Repository: Wohlstand/TheXTech
Branch: main
Commit: f98b95e99525
Files: 899
Total size: 10.9 MB

Directory structure:
gitextract_aj92w71a/

├── .appveyor.yml
├── .gitattributes
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug-report.yml
│   │   └── compile-fail-report.yml
│   ├── ci-helper/
│   │   ├── .gitignore
│   │   ├── create-dmg.sh
│   │   ├── pack-game-macos.sh
│   │   ├── pack-game.sh
│   │   ├── support/
│   │   │   ├── dmg-license.py
│   │   │   ├── dmg-license3.py
│   │   │   └── template.applescript
│   │   ├── translate_patcher.py
│   │   ├── translate_sync_assets.sh
│   │   ├── translate_sync_to_stable.sh
│   │   └── translate_update.sh
│   └── workflows/
│       ├── 16m-ci.yml
│       ├── 3ds-ci.yml
│       ├── android-ci.yml
│       ├── android-fdroid-ci.yml
│       ├── blocksds-ci.yml
│       ├── emscripten.yml
│       ├── flatpak.yml
│       ├── homebrew-assets-ci.yml
│       ├── macos-ci.yml
│       ├── portmaster-ci.yml
│       ├── regression-testing-ci.yaml
│       ├── switch-ci.yml
│       ├── sync-langs.yml
│       ├── ubuntu-deb-ci.yml
│       ├── ubuntu-tar-ci.yml
│       ├── vita-ci.yml
│       ├── wii-ci.yml
│       ├── wiiu-ci.yml
│       └── windows-ci.yml
├── .gitignore
├── .gitmodules
├── CMakeLists.txt
├── CONTRIBUTING.md
├── LICENSE
├── PORTING.md
├── README.ESP.md
├── README.RUS.md
├── README.md
├── android-project/
│   ├── .gitignore
│   ├── build.gradle
│   ├── build_init.sh
│   ├── gradle/
│   │   └── wrapper/
│   │       ├── gradle-wrapper.jar
│   │       └── gradle-wrapper.properties
│   ├── gradle.properties
│   ├── gradlew
│   ├── gradlew.bat
│   ├── settings.gradle
│   └── thextech/
│       ├── build.gradle
│       ├── icon/
│       │   ├── debug/
│       │   │   ├── mipmap-anydpi-v26/
│       │   │   │   ├── ic_launcher.xml
│       │   │   │   └── ic_launcher_round.xml
│       │   │   └── values/
│       │   │       └── ic_launcher_background.xml
│       │   ├── devel/
│       │   │   ├── mipmap-anydpi-v26/
│       │   │   │   ├── ic_launcher.xml
│       │   │   │   └── ic_launcher_round.xml
│       │   │   └── values/
│       │   │       └── ic_launcher_background.xml
│       │   └── main/
│       │       ├── mipmap-anydpi-v26/
│       │       │   ├── ic_launcher.xml
│       │       │   └── ic_launcher_round.xml
│       │       └── values/
│       │           └── ic_launcher_background.xml
│       ├── proguard-rules.pro
│       └── src/
│           └── main/
│               ├── AndroidManifest.xml
│               ├── assets/
│               │   └── buttons/
│               │       └── Credits.txt
│               ├── generate_patternPath.sh
│               ├── java/
│               │   ├── javautil/
│               │   │   ├── FileUtils.java
│               │   │   └── README.md
│               │   ├── org/
│               │   │   └── libsdl/
│               │   │       └── app/
│               │   │           ├── HIDDevice.java
│               │   │           ├── HIDDeviceBLESteamController.java
│               │   │           ├── HIDDeviceManager.java
│               │   │           ├── HIDDeviceUSB.java
│               │   │           ├── SDL.java
│               │   │           ├── SDLActivity.java
│               │   │           ├── SDLAudioManager.java
│               │   │           ├── SDLControllerManager.java
│               │   │           └── SDLSurface.java
│               │   └── ru/
│               │       └── wohlsoft/
│               │           └── thextech/
│               │               ├── GameSettings.java
│               │               ├── IniFile.java
│               │               ├── Launcher.java
│               │               ├── OpenFileDialog.java
│               │               ├── UIUpdater.java
│               │               └── thextechActivity.java
│               └── res/
│                   ├── layout/
│                   │   ├── activity_launcher.xml
│                   │   └── settings_activity.xml
│                   ├── values/
│                   │   ├── arrays.xml
│                   │   ├── colors.xml
│                   │   ├── strings.xml
│                   │   └── styles.xml
│                   ├── values-bg/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-de/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-es-rES/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-fr/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-hu/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-it/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-ja/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-ko/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-nb-rNO/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-pl/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-pt/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-pt-rBR/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-ru-rRU/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-ta/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-tr/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-uk/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-zh-rCN/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   ├── values-zh-rTW/
│                   │   ├── arrays.xml
│                   │   └── strings.xml
│                   └── xml/
│                       └── root_preferences.xml
├── changelog.txt
├── cmake/
│   ├── TargetArch.cmake
│   ├── build_props.cmake
│   ├── ci_linux_gcc_toolchain_arm64.cmake
│   ├── ci_linux_gcc_toolchain_armhf.cmake
│   ├── ci_linux_gcc_toolchain_x32.cmake
│   ├── ci_windows_mingw_toolchain_x32.cmake
│   ├── ci_windows_mingw_toolchain_x64.cmake
│   ├── ci_windows_msvc_toolchain_arm64.cmake
│   ├── deploy.cmake
│   ├── git_info.cmake
│   ├── git_version.cmake
│   ├── git_version_update.cmake
│   ├── icon.desktop.in
│   ├── library_FreeImage.cmake
│   ├── library_FreeType.cmake
│   ├── library_HarfBuzz.cmake
│   ├── library_SDLMixerX.cmake
│   ├── library_discord_rpc.cmake
│   ├── library_glew.cmake
│   ├── library_luabind.cmake
│   ├── library_luajit.cmake
│   ├── library_syslibs.cmake
│   ├── library_zlib.cmake
│   ├── ndk-stl-config.cmake
│   ├── overlays-16m.ld
│   ├── package_switch.cmake
│   ├── package_vita.cmake
│   └── vita_buildprops.cmake
├── debian/
│   ├── changelog
│   ├── control
│   ├── copyright
│   └── rules
├── docs/
│   ├── README_3DS.md
│   ├── README_DSI.md
│   ├── README_SWITCH.md
│   ├── README_VITA.ESP.md
│   ├── README_VITA.RUS.md
│   ├── README_VITA.md
│   ├── README_WII.md
│   ├── README_WIIU.md
│   └── editor.ini
├── fastlane/
│   └── metadata/
│       └── android/
│           ├── en-GB/
│           │   ├── changelogs/
│           │   │   ├── 1030700.txt
│           │   │   └── 1030701.txt
│           │   ├── full_description.txt
│           │   ├── short_description.txt
│           │   └── title.txt
│           └── ru/
│               ├── full_description.txt
│               └── short_description.txt
├── lib/
│   ├── Allocator/
│   │   ├── Allocator.h
│   │   ├── LICENSE
│   │   ├── LinearAllocator.cpp
│   │   ├── LinearAllocator.h
│   │   ├── PoolAllocator.cpp
│   │   ├── PoolAllocator.h
│   │   ├── README.md
│   │   ├── StackLinkedList.h
│   │   ├── StackLinkedListImpl.h
│   │   ├── Utils.h
│   │   ├── linear-allocator.cmake
│   │   └── pool-allocator.cmake
│   ├── AppPath/
│   │   ├── app_path.cmake
│   │   ├── app_path.h
│   │   └── private/
│   │       ├── app_path.cpp
│   │       ├── app_path_16m.cpp
│   │       ├── app_path_3ds.cpp
│   │       ├── app_path_android.cpp
│   │       ├── app_path_emscripten.cpp
│   │       ├── app_path_macos.cpp
│   │       ├── app_path_macos_dirs.h
│   │       ├── app_path_macos_dirs.m
│   │       ├── app_path_old.cpp
│   │       ├── app_path_private.h
│   │       ├── app_path_skeleton.cpp
│   │       ├── app_path_switch.cpp
│   │       ├── app_path_unix.cpp
│   │       ├── app_path_vita.cpp
│   │       ├── app_path_wii.cpp
│   │       ├── app_path_wiiu.cpp
│   │       └── app_path_win32.cpp
│   ├── Archives/
│   │   ├── archives.h
│   │   ├── archives_dir.cpp
│   │   ├── archives_mount.cpp
│   │   ├── archives_priv.h
│   │   └── archives_rwops.cpp
│   ├── CrashHandler/
│   │   ├── StackWalker/
│   │   │   ├── StackWalker.cmake
│   │   │   ├── StackWalker.cpp
│   │   │   └── StackWalker.h
│   │   ├── backtrace.h.in
│   │   ├── crash_handler.cpp
│   │   └── crash_handler.h
│   ├── FixPointCS/
│   │   ├── Fixed64.h
│   │   └── FixedUtil.h
│   ├── Graphics/
│   │   ├── PGEString.h
│   │   ├── bitmask2rgba.c
│   │   ├── bitmask2rgba.cmake
│   │   ├── bitmask2rgba.h
│   │   ├── graphics_funcs.cpp
│   │   ├── graphics_funcs.h
│   │   ├── image_size.cpp
│   │   ├── image_size.h
│   │   ├── size.cpp
│   │   ├── size.h
│   │   └── xt_qoi.cpp
│   ├── Integrator/
│   │   ├── int_discorcrpc.cpp
│   │   ├── int_discorcrpc.h
│   │   ├── integrator.cpp
│   │   └── integrator.h
│   ├── InterProcess/
│   │   ├── editor_pipe.cpp
│   │   ├── editor_pipe.h
│   │   ├── intproc.cpp
│   │   └── intproc.h
│   ├── Logger/
│   │   ├── logger.cmake
│   │   ├── logger.h
│   │   ├── logger_level.h
│   │   └── private/
│   │       ├── logger.cpp
│   │       ├── logger_android.cpp
│   │       ├── logger_desktop.cpp
│   │       ├── logger_dummy.cpp
│   │       ├── logger_emscripten.cpp
│   │       ├── logger_min.cpp
│   │       ├── logger_private.h
│   │       ├── logger_sets.h
│   │       ├── logger_vita.cpp
│   │       └── logger_wiiu.cpp
│   ├── Utf8Main/
│   │   ├── utf8main.cmake
│   │   ├── utf8main.h
│   │   └── utf8main_win32.cpp
│   ├── Utils/
│   │   ├── Utils.cmake
│   │   ├── UtilsSDL.cmake
│   │   ├── dir_list_ci.cpp
│   │   ├── dir_list_ci.h
│   │   ├── elapsed_timer.cpp
│   │   ├── elapsed_timer.h
│   │   ├── files.cpp
│   │   ├── files.h
│   │   ├── files_ini.h
│   │   ├── openUrl.cmake
│   │   ├── open_url.cpp
│   │   ├── open_url.h
│   │   ├── strings.cpp
│   │   ├── strings.h
│   │   └── vptrlist.h
│   ├── fixed_point.cpp
│   ├── fixed_point.h
│   ├── floating_point.cpp
│   ├── floating_point.h
│   ├── fmt/
│   │   ├── CMakeLists.txt
│   │   ├── CONTRIBUTING.rst
│   │   ├── LICENSE.rst
│   │   ├── README.rst
│   │   ├── README.txt
│   │   ├── fmt.cmake
│   │   ├── fmt_container.h
│   │   ├── fmt_format.cpp
│   │   ├── fmt_format.h
│   │   ├── fmt_ostream.cpp
│   │   ├── fmt_ostream.h
│   │   ├── fmt_posix.cpp
│   │   ├── fmt_posix.h
│   │   ├── fmt_printf.cpp
│   │   ├── fmt_printf.h
│   │   ├── fmt_qformat.h
│   │   ├── fmt_string.h
│   │   ├── fmt_time.h
│   │   ├── orig/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── container.h
│   │   │   ├── format.cc
│   │   │   ├── format.h
│   │   │   ├── ostream.cc
│   │   │   ├── ostream.h
│   │   │   ├── posix.cc
│   │   │   ├── posix.h
│   │   │   ├── printf.cc
│   │   │   ├── printf.h
│   │   │   ├── string.h
│   │   │   └── time.h
│   │   └── update.sh
│   ├── fmt_format_ne.h
│   ├── fmt_impl.cpp
│   ├── fmt_time_ne.h
│   ├── forced_int.h
│   ├── gif.h
│   ├── gif_writer.h
│   ├── json/
│   │   ├── LICENSE.MIT
│   │   ├── README.md
│   │   ├── json.hpp
│   │   └── json_rwops_input.hpp
│   ├── md5/
│   │   ├── LICENSE
│   │   ├── README
│   │   ├── md5.cmake
│   │   ├── md5.cpp
│   │   ├── md5.h
│   │   ├── md5_loc.h
│   │   ├── md5tools.cpp
│   │   └── md5tools.hpp
│   ├── numeric_types.h
│   ├── pcg/
│   │   ├── LICENSE.txt
│   │   ├── README.md
│   │   ├── pcg_extras.hpp
│   │   ├── pcg_random.hpp
│   │   └── pcg_uint128.hpp
│   ├── pge_cpu_arch.h
│   ├── pge_delay.h
│   ├── pge_tonearest.h
│   ├── pge_video_rec/
│   │   ├── pge-video-rec.cmake
│   │   ├── pge_record_gif.cpp
│   │   ├── pge_record_vp8.cpp
│   │   ├── pge_video_rec.h
│   │   └── pge_video_sink.cpp
│   ├── sdl_proxy/
│   │   ├── 16m/
│   │   │   └── std_16m.cpp
│   │   ├── 3ds/
│   │   │   ├── 3ds-audio-lib.cpp
│   │   │   ├── 3ds-audio-lib.h
│   │   │   ├── mixer_3ds.cpp
│   │   │   └── std_3ds.cpp
│   │   ├── _trash/
│   │   │   ├── mixer_mixerx.cpp
│   │   │   ├── sdl_assert.h
│   │   │   ├── sdl_atomic.h
│   │   │   ├── sdl_head.h
│   │   │   ├── sdl_stdinc.h
│   │   │   └── sdl_timer.h
│   │   ├── base/
│   │   │   └── std_base.cpp
│   │   ├── mixer.h
│   │   ├── null/
│   │   │   ├── mixer_null.cpp
│   │   │   ├── sdl_null.h
│   │   │   └── std_null.cpp
│   │   ├── sdl_assert.h
│   │   ├── sdl_atomic.h
│   │   ├── sdl_audio.h
│   │   ├── sdl_common.h
│   │   ├── sdl_filesystem.h
│   │   ├── sdl_head.h
│   │   ├── sdl_proxy.cmake
│   │   ├── sdl_stdinc.h
│   │   ├── sdl_timer.h
│   │   ├── sdl_types.h
│   │   └── wii/
│   │       └── std_wii.cpp
│   ├── sdl_proxy_rwops/
│   │   ├── CMakeLists.txt
│   │   ├── include/
│   │   │   └── SDL2/
│   │   │       ├── SDL_rwops.h
│   │   │       └── _priv_rwops_funcs.h
│   │   ├── sdl_proxy_rwops.c
│   │   └── sdl_proxy_rwops_file.c
│   ├── sorting/
│   │   ├── pdqsort.h
│   │   └── tinysort.h
│   ├── tclap/
│   │   ├── Arg.h
│   │   ├── ArgContainer.h
│   │   ├── ArgException.h
│   │   ├── ArgGroup.h
│   │   ├── ArgTraits.h
│   │   ├── CmdLine.h
│   │   ├── CmdLineInterface.h
│   │   ├── CmdLineOutput.h
│   │   ├── Constraint.h
│   │   ├── DeferDelete.h
│   │   ├── DocBookOutput.h
│   │   ├── HelpVisitor.h
│   │   ├── IgnoreRestVisitor.h
│   │   ├── MultiArg.h
│   │   ├── MultiSwitchArg.h
│   │   ├── OptionalUnlabeledTracker.h
│   │   ├── README
│   │   ├── StandardTraits.h
│   │   ├── StdOutput.h
│   │   ├── SwitchArg.h
│   │   ├── UnlabeledMultiArg.h
│   │   ├── UnlabeledValueArg.h
│   │   ├── ValueArg.h
│   │   ├── ValuesConstraint.h
│   │   ├── VersionVisitor.h
│   │   ├── Visitor.h
│   │   ├── sstream.h
│   │   └── tclap.cmake
│   ├── util.cpp
│   └── util.h
├── pge_version.h
├── repo.sh
├── resources/
│   ├── PkgInfo
│   ├── _concepts/
│   │   ├── tv-banner-label.xcf
│   │   └── tv-banner.xcf
│   ├── _dev_scripts/
│   │   ├── snd_id_2_enum.sh
│   │   ├── snd_id_sed.sh
│   │   └── xserver.py
│   ├── emscripten/
│   │   ├── manifest.json.in
│   │   ├── shell_minimal.html
│   │   └── sw.js.in
│   ├── file_icons/
│   │   ├── file_lvl.icns
│   │   ├── file_lvlx.icns
│   │   ├── file_wld.icns
│   │   └── file_wldx.icns
│   ├── flatpak/
│   │   ├── appdata.xml.in
│   │   └── build.yml
│   ├── haiku/
│   │   ├── PackageInfo.in
│   │   ├── icon.hvif
│   │   └── icon.rdef
│   ├── icon/
│   │   ├── make_icns.sh
│   │   └── make_icns_linux.sh
│   ├── icon_dev_android/
│   │   └── thextech_512.xcf
│   ├── languages/
│   │   ├── assets_bg.json
│   │   ├── assets_de.json
│   │   ├── assets_en.json
│   │   ├── assets_es.json
│   │   ├── assets_fr.json
│   │   ├── assets_hu.json
│   │   ├── assets_it.json
│   │   ├── assets_ja.json
│   │   ├── assets_ko.json
│   │   ├── assets_nb-no.json
│   │   ├── assets_pl.json
│   │   ├── assets_pt-br.json
│   │   ├── assets_pt.json
│   │   ├── assets_ru.json
│   │   ├── assets_ta.json
│   │   ├── assets_tr.json
│   │   ├── assets_uk.json
│   │   ├── assets_zh-cn.json
│   │   ├── assets_zh-tw.json
│   │   ├── thextech_bg.json
│   │   ├── thextech_de.json
│   │   ├── thextech_en.json
│   │   ├── thextech_es.json
│   │   ├── thextech_fr.json
│   │   ├── thextech_hu.json
│   │   ├── thextech_it.json
│   │   ├── thextech_ja.json
│   │   ├── thextech_ko.json
│   │   ├── thextech_nb-no.json
│   │   ├── thextech_pl.json
│   │   ├── thextech_pt-br.json
│   │   ├── thextech_pt.json
│   │   ├── thextech_ru.json
│   │   ├── thextech_ta.json
│   │   ├── thextech_tr.json
│   │   ├── thextech_uk.json
│   │   ├── thextech_zh-cn.json
│   │   └── thextech_zh-tw.json
│   ├── switch/
│   │   ├── Important.txt
│   │   └── thextech-logo.xcf
│   ├── thextech.icns
│   ├── thextech.plist.in
│   ├── thextech.plist.tiger.in
│   ├── thextech.rc
│   ├── tiger/
│   │   ├── TheXTechRun.in
│   │   └── thextech.icns
│   ├── vita/
│   │   ├── frag.cgf
│   │   ├── sce_sys/
│   │   │   └── livearea/
│   │   │       └── contents/
│   │   │           └── template.xml.in
│   │   └── vert.cgv
│   ├── wii/
│   │   ├── icon.xcf
│   │   └── meta.xml.in
│   └── wiiu/
│       ├── icon.xcf
│       └── meta.xml.in
├── script/
│   ├── CMakeLists.txt
│   ├── include/
│   │   └── xtech_lua_main.h
│   └── src/
│       └── xtech_lua_main.cpp
├── src/
│   ├── blk_id.h
│   ├── blocks.cpp
│   ├── blocks.h
│   ├── capabilities.cpp
│   ├── capabilities.h
│   ├── change_res.cpp
│   ├── change_res.h
│   ├── cmd_line_setup.h
│   ├── collision.cpp
│   ├── collision.h
│   ├── compat.cpp
│   ├── compat.h
│   ├── config/
│   │   ├── config_base.cpp
│   │   ├── config_base.hpp
│   │   ├── config_hooks.cpp
│   │   ├── config_hooks.h
│   │   ├── config_impl.hpp
│   │   ├── config_legacy_compat.cpp
│   │   └── config_main.cpp
│   ├── config.h
│   ├── control/
│   │   ├── con_control.h
│   │   ├── controls.cpp
│   │   ├── controls_methods.h
│   │   ├── controls_strings.h
│   │   ├── duplicate.cpp
│   │   ├── duplicate.h
│   │   ├── input_16m.cpp
│   │   ├── input_16m.h
│   │   ├── input_3ds.cpp
│   │   ├── input_3ds.h
│   │   ├── input_wii.cpp
│   │   ├── input_wii.h
│   │   ├── input_wii_gc.cpp
│   │   ├── input_wii_gc.h
│   │   ├── joystick.cpp
│   │   ├── joystick.h
│   │   ├── keyboard.cpp
│   │   ├── keyboard.h
│   │   ├── touchscreen.cpp
│   │   ├── touchscreen.h
│   │   └── touchscreen.txt
│   ├── control_types.h
│   ├── controls.h
│   ├── custom.cpp
│   ├── custom.h
│   ├── draw_planes.h
│   ├── editor/
│   │   ├── editor.cpp
│   │   ├── editor_custom.cpp
│   │   ├── editor_custom.h
│   │   ├── editor_strings.cpp
│   │   ├── editor_strings.h
│   │   ├── magic_block.cpp
│   │   ├── magic_block.h
│   │   ├── new_editor.cpp
│   │   ├── new_editor.h
│   │   ├── write_common.cpp
│   │   ├── write_common.h
│   │   ├── write_level.cpp
│   │   ├── write_level.h
│   │   ├── write_world.cpp
│   │   └── write_world.h
│   ├── editor.h
│   ├── eff_id.h
│   ├── effect.cpp
│   ├── effect.h
│   ├── fontman/
│   │   ├── crop_info.h
│   │   ├── font_engine_base.h
│   │   ├── font_manager.cpp
│   │   ├── font_manager.h
│   │   ├── font_manager_private.cpp
│   │   ├── font_manager_private.h
│   │   ├── hardcoded_font.cpp
│   │   ├── hardcoded_font.h
│   │   ├── legacy_font.cpp
│   │   ├── legacy_font.h
│   │   ├── raster_font.cpp
│   │   ├── raster_font.h
│   │   ├── ttf_font.cpp
│   │   ├── ttf_font.h
│   │   └── utf8_helpers.cpp
│   ├── frame_timer.cpp
│   ├── frame_timer.h
│   ├── frm_main.cpp
│   ├── frm_main.h
│   ├── game_main.cpp
│   ├── game_main.h
│   ├── gfx.cpp
│   ├── gfx.h
│   ├── global_constants.h
│   ├── global_dirs.cpp
│   ├── global_dirs.h
│   ├── global_strings.cpp
│   ├── global_strings.h
│   ├── globals.cpp
│   ├── globals.h
│   ├── graphics/
│   │   ├── gfx_background.cpp
│   │   ├── gfx_camera.cpp
│   │   ├── gfx_camera.h
│   │   ├── gfx_credits.cpp
│   │   ├── gfx_draw_player.cpp
│   │   ├── gfx_editor.cpp
│   │   ├── gfx_enter_screen.cpp
│   │   ├── gfx_frame.cpp
│   │   ├── gfx_frame.h
│   │   ├── gfx_hud.cpp
│   │   ├── gfx_keyhole.cpp
│   │   ├── gfx_keyhole.h
│   │   ├── gfx_marquee.cpp
│   │   ├── gfx_marquee.h
│   │   ├── gfx_message.cpp
│   │   ├── gfx_print.cpp
│   │   ├── gfx_screen.cpp
│   │   ├── gfx_special_frames.cpp
│   │   ├── gfx_special_frames.h
│   │   ├── gfx_update.cpp
│   │   ├── gfx_update.h
│   │   ├── gfx_update2.cpp
│   │   ├── gfx_world.cpp
│   │   └── gfx_world.h
│   ├── graphics.cpp
│   ├── graphics.h
│   ├── layers.cpp
│   ├── layers.h
│   ├── load_gfx.cpp
│   ├── load_gfx.h
│   ├── location.h
│   ├── logic/
│   │   ├── object_graph.cpp
│   │   └── object_graph.h
│   ├── main/
│   │   ├── asset_pack.cpp
│   │   ├── asset_pack.h
│   │   ├── block_table.cpp
│   │   ├── block_table.h
│   │   ├── block_table.hpp
│   │   ├── cheat_code.cpp
│   │   ├── cheat_code.h
│   │   ├── client.cpp
│   │   ├── client.h
│   │   ├── client_methods.cpp
│   │   ├── client_methods.h
│   │   ├── game_globals.h
│   │   ├── game_info.cpp
│   │   ├── game_info.h
│   │   ├── game_loop.cpp
│   │   ├── game_loop_interrupt.h
│   │   ├── game_save.cpp
│   │   ├── game_strings.cpp
│   │   ├── game_strings.h
│   │   ├── gameplay_timer.cpp
│   │   ├── gameplay_timer.h
│   │   ├── hints.cpp
│   │   ├── hints.h
│   │   ├── level_file.cpp
│   │   ├── level_file.h
│   │   ├── level_medals.cpp
│   │   ├── level_medals.h
│   │   ├── level_save_info.cpp
│   │   ├── level_save_info.h
│   │   ├── main_config.cpp
│   │   ├── menu_controls.cpp
│   │   ├── menu_controls.h
│   │   ├── menu_loop.cpp
│   │   ├── menu_main.cpp
│   │   ├── menu_main.h
│   │   ├── outro_loop.cpp
│   │   ├── outro_loop.h
│   │   ├── player_frames.cpp
│   │   ├── record.cpp
│   │   ├── record.h
│   │   ├── screen_asset_pack.cpp
│   │   ├── screen_asset_pack.h
│   │   ├── screen_connect.cpp
│   │   ├── screen_connect.h
│   │   ├── screen_content.cpp
│   │   ├── screen_content.h
│   │   ├── screen_options.cpp
│   │   ├── screen_options.h
│   │   ├── screen_pause.cpp
│   │   ├── screen_pause.h
│   │   ├── screen_progress.cpp
│   │   ├── screen_progress.h
│   │   ├── screen_prompt.cpp
│   │   ├── screen_prompt.h
│   │   ├── screen_quickreconnect.cpp
│   │   ├── screen_quickreconnect.h
│   │   ├── screen_textentry.cpp
│   │   ├── screen_textentry.h
│   │   ├── setup_physics.cpp
│   │   ├── setup_vars.cpp
│   │   ├── speedrunner.cpp
│   │   ├── speedrunner.h
│   │   ├── translate/
│   │   │   ├── tr_level.h
│   │   │   ├── tr_script.h
│   │   │   ├── tr_title.h
│   │   │   └── tr_world.h
│   │   ├── translate.cpp
│   │   ├── translate.h
│   │   ├── translate_episode.cpp
│   │   ├── translate_episode.h
│   │   ├── trees.cpp
│   │   ├── trees.h
│   │   ├── world_file.cpp
│   │   ├── world_file.h
│   │   ├── world_globals.h
│   │   └── world_loop.cpp
│   ├── main.cpp
│   ├── message.cpp
│   ├── message.h
│   ├── npc/
│   │   ├── npc_activation.cpp
│   │   ├── npc_activation.h
│   │   ├── npc_bonus.cpp
│   │   ├── npc_cockpit_bits.h
│   │   ├── npc_frames.cpp
│   │   ├── npc_hit.cpp
│   │   ├── npc_kill.cpp
│   │   ├── npc_queues.cpp
│   │   ├── npc_queues.h
│   │   ├── npc_update/
│   │   │   ├── npc_block_logic.cpp
│   │   │   ├── npc_collide.cpp
│   │   │   ├── npc_effects.cpp
│   │   │   ├── npc_generator.cpp
│   │   │   ├── npc_movement_logic.cpp
│   │   │   ├── npc_special_maybe_held.cpp
│   │   │   ├── npc_update_priv.h
│   │   │   └── npc_walking_logic.cpp
│   │   ├── npc_update.cpp
│   │   ├── safe_set.hpp
│   │   ├── section_overlap.cpp
│   │   └── section_overlap.h
│   ├── npc.cpp
│   ├── npc.h
│   ├── npc_constant_traits.h
│   ├── npc_effect.h
│   ├── npc_id.h
│   ├── npc_special_data.h
│   ├── npc_traits.h
│   ├── phys_env.cpp
│   ├── phys_env.h
│   ├── phys_id.h
│   ├── pinched_info.h
│   ├── player/
│   │   ├── player_action_logic.cpp
│   │   ├── player_block_logic.cpp
│   │   ├── player_char5_logic.cpp
│   │   ├── player_death_logic.cpp
│   │   ├── player_effect.h
│   │   ├── player_fairy_logic.cpp
│   │   ├── player_movement_logic.cpp
│   │   ├── player_npc_logic.cpp
│   │   ├── player_pinched_logic.cpp
│   │   ├── player_screen_logic.cpp
│   │   ├── player_update.cpp
│   │   ├── player_update_priv.h
│   │   ├── player_vehicle_logic.cpp
│   │   ├── player_vine_logic.cpp
│   │   └── player_warp_logic.cpp
│   ├── player.cpp
│   ├── player.h
│   ├── pseudo_vb.h
│   ├── rand.cpp
│   ├── rand.h
│   ├── range_arr.hpp
│   ├── ref_type.h
│   ├── saved_layers.cpp
│   ├── saved_layers.h
│   ├── screen.cpp
│   ├── screen.h
│   ├── screen_fader.cpp
│   ├── screen_fader.h
│   ├── script/
│   │   ├── luau/
│   │   │   ├── test.cpp
│   │   │   └── test.h
│   │   ├── luna/
│   │   │   ├── autocode.cpp
│   │   │   ├── autocode.h
│   │   │   ├── autocode_manager.cpp
│   │   │   ├── autocode_manager.h
│   │   │   ├── csprite.cpp
│   │   │   ├── csprite.h
│   │   │   ├── hitbox.cpp
│   │   │   ├── hitbox.h
│   │   │   ├── levels/
│   │   │   │   ├── Docopoper-AbstractAssault.cpp
│   │   │   │   ├── Docopoper-AbstractAssault.h
│   │   │   │   ├── Docopoper-Calleoca.cpp
│   │   │   │   ├── Docopoper-Calleoca.h
│   │   │   │   ├── Docopoper-TheFloorisLava.cpp
│   │   │   │   ├── Docopoper-TheFloorisLava.h
│   │   │   │   ├── KilArmoryCode.cpp
│   │   │   │   ├── KilArmoryCode.h
│   │   │   │   ├── README.txt
│   │   │   │   ├── SAJewers-QraestoliaCaverns.cpp
│   │   │   │   ├── SAJewers-QraestoliaCaverns.h
│   │   │   │   ├── SAJewers-Snowboardin.cpp
│   │   │   │   ├── SAJewers-Snowboardin.h
│   │   │   │   ├── Talkhaus-Science_Final_Battle.cpp
│   │   │   │   └── Talkhaus-Science_Final_Battle.h
│   │   │   ├── luna.cpp
│   │   │   ├── luna.h
│   │   │   ├── lunablock.cpp
│   │   │   ├── lunablock.h
│   │   │   ├── lunacounter.cpp
│   │   │   ├── lunacounter.h
│   │   │   ├── lunacounter_record.cpp
│   │   │   ├── lunacounter_record.h
│   │   │   ├── lunacounter_util.h
│   │   │   ├── lunadefs.h
│   │   │   ├── lunaglobals.cpp
│   │   │   ├── lunaimgbox.cpp
│   │   │   ├── lunaimgbox.h
│   │   │   ├── lunainput.cpp
│   │   │   ├── lunainput.h
│   │   │   ├── lunalayer.cpp
│   │   │   ├── lunalayer.h
│   │   │   ├── lunalevel.cpp
│   │   │   ├── lunalevel.h
│   │   │   ├── lunalevels.cpp
│   │   │   ├── lunalevels.h
│   │   │   ├── lunamisc.cpp
│   │   │   ├── lunamisc.h
│   │   │   ├── lunanpc.cpp
│   │   │   ├── lunanpc.h
│   │   │   ├── lunaplayer.cpp
│   │   │   ├── lunaplayer.h
│   │   │   ├── lunarender.cpp
│   │   │   ├── lunarender.h
│   │   │   ├── lunaspriteman.cpp
│   │   │   ├── lunaspriteman.h
│   │   │   ├── lunavarbank.cpp
│   │   │   ├── lunavarbank.h
│   │   │   ├── mememu.cpp
│   │   │   ├── mememu.h
│   │   │   ├── renderop.h
│   │   │   ├── renderop_bitmap.cpp
│   │   │   ├── renderop_bitmap.h
│   │   │   ├── renderop_effect.cpp
│   │   │   ├── renderop_effect.h
│   │   │   ├── renderop_rect.cpp
│   │   │   ├── renderop_rect.h
│   │   │   ├── renderop_string.cpp
│   │   │   ├── renderop_string.h
│   │   │   ├── sprite_component.cpp
│   │   │   ├── sprite_component.h
│   │   │   ├── sprite_funcs.cpp
│   │   │   └── sprite_funcs.h
│   │   ├── msg_macros.cpp
│   │   ├── msg_macros.h
│   │   ├── msg_preprocessor.cpp
│   │   └── msg_preprocessor.h
│   ├── sorting.cpp
│   ├── sorting.h
│   ├── sound/
│   │   ├── fx/
│   │   │   ├── fx_common.hpp
│   │   │   ├── fx_format.h
│   │   │   ├── reverb.cpp
│   │   │   ├── reverb.h
│   │   │   ├── spc_echo.cpp
│   │   │   └── spc_echo.h
│   │   ├── snd-src/
│   │   │   ├── message.mid
│   │   │   └── sm-glass.mid
│   │   ├── sound_msgsnd.cpp
│   │   └── sound_msgsnd.h
│   ├── sound.cpp
│   ├── sound.h
│   ├── sound_spatial.cpp
│   ├── sound_thread.cpp
│   ├── sound_thread.h
│   ├── std_picture.cpp
│   ├── std_picture.h
│   ├── video.h
│   └── xt_color.h
├── test/
│   ├── CI-tests.py
│   ├── CMakeLists.txt
│   ├── common/
│   │   ├── catch_amalgamated.cpp
│   │   └── catch_amalgamated.hpp
│   ├── levels/
│   │   ├── Beech kick 1.lvl
│   │   ├── Beech kick 2.lvl
│   │   ├── Conveyor hell.lvl
│   │   ├── Exits test.lvl
│   │   ├── Fall test.lvl
│   │   ├── Fence climb Move.lvl
│   │   ├── Fence climb.lvl
│   │   ├── Player clip - min.lvl
│   │   ├── Player clip.lvl
│   │   ├── Player through block.lvl
│   │   ├── Pockey test.lvl
│   │   ├── Raft ride.lvl
│   │   ├── Shelf surf.lvl
│   │   ├── Shell on spring.lvl
│   │   ├── Skull raft 2.lvl
│   │   ├── Slope test.lvl
│   │   ├── Veggies shoot.lvl
│   │   ├── compat.ini
│   │   └── doors test.lvl
│   ├── test_msg_macro/
│   │   ├── CMakeLists.txt
│   │   └── test_msg_macro.cpp
│   └── worlds/
│       └── speedrun-unit-test/
│           ├── unit-test.lvlx
│           └── unit-test.wldx
├── utils/
│   ├── convertkit/
│   │   ├── GIFs2PNG/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── _resources/
│   │   │   │   ├── cat_gif2png/
│   │   │   │   │   └── make_icns.sh
│   │   │   │   ├── cat_gif2png.icns
│   │   │   │   ├── gifs2png.qrc
│   │   │   │   └── gifs2png.rc
│   │   │   ├── common_features/
│   │   │   │   ├── config_manager.cpp
│   │   │   │   └── config_manager.h
│   │   │   ├── gifs2png.cpp
│   │   │   ├── version.cmake
│   │   │   └── version.h
│   │   ├── assets-convert-homebrew.py
│   │   ├── audio_convert_16m.py
│   │   ├── convert_plr.py
│   │   ├── dist/
│   │   │   ├── gameinfo.ini
│   │   │   ├── gfx-convert-lin.sh
│   │   │   ├── gfx-convert-win.cmd
│   │   │   ├── music.ini
│   │   │   ├── sounds.ini
│   │   │   └── thextech.ini
│   │   ├── exe2ui/
│   │   │   ├── exe2ui.c
│   │   │   └── exe2ui_build.sh
│   │   ├── gfx-convert-16m.py
│   │   ├── gfx-convert-3ds.py
│   │   └── gfx-convert-wii.py
│   ├── submodule-update.sh
│   └── update-copyright.sh
├── version.cmake
└── version.h

================================================
FILE CONTENTS
================================================

================================================
FILE: .appveyor.yml
================================================
version: build-{build}

environment:
  global:
    PLATFORMTOOLSET: "v140"
    CMAKEPREFIXPATH: "."
    SEVENZIP: "C:\\Program Files\\7-Zip\\7z.exe"
    WGET_BIN: "C:\\msys64\\usr\\bin\\wget.exe"
    APPVEYOR_BUILD_WORKER_IMAGE: "Visual Studio 2015"
  matrix:
    - BUILD_TYPE: MinSizeRel
      COMPILER: MinGW-w32
      COMPILER_FAMILY: MinGW
      GENERATOR: "MinGW Makefiles"
      PLATFORM: Win32
      CMAKEPREFIXPATH: "C:/Qt/Tools/mingw730_32"
      TOOLCHAIN_BIN: "C:\\Qt\\Tools\\mingw730_32\\bin"
    - BUILD_TYPE: MinSizeRel
      COMPILER: MinGW-w64
      COMPILER_FAMILY: MinGW
      GENERATOR: "MinGW Makefiles"
      PLATFORM: x64
      CMAKEPREFIXPATH: "C:/Qt/Tools/mingw730_64"
      TOOLCHAIN_BIN: "C:\\Qt\\Tools\\mingw730_64\\bin"

build_script:
  - git submodule init
  - git submodule update
  - md b
  - cd b
  - if NOT [%TOOLCHAIN_BIN%]==[] set PATH=%TOOLCHAIN_BIN%;%PATH:C:\Program Files\Git\usr\bin;=%
  - cmake -G "%GENERATOR%" -DCPACK_PACKAGE_FILE_NAME=thextech-%APPVEYOR_REPO_BRANCH%-%COMPILER%-%BUILD_TYPE%-%PLATFORM% -DCMAKE_BUILD_TYPE=%BUILD_TYPE% -DCMAKE_PREFIX_PATH=%CMAKEPREFIXPATH% ..
  - cmake --build . --config %BUILD_TYPE% -- -j 2
  - cpack ..
  - appveyor PushArtifact "thextech-%APPVEYOR_REPO_BRANCH%-%COMPILER%-%BUILD_TYPE%-%PLATFORM%.7z"

deploy:
  - provider: Environment
    name: WohlnetFTP

#on_finish:
#  - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))



================================================
FILE: .gitattributes
================================================
changelog.txt       text eol=crlf
LICENSE             text eol=crlf
README.md           text eol=crlf
*.lvl               text eol=crlf
*.wld               text eol=crlf
*.lvlx              text eol=lf
*.wldx              text eol=lf


================================================
FILE: .github/ISSUE_TEMPLATE/bug-report.yml
================================================
name: Bug Report
description: Create a report of the issue ocurred with the game during its use
labels: ["NEW-BUG"]
projects: ["TheXTech/1"]

body:
  - type: textarea
    id: description
    attributes:
      label: Describe the issue
      description: A clear and concise description of what the bug.
    validations:
      required: true

  - type: dropdown
    id: bug_type
    attributes:
      label: A type of bug
      description: |
        How you would classify this bug by yourself?
        * **Native bug** - The own bug of TheXTech itself that was never happen in the original SMBX.
        * **Vanilla bug** - The bug of original SMBX that got being inherited by TheXTech during its initial creation.
        * **Compatibility bug** - The deviation of behaviour from the original even with the strict compatibility mode (run the game with `--compat-level smbx13` command-line argument).

        **Note:** The development team can classify this issue in a different way depending on the result of the analysis.
      options:
        - [Not specified]
        - Native bug
        - Vanilla bug
        - Compatibility bug
    validations:
      required: true

  - type: dropdown
    id: frequency
    attributes:
      label: Does this issue happens always or randomly?
      description: Is it possible to reproduce this issue easily, or it happens very rare?
      options:
        - Always happens
        - Happens randomly, often
        - Happens randomly, rare
        - Happens very rare
    validations:
      required: true

  - type: input
    id: version
    attributes:
      label: Version
      description: What version of TheXtech you are using? You can see it in the title of the window.
    validations:
      required: true

  - type: input
    id: version_hash
    attributes:
      label: Version Hash
      description: If you run a **DEVEL** version, please also tell the hash tag (like `#1A2BC3E`) that can be found in the window title or in the main menu at the right-bottom of the screen.
    validations:
      required: false

  - type: dropdown
    id: os
    attributes:
      label: Platform
      description: What the platform where you run the game?
      options:
        - [Not specified]
        - Linux
        - Windows
        - macOS
        - Android
        - Haiku
        - xBSD
        - Web-browser (Emscripten)
        - 3DS
        - Wii
        - Wii U
        - Switch
        - PS Vita
        - Other (tell in the bug description)
    validations:
      required: true

  - type: dropdown
    id: cpu
    attributes:
      label: Processor architecture
      description: |
        Which architecture your processor where you ran the game have?

        * If you run the **Windows**, you can easily check your architecture (x86 32-bit, 64-bit, or "64-bit processor ARM"), you can open the properties of the "This computer" / "My computer".
        * On **Linux** / **xBSD**, you can open the terminal and run the `uname -m` command to get the exact processor architecture.
        * On **macOS**, just can open the "About this Mac" to see the architecture in the description. If you see in description such as 32-bit "Power PC" (PPC G3, PPC G4) or PPC G5 which is 64-bit Power PC, **Intel Core Solo, Core Duo (not 2 Duo!)** which are 32-bit i386, **Intel Core 2 Duo, Quad-Core, i3/i5/i7** which are 64-bit x86_64, and the **Apple M1/M2/M3/etc.** which is an ARM64).
        * On **Android** you might want to use program such as AIDA64 where you can open the "CPU" list, and find the "Instructions set" paragraph where you can see exact processor architecture that your device runs.

        **Note:** Some platforms do have one single architecture only, for example:
        * **PSP** has the MIPS32.
        * **3DS** and **Vita** has the ARM32/ARMv7.
        * **Wii** and **Wii U** has the PPC32.
        * **Switch** has the ARM64/AARCH64.
      options:
        - [Not specified / I don't know]
        - x86_64 / x64 (64-bit x86)
        - i386 / x86_32 (32-bit x86)
        - ARM64 / AARCH64 (64-bit ARM)
        - ARM32 / ARMv7 (32-bit ARM)
        - PPC64LE (64-bit Power PC with Little-Endian)
        - PPC64 (64-bit Power PC with Big-Endian)
        - PPC32 (32-bit Power PC with Big-Endian)
        - MIPS64 (32-bit MIPS)
        - MIPS32 (64-bit MIPS)
        - RISC-V
        - WebAssembly (Emscripten)
        - Other (tell in the bug description)
    validations:
      required: false

  - type: textarea
    id: log_file
    attributes:
      label: Log file (if presented)
      description: |
        Please upload the log file that have the `TheXTech_log_YYYY_MM_DD_HH_mm_ss.txt` name which can be found in the `logs` sub-directory in the game's user directory.
    validations:
      required: false

  - type: textarea
    id: example_case
    attributes:
      label: Example Case
      description: |
        Post a link to the level where the issue occurs:
        *levelname.lvl* from `[Episode name](https://link.to.episode/)`
        Even better: If you make a dedicated test level and attach it to your GitHub Post (pack it as `.zip` first, and then drag it and drop into this text area).
    validations:
      required: false

  - type: textarea
    id: recording
    attributes:
      label: Recording
      description: Embed or add a link to a Recording here. If it's an in-game issue, you can use TheXTech's built-in GIF Recorder (Press F11 or F10 on macOS). If it's a crash, use a Screen Capture program such as OBS or vokoscreen.
    validations:
      required: false

  - type: textarea
    id: vanilla_recording
    attributes:
      label: Vanilla Recording
      description: Not required, but if you can run SMBX 1.3 (or [use our Research Version](https://github.com/Wohlstand/smbx-experiments/releases) that will work better on Linux under Wine and has the built-in GIF recorder using the F11 key), it would be appreciated if you made a recording of whether the bug occurs here as well.
    validations:
      required: false

  - type: textarea
    id: misc_info
    attributes:
      label: Additional context
      description: Add any other context that could be useful for solving the problem here. If your problem is tied to your Operating System, add it at the beginning of the Title ("[Windows] Windows Issue").
    validations:
      required: false


================================================
FILE: .github/ISSUE_TEMPLATE/compile-fail-report.yml
================================================
name: Build/Compilation failure report
description: Create a report of the problems to compile the game from the source code
labels: ["NEW-BUG"]
projects: ["TheXTech/1"]

body:
  - type: textarea
    id: description
    attributes:
      label: Describe the issue
      description: A clear and concise description of what the bug.
    validations:
      required: true

  - type: input
    id: version
    attributes:
      label: Version
      description: What version of TheXtech you are using? Do you trying to build the stable version or the latest state of the GIT?
    validations:
      required: true

  - type: input
    id: version_hash
    attributes:
      label: Version Hash
      description: If you build the game from the source source code clonned from the GIT, retrieve the hash of the commit where your current state is.
    validations:
      required: false

  - type: dropdown
    id: os_host
    attributes:
      label: Build platform
      description: What the platform where you build the game?
      options:
        - [Not specified]
        - Linux
        - Windows
        - macOS
        - Android
        - Haiku
        - xBSD
        - Other (tell in the bug description)
    validations:
      required: true

  - type: dropdown
    id: os_target
    attributes:
      label: Target platform
      description: For which platform you trying to build the game?
      options:
        - [Not specified]
        - Linux
        - Windows
        - macOS
        - Android
        - Haiku
        - xBSD
        - Web-browser (Emscripten)
        - 3DS
        - Wii
        - Wii U
        - Switch
        - PS Vita
        - Other (tell in the bug description)
    validations:
      required: true

  - type: dropdown
    id: cpu
    attributes:
      label: Target processor architecture
      description: Which target architecture for which you attempted to build the game?
      options:
        - [Not specified]
        - x86_64 / x64 (64-bit x86)
        - i386 / x86_32 (32-bit x86)
        - ARM64 / AARCH64 (64-bit ARM)
        - ARM32 / ARMv7 (32-bit ARM)
        - PPC64LE (64-bit Power PC with Little-Endian)
        - PPC64 (64-bit Power PC with Big-Endian)
        - PPC32 (32-bit Power PC with Big-Endian)
        - MIPS64 (32-bit MIPS)
        - MIPS32 (64-bit MIPS)
        - RISC-V
        - Other (tell in the bug description)
    validations:
      required: true

  - type: dropdown
    id: compiler
    attributes:
      label: Compiler name
      description: What the compiler you used to build the game?
      options:
        - [Not specified]
        - GCC
        - Clang
        - MSVC
        - Intel-CC
        - ARM-CC
        - Other (tell in the bug description)
    validations:
      required: true

  - type: textarea
    id: build_log
    attributes:
      label: Build log
      description: |
        Please save your full build output log into a text file and upload it here.
    validations:
      required: false

  - type: textarea
    id: build_commands
    attributes:
      label: What commands you typed in the terminal or what you did in your IDE?
      description: |
        Explain step-by-step what you did before you got an error.
    validations:
      required: false

  - type: textarea
    id: misc_info
    attributes:
      label: Additional context
      description: Add any other context that could be useful for solving the problem here. If your problem is tied to your Operating System, add it at the beginning of the Title ("[Windows] Windows Issue").
    validations:
      required: false


================================================
FILE: .github/ci-helper/.gitignore
================================================
.idea/

================================================
FILE: .github/ci-helper/create-dmg.sh
================================================
#!/bin/bash

# Create a read-only disk image of the conkmtents of a folder

set -e

function pure_version() {
    echo '1.0.1.0'
}

function version() {
    echo "create-dmg $(pure_version)"
}

function usage() {
    version
    echo "Creates a fancy DMG file."
    echo "Usage:  $(basename $0) options... image.dmg source_folder"
    echo "All contents of source_folder will be copied into the disk image."
    echo "Options:"
    echo "  --volname name"
    echo "      set volume name (displayed in the Finder sidebar and window title)"
    echo "  --volicon icon.icns"
    echo "      set volume icon"
    echo "  --background pic.png"
    echo "      set folder background image (provide png, gif, jpg)"
    echo "  --window-pos x y"
    echo "      set position the folder window"
    echo "  --window-size width height"
    echo "      set size of the folder window"
    echo "  --icon-size icon_size"
    echo "      set window icons size (up to 128)"
    echo "  --icon file_name x y"
    echo "      set position of the file's icon"
    echo "  --hide-extension file_name"
    echo "      hide the extension of file"
    echo "  --custom-icon file_name custom_icon_or_sample_file x y"
    echo "      set position and custom icon"
    echo "  --app-drop-link x y"
    echo "      make a drop link to Applications, at location x,y"
    echo "  --eula eula_file"
    echo "      attach a license file to the dmg"
    echo "  --no-internet-enable"
    echo "      disable automatic mount&copy"
    echo "  --subfolder"
    echo "      put all content of source folder into sub-folder"
    echo "  --version         show tool version number"
    echo "  -h, --help        display this help"
    exit 0
}

WINX=10
WINY=60
WINW=500
WINH=350
ICON_SIZE=128

while test "${1:0:1}" = "-"; do
    case $1 in
    --volname)
        VOLUME_NAME="$2"
        shift
        shift
        ;;
    --volicon)
        VOLUME_ICON_FILE="$2"
        shift
        shift
        ;;
    --background)
        BACKGROUND_FILE="$2"
        BACKGROUND_FILE_NAME="$(basename $BACKGROUND_FILE)"
        BACKGROUND_CLAUSE="set background picture of opts to file \".background:$BACKGROUND_FILE_NAME\""
        shift
        shift
        ;;
    --icon-size)
        ICON_SIZE="$2"
        shift
        shift
        ;;
    --window-pos)
        WINX=$2
        WINY=$3
        shift
        shift
        shift
        ;;
    --window-size)
        WINW=$2
        WINH=$3
        shift
        shift
        shift
        ;;
    --icon)
        POSITION_CLAUSE="${POSITION_CLAUSE}set position of item \"$2\" to {$3, $4}
"
        shift
        shift
        shift
        shift
        ;;
    --hide-extension)
        HIDING_CLAUSE="${HIDING_CLAUSE}set the extension hidden of item \"$2\" to true"
        shift
        shift
        ;;
    --custom-icon)
        shift
        shift
        shift
        shift
        shift
        ;;
    -h | --help)
        usage
        ;;
    --version)
        version
        exit 0
        ;;
    --pure-version)
        pure_version
        exit 0
        ;;
    --app-drop-link)
        APPLICATION_LINK=$2
        APPLICATION_CLAUSE="set position of item \"Applications\" to {$2, $3}
"
        shift
        shift
        shift
        ;;
    --eula)
        EULA_RSRC=$2
        shift
        shift
        ;;
    --no-internet-enable)
        NOINTERNET=1
        shift
        ;;
    --subfolder)
        DOSUBFOLDER=1
        shift
        ;;
    -*)
        echo "Unknown option $1. Run with --help for help."
        exit 1
        ;;
    esac
done

test -z "$2" && {
    echo "Not enough arguments. Invoke with --help for help."
    exit 1
}

DMG_PATH="$1"
DMG_DIRNAME="$(dirname "$DMG_PATH")"
DMG_DIR="$(
    cd $DMG_DIRNAME >/dev/null
    pwd
)"
DMG_NAME="$(basename "$DMG_PATH")"
DMG_TEMP_NAME="$DMG_DIR/rw.${DMG_NAME}"
SRC_FOLDER="$(
    cd "$2" >/dev/null
    pwd
)"
test -z "$VOLUME_NAME" && VOLUME_NAME="$(basename "$DMG_PATH" .dmg)"

AUX_PATH="$(dirname $0)/support"

test -d "$AUX_PATH" || {
    echo "Cannot find support directory: $AUX_PATH"
    exit 1
}

if [[ $DOSUBFOLDER == 1 ]]; then
    SRC_FOLDER_TEMP="${SRC_FOLDER}_tmp/"
    SRC_FOLDER_SF="${SRC_FOLDER}_tmp/${SRC_FOLDER##*/}"
    echo "Generating subfolder $SRC_FOLDER_SF..."
    mkdir -p "$SRC_FOLDER_SF"
    cp -a "$SRC_FOLDER" "$SRC_FOLDER_SF"
    SRC_FOLDER="$SRC_FOLDER_SF"
fi

if [ -f "$SRC_FOLDER/.DS_Store" ]; then
    echo "Deleting any .DS_Store in source folder"
    rm "$SRC_FOLDER/.DS_Store"
fi

# Create the image
echo "Creating disk image..."
test -f "${DMG_TEMP_NAME}" && rm -f "${DMG_TEMP_NAME}"
ACTUAL_SIZE=$(du -sm "$SRC_FOLDER" | sed -e 's/	.*//g')
DISK_IMAGE_SIZE=$(expr $ACTUAL_SIZE + 20)
hdiutil create -srcfolder "$SRC_FOLDER" -volname "${VOLUME_NAME}" -fs HFS+ -fsargs "-c c=64,a=16,e=16" -format UDRW -size ${DISK_IMAGE_SIZE}m "${DMG_TEMP_NAME}"

# mount it
echo "Mounting disk image..."
MOUNT_DIR="/Volumes/${VOLUME_NAME}"

# try unmount dmg if it was mounted previously (e.g. developer mounted dmg, installed app and forgot to unmount it)
echo "Unmounting disk image..."
DEV_NAME=$(hdiutil info | egrep '^/dev/' | sed 1q | awk '{print $1}')
test -d "${MOUNT_DIR}" && hdiutil detach "${DEV_NAME}"

echo "Mount directory: $MOUNT_DIR"
DEV_NAME=$(hdiutil attach -readwrite -noverify -noautoopen "${DMG_TEMP_NAME}" | egrep '^/dev/' | sed 1q | awk '{print $1}')
echo "Device name:     $DEV_NAME"

if ! test -z "$BACKGROUND_FILE"; then
    echo "Copying background file..."
    test -d "$MOUNT_DIR/.background" || mkdir "$MOUNT_DIR/.background"
    cp "$BACKGROUND_FILE" "$MOUNT_DIR/.background/$BACKGROUND_FILE_NAME"
fi

if ! test -z "$APPLICATION_LINK"; then
    echo "making link to Applications dir"
    echo $MOUNT_DIR
    ln -s /Applications "$MOUNT_DIR/Applications"
fi

if ! test -z "$VOLUME_ICON_FILE"; then
    echo "Copying volume icon file '$VOLUME_ICON_FILE'..."
    cp "$VOLUME_ICON_FILE" "$MOUNT_DIR/.VolumeIcon.icns"
    SetFile -c icnC "$MOUNT_DIR/.VolumeIcon.icns"
fi

# run applescript
APPLESCRIPT=$(mktemp -t createdmg.XXXXXXX)
cat "$AUX_PATH/template.applescript" | sed -e "s/WINX/$WINX/g" -e "s/WINY/$WINY/g" -e "s/WINW/$WINW/g" -e "s/WINH/$WINH/g" -e "s/BACKGROUND_CLAUSE/$BACKGROUND_CLAUSE/g" -e "s/ICON_SIZE/$ICON_SIZE/g" | perl -pe "s/POSITION_CLAUSE/$POSITION_CLAUSE/g" | perl -pe "s/APPLICATION_CLAUSE/$APPLICATION_CLAUSE/g" | perl -pe "s/HIDING_CLAUSE/$HIDING_CLAUSE/" >"$APPLESCRIPT"

echo "Running Applescript: /usr/bin/osascript \"${APPLESCRIPT}\" \"${VOLUME_NAME}\""
"/usr/bin/osascript" "${APPLESCRIPT}" "${VOLUME_NAME}" || true
echo "Done running the applescript..."
sleep 4

rm "$APPLESCRIPT"

# make sure it's not world writeable
echo "Fixing permissions..."
chmod -Rf go-w "${MOUNT_DIR}" &>/dev/null || true
echo "Done fixing permissions."

# make the top window open itself on mount:
echo "Blessing started"
bless --folder "${MOUNT_DIR}" --openfolder "${MOUNT_DIR}"
echo "Blessing finished"

if ! test -z "$VOLUME_ICON_FILE"; then
    # tell the volume that it has a special file attribute
    SetFile -a C "$MOUNT_DIR"
fi

# unmount
echo "Unmounting disk image..."
hdiutil detach "${DEV_NAME}"

# compress image
echo "Compressing disk image..."
hdiutil convert "${DMG_TEMP_NAME}" -format UDBZ -o "${DMG_DIR}/${DMG_NAME}"
rm -f "${DMG_TEMP_NAME}"

# adding EULA resources
if [ ! -z "${EULA_RSRC}" -a "${EULA_RSRC}" != "-null-" ]; then
    echo "adding EULA resources"
    "${AUX_PATH}/dmg-license3.py" "${DMG_DIR}/${DMG_NAME}" "${EULA_RSRC}"
fi

if [ ! -z "${NOINTERNET}" -a "${NOINTERNET}" == 1 ]; then
    echo "not setting 'internet-enable' on the dmg"
else
    hdiutil internet-enable -yes "${DMG_DIR}/${DMG_NAME}"
fi

# Removing temporary folder
if [[ $DOSUBFOLDER == 1 ]]; then
    rm -Rf ${SRC_FOLDER_TEMP}
fi

echo "Disk image done"
exit 0


================================================
FILE: .github/ci-helper/pack-game-macos.sh
================================================
#!/bin/bash

# $1 assets; $2 icon $3 bundle name

ASSETS_NAME=$1
ICON_FILE=$2
BUNDLE_NAME=$3
ARCHIVE_NAME=$4

if [[ "${ASSETS_NAME}" != "none" ]]; then
    echo "Preparing the application..."
    cp -R TheXTech.app "tmpapp"
    cp -R $ASSETS_NAME/* "tmpapp/Contents/Resources/assets/"
    find tmpapp -name ".DS_Store" -delete
    plutil -replace CFBundleName -string "$BUNDLE_NAME" "tmpapp/Contents/Info.plist"
    plutil -replace CFBundleIconFile -string "$ICON_FILE" "tmpapp/Contents/Info.plist"
    mv tmpapp "$BUNDLE_NAME.app"
fi

mkdir dmg-root

cp LICENSE "dmg-root/License.TheXTech.txt"

cp README.md "dmg-root/ReadMe.txt"
cp README.RUS.md "dmg-root/ReadMe.RUS.txt"
cp README.ESP.md "dmg-root/ReadMe.ESP.txt"

echo "== mv \"$BUNDLE_NAME.app\" dmg-root/"
mv "$BUNDLE_NAME.app" dmg-root/

if [[ "${ASSETS_NAME}" == "none" ]]; then
    echo "Creating ZIP..."
    cd dmg-root
    zip -9 -r ../${ARCHIVE_NAME} *
    cd ..
else
    echo "Creating DMG..."
    ./.github/ci-helper/create-dmg.sh \
        --volname "$BUNDLE_NAME" \
        --window-size 800 600 \
        --app-drop-link 450 320 \
        --no-internet-enable \
        "$ARCHIVE_NAME" \
        "dmg-root/"
fi

echo "Cleaning up..."
rm -Rf dmg-root
printf "\n----------------------------------------------------------------\n\n"


================================================
FILE: .github/ci-helper/pack-game.sh
================================================
#!/bin/bash

RUNNER_OS=$1
SUBDIR_NAME=$2
EXECUTABLE_NAME=$3
ARCHIVE_NAME="$4"
ASSETS_NAME=$5


cd build

mkdir -p "package/${SUBDIR_NAME}"

cp ../changelog.txt "package/${SUBDIR_NAME}/"

cp ../LICENSE "package/${SUBDIR_NAME}/License.TheXTech.txt"

cp ../README.md "package/${SUBDIR_NAME}/ReadMe.txt"
cp ../README.RUS.md "package/${SUBDIR_NAME}/ReadMe.RUS.txt"
cp ../README.ESP.md "package/${SUBDIR_NAME}/ReadMe.ESP.txt"

if [[ "${RUNNER_OS}" == "Windows" ]]; then
    cp output/bin/thextech.exe "package/${SUBDIR_NAME}/${EXECUTABLE_NAME}.exe"
    cp output/bin/*.dll "package/${SUBDIR_NAME}/"
elif [[ "${RUNNER_OS}" == "Linux" ]]; then
    cp output/bin/thextech "package/${SUBDIR_NAME}/${EXECUTABLE_NAME}"
fi

if [[ "${ASSETS_NAME}" != "none" ]]; then
    cp -r ../${ASSETS_NAME}/* "package/${SUBDIR_NAME}/"
fi

cd package

if [[ "${RUNNER_OS}" == "Windows" ]]; then
    7z a "${ARCHIVE_NAME}.7z" "${SUBDIR_NAME}"
else
    tar -cvzf "${ARCHIVE_NAME}.tar.gz" "${SUBDIR_NAME}"
fi

rm -Rf "${SUBDIR_NAME}"

cd ../..


================================================
FILE: .github/ci-helper/support/dmg-license.py
================================================
#! /usr/bin/env python
"""
This script adds a license file to a DMG. Requires Xcode and a plain ascii text
license file.
Obviously only runs on a Mac.

Copyright (C) 2011 Jared Hobbs

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
import os
import sys
import tempfile
import optparse


class Path(str):
    def __enter__(self):
        return self

    def __exit__(self, in_type, value, traceback):
        os.unlink(self)


def mktemp(dir=None, suffix=''):
    (fd, filename) = tempfile.mkstemp(dir=dir, suffix=suffix)
    os.close(fd)
    return Path(filename)


def main(in_options, in_args):
    dmg_file, license_file = in_args
    with mktemp('.') as tmpFile:
        with open(tmpFile, 'w') as f:
            f.write("""data 'LPic' (5000) {
    $"0002 0011 0003 0001 0000 0000 0002 0000"
    $"0000 000E 0006 0001 0005 0007 0000 0007"
    $"0008 0000 0047 0009 0000 0034 000A 0001"
    $"0035 000B 0001 0020 000C 0000 0011 000D"
    $"0000 005B 0004 0000 0033 000F 0001 000C"
    $"0010 0000 000B 000E 0000"
};\n\n""")
            with open(license_file, 'r') as l:
                f.write('data \'TEXT\' (5002, "English") {\n')
                for line in l:
                    if len(line) < 1000:
                        f.write('    "' + line.strip().replace('"', '\\"') +
                                '\\n"\n')
                    else:
                        for liner in line.split('.'):
                            f.write('    "' +
                                    liner.strip().replace('"', '\\"') +
                                    '. \\n"\n')
                f.write('};\n\n')
            f.write("""resource 'STR#' (5002, "English") {
    {
        "English",
        "Agree",
        "Disagree",
        "Print",
        "Save...",
        "IMPORTANT - By clicking on the \\"Agree\\" button, you agree "
        "to be bound by the terms of the License Agreement.",
        "Software License Agreement",
        "This text cannot be saved. This disk may be full or locked, or the "
        "file may be locked.",
        "Unable to print. Make sure you have selected a printer."
    }
};""")
        os.system('/usr/bin/hdiutil unflatten -quiet "%s"' % dmg_file)
        os.system('%s "%s/"*.r %s -a -o "%s"' %
                  (in_options.rez, in_options.flat_carbon, tmpFile, dmg_file))

        os.system('/usr/bin/hdiutil flatten -quiet "%s"' % dmg_file)
        if in_options.compression is not None:
            os.system('cp %s %s.temp.dmg' % (dmg_file, dmg_file))
            os.remove(dmg_file)
            if in_options.compression == "bz2":
                os.system('hdiutil convert %s.temp.dmg -format UDBZ -o %s' %
                          (dmg_file, dmg_file))
            elif in_options.compression == "gz":
                os.system('hdiutil convert %s.temp.dmg -format ' % dmg_file +
                          'UDZO -imagekey zlib-devel=9 -o %s' % dmg_file)
            os.remove('%s.temp.dmg' % dmg_file)
    print "Successfully added license to '%s'" % dmg_file


if __name__ == '__main__':
    parser = optparse.OptionParser()
    parser.set_usage("""%prog <dmgFile> <licenseFile> [OPTIONS]
  This program adds a software license agreement to a DMG file.
  It requires Xcode and a plain ascii text <licenseFile>.

  See --help for more details.""")
    parser.add_option(
        '--rez',
        '-r',
        action='store',
        default='/Applications/Xcode.app/Contents/Developer/Tools/Rez',
        help='The path to the Rez tool. Defaults to %default'
    )
    parser.add_option(
        '--flat-carbon',
        '-f',
        action='store',
        default='/Applications/Xcode.app/Contents/Developer/Platforms'
                '/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk'
                '/Developer/Headers/FlatCarbon',
        help='The path to the FlatCarbon headers. Defaults to %default'
    )
    parser.add_option(
        '--compression',
        '-c',
        action='store',
        choices=['bz2', 'gz'],
        default=None,
        help='Optionally compress dmg using specified compression type. '
             'Choices are bz2 and gz.'
    )
    options, args = parser.parse_args()
    cond = len(args) != 2 or not os.path.exists(options.rez) \
           or not os.path.exists(options.flat_carbon)
    if cond:
        parser.print_usage()
        sys.exit(1)
    main(options, args)


================================================
FILE: .github/ci-helper/support/dmg-license3.py
================================================
#! /usr/bin/env python3
"""
This script adds a license file to a DMG. Requires Xcode and a plain ascii text
license file.
Obviously only runs on a Mac.

Copyright (C) 2011 Jared Hobbs

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
import os
import sys
import tempfile
import optparse


class Path(str):
    def __enter__(self):
        return self

    def __exit__(self, in_type, value, traceback):
        os.unlink(self)


def mktemp(dirname=None, suffix=''):
    (fd, filename) = tempfile.mkstemp(dir=dirname, suffix=suffix)
    os.close(fd)
    return Path(filename)


def main(in_options, in_args):
    dmg_file, license_file = in_args
    with mktemp('.') as tmpFile:
        with open(tmpFile, 'w') as f:
            f.write("""data 'LPic' (5000) {
    $"0002 0011 0003 0001 0000 0000 0002 0000"
    $"0000 000E 0006 0001 0005 0007 0000 0007"
    $"0008 0000 0047 0009 0000 0034 000A 0001"
    $"0035 000B 0001 0020 000C 0000 0011 000D"
    $"0000 005B 0004 0000 0033 000F 0001 000C"
    $"0010 0000 000B 000E 0000"
};\n\n""")
            with open(license_file, 'r') as l:
                f.write('data \'TEXT\' (5002, "English") {\n')
                for line in l:
                    if len(line) < 1000:
                        f.write('    "' + line.strip().replace('"', '\\"') +
                                '\\n"\n')
                    else:
                        for liner in line.split('.'):
                            f.write('    "' +
                                    liner.strip().replace('"', '\\"') +
                                    '. \\n"\n')
                f.write('};\n\n')
            f.write("""resource 'STR#' (5002, "English") {
    {
        "English",
        "Agree",
        "Disagree",
        "Print",
        "Save...",
        "IMPORTANT - By clicking on the \\"Agree\\" button, you agree "
        "to be bound by the terms of the License Agreement.",
        "Software License Agreement",
        "This text cannot be saved. This disk may be full or locked, or the "
        "file may be locked.",
        "Unable to print. Make sure you have selected a printer."
    }
};""")
        os.system('/usr/bin/hdiutil unflatten -quiet "%s"' % dmg_file)
        os.system('%s "%s/"*.r %s -a -o "%s"' %
                  (in_options.rez, in_options.flat_carbon, tmpFile, dmg_file))

        os.system('/usr/bin/hdiutil flatten -quiet "%s"' % dmg_file)
        if in_options.compression is not None:
            os.system('cp %s %s.temp.dmg' % (dmg_file, dmg_file))
            os.remove(dmg_file)
            if in_options.compression == "bz2":
                os.system('hdiutil convert %s.temp.dmg -format UDBZ -o %s' %
                          (dmg_file, dmg_file))
            elif in_options.compression == "gz":
                os.system('hdiutil convert %s.temp.dmg -format ' % dmg_file +
                          'UDZO -imagekey zlib-devel=9 -o %s' % dmg_file)
            os.remove('%s.temp.dmg' % dmg_file)
    print("Successfully added license to '%s'" % dmg_file)


if __name__ == '__main__':
    parser = optparse.OptionParser()
    parser.set_usage("""%prog <dmgFile> <licenseFile> [OPTIONS]
  This program adds a software license agreement to a DMG file.
  It requires Xcode and a plain ascii text <licenseFile>.

  See --help for more details.""")
    parser.add_option(
        '--rez',
        '-r',
        action='store',
        default='/Applications/Xcode.app/Contents/Developer/Tools/Rez',
        help='The path to the Rez tool. Defaults to %default'
    )
    parser.add_option(
        '--flat-carbon',
        '-f',
        action='store',
        default='/Applications/Xcode.app/Contents/Developer/Platforms'
                '/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk'
                '/Developer/Headers/FlatCarbon',
        help='The path to the FlatCarbon headers. Defaults to %default'
    )
    parser.add_option(
        '--compression',
        '-c',
        action='store',
        choices=['bz2', 'gz'],
        default=None,
        help='Optionally compress dmg using specified compression type. '
             'Choices are bz2 and gz.'
    )
    options, args = parser.parse_args()
    cond = len(args) != 2 or not os.path.exists(options.rez) \
        or not os.path.exists(options.flat_carbon)
    if cond:
        parser.print_usage()
        sys.exit(1)
    main(options, args)


================================================
FILE: .github/ci-helper/support/template.applescript
================================================
on run (volumeName)
	tell application "Finder"
		tell disk (volumeName as string)
			open
			
			set theXOrigin to WINX
			set theYOrigin to WINY
			set theWidth to WINW
			set theHeight to WINH
			
			set theBottomRightX to (theXOrigin + theWidth)
			set theBottomRightY to (theYOrigin + theHeight)
			set dsStore to "\"" & "/Volumes/" & volumeName & "/" & ".DS_STORE\""
			
			tell container window
				set current view to icon view
				set toolbar visible to false
				set statusbar visible to false
				set the bounds to {theXOrigin, theYOrigin, theBottomRightX, theBottomRightY}
				set statusbar visible to false
			end tell
			
			set opts to the icon view options of container window
			tell opts
				set icon size to ICON_SIZE
				set arrangement to not arranged
			end tell
			BACKGROUND_CLAUSE
			
			-- Positioning
			POSITION_CLAUSE
			
			-- Hiding
			HIDING_CLAUSE
			
			-- Application Link Clause
			APPLICATION_CLAUSE
            close
            open
			
			update without registering applications
			-- Force saving of the size
			delay 1
			
			tell container window
				set statusbar visible to false
				set the bounds to {theXOrigin, theYOrigin, theBottomRightX - 10, theBottomRightY - 10}
			end tell
			
			update without registering applications
		end tell
		
		delay 1
		
		tell disk (volumeName as string)
			tell container window
				set statusbar visible to false
				set the bounds to {theXOrigin, theYOrigin, theBottomRightX, theBottomRightY}
			end tell
			
			update without registering applications
		end tell
		
		--give the finder some time to write the .DS_Store file
		delay 3
		
		set waitTime to 0
		set ejectMe to false
		repeat while ejectMe is false
			delay 1
			set waitTime to waitTime + 1
			
			if (do shell script "[ -f " & dsStore & " ]; echo $?") = "0" then set ejectMe to true
		end repeat
		log "waited " & waitTime & " seconds for .DS_STORE to be created."
	end tell
end run


================================================
FILE: .github/ci-helper/translate_patcher.py
================================================
#!/usr/bin/python3

import json
import sys
import optparse


def merge_jsons(my_dict, output):
    for k, v in my_dict.items():
        if isinstance(v, dict):
            if k not in output:
                output[k] = dict()
            merge_jsons(v, output[k])
            continue

        output[k] = v


def main(in_args):
    in_file = in_args[0]
    patch_file = in_args[1]
    out_file = in_args[2]

    with open(in_file, encoding='utf-8') as first_file:
        json_out = json.load(first_file)

    with open(patch_file, encoding='utf-8') as second_file:
        json_in = json.load(second_file)

    print("-- Patching translation file: %s\n"
          "-- By the patch file: %s\n"
          "-- Writing result into the %s" % (in_file, patch_file, out_file))

    merge_jsons(json_in, json_out)

    with open(out_file, 'w', encoding='utf-8') as f:
        json.dump(json_out, f, ensure_ascii=False, indent=4)

    print("Completed!")


if __name__ == '__main__':
    parser = optparse.OptionParser()
    parser.set_usage("""%prog <in file to patch> <patch file> <output file>.

  See --help for more details.""")

    options, args = parser.parse_args()
    cond = len(args) != 3
    if cond:
        parser.print_usage()
        sys.exit(1)

    main(args)


================================================
FILE: .github/ci-helper/translate_sync_assets.sh
================================================
#!/bin/bash

OLD=$PWD
GIT_ROOT=$PWD/build-git
WORKDIR="$PWD/.github/ci-helper"

mkdir -p build-git

function update_repo()
{
    q=$1
    branch=$2

    if [[ "$branch" != "" ]]; then
        branch_command="-b $branch"
        branch_display="[Branch $branch] "
    fi

    echo "============================================================="
    echo "================ $q $branch_display================"
    echo "============================================================="
    cd "${GIT_ROOT}"
    git clone "$q" --depth 1 $branch_command repo

    cd "${WORKDIR}"
    bash translate_update.sh "${GIT_ROOT}/repo"

    cd "${GIT_ROOT}/repo"
    if [[ ! -z $(git status -s) ]]; then
        echo "-- Found updated languages, commiting..."
        git add --all
        git commit --author="${GIT_AUTHOR}" -m "Synchronized translations"
        git push
    else
        echo "-- No updates found, skipping..."
    fi
    cd ..
    rm -Rf repo
    printf "=============================================================\n\n\n"
}


# FIXME: Replace this hardcoded list with a server-side one to don't re-commit this list
# every time
for q in \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-smbx.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-adventures-of-demo.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-convert-kit.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-a2xt-analog-funk.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-a2xt-prelude-to-the-stupid.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-lowser-s-conquest-beta.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-sarasaland-adventure-v1-2.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-sarasaland-adventure-2.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-sarasaland-adventure-v4-0.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-smbx-nes.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-smbx-nostalgic.git" \
    "git@gitea.wohlsoft.ru:Games-for-TheXTech/thextech-super-talking-time-bros-1n2-v1-5.git" \
    ;
do
    update_repo "$q"
done

# Nostalgic Paradise needs another branch
update_repo git@gitea.wohlsoft.ru:Games-for-TheXTech/nostalgic-paradise.git development

cd "${OLD}"


================================================
FILE: .github/ci-helper/translate_sync_to_stable.sh
================================================
#!/bin/bash

OLD=$PWD
GIT_ROOT=$PWD/build-git
WORKDIR="$PWD/.github/ci-helper"

STABLE_BRANCH=stable-1.3.7.x

if [[ -z "$GITHUB_TOKEN" ]]; then
    echo 'Missing input "github_token: $GITHUB_TOKEN".';
    exit 1;
fi

git clone https://github.com/TheXTech/TheXTech.git --depth 1 -b ${STABLE_BRANCH} build-git

# General engine translations
cp -av resources/languages/* build-git/resources/languages/

# Android launcher translations
cd android-project/thextech/src/main/res
for q in values values-*; do
    if [[ -f "$q/strings.xml" ]]; then
        cp -v "$q/strings.xml" "${GIT_ROOT}/android-project/thextech/src/main/res/${q}/strings.xml"
    fi
    if [[ -f "$q/arrays.xml" ]]; then
        cp -v "$q/arrays.xml" "${GIT_ROOT}/android-project/thextech/src/main/res/${q}/arrays.xml"
    fi
done
cd "$OLD"

# Commit all changes that was done
cd build-git
if [[ ! -z $(git status -s) ]]; then
    echo "-- Found updated languages, commiting..."
    git add --all
    git commit --author="${GIT_AUTHOR}" -m "Synchronized translations with mainstream branch"
    remote_repo="https://${GITHUB_ACTOR}:${GITHUB_TOKEN}@github.com/TheXTech/TheXTech.git"
    git push "${remote_repo}" ${STABLE_BRANCH}
else
    echo "-- No updates found, skipping..."
fi

cd ..
rm -Rf build-git

cd "${OLD}"

exit 0


================================================
FILE: .github/ci-helper/translate_update.sh
================================================
#!/bin/bash

OLD_DIR=~+

ASSETS_ROOT=$1

LANGS_IN="$PWD/../../resources/languages"
LANGS_PATCH=$1/languages/patches
LANGS_OUT=$1/languages

# Update only existing files at the target (Don't copy new files, they should be placed manually to add them for the autosync)
cd "${LANGS_OUT}"

function update_tr_file()
{
    q="$1"
    if [[ ! -f "${LANGS_PATCH}/$q" ]]; then
        # If no patch file exists, just copy
        printf "==== COPY: %s ====\n" $q
        cp -v "${LANGS_IN}/$q" "${LANGS_OUT}/$q"
    else
        # Otherwise, apply the patch
        printf "==== PATCH: %s ====\n" $q
        echo python3 "${OLD_DIR}/translate_patcher.py" "${LANGS_IN}/$q" "${LANGS_PATCH}/$q" "${LANGS_OUT}/$q"
        python3 "${OLD_DIR}/translate_patcher.py" "${LANGS_IN}/$q" "${LANGS_PATCH}/$q" "${LANGS_OUT}/$q"
    fi
    printf "\n"
}

echo "---------------------------------------------"

for q in thextech_*.json; do
    update_tr_file "$q"
done

for q in assets_*.json; do
    update_tr_file "$q"
done

echo "---------------------------------------------"

cd "$OLD_DIR"


================================================
FILE: .github/workflows/16m-ci.yml
================================================
name: DSi CI

on:
  push:
    branches:
      - main
      - versus-ci-homebrew
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ubuntu-latest
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404-dkp-vita:latest
    env:
        DEVKITPRO: /opt/devkitpro
        DEVKITARM: /opt/devkitpro/devkitARM
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "DSi build",

            extra_options: "-DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/NDS.cmake -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON",

            deps_cmdline: "echo 'DevkitPro SDK is already pre-installed'",

            generator: "Ninja",
            build_type: "RelWithDebInfo",
            executable_name: "thextech",
            subdir_name: "thextech-dsi",
            upload_directory: "www/dsi/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Configure
      shell: bash
      run: |
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        cmake --build build --target all -j4

    - name: Check codesize and RAM usage
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        size build/output/bin/thextech.elf

    - name: Create Package
      if: success()
      shell: bash
      run: |
        cd build
        mkdir package
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        cat ../docs/README_DSI.md ../README.md >> "package/${{ matrix.config.subdir_name }}/README.md"
        cp thextech.nds "package/${{ matrix.config.subdir_name }}/"
        cd package
        zip -9 -r "thextech-calico-${BRANCH_NAME}.zip" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.zip; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/3ds-ci.yml
================================================
name: 3DS CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-homebrew
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ubuntu-latest
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404-dkp-vita:latest
    env:
        DEVKITPRO: /opt/devkitpro
        DEVKITARM: /opt/devkitpro/devkitARM
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "3DS build",

            extra_options: "-DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/3DS.cmake -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON",

            deps_cmdline: "echo 'DevkitPro SDK is already pre-installed'",

            generator: "Ninja",
            build_type: "Release",
            executable_name: "thextech",
            subdir_name: "thextech-3ds",
            upload_directory: "www/3ds/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Configure
      shell: bash
      run: |
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        cmake --build build --target all -j4

    - name: Check codesize and RAM usage
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        size build/output/bin/thextech.elf

    - name: Create Package
      if: success()
      shell: bash
      run: |
        cd build
        mkdir package
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        cat ../docs/README_3DS.md ../README.md >> "package/${{ matrix.config.subdir_name }}/README.md"
        cp thextech.3dsx "package/${{ matrix.config.subdir_name }}/"
        cd package
        zip -9 -r "thextech-3ds-${BRANCH_NAME}.zip" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.zip; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/android-ci.yml
================================================
name: Android CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-android
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

defaults:
  run:
    working-directory: android-project

jobs:
  build:
    runs-on: ubuntu-latest
    name: Build release-apk
    steps:
      - uses: TheXTech/checkout@v0.1

      - uses: TheXTech/branch-name@v0.1

      - name: Pull submodules
        shell: bash
        run: |
          git submodule update --init --recursive

      - name: Check for the upload support
        id: upload-check
        shell: bash
        run: |
          if [[ "${{ secrets.builds_login }}" != '' && \
                "${{ secrets.builds_password }}" != '' && \
                "${{ secrets.builds_host }}" != '' ]]; then
            echo "available=true" >> $GITHUB_OUTPUT;
          else
            echo "available=false" >> $GITHUB_OUTPUT;
          fi

      - name: Check for the upload support
        id: signing-check
        shell: bash
        run: |
          if [[ "${{ secrets.ANDROID_KEYSTORE }}" != '' && \
                "${{ secrets.RELEASE_STORE_PASSWORD }}" != '' && \
                "${{ secrets.RELEASE_KEY_PASSWORD }}" != '' && \
                "${{ secrets.RELEASE_KEY_ALIAS }}" != '' ]];
          then
              echo "available=true" >> $GITHUB_OUTPUT;
          else
              echo "available=false" >> $GITHUB_OUTPUT;
          fi

      - name: Install Dependencies
        shell: bash
        run: |
          sudo apt-get update -qq
          sudo apt-get install -qq lftp

      - name: Set up JDK 21
        uses: actions/setup-java@v3.11.0
        with:
          java-version: 21
          distribution: 'temurin'

      - uses: nttld/setup-ndk@v1
        with:
          ndk-version: r23c
      # IMPORTANT NOTE: The SDK r23b is REQUIRED to support Android 4.1, 4.2, and 4.3, and to support non-Neon hardware

      - name: Setup Android SDK
        uses: android-actions/setup-android@v2

      # Without NDK not compile and not normal error message. NDK is required
      #- name: Install NDK
      #  run: echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;23.2.8568313" --sdk_root=${ANDROID_SDK_ROOT}
      # Some times is have problems with permissions for ./gradle file. Then uncommit it code
      #    - name: Make gradlew executable
      #      run: chmod +x ./gradlew

      - name: Output version code
        run: echo VERSION_CODE=${{ github.run_number }} > ./version.properties

      - name: Import the signing
        if: ${{ steps.signing-check.outputs.available == 'true' }}
        run: echo "${{ secrets.ANDROID_KEYSTORE }}" | base64 -d > release-key.jks

      - name: Build with Gradle
        if: ${{ steps.signing-check.outputs.available == 'true' }}
        run: ./gradlew assembleApkReleaseci
        env:
          RELEASE_STORE_PASSWORD: ${{ secrets.RELEASE_STORE_PASSWORD }}
          RELEASE_KEY_PASSWORD: ${{ secrets.RELEASE_KEY_PASSWORD }}
          RELEASE_KEY_ALIAS: ${{ secrets.RELEASE_KEY_ALIAS }}
          PIN_ALIAS: ${{ secrets.PIN_ALIAS }}
          DB_PASS_ALIAS: ${{ secrets.DB_PASS_ALIAS }}

      - name: Build with Gradle (unsigned)
        if: ${{ steps.signing-check.outputs.available != 'true' }}
        run: ./gradlew assembleApkRelease
        env:
          RELEASE_STORE_PASSWORD: ${{ secrets.RELEASE_STORE_PASSWORD }}
          RELEASE_KEY_PASSWORD: ${{ secrets.RELEASE_KEY_PASSWORD }}
          RELEASE_KEY_ALIAS: ${{ secrets.RELEASE_KEY_ALIAS }}
          PIN_ALIAS: ${{ secrets.PIN_ALIAS }}
          DB_PASS_ALIAS: ${{ secrets.DB_PASS_ALIAS }}

      - name: Rename APK
        if: ${{ steps.signing-check.outputs.available == 'true' }}
        shell: bash
        run: |
          mv thextech/build/outputs/apk/apk/releaseci/thextech-apk-releaseci.apk thextech-android-${BRANCH_NAME}.apk

      - name: Rename APK (unsigned)
        if: ${{ steps.signing-check.outputs.available != 'true' }}
        shell: bash
        run: |
          mv thextech/build/outputs/apk/apk/release/thextech-apk-release-unsigned.apk thextech-android-${BRANCH_NAME}-unsigned.apk

      - name: Upload APK
        if: success() && ${{ steps.signing-check.outputs.available == 'true' }}
        uses: actions/upload-artifact@v4
        with:
          name: thextech-android-${BRANCH_NAME}
          path: android-project/thextech-android-*.apk

      - name: Upload APK (unsigned)
        if: success() && ${{ steps.signing-check.outputs.available != 'true' }}
        uses: actions/upload-artifact@v4
        continue-on-error: true
        with:
          name: thextech-android-${BRANCH_NAME}-unsigned
          path: android-project/thextech-android-*.apk

      - name: Deploy to builds.wohlsoft.ru
        if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
        continue-on-error: true
        shell: bash
        run: |
          UPLOAD_LIST="set ssl:verify-certificate no;"
          if [[ "${{ steps.signing-check.outputs.available }}" == 'true' ]]; then
              UPLOAD_LIST="${UPLOAD_LIST} put -O "www/android/" ./thextech-android-${BRANCH_NAME}.apk;"
          else
              UPLOAD_LIST="${UPLOAD_LIST} put -O "www/android/" ./thextech-android-${BRANCH_NAME}-unsigned.apk;"
          fi
          lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

      - name: List Build Directory
        if: always()
        shell: bash
        run: |
          git status
          ls -lR .


================================================
FILE: .github/workflows/android-fdroid-ci.yml
================================================
name: Android (F-Droid) CI

on:
  workflow_dispatch:
  push:
    branches:
      - release-1.3.7-fdroid

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

defaults:
  run:
    working-directory: android-project

jobs:
  build:
    runs-on: ubuntu-latest
    name: Build release-apk
    steps:
      - uses: TheXTech/checkout@v0.1

      - uses: TheXTech/branch-name@v0.1

      - name: Pull submodules
        shell: bash
        run: |
          git submodule update --init --recursive

      - name: Check for the upload support
        id: upload-check
        shell: bash
        run: |
          if [[ "${{ secrets.builds_login }}" != '' && \
                "${{ secrets.builds_password }}" != '' && \
                "${{ secrets.builds_host }}" != '' ]]; then
            echo "available=true" >> $GITHUB_OUTPUT;
          else
            echo "available=false" >> $GITHUB_OUTPUT;
          fi

      - name: Check for the upload support
        id: signing-check
        shell: bash
        run: |
          if [[ "${{ secrets.ANDROID_KEYSTORE }}" != '' && \
                "${{ secrets.RELEASE_STORE_PASSWORD }}" != '' && \
                "${{ secrets.RELEASE_KEY_PASSWORD }}" != '' && \
                "${{ secrets.RELEASE_KEY_ALIAS }}" != '' ]];
          then
              echo "available=true" >> $GITHUB_OUTPUT;
          else
              echo "available=false" >> $GITHUB_OUTPUT;
          fi

      - name: Extracting version name
        id: extract-version
        shell: bash
        run: |
            ver_name=`perl -ne 'm/THEXTECH_ANDROID_VERSION_NAME\s+"([\d\w.\-]+)"/ && print "$1"' ../version.cmake`
            echo "Version name in version.cmake: ${ver_name}"
            echo "ver_name=${ver_name}" >> $GITHUB_OUTPUT;

      - name: Install Dependencies
        shell: bash
        run: |
          sudo apt-get update -qq
          sudo apt-get install -qq lftp apksigner

      - name: Set up JDK 21
        uses: actions/setup-java@v3.11.0
        with:
          java-version: 21
          distribution: 'temurin'

      - uses: nttld/setup-ndk@v1
        with:
          ndk-version: r23c
      # IMPORTANT NOTE: The SDK r23b is REQUIRED to support Android 4.1, 4.2, and 4.3, and to support non-Neon hardware

      - name: Setup Android SDK
        uses: android-actions/setup-android@v2

      # Without NDK not compile and not normal error message. NDK is required
      #- name: Install NDK
      #  run: echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;23.2.8568313" --sdk_root=${ANDROID_SDK_ROOT}
      # Some times is have problems with permissions for ./gradle file. Then uncommit it code
      #    - name: Make gradlew executable
      #      run: chmod +x ./gradlew

      - name: Output version code
        run: echo VERSION_CODE=${{ github.run_number }} > ./version.properties

      - name: Import the signing
        if: ${{ steps.signing-check.outputs.available == 'true' }}
        run: echo "${{ secrets.ANDROID_KEYSTORE }}" | base64 -d > release-key.jks

      - name: Build unsigned with Gradle
        run: ./gradlew assembleFdroidRelease

      - name: Sign and rename APK
        if: ${{ steps.signing-check.outputs.available == 'true' }}
        shell: bash
        run: |
          apksigner sign --ks 'release-key.jks' \
            --ks-pass env:RELEASE_STORE_PASSWORD \
            --ks-key-alias ${{ secrets.RELEASE_KEY_ALIAS }} \
            --min-sdk-version 16 \
            --v1-signing-enabled \
            --v2-signing-enabled \
            --out thextech-android-fdroid-${{ steps.extract-version.outputs.ver_name }}.apk \
            thextech/build/outputs/apk/fdroid/release/thextech-fdroid-release-unsigned.apk
        env:
          RELEASE_STORE_PASSWORD: ${{ secrets.RELEASE_STORE_PASSWORD }}
          RELEASE_KEY_PASSWORD: ${{ secrets.RELEASE_KEY_PASSWORD }}
          RELEASE_KEY_ALIAS: ${{ secrets.RELEASE_KEY_ALIAS }}
          PIN_ALIAS: ${{ secrets.PIN_ALIAS }}
          DB_PASS_ALIAS: ${{ secrets.DB_PASS_ALIAS }}

      - name: Rename APK (unsigned)
        if: ${{ steps.signing-check.outputs.available != 'true' }}
        shell: bash
        run: |
          mv thextech/build/outputs/apk/fdroid/release/thextech-fdroid-release-unsigned.apk thextech-android-fdroid-${{ steps.extract-version.outputs.ver_name }}-unsigned.apk

      - name: Upload APK
        if: success() && ${{ steps.signing-check.outputs.available == 'true' }}
        uses: actions/upload-artifact@v4
        with:
          name: thextech-android-${{ steps.extract-version.outputs.ver_name }}
          path: android-project/thextech-android-*.apk

      - name: Upload APK (unsigned)
        if: success() && ${{ steps.signing-check.outputs.available != 'true' }}
        uses: actions/upload-artifact@v4
        continue-on-error: true
        with:
          name: thextech-android-${{ steps.extract-version.outputs.ver_name }}-unsigned
          path: android-project/thextech-android-*.apk

      - name: Deploy to builds.wohlsoft.ru
        if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
        continue-on-error: true
        shell: bash
        run: |
          UPLOAD_LIST="set ssl:verify-certificate no;"
          if [[ "${{ steps.signing-check.outputs.available }}" == 'true' ]]; then
              UPLOAD_LIST="${UPLOAD_LIST} put -O "www/android/fdroid/" ./thextech-android-fdroid-${{ steps.extract-version.outputs.ver_name }}.apk;"
          else
              UPLOAD_LIST="${UPLOAD_LIST} put -O "www/android/fdroid/" ./thextech-android-fdroid-${{ steps.extract-version.outputs.ver_name }}-unsigned.apk;"
          fi
          lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

      - name: List Build Directory
        if: always()
        shell: bash
        run: |
          git status
          ls -lR .


================================================
FILE: .github/workflows/blocksds-ci.yml
================================================
name: DSi BlocksDS CI

on:
  push:
    branches:
      - main
      - versus-ci-homebrew
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ubuntu-latest
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404-blocksds:latest
    env:
        WONDERFUL_TOOLCHAIN: /opt/wonderful
        BLOCKSDS: /opt/wonderful/thirdparty/blocksds/core
        BLOCKSDSEXT: /opt/wonderful/thirdparty/blocksds/external
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "DSi BlocksDS build",

            extra_options: "-DCMAKE_TOOLCHAIN_FILE=$BLOCKSDS/cmake/BlocksDSi.cmake -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON",
            extra_path: "/opt/wonderful/bin",

            deps_cmdline: "echo 'BlocksDS SDK is already pre-installed'",

            generator: "Ninja",
            build_type: "RelWithDebInfo",
            executable_name: "thextech",
            subdir_name: "thextech-dsi",
            upload_directory: "www/dsi/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Configure
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
            export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi

        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
            export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi

        cmake --build build --target all -j4

    - name: Check codesize and RAM usage
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        size build/output/bin/thextech.elf

    - name: Create Package
      if: success()
      shell: bash
      run: |
        cd build
        mkdir package
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        cat ../docs/README_DSI.md ../README.md >> "package/${{ matrix.config.subdir_name }}/README.md"
        cp thextech.nds "package/${{ matrix.config.subdir_name }}/"
        cd package
        zip -9 -r "thextech-blocksds-${BRANCH_NAME}.zip" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
            export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi

        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.zip; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/emscripten.yml
================================================
name: Emscripten CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-emscripten
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ${{ matrix.config.os }}
    strategy:
      fail-fast: false
      matrix:
        config:
        # ======================================= Adventures of Demo =======================================
        # The side game about Demo and siblings from the A2XT universe by raocow and his fan community.
        - {
            name: "Adventures of Demo",
            os: ubuntu-24.04,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=advdemo \
            -DTHEXTECH_GAME_NAME_TITLE=\"Adventures of Demo - Web Edition\" \
            -DTHEXTECH_CREDITS_URL=\"wohlsoft.ru\" \
            -DTHEXTECH_CREDITS_TITLE=\"Adventures of Demo\" \
            -DTHEXTECH_MANIFEST_NAME=\"AoD on TheXTech ${THEXTECH_VERSION_STRING}\" \
            -DTHEXTECH_MANIFEST_ID=\"wohlsoft-aod-thextech\" \
            -DTHEXTECH_MANIFEST_DESC=\"Play AoD on TheXTech ${THEXTECH_VERSION_STRING}\" \
            -DTHEXTECH_DEPLOY_URL=\"https://wohlsoft.ru/projects/TheXTech/aod-on-web-debug/\"",

            deps_cmdline: "sudo apt-get update -qq \
            && sudo apt-get install -qq cmake ninja-build cmake ninja-build lftp",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name: "advdemo",
            assets_url: "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z",
            subdir_name: "thextech-adventures-of-demo",
            package_filename_game: "adventures-of-demo",
            upload_directory: "www/webassembly/",
            deploy_directory: "www/webassembly/debug-deploy/aod-on-web-debug"
          }

        # ======================================= Super Mario Bros. X - a fan-game =======================================
        # Was made in 2009 by Andrew Spinks "Redigit", and supported up to 2011 by it's original author.
        - {
            name: "Super Mario Bros. X",
            os: ubuntu-24.04,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=smbx \
            -DTHEXTECH_GAME_NAME_TITLE=\"Super Mario Bros. X - Web Edition\" \
            -DTHEXTECH_CREDITS_URL=\"www.SuperMarioBrosX.org\" \
            -DTHEXTECH_CREDITS_TITLE=\"Super Mario Bros. X\" \
            -DTHEXTECH_MANIFEST_NAME=\"SMBX on TheXTech ${THEXTECH_VERSION_STRING}\" \
            -DTHEXTECH_MANIFEST_ID=\"wohlsoft-smbx-thextech\" \
            -DTHEXTECH_MANIFEST_DESC=\"Play SMBX on TheXTech ${THEXTECH_VERSION_STRING}\" \
            -DTHEXTECH_DEPLOY_URL=\"https://wohlsoft.ru/projects/TheXTech/smbx-on-web-debug/\"",

            deps_cmdline: "sudo apt-get update -qq \
            && sudo apt-get install -qq cmake ninja-build cmake ninja-build lftp",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name: "smbx",
            assets_url: "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-smbx13-assets-full.7z",
            subdir_name: "thextech-super-mario-bros-x",
            package_filename_game: "super-mario-bros-x",
            upload_directory: "www/webassembly/",
            deploy_directory: "www/webassembly/debug-deploy/smbx-on-web-debug"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        # Pull submodules
        git submodule update --init --recursive

    - name: Install emscripten
      run: |
        cd ..
        git clone https://github.com/emscripten-core/emsdk.git
        cd emsdk
        ./emsdk install latest
        ./emsdk activate latest

    - name: Download assets
      shell: bash
      run: wget -d -nv -t 5 -O assets.7z "${{ matrix.config.assets_url }}"

    - name: Unpack assets
      shell: bash
      run: |
        mkdir -p assets
        cd assets
        7z x ../assets.7z
        cd ..
        rm assets.7z

    - name: Apply update to translations
      shell: bash
      run: |
        ASSETS_ROOT="$PWD/assets"
        cd .github/ci-helper
        bash translate_update.sh "${ASSETS_ROOT}"
        cd ../..

    - name: Configure
      shell: bash
      run: |
        source ../emsdk/emsdk_env.sh
        emcmake cmake -B build -G "${{ matrix.config.generator }}" \
            -DPGE_PRELOAD_ENVIRONMENT="`pwd`/assets" \
            -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        source ../emsdk/emsdk_env.sh
        emmake cmake --build build --target all

    - name: Create Package
      if: success()
      shell: bash
      run: |
        cd build
        mkdir package
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        cp ../README.md "package/${{ matrix.config.subdir_name }}/"
        cp ../README.RUS.md "package/${{ matrix.config.subdir_name }}/"
        cp ../README.ESP.md "package/${{ matrix.config.subdir_name }}/"
        cp output/bin/* "package/${{ matrix.config.subdir_name }}/"
        cd package
        tar -cvzf "thextech-${{ matrix.config.package_filename_game }}-webassembly-${BRANCH_NAME}.tar.gz" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.tar.gz
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
            export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.tar.gz; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done

        UPLOAD_LIST="${UPLOAD_LIST} rm -rf ${{ matrix.config.deploy_directory }}-next;"
        UPLOAD_LIST="${UPLOAD_LIST} mkdir ${{ matrix.config.deploy_directory }}-next;"
        for q in ./build/output/bin/*; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.deploy_directory }}-next/ $q;"
        done

        UPLOAD_LIST="${UPLOAD_LIST} rm -rf ${{ matrix.config.deploy_directory }}-prev;"
        UPLOAD_LIST="${UPLOAD_LIST} mv ${{ matrix.config.deploy_directory }} ${{ matrix.config.deploy_directory }}-prev;"
        UPLOAD_LIST="${UPLOAD_LIST} mv ${{ matrix.config.deploy_directory }}-next ${{ matrix.config.deploy_directory }};"
        UPLOAD_LIST="${UPLOAD_LIST} rm -rf ${{ matrix.config.deploy_directory }}-prev;"

        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/flatpak.yml
================================================
name: Flatpak CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci
      - versus-ci-flatpak
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: Flatpak for ${{ matrix.arch.name }}
    runs-on: ${{ matrix.arch.runs_on }}
    container:
      image: ${{ matrix.arch.image }}
      options: --privileged
    strategy:
      fail-fast: true
      matrix:
        arch:
        - {
            name: "x86-64",
            id: "x86_64",
#            sdk_ver: "22.08",
            runs_on: "ubuntu-latest",
            image: "ghcr.io/thextech/wohlnet-ci-ubuntu2204:latest"
          }
        - {
            name: "arm64",
            id: "aarch64",
#            sdk_ver: "22.08",
            runs_on: "ubuntu-24.04-arm",
            image: "ghcr.io/thextech/wohlnet-ci-ubuntu2204-arm64:latest"
          }
    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

#    - name: Install Ubuntu Dependencies
#      shell: bash
#      run: |
#        apt update --fix-missing -y
#        apt upgrade -y
#
#        apt install -y flatpak flatpak-builder p7zip-full git lftp
#
#    - name: Install flatpak Dependencies
#      shell: bash
#      run: |
#        flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
#        flatpak install -y flathub org.freedesktop.Platform/${{ matrix.arch.id }}/${{ matrix.arch.sdk_ver }} org.freedesktop.Sdk/${{ matrix.arch.id }}/${{ matrix.arch.sdk_ver }}

    - uses: TheXTech/branch-name@v0.1


    - uses: TheXTech/checkout@v0.1

    - name: Pull submodules
      shell: bash
      run: |
        git config --global --add safe.directory '*'
        git submodule update --init --recursive

    - name: Create flatpak manifest YML
      id: make-yml
      shell: bash
      run: |
        export REPO_PATH="$(pwd)"
        export REPO_PATH_SED="$(pwd | sed 's_/_\\/_g')"
        export BRANCH_NAME_SED="$(echo $BRANCH_NAME | sed 's_/_\\/_g')"
        cd ..
        cat $REPO_PATH/resources/flatpak/build.yml \
          | sed "s/- type: git/- type: dir/" \
          | sed "s/url: https:.*/path: $REPO_PATH_SED/" \
          | sed "s/OVERRIDE_GIT_BRANCH=/OVERRIDE_GIT_BRANCH=$BRANCH_NAME_SED/" \
          | tee ci-build.yml

    - name: Build flatpak
      shell: bash
      run: |
        cd ..
        flatpak-builder --arch=${{ matrix.arch.id }} --force-clean --repo=temp_repo temp_build ci-build.yml

    - name: Create bundle
      shell: bash
      run: |
        mkdir -p package
        # ru.wohlsoft.TheXTech is the package id, and dev is the branch
        flatpak build-bundle --arch=${{ matrix.arch.id }} ../temp_repo package/thextech-${{ matrix.arch.name }}.flatpak ru.wohlsoft.TheXTech dev

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: package/thextech-${{ matrix.arch.name }}.flatpak
        name: TheXTech (${{ matrix.arch.name }})

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        cd package
        mv "thextech-${{ matrix.arch.name }}.flatpak" "thextech-${BRANCH_NAME}-${{ matrix.arch.name }}.flatpak"

        UPLOAD_LIST="set ssl:verify-certificate no;"
        UPLOAD_LIST="${UPLOAD_LIST} put -O www/flatpak thextech-${BRANCH_NAME}-${{ matrix.arch.name }}.flatpak;"

        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}



================================================
FILE: .github/workflows/homebrew-assets-ci.yml
================================================
name: Homebrew Assets CI

on:
  push:
    branches:
      - main
      - stable*
    paths:
      - .github/workflows/homebrew-assets-ci.yml
      - utils/convertkit/assets-convert-homebrew.py
  pull_request:
    branches:
      - main
    paths:
      - .github/workflows/homebrew-assets-ci.yml
      - utils/convertkit/assets-convert-homebrew.py
  workflow_dispatch:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: ${{ matrix.source.name }} for ${{ matrix.target.name }}
    runs-on: ubuntu-latest
    container: ${{ matrix.target.docker_image }}
    env:
        DEVKITPRO: /opt/devkitpro
    strategy:
      fail-fast: true
      matrix:
        target:
        - {
            name: "3DS",
            id: "3ds",
            docker_image: "devkitpro/devkitarm",
            upload_directory: "www/3ds/"
          }
        - {
            name: "Wii",
            id: "wii",
            docker_image: "devkitpro/devkitppc",
            upload_directory: "www/wii/"
          }
        source:
        # ======================================= Adventures of Demo =======================================
        # The side game about Demo and siblings from the A2XT universe by raocow and his fan community.
        - {
            name: "Adventures of Demo",
            id: "aod",
            assets_url: "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z",
          }
        # ======================================= Super Mario Bros. X - a fan-game =======================================
        # Was made in 2009 by Andrew Spinks "Redigit", and supported up to 2011 by it's original author.
        - {
            name: "Super Mario Bros. X",
            id: "smbx13",
            assets_url: "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-smbx13-assets-full.7z",
          }
    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Resolve artifact filename
      id: res
      shell: bash
      run: |
        echo "filename=assets-${{ matrix.source.id }}-${{ matrix.target.id }}.zip" >> $GITHUB_OUTPUT;
        echo "The target will be named: [assets-${{ matrix.source.id }}-${{ matrix.target.id }}.${{ matrix.target.package_ext }}]"

    - name: Install Debian Dependencies
      shell: bash
      run: |
        apt update
        apt install -y build-essential cmake  \
                       imagemagick ffmpeg     \
                       python3                \
                       p7zip-full             \
                       zip                    \
                       lftp

    - uses: TheXTech/branch-name@v0.1


    - name: Build and install spc2it Dependency
      shell: bash
      continue-on-error: true
      run: |
        git clone https://github.com/ds-sloth/spc2it ../spc2it
        cd ../spc2it
        mkdir build
        cd build
        cmake ..
        make
        cp spc2it /usr/bin/spc2it

    - uses: TheXTech/checkout@v0.1

    - name: Download assets
      shell: bash
      run: wget -d -nv -t 5 -O assets-source.7z "${{ matrix.source.assets_url }}"

    - name: Unpack assets
      shell: bash
      run: |
        mkdir -p assets/source
        cd assets/source
        7z x ../../assets-source.7z
        cd ../..
        rm assets-source.7z

        mkdir -p package

    - name: Apply update to translations
      shell: bash
      run: |
        ASSETS_ROOT="$PWD/assets/source"
        cd .github/ci-helper
        bash translate_update.sh "${ASSETS_ROOT}"
        cd ../..

    - name: Convert assets
      shell: bash
      run: |
        cd assets
        python3 ../utils/convertkit/assets-convert-homebrew.py -t ${{ matrix.target.id }} source target

    - name: Package for 3DS
      if: matrix.target.id == '3ds'
      shell: bash
      run: |
        mkromfs3ds assets/target package/${{ steps.res.outputs.filename }}.romfs
        cd package
        zip -9 "${{ steps.res.outputs.filename }}" "${{ steps.res.outputs.filename }}.romfs"
        cd ..

    - name: Package for Wii
      if: matrix.target.id == 'wii'
      shell: bash
      run: |
        cd assets/target
        zip -9 -r "../../package/${{ steps.res.outputs.filename }}" .
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: package/${{ steps.res.outputs.filename }}
        name: ${{ matrix.source.name }} Assets (${{ matrix.target.name }})

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        cd package

        UPLOAD_LIST="set ssl:verify-certificate no;"
        UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.target.upload_directory }} ${{ steps.res.outputs.filename }};"

        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        cd assets/target
        pwd
        ls -lR


================================================
FILE: .github/workflows/macos-ci.yml
================================================
name: macOS CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-macos
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ${{ matrix.config.os }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "macOS Universal",
            os: macos-15-intel,
            extra_options: "-DTHEXTECH_PRELOAD_ENVIRONMENT_MANUALLY=ON -DTHEXTECH_EXECUTABLE_NAME=\"thextech\"",
            deps_cmdline: "brew install ninja wget p7zip lftp",
            generator: "Ninja",
            build_type: "MinSizeRel",
            upload_directory: "www/macosx/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi

    - name: CI Server's network meta-info
      shell: bash
      run: |
        echo "CI server IP address:"
        wget -q -O - ipinfo.io/ip
        printf "\n"
        wget -d ipinfo.io/ip -O/dev/null 2>&1 |grep ^User-Agent

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Download SMBX assets
      shell: bash
      run: wget -d -nv -t 5 -O smbx13.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-smbx13-assets-full.7z"

    - name: Download AoD assets
      shell: bash
      run: wget -d -nv -t 5 -O aod.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z"

    - name: Unpack all assets
      shell: bash
      run: |
        mkdir -p smbx13
        cd smbx13
        7z x ../smbx13.7z
        cd ..
        rm smbx13.7z
        mkdir -p aod
        cd aod
        7z x ../aod.7z
        cd ..
        rm aod.7z

    - name: Apply update to translations
      shell: bash
      run: |
        ASSETS_ROOT1="$PWD/smbx13"
        ASSETS_ROOT2="$PWD/aod"
        cd .github/ci-helper
        bash translate_update.sh "${ASSETS_ROOT1}"
        bash translate_update.sh "${ASSETS_ROOT2}"
        cd ../..

    - name: Configure (x86_64)
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
          echo "PATH environment: ${PATH}"
        fi
        if [[ "${{ secrets.DISCORD_APP_ID }}" != '' ]]; then
          LOCAL_EXTRA_SETUP="-DTHEXTECH_ENABLE_DISCORD_RPC=ON -DTHEXTECH_DISCORD_APPID=\"${{ secrets.DISCORD_APP_ID }}\""
        fi
        cmake -B build-x64 -G "${{ matrix.config.generator }}" \
              -DCMAKE_OSX_DEPLOYMENT_TARGET="10.9" \
              -DCMAKE_OSX_ARCHITECTURES="x86_64" \
              -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
              ${{ matrix.config.extra_options }} \
              ${LOCAL_EXTRA_SETUP} .

    - name: Build (x86_64)
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        export MAKEFLAGS=--keep-going
        cmake --build build-x64 --config ${{ matrix.config.build_type }} --parallel 3

    - name: Configure (arm64)
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
          echo "PATH environment: ${PATH}"
        fi
        if [[ "${{ secrets.DISCORD_APP_ID }}" != '' ]]; then
          LOCAL_EXTRA_SETUP="-DTHEXTECH_ENABLE_DISCORD_RPC=ON -DTHEXTECH_DISCORD_APPID=\"${{ secrets.DISCORD_APP_ID }}\""
        fi
        cmake -B build-arm -G "${{ matrix.config.generator }}"  \
              -DCMAKE_OSX_DEPLOYMENT_TARGET="11.0" \
              -DCMAKE_OSX_ARCHITECTURES="arm64" \
              -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
              ${{ matrix.config.extra_options }} \
              ${LOCAL_EXTRA_SETUP} .

    - name: Build (arm64)
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        export MAKEFLAGS=--keep-going
        cmake --build build-arm --config ${{ matrix.config.build_type }} --parallel 3

    - name: Merging executible
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        cp -R build-arm/output/bin/TheXTech.app TheXTech.app
        rm TheXTech.app/Contents/MacOS/TheXTech
        lipo -create -output TheXTech.app/Contents/MacOS/TheXTech build-x64/output/bin/TheXTech.app/Contents/MacOS/TheXTech build-arm/output/bin/TheXTech.app/Contents/MacOS/TheXTech
        mkdir TheXTech.app/Contents/Resources/assets

    - name: Executable info
      shell: bash
      run: |
        file TheXTech.app/Contents/MacOS/TheXTech
        otool -L TheXTech.app/Contents/MacOS/TheXTech

    - name: Create Package
      if: success()
      shell: bash
      run: |
        bash .github/ci-helper/pack-game-macos.sh \
            aod \
            "assets/graphics/ui/icon/advdemo.icns" \
            "Adventures of Demo" \
            "thextech-adventures-of-demo-macos-uni-${BRANCH_NAME}.dmg"

        bash .github/ci-helper/pack-game-macos.sh \
            smbx13 \
            "assets/graphics/ui/icon/smbx.icns" \
            "Super Mario Bros. X" \
            "thextech-super-mario-bros-x-macos-uni-${BRANCH_NAME}.dmg"

        bash .github/ci-helper/pack-game-macos.sh \
            none \
            "thextech.icns" \
            "TheXTech" \
            "thextech-macos-uni-${BRANCH_NAME}.zip"

    - name: Upload DMG artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: ./*.dmg
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }} DMG

    - name: Upload ZIP artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: ./*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }} ZIP

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        if ls *.dmg 1> /dev/null 2>&1; then
            for q in *.dmg; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        fi
        if ls *.zip 1> /dev/null 2>&1; then
            for q in *.zip; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        fi
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: Clean-up
      if: always()
      shell: bash
      run: |
        rm -Rf TheXTech.app
        rm -Rf aod
        rm -Rf smbx13

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build-x64
        ls -lR build-arm


================================================
FILE: .github/workflows/portmaster-ci.yml
================================================
name: PortMaster CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci
      - versus-ci-portmaster
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ${{ matrix.config.os }}
    container: ${{ matrix.config.container }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "PortMaster Ubuntu 20.04 aarch64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2004-arm64-cross:latest",

            extra_options: "-DPORTMASTER=ON -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_arm64.cmake",

            deps_cmdline: "echo 'Ubuntu 20 arm64, cross from x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "portmaster",
            upload_directory: "www/portmaster/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Configure
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
          echo "PATH environment: ${PATH}"
        fi
        if [[ "${{ secrets.DISCORD_APP_ID }}" != '' ]]; then
          LOCAL_EXTRA_SETUP="-DTHEXTECH_ENABLE_DISCORD_RPC=ON -DTHEXTECH_DISCORD_APPID=\"${{ secrets.DISCORD_APP_ID }}\""
        fi
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} ${LOCAL_EXTRA_SETUP} .

    - name: Build
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        export MAKEFLAGS=--keep-going
        cmake --build build --config ${{ matrix.config.build_type }} --parallel 4

    - name: List dependent libraries
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        file build/output/bin/thextech
#        ldd build/output/bin/thextech # Not for cross compile!


    - name: Create Package
      if: success()
      id: create_package
      shell: bash
      run: |
        bash .github/ci-helper/pack-game.sh \
            "${{ runner.os }}" \
            "thextech-bin" \
            "thextech${{ matrix.config.executable_name_suffix }}" \
            "thextech-bin-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
            "none"

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.tar.gz
        name: TheXTech PortMaster ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: steps.create_package.outcome == 'success' && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        if [[ "${{ runner.os }}" == 'Windows' ]]; then
            for q in ./build/package/*.7z; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        elif [[ "${{ runner.os }}" == 'Linux' ]]; then
            for q in ./build/package/*.tar.gz; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        fi
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/regression-testing-ci.yaml
================================================
name: Regression Test CI

on:
  push:
    branches:
      - main
      - stable*
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ${{ matrix.config.os }}
    container: ${{ matrix.config.container }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "Ubuntu 24.04 x86_64 (no-SDL)",
            os: ubuntu-24.04,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DTHEXTECH_CLI_BUILD=ON \
            -DTHEXTECH_NO_SDL_BUILD=ON",

            deps_cmdline: "sudo apt-get update -qq \
            && sudo apt-get install -qq cmake ninja-build lftp \
            build-essential",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-24-04-amd64",
            upload_directory: ""
          }
        - {
            name: "Ubuntu 24.04 x86_64 (no-SDL, legacy floats)",
            os: ubuntu-24.04,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DTHEXTECH_CLI_BUILD=ON \
            -DTHEXTECH_NO_SDL_BUILD=ON \
            -DTHEXTECH_FIXED_POINT=OFF",

            deps_cmdline: "sudo apt-get update -qq \
            && sudo apt-get install -qq cmake ninja-build lftp \
            build-essential",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-24-04-amd64-legacy-floats",
            upload_directory: ""
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

#    - name: Download SMBX assets
#      shell: bash
#      run: wget -d -nv -t 5 -O smbx13.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-smbx13-assets-full.7z"
#
#    - name: Download AoD assets
#      shell: bash
#      run: wget -d -nv -t 5 -O aod.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z"
#
#    - name: Unpack all assets
#      shell: bash
#      run: |
#        mkdir -p smbx13
#        cd smbx13
#        7z x ../smbx13.7z
#        cd ..
#        rm smbx13.7z
#        mkdir -p aod
#        cd aod
#        7z x ../aod.7z
#        cd ..
#        rm aod.7z
#
#    - name: Apply update to translations
#      shell: bash
#      run: |
#        ASSETS_ROOT1="$PWD/smbx13"
#        ASSETS_ROOT2="$PWD/aod"
#        cd .github/ci-helper
#        bash translate_update.sh "${ASSETS_ROOT1}"
#        bash translate_update.sh "${ASSETS_ROOT2}"
#        cd ../..

    - name: Configure
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
          echo "PATH environment: ${PATH}"
        fi
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} ${LOCAL_EXTRA_SETUP} .

    - name: Build
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        export MAKEFLAGS=--keep-going
        cmake --build build --config ${{ matrix.config.build_type }} --parallel 3

    - name: List dependent libraries
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        file build/output/bin/thextech
        ldd build/output/bin/thextech

    - name: Check codesize and RAM usage
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        size build/output/bin/thextech

    # TODO: some performance and regression testing on a suite. Wait for wip-archives merge so that it is easy to use a test-suite.

    # - name: Create Package
    #   if: success()
    #   id: create_package
    #   shell: bash
    #   run: |
    #     bash .github/ci-helper/pack-game.sh \
    #         "${{ runner.os }}" \
    #         "thextech-bin" \
    #         "thextech${{ matrix.config.executable_name_suffix }}" \
    #         "thextech-bin-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
    #         "none"

    # - name: Upload artifact
    #   if: success() && runner.os == 'Linux' && config.upload_directory != ''
    #   uses: actions/upload-artifact@v3
    #   continue-on-error: true
    #   with:
    #     path: build/package/*.tar.gz
    #     name: TheXTech ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    # - name: Upload artifact
    #   if: success() && runner.os == 'Windows'
    #   uses: actions/upload-artifact@v3
    #   continue-on-error: true
    #   with:
    #     path: build/package/*.7z
    #     name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    # - name: Deploy to builds.wohlsoft.ru
    #   if: steps.create_package.outcome == 'success' && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true' && config.upload_directory != ''
    #   continue-on-error: true
    #   shell: bash
    #   run: |
    #     if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
    #       export PATH=${{ matrix.config.extra_path }}:${PATH}
    #     fi
    #     UPLOAD_LIST="set ssl:verify-certificate no;"
    #     if [[ "${{ runner.os }}" == 'Windows' ]]; then
    #         for q in ./build/package/*.7z; do
    #             UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
    #         done
    #     elif [[ "${{ runner.os }}" == 'Linux' ]]; then
    #         for q in ./build/package/*.tar.gz; do
    #             UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
    #         done
    #     fi
    #     lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/switch-ci.yml
================================================
name: Switch CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-homebrew
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ubuntu-latest
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404-dkp-vita:latest
    env:
        DEVKITPRO: /opt/devkitpro
        DEVKITA64: /opt/devkitpro/devkitA64
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "Switch build",

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/Switch.cmake \
            -DCMAKE_INSTALL_PREFIX=$DEVKITPRO/portlibs/switch",
            # -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/switch-local

            deps_cmdline: "echo 'DevkitPro SDK is already pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name: "thextech",
            assets_url: "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z",
            subdir_name: "thextech-switch",
            upload_directory: "www/switch/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

#    - name: Install Devkit Pro
#      run: |
#        cd ..
#        sudo chmod 755 /opt
#        if [[ ! -f /usr/local/share/keyring/devkitpro-pub.gpg ]]; then
#            sudo mkdir -p /usr/local/share/keyring/
#            sudo wget -O /usr/local/share/keyring/devkitpro-pub.gpg https://apt.devkitpro.org/devkitpro-pub.gpg
#        fi
#
#        if [[ ! -f /etc/apt/sources.list.d/devkitpro.list ]]; then
#            echo "deb [signed-by=/usr/local/share/keyring/devkitpro-pub.gpg] https://apt.devkitpro.org stable main" | sudo tee -a /etc/apt/sources.list.d/devkitpro.list
#        fi
#
#        sudo apt-get update -qq
#        sudo apt-get install -qq devkitpro-pacman
#
#        sudo dkp-pacman --noconfirm -Sy
#        sudo dkp-pacman --noconfirm -Syu
#        sudo dkp-pacman --noconfirm -Sy switch-dev switch-libpng switch-libjpeg-turbo switch-zlib switch-tools switch-cmake switch-mesa switch-libdrm_nouveau switch-glm switch-glad

#    - name: Install modified SDL2
#      run: |
#        cd ..
#        git clone https://github.com/Wohlstand/SDL.git -b switch-sdl2-2.0.14-dev --depth 1 SDL2
#        cd SDL2
#        mkdir build
#        cd build
#        cmake -G Ninja -DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/Switch.cmake -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/switch-local -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/switch-local ..
#        cmake --build . --target all -j4
#        sudo cmake --build . --target install

    - name: Configure
      shell: bash
      run: |
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        cmake --build build --target all -j4

    - name: Create Package
      if: success()
      shell: bash
      run: |
        cd build
        mkdir package
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        cat ../docs/README_SWITCH.md ../README.md >> "package/${{ matrix.config.subdir_name }}/README.md"
        cp output/bin/thextech.nro "package/${{ matrix.config.subdir_name }}/"
        cd package
        zip -9 -r "thextech-switch-${BRANCH_NAME}.zip" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.zip; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/sync-langs.yml
================================================
name: Languages sync CI

on:
  push:
    branches:
      - main
      - versus-ci-langsync
    paths:
      - .github/workflows/sync-langs.yml
      - .github/ci-helper/translate_sync_assets.sh
      - .github/ci-helper/translate_update.sh
      - .github/ci-helper/translate_patcher.py
      - resources/languages/**.json
      - android-project/thextech/src/main/res/values/strings.xml
      - android-project/thextech/src/main/res/values/arrays.xml
      - android-project/thextech/src/main/res/values-**/strings.xml
      - android-project/thextech/src/main/res/values-**/arrays.xml
  workflow_dispatch:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: Syncing languages
    runs-on: ubuntu-latest
    permissions:
      contents: write
      packages: read
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404:latest
    strategy:
      fail-fast: true
    steps:
    - uses: TheXTech/branch-name@v0.1

    - uses: TheXTech/checkout@v0.1

    - name: Adding Gitea SSH key
      shell: bash
      env:
        SSH_KEY: ${{secrets.GITEA_SYNCBOT_SSH_KEY}}
      run: |
        mkdir ~/.ssh
        chmod 700 ~/.ssh
        eval `ssh-agent -s`
        ssh-add - <<< "${SSH_KEY}"
        ls -la ~/.ssh/
        ssh -o StrictHostKeyChecking=no -T git@gitea.wohlsoft.ru
        echo "SSH_AUTH_SOCK=${SSH_AUTH_SOCK}" >> $GITHUB_ENV
        git config --global user.email "ci@example.ru"
        git config --global user.name "Language Sync Bot"

    - name: Copy updated translations to stable branch
      shell: bash
      env:
        GIT_AUTHOR: "github-actions[bot] <github-actions[bot]@users.noreply.github.com>"
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }}
      run: |
        bash .github/ci-helper/translate_sync_to_stable.sh

    - name: Apply update to all the translations
      shell: bash
      env:
        GIT_AUTHOR: ${{secrets.GITEA_SYNCBOT_AUTHOR}}
      run: |
        bash .github/ci-helper/translate_sync_assets.sh


================================================
FILE: .github/workflows/ubuntu-deb-ci.yml
================================================
name: Ubuntu DEB CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci
      - versus-ci-ubuntu
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ${{ matrix.config.os }}
    container: ${{ matrix.config.container }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "DEB Ubuntu 14.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1404-64bit:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=OFF -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_USE_ANGLE_TRANSLATOR=OFF \
            -DCMAKE_C_COMPILER=gcc-8 \
            -DCMAKE_CXX_COMPILER=g++-8 \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=amd64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.19), libpng12-0 (>= 1.2.50), libjpeg-turbo8 (>= 1.3.0) | libturbojpeg0 (>= 1.3.0), libasound2 (>= 1.0.27), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Ubuntu 14 x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-14-04-amd64",
            upload_directory: "www/ubuntu-14-04/"
          }
        - {
            name: "DEB Ubuntu 14.04 32bit",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1404-32bit:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_FREEIMAGE_SYSTEM_LIBS=OFF \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_USE_ANGLE_TRANSLATOR=OFF \
            -DCMAKE_C_COMPILER=/usr/bin/i686-linux-gnu-gcc-8 \
            -DCMAKE_CXX_COMPILER=/usr/bin/i686-linux-gnu-g++-8 \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=i386 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.19), libpng12-0 (>= 1.2.50), libjpeg-turbo8 (>= 1.3.0) | libturbojpeg0 (>= 1.3.0), libasound2 (>= 1.0.27), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Ubuntu 14 x86_32, everything pre-installed'; ln -sf /usr/bin/i686-linux-gnu-gcc-8 /usr/bin/gcc; ln -sf /usr/bin/i686-linux-gnu-g++-8 /usr/bin/g++;",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-14-04-i386",
            upload_directory: "www/ubuntu-14-04/"
          }
        - {
            name: "DEB Ubuntu 16.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1604-64bit:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=OFF -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=amd64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.23), libpng12-0 (>= 1.2.54), libjpeg-turbo8 (>= 1.4.2) | libturbojpeg0 (>= 1.4.2), libasound2 (>= 1.1.0), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Ubuntu 16 x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-16-04-amd64",
            upload_directory: "www/ubuntu-16-04/"
          }
        - {
            name: "DEB Ubuntu 16.04 32bit",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1604-32bit:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_FREEIMAGE_SYSTEM_LIBS=OFF \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=i386 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.23), libpng12-0 (>= 1.2.54), libjpeg-turbo8 (>= 1.4.2) | libturbojpeg0 (>= 1.4.2), libasound2 (>= 1.1.0), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\" \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_x32.cmake",

            deps_cmdline: "echo 'Ubuntu 16 x86_32, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-16-04-i386",
            upload_directory: "www/ubuntu-16-04/"
          }
        - {
            name: "DEB Ubuntu 16.04 armhf",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1604-armhf-cross:latest",
            cross: true,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_FREEIMAGE_SYSTEM_LIBS=OFF \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=armhf \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.23), libpng12-0 (>= 1.2.54), libjpeg-turbo8 (>= 1.4.2) | libturbojpeg0 (>= 1.4.2), libasound2 (>= 1.1.0), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\" \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_armhf.cmake",

            deps_cmdline: "echo 'Ubuntu 16 armhf, cross from x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-16-04-armhf",
            upload_directory: "www/ubuntu-16-04/"
          }
        - {
            name: "DEB Ubuntu 18.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1804:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=amd64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.27), libsdl2-2.0-0 (>= 2.0.8), libpng16-16 (>= 1.6.34), libjpeg-turbo8 (>= 1.5.2) | libturbojpeg0 (>= 1.5.2), libasound2 (>= 1.1.3), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Ubuntu 18 x86_32, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-18-04-amd64",
            upload_directory: "www/ubuntu-18-04/"
          }
        - {
            name: "DEB Ubuntu 20.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2004:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=amd64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.31), libsdl2-2.0-0 (>= 2.0.10), libpng16-16 (>= 1.6.37), libjpeg-turbo8 (>= 2.0.3) | libturbojpeg0 (>= 2.0.3), libasound2 (>= 1.2.2), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Ubuntu 20 x86_32, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-20-04-amd64",
            upload_directory: "www/ubuntu-20-04/"
          }
        - {
            name: "DEB Ubuntu 20.04 arm64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2004-arm64-cross:latest",
            cross: true,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=arm64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.31), libsdl2-2.0-0 (>= 2.0.10), libpng16-16 (>= 1.6.37), libjpeg-turbo8 (>= 2.0.3) | libturbojpeg0 (>= 2.0.3), libasound2 (>= 1.2.2), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\" \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_arm64.cmake",

            deps_cmdline: "echo 'Ubuntu 20 arm64, cross from x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-20-04-aarch64",
            upload_directory: "www/ubuntu-20-04/"
          }
        - {
            name: "DEB Ubuntu 20.04 armhf",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2004-armhf-cross:latest",
            cross: true,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=armhf \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.31), libsdl2-2.0-0 (>= 2.0.10), libpng16-16 (>= 1.6.37), libjpeg-turbo8 (>= 2.0.3) | libturbojpeg0 (>= 2.0.3), libasound2 (>= 1.2.2), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\" \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_armhf.cmake",

            deps_cmdline: "echo 'Ubuntu 20 armhf, cross from x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-20-04-armhf",
            upload_directory: "www/ubuntu-20-04/"
          }
        - {
            name: "DEB Ubuntu 22.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2204:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=amd64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.35), libsdl2-2.0-0 (>= 2.0.20), libpng16-16 (>= 1.6.37), libjpeg-turbo8 (>= 2.1.2) | libturbojpeg0 (>= 2.1.2), libasound2 (>= 1.2.6), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Ubuntu 22 x86_32, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-22-04-amd64",
            upload_directory: "www/ubuntu-22-04/"
          }
        - {
            name: "DEB Ubuntu 22.04 aarch64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2204-arm64-cross:latest",
            cross: true,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=arm64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.35), libsdl2-2.0-0 (>= 2.0.20), libpng16-16 (>= 1.6.37), libjpeg-turbo8 (>= 2.1.2) | libturbojpeg0 (>= 2.1.2), libasound2 (>= 1.2.6), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\" \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_arm64.cmake",

            deps_cmdline: "echo 'Ubuntu 22 arm64, cross from x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-22-04-aarch64",
            upload_directory: "www/ubuntu-22-04/"
          }
        - {
            name: "DEB Ubuntu 24.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2404:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=amd64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.38), libsdl2-2.0-0 (>= 2.30.0), libpng16-16 (>= 1.6.43), libjpeg-turbo8 (>= 2.1.5), libasound2 (>= 1.2.10), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Ubuntu 24 x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-24-04-amd64",
            upload_directory: "www/ubuntu-24-04/"
          }
        - {
            name: "DEB Debian 13 (Trixie) x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-debian13:latest",
            cross: false,

            extra_options: "-DPGE_SHARED_SDLMIXER=OFF -DUSE_SYSTEM_SDL2=ON -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
            -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=MinSizeRel \
            -DTHEXTECH_PACKAGE_NAME=\"thextech-bin\" \
            -DTHEXTECH_INSTALLER_PACKAGE_NAME=\"thextech-bin\" \
            -DCPACK_GENERATOR=DEB \
            -DCPACK_DEBIAN_PACKAGE_HOMEPAGE=\"https://wohlsoft.ru\" \
            -DCPACK_DEBIAN_PACKAGE_RELEASE=${GITHUB_RUN_NUMBER} \
            -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=amd64 \
            -DCPACK_DEBIAN_PACKAGE_DEPENDS=\"libc6 (>= 2.38), libsdl2-2.0-0 (>= 2.30.0), libpng16-16 (>= 1.6.43), libturbojpeg0 (>= 2.1.5), libasound2 (>= 1.2.10), libpulse0\" \
            -DCPACK_DEBIAN_PACKAGE_DESCRIPTION=\"TheXTech - the modern C++ port and successor of the SMBX engine\"",

            deps_cmdline: "echo 'Debian 13 Trixie x86_64, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "debian-13-trixie-amd64",
            upload_directory: "www/debian-13/"
          }

    steps:
    - name: Host info
      shell: bash
      run: |
        uname -a
        cat /proc/cpuinfo

    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1

    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Configure
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
          echo "PATH environment: ${PATH}"
        fi
        if [[ "${{ secrets.DISCORD_APP_ID }}" != '' ]]; then
          LOCAL_EXTRA_SETUP="-DTHEXTECH_ENABLE_DISCORD_RPC=ON -DTHEXTECH_DISCORD_APPID=\"${{ secrets.DISCORD_APP_ID }}\""
        fi
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} ${LOCAL_EXTRA_SETUP} .

    - name: Build
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        export MAKEFLAGS=--keep-going
        cmake --build build --config ${{ matrix.config.build_type }} --parallel 3

    - name: List dependent libraries
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        file build/output/bin/${{ matrix.config.executable_name }}
        if [[ "${{ matrix.config.cross}}" != true ]]; then
            ldd build/output/bin/${{ matrix.config.executable_name }}
        fi

    - name: Create DEB packages
      shell: bash
      id: create_package
      if: success()
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        cd build
        cpack .
        mv *.deb thextech-bin-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}.deb
        cd ..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/*.deb
        name: TheXTech ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: steps.create_package.outcome == 'success' && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/*.deb; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/ubuntu-tar-ci.yml
================================================
name: Ubuntu TAR CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci
      - versus-ci-ubuntu
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ${{ matrix.config.os }}
    container: ${{ matrix.config.container }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "TAR Ubuntu 14.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1404-64bit:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_USE_ANGLE_TRANSLATOR=OFF \
            -DCMAKE_C_COMPILER=gcc-8 \
            -DCMAKE_CXX_COMPILER=g++-8",

            deps_cmdline: "echo 'Ubuntu 14 x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-14-04-amd64",
            upload_directory: "www/ubuntu-14-04/"
          }
        - {
            name: "TAR Ubuntu 14.04 x86_64 (legacy floats)",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1404-64bit:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_USE_ANGLE_TRANSLATOR=OFF \
            -DTHEXTECH_FIXED_POINT=OFF \
            -DCMAKE_C_COMPILER=gcc-8 \
            -DCMAKE_CXX_COMPILER=g++-8",

            deps_cmdline: "echo 'Ubuntu 14 x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-14-04-amd64-legacy-floats",
            upload_directory: "www/ubuntu-14-04/"
          }
        - {
            name: "TAR Ubuntu 14.04 32bit",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1404-32bit:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_USE_ANGLE_TRANSLATOR=OFF \
            -DCMAKE_C_COMPILER=/usr/bin/i686-linux-gnu-gcc-8 \
            -DCMAKE_CXX_COMPILER=/usr/bin/i686-linux-gnu-g++-8",

            deps_cmdline: "echo 'Ubuntu 14 x86_32, everything pre-installed'; ln -sf /usr/bin/i686-linux-gnu-gcc-8 /usr/bin/gcc; ln -sf /usr/bin/i686-linux-gnu-g++-8 /usr/bin/g++;",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-14-04-i386",
            upload_directory: "www/ubuntu-14-04/"
          }
        - {
            name: "TAR Ubuntu 16.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1604-64bit:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF",

            deps_cmdline: "echo 'Ubuntu 16 x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-16-04-amd64",
            upload_directory: "www/ubuntu-16-04/"
          }
        - {
            name: "TAR Ubuntu 16.04 x86_64 (legacy floats)",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1604-64bit:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DTHEXTECH_FIXED_POINT=OFF",

            deps_cmdline: "echo 'Ubuntu 16 x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-16-04-amd64-legacy-floats",
            upload_directory: "www/ubuntu-16-04/"
          }
        - {
            name: "TAR Ubuntu 16.04 32bit",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1604-32bit:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_x32.cmake",

            deps_cmdline: "echo 'Ubuntu 16 x86_32, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-16-04-i386",
            upload_directory: "www/ubuntu-16-04/"
          }
        - {
            name: "TAR Ubuntu 16.04 armhf",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1604-armhf-cross:latest",
            cross: true,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_armhf.cmake",

            deps_cmdline: "echo 'Ubuntu 16 armhf, cross from x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-16-04-armhf",
            upload_directory: "www/ubuntu-16-04/"
          }
        - {
            name: "TAR Ubuntu 18.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu1804:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DTHEXTECH_BUILD_GL_ES_LEGACY=OFF",

            deps_cmdline: "echo 'Ubuntu 18 x86_32, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-18-04-amd64",
            upload_directory: "www/ubuntu-18-04/"
          }
        - {
            name: "TAR Ubuntu 20.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2004:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF",

            deps_cmdline: "echo 'Ubuntu 20 x86_32, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-20-04-amd64",
            upload_directory: "www/ubuntu-20-04/"
          }
        - {
            name: "TAR Ubuntu 20.04 aarch64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2004-arm64-cross:latest",
            cross: true,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_arm64.cmake",

            deps_cmdline: "echo 'Ubuntu 20 arm64, cross from x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-20-04-aarch64",
            upload_directory: "www/ubuntu-20-04/"
          }
        - {
            name: "TAR Ubuntu 20.04 armhf",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2004-armhf-cross:latest",
            cross: true,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_armhf.cmake",

            deps_cmdline: "echo 'Ubuntu 20 armhf, cross from x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-20-04-armhf",
            upload_directory: "www/ubuntu-20-04/"
          }
        - {
            name: "TAR Ubuntu 22.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2204:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF",

            deps_cmdline: "echo 'Ubuntu 22 x86_32, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-22-04-amd64",
            upload_directory: "www/ubuntu-22-04/"
          }
        - {
            name: "TAR Ubuntu 22.04 aarch64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2204-arm64-cross:latest",
            cross: true,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_linux_gcc_toolchain_arm64.cmake",

            deps_cmdline: "echo 'Ubuntu 22 arm64, cross from x86_64, everything pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-22-04-aarch64",
            upload_directory: "www/ubuntu-22-04/"
          }
        - {
            name: "TAR Ubuntu 24.04 x86_64",
            os: ubuntu-latest,
            container: "ghcr.io/thextech/wohlnet-ci-ubuntu2404:latest",
            cross: false,

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DUSE_STATIC_LIBC=ON \
            -DUSE_SYSTEM_LIBS=OFF \
            -DUSE_SYSTEM_SDL2=OFF \
            -DUSE_SHARED_FREEIMAGE=OFF \
            -DPGE_SHARED_SDLMIXER=OFF",

            deps_cmdline: "echo 'Ubuntu 24 x86_32, everything pre-installed'",

            executable_name: "thextech",
            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name_suffix: "",
            package_filename_suffix: "ubuntu-24-04-amd64",
            upload_directory: "www/ubuntu-24-04/"
          }

    steps:
    - name: Host info
      shell: bash
      run: |
        uname -a
        cat /proc/cpuinfo

    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Download SMBX assets
      shell: bash
      run: wget -d -nv -t 5 -O smbx13.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-smbx13-assets-full.7z"

    - name: Download AoD assets
      shell: bash
      run: wget -d -nv -t 5 -O aod.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z"

    - name: Unpack all assets
      shell: bash
      run: |
        mkdir -p smbx13
        cd smbx13
        7z x ../smbx13.7z
        cd ..
        rm smbx13.7z
        mkdir -p aod
        cd aod
        7z x ../aod.7z
        cd ..
        rm aod.7z

    - name: Apply update to translations
      shell: bash
      run: |
        ASSETS_ROOT1="$PWD/smbx13"
        ASSETS_ROOT2="$PWD/aod"
        cd .github/ci-helper
        bash translate_update.sh "${ASSETS_ROOT1}"
        bash translate_update.sh "${ASSETS_ROOT2}"
        cd ../..

    - name: Configure
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
          echo "PATH environment: ${PATH}"
        fi
        if [[ "${{ secrets.DISCORD_APP_ID }}" != '' ]]; then
          LOCAL_EXTRA_SETUP="-DTHEXTECH_ENABLE_DISCORD_RPC=ON -DTHEXTECH_DISCORD_APPID=\"${{ secrets.DISCORD_APP_ID }}\""
        fi
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} ${LOCAL_EXTRA_SETUP} .

    - name: Build
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        export MAKEFLAGS=--keep-going
        cmake --build build --config ${{ matrix.config.build_type }} --parallel 3

    - name: List dependent libraries
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        file build/output/bin/thextech
        if [[ "${{ matrix.config.cross}}" != true ]]; then
            ldd build/output/bin/thextech
        fi

    - name: Create Package
      if: success()
      id: create_package
      shell: bash
      # ======================================= Adventures of Demo =======================================
      # The side game about Demo and siblings from the A2XT universe by raocow and his fan community.
      # ======================================= Super Mario Bros. X - a fan-game =======================================
      # Was made in 2009 by Andrew Spinks "Redigit", and supported up to 2011 by it's original author.
      run: |
        bash .github/ci-helper/pack-game.sh \
            "${{ runner.os }}" \
            "thextech-adventures-of-demo" \
            "advdemo${{ matrix.config.executable_name_suffix }}" \
            "thextech-adventures-of-demo-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
            "aod"

        bash .github/ci-helper/pack-game.sh \
            "${{ runner.os }}" \
            "thextech-super-mario-bros-x" \
            "smbx${{ matrix.config.executable_name_suffix }}" \
            "thextech-super-mario-bros-x-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
            "smbx13"

        bash .github/ci-helper/pack-game.sh \
            "${{ runner.os }}" \
            "thextech-bin" \
            "thextech${{ matrix.config.executable_name_suffix }}" \
            "thextech-bin-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
            "none"

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.tar.gz
        name: TheXTech ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: steps.create_package.outcome == 'success' && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        if [[ "${{ runner.os }}" == 'Windows' ]]; then
            for q in ./build/package/*.7z; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        elif [[ "${{ runner.os }}" == 'Linux' ]]; then
            for q in ./build/package/*.tar.gz; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        fi
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/vita-ci.yml
================================================
name: Vita CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-homebrew
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ubuntu-latest
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404-dkp-vita:latest
    env:
        VITASDK: /usr/local/vitasdk
    strategy:
      fail-fast: true
      matrix:
        config:
        - {
            name: "Vita build",

            extra_options: "-DCMAKE_TOOLCHAIN_FILE=$VITASDK/share/vita.toolchain.cmake",

            deps_cmdline: "echo 'Vita SDK is already pre-installed'",

            generator: "Unix Makefiles",
            build_type: "MinSizeRel",
            executable_name: "thextech",
            assets_url: "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z",
            subdir_name: "thextech-vita",
            upload_directory: "www/vita/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1

    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

# NOTE: 2023-08-11 now using container including Vita SDK
#    - name: Install Vita SDK
#      run: |
#        cd ..
#        export VITASDK=/usr/local/vitasdk
#        export PATH=$VITASDK/bin:$PATH
#        git clone https://github.com/vitasdk/vdpm
#        cd vdpm
#        ./bootstrap-vitasdk.sh
#        ./install-all.sh || echo A library from vitasdk failed to install.

# NOTE: 2/13/2022 Current Vita version does not use cglm or vitaGL renderer. All is handled by SDL2 at the moment.
#    - name: Install cglm
#      run: |
#        cd ..
#        export PATH=$VITASDK/bin:$PATH
#        git clone https://github.com/recp/cglm.git
#        cd cglm
#        sed -i "s|-Werror||g" CMakeLists.txt
#        cmake -B build-vita -G Ninja -DCMAKE_INSTALL_PREFIX=$VITASDK/arm-vita-eabi -DCGLM_STATIC=ON -DCGLM_SHARED=OFF -DCMAKE_BUILD_TYPE=MinSizeRel -DCMAKE_TOOLCHAIN_FILE=/usr/local/vitasdk/share/vita.toolchain.cmake .
#        cmake --build build-vita --target all
#        cmake --build build-vita --target install

#    - name: Install Latest vitaGL
#      run: |
#        cd ..
#        export PATH=$VITASDK/bin:$PATH
#        git clone https://github.com/Rinnegatamante/vitaGL.git
#        cd vitaGL
#        NO_DEBUG=1 NO_TEX_COMBINER=1 make
#        make install

# no longer distributing packed Vita builds
#    - name: Download assets
#      uses: carlosperate/download-file-action@v2
#      with:
#        file-url: "${{ matrix.config.assets_url }}"
#        file-name: assets.7z
#
#    - name: Unpack assets
#      shell: bash
#      run: |
#        mkdir -p assets
#        cd assets
#        7z x ../assets.7z
#        cd ..
#        rm assets.7z

    - name: Configure
      shell: bash
      run: |
        export PATH=$VITASDK/bin:$PATH
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        export PATH=$VITASDK/bin:$PATH
        cmake --build build --target all -j4

    - name: Create Package
      if: success()
      id: create_package
      shell: bash
      run: |
        cd build
        mkdir package
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        cat ../docs/README_VITA.md ../README.md >> "package/${{ matrix.config.subdir_name }}/README.md"
        cat ../docs/README_VITA.RUS.md ../README.RUS.md >> "package/${{ matrix.config.subdir_name }}/README.RUS.md"
        cat ../docs/README_VITA.ESP.md ../README.ESP.md >> "package/${{ matrix.config.subdir_name }}/README.ESP.md"
        cp thextech.vpk "package/${{ matrix.config.subdir_name }}/"
        cd package
        zip -9 -r "thextech-vita-${BRANCH_NAME}.zip" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: steps.create_package.outcome == 'success' && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.zip; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        if [ "${BRANCH_NAME}" = "main" ]; then
          UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} build/thextech.vpk -o thextech-vitadb-nightly.vpk;"
        fi
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/wii-ci.yml
================================================
name: Wii CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-homebrew
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ubuntu-latest
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404-dkp-vita:latest
    env:
        DEVKITPRO: /opt/devkitpro
        DEVKITPPC: /opt/devkitpro/devkitPPC
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "Wii build",

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/Wii.cmake \
            -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/wii-local \
            -DCMAKE_INSTALL_PREFIX=$DEVKITPRO/portlibs/wii \
            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON",

            deps_cmdline: "echo 'DevkitPro SDK is already pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name: "thextech",
            subdir_name: "thextech-wii",
            upload_directory: "www/wii/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Install modified SDL2
      run: |
        cd ..
        git clone https://github.com/Wohlstand/SDL.git -b wii-support --depth 1 SDL2
        cd SDL2
        mkdir build
        cd build
        cmake -G Ninja \
            -DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/Wii.cmake \
            -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/wii-local \
            -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/wii-local \
            -DSDL_ALTIVEC=OFF \
            -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
            ..
        cmake --build . --target all -j4
        sudo cmake --build . --target install

    - name: Configure
      shell: bash
      run: |
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        cmake --build build --target all -j4

    - name: Check codesize and RAM usage
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        size build/output/bin/thextech.elf

    - name: Create Package
      if: success()
      shell: bash
      run: |
        cd build
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        mv "package/meta.xml" "package/${{ matrix.config.subdir_name }}/"
        mv "package/icon.png" "package/${{ matrix.config.subdir_name }}/"
        mv "package/boot.dol" "package/${{ matrix.config.subdir_name }}/boot.dol"
        cat ../docs/README_WII.md ../README.md >> "package/${{ matrix.config.subdir_name }}/README.md"
        cd package
        zip -9 -r "thextech-wii-${BRANCH_NAME}.zip" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.zip; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/wiiu-ci.yml
================================================
name: Wii U CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci-homebrew
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ubuntu-latest
    container: ghcr.io/thextech/wohlnet-ci-ubuntu2404-dkp-vita:latest
    env:
        DEVKITPRO: /opt/devkitpro
        DEVKITPPC: /opt/devkitpro/devkitPPC
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "Wii U build",

            extra_options: "-DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/WiiU.cmake \
            -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/wiiu-local \
            -DSDL2_DIR=/opt/devkitpro/portlibs/wiiu-local/lib/cmake/SDL2 \
            -DCMAKE_INSTALL_PREFIX=$DEVKITPRO/portlibs/wiiu",

            deps_cmdline: "echo 'DevkitPro SDK is already pre-installed'",

            generator: "Ninja",
            build_type: "MinSizeRel",
            executable_name: "thextech",
            assets_url: "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z",
            subdir_name: "thextech-wiiu",
            upload_directory: "www/wiiu/"
          }

    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Install modified SDL2
      run: |
        cd ..
        git clone https://github.com/Wohlstand/SDL.git -b wiiu-fixes-2.28--06-2025 --depth 1 SDL2
        cd SDL2
        mkdir build
        cd build
        cmake -G Ninja \
            -DCMAKE_TOOLCHAIN_FILE=$DEVKITPRO/cmake/WiiU.cmake \
            -DCMAKE_INSTALL_PATH=/opt/devkitpro/portlibs/wiiu-local \
            -DCMAKE_PREFIX_PATH=/opt/devkitpro/portlibs/wiiu \
            -DSDL_ALTIVEC=OFF \
            -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
            ..
        cmake --build . --target all -j4
        sudo cmake --build . --target install

    - name: Configure
      shell: bash
      run: |
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} .

    - name: Build
      shell: bash
      run: |
        cmake --build build --target all -j4

    - name: Create Package
      if: success()
      shell: bash
      run: |
        cd build
        mkdir package
        mkdir "package/${{ matrix.config.subdir_name }}"
        cp ../changelog.txt "package/${{ matrix.config.subdir_name }}/"
        cp ../LICENSE "package/${{ matrix.config.subdir_name }}/License.TheXTech.txt"
        cp meta.xml "package/${{ matrix.config.subdir_name }}/"
        cp icon.png "package/${{ matrix.config.subdir_name }}/"
        cp thextech.rpx "package/${{ matrix.config.subdir_name }}/thextech.rpx"
        cp thextech.wuhb "package/${{ matrix.config.subdir_name }}/thextech.wuhb"
        cat ../docs/README_WIIU.md ../README.md >> "package/${{ matrix.config.subdir_name }}/README.md"
        cd package
        zip -9 -r "thextech-wiiu-${BRANCH_NAME}.zip" "${{ matrix.config.subdir_name }}"
        rm -Rf "${{ matrix.config.subdir_name }}"
        cd ../..

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.zip
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        for q in ./build/package/*.zip; do
            UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
        done
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .github/workflows/windows-ci.yml
================================================
name: Windows CI

on:
  push:
    branches:
      - main
      - stable*
      - versus-ci
  pull_request:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  build:
    name: "${{ matrix.config.name }} | ${{ matrix.config.build_type }}"
    runs-on: ${{ matrix.config.os }}
    container: ${{ matrix.config.container }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "Windows - 64-bit",
            os: windows-latest,

            extra_options: "-DCMAKE_PREFIX_PATH=C:/WohlMinGWw64/mingw64 \
            -DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_windows_mingw_toolchain_x64.cmake",

            generator: "Ninja",
            build_type: "MinSizeRel",
            extra_path: "/c/WohlMinGWw64/mingw64/bin",
            executable_name_suffix: "-win64",
            package_filename_suffix: "win64",
            upload_directory: "www/win32/",
            mingw_download: "https://wohlsoft.ru/docs/Software/MinGW/x86_64-12.2.0-release-posix-seh-rt_v10-rev1.7z", mingw_install_dir: "C:/WohlMinGWw64/",
            ninja_download: "https://wohlsoft.ru/docs/Software/Ninja-Build/ninja-win.zip", ninja_install_dir: "C:/WohlMinGWw64/mingw64/bin",
            lftp_download: "https://wohlsoft.ru/docs/Software/lftp-4.4.15.win64-openssl-1.0.1g.7z", lftp_install_dir: "C:/WohlMinGWw64/mingw64/"
          }
        - {
            name: "Windows - 32-bit",
            os: windows-latest,

            extra_options: "-DCMAKE_PREFIX_PATH=C:/WohlMinGWw64/mingw32 \
            -DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_windows_mingw_toolchain_x32.cmake",

            generator: "Ninja",
            build_type: "MinSizeRel",
            extra_path: "/c/WohlMinGWw64/mingw32/bin",
            executable_name_suffix: "",
            package_filename_suffix: "win32",
            upload_directory: "www/win32/",
            mingw_download: "https://wohlsoft.ru/docs/Software/MinGW/i686-12.2.0-release-posix-dwarf-rt_v10-rev1.7z", mingw_install_dir: "C:/WohlMinGWw64/",
            ninja_download: "https://wohlsoft.ru/docs/Software/Ninja-Build/ninja-win.zip", ninja_install_dir: "C:/WohlMinGWw64/mingw32/bin",
            lftp_download: "https://wohlsoft.ru/docs/Software/lftp-4.4.15.win64-openssl-1.0.1g.7z", lftp_install_dir: "C:/WohlMinGWw64/mingw32/"
          }
        - {
            name: "Windows - 32-bit (legacy floats)",
            os: windows-latest,

            extra_options: "-DCMAKE_PREFIX_PATH=C:/WohlMinGWw64/mingw32 \
            -DTHEXTECH_EXECUTABLE_NAME=thextech \
            -DCMAKE_TOOLCHAIN_FILE=`pwd`/cmake/ci_windows_mingw_toolchain_x32.cmake \
            -DTHEXTECH_FIXED_POINT=OFF",

            generator: "Ninja",
            build_type: "MinSizeRel",
            extra_path: "/c/WohlMinGWw64/mingw32/bin",
            executable_name_suffix: "",
            package_filename_suffix: "win32-legacy-floats",
            upload_directory: "www/win32/",
            mingw_download: "https://wohlsoft.ru/docs/Software/MinGW/i686-12.2.0-release-posix-dwarf-rt_v10-rev1.7z", mingw_install_dir: "C:/WohlMinGWw64/",
            ninja_download: "https://wohlsoft.ru/docs/Software/Ninja-Build/ninja-win.zip", ninja_install_dir: "C:/WohlMinGWw64/mingw32/bin",
            lftp_download: "https://wohlsoft.ru/docs/Software/lftp-4.4.15.win64-openssl-1.0.1g.7z", lftp_install_dir: "C:/WohlMinGWw64/mingw32/"
          }
        - {
            name: "Windows - ARM64",
            os: windows-2022,
            extra_options: "-A ARM64 -DTHEXTECH_EXECUTABLE_NAME=thextech",
            generator: "Visual Studio 17 2022",
            build_type: "MinSizeRel",
            extra_path: "/c/WohlLFTP/bin",
            executable_name_suffix: "-arm64",
            package_filename_suffix: "arm64",
            upload_directory: "www/win-arm/",
            lftp_download: "https://wohlsoft.ru/docs/Software/lftp-4.4.15.win64-openssl-1.0.1g.7z", lftp_install_dir: "C:/WohlLFTP/"
          }


    steps:
    - name: Check for the upload support
      id: upload-check
      shell: bash
      run: |
        if [[ "${{ secrets.builds_login }}" != '' && \
              "${{ secrets.builds_password }}" != '' && \
              "${{ secrets.builds_host }}" != '' ]]; then
          echo "available=true" >> $GITHUB_OUTPUT;
        else
          echo "available=false" >> $GITHUB_OUTPUT;
        fi

    - name: Install Dependencies
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.deps_cmdline }}" ]]; then
          eval ${{ matrix.config.deps_cmdline }}
        fi
        cmake --version

    - uses: TheXTech/checkout@v0.1

    - uses: TheXTech/branch-name@v0.1


    - name: Pull submodules
      shell: bash
      run: |
        git submodule update --init --recursive

    - name: Download MinGW
      if: matrix.config.mingw_download
      shell: bash
      run: C:\\msys64\\usr\\bin\\wget.exe -d -nv -t 5 -O mingw.7z "${{ matrix.config.mingw_download }}"

    - name: Extract MinGW
      if: matrix.config.mingw_install_dir
      shell: bash
      run: |
        7z x mingw.7z -o"${{ matrix.config.mingw_install_dir }}"

    - name: Download Ninja
      if: matrix.config.ninja_download
      shell: bash
      run: C:\\msys64\\usr\\bin\\wget.exe -d -nv -t 5 -O ninja.zip "${{ matrix.config.ninja_download }}"

    - name: Extract Ninja
      if: matrix.config.ninja_install_dir
      shell: bash
      run: |
        7z x ninja.zip -o"${{ matrix.config.ninja_install_dir }}"

    - name: Download LFTP
      if: matrix.config.lftp_download
      shell: bash
      run: C:\\msys64\\usr\\bin\\wget.exe -d -nv -t 5 -O lftp.7z "${{ matrix.config.lftp_download }}"

    - name: Extract LFTP
      if: matrix.config.lftp_install_dir
      shell: bash
      run: |
        7z x lftp.7z bin etc -o"${{ matrix.config.lftp_install_dir }}"

    - name: Download SMBX assets
      shell: bash
      run: C:\\msys64\\usr\\bin\\wget.exe -d -nv -t 5 -O smbx13.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-smbx13-assets-full.7z"

    - name: Download AoD assets
      shell: bash
      run: C:\\msys64\\usr\\bin\\wget.exe -d -nv -t 5 -O aod.7z "https://wohlsoft.ru/projects/TheXTech/_downloads/thextech-adventure-of-demo-assets-full.7z"

    - name: Unpack all assets
      shell: bash
      run: |
        mkdir -p smbx13
        cd smbx13
        7z x ../smbx13.7z
        cd ..
        rm smbx13.7z
        mkdir -p aod
        cd aod
        7z x ../aod.7z
        cd ..
        rm aod.7z

    - name: Apply update to translations
      shell: bash
      run: |
        ASSETS_ROOT1="$PWD/smbx13"
        ASSETS_ROOT2="$PWD/aod"
        cd .github/ci-helper
        bash translate_update.sh "${ASSETS_ROOT1}"
        bash translate_update.sh "${ASSETS_ROOT2}"
        cd ../..

    - name: Configure
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
          echo "PATH environment: ${PATH}"
        fi
        if [[ "${{ secrets.DISCORD_APP_ID }}" != '' ]]; then
          LOCAL_EXTRA_SETUP="-DTHEXTECH_ENABLE_DISCORD_RPC=ON -DTHEXTECH_DISCORD_APPID=\"${{ secrets.DISCORD_APP_ID }}\""
        fi
        cmake -B build -G "${{ matrix.config.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} ${{ matrix.config.extra_options }} ${LOCAL_EXTRA_SETUP} .

    - name: Build
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        export MAKEFLAGS=--keep-going
        cmake --build build --config ${{ matrix.config.build_type }} --parallel 3

    - name: List dependent libraries
      if: success() && runner.os == 'Linux'
      shell: bash
      run: |
        file build/output/bin/thextech
        ldd build/output/bin/thextech


    - name: Create Package
      if: success()
      shell: bash
      # ======================================= Adventures of Demo =======================================
      # The side game about Demo and siblings from the A2XT universe by raocow and his fan community.
      # ======================================= Super Mario Bros. X - a fan-game =======================================
      # Was made in 2009 by Andrew Spinks "Redigit", and supported up to 2011 by it's original author.
      run: |
        bash .github/ci-helper/pack-game.sh \
            "${{ runner.os }}" \
            "thextech-adventures-of-demo" \
            "advdemo${{ matrix.config.executable_name_suffix }}" \
            "thextech-adventures-of-demo-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
            "aod"

        bash .github/ci-helper/pack-game.sh \
            "${{ runner.os }}" \
            "thextech-super-mario-bros-x" \
            "smbx${{ matrix.config.executable_name_suffix }}" \
            "thextech-super-mario-bros-x-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
            "smbx13"

        bash .github/ci-helper/pack-game.sh \
            "${{ runner.os }}" \
            "thextech-bin" \
            "thextech${{ matrix.config.executable_name_suffix }}" \
            "thextech-bin-${{ matrix.config.package_filename_suffix }}-${BRANCH_NAME}" \
            "none"

    - name: Upload artifact
      if: success()
      uses: actions/upload-artifact@v4
      continue-on-error: true
      with:
        path: build/package/*.7z
        name: ${{ matrix.config.name }} ${{ matrix.config.build_type }}

    - name: Deploy to builds.wohlsoft.ru
      if: success() && github.event_name != 'pull_request' && steps.upload-check.outputs.available == 'true'
      continue-on-error: true
      shell: bash
      run: |
        if [[ ! -z "${{ matrix.config.extra_path }}" ]]; then
          export PATH=${{ matrix.config.extra_path }}:${PATH}
        fi
        UPLOAD_LIST="set ssl:verify-certificate no;"
        if [[ "${{ runner.os }}" == 'Windows' ]]; then
            for q in ./build/package/*.7z; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        elif [[ "${{ runner.os }}" == 'Linux' ]]; then
            for q in ./build/package/*.tar.gz; do
                UPLOAD_LIST="${UPLOAD_LIST} put -O ${{ matrix.config.upload_directory }} $q;"
            done
        fi
        lftp -e "${UPLOAD_LIST} exit" -u ${{ secrets.builds_login }},${{ secrets.builds_password }} ${{ secrets.builds_host }}

    - name: List Build Directory
      if: always()
      shell: bash
      run: |
        git status
        ls -lR build


================================================
FILE: .gitignore
================================================
# This file is used to ignore files which are generated
# ----------------------------------------------------------------------------

*~
*.autosave
*.a
*.core
*.moc
*.o
*.obj
*.orig
*.rej
*.so
*.so.*
*_pch.h.cpp
*_resource.rc
*.qm
.#*
*.*#
core
!core/
tags
.DS_Store
.directory
*.debug
Makefile*
*.prl
*.app
moc_*.cpp
ui_*.h
qrc_*.cpp
Thumbs.db
*.res
/.qmake.cache
/.qmake.stash

# qtcreator generated files
*.pro.user*
*.txt.user*

# xemacs temporary files
*.flc

# Vim temporary files
.*.swp

# Visual Studio generated files
*.ib_pdb_index
*.idb
*.ilk
*.pdb
*.sln
*.suo
*.vcproj
*vcproj.*.*.user
*.ncb
*.sdf
*.opensdf
*.vcxproj
*vcxproj.*

build-*

build/

# MinGW generated files
*.Debug
*.Release

# Python byte code
*.pyc

# Binaries
# --------
*.dll
*.exe

# CLion and like environments
.idea/*
cmake-build-*/*

.vscode/*
.vs/*
CMakeSettings.json

# PVS-Studio related stuff
*.PVS-Studio.*
.PVS-Studio/

# Vendored assets packages shouldn't appear at the GIT history
/assets/

# clangd related stuff
.cache/


================================================
FILE: .gitmodules
================================================
[submodule "3rdparty/PGE_File_Formats"]
	path = 3rdparty/PGE_File_Formats
	url = https://github.com/WohlSoft/PGE-File-Library-STL.git
	branch = wip-mdx
[submodule "3rdparty/LuaJIT"]
	path = 3rdparty/LuaJIT
	url = https://github.com/WohlSoft/LuaJIT.git
	branch = v2.1
[submodule "3rdparty/luabind"]
	path = 3rdparty/luabind
	url = https://github.com/WohlSoft/luabind-deboostified.git
	branch = master
[submodule "3rdparty/AudioCodecs"]
	path = 3rdparty/AudioCodecs
	url = https://github.com/WohlSoft/AudioCodecs.git
	branch = master
[submodule "3rdparty/SDL-Mixer-X"]
	path = 3rdparty/SDL-Mixer-X
	url = https://github.com/WohlSoft/SDL-Mixer-X.git
	branch = master
[submodule "3rdparty/FreeImageLite"]
	path = 3rdparty/FreeImageLite
	url = https://github.com/WohlSoft/libFreeImage.git
	branch = master
[submodule "3rdparty/freetype"]
	path = 3rdparty/freetype
	url = https://github.com/TheXTech/freetype.git
	branch = master
[submodule "3rdparty/thextech-discord-rpc"]
	path = 3rdparty/thextech-discord-rpc
	url = https://github.com/TheXTech/thextech-discord-rpc.git
	branch = main
[submodule "3rdparty/glew-cmake"]
	path = 3rdparty/glew-cmake
	url = https://github.com/TheXTech/thextech-glew-cmake.git
	branch = master
[submodule "3rdparty/DirManager"]
	path = 3rdparty/DirManager
	url = https://github.com/WohlSoft/DirManager.git
	branch = master
[submodule "3rdparty/IniProcessor"]
	path = 3rdparty/IniProcessor
	url = https://github.com/WohlSoft/IniProcessing.git
	branch = master
[submodule "3rdparty/FileMapper"]
	path = 3rdparty/FileMapper
	url = https://github.com/WohlSoft/FileMapper.git
	branch = master
[submodule "3rdparty/angle-shader-translator"]
	path = 3rdparty/angle-shader-translator
	url = https://github.com/TheXTech/angle-shader-translator-library.git
	branch = dist-no-spirv
[submodule "3rdparty/luau"]
	path = 3rdparty/luau
	url = https://github.com/TheXTech/luau.git
	branch = master
[submodule "mbediso"]
	path = 3rdparty/mbediso
	url = https://github.com/ds-sloth/mbediso/
	branch = main
[submodule "3rdparty/SDL_net"]
	path = 3rdparty/SDL_net
	url = https://github.com/TheXTech/SDL_net.git
	branch = SDL2


================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.5...3.10)

if(POLICY CMP0069) # Allow CMAKE_INTERPROCEDURAL_OPTIMIZATION (lto) to be set
    cmake_policy(SET CMP0069 NEW)
    set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
endif()

if(POLICY CMP0079) # Allow linking subprojects against each other
    cmake_policy(SET CMP0079 NEW)
    set(CMAKE_POLICY_DEFAULT_CMP0079 NEW)
endif()

project(TheXTech LANGUAGES C CXX)

if(APPLE)
    enable_language(OBJC)
endif()

include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
include(ExternalProject)
include(CheckLibraryExists)
include(CheckFunctionExists)
include(GNUInstallDirs)
include(FindBacktrace)
include(TestBigEndian)
include(CheckIncludeFile)


include(cmake/git_info.cmake)
message("== Current GIT hash [${GIT_COMMIT_HASH}], branch [${GIT_BRANCH}], package [${PACKAGE_SUFFIX}] ==")

if(NOT WIN32 AND NOT NINTENDO_SWITCH AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX))
    check_cxx_compiler_flag("-no-pie" HAS_NO_PIE)
endif()

function(pge_set_nopie _target)
    set_target_properties(${_target} PROPERTIES
        POSITION_INDEPENDENT_CODE False
    )
    if(HAS_NO_PIE AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX))
        set_property(TARGET ${_target} APPEND_STRING PROPERTY LINK_FLAGS " -no-pie")
    endif()
endfunction()

set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_POSITION_INDEPENDENT_CODE FALSE)

set(CMAKE_INSTALL_RPATH ".")
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)

if(EMSCRIPTEN)
    set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
endif()

if(APPLE)
    if(CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 9)
        set(XTECH_PLIST_NAME "thextech.plist.tiger.in")
        set(XTECH_DEFAULT_ICNS "resources/tiger/thextech.icns")
    else()
        set(XTECH_PLIST_NAME "thextech.plist.in")
        set(XTECH_DEFAULT_ICNS "resources/thextech.icns")
    endif()

    if(NOT DEFINED CMAKE_OSX_DEPLOYMENT_TARGET OR CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "")
        if(CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 9)
            set(THEXTECH_MACOS_MIN_VERSION "10.4")
        else()
            set(THEXTECH_MACOS_MIN_VERSION "10.9")
        endif()
    else()
        set(THEXTECH_MACOS_MIN_VERSION "${CMAKE_OSX_DEPLOYMENT_TARGET}")
    endif()

    message("-> Mac OS X minimal version: ${THEXTECH_MACOS_MIN_VERSION}")
endif()

if(ANDROID)
    set(DEPENDENCIES_INSTALL_DIR ${CMAKE_BINARY_DIR}/output-deps)
    set(FDROID_BUILD OFF CACHE BOOL "Is this build a part of the F-Droid workflow?")
    mark_as_advanced(FDROID_BUILD)
else()
    set(DEPENDENCIES_INSTALL_DIR ${CMAKE_BINARY_DIR}/output)
endif()

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/bin)

foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
    message("--> ${OUTPUTCONFIG}")
    string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}")
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES )

set(PGE_INSTALL_DIRECTORY "TheXTech")

include(cmake/build_props.cmake)

if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
    # Update if necessary
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ffloat-store")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffloat-store")
endif()

if(WIN32 AND NOT EMSCRIPTEN)
    set(CMAKE_SHARED_LIBRARY_PREFIX "")
endif()

if(UNIX)
    check_include_file(/opt/vc/include/bcm_host.h BCMHOST_H)
endif()

string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER)

if(CMAKE_BUILD_TYPE_LOWER STREQUAL "debug")
    add_definitions(-DDEBUG_BUILD)
    if(CMAKE_COMPILER_IS_GNUCXX)
        add_definitions(-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_ASSERTIONS=1)
    endif()
endif()

# Version
include(version.cmake)
# Default GIT version
include(cmake/git_version.cmake)


configure_file(lib/CrashHandler/backtrace.h.in
               generated-include/lib/CrashHandler/backtrace.h)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/generated-include)

if(NINTENDO_SWITCH)
    include_directories($ENV{DEVKITPRO}/portlibs/switch/include)
endif()

#if(WIN32 OR EMSCRIPTEN OR HAIKU)
#    set(USE_SYSTEM_LIBS_DEFAULT OFF)
#else()
#    set(USE_SYSTEM_LIBS_DEFAULT ON)
#endif()
set(USE_SYSTEM_LIBS_DEFAULT OFF)


if(UNIX)
    option(PORTMASTER "Make a special build for PortMaster" OFF)
endif()

if(HAIKU OR NINTENDO_SWITCH OR NINTENDO_WII OR NINTENDO_WIIU OR XTECH_MACOSX_TIGER OR PORTMASTER)
    set(USE_SYSTEM_SDL2_DEFAULT ON)  # Should be used on Haiku, own SDL2 Haiku build on CMake is broken
else()
    set(USE_SYSTEM_SDL2_DEFAULT ${USE_SYSTEM_LIBS_DEFAULT})
endif()

if(NINTENDO_DS)
    set(THEXTECH_ENABLE_TTF_SUPPORT_DEFAULT OFF)
else()
    set(THEXTECH_ENABLE_TTF_SUPPORT_DEFAULT ON)
endif()

if((APPLE AND NOT XTECH_MACOSX_TIGER) OR WIN32 OR (CMAKE_SYSTEM_NAME STREQUAL "Linux"))
    set(THEXTECH_USE_ANGLE_TRANSLATOR_DEFAULT ON)
else()
    set(THEXTECH_USE_ANGLE_TRANSLATOR_DEFAULT OFF)
endif()

option(USE_SYSTEM_LIBS "Use dependent libraries like SDL2, FreeImageLite and MixerX, installed in the system" ${USE_SYSTEM_LIBS_DEFAULT})
option(USE_SYSTEM_SDL2 "Use SDL2 from a system even prefering system libraries" ${USE_SYSTEM_SDL2_DEFAULT})

option(USE_STATIC_LIBC "Link libc and libstdc++ statically" OFF)

if(NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_DS)
    set(USE_STATIC_LIBC ON)
endif()

if(NINTENDO_3DS)
    option(THEXTECH_CUSTOM_AUDIO_LIBRARY "Use the custom audio library instead of MixerX" OFF)
endif()

if(ANDROID OR VITA OR NINTENDO_DS OR NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_SWITCH OR PGE_MIN_PORT OR THEXTECH_NO_SDL_BUILD OR PORTMASTER)
    set(THEXTECH_FORCE_FULLSCREEN ON)
else()
    option(THEXTECH_FORCE_FULLSCREEN "Force the game to only use fullscreen mode" OFF)
endif()

if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND "${TARGET_PROCESSOR}" MATCHES "arm.*")
    message("-- Desktop OpenGL build will be disabled on unsupported platform (${CMAKE_SYSTEM_NAME} on ${TARGET_PROCESSOR})")
    set(THEXTECH_BUILD_GL_DESKTOP_DEFAULT OFF)
else()
    set(THEXTECH_BUILD_GL_DESKTOP_DEFAULT ON)
endif()

option(THEXTECH_BUILD_GL_DESKTOP_MODERN "On SDL builds, include the OpenGL 2.0+ Core/Compatibility renderer" ${THEXTECH_BUILD_GL_DESKTOP_DEFAULT})
option(THEXTECH_BUILD_GL_ES_MODERN "On SDL builds, include the OpenGL ES 2.0+ renderer" ON)
option(THEXTECH_BUILD_GL_DESKTOP_LEGACY "On SDL builds, include the OpenGL 1.1+ renderer" ${THEXTECH_BUILD_GL_DESKTOP_DEFAULT})
option(THEXTECH_BUILD_GL_ES_LEGACY "On SDL builds, include the OpenGL ES 1.1 renderer" OFF)

option(THEXTECH_USE_ANGLE_TRANSLATOR "On modern OpenGL builds, include the ANGLE shader translator to improve shader support in OpenGL 3.0+ Core/Compatibility profiles" ${THEXTECH_USE_ANGLE_TRANSLATOR_DEFAULT})

option(RANGE_ARR_USE_HEAP "Store data of RangeArr<> template in a heap" OFF)
option(RANGE_ARR_UNSAFE_MODE "Disable all range checks at RangeArr<> template" OFF)

option(ENABLE_ANTICHEAT_TRAP "Enable anti-cheating trap for the \"redigitiscool\" cheat code" OFF)
option(ENABLE_OLD_CREDITS "Use original Redigit's credits without changes" OFF)
option(ENABLE_LOGGING "Enable debug logging written into a file (may not work on some platfors)" ON)

option(THEXTECH_ENABLE_LUA "Enable lua scripting support" OFF)
option(THEXTECH_ENABLE_LUAU "Enable luau build testing" OFF)
option(THEXTECH_ENABLE_LUNA_AUTOCODE "Enable LunaDLL Autocode scripting support" ON)

option(THEXTECH_ENABLE_SDL_NET "Enable SDL_net build testing" OFF)

option(THEXTECH_ENABLE_EDITOR "Enable runtime support for editor features" ON)

option(THEXTECH_ENABLE_TTF_SUPPORT "Enable TTF fonts support (FreeType required)" ${THEXTECH_ENABLE_TTF_SUPPORT_DEFAULT})

option(THEXTECH_CLI_BUILD "Minimal CLI build for testing and benchmarking on desktop platforms" OFF)
option(THEXTECH_NO_SDL_BUILD "Do not use SDL in the CLI build; useful as a starting point for new ports" OFF)

option(THEXTECH_ENABLE_WIP_FEATURES "Enable experimental and incomplete features (disabled by default)" OFF)
mark_as_advanced(THEXTECH_ENABLE_WIP_FEATURES)

option(THEXTECH_NO_BUILD_DATE "Disables the using of the build timestamp in order to make the build reproducible" OFF)

option(THEXTECH_ENABLE_AUDIO_FX "Enable real-time audio effects support" ON)

option(THEXTECH_FIXED_POINT "Experimental: use fixed-point arithmetic for gameplay logic" ON)

option(ENABLE_ADDRESS_SANITIZER "Enable the Address Sanitizer GCC feature" OFF)

# ============ Customization ==============
set(LIB_SRC_EXTRA)

set(THEXTECH_PACKAGE_NAME "thextech" CACHE STRING "Name of package archive file")
set(THEXTECH_EXECUTABLE_NAME "thextech" CACHE STRING "Name of executable file")
set(THEXTECH_DIRECTORY_PREFIX "TheXTech" CACHE STRING "Name used for directories on installed targets (should vary across forks, not asset packs)")
set(THEXTECH_INSTALLER_PACKAGE_NAME "${THEXTECH_EXECUTABLE_NAME}" CACHE STRING "The package name for the package manager")

if(APPLE)
    set(THEXTECH_PRELOAD_ENVIRONMENT "" CACHE STRING "Path to resources root to pack")
    option(THEXTECH_PRELOAD_ENVIRONMENT_MANUALLY "Make application look for assets inside the bundle, but don't actually put any assets. The 'Template' app will be produced for manual addition of assets." OFF)
    set(THEXTECH_BUNDLE_NAME "TheXTech" CACHE STRING "Name of bundle folder")
    set(THEXTECH_ICON_NAME "thextech.icns" CACHE STRING "Name of bundle icon file")
    set(THEXTECH_CUSTOM_ICON_PATH "" CACHE STRING "Name of icon file to pack into the bundle")
    if(NOT THEXTECH_CUSTOM_ICON_PATH STREQUAL "")
        message("Use custom macOS icon: ${THEXTECH_CUSTOM_ICON_PATH}")
        list(APPEND LIB_SRC_EXTRA
            "${THEXTECH_CUSTOM_ICON_PATH}"
        )
    endif()
endif()

if(NOT APPLE AND NOT ANDROID AND NOT EMSCRIPTEN)
    set(THEXTECH_UNIX_INSTALL TRUE)
endif()

# ============ Customization ==end=========

# ============ Platform-conf ==============

if(EMSCRIPTEN)
    # config for web app deployment manifest
    set(THEXTECH_MANIFEST_NAME "TheXTech Engine ${THEXTECH_VERSION_STRING}" CACHE STRING "Web app manifest name, used as title after installation")
    set(THEXTECH_MANIFEST_ID "wohlsoft-thextech" CACHE STRING "Web app ID, uniquely identifies installed app")
    set(THEXTECH_MANIFEST_DESC "" CACHE STRING "Web app description")
    set(THEXTECH_DEPLOY_URL "http://localhost:8080/" CACHE STRING "Fully qualified HTTPS URL where application will be deployed (HTTP may only be used for local testing)")

    # versioned ID
    if(GIT_BRANCH STREQUAL "main")
        set(GIT_BRANCH_IF_NOT_MAIN "")
    else()
        set(GIT_BRANCH_IF_NOT_MAIN "-${GIT_BRANCH}")
    endif()

    set(THEXTECH_MANIFEST_ID_V "${THEXTECH_MANIFEST_ID}${GIT_BRANCH_IF_NOT_MAIN}${THEXTECH_VERSION_REL}")

    string(CONFIGURE "${THEXTECH_MANIFEST_NAME}" THEXTECH_MANIFEST_NAME_OUT)
    string(CONFIGURE "${THEXTECH_MANIFEST_ID_V}"   THEXTECH_MANIFEST_ID_OUT)
    string(CONFIGURE "${THEXTECH_MANIFEST_DESC}" THEXTECH_MANIFEST_DESC_OUT)
endif()

if(VITA)
    message("Enabling PS Vita Support and fast-math flags.")

    # Fast Math flags for Vita, ensuring -DVITA is passed to the compiler.
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ffast-math -mtune=cortex-a9 -mfpu=neon -DVITA")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math -mtune=cortex-a9 -mfpu=neon -DVITA")

    # Disable annoying warning for Parameter passing.
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-psabi")

    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY OFF CACHE BOOL "" FORCE)

    # note: to test GLESv2 on Vita, remove the below line, install VitaGL with shader support and Northfear's SDL2 fork, and enable USE_SYSTEM_SDL2
    # As of August 2025, Northfear's SDL2 fork invalidly reports the OpenGL profile as Compatibility instead of ES, and VitaGL doesn't support clearing buffers, and its shader transpiler is imperfect
    set(THEXTECH_BUILD_GL_ES_MODERN OFF CACHE BOOL "" FORCE)
endif()

if(NINTENDO_SWITCH)
    message("Enabling Nintendo Switch Support and fast-math flags.")

    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE -DNINTENDO_SWITCH -D__SWITCH__")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE -DNINTENDO_SWITCH -D__SWITCH__")
endif()

if(NINTENDO_WII OR NINTENDO_3DS OR NINTENDO_DS)
    set(PGE_MIN_PORT ON)
    set(THEXTECH_NO_ARGV_HANDLING ON)
    add_compile_definitions(PGE_MIN_PORT)

    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY OFF CACHE BOOL "" FORCE)
endif()

if(NINTENDO_WIIU)
    set(THEXTECH_NO_ARGV_HANDLING ON)
    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY OFF CACHE BOOL "" FORCE)
endif()

if(PORTMASTER)
    message("Special build for PortMaster.")

    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_MODERN ON CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY OFF CACHE BOOL "" FORCE)
    set(PGE_SHARED_SDLMIXER OFF CACHE BOOL "" FORCE)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
endif()

if(THEXTECH_CLI_BUILD)
    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY OFF CACHE BOOL "" FORCE)
endif()

if(THEXTECH_CLI_BUILD OR PGE_MIN_PORT OR EMSCRIPTEN OR PORTMASTER)
    set(RANGE_ARR_UNSAFE_MODE ON)
endif()

if(NINTENDO_DS)
    set(THEXTECH_NO_SDL_BUILD ON CACHE BOOL "" FORCE)
endif()

if(ANDROID)
    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY ON CACHE BOOL "")
endif()

if(APPLE OR WIN32)
    set(THEXTECH_BUILD_GL_ES_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY OFF CACHE BOOL "" FORCE)
endif()

# 32-bit Android special case, temporarily disabled for some experiments
# if(ANDROID AND CMAKE_SIZEOF_VOID_P EQUAL 4)
#     set(THEXTECH_BUILD_GL_ES_MODERN OFF CACHE BOOL "" FORCE)
# endif()

if(EMSCRIPTEN)
    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY      OFF CACHE BOOL "" FORCE)
endif()

if(NINTENDO_SWITCH)
    set(THEXTECH_BUILD_GL_ES_MODERN      ON  CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_ES_LEGACY      OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_LEGACY OFF CACHE BOOL "" FORCE)
    set(THEXTECH_BUILD_GL_DESKTOP_MODERN OFF CACHE BOOL "" FORCE)
endif()

if(THEXTECH_NO_SDL_BUILD)
    set(THEXTECH_ENABLE_AUDIO_FX OFF CACHE BOOL "" FORCE)
    set(MBEDISO_THREADS "NONE")
else()
    set(MBEDISO_THREADS "SDL2")
endif()

if(EMSCRIPTEN)
    message("Is EMSCRIPTEN!")
    set(PGE_PRELOAD_ENVIRONMENT "/home/vitaly/.PGE_Project/_emscripten/thextech" CACHE STRING "Path to resources root to pack")
    set(CMAKE_EXECUTABLE_SUFFIX ".html")
#    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse -msse2")
    # -DIS_CXX -s USE_PTHREADS=1
#    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s WASM=1 -s 'BINARYEN_METHOD=\"native-wasm\"'")
    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s EMTERPRETIFY=1 -s EMTERPRETIFY_ASYNC=1  -s 'EMTERPRETIFY_FILE=\"pge_engine.binary\"'")
    # -s \"EMTERPRETIFY_WHITELIST=['_main']\"
    if(CMAKE_BUILD_TYPE_LOWER STREQUAL "debug" OR CMAKE_BUILD_TYPE_LOWER STREQUAL "relwithdebinfo")
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s ASSERTIONS=1")
    endif()
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -s USE_SDL=0")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s USE_SDL=0")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s \"DEFAULT_LIBRARY_FUNCS_TO_INCLUDE=['\\$autoResumeAudioContext', '\\$dynCall']\"") #-s USE_SDL=2
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s LLD_REPORT_UNDEFINED -s ERROR_ON_UNDEFINED_SYMBOLS=1 -s ASYNCIFY=1 -lidbfs.js")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s \"EXPORTED_FUNCTIONS=['_main', '_unlockLoadingCustomState']\"")
#    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s 'BINARYEN_TRAP_MODE=\"clamp\"'")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s TOTAL_MEMORY=83886080 --no-heap-copy -s ALLOW_MEMORY_GROWTH=1")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s EXPORTED_RUNTIME_METHODS=ccall")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s BINARYEN_EXTRA_PASSES=coalesce-locals")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s MAX_WEBGL_VERSION=2")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s GL_ENABLE_GET_PROC_ADDRESS")
#    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s \"EXTRA_EXPORTED_RUNTIME_METHODS=['Pointer_stringify']\"")
#    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --embed-file \"${_LANGAUGES_TEMP_FOLDER}\"@\"languages/\"")
#    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --preload-file \"${PGE_PRELOAD_CONFIG_PACK}\"@\"configs/${PGE_PRELOAD_CONFIG_PACK_NAME}/\"")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --preload-file \"${PGE_PRELOAD_ENVIRONMENT}\"@\"/\"")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --shell-file '${CMAKE_CURRENT_SOURCE_DIR}/resources/emscripten/shell_minimal.html'")
    # set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --use-preload-cache")
    # set(LINK_FLAGS "${LINK_FLAGS} -DIS_LINK -s USE_PTHREADS=1 -s FORCE_FILESYSTEM=1 --embed-file '${CMAKE_CURRENT_SOURCE_DIR}/@languages'")

    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions") # bump to -fwasm-exceptions once widely supported
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fexceptions") # bump to -fwasm-exceptions once widely supported
endif()

# ============ Platform-conf ==end=========

option(PGEFL_QT_SUPPORT "Build PGE-FL with Qt support [Unneeded]" OFF)
set(Moondust_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) # Don't install PGE-FL libraries
set(PGEFL_ENABLE_RWOPS ON)

if(PGE_MIN_PORT)
    set(PGEFL_DISABLE_SMBX38A ON)
endif()

add_subdirectory(3rdparty/PGE_File_Formats)
mark_as_advanced(WITH_UNIT_TESTS PGEFL_QT_SUPPORT)

if(USE_STATIC_LIBC)
    set(BUILD_SHARED_LIBS OFF)
endif()

include(lib/Allocator/pool-allocator.cmake)
include(lib/pge_video_rec/pge-video-rec.cmake)
include(3rdparty/DirManager/dirman.cmake)

if(NOT VITA AND NOT NINTENDO_SWITCH AND NOT NINTENDO_3DS AND NOT NINTENDO_WII AND NOT NINTENDO_WIIU AND NOT NINTENDO_DS)
    include(3rdparty/FileMapper/FileMapper.cmake)
endif()

include(lib/fmt/fmt.cmake)
include(3rdparty/IniProcessor/IniProcessor.cmake)
include(lib/Utils/Utils.cmake)
include(lib/Logger/logger.cmake)
include(lib/AppPath/app_path.cmake)
include(lib/tclap/tclap.cmake)
include(lib/md5/md5.cmake)
include(lib/sdl_proxy/sdl_proxy.cmake)
if(WIN32)
    include(lib/CrashHandler/StackWalker/StackWalker.cmake)
endif()

include(cmake/library_zlib.cmake)

add_definitions("-DMOONDUST_LOGGER_FILENAME_PREFIX=\"TheXTech\"")

if(THEXTECH_ENABLE_TTF_SUPPORT)
#    option(THEXTECH_ENABLE_TTF_HARFBUZZ "Enable the HarfBuzz library use" OFF)
#    mark_as_advanced(THEXTECH_ENABLE_TTF_HARFBUZZ) # Temporarily disable
#    if(THEXTECH_ENABLE_TTF_HARFBUZZ AND NOT NINTENDO_3DS)
#        include(cmake/library_HarfBuzz.cmake)
#    else()
#        set(FT_DISABLE_HARFBUZZ ON)
#    endif()
    set(FT_DISABLE_HARFBUZZ ON)
    include(cmake/library_FreeType.cmake)
endif()

if(PGE_MIN_PORT)
    set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
    set(ENABLE_UBSAN OFF CACHE BOOL "" FORCE)
endif()

if(THEXTECH_ENABLE_LUA)
    include(cmake/library_luajit.cmake)
    include(cmake/library_luabind.cmake)
endif()

if(NOT THEXTECH_CLI_BUILD AND NOT THEXTECH_NO_SDL_BUILD)
    include(cmake/library_discord_rpc.cmake)
endif()

set(A2XT_LIBS pgefl ${UTILS_LIBS})
set(A2XT_INCS src lib 3rdparty)
set(A2XT_DEPS)

add_library(A2XT_Int INTERFACE)

if(THEXTECH_NO_SDL_BUILD)
    add_subdirectory(lib/sdl_proxy_rwops)
    get_target_property(SDL_PROXY_RWOPS_INCS sdl_proxy_rwops INTERFACE_INCLUDE_DIRECTORIES)
    target_include_directories(pgefl PRIVATE ${SDL_PROXY_RWOPS_INCS})
    add_dependencies(pgefl sdl_proxy_rwops)
    target_link_libraries(A2XT_Int INTERFACE sdl_proxy_rwops)
endif()

if(THEXTECH_ENABLE_TTF_SUPPORT)
    list(APPEND A2XT_DEPS FREETYPE_Local)
    list(APPEND A2XT_LIBS PGE_FreeType)
    if(TARGET PGE_HarfBuzz)
        list(APPEND A2XT_DEPS HARFBUZZ_Local)
        list(APPEND A2XT_LIBS PGE_HarfBuzz)
    endif()
endif()

if(THEXTECH_ENABLE_LUA)
    list(APPEND A2XT_DEPS LuaBind_Local)
    list(APPEND A2XT_INCS script/include)
endif()

target_compile_definitions(A2XT_Int INTERFACE
    -DINI_PROCESSING_USE_MDX_PARSER  # IniProcessor should use the MDX tokenizer for lists
)

include(cmake/library_glew.cmake)
include(cmake/library_syslibs.cmake)

if(USE_SYSTEM_LIBS)
    find_package(SDL2 REQUIRED)

    find_library(MIXERX_LIB NAMES SDL2_mixer_ext)
    find_path(MIXERX_HEAD_DIR SDL_mixer_ext.h PATH_SUFFIXES SDL2)

    find_library(FREEIMAGELITE_LIB NAMES FreeImageLite)
    find_path(FREEIMAGELITE_HEAD_DIR NAMES FreeImageLite.h)

    if(MINGW AND NOT SDL2_LIBRARIES)
        set(SDL2_LIBRARIES mingw32 SDL2main SDL2)
    endif()

    list(APPEND A2XT_LIBS ${FREEIMAGELITE_LIB} ${MIXERX_LIB} "${SDL2_LIBRARIES}" ${THEXTECH_SYSLIBS})
    list(APPEND A2XT_INCS ${SDL2_INCLUDE_DIRS} ${MIXERX_HEAD_DIR} ${FREEIMAGELITE_HEAD_DIR})
    target_include_directories(pgefl PRIVATE ${SDL2_INCLUDE_DIRS})
elseif(NOT THEXTECH_NO_SDL_BUILD)
    include(cmake/library_FreeImage.cmake)
    list(APPEND A2XT_DEPS FreeImage_Local)
    list(APPEND A2XT_LIBS PGE_FreeImage)

    include(cmake/library_SDLMixerX.cmake)
    list(APPEND A2XT_INCS "${DEPENDENCIES_INSTALL_DIR}/include" ${SDL2_INCLUDE_DIRS})
    target_include_directories(pgefl PRIVATE ${SDL2_INCLUDE_DIRS})

    # depend on RWops from AudioCodecs_Local SDL2 build
    add_dependencies(pgefl AudioCodecs_Local)

    if(NOT USE_SYSTEM_ZLIB) # Depend on ZLib at AudioCodecs
        if(TARGET FREETYPE_Local)
            add_dependencies(FREETYPE_Local AudioCodecs_Local)
        endif()
        add_dependencies(FreeImage_Local AudioCodecs_Local)
    endif()

    if(NOT THEXTECH_NO_MIXER_X)
        list(APPEND A2XT_DEPS SDLMixerX_Local)
    else()
        list(APPEND A2XT_DEPS AudioCodecs_Local)
    endif()

    if(PGE_SHARED_SDLMIXER)
        list(APPEND A2XT_LIBS PGE_SDLMixerX)
    else()
        list(APPEND A2XT_LIBS PGE_SDLMixerX_static)
    endif()

# UNIX seems to be too general -- how to target desktop Linux specifically?
#    if(UNIX AND (THEXTECH_BUILD_GL_DESKTOP_MODERN OR THEXTECH_BUILD_GL_DESKTOP_LEGACY OR THEXTECH_BUILD_GL_ES_MODERN OR THEXTECH_BUILD_GL_ES_LEGACY))
#        list(APPEND A2XT_LIBS GL)
#    endif()

    if(THEXTECH_ENABLE_VENDORED_GLEW)
        list(APPEND A2XT_DEPS GLEW_Local)
        list(APPEND A2XT_LIBS PGE_GLEW)
    endif()

    if(WIN32 AND (THEXTECH_BUILD_GL_DESKTOP_MODERN OR THEXTECH_BUILD_GL_DESKTOP_LEGACY))
        # glu32 not needed or provided on ARM
        if("${TARGET_PROCESSOR}" STREQUAL "i386" OR "${TARGET_PROCESSOR}" STREQUAL "x86_64")
            list(APPEND A2XT_LIBS glu32)
        endif()

        list(APPEND A2XT_LIBS opengl32 gdi32)
    endif()

    if(PGE_SHARED_SDLMIXER)
        if(NOT WIN32 AND NOT EMSCRIPTEN AND NOT APPLE AND NOT ANDROID AND NOT NINTENDO_SWITCH)
            if(THEXTECH_BUILD_GL_ES_MODERN AND NOT THEXTECH_BUILD_GL_DESKTOP_MODERN AND NOT THEXTECH_BUILD_GL_DESKTOP_LEGACY AND NOT THEXTECH_BUILD_GL_ES_LEGACY)
                list(APPEND A2XT_LIBS GLESv2)
            else()
                find_library(_LIB_GL GL)
                if(_LIB_GL)
                    list(APPEND A2XT_LIBS ${_LIB_GL})
                endif()
            endif()
        else()
            list(APPEND A2XT_LIBS shell32)
        endif()
    endif()

    if(THEXTECH_CUSTOM_AUDIO_LIBRARY)
        list(APPEND A2XT_LIBS gme vorbisidec ogg)
    endif()

    list(APPEND A2XT_LIBS PGE_ZLib)
endif()

if(THEXTECH_ENABLE_DISCORD_RPC)
    list(APPEND A2XT_DEPS DiscordPRC_Local)
    list(APPEND A2XT_LIBS PGE_DiscordRPC)
    set(THEXTECH_ENABLE_INTEGRATOR ON)  # This feature needs for an Integrator
endif()

if(PGE_ENABLE_VIDEO_REC)
    list(APPEND A2XT_LIBS ${VIDEO_REC_LIBS})
    list(APPEND A2XT_DEPS ${VIDEO_REC_DEPS})
    list(APPEND A2XT_INCS ${VIDEO_REC_INCS})
endif()

if(THEXTECH_BUILD_GL_DESKTOP_MODERN AND THEXTECH_USE_ANGLE_TRANSLATOR)
    add_subdirectory(3rdparty/angle-shader-translator)

    message("== Building ANGLE shader translator ==")
    # suppress some known warnings on GCC / Clang
    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
        target_compile_options(angle_shader_translator PRIVATE -Wno-unused-parameter)
        target_compile_options(angle_shader_translator PRIVATE -Wno-c++17-attribute-extensions)
    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
        target_compile_options(angle_shader_translator PRIVATE -Wno-unused-parameter)
        target_compile_options(angle_shader_translator PRIVATE -Wno-c++17-extensions)
    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
        target_compile_options(angle_shader_translator PRIVATE /wd4100) # unreferenced formal parameter
    endif()

    target_link_libraries(A2XT_Int INTERFACE angle_shader_translator)
endif()

if(THEXTECH_ENABLE_SDL_NET)
    message("== Building SDL_net... but it doesn't do anything! ==")
    set(SDL_NET_PGE_DEPENDENT_BUILD ON)
    add_subdirectory(3rdparty/SDL_net EXCLUDE_FROM_ALL)
    target_link_libraries(SDL2_net PRIVATE A2XT_Int)
    target_compile_definitions(A2XT_Int INTERFACE
        -DTHEXTECH_ENABLE_SDL_NET
    )
endif()

if(THEXTECH_ENABLE_LUAU)
    message("== Building Luau... but it doesn't do anything! ==")
    add_subdirectory(3rdparty/luau EXCLUDE_FROM_ALL)
    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
        target_compile_options(Luau.Compiler PRIVATE "-w")
        target_compile_options(Luau.Ast PRIVATE "-w")
        target_compile_options(Luau.VM PRIVATE "-w")
    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
        target_compile_options(Luau.Compiler PRIVATE /wd4100) # unreferenced formal parameter
        target_compile_options(Luau.Ast PRIVATE /wd4100) # unreferenced formal parameter
        target_compile_options(Luau.VM PRIVATE /wd4100) # unreferenced formal parameter
    endif()
    target_link_libraries(A2XT_Int INTERFACE Luau.Compiler Luau.VM)
endif()

if(NINTENDO_DS AND CALICO_ROOT)
    add_library(xtbootstrap src/core/16m/boot_16m.c)
    set_property(TARGET xtbootstrap PROPERTY INTERPROCEDURAL_OPTIMIZATION FALSE)
    target_link_libraries(A2XT_Int INTERFACE xtbootstrap)
endif()

add_subdirectory(3rdparty/mbediso EXCLUDE_FROM_ALL)
if(NOT THEXTECH_NO_SDL_BUILD)
    if(NOT USE_SYSTEM_SDL2)
        target_include_directories(mbediso PRIVATE "${DEPENDENCIES_INSTALL_DIR}/include")
        add_dependencies(mbediso AudioCodecs_Local)
    else()
        target_include_directories(mbediso PRIVATE "${SDL2_INCLUDE_DIRS}")
    endif()
endif()
target_link_libraries(A2XT_Int INTERFACE mbediso)
target_compile_definitions(A2XT_Int INTERFACE
    -DPGE_USE_ARCHIVES   # DirMan should use the archives library
    -DPGE_FILES_PRESENT  # DirMan should use the Files checkSuffix routine
)

if(ANDROID)
    set_target_properties(lz4 PROPERTIES POSITION_INDEPENDENT_CODE ON)
    set_target_properties(lz4_static PROPERTIES POSITION_INDEPENDENT_CODE ON)
    set_target_properties(mbediso PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif()


target_link_libraries(A2XT_Int INTERFACE ${A2XT_LIBS})
target_include_directories(A2XT_Int INTERFACE ${A2XT_INCS})

set(LIB_SRC
    lib/util.cpp
    lib/fmt_impl.cpp
    lib/Graphics/image_size.cpp
    lib/Graphics/size.cpp
    lib/Archives/archives_rwops.cpp
    lib/Archives/archives_mount.cpp
    lib/Archives/archives_dir.cpp
    ${APPPATH_SRCS}
    ${DIRMANAGER_SRCS}
    ${FMT_SRCS}
    ${MD5_SRCS}
    ${POOLALLOC_SRCS}
    ${INIPROCESSOR_SRCS}
    ${LOGGER_SRCS}
    ${UTILS_SRCS}
    ${LIB_SRC_EXTRA}
    ${SDLPROXY_SRCS}
)

if(THEXTECH_FIXED_POINT)
    list(APPEND LIB_SRC
        lib/fixed_point.cpp
    )
    target_compile_definitions(A2XT_Int INTERFACE
        -DTHEXTECH_FIXED_POINT
    )
else()
    list(APPEND LIB_SRC
        lib/floating_point.cpp
    )
endif()

if(NOT THEXTECH_NO_SDL_BUILD)
list(APPEND LIB_SRC
    lib/Graphics/graphics_funcs.cpp
)
endif()

if(NOT ANDROID
   AND NOT EMSCRIPTEN
   AND NOT VITA
   AND NOT NINTENDO_3DS
   AND NOT NINTENDO_WII
   AND NOT NINTENDO_WIIU
   AND NOT NINTENDO_SWITCH
   AND NOT THEXTECH_CLI_BUILD
   AND NOT PGE_MIN_PORT)
    list(APPEND LIB_SRC
        lib/InterProcess/editor_pipe.h
        lib/InterProcess/editor_pipe.cpp
        lib/InterProcess/intproc.h
        lib/InterProcess/intproc.cpp
        src/capabilities.cpp
    )
    set(THEXTECH_INTERPROC_SUPPORTED ON)
endif()

# Integrations with external applications
if(THEXTECH_ENABLE_INTEGRATOR)
    list(APPEND LIB_SRC
        lib/Integrator/integrator.h
        lib/Integrator/integrator.cpp)

    if(THEXTECH_ENABLE_DISCORD_RPC)
        list(APPEND LIB_SRC
            lib/Integrator/int_discorcrpc.h
            lib/Integrator/int_discorcrpc.cpp
        )
    endif()
endif()

if(THEXTECH_ENABLE_SDL_NET)
    list(APPEND LIB_SRC
        src/main/client.cpp
        src/main/client_methods.cpp)
endif()

if(NOT NINTENDO_3DS AND NOT NINTENDO_WII AND NOT NINTENDO_WIIU AND NOT NINTENDO_SWITCH AND NOT VITA AND NOT PGE_MIN_PORT)
    list(APPEND LIB_SRC ${FILEMAPPER_SRCS})
    set(THEXTECH_FILEMAPPER_SUPPORTED ON)
endif()


if(NINTENDO_3DS OR NINTENDO_WII OR NOT PGE_MIN_PORT)
    list(APPEND LIB_SRC
        ${STACK_WALKER_SRCS}
        lib/CrashHandler/crash_handler.cpp
    )
    set(THEXTECH_CRASHHANDLER_SUPPORTED ON)
endif()

if(PGE_ENABLE_VIDEO_REC)
    list(APPEND LIB_SRC ${VIDEO_REC_SRCS})
endif()

if(APPLE)
    file(GLOB PGE_FILE_ICONS "${CMAKE_CURRENT_SOURCE_DIR}/resources/file_icons/*.icns")
    list(APPEND LIB_SRC
        ${XTECH_DEFAULT_ICNS}
        ${PGE_FILE_ICONS}
        ${CMAKE_CURRENT_SOURCE_DIR}/resources/PkgInfo
    )

    if(XTECH_MACOSX_TIGER)
        set(THEXTECH_MAC_EXEX_GENERATED "${CMAKE_BINARY_DIR}/generated/TheXTechRun")
        configure_file("${CMAKE_CURRENT_SOURCE_DIR}/resources/tiger/TheXTechRun.in" "${THEXTECH_MAC_EXEX_GENERATED}_tmp/TheXTechRun")
        file(COPY
            "${THEXTECH_MAC_EXEX_GENERATED}_tmp/TheXTechRun"
            DESTINATION "${CMAKE_BINARY_DIR}/generated/"
            FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
        )
        list(APPEND LIB_SRC "${THEXTECH_MAC_EXEX_GENERATED}")
    endif()
endif()

set(THEXTECH_SRC
    src/game_main.cpp
    src/globals.cpp
    src/npc.cpp
    src/sound.cpp
    src/sound_spatial.cpp
    src/sound/sound_msgsnd.cpp
    src/frame_timer.cpp
    src/global_dirs.cpp
    src/global_strings.cpp
    src/config/config_base.cpp
    src/config/config_hooks.cpp
    src/config/config_legacy_compat.cpp
    src/config/config_main.cpp
    src/main/world_loop.cpp
    src/main/world_file.cpp
    src/main/game_info.cpp
    src/main/game_loop.cpp
    src/main/gameplay_timer.cpp
    src/main/player_frames.cpp
    src/main/setup_vars.cpp
    src/main/setup_physics.cpp
    src/main/speedrunner.cpp
    src/main/record.cpp
    src/main/game_save.cpp
    src/main/level_save_info.cpp
    src/main/level_medals.cpp
    src/main/main_config.cpp
    src/main/level_file.cpp
    src/main/menu_loop.cpp
    src/main/menu_main.cpp
    src/main/screen_pause.cpp
    src/main/screen_connect.cpp
    src/main/screen_options.cpp
    src/main/screen_quickreconnect.cpp
    src/main/screen_textentry.cpp
    src/main/screen_prompt.cpp
    src/main/screen_progress.cpp
    src/main/screen_content.cpp
    src/main/hints.cpp
    src/main/game_strings.cpp
    src/main/translate.cpp
    src/main/translate_episode.cpp
    src/main/menu_controls.cpp
    src/main/cheat_code.cpp
    src/main/outro_loop.cpp
    src/main/trees.cpp
    src/main/block_table.cpp
    src/main/asset_pack.cpp
    src/main/screen_asset_pack.cpp
    src/graphics/gfx_update2.cpp
    src/graphics/gfx_update.cpp
    src/graphics/gfx_background.cpp
    src/graphics/gfx_print.cpp
    src/graphics/gfx_message.cpp
    src/graphics/gfx_editor.cpp
    src/graphics/gfx_frame.cpp
    src/graphics/gfx_camera.cpp
    src/graphics/gfx_world.cpp
    src/graphics/gfx_credits.cpp
    src/graphics/gfx_hud.cpp
    src/graphics/gfx_enter_screen.cpp
    src/graphics/gfx_draw_player.cpp
    src/graphics/gfx_special_frames.cpp
    src/graphics/gfx_screen.cpp
    src/graphics/gfx_keyhole.cpp
    src/graphics/gfx_marquee.cpp
    src/control/duplicate.cpp
    src/control/controls.cpp
    src/core/xerror.cpp
    src/script/msg_preprocessor.cpp
    src/script/msg_macros.cpp
    src/logic/object_graph.cpp
    src/change_res.cpp
    src/effect.cpp
    src/collision.cpp
    src/load_gfx.cpp
    src/layers.cpp
    src/saved_layers.cpp
    src/custom.cpp
    src/graphics.cpp
    src/main.cpp
    src/blocks.cpp
    src/gfx.cpp
    src/frm_main.cpp
    src/player.cpp
    src/rand.cpp
    src/sorting.cpp
    src/screen.cpp
    src/screen_fader.cpp
    src/message.cpp
    src/std_picture.cpp
    src/phys_env.cpp
    src/npc/npc_hit.cpp
    src/npc/npc_kill.cpp
    src/npc/npc_update.cpp
    src/npc/npc_update/npc_movement_logic.cpp
    src/npc/npc_update/npc_block_logic.cpp
    src/npc/npc_update/npc_collide.cpp
    src/npc/npc_update/npc_walking_logic.cpp
    src/npc/npc_update/npc_effects.cpp
    src/npc/npc_update/npc_special_maybe_held.cpp
    src/npc/npc_update/npc_generator.cpp
    src/npc/npc_frames.cpp
    src/npc/npc_bonus.cpp
    src/npc/npc_queues.cpp
    src/npc/section_overlap.cpp
    src/npc/npc_activation.cpp
    src/player/player_update.cpp
    src/player/player_npc_logic.cpp
    src/player/player_block_logic.cpp
    src/player/player_vine_logic.cpp
    src/player/player_screen_logic.cpp
    src/player/player_fairy_logic.cpp
    src/player/player_action_logic.cpp
    src/player/player_movement_logic.cpp
    src/player/player_pinched_logic.cpp
    src/player/player_death_logic.cpp
    src/player/player_vehicle_logic.cpp
    src/player/player_char5_logic.cpp
    src/player/player_warp_logic.cpp
    src/fontman/font_manager.cpp
    src/fontman/font_manager_private.cpp
    src/fontman/raster_font.cpp
    src/fontman/legacy_font.cpp
    src/fontman/hardcoded_font.cpp
    src/fontman/utf8_helpers.cpp
)

if(NOT CMAKE_BUILD_TYPE_LOWER STREQUAL "debug")
    # some performance-critical files get special treatment, even though the executable overall is normally -Os
    set_source_files_properties(
        src/main/trees.cpp
        src/main/block_table.cpp
    PROPERTIES COMPILE_FLAGS -O2)
endif()

if(NOT THEXTECH_NO_SDL_BUILD)
    list(APPEND THEXTECH_SRC src/sound_thread.cpp)
endif()

if(THEXTECH_ENABLE_TTF_SUPPORT)
    add_definitions(-DTHEXTECH_ENABLE_TTF_SUPPORT)
    list(APPEND THEXTECH_SRC
        src/fontman/ttf_font.cpp
    )
endif()

# Luna Autocode script engine
list(APPEND THEXTECH_SRC
    src/script/luna/lunaglobals.cpp
    src/script/luna/lunacounter.cpp
    src/script/luna/lunacounter_record.cpp
)

if(THEXTECH_ENABLE_LUNA_AUTOCODE)
    add_definitions(-DTHEXTECH_ENABLE_LUNA_AUTOCODE)
    list(APPEND THEXTECH_SRC
        src/script/luna/luna.cpp
        src/script/luna/autocode.cpp
        src/script/luna/autocode_manager.cpp
        src/script/luna/csprite.cpp
        src/script/luna/lunaspriteman.cpp
        src/script/luna/hitbox.cpp
        src/script/luna/lunaimgbox.cpp
        src/script/luna/sprite_component.cpp
        src/script/luna/sprite_funcs.cpp
        src/script/luna/lunalevels.cpp
        src/script/luna/lunaplayer.cpp
        src/script/luna/lunanpc.cpp
        src/script/luna/lunablock.cpp
        src/script/luna/lunalayer.cpp
        src/script/luna/lunamisc.cpp
        src/script/luna/lunalevel.cpp
        src/script/luna/lunarender.cpp
        src/script/luna/lunainput.cpp
        src/script/luna/lunavarbank.cpp
        src/script/luna/renderop_bitmap.cpp
        src/script/luna/renderop_rect.cpp
        src/script/luna/renderop_effect.cpp
        src/script/luna/renderop_string.cpp
        src/script/luna/mememu.cpp
        src/script/luna/levels/Docopoper-AbstractAssault.cpp
        src/script/luna/levels/Docopoper-Calleoca.cpp
        src/script/luna/levels/Docopoper-TheFloorisLava.cpp
        src/script/luna/levels/SAJewers-QraestoliaCaverns.cpp
        src/script/luna/levels/SAJewers-Snowboardin.cpp
        src/script/luna/levels/Talkhaus-Science_Final_Battle.cpp
        src/script/luna/levels/KilArmoryCode.cpp
    )
endif()

if(THEXTECH_ENABLE_AUDIO_FX)
    add_definitions(-DTHEXTECH_ENABLE_AUDIO_FX)
    list(APPEND THEXTECH_SRC
        src/sound/fx/spc_echo.cpp
        src/sound/fx/reverb.cpp
    )
endif()

if(THEXTECH_ENABLE_EDITOR)
    add_definitions(-DTHEXTECH_ENABLE_EDITOR)
    list(APPEND THEXTECH_SRC
        src/editor/editor.cpp
        src/editor/new_editor.cpp
        src/editor/write_common.cpp
        src/editor/write_level.cpp
        src/editor/write_world.cpp
        src/editor/editor_custom.cpp
        src/editor/editor_strings.cpp
        src/editor/magic_block.cpp
    )
endif()

if(THEXTECH_ENABLE_LUAU)
    target_compile_definitions(A2XT_Int INTERFACE -DTHEXTECH_ENABLE_LUAU)
    list(APPEND THEXTECH_SRC
        src/script/luau/test.cpp
    )
endif()

if(NINTENDO_3DS)
    add_definitions(-DWINDOW_CUSTOM -DMSGBOX_CUSTOM -DEVENTS_CUSTOM -DRENDER_CUSTOM)
    list(APPEND THEXTECH_SRC
        src/control/input_3ds.cpp
        src/core/3ds/render_3ds.cpp
        src/core/3ds/window_3ds.cpp
        src/core/3ds/msgbox_3ds.cpp
        src/core/3ds/events_3ds.cpp
#        src/core/3ds/3ds-audio-lib.cpp
        src/core/sdl/sdl_core.cpp
        src/core/power/power_3ds.cpp
    )
elseif(NINTENDO_WII)
    add_definitions(-DWINDOW_CUSTOM -DMSGBOX_CUSTOM -DEVENTS_CUSTOM -DRENDER_CUSTOM)
    list(APPEND THEXTECH_SRC
        src/control/input_wii.cpp
        src/control/input_wii_gc.cpp
        src/core/wii/render_wii.cpp
        src/core/wii/window_wii.cpp
        src/core/wii/msgbox_wii.cpp
        src/core/wii/events_wii.cpp
        src/core/sdl/sdl_core.cpp
        src/core/power/power_wii.cpp
    )
elseif(NINTENDO_DS)
    add_definitions(-DWINDOW_CUSTOM -DMSGBOX_CUSTOM -DEVENTS_CUSTOM -DRENDER_CUSTOM -DTHEXTECH_NO_SDL_CORE)
    list(REMOVE_ITEM THEXTECH_SRC src/sound.cpp src/sound/sound_msgsnd.cpp)

    list(APPEND THEXTECH_SRC
        src/control/input_16m.cpp
        src/core/16m/render_16m.cpp
        src/core/16m/msgbox_16m.cpp
        src/core/16m/window_16m.cpp
        src/core/16m/events_16m.cpp
        src/core/16m/sound_16m.cpp
        src/core/16m/sound_stream_16m.cpp
        src/core/power/power_16m.cpp
    )
elseif(THEXTECH_NO_SDL_BUILD)
    add_definitions(-DWINDOW_CUSTOM -DMSGBOX_CUSTOM -DEVENTS_CUSTOM -DRENDER_CUSTOM -DTHEXTECH_NO_SDL_CORE)
    list(APPEND THEXTECH_SRC
        src/core/null/render_null.cpp
        src/core/null/window_null.cpp
        src/core/null/msgbox_null.cpp
        src/core/null/events_null.cpp
        src/core/power/power_null.cpp
    )
elseif(THEXTECH_CLI_BUILD)
    add_definitions(-DWINDOW_CUSTOM -DMSGBOX_CUSTOM -DEVENTS_CUSTOM -DRENDER_CUSTOM)
    list(APPEND THEXTECH_SRC
        src/core/null/render_null.cpp
        src/core/null/window_null.cpp
        src/core/null/msgbox_null.cpp
        src/core/null/events_null.cpp
        src/core/sdl/sdl_core.cpp
        src/core/power/power_null.cpp
    )
else()
    add_definitions(-DCORE_EVERYTHING_SDL)
    list(APPEND THEXTECH_SRC
        src/control/joystick.cpp
        src/control/keyboard.cpp
        src/control/touchscreen.cpp
        src/core/base/render_base.cpp
        src/core/base/window_base.cpp
        src/core/base/msgbox_base.cpp
        src/core/base/events_base.cpp
        src/core/sdl/render_sdl.cpp
        src/core/sdl/window_sdl.cpp
        src/core/sdl/msgbox_sdl.cpp
        src/core/sdl/events_sdl.cpp
        src/core/sdl/sdl_core.cpp
        src/core/power/power_sdl.cpp
        lib/Graphics/xt_qoi.cpp
    )

    if(NOT THEXTECH_FORCE_FULLSCREEN AND NOT EMSCRIPTEN)
        add_definitions(-DRENDER_FULLSCREEN_TYPES_SUPPORTED)
    endif()

    if(NINTENDO_WIIU)
        list(APPEND THEXTECH_SRC
            src/core/wiiu/msgbox_wiiu.cpp
        )
    else()
        list(APPEND THEXTECH_SRC
            src/core/sdl/msgbox_sdl.cpp
        )
    endif()

    if(THEXTECH_BUILD_GL_DESKTOP_MODERN OR THEXTECH_BUILD_GL_DESKTOP_LEGACY OR THEXTECH_BUILD_GL_ES_MODERN OR THEXTECH_BUILD_GL_ES_LEGACY)
        list(APPEND THEXTECH_SRC
            src/core/opengl/gl_program_object.cpp
            src/core/opengl/render_gl_frontend.cpp
            src/core/opengl/render_gl_backend.cpp
            src/core/opengl/render_gl_init.cpp
            src/core/opengl/render_gl_shaders.cpp
            src/core/opengl/render_gl_shader_lighting.cpp
        )
    endif()

    if(THEXTECH_BUILD_GL_DESKTOP_MODERN OR THEXTECH_BUILD_GL_ES_MODERN)
        list(APPEND THEXTECH_SRC
            src/core/opengl/gl_program_bank.cpp
            src/core/opengl/gl_particle_system.cpp
        )
    endif()

    if(THEXTECH_BUILD_GL_DESKTOP_MODERN AND THEXTECH_USE_ANGLE_TRANSLATOR)
        add_definitions(-DTHEXTECH_USE_ANGLE_TRANSLATOR)
        list(APPEND THEXTECH_SRC
            src/core/opengl/gl_shader_translator.cpp
        )
    endif()

endif()


list(APPEND THEXTECH_SRC src/core/language/language_common.cpp)

# Notes:
# - First, algorithm will try to detect language using SDL's method if available (Supported by SDL 2.0.14 and newer)
# - Then, falls to the system specific code to detect the language
# If there is a necessary to disable use of SDL-based language detection,
# define the macro `THEXTECH_DISABLE_SDL_LOCALE` which will completely disable the SDL-based language detector

if(THEXTECH_NO_SDL_BUILD)
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE)
endif()

if(WIN32)
    list(APPEND THEXTECH_SRC src/core/language/language_win32.cpp)
elseif(APPLE)
    list(APPEND THEXTECH_SRC src/core/language/language_apple.cpp)
elseif(ANDROID)
    list(APPEND THEXTECH_SRC src/core/language/language_android.cpp)
elseif(NINTENDO_DS)
    # FIXME: Implement the Nintendo DS language initializer
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE)
    list(APPEND THEXTECH_SRC src/core/language/language_dummy.cpp)
elseif(NINTENDO_3DS)
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE) # SDL for 3DS doesn't support language detection
    list(APPEND THEXTECH_SRC src/core/language/language_3ds.cpp)
elseif(NINTENDO_WII)
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE) # SDL for Wii doesn't support language detection
    list(APPEND THEXTECH_SRC src/core/language/language_wii.cpp)
elseif(NINTENDO_WIIU)
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE) # SDL for WiiU doesn't support language detection
    list(APPEND THEXTECH_SRC src/core/language/language_wiiu.cpp)
elseif(NINTENDO_SWITCH)
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE) # SDL for Switch doesn't support language detection
    list(APPEND THEXTECH_SRC src/core/language/language_switch.cpp)
elseif(VITA)
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE)
    list(APPEND THEXTECH_SRC src/core/language/language_vita.cpp)
elseif(UNIX)
    list(APPEND THEXTECH_SRC src/core/language/language_unix.cpp)
else()
    add_definitions(-DTHEXTECH_DISABLE_SDL_LOCALE)
    list(APPEND THEXTECH_SRC src/core/language/language_dummy.cpp)
endif()


# Add heads into the list
file(GLOB THEXTECH_HEADS_SRC
    *.h
    lib/*.h
    lib/AppPath/*.h
    lib/CrashHandler/*.h
    lib/Graphics/*.h
    lib/tclap/*.h
    lib/fmt/*.h
    lib/sorting/*.h
    lib/Archives/*.h
    lib/json/*.hpp
    src/*.h
    src/*.hpp
    src/script/*.h
    src/script/luna/*.h
    src/script/luna/level/*.h
    src/control/*.h
    src/core/*.h
    src/core/16m/*.h
    src/core/3ds/*.h
    src/core/base/*.h
    src/core/language/*.h
    src/core/minport/*.h
    src/core/null/*.h
    src/core/opengl/*.h
    src/core/power/*.h
    src/core/sdl/*.h
    src/core/vita/*.h
    src/core/wii/*.h
    src/core/wiiu/*.h
    src/editor/*.h
    src/main/*.h
    src/main/translate/*.h
    src/main/*.hpp
    src/npc/*.h
    src/npc/*.hpp
    src/sound/*.h
    src/sound/fx/*.h
    src/sound/fx/*.hpp
    src/fontman/*.h
)
list(APPEND THEXTECH_SRC ${THEXTECH_HEADS_SRC})

# ----------------------------------------------------
# Non-buildable meta files such as change log, Readmes, etc.
set(THEXTECH_EXTRA_RESOURCES
    changelog.txt
    README.md
    README.RUS.md
    README.ESP.md
    resources/thextech.plist.in
    resources/thextech.plist.tiger.in
    resources/emscripten/manifest.json.in
    resources/emscripten/shell_minimal.html
    resources/emscripten/sw.js.in
    resources/flatpak/appdata.xml.in
    resources/flatpak/build.yml
    resources/haiku/PackageInfo.in
    resources/haiku/icon.hvif
    resources/haiku/icon.rdef
    resources/vita/frag.cgf
    resources/vita/vert.cgv
    resources/vita/sce_sys/icon0.png
    resources/vita/sce_sys/livearea/contents/bg.png
    resources/vita/sce_sys/livearea/contents/startup.png
    resources/vita/sce_sys/livearea/contents/template.xml.in
    resources/nds/icon.bmp
    resources/switch/splash_logo.png
    resources/switch/thextech-logo.jpg
    resources/switch/thextech-logo.png
    resources/tiger/TheXTechRun.in
    resources/wii/icon.png
    resources/wii/meta.xml.in
    resources/wiiu/icon.png
    resources/wiiu/meta.xml.in
    resources/wiiu/wuhb-splash.png
)

list(APPEND THEXTECH_SRC ${THEXTECH_EXTRA_RESOURCES})
set_source_files_properties(${THEXTECH_EXTRA_RESOURCES} PROPERTIES HEADER_FILE_ONLY ON)
source_group("Resources" FILES ${THEXTECH_EXTRA_RESOURCES})

# ------------------ Unit tests ----------------------
option(WITH_UNIT_TESTS "Enable unit testing" OFF)
if(WITH_UNIT_TESTS)
    enable_testing()
    add_subdirectory(test)
endif()

# ----------------------------------------------------

if(WIN32 AND NOT EMSCRIPTEN)
    list(APPEND THEXTECH_SRC resources/thextech.rc)
endif()

if(THEXTECH_ENABLE_LUA)
    add_subdirectory(script)
    target_link_libraries(A2XT_Int INTERFACE XTechLua ${libLuaBind_Lib} ${libLuaJit_Lib})
    if(UNIX)
        find_library(LIB_DL_PATH dl)
        if(LIB_DL_PATH)
            target_link_libraries(A2XT_Int INTERFACE ${LIB_DL_PATH})
        endif()
    endif()
endif()

if(ANDROID)
    set(CMAKE_DEBUG_POSTFIX "")
    add_library(thextech SHARED ${THEXTECH_SRC} ${LIB_SRC})
    target_compile_options(thextech PRIVATE -fPIC)

    target_link_options(thextech PUBLIC "-Wl,-z,max-page-size=16384")
    target_link_options(thextech PUBLIC "-Wl,-z,common-page-size=16384")

    # Include own-built libraries into the APK
    set(APK_PACK_LIBS ${CMAKE_SOURCE_DIR}/android-project/thextech/jniLibs/${CMAKE_BUILD_TYPE_LOWER}/${ANDROID_ABI})
    add_custom_target(SDL_ApkPackLibs_makeDir ALL COMMAND ${CMAKE_COMMAND} -E make_directory "${APK_PACK_LIBS}")

    if(PGE_SHARED_SDLMIXER)
#        add_library(SDL2_mixer_ext SHARED IMPORTED DEPENDS SDLMixerX_Local AudioCodecs_Local)
#        set_target_properties(SDL2_mixer_ext PROPERTIES IMPORTED_LOCATION "${DEPENDENCIES_INSTALL_DIR}/lib/libSDL2_mixer_ext.so")
        add_custom_target(SDL_ApkPackLibs_mixerx ALL
            COMMAND ${CMAKE_COMMAND} -E copy "${DEPENDENCIES_INSTALL_DIR}/lib/libSDL2_mixer_ext.so" "${APK_PACK_LIBS}"
            DEPENDS SDL_ApkPackLibs_makeDir ${DEPENDENCIES_INSTALL_DIR}/lib/libSDL2_mixer_ext.so AudioCodecs_Local
        )
        add_dependencies(thextech SDL_ApkPackLibs_mixerx)

#        add_library(SDL2 SHARED IMPORTED DEPENDS AudioCodecs_Local)
#        set_target_properties(SDL2 PROPERTIES IMPORTED_LOCATION "${DEPENDENCIES_INSTALL_DIR}/lib/libSDL2.so")
        add_custom_target(SDL_ApkPackLibs_sdl2 ALL
            COMMAND ${CMAKE_COMMAND} -E copy "${DEPENDENCIES_INSTALL_DIR}/lib/libSDL2.so" "${APK_PACK_LIBS}"
            DEPENDS SDL_ApkPackLibs_makeDir ${DEPENDENCIES_INSTALL_DIR}/lib/libSDL2.so AudioCodecs_Local
        )
        add_dependencies(thextech SDL_ApkPackLibs_sdl2)
    endif()

#    add_library(hidapi SHARED IMPORTED DEPENDS AudioCodecs_Local)
#    set_target_properties(hidapi PROPERTIES IMPORTED_LOCATION "${DEPENDENCIES_INSTALL_DIR}/lib/libhidapi.so")

# libhidapi.so is NO LONGER required since SDL 2.0.18
#    add_custom_target(SDL_ApkPackLibs_hidapi ALL
#        COMMAND ${CMAKE_COMMAND} -E copy "${DEPENDENCIES_INSTALL_DIR}/lib/libhidapi.so" "${APK_PACK_LIBS}"
#        DEPENDS SDL_ApkPackLibs_makeDir "${DEPENDENCIES_INSTALL_DIR}/lib/libhidapi.so" AudioCodecs_Local
#    )
#    add_dependencies(thextech SDL_ApkPackLibs_hidapi)

elseif(NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_3DS OR NINTENDO_DS)
    add_executable(thextech ${THEXTECH_SRC} ${LIB_SRC})
    set_target_properties(thextech PROPERTIES SUFFIX ".elf")

else()
    add_executable(thextech ${THEXTECH_SRC} ${LIB_SRC})
    pge_set_nopie(thextech)
endif()

add_dependencies(thextech git_version)
target_include_directories(thextech PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/generated-include")

set_target_properties(thextech PROPERTIES
    OUTPUT_NAME "${THEXTECH_EXECUTABLE_NAME}"
)

if(CMAKE_BUILD_TYPE_LOWER STREQUAL "debug" OR CMAKE_BUILD_TYPE_LOWER STREQUAL "relwithdebinfo")
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_DEBUG_INFO)
endif()

if(APPLE)
    if(XTECH_MACOSX_TIGER)
        set(THEXTECH_EXECUTABLE_NAME_OUT TheXTechRun)
    else()
        set(THEXTECH_EXECUTABLE_NAME_OUT ${THEXTECH_EXECUTABLE_NAME})
    endif()

    set_target_properties(thextech PROPERTIES
        OUTPUT_NAME "${THEXTECH_BUNDLE_NAME}"
        MACOSX_BUNDLE TRUE
        MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/resources/${XTECH_PLIST_NAME}"
        MACOSX_BUNDLE_BUNDLE_NAME "${THEXTECH_BUNDLE_NAME}"
        MACOSX_BUNDLE_EXECUTABLE_NAME "${THEXTECH_EXECUTABLE_NAME_OUT}"
        MACOSX_BUNDLE_GUI_IDENTIFIER "ru.wohlsoft.thextech"
        MACOSX_BUNDLE_SHORT_VERSION_STRING "${THEXTECH_VERSION_STRING}"
        MACOSX_BUNDLE_LONG_VERSION_STRING "${THEXTECH_VERSION_STRING}"
        MACOSX_BUNDLE_ICON_FILE "${THEXTECH_ICON_NAME}"
        CPACK_BUNDLE_NAME "${THEXTECH_BUNDLE_NAME}"
        MACOSX_BUNDLE_INFO_STRING "TheXTech classic game engine"
    )
    set_source_files_properties("${CMAKE_CURRENT_SOURCE_DIR}/${XTECH_DEFAULT_ICNS}" PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
    set_source_files_properties(${PGE_FILE_ICONS} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
    set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/resources/PkgInfo PROPERTIES MACOSX_PACKAGE_LOCATION "")
    if(XTECH_MACOSX_TIGER)
        set_source_files_properties("${THEXTECH_MAC_EXEX_GENERATED}" PROPERTIES MACOSX_PACKAGE_LOCATION "MacOS")
    endif()

    if(THEXTECH_CUSTOM_ICON_PATH AND NOT THEXTECH_CUSTOM_ICON_PATH STREQUAL "")
        set_source_files_properties("${THEXTECH_CUSTOM_ICON_PATH}" PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
    endif()

    if(THEXTECH_PRELOAD_ENVIRONMENT AND NOT THEXTECH_PRELOAD_ENVIRONMENT STREQUAL "")
        add_custom_command(TARGET thextech POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:thextech>/../Resources/assets"
            COMMAND ${CMAKE_COMMAND} -E copy_directory "${THEXTECH_PRELOAD_ENVIRONMENT}" "$<TARGET_FILE_DIR:thextech>/../Resources/assets"
            COMMENT "Copying assets into bundle..."
        )
        target_compile_definitions(thextech PRIVATE -DUSE_BUNDLED_ASSETS)
    endif()

    if(THEXTECH_PRELOAD_ENVIRONMENT_MANUALLY)
        target_compile_definitions(thextech PRIVATE -DUSE_BUNDLED_ASSETS)
    endif()

    if(XTECH_MACOSX_TIGER) # Use X11 mode on Mac OS X Tiger
        target_compile_definitions(thextech PRIVATE -DUSE_APPLE_X11)
    endif()

    check_library_exists(iconv iconv_open "" HAVE_LIBICONV)
    if(HAVE_LIBICONV)
        target_link_libraries(A2XT_Int INTERFACE iconv)
    endif()

    if(PGE_USE_LUAJIT)
        # Required to link on 64-bit macOS
        # See: http://luajit.org/install.html
        set_property(TARGET thextech APPEND_STRING PROPERTY
            LINK_FLAGS " -pagezero_size 10000 -image_base 100000000"
        )
    endif()
endif()

if(ANDROID)
    target_link_libraries(A2XT_Int INTERFACE log)

    if(THEXTECH_BUILD_GL_ES_LEGACY OR THEXTECH_BUILD_GL_ES_MODERN)
        target_link_libraries(A2XT_Int INTERFACE EGL)
    endif()
endif()

if(NINTENDO_SWITCH)
    target_link_libraries(A2XT_Int INTERFACE nx)

    if(THEXTECH_BUILD_GL_DESKTOP_MODERN)
        target_link_libraries(A2XT_Int INTERFACE glad)
    endif()

    # Set explicit flags for this project
    target_compile_definitions(thextech PRIVATE -D__SWITCH__ -DNO_INTPTROC)
endif()

if(VITA)
    if(THEXTECH_BUILD_GL_ES_MODERN)
        target_link_libraries(A2XT_Int INTERFACE vitaGL vitashark)
    endif()

    # Link Vita specific libraries to the generic interface.
    target_link_libraries(A2XT_Int INTERFACE ${VITA_ADDTL_LIBS})

    # Set explicit flags for this project
    target_compile_definitions(thextech PRIVATE
        -DVITA -DNO_SCREENSHOT -DTHEXTECH_PRELOAD_LEVELS -DNO_INTPTROC)
endif()

if(WIN32 AND WINDOWS_STORE)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_WINRT)
endif()

if(NINTENDO_3DS)
    target_compile_definitions(thextech PRIVATE -DPGE_SDL_MUTEX -DLOW_MEM -DTHEXTECH_PRELOAD_LEVELS -D__3DS__)
elseif(NINTENDO_WII)
    target_compile_definitions(thextech PRIVATE -DPGE_SDL_MUTEX -DLOW_MEM -DTHEXTECH_PRELOAD_LEVELS -D__WII__)
elseif(NINTENDO_WIIU)
    target_compile_definitions(thextech PRIVATE -DPGE_SDL_MUTEX)
elseif(NINTENDO_DS)
    target_link_libraries(thextech PRIVATE mm9)
    target_compile_definitions(thextech PRIVATE -DPGE_NO_THREADING -DLOW_MEM -DTHEXTECH_PRELOAD_LEVELS -D__16M__)

    if(CALICO_ROOT)
        target_compile_definitions(thextech PRIVATE -D__CALICO__)
    elseif(BLOCKSDS)
        target_compile_definitions(thextech PRIVATE -D__BLOCKS__)
    endif()

    if(NOT BLOCKSDS)
        target_link_libraries(thextech PRIVATE fat)
        set(CMAKE_EXE_LINKER_FLAGS "-L${CALICO_ROOT}/lib -L${NDS_ROOT}/lib -specs=${CALICO_ROOT}/share/ds9.specs -T ${CMAKE_CURRENT_SOURCE_DIR}/cmake/overlays-16m.ld")
    endif()

    if(BLOCKSDS)
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--defsym,__dtcm_data_size=8")
    endif()
elseif(PGE_MIN_PORT)
    target_compile_definitions(thextech PRIVATE -DLOW_MEM)
endif()

if(VITA OR NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_SWITCH)
    # Run in-game message box to show assert failures on platforms without SDL's message box
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_ASSERTS_INGAME_MESSAGE)
endif()

if(VITA OR NINTENDO_DS OR NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_SWITCH OR ANDROID OR EMSCRIPTEN)
    # Disable language tools at non-desktop platforms
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_DISABLE_LANG_TOOLS)
endif()

if((UNIX OR NINTENDO_SWITCH OR ANDROID OR APPLE) AND NOT EMSCRIPTEN)
    # Allow hotswapping renderer on fully tested platforms
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_RESTART_RENDERER_SUPPORTED)
endif()

if(THEXTECH_NO_SDL_BUILD)
    target_compile_definitions(thextech PRIVATE -DPGE_NO_THREADING -DTHEXTECH_NO_SDL_BUILD)
endif()

if(THEXTECH_CLI_BUILD)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_CLI_BUILD)
endif()

if(THEXTECH_BUILD_GL_DESKTOP_MODERN)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_BUILD_GL_DESKTOP_MODERN)
endif()

if(THEXTECH_BUILD_GL_ES_MODERN)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_BUILD_GL_ES_MODERN)
endif()

if(THEXTECH_BUILD_GL_DESKTOP_MODERN OR THEXTECH_BUILD_GL_ES_MODERN)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_BUILD_GL_MODERN)
endif()

if(THEXTECH_BUILD_GL_DESKTOP_LEGACY)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_BUILD_GL_DESKTOP_LEGACY)
endif()

if(THEXTECH_BUILD_GL_ES_LEGACY)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_BUILD_GL_ES_LEGACY)
endif()

if(THEXTECH_ENABLE_WIP_FEATURES)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_WIP_FEATURES)
endif()

target_compile_definitions(thextech PRIVATE -DTHEXTECH_DIRECTORY_PREFIX="${THEXTECH_DIRECTORY_PREFIX}")

if(THEXTECH_NO_BUILD_DATE)
    target_compile_definitions(thextech PRIVATE -DDISABLE_XTECH_BUILD_DATE)
endif()

if(THEXTECH_ENABLE_LUA)
    target_compile_definitions(thextech PRIVATE -DENABLE_XTECH_LUA)
endif()

if(THEXTECH_ENABLE_INTEGRATOR)
    target_compile_definitions(thextech PRIVATE -DENABLE_XTECH_INTEGRATOR)
endif()

if(THEXTECH_ENABLE_DISCORD_RPC)
    target_compile_definitions(thextech PRIVATE -DENABLE_XTECH_DISCORD_RPC -DXTECH_DISCORD_APPID=${THEXTECH_DISCORD_APPID})
endif()

if(PGE_ENABLE_VIDEO_REC)
    target_compile_definitions(thextech PRIVATE -DPGE_ENABLE_VIDEO_REC)

    if(PGE_VIDEO_REC_WEBM_SUPPORTED)
        target_compile_definitions(thextech PRIVATE -DPGE_VIDEO_REC_WEBM_SUPPORTED)
    endif()
endif()

if(ENABLE_ADDRESS_SANITIZER)
    target_compile_options(thextech PRIVATE -fsanitize=address)
    target_link_options(thextech PRIVATE -fsanitize=address)
endif()

target_include_directories(thextech PRIVATE ${A2XT_INCS})
target_link_libraries(thextech PRIVATE A2XT_Int)

if(THEXTECH_ENABLE_SDL_NET)
    target_link_libraries(thextech PRIVATE SDL2_net)
endif()

if(RANGE_ARR_USE_HEAP)
    target_compile_definitions(thextech PRIVATE -DRANGE_ARR_USE_HEAP)
endif()

if(RANGE_ARR_UNSAFE_MODE)
    target_compile_definitions(thextech PRIVATE -DRANGE_ARR_UNSAFE_MODE)
endif()

if(ENABLE_ANTICHEAT_TRAP)
    target_compile_definitions(thextech PRIVATE -DENABLE_ANTICHEAT_TRAP)
endif()

if(ENABLE_OLD_CREDITS)
    target_compile_definitions(thextech PRIVATE -DENABLE_OLD_CREDITS)
    set_target_properties(thextech PROPERTIES OUTPUT_NAME "smbx")
endif()

if(NOT ENABLE_LOGGING)
    target_compile_definitions(thextech PRIVATE -DDISABLE_LOGGING -DNO_FILE_LOGGING)
endif()

if(EMSCRIPTEN)
    target_compile_definitions(thextech PRIVATE -DPGE_NO_THREADING -DNO_FILE_LOGGING)
endif()

if(THEXTECH_NO_ARGV_HANDLING)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_NO_ARGV_HANDLING)
endif()

if(THEXTECH_INTERPROC_SUPPORTED)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_INTERPROC_SUPPORTED)
endif()

if(THEXTECH_FILEMAPPER_SUPPORTED)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_FILEMAPPER_SUPPORTED)
endif()

if(THEXTECH_CRASHHANDLER_SUPPORTED)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_CRASHHANDLER_SUPPORTED)
endif()

# ======================= Render specific global macros ========================
if(EMSCRIPTEN)
    target_compile_definitions(thextech PRIVATE
        -DNO_WINDOW_FOCUS_TRACKING  # Don't track for window focus
    )
endif()

if(NOT EMSCRIPTEN AND
   NOT NINTENDO_3DS AND
   NOT NINTENDO_WII AND
   NOT NINTENDO_WIIU AND
   NOT PGE_MIN_PORT AND
   NOT THEXTECH_CLI_BUILD)
    target_compile_definitions(thextech PRIVATE
        -DUSE_SCREENSHOTS_AND_RECS  # Built-in screenshots and GIF recording
    )
endif()

if(ANDROID)
    target_compile_definitions(thextech PRIVATE
        -DUSE_RENDER_BLOCKING
    )
endif()

if(THEXTECH_FORCE_FULLSCREEN)
    target_compile_definitions(thextech PRIVATE
        -DRENDER_FULLSCREEN_ALWAYS  # Game works always fullscreen
        -DNO_WINDOW_FOCUS_TRACKING  # Don't track for window focus
    )
endif()

# ==============================================================================

if(NOT USE_SYSTEM_LIBS AND A2XT_DEPS)
    add_dependencies(thextech ${A2XT_DEPS})
endif()

if(THEXTECH_IS_BIG_ENDIAN)
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_BIG_ENDIAN -DSOUND_FX_BIG_ENDIAN)
endif()

if(CMAKE_SIZEOF_VOID_P MATCHES "8")
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_WORDSIZE=64)
elseif(CMAKE_SIZEOF_VOID_P MATCHES "4")
    target_compile_definitions(thextech PRIVATE -DTHEXTECH_WORDSIZE=32)
else()
    message(WARNING "Unknown word size ${CMAKE_SIZEOF_VOID_P}!")
endif()

if(USE_STATIC_LIBC AND NOT USE_SYSTEM_LIBS)
    if(NOT APPLE AND NOT MSVC)
#        target_link_libraries(thextech PRIVATE -static)
        set_property(TARGET thextech APPEND_STRING PROPERTY LINK_FLAGS " -static-libgcc -static-libstdc++")
    endif()

    if(MSVC)
        target_compile_options(thextech PRIVATE /MT)
        target_link_options(thextech PRIVATE /INCREMENTAL:NO /NODEFAULTLIB:MSVCRT)
    endif()
endif()

if (Backtrace_FOUND)
    set_property(TARGET thextech APPEND_STRING PROPERTY LINK_FLAGS " ${Backtrace_LIBRARIES}")
endif()

if(WIN32)
    set_target_properties(thextech PROPERTIES WIN32_EXECUTABLE ON)
    target_compile_definitions(thextech PRIVATE -DNOMINMAX)
    target_link_libraries(thextech PRIVATE "version" dbghelp) # needed by StackWalker
endif()

include(cmake/deploy.cmake)

if(APPLE)
    install(TARGETS thextech DESTINATION .)
    install(FILES changelog.txt DESTINATION .)
    install(FILES README.md DESTINATION . RENAME ReadMe.txt)
    install(FILES LICENSE DESTINATION . RENAME License.txt)
elseif(WIN32)
    # For MinGW toolchain, copy missing DLLs
    if(MINGW)
        function(find_mingw_dll _FieldName _FileName _DestList _SearchPaths)
            find_file(MINGWDLL_${_FieldName} ${_FileName} PATH_SUFFIXES bin PATHS "${_SearchPaths}")
            if(MINGWDLL_${_FieldName})
                list(APPEND ${_DestList} "${MINGWDLL_${_FieldName}}")
                set(${_DestList} ${${_DestList}} PARENT_SCOPE)
            endif()
        endfunction()

        set(MINGW_BIN_PATH "")
        set(MINGW_DLLS)

        find_mingw_dll(LIBGCCDW         "libgcc_s_dw2-1.dll" MINGW_DLLS "${MINGW_BIN_PATH}")
        find_mingw_dll(LIBGCCSJLJ       "libgcc_s_sjlj-1.dll" MINGW_DLLS "${MINGW_BIN_PATH}")
        find_mingw_dll(LIBGCCSEC        "libgcc_s_seh-1.dll" MINGW_DLLS "${MINGW_BIN_PATH}")
        find_mingw_dll(MINGWEX          "libmingwex-0.dll" MINGW_DLLS "${MINGW_BIN_PATH}")
        find_mingw_dll(WINPTHREAD       "libwinpthread-1.dll" MINGW_DLLS "${MINGW_BIN_PATH}")
        find_mingw_dll(WINPTHREADGC3    "pthreadGC-3.dll" MINGW_DLLS "${MINGW_BIN_PATH}")
        find_mingw_dll(STDCPP           "libstdc++-6.dll" MINGW_DLLS "${MINGW_BIN_PATH}")

        message("MinGW DLLs: [${MINGW_DLLS}]")
        file(COPY ${MINGW_DLLS} DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/")
    endif()

    install(TARGETS thextech DESTINATION .)
    file(GLOB BUILT_DLLS "${DEPENDENCIES_INSTALL_DIR}/bin/*-*.dll")
    file(GLOB BUILT_DLLS2 "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/*-*.dll")
    list(APPEND BUILT_DLLS ${BUILT_DLLS2})
    if(NOT USE_SYSTEM_SDL2)
        list(APPEND BUILT_DLLS
            "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/SDL2.dll"
            "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/SDL2_mixer_ext.dll"
        )
    endif()
    install(FILES ${BUILT_DLLS} DESTINATION .)
    install(FILES changelog.txt DESTINATION .)
    install(FILES README.md DESTINATION . RENAME ReadMe.txt)
    install(FILES LICENSE DESTINATION . RENAME License.TheXTech.txt)
elseif(VITA)
    include(cmake/package_vita.cmake)
elseif(NINTENDO_3DS)
    if(NOT "${THEXTECH_VERSION_REL}" STREQUAL "")
        set(SMDH_VERSION "git branch ${GIT_BRANCH} #${GIT_COMMIT_HASH}")
    else()
        set(SMDH_VERSION "Based on SMBX 1.3 by Redigit")
    endif()

    ctr_generate_smdh(OUTPUT "thextech.smdh"
        NAME "TheXTech ${THEXTECH_VERSION_STRING}"
        DESCRIPTION "${SMDH_VERSION}"
        AUTHOR "Wohlstand and ds-sloth"
        ICON "${CMAKE_SOURCE_DIR}/resources/icon/thextech_48.png"
    )

    ctr_create_3dsx(thextech SMDH "thextech.smdh")
elseif(NINTENDO_WII)
    string(TIMESTAMP XTECH_WIIMETA_RELEASE_DATE "%Y%m%d")
    if(NOT "${THEXTECH_VERSION_REL}" STREQUAL "")
        set(XTECH_WIIMETA_SHORT_DESC "git ${GIT_BRANCH} #${GIT_COMMIT_HASH}")
    else()
        set(XTECH_WIIMETA_SHORT_DESC "Based on SMBX 1.3 by Redigit")
    endif()

    configure_file(${CMAKE_SOURCE_DIR}/resources/wii/icon.png ${CMAKE_BINARY_DIR}/package/icon.png COPYONLY)
    configure_file(${CMAKE_SOURCE_DIR}/resources/wii/meta.xml.in ${CMAKE_BINARY_DIR}/package/meta.xml)

    ogc_create_dol(thextech)
    add_custom_command(TARGET thextech POST_BUILD
                       COMMAND ${CMAKE_COMMAND} -E copy
                           ${CMAKE_BINARY_DIR}/thextech.dol
                           ${CMAKE_BINARY_DIR}/package/boot.dol
                       COMMENT "Copying thextech executable into package")
elseif(NINTENDO_WIIU)
    string(TIMESTAMP XTECH_WIIMETA_RELEASE_DATE "%Y%m%d")
    configure_file(${CMAKE_SOURCE_DIR}/resources/wiiu/icon.png ${CMAKE_BINARY_DIR}/icon.png COPYONLY)
    configure_file(${CMAKE_SOURCE_DIR}/resources/wiiu/meta.xml.in ${CMAKE_BINARY_DIR}/meta.xml)
    wut_create_rpx(thextech)
    wut_create_wuhb(thextech
        CONTENT
        NAME "TheXTech v${THEXTECH_VERSION_STRING}"
        SHORTNAME "TheXTech"
        AUTHOR "Wohlstand and ds-sloth"
        ICON "${CMAKE_SOURCE_DIR}/resources/switch/thextech-logo.png"
        TVSPLASH "${CMAKE_SOURCE_DIR}/resources/wiiu/wuhb-splash.png"
        DRCSPLASH "${CMAKE_SOURCE_DIR}/resources/wiiu/wuhb-splash.png"
    )
elseif(NINTENDO_DS)
    if(NOT "${THEXTECH_VERSION_REL}" STREQUAL "")
        set(ROM_VERSION "${GIT_BRANCH} #${GIT_COMMIT_HASH}")
    else()
        set(ROM_VERSION "Based on SMBX 1.3")
    endif()

    nds_create_rom(thextech
        NAME "TheXTech ${THEXTECH_VERSION_STRING}"
        SUBTITLE1 "Wohlstand and ds-sloth"
        SUBTITLE2 "${ROM_VERSION}"
        ICON "${CMAKE_SOURCE_DIR}/resources/nds/icon.bmp"
    )
elseif(NINTENDO_SWITCH)
    include(cmake/package_switch.cmake)
elseif(EMSCRIPTEN)
    add_custom_command(
        TARGET thextech POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E rename
                "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${THEXTECH_EXECUTABLE_NAME}.html"
                "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/index.html")

    add_custom_command(
        TARGET thextech POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy
                "${PGE_PRELOAD_ENVIRONMENT}/graphics/ui/icon/thextech.ico"
                "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/favicon.ico")

    add_custom_command(
        TARGET thextech POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy
                "${PGE_PRELOAD_ENVIRONMENT}/graphics/ui/icon/thextech_32.png"
                "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/thextech_32.png")

    add_custom_command(
        TARGET thextech POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy
                "${PGE_PRELOAD_ENVIRONMENT}/graphics/ui/icon/thextech_256.png"
                "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/thextech_256.png")

    configure_file(${CMAKE_SOURCE_DIR}/resources/emscripten/manifest.json.in ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/manifest.json)
    configure_file(${CMAKE_SOURCE_DIR}/resources/emscripten/sw.js.in ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/sw.js)

elseif(HAIKU)
    string(TIMESTAMP XTECH_HAIKU_COPYRIGHT_YEAR "%Y")
    message("-- Haiku package version: ${THEXTECH_HAIKU_VERSION_STRING} (Yer ${XTECH_HAIKU_COPYRIGHT_YEAR})")
    set(DESKTOP_NAME "TheXTech" CACHE STRING "Name for the application icon")
    set(XTECH_HAIKU_SHORT_DESC "TheXTech is an open-source continuation of the SMBX 1.3 platformer game engine. Its highest priority is full compatibility with the SMBX 1.3 content standard, but it also adds a number of enhancements and bugfixes." CACHE STRING "Description for the installable Haiku package.")
    configure_file("${CMAKE_SOURCE_DIR}/resources/haiku/PackageInfo.in" "${CMAKE_BINARY_DIR}/package/.PackageInfo")

    set_target_properties(thextech PROPERTIES LINK_FLAGS "-Wl,-rpath,'$ORIGIN/../lib'")

    add_custom_command(
        TARGET thextech POST_BUILD
        COMMAND rc
                -o "${CMAKE_BINARY_DIR}/icon.rsrc"
                "${CMAKE_SOURCE_DIR}/resources/haiku/icon.rdef"
                COMMENT "Preparing icon file...")

    add_custom_command(
        TARGET thextech POST_BUILD
        COMMAND resattr
                -o "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${THEXTECH_EXECUTABLE_NAME}"
                "${CMAKE_BINARY_DIR}/icon.rsrc"
        COMMENT "Assigning icon to ${THEXTECH_EXECUTABLE_NAME}...")

    if(NOT EXISTS "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}")
        file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/bin")
        file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/lib")
        file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/doc")
    endif()

    if(NOT EXISTS "${CMAKE_BINARY_DIR}/package/data/deskbar/menu/Applications")
        file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/package/data/deskbar/menu/Applications")
    endif()

    add_custom_target(make_hkpg
        DEPENDS "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/bin/${THEXTECH_EXECUTABLE_NAME}"
        COMMENT "Creating HPKG package..."
    )

    add_custom_command(
        OUTPUT "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/bin/${THEXTECH_EXECUTABLE_NAME}"
        DEPENDS "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${THEXTECH_EXECUTABLE_NAME}"
        COMMAND
            ${CMAKE_COMMAND} -E copy
            "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${THEXTECH_EXECUTABLE_NAME}"
            "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/bin/${THEXTECH_EXECUTABLE_NAME}"
    )

    add_custom_command(
        TARGET make_hkpg PRE_BUILD
        COMMAND
            ${CMAKE_COMMAND} -E copy
            "${CMAKE_SOURCE_DIR}/changelog.txt"
            "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/doc/changelog.txt"
    )

    add_custom_command(
        TARGET make_hkpg PRE_BUILD
        COMMAND
            ${CMAKE_COMMAND} -E copy
            "${CMAKE_SOURCE_DIR}/README.md"
            "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/doc/ReadMe.txt"
    )

    add_custom_command(
        TARGET make_hkpg PRE_BUILD
        COMMAND
            ${CMAKE_COMMAND} -E copy
            "${CMAKE_SOURCE_DIR}/LICENSE"
            "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/doc/License.TheXTech.txt"
    )

    add_custom_command(
        TARGET make_hkpg PRE_BUILD
        COMMAND resattr
                -o "${CMAKE_BINARY_DIR}/package/apps/${THEXTECH_DIRECTORY_PREFIX}/bin/${THEXTECH_EXECUTABLE_NAME}"
                "${CMAKE_BINARY_DIR}/icon.rsrc"
        COMMENT "Assigning icon to ${THEXTECH_EXECUTABLE_NAME}...")

    add_custom_command(
        TARGET make_hkpg PRE_BUILD
        COMMAND cp -a "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/*.so*" "${CMAKE_BINARY_DIR}/package/apps/TheXTech/lib/"
    )

    add_custom_command(
        TARGET make_hkpg PRE_BUILD
        COMMAND ${CMAKE_COMMAND} -E create_symlink
                "../../../../apps/TheXTech/bin/${THEXTECH_EXECUTABLE_NAME}"
                "${CMAKE_BINARY_DIR}/package/data/deskbar/menu/Applications/${DESKTOP_NAME}"
    )

    add_custom_command(
        TARGET make_hkpg POST_BUILD
        COMMAND package create -C "${CMAKE_BINARY_DIR}/package/"
                "${CMAKE_BINARY_DIR}/${THEXTECH_INSTALLER_PACKAGE_NAME}_bin-${THEXTECH_HAIKU_VERSION_STRING}-${TARGET_PROCESSOR}.hpkg"
    )

else()
    install(TARGETS thextech
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
    )

    if(THEXTECH_UNIX_INSTALL)
        # set up application metadata
        if(NOT HAIKU)
            # application launcher
            if(NOT EXISTS "${DEPENDENCIES_INSTALL_DIR}/share/applications")
                file(MAKE_DIRECTORY "${DEPENDENCIES_INSTALL_DIR}/share/applications")
            endif()

            set(DESKTOP_EXEC ${THEXTECH_EXECUTABLE_NAME})
            set(DESKTOP_ICON ${THEXTECH_EXECUTABLE_NAME})
            set(DESKTOP_WMCLASS ${THEXTECH_EXECUTABLE_NAME})
            set(DESKTOP_NAME "TheXTech" CACHE STRING "Name for the application icon")
            set(DESKTOP_GENERIC_NAME "TheXTech Engine" CACHE STRING "")
            set(DESKTOP_COMMENT "TheXTech - the modern C++ port and successor of the SMBX engine" CACHE STRING "Short description of the application")

            configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/icon.desktop.in"
                           "${DEPENDENCIES_INSTALL_DIR}/share/applications/${THEXTECH_EXECUTABLE_NAME}.desktop")
            install(FILES "${DEPENDENCIES_INSTALL_DIR}/share/applications/${THEXTECH_EXECUTABLE_NAME}.desktop"
                    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/applications)

            # flatpak manifest
            set(FLATPAK_BUILD OFF CACHE BOOL "Is this build a part of a flatpak workflow?")
            mark_as_advanced(FLATPAK_BUILD)
            if(FLATPAK_BUILD)
                set(FLATPAK_DESCRIPTION "TheXTech is an open-source continuation of the SMBX 1.3 platformer game engine. Its highest priority is full compatibility with the SMBX 1.3 content standard, but it also adds a number of enhancements and bugfixes." CACHE STRING "Description for the installable flatpak package.")

                configure_file("${CMAKE_CURRENT_SOURCE_DIR}/resources/flatpak/appdata.xml.in"
                               "${DEPENDENCIES_INSTALL_DIR}/share/metainfo/${THEXTECH_EXECUTABLE_NAME}.metainfo.xml")
                install(FILES "${DEPENDENCIES_INSTALL_DIR}/share/metainfo/${THEXTECH_EXECUTABLE_NAME}.metainfo.xml"
                        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/metainfo)
            endif()

            # application icons
            set(THEXTECH_ICON_PATH "${CMAKE_CURRENT_SOURCE_DIR}/resources/icon/")

            install(FILES "${THEXTECH_ICON_PATH}/thextech_16.png"
                    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/16x16/apps/" RENAME "${THEXTECH_EXECUTABLE_NAME}.png")
            install(FILES "${THEXTECH_ICON_PATH}/thextech_32.png"
                    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/32x32/apps/" RENAME "${THEXTECH_EXECUTABLE_NAME}.png")
            install(FILES "${THEXTECH_ICON_PATH}/thextech_48.png"
                    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/48x48/apps/" RENAME "${THEXTECH_EXECUTABLE_NAME}.png")
            install(FILES "${THEXTECH_ICON_PATH}/thextech_128.png"
                    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/128x128/apps/" RENAME "${THEXTECH_EXECUTABLE_NAME}.png")
            install(FILES "${THEXTECH_ICON_PATH}/thextech_256.png"
                    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/256x256/apps/" RENAME "${THEXTECH_EXECUTABLE_NAME}.png")
            install(FILES "${THEXTECH_ICON_PATH}/thextech_512.png" OPTIONAL
                    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/512x512/apps/" RENAME "${THEXTECH_EXECUTABLE_NAME}.png")
        endif()

        # install readmes
        install(FILES changelog.txt DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/${THEXTECH_EXECUTABLE_NAME})
        install(FILES README.md DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/${THEXTECH_EXECUTABLE_NAME} RENAME ReadMe.txt)
        install(FILES LICENSE DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/${THEXTECH_EXECUTABLE_NAME} RENAME License.TheXTech.txt)
    else()
        install(FILES changelog.txt DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/thextech)
        install(FILES README.md DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/thextech RENAME ReadMe.txt)
        install(FILES LICENSE DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/thextech RENAME License.TheXTech.txt)
    endif()
endif()

# ================== Clean-up ==================
add_custom_target(clean_external)
add_custom_command(
    TARGET clean_external POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_BINARY_DIR}/external/"
    COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_BINARY_DIR}/output/include"
    COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_BINARY_DIR}/output/lib"
    COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_BINARY_DIR}/output/share"
)


================================================
FILE: CONTRIBUTING.md
================================================
We're glad you're interested in the project! Well-implemented PRs that improve TheXTech's compatibility with SMBX64 or add/improve our ports are always welcome. We are also very interested in PRs that add quality-of-life features to base SMBX64 content.

# Project Roadmap

A broad overview of the goals for the project in the next few versions:

## 1.3.7 (released)

* [Multiple resolution system to play game at non-800x600 resolutions](https://github.com/TheXTech/TheXTech/pull/328)
* [In-game configuration system](https://github.com/TheXTech/TheXTech/pull/734)
* Shared-screen and split-screen >2P multiplayer

## 1.3.7.x

* Compressed archive support for episodes and asset packs (`.xte` / `.xta`)
* Updated file formats system
* NetPlay (aka Online Play) system

## 1.(3.)8

* See [here](https://github.com/TheXTech/TheXTech/issues/952).

## ???

* [Luau scripting system](https://github.com/TheXTech/TheXTech/issues/472) for **Classic Events** and **NPC's**
* GLSL ES shader API
* TAS System
* Rewinding

Please see the [Issues](https://github.com/TheXTech/TheXTech/issues) and [milestones](https://github.com/TheXTech/TheXTech/milestones) that developers have endorsed for a fine-grained list of the development tasks and targets we are currently considering.

## An important note on the scope of TheXTech

TheXTech is based on the [SMBX64](https://wohlsoft.ru/pgewiki/SMBX64) standard, and it also aims for limited compatibility with the other SMBX branches, as well as Low-end device support, NetPlay support, and TAS/Rewind system support. Therefore, any topics (including but not limited to issues, PR's, and discussions) whose purpose is to make the base TheXTech engine with one of the following situations, will be rejected as **out-of-scope**, even with Lua Script System support:

1. Imitating features of non-SMBX games
2. Featuring major gameplay changes
3. Affecting low-end device support
  - We monitor code size, static and dynamic memory usage, and CPU performance
4. Breaks legacy SMBX64 logic
5. Affects past works
6. Spamming new content ideas
7. Causing the engine slowdown
8. Affecting TAS (Tool-assisted Speedrun) Mechanic, Netplay, or rewinding
9. Mentioning unofficial engine features
10. Create lots of forks
  - For anything platform games to be made from scratch, You should use **Moondust Engine** instead, but currently is in progress.

Related comments will also be marked as "off-topic". Related conversations of partial issues and PR's will be locked as "off-topic".

## A note on "bugfixes"

TheXTech is a faithful reproduction of the SMBX 1.3 engine, so a number of things that may appear to be bugs to a user or contributor may actually be TheXTech reproducing SMBX 1.3 logic intended. Please see [Types of Bugs](https://github.com/TheXTech/TheXTech/wiki/Types-of-bugs) for a categorization of types of bugs.

PRs fixing native bugs and critical vanilla bugs are always welcome (but you may be asked to justify that the bug in question is indeed critical).

Fixes for other vanilla bugs are not a good first contribution to the engine, due to the considerations we need to employ when faced with these. You are welcome to file an issue for any vanilla peculiarities you discover, but we are unlikely to fix them.

# TheXTech content standard
We are in the process of developing a content standard for TheXTech, including new engine features such as multistars, more flexible warps, and world map sections. We are also developing a scripting layer including TheXTech-specific Lua and GLSL ES APIs.

We are being very careful in how we create the TheXTech standard, and we are generally hesitant to accept PRs that add new content to the standard. We intend to maintain indefinite compatibility with all content created for TheXTech 1.3.7+, and this makes it difficult to remove or refactor features once added.

# Ports and limitations

We maintain ports for a wide variety of systems, and you should take care when developing new features to ensure that the appropriate ports of the game will continue to run with our minimum system requirements (16 MB of RAM and 200 MHz CPU).

If you are interested in contributing new ports to any such systems, please see [Porting](PORTING.md).


================================================
FILE: LICENSE
================================================
GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    {one line to give the program's name and a brief idea of what it does.}
    Copyright (C) {year}  {name of author}

    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 3 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, see <http://www.gnu.org/licenses/>.

Also add information on how to contact you by electronic and paper mail.

  If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

    {project}  Copyright (C) {year}  {fullname}
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

  You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.

  The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.


================================================
FILE: PORTING.md
================================================
TheXTech is a cross-platform engine and is built to be easy to port to new systems. It has very limited dependencies and can be built for most POSIX-like targets.

# System Requirements

The target must have at least **16 MB RAM** (working on Wii with ~48 MB available), a **200 MHz CPU** (working on old Nintendo 3DS with 268 MHz ARM11), and a **C++11-compliant compiler**.

On some of our existing ports, storage or filesystem bandwidth is a pressing consideration.

Full compliance with the SMBX64 standard requires support for the AND and OR bitwise / logical blend modes, but the game includes tools used by our SDL2 ports to approximate these with alpha blending. Some features require the target to support compiling GLSL ES 1.00 and 3.00 shaders.

# Port types and guidelines

Most versions of the game use SDL2 + OpenGL for rendering and SDL Mixer X for software mixing. Your port may make use of these APIs, but is not required to.

## SDL2

If your target supports the SDL2 joystick, window, message box, render, audio, and threading APIs, porting to your target may be as simple as pointing CMake to the appropriate toolchain file. You may need to edit the `CMakeLists.txt` build instructions to enable / disable features for your target as appropriate. Use the Switch, Wii U, or Vita port for reference.

## Custom + SDL2 audio

If your target supports the SDL2 audio and threading APIs but is missing other APIs, you may create custom bindings for many of the subsystems under `src/core/`. Use the 3DS and Wii port for reference.

## Custom

We maintain a "null" port designed to compile on virtually any POSIX-compliant system. This port does **not** depend on SDL2 but uses a shim layer to delegate most SDL2 calls to their POSIX equivalents. This port may be used in a command-line environment with a gameplay recording file to verify gameplay logic before you invest the time in creating a full port for your target.

The null port may be built by passing `-DTHEXTECH_CLI_BUILD=On -DTHEXTECH_NO_SDL_BUILD=On` to CMake in addition to specifying your toolchain.

You may initially extend the null port with a minimal renderer for your target system that (for instance) draws rectangles for all drawn textures. This facilitates early testing and development.

We previously maintained a custom audio library that used the 3DS's DSP for hardware-accelerated mixing. This source code may be checked to understand how to implement a MixerX-like audio library. It may also be possible to replace the audio at a different level of abstraction (for instance, replacing `sound.cpp` entirely).


================================================
FILE: README.ESP.md
================================================
<p align="center">
<a href="https://github.com/Wohlstand/TheXTech/releases"><img src="https://raw.githubusercontent.com/Wohlstand/TheXTech/master/resources/icon/thextech_512.png" alt="TheXTech"></a>
</p>

# TheXTech

Motor SMBX, reescrito en C ++ a partir de VisualBasic 6.

| <!-- -->      | <!-- -->        | <!-- -->      |
|:-------------:|:---------------:|:-------------:|
| [English](README.md) | [Русский](README.RUS.md) | Español |

-----------


# Preguntas Frecuentes

## ¿Qué es esto?
Es una continuación directa del motor SMBX 1.3. Originalmente fue escrito en VB6 para Windows, y más tarde, fue portado / reescrito en C++ y se convirtió en un motor multiplataforma. Reproduce enteramente el antiguo motor SMBX 1.3 (aparte de su Editor), incluye varios de sus errores lógicos (se reparan los errores críticos que hacen que el juego se bloquee o se falle) y también agrega muchas actualizaciones y características nuevas.


## ¿Por qué lo hiciste?
Tengo diversos fines para realizarlo:
- Es un modelo de investigación bastante conveniente que deseo usar en el desarrollo del motor Moondust.
- Proveer una copia plenamente compatible del motor antiguo para plataformas modernas, lo cual posibilita jugar niveles y episodios viejos con la misma sensación que si se hubieran jugado en el juego SMBX original basado en VB6.
- Para que funcione sin la necesidad de usar Wine en plataformas que no sean Windows y que se encuentre disponible en plataformas que no sean x86 / x64.
- Optimizarlo para utilizar menos recursos de hardware que el juego original con base en VB6.

## Tienes Moondust Engine, ¿por qué has pasado bastante más de un mes para producir esta cosa?
Lo necesito para el desarrollo de Moondust Engine de manera directa, es muchísimo más simple de hackear y examinar que un ambiente VB6 antiguo e inconveniente.

## ¿Cuál es el futuro de Moondust Engine ahora que existe TheXTech?
Continuaré desarrollando el motor Moondust debido a que aún tengo que conseguir el segundo objetivo del proyecto.
A partir de su fundación, el Proyecto Moondust poseía 2 fines:
1) Salvar SMBX
2) Dar un grupo de herramientas flexible para nuevos juegos de plataformas.
La apertura del código fuente de SMBX y la introducción de TheXTech ha resuelto el primer objetivo: SMBX ha sido salvado y ahora es un software multiplataforma gratuito de código abierto. Moondust Engine se usará para el segundo objetivo: dar un grupo de herramientas para nuevos juegos. A diferencia de TheXTech, Moondust Engine da un elevado nivel de flexibilidad que posibilita a cualquier persona edificar algo nuevo a partir de cero sin heredar un viejo juego base. No obstante, TheXTech se necesita para Moondust Engine como modelo de investigacion funcional para desarrollar el nuevo motor. Va a ser parecido a las transportaciónes GZDoom y Chocolate Doom del juego Doom: GZDoom es un motor potente y servible, la mejor alternativa para los modders; Chocolate Doom es una adaptacion precisa del juego original a  plataformas modernas para representar el juego original, incluidos los errores. El motor Moondust pretende ser como GZDoom, en lo que TheXTech es un semejante de Chocolate Doom para representar un juego original en plataformas modernas.

## ¿Los niveles y episodios con LunaDLL Autocode funcionarán en Este juego?
Sí, lo harán. A partir de la versión 1.3.6 de TheXTech, hay una implementación incorporada del lenguaje de scripting LunaDLL Autocode, llamado LunaScript. Con este sistema, es posible ejecutar episodios LunaDLL en cualquier hardware, incluso con una arquitectura de procesador que no sea x86.

## ¿Puede LunaLua funcionar en esto?
No, LunaLua no funcionará: este proyecto es binario-incompatible con LunaLua. Esto también significa que el contenido SMBX2 es incompatible. El sistema de secuencias de comandos planificado en el lenguaje lua no podrá garantizar la compatibilidad. Por lo tanto, después de la posible aparición de soporte para scripts lua, será aconsejable portar o crear desde cero específicamente para TheXTech.


## ¿Por qué el código aquí es tan malo?
El autor original escribió la mayor parte del código en la carpeta "* src *" en VB6. Hice una conversión completa del código con un esfuerzo por lograr una reproducción precisa. Por lo tanto, gran parte del código es idéntico a lo que se escribió originalmente en VB6. La plataforma VB6 tenía muchos desafíos y limitaciones como:
- Todas las variables son globales y accesibles desde todos los módulos y se forman de forma predeterminada sin ninguna inclusión o importación. La razón por la que existe "globals.h": tiene una lista completa de variables disponibles globalmente.
- Soporte limitado e inconveniente para las clases, por lo tanto, el código tiende a abusar de una tonelada de variables y matrices globales (también una falta inicial de experiencia del autor original fue otro factor que llevó a este problema).
- Todas las funciones de todos los módulos son globales y se pueden llamar directamente desde cada módulo. Excepto las llamadas marcadas como "privadas". Por lo tanto, tuve un trabajo adicional para proporcionar inclusiones en archivos donde se solicitan estas llamadas.
- ¿Por qué tanto `if-elseif-elseif-elseif-elseif -....?` Sí, aquí probablemente sea correcto usar `switch ()` (en VB6 el operador `Select Case` analógico). Otro factor que muestra que el autor original tenía poca experiencia cuando codificó este proyecto.
- ¿Por qué la lasaña `if () {if {} if {....}}`? Dos razones: 1) inexperiencia del autor original, 2) solución para no verificar todas las condiciones de expresión que pueden causar un bloqueo. En C ++ con múltiples condiciones divididas por el operador `&&`, nunca se ejecuta cuando una de ellas obtiene un resultado falso. En VB6, TODAS las condiciones en la obtención de expresiones siempre se ejecutarán. Esta diferencia provocó la siguiente situación: en VB6, una expresión `if A <5 And Array (A) = 1 Then` provocará un bloqueo cuando A sea más de 5. En C ++ el mismo` if (A <5 && Array [ Una expresión] == 1) `nunca fallará porque una segunda verificación nunca se ejecutará si una primera verificación dio un resultado falso.
- ¿Por qué expresiones tan largas como `if (id == 1 || id == 3 || id == 4 || ... id == N)`? En lugar de hacer un montón de condiciones como esta, sería mejor usar clases con un polimorfismo y separar la lógica de cada objeto entre diferentes clases. También debería poder resolverse teniendo que usar punteros de función (que no son posibles en VB6 sin workaronds, pero son posibles en C ++). Pero, nuevamente, la inexperiencia del autor original combinada con un montón de límites de VB6 causaron estas construcciones.


## ¿Como usar esto?
Aquí hay muchas formas de jugar con él:
- hay algunos paquetes listos para usar, simplemente tómelos y juegue como lo hizo con SMBX.
- [usuarios de macOS, omitan esto]: use la misma manera que el juego original: coloque el archivo ejecutable en la carpeta raíz del juego con un "thextech.ini" que contenga el siguiente texto:
```
[Main]
force-portable = true
```
, music.ini, sounds.ini y una carpeta adicional "graphics/ui". Una nota importante: todos los gráficos predeterminados deben convertirse a PNG, use la herramienta GIFs2PNG de PGE Project en su carpeta "gráficos" con un interruptor "-d". No use el interruptor "-r" para mantener los GIF originales junto con los PNG recién creados si planea continuar usando SMBX original escrito en VB6.
- use esto para el modo de depuración: en su directorio de inicio, cree la carpeta ".PGE_Project/thextech" (en macOS, la "`~/TheXTech Games/Debug Assets/`") donde debe colocar un set completo de recursos del juego y cosas de mundos, esta carpeta funcionará como la raíz del juego en el juego original. Este modo le permite ejecutar un archivo ejecutable desde cualquier ubicación de la carpeta en su computadora y usar la misma ubicación de recursos para todas las compilaciones (excepto las que están marcadas como portátiles por el archivo INI).


## ¿Cómo agregar episodios personalizados para la versión de macOS?
Si tiene una compilación empaquetada de TheXTech, todos los recursos predeterminados están dentro de su .app: "Content/Resources/assets/". Puedes modificar el contenido, ¡pero no es recomendable! En cambio, después de la primera ejecución de un juego, en su directorio de inicio aparecerá el siguiente directorio:
''
   ~/TheXTech Episodes
''
En este directorio, encontrará una carpeta vacía de "batalla" y "mundos" para colocar sus cosas personalizadas. En la ruta "`~/Library/Application Support/PGE Project/thextech` ", se almacenarán los registros, las configuraciones y las partidas guardadas.
Si desea reemplazar los recursos predeterminados por los suyos, puede modificar el contenido del paquete de la aplicación o hacer una nueva compilación con los argumentos de CMake necesarios que se necesitan para empaquetar la raíz de los recursos personalizados y el icono en el nuevo paquete o crear la compilación sin recursos (si no das argumentos, resultará la compilación sin recursos). Por lo tanto, debes colocar el contenido completo de la raíz del juego en la carpeta "`~/TheXTech Games/Debug Assets/` ", incluye recursos predeterminados (gráficos, música, sonidos, niveles de introducción y salida, niveles de batalla predeterminados y carpetas de mundos).


## ¿Qué diferencia hay con esto en comparación con la versión original en VB6?
- En primer lugar, está escrito en C ++, mientras que el original (como ya sabemos) está escrito en VB6.
- No tiene editor. En cambio, tiene una integración profunda con Moondust Editor que permite usarlo con la misma funcionalidad que en el editor original (la funcionalidad de "mano mágica" se mantuvo para permitir la edición en tiempo real del nivel durante la prueba, es necesario usar la comunicación IPC con Moondust Editor para tener la capacidad de usarlo mejor).
- Soporte completo de UTF-8 en rutas de nombre de archivo y datos de texto internos (el juego original tenía solamente soporte ANSI de 8 bits).
- Para gráficos y control, usa una biblioteca SDL2, mientras que el juego original ha usado llamadas WinAPI y biblioteca GDI.
- Utiliza PGE-FL que tiene un mejor soporte de formatos de archivo.
- Un soporte para mapas del mundo WLDX permite líneas de crédito ilimitadas y música personalizada sin que sea necesario usar un music.ini para reemplazos de música.
- Algunas características exclusivas de LVLX ahora funcionan: envolvimiento de sección vertical, warp bidireccional, mensaje personalizado de "Estrella requerida", evento de entrada de warp, capacidad para deshabilitar la impresión de estrellas en episodios HUB para puertas específicas, capacidad para deshabilitar la visualización entre escenas al pasar a otro nivel a través de un warp.
- Soporte incorporado para extensos music.ini y sounds.ini de episodios y niveles para anular los recursos de musica y sonidos predeterminados.
- Los mapas del mundo ahora admiten un directorio personalizado para almacenar recursos específicos como baldosas/escenas/caminos/niveles personalizados y ya no enviar spam a la carpeta raíz del episodio con recursos del mapa del mundo.
- El formato de configuración por defecto es INI, el viejo formato config.dat ya no es compatible, principalmente por valores de codigo de teclas incompatibles (SDL_Scancode versus enumeración de VirtualKeys de Windows API).
- El juego se guarda ahora usando el formato SAVX en lugar del clásico SAV. Sin embargo, si ya tiene un juego guardado antiguo, aún puede reanudar su juego usando el nuevo motor ahora (el próximo intento de guardado de juegos dará como resultado un archivo SAVX, el juego guardado antiguo en formato SAV se mantendrá intacto).
- Soporte PNG incorporado para gráficos personalizados y predeterminados. Sin embargo, los GIF enmascarados todavía son compatibles por compatibilidad con versiones anteriores, sin realizar una conversión automática inesperada como lo hace SMBX-38A.
- ¡Los puntos de control ahora tienen puntos múltiples! ¡Puedes usarlos en tus niveles varias veces sin límites!
- Utiliza un algoritmo de descompresión diferida para acelerar la carga del juego y reducir el uso de memoria.
- ¡Para música y SFX, la librería MixerX se usa para brindar soporte a una amplia cantidad de formatos de sonido y música!
- No incorpora ningún gráfico: NO hay gráficos realmente codificados, ¡ahora todo está representado por gráficos externos!
- Se han ampliado algunos límites internos.
- Grabador GIF integrado con la tecla F11 (F10 en macOS, F11 está reservado por la interfaz de usuario del sistema para una acción de "mostrar escritorio")
- Comienza más rápido: la carga del juego es casi instantánea (depende de una computadora y del rendimiento de su HDD/SSD).
- Utiliza menos RAM (80 ... 150 MB en lugar de 600 ... 800 MB como usualmente), y está libre de pérdidas de memoria dadas por la interfaz MCI utilizada originalmente por SMBX en VB6.
- no sobrecarga la CPU (la razón fue una mala manera de procesar bucles infinitos, también hice la corrección de la compilación de VB6 en mi rama "smbx-experiment")
- Puede funcionar en una "tostadora" (una computadora débil) mientras que VB6-SMBX no funcionará.
- es completamente multiplataforma y no depende de Windows, y ya no depende del procesador x86: también puede funcionar en procesadores ARM y MIPS (VB6-SMBX no funcionará en ARM en absoluto, con el emulador x86 funcionará 20 veces más lento de lo habitual).


## ¿Cómo compilarlo?
Puede leer una guía sobre cómo compilar este proyecto desde la fuente aquí: https://github.com/Wohlstand/TheXTech/wiki/Building-the-game

Para compilarlo, necesita tener lo siguiente:
- CMake
- Ninja opcionalmente (para acelerar el proceso de construcción)
- Compilador C/C ++ compatible (GCC, Clang, MinGW, MSVC 2017 y 2019, posiblemente también se construirá en 2015, pero no se ha probado)
- Git (necesario para extraer submódulos y clonar la fuente de las líbrerias dependientes para construirlos en su lugar)
- Mercurial (necesario para clonar un repositorio oficial de SDL2 para construirlo en su lugar aquí)
- Opcionalmente: dependencias instaladas en todo el sistema: SDL2, libFreeImageLite (una implementación modificada de FreeImage), librería de sonido MixerX, colección de librerías AudioCodecs. Tenerlos instalados en el sistema aumenta la velocidad de compilación. Sin embargo, es posible compilar todas estas dependencias en su lugar aquí con un costo adicional de tiempo de compilación agregado.


================================================
FILE: README.RUS.md
================================================
<p align="center">
<a href="https://github.com/Wohlstand/TheXTech/releases"><img src="https://raw.githubusercontent.com/Wohlstand/TheXTech/master/resources/icon/thextech_512.png" alt="TheXTech"></a>
</p>

# TheXTech

SMBX-движок, переписанный на C++ с VisualBasic 6

| <!-- -->      | <!-- -->        | <!-- -->      |
|:-------------:|:---------------:|:-------------:|
| [English](README.md) | Русский | [Español](README.ESP.md) |

-----------


# Часто задаваемые вопросы

## Что это такое?
Это прямое продолжение старого движка SMBX 1.3. Изначально движок был написан на VB6 под Windows, а позже был портирован/переписан на C++: и с тех пор движок стал кросс-платформенным. Он полностью повторяет старый движок (кроме редактора), включая множество логических багов (часть багов была исправлена, первым делом те, которые ломают игру), а также содержит множество обновлений и новых возможностей.


## Зачем ты это сделал?
Зачем? У меня имеется несколько целей, почему я это сделал:
- Это - очень удобная живая модель для исследований, которую я хочу использовать для разработки Moondust-движка.
- Чтобы предоставить полностью совместимую со старым SMBX-движком игру для современных платформ, чтобы можно было играть старые уровни и эпизоды, сохранив первозданную атмосферу оригинальной игры SMBX, писанной на VB6.
- Чтобы игра работала на не-Windows платформах без необходимости использовать Wine, а также запускать игру на других процессорах, отличных от x86 (например ARM).
- Чтобы была возможность оптимизировать игру, используя меньше аппаратных ресурсов, в отличии от оригинальной игры, основанной на VB6.


## У тебя есть Moondust-движок, зачем ты портатил больше месяца на то, чтобы создать эту вещь?
Мне оно нужно для разработки Moondust-движка напрямую. С ним мне намного проще исследовать и экспериментировать, чем через старую и неудобную среду VB6.


## Какое будущее у движка Mooddust (ранее PGE) с тех пор как существует TheXTech?
Я продолжу разработку Moondust-движка, поскльку мне всё равно надо исполнить вторую цель Moondust Project.
С момента основания у Moondust Project было две цели: 1) спасти SMBX; 2) предоставить гибкий набор для создания новых игр-платформеров. Открытие исходников SMBX и связанное с этим появление TheXTech, полностью исполнило первую цель: SMBX спасён, и теперь это свободное ПО с открытым исходным кодом. Moondust-движок останется для исполнения второй цели - предоставить набор для новых игр. В отличии от TheXTech, Moondust-движок даёт максимальную гибкость, которая позволяет каждому создать что-либо с нуля, без необходимости наследовать старую игровую базу. Однако, TheXTech нужен для Moondust-движка в качестве модели для исследований, чтобы разработать новый движок. В итоге, результат будет схож с портами игры Doom: GZDoom и Chocolate Doom. GZDoom - мощный и функциональный движок, лучший выбор для моддеров. Chocolate Doom - это высокоточный порт оригинальной игры на современные платформы с целью предоставить оригинальную игру, включая даже баги. Moondust-движок стремится быть похожим на GZDoom в то время, как TheXTech будет аналогом Chocolate Doom с целью повторить оригинальную игру на современных платформах.


## Смогут ли уровни и эпизоды с LunaDLL Autocode работать в этой игре?
Да, смогут. Начиная с версии TheXTech 1.3.6, имеется встроенная реализация скриптового языка LunaDLL Autocode, именуемая LunaScript. С этой системой можно запускать LunaDLL-эпизоды на любом оборудовании, даже с процессорной архитектурой, отличной от x86.


## Сможет LunaLua работать в этой игре?
Нет, LunaLua не сможет работать: данный проект бинарно несовместим с LunaLua. Это ещё значит, что контент, предназначенный для SMBX2, также будет несовместим. Планируемая скриптовая система на языке lua не сможет гарантировать совместимость. Поэтому, после возможного появления поддержки lua-скриптов, будет целесообразно портировать, либо создавать с нуля конкретно для TheXTech.


## Почему здесь такой плохой код?
Изначально, большинство кода в папке "src" было написано на VB6 его изначальным автором. Я сделал полное преобразование кода с упором на максимально точное воспроизведение игры. То есть, большинство кода практически идентично тому, что было изначально написано на VB6. Платформа VB6 имела огромное количество всевозможных трудностей и ограничений:
- Все переменные глобальны и доступны из каждого модуля и формы по умолчанию, без каких-либо включений или импортов. Это и есть причина, почему существует "globals.h": этот файл содержит в себе весь полный список глобально доступных переменных.
- Ограниченная и неудобная поддержка классов, почему большая часть кода нагло злоупотребляла большим колличеством глобальных переменных и массивов (также свою лепту привнесло отсутствие опыта у изначального автора, которое стало дополнительным фактором существования всего этого безобразия).
- Все функции во всех модулях глобальны, и могут вызываться из кажого модуля напрямую (за исключением вызовов, помеченных как "приватные"). Из-за чего мне пришлось проделать дополнительную работу по включению заголовков в файлы, где эти вызовы применялись.
- Почему так много `if-elseif-elseif-elseif-elseif-....`? Да, здесь, скорее всего, было бы правильно использовать оператор `switch()` (аналог в VB6: `Select Case`). Ещё одна причина, которая объясняет, что у изначального автора на тот момент времени не хватало опыта, пока он работал над этим проектом.
- Почему такие глубокие лазаньи из `if() { if {} if { .... } }`? На то есть две причины: 1) мало опыта у изначального автора, 2) костыль, предназначенный для того, чтобы не проверять все условия логического выражения в случаях, способных вызвать крэш. В C++, множество условий, разделённых с помощью оператора `&&`, никогда не будут проверены, если одно из них даёт отрицательный результат. В VB6 наборот, ВСЕ узлы выражения исполняются, не зависимо от их реузльтата. Эта разница даёт следующее: в VB6, выражение `if A < 5 And Array(A) = 1 Then` спровоцирует ошибку, если A будет больше пяти. В C++, аналогичное выражение `if(A < 5 && Array[A] == 1)` никогда не спровоцирует ошибку, потому что вторая часть выражения никогда не проверяется, если первая дала отрицательный результат.
- Почему такие длинные выражения по типу `if(id == 1 || id == 3 || id == 4 || ... id == N)`? Вместо того, чтобы создавать кучи подобных выражений, было бы лучше использовать классы и полиморфизм с отдельной логикой для каждого объекта между разными классами. Это также должно решаться с помощью указателей на функции (которые невозможны в VB6 без костылей, однако легко возможны в C++). Однако снова, отсутствие опыта у изначального автора одновременно с огромной кучей ограничений VB6 спровоцировало появление подобных конструкций.



## Как пользоваться игрой?
Имеется несколько способов, как пользоваться этой игрой:
- Имеются уже готовые к работе сборки, просто взять использовать также, как SMBX.
- [Пропустить этот пункт пользователям macOS]: Смешать исполняемый файл игры с существующими игровыми ресурсами: положить исполняемый файл в кореневую папку ресурсов совместно с INI-файлом "thextech.ini", содержащим следующий текст:
```ini
[Main]
force-portable = true
```
, файлами "music.ini", "sounds.ini" и с дополнительной папкой "graphics/ui".
Важно: вся штатная графика должна быть преобразована в PNG. Используйте утилиту GIFs2PNG из комплекта Moondust Project, применив на папке "graphics" с флагом "-d". Не используйте флаг "-r", чтобы сохранить исходные GIF-файлы совместно с новоиспечёнными PNG, если есть в планах продолжить использовать оригинальную игру, написанную на VB6.
- Использовать это в отладочном режиме: в Вашем домашнем каталоге, создайте папку `.PGE_Project` (обязательно должно начинаться с точки), и затем внутри `.PGE_Project`, создать папку "thextech" (на macOS вместо этого нужно создать путь "`~/TheXTech Games/Debug Assets/`"). Это отладочный корень игры, в коротом необходимо разместить полный комплект ресурсов игры и данные эпизодов. Этот каталог будет действовать аналогично корневому каталогу оригинальной игры. Этот режим позволяет запускать исполняемый файл игры из абсолютно любого места на Вашем компьютере, и при этом использовать одно общее местоположение игровых ресурсов для всех сборок (за исключением тех, которые были помечены как портативные с помощью INI-файла).


## Как добавить сторонние эпизоды в версии для macOS?
Если у вас укомплектованная сборка TheXTech, то все встроенные ресурсы находятся внутри вашего .app: "Content/Resources/assets/". Можно изменить содержиеме, однако, этого не рекомендуется делать! Вместо этого, после первого запуска игры в вашем домашнем каталоге появятся следующая директория:

```
   ~/TheXTech Games/<имя игры>/
```
Внутри этой директории будут две пустые папки: "battle" и "worlds", в которые вы сможете положить ваши эпизоды. В подпапку "settings" будут сохранены настройки и сохранения игры.
Логи будут сохранены в папке "`~/Library/Application Support/PGE Project/thextech`".
Если же вы хотите заменить встроенные ресурсы на собственные, можно изменить содержимое пакета приложения, или собрать новую сборку с указанием необходимых флагов CMake, с помощью которых вы сможете упаковать ваш собственный набор ресурсов и иконку для нового пакета, либо же сделать безресурсную сборку (по умолчанию, если не указать никаких аргументов, будет собираться безресурсная сборка по-умолчанию). Поэтому вам нужно разместить полный комплект игровых ресурсов в папку "`~/TheXTech Games/Debug Assets/`", включая все основные ресурсы (графику, музыку, звуки, вводный и завершающий уровни, уровни битв и папки миров по умолчанию).


## В чём разница между этой и оригинальной сборкой игры, созданной на VB6?
- Первым делом, эта игра написана на C++, когда оригинал (как мы уже знаем) был создан на VisualBasic6.
- До выпуска 1.3.6, редактор полностью отсутствовал. Начиная с 1.3.6 имеет встроенный мобильный редактор, работающий в полноэкранном режиме. Им можно управлять не только клавиатурой и мышкой, но и геймпадов или сенсорным экраном. Также, игра имеет глубокую интеграцию с редактором Moondust, которая позволяет использовать игру с той же функциональностью, что и через оригинальный редактор (Была сохранена функциональность "волшебной руки", которая позволяет редактировать уровень в реальном времени во время тестирования).
- Полная поддержка UTF-8 в именах файлов, путях и внутренних текстовых ресурсах (оригинальная игра поддерживала только 8битные кодировки ANSI).
- Игра использует SDL2 для графики и управления в то время, как оригинальная игра использовала вызовы WinAPI и библиотеки GDI.
- Игра использует библиотеку PGE-FL для улучшенной поддержки форматов файлов.
- Имеется поддержка карт мира WLDX, которые позволяют сохранять неограниченное число строк титров, а также встроенная поддежка использования сторонней музыки без необходимости использовать music.ini.
- В игре работают некоторые уникальные возможности уровней LVLX: вертикальное соединение; двунаправленные проходы; возможность указать собственное сообщение, чтобы рассказать о необходимом числе звёзд для взода в проход; событие входа в проход; возможность отключить отображение числа звёзд над определёнными дверями в корридорных мирах; возможность отключить входной экран при переходе между уровнями через проход.
- Встроенная поддержка файлов "music.ini" и "sounds.ini" для замены музыки и звуков на отдельных уровнях, и даже в целых эпизодах.
- Карты мира отныне поддерживают собственную директорию, чтобы размещать в ней любые специфичные ресурсы (ландшафт, декорации, пути, уровни), и при этом больше не засорять корневую папкпу эпизода ресурсами карты мира.
- Формат настроек теперь INI, старый формат config.dat больше не поддерживается, первым делом из-за несовместимых форматов кодов клавиш (SDL_Scancode против VirtualKeys из Windows API).
- Сохранения игры отныне используют формат SAVX вместо классического SAV. Однако, если у вас уже имеется старое сохранение, вы всё ещё можете продожить игру, используя новый движок (при следующем сохранеии игры, будет создан файл в новом SAVX-формате, старое сохранение игры останется нетронутым).
- Встроенная поддкржика PNG для сторонней и встроенной графики. Масковые GIF по прежнему поддерживаются для обратной совместимости, однако, без автопреобразований, как это обычно делает SMBX-38A.
- Контрольные точки отныне можно использовать по много раз! Вы сможете использовать их на ваших уровнях по несколько раз без каких либо ограничений!
- Игра использует алгоритм ленивой распаковки, чтобы ускорить время загрузки игры и уменьшить использование памяти.
- Был полностью переработан алгоритм поиска объектов, чего позволило полностью решить проблему сильного замедления на слабых машинах из-за горизонтального движения слоёв (См. подробное описание проблемы тут: [Проблема Доктора Пеппера](https://wohlsoft.ru/pgewiki/DrPepper_Problem/ru))
- Игра использует библиотеку MixerX для звука и музыки, которая поддерживает огрномное число различных аудиоформатов!
- Игра не внедряет в сборку какую-либо графику: отныне в игре больше НИКАКИХ истинно "внедрённых" ресурсов, теперь вся графика представлена в виде внешних ресурсов!
- Расширены некоторые встроенные ограничения.
- Встроення запись GIF с помощью клавиши F11 (на macOS используется клавиша F10, F11 используется системой, чтобы показать/скрыть рабочий сто).
- Игра запускается быстрее: игра загружается почти мгновенно (зависит от компьютера и производительности его диска).
- Игра использует меньше оперативной памяти (вместо 600...800 мегабайт, игра теперь в среднем использует 80...150 мегабайт), а также, она теперь чиста от утечек в памяти, вызванных MCI-интерфейсом, который использовался в оригинальной игре.
- Игра больше не перегружает процессор до 100% (проблема была из-за неправильного способа обработки вечных циклов, я также исправил этот деффект и в VB6-сборке в ветке "smbx-experiments").
- Игра способна работать даже на "тостере" (старом/слабом компьютере) в то время как VB6-SMBX не можеты.
- Игра полностью кросс-платформенна, и больше не зависит от Windows, а также больше не зависит от процессоров x86: игра сможет работать на ARM и MIPS-процессорах тоже (VB6-SMBX зависит от Windows и x86).


## Как собрать игру?
Вы можете почитать подробно инструкцию сборки этого проекта из исходников тут: https://github.com/Wohlstand/TheXTech/wiki/Building-the-game

Чтобы собрать игру, нужно иметь несколько вещей:
- CMake
- Ninja, не обязательно (чтобы ускорить процесс сборки)
- Совместимый компилятор C/C++ (GCC, Clang, MinGW, MSVC 2017 и 2019, вожможно будет собираться и в MSVC 2015, но не проверено)
- Git (нужен для загрузки подмодулей и клонирования исходников зависисимых библиотек для их сборки на месте)
- Mercurial (необходим для загрузки исходников с официального репозитория SDL2, чтобы собрать его на месте)
- Не обязательно: зависимости, установленные в систему: SDL2, libFreeImageLite (модифицированная реализация FreeImage), звуковая библиотека MixerX, коллекция библиотек AudioCodecs. Если все эти зависимости установлены в системе, процесс сборки будет идти значительно быстрее. Однако, возможно собирать все зависимости прямо на месте, но при этом сборка будет идти дольше.


## Локализация
Некоторые части TheXTech можно локазиловать (напримет, загрузчик на Android), Вы можете помочь перевести их, используя платформу WebLate: https://hosted.weblate.org/projects/thextech/


## Используемые инструменты
* GCC, MinGW-w64 и Clang - основные компиляторы, используемые во время разработки игры. Редко MSVC, который используется исключительно для Windows-сборок под процессоры ARM64.
* [Qt Creator](https://www.qt.io/product/development-tools) - среда разработки из комплекта Qt, в основном используемя при разработке.
* [JetBrans CLion](https://www.jetbrains.com/ru-ru/clion/) - среда разработки для C/C++ на базе Intelliji Idea, бесплатна по [лицензии для СПО](https://www.jetbrains.com/ru-ru/community/opensource/).
* [PVS-Studio](https://pvs-studio.com/ru/pvs-studio/?utm_source=website&utm_medium=github&utm_campaign=open_source) - статический анализатор кода для C, C++, C# и Java. Используется для периодических проверок кода на возможные ошибки. Бесплатен по [лицензии для СПО](https://pvs-studio.com/ru/order/open-source-license/).


================================================
FILE: README.md
================================================
<p align="center">
<a href="https://github.com/Wohlstand/TheXTech/releases"><img src="https://raw.githubusercontent.com/Wohlstand/TheXTech/master/resources/icon/thextech_512.png" alt="TheXTech"></a>
</p>

# TheXTech

SMBX engine, rewritten into C++ from VisualBasic 6.

| <!-- -->      | <!-- -->        | <!-- -->      |
|:-------------:|:---------------:|:-------------:|
| English | [Русский](README.RUS.md) | [Español](README.ESP.md) |

-----------


# Frequently Asked Questions

## What is this?
This is a direct continuation of the SMBX 1.3 engine. Originally it was written in VB6 for Windows, and later, it got ported/rewritten into C++ and became a cross-platform engine. It completely reproduces the old SMBX 1.3 engine (aside from its Editor), includes many of its logical bugs (critical bugs that lead the game to crash or freeze got fixed), and also adds a lot of new updates and features.


## Why did you make it?
I have several purposes for making it:
- It's a very convenient research model I want to use in developent of the Moondust Engine.
- To provide a fully-compatible replica of the old engine for modern platforms, allowing to play old levels and episodes with the same feeling as if they were played on the original VB6-based SMBX game.
- To make it work without the necessity to use Wine on non-Windows platforms and making it available on non-x86/x64 platforms.
- Optimizing it to use fewer hardware resources than the original VB6-based game.


## You have Moondust Engine, why you have spent over a month to craft this thing?
I need it for Moondust Engine development directly, it's much easier to hack and inspect than an old, inconvenient VB6 environment.


## What's the future of Moondust Engine now that TheXTech exists?
I'll continue developing the Moondust Engine as I have yet to reach the second goal of the project.
Since it's foundation, the Moondust Project had two goals: 1) save SMBX; 2) give a flexible toolkit for new platform games. The opening of SMBX's source-code and introducing TheXTech has solved the first goal: SMBX has been saved and now it's free/opensource cross-platform software. Moondust Engine will be used for the second goal - giving a toolkit for new games. Unlike TheXTech, Moondust Engine gives a high degree of flexibility that allows anyone to build something new from scratch without inheriting an old game base. However, TheXTech is needed for Moondust Engine as a working research model to develop the new engine. It will be similar to GZDoom and Chocolate Doom ports of the Doom game: GZDoom is a powerful and functional engine, the best choice for modders; Chocolate Doom is an accurate port of the original game to a modern platform with the purpose to represent the original game including even bugs. The Moondust Engine intends to be like GZDoom while TheXTech is an analog of Chocolate Doom to represent an original game on modern platforms.


## Can levels and episodes with LunaDLL Autocode work on this?
Yes, can. Since the TheXTech version 1.3.6, there is a built-in implementation of the LunaDLL Autocode language, called LunaScript. This system allows the running of LunaDLL-episodes on any hardware including non-x86 processor architectures.


## Can LunaLua work on this?
No, LunaLua won't work: this project is binary-incompatible with LunaLua. This also means that SMBX2 content is incompatible. The planned lua-based scripting system won't guarantee compatibility. Therefore, after the possible appearance of the Lua scripts support, it will be reasonable to port, or create new from the ground up and target to TheXTech exclusively.


## Why is the code here so bad?
The original author wrote most of the code in the "*src*" folder in VB6. I did a whole conversion of the code with an effort to accurate reproduction. So, a lot of the code is identical to what was written in VB6 originally. The VB6 platform had a lot of challenges and limitations such as:
- All variables are global and accessible from every module and form by default without any includes or imports. The reason why "globals.h" exists: it has a full list of globally available variables.
- Limited and inconvenient support for classes, therefore the code tends to abuse a ton of global variables and arrays (also an initial lack of experience of the original author was an another factor that lead to this mess).
- All functions in all modules are global and can be called from each module directly. Except calls marked as "private". Therefore I had an additional work to provide inclusions into files where these calls are requested.
- Why so much `if-elseif-elseif-elseif-elseif-....?` Yes, here probably will be correct to use `switch()` (in VB6 the `Select Case` analogue) operator. Another factor that shows the original author had a low amount of experience when he coded this project.
- Why the `if() { if {} if { .... } }` lasagna? Two reasons: 1) inexperience of original author, 2) workaround to not check all conditions of expression which may cause a crash. In C++ with multiple conditions splitted by `&&` operator, never executing when one of them gets a false result. In VB6, ALL conditions in expression getting be always executed. This difference caused the next situation: in VB6, an expression `if A < 5 And Array(A) = 1 Then` will cause a crash when A is more than 5. In C++ the same `if(A < 5 && Array[A] == 1)` expression will never crash because a second check gets be never executed if a first check gave a false result.
- Why so long expressions like `if(id == 1 || id == 3 || id == 4 || ... id == N)`? Rather making a ton of conditions like this, it's would be better to use classes with a polymorphism and separate the logic of every object between different classes. Also should be solvable with having to use of function pointers (which aren't possible in VB6 without workaronds, but possible in C++). But, again, the original author's inexperience combined with a bunch of VB6 limits caused these constructions.


## How to use this?
Here are many ways to play games with it:
- There are some ready-to-use packages, just download them, unpack and run them as you did it with SMBX, absolutely same.
- [macOS users, skip this]: Mix the game with existing assets directory: put an executable file into the game root folder with an "thextech.ini" that contains next text:
```ini
[Main]
force-portable = true
```
, music.ini, sounds.ini and additional "graphics/ui" folder. An important note: all default graphics must be converted into PNG, use GIFs2PNG tool from Moondust Project over your "graphics" folder with a "-d" switch. Don't use "-r" switch to keep original GIFs together with new-made PNGs if you plan to continue the use of original VB6-written SMBX.
- Use it for debug mode: in your home directory, create the ".PGE_Project/thextech" folder (on macOS the "`~/TheXTech Games/Debug Assets/`") where you should put a full set of game resources and worlds stuff, this folder will work like a game root in the original game. This mode allows you to run an executable file from any folder location of your computer and use the same location of resources for all builds (except these are marked as portable by an INI file).


## How to add custom episodes for the macOS version?
If you have a bundled build of TheXTech, all default resources are inside your .app: "Content/Resources/assets/". You can modify the content, but it's not recommended! Instead, after the first run of a game, in your home directory will appear the next directory:
```
   ~/TheXTech Games/<game name>/
```
In this directory, you will find an empty "battle" and "worlds" folder to put your custom stuff. At the "settings" sub-directory the game settings and game saves will be stored.
At the "`~/Library/Application Support/PGE Project/thextech/logs/`" path logs will be stored.
If you want to replace default assets with your own, you can modify the content of the app bundle or compile a new build with giving of the necessary CMake arguments which needed to pack your custom assets root and icon into the new bundle or make the assets-less build (if you give no arguments, the assets-less build will result). Therefore, you need to put the full content of the game root into the "`~/TheXTech Games/Debug Assets/`" folder, include default assets (graphics, music, sounds, intro and outro levels, default battle and worlds folders).


## What is different with this thing in comparison to the original VB6 build?
- First off, it's written in C++ while original (as we already know) is written in VB6.
- Before the version 1.3.6, it had no Editor at all. Since the version 1.3.6, it has an embedded mobile editor that works in a full screen. It can be controlled by keyboard and mouse as well, as by gamepad or by touch screen. In addition, it has a deep integration with Moondust Editor that allows to use game with the same functionality as was possible in the original editor (the "magic hand" functionality was kept to allow real-time editing of a level while testing).
- Full support of UTF-8 in filename paths and internal text data (original game had the only 8bit ANSI support).
- For graphics and controlling, it uses an SDL2 library while original game have used WinAPI calls and GDI library.
- It uses PGE-FL library that has better file formats support.
- A support for WLDX world maps are allowing unlimited credits lines and custom music without it being necessary to use a music.ini for music replacements.
- Some LVLX exclusive features now working: vertical section wrap, two-way warps, custom "star needed" message, warp enter event, ability to disable stars printing in HUB episodes for specific doors, ability to disable interscene showing when going to another level through a warp.
- Built-in support for episode and level wide music.ini and sounds.ini to override default music and sounds assets.
- World maps now supports a custom directory to store any specific resources like custom tiles/scenes/paths/levels and not spam the episode root folder with world map resources anymore.
- Default config format is INI, old config.dat format is no longer supported, mainly because of incompatible key code values (SDL_Scancode versus VirtualKeys enum of Windows API).
- Game saves now using the SAVX format instead of a classic SAV. However, if you already have an old gamesave, you still can resume your game by using a new engine now (next gamesave attempt will result a SAVX file, old gamesave in SAV format will be kept untouched).
- Built-in PNG support for custom and default graphics. Masked GIFs are still supported for backward compatibility, however, without making an unexpected auto-conversion like SMBX-38A does.
- Checkpoints now have multi-points! You can use them in your levels multiple times without limits!
- It does use of lazy-decompress algorithm to speed-up the loading of a game and reduce the memory usage.
- It has the completely reworked objects search algorithm which resolves the lag problem on slow systems after horizontal move of layers (See description of the [DrPepper Problem](https://wohlsoft.ru/pgewiki/DrPepper_Problem)).
- For music and SFX, the MixerX library is used to give a support for a wide amount of sound and music formats!
- It doesn't embeds any graphics: there are NO trurely hardcoded graphics, everything is now represented by external graphics!
- Some internal limits have been expanded.
- Built-in GIF recorder by F11 key (F10 on macOS, F11 is reserved by system UI for a "show desktop" action)
- It starts faster: the loading of the game is almost instant (depend on a computer and it's HDD/SSD performance).
- It uses less RAM (80...150 MB instead of 600...800 MB like usually), and it's free from memory leaks given by the MCI interface used by VB6 SMBX originally.
- it doesn't overload CPU (the reason was a bad way to process infinite loops, I did the fix of VB6 build too at my "smbx-experiments" branch)
- it able to work on "toaster" (a weak computer) while VB6-SMBX won't work.
- it's fully cross-platform and doesn't depend on Windows, and it no longer depends on x86 processor: it can work on ARM and MIPS processors too (VB6-SMBX won't work on ARM at all, with x86 emulator it will 20x times slower than usualy).


## How to build it?
You can read a guide how to build this project from source here: https://github.com/Wohlstand/TheXTech/wiki/Building-the-game

To build it, you need to have the following things:
- CMake
- Ninja optionally (to speed-up the build process)
- Compatible C/C++ compiler (GCC, Clang, MinGW, MSVC 2017 and 2019, possibly will build also on 2015, but wasn't tested)
- Git (required to pull submodules and clone source of dependent libraries to build them in place)
- Mercurial (required to clone an official SDL2 repository to build it in place here)
- Optionally: system-wide installed dependencies: SDL2, libFreeImageLite (a modded implementation of the FreeImage), MixerX sound library, AudioCodecs collection of libraries. Having them be installed in a system gives a major build speed up. However, it's possible to build all these dependencies in place here with a cost of extra build time being added.

## Localization
Some parts of TheXTech (such as Android launcher) can be localized into many languages, you may help to translate them using WebLate platform: https://hosted.weblate.org/projects/thextech/


## Used software
* GCC, MinGW-w64, and Clang - main compilers used during the development of the game. The MSVC is used sometimes which is used for Windows builds for ARM64 processors.
* [Qt Creator](https://www.qt.io/product/development-tools) - IDE from the Qt toolkit, mainly used during the development.
* [JetBrans CLion](https://www.jetbrains.com/ru-ru/clion/) - Intelliji Idea based C/C++ IDE, free for the [Open Source development](https://www.jetbrains.com/ru-ru/community/opensource/).
* [PVS-Studio](https://pvs-studio.com/pvs-studio/?utm_source=website&utm_medium=github&utm_campaign=open_source) - static analyzer for C, C++, C#, and Java code. Is used for periodical checking of the code for possible bugs. It's free for the [Open Source development](https://pvs-studio.com/en/order/open-source-license/).


================================================
FILE: android-project/.gitignore
================================================
# Folders
/.idea/*
/.gradle/*
/build/*
/local.properties
/SDL-default/*
/thextech/jni/SDL/*
/thextech/build/*
/thextech/release/*
/thextech/apk/release/*
/thextech/fdroid/release/*
/thextech/debug/*
/thextech/.cxx/*
.externalNativeBuild
/thextech/src/main/assets/languages/*

# Files
*.iml
*.apk

# Key files
*.jks
*.keystore


================================================
FILE: android-project/build.gradle
================================================
// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    repositories {
        mavenCentral()
        google()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:8.13.2'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        google()
        mavenCentral()
    }
}

tasks.register('clean', Delete) {
    delete rootProject.layout.buildDirectory
}


================================================
FILE: android-project/build_init.sh
================================================
#!/bin/bash

# Remove old version if presented
if [[ -d SDL-default ]]; then
    rm -Rf SDL-default
fi

# Unpack recent SDL2 tarball
if [[ ! -d SDL-default ]]; then
    wget https://github.com/WohlSoft/PGE-Project/raw/master/_Libs/_sources/SDL-default.tar.gz
    tar -xf SDL-default.tar.gz
    rm SDL-default.tar.gz
fi

if [[ ! -d thextech/jni/SDL ]]; then
    mkdir thextech/jni/SDL
fi

# Make a link for SDL2 sources
if [[ ! -e thextech/jni/SDL/src ]]; then
    ln -s ../../../SDL-default/src thextech/jni/SDL/src
fi

# Make a link for SDL2 includes
if [[ ! -e thextech/jni/SDL/include ]]; then
    ln -s ../../../SDL-default/src thextech/jni/SDL/include
fi

# Remove old SDL2 Java files
rm -f thextech/src/main/java/org/libsdl/app/*.java

# Copy SDL2 Java files
cp SDL-default/android-project/app/src/main/java/org/libsdl/app/*.java thextech/src/main/java/org/libsdl/app

# Copy Android NDK makefile
cp SDL-default/Android.mk thextech/jni/SDL

echo "Done!"


================================================
FILE: android-project/gradle/wrapper/gradle-wrapper.properties
================================================
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionSha256Sum=ed1a8d686605fd7c23bdf62c7fc7add1c5b23b2bbc3721e661934ef4a4911d7c
distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-all.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists


================================================
FILE: android-project/gradle.properties
================================================
# Project-wide Gradle settings.

# IDE (e.g. Android Studio) users:
# Gradle settings configured through the IDE *will override*
# any settings specified in this file.

# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
android.enableJetifier=false
android.nonFinalResIds=true
android.nonTransitiveRClass=true
android.useAndroidX=true
org.gradle.jvmargs=-Xmx1536m

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
# org.gradle.parallel=true


================================================
FILE: android-project/gradlew
================================================
#!/bin/sh

#
# Copyright © 2015-2021 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
#

##############################################################################
#
#   Gradle start up script for POSIX generated by Gradle.
#
#   Important for running:
#
#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
#       noncompliant, but you have some other compliant shell such as ksh or
#       bash, then to run this script, type that shell name before the whole
#       command line, like:
#
#           ksh Gradle
#
#       Busybox and similar reduced shells will NOT work, because this script
#       requires all of these POSIX shell features:
#         * functions;
#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
#         * compound commands having a testable exit status, especially «case»;
#         * various built-in commands including «command», «set», and «ulimit».
#
#   Important for patching:
#
#   (2) This script targets any POSIX shell, so it avoids extensions provided
#       by Bash, Ksh, etc; in particular arrays are avoided.
#
#       The "traditional" practice of packing multiple parameters into a
#       space-separated string is a well documented source of bugs and security
#       problems, so this is (mostly) avoided, by progressively accumulating
#       options in "$@", and eventually passing that to Java.
#
#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
#       see the in-line comments for details.
#
#       There are tweaks for specific operating systems such as AIX, CygWin,
#       Darwin, MinGW, and NonStop.
#
#   (3) This script is generated from the Groovy template
#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
#       within the Gradle project.
#
#       You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################

# Attempt to set APP_HOME

# Resolve links: $0 may be a link
app_path=$0

# Need this for daisy-chained symlinks.
while
    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
    [ -h "$app_path" ]
do
    ls=$( ls -ld "$app_path" )
    link=${ls#*' -> '}
    case $link in             #(
      /*)   app_path=$link ;; #(
      *)    app_path=$APP_HOME$link ;;
    esac
done

# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
' "$PWD" ) || exit

# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum

warn () {
    echo "$*"
} >&2

die () {
    echo
    echo "$*"
    echo
    exit 1
} >&2

# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in                #(
  CYGWIN* )         cygwin=true  ;; #(
  Darwin* )         darwin=true  ;; #(
  MSYS* | MINGW* )  msys=true    ;; #(
  NONSTOP* )        nonstop=true ;;
esac

CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar


# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
        # IBM's JDK on AIX uses strange locations for the executables
        JAVACMD=$JAVA_HOME/jre/sh/java
    else
        JAVACMD=$JAVA_HOME/bin/java
    fi
    if [ ! -x "$JAVACMD" ] ; then
        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
    fi
else
    JAVACMD=java
    if ! command -v java >/dev/null 2>&1
    then
        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
    fi
fi

# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
    case $MAX_FD in #(
      max*)
        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
        # shellcheck disable=SC2039,SC3045
        MAX_FD=$( ulimit -H -n ) ||
            warn "Could not query maximum file descriptor limit"
    esac
    case $MAX_FD in  #(
      '' | soft) :;; #(
      *)
        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
        # shellcheck disable=SC2039,SC3045
        ulimit -n "$MAX_FD" ||
            warn "Could not set maximum file descriptor limit to $MAX_FD"
    esac
fi

# Collect all arguments for the java command, stacking in reverse order:
#   * args from the command line
#   * the main class name
#   * -classpath
#   * -D...appname settings
#   * --module-path (only if needed)
#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.

# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

    JAVACMD=$( cygpath --unix "$JAVACMD" )

    # Now convert the arguments - kludge to limit ourselves to /bin/sh
    for arg do
        if
            case $arg in                                #(
              -*)   false ;;                            # don't mess with options #(
              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
                    [ -e "$t" ] ;;                      #(
              *)    false ;;
            esac
        then
            arg=$( cygpath --path --ignore --mixed "$arg" )
        fi
        # Roll the args list around exactly as many times as the number of
        # args, so each arg winds up back in the position where it started, but
        # possibly modified.
        #
        # NB: a `for` loop captures its iteration list before it begins, so
        # changing the positional parameters here affects neither the number of
        # iterations, nor the values presented in `arg`.
        shift                   # remove old arg
        set -- "$@" "$arg"      # push replacement arg
    done
fi


# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'

# Collect all arguments for the java command:
#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
#     and any embedded shellness will be escaped.
#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
#     treated as '${Hostname}' itself on the command line.

set -- \
        "-Dorg.gradle.appname=$APP_BASE_NAME" \
        -classpath "$CLASSPATH" \
        org.gradle.wrapper.GradleWrapperMain \
        "$@"

# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
    die "xargs is not available"
fi

# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
#   set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#

eval "set -- $(
        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
        xargs -n1 |
        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
        tr '\n' ' '
    )" '"$@"'

exec "$JAVACMD" "$@"


================================================
FILE: android-project/gradlew.bat
================================================
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem      https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@rem SPDX-License-Identifier: Apache-2.0
@rem

@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem  Gradle startup script for Windows
@rem
@rem ##########################################################################

@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal

set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=.
@rem This is normally unused
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%

@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi

@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"

@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome

set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute

echo. 1>&2
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2

goto fail

:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe

if exist "%JAVA_EXE%" goto execute

echo. 1>&2
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2

goto fail

:execute
@rem Setup the command line

set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar


@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*

:end
@rem End local scope for the variables with windows NT shell
if %ERRORLEVEL% equ 0 goto mainEnd

:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%

:mainEnd
if "%OS%"=="Windows_NT" endlocal

:omega


================================================
FILE: android-project/settings.gradle
================================================
include ':thextech'


================================================
FILE: android-project/thextech/build.gradle
================================================
def buildAsLibrary = project.hasProperty('BUILD_AS_LIBRARY');
def buildAsApplication = !buildAsLibrary
if (buildAsApplication) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}

def release_store_password = System.env.RELEASE_STORE_PASSWORD
def release_key_password = System.env.RELEASE_KEY_PASSWORD
def release_key_alias = System.env.RELEASE_KEY_ALIAS
def pin_alias = System.env.PIN_ALIAS
def db_pass_alias = System.env.DB_PASS_ALIAS

def getGitHash() {
    def gitExec = providers.exec {
        commandLine('git', 'rev-parse', '--short', 'HEAD')
    }.standardOutput.asText.get()
    return gitExec.trim()
}

def getGitBranch() {
    def gitExec = providers.exec {
        commandLine('git', 'rev-parse', '--abbrev-ref', 'HEAD')
    }.standardOutput.asText.get()
    return gitExec.trim()
}

def parseVersion(verNum) {
    def cmakeVersion = file('../../version.cmake')

    if (cmakeVersion.canRead()) {
        def input = new FileInputStream(cmakeVersion)
        def rawVersion = input.getText()

        def verMajorEx      = ~/(?m)THEXTECH_VERSION_1 (\d+)/
        def verMajorM       = verMajorEx.matcher(rawVersion)
        verNum[0]           = verMajorM[0][1].toInteger()

        def verMinorEx      = ~/(?m)THEXTECH_VERSION_2 (\d+)/
        def verMinorM       = verMinorEx.matcher(rawVersion)
        verNum[1]           = verMinorM[0][1].toInteger()

        def verRevisionEx   = ~/(?m)THEXTECH_VERSION_3 (\d+)/
        def verRevisionM    = verRevisionEx.matcher(rawVersion)
        verNum[2]           = verRevisionM[0][1].toInteger()

        def verPatchEx      = ~/(?m)THEXTECH_VERSION_4 (\d+)/
        def verPatchM       = verPatchEx.matcher(rawVersion)
        verNum[3]           = verPatchM[0][1].toInteger()

        def verRelEx        = ~/(?m)THEXTECH_VERSION_REL "(-?\w*)"/
        def verRelM         = verRelEx.matcher(rawVersion)
        verNum[5]           = verRelM[0][1]

        return verNum
    } else {
        throw new GradleException("Can't read ../../version.cmake file")
    }
}

def cmakeToVersionCode(verNum) {
    def ret = ""

    ret += verNum[0].toString()
    ret += "." + verNum[1].toString()
    if (verNum[2] > 0 || verNum[3] > 0) {
        ret += "." + verNum[2].toString()
        if (verNum[3] > 0) {
            ret += "." + verNum[3].toString()
        }
    }

    if (verNum[5] != "") {
        ret += verNum[5]
    }

    ret += " #" + getGitHash()

    return ret
}

static def cmakeToClearVersionCode(verNum) {
    def ret = ""

    ret += verNum[0].toString()
    ret += "." + verNum[1].toString()
    if (verNum[2] > 0 || verNum[3] > 0) {
        ret += "." + verNum[2].toString()
        if (verNum[3] > 0) {
            ret += "." + verNum[3].toString()
        }
    }

    if (verNum[5] != "") {
        ret += verNum[5]
    }

    return ret
}

def verNum = [
    0: 0, // major
    1: 0, // minor
    2: 0, // revision
    3: 0, // patch
    4: 0, // CI build number
    5: "" // release type
]

parseVersion(verNum)
def xTechBranchOrig = getGitBranch()
def xTechBranch = xTechBranchOrig.replace('.', '').replace('-', '')
def xTechVersionString = cmakeToVersionCode(verNum)
def xTechVersionStringClear = cmakeToClearVersionCode(verNum)
def xTechVersionType = verNum[5]
def xTechVersionNumber = (verNum[0] * 1000000) + (verNum[1] * 10000) + (verNum[2] * 100) + verNum[3]

println "Project version: " + xTechVersionString + " (Clear version: " + xTechVersionStringClear + ", version code: " + xTechVersionNumber.toString()

android {
    compileSdkVersion 36

    // Note: The NDK 23 is SIGNIFICANTLY important, because of the support for non-NEON and older Android versions
    //       The NDK 24 removes the support for Android 4.1, 4.2, and 4.3.
    //       See details: https://github.com/android/ndk/wiki/Changelog-r24
    ndkVersion = "23.2.8568313"

    buildFeatures {
        buildConfig = true
    }

    dependenciesInfo {
        // Disables dependency metadata when building APKs.
        includeInApk = false
        // Disables dependency metadata when building Android App Bundles.
        includeInBundle = false
    }

    defaultConfig {
        if (buildAsApplication) {
            applicationId "ru.wohlsoft.thextech"
        }

        minSdkVersion 16
        targetSdkVersion 36

        versionName xTechVersionString
        versionCode xTechVersionNumber

        externalNativeBuild {
            cmake {
                abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
                arguments "-DANDROID_PLATFORM=16", "-DANDROID_STL=c++_static"
            }
        }
        ndk{
            abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
        }
    }

    signingConfigs {
        releaseci {
            storeFile file("../release-key.jks")
            storePassword = release_store_password
            keyAlias = release_key_alias
            keyPassword = release_key_password
        }
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

            if(xTechVersionType == "-dev") {
                applicationIdSuffix = '.dev.' + xTechBranch
                android.sourceSets.release.res.srcDirs += project.projectDir.toString() + '/icon/devel'
                manifestPlaceholders.dstAppName = "TheXTech DEV [" + xTechBranchOrig + "]"
            } else {
                android.sourceSets.release.res.srcDirs += project.projectDir.toString() + '/icon/main'
                manifestPlaceholders.dstAppName = "@string/app_name"
            }
        }
        releaseci {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            buildConfigField "String", "PIN_ALIAS", "\"$pin_alias\""
            buildConfigField "String", "DB_PASS_ALIAS", "\"$db_pass_alias\""
            signingConfig = signingConfigs.releaseci

            if(xTechVersionType == "-dev") {
                applicationIdSuffix = '.dev.' + xTechBranch
                android.sourceSets.releaseci.res.srcDirs += project.projectDir.toString() + '/icon/devel'
                manifestPlaceholders.dstAppName = "TheXTech DEV [" + xTechBranchOrig + "]"
            } else {
                android.sourceSets.releaseci.res.srcDirs += project.projectDir.toString() + '/icon/main'
                manifestPlaceholders.dstAppName = "@string/app_name"
            }
        }
        debug {
            applicationIdSuffix '.debug'
            versionNameSuffix '-DEVDEBUG'
            manifestPlaceholders.dstAppName = "TheXTech [DEBUG]"
            debuggable true
            android.sourceSets.debug.res.srcDirs += project.projectDir.toString() + '/icon/debug'
        }
    }

    flavorDimensions = ["dist"]
    productFlavors {
        apk {
            dimension "dist"
            isDefault = true
        }
        fdroid {
            dimension "dist"
            externalNativeBuild {
                cmake {
                    arguments += ["-DTHEXTECH_NO_BUILD_DATE=ON", "-DFDROID_BUILD=TRUE", "-DOVERRIDE_GIT_BRANCH=\"<fdroid>\"", "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"]
                }
            }

            versionName = xTechVersionStringClear

            if(project.hasProperty('applicationIdSuffix')) {
                applicationIdSuffix += '.fdroid'
            } else {
                applicationIdSuffix = '.fdroid'
            }
        }
    }

    println "Resource paths per config:"
    println "Main: " + android.sourceSets.main.res.srcDirs
    println "Debug: " + android.sourceSets.debug.res.srcDirs
    println "Release: " + android.sourceSets.release.res.srcDirs
    println "Release-CI: " + android.sourceSets.releaseci.res.srcDirs

    lint {
        abortOnError = false
    }
    namespace = 'ru.wohlsoft.thextech'

    if (!project.hasProperty('EXCLUDE_NATIVE_LIBS')) {
        sourceSets {
            main {
                jniLibs.srcDirs += "jniLibs"
            }
            debug {
                jniLibs.srcDirs += "jniLibs/debug"
            }
            release {
                jniLibs.srcDirs += ["jniLibs/release", "jniLibs/minsizerel"]
            }
            releaseci {
                jniLibs.srcDirs += ["jniLibs/release", "jniLibs/minsizerel"]
            }
        }
        externalNativeBuild {
            cmake {
                path "../../CMakeLists.txt"
            }
        }
    }


    if (buildAsLibrary) {
        libraryVariants.all { variant ->
            variant.outputs.each { output ->
                def outputFile = output.outputFile
                if (outputFile != null && outputFile.name.endsWith(".aar")) {
                    def fileName = "ru.wohlsoft.thextech.aar";
                    output.outputFile = new File(outputFile.parent, fileName);
                }
            }
        }
    }
}

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'jniLibs')
    //noinspection GradleDependency: the version 1.6.1 is last that support minSDK 16, newer version will require MinSDK 21
    implementation 'androidx.appcompat:appcompat:1.6.1'
    //noinspection GradleDependency: the version 2.1.4 is last that support minSDK 16, newer version will require MinSDK 21
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    def lifecycle_version = "2.6.2"
    //noinspection GradleDependency: the version 2.6.2 is last that support minSDK 16, newer version will require MinSDK 19
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
    //noinspection GradleDependency
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    //noinspection GradleDependency: the version 1.11.0 is last that support minSDK 16, newer version will require MinSDK 19
    implementation 'com.google.android.material:material:1.11.0'
    implementation 'androidx.preference:preference:1.2.1'
//    constraints {
//        // Workaround to fix the build: https://dev.to/retyui/fix-react-native-android-builds-duplicate-class-kotlincollections-found-in-modules-jetified-kotlin-stdlib-180-2ca7
//        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.8.0") {
//            because("kotlin-stdlib-jdk7 is now a part of kotlin-stdlib")
//        }
//        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.8.0") {
//            because("kotlin-stdlib-jdk8 is now a part of kotlin-stdlib")
//        }
//    }
}


================================================
FILE: android-project/thextech/icon/debug/mipmap-anydpi-v26/ic_launcher.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@color/ic_launcher_background"/>
    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
</adaptive-icon>

================================================
FILE: android-project/thextech/icon/debug/mipmap-anydpi-v26/ic_launcher_round.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@color/ic_launcher_background"/>
    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
</adaptive-icon>

================================================
FILE: android-project/thextech/icon/debug/values/ic_launcher_background.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="ic_launcher_background">#C1A4A7</color>
</resources>

================================================
FILE: android-project/thextech/icon/devel/mipmap-anydpi-v26/ic_launcher.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@color/ic_launcher_background"/>
    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
</adaptive-icon>

================================================
FILE: android-project/thextech/icon/devel/mipmap-anydpi-v26/ic_launcher_round.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@color/ic_launcher_background"/>
    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
</adaptive-icon>

================================================
FILE: android-project/thextech/icon/devel/values/ic_launcher_background.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="ic_launcher_background">#BF8054</color>
</resources>

================================================
FILE: android-project/thextech/icon/main/mipmap-anydpi-v26/ic_launcher.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@color/ic_launcher_background"/>
    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
</adaptive-icon>

================================================
FILE: android-project/thextech/icon/main/mipmap-anydpi-v26/ic_launcher_round.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@color/ic_launcher_background"/>
    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
</adaptive-icon>

================================================
FILE: android-project/thextech/icon/main/values/ic_launcher_background.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="ic_launcher_background">#696F91</color>
</resources>

================================================
FILE: android-project/thextech/proguard-rules.pro
================================================
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in [sdk]/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the proguardFiles
# directive in build.gradle.
#
# For more details, see
#   http://developer.android.com/guide/developing/tools/proguard.html

# Add any project specific keep options here:

# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
#   public *;
#}


================================================
FILE: android-project/thextech/src/main/AndroidManifest.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:installLocation="auto">

    <!-- OpenGL ES 2.0 -->
    <uses-feature android:glEsVersion="0x00020000" />

    <!-- Game controller support -->
    <uses-feature
        android:name="android.hardware.bluetooth"
        android:required="false" />
    <uses-feature
        android:name="android.hardware.gamepad"
        android:required="false" />
    <uses-feature
        android:name="android.hardware.usb.host"
        android:required="false" />

    <!-- External mouse input events -->
    <uses-feature
        android:name="android.hardware.type.pc"
        android:required="false" />

    <!-- Touchscreen support -->
    <uses-feature
        android:name="android.hardware.touchscreen"
        android:required="false" />

    <!-- Android TV support -->
    <uses-feature android:name="android.software.leanback"
        android:required="false" />


    <!-- Allow writing to external storage -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <!-- Allow reading from the external storage -->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <!-- This game needs to have the resource directory at user's storage to allow easier customization and episodes placement -->
    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" tools:ignore="ScopedStorage" />
    <!-- Allow access to the vibrator -->
    <uses-permission android:name="android.permission.VIBRATE" />
    <!-- Allow access to Bluetooth devices -->
    <uses-permission android:name="android.permission.BLUETOOTH" />


    <application
        android:allowBackup="true"
        android:fullBackupContent="false"
        android:hardwareAccelerated="true"
        android:icon="@mipmap/ic_launcher"
        android:banner="@mipmap/ic_banner"
        android:label="${dstAppName}"
        android:launchMode="singleInstance"
        android:requestLegacyExternalStorage="true"
        android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
        android:isGame="true"
        tools:targetApi="lollipop"
        tools:ignore="DataExtractionRules">

        <activity
            android:name=".Launcher"
            android:exported="true"
            android:theme="@style/Theme.AppCompat.NoActionBar"
            android:launchMode="singleInstance"
            android:screenOrientation="landscape">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.LAUNCHER" />
                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
            </intent-filter>

            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <action android:name="android.intent.action.EDIT" />

                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.BROWSABLE" />

                <data android:scheme="file"/>
                <data android:scheme="content"/>
                <data android:mimeType="*/*"/>
                <data android:host="*" />

                <data android:mimeType="application/lvl" />
                <data android:mimeType="application/wld" />
                <data android:mimeType="application/lvlx" />
                <data android:mimeType="application/wldx" />

                <data android:mimeType="application/x-lvl" />
                <data android:mimeType="application/x-wld" />
                <data android:mimeType="application/x-lvlx" />
                <data android:mimeType="application/x-wldx" />

                <data android:pathPattern=".*\\.lvl" />
                <data android:pathPattern=".*\\..*\\.lvl" />
                <data android:pathPattern=".*\\..*\\..*\\.lvl" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.lvl" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.lvl" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.lvl" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.lvl" />

                <data android:pathPattern=".*\\.LVL" />
                <data android:pathPattern=".*\\..*\\.LVL" />
                <data android:pathPattern=".*\\..*\\..*\\.LVL" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.LVL" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.LVL" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.LVL" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.LVL" />

                <data android:pathPattern=".*\\.wld" />
                <data android:pathPattern=".*\\..*\\.wld" />
                <data android:pathPattern=".*\\..*\\..*\\.wld" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.wld" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.wld" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.wld" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.wld" />

                <data android:pathPattern=".*\\.WLD" />
                <data android:pathPattern=".*\\..*\\.WLD" />
                <data android:pathPattern=".*\\..*\\..*\\.WLD" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.WLD" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.WLD" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.WLD" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.WLD" />

                <data android:pathPattern=".*\\.lvlx" />
                <data android:pathPattern=".*\\..*\\.lvlx" />
                <data android:pathPattern=".*\\..*\\..*\\.lvlx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.lvlx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.lvlx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.lvlx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.lvlx" />

                <data android:pathPattern=".*\\.LVLX" />
                <data android:pathPattern=".*\\..*\\.LVLX" />
                <data android:pathPattern=".*\\..*\\..*\\.LVLX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.LVLX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.LVLX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.LVLX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.LVLX" />

                <data android:pathPattern=".*\\.wldx" />
                <data android:pathPattern=".*\\..*\\.wldx" />
                <data android:pathPattern=".*\\..*\\..*\\.wldx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.wldx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.wldx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.wldx" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.wldx" />

                <data android:pathPattern=".*\\.WLDX" />
                <data android:pathPattern=".*\\..*\\.WLDX" />
                <data android:pathPattern=".*\\..*\\..*\\.WLDX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\.WLDX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.WLDX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.WLDX" />
                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.WLDX" />
            </intent-filter>
        </activity>

        <activity
            android:name=".GameSettings"
            android:theme="@style/Theme.AppCompat.DayNight"
            android:label="@string/title_activity_game_settings"
            android:screenOrientation="landscape"
            android:parentActivityName=".Launcher">
            <meta-data
                android:name="android.support.PARENT_ACTIVITY"
                android:value=".Launcher" />
        </activity>

        <activity
            android:name="thextechActivity"
            android:alwaysRetainTaskState="true"
            android:configChanges="layoutDirection|locale|orientation|uiMode|screenLayout|screenSize|smallestScreenSize|keyboard|keyboardHidden|navigation"
            android:launchMode="singleInstance"
            android:screenOrientation="landscape">
            <!-- android:label="@string/app_name" -->
            <!-- Drop file event -->
            <!--
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="*/*" />
            </intent-filter>
            -->
        </activity>

        <meta-data android:name="SDL_ENV.SDL_ACCELEROMETER_AS_JOYSTICK" android:value="0"/>
    </application>

</manifest>


================================================
FILE: android-project/thextech/src/main/assets/buttons/Credits.txt
================================================
Button pictures made by ZeZeinzer (Discord BlueBoi#8980)
Additions and mods by 0lhi and Wohlstand


================================================
FILE: android-project/thextech/src/main/generate_patternPath.sh
================================================
#!/bin/bash

for q in lvl LVL wld WLD lvlx LVLX wldx WLDX; do
    echo "                <data android:pathPattern=\".*\\\\.${q}\" />"
    echo "                <data android:pathPattern=\".*\\\\..*\\\\.${q}\" />"
    echo "                <data android:pathPattern=\".*\\\\..*\\\\..*\\\\.${q}\" />"
    echo "                <data android:pathPattern=\".*\\\\..*\\\\..*\\\\..*\\\\.${q}\" />"
    echo "                <data android:pathPattern=\".*\\\\..*\\\\..*\\\\..*\\\\..*\\\\.${q}\" />"
    echo "                <data android:pathPattern=\".*\\\\..*\\\\..*\\\\..*\\\\..*\\\\..*\\\\.${q}\" />"
    echo "                <data android:pathPattern=\".*\\\\..*\\\\..*\\\\..*\\\\..*\\\\..*\\\\..*\\\\.${q}\" />"
    echo ""
done


================================================
FILE: android-project/thextech/src/main/java/javautil/FileUtils.java
================================================
package javautil;

import android.annotation.SuppressLint;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.provider.MediaStore;
import android.provider.OpenableColumns;
import android.text.TextUtils;
import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

public class FileUtils
{
    public static String FALLBACK_COPY_FOLDER = "upload_part";

    private static final String TAG = "FileUtils";

    private static Uri contentUri = null;

    private boolean m_wasCopiedToInternal = false;

    Context context;

    public FileUtils(Context context)
    {
        this.context = context;
    }

    public boolean isInternalCopy()
    {
        return m_wasCopiedToInternal;
    }

    @SuppressLint("NewApi")
    public String getPath(final Uri uri)
    {
        // check here to KITKAT or new version
        final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
        String selection = null;
        String[] selectionArgs = null;
        // DocumentProvider

        if (isKitKat)
        {
            // ExternalStorageProvider
            if (isExternalStorageDocument(uri))
            {
                final String docId = DocumentsContract.getDocumentId(uri);
                final String[] split = docId.split(":");
                final String type = split[0];

                String fullPath = getPathFromExtSD(split);

                if (fullPath == null || !fileExists(fullPath))
                {
                    Log.d(TAG, "Copy files as a fallback");
                    fullPath = copyFileToInternalStorage(uri, FALLBACK_COPY_FOLDER);
                }
                else
                    m_wasCopiedToInternal = false;

                if (!fullPath.equals(""))
                    return fullPath;
                else
                    return null;
            }

            // DownloadsProvider
            if (isDownloadsDocument(uri))
            {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
                {
                    final String id;
                    Cursor cursor = null;

                    try
                    {
                        cursor = context.getContentResolver().query(uri, new String[] { MediaStore.MediaColumns.DISPLAY_NAME }, null, null, null);
                        if (cursor != null && cursor.moveToFirst())
                        {
                            String fileName = cursor.getString(0);
                            String path = Environment.getExternalStorageDirectory().toString() + "/Download/" + fileName;
                            if (!TextUtils.isEmpty(path))
                            {
                                m_wasCopiedToInternal = false;
                                return path;
                            }
                        }
                    }
                    finally
                    {
                        if (cursor != null)
                            cursor.close();
                    }

                    id = DocumentsContract.getDocumentId(uri);

                    if (!TextUtils.isEmpty(id))
                    {
                        if (id.startsWith("raw:"))
                            return id.replaceFirst("raw:", "");

                        String[] contentUriPrefixesToTry = new String[]
                        {
                            "content://downloads/public_downloads",
                            "content://downloads/my_downloads"
                        };

                        for (String contentUriPrefix : contentUriPrefixesToTry)
                        {
                            try
                            {
                                final Uri contentUri = ContentUris.withAppendedId(Uri.parse(contentUriPrefix), Long.parseLong(id));
                                return getDataColumn(context, contentUri, null, null);
                            }
                            catch (NumberFormatException e)
                            {
                                //In Android 8 and Android P the id is not a number
                                String ret = uri.getPath();
                                assert(ret != null);
                                return ret.replaceFirst("^/document/raw:", "").replaceFirst("^raw:", "");
                            }
                        }
                    }
                }
                else
                {
                    final String id = DocumentsContract.getDocumentId(uri);

                    if (id.startsWith("raw:"))
                    {
                        m_wasCopiedToInternal = true;
                        return id.replaceFirst("raw:", "");
                    }

                    try
                    {
                        contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.parseLong(id));
                    }
                    catch (NumberFormatException e)
                    {
                        e.printStackTrace();
                    }

                    if (contentUri != null)
                        return getDataColumn(context, contentUri, null, null);
                }
            }


            // MediaProvider
            if (isMediaDocument(uri))
            {
                final String docId = DocumentsContract.getDocumentId(uri);
                final String[] split = docId.split(":");
                final String type = split[0];

                Log.d(TAG, "MEDIA DOCUMENT TYPE: " + type);

                Uri contentUri = null;

                if ("image".equals(type))
                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                else if ("video".equals(type))
                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                else if ("audio".equals(type))
                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                else if ("document".equals(type))
                    contentUri = MediaStore.Files.getContentUri(MediaStore.getVolumeName(uri));

                selection = "_id=?";
                selectionArgs = new String[] { split[1] };

                return getDataColumn(context, contentUri, selection, selectionArgs);
            }

            if (isGoogleDriveUri(uri))
                return getDriveFilePath(uri);

            if (isWhatsAppFile(uri))
                return getFilePathForWhatsApp(uri);

            if ("content".equalsIgnoreCase(uri.getScheme()))
            {
                if (isGooglePhotosUri(uri))
                {
                    m_wasCopiedToInternal = false;
                    return uri.getLastPathSegment();
                }

                if (isGoogleDriveUri(uri) || isSamsungMyFilesAppFile(uri))
                    return getDriveFilePath(uri);

                // if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
                if (Build.VERSION.SDK_INT >= 30 && !Environment.isExternalStorageManager())
                {
                    // return getFilePathFromURI(context,uri);
                    return copyFileToInternalStorage(uri, FALLBACK_COPY_FOLDER);
                    // return getRealPathFromURI(context,uri);
                }
                else
                {
                    return getDataColumn(context, uri, null, null);
                }
            }

            if ("file".equalsIgnoreCase(uri.getScheme()))
            {
                m_wasCopiedToInternal = false;
                return uri.getPath();
            }

        }
        else
        {
            String scheme = uri.getScheme();

            if (isWhatsAppFile(uri))
                return getFilePathForWhatsApp(uri);

            if(scheme == null)
                return copyFileToInternalStorage(uri, FALLBACK_COPY_FOLDER);

            if (scheme.equalsIgnoreCase(ContentResolver.SCHEME_FILE))
            {
                String ret = uri.getPath();
                Log.d(TAG, "Got URI path from File intent: " + ret);
                return ret;
            }
            else if (scheme.equalsIgnoreCase(ContentResolver.SCHEME_CONTENT))
            {
                String[] projection = { MediaStore.Images.Media.DATA };
                Cursor cursor = null;

                try
                {
                    cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
                    assert(cursor != null);

                    int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);

                    if (cursor.moveToFirst())
                    {
                        String ret = cursor.getString(column_index);
                        cursor.close();
                        return ret;
                    }

                    cursor.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
        }

        return copyFileToInternalStorage(uri, FALLBACK_COPY_FOLDER);
    }

    private static boolean fileExists(String filePath)
    {
        File file = new File(filePath);
        return file.exists();
    }

    private static String getPathFromExtSD(String[] pathData)
    {
        final String type = pathData[0];
        final String relativePath = File.separator + pathData[1];
        String fullPath = "";


        Log.d(TAG, "MEDIA EXTSD TYPE: " + type);
        Log.d(TAG, "Relative path: " + relativePath);
        // on my Sony devices (4.4.4 & 5.1.1), `type` is a dynamic string
        // something like "71F8-2C0A", some kind of unique id per storage
        // don't know any API that can get the root path of that storage based on its id.
        //
        // so no "primary" type, but let the check here for other devices
        if ("primary".equalsIgnoreCase(type))
        {
            fullPath = Environment.getExternalStorageDirectory() + relativePath;
            if (fileExists(fullPath))
            {
                return fullPath;
            }
        }

        if ("home".equalsIgnoreCase(type))
        {
            fullPath = "/storage/emulated/0/Documents" + relativePath;
            if (fileExists(fullPath))
            {
                return fullPath;
            }
        }

        // Environment.isExternalStorageRemovable() is `true` for external and internal storage
        // so we cannot relay on it.
        //
        // instead, for each possible path, check if file exists
        // we'll start with secondary storage as this could be our (physically) removable sd card
        fullPath = System.getenv("SECONDARY_STORAGE") + relativePath;
        if (fileExists(fullPath))
        {
            return fullPath;
        }

        fullPath = System.getenv("EXTERNAL_STORAGE") + relativePath;
        if (fileExists(fullPath))
        {
            return fullPath;
        }

        return null;
    }

    private String getDriveFilePath(Uri uri)
    {
        //Uri returnUri = uri;
        Cursor returnCursor = context.getContentResolver().query(uri, null, null, null, null);
        assert(returnCursor != null);

        /*
         * Get the column indexes of the data in the Cursor,
         *     * move to the first row in the Cursor, get the data,
         *     * and display it.
         * */
        int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
        // int sizeIndex = returnCursor.getColumnIndex(OpenableColumns.SIZE);
        returnCursor.moveToFirst();
        String name = (returnCursor.getString(nameIndex));
        // String size = (Long.toString(returnCursor.getLong(sizeIndex)));
        File file = new File(context.getCacheDir(), name);

        try
        {
            InputStream inputStream = context.getContentResolver().openInputStream(uri);
            assert(inputStream != null);
            FileOutputStream outputStream = new FileOutputStream(file);

            int read = 0;
            int maxBufferSize = 1024 * 1024;
            int bytesAvailable = inputStream.available();

            //int bufferSize = 1024;
            int bufferSize = Math.min(bytesAvailable, maxBufferSize);

            final byte[] buffers = new byte[bufferSize];
            while ((read = inputStream.read(buffers)) != -1)
                outputStream.write(buffers, 0, read);

            Log.e(TAG, "Size " + file.length());
            inputStream.close();
            outputStream.close();
            Log.e(TAG, "Path " + file.getPath());
            Log.e(TAG, "Size " + file.length());
        }
        catch (Exception e)
        {
            String err = e.getMessage();
            assert(err != null);
            Log.e(TAG, err);
        }

        returnCursor.close();
        m_wasCopiedToInternal = true;

        return file.getPath();
    }

    /***
     * Used for Android Q+
     * @param uri Input URI file
     * @param newDirName if you want to create a directory, you can set this variable
     * @return path to copied file
     */
    private String copyFileToInternalStorage(Uri uri, String newDirName)
    {
        Cursor returnCursor = context.getContentResolver().query(uri, new String[] { OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE }, null, null, null);
        assert(returnCursor != null);
        String name;

        /*
         * Get the column indexes of the data in the Cursor,
         *     * move to the first row in the Cursor, get the data,
         *     * and display it.
         * */
        int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
        // int sizeIndex = returnCursor.getColumnIndex(OpenableColumns.SIZE);
        returnCursor.moveToFirst();
        try
        {
            name = (returnCursor.getString(nameIndex));
        }
        catch (Exception e)
        {
            if(e.getMessage() != null)
                Log.e(TAG, e.getMessage());
            else
                Log.e(TAG, "<NULL error>");

            name = "unknown.lvlx";
        }
        // String size = (Long.toString(returnCursor.getLong(sizeIndex)));

        File output;
        if (!newDirName.equals(""))
        {
            String random_collision_avoidance = UUID.randomUUID().toString();

            File dir = new File(context.getFilesDir() + File.separator + newDirName + File.separator + random_collision_avoidance);
            if (!dir.exists())
            {
                if(!dir.mkdirs())
                    Log.e(TAG, "Can't create directory: " + dir.getPath());
            }

            output = new File(context.getFilesDir() + File.separator + newDirName + File.separator + random_collision_avoidance + File.separator + name);
        }
        else
        {
            output = new File(context.getFilesDir() + File.separator + name);
        }

        try
        {
            InputStream inputStream = context.getContentResolver().openInputStream(uri);
            if(inputStream == null)
                throw new Exception("InputStream is NULL");

            FileOutputStream outputStream = new FileOutputStream(output);
            int read = 0;
            int bufferSize = 1024;
            final byte[] buffers = new byte[bufferSize];

            while ((read = inputStream.read(buffers)) != -1)
            {
                outputStream.write(buffers, 0, read);
            }

            inputStream.close();
            outputStream.close();
        }
        catch (Exception e)
        {
            if(e.getMessage() != null)
                Log.e(TAG, e.getMessage());
            else
                Log.e(TAG, "<NULL error>");
        }

        returnCursor.close();
        m_wasCopiedToInternal = true;

        return output.getPath();
    }

    private String getFilePathForWhatsApp(Uri uri)
    {
        return copyFileToInternalStorage(uri, "whatsapp");
    }

    private String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs)
    {
        Cursor cursor = null;
        final String column = "_data";
        final String[] projection = { column };

        try
        {
            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);

            if (cursor != null && cursor.moveToFirst())
            {
                List<String> columns = Arrays.asList(cursor.getColumnNames());
                Log.d(TAG, "Available columns: " + String.join(", ", columns));
                final int index = cursor.getColumnIndexOrThrow(column);
                m_wasCopiedToInternal = false;
                return cursor.getString(index);
            }
        }
        catch(Exception e)
        {
            if(e.getMessage() != null)
                Log.e(TAG, e.getMessage());
            else
                Log.e(TAG, "<NULL error>");

            return copyFileToInternalStorage(uri, FALLBACK_COPY_FOLDER);
        }
        finally
        {
            if(cursor != null)
                cursor.close();
        }

        return copyFileToInternalStorage(uri, FALLBACK_COPY_FOLDER);
    }

    private static boolean isExternalStorageDocument(Uri uri)
    {
        return "com.android.externalstorage.documents".equals(uri.getAuthority());
    }

    private static boolean isDownloadsDocument(Uri uri)
    {
        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
    }

    private boolean isMediaDocument(Uri uri)
    {
        return "com.android.providers.media.documents".equals(uri.getAuthority());
    }

    private boolean isGooglePhotosUri(Uri uri)
    {
        return "com.google.android.apps.photos.content".equals(uri.getAuthority());
    }

    public boolean isWhatsAppFile(Uri uri)
    {
        return "com.whatsapp.provider.media".equals(uri.getAuthority());
    }

    public boolean isSamsungMyFilesAppFile(Uri uri)
    {
        return "com.sec.android.app.myfiles.FileProvider".equals(uri.getAuthority());
    }

    private boolean isGoogleDriveUri(Uri uri)
    {
        return "com.google.android.apps.docs.storage".equals(uri.getAuthority()) || "com.google.android.apps.docs.storage.legacy".equals(uri.getAuthority());
    }
}


================================================
FILE: android-project/thextech/src/main/java/javautil/README.md
================================================
# Android Filename Picker using Java
A library for getting filenames in an Android device

Original got from the repository: https://github.com/saparkhid/AndroidFileNamePicker
Referred at: https://stackoverflow.com/a/60642994


================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/HIDDevice.java
================================================
package org.libsdl.app;

import android.hardware.usb.UsbDevice;

interface HIDDevice
{
    public int getId();
    public int getVendorId();
    public int getProductId();
    public String getSerialNumber();
    public int getVersion();
    public String getManufacturerName();
    public String getProductName();
    public UsbDevice getDevice();
    public boolean open();
    public int sendFeatureReport(byte[] report);
    public int sendOutputReport(byte[] report);
    public boolean getFeatureReport(byte[] report);
    public void setFrozen(boolean frozen);
    public void close();
    public void shutdown();
}


================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
================================================
package org.libsdl.app;

import android.content.Context;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothGattService;
import android.hardware.usb.UsbDevice;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.os.*;

//import com.android.internal.util.HexDump;

import java.lang.Runnable;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.UUID;

class HIDDeviceBLESteamController extends BluetoothGattCallback implements HIDDevice {

    private static final String TAG = "hidapi";
    private HIDDeviceManager mManager;
    private BluetoothDevice mDevice;
    private int mDeviceId;
    private BluetoothGatt mGatt;
    private boolean mIsRegistered = false;
    private boolean mIsConnected = false;
    private boolean mIsChromebook = false;
    private boolean mIsReconnecting = false;
    private boolean mFrozen = false;
    private LinkedList<GattOperation> mOperations;
    GattOperation mCurrentOperation = null;
    private Handler mHandler;

    private static final int TRANSPORT_AUTO = 0;
    private static final int TRANSPORT_BREDR = 1;
    private static final int TRANSPORT_LE = 2;

    private static final int CHROMEBOOK_CONNECTION_CHECK_INTERVAL = 10000;

    static public final UUID steamControllerService = UUID.fromString("100F6C32-1735-4313-B402-38567131E5F3");
    static public final UUID inputCharacteristic = UUID.fromString("100F6C33-1735-4313-B402-38567131E5F3");
    static public final UUID reportCharacteristic = UUID.fromString("100F6C34-1735-4313-B402-38567131E5F3");
    static private final byte[] enterValveMode = new byte[] { (byte)0xC0, (byte)0x87, 0x03, 0x08, 0x07, 0x00 };

    static class GattOperation {
        private enum Operation {
            CHR_READ,
            CHR_WRITE,
            ENABLE_NOTIFICATION
        }

        Operation mOp;
        UUID mUuid;
        byte[] mValue;
        BluetoothGatt mGatt;
        boolean mResult = true;

        private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid) {
            mGatt = gatt;
            mOp = operation;
            mUuid = uuid;
        }

        private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid, byte[] value) {
            mGatt = gatt;
            mOp = operation;
            mUuid = uuid;
            mValue = value;
        }

        public void run() {
            // This is executed in main thread
            BluetoothGattCharacteristic chr;

            switch (mOp) {
                case CHR_READ:
                    chr = getCharacteristic(mUuid);
                    //Log.v(TAG, "Reading characteristic " + chr.getUuid());
                    if (!mGatt.readCharacteristic(chr)) {
                        Log.e(TAG, "Unable to read characteristic " + mUuid.toString());
                        mResult = false;
                        break;
                    }
                    mResult = true;
                    break;
                case CHR_WRITE:
                    chr = getCharacteristic(mUuid);
                    //Log.v(TAG, "Writing characteristic " + chr.getUuid() + " value=" + HexDump.toHexString(value));
                    chr.setValue(mValue);
                    if (!mGatt.writeCharacteristic(chr)) {
                        Log.e(TAG, "Unable to write characteristic " + mUuid.toString());
                        mResult = false;
                        break;
                    }
                    mResult = true;
                    break;
                case ENABLE_NOTIFICATION:
                    chr = getCharacteristic(mUuid);
                    //Log.v(TAG, "Writing descriptor of " + chr.getUuid());
                    if (chr != null) {
                        BluetoothGattDescriptor cccd = chr.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
                        if (cccd != null) {
                            int properties = chr.getProperties();
                            byte[] value;
                            if ((properties & BluetoothGattCharacteristic.PROPERTY_NOTIFY) == BluetoothGattCharacteristic.PROPERTY_NOTIFY) {
                                value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE;
                            } else if ((properties & BluetoothGattCharacteristic.PROPERTY_INDICATE) == BluetoothGattCharacteristic.PROPERTY_INDICATE) {
                                value = BluetoothGattDescriptor.ENABLE_INDICATION_VALUE;
                            } else {
                                Log.e(TAG, "Unable to start notifications on input characteristic");
                                mResult = false;
                                return;
                            }

                            mGatt.setCharacteristicNotification(chr, true);
                            cccd.setValue(value);
                            if (!mGatt.writeDescriptor(cccd)) {
                                Log.e(TAG, "Unable to write descriptor " + mUuid.toString());
                                mResult = false;
                                return;
                            }
                            mResult = true;
                        }
                    }
            }
        }

        public boolean finish() {
            return mResult;
        }

        private BluetoothGattCharacteristic getCharacteristic(UUID uuid) {
            BluetoothGattService valveService = mGatt.getService(steamControllerService);
            if (valveService == null)
                return null;
            return valveService.getCharacteristic(uuid);
        }

        static public GattOperation readCharacteristic(BluetoothGatt gatt, UUID uuid) {
            return new GattOperation(gatt, Operation.CHR_READ, uuid);
        }

        static public GattOperation writeCharacteristic(BluetoothGatt gatt, UUID uuid, byte[] value) {
            return new GattOperation(gatt, Operation.CHR_WRITE, uuid, value);
        }

        static public GattOperation enableNotification(BluetoothGatt gatt, UUID uuid) {
            return new GattOperation(gatt, Operation.ENABLE_NOTIFICATION, uuid);
        }
    }

    public HIDDeviceBLESteamController(HIDDeviceManager manager, BluetoothDevice device) {
        mManager = manager;
        mDevice = device;
        mDeviceId = mManager.getDeviceIDForIdentifier(getIdentifier());
        mIsRegistered = false;
        mIsChromebook = mManager.getContext().getPackageManager().hasSystemFeature("org.chromium.arc.device_management");
        mOperations = new LinkedList<GattOperation>();
        mHandler = new Handler(Looper.getMainLooper());

        mGatt = connectGatt();
        // final HIDDeviceBLESteamController finalThis = this;
        // mHandler.postDelayed(new Runnable() {
        //     @Override
        //     public void run() {
        //         finalThis.checkConnectionForChromebookIssue();
        //     }
        // }, CHROMEBOOK_CONNECTION_CHECK_INTERVAL);
    }

    public String getIdentifier() {
        return String.format("SteamController.%s", mDevice.getAddress());
    }

    public BluetoothGatt getGatt() {
        return mGatt;
    }

    // Because on Chromebooks we show up as a dual-mode device, it will attempt to connect TRANSPORT_AUTO, which will use TRANSPORT_BREDR instead
    // of TRANSPORT_LE.  Let's force ourselves to connect low energy.
    private BluetoothGatt connectGatt(boolean managed) {
        if (Build.VERSION.SDK_INT >= 23 /* Android 6.0 (M) */) {
            try {
                return mDevice.connectGatt(mManager.getContext(), managed, this, TRANSPORT_LE);
            } catch (Exception e) {
                return mDevice.connectGatt(mManager.getContext(), managed, this);
            }
        } else {
            return mDevice.connectGatt(mManager.getContext(), managed, this);
        }
    }

    private BluetoothGatt connectGatt() {
        return connectGatt(false);
    }

    protected int getConnectionState() {

        Context context = mManager.getContext();
        if (context == null) {
            // We are lacking any context to get our Bluetooth information.  We'll just assume disconnected.
            return BluetoothProfile.STATE_DISCONNECTED;
        }

        BluetoothManager btManager = (BluetoothManager)context.getSystemService(Context.BLUETOOTH_SERVICE);
        if (btManager == null) {
            // This device doesn't support Bluetooth.  We should never be here, because how did
            // we instantiate a device to start with?
            return BluetoothProfile.STATE_DISCONNECTED;
        }

        return btManager.getConnectionState(mDevice, BluetoothProfile.GATT);
    }

    public void reconnect() {

        if (getConnectionState() != BluetoothProfile.STATE_CONNECTED) {
            mGatt.disconnect();
            mGatt = connectGatt();
        }

    }

    protected void checkConnectionForChromebookIssue() {
        if (!mIsChromebook) {
            // We only do this on Chromebooks, because otherwise it's really annoying to just attempt
            // over and over.
            return;
        }

        int connectionState = getConnectionState();

        switch (connectionState) {
            case BluetoothProfile.STATE_CONNECTED:
                if (!mIsConnected) {
                    // We are in the Bad Chromebook Place.  We can force a disconnect
                    // to try to recover.
                    Log.v(TAG, "Chromebook: We are in a very bad state; the controller shows as connected in the underlying Bluetooth layer, but we never received a callback.  Forcing a reconnect.");
                    mIsReconnecting = true;
                    mGatt.disconnect();
                    mGatt = connectGatt(false);
                    break;
                }
                else if (!isRegistered()) {
                    if (mGatt.getServices().size() > 0) {
                        Log.v(TAG, "Chromebook: We are connected to a controller, but never got our registration.  Trying to recover.");
                        probeService(this);
                    }
                    else {
                        Log.v(TAG, "Chromebook: We are connected to a controller, but never discovered services.  Trying to recover.");
                        mIsReconnecting = true;
                        mGatt.disconnect();
                        mGatt = connectGatt(false);
                        break;
                    }
                }
                else {
                    Log.v(TAG, "Chromebook: We are connected, and registered.  Everything's good!");
                    return;
                }
                break;

            case BluetoothProfile.STATE_DISCONNECTED:
                Log.v(TAG, "Chromebook: We have either been disconnected, or the Chromebook BtGatt.ContextMap bug has bitten us.  Attempting a disconnect/reconnect, but we may not be able to recover.");

                mIsReconnecting = true;
                mGatt.disconnect();
                mGatt = connectGatt(false);
                break;

            case BluetoothProfile.STATE_CONNECTING:
                Log.v(TAG, "Chromebook: We're still trying to connect.  Waiting a bit longer.");
                break;
        }

        final HIDDeviceBLESteamController finalThis = this;
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                finalThis.checkConnectionForChromebookIssue();
            }
        }, CHROMEBOOK_CONNECTION_CHECK_INTERVAL);
    }

    private boolean isRegistered() {
        return mIsRegistered;
    }

    private void setRegistered() {
        mIsRegistered = true;
    }

    private boolean probeService(HIDDeviceBLESteamController controller) {

        if (isRegistered()) {
            return true;
        }

        if (!mIsConnected) {
            return false;
        }

        Log.v(TAG, "probeService controller=" + controller);

        for (BluetoothGattService service : mGatt.getServices()) {
            if (service.getUuid().equals(steamControllerService)) {
                Log.v(TAG, "Found Valve steam controller service " + service.getUuid());

                for (BluetoothGattCharacteristic chr : service.getCharacteristics()) {
                    if (chr.getUuid().equals(inputCharacteristic)) {
                        Log.v(TAG, "Found input characteristic");
                        // Start notifications
                        BluetoothGattDescriptor cccd = chr.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
                        if (cccd != null) {
                            enableNotification(chr.getUuid());
                        }
                    }
                }
                return true;
            }
        }

        if ((mGatt.getServices().size() == 0) && mIsChromebook && !mIsReconnecting) {
            Log.e(TAG, "Chromebook: Discovered services were empty; this almost certainly means the BtGatt.ContextMap bug has bitten us.");
            mIsConnected = false;
            mIsReconnecting = true;
            mGatt.disconnect();
            mGatt = connectGatt(false);
        }

        return false;
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////

    private void finishCurrentGattOperation() {
        GattOperation op = null;
        synchronized (mOperations) {
            if (mCurrentOperation != null) {
                op = mCurrentOperation;
                mCurrentOperation = null;
            }
        }
        if (op != null) {
            boolean result = op.finish(); // TODO: Maybe in main thread as well?

            // Our operation failed, let's add it back to the beginning of our queue.
            if (!result) {
                mOperations.addFirst(op);
            }
        }
        executeNextGattOperation();
    }

    private void executeNextGattOperation() {
        synchronized (mOperations) {
            if (mCurrentOperation != null)
                return;

            if (mOperations.isEmpty())
                return;

            mCurrentOperation = mOperations.removeFirst();
        }

        // Run in main thread
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                synchronized (mOperations) {
                    if (mCurrentOperation == null) {
                        Log.e(TAG, "Current operation null in executor?");
                        return;
                    }

                    mCurrentOperation.run();
                    // now wait for the GATT callback and when it comes, finish this operation
                }
            }
        });
    }

    private void queueGattOperation(GattOperation op) {
        synchronized (mOperations) {
            mOperations.add(op);
        }
        executeNextGattOperation();
    }

    private void enableNotification(UUID chrUuid) {
        GattOperation op = HIDDeviceBLESteamController.GattOperation.enableNotification(mGatt, chrUuid);
        queueGattOperation(op);
    }

    public void writeCharacteristic(UUID uuid, byte[] value) {
        GattOperation op = HIDDeviceBLESteamController.GattOperation.writeCharacteristic(mGatt, uuid, value);
        queueGattOperation(op);
    }

    public void readCharacteristic(UUID uuid) {
        GattOperation op = HIDDeviceBLESteamController.GattOperation.readCharacteristic(mGatt, uuid);
        queueGattOperation(op);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////  BluetoothGattCallback overridden methods
    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public void onConnectionStateChange(BluetoothGatt g, int status, int newState) {
        //Log.v(TAG, "onConnectionStateChange status=" + status + " newState=" + newState);
        mIsReconnecting = false;
        if (newState == 2) {
            mIsConnected = true;
            // Run directly, without GattOperation
            if (!isRegistered()) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        mGatt.discoverServices();
                    }
                });
            }
        }
        else if (newState == 0) {
            mIsConnected = false;
        }

        // Disconnection is handled in SteamLink using the ACTION_ACL_DISCONNECTED Intent.
    }

    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        //Log.v(TAG, "onServicesDiscovered status=" + status);
        if (status == 0) {
            if (gatt.getServices().size() == 0) {
                Log.v(TAG, "onServicesDiscovered returned zero services; something has gone horribly wrong down in Android's Bluetooth stack.");
                mIsReconnecting = true;
                mIsConnected = false;
                gatt.disconnect();
                mGatt = connectGatt(false);
            }
            else {
                probeService(this);
            }
        }
    }

    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        //Log.v(TAG, "onCharacteristicRead status=" + status + " uuid=" + characteristic.getUuid());

        if (characteristic.getUuid().equals(reportCharacteristic) && !mFrozen) {
            mManager.HIDDeviceFeatureReport(getId(), characteristic.getValue());
        }

        finishCurrentGattOperation();
    }

    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        //Log.v(TAG, "onCharacteristicWrite status=" + status + " uuid=" + characteristic.getUuid());

        if (characteristic.getUuid().equals(reportCharacteristic)) {
            // Only register controller with the native side once it has been fully configured
            if (!isRegistered()) {
                Log.v(TAG, "Registering Steam Controller with ID: " + getId());
                mManager.HIDDeviceConnected(getId(), getIdentifier(), getVendorId(), getProductId(), getSerialNumber(), getVersion(), getManufacturerName(), getProductName(), 0, 0, 0, 0);
                setRegistered();
            }
        }

        finishCurrentGattOperation();
    }

    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
    // Enable this for verbose logging of controller input reports
        //Log.v(TAG, "onCharacteristicChanged uuid=" + characteristic.getUuid() + " data=" + HexDump.dumpHexString(characteristic.getValue()));

        if (characteristic.getUuid().equals(inputCharacteristic) && !mFrozen) {
            mManager.HIDDeviceInputReport(getId(), characteristic.getValue());
        }
    }

    public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
        //Log.v(TAG, "onDescriptorRead status=" + status);
    }

    public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
        BluetoothGattCharacteristic chr = descriptor.getCharacteristic();
        //Log.v(TAG, "onDescriptorWrite status=" + status + " uuid=" + chr.getUuid() + " descriptor=" + descriptor.getUuid());

        if (chr.getUuid().equals(inputCharacteristic)) {
            boolean hasWrittenInputDescriptor = true;
            BluetoothGattCharacteristic reportChr = chr.getService().getCharacteristic(reportCharacteristic);
            if (reportChr != null) {
                Log.v(TAG, "Writing report characteristic to enter valve mode");
                reportChr.setValue(enterValveMode);
                gatt.writeCharacteristic(reportChr);
            }
        }

        finishCurrentGattOperation();
    }

    public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
        //Log.v(TAG, "onReliableWriteCompleted status=" + status);
    }

    public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
        //Log.v(TAG, "onReadRemoteRssi status=" + status);
    }

    public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
        //Log.v(TAG, "onMtuChanged status=" + status);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////
    //////// Public API
    //////////////////////////////////////////////////////////////////////////////////////////////////////

    @Override
    public int getId() {
        return mDeviceId;
    }

    @Override
    public int getVendorId() {
        // Valve Corporation
        final int VALVE_USB_VID = 0x28DE;
        return VALVE_USB_VID;
    }

    @Override
    public int getProductId() {
        // We don't have an easy way to query from the Bluetooth device, but we know what it is
        final int D0G_BLE2_PID = 0x1106;
        return D0G_BLE2_PID;
    }

    @Override
    public String getSerialNumber() {
        // This will be read later via feature report by Steam
        return "12345";
    }

    @Override
    public int getVersion() {
        return 0;
    }

    @Override
    public String getManufacturerName() {
        return "Valve Corporation";
    }

    @Override
    public String getProductName() {
        return "Steam Controller";
    }

    @Override
    public UsbDevice getDevice() {
        return null;
    }

    @Override
    public boolean open() {
        return true;
    }

    @Override
    public int sendFeatureReport(byte[] report) {
        if (!isRegistered()) {
            Log.e(TAG, "Attempted sendFeatureReport before Steam Controller is registered!");
            if (mIsConnected) {
                probeService(this);
            }
            return -1;
        }

        // We need to skip the first byte, as that doesn't go over the air
        byte[] actual_report = Arrays.copyOfRange(report, 1, report.length - 1);
        //Log.v(TAG, "sendFeatureReport " + HexDump.dumpHexString(actual_report));
        writeCharacteristic(reportCharacteristic, actual_report);
        return report.length;
    }

    @Override
    public int sendOutputReport(byte[] report) {
        if (!isRegistered()) {
            Log.e(TAG, "Attempted sendOutputReport before Steam Controller is registered!");
            if (mIsConnected) {
                probeService(this);
            }
            return -1;
        }

        //Log.v(TAG, "sendFeatureReport " + HexDump.dumpHexString(report));
        writeCharacteristic(reportCharacteristic, report);
        return report.length;
    }

    @Override
    public boolean getFeatureReport(byte[] report) {
        if (!isRegistered()) {
            Log.e(TAG, "Attempted getFeatureReport before Steam Controller is registered!");
            if (mIsConnected) {
                probeService(this);
            }
            return false;
        }

        //Log.v(TAG, "getFeatureReport");
        readCharacteristic(reportCharacteristic);
        return true;
    }

    @Override
    public void close() {
    }

    @Override
    public void setFrozen(boolean frozen) {
        mFrozen = frozen;
    }

    @Override
    public void shutdown() {
        close();

        BluetoothGatt g = mGatt;
        if (g != null) {
            g.disconnect();
            g.close();
            mGatt = null;
        }
        mManager = null;
        mIsRegistered = false;
        mIsConnected = false;
        mOperations.clear();
    }

}



================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/HIDDeviceManager.java
================================================
package org.libsdl.app;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.os.Build;
import android.util.Log;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.hardware.usb.*;
import android.os.Handler;
import android.os.Looper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

public class HIDDeviceManager {
    private static final String TAG = "hidapi";
    private static final String ACTION_USB_PERMISSION = "org.libsdl.app.USB_PERMISSION";

    private static HIDDeviceManager sManager;
    private static int sManagerRefCount = 0;

    public static HIDDeviceManager acquire(Context context) {
        if (sManagerRefCount == 0) {
            sManager = new HIDDeviceManager(context);
        }
        ++sManagerRefCount;
        return sManager;
    }

    public static void release(HIDDeviceManager manager) {
        if (manager == sManager) {
            --sManagerRefCount;
            if (sManagerRefCount == 0) {
                sManager.close();
                sManager = null;
            }
        }
    }

    private Context mContext;
    private HashMap<Integer, HIDDevice> mDevicesById = new HashMap<Integer, HIDDevice>();
    private HashMap<BluetoothDevice, HIDDeviceBLESteamController> mBluetoothDevices = new HashMap<BluetoothDevice, HIDDeviceBLESteamController>();
    private int mNextDeviceId = 0;
    private SharedPreferences mSharedPreferences = null;
    private boolean mIsChromebook = false;
    private UsbManager mUsbManager;
    private Handler mHandler;
    private BluetoothManager mBluetoothManager;
    private List<BluetoothDevice> mLastBluetoothDevices;

    private final BroadcastReceiver mUsbBroadcast = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
                UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                handleUsbDeviceAttached(usbDevice);
            } else if (action.equals(UsbManager.ACTION_USB_DEVICE_DETACHED)) {
                UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                handleUsbDeviceDetached(usbDevice);
            } else if (action.equals(HIDDeviceManager.ACTION_USB_PERMISSION)) {
                UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                handleUsbDevicePermission(usbDevice, intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false));
            }
        }
    };

    private final BroadcastReceiver mBluetoothBroadcast = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            // Bluetooth device was connected. If it was a Steam Controller, handle it
            if (action.equals(BluetoothDevice.ACTION_ACL_CONNECTED)) {
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                Log.d(TAG, "Bluetooth device connected: " + device);

                if (isSteamController(device)) {
                    connectBluetoothDevice(device);
                }
            }

            // Bluetooth device was disconnected, remove from controller manager (if any)
            if (action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) {
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                Log.d(TAG, "Bluetooth device disconnected: " + device);

                disconnectBluetoothDevice(device);
            }
        }
    };

    private HIDDeviceManager(final Context context) {
        mContext = context;

        HIDDeviceRegisterCallback();

        mSharedPreferences = mContext.getSharedPreferences("hidapi", Context.MODE_PRIVATE);
        mIsChromebook = mContext.getPackageManager().hasSystemFeature("org.chromium.arc.device_management");

//        if (shouldClear) {
//            SharedPreferences.Editor spedit = mSharedPreferences.edit();
//            spedit.clear();
//            spedit.commit();
//        }
//        else
        {
            mNextDeviceId = mSharedPreferences.getInt("next_device_id", 0);
        }
    }

    public Context getContext() {
        return mContext;
    }

    public int getDeviceIDForIdentifier(String identifier) {
        SharedPreferences.Editor spedit = mSharedPreferences.edit();

        int result = mSharedPreferences.getInt(identifier, 0);
        if (result == 0) {
            result = mNextDeviceId++;
            spedit.putInt("next_device_id", mNextDeviceId);
        }

        spedit.putInt(identifier, result);
        spedit.commit();
        return result;
    }

    private void initializeUSB() {
        mUsbManager = (UsbManager)mContext.getSystemService(Context.USB_SERVICE);
        if (mUsbManager == null) {
            return;
        }

        /*
        // Logging
        for (UsbDevice device : mUsbManager.getDeviceList().values()) {
            Log.i(TAG,"Path: " + device.getDeviceName());
            Log.i(TAG,"Manufacturer: " + device.getManufacturerName());
            Log.i(TAG,"Product: " + device.getProductName());
            Log.i(TAG,"ID: " + device.getDeviceId());
            Log.i(TAG,"Class: " + device.getDeviceClass());
            Log.i(TAG,"Protocol: " + device.getDeviceProtocol());
            Log.i(TAG,"Vendor ID " + device.getVendorId());
            Log.i(TAG,"Product ID: " + device.getProductId());
            Log.i(TAG,"Interface count: " + device.getInterfaceCount());
            Log.i(TAG,"---------------------------------------");

            // Get interface details
            for (int index = 0; index < device.getInterfaceCount(); index++) {
                UsbInterface mUsbInterface = device.getInterface(index);
                Log.i(TAG,"  *****     *****");
                Log.i(TAG,"  Interface index: " + index);
                Log.i(TAG,"  Interface ID: " + mUsbInterface.getId());
                Log.i(TAG,"  Interface class: " + mUsbInterface.getInterfaceClass());
                Log.i(TAG,"  Interface subclass: " + mUsbInterface.getInterfaceSubclass());
                Log.i(TAG,"  Interface protocol: " + mUsbInterface.getInterfaceProtocol());
                Log.i(TAG,"  Endpoint count: " + mUsbInterface.getEndpointCount());

                // Get endpoint details
                for (int epi = 0; epi < mUsbInterface.getEndpointCount(); epi++)
                {
                    UsbEndpoint mEndpoint = mUsbInterface.getEndpoint(epi);
                    Log.i(TAG,"    ++++   ++++   ++++");
                    Log.i(TAG,"    Endpoint index: " + epi);
                    Log.i(TAG,"    Attributes: " + mEndpoint.getAttributes());
                    Log.i(TAG,"    Direction: " + mEndpoint.getDirection());
                    Log.i(TAG,"    Number: " + mEndpoint.getEndpointNumber());
                    Log.i(TAG,"    Interval: " + mEndpoint.getInterval());
                    Log.i(TAG,"    Packet size: " + mEndpoint.getMaxPacketSize());
                    Log.i(TAG,"    Type: " + mEndpoint.getType());
                }
            }
        }
        Log.i(TAG," No more devices connected.");
        */

        // Register for USB broadcasts and permission completions
        IntentFilter filter = new IntentFilter();
        filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
        filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
        filter.addAction(HIDDeviceManager.ACTION_USB_PERMISSION);
        mContext.registerReceiver(mUsbBroadcast, filter);

        for (UsbDevice usbDevice : mUsbManager.getDeviceList().values()) {
            handleUsbDeviceAttached(usbDevice);
        }
    }

    UsbManager getUSBManager() {
        return mUsbManager;
    }

    private void shutdownUSB() {
        try {
            mContext.unregisterReceiver(mUsbBroadcast);
        } catch (Exception e) {
            // We may not have registered, that's okay
        }
    }

    private boolean isHIDDeviceInterface(UsbDevice usbDevice, UsbInterface usbInterface) {
        if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_HID) {
            return true;
        }
        if (isXbox360Controller(usbDevice, usbInterface) || isXboxOneController(usbDevice, usbInterface)) {
            return true;
        }
        return false;
    }

    private boolean isXbox360Controller(UsbDevice usbDevice, UsbInterface usbInterface) {
        final int XB360_IFACE_SUBCLASS = 93;
        final int XB360_IFACE_PROTOCOL = 1; // Wired
        final int XB360W_IFACE_PROTOCOL = 129; // Wireless
        final int[] SUPPORTED_VENDORS = {
            0x0079, // GPD Win 2
            0x044f, // Thrustmaster
            0x045e, // Microsoft
            0x046d, // Logitech
            0x056e, // Elecom
            0x06a3, // Saitek
            0x0738, // Mad Catz
            0x07ff, // Mad Catz
            0x0e6f, // PDP
            0x0f0d, // Hori
            0x1038, // SteelSeries
            0x11c9, // Nacon
            0x12ab, // Unknown
            0x1430, // RedOctane
            0x146b, // BigBen
            0x1532, // Razer Sabertooth
            0x15e4, // Numark
            0x162e, // Joytech
            0x1689, // Razer Onza
            0x1949, // Lab126, Inc.
            0x1bad, // Harmonix
            0x20d6, // PowerA
            0x24c6, // PowerA
            0x2c22, // Qanba
            0x2dc8, // 8BitDo
            0x9886, // ASTRO Gaming
        };

        if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_VENDOR_SPEC &&
            usbInterface.getInterfaceSubclass() == XB360_IFACE_SUBCLASS &&
            (usbInterface.getInterfaceProtocol() == XB360_IFACE_PROTOCOL ||
             usbInterface.getInterfaceProtocol() == XB360W_IFACE_PROTOCOL)) {
            int vendor_id = usbDevice.getVendorId();
            for (int supportedVid : SUPPORTED_VENDORS) {
                if (vendor_id == supportedVid) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean isXboxOneController(UsbDevice usbDevice, UsbInterface usbInterface) {
        final int XB1_IFACE_SUBCLASS = 71;
        final int XB1_IFACE_PROTOCOL = 208;
        final int[] SUPPORTED_VENDORS = {
            0x03f0, // HP
            0x044f, // Thrustmaster
            0x045e, // Microsoft
            0x0738, // Mad Catz
            0x0b05, // ASUS
            0x0e6f, // PDP
            0x0f0d, // Hori
            0x10f5, // Turtle Beach
            0x1532, // Razer Wildcat
            0x20d6, // PowerA
            0x24c6, // PowerA
            0x2dc8, // 8BitDo
            0x2e24, // Hyperkin
            0x3537, // GameSir
        };

        if (usbInterface.getId() == 0 &&
            usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_VENDOR_SPEC &&
            usbInterface.getInterfaceSubclass() == XB1_IFACE_SUBCLASS &&
            usbInterface.getInterfaceProtocol() == XB1_IFACE_PROTOCOL) {
            int vendor_id = usbDevice.getVendorId();
            for (int supportedVid : SUPPORTED_VENDORS) {
                if (vendor_id == supportedVid) {
                    return true;
                }
            }
        }
        return false;
    }

    private void handleUsbDeviceAttached(UsbDevice usbDevice) {
        connectHIDDeviceUSB(usbDevice);
    }

    private void handleUsbDeviceDetached(UsbDevice usbDevice) {
        List<Integer> devices = new ArrayList<Integer>();
        for (HIDDevice device : mDevicesById.values()) {
            if (usbDevice.equals(device.getDevice())) {
                devices.add(device.getId());
            }
        }
        for (int id : devices) {
            HIDDevice device = mDevicesById.get(id);
            mDevicesById.remove(id);
            device.shutdown();
            HIDDeviceDisconnected(id);
        }
    }

    private void handleUsbDevicePermission(UsbDevice usbDevice, boolean permission_granted) {
        for (HIDDevice device : mDevicesById.values()) {
            if (usbDevice.equals(device.getDevice())) {
                boolean opened = false;
                if (permission_granted) {
                    opened = device.open();
                }
                HIDDeviceOpenResult(device.getId(), opened);
            }
        }
    }

    private void connectHIDDeviceUSB(UsbDevice usbDevice) {
        synchronized (this) {
            int interface_mask = 0;
            for (int interface_index = 0; interface_index < usbDevice.getInterfaceCount(); interface_index++) {
                UsbInterface usbInterface = usbDevice.getInterface(interface_index);
                if (isHIDDeviceInterface(usbDevice, usbInterface)) {
                    // Check to see if we've already added this interface
                    // This happens with the Xbox Series X controller which has a duplicate interface 0, which is inactive
                    int interface_id = usbInterface.getId();
                    if ((interface_mask & (1 << interface_id)) != 0) {
                        continue;
                    }
                    interface_mask |= (1 << interface_id);

                    HIDDeviceUSB device = new HIDDeviceUSB(this, usbDevice, interface_index);
                    int id = device.getId();
                    mDevicesById.put(id, device);
                    HIDDeviceConnected(id, device.getIdentifier(), device.getVendorId(), device.getProductId(), device.getSerialNumber(), device.getVersion(), device.getManufacturerName(), device.getProductName(), usbInterface.getId(), usbInterface.getInterfaceClass(), usbInterface.getInterfaceSubclass(), usbInterface.getInterfaceProtocol());
                }
            }
        }
    }

    private void initializeBluetooth() {
        Log.d(TAG, "Initializing Bluetooth");

        if (Build.VERSION.SDK_INT >= 31 /* Android 12  */ &&
            mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH_CONNECT, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "Couldn't initialize Bluetooth, missing android.permission.BLUETOOTH_CONNECT");
            return;
        }

        if (Build.VERSION.SDK_INT <= 30 /* Android 11.0 (R) */ &&
            mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "Couldn't initialize Bluetooth, missing android.permission.BLUETOOTH");
            return;
        }

        if (!mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE) || (Build.VERSION.SDK_INT < 18 /* Android 4.3 (JELLY_BEAN_MR2) */)) {
            Log.d(TAG, "Couldn't initialize Bluetooth, this version of Android does not support Bluetooth LE");
            return;
        }

        // Find bonded bluetooth controllers and create SteamControllers for them
        mBluetoothManager = (BluetoothManager)mContext.getSystemService(Context.BLUETOOTH_SERVICE);
        if (mBluetoothManager == null) {
            // This device doesn't support Bluetooth.
            return;
        }

        BluetoothAdapter btAdapter = mBluetoothManager.getAdapter();
        if (btAdapter == null) {
            // This device has Bluetooth support in the codebase, but has no available adapters.
            return;
        }

        // Get our bonded devices.
        for (BluetoothDevice device : btAdapter.getBondedDevices()) {

            Log.d(TAG, "Bluetooth device available: " + device);
            if (isSteamController(device)) {
                connectBluetoothDevice(device);
            }

        }

        // NOTE: These don't work on Chromebooks, to my undying dismay.
        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED);
        filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
        mContext.registerReceiver(mBluetoothBroadcast, filter);

        if (mIsChromebook) {
            mHandler = new Handler(Looper.getMainLooper());
            mLastBluetoothDevices = new ArrayList<BluetoothDevice>();

            // final HIDDeviceManager finalThis = this;
            // mHandler.postDelayed(new Runnable() {
            //     @Override
            //     public void run() {
            //         finalThis.chromebookConnectionHandler();
            //     }
            // }, 5000);
        }
    }

    private void shutdownBluetooth() {
        try {
            mContext.unregisterReceiver(mBluetoothBroadcast);
        } catch (Exception e) {
            // We may not have registered, that's okay
        }
    }

    // Chromebooks do not pass along ACTION_ACL_CONNECTED / ACTION_ACL_DISCONNECTED properly.
    // This function provides a sort of dummy version of that, watching for changes in the
    // connected devices and attempting to add controllers as things change.
    public void chromebookConnectionHandler() {
        if (!mIsChromebook) {
            return;
        }

        ArrayList<BluetoothDevice> disconnected = new ArrayList<BluetoothDevice>();
        ArrayList<BluetoothDevice> connected = new ArrayList<BluetoothDevice>();

        List<BluetoothDevice> currentConnected = mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT);

        for (BluetoothDevice bluetoothDevice : currentConnected) {
            if (!mLastBluetoothDevices.contains(bluetoothDevice)) {
                connected.add(bluetoothDevice);
            }
        }
        for (BluetoothDevice bluetoothDevice : mLastBluetoothDevices) {
            if (!currentConnected.contains(bluetoothDevice)) {
                disconnected.add(bluetoothDevice);
            }
        }

        mLastBluetoothDevices = currentConnected;

        for (BluetoothDevice bluetoothDevice : disconnected) {
            disconnectBluetoothDevice(bluetoothDevice);
        }
        for (BluetoothDevice bluetoothDevice : connected) {
            connectBluetoothDevice(bluetoothDevice);
        }

        final HIDDeviceManager finalThis = this;
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                finalThis.chromebookConnectionHandler();
            }
        }, 10000);
    }

    public boolean connectBluetoothDevice(BluetoothDevice bluetoothDevice) {
        Log.v(TAG, "connectBluetoothDevice device=" + bluetoothDevice);
        synchronized (this) {
            if (mBluetoothDevices.containsKey(bluetoothDevice)) {
                Log.v(TAG, "Steam controller with address " + bluetoothDevice + " already exists, attempting reconnect");

                HIDDeviceBLESteamController device = mBluetoothDevices.get(bluetoothDevice);
                device.reconnect();

                return false;
            }
            HIDDeviceBLESteamController device = new HIDDeviceBLESteamController(this, bluetoothDevice);
            int id = device.getId();
            mBluetoothDevices.put(bluetoothDevice, device);
            mDevicesById.put(id, device);

            // The Steam Controller will mark itself connected once initialization is complete
        }
        return true;
    }

    public void disconnectBluetoothDevice(BluetoothDevice bluetoothDevice) {
        synchronized (this) {
            HIDDeviceBLESteamController device = mBluetoothDevices.get(bluetoothDevice);
            if (device == null)
                return;

            int id = device.getId();
            mBluetoothDevices.remove(bluetoothDevice);
            mDevicesById.remove(id);
            device.shutdown();
            HIDDeviceDisconnected(id);
        }
    }

    public boolean isSteamController(BluetoothDevice bluetoothDevice) {
        // Sanity check.  If you pass in a null device, by definition it is never a Steam Controller.
        if (bluetoothDevice == null) {
            return false;
        }

        // If the device has no local name, we really don't want to try an equality check against it.
        if (bluetoothDevice.getName() == null) {
            return false;
        }

        return bluetoothDevice.getName().equals("SteamController") && ((bluetoothDevice.getType() & BluetoothDevice.DEVICE_TYPE_LE) != 0);
    }

    private void close() {
        shutdownUSB();
        shutdownBluetooth();
        synchronized (this) {
            for (HIDDevice device : mDevicesById.values()) {
                device.shutdown();
            }
            mDevicesById.clear();
            mBluetoothDevices.clear();
            HIDDeviceReleaseCallback();
        }
    }

    public void setFrozen(boolean frozen) {
        synchronized (this) {
            for (HIDDevice device : mDevicesById.values()) {
                device.setFrozen(frozen);
            }
        }
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////

    private HIDDevice getDevice(int id) {
        synchronized (this) {
            HIDDevice result = mDevicesById.get(id);
            if (result == null) {
                Log.v(TAG, "No device for id: " + id);
                Log.v(TAG, "Available devices: " + mDevicesById.keySet());
            }
            return result;
        }
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////// JNI interface functions
    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public boolean initialize(boolean usb, boolean bluetooth) {
        Log.v(TAG, "initialize(" + usb + ", " + bluetooth + ")");

        if (usb) {
            initializeUSB();
        }
        if (bluetooth) {
            initializeBluetooth();
        }
        return true;
    }

    public boolean openDevice(int deviceID) {
        Log.v(TAG, "openDevice deviceID=" + deviceID);
        HIDDevice device = getDevice(deviceID);
        if (device == null) {
            HIDDeviceDisconnected(deviceID);
            return false;
        }

        // Look to see if this is a USB device and we have permission to access it
        UsbDevice usbDevice = device.getDevice();
        if (usbDevice != null && !mUsbManager.hasPermission(usbDevice)) {
            HIDDeviceOpenPending(deviceID);
            try {
                final int FLAG_MUTABLE = 0x02000000; // PendingIntent.FLAG_MUTABLE, but don't require SDK 31
                int flags;
                if (Build.VERSION.SDK_INT >= 31 /* Android 12.0 (S) */) {
                    flags = FLAG_MUTABLE;
                } else {
                    flags = 0;
                }
                if (Build.VERSION.SDK_INT >= 33 /* Android 14.0 (U) */) {
                   Intent intent = new Intent(HIDDeviceManager.ACTION_USB_PERMISSION);
                   intent.setPackage(mContext.getPackageName());
                   mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, intent, flags));
               } else {
                   mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, new Intent(HIDDeviceManager.ACTION_USB_PERMISSION), flags));
               }
            } catch (Exception e) {
                Log.v(TAG, "Couldn't request permission for USB device " + usbDevice);
                HIDDeviceOpenResult(deviceID, false);
            }
            return false;
        }

        try {
            return device.open();
        } catch (Exception e) {
            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
        }
        return false;
    }

    public int sendOutputReport(int deviceID, byte[] report) {
        try {
            //Log.v(TAG, "sendOutputReport deviceID=" + deviceID + " length=" + report.length);
            HIDDevice device;
            device = getDevice(deviceID);
            if (device == null) {
                HIDDeviceDisconnected(deviceID);
                return -1;
            }

            return device.sendOutputReport(report);
        } catch (Exception e) {
            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
        }
        return -1;
    }

    public int sendFeatureReport(int deviceID, byte[] report) {
        try {
            //Log.v(TAG, "sendFeatureReport deviceID=" + deviceID + " length=" + report.length);
            HIDDevice device;
            device = getDevice(deviceID);
            if (device == null) {
                HIDDeviceDisconnected(deviceID);
                return -1;
            }

            return device.sendFeatureReport(report);
        } catch (Exception e) {
            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
        }
        return -1;
    }

    public boolean getFeatureReport(int deviceID, byte[] report) {
        try {
            //Log.v(TAG, "getFeatureReport deviceID=" + deviceID);
            HIDDevice device;
            device = getDevice(deviceID);
            if (device == null) {
                HIDDeviceDisconnected(deviceID);
                return false;
            }

            return device.getFeatureReport(report);
        } catch (Exception e) {
            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
        }
        return false;
    }

    public void closeDevice(int deviceID) {
        try {
            Log.v(TAG, "closeDevice deviceID=" + deviceID);
            HIDDevice device;
            device = getDevice(deviceID);
            if (device == null) {
                HIDDeviceDisconnected(deviceID);
                return;
            }

            device.close();
        } catch (Exception e) {
            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
        }
    }


    //////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////// Native methods
    //////////////////////////////////////////////////////////////////////////////////////////////////////

    private native void HIDDeviceRegisterCallback();
    private native void HIDDeviceReleaseCallback();

    native void HIDDeviceConnected(int deviceID, String identifier, int vendorId, int productId, String serial_number, int release_number, String manufacturer_string, String product_string, int interface_number, int interface_class, int interface_subclass, int interface_protocol);
    native void HIDDeviceOpenPending(int deviceID);
    native void HIDDeviceOpenResult(int deviceID, boolean opened);
    native void HIDDeviceDisconnected(int deviceID);

    native void HIDDeviceInputReport(int deviceID, byte[] report);
    native void HIDDeviceFeatureReport(int deviceID, byte[] report);
}


================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/HIDDeviceUSB.java
================================================
package org.libsdl.app;

import android.hardware.usb.*;
import android.os.Build;
import android.util.Log;
import java.util.Arrays;

class HIDDeviceUSB implements HIDDevice {

    private static final String TAG = "hidapi";

    protected HIDDeviceManager mManager;
    protected UsbDevice mDevice;
    protected int mInterfaceIndex;
    protected int mInterface;
    protected int mDeviceId;
    protected UsbDeviceConnection mConnection;
    protected UsbEndpoint mInputEndpoint;
    protected UsbEndpoint mOutputEndpoint;
    protected InputThread mInputThread;
    protected boolean mRunning;
    protected boolean mFrozen;

    public HIDDeviceUSB(HIDDeviceManager manager, UsbDevice usbDevice, int interface_index) {
        mManager = manager;
        mDevice = usbDevice;
        mInterfaceIndex = interface_index;
        mInterface = mDevice.getInterface(mInterfaceIndex).getId();
        mDeviceId = manager.getDeviceIDForIdentifier(getIdentifier());
        mRunning = false;
    }

    public String getIdentifier() {
        return String.format("%s/%x/%x/%d", mDevice.getDeviceName(), mDevice.getVendorId(), mDevice.getProductId(), mInterfaceIndex);
    }

    @Override
    public int getId() {
        return mDeviceId;
    }

    @Override
    public int getVendorId() {
        return mDevice.getVendorId();
    }

    @Override
    public int getProductId() {
        return mDevice.getProductId();
    }

    @Override
    public String getSerialNumber() {
        String result = null;
        if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
            try {
                result = mDevice.getSerialNumber();
            }
            catch (SecurityException exception) {
                //Log.w(TAG, "App permissions mean we cannot get serial number for device " + getDeviceName() + " message: " + exception.getMessage());
            }
        }
        if (result == null) {
            result = "";
        }
        return result;
    }

    @Override
    public int getVersion() {
        return 0;
    }

    @Override
    public String getManufacturerName() {
        String result = null;
        if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
            result = mDevice.getManufacturerName();
        }
        if (result == null) {
            result = String.format("%x", getVendorId());
        }
        return result;
    }

    @Override
    public String getProductName() {
        String result = null;
        if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
            result = mDevice.getProductName();
        }
        if (result == null) {
            result = String.format("%x", getProductId());
        }
        return result;
    }

    @Override
    public UsbDevice getDevice() {
        return mDevice;
    }

    public String getDeviceName() {
        return getManufacturerName() + " " + getProductName() + "(0x" + String.format("%x", getVendorId()) + "/0x" + String.format("%x", getProductId()) + ")";
    }

    @Override
    public boolean open() {
        mConnection = mManager.getUSBManager().openDevice(mDevice);
        if (mConnection == null) {
            Log.w(TAG, "Unable to open USB device " + getDeviceName());
            return false;
        }

        // Force claim our interface
        UsbInterface iface = mDevice.getInterface(mInterfaceIndex);
        if (!mConnection.claimInterface(iface, true)) {
            Log.w(TAG, "Failed to claim interfaces on USB device " + getDeviceName());
            close();
            return false;
        }

        // Find the endpoints
        for (int j = 0; j < iface.getEndpointCount(); j++) {
            UsbEndpoint endpt = iface.getEndpoint(j);
            switch (endpt.getDirection()) {
            case UsbConstants.USB_DIR_IN:
                if (mInputEndpoint == null) {
                    mInputEndpoint = endpt;
                }
                break;
            case UsbConstants.USB_DIR_OUT:
                if (mOutputEndpoint == null) {
                    mOutputEndpoint = endpt;
                }
                break;
            }
        }

        // Make sure the required endpoints were present
        if (mInputEndpoint == null || mOutputEndpoint == null) {
            Log.w(TAG, "Missing required endpoint on USB device " + getDeviceName());
            close();
            return false;
        }

        // Start listening for input
        mRunning = true;
        mInputThread = new InputThread();
        mInputThread.start();

        return true;
    }

    @Override
    public int sendFeatureReport(byte[] report) {
        int res = -1;
        int offset = 0;
        int length = report.length;
        boolean skipped_report_id = false;
        byte report_number = report[0];

        if (report_number == 0x0) {
            ++offset;
            --length;
            skipped_report_id = true;
        }

        res = mConnection.controlTransfer(
            UsbConstants.USB_TYPE_CLASS | 0x01 /*RECIPIENT_INTERFACE*/ | UsbConstants.USB_DIR_OUT,
            0x09/*HID set_report*/,
            (3/*HID feature*/ << 8) | report_number,
            mInterface,
            report, offset, length,
            1000/*timeout millis*/);

        if (res < 0) {
            Log.w(TAG, "sendFeatureReport() returned " + res + " on device " + getDeviceName());
            return -1;
        }

        if (skipped_report_id) {
            ++length;
        }
        return length;
    }

    @Override
    public int sendOutputReport(byte[] report) {
        int r = mConnection.bulkTransfer(mOutputEndpoint, report, report.length, 1000);
        if (r != report.length) {
            Log.w(TAG, "sendOutputReport() returned " + r + " on device " + getDeviceName());
        }
        return r;
    }

    @Override
    public boolean getFeatureReport(byte[] report) {
        int res = -1;
        int offset = 0;
        int length = report.length;
        boolean skipped_report_id = false;
        byte report_number = report[0];

        if (report_number == 0x0) {
            /* Offset the return buffer by 1, so that the report ID
               will remain in byte 0. */
            ++offset;
            --length;
            skipped_report_id = true;
        }

        res = mConnection.controlTransfer(
            UsbConstants.USB_TYPE_CLASS | 0x01 /*RECIPIENT_INTERFACE*/ | UsbConstants.USB_DIR_IN,
            0x01/*HID get_report*/,
            (3/*HID feature*/ << 8) | report_number,
            mInterface,
            report, offset, length,
            1000/*timeout millis*/);

        if (res < 0) {
            Log.w(TAG, "getFeatureReport() returned " + res + " on device " + getDeviceName());
            return false;
        }

        if (skipped_report_id) {
            ++res;
            ++length;
        }

        byte[] data;
        if (res == length) {
            data = report;
        } else {
            data = Arrays.copyOfRange(report, 0, res);
        }
        mManager.HIDDeviceFeatureReport(mDeviceId, data);

        return true;
    }

    @Override
    public void close() {
        mRunning = false;
        if (mInputThread != null) {
            while (mInputThread.isAlive()) {
                mInputThread.interrupt();
                try {
                    mInputThread.join();
                } catch (InterruptedException e) {
                    // Keep trying until we're done
                }
            }
            mInputThread = null;
        }
        if (mConnection != null) {
            UsbInterface iface = mDevice.getInterface(mInterfaceIndex);
            mConnection.releaseInterface(iface);
            mConnection.close();
            mConnection = null;
        }
    }

    @Override
    public void shutdown() {
        close();
        mManager = null;
    }

    @Override
    public void setFrozen(boolean frozen) {
        mFrozen = frozen;
    }

    protected class InputThread extends Thread {
        @Override
        public void run() {
            int packetSize = mInputEndpoint.getMaxPacketSize();
            byte[] packet = new byte[packetSize];
            while (mRunning) {
                int r;
                try
                {
                    r = mConnection.bulkTransfer(mInputEndpoint, packet, packetSize, 1000);
                }
                catch (Exception e)
                {
                    Log.v(TAG, "Exception in UsbDeviceConnection bulktransfer: " + e);
                    break;
                }
                if (r < 0) {
                    // Could be a timeout or an I/O error
                }
                if (r > 0) {
                    byte[] data;
                    if (r == packetSize) {
                        data = packet;
                    } else {
                        data = Arrays.copyOfRange(packet, 0, r);
                    }

                    if (!mFrozen) {
                        mManager.HIDDeviceInputReport(mDeviceId, data);
                    }
                }
            }
        }
    }
}


================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/SDL.java
================================================
package org.libsdl.app;

import android.content.Context;

import java.lang.Class;
import java.lang.reflect.Method;

/**
    SDL library initialization
*/
public class SDL {

    // This function should be called first and sets up the native code
    // so it can call into the Java classes
    public static void setupJNI() {
        SDLActivity.nativeSetupJNI();
        SDLAudioManager.nativeSetupJNI();
        SDLControllerManager.nativeSetupJNI();
    }

    // This function should be called each time the activity is started
    public static void initialize() {
        setContext(null);

        SDLActivity.initialize();
        SDLAudioManager.initialize();
        SDLControllerManager.initialize();
    }

    // This function stores the current activity (SDL or not)
    public static void setContext(Context context) {
        SDLAudioManager.setContext(context);
        mContext = context;
    }

    public static Context getContext() {
        return mContext;
    }

    public static void loadLibrary(String libraryName) throws UnsatisfiedLinkError, SecurityException, NullPointerException {
        loadLibrary(libraryName, mContext);
    }

    public static void loadLibrary(String libraryName, Context context) throws UnsatisfiedLinkError, SecurityException, NullPointerException {

        if (libraryName == null) {
            throw new NullPointerException("No library name provided.");
        }

        try {
            // Let's see if we have ReLinker available in the project.  This is necessary for 
            // some projects that have huge numbers of local libraries bundled, and thus may 
            // trip a bug in Android's native library loader which ReLinker works around.  (If
            // loadLibrary works properly, ReLinker will simply use the normal Android method
            // internally.)
            //
            // To use ReLinker, just add it as a dependency.  For more information, see 
            // https://github.com/KeepSafe/ReLinker for ReLinker's repository.
            //
            Class<?> relinkClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker");
            Class<?> relinkListenerClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker$LoadListener");
            Class<?> contextClass = context.getClassLoader().loadClass("android.content.Context");
            Class<?> stringClass = context.getClassLoader().loadClass("java.lang.String");

            // Get a 'force' instance of the ReLinker, so we can ensure libraries are reinstalled if 
            // they've changed during updates.
            Method forceMethod = relinkClass.getDeclaredMethod("force");
            Object relinkInstance = forceMethod.invoke(null);
            Class<?> relinkInstanceClass = relinkInstance.getClass();

            // Actually load the library!
            Method loadMethod = relinkInstanceClass.getDeclaredMethod("loadLibrary", contextClass, stringClass, stringClass, relinkListenerClass);
            loadMethod.invoke(relinkInstance, context, libraryName, null, null);
        }
        catch (final Throwable e) {
            // Fall back
            try {
                System.loadLibrary(libraryName);
            }
            catch (final UnsatisfiedLinkError ule) {
                throw ule;
            }
            catch (final SecurityException se) {
                throw se;
            }
        }
    }

    protected static Context mContext;
}


================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/SDLActivity.java
================================================
package org.libsdl.app;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.UiModeManager;
import android.content.ClipboardManager;
import android.content.ClipData;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.PorterDuff;
import android.graphics.drawable.Drawable;
import android.hardware.Sensor;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.Editable;
import android.text.InputType;
import android.text.Selection;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.SparseArray;
import android.view.Display;
import android.view.Gravity;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.PointerIcon;
import android.view.Surface;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.view.inputmethod.BaseInputConnection;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import java.util.Hashtable;
import java.util.Locale;


/**
    SDL Activity
*/
public class SDLActivity extends Activity implements View.OnSystemUiVisibilityChangeListener {
    private static final String TAG = "SDL";
    private static final int SDL_MAJOR_VERSION = 2;
    private static final int SDL_MINOR_VERSION = 32;
    private static final int SDL_MICRO_VERSION = 10;
/*
    // Display InputType.SOURCE/CLASS of events and devices
    //
    // SDLActivity.debugSource(device.getSources(), "device[" + device.getName() + "]");
    // SDLActivity.debugSource(event.getSource(), "event");
    public static void debugSource(int sources, String prefix) {
        int s = sources;
        int s_copy = sources;
        String cls = "";
        String src = "";
        int tst = 0;
        int FLAG_TAINTED = 0x80000000;

        if ((s & InputDevice.SOURCE_CLASS_BUTTON) != 0)     cls += " BUTTON";
        if ((s & InputDevice.SOURCE_CLASS_JOYSTICK) != 0)   cls += " JOYSTICK";
        if ((s & InputDevice.SOURCE_CLASS_POINTER) != 0)    cls += " POINTER";
        if ((s & InputDevice.SOURCE_CLASS_POSITION) != 0)   cls += " POSITION";
        if ((s & InputDevice.SOURCE_CLASS_TRACKBALL) != 0)  cls += " TRACKBALL";


        int s2 = s_copy & ~InputDevice.SOURCE_ANY; // keep class bits
        s2 &= ~(  InputDevice.SOURCE_CLASS_BUTTON
                | InputDevice.SOURCE_CLASS_JOYSTICK
                | InputDevice.SOURCE_CLASS_POINTER
                | InputDevice.SOURCE_CLASS_POSITION
                | InputDevice.SOURCE_CLASS_TRACKBALL);

        if (s2 != 0) cls += "Some_Unknown";

        s2 = s_copy & InputDevice.SOURCE_ANY; // keep source only, no class;

        if (Build.VERSION.SDK_INT >= 23) {
            tst = InputDevice.SOURCE_BLUETOOTH_STYLUS;
            if ((s & tst) == tst) src += " BLUETOOTH_STYLUS";
            s2 &= ~tst;
        }

        tst = InputDevice.SOURCE_DPAD;
        if ((s & tst) == tst) src += " DPAD";
        s2 &= ~tst;

        tst = InputDevice.SOURCE_GAMEPAD;
        if ((s & tst) == tst) src += " GAMEPAD";
        s2 &= ~tst;

        if (Build.VERSION.SDK_INT >= 21) {
            tst = InputDevice.SOURCE_HDMI;
            if ((s & tst) == tst) src += " HDMI";
            s2 &= ~tst;
        }

        tst = InputDevice.SOURCE_JOYSTICK;
        if ((s & tst) == tst) src += " JOYSTICK";
        s2 &= ~tst;

        tst = InputDevice.SOURCE_KEYBOARD;
        if ((s & tst) == tst) src += " KEYBOARD";
        s2 &= ~tst;

        tst = InputDevice.SOURCE_MOUSE;
        if ((s & tst) == tst) src += " MOUSE";
        s2 &= ~tst;

        if (Build.VERSION.SDK_INT >= 26) {
            tst = InputDevice.SOURCE_MOUSE_RELATIVE;
            if ((s & tst) == tst) src += " MOUSE_RELATIVE";
            s2 &= ~tst;

            tst = InputDevice.SOURCE_ROTARY_ENCODER;
            if ((s & tst) == tst) src += " ROTARY_ENCODER";
            s2 &= ~tst;
        }
        tst = InputDevice.SOURCE_STYLUS;
        if ((s & tst) == tst) src += " STYLUS";
        s2 &= ~tst;

        tst = InputDevice.SOURCE_TOUCHPAD;
        if ((s & tst) == tst) src += " TOUCHPAD";
        s2 &= ~tst;

        tst = InputDevice.SOURCE_TOUCHSCREEN;
        if ((s & tst) == tst) src += " TOUCHSCREEN";
        s2 &= ~tst;

        if (Build.VERSION.SDK_INT >= 18) {
            tst = InputDevice.SOURCE_TOUCH_NAVIGATION;
            if ((s & tst) == tst) src += " TOUCH_NAVIGATION";
            s2 &= ~tst;
        }

        tst = InputDevice.SOURCE_TRACKBALL;
        if ((s & tst) == tst) src += " TRACKBALL";
        s2 &= ~tst;

        tst = InputDevice.SOURCE_ANY;
        if ((s & tst) == tst) src += " ANY";
        s2 &= ~tst;

        if (s == FLAG_TAINTED) src += " FLAG_TAINTED";
        s2 &= ~FLAG_TAINTED;

        if (s2 != 0) src += " Some_Unknown";

        Log.v(TAG, prefix + "int=" + s_copy + " CLASS={" + cls + " } source(s):" + src);
    }
*/

    public static boolean mIsResumedCalled, mHasFocus;
    public static final boolean mHasMultiWindow = (Build.VERSION.SDK_INT >= 24  /* Android 7.0 (N) */);

    // Cursor types
    // private static final int SDL_SYSTEM_CURSOR_NONE = -1;
    private static final int SDL_SYSTEM_CURSOR_ARROW = 0;
    private static final int SDL_SYSTEM_CURSOR_IBEAM = 1;
    private static final int SDL_SYSTEM_CURSOR_WAIT = 2;
    private static final int SDL_SYSTEM_CURSOR_CROSSHAIR = 3;
    private static final int SDL_SYSTEM_CURSOR_WAITARROW = 4;
    private static final int SDL_SYSTEM_CURSOR_SIZENWSE = 5;
    private static final int SDL_SYSTEM_CURSOR_SIZENESW = 6;
    private static final int SDL_SYSTEM_CURSOR_SIZEWE = 7;
    private static final int SDL_SYSTEM_CURSOR_SIZENS = 8;
    private static final int SDL_SYSTEM_CURSOR_SIZEALL = 9;
    private static final int SDL_SYSTEM_CURSOR_NO = 10;
    private static final int SDL_SYSTEM_CURSOR_HAND = 11;

    protected static final int SDL_ORIENTATION_UNKNOWN = 0;
    protected static final int SDL_ORIENTATION_LANDSCAPE = 1;
    protected static final int SDL_ORIENTATION_LANDSCAPE_FLIPPED = 2;
    protected static final int SDL_ORIENTATION_PORTRAIT = 3;
    protected static final int SDL_ORIENTATION_PORTRAIT_FLIPPED = 4;

    protected static int mCurrentOrientation;
    protected static Locale mCurrentLocale;

    // Handle the state of the native layer
    public enum NativeState {
           INIT, RESUMED, PAUSED
    }

    public static NativeState mNextNativeState;
    public static NativeState mCurrentNativeState;

    /** If shared libraries (e.g. SDL or the native application) could not be loaded. */
    public static boolean mBrokenLibraries = true;

    // Main components
    protected static SDLActivity mSingleton;
    protected static SDLSurface mSurface;
    protected static DummyEdit mTextEdit;
    protected static boolean mScreenKeyboardShown;
    protected static ViewGroup mLayout;
    protected static SDLClipboardHandler mClipboardHandler;
    protected static Hashtable<Integer, PointerIcon> mCursors;
    protected static int mLastCursorID;
    protected static SDLGenericMotionListener_API12 mMotionListener;
    protected static HIDDeviceManager mHIDDeviceManager;

    // This is what SDL runs in. It invokes SDL_main(), eventually
    protected static Thread mSDLThread;

    protected static SDLGenericMotionListener_API12 getMotionListener() {
        if (mMotionListener == null) {
            if (Build.VERSION.SDK_INT >= 26 /* Android 8.0 (O) */) {
                mMotionListener = new SDLGenericMotionListener_API26();
            } else if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
                mMotionListener = new SDLGenericMotionListener_API24();
            } else {
                mMotionListener = new SDLGenericMotionListener_API12();
            }
        }

        return mMotionListener;
    }

    /**
     * This method returns the name of the shared object with the application entry point
     * It can be overridden by derived classes.
     */
    protected String getMainSharedObject() {
        String library;
        String[] libraries = SDLActivity.mSingleton.getLibraries();
        if (libraries.length > 0) {
            library = "lib" + libraries[libraries.length - 1] + ".so";
        } else {
            library = "libmain.so";
        }
        return getContext().getApplicationInfo().nativeLibraryDir + "/" + library;
    }

    /**
     * This method returns the name of the application entry point
     * It can be overridden by derived classes.
     */
    protected String getMainFunction() {
        return "SDL_main";
    }

    /**
     * This method is called by SDL before loading the native shared libraries.
     * It can be overridden to provide names of shared libraries to be loaded.
     * The default implementation returns the defaults. It never returns null.
     * An array returned by a new implementation must at least contain "SDL2".
     * Also keep in mind that the order the libraries are loaded may matter.
     * @return names of shared libraries to be loaded (e.g. "SDL2", "main").
     */
    protected String[] getLibraries() {
        return new String[] {
            "SDL2",
            // "SDL2_image",
            // "SDL2_mixer",
            // "SDL2_net",
            // "SDL2_ttf",
            "main"
        };
    }

    // Load the .so
    public void loadLibraries() {
       for (String lib : getLibraries()) {
          SDL.loadLibrary(lib, this);
       }
    }

    /**
     * This method is called by SDL before starting the native application thread.
     * It can be overridden to provide the arguments after the application name.
     * The default implementation returns an empty array. It never returns null.
     * @return arguments for the native application.
     */
    protected String[] getArguments() {
        return new String[0];
    }

    public static void initialize() {
        // The static nature of the singleton and Android quirkyness force us to initialize everything here
        // Otherwise, when exiting the app and returning to it, these variables *keep* their pre exit values
        mSingleton = null;
        mSurface = null;
        mTextEdit = null;
        mLayout = null;
        mClipboardHandler = null;
        mCursors = new Hashtable<Integer, PointerIcon>();
        mLastCursorID = 0;
        mSDLThread = null;
        mIsResumedCalled = false;
        mHasFocus = true;
        mNextNativeState = NativeState.INIT;
        mCurrentNativeState = NativeState.INIT;
    }
    
    protected SDLSurface createSDLSurface(Context context) {
        return new SDLSurface(context);
    }

    // Setup
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.v(TAG, "Device: " + Build.DEVICE);
        Log.v(TAG, "Model: " + Build.MODEL);
        Log.v(TAG, "onCreate()");
        super.onCreate(savedInstanceState);

        try {
            Thread.currentThread().setName("SDLActivity");
        } catch (Exception e) {
            Log.v(TAG, "modify thread properties failed " + e.toString());
        }

        // Load shared libraries
        String errorMsgBrokenLib = "";
        try {
            loadLibraries();
            mBrokenLibraries = false; /* success */
        } catch(UnsatisfiedLinkError e) {
            System.err.println(e.getMessage());
            mBrokenLibraries = true;
            errorMsgBrokenLib = e.getMessage();
        } catch(Exception e) {
            System.err.println(e.getMessage());
            mBrokenLibraries = true;
            errorMsgBrokenLib = e.getMessage();
        }

        if (!mBrokenLibraries) {
            String expected_version = String.valueOf(SDL_MAJOR_VERSION) + "." +
                                      String.valueOf(SDL_MINOR_VERSION) + "." +
                                      String.valueOf(SDL_MICRO_VERSION);
            String version = nativeGetVersion();
            if (!version.equals(expected_version)) {
                mBrokenLibraries = true;
                errorMsgBrokenLib = "SDL C/Java version mismatch (expected " + expected_version + ", got " + version + ")";
            }
        }

        if (mBrokenLibraries) {
            mSingleton = this;
            AlertDialog.Builder dlgAlert  = new AlertDialog.Builder(this);
            dlgAlert.setMessage("An error occurred while trying to start the application. Please try again and/or reinstall."
                  + System.getProperty("line.separator")
                  + System.getProperty("line.separator")
                  + "Error: " + errorMsgBrokenLib);
            dlgAlert.setTitle("SDL Error");
            dlgAlert.setPositiveButton("Exit",
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog,int id) {
                        // if this button is clicked, close current activity
                        SDLActivity.mSingleton.finish();
                    }
                });
           dlgAlert.setCancelable(false);
           dlgAlert.create().show();

           return;
        }

        // Set up JNI
        SDL.setupJNI();

        // Initialize state
        SDL.initialize();

        // So we can call stuff from static callbacks
        mSingleton = this;
        SDL.setContext(this);

        mClipboardHandler = new SDLClipboardHandler();

        mHIDDeviceManager = HIDDeviceManager.acquire(this);

        // Set up the surface
        mSurface = createSDLSurface(this);

        mLayout = new RelativeLayout(this);
        mLayout.addView(mSurface);

        // Get our current screen orientation and pass it down.
        mCurrentOrientation = SDLActivity.getCurrentOrientation();
        // Only record current orientation
        SDLActivity.onNativeOrientationChanged(mCurrentOrientation);

        try {
            if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
                mCurrentLocale = getContext().getResources().getConfiguration().locale;
            } else {
                mCurrentLocale = getContext().getResources().getConfiguration().getLocales().get(0);
            }
        } catch(Exception ignored) {
        }

        setContentView(mLayout);

        setWindowStyle(false);

        getWindow().getDecorView().setOnSystemUiVisibilityChangeListener(this);

        // Get filename from "Open with" of another application
        Intent intent = getIntent();
        if (intent != null && intent.getData() != null) {
            String filename = intent.getData().getPath();
            if (filename != null) {
                Log.v(TAG, "Got filename: " + filename);
                SDLActivity.onNativeDropFile(filename);
            }
        }
    }

    protected void pauseNativeThread() {
        mNextNativeState = NativeState.PAUSED;
        mIsResumedCalled = false;

        if (SDLActivity.mBrokenLibraries) {
            return;
        }

        SDLActivity.handleNativeState();
    }

    protected void resumeNativeThread() {
        mNextNativeState = NativeState.RESUMED;
        mIsResumedCalled = true;

        if (SDLActivity.mBrokenLibraries) {
           return;
        }

        SDLActivity.handleNativeState();
    }

    // Events
    @Override
    protected void onPause() {
        Log.v(TAG, "onPause()");
        super.onPause();

        if (mHIDDeviceManager != null) {
            mHIDDeviceManager.setFrozen(true);
        }
        if (!mHasMultiWindow) {
            pauseNativeThread();
        }
    }

    @Override
    protected void onResume() {
        Log.v(TAG, "onResume()");
        super.onResume();

        if (mHIDDeviceManager != null) {
            mHIDDeviceManager.setFrozen(false);
        }
        if (!mHasMultiWindow) {
            resumeNativeThread();
        }
    }

    @Override
    protected void onStop() {
        Log.v(TAG, "onStop()");
        super.onStop();
        if (mHasMultiWindow) {
            pauseNativeThread();
        }
    }

    @Override
    protected void onStart() {
        Log.v(TAG, "onStart()");
        super.onStart();
        if (mHasMultiWindow) {
            resumeNativeThread();
        }
    }

    public static int getCurrentOrientation() {
        int result = SDL_ORIENTATION_UNKNOWN;

        Activity activity = (Activity)getContext();
        if (activity == null) {
            return result;
        }
        Display display = activity.getWindowManager().getDefaultDisplay();

        switch (display.getRotation()) {
            case Surface.ROTATION_0:
                result = SDL_ORIENTATION_PORTRAIT;
                break;

            case Surface.ROTATION_90:
                result = SDL_ORIENTATION_LANDSCAPE;
                break;

            case Surface.ROTATION_180:
                result = SDL_ORIENTATION_PORTRAIT_FLIPPED;
                break;

            case Surface.ROTATION_270:
                result = SDL_ORIENTATION_LANDSCAPE_FLIPPED;
                break;
        }

        return result;
    }

    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        Log.v(TAG, "onWindowFocusChanged(): " + hasFocus);

        if (SDLActivity.mBrokenLibraries) {
           return;
        }

        mHasFocus = hasFocus;
        if (hasFocus) {
           mNextNativeState = NativeState.RESUMED;
           SDLActivity.getMotionListener().reclaimRelativeMouseModeIfNeeded();

           SDLActivity.handleNativeState();
           nativeFocusChanged(true);

        } else {
           nativeFocusChanged(false);
           if (!mHasMultiWindow) {
               mNextNativeState = NativeState.PAUSED;
               SDLActivity.handleNativeState();
           }
        }
    }

    @Override
    public void onLowMemory() {
        Log.v(TAG, "onLowMemory()");
        super.onLowMemory();

        if (SDLActivity.mBrokenLibraries) {
           return;
        }

        SDLActivity.nativeLowMemory();
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        Log.v(TAG, "onConfigurationChanged()");
        super.onConfigurationChanged(newConfig);

        if (SDLActivity.mBrokenLibraries) {
           return;
        }

        if (mCurrentLocale == null || !mCurrentLocale.equals(newConfig.locale)) {
            mCurrentLocale = newConfig.locale;
            SDLActivity.onNativeLocaleChanged();
        }
    }

    @Override
    protected void onDestroy() {
        Log.v(TAG, "onDestroy()");

        if (mHIDDeviceManager != null) {
            HIDDeviceManager.release(mHIDDeviceManager);
            mHIDDeviceManager = null;
        }

        SDLAudioManager.release(this);

        if (SDLActivity.mBrokenLibraries) {
           super.onDestroy();
           return;
        }

        if (SDLActivity.mSDLThread != null) {

            // Send Quit event to "SDLThread" thread
            SDLActivity.nativeSendQuit();

            // Wait for "SDLThread" thread to end
            try {
                SDLActivity.mSDLThread.join();
            } catch(Exception e) {
                Log.v(TAG, "Problem stopping SDLThread: " + e);
            }
        }

        SDLActivity.nativeQuit();

        super.onDestroy();
    }

    @Override
    public void onBackPressed() {
        // Check if we want to block the back button in case of mouse right click.
        //
        // If we do, the normal hardware back button will no longer work and people have to use home,
        // but the mouse right click will work.
        //
        boolean trapBack = SDLActivity.nativeGetHintBoolean("SDL_ANDROID_TRAP_BACK_BUTTON", false);
        if (trapBack) {
            // Exit and let the mouse handler handle this button (if appropriate)
            return;
        }

        // Default system back button behavior.
        if (!isFinishing()) {
            super.onBackPressed();
        }
    }

    // Called by JNI from SDL.
    public static void manualBackButton() {
        mSingleton.pressBackButton();
    }

    // Used to get us onto the activity's main thread
    public void pressBackButton() {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if (!SDLActivity.this.isFinishing()) {
                    SDLActivity.this.superOnBackPressed();
                }
            }
        });
    }

    // Used to access the system back behavior.
    public void superOnBackPressed() {
        super.onBackPressed();
    }

    @Override
    public boolean dispatchKeyEvent(KeyEvent event) {

        if (SDLActivity.mBrokenLibraries) {
           return false;
        }

        int keyCode = event.getKeyCode();
        // Ignore certain special keys so they're handled by Android
        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN ||
            keyCode == KeyEvent.KEYCODE_VOLUME_UP ||
            keyCode == KeyEvent.KEYCODE_CAMERA ||
            keyCode == KeyEvent.KEYCODE_ZOOM_IN || /* API 11 */
            keyCode == KeyEvent.KEYCODE_ZOOM_OUT /* API 11 */
            ) {
            return false;
        }
        return super.dispatchKeyEvent(event);
    }

    /* Transition to next state */
    public static void handleNativeState() {

        if (mNextNativeState == mCurrentNativeState) {
            // Already in same state, discard.
            return;
        }

        // Try a transition to init state
        if (mNextNativeState == NativeState.INIT) {

            mCurrentNativeState = mNextNativeState;
            return;
        }

        // Try a transition to paused state
        if (mNextNativeState == NativeState.PAUSED) {
            if (mSDLThread != null) {
                nativePause();
            }
            if (mSurface != null) {
                mSurface.handlePause();
            }
            mCurrentNativeState = mNextNativeState;
            return;
        }

        // Try a transition to resumed state
        if (mNextNativeState == NativeState.RESUMED) {
            if (mSurface.mIsSurfaceReady && mHasFocus && mIsResumedCalled) {
                if (mSDLThread == null) {
                    // This is the entry point to the C app.
                    // Start up the C app thread and enable sensor input for the first time
                    // FIXME: Why aren't we enabling sensor input at start?

                    mSDLThread = new Thread(new SDLMain(), "SDLThread");
                    mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, true);
                    mSDLThread.start();

                    // No nativeResume(), don't signal Android_ResumeSem
                } else {
                    nativeResume();
                }
                mSurface.handleResume();

                mCurrentNativeState = mNextNativeState;
            }
        }
    }

    // Messages from the SDLMain thread
    static final int COMMAND_CHANGE_TITLE = 1;
    static final int COMMAND_CHANGE_WINDOW_STYLE = 2;
    static final int COMMAND_TEXTEDIT_HIDE = 3;
    static final int COMMAND_SET_KEEP_SCREEN_ON = 5;

    protected static final int COMMAND_USER = 0x8000;

    protected static boolean mFullscreenModeActive;

    /**
     * This method is called by SDL if SDL did not handle a message itself.
     * This happens if a received message contains an unsupported command.
     * Method can be overwritten to handle Messages in a different class.
     * @param command the command of the message.
     * @param param the parameter of the message. May be null.
     * @return if the message was handled in overridden method.
     */
    protected boolean onUnhandledMessage(int command, Object param) {
        return false;
    }

    /**
     * A Handler class for Messages from native SDL applications.
     * It uses current Activities as target (e.g. for the title).
     * static to prevent implicit references to enclosing object.
     */
    protected static class SDLCommandHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Context context = SDL.getContext();
            if (context == null) {
                Log.e(TAG, "error handling message, getContext() returned null");
                return;
            }
            switch (msg.arg1) {
            case COMMAND_CHANGE_TITLE:
                if (context instanceof Activity) {
                    ((Activity) context).setTitle((String)msg.obj);
                } else {
                    Log.e(TAG, "error handling message, getContext() returned no Activity");
                }
                break;
            case COMMAND_CHANGE_WINDOW_STYLE:
                if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
                    if (context instanceof Activity) {
                        Window window = ((Activity) context).getWindow();
                        if (window != null) {
                            if ((msg.obj instanceof Integer) && ((Integer) msg.obj != 0)) {
                                int flags = View.SYSTEM_UI_FLAG_FULLSCREEN |
                                        View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
                                        View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
                                        View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
                                        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
                                        View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.INVISIBLE;
                                window.getDecorView().setSystemUiVisibility(flags);
                                window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
                                window.clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
                                SDLActivity.mFullscreenModeActive = true;
                            } else {
                                int flags = View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_VISIBLE;
                                window.getDecorView().setSystemUiVisibility(flags);
                                window.addFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
                                window.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
                                SDLActivity.mFullscreenModeActive = false;
                            }
                            if (Build.VERSION.SDK_INT >= 28 /* Android 9 (Pie) */) {
                                window.getAttributes().layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
                            }
                        }
                    } else {
                        Log.e(TAG, "error handling message, getContext() returned no Activity");
                    }
                }
                break;
            case COMMAND_TEXTEDIT_HIDE:
                if (mTextEdit != null) {
                    // Note: On some devices setting view to GONE creates a flicker in landscape.
                    // Setting the View's sizes to 0 is similar to GONE but without the flicker.
                    // The sizes will be set to useful values when the keyboard is shown again.
                    mTextEdit.setLayoutParams(new RelativeLayout.LayoutParams(0, 0));

                    InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
                    imm.hideSoftInputFromWindow(mTextEdit.getWindowToken(), 0);

                    mScreenKeyboardShown = false;

                    mSurface.requestFocus();
                }
                break;
            case COMMAND_SET_KEEP_SCREEN_ON:
            {
                if (context instanceof Activity) {
                    Window window = ((Activity) context).getWindow();
                    if (window != null) {
                        if ((msg.obj instanceof Integer) && ((Integer) msg.obj != 0)) {
                            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
                        } else {
                            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
                        }
                    }
                }
                break;
            }
            default:
                if ((context instanceof SDLActivity) && !((SDLActivity) context).onUnhandledMessage(msg.arg1, msg.obj)) {
                    Log.e(TAG, "error handling message, command is " + msg.arg1);
                }
            }
        }
    }

    // Handler for the messages
    Handler commandHandler = new SDLCommandHandler();

    // Send a message from the SDLMain thread
    boolean sendCommand(int command, Object data) {
        Message msg = commandHandler.obtainMessage();
        msg.arg1 = command;
        msg.obj = data;
        boolean result = commandHandler.sendMessage(msg);

        if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
            if (command == COMMAND_CHANGE_WINDOW_STYLE) {
                // Ensure we don't return until the resize has actually happened,
                // or 500ms have passed.

                boolean bShouldWait = false;

                if (data instanceof Integer) {
                    // Let's figure out if we're already laid out fullscreen or not.
                    Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
                    DisplayMetrics realMetrics = new DisplayMetrics();
                    display.getRealMetrics(realMetrics);

                    boolean bFullscreenLayout = ((realMetrics.widthPixels == mSurface.getWidth()) &&
                            (realMetrics.heightPixels == mSurface.getHeight()));

                    if ((Integer) data == 1) {
                        // If we aren't laid out fullscreen or actively in fullscreen mode already, we're going
                        // to change size and should wait for surfaceChanged() before we return, so the size
                        // is right back in native code.  If we're already laid out fullscreen, though, we're
                        // not going to change size even if we change decor modes, so we shouldn't wait for
                        // surfaceChanged() -- which may not even happen -- and should return immediately.
                        bShouldWait = !bFullscreenLayout;
                    } else {
                        // If we're laid out fullscreen (even if the status bar and nav bar are present),
                        // or are actively in fullscreen, we're going to change size and should wait for
                        // surfaceChanged before we return, so the size is right back in native code.
                        bShouldWait = bFullscreenLayout;
                    }
                }

                if (bShouldWait && (SDLActivity.getContext() != null)) {
                    // We'll wait for the surfaceChanged() method, which will notify us
                    // when called.  That way, we know our current size is really the
                    // size we need, instead of grabbing a size that's still got
                    // the navigation and/or status bars before they're hidden.
                    //
                    // We'll wait for up to half a second, because some devices
                    // take a surprisingly long time for the surface resize, but
                    // then we'll just give up and return.
                    //
                    synchronized (SDLActivity.getContext()) {
                        try {
                            SDLActivity.getContext().wait(500);
                        } catch (InterruptedException ie) {
                            ie.printStackTrace();
                        }
                    }
                }
            }
        }

        return result;
    }

    // C functions we call
    public static native String nativeGetVersion();
    public static native int nativeSetupJNI();
    public static native int nativeRunMain(String library, String function, Object arguments);
    public static native void nativeLowMemory();
    public static native void nativeSendQuit();
    public static native void nativeQuit();
    public static native void nativePause();
    public static native void nativeResume();
    public static native void nativeFocusChanged(boolean hasFocus);
    public static native void onNativeDropFile(String filename);
    public static native void nativeSetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, float rate);
    public static native void onNativeResize();
    public static native void onNativeKeyDown(int keycode);
    public static native void onNativeKeyUp(int keycode);
    public static native boolean onNativeSoftReturnKey();
    public static native void onNativeKeyboardFocusLost();
    public static native void onNativeMouse(int button, int action, float x, float y, boolean relative);
    public static native void onNativeTouch(int touchDevId, int pointerFingerId,
                                            int action, float x,
                                            float y, float p);
    public static native void onNativeAccel(float x, float y, float z);
    public static native void onNativeClipboardChanged();
    public static native void onNativeSurfaceCreated();
    public static native void onNativeSurfaceChanged();
    public static native void onNativeSurfaceDestroyed();
    public static native String nativeGetHint(String name);
    public static native boolean nativeGetHintBoolean(String name, boolean default_value);
    public static native void nativeSetenv(String name, String value);
    public static native void onNativeOrientationChanged(int orientation);
    public static native void nativeAddTouch(int touchId, String name);
    public static native void nativePermissionResult(int requestCode, boolean result);
    public static native void onNativeLocaleChanged();

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean setActivityTitle(String title) {
        // Called from SDLMain() thread and can't directly affect the view
        return mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void setWindowStyle(boolean fullscreen) {
        // Called from SDLMain() thread and can't directly affect the view
        mSingleton.sendCommand(COMMAND_CHANGE_WINDOW_STYLE, fullscreen ? 1 : 0);
    }

    /**
     * This method is called by SDL using JNI.
     * This is a static method for JNI convenience, it calls a non-static method
     * so that is can be overridden
     */
    public static void setOrientation(int w, int h, boolean resizable, String hint)
    {
        if (mSingleton != null) {
            mSingleton.setOrientationBis(w, h, resizable, hint);
        }
    }

    /**
     * This can be overridden
     */
    public void setOrientationBis(int w, int h, boolean resizable, String hint)
    {
        int orientation_landscape = -1;
        int orientation_portrait = -1;

        /* If set, hint "explicitly controls which UI orientations are allowed". */
        if (hint.contains("LandscapeRight") && hint.contains("LandscapeLeft")) {
            orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
        } else if (hint.contains("LandscapeLeft")) {
            orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
        } else if (hint.contains("LandscapeRight")) {
            orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
        }

        /* exact match to 'Portrait' to distinguish with PortraitUpsideDown */
        boolean contains_Portrait = hint.contains("Portrait ") || hint.endsWith("Portrait");

        if (contains_Portrait && hint.contains("PortraitUpsideDown")) {
            orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT;
        } else if (contains_Portrait) {
            orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        } else if (hint.contains("PortraitUpsideDown")) {
            orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
        }

        boolean is_landscape_allowed = (orientation_landscape != -1);
        boolean is_portrait_allowed = (orientation_portrait != -1);
        int req; /* Requested orientation */

        /* No valid hint, nothing is explicitly allowed */
        if (!is_portrait_allowed && !is_landscape_allowed) {
            if (resizable) {
                /* All orientations are allowed, respecting user orientation lock setting */
                req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
            } else {
                /* Fixed window and nothing specified. Get orientation from w/h of created window */
                req = (w > h ? ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
            }
        } else {
            /* At least one orientation is allowed */
            if (resizable) {
                if (is_portrait_allowed && is_landscape_allowed) {
                    /* hint allows both landscape and portrait, promote to full user */
                    req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
                } else {
                    /* Use the only one allowed "orientation" */
                    req = (is_landscape_allowed ? orientation_landscape : orientation_portrait);
                }
            } else {
                /* Fixed window and both orientations are allowed. Choose one. */
                if (is_portrait_allowed && is_landscape_allowed) {
                    req = (w > h ? orientation_landscape : orientation_portrait);
                } else {
                    /* Use the only one allowed "orientation" */
                    req = (is_landscape_allowed ? orientation_landscape : orientation_portrait);
                }
            }
        }

        Log.v(TAG, "setOrientation() requestedOrientation=" + req + " width=" + w +" height="+ h +" resizable=" + resizable + " hint=" + hint);
        mSingleton.setRequestedOrientation(req);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void minimizeWindow() {

        if (mSingleton == null) {
            return;
        }

        Intent startMain = new Intent(Intent.ACTION_MAIN);
        startMain.addCategory(Intent.CATEGORY_HOME);
        startMain.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        mSingleton.startActivity(startMain);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean shouldMinimizeOnFocusLoss() {
/*
        if (Build.VERSION.SDK_INT >= 24) {
            if (mSingleton == null) {
                return true;
            }

            if (mSingleton.isInMultiWindowMode()) {
                return false;
            }

            if (mSingleton.isInPictureInPictureMode()) {
                return false;
            }
        }

        return true;
*/
        return false;
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean isScreenKeyboardShown()
    {
        if (mTextEdit == null) {
            return false;
        }

        if (!mScreenKeyboardShown) {
            return false;
        }

        InputMethodManager imm = (InputMethodManager) SDL.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
        return imm.isAcceptingText();

    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean supportsRelativeMouse()
    {
        // DeX mode in Samsung Experience 9.0 and earlier doesn't support relative mice properly under
        // Android 7 APIs, and simply returns no data under Android 8 APIs.
        //
        // This is fixed in Samsung Experience 9.5, which corresponds to Android 8.1.0, and
        // thus SDK version 27.  If we are in DeX mode and not API 27 or higher, as a result,
        // we should stick to relative mode.
        //
        if (Build.VERSION.SDK_INT < 27 /* Android 8.1 (O_MR1) */ && isDeXMode()) {
            return false;
        }

        return SDLActivity.getMotionListener().supportsRelativeMouse();
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean setRelativeMouseEnabled(boolean enabled)
    {
        if (enabled && !supportsRelativeMouse()) {
            return false;
        }

        return SDLActivity.getMotionListener().setRelativeMouseEnabled(enabled);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean sendMessage(int command, int param) {
        if (mSingleton == null) {
            return false;
        }
        return mSingleton.sendCommand(command, param);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static Context getContext() {
        return SDL.getContext();
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean isAndroidTV() {
        UiModeManager uiModeManager = (UiModeManager) getContext().getSystemService(UI_MODE_SERVICE);
        if (uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_TELEVISION) {
            return true;
        }
        if (Build.MANUFACTURER.equals("MINIX") && Build.MODEL.equals("NEO-U1")) {
            return true;
        }
        if (Build.MANUFACTURER.equals("Amlogic") && Build.MODEL.equals("X96-W")) {
            return true;
        }
        return Build.MANUFACTURER.equals("Amlogic") && Build.MODEL.startsWith("TV");
    }

    public static double getDiagonal()
    {
        DisplayMetrics metrics = new DisplayMetrics();
        Activity activity = (Activity)getContext();
        if (activity == null) {
            return 0.0;
        }
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        double dWidthInches = metrics.widthPixels / (double)metrics.xdpi;
        double dHeightInches = metrics.heightPixels / (double)metrics.ydpi;

        return Math.sqrt((dWidthInches * dWidthInches) + (dHeightInches * dHeightInches));
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean isTablet() {
        // If our diagonal size is seven inches or greater, we consider ourselves a tablet.
        return (getDiagonal() >= 7.0);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean isChromebook() {
        if (getContext() == null) {
            return false;
        }
        return getContext().getPackageManager().hasSystemFeature("org.chromium.arc.device_management");
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean isDeXMode() {
        if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
            return false;
        }
        try {
            final Configuration config = getContext().getResources().getConfiguration();
            final Class<?> configClass = config.getClass();
            return configClass.getField("SEM_DESKTOP_MODE_ENABLED").getInt(configClass)
                    == configClass.getField("semDesktopModeEnabled").getInt(config);
        } catch(Exception ignored) {
            return false;
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static DisplayMetrics getDisplayDPI() {
        return getContext().getResources().getDisplayMetrics();
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean getManifestEnvironmentVariables() {
        try {
            if (getContext() == null) {
                return false;
            }

            ApplicationInfo applicationInfo = getContext().getPackageManager().getApplicationInfo(getContext().getPackageName(), PackageManager.GET_META_DATA);
            Bundle bundle = applicationInfo.metaData;
            if (bundle == null) {
                return false;
            }
            String prefix = "SDL_ENV.";
            final int trimLength = prefix.length();
            for (String key : bundle.keySet()) {
                if (key.startsWith(prefix)) {
                    String name = key.substring(trimLength);
                    String value = bundle.get(key).toString();
                    nativeSetenv(name, value);
                }
            }
            /* environment variables set! */
            return true;
        } catch (Exception e) {
           Log.v(TAG, "exception " + e.toString());
        }
        return false;
    }

    // This method is called by SDLControllerManager's API 26 Generic Motion Handler.
    public static View getContentView() {
        return mLayout;
    }

    static class ShowTextInputTask implements Runnable {
        /*
         * This is used to regulate the pan&scan method to have some offset from
         * the bottom edge of the input region and the top edge of an input
         * method (soft keyboard)
         */
        static final int HEIGHT_PADDING = 15;

        public int x, y, w, h;

        public ShowTextInputTask(int x, int y, int w, int h) {
            this.x = x;
            this.y = y;
            this.w = w;
            this.h = h;

            /* Minimum size of 1 pixel, so it takes focus. */
            if (this.w <= 0) {
                this.w = 1;
            }
            if (this.h + HEIGHT_PADDING <= 0) {
                this.h = 1 - HEIGHT_PADDING;
            }
        }

        @Override
        public void run() {
            RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(w, h + HEIGHT_PADDING);
            params.leftMargin = x;
            params.topMargin = y;

            if (mTextEdit == null) {
                mTextEdit = new DummyEdit(SDL.getContext());

                mLayout.addView(mTextEdit, params);
            } else {
                mTextEdit.setLayoutParams(params);
            }

            mTextEdit.setVisibility(View.VISIBLE);
            mTextEdit.requestFocus();

            InputMethodManager imm = (InputMethodManager) SDL.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(mTextEdit, 0);

            mScreenKeyboardShown = true;
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean showTextInput(int x, int y, int w, int h) {
        // Transfer the task to the main thread as a Runnable
        return mSingleton.commandHandler.post(new ShowTextInputTask(x, y, w, h));
    }

    public static boolean isTextInputEvent(KeyEvent event) {

        // Key pressed with Ctrl should be sent as SDL_KEYDOWN/SDL_KEYUP and not SDL_TEXTINPUT
        if (event.isCtrlPressed()) {
            return false;
        }

        return event.isPrintingKey() || event.getKeyCode() == KeyEvent.KEYCODE_SPACE;
    }

    public static boolean handleKeyEvent(View v, int keyCode, KeyEvent event, InputConnection ic) {
        int deviceId = event.getDeviceId();
        int source = event.getSource();

        if (source == InputDevice.SOURCE_UNKNOWN) {
            InputDevice device = InputDevice.getDevice(deviceId);
            if (device != null) {
                source = device.getSources();
            }
        }

//        if (event.getAction() == KeyEvent.ACTION_DOWN) {
//            Log.v("SDL", "key down: " + keyCode + ", deviceId = " + deviceId + ", source = " + source);
//        } else if (event.getAction() == KeyEvent.ACTION_UP) {
//            Log.v("SDL", "key up: " + keyCode + ", deviceId = " + deviceId + ", source = " + source);
//        }

        // Dispatch the different events depending on where they come from
        // Some SOURCE_JOYSTICK, SOURCE_DPAD or SOURCE_GAMEPAD are also SOURCE_KEYBOARD
        // So, we try to process them as JOYSTICK/DPAD/GAMEPAD events first, if that fails we try them as KEYBOARD
        //
        // Furthermore, it's possible a game controller has SOURCE_KEYBOARD and
        // SOURCE_JOYSTICK, while its key events arrive from the keyboard source
        // So, retrieve the device itself and check all of its sources
        if (SDLControllerManager.isDeviceSDLJoystick(deviceId)) {
            // Note that we process events with specific key codes here
            if (event.getAction() == KeyEvent.ACTION_DOWN) {
                if (SDLControllerManager.onNativePadDown(deviceId, keyCode) == 0) {
                    return true;
                }
            } else if (event.getAction() == KeyEvent.ACTION_UP) {
                if (SDLControllerManager.onNativePadUp(deviceId, keyCode) == 0) {
                    return true;
                }
            }
        }

        if ((source & InputDevice.SOURCE_MOUSE) == InputDevice.SOURCE_MOUSE) {
            // on some devices key events are sent for mouse BUTTON_BACK/FORWARD presses
            // they are ignored here because sending them as mouse input to SDL is messy
            if ((keyCode == KeyEvent.KEYCODE_BACK) || (keyCode == KeyEvent.KEYCODE_FORWARD)) {
                switch (event.getAction()) {
                case KeyEvent.ACTION_DOWN:
                case KeyEvent.ACTION_UP:
                    // mark the event as handled or it will be handled by system
                    // handling KEYCODE_BACK by system will call onBackPressed()
                    return true;
                }
            }
        }

        if (event.getAction() == KeyEvent.ACTION_DOWN) {
            if (isTextInputEvent(event)) {
                if (ic != null) {
                    ic.commitText(String.valueOf((char) event.getUnicodeChar()), 1);
                } else {
                    SDLInputConnection.nativeCommitText(String.valueOf((char) event.getUnicodeChar()), 1);
                }
            }
            onNativeKeyDown(keyCode);
            return true;
        } else if (event.getAction() == KeyEvent.ACTION_UP) {
            onNativeKeyUp(keyCode);
            return true;
        }

        return false;
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static Surface getNativeSurface() {
        if (SDLActivity.mSurface == null) {
            return null;
        }
        return SDLActivity.mSurface.getNativeSurface();
    }

    // Input

    /**
     * This method is called by SDL using JNI.
     */
    public static void initTouch() {
        int[] ids = InputDevice.getDeviceIds();

        for (int id : ids) {
            InputDevice device = InputDevice.getDevice(id);
            /* Allow SOURCE_TOUCHSCREEN and also Virtual InputDevices because they can send TOUCHSCREEN events */
            if (device != null && ((device.getSources() & InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN
                    || device.isVirtual())) {

                int touchDevId = device.getId();
                /*
                 * Prevent id to be -1, since it's used in SDL internal for synthetic events
                 * Appears when using Android emulator, eg:
                 *  adb shell input mouse tap 100 100
                 *  adb shell input touchscreen tap 100 100
                 */
                if (touchDevId < 0) {
                    touchDevId -= 1;
                }
                nativeAddTouch(touchDevId, device.getName());
            }
        }
    }

    // Messagebox

    /** Result of current messagebox. Also used for blocking the calling thread. */
    protected final int[] messageboxSelection = new int[1];

    /**
     * This method is called by SDL using JNI.
     * Shows the messagebox from UI thread and block calling thread.
     * buttonFlags, buttonIds and buttonTexts must have same length.
     * @param buttonFlags array containing flags for every button.
     * @param buttonIds array containing id for every button.
     * @param buttonTexts array containing text for every button.
     * @param colors null for default or array of length 5 containing colors.
     * @return button id or -1.
     */
    public int messageboxShowMessageBox(
            final int flags,
            final String title,
            final String message,
            final int[] buttonFlags,
            final int[] buttonIds,
            final String[] buttonTexts,
            final int[] colors) {

        messageboxSelection[0] = -1;

        // sanity checks

        if ((buttonFlags.length != buttonIds.length) && (buttonIds.length != buttonTexts.length)) {
            return -1; // implementation broken
        }

        // collect arguments for Dialog

        final Bundle args = new Bundle();
        args.putInt("flags", flags);
        args.putString("title", title);
        args.putString("message", message);
        args.putIntArray("buttonFlags", buttonFlags);
        args.putIntArray("buttonIds", buttonIds);
        args.putStringArray("buttonTexts", buttonTexts);
        args.putIntArray("colors", colors);

        // trigger Dialog creation on UI thread

        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                messageboxCreateAndShow(args);
            }
        });

        // block the calling thread

        synchronized (messageboxSelection) {
            try {
                messageboxSelection.wait();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
                return -1;
            }
        }

        // return selected value

        return messageboxSelection[0];
    }

    protected void messageboxCreateAndShow(Bundle args) {

        // TODO set values from "flags" to messagebox dialog

        // get colors

        int[] colors = args.getIntArray("colors");
        int backgroundColor;
        int textColor;
        int buttonBorderColor;
        int buttonBackgroundColor;
        int buttonSelectedColor;
        if (colors != null) {
            int i = -1;
            backgroundColor = colors[++i];
            textColor = colors[++i];
            buttonBorderColor = colors[++i];
            buttonBackgroundColor = colors[++i];
            buttonSelectedColor = colors[++i];
        } else {
            backgroundColor = Color.TRANSPARENT;
            textColor = Color.TRANSPARENT;
            buttonBorderColor = Color.TRANSPARENT;
            buttonBackgroundColor = Color.TRANSPARENT;
            buttonSelectedColor = Color.TRANSPARENT;
        }

        // create dialog with title and a listener to wake up calling thread

        final AlertDialog dialog = new AlertDialog.Builder(this).create();
        dialog.setTitle(args.getString("title"));
        dialog.setCancelable(false);
        dialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
            @Override
            public void onDismiss(DialogInterface unused) {
                synchronized (messageboxSelection) {
                    messageboxSelection.notify();
                }
            }
        });

        // create text

        TextView message = new TextView(this);
        message.setGravity(Gravity.CENTER);
        message.setText(args.getString("message"));
        if (textColor != Color.TRANSPARENT) {
            message.setTextColor(textColor);
        }

        // create buttons

        int[] buttonFlags = args.getIntArray("buttonFlags");
        int[] buttonIds = args.getIntArray("buttonIds");
        String[] buttonTexts = args.getStringArray("buttonTexts");

        final SparseArray<Button> mapping = new SparseArray<Button>();

        LinearLayout buttons = new LinearLayout(this);
        buttons.setOrientation(LinearLayout.HORIZONTAL);
        buttons.setGravity(Gravity.CENTER);
        for (int i = 0; i < buttonTexts.length; ++i) {
            Button button = new Button(this);
            final int id = buttonIds[i];
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    messageboxSelection[0] = id;
                    dialog.dismiss();
                }
            });
            if (buttonFlags[i] != 0) {
                // see SDL_messagebox.h
                if ((buttonFlags[i] & 0x00000001) != 0) {
                    mapping.put(KeyEvent.KEYCODE_ENTER, button);
                }
                if ((buttonFlags[i] & 0x00000002) != 0) {
                    mapping.put(KeyEvent.KEYCODE_ESCAPE, button); /* API 11 */
                }
            }
            button.setText(buttonTexts[i]);
            if (textColor != Color.TRANSPARENT) {
                button.setTextColor(textColor);
            }
            if (buttonBorderColor != Color.TRANSPARENT) {
                // TODO set color for border of messagebox button
            }
            if (buttonBackgroundColor != Color.TRANSPARENT) {
                Drawable drawable = button.getBackground();
                if (drawable == null) {
                    // setting the color this way removes the style
                    button.setBackgroundColor(buttonBackgroundColor);
                } else {
                    // setting the color this way keeps the style (gradient, padding, etc.)
                    drawable.setColorFilter(buttonBackgroundColor, PorterDuff.Mode.MULTIPLY);
                }
            }
            if (buttonSelectedColor != Color.TRANSPARENT) {
                // TODO set color for selected messagebox button
            }
            buttons.addView(button);
        }

        // create content

        LinearLayout content = new LinearLayout(this);
        content.setOrientation(LinearLayout.VERTICAL);
        content.addView(message);
        content.addView(buttons);
        if (backgroundColor != Color.TRANSPARENT) {
            content.setBackgroundColor(backgroundColor);
        }

        // add content to dialog and return

        dialog.setView(content);
        dialog.setOnKeyListener(new Dialog.OnKeyListener() {
            @Override
            public boolean onKey(DialogInterface d, int keyCode, KeyEvent event) {
                Button button = mapping.get(keyCode);
                if (button != null) {
                    if (event.getAction() == KeyEvent.ACTION_UP) {
                        button.performClick();
                    }
                    return true; // also for ignored actions
                }
                return false;
            }
        });

        dialog.show();
    }

    private final Runnable rehideSystemUi = new Runnable() {
        @Override
        public void run() {
            if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
                int flags = View.SYSTEM_UI_FLAG_FULLSCREEN |
                        View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
                        View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
                        View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
                        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
                        View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.INVISIBLE;

                SDLActivity.this.getWindow().getDecorView().setSystemUiVisibility(flags);
            }
        }
    };

    public void onSystemUiVisibilityChange(int visibility) {
        if (SDLActivity.mFullscreenModeActive && ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0 || (visibility & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0)) {

            Handler handler = getWindow().getDecorView().getHandler();
            if (handler != null) {
                handler.removeCallbacks(rehideSystemUi); // Prevent a hide loop.
                handler.postDelayed(rehideSystemUi, 2000);
            }

        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean clipboardHasText() {
        return mClipboardHandler.clipboardHasText();
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static String clipboardGetText() {
        return mClipboardHandler.clipboardGetText();
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void clipboardSetText(String string) {
        mClipboardHandler.clipboardSetText(string);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static int createCustomCursor(int[] colors, int width, int height, int hotSpotX, int hotSpotY) {
        Bitmap bitmap = Bitmap.createBitmap(colors, width, height, Bitmap.Config.ARGB_8888);
        ++mLastCursorID;

        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            try {
                mCursors.put(mLastCursorID, PointerIcon.create(bitmap, hotSpotX, hotSpotY));
            } catch (Exception e) {
                return 0;
            }
        } else {
            return 0;
        }
        return mLastCursorID;
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void destroyCustomCursor(int cursorID) {
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            try {
                mCursors.remove(cursorID);
            } catch (Exception e) {
            }
        }
        return;
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean setCustomCursor(int cursorID) {

        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            try {
                mSurface.setPointerIcon(mCursors.get(cursorID));
            } catch (Exception e) {
                return false;
            }
        } else {
            return false;
        }
        return true;
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static boolean setSystemCursor(int cursorID) {
        int cursor_type = 0; //PointerIcon.TYPE_NULL;
        switch (cursorID) {
        case SDL_SYSTEM_CURSOR_ARROW:
            cursor_type = 1000; //PointerIcon.TYPE_ARROW;
            break;
        case SDL_SYSTEM_CURSOR_IBEAM:
            cursor_type = 1008; //PointerIcon.TYPE_TEXT;
            break;
        case SDL_SYSTEM_CURSOR_WAIT:
            cursor_type = 1004; //PointerIcon.TYPE_WAIT;
            break;
        case SDL_SYSTEM_CURSOR_CROSSHAIR:
            cursor_type = 1007; //PointerIcon.TYPE_CROSSHAIR;
            break;
        case SDL_SYSTEM_CURSOR_WAITARROW:
            cursor_type = 1004; //PointerIcon.TYPE_WAIT;
            break;
        case SDL_SYSTEM_CURSOR_SIZENWSE:
            cursor_type = 1017; //PointerIcon.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW;
            break;
        case SDL_SYSTEM_CURSOR_SIZENESW:
            cursor_type = 1016; //PointerIcon.TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW;
            break;
        case SDL_SYSTEM_CURSOR_SIZEWE:
            cursor_type = 1014; //PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
            break;
        case SDL_SYSTEM_CURSOR_SIZENS:
            cursor_type = 1015; //PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
            break;
        case SDL_SYSTEM_CURSOR_SIZEALL:
            cursor_type = 1020; //PointerIcon.TYPE_GRAB;
            break;
        case SDL_SYSTEM_CURSOR_NO:
            cursor_type = 1012; //PointerIcon.TYPE_NO_DROP;
            break;
        case SDL_SYSTEM_CURSOR_HAND:
            cursor_type = 1002; //PointerIcon.TYPE_HAND;
            break;
        }
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            try {
                mSurface.setPointerIcon(PointerIcon.getSystemIcon(SDL.getContext(), cursor_type));
            } catch (Exception e) {
                return false;
            }
        }
        return true;
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void requestPermission(String permission, int requestCode) {
        if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
            nativePermissionResult(requestCode, true);
            return;
        }

        Activity activity = (Activity)getContext();
        if (activity.checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
            activity.requestPermissions(new String[]{permission}, requestCode);
        } else {
            nativePermissionResult(requestCode, true);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        boolean result = (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED);
        nativePermissionResult(requestCode, result);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static int openURL(String url)
    {
        try {
            Intent i = new Intent(Intent.ACTION_VIEW);
            i.setData(Uri.parse(url));

            int flags = Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
            if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
                flags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
            } else {
                flags |= Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET;
            }
            i.addFlags(flags);

            mSingleton.startActivity(i);
        } catch (Exception ex) {
            return -1;
        }
        return 0;
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static int showToast(String message, int duration, int gravity, int xOffset, int yOffset)
    {
        if(null == mSingleton) {
            return - 1;
        }

        try
        {
            class OneShotTask implements Runnable {
                String mMessage;
                int mDuration;
                int mGravity;
                int mXOffset;
                int mYOffset;

                OneShotTask(String message, int duration, int gravity, int xOffset, int yOffset) {
                    mMessage  = message;
                    mDuration = duration;
                    mGravity  = gravity;
                    mXOffset  = xOffset;
                    mYOffset  = yOffset;
                }

                public void run() {
                    try
                    {
                        Toast toast = Toast.makeText(mSingleton, mMessage, mDuration);
                        if (mGravity >= 0) {
                            toast.setGravity(mGravity, mXOffset, mYOffset);
                        }
                        toast.show();
                    } catch(Exception ex) {
                        Log.e(TAG, ex.getMessage());
                    }
                }
            }
            mSingleton.runOnUiThread(new OneShotTask(message, duration, gravity, xOffset, yOffset));
        } catch(Exception ex) {
            return -1;
        }
        return 0;
    }
}

/**
    Simple runnable to start the SDL application
*/
class SDLMain implements Runnable {
    @Override
    public void run() {
        // Runs SDL_main()
        String library = SDLActivity.mSingleton.getMainSharedObject();
        String function = SDLActivity.mSingleton.getMainFunction();
        String[] arguments = SDLActivity.mSingleton.getArguments();

        try {
            android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_DISPLAY);
        } catch (Exception e) {
            Log.v("SDL", "modify thread properties failed " + e.toString());
        }

        Log.v("SDL", "Running main function " + function + " from library " + library);

        SDLActivity.nativeRunMain(library, function, arguments);

        Log.v("SDL", "Finished main function");

        if (SDLActivity.mSingleton != null && !SDLActivity.mSingleton.isFinishing()) {
            // Let's finish the Activity
            SDLActivity.mSDLThread = null;
            SDLActivity.mSingleton.finish();
        }  // else: Activity is already being destroyed

    }
}

/* This is a fake invisible editor view that receives the input and defines the
 * pan&scan region
 */
class DummyEdit extends View implements View.OnKeyListener {
    InputConnection ic;

    public DummyEdit(Context context) {
        super(context);
        setFocusableInTouchMode(true);
        setFocusable(true);
        setOnKeyListener(this);
    }

    @Override
    public boolean onCheckIsTextEditor() {
        return true;
    }

    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        return SDLActivity.handleKeyEvent(v, keyCode, event, ic);
    }

    //
    @Override
    public boolean onKeyPreIme (int keyCode, KeyEvent event) {
        // As seen on StackOverflow: http://stackoverflow.com/questions/7634346/keyboard-hide-event
        // FIXME: Discussion at http://bugzilla.libsdl.org/show_bug.cgi?id=1639
        // FIXME: This is not a 100% effective solution to the problem of detecting if the keyboard is showing or not
        // FIXME: A more effective solution would be to assume our Layout to be RelativeLayout or LinearLayout
        // FIXME: And determine the keyboard presence doing this: http://stackoverflow.com/questions/2150078/how-to-check-visibility-of-software-keyboard-in-android
        // FIXME: An even more effective way would be if Android provided this out of the box, but where would the fun be in that :)
        if (event.getAction()==KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
            if (SDLActivity.mTextEdit != null && SDLActivity.mTextEdit.getVisibility() == View.VISIBLE) {
                SDLActivity.onNativeKeyboardFocusLost();
            }
        }
        return super.onKeyPreIme(keyCode, event);
    }

    @Override
    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
        ic = new SDLInputConnection(this, true);

        outAttrs.inputType = InputType.TYPE_CLASS_TEXT |
                             InputType.TYPE_TEXT_FLAG_MULTI_LINE;
        outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI |
                              EditorInfo.IME_FLAG_NO_FULLSCREEN /* API 11 */;

        return ic;
    }
}

class SDLInputConnection extends BaseInputConnection {

    protected EditText mEditText;
    protected String mCommittedText = "";

    public SDLInputConnection(View targetView, boolean fullEditor) {
        super(targetView, fullEditor);
        mEditText = new EditText(SDL.getContext());
    }

    @Override
    public Editable getEditable() {
        return mEditText.getEditableText();
    }

    @Override
    public boolean sendKeyEvent(KeyEvent event) {
        /*
         * This used to handle the keycodes from soft keyboard (and IME-translated input from hardkeyboard)
         * However, as of Ice Cream Sandwich and later, almost all soft keyboard doesn't generate key presses
         * and so we need to generate them ourselves in commitText.  To avoid duplicates on the handful of keys
         * that still do, we empty this out.
         */

        /*
         * Return DOES still generate a key event, however.  So rather than using it as the 'click a button' key
         * as we do with physical keyboards, let's just use it to hide the keyboard.
         */

        if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
            if (SDLActivity.onNativeSoftReturnKey()) {
                return true;
            }
        }

        return super.sendKeyEvent(event);
    }

    @Override
    public boolean commitText(CharSequence text, int newCursorPosition) {
        if (!super.commitText(text, newCursorPosition)) {
            return false;
        }
        updateText();
        return true;
    }

    @Override
    public boolean setComposingText(CharSequence text, int newCursorPosition) {
        if (!super.setComposingText(text, newCursorPosition)) {
            return false;
        }
        updateText();
        return true;
    }

    @Override
    public boolean deleteSurroundingText(int beforeLength, int afterLength) {
        if (Build.VERSION.SDK_INT <= 29 /* Android 10.0 (Q) */) {
            // Workaround to capture backspace key. Ref: http://stackoverflow.com/questions>/14560344/android-backspace-in-webview-baseinputconnection
            // and https://bugzilla.libsdl.org/show_bug.cgi?id=2265
            if (beforeLength > 0 && afterLength == 0) {
                // backspace(s)
                while (beforeLength-- > 0) {
                    nativeGenerateScancodeForUnichar('\b');
                }
                return true;
           }
        }

        if (!super.deleteSurroundingText(beforeLength, afterLength)) {
            return false;
        }
        updateText();
        return true;
    }

    protected void updateText() {
        final Editable content = getEditable();
        if (content == null) {
            return;
        }

        String text = content.toString();
        int compareLength = Math.min(text.length(), mCommittedText.length());
        int matchLength, offset;

        /* Backspace over characters that are no longer in the string */
        for (matchLength = 0; matchLength < compareLength; ) {
            int codePoint = mCommittedText.codePointAt(matchLength);
            if (codePoint != text.codePointAt(matchLength)) {
                break;
            }
            matchLength += Character.charCount(codePoint);
        }
        /* FIXME: This doesn't handle graphemes, like '🌬️' */
        for (offset = matchLength; offset < mCommittedText.length(); ) {
            int codePoint = mCommittedText.codePointAt(offset);
            nativeGenerateScancodeForUnichar('\b');
            offset += Character.charCount(codePoint);
        }

        if (matchLength < text.length()) {
            String pendingText = text.subSequence(matchLength, text.length()).toString();
            for (offset = 0; offset < pendingText.length(); ) {
                int codePoint = pendingText.codePointAt(offset);
                if (codePoint == '\n') {
                    if (SDLActivity.onNativeSoftReturnKey()) {
                        return;
                    }
                }
                /* Higher code points don't generate simulated scancodes */
                if (codePoint < 128) {
                    nativeGenerateScancodeForUnichar((char)codePoint);
                }
                offset += Character.charCount(codePoint);
            }
            SDLInputConnection.nativeCommitText(pendingText, 0);
        }
        mCommittedText = text;
    }

    public static native void nativeCommitText(String text, int newCursorPosition);

    public static native void nativeGenerateScancodeForUnichar(char c);
}

class SDLClipboardHandler implements
    ClipboardManager.OnPrimaryClipChangedListener {

    protected ClipboardManager mClipMgr;

    SDLClipboardHandler() {
       mClipMgr = (ClipboardManager) SDL.getContext().getSystemService(Context.CLIPBOARD_SERVICE);
       mClipMgr.addPrimaryClipChangedListener(this);
    }

    public boolean clipboardHasText() {
       return mClipMgr.hasPrimaryClip();
    }

    public String clipboardGetText() {
        ClipData clip = mClipMgr.getPrimaryClip();
        if (clip != null) {
            ClipData.Item item = clip.getItemAt(0);
            if (item != null) {
                CharSequence text = item.getText();
                if (text != null) {
                    return text.toString();
                }
            }
        }
        return null;
    }

    public void clipboardSetText(String string) {
       mClipMgr.removePrimaryClipChangedListener(this);
       ClipData clip = ClipData.newPlainText(null, string);
       mClipMgr.setPrimaryClip(clip);
       mClipMgr.addPrimaryClipChangedListener(this);
    }

    @Override
    public void onPrimaryClipChanged() {
        SDLActivity.onNativeClipboardChanged();
    }
}



================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/SDLAudioManager.java
================================================
package org.libsdl.app;

import android.content.Context;
import android.media.AudioDeviceCallback;
import android.media.AudioDeviceInfo;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.media.MediaRecorder;
import android.os.Build;
import android.util.Log;

import java.util.Arrays;

public class SDLAudioManager {
    protected static final String TAG = "SDLAudio";

    protected static AudioTrack mAudioTrack;
    protected static AudioRecord mAudioRecord;
    protected static Context mContext;

    private static final int[] NO_DEVICES = {};

    private static AudioDeviceCallback mAudioDeviceCallback;

    public static void initialize() {
        mAudioTrack = null;
        mAudioRecord = null;
        mAudioDeviceCallback = null;

        if(Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */)
        {
            mAudioDeviceCallback = new AudioDeviceCallback() {
                @Override
                public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
                    Arrays.stream(addedDevices).forEach(deviceInfo -> addAudioDevice(deviceInfo.isSink(), deviceInfo.getId()));
                }

                @Override
                public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
                    Arrays.stream(removedDevices).forEach(deviceInfo -> removeAudioDevice(deviceInfo.isSink(), deviceInfo.getId()));
                }
            };
        }
    }

    public static void setContext(Context context) {
        mContext = context;
        if (context != null) {
            registerAudioDeviceCallback();
        }
    }

    public static void release(Context context) {
        unregisterAudioDeviceCallback(context);
    }

    // Audio

    protected static String getAudioFormatString(int audioFormat) {
        switch (audioFormat) {
            case AudioFormat.ENCODING_PCM_8BIT:
                return "8-bit";
            case AudioFormat.ENCODING_PCM_16BIT:
                return "16-bit";
            case AudioFormat.ENCODING_PCM_FLOAT:
                return "float";
            default:
                return Integer.toString(audioFormat);
        }
    }

    protected static int[] open(boolean isCapture, int sampleRate, int audioFormat, int desiredChannels, int desiredFrames, int deviceId) {
        int channelConfig;
        int sampleSize;
        int frameSize;

        Log.v(TAG, "Opening " + (isCapture ? "capture" : "playback") + ", requested " + desiredFrames + " frames of " + desiredChannels + " channel " + getAudioFormatString(audioFormat) + " audio at " + sampleRate + " Hz");

        /* On older devices let's use known good settings */
        if (Build.VERSION.SDK_INT < 21 /* Android 5.0 (LOLLIPOP) */) {
            if (desiredChannels > 2) {
                desiredChannels = 2;
            }
        }

        /* AudioTrack has sample rate limitation of 48000 (fixed in 5.0.2) */
        if (Build.VERSION.SDK_INT < 22 /* Android 5.1 (LOLLIPOP_MR1) */) {
            if (sampleRate < 8000) {
                sampleRate = 8000;
            } else if (sampleRate > 48000) {
                sampleRate = 48000;
            }
        }

        if (audioFormat == AudioFormat.ENCODING_PCM_FLOAT) {
            int minSDKVersion = (isCapture ? 23 /* Android 6.0 (M) */ : 21 /* Android 5.0 (LOLLIPOP) */);
            if (Build.VERSION.SDK_INT < minSDKVersion) {
                audioFormat = AudioFormat.ENCODING_PCM_16BIT;
            }
        }
        switch (audioFormat)
        {
        case AudioFormat.ENCODING_PCM_8BIT:
            sampleSize = 1;
            break;
        case AudioFormat.ENCODING_PCM_16BIT:
            sampleSize = 2;
            break;
        case AudioFormat.ENCODING_PCM_FLOAT:
            sampleSize = 4;
            break;
        default:
            Log.v(TAG, "Requested format " + audioFormat + ", getting ENCODING_PCM_16BIT");
            audioFormat = AudioFormat.ENCODING_PCM_16BIT;
            sampleSize = 2;
            break;
        }

        if (isCapture) {
            switch (desiredChannels) {
            case 1:
                channelConfig = AudioFormat.CHANNEL_IN_MONO;
                break;
            case 2:
                channelConfig = AudioFormat.CHANNEL_IN_STEREO;
                break;
            default:
                Log.v(TAG, "Requested " + desiredChannels + " channels, getting stereo");
                desiredChannels = 2;
                channelConfig = AudioFormat.CHANNEL_IN_STEREO;
                break;
            }
        } else {
            switch (desiredChannels) {
            case 1:
                channelConfig = AudioFormat.CHANNEL_OUT_MONO;
                break;
            case 2:
                channelConfig = AudioFormat.CHANNEL_OUT_STEREO;
                break;
            case 3:
                channelConfig = AudioFormat.CHANNEL_OUT_STEREO | AudioFormat.CHANNEL_OUT_FRONT_CENTER;
                break;
            case 4:
                channelConfig = AudioFormat.CHANNEL_OUT_QUAD;
                break;
            case 5:
                channelConfig = AudioFormat.CHANNEL_OUT_QUAD | AudioFormat.CHANNEL_OUT_FRONT_CENTER;
                break;
            case 6:
                channelConfig = AudioFormat.CHANNEL_OUT_5POINT1;
                break;
            case 7:
                channelConfig = AudioFormat.CHANNEL_OUT_5POINT1 | AudioFormat.CHANNEL_OUT_BACK_CENTER;
                break;
            case 8:
                if (Build.VERSION.SDK_INT >= 23 /* Android 6.0 (M) */) {
                    channelConfig = AudioFormat.CHANNEL_OUT_7POINT1_SURROUND;
                } else {
                    Log.v(TAG, "Requested " + desiredChannels + " channels, getting 5.1 surround");
                    desiredChannels = 6;
                    channelConfig = AudioFormat.CHANNEL_OUT_5POINT1;
                }
                break;
            default:
                Log.v(TAG, "Requested " + desiredChannels + " channels, getting stereo");
                desiredChannels = 2;
                channelConfig = AudioFormat.CHANNEL_OUT_STEREO;
                break;
            }

/*
            Log.v(TAG, "Speaker configuration (and order of channels):");

            if ((channelConfig & 0x00000004) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_FRONT_LEFT");
            }
            if ((channelConfig & 0x00000008) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_FRONT_RIGHT");
            }
            if ((channelConfig & 0x00000010) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_FRONT_CENTER");
            }
            if ((channelConfig & 0x00000020) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_LOW_FREQUENCY");
            }
            if ((channelConfig & 0x00000040) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_BACK_LEFT");
            }
            if ((channelConfig & 0x00000080) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_BACK_RIGHT");
            }
            if ((channelConfig & 0x00000100) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_FRONT_LEFT_OF_CENTER");
            }
            if ((channelConfig & 0x00000200) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_FRONT_RIGHT_OF_CENTER");
            }
            if ((channelConfig & 0x00000400) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_BACK_CENTER");
            }
            if ((channelConfig & 0x00000800) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_SIDE_LEFT");
            }
            if ((channelConfig & 0x00001000) != 0) {
                Log.v(TAG, "   CHANNEL_OUT_SIDE_RIGHT");
            }
*/
        }
        frameSize = (sampleSize * desiredChannels);

        // Let the user pick a larger buffer if they really want -- but ye
        // gods they probably shouldn't, the minimums are horrifyingly high
        // latency already
        int minBufferSize;
        if (isCapture) {
            minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat);
        } else {
            minBufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat);
        }
        desiredFrames = Math.max(desiredFrames, (minBufferSize + frameSize - 1) / frameSize);

        int[] results = new int[4];

        if (isCapture) {
            if (mAudioRecord == null) {
                mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.DEFAULT, sampleRate,
                        channelConfig, audioFormat, desiredFrames * frameSize);

                // see notes about AudioTrack state in audioOpen(), above. Probably also applies here.
                if (mAudioRecord.getState() != AudioRecord.STATE_INITIALIZED) {
                    Log.e(TAG, "Failed during initialization of AudioRecord");
                    mAudioRecord.release();
                    mAudioRecord = null;
                    return null;
                }

                if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */ && deviceId != 0) {
                    mAudioRecord.setPreferredDevice(getOutputAudioDeviceInfo(deviceId));
                }

                mAudioRecord.startRecording();
            }

            results[0] = mAudioRecord.getSampleRate();
            results[1] = mAudioRecord.getAudioFormat();
            results[2] = mAudioRecord.getChannelCount();

        } else {
            if (mAudioTrack == null) {
                mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate, channelConfig, audioFormat, desiredFrames * frameSize, AudioTrack.MODE_STREAM);

                // Instantiating AudioTrack can "succeed" without an exception and the track may still be invalid
                // Ref: https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/media/java/android/media/AudioTrack.java
                // Ref: http://developer.android.com/reference/android/media/AudioTrack.html#getState()
                if (mAudioTrack.getState() != AudioTrack.STATE_INITIALIZED) {
                    /* Try again, with safer values */

                    Log.e(TAG, "Failed during initialization of Audio Track");
                    mAudioTrack.release();
                    mAudioTrack = null;
                    return null;
                }

                if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */ && deviceId != 0) {
                    mAudioTrack.setPreferredDevice(getInputAudioDeviceInfo(deviceId));
                }

                mAudioTrack.play();
            }

            results[0] = mAudioTrack.getSampleRate();
            results[1] = mAudioTrack.getAudioFormat();
            results[2] = mAudioTrack.getChannelCount();
        }
        results[3] = desiredFrames;

        Log.v(TAG, "Opening " + (isCapture ? "capture" : "playback") + ", got " + results[3] + " frames of " + results[2] + " channel " + getAudioFormatString(results[1]) + " audio at " + results[0] + " Hz");

        return results;
    }

    private static AudioDeviceInfo getInputAudioDeviceInfo(int deviceId) {
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
            return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS))
                    .filter(deviceInfo -> deviceInfo.getId() == deviceId)
                    .findFirst()
                    .orElse(null);
        } else {
            return null;
        }
    }

    private static AudioDeviceInfo getOutputAudioDeviceInfo(int deviceId) {
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
            return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS))
                    .filter(deviceInfo -> deviceInfo.getId() == deviceId)
                    .findFirst()
                    .orElse(null);
        } else {
            return null;
        }
    }

    private static void registerAudioDeviceCallback() {
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
            audioManager.registerAudioDeviceCallback(mAudioDeviceCallback, null);
        }
    }

    private static void unregisterAudioDeviceCallback(Context context) {
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
            audioManager.unregisterAudioDeviceCallback(mAudioDeviceCallback);
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static int[] getAudioOutputDevices() {
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
            return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)).mapToInt(AudioDeviceInfo::getId).toArray();
        } else {
            return NO_DEVICES;
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static int[] getAudioInputDevices() {
        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
            return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)).mapToInt(AudioDeviceInfo::getId).toArray();
        } else {
            return NO_DEVICES;
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static int[] audioOpen(int sampleRate, int audioFormat, int desiredChannels, int desiredFrames, int deviceId) {
        return open(false, sampleRate, audioFormat, desiredChannels, desiredFrames, deviceId);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void audioWriteFloatBuffer(float[] buffer) {
        if (mAudioTrack == null) {
            Log.e(TAG, "Attempted to make audio call with uninitialized audio!");
            return;
        }

        if (android.os.Build.VERSION.SDK_INT < 21 /* Android 5.0 (LOLLIPOP) */) {
            Log.e(TAG, "Attempted to make an incompatible audio call with uninitialized audio! (floating-point output is supported since Android 5.0 Lollipop)");
            return;
        }

        for (int i = 0; i < buffer.length;) {
            int result = mAudioTrack.write(buffer, i, buffer.length - i, AudioTrack.WRITE_BLOCKING);
            if (result > 0) {
                i += result;
            } else if (result == 0) {
                try {
                    Thread.sleep(1);
                } catch(InterruptedException e) {
                    // Nom nom
                }
            } else {
                Log.w(TAG, "SDL audio: error return from write(float)");
                return;
            }
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void audioWriteShortBuffer(short[] buffer) {
        if (mAudioTrack == null) {
            Log.e(TAG, "Attempted to make audio call with uninitialized audio!");
            return;
        }

        for (int i = 0; i < buffer.length;) {
            int result = mAudioTrack.write(buffer, i, buffer.length - i);
            if (result > 0) {
                i += result;
            } else if (result == 0) {
                try {
                    Thread.sleep(1);
                } catch(InterruptedException e) {
                    // Nom nom
                }
            } else {
                Log.w(TAG, "SDL audio: error return from write(short)");
                return;
            }
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void audioWriteByteBuffer(byte[] buffer) {
        if (mAudioTrack == null) {
            Log.e(TAG, "Attempted to make audio call with uninitialized audio!");
            return;
        }

        for (int i = 0; i < buffer.length; ) {
            int result = mAudioTrack.write(buffer, i, buffer.length - i);
            if (result > 0) {
                i += result;
            } else if (result == 0) {
                try {
                    Thread.sleep(1);
                } catch(InterruptedException e) {
                    // Nom nom
                }
            } else {
                Log.w(TAG, "SDL audio: error return from write(byte)");
                return;
            }
        }
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static int[] captureOpen(int sampleRate, int audioFormat, int desiredChannels, int desiredFrames, int deviceId) {
        return open(true, sampleRate, audioFormat, desiredChannels, desiredFrames, deviceId);
    }

    /** This method is called by SDL using JNI. */
    public static int captureReadFloatBuffer(float[] buffer, boolean blocking) {
        if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
            return 0;
        } else {
            return mAudioRecord.read(buffer, 0, buffer.length, blocking ? AudioRecord.READ_BLOCKING : AudioRecord.READ_NON_BLOCKING);
        }
    }

    /** This method is called by SDL using JNI. */
    public static int captureReadShortBuffer(short[] buffer, boolean blocking) {
        if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
            return mAudioRecord.read(buffer, 0, buffer.length);
        } else {
            return mAudioRecord.read(buffer, 0, buffer.length, blocking ? AudioRecord.READ_BLOCKING : AudioRecord.READ_NON_BLOCKING);
        }
    }

    /** This method is called by SDL using JNI. */
    public static int captureReadByteBuffer(byte[] buffer, boolean blocking) {
        if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
            return mAudioRecord.read(buffer, 0, buffer.length);
        } else {
            return mAudioRecord.read(buffer, 0, buffer.length, blocking ? AudioRecord.READ_BLOCKING : AudioRecord.READ_NON_BLOCKING);
        }
    }

    /** This method is called by SDL using JNI. */
    public static void audioClose() {
        if (mAudioTrack != null) {
            mAudioTrack.stop();
            mAudioTrack.release();
            mAudioTrack = null;
        }
    }

    /** This method is called by SDL using JNI. */
    public static void captureClose() {
        if (mAudioRecord != null) {
            mAudioRecord.stop();
            mAudioRecord.release();
            mAudioRecord = null;
        }
    }

    /** This method is called by SDL using JNI. */
    public static void audioSetThreadPriority(boolean iscapture, int device_id) {
        try {

            /* Set thread name */
            if (iscapture) {
                Thread.currentThread().setName("SDLAudioC" + device_id);
            } else {
                Thread.currentThread().setName("SDLAudioP" + device_id);
            }

            /* Set thread priority */
            android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_AUDIO);

        } catch (Exception e) {
            Log.v(TAG, "modify thread properties failed " + e.toString());
        }
    }

    public static native int nativeSetupJNI();

    public static native void removeAudioDevice(boolean isCapture, int deviceId);

    public static native void addAudioDevice(boolean isCapture, int deviceId);

}


================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/SDLControllerManager.java
================================================
package org.libsdl.app;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import android.content.Context;
import android.os.Build;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.util.Log;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;


public class SDLControllerManager
{

    public static native int nativeSetupJNI();

    public static native int nativeAddJoystick(int device_id, String name, String desc,
                                               int vendor_id, int product_id,
                                               boolean is_accelerometer, int button_mask,
                                               int naxes, int axis_mask, int nhats, int nballs);
    public static native int nativeRemoveJoystick(int device_id);
    public static native int nativeAddHaptic(int device_id, String name);
    public static native int nativeRemoveHaptic(int device_id);
    public static native int onNativePadDown(int device_id, int keycode);
    public static native int onNativePadUp(int device_id, int keycode);
    public static native void onNativeJoy(int device_id, int axis,
                                          float value);
    public static native void onNativeHat(int device_id, int hat_id,
                                          int x, int y);

    protected static SDLJoystickHandler mJoystickHandler;
    protected static SDLHapticHandler mHapticHandler;

    private static final String TAG = "SDLControllerManager";

    public static void initialize() {
        if (mJoystickHandler == null) {
            if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
                mJoystickHandler = new SDLJoystickHandler_API19();
            } else {
                mJoystickHandler = new SDLJoystickHandler_API16();
            }
        }

        if (mHapticHandler == null) {
            if (Build.VERSION.SDK_INT >= 26 /* Android 8.0 (O) */) {
                mHapticHandler = new SDLHapticHandler_API26();
            } else {
                mHapticHandler = new SDLHapticHandler();
            }
        }
    }

    // Joystick glue code, just a series of stubs that redirect to the SDLJoystickHandler instance
    public static boolean handleJoystickMotionEvent(MotionEvent event) {
        return mJoystickHandler.handleMotionEvent(event);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void pollInputDevices() {
        mJoystickHandler.pollInputDevices();
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void pollHapticDevices() {
        mHapticHandler.pollHapticDevices();
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void hapticRun(int device_id, float intensity, int length) {
        mHapticHandler.run(device_id, intensity, length);
    }

    /**
     * This method is called by SDL using JNI.
     */
    public static void hapticStop(int device_id)
    {
        mHapticHandler.stop(device_id);
    }

    // Check if a given device is considered a possible SDL joystick
    public static boolean isDeviceSDLJoystick(int deviceId) {
        InputDevice device = InputDevice.getDevice(deviceId);
        // We cannot use InputDevice.isVirtual before API 16, so let's accept
        // only nonnegative device ids (VIRTUAL_KEYBOARD equals -1)
        if ((device == null) || (deviceId < 0)) {
            return false;
        }
        int sources = device.getSources();

        /* This is called for every button press, so let's not spam the logs */
        /*
        if ((sources & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
            Log.v(TAG, "Input device " + device.getName() + " has class joystick.");
        }
        if ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD) {
            Log.v(TAG, "Input device " + device.getName() + " is a dpad.");
        }
        if ((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD) {
            Log.v(TAG, "Input device " + device.getName() + " is a gamepad.");
        }
        */

        return ((sources & InputDevice.SOURCE_CLASS_JOYSTICK) != 0 ||
                ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD) ||
                ((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD)
        );
    }

}

class SDLJoystickHandler {

    /**
     * Handles given MotionEvent.
     * @param event the event to be handled.
     * @return if given event was processed.
     */
    public boolean handleMotionEvent(MotionEvent event) {
        return false;
    }

    /**
     * Handles adding and removing of input devices.
     */
    public void pollInputDevices() {
    }
}

/* Actual joystick functionality available for API >= 12 devices */
class SDLJoystickHandler_API16 extends SDLJoystickHandler {

    static class SDLJoystick {
        public int device_id;
        public String name;
        public String desc;
        public ArrayList<InputDevice.MotionRange> axes;
        public ArrayList<InputDevice.MotionRange> hats;
    }
    static class RangeComparator implements Comparator<InputDevice.MotionRange> {
        @Override
        public int compare(InputDevice.MotionRange arg0, InputDevice.MotionRange arg1) {
            // Some controllers, like the Moga Pro 2, return AXIS_GAS (22) for right trigger and AXIS_BRAKE (23) for left trigger - swap them so they're sorted in the right order for SDL
            int arg0Axis = arg0.getAxis();
            int arg1Axis = arg1.getAxis();
            if (arg0Axis == MotionEvent.AXIS_GAS) {
                arg0Axis = MotionEvent.AXIS_BRAKE;
            } else if (arg0Axis == MotionEvent.AXIS_BRAKE) {
                arg0Axis = MotionEvent.AXIS_GAS;
            }
            if (arg1Axis == MotionEvent.AXIS_GAS) {
                arg1Axis = MotionEvent.AXIS_BRAKE;
            } else if (arg1Axis == MotionEvent.AXIS_BRAKE) {
                arg1Axis = MotionEvent.AXIS_GAS;
            }

            // Make sure the AXIS_Z is sorted between AXIS_RY and AXIS_RZ.
            // This is because the usual pairing are:
            // - AXIS_X + AXIS_Y (left stick).
            // - AXIS_RX, AXIS_RY (sometimes the right stick, sometimes triggers).
            // - AXIS_Z, AXIS_RZ (sometimes the right stick, sometimes triggers).
            // This sorts the axes in the above order, which tends to be correct
            // for Xbox-ish game pads that have the right stick on RX/RY and the
            // triggers on Z/RZ.
            //
            // Gamepads that don't have AXIS_Z/AXIS_RZ but use
            // AXIS_LTRIGGER/AXIS_RTRIGGER are unaffected by this.
            //
            // References:
            // - https://developer.android.com/develop/ui/views/touch-and-input/game-controllers/controller-input
            // - https://www.kernel.org/doc/html/latest/input/gamepad.html
            if (arg0Axis == MotionEvent.AXIS_Z) {
                arg0Axis = MotionEvent.AXIS_RZ - 1;
            } else if (arg0Axis > MotionEvent.AXIS_Z && arg0Axis < MotionEvent.AXIS_RZ) {
                --arg0Axis;
            }
            if (arg1Axis == MotionEvent.AXIS_Z) {
                arg1Axis = MotionEvent.AXIS_RZ - 1;
            } else if (arg1Axis > MotionEvent.AXIS_Z && arg1Axis < MotionEvent.AXIS_RZ) {
                --arg1Axis;
            }

            return arg0Axis - arg1Axis;
        }
    }

    private final ArrayList<SDLJoystick> mJoysticks;

    public SDLJoystickHandler_API16() {

        mJoysticks = new ArrayList<SDLJoystick>();
    }

    @Override
    public void pollInputDevices() {
        int[] deviceIds = InputDevice.getDeviceIds();

        for (int device_id : deviceIds) {
            if (SDLControllerManager.isDeviceSDLJoystick(device_id)) {
                SDLJoystick joystick = getJoystick(device_id);
                if (joystick == null) {
                    InputDevice joystickDevice = InputDevice.getDevice(device_id);
                    joystick = new SDLJoystick();
                    joystick.device_id = device_id;
                    joystick.name = joystickDevice.getName();
                    joystick.desc = getJoystickDescriptor(joystickDevice);
                    joystick.axes = new ArrayList<InputDevice.MotionRange>();
                    joystick.hats = new ArrayList<InputDevice.MotionRange>();

                    List<InputDevice.MotionRange> ranges = joystickDevice.getMotionRanges();
                    Collections.sort(ranges, new RangeComparator());
                    for (InputDevice.MotionRange range : ranges) {
                        if ((range.getSource() & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
                            if (range.getAxis() == MotionEvent.AXIS_HAT_X || range.getAxis() == MotionEvent.AXIS_HAT_Y) {
                                joystick.hats.add(range);
                            } else {
                                joystick.axes.add(range);
                            }
                        }
                    }

                    mJoysticks.add(joystick);
                    SDLControllerManager.nativeAddJoystick(joystick.device_id, joystick.name, joystick.desc,
                            getVendorId(joystickDevice), getProductId(joystickDevice), false,
                            getButtonMask(joystickDevice), joystick.axes.size(), getAxisMask(joystick.axes), joystick.hats.size()/2, 0);
                }
            }
        }

        /* Check removed devices */
        ArrayList<Integer> removedDevices = null;
        for (SDLJoystick joystick : mJoysticks) {
            int device_id = joystick.device_id;
            int i;
            for (i = 0; i < deviceIds.length; i++) {
                if (device_id == deviceIds[i]) break;
            }
            if (i == deviceIds.length) {
                if (removedDevices == null) {
                    removedDevices = new ArrayList<Integer>();
                }
                removedDevices.add(device_id);
            }
        }

        if (removedDevices != null) {
            for (int device_id : removedDevices) {
                SDLControllerManager.nativeRemoveJoystick(device_id);
                for (int i = 0; i < mJoysticks.size(); i++) {
                    if (mJoysticks.get(i).device_id == device_id) {
                        mJoysticks.remove(i);
                        break;
                    }
                }
            }
        }
    }

    protected SDLJoystick getJoystick(int device_id) {
        for (SDLJoystick joystick : mJoysticks) {
            if (joystick.device_id == device_id) {
                return joystick;
            }
        }
        return null;
    }

    @Override
    public boolean handleMotionEvent(MotionEvent event) {
        int actionPointerIndex = event.getActionIndex();
        int action = event.getActionMasked();
        if (action == MotionEvent.ACTION_MOVE) {
            SDLJoystick joystick = getJoystick(event.getDeviceId());
            if (joystick != null) {
                for (int i = 0; i < joystick.axes.size(); i++) {
                    InputDevice.MotionRange range = joystick.axes.get(i);
                    /* Normalize the value to -1...1 */
                    float value = (event.getAxisValue(range.getAxis(), actionPointerIndex) - range.getMin()) / range.getRange() * 2.0f - 1.0f;
                    SDLControllerManager.onNativeJoy(joystick.device_id, i, value);
                }
                for (int i = 0; i < joystick.hats.size() / 2; i++) {
                    int hatX = Math.round(event.getAxisValue(joystick.hats.get(2 * i).getAxis(), actionPointerIndex));
                    int hatY = Math.round(event.getAxisValue(joystick.hats.get(2 * i + 1).getAxis(), actionPointerIndex));
                    SDLControllerManager.onNativeHat(joystick.device_id, i, hatX, hatY);
                }
            }
        }
        return true;
    }

    public String getJoystickDescriptor(InputDevice joystickDevice) {
        String desc = joystickDevice.getDescriptor();

        if (desc != null && !desc.isEmpty()) {
            return desc;
        }

        return joystickDevice.getName();
    }
    public int getProductId(InputDevice joystickDevice) {
        return 0;
    }
    public int getVendorId(InputDevice joystickDevice) {
        return 0;
    }
    public int getAxisMask(List<InputDevice.MotionRange> ranges) {
        return -1;
    }
    public int getButtonMask(InputDevice joystickDevice) {
        return -1;
    }
}

class SDLJoystickHandler_API19 extends SDLJoystickHandler_API16 {

    @Override
    public int getProductId(InputDevice joystickDevice) {
        return joystickDevice.getProductId();
    }

    @Override
    public int getVendorId(InputDevice joystickDevice) {
        return joystickDevice.getVendorId();
    }

    @Override
    public int getAxisMask(List<InputDevice.MotionRange> ranges) {
        // For compatibility, keep computing the axis mask like before,
        // only really distinguishing 2, 4 and 6 axes.
        int axis_mask = 0;
        if (ranges.size() >= 2) {
            // ((1 << SDL_GAMEPAD_AXIS_LEFTX) | (1 << SDL_GAMEPAD_AXIS_LEFTY))
            axis_mask |= 0x0003;
        }
        if (ranges.size() >= 4) {
            // ((1 << SDL_GAMEPAD_AXIS_RIGHTX) | (1 << SDL_GAMEPAD_AXIS_RIGHTY))
            axis_mask |= 0x000c;
        }
        if (ranges.size() >= 6) {
            // ((1 << SDL_GAMEPAD_AXIS_LEFT_TRIGGER) | (1 << SDL_GAMEPAD_AXIS_RIGHT_TRIGGER))
            axis_mask |= 0x0030;
        }
        // Also add an indicator bit for whether the sorting order has changed.
        // This serves to disable outdated gamecontrollerdb.txt mappings.
        boolean have_z = false;
        boolean have_past_z_before_rz = false;
        for (InputDevice.MotionRange range : ranges) {
            int axis = range.getAxis();
            if (axis == MotionEvent.AXIS_Z) {
                have_z = true;
            } else if (axis > MotionEvent.AXIS_Z && axis < MotionEvent.AXIS_RZ) {
                have_past_z_before_rz = true;
            }
        }
        if (have_z && have_past_z_before_rz) {
            // If both these exist, the compare() function changed sorting order.
            // Set a bit to indicate this fact.
            axis_mask |= 0x8000;
        }
        return axis_mask;
    }

    @Override
    public int getButtonMask(InputDevice joystickDevice) {
        int button_mask = 0;
        int[] keys = new int[] {
            KeyEvent.KEYCODE_BUTTON_A,
            KeyEvent.KEYCODE_BUTTON_B,
            KeyEvent.KEYCODE_BUTTON_X,
            KeyEvent.KEYCODE_BUTTON_Y,
            KeyEvent.KEYCODE_BACK,
            KeyEvent.KEYCODE_MENU,
            KeyEvent.KEYCODE_BUTTON_MODE,
            KeyEvent.KEYCODE_BUTTON_START,
            KeyEvent.KEYCODE_BUTTON_THUMBL,
            KeyEvent.KEYCODE_BUTTON_THUMBR,
            KeyEvent.KEYCODE_BUTTON_L1,
            KeyEvent.KEYCODE_BUTTON_R1,
            KeyEvent.KEYCODE_DPAD_UP,
            KeyEvent.KEYCODE_DPAD_DOWN,
            KeyEvent.KEYCODE_DPAD_LEFT,
            KeyEvent.KEYCODE_DPAD_RIGHT,
            KeyEvent.KEYCODE_BUTTON_SELECT,
            KeyEvent.KEYCODE_DPAD_CENTER,

            // These don't map into any SDL controller buttons directly
            KeyEvent.KEYCODE_BUTTON_L2,
            KeyEvent.KEYCODE_BUTTON_R2,
            KeyEvent.KEYCODE_BUTTON_C,
            KeyEvent.KEYCODE_BUTTON_Z,
            KeyEvent.KEYCODE_BUTTON_1,
            KeyEvent.KEYCODE_BUTTON_2,
            KeyEvent.KEYCODE_BUTTON_3,
            KeyEvent.KEYCODE_BUTTON_4,
            KeyEvent.KEYCODE_BUTTON_5,
            KeyEvent.KEYCODE_BUTTON_6,
            KeyEvent.KEYCODE_BUTTON_7,
            KeyEvent.KEYCODE_BUTTON_8,
            KeyEvent.KEYCODE_BUTTON_9,
            KeyEvent.KEYCODE_BUTTON_10,
            KeyEvent.KEYCODE_BUTTON_11,
            KeyEvent.KEYCODE_BUTTON_12,
            KeyEvent.KEYCODE_BUTTON_13,
            KeyEvent.KEYCODE_BUTTON_14,
            KeyEvent.KEYCODE_BUTTON_15,
            KeyEvent.KEYCODE_BUTTON_16,
        };
        int[] masks = new int[] {
            (1 << 0),   // A -> A
            (1 << 1),   // B -> B
            (1 << 2),   // X -> X
            (1 << 3),   // Y -> Y
            (1 << 4),   // BACK -> BACK
            (1 << 6),   // MENU -> START
            (1 << 5),   // MODE -> GUIDE
            (1 << 6),   // START -> START
            (1 << 7),   // THUMBL -> LEFTSTICK
            (1 << 8),   // THUMBR -> RIGHTSTICK
            (1 << 9),   // L1 -> LEFTSHOULDER
            (1 << 10),  // R1 -> RIGHTSHOULDER
            (1 << 11),  // DPAD_UP -> DPAD_UP
            (1 << 12),  // DPAD_DOWN -> DPAD_DOWN
            (1 << 13),  // DPAD_LEFT -> DPAD_LEFT
            (1 << 14),  // DPAD_RIGHT -> DPAD_RIGHT
            (1 << 4),   // SELECT -> BACK
            (1 << 0),   // DPAD_CENTER -> A
            (1 << 15),  // L2 -> ??
            (1 << 16),  // R2 -> ??
            (1 << 17),  // C -> ??
            (1 << 18),  // Z -> ??
            (1 << 20),  // 1 -> ??
            (1 << 21),  // 2 -> ??
            (1 << 22),  // 3 -> ??
            (1 << 23),  // 4 -> ??
            (1 << 24),  // 5 -> ??
            (1 << 25),  // 6 -> ??
            (1 << 26),  // 7 -> ??
            (1 << 27),  // 8 -> ??
            (1 << 28),  // 9 -> ??
            (1 << 29),  // 10 -> ??
            (1 << 30),  // 11 -> ??
            (1 << 31),  // 12 -> ??
            // We're out of room...
            0xFFFFFFFF,  // 13 -> ??
            0xFFFFFFFF,  // 14 -> ??
            0xFFFFFFFF,  // 15 -> ??
            0xFFFFFFFF,  // 16 -> ??
        };
        boolean[] has_keys = joystickDevice.hasKeys(keys);
        for (int i = 0; i < keys.length; ++i) {
            if (has_keys[i]) {
                button_mask |= masks[i];
            }
        }
        return button_mask;
    }
}

class SDLHapticHandler_API26 extends SDLHapticHandler {
    @Override
    public void run(int device_id, float intensity, int length) {
        SDLHaptic haptic = getHaptic(device_id);
        if (haptic != null) {
            Log.d("SDL", "Rtest: Vibe with intensity " + intensity + " for " + length);
            if (intensity == 0.0f) {
                stop(device_id);
                return;
            }

            int vibeValue = Math.round(intensity * 255);

            if (vibeValue > 255) {
                vibeValue = 255;
            }
            if (vibeValue < 1) {
                stop(device_id);
                return;
            }
            try {
                haptic.vib.vibrate(VibrationEffect.createOneShot(length, vibeValue));
            }
            catch (Exception e) {
                // Fall back to the generic method, which uses DEFAULT_AMPLITUDE, but works even if
                // something went horribly wrong with the Android 8.0 APIs.
                haptic.vib.vibrate(length);
            }
        }
    }
}

class SDLHapticHandler {

    static class SDLHaptic {
        public int device_id;
        public String name;
        public Vibrator vib;
    }

    private final ArrayList<SDLHaptic> mHaptics;

    public SDLHapticHandler() {
        mHaptics = new ArrayList<SDLHaptic>();
    }

    public void run(int device_id, float intensity, int length) {
        SDLHaptic haptic = getHaptic(device_id);
        if (haptic != null) {
            haptic.vib.vibrate(length);
        }
    }

    public void stop(int device_id) {
        SDLHaptic haptic = getHaptic(device_id);
        if (haptic != null) {
            haptic.vib.cancel();
        }
    }

    public void pollHapticDevices() {

        final int deviceId_VIBRATOR_SERVICE = 999999;
        boolean hasVibratorService = false;

        int[] deviceIds = InputDevice.getDeviceIds();
        // It helps processing the device ids in reverse order
        // For example, in the case of the XBox 360 wireless dongle,
        // so the first controller seen by SDL matches what the receiver
        // considers to be the first controller

        for (int i = deviceIds.length - 1; i > -1; i--) {
            SDLHaptic haptic = getHaptic(deviceIds[i]);
            if (haptic == null) {
                InputDevice device = InputDevice.getDevice(deviceIds[i]);
                Vibrator vib = device.getVibrator();
                if (vib != null) {
                    if (vib.hasVibrator()) {
                        haptic = new SDLHaptic();
                        haptic.device_id = deviceIds[i];
                        haptic.name = device.getName();
                        haptic.vib = vib;
                        mHaptics.add(haptic);
                        SDLControllerManager.nativeAddHaptic(haptic.device_id, haptic.name);
                    }
                }
            }
        }

        /* Check VIBRATOR_SERVICE */
        Vibrator vib = (Vibrator) SDL.getContext().getSystemService(Context.VIBRATOR_SERVICE);
        if (vib != null) {
            hasVibratorService = vib.hasVibrator();

            if (hasVibratorService) {
                SDLHaptic haptic = getHaptic(deviceId_VIBRATOR_SERVICE);
                if (haptic == null) {
                    haptic = new SDLHaptic();
                    haptic.device_id = deviceId_VIBRATOR_SERVICE;
                    haptic.name = "VIBRATOR_SERVICE";
                    haptic.vib = vib;
                    mHaptics.add(haptic);
                    SDLControllerManager.nativeAddHaptic(haptic.device_id, haptic.name);
                }
            }
        }

        /* Check removed devices */
        ArrayList<Integer> removedDevices = null;
        for (SDLHaptic haptic : mHaptics) {
            int device_id = haptic.device_id;
            int i;
            for (i = 0; i < deviceIds.length; i++) {
                if (device_id == deviceIds[i]) break;
            }

            if (device_id != deviceId_VIBRATOR_SERVICE || !hasVibratorService) {
                if (i == deviceIds.length) {
                    if (removedDevices == null) {
                        removedDevices = new ArrayList<Integer>();
                    }
                    removedDevices.add(device_id);
                }
            }  // else: don't remove the vibrator if it is still present
        }

        if (removedDevices != null) {
            for (int device_id : removedDevices) {
                SDLControllerManager.nativeRemoveHaptic(device_id);
                for (int i = 0; i < mHaptics.size(); i++) {
                    if (mHaptics.get(i).device_id == device_id) {
                        mHaptics.remove(i);
                        break;
                    }
                }
            }
        }
    }

    protected SDLHaptic getHaptic(int device_id) {
        for (SDLHaptic haptic : mHaptics) {
            if (haptic.device_id == device_id) {
                return haptic;
            }
        }
        return null;
    }
}

class SDLGenericMotionListener_API12 implements View.OnGenericMotionListener {
    // Generic Motion (mouse hover, joystick...) events go here
    @Override
    public boolean onGenericMotion(View v, MotionEvent event) {
        float x, y;
        int action;

        switch ( event.getSource() ) {
            case InputDevice.SOURCE_JOYSTICK:
                return SDLControllerManager.handleJoystickMotionEvent(event);

            case InputDevice.SOURCE_MOUSE:
                action = event.getActionMasked();
                switch (action) {
                    case MotionEvent.ACTION_SCROLL:
                        x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
                        y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
                        SDLActivity.onNativeMouse(0, action, x, y, false);
                        return true;

                    case MotionEvent.ACTION_HOVER_MOVE:
                        x = event.getX(0);
                        y = event.getY(0);

                        SDLActivity.onNativeMouse(0, action, x, y, false);
                        return true;

                    default:
                        break;
                }
                break;

            default:
                break;
        }

        // Event was not managed
        return false;
    }

    public boolean supportsRelativeMouse() {
        return false;
    }

    public boolean inRelativeMode() {
        return false;
    }

    public boolean setRelativeMouseEnabled(boolean enabled) {
        return false;
    }

    public void reclaimRelativeMouseModeIfNeeded()
    {

    }

    public float getEventX(MotionEvent event) {
        return event.getX(0);
    }

    public float getEventY(MotionEvent event) {
        return event.getY(0);
    }

}

class SDLGenericMotionListener_API24 extends SDLGenericMotionListener_API12 {
    // Generic Motion (mouse hover, joystick...) events go here

    private boolean mRelativeModeEnabled;

    @Override
    public boolean onGenericMotion(View v, MotionEvent event) {

        // Handle relative mouse mode
        if (mRelativeModeEnabled) {
            if (event.getSource() == InputDevice.SOURCE_MOUSE) {
                int action = event.getActionMasked();
                if (action == MotionEvent.ACTION_HOVER_MOVE) {
                    float x = event.getAxisValue(MotionEvent.AXIS_RELATIVE_X);
                    float y = event.getAxisValue(MotionEvent.AXIS_RELATIVE_Y);
                    SDLActivity.onNativeMouse(0, action, x, y, true);
                    return true;
                }
            }
        }

        // Event was not managed, call SDLGenericMotionListener_API12 method
        return super.onGenericMotion(v, event);
    }

    @Override
    public boolean supportsRelativeMouse() {
        return true;
    }

    @Override
    public boolean inRelativeMode() {
        return mRelativeModeEnabled;
    }

    @Override
    public boolean setRelativeMouseEnabled(boolean enabled) {
        mRelativeModeEnabled = enabled;
        return true;
    }

    @Override
    public float getEventX(MotionEvent event) {
        if (mRelativeModeEnabled) {
            return event.getAxisValue(MotionEvent.AXIS_RELATIVE_X);
        } else {
            return event.getX(0);
        }
    }

    @Override
    public float getEventY(MotionEvent event) {
        if (mRelativeModeEnabled) {
            return event.getAxisValue(MotionEvent.AXIS_RELATIVE_Y);
        } else {
            return event.getY(0);
        }
    }
}

class SDLGenericMotionListener_API26 extends SDLGenericMotionListener_API24 {
    // Generic Motion (mouse hover, joystick...) events go here
    private boolean mRelativeModeEnabled;

    @Override
    public boolean onGenericMotion(View v, MotionEvent event) {
        float x, y;
        int action;

        switch ( event.getSource() ) {
            case InputDevice.SOURCE_JOYSTICK:
                return SDLControllerManager.handleJoystickMotionEvent(event);

            case InputDevice.SOURCE_MOUSE:
            // DeX desktop mouse cursor is a separate non-standard input type.
            case InputDevice.SOURCE_MOUSE | InputDevice.SOURCE_TOUCHSCREEN:
                action = event.getActionMasked();
                switch (action) {
                    case MotionEvent.ACTION_SCROLL:
                        x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
                        y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
                        SDLActivity.onNativeMouse(0, action, x, y, false);
                        return true;

                    case MotionEvent.ACTION_HOVER_MOVE:
                        x = event.getX(0);
                        y = event.getY(0);
                        SDLActivity.onNativeMouse(0, action, x, y, false);
                        return true;

                    default:
                        break;
                }
                break;

            case InputDevice.SOURCE_MOUSE_RELATIVE:
                action = event.getActionMasked();
                switch (action) {
                    case MotionEvent.ACTION_SCROLL:
                        x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
                        y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
                        SDLActivity.onNativeMouse(0, action, x, y, false);
                        return true;

                    case MotionEvent.ACTION_HOVER_MOVE:
                        x = event.getX(0);
                        y = event.getY(0);
                        SDLActivity.onNativeMouse(0, action, x, y, true);
                        return true;

                    default:
                        break;
                }
                break;

            default:
                break;
        }

        // Event was not managed
        return false;
    }

    @Override
    public boolean supportsRelativeMouse() {
        return (!SDLActivity.isDeXMode() || Build.VERSION.SDK_INT >= 27 /* Android 8.1 (O_MR1) */);
    }

    @Override
    public boolean inRelativeMode() {
        return mRelativeModeEnabled;
    }

    @Override
    public boolean setRelativeMouseEnabled(boolean enabled) {
        if (!SDLActivity.isDeXMode() || Build.VERSION.SDK_INT >= 27 /* Android 8.1 (O_MR1) */) {
            if (enabled) {
                SDLActivity.getContentView().requestPointerCapture();
            } else {
                SDLActivity.getContentView().releasePointerCapture();
            }
            mRelativeModeEnabled = enabled;
            return true;
        } else {
            return false;
        }
    }

    @Override
    public void reclaimRelativeMouseModeIfNeeded()
    {
        if (mRelativeModeEnabled && !SDLActivity.isDeXMode()) {
            SDLActivity.getContentView().requestPointerCapture();
        }
    }

    @Override
    public float getEventX(MotionEvent event) {
        // Relative mouse in capture mode will only have relative for X/Y
        return event.getX(0);
    }

    @Override
    public float getEventY(MotionEvent event) {
        // Relative mouse in capture mode will only have relative for X/Y
        return event.getY(0);
    }
}


================================================
FILE: android-project/thextech/src/main/java/org/libsdl/app/SDLSurface.java
================================================
package org.libsdl.app;


import android.content.Context;
import android.content.pm.ActivityInfo;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Build;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.WindowManager;


/**
    SDLSurface. This is what we draw on, so we need to know when it's created
    in order to do anything useful.

    Because of this, that's where we set up the SDL thread
*/
public class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
    View.OnKeyListener, View.OnTouchListener, SensorEventListener  {

    // Sensors
    protected SensorManager mSensorManager;
    protected Display mDisplay;

    // Keep track of the surface size to normalize touch events
    protected float mWidth, mHeight;

    // Is SurfaceView ready for rendering
    public boolean mIsSurfaceReady;

    // Startup
    public SDLSurface(Context context) {
        super(context);
        getHolder().addCallback(this);

        setFocusable(true);
        setFocusableInTouchMode(true);
        requestFocus();
        setOnKeyListener(this);
        setOnTouchListener(this);

        mDisplay = ((WindowManager)context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);

        setOnGenericMotionListener(SDLActivity.getMotionListener());

        // Some arbitrary defaults to avoid a potential division by zero
        mWidth = 1.0f;
        mHeight = 1.0f;

        mIsSurfaceReady = false;
    }

    public void handlePause() {
        enableSensor(Sensor.TYPE_ACCELEROMETER, false);
    }

    public void handleResume() {
        setFocusable(true);
        setFocusableInTouchMode(true);
        requestFocus();
        setOnKeyListener(this);
        setOnTouchListener(this);
        enableSensor(Sensor.TYPE_ACCELEROMETER, true);
    }

    public Surface getNativeSurface() {
        return getHolder().getSurface();
    }

    // Called when we have a valid drawing surface
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        Log.v("SDL", "surfaceCreated()");
        SDLActivity.onNativeSurfaceCreated();
    }

    // Called when we lose the surface
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        Log.v("SDL", "surfaceDestroyed()");

        // Transition to pause, if needed
        SDLActivity.mNextNativeState = SDLActivity.NativeState.PAUSED;
        SDLActivity.handleNativeState();

        mIsSurfaceReady = false;
        SDLActivity.onNativeSurfaceDestroyed();
    }

    // Called when the surface is resized
    @Override
    public void surfaceChanged(SurfaceHolder holder,
                               int format, int width, int height) {
        Log.v("SDL", "surfaceChanged()");

        if (SDLActivity.mSingleton == null) {
            return;
        }

        mWidth = width;
        mHeight = height;
        int nDeviceWidth = width;
        int nDeviceHeight = height;
        try
        {
            if (Build.VERSION.SDK_INT >= 17 /* Android 4.2 (JELLY_BEAN_MR1) */) {
                DisplayMetrics realMetrics = new DisplayMetrics();
                mDisplay.getRealMetrics( realMetrics );
                nDeviceWidth = realMetrics.widthPixels;
                nDeviceHeight = realMetrics.heightPixels;
            }
        } catch(Exception ignored) {
        }

        synchronized(SDLActivity.getContext()) {
            // In case we're waiting on a size change after going fullscreen, send a notification.
            SDLActivity.getContext().notifyAll();
        }

        Log.v("SDL", "Window size: " + width + "x" + height);
        Log.v("SDL", "Device size: " + nDeviceWidth + "x" + nDeviceHeight);
        SDLActivity.nativeSetScreenResolution(width, height, nDeviceWidth, nDeviceHeight, mDisplay.getRefreshRate());
        SDLActivity.onNativeResize();

        // Prevent a screen distortion glitch,
        // for instance when the device is in Landscape and a Portrait App is resumed.
        boolean skip = false;
        int requestedOrientation = SDLActivity.mSingleton.getRequestedOrientation();

        if (requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT || requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT) {
            if (mWidth > mHeight) {
               skip = true;
            }
        } else if (requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE || requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) {
            if (mWidth < mHeight) {
               skip = true;
            }
        }

        // Special Patch for Square Resolution: Black Berry Passport
        if (skip) {
           double min = Math.min(mWidth, mHeight);
           double max = Math.max(mWidth, mHeight);

           if (max / min < 1.20) {
              Log.v("SDL", "Don't skip on such aspect-ratio. Could be a square resolution.");
              skip = false;
           }
        }

        // Don't skip in MultiWindow.
        if (skip) {
            if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
                if (SDLActivity.mSingleton.isInMultiWindowMode()) {
                    Log.v("SDL", "Don't skip in Multi-Window");
                    skip = false;
                }
            }
        }

        if (skip) {
           Log.v("SDL", "Skip .. Surface is not ready.");
           mIsSurfaceReady = false;
           return;
        }

        /* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */
        SDLActivity.onNativeSurfaceChanged();

        /* Surface is ready */
        mIsSurfaceReady = true;

        SDLActivity.mNextNativeState = SDLActivity.NativeState.RESUMED;
        SDLActivity.handleNativeState();
    }

    // Key events
    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        return SDLActivity.handleKeyEvent(v, keyCode, event, null);
    }

    // Touch events
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        /* Ref: http://developer.android.com/training/gestures/multi.html */
        int touchDevId = event.getDeviceId();
        final int pointerCount = event.getPointerCount();
        int action = event.getActionMasked();
        int pointerFingerId;
        int i = -1;
        float x,y,p;

        /*
         * Prevent id to be -1, since it's used in SDL internal for synthetic events
         * Appears when using Android emulator, eg:
         *  adb shell input mouse tap 100 100
         *  adb shell input touchscreen tap 100 100
         */
        if (touchDevId < 0) {
            touchDevId -= 1;
        }

        // 12290 = Samsung DeX mode desktop mouse
        // 12290 = 0x3002 = 0x2002 | 0x1002 = SOURCE_MOUSE | SOURCE_TOUCHSCREEN
        // 0x2   = SOURCE_CLASS_POINTER
        if (event.getSource() == InputDevice.SOURCE_MOUSE || event.getSource() == (InputDevice.SOURCE_MOUSE | InputDevice.SOURCE_TOUCHSCREEN)) {
            int mouseButton = 1;
            try {
                Object object = event.getClass().getMethod("getButtonState").invoke(event);
                if (object != null) {
                    mouseButton = (Integer) object;
                }
            } catch(Exception ignored) {
            }

            // We need to check if we're in relative mouse mode and get the axis offset rather than the x/y values
            // if we are.  We'll leverage our existing mouse motion listener
            SDLGenericMotionListener_API12 motionListener = SDLActivity.getMotionListener();
            x = motionListener.getEventX(event);
            y = motionListener.getEventY(event);

            SDLActivity.onNativeMouse(mouseButton, action, x, y, motionListener.inRelativeMode());
        } else {
            switch(action) {
                case MotionEvent.ACTION_MOVE:
                    for (i = 0; i < pointerCount; i++) {
                        pointerFingerId = event.getPointerId(i);
                        x = event.getX(i) / mWidth;
                        y = event.getY(i) / mHeight;
                        p = event.getPressure(i);
                        if (p > 1.0f) {
                            // may be larger than 1.0f on some devices
                            // see the documentation of getPressure(i)
                            p = 1.0f;
                        }
                        SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
                    }
                    break;

                case MotionEvent.ACTION_UP:
                case MotionEvent.ACTION_DOWN:
                    // Primary pointer up/down, the index is always zero
                    i = 0;
                    /* fallthrough */
                case MotionEvent.ACTION_POINTER_UP:
                case MotionEvent.ACTION_POINTER_DOWN:
                    // Non primary pointer up/down
                    if (i == -1) {
                        i = event.getActionIndex();
                    }

                    pointerFingerId = event.getPointerId(i);
                    x = event.getX(i) / mWidth;
                    y = event.getY(i) / mHeight;
                    p = event.getPressure(i);
                    if (p > 1.0f) {
                        // may be larger than 1.0f on some devices
                        // see the documentation of getPressure(i)
                        p = 1.0f;
                    }
                    SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
                    break;

                case MotionEvent.ACTION_CANCEL:
                    for (i = 0; i < pointerCount; i++) {
                        pointerFingerId = event.getPointerId(i);
                        x = event.getX(i) / mWidth;
                        y = event.getY(i) / mHeight;
                        p = event.getPressure(i);
                        if (p > 1.0f) {
                            // may be larger than 1.0f on some devices
                            // see the documentation of getPressure(i)
                            p = 1.0f;
                        }
                        SDLActivity.onNativeTouch(touchDevId, pointerFingerId, MotionEvent.ACTION_UP, x, y, p);
                    }
                    break;

                default:
                    break;
            }
        }

        return true;
   }

    // Sensor events
    public void enableSensor(int sensortype, boolean enabled) {
        // TODO: This uses getDefaultSensor - what if we have >1 accels?
        if (enabled) {
            mSensorManager.registerListener(this,
                            mSensorManager.getDefaultSensor(sensortype),
                            SensorManager.SENSOR_DELAY_GAME, null);
        } else {
            mSensorManager.unregisterListener(this,
                            mSensorManager.getDefaultSensor(sensortype));
        }
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // TODO
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {

            // Since we may have an orientation set, we won't receive onConfigurationChanged events.
            // We thus should check here.
            int newOrientation;

            float x, y;
            switch (mDisplay.getRotation()) {
                case Surface.ROTATION_90:
                    x = -event.values[1];
                    y = event.values[0];
                    newOrientation = SDLActivity.SDL_ORIENTATION_LANDSCAPE;
                    break;
                case Surface.ROTATION_270:
                    x = event.values[1];
                    y = -event.values[0];
                    newOrientation = SDLActivity.SDL_ORIENTATION_LANDSCAPE_FLIPPED;
                    break;
                case Surface.ROTATION_180:
                    x = -event.values[0];
                    y = -event.values[1];
                    newOrientation = SDLActivity.SDL_ORIENTATION_PORTRAIT_FLIPPED;
                    break;
                case Surface.ROTATION_0:
                default:
                    x = event.values[0];
                    y = event.values[1];
                    newOrientation = SDLActivity.SDL_ORIENTATION_PORTRAIT;
                    break;
            }

            if (newOrientation != SDLActivity.mCurrentOrientation) {
                SDLActivity.mCurrentOrientation = newOrientation;
                SDLActivity.onNativeOrientationChanged(newOrientation);
            }

            SDLActivity.onNativeAccel(-x / SensorManager.GRAVITY_EARTH,
                                      y / SensorManager.GRAVITY_EARTH,
                                      event.values[2] / SensorManager.GRAVITY_EARTH);


        }
    }

    // Captured pointer events for API 26.
    public boolean onCapturedPointerEvent(MotionEvent event)
    {
        int action = event.getActionMasked();

        float x, y;
        switch (action) {
            case MotionEvent.ACTION_SCROLL:
                x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
                y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
                SDLActivity.onNativeMouse(0, action, x, y, false);
                return true;

            case MotionEvent.ACTION_HOVER_MOVE:
            case MotionEvent.ACTION_MOVE:
                x = event.getX(0);
                y = event.getY(0);
                SDLActivity.onNativeMouse(0, action, x, y, true);
                return true;

            case MotionEvent.ACTION_BUTTON_PRESS:
            case MotionEvent.ACTION_BUTTON_RELEASE:

                // Change our action value to what SDL's code expects.
                if (action == MotionEvent.ACTION_BUTTON_PRESS) {
                    action = MotionEvent.ACTION_DOWN;
                } else { /* MotionEvent.ACTION_BUTTON_RELEASE */
                    action = MotionEvent.ACTION_UP;
                }

                x = event.getX(0);
                y = event.getY(0);
                int button = event.getButtonState();

                SDLActivity.onNativeMouse(button, action, x, y, true);
                return true;
        }

        return false;
    }
}


================================================
FILE: android-project/thextech/src/main/java/ru/wohlsoft/thextech/GameSettings.java
================================================
package ru.wohlsoft.thextech;

import android.content.Context;
import android.content.SharedPreferences;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.util.Pair;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

import androidx.appcompat.app.ActionBar;
import androidx.appcompat.app.AppCompatActivity;
import androidx.preference.Preference;
import androidx.preference.PreferenceFragmentCompat;
import androidx.preference.PreferenceManager;

public class GameSettings extends AppCompatActivity
{
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.settings_activity);
        if (savedInstanceState == null)
        {
            getSupportFragmentManager()
                    .beginTransaction()
                    .replace(R.id.settings, new SettingsFragment())
                    .commit();
        }

        ActionBar actionBar = getSupportActionBar();
        if (actionBar != null)
            actionBar.setDisplayHomeAsUpEnabled(true);
    }

    public static class SettingsFragment extends PreferenceFragmentCompat
    {
        @Override
        public void onCreatePreferences(Bundle savedInstanceState, String rootKey)
        {
            setPreferencesFromResource(R.xml.root_preferences, rootKey);

            Preference button = getPreferenceManager().findPreference("setup_assets_path");
            if (button != null)
            {
                button.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener()
                {
                    @Override
                    public boolean onPreferenceClick(Preference arg0)
                    {
                        Context ctx = getContext();
                        if(ctx == null)
                            return false;// Null context, not allowed!
                        return selectAssetsPath(ctx, null);
                    }
                });
            }
        }
    }

    private static final String m_defaultAssetsDir = Environment.getExternalStorageDirectory().getAbsolutePath() + "/PGE Project/thextech";

    public static boolean isDirectoryExist(String dir)
    {
        File file = new File(dir);
        return file.exists() && file.isDirectory();
    }

    public static boolean isFileExist(String f)
    {
        File file = new File(f);
        return file.exists() && file.isFile();
    }

    public static boolean verifyAssetsPath(String path)
    {
        if(path.isEmpty())
            path = GameSettings.m_defaultAssetsDir;

        if(!isDirectoryExist(path))
            return false;

        if(!isDirectoryExist(path + "/graphics"))
            return false;

        if(!isDirectoryExist(path + "/sound"))
            return false;

        if(!isDirectoryExist(path + "/music"))
            return false;

        if(!isFileExist(path + "/intro.lvlx") &&
           !isFileExist(path + "/intro.lvl") &&
           !isDirectoryExist(path + "/introset"))
            return false;

        return true;
    }

    public static JSONArray sortAssetsList(JSONArray inArr)
    {
        try
        {
            ArrayList<JSONObject> array = new ArrayList<JSONObject>();

            for(int i = 0; i < inArr.length(); i++)
                array.add(inArr.getJSONObject(i));

            Collections.sort(array, new Comparator<JSONObject>()
            {
                @Override
                public int compare(JSONObject lhs, JSONObject rhs)
                {
                    try
                    {
                        return (lhs.getString("game").toLowerCase().compareTo(rhs.getString("game").toLowerCase()));
                    }
                    catch (JSONException e)
                    {
                        e.printStackTrace();
                        return 0;
                    }
                }
            });

            JSONArray outArray = new JSONArray();

            for(int i = 0; i < array.size(); i++)
                outArray.put(array.get(i));

            return outArray;
        }
        catch (JSONException e)
        {
            e.printStackTrace();
            return inArr;
        }
    }

    public static boolean selectAssetsPath(Context ctx, final Launcher l)
    {
        if(ctx == null)
            return false;// Null context, not allowed!

        SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(ctx);
        String gameAssetsPath = setup.getString("setup_assets_path", "");
        if(gameAssetsPath.isEmpty())
            gameAssetsPath = GameSettings.m_defaultAssetsDir;

        File file = new File(gameAssetsPath);
        if(!file.exists() || !file.isDirectory())
        {
            gameAssetsPath = Environment.getExternalStorageDirectory().getAbsolutePath();
        }

        OpenFileDialog fileDialog = new OpenFileDialog(ctx)
                .setDirectoryMode()
                .setFilter("gameinfo\\.ini")
                .setCurrentDirectory(gameAssetsPath)
                .setOpenDialogListener(new OpenFileDialog.OpenDialogListener()
                {
                    @Override
                    public void OnSelectedDirectory(Context ctx, String lastPath)
                    {
                        SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(ctx);
                        setup.edit().putString("setup_assets_path", lastPath).apply();
                        if(l != null)
                            l.updateOverlook();

                        // Update list of assets (if needed)
                        String gameName = "<untitled game>";
                        String giPath = lastPath + "/gameinfo.ini";

                        boolean hasGameInfo = !lastPath.isEmpty() && GameSettings.isFileExist(giPath);
                        if(hasGameInfo)
                        {
                            IniFile gi = new IniFile(giPath);
                            gameName = gi.getString("game", "title", gameName);
                        }

                        // Add assets if missing
                        String gameAssetsPath = setup.getString("setup_assets_list", "");
                        try
                        {
                            boolean updateNeeded = false;
                            if(gameAssetsPath.isEmpty()) // Create new list
                            {
                                JSONObject jObject = new JSONObject();
                                JSONArray jArray = new JSONArray();
                                JSONObject oneObject = new JSONObject();
                                oneObject.put("game", gameName);
                                oneObject.put("path", lastPath);
                                jArray.put(oneObject);
                                jObject.put("assets", jArray);
                                setup.edit().putString("setup_assets_list", jObject.toString()).apply();
                                updateNeeded = true;
                            }
                            else // Append if not exists
                            {
                                JSONObject jObject = new JSONObject(gameAssetsPath);
                                JSONArray jArray = jObject.getJSONArray("assets");
                                updateNeeded = true;

                                for(int i = 0; i < jArray.length(); i++)
                                {
                                    JSONObject oneObject = jArray.getJSONObject(i);
                                    String tPath = oneObject.getString("path");
                                    if(tPath.equals(lastPath))
                                    {
                                        updateNeeded = false;
                                        break;
                                    }
                                }

                                if(updateNeeded) // Append missing item
                                {
                                    JSONObject oneObject = new JSONObject();
                                    oneObject.put("game", gameName);
                                    oneObject.put("path", lastPath);
                                    jArray.put(oneObject);
                                    jObject.put("assets", sortAssetsList(jArray));
                                    setup.edit().putString("setup_assets_list", jObject.toString()).apply();
                                }
                            }

                            if(updateNeeded && l != null)
                                l.reloadAssetsList();
                        }
                        catch (JSONException e)
                        {
                            e.printStackTrace();
                        }
                    }
                    @Override
                    public void OnSelectedFile(Context ctx, String fileName, String lastPath){}
                });
        fileDialog.show();
        return true;
    }
}


================================================
FILE: android-project/thextech/src/main/java/ru/wohlsoft/thextech/IniFile.java
================================================
package ru.wohlsoft.thextech;

/*
    Code made by Aerospace and published at the StackOverflow https://stackoverflow.com/a/15638381
    CC BY-SA 3.0
 */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IniFile
{
    private final Pattern _section = Pattern.compile("\\s*\\[([^]]*)\\]\\s*");
    private final Pattern _keyValue = Pattern.compile("\\s*([^=]*)=(.*)");
    private final Map<String, Map<String, String>> _entries = new HashMap<>();

    public IniFile(String path)
    {
        load(path);
    }

    public void load(String path)
    {
        try
        {
            BufferedReader br = new BufferedReader(new FileReader(path));
            String line;
            String section = null;

            while((line = br.readLine()) != null)
            {
                Matcher m = _section.matcher(line);

                if(m.matches())
                {
                    section = m.group(1);
                    if(section != null)
                        section = section.trim();
                }
                else if(section != null)
                {
                    m = _keyValue.matcher(line);
                    if(m.matches())
                        insertValue(section, m);
                }
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    private void insertValue(String section, Matcher m)
    {
        String key = m.group(1);
        String value = m.group(2);

        if(key == null || value == null)
            return;

        key = key.trim();
        value = value.trim();

        boolean quoteOpen = false;
        for(int i = 0; i < value.length(); ++i)
        {
            char c = value.charAt(i);
            if(!quoteOpen && c == '"')
            {
                quoteOpen = true;
            }
            else if(quoteOpen && c == '"')
            {
                quoteOpen = false;
            }
            else if(!quoteOpen && c == ';')
            {
                value = value.substring(0, i).trim();
                break; // Found leading comment, let's strip it!
            }
        }

        if(value.startsWith("\"") && value.endsWith("\""))
            value = value.substring(1, value.length()-1).trim();

        Map<String, String> kv = _entries.get(section);

        if(kv == null)
            _entries.put(section, kv = new HashMap<>());

        kv.put(key, value);
    }

    public String getString(String section, String key, String defaultvalue)
    {
        Map<String, String> kv = _entries.get(section);
        if(kv == null)
            return defaultvalue;
        String ret = kv.get(key);
        if(ret == null)
            return defaultvalue;
        return ret;
    }

    public int getInt(String section, String key, int defaultvalue)
    {
        Map<String, String> kv = _entries.get(section);
        if(kv == null)
            return defaultvalue;
        String ret = kv.get(key);
        if(ret == null)
            return defaultvalue;
        return Integer.parseInt(ret);
    }

    public float getFloat(String section, String key, float defaultvalue)
    {
        Map<String, String> kv = _entries.get(section);
        if(kv == null)
            return defaultvalue;
        String ret = kv.get(key);
        if(ret == null)
            return defaultvalue;
        return Float.parseFloat(ret);
    }

    public double getDouble(String section, String key, double defaultvalue)
    {
        Map<String, String> kv = _entries.get(section);
        if(kv == null)
            return defaultvalue;
        String ret = kv.get(key);
        if(ret == null)
            return defaultvalue;
        return Double.parseDouble(ret);
    }
}


================================================
FILE: android-project/thextech/src/main/java/ru/wohlsoft/thextech/Launcher.java
================================================
package ru.wohlsoft.thextech;

import android.Manifest;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Shader;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Build;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import android.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.preference.PreferenceManager;

import android.os.Bundle;
import android.os.Environment;
import android.provider.Settings;
import android.util.Log;
import android.util.Pair;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.PopupMenu;
import android.widget.RelativeLayout;
import android.widget.Toast;

import com.google.android.material.floatingactionbutton.FloatingActionButton;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import javautil.FileUtils;


public class Launcher extends AppCompatActivity
{
    final String LOG_TAG = "TheXTech";
    public static final int READWRITE_PERMISSION_FOR_GAME = 1;
    public static final int READWRITE_PERMISSION_FOR_GAME_BY_INTENT = 2;
    public static final int READWRITE_PERMISSION_FOR_ADD_DIRECTORY = 3;
    private Context m_context = null;
    private String filePathToOpen;
    private String filePathToEdit;
    private boolean editRequested = false;

    /* ============ Animated background code ============ */
    private int m_bgAnimatorFrames = 1;
    private int m_bgAnimatorCurrentFrame = 0;
    private Bitmap m_bgAnimatorBitmap;
    private final UIUpdater m_bgAnimator = new UIUpdater(new Runnable()
    {
        @Override
        public void run()
        {
            m_bgAnimatorCurrentFrame++;
            if(m_bgAnimatorCurrentFrame >= m_bgAnimatorFrames)
                m_bgAnimatorCurrentFrame = 0;
            RelativeLayout launcher = findViewById(R.id.LauncherLayout);
            int fHeight = m_bgAnimatorBitmap.getHeight() / m_bgAnimatorFrames;
            int fOffset = m_bgAnimatorCurrentFrame * fHeight;
            Bitmap bitmap = Bitmap.createBitmap(m_bgAnimatorBitmap, 0, fOffset, m_bgAnimatorBitmap.getWidth(), fHeight);
            BitmapDrawable drawable = new BitmapDrawable(Launcher.this.getResources(), bitmap);
            drawable.setTileModeX(Shader.TileMode.REPEAT);
            drawable.getPaint().setFilterBitmap(false);
            launcher.setBackground(drawable);
        }
    });
    /* ================================================== */

    private static final int MENU_ADD = Menu.FIRST;
    private List<Pair<String, String>> menu_items = new ArrayList<Pair<String, String>>();;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        if(!isTaskRoot())
        {
            finish();
            return;
        }
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_launcher);
        initUiSetup();
        filePathToOpen = "";
        filePathToEdit = "";
        handleFileIntent();
    }

    @Override
    protected void onResume()
    {
        super.onResume();
        updateOverlook();
    }

    private void initUiSetup()
    {
        Button startGame = findViewById(R.id.startGame);
        startGame.setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View view)
            {
                OnStartGameClick(view);
            }
        });

        Button gameSettings = findViewById(R.id.gameSettings);
        gameSettings.setOnClickListener(
        new View.OnClickListener()
        {
            @Override
            public void onClick(View view)
            {
                Intent myIntent = new Intent(Launcher.this, GameSettings.class);
                Launcher.this.startActivity(myIntent);
            }
        });

        updateOverlook();
        reloadAssetsList();

        FloatingActionButton fab = findViewById(R.id.selectGame);
        fab.setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View view)
            {
                int i = 0;
                PopupMenu menu = new PopupMenu(Launcher.this, view);

                MenuItem dirSelect = menu.getMenu().add(0, MENU_ADD, Menu.NONE, R.string.launcher_gameSelect_pickTheDir);
                dirSelect.setIcon(R.drawable.add_directory);

                for(i = 0; i < menu_items.size(); i++)
                {
                    Pair<String, String> e = menu_items.get(i);
                    String gameName = e.first;
                    String gamePath = e.second;

                    Log.d(LOG_TAG, "Assets name: " + gameName + "; path: " + gamePath);

                    if(!GameSettings.isDirectoryExist(gamePath))
                        continue; // Skip invalid assets

                    MenuItem it = menu.getMenu().add(0, MENU_ADD + i + 1, Menu.NONE, gameName);

                    String iconPath = gamePath + "/graphics/ui/icon/thextech_128.png";
                    if(GameSettings.isFileExist(iconPath)) // Add icon only when it exists and accessible
                    {
                        Log.d(LOG_TAG, "Icon file exists: " + iconPath);
                        Drawable d = Drawable.createFromPath(iconPath);
                        it.setIcon(d);
                    }
                    else
                        Log.d(LOG_TAG, "Icon file DOES NOT EXISTS: " + iconPath);
                }

                int CLEAR_ITEM = MENU_ADD + i + 1;
                MenuItem clearItem = menu.getMenu().add(0, CLEAR_ITEM, Menu.NONE, R.string.launcher_gameSelect_clearList);
                clearItem.setIcon(R.drawable.clear_list);

                menu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener()
                {
                    @Override
                    public boolean onMenuItemClick(MenuItem item)
                    {
                        int id = item.getItemId();

                        if(id == MENU_ADD)
                        {
                            if(checkFilePermissions(READWRITE_PERMISSION_FOR_ADD_DIRECTORY) || !hasManageAppFS())
                                return false;
                            GameSettings.selectAssetsPath(Launcher.this, Launcher.this);
                        }
                        else if(id == CLEAR_ITEM)
                        {
                            AlertDialog.Builder b = new AlertDialog.Builder(Launcher.this);
                            b.setTitle(R.string.launcher_gameselect_clearlist_title);
                            b.setMessage(R.string.launcher_gameselect_clearlist_question);
                            b.setNegativeButton(android.R.string.no, null);
                            b.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener()
                            {
                                public void onClick(DialogInterface dialog, int whichButton)
                                {
                                    SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
                                    setup.edit().putString("setup_assets_list", "").apply();
                                    reloadAssetsList();
                                    Toast.makeText(getApplicationContext(), getString(R.string.launcher_gameselect_toast_listclean), Toast.LENGTH_SHORT).show();
                                }
                            });
                            b.show();
                        }
                        else
                        {
                            int itemId = id - 2;
                            String gameName = menu_items.get(itemId).first;
                            String gamePath = menu_items.get(itemId).second;

                            Toast.makeText(getApplicationContext(), String.format(getString(R.string.launcher_gameselect_toast_selected), gameName), Toast.LENGTH_SHORT).show();
                            SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
                            setup.edit().putString("setup_assets_path", gamePath).apply();
                            updateOverlook();
                        }

                        return true;
                    }
                });

                if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
                    menu.setForceShowIcon(true);

                menu.show();
            }
        });

    }

    private void handleFileIntent()
    {
        Intent intent = getIntent();
        String scheme = intent.getScheme();
        if(scheme != null)
        {
            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            if(checkFilePermissions(READWRITE_PERMISSION_FOR_GAME_BY_INTENT) || !hasManageAppFS())
                return;

            if(m_context == null)
                m_context = getApplicationContext();

            FileUtils utils = new FileUtils(this.m_context);
            filePathToOpen = utils.getPath(intent.getData());

            editRequested = Objects.equals(intent.getAction(), Intent.ACTION_EDIT);

            Log.d(LOG_TAG, "Got a file: " + filePathToOpen + ";");

            if(utils.isInternalCopy()) // File was coped into internal storage, resources are unavailable!
            {
                DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener()
                {
                    @Override
                    public void onClick(DialogInterface dialog, int which)
                    {
                        switch (which){
                            case DialogInterface.BUTTON_POSITIVE:
                                tryStartGame(m_context);
                                break;
                            case DialogInterface.BUTTON_NEGATIVE:
                                break;
                        }
                    }
                };

                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setMessage(R.string.launcher_openfile_indirectly)
                        .setPositiveButton(android.R.string.yes, dialogClickListener)
                        .setNegativeButton(android.R.string.no, dialogClickListener)
                        .show();
            }
            else // File is accessible directly, do open it normally
                tryStartGame(m_context);
        }
    }

    public void OnStartGameClick(View view)
    {
        if(m_context == null)
            m_context = view.getContext();

        // Here, thisActivity is the current activity
        if(checkFilePermissions(READWRITE_PERMISSION_FOR_GAME) || !hasManageAppFS())
            return;

        tryStartGame(m_context);
    }

    private void tryStartGame(Context context)
    {
        assert(context != null);

        SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
        String gameAssetsPath = setup.getString("setup_assets_path", "");

        if(!GameSettings.verifyAssetsPath(gameAssetsPath))
        {
            DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener()
            {
                @Override
                public void onClick(DialogInterface dialog, int which)
                {
                    switch (which){
                        case DialogInterface.BUTTON_POSITIVE:
                            GameSettings.selectAssetsPath(Launcher.this, Launcher.this);
                            break;
                        case DialogInterface.BUTTON_NEGATIVE:
                            //No button clicked
                            break;
                    }
                }
            };

            AlertDialog.Builder builder = new AlertDialog.Builder(context);
            builder.setMessage(R.string.launcher_no_resources_question)
                    .setPositiveButton(android.R.string.yes, dialogClickListener)
                    .setNegativeButton(android.R.string.no, dialogClickListener)
                    .show();
            return;
        }

        startGame();
    }

    public void reloadAssetsList()
    {
        SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
        String gameAssetsPath = setup.getString("setup_assets_list", "");

        menu_items.clear();

        if(!gameAssetsPath.isEmpty())
        {
            try
            {
                JSONObject jObject = new JSONObject(gameAssetsPath);
                JSONArray jArray = jObject.getJSONArray("assets");
                for(int i = 0; i < jArray.length(); i++)
                {
                    JSONObject oneObject = jArray.getJSONObject(i);
                    String gameName = oneObject.getString("game");
                    String gamePath = oneObject.getString("path");
                    menu_items.add(new Pair<String, String>(gameName, gamePath));
                }
            }
            catch (JSONException e)
            {
                e.printStackTrace();
            }
        }
    }

    public void updateOverlook()
    {
        SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
        String gameAssetsPath = setup.getString("setup_assets_path", "");

        String logoImagePath = "graphics/ui/MenuGFX2.png";
        String assetsIcon = "graphics/ui/icon/thextech_128.png";
        String bgImagePath = "graphics/background2/background2-2.png";
        int bgImageFrames = 1;
        int bgImageFramesDelay = 125;

        String giPath = gameAssetsPath + "/gameinfo.ini";
        boolean hasGameInfo = !gameAssetsPath.isEmpty() && GameSettings.isFileExist(giPath);
        if(hasGameInfo)
        {
            IniFile gi = new IniFile(giPath);
            logoImagePath = gi.getString("android", "logo", logoImagePath);
            bgImagePath = gi.getString("android", "background", bgImagePath);
            bgImageFrames = gi.getInt("android", "background-frames", 1);
            bgImageFramesDelay = gi.getInt("android", "background-delay", 125);
        }

        String bgPath = gameAssetsPath + "/" + bgImagePath;
        String logoPath = gameAssetsPath + "/" + logoImagePath;
        String iconPath = gameAssetsPath + "/" + assetsIcon;

        m_bgAnimator.stopUpdates();

        RelativeLayout launcher = findViewById(R.id.LauncherLayout);
        if(!gameAssetsPath.isEmpty() && GameSettings.isFileExist(bgPath))
        {
            Bitmap bitmap = BitmapFactory.decodeFile(bgPath);
            if(bgImageFrames > 1)
            {
                m_bgAnimatorBitmap = Bitmap.createBitmap(bitmap);
                bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight() / bgImageFrames);
                m_bgAnimatorFrames = bgImageFrames;
                m_bgAnimatorCurrentFrame = 0;
                m_bgAnimator.setInterval(bgImageFramesDelay);
            }
            BitmapDrawable drawable = new BitmapDrawable(this.getResources(), bitmap);
            drawable.setTileModeX(Shader.TileMode.REPEAT);
            drawable.getPaint().setFilterBitmap(false);
            launcher.setBackground(drawable);
            if(bgImageFrames > 1)
                m_bgAnimator.startUpdates();
        }
        else
            launcher.setBackgroundResource(R.drawable.background);

        ImageView gameLogo = findViewById(R.id.gameLogo);
        if(!gameAssetsPath.isEmpty() && GameSettings.isFileExist(logoPath))
        {
            Bitmap bitmap = BitmapFactory.decodeFile(logoPath);
            BitmapDrawable drawable = new BitmapDrawable(this.getResources(), bitmap);
            drawable.getPaint().setFilterBitmap(false);
            gameLogo.setImageDrawable(drawable);
        }
        else
            gameLogo.setImageResource(R.drawable.logo);

        FloatingActionButton fab = findViewById(R.id.selectGame);
        if(!gameAssetsPath.isEmpty() && GameSettings.isFileExist(iconPath))
        {
            Drawable d = Drawable.createFromPath(iconPath);
            fab.setImageDrawable(d);
        }
        else
            fab.setImageResource(R.drawable.add_directory);
    }

    private boolean checkFilePermissions(int requestCode)
    {
        final int grant = PackageManager.PERMISSION_GRANTED;
        final String exStorage = Manifest.permission.WRITE_EXTERNAL_STORAGE;

        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
            return false; /* Has no effect, the manage file storage permission is used instead of this */

        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
        {
            if(ContextCompat.checkSelfPermission(this, exStorage) == grant)
                Log.d(LOG_TAG, "File permission is granted");
            else
                Log.d(LOG_TAG, "File permission is revoked");
        }

//      // if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
//        {
        if(ContextCompat.checkSelfPermission(this, exStorage) == grant)
            return false;

        // Should we show an explanation?
        if(ActivityCompat.shouldShowRequestPermissionRationale(this, exStorage))
        {
            // Show an explanation to the user *asynchronously* -- don't block
            // this thread waiting for the user's response! After the user
            // sees the explanation, try again to request the permission.
            AlertDialog.Builder b = new AlertDialog.Builder(this);
            b.setTitle("Permission denied");
            b.setMessage("Sorry, but permission is denied!\n"+
                         "Please, check the External Storage access permission to the game!");
            b.setNegativeButton(android.R.string.ok, null);
            b.show();
            return true;
        }
        else
        {
            // No explanation needed, we can request the permission.
            ActivityCompat.requestPermissions(this, new String[] { exStorage }, requestCode);
            // MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE
            // MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE is an
            // app-defined int constant. The callback method gets the
            // result of the request.
        }

        return true;
//        } // if JELLY_BEAN

//        return false;
    }

    public boolean hasManageAppFS()
    {
        if(Build.VERSION.SDK_INT >= 30)
        {
            if(Environment.isExternalStorageManager())
                return true;

            AlertDialog.Builder b = new AlertDialog.Builder(this);
            b.setTitle(R.string.managePermExplainTitle);
            b.setMessage(R.string.managePermExplainText);
            b.setNegativeButton(android.R.string.ok, new DialogInterface.OnClickListener()
            {
                public void onClick(DialogInterface dialog, int whichButton)
                {
                    Intent intent = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
                    String pName = getPackageName();
                    Uri uri = Uri.fromParts("package", pName, null);
                    intent.setData(uri);
                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    startActivity(intent);
                }
            });
            b.show();

            return false;
        }

        return true;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults)
    {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        if(grantResults.length == 0)
            return;
        if(!permissions[0].equals(Manifest.permission.WRITE_EXTERNAL_STORAGE))
            return;
        if(grantResults[0] != PackageManager.PERMISSION_GRANTED)
            return;
        if(!hasManageAppFS())
            return;

        switch(requestCode)
        {
        case READWRITE_PERMISSION_FOR_GAME:
            tryStartGame(m_context);
            break;

        case READWRITE_PERMISSION_FOR_ADD_DIRECTORY:
            GameSettings.selectAssetsPath(Launcher.this, Launcher.this);
            break;
        }
    }

    public void startGame()
    {
        Intent myIntent = new Intent(Launcher.this, thextechActivity.class);
        if(!filePathToOpen.isEmpty())
            myIntent.putExtra("do-open-file", filePathToOpen);

        if(editRequested)
            myIntent.putExtra("edit-requested", true);

//        myIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
//        myIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        myIntent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
        Launcher.this.startActivity(myIntent);
        Launcher.this.finish();
    }
}


================================================
FILE: android-project/thextech/src/main/java/ru/wohlsoft/thextech/OpenFileDialog.java
================================================
package ru.wohlsoft.thextech;


import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
//import android.os.Build;
import android.os.Environment;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.view.*;
import android.widget.*;

import java.io.File;
import java.io.FilenameFilter;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.*;

import androidx.core.content.res.ResourcesCompat;


/**
 * Created with IntelliJ IDEA.
 * User: Scogun
 * Date: 27.11.13
 * Time: 10:47
 */
public class OpenFileDialog extends AlertDialog.Builder {

    private String currentPath = Environment.getExternalStorageDirectory().getPath();
    private String initialPath = currentPath;
    private List<File> files = new ArrayList<File>();
    private TextView title;
    private ListView listView;
    private FilenameFilter filenameFilter;
    private int selectedIndex = -1;
    private OpenDialogListener listener;
    private Drawable folderIcon;
    private Drawable fileIcon;
    private String accessDeniedMessage;
    private Boolean m_directoryMode = false;

    public interface OpenDialogListener
    {
        public void OnSelectedFile(Context ctx, String fileName, String lastPath);
        public void OnSelectedDirectory(Context ctx, String lastPath);
    }

    private class FileAdapter extends ArrayAdapter<File> {

        public FileAdapter(Context context, List<File> files) {
            super(context, android.R.layout.simple_list_item_1, files);
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            TextView view = (TextView) super.getView(position, convertView, parent);
            File file = getItem(position);
            assert file != null;
            view.setText(file.getName());
            if (file.isDirectory()) {
                setDrawable(view, folderIcon);
                view.setTextColor(Color.DKGRAY);
                view.setBackgroundColor(Color.LTGRAY);
            } else {
                setDrawable(view, fileIcon);
                view.setTextColor(Color.BLACK);
                if (selectedIndex == position)
                    view.setBackgroundColor(Color.LTGRAY);
                else
                    view.setBackgroundColor(Color.WHITE);
            }
            return view;
        }

        private void setDrawable(TextView view, Drawable drawable) {
            if (view != null) {
                if (drawable != null) {
                    drawable.setBounds(0, 0, 60, 60);
                    view.setCompoundDrawables(drawable, null, null, null);
                } else {
                    view.setCompoundDrawables(null, null, null, null);
                }
            }
        }
    }

    public OpenFileDialog(Context context) {
        super(context);
        title = createTitle(context);
        changeTitle();

        LinearLayout linearLayout = createMainLayout(context);

        LinearLayout menuBar = createMenuLayout(linearLayout.getContext());
        menuBar.addView(createBackItem(context));
        menuBar.addView(createGoHomeItem(context));
        menuBar.addView(createGoInitPathItem(context));
        linearLayout.addView(menuBar);

        listView = createListView(context);
        linearLayout.addView(listView);

        setCustomTitle(title)
            .setView(linearLayout)
            .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener()
            {
                @Override
                public void onClick(DialogInterface dialog, int which)
                {
                    if(m_directoryMode)
                    {
                        listener.OnSelectedDirectory(getContext(), currentPath);
                    }
                    else if (selectedIndex > -1 && listener != null)
                    {
                        listener.OnSelectedFile(getContext(), listView.getItemAtPosition(selectedIndex).toString(), currentPath);
                    }
                }
            })
            .setNegativeButton(android.R.string.cancel, null);
    }

    @Override
    public AlertDialog show() {
        files.addAll(getFiles(currentPath));
        listView.setAdapter(new FileAdapter(getContext(), files));
        return super.show();
    }

    public OpenFileDialog setFilter(final String filter) {
        filenameFilter = new FilenameFilter() {
            @Override
            public boolean accept(File file, String fileName) {
                Pattern filt = Pattern.compile(filter, Pattern.CASE_INSENSITIVE);
                File tempFile = new File(String.format("%s/%s", file.getPath(), fileName));
                if (tempFile.isFile()) {
                    Matcher m = filt.matcher(tempFile.getName());
                    return m.matches();
                }

                return true;
            }
        };
        return this;
    }

    public OpenFileDialog setDirectoryMode()
    {
        m_directoryMode = true;
        return this;
    }

    public OpenFileDialog setCurrentDirectory(String path)
    {
        currentPath = path;
        initialPath = path;
        changeTitle();
        return this;
    }

    public OpenFileDialog setOpenDialogListener(OpenDialogListener listener) {
        this.listener = listener;
        return this;
    }

    public OpenFileDialog setFolderIcon(Drawable drawable) {
        this.folderIcon = drawable;
        return this;
    }

    public OpenFileDialog setFileIcon(Drawable drawable) {
        this.fileIcon = drawable;
        return this;
    }

    public OpenFileDialog setAccessDeniedMessage(String message) {
        this.accessDeniedMessage = message;
        return this;
    }

    private static Display getDefaultDisplay(Context context) {
        return ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
    }

    private static Point getScreenSize(Context context) {
        Point screeSize = new Point();
//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
        getDefaultDisplay(context).getSize(screeSize);
//        } else {
//            screeSize.set( getDefaultDisplay(context).getWidth(), getDefaultDisplay(context).getHeight() );
//        }
        return screeSize;
    }

    private static int getLinearLayoutMinHeight(Context context) {
        return getScreenSize(context).y;
    }

    private LinearLayout createMainLayout(Context context) {
        LinearLayout linearLayout = new LinearLayout(context);
        linearLayout.setOrientation(LinearLayout.VERTICAL);
        linearLayout.setMinimumHeight(getLinearLayoutMinHeight(context));
        return linearLayout;
    }

    private LinearLayout createMenuLayout(Context context) {
        LinearLayout linearLayout = new LinearLayout(context);
        linearLayout.setOrientation(LinearLayout.HORIZONTAL);
        return linearLayout;
    }

    private int getItemHeight(Context context) {
        TypedValue value = new TypedValue();
        DisplayMetrics metrics = new DisplayMetrics();
        context.getTheme().resolveAttribute(android.R.attr.listPreferredItemHeightSmall, value, true);
        getDefaultDisplay(context).getMetrics(metrics);
        return (int) TypedValue.complexToDimension(value.data, metrics);
    }

    private TextView createTextView(Context context, int style) {
        TextView textView = new TextView(context);
        //textView.setTextAppearance(context, style);
        int itemHeight = getItemHeight(context);
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, itemHeight));
        textView.setMinHeight(itemHeight);
        textView.setGravity(Gravity.CENTER_VERTICAL);
        textView.setPadding(15, 0, 0, 0);
        return textView;
    }

    private TextView createTitle(Context context) {
        return createTextView(context, android.R.style.TextAppearance_DeviceDefault_DialogWindowTitle);
    }

    private TextView createBackItem(Context context) {
        TextView textView = createTextView(context, android.R.style.TextAppearance_DeviceDefault_Small);
        Drawable drawable = ResourcesCompat.getDrawable(getContext().getResources(), R.drawable.ic_menu_back, context.getTheme());
        assert drawable != null;
        drawable.setBounds(0, 0, 60, 60);
        textView.setCompoundDrawables(drawable, null, null, null);
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        textView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                File file = new File(currentPath);
                File parentDirectory = file.getParentFile();
                if (parentDirectory != null) {
                    currentPath = parentDirectory.getPath();
                    RebuildFiles(((FileAdapter) listView.getAdapter()));
                }
            }
        });
        return textView;
    }

    private TextView createGoHomeItem(Context context) {
        TextView textView = createTextView(context, android.R.style.TextAppearance_DeviceDefault_Small);
        Drawable drawable = ResourcesCompat.getDrawable(getContext().getResources(), R.drawable.ic_menu_home, context.getTheme());
        assert drawable != null;
        drawable.setBounds(0, 0, 60, 60);
        textView.setCompoundDrawables(drawable, null, null, null);
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        textView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                currentPath = Environment.getExternalStorageDirectory().getPath();
                RebuildFiles(((FileAdapter) listView.getAdapter()));
            }
        });
        return textView;
    }

    private TextView createGoInitPathItem(Context context) {
        TextView textView = createTextView(context, android.R.style.TextAppearance_DeviceDefault_Small);
        Drawable drawable = ResourcesCompat.getDrawable(getContext().getResources(), android.R.drawable.ic_menu_directions, context.getTheme());
        assert drawable != null;
        drawable.setBounds(0, 0, 60, 60);
        textView.setCompoundDrawables(drawable, null, null, null);
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        textView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                currentPath = initialPath;
                RebuildFiles(((FileAdapter) listView.getAdapter()));
            }
        });
        return textView;
    }

    private int getTextWidth(String text, Paint paint) {
        Rect bounds = new Rect();
        paint.getTextBounds(text, 0, text.length(), bounds);
        return bounds.left + bounds.width() + 80;
    }

    private void changeTitle() {
        String titleText = currentPath;
        int screenWidth = getScreenSize(getContext()).x;
        int maxWidth = (int) (screenWidth * 0.99);
        if (getTextWidth(titleText, title.getPaint()) > maxWidth) {
            while (getTextWidth("..." + titleText, title.getPaint()) > maxWidth) {
                int start = titleText.indexOf("/", 2);
                if (start > 0)
                    titleText = titleText.substring(start);
                else
                    titleText = titleText.substring(2);
            }
            title.setText( String.format("...%s", titleText) );
        } else {
            title.setText(titleText);
        }
    }

    private List<File> getFiles(String directoryPath) {
        File directory = new File(directoryPath);
        File[] list = directory.listFiles(filenameFilter);
        if(list == null)
            list = new File[]{};
        List<File> fileList = Arrays.asList(list);
        Collections.sort(fileList, new Comparator<File>() {
            @Override
            public int compare(File file, File file2) {
                if (file.isDirectory() && file2.isFile())
                    return -1;
                else if (file.isFile() && file2.isDirectory())
                    return 1;
                else
                    return file.getPath().compareToIgnoreCase(file2.getPath());
            }
        });
        return fileList;
    }

    private void RebuildFiles(ArrayAdapter<File> adapter) {
        try {
            List<File> fileList = getFiles(currentPath);
            files.clear();
            selectedIndex = -1;
            files.addAll(fileList);
            adapter.notifyDataSetChanged();
            changeTitle();
        } catch (NullPointerException e) {
            String message = getContext().getResources().getString(android.R.string.unknownName);
            if (!accessDeniedMessage.equals(""))
                message = accessDeniedMessage;
            Toast.makeText(getContext(), message, Toast.LENGTH_SHORT).show();
        }
    }

    private ListView createListView(Context context) {
        ListView listView = new ListView(context);
        listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {

            @Override
            public void onItemClick(AdapterView<?> adapterView, View view, int index, long l) {
                final ArrayAdapter<File> adapter = (FileAdapter) adapterView.getAdapter();
                File file = adapter.getItem(index);
                assert file != null;
                if (file.isDirectory()) {
                    currentPath = file.getPath();
                    RebuildFiles(adapter);
                } else {
                    if (index != selectedIndex)
                        selectedIndex = index;
                    else
                        selectedIndex = -1;
                    adapter.notifyDataSetChanged();
                }
            }
        });
        return listView;
    }
}


================================================
FILE: android-project/thextech/src/main/java/ru/wohlsoft/thextech/UIUpdater.java
================================================
package ru.wohlsoft.thextech;

import android.os.Handler;
import android.os.Looper;

/**
 * A class used to perform periodical updates,
 * specified inside a runnable object. An update interval
 * may be specified (otherwise, the class will perform the
 * update every 2 seconds).
 *
 * @author Carlos Simões
 *
 * https://stackoverflow.com/a/14234984
 */
public class UIUpdater
{
    // Create a Handler that uses the Main Looper to run in
    private final Handler mHandler = new Handler(Looper.getMainLooper());

    private Runnable mStatusChecker;
    private int UPDATE_INTERVAL = 2000;

    /**
     * Creates an UIUpdater object, that can be used to
     * perform UIUpdates on a specified time interval.
     *
     * @param uiUpdater A runnable containing the update routine.
     */
    public UIUpdater(final Runnable uiUpdater)
    {
        init(uiUpdater);
    }

    /**
     * The same as the default constructor, but specifying the
     * intended update interval.
     *
     * @param uiUpdater A runnable containing the update routine.
     * @param interval  The interval over which the routine
     *                  should run (milliseconds).
     */
    public UIUpdater(Runnable uiUpdater, int interval)
    {
        UPDATE_INTERVAL = interval;
        init(uiUpdater);
    }

    private void init(final Runnable uiUpdater)
    {
        mStatusChecker = new Runnable()
        {
            @Override
            public void run()
            {
                // Run the passed runnable
                uiUpdater.run();
                // Re-run it after the update interval
                mHandler.postDelayed(this, UPDATE_INTERVAL);
            }
        };
    }

    public void setInterval(int interval)
    {
        UPDATE_INTERVAL = interval;
    }

    /**
     * Starts the periodical update routine (mStatusChecker
     * adds the callback to the handler).
     */
    public synchronized void startUpdates()
    {
        mStatusChecker.run();
    }

    /**
     * Stops the periodical update routine from running,
     * by removing the callback.
     */
    public synchronized void stopUpdates()
    {
        mHandler.removeCallbacks(mStatusChecker);
    }
}


================================================
FILE: android-project/thextech/src/main/java/ru/wohlsoft/thextech/thextechActivity.java
================================================
package ru.wohlsoft.thextech;

import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.os.Environment;
import android.text.InputType;
import android.util.DisplayMetrics;
import android.widget.EditText;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

import org.libsdl.app.SDLActivity;

import androidx.preference.PreferenceManager;

enum ControllerKeys
{
    key_BEGIN(0),
    key_start(0),
    key_left(1),
    key_right(2),
    key_up(3),
    key_down(4),
    key_run(5),
    key_jump(6),
    key_altrun(7),
    key_altjump(8),
    key_drop(9),
    key_END(10);

    private final int value;

    ControllerKeys(final int newValue)
    {
        value = newValue;
    }

    public int getValue()
    {
        return value;
    }
}

public class thextechActivity extends SDLActivity
{
    static boolean gameRunning = false;
    private String levelToRun;
    private boolean editRequested = false;

    protected String[] getLibraries()
    {
        return new String[] {
//            "c++_shared",
//            "hidapi",
//            "SDL2",
            "thextech"
        };
    }

    private void detectLanguage()
    {
        String lang = Locale.getDefault().toString();
        String[] langD = lang.split("_");
        if(langD.length >= 2)
            setLanguageCodes(langD[0], langD[1]);
        else if(langD.length == 1)
            setLanguageCodes(langD[0], "");
    }

    protected String[] getArguments()
    {
        List<String> args = new ArrayList<>();
        args.add("thextech"); // fake %0

        SharedPreferences setup = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
        if(setup.getBoolean("enable_frame_skip", false))
            args.add("--frameskip");
        if(setup.getBoolean("disable_sound", false))
            args.add("--no-sound");
        if(setup.getBoolean("show_fps", false))
            args.add("--show-fps");
        if(setup.getBoolean("enable_max_fps", false))
            args.add("--max-fps");

        if(setup.getBoolean("setup_show_controller_state", false))
            args.add("--show-controls");

        String renderer = setup.getString("setup_renderer", "");
        if(!renderer.isEmpty())
        {
            args.add("--render");
            args.add(renderer);
        }

        int showBatteryStatus = Integer.parseInt(setup.getString("setup_show_battery_status", "0"));
        if(showBatteryStatus > 0)
        {
            args.add("--show-battery-status");
            args.add(String.valueOf(showBatteryStatus));
        }

        int speedRunMode = Integer.parseInt(setup.getString("setup_speedRunMode", "0"));
        if(speedRunMode > 0)
        {
            args.add("--speed-run-mode");
            args.add(String.valueOf(speedRunMode));

            if(setup.getBoolean("setup_sr_showStopwatchTransparent", false))
                args.add("--speed-run-semitransparent");
        }

        if(editRequested)
            args.add("-e");

        if(!levelToRun.isEmpty())
            args.add(levelToRun);

        String gameAssetsPath = setup.getString("setup_assets_path", "");
        if(!gameAssetsPath.isEmpty())
        {
            File f = new File(gameAssetsPath);
            if (f.exists() && f.isDirectory()) {
                setGameAssetsPath(gameAssetsPath);
            }
        }

        String[] argsOut = new String[args.size()];
        args.toArray(argsOut);

        return argsOut;
    }

    @Override
    protected void onStart()
    {
        super.onStart();
        gameRunning = true;
        levelToRun = "";
        // Detect current language of the system
        detectLanguage();
        Intent intent = getIntent();
        Bundle extras = intent.getExtras();
        if(extras != null)
        {
            if(extras.containsKey("do-open-file"))
                levelToRun = extras.getString("do-open-file");

            if(extras.containsKey("edit-requested"))
                editRequested = true;
        }
    }


    @Override
    public void onStop()
    {
        super.onStop();
        gameRunning = false;
    }

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        setSdCardPath(Environment.getExternalStorageDirectory().getAbsolutePath());
        setAppDataPath(getApplication().getApplicationContext().getFilesDir().getAbsolutePath());

        DisplayMetrics displayMetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
        setScreenSize(SDLActivity.getDiagonal(), displayMetrics.widthPixels, displayMetrics.heightPixels);
    }

    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        // Completely close the application.
        System.exit(0);
    }

    private void requestTextShow()
    {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle(R.string.cheat_dialog_title);

        // Set up the input
        final EditText input = new EditText(this);

        input.setInputType(InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);
        builder.setView(input);

        builder.setPositiveButton(R.string.cheat_dialog_ok, new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                textentry_setBuffer(input.getText().toString());
                messageboxSelection[0] = 1;
                dialog.dismiss();
            }
        });

        builder.setNegativeButton(R.string.cheat_dialog_cancel, new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                messageboxSelection[0] = 1;
                dialog.cancel();
            }
        });

        final AlertDialog dialog = builder.create();
        dialog.setCancelable(false);
        dialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
            @Override
            public void onDismiss(DialogInterface unused) {
                synchronized (messageboxSelection) {
                    messageboxSelection.notify();
                }
            }
        });

        dialog.show();
    }

    public void requestText()
    {
        messageboxSelection[0] = -1;

        runOnUiThread(new Runnable()
        {
            @Override
            public void run() {
                requestTextShow();
            }
        });

        synchronized (messageboxSelection) {
            try {
                messageboxSelection.wait();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    public static native void setScreenSize(double screenSize, double width, double height);
    public static native void setSdCardPath(String path);
    public static native void setAppDataPath(String path);
    public static native void setGameAssetsPath(String path);
    // Send the cheat buffer line
    public static native void textentry_setBuffer(String line);
    // set language settings
    public static native void setLanguageCodes(String lang, String country);
}


================================================
FILE: android-project/thextech/src/main/res/layout/activity_launcher.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/LauncherLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@drawable/background"
    android:orientation="horizontal"
    tools:context=".Launcher">

    <Button
        android:id="@+id/startGame"
        android:layout_width="127dp"
        android:layout_height="77dp"
        android:layout_alignParentStart="true"
        android:layout_alignParentLeft="true"
        android:layout_alignParentBottom="true"
        android:layout_marginStart="75dp"
        android:layout_marginLeft="75dp"
        android:layout_marginBottom="47dp"
        android:saveEnabled="true"
        android:text="@string/start_game_button" />

    <Button
        android:id="@+id/gameSettings"
        android:layout_width="127dp"
        android:layout_height="77dp"
        android:layout_alignParentStart="false"
        android:layout_alignParentLeft="false"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentBottom="true"
        android:layout_marginStart="225dp"
        android:layout_marginLeft="225dp"
        android:layout_marginEnd="81dp"
        android:layout_marginRight="81dp"
        android:layout_marginBottom="47dp"
        android:saveEnabled="true"
        android:text="@string/settings_button" />

    <ImageView
        android:id="@+id/gameLogo"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentStart="true"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentBottom="true"
        android:layout_marginStart="99dp"
        android:layout_marginLeft="99dp"
        android:layout_marginTop="15dp"
        android:layout_marginEnd="99dp"
        android:layout_marginRight="99dp"
        android:layout_marginBottom="160dp"
        android:contentDescription="@string/game_logo_label"
        android:saveEnabled="true"
        android:scaleType="fitCenter"
        app:srcCompat="@drawable/logo" />

    <com.google.android.material.floatingactionbutton.FloatingActionButton
        android:id="@+id/selectGame"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:layout_marginTop="10dp"
        android:layout_marginEnd="14dp"
        android:layout_marginRight="14dp"
        android:clickable="true"
        app:backgroundTint="#FFFFFF"
        app:srcCompat="@android:drawable/ic_menu_add" />

</RelativeLayout>

================================================
FILE: android-project/thextech/src/main/res/layout/settings_activity.xml
================================================
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <FrameLayout
        android:id="@+id/settings"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
</LinearLayout>

================================================
FILE: android-project/thextech/src/main/res/values/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="touchscreenControllerTypes">
        <item>@string/touchscreenControllerType0</item>
        <item>@string/touchscreenControllerType1</item>
        <item>@string/touchscreenControllerType2</item>
    </string-array>
    <string-array name="touchscreenControllerTypesValues">
        <item>2</item>
        <item>1</item>
        <item>0</item>
    </string-array>
    <string name="touchscreenControllerType0">Always enable</string>
    <string name="touchscreenControllerType1">Disable when hardware keyboard is plugged</string>
    <string name="touchscreenControllerType2">Always disable</string>
    <string-array name="speedRunModes">
        <item>@string/speedRunMode0</item>
        <item>@string/speedRunMode1</item>
        <item>@string/speedRunMode2</item>
        <item>@string/speedRunMode3</item>
    </string-array>
    <string-array name="speedRunModesValues">
        <item>0</item>
        <item>1</item>
        <item>2</item>
        <item>3</item>
    </string-array>
    <string name="speedRunMode0">Off</string>
    <string name="speedRunMode1">Mode 1 (TheXTech native)</string>
    <string name="speedRunMode2">Mode 2 (Disable time-winning features)</string>
    <string name="speedRunMode3">Mode 3 (Strict SMBX 1.3, all bugs enabled)</string>
    <string-array name="touchPadStyles">
        <item>@string/touchPadStyle0</item>
        <item>@string/touchPadStyle1</item>
        <item>@string/touchPadStyle2</item>
    </string-array>
    <string-array name="touchPadStylesValues">
        <item>0</item>
        <item>1</item>
        <item>2</item>
    </string-array>
    <string name="touchPadStyle0">In-Game Actions</string>
    <string name="touchPadStyle1">Nintendo/Xbox style (A/B/X/Y)</string>
    <string name="touchPadStyle2">PlayStation style (X/O/D/A</string>
    <string-array name="batteryStatusShow">
        <item>@string/batteryStatusShow0</item>
        <item>@string/batteryStatusShow1</item>
        <item>@string/batteryStatusShow2</item>
    </string-array>
    <string-array name="batteryStatusShowValues">
        <item>0</item>
        <item>2</item>
        <item>4</item>
    </string-array>
    <string name="batteryStatusShow0">Never show</string>
    <string name="batteryStatusShow1">Show when low battery</string>
    <string name="batteryStatusShow2">Show always</string>
    <string-array name="renderer">
        <item>@string/rendererDefault</item>
        <item>@string/rendererSdl</item>
        <item>@string/rendererGles</item>
        <item>@string/rendererGles11</item>
    </string-array>
    <string-array name="rendererValues">
        <item></item>
        <item>sdl</item>
        <item>opengles</item>
        <item>opengles11</item>
    </string-array>
    <string name="rendererDefault">Default</string>
    <string name="rendererSdl" translatable="false">SDL2</string>
    <string name="rendererGles" translatable="false">OpenGL ES 2.0+</string>
    <string name="rendererGles11" translatable="false">OpenGL ES 1.1</string>
    <string-array name="feedBackStrength">
        <item>0.1</item>
        <item>0.2</item>
        <item>0.3</item>
        <item>0.4</item>
        <item>0.5</item>
        <item>0.6</item>
        <item>0.7</item>
        <item>0.8</item>
        <item>0.9</item>
        <item>1.0</item>
    </string-array>
    <string-array name="feedBackStrengthValues">
        <item>0.1</item>
        <item>0.2</item>
        <item>0.3</item>
        <item>0.4</item>
        <item>0.5</item>
        <item>0.6</item>
        <item>0.7</item>
        <item>0.8</item>
        <item>0.9</item>
        <item>1.0</item>
    </string-array>
    <string-array name="feedBackLength">
        <item>5</item>
        <item>6</item>
        <item>7</item>
        <item>8</item>
        <item>9</item>
        <item>10</item>
        <item>11</item>
        <item>12</item>
        <item>13</item>
        <item>14</item>
        <item>15</item>
        <item>16</item>
        <item>17</item>
        <item>18</item>
        <item>19</item>
        <item>20</item>
        <item>21</item>
        <item>22</item>
        <item>23</item>
        <item>24</item>
        <item>25</item>
        <item>26</item>
        <item>27</item>
        <item>28</item>
        <item>29</item>
        <item>30</item>
    </string-array>
    <string-array name="feedBackLengthValues">
        <item>5</item>
        <item>6</item>
        <item>7</item>
        <item>8</item>
        <item>9</item>
        <item>10</item>
        <item>11</item>
        <item>12</item>
        <item>13</item>
        <item>14</item>
        <item>15</item>
        <item>16</item>
        <item>17</item>
        <item>18</item>
        <item>19</item>
        <item>20</item>
        <item>21</item>
        <item>22</item>
        <item>23</item>
        <item>24</item>
        <item>25</item>
        <item>26</item>
        <item>27</item>
        <item>28</item>
        <item>29</item>
        <item>30</item>
    </string-array>
</resources>

================================================
FILE: android-project/thextech/src/main/res/values/colors.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#3F51B5</color>
    <color name="colorPrimaryDark">#303F9F</color>
    <color name="colorAccent">#FF4081</color>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name" translatable="false">TheXTech</string>
    <string name="title_activity_game_settings">Game settings</string>
    <string name="start_game_button">Start game</string>
    <string name="settings_button">Settings</string>
    <string name="game_logo_label">Game logo</string>
    <string name="settings_enable_frameskip">Enable frame skipping</string>
    <string name="setup_disable_sound">Disable sound</string>
    <string name="setup_general_cat">General</string>
    <string name="setup_control_cat">Touchscreen controller</string>
    <string name="setup_display_cat">Display</string>
    <string name="setup_touchscreen_controller_enable">Use touch-screen controller</string>
    <string name="setup_touchscreen_alwaysshow">Show the touchscreen controller on start</string>
    <string name="setup_show_framerate">Show frame-rate value</string>
    <string name="setup_max_framerate_mode">Max frame-rate mode</string>
    <string name="setup_touchscreen_mode">Controller mode</string>
    <string name="setup_sr_speedrunMode">Speed-Run Mode</string>
    <string name="setup_sr_stopwatchSemiTransparent">Make stopwatch being semi-transparent</string>
    <string name="setup_speedrunner">Speed-runner</string>
    <string name="setup_touchpad_style">Controller style</string>
    <string name="managePermExplainTitle">All files access permission is required</string>
    <string name="managePermExplainText">This game uses resources (such as levels, episodes, graphics, music, sounds, configs, etc.) that were placed by the user on the local store directly. This concept allows users to modify and extend the content for their own purposes like that was done at the desktop version of this game. Unfortunately, Android 11+ doesn\'t give the way to grant individual read permission for the specified directory instead of a single file. To run this game you should grant access to all files for the game because of explained reasons.</string>
    <string name="setup_assets_path_label">Change the resources absolute path</string>
    <string name="launcher_no_resources_question">The game requires a resource package for the work. Please download the game resources and unpack them at any convenient directory. Do you want to select an already unpacked folder\?</string>
    <string name="setup_feedback_enable_vibration">Enable vibration</string>
    <string name="setup_feedback_vibration_strength">Vibration strength</string>
    <string name="setup_feedback_vibration_length">Vibration length</string>
    <string name="setup_feedback">Feedback</string>
    <string name="touchscreen_vibration_test_label">Test feedback</string>
    <string name="setup_show_battery_status_label">Device battery status</string>
    <string name="setup_renderer_label">Render system</string>
    <string name="setup_show_controller_state_label">Show a game controller state</string>
    <string name="cheat_dialog_cancel">Cancel</string>
    <string name="cheat_dialog_ok">Run</string>
    <string name="cheat_dialog_title">Type command:</string>
    <string name="launcher_gameSelect_clearList">Clear list</string>
    <string name="launcher_gameSelect_pickTheDir">Select directory...</string>
    <string name="launcher_gameselect_toast_selected">Switched the game: %s</string>
    <string name="launcher_gameselect_toast_listclean">The list of games has been clean.</string>
    <string name="launcher_gameselect_clearlist_title">Clear the games list</string>
    <string name="launcher_gameselect_clearlist_question">Do you really want to clear the list of games?</string>
    <string name="launcher_openfile_indirectly">Can\'t retrieve a direct absolute path for the opened file, and therefore, it was coped into the internal storage of the game. Extra resources (such as custom graphics, music, configs, scripts, etc.) can\'t be loaded. Do you want to start the game in any way\?</string>
</resources>

================================================
FILE: android-project/thextech/src/main/res/values/styles.xml
================================================
<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
        <!-- Customize your theme here. -->
    </style>

</resources>


================================================
FILE: android-project/thextech/src/main/res/values-bg/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    </resources>


================================================
FILE: android-project/thextech/src/main/res/values-bg/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="start_game_button">Започни игра</string>
    <string name="game_logo_label">Лого на играта</string>
    <string name="title_activity_game_settings">Настройки на играта</string>
    <string name="setup_disable_sound">Забраняване на звука</string>
    <string name="setup_general_cat">Основни</string>
    <string name="setup_control_cat">Сензорен контролер</string>
    <string name="setup_display_cat">Дисплей</string>
    <string name="setup_sr_stopwatchSemiTransparent">Направете хронометъра полупрозрачен</string>
    <string name="setup_speedrunner">Спийдрънер</string>
    <string name="setup_touchpad_style">Стил на контролера</string>
    <string name="setup_assets_path_label">Промяна на абсолютният път на ресурсите</string>
    <string name="launcher_no_resources_question">Играта изисква ресурсен пакет за да работи. Моля, изтеглете ресурсите на играта и ги разопаковайте във всяка удобна директория. Искате ли да изберете вече разопакована папка?</string>
    <string name="setup_feedback_enable_vibration">Разрешаване на вибрация</string>
    <string name="setup_feedback_vibration_strength">Сила на вибрация</string>
    <string name="setup_feedback_vibration_length">Дължина на вибрация</string>
    <string name="setup_feedback">Обратна връзка</string>
    <string name="touchscreen_vibration_test_label">Изпробване на обратна връзка</string>
    <string name="settings_button">Настройки</string>
    <string name="settings_enable_frameskip">Разрешаване на пропускане на кадри</string>
    <string name="setup_show_framerate">Показване на стойността на кадровата честота</string>
    <string name="setup_touchscreen_controller_enable">Използване на сензорен контролер</string>
    <string name="setup_touchscreen_alwaysshow">Показване на сензорният контролер при стартиране</string>
    <string name="setup_touchscreen_mode">Режим на контролера</string>
    <string name="setup_max_framerate_mode">Режим на максимална кадрова честота</string>
    <string name="managePermExplainTitle">Изисква се разрешение за достъп до всички файлове</string>
    <string name="setup_sr_speedrunMode">Режим на спийдрън</string>
    <string name="managePermExplainText">Тази игра използва ресурси (като нива, епизоди, графики, музика, звуци, настройки и т.н.), които са били поставени от потребителя директно в местното хранилище. Тази концепция позволява на потребителите да променят и разширяват съдържанието за свои собствени цели, точно както в настолната версия на тази игра. За съжаление Android 11+ не дава възможност да се предоставят индивидуални права за четене на определена директория вместо на отделен файл. За да стартирате тази игра, трябва да дадете разрешение за достъп до всички файлове за играта поради обяснените причини.</string>
    <string name="setup_show_controller_state_label">Показване на състоянието на игровия контролер</string>
    <string name="cheat_dialog_title">Въведете команда:</string>
    <string name="cheat_dialog_ok">Изпълнение</string>
    <string name="setup_show_battery_status_label">Състояние на батерията на устройството</string>
    <string name="cheat_dialog_cancel">Отказ</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-de/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType2">Immer deaktiviert</string>
    <string name="touchscreenControllerType1">Deaktivieren wenn Hardware Tastatur angeschlossen ist</string>
    <string name="speedRunMode1">Modus 1 (TheXTech Nativ)</string>
    <string name="speedRunMode2">Modus 2 (Deaktiviert Zeit-Gewinn Funktionen)</string>
    <string name="touchPadStyle1">Nintendo/Xbox Stil (A/B/X/Y)</string>
    <string name="touchPadStyle2">PlayStation Stil (X/O/D/A)</string>
    <string name="touchPadStyle0">Aktionen im Spiel</string>
    <string name="batteryStatusShow0">Niemals anzeigen</string>
    <string name="batteryStatusShow1">Anzeigen wenn schwaches Batterie</string>
    <string name="batteryStatusShow2">Immer anzeigen</string>
    <string name="rendererDefault">Standard</string>
    <string name="touchscreenControllerType0">Immer aktiviert</string>
    <string name="speedRunMode0">Aus</string>
    <string name="speedRunMode3">Modus 3 (Striktes SMBX 1.3, alle Fehlern aktiviert)</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-de/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">Spieleinstellungen</string>
    <string name="start_game_button">Spiel starten</string>
    <string name="settings_button">Einstellungen</string>
    <string name="game_logo_label">Spiellogo</string>
    <string name="settings_enable_frameskip">Aktiviere Frameüberspringung</string>
    <string name="setup_disable_sound">Deaktiviere Ton</string>
    <string name="setup_general_cat">Allgemein</string>
    <string name="setup_control_cat">Touchscreen Steuerung</string>
    <string name="setup_display_cat">Anzeige</string>
    <string name="setup_touchscreen_controller_enable">Benutze Touchscreen Steuerung</string>
    <string name="setup_touchscreen_alwaysshow">Zeige Touchscreen Steuerung beim Starten</string>
    <string name="setup_show_framerate">Zeige Framerate Wert</string>
    <string name="setup_max_framerate_mode">Maximaler Framerate Modus</string>
    <string name="setup_touchscreen_mode">Steuerungsmodus</string>
    <string name="setup_sr_speedrunMode">Geschwindigkeitsmodus</string>
    <string name="setup_sr_stopwatchSemiTransparent">Stoppuhr Halbtransparenz anzeigen</string>
    <string name="setup_speedrunner">Geschwindigkeitsläufer</string>
    <string name="setup_touchpad_style">Steuerungsstil</string>
    <string name="setup_feedback_enable_vibration">Vibration aktivieren</string>
    <string name="setup_feedback_vibration_strength">Vibrationsstärke</string>
    <string name="setup_feedback_vibration_length">Vibrationsdauer</string>
    <string name="setup_feedback">Vibration</string>
    <string name="touchscreen_vibration_test_label">Teste Vibration</string>
    <string name="setup_show_battery_status_label">Gerätbatterienstatus</string>
    <string name="cheat_dialog_cancel">Abbruch</string>
    <string name="managePermExplainTitle">Alle Dateien-Zugriffsberechtigungen sind erforderlich</string>
    <string name="launcher_no_resources_question">Das Spiel braucht ein Ressourcenpaket fürs abspielen. Bitte den Spiel-Ressourcen herunterladen, entpacke und platziere es an einem bequemen Verzeichnis. Möchtest du den entpackten Ordner aussuchen?</string>
    <string name="setup_assets_path_label">Ändere absoluten Weg der Ressourcen</string>
    <string name="managePermExplainText">Dieses Spiel verwendet Ressourcen (z. B. Niveaus, Episoden, Grafiken, Musik, Sounds, Konfigurationen usw.), die vom Benutzer direkt im lokalen Speicher platziert wurden. Mit diesem Konzept können Benutzer den Inhalt für ihre eigenen Zwecke ändern und erweitern, die in der Desktop Version dieses Spiels durchgeführt werden. Leider gibt Android 11+ nicht die Möglichkeit, die individuelle Lese-Erlaubnis für das angegebene Verzeichnis anstelle einer einzelnen Datei zu erteilen. Um dieses Spiel auszuführen, solltest du aus den erklärten Gründen Zugriff auf alle Dateien für das Spiel gewähren.</string>
    <string name="setup_show_controller_state_label">Zeige Spiel-Kontroller Zustand</string>
    <string name="setup_renderer_label">Rendersystem</string>
    <string name="cheat_dialog_ok">Ausführen</string>
    <string name="cheat_dialog_title">Befehl eingeben:</string>
    <string name="launcher_gameSelect_clearList">Liste löschen</string>
    <string name="launcher_gameSelect_pickTheDir">Verzeichnis auswählen...</string>
    <string name="launcher_gameselect_toast_selected">Spiel geändert zu: %s</string>
    <string name="launcher_gameselect_toast_listclean">Die Spieleliste wurde geleert.</string>
    <string name="launcher_gameselect_clearlist_title">Die Spieleliste leeren</string>
    <string name="launcher_gameselect_clearlist_question">Willst du sicher die Spieleliste leeren?</string>
    <string name="launcher_openfile_indirectly">Kann keinen absoluten Pfad für die geöffnete Datei finden, weshalb sie in den internen Spiele-Ordner verschoben wurde. Extra Ressourcen (so wie eigene Grafiken, Musik, Configs, Scripte usw.) können nicht geladen werden. Möchtest du das Spiel trotzdem starten?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-es-rES/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">Activar siempre</string>
    <string name="touchscreenControllerType1">Desactivar si se ha conectado un teclado fisico</string>
    <string name="touchscreenControllerType2">Desactivar siempre</string>
    <string name="speedRunMode0">Apagado</string>
    <string name="speedRunMode1">Modo 1 (Motor X-Tech nativo)</string>
    <string name="speedRunMode2">Modo 2 (Desactivar funciones que dan ventaja)</string>
    <string name="speedRunMode3">Modo 3 (Simular SMBX 1.3 original, errores incluidos)</string>
    <string name="touchPadStyle0">Acciones del juego</string>
    <string name="touchPadStyle1">Estilo Nintendo/Xbox (A/B/X/Y)</string>
    <string name="touchPadStyle2">Estilo PlayStation (X/O/D/A)</string>
    <string name="batteryStatusShow0">Nunca mostrar</string>
    <string name="batteryStatusShow1">Mostrar con batería baja</string>
    <string name="batteryStatusShow2">Mostrar siempre</string>
    <string name="rendererDefault">Por defecto</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-es-rES/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">Ajustes del juego</string>
    <string name="start_game_button">Jugar</string>
    <string name="settings_button">Ajustes</string>
    <string name="game_logo_label">Logo del Juego</string>
    <string name="settings_enable_frameskip">Activar omisión de fotogramas</string>
    <string name="setup_disable_sound">Desactivar sonido</string>
    <string name="setup_general_cat">General</string>
    <string name="setup_control_cat">Mando en pantalla</string>
    <string name="setup_display_cat">Mostrar</string>
    <string name="setup_touchscreen_controller_enable">Usar mando en pantalla</string>
    <string name="setup_touchscreen_alwaysshow">Mostrar el mando en pantalla al iniciar el juego</string>
    <string name="setup_show_framerate">Mostrar valor de fotogramas por segundo</string>
    <string name="setup_max_framerate_mode">Máximos fotogramas por segundo</string>
    <string name="setup_touchscreen_mode">Modo de mando</string>
    <string name="setup_sr_speedrunMode">Modo Speed-Run</string>
    <string name="setup_sr_stopwatchSemiTransparent">Hacer el cronómetro translúcido</string>
    <string name="setup_speedrunner">Speed-runner</string>
    <string name="setup_touchpad_style">Estilo de mando en pantalla</string>
    <string name="managePermExplainTitle">Se requiere acceso total al almacenamiento</string>
    <string name="managePermExplainText">Este juego utiliza recursos (como niveles, episodios, gráficos, música, sonidos, configuraciones, etc.) que el usuario colocó directamente en la tienda local. Este concepto permite a los usuarios modificar y ampliar el contenido para sus propios fines, como se hizo en la versión de escritorio de este juego. Desafortunadamente, Android 11+ no permite otorgar permiso de lectura individual para el directorio especificado en lugar de para un solo archivo. Para ejecutar este juego, debes otorgar acceso a todos los archivos del juego por razones explicadas.</string>
    <string name="setup_assets_path_label">Cambiar la ruta de los recursos</string>
    <string name="launcher_no_resources_question">El juego requiere un paquete de recursos para el trabajo. Por favor descargue los recursos y descomprimirlos en cualquier directorio conveniente. ¿Desea seleccionar una carpeta ya descomprimida?</string>
    <string name="setup_feedback_enable_vibration">Activar la vibración</string>
    <string name="setup_feedback_vibration_strength">Fuerza de vibración</string>
    <string name="cheat_dialog_cancel">Cancelar</string>
    <string name="cheat_dialog_ok">Ejecutar</string>
    <string name="cheat_dialog_title">Escribir comando:</string>
    <string name="setup_feedback">Retroalimentación</string>
    <string name="setup_feedback_vibration_length">Duración de vibración</string>
    <string name="touchscreen_vibration_test_label">Probar retroalimentación</string>
    <string name="setup_show_battery_status_label">Estado de la batería</string>
    <string name="setup_show_controller_state_label">Mostrar un estado de controlador</string>
    <string name="launcher_gameselect_clearlist_title">Limpiar la lista de juegos</string>
    <string name="launcher_gameSelect_clearList">Limpiar lista</string>
    <string name="launcher_gameselect_toast_selected">Cambió el juego: %s</string>
    <string name="launcher_gameSelect_pickTheDir">Seleccionar directorio...</string>
    <string name="launcher_gameselect_toast_listclean">La lista de juegos fue limpiada.</string>
    <string name="launcher_gameselect_clearlist_question">¿Desea limpiar la lista de juegos?</string>
    <string name="setup_renderer_label">Sistema de renderizado</string>
    <string name="launcher_openfile_indirectly">No se puede recuperar una ruta directa para el archivo abierto y, por lo tanto, se guardó en el almacenamiento interno del juego. No se pueden cargar los recursos adicionales (como gráficos personalizados, música, configuraciones, scripts, etc.). ¿Quieres iniciar el juego de igual manera?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-fr/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    </resources>


================================================
FILE: android-project/thextech/src/main/res/values-fr/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="setup_feedback">Réactions</string>
    <string name="setup_show_controller_state_label">Afficher l\'état d\'une manette de jeu</string>
    <string name="setup_show_battery_status_label">État de la batterie de l\'appareil</string>
    <string name="touchscreen_vibration_test_label">Tester les réactions</string>
    <string name="setup_feedback_vibration_length">Durée des vibrations</string>
    <string name="setup_feedback_vibration_strength">Intensité des vibrations</string>
    <string name="setup_feedback_enable_vibration">Activer les vibrations</string>
    <string name="launcher_no_resources_question">Le jeu nécessite un paquet de ressources. Veuillez télécharger les ressources du jeu et les décompresser dans le répertoire de votre choix. Voulez-vous sélectionner un dossier déjà décompressé ?</string>
    <string name="setup_assets_path_label">Modifier le chemin absolu des ressources</string>
    <string name="managePermExplainText">Ce jeu utilise des ressources (comme des niveaux, des épisodes, des graphiques, de la musique, des sons, des configurations, etc.) qui ont été placées par l\'utilisateur directement sur le magasin local. Ce concept permet aux utilisateurs de modifier et d\'étendre le contenu pour leurs propres besoins, comme cela a été fait pour la version de bureau de ce jeu. Malheureusement, Android 11+ ne permet pas d\'accorder des droits de lecture individuels pour le répertoire spécifié au lieu d\'un seul fichier. Pour exécuter ce jeu, vous devez avoir accès à tous les fichiers du jeu pour les raisons expliquées.</string>
    <string name="managePermExplainTitle">L\'autorisation d\'accès à tous les fichiers est nécessaire</string>
    <string name="setup_touchpad_style">Style de manette</string>
    <string name="setup_speedrunner">Speed-runneur</string>
    <string name="setup_sr_stopwatchSemiTransparent">Rendre le chronomètre semi-transparent</string>
    <string name="setup_sr_speedrunMode">Mode speed-run</string>
    <string name="setup_touchscreen_mode">Mode manette</string>
    <string name="setup_max_framerate_mode">Mode de fréquence d\'images maximal</string>
    <string name="setup_show_framerate">Afficher la valeur de la fréquence d\'images</string>
    <string name="setup_touchscreen_alwaysshow">Afficher la manette tactile au démarrage</string>
    <string name="setup_touchscreen_controller_enable">Utiliser la manette tactile</string>
    <string name="setup_display_cat">Affichage</string>
    <string name="setup_control_cat">Manette tactile</string>
    <string name="setup_general_cat">Général</string>
    <string name="setup_disable_sound">Désactiver le son</string>
    <string name="settings_enable_frameskip">Activer le saut de trame</string>
    <string name="game_logo_label">Logo du jeu</string>
    <string name="settings_button">Paramètres</string>
    <string name="start_game_button">Démarrer le jeu</string>
    <string name="title_activity_game_settings">Paramètres du jeu</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-hu/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="batteryStatusShow1">Mutasd alacsony töltöttség esetén</string>
    <string name="touchscreenControllerType0">Mindig engedélyezve</string>
    <string name="touchscreenControllerType1">Letiltva, amikor fizikai billentyűzet csatlakoztatva van</string>
    <string name="touchscreenControllerType2">Mindig letiltva</string>
    <string name="speedRunMode0">Ki</string>
    <string name="speedRunMode1">1-es mód (TheXTech natív)</string>
    <string name="speedRunMode2">2-es mód (időnyerési funkciók letiltva)</string>
    <string name="touchPadStyle0">Játékbeli műveletek</string>
    <string name="touchPadStyle1">Nintendo/Xbox stílus (A,B,X,Y)</string>
    <string name="touchPadStyle2">PlayStation stílus (X,O,D,A)</string>
    <string name="batteryStatusShow0">Soha ne mutasd</string>
    <string name="batteryStatusShow2">Mindig mutatsd</string>
    <string name="speedRunMode3">3-as mód (nyers SMBX 1.3, minden bug engedélyezve)</string>
    <string name="rendererDefault">Alapértelmezett</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-hu/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">Játékbeállítások</string>
    <string name="start_game_button">Játék indítása</string>
    <string name="settings_button">Beállítások</string>
    <string name="game_logo_label">Játék logó</string>
    <string name="settings_enable_frameskip">Képkockakihagyás engedélyezése</string>
    <string name="setup_disable_sound">Hang tiltása</string>
    <string name="setup_general_cat">Központi</string>
    <string name="setup_control_cat">Érintőképernyős vezérlés</string>
    <string name="setup_display_cat">Kijelző</string>
    <string name="setup_touchscreen_controller_enable">Érintőképernyős vezérlés használata</string>
    <string name="setup_touchscreen_alwaysshow">Érintőképernyős vezérlés mutatása indításkor</string>
    <string name="setup_show_framerate">Képráta mutatása</string>
    <string name="setup_max_framerate_mode">Maximális képráta mód</string>
    <string name="setup_touchscreen_mode">Kontroller mód</string>
    <string name="setup_sr_speedrunMode">Sprintjáték mód</string>
    <string name="setup_sr_stopwatchSemiTransparent">Áttetsző stopperóra</string>
    <string name="setup_touchpad_style">Kontrollerstílus</string>
    <string name="managePermExplainTitle">Fájlhozzáférési jog szükséges</string>
    <string name="setup_assets_path_label">A források abszolút útvonalának megváltoztatása</string>
    <string name="launcher_no_resources_question">A játék bizonyos adatcsomagokat igényel működéséhez. Kérjük töltsd le és tömörítsd ki az adatokat a megfelelő könyvtárba. Szeretnél kiválasztani egy már kicsomagolt adatcsomagot?</string>
    <string name="setup_feedback_enable_vibration">Rezgés engedélyezése</string>
    <string name="setup_feedback_vibration_strength">Rezgés erőssége</string>
    <string name="setup_feedback_vibration_length">Rezgés hossza</string>
    <string name="setup_feedback">Visszajelzés</string>
    <string name="touchscreen_vibration_test_label">Visszajelzés próba</string>
    <string name="setup_show_battery_status_label">Eszköz akkumulátorállapota</string>
    <string name="setup_show_controller_state_label">A kontrollerállapot mutatása</string>
    <string name="cheat_dialog_cancel">Mégse</string>
    <string name="cheat_dialog_ok">Futtatás</string>
    <string name="cheat_dialog_title">Írj be parancsot:</string>
    <string name="managePermExplainText">Ez a játék olyan forrásokat (mint a pályák, epizódok, grafikák, zene, hangok, konfigurációk, stb...) használ, amiket a felhasználónak kell elhelyeznie közvetlenül a helyi tárolóba. Ez megengedi, hogy módosítsd és bővítsd a játék tartalmát, ahogyan az asztali verziójában is történik. Sajnos az Android 11-es verziójától nem lehet egyedi hozzáférést adni néhány játékkönyvtárhoz vagy fájlhoz. Hogy futtasd ezt a játékot, engedélyezned kell a hozzáférést az összes játékfájlhoz az előbbi okokból.</string>
    <string name="launcher_gameSelect_pickTheDir">Könyvtár kiválasztása...</string>
    <string name="launcher_gameSelect_clearList">Lista ürítése</string>
    <string name="launcher_gameselect_clearlist_title">Játéklista ürítése</string>
    <string name="launcher_gameselect_toast_listclean">A jétéklista ürítve.</string>
    <string name="launcher_gameselect_clearlist_question">Biztosan szeretnéd üríteni a játéklistát?</string>
    <string name="setup_speedrunner">Sprintjáték</string>
    <string name="launcher_gameselect_toast_selected">Játék váltva: %s</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-it/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="rendererDefault">Predefinito</string>
    <string name="speedRunMode0">Off</string>
    <string name="speedRunMode1">Modalità 1 (nativa di TheXTech)</string>
    <string name="speedRunMode3">Modalità 3 (SMBX 1.3 con tutti i bug abilitati)</string>
    <string name="touchPadStyle0">Azioni in gioco</string>
    <string name="touchPadStyle1">Stile Nintendo/Xbox (A/B/X/Y)</string>
    <string name="touchPadStyle2">Stile PlayStation (X/O/D/A)</string>
    <string name="batteryStatusShow0">Non mostrare mai</string>
    <string name="batteryStatusShow1">Mostra quando la batteria è scarica</string>
    <string name="batteryStatusShow2">Mostra sempre</string>
    <string name="touchscreenControllerType0">Sempre attivo</string>
    <string name="touchscreenControllerType1">Disabilita quando la tastiera hardware è collegata</string>
    <string name="touchscreenControllerType2">Sempre disattivato</string>
    <string name="speedRunMode2">Modalitò 2 (Disabilita le funzioni di time-winning)</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-it/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">Impostazioni di gioco</string>
    <string name="start_game_button">Inizia gioco</string>
    <string name="settings_button">Impostazioni</string>
    <string name="game_logo_label">Logo del gioco</string>
    <string name="settings_enable_frameskip">Salta i frame</string>
    <string name="setup_disable_sound">Disabilita suoni</string>
    <string name="setup_general_cat">Generale</string>
    <string name="setup_control_cat">Controlli a schermo</string>
    <string name="setup_display_cat">Schermo</string>
    <string name="setup_touchscreen_controller_enable">Usa i controlli a schermo</string>
    <string name="setup_touchscreen_alwaysshow">Mostra i controlli a schermo all\'avvio</string>
    <string name="setup_show_framerate">Mostra valori frame-rate</string>
    <string name="setup_max_framerate_mode">Modalità frame-rate massimi</string>
    <string name="setup_touchscreen_mode">Modalità controller</string>
    <string name="setup_sr_speedrunMode">Modalità Speed-Run</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ja/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">つねに有効にする</string>
    <string name="batteryStatusShow0">表示しない</string>
    <string name="batteryStatusShow1">残量低下時に表示</string>
    <string name="batteryStatusShow2">つねに表示</string>
    <string name="rendererDefault">デフォルト</string>
    <string name="touchscreenControllerType1">ハードウェアキーボードが接続されている時は無効にする</string>
    <string name="touchscreenControllerType2">つねに無効にする</string>
    <string name="speedRunMode0">オフ</string>
    <string name="speedRunMode1">モード1(TheXTech ネイティブ)</string>
    <string name="touchPadStyle2">PSスタイル(‪✕‬/〇/□/△)</string>
    <string name="speedRunMode2">モード2(時間短縮機能が無効)</string>
    <string name="speedRunMode3">モード3(すべてのバグが有効。完全なSMBX 1.3)</string>
    <string name="touchPadStyle0">ゲーム内操作</string>
    <string name="touchPadStyle1">ニンテンドー/Xboxスタイル</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ja/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="setup_general_cat">一般</string>
    <string name="setup_feedback">振動</string>
    <string name="start_game_button">ゲームをはじめる</string>
    <string name="settings_enable_frameskip">フレームスキップを有効にする</string>
    <string name="setup_max_framerate_mode">最大フレームレートモード</string>
    <string name="title_activity_game_settings">ゲーム設定</string>
    <string name="setup_touchscreen_controller_enable">タッチスクリーンコントローラーを使用する</string>
    <string name="cheat_dialog_ok">実行</string>
    <string name="launcher_gameSelect_clearList">リストを全削除する</string>
    <string name="launcher_gameselect_toast_selected">ゲームを%sにへんこうしました</string>
    <string name="setup_feedback_vibration_strength">振動の強さ</string>
    <string name="setup_renderer_label">描画システム</string>
    <string name="touchscreen_vibration_test_label">振動をテスト</string>
    <string name="setup_speedrunner">スピードランナー</string>
    <string name="setup_touchpad_style">コントローラースタイル</string>
    <string name="setup_sr_speedrunMode">スピードランモード</string>
    <string name="launcher_openfile_indirectly">ファイルの絶対パスを取得できないため、ゲームは内部ストレージにコピーされました。\n追加リソース（カスタムグラフィック、音楽、設定、スクリプトなど）を読み込むことができませんが、それでもゲームを起動しますか？</string>
    <string name="setup_show_framerate">FPSを表示する</string>
    <string name="managePermExplainTitle">すべてのファイルへのアクセス権限が必要です</string>
    <string name="setup_feedback_enable_vibration">振動を有効にする</string>
    <string name="setup_disable_sound">音声を無効にする</string>
    <string name="cheat_dialog_cancel">キャンセル</string>
    <string name="launcher_no_resources_question">このゲームの動作にはリソースパッケージが必須です。ゲームリソースをダウンロードし、任意の場所に解凍してください。解凍済みのフォルダーを指定しますか？</string>
    <string name="launcher_gameselect_clearlist_question">ほんとうにゲームリストを全削除しますか？</string>
    <string name="setup_show_battery_status_label">デバイスのバッテリー状態</string>
    <string name="settings_button">設定</string>
    <string name="setup_touchscreen_alwaysshow">開始時にタッチスクリーンコントローラーを表示</string>
    <string name="setup_control_cat">タッチスクリーン コントローラー</string>
    <string name="setup_touchscreen_mode">コントローラーモード</string>
    <string name="launcher_gameselect_toast_listclean">ゲームリストは空になりました。</string>
    <string name="setup_assets_path_label">リソースの絶対パスを変更</string>
    <string name="setup_show_controller_state_label">コントローラーの操作状態を表示する</string>
    <string name="setup_display_cat">ディスプレイ</string>
    <string name="launcher_gameselect_clearlist_title">ゲームリストを全削除する</string>
    <string name="launcher_gameSelect_pickTheDir">場所をえらんでください...</string>
    <string name="cheat_dialog_title">コマンドを入力:</string>
    <string name="game_logo_label">ゲームロゴ</string>
    <string name="setup_feedback_vibration_length">振動のつよさ</string>
    <string name="setup_sr_stopwatchSemiTransparent">ストップウォッチを半透明にする</string>
    <string name="managePermExplainText">このゲームは、この端末に保存したローカルファイルを読み込んでいます。そのおかげで、プレイヤーはPC版と同じように様々なコンテンツを独自の方法で改変・拡張することができるのです。しかし、Android 11以降では、ファイルの読み取り権限を個々のファイルや一部のディレクトリのみに付与することができなくなりました。そのため、このゲームを実行するためにはすべてのファイルへのアクセス許可が必要となっています。</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ko/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType1">하드웨어 키보드가 연결되면 비활성화</string>
    <string name="rendererDefault">기본값</string>
    <string name="speedRunMode2">모드 2 (시간을 적약하는 기능 비활성화)</string>
    <string name="speedRunMode0">끔</string>
    <string name="batteryStatusShow2">항상 표시</string>
    <string name="batteryStatusShow1">배터리가 부족할 때 표시</string>
    <string name="touchPadStyle2">플레이스테이션 스타일 (X/O/D/A</string>
    <string name="speedRunMode3">모드 3 (엄격한 SMBX 1.3, 모든 버그 활성화)</string>
    <string name="speedRunMode1">모드 1 (TheXTech 기본)</string>
    <string name="touchscreenControllerType2">항상 비활성화</string>
    <string name="touchscreenControllerType0">항상 활성화</string>
    <string name="touchPadStyle1">닌텐도/Xbox 스타일 (A/B/X/Y)</string>
    <string name="touchPadStyle0">게임 내 동작</string>
    <string name="batteryStatusShow0">표시하지 않음</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ko/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="setup_general_cat">일반 사항</string>
    <string name="setup_feedback">피드백</string>
    <string name="start_game_button">게임 시작</string>
    <string name="settings_enable_frameskip">프레임 건너뛰기 활성화</string>
    <string name="setup_max_framerate_mode">최대 프레임 속도 모드</string>
    <string name="title_activity_game_settings">게임 설정</string>
    <string name="setup_touchscreen_controller_enable">터치스크린 컨트롤러 사용</string>
    <string name="cheat_dialog_ok">시작</string>
    <string name="launcher_gameSelect_clearList">목록 지우기</string>
    <string name="launcher_gameselect_toast_selected">게임 전환: %s</string>
    <string name="setup_feedback_vibration_strength">진동 강도</string>
    <string name="setup_renderer_label">렌더 시스템</string>
    <string name="managePermExplainText">이 게임은 사용자가 로컬 스토어에 직접 배치한 리소스 (예: 레벨, 에피소드, 그래픽, 음악, 사운드, 구성 등)를 사용합니다. 이 개념을 통해 사용자는 이 게임의 데스크톱 버전에서 수행된 것처럼 자신의 목적에 맞게 콘텐츠를 수정하고 확장할 수 있습니다. 안타깝게도 안드로이드 11 이상에서는 단일 파일 대신 지정된 디렉터리에 대해 개별 읽기 권한을 부여하는 방법을 제공하지 않습니다. 이 게임을 실행하려면 설명된 이유 때문에 게임의 모든 파일에 대한 그랜드 접속이 필요합니다.</string>
    <string name="touchscreen_vibration_test_label">테스트 피드백</string>
    <string name="setup_speedrunner">스피드러너</string>
    <string name="setup_touchpad_style">컨트롤러 스타일</string>
    <string name="setup_sr_speedrunMode">스피드런 모드</string>
    <string name="launcher_openfile_indirectly">열린 파일의 직접 절대 경로를 검색할 수 없어 게임 내부 저장소에 대처했습니다. 추가 리소스 (예: 사용자 정의 그래픽, 음악, 구성, 스크립트 등)는 불러올 수 없습니다. 어떤 방식으로든 게임을 시작하겠습니까?</string>
    <string name="setup_show_framerate">프레임 속도 값 표시</string>
    <string name="managePermExplainTitle">모든 파일 접근 권한 필요함</string>
    <string name="setup_feedback_enable_vibration">진동 활성화</string>
    <string name="setup_disable_sound">사운드 비활성화</string>
    <string name="cheat_dialog_cancel">취소</string>
    <string name="launcher_no_resources_question">게임에는 작업을 위한 리소스 패키지가 필요합니다. 게임 리소스를 다운로드하고 편리한 디렉터리에 압축을 풀어보세요. 이미 압축이 풀린 폴더를 선택하겠습니까?</string>
    <string name="launcher_gameselect_clearlist_question">정말로 게임 목록을 지우겠습니까?</string>
    <string name="setup_show_battery_status_label">기기 배터리 상태</string>
    <string name="settings_button">설정</string>
    <string name="setup_touchscreen_alwaysshow">시작 시 터치스크린 컨트롤러 표시</string>
    <string name="setup_control_cat">터치스크린 컨트롤러</string>
    <string name="setup_touchscreen_mode">컨트롤러 모드</string>
    <string name="launcher_gameselect_toast_listclean">게임 목록이 깨끗해졌습니다.</string>
    <string name="setup_assets_path_label">리소스 절대 경로 변경</string>
    <string name="setup_show_controller_state_label">게임 컨트롤러 상태 표시</string>
    <string name="setup_display_cat">디스플레이</string>
    <string name="launcher_gameselect_clearlist_title">게임 목록 지우기</string>
    <string name="launcher_gameSelect_pickTheDir">디렉토리 선택...</string>
    <string name="cheat_dialog_title">명령 입력 :</string>
    <string name="game_logo_label">게임 로고</string>
    <string name="setup_feedback_vibration_length">진동 길이</string>
    <string name="setup_sr_stopwatchSemiTransparent">스톱워치를 반투명하게 만들기</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-nb-rNO/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    </resources>


================================================
FILE: android-project/thextech/src/main/res/values-nb-rNO/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="managePermExplainText">På Android 11+ trengs må full filtilgang innvilges til spillressursmappen (nivåer, episoder, grafikk, musikk, lyder, oppsett, osv.) som er å finne i lokallager.</string>
    <string name="launcher_no_resources_question">Last ned spillressursene for å starte spillet. Ønsker du å velge en allerede utpakket mappe?</string>
    <string name="settings_enable_frameskip">Hopp over rammer</string>
    <string name="setup_assets_path_label">Endre absolutt sti for ressurser</string>
    <string name="managePermExplainTitle">Full filtilgang kreves</string>
    <string name="setup_touchpad_style">Kontrollerstil</string>
    <string name="setup_speedrunner">Hastighetsfullfører</string>
    <string name="setup_sr_stopwatchSemiTransparent">Gjør stoppeklokke half-gjennomsiktig</string>
    <string name="setup_sr_speedrunMode">Hastighetsfullføringsmodus</string>
    <string name="setup_feedback_vibration_length">Varighet</string>
    <string name="setup_feedback_vibration_strength">Styrke</string>
    <string name="setup_feedback_enable_vibration">Vibrasjon</string>
    <string name="setup_show_controller_state_label">Vis spillkontrollertilstand</string>
    <string name="setup_show_battery_status_label">Enhetsbatteristatus</string>
    <string name="touchscreen_vibration_test_label">Test-tilbakemelding</string>
    <string name="setup_feedback">Tilbakemelding</string>
    <string name="setup_touchscreen_mode">Kontrollermodus</string>
    <string name="setup_max_framerate_mode">Tak for rammetakt</string>
    <string name="setup_show_framerate">Vis rammetaktsverdi</string>
    <string name="setup_touchscreen_alwaysshow">Vis pekeskjermskontrolleren ved programstart</string>
    <string name="setup_touchscreen_controller_enable">Bruk pekeskjermskontroller</string>
    <string name="setup_display_cat">Skjerm</string>
    <string name="setup_control_cat">Pekeskjermskontroller</string>
    <string name="setup_general_cat">Generelt</string>
    <string name="setup_disable_sound">Skru av lyd</string>
    <string name="game_logo_label">Spill-logo</string>
    <string name="settings_button">Innstillinger</string>
    <string name="start_game_button">Start spill</string>
    <string name="title_activity_game_settings">Spillinnstillinger</string>
    <string name="cheat_dialog_cancel">Avbryt</string>
    <string name="cheat_dialog_ok">Kjør</string>
    <string name="cheat_dialog_title">Skriv kommando:</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-pl/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    </resources>


================================================
FILE: android-project/thextech/src/main/res/values-pl/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    </resources>


================================================
FILE: android-project/thextech/src/main/res/values-pt/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">Sempre ativo</string>
    <string name="touchscreenControllerType1">Desativar ao conectar teclado físico</string>
    <string name="touchscreenControllerType2">Sempre desativado</string>
    <string name="speedRunMode0">Desligado</string>
    <string name="speedRunMode1">Modo 1 (Nativo TheXTech)</string>
    <string name="speedRunMode2">Modo 2 (Sem vantagens de tempo)</string>
    <string name="speedRunMode3">Modo 3 (Derivado do SMBX 1.3, com todos os bugs)</string>
    <string name="touchPadStyle0">Ações no jogo</string>
    <string name="touchPadStyle1">Estilo Nintendo/Xbox (A/B/X/Y)</string>
    <string name="touchPadStyle2">Estilo PlayStation (𐄂/○/□/△)</string>
    <string name="batteryStatusShow0">Nunca mostrar</string>
    <string name="batteryStatusShow1">Mostrar caso a bateria esteja baixa</string>
    <string name="batteryStatusShow2">Exibir sempre</string>
    <string name="rendererDefault">Padrão</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-pt/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="setup_disable_sound">Desativar som</string>
    <string name="setup_general_cat">Gerais</string>
    <string name="setup_control_cat">Controles de toque</string>
    <string name="setup_display_cat">Ecrã</string>
    <string name="setup_touchscreen_controller_enable">Usar controles de toque</string>
    <string name="setup_touchscreen_alwaysshow">Mostrar controles de toque ao iniciar</string>
    <string name="setup_show_framerate">Mostrar taxa de quadros</string>
    <string name="setup_max_framerate_mode">Não limitar taxa de quadros</string>
    <string name="setup_touchscreen_mode">Modo do controle</string>
    <string name="setup_sr_speedrunMode">Modo corrida (Speedrun)</string>
    <string name="setup_sr_stopwatchSemiTransparent">Cronômetro semitransparente</string>
    <string name="setup_speedrunner">Corridas (Speedruns)</string>
    <string name="setup_touchpad_style">Estilo do controle</string>
    <string name="managePermExplainTitle">Permissão para acesso total a ficheiros é necessária</string>
    <string name="setup_assets_path_label">Mudar caminho absoluto dos recursos</string>
    <string name="managePermExplainText">Este jogo utiliza recursos (como níveis, episódios, gráficos, músicas, sons, configurações, etc.) que foram alocadas pelo utilizador no armazenamento local. Isso permite que o utilizador modifique e expanda o conteúdo para propósitos próprios exatamente como a versão Desktop do jogo. Infelizmente, a partir do Android 11, não existe uma maneira de garantir acesso individual a uma única pasta em vez de um ficheiro. Para executar o jogo, deve garantir acesso a todos os ficheiros pelas razões citadas acima.</string>
    <string name="setup_feedback_enable_vibration">Ativar vibração</string>
    <string name="setup_feedback_vibration_strength">Força da vibração</string>
    <string name="launcher_no_resources_question">O jogo requer um pacote de recursos para funcionar. Por favor, descarregue os recursos do jogo e desempacote num lugar conveniente. Deseja selecionar uma pasta já desempacotada?</string>
    <string name="setup_feedback_vibration_length">Duração da vibração</string>
    <string name="setup_feedback">Vibração</string>
    <string name="touchscreen_vibration_test_label">Testar vibração</string>
    <string name="setup_show_battery_status_label">Estado da bateria do aparelho</string>
    <string name="setup_renderer_label">Sistema de renderização</string>
    <string name="setup_show_controller_state_label">Mostrar estado do controle</string>
    <string name="cheat_dialog_cancel">Cancelar</string>
    <string name="cheat_dialog_ok">Executar</string>
    <string name="cheat_dialog_title">Escrever comando:</string>
    <string name="launcher_gameSelect_clearList">Limpar lista</string>
    <string name="launcher_gameSelect_pickTheDir">Selecionar diretório...</string>
    <string name="launcher_gameselect_toast_selected">Mudou o jogo: %s</string>
    <string name="launcher_gameselect_toast_listclean">A lista de jogos foi limpa.</string>
    <string name="launcher_gameselect_clearlist_title">Limpar lista de jogos</string>
    <string name="launcher_openfile_indirectly">Não foi possível aceder o caminho absoluto para o ficheiro aberto, foi criada uma copia no armazenamento do jogo. Recursos personalizados (como gráficos, músicas, configurações, scripts e outros) não serão carregados. Quer iniciar o jogo mesmo assim?</string>
    <string name="title_activity_game_settings">Configurações do jogo</string>
    <string name="start_game_button">Iniciar jogo</string>
    <string name="settings_button">Configurações</string>
    <string name="game_logo_label">Logo do jogo</string>
    <string name="settings_enable_frameskip">Ativar pulo de frames (Frameskipping)</string>
    <string name="launcher_gameselect_clearlist_question">Deseja limpar a lista de jogos?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-pt-rBR/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="speedRunMode0">Desligado</string>
    <string name="speedRunMode1">Modo 1 (Nativo TheXTech)</string>
    <string name="speedRunMode2">Modo 2 (Sem vantagens de tempo)</string>
    <string name="speedRunMode3">Modo 3 (Derivado do SMBX 1.3, com todos os bugs)</string>
    <string name="touchPadStyle0">Ações no jogo</string>
    <string name="batteryStatusShow0">Nunca mostrar</string>
    <string name="batteryStatusShow1">Mostrar caso a bateria esteja baixa</string>
    <string name="rendererDefault">Padrão</string>
    <string name="batteryStatusShow2">Mostrar sempre</string>
    <string name="touchscreenControllerType1">Desabilitar ao conectar teclado físico</string>
    <string name="touchscreenControllerType2">Desabilitado sempre</string>
    <string name="touchPadStyle1">Estilo Nintendo/Xbox (A/B/X/Y)</string>
    <string name="touchPadStyle2">Estilo PlayStation (𐄂/○/□/△)</string>
    <string name="touchscreenControllerType0">Sempre na tela</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-pt-rBR/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="start_game_button">Iniciar jogo</string>
    <string name="game_logo_label">Logo do jogo</string>
    <string name="settings_enable_frameskip">Habilitar pulo de frames (Frameskipping)</string>
    <string name="setup_disable_sound">Desabilitar som</string>
    <string name="setup_general_cat">Gerais</string>
    <string name="setup_display_cat">Tela</string>
    <string name="setup_touchscreen_controller_enable">Usar controles de toque</string>
    <string name="setup_touchscreen_alwaysshow">Mostrar controles de toque ao iniciar</string>
    <string name="setup_touchscreen_mode">Modo do controle</string>
    <string name="setup_sr_speedrunMode">Modo corrida (Speedrun)</string>
    <string name="setup_speedrunner">Corridas (Speedruns)</string>
    <string name="setup_touchpad_style">Estilo do controle</string>
    <string name="managePermExplainTitle">Permissão para acesso total a arquivos é necessária</string>
    <string name="title_activity_game_settings">Configurações do jogo</string>
    <string name="settings_button">Configurações</string>
    <string name="setup_control_cat">Controles de toque</string>
    <string name="setup_show_framerate">Mostrar taxa de quadros</string>
    <string name="setup_max_framerate_mode">Não limitar taxa de quadros</string>
    <string name="setup_assets_path_label">Mudar caminho absoluto dos recursos</string>
    <string name="launcher_no_resources_question">O jogo requer um pacote de recursos para funcionar. Por favor, descarregue os recursos do jogo e desempacote em um lugar conveniente. Você deseja selecionar uma pasta já desempacotada?</string>
    <string name="setup_feedback_enable_vibration">Habilitar vibração</string>
    <string name="setup_feedback_vibration_strength">Força da vibração</string>
    <string name="setup_feedback_vibration_length">Duração da vibração</string>
    <string name="setup_feedback">Vibração</string>
    <string name="touchscreen_vibration_test_label">Testar vibração</string>
    <string name="setup_show_battery_status_label">Estado da bateria do dispositivo</string>
    <string name="setup_renderer_label">Sistema de renderização</string>
    <string name="cheat_dialog_ok">Executar</string>
    <string name="cheat_dialog_title">Escrever comando:</string>
    <string name="launcher_gameSelect_clearList">Limpar lista</string>
    <string name="setup_show_controller_state_label">Mostrar estado do controle</string>
    <string name="cheat_dialog_cancel">Cancelar</string>
    <string name="launcher_gameSelect_pickTheDir">Selecionar diretório...</string>
    <string name="launcher_gameselect_toast_selected">Mudou o jogo: %s</string>
    <string name="launcher_gameselect_toast_listclean">A lista de jogos foi limpa.</string>
    <string name="launcher_gameselect_clearlist_title">Limpar lista de jogos</string>
    <string name="launcher_gameselect_clearlist_question">Você deseja limpar a lista de jogos?</string>
    <string name="setup_sr_stopwatchSemiTransparent">Cronômetro semitransparente</string>
    <string name="managePermExplainText">Este jogo utiliza recursos (como níveis, episódios, gráficos, músicas, sons, configurações, etc.) que foram alocadas pelo usuário no armazenamento local. Isso permite que o usuário modifique e expanda o conteúdo para propósitos próprios exatamente como a versão Desktop do jogo. Infelizmente, a partir do Android 11, não existe uma maneira de garantir acesso individual a uma única pasta em vez de um arquivo. Para rodar o jogo, você deve garantir acesso a todos os arquivos pelas razões citadas acima.</string>
    <string name="launcher_openfile_indirectly">Não foi possível acessar o caminho absoluto para o arquivo aberto, foi criada uma copia no armazenamento do jogo. Recursos personalizados (como gráficos, músicas, configurações, scripts, e outros) não serão carregados. Quer iniciar o jogo mesmo assim?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ru-rRU/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">Всегда включать</string>
    <string name="touchscreenControllerType1">Выключить при наличии аппаратной клавиатуры</string>
    <string name="touchscreenControllerType2">Всегда выключать</string>
    <string name="speedRunMode0">Отключить</string>
    <string name="speedRunMode1">Режим 1 (Штатный функционал TheXTech)</string>
    <string name="speedRunMode2">Режим 2 (Отключить функции, дающие преимущество во времени)</string>
    <string name="speedRunMode3">Режим 3 (Строгое следование SMBX 1.3, все баги будут включены)</string>
    <string name="touchPadStyle0">Внутри-игровые действия</string>
    <string name="touchPadStyle1">Стиль Nintendo/Xbox (A/B/X/Y)</string>
    <string name="touchPadStyle2">Стиль PlayStation (X/O/D/A)</string>
    <string name="batteryStatusShow0">Скрывать</string>
    <string name="batteryStatusShow1">Показывать при слабом заряде</string>
    <string name="batteryStatusShow2">Показывать всегда</string>
    <string name="rendererDefault">По-умолчанию</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ru-rRU/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">Настройки игры</string>
    <string name="start_game_button">Начать игру</string>
    <string name="settings_button">Настройки</string>
    <string name="game_logo_label">Логотип игры</string>
    <string name="settings_enable_frameskip">Включить пропуск кадров</string>
    <string name="setup_disable_sound">Отключить звук</string>
    <string name="setup_general_cat">Общее</string>
    <string name="setup_control_cat">Сенсорный контроллер</string>
    <string name="setup_display_cat">Отображение</string>
    <string name="setup_touchscreen_controller_enable">Включить экранный джойстик</string>
    <string name="setup_touchscreen_alwaysshow">Показывать экранный джойстик при запуске</string>
    <string name="setup_show_framerate">Показать частоту кадров</string>
    <string name="setup_max_framerate_mode">Режим максимальной частоты кадров</string>
    <string name="setup_touchscreen_mode">Режим контроллера</string>
    <string name="setup_sr_speedrunMode">Режим спидраннера</string>
    <string name="setup_speedrunner">Скоростное прохождение</string>
    <string name="setup_sr_stopwatchSemiTransparent">Сделать секундомер прозрачным</string>
    <string name="setup_touchpad_style">Стиль контроллера</string>
    <string name="managePermExplainTitle">Требуется разрешение на доступ ко всем файлам</string>
    <string name="managePermExplainText">Эта игра использует ресурсы (т.е. уровни, эпизоды, графику, музыку, звуки, конфиги, и т.п.), размещённые пользователем в локальном хранилище напрямую. Такая концепция позволяет пользователям менять и расширять содержимое ресурсов для любых своих целей, в точности как и на настольной версии игры. К сожалению, Android 11+ не позволяет предоставлять разрешение для чтения на отдельную папку вместо каждого отдельного файла. Чтобы запустить игру, Вы должны предоставить разрешение на доступ ко всем файлам из-за объяснённой выше причины.</string>
    <string name="setup_assets_path_label">Изменить абсолютный путь к ресурсам</string>
    <string name="launcher_no_resources_question">Для работы игры необходим пакет ресурсов. Пожалуйста, загрузите пакет ресурсов и распакуйте его в любую удобную директорию. Хотите выбрать директорию с уже распакованным пакетом ресурсов?</string>
    <string name="setup_feedback">Обратная отдача</string>
    <string name="setup_feedback_enable_vibration">Включить вибрацию</string>
    <string name="setup_feedback_vibration_strength">Сила вибрации</string>
    <string name="setup_feedback_vibration_length">Длина вибрации</string>
    <string name="touchscreen_vibration_test_label">Тест обратной отдачи</string>
    <string name="setup_show_battery_status_label">Состояние батареи устройства</string>
    <string name="setup_renderer_label">Графическая система</string>
    <string name="setup_show_controller_state_label">Показать состояние игрового контроллера</string>
    <string name="cheat_dialog_ok">Исполнить</string>
    <string name="cheat_dialog_title">Введите команду:</string>
    <string name="cheat_dialog_cancel">Отмена</string>
    <string name="launcher_gameSelect_clearList">Очистить список</string>
    <string name="launcher_gameSelect_pickTheDir">Указать директорию...</string>
    <string name="launcher_gameselect_toast_selected">Выбрана игра: %s</string>
    <string name="launcher_gameselect_toast_listclean">Список игр очищен.</string>
    <string name="launcher_gameselect_clearlist_title">Очистить список игр</string>
    <string name="launcher_gameselect_clearlist_question">Вы действительно хотите очистить список игр?</string>
    <string name="launcher_openfile_indirectly">Невозможно получить абсолютный путь к открытому файлу. Поэтому, последний был скопирован во внутреннее хранилище игры. Дополнительные ресурсы (пользовательская графика, музыка, настройки, скрипты, и т.п.) не загрузятся. Запустить игру в любом случае?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ta/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType1">வன்பொருள் விசைப்பலகை செருகப்படும்போது முடக்கு</string>
    <string name="speedRunMode0">அணை</string>
    <string name="speedRunMode1">பயன்முறை 1 (textech native)</string>
    <string name="speedRunMode2">பயன்முறை 2 (நேரத்தை வென்ற அம்சங்களை முடக்கு)</string>
    <string name="speedRunMode3">பயன்முறை 3 (கடுமையான SMBX 1.3, அனைத்து பிழைகள் இயக்கப்பட்டன)</string>
    <string name="touchPadStyle0">விளையாட்டு செயல்கள்</string>
    <string name="touchPadStyle1">நிண்டெண்டோ/எக்ச்பாக்ச் பாணி (a/b/x/y)</string>
    <string name="touchPadStyle2">பிளேச்டேசன் பாணி (x/o/d/a</string>
    <string name="batteryStatusShow1">குறைந்த பேட்டரி போது காண்பி</string>
    <string name="rendererDefault">இயல்புநிலை</string>
    <string name="touchscreenControllerType0">எப்போதும் இயக்கவும்</string>
    <string name="touchscreenControllerType2">எப்போதும் முடக்கு</string>
    <string name="batteryStatusShow0">ஒருபோதும் காட்ட வேண்டாம்</string>
    <string name="batteryStatusShow2">எப்போதும் காட்டு</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-ta/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">விளையாட்டு அமைப்புகள்</string>
    <string name="start_game_button">விளையாட்டைத் தொடங்கவும்</string>
    <string name="settings_button">அமைப்புகள்</string>
    <string name="setup_sr_stopwatchSemiTransparent">ச்டாப்வாட்ச் அரை வெளிப்படையானதாக ஆக்குங்கள்</string>
    <string name="setup_speedrunner">வேகம்-ரன்னர்</string>
    <string name="setup_feedback_enable_vibration">அதிர்வுகளை இயக்கவும்</string>
    <string name="setup_feedback_vibration_strength">அதிர்வு வலிமை</string>
    <string name="setup_feedback">கருத்து</string>
    <string name="setup_renderer_label">அமைப்பு வழங்கவும்</string>
    <string name="setup_show_controller_state_label">விளையாட்டு கட்டுப்பாட்டு நிலையைக் காட்டு</string>
    <string name="launcher_gameselect_toast_selected">விளையாட்டை மாற்றியது: %s</string>
    <string name="launcher_gameselect_toast_listclean">விளையாட்டுகளின் பட்டியல் சுத்தமாக உள்ளது.</string>
    <string name="game_logo_label">விளையாட்டு லோகோ</string>
    <string name="settings_enable_frameskip">பிரேம் ச்கிப்பிங்கை இயக்கவும்</string>
    <string name="setup_disable_sound">ஒலியை முடக்கு</string>
    <string name="setup_general_cat">பொது</string>
    <string name="setup_control_cat">தொடுதிரை கட்டுப்படுத்தி</string>
    <string name="setup_display_cat">காட்சி</string>
    <string name="setup_touchscreen_controller_enable">தொடு-திரை கட்டுப்படுத்தியைப் பயன்படுத்தவும்</string>
    <string name="setup_touchscreen_alwaysshow">தொடக்கத்தில் தொடுதிரை கட்டுப்படுத்தியைக் காட்டு</string>
    <string name="setup_show_framerate">பிரேம்-வீத மதிப்பைக் காட்டு</string>
    <string name="setup_max_framerate_mode">அதிகபட்ச பிரேம்-வீத முறை</string>
    <string name="setup_touchscreen_mode">கட்டுப்படுத்தி பயன்முறை</string>
    <string name="setup_sr_speedrunMode">வேகம்-ரன் பயன்முறை</string>
    <string name="setup_touchpad_style">கட்டுப்படுத்தி நடை</string>
    <string name="managePermExplainTitle">அனைத்து கோப்புகள் அணுகல் இசைவு தேவை</string>
    <string name="managePermExplainText">இந்த விளையாட்டு உள்ளக கடையில் பயனரால் நேரடியாக வைக்கப்பட்ட வளங்களை (நிலைகள், அத்தியாயங்கள், கிராபிக்ச், இசை, ஒலிகள், உள்ளமைவுகள் போன்றவை) பயன்படுத்துகிறது. இந்த கருத்து பயனர்கள் தங்கள் சொந்த நோக்கங்களுக்காக உள்ளடக்கத்தை மாற்றியமைக்கவும் நீட்டிக்கவும் இந்த விளையாட்டின் டெச்க்டாப் பதிப்பில் செய்யப்பட்டது. துரதிர்ச்டவசமாக, ஆண்ட்ராய்டு 11+ ஒரு கோப்பிற்கு பதிலாக குறிப்பிட்ட கோப்பகத்திற்கு தனிப்பட்ட வாசிப்பு அனுமதியை வழங்க வழிவகுக்காது. இந்த விளையாட்டை இயக்க நீங்கள் விளக்கப்பட்ட காரணங்களால் விளையாட்டுக்கான அனைத்து கோப்புகளுக்கும் அணுகலை வழங்க வேண்டும்.</string>
    <string name="setup_assets_path_label">வளங்களின் முழுமையான பாதையை மாற்றவும்</string>
    <string name="launcher_no_resources_question">விளையாட்டுக்கு வேலைக்கு ஒரு ஆதார தொகுப்பு தேவை. தயவுசெய்து விளையாட்டு வளங்களைப் பதிவிறக்கி, எந்தவொரு வசதியான கோப்பகத்திலும் அவற்றைத் திறக்கவும். ஏற்கனவே திறக்கப்படாத கோப்புறையைத் தேர்ந்தெடுக்க விரும்புகிறீர்களா?</string>
    <string name="setup_feedback_vibration_length">அதிர்வு நீளம்</string>
    <string name="touchscreen_vibration_test_label">சோதனை கருத்து</string>
    <string name="setup_show_battery_status_label">சாதன பேட்டரி நிலை</string>
    <string name="cheat_dialog_cancel">ரத்துசெய்</string>
    <string name="cheat_dialog_ok">ஓடு</string>
    <string name="cheat_dialog_title">கட்டளை வகை:</string>
    <string name="launcher_gameSelect_clearList">தெளிவான பட்டியல்</string>
    <string name="launcher_gameSelect_pickTheDir">கோப்பகத்தைத் தேர்ந்தெடுக்கவும் ...</string>
    <string name="launcher_gameselect_clearlist_title">விளையாட்டு பட்டியலை அழிக்கவும்</string>
    <string name="launcher_gameselect_clearlist_question">விளையாட்டுகளின் பட்டியலை நீங்கள் உண்மையில் அழிக்க விரும்புகிறீர்களா?</string>
    <string name="launcher_openfile_indirectly">திறந்த கோப்பிற்கான நேரடி முழுமையான பாதையை மீட்டெடுக்க முடியாது, எனவே, இது விளையாட்டின் உள் சேமிப்பகத்தில் சமாளிக்கப்பட்டது. கூடுதல் ஆதாரங்களை (தனிப்பயன் கிராபிக்ச், இசை, உள்ளமைவுகள், ச்கிரிப்ட்கள் போன்றவை) ஏற்ற முடியாது. நீங்கள் எந்த வகையிலும் விளையாட்டைத் தொடங்க விரும்புகிறீர்களா?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-tr/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">Her zaman açık</string>
    <string name="touchscreenControllerType1">Klavye takılı olduğu zaman kapat</string>
    <string name="touchscreenControllerType2">Her zaman kapalı</string>
    <string name="speedRunMode0">Kapat</string>
    <string name="speedRunMode2">2. Seçenek (Zaman kazandıran özellikleri kapat)</string>
    <string name="touchPadStyle2">PlayStation tarzı (X/O/D/A)</string>
    <string name="touchPadStyle1">Nintendo/Xbox tarzı (A/B/X/Y)</string>
    <string name="batteryStatusShow1">Batarya düşükken göster</string>
    <string name="batteryStatusShow0">Asla gösterme</string>
    <string name="batteryStatusShow2">Her zaman göster</string>
    <string name="speedRunMode1">1. Seçenek (TheXTech native)</string>
    <string name="touchPadStyle0">Oyun İçi Aksiyon</string>
    <string name="speedRunMode3">3. Seçenek (SMBX 1.3 gibi, bütün buglar dahil)</string>
    <string name="rendererDefault">Varsayılan</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-tr/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="launcher_no_resources_question">Bu oyunun çalışması için kaynak paketi gerekmektedir. Lütfen oyunun kaynak paketini indirip istediğiniz bir dizine boşaltın. Zaten boşaltılmış bir dosya seçmek ister misiniz?</string>
    <string name="setup_feedback">Geri dönüş</string>
    <string name="launcher_gameSelect_clearList">Listeyi temizle</string>
    <string name="launcher_gameselect_toast_selected">Oyunu değiştir: %s</string>
    <string name="setup_display_cat">Görüntü</string>
    <string name="launcher_gameselect_toast_listclean">Oyun listesi temizlenmiştir.</string>
    <string name="touchscreen_vibration_test_label">Geri dönüşü test et</string>
    <string name="launcher_gameselect_clearlist_title">Oyun listesini temizle</string>
    <string name="cheat_dialog_title">Komut yaz:</string>
    <string name="setup_sr_speedrunMode">Speed-Run Modu</string>
    <string name="setup_sr_stopwatchSemiTransparent">Stopwatchı yarı şeffaf yap</string>
    <string name="setup_speedrunner">Speed-runner</string>
    <string name="setup_touchpad_style">Kontrolcü tarzı</string>
    <string name="managePermExplainTitle">Bütün dosyalara erişim izni gereklidir</string>
    <string name="cheat_dialog_cancel">İptal</string>
    <string name="launcher_gameSelect_pickTheDir">Dizin seçiniz...</string>
    <string name="title_activity_game_settings">Oyun ayarları</string>
    <string name="setup_control_cat">Dokunmatik kontroller</string>
    <string name="start_game_button">Oyunu başlat</string>
    <string name="settings_button">Ayarlar</string>
    <string name="game_logo_label">Oyun logosu</string>
    <string name="setup_general_cat">Genel</string>
    <string name="setup_show_framerate">Kare hızı değerini göster</string>
    <string name="setup_feedback_enable_vibration">Titreşimi aç</string>
    <string name="setup_feedback_vibration_strength">Titreşim gücü</string>
    <string name="launcher_gameselect_clearlist_question">Oyun listesini temizlemek istediğinize emin misiniz?</string>
    <string name="setup_disable_sound">Sesi kapat</string>
    <string name="settings_enable_frameskip">Kare atlamayı aç</string>
    <string name="setup_touchscreen_alwaysshow">Dokunmatik ekran kontrollerini başlangıçta göster</string>
    <string name="setup_touchscreen_controller_enable">Dokunmatik ekran kontrollerini kullan</string>
    <string name="setup_touchscreen_mode">Kontrolcü modu</string>
    <string name="setup_max_framerate_mode">Maksimum kare hızı modu</string>
    <string name="managePermExplainText">Bu oyun kullanıcı tarafından cihazın hafızasına konulmuş dosyaları (seviyeler, bölümler, grafikle, müzikler, ayarlar, vb. gibi) kullanır. Bu kullanıcıların içerikleri değiştirmelerine ve geliştirmelerini sağlar (masaüstü versiyonundaki gibi). Maalesef ki Android11 ve üzeri sürümler bazı dosyaların tek tek okunmasına izin vermiyor. Bu oyunu çalıştırmak için oyunun, bütün dosyalara görmesine izin vermeniz gerekmektedir.</string>
    <string name="setup_assets_path_label">Kaynak yolunu değiştir</string>
    <string name="setup_feedback_vibration_length">Titreşim uzunluğu</string>
    <string name="setup_show_battery_status_label">Cihazın batarya durumu</string>
    <string name="setup_show_controller_state_label">Bir oyun kontrolcüsü durumu göster</string>
    <string name="cheat_dialog_ok">Çalıştır</string>
    <string name="setup_renderer_label">Render sistemi</string>
    <string name="launcher_openfile_indirectly">Açılan dosyalar için dizindeki kaynaklara ulaşılamadı. Bu nedenle oyun var olan kaynaklarla açılacaktır. Fazladan kaynaklar (custom grafikler, müzikler, ayarlar, scriptler vb.) yüklenememektedir. Oyunu başlatmak istediğinize emin misiniz?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-uk/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">Завжди вмикати</string>
    <string name="touchscreenControllerType1">Вимкнути при наявності апаратної клавіатури</string>
    <string name="touchscreenControllerType2">Завжди вимикати</string>
    <string name="speedRunMode0">Вимкнути</string>
    <string name="speedRunMode1">Режим 1 (Штатний функціонал TheXTech)</string>
    <string name="speedRunMode2">Режим 2 (Вимкнути функції, які дають перевагу у часі)</string>
    <string name="speedRunMode3">Режим 3 (суворо SMBX 1.3, зі всіма його помилками)</string>
    <string name="touchPadStyle0">Внутрішньо-ігрові дії</string>
    <string name="touchPadStyle1">Стиль Nintendo/Xbox (A/B/X/Y)</string>
    <string name="touchPadStyle2">Стиль PlayStation (X/O/D/A)</string>
    <string name="batteryStatusShow0">Ховати</string>
    <string name="batteryStatusShow1">Показувати при низькому заряді</string>
    <string name="batteryStatusShow2">Завжди показувати</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-uk/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">Налаштування гри</string>
    <string name="start_game_button">Почати гру</string>
    <string name="game_logo_label">Логотип гри</string>
    <string name="settings_enable_frameskip">Увімкнути пропуск кадрів</string>
    <string name="setup_disable_sound">Вимкнути аудіо</string>
    <string name="setup_general_cat">Загальні</string>
    <string name="setup_control_cat">Сенсорний контролер</string>
    <string name="setup_display_cat">Відображення</string>
    <string name="setup_show_framerate">Вивести частоту кадрів</string>
    <string name="setup_max_framerate_mode">Режим максимальної частоти кадрів</string>
    <string name="setup_touchscreen_mode">Режим контролера</string>
    <string name="setup_sr_speedrunMode">Режим спідранера</string>
    <string name="setup_sr_stopwatchSemiTransparent">Зробити секундомір напівпрозорим</string>
    <string name="setup_speedrunner">Швидке проходження</string>
    <string name="setup_touchpad_style">Стиль контролера</string>
    <string name="setup_assets_path_label">Змінити абсолютний шлях до ресурсів</string>
    <string name="launcher_no_resources_question">Гра потребує необхідний пакет ресурсів. Будь ласка, завантажте пакет ресурсів і розпакуйте його в будь-яку зручну для вас директорію. Чи бажаєте ви вибрати директорію з вже розпакованим пакетом ресурсів?</string>
    <string name="setup_feedback_enable_vibration">Увімкнути вібрацію</string>
    <string name="setup_feedback_vibration_strength">Сила вібрації</string>
    <string name="setup_feedback_vibration_length">Час вібрації</string>
    <string name="setup_feedback">Зворотній зв\'язок</string>
    <string name="touchscreen_vibration_test_label">Тест зворотнього зв\'язку</string>
    <string name="setup_show_battery_status_label">Стан батареї пристрою</string>
    <string name="setup_show_controller_state_label">Вивести стан ігрового контролера</string>
    <string name="setup_touchscreen_controller_enable">Увімкнути екранний джойстик</string>
    <string name="settings_button">Налаштування</string>
    <string name="setup_touchscreen_alwaysshow">Виводити екранний джойстик при запуску</string>
    <string name="managePermExplainTitle">Потрібен дозвіл на доступ до всіх файлів</string>
    <string name="managePermExplainText">Ця гра використовує ресурси, (такі, як рівні, епізоди, графіку, музику, звуки, конфіги, і т.д.) які були поміщені користувачем у локальному сховищі. Така концепція дозволяє користувачам змінювати і розширювати зміст ресурсів для будь-яких своїх цілей, так само, як і в настільній версії гри. Нажаль, Android 11+ не надає дозволу на читання окремих директорій, замість читання окремого файлу. Щоб запустити гру, вам потрібно надати дозвіл на доступ до всіх файлів із-за поясненої вище причини.</string>
    <string name="cheat_dialog_cancel">Скасувати</string>
    <string name="cheat_dialog_ok">Виконати</string>
    <string name="cheat_dialog_title">Введіть команду:</string>
    <string name="launcher_gameSelect_clearList">Очистити список</string>
    <string name="launcher_gameSelect_pickTheDir">Вказати директорію...</string>
    <string name="launcher_gameselect_toast_selected">Вибрана гра: %s</string>
    <string name="launcher_gameselect_toast_listclean">Список ігр очищено.</string>
    <string name="launcher_gameselect_clearlist_title">Очистити список ігр</string>
    <string name="launcher_gameselect_clearlist_question">Ви справді бажаєте очистити список ігр?</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-zh-rCN/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">启用</string>
    <string name="touchscreenControllerType1">仅在未连接实体键盘时启用</string>
    <string name="touchscreenControllerType2">禁用</string>
    <string name="speedRunMode0">禁用</string>
    <string name="speedRunMode1">模式 1（原始TheXTech）</string>
    <string name="speedRunMode2">模式 2（禁用计时过关）</string>
    <string name="speedRunMode3">模式 3（SMBX 1.3，启用所有Bug）</string>
    <string name="touchPadStyle0">游戏内动作</string>
    <string name="touchPadStyle1">字母风格（A/B/X/Y）</string>
    <string name="touchPadStyle2">PS风格（X/O/D/A）</string>
    <string name="batteryStatusShow0">不显示</string>
    <string name="batteryStatusShow2">显示</string>
    <string name="batteryStatusShow1">仅在电池电量低时显示</string>
    <string name="rendererDefault">默认</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-zh-rCN/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title_activity_game_settings">游戏设置</string>
    <string name="start_game_button">开始游戏</string>
    <string name="settings_button">设置</string>
    <string name="setup_speedrunner">秒表计时</string>
    <string name="setup_sr_stopwatchSemiTransparent">半透明秒表计时器</string>
    <string name="setup_sr_speedrunMode">速通模式</string>
    <string name="setup_touchscreen_mode">按键模式</string>
    <string name="setup_max_framerate_mode">禁用锁帧</string>
    <string name="setup_show_framerate">显示帧数</string>
    <string name="setup_touchscreen_alwaysshow">启动时显示虚拟按键</string>
    <string name="setup_touchscreen_controller_enable">使用虚拟按键</string>
    <string name="setup_display_cat">显示</string>
    <string name="setup_control_cat">虚拟按键</string>
    <string name="setup_general_cat">常规</string>
    <string name="setup_disable_sound">禁用声音</string>
    <string name="settings_enable_frameskip">启用跳帧</string>
    <string name="game_logo_label">游戏Logo</string>
    <string name="setup_touchpad_style">控制器样式</string>
    <string name="managePermExplainTitle">需要文件访问权限</string>
    <string name="setup_assets_path_label">更改组件所在文件夹</string>
    <string name="managePermExplainText">此游戏使用的是用户在直接在本地存储的数据（例如关卡、素材、音乐、音效、设置等），即允许用户修改或扩展内容。不幸的是安卓 11 以上的版本不支持设置文件夹权限。因此当游戏运行时，请您开启所有文件的访问权限。</string>
    <string name="launcher_no_resources_question">此游戏需要相关的组件才能运行，请您下载游戏组件并解压。现在要选择已经解压的游戏组件所在的文件夹吗？</string>
    <string name="setup_feedback">反馈</string>
    <string name="setup_feedback_enable_vibration">启用震动</string>
    <string name="setup_feedback_vibration_strength">震动强度</string>
    <string name="setup_feedback_vibration_length">震动时间</string>
    <string name="touchscreen_vibration_test_label">测试反馈</string>
    <string name="setup_show_battery_status_label">电池状态</string>
    <string name="setup_show_controller_state_label">显示控制键状态</string>
    <string name="cheat_dialog_ok">执行</string>
    <string name="cheat_dialog_cancel">取消</string>
    <string name="cheat_dialog_title">输入指令：</string>
    <string name="launcher_gameSelect_clearList">清除列表</string>
    <string name="launcher_gameSelect_pickTheDir">选择文件夹……</string>
    <string name="launcher_gameselect_toast_listclean">游戏列表已清除。</string>
    <string name="launcher_gameselect_clearlist_title">清除游戏列表</string>
    <string name="launcher_gameselect_toast_selected">游戏已更改为：%s</string>
    <string name="launcher_gameselect_clearlist_question">要清除游戏列表吗？</string>
    <string name="launcher_openfile_indirectly">无法检索所打开文件的指定绝对路径，但已复制到该游戏所在的内置存储位置，因此无法加载外部资源（例如自定义素材、音乐、设置、脚本等）。您还要启动游戏吗？</string>
    <string name="setup_renderer_label">图形渲染类型</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-zh-rTW/arrays.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="touchscreenControllerType0">啓用</string>
    <string name="touchscreenControllerType1">僅在未連接實體鍵盤時啓用</string>
    <string name="touchscreenControllerType2">禁用</string>
    <string name="speedRunMode0">禁用</string>
    <string name="speedRunMode1">模式1（原始TheXTech）</string>
    <string name="speedRunMode2">模式 2（禁用計時過關）</string>
    <string name="speedRunMode3">模式 3（SMBX 1.3，啓用所有Bug）</string>
    <string name="touchPadStyle0">遊戲內動作</string>
    <string name="touchPadStyle1">字母風格（A/B/X/Y）</string>
    <string name="touchPadStyle2">PS風格（X/O/D/A）</string>
    <string name="batteryStatusShow0">不顯示</string>
    <string name="batteryStatusShow1">僅在電池電量低時顯示</string>
    <string name="batteryStatusShow2">顯示</string>
    <string name="rendererDefault">默認</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/values-zh-rTW/strings.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="setup_control_cat">虛擬按鍵</string>
    <string name="setup_sr_speedrunMode">秒錶計時模式</string>
    <string name="setup_display_cat">顯示</string>
    <string name="setup_touchscreen_controller_enable">使用虛擬按鍵</string>
    <string name="setup_touchscreen_mode">按鍵模式</string>
    <string name="launcher_no_resources_question">此遊戲需要相關的組件才能運行，請您下載遊戲組件並解壓。現在要選擇已經解壓的遊戲組件所在的資料夾嗎？</string>
    <string name="launcher_gameselect_clearlist_question">要清除遊戲列表嗎？</string>
    <string name="launcher_gameselect_toast_listclean">遊戲列表已清除。</string>
    <string name="launcher_openfile_indirectly">無法檢索所打開文件的指定絕對路徑，但已複製到該遊戲所在的內置存儲位置，因此無法加載外部資源（例如自定義素材、音樂、設置、腳本等）。您還要啓動遊戲嗎？</string>
    <string name="start_game_button">開始遊戲</string>
    <string name="title_activity_game_settings">遊戲設定</string>
    <string name="settings_button">設定</string>
    <string name="game_logo_label">遊戲Logo</string>
    <string name="settings_enable_frameskip">啓用跳幀</string>
    <string name="setup_disable_sound">禁用聲音</string>
    <string name="setup_general_cat">常規</string>
    <string name="setup_touchscreen_alwaysshow">啓動時顯示虛擬按鍵</string>
    <string name="setup_show_framerate">顯示幀數</string>
    <string name="setup_max_framerate_mode">禁用鎖幀</string>
    <string name="setup_speedrunner">秒錶計時</string>
    <string name="setup_sr_stopwatchSemiTransparent">半透明秒錶計時器</string>
    <string name="setup_touchpad_style">控制器樣式</string>
    <string name="managePermExplainTitle">需要檔案訪問權限</string>
    <string name="setup_assets_path_label">更改組件所在位置</string>
    <string name="setup_feedback_enable_vibration">啓用震動</string>
    <string name="setup_feedback_vibration_strength">震動強度</string>
    <string name="setup_feedback_vibration_length">震動時間</string>
    <string name="setup_feedback">反饋</string>
    <string name="touchscreen_vibration_test_label">測試反饋</string>
    <string name="setup_show_battery_status_label">電池狀態</string>
    <string name="setup_renderer_label">圖形渲染類型</string>
    <string name="setup_show_controller_state_label">顯示控制鍵狀態</string>
    <string name="cheat_dialog_cancel">取消</string>
    <string name="cheat_dialog_ok">執行</string>
    <string name="cheat_dialog_title">輸入指令：</string>
    <string name="launcher_gameSelect_clearList">清除列表</string>
    <string name="launcher_gameSelect_pickTheDir">選擇資料夾……</string>
    <string name="launcher_gameselect_toast_selected">遊戲已更改為：%s</string>
    <string name="launcher_gameselect_clearlist_title">清除遊戲列表</string>
    <string name="managePermExplainText">此遊戲使用的是用戶在直接在本地存儲的數據（例如關卡、素材、音樂、音效、設置等），即允許用戶修改或擴展內容。不幸的是安卓 11 以上的版本不支持設置資料夾權限。因此當遊戲運行時，請您開啓所有檔案的訪問權限。</string>
</resources>


================================================
FILE: android-project/thextech/src/main/res/xml/root_preferences.xml
================================================
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <PreferenceCategory android:title="@string/setup_general_cat">
        <CheckBoxPreference
            android:defaultValue="false"
            android:key="enable_frame_skip"
            android:title="@string/settings_enable_frameskip" />
        <CheckBoxPreference
            android:defaultValue="false"
            android:key="disable_sound"
            android:title="@string/setup_disable_sound" />
        <Preference
            android:key="setup_assets_path"
            android:title="@string/setup_assets_path_label" />
    </PreferenceCategory>
    <PreferenceCategory android:title="@string/setup_display_cat">
        <ListPreference
            android:defaultValue=""
            android:entries="@array/renderer"
            android:entryValues="@array/rendererValues"
            android:key="setup_renderer"
            android:title="@string/setup_renderer_label" />
        <CheckBoxPreference
            android:defaultValue="false"
            android:key="show_fps"
            android:title="@string/setup_show_framerate" />
        <CheckBoxPreference
            android:defaultValue="false"
            android:key="enable_max_fps"
            android:title="@string/setup_max_framerate_mode" />
        <CheckBoxPreference
            android:defaultValue="false"
            android:key="setup_show_controller_state"
            android:title="@string/setup_show_controller_state_label" />
        <ListPreference
            android:defaultValue="0"
            android:entries="@array/batteryStatusShow"
            android:entryValues="@array/batteryStatusShowValues"
            android:key="setup_show_battery_status"
            android:title="@string/setup_show_battery_status_label" />
    </PreferenceCategory>
    <PreferenceCategory android:title="@string/setup_speedrunner">
        <ListPreference
            android:defaultValue="0"
            android:entries="@array/speedRunModes"
            android:entryValues="@array/speedRunModesValues"
            android:key="setup_speedRunMode"
            android:title="@string/setup_sr_speedrunMode" />
        <CheckBoxPreference
            android:defaultValue="false"
            android:key="setup_sr_showStopwatchTransparent"
            android:title="@string/setup_sr_stopwatchSemiTransparent" />
    </PreferenceCategory>
</PreferenceScreen>

================================================
FILE: changelog.txt
================================================
TheXTech Changelog.

Changelog for 1.3.8-dev
-Unstable changes will go here for testing during the 1.3.7.x release lifespan...
-Update LVLX/WLDX/SAVX loader to use new MDX file parser (@ds-sloth)
-3DS/Wii: disable partial support for loading SMBX-38A content (@ds-sloth)
-Technical update: reduce mainloop nesting to improve engine flexibility (@ds-sloth)
-Add experimental support for loading game/episode content from single-file archives (@ds-sloth)
-Important notice: gray and red bricks are now killed at the end of the frame they are destroyed (like other blocks). This is an intentional change to the game workflow that is required for us to support NetPlay. Content where these blocks have destroy / last events can no longer be loaded in Vanilla Mode. (@ds-sloth)
-Improve the performance of levels with many coins, guarded by compat flag "optimize-coins". (@ds-sloth)
-Improve the performance of levels with many conveyor belts, guarded by compat flag "new-conveyor-belts". (@ds-sloth)
-In split screen, extra screen shake effects now apply only to the camera where the object is present. (@ds-sloth)
-Extra screen shake effects now applies separately per camera [Classic/Modern Mode] (@ds-sloth)
-Performance improvements for the stopwatch freeze logic (@ds-sloth)
-Add experimental support for maze physics zones to the game and editor (@ds-sloth)
-Add experimental cheat "borntoclimb" (@ds-sloth)
-Added an experimental port to the Nintendo DSi port (@ds-sloth)
-Fix SMBX 1.3 visual peculiarity where a large reserve item was drawn at the wrong offset and size, guarded by compat flag "fix-visual-bugs" [Modern Mode] (@ds-sloth)
-Battle mode: allow eaten player to escape by repeatedly hitting Jump (@ds-sloth)
-Fix SMBX 1.3 peculiarity where NPCs would not respawn when coming back onscreen during a timestop, guarded by compat flag "fix-timestop-respawn" [Modern Mode] (@ds-sloth)
-Add experimental support for attaching wings to NPCs to the game and editor (@ds-sloth)
-Switch the engine to fixed point arithmetic for performance and reproducibility (@ds-sloth)
-Tweak camera logic to reduce jitter when standing on a group of NPCs (@ds-sloth)
-Battle mode: char 5's shield now blocks and cancels another char 5 player's stab, creating an opening for attack (@ds-sloth)
-Battle mode: allow multiple players to choose the same character (@ds-sloth)
-For creators: add compat flag "alt-powerdown" which makes Chars 1 and 2 go to Big after being hit with a stronger powerup, and disables the item box (@ds-sloth)

Changelog for 1.3.7.3-dev
-Fixed an inability to save the state of the collected medals on triggering the game beat (@Wohlstand, thanks to @Liebning for the report)
-Fixed a TTF text print bug from the version 1.3.7.2 that caused missing vertical offset on line breaking (@Wohlstand, thanks to 呜哩哇啦 for the report)
-Wii: fix v1.3.7.2 bug where deleting an in-use controls profile could lead to a crash (@ds-sloth)
-Fix TheXTech v1.3.7 bug where popping an empty bubble (ID 283) could harm the player (@ds-sloth, thanks to @Liebning for the report)
-Fix SMBX 1.3 peculiarity where frozen NPCs would sometimes be rendered incorrectly, guarded by compat flag "fix-visual-bugs" [Modern Mode] (@ds-sloth)
-Fix SMBX 1.3 bug where the swap power (ID 273) could result in unexpected deaths or softlocks if the players were in different sections, guarded by compat flag "fix-multiplayer-targeting" [Modern/Classic Mode] (@ds-sloth, thanks to @Shadowblitz16 for the report)
-Logic change for TheXTech-exclusive feature: portal warps will not trigger until the player has spent 10 frames without overlapping any portal warps (@ds-sloth)
-Fixed an inability to load a game pack from command line by path without slash ending (@Wohlstand)
-3DS: fix v1.3.7 bug where the title screen could get stuck at the right of the level (@ds-sloth)
-Enabled running of Layers, Events, and LunaScript loops at the Outro screen to allow more dynamics (@Wohlstand)
-Fix SMBX 1.3 bug where character passthrough blocks treated char 2-4's ice balls as belonging to char 1, guarded by compat flag "fix-char-pass-balls" [Modern Mode] (@ds-sloth, thanks to @Wohlstand for the report)
-Fix SMBX 1.3 bug where character passthrough blocks did not allow char 5's fire/ice balls to pass through, guarded by compat flag "fix-char-pass-balls" [Modern Mode] (@ds-sloth)
-Fixed a crash caused by hit of invisible Block-88 with a coin inside while the Coin Swtich is active (@Wohlstand)

Changelog for 1.3.7.2
-i18n: Added support for the localisation of the loading screen (@Wohlstand)
-i18n: Removed the support for legacy placement of translations outside the i18n sub-directory since no production projects used it. (@Wohlstand)
-Modern mode: allow static, always-shown NPCs (eg, O or bullet shooters) to deactivate while onscreen (@Wohlstand, @ds-sloth)
-Added an ability to assign some TTF font per language (@Wohlstand)
-Menus: Alt Run is now used to erase options, instead of Alt Jump (@ds-sloth)
-Menus: Alt Jump may now advance message boxes and start levels, guarded by existing compat flag "multiplayer-pause-controls" [Modern/Classic Mode] (@ds-sloth)
-Controls: add Alt Menu Controls option to controller profiles, which makes Jump act as Back and Alt Jump act as Confirm, to improve experience on Japanese-layout controllers (@ds-sloth)
-Controls: re-use controller profile when connected on different interfaces (@ds-sloth)
-Controls: remove ability to load controller profiles saved by versions before v1.3.6 (2022) (@ds-sloth)
-Controls: fix v1.3.6 bug where controller was assigned the wrong profile after its original profile was deleted (@ds-sloth)
-Controls: allow deleting a profile in use. This will allow the controller's profile to be reset. (@ds-sloth)
-Controls: fix face button labels on Switch port. (@Wohlstand, @ds-sloth)
-Controls: fix v1.3.6 bug where closing the Enter Code screen with the Start button might prevent successful code entry (@ds-sloth, @Wohlstand)
-Controls: adjusted support for Wii Remote and Wii Remote with Nunchuk controllers on Wii U. (@Wohlstand)
-Visuals: fix v1.3.7.1 bug where there was a black frame during the transition from the main menu to the asset pack select screen (@ds-sloth)
-Fonts: Fixed the incorrect vertical alignment of some TTF glyph. (@Wohlstand)
-Fix v1.3.7.1 bug where npc-300.txt was not loaded properly - fixes spinning platforms in Lowser's Conquest (@ds-sloth, @Wohlstand)
-Fix v1.3.7.1 bug where default masks/outlines were not loaded for custom GIF player sprites, resulting in black boxes (@ds-sloth)
-Fix v1.3.7.1 Modern/Classic bug where it was not safe to run on a series of fall blocks with gaps between them, caused by the downward clip fix introduced in v1.3.7.1 (@ds-sloth, thanks to @Liebning for the report)
-Vanilla mode: reset score between gameplay sessions, like SMBX 1.3 (@ds-sloth)
-Desktop: fix a minor cosmetic bug where the screen could flicker when resizing the window (@ds-sloth)
-Fixed the SMBX 1.3 bug where the engine would appear to break if an AutoStart event (other than "Level - Start") changed section bounds, guarded by compat flag "modern-section-change" [Modern/Classic Mode] (@Wohlstand)
-Fixed the v1.3.6 bug where skull raft with modern logic enabled will glitch when impacts a barrier being in a water (@Wohlstand)
-Fix v1.3.1 inaccuracy where NPCs 69 and 70 were one pixel shorter than they are in SMBX 1.3 (@ds-sloth, thanks to @Liebning for the report)
-Fix SMBX 1.3 crash caused by hitting a coin switch while on a slope (@ds-sloth, thanks to Peter Smith for the report)
-Logic change: when modern (LVLX) autoscroll hits the end of the section, it now keeps the current camera size instead of resetting the camera to 800x800 as in SMBX 1.3 (@ds-sloth)
-Logic change: the terminal velocity for rail/lineguide platforms has been increased from 16 to 40 to address compatibility issues at some levels where falling speed is not enough to beat the challenge. (@Wohlstand)
-Fixed an inability to auto-create the screenshots directory on macOS (@Wohlstand)
-Fix v1.3.7 bug where the engine would fail to load if the first encountered asset pack was invalid (@ds-sloth)
-Fix v1.3.6 inaccuracy where warp-spawned NPCs would fail to be hidden if their layer was hidden immediately following spawn (their layer is set to "Spawned NPCs" when warp is complete) (@ds-sloth)
-Fix v1.3.7.1 bug where static NPCs spawned by a generator could despawn while onscreen (@ds-sloth)
-Fix v1.3.1 bug where whipping a turtle (with leaf power) would kill the turtle as well as releasing it from its shell (@ds-sloth, thanks to @Liebning for the report)
-Fixed vanilla crash bug caused by division by zero on rendering of Background2-25 with a texture width smaller than 800 and when the section has an exact width of 800 (@Wohlstand)
Changelog for 1.3.7.2-hotfix1
-Fixed an incorrect resampling logic at the MixerX audio library that caused accelerated tempo of music on 3DS, Wii, and PSVita (@Wohlstand)

Changelog for 1.3.7.1
-Add GameCube controller support for Wii (@ds-sloth)
-Fix TheXTech 1.3.7 peculiarity where NPCs that hid themselves on activation would be shown before coming onscreen (@ds-sloth)
-Fix TheXTech 1.3.7 peculiarity where player preview sprites in the main menu would not use the correct death effects (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where a plant on a hidden moving layer would sometimes not appear after showing the layer (@ds-sloth, @Wohlstand)
-Fixed a bug from the TheXTech 1.3.6 where music of a wrong section gets started when player enters level by a warp into section with no music (@Wohlstand)
-Fix TheXTech 1.3.7 bug where rail/lineguide platforms could get stuck below the current section (@ds-sloth, thanks to @Liebning for the report)
-3DS: fix bug where gameplay could slow down when audio performance is reduced (@ds-sloth)
-Implemented support for Power-of-Two only textures on some platforms via SDL Render (@Wohlstand)
-Adjusted the frame-skip behaviour to address the performance slowdown on some systems (@Wohlstand)
-Added exclusive full-screen mode support to maintain good performance on weak devices (@Wohlstand)
-Windows: use SDL2 renderer on video cards without OpenGL acceleration (@ds-sloth)
-Fix TheXTech 1.3.5.3 visual bug where P2's screen fader was not reset when P1 gets a level exit (@ds-sloth)
-Wii: fix bug where Wiimote could get stuck in Rumble state (@ds-sloth)
-Fix TheXTech 1.3.6.1 visual change in the width of spaces in the in-game message box (@ds-sloth)
-Fix TheXTech 1.3.7 visual change in the line-breaking algorithm for the in-game message box (@ds-sloth)
-Fix vanilla bug where chars 3 and 4 could clip downwards if they powered up while digging, guarded by "fix-player-grab-clip" [Classic Mode] (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where setting width or height to 0 in npc.txt would prevent the NPC from spawning (this affected the boss of Hall of Masks in MM4) (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where colored platform NPCs could mistakenly trigger activation events (this affected The Sinister Side in SRW) (@ds-sloth)
-Fix SMBX 1.3 crash caused by freezing a bubble when the NPC with index 3 is an ice ball (@ds-sloth)
-Fix TheXTech 1.3.1 inaccuracy where certain internal values were not rounded correctly (@ds-sloth)
-Fix TheXTech 1.3.1 bug where characters 2 and 5 couldn't release all coins in a block if the block was in front of another sizable block (@ds-sloth)
-Added compat flag "no-shell-grab-top" to disable grabbing shells while falling from above, for compatibility with pre-SMBX 1.3 content (@Wohlstand)
-Fix loading of custom resolution specified in thextech.ini (@ds-sloth)
-Add 3x scale mode (@ds-sloth, thanks to @Yave-Yu for the request)
-Fix TheXTech 1.3.7 bug where medals were incorrectly tracked after using Coin Switch in Classic Mode (@ds-sloth, thanks to @Agatha for the report)
-Fix TheXTech 1.3.7 editor bug where sizable block priority was not used when resizing sizable blocks (@ds-sloth, thanks to @ChristianSilvermoon for the report)
-Refine Magic Block handling of lava next to slopes (@ds-sloth, thanks to @ChristianSilvermoon for the report)
-Fix TheXTech v1.3.7 change to the timing of events triggered by warp enter/exit events (@ds-sloth, thanks to @ChristianSilvermoon for the report)
-Fix TheXTech v1.3.6.1 inaccuracy where generator NPCs with IDs 57, 60, 62, 64, and 66 could not be walked on in their generator state (@ds-sloth)
-Resolved the pool allocator memory overflow crash problem (Caused by LunaScript's render operations with frame skipping enabled on slow devices) (@Wohlstand)
-Fix TheXTech 1.3.7-beta bug which prevented the compat flag "fix-player-clip-wall-at-npc" from working as intended (@ds-sloth)
-Fix vanilla editor peculiarity where the order of overlapping blocks might change. Note that overlapping blocks larger than 1 tile are still sorted according to SMBX rules. (@ds-sloth)
-Rapidly clicking on menu items no longer toggles fullscreen. (@ds-sloth, thanks to @Agatha for the suggestion)
-The mouse can now be used to click through message boxes in the main menu. (@ds-sloth, thanks to @Agatha for the suggestion)
-Advanced options are now applied only when hitting Select or returning to the previous screen. (@ds-sloth, thanks to @Wohlstand for the suggestion)
-Fix TheXTech v1.3.7-beta visual bug in which the backdrop did not have proper borders in 4P split screen at 1440p. (@ds-sloth)
-Fix TheXTech v1.3.7 bug in which input methods might get disconnected when switching between battle levels in 3/4-player mode. (@ds-sloth)
-Added an explicit indication that game is suspended when window is out of focus by showing the "Paused" label over the gray filter. (@Wohlstand)
-Fix TheXTech v1.3.7-beta bug in which bullet generators not facing the player could become inactive. (@ds-sloth, thanks to @Liebning for the report)
-Tune TheXTech v1.3.7 Modern/Classic Mode logic for when to activate NPCs shown by events to better match Vanilla. (@ds-sloth, thanks to @Liebning for the report)
-Fix critical TheXTech v1.3.6 editor bug where reordering layers resulting in objects losing their layers. (@ds-sloth, thanks to @ChristianSilvermoon for the report)
-Fix TheXTech v1.3.6 editor bug where world music tiles would move a tiny bit when the world was saved (@ds-sloth, thanks to @ChristianSilvermoon for the report)
-Fix vanilla bug where the player could clip downwards when hurt or running into a block while on a platform, guarded by existing compat flag "fix-player-downward-clip" [Classic Mode] (affected Frozen Valley in Fallen Spirits and Mushroom Heights in Princess Cliche) (@ds-sloth, thanks to @Agatha for the report)
-Fixed the viewport problem on non-SMBX resolutions at the PS Vita (@Wohlstand, @ds-sloth)
-Fixed the early interrupting of the level workflow when going to the inter-level warp on some platforms (@Wohlstand)
-Fixed the visual glitch of the last screen fade out frame being frozen instead of complete going into darkness (@Wohlstand)
-Fixed the bug that causes gamesave's fails counter not being copied or removed via game menu (@Wohlstand)
-Fix TheXTech 1.3.7-beta editor bug where a player object could become deselected when closing the editor pane (@ds-sloth, thanks to @fbitninja for the report)
-Fixed the incorrect work of the Java-coded INI parser on Android that led some properties being loaded incorrectly (for example, valid background picture fails to load) (@Wohlstand)
-On failures while using interprocess-based level testing, the explicit error messages will be shown (@Wohlstand)
1.3.7.1-hotfix:
-Added workaround for the texture corruption problem on Windows 10+ with the Intel Iris Xe GPU: the depth buffer will be completely disabled here to avoid glitches (@Wohlstand)
-Implemented the proper initialisation of the OpenGL on VirtualBox's SVGA3D driver (@Wohlstand)
1.3.7.1-hotfix2:
-Fixed the startup crash on OpenGL render initialization, now the OpenGL ES 2+ is used instead (@Wohlstand)

Changelog for 1.3.7
-Fix vanilla peculiarity where medals were sometimes not collected when killed, guarded by "fix-medal-kill" [Modern Mode] (@ds-sloth, thanks to @Superbloxen for the report)
-Implemented the in-game assert failures will be shown as in-game message box until perform an emergency close on platforms that doesn't have SDL's message box (@Wohlstand)
-Wii: fix TheXTech 1.3.6.1 inaccuracy in how very small GIF bitmasks are rendered (@ds-sloth)
-Fix TheXTech 1.3.7-beta visual glitch when the vanilla cam hotkey was pressed during the level intro scene (@ds-sloth)
-Fix TheXTech 1.3.7-beta bug where vanilla cam was not reset before entering credits (@ds-sloth)
-Refine GIF bitmask detection and fallback algorithm (@ds-sloth)
-3DS/Wii: speed up graphics loading code (@ds-sloth)
-3DS/Wii: fix TheXTech 1.3.7-beta bug where levels with 101 layers/events could not load (@ds-sloth)
-Update level loading error screen to be more informative (@ds-sloth)
-Add world loading error screen (@ds-sloth)
-Hints: fix the graphical display of the surfing hint (@ds-sloth)
-Refine the placement of HUD items at low resolutions (@ds-sloth)
-Don't allow pressing the vanilla cam hotkey during a camera pan event (@ds-sloth)
-3DS: add advanced option "Inaccurate GIFs" to allow playing in 3D on levels with GIFs (@ds-sloth)
-Fix TheXTech 1.3.7-beta bug where battle levels could be created even if the asset pack disables battle mode (@ds-sloth, thanks to @LoveBodhi for the report)
-Fix TheXTech 1.3.6.1 bug where player-dependent event text could be inaccurate if Autocode cancelled a different event (@ds-sloth)
-TheXTech-exclusive events are now processed at the end of the frame they are triggered in (@ds-sloth)
-Fix TheXTech 1.3.1 inaccuracy where a vanilla bug failed to replicate. This bug caused a pending event to be overwritten when two events triggered in a single frame. The bugfix now has compat flag "fix-event-swap-bug" (@ds-sloth)
-Improve the performance of levels with many climbable NPCs (@ds-sloth)
-Move the `[intro]` and `[outro]` sections of `gameinfo.ini` to `[activity-setup]` in the `compat.ini` file for the intro/outro levels, for per-level configuration of these settings. Setting the fields via `gameinfo.ini` is deprecated and will be removed during the v1.3.7.x series. (@ds-sloth, @Wohlstand)
-Fix TheXTech 1.3.7-beta bug where it was impossible to enter speedrun mode using the main menu interface (@ds-sloth, thanks to @0lhi for the report)
-Added support for on-exit warp event. (@Wohlstand)
-Fix TheXTech 1.3.7-beta bug where the modern lives count was shown at the title screen for vanilla gamesaves (@ds-sloth, thanks to @0lhi for the report)
-Fix TheXTech 1.3.7-beta bug where "4shared" and "4split" could give Chars 3 and 4 pet mounts (@ds-sloth, thanks to @0lhi for the report)
-Fix TheXTech 1.3.7-beta defect where it was not clear whether vanilla cam was activated at high resolutions (@ds-sloth, thanks to @0lhi for the report)
-Fix TheXTech 1.3.7-beta inaccuracy in which an NPC that moves into a section during gameplay might fail to spawn (this affected the final boss of Valtteri's Island - Revisited) (@ds-sloth)
-Fix TheXTech 1.3.7-beta bug where an assertion failure could be triggered when a player went offscreen in shared screen multiplayer (@ds-sloth)
-Ensure that the player setup menu always remembers the most recently selected characters (@ds-sloth, thanks to @0lhi for the suggestion)
-Fix TheXTech 1.3.7-beta bug where the logical screen could desync after dropping a player (@ds-sloth)
-Fixed the random crash and memory damaging during the load process (@Wohlstand)
-Add ability to change last warp resume setting on hub worlds. This allows playing episodes incompatible with this behavior in Modern Mode. (@ds-sloth, thanks to @0lhi for the suggestion)
-Fix TheXTech 1.3.6 bug where some controls profiles could not be deleted. (@ds-sloth, thanks to @0lhi for the report)
-Added support for custom main menu single intro level or introset powered by recently played episode. (@Wohlstand)
-Added support for custom outro level powered by just completed currently playing episode. (@Wohlstand)
-Fix TheXTech 1.3.7-beta bug where menus could become unresponsive if a player had been dropped while holding a button. (@ds-sloth, thanks to @0lhi for the report)
-Add ability to keep forced character through menu quit (@ds-sloth)
-Fix TheXTech 1.3.7-beta bug where the player start points were incorrect for some content (@ds-sloth)
-Fix TheXTech 1.3.7-beta bug where hitting Escape at the pause menu could return to menu (@ds-sloth, thanks to @sl4cer for the report)
-Fix TheXTech 1.3.7-beta PortMaster peculiarity where the load screen would be drawn too small (@ds-sloth)
-Fix TheXTech 1.3.7-beta Wii bug where the no-assets screen would not display correctly (@ds-sloth)
-Fix TheXTech 1.3.7-beta Wii bug where unconverted UI assets could not be loaded (@ds-sloth)
-3DS: display system and video memory usage in Debug Info screen (@ds-sloth)
-Add support for TTF fonts up to 24x24 (@ds-sloth)
-Allow customization of TTF colour of fonts (@ds-sloth)
-Fix TheXTech 1.3.7-beta bug where the controller preview on the controls menu was inaccurate (@ds-sloth)
-Fix TheXTech 1.3.7-beta bug where simple editor controls would interfere with text entry in the editor (@ds-sloth)

Changelog for 1.3.7-beta
-Add ability to trigger event layer smoke in the in-game editor (@ds-sloth)
-Add tracking for medals collected in levels (@ds-sloth)
-Save the number of medals / stars that exist in levels to speed up subsequent loads (@ds-sloth)
-Fix thrower vertical position logic in split-screen, guarded by compat flag modern-npc-camera-logic (@ds-sloth)
-Internal change: added draw plane system to track different object groups' scene depth (@ds-sloth)
-Note: screen-space autocode draws now occur in the HUD plane instead of the level plane (@ds-sloth)
-Added "opensesame" world map cheat to unlock paths from level (@ds-sloth)
-Added smooth path unlock animations at the world map (@ds-sloth)
-Added full game and in-game editor support for world map sections that limit screen view (@ds-sloth)
-Added support for more than 2 cameras (@ds-sloth)
-Added support for different display resolutions (@ds-sloth)
-Allow event logic NPCs to consider SMBX 1.3 camera when activating, guarded by compat flag modern-npc-camera-logic (@ds-sloth)
-Added code "logicscreen" to view camera used by event logic NPCs (@ds-sloth)
-Add npc.txt attribute "usedefaultcam"; set this to "1" to force NPCs to use the event logic camera to activate and "0" to force them to use the visible camera (@ds-sloth)
-Add compat.ini setting "dynamic-camera-logic" which may be disabled to force a level to use the 800x600 camera for all logic (@ds-sloth)
-Added backdrop for levels smaller than the screen at graphics/ui/Backdrop.png (@ds-sloth)
-Added alternative format for world map frame with better support for various display resolutions (@ds-sloth)
-Add ability to edit BGO sort layers and offset in the in-game editor (@ds-sloth)
-Redesigned character select screen for multiplayer game start and player setup (@Savbyn, @ds-sloth)
-Drop/add screen renamed to "Player Setup"
-In modern gameplay, the main menu now has a single "Play Episode" item instead of separate 1P/2P items
-COMPATIBILITY CHANGE: remove automatic version targeting for pre-SMBX 1.3 content (@ds-sloth)
-Sounds now get quieter when they are further from the screen (@ds-sloth)
-In Modern and Classic modes, now allow negative lives instead of game over (@ds-sloth, @0lhi)
-Game looks for asset packs in the assets/ subdirectory of the user and system directories (@ds-sloth)
-Add ability to specify asset pack by ID in the command line (as well as by path) (@ds-sloth)
-Add ability to switch asset pack at main menu screen by holding select button (@ds-sloth)
-Very long SFX are now played from disk to save memory (@ds-sloth)
-Made some internal memory optimizations to the Block and NPC objects, saving 360KB RAM (@ds-sloth)
-Add hints system to the loading and pause screens (@ds-sloth)
-Fix SMBX 1.3 bug where camera would not track respawning player, guarded by compat flag multiplayer-pause-controls (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where level fadeout did not properly occur on fail in 2P mode (@ds-sloth)
-Fix ghost, boss, and other NPC target player selection, guarded by compat flag "fix-multiplayer-targeting" (@ds-sloth)
-Add ability to resize placed items, section boundaries, and event section boundaries in the editor (@ds-sloth)
-Overhaul the Main Menu and in-game Options menu with support for editing all "thextech.ini" options (@ds-sloth)
-Add "Modern", "Classic", and "Vanilla" playstyles which determine which bugfixes and gameplay updates are applied (@ds-sloth, @0lhi)
-Add ability to start speedrun in-game by pressing Select when making a new game save (@ds-sloth, @0lhi)
-Add cheat "edityourfriends" to experiment with compatibility settings (@ds-sloth)
-Add option to always use shared or split screen in 2P (@ds-sloth)
-Add ability to play >2P mode with shared or split screen (@ds-sloth)
-Add cheats "4shared" and "4split" to test 4-player shared / split screen modes (@ds-sloth)
-Add new item drop system, used by default in Modern Mode at low resolutions (@ds-sloth, @ChristianSilvermoon, @0lhi)
-GIF recorder now turns grey and skips frames when recording is slower than gameplay (@ds-sloth)
-Add compat flag "disable-spin-jump", which causes the AltJump key to map to a normal jump, but still allows players to dismount. The flag replaces a hack used to force-disable the key in Superb Demo Sisters. (@ds-sloth)
-Fix vanilla peculiarity where plants would make a sound when dying in a no-turn-back level, guarded by compat flag "fix-visual-bugs" [Modern Mode] (@ds-sloth)
-Update TheXTech's logic for climbing moving fences (@ds-sloth)
-Fix vanilla peculiarity where the speed of blocks attached to an NPC would not be fully reset when the NPC dies, guarded by compat flag "fix-attlayer-reset" [Modern Mode] (@ds-sloth)
-Fix TheXTech 1.3.6.1 peculiarity where a player could reach an inaccessible location by respawning while another player was scrolling (@ds-sloth)
-Editor: fix TheXTech 1.3.6 bug where level test might incorrectly start following text input (@ds-sloth)
-Fix vanilla peculiarity where some held NPCs would appear to move on the player's hands / feet, guarded by compat flag "fix-visual-bugs" [Modern Mode] (@ds-sloth)
-Change cheat "shadowstar" to use a 75% black tint (instead of 100% as in SMBX 1.3) for visibility against dark level backgrounds (@0lhi, @ds-sloth)
-Added support for error boxes at the Wii U to explicitly show reasons of errors to users (@Wohlstand)
-Fixed crash on attempt to execute the "SetHits" and "AllFace" LunaScript commands (@Wohlstand)
-Speedrun timer no longer permanently stops following initial game win, allowing speedruns of postgame content (@ds-sloth)
-Fix TheXTech 1.3.5.1 bug where the lower half of a player's sprite could be shown behind a shoe / sack (@ds-sloth)
-Fixed the inability to close error LunaScript parse error box on Android when file contains too long lines (@Wohlstand)
-Fix vanilla editor bug where NPC spawn logic might be inaccurate on level test (@ds-sloth)
-Fix TheXTech 1.3.6 bug where an item could be cloned by changing characters during powerup animation (@ds-sloth)
-Fix TheXTech 1.3.6.1 OpenGL bug where a mask larger than its texture could be drawn incorrectly (@ds-sloth, thanks to @AntonioGZZ96 for the report)
-Fix TheXTech 1.3.6.1 inaccuracy affecting "Endless Exploration" where levels started via an invalid warp point could not be played (in SMBX 1.3, the warp point is ignored) (@ds-sloth)
-Fix TheXTech 1.3.1 bug where many max-ID custom GFX were not loaded (including player-5 map sprites) (@ds-sloth, thanks to @AntonioGZZ96 for the report)
-Add option (on-by-default) for gamepads to use simple editor controls. Prevents getting locked in the editor. (@ds-sloth)
-Fix TheXTech v1.3.6 editor bug where NPC properties could change when their layer was hidden. (@ds-sloth, thanks to @cre8iveexercise for the report)
-Fix TheXTech v1.3.6.1 Android bug where the screen would be black after switching applications. (@ds-sloth)
-System message boxes will have their unique style that is different from the in-game one. (@Wohlstand)
-Update TheXTech userdata locations to system-native locations on new installs. (@ds-sloth, @Wohlstand)

Changelog for 1.3.6.6
-Fix vanilla bug where vehicle could be vulnerable if player entered it during AltJump (requires frame perfect down press), guarded by compat flag "fix-vehicle-altjump-bug" (@ds-sloth)
-Fix vanilla bug where vehicle could not be exited if player entered it while holding AltJump key, guarded by compat flag "fix-vehicle-altjump-lock" (@ds-sloth)
-Fixed the problem when a touch screen is not detected on some Android devices (@Wohlstand)
-Fix minor bug that caused certain configurations on macOS to crash on startup (@ds-sloth)
-Fix Wii U bug where resizing the game screen could cause the game to crash (@ds-sloth)
-Fix TheXTech 1.3.6.1 crash caused when a pet mount is eating the last NPC in the level and the eaten NPC is killed (@ds-sloth)
-Fixed Wii U bug where game quits into the black screen instead of the Wii U's main menu when game started from the Aroma (@Wohlstand)
-Fix TheXTech 1.3.6.1 inaccuracy allowing the player to dismount a vehicle when blocked by an NPC (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where conveyor belts would sometimes not activate correctly (@ds-sloth)
-Fix TheXTech 1.3.6.1 OpenGL bug where the shadow effect interacted inaccurately with bitmasked textures (@ds-sloth)
-Fix TheXTech 1.3.6 bug where it was impossible to unpause while holding an item (@ds-sloth, thanks to SimplyMav for the report)
-Fix TheXTech 1.3.6.1 bug where GIF masks for sizable block 261 were not loaded (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where SMBX level version autodetection did not work for platforms (note that this logic will be fully removed in 1.3.7) (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where NPCs on hidden layers were incorrectly allowed to chain-activate. (The bug affected the outro scene of Dynamite Grotto in SRW2.) (@ds-sloth)
-Add workaround for TheXTech 1.3.6.1 Modern Mode inaccuracy where NPC clipping did not match SMBX 1.3. (This bug affected the same scene.) (@ds-sloth)
-Fix vanilla bug where player can get softlocked if hit by a grabbable NPC while digging dirt, guarded by compat flag "fix-player-stuck-on-dirt" (Classic Mode) (@ds-sloth)

Changelog for 1.3.6.5
-Fix TheXTech 1.3.6 bug where auto movement on the world map was not reset when switching episodes (@ds-sloth)
-Fix TheXTech 1.3.6 bug where dropping a player at the world map removed their mount (@ds-sloth)
-Fix TheXTech 1.3.6.4 editor bug where NPCs could not be erased from a battle level (@ds-sloth)
-Fix vanilla bug where an incorrect frame gets shown when player attempts to enter the star-locked pipe, guarded by compat flag fix-visual-bugs (@Wohlstand)
-Added an experimental Sub-Hubs sub-system: it's will be possible to mark any level as a "sub-hub" where player can save the game and resume it from that level instead of the main hub (@Wohlstand)
-Added the CopyVar command to the LunaScript which allows to copy value of one user variable to another (@Wohlstand)
-The fails counter now increments whenever any player dies (not just P1) (@ds-sloth)
-Fix a graphical bug where an NPC emerging upwards from a block might use the wrong frame and width (@ds-sloth)
-Fix the logical size of an NPC emerging downwards from a block, guarded by compat flag fix-npc-emerge-size (@ds-sloth)
-Fix a vanilla bug where blocks could become intangible to NPCs after a coin switch was used (@ds-sloth)
-Add a terminal velocity of 16 for rail/lineguide platform blocks, guarded by compat flag fix-platform-acceleration (@ds-sloth)
-Add a workaround for a memory exhaustion error from rail/lineguide platform blocks (@ds-sloth)
-Fix TheXTech 1.3.6 bug where carefully-constructed single-frame wall clips would not work in TheXTech (@ds-sloth)
-Fix TheXTech 1.3.6 bug where the vanilla player-filter-bounce bug was not correctly reproduced in TheXTech (@ds-sloth)
-Added automatical language detection for Vita (@Wohlstand)
-Fixed a leak of file descriptors in the translations sub-system (@Wohlstand)
-Allow asset packs to customize Font 5 (outlined mixed-case font) (@ds-sloth)
-Fixed the problem when anti-cheat trap will break levels in the editor (@Wohlstand)
-Fixed the unexpected fade-in effect that gets played during any level quits by warps (@Wohlstand)
-Fixed the incorrect work of the touch screen on PS Vita (@Wohlstand)

Changelog for 1.3.6.4
-Use OpenGL as the default renderer on supported platforms ("sdl" may be used in config.ini or at at the command line to request the SDL2 renderer)
-Add ability to edit battle levels using in-game editor (@ds-sloth)
-Fix bug where it was not possible to return to the main menu from an invalid battle mode level (@ds-sloth)
-Fix vanilla bug where P2 could not close message box during shared screen coop (@ds-sloth)
-Changed credits font id to 5 for outlines. (@0lhi)
-Fix Emscripten bug where worlds created in the editor would get lost on page refresh (@ds-sloth)
-Remove option "osk-fill-screen"; this behavior is now used whenever a touchscreen is active (@ds-sloth)
-Fix TheXTech 1.3.6.1 crash on activating a joystick with an empty SDL name (@ds-sloth)
-Fixed the TheXTech 1.3.6.3's startup crash on some 32-bit Windows systems. (@Wohlstand)
-Removed config option "editor-edge-scroll" (enable by default on gamepads) (@ds-sloth)
-Add ability to scroll in editor using mouse wheel or touchpad (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where bitmask GIFs would sometimes be rendered incorrectly (@ds-sloth)
-Fix TheXTech 1.3.6 bug where the editor could occasionally crash when placing warps (@ds-sloth)
-Fix TheXTech 1.3.6 bug where the editor could not set the level name (used in battle mode) (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug affecting debug builds where the editor could crash when erasing objects (@ds-sloth)
-Improve the performance of MixerX on low-end targets (3DS, Wii, Vita) (@Wohlstand)

Changelog for 1.3.6.3
-Fixed a TheXTech 1.3.6.1 crash where object lookup table could not process items with negative size (@ds-sloth)
-On level load, replace negative item sizes with size zero (such items cannot be created by any editor)
-Fix TheXTech 1.3.6.1 bug where item would drop above incorrect player in SharedCoop mode (@ds-sloth)
-Fix rare TheXTech 1.3.6 bug where newly-added player could get stuck in immune state if other player died (@ds-sloth)
-Display current version (and git revision if a dev build) on title screen (@ds-sloth)
-Wii U port: add WUHB build (@ds-sloth)
-Fix TheXTech 1.3.6.1 bug where the score display would not show '9's when using legacy assets (@ds-sloth)
-Use the ANGLE shader translator library to improve support for OpenGL ES 3.0 shaders on desktop platforms (@ds-sloth)
-Fix vanilla / TheXTech bug where a player could clip into ground while standing on a downwards-moving slope, guarded by fix-player-downward-clip compat flag (@ds-sloth)
-CONTROLS / LOGIC CHANGE: when riding a purple pet mount, alt run is now used to enter a pound (down is still used in compat mode) (@0lhi, @ds-sloth, @Wohlstand)
-Fix TheXTech modern mode bug where simultaneous slope-ground collisions were not handled properly (@ds-sloth)

Changelog for 1.3.6.2
-Fixed a crash on attempt to add a game directory after storage permission grant on Android (@Wohlstand)
-Added workaround for Little File Manager on Android (to open level file by content with no resources) (@Wohlstand)
-Fixed TheXTech 1.3.6.1 bug where error messages at the main menu would lock the game (@ds-sloth)
-Fixed an inability to parse LunaDLL Autocode files via MSVC builds of the game (@Wohlstand)
-Added experimental support for the Nintendo Wii U homebrew platform (@Wohlstand).
-Fixed audio not working when "/3ds/dspfirm.cdc" is missing on the 3DS (@Wohlstand).

Changelog for 1.3.6.1
-Fixed some of the performance slowdown problems using improved object spatial lookup tables (@ds-sloth)
-Fixed the work of Sound FX on big-endian architectures (@Wohlstand)
-Fixed directory creation flags on Vita (@suicvne)
-Minor fixes to the gameplay recording system (@Wohlstand, @ds-sloth)
-Changed the logic of the music pausing at the pause menu when P-Switch is active: don't suspend the entire sound stream, do suspend the music only (@Wohlstand)
-Added experimental support for the Nintendo Switch homebrew platform (@Wohlstand)
-Added experimental support for the Nintendo Wii homebrew platform (@ds-sloth - graphics and controls, @Wohlstand - audio and threading)
-Added CLI build of the application with very minimal dependencies, suitable for CI testing of the game logic (@ds-sloth)
-Added incomplete version of the Nintendo 3DS port (locked to 400x300 resolution until 1.3.7) (@ds-sloth)
-Added performance statistics (in debug info HUD) for level designers and developers to check CPU time spent on each game task (@ds-sloth)
-In-Game Editor: added ability to customize block, BGO, NPC, tile, music, section BG, and sound layouts in the editor (@ds-sloth)
-In-Game Editor: added new Magic Block feature that automatically picks the proper item given its context (@ds-sloth)
-Adjusted the bitmask to the RGBA conversion algorithm to apply the compromise among different semi-transparent textures (@Wohlstand)
-Fixed an invalid byte hacking behaviour at the memory emulator on x86_32 processors (@Wohlstand)
-Fixed the validation of  assets packages on Android where "introset"-based assets were treated as invalid (@Wohlstand)
-The new font engine based on the Moondust Engine implementation has been added. Now, the game can print Unicode text in a condition where the assets package contains the necessary font resources. (@Wohlstand, @ds-sloth)
-Added animation for keyhole exit. (@ds-sloth)
-Added ShowLevelName and ShowLevelFile LunaScript commands (@Wohlstand)
-An uncolored PCursor.png is now automatically colored and used for indicating player menu selections; MCursor0.png and MCursor3.png are used as fallbacks. (@ds-sloth)
-If controller inputs are displayed onscreen, Player 2's controller is now shown at the world map screen. (@ds-sloth, @0lhi)
-Controls: don't continuously rumble on player hurt after getting level exit NPC. (@ds-sloth)
-Added compatibility flags for multiple early vanilla bugfixes. (@ds-sloth)
-Added level exit cheats from SMBX2. (@SpencerEverly, @0lhi, @ds-sloth)
-Fixed an unexpected disappear of LunaScript-drawn text and graphics when a pause menu or a message box was open. (@Wohlstand)
-Added game save info (score, lives, coins, etc) display to the main menu screen. (@ds-sloth)
-Allow a single player to reconnect their controls at the menu screen. (@ds-sloth)
-In Magic Hand mode, cursor now snaps to current layer's grid, instead of global grid. (@ds-sloth)
-Fixed crash that could occur if player warped with >2P cheat active. (@ds-sloth)
-Correctly render large level graphics at the edge of the screen. (@Wohlstand, @ds-sloth)
-Miscellaneous improvements for the Emscripten experience on iOS (@ds-sloth)
-Fixed bug where touchscreen controller would stay active during text entry screen without rendering (@ds-sloth)
-Added an ability to place multiple stars at the same section using the Unique Star ID special value. (@Wohlstand)
-Added support for Discord Rich Presense support (need to enable it at the game settings). (@Wohlstand)
-Added the localisation system which allows you to translate engine into other languages than English. (@Wohlstand)
-Deep revision of the game's internal NPC and render logic, with up to 2x higher framerates on very large levels. (@ds-sloth)
-Fixed vanilla bug where player could be crushed by a sloped ceiling (@ds-sloth)
-Fixed vanilla bug where player could be crushed by a horizontally (not vertically) moving ceiling (@ds-sloth)
-Fixed TheXTech bug where a semi-transparent message box was not rendered correctly with a single-line messages. (@ds-sloth)
-Log messages now include timestamps relative to application start time. (@Wohlstand)
-Keyhole framerate fix will be enabled by default (@Wohlstand, @0lhi)
-Fixed vanilla bug where player could fall through an Instant/Portal warp while performing the "Pound" move. (@ds-sloth)
-Fixed vanilla bug where held item would not affect a hostile NPC that intersects with an immune NPC (such as an egg container). (@ds-sloth)
-Fixed vanilla bug where engine would appear to break if an event changed the boundaries of a different section. (@ds-sloth)
-Added modern animations for section boundary change in multiplayer. (@ds-sloth)
-The keyhole framerate fix has been turned on permanently, now it's impossible to disable this fix (@Wohlstand, @0lhi)
-Misc improvements for the level testing experience (@ds-sloth, @0lhi)
-Restyled pause menu user interface (@ds-sloth, @0lhi)
-Misc stability improvements (@Wohlstand, @ds-sloth)
-Fade out effect occurs during the last 30 frames of the SMBX64 death animation instead of during a pause following the animation (@ds-sloth)
-Added support for starting a level test from a certain warp (available in editor and command line flag -w / --start-warp) (@ds-sloth)
-Added support for starting a world with a specific save (--save-slot X) from the command line (@ds-sloth)
-In modern mode, pause speedrun timer during qScreen animation (game logic is frozen) (@0lhi, @ds-sloth)
-On attempt to start a level without start point or entrance warp specified, an error message will be shown (@Wohlstand)
-Update of controller disconnect user interface (@0lhi, @ds-sloth)
-Add a beta OpenGL renderer for the game, supporting proper bitmask (GIF) rendering (@ds-sloth)
-The pause menu is now able to be controlled by all players. (@ds-sloth, @0lhi)
-Multiple message boxes are now controlled by the player who originally triggered the event. (@ds-sloth)
-Added simple pre-processor that allows showing different message text depending on a playable characters (@Wohlstand)
-Updated scroll transition effect for warps; no longer pauses the game for other players. (@ds-sloth)
-Fix vanilla bug where NPC would never respawn if it came onscreen same frame as it had timed out. (@ds-sloth)
-Removed thextech.ini option to enter codes at pause menu; this ability is now unlocked by the input sequence LRLRRLRRRLRRRR (@0lhi, @ds-sloth)
-Removed TheXTech 1.3.6 exploit where dead player could be respawned for free by dropping then adding them (@ds-sloth)
-Removed "strict-drop-add" thextech.ini option (@ds-sloth)
-Removed deprecated global controls settings "ground-pound-by-alt-run", "enable-rumble", and "enable-battery-status". Set these per-profile in the controls menu. (@ds-sloth)
-In speed run mode, indicate whether Cheater mode is active by showing "CMode" instead of "Mode" in the top-right. (@0lhi)
-Fixed the version number being printed improperly via `--version` command-line argument. (@Wohlstand)
-Fixed TheXTech 1.3.6 bug where P2 would keep partial control during Single Coop (superbdemo2) and Cloned Player (superbdemoX) modes. (@ds-sloth)
-Fixed TheXTech 1.3.6 bug where 2P gameplay recordings might fail to replay correctly. (@ds-sloth)

Changelog for 1.3.6
-Added an ability to toggle drawing of the HUD and other on-screen meta data using F1 key (@Wohlstand)
-Added an ability to type cheats on touchscreen using special new cheats key (@Wohlstand, @ds-sloth)
-Added native support for LunaDLL Autocode script language (@Wohlstand)
-Added deaths counter feature (keeps counting of deaths per game save) (@Wohlstand)
-Reworked the controllers support (@ds-sloth)
-Touchscreen support for non-Android platforms (@ds-sloth)
-Added ability to save multiple keyboard profiles (@ds-sloth)
-New multiplayer start screen (@ds-sloth with design input from @0lhi)
-Added controller disconnect recovery screen (@ds-sloth)
-Ground pound by alt run is now a per-controller setting (@ds-sloth)
-Added an ability to add/drop the second player from the pause menu (@ds-sloth)
-Added the support for real-time audio effects such as reverb and SPC echo. They can be configured by sounds.ini for each level section (@Wohlstand)
-Performance improvements for showing, hiding, and moving layers (@ds-sloth)
-Reduced game object memory footprint (@ds-sloth)
-Performance improvements when run on slow filesystems (@ds-sloth)
-Fixed unexpected music got started after the level got entered too quick from the world map (@Wohlstand)
-Fixed the vanilla bug: a Player can stuck in the pipe when enters it being a fairy (@Wohlstand)
-Added an option to enable the fast walking on the world map (@ds-sloth, @Wohlstand)
-Added an ability to customize UI/common assets from the episode and level sides (@Wohlstand)
-Added a blink effect at speedrun timer on level/episode completion (@Wohlstand)
-Added an in-game editor based on the original game's editor code (requires EditorIcons.png asset) (@ds-sloth)
-Added config option to show the current episode's title onscreen (@ds-sloth)
-Fixed the clipped render of the Roto-Disk's effect (@Wohlstand)
-Fixed the lock/star sign behavior at locked two-way warps: now they work correctly at the opposite side (@Wohlstand)
-Added an ability to set a different path for the user directory by command line argument (@Wohlstand)
-Blocked an ability to start the game with no episodes or battle levels available in the list and prevented several issues with this (@Wohlstand)
-Added option to disable or always perform 2x texture scale down optimization (@ds-sloth)
-Added the ability to have multiple intro levels per assets pack (if introset directory exists and it contains at least one level file, they will be selected randomly every time when main menu opens) (@Wohlstand)
-Added game selection menu into Android launcher: every browsed assets directory will be remembered and can be accessed quickly using the new menu (@Wohlstand)
-Added the individual sound for Ludwig von Koopa's death (@Wohlstand)
-Added the individual sound for Larry Koopa's death and shell spinning after stomp (@Wohlstand)
-Fixed an improper new (when specific compatibility option is not disabled) behaviour of the Skull Raft when the head segment impacts a wall but loses a floor at the same time, causing the following segments to suspend forever (@Wohlstand)
-Fixed the issue of a possible fall through the floor if walking point-blank to a block that had an extracted bonus and another solid block placed under it (does not happen if the "fix-player-downward-clip" option was disabled) (https://github.com/Wohlstand/TheXTech/issues/401) (@Wohlstand)
-Removed the "require-ground-to-enter-warps" compat.ini option as redundant: there is the native option of LVLX and 38A-LVL level formats to enable this behaviour. (@Wohlstand)
-Some options of the compat.ini have been renamed (for backward compatibility, there are aliases kept) (@Wohlstand)
-Added the individual sound for Link's iceball shoot (@Wohlstand)
-Added the proper sound for Link's fireball shoot (@Wohlstand)
-Fixed TheXTech bug where if a moving layer stopped while a player was climbing a BGO, the player would keep moving. Also added bugfix for corresponding vanilla bug that occurred if a player was climbing a moving layer NPC. (@ds-sloth)

Changes for 1.3.5.3-1
-Fixed autostart events behaviour

Changes for 1.3.5.3
-Fixed the vanilla crash: Attempting to freeze any Pokey segments when they have the "noiceball=0" option set will cause the out-of-range error with NPC-ID=-3 in a random moment. (https://github.com/Wohlstand/TheXTech/issues/220)
-Changed the user directory location for macOS-built games into the "~/TheXTech Games/<bundle name without .app suffix>/" to avoid conflict between different games ran on the same device.
-Changed the debug assets location on macOS into "~/TheXTech Games/Debug Assets/" to simplify the debug environment installation.
-Fixed BGO-65, Bowser III, and rail platforms compatibility with SMBX build version up to 30
-Fixed the false positive that enables the Yoshi Mode of music when a player actually doesn't ride any Yoshi
-Mario and Luigi will be only available at episodes built with SMBX older than build version 30 (the first version that introduces Peach, Toad, and Link)
-Fixed the invalid vertical offset while drawing a playable character sprite
-Resolved the old jittering problem when drawing a playable character while moving the camera (thanks to @ds-sloth for the fix)
-Fixed the minor graphical distortion of a playable character that appears while flying up and down with a shoe.
-The last played episode will be reminded and scrolled at the episode selection menu
-Improved episodes menu control: added mouse wheel, page-up/page-down/home/end/delete, and left/right/alt-run/alt-jump/drop on controllers to scroll episodes lists
-Fixed the vanilla bug: episodes list menu gets reset every attempt to go back from the character or the game save slot select menu
-Fixed the soft-lock in an attempt to erase the gamesave using the two-player game menu
-Order of episodes lists now alphabetical
-Added the "compat.ini" option to require players to be on the ground to enter warps
-On-screen elements such as HUD and other printing debug information will not shake with in-game happenings
-Added screen fading effects at the world map and levels
-Added support for different transition effects per every warp entry
-Fixed the vanilla bug: The deadlock in the form of a looped message box showing will happen in the condition: the first NPC activates another NPC using recursive activation of all touching NPCs. And when the second NPC has an on-activation event trigger that hides its layer and shows a message box
-Fixed the unexpected Wart's death sound spam

Changes for 1.3.5.2
-Fixed the ARM64 building
-Updated the log writer
-Disabled the "Boss Dead" event hook to stop the episode speed-run timer by default, added the compat.ini options to enable and configure it
-Fixed the unexpected Swooper flap sound played after the Swooper has gone far away
-Fixed the vanilla bug: The Swooper has avoided being started to fly when inactive
-Added the compatibility level command line option separated from the speed-run modes (However, the speed-run mode will still override the compativility level)
-Added an option to enable the background game controller input handling
-Portal warps have been allowed to be used for level entrances and level exits (Instant warps kept unsupported to avoid possible compatibility issues)
-Added the cannon pipes that can shoot the player with a given speed
-Added the workaround for custom background2-42 that has non-multiple 4 height (there are several custom sprites with the 3455 invalid height, they must be 3456)
-Fixed an incorrect speed-run timer render at multiplayer mode
-The controller state print has been replaced with a controller drawing to indicate the pressure state of buttons
-Added the opt-in 2x scale down optimization for all textures to reduce the memory usage
-Fixed the confusion when using the modern section auto-scroll settings when an auto-scroll fix was disabled
-License was changed into GPLv3 (see details: https://github.com/Wohlstand/TheXTech/issues/162)
-Enabled the work on the Android TV
-Fixed the game start error after granting the storage permission on Android 9 and lower
-Added an ability to change the look of the launcher screen on Android via gameinfo.ini (Change the logo, change the background, and set up the simple animation)
-Added mask fallback support for custom graphics mask compatibility for old episodes
-Fixed vanilla bug: Attempt to enter the locked warp or take the star with star-locked warp the game will crash if a level has no BGO at all
-Make turn blocks (block-90) work as bricks when SMBX19 and lower level file version is open
-Added a workaround for the yellow platform (NPC-60) at "The Invasion 1" episode where it won't move at level42
-Added Billy Gun (NPC-22) behavior compatibility with SMBX 1.2 and 1.1.x and older file formats
-Added wireless game controllers battery status displaying when enabled at the settings
-Added device battery status displaying at the right-top corner when enabled at the settings
-Fixed an inability to save the game when game assets were stored at SD Card on an Android device
-Added support for gamecontrollerdb.txt at the assets root and at the user directory
-Fixed vanilla bug: World map music won't resume after going through the warp that leads to no music points or the music point with the same song
-Fixed the improper custom music change when going through the warp on the world map
-Fixed vanilla bug: Offscreen NPC can now respawn during the stopwatch freeze
-Added Thwomp (NPC-37) behavior compatibility with SMBX 1.0.x
-Added the Yoshi mode support for specified songs at the music.ini: mute selected track number without Yoshi, enable it back when Yoshi is presented
-Fixed a bug when a last world map music is not remembered when sound is disabled
-Fixed the wrong restart place when running the lasanha of levels and "restart level after death" option is enabled
-Fixed the NPC logic distortion caused by early gfx update
-Added an ability to customize an outro behaviour using gameinfo.ini
-Battle mode access can be disabled via gameinfo.ini
-Two-player game mode access can be disabled via gameinfo.ini
-The Scores of Power-Ups (NPC-9, NPC-14, NPC-34, NPC-169, NPC-170, NPC-182, NPC-183, NPC-184, NPC-185, NPC-249, NPC-250, NPC-264, NPC-277) can be changed via npc-X.txt
-Added a fixed behavior for rail platforms and grinder (NPC-60, NPC-62, NPC-64, NPC-66, NPC-104, NPC-179). It can be enabled using new-added custom values
-Fixed the collision bug when an attempt of the player with the shoe to jump up at the moving NPC being pushed into the wall, causes the player to go through the wall
-The settings/thextech.ini config file will be created on the first launch if not exist

Changes for 1.3.5.1
-Episodes and battle levels lists now loading in the separated thread with a progress showing
-Fixed the regression caused world map music not being switched properly
-Added an ability to control the intro scene activity on the level by `gameinfo.ini`: set maximum number of running players, and enable/disable the activity at all
-Fixed an inability to copy the game save based on old files at episode directory
-Fixed the vanilla bug: incorrect blooper effect when stomped (needed an npc-*.txt with the "jumphurt=0" flag being set)
-Changed the default compat.ini value "fix-autoscroll-speed" into "false" to prevent possible glitches from invalid setup given by several old levels
-The "Checkpoint" sound will be played when selecting the "Save and Continue" menu item at the pause menu
-Fixed a minor glitch at the game save copy and erase menu while moving the mouse under menu block
-Fixed the bullet bill getting stuck after it got unfrozen (Thanks to the @ds-sloth for the contribution!)
-Updated an inter-process protocol with adding new commands
-Fixed the vanilla bug: The dragon coin has avoided being turned into the block by the P-Switch activation

Changes for 1.3.5
-Fixed the gamepad control stuck because of axes returned value that doesn't equal the initial state on some devices
-Fixed the invalid conversion of old sprites with a mask that is smaller than the front
-Implemented usage of the SDL_GameController with some extras like using the rumble and the battery status (Render of the status is not implemented yet)
-Player now can quit the credits screen by pressing the Start button on the gamepad
-Fixed the glitched rendering of the first frame at the main menu and at the world map when frame-skip is enabled
-Every gamepad model will keep its individual settings per player
-Added the "Reset to default" menu item to reset controls
-Resolved the slow work of the world map on weak devices
-Added the performance debug printing that you can activate by the F3 key
-Automatically select the gamepad on startup if the user didn't manually set up the keyboard usage
-Added the ability of the hot connection and disconnection of game controllers
-Control mappings have been moved into the "controls.ini" to keep the "thextech.ini" file being human-friendly
-Swooper can play the flap sound if presented at the assets pack
-Iceball may have the individual shoot sound of sounds.ini enables that
-Fixed an unexpected ability of Peach to spin-jump from off vines and on pressing of the ALT-JUMP while the JUMP key is held
-Fixed the GFX shaking of the upside-down piranha plants when they got customized in some cases
-NPC freezing sound got an individual sound instead of the shell hit
-Frozen NPC breaking got an individual sound
-Added an ability to put the silence instead of the actual sound file by specifying the "silent=true" field instead of the "file=..."
-Thwomps will slightly shake the screen on their fall
-Yoshi's ground pound will slightly shake the screen
-Sprout vine from blocks got an individual sound
-Fixed an incorrect word wrapping at message boxes
-Fixed the vanilla GFX bug: the thwomp's ground pound dirt effect being improperly aligned
-Bowser III'rd will shake the screen on his ground pound
-Fixed the vanilla bug: Link may die when attempting to use the Clown Car being in a fairy form, and when flying up on the Clown Car while any vines behind him
-Avoided the ability to switch the playable character by the Clown Car at the top of a player switch block
-Added an ability to restore old checkpoints behavior of the SMBX 1.3 using the "compat.ini" file
-Fixed the vanilla GFX bug: an incorrect Link's alignment at the Clown Car after being transformed from anybody who rides Yoshi
-Fixed the skull raft getting stuck at the ceiling slope blocks
-Fixed the vanilla GFX bug: the unexpected water splash effect appearance at BGOs
-Fixed the inability to set up the jump button on gamepads in some conditions
-Fixed the vanilla bug: inability to set the autoscrolling for any non-zero section
-Added the support for the simple-style per-section autoscrolling setup from the SMBX-38A specification
-Fixed the vanilla crash when NPC being located far off the screen, tries to find blocks
-Added an ability to copy and delete game saves from the game menu
-Fixed the missing "Game Beaten" flag while loading the game save

Changes for 1.3.4
-Fixed the inability to use any custom sounds and custom music at level's custom data directory
-Added an ability to change sound setup (sample rate, channels, sample format, and the buffer size) via the [sound] INI section
-Optimized the work of a lazy-decompression algorithm workflow
-At credits, the bible quote has been replaced with a meme
-Fixed the vanilla bug: free-falling platforms getting confused when the player changes their power-up state
-Fixed an inability to autostart events when "restart level after death" mode is enabled on the world map
-Fixed the case when Pokey getting collapsed during walking on slopes
-Fixed an unwanted player bounce by a filter block after NPC stomp
-Added the "compat.ini" support for episode and level specific to enable/disable certain bugs of the old game
-Fixed the vanilla bug: player can get clipped into floor while standing on a block of a down-moving layer
-Fixed the vanilla bug: NPC can get clipped into floor while standing on a block of a down-moving layer
-Fence BGOs now can move player together with a moving layer as vine NPCs does
-Fixed the vanilla bug: attempt of player to jump from NPC standing together with getting pushed into the wall causes the clipping
-Fixed the vanilla bug: resolved an incorrect behavior of a skull raft cells that makes the raft being squished when reaching a barrier wall
-Credits look and performance has been improved
-Fixed the vanilla bug: Peach can't escape the running shell surf
-Loading screen now goes smoother (except Emscripten)
-Level testing will quit on success completion of a level
-Improved the framerate controller behavior, added the guarantee of the 65.1025 FPS on almost all supported platforms
-Added the Speed-Runner mode which can be enabled via the --speed-run-mode <mode> command line argument
-Fixed an wrong FPS while the key-hole exit is in process
-Improved the frame-skip logic

Changes for 1.3.3.1
-Fixed a crash, caused by the incremental locked warps counter that leads BGO array exciting
-Added support for Windows ARM64 target architecture
-Added support for Apple Silicon target architecture
-Fixed the inability to enter levels through warp were extension is missing

Changes for 1.3.3
-Added the "gameinfo.ini" to give the support for the partial customization of internals (window/game title, character names in menu, credits, etc.)
-Added an ability to globally override NPC settings by placing of npc-*.txt file into graphics/npc directlry of assets
-Added an ability to run executable with a different assets directory specified
-Added the support for playable character custom INI calibrations
-Message box line breaking algorithm has been improved, added support for new-line characters
-Settings now can remember the initial state of the frame-skip and show-fps options
-Added an option to make use the Alt-Run key for Yoshi's Ground-Pound ([gameplay] section and 'ground-pound-by-alt-run' boolean field)

Changes for 1.3.2.4
-Allow music change for outro level (if outro level has non-silent music, it will be played instead of built-in)
-Allow unlimited count of episodes and battle levels
-Fixed an incorrect effect frames count rounding, caused glitches at the death effect for a Hammer Bros.
-Corrected the sensitivity of axes-based sticks of game-pads to prevent the mystery, caused by value errors

Changes for 1.3.2.3
-Fixed a SIGFPE crash, caused by an attempt to load some custom effects
-Resolved the inability to grab vegetables normally, caused by an incorrect porting of logical expression

Changes for 1.3.2.2
-Fixed an incorrect computation of effect sizes, caused by a missing part of code

Changes for 1.3.2.1
-Reworked joysticks support
-Added a workaround for case-sensitive file systems
-The 1up sound now playing multiple times if the player has got more than 1 life (for example, a 3-up moon)
-Fixed a broken work of magic potion warp packed inside of a grass container
-Fixed a minor inaccuracy of the moving layers system
-Fixed an incorrect process of blocked playable characters while loaiding the episodes list


Changes for 1.3.2
-Added an own timeout sound-92 for P-Switch timer (will be played with 3 seconds before the end)
-Added a level testing interprocess interface to work with PGE Editor
-Fixed the Podoboo's tail effect glitch
-Fixed an incorrect priority of BGO65 in the level file of SMBX prior to 10 format
-Fixed a classic Bowser's behavior in "The Invasion 1" episode from SMBX 1.0.x
-Removed 20 layers limit to show/hide/toggle per event
-Extended limit to use up to 200 sections in one level
-Added an error message on attempt to open an invalid level file
-Fixed a glitch of the rendering of the two-camera screen caused by an incorrect SDL_RenderSetViewport() call usage


Changes for 1.3.1 (First version made by Wohlstand in March 2020):

Technical stuff
-The whole code has been ported into C++, taking use of libFreeImageLite, SDL2, and MixerX.
-Built-in Editor has been removed in favor of PGE devkit
-Full support of UTF-8 in filename paths and internal text data (original game had the only 8bit ANSI support).
-For graphics and controlling, it uses an SDL2 library while original game have used WinAPI calls and GDI library.
-It uses PGE-FL that has a better file formats support.
-A support for WLDX world maps are allowing unlimited credits lines and custom music without necessary to use a music.ini for music replacements.
-Some LVLX exclusive features now working: vertical section wrap, two-way warps, custom "star needed" message, warp enter event, ability to disable stars printing in HUB episodes for specific door, ability to disable interscene showing when going to another level through a warp.
-Built-in support for episide and level wide music.ini and sounds.ini to override default music and sounds assets.
-World maps now supports a custom directory to store any specific resources like custom tiles/scenes/paths/levels and don't spam the episode root folder with wolrd map resources anymore.
-Default config format is INI, old config.dat format is no more supported, mainly because of incompatible key code values (SDL_Scancode versus VirtualKeys enum of Windows API).
-Game saves now using the SAVX format instead of a classic SAV. However, if you already have an old gamesave, you still can resume your game with using of a new engine now (next gamesave attempt will result a SAVX file, old gamesave in SAV format will be kept untouched).
-Game saves now saving in the "settings/gamesaves" folder instead of episode root to allow them be read-only.
-Built-in PNG support for custom and default graphics. Masked GIFs are still supported for backward compatibility, however, without making an unexpected auto-conversion.
-Checkpoints now multi-points! You can use them in your levels multiple times without limits!
-Make the use of lazy-decompress algorithm to speed-up the loading of a game and reduce the whole memory usage.
-For music and SFX, the MixerX library is used to give a support for a wide amount of sound and music formats!
-It doesn't embeds any graphics: here is NO any trurely hardcoded graphics, everything now representing as an external graphics!
-Some internal limits was been expanded.
-Built-in GIF recorder by F11 key (F10 on macOS, F11 is reserved by system UI for a "show desktop" action)

Bugfixes
-Fixed a crash when mushroom falls into the lava
-Fixed a division by zero error caused by match of player and Venus Firetrap NPC centers
-Fixed an unnecessary ability to climb invisible fences
-Fixed a mystical speed-adding while climbing fences, caused by after standing on any moving layers
-Attempt to fix the level data initialization which was been incomplete and caused various issues like incorrect position of moving layers



Super Mario Bros. X Changelog.

Changes for 1.3 (last version made by Redigit in October 2010):

Players
-Peach, Toad, and Link can now make use of the Leaf, Tanooki Suit, and Hammer Suit power-ups.
-Toad can spin jump.
-Link now moves a little bit quicker.

Misc.
-Quicksand
-Attach Layers to NPCs
-Fleet Glide Galaxy Music
-SMW Desert Night Background
-Block Fill Tool
-NPC Text Preview
-Custumizable NPCs
-Screen Shot capturing (F12)
-Slippery Blocks
-Battle Mode
-NPC generators can now be up to 60 second delay

New Items
-Ice Flower
-Bubbles
-SMB2 Door Potion
-Propeller Block
-Flame Thrower
-Dragon Coins
-? Mushroom
-Random Power-ups
-Toad's Boomerang
-Peach's Heart Bombs.

New Enemies
-Roto-Disc
-Firebar
-Nipper
-Mouser
-Larry Koopa
-Ludwig Koopa
-Swooper
-Hoopster
-Volcano Lotus
-SMW Lakitu (with the ability to choose what he throws)
-SMW Spineys



Changes for 1.2.2:

Players
-Link has been added as a playable character.
-Toad has been added as a playable character.
-Peach has been added as a playable character.
-Mario and Luigi no longer automatically drop their reserve item when hurt.

NPCs
-The Silver SMW P-Switch has been replaced with a Green SMB3 P-Switch
-All times stop effects play the SMB3 switch song
-Added green, blue, and red rupees.
-Added the heart piece.
-Added the fairy pendant that turns the user into a fairy.
-Added the SMB2 mushroom.
-Added a Zelda 2 style lock.
-Turtle shells now have a 'spark' effect when kicked/hit.
-Red Yoshi fireballs no longer die when they hit an enemy.
-Added a blue SMW coin that is worth 5 coins.
-Fireballs have a different smoke effect when they 'die.'
-Added a giant Piranha Plant that takes multiple hits to kill.
-Max time for NPC generators has been raised to 60 seconds.
-NPCs in the level editor are now animated.

Blocks
-Added blocks that change the player's character when hit.
-Added blocks that only allows specific characters through them.
-The SMB2 cracked block now has it's own smash graphic.

Misc
-The game window is now resizable.
-Playable characters can be blocked in the world editor.
-The player can switch characters on the world map by pressing pause and then tapping left or right.
-The editor now shows what is inside blocks.
-The debugger displays information about what NPCs are in the level.
-You can now use PageUp and PageDown to change your current section in the editor.
-There is now a menu option that brings up the help file.
-The Level Settings tab no longer defaults to the level size cursor.
-When using custom graphics, the icons in the editor now show the correct picture.
-Added an option to play the game without sound.
-Added an option to turn of the frame skip.
-The editor now shows the contents of Eggs and Burried Items.

Bug Fixes
-Fixed a bug that would cause sound/music not to load in the game.
-Fixed the bug that caused NPCs to get 'smashed' when they shouldn't have.
-The level background is now drawn correctly when the screen splits horizontally.
-Several small bug fixes.

Cheat Codes
-Added 'anothercastle'
-Added 'ibakedacakeforyou'
-Added 'iamerror'
-Added 'fairymagic'



Changes for 1.2.1:

Engine Updates
-NPCs can now be crushed by moving blocks.
-Added SMB2 throw sound for SMB2 enemies that are thrown.
-You are now given the option to chose between Mario and Luigi in 1 player mode.
-Cheat codes are now back in the main game, but you can no longer save after using them.
-You can no longer save the game while playing a level.
-Added the cheat code wetwater.
-Added the cheat code istillplaywithlegos.
-The cheat sonicstoslow has become sonicstooslow.
-Added the cheat code itsrainingmen.
-Added the cheat code donttypethis.
-Several cheat codes have been fixed.
-The test settings window has been updated to include the new power ups.
-The hot box for lava tiles has been pushed down by 6 pixels.
-Now you can use the mouse to select the options on the menu screen.
-Hit detection is now a little bit more lenient when deciding if a player should be hurt by an NPC.
-Added the cheat code needaclock.
-Added the cheat code powhammer.
-Revived the cheat code imtiredofallthiswalking.

Player
-The player now sticks to downward slopes instead of falling over them. This should make it easier to jump over cliffs when running down a slope.
-There is now a brief animation and delay when picking things up SMB2 style.
-The player now spins while shell surfing.
-The player no longer falls off a shell when it bounces off a wall.
-The player can now grab shells from above.
-The player now has walking animations when using a warp pipe.
-The player can now swim upward fast by holding up while swimming.
-The distance needed to fly was shortened very slightly.
-Luigi's fireballs now go up steep slopes.
-Luigi's controls have been tightened slightly.
-When the first player is Luigi, he appears instead of Mario on the world map.
-The player gets a slight speed boost when running down a slope.
-Yoshi will be returned to you after you complete a level that takes him away.
-Dead players no longer spawn from blocks containing the Hammer Suit or Tanooki Suit.
-Luigi now causes all the coins to pop out of coin blocks after he hits them.

NPCs
-The SMW Goomba and SMB3 Bob-omb have been updated to more accurately reflect the games they're from. SMB3 Bob-ombs go farther when kicked.
-Boom Boom now has a brief period of immunity when hit by objects. This stops him from being insta-killed.
-After a veggie has been thrown up it will change speed if it hits an enemy. This prevents a single veggie from killing bosses.
-The smashed Rex and Mega Mole now move faster. The SMB1 and SMW 1-ups now move the correct speed.
-The Ice Block now melts 7 seconds after being picked up, unless thrown.
-Only bosses now give points when falling into lava.
-Wart now gives the correct amount of points when killed.
-SMB1 Bowser now has a more predictable hammer throwing pattern.
-NPCs now have walking animations and will walk out of a pipe when spawned with a warp generator.
-Grass and turnips now have a higher pitched grab sound.
-SMW saws now make the 'ticking' sound when on screen, are drawn behind blocks, and only stick out of the ground halfway.
-Thwomps now create 'smoke effect' after hitting the ground.
-The Ice Block now breaks bricks when thrown up.
-Switch goombas and platforms have been recolored to match the SMW switch blocks.
-Paratroopas set to hover left/right now flutter up and down.
-Yoshi, Kuribo's shoe, and several other power-ups can now be off screen for 60 seconds before being reset.
-The off screen timer of shells now resets after they break a block. Now you don't have to supervise them to make sure they are doing there job.
-Sonic rings have been changed to a graphic style that fits the game better.
-Mr. Saturn is now indestructible.
-Blaarg's hit box has been fixed.
-The Clown car now checks for collisions against blocks.
-Added a silver P Switch that stops time for a short while when hit.
-Added a red switch used for triggering events.
-Added the stop watch from SMB2.
-Added the POW block from SMB2.
-Added the brown Paragoomba from SMB3 with Paratroopa AI.
-Added the Paragoomba from SML2 with Paratroopa AI.
-Added the goomba from SML2.
-Added the venus fire trap from SMB3
-Added pokey from SMB2.
-Added the stop watch power-up.

Blocks
-Digable dirt now behaves correctly.
-Munchers hurt from all sides.
-SMW switch blocks have been recolored to look like they did in SMW.

Backgrounds
-SMW Ghost House background is now animated.
-SMW Castle background is now properly animated.

Bug Fixes
-Fixed a bug that stopped the game from actually skipping frames when it was supposed to.
-The yellow Yoshi now correctly ground pounds enemies on slopes.
-The world map no longer unloads custom graphics after playing a level.
-The Billy Gun and Hammer Bros. no longer keep shooting when the player loses control of himself.
-The game more accurately decides which block the player should stand on while on multiple blocks. This mainly affects note blocks.
-Fixed a bug that would push the player through blocks when standing on a falling block. (As seen in the last fight of The Invasion 2)
-The game no longer freezes when using events to takeover the players controls and opening a message window.
-The player can no longer climb vines while in Tanooki form.
-NPC speed is now calculated correctly when walking on another NPC while underwater.
-Checkpoints now work on episodes that use a hub world.



Changes for 1.2:

Engine Updates
-Sloped tiles have been fully implemented, including the ability to slide down slopes.
-New "projectile" spawn point that allows NPCs to be shot out of pipes.
-Updated the graphics engine, allowing for custom graphics.
-Spikes only hurt when hit from the correct angle
-Keys can be used to unlock doors.
-Swimmable water has been implemented.
-The title screen now plays a level.
-You can now use events to move layers.
-Added online level edit mode.
-Cheat codes now only work in the level editor.
-Added auto frame skip.

Players
-Added the Tanooki Suit.
-Added the Hammer Suit.
-Added Fire Shoe Power-up that turns stomped enemies into fireballs and allows the wearer to walk on lava.
-Added Blue Shoe Power-up that allows the wearer infinite flight.
-There is a longer delay between eating enemies with Yoshi.
-You can no longer spit and eat a shell in midair to fly indefinitely.
-The player now needs to run longer before he can fly.
-Players now "slide" when spit out of Yoshi.
-Players can use lives to come back to life instantly in 2 player mode.

Tiles/Backgrounds
-Added cave tiles and two backgrounds (SMB3)
-Added Mystic Cave Zone background (Sonic 2).
-Added the underwater block (SMB1).
-Added sloped grass (SMW, SMB3, SMB2) and cave (SMW, SMB3 & SMB1) tiles.
-Added castle tiles and background (SMB1).
-Added several tiles (SMB1) (SMB2).
-Added coral block (SMB1).
-Added fence and tree backgrounds (SMB1).
-Added several castle tiles and backgrounds (SMW).
-Added various blocks (SMW).
-Added multiple lava tiles (SMW).
-Added Ghost House background (SMW).
-Added Wart's Throne Room tileset (SMB2).
-Added several new Super Metroid tilesets.
-Added 2 Super Metroid backgrounds.
-Added clouds background (SMB2).
-Added several new blocks. (Multiple)
-Added six backgrounds. (SMB1 & SMB2)
-Add table and chair background objects. (SMA4)
-Added underwater backgrounds. (SMB3, SMW)
-Added water dirt blocks (SMB3)
-Added giant wood blocks (SMB3)
-Added giant coral (SMB3)
-Added water backgrounds objects (SMB1, SMB3)
-Added bubble background.
-Added the frozen coin and chomper blocks.

NPCs
-Added Goomba and Paragoomba (SMW).
-Added Rex (SMW).
-Added Mega Mole (SMW).
-Added Poison Mushroom (SMB).
-Added rings that act like coins (Sonic the Hedgehog)
-Added Mushroom Blocks (SMB2).
-Added Digable Dirt (SMB2).
-Added flying Airship part (SMB3).
-Added Mister Saturn (Earthbound).
-Changed the Cheep Cheep (SMB1) to die when jumped on.
-Blue Beach Koopas (SMW) can now kick Ice Blocks (SMB3).
-Added Bullies (SM64). Sprites by LuigiFan.
-Thwomp and the Boos can now be killed.
-Added both normal Koopas and Parakoopas (SMB1)
-Added Axe, which dies on contact with the player, that can be used to start events. (SMB1)
-Added Thwomp (SMW)
-Added Grinder (SMW)
-Added Dry Bones. (SMW)
-Added Mushroom, Fire Flower, 1-Up, and 3-Up Moon (SMW) (SMB1).
-Added skull ride. (SMW)
-Added the Rainbow shell, which when hit by a tail becomes a powerful item and allows Mario to ride it. (SMW)
-Added Princess Peach. (SMB3)
-Added collectible stars that don't end the level. (SMW)
-Add the King Koopa. (SMB1)
-Added Wart (SMB2)
-Added Spark (SMB2).
-Added 3 Super Metroid monsters.
-Added Spike Top (SMW).
-Added Mother Brain
-Added Green Cheep Cheeps (SMB1, SMB3)
-Added Red Cheep Cheeps that jump out of the water at the player (SMB3)
-Added Bloopers (SMB1, SMB3)
-Added some misc. Sushi from SMW
-SMB2 enemies are now immune to fireballs
-Podoboos are immune to fire and no longer kill enemy NPCs
-Yoshi now run away faster when the player is hit.
-The Billy Gun now shoots roughly twice as fast.

World Map
-Added several tiles and scenery objects (SMW).
-Ability to choose start point.
-Added level path background options.
-Added several level icons. (SMBA4) (SMB3) (SMW
-Instant warp zones.
-Player faces the direction he is walking.
-Added new levels and path graphics.

Music
-Added Meta Knight's Revenge (SSBB).
-Added Castle music (SMW).
-Added Castle music (SMB1).
-Added Wart battle music (SMB2).
-Added Item Room music (Super Metroid).
-Added Underwater music (SMB1, SMB3, SMW, SM64)
-Added Waluigi Pinball and SSBB Underground themes.
-Added SM64 cave theme.
-Added SMB3 hammer bros. theme.

Bug Fixes
-The player now correctly changes sections when he enters a door while standing on a NPC.
-Fixed a bug that would cause the map to scroll to a location other then 0, 0 when changing modes to the world editor.
-Added an auto-align toggle to the world editor.
-Fixed several bugs with the conveyor belts.
-Exits no longer despawn when they go off-screen.
-World editor now plays sounds when the user saves and erases the map.
-Player stops ducking when leaving a vertical pipe warp.
-Spin Jump has been toned down.
-Platform now properly pass through cross sections.
-Fixed a bug that prevented music from playing in the 'intro.lvl"
-P switch is no longer linked to music.


================================================
FILE: cmake/TargetArch.cmake
================================================
# Based on the Qt 5 processor detection code, so should be very accurate
# https://qt.gitorious.org/qt/qtbase/blobs/master/src/corelib/global/qprocessordetection.h
# Currently handles arm (v5, v6, v7), x86 (32/64), ia64, and ppc (32/64)

# Regarding POWER/PowerPC, just as is noted in the Qt source,
# "There are many more known variants/revisions that we do not handle/detect."

set(archdetect_c_code "
#if defined(__arm__) || defined(__TARGET_ARCH_ARM) || defined(__ARM_ARCH)
    #if defined(__ARM_ARCH_8__) \\
        || defined(__ARM_ARCH_8A) \\
        || defined(__ARM_ARCH_8A__) \\
        || defined(__ARM_ARCH_8R__) \\
        || defined(__ARM_ARCH_8M__) \\
        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 8) \\
        || (defined(__ARM_ARCH) && __ARM_ARCH >= 8)
        #error cmake_ARCH arm64
    #elif defined(__ARM_ARCH_7__) \\
        || defined(__ARM_ARCH_7A__) \\
        || defined(__ARM_ARCH_7R__) \\
        || defined(__ARM_ARCH_7M__) \\
        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 7) \\
        || (defined(__ARM_ARCH) && __ARM_ARCH >= 7)
        #error cmake_ARCH armv7
    #elif defined(__ARM_ARCH_6__) \\
        || defined(__ARM_ARCH_6J__) \\
        || defined(__ARM_ARCH_6T2__) \\
        || defined(__ARM_ARCH_6Z__) \\
        || defined(__ARM_ARCH_6K__) \\
        || defined(__ARM_ARCH_6ZK__) \\
        || defined(__ARM_ARCH_6M__) \\
        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 6) \\
        || (defined(__ARM_ARCH) && __ARM_ARCH >= 6)
        #error cmake_ARCH armv6
    #elif defined(__ARM_ARCH_5TEJ__) \\
        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 5)
        #error cmake_ARCH armv5
    #else
        #error cmake_ARCH arm
    #endif
#elif defined(_M_ARM64) || defined(__aarch64__)
    #error cmake_ARCH arm64
#elif defined(_M_ARM_ARMV7VE)
    #error cmake_ARCH armv7
#elif defined(_M_ARM) || defined(__arm__) || defined(_ARM)
    #error cmake_ARCH arm
#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
    #error cmake_ARCH i386
#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
    #error cmake_ARCH x86_64
#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
    #error cmake_ARCH ia64
#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) \\
      || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \\
      || defined(_M_MPPC) || defined(_M_PPC)
    #if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
        #error cmake_ARCH ppc64
    #else
        #error cmake_ARCH ppc
    #endif
#endif

#error cmake_ARCH unknown
")

# Set ppc_support to TRUE before including this file or ppc and ppc64
# will be treated as invalid architectures since they are no longer supported by Apple

function(target_architecture output_var)
    if(APPLE AND CMAKE_OSX_ARCHITECTURES)
        # On OS X we use CMAKE_OSX_ARCHITECTURES *if* it was set
        # First let's normalize the order of the values

        # Note that it's not possible to compile PowerPC applications if you are using
        # the OS X SDK version 10.6 or later - you'll need 10.4/10.5 for that, so we
        # disable it by default
        # See this page for more information:
        # http://stackoverflow.com/questions/5333490/how-can-we-restore-ppc-ppc64-as-well-as-full-10-4-10-5-sdk-support-to-xcode-4

        # Architecture defaults to i386 or ppc on OS X 10.5 and earlier, depending on the CPU type detected at runtime.
        # On OS X 10.6+ the default is x86_64 if the CPU supports it, i386 otherwise.

        foreach(osx_arch ${CMAKE_OSX_ARCHITECTURES})
            if("${osx_arch}" STREQUAL "ppc" AND ppc_support)
                set(osx_arch_ppc TRUE)
            elseif("${osx_arch}" STREQUAL "i386")
                set(osx_arch_i386 TRUE)
            elseif("${osx_arch}" STREQUAL "x86_64")
                set(osx_arch_x86_64 TRUE)
            elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
                set(osx_arch_ppc64 TRUE)
            elseif("${osx_arch}" STREQUAL "arm64")
                set(osx_arch_arm64 TRUE)
            elseif("${osx_arch}" STREQUAL "arm")
                set(osx_arch_arm TRUE)
            else()
                message(FATAL_ERROR "Invalid OS X arch name: ${osx_arch}")
            endif()
        endforeach()

        # Now add all the architectures in our normalized order
        if(osx_arch_ppc)
            list(APPEND ARCH ppc)
        endif()

        if(osx_arch_i386)
            list(APPEND ARCH i386)
        endif()

        if(osx_arch_x86_64)
            list(APPEND ARCH x86_64)
        endif()

        if(osx_arch_ppc64)
            list(APPEND ARCH ppc64)
        endif()

        if(osx_arch_arm)
            list(APPEND ARCH arm)
        endif()

        if(osx_arch_arm64)
            list(APPEND ARCH arm64)
        endif()
    else()
        file(WRITE "${CMAKE_BINARY_DIR}/arch.c" "${archdetect_c_code}")

        enable_language(C)

        # Detect the architecture in a rather creative way...
        # This compiles a small C program which is a series of ifdefs that selects a
        # particular #error preprocessor directive whose message string contains the
        # target architecture. The program will always fail to compile (both because
        # file is not a valid C program, and obviously because of the presence of the
        # #error preprocessor directives... but by exploiting the preprocessor in this
        # way, we can detect the correct target architecture even when cross-compiling,
        # since the program itself never needs to be run (only the compiler/preprocessor)
        try_run(
            run_result_unused
            compile_result_unused
            "${CMAKE_BINARY_DIR}"
            "${CMAKE_BINARY_DIR}/arch.c"
            COMPILE_OUTPUT_VARIABLE ARCH
            CMAKE_FLAGS CMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
        )

        # Parse the architecture name from the compiler output
        string(REGEX MATCH "cmake_ARCH ([a-zA-Z0-9_]+)" ARCH "${ARCH}")

        # Get rid of the value marker leaving just the architecture name
        string(REPLACE "cmake_ARCH " "" ARCH "${ARCH}")

        # If we are compiling with an unknown architecture this variable should
        # already be set to "unknown" but in the case that it's empty (i.e. due
        # to a typo in the code), then set it to unknown
        if (NOT ARCH)
            set(ARCH unknown)
        endif()
    endif()

    set(${output_var} "${ARCH}" PARENT_SCOPE)
endfunction()


================================================
FILE: cmake/build_props.cmake
================================================
# ============================ Generic setup ==================================
# If platform is Emscripten
if(${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten")
    set(EMSCRIPTEN 1 BOOLEAN)
    unset(WIN32)
    unset(APPLE)
endif()

if(APPLE AND CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 9)
    message("-- MacOS X 10.4 Tiger detected!")
    set(XTECH_MACOSX_TIGER TRUE)
endif()

# =========================== Architecture info ===============================

include(${CMAKE_CURRENT_LIST_DIR}/TargetArch.cmake)
target_architecture(TARGET_PROCESSOR)
message(STATUS "Target architecture: ${TARGET_PROCESSOR}")

test_big_endian(THEXTECH_IS_BIG_ENDIAN)
if(THEXTECH_IS_BIG_ENDIAN)
    message(STATUS "Target processor endianess: BIG ENDIAN")
else()
    message(STATUS "Target processor endianess: LITTLE ENDIAN")
endif()

message(STATUS "Size of void pointer is ${CMAKE_SIZEOF_VOID_P}!")

# =============================== Policies ====================================

# Ninja requires custom command byproducts to be explicit.
if(POLICY CMP0058)
    cmake_policy(SET CMP0058 NEW)
endif()

# ExternalProject step targets fully adopt their steps.
if(POLICY CMP0114)
    cmake_policy(SET CMP0114 NEW)
endif()

# Report about improperly use of PRE_BUILD, PRE_LINK, and POST_BUILD keywords
if(POLICY CMP0175)
    cmake_policy(SET CMP0175 NEW)
endif()

# ========================= Macros and Functions ==============================

include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)

macro(xtech_add_warning_flag WARNINGFLAG WARNING_VAR)
    check_c_compiler_flag("${WARNINGFLAG}" HAVE_W_C_${WARNING_VAR})
    if(HAVE_W_C_${WARNING_VAR})
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNINGFLAG}")
    endif()

    check_cxx_compiler_flag("${WARNINGFLAG}" HAVE_W_CXX_${WARNING_VAR})
    if(HAVE_W_CXX_${WARNING_VAR})
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNINGFLAG}")
    endif()
endmacro()

macro(xtech_disable_warning_flag WARNINGFLAG WARNING_VAR)
    check_c_compiler_flag("-W${WARNINGFLAG}" HAVE_W_C_${WARNING_VAR})
    if(HAVE_W_C_${WARNING_VAR})
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-${WARNINGFLAG}")
    endif()

    check_cxx_compiler_flag("-W${WARNINGFLAG}" HAVE_W_CXX_${WARNING_VAR})
    if(HAVE_W_CXX_${WARNING_VAR})
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-${WARNINGFLAG}")
    endif()
endmacro()

macro(pge_add_opt_flag OPTFLAG OPT_VAR)
    check_c_compiler_flag("${OPTFLAG}" HAVE_M_C_${OPT_VAR})
    if(HAVE_M_C_${OPT_VAR})
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPTFLAG}")
    endif()

    check_cxx_compiler_flag("${OPTFLAG}" HAVE_M_CXX_${OPT_VAR})
    if(HAVE_M_CXX_${OPT_VAR})
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPTFLAG}")
    endif()
endmacro()

function(pge_cxx_standard STDVER)
    if(NOT WIN32)
        set(CMAKE_CXX_STANDARD ${STDVER} PARENT_SCOPE)
    elseif(MSVC AND CMAKE_VERSION VERSION_LESS "3.9.0" AND MSVC_VERSION GREATER_EQUAL "1900")
        CHECK_CXX_COMPILER_FLAG("/std:c++${STDVER}" _cpp_stdxx_flag_supported)
        if (_cpp_stdxx_flag_supported)
            add_compile_options("/std:c++${STDVER}")
        else()
            CHECK_CXX_COMPILER_FLAG("/std:c++latest" _cpp_latest_flag_supported)
            if (_cpp_latest_flag_supported)
                add_compile_options("/std:c++latest")
            endif()
        endif()
    else()
        set(CMAKE_CXX_STANDARD ${STDVER} PARENT_SCOPE)
    endif()
endfunction()


# ============================ Optimisations ==================================

# Strip garbage
if(APPLE)
    string(REGEX REPLACE "-O3" ""
        CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
    string(REGEX REPLACE "-O3" ""
        CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2")
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
    set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -dead_strip")

    # Unify visibility to meet llvm's default.
    check_cxx_compiler_flag("-fvisibility-inlines-hidden" SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG)
    if(SUPPORTS_FVISIBILITY_INLINES_HIDDEN_FLAG)
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility-inlines-hidden")
    endif()
elseif(NOT MSVC)
    if(EMSCRIPTEN)
        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -Os -fdata-sections -ffunction-sections")
        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -Os -fdata-sections -ffunction-sections")
        set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} -O3 -Os -fdata-sections -ffunction-sections")
        set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -O3 -Os -fdata-sections -ffunction-sections")
        set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -fdata-sections -ffunction-sections")
        set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -fdata-sections -ffunction-sections")

        if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
            set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -dead_strip")
            set(LINK_FLAGS_MINSIZEREL  "${LINK_FLAGS_MINSIZEREL} -dead_strip")
            set(LINK_FLAGS_RELWITHDEBINFO  "${LINK_FLAGS_RELWITHDEBINFO} -dead_strip")
        else()
            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Wl,--gc-sections -Wl,-s")
            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wl,--gc-sections -Wl,-s")
            set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} -Wl,--gc-sections -Wl,-s")
            set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -Wl,--gc-sections -Wl,-s")
            set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -Wl,--gc-sections -Wl,-s")
            set(LINK_FLAGS_MINSIZEREL  "${LINK_FLAGS_MINSIZEREL} -Wl,--gc-sections -Wl,-s")
            set(LINK_FLAGS_RELWITHDEBINFO  "${LINK_FLAGS_RELWITHDEBINFO} -Wl,--gc-sections -Wl,-s")
        endif()
    else()
        string(REGEX REPLACE "-O3" ""
            CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
        string(REGEX REPLACE "-O3" ""
            CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -fdata-sections -ffunction-sections")
        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -fdata-sections -ffunction-sections")
        if(ANDROID)
            set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -funwind-tables")
            set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -funwind-tables")
        elseif(THEXTECH_CLI_BUILD AND THEXTECH_NO_SDL_BUILD)
            # use -Os by default for all build types
            string(REGEX REPLACE "-O3" "-Os"
                CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
            string(REGEX REPLACE "-O3" "-Os"
                CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
            string(REGEX REPLACE "-O2" "-Os"
                CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
            string(REGEX REPLACE "-O2" "-Os"
                CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
        elseif(NINTENDO_DS)
            # use -Os by default for all build types
            string(REGEX REPLACE "-O3" "-Os"
                CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
            string(REGEX REPLACE "-O3" "-Os"
                CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
            string(REGEX REPLACE "-O2" "-Os"
                CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
            string(REGEX REPLACE "-O2" "-Os"
                CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")

            # Supress the std::vector::insert() GCC change warning
            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcompare-debug-second")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcompare-debug-second")
            # use --gc-sections for all build types
            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -g -Wl,--gc-sections -fipa-pta")
            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -g -Wl,--gc-sections -fipa-pta")
            set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -g -Wl,--gc-sections")
            set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -Wl,--gc-sections -fipa-pta")
            set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Wl,--gc-sections -fipa-pta")
            set(LINK_FLAGS_RELWITHDEBINFO  "${LINK_FLAGS_RELWITHDEBINFO} -Wl,--gc-sections")
            set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} -g -Wl,--gc-sections -fipa-pta")
            set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -g -Wl,--gc-sections -fipa-pta")
            set(LINK_FLAGS_MINSIZEREL  "${LINK_FLAGS_MINSIZEREL} -g -Wl,--gc-sections")
        elseif(NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_SWITCH)
            # Supress the std::vector::insert() GCC change warning
            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcompare-debug-second")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcompare-debug-second")
            if(NINTENDO_WII OR NINTENDO_WIIU)
                set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mno-altivec -Ubool -Uvector -U_GNU_SOURCE")
                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mno-altivec -Ubool -Uvector -U_GNU_SOURCE")
            endif()
            # use --gc-sections for all build types
            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -g -Wl,--gc-sections")
            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -g -Wl,--gc-sections")
            set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -g -Wl,--gc-sections")
            set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -Wl,--gc-sections")
            set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Wl,--gc-sections")
            set(LINK_FLAGS_RELWITHDEBINFO  "${LINK_FLAGS_RELWITHDEBINFO} -Wl,--gc-sections")
            set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} -g -Wl,--gc-sections")
            set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -g -Wl,--gc-sections")
            set(LINK_FLAGS_MINSIZEREL  "${LINK_FLAGS_MINSIZEREL} -g -Wl,--gc-sections")
        elseif(VITA)
            # Supress the std::vector::insert() GCC change warning
            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVITA=1 -fcompare-debug-second")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVITA=1 -fcompare-debug-second")
            # VitaSDK specifies -O2 for release configurations. PS Vita Support - Axiom 2022
            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -g -I../src -Wl,--gc-sections -DVITA=1")
            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -g -I../src -Wl,--gc-sections -DVITA=1 -fpermissive -fno-optimize-sibling-calls -Wno-class-conversion")
            set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -Wl,--gc-sections")
        elseif(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s -Wl,--gc-sections -Wl,-s")
            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s -Wl,--gc-sections -Wl,-s")
            set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -Wl,--gc-sections -Wl,-s")
        else()
            set(LINK_FLAGS_RELEASE  "${LINK_FLAGS_RELEASE} -dead_strip")
        endif()
    endif()
endif()

# Global optimization flags
if(NOT MSVC)
    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -fno-omit-frame-pointer")
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-omit-frame-pointer")
endif()

if(ANDROID)
    if(${ANDROID_ABI} STREQUAL "armeabi-v7a")
        # Disable NEON support for old devices
        set(ANDROID_ARM_NEON FALSE)
    elseif(NOT DEFINED ANDROID_ARM_NEON)
        set(ANDROID_ARM_NEON TRUE)
    endif()

    if(NOT DEFINED ANDROID_STL)
        # include(ndk-stl-config.cmake)
        set(ANDROID_STL "c++_static")
    endif()

    if(NOT DEFINED ANDROID_PLATFORM)
        set(ANDROID_PLATFORM 16)
    endif()

    set(CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS} -Wl,-z,max-page-size=16384 -Wl,-z,common-page-size=16384")

    if(FDROID_BUILD)
        set(FILE_PATH_OVERRIDE "-ffile-prefix-map=${CMAKE_SOURCE_DIR}=/builds/fdroid/fdroiddata/build/ru.wohlsoft.thextech.fdroid/")
        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${FILE_PATH_OVERRIDE}")
        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${FILE_PATH_OVERRIDE}")
        set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${FILE_PATH_OVERRIDE}")
        set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${FILE_PATH_OVERRIDE}")
        set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} ${FILE_PATH_OVERRIDE}")
        set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} ${FILE_PATH_OVERRIDE}")
        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--build-id=none")
        set(ENV{CFLAGS} "${FILE_PATH_OVERRIDE}")
        set(ENV{CXXFLAGS} "${FILE_PATH_OVERRIDE}")
    endif()

    set(ANDROID_CMAKE_FLAGS
        "-DANDROID_ABI=${ANDROID_ABI}"
        "-DANDROID_NDK=${ANDROID_NDK}"
        "-DANDROID_STL=${ANDROID_STL}"
        "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
        "-DANDROID_PLATFORM=${ANDROID_PLATFORM}"
        "-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}"
        "-DANDROID_NATIVE_API_LEVEL=${ANDROID_NATIVE_API_LEVEL}"
        "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
        "-DANDROID_ARM_NEON=${ANDROID_ARM_NEON}"
        "-DCMAKE_LINKER_FLAGS=-Wl,-z,max-page-size=16384 -Wl,-z,common-page-size=16384"
    )

    message("--Current Android STL=${ANDROID_STL} and flags: ${ANDROID_CMAKE_FLAGS}")

    if(FDROID_BUILD)
        # Ensure reproducibility of builds by replacing build paths with a custom one
        # So, forward all flags that was set above into dependencies
        list(APPEND ANDROID_CMAKE_FLAGS
            "-DCMAKE_SHARED_LINKER_FLAGS=-Wl,--build-id=none"
            "-DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}"
            "-DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}"
            "-DCMAKE_C_FLAGS_RELWITHDEBINFO=${CMAKE_C_FLAGS_RELWITHDEBINFO}"
            "-DCMAKE_CXX_FLAGS_RELWITHDEBINFO=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}"
            "-DCMAKE_C_FLAGS_MINSIZEREL=${CMAKE_C_FLAGS_MINSIZEREL}"
            "-DCMAKE_CXX_FLAGS_MINSIZEREL=${CMAKE_CXX_FLAGS_MINSIZEREL}"
            "-DFDROID_BUILD=TRUE"
        )
    endif()
endif()

if(VITA)
    include(cmake/vita_buildprops.cmake)
endif()

string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER)
if (CMAKE_BUILD_TYPE_LOWER STREQUAL "release")
    add_definitions(-DNDEBUG)
endif()

if(CMAKE_BUILD_TYPE_LOWER STREQUAL "debug" AND NOT ANDROID)
    set(PGE_LIBS_DEBUG_SUFFIX "d")
else()
    set(PGE_LIBS_DEBUG_SUFFIX "")
endif()


# ============================= Warnings ======================================

if(MSVC)
    # Force to always compile with W4
    if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
        string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
    else()
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
    endif()
    if(CMAKE_C_FLAGS MATCHES "/W[0-4]")
        string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
    else()
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
    endif()

    # Remove "/showIncludes" flag
    if(CMAKE_CXX_FLAGS MATCHES "/showIncludes")
        string(REGEX REPLACE "/showIncludes" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
    endif()
    if(CMAKE_C_FLAGS MATCHES "/showIncludes")
        string(REGEX REPLACE "/showIncludes" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
    endif()

    # Disable bogus MSVC warnings
    add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4244 /wd4551 /wd4276 /wd6388")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4551 /wd4276 /wd6388")

else()
    xtech_add_warning_flag("-Wall" ALL)
    xtech_add_warning_flag("-Wextra" EXTRA)
    if(NOT HAVE_W_EXTRA)
        xtech_add_warning_flag("-W" W)
    endif()
    xtech_add_warning_flag("-Wpedantic" PEDANTIC_WARNING)
    xtech_disable_warning_flag("variadic-macros" NO_VARIADIC_MACROS_WARNING)
    xtech_disable_warning_flag("psabi" NO_PSABI_WARNING)
    xtech_disable_warning_flag("dangling-reference" NO_DANGLING_REFERENCE_WARNING)
endif()


# ================================ Tweaks ====================================

# -fPIC thing
if(LIBRARY_PROJECT AND NOT WIN32 AND NOT VITA)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
endif()

if(UNIX) # When include/library/binary directory name is not usual in a system, make symbolic links for them
    if(NOT "${CMAKE_INSTALL_LIBDIR}" STREQUAL "lib")
        message("${CMAKE_INSTALL_LIBDIR} IS NOT STREQUAL lib")
        file(MAKE_DIRECTORY "${DEPENDENCIES_INSTALL_DIR}")
        execute_process(COMMAND ln -s "lib" "${DEPENDENCIES_INSTALL_DIR}/${CMAKE_INSTALL_LIBDIR}")
    endif()
    if(NOT "${CMAKE_INSTALL_BINDIR}" STREQUAL "bin")
        message("${CMAKE_INSTALL_BINDIR} IS NOT STREQUAL bin")
        file(MAKE_DIRECTORY "${DEPENDENCIES_INSTALL_DIR}")
        execute_process(COMMAND ln -s "bin" "${DEPENDENCIES_INSTALL_DIR}/${CMAKE_INSTALL_BINDIR}")
    endif()
    if(NOT "${CMAKE_INSTALL_INCLUDEDIR}" STREQUAL "include")
        message("${CMAKE_INSTALL_INCLUDEDIR} IS NOT STREQUAL lib")
        file(MAKE_DIRECTORY "${DEPENDENCIES_INSTALL_DIR}")
        execute_process(COMMAND ln -s "include" "${DEPENDENCIES_INSTALL_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
    endif()
endif()

if(APPLE)
    # Prevent "directory not exists" warnings when building XCode as project
    file(MAKE_DIRECTORY ${DEPENDENCIES_INSTALL_DIR}/lib/Debug)
    file(MAKE_DIRECTORY ${DEPENDENCIES_INSTALL_DIR}/lib/Release)
    # Don't store built executables into "Debug" and "Release" folders
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/bin)
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/bin)
    set(CMAKE_BUNDLE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/bin)
    set(CMAKE_BUNDLE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/bin)
endif()

if(CMAKE_STATIC_LIBRARY_PREFIX STREQUAL "" AND CMAKE_STATIC_LIBRARY_SUFFIX STREQUAL ".lib")
    set(LIBRARY_STATIC_NAME_SUFFIX "-static")
else()
    set(LIBRARY_STATIC_NAME_SUFFIX "")
endif()

# Library path helpers
macro(set_static_lib OUTPUT_VAR LIBDIR LIBNAME)
    set(${OUTPUT_VAR} "${LIBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${LIBNAME}${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")
endmacro()

macro(set_shared_lib OUTPUT_VAR LIBDIR LIBNAME)
    if(WIN32)
        set(${OUTPUT_VAR} "${LIBDIR}/${CMAKE_IMPORT_LIBRARY_PREFIX}${LIBNAME}${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_IMPORT_LIBRARY_SUFFIX}")
    else()
        set(${OUTPUT_VAR} "${LIBDIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBNAME}${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
    endif()
endmacro()


================================================
FILE: cmake/ci_linux_gcc_toolchain_arm64.cmake
================================================
set(CMAKE_SYSTEM_NAME Linux)

set(CMAKE_C_COMPILER /usr/bin/aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER /usr/bin/aarch64-linux-gnu-g++)
set(CMAKE_ASM_COMPILER /usr/bin/aarch64-linux-gnu-as)
set(CMAKE_ASM-ATT_COMPILER /usr/bin/aarch64-linux-gnu-as)
set(CMAKE_AR ar)

set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(CMAKE_CROSSCOMPILING ON)

set(CMAKE_FIND_ROOT_PATH /usr/aarch64-linux-gnu)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
#set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
#set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
#set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)


================================================
FILE: cmake/ci_linux_gcc_toolchain_armhf.cmake
================================================
set(CMAKE_SYSTEM_NAME Linux)

set(CMAKE_C_COMPILER /usr/bin/arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER /usr/bin/arm-linux-gnueabihf-g++)
set(CMAKE_ASM_COMPILER /usr/bin/arm-linux-gnueabihf-as)
set(CMAKE_ASM-ATT_COMPILER /usr/bin/arm-linux-gnueabihf-as)
set(CMAKE_AR ar)

set(CMAKE_SYSTEM_PROCESSOR armhf)

set(CMAKE_CROSSCOMPILING ON)

set(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabihf)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
#set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
#set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
#set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)



================================================
FILE: cmake/ci_linux_gcc_toolchain_x32.cmake
================================================
set(CMAKE_SYSTEM_NAME Linux)

set(CMAKE_C_COMPILER gcc)
set(CMAKE_C_FLAGS -m32)
set(CMAKE_CXX_COMPILER g++)
set(CMAKE_CXX_FLAGS -m32)
set(CMAKE_AR ar)

set(CMAKE_CROSSCOMPILING ON)

set(CMAKE_FIND_ROOT_PATH /usr/lib/i386-linux-gnu/)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
#set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
#set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
#set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)


================================================
FILE: cmake/ci_windows_mingw_toolchain_x32.cmake
================================================
set(CMAKE_SYSROOT "C:/WohlMinGWw64/mingw32/")

set(CMAKE_SYSTEM_PREFIX_PATH "C:/WohlMinGWw64/mingw32/")

set(CMAKE_C_COMPILER "C:/WohlMinGWw64/mingw32/bin/gcc.exe")
set(CMAKE_CXX_COMPILER "C:/WohlMinGWw64/mingw32/bin/g++.exe")

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)


================================================
FILE: cmake/ci_windows_mingw_toolchain_x64.cmake
================================================
set(CMAKE_SYSROOT "C:/WohlMinGWw64/mingw64/")

set(CMAKE_SYSTEM_PREFIX_PATH "C:/WohlMinGWw64/mingw64/")

set(CMAKE_C_COMPILER "C:/WohlMinGWw64/mingw64/bin/gcc.exe")
set(CMAKE_CXX_COMPILER "C:/WohlMinGWw64/mingw64/bin/g++.exe")

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)


================================================
FILE: cmake/ci_windows_msvc_toolchain_arm64.cmake
================================================
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")


================================================
FILE: cmake/deploy.cmake
================================================
set(CPACK_PACKAGE_VENDOR "Wohlstand")
set(CPACK_PACKAGE_CONTACT "admin@wohlnet.ru")
set(CPACK_PACKAGE_VERSION "${THEXTECH_VERSION_STRING}")

if(APPLE)
    set(CPACK_PACKAGE_NAME "${THEXTECH_BUNDLE_NAME}")
    set(CPACK_GENERATOR "DragNDrop")
    set(CPACK_PACKAGE_VERSION "${THEXTECH_VERSION_STRING}")
    set(CPACK_DMG_FORMAT "UDBZ")
    set(CPACK_DMG_VOLUME_NAME "${THEXTECH_BUNDLE_NAME}")
    if(NOT CPACK_PACKAGE_FILE_NAME)
        set(CPACK_PACKAGE_FILE_NAME "${THEXTECH_BUNDLE_NAME}-${THEXTECH_VERSION_STRING}")
    endif()
    include(CPack)

elseif(UNIX)
    set(CPACK_PACKAGE_NAME "${THEXTECH_PACKAGE_NAME}")
    if(NOT CPACK_GENERATOR)
        set(CPACK_GENERATOR "TBZ2")
    endif()

    # DEB related
    set(CPACK_DEB_COMPONENT_INSTALL OFF)
    set(CPACK_DEBIAN_PACKAGE_NAME "${THEXTECH_INSTALLER_PACKAGE_NAME}")
    set(CPACK_DEBIAN_PACKAGE_VERSION ${THEXTECH_VERSION_STRING})
    if(NOT CPACK_DEBIAN_PACKAGE_RELEASE)
        set(CPACK_DEBIAN_PACKAGE_RELEASE 1)
    endif()

    set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_VENDOR} <${CPACK_PACKAGE_CONTACT}>")
    set(CPACK_DEBIAN_PACKAGE_SECTION games)
    set(CPACK_DEBIAN_PACKAGE_PRIORITY optional)
    if(NOT CPACK_DEBIAN_PACKAGE_HOMEPAGE)
        set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://wohlsoft.ru/")
    endif()

    # RPM related
    set(CPACK_RPM_PACKAGE_VENDOR "${CPACK_PACKAGE_VENDOR} <${CPACK_PACKAGE_CONTACT}>")
    set(CPACK_RPM_PACKAGE_NAME  "${THEXTECH_INSTALLER_PACKAGE_NAME}")
    set(CPACK_RPM_PACKAGE_VERSION ${THEXTECH_VERSION_STRING})

    if(NOT CPACK_RPM_PACKAGE_RELEASE)
        set(CPACK_RPM_PACKAGE_RELEASE 1)
    endif()

    if(NOT CPACK_RPM_PACKAGE_URL)
        set(CPACK_RPM_PACKAGE_URL "https://wohlsoft.ru/")
    endif()

    # Generic
    if(NOT CPACK_PACKAGE_FILE_NAME)
        set(CPACK_PACKAGE_FILE_NAME "${THEXTECH_PACKAGE_NAME}-${THEXTECH_VERSION_STRING}")
    endif()
    include(CPack)
endif()

if(WIN32)
    set(CPACK_PACKAGE_NAME "${THEXTECH_PACKAGE_NAME}")
    set(CPACK_GENERATOR "7Z")
    set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
    if(NOT CPACK_PACKAGE_FILE_NAME)
        set(CPACK_PACKAGE_FILE_NAME "${THEXTECH_PACKAGE_NAME}-${THEXTECH_VERSION_STRING}")
    endif()
    include(CPack)
endif()



================================================
FILE: cmake/git_info.cmake
================================================
# Get the current working branch
set(OVERRIDE_GIT_BRANCH "" CACHE STRING "Override name of GIT branch")

# Identify the Pull-Request
if((DEFINED ENV{TRAVIS_PULL_REQUEST} AND NOT "$ENV{TRAVIS_PULL_REQUEST}" STREQUAL "false")
    OR (DEFINED ENV{APPVEYOR_PULL_REQUEST_NUMBER})
    OR (DEFINED ENV{PULL_REQUEST_NUMBER}))
    set(CI_PULL_REQUEST "-pr-check")
else()
    set(CI_PULL_REQUEST "")
endif()

if(OVERRIDE_GIT_BRANCH)
    set(GIT_BRANCH ${OVERRIDE_GIT_BRANCH})
elseif(DEFINED ENV{APPVEYOR_REPO_BRANCH})
    set(GIT_BRANCH $ENV{APPVEYOR_REPO_BRANCH})
elseif(DEFINED ENV{TRAVIS_BRANCH})
    set(GIT_BRANCH $ENV{TRAVIS_BRANCH})
elseif(DEFINED ENV{BRANCH_NAME})
    set(GIT_BRANCH $ENV{BRANCH_NAME})
else()
    execute_process(
            COMMAND git rev-parse --abbrev-ref HEAD
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
            OUTPUT_VARIABLE GIT_BRANCH
            OUTPUT_STRIP_TRAILING_WHITESPACE
    )
endif()

# Get the latest abbreviated commit hash of the working branch
execute_process(
        COMMAND git log -1 --format=%h
        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        OUTPUT_VARIABLE GIT_COMMIT_HASH
        OUTPUT_STRIP_TRAILING_WHITESPACE
)

# Check if the git index is dirty
execute_process(
        COMMAND git diff-index HEAD --
        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        OUTPUT_VARIABLE GIT_DIRTY_STRING
        OUTPUT_STRIP_TRAILING_WHITESPACE
)

# flatpak-builder breaks any commands that check the git tree,
# and fdroid applies local autochanges such as gradle wrapper removal and build.gradle patching
if(NOT "${GIT_DIRTY_STRING}" STREQUAL "" AND NOT FLATPAK_BUILD AND NOT FDROID_BUILD)
    set(GIT_COMMIT_HASH "${GIT_COMMIT_HASH}-dirty")
endif()

set(PACKAGE_SUFFIX ${GIT_BRANCH}${CI_PULL_REQUEST})


================================================
FILE: cmake/git_version.cmake
================================================
# adds a custom target for git version (always built)
add_custom_target(git_version ALL)

# Report about improperly use of PRE_BUILD, PRE_LINK, and POST_BUILD keywords
if(POLICY CMP0175)
    cmake_policy(SET CMP0175 NEW)
endif()

# creates git_version.h using cmake script
add_custom_command(TARGET git_version PRE_BUILD
    COMMAND ${CMAKE_COMMAND}
        "-DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
        "-DOVERRIDE_GIT_BRANCH=${OVERRIDE_GIT_BRANCH}"
        "-DFLATPAK_BUILD=${FLATPAK_BUILD}"
        "-DFDROID_BUILD=${FDROID_BUILD}"
        -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/git_version_update.cmake")

# attempt to force reconfigure for the build AFTER git status changes
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/generated-include/git_version.h")


================================================
FILE: cmake/git_version_update.cmake
================================================
# Get the current working branch
set(OVERRIDE_GIT_BRANCH "" CACHE STRING "Override name of GIT branch")

if(OVERRIDE_GIT_BRANCH)
    set(GIT_BRANCH ${OVERRIDE_GIT_BRANCH})
elseif(DEFINED ENV{APPVEYOR_REPO_BRANCH})
    set(GIT_BRANCH $ENV{APPVEYOR_REPO_BRANCH})
elseif(DEFINED ENV{TRAVIS_BRANCH})
    set(GIT_BRANCH $ENV{TRAVIS_BRANCH})
elseif(DEFINED ENV{BRANCH_NAME})
    set(GIT_BRANCH $ENV{BRANCH_NAME})
else()
    execute_process(
            COMMAND git rev-parse --abbrev-ref HEAD
            WORKING_DIRECTORY ${SOURCE_DIR}
            OUTPUT_VARIABLE GIT_BRANCH
            OUTPUT_STRIP_TRAILING_WHITESPACE
    )
endif()

# Get the latest abbreviated commit hash of the working branch
execute_process(
        COMMAND git log -1 --format=%h --abbrev=8
        WORKING_DIRECTORY ${SOURCE_DIR}
        OUTPUT_VARIABLE GIT_COMMIT_HASH
        OUTPUT_STRIP_TRAILING_WHITESPACE
)

# Check if the git index is dirty
execute_process(
        COMMAND git diff-index HEAD --
        WORKING_DIRECTORY ${SOURCE_DIR}
        OUTPUT_VARIABLE GIT_DIRTY_STRING
        OUTPUT_STRIP_TRAILING_WHITESPACE
)

# flatpak-builder breaks any commands that check the git tree
if(NOT "${GIT_DIRTY_STRING}" STREQUAL "" AND NOT FLATPAK_BUILD AND NOT FDROID_BUILD)
    # on CI, display the git diff in the log
    if(OVERRIDE_GIT_BRANCH OR DEFINED ENV{CI})
        message("=== git index dirty, see diff:")
        message("${GIT_DIRTY_STRING}")
    endif()

    set(GIT_COMMIT_HASH "${GIT_COMMIT_HASH}-dirty")
endif()

if(NOT GIT_COMMIT_HASH)
    set(THEXTECH_GIT_VERSION "CMakeUnknown")
else()
    set(THEXTECH_GIT_VERSION "${GIT_COMMIT_HASH}")
endif()

if(NOT GIT_BRANCH)
    set(THEXTECH_GIT_BRANCH "unknown")
else()
    set(THEXTECH_GIT_BRANCH "${GIT_BRANCH}")
endif()

message("=== git info: commit ${THEXTECH_GIT_VERSION}, branch ${THEXTECH_GIT_BRANCH}")

file(MAKE_DIRECTORY generated-include)
file(WRITE generated-include/git_version.h.txt "#define GIT_VERSION \"${THEXTECH_GIT_VERSION}\"\n#define GIT_BRANCH \"${THEXTECH_GIT_BRANCH}\"\n")

execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different generated-include/git_version.h.txt generated-include/git_version.h)


================================================
FILE: cmake/icon.desktop.in
================================================
[Desktop Entry]
Name=@DESKTOP_NAME@
GenericName=@DESKTOP_GENERIC_NAME@
Comment=@DESKTOP_COMMENT@
Encoding=UTF-8
Version=1.0
Type=Application
Terminal=false
Icon=@DESKTOP_ICON@
Exec=@DESKTOP_EXEC@ %f
X-Purism-FormFactor=Workstation;Mobile;
Categories=Game;
StartupWMClass=@DESKTOP_WMCLASS@
Actions=SpeedRunMode1;SpeedRunMode2;SpeedRunMode3;CompatModeClassic;CompatModeVanilla;

[Desktop Action SpeedRunMode1]
Name=Speedrun Mode 1 (Native)
Exec=@DESKTOP_EXEC@ --speed-run-mode 1 %f

[Desktop Action SpeedRunMode2]
Name=Speedrun Mode 2 (Classic)
Exec=@DESKTOP_EXEC@ --speed-run-mode 2 %f

[Desktop Action SpeedRunMode3]
Name=Speedrun Mode 3 (Strict Vanilla)
Exec=@DESKTOP_EXEC@ --speed-run-mode 3 %f

[Desktop Action CompatModeClassic]
Name=Run in "Classic" compatibiltiy mode (critical bugfixes only)
Exec=@DESKTOP_EXEC@ --compat-level classic %f

[Desktop Action CompatModeVanilla]
Name=Run in "Vanilla" strict compatibiltiy mode (no bugfixes at all)
Exec=@DESKTOP_EXEC@ --compat-level vanilla %f


================================================
FILE: cmake/library_FreeImage.cmake
================================================
# FreeImage is an image management library

add_library(PGE_FreeImage INTERFACE)

if(NINTENDO_SWITCH)
    set(USE_FREEIMAGE_SYSTEM_LIBS_DEFAULT ON)
else()
    set(USE_FREEIMAGE_SYSTEM_LIBS_DEFAULT OFF)
endif()

if(NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_3DS OR NINTENDO_SWITCH OR XTECH_MACOSX_TIGER)
    set(USE_PNG_HARDWARE_OPTIMIZATIONS_DEFAULT OFF)
else()
    set(USE_PNG_HARDWARE_OPTIMIZATIONS_DEFAULT ON)
endif()

option(USE_SHARED_FREEIMAGE "Use shared build of FreeImage" OFF)
option(USE_FREEIMAGE_SYSTEM_LIBS "Let FreeImage to use libPNG and libJPEG from the system" ${USE_FREEIMAGE_SYSTEM_LIBS_DEFAULT})
option(USE_PNG_HARDWARE_OPTIMIZATIONS "Enable hardware optimizations for the FreeImage internal build of libPNG" ${USE_PNG_HARDWARE_OPTIMIZATIONS_DEFAULT})
option(FREEIMAGE_PIC "Enable -fPIC flag for libFreeImage" ON)

if(VITA OR NINTENDO_SWITCH OR NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_WIIU)
    set(FREEIMAGE_PIC OFF)
endif()


if(USE_SHARED_FREEIMAGE)
    set_shared_lib(libFreeImage_Libs "${DEPENDENCIES_INSTALL_DIR}/lib" FreeImageLite)
    set(USE_STATIC_FREEIMAGE OFF)
else()
    set_static_lib(libFreeImage_Libs "${DEPENDENCIES_INSTALL_DIR}/lib" FreeImageLite${LIBRARY_STATIC_NAME_SUFFIX})
    set(USE_STATIC_FREEIMAGE ON)
endif()

if(NOT THEXTECH_NO_SDL_BUILD)
    set(USE_FREEIMAGE_SYSTEM_ZLIB ON)
    # Use Zlib from AudioCodecs kit
    if(USE_SYSTEM_ZLIB)
        set(FREEIMAGE_ZLIB_INCLUDE ${ZLIB_INCLUDE_DIRS})
        set(FREEIMAGE_ZLIB_LIBS ${ZLIB_LIBRARIES})
    else()
        set(FREEIMAGE_ZLIB_INCLUDE "${DEPENDENCIES_INSTALL_DIR}/include")
        set(FREEIMAGE_ZLIB_LIBS ${AC_ZLIB})
    endif()
endif()

ExternalProject_Add(
    FreeImage_Local
    PREFIX ${CMAKE_BINARY_DIR}/external/FreeImage
#    GIT_REPOSITORY https://github.com/WohlSoft/libFreeImage.git
#    UPDATE_COMMAND ""
    DOWNLOAD_COMMAND ""
    SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/FreeImageLite
    CMAKE_ARGS
        "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
        "-DFREEIMAGE_SHARED=${USE_SHARED_FREEIMAGE}"
        "-DFREEIMAGE_STATIC=${USE_STATIC_FREEIMAGE}"
        "-DDEPENDENCIES_INSTALL_DIR=${DEPENDENCIES_INSTALL_DIR}"
        #"-DCMAKE_PROJECT_FreeImage_INCLUDE=${CMAKE_SOURCE_DIR}/_common/build_env.cmake"
        "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
        "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
        "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
        "-DCMAKE_POSITION_INDEPENDENT_CODE=${FREEIMAGE_PIC}"
        "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
        "-DFREEIMAGE_USE_SYSTEM_LIBPNG=${USE_FREEIMAGE_SYSTEM_LIBS}"
        "-DFREEIMAGE_USE_SYSTEM_LIBJPEG=${USE_FREEIMAGE_SYSTEM_LIBS}"
        "-DFREEIMAGE_USE_SYSTEM_ZLIB=${USE_FREEIMAGE_SYSTEM_ZLIB}"
        "-DPNG_HARDWARE_OPTIMIZATIONS=${USE_PNG_HARDWARE_OPTIMIZATIONS}"
        #"-DFREEIMAGE_PNG_INCLUDE=${PNG_INCLUDE_DIRS}"
        "-DFREEIMAGE_ZLIB_INCLUDE=${FREEIMAGE_ZLIB_INCLUDE}"
        #"-DFREEIMAGE_PNG_LIB=${libPNG_A_Lib}"
        "-DFREEIMAGE_ZLIB_LIB=${FREEIMAGE_ZLIB_LIBS}"
        $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
        $<$<BOOL:APPLE>:-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}>
        ${ANDROID_CMAKE_FLAGS}
    BUILD_BYPRODUCTS
        "${libFreeImage_Libs}"
)

target_link_libraries(PGE_FreeImage INTERFACE
    "${libFreeImage_Libs}"
)

if(USE_FREEIMAGE_SYSTEM_LIBS AND NOT USE_SHARED_FREEIMAGE)
    find_library(LIBRARY_PNG png)
    find_library(LIBRARY_JPEG jpeg)

    if(NOT LIBRARY_PNG OR NOT LIBRARY_JPEG)
        message(FATAL_ERROR "Required libPNG and libJPEG libraries are not found!")
    endif()

    target_link_libraries(PGE_FreeImage INTERFACE
        "${LIBRARY_PNG}"
        "${LIBRARY_JPEG}"
    )
endif()

if(USE_SHARED_FREEIMAGE AND NOT WIN32)
    install(FILES ${libFreeImage_Libs} DESTINATION ${PGE_INSTALL_DIRECTORY})
endif()


================================================
FILE: cmake/library_FreeType.cmake
================================================
option(FREETYPE_PIC "Enable -fPIC flag for libFreeType" ON)

if(VITA OR NINTENDO_SWITCH OR NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_WIIU)
    set(FREETYPE_PIC OFF)
endif()

add_library(PGE_FreeType INTERFACE)

if(USE_SYSTEM_LIBS)
    add_library(FREETYPE_Local INTERFACE)

    find_package(Freetype REQUIRED)
    message("-- Found FreeType: ${FREETYPE_LIBRARIES} --")
    target_link_libraries(PGE_FreeType INTERFACE ${FREETYPE_LIBRARIES})
    target_include_directories(PGE_FreeType INTERFACE ${FREETYPE_INCLUDE_DIRS})

    set(libFreeType_Libs "${FREETYPE_LIBRARIES}")

else()
    set(libFreeType_Libs "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}freetype${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")

    if(NOT THEXTECH_NO_SDL_BUILD)
        # Use Zlib from AudioCodecs kit
        if(USE_SYSTEM_ZLIB)
            set(FREETYPE_ZLIB_INCLUDE ${ZLIB_INCLUDE_DIRS})
            set(FREETYPE_ZLIB_LIBS ${ZLIB_LIBRARIES})
        else()
            set(FREETYPE_ZLIB_INCLUDE "${DEPENDENCIES_INSTALL_DIR}/include")
            set(FREETYPE_ZLIB_LIBS ${AC_ZLIB})
        endif()
    endif()

    if(NOT DEFINED FT_DISABLE_HARFBUZZ)
        set(FT_DISABLE_HARFBUZZ OFF)
    endif()

    if(TARGET HARFBUZZ_Local)
        set(FT_HARFBUZZ_TARGET HARFBUZZ_Local)
    endif()

    # FreeType to render TTF fonts
    ExternalProject_Add(
        FREETYPE_Local
        PREFIX ${CMAKE_BINARY_DIR}/external/FreeType
        DOWNLOAD_COMMAND ""
        SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/freetype
        CMAKE_ARGS
            "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
            "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
            "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
            "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
#            "-DCMAKE_CONFIGURATION_TYPES=${CMAKE_CONFIGURATION_TYPES}"
            "-DCMAKE_POSITION_INDEPENDENT_CODE=${FREETYPE_PIC}"
            "-DDISABLE_FORCE_DEBUG_POSTFIX=ON"
            "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
            ${ANDROID_CMAKE_FLAGS}
            -DFT_ENABLE_ERROR_STRINGS=ON
            -DFT_DISABLE_ZLIB=OFF
            -DFT_DISABLE_BZIP2=ON
            -DFT_DISABLE_BROTLI=ON
            -DFT_DISABLE_PNG=ON
            -DFT_DISABLE_BROTLI=ON
            "-DZLIB_INCLUDE_DIR=${FREETYPE_ZLIB_INCLUDE}"
            "-DZLIB_LIBRARY=${AC_ZLIB}"
            -DFT_DISABLE_HARFBUZZ=${FT_DISABLE_HARFBUZZ}
            "-DHARFBUZZ_LIBRARIES=${libHarfBuzz_Libs}"
            -DCMAKE_DISABLE_FIND_PACKAGE_PNG=TRUE
            -DCMAKE_DISABLE_FIND_PACKAGE_BZip2=TRUE
            -DCMAKE_DISABLE_FIND_PACKAGE_HarfBuzz=TRUE
            $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
            $<$<BOOL:APPLE>:-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}>
        BUILD_BYPRODUCTS
            "${libFreeType_Libs}"
        DEPENDS
            ${FT_HARFBUZZ_TARGET}
    )

    message("-- FreeType will be built: ${libFreeType_Libs} --")

    target_link_libraries(PGE_FreeType INTERFACE "${libFreeType_Libs}")
    target_include_directories(PGE_FreeType INTERFACE "${DEPENDENCIES_INSTALL_DIR}/include" "${DEPENDENCIES_INSTALL_DIR}/include/freetype2")

endif()


================================================
FILE: cmake/library_HarfBuzz.cmake
================================================
# HarfBuzz is a text shaping engine

option(HARFBUZZ_PIC "Enable -fPIC flag for libHarfBuzz" ON)

if(VITA)
    set(HARFBUZZ_PIC OFF)
endif()


add_library(PGE_HarfBuzz INTERFACE)

if(USE_SYSTEM_LIBS)
    add_library(HARFBUZZ_Local INTERFACE)

    find_package(HarfBuzz REQUIRED)
    message("-- Found FreeType: ${HARFBUZZ_LIBRARIES} --")
    target_link_libraries(PGE_HarfBuzz INTERFACE ${HARFBUZZ_LIBRARIES})
    target_include_directories(PGE_HarfBuzz INTERFACE ${HARFBUZZ_INCLUDE_DIRS})

    set(libFreeType_Libs "${HARFBUZZ_LIBRARIES}")

else()
    set(libHarfBuzz_Libs "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}harfbuzz${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")

    # FreeType to render TTF fonts
    ExternalProject_Add(
        HARFBUZZ_Local
        PREFIX ${CMAKE_BINARY_DIR}/external/harfbuzz
        DOWNLOAD_COMMAND ""
        SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/harfbuzz
        CMAKE_ARGS
            "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
            "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
            "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
            "-DCMAKE_POSITION_INDEPENDENT_CODE=${HARFBUZZ_PIC}"
            "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
            ${ANDROID_CMAKE_FLAGS}
            -DFT_WITH_ZLIB=ON -DFT_WITH_BZIP2=OFF -DFT_WITH_PNG=ON -DFT_WITH_HARFBUZZ=OFF
            $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
        BUILD_BYPRODUCTS
            "${libHarfBuzz_Libs}"
    )

    message("-- HarfBuzz will be built: ${libHarfBuzz_Libs} --")

    target_link_libraries(PGE_HarfBuzz INTERFACE "${libHarfBuzz_Libs}")
    target_include_directories(PGE_HarfBuzz INTERFACE "${DEPENDENCIES_INSTALL_DIR}/include/harfbuzz")

endif()



================================================
FILE: cmake/library_SDLMixerX.cmake
================================================

# Note: You must also include "library_AudioCodecs.cmake" too!

add_library(PGE_SDLMixerX        INTERFACE)
add_library(PGE_SDLMixerX_static INTERFACE)

set(SDL_BRANCH "release-2.0.12")
set(SDL_GIT_BRANCH "origin/release-2.0.12")

if(APPLE)
    set(PGE_SHARED_SDLMIXER_DEFAULT OFF)
elseif(EMSCRIPTEN OR ANDROID OR VITA OR NINTENDO_SWITCH OR NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_3DS)
    set(PGE_SHARED_SDLMIXER_FORCE_OFF ON)
else()
    set(PGE_SHARED_SDLMIXER_DEFAULT ON)
endif()

if(NOT PGE_SHARED_SDLMIXER_FORCE_OFF)
    option(PGE_SHARED_SDLMIXER "Link MixerX as a shared library (dll/so/dylib)" ${PGE_SHARED_SDLMIXER_DEFAULT})
else()
    set(PGE_SHARED_SDLMIXER OFF)
endif()

option(MIXERX_ENABLE_WAVPACK "Enable the WavPack codec support [Support is experimental, doesn't builds on some platforms]" OFF)
option(AUDIOCODECS_DISABLE_ASM_OPTIMIZATIONS "Disable hardware optimizations for libopus and other AudioCodecs-built libraries" OFF)

if(NOT NINTENDO_WII AND NOT NINTENDO_WIIU AND NOT XTECH_MACOSX_TIGER)
    option(PGE_USE_LOCAL_SDL2 "Do use the locally-built SDL2 library from the AudioCodecs set. Otherwise, download and build the development top main version." ON)
else()
    option(PGE_USE_LOCAL_SDL2 "Do use the locally-built SDL2 library from the AudioCodecs set. Otherwise, download and build the development top main version." OFF)
endif()

set(MIXER_USE_OGG_VORBIS_FILE OFF)
set(MIXER_USE_OGG_VORBIS_STB ON)
set(MIXER_USE_OGG_VORBIS_TREMOR OFF)
set(AUDIOCODECS_OGG_UNSAFE_DISABLE_CRC OFF)

if(NINTENDO_3DS)
    set(MIXER_USE_OGG_VORBIS_STB OFF)
    set(MIXER_USE_OGG_VORBIS_TREMOR ON)
    set(AUDIOCODECS_OGG_UNSAFE_DISABLE_CRC ON)
endif()

#if(WIN32)
#    if(MSVC)
#        set(SDL_MixerX_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2_mixer_ext${PGE_LIBS_DEBUG_SUFFIX}.lib")
#        set(SDL2_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2${PGE_LIBS_DEBUG_SUFFIX}.lib")
#    else()
#        # Note: implibs should use static library prefix
#        set(SDL_MixerX_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2_mixer_ext${PGE_LIBS_DEBUG_SUFFIX}.dll.a")
#        set(SDL2_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2${PGE_LIBS_DEBUG_SUFFIX}.dll.a")
#    endif()
#else()
#    set(SDL_MixerX_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2_mixer_ext${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
#    set(SDL2_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
#endif()
set_shared_lib(SDL_MixerX_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib" SDL2_mixer_ext)
set_shared_lib(SDL2_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib" SDL2)

# NO LONGER REQUIRED SINCE SDL 2.0.18 (https://github.com/libsdl-org/SDL/issues/4955#issuecomment-968366436)
# set_shared_lib(SDLHIDAPI_SO_Lib "${DEPENDENCIES_INSTALL_DIR}/lib" hidapi)

set_static_lib(SDL2_main_A_Lib "${DEPENDENCIES_INSTALL_DIR}/lib" SDL2main)

set_static_lib(SDL_MixerX_A_Lib "${DEPENDENCIES_INSTALL_DIR}/lib" SDL2_mixer_ext${LIBRARY_STATIC_NAME_SUFFIX})
set_static_lib(SDL2_A_Lib "${DEPENDENCIES_INSTALL_DIR}/lib" SDL2${LIBRARY_STATIC_NAME_SUFFIX})

set(CODECS_LIBRARIES_DIR ${DEPENDENCIES_INSTALL_DIR}/lib)

if(USE_SYSTEM_SDL2)
    set(USE_LOCAL_SDL2 OFF)
    if(HAIKU)
        find_library(SDL2_LIBRARY SDL2)
        find_path(SDL2_INCLUDE_DIR "SDL.h" PATH_SUFFIXES SDL2)
        if(NOT SDL2_LIBRARY AND NOT SDL2_INCLUDE_DIR)
            message(FATAL_ERROR "The SDL2 Library was not found!")
        endif()
        set(SDL2_INCLUDE_DIRS ${SDL2_INCLUDE_DIR})
        set(SDL2_LIBRARIES ${SDL2_LIBRARY})
    else()
        find_package(SDL2 REQUIRED)
        if(TARGET SDL2::SDL2)
            set(SDL2_LIBRARIES SDL2::SDL2main SDL2::SDL2)
        elseif(TARGET SDL2::SDL2-static)
            set(SDL2_LIBRARIES SDL2::SDL2main SDL2::SDL2-static)
        endif()
    endif()
else()
    set(USE_LOCAL_SDL2 ${PGE_USE_LOCAL_SDL2})
    set(SDL2_INCLUDE_DIRS "${DEPENDENCIES_INSTALL_DIR}/include/" "${DEPENDENCIES_INSTALL_DIR}/include/SDL2")
endif()

set(MixerX_SysLibs ${THEXTECH_SYSLIBS})

set_static_lib(AC_FLAC         "${CODECS_LIBRARIES_DIR}" FLAC)
set_static_lib(AC_FLUIDLITE    "${CODECS_LIBRARIES_DIR}" fluidlite)
set_static_lib(AC_VORBISFILE   "${CODECS_LIBRARIES_DIR}" vorbisfile)
set_static_lib(AC_VORBISIDEC   "${CODECS_LIBRARIES_DIR}" vorbisidec)
set_static_lib(AC_VORBIS       "${CODECS_LIBRARIES_DIR}" vorbis)
set_static_lib(AC_OPUSFILE     "${CODECS_LIBRARIES_DIR}" opusfile)
set_static_lib(AC_OPUS         "${CODECS_LIBRARIES_DIR}" opus)
set_static_lib(AC_OGG          "${CODECS_LIBRARIES_DIR}" ogg)
set_static_lib(AC_WAVPACK      "${CODECS_LIBRARIES_DIR}" wavpack)
set_static_lib(AC_ADLMIDI      "${CODECS_LIBRARIES_DIR}" ADLMIDI)
set_static_lib(AC_OPNMIDI      "${CODECS_LIBRARIES_DIR}" OPNMIDI)
set_static_lib(AC_EDMIDI       "${CODECS_LIBRARIES_DIR}" EDMIDI)
set_static_lib(AC_TIMIDITYSDL  "${CODECS_LIBRARIES_DIR}" timidity_sdl2)
set_static_lib(AC_GME          "${CODECS_LIBRARIES_DIR}" gme)
if(MSVC) # MSVC-built libxmp has the "libxmp" name
    set_static_lib(AC_LIBXMP       "${CODECS_LIBRARIES_DIR}" libxmp)
else()
    set_static_lib(AC_LIBXMP       "${CODECS_LIBRARIES_DIR}" xmp)
endif()
set_static_lib(AC_MODPLUG      "${CODECS_LIBRARIES_DIR}" modplug)
# set_static_lib(AC_ZLIB         "${CODECS_LIBRARIES_DIR}" zlib)   # Moved to own ZLib header

set(MixerX_CodecLibs
#    "${AC_FLAC}"
    "${AC_FLUIDLITE}"
)

if(MIXER_USE_OGG_VORBIS_FILE)
    list(APPEND MixerX_CodecLibs ${AC_VORBISFILE})
    list(APPEND MixerX_CodecLibs ${AC_VORBIS})
endif()

if(MIXER_USE_OGG_VORBIS_TREMOR)
    list(APPEND MixerX_CodecLibs ${AC_VORBISIDEC})
endif()

list(APPEND MixerX_CodecLibs
    "${AC_OPUSFILE}"
    "${AC_OPUS}"
    "${AC_OGG}")

if(MIXERX_ENABLE_WAVPACK)
    list(APPEND MixerX_CodecLibs "${AC_WAVPACK}")
endif()

list(APPEND MixerX_CodecLibs
    "${AC_ADLMIDI}"
    "${AC_OPNMIDI}"
    "${AC_EDMIDI}"
    "${AC_TIMIDITYSDL}"
    "${AC_GME}"
    "${AC_LIBXMP}"
    "${AC_MODPLUG}"
)

if(VITA)
    set(VITA_AUDIOCODECS_CMAKE_FLAGS
        "-DBUILD_OGG_VORBIS=OFF"
        "-DBUILD_FLAC=OFF"
        "-DBUILD_OPUS=ON"
    )

    if(THEXTECH_BUILD_GL_ES_MODERN)
        list(APPEND VITA_AUDIOCODECS_CMAKE_FLAGS
            "-DVITA_SDL2_PVR=ON"
        )
    endif()

    set(VITA_MIXERX_CMAKE_FLAGS
        "-DUSE_OGG_VORBIS_TREMOR=OFF"
        "-DUSE_SYSTEM_AUDIO_LIBRARIES_DEFAULT=ON"
        "-DSDL_MIXER_X_SHARED=OFF"
        "-DFLAC_LIBRARIES=FLAC"
        "-DOGG_LIBRARIES=ogg"
        "-DLIBOPUSFILE_LIB=opusfile"
        "-DLIBOPUS_LIB=opus"
        "-DCMAKE_C_FLAGS=-I$ENV{VITASDK}/arm-vita-eabi/include/opus"
        "-DLIBVORBISIDEC_LIB=vorbisidec"
        "-DLIBVORBIS_LIB=vorbis"
        "-DLIBVORBISFILE_LIB=vorbisfile"
    )

    # Minimal list of libraries to link
    set(MixerX_CodecLibs "${AC_FLUIDLITE}")

    if(MIXERX_ENABLE_WAVPACK)
        list(append MixerX_CodecLibs "${AC_WAVPACK}")
    endif()

    list(APPEND MixerX_CodecLibs
        "${AC_ADLMIDI}"
        "${AC_OPNMIDI}"
        "${AC_EDMIDI}"
        "${AC_TIMIDITYSDL}"
        "${AC_GME}"
        "${AC_LIBXMP}"
        "${AC_MODPLUG}"
    )
endif()

set(MixerX_Deps)
set(AudioCodecs_Deps)
set(AUDIO_CODECS_BUILD_ARGS)

if(THEXTECH_NO_MIXER_X)
    # Disable everything except of SDL2
    list(APPEND AUDIO_CODECS_BUILD_ARGS
        "-DBUILD_FLAC=OFF"
        "-DBUILD_MPG123=OFF"
        "-DBUILD_MODPLUG=OFF"
        "-DBUILD_LIBXMP=OFF"
        "-DBUILD_OPUS=OFF"
        "-DBUILD_WAVPACK=OFF"
        "-DBUILD_FLUIDLITE=OFF"
        "-DBUILD_ADLMIDI=OFF"
        "-DBUILD_OPNMIDI=OFF"
        "-DBUILD_EDMIDI=OFF"
    )

    if(NOT NINTENDO_3DS)
        list(APPEND AUDIO_CODECS_BUILD_ARGS
            "-DBUILD_GME=OFF"
            "-DBUILD_OGG_VORBIS=OFF"
        )
    endif()
else()
    list(APPEND AUDIO_CODECS_BUILD_ARGS
        "-DBUILD_OGG_VORBIS=${MIXER_USE_OGG_VORBIS_TREMOR}"
        "-DOGG_UNSAFE_DISABLE_CRC=${AUDIOCODECS_OGG_UNSAFE_DISABLE_CRC}"
        "-DBUILD_FLAC=OFF"
        "-DBUILD_MPG123=OFF"
        "-DBUILD_GME_SYSTEM_ZLIB=${USE_SYSTEM_ZLIB}"
        "-DBUILD_WAVPACK=${MIXERX_ENABLE_WAVPACK}"
    )
endif()

if(NINTENDO_WII OR NINTENDO_DS OR NINTENDO_3DS)
    list(APPEND AUDIO_CODECS_BUILD_ARGS
        "-DDISABLE_HEAVY_SYNTHS=ON"
    )
endif()

list(APPEND AUDIO_CODECS_BUILD_ARGS
    "-DUSE_LOCAL_SDL2=${USE_LOCAL_SDL2}"
    "-DBUILD_SDL2_SHARED=${PGE_SHARED_SDLMIXER}"
    "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
    ${ANDROID_CMAKE_FLAGS}
    ${VITA_CMAKE_FLAGS}
    ${VITA_AUDIOCODECS_CMAKE_FLAGS}
)

if(AUDIOCODECS_DISABLE_ASM_OPTIMIZATIONS)
    list(APPEND AUDIO_CODECS_BUILD_ARGS
        "-DBUILD_OPUS_DISABLE_RTCD=ON"
        "-DDISABLE_RTCD=ON"
    )
endif()

if(VITA OR NINTENDO_DS OR NINTENDO_3DS OR NINTENDO_WII OR NINTENDO_WIIU OR NINTENDO_SWITCH)
    list(APPEND AUDIO_CODECS_BUILD_ARGS
        -DENABLE_FPIC=OFF
    )
endif()

if(WIN32 AND "${TARGET_PROCESSOR}" STREQUAL "i386")
    # Disable SIMD on 32-bit Windows architecture to allow running on old computers
    list(APPEND AUDIO_CODECS_BUILD_ARGS
        -DDISABLE_SIMD=ON
    )
endif()

if(USE_SYSTEM_SDL2)
    # Ensure the SAME SDL2 directory will be used
    list(APPEND AUDIO_CODECS_BUILD_ARGS
        "-DSDL2_DIR=${SDL2_DIR}"
    )
endif()

list(REMOVE_DUPLICATES AUDIO_CODECS_BUILD_ARGS)

#message("DEBUG: Audio Codecs CMake: arguments: ${AUDIO_CODECS_BUILD_ARGS}")

ExternalProject_Add(
    AudioCodecs_Local
    PREFIX ${CMAKE_BINARY_DIR}/external/AudioCodecs
#    GIT_REPOSITORY https://github.com/WohlSoft/AudioCodecs.git
#   UPDATE_COMMAND ""
    DOWNLOAD_COMMAND ""
    SOURCE_DIR ${CMAKE_SOURCE_DIR}/3rdparty/AudioCodecs
    CMAKE_ARGS
        "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
        "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
        "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
        ${AUDIO_CODECS_BUILD_ARGS}
        $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
        $<$<BOOL:APPLE>:-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}>
        $<$<BOOL:WIN32>:-DCMAKE_SHARED_LIBRARY_PREFIX="">
    DEPENDS ${AudioCodecs_Deps}
    BUILD_BYPRODUCTS
        "${SDL2_SO_Lib}"
        "${SDL2_A_Lib}"
        "${SDL2_main_A_Lib}"
        "${AC_ZLIB}"
#        "${SDLHIDAPI_SO_Lib}" # No longer needed since SDL 2.0.18
        ${MixerX_CodecLibs}
)

list(APPEND MixerX_Deps AudioCodecs_Local)

if(NOT THEXTECH_NO_MIXER_X)
    set(MIXERX_CMAKE_FLAGS)
    if(USE_SYSTEM_SDL2)
        # Ensure the SAME SDL2 directory will be used
        list(APPEND MIXERX_CMAKE_FLAGS
            "-DSDL2_DIR=${SDL2_DIR}"
        )
    endif()

    # SDL Mixer X - an audio library, fork of SDL Mixer
    ExternalProject_Add(
        SDLMixerX_Local
        PREFIX ${CMAKE_BINARY_DIR}/external/SDLMixerX
    #    GIT_REPOSITORY https://github.com/WohlSoft/SDL-Mixer-X.git
    #    UPDATE_COMMAND ""
        DOWNLOAD_COMMAND ""
        SOURCE_DIR ${CMAKE_SOURCE_DIR}/3rdparty/SDL-Mixer-X
        CMAKE_ARGS
            "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
            "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
            "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
            "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
            "-DAUDIO_CODECS_REPO_PATH=${CMAKE_BINARY_DIR}/external/AudioCodecs"
            "-DAUDIO_CODECS_INSTALL_PATH=${DEPENDENCIES_INSTALL_DIR}"
            "-DUSE_SYSTEM_SDL2=${USE_SYSTEM_SDL2}"
            "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
            "-DSDL_MIXER_X_SHARED=${PGE_SHARED_SDLMIXER}"
            "-DAUDIO_CODECS_SDL2_HG_BRANCH=${SDL_BRANCH}"
            "-DAUDIO_CODECS_SDL2_GIT_BRANCH=${SDL_GIT_BRANCH}"
            "-DMIXERX_ENABLE_GPL=ON"
            "-DWITH_SDL2_WASAPI=ON"
            "-DUSE_MIDI_FLUIDLITE_OGG_STB=ON"
            "-DUSE_DRFLAC=ON"
            "-DUSE_FLAC=OFF"
            "-DUSE_WAVPACK=${MIXERX_ENABLE_WAVPACK}"
            "-DUSE_OGG_VORBIS_STB=${MIXER_USE_OGG_VORBIS_STB}"
            "-DUSE_OGG_VORBIS_TREMOR=${MIXER_USE_OGG_VORBIS_TREMOR}"
            "-DUSE_MP3_DRMP3=ON"
            "-DUSE_MP3_MPG123=OFF"
            "-DUSE_SYSTEM_ZLIB=${USE_SYSTEM_ZLIB}"
            ${MIXERX_CMAKE_FLAGS}
            ${ANDROID_CMAKE_FLAGS}
            ${VITA_CMAKE_FLAGS}
            ${VITA_MIXERX_CMAKE_FLAGS}
            $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
            $<$<BOOL:APPLE>:-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}>
            $<$<BOOL:WIN32>:-DCMAKE_SHARED_LIBRARY_PREFIX="">
        DEPENDS ${MixerX_Deps}
        BUILD_BYPRODUCTS
            "${SDL_MixerX_SO_Lib}"
            "${SDL_MixerX_A_Lib}"
    )

    target_link_libraries(PGE_SDLMixerX INTERFACE "${SDL_MixerX_SO_Lib}")
    target_link_libraries(PGE_SDLMixerX_static INTERFACE "${SDL_MixerX_A_Lib}")
endif()

if(USE_SYSTEM_SDL2)
    target_link_libraries(PGE_SDLMixerX INTERFACE ${SDL2_LIBRARIES})
elseif(WIN32 AND MINGW)
    target_link_libraries(PGE_SDLMixerX INTERFACE mingw32 "${SDL2_main_A_Lib}" "${SDL2_SO_Lib}" )
elseif(WIN32 AND MSVC)
    target_link_libraries(PGE_SDLMixerX INTERFACE "${SDL2_main_A_Lib}" "${SDL2_SO_Lib}")
else()
    target_link_libraries(PGE_SDLMixerX INTERFACE "${SDL2_SO_Lib}")
endif()


message("--- Detected system libraries list: ${MixerX_SysLibs} ---")
if(NOT THEXTECH_CLI_BUILD AND NOT THEXTECH_NO_MIXER_X)
    target_link_libraries(PGE_SDLMixerX_static INTERFACE ${MixerX_CodecLibs})
endif()

if(USE_SYSTEM_SDL2)
    target_link_libraries(PGE_SDLMixerX_static INTERFACE ${SDL2_LIBRARIES})
elseif(WIN32 AND MINGW)
    target_link_libraries(PGE_SDLMixerX_static INTERFACE mingw32 "${SDL2_main_A_Lib}" "${SDL2_A_Lib}" )
elseif((WIN32 AND MSVC) OR NINTENDO_3DS OR VITA)
    target_link_libraries(PGE_SDLMixerX_static INTERFACE "${SDL2_main_A_Lib}" "${SDL2_A_Lib}")
else()
    target_link_libraries(PGE_SDLMixerX_static INTERFACE "${SDL2_A_Lib}")
endif()

target_link_libraries(PGE_SDLMixerX_static INTERFACE ${MixerX_SysLibs})

#if(ANDROID) # No longer required since SDL 2.0.18
#    target_link_libraries(PGE_SDLMixerX_static INTERFACE "${SDLHIDAPI_SO_Lib}")
#endif()

if(PGE_SHARED_SDLMIXER AND NOT WIN32)
    install(FILES ${SDL_MixerX_SO_Lib} DESTINATION "${PGE_INSTALL_DIRECTORY}")
endif()


================================================
FILE: cmake/library_discord_rpc.cmake
================================================
add_library(PGE_DiscordRPC INTERFACE)

if(WIN32)
    if("${TARGET_PROCESSOR}" STREQUAL "i386" OR "${TARGET_PROCESSOR}" STREQUAL "x86_64")
        set(DISCORD_RPC_SUPPORTED ON)
    endif()
elseif(APPLE)
    if(NOT XTECH_MACOSX_TIGER AND ("${TARGET_PROCESSOR}" STREQUAL "x86_64" OR "${TARGET_PROCESSOR}" STREQUAL "arm64"))
        set(DISCORD_RPC_SUPPORTED ON)
    endif()
elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
    if("${TARGET_PROCESSOR}" STREQUAL "x86_64")
        set(DISCORD_RPC_SUPPORTED ON)
    endif()
endif()

if(DISCORD_RPC_SUPPORTED)
    option(THEXTECH_ENABLE_DISCORD_RPC "Enable Discord RPC support" OFF)
else()
    set(THEXTECH_ENABLE_DISCORD_RPC OFF CACHE BOOL "" FORCE)
    mark_as_advanced(THEXTECH_ENABLE_DISCORD_RPC)
endif()

if(DISCORD_RPC_SUPPORTED AND THEXTECH_ENABLE_DISCORD_RPC)
    set(libDiscordRpc_Libs "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}discord-rpc${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")
    set(THEXTECH_DISCORD_APPID nullptr CACHE STRING "Discord Application ID for the Risch Presence work")

    ExternalProject_Add(
        DiscordPRC_Local
        PREFIX ${CMAKE_BINARY_DIR}/external/DiscordRPC
        DOWNLOAD_COMMAND ""
        SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/thextech-discord-rpc
        CMAKE_ARGS
            "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
            "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
            "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
            "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
            "-DCMAKE_POSITION_INDEPENDENT_CODE=${FREETYPE_PIC}"
            "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
            "-DBUILD_EXAMPLES=OFF"
            ${ANDROID_CMAKE_FLAGS}
            $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
            $<$<BOOL:APPLE>:-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}>
        BUILD_BYPRODUCTS
            "${libDiscordRpc_Libs}"
    )

    message(STATUS "Discord RPC will be built: ${libDiscordRpc_Libs}")

    target_link_libraries(PGE_DiscordRPC INTERFACE "${libDiscordRpc_Libs}")
    target_include_directories(PGE_DiscordRPC INTERFACE "${DEPENDENCIES_INSTALL_DIR}/include")
else()
    if(NOT DISCORD_RPC_SUPPORTED)
        message(STATUS "Discord RPC will be disabled: unsupported platform [SYS=${CMAKE_SYSTEM_NAME}, ARCH=${TARGET_PROCESSOR}]")
    else()
        message(STATUS "Discord RPC disabled by user's CMake option")
    endif()
endif()


================================================
FILE: cmake/library_glew.cmake
================================================
add_library(PGE_GLEW INTERFACE)

# GLEW is only used for the Windows builds
if(WIN32)
    set(GLEW_SUPPORTED ON)
else()
    set(GLEW_SUPPORTED OFF)
endif()

if(GLEW_SUPPORTED)
    option(THEXTECH_ENABLE_VENDORED_GLEW "Enable building of the vendored GLEW library" ON)
    mark_as_advanced(THEXTECH_ENABLE_VENDORED_GLEW)

    if(NOT THEXTECH_BUILD_GL_DESKTOP_MODERN)
        set(THEXTECH_ENABLE_VENDORED_GLEW OFF CACHE BOOL "")
    endif()
else()
    set(THEXTECH_ENABLE_VENDORED_GLEW OFF CACHE BOOL "" FORCE)
endif()

if(GLEW_SUPPORTED AND THEXTECH_ENABLE_VENDORED_GLEW)
    set(libglew_Libs "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}glew${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")

    ExternalProject_Add(
        GLEW_Local
        PREFIX ${CMAKE_BINARY_DIR}/external/glew-cmake
        DOWNLOAD_COMMAND ""
        SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/glew-cmake
        CMAKE_ARGS
            "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
            "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
            "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
            "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
            "-DCMAKE_POSITION_INDEPENDENT_CODE=${FREETYPE_PIC}"
            "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
            "-Dglew-cmake_BUILD_SHARED=OFF"
            "-DONLY_LIBS=ON"
            ${ANDROID_CMAKE_FLAGS}
            $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
            $<$<BOOL:APPLE>:-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}>
        BUILD_BYPRODUCTS
            "${libglew_Libs}"
    )

    message(STATUS "GLEW will be built in a place: ${libglew_Libs}")

    target_link_libraries(PGE_GLEW INTERFACE "${libglew_Libs}")
    target_include_directories(PGE_GLEW INTERFACE "${DEPENDENCIES_INSTALL_DIR}/include")
else()
    message(STATUS "GLEW will be disabled: unsupported platform")
endif()


================================================
FILE: cmake/library_luabind.cmake
================================================

# Note: You must also include "library_luajit.cmake" too!

add_library(PGE_LuaBind INTERFACE)

if(PGE_USE_LUAJIT)
    set(LUAJIT_USE_CMAKE_FLAG -DUSE_LUAJIT=ON)
    message("***** LuaJIT Lua in use! *****")
else()
    set(LUAJIT_USE_CMAKE_FLAG -DUSE_LUAJIT=OFF)
    message("***** PUC-Rio Lua in use! *****")
endif()

set(libLuaBind_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}luabind${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")

if(NOT LUABIND_SOURCE_DIR)
    set(LUABIND_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../3rdparty/luabind")
endif()

# LuaBind is a powerful lua binding library for C++
ExternalProject_Add(
    LuaBind_Local
    PREFIX ${CMAKE_BINARY_DIR}/external/luabind
    DOWNLOAD_COMMAND ""
    SOURCE_DIR "${LUABIND_SOURCE_DIR}"
    CMAKE_ARGS
        "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
        "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
        "-DCMAKE_CONFIGURATION_TYPES=${CMAKE_CONFIGURATION_TYPES}"
        "-DCMAKE_DEBUG_POSTFIX=d"
        "-DCMAKE_POSITION_INDEPENDENT_CODE=ON"
        ${ANDROID_CMAKE_FLAGS}
        ${LUAJIT_USE_CMAKE_FLAG}
        $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
    BUILD_BYPRODUCTS
        "${libLuaBind_Lib}"
)

if(PGE_USE_LUAJIT)
    add_dependencies(LuaBind_Local LuaJIT_local)
endif()

target_link_libraries(PGE_LuaBind INTERFACE "${libLuaBind_Lib}" PGE_LuaJIT)


================================================
FILE: cmake/library_luajit.cmake
================================================
add_library(PGE_LuaJIT INTERFACE)

set(PGE_USE_LUAJIT_ENABLED_BY_DEFAULT ON)
if(EMSCRIPTEN)
    # Disable LuaJIT for unsupported platforms
    set(PGE_USE_LUAJIT_ENABLED_BY_DEFAULT OFF)
endif()

option(PGE_USE_LUAJIT "Use LuaJIT lua engine" ${PGE_USE_LUAJIT_ENABLED_BY_DEFAULT})

#set(luajitArchive ${CMAKE_SOURCE_DIR}/_Libs/_sources/luajit.tar.gz)
#file(SHA256 ${luajitArchive} luajitArchive_hash)

set(libLuaJit_Lib "${DEPENDENCIES_INSTALL_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}luajit${PGE_LIBS_DEBUG_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")

set(LUAJIT_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../3rdparty/LuaJIT")

if(PGE_USE_LUAJIT)
    ExternalProject_Add(
        LuaJIT_local
        PREFIX ${CMAKE_BINARY_DIR}/external/luabind
        DOWNLOAD_COMMAND ""
        SOURCE_DIR "${LUAJIT_SOURCE_DIR}"
        CMAKE_ARGS
        "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
        "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
        "-DCMAKE_CONFIGURATION_TYPES=${CMAKE_CONFIGURATION_TYPES}"
        "-DCMAKE_DEBUG_POSTFIX=d"
        "-DCMAKE_POSITION_INDEPENDENT_CODE=ON"
        "-DLUAJIT_FORCE_UTF8_FOPEN=ON"
        ${ANDROID_CMAKE_FLAGS}
        ${LUAJIT_USE_CMAKE_FLAG}
        $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
    BUILD_BYPRODUCTS
        "${libLuaJit_Lib}"
    )

    target_link_libraries(PGE_LuaJIT INTERFACE ${libLuaJit_Lib})

elseif(PGE_USE_LUAJIT_LEGACY_BUILD)
    if(WIN32)
        set(MAKECMD "mingw32-make")
    else()
        set(MAKECMD "make")
    endif()
    if(APPLE)
        set(ENV{MACOSX_DEPLOYMENT_TARGET} "${CMAKE_OSX_DEPLOYMENT_TARGET}")
    endif()
    set(LUAJIT_LIBNAME libluajit$<$<CONFIG:Debug>:d>.a)
    string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER)
    if(${CMAKE_BUILD_TYPE_LOWER} STREQUAL "debug")
        message("== LuaJIT will be built in debug mode")
        set(BUILD_FLAGS "CCDEBUG=-g -O0")
    endif()

    if(WIN32)
        set(LUAJIT_INSTALL_COMMAND "")
    else()
        set(LUAJIT_INSTALL_COMMAND
            ${MAKECMD}
            install
            "INSTALL_ANAME=${LUAJIT_LIBNAME}"
            "BUILDMODE=static"
            "PREFIX=${CMAKE_BINARY_DIR}"
        )
    endif()

    set(LUAJIT_INSTALL_DIR ${CMAKE_BINARY_DIR})
    set(LUAJIT_LOCAL_SOURCE_DIR ${CMAKE_BINARY_DIR}/external/luajit/LuaJIT-src)

    ExternalProject_Add(
        LuaJIT_local
        PREFIX ${CMAKE_BINARY_DIR}/external/luajit
        URL ${luajitArchive}
        URL_HASH SHA256=${luajitArchive_hash}
        UPDATE_COMMAND ""
        CONFIGURE_COMMAND ""
        SOURCE_DIR ${LUAJIT_LOCAL_SOURCE_DIR}
        BUILD_IN_SOURCE 1
        BUILD_COMMAND
            ${MAKECMD} -s
            "BUILDMODE=static"
            "PREFIX=${CMAKE_BINARY_DIR}"
            "CCWARN+=-Wno-unused-function"
            ${BUILD_FLAGS}
        INSTALL_COMMAND "${LUAJIT_INSTALL_COMMAND}"
    BUILD_BYPRODUCTS
        "${libLuaJit_Lib}"
    )
    if(WIN32)
        set(LUAJIT_BINARY_FILES "luajit.exe")

        ExternalProject_Add_Step(
            LuaJIT_local CreateLuaJitInstallFolder
            COMMAND ${CMAKE_COMMAND} -E make_directory ${LUAJIT_INSTALL_DIR}/include/luajit-2.1 ${LUAJIT_INSTALL_DIR}/lib ${LUAJIT_INSTALL_DIR}/bin
            COMMENT "Creating install folder"
            DEPENDEES BUILD
        )

        ExternalProject_Add_Step(
            LuaJIT_local InstallLuaJitHeaders
            COMMAND ${CMAKE_COMMAND} -E copy lua.h lua.hpp luaconf.h luajit.h lualib.h lauxlib.h ${LUAJIT_INSTALL_DIR}/include/luajit-2.1
            WORKING_DIRECTORY ${LUAJIT_LOCAL_SOURCE_DIR}/src
            COMMENT "Installing luajit headers"
            DEPENDEES BUILD CreateLuaJitInstallFolder
        )

        ExternalProject_Add_Step(
            LuaJIT_local InstallLuaJitLib
            COMMAND ${CMAKE_COMMAND} -E copy libluajit.a "${LUAJIT_INSTALL_DIR}/lib/${LUAJIT_LIBNAME}"
            WORKING_DIRECTORY ${LUAJIT_LOCAL_SOURCE_DIR}/src
            COMMENT "Installing luajit lib"
            DEPENDEES BUILD CreateLuaJitInstallFolder
        )

        ExternalProject_Add_Step(
            LuaJIT_local InstallLuaJitDLL
            COMMAND ${CMAKE_COMMAND} -E copy ${LUAJIT_BINARY_FILES} ${LUAJIT_INSTALL_DIR}/bin
            WORKING_DIRECTORY ${LUAJIT_LOCAL_SOURCE_DIR}/src
            COMMENT "Installing luajit shared library"
            DEPENDEES BUILD CreateLuaJitInstallFolder
        )
    endif() #NOT WIN32

    target_link_libraries(PGE_LuaJIT INTERFACE ${libLuaJit_Lib})

endif()


================================================
FILE: cmake/library_syslibs.cmake
================================================
# In this file all the generic platform specific system libraries should be listed

set(THEXTECH_SYSLIBS)

if(WIN32 AND NOT EMSCRIPTEN)
    list(APPEND THEXTECH_SYSLIBS
        "version" opengl32 dbghelp advapi32 kernel32 winmm imm32 setupapi
    )
endif()

if(NINTENDO_SWITCH)
    list(APPEND THEXTECH_SYSLIBS
        EGL glapi drm_nouveau nx pthread GLESv2
    )
endif()

if(NINTENDO_WII)
    set(CMAKE_STANDARD_LIBRARIES "")
    set(CMAKE_C_STANDARD_LIBRARIES "")
    set(CMAKE_CXX_STANDARD_LIBRARIES "")
    list(APPEND THEXTECH_SYSLIBS
        db wiiuse fat bte asnd ogc m
        # vorbisidec ogg
    )
endif()

if(NINTENDO_WIIU)
    set(CMAKE_STANDARD_LIBRARIES "")
    set(CMAKE_C_STANDARD_LIBRARIES "")
    set(CMAKE_CXX_STANDARD_LIBRARIES "")
    list(APPEND THEXTECH_SYSLIBS
        wut m
    )
endif()

if(NINTENDO_3DS)
    list(APPEND THEXTECH_SYSLIBS
        citro2d citro3d ctru #vorbisidec ogg
    )
endif()

if(NOT WIN32 AND NOT EMSCRIPTEN AND NOT APPLE AND NOT ANDROID AND NOT NINTENDO_SWITCH AND NOT NINTENDO_WIIU)
    if(THEXTECH_BUILD_GL_ES_MODERN AND NOT THEXTECH_BUILD_GL_DESKTOP_MODERN AND NOT THEXTECH_BUILD_GL_DESKTOP_LEGACY)
        find_library(_LIB_GL GLESv2)
    else()
        find_library(_LIB_GL GL)
    endif()

    if(_LIB_GL)
        list(APPEND THEXTECH_SYSLIBS ${_LIB_GL})
    endif()

    if(BCMHOST_H) # Raspberry Pi dependencies
        find_library(BCM_HOST_LIBRARY bcm_host)
        if(BCM_HOST_LIBRARY)
            list(APPEND THEXTECH_SYSLIBS ${BCM_HOST_LIBRARY})
        endif()

        find_library(VCOS_LIBRARY vcos)
        if(VCOS_LIBRARY)
            list(APPEND THEXTECH_SYSLIBS ${VCOS_LIBRARY})
        endif()

        find_library(VCHIQ_ARM_LIBRARY vchiq_arm)
        if(VCHIQ_ARM_LIBRARY)
            list(APPEND THEXTECH_SYSLIBS ${VCHIQ_ARM_LIBRARY})
        endif()
    endif()

    find_library(_lib_pthread pthread)
    if(_lib_pthread)
        list(APPEND THEXTECH_SYSLIBS ${_lib_pthread})
    endif()

    find_library(_lib_dl dl)
    if(_lib_dl)
        list(APPEND THEXTECH_SYSLIBS ${_lib_dl})
    endif()
endif()

if(ANDROID)
    list(APPEND THEXTECH_SYSLIBS
        GLESv1_CM GLESv2 OpenSLES log dl android
    )
endif()

if(HAIKU)
    list(APPEND THEXTECH_SYSLIBS
        be device game media
    )
endif()

if(APPLE)
    macro(xtech_add_macos_library LIBRARY_NAME)
        find_library(MACOS_LIBRARY_${LIBRARY_NAME} ${LIBRARY_NAME})
        if(MACOS_LIBRARY_${LIBRARY_NAME})
            list(APPEND THEXTECH_SYSLIBS ${MACOS_LIBRARY_${LIBRARY_NAME}})
            message("-- Library ${LIBRARY_NAME} found")
        else()
            message("-- Library ${LIBRARY_NAME} NOT found")
        endif()
    endmacro()

    xtech_add_macos_library(CoreAudio)
    xtech_add_macos_library(CoreVideo)
    xtech_add_macos_library(CoreHaptics)
    xtech_add_macos_library(GameController)
    xtech_add_macos_library(IOKit)
    xtech_add_macos_library(Carbon)
    xtech_add_macos_library(Cocoa)
    xtech_add_macos_library(ForceFeedback)
    xtech_add_macos_library(Metal)
    xtech_add_macos_library(CoreFoundation)
    xtech_add_macos_library(AudioToolbox)
    xtech_add_macos_library(AudioUnit)
    xtech_add_macos_library(OpenGL)
endif()


================================================
FILE: cmake/library_zlib.cmake
================================================

if(NINTENDO_SWITCH OR XTECH_MACOSX_TIGER)
    set(PGE_SYSTEM_ZLIB_DEFAULT ON)
else()
    set(PGE_SYSTEM_ZLIB_DEFAULT OFF)
endif()

option(USE_SYSTEM_ZLIB "Use zlib library from the system" ${PGE_SYSTEM_ZLIB_DEFAULT})

add_library(PGE_ZLib INTERFACE)

if(USE_SYSTEM_ZLIB)
    find_package(ZLIB REQUIRED)
    target_include_directories(PGE_ZLib INTERFACE "${ZLIB_INCLUDE_DIRS}")
    target_link_libraries(PGE_ZLib INTERFACE ${ZLIB_LIBRARIES})
else()
    # ZLib copy from the AudioCodecs package
    set_static_lib(AC_ZLIB  "${DEPENDENCIES_INSTALL_DIR}/lib"   zlib)
    target_include_directories(PGE_ZLib INTERFACE "${DEPENDENCIES_INSTALL_DIR}/include")
    target_link_libraries(PGE_ZLib INTERFACE "${AC_ZLIB}")
endif()


================================================
FILE: cmake/ndk-stl-config.cmake
================================================
# Copy shared STL files to Android Studio output directory so they can be
# packaged in the APK.
# Usage:
#
#   find_package(ndk-stl REQUIRED)
#
# or
#
#   find_package(ndk-stl REQUIRED PATHS ".")

if(NOT ${ANDROID_STL} MATCHES "_shared")
  return()
endif()

function(configure_shared_stl lib_path so_base)
  message("Configuring STL ${so_base} for ${ANDROID_ABI}")
  configure_file(
    "${ANDROID_NDK}/sources/cxx-stl/${lib_path}/libs/${ANDROID_ABI}/lib${so_base}.so" 
    "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${so_base}.so" 
    COPYONLY)
endfunction()

if("${ANDROID_STL}" STREQUAL "libstdc++")
  # The default minimal system C++ runtime library.
elseif("${ANDROID_STL}" STREQUAL "gabi++_shared")
  # The GAbi++ runtime (shared).
  message(FATAL_ERROR "gabi++_shared was not configured by ndk-stl package")
elseif("${ANDROID_STL}" STREQUAL "stlport_shared")
  # The STLport runtime (shared).
  configure_shared_stl("stlport" "stlport_shared")
elseif("${ANDROID_STL}" STREQUAL "gnustl_shared")
  # The GNU STL (shared).
  configure_shared_stl("gnu-libstdc++/4.9" "gnustl_shared")
elseif("${ANDROID_STL}" STREQUAL "c++_shared")
  # The LLVM libc++ runtime (static).
  configure_shared_stl("llvm-libc++" "c++_shared")
else()
   message(FATAL_ERROR "STL configuration ANDROID_STL=${ANDROID_STL} is not supported")
endif()



================================================
FILE: cmake/overlays-16m.ld
================================================
/*--------------------------------------------------------------------------------
    ** Example linker script for ARM9 overlays **
--------------------------------------------------------------------------------*/

MEMORY {
    /* Placeholder LMA for overlays */
    ovlmem : ORIGIN = 0xb0000000, LENGTH = 0x10000000
}

PHDRS {
    /* Program header for the overlay table */
    ovltable  PT_LOAD FLAGS(0x200007);

    /* Program headers for each overlay (in order) */
    ovl_dsi PT_LOAD FLAGS(0x200007);
}

/* Overlays in main RAM */
SECTIONS {

    PROVIDE_HIDDEN( __ovlarea_main_start = . );
    PROVIDE_HIDDEN( __ovlarea_main_end = . );

    /* ======== Overlay 'dsi' ======== */

    . = __ovlarea_main_start;

    .ovl.dsi ALIGN(32) : {
        EXCLUDE_FILE(*.a *libnds9*.a *libcalico_ds9*.a *16m.o) *(.text .text.* .gnu.linkonce.t.* .glue_7t .glue_7 .vfp11_veneer .v4_bx)
        EXCLUDE_FILE(*.a *libnds9*.a *libcalico_ds9*.a *16m.o) *(.rodata .rodata1 .rodata.* .gnu.linkonce.r.*)
        EXCLUDE_FILE(*.a *libnds9*.a *libcalico_ds9*.a *16m.o) *(.data .data1 .data.* .gnu.linkonce.d.*)
        . = ALIGN(4);

        PROVIDE_HIDDEN( __ovl_ctor_start_dsi = . );
        KEEP( EXCLUDE_FILE(*.a *libnds9*.a *libcalico_ds9*.a *16m.o) *(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*) .init_array .ctors) )
        PROVIDE_HIDDEN( __ovl_ctor_end_dsi = . );
        KEEP( EXCLUDE_FILE(*.a *libnds9*.a *libcalico_ds9*.a *16m.o) *(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*) .fini_array .dtors) )
        PROVIDE_HIDDEN( __ovl_dtor_end_dsi = . );
    } AT>ovlmem :ovl_dsi = 0xff

    .ovl.dsi.bss . (NOLOAD) : {
        EXCLUDE_FILE(*.a *libnds9*.a *libcalico_ds9*.a *boot_16m.o) *(.bss .bss.* .dynbss .gnu.linkonce.b.* COMMON)
        . = ALIGN(4);
    } AT>ovlmem :ovl_dsi

    PROVIDE_HIDDEN( __ovl_dsi_end = . );
    __ovlarea_main_end = MAX(__ovlarea_main_end, .);

}
INSERT AFTER .twl.bss;

SECTIONS {

    .ovltable 0 : {
        /* Static ctors/dtors for overlay 'dsi' */
        LONG(__ovl_ctor_start_dsi)
        LONG(__ovl_ctor_end_dsi)
        LONG(__ovl_dtor_end_dsi)

    } AT>ovlmem :ovltable

}


================================================
FILE: cmake/package_switch.cmake
================================================
find_program(NACPTOOL nacptool REQUIRED)
message("-- napctool found: ${NACPTOOL}")

find_program(ELF2NRO elf2nro REQUIRED)
message("-- elf2nro found: ${ELF2NRO}")

add_custom_target(thextech_nacp ALL
    "${NACPTOOL}" --create
    "${THEXTECH_PACKAGE_NAME}"
    "${CPACK_PACKAGE_VENDOR}"
    "${THEXTECH_VERSION_1}.${THEXTECH_VERSION_2}.${THEXTECH_VERSION_3}"
    "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/thextech.nacp"
    DEPENDS thextech
    BYPRODUCTS "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/thextech.nacp"
)

add_custom_target(thextech_nro ALL
    "${ELF2NRO}"
    "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/thextech.elf"
    "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/thextech.nro"
    "--icon=${TheXTech_SOURCE_DIR}/resources/switch/thextech-logo.jpg"
    "--nacp=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/thextech.nacp"
    DEPENDS thextech thextech_nacp
)


================================================
FILE: cmake/package_vita.cmake
================================================

set(VITA_APP_NAME "TheXTech ${THEXTECH_VERSION_STRING}")
set(VITA_TITLEID "THEXTECH0")

set(VITA_VERSION "${THEXTECH_VERSION_1}${THEXTECH_VERSION_2}.${THEXTECH_VERSION_3}${THEXTECH_VERSION_4}")

# the next two variables are used by template.xml.in
set(XTECH_VITA_AUTHORS "By Wohlstand and ds-sloth. Ported by Axiom.")

if(NOT "${THEXTECH_VERSION_REL}" STREQUAL "")
    set(XTECH_VITA_SHORT_DESC "git ${GIT_BRANCH} #${GIT_COMMIT_HASH}")
else()
    set(XTECH_VITA_SHORT_DESC "Based on SMBX 1.3 by Redigit")
endif()

message("Configuring Packaging for PS Vita")
message("THEXTECH_EXECUTABLE_NAME = ${THEXTECH_EXECUTABLE_NAME}")
message("VITA_APP_NAME = ${VITA_APP_NAME}")
message("VITA_TITLEID = ${VITA_TITLEID}")
message("VITA_VERSION = ${VITA_VERSION}")
message("VITA_AUTHORS = ${XTECH_VITA_AUTHORS}")
message("VITA_DESC = ${XTECH_VITA_SHORT_DESC}")
install(TARGETS thextech DESTINATION .)

configure_file(${CMAKE_SOURCE_DIR}/resources/vita/sce_sys/livearea/contents/template.xml.in ${CMAKE_BINARY_DIR}/template.xml)

vita_create_self(${THEXTECH_EXECUTABLE_NAME}.self output/bin/thextech UNSAFE)
vita_create_vpk(${THEXTECH_EXECUTABLE_NAME}.vpk ${VITA_TITLEID} ${THEXTECH_EXECUTABLE_NAME}.self
    VERSION ${VITA_VERSION}
    NAME ${VITA_APP_NAME}
    FILE    ${CMAKE_SOURCE_DIR}/resources/vita/sce_sys/icon0.png sce_sys/icon0.png
            ${CMAKE_SOURCE_DIR}/resources/vita/sce_sys/livearea/contents/bg.png sce_sys/livearea/contents/bg.png
            ${CMAKE_SOURCE_DIR}/resources/vita/sce_sys/livearea/contents/startup.png sce_sys/livearea/contents/startup.png
            ${CMAKE_BINARY_DIR}/template.xml sce_sys/livearea/contents/template.xml
)

add_custom_target(copy 
    COMMAND cp ${THEXTECH_EXECUTABLE_NAME}.self eboot.bin
    DEPENDS ${THEXTECH_EXECUTABLE_NAME}.self
)


================================================
FILE: cmake/vita_buildprops.cmake
================================================
message("Set CMAKE Flags for Vita.")
include("$ENV{VITASDK}/share/vita.cmake" REQUIRED)

if(POLICY CMP0077)
    cmake_policy(SET CMP0077 NEW)
endif()

if(NOT VITA_MKSFOEX_FLAGS)
    set(VITA_MKSFOEX_FLAGS "-d ATTRIBUTE2=12") # ATTRIBUTE2=12 specifies we need more RAM.  
endif()


set(VITA_ADDTL_LIBS
    FLAC
    modplug
    opusfile
    opus
    vorbisfile
    vorbis
    ogg
    mpg123
    debugnet
    mathneon
    SceCtrl_stub
    SceMotion_stub
    SceHid_stub
    SceRtc_stub
    SceNetCtl_stub
    SceNet_stub
    SceLibKernel_stub
    ScePvf_stub
    SceAppMgr_stub
    SceAppUtil_stub
    ScePgf_stub
    ScePower_stub
    freetype
    png
    jpeg
    SceCommonDialog_stub
    m
    zip
    z
    pthread
    SceGxm_stub
    SceDisplay_stub
    SceSysmodule_stub
    SceTouch_stub
    SceAudio_stub
    SceAudioIn_stub
    vitashark
    SceShaccCg_stub
    SceSysmem_stub
    SceIofilemgr_stub
    SceKernelThreadMgr_stub
    SceKernelDmacMgr_stub
    SceVshBridge_stub
)

if(THEXTECH_BUILD_GL_ES_MODERN)
    list(APPEND VITA_ADDTL_LIBS
        SceShaccCgExt
        taihen_stub
        SceIme_stub
     )
endif()

# VITA_CMAKE_FLAGS is used in conjunction with ExternalProject_Add
set(VITA_CMAKE_FLAGS
    # General/TheXTech
    "-DVITA=1"
    "-DENABLE_FPIC=0"
    "-DUSE_STATIC_LIBC=OFF"

    # Free Image
    "-DCMAKE_POSITION_INDEPENDENT_CODE=OFF"
    "-DFREEIMAGE_SHARED=OFF"
    "-DFREEIMAGE_USE_SYSTEM_LIBPNG=ON"
    "-DFREEIMAGE_USE_SYSTEM_LIBJPEG=ON"

    # Audio Mixer
    "-DPGE_SHARED_SDLMIXER=OFF"
    "-DUSE_GME=ON"
    "-DUSE_MIDI=ON"
    "-DADLMIDI_LIBRARY="
    "-DBUILD_OGG_VORBIS=1"
    "-DLIBXMP_PIC=0"
)





================================================
FILE: debian/changelog
================================================
thextech-smbx (1.3.6-1ppa0) oneiric; urgency=low

  * All changes shown at the included changelog.txt file

 -- Vitaly Novichkov <admin@wohlnet.ru>  Tue, 04 Jan 2022 22:16:54 +0300


================================================
FILE: debian/control
================================================
Source: thextech-smbx
Section: games
Priority: optional
Maintainer: Vitaly Novichkov <admin@wohlnet.ru>
Build-Depends: cmake, build-essential, ninja-build, libsdl2-dev, libpng-dev, libjpeg-dev
Homepage: https://wohlsoft.ru

Package: thextech-smbx
Architecture: any
Depends: libsdl2-2.0-0, libpng16-16, libjpeg8
Description: The Mario fan game
 The Super Mario fan game developed by Andrew Spinks in the past


================================================
FILE: debian/copyright
================================================
####################################################################
#                      thextech-smbx                               #
####################################################################

Copyright (C) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>

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 3 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, see <https://www.gnu.org/licenses/>.


================================================
FILE: debian/rules
================================================
#!/usr/bin/make -f

BUILDDIR = build_dir

# secondly called by launchpad
build:
	mkdir $(BUILDDIR);
	cd $(BUILDDIR); cmake -DPGE_SHARED_SDLMIXER=OFF \
    -DUSE_SYSTEM_SDL2=ON \
    -DUSE_FREEIMAGE_SYSTEM_LIBS=ON \
    -DCMAKE_INSTALL_PREFIX=../debian/tmp/usr \
    -DCMAKE_BUILD_TYPE=MinSizeRel \
    -DTHEXTECH_FIXED_ASSETS_PATH=/usr/share/games/smbx \
    -DTHEXTECH_SOURCE_ASSETS_PATH="/full/path/to/unpacket/assets/thextech-smbx13-assets-full" \
    -DTHEXTECH_USER_DIR_NAME=".thextech-smbx" \
    -DDESKTOP_NAME="Super Mario Bros. X" \
    -DDESKTOP_GENERIC_NAME="Super Mario Bros. X" \
    -DDESKTOP_COMMENT="The Mario fan game" \
    -DTHEXTECH_EXECUTABLE_NAME="thextech-smbx" \
    -DTHEXTECH_PACKAGE_NAME="thextech-smbx" \
    ..
	make -C $(BUILDDIR)

# thirdly called by launchpad
binary: binary-indep binary-arch

binary-indep:
	# nothing to be done

binary-arch:
	cd $(BUILDDIR); cmake -P cmake_install.cmake
	mkdir debian/tmp/DEBIAN
	dpkg-gencontrol -pthextech-smbx
	dpkg --build debian/tmp ..

# firstly called by launchpad
clean:
	rm -f build
	rm -rf $(BUILDDIR)

.PHONY: binary binary-arch binary-indep clean


================================================
FILE: docs/README_3DS.md
================================================
# About TheXTech & its Nintendo 3DS Port

TheXTech is an open-source rewrite of Super Mario Bros X. in C/++.
The original was written in VB6, targeting Windows only and eating up 2-3Gb of resources easily.

## 3DS Installation Guide

0. You are required to use the hacked 3DS.
1. Download and place the `thextech.3dsx` at the "3ds" directory at the root of SD card.
2. Download one of the game assets packages for TheXTech from here:
  - Original packages (will work slow without conversion into native 3DS format) https://github.com/Wohlstand/TheXTech/wiki/Game-assets-packages
  - Pre-converted packages as ROMFS (Optimized for 3DS):
    - Super Mario Bros. X: https://builds.wohlsoft.ru/3ds/assets-smbx13-3ds.zip
    - Adventures of Demo: https://builds.wohlsoft.ru/3ds/assets-aod-3ds.zip
3. Extract the downloaded archive with all it's content
4. Created a folder on your 3ds named “3ds/thextech” (case matters) in root of your SD card
    sdmc:/3ds/thextech
5. Move all extracted folders & files from the computer to sdmc:/3ds/thextech.
    Upon completion, if you use the original (not optmizied for 3DS) package, your folder structure should look like this:
        sdmc:/3ds/thextech/battle/
        sdmc:/3ds/thextech/graphics/
        sdmc:/3ds/thextech/music/
        sdmc:/3ds/thextech/sound/
        sdmc:/3ds/thextech/worlds/
        sdmc:/3ds/thextech/gameinfo.ini
        sdmc:/3ds/thextech/intro.lvl
        sdmc:/3ds/thextech/music.ini
        sdmc:/3ds/thextech/outro.lvl
        sdmc:/3ds/thextech/sounds.ini
    Otherwise, if you downloaded a .romfs package, simply place it into `sdmc:/3ds/thextech/` directory and rename it into `sdmc:/3ds/thextech/assets.romfs`.

6. Run `TheXTech` application via Homebrew Launcher and enjoy.


### KNOWN ISSUES

- LunaLua/LuaJIT episodes are not supported. (ATWE: A Tiny World Episode immediately comes to mind. The Episode shows in the world list, but upon trying to load the game will gracefully exit.)
- Has <1s delays when loading music (can cause in-level stuttering)
- Has <1s delays when loading PNG or GIF images (can cause in-level stuttering)
- Minor graphical glitches (images sometimes do not line up correctly, leaving gaps)
- Has several performance issues related to 3DS's slow SD card filesystem access
  - Has >10s delays when loading unpacked episodes
  - Has ~2s delays when loading images from unpacked episodes (will cause in-level stuttering)
  - Has ~2s delays when storing game saves or settings to the SD card
- Has several performance issues on the Old 3DS
  - Low framerates when playing with SPC and non-44.1 KHz music
  - Low framerates when section echo effects are active
  - Occasional crashes have been reported due to the Old 3DS's limited memory

# TheXTech Standard Readme


================================================
FILE: docs/README_DSI.md
================================================
# About TheXTech & its Nintendo DSi Port

TheXTech is an open-source rewrite of Super Mario Bros X. in C++.
The original was written in VB6, targeting Windows only and eating up 2-3 GB of memory easily.

The DSi has 16 MB of system memory and 512 KB of video memory.

## DSi Installation Guide

0. You are required to use a hacked DSi. The game runs best through hbmenu but may work with other launchers. It is confirmed not to work with unlaunch.
1. Download and place the `thextech.nds` at any convenient directory on your SD.
2. Create a folder on your DSi named “/TheXTech/assets/” from the root of your SD card:
    sd:/TheXTech/assets/
3. Download one of the game assets packages for TheXTech from here:
  - Pre-converted packages in the dsi.xta format (optimized for DSi):
    - Super Mario Bros. X: https://www.wohlsoft.ru/projects/TheXTech/_downloads/assets/thextech-smbx13.dsi.xta
    - Adventures of Demo: https://www.wohlsoft.ru/projects/TheXTech/_downloads/assets/thextech-aod.dsi.xta
  - Place the file into the assets folder you created in the previous step:
    For instance, sd:/TheXTech/assets/thextech-aod.dsi.xta
4. Wait for the XTConvert tool to be released to convert your episodes to the dsi.xte format.
5. Place any converted episodes in sd:/TheXTech/worlds/smbx/ or sd:/TheXTech/worlds/aod/.
6. Run `TheXTech` application via Homebrew Launcher and enjoy.

## DSi Usage Guide

- For consistency with other platforms, the game uses B for jump/accept and Y for run/back. The keybindings can be configured in the options menu.
- The DSi screen resolution is 256x192 which yields a significantly smaller playfield than SMBX 1.3's 800x600. The L shoulder button toggles the viewport to match SMBX 1.3's. You can further customize the resolution in the options.

### KNOWN ISSUES

- This is a build straight off of TheXTech's development tree and may contain unexpected bugs
- Most content is playable, but depending on level content, performance may drop as low as 1 FPS
- On launchers other than hbmenu, the system crashes on attempting to exit the game
- Music/sound volume may be unbalanced at times
- Has <1s delays when loading music (can cause in-level stuttering)
- Minor graphical glitches (images sometimes do not line up correctly, leaving gaps)

# TheXTech Standard Readme


================================================
FILE: docs/README_SWITCH.md
================================================
# About TheXTech & its Nintendo Switch Port

TheXTech is an open-source rewrite of Super Mario Bros X. in C/++.
The original was written in VB6, targeting Windows only and eating up 2-3Gb of resources easily.

## Switch Installation Guide

0. You are required to use the hacked Switch.
1. Download and place the `thextech.nro` at the "switch" directory at the root of SD card.
2. Download one of the game assets packages for TheXTech from here: https://github.com/Wohlstand/TheXTech/wiki/Game-assets-packages
3. Extract the downloaded archive with all it's content
4. Created a folder on your Switch named “TheXTech” (case matters) in root of your SD card
        sdmc:/TheXTech
5. Move all extracted folders & files from the computer to sdmc:/TheXTech.
    Upon completion, your folder structure should look like this:
        sdmc:/TheXTech/battle/
        sdmc:/TheXTech/graphics/
        sdmc:/TheXTech/music/
        sdmc:/TheXTech/sound/
        sdmc:/TheXTech/worlds/
        sdmc:/TheXTech/gameinfo.ini
        sdmc:/TheXTech/intro.lvl
        sdmc:/TheXTech/music.ini
        sdmc:/TheXTech/outro.lvl
        sdmc:/TheXTech/sounds.ini

6. Run `thextech.nro` via homebrew and enjoy.


### KNOWN ISSUES

- LunaLua/LuaJIT episodes are not supported. (ATWE: A Tiny World Episode immediately comes to mind. The Episode shows in the world list, but upon trying to load the game will gracefully exit.)


# TheXTech Standard Readme


================================================
FILE: docs/README_VITA.ESP.md
================================================
# Acerca de TheXTech y su puerto para Vita

<La traducción aún está en desarrollo, lea la versión en inglés en el archivo README.md por ahora>


# Descripción básica de TheXTech


================================================
FILE: docs/README_VITA.RUS.md
================================================
# О TheXTech и его порте под Vita

<Перевод ещё в разработке, пожалуйста, почитайте пока английскую версию в файле README.md>


# Основное описание TheXTech


================================================
FILE: docs/README_VITA.md
================================================
# About TheXTech & its Vita Port

TheXTech is an open-source rewrite of Super Mario Bros X. in C/++.
The original was written in VB6, targeting Windows only and eating up 2-3Gb of resources easily.

*Almost* every other piece of code compiled with little fighting for the 333 Mhz RISC handheld. Performance is also *pretty good* if I do say so myself. SDL2 is being used for *everything* in this current version. Though, support for a more Vita-specific rendering engine may come at a later date.

## Vita Installation Guide

0. While possible to move all assets over FTP, it’s much faster and more reliable to mount your Vita over USB or move your Vita2SD to your computer and copy that way. You’ve been warned.
1. Download and install `thextech.vpk`.
2. Download one of the game assets packages for TheXTech from here: https://github.com/Wohlstand/TheXTech/wiki/Game-assets-packages
3. Extract the downloaded archive with all it's content
4. Created a folder on your Vita named “TheXTech” (case matters) in ux0:data
        ux0:data/TheXTech
5. Move all extracted folders & files from the computer to ux0:data/TheXTech.
    Upon completion, your folder structure should look like this:
        ux0:data/TheXTech/battle/
        ux0:data/TheXTech/graphics/
        ux0:data/TheXTech/music/
        ux0:data/TheXTech/sound/
        ux0:data/TheXTech/worlds/
        ux0:data/TheXTech/gameinfo.ini
        ux0:data/TheXTech/intro.lvl
        ux0:data/TheXTech/music.ini
        ux0:data/TheXTech/outro.lvl
        ux0:data/TheXTech/sounds.ini

6. Install `thextech.vpk` and enjoy.


### KNOWN ISSUES

- Slowdowns may happen.
- SOME Midi tracks may kill performance (specifcially: using the libOPNMidi backend. this is pretty rare and midi support through libOPN and libADL are all relatively new to SMBX)
- LunaLua/LuaJIT episodes are not supported. (ATWE: A Tiny World Episode immediately comes to mind. The Episode shows in the world list, but upon trying to load the game will gracefully exit.)


## Addendum

I was a huge fan, and VERY involved, in the original Super Mario Bros. X community as **Luigifan2010**.
When Wohlstand first came to me mid 2020 teasing TheXTech, I immediately thought about porting it
to the Vita. Well now, here it is. The stars finally aligned and I've taught myself enough C to figure
this out!

If you want to learn how to code, just do it! There are tons of resources out there.

And most of all, have FUN while playing this port!

- Axiom


# TheXTech Standard Readme


================================================
FILE: docs/README_WII.md
================================================
# About TheXTech & its Nintendo Wii Port

TheXTech is an open-source rewrite of Super Mario Bros X. in C/++.
The original was written in VB6, targeting Windows only and eating up 2-3Gb of resources easily.

## Wii Installation Guide

0. You are required to use the hacked Wii with installed Homebrew Channel.
1. Download and place files `boot.dol`, `icon.png`, and `meta.xml` at the "apps/thextech-wii" directory at the root of SD card.
2. Download one of the game assets packages for TheXTech from here:
  - Original packages (will work slow without conversion into native Wii format) https://github.com/Wohlstand/TheXTech/wiki/Game-assets-packages
  - Pre-converted packages (Optimized for Wii):
    - Super Mario Bros. X: https://builds.wohlsoft.ru/wii/assets-smbx13-wii.zip
    - Adventures of Demo: https://builds.wohlsoft.ru/wii/assets-aod-wii.zip
3. Extract the downloaded archive with all it's content
4. Created a folder on your Wii named “thextech” (case matters) in root of your SD card
    sdmc:/thextech
5. Move all extracted folders & files from the computer to sdmc:/thextech.
    Upon completion, your folder structure should look like this:
        sdmc:/thextech/battle/
        sdmc:/thextech/graphics/
        sdmc:/thextech/music/
        sdmc:/thextech/sound/
        sdmc:/thextech/worlds/
        sdmc:/thextech/gameinfo.ini
        sdmc:/thextech/intro.lvl
        sdmc:/thextech/music.ini
        sdmc:/thextech/outro.lvl
        sdmc:/thextech/sounds.ini

6. Run `TheXTech` application via Homebrew Channel and enjoy.


### KNOWN ISSUES

- **The Wii port is currently experimental and not fully tested.**
- LunaLua/LuaJIT episodes are not supported. (ATWE: A Tiny World Episode immediately comes to mind. The Episode shows in the world list, but upon trying to load the game will gracefully exit.)
- Background pictures (especially animated) may sometimes fail to load because of insufficient memory.
- Minor graphical glitches (images sometimes do not line up correctly, leaving gaps)
- Has several performance issues related to Wii's slow SD card access
  - Has <1s delays when loading images (will cause in-level stuttering)
  - Has ~1s delays when storing game saves or settings to the SD card

# TheXTech Standard Readme


================================================
FILE: docs/README_WIIU.md
================================================
# About TheXTech & its Nintendo Wii U Port

TheXTech is an open-source rewrite of Super Mario Bros X. in C/++.
The original was written in VB6, targeting Windows only and eating up 2-3Gb of resources easily.

## Wii U Installation Guide

0. You are required to use the hacked Wii U.

### Generic way (resources on SD card as a directory)
This is a simplest way to get the game work on Wii U, and this way even allows you to customise the stuff on the fly as you do on the PC.
HOWEVER, with this way, the game LOADS WERY SLOW on hardware because of the how SD card file system works on Wii U.

1. Download and place files `thextech.rpx`, `icon.png`, and `meta.xml` at the "wiiu/apps/thextech-wiiu" directory at the root of SD card.
2. Download one of the game assets packages for TheXTech from here: https://github.com/Wohlstand/TheXTech/wiki/Game-assets-packages
3. Extract the downloaded archive with all it's content
4. Created a folder "wiiu" in root of your SD card if not exist, and then, inside, make another directory named "thextech" (case matters)
    `sd:/wiiu/thextech`
5. Move all extracted folders & files from the computer to `sd:/wiiu/thextech`.
    Upon completion, your folder structure should look like this:
        sd:/wiiu/thextech/battle/
        sd:/wiiu/thextech/graphics/
        sd:/wiiu/thextech/music/
        sd:/wiiu/thextech/sound/
        sd:/wiiu/thextech/worlds/
        sd:/wiiu/thextech/gameinfo.ini
        sd:/wiiu/thextech/intro.lvl
        sd:/wiiu/thextech/music.ini
        sd:/wiiu/thextech/outro.lvl
        sd:/wiiu/thextech/sounds.ini

6. Run `TheXTech` application via Homebrew Launcher and enjoy.

### Packing into WOHB
To run game via this way, you are required to have the `wohbtool` program (a part of DevkitPro: https://github.com/devkitPro/wut-tools).

**Important note:** Currently CEMU doesn't support WOHB files yet (see details: https://github.com/cemu-project/Cemu/issues/962), so, use this way to play on hardware. In CEMU, the Generic way should work good and load fast.

1. Download the `thextech.rpx` file and place it at any convenient place on your PC.
2. Download one of the game assets packages for TheXTech from here: https://github.com/Wohlstand/TheXTech/wiki/Game-assets-packages
3. Extract the downloaded archive with all its content into new empty directory. If you want to add custom episodes, do that now: place any custom episodes that you want to play into the "worlds" sub-directory at the directory of extracted assets.
4. Run the `wuhbtool` with next arguments:
```
wuhbtool <path-to-RPX-file> <path-to-the-output-WOBH-file> --content=<path-to-assets-directory> --name="<Name-of-the-game>" --short-name="<NoTG>" --icon=<path-to-icon-file> --author="Put-the-name-of-game-creator"
```

**Where:**
- **path-to-RPX-file** - an absolute path to the `thextech.rpx` file that you downloaded recently.
- **path-to-the-output-WOBH-file** - An absolute or relative path to the output filename that will be created. It should end with the ".wohb" suffix.
- **Name-of-the-game** - The understandible name of the game. Give it name from an assets name, for example, "Adventures of Demo", "Lowser's Conquest", etc.
- **NoTG** - The shortened name of the game, can be just an acronym.
- **path-to-icon-file** - The absolute path to the icon file that will be used as game icon: Give an absolute path to assets' "graphics/ui/icon/thextech_128.png" file that is being used as a game icon of the assets package.
- **Put-the-name-of-game-creator** - The name of the author who created the game of this assets pack. For example, "Redigit" (SMBX), "Wohlstand" (AoD), "Talkhaus" ('Analogue Funk' or 'Prelude To The Stupid'), "Sednaiur" (Lowser's Conquest), etc.

After you run the tool with giving proper arguments values, you will get the .wobh file that you can run on your hardware Wii U and have faster loading time.

And now, you can try to launch the package throgh the Aroma or something also.

In addition, there is a note that unlike the generic way, game saves and other stuff appears in different places:
- Settings and game saves will appear at the system-wide gamesave directory. The name of directory is directly depends on the name of the WOHB file, and if you rename it, the gamesave directory will be changed!
- If you plugged an SD card or USB stick, the `wiiu/thextech-user/<title-id>` sub-directory will appear on it: here are screenshots and logs will be saved.
- Inside `wiiu/thextech-user` directory, there are sub-directories with the "Title-ID" value (a hexidecial number) that will contain the different stuff depending on currently running assets package.


### KNOWN ISSUES

- **The Wii U port is currently experimental and not fully tested.**
- Has a very long loading when placing all resources on SD card: the file system of SD card is slow. Suggested to make a WUHB package and run it as a monolythig game package.
- Running the release build on CEMU, you may notice that control gets lost after returning back to the world map. The source of error are bugs in the CEMU's recompiler. To escape this until these bugs gets fixed later, it's need to run the CEMU with the `--force-interpreter` command-line argument.
- Attempt to change the scaling mode will lead a crash (at least on CEMU, not tested on hardware).

# TheXTech Standard Readme


================================================
FILE: docs/editor.ini
================================================
[exit-codes]
any = "Any"
none = "None"
code1 = "Roulette"
code2 = "Orb #16"
code3 = "Leave"
code4 = "Key"
code5 = "Orb #41"
code6 = "Warp"
code7 = "Collect"
code8 = "Bar end"

[blkfam-overworld1]
name = "Overworld"
category = 1
icon = 63
blk332-adj = 236
blk332-slope = 1
blk332-group = 3
blk333-adj = 124
blk333-slope = 1
blk333-group = 3
blk335-adj = 896
blk335-slope = 1
blk335-group = 3
blk334-adj = 874
blk334-slope = 1
blk334-group = 3
blk65-adj = 12346789
blk65-altadj =
blk65-altgroup = 3
blk93-adj = 12346789
blk93-w = 4
blk93-h = 4
blk62-adj = 6
blk63-adj = 46
blk64-adj = 4
blk62-group = 1
blk63-group = 1
blk64-group = 1
blk189-adj = 6
blk190-adj = 46
blk191-adj = 4
blk189-group = 2
blk190-group = 2
blk191-group = 2

[blkfam-underground1]
name = "Underground"
category = 1
blk56-adj = 623
blk56-group = 1
blk57-adj = 46123
blk57-group = 1
blk58-adj = 412
blk58-group = 1
blk331-adj = 62389
blk331-group = 1
blk323-adj = 46123789
blk323-group = 1
blk330-adj = 41278
blk330-group = 1
blk324-adj = 236
blk324-group = 1
blk324-width = 2
blk324-slope = 2
blk325-adj = 214
blk325-group = 1
blk325-width = 2
blk325-slope = 2
blk326-adj = 236
blk326-slope = 1
blk326-group = 2
blk327-adj = 124
blk327-slope = 1
blk327-group = 2
blk329-adj = 896
blk329-slope = 1
blk329-group = 2
blk328-adj = 874
blk328-slope = 1
blk328-group = 2
blk59-adj = 12346789
blk59-altadj =
blk59-altgroup = 2
blk61-adj = 12346789
blk61-w = 4
blk61-h = 4

[blkfam-special1]
name = "Special"
category = 1
members = 193,192,60,188

[blkfam-sized1]
name = "Sized"
category = 1
members = 287

[blkfam-dungeon1]
name = "Dungeon"
category = 1
blk396-adj = 623
blk387-adj = 46123
blk402-adj = 412
blk395-adj = 62389
blk394-adj = 46123789
blk393-adj = 41278
blk386-adj = 1234689
blk390-adj = 1234678
blk385-adj = 46123
blk385-group = 1
blk403-adj = 412
blk403-group = 1
blk384-adj = 46123789
blk384-group = 1
blk383-adj = 41278
blk383-altadj = 1234678
blk383-group = 1
blk400-group = 2
blk399-group = 2
blk398-group = 2
blk401-group = 2
blk397-group = 3

[blkfam-clouds1]
name = "Clouds"
category = 1
blk372-group = 2
blk373-adj = 6
blk373-group = 1
blk374-adj = 46
blk374-group = 1
blk375-adj = 4
blk375-group = 1
blk379-adj = 6
blk380-adj = 46
blk381-adj = 46
blk382-adj = 4

[blkfam-misc1]
name = "Misc"
category = 1
blk66-adj = 6
blk67-adj = 46
blk68-adj = 4
blk576-adj = 12346
blk576-group = 1
blk577-adj = 12346789
blk577-group = 1
blk369-group = 2
blk388-group = 2
blk69-group = 2
blk371-adj = 12346
blk371-group = 3
blk405-adj = 12346789
blk405-group = 3

[blkfam-pipes1]
name = "Pipes"
category = 1
blk196-width = 2
blk196-adj = 2
blk196-altadj = 8
blk197-width = 2
blk197-adj = 28
blk376-height = 2
blk376-adj = 4
blk376-altadj = 6
blk377-height = 2
blk377-adj = 46
blk378-height = 2
blk378-adj = 428
blk378-width = 2
blk194-width = 2
blk194-adj = 2
blk194-altadj = 8
blk194-group = 1
blk195-width = 2
blk195-adj = 28
blk195-group = 1

[blkfam-overworld2]
name = "Overworld"
category = 2
icon = 40
blk39-adj = 623
blk40-adj = 46123
blk41-adj = 412
blk198-adj = 62389
blk200-adj = 46123789
blk200-altadj = 4612389
blk200-altadj = 4612378
blk199-adj = 41278
blk341-adj = 236
blk341-slope = 1
blk343-adj = 124
blk343-slope = 1
blk337-adj = 1234689
blk337-slope = 1
blk339-adj = 1234678
blk339-slope = 1
blk340-adj = 236
blk340-slope = 2
blk340-width = 2
blk342-adj = 124
blk342-slope = 2
blk342-width = 2
blk336-adj = 1234689
blk336-slope = 2
blk336-width = 2
blk338-adj = 1234678
blk338-slope = 2
blk338-width = 2

[blkfam-wood2]
name = "Wood"
category = 2
blk42-adj = 6
blk43-adj = 46
blk44-adj = 4
blk45-adj = 2
blk46-adj = 28

[blkfam-underground2]
name = "Underground"
category = 2
blk207-adj = 623
blk201-adj = 46123
blk208-adj = 412
blk203-adj = 62389
blk205-adj = 46123789
blk204-adj = 41278
blk214-adj = 689
blk213-adj = 46789
blk215-adj = 478
blk211-adj = 62389
blk211-height = 2
blk212-adj = 41278
blk212-height = 2
blk206-adj = 46123789
blk206-width = 2
blk206-height = 2
blk216-group = 1
blk216-adj = 46123

[blkfam-special2]
name = "Special"
category = 2
members = 370,293

[blkfam-sized2]
name = "Sized"
category = 2
members = 38,288,243,242

[blkfam-castle2]
name = "Castle"
category = 2
members = 504,502,491,511,498,490,493,494,495,496,492,499,497,500,501,503,506,507,508,510

[blkfam-misc2]
name = "Misc"
category = 2
members = 131,505,509
blk391-group = 1
blk391-adj = 6
blk392-group = 1
blk392-adj = 46
blk389-group = 1
blk389-adj = 4
blk573-group = 2
blk573-adj = 2
blk574-group = 2
blk574-adj = 28

blk209-group = 3
blk209-adj = 2
blk202-group = 3
blk202-altgroup = 4
blk202-adj = 28
blk210-group = 3
blk210-adj = 8
blk297-group = 4
blk297-adj = 2
blk298-group = 4
blk298-adj = 8


[blkfam-wood3]
name = "Wood"
category = 3
icon = 3

blk7-adj = 236
blk3-adj = 12346
blk6-adj = 124
blk15-adj = 23689
blk16-adj = 12346789
blk17-adj = 12478
blk275-adj = 478
blk276-adj = 46789
blk274-adj = 689


blk600-adj = 236
blk600-slope = 1

blk601-adj = 124
blk601-slope = 1

blk602-adj = 1234689
blk602-slope = 1

blk603-adj = 1234678
blk603-slope = 1


blk604-adj = 1236
blk604-slope = 2
blk604-width = 2

blk605-adj = 1234
blk605-slope = 2
blk605-width = 2

blk606-adj = 1234689
blk606-slope = 2

blk607-adj = 1234678
blk607-slope = 2


blk1-adj =
blk1-group = 1

blk92-adj =
blk92-width = 4
blk92-height = 4
blk92-group = 1


blk128-adj = 6
blk128-group = 4

blk127-adj = 46
blk127-group = 4

blk129-adj = 4
blk129-group = 4


blk595-adj = 6
blk595-height = 2
blk595-group = 4

blk596-adj = 46
blk596-height = 2
blk596-group = 4

blk597-adj = 4
blk597-height = 2
blk597-group = 4


blk270-adj = 236
blk270-group = 2

blk272-adj = 12346
blk272-group = 2

blk271-adj = 124
blk271-group = 2


blk633-adj =
blk633-group = 3

blk634-adj =
blk634-width = 2
blk634-height = 2
blk634-group = 3


[blkfam-desert3]
name = "Desert"
category = 3

blk162-adj = 236
blk163-adj = 12346
blk164-adj = 124
blk165-adj = 23689
blk166-adj = 12346789
blk167-adj = 12478
blk286-adj = 689
blk285-adj = 46789
blk284-adj = 478

blk183-adj = 12346
blk183-group = 2


blk635-adj = 236
blk635-slope = 1

blk637-adj = 124
blk637-slope = 1


blk636-adj = 1236
blk636-slope = 2
blk636-width = 2

blk638-adj = 1234
blk638-slope = 2
blk638-width = 2


blk94-adj = 236
blk94-group = 1
blk95-adj = 12346
blk95-group = 1
blk96-adj = 124
blk96-group = 1
blk97-adj = 23689
blk97-group = 1
blk98-adj = 12346789
blk98-group = 1
blk99-adj = 12478
blk99-group = 1
blk100-adj = 689
blk100-group = 1
blk101-adj = 46789
blk101-group = 1
blk102-adj = 478
blk102-group = 1


[blkfam-bonus3]
name = "Bonus"
category = 3
icon = 52

blk49-adj = 236
blk52-adj = 12346
blk610-adj = 124
blk50-adj = 23689
blk54-adj = 12346789
blk47-adj = 12478
blk608-adj = 689
blk48-adj = 46789
blk609-adj = 478

blk611-adj = 1246789
blk53-adj = 1234689
blk612-adj = 2346789
blk51-adj = 1234678


[blkfam-grass3]
name = "Grass"
category = 3
icon = 10

blk9-adj = 236
blk10-adj = 12346
blk11-adj = 124
blk18-adj = 23689
blk19-adj = 12346789
blk20-adj = 12478
blk279-adj = 689
blk278-adj = 46789
blk277-adj = 478

blk12-adj = 689
blk12-group = 1
blk13-adj = 46789
blk13-group = 1
blk14-adj = 478
blk14-group = 1


blk305-adj = 236
blk305-slope = 1

blk307-adj = 124
blk307-slope = 1

blk313-adj = 478
blk313-slope = 1

blk311-adj = 689
blk311-slope = 1


blk306-adj = 1236
blk306-slope = 2
blk306-width = 2

blk308-adj = 1234
blk308-slope = 2
blk308-width = 2

blk314-adj = 4789
blk314-slope = 2
blk314-width = 2

blk312-adj = 6789
blk312-slope = 2
blk312-width = 2


[blkfam-cave3]
name = "Cave"
category = 3


blk344-adj = 236
blk345-adj = 12346
blk346-adj = 124
blk347-adj = 23689
blk348-adj = 12346789
blk349-adj = 12478
blk350-adj = 689
blk351-adj = 46789
blk352-adj = 478

blk357-adj = 1236
blk357-slope = 2
blk357-width = 2

blk360-adj = 1234
blk360-slope = 2
blk360-width = 2

blk364-adj = 4789
blk364-slope = 2
blk364-width = 2

blk361-adj = 6789
blk361-slope = 2
blk361-width = 2


blk358-adj = 236
blk358-slope = 1

blk359-adj = 124
blk359-slope = 1

blk363-adj = 478
blk363-slope = 1

blk362-adj = 689
blk362-slope = 1

blk353-adj = 1246789
blk354-adj = 2346789
blk355-adj = 1234678
blk356-adj = 1234689


[blkfam-house3]
name = "House"
category = 3

blk219-adj = 236
blk220-adj = 124
blk221-adj = 689
blk222-adj = 478
blk217-adj = 28
blk218-adj = 46


[blkfam-water3]
name = "Water"
category = 3

blk586-adj = 236
blk587-adj = 12346
blk588-adj = 124
blk589-adj = 23689
blk590-adj = 12346789
blk591-adj = 12478
blk592-adj = 689
blk593-adj = 46789
blk594-adj = 478

blk580-adj = 236
blk580-group = 1
blk581-adj = 12346
blk581-group = 1
blk582-adj = 124
blk582-group = 1
blk583-adj = 23689
blk583-group = 1
blk584-adj = 12346789
blk584-group = 1
blk585-adj = 12478
blk585-group = 1

blk578-adj =
blk578-group = 2

blk599-adj =
blk599-width = 2
blk599-height = 2
blk599-group = 2

blk598-adj =
blk598-group = 3


[blkfam-pipes3]
name = "Pipes"
category = 3

blk22-adj = 28
blk22-width = 2
blk21-adj = 2
blk21-width = 2
blk21-adj = 8
blk21-width = 2

blk24-adj = 46
blk24-height = 2
blk23-adj = 4
blk23-height = 2
blk23-adj = 6
blk23-height = 2

blk182-adj =
blk182-width = 3
blk182-height = 3

blk31-adj = 6
blk32-adj = 46
blk33-adj = 4

blk294-adj = 2
blk295-adj = 28
blk296-adj = 8

blk35-adj = 28
blk35-width = 2
blk35-group = 1
blk34-adj = 2
blk34-width = 2
blk34-group = 1
blk34-adj = 8
blk34-width = 2
blk34-group = 1

blk570-adj = 46
blk570-height = 2
blk570-group = 1
blk569-adj = 4
blk569-height = 2
blk569-group = 1
blk569-adj = 6
blk569-height = 2
blk569-group = 1

blk571-adj =
blk571-width = 2
blk571-height = 2
blk571-group = 1

blk37-adj = 28
blk37-width = 2
blk37-group = 2
blk36-adj = 2
blk36-width = 2
blk36-group = 2
blk36-adj = 8
blk36-width = 2
blk36-group = 2

blk104-adj = 28
blk104-width = 2
blk104-group = 3
blk103-adj = 2
blk103-width = 2
blk103-group = 3
blk103-adj = 8
blk103-width = 2
blk103-group = 3


[blkfam-steampunk3]
name = "Steampunk"
category = 3

blk70-adj = 6
blk71-adj = 46
blk72-adj = 4

blk71-altgroup = 2

blk73-adj = 2
blk74-adj = 28
blk75-adj = 8

blk76-adj = 46
blk76-group = 1

blk77-adj = 6
blk77-group = 2
blk614-adj = 4
blk614-group = 2

blk78-adj = 6
blk78-width = 2
blk78-group = 2
blk613-adj = 4
blk613-width = 2
blk613-group = 2

blk185-adj = 8
blk185-width = 4
blk185-group = 3


[blkfam-dungeon3]
name = "Dungeon"
category = 3
members = 630,91,136,126,29

[blkfam-hurts3]
name = "Hurts"
category = 3
members = 406,267,268,269,30,110,109
blk30-group = 1
blk30-adj = 12346
blk406-group = 1
blk406-adj = 12346789

[blkfam-special3]
name = "Special"
category = 3
members = 2,4,5,55,159,186,224,225,226,620,621

[blkfam-sized3]
name = "Sized 3"
category = 3
members = 579,575,568,130,108,260,240,241,26,25,27,28

[blkfam-misc3]
name = "Misc 3"
category = 3
members = 132,572,457,458,168,8,290,289,280,107,106,105,184,223,187,160,112,111


[blkfam-sized4]
name = "Sized"
category = 4
members = 79,161,442,441,259,244,261,245,444,445,443,440,439,437,438

[blkfam-special4]
name = "Special"
category = 4
members = 88,89,90,169,281,282,283,615

[blkfam-grass4]
name = "Grass"
category = 4
icon = 81

blk80-adj = 623
blk81-adj = 46123
blk82-adj = 412
blk83-adj = 62389
blk87-adj = 46123789
blk84-adj = 41278
blk265-adj = 689
blk264-adj = 46789
blk266-adj = 478

blk86-adj = 1234689
blk86-altslope = 1
blk85-adj = 1234678
blk85-altslope = 1
blk263-adj = 2346789
blk263-altslope = 1
blk273-adj = 1246789
blk273-altslope = 1

blk488-adj = 46123
blk488-group = 1
blk489-adj = 46123789
blk489-group = 1

blk618-adj = 1234689
blk618-slope = 2
blk619-adj = 1234678
blk619-slope = 2

blk304-adj = 1234689
blk304-slope = 4
blk304-width = 4
blk303-adj = 1234678
blk303-slope = 4
blk303-width = 4

blk299-adj = 236
blk299-slope = 1

blk300-adj = 124
blk300-slope = 1

blk616-adj = 236
blk616-slope = 2
blk616-width = 2

blk617-adj = 124
blk617-slope = 2
blk617-width = 2

blk302-adj = 236
blk302-slope = 4
blk302-width = 4

blk301-adj = 124
blk301-slope = 4
blk301-width = 4

blk309-adj = 896
blk309-slope = 1

blk310-adj = 784
blk310-slope = 1


[blkfam-cave4]
name = "Cave"
category = 4

blk246-adj = 236
blk250-adj = 12346
blk247-adj = 124
blk252-adj = 23689
blk251-adj = 12346789
blk253-adj = 12478
blk248-adj = 689
blk254-adj = 46789
blk249-adj = 478

blk258-adj = 1234689
blk255-adj = 2346789
blk256-adj = 1246789
blk257-adj = 1234678


blk262-adj = 12346789
blk262-width = 4
blk262-height = 4


blk316-adj = 236
blk316-slope = 1

blk315-adj = 124
blk315-slope = 1

blk318-adj = 478
blk318-slope = 1

blk317-adj = 689
blk317-slope = 1


blk365-adj = 1236
blk365-slope = 2
blk365-width = 2

blk366-adj = 1234
blk366-slope = 2
blk366-width = 2

blk367-adj = 4789
blk367-slope = 2
blk367-width = 2

blk368-adj = 6789
blk368-slope = 2
blk368-width = 2


blk321-adj = 1236
blk321-slope = 4
blk321-width = 4

blk319-adj = 1234
blk319-slope = 4
blk319-width = 4

blk322-adj = 1234689
blk322-slope = 4
blk322-width = 4

blk320-adj = 1234678
blk320-slope = 4
blk320-width = 4


[blkfam-bonus4]
name = "Bonus"
category = 4
blk227-adj = 623
blk228-adj = 46123
blk229-adj = 412
blk230-adj = 62389
blk231-adj = 46123789
blk232-adj = 41278
blk233-adj = 689
blk234-adj = 46789
blk235-adj = 478

blk238-adj = 1234689
blk239-adj = 1234678
blk237-adj = 2346789
blk236-adj = 1246789

[blkfam-woods4]
name = "Woods"
category = 4
blk116-adj = 623
blk119-adj = 46123
blk117-adj = 412
blk120-adj = 62389
blk118-adj = 41278

[blkfam-misc4]
name = "Misc"
category = 4
members = 115,446,447,448
blk133-adj = 6
blk133-group = 1
blk134-adj = 46
blk134-group = 1
blk135-adj = 4
blk135-group = 1

[blkfam-lava4]
name = "Lava and Hurts"
category = 4
icon = 459

blk466-adj = 623
blk459-adj = 46123
blk460-adj = 412
blk463-adj = 62389
blk467-adj = 46123789
blk461-adj = 41278
blk465-adj = 689
blk462-adj = 46789
blk464-adj = 478

blk471-adj = 1234689
blk468-adj = 1234678
blk470-adj = 2346789
blk469-adj = 1246789

blk404-adj = 46123
blk404-group = 1
blk420-adj = 46123789
blk420-group = 1

blk481-adj = 1234689
blk481-slope = 1
blk483-adj = 1234678
blk483-slope = 1
blk487-adj = 2346789
blk487-slope = 1
blk484-adj = 1246789
blk484-slope = 1

blk473-adj = 1234689
blk473-slope = 2
blk475-adj = 1234678
blk475-slope = 2
blk477-adj = 2346789
blk477-slope = 2
blk478-adj = 1246789
blk478-slope = 2

blk480-adj = 236
blk480-slope = 1

blk482-adj = 124
blk482-slope = 1

blk472-adj = 236
blk472-slope = 2
blk472-width = 2

blk474-adj = 124
blk474-slope = 2
blk474-width = 2

blk486-adj = 896
blk486-slope = 1

blk485-adj = 784
blk485-slope = 1

blk476-adj = 896
blk476-slope = 2
blk476-width = 2

blk479-adj = 784
blk479-slope = 2
blk479-width = 2

blk408-adj = 2
blk408-group = 2
blk409-adj = 28
blk409-group = 2
blk407-adj = 8
blk407-group = 2

blk429-group = 3
blk428-group = 3
blk430-group = 3
blk431-group = 3

[blkfam-mansion4]
name = "Mansion"
category = 4
icon = 122

blk121-adj = 6
blk122-adj = 46
blk123-adj = 4
blk124-group = 2
blk125-group = 2
blk125-width = 2
blk125-height = 2

[blkfam-switch4]
name = "Switch"
category = 4
members = 170,171,172,173,174,175,176,177,178,179,180,181

[blkfam-castle4]
name = "Castle"
category = 4
blk425-adj = 623
blk424-adj = 46123
blk426-adj = 412
blk423-adj = 62389
blk422-adj = 46123789
blk421-adj = 41278
blk427-adj = 689
blk419-adj = 46789
blk436-adj = 478

blk415-adj = 1234689
blk416-adj = 1234678
blk417-adj = 2346789
blk418-adj = 1246789

blk450-adj = 1234689
blk450-slope = 1
blk449-adj = 1234678
blk449-slope = 1

blk452-adj = 236
blk452-slope = 1

blk451-adj = 124
blk451-slope = 1

blk453-group = 2
blk454-group = 2
blk456-group = 2
blk455-group = 2

blk435-adj = 623
blk435-group = 1
blk414-adj = 46123
blk414-group = 1
blk434-adj = 412
blk434-group = 1
blk412-adj = 62389
blk412-group = 1
blk413-adj = 46123789
blk413-group = 1
blk411-adj = 41278
blk411-group = 1
blk433-adj = 689
blk433-group = 1
blk410-adj = 46789
blk410-group = 1
blk432-adj = 478
blk432-group = 1

[blkfam-pipes4]
name = "Pipes"
category = 4
blk138-width = 2
blk138-adj = 2
blk138-altadj = 8
blk143-width = 2
blk143-adj = 28

blk147-height = 2
blk147-adj = 4
blk147-altadj = 6
blk153-height = 2
blk153-adj = 46

blk139-width = 2
blk139-adj = 2
blk139-altadj = 8
blk139-group = 1
blk144-width = 2
blk144-adj = 28
blk144-group = 1

blk148-height = 2
blk148-adj = 4
blk148-altadj = 6
blk148-group = 1
blk154-height = 2
blk154-adj = 46
blk154-group = 1

blk140-width = 2
blk140-adj = 2
blk140-altadj = 8
blk140-group = 2
blk145-width = 2
blk145-adj = 28
blk145-group = 2

blk149-height = 2
blk149-adj = 4
blk149-altadj = 6
blk149-group = 2
blk155-height = 2
blk155-adj = 46
blk155-group = 2

blk141-width = 2
blk141-adj = 2
blk141-altadj = 8
blk141-group = 3
blk146-width = 2
blk146-adj = 28
blk146-group = 3

blk150-height = 2
blk150-adj = 4
blk150-altadj = 6
blk150-group = 3
blk156-height = 2
blk156-adj = 46
blk156-group = 3

blk137-width = 2
blk137-adj = 2
blk137-altadj = 8
blk137-group = 4
blk142-width = 2
blk142-adj = 28
blk142-group = 4

blk151-height = 2
blk151-adj = 4
blk151-altadj = 6
blk151-group = 4
blk157-height = 2
blk157-adj = 46
blk157-group = 4

blk113-width = 2
blk113-adj = 2
blk113-altadj = 8
blk113-group = 5
blk114-width = 2
blk114-adj = 28
blk114-group = 5

blk152-height = 2
blk152-adj = 4
blk152-altadj = 6
blk152-group = 5
blk158-height = 2
blk158-adj = 46
blk158-group = 5

[blkfam-bricks5]
name = "Brick"
category = 5
blk291-adj = 12346
blk292-adj = 12346789

[blkfam-metal5-1]
name = "Plates"
category = 5
blk515-adj = 6
blk513-adj = 46
blk533-adj = 4
blk517-adj = 6
blk517-group = 1
blk514-adj = 46
blk514-group = 1
blk518-adj = 4
blk518-group = 1



[blkfam-pipes5-2]
name = "Pipes"
category = 5
blk564-adj = 2
blk555-adj = 28
blk552-adj = 8

blk557-adj = 2
blk557-group = 1
blk558-adj = 28
blk558-group = 1
blk566-adj = 8
blk566-group = 1


[blkfam-pipes5-3]
name = "Long Pipes"
category = 5
blk561-adj = 28
blk561-altadj = 2
blk561-altadj = 8
blk563-adj = 4
blk563-group = 1
blk559-adj = 6
blk551-adj = 46
blk560-adj = 4

blk550-adj = 62
blk556-adj = 24
blk553-adj = 268
blk554-adj = 248
blk565-adj = 68
blk567-adj = 48

blk546-adj = 2468
blk546-altadj =

blk516-adj = 2
blk516-group = 2
blk532-adj = 28
blk532-group = 2
blk531-adj = 8
blk531-group = 2


[blkfam-metal5-3]
name = "Misc"
category = 5
icon = 562
members = 512,539,538,542,543,544,545,547,548,549,562,534,535,536,537,540,541

[blkfam-ruins5]
name = "Ruins"
category = 5
members = 524,525,526,530,527,529
blk528-adj = 869
blk528-group = 1
blk519-adj = 2346789
blk519-altadj = 46789
blk519-group = 1
blk523-adj = 847
blk523-group = 1
blk522-adj = 1246789
blk522-altadj = 46789
blk522-group = 1
blk520-adj = 12346789
blk520-group = 1
blk521-adj =
blk521-altadj = 12346789
blk521-group = 1

[blkfam-char5]
name = "Char"
category = 5
members = 622,626,623,627,624,628,625,629,631,632



[bgofam-fences1]
name = "Fences"
category = 1
members = 23,24,25,86,129,130,131,147

[bgofam-hut1]
name = "Hut"
category = 1
icon = 16
members = 16,17

[bgofam-plants1]
name = "Plants"
category = 1
members = 21,22,127,128,18,20,84,85,19

bgo21-group = 1
bgo21-adj = 2
bgo22-group = 1
bgo22-adj = 28

[bgofam-water1]
name = "Water"
category = 1
members = 168,26,169,164
bgo168-adj = 46123
bgo169-adj = 46123789
bgo26-group = 1
bgo26-adj = 46123
bgo164-group = 1
bgo164-adj = 46123789

[bgofam-clouds1]
name = "Clouds"
category = 1
members = 161


[bgofam-art2]
name = "Art"
category = 2
members = 148,149,150

[bgofam-doors2]
name = "Doors"
category = 2
icon = 88
members = 87,88

[bgofam-plants2]
name = "Plants"
category = 2
members = 111,112,113,110,62,108,109,63

[bgofam-water2]
name = "Water"
category = 2
bgo159-adj = 46123
bgo158-adj = 46123789


[bgofam-structures3]
name = "Structures"
category = 3
icon = 103
members = 89,94,80,67,81,46,91,95,106,101,102,45,90,96,36,68,69,93,97,99,162,163,103,107
bgo89-group = 1
bgo89-adj = 2
bgo91-group = 1
bgo91-adj = 28
bgo90-group = 1
bgo90-adj = 8

bgo94-group = 2
bgo94-adj = 2
bgo95-group = 2
bgo95-adj = 28
bgo96-group = 2
bgo96-adj = 8

bgo46-group = 3
bgo46-adj = 28
bgo45-group = 3
bgo45-adj = 8

bgo80-group = 4
bgo80-adj = 6
bgo67-group = 4
bgo67-adj = 46
bgo81-group = 4
bgo81-adj = 4


[bgofam-exit3]
name = "Exit"
category = 3
members = 33,34,13,61,60,12,11

[bgofam-tiles3]
name = "Tiles"
category = 3
members = 75,76,77,78,79,40,39,64,15,14

[bgofam-plants3]
name = "Plants"
category = 3
members = 1,2,3,4,5,6,7,8,9,10,114,37,38

[bgofam-water3]
name = "Water"
category = 3
members = 172,170,65,82,66,171,165,83

bgo172-adj = 12346
bgo66-adj = 12346789

bgo170-group = 1
bgo170-adj = 12346
bgo171-group = 1
bgo171-adj = 12346789

bgo65-group = 2
bgo65-adj = 12346
bgo165-group = 2
bgo165-adj = 12346789

bgo82-group = 3
bgo82-adj = 12346
bgo83-group = 3
bgo83-adj = 12346789

[bgofam-sandbg3]
name = "Sand BG"
category = 3
bgo189-adj = 12346
bgo190-adj = 12346789

[bgofam-sandfg3]
name = "FG"
category = 3
bgo188-adj = 12346
bgo187-adj = 12346789


[bgofam-fences4]
name = "Fences"
category = 4
icon = 179

bgo178-adj = 623
bgo179-adj = 46123
bgo180-adj = 412
bgo181-adj = 62389
bgo182-adj = 46123789
bgo183-adj = 41278
bgo184-adj = 689
bgo185-adj = 46789
bgo186-adj = 478

bgo177-adj = 1234689
bgo176-adj = 1234678
bgo175-adj = 2346789
bgo174-adj = 1246789

[bgofam-bars4]
name = "Bars"
category = 4
members = 134,138,142,143

bgo136-adj = 2
bgo134-adj = 28

bgo135-adj = 28
bgo135-group = 4

bgo138-group = 1
bgo138-adj = 2
bgo137-group = 1
bgo137-adj = 28

bgo142-group = 2
bgo142-adj = 2
bgo144-group = 2
bgo144-adj = 28

bgo143-group = 3
bgo143-adj = 2
bgo145-group = 3
bgo145-adj = 28


[bgofam-plants4]
name = "Plants"
category = 4
members = 59,52,53,54,55,56,57,58,32,31,28,27

[bgofam-ghost4]
name = "Ghost"
category = 4
members = 146,140,139,43,44,47,48,49,50,51

bgo43-group = 2
bgo43-adj = 2
bgo44-group = 2
bgo44-adj = 28

[bgofam-water4]
name = "Water"
category = 4
members = 173
bgo166-adj = 12346
bgo167-adj = 12346789

[bgofam-misc4]
name = "Misc"
category = 4
members = 133,132,29,42,41,30

[bgofam-platform4]
name = "Plat"
category = 4
members = 71,72,70,73,74,100

[bgofam-doors4]
name = "Doors"
category = 4
members = 141,104,105,92

[bgofam-key4]
name = "Key"
category = 4
icon = 35

members = 35


[bgofam-space5]
name = "Space Bug"
category = 5
members = 153,155,154,151,156,157,152

bgo153-group = 1
bgo153-adj = 2
bgo151-group = 1
bgo151-adj = 28
bgo152-group = 1
bgo152-adj = 8

[bgofam-temple5]
name = "Temple"
category = 5
icon = 126
members = 122,121,115,116,117,123,119,118,126,125,124,120

bgo122-group = 1
bgo122-adj = 2
bgo123-group = 1
bgo123-adj = 28
bgo124-group = 1
bgo124-adj = 8

bgo115-group = 2
bgo115-adj = 6
bgo116-group = 2
bgo116-adj = 46
bgo117-group = 2
bgo117-adj = 4

bgo119-group = 3
bgo119-adj = 28
bgo120-group = 3
bgo120-adj = 8


[npcfam-enemies1]
name = "Enemies"
members = 28,233,235,260,177,176,175,173,153,93,89,29,27
category = 1
icon = 89

[npcfam-vine1]
name = "Vine"
members = 223,222
category = 1

[npcfam-shell1]
name = "Shell"
members = 174,172
category = 1

[npcfam-plat1]
name = "Plat"
members = 106
category = 1

[npcfam-items1]
name = "Items"
members = 186,182,184,178,88
category = 1

[npcfam-boss1]
name = "Boss"
members = 200
category = 1


[npcfam-warp2]
name = "Warp"
members = 289,288
category = 2

[npcfam-vine2]
name = "Vine"
members = 215,216,217,218,219,220,221
category = 2

[npcfam-veg2]
name = "Veg"
members = 147,146,145,144,143,141,140,139,142,92
category = 2

[npcfam-blocks2]
name = "Blocks"
members = 157,156,155,154
category = 2

[npcfam-items2]
name = "Items"
members = 249,241,240,138,134
category = 2

[npcfam-exit2]
name = "Exit"
members = 41
category = 2

[npcfam-boss2]
name = "Boss"
members = 262,201,39
category = 2

[npcfam-enemies2]
name = "Enemies"
members = 272,247,206,135,132,131,130,129,25,19,20
category = 2
icon = 20

[npcfam-vine3]
name = "Vine"
members = 226,225,214,213
category = 3

[npcfam-exit3]
name = "Exit"
members = 11,16,97
category = 3

[npcfam-plat3]
name = "Plat"
members = 212,57,46,104
category = 3

[npcfam-char3]
name = "Char"
members = 198,101,75,94
category = 3

[npcfam-plant3]
name = "Plant"
members = 261,245,74,52,8,51
category = 3

[npcfam-shell3]
name = "Shell"
members = 5,7,24,73
category = 3

[npcfam-blocks3]
name = "Blocks"
members = 45,160,84,21,79,80,83,82,78,81,70,69,68,58,67
category = 3

[npcfam-boss3]
name = "Boss"
members = 267,86,15
category = 3
icon = 15

[npcfam-items3]
name = "Items"
members = 287,273,264,238,248,49,193,191,170,169,103,34,90,35,22,14,10,9
category = 3

[npcfam-enemies3]
name = "Enemies"
members = 259,244,161,137,136,76,72,71,54,53,48,47,38,37,36,23,17,12,6,2,1,3,4,231,230,229
category = 3
icon = 1

[npcfam-boss4]
name = "Boss"
members = 280
category = 4

[npcfam-vine4]
name = "Vine"
members = 227,224
category = 4

[npcfam-ckpt4]
name = "Ckpt"
category = 4
members = 192

[npcfam-sign4]
name = "Sign"
category = 4
members = 151

[npcfam-pet4]
name = "Pet"
members = 228,150,149,148,95,98,99,100
category = 4

[npcfam-plat4]
name = "Plat"
members = 190,105,66,64,62,60
category = 4

[npcfam-exit4]
name = "Exit"
members = 196,197,31
category = 4
icon = 31

[npcfam-items4]
name = "Items"
members = 279,278,277,274,258,239,195,188,187,183,185,96,56,33,32,26
category = 4

[npcfam-enemies4]
name = "Enemies"
members = 236,232,234,286,285,275,271,270,207,199,189,179,181,180,167,166,165,164,163,162,77,43,42,44,18,194,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109
category = 4
icon = 165

[npcfam-boss5]
name = "Boss"
members = 209,208
category = 5

[npcfam-switch5]
name = "Switch"
members = 65,63,61,59
category = 5

[npcfam-items5]
name = "Items"
members = 255,254,253,252,251,250,158,152
category = 5

[npcfam-enemies5]
name = "Enemies"
members = 257,256,243,242,211,205,204,203,168,128,127,126,125
category = 5
icon = 242

[npcfam-char5]
name = "Char"
members = 107,102
category = 5


[tilefam-grass1]
name = "Old Grass"
category = 1
tile20-adj = 623
tile21-adj = 46123
tile22-adj = 412
tile23-adj = 62389
tile11-adj = 46123789
tile24-adj = 41278
tile25-adj = 689
tile26-adj = 46789
tile17-adj = 478

tile19-adj = 1234689
tile18-adj = 1234678
tile16-adj = 2346789
tile15-adj = 1246789

tile40-adj =
tile41-group = 1
tile12-adj = 46123789
tile12-width = 2
tile12-height = 2
tile13-adj = 46123789
tile13-width = 2
tile13-height = 2


[tilefam-desert1]
name = "Dust"
category = 1
icon = 1
tile28-adj = 623
tile32-adj = 46123
tile29-adj = 412
tile33-adj = 62389
tile1-adj = 46123789
tile35-adj = 41278
tile30-adj = 689
tile34-adj = 46789
tile31-adj = 478

tile38-adj = 1234689
tile39-adj = 1234678
tile37-adj = 2346789
tile36-adj = 1246789

tile8-adj = 46123789
tile8-width = 2
tile8-height = 2
tile9-adj = 46123789
tile9-width = 2
tile9-height = 2

tile42-adj =
tile42-group = 1
tile6-adj = 46
tile6-group = 1
tile7-adj = 28
tile7-group = 1
tile5-adj = 26
tile5-group = 1
tile3-adj = 24
tile3-group = 1
tile2-adj = 86
tile2-group = 1
tile4-adj = 48
tile4-group = 1


[tilefam-snow1]
name = "Old Snow"
category = 1
tile48-adj = 623
tile53-adj = 46123
tile49-adj = 412
tile52-adj = 62389
tile10-adj = 46123789
tile54-adj = 41278
tile50-adj = 689
tile55-adj = 46789
tile51-adj = 478

tile46-adj = 1234689
tile44-adj = 1234678
tile45-adj = 2346789
tile43-adj = 1246789

tile47-adj =


[tilefam-grass2]
name = "Happy Grass"
category = 2
icon = 81

pod1-members = 79,80,81,82,83,67,56,73,69,66,72,57,89,102,61,70,74,68,76,59,65,71,62,64,58
pod1-width = 5
pod2-members = 92,93,90,91,106,105,96,94,104,103
pod2-width = 2

[tilefam-dirt2]
name = "Dead Grass"
category = 2
pod1-members = 137,144,126,125,132,122,114,134,119,121,127,112,143,135,116,145,138,118,133,115,120,128,117,111,113
pod1-width = 5
pod2-members = 139,141,136,142,123,124,131,140,129,130
pod2-width = 2

[tilefam-wall2]
name = "Dirt Wall"
category = 2
members = 95,240,14,27
pod1-members = 77,63,60,78,75,84,85,86,87,88
pod1-width = 5
pod2-members = 97,98,101,99,100,109,107,108,110
pod2-width = 3

[tilefam-granite3]
name = "Granite"
category = 3
icon = 256
pod1-members = 255,251,256,254,253,216,233,207,221,227,213,214,225,204,215,206,210,232,224,203,234,223,201,226,200,208,212,202,211,209
pod1-width = 5
pod2-members = 252,244,229,150,228,231,219,218,220,230,217,222
pod2-width = 2

[tilefam-marble3]
name = "Marble"
category = 3
pod1-members = 238,239,235,237,236,170,171,180,172,173,161,154,157,164,159,152,155,179,197,147,165,158,162,167,163,156,151,148,153,160
pod1-width = 5
pod2-members = 0,0,196,182,181,183,189,198,185,184,191,190
pod2-width = 2

[tilefam-stonewall3]
name = "Stone Wall"
category = 3
members = 192,193,199,205,195
pod1-members = 168,149,146,169,166,174,175,176,177,178,250,249,248,247,246
pod1-width = 5
pod2-members = 186,187,188,194,243,245
pod2-width = 2

[tilefam-lava3]
name = "Lava"
category = 3
members = 242,241,257,261,260,259,262,258,264,263

[tilefam-clouds4]
name = "Clouds"
category = 4
icon = 284
pod1-members = 318,319,323,320,322,279,285,284,291,288,272,268,298,278,271,280,267,286,302,283,289,287,273,275,265,270,281,290,269,266
pod1-width = 5
pod2-members = 324,321,293,309,292,294,306,314,304,305,313,312
pod2-width = 2

[tilefam-lilac4]
name = "Lilac Wall"
category = 4
pod1-members = 277,307,276,282,274,296,300,299,308,310,297,303,326,325,327
pod1-width = 5
pod2-members = 301,295,311,315,316,317,328
pod2-width = 3

[bg2fam-set1]
name = "Set 1"
sort-index = 1
members = 7,8,9,10,41,50,51
bg2-7-name = "Underground"
bg2-8-name = "Night"
bg2-9-name = "Night 2"
bg2-10-name = "Overworld"
bg2-41-name = "Castle"
bg2-50-name = "Mushrooms"
bg2-51-name = "Desert"

[bg2fam-set2]
name = "Set 2"
sort-index = 2
members = 5,25,44,48,49,52,53,54,57
bg2-5-name = "Trees"
bg2-25-name = "Underground"
bg2-44-name = "Castle"
bg2-48-name = "Clouds"
bg2-49-name = "Night - Hills"
bg2-52-name = "Night - Desert"
bg2-53-name = "Cliff"
bg2-54-name = "Warehouse"
bg2-57-name = "Dungeon"

[bg2fam-set3]
name = "Set 3"
sort-index = 3
members = 1,2,3,4,6,13,14,15,17,20,21,22,23,24,26,27,35,36,37,38,39,56
bg2-1-name = "Blocks"
bg2-2-name = "Hills"
bg2-3-name = "Dungeon"
bg2-4-name = "Pipes"
bg2-6-name = "Bonus"
bg2-13-name = "Clouds"
bg2-14-name = "Desert"
bg2-15-name = "Dungeon 2"
bg2-17-name = "Ship"
bg2-20-name = "Forest"
bg2-21-name = "Battle"
bg2-22-name = "Waterfall"
bg2-23-name = "Tanks"
bg2-24-name = "Final Boss"
bg2-26-name = "Shroom Dealer"
bg2-27-name = "Castle"
bg2-35-name = "Snow Trees"
bg2-36-name = "Clouds 2"
bg2-37-name = "Snow Hills"
bg2-38-name = "Cave"
bg2-39-name = "Cave 2"
bg2-56-name = "Underwater"

[bg2fam-set4]
name = "Set 4"
sort-index = 4
members = 12,18,19,28,29,30,31,11,32,34,33,42,43,55,58
bg2-12-name = "Trees"
bg2-18-name = "Mansion"
bg2-19-name = "Forest"
bg2-28-name = "Bonus"
bg2-29-name = "Night"
bg2-30-name = "Cave"
bg2-31-name = "Clouds"
bg2-11-name = "Hills"
bg2-32-name = "Hills 2"
bg2-34-name = "Hills 3"
bg2-33-name = "Hills 4"
bg2-42-name = "Castle"
bg2-43-name = "Castle 2"
bg2-55-name = "Underwater"
bg2-58-name = "Desert Night"

[bg2fam-misc]
name = "Misc."
sort-index = 5
members = 47,46,45,16,40
bg2-47-name = "Space Base"
bg2-46-name = "Space Ship"
bg2-45-name = "Space Swamp"
bg2-16-name = "Space Crater"
bg2-40-name = "Secret Mine"

[sndfam-player]
name = "Player"
sort-index = 1
snd1-name = "Jump"
snd2-name = "Stomp"
snd5-name = "Shrink"
snd6-name = "Grow"
snd10-name = "Skid"
snd23-name = "Grab"
snd25-name = "Hammer Toss"
snd71-name = "Climbing"
snd72-name = "Swim"
snd73-name = "Light Grab"
snd75-name = "Throw Veggie"
snd76-name = "Lose Heart"
snd33-name = "Tail"
snd17-name = "Warp"
snd24-name = "Spring"
snd46-name = "Door"
snd54-name = "Player Died 2"
snd15-name = "1up"
snd12-name = "Got Item"
snd34-name = "Racoon"
snd18-name = "Fireball"
snd35-name = "Lose Boot"

[sndfam-item]
name = "Item"
sort-index = 2
snd3-name = "Block Hit"
snd4-name = "Block Smashed"
snd7-name = "Powerup"
snd9-name = "Shell Kick"
snd14-name = "Coin"
snd16-name = "Lava"
snd22-name = "Bullet"
snd32-name = "Switch"
snd37-name = "Crusher"
snd56-name = "Ring"
snd57-name = "Skeleton"
snd58-name = "Checkpoint"
snd59-name = "Collectible"
snd61-name = "Lava Creature"
snd42-name = "Big Fireball"
snd74-name = "Saw"
snd43-name = "Fireworks"
snd64-name = "Space Block Hit"
snd65-name = "Space NPC Kill"
snd66-name = "Space NPC Hurt"
snd51-name = "Egg Hatch"


[sndfam-boss]
name = "Boss"
sort-index = 3
snd38-name = "Bird Spit"
snd39-name = "Bird Hit"
snd41-name = "Bird Beat"
snd44-name = "Turtle Killed"
snd62-name = "Frog Bubbles"
snd63-name = "Frog Killed"
snd67-name = "Glass Break"
snd68-name = "Space Boss Hit"
snd69-name = "Space Boss Cry"
snd70-name = "Space Boss Kill"


[sndfam-jingle]
name = "Jingle"
sort-index = 4
snd8-name = "Player Died"
snd19-name = "Roulette Exit"
snd20-name = "Defeat Boss"
snd21-name = "Dungeon Clear"
snd31-name = "Key Exit"
snd40-name = "Ball Exit"
snd45-name = "Game Beat"
snd52-name = "Got Star Exit"
snd60-name = "Bar Exit"


[sndfam-world]
name = "World"
sort-index = 5
snd27-name = "New Path"
snd28-name = "Level Select"


[sndfam-ui]
name = "UI"
sort-index = 6
snd11-name = "Drop Item"
snd13-name = "Camera"
snd26-name = "Slide"
snd29-name = "Do"
snd30-name = "Pause"
snd47-name = "Message"


[sndfam-hero]
name = "Hero"
sort-index = 7
snd53-name = "Hero NPC Kill"
snd77-name = "Hero Stab"
snd78-name = "Hero Hurt"
snd79-name = "Get Heart"
snd80-name = "Hero Died"
snd81-name = "Get Gem"
snd82-name = "Hero Fire"
snd83-name = "Hero Item"
snd84-name = "Get Key"
snd85-name = "Shield Block"
snd86-name = "Hermes Boots"
snd87-name = "Fly"
snd88-name = "Mow Lawn"


[sndfam-pet]
name = "Pet"
sort-index = 8
snd48-name = "Pet Mount"
snd49-name = "Pet Hurt"
snd50-name = "Pet Tongue"
snd55-name = "Pet Swallow"
snd36-name = "Pet Stomp"


[musfam-set1]
name = "Set 1"
sort-index = 1
mus9-name = "Overworld"
mus7-name = "Underground"
mus42-name = "Dungeon"
mus46-name = "Water"

[musfam-set2]
name = "Set 2"
sort-index = 2
mus5-name = "Overworld"
mus25-name = "Underground"
mus15-name = "Boss"
mus43-name = "Final Boss"

[musfam-set3]
name = "Set 3"
sort-index = 3
mus1-name = "Overworld"
mus2-name = "Sky"
mus4-name = "Underground"
mus3-name = "Dungeon"
mus47-name = "Water"
mus54-name = "Roaming Enemy"
mus6-name = "Boss"

[musfam-world]
name = "World"
sort-index = 4
mus10-name = "Overworld"
mus17-name = "Mansion"
mus28-name = "Sky"
mus29-name = "Cave"
mus41-name = "Dungeon"
mus48-name = "Water"
mus51-name = "Boss"

[musfam-rpg]
name = "RPG"
sort-index = 5
mus30-name = "Bachelor Pad"
mus34-name = "Town"
mus16-name = "Forest"
mus31-name = "Seaside"
mus32-name = "Pond"
mus33-name = "Clouds"
mus21-name = "Battle"

[musfam-64]
name = "64"
sort-index = 6
mus27-name = "Main Theme"
mus50-name = "Cave"
mus35-name = "Snow"
mus14-name = "Desert"
mus49-name = "Water"
mus26-name = "Castle"
mus36-name = "Boss"

[musfam-fight]
name = "Fight"
sort-index = 7
mus40-name = "Knight"
mus52-name = "Underground"
mus39-name = "Temple"
mus19-name = "Steampunk"
mus53-name = "Pinball"

[musfam-space]
name = "Space"
sort-index = 8
mus11-name = "Red Swamp"
mus12-name = "Crater"
mus44-name = "Item Room"
mus45-name = "Final Boss"
mus22-name = "Space Charge"

[musfam-misc]
name = "Misc."
sort-index = 9
mus38-name = "Jungle Village"
mus37-name = "Ice Mountain"
mus55-name = "Title Theme"
mus18-name = "Beach"
mus20-name = "Fusion Reactor"
mus56-name = "Bouncy Race"
mus13-name = "New Overworld"
mus23-name = "Heroic Woods"
mus8-name = "Cornered!"

[wmusfam-set3]
name = "Set 3"
members = 1,6,8,2,11,10,3,9
sort-index = 1
wmus1-name = "World 1"
wmus6-name = "World 2"
wmus8-name = "World 3"
wmus2-name = "World 4"
wmus11-name = "World 5"
wmus10-name = "World 6"
wmus3-name = "World 7"
wmus9-name = "World 8"

[wmusfam-world]
name = "World"
members = 4,16,15,7,13,14,12
sort-index = 2
wmus4-name = "Theme"
wmus16-name = "Cave"
wmus15-name = "Island"
wmus7-name = "Forest"
wmus13-name = "Dungeon"
wmus14-name = "Sky"
wmus12-name = "Special"

[wmusfam-new]
name = "New"
sort-index = 3
wmus5-name = "Theme"


================================================
FILE: fastlane/metadata/android/en-GB/changelogs/1030700.txt
================================================
This is a large update. We worked long and hard on this update, and we finally ready to present this big update for you all! This update will be the biggest in TheXTech's history and features a huge set of features, bugfixes, and improvements.

Thank you to @0lhi who served on our core development team for design and quality assurance from version v1.3.4 (2021) to v1.3.7 (2025). His contributions are much appreciated.

Read more here: https://github.com/Wohlstand/TheXTech/releases/tag/v1.3.7

================================================
FILE: fastlane/metadata/android/en-GB/changelogs/1030701.txt
================================================
This update features a lot of platform-related improvements and stabilisation. Since this update the exclusive full-screen modes on some platforms (such as retro computers) are supported to maintain the graphics performance which is impossible with the regular configuration and windowed mode.

Read more here: https://github.com/Wohlstand/TheXTech/releases/tag/v1.3.7.1


================================================
FILE: fastlane/metadata/android/en-GB/full_description.txt
================================================
This is a game engine for platforming games. This is a complete and extended port of source code of the SMBX 1.3 game engine originally writtein in MS Visual Basic 6, and its direct unofficial continuation after development of original halted in the 2011th year. This engine preserves full compatibility with levels and episodes made for the original SMBX game, including its repacks. And it's allowed to create brand-new Levels, Episodes, and content packs. Unlike the original SMBX game that depends on Windows and x86, TheXTech can work on many operating systems (including Linux distros, macOS, xBSD, Android, Haiku, etc.) and processor architectures (including x86_64, ARM, PowerPC, MIPS, etc.).

**NOTE:** This is a runtime engine only. It requires game packages to be downloaded and unpacked properly. Please follow this instruction in order to get any game work:
https://github.com/TheXTech/TheXTech/wiki/Running-game-assets-on-Android


================================================
FILE: fastlane/metadata/android/en-GB/short_description.txt
================================================
2D-platformer game engine

================================================
FILE: fastlane/metadata/android/en-GB/title.txt
================================================
TheXTech


================================================
FILE: fastlane/metadata/android/ru/full_description.txt
================================================
Это игровой движок для игр-платформеров. Это полный и расширенный порт из исходного кода движка SMBX 1.3, который изначально был создан через MS Visual Basic 6, а также, это его прямое неофициальное продолжение с тех пор, как разработка оригинала была прекращена в 2011м году. Данный движок сохраняет полную совместимость с уровнями и эпизодами для оригинальной SMBX-игры, включая её модифицированные издания. Также, под данный движок можно создавать совершенно новые уровни, эпизоды и наборы ресурсов. В отличии от первоначальной игры SMBX, которая зависит от Windows и архитектуры x86, TheXTech способен работать на широком спектре операционных систем (включая различные дистрибутивы Linux, macOS, xBSD, Android, Haiku и т.п.) и процессорных архитектурах (включая x86_64, ARM, PowerPC, MIPS, и т.п.).

**ПРИМЕЧАНИЕ:** Это чистый исполняемый движок, без каких либо игровых ресурсов. Чтобы на нём играть, нужно отдельно загружать и правильно распаковывать пакеты игровых ресурсов. Следуйте данной инструкции, чтобы узнать, как надо устанавливать игровые ресурсы и запустить игру:
https://github.com/TheXTech/TheXTech/wiki/Running-game-assets-on-Android


================================================
FILE: fastlane/metadata/android/ru/short_description.txt
================================================
Игровой движок для 2D-платформеров


================================================
FILE: lib/Allocator/Allocator.h
================================================
#ifndef ALLOCATOR_H
#define ALLOCATOR_H

#include <cstddef> // size_t

class Allocator
{
protected:
    std::size_t m_totalSize;
    std::size_t m_used;
    std::size_t m_peak;
public:

    Allocator(const std::size_t totalSize) : m_totalSize { totalSize }, m_used { 0 }, m_peak { 0 } { }

    virtual ~Allocator()
    {
        m_totalSize = 0;
    }

    virtual void* Allocate(const std::size_t size, const std::size_t alignment = 0) = 0;

    virtual void Free(void* ptr) = 0;

    virtual void Init() = 0;

    inline std::size_t getUsed()
    {
        return m_used;
    }

    friend class Benchmark;
};

#endif /* ALLOCATOR_H */



================================================
FILE: lib/Allocator/LICENSE
================================================
MIT License

Copyright (c) 2016 Mariano Trebino

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: lib/Allocator/LinearAllocator.cpp
================================================
#include "LinearAllocator.h"
#include "Utils.h"  /* CalculatePadding */
#include <stdlib.h>     /* malloc, free */
#include <cassert>   /*assert       */
#include <algorithm>    // max
#ifdef _DEBUG
#include <iostream>
#endif

LinearAllocator::LinearAllocator(const std::size_t totalSize)
    : Allocator(totalSize)
{}

void LinearAllocator::Init()
{
    if(m_start_ptr != nullptr)
    {
        free(m_start_ptr);
    }

    m_start_ptr = malloc(m_totalSize);
    m_offset = 0;
}

LinearAllocator::~LinearAllocator()
{
    free(m_start_ptr);
    m_start_ptr = nullptr;
}

void* LinearAllocator::Allocate(const std::size_t size, const std::size_t alignment)
{
    std::size_t padding = 0;
    // std::size_t paddedAddress = 0;
    const std::size_t currentAddress = (std::size_t)m_start_ptr + m_offset;

    if(alignment != 0 && m_offset % alignment != 0)
    {
        // Alignment is required. Find the next aligned memory address and update offset
        padding = Utils::CalculatePadding(currentAddress, alignment);
    }

    if(m_offset + padding + size > m_totalSize)
    {
        return nullptr;
    }

    m_offset += padding;
    const std::size_t nextAddress = currentAddress + padding;
    m_offset += size;

#ifdef _DEBUG
    std::cout << "A" << "\t@C " << (void*) currentAddress << "\t@R " << (void*) nextAddress << "\tO " << m_offset << "\tP " << padding << std::endl;
#endif

    m_used = m_offset;
    m_peak = std::max(m_peak, m_used);

    return (void*) nextAddress;
}

void LinearAllocator::Free(void* /*ptr*/)
{
    assert(false && "Use Reset() method");
}

void LinearAllocator::Reset()
{
    m_offset = 0;
    m_used = 0;
    m_peak = 0;
}


================================================
FILE: lib/Allocator/LinearAllocator.h
================================================
#ifndef LINEARALLOCATOR_H
#define LINEARALLOCATOR_H

#include "Allocator.h"

class LinearAllocator : public Allocator
{
protected:
    void* m_start_ptr = nullptr;
    std::size_t m_offset;
public:
    LinearAllocator(const std::size_t totalSize);

    virtual ~LinearAllocator();

    virtual void* Allocate(const std::size_t size, const std::size_t alignment = 0) override;

    virtual void Free(void* ptr) override;

    virtual void Init() override;

    virtual void Reset();
private:
    LinearAllocator(LinearAllocator& linearAllocator);
};

#endif /* LINEARALLOCATOR_H */


================================================
FILE: lib/Allocator/PoolAllocator.cpp
================================================
#include "PoolAllocator.h"
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>     /* malloc, free */
#include <fmt_format_ne.h>
#ifdef _BUILD
#include <iostream>
#endif
#include "core/msgbox.h"
#include "../sdl_proxy/sdl_stdinc.h"
#include "../sdl_proxy/sdl_assert.h"


PoolAllocator::PoolAllocator(const std::size_t totalSize, const std::size_t chunkSize)
    : Allocator(totalSize)
{
    assert(chunkSize >= 8 && "Chunk size must be greater or equal to 8");
    assert(totalSize % chunkSize == 0 && "Total Size must be a multiple of Chunk Size");

    this->m_chunkSize = chunkSize;
    this->m_chunkSizeH = chunkSize + sizeof(Node);
    this->m_capacity = totalSize / chunkSize;
}

void PoolAllocator::Init()
{
    m_start_ptr = SDL_malloc(m_totalSize + (m_capacity * sizeof(Node)));
    SDL_assert_release(m_start_ptr && "Out of memory: Can't allocate the pool allocator");
    this->Reset();
}

PoolAllocator::~PoolAllocator()
{
    SDL_free(m_start_ptr);
}

void* PoolAllocator::Allocate(const std::size_t allocationSize, const std::size_t /*alignment*/)
{
#ifdef NDEBUG
    (void)allocationSize;
#endif
    SDL_assert(allocationSize == this->m_chunkSize && "Allocation size must be equal to chunk size");

    Node* freePosition = m_freeList.pop();

    if(!freePosition)
    {
        // Fatal error
        XMsgBox::errorMsgBox("Fatal error",
            fmt::sprintf_ne("The pool allocator is full:\n"
            "- Total capacity: %zu items\n"
            "- Current number of free list: %zu\n"
            "- Maximum number of taken items: %zu\n"
            "\n"
            "Game will be closed. Please check logs for details.",
            m_capacity,
            m_freeList.count(),
            m_freeList.maximum())
        );
        abort();
    }

    m_used += m_chunkSize;
    m_peak = SDL_max(m_peak, m_used);

#ifdef _BUILD
    std::cout << "A" << "\t@S " << m_start_ptr << "\t@R " << (void*) freePosition << "\tM " << m_used << std::endl;
    std::cout.flush();
#endif

    ++m_count;
    if(m_count > m_maximum)
        m_maximum = m_count;

    return reinterpret_cast<void*>(freePosition->data);
}

void PoolAllocator::Free(void* ptr)
{
    if(reinterpret_cast<uintptr_t>(ptr) == 0)
        return;

    --m_count;
    m_used -= m_chunkSizeH;

    Node *n = reinterpret_cast<Node*>(reinterpret_cast<uintptr_t>(ptr) + m_chunkSize);
    if(n->data != reinterpret_cast<uintptr_t>(ptr))
    {
        // Fatal error
        XMsgBox::errorMsgBox("Fatal error",
            fmt::sprintf_ne("Attempt to free wrong memory block at the pool allocator:\n"
            "- Desired address: 0x%08llX\n"
            "- Reported in the node address: 0x%08llX\n"
            "\n"
            "Game will be closed. Please check logs for details.",
            reinterpret_cast<unsigned long long>(ptr),
            static_cast<unsigned long long>(n->data))
        );
        abort();
    }

    n->next = nullptr;

    m_freeList.push(n);

#ifdef _BUILD
    std::cout << "F" << "\t@S " << m_start_ptr << "\t@F " << ptr << "\tM " << m_used << std::endl;
    std::cout.flush();
#endif
}

void PoolAllocator::Reset()
{
    m_maximumPrev = m_maximum;
    m_count = 0;
    m_maximum = 0;
    m_used = 0;
    m_peak = 0;
    // Create a linked-list with all free positions
    const size_t nChunks = m_capacity;

    uintptr_t front = reinterpret_cast<uintptr_t>(m_start_ptr);
    uintptr_t back = reinterpret_cast<uintptr_t>(m_start_ptr) + (m_capacity * m_chunkSizeH);

    m_freeList.set_edges(reinterpret_cast<Node*>(front), reinterpret_cast<Node*>(back));

    uintptr_t address = reinterpret_cast<uintptr_t>(m_start_ptr);
    for(size_t i = 0; i < nChunks; ++i)
    {
        Node *n = reinterpret_cast<Node*>(address + m_chunkSize);
        n->data = address;
        n->next = nullptr;

        m_freeList.push(n);

        address += m_chunkSizeH;
    }
}

size_t PoolAllocator::maximum() const
{
    return m_maximum;
}

size_t PoolAllocator::prevMaximum() const
{
    return m_maximumPrev;
}


================================================
FILE: lib/Allocator/PoolAllocator.h
================================================
#pragma once
#ifndef POOL_ALLOCATOR_H
#define POOL_ALLOCATOR_H

#include <stdint.h>

#include "Allocator.h"
#include "StackLinkedList.h"

class PoolAllocator : public Allocator
{
private:
    typedef uintptr_t FreeHeader;
    using Node = StackLinkedList<FreeHeader>::Node;
    StackLinkedList<FreeHeader> m_freeList;

    void* m_start_ptr = nullptr;
    std::size_t m_chunkSize;
    std::size_t m_chunkSizeH;
    std::size_t m_capacity;

    size_t m_count = 0;
    size_t m_maximum = 0;
    size_t m_maximumPrev = 0;
public:
    PoolAllocator(const std::size_t totalSize, const std::size_t chunkSize);

    virtual ~PoolAllocator();

    virtual void* Allocate(const std::size_t size, const std::size_t alignment = 0) override;

    virtual void Free(void* ptr) override;

    virtual void Init() override;

    virtual void Reset();

    size_t maximum() const;
    size_t prevMaximum() const;
private:
    PoolAllocator(PoolAllocator& poolAllocator);

};

#endif // POOL_ALLOCATOR_H


================================================
FILE: lib/Allocator/README.md
================================================
Stuff taken from the repository: https://github.com/mtrebi/memory-allocators

<a href='http://www.recurse.com' title='Made with love at the Recurse Center'><img src='https://cloud.githubusercontent.com/assets/2883345/11325206/336ea5f4-9150-11e5-9e90-d86ad31993d8.png' height='20px'/></a>

# Table of Contents
&nbsp;[Introduction](https://github.com/mtrebi/memory-allocators#introduction)  <br/>
&nbsp;[Build instructions](https://github.com/mtrebi/memory-allocators#build-instructions)  <br/>
&nbsp;[What's wrong with Malloc?](https://github.com/mtrebi/memory-allocators#whats-wrong-with-malloc)  <br/>
&nbsp;[Custom allocators](https://github.com/mtrebi/memory-allocators#custom-allocators)  <br/>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[Linear Allocator](https://github.com/mtrebi/memory-allocators#linear-allocator)  <br/>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[Stack Allocator](https://github.com/mtrebi/memory-allocators#stack-allocator)  <br/>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[Pool Allocator](https://github.com/mtrebi/memory-allocators#pool-allocator)  <br/>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[Free list Allocator](https://github.com/mtrebi/memory-allocators#free-list-allocator)  <br/>
&nbsp;[Benchmarks](https://github.com/mtrebi/memory-allocators#benchmarks)  <br/>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[Time complexity](https://github.com/mtrebi/memory-allocators#time-complexity)  <br/>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[Space complexity](https://github.com/mtrebi/memory-allocators#space-complexity)  <br/>
&nbsp;[Summary](https://github.com/mtrebi/memory-allocators#summary)  <br/>
&nbsp;[Last thoughts](https://github.com/mtrebi/memory-allocators#last-thoughts)  <br/>
&nbsp;[Acknowledgments](https://github.com/mtrebi/memory-allocators#acknowledgments)  <br/>

# Introduction
When applications need more memory this can be allocated in the heap (rather than in the stack) in _runtime_. This memory is called 'dynamic memory' because it can't be known at compile time and its need changes during the execution. Our programs can ask for dynamic memory usin 'malloc'. Malloc returns an address to a position in memory where we can store our data. Once we're done with that data, we can call 'free' to free the memory and let others processes use it.

For this project I've implemented different ways to manage by ourselves dynamic memory in C++.This means that instead of using native calls like 'malloc' or 'free' we're going to use a custom memory allocator that will do this for us but in a more efficient way.
The goal, then, is to understand how the most common allocators work, what they offer and compare them to see which one performs better.

# Build instructions

```c
git clone https://github.com/mtrebi/memory-allocators.git
cmake -S memory-allocator -B build
cmake --build build
```

# What's wrong with Malloc?
* **General purpose**: Being a general purpose operation means that it must work in all cases (from 1byte to 1GB or more...). For this reason the implementation is not as efficient as it could be if the needs were more specific.
* **Slow**: Sometimes, when allocating memory, malloc needs to change from user to kernel mode to get more memory from the system. When this happens, malloc turns out to be super slow!

# Custom allocators
Because every program has specific needs, it makes no sense to use a general purpose allocator. We can choose the right allocator that works best for us. This way we can increase our **performance**.

In general, custom allocators share some features:
* **Low number of mallocs**: Any custom allocator tries to keep the number of mallocs low. To do that, they malloc _big chunks of memory_ and then, they manage this chunk internally to provide smaller allocations.
* **Data structures**: Secondary data structures like _Linked Lists_, _Trees_, _Stacks_ to manage these big chunks of memory. Usually they are used to keep track of the allocated and/or free portions of memory to _speed up_ operations.
* **Constraints**: Some allocators are very specific and have constraints over the data or operations that can be performed. This allows them to achieve a high performance but can only be used in some applications.

## Linear allocator
This is the simplest kind of allocator. The idea is to keep a pointer at the first memory address of your memory chunk and move it every time an allocation is done. In this allocator, the internal fragmentation is kept to a minimum because all elements are sequentially (spatial locality) inserted and the only fragmentation between them is the alignment.

### Data structure
This allocator only requires a pointer (or an offset) to tell us the position of the last allocation. It doesn't require any extra information or data structure.

![Data structure of a Linear Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/linear1.png)

_Complexity: **O(1)**_

### Allocate
Simply move the pointer (or offset) forward.

![Allocating memory in a Linear Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/linear2.png)

_Complexity: **O(1)**_

### Free
Due to its simplicity, this allocator doesn't allow specific positions of memory to be freed. Usually, all memory is freed together.

## Stack allocator
This is a smart evolution of the Linear Allocator. The idea is to manage the memory as a Stack. So, as before, we keep a pointer to the current memory address and we move it forward for every allocation. However, we also can move it backwards when a free operation is done. As before, we keep the spatial locality principle and the fragmentation is still very low.

### Data structure
As I said, we need the pointer (or offset) to keep track of the last allocation. In order to be able to free memory, we also need to store a _header_ for each allocation that tell us the size of the allocated block. Thus, when we free, we know how many positions we have to move back the pointer.

![Data structure of a Stack Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/stack1.png)

_Complexity: **O(N*H) --> O(N)**_ where H is the Header size and N is the number of allocations

### Allocate
Simply move the pointer (or offset) forward and place a header right before the memory block indicating its size.

![Allocating memory in a Stack Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/stack2.png)

_Complexity: **O(1)**_

### Free
Simply read the block size from the header and move the pointer backwards given that size.

![Freeing memory in a Stack Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/stack3.png)

_Complexity: **O(1)**_

## Pool allocator
A Pool allocator is quite different from the previous ones. It splits the big memory chunk in smaller chunks of the same size and keeps track of which of them are free. When an allocation is requested it returns the free chunk size. When a freed is done, it just stores it to be used in the next allocation. This way, allocations work super fast and the fragmentation is still very low.

![Splitting scheme in a Pool Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/pool1.png)

### Data structure
To keep track of the free blocks of memory, the Pool allocator uses a Linked List that links the address of each free memory block.

![Linked List used in a Pool Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/pool2.png)

To reduce the space needed, this **Linked List is stored in the same free blocks** (smart right?). However, this set the constraint that the data chunks must be at least as big as our nodes in the Linked List (so that, we can store the Linked List in the free memory blocks).

![In memory Linked List used in a Pool Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/pool3.png)

_Complexity: **O(1)**_

### Allocate
An allocation simply means to take (pop) the first free block of the Linked List.

![Allocation in a Pool Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/pool4.png)

The linked list doesn't have to be sorted. Its order its determined by the how the allocations and free are done.

![Random State of a Linked List in a Pool Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/pool5.png)

_Complexity: **O(1)**_

### Free
Free means to add (push) the freed element as the first element in the Linked List.

_Complexity: **O(1)**_

## Free list allocator

This is a general purpose allocator that, contrary to the others, doesn't impose any restriction. It allows allocations and deallocations to be done in any order. For this reason, its performance is not as good as its predecessors. Depending on the data structure used to speed up this allocator, there are two common implementations: one that uses a Linked List and one that uses a Red black tree.

### Linked list data structure
As the name says, this implementation uses a Linked List to store, in a sorted manner, the start address of each free contiguous block in memory and its size.
When an allocation is requested, it searches in the linked list for a block where the data can fit. Then it removes the element from the linked list and places an allocation header (used on deallocations) right before the data (as we did in the Stack allocator).
On deallocations, we get back the allocation header to know the size of the block that we are going to free. Once we free it we insert it into the sorted linked list and we try to merge contiguous memory blocks together creating bigger blocks.

*Notes: My implementation has some constraints on the size and alignment of the data that can be allocated using **this** allocator. For example, the minimum size that can be allocated should be equals or bigger than the size required of a Free Node. Otherwise, we would be wasting more space in meta-data than in real data (Something similar happens with the alignment) These constraints are related with my implementation. A better implementation would probably handle these cases. I decided not to do so because performance would be drastically affected. In these cases its probably better to use a different allocator.*

![Data structure in a Free list Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/freelist_seq1.png)

_Complexity: **O(N*HF + M*HA)--> O(M)**_ where N is the number of free blocks, HF is the size of the header of free blocks, M the number of allocated blocks and HA the size of the header of allocated blocks


### Linked list Allocate
 When an allocation is requested, we look for a block in memory where our data can fit. This means that we have to iterate our linked list until we find a block that has a size equal or bigger than the size requested (it can store this data plus the allocation header) and remove it from the linked list. This would be a **first-fit** allocation because it stops when it finds the first block where the memory fits. There is another type of search called **best-fit** that looks for the free memory block of smaller size that can handle our data. The latter operation may take more time because is always iterating through all elements but it can reduce fragmentation.

![Allocating in a Free list Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/freelist_seq2.png)

_Complexity: **O(N)**_ where N is the number of free blocks

### Linked list Free
First of all we get back the information about the allocation from the header. Then, we iterate the Linked List to intert the free block in the right position (because is sorted by address). Once we've inserted it, we merge contiguous blocks. We can merge in _O(1) because our Linked List is sorted. We only need to look at the previous and next elements in the linked list to see if we can merge this contiguous blocks. This operation of merging contiguous memory blocks to create bigger blocks is called _Coalescence_
If we used instead a Sorted Linked List of free and allocated blocks, the complexity would be *O(1)* but the allocation compleixity would be *O(N) where N is the number of free and allocated blocks and space complexity would be much higher. When we free a memory block we also look at the previous and next blocks to see if we can merge them into one bigger block.

![Freeing in a Free list Allocator](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/freelist_seq3.png)

_Complexity: **O(N)**_ where N is the number of free blocks

### Red black tree data structure
The purpose of using a Red black tree is to speed up allocations and deallocations. In the Linked List (or sequential) implementation every time an operation was made we needed to iterate the Linked List. This was O(N) in all cases.

Using Red Black trees we can reduce its complexity to O(log N) while keeping space complexity quite low because the tree data is stored inside the free memory blocks. In addition, this structure allows a **best-fit** algorithm to be used, reducing the fragmentation and keeping performance. However, an additional sorted Doubly Linked list is required to store allocated and free elements in order to be able to do coalescence operations in O(1).
This implementation is the most common and most used in real systems because it offers high flexibility while keeping performance very high.

# Benchmarks
Now its time to make sure that all the effort in designing and implementing custom memory allocators is worth.
I've made several benchmarks with different block sizes, number of operations, random order, etc. The time benchmark measures the time execution that takes initializing the allocator 'Init()' (malloc big chunk, setup additional data structures...) and untill the last operation (allocation or free) is performed.

Here I'm only showing what I believe is relevant for the goal of this project.

## Time complexity
* **Malloc** is without doubt the **worst allocator**.Due to its general and flexible use. _**O(n)**_
* **Free list allocator** is **A much better choice than malloc** as a general purpose allocator.It uses Linked List to speed up allocations/free. It's about three times better than malloc _**O(n)**_

The next allocator are even better BUT they are no longer general purpose allocators. They **impose restrictions** in how we can use them:
* **Pool allocator** forces us to always allocate the same size but then we can allocate and deallocate in any order. The complexity of this one is slightly better than the free list allocator, wait what? The complexity of the pool allocator was supposed to be constant not linear! And that's true. What its happening here is that the initialization of the additional data structure (the linked list) is _**O(n)**_. It has to create all memory chunks in then linked them in the linked list. This operation is hiding the truly complexity of the allocation and free operations that is _**O(1)**_.  So, take into account to initialize the Pool allocator (and all the allocators in general) before to avoid this kind of behaviors.
* **Stack allocator** can allocate any size, but deallocations must be done in a LIFO fashion with a _**O(1)**_ complexity. In the chart the complexity is not completely constant due to init function that has to allocate the first big chunk of memory, similarly as before in the pool allocator.
* **Linear allocator** is the simplest and the best performant allocator with a _**O(1)**_ complexity but its also the most restrictive because single free operations are not allowed. As with the stack, the complexity doesn't look completely constant due to the init function.

![Time complexity of different allocators](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/operations_over_time.png)

In the next chart we can see that if we don't include the Init() function in the benchmark, the overall execution time is reduced and as a consequence we can effectively see that the Linear, Stack and Pool allocators are constant while malloc and free list are clearly linear. The free list implementation using black tree can reduce the complexity to _**O(log n)**_ and therefore its position in the chart would be between the pool allocator and the free list.

![Time complexity of different allocators](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/operations_over_time_no_init.png)

_Note: The time complexity (in general) scales following a linear fashion regarding the size of the allocation request.

## Space complexity
As we can see, even that the space complexity for each allocator is slightly different(due to constants), in the end, all of them have the same space complexity **O(N)**. It is very clear, then, why when denoting big O, constants can be ignored: because its weight in the overall equation is very low when N grows.

![Space complexity of different allocators](https://github.com/mtrebi/memory-allocators/blob/master/docs/images/operations_over_space.png)

# Summary
This is a brief summary describing when you should use each allocator. From more restrictive and efficient allocators to less efficient and general.

* **Linear allocator**. If your data does not follows any specific structure. However, there's a common behavior in time: all data "expires" after a certain time and then is no longer useful and thus can be freed. Think about games for example, you can allocate data in one frame using a this allocator and free all data at the start of the next frame.
* **Stack allocator**. The same as the Linear allocator but think if it useful to free elements in a LIFO fashion.
* **Pool allocator**. Your data has definitely a structure. All elements of your data have the same size. This is your choice, fast and no fragmentation.
* **Buddy allocator** (_Not implemented here_). Your data is organized in exponential sizes power-of-two (1,2,4,8,16,32...). This allocator performs extremely well when data is structure in that way, being fast and wasting little space.
* **Free list allocator**. No structure or common behavior. This allocator allows you to allocate and free memory as you wish. This is a general purpose allocator that works much better than malloc, but is not as good as the previous allocators, given its flexibility to work in all situations.

# Last thoughts
* Avoid dynamic memory as much as possible. Its behavior is unexpected and a source of problems
* If you are worried about performance and your application uses dynamic memory, think about using a custom allocator instead of malloc
* Try to understand your data and its behavior to choose the right allocator for you. Specific allocators (that impose restrictions on how we can structure/use our data) are far more better than the generic ones. We saw a huge gap between the specific purpose allocator: **Linear, Stack and Pool** and the general purpose: **Free list and Malloc**
* Always choose a less restrictive (or more general) allocator if unsure. If you later see that your data is structured you can always change to use a more restrictive one.

# Future work
* Implement every memory allocator assuming that the alignment is always 8 bytes and thus everything is always align (we no longer need headers).
* Implement a Free list allocator using Red Black Trees to improve performance from O(N) to O(log N)
* Implement a Buddy allocator
* Implement a Slab allocator
* Benchmark internal fragmentation
* Benchmark spatial location (cache misses)

# Acknowledgments

Thanks to [Vanessa](https://github.com/vipyne) and [Krish](https://github.com/sigmasleep) for helping me in the different stages of this project.


================================================
FILE: lib/Allocator/StackLinkedList.h
================================================
#ifndef STACKLINKEDLIST_H
#define STACKLINKEDLIST_H

#include <stddef.h>

template <class T>
class StackLinkedList
{
public:
    struct Node
    {
        T data;
        Node* next = nullptr;
    };

    Node* head = nullptr;
    Node* front = nullptr;
    Node* back = nullptr;
    size_t m_counter = 0;
    size_t m_taken = 0;
    size_t m_maximum = 0;

public:
    StackLinkedList() = default;
    StackLinkedList(StackLinkedList& stackLinkedList) = delete;
    void set_edges(Node *front, Node *back);
    void push(Node* newNode);
    Node* pop();

    size_t count() const
    {
        return m_counter;
    }

    size_t maximum() const
    {
        return m_maximum;
    }
};

#include "StackLinkedListImpl.h"

#endif /* STACKLINKEDLIST_H */


================================================
FILE: lib/Allocator/StackLinkedListImpl.h
================================================
#pragma once
#ifndef STACK_LINKED_LIST_IMPL_H
#define STACK_LINKED_LIST_IMPL_H

#include "StackLinkedList.h"

template <class T>
void StackLinkedList<T>::push(Node* newNode)
{
    newNode->next = head;
    head = newNode;
    ++m_counter;

    if(m_taken > 0)
        --m_taken;
}

template <class T>
typename StackLinkedList<T>::Node* StackLinkedList<T>::pop()
{
    if(!head || head < front || head > back)
        return nullptr;

    Node* top = head;
    head = head->next;

    ++m_taken;
    if(m_taken > m_maximum)
        m_maximum = m_taken;

    if(m_counter > 0)
        --m_counter;

    return top;
}

template <class T>
void StackLinkedList<T>::set_edges(Node *i_front, Node *i_back)
{
    m_counter = 0;
    front = i_front;
    back = i_back;
}

#endif // STACK_LINKED_LIST_IMPL_H


================================================
FILE: lib/Allocator/Utils.h
================================================
#ifndef UTILS_H
#define UTILS_H

#include <cstddef>

class Utils
{
public:
    static std::size_t CalculatePadding(const std::size_t baseAddress, const std::size_t alignment)
    {
        const std::size_t multiplier = (baseAddress / alignment) + 1;
        const std::size_t alignedAddress = multiplier * alignment;
        const std::size_t padding = alignedAddress - baseAddress;
        return padding;
    }

    static std::size_t CalculatePaddingWithHeader(const std::size_t baseAddress, const std::size_t alignment, const std::size_t headerSize)
    {
        std::size_t padding = CalculatePadding(baseAddress, alignment);
        std::size_t neededSpace = headerSize;

        if(padding < neededSpace)
        {
            // Header does not fit - Calculate next aligned address that header fits
            neededSpace -= padding;

            // How many alignments I need to fit the header
            if(neededSpace % alignment > 0)
            {
                padding += alignment * (1 + (neededSpace / alignment));
            }
            else
            {
                padding += alignment * (neededSpace / alignment);
            }
        }

        return padding;
    }
};

#endif /* UTILS_H */


================================================
FILE: lib/Allocator/linear-allocator.cmake
================================================
include_directories(${CMAKE_CURRENT_LIST_DIR})

set(LINALLOC_SRCS)

list(APPEND LINALLOC_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/LinearAllocator.cpp
)


================================================
FILE: lib/Allocator/pool-allocator.cmake
================================================
include_directories(${CMAKE_CURRENT_LIST_DIR})

set(POOLALLOC_SRCS)

list(APPEND POOLALLOC_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/PoolAllocator.cpp
    ${CMAKE_CURRENT_LIST_DIR}/PoolAllocator.h
    ${CMAKE_CURRENT_LIST_DIR}/Allocator.h
    ${CMAKE_CURRENT_LIST_DIR}/StackLinkedList.h
    ${CMAKE_CURRENT_LIST_DIR}/StackLinkedListImpl.h
)


================================================
FILE: lib/AppPath/app_path.cmake
================================================
set(APPPATH_SRCS)

list(APPEND APPPATH_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/app_path.h
    ${CMAKE_CURRENT_LIST_DIR}/private/app_path_private.h
    ${CMAKE_CURRENT_LIST_DIR}/private/app_path.cpp
)

if(APPLE)
    message("-- AppPath for Apple")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_macos.cpp
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_macos_dirs.h
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_macos_dirs.m
    )
elseif(ANDROID)
    message("-- AppPath for Android")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_android.cpp
    )
elseif(EMSCRIPTEN)
    message("-- AppPath for Emscripten")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_emscripten.cpp
    )
elseif(VITA)
    message("-- AppPath for Vita")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_vita.cpp
    )
elseif(NINTENDO_3DS)
    message("-- AppPath for 3DS")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_3ds.cpp
    )
elseif(NINTENDO_DS)
    message("-- AppPath for 16M")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_16m.cpp
    )
elseif(NINTENDO_WII)
    message("-- AppPath for Wii")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_wii.cpp
    )
elseif(NINTENDO_WIIU)
    message("-- AppPath for Wii")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_wiiu.cpp
    )
elseif(NINTENDO_SWITCH)
    message("-- AppPath for Switch")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_switch.cpp
    )
elseif(WIN32)
    message("-- AppPath for Windows")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_win32.cpp
    )
elseif(UNIX OR HAIKU)
    message("-- AppPath for UNIX-like operating systems")
    list(APPEND APPPATH_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/app_path_unix.cpp
    )
else()
    message(WARNING "-- AppPath: Possibly unsupported platform detected")
endif()


================================================
FILE: lib/AppPath/app_path.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef APP_PATH_H
#define APP_PATH_H

#include <string>
#include <vector>

#if defined(__3DS__)
#   define APP_PATH_HAS_EXTRA_WORLDS
#endif


/*!
 * \brief Set of possible asset pack search path types
 */
enum class AssetsPathType
{
    Legacy,   // search the path directly for asset pack (as legacy), and check for additional packs in assets subdirectory
    Single,   // single modern asset pack
    Multiple, // directory containing multiple subdirectories with modern asset packs
};


class AppPathManager
{
public:
    /*!
     * \brief Prepend a single custom assets directory to the search path
     * \param root Path to the assets directory to use
     *
     * This function must be called BEFORE calling the initAppPath()
     */
    static void addAssetsRoot(const std::string &root);

    /*!
     * \brief Custom user directory (will be used instead of default)
     * \param root Path to the writable user directory to use
     *
     * The custom user directory is prepended to the search path but has lower precedence than an added assets root.
     * Overrides a custom-set GameDirName
     *
     * This function must be called BEFORE calling the initAppPath()
     */
    static void setUserDirectory(const std::string &root);

    /*!
     * \brief Custom game directory name for default locations
     * \param dirName Name of directory name that will be used for game initialisation
     *
     * This function must be called BEFORE calling the initAppPath()
     */
    static void setGameDirName(const std::string &dirName);

    /*!
     * \brief Initialise all paths
     */
    static void initAppPath();

    /*!
     * \brief Check the user added assets root (so that it can be treated differently than other members of the search path)
     * \return root passed to addAssetsRoot()
     */
    static std::string userAddedAssetsRoot(); // Read-Only

    /*!
     * \brief Get a list of folders that should be searched for asset packs (each folder directly, and also each subdirectory in folder + "/assets"). Does not change after initAppPath() is called.
     * \return Vector of paths to the read-only assets directory, always ends with a slash. Type of each path is specified.
     */
    static std::vector<std::pair<std::string, AssetsPathType>> assetsSearchPath(); // Read-Only

    /*!
     * \brief Set the custom assets directory by ID and absolute path (will be used instead of default)
     * \param id Name of the asset pack (used to postfix user paths if not empty)
     * \param path Path to the assets directory to use
     *
     * This function should be called AFTER calling the initAppPath(), and it will update all other paths
     */
    static void setCurrentAssetPack(const std::string &id, const std::string &path);

    /*!
     * \brief Get the path to the game settings file
     * \return Path to the game settings file
     */
    static std::string settingsFileSTD(); // Must be writable

    /*!
     * \brief Get the settings directory path
     * \return Settings directory path, always ends with a slash
     */
    static std::string settingsRoot(); // Must be writable

    /*!
     * \brief Get the path to the controls settings file
     * \return Path to the controls settings file
     */
    static std::string settingsControlsFileSTD(); // Must be writable

    /*!
     * \brief Get the path to the writable user directory
     * \return Path to ther writable user directory, always ends with a slash
     */
    static std::string userAppDirSTD(); // Must be writable

    /*!
     * \brief Get the path to the read-only assets directory
     * \return Path to ther read-only assets directory, always ends with a slash
     */
    static std::string assetsRoot(); // Read-Only

    /*!
     * \brief Get the path to the logs output directory
     * \return Path to ther logs output directory, always ends with a slash
     */
    static std::string logsDir(); // Must be writable

    /*!
     * \brief Get the path to engine languages directory
     * \return Path to ther engine languages directory, always ends with a slash
     */
    static std::string languagesDir(); // Read-Only

    /*!
     * \brief Get the path to the screenshots output directory
     * \return Path to ther screenshots output directory, always ends with a slash
     */
    static std::string screenshotsDir(); // Must be writable

    /*!
     * \brief Get the path to the GIF recordings output directory
     * \return Path to ther GIF recordings output directory, always ends with a slash
     */
    static std::string gifRecordsDir(); // Must be writable

    /*!
     * \brief Get the path to the game saves directory
     * \return Path to ther game saves directory, always ends with a slash
     */
    static std::string gameSaveRootDir(); // Must be writable

    static std::string gameplayRecordsRootDir(); // Must be writable

    static std::string userWorldsRootDir(); // Read-Only, appears at writable directory

    static std::string userBattleRootDir(); // Read-Only, appears at writable directory

#ifdef APP_PATH_HAS_EXTRA_WORLDS
    static const std::vector<std::string>& worldRootDirs(); // Read-Only, appears at writable directory
#endif

    static void install();
    static bool userDirIsAvailable();

    /*!
     * \brief Emscripten-only file system synchronization request
     */
    static void syncFs();

private:
    static bool checkPortable();
    /**
     * @brief Makes settings path if not exists
     */
    static void initSettingsPath();

    static void initString(std::string &text, const std::string& inValue, const std::string &defValue);

    //! Location for writable settings
    static std::string m_settingsPath;
    //! Location for writable gamesaves
    static std::string m_gamesavesPath;
    //! Location for writable user directory
    static std::string m_userPath;
    //! Screenshots output directory
    static std::string m_screenshotsPath;
    //! GIF recordings output directory
    static std::string m_gifrecordingsPath;
    //! Logs output directory
    static std::string m_logsPath;

    //! Location for read-only current asset pack
    static std::string m_currentAssetPackPath;
    //! Asset pack-specific postfix for some user directories (either "id/" or "")
    static std::string m_assetPackPostfix;

    //! Location for read-only custom assets root
    static std::string m_customAssetsRoot;
    //! Location for writable custom user directory
    static std::string m_customUserDirectory;
    //! Custom name for the game directory name at default locations
    static std::string m_customGameDirName;
    //! Is portable configuration active?
    static bool m_isPortable;
};

#endif // APP_PATH_H


================================================
FILE: lib/AppPath/private/app_path.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <IniProcessor/ini_processing.h>
#define FMT_NOEXCEPT
#include <fmt/fmt_format.h>

#include "../app_path.h"
#include "../../version.h"
#include "app_path_private.h"

#include "sdl_proxy/sdl_assert.h"

std::string AppPathManager::m_settingsPath;
std::string AppPathManager::m_gamesavesPath;
std::string AppPathManager::m_userPath;

std::string AppPathManager::m_screenshotsPath;
std::string AppPathManager::m_gifrecordingsPath;
std::string AppPathManager::m_logsPath;

std::string AppPathManager::m_customAssetsRoot;
std::string AppPathManager::m_customUserDirectory;
std::string AppPathManager::m_customGameDirName;

std::string AppPathManager::m_currentAssetPackPath;
std::string AppPathManager::m_assetPackPostfix;

bool AppPathManager::m_isPortable = false;


static void appendSlash(std::string &path)
{
#if defined(__EMSCRIPTEN__)
    // fix emscripten bug of duplicated worlds
    if(path.empty() || path.back() != '/')
        path.push_back('/');
#else
    if(!path.empty() && path.back() != '/')
        path.push_back('/');
#endif
}

void AppPathManager::addAssetsRoot(const std::string &root)
{
    m_customAssetsRoot = root;
    appendSlash(m_customAssetsRoot);
}

void AppPathManager::setUserDirectory(const std::string& root)
{
    m_customUserDirectory = root;
    appendSlash(m_customUserDirectory);
}

void AppPathManager::setGameDirName(const std::string& dirName)
{
    m_customGameDirName = dirName;
    appendSlash(m_customGameDirName);
    // Also append to front
    if(!m_customGameDirName.empty() && m_customGameDirName.front() != '/')
        m_customGameDirName.insert(0, 1, '/');
}

void AppPathManager::initAppPath()
{
    AppPathP::initDefaultPaths(m_customGameDirName.empty() ? THEXTECH_DIRECTORY_PREFIX : m_customGameDirName);

    // When user directory is redefined externally
    if(!m_customUserDirectory.empty())
    {
        m_userPath = m_customUserDirectory;
        // Assets root matches to user directory if not specified other
        initSettingsPath();
        return;
    }

    if(AppPathP::portableAvailable() && checkPortable())
        return;

    std::string userDirPath = AppPathP::userDirectory();

    if(userDirPath.empty())
        goto defaultSettingsPath;
    else
    {
        DirMan appDir(userDirPath);
        if(userDirPath != "/" && !appDir.exists() && !appDir.mkpath())
            goto defaultSettingsPath;

        m_userPath = appDir.absolutePath();
    }

    appendSlash(m_userPath);

    initSettingsPath();

    return;

defaultSettingsPath:
    m_userPath = AppPathP::appDirectory();
    initSettingsPath();

#if defined(__EMSCRIPTEN__) && !defined(DISABLE_LOGGING)
    std::printf("== Default User Path is %s\n", m_userPath.c_str());
    fflush(stdout);
#endif
}

std::string AppPathManager::userAddedAssetsRoot()
{
    return m_customAssetsRoot;
}

std::vector<std::pair<std::string, AssetsPathType>> AppPathManager::assetsSearchPath()
{
    std::vector<std::pair<std::string, AssetsPathType>> out;

    if(!m_customAssetsRoot.empty())
        out.push_back({m_customAssetsRoot, AssetsPathType::Single});

    if(!m_customUserDirectory.empty())
        out.push_back({m_customUserDirectory, AssetsPathType::Legacy});

    if(!AppPathP::appDirectory().empty())
        out.push_back({AppPathP::appDirectory(), AssetsPathType::Legacy});

    if(!m_isPortable)
    {
        if(m_customUserDirectory.empty())
            out.push_back({m_userPath, AssetsPathType::Legacy});

        if(!AppPathP::assetsRoot().empty())
            out.push_back({AppPathP::assetsRoot(), AppPathP::assetsRootType()});

#ifdef APP_PATH_HAS_EXTRA_WORLDS
        // 3DS: add assets from additional romfs packages
        for(const std::string& root : AppPathManager::worldRootDirs())
            out.push_back({root, AssetsPathType::Single});
#endif
    }

    // add slashes to all strings
    for(size_t i = 0; i < out.size(); i++)
        appendSlash(out[i].first);

    // remove any duplicates
    for(size_t i = 0; i < out.size(); i++)
    {
        for(size_t j = i + 1; j < out.size();)
        {
            if(out[i].first == out[j].first)
                out.erase(out.begin() + j);
            else
                j++;
        }
    }

    return out;
}

void AppPathManager::setCurrentAssetPack(const std::string &id, const std::string &path)
{
    m_currentAssetPackPath = path;
    appendSlash(m_currentAssetPackPath);

    if(!id.empty())
        m_assetPackPostfix = id + "/";
    else
        m_assetPackPostfix = "";

    initSettingsPath();
}

bool AppPathManager::checkPortable()
{
    std::string appPath = AppPathP::appDirectory();

    if(appPath.empty())
        return false;

    if(m_settingsPath.empty())
        m_settingsPath = appPath;

    if(m_userPath.empty())
        m_userPath = appPath;

    if(!Files::fileExists(settingsFileSTD()))
        return false;

    m_isPortable = false;

    IniProcessing checkForPort(settingsFileSTD());
    checkForPort.beginGroup("Main");
    m_isPortable = checkForPort.value("force-portable", false).toBool();
    checkForPort.endGroup();

    if(m_isPortable)
        initSettingsPath();

    return m_isPortable;
}

void AppPathManager::initSettingsPath()
{
    // Default settings path
    initString(m_settingsPath, AppPathP::settingsRoot(), m_userPath + "settings/");

    // Default settings path
    initString(m_gamesavesPath, AppPathP::gamesavesRoot(), m_settingsPath + "gamesaves/" + m_assetPackPostfix);

    // Check if need to use system-wide screenshots directory
    initString(m_screenshotsPath, AppPathP::screenshotsRoot(), m_userPath + "screenshots/" + m_assetPackPostfix);

    // Check if need to use system-wide gif recording directory
    initString(m_gifrecordingsPath, AppPathP::gifRecsRoot(), m_userPath + "gif-recordings/" + m_assetPackPostfix);

    // Check if need to use system-wide logs directory
    initString(m_logsPath, AppPathP::logsRoot(), m_userPath + "logs/");

#ifndef VITA
    // Just in case, avoid mad jokes with making name-sake file as a settings folder
    if(Files::fileExists(m_settingsPath))
        Files::deleteFile(m_settingsPath);
#endif

    // Create the settings directory
    if(!DirMan::exists(m_settingsPath))
        DirMan::mkAbsPath(m_settingsPath);

    // Also create the game saves root folder to be exist
    if(!DirMan::exists(gameSaveRootDir()))
        DirMan::mkAbsPath(gameSaveRootDir());

    // Create the user assets directory, as a hint for the user
    if(!DirMan::exists(m_userPath + "assets/"))
        DirMan::mkAbsPath(m_userPath + "assets/");

    // And create empty worlds and battle directories too, make a hint for user
    if(!DirMan::exists(userWorldsRootDir()))
        DirMan::mkAbsPath(userWorldsRootDir());
    if(!DirMan::exists(userBattleRootDir()))
        DirMan::mkAbsPath(userBattleRootDir());
}

void AppPathManager::initString(std::string& text, const std::string& inValue, const std::string& defValue)
{
    if(m_isPortable)
        text = defValue;
    else
    {
        text = inValue;
        if(text.empty())
            text = defValue;
    }
}


std::string AppPathManager::settingsFileSTD() // Writable
{
    return m_settingsPath + "thextech.ini";
}

std::string AppPathManager::settingsRoot() // Writable
{
    return m_settingsPath;
}

std::string AppPathManager::settingsControlsFileSTD() // Writable
{
    return m_settingsPath + "controls.ini";
}

std::string AppPathManager::userAppDirSTD() // Writable
{
    return m_userPath;
}

std::string AppPathManager::assetsRoot() // Readable
{
    SDL_assert_release(!m_currentAssetPackPath.empty());
    return m_currentAssetPackPath;
}

std::string AppPathManager::logsDir() // Writable
{
    return m_logsPath;
}

std::string AppPathManager::languagesDir() // Readable
{
    SDL_assert_release(!m_currentAssetPackPath.empty());
    return m_currentAssetPackPath + "languages/";
}

std::string AppPathManager::screenshotsDir() // Writable
{
    return m_screenshotsPath;
}

std::string AppPathManager::gifRecordsDir() // Writable
{
    return m_gifrecordingsPath;
}

std::string AppPathManager::gameSaveRootDir() // Writable
{
    return m_gamesavesPath;
}

std::string AppPathManager::gameplayRecordsRootDir() // Writable
{
    return m_userPath + "gameplay-records/" + m_assetPackPostfix;
}

std::string AppPathManager::userWorldsRootDir() // Readable
{
    return m_userPath + "worlds/" + m_assetPackPostfix;
}

std::string AppPathManager::userBattleRootDir() // Readable
{
    return m_userPath + "battle/" + m_assetPackPostfix;
}

void AppPathManager::install()
{
    std::string path = AppPathP::userDirectory();

    if(!path.empty())
    {
        DirMan appDir(path);
        if(!appDir.exists())
            appDir.mkpath(path);
    }
}

bool AppPathManager::userDirIsAvailable()
{
    SDL_assert_release(!m_currentAssetPackPath.empty());
    return (m_userPath != m_currentAssetPackPath);
}

void AppPathManager::syncFs()
{
    AppPathP::syncFS();
}


================================================
FILE: lib/AppPath/private/app_path_16m.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <filesystem.h>
#include <fat.h>

#include <vector>
#include <string>

#include <DirManager/dirman.h>

#include "../app_path.h"
#include "app_path_private.h"

void AppPathP::initDefaultPaths(const std::string &userDirName)
{
    (void)userDirName;

    fatInitDefault();
}

std::string AppPathP::appDirectory()
{
    return std::string();
}

std::string AppPathP::userDirectory()
{
    return "sd:/" THEXTECH_DIRECTORY_PREFIX "/";
}

std::string AppPathP::assetsRoot()
{
    return std::string();
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_3ds.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <3ds.h>

#include <vector>
#include <string>

#include <DirManager/dirman.h>

#include "../app_path.h"
#include "app_path_private.h"

static std::vector<std::string> s_worldRootDirs;
static std::string s_assetRoot;

// special 3DS functions to handle fast romfs archives
static bool mountRomfsFile(const char* path, const char* mount_label)
{
    // for some reason dirent returns a very strange format that appears to be
    // utf-8 expressed as utf-16 and then converted back to utf-8.
    uint16_t utf16_buf[4096 + 1];
    uint8_t utf8_buf[4096 + 1];

    ssize_t units = utf8_to_utf16(utf16_buf, (const uint8_t*)path, 4096);

    if((units < 0) || (units > 4096))
        return false;

    utf16_buf[units] = 0;

    for(int i = 0; i < units; i++)
        utf8_buf[i] = (uint8_t)(0xff & utf16_buf[i]);

    utf8_buf[units] = 0;

    Handle fd = 0;
    FS_Path archPath = { PATH_EMPTY, 1, "" };
    FS_Path filePath = { PATH_ASCII, (size_t)units + 1, utf8_buf };

    Result rc = FSUSER_OpenFileDirectly(&fd, ARCHIVE_SDMC, archPath, filePath, FS_OPEN_READ, 0);

    if(R_FAILED(rc))
        return false;

    rc = romfsMountFromFile(fd, 0, mount_label);

    if(R_FAILED(rc))
        return false;

    return true;
}

// find additional user worlds packaged in .romfs files
static void findUserWorlds()
{
    std::vector<std::string> romfsFiles;
    static const std::vector<std::string> romfsExt = {".romfs"};

    DirMan userDir(AppPathP::userDirectory());
    userDir.getListOfFiles(romfsFiles, romfsExt);

    std::string fullPath;
    char mount_label[9] = "romfsA:/";

    for(std::string& s : romfsFiles)
    {
        if(s == "assets.romfs")
            continue;

        fullPath = userDir.absolutePath() + "/" + s;
        mount_label[6] = '\0';

        if(!mountRomfsFile(fullPath.c_str(), mount_label))
            continue;

        mount_label[6] = ':';
        s_worldRootDirs.push_back(std::string(mount_label));
        mount_label[5] ++;

        // from Z to a.
        if(mount_label[5] == 91)
            mount_label[5] = 97;

        // max of 52 mounts.
        if(mount_label[5] == 123)
            break;
    }
}

void AppPathP::initDefaultPaths(const std::string& userDirName)
{
    (void)userDirName;

    s_assetRoot = "romfs:/";

    // try to mount packaged files
    if(R_FAILED(romfsInit()))
    {
        // fallback to assets.romfs
        if(!mountRomfsFile("/3ds/" THEXTECH_DIRECTORY_PREFIX "/assets.romfs", "romfs"))
        {
            // just use user dir for assets. this is really bad. everything will be insanely slow.
            s_assetRoot.clear();
        }
    }

    findUserWorlds();
}

std::string AppPathP::appDirectory()
{
    return std::string();
}

std::string AppPathP::userDirectory()
{
    return "/3ds/" THEXTECH_DIRECTORY_PREFIX "/";
}

std::string AppPathP::assetsRoot()
{
    return s_assetRoot;
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}

const std::vector<std::string>& AppPathManager::worldRootDirs() // Read-Only, appears at writable directory
{
    return s_worldRootDirs;
}


================================================
FILE: lib/AppPath/private/app_path_android.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <unistd.h>
//#   include <md5/md5.h>
#include <jni.h>

#include <SDL2/SDL_stdinc.h>
#include <SDL2/SDL_rwops.h>

#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <IniProcessor/ini_processing.h>
#define FMT_NOEXCEPT
#include <fmt/fmt_format.h>

#include "app_path_private.h"

static std::string s_assetsRoot;
static std::string s_userDirectory;
static std::string s_applicationPath;

//! Default path to the internal sotrage directory
static std::string m_androidSdCardPath = "/storage/emulated/0";
//! Customized absolute path to the game assets directory
static std::string m_androidGameAssetsPath;
//! Application data absolute directory path (may be inaccessible from file managers since Android 11, etc.)
static std::string m_androidAppDataPath;


extern "C" JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_setSdCardPath(
    JNIEnv *env,
    jclass type,
    jstring sdcardPath_j
)
{
    const char *sdcardPath;
    (void)type;
    sdcardPath = env->GetStringUTFChars(sdcardPath_j, nullptr);
    m_androidSdCardPath = sdcardPath;
    env->ReleaseStringUTFChars(sdcardPath_j, sdcardPath);
}

extern "C" JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_setAppDataPath(
    JNIEnv *env,
    jclass type,
    jstring appDataPath_j
)
{
    const char *appDataPath;
    (void)type;
    appDataPath = env->GetStringUTFChars(appDataPath_j, nullptr);
    m_androidAppDataPath = appDataPath;
    env->ReleaseStringUTFChars(appDataPath_j, appDataPath);
}

extern "C" JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_setGameAssetsPath(
    JNIEnv *env,
    jclass type,
    jstring gameAssetsPath_j
)
{
    const char *gameAssetsPath;
    (void)type;
    gameAssetsPath = env->GetStringUTFChars(gameAssetsPath_j, nullptr);
    m_androidGameAssetsPath = gameAssetsPath;
    env->ReleaseStringUTFChars(gameAssetsPath_j, gameAssetsPath);
}


void AppPathP::initDefaultPaths(const std::string &userDirName)
{
    // Application path
    s_applicationPath = m_androidAppDataPath;

    // Detect the user directory
    if(!m_androidGameAssetsPath.empty())
    {
        s_userDirectory = m_androidGameAssetsPath; // Don't search the path, simply re-use the defined path
        s_assetsRoot = m_androidGameAssetsPath;
    }
    else
    {
        s_userDirectory = m_androidSdCardPath;
        DirMan homeDir(s_userDirectory);
        if(s_userDirectory.empty() || !homeDir.exists())
            s_userDirectory = "/sdcard";

        s_userDirectory += userDirName;
    }

    // Check does user directory exists
    DirMan appDir(s_userDirectory);
    if(!appDir.exists() && !appDir.mkpath())
        s_userDirectory = s_applicationPath;

    if(!s_userDirectory.empty() && s_userDirectory.back() != '/')
        s_userDirectory.push_back('/');

    // Check is selected user directory writable
    if(access(s_userDirectory.c_str(), W_OK) != 0) // If assets directory is not writable
    {
        // Use the application's data directory for logs / settings / screenshots / GIFs / gamesaves
        s_userDirectory = fmt::format("{0}/{1}",
                                      m_androidAppDataPath,
                                      Files::basename(s_userDirectory));
    }

    // Check presence for ".nomedia" file
    std::string noMediaFile = s_userDirectory + ".nomedia";
    if(!Files::fileExists(noMediaFile))
    {
        // If doesn't exists, make it
        SDL_RWops *noMediaRWops = SDL_RWFromFile(noMediaFile.c_str(), "w");
        if(noMediaRWops)
        {
            SDL_RWwrite(noMediaRWops, "\0", 1, 1);
            SDL_RWclose(noMediaRWops);
        }
    }

    // Choose the assets directory
    if(!m_androidGameAssetsPath.empty())
        s_assetsRoot = m_androidGameAssetsPath;
    else
        s_assetsRoot.clear();

    if(!s_assetsRoot.empty() && s_assetsRoot.back() != '/')
        s_assetsRoot.push_back('/');

    if(s_assetsRoot == s_userDirectory)
        s_assetsRoot.clear();
}

std::string AppPathP::appDirectory()
{
    return s_applicationPath;
}

std::string AppPathP::userDirectory()
{
    return s_userDirectory;
}

std::string AppPathP::assetsRoot()
{
    return s_assetsRoot;
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Legacy;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_emscripten.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <emscripten.h>

#include <SDL2/SDL_stdinc.h>
#include <SDL2/SDL_rwops.h>
#include <SDL2/SDL_filesystem.h>

#include <Logger/logger.h>

#include "app_path_private.h"


static std::string s_assetsRoot;
static std::string s_userDirectory;
static std::string s_applicationPath;

static bool loadingLocked = false;


extern "C" void unlockLoadingCustomState()
{
    loadingLocked = false;
}

static void loadCustomState()
{
    loadingLocked = true;
    EM_ASM(
        FS.mkdir('/settings');
        FS.mount(IDBFS, {}, '/settings');

        FS.mkdir('/user');
        FS.mount(IDBFS, {}, '/user');

        // sync from persisted state into memory and then
        // run the 'test' function
        FS.syncfs(true, function (err) {
            assert(!err);
            Module.ccall('unlockLoadingCustomState', 'v', null, null, {async: true});
        });
    );

    while(loadingLocked)
        emscripten_sleep(10);
}

static void saveCustomState()
{
    loadingLocked = true;
    pLogDebug("Synchronizing user file data...");

    EM_ASM(
        FS.syncfs(function (err) {
            assert(!err);
            Module.ccall('unlockLoadingCustomState', 'v');
        });
    );

    while(loadingLocked)
        emscripten_sleep(10);
}




void AppPathP::initDefaultPaths(const std::string & /*userDirName*/)
{
    char *path = SDL_GetBasePath();
    if(!path)
    {
#   ifndef DISABLE_LOGGING
        std::fprintf(stderr, "== Failed to recognize application path by using of SDL_GetBasePath! Using current working directory \"./\" instead.\n");
        std::fflush(stderr);
#   endif
        path = SDL_strdup("./");
    }

    s_applicationPath = std::string(path);
    SDL_free(path);

    if(!s_applicationPath.empty() && s_applicationPath.back() != '/')
        s_applicationPath.push_back('/');

    s_assetsRoot = s_applicationPath;
    s_userDirectory = "/user/";

    loadCustomState();

#if !defined(DISABLE_LOGGING)
    std::printf("== App Path is %s\n", s_applicationPath.c_str());
    std::printf("== Assets Path is %s\n", s_assetsRoot.c_str());
    std::printf("== User Path is %s\n", s_userDirectory.c_str());
    fflush(stdout);
#endif
}

std::string AppPathP::appDirectory()
{
    return s_applicationPath;
}

std::string AppPathP::userDirectory()
{
    return s_userDirectory;
}

std::string AppPathP::assetsRoot()
{
    return s_assetsRoot;
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Legacy;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return "/settings/";
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return false;
}

void AppPathP::syncFS()
{
    saveCustomState();
}


================================================
FILE: lib/AppPath/private/app_path_macos.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <CoreFoundation/CoreFoundation.h>
#include <CoreServices/CoreServices.h>
#include <PGE_File_Formats/pge_file_lib_globs.h> // For URL-Decode.

#include <SDL2/SDL_stdinc.h>

#include <DirManager/dirman.h>

#include "app_path_macos_dirs.h"
#include "app_path_private.h"


static std::string s_assetsRoot;
static std::string s_userDirectory;
static std::string s_applicationPath;
static std::string s_screenshotsPath;
static std::string s_gifRecordPath;
//! The name of application bundle to be re-used as the user directory name
static std::string s_bundleName;
static std::string s_sysHomeDir;

static void decodeHome(std::string &path)
{
    if(!s_sysHomeDir.empty() && !path.empty() && path[0] == '~')
    {
        path.erase(path.begin());
        path = s_sysHomeDir + path;
    }
}


void AppPathP::initDefaultPaths(const std::string &userDirName)
{
    // Initialize the application path
    {
        CFURLRef appUrlRef;
        appUrlRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
        CFStringRef filePathRef = CFURLGetString(appUrlRef);
        char temporaryCString[PATH_MAX];
        bzero(temporaryCString, PATH_MAX);
        CFStringGetCString(filePathRef, temporaryCString, PATH_MAX, kCFStringEncodingUTF8);
        s_applicationPath = PGE_FileFormats_misc::url_decode(std::string(temporaryCString));
        {
            s_bundleName.clear();

            auto i = s_applicationPath.find_last_of(".app");

            auto j = s_applicationPath.find_last_of('/', i);
            if(j != std::string::npos)
            {
                s_bundleName = s_applicationPath.substr(j + 1);
                auto k = s_bundleName.find_last_of(".app") - 3;
                s_bundleName.erase(k, s_bundleName.size() - k);
            }

            i = s_applicationPath.find_last_of('/', i);

            s_applicationPath.erase(i, s_applicationPath.size() - i);
            if(s_applicationPath.compare(0, 7, "file://") == 0)
                s_applicationPath.erase(0, 7);

            if(!s_applicationPath.empty() && (s_applicationPath.back() != '/'))
                s_applicationPath.push_back('/');
        }
        CFRelease(appUrlRef);
    }

    // Assets directory
    s_assetsRoot.clear();

#if defined(USE_BUNDLED_ASSETS) // When its release game with assets shipped with a game
    {
        CFURLRef appUrlRef;
        appUrlRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("assets"), NULL, NULL);
        CFStringRef filePathRef = CFURLGetString(appUrlRef);
        char temporaryCString[PATH_MAX];
        bzero(temporaryCString, PATH_MAX);
        CFStringGetCString(filePathRef, temporaryCString, PATH_MAX, kCFStringEncodingUTF8);
        std::string path = PGE_FileFormats_misc::url_decode(std::string(temporaryCString));
        if(path.compare(0, 7, "file://") == 0)
            path.erase(0, 7);
        s_assetsRoot = path;
    }
#endif

    // Initialize the user directory
    {
        const char *homeDir;
        char *home_dir = getHomeDir();

        if(home_dir)
        {
            s_sysHomeDir = home_dir;
            SDL_free(home_dir);
            homeDir = s_sysHomeDir.c_str();
        }
        else
            homeDir = SDL_getenv("HOME");


        std::string appSupport;

        char *base_path = getAppSupportDir();
        if(base_path)
        {
            appSupport.append(base_path);
            SDL_free(base_path);
        }

        if(appSupport.empty())
            appSupport = std::string("/Library/Application Support/");

        appSupport += userDirName;

        if(!appSupport.empty() && appSupport.back() != '/')
            appSupport.push_back('/');

        if(homeDir)
        {
            // Current TheXTech distribution: per-bundle directories
            if(!s_assetsRoot.empty() && !s_bundleName.empty())
                s_userDirectory = std::string(homeDir) + "/TheXTech Games/" + s_bundleName;
            // Shared userdata directory
            else
            {
                s_userDirectory = std::string(homeDir) + userDirName;

                // fallback to legacy directory if there is no custom directory set
                std::string legacyUserDirectory = std::string(homeDir) + "/TheXTech Games/" + s_bundleName;
                std::string legacyAssetsDirectory = std::string(homeDir) + "/TheXTech Games/Debug Assets";
                if(userDirName == "TheXTech" && !DirMan::exists(s_userDirectory) && DirMan::exists(legacyUserDirectory))
                {
                    s_userDirectory = legacyUserDirectory;
                    s_assetsRoot = legacyAssetsDirectory;
                }
            }
        }
        else
            s_userDirectory = appSupport;
    }

    // Screenshots directory
    {
        std::string path = s_userDirectory;
        char *base_path = getScreenCaptureDir();
        if(base_path)
        {
            path = base_path;
            SDL_free(base_path);
        }

        decodeHome(path);

        s_screenshotsPath = path + "/TheXTech Game Screenshots/";
        s_gifRecordPath = path + "/TheXTech Game Screenshots/gif-recordings/";
    }
}

std::string AppPathP::appDirectory()
{
    return s_applicationPath;
}

std::string AppPathP::userDirectory()
{
    return s_userDirectory;
}

std::string AppPathP::assetsRoot()
{
    return s_assetsRoot;
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Legacy;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    return s_screenshotsPath;
}

std::string AppPathP::gifRecsRoot()
{
    return s_gifRecordPath;
}

std::string AppPathP::logsRoot()
{
    return std::string();
}

bool AppPathP::portableAvailable()
{
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_macos_dirs.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef APP_PATH_MACOSX_H
#define APP_PATH_MACOSX_H

#ifdef __cplusplus
extern "C"
{
#endif

char * getHomeDir(void);
char * getAppSupportDir(void);
char * getScreenCaptureDir(void);

#ifdef __cplusplus
}
#endif

#endif /* APP_PATH_MACOSX_H */


================================================
FILE: lib/AppPath/private/app_path_macos_dirs.m
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <Foundation/Foundation.h>
#include <SDL2/SDL_error.h>
#include <SDL2/SDL_filesystem.h>

#include "app_path_macos_dirs.h"

char *getHomeDir(void)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    NSString *str;
    char *retval = NULL;
    const char *base;

    str = NSHomeDirectory();
    base = [str fileSystemRepresentation];

    if(base)
    {
        const size_t len = SDL_strlen(base) + 4;
        retval = (char *)SDL_malloc(len);

        if(retval == NULL)
            SDL_OutOfMemory();
        else
            SDL_snprintf(retval, len, "%s", base);
    }

    [pool drain];
    return retval;
}

char * getAppSupportDir(void)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    char *retval = NULL;
    NSString *str;
    const char *base;

    NSArray *array = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES);

    if([array count] > 0) /* we only want the first item in the list. */
    {
        str = [array objectAtIndex:0];
        base = [str fileSystemRepresentation];

        if(base)
        {
            const size_t len = SDL_strlen(base) + 4;
            retval = (char *)SDL_malloc(len);

            if(retval == NULL)
                SDL_OutOfMemory();
            else
                SDL_snprintf(retval, len, "%s", base);
        }
    }

    [pool drain];
    return retval;
}

char * getScreenCaptureDir(void)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    char *retval = NULL;
    NSUserDefaults *appUserDefaults;
    NSDictionary *prefsDict;
    NSString *str;
    const char *base;

    /* Get current screencapture location */
    appUserDefaults = [[NSUserDefaults alloc] init];
    [appUserDefaults addSuiteNamed:@"com.apple.screencapture"];
    prefsDict = [appUserDefaults dictionaryRepresentation];

    str = [prefsDict valueForKey:@"location"];
    base = [str fileSystemRepresentation];

    if(base)
    {
        const size_t len = SDL_strlen(base) + 4;
        retval = (char *)SDL_malloc(len);

        if(retval == NULL)
            SDL_OutOfMemory();
        else
            SDL_snprintf(retval, len, "%s", base);
    }

    [pool drain];
    return retval;
}


================================================
FILE: lib/AppPath/private/app_path_old.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <SDL2/SDL_stdinc.h>
#include <SDL2/SDL_rwops.h>
#include <SDL2/SDL_filesystem.h>

#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <IniProcessor/ini_processing.h>
#define FMT_NOEXCEPT
#include <fmt/fmt_format.h>

#ifdef __ANDROID__
#   include <unistd.h>
//#   include <md5/md5.h>
#   include <jni.h>
#   if 1
#       undef JNIEXPORT
#       undef JNICALL
#       define JNIEXPORT extern "C"
#       define JNICALL
#   endif
#endif

#ifdef __APPLE__
#include <CoreFoundation/CoreFoundation.h>
#include <CoreServices/CoreServices.h>
#include <PGE_File_Formats/pge_file_lib_private.h>//It's only exception for macOS here to get URL-Decode. Never include this!
#include "app_path_macos_dirs.h"
#endif

#ifdef __gnu_linux__
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#endif

#ifdef _WIN32
#include <windows.h>
#include <winreg.h>
#include <algorithm> // std::replace from \\ into /
#endif

#ifdef __EMSCRIPTEN__
#include <emscripten.h>

static bool loadingLocked = false;

extern "C" void unlockLoadingCustomState()
{
    loadingLocked = false;
}

static void loadCustomState()
{
    loadingLocked = true;
    EM_ASM(
        FS.mkdir('/settings');
        FS.mount(IDBFS, {}, '/settings');

        // sync from persisted state into memory and then
        // run the 'test' function
        FS.syncfs(true, function (err) {
            assert(!err);
            ccall('unlockLoadingCustomState', 'v', null, null, {async: true});
        });
    );

    while(loadingLocked)
        emscripten_sleep(10);
}

static void saveCustomState()
{
    loadingLocked = true;
    EM_ASM(
        FS.syncfs(function (err) {
            assert(!err);
            ccall('unlockLoadingCustomState', 'v');
        });
    );

    while(loadingLocked)
        emscripten_sleep(10);
}
#endif

#include "../app_path.h"
#include "../../version.h"

static std::string ApplicationPathSTD;

std::string AppPathManager::m_settingsPath;
std::string AppPathManager::m_assetsPath;
std::string AppPathManager::m_userPath;

std::string AppPathManager::m_screenshotsPath;
std::string AppPathManager::m_gifrecordingsPath;
std::string AppPathManager::m_logsPath;

std::string AppPathManager::m_customAssetsRoot;
std::string AppPathManager::m_customUserDirectory;

#if defined(__APPLE__)
//! The name of application bundle to be re-used as the user directory name
static std::string s_bundleName;
static std::string s_defaultAssetsRoot;
#endif

#if defined(VITA)
static std::string m_vitaAppDataPath = "ux0:data/TheXTech/";
#endif

#if defined(__ANDROID__)
//! Default path to the internal sotrage directory
static std::string m_androidSdCardPath = "/storage/emulated/0";
//! Customized absolute path to the game assets directory
static std::string m_androidGameAssetsPath;
//! Application data absolute directory path (may be inaccessible from file managers since Android 11, etc.)
static std::string m_androidAppDataPath;

JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_setSdCardPath(
    JNIEnv *env,
    jclass type,
    jstring sdcardPath_j
)
{
    const char *sdcardPath;
    (void)type;
    sdcardPath = env->GetStringUTFChars(sdcardPath_j, nullptr);
    m_androidSdCardPath = sdcardPath;
    env->ReleaseStringUTFChars(sdcardPath_j, sdcardPath);
}

JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_setAppDataPath(
    JNIEnv *env,
    jclass type,
    jstring appDataPath_j
)
{
    const char *appDataPath;
    (void)type;
    appDataPath = env->GetStringUTFChars(appDataPath_j, nullptr);
    m_androidAppDataPath = appDataPath;
    env->ReleaseStringUTFChars(appDataPath_j, appDataPath);
}

JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_setGameAssetsPath(
    JNIEnv *env,
    jclass type,
    jstring gameAssetsPath_j
)
{
    const char *gameAssetsPath;
    (void)type;
    gameAssetsPath = env->GetStringUTFChars(gameAssetsPath_j, nullptr);
    m_androidGameAssetsPath = gameAssetsPath;
    env->ReleaseStringUTFChars(gameAssetsPath_j, gameAssetsPath);
}
#endif

#ifdef __APPLE__

#   ifndef USERDATA_ROOT_NAME
#       define USERDATA_ROOT_NAME "TheXTech"
#   endif

std::string AppPathManager::m_userDataRoot;
#endif
bool AppPathManager::m_isPortable = false;

#if defined(USER_DIR_NAME)
#define UserDirName "/" USER_DIR_NAME
#elif defined(__ANDROID__) || defined(__APPLE__) || defined(__HAIKU__)
#define UserDirName "/PGE Project"
#else
#define UserDirName "/.PGE_Project"
#endif

/**
 * @brief Retreive User Home directory with appending of the PGE user data directory
 * @return Absolute directory path
 */
static std::string getPgeUserDirectory()
{
    std::string path;

#if defined(__APPLE__)
    {
        char *base_path = getAppSupportDir();
        if(base_path)
        {
            path.append(base_path);
            SDL_free(base_path);
        }
    }

#elif defined(_WIN32)
    {
        wchar_t pathW[MAX_PATH];
        DWORD path_len = GetEnvironmentVariableW(L"UserProfile", pathW, MAX_PATH);
        assert(path_len);
        path.resize(path_len * 2);
        path_len = WideCharToMultiByte(CP_UTF8, 0,
                                       pathW,       path_len,
                                       &path[0],    path.size(),
                                       0, FALSE);
        path.resize(path_len);
    }

#elif defined(__ANDROID__)
    if(!m_androidGameAssetsPath.empty())
    {
        if(access(m_androidGameAssetsPath.c_str(), W_OK) != 0) // If assets directory is not writable
        {
            // Use the application's data directory for logs / settings / screenshots / GIFs
            return fmt::format("{0}/{1}",
                               m_androidAppDataPath,
                               Files::basename(m_androidGameAssetsPath));
        }

        return m_androidGameAssetsPath; // Don't search the path, simply re-use the defined path
    }

    path = m_androidSdCardPath;

    DirMan homeDir(path);
    if(!homeDir.exists())
        path = "/sdcard";

#elif defined(__HAIKU__)
    {
        const char *home = SDL_getenv("HOME");
        path.append(home);
    }

#elif defined(__gnu_linux__)
    {
        passwd *pw = getpwuid(getuid());
        path.append(pw->pw_dir);
    }
#endif

    return path.empty() ? std::string(".") : (path + UserDirName);
}


void AppPathManager::initAppPath()
{
#if defined(__APPLE__)
    {
        CFURLRef appUrlRef;
        appUrlRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
        CFStringRef filePathRef = CFURLGetString(appUrlRef);
        char temporaryCString[PATH_MAX];
        bzero(temporaryCString, PATH_MAX);
        CFStringGetCString(filePathRef, temporaryCString, PATH_MAX, kCFStringEncodingUTF8);
        ApplicationPathSTD = PGE_URLDEC(std::string(temporaryCString));
        {
            s_bundleName = USERDATA_ROOT_NAME;

            auto i = ApplicationPathSTD.find_last_of(".app");

            auto j = ApplicationPathSTD.find_last_of('/', i);
            if(j != std::string::npos)
            {
                s_bundleName = ApplicationPathSTD.substr(j + 1);
                auto k = s_bundleName.find_last_of(".app") - 3;
                s_bundleName.erase(k, s_bundleName.size() - k);
            }

            i = ApplicationPathSTD.find_last_of('/', i);

            ApplicationPathSTD.erase(i, ApplicationPathSTD.size() - i);
            if(ApplicationPathSTD.compare(0, 7, "file://") == 0)
                ApplicationPathSTD.erase(0, 7);

            if(!ApplicationPathSTD.empty() && (ApplicationPathSTD.back() != '/'))
                ApplicationPathSTD.push_back('/');
        }
        CFRelease(appUrlRef);
    }

#elif defined(__ANDROID__)
    ApplicationPathSTD = m_androidAppDataPath;

#elif defined(VITA)
    ApplicationPathSTD = m_vitaAppDataPath;

#else // all other platforms (Windows, Linux, Haiku, etc.)
    char *path = SDL_GetBasePath();
    if(!path)
    {
#   ifndef DISABLE_LOGGING
        std::fprintf(stderr, "== Failed to recognize application path by using of SDL_GetBasePath! Using current working directory \"./\" instead.\n");
        std::fflush(stderr);
#   endif
        path = SDL_strdup("./");
    }
    ApplicationPathSTD = std::string(path);
#   if defined(_WIN32)
    std::replace(ApplicationPathSTD.begin(), ApplicationPathSTD.end(), '\\', '/');
#   endif
    SDL_free(path);

#endif // __APPLE__/__ANDROID__


#ifdef __EMSCRIPTEN__
    loadCustomState();
#endif

    // When user directory is redefined externally
    if(!m_customUserDirectory.empty())
    {
        m_userPath = m_customUserDirectory;
        initSettingsPath();
        return;
    }

    if(checkPortable())
        return;

    std::string userDirPath = getPgeUserDirectory();
    if(!userDirPath.empty())
    {
        DirMan appDir(userDirPath);
        if(!appDir.exists() && !appDir.mkpath())
            goto defaultSettingsPath;
// #ifdef __APPLE__
//         if(!DirMan::exists(ApplicationPathSTD + "/Data directory"))
//             symlink((userDirPath).c_str(), (ApplicationPathSTD + "/Data directory").c_str());
// #endif

#ifdef __ANDROID__
        std::string noMediaFile = userDirPath + "/.nomedia";
        if(!Files::fileExists(noMediaFile))
        {
            SDL_RWops *noMediaRWops = SDL_RWFromFile(noMediaFile.c_str(), "w");
            if(noMediaRWops)
            {
                SDL_RWwrite(noMediaRWops, "\0", 1, 1);
                SDL_RWclose(noMediaRWops);
            }
        }
#endif
        m_userPath = appDir.absolutePath();

#if !defined(__EMSCRIPTEN__) && !defined(USER_DIR_NAME)
#   if defined(__ANDROID__)
        if(m_androidGameAssetsPath.empty())
            m_userPath.append("/thextech/");
        else
            m_userPath.append("/");
#   else
        m_userPath.append("/thextech/");
#   endif
#else
        m_userPath.append("/");
#endif
        initSettingsPath();
    }
    else
    {
        goto defaultSettingsPath;
    }

    return;
defaultSettingsPath:
    m_userPath = ApplicationPathSTD;
    initSettingsPath();
#if defined(__EMSCRIPTEN__) && !defined(DISABLE_LOGGING)
    std::printf("== App Path is %s\n", ApplicationPathSTD.c_str());
    std::printf("== User Path is %s\n", m_userPath.c_str());
    fflush(stdout);
#endif
}

std::string AppPathManager::settingsFileSTD() // Writable
{
    return m_settingsPath + "thextech.ini";
}

std::string AppPathManager::settingsRoot() // Writable
{
    return m_settingsPath;
}

std::string AppPathManager::settingsControlsFileSTD() // Writable
{
    return m_settingsPath + "controls.ini";
}

std::string AppPathManager::userAppDirSTD() // Writable
{
    return m_userPath;
}

std::string AppPathManager::assetsRoot() // Readable
{
    if(!m_customAssetsRoot.empty())
        return m_customAssetsRoot;

#if defined(FIXED_ASSETS_PATH) // Fixed assets path, for the rest of UNIX-like OS packages
    std::string assets(FIXED_ASSETS_PATH);
    if(!assets.empty() && assets.back() != '/')
        assets.push_back('/');
    return assets;

#elif defined(__APPLE__)
#   if defined(USE_BUNDLED_ASSETS) // When its release game with assets shipped with a game
    CFURLRef appUrlRef;
    appUrlRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("assets"), NULL, NULL);
    CFStringRef filePathRef = CFURLGetString(appUrlRef);
    char temporaryCString[PATH_MAX];
    bzero(temporaryCString, PATH_MAX);
    CFStringGetCString(filePathRef, temporaryCString, PATH_MAX, kCFStringEncodingUTF8);
    std::string path = PGE_URLDEC(std::string(temporaryCString));
    if(path.compare(0, 7, "file://") == 0)
        path.erase(0, 7);
    return path;
#   else // When it's debug-mode built bundle, external assets will be used
    return s_defaultAssetsRoot;
#   endif

#elif defined(__ANDROID__)
    std::string assets = m_androidGameAssetsPath;
    if(!assets.empty() && assets.back() != '/')
        assets.push_back('/');
    return assets;

#else
    return m_userPath;

#endif
}

void AppPathManager::setAssetsRoot(const std::string &root)
{
    m_customAssetsRoot = root;
    if(!m_customAssetsRoot.empty() && m_customAssetsRoot.back() != '/')
        m_customAssetsRoot.push_back('/');
}

void AppPathManager::setUserDirectory(const std::string& root)
{
    m_customUserDirectory = root;
    if(!m_customUserDirectory.empty() && m_customUserDirectory.back() != '/')
        m_customUserDirectory.push_back('/');
}

std::string AppPathManager::logsDir() // Writable
{
    return m_userPath + "logs/";
}

std::string AppPathManager::languagesDir() // Readable
{
#if defined(__APPLE__)
    CFURLRef appUrlRef;
    appUrlRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("languages"), NULL, NULL);
    CFStringRef filePathRef = CFURLGetString(appUrlRef);
    char temporaryCString[PATH_MAX];
    bzero(temporaryCString, PATH_MAX);
    CFStringGetCString(filePathRef, temporaryCString, PATH_MAX, kCFStringEncodingUTF8);
    std::string path = PGE_URLDEC(std::string(temporaryCString));
    if(path.compare(0, 7, "file://") == 0)
        path.erase(0, 7);
    return path;

#elif defined(__ANDROID__)
    return AppPathManager::assetsRoot() + "languages/";

#else
    return ApplicationPathSTD + "languages/";

#endif
}

std::string AppPathManager::screenshotsDir() // Writable
{
#ifndef __APPLE__
    return m_userPath + "screenshots/";

#else
    std::string path = m_userPath;
    char *base_path = getScreenCaptureDir();
    if(base_path)
    {
        path = base_path;
        SDL_free(base_path);
    }
    return path + "/TheXTech Game Screenshots/";

#endif
}

std::string AppPathManager::gifRecordsDir() // Writable
{
#ifndef __APPLE__
    return m_userPath + "gif-recordings/";

#else
    std::string path = m_userPath;
    char *base_path = getScreenCaptureDir();
    if(base_path)
    {
        path = base_path;
        SDL_free(base_path);
    }
    return path + "/TheXTech Game Screenshots/gif-recordings/";

#endif
}

std::string AppPathManager::gameSaveRootDir() // Writable
{
    return m_settingsPath + "gamesaves/";
}

std::string AppPathManager::gameplayRecordsRootDir() // Writable
{
    return m_userPath + "gameplay-records/";
}

std::string AppPathManager::userWorldsRootDir() // Readable
{
#ifdef __APPLE__
    return m_userDataRoot + "worlds/";
#else
    return m_userPath + "worlds/";
#endif
}

std::string AppPathManager::userBattleRootDir() // Readable
{
#ifdef __APPLE__
    return m_userDataRoot + "battle/";
#else
    return m_userPath + "battle/";
#endif
}

void AppPathManager::install()
{
    std::string path = getPgeUserDirectory();

    if(!path.empty())
    {
        DirMan appDir(path);
        if(!appDir.exists())
            appDir.mkpath(path);
    }
}

//bool AppPathManager::isPortable()
//{
//    return m_isPortable;
//}

bool AppPathManager::checkPortable()
{
    if(m_settingsPath.empty())
        m_settingsPath = ApplicationPathSTD;

    if(m_userPath.empty())
        m_userPath = ApplicationPathSTD;

    if(!Files::fileExists(settingsFileSTD()))
        return false;

    m_isPortable = false;

    IniProcessing checkForPort(settingsFileSTD());
    checkForPort.beginGroup("Main");
    m_isPortable = checkForPort.value("force-portable", false).toBool();
    checkForPort.endGroup();

    if(m_isPortable)
        initSettingsPath();

    return m_isPortable;
}

bool AppPathManager::userDirIsAvailable()
{
    return (m_userPath != assetsRoot());
}

#ifdef __EMSCRIPTEN__
void AppPathManager::syncFs()
{
    saveCustomState();
}
#endif


void AppPathManager::initSettingsPath()
{
    m_settingsPath = m_userPath + "settings/";

#ifdef __APPLE__
    {
        const char *homeDir = std::getenv("HOME");
        if(homeDir)
        {
            m_userDataRoot = std::string(homeDir) + "/TheXTech Games/" + s_bundleName;
            m_userDataRoot.append("/");
            // Automatically create an infrastructure
            if(!DirMan::exists(m_userDataRoot))
                DirMan::mkAbsPath(m_userDataRoot);
            if(!DirMan::exists(m_userDataRoot + "worlds"))
                DirMan::mkAbsPath(m_userDataRoot + "worlds");
            if(!DirMan::exists(m_userDataRoot + "battle"))
                DirMan::mkAbsPath(m_userDataRoot + "battle");
            m_settingsPath = m_userDataRoot + "settings/";

            s_defaultAssetsRoot = std::string(homeDir) + "/TheXTech Games/Debug Assets/";
        }
        else
            m_userDataRoot = m_userPath;
    }
#endif

    if(Files::fileExists(m_settingsPath))
        Files::deleteFile(m_settingsPath);//Just in case, avoid mad jokes with making same-named file as settings folder

    if(!DirMan::exists(m_settingsPath))
        DirMan::mkAbsPath(m_settingsPath);

    // Also make the game saves root folder to be exist
    if(!DirMan::exists(gameSaveRootDir()))
        DirMan::mkAbsPath(gameSaveRootDir());

    // And make empty worlds and battle directories too, make a hint for user
    if(!DirMan::exists(userWorldsRootDir()))
        DirMan::mkAbsPath(userWorldsRootDir());
    if(!DirMan::exists(userBattleRootDir()))
        DirMan::mkAbsPath(userBattleRootDir());
}


================================================
FILE: lib/AppPath/private/app_path_private.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef APP_PATH_PRIVATE_H
#define APP_PATH_PRIVATE_H

#include <string>

#include "AppPath/app_path.h"

namespace AppPathP
{

/*!
 * \brief Initialize all default internals
 */
extern void initDefaultPaths(const std::string &userDirName);

/*!
 * \brief Get the path to the executable's directory (on some platforms may be empty)
 * \return Path to the executable's directory, or an empty string if unsupported
 */
extern std::string appDirectory();

/*!
 * \brief Get the default path to the writable user directory
 * \return Path to the user directory
 */
extern std::string userDirectory();

/*!
 * \brief Get the default path to the system's read-only assets root
 * \return Path to the assets root directory, or an empty string if none is present
 */
extern std::string assetsRoot();

/*!
 * \brief Returns the type of the assets root directory
 *
 * - Legacy should point to a single asset pack and will result in non-nested user directories
 * - Single should point to a single modern asset pack and will result in nested user directories
 * - Multiple should point to a directory containing multiple modern asset packs and will result in nested user directories
 */
extern AssetsPathType assetsRootType();

/*!
 * \brief Get the default path to the writable settings directory (if empty, store at the usre directory)
 * \return Path to the system-wide settings directory
 */
extern std::string settingsRoot();

/*!
 * \brief Get the default path to the writable gamesaves directory (if empty, store at the usre directory)
 * \return Path to the system-wide gamesaves directory
 */
extern std::string gamesavesRoot();

/*!
 * \brief Default directory for screenshots (if empty, store at the user directory)
 * \return Path to the system-wide screenshots directory
 */
extern std::string screenshotsRoot();

/*!
 * \brief Default directory for GIF recordings (if empty, store at the usre directory)
 * \return Path to the system-wide GIF recording directory
 */
extern std::string gifRecsRoot();

/*!
 * \brief Default directory for logs (if empty, store at the usre directory)
 * \return Path to the system-wide logs directory
 */
extern std::string logsRoot();

/*!
 * \brief Reports does platform supports portable mode
 * \return true if Portable mode is supported
 *
 * When it returns false, the "thextech.ini" with "force-portable" flag will never been checked
 */
extern bool portableAvailable();

/*!
 * \brief Run the FS synchronization (Emscripten only)
 */
extern void syncFS();

}

#endif // APP_PATH_PRIVATE_H


================================================
FILE: lib/AppPath/private/app_path_skeleton.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "app_path_private.h"


void AppPathP::initDefaultPaths(const std::string &userDirName)
{

}

std::string AppPathP::appDirectory()
{
    return std::string();
}

std::string AppPathP::userDirectory()
{
    return std::string();
}

std::string AppPathP::assetsRoot()
{
    return std::string();
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return true;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_switch.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "app_path_private.h"

static const char* s_userDirectory = "/TheXTech/";


void AppPathP::initDefaultPaths(const std::string & /*userDirName*/)
{
}

std::string AppPathP::appDirectory()
{
    return std::string();
}

std::string AppPathP::userDirectory()
{
    return s_userDirectory;
}

std::string AppPathP::assetsRoot()
{
    return std::string();
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_unix.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>

#include <DirManager/dirman.h>

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_filesystem.h"

#include "app_path_private.h"

static std::string s_userDirectory;

static std::string s_gameInstallDirectory;

static std::string s_applicationPath;

//! The root for installed data (note: asset packs are placed at /usr/share/games/TheXTech/<pack-name> by default)
#ifdef __HAIKU__
    // FIXME: check that this Haiku-specific logic is correct
    static const char* s_gamesSysDir = "/boot/system/data/" THEXTECH_DIRECTORY_PREFIX "/";
#else
    static const char* s_gamesSysDir = "/usr/share/games/" THEXTECH_DIRECTORY_PREFIX "/";
#endif

static std::string s_getEnvNotNull(const char *env)
{
    const char *e = SDL_getenv(env);
    if(e)
        return std::string(e);
    else
        return std::string();
}

void AppPathP::initDefaultPaths(const std::string &userDirName)
{
    std::string homePath;
    std::string userDir;

    // check for deployment as AppImage when looking for system-installed assets
    s_gameInstallDirectory = s_getEnvNotNull("APPDIR");
    s_gameInstallDirectory += s_gamesSysDir;

    // Environment
    const char *env_home = SDL_getenv("HOME");
    userDir = s_getEnvNotNull("XDG_DATA_HOME");

    // Init home directory
#if defined(__HAIKU__)
    if(env_home)
        homePath.append(env_home);
#else
    passwd *pw = getpwuid(getuid());
    if(pw)
        homePath.append(pw->pw_dir);
    else if(env_home)
        homePath.append(env_home);
#endif

    // Set default paths if environments aren't defined
    if(homePath.empty())
        homePath = std::string(".");

    if(userDir.empty())
        userDir = homePath + "/.local/share";

    userDir += "/";

    // use modern user directory by default
    s_userDirectory = userDir + userDirName;

    // fallback to legacy directory if there is no custom directory set
    std::string legacyUserDirectory = homePath + "/.PGE_Project/thextech";
    if(userDirName == "TheXTech" && !DirMan::exists(s_userDirectory) && DirMan::exists(legacyUserDirectory))
        s_userDirectory = legacyUserDirectory;

    // find the application's own path
    char *appPath = SDL_GetBasePath();
    if(!appPath)
    {
#ifndef DISABLE_LOGGING
        std::fprintf(stderr, "== Failed to recognize application path by using of SDL_GetBasePath! Using current working directory \"./\" instead.\n");
        std::fflush(stderr);
#endif
        appPath = SDL_strdup("./");
    }

    s_applicationPath = std::string(appPath);
    SDL_free(appPath);
}

std::string AppPathP::appDirectory()
{
    return s_applicationPath;
}

std::string AppPathP::userDirectory()
{
    return s_userDirectory;
}

std::string AppPathP::assetsRoot()
{
    return s_gameInstallDirectory;
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Multiple;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return true;
}

void AppPathP::syncFS()
{}


================================================
FILE: lib/AppPath/private/app_path_vita.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "app_path_private.h"

static std::string s_userDirectory;


void AppPathP::initDefaultPaths(const std::string & /*userDirName*/)
{
    s_userDirectory = "ux0:data/" THEXTECH_DIRECTORY_PREFIX "/";
}

std::string AppPathP::appDirectory()
{
    return std::string();
}

std::string AppPathP::userDirectory()
{
    return s_userDirectory;
}

std::string AppPathP::assetsRoot()
{
    return std::string();
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_wii.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <vector>
#include <string>
#include <fat.h>

#include <DirManager/dirman.h>

#include "../app_path.h"
#include "app_path_private.h"

constexpr const char* s_assetRoot = "/" THEXTECH_DIRECTORY_PREFIX "/";

void AppPathP::initDefaultPaths(const std::string &userDirName)
{
    fatInitDefault();

    (void)userDirName;
}

std::string AppPathP::appDirectory()
{
    return std::string();
}

std::string AppPathP::userDirectory()
{
    return s_assetRoot;
}

std::string AppPathP::assetsRoot()
{
    return std::string();
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_wiiu.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <vector>
#include <string>

#include <nn/save.h>
#include <coreinit/title.h>

#include "../app_path.h"
#include <DirManager/dirman.h>
#include <fmt/fmt_printf.h>
#include "app_path_private.h"

//! The assets&user directory for standalone RPX when SD card is plugged
constexpr const char* s_assetRootSD = "fs:/vol/external01/wiiu/" THEXTECH_DIRECTORY_PREFIX "/";
//! The assets&user directory for standalone RPX when USB stick is plugged
constexpr const char* s_assetRootUSB = "usb:/wiiu/" THEXTECH_DIRECTORY_PREFIX "/";
//! The assets directory for WUHB/installable package of the game
constexpr const char* s_assetRootContent = "fs:/vol/content/";

//! Settings and gamesave directory for WUHB and installable packages
constexpr const char* s_assetSaveRoot = "fs:/vol/save/common/";

//! Read-only assets directory (may be separated when WUHB or an installable thing)
static std::string s_assetRoot;
//! Writeable user directory for logs, screenshots, settings and extra user's episodes
static std::string s_userDir;


void AppPathP::initDefaultPaths(const std::string &userDirName)
{
    (void)userDirName;

    // When running game under WUHB package or as an installable game (/vol/content and /vol/save dirs do exist)
    // Also check that /vol/content/graphics/ exists (assets non-empty)
    if(DirMan::exists(s_assetRootContent) && DirMan::exists(std::string(s_assetRootContent) + "graphics/"))
    {
        SAVEInit();
        SAVEInitCommonSaveDir();

        // Consider /vol/content (WUHB resources) as read-only Assets directory
        s_assetRoot = s_assetRootContent;
        // And consider /vol/save directory as default User Directory
        s_userDir = s_assetSaveRoot;

        // When USB stick is presented, store logs, screenshots and find user's episodes on it
        if(DirMan::exists("usb:/"))
            s_userDir = s_assetRootUSB;
        // When SD card is presented, store logs, screenshots and find user's episodes on it
        else if(DirMan::exists("fs:/vol/external01/"))
            s_userDir = s_assetRootSD;
    }
    else if(DirMan::exists(s_assetRootUSB))
    {
        s_assetRoot.clear();
        s_userDir = s_assetRootUSB;
    }
    else
    {
        s_assetRoot.clear();
        s_userDir = s_assetRootSD;
    }
}

std::string AppPathP::appDirectory()
{
    return std::string();
}

std::string AppPathP::userDirectory()
{
    return s_userDir;
}

std::string AppPathP::assetsRoot()
{
    return s_assetRoot;
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return false;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/AppPath/private/app_path_win32.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <windows.h>
#include <winreg.h>
#include <shlobj.h>
#include <algorithm> // std::replace from \\ into /

#include <SDL2/SDL_stdinc.h>
#include <SDL2/SDL_assert.h>
#include <SDL2/SDL_filesystem.h>

#include <DirManager/dirman.h>

#include "app_path_private.h"

static std::string s_userDirectory;
static std::string s_applicationPath;

static void s_toUtf8(std::string &ret, wchar_t *str, DWORD len)
{
    int outLen;
    ret.clear();
    ret.resize(len * 4); // 4x size to ensure size is enough
    outLen = WideCharToMultiByte(CP_UTF8, 0,
                                 str,       len,
                                 &ret[0],   (int)ret.size(),
                                 0, FALSE);
    ret.resize(outLen);

    // Convert slashes
    for(auto &c : ret)
    {
        if(c == '\\')
            c = '/';
    }
}

void AppPathP::initDefaultPaths(const std::string &userDirName)
{
    wchar_t pathBuffer[MAX_PATH] = L"";

    std::string roamingPath, homePath;

    if(FAILED(SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, pathBuffer)))
    {
#   ifndef DISABLE_LOGGING
        std::fprintf(stderr, "== Failed to retrieve the common AppData\n");
        std::fflush(stderr);
#   endif
    }
    else
        s_toUtf8(roamingPath, pathBuffer, (DWORD)SDL_wcslen(pathBuffer));

    // Application path
    char *path = SDL_GetBasePath();
    if(!path)
    {
#   ifndef DISABLE_LOGGING
        std::fprintf(stderr, "== Failed to recognize application path by using of SDL_GetBasePath! Using current working directory \"./\" instead.\n");
        std::fflush(stderr);
#   endif
        path = SDL_strdup("./");
    }

    s_applicationPath = std::string(path);
    std::replace(s_applicationPath.begin(), s_applicationPath.end(), '\\', '/');
    SDL_free(path);

    // User directory
    DWORD path_len = GetEnvironmentVariableW(L"UserProfile", pathBuffer, MAX_PATH);
    SDL_assert_release(path_len);
    s_toUtf8(homePath, pathBuffer, path_len);

    if(homePath.empty() && roamingPath.empty())
        s_userDirectory = s_applicationPath;
    else
    {
        s_userDirectory = roamingPath + "/" + userDirName;

        // fallback to legacy directory if there is no custom directory set
        std::string legacyUserDirectory = homePath + "/.PGE_Project/thextech";
        if(userDirName == "TheXTech" && !DirMan::exists(s_userDirectory) && DirMan::exists(legacyUserDirectory))
            s_userDirectory = legacyUserDirectory;
    }
}

std::string AppPathP::appDirectory()
{
    return s_applicationPath;
}

std::string AppPathP::userDirectory()
{
    return s_userDirectory;
}

std::string AppPathP::assetsRoot()
{
    return std::string();
}

AssetsPathType AppPathP::assetsRootType()
{
    return AssetsPathType::Single;
}

std::string AppPathP::settingsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide settings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. settings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gamesavesRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide gamesaves
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. gamesaves saved at the settings directory)
     */
    return std::string();
}

std::string AppPathP::screenshotsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide screenshots
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. screenshots saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::gifRecsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide GIF recordings
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. GIF recordings saved at the user directory)
     */
    return std::string();
}

std::string AppPathP::logsRoot()
{
    /*
     * Fill this in only condition when you want to use the system-wide logs
     * directory out of user directory. Keep it empty if you want to keep the
     * default behaviour (i.e. logs saved at the user directory)
     */
    return std::string();
}

bool AppPathP::portableAvailable()
{
    /*
     * Report, does this platfor support portable mode or not
     */
    return true;
}

void AppPathP::syncFS()
{
    /* Run the FS synchronization (Implement this for Emscripten only) */
}


================================================
FILE: lib/Archives/archives.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#pragma once

#ifndef THEXTECH_ARCHIVES_H
#define THEXTECH_ARCHIVES_H

#include <string>

struct SDL_RWops;
struct mbediso_fs;
struct mbediso_dir;

namespace Archives
{

enum PathType
{
    PATH_NONE = 0,
    PATH_FILE,
    PATH_DIR,
};

struct DirEntry
{
    const char* name;
    PathType type;
};

struct DirIterator
{
    mbediso_dir* dir = nullptr;
    bool has_temp_ref = false;
    bool expired = false;

    struct DirIter
    {
        bool is_end = false;
        mbediso_dir* dir = nullptr;
        DirEntry entry;

        DirEntry& operator*();
        DirIter& operator++();
        bool operator!=(const DirIter& o) const;
    };

    DirIter begin();
    DirIter end();
    ~DirIterator();
};

inline bool is_prefix(char letter)
{
    return letter == ':' || letter == '@';
}

inline bool has_prefix(const std::string& s)
{
    return is_prefix(s.c_str()[0]);
}

bool mount_assets(const char* archive_path);
void unmount_assets();
const std::string& assets_archive_path();

bool mount_episode(const char* archive_path);
void unmount_episode();
const std::string& episode_archive_path();

void unmount_temp();

SDL_RWops* open_file(const char* name);
DirIterator list_dir(const char* name);
PathType exists(const char* name);

} // namespace Archives

#endif // #ifndef THEXTECH_ARCHIVES_H


================================================
FILE: lib/Archives/archives_dir.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <vector>

#include <cstring>
#include <cstddef>

#include "sdl_proxy/sdl_assert.h"

#include "archives.h"
#include "archives_priv.h"

#include "mbediso.h"

namespace Archives
{

static void s_next_iter(DirIterator::DirIter& iter)
{
    const auto* ent = mbediso_readdir(iter.dir);
    if(!ent)
    {
        iter.is_end = true;
        return;
    }

    iter.entry.name = (char*)ent->d_name;

    if(ent->d_type == MBEDISO_DT_REG)
        iter.entry.type = PATH_FILE;
    else if(ent->d_type == MBEDISO_DT_DIR)
        iter.entry.type = PATH_DIR;
    else
        iter.entry.type = PATH_NONE;
}

DirIterator::DirIter DirIterator::begin()
{
    DirIter ret;
    if(!dir || expired)
    {
        ret.is_end = true;
        return ret;
    }

    expired = true;

    ret.dir = dir;
    s_next_iter(ret);
    return ret;
}

DirIterator::DirIter DirIterator::end()
{
    DirIter ret;
    ret.is_end = true;
    return ret;
}

DirIterator::~DirIterator()
{
    if(dir)
        mbediso_closedir(dir);
    if(has_temp_ref)
    {
        SDL_assert_release(temp_refs > 0);
        temp_refs--;
    }

    dir = nullptr;
    has_temp_ref = false;
}

DirEntry& DirIterator::DirIter::operator*()
{
    return entry;
}

DirIterator::DirIter& DirIterator::DirIter::operator++()
{
    s_next_iter(*this);
    return *this;
}

bool DirIterator::DirIter::operator!=(const DirIterator::DirIter& o) const
{
    return !is_end || !o.is_end;
}

DirIterator list_dir(const char* name)
{
    DirIterator ret;

    if(!is_prefix(name[0]))
        return ret;

    mbediso_dir* d = nullptr;

    if(name[0] == '@')
    {
        const char* archive_path_start = name + 1;
        const char* archive_path_end = archive_path_start;
        // don't check for path end until after the first slash
        while(*archive_path_end != '\0' && *archive_path_end != '/' && *archive_path_end != '\\')
            ++archive_path_end;
        while(*archive_path_end != '\0' && *archive_path_end != ':')
            ++archive_path_end;

        if(archive_path_end == archive_path_start || *archive_path_end == '\0')
            return ret;

        ptrdiff_t archive_path_size = archive_path_end - archive_path_start;

        char* archive_path = (char*)malloc(archive_path_size + 1);
        memcpy(archive_path, archive_path_start, archive_path_size);
        archive_path[archive_path_size] = '\0';

        bool mounted = mount_temp(archive_path);
        free(archive_path);

        if(!mounted || !temp_mount)
            return ret;

        const char* dir_path_begin = archive_path_end + 1;

        d = mbediso_opendir(temp_mount, dir_path_begin);

        if(d)
        {
            temp_refs++;
            ret.has_temp_ref = true;
        }
    }
    else if(name[0] == ':' && (name[1] == 'a' || name[1] == 'e'))
    {
        mbediso_fs* fs = (name[1] == 'a') ? assets_mount : episode_mount;

        if(fs)
            d = mbediso_opendir(fs, name + 2);
    }

    ret.dir = d;

    return ret;
}

PathType exists(const char* name)
{
    if(!is_prefix(name[0]))
        return PATH_NONE;

    int found = 0;

    if(name[0] == '@')
    {
        const char* archive_path_start = name + 1;
        const char* archive_path_end = archive_path_start;
        // don't check for path end until after the first slash
        while(*archive_path_end != '\0' && *archive_path_end != '/' && *archive_path_end != '\\')
            ++archive_path_end;
        while(*archive_path_end != '\0' && *archive_path_end != ':')
            ++archive_path_end;

        if(archive_path_end == archive_path_start || *archive_path_end == '\0')
            return PATH_NONE;

        ptrdiff_t archive_path_size = archive_path_end - archive_path_start;

        char* archive_path = (char*)malloc(archive_path_size + 1);
        memcpy(archive_path, archive_path_start, archive_path_size);
        archive_path[archive_path_size] = '\0';

        bool mounted = mount_temp(archive_path);
        free(archive_path);

        if(!mounted || !temp_mount)
            return PATH_NONE;

        const char* dir_path_begin = archive_path_end + 1;

        found = mbediso_exists(temp_mount, dir_path_begin);
    }
    else if(name[0] == ':' && (name[1] == 'a' || name[1] == 'e'))
    {
        mbediso_fs* fs = (name[1] == 'a') ? assets_mount : episode_mount;

        if(fs)
            found = mbediso_exists(fs, name + 2);
    }

    if(found == MBEDISO_DT_DIR)
        return PATH_DIR;
    else if(found == MBEDISO_DT_REG)
        return PATH_FILE;
    else
        return PATH_NONE;
}

} // namespace Archives


================================================
FILE: lib/Archives/archives_mount.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <string>
#include <Logger/logger.h>

#include "archives.h"
#include "archives_priv.h"

#include "mbediso.h"

namespace Archives
{

mbediso_fs* assets_mount = nullptr;
mbediso_fs* episode_mount = nullptr;
mbediso_fs* temp_mount = nullptr;
static std::string s_assets_archive_path;
static std::string s_episode_archive_path;
static std::string s_temp_archive_path;

int temp_refs;

static void s_unmount(mbediso_fs*& target, std::string& loaded_path)
{
    loaded_path.clear();

    if(!target)
        return;

    mbediso_closefs(target);
    target = nullptr;
}

static bool s_mount(mbediso_fs*& target, std::string& loaded_path, const char* archive_path)
{
    if(loaded_path == archive_path)
        return true;

    s_unmount(target, loaded_path);

    if(s_temp_archive_path == archive_path && temp_refs == 0 && temp_mount != nullptr && mbediso_scanfs(temp_mount) == 0)
    {
        pLogDebug("Upgrading temporary mount to real mount");

        target = temp_mount;
        temp_mount = nullptr;

        loaded_path = std::move(s_temp_archive_path);
        s_temp_archive_path.clear();

        return true;
    }

    target = mbediso_openfs_file(archive_path, target != temp_mount);

    if(target)
        loaded_path = archive_path;

    return target;
}

bool mount_assets(const char* archive_path)
{
    return s_mount(assets_mount, s_assets_archive_path, archive_path);
}

void unmount_assets()
{
    return s_unmount(assets_mount, s_assets_archive_path);
}

const std::string& assets_archive_path()
{
    return s_assets_archive_path;
}

bool mount_episode(const char* archive_path)
{
    return s_mount(episode_mount, s_episode_archive_path, archive_path);
}

void unmount_episode()
{
    return s_unmount(episode_mount, s_episode_archive_path);
}

const std::string& episode_archive_path()
{
    return s_episode_archive_path;
}

bool mount_temp(const char* archive_path)
{
    if(s_temp_archive_path == archive_path)
        return true;

    if(temp_refs > 0)
    {
        pLogCritical("Can't mount new archive [%s]; items still open from prev archive [%s]", archive_path, s_temp_archive_path.c_str());
        return false;
    }

    return s_mount(temp_mount, s_temp_archive_path, archive_path);
}

void unmount_temp()
{
    if(temp_refs > 0)
    {
        pLogCritical("Can't unmount temp archive [%s]; %d items still open.", s_temp_archive_path.c_str(), (int)temp_refs);
        return;
    }

    return s_unmount(temp_mount, s_temp_archive_path);
}

} // namespace Archives


================================================
FILE: lib/Archives/archives_priv.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#pragma once

#ifndef THEXTECH_ARCHIVES_PRIV_H
#define THEXTECH_ARCHIVES_PRIV_H

namespace Archives
{

extern mbediso_fs* assets_mount;
extern mbediso_fs* episode_mount;
extern mbediso_fs* temp_mount;
extern int temp_refs;

bool mount_temp(const char* archive_path);

} // namespace Archives

#endif // #ifndef THEXTECH_ARCHIVES_PRIV_H


================================================
FILE: lib/Archives/archives_rwops.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <cstring>

#include <SDL2/SDL_rwops.h>
#include "Logger/logger.h"
#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_assert.h"

#include "mbediso.h"

#include "archives.h"
#include "archives_priv.h"

// define specific warnings here until we have full specific warning support via CMake
#ifdef __PSP__
#    define archives_pLogWarning pLogWarning
#else
#    define archives_pLogWarning D_pLogWarning
#endif

namespace Archives
{

static int64_t s_file_size(SDL_RWops* stream)
{
    if(!stream || !stream->hidden.unknown.data1)
        return -1;

    mbediso_file* f = static_cast<mbediso_file*>(stream->hidden.unknown.data1);

    return mbediso_fsize(f);
}

static int64_t s_file_seek(SDL_RWops* stream, int64_t offset, int whence)
{
    if(!stream || !stream->hidden.unknown.data1)
        return -1;

    mbediso_file* f = static_cast<mbediso_file*>(stream->hidden.unknown.data1);

    return mbediso_fseek(f, offset, whence);
}

static size_t s_file_read(SDL_RWops* stream, void* ptr, size_t size, size_t nmemb)
{
    if(!stream || !stream->hidden.unknown.data1)
        return 0;

    mbediso_file* f = static_cast<mbediso_file*>(stream->hidden.unknown.data1);

    return (size_t)mbediso_fread(f, ptr, size, nmemb);
}

static size_t s_file_write(SDL_RWops*, const void*, size_t, size_t)
{
    return 0;
}

static int s_file_close_normal(SDL_RWops* stream)
{
    if(!stream || !stream->hidden.unknown.data1)
        return -1;

    mbediso_file* f = static_cast<mbediso_file*>(stream->hidden.unknown.data1);

    mbediso_fclose(f);

    return 0;
}

static int s_file_close_decref(SDL_RWops* stream)
{
    if(s_file_close_normal(stream))
        return -1;

    SDL_assert_release(temp_refs > 0);
    temp_refs--;

    return 0;
}

SDL_RWops* open_file(const char* name)
{
    if(!is_prefix(name[0]))
    {
        archives_pLogWarning("Archives: Unsupported prefix at path [%s]", name);
        return nullptr;
    }

    bool has_temp_ref = false;
    mbediso_file* f = nullptr;

    if(name[0] == '@')
    {
        const char* archive_path_start = name + 1;
        const char* archive_path_end = archive_path_start;
        // don't check for path end until after the first slash
        while(*archive_path_end != '\0' && *archive_path_end != '/' && *archive_path_end != '\\')
            ++archive_path_end;
        while(*archive_path_end != '\0' && *archive_path_end != ':')
            ++archive_path_end;

        if(archive_path_end == archive_path_start || *archive_path_end == '\0')
        {
            archives_pLogWarning("Archives: invalid composite path [%s]", name);
            return nullptr;
        }

        ptrdiff_t archive_path_size = archive_path_end - archive_path_start;

        char* archive_path = (char*)malloc(archive_path_size + 1);
        memcpy(archive_path, archive_path_start, archive_path_size);
        archive_path[archive_path_size] = '\0';

        bool mounted = mount_temp(archive_path);

        if(!mounted || !temp_mount)
        {
            archives_pLogWarning("Archives: Failed to mount archive [%s]", archive_path);
            free(archive_path);
            return nullptr;
        }

        free(archive_path);

        const char* file_path_begin = archive_path_end + 1;

        f = mbediso_fopen(temp_mount, file_path_begin);
        has_temp_ref = true;
    }
    else if(name[0] == ':' && (name[1] == 'a' || name[1] == 'e'))
    {
        mbediso_fs* fs = (name[1] == 'a') ? assets_mount : episode_mount;

        if(fs)
            f = mbediso_fopen(fs, name + 2);
    }

    if(!f)
    {
        archives_pLogWarning("Archives: File [%s] doesn't exists", name);
        return nullptr;
    }

    SDL_RWops* ret = SDL_AllocRW();

    if(!ret)
    {
        mbediso_fclose(f);
        archives_pLogWarning("Archives: Failed attempt to open [%s]: SDL_RWops error: %s", name, SDL_GetError());
        return nullptr;
    }

    ret->size = s_file_size;
    ret->seek = s_file_seek;
    ret->read = s_file_read;
    ret->write = s_file_write;
    ret->close = (has_temp_ref) ? s_file_close_decref : s_file_close_normal;

    if(has_temp_ref)
        temp_refs++;

    ret->type = SDL_RWOPS_UNKNOWN;
    ret->hidden.unknown.data1 = f;

    return ret;
}

} // namespace Archives


================================================
FILE: lib/CrashHandler/StackWalker/StackWalker.cmake
================================================
# message("Path to StackWalker is [${CMAKE_CURRENT_LIST_DIR}]")
include_directories(${CMAKE_CURRENT_LIST_DIR}/)

set(STACK_WALKER_SRCS)

if(WIN32)
    list(APPEND STACK_WALKER_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/StackWalker.cpp
    )
else()
    message("StackWalker is Windows-only module, nothing was used.")
endif()



================================================
FILE: lib/CrashHandler/StackWalker/StackWalker.cpp
================================================
#ifdef _WIN32
/**********************************************************************
 *
 * StackWalker.cpp
 * http://stackwalker.codeplex.com/
 *
 *
 * History:
 *  2005-07-27   v1    - First public release on http://www.codeproject.com/
 *                       http://www.codeproject.com/threads/StackWalker.asp
 *  2005-07-28   v2    - Changed the params of the constructor and ShowCallstack
 *                       (to simplify the usage)
 *  2005-08-01   v3    - Changed to use 'CONTEXT_FULL' instead of CONTEXT_ALL
 *                       (should also be enough)
 *                     - Changed to compile correctly with the PSDK of VC7.0
 *                       (GetFileVersionInfoSizeA and GetFileVersionInfoA is wrongly defined:
 *                        it uses LPSTR instead of LPCSTR as first paremeter)
 *                     - Added declarations to support VC5/6 without using 'dbghelp.h'
 *                     - Added a 'pUserData' member to the ShowCallstack function and the
 *                       PReadProcessMemoryRoutine declaration (to pass some user-defined data,
 *                       which can be used in the readMemoryFunction-callback)
 *  2005-08-02   v4    - OnSymInit now also outputs the OS-Version by default
 *                     - Added example for doing an exception-callstack-walking in main.cpp
 *                       (thanks to owillebo: http://www.codeproject.com/script/profile/whos_who.asp?id=536268)
 *  2005-08-05   v5    - Removed most Lint (http://www.gimpel.com/) errors... thanks to Okko Willeboordse!
 *  2008-08-04   v6    - Fixed Bug: Missing LEAK-end-tag
 *                       http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=2502890#xx2502890xx
 *                       Fixed Bug: Compiled with "WIN32_LEAN_AND_MEAN"
 *                       http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=1824718#xx1824718xx
 *                       Fixed Bug: Compiling with "/Wall"
 *                       http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=2638243#xx2638243xx
 *                       Fixed Bug: Now checking SymUseSymSrv
 *                       http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=1388979#xx1388979xx
 *                       Fixed Bug: Support for recursive function calls
 *                       http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=1434538#xx1434538xx
 *                       Fixed Bug: Missing FreeLibrary call in "GetModuleListTH32"
 *                       http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=1326923#xx1326923xx
 *                       Fixed Bug: SymDia is number 7, not 9!
 *  2008-09-11   v7      For some (undocumented) reason, dbhelp.h is needing a packing of 8!
 *                       Thanks to Teajay which reported the bug...
 *                       http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=2718933#xx2718933xx
 *  2008-11-27   v8      Debugging Tools for Windows are now stored in a different directory
 *                       Thanks to Luiz Salamon which reported this "bug"...
 *                       http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=2822736#xx2822736xx
 *  2009-04-10   v9      License slihtly corrected (<ORGANIZATION> replaced)
 *  2009-11-01   v10     Moved to http://stackwalker.codeplex.com/
 *  2009-11-02   v11     Now try to use IMAGEHLP_MODULE64_V3 if available
 *  2010-04-15   v12     Added support for VS2010 RTM
 *  2010-05-25   v13     Now using secure MyStrcCpy. Thanks to luke.simon:
 *                       http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=3477467#xx3477467xx
 *  2013-01-07   v14     Runtime Check Error VS2010 Debug Builds fixed:
 *                       http://stackwalker.codeplex.com/workitem/10511
 *
 *
 * LICENSE (http://www.opensource.org/licenses/bsd-license.php)
 *
 *   Copyright (c) 2005-2013, Jochen Kalmbach
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without modification,
 *   are permitted provided that the following conditions are met:
 *
 *   Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *   Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *   Neither the name of Jochen Kalmbach nor the names of its contributors may be
 *   used to endorse or promote products derived from this software without
 *   specific prior written permission.
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 *   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 **********************************************************************/
#include <windows.h>
#include <wchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
//#pragma comment(lib, "version.lib")  // for "VerQueryValue"
//#pragma warning(disable:4826)

#include "StackWalker.h"
#include <string>

void ansi2utf8(char *inout, const DWORD maxLen)
{
    std::wstring tmpW;
    tmpW.resize(maxLen);
    memset(&tmpW[0], 0, sizeof(wchar_t) * maxLen);
    int len = (int)strlen(inout);
    len = MultiByteToWideChar(CP_ACP, 0, inout, len, &tmpW[0], maxLen);
    len = WideCharToMultiByte(CP_UTF8, 0, &tmpW[0], len, inout, (maxLen - 1), 0, 0);
    inout[len] = '\0';
}

// If VC7 and later, then use the shipped 'dbghelp.h'-file
#pragma pack(push,8)
#if _MSC_VER >= 1300
#include <dbghelp.h>
#else
// inline the important dbghelp.h-declarations...
typedef enum
{
    SymNone = 0,
    SymCoff,
    SymCv,
    SymPdb,
    SymExport,
    SymDeferred,
    SymSym,
    SymDia,
    SymVirtual,
    NumSymTypes
} SYM_TYPE;
typedef struct _IMAGEHLP_LINE64
{
    DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_LINE64)
    PVOID                       Key;                    // internal
    DWORD                       LineNumber;             // line number in file
    PCHAR                       FileName;               // full filename
    DWORD64                     Address;                // first instruction of line
} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
typedef struct _IMAGEHLP_MODULE64
{
    DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE64)
    DWORD64                     BaseOfImage;            // base load address of module
    DWORD                       ImageSize;              // virtual size of the loaded module
    DWORD                       TimeDateStamp;          // date/time stamp from pe header
    DWORD                       CheckSum;               // checksum from the pe header
    DWORD                       NumSyms;                // number of symbols in the symbol table
    SYM_TYPE                    SymType;                // type of symbols loaded
    CHAR                        ModuleName[32];         // module name
    CHAR                        ImageName[256];         // image name
    CHAR                        LoadedImageName[256];   // symbol file name
} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
typedef struct _IMAGEHLP_SYMBOL64
{
    DWORD                       SizeOfStruct;           // set to sizeof(IMAGEHLP_SYMBOL64)
    DWORD64                     Address;                // virtual address including dll base address
    DWORD                       Size;                   // estimated size of symbol, can be zero
    DWORD                       Flags;                  // info about the symbols, see the SYMF defines
    DWORD                       MaxNameLength;          // maximum size of symbol name in 'Name'
    CHAR                        Name[1];                // symbol name (null terminated string)
} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
typedef enum
{
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
} ADDRESS_MODE;
typedef struct _tagADDRESS64
{
    DWORD64       Offset;
    WORD          Segment;
    ADDRESS_MODE  Mode;
} ADDRESS64, *LPADDRESS64;
typedef struct _KDHELP64
{
    DWORD64   Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64   KiCallUserMode;
    DWORD64   KeUserCallbackDispatcher;
    DWORD64   SystemRangeStart;
    DWORD64  Reserved[8];
} KDHELP64, *PKDHELP64;
typedef struct _tagSTACKFRAME64
{
    ADDRESS64   AddrPC;               // program counter
    ADDRESS64   AddrReturn;           // return address
    ADDRESS64   AddrFrame;            // frame pointer
    ADDRESS64   AddrStack;            // stack pointer
    ADDRESS64   AddrBStore;           // backing store pointer
    PVOID       FuncTableEntry;       // pointer to pdata/fpo or NULL
    DWORD64     Params[4];            // possible arguments to the function
    BOOL        Far;                  // WOW far call
    BOOL        Virtual;              // is this a virtual frame?
    DWORD64     Reserved[3];
    KDHELP64    KdHelp;
} STACKFRAME64, *LPSTACKFRAME64;
typedef
BOOL
(__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)(
    HANDLE      hProcess,
    DWORD64     qwBaseAddress,
    PVOID       lpBuffer,
    DWORD       nSize,
    LPDWORD     lpNumberOfBytesRead
);
typedef
PVOID
(__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64)(
    HANDLE  hProcess,
    DWORD64 AddrBase
);
typedef
DWORD64
(__stdcall *PGET_MODULE_BASE_ROUTINE64)(
    HANDLE  hProcess,
    DWORD64 Address
);
typedef
DWORD64
(__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)(
    HANDLE    hProcess,
    HANDLE    hThread,
    LPADDRESS64 lpaddr
);
#define SYMOPT_CASE_INSENSITIVE         0x00000001
#define SYMOPT_UNDNAME                  0x00000002
#define SYMOPT_DEFERRED_LOADS           0x00000004
#define SYMOPT_NO_CPP                   0x00000008
#define SYMOPT_LOAD_LINES               0x00000010
#define SYMOPT_OMAP_FIND_NEAREST        0x00000020
#define SYMOPT_LOAD_ANYTHING            0x00000040
#define SYMOPT_IGNORE_CVREC             0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS     0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS     0x00000200
#define SYMOPT_EXACT_SYMBOLS            0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS   0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH        0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES    0x00002000
#define SYMOPT_PUBLICS_ONLY             0x00004000
#define SYMOPT_NO_PUBLICS               0x00008000
#define SYMOPT_AUTO_PUBLICS             0x00010000
#define SYMOPT_NO_IMAGE_SEARCH          0x00020000
#define SYMOPT_SECURE                   0x00040000
#define SYMOPT_DEBUG                    0x80000000
#define UNDNAME_COMPLETE                 (0x0000)  // Enable full undecoration
#define UNDNAME_NAME_ONLY                (0x1000)  // Crack only the name for primary declaration;
#endif  // _MSC_VER < 1300
#pragma pack(pop)

// Some missing defines (for VC5/6):
#ifndef INVALID_FILE_ATTRIBUTES
#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
#endif


// secure-CRT_functions are only available starting with VC8
#define strcpy_s(dst, len, src) strcpy(dst, src)
#define strncpy_s(dst, len, src, maxLen) strncpy(dst, src, maxLen)
#define strcat_s(dst, len, src) strcat(dst, src)
#define sprintf_s snprintf
//#define _tcscat_s _tcscat



static void MyStrCpy(char *szDest, size_t nMaxDestSize, const char *szSrc)
{
    if(nMaxDestSize <= 0)
        return;
    memset(szDest, 0, nMaxDestSize);
    strncpy(szDest, szSrc, nMaxDestSize);
    szDest[nMaxDestSize - 1] = 0;// INFO: _TRUNCATE will ensure that it is nul-terminated; but with older compilers (<1400) it uses "strncpy" and this does not!)
}  // MyStrCpy

// Normally it should be enough to use 'CONTEXT_FULL' (better would be 'CONTEXT_ALL')
#define USED_CONTEXT_FLAGS CONTEXT_FULL


class StackWalkerInternal
{
public:
    StackWalkerInternal(StackWalker *parent, HANDLE hProcess)
    {
        m_parent = parent;
        m_hDbhHelp = NULL;
        pSC = NULL;
        m_hProcess = hProcess;
        m_szSymPath = NULL;
        pSFTA = NULL;
        pSGLFA = NULL;
        pSGMB = NULL;
        pSGMI = NULL;
        pSGO = NULL;
        pSGSFA = NULL;
        pSI = NULL;
        pSLM = NULL;
        pSSO = NULL;
        pSW = NULL;
        pUDSN = NULL;
        pSGSP = NULL;
    }
    ~StackWalkerInternal()
    {
        if(pSC != NULL)
            pSC(m_hProcess);  // SymCleanup
        if(m_hDbhHelp != NULL)
            FreeLibrary(m_hDbhHelp);
        m_hDbhHelp = NULL;
        m_parent = NULL;
        if(m_szSymPath != NULL)
            free(m_szSymPath);
        m_szSymPath = NULL;
    }
    BOOL Init(LPCSTR szSymPath)
    {
        if(m_parent == NULL)
            return FALSE;
        // Dynamically load the Entry-Points for dbghelp.dll:
        // First try to load the newsest one from

        std::wstring szTemp;
        szTemp.resize(4100);
        // But before wqe do this, we first check if the ".local" file exists
        DWORD szTempSize = GetModuleFileNameW(NULL, &szTemp[0], 4096);
        szTemp.resize(szTempSize);
        if(szTempSize > 0)
        {
            szTemp += L".local";
            if(GetFileAttributesW(&szTemp[0]) == INVALID_FILE_ATTRIBUTES)
            {
                // ".local" file does not exist, so we can try to load the dbghelp.dll from the "Debugging Tools for Windows"
                // Ok, first try the new path according to the archtitecture:
                if(!m_hDbhHelp)
                {
                    szTempSize = GetEnvironmentVariableW(L"ProgramFiles", &szTemp[0], 4096);
                    szTemp.resize(szTempSize);
                }
#ifdef _M_IX86
                if((m_hDbhHelp == NULL) && (szTempSize > 0))
                {
                    szTemp = szTemp + L"\\Debugging Tools for Windows (x86)\\dbghelp.dll";
                    // now check if the file exists:
                    if(GetFileAttributesW(szTemp.c_str()) != INVALID_FILE_ATTRIBUTES)
                    {
                        m_hDbhHelp = LoadLibraryW(szTemp.c_str());
                    }
                }
#elif _M_X64
                if((m_hDbhHelp == NULL) && (szTempSize > 0))
                {
                    szTemp += L"\\Debugging Tools for Windows (x64)\\dbghelp.dll";
                    // now check if the file exists:
                    if(GetFileAttributesW(szTemp.c_str()) != INVALID_FILE_ATTRIBUTES)
                    {
                        m_hDbhHelp = LoadLibraryW(szTemp.c_str());
                    }
                }
#elif _M_IA64
                if((m_hDbhHelp == NULL) && (szTempSize > 0))
                {
                    szTemp += L"\\Debugging Tools for Windows (ia64)\\dbghelp.dll";
                    // now check if the file exists:
                    if(GetFileAttributes(szTempS) != INVALID_FILE_ATTRIBUTES)
                    {
                        m_hDbhHelp = LoadLibrary(szTempS);
                    }
                }
#endif

                if(!m_hDbhHelp)
                {
                    szTempSize = GetEnvironmentVariableW(L"ProgramFiles", &szTemp[0], 4096);
                    szTemp.resize(szTempSize);
                }

                // If still not found, try the old directories...
                if((m_hDbhHelp == NULL) && (szTempSize > 0))
                {
                    szTemp += L"\\Debugging Tools for Windows\\dbghelp.dll";
                    // now check if the file exists:
                    if(GetFileAttributesW(&szTemp[0]) != INVALID_FILE_ATTRIBUTES)
                    {
                        m_hDbhHelp = LoadLibraryW(&szTemp[0]);
                    }
                }

#if defined _M_X64 || defined _M_IA64
                if(!m_hDbhHelp)
                {
                    szTempSize = GetEnvironmentVariableW(L"ProgramFiles", &szTemp[0], 4096);
                    szTemp.resize(szTempSize);
                }
                // Still not found? Then try to load the (old) 64-Bit version:
                if((m_hDbhHelp == NULL) && (szTempSize > 0))
                {
                    szTemp += L"\\Debugging Tools for Windows 64-Bit\\dbghelp.dll";
                    const wchar_t *szTempS = (wchar_t *)szTemp.c_str();
                    if(GetFileAttributesW(szTempS) != INVALID_FILE_ATTRIBUTES)
                    {
                        m_hDbhHelp = LoadLibraryW(szTempS);
                    }
                }
#endif
            }
        }

        if(m_hDbhHelp == NULL)   // if not already loaded, try to load a default-one
            m_hDbhHelp = LoadLibraryW(L"dbghelp.dll");

        if(m_hDbhHelp == NULL)
            return FALSE;

        pSI = (tSI)(void*)GetProcAddress(m_hDbhHelp, "SymInitialize");
        pSC = (tSC)(void*)GetProcAddress(m_hDbhHelp, "SymCleanup");

        pSW = (tSW)(void*)GetProcAddress(m_hDbhHelp, "StackWalk64");
        pSGO = (tSGO)(void*)GetProcAddress(m_hDbhHelp, "SymGetOptions");
        pSSO = (tSSO)(void*)GetProcAddress(m_hDbhHelp, "SymSetOptions");

        pSFTA = (tSFTA)(void*)GetProcAddress(m_hDbhHelp, "SymFunctionTableAccess64");
        pSGLFA = (tSGLFA)(void*)GetProcAddress(m_hDbhHelp, "SymGetLineFromAddr64");
        pSGMB = (tSGMB)(void*)GetProcAddress(m_hDbhHelp, "SymGetModuleBase64");
        pSGMI = (tSGMI)(void*)GetProcAddress(m_hDbhHelp, "SymGetModuleInfo64");
        pSGSFA = (tSGSFA)(void*)GetProcAddress(m_hDbhHelp, "SymGetSymFromAddr64");
        pUDSN = (tUDSN)(void*)GetProcAddress(m_hDbhHelp, "UnDecorateSymbolName");
        pSLM = (tSLM)(void*)GetProcAddress(m_hDbhHelp, "SymLoadModule64");
        pSGSP = (tSGSP)(void*)GetProcAddress(m_hDbhHelp, "SymGetSearchPath");

        if(pSC == NULL || pSFTA == NULL || pSGMB == NULL || pSGMI == NULL ||
           pSGO == NULL || pSGSFA == NULL || pSI == NULL || pSSO == NULL ||
           pSW == NULL || pUDSN == NULL || pSLM == NULL)
        {
            FreeLibrary(m_hDbhHelp);
            m_hDbhHelp = NULL;
            pSC = NULL;
            return FALSE;
        }

        // SymInitialize
        if(szSymPath != NULL)
            m_szSymPath = _strdup(szSymPath);
        if(this->pSI(m_hProcess, m_szSymPath, FALSE) == FALSE)
            this->m_parent->OnDbgHelpErr("SymInitialize", GetLastError(), 0);

        DWORD symOptions = this->pSGO();  // SymGetOptions
        symOptions |= SYMOPT_LOAD_LINES;
        symOptions |= SYMOPT_FAIL_CRITICAL_ERRORS;
        //symOptions |= SYMOPT_NO_PROMPTS;
        // SymSetOptions
        symOptions = this->pSSO(symOptions);

        char   buf[StackWalker::STACKWALK_MAX_NAMELEN] = {0};
        if(this->pSGSP != NULL)
        {
            if(this->pSGSP(m_hProcess, buf, StackWalker::STACKWALK_MAX_NAMELEN) == FALSE)
                this->m_parent->OnDbgHelpErr("SymGetSearchPath", GetLastError(), 0);
        }
        char    szUserName[1024] = {0};
        DWORD   dwSize = 1024;
#ifdef THEXTECH_WINRT
        dwSize = sprintf(szUserName, "<unknown>");
#else
        GetUserNameA(szUserName, &dwSize);
#endif

        this->m_parent->OnSymInit(buf, symOptions, szUserName);

        return TRUE;
    }

    StackWalker *m_parent;

    HMODULE m_hDbhHelp;
    HANDLE m_hProcess;
    LPSTR m_szSymPath;

#pragma pack(push,8)
    struct IMAGEHLP_MODULE64_V3
    {
        DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE64)
        DWORD64  BaseOfImage;            // base load address of module
        DWORD    ImageSize;              // virtual size of the loaded module
        DWORD    TimeDateStamp;          // date/time stamp from pe header
        DWORD    CheckSum;               // checksum from the pe header
        DWORD    NumSyms;                // number of symbols in the symbol table
        SYM_TYPE SymType;                // type of symbols loaded
        CHAR     ModuleName[32];         // module name
        CHAR     ImageName[256];         // image name
        CHAR     LoadedImageName[256];   // symbol file name
        // new elements: 07-Jun-2002
        CHAR     LoadedPdbName[256];     // pdb file name
        DWORD    CVSig;                  // Signature of the CV record in the debug directories
        CHAR     CVData[MAX_PATH * 3];   // Contents of the CV record
        DWORD    PdbSig;                 // Signature of PDB
        GUID     PdbSig70;               // Signature of PDB (VC 7 and up)
        DWORD    PdbAge;                 // DBI age of pdb
        BOOL     PdbUnmatched;           // loaded an unmatched pdb
        BOOL     DbgUnmatched;           // loaded an unmatched dbg
        BOOL     LineNumbers;            // we have line number information
        BOOL     GlobalSymbols;          // we have internal symbol information
        BOOL     TypeInfo;               // we have type information
        // new elements: 17-Dec-2003
        BOOL     SourceIndexed;          // pdb supports source server
        BOOL     Publics;                // contains public symbols
    };

    struct IMAGEHLP_MODULE64_V2
    {
        DWORD    SizeOfStruct;           // set to sizeof(IMAGEHLP_MODULE64)
        DWORD64  BaseOfImage;            // base load address of module
        DWORD    ImageSize;              // virtual size of the loaded module
        DWORD    TimeDateStamp;          // date/time stamp from pe header
        DWORD    CheckSum;               // checksum from the pe header
        DWORD    NumSyms;                // number of symbols in the symbol table
        SYM_TYPE SymType;                // type of symbols loaded
        CHAR     ModuleName[32];         // module name
        CHAR     ImageName[256];         // image name
        CHAR     LoadedImageName[256];   // symbol file name
    };
#pragma pack(pop)


    // SymCleanup()
    typedef BOOL (__stdcall *tSC)(IN HANDLE hProcess);
    tSC pSC;

    // SymFunctionTableAccess64()
    typedef PVOID(__stdcall *tSFTA)(HANDLE hProcess, DWORD64 AddrBase);
    tSFTA pSFTA;

    // SymGetLineFromAddr64()
    typedef BOOL (__stdcall *tSGLFA)(IN HANDLE hProcess, IN DWORD64 dwAddr,
                                     OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_LINE64 Line);
    tSGLFA pSGLFA;

    // SymGetModuleBase64()
    typedef DWORD64(__stdcall *tSGMB)(IN HANDLE hProcess, IN DWORD64 dwAddr);
    tSGMB pSGMB;

    // SymGetModuleInfo64()
    typedef BOOL (__stdcall *tSGMI)(IN HANDLE hProcess, IN DWORD64 dwAddr, OUT IMAGEHLP_MODULE64_V3 *ModuleInfo);
    tSGMI pSGMI;

    // SymGetOptions()
    typedef DWORD (__stdcall *tSGO)(VOID);
    tSGO pSGO;

    // SymGetSymFromAddr64()
    typedef BOOL (__stdcall *tSGSFA)(IN HANDLE hProcess, IN DWORD64 dwAddr,
                                     OUT PDWORD64 pdwDisplacement, OUT PIMAGEHLP_SYMBOL64 Symbol);
    tSGSFA pSGSFA;

    // SymInitialize()
    typedef BOOL (__stdcall *tSI)(IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess);
    tSI pSI;

    // SymLoadModule64()
    typedef DWORD64(__stdcall *tSLM)(IN HANDLE hProcess, IN HANDLE hFile,
                                     IN PSTR ImageName, IN PSTR ModuleName, IN DWORD64 BaseOfDll, IN DWORD SizeOfDll);
    tSLM pSLM;

    // SymSetOptions()
    typedef DWORD (__stdcall *tSSO)(IN DWORD SymOptions);
    tSSO pSSO;

    // StackWalk64()
    typedef BOOL (__stdcall *tSW)(
        DWORD MachineType,
        HANDLE hProcess,
        HANDLE hThread,
        LPSTACKFRAME64 StackFrame,
        PVOID ContextRecord,
        PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
        PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
        PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
        PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
    tSW pSW;

    // UnDecorateSymbolName()
    typedef DWORD (__stdcall WINAPI *tUDSN)(PCSTR DecoratedName, PSTR UnDecoratedName,
                                            DWORD UndecoratedLength, DWORD Flags);
    tUDSN pUDSN;

    typedef BOOL (__stdcall WINAPI *tSGSP)(HANDLE hProcess, PSTR SearchPath, DWORD SearchPathLength);
    tSGSP pSGSP;


private:
    // **************************************** ToolHelp32 ************************
#define MAX_MODULE_NAME32 255
#define TH32CS_SNAPMODULE   0x00000008
#pragma pack( push, 8 )
    typedef struct tagMODULEENTRY32
    {
        DWORD   dwSize;
        DWORD   th32ModuleID;       // This module
        DWORD   th32ProcessID;      // owning process
        DWORD   GlblcntUsage;       // Global usage count on the module
        DWORD   ProccntUsage;       // Module usage count in th32ProcessID's context
        BYTE   *modBaseAddr;        // Base address of module in th32ProcessID's context
        DWORD   modBaseSize;        // Size in bytes of module starting at modBaseAddr
        HMODULE hModule;            // The hModule of this module in th32ProcessID's context
        char    szModule[MAX_MODULE_NAME32 + 1];
        char    szExePath[MAX_PATH];
    } MODULEENTRY32;
    typedef MODULEENTRY32   *PMODULEENTRY32;
    typedef MODULEENTRY32   *LPMODULEENTRY32;
#pragma pack( pop )

    BOOL GetModuleListTH32(HANDLE hProcess, DWORD pid)
    {
        // CreateToolhelp32Snapshot()
        typedef HANDLE(__stdcall * tCT32S)(DWORD dwFlags, DWORD th32ProcessID);
        // Module32First()
        typedef BOOL (__stdcall * tM32F)(HANDLE hSnapshot, LPMODULEENTRY32 lpme);
        // Module32Next()
        typedef BOOL (__stdcall * tM32N)(HANDLE hSnapshot, LPMODULEENTRY32 lpme);

        // try both dlls...
        const wchar_t *dllname[] = { L"kernel32.dll", L"tlhelp32.dll" };
        HINSTANCE hToolhelp = NULL;
        tCT32S pCT32S = NULL;
        tM32F pM32F = NULL;
        tM32N pM32N = NULL;

        HANDLE hSnap;
        MODULEENTRY32 me;
        me.dwSize = sizeof(me);
        BOOL keepGoing;
        size_t i;

        for(i = 0; i < (sizeof(dllname) / sizeof(dllname[0])); i++)
        {
            hToolhelp = LoadLibraryW(dllname[i]);
            if(hToolhelp == NULL)
                continue;
            pCT32S = (tCT32S)(void*)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot");
            pM32F = (tM32F)(void*)GetProcAddress(hToolhelp, "Module32First");
            pM32N = (tM32N)(void*)GetProcAddress(hToolhelp, "Module32Next");
            if((pCT32S != NULL) && (pM32F != NULL) && (pM32N != NULL))
                break; // found the functions!
            FreeLibrary(hToolhelp);
            hToolhelp = NULL;
        }

        if(hToolhelp == NULL)
            return FALSE;

        hSnap = pCT32S(TH32CS_SNAPMODULE, pid);
        if(hSnap == (HANDLE) - 1)
        {
            FreeLibrary(hToolhelp);
            return FALSE;
        }

        keepGoing = !!pM32F(hSnap, &me);
        int cnt = 0;
        while(keepGoing)
        {
            this->LoadModule(hProcess, me.szExePath, me.szModule, (DWORD64) me.modBaseAddr, me.modBaseSize);
            cnt++;
            keepGoing = !!pM32N(hSnap, &me);
        }
        CloseHandle(hSnap);
        FreeLibrary(hToolhelp);
        if(cnt <= 0)
            return FALSE;
        return TRUE;
    }  // GetModuleListTH32

    // **************************************** PSAPI ************************
    typedef struct _MODULEINFO
    {
        LPVOID lpBaseOfDll;
        DWORD SizeOfImage;
        LPVOID EntryPoint;
    } MODULEINFO, *LPMODULEINFO;

    BOOL GetModuleListPSAPI(HANDLE hProcess)
    {
        // EnumProcessModules()
        typedef BOOL (__stdcall * tEPM)(HANDLE hProcess, HMODULE * lphModule, DWORD cb, LPDWORD lpcbNeeded);
        // GetModuleFileNameEx()
        typedef DWORD (__stdcall * tGMFNE)(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize);
        // GetModuleBaseName()
        typedef DWORD (__stdcall * tGMBN)(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize);
        // GetModuleInformation()
        typedef BOOL (__stdcall * tGMI)(HANDLE hProcess, HMODULE hModule, LPMODULEINFO pmi, DWORD nSize);

        HINSTANCE hPsapi;
        tEPM pEPM;
        tGMFNE pGMFNE;
        tGMBN pGMBN;
        tGMI pGMI;

        DWORD i;
        //ModuleEntry e;
        DWORD cbNeeded;
        MODULEINFO mi;
        HMODULE *hMods = 0;
        char *tt = NULL;
        char *tt2 = NULL;
        const SIZE_T TTBUFLEN = 8096;
        int cnt = 0;

        hPsapi = LoadLibraryW(L"psapi.dll");
        if(hPsapi == NULL)
            return FALSE;
        pEPM = (tEPM)(void*)GetProcAddress(hPsapi, "EnumProcessModules");
        pGMFNE = (tGMFNE)(void*)GetProcAddress(hPsapi, "GetModuleFileNameExA");
        pGMBN = (tGMFNE)(void*)GetProcAddress(hPsapi, "GetModuleBaseNameA");
        pGMI = (tGMI)(void*)GetProcAddress(hPsapi, "GetModuleInformation");
        if((pEPM == NULL) || (pGMFNE == NULL) || (pGMBN == NULL) || (pGMI == NULL))
        {
            // we couldn? find all functions
            FreeLibrary(hPsapi);
            return FALSE;
        }

        hMods = (HMODULE *) malloc(sizeof(HMODULE) * (TTBUFLEN / sizeof(HMODULE)));
        tt = (char *) malloc(sizeof(char) * TTBUFLEN);
        tt2 = (char *) malloc(sizeof(char) * TTBUFLEN);
        if((hMods == NULL) || (tt == NULL) || (tt2 == NULL))
            goto cleanup;

        if(!pEPM(hProcess, hMods, TTBUFLEN, &cbNeeded))
        {
            //_ftprintf(fLogFile, _T("%lu: EPM failed, GetLastError = %lu\n"), g_dwShowCount, gle );
            goto cleanup;
        }

        if(cbNeeded > TTBUFLEN)
        {
            //_ftprintf(fLogFile, _T("%lu: More than %lu module handles. Huh?\n"), g_dwShowCount, lenof( hMods ) );
            goto cleanup;
        }

        for(i = 0; i < cbNeeded / sizeof(hMods[0]); i++)
        {
            // base address, size
            pGMI(hProcess, hMods[i], &mi, sizeof(mi));
            // image file name
            tt[0] = 0;
            pGMFNE(hProcess, hMods[i], tt, TTBUFLEN);
            // module name
            tt2[0] = 0;
            pGMBN(hProcess, hMods[i], tt2, TTBUFLEN);

            DWORD dwRes = this->LoadModule(hProcess, tt, tt2, (DWORD64) mi.lpBaseOfDll, mi.SizeOfImage);
            if(dwRes != ERROR_SUCCESS)
                this->m_parent->OnDbgHelpErr("LoadModule", dwRes, 0);
            cnt++;
        }

cleanup:
        if(hPsapi != NULL) FreeLibrary(hPsapi);
        if(tt2 != NULL) free(tt2);
        if(tt != NULL) free(tt);
        if(hMods != NULL) free(hMods);

        return cnt != 0;
    }// GetModuleListPSAPI

    DWORD LoadModule(HANDLE hProcess, LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size)
    {
        CHAR *szImg = _strdup(img);
        CHAR *szMod = _strdup(mod);
        DWORD result = ERROR_SUCCESS;
        if((szImg == NULL) || (szMod == NULL))
            result = ERROR_NOT_ENOUGH_MEMORY;
        else
        {
            if(pSLM(hProcess, 0, szImg, szMod, baseAddr, size) == 0)
                result = GetLastError();
        }
        ULONGLONG fileVersion = 0;
        if((m_parent != NULL) && (szImg != NULL))
        {
            // try to retrive the file-version:
            if((this->m_parent->m_options & StackWalker::RetrieveFileVersion) != 0)
            {
                VS_FIXEDFILEINFO *fInfo = NULL;
                DWORD dwHandle = 0;
                DWORD dwSize = GetFileVersionInfoSizeA(szImg, &dwHandle);
                if(dwSize > 0)
                {
                    LPVOID vData = malloc(dwSize);
                    if(vData != NULL)
                    {
                        //#pragma warning(suppress: 6388)
                        if(GetFileVersionInfoA(szImg, dwHandle, dwSize, vData) != 0)
                        {
                            UINT len;
                            wchar_t szSubBlock[] = L"\\";
                            if(VerQueryValueW(vData, szSubBlock, (LPVOID *) &fInfo, &len) == 0)
                                fInfo = NULL;
                            else
                            {
                                fileVersion = ((ULONGLONG)fInfo->dwFileVersionLS) + ((ULONGLONG)fInfo->dwFileVersionMS << 32);
                            }
                        }
                        free(vData);
                    }
                }
            }

            // Retrive some additional-infos about the module
            IMAGEHLP_MODULE64_V3 Module;
            const char *szSymType = "-unknown-";
            if(this->GetModuleInfo(hProcess, baseAddr, &Module) != FALSE)
            {
                switch(Module.SymType)
                {
                case SymNone:
                    szSymType = "-nosymbols-";
                    break;
                case SymCoff:  // 1
                    szSymType = "COFF";
                    break;
                case SymCv:  // 2
                    szSymType = "CV";
                    break;
                case SymPdb:  // 3
                    szSymType = "PDB";
                    break;
                case SymExport:  // 4
                    szSymType = "-exported-";
                    break;
                case SymDeferred:  // 5
                    szSymType = "-deferred-";
                    break;
                case SymSym:  // 6
                    szSymType = "SYM";
                    break;
                case 7: // SymDia:
                    szSymType = "DIA";
                    break;
                case 8: //SymVirtual:
                    szSymType = "Virtual";
                    break;
                default:
                    break;
                }
            }
            LPCSTR pdbName = Module.LoadedImageName;
            if(Module.LoadedPdbName[0] != 0)
                pdbName = Module.LoadedPdbName;
            this->m_parent->OnLoadModule(img, mod, baseAddr, size, result, szSymType, pdbName, fileVersion);
        }
        if(szImg != NULL) free(szImg);
        if(szMod != NULL) free(szMod);
        return result;
    }
public:
    BOOL LoadModules(HANDLE hProcess, DWORD dwProcessId)
    {
        // first try toolhelp32
        if(GetModuleListTH32(hProcess, dwProcessId))
            return true;
        // then try psapi
        return GetModuleListPSAPI(hProcess);
    }


    BOOL GetModuleInfo(HANDLE hProcess, DWORD64 baseAddr, IMAGEHLP_MODULE64_V3 *pModuleInfo)
    {
        memset(pModuleInfo, 0, sizeof(IMAGEHLP_MODULE64_V3));
        if(this->pSGMI == NULL)
        {
            SetLastError(ERROR_DLL_INIT_FAILED);
            return FALSE;
        }
        // First try to use the larger ModuleInfo-Structure
        pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V3);
        void *pData = malloc(4096); // reserve enough memory, so the bug in v6.3.5.1 does not lead to memory-overwrites...
        if(pData == NULL)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
        memcpy(pData, pModuleInfo, sizeof(IMAGEHLP_MODULE64_V3));
        static bool s_useV3Version = true;
        if(s_useV3Version)
        {
            if(this->pSGMI(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3 *) pData) != FALSE)
            {
                // only copy as much memory as is reserved...
                memcpy(pModuleInfo, pData, sizeof(IMAGEHLP_MODULE64_V3));
                pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V3);
                free(pData);
                return TRUE;
            }
            s_useV3Version = false;  // to prevent unneccessarry calls with the larger struct...
        }

        // could not retrive the bigger structure, try with the smaller one (as defined in VC7.1)...
        pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V2);
        memcpy(pData, pModuleInfo, sizeof(IMAGEHLP_MODULE64_V2));
        if(this->pSGMI(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3 *) pData) != FALSE)
        {
            // only copy as much memory as is reserved...
            memcpy(pModuleInfo, pData, sizeof(IMAGEHLP_MODULE64_V2));
            pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V2);
            free(pData);
            return TRUE;
        }
        free(pData);
        SetLastError(ERROR_DLL_INIT_FAILED);
        return FALSE;
    }
};

// #############################################################
StackWalker::StackWalker(DWORD dwProcessId, HANDLE hProcess)
{
    this->m_options = OptionsAll;
    this->m_modulesLoaded = FALSE;
    this->m_hProcess = hProcess;
    this->m_sw = new StackWalkerInternal(this, this->m_hProcess);
    this->m_dwProcessId = dwProcessId;
    this->m_szSymPath = NULL;
    this->m_MaxRecursionCount = 1000;
}
StackWalker::StackWalker(int options, LPCSTR szSymPath, DWORD dwProcessId, HANDLE hProcess)
{
    this->m_options = options;
    this->m_modulesLoaded = FALSE;
    this->m_hProcess = hProcess;
    this->m_sw = new StackWalkerInternal(this, this->m_hProcess);
    this->m_dwProcessId = dwProcessId;
    if(szSymPath != NULL)
    {
        this->m_szSymPath = _strdup(szSymPath);
        this->m_options |= SymBuildPath;
    }
    else
        this->m_szSymPath = NULL;
    this->m_MaxRecursionCount = 1000;
}

StackWalker::~StackWalker()
{
    if(m_szSymPath != NULL)
        free(m_szSymPath);
    m_szSymPath = NULL;
    if(this->m_sw != NULL)
        delete this->m_sw;
    this->m_sw = NULL;
}

BOOL StackWalker::LoadModules()
{
    if(this->m_sw == NULL)
    {
        SetLastError(ERROR_DLL_INIT_FAILED);
        return FALSE;
    }
    if(m_modulesLoaded != FALSE)
        return TRUE;

    // Build the sym-path:
    char *szSymPath = NULL;
    if((this->m_options & SymBuildPath) != 0)
    {
        const size_t nSymPathLen = 4096;
        szSymPath = (char *) malloc(nSymPathLen);
        if(szSymPath == NULL)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
        szSymPath[0] = 0;
        // Now first add the (optional) provided sympath:
        if(this->m_szSymPath != NULL)
        {
            strcat_s(szSymPath, nSymPathLen, this->m_szSymPath);
            strcat_s(szSymPath, nSymPathLen, ";");
        }

        strcat_s(szSymPath, nSymPathLen, ".;");

        const size_t nTempLen = 1024;
        char szTemp[nTempLen];
        // Now add the current directory:
        if(GetCurrentDirectoryA(nTempLen, szTemp) > 0)
        {
            szTemp[nTempLen - 1] = 0;
            strcat_s(szSymPath, nSymPathLen, szTemp);
            strcat_s(szSymPath, nSymPathLen, ";");
        }

        // Now add the path for the main-module:
        if(GetModuleFileNameA(NULL, szTemp, nTempLen) > 0)
        {
            szTemp[nTempLen - 1] = 0;
            for(char *p = (szTemp + strlen(szTemp) - 1); p >= szTemp; --p)
            {
                // locate the rightmost path separator
                if((*p == '\\') || (*p == '/') || (*p == ':'))
                {
                    *p = 0;
                    break;
                }
            }  // for (search for path separator...)
            if(strlen(szTemp) > 0)
            {
                strcat_s(szSymPath, nSymPathLen, szTemp);
                strcat_s(szSymPath, nSymPathLen, ";");
            }
        }
        if(GetEnvironmentVariableA("_NT_SYMBOL_PATH", szTemp, nTempLen) > 0)
        {
            szTemp[nTempLen - 1] = 0;
            strcat_s(szSymPath, nSymPathLen, szTemp);
            strcat_s(szSymPath, nSymPathLen, ";");
        }
        if(GetEnvironmentVariableA("_NT_ALTERNATE_SYMBOL_PATH", szTemp, nTempLen) > 0)
        {
            szTemp[nTempLen - 1] = 0;
            strcat_s(szSymPath, nSymPathLen, szTemp);
            strcat_s(szSymPath, nSymPathLen, ";");
        }
        if(GetEnvironmentVariableA("SYSTEMROOT", szTemp, nTempLen) > 0)
        {
            szTemp[nTempLen - 1] = 0;
            strcat_s(szSymPath, nSymPathLen, szTemp);
            strcat_s(szSymPath, nSymPathLen, ";");
            // also add the "system32"-directory:
            strcat_s(szTemp, nTempLen, "\\system32");
            strcat_s(szSymPath, nSymPathLen, szTemp);
            strcat_s(szSymPath, nSymPathLen, ";");
        }

        if((this->m_options & SymUseSymSrv) != 0)
        {
            if(GetEnvironmentVariableA("SYSTEMDRIVE", szTemp, nTempLen) > 0)
            {
                szTemp[nTempLen - 1] = 0;
                strcat_s(szSymPath, nSymPathLen, "SRV*");
                strcat_s(szSymPath, nSymPathLen, szTemp);
                strcat_s(szSymPath, nSymPathLen, "\\websymbols");
                strcat_s(szSymPath, nSymPathLen, "*http://msdl.microsoft.com/download/symbols;");
            }
            else
                strcat_s(szSymPath, nSymPathLen, "SRV*c:\\websymbols*http://msdl.microsoft.com/download/symbols;");
        }
    }  // if SymBuildPath

    this->OnOutput("\n\n**** LIBRARY INFORMATION ****\n");
    // First Init the whole stuff...
    BOOL bRet = this->m_sw->Init(szSymPath);
    if(szSymPath != NULL) free(szSymPath);
    szSymPath = NULL;
    if(bRet == FALSE)
    {
        this->OnDbgHelpErr("Error while initializing dbghelp.dll", 0, 0);
        SetLastError(ERROR_DLL_INIT_FAILED);
        return FALSE;
    }

    bRet = this->m_sw->LoadModules(this->m_hProcess, this->m_dwProcessId);
    this->OnOutput("\n\n**** THE STACKTRACE ****\n");
    if(bRet != FALSE)
        m_modulesLoaded = TRUE;
    return bRet;
}

// The following is used to pass the "userData"-Pointer to the user-provided readMemoryFunction
// This has to be done due to a problem with the "hProcess"-parameter in x64...
// Because this class is in no case multi-threading-enabled (because of the limitations
// of dbghelp.dll) it is "safe" to use a static-variable
static StackWalker::PReadProcessMemoryRoutine s_readMemoryFunction = NULL;
static LPVOID s_readMemoryFunction_UserData = NULL;

BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadProcessMemoryRoutine readMemoryFunction, LPVOID pUserData)
{
    CONTEXT c;
    CallstackEntry csEntry;
    IMAGEHLP_SYMBOL64 *pSym = NULL;
    StackWalkerInternal::IMAGEHLP_MODULE64_V3 Module;
    IMAGEHLP_LINE64 Line;
    int frameNum;
    bool bLastEntryCalled = true;
    int curRecursionCount = 0;

    if(m_modulesLoaded == FALSE)
        this->LoadModules();  // ignore the result...

    if(this->m_sw->m_hDbhHelp == NULL)
    {
        SetLastError(ERROR_DLL_INIT_FAILED);
        return FALSE;
    }

    s_readMemoryFunction = readMemoryFunction;
    s_readMemoryFunction_UserData = pUserData;

    if(context == NULL)
    {
        // If no context is provided, capture the context
        // See: https://stackwalker.codeplex.com/discussions/446958
        //#if _WIN32_WINNT <= 0x0501
        // If we need to support XP, we need to use the "old way", because "GetThreadId" is not available!
        if(hThread == GetCurrentThread())
            //#else
            //    if (GetThreadId_My(hThread) == GetCurrentThreadId())
            //#endif
        {
            GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, USED_CONTEXT_FLAGS);
        }
        else
        {
            SuspendThread(hThread);
            memset(&c, 0, sizeof(CONTEXT));
            c.ContextFlags = USED_CONTEXT_FLAGS;
            if(GetThreadContext(hThread, &c) == FALSE)
            {
                ResumeThread(hThread);
                return FALSE;
            }
        }
    }
    else
        c = *context;

    // init STACKFRAME for first call
    STACKFRAME64 s; // in/out stackframe
    memset(&s, 0, sizeof(s));
    DWORD imageType;
    #ifdef _M_IX86
    // normally, call ImageNtHeader() and use machine info from PE header
    imageType = IMAGE_FILE_MACHINE_I386;
    s.AddrPC.Offset = c.Eip;
    s.AddrPC.Mode = AddrModeFlat;
    s.AddrFrame.Offset = c.Ebp;
    s.AddrFrame.Mode = AddrModeFlat;
    s.AddrStack.Offset = c.Esp;
    s.AddrStack.Mode = AddrModeFlat;
    #elif _M_X64
    imageType = IMAGE_FILE_MACHINE_AMD64;
    s.AddrPC.Offset = c.Rip;
    s.AddrPC.Mode = AddrModeFlat;
    s.AddrFrame.Offset = c.Rsp;
    s.AddrFrame.Mode = AddrModeFlat;
    s.AddrStack.Offset = c.Rsp;
    s.AddrStack.Mode = AddrModeFlat;
    #elif _M_IA64
    imageType = IMAGE_FILE_MACHINE_IA64;
    s.AddrPC.Offset = c.StIIP;
    s.AddrPC.Mode = AddrModeFlat;
    s.AddrFrame.Offset = c.IntSp;
    s.AddrFrame.Mode = AddrModeFlat;
    s.AddrBStore.Offset = c.RsBSP;
    s.AddrBStore.Mode = AddrModeFlat;
    s.AddrStack.Offset = c.IntSp;
    s.AddrStack.Mode = AddrModeFlat;
    #elif _M_ARM64
    imageType = IMAGE_FILE_MACHINE_ARM64;
    s.AddrPC.Offset = c.Pc;
    s.AddrPC.Mode = AddrModeFlat;
    s.AddrFrame.Offset = c.Fp;
    s.AddrFrame.Mode = AddrModeFlat;
    s.AddrStack.Offset = c.Sp;
    s.AddrStack.Mode = AddrModeFlat;
    #else
#error "Platform not supported!"
    #endif

    pSym = (IMAGEHLP_SYMBOL64 *) malloc(sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN);
    if(!pSym) goto cleanup;   // not enough memory...
    memset(pSym, 0, sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN);
    pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
    pSym->MaxNameLength = STACKWALK_MAX_NAMELEN;

    memset(&Line, 0, sizeof(Line));
    Line.SizeOfStruct = sizeof(Line);

    memset(&Module, 0, sizeof(Module));
    Module.SizeOfStruct = sizeof(Module);

    for(frameNum = 0; ; ++frameNum)
    {
        // get next stack frame (StackWalk64(), SymFunctionTableAccess64(), SymGetModuleBase64())
        // if this returns ERROR_INVALID_ADDRESS (487) or ERROR_NOACCESS (998), you can
        // assume that either you are done, or that the stack is so hosed that the next
        // deeper frame could not be found.
        // CONTEXT need not to be suplied if imageTyp is IMAGE_FILE_MACHINE_I386!
        if(! this->m_sw->pSW(imageType, this->m_hProcess, hThread, &s, &c, myReadProcMem, this->m_sw->pSFTA, this->m_sw->pSGMB, NULL))
        {
            // INFO: "StackWalk64" does not set "GetLastError"...
            this->OnDbgHelpErr("StackWalk64", 0, s.AddrPC.Offset);
            break;
        }

        csEntry.offset = s.AddrPC.Offset;
        csEntry.name[0] = 0;
        csEntry.undName[0] = 0;
        csEntry.undFullName[0] = 0;
        csEntry.offsetFromSmybol = 0;
        csEntry.offsetFromLine = 0;
        csEntry.lineFileName[0] = 0;
        csEntry.lineNumber = 0;
        csEntry.loadedImageName[0] = 0;
        csEntry.moduleName[0] = 0;
        if(s.AddrPC.Offset == s.AddrReturn.Offset)
        {
            if((this->m_MaxRecursionCount > 0) && (curRecursionCount > m_MaxRecursionCount))
            {
                this->OnDbgHelpErr("StackWalk64-Endless-Callstack!", 0, s.AddrPC.Offset);
                break;
            }
            curRecursionCount++;
        }
        else
            curRecursionCount = 0;
        if(s.AddrPC.Offset != 0)
        {
            // we seem to have a valid PC
            // show procedure info (SymGetSymFromAddr64())
            if(this->m_sw->pSGSFA(this->m_hProcess, s.AddrPC.Offset, &(csEntry.offsetFromSmybol), pSym) != FALSE)
            {
                MyStrCpy(csEntry.name, STACKWALK_MAX_NAMELEN, pSym->Name);
                // UnDecorateSymbolName()
                this->m_sw->pUDSN(pSym->Name, csEntry.undName, STACKWALK_MAX_NAMELEN, UNDNAME_NAME_ONLY);
                this->m_sw->pUDSN(pSym->Name, csEntry.undFullName, STACKWALK_MAX_NAMELEN, UNDNAME_COMPLETE);
            }
            else
            {
                this->OnDbgHelpErr("SymGetSymFromAddr64", GetLastError(), s.AddrPC.Offset);
            }

            // show line number info, NT5.0-method (SymGetLineFromAddr64())
            if(this->m_sw->pSGLFA != NULL)
            {
                // yes, we have SymGetLineFromAddr64()
                if(this->m_sw->pSGLFA(this->m_hProcess, s.AddrPC.Offset, &(csEntry.offsetFromLine), &Line) != FALSE)
                {
                    csEntry.lineNumber = Line.LineNumber;
                    MyStrCpy(csEntry.lineFileName, STACKWALK_MAX_NAMELEN, Line.FileName);
                }
                else
                {
                    this->OnDbgHelpErr("SymGetLineFromAddr64", GetLastError(), s.AddrPC.Offset);
                }
            } // yes, we have SymGetLineFromAddr64()

            // show module info (SymGetModuleInfo64())
            if(this->m_sw->GetModuleInfo(this->m_hProcess, s.AddrPC.Offset, &Module) != FALSE)
            {
                // got module info OK
                switch(Module.SymType)
                {
                case SymNone:
                    csEntry.symTypeString = "-nosymbols-";
                    break;
                case SymCoff:
                    csEntry.symTypeString = "COFF";
                    break;
                case SymCv:
                    csEntry.symTypeString = "CV";
                    break;
                case SymPdb:
                    csEntry.symTypeString = "PDB";
                    break;
                case SymExport:
                    csEntry.symTypeString = "-exported-";
                    break;
                case SymDeferred:
                    csEntry.symTypeString = "-deferred-";
                    break;
                case SymSym:
                    csEntry.symTypeString = "SYM";
                    break;
                    #if API_VERSION_NUMBER >= 9
                case SymDia:
                    csEntry.symTypeString = "DIA";
                    break;
                    #endif
                case 8: //SymVirtual:
                    csEntry.symTypeString = "Virtual";
                    break;
                default:
                    //_snprintf( ty, sizeof(ty), "symtype=%ld", (long) Module.SymType );
                    csEntry.symTypeString = NULL;
                    break;
                }

                MyStrCpy(csEntry.moduleName, STACKWALK_MAX_NAMELEN, Module.ModuleName);
                csEntry.baseOfImage = Module.BaseOfImage;
                MyStrCpy(csEntry.loadedImageName, STACKWALK_MAX_NAMELEN, Module.LoadedImageName);
            } // got module info OK
            else
            {
                this->OnDbgHelpErr("SymGetModuleInfo64", GetLastError(), s.AddrPC.Offset);
            }
        } // we seem to have a valid PC

        this->OnOutput((std::to_string(frameNum) + std::string(": ")).c_str());

        CallstackEntryType et = nextEntry;
        if(frameNum == 0)
            et = firstEntry;
        bLastEntryCalled = false;
        this->OnCallstackEntry(et, csEntry);

        if(s.AddrReturn.Offset == 0)
        {
            bLastEntryCalled = true;
            this->OnCallstackEntry(lastEntry, csEntry);
            SetLastError(ERROR_SUCCESS);
            break;
        }
    } // for ( frameNum )

cleanup:
    if(pSym) free(pSym);

    if(bLastEntryCalled == false)
        this->OnCallstackEntry(lastEntry, csEntry);

    if(context == NULL)
        ResumeThread(hThread);

    return TRUE;
}

BOOL __stdcall StackWalker::myReadProcMem(
    HANDLE      hProcess,
    DWORD64     qwBaseAddress,
    PVOID       lpBuffer,
    DWORD       nSize,
    LPDWORD     lpNumberOfBytesRead
)
{
    if(s_readMemoryFunction == NULL)
    {
        SIZE_T st;
        BOOL bRet = ReadProcessMemory(hProcess, (LPVOID) qwBaseAddress, lpBuffer, nSize, &st);
        //#pragma warning(suppress: 6102) //API
        *lpNumberOfBytesRead = (DWORD) st;
        //printf("ReadMemory: hProcess: %p, baseAddr: %p, buffer: %p, size: %d, read: %d, result: %d\n", hProcess, (LPVOID) qwBaseAddress, lpBuffer, nSize, (DWORD) st, (DWORD) bRet);
        return bRet;
    }
    else
    {
        return s_readMemoryFunction(hProcess, qwBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead, s_readMemoryFunction_UserData);
    }
}

void StackWalker::OnLoadModule(LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size, DWORD result, LPCSTR symType, LPCSTR pdbName, ULONGLONG fileVersion)
{
    CHAR buffer[STACKWALK_MAX_NAMELEN];
    if(fileVersion == 0)
        sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "%s:%s (%p), size: %ld (result: %ld), SymType: '%s', PDB: '%s'\n", img, mod, (LPVOID) baseAddr, size, result, symType, pdbName);
    else
    {
        DWORD v4 = (DWORD)(fileVersion & 0xFFFF);
        DWORD v3 = (DWORD)((fileVersion >> 16) & 0xFFFF);
        DWORD v2 = (DWORD)((fileVersion >> 32) & 0xFFFF);
        DWORD v1 = (DWORD)((fileVersion >> 48) & 0xFFFF);
        sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "%s:%s (%p), size: %ld (result: %ld), SymType: '%s', PDB: '%s', fileVersion: %ld.%ld.%ld.%ld\n", img, mod, (LPVOID) baseAddr, size, result, symType, pdbName, v1, v2, v3, v4);
    }
    ansi2utf8(buffer, STACKWALK_MAX_NAMELEN);
    OnOutput(buffer);
}

void StackWalker::OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry)
{
    CHAR buffer[STACKWALK_MAX_NAMELEN];
    if((eType != lastEntry) && (entry.offset != 0))
    {
        if(entry.name[0] == 0)
            MyStrCpy(entry.name, STACKWALK_MAX_NAMELEN, "(function-name not available)");
        if(entry.undName[0] != 0)
            MyStrCpy(entry.name, STACKWALK_MAX_NAMELEN, entry.undName);
        if(entry.undFullName[0] != 0)
            MyStrCpy(entry.name, STACKWALK_MAX_NAMELEN, entry.undFullName);
        if(entry.lineFileName[0] == 0)
        {
            MyStrCpy(entry.lineFileName, STACKWALK_MAX_NAMELEN, "(filename not available)");
            if(entry.moduleName[0] == 0)
                MyStrCpy(entry.moduleName, STACKWALK_MAX_NAMELEN, "(module-name not available)");
            sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "%p (%s): %s: %s\n", (LPVOID) entry.offset, entry.moduleName, entry.lineFileName, entry.name);
        }
        else
            sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "%s (%ld): %s\n", entry.lineFileName, entry.lineNumber, entry.name);
        buffer[STACKWALK_MAX_NAMELEN - 1] = 0;
        ansi2utf8(buffer, STACKWALK_MAX_NAMELEN);
        OnOutput(buffer);
    }
}

void StackWalker::OnDbgHelpErr(LPCSTR /*szFuncName*/, DWORD /*gle*/, DWORD64 /*addr*/)
{
    /*
    CHAR buffer[STACKWALK_MAX_NAMELEN];
    sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "ERROR: %s, GetLastError: %d (Address: %p)\n", szFuncName, gle, (LPVOID) addr);
    OnOutput(buffer);
    */
}

void StackWalker::OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName)
{
    char buffer[STACKWALK_MAX_NAMELEN];
    sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "SymInit: Symbol-SearchPath: '%s', symOptions: %ld, UserName: '%s'\n", szSearchPath, symOptions, szUserName);
    ansi2utf8(buffer, STACKWALK_MAX_NAMELEN);
    OnOutput(buffer);

    // Also display the OS-version
#if !defined(_MSC_VER) || _MSC_VER <= 1200
    OSVERSIONINFOA ver;
    ZeroMemory(&ver, sizeof(OSVERSIONINFOA));
    ver.dwOSVersionInfoSize = sizeof(ver);

    if(GetVersionExA(&ver) != FALSE)
    {
        sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "OS-Version: %ld.%ld.%ld (%s)\n",
                  (long)ver.dwMajorVersion,
                  (long)ver.dwMinorVersion,
                  (long)ver.dwBuildNumber,
                  ver.szCSDVersion);
        ansi2utf8(buffer, STACKWALK_MAX_NAMELEN);
        OnOutput(buffer);
    }
#else
    OSVERSIONINFOEXA ver;
    ZeroMemory(&ver, sizeof(OSVERSIONINFOEXA));
    ver.dwOSVersionInfoSize = sizeof(ver);

#pragma warning(suppress: 28159) // API
#pragma warning(suppress: 4996)  // The "GetVersionExA" is deprecated
    if(GetVersionExA((OSVERSIONINFOA *) &ver) != FALSE)
    {
        sprintf_s(buffer, STACKWALK_MAX_NAMELEN, "OS-Version: %u.%u.%u (%s) 0x%x-0x%x\n",
                  (uint32_t)ver.dwMajorVersion,
                  (uint32_t)ver.dwMinorVersion,
                  (uint32_t)ver.dwBuildNumber,
                  ver.szCSDVersion,
                  ver.wSuiteMask,
                  ver.wProductType);
        ansi2utf8(buffer, STACKWALK_MAX_NAMELEN);
        OnOutput(buffer);
    }
#endif
}

void StackWalker::OnOutput(LPCSTR buffer)
{
    OutputDebugStringA(buffer);
}
#endif


================================================
FILE: lib/CrashHandler/StackWalker/StackWalker.h
================================================
#ifdef _WIN32
/**********************************************************************
 *
 * StackWalker.h
 *
 *
 *
 * LICENSE (http://www.opensource.org/licenses/bsd-license.php)
 *
 *   Copyright (c) 2005-2009, Jochen Kalmbach
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without modification,
 *   are permitted provided that the following conditions are met:
 *
 *   Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *   Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *   Neither the name of Jochen Kalmbach nor the names of its contributors may be
 *   used to endorse or promote products derived from this software without
 *   specific prior written permission.
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 *   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * **********************************************************************/
// #pragma once is supported starting with _MCS_VER 1000,
// so we need not to check the version (because we only support _MSC_VER >= 1100)!
#ifndef StackWalker_hhhhh
#define StackWalker_hhhhh
#include <windows.h>
#include <string>

// special defines for VC5/6 (if no actual PSDK is installed):
#if _MSC_VER < 1300
typedef unsigned __int64 DWORD64, *PDWORD64;
#if defined(_WIN64)
typedef unsigned __int64 SIZE_T, *PSIZE_T;
#else
typedef unsigned long SIZE_T, *PSIZE_T;
#endif
#endif  // _MSC_VER < 1300

class StackWalkerInternal;  // forward
class StackWalker
{
public:
    typedef enum StackWalkOptions
    {
        // No addition info will be retrived
        // (only the address is available)
        RetrieveNone = 0,

        // Try to get the symbol-name
        RetrieveSymbol = 1,

        // Try to get the line for this symbol
        RetrieveLine = 2,

        // Try to retrieve the module-infos
        RetrieveModuleInfo = 4,

        // Also retrieve the version for the DLL/EXE
        RetrieveFileVersion = 8,

        // Contains all the abouve
        RetrieveVerbose = 0xF,

        // Generate a "good" symbol-search-path
        SymBuildPath = 0x10,

        // Also use the public Microsoft-Symbol-Server
        SymUseSymSrv = 0x20,

        // Contains all the abouve "Sym"-options
        SymAll = 0x30,

        // Contains all options (default)
        OptionsAll = 0x3F
    } StackWalkOptions;

    StackWalker(
        int options = OptionsAll, // 'int' is by design, to combine the enum-flags
        LPCSTR szSymPath = NULL,
        DWORD dwProcessId = GetCurrentProcessId(),
        HANDLE hProcess = GetCurrentProcess()
    );
    StackWalker(DWORD dwProcessId, HANDLE hProcess);
    virtual ~StackWalker();

    typedef BOOL (__stdcall *PReadProcessMemoryRoutine)(
        HANDLE      hProcess,
        DWORD64     qwBaseAddress,
        PVOID       lpBuffer,
        DWORD       nSize,
        LPDWORD     lpNumberOfBytesRead,
        LPVOID      pUserData  // optional data, which was passed in "ShowCallstack"
    );

    BOOL LoadModules();

    BOOL ShowCallstack(
        HANDLE hThread = GetCurrentThread(),
        const CONTEXT *context = NULL,
        PReadProcessMemoryRoutine readMemoryFunction = NULL,
        LPVOID pUserData = NULL  // optional to identify some data in the 'readMemoryFunction'-callback
    );

    #if _MSC_VER >= 1300
    // due to some reasons, the "STACKWALK_MAX_NAMELEN" must be declared as "public"
    // in older compilers in order to use it... starting with VC7 we can declare it as "protected"
protected:
    #endif
    enum { STACKWALK_MAX_NAMELEN = 1024 }; // max name length for found symbols

protected:
    // Entry for each Callstack-Entry
    typedef struct CallstackEntry
    {
        DWORD64 offset;  // if 0, we have no valid entry
        CHAR name[STACKWALK_MAX_NAMELEN];
        CHAR undName[STACKWALK_MAX_NAMELEN];
        CHAR undFullName[STACKWALK_MAX_NAMELEN];
        DWORD64 offsetFromSmybol;
        DWORD offsetFromLine;
        DWORD lineNumber;
        CHAR lineFileName[STACKWALK_MAX_NAMELEN];
        DWORD symType;
        LPCSTR symTypeString;
        CHAR moduleName[STACKWALK_MAX_NAMELEN];
        DWORD64 baseOfImage;
        CHAR loadedImageName[STACKWALK_MAX_NAMELEN];
    } CallstackEntry;

    enum CallstackEntryType {firstEntry, nextEntry, lastEntry};

    virtual void OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName);
    virtual void OnLoadModule(LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size, DWORD result, LPCSTR symType, LPCSTR pdbName, ULONGLONG fileVersion);
    virtual void OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry);
    virtual void OnDbgHelpErr(LPCSTR szFuncName, DWORD gle, DWORD64 addr);
    virtual void OnOutput(LPCSTR szText);

    StackWalkerInternal *m_sw;
    HANDLE m_hProcess;
    DWORD m_dwProcessId;
    BOOL m_modulesLoaded;
    LPSTR m_szSymPath;

    int m_options;
    int m_MaxRecursionCount;

    static BOOL __stdcall myReadProcMem(HANDLE hProcess, DWORD64 qwBaseAddress, PVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead);

    friend StackWalkerInternal;
};  // class StackWalker


// The "ugly" assembler-implementation is needed for systems before XP
// If you have a new PSDK and you only compile for XP and later, then you can use
// the "RtlCaptureContext"
// Currently there is no define which determines the PSDK-Version...
// So we just use the compiler-version (and assumes that the PSDK is
// the one which was installed by the VS-IDE)

// INFO: If you want, you can use the RtlCaptureContext if you only target XP and later...
//       But I currently use it in x64/IA64 environments...
//#if defined(_M_IX86) && (_WIN32_WINNT <= 0x0500) && (_MSC_VER < 1400)



#if 0
#ifdef CURRENT_THREAD_VIA_EXCEPTION
// TODO: The following is not a "good" implementation,
// because the callstack is only valid in the "__except" block...
#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \
    do { \
        memset(&c, 0, sizeof(CONTEXT)); \
        EXCEPTION_POINTERS *pExp = NULL; \
        __try { \
            throw 0; \
        } __except( ( (pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_EXECUTE_HANDLER)) {} \
        if (pExp != NULL) \
            memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT)); \
        c.ContextFlags = contextFlags; \
    } while(0);
#else
// The following should be enough for walking the callstack...
#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \
    do { \
        memset(&c, 0, sizeof(CONTEXT)); \
        c.ContextFlags = contextFlags; \
        __asm    call x \
        __asm x: pop eax \
        __asm    mov c.Eip, eax \
        __asm    mov c.Ebp, ebp \
        __asm    mov c.Esp, esp \
    } while(0);
#endif

#else

// The following is defined for x86 (XP and higher), x64 and IA64:
#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \
    do { \
        memset(&c, 0, sizeof(CONTEXT)); \
        c.ContextFlags = contextFlags; \
        RtlCaptureContext(&c); \
    } while(0);
#endif


class StackWalkerToString : public StackWalker
{
    std::string *m_out;
public:
    StackWalkerToString(std::string &out) : m_out(&out) {}
protected:
    virtual void OnOutput(LPCSTR szText)
    {
        m_out->append(szText);
    }
};

#endif//StackWalker_hhhhh
#endif//_WIN32


================================================
FILE: lib/CrashHandler/backtrace.h.in
================================================
#cmakedefine01 Backtrace_FOUND
#if Backtrace_FOUND
#include <${Backtrace_HEADER}>
#endif


================================================
FILE: lib/CrashHandler/crash_handler.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef SDL_HEAD_HHHHHH
#   include "sdl_proxy/sdl_head.h"
#endif
#ifndef SDL_SDL_ASSERT_H
#   include "sdl_proxy/sdl_assert.h"
#endif

#if !defined(__16M__) && !defined(__WII__) && !defined(__3DS__) && !defined(__SWITCH__) && !defined(VITA)
#   define PGE_ENABLE_SIGNAL_HOOKS
#endif

#ifndef THEXTECH_NO_SDL_BUILD
#   include <SDL2/SDL_version.h>
#   if !defined(THEXTECH_CLI_BUILD) && !defined(CUSTOM_AUDIO)
#       include <SDL2/SDL_mixer_ext.h>
#   endif
#endif

#include <exception>
#include <cstdlib>
#include <signal.h>

#include <lib/CrashHandler/backtrace.h>

#if defined(DEBUG_BUILD) && (Backtrace_FOUND || defined(_WIN32))
#   define PGE_ENGINE_DEBUG
#endif

#ifdef PGE_ENGINE_DEBUG

#ifdef __gnu_linux__
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#endif

#ifdef __APPLE__
#include <stdbool.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/sysctl.h>
#endif

#ifdef _WIN32
#include <windows.h>
#endif

#endif //PGE_ENGINE_DEBUG

// Exclude platforms that don't have SIG_INFO support
#if    !defined(_WIN32) \
    && !defined(__16M__) \
    && !defined(__3DS__) \
    && !defined(__WII__) \
    && !defined(__WIIU__) \
    && !defined(__SWITCH__) \
    && !defined(VITA)
#   define HAS_SIG_INFO
#endif

// Exclude personal data removal from platforms where API doesn't allows to recognise the user and/or home directory
#if    !defined(VITA) \
    && !defined(__16M__) \
    && !defined(__3DS__) \
    && !defined(__WII__) \
    && !defined(__WIIU__)  \
    && !defined(__SWITCH__) \
    && !defined(__EMSCRIPTEN__) \
    && !defined(__ANDROID__) \
    && !defined(__HAIKU__)
#   define DO_REMOVE_PERSONAL_DATA
#endif


#ifdef PGE_ENGINE_DEBUG
static int isDebuggerPresent()
{
#if defined(__gnu_linux__)
    const size_t buf_size = 2048;
    char buf[buf_size];
    int debugger_present = 0;

    int status_fd = open("/proc/self/status", O_RDONLY);
    if(status_fd == -1)
        return 0;

    ssize_t num_read = read(status_fd, buf, buf_size);

    if(num_read > 0)
    {
        static const char TracerPid[] = "TracerPid:";
        char *tracer_pid;

        if(num_read < (ssize_t)buf_size)
            buf[num_read] = 0;
        else
            buf[buf_size - 1] = 0;
        tracer_pid    = strstr(buf, TracerPid);
        if(tracer_pid)
            debugger_present = static_cast<bool>(SDL_atoi(tracer_pid + sizeof(TracerPid) - 1));
    }
    return debugger_present;

#elif defined(__APPLE__)
    // https://stackoverflow.com/a/2200786/5618998
    int                 junk;
    int                 mib[4];
    struct kinfo_proc   info;
    size_t              size;

    // Initialize the flags so that, if sysctl fails for some bizarre
    // reason, we get a predictable result.

    info.kp_proc.p_flag = 0;

    // Initialize mib, which tells sysctl the info we want, in this case
    // we're looking for information about a specific process ID.

    mib[0] = CTL_KERN;
    mib[1] = KERN_PROC;
    mib[2] = KERN_PROC_PID;
    mib[3] = getpid();

    // Call sysctl.

    size = sizeof(info);
    junk = sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0);
    SDL_assert(junk == 0);

    // We're being debugged if the P_TRACED flag is set.

    return ( (info.kp_proc.p_flag & P_TRACED) != 0 );

#elif defined(_WIN32)
    return IsDebuggerPresent();

#else
    return 0; // Unknown platform
#endif
}
#endif

#ifdef _WIN32
#   include <windows.h>
#   include <dbghelp.h>
#   include <shlobj.h>
#elif (defined(__linux__) && !defined(__ANDROID__) || defined(__APPLE__))
#   include <pwd.h>
#   include <unistd.h>
#elif defined(__ANDROID__)
#   include <unwind.h>
#   include <dlfcn.h>
#   include <sstream>
#   include <iomanip>
#endif

#include "crash_handler.h"
#include "../Logger/logger.h"

#include "../../version.h"
#include "core/msgbox.h"

#define STACK_FORMAT    \
    "====Stack trace====" OS_NEWLINE \
    "%s" OS_NEWLINE \
    "===================" OS_NEWLINE \
    "%s"

#define STR_EXPAND(tok) #tok
#define STRR(tok) STR_EXPAND(tok)

static const char *g_messageToUser =
    "================================================" OS_NEWLINE
    "            Additional information:" OS_NEWLINE
    "================================================" OS_NEWLINE
    V_FILE_DESC "\n"
    "- Version:           " V_FILE_VERSION V_FILE_RELEASE OS_NEWLINE
    "- Architecture:      " FILE_CPU OS_NEWLINE
    "- Operating system:  " OPERATION_SYSTEM OS_NEWLINE
    "- GIT Revision code: #" V_BUILD_VER OS_NEWLINE
    "- GIT branch:        " V_BUILD_BRANCH OS_NEWLINE
#ifndef DISABLE_XTECH_BUILD_DATE
    "- Build date:        " V_DATE_OF_BUILD OS_NEWLINE
#endif
    "================================================" OS_NEWLINE
#ifndef THEXTECH_NO_SDL_BUILD
    "SDL2 version:        " STRR(SDL_MAJOR_VERSION) "." STRR(SDL_MINOR_VERSION) "." STRR(SDL_PATCHLEVEL) OS_NEWLINE
#endif
#if !defined(THEXTECH_NO_SDL_BUILD) && !defined(THEXTECH_CLI_BUILD) && !defined(CUSTOM_AUDIO)
    "SDL Mixer X version: " STRR(SDL_MIXER_MAJOR_VERSION) "." STRR(SDL_MIXER_MINOR_VERSION) "." STRR(SDL_MIXER_PATCHLEVEL) OS_NEWLINE
#endif
    "================================================" OS_NEWLINE
    " Please send this log file to the developers by one of ways:" OS_NEWLINE
    " - Via contact form:          https://wohlsoft.ru/contacts/" OS_NEWLINE
    " - Official forums:           https://wohlsoft.ru/forum/" OS_NEWLINE
    " - Official Discord server:   https://wohlsoft.ru/chat/" OS_NEWLINE
    " - Make issue at GitHub repo: https://github.com/Wohlstand/TheXTech" OS_NEWLINE OS_NEWLINE
    "================================================" OS_NEWLINE;

#ifdef _WIN32
//
// http://blog.aaronballman.com/2011/04/generating-a-stack-crawl/
//
static bool GetStackWalk(std::string &outWalk)
{
    // Set up the symbol options so that we can gather information from the current
    // executable's PDB files, as well as the Microsoft symbol servers.  We also want
    // to undecorate the symbol names we're returned.  If you want, you can add other
    // symbol servers or paths via a semi-colon separated list in SymInitialized.
    ::SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_INCLUDE_32BIT_MODULES | SYMOPT_UNDNAME);

    if(!::SymInitialize(::GetCurrentProcess(), "http://msdl.microsoft.com/download/symbols", TRUE)) return false;

    // Capture up to 25 stack frames from the current call stack.  We're going to
    // skip the first stack frame returned because that's the GetStackWalk function
    // itself, which we don't care about.
    PVOID addrs[ 400 ] = { 0 };
    USHORT frames = CaptureStackBackTrace(1, 400, addrs, nullptr);

    for(USHORT i = 0; i < frames; i++)
    {
        // Allocate a buffer large enough to hold the symbol information on the stack and get
        // a pointer to the buffer.  We also have to set the size of the symbol structure itself
        // and the number of bytes reserved for the name.
        ULONG64 buffer[(sizeof(SYMBOL_INFO) + 1024 + sizeof(ULONG64) - 1) / sizeof(ULONG64) ] = { 0 };
        SYMBOL_INFO *info = (SYMBOL_INFO *)buffer;
        info->SizeOfStruct = sizeof(SYMBOL_INFO);
        info->MaxNameLen = 1024;
        // Attempt to get information about the symbol and add it to our output parameter.
        DWORD64 displacement = 0;

        if(::SymFromAddr(::GetCurrentProcess(), (DWORD64)addrs[ i ], &displacement, info))
        {
            outWalk.append(info->Name, info->NameLen);
            outWalk.append(OS_NEWLINE);
        }
    }

    ::SymCleanup(::GetCurrentProcess());
    return true;
}
#endif

#ifdef __ANDROID__
namespace AndroidStackTrace
{
struct BacktraceState
{
    void **current;
    void **end;
};

static _Unwind_Reason_Code unwindCallback(struct _Unwind_Context *context, void *arg)
{
    BacktraceState *state = static_cast<BacktraceState *>(arg);
    uintptr_t pc = _Unwind_GetIP(context);
    if(pc)
    {
        if(state->current == state->end)
            return _URC_END_OF_STACK;
        else
            *state->current++ = reinterpret_cast<void *>(pc);
    }
    return _URC_NO_REASON;
}

}

static size_t captureBacktrace(void **buffer, size_t max)
{
    AndroidStackTrace::BacktraceState state = {buffer, buffer + max};
    _Unwind_Backtrace(AndroidStackTrace::unwindCallback, &state);

    return state.current - buffer;
}

static void androidDumpBacktrace(std::ostringstream &os, void **buffer, size_t count)
{
    for(size_t idx = 0; idx < count; ++idx)
    {
        const void *addr = buffer[idx];
        const char *symbol = "";

        Dl_info info;
        if(dladdr(addr, &info) && info.dli_sname)
            symbol = info.dli_sname;

        os << "  #" << std::setw(2) << idx << ": " << addr << "  " << symbol << "\n";
    }
}
#endif

#ifdef DO_REMOVE_PERSONAL_DATA
static std::string getCurrentUserName()
{
    std::string user;

#if defined(_WIN32)
#   if defined(THEXTECH_WINRT)
    user = "UnknownUser";  // FIXME: Implement for WinRT
#   else
    char    userName[256];
    wchar_t userNameW[256];
    DWORD usernameLen = 256;
    GetUserNameW(userNameW, &usernameLen);
    userNameW[usernameLen--] = L'\0';
    size_t nCnt = WideCharToMultiByte(CP_UTF8, 0, userNameW, usernameLen, userName, 256, 0, 0);
    userName[nCnt] = '\0';
    user = std::string(userName);
#   endif
#else
    struct passwd *pwd = getpwuid(getuid());
    if(pwd == nullptr)
        return "UnknownUser"; // Failed to get a user name!
    user = std::string(pwd->pw_name);
#endif

    return user;
}

static std::string getCurrentHomePath()
{
    std::string homedir;

#ifdef _WIN32
#   if defined(THEXTECH_WINRT)
    homedir = "C:\\Users\\<unknown>"; // FIXME: Implement for WinRT
#   else
    char    homeDir[MAX_PATH * 4];
    wchar_t homeDirW[MAX_PATH];
    SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, homeDirW);
    size_t nCnt = WideCharToMultiByte(CP_UTF8, 0, homeDirW, -1, homeDir, MAX_PATH * 4, 0, 0);
    homeDir[nCnt] = '\0';
    homedir = std::string(homeDir);
#   endif
#elif defined(__HAIKU__)
    {
        const char *home = SDL_getenv("HOME");
        if(home == nullptr)
            return "/home/<unknown>"; // Failed to get a user name!
        homedir = std::string(home);
    }
#else
    struct passwd *pwd = getpwuid(getuid());
    if(pwd == nullptr)
        return "/home/<unknown>"; // Failed to get a user name!
    homedir = std::string(pwd->pw_dir);

#endif

    return homedir;
}

static void replaceStr(std::string &data, const std::string &toSearch, const std::string &replaceStr)
{
    size_t pos = data.find(toSearch);

    while(pos != std::string::npos)
    {
        data.replace(pos, toSearch.size(), replaceStr);
        pos = data.find(toSearch, pos + replaceStr.size());
    }
}

static void removePersonalData(std::string &log)
{
    std::string user = getCurrentUserName();
    std::string homePath = getCurrentHomePath();

    // Replace username
    if(!homePath.empty())
    {
        replaceStr(log, homePath, "{...}");
#ifdef _WIN32
        replaceStr(homePath, "\\", "/");
        replaceStr(log, homePath, "{...}");
#endif
    }

    replaceStr(log, user, "anonymouse");
}

#endif // DO_REMOVE_PERSONAL_DATA

#if defined(__WII__) || defined(__WIIU__)
#   define USE_PPC_BACKTRACE
int ppc_backtrace(void **buffer, int size)
{
    int depth;
    uint32_t stackptr = 0, lr, *addr;

    pLogDebug("Stack trace: PPC: Get link register...");

    // get link register
    asm volatile ("mflr %0" : "=r"(lr));

    // link register is assigned to depth[0]
    buffer[0] = (void *) (lr - 4);

    pLogDebug("Stack trace: PPC: Get link stack pointer...");

    // get stackpointer
    asm volatile("stw %%sp, 0(%0)" : : "b" ((uint32_t)&stackptr));

    pLogDebug("Stack trace: PPC: Assign...");

    // assign stack ptr to address
    addr = reinterpret_cast<uint32_t *>(stackptr);

    // get the frames
    if (*addr)
    {
        // skip first two frames because this function
        // does create a stackframe but doesn't set lr on
        // the previous one.
        addr = (uint32_t *)*addr;
        if (*addr)
            addr = (uint32_t *)*addr;

    }

    D_pLogDebugNA("Stack trace: PPC: Loop...");

    for(depth = 1; (depth < size && *addr); ++depth)
    {
        uint32_t * next = (uint32_t *) *addr;
        buffer[depth] = (void *) (*(addr + 1) - 4);
        addr = next;
    }

    D_pLogDebugNA("Stack trace: PPC: Return...");

    return depth;
}
#endif

static std::string getStacktrace()
{
    D_pLogDebugNA("Stack trace: Initializing std::string...");
    std::string bkTrace;
    D_pLogDebugNA("Stack trace: String done...");

#if defined(_WIN32)
    GetStackWalk(bkTrace);

#elif defined(USE_PPC_BACKTRACE)

    D_pLogDebugNA("Stack trace: Static arrays...");
    void  *array[400];
    char stack_entry[25];
    int size;
    D_pLogDebugNA("Stack trace: Done...");

    D_pLogDebugNA("Stack trace: Requesting backtrace...");
    size = ppc_backtrace(array, 400);

    D_pLogDebugNA("Stack trace: Filling std::string...");
    for(int j = 0; j < size; j++)
    {
        SDL_snprintf(stack_entry, 25, "- 0x%08x\n", (uint32_t)array[j]);
        bkTrace.append(stack_entry);
    }

    D_pLogDebugNA("Stack trace: DONE!");

#elif Backtrace_FOUND
    void  *array[400];
    int size;
    char **strings;

    D_pLogDebugNA("Requesting backtrace...");
    size = backtrace(array, 400);
    D_pLogDebugNA("Converting...");
    strings = backtrace_symbols(array, size);
    D_pLogDebugNA("Filling std::string...");

    for(int j = 0; j < size; j++)
    {
        bkTrace.append(strings[j]);
        bkTrace.push_back('\n');
    }

    D_pLogDebugNA("DONE!");

#elif defined(__ANDROID__)
    const size_t max = 400;
    void *buffer[max];
    std::ostringstream oss;
    androidDumpBacktrace(oss, buffer, captureBacktrace(buffer, max));
    D_pLogDebugNA("DONE!");
    bkTrace = oss.str();

#else
    bkTrace = "<Stack trace not supported for this platform!>";
#endif

#ifdef DO_REMOVE_PERSONAL_DATA
    removePersonalData(bkTrace);
#endif // DO_REMOVE_PERSONAL_DATA

    return bkTrace;
}


#ifdef __GNUC__
#   define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
#elif defined(_MSC_VER)
#   define LLVM_ATTRIBUTE_NORETURN //__declspec(noreturn)
#else
#   define LLVM_ATTRIBUTE_NORETURN
#endif

static LLVM_ATTRIBUTE_NORETURN void abortEngine(int sig)
{
    CloseLog();
    signal(SIGABRT, SIG_DFL);
#ifndef THEXTECH_NO_SDL_BUILD
    SDL_Quit();
#endif
    exit(sig);
}

static CrashHandler::MsgBoxHook_t g_msgBoxHook = &XMsgBox::errorMsgBox;

void CrashHandler::setCrashMsgBoxHook(MsgBoxHook_t hook)
{
    g_msgBoxHook = hook;
}

void LLVM_ATTRIBUTE_NORETURN CrashHandler::crashByUnhandledException()
{
    std::string stack = getStacktrace();
    std::string exc;
    std::string exc_line;

    try
    {
        std::rethrow_exception(std::current_exception());
    }
    catch(const std::exception &e)
    {
        exc_line = e.what();
        exc.append(" caught an unhandled exception. [");
        exc.append(exc_line);
        exc.append("]");
    }
    catch(...)
    {
        exc_line = "<unknown>";
        exc.append(" caught unhandled exception. (unknown) ");
    }

    pLogFatal("<Unhandled exception! %s>" OS_NEWLINE
              STACK_FORMAT, exc.c_str(),
              stack.c_str(), g_messageToUser);
    g_msgBoxHook(
        "Unhandled exception!",
        "The engine has crashed because of an unhandled exception!" OS_NEWLINE OS_NEWLINE
        "--Exception message:----" OS_NEWLINE +
        exc_line + OS_NEWLINE
        "------------------------"
    );
    abortEngine(-1);
}

void LLVM_ATTRIBUTE_NORETURN CrashHandler::crashByFlood()
{
    std::string stack = getStacktrace();
    pLogFatal("<Out of memory!>" OS_NEWLINE
              STACK_FORMAT,
              stack.c_str(), g_messageToUser);
    g_msgBoxHook(
        "Out of memory!",
        "Engine has crashed because out of memory! Try to close other applications and restart game.");
    abortEngine(-2);
}

#if defined(PGE_ENABLE_SIGNAL_HOOKS)
#if defined(_WIN32) // Unsupported signals by Windows
struct siginfo_t;
#endif

static void handle_signal(int signal, siginfo_t *siginfo, void * /*context*/)
{
#if !defined(_WIN32) || !defined(__SWITCH__)  // Unsupported signals by Windows and Switch
    (void)siginfo;
#endif

    // Find out which signal we're handling
    switch(signal)
    {
#ifndef _WIN32  //Unsupported signals by Windows

    case SIGHUP:
        pLogWarning("Terminal was closed");
        abortEngine(signal);

    case SIGQUIT:
        pLogWarning("<Quit command>");
        abortEngine(signal);

    case SIGKILL:
        pLogFatal("<killed>");
        abortEngine(signal);

    case SIGALRM:
    {
        pLogFatal("<alarm() time out!>");
        g_msgBoxHook(
            "Time out!",
            "Engine has abourted because alarm() time out!");
        abortEngine(signal);
    }

    case SIGBUS:
    {
        std::string stack = getStacktrace();

#   if defined(HAS_SIG_INFO)
        if(siginfo)
        {
            switch(siginfo->si_code)
            {
            case BUS_ADRALN:
                pLogFatal("<Physical memory address error: wrong address alignment>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            case BUS_ADRERR:
                pLogFatal("<Physical memory address error: physical address is not exists>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            case BUS_OBJERR:
                pLogFatal("<Physical memory address error: object specific hardware error>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            default:
                pLogFatal("<Physical memory address error>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
            }
        }
        else
#   endif // HAS_SIG_INFO
        {
            pLogFatal("<Physical memory address error>\n"
                      STACK_FORMAT,
                      stack.c_str(), g_messageToUser);
        }

        g_msgBoxHook(
            "Physical memory address error!",
            "Engine has crashed because a physical memory address error");
        abortEngine(signal);
    }

    case SIGURG:
    case SIGUSR1:
    case SIGUSR2:
        break;

    case SIGILL:
    {
        std::string stack = getStacktrace();
        pLogFatal("<Wrong CPU Instruction>\n"
                  STACK_FORMAT,
                  stack.c_str(), g_messageToUser);
        g_msgBoxHook(
            "Wrong CPU Instruction!",
            "Engine has crashed because a wrong CPU instruction");
        abortEngine(signal);
    }

#endif // NOT _WIN32

    case SIGFPE:
    {
        std::string stack = getStacktrace();

#if defined(HAS_SIG_INFO)  //Unsupported signals by Windows and Switch
        if(siginfo)
        {
            switch(siginfo->si_code)
            {
            case FPE_INTDIV:
                pLogFatal("<wrong arithmetical operation: division of integer number by zero>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            case FPE_FLTDIV:
                pLogFatal("<wrong arithmetical operation: division of floating point number by zero>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            case FPE_INTOVF:
                pLogFatal("<wrong arithmetical operation: integer number max bits size overflot>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            case FPE_FLTOVF:
                pLogFatal("<wrong arithmetical operation: floating point number max bits size overflot>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            default:
                pLogFatal("<wrong arithmetical operation>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
            }
        }
        else
#endif // HAS_SIG_INFO
        {
            pLogFatal("<wrong arithmetical operation>" OS_NEWLINE
                      STACK_FORMAT,
                      stack.c_str(), g_messageToUser);
        }

        g_msgBoxHook(
            "Wrong arithmetical operation",
            "Engine has crashed because of a wrong arithmetical operation!");
        abortEngine(signal);
    }

    case SIGABRT:
    {
        std::string stack = getStacktrace();
        pLogFatal("<Aborted!>" OS_NEWLINE
                  STACK_FORMAT,
                  stack.c_str(), g_messageToUser);
        g_msgBoxHook(
            "Aborted",
            "Engine has been aborted because critical error was occouped.");
        abortEngine(signal);
    }

    case SIGSEGV:
    {
        D_pLogDebugNA(OS_NEWLINE "===========================================================" OS_NEWLINE
                      "Attempt to take a backtrace..."
                      "(if log ends before \"DONE\" will be shown, seems also trouble in the backtracing function too...)");
        std::string stack = getStacktrace();

#if defined(HAS_SIG_INFO)  //Unsupported signals by Windows
        if(siginfo)
        {
            switch(siginfo->si_code)
            {
            case SEGV_MAPERR:
                pLogFatal("<Segmentation fault crash!: Address is not pointing to object!!!>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            case SEGV_ACCERR:
                pLogFatal("<Segmentation fault crash!: Wrong access rights for address!!!>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;

            default:
                pLogFatal("<Segmentation fault crash!>\n"
                          STACK_FORMAT,
                          stack.c_str(), g_messageToUser);
                break;
            }
        }
        else
#endif // HAS_SIG_INFO
        {
            pLogFatal("<Segmentation fault crash!>" OS_NEWLINE
                      STACK_FORMAT,
                      stack.c_str(), g_messageToUser);
        }

        g_msgBoxHook(
            "Segmentation fault",
            "Engine has crashed because of a Segmentation fault.\n"
            "Run debugging with a built in debug mode application\n"
            "and retry your recent actions to get more detailed information.");
        abortEngine(signal);
    }

    case SIGINT:
    {
        pLogFatal("<Interrupted!>");
        g_msgBoxHook(
            "Interrupt",
            "Engine has been interrupted");
        abortEngine(signal);
    }

    default:
        return;
    }
}
#endif // defined(PGE_ENABLE_SIGNAL_HOOKS)

#ifndef THEXTECH_NO_SDL_BUILD
static SDL_AssertState custom_sdl_handler(const SDL_AssertData *data, void *userdata)
{
    CrashHandler::logAssertInfo(data);
    return SDL_GetDefaultAssertionHandler()(data, userdata);
}

void CrashHandler::logAssertInfo(const void* data_p)
{
    const SDL_AssertData *data = reinterpret_cast<const SDL_AssertData*>(data_p);
    CrashHandler::logAssertInfo(data->condition, data->filename, data->function, data->linenum);
}
#endif // #ifndef THEXTECH_NO_SDL_BUILD

void CrashHandler::logAssertInfo(const char *condition, const char *file, const char *func, int line_number)
{
    std::string stack = getStacktrace();
    pLogFatal("<Assertion condition has failed>:" OS_NEWLINE
              "---------------------------------------------------------" OS_NEWLINE
              "File: %s(%d)" OS_NEWLINE
              "Function: %s" OS_NEWLINE
              "Condition: %s" OS_NEWLINE
              "---------------------------------------------------------" OS_NEWLINE
              STACK_FORMAT,
              file, line_number,
              func,
              condition,
              stack.c_str(),
              g_messageToUser);

    // Finalize logger
    CloseLog();
}

#if defined(HAS_SIG_INFO)
static struct sigaction act;
#elif defined(PGE_ENABLE_SIGNAL_HOOKS)
#   if _WIN32
struct siginfo_t;
#   endif

static void handle_signalWIN32(int signal)
{
    handle_signal(signal, nullptr, nullptr);
}
#endif


void CrashHandler::initSigs()
{
#ifdef PGE_ENGINE_DEBUG
    if(isDebuggerPresent())
        return; // Don't initialize crash handlers on attached debugger
#endif

#ifndef THEXTECH_NO_SDL_BUILD
    SDL_SetAssertionHandler(&custom_sdl_handler, NULL);
#endif

    std::set_new_handler(&crashByFlood);
    std::set_terminate(&crashByUnhandledException);
#if defined(HAS_SIG_INFO) && defined(PGE_ENABLE_SIGNAL_HOOKS) // Unsupported signals by Windows
    memset(&act, 0, sizeof(struct sigaction));
    sigemptyset(&act.sa_mask);
    act.sa_sigaction = handle_signal;
    act.sa_flags = SA_SIGINFO;
    sigaction(SIGHUP,  &act, nullptr);
    sigaction(SIGQUIT, &act, nullptr);
    //sigaction(SIGKILL, &act, nullptr); This signal is unhandlable
    sigaction(SIGALRM, &act, nullptr);
    sigaction(SIGURG,  &act, nullptr);
    sigaction(SIGUSR1, &act, nullptr);
    sigaction(SIGUSR2, &act, nullptr);
    sigaction(SIGBUS,  &act, nullptr);
    sigaction(SIGILL,  &act, nullptr);
    sigaction(SIGFPE,  &act, nullptr);
    sigaction(SIGSEGV, &act, nullptr);
    sigaction(SIGINT,  &act, nullptr);
    sigaction(SIGABRT, &act, nullptr);
#elif defined(PGE_ENABLE_SIGNAL_HOOKS) // HAS_SIG_INFO
    signal(SIGILL,  &handle_signalWIN32);
    signal(SIGFPE,  &handle_signalWIN32);
    signal(SIGSEGV, &handle_signalWIN32);
    signal(SIGINT,  &handle_signalWIN32);
    signal(SIGABRT, &handle_signalWIN32);
#   ifndef _WIN32
    signal(SIGHUP, &handle_signalWIN32);
    signal(SIGQUIT, &handle_signalWIN32);
    signal(SIGALRM, &handle_signalWIN32);
    signal(SIGBUS, &handle_signalWIN32);
    signal(SIGURG, &handle_signalWIN32);
#   endif
#endif // HAS_SIG_INFO
}

/* Signals End */


================================================
FILE: lib/CrashHandler/crash_handler.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef CRASHHANDLER_H
#define CRASHHANDLER_H

#include <string>

class CrashHandler
{
public:
    CrashHandler() = default;
    typedef void (*MsgBoxHook_t)(const std::string &title, const std::string &message);
    static void setCrashMsgBoxHook(MsgBoxHook_t hook);
    static void crashByUnhandledException();
    static void crashByFlood();
    static void initSigs();
#ifndef THEXTECH_NO_SDL_BUILD
    static void logAssertInfo(const void *data);
#endif
    static void logAssertInfo(const char *condition, const char *file, const char *func, int line_number);
};

#endif // CRASHHANDLER_H


================================================
FILE: lib/FixPointCS/Fixed64.h
================================================
//
// FixPointCS
//
// Copyright(c) Jere Sanisalo, Petri Kero
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY INT64_C(C)AIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER INT64_C(DEA)INGS IN THE
// SOFTWARE.
//

//
// GENERATED FILE!!!
//
// Generated from Fixed64.cs, part of the FixPointCS project (MIT license).
//
#pragma once
#ifndef __FIXED64_H
#define __FIXED64_H

// Include numeric types
#include <stdint.h>
#include "FixedUtil.h"


// If FP_ASSERT is not custom-defined, then use the standard one
#ifndef FP_ASSERT
#   define FP_ASSERT(x) (void)(x)
#endif

// If FP_CUSTOM_INVALID_ARGS is defined, then the used is expected to implement the following functions in
// the FixedUtil namespace:
//  void InvalidArgument(const char* funcName, const char* argName, FP_INT argValue);
//  void InvalidArgument(const char* funcName, const char* argName, FP_INT argValue1, FP_INT argValue2);
//	void InvalidArgument(const char* funcName, const char* argName, FP_LONG argValue);
//	void InvalidArgument(const char* funcName, const char* argName, FP_LONG argValue1, FP_LONG argValue2);
// These functions should handle the cases for invalid arguments in any desired way (assert, exception, log, ignore etc).
//#define FP_CUSTOM_INVALID_ARGS

namespace Fixed64
{
    typedef int32_t FP_INT;
    typedef uint32_t FP_UINT;
    typedef int64_t FP_LONG;
    typedef uint64_t FP_ULONG;

    static_assert(sizeof(FP_INT) == 4, "Wrong bytesize for FP_INT");
    static_assert(sizeof(FP_UINT) == 4, "Wrong bytesize for FP_UINT");
    static_assert(sizeof(FP_LONG) == 8, "Wrong bytesize for FP_LONG");
    static_assert(sizeof(FP_ULONG) == 8, "Wrong bytesize for FP_ULONG");



    const FP_INT Shift = 32;
    const FP_LONG FractionMask = ( INT64_C(1) << Shift ) - 1; // Space before INT64_C(1) needed because of hacky C++ code generator
    const FP_LONG IntegerMask = ~FractionMask;

    // Constants
    const FP_LONG Zero = INT64_C(0);
    const FP_LONG Neg1 = -(INT64_C(1) << Shift);
    const FP_LONG One = INT64_C(1) << Shift;
    const FP_LONG Two = INT64_C(2) << Shift;
    const FP_LONG Three = INT64_C(3) << Shift;
    const FP_LONG Four = INT64_C(4) << Shift;
    const FP_LONG Half = One >> 1;
    const FP_LONG Pi = INT64_C(13493037705); //(FP_LONG)(Math.PI * 65536.0) << 16;
    const FP_LONG Pi2 = INT64_C(26986075409);
    const FP_LONG PiHalf = INT64_C(6746518852);
    const FP_LONG E = INT64_C(11674931555);

    const FP_LONG MinValue = INT64_MIN;
    const FP_LONG MaxValue = INT64_MAX;

    // Private constants
    const FP_LONG RCP_LN2      = INT64_C(0x171547652); // 1.0 / log(2.0) ~= 1.4426950408889634
    const FP_LONG RCP_LOG2_E   = INT64_C(2977044471);  // 1.0 / log2(e) ~= 0.6931471805599453
    const FP_INT  RCP_HALF_PI  = 683565276; // 1.0 / (4.0 * 0.5 * Math.PI);  // the 4.0 factor converts directly to s2.30

    /// <summary>
    /// Converts an integer to a fixed-point value.
    /// </summary>
    FP_LONG FromInt(FP_INT v)
    {
        return (FP_LONG)v << Shift;
    }

    /// <summary>
    /// Converts a double to a fixed-point value.
    /// </summary>
    FP_LONG FromDouble(double v)
    {
        return (FP_LONG)(v * 4294967296.0);
    }

    /// <summary>
    /// Converts a float to a fixed-point value.
    /// </summary>
    FP_LONG FromFloat(float v)
    {
        return (FP_LONG)(v * 4294967296.0f);
    }

    /// <summary>
    /// Converts a fixed-point value into an integer by rounding it up to nearest integer.
    /// </summary>
    FP_INT CeilToInt(FP_LONG v)
    {
        return (FP_INT)((v + (One - 1)) >> Shift);
    }

    /// <summary>
    /// Converts a fixed-point value into an integer by rounding it down to nearest integer.
    /// </summary>
    FP_INT FloorToInt(FP_LONG v)
    {
        return (FP_INT)(v >> Shift);
    }

    /// <summary>
    /// Converts a fixed-point value into an integer by rounding it to nearest integer.
    /// </summary>
    FP_INT RoundToInt(FP_LONG v)
    {
        return (FP_INT)((v + Half) >> Shift);
    }

    /// <summary>
    /// Converts a fixed-point value into a double.
    /// </summary>
    double ToDouble(FP_LONG v)
    {
        return (double)v * (1.0 / 4294967296.0);
    }

    /// <summary>
    /// Converts a FP value into a float.
    /// </summary>
    float ToFloat(FP_LONG v)
    {
        return (float)v * (1.0f / 4294967296.0f);
    }

    /// <summary>
    /// Converts the value to a human readable string.
    /// </summary>

    /// <summary>
    /// Returns the absolute (positive) value of x.
    /// </summary>
    FP_LONG Abs(FP_LONG x)
    {
        // \note fails with LONG_MIN
        FP_LONG mask = x >> 63;
        return (x + mask) ^ mask;
    }

    /// <summary>
    /// Negative absolute value (returns -abs(x)).
    /// </summary>
    FP_LONG Nabs(FP_LONG x)
    {
        return -Abs(x);
    }

    /// <summary>
    /// Round up to nearest integer.
    /// </summary>
    FP_LONG Ceil(FP_LONG x)
    {
        return (x + FractionMask) & IntegerMask;
    }

    /// <summary>
    /// Round down to nearest integer.
    /// </summary>
    FP_LONG Floor(FP_LONG x)
    {
        return x & IntegerMask;
    }

    /// <summary>
    /// Round to nearest integer.
    /// </summary>
    FP_LONG Round(FP_LONG x)
    {
        return (x + Half) & IntegerMask;
    }

    /// <summary>
    /// Returns the fractional part of x. Equal to 'x - floor(x)'.
    /// </summary>
    FP_LONG Fract(FP_LONG x)
    {
        return x & FractionMask;
    }

    /// <summary>
    /// Returns the minimum of the two values.
    /// </summary>
    FP_LONG Min(FP_LONG a, FP_LONG b)
    {
        return (a < b) ? a : b;
    }

    /// <summary>
    /// Returns the maximum of the two values.
    /// </summary>
    FP_LONG Max(FP_LONG a, FP_LONG b)
    {
        return (a > b) ? a : b;
    }

    /// <summary>
    /// Returns the value clamped between min and max.
    /// </summary>
    FP_LONG Clamp(FP_LONG a, FP_LONG min, FP_LONG max)
    {
        return (a > max) ? max : (a < min) ? min : a;
    }

    /// <summary>
    /// Returns the sign of the value (-1 if negative, 0 if zero, 1 if positive).
    /// </summary>
    FP_INT Sign(FP_LONG x)
    {
        // https://stackoverflow.com/questions/14579920/fast-sign-of-integer-in-c/14612418#14612418
        return (FP_INT)((x >> 63) | (FP_LONG)(((FP_ULONG)-x) >> 63));
    }

    /// <summary>
    /// Adds the two FP numbers together.
    /// </summary>
    FP_LONG Add(FP_LONG a, FP_LONG b)
    {
        return a + b;
    }

    /// <summary>
    /// Subtracts the two FP numbers from each other.
    /// </summary>
    FP_LONG Sub(FP_LONG a, FP_LONG b)
    {
        return a - b;
    }

    /// <summary>
    /// Multiplies two FP values together.
    /// </summary>
    FP_LONG Mul(FP_LONG a, FP_LONG b)
    {
        FP_LONG ai = a >> Shift;
        FP_LONG af = (a & FractionMask);
        FP_LONG bi = b >> Shift;
        FP_LONG bf = (b & FractionMask);
        return FixedUtil::LogicalShiftRight(af * bf, Shift) + ai * b + af * bi;
    }

    FP_INT MulIntLongLow(FP_INT a, FP_LONG b)
    {
        FP_ASSERT(a >= 0);
        FP_INT bi = (FP_INT)(b >> Shift);
        FP_LONG bf = b & FractionMask;
        return (FP_INT)FixedUtil::LogicalShiftRight(a * bf, Shift) + a * bi;
    }

    FP_LONG MulIntLongLong(FP_INT a, FP_LONG b)
    {
        FP_ASSERT(a >= 0);
        FP_LONG bi = b >> Shift;
        FP_LONG bf = b & FractionMask;
        return FixedUtil::LogicalShiftRight(a * bf, Shift) + a * bi;
    }

    /// <summary>
    /// Linearly interpolate from a to b by t.
    /// </summary>
    FP_LONG Lerp(FP_LONG a, FP_LONG b, FP_LONG t)
    {
        return Mul(a, t) + Mul(b, One - t);
    }

    FP_INT Nlz(FP_ULONG x)
    {
    #if NET5_0_OR_GREATER
        return System.Numerics.BitOperations.LeadingZeroCount(x);
    #else
        FP_INT n = 0;
        if (x <= INT64_C(0x00000000FFFFFFFF)) { n = n + 32; x = x << 32; }
        if (x <= INT64_C(0x0000FFFFFFFFFFFF)) { n = n + 16; x = x << 16; }
        if (x <= INT64_C(0x00FFFFFFFFFFFFFF)) { n = n + 8; x = x << 8; }
        if (x <= INT64_C(0x0FFFFFFFFFFFFFFF)) { n = n + 4; x = x << 4; }
        if (x <= INT64_C(0x3FFFFFFFFFFFFFFF)) { n = n + 2; x = x << 2; }
        if (x <= INT64_C(0x7FFFFFFFFFFFFFFF)) { n = n + 1; }
        if (x == 0) return 64;
        return n;
    #endif
    }

    /// <summary>
    /// Divides two FP values.
    /// </summary>
    FP_LONG DivPrecise(FP_LONG arg_a, FP_LONG arg_b)
    {
        // From http://www.hackersdelight.org/hdcodetxt/divlu.c.txt

        FP_LONG sign_dif = arg_a ^ arg_b;

        const FP_ULONG b = INT64_C(0x100000000); // Number base (32 bits)
        FP_ULONG abs_arg_a = (FP_ULONG)((arg_a < 0) ? -arg_a : arg_a);
        FP_ULONG u1 = abs_arg_a >> 32;
        FP_ULONG u0 = abs_arg_a << 32;
        FP_ULONG v = (FP_ULONG)((arg_b < 0) ? -arg_b : arg_b);

        // Overflow?
        if (u1 >= v)
        {
            //rem = 0;
            return INT64_C(0x7fffffffffffffff);
        }

        // Shift amount for norm
        FP_INT s = Nlz(v); // 0 <= s <= 63
        v = v << s; // Normalize the divisor
        FP_ULONG vn1 = v >> 32; // Break the divisor into two 32-bit digits
        FP_ULONG vn0 = v & INT64_C(0xffffffff);

        FP_ULONG un32 = (u1 << s) | ((u0 >> (64 - s)) & (FP_ULONG)((FP_LONG)-s >> 63));
        FP_ULONG un10 = u0 << s; // Shift dividend left

        FP_ULONG un1 = un10 >> 32; // Break the right half of dividend into two digits
        FP_ULONG un0 = un10 & INT64_C(0xffffffff);

        // Compute the first quotient digit, q1
        FP_ULONG q1 = un32 / vn1;
        FP_ULONG rhat = un32 - q1 * vn1;
        do
        {
            if ((q1 >= b) || ((q1 * vn0) > (b * rhat + un1)))
            {
                q1 = q1 - 1;
                rhat = rhat + vn1;
            }
            else break;
        } while (rhat < b);

        FP_ULONG un21 = un32 * b + un1 - q1 * v; // Multiply and subtract

        // Compute the second quotient digit, q0
        FP_ULONG q0 = un21 / vn1;
        rhat = un21 - q0 * vn1;
        do
        {
            if ((q0 >= b) || ((q0 * vn0) > (b * rhat + un0)))
            {
                q0 = q0 - 1;
                rhat = rhat + vn1;
            }
            else break;
        } while (rhat < b);

        // Calculate the remainder
        // FP_ULONG r = (un21 * b + un0 - q0 * v) >> s;
        // rem = (FP_LONG)r;

        FP_ULONG ret = q1 * b + q0;
        return (sign_dif < 0) ? -(FP_LONG)ret : (FP_LONG)ret;
    }

    /// <summary>
    /// Calculates division approximation.
    /// </summary>
    FP_LONG Div(FP_LONG a, FP_LONG b)
    {
        if (b == MinValue || b == 0)
        {
            FixedUtil::InvalidArgument("Fixed64::Div", "b", b);
            return 0;
        }

        // Handle negative values.
        FP_INT sign = (b < 0) ? -1 : 1;
        b *= sign;

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)b);
        FP_INT n = (FP_INT)FixedUtil::ShiftRight(b, offset + 2);
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);

        // Polynomial approximation.
        FP_INT res = FixedUtil::RcpPoly4Lut8(n - ONE);

        // Apply exponent, convert back to s32.32.
        FP_LONG y = MulIntLongLong(res, a) << 2;
        return FixedUtil::ShiftRight(sign * y, offset);
    }

    /// <summary>
    /// Calculates division approximation.
    /// </summary>
    FP_LONG DivFast(FP_LONG a, FP_LONG b)
    {
        if (b == MinValue || b == 0)
        {
            FixedUtil::InvalidArgument("Fixed64::DivFast", "b", b);
            return 0;
        }

        // Handle negative values.
        FP_INT sign = (b < 0) ? -1 : 1;
        b *= sign;

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)b);
        FP_INT n = (FP_INT)FixedUtil::ShiftRight(b, offset + 2);
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);

        // Polynomial approximation.
        FP_INT res = FixedUtil::RcpPoly6(n - ONE);

        // Apply exponent, convert back to s32.32.
        FP_LONG y = MulIntLongLong(res, a) << 2;
        return FixedUtil::ShiftRight(sign * y, offset);
    }

    /// <summary>
    /// Calculates division approximation.
    /// </summary>
    FP_LONG DivFastest(FP_LONG a, FP_LONG b)
    {
        if (b == MinValue || b == 0)
        {
            FixedUtil::InvalidArgument("Fixed64::DivFastest", "b", b);
            return 0;
        }

        // Handle negative values.
        FP_INT sign = (b < 0) ? -1 : 1;
        b *= sign;

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)b);
        FP_INT n = (FP_INT)FixedUtil::ShiftRight(b, offset + 2);
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);

        // Polynomial approximation.
        FP_INT res = FixedUtil::RcpPoly4(n - ONE);

        // Apply exponent, convert back to s32.32.
        FP_LONG y = MulIntLongLong(res, a) << 2;
        return FixedUtil::ShiftRight(sign * y, offset);
    }

    /// <summary>
    /// Divides two FP values and returns the modulus.
    /// </summary>
    FP_LONG Mod(FP_LONG a, FP_LONG b)
    {
        if (b == 0)
        {
            FixedUtil::InvalidArgument("Fixed64::Mod", "b", b);
            return 0;
        }

        return a % b;
    }

    /// <summary>
    /// Calculates the square root of the given number.
    /// </summary>
    FP_LONG SqrtPrecise(FP_LONG a)
    {
        // Adapted from https://github.com/chmike/fpsqrt
        if (a <= 0)
        {
            if (a < 0)
                FixedUtil::InvalidArgument("Fixed64::SqrtPrecise", "a", a);
            return 0;
        }

        FP_ULONG r = (FP_ULONG)a;
        FP_ULONG b = INT64_C(0x4000000000000000);
        FP_ULONG q = INT64_C(0);
        while (b > INT64_C(0x40))
        {
            FP_ULONG t = q + b;
            if (r >= t)
            {
                r -= t;
                q = t + b;
            }
            r <<= 1;
            b >>= 1;
        }
        q >>= 16;
        return (FP_LONG)q;
    }

    FP_LONG Sqrt(FP_LONG x)
    {
        // Return 0 for all non-positive values.
        if (x <= 0)
        {
            if (x < 0)
                FixedUtil::InvalidArgument("Fixed64::Sqrt", "x", x);
            return 0;
        }

        // Constants (s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT SQRT2 = 1518500249; // sqrt(2.0)

        // Normalize input into [1.0, 2.0( range (as s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_INT y = FixedUtil::SqrtPoly3Lut8(n - ONE);

        // Divide offset by 2 (to get sqrt), compute adjust value for odd exponents.
        FP_INT adjust = ((offset & 1) != 0) ? SQRT2 : ONE;
        offset = offset >> 1;

        // Apply exponent, convert back to s32.32.
        FP_LONG yr = (FP_LONG)FixedUtil::Qmul30(adjust, y) << 2;
        return (offset >= 0) ? (yr << offset) : (yr >> -offset);
    }

    FP_LONG SqrtFast(FP_LONG x)
    {
        // Return 0 for all non-positive values.
        if (x <= 0)
        {
            if (x < 0)
                FixedUtil::InvalidArgument("Fixed64::SqrtFast", "x", x);
            return 0;
        }

        // Constants (s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT SQRT2 = 1518500249; // sqrt(2.0)

        // Normalize input into [1.0, 2.0( range (as s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_INT y = FixedUtil::SqrtPoly4(n - ONE);

        // Divide offset by 2 (to get sqrt), compute adjust value for odd exponents.
        FP_INT adjust = ((offset & 1) != 0) ? SQRT2 : ONE;
        offset = offset >> 1;

        // Apply exponent, convert back to s32.32.
        FP_LONG yr = (FP_LONG)FixedUtil::Qmul30(adjust, y) << 2;
        return (offset >= 0) ? (yr << offset) : (yr >> -offset);
    }

    FP_LONG SqrtFastest(FP_LONG x)
    {
        // Return 0 for all non-positive values.
        if (x <= 0)
        {
            if (x < 0)
                FixedUtil::InvalidArgument("Fixed64::SqrtFastest", "x", x);
            return 0;
        }

        // Constants (s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT SQRT2 = 1518500249; // sqrt(2.0)

        // Normalize input into [1.0, 2.0( range (as s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_INT y = FixedUtil::SqrtPoly3(n - ONE);

        // Divide offset by 2 (to get sqrt), compute adjust value for odd exponents.
        FP_INT adjust = ((offset & 1) != 0) ? SQRT2 : ONE;
        offset = offset >> 1;

        // Apply exponent, convert back to s32.32.
        FP_LONG yr = (FP_LONG)FixedUtil::Qmul30(adjust, y) << 2;
        return (offset >= 0) ? (yr << offset) : (yr >> -offset);
    }

    /// <summary>
    /// Calculates the reciprocal square root.
    /// </summary>
    FP_LONG RSqrt(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::RSqrt", "x", x);
            return 0;
        }

        // Constants (s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT HALF_SQRT2 = 759250125; // 0.5 * sqrt(2.0)

        // Normalize input into [1.0, 2.0( range (as s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_INT y = FixedUtil::RSqrtPoly3Lut16(n - ONE);

        // Divide offset by 2 (to get sqrt), compute adjust value for odd exponents.
        FP_INT adjust = ((offset & 1) != 0) ? HALF_SQRT2 : ONE;
        offset = offset >> 1;

        // Apply exponent, convert back to s32.32.
        FP_LONG yr = (FP_LONG)FixedUtil::Qmul30(adjust, y) << 2;
        return (offset >= 0) ? (yr >> offset) : (yr << -offset);
    }

    /// <summary>
    /// Calculates the reciprocal square root.
    /// </summary>
    FP_LONG RSqrtFast(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::RSqrtFast", "x", x);
            return 0;
        }

        // Constants (s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT HALF_SQRT2 = 759250125; // 0.5 * sqrt(2.0)

        // Normalize input into [1.0, 2.0( range (as s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_INT y = FixedUtil::RSqrtPoly5(n - ONE);

        // Divide offset by 2 (to get sqrt), compute adjust value for odd exponents.
        FP_INT adjust = ((offset & 1) != 0) ? HALF_SQRT2 : ONE;
        offset = offset >> 1;

        // Apply exponent, convert back to s32.32.
        FP_LONG yr = (FP_LONG)FixedUtil::Qmul30(adjust, y) << 2;
        return (offset >= 0) ? (yr >> offset) : (yr << -offset);
    }

    /// <summary>
    /// Calculates the reciprocal square root.
    /// </summary>
    FP_LONG RSqrtFastest(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::RSqrtFastest", "x", x);
            return 0;
        }

        // Constants (s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT HALF_SQRT2 = 759250125; // 0.5 * sqrt(2.0)

        // Normalize input into [1.0, 2.0( range (as s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_INT y = FixedUtil::RSqrtPoly3(n - ONE);

        // Divide offset by 2 (to get sqrt), compute adjust value for odd exponents.
        FP_INT adjust = ((offset & 1) != 0) ? HALF_SQRT2 : ONE;
        offset = offset >> 1;

        // Apply exponent, convert back to s32.32.
        FP_LONG yr = (FP_LONG)FixedUtil::Qmul30(adjust, y) << 2;
        return (offset >= 0) ? (yr >> offset) : (yr << -offset);
    }

    /// <summary>
    /// Calculates reciprocal approximation.
    /// </summary>
    FP_LONG Rcp(FP_LONG x)
    {
        if (x == MinValue || x == 0)
        {
            FixedUtil::InvalidArgument("Fixed64::Rcp", "x", x);
            return 0;
        }

        // Handle negative values.
        FP_INT sign = (x < 0) ? -1 : 1;
        x *= sign;

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)FixedUtil::ShiftRight(x, offset + 2);
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);

        // Polynomial approximation.
        FP_INT res = FixedUtil::RcpPoly4Lut8(n - ONE);
        FP_LONG y = (FP_LONG)(sign * res) << 2;

        // Apply exponent, convert back to s32.32.
        return FixedUtil::ShiftRight(y, offset);
    }

    /// <summary>
    /// Calculates reciprocal approximation.
    /// </summary>
    FP_LONG RcpFast(FP_LONG x)
    {
        if (x == MinValue || x == 0)
        {
            FixedUtil::InvalidArgument("Fixed64::RcpFast", "x", x);
            return 0;
        }

        // Handle negative values.
        FP_INT sign = (x < 0) ? -1 : 1;
        x *= sign;

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)FixedUtil::ShiftRight(x, offset + 2);
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);

        // Polynomial approximation.
        FP_INT res = FixedUtil::RcpPoly6(n - ONE);
        FP_LONG y = (FP_LONG)(sign * res) << 2;

        // Apply exponent, convert back to s32.32.
        return FixedUtil::ShiftRight(y, offset);
    }

    /// <summary>
    /// Calculates reciprocal approximation.
    /// </summary>
    FP_LONG RcpFastest(FP_LONG x)
    {
        if (x == MinValue || x == 0)
        {
            FixedUtil::InvalidArgument("Fixed64::RcpFastest", "x", x);
            return 0;
        }

        // Handle negative values.
        FP_INT sign = (x < 0) ? -1 : 1;
        x *= sign;

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        const FP_INT ONE = (1 << 30);
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)FixedUtil::ShiftRight(x, offset + 2);
        //FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);

        // Polynomial approximation.
        FP_INT res = FixedUtil::RcpPoly4(n - ONE);
        FP_LONG y = (FP_LONG)(sign * res) << 2;

        // Apply exponent, convert back to s32.32.
        return FixedUtil::ShiftRight(y, offset);
    }

    /// <summary>
    /// Calculates the base 2 exponent.
    /// </summary>
    FP_LONG Exp2(FP_LONG x)
    {
        // Handle values that would under or overflow.
        if (x >= 32 * One) return MaxValue;
        if (x <= -32 * One) return 0;

        // Compute exp2 for fractional part.
        FP_INT k = (FP_INT)((x & FractionMask) >> 2);
        FP_LONG y = (FP_LONG)FixedUtil::Exp2Poly5(k) << 2;

        // Combine integer and fractional result, and convert back to s32.32.
        FP_INT intPart = (FP_INT)(x >> Shift);
        return (intPart >= 0) ? (y << intPart) : (y >> -intPart);
    }

    /// <summary>
    /// Calculates the base 2 exponent.
    /// </summary>
    FP_LONG Exp2Fast(FP_LONG x)
    {
        // Handle values that would under or overflow.
        if (x >= 32 * One) return MaxValue;
        if (x <= -32 * One) return 0;

        // Compute exp2 for fractional part.
        FP_INT k = (FP_INT)((x & FractionMask) >> 2);
        FP_LONG y = (FP_LONG)FixedUtil::Exp2Poly4(k) << 2;

        // Combine integer and fractional result, and convert back to s32.32.
        FP_INT intPart = (FP_INT)(x >> Shift);
        return (intPart >= 0) ? (y << intPart) : (y >> -intPart);
    }

    /// <summary>
    /// Calculates the base 2 exponent.
    /// </summary>
    FP_LONG Exp2Fastest(FP_LONG x)
    {
        // Handle values that would under or overflow.
        if (x >= 32 * One) return MaxValue;
        if (x <= -32 * One) return 0;

        // Compute exp2 for fractional part.
        FP_INT k = (FP_INT)((x & FractionMask) >> 2);
        FP_LONG y = (FP_LONG)FixedUtil::Exp2Poly3(k) << 2;

        // Combine integer and fractional result, and convert back to s32.32.
        FP_INT intPart = (FP_INT)(x >> Shift);
        return (intPart >= 0) ? (y << intPart) : (y >> -intPart);
    }

    FP_LONG Exp(FP_LONG x)
    {
        // e^x == 2^(x / ln(2))
        return Exp2(Mul(x, RCP_LN2));
    }

    FP_LONG ExpFast(FP_LONG x)
    {
        // e^x == 2^(x / ln(2))
        return Exp2Fast(Mul(x, RCP_LN2));
    }

    FP_LONG ExpFastest(FP_LONG x)
    {
        // e^x == 2^(x / ln(2))
        return Exp2Fastest(Mul(x, RCP_LN2));
    }

    // Natural logarithm (base e).
    FP_LONG Log(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::Log", "x", x);
            return 0;
        }

        // Normalize value to range [1.0, 2.0( as s2.30 and extract exponent.
        const FP_INT ONE = (1 << 30);
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_LONG y = (FP_LONG)FixedUtil::LogPoly5Lut8(n - ONE) << 2;

        // Combine integer and fractional parts (into s32.32).
        return (FP_LONG)offset * RCP_LOG2_E + y;
    }

    FP_LONG LogFast(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::LogFast", "x", x);
            return 0;
        }

        // Normalize value to range [1.0, 2.0( as s2.30 and extract exponent.
        const FP_INT ONE = (1 << 30);
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_LONG y = (FP_LONG)FixedUtil::LogPoly3Lut8(n - ONE) << 2;

        // Combine integer and fractional parts (into s32.32).
        return (FP_LONG)offset * RCP_LOG2_E + y;
    }

    FP_LONG LogFastest(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::LogFastest", "x", x);
            return 0;
        }

        // Normalize value to range [1.0, 2.0( as s2.30 and extract exponent.
        const FP_INT ONE = (1 << 30);
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_ASSERT(n >= ONE);
        FP_LONG y = (FP_LONG)FixedUtil::LogPoly5(n - ONE) << 2;

        // Combine integer and fractional parts (into s32.32).
        return (FP_LONG)offset * RCP_LOG2_E + y;
    }

    FP_LONG Log2(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::Log2", "x", x);
            return 0;
        }

        // Normalize value to range [1.0, 2.0( as s2.30 and extract exponent.
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);

        // Polynomial approximation of mantissa.
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);
        FP_LONG y = (FP_LONG)FixedUtil::Log2Poly4Lut16(n - ONE) << 2;

        // Combine integer and fractional parts (into s32.32).
        return ((FP_LONG)offset << Shift) + y;
    }

    FP_LONG Log2Fast(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::Log2Fast", "x", x);
            return 0;
        }

        // Normalize value to range [1.0, 2.0( as s2.30 and extract exponent.
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);

        // Polynomial approximation of mantissa.
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);
        FP_LONG y = (FP_LONG)FixedUtil::Log2Poly3Lut16(n - ONE) << 2;

        // Combine integer and fractional parts (into s32.32).
        return ((FP_LONG)offset << Shift) + y;
    }

    FP_LONG Log2Fastest(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            FixedUtil::InvalidArgument("Fixed64::Log2Fastest", "x", x);
            return 0;
        }

        // Normalize value to range [1.0, 2.0( as s2.30 and extract exponent.
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);

        // Polynomial approximation of mantissa.
        const FP_INT ONE = (1 << 30);
        FP_ASSERT(n >= ONE);
        FP_LONG y = (FP_LONG)FixedUtil::Log2Poly5(n - ONE) << 2;

        // Combine integer and fractional parts (into s32.32).
        return ((FP_LONG)offset << Shift) + y;
    }

    /// <summary>
    /// Calculates x to the power of the exponent.
    /// </summary>
    FP_LONG Pow(FP_LONG x, FP_LONG exponent)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            if (x < 0)
                FixedUtil::InvalidArgument("Fixed64::Pow", "x", x);
            return 0;
        }

        return Exp(Mul(exponent, Log(x)));
    }

    /// <summary>
    /// Calculates x to the power of the exponent.
    /// </summary>
    FP_LONG PowFast(FP_LONG x, FP_LONG exponent)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            if (x < 0)
                FixedUtil::InvalidArgument("Fixed64::PowFast", "x", x);
            return 0;
        }

        return ExpFast(Mul(exponent, LogFast(x)));
    }

    /// <summary>
    /// Calculates x to the power of the exponent.
    /// </summary>
    FP_LONG PowFastest(FP_LONG x, FP_LONG exponent)
    {
        // Return 0 for invalid values
        if (x <= 0)
        {
            if (x < 0)
                FixedUtil::InvalidArgument("Fixed64::PowFastest", "x", x);
            return 0;
        }

        return ExpFastest(Mul(exponent, LogFastest(x)));
    }

    FP_INT UnitSin(FP_INT z)
    {
        // See: http://www.coranac.com/2009/07/sines/

        // Handle quadrants 1 and 2 by mirroring the [1, 3] range to [-1, 1] (by calculating 2 - z).
        // The if condition uses the fact that for the quadrants of interest are 0b01 and 0b10 (top two bits are different).
        if ((z ^ (z << 1)) < 0)
            z = (1 << 31) - z;

        // Now z is in range [-1, 1].
        const FP_INT ONE = (1 << 30);
        FP_ASSERT((z >= -ONE) && (z <= ONE));

        // Polynomial approximation.
        FP_INT zz = FixedUtil::Qmul30(z, z);
        FP_INT res = FixedUtil::Qmul30(FixedUtil::SinPoly4(zz), z);

        // Return s2.30 value.
        return res;
    }

    FP_INT UnitSinFast(FP_INT z)
    {
        // See: http://www.coranac.com/2009/07/sines/

        // Handle quadrants 1 and 2 by mirroring the [1, 3] range to [-1, 1] (by calculating 2 - z).
        // The if condition uses the fact that for the quadrants of interest are 0b01 and 0b10 (top two bits are different).
        if ((z ^ (z << 1)) < 0)
            z = (1 << 31) - z;

        // Now z is in range [-1, 1].
        const FP_INT ONE = (1 << 30);
        FP_ASSERT((z >= -ONE) && (z <= ONE));

        // Polynomial approximation.
        FP_INT zz = FixedUtil::Qmul30(z, z);
        FP_INT res = FixedUtil::Qmul30(FixedUtil::SinPoly3(zz), z);

        // Return s2.30 value.
        return res;
    }

    FP_INT UnitSinFastest(FP_INT z)
    {
        // See: http://www.coranac.com/2009/07/sines/

        // Handle quadrants 1 and 2 by mirroring the [1, 3] range to [-1, 1] (by calculating 2 - z).
        // The if condition uses the fact that for the quadrants of interest are 0b01 and 0b10 (top two bits are different).
        if ((z ^ (z << 1)) < 0)
            z = (1 << 31) - z;

        // Now z is in range [-1, 1].
        const FP_INT ONE = (1 << 30);
        FP_ASSERT((z >= -ONE) && (z <= ONE));

        // Polynomial approximation.
        FP_INT zz = FixedUtil::Qmul30(z, z);
        FP_INT res = FixedUtil::Qmul30(FixedUtil::SinPoly2(zz), z);

        // Return s2.30 value.
        return res;
    }

    FP_LONG Sin(FP_LONG x)
    {
        // Map [0, 2pi] to [0, 4] (as s2.30).
        // This also wraps the values into one period.
        FP_INT z = MulIntLongLow(RCP_HALF_PI, x);

        // Compute sine and convert to s32.32.
        return (FP_LONG)UnitSin(z) << 2;
    }

    FP_LONG SinFast(FP_LONG x)
    {
        // Map [0, 2pi] to [0, 4] (as s2.30).
        // This also wraps the values into one period.
        FP_INT z = MulIntLongLow(RCP_HALF_PI, x);

        // Compute sine and convert to s32.32.
        return (FP_LONG)UnitSinFast(z) << 2;
    }

    FP_LONG SinFastest(FP_LONG x)
    {
        // Map [0, 2pi] to [0, 4] (as s2.30).
        // This also wraps the values into one period.
        FP_INT z = MulIntLongLow(RCP_HALF_PI, x);

        // Compute sine and convert to s32.32.
        return (FP_LONG)UnitSinFastest(z) << 2;
    }

    FP_LONG Cos(FP_LONG x)
    {
        return Sin(x + PiHalf);
    }

    FP_LONG CosFast(FP_LONG x)
    {
        return SinFast(x + PiHalf);
    }

    FP_LONG CosFastest(FP_LONG x)
    {
        return SinFastest(x + PiHalf);
    }

    FP_LONG Tan(FP_LONG x)
    {
        FP_INT z = MulIntLongLow(RCP_HALF_PI, x);
        FP_LONG sinX = (FP_LONG)UnitSin(z) << 32;
        FP_LONG cosX = (FP_LONG)UnitSin(z + (1 << 30)) << 32;
        return Div(sinX, cosX);
    }

    FP_LONG TanFast(FP_LONG x)
    {
        FP_INT z = MulIntLongLow(RCP_HALF_PI, x);
        FP_LONG sinX = (FP_LONG)UnitSinFast(z) << 32;
        FP_LONG cosX = (FP_LONG)UnitSinFast(z + (1 << 30)) << 32;
        return DivFast(sinX, cosX);
    }

    FP_LONG TanFastest(FP_LONG x)
    {
        FP_INT z = MulIntLongLow(RCP_HALF_PI, x);
        FP_LONG sinX = (FP_LONG)UnitSinFastest(z) << 32;
        FP_LONG cosX = (FP_LONG)UnitSinFastest(z + (1 << 30)) << 32;
        return DivFastest(sinX, cosX);
    }

    FP_INT Atan2Div(FP_LONG y, FP_LONG x)
    {
        FP_ASSERT(y >= 0 && x > 0 && x >= y);

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT HALF = (1 << 29);
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_INT k = n - ONE;

        // Polynomial approximation of reciprocal.
        FP_INT oox = FixedUtil::RcpPoly4Lut8(k);
        FP_ASSERT(oox >= HALF && oox <= ONE);

        // Apply exponent and multiply.
        FP_LONG yr = (offset >= 0) ? (y >> offset) : (y << -offset);
        return FixedUtil::Qmul30((FP_INT)(yr >> 2), oox);
    }

    FP_LONG Atan2(FP_LONG y, FP_LONG x)
    {
        // See: https://www.dsprelated.com/showarticle/1052.php

        if (x == 0)
        {
            if (y > 0) return PiHalf;
            if (y < 0) return -PiHalf;

            FixedUtil::InvalidArgument("Fixed64::Atan2", "y, x", y, x);
            return 0;
        }

        // \note these round negative numbers slightly
        FP_LONG nx = x ^ (x >> 63);
        FP_LONG ny = y ^ (y >> 63);
        FP_LONG negMask = ((x ^ y) >> 63);

        if (nx >= ny)
        {
            FP_INT k = Atan2Div(ny, nx);
            FP_INT z = FixedUtil::AtanPoly5Lut8(k);
            FP_LONG angle = negMask ^ ((FP_LONG)z << 2);
            if (x > 0) return angle;
            if (y >= 0) return angle + Pi;
            return angle - Pi;
        }
        else
        {
            FP_INT k = Atan2Div(nx, ny);
            FP_INT z = FixedUtil::AtanPoly5Lut8(k);
            FP_LONG angle = negMask ^ ((FP_LONG)z << 2);
            return ((y > 0) ? PiHalf : -PiHalf) - angle;
        }
    }

    FP_INT Atan2DivFast(FP_LONG y, FP_LONG x)
    {
        FP_ASSERT(y >= 0 && x > 0 && x >= y);

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT HALF = (1 << 29);
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_INT k = n - ONE;

        // Polynomial approximation.
        FP_INT oox = FixedUtil::RcpPoly6(k);
        FP_ASSERT(oox >= HALF && oox <= ONE);

        // Apply exponent and multiply.
        FP_LONG yr = (offset >= 0) ? (y >> offset) : (y << -offset);
        return FixedUtil::Qmul30((FP_INT)(yr >> 2), oox);
    }

    FP_LONG Atan2Fast(FP_LONG y, FP_LONG x)
    {
        // See: https://www.dsprelated.com/showarticle/1052.php

        if (x == 0)
        {
            if (y > 0) return PiHalf;
            if (y < 0) return -PiHalf;

            FixedUtil::InvalidArgument("Fixed64::Atan2Fast", "y, x", y, x);
            return 0;
        }

        // \note these round negative numbers slightly
        FP_LONG nx = x ^ (x >> 63);
        FP_LONG ny = y ^ (y >> 63);
        FP_LONG negMask = ((x ^ y) >> 63);

        if (nx >= ny)
        {
            FP_INT k = Atan2DivFast(ny, nx);
            FP_INT z = FixedUtil::AtanPoly3Lut8(k);
            FP_LONG angle = negMask ^ ((FP_LONG)z << 2);
            if (x > 0) return angle;
            if (y >= 0) return angle + Pi;
            return angle - Pi;
        }
        else
        {
            FP_INT k = Atan2DivFast(nx, ny);
            FP_INT z = FixedUtil::AtanPoly3Lut8(k);
            FP_LONG angle = negMask ^ ((FP_LONG)z << 2);
            return ((y > 0) ? PiHalf : -PiHalf) - angle;
        }
    }

    FP_INT Atan2DivFastest(FP_LONG y, FP_LONG x)
    {
        FP_ASSERT(y >= 0 && x > 0 && x >= y);

        // Normalize input into [1.0, 2.0( range (convert to s2.30).
        const FP_INT ONE = (1 << 30);
        const FP_INT HALF = (1 << 29);
        FP_INT offset = 31 - Nlz((FP_ULONG)x);
        FP_INT n = (FP_INT)(((offset >= 0) ? (x >> offset) : (x << -offset)) >> 2);
        FP_INT k = n - ONE;

        // Polynomial approximation.
        FP_INT oox = FixedUtil::RcpPoly4(k);
        FP_ASSERT(oox >= HALF && oox <= ONE);

        // Apply exponent and multiply.
        FP_LONG yr = (offset >= 0) ? (y >> offset) : (y << -offset);
        return FixedUtil::Qmul30((FP_INT)(yr >> 2), oox);
    }

    FP_LONG Atan2Fastest(FP_LONG y, FP_LONG x)
    {
        // See: https://www.dsprelated.com/showarticle/1052.php

        if (x == 0)
        {
            if (y > 0) return PiHalf;
            if (y < 0) return -PiHalf;

            FixedUtil::InvalidArgument("Fixed64::Atan2Fastest", "y, x", y, x);
            return 0;
        }

        // \note these round negative numbers slightly
        FP_LONG nx = x ^ (x >> 63);
        FP_LONG ny = y ^ (y >> 63);
        FP_LONG negMask = ((x ^ y) >> 63);

        if (nx >= ny)
        {
            FP_INT z = Atan2DivFastest(ny, nx);
            FP_INT res = FixedUtil::AtanPoly4(z);
            FP_LONG angle = negMask ^ ((FP_LONG)res << 2);
            if (x > 0) return angle;
            if (y >= 0) return angle + Pi;
            return angle - Pi;
        }
        else
        {
            FP_INT z = Atan2DivFastest(nx, ny);
            FP_INT res = FixedUtil::AtanPoly4(z);
            FP_LONG angle = negMask ^ ((FP_LONG)res << 2);
            return ((y > 0) ? PiHalf : -PiHalf) - angle;
        }
    }

    FP_LONG Asin(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x < -One || x > One)
        {
            FixedUtil::InvalidArgument("Fixed64::Asin", "x", x);
            return 0;
        }

        return Atan2(x, Sqrt(Mul(One + x, One - x)));
    }

    FP_LONG AsinFast(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x < -One || x > One)
        {
            FixedUtil::InvalidArgument("Fixed64::AsinFast", "x", x);
            return 0;
        }

        return Atan2Fast(x, SqrtFast(Mul(One + x, One - x)));
    }

    FP_LONG AsinFastest(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x < -One || x > One)
        {
            FixedUtil::InvalidArgument("Fixed64::AsinFastest", "x", x);
            return 0;
        }

        return Atan2Fastest(x, SqrtFastest(Mul(One + x, One - x)));
    }

    FP_LONG Acos(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x < -One || x > One)
        {
            FixedUtil::InvalidArgument("Fixed64::Acos", "x", x);
            return 0;
        }

        return Atan2(Sqrt(Mul(One + x, One - x)), x);
    }

    FP_LONG AcosFast(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x < -One || x > One)
        {
            FixedUtil::InvalidArgument("Fixed64::AcosFast", "x", x);
            return 0;
        }

        return Atan2Fast(SqrtFast(Mul(One + x, One - x)), x);
    }

    FP_LONG AcosFastest(FP_LONG x)
    {
        // Return 0 for invalid values
        if (x < -One || x > One)
        {
            FixedUtil::InvalidArgument("Fixed64::AcosFastest", "x", x);
            return 0;
        }

        return Atan2Fastest(SqrtFastest(Mul(One + x, One - x)), x);
    }

    FP_LONG Atan(FP_LONG x)
    {
        return Atan2(x, One);
    }

    FP_LONG AtanFast(FP_LONG x)
    {
        return Atan2Fast(x, One);
    }

    FP_LONG AtanFastest(FP_LONG x)
    {
        return Atan2Fastest(x, One);
    }




    #undef FP_ASSERT
}
#endif // __FIXED64_H


================================================
FILE: lib/FixPointCS/FixedUtil.h
================================================
//
// FixPointCS
//
// Copyright(c) Jere Sanisalo, Petri Kero
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY INT64_C(C)AIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER INT64_C(DEA)INGS IN THE
// SOFTWARE.
//

//
// GENERATED FILE!!!
//
// Generated from FixedUtil.cs, part of the FixPointCS project (MIT license).
//
#pragma once
#ifndef __FIXEDUTIL_H
#define __FIXEDUTIL_H

// Include numeric types
#include <stdint.h>


// If FP_ASSERT is not custom-defined, then use the standard one
#ifndef FP_ASSERT
#   include <assert.h>
#   define FP_ASSERT(x) assert(x)
#endif

// If FP_CUSTOM_INVALID_ARGS is defined, then the used is expected to implement the following functions in
// the FixedUtil namespace:
//  void InvalidArgument(const char* funcName, const char* argName, FP_INT argValue);
//  void InvalidArgument(const char* funcName, const char* argName, FP_INT argValue1, FP_INT argValue2);
//	void InvalidArgument(const char* funcName, const char* argName, FP_LONG argValue);
//	void InvalidArgument(const char* funcName, const char* argName, FP_LONG argValue1, FP_LONG argValue2);
// These functions should handle the cases for invalid arguments in any desired way (assert, exception, log, ignore etc).
//#define FP_CUSTOM_INVALID_ARGS

namespace FixedUtil
{
    typedef int32_t FP_INT;
    typedef uint32_t FP_UINT;
    typedef int64_t FP_LONG;
    typedef uint64_t FP_ULONG;

    static_assert(sizeof(FP_INT) == 4, "Wrong bytesize for FP_INT");
    static_assert(sizeof(FP_UINT) == 4, "Wrong bytesize for FP_UINT");
    static_assert(sizeof(FP_LONG) == 8, "Wrong bytesize for FP_LONG");
    static_assert(sizeof(FP_ULONG) == 8, "Wrong bytesize for FP_ULONG");

#ifdef FP_CUSTOM_INVALID_ARGS
    extern void InvalidArgument(const char* funcName, const char* argName, FP_INT argValue);
    extern void InvalidArgument(const char* funcName, const char* argName, FP_INT argValue1, FP_INT argValue2);
    extern void InvalidArgument(const char* funcName, const char* argName, FP_LONG argValue);
    extern void InvalidArgument(const char* funcName, const char* argName, FP_LONG argValue1, FP_LONG argValue2);
#else
    inline void InvalidArgument(const char*, const char*, FP_INT) { }
    inline void InvalidArgument(const char*, const char*, FP_INT, FP_INT) { }
    inline void InvalidArgument(const char*, const char*, FP_LONG) { }
    inline void InvalidArgument(const char*, const char*, FP_LONG, FP_LONG) { }
#endif




    // InvalidArgument function defined in the transpiler generated header

    FP_INT Qmul29(FP_INT a, FP_INT b)
    {
        return (FP_INT)((FP_LONG)a * (FP_LONG)b >> 29);
    }

    FP_INT Qmul30(FP_INT a, FP_INT b)
    {
        return (FP_INT)((FP_LONG)a * (FP_LONG)b >> 30);
    }

    FP_INT ShiftLeft(FP_INT v, FP_INT shift)
    {
        return (shift >= 0) ? (v << shift) : (v >> -shift);
    }

    FP_INT ShiftRight(FP_INT v, FP_INT shift)
    {
        return (shift >= 0) ? (v >> shift) : (v << -shift);
    }

    FP_LONG ShiftRight(FP_LONG v, FP_INT shift)
    {
        return (shift >= 0) ? (v >> shift) : (v << -shift);
    }

    FP_LONG LogicalShiftRight(FP_LONG v, FP_INT shift)
    {
        return (FP_LONG)((FP_ULONG)v >> shift);
    }

    // Exp2()

    // Precision: 13.24 bits
    FP_INT Exp2Poly3(FP_INT a)
    {
        FP_INT y = Qmul30(a, 84039593); // 0.0782679701835315868647357253725971674790033117245148781445598202137415363194904317749528903660739148499430948967629357887
        y = Qmul30(a, y + 242996024); // 0.226307682289372255347421644246257966273699535419878898050811760122384683941875786929647503217974831952486347597791720611
        y = Qmul30(a, y + 746706207); // 0.695424347527096157787842630381144866247297152855606223804628419663873779738633781295399606415951253197570557505445343601
        y = y + 1073741824;
        return y;
    }

    // Precision: 18.19 bits
    FP_INT Exp2Poly4(FP_INT a)
    {
        FP_INT y = Qmul30(a, 14555373); // 0.0135557472348149177040307931905578544538124307723745221579881209426474911809748672636364432116420009120178935332926148611
        y = Qmul30(a, y + 55869331); // 0.0520323690084328924674487312215472415900450170687696511359785661622616863440911035364584944748959228308174520922142865995
        y = Qmul30(a, y + 259179547); // 0.241379762937091639018661074809242143033914474070411268883151785382581196588939527676019951096295687987322799846420118765
        y = Qmul30(a, y + 744137573); // 0.693032120819660550809859400778652760922228078088444557822881527512509625885994501523885111217166388269841854528072979774
        y = y + 1073741824;
        return y;
    }

    // Precision: 23.37 bits
    FP_INT Exp2Poly5(FP_INT a)
    {
        FP_INT y = Qmul30(a, 2017903); // 0.00187931864849444079178064366523643962831734445578833344828943266930262096728457318136293441770024748382988959051143223706
        y = Qmul30(a, y + 9654007); // 0.0089909950956369787948425038952611903126353369666002380364841111113291819538448433335270460143993823536893996134420311419
        y = Qmul30(a, y + 59934847); // 0.0558186759615980431203104787377782200574008231751237416643519892213181468390965300572726745159591410385167709971364406724
        y = Qmul30(a, y + 257869054); // 0.240159271464382269128561549965297376067896183861587452990582800168980375711748974675500420263841816476095364031528449763
        y = Qmul30(a, y + 744266012); // 0.693151738829888268164504823736426773933750311540900233860291666829069674528025078752336924788099412647868575767381646186
        y = y + 1073741824;
        return y;
    }

    // Rcp()

    // Precision: 11.33 bits
    FP_INT RcpPoly4(FP_INT a)
    {
        FP_INT y = Qmul30(a, 166123244); // 0.154714327545457094588979713106287560782537959277436051827019427328357322113481152734370734443893548182187731839301875899
        y = Qmul30(a, y + -581431354); // -0.54150014640909983106142899587200646273888285747102618139456799564925062739718403457029757055362741863765712410515426083
        y = Qmul30(a, y + 939345296); // 0.874833479742433164394762329205339796072216190804359514727901328982583960730517367903630903886960751970990489874952162084
        y = Qmul30(a, y + -1060908097); // -0.988047660878790427922313046439620894115871292610769385160352760661690655446814486067704067777226881515521097609099777152
        y = y + 1073741824;
        return y;
    }

    // Precision: 16.53 bits
    FP_INT RcpPoly6(FP_INT a)
    {
        FP_INT y = Qmul30(a, 77852993); // 0.0725062501842326696626758301282171253618850679805450684783331254738896577827939599454470990870969993306249485759929666981
        y = Qmul30(a, y + -350338469); // -0.326278125829047013482041235576977064128482805912452808152499064632503460022572819754511945891936496987812268591968349959
        y = Qmul30(a, y + 723231606); // 0.673561921455982545223734340382301840739167811454662043292934558465813280438563313561682188125190962075365760110255605888
        y = Qmul30(a, y + -974250754); // -0.907341721411285515029553588773713935349385980480415781958608445152553325879092398556945676696228380651281188866035287881
        y = Qmul30(a, y + 1059679220); // 0.986903179099804504543521516658287329916121575881841375617775839327272856972646872081214163224722216327427202183393238047
        y = Qmul30(a, y + -1073045505); // -0.999351503499687190918336862818115296539305668924179897277936013481919009292338927276885827848845300094324453411638172793
        y = y + 1073741824;
        return y;
    }

    FP_INT RcpPoly3Lut4Table[] =
    {
        -678697788, 1018046684, -1071069948, 1073721112,
        -302893157, 757232894, -1008066289, 1068408287,
        -154903745, 542163110, -902798392, 1051046118,
        -87262610, 392681750, -792180891, 1023631333,
    };

    // Precision: 15.66 bits
    FP_INT RcpPoly3Lut4(FP_INT a)
    {
        FP_INT offset = (a >> 28) * 4;
        FP_INT y = Qmul30(a, RcpPoly3Lut4Table[offset + 0]);
        y = Qmul30(a, y + RcpPoly3Lut4Table[offset + 1]);
        y = Qmul30(a, y + RcpPoly3Lut4Table[offset + 2]);
        y = y + RcpPoly3Lut4Table[offset + 3];
        return y;
    }

    FP_INT RcpPoly4Lut8Table[] =
    {
        796773553, -1045765287, 1072588028, -1073726795, 1073741824,
        456453183, -884378041, 1042385791, -1071088216, 1073651788,
        276544830, -708646126, 977216564, -1060211779, 1072962711,
        175386455, -559044324, 893798171, -1039424537, 1071009496,
        115547530, -440524957, 805500803, -1010097984, 1067345574,
        78614874, -348853503, 720007233, -974591889, 1061804940,
        54982413, -278348465, 641021491, -935211003, 1054431901,
        39383664, -223994590, 569927473, -893840914, 1045395281,
    };

    // Precision: 24.07 bits
    FP_INT RcpPoly4Lut8(FP_INT a)
    {
        FP_INT offset = (a >> 27) * 5;
        FP_INT y = Qmul30(a, RcpPoly4Lut8Table[offset + 0]);
        y = Qmul30(a, y + RcpPoly4Lut8Table[offset + 1]);
        y = Qmul30(a, y + RcpPoly4Lut8Table[offset + 2]);
        y = Qmul30(a, y + RcpPoly4Lut8Table[offset + 3]);
        y = y + RcpPoly4Lut8Table[offset + 4];
        return y;
    }

    // Sqrt()

    // Precision: 13.36 bits
    FP_INT SqrtPoly3(FP_INT a)
    {
        FP_INT y = Qmul30(a, 26809804); // 0.0249685755493961204934845015323729712245958715357182065425848552518546416164312449413742280712638308483065114885417147904
        y = Qmul30(a, y + -116435772); // -0.108439263715492087333244576730247754908569708153374339944951137491994192013534152641012071161185446185655458733810736431
        y = Qmul30(a, y + 534384395); // 0.497684250539191015641448799407572862253645711994604206579046020230872028859209946550025377417563188072362793476181318665
        y = y + 1073741824; // 1.0
        return y;
    }

    // Precision: 16.50 bits
    FP_INT SqrtPoly4(FP_INT a)
    {
        FP_INT y = Qmul30(a, -11559524); // -0.0107656468280005064933278905326776959702034851444407595549875999349858889266381514341825269487372902092181743561671344361
        y = Qmul30(a, y + 49235626); // 0.0458542501550120083313075597659725264999808459122954966477604412728019257521420334516113399358029950852981420572751187192
        y = Qmul30(a, y + -129356986); // -0.120473082434524586846319215086079446047783981719931015048359535322204769538816469963000080874223090148906445903268633479
        y = Qmul30(a, y + 536439312); // 0.499598041480608133810028270062482694087678496329024351132266431975121211175419626795958802214798958007840324433072946221
        y = y + 1073741824; // 1.0
        return y;
    }

    FP_INT SqrtPoly3Lut8Table[] =
    {
        57835763, -133550637, 536857054, 1073741824,
        43771091, -128445855, 536217068, 1073769530,
        34067722, -121273511, 534434402, 1073918540,
        27129178, -113536005, 531547139, 1074279077,
        22019236, -105917226, 527752485, 1074910452,
        18161894, -98716852, 523266057, 1075843557,
        15188335, -92049348, 518277843, 1077088717,
        12854281, -85939307, 512942507, 1078642770,
    };

    // Precision: 23.56 bits
    FP_INT SqrtPoly3Lut8(FP_INT a)
    {
        FP_INT offset = (a >> 27) * 4;
        FP_INT y = Qmul30(a, SqrtPoly3Lut8Table[offset + 0]);
        y = Qmul30(a, y + SqrtPoly3Lut8Table[offset + 1]);
        y = Qmul30(a, y + SqrtPoly3Lut8Table[offset + 2]);
        y = y + SqrtPoly3Lut8Table[offset + 3];
        return y;
    }

    // RSqrt()

    // Precision: 10.55 bits
    FP_INT RSqrtPoly3(FP_INT a)
    {
        FP_INT y = Qmul30(a, -91950555); // -0.0856356289309618075724442347978716997984112060739604608172096078728382955692378474864988406402256175535135909431476122756
        y = Qmul30(a, y + 299398639); // 0.278836710932968623313626076681628936089988230155462820435332822241435754263689225928134347217644388668377307808008581711
        y = Qmul30(a, y + -521939780); // -0.486094300815459291340337479778908197006741086393028323029783345373231219463397859016441739413597984747356793749404820923
        y = y + 1073741824; // 1.0
        return y;
    }

    // Precision: 16.08 bits
    FP_INT RSqrtPoly5(FP_INT a)
    {
        FP_INT y = Qmul30(a, -34036183); // -0.0316986662178132948125724057457789067274319219669948992806572724657733410288354401675056668794389506376695226173434879395
        y = Qmul30(a, y + 140361627); // 0.130721952132469025002475913996909202114937889568059538633961150597311078891698356228999013320515864372663894767082977274
        y = Qmul30(a, y + -276049470); // -0.257091104134768572313864227992129218223743238765168155465701243532365537275047394354439662434976402678179717893043406024
        y = Qmul30(a, y + 391366758); // 0.364488696521754181874287383887070965401384329257252476170774837632778316357675818762347533724407215505228711973415321601
        y = Qmul30(a, y + -536134428); // -0.4993140971150938153494823020412230032803111204046749234700376032365842777144378210442074505666869401945364431146552564
        y = y + 1073741824; // 1.0
        return y;
    }

    FP_INT RSqrtPoly3Lut16Table[] =
    {
        -301579590, 401404709, -536857690, 1073741824,
        -245423010, 391086820, -536203235, 1073727515,
        -202026137, 374967334, -534189977, 1073642965,
        -168017146, 355951863, -530632261, 1073420226,
        -141028602, 335796841, -525604155, 1073001192,
        -119367482, 315555573, -519290609, 1072343850,
        -101802870, 295846496, -511911750, 1071422108,
        -87426328, 277017299, -503685655, 1070223323,
        -75558212, 259246781, -494811415, 1068745317,
        -65683680, 242608795, -485462769, 1066993613,
        -57408255, 227112748, -475787122, 1064979109,
        -50426484, 212729399, -465907121, 1062716254,
        -44499541, 199407328, -455923331, 1060221646,
        -39439007, 187083448, -445917204, 1057513002,
        -35094980, 175689646, -435953979, 1054608400,
        -31347269, 165156947, -426085312, 1051525761,
    };

    // Precision: 24.59 bits
    FP_INT RSqrtPoly3Lut16(FP_INT a)
    {
        FP_INT offset = (a >> 26) * 4;
        FP_INT y = Qmul30(a, RSqrtPoly3Lut16Table[offset + 0]);
        y = Qmul30(a, y + RSqrtPoly3Lut16Table[offset + 1]);
        y = Qmul30(a, y + RSqrtPoly3Lut16Table[offset + 2]);
        y = y + RSqrtPoly3Lut16Table[offset + 3];
        return y;
    }

    // Log()

    // Precision: 12.18 bits
    FP_INT LogPoly5(FP_INT a)
    {
        FP_INT y = Qmul30(a, 34835446); // 0.0324430374324099257645920506145091908173169505782530351933872568452187970039716570286755191899094832608276898590172296967
        y = Qmul30(a, y + -149023176); // -0.138788648453891138663259214948877985710758551758834443319382469349215457727435900740974302256302169487791331019735819359
        y = Qmul30(a, y + 315630515); // 0.293953823490661881198275484636301174125635657531784266710660462843103551518793294127904893642006610982580864921150987405
        y = Qmul30(a, y + -530763208); // -0.494311758014893283441267083938639942320000878038159975670627731298854764041757060977673894877216298188619864197654458825
        y = Qmul30(a, y + 1073581542); // 0.999850726105657924558890885094884131163156956047212371206642490453141495216122729917931111298021060974997472559962156274
        return y;
    }

    FP_INT LogPoly3Lut4Table[] =
    {
        270509931, -528507852, 1073614348, 0,
        139305305, -442070189, 1053671695, 1633382,
        83615845, -360802306, 1013781196, 8222843,
        52639154, -291267388, 961502851, 21386502,
    };

    // Precision: 12.51 bits
    FP_INT LogPoly3Lut4(FP_INT a)
    {
        FP_INT offset = (a >> 28) * 4;
        FP_INT y = Qmul30(a, LogPoly3Lut4Table[offset + 0]);
        y = Qmul30(a, y + LogPoly3Lut4Table[offset + 1]);
        y = Qmul30(a, y + LogPoly3Lut4Table[offset + 2]);
        y = y + LogPoly3Lut4Table[offset + 3];
        return y;
    }

    FP_INT LogPoly3Lut8Table[] =
    {
        309628536, -534507419, 1073724054, 0,
        215207992, -502390266, 1069897914, 160852,
        158892020, -461029083, 1059680319, 1010114,
        120758300, -418592578, 1043877151, 2979626,
        93932535, -378620013, 1023979692, 6288435,
        74487828, -342313729, 1001351633, 10996073,
        60012334, -309817259, 977010327, 17079637,
        48377690, -279159893, 950059138, 24984183,
    };

    // Precision: 15.35 bits
    FP_INT LogPoly3Lut8(FP_INT a)
    {
        FP_INT offset = (a >> 27) * 4;
        FP_INT y = Qmul30(a, LogPoly3Lut8Table[offset + 0]);
        y = Qmul30(a, y + LogPoly3Lut8Table[offset + 1]);
        y = Qmul30(a, y + LogPoly3Lut8Table[offset + 2]);
        y = y + LogPoly3Lut8Table[offset + 3];
        return y;
    }

    FP_INT LogPoly5Lut8Table[] =
    {
        166189159, -263271008, 357682461, -536867223, 1073741814, 0,
        91797130, -221452381, 347549389, -535551692, 1073651718, 2559,
        55429773, -177286543, 325776420, -530104991, 1072960646, 38103,
        35101911, -139778071, 297915163, -519690478, 1071001695, 186416,
        23102252, -110088504, 268427087, -504993810, 1067326167, 555414,
        15701243, -87124604, 239861114, -487185708, 1061762610, 1252264,
        10960108, -69430156, 213404033, -467374507, 1054333366, 2368437,
        7703441, -55178389, 188423866, -445453304, 1044702281, 4063226,
    };

    // Precision: 26.22 bits
    FP_INT LogPoly5Lut8(FP_INT a)
    {
        FP_INT offset = (a >> 27) * 6;
        FP_INT y = Qmul30(a, LogPoly5Lut8Table[offset + 0]);
        y = Qmul30(a, y + LogPoly5Lut8Table[offset + 1]);
        y = Qmul30(a, y + LogPoly5Lut8Table[offset + 2]);
        y = Qmul30(a, y + LogPoly5Lut8Table[offset + 3]);
        y = Qmul30(a, y + LogPoly5Lut8Table[offset + 4]);
        y = y + LogPoly5Lut8Table[offset + 5];
        return y;
    }

    // Log2()

    // Precision: 12.29 bits
    FP_INT Log2Poly5(FP_INT a)
    {
        FP_INT y = Qmul30(a, 47840369); // 0.0445548155276207896995334754162140597637031202974591126199168774393873986289641382244343408731171726931757539068975485089
        y = Qmul30(a, y + -208941842); // -0.194592255208938416591621284205816720732140050852301947258138293025978577320103558315407526014074332839410207729682281855
        y = Qmul30(a, y + 450346773); // 0.419418116511448143225544710148490988337404380945888758986024844824480954559055561814904948371254539592688384332290775469
        y = Qmul30(a, y + -764275149); // -0.711786700405071059895411856470396704111669190613765834655920030051222814749610509844938951593547905280264475803542602324
        y = Qmul30(a, y + 1548771675); // 1.44240602357494054356195495511150837674248533596658656579701261211118275506108037663799064380674298602249584492474438398
        return y;
    }

    FP_INT Log2Poly4Lut4Table[] =
    {
        -262388804, 497357316, -773551400, 1549073482, 0,
        -109627834, 364448809, -727169110, 1541348674, 512282,
        -55606812, 259947350, -650393145, 1515947800, 3705096,
        -30193295, 184276844, -565362946, 1473209058, 11812165,
    };

    // Precision: 17.47 bits
    FP_INT Log2Poly4Lut4(FP_INT a)
    {
        FP_INT offset = (a >> 28) * 5;
        FP_INT y = Qmul30(a, Log2Poly4Lut4Table[offset + 0]);
        y = Qmul30(a, y + Log2Poly4Lut4Table[offset + 1]);
        y = Qmul30(a, y + Log2Poly4Lut4Table[offset + 2]);
        y = Qmul30(a, y + Log2Poly4Lut4Table[offset + 3]);
        y = y + Log2Poly4Lut4Table[offset + 4];
        return y;
    }

    FP_INT Log2Poly5Lut4Table[] =
    {
        188232988, -362436158, 514145569, -774469188, 1549081618, 0,
        63930491, -229184904, 452495120, -759064000, 1547029186, 114449,
        27404630, -141534019, 367122541, -716855295, 1536437358, 1193011,
        12852334, -87700426, 286896922, -656644341, 1513678972, 4658365,
    };

    // Precision: 21.93 bits
    FP_INT Log2Poly5Lut4(FP_INT a)
    {
        FP_INT offset = (a >> 28) * 6;
        FP_INT y = Qmul30(a, Log2Poly5Lut4Table[offset + 0]);
        y = Qmul30(a, y + Log2Poly5Lut4Table[offset + 1]);
        y = Qmul30(a, y + Log2Poly5Lut4Table[offset + 2]);
        y = Qmul30(a, y + Log2Poly5Lut4Table[offset + 3]);
        y = Qmul30(a, y + Log2Poly5Lut4Table[offset + 4]);
        y = y + Log2Poly5Lut4Table[offset + 5];
        return y;
    }

    FP_INT Log2Poly3Lut8Table[] =
    {
        446326382, -771076074, 1549055308, 0,
        310260104, -724673704, 1543514571, 233309,
        229088935, -664989874, 1528754169, 1461470,
        174118266, -603771378, 1505939900, 4306814,
        135444733, -546112897, 1477222993, 9084839,
        107410065, -493744566, 1444569702, 15881168,
        86538496, -446871661, 1409446548, 24662718,
        69761446, -402649011, 1370556774, 36072616,
    };

    // Precision: 15.82 bits
    FP_INT Log2Poly3Lut8(FP_INT a)
    {
        FP_INT offset = (a >> 27) * 4;
        FP_INT y = Qmul30(a, Log2Poly3Lut8Table[offset + 0]);
        y = Qmul30(a, y + Log2Poly3Lut8Table[offset + 1]);
        y = Qmul30(a, y + Log2Poly3Lut8Table[offset + 2]);
        y = y + Log2Poly3Lut8Table[offset + 3];
        return y;
    }

    FP_INT Log2Poly3Lut16Table[] =
    {
        479498023, -773622327, 1549078527, 0,
        395931761, -759118188, 1548197526, 18808,
        334661898, -736470659, 1545381846, 136568,
        285596493, -709076642, 1540263722, 456574,
        245720905, -679311878, 1532841693, 1074840,
        212953734, -648695298, 1523292726, 2068966,
        185770248, -618189987, 1511870714, 3495916,
        163026328, -588395848, 1498851584, 5393582,
        143849516, -559673988, 1484504546, 7783737,
        127565758, -532227925, 1469077963, 10675243,
        113648249, -506157040, 1452793288, 14067055,
        101680803, -481491750, 1435843119, 17950929,
        91330868, -458215848, 1418390572, 22314023,
        82328154, -436276909, 1400565714, 27142441,
        74439828, -415566448, 1382437636, 32432624,
        67062062, -394757211, 1362869483, 38567491,
    };

    // Precision: 18.77 bits
    FP_INT Log2Poly3Lut16(FP_INT a)
    {
        FP_INT offset = (a >> 26) * 4;
        FP_INT y = Qmul30(a, Log2Poly3Lut16Table[offset + 0]);
        y = Qmul30(a, y + Log2Poly3Lut16Table[offset + 1]);
        y = Qmul30(a, y + Log2Poly3Lut16Table[offset + 2]);
        y = y + Log2Poly3Lut16Table[offset + 3];
        return y;
    }

    FP_INT Log2Poly4Lut16Table[] =
    {
        -349683705, 514860252, -774521507, 1549081965, 0,
        -271658431, 496776802, -772844764, 1549008620, 1259,
        -217158937, 469966332, -767835780, 1548587446, 14699,
        -175799370, 439219304, -759216789, 1547507699, 65699,
        -143866844, 407471403, -747343665, 1545528123, 189847,
        -118877791, 376365258, -732794890, 1542497870, 426993,
        -99090809, 346778829, -716182669, 1538346679, 816522,
        -83256460, 319137771, -698070351, 1533066538, 1394329,
        -70462839, 293601763, -678942086, 1526693477, 2191193,
        -60034672, 270176585, -659197359, 1519292323, 3232171,
        -51465396, 248781811, -639156567, 1510944906, 4536639,
        -44370441, 229291517, -619070546, 1501741200, 6118756,
        -38454405, 211558058, -599130091, 1491772420, 7988267,
        -33487114, 195423423, -579471329, 1481123710, 10151959,
        -29282549, 180709967, -560158338, 1469854024, 12618653,
        -25515190, 166551747, -540200057, 1457346639, 15558687,
    };

    // Precision: 25.20 bits
    FP_INT Log2Poly4Lut16(FP_INT a)
    {
        FP_INT offset = (a >> 26) * 5;
        FP_INT y = Qmul30(a, Log2Poly4Lut16Table[offset + 0]);
        y = Qmul30(a, y + Log2Poly4Lut16Table[offset + 1]);
        y = Qmul30(a, y + Log2Poly4Lut16Table[offset + 2]);
        y = Qmul30(a, y + Log2Poly4Lut16Table[offset + 3]);
        y = y + Log2Poly4Lut16Table[offset + 4];
        return y;
    }

    // Sin()

    // Precision: 12.55 bits
    FP_INT SinPoly2(FP_INT a)
    {
        FP_INT y = Qmul30(a, 78160664); // 0.072792791246675240806633584756838912025391316324690126147664432597740012658387971002826696503964998382073099859493224924
        y = Qmul30(a, y + -691048553); // -0.643589118041571860037955276396590354123911419602492412009771153095258421228154501762591444328997849123819708031503216569
        y = y + 1686629713; // 1.57079632679489661923132169163975144209852010327780228586210672049751840856976653075976474782503285074174660817200999164
        return y;
    }

    // Precision: 19.56 bits
    FP_INT SinPoly3(FP_INT a)
    {
        FP_INT y = Qmul30(a, -4685819); // -0.00436400981703153243210864997931625819052350492882668525242722064533389220603470732171385204753335364507030843902034709469
        y = Qmul30(a, y + 85358772); // 0.0794965509242783578799016950654626792792298788902324903830739535612665082075477776612291621671450318813032241372211405835
        y = Qmul30(a, y + -693560840); // -0.645928867902143444679114736725897863187226477239208090992753453413451024571279601099280057944644528977979523870210785134
        y = y + 1686629713; // 1.57079632679489661923132169163975144209852010327780228586210672049751840856976653075976474782503285074174660817200999164
        return y;
    }

    // Precision: 27.13 bits
    FP_INT SinPoly4(FP_INT a)
    {
        FP_INT y = Qmul30(a, 162679); // 0.000151506641710145430212560273580165931825591912723771559939880958777921352896251494433561036087921925941339032487946104446
        y = Qmul30(a, y + -5018587); // -0.0046739239118693360423625115440933405485555388758012378155538229669555462190128366781129325889847935291248353457031014355
        y = Qmul30(a, y + 85566362); // 0.0796898846149471415166275702814129714699583291426024010731469442497475447581642697337742897122044339073717901878121832219
        y = Qmul30(a, y + -693598342); // -0.645963794139684570135799310650651238951748485457327220679639722739088328461814215309859665984340413045934902046607019536
        y = y + 1686629713; // 1.57079632679489661923132169163975144209852010327780228586210672049751840856976653075976474782503285074174660817200999164
        return y;
    }

    // Atan()

    // Precision: 11.51 bits
    FP_INT AtanPoly4(FP_INT a)
    {
        FP_INT y = Qmul30(a, 160726798); // 0.149688495302819745936382180128149414212975169816783327757105073455364913850052796368792673611118203908491930788482514717
        y = Qmul30(a, y + -389730008); // -0.3629643552067315751294669187222720090413427534177140297655271624082990667114095804438257977266614399793827935382192301
        y = Qmul30(a, y + -1791887); // -0.00166882600835556487643157555251563341464517039273944961175492629580374127544152356827950414733023151629754542508176777682
        y = Qmul30(a, y + 1074109956); // 1.00034284930971570368517715996651394929230510383744660686391316332569199570835055730032133459840273458272542980313905982
        return y;
    }

    FP_INT AtanPoly5Lut8Table[] =
    {
        204464916, 1544566, -357994250, 1395, 1073741820, 0,
        119369854, 56362968, -372884915, 2107694, 1073588633, 4534,
        10771151, 190921163, -440520632, 19339556, 1071365339, 120610,
        -64491917, 329189978, -542756389, 57373179, 1064246365, 656900,
        -89925028, 390367074, -601765924, 85907899, 1057328034, 1329793,
        -80805750, 360696628, -563142238, 60762238, 1065515580, 263159,
        -58345538, 276259197, -435975641, -35140679, 1101731779, -5215389,
        -36116738, 179244146, -266417331, -183483381, 1166696761, -16608596,
        0, 0, 0, 0, 0, 843314857 // Atan(1.0)
	};

    // Precision: 28.06 bits
    FP_INT AtanPoly5Lut8(FP_INT a)
    {
        FP_INT offset = (a >> 27) * 6;
        FP_INT y = Qmul30(a, AtanPoly5Lut8Table[offset + 0]);
        y = Qmul30(a, y + AtanPoly5Lut8Table[offset + 1]);
        y = Qmul30(a, y + AtanPoly5Lut8Table[offset + 2]);
        y = Qmul30(a, y + AtanPoly5Lut8Table[offset + 3]);
        y = Qmul30(a, y + AtanPoly5Lut8Table[offset + 4]);
        y = y + AtanPoly5Lut8Table[offset + 5];
        return y;
    }

    FP_INT AtanPoly3Lut8Table[] =
    {
        -351150132, -463916, 1073745980, 0,
        -289359685, -24349242, 1076929105, -145366,
        -192305259, -97257464, 1095342438, -1708411,
        -91138684, -210466171, 1137733496, -7020039,
        -8856969, -332956892, 1198647251, -17139451,
        46187514, -435267135, 1262120294, -30283758,
        76277334, -502284461, 1311919661, -42630181,
        88081006, -532824470, 1338273149, -50214826,
        0, 0, 0, 843314857 // Atan(1.0)
    };

    // Precision: 17.98 bits
    FP_INT AtanPoly3Lut8(FP_INT a)
    {
        FP_INT offset = (a >> 27) * 4;
        FP_INT y = Qmul30(a, AtanPoly3Lut8Table[offset + 0]);
        y = Qmul30(a, y + AtanPoly3Lut8Table[offset + 1]);
        y = Qmul30(a, y + AtanPoly3Lut8Table[offset + 2]);
        y = y + AtanPoly3Lut8Table[offset + 3];
        return y;
    }




    #undef FP_ASSERT
}
#endif // __FIXEDUTIL_H


================================================
FILE: lib/Graphics/PGEString.h
================================================
/*
 * Used for compatibiltiy of common code with both QString and std::string
 */
#ifndef PGEString_HHH
#define PGEString_HHH
#pragma once

#ifdef PGE_EDITOR
#include <QString>
#include <QStringList>
#include <QList>
typedef QString     PGEString;
typedef QStringList PGEStringList;
#define PGEList     QList
#define StdToPGEString(str)     QString::fromStdString(str)
#define PGEStringToStd(str)     (str).toStdString()
#define PGEStringLit(str)       QStringLiteral(str)
typedef int pge_size_t;
#else
#include <string>
#include <vector>
typedef std::string                 PGEString;
typedef std::vector<std::string>    PGEStringList;
#define PGEList                     std::vector
#define StdToPGEString(str)         (str)
#define PGEStringToStd(str)         (str)
#define PGEStringLit(str)
typedef size_t pge_size_t;
#endif

template <class T>
inline const T &pgeConstReference(const T &t)
{
    return t;
}

#endif /*PGEString_HHH*/


================================================
FILE: lib/Graphics/bitmask2rgba.c
================================================
/*
 * Bitmask to RGBA converter: allows to convert graphics with a front (image with
 * a black background) and mask (a dark shape of image on a white background)
 * into RGBA with a transparent background
 *
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include <FreeImageLite.h>

#include "bitmask2rgba.h"


void bitmask_to_rgba(FIBITMAP *front, FIBITMAP *mask)
{
    unsigned int x, y, ym, img_w, img_h, mask_w, mask_h, img_pitch, mask_pitch;

    BYTE *img_bits, *mask_bits, *FPixP, *SPixP;
    RGBQUAD Npix = {0x00, 0x00, 0x00, 0xFF};   /* Destination pixel color */
    BYTE Wpix[] = {0xFF, 0xFF, 0xFF, 0xFF};   /* Dummy white pixel */
    unsigned short newAlpha = 0xFF; /* Calculated destination alpha-value*/

    BOOL endOfY = FALSE;

    if(!mask)
        return; /* Nothing to do */

    img_w  = FreeImage_GetWidth(front);
    img_h  = FreeImage_GetHeight(front);
    img_pitch = FreeImage_GetPitch(front);
    mask_w = FreeImage_GetWidth(mask);
    mask_h = FreeImage_GetHeight(mask);
    mask_pitch = FreeImage_GetPitch(mask);

    img_bits  = FreeImage_GetBits(front);
    mask_bits = FreeImage_GetBits(mask);
    FPixP = img_bits;
    SPixP = mask_bits;

    ym = mask_h - 1;
    y = img_h - 1;

    while(1)
    {
        FPixP = img_bits + (img_pitch * y);
        if(!endOfY)
            SPixP = mask_bits + (mask_pitch * ym);

        for(x = 0; (x < img_w); x++)
        {
            Npix.rgbBlue = ((SPixP[FI_RGBA_BLUE] & 0x7F) | FPixP[FI_RGBA_BLUE]);
            Npix.rgbGreen = ((SPixP[FI_RGBA_GREEN] & 0x7F) | FPixP[FI_RGBA_GREEN]);
            Npix.rgbRed = ((SPixP[FI_RGBA_RED] & 0x7F) | FPixP[FI_RGBA_RED]);
            newAlpha = 255 - (((unsigned short)(SPixP[FI_RGBA_RED]) +
                               (unsigned short)(SPixP[FI_RGBA_GREEN]) +
                               (unsigned short)(SPixP[FI_RGBA_BLUE])) / 3);

            if((SPixP[FI_RGBA_RED] > 240u) //is almost White
               && (SPixP[FI_RGBA_GREEN] > 240u)
               && (SPixP[FI_RGBA_BLUE] > 240u))
                newAlpha = 0;

            newAlpha += (((unsigned short)(FPixP[FI_RGBA_RED]) +
                          (unsigned short)(FPixP[FI_RGBA_GREEN]) +
                          (unsigned short)(FPixP[FI_RGBA_BLUE])) / 3);

            if(newAlpha > 255)
                newAlpha = 255;

            FPixP[FI_RGBA_BLUE]  = Npix.rgbBlue;
            FPixP[FI_RGBA_GREEN] = Npix.rgbGreen;
            FPixP[FI_RGBA_RED]   = Npix.rgbRed;
            FPixP[FI_RGBA_ALPHA] = (BYTE)(newAlpha);
            FPixP += 4;

            if(x >= mask_w - 1 || endOfY)
                SPixP = Wpix;
            else
                SPixP += 4;
        }

        if(ym == 0)
        {
            endOfY = TRUE;
            SPixP = Wpix;
        }
        else
            ym--;

        if(y == 0)
            break;
        y--;
    }
}

void bitmask_get_mask_from_rgba(FIBITMAP *image, FIBITMAP **outmask)
{
    unsigned int img_w, img_h, x, y;
    RGBQUAD Fpix;
    RGBQUAD Npix = {0x0, 0x0, 0x0, 0xFF};
    BYTE gray;

    if(!image)
        *outmask = NULL;

    img_w = FreeImage_GetWidth(image);
    img_h = FreeImage_GetHeight(image);

    *outmask = FreeImage_AllocateT(FIT_BITMAP,
                                   (int)(img_w), (int)(img_h),
                                   (int)(FreeImage_GetBPP(image)),
                                   FreeImage_GetRedMask(image),
                                   FreeImage_GetGreenMask(image),
                                   FreeImage_GetBlueMask(image));

    for(y = 0; (y < img_h); y++)
    {
        for(x = 0; (x < img_w); x++)
        {
            FreeImage_GetPixelColor(image, x, y, &Fpix);

            gray = (255 - Fpix.rgbReserved);
            Npix.rgbRed  = gray;
            Npix.rgbGreen = gray;
            Npix.rgbBlue = gray;
            Npix.rgbReserved = 0xFF;
            FreeImage_SetPixelColor(*outmask,  x, y, &Npix);
        }
    }
}


================================================
FILE: lib/Graphics/bitmask2rgba.cmake
================================================
# message("Path to UTF8-Main is [${CMAKE_CURRENT_LIST_DIR}]")
include_directories(${CMAKE_CURRENT_LIST_DIR}/)

set(BITMASK2RGBA_SRCS ${CMAKE_CURRENT_LIST_DIR}/bitmask2rgba.c)



================================================
FILE: lib/Graphics/bitmask2rgba.h
================================================
/*
 * Bitmask to RGBA converter: allows to convert graphics with a front (image with
 * a black background) and mask (a dark shape of image on a white background)
 * into RGBA with a transparent background
 *
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */


#ifdef __cplusplus
extern "C" {
#endif

typedef struct FIBITMAP FIBITMAP;

/**
 * @brief Merge front and mask image into united RGBA image
 * @param [InOut] front
 * @param [In] mask
 */
extern void bitmask_to_rgba(FIBITMAP *front, FIBITMAP *mask);

/**
 * @brief Extract mask from RGBA image
 * @param [In] image RGBA image
 * @param [Out] outmask Output mask image
 */
extern void bitmask_get_mask_from_rgba(FIBITMAP *image, FIBITMAP **outmask);

#ifdef __cplusplus
}
#endif


================================================
FILE: lib/Graphics/graphics_funcs.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <array>

#include <SDL2/SDL_video.h>
#ifndef SDL_SDL_ASSERT_H
#   include "sdl_proxy/sdl_assert.h"
#endif

#include <Utils/files.h>
#ifdef THEXTECH_FILEMAPPER_SUPPORTED
#   include <FileMapper/file_mapper.h>
#endif

#include "graphics_funcs.h"
#include <Logger/logger.h>

#ifdef DEBUG_BUILD
#   include <Utils/elapsed_timer.h>
#endif

#include "image_size.h"

//#include <common_features/engine_resources.h>

#ifdef _WIN32
#   include <SDL2/SDL_syswm.h>
#endif
#include <FreeImageLite.h>

static unsigned DLL_CALLCONV
_RWopsReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
    return (unsigned)SDL_RWread ((SDL_RWops *)handle, buffer, size, count);
}

static unsigned DLL_CALLCONV
_RWopsWriteProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
    return (unsigned)SDL_RWwrite((SDL_RWops *)handle, buffer, size, count);
}

static int DLL_CALLCONV
_RWopsSeekProc(fi_handle handle, long offset, int origin) {
    int use_origin = origin;

    if(origin == SEEK_CUR)
        use_origin = RW_SEEK_CUR;
    else if(origin == SEEK_SET)
        use_origin = RW_SEEK_SET;
    else if(origin == SEEK_END)
        use_origin = RW_SEEK_END;

    return SDL_RWseek((SDL_RWops *)handle, offset, use_origin);
}

static long DLL_CALLCONV
_RWopsTellProc(fi_handle handle) {
    return SDL_RWseek((SDL_RWops *)handle, 0, RW_SEEK_CUR);
}

// strangely undocumented import necessary to use the FreeImage handle functions
extern void SetDefaultIO(FreeImageIO *io);

void GraphicsHelps::initFreeImage()
{
    FreeImage_Initialise();
}

void GraphicsHelps::closeFreeImage()
{
    FreeImage_DeInitialise();
}

void GraphicsHelps::SetRWopsIO(FreeImageIO *io) {
    io->read_proc  = _RWopsReadProc;
    io->seek_proc  = _RWopsSeekProc;
    io->tell_proc  = _RWopsTellProc;
    io->write_proc = _RWopsWriteProc;
}

FIBITMAP *GraphicsHelps::loadImage(const std::string &file, bool convertTo32bit)
{
#ifdef DEBUG_BUILD
    ElapsedTimer loadingTime;
    ElapsedTimer fReadTime;
    ElapsedTimer imgConvTime;
    loadingTime.start();
    fReadTime.start();
#endif

    // disabled filemapper because it does not support archive contents
#if 0 // #if defined(THEXTECH_FILEMAPPER_SUPPORTED)
    FileMapper fileMap;

    if(!fileMap.open_file(file))
        return nullptr;

    FIMEMORY *imgMEM = FreeImage_OpenMemory(reinterpret_cast<unsigned char *>(fileMap.data()),
                                            static_cast<unsigned int>(fileMap.size()));
    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);

    if(formato  == FIF_UNKNOWN)
        return nullptr;

    FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);
    FreeImage_CloseMemory(imgMEM);
    fileMap.close_file();

    if(!img)
        return nullptr;

#else
    FreeImageIO io;
    SetRWopsIO(&io);
    SDL_RWops *handle = Files::open_file(file, "rb");

    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)handle);

    if(formato == FIF_UNKNOWN)
    {
        SDL_RWclose(handle);
        return NULL;
    }

    FIBITMAP *img = FreeImage_LoadFromHandle(formato, &io, (fi_handle)handle);

    SDL_RWclose(handle);

    if(!img)
        return NULL;

#endif
#ifdef DEBUG_BUILD
    long long fReadTimeElapsed = static_cast<long long>(fReadTime.nanoelapsed());
    long long imgConvertElapsed = 0;
#endif

    if(convertTo32bit && (FreeImage_GetBPP(img) != 32))
    {
#ifdef DEBUG_BUILD
        imgConvTime.start();
#endif
        FIBITMAP *temp = nullptr;

#ifdef THEXTECH_WIP_FEATURES
        temp = fastConvertTo32Bit(img);
#endif

        if(!temp)
            temp = FreeImage_ConvertTo32Bits(img);

        FreeImage_Unload(img);

        if(!temp)
            return nullptr;

        img = temp;
#ifdef DEBUG_BUILD
        imgConvertElapsed = static_cast<long long>(imgConvTime.nanoelapsed());
#endif
    }

#ifdef DEBUG_BUILD
    D_pLogDebug("File read of texture %s passed in %d nanoseconds", file.c_str(), static_cast<int>(fReadTimeElapsed));
    D_pLogDebug("Conv to 32-bit of %s passed in %d nanoseconds", file.c_str(), static_cast<int>(imgConvertElapsed));
    D_pLogDebug("Total Loading of image %s passed in %d nanoseconds", file.c_str(), static_cast<int>(loadingTime.nanoelapsed()));
#endif
    return img;
}

FIBITMAP *GraphicsHelps::loadImage(const Files::Data &raw, bool convertTo32bit)
{
    FIMEMORY *imgMEM = FreeImage_OpenMemory(const_cast<unsigned char*>(raw.begin()),
                                            static_cast<unsigned int>(raw.size()));
    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);

    if(formato  == FIF_UNKNOWN)
        return nullptr;

    FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);
    FreeImage_CloseMemory(imgMEM);

    if(!img)
        return nullptr;

    if(convertTo32bit && (FreeImage_GetBPP(img) != 32))
    {
        FIBITMAP *temp = nullptr;

#ifdef THEXTECH_WIP_FEATURES
        temp = fastConvertTo32Bit(img);
#endif

        if(!temp)
            temp = FreeImage_ConvertTo32Bits(img);

        FreeImage_Unload(img);

        if(!temp)
            return nullptr;
        img = temp;
    }

    return img;
}

FIBITMAP *GraphicsHelps::loadMask(const std::string &file, bool maskIsPng, bool convertTo32bit)
{
    FIBITMAP *mask;

    if(file.empty())
        return nullptr; //Nothing to do
    mask = loadImage(file, convertTo32bit);

    if(!mask)
        return nullptr;//Nothing to do

    // this is the main reason that we have a separate call: extract a bitmask from a PNG RGBA image
    if(maskIsPng)
        RGBAToMask(mask);

    return mask;
}

FIBITMAP *GraphicsHelps::loadMask(const Files::Data &raw, bool maskIsPng, bool convertTo32bit)
{
    FIBITMAP *mask;

    if(raw.empty())
        return nullptr; //Nothing to do
    mask = loadImage(raw, convertTo32bit);

    if(!mask)
        return nullptr;//Nothing to do

    // this is the main reason that we have a separate call: extract a bitmask from a PNG RGBA image
    if(maskIsPng)
        RGBAToMask(mask);

    return mask;
}

//FIBITMAP *GraphicsHelps::loadImageRC(const char *file)
//{
//    unsigned char *memory = nullptr;
//    size_t fileSize = 0;
//    SDL_assert_release(RES_getMem(file, memory, fileSize));
//    //{
//        //pLogCritical("Resource file \"%s\" is not found!", file);
//        //return nullptr;
//    //}
//
//    FIMEMORY *imgMEM = FreeImage_OpenMemory(memory, static_cast<FI_DWORD>(fileSize));
//    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);
//
//    if(formato == FIF_UNKNOWN)
//        return nullptr;
//
//    FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);
//    FreeImage_CloseMemory(imgMEM);
//
//    if(!img)
//        return nullptr;
//
//    FIBITMAP *temp;
//    temp = FreeImage_ConvertTo32Bits(img);
//
//    if(!temp)
//        return nullptr;
//
//    FreeImage_Unload(img);
//    img = temp;
//    return img;
//}

void GraphicsHelps::closeImage(FIBITMAP *img)
{
    FreeImage_Unload(img);
}

void GraphicsHelps::RGBAToMask(FIBITMAP *mask)
{
    if(!mask)
        return;

    // convert alpha channel to luminance
    unsigned int img_w  = FreeImage_GetWidth(mask);
    unsigned int img_h  = FreeImage_GetHeight(mask);

    uint8_t *pixel_data = reinterpret_cast<uint8_t*>(FreeImage_GetBits(mask));
    auto dest_px_stride = static_cast<uint32_t>(FreeImage_GetPitch(mask));

    for(unsigned int y = 0; (y < img_h); y++)
    {
        for(unsigned int x = 0; (x < img_w); x++)
        {
            uint8_t* pixel = &pixel_data[dest_px_stride * y + 4 * x];

            uint8_t grey = 0xFF - pixel[3];
            pixel[0] = grey;
            pixel[1] = grey;
            pixel[2] = grey;
            pixel[3] = 0xFF;
        }
    }
}

SDL_Surface *GraphicsHelps::fi2sdl(FIBITMAP *img)
{
    int h = static_cast<int>(FreeImage_GetHeight(img));
    int w = static_cast<int>(FreeImage_GetWidth(img));
    FreeImage_FlipVertical(img);
    SDL_Surface *surf = SDL_CreateRGBSurfaceFrom(FreeImage_GetBits(img),
                        w, h, 32, w * 4, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, FI_RGBA_ALPHA_MASK);
    return surf;
}

void GraphicsHelps::mergeWithMask(FIBITMAP *image,
                                  const std::string &pathToMask,
                                  const std::string &pathToMaskFallback)
{
    if(!image)
        return;

    if(!Files::fileExists(pathToMask) && pathToMaskFallback.empty())
        return; //Nothing to do

    FIBITMAP *mask = pathToMask.empty() ? nullptr : loadImage(pathToMask, true);
    if(!mask && !pathToMaskFallback.empty())
    {
        mask = loadImage(pathToMaskFallback, true);
        RGBAToMask(mask);
    }

    if(!mask)
        return;//Nothing to do

    mergeWithMask(image, mask);

    FreeImage_Unload(mask);
}

void GraphicsHelps::mergeWithMask(FIBITMAP *image, const Files::Data &maskRaw, bool maskIsPng)
{
    if(!image)
        return;

    if(maskRaw.empty())
        return; //Nothing to do

    FIBITMAP *mask = loadImage(maskRaw, true);

    if(!mask)
        return;//Nothing to do

    if(maskIsPng)
        RGBAToMask(mask);

    mergeWithMask(image, mask);

    FreeImage_Unload(mask);
}


static RGBQUAD s_bitblitBG = {0, 0, 0, 0xFF};

void GraphicsHelps::mergeWithMask(FIBITMAP *image, FIBITMAP *mask)
{
    unsigned int img_w = FreeImage_GetWidth(image);
    unsigned int img_h = FreeImage_GetHeight(image);
    unsigned int img_pitch = FreeImage_GetPitch(image);
    unsigned int mask_w = FreeImage_GetWidth(mask);
    unsigned int mask_h = FreeImage_GetHeight(mask);
    unsigned int mask_pitch = FreeImage_GetPitch(mask);
    BYTE *img_bits  = FreeImage_GetBits(image);
    BYTE *mask_bits = FreeImage_GetBits(mask);
    BYTE *FPixP = nullptr;
    BYTE *SPixP = mask_bits;
    RGBQUAD Npix = {0x00, 0x00, 0x00, 0xFF};   //Destination pixel color
    BYTE Wpix[] = {0xFF, 0xFF, 0xFF, 0xFF};   //Dummy white pixel
    unsigned short newAlpha = 0xFF; //Calculated destination alpha-value

    bool endOfY = false;
    unsigned int ym = mask_h - 1;
    unsigned int y = img_h - 1;

    while(1)
    {
        FPixP = img_bits + (img_pitch * y);
        if(!endOfY)
            SPixP = mask_bits + (mask_pitch * ym);

        for(unsigned int x = 0; (x < img_w); x++)
        {
            Npix.rgbBlue = ((SPixP[FI_RGBA_BLUE] & s_bitblitBG.rgbBlue) | FPixP[FI_RGBA_BLUE]);
            Npix.rgbGreen = ((SPixP[FI_RGBA_GREEN] & s_bitblitBG.rgbGreen) | FPixP[FI_RGBA_GREEN]);
            Npix.rgbRed = ((SPixP[FI_RGBA_RED] & s_bitblitBG.rgbRed) | FPixP[FI_RGBA_RED]);

            // these terms (mask pixel and not front pixel, bitwise) represent the values that could be seen in SMBX 1.3
            newAlpha = 255 - ((static_cast<unsigned short>(SPixP[FI_RGBA_RED] & ~FPixP[FI_RGBA_RED]) +
                               static_cast<unsigned short>(SPixP[FI_RGBA_GREEN] & ~FPixP[FI_RGBA_GREEN]) +
                               static_cast<unsigned short>(SPixP[FI_RGBA_BLUE] & ~FPixP[FI_RGBA_BLUE])) / 3);

            if(newAlpha < 16)
                newAlpha = 0;

            if(newAlpha > 240)
                newAlpha = 255;

            FPixP[FI_RGBA_BLUE]  = Npix.rgbBlue;
            FPixP[FI_RGBA_GREEN] = Npix.rgbGreen;
            FPixP[FI_RGBA_RED]   = Npix.rgbRed;
            FPixP[FI_RGBA_ALPHA] = static_cast<BYTE>(newAlpha);
            FPixP += 4;

            if(x >= mask_w - 1 || endOfY)
                SPixP = Wpix;
            else
                SPixP += 4;
        }

        if(ym == 0)
        {
            endOfY = true;
            SPixP = Wpix;
        }
        else
            ym--;

        if(y == 0)
            break;
        y--;
    }
}

void GraphicsHelps::setBitBlitBG(uint8_t red, uint8_t green, uint8_t blue)
{
    s_bitblitBG.rgbRed = red;
    s_bitblitBG.rgbGreen = green;
    s_bitblitBG.rgbBlue = blue;
}

void GraphicsHelps::resetBitBlitBG()
{
    s_bitblitBG.rgbRed = 0;
    s_bitblitBG.rgbGreen = 0;
    s_bitblitBG.rgbBlue = 0;
}

void GraphicsHelps::replaceColor(FIBITMAP* image, const PGE_Pix& src, const PGE_Pix& dst)
{
    if(!image)
        return;

    unsigned int img_w = FreeImage_GetWidth(image);
    unsigned int img_h = FreeImage_GetHeight(image);
    unsigned int img_pitch = FreeImage_GetPitch(image);

    BYTE *img_bits  = FreeImage_GetBits(image);
    BYTE *FPixP = nullptr;

    for(unsigned int y = 0; y < img_h; ++y)
    {
        FPixP = img_bits + (img_pitch * y);

        for(unsigned int x = 0; (x < img_w); ++x)
        {
            if(FPixP[FI_RGBA_GREEN] == src.g &&
               FPixP[FI_RGBA_BLUE] == src.b &&
               FPixP[FI_RGBA_RED] == src.a &&
               FPixP[FI_RGBA_ALPHA] == src.a)
            {
                FPixP[FI_RGBA_RED]   = dst.r;
                FPixP[FI_RGBA_GREEN] = dst.g;
                FPixP[FI_RGBA_BLUE]  = dst.b;
                FPixP[FI_RGBA_ALPHA] = dst.a;
            }
            FPixP += 4;
        }
    }
}

bool GraphicsHelps::getImageMetrics(const std::string &imageFile, PGE_Size* imgSize)
{
    if(!imgSize)
        return false;

    int errorCode;
    uint32_t w, h;

    if(!PGE_ImageInfo::getImageSize(imageFile, &w, &h, &errorCode))
        return false;

    imgSize->setSize(int(w), int(h));
    return true;
}

void GraphicsHelps::getMaskedImageInfo(const std::string &rootDir,
                                       const std::string &in_imgName,
                                       std::string& out_maskName,
                                       std::string& out_errStr,
                                       PGE_Size* imgSize)
{
    if(in_imgName.empty())
    {
        out_errStr = "Image filename isn't defined";
        return;
    }

    int errorCode;
    uint32_t w, h;

    if(!PGE_ImageInfo::getImageSize(rootDir + in_imgName, &w, &h, &errorCode))
    {
        switch(errorCode)
        {
        default:
        case PGE_ImageInfo::ERR_UNKNOWN:
            out_errStr = "Unknown error has occurred: " + rootDir + in_imgName;
            break;

        case PGE_ImageInfo::ERR_UNSUPPORTED_FILETYPE:
            out_errStr = "Unsupported or corrupted file format: " + rootDir + in_imgName;
            break;

        case PGE_ImageInfo::ERR_NOT_EXISTS:
            out_errStr = "image file is not exist: " + rootDir + in_imgName;
            break;

        case PGE_ImageInfo::ERR_CANT_OPEN:
            out_errStr = "Can't open image file: " + rootDir + in_imgName;
            break;
        }

        return;
    }

    out_maskName = PGE_ImageInfo::getMaskName(in_imgName);
    out_errStr = "";

    if(imgSize)
    {
        imgSize->setWidth(int(w));
        imgSize->setHeight(int(h));
    }
}

bool GraphicsHelps::validateFor2xScaleDown(FIBITMAP *image, const std::string &origPath)
{
    if(!image)
        return false;

    (void)origPath; // supress warning when build the release build

    SDL_assert_release(FreeImage_GetBPP(image) == 32);
    if(FreeImage_GetBPP(image) != 32)
        return false;

    auto w = static_cast<uint32_t>(FreeImage_GetWidth(image));
    auto h = static_cast<uint32_t>(FreeImage_GetHeight(image));
    const uint32_t *img_pixels = reinterpret_cast<uint32_t*>(FreeImage_GetBits(image));
    auto pitch_px = static_cast<uint32_t>(FreeImage_GetPitch(image)) / 4;

    if(w % 2 || h % 2)
    {
        D_pLogWarning("Texture can't be shrank, non-multiple size: %" PRIu32 " x %" PRIu32 " (%s)", w, h, origPath.c_str());
        return false; // Not multiple two!
    }

    for(uint32_t y = 0; y < h; y += 2)
    {
        for(uint32_t x = 0; x < w; x += 2)
        {
            if(img_pixels[y * pitch_px + x] != img_pixels[y * pitch_px + (x + 1)]
                || img_pixels[y * pitch_px + x] != img_pixels[(y + 1) * pitch_px + x]
                || img_pixels[y * pitch_px + x] != img_pixels[(y + 1) * pitch_px + (x + 1)])
            {
                D_pLogWarning("Texture can't be shrank: Pixel colors at the %" PRIu32 " x %" PRIu32 " sector (2x2 square) aren't equal (%s)", x, y, origPath.c_str());
                return false;
            }
        }
    }

    D_pLogDebug("Texture CAN be shrank (%s)", origPath.c_str());
    return true;
}

FIBITMAP *GraphicsHelps::fast2xScaleDown(FIBITMAP *image)
{
    if(!image)
        return nullptr;

    if(FreeImage_GetBPP(image) != 32)
        return nullptr;

    auto src_w = static_cast<uint32_t>(FreeImage_GetWidth(image));
    auto src_h = static_cast<uint32_t>(FreeImage_GetHeight(image));
    const uint32_t *src_pixels  = reinterpret_cast<uint32_t*>(FreeImage_GetBits(image));
    auto src_pitch_px = static_cast<uint32_t>(FreeImage_GetPitch(image)) / 4;

    auto dest_w = src_w / 2;
    auto dest_h = src_h / 2;

    FIBITMAP *dest = FreeImage_Allocate(dest_w, dest_h, 32);

    if(!dest)
        return nullptr;

    uint32_t *dest_pixels  = reinterpret_cast<uint32_t*>(FreeImage_GetBits(dest));
    auto dest_pitch_px = static_cast<uint32_t>(FreeImage_GetPitch(dest)) / 4;

    for(uint32_t src_y = 0, dest_y = 0; dest_y < dest_h; src_y += 2, dest_y += 1)
    {
        for(uint32_t src_x = 0, dest_x = 0; dest_x < dest_w; src_x += 2, dest_x += 1)
        {
            dest_pixels[dest_y * dest_pitch_px + dest_x] = src_pixels[src_y * src_pitch_px + src_x];
        }
    }

    return dest;
}

FIBITMAP *GraphicsHelps::fastConvertTo32Bit(FIBITMAP *image)
{
    // two kilobytes of stack isn't affordable? make these static, then.

    // palette for high nybble (ignores low nybble)
    std::array<uint32_t, 256> palette_high;

    // palette for low nybble (ignores high nybble)
    std::array<uint32_t, 256> palette_low;


    if(!image)
        return nullptr;

    if(FreeImage_GetBPP(image) != 1 && FreeImage_GetBPP(image) != 4 && FreeImage_GetBPP(image) != 8)
        return nullptr;

    auto src_w = static_cast<uint32_t>(FreeImage_GetWidth(image));
    auto src_h = static_cast<uint32_t>(FreeImage_GetHeight(image));
    const uint8_t *src_pixels  = reinterpret_cast<uint8_t*>(FreeImage_GetBits(image));
    const uint32_t *src_palette = reinterpret_cast<uint32_t*>(FreeImage_GetPalette(image));
    const uint8_t *src_trans = reinterpret_cast<uint8_t*>(FreeImage_GetTransparencyTable(image));
    auto src_pitch = static_cast<uint32_t>(FreeImage_GetPitch(image));

    FIBITMAP *dest = FreeImage_Allocate(src_w, src_h, 32);

    if(!dest)
        return nullptr;

    uint32_t *dest_pixels  = reinterpret_cast<uint32_t*>(FreeImage_GetBits(dest));
    auto dest_pitch_px = static_cast<uint32_t>(FreeImage_GetPitch(dest)) / 4;

    // special logic for 1 BPP
    if(FreeImage_GetBPP(image) == 1)
    {
        // fill first two entries
        for(int i = 0; i < 2; i++)
        {
            palette_high[i] = src_palette[i];

            if(src_trans)
                ((uint8_t*)&palette_high[i])[3] = src_trans[i];
            else
                ((uint8_t*)&palette_high[i])[3] = 255;
        }

        // perform lookups
        for(uint32_t y = 0; y < src_h; y++)
        {
            for(uint32_t x = 0; x < src_w; x++)
            {
                uint8_t which_bit = 128 >> (x % 8);
                bool lit = src_pixels[y * src_pitch + x / 8] & which_bit;
                dest_pixels[y * dest_pitch_px + x] = palette_high[lit];
            }
        }

        return dest;
    }

    if(FreeImage_GetBPP(image) == 8)
    {
        for(int i = 0; i < 256; i++)
        {
            palette_high[i] = src_palette[i];

            if(src_trans)
                ((uint8_t*)&palette_high[i])[3] = src_trans[i];
            else
                ((uint8_t*)&palette_high[i])[3] = 255;
        }

        for(uint32_t y = 0; y < src_h; y++)
        {
            for(uint32_t x = 0; x < src_w; x++)
            {
                dest_pixels[y * dest_pitch_px + x] = palette_high[src_pixels[y * src_pitch + x]];
            }
        }
    }
    else
    {
        // fill low and high nybble palettes
        for(int i = 0; i < 16; i++)
        {
            for(int j = 0; j < 16; j++)
            {
                palette_high[i * 16 + j] = src_palette[i];
                if(src_trans)
                    ((uint8_t*)&palette_high[i * 16 + j])[3] = src_trans[i];
                else
                    ((uint8_t*)&palette_high[i * 16 + j])[3] = 255;

                palette_low[i * 16 + j] = src_palette[j];
                if(src_trans)
                    ((uint8_t*)&palette_low[i * 16 + j])[3] = src_trans[j];
                else
                    ((uint8_t*)&palette_low[i * 16 + j])[3] = 255;
            }
        }

        for(uint32_t y = 0; y < src_h; y++)
        {
            for(uint32_t x = 0; x < src_w - 1; x += 2)
            {
                dest_pixels[y * dest_pitch_px + x] = palette_high[src_pixels[y * src_pitch + (x / 2)]];
                dest_pixels[y * dest_pitch_px + x + 1] = palette_low[src_pixels[y * src_pitch + (x / 2)]];
            }

            if(src_w % 2)
                dest_pixels[y * dest_pitch_px + src_w - 1] = palette_high[src_pixels[y * src_pitch + (src_w / 2)]];
        }
    }

    return dest;
}

bool GraphicsHelps::validateBitmaskRequired(FIBITMAP *image, FIBITMAP *mask, const std::string &origPath)
{
    if(!image || !mask)
        return false;

    (void)origPath; // supress warning when build the release build

    auto fw = static_cast<uint32_t>(FreeImage_GetWidth(image));
    auto fh = static_cast<uint32_t>(FreeImage_GetHeight(image));
    auto fpitch = static_cast<uint32_t>(FreeImage_GetPitch(image));
    BYTE *fimg_bits  = FreeImage_GetBits(image);

    auto bw = static_cast<uint32_t>(FreeImage_GetWidth(mask));
    auto bh = static_cast<uint32_t>(FreeImage_GetHeight(mask));
    auto bpitch = static_cast<uint32_t>(FreeImage_GetPitch(mask));
    BYTE *bimg_bits  = FreeImage_GetBits(mask);

    BYTE *line1 = fimg_bits;
    BYTE *line2 = bimg_bits;

    int blend_bits = 0;

    BYTE fp_default[4] = {0, 0, 0, 0};
    BYTE bp_default[4] = {255, 255, 255, 255};

    for(uint32_t y = 0; y < fh || y < bh; ++y)
    {
        for(uint32_t x = 0; x < fw || x < bw; ++x)
        {
            bool bp_present = y < bh && x < bw;
            bool fp_present = y < fh && x < fw;

            BYTE *fp = line1 + (y * fpitch) + (x * 4);
            BYTE *bp = line2 + (y * bpitch) + (x * 4);

            if(!fp_present)
                fp = fp_default;

            if(!bp_present)
                bp = bp_default;

            // accept vanilla GIFs that target 16-bit color depth
            // note that missing back pixels are white and absent front pixels are black
            bool bp_is_white = bp[0] >= 0xf0 && bp[1] >= 0xf0 && bp[2] >= 0xf0;
            bool fp_is_black = fp[0] <  0x10 && fp[1] <  0x10 && fp[2] <  0x10;

            // back pixel is white and front pixel is black: buffer preserved
            if(bp_is_white && fp_is_black)
                continue;

            // front contains back: buffer replaced with front pixel
            // (this subsumes mask pixel black, front pixel white, and matching cases)
            if((bp[0] & ~fp[0] & 0xf8) == 0 && (bp[1] & ~fp[1] & 0xf8) == 0 && (bp[2] & ~fp[2] & 0xf8) == 0)
                continue;

            blend_bits += (bp[0] & ~fp[0]) / 0x08;
            blend_bits += (bp[1] & ~fp[1]) / 0x08;
            blend_bits += (bp[2] & ~fp[2]) / 0x08;
        }
    }

    if(blend_bits >= 10000)
    {
        D_pLogDebug("Texture REQUIRES the bitmask render (%s)", origPath.c_str());
        return true;
    }
    else
    {
        D_pLogDebug("Texture doesn't require bitmask render (%s)", origPath.c_str());
        return false;
    }
}

bool GraphicsHelps::validateForDepthTest(FIBITMAP *image, const std::string &origPath)
{
    if(!image)
        return false;

    (void)origPath; // supress warning when build the release build

    auto w = static_cast<uint32_t>(FreeImage_GetWidth(image));
    auto h = static_cast<uint32_t>(FreeImage_GetHeight(image));
    auto pitch = static_cast<uint32_t>(FreeImage_GetPitch(image));
    BYTE *img_bits  = FreeImage_GetBits(image);

    for(uint32_t y = 0; y < h; ++y)
    {
        for(uint32_t x = 0; x < w; ++x)
        {
            BYTE *alpha = img_bits + (y * pitch) + (x * 4) + 3;

            // vanilla game used 5 bits per channel, so we set the alpha test as >= 0x08
            if(*alpha < 0x08 || *alpha >= 0xf8)
                continue;

            D_pLogDebug("Texture CANNOT use depth test (%s)", origPath.c_str());
            return false;
        }
    }

    D_pLogDebug("Texture can use depth test (%s)", origPath.c_str());
    return true;
}

FIBITMAP *GraphicsHelps::fastScaleDownAnd32Bit(FIBITMAP *image, bool do_scale_down)
{
    // one kilobytes of stack isn't affordable? make this static, then.

    // palette for full byte or high nybble (ignores low nybble if 4bpp)
    std::array<uint32_t, 256> palette;


    if(!image)
        return nullptr;

    if(!do_scale_down)
        return fastConvertTo32Bit(image);

    if(FreeImage_GetBPP(image) == 32)
        return fast2xScaleDown(image);

    if(FreeImage_GetBPP(image) != 1 && FreeImage_GetBPP(image) != 4 && FreeImage_GetBPP(image) != 8 && FreeImage_GetBPP(image) != 24)
        return nullptr;

    auto src_w = static_cast<uint32_t>(FreeImage_GetWidth(image));
    auto src_h = static_cast<uint32_t>(FreeImage_GetHeight(image));
    const uint8_t *src_pixels  = reinterpret_cast<uint8_t*>(FreeImage_GetBits(image));
    const uint32_t *src_palette = reinterpret_cast<uint32_t*>(FreeImage_GetPalette(image));
    const uint8_t *src_trans = reinterpret_cast<uint8_t*>(FreeImage_GetTransparencyTable(image));

    auto src_stride = static_cast<uint32_t>(FreeImage_GetPitch(image)) * 2;
    auto src_pixel_stride = (FreeImage_GetBPP(image) == 8) ? 2 : 1;

    auto dest_w = src_w / 2;
    auto dest_h = src_h / 2;

    FIBITMAP *dest = FreeImage_Allocate(dest_w, dest_h, 32);

    if(!dest)
        return nullptr;

    uint32_t *dest_pixels = reinterpret_cast<uint32_t*>(FreeImage_GetBits(dest));
    auto dest_px_stride = static_cast<uint32_t>(FreeImage_GetPitch(dest)) / 4;

    // special logic for 1 BPP
    if(FreeImage_GetBPP(image) == 1)
    {
        // fill first two entries
        for(int i = 0; i < 2; i++)
        {
            palette[i] = src_palette[i];

            if(src_trans)
                ((uint8_t*)&palette[i])[3] = src_trans[i];
            else
                ((uint8_t*)&palette[i])[3] = 255;
        }

        // perform lookups
        for(uint32_t y = 0; y < dest_h; y++)
        {
            for(uint32_t x = 0; x < dest_w; x++)
            {
                uint8_t which_bit = 64 >> ((x % 4) * 2);
                bool lit = src_pixels[y * src_stride + x / 4] & which_bit;
                dest_pixels[y * dest_px_stride + x] = palette[lit];
            }
        }

        return dest;
    }

    // special logic for 24 BPP
    if(FreeImage_GetBPP(image) == 24)
    {
        src_pixel_stride = 6;
        uint8_t* dest_pixel_components = reinterpret_cast<uint8_t*>(dest_pixels);

        for(uint32_t y = 0; y < dest_h; y++)
        {
            for(uint32_t x = 0; x < dest_w; x++)
            {
                dest_pixel_components[(y * dest_px_stride + x) * 4 + 0] = src_pixels[y * src_stride + x * src_pixel_stride + 0];
                dest_pixel_components[(y * dest_px_stride + x) * 4 + 1] = src_pixels[y * src_stride + x * src_pixel_stride + 1];
                dest_pixel_components[(y * dest_px_stride + x) * 4 + 2] = src_pixels[y * src_stride + x * src_pixel_stride + 2];
                dest_pixel_components[(y * dest_px_stride + x) * 4 + 3] = 255;
            }
        }

        return dest;
    }

    // fill palette
    if(FreeImage_GetBPP(image) == 8)
    {
        for(int i = 0; i < 256; i++)
        {
            palette[i] = src_palette[i];

            if(src_trans)
                ((uint8_t*)&palette[i])[3] = src_trans[i];
            else
                ((uint8_t*)&palette[i])[3] = 255;
        }
    }
    else if(FreeImage_GetBPP(image) == 4)
    {
        // fill high nybble palettes
        for(int i = 0; i < 16; i++)
        {
            for(int j = 0; j < 16; j++)
            {
                palette[i * 16 + j] = src_palette[i];
                if(src_trans)
                    ((uint8_t*)&palette[i * 16 + j])[3] = src_trans[i];
                else
                    ((uint8_t*)&palette[i * 16 + j])[3] = 255;
            }
        }
    }

    // perform lookups
    for(uint32_t y = 0; y < dest_h; y++)
    {
        for(uint32_t x = 0; x < dest_w; x++)
        {
            dest_pixels[y * dest_px_stride + x] = palette[src_pixels[y * src_stride + x * src_pixel_stride]];
        }
    }

    return dest;
}

static uint16_t s_RGB24_to_RGB565(uint32_t RGB24)
{
#ifdef __WII__
    uint16_t r = ((uint8_t*)(&RGB24))[0];
    uint16_t g = ((uint8_t*)(&RGB24))[1];
    uint16_t b = ((uint8_t*)(&RGB24))[2];
#else
    uint16_t r = ((uint8_t*)(&RGB24))[2];
    uint16_t g = ((uint8_t*)(&RGB24))[1];
    uint16_t b = ((uint8_t*)(&RGB24))[0];
#endif

    return ((r >> 3) << FI16_565_RED_SHIFT) | ((g >> 2) << FI16_565_GREEN_SHIFT) | ((b >> 3) << FI16_565_BLUE_SHIFT);
}

FIBITMAP *GraphicsHelps::fastConvertToRGB565AndFlip(FIBITMAP *image, bool /*unused*/)
{
    // one kilobytes of stack isn't affordable? make this static, then.

    // palette for full bytes
    std::array<uint16_t, 256> palette;


    if(!image)
        return nullptr;

    if(FreeImage_GetBPP(image) != 1 && FreeImage_GetBPP(image) != 8)
        return nullptr;


    auto src_w = static_cast<uint32_t>(FreeImage_GetWidth(image));
    auto src_h = static_cast<uint32_t>(FreeImage_GetHeight(image));
    const uint8_t *src_pixels  = reinterpret_cast<uint8_t*>(FreeImage_GetBits(image));
    const uint32_t *src_palette = reinterpret_cast<uint32_t*>(FreeImage_GetPalette(image));
    auto src_stride = static_cast<uint32_t>(FreeImage_GetPitch(image));

    FIBITMAP *dest = FreeImage_Allocate(src_w, src_h, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);

    if(!dest)
        return nullptr;

    uint16_t *dest_pixels  = reinterpret_cast<uint16_t*>(FreeImage_GetBits(dest));
    auto dest_px_stride = static_cast<uint32_t>(FreeImage_GetPitch(dest)) / 2;

    // special logic for 1 BPP
    if(FreeImage_GetBPP(image) == 1)
    {
        // fill first two entries
        for(int i = 0; i < 2; i++)
            palette[i] = s_RGB24_to_RGB565(src_palette[i]);

        // perform lookups
        for(uint32_t y = 0; y < src_h; y++)
        {
            int src_y = src_h - (y + 1);
            for(uint32_t x = 0; x < src_w; x++)
            {
                uint8_t which_bit = 128 >> (x % 8);
                bool lit = src_pixels[src_y * src_stride + x / 8] & which_bit;
                dest_pixels[y * dest_px_stride + x] = palette[lit];
            }
        }

        return dest;
    }

    // fill 8-bit palette
    for(int i = 0; i < 256; i++)
        palette[i] = s_RGB24_to_RGB565(src_palette[i]);

    // perform lookups
    for(uint32_t y = 0; y < src_h; y++)
    {
        int src_y = src_h - (y + 1);
        for(uint32_t x = 0; x < src_w; x++)
        {
            dest_pixels[y * dest_px_stride + x] = palette[src_pixels[src_y * src_stride + x]];
        }
    }

    return dest;
}

bool GraphicsHelps::setWindowIcon(SDL_Window *window, FIBITMAP *img, int iconSize)
{
#if defined(_WIN32) && !defined(THEXTECH_WINRT)
    struct SDL_SysWMinfo wmInfo;
    SDL_VERSION(&wmInfo.version)

    if(SDL_FALSE == SDL_GetWindowWMInfo(window, &wmInfo))
        return false;

    if(wmInfo.subsystem != SDL_SYSWM_WINDOWS)
        return false;

    HWND windowH = wmInfo.info.win.window;
    HICON hicon = nullptr;
    BYTE *icon_bmp = nullptr;
    unsigned int icon_len, y;
    SDL_RWops *dst;
    unsigned int w = FreeImage_GetWidth(img);
    unsigned int h = FreeImage_GetWidth(img);
    Uint8 *bits = (Uint8 *)FreeImage_GetBits(img);
    unsigned int pitch = FreeImage_GetPitch(img);
    /* Create temporary bitmap buffer */
    icon_len = 40 + h * w * 4;
    icon_bmp = SDL_stack_alloc(BYTE, icon_len);
    dst = SDL_RWFromMem(icon_bmp, icon_len);

    if(!dst)
    {
        SDL_stack_free(icon_bmp);
        return false;
    }

    /* Write the BITMAPINFO header */
    SDL_WriteLE32(dst, 40);
    SDL_WriteLE32(dst, w);
    SDL_WriteLE32(dst, h * 2);
    SDL_WriteLE16(dst, 1);
    SDL_WriteLE16(dst, 32);
    SDL_WriteLE32(dst, BI_RGB);
    SDL_WriteLE32(dst, h * w * 4);
    SDL_WriteLE32(dst, 0);
    SDL_WriteLE32(dst, 0);
    SDL_WriteLE32(dst, 0);
    SDL_WriteLE32(dst, 0);
    y = 0;

    do
    {
        Uint8 *src = bits + y * pitch;
        SDL_RWwrite(dst, src, pitch, 1);
    }
    while(++y < h);

    hicon = CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
    SDL_RWclose(dst);
    SDL_stack_free(icon_bmp);
    /* Set the icon for the window */
    SendMessage(windowH, WM_SETICON, (iconSize < 32) ? ICON_SMALL : ICON_BIG, (LPARAM) hicon);
#else
    (void)iconSize;
    SDL_Surface *sicon = GraphicsHelps::fi2sdl(img);
    SDL_SetWindowIcon(window, sicon);
    SDL_FreeSurface(sicon);
    const char *error = SDL_GetError();

    if(*error != '\0')
        return false;

#endif
    return true;
}


/*********************Code from Qt**end****************/


================================================
FILE: lib/Graphics/graphics_funcs.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef GRAPHICS_FUNCS_H
#define GRAPHICS_FUNCS_H

#ifndef SDL_SDL_STDINC_H
#   include "sdl_proxy/sdl_stdinc.h"
#endif

#include <string>
#include <vector>

#include "size.h"
#include "Utils/files.h"

struct PGE_Pix
{
    Uint8 r;
    Uint8 g;
    Uint8 b;
    Uint8 a;
};

typedef struct SDL_Window SDL_Window;
typedef struct SDL_Surface SDL_Surface;

struct FreeImageIO;

/*!
 * \brief Helpful graphical functions which are doing various work: I/O, Front+Mask blending, etc.
 */
struct FIBITMAP;
class GraphicsHelps
{
public:
    /*!
     * \brief Initializes FreeImage
     */
    static void  initFreeImage();
    /*!
     * \brief DeInitializes FreeImage
     */
    static void  closeFreeImage();

    /*!
     * \brief initializes a FreeImageIO with operations to load from an SDL_RWops object
     */
    static void SetRWopsIO(FreeImageIO *io);

    /*!
     * \brief Loads image from a disk
     * \param file full or relative path to the file
     * \param convertTo32bit need to convert image into 32bit RGBA
     * \return FreeImage descriptor to loaded image
     */
    static FIBITMAP *loadImage(const std::string &file, bool convertTo32bit = true);
    static FIBITMAP *loadImage(const Files::Data &raw, bool convertTo32bit = true);

    /*!
     * \brief Loads QOI image from a memory buffer
     * \param raw - QOI buffer
     * \param[out] depthTestSupported - whether QOI indicates that depth test is supported (sets channels flag to 3)
     * \return FreeImage descriptor to loaded image
     *
     * Implemented in xt_qoi.cpp
     */
    static FIBITMAP *loadQOI(const Files::Data &raw, bool &depthTestSupported);

    /*!
     * \brief Loads mask image from a disk
     * \param file full or relative path to the file
     * \param maskIsPng if set, set the RGB channels of the mask to the inverse alpha channel of the loaded image
     * \param convertTo32bit need to convert image into 32bit RGBA
     * \return FreeImage descriptor to loaded mask
     */
    static FIBITMAP *loadMask(const std::string &file, bool maskIsPng, bool convertTo32bit = true);
    static FIBITMAP *loadMask(const Files::Data &raw, bool maskIsPng, bool convertTo32bit = true);

    /*!
     * \brief Loads image from application resources
     * \param file in-resource path to the file
     * \return FreeImage descriptor to loaded image
     */
    //static FIBITMAP *loadImageRC(const char *file);

    /*!
     * \brief Converts FreeImage into SDL_Surface
     * \param img Source FreeImage descriptor to loaded image
     * \return SDL_Surface pointer
     */
    static SDL_Surface *fi2sdl(FIBITMAP *img);

    /*!
     * \brief Closes image and frees memory
     * \param FreeImage descriptor to loaded image
     */
    static void closeImage(FIBITMAP *img);

    /**
     * @brief Generate mask from an RGBA source
     * @param mask [inout] Mask initially in RGBA format
     */
    static void RGBAToMask(FIBITMAP* mask);

    /*!
     * \brief Merges mask and foreground image with bit blitting algorithm
     * 1) draw mask over grey-filled image with bitwise AND per each pixel (white pixels are will not change background)
     * 2) draw foreground over same image with bitwise OR per each pixel (black pixels are will not change background)
     * 3) Calculate alpha-channel level dependent to black-white difference on the mask and on the foreground:
     *    white on the mask is a full transparency, black - is a solid pixels area.
     * \param image
     * \param pathToMask
     * \param pathToMaskFallback
     */
    static void mergeWithMask(FIBITMAP *image,
                              const std::string &pathToMask,
                              const std::string &pathToMaskFallback = std::string());
    static void mergeWithMask(FIBITMAP *image, const Files::Data &maskRaw, bool maskIsPng = false);
    static void mergeWithMask(FIBITMAP *image, FIBITMAP *mask);

    static void setBitBlitBG(uint8_t red, uint8_t green, uint8_t blue);
    static void resetBitBlitBG();

    /*!
     * \brief Replaces one color with another
     * \param image Image
     * \param src Original pixel color
     * \param dst New pixel color
     */
    static void replaceColor(FIBITMAP *image, const PGE_Pix &src, const PGE_Pix &dst);

    /*!
     * \brief Gets metric from image file
     * \param [__in] imageFile Path to image file
     * \param [__out] imgSize Pointer to PGE_Size value
     */
    static bool getImageMetrics(const std::string &imageFile, PGE_Size *imgSize);
    static void getMaskedImageInfo(const std::string &rootDir,
                                   const std::string &in_imgName,
                                   std::string &out_maskName,
                                   std::string &out_errStr,
                                   PGE_Size *imgSize = nullptr);

    /*!
     * \brief Checks the possibility to shrink down the image with 2x factor without losses
     * This call checks the ability to scale-down an image without getting distortions after process.
     * There are next conditions required:
     * - Image should have metrics being multiple 2
     * - Every 2x2 sector at the image should contain the same color.
     * This means, this image was been scaled up with 2x factor in the past to get this image
     * \param image Image to check
     * \param origPath The optional original path to the texture, needed for log printing
     * \return true - image will be shrank without damages
     */
    static bool validateFor2xScaleDown(FIBITMAP *image, const std::string &origPath = std::string());

    /*!
     * \brief Quickly scales down the image 2x using nearest-neighbor downsampling
     * \param image Image to downscale
     * \return FreeImage descriptor to scaled image
     */
    static FIBITMAP *fast2xScaleDown(FIBITMAP *image);

    /*!
     * \brief Quickly convert the image from 16-color or 256-color to 32-bit RGBA
     * \param image Image to convert
     * \return FreeImage descriptor to converted image
     */
    static FIBITMAP *fastConvertTo32Bit(FIBITMAP *image);

    /*!
     * \brief Check textures are they require the bitmask render or not
     * \param image Front image
     * \param mask Mask image
     * \param origPath The optional original path to the texture, needed for log printing
     * \return true if bitmask render suggested for better accuracy
     */
    static bool validateBitmaskRequired(FIBITMAP *image, FIBITMAP *mask, const std::string &origPath = std::string());

    /*!
     * \brief Checks the possibility to render the image using a depth test without losses
     * There are next conditions required:
     * - Every pixel in the image must be either fully transparent or fully opaque
     * \param image Image to check
     * \param origPath The optional original path to the texture, needed for log printing
     * \return true - image may be included in draws using the depth test
     */
    static bool validateForDepthTest(FIBITMAP *image, const std::string &origPath = std::string());

    /*!
     * \brief Quickly convert the image from 16-color or 256-color to 32-bit RGBA and simultaneously downscale
     * \param image           Image to convert
     * \param do_scale_down   Whether to actually scale down image
     * \return FreeImage descriptor to converted image
     */
    static FIBITMAP *fastScaleDownAnd32Bit(FIBITMAP *image, bool do_scale_down = true);

    /*!
     * \brief Quickly convert the image from 1-color or 256-color to 16-bit RGB565 (3DS-exclusive). Also does a vertical flip.
     * \param image           Image to convert
     * \return FreeImage descriptor to converted image
     */
    static FIBITMAP *fastConvertToRGB565AndFlip(FIBITMAP *image, bool /*unused*/);

    /*!
     * \brief Set the icon for the SDL Window
     * \param window Target window instance
     * \param img Icon image to set
     * \param iconSize The desired size for the icon
     * \return true if success
     */
    static bool setWindowIcon(SDL_Window *window, FIBITMAP *img, int iconSize);
};

#endif // GRAPHICS_FUNCS_H


================================================
FILE: lib/Graphics/image_size.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "image_size.h"

#include <SDL2/SDL_rwops.h>
#include "sdl_proxy/sdl_stdinc.h"


#include <Utils/files.h>

static bool tryGIF(SDL_RWops* file, uint32_t *w, uint32_t *h)
{
    SDL_RWseek(file, 0, RW_SEEK_SET);
    const char *GIF1 = "GIF87a";
    const char *GIF2 = "GIF89a";
    char magic[6];

    if(SDL_RWread(file, magic, 1, 6) != 6)
        return false;

    bool found = false;

    if(SDL_strncmp(magic, GIF1, 6) == 0)
        found = true;

    if(SDL_strncmp(magic, GIF2, 6) == 0)
        found = true;

    if(!found)
        return false;

    unsigned char size[4];

    if(SDL_RWread(file, reinterpret_cast<char *>(size), 1, 4) != 4)
        return false;

#define UINT(d) static_cast<unsigned int>(d)
    *w = ((UINT(size[0]) & 0x00FF) | ((UINT(size[1]) << 8) & 0xFF00));
    *h = ((UINT(size[2]) & 0x00FF) | ((UINT(size[3]) << 8) & 0xFF00));
#undef UINT

    return true;
}

static bool tryBMP(SDL_RWops* file, uint32_t *w, uint32_t *h)
{
    SDL_RWseek(file, 0, RW_SEEK_SET);
    const char *BMP = "BM";
    char magic[2];

    if(SDL_RWread(file, magic, 1, 2) != 2)
        return false;

    if(SDL_strncmp(magic, BMP, 2) != 0)
        return false;

    unsigned char size[8];

    if(SDL_RWseek(file, 18, RW_SEEK_SET) < 0)
        return false;

    if(SDL_RWread(file, reinterpret_cast<char *>(size), 1, 8) != 8)
        return false;

#define UINT(d) static_cast<unsigned int>(d)
    *w = ((UINT(size[0]) & 0xFF) | ((UINT(size[1]) << 8) & 0xFF00) |
         ((UINT(size[2]) << 16) & 0xFF0000) | ((UINT(size[3]) << 24) & 0xFF000000));

    *h = ((UINT(size[4]) & 0xFF) | ((UINT(size[5]) << 8) & 0xFF00) |
         ((UINT(size[6]) << 16) & 0xFF0000) | ((UINT(size[7]) << 24) & 0xFF000000));
#undef UINT

    return true;
}

static bool tryPNG(SDL_RWops* file, uint32_t *w, uint32_t *h)
{
    SDL_RWseek(file, 0, RW_SEEK_SET);
    const char *PNG  = "\211PNG\r\n\032\n";
    const char *IHDR = "IHDR";
    char magic[8];

    if(SDL_RWread(file, magic, 1, 8) != 8)
        return false;

    if(SDL_strncmp(magic, PNG, 8) != 0)
        return false;

    if(SDL_RWread(file, magic, 1, 8) != 8)
        return false;

    if(SDL_strncmp(magic + 4, IHDR, 4) != 0)
        return false;

    unsigned char size[8];

    if(SDL_RWread(file, reinterpret_cast<char *>(size), 1, 8) != 8)
        return false;

#define UINT(d) static_cast<unsigned int>(d)
    *w = ((UINT(size[3]) & 0xFF) | ((UINT(size[2]) << 8) & 0xFF00) | ((UINT(size[1]) << 16) & 0xFF0000) | ((UINT(size[0]) << 24) & 0xFF000000));
    *h = ((UINT(size[7]) & 0xFF) | ((UINT(size[6]) << 8) & 0xFF00) | ((UINT(size[5]) << 16) & 0xFF0000) | ((UINT(size[4]) << 24) & 0xFF000000));
#undef UINT

    return true;
}

static bool tryQOI(SDL_RWops* file, uint32_t *w, uint32_t *h)
{
    SDL_RWseek(file, 0, RW_SEEK_SET);
    const char *qoif = "qoif";
    char header[14];

    if(SDL_RWread(file, header, 1, 14) != 14)
        return false;

    if(SDL_memcmp(&header[0], qoif, 4) != 0)
        return false;

    // check channels valid
    if(header[12] != 3 && header[12] != 4)
        return false;

    // check colorspace valid
    if(header[13] != 0 && header[13] != 1)
        return false;

#define UINT(d) static_cast<unsigned int>(d)
    *w = ((UINT(header[7]) & 0xFF) | ((UINT(header[6]) << 8) & 0xFF00) |
         ((UINT(header[5]) << 16) & 0xFF0000) | ((UINT(header[4]) << 24) & 0xFF000000));

    *h = ((UINT(header[11]) & 0xFF) | ((UINT(header[10]) << 8) & 0xFF00) |
         ((UINT(header[9]) << 16) & 0xFF0000) | ((UINT(header[8]) << 24) & 0xFF000000));
#undef UINT

    // mark of a 1x texture
    if(header[13] == 1)
    {
        *w *= 2;
        *h *= 2;
    }

    return true;
}

static char *findJpegHead(char *src, size_t src_size)
{
    char *cur = src;
    const char **nd;

    const size_t hSize = 2;

    const char *heads[] =
    {
        /*EXIF*/ "\xFF\xE1", /* needed for bytes to skip */
        /*SOF0*/ "\xff\xc0", /*SOF1*/ "\xff\xc1", /*SOF2*/ "\xff\xc2",
        /*SOF9*/ "\xff\xc9", /*SOF10*/ "\xff\xca",
        nullptr
    };

    while(src_size > 2)
    {
        nd = heads;
        while(*nd)
        {
            if(SDL_memcmp(cur, *nd, hSize) == 0)
            {
#ifdef IMGSIZE_DEBUG
                if(SDL_memcmp(*nd, "\xFF\xE1", 2) != 0)
                    printf("JPEG: got header: [%02X %02X]\n", (*nd)[0], (*nd)[1]);
#endif
                return cur;
            }
            nd++;
        }
        cur++;
        src_size -= 1;
    }
    return nullptr;
}

static bool tryJPEG(SDL_RWops* file, uint32_t *w, uint32_t *h)
{
#define JPEG_BUFFER_SIZE 1024
#define UINT(d) static_cast<unsigned int>(d)
#define BE16(arr, i) (((UINT(arr[i]) << 8) & 0xFF00) | (UINT(arr[i + 1]) & 0xFF))
    const char *JPG1  = "\xFF\xD8\xFF\xDB";
    const char *JPG2_1  = "\xFF\xD8\xFF\xE0", *JPG2_2  = "\x4A\x46\x49\x46\x00\x01";
    const char *JPG3_1  = "\xFF\xD8\xFF\xE1", *JPG3_2  = "\x45\x78\x69\x66\x00\x00";
    char magic[12], raw[JPEG_BUFFER_SIZE];
    char *head = nullptr;
    size_t chunk_size = 0;
    Sint64 pos;

    SDL_RWseek(file, 0, RW_SEEK_SET);

    if(SDL_RWread(file, magic, 1, 10) != 10)
        return false;

    if(SDL_strncmp(magic, JPG1, 4) != 0 &&
      (SDL_strncmp(magic, JPG2_1, 4) != 0 && SDL_strncmp(magic + 6, JPG2_2, 6) != 0) &&
      (SDL_strncmp(magic, JPG3_1, 4) != 0 && SDL_strncmp(magic + 6, JPG3_2, 6) != 0))
        return false;

    while(true)
    {
        SDL_memset(raw, 0, JPEG_BUFFER_SIZE);
        pos = SDL_RWtell(file);
        chunk_size = SDL_RWread(file, raw, 1, JPEG_BUFFER_SIZE);
        if(chunk_size == 0)
            break;

        head = findJpegHead(raw, JPEG_BUFFER_SIZE);
        if(head)
        {
            if(head + 20 >= raw + JPEG_BUFFER_SIZE)
            {
                SDL_RWseek(file, -20, RW_SEEK_CUR);
                continue; /* re-scan this place */
            }

            if(SDL_memcmp(head, "\xFF\xE1", 2) == 0) /* EXIF, skip it!*/
            {
                const Sint64 curPos = pos + (head - raw);
                unsigned int toSkip = BE16(head, 2);
                SDL_RWseek(file, curPos + toSkip + 2, RW_SEEK_SET);
                continue;
            }

            *h = BE16(head, 5);
            *w = BE16(head, 7);
            return true;
        }
    }

    return false;
#undef BE16
#undef UINT
#undef JPEG_BUFFER_SIZE
}

bool PGE_ImageInfo::getImageSizeRW(SDL_RWops *image, uint32_t *w, uint32_t *h, int *errCode)
{
    bool ret = false;
    if(tryPNG(image, w, h))
        ret = true;
    else
    if(tryQOI(image, w, h))
        ret = true;
    else
    if(tryGIF(image, w, h))
        ret = true;
    else
    if(tryBMP(image, w, h))
        ret = true;
    else
    if(tryJPEG(image, w, h))
        ret = true;

    SDL_RWclose(image);

    if(!ret)
    {
        if(errCode)
            *errCode = ERR_UNSUPPORTED_FILETYPE;
    }

    return ret;
}

bool PGE_ImageInfo::getImageSize(const PGEString &imagePath, uint32_t *w, uint32_t *h, int *errCode)
{
    if(errCode)
        *errCode = ERR_OK;

    std::string imgPath = PGEStringToStd(imagePath);

    SDL_RWops* image = Files::open_file(imgPath, "rb");

    if(!image)
    {
        if(errCode)
            *errCode = ERR_NOT_EXISTS;

        return false;
    }

    return getImageSizeRW(image, w, h, errCode);
}


PGEString PGE_ImageInfo::getMaskName(const PGEString &imageFileName)
{
    std::string mask = PGEStringToStd(imageFileName);
    //Make mask filename
    size_t dotPos = mask.find_last_of('.');

    if(dotPos == std::string::npos)
        mask.push_back('m');
    else
        mask.insert(mask.begin() + std::string::difference_type(dotPos), 'm');

    return StdToPGEString(mask);
}


================================================
FILE: lib/Graphics/image_size.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef IMAGESIZE_H
#define IMAGESIZE_H

#include "PGEString.h"
#include <cstdint>

struct SDL_RWops;

/**
 * @brief Basic image information misc. functions
 */
namespace PGE_ImageInfo
{

/**
 * @brief Error codes of image information retrieving
 */
enum ErrCodes
{
    //! No errors, everything is OK
    ERR_OK,
    //! Unknown error
    ERR_UNKNOWN,
    //! Image file type is not supported
    ERR_UNSUPPORTED_FILETYPE,
    //! File not exists
    ERR_NOT_EXISTS,
    //! Can't open the file
    ERR_CANT_OPEN,
};

bool getImageSizeRW(SDL_RWops *image, uint32_t *w, uint32_t *h, int *errCode=nullptr);

/**
 * @brief Quickly get image size (width and height) from image file.
 * @param [in] imagePath Path to image file
 * @param [out] w Width of image
 * @param [out] h Height of image
 * @param [out] errCode Error code
 * @return true if successfully finished, false if error occouped
 */
bool getImageSize(const PGEString &imagePath, uint32_t *w, uint32_t *h, int *errCode = nullptr);

/**
 * @brief Returns filename of masked image
 * @param [in] imageFileName foreground image file-name
 * @return masked image filename
 */
PGEString getMaskName(const PGEString &imageFileName);

}//PGE_ImageInfo

#endif // IMAGESIZE_H


================================================
FILE: lib/Graphics/size.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "size.h"

PGE_Size::PGE_Size()
{
    setSize(0, 0);
}

PGE_Size::PGE_Size(int w, int h)
{
    m_w = w;
    m_h = h;
}

void PGE_Size::setSize(int w, int h)
{
    m_w = w;
    m_h = h;
}

void PGE_Size::setWidth(int w)
{
    m_w = w;
}

void PGE_Size::setHeight(int h)
{
    m_h = h;
}

bool PGE_Size::isNull() const
{
    return ((m_w == 0) && (m_h == 0));
}

int PGE_Size::w() const
{
    return m_w;
}

int PGE_Size::h() const
{
    return m_h;
}


================================================
FILE: lib/Graphics/size.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef PGE_Size_H
#define PGE_Size_H

class PGE_Size
{
public:
    PGE_Size();
    PGE_Size(const PGE_Size &p) = default;
    PGE_Size(int w, int h);
    ~PGE_Size() = default;
    void setSize(int w, int h);
    void setWidth(int w);
    void setHeight(int h);
    bool isNull() const;
    int w() const;
    int h() const;
private:
    int m_w;
    int m_h;
};

#endif // PGE_Size_H


================================================
FILE: lib/Graphics/xt_qoi.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru> and ds-sloth
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/*

Includes material from qoi.h

Copyright (c) 2021, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT

*/

#include <stdlib.h>
#include <string.h>

#include <Utils/files.h>

#include "graphics_funcs.h"
#include <Logger/logger.h>

#include <FreeImageLite.h>


#ifndef QOI_MALLOC
    #define QOI_MALLOC(sz) malloc(sz)
    #define QOI_FREE(p)    free(p)
#endif
#ifndef QOI_ZEROARR
    #define QOI_ZEROARR(a) memset((a),0,sizeof(a))
#endif

#define QOI_SRGB   0
#define QOI_LINEAR 1
#define BUF_SIZE 4096

typedef struct {
    unsigned int width;
    unsigned int height;
    unsigned char channels;
    unsigned char colorspace;
} qoi_desc;


#define QOI_OP_INDEX  0x00 /* 00xxxxxx */
#define QOI_OP_DIFF   0x40 /* 01xxxxxx */
#define QOI_OP_LUMA   0x80 /* 10xxxxxx */
#define QOI_OP_RUN    0xc0 /* 11xxxxxx */
#define QOI_OP_RGB    0xfe /* 11111110 */
#define QOI_OP_RGBA   0xff /* 11111111 */

#define QOI_MASK_2    0xc0 /* 11000000 */

#define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
#define QOI_COLOR_HASH_RGBQUAD(C) (C.rgbRed*3 + C.rgbGreen*5 + C.rgbBlue*7 + C.rgbReserved*11)
#define QOI_MAGIC \
    (((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
     ((unsigned int)'i') <<  8 | ((unsigned int)'f'))
#define QOI_HEADER_SIZE 14

/* 2GB is the max file size that this implementation can safely handle. We guard
against anything larger than that, assuming the worst case with 5 bytes per
pixel, rounded down to a nice clean value. 400 million pixels ought to be
enough for anybody. */
#define QOI_PIXELS_MAX ((unsigned int)400000000)

static const unsigned char qoi_padding[8] = {0,0,0,0,0,0,0,1};

static unsigned int qoi_read_32(const unsigned char*& read_ptr) {
    unsigned int a = *(read_ptr++);
    unsigned int b = *(read_ptr++);
    unsigned int c = *(read_ptr++);
    unsigned int d = *(read_ptr++);
    return a << 24 | b << 16 | c << 8 | d;
}

FIBITMAP *GraphicsHelps::loadQOI(const Files::Data &raw, bool &depthTestSupported)
{
    if(raw.size() < QOI_HEADER_SIZE + 8)
        return nullptr;

    FIBITMAP *dib = nullptr;
    const unsigned char *read_ptr = raw.begin();
    const unsigned char *read_bound = raw.end() - 8;

    // qoi_decode: local declarations
    qoi_desc _desc;
    qoi_desc* const desc = &_desc;

    // qoi_decode: header read
    unsigned int header_magic = qoi_read_32(read_ptr);
    desc->width = qoi_read_32(read_ptr);
    desc->height = qoi_read_32(read_ptr);
    desc->channels = *(read_ptr++);
    desc->colorspace = *(read_ptr++);

    if(desc->width == 0 || desc->height == 0 ||
       desc->channels < 3 || desc->channels > 4 ||
       desc->colorspace > 1 ||
       header_magic != QOI_MAGIC ||
       desc->height >= QOI_PIXELS_MAX / desc->width)
    {
        return nullptr;
    }

    // allocate bitmap
    dib = FreeImage_Allocate(desc->width, desc->height, 32);

    if(!dib)
        return nullptr;

    FreeImage_SetTransparent(dib, TRUE);

    // store whether the depth test is supported
    depthTestSupported = (desc->channels == 3);

    // start actually decoding
    int run = 0;

    RGBQUAD index[64];
    RGBQUAD px;

    QOI_ZEROARR(index);
    px.rgbRed = 0;
    px.rgbGreen = 0;
    px.rgbBlue = 0;
    px.rgbReserved = 255;

    RGBQUAD* pixels = reinterpret_cast<RGBQUAD*>(FreeImage_GetBits(dib));
    RGBQUAD* pixels_end = reinterpret_cast<RGBQUAD*>(FreeImage_GetBits(dib) + FreeImage_GetPitch(dib) * desc->height);
    RGBQUAD* pixels_risk = pixels_end - 0x40; // optimization: moment after which we need to check that runs won't overrun the pixel buffer

    while(pixels < pixels_end)
    {
        // if we're going to overrun bytes array, that's a bug!
        if(read_ptr >= read_bound)
            goto error;

        unsigned char b1 = *(read_ptr++);
        unsigned char fam = (b1 & QOI_MASK_2);

        if(fam == QOI_OP_RUN)
        {
            // QOI_OP_RUN
            if(b1 < QOI_OP_RGB)
            {
                run = (b1 & 0x3f) + 1; // add one because we will subtract one for this pixel below

                if(pixels > pixels_risk && pixels + run > pixels_end)
                    goto error;

                for(; run > 0; run--)
                    *(pixels++) = px;

                continue;
            }
            else if(b1 == QOI_OP_RGB)
            {
                px.rgbRed   = *(read_ptr++);
                px.rgbGreen = *(read_ptr++);
                px.rgbBlue  = *(read_ptr++);
            }
            // QOI_OP_RGBA
            else
            {
                px.rgbRed      = *(read_ptr++);
                px.rgbGreen    = *(read_ptr++);
                px.rgbBlue     = *(read_ptr++);
                px.rgbReserved = *(read_ptr++);
            }
        }
        else if(fam == QOI_OP_INDEX)
        {
            px = index[b1];
        }
        else if(fam == QOI_OP_DIFF)
        {
            px.rgbRed   += ((b1 >> 4) & 0x03) - 2;
            px.rgbGreen += ((b1 >> 2) & 0x03) - 2;
            px.rgbBlue  += ( b1       & 0x03) - 2;
        }
        else if(fam == QOI_OP_LUMA)
        {
            unsigned char b2 = *(read_ptr++);
            char vg = (char)(b1 & 0x3f) - 32;
            px.rgbRed   += vg - 8 + (char)((b2 >> 4) & 0x0f);
            px.rgbGreen += vg;
            px.rgbBlue  += vg - 8 +  (char)(b2       & 0x0f);
        }

        index[QOI_COLOR_HASH_RGBQUAD(px) & (64 - 1)] = px;

        *(pixels++) = px;
    }

    // if there aren't exactly 8 bytes (padding) left, or the padding doesn't match, that's a bug!
    if(read_ptr != read_bound || memcmp(read_ptr, qoi_padding, 8) != 0)
        goto error;

    return dib;

error:
    if(dib)
        FreeImage_Unload(dib);

    return nullptr;
}


================================================
FILE: lib/Integrator/int_discorcrpc.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_timer.h"
#include "int_discorcrpc.h"
#include <Logger/logger.h>

#include <time.h>
#include <discord_rpc.h>


static constexpr const char* APPLICATION_ID = XTECH_DISCORD_APPID;
static_assert(APPLICATION_ID != nullptr, "Discord Application ID is undefined. Please set the -DTHEXTECH_DISCORD_APPID=<app-id> CMake argument.");


static void handleDiscordReady(const DiscordUser* connectedUser)
{
    pLogDebug("Discord: connected to user %s#%s - %s",
              connectedUser->username,
              connectedUser->discriminator,
              connectedUser->userId);
}

static void handleDiscordDisconnected(int errcode, const char* message)
{
    pLogDebug("Discord: disconnected (%d: %s)", errcode, message);
}

static void handleDiscordError(int errcode, const char* message)
{
    pLogDebug("Discord: error (%d: %s)", errcode, message);
}

static void handleDiscordJoin(const char* secret)
{
    pLogDebug("Discord: join (%s)", secret);
}

static void handleDiscordSpectate(const char* secret)
{
    pLogDebug("Discord: spectate (%s)", secret);
}

static void handleDiscordJoinRequest(const DiscordUser* request)
{
    (void)request;
}


void DiscorcRPC::clearAllLabels()
{
    episodeName.clear();
    levelName.clear();
    editorFile.clear();
}

DiscorcRPC::DiscorcRPC()
{
    m_last_sync = SDL_GetTicks();
}

DiscorcRPC::~DiscorcRPC()
{
    clear();
    quit();
}

void DiscorcRPC::init()
{
    pLogDebug("Discord: Initializing...");

    DiscordEventHandlers handlers;
    SDL_memset(&handlers, 0, sizeof(handlers));
    handlers.ready = handleDiscordReady;
    handlers.disconnected = handleDiscordDisconnected;
    handlers.errored = handleDiscordError;
    handlers.joinGame = handleDiscordJoin;
    handlers.spectateGame = handleDiscordSpectate;
    handlers.joinRequest = handleDiscordJoinRequest;
    Discord_Initialize(APPLICATION_ID, &handlers, 1, NULL);
}

void DiscorcRPC::quit()
{
    pLogDebug("Discord: Quitting...");
    Discord_Shutdown();
}

void DiscorcRPC::setGameName(const std::string& game)
{
    gameName = game;
    if(gameName.size() > 128)
        gameName.resize(128);

    // HEURISTIC icon name (for assets packs that has "status-icon-name" unset):
    //   it's impossible to dynamiclally upload custom images,
    //   So, there is a pre-defined list of available assets
    if(gameName == "Adventures of Demo")
        iconName = "assets_aod";
    else if(gameName == "A Super Mario Bros. X Thing" || gameName == "A Second Mario Bros. X Thing")
        iconName = "assets_a2xt_ptts";
    else if(gameName == "Nostalgic Paradise")
        iconName = "assets_nostalgic_paradise";
    else if(gameName == "Super Talking Time Bros." || gameName == "Super Talking Time Bros. 2.5")
        iconName = "assets_talking_time_bros";
    else if(gameName == "Super Mario Bros. X Nostalgie")
        iconName = "assets_smbx_nostalgie";
    else if(gameName == "Super Mario Bros. X")
        iconName = "assets_smbx";
    else
        iconName.clear();
}

void DiscorcRPC::setEpisodeName(const std::string& ep)
{
    clearAllLabels();
    episodeName = ep;
    if(episodeName.size() > 128)
        episodeName.resize(128);
}

void DiscorcRPC::setLevelName(const std::string& lev)
{
    clearAllLabels();
    levelName = lev;
    if(levelName.size() > 128)
        levelName.resize(128);
}

void DiscorcRPC::setEditorFile(const std::string& fil)
{
    clearAllLabels();
    editorFile = fil;
    if(editorFile.size() > 128)
        editorFile.resize(128);
}

void DiscorcRPC::setIconName(const std::string& icon)
{
    iconName = icon;
    if(iconName.size() > 32)
        iconName.resize(32);
}

void DiscorcRPC::sync()
{
    if(SDL_GetTicks() - m_last_sync < 100)
        return; // 10 calls per second is allowed!

    m_last_sync = SDL_GetTicks();
#ifdef DISCORD_DISABLE_IO_THREAD
    Discord_UpdateConnection();
#endif
    Discord_RunCallbacks();
}

void DiscorcRPC::update()
{
    pLogDebug("Discord: Updating state...");

    char buffer[128];

    DiscordRichPresence discordPresence;
    SDL_memset(&discordPresence, 0, sizeof(discordPresence));

    discordPresence.details = gameName.c_str();

    if(!levelName.empty())
    {
        SDL_snprintf(buffer, 128, "Playing level: %s", levelName.c_str());
        discordPresence.state = buffer;
    }
    else if(!episodeName.empty())
    {
        SDL_snprintf(buffer, 128, "Playing Episode: %s", episodeName.c_str());
        discordPresence.state = buffer;
    }
    else if(!editorFile.empty())
    {
        SDL_snprintf(buffer, 128, "Editing file: %s", editorFile.c_str());
        discordPresence.state = buffer;
    }

    discordPresence.startTimestamp = time(0);
    discordPresence.endTimestamp = 0;
    discordPresence.largeImageKey = iconName.empty() ? "thextech_default_icon" : iconName.c_str();
    discordPresence.largeImageText = "TheXTech";
    discordPresence.smallImageKey = iconName.empty() ? "" : "thextech_default_icon";
    discordPresence.smallImageText = gameName.c_str();
    discordPresence.partyId = "";
    discordPresence.partySize = 0;
    discordPresence.partyMax = 0;
    discordPresence.partyPrivacy = DISCORD_PARTY_PRIVATE;
    discordPresence.matchSecret = "";
    discordPresence.joinSecret = "";
    discordPresence.spectateSecret = "";
    discordPresence.instance = 0;
    Discord_UpdatePresence(&discordPresence);
    sync();
}

void DiscorcRPC::clear()
{
    pLogDebug("Discord: Clearing the presence...");
    Discord_ClearPresence();
    sync();
}


================================================
FILE: lib/Integrator/int_discorcrpc.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef DISCORCRPC_H
#define DISCORCRPC_H

#include <stdint.h>
#include <string>

class DiscorcRPC
{
    int FrustrationLevel = 0;
    int SendPresence = 1;
    uint32_t m_last_sync = 0;

    std::string episodeName;
    std::string levelName;
    std::string editorFile;

    std::string gameName;
    std::string iconName;

    void clearAllLabels();

public:
    DiscorcRPC();
    ~DiscorcRPC();

    void init();
    void quit();

    void setGameName(const std::string &game);
    void setEpisodeName(const std::string &ep);
    void setLevelName(const std::string &lev);
    void setEditorFile(const std::string &fil);
    void setIconName(const std::string &icon);

    void sync();

    void update();
    void clear();
};

#endif // DISCORCRPC_H


================================================
FILE: lib/Integrator/integrator.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "integrator.h"
#include "config.h"

#ifdef ENABLE_XTECH_DISCORD_RPC
#include "int_discorcrpc.h"
static DiscorcRPC s_discord;
static bool s_discordLoaded = false;
#endif

static bool s_integrationsLoaded = false;
static std::string s_prevEpisodeName;
static std::string s_prevLevelName;
static std::string s_prevEditorFile;

static void clearAllPrev()
{
    s_prevEpisodeName.clear();
    s_prevLevelName.clear();
    s_prevEditorFile.clear();
}

void Integrator::initIntegrations()
{
    if(s_integrationsLoaded)
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(g_config.discord_rpc)
    {
        s_discord.init();
        s_discordLoaded = true;
    }
#endif

    s_integrationsLoaded = true;
}

void Integrator::quitIntegrations()
{
    if(!s_integrationsLoaded)
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.clear();
        s_discord.quit();
    }
#endif

    s_integrationsLoaded = false;
}

void Integrator::setGameName(const std::string& gameName, const std::string& iconName)
{
#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.setGameName(gameName);
        if(!iconName.empty())
            s_discord.setIconName(iconName);
        s_discord.update();
    }
#endif
}

void Integrator::setEpisodeName(const std::string& episodeName)
{
    if(s_prevEpisodeName == episodeName)
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.setEpisodeName(episodeName);
        s_discord.update();
    }
#endif

    clearAllPrev();
    s_prevEpisodeName = episodeName;
}

void Integrator::clearEpisodeName()
{
    if(s_prevEpisodeName.empty())
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.setEpisodeName(std::string());
        s_discord.update();
    }
#endif

    s_prevEpisodeName.clear();
}

void Integrator::setLevelName(const std::string& levelName)
{
    if(s_prevLevelName == levelName)
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.setLevelName(levelName);
        s_discord.update();
    }
#endif

    clearAllPrev();
    s_prevLevelName = levelName;
}

void Integrator::clearLevelName()
{
    if(s_prevLevelName.empty())
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.setLevelName(std::string());
        s_discord.update();
    }
#endif

    s_prevLevelName.clear();
}

void Integrator::setEditorFile(const std::string& editorFile)
{
    if(s_prevEditorFile == editorFile)
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.setEditorFile(editorFile);
        s_discord.update();
    }
#endif

    clearAllPrev();
    s_prevEditorFile = editorFile;
}

void Integrator::clearEditorFile()
{
    if(s_prevEditorFile.empty())
        return;

#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
    {
        s_discord.setEditorFile(std::string());
        s_discord.update();
    }
#endif

    s_prevEditorFile.clear();
}

void Integrator::sync()
{
#ifdef ENABLE_XTECH_DISCORD_RPC
    if(s_discordLoaded)
        s_discord.sync();
#endif
}


================================================
FILE: lib/Integrator/integrator.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef INTEGRATOR_H
#define INTEGRATOR_H

#include <string>

namespace Integrator
{
#ifdef ENABLE_XTECH_INTEGRATOR

void initIntegrations();
void quitIntegrations();

void setGameName(const std::string &gameName, const std::string &iconName);

void setEpisodeName(const std::string &episodeName);
void clearEpisodeName();

void setLevelName(const std::string &levelName);
void clearLevelName();

void setEditorFile(const std::string &editorFile);
void clearEditorFile();

void sync();

#else

// Empty calls that does nothing

static inline void initIntegrations() {}
static inline void quitIntegrations() {}

static inline void setGameName(const std::string &, const std::string &) {}

static inline void setEpisodeName(const std::string &) {}
static inline void clearEpisodeName() {}

static inline void setLevelName(const std::string &) {}
static inline void clearLevelName() {}

static inline void setEditorFile(const std::string &) {}
static inline void clearEditorFile() {}

static inline void sync() {}

#endif
}

#endif // INTEGRATOR_H


================================================
FILE: lib/InterProcess/editor_pipe.cpp
================================================
#include "editor_pipe.h"
#include "../Logger/logger.h"
#include "../util.h"

#include <Utils/files.h>
#include <Utils/elapsed_timer.h>
#include <Utils/strings.h>

#include <iostream>
#include <cstdio>
#include "../AppPath/app_path.h"
#include "intproc.h"
#include <fmt_format_ne.h>

#include "main/game_strings.h"

/**************************************************************************************************************/

int EditorPipe::run(void *self)
{
    EditorPipe &me = *reinterpret_cast<EditorPipe *>(self);

    while(me.m_thread_isAlive)
    {
        std::string buffer;
        std::string out;
        std::cin >> buffer;

        if(me.m_thread_isAlive)
        {
            util::base64_decode(out, buffer);
            me.icomingData(out);
        }
    }

    return 0;
}

void EditorPipe::start()
{
    std::cin.sync_with_stdio(false);
#ifndef PGE_NO_THREADING
    m_thread_isAlive = true;
    m_thread = SDL_CreateThread(&run, "EditorPipe_std", this);
    SDL_DetachThread(m_thread);
#endif
}

void EditorPipe::stop()
{
    m_thread_isAlive = false;
    //int status = 0;
    //SDL_WaitThread(m_thread, &status);
}

void EditorPipe::sendMessage(const std::string &in)
{
    std::string outO;
    util::base64_encode(outO, reinterpret_cast<const unsigned char *>(in.c_str()), in.size());
    D_pLogDebug("EditorPipe::sendMessage: sending data [%s]", outO.c_str());
    std::fprintf(stdout, "%s\n", outO.c_str());
    std::fflush(stdout);
}

void EditorPipe::sendMessage(const char *in)
{
    std::string outO;
    util::base64_encode(outO, reinterpret_cast<const unsigned char *>(in), strlen(in));
    D_pLogDebug("EditorPipe::sendMessage: sending data [%s]", outO.c_str());
    std::fprintf(stdout, "%s\n", outO.c_str());
    std::fflush(stdout);
}
/**************************************************************************************************************/


/**
 * @brief EditorPipe::LocalServer
 *  Constructor
 */

EditorPipe::EditorPipe():
    m_thread(nullptr),
    m_thread_isAlive(false),
    m_isWorking(false),
    m_doAcceptLevelData(false),
    m_doParseLevelData(false),
    m_levelAccepted(false)
{
    m_acceptedRawData.clear();
    pLogDebug("Construct interprocess pipe...");
    start();
}

/**
 * @brief EditorPipe::~LocalServer
 *  Destructor
 */
EditorPipe::~EditorPipe()
{
    pLogDebug("Destroying interprocess pipe...");
    stop();
}

void EditorPipe::sendStarsNumber(int numStars)
{
    sendMessage(fmt::sprintf_ne("CMD:NUM_STARS %d", numStars));
}

void EditorPipe::sendTakenBlock(const LevelBlock &block)
{
    std::string encoded;
    LevelData buffer;
    FileFormats::CreateLevelData(buffer);
    buffer.blocks.push_back(block);
    buffer.layers.clear();
    buffer.events.clear();
    if(FileFormats::WriteExtendedLvlFileRaw(buffer, encoded))
        sendMessage(fmt::format_ne("CMD:TAKEN_BLOCK\nTAKEN_BLOCK_END\n{0}", encoded));
}

void EditorPipe::sendTakenBGO(const LevelBGO &bgo)
{
    std::string encoded;
    LevelData buffer;
    FileFormats::CreateLevelData(buffer);
    buffer.bgo.push_back(bgo);
    buffer.layers.clear();
    buffer.events.clear();
    if(FileFormats::WriteExtendedLvlFileRaw(buffer, encoded))
        sendMessage(fmt::format_ne("CMD:TAKEN_BGO\nTAKEN_BGO_END\n{0}", encoded));
}

void EditorPipe::sendTakenNPC(const LevelNPC &npc)
{
    std::string encoded;
    LevelData buffer;
    FileFormats::CreateLevelData(buffer);
    buffer.npc.push_back(npc);
    buffer.layers.clear();
    buffer.events.clear();
    if(FileFormats::WriteExtendedLvlFileRaw(buffer, encoded))
        sendMessage(fmt::format_ne("CMD:TAKEN_NPC\nTAKEN_NPC_END\n{0}", encoded));
}

void EditorPipe::sendCloseProperties()
{
    sendMessage("CMD:CLOSE_PROPERTIES");
}

void EditorPipe::sendPlayerSettings(int playerId, int character, int state, int vehicleID, int vehicleState)
{
    sendMessage(fmt::sprintf_ne("CMD:PLAYER_SETUP_UPDATE %d %d %d %d %d", playerId, character, state, vehicleID, vehicleState));
}

void EditorPipe::sendPlayerSettings2(int playerId, int health, int reservedItem)
{
    sendMessage(fmt::sprintf_ne("CMD:PLAYER_SETUP_UPDATE2 %d %d %d", playerId, health, reservedItem));
}

void EditorPipe::shut()
{
    sendMessage("CMD:ENGINE_CLOSED");
    stop();
}

bool EditorPipe::hasLevelData()
{
    m_levelAccepted_lock.lock();
    bool state = m_levelAccepted;
    m_levelAccepted = false;
    m_levelAccepted_lock.unlock();
    return state;
}

bool EditorPipe::levelReceivingInProcess()
{
    return m_doAcceptLevelData;
}

void EditorPipe::icomingData(const std::string &in)
{
    if(in.compare(0, 10, "PARSE_LVLX") == 0)
    {
        m_doAcceptLevelData = false;
        pLogDebug("LVLX accepting is done!");
        IntProc::setState(g_gameStrings.ipcStatusDataAccepted);
    }

    if(m_doAcceptLevelData)
    {
        m_acceptedRawData.append(in);

        if(m_doAcceptLevelDataParts)
            sendMessage("LVLX_NEXT\n\n");

        pLogDebug("Append LVLX data...");
    }
    else if(in.compare(0, 11, "SEND_LVLX: ") == 0 || in.compare(0, 17, "SEND_LVLX_PARTS: ") == 0)
    {
        m_doAcceptLevelDataParts = (in.compare(0, 17, "SEND_LVLX_PARTS: ") == 0);
        size_t offset = m_doAcceptLevelDataParts ? 17 : 11;
        //Delete old cached stuff
        m_acceptedRawData.clear();
        D_pLogDebug("IN: >> %s",
                    (in.size() > 30 ?
                     in.substr(0, 30).c_str() :
                     in.c_str())
                   );
        m_accepted_lvl_path   = std::string(in.c_str() + offset, (in.size() - offset));//skip "SEND_LVLX: "
        Strings::doTrim(m_accepted_lvl_path);
        m_doAcceptLevelData  = true;
        IntProc::setState(g_gameStrings.ipcStatusDataTransferStarted);
        sendMessage(m_doAcceptLevelDataParts ? "READY_PARTS\n\n" : "READY\n\n");
    }
    else if(in.compare(0, 10, "PARSE_LVLX") == 0)
    {
        pLogDebug("do Parse LVLX: PARSE_LVLX");
        m_doParseLevelData = true;
        m_doAcceptLevelDataParts = false;
        m_acceptedLevel.open(&m_acceptedRawData, m_accepted_lvl_path);
        IntProc::setState(g_gameStrings.ipcStatusDataValid);

        m_levelAccepted_lock.lock();
        m_levelAccepted = true;
        m_levelAccepted_lock.unlock();
    }
    else if(in.compare(0, 11, "PLACEITEM: ") == 0)
    {
        D_pLogDebugNA("Accepted Placing item!");
        IntProc::storeCommand(in.c_str() + 11, in.size() - 11, IntProc::PlaceItem);
    }
    else if(in.compare(0, 11, "SET_LAYER: ") == 0)
    {
        D_pLogDebugNA("Accepted layer change!");
        IntProc::storeCommand(in.c_str() + 11, in.size() - 11, IntProc::SetLayer);
    }
    else if(in.compare(0, 14, "SET_NUMSTARS: ") == 0)
    {
        D_pLogDebugNA("Accepted stars number change!");
        IntProc::storeCommand(in.c_str() + 14, in.size() - 14, IntProc::SetNumStars);
    }
    else if(in.compare(0, 8, "MSGBOX: ") == 0)
    {
        pLogDebug("Accepted Message box: %s", in.c_str());
        IntProc::storeCommand(in.c_str() + 8, in.size() - 8, IntProc::MsgBox);
    }
    else if(in.compare(0, 7, "CHEAT: ") == 0)
    {
        pLogDebug("Accepted cheat code: %s", in.c_str());
        IntProc::storeCommand(in.c_str() + 7, in.size() - 7, IntProc::Cheat);
    }
    else if(in.compare(0, 4, "PING") == 0)
    {
        D_pLogDebugNA("IN: >> PING");
        sendMessage("PONG\n\n");
        pLogDebug("Ping-Pong!");
    }
}


================================================
FILE: lib/InterProcess/editor_pipe.h
================================================
#ifndef EDITOR_PIPE_H
#define EDITOR_PIPE_H

#include <SDL2/SDL_thread.h>
#include <vector>
#include <atomic>
#include <mutex>
#include <PGE_File_Formats/file_formats.h>

class EditorPipe
{
    friend class EditorPipe_std;
    SDL_Thread *m_thread = nullptr;
    bool        m_thread_isAlive = false;
public:
    EditorPipe();
    ~EditorPipe();
    void sendStarsNumber(int numStars);
    void sendTakenBlock(const LevelBlock &block);
    void sendTakenBGO(const LevelBGO &bgo);
    void sendTakenNPC(const LevelNPC &npc);
    void sendCloseProperties();
    void sendPlayerSettings(int playerId, int character, int state, int vehicleID, int vehicleState);
    void sendPlayerSettings2(int playerId, int health, int reservedItem);
    void shut();

    bool        m_isWorking;

    static int run(void *self);
    static int sendMessageAsync(void *outString);
    void start();
    void stop();

    using RawTextInput = PGE_FileFormats_misc::RawTextInput;

    // SEND_LVLX: /some/path/to/level file\n\n
    std::string     m_accepted_lvl_path; // Send to client the "READY\n\n" before accent raw data
    bool            m_doAcceptLevelData = false;
    bool            m_doAcceptLevelDataParts = false;
    std::string     m_acceptedRawData;  // accept any raw data before will be accepted '\n\n'
    bool            m_doParseLevelData = false;
    RawTextInput    m_acceptedLevel;    // When accepted PARSE_LVLX\n\n, parse data and call signal

    bool hasLevelData();
    bool levelReceivingInProcess();

    void sendMessage(const std::string &in);
    void sendMessage(const char *in);

private:
    std::atomic_bool    m_levelAccepted;
    std::mutex          m_levelAccepted_lock;

    void icomingData(const std::string &in);
};

#endif // EDITOR_PIPE_H


================================================
FILE: lib/InterProcess/intproc.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "intproc.h"
#include <SDL2/SDL_atomic.h>
#include "../Logger/logger.h"

EditorPipe              *IntProc::editor = nullptr;
static bool             s_ipc_enabled = false;
static SDL_atomic_t     s_has_command;

static std::string      s_state;
static std::mutex       s_state_lock;

static IntProc::ExternalCommands        s_cmd_recentType = IntProc::MsgBox;

static std::deque<IntProc::cmdEntry>    s_cmd_queue;
static std::mutex                       s_cmd_mutex;

void IntProc::init()
{
    SDL_AtomicSet(&s_has_command, 0);
    pLogDebug("IntProc constructing...");
    editor = new EditorPipe();
    editor->m_isWorking = true;
    pLogDebug("IntProc started!");
    s_ipc_enabled = true;
}

void IntProc::quit()
{
    if(editor != nullptr)
    {
        editor->m_isWorking = false;
        editor->shut();
        delete editor;
    }

    editor  = nullptr;
    s_ipc_enabled = false;
}

bool IntProc::isEnabled()
{
    return s_ipc_enabled;
}

bool IntProc::isWorking()
{
    return (editor != nullptr);
}

std::string IntProc::getState()
{
    s_state_lock.lock();
    std::string tmp = s_state;
    s_state_lock.unlock();
    return tmp;
}

void IntProc::setState(const std::string &instate)
{
    s_state_lock.lock();
    s_state = instate;
    s_state_lock.unlock();
}

void IntProc::storeCommand(const char *cmd, size_t length, IntProc::ExternalCommands type)
{
    s_cmd_mutex.lock();
    std::string in;
    in.reserve(length);
    bool escape = false;

    for(size_t i = 0; i < length; i++)
    {
        const char &c = cmd[i];

        if(escape)
        {
            if(c == 'n')
                in.push_back('\n');

            escape = false;
        }
        else if(c == '\\')
        {
            escape = true;
            continue;
        }
        else
            in.push_back(c);
    }

    s_cmd_queue.push_back({in, type});
    s_cmd_recentType = type;
    SDL_AtomicSet(&s_has_command, 1);
    s_cmd_mutex.unlock();
}

void IntProc::cmdLock()
{
    s_cmd_mutex.lock();
}

void IntProc::cmdUnLock()
{
    s_cmd_mutex.unlock();
}

bool IntProc::hasCommand()
{
    return SDL_AtomicGet(&s_has_command);
}

IntProc::ExternalCommands IntProc::commandType()
{
    return s_cmd_recentType;
}

std::string IntProc::getCMD()
{
    cmdEntry tmp = s_cmd_queue.front();
    s_cmd_queue.pop_front();
    if(!s_cmd_queue.empty())
        s_cmd_recentType = s_cmd_queue.front().type;
    else
        SDL_AtomicSet(&s_has_command, 0);
    return tmp.cmd;
}

bool IntProc::sendMessage(const std::string &command)
{
    if(!editor)
    {
        pLogWarning("IntProc::sendMessage: `editor` is not initialized!");
        return false;
    }

    editor->sendMessage(command);
    return true;
}

bool IntProc::sendMessageS(const std::string &command)
{
    if(!editor)
    {
        pLogWarning("IntProc::sendMessageS: `editor` is not initialized!");
        return false;
    }

    editor->sendMessage(command);
    return true;
}

bool IntProc::sendMessage(const char *command)
{
    if(!editor)
    {
        pLogWarning("IntProc::sendMessage: `editor` is not initialized!");
        return false;
    }

    editor->sendMessage(command);
    return true;
}

bool IntProc::hasLevelData()
{
    if(!editor)
        return false;
    return editor->hasLevelData();
}

bool IntProc::levelReceivingInProcess()
{
    if(!editor)
        return false;
    return editor->levelReceivingInProcess();
}

void IntProc::sendStarsNumber(int numStars)
{
    if(!editor)
        return;
    editor->sendStarsNumber(numStars);
}

void IntProc::sendTakenBlock(const LevelBlock &block)
{
    if(!editor)
        return;
    editor->sendTakenBlock(block);
}

void IntProc::sendTakenBGO(const LevelBGO &bgo)
{
    if(!editor)
        return;
    editor->sendTakenBGO(bgo);
}

void IntProc::sendTakenNPC(const LevelNPC &npc)
{
    if(!editor)
        return;
    editor->sendTakenNPC(npc);
}

void IntProc::sendPlayerSettings(int playerId, int character, int state, int vehicleID, int vehicleState)
{
    if(!editor)
        return;
    editor->sendPlayerSettings(playerId, character, state, vehicleID, vehicleState);
}

void IntProc::sendPlayerSettings2(int playerId, int health, int reservedItem)
{
    if(!editor)
        return;
    editor->sendPlayerSettings2(playerId, health, reservedItem);
}

void IntProc::sendCloseProperties()
{
    if(!editor)
        return;
    editor->sendCloseProperties();
}



================================================
FILE: lib/InterProcess/intproc.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef INTPROC_H
#define INTPROC_H

#ifdef THEXTECH_INTERPROC_SUPPORTED

#include <mutex>
#include <deque>
#include <string>
#include "editor_pipe.h"

namespace IntProc
{
    void init();
    void quit();
    bool isEnabled();
    bool isWorking();

    void sendStarsNumber(int numStars);
    void sendTakenBlock(const LevelBlock &block);
    void sendTakenBGO(const LevelBGO &bgo);
    void sendTakenNPC(const LevelNPC &npc);
    void sendPlayerSettings(int playerId, int character, int state, int vehicleID, int vehicleState);
    void sendPlayerSettings2(int playerId, int health, int reservedItem);
    void sendCloseProperties();

    std::string getState();
    void        setState(const std::string &instate);

    enum ExternalCommands
    {
        //! Show messag ebox
        MsgBox = 0,
        //! Cheat code proxy
        Cheat = 1,
        //! Place item (magic-hand only)
        PlaceItem = 2,
        //! Toggle a name of current
        SetLayer = 3,
        //! Set number of taken stars
        SetNumStars = 4
    };

    struct cmdEntry
    {
        std::string cmd;
        ExternalCommands type;
    };

    /**
     * @brief IPC interface has accepted level data
     * @return true if IPC interface keeps a complete level data buffer
     */
    bool hasLevelData();
    /**
     * @brief Is level data in process of receiving
     * @return true if receiving is in process
     */
    bool levelReceivingInProcess();

    bool sendMessage(const char *command);
    bool sendMessageS(const std::string &command);
    bool sendMessage(const std::string &command);

    void             storeCommand(const char *cmd, size_t length, ExternalCommands type);
    void             cmdLock();
    void             cmdUnLock();
    bool             hasCommand();
    ExternalCommands commandType();
    std::string getCMD();

    extern EditorPipe *editor;

}// namespace IntProc

#endif // THEXTECH_INTERPROC_SUPPORTED

#endif // INTPROC_H


================================================
FILE: lib/Logger/logger.cmake
================================================
set(LOGGER_SRCS)

list(APPEND LOGGER_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/logger.h
    ${CMAKE_CURRENT_LIST_DIR}/private/logger.cpp
    ${CMAKE_CURRENT_LIST_DIR}/private/logger_sets.h
    ${CMAKE_CURRENT_LIST_DIR}/private/logger_private.h
)

if(ANDROID)
    message("-- Logger for Android")
    list(APPEND LOGGER_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/logger_android.cpp
    )
elseif(EMSCRIPTEN)
    message("-- Logger for Emscripten")
    list(APPEND LOGGER_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/logger_emscripten.cpp
    )
elseif(VITA)
    message("-- Logger for PS Vita")
    list(APPEND LOGGER_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/logger_vita.cpp
    )
elseif(NINTENDO_3DS OR NINTENDO_WII OR THEXTECH_NO_SDL_BUILD OR PGE_MIN_PORT)
    message("-- Logger for Minimal Port (no SDL)")
    list(APPEND LOGGER_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/logger_min.cpp
    )
elseif(NINTENDO_WIIU)
    message("-- Logger for WiiU")
    list(APPEND LOGGER_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/logger_wiiu.cpp
    )
else()
    message("-- Logger for Desktop")
    list(APPEND LOGGER_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/private/logger_desktop.cpp
    )
endif()


================================================
FILE: lib/Logger/logger.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LOGGER_H
#define LOGGER_H

#ifdef __cplusplus
#include <string>

#ifdef _WIN32
#   define OS_NEWLINE "\r\n"
#else
#   define OS_NEWLINE "\n"
#endif

#include "logger_level.h"

#if defined(__GNUC__) || defined(__clang__)
#   define FORMAT_ATTRIBUTE_PRINTF_12  __attribute__ ((format (printf, 1, 2)))
#else
#   define FORMAT_ATTRIBUTE_PRINTF_12
#endif

extern struct PGE_LogSetup
{
    //! The logging level
    PGE_LogLevel::Level level = PGE_LogLevel::Debug;
    //! Maximum number of log files in the directory
    int maxFilesCount = 10;
    //! Default logs directory
    std::string logPathDefault;
    //! Fallback log directory when default log directory is inaccessible
    std::string logPathFallBack;
    //! Custom log directory, specified by user
    std::string logPathCustom;
} g_pLogGlobalSetup;

extern void LoadLogSettings(bool disableStdOut = false, bool verboseLogs = false);
extern void CloseLog();
#endif//__cplusplus

#ifdef __cplusplus
extern "C"
{
#endif
extern void pLogDebug(const char *format, ...) FORMAT_ATTRIBUTE_PRINTF_12;
extern void pLogWarning(const char *format, ...) FORMAT_ATTRIBUTE_PRINTF_12;
extern void pLogCritical(const char *format, ...) FORMAT_ATTRIBUTE_PRINTF_12;
extern void pLogInfo(const char *format, ...) FORMAT_ATTRIBUTE_PRINTF_12;
extern void pLogFatal(const char *format, ...) FORMAT_ATTRIBUTE_PRINTF_12;

#define pLogDebugS(str) pLogDebug("%s", str)
#define pLogWarningS(str) pLogWarning("%s", str)
#define pLogCriticalS(str) pLogCritical("%s", str)
#define pLogInfoS(str) pLogInfo("%s", str)
#define pLogFatalS(str) pLogFatal("%s", str)

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern void pLogDebug(const std::string &line);
extern void pLogWarning(const std::string &line);
extern void pLogCritical(const std::string &line);
extern void pLogInfo(const std::string &line);
extern void pLogFatal(const std::string &line);
extern std::string getLogFilePath();
#endif

#ifdef DEBUG_BUILD
// Variadic with arguments
#define D_pLogDebug(fmt, ...) pLogDebug(fmt, __VA_ARGS__)
#define D_pLogWarning(fmt, ...) pLogWarning(fmt, __VA_ARGS__)
#define D_pLogCritical(fmt, ...) pLogCritical(fmt, __VA_ARGS__)
#define D_pLogInfo(fmt, ...) pLogInfo(fmt, __VA_ARGS__)
#define D_pLogFatal(fmt, ...) pLogFatal(fmt, __VA_ARGS__)
// Standard without arguments to avoid "ISO C++11 requires at least one argument of the '...' in a variadic macro"
#define D_pLogDebugNA(fmt) pLogDebug(fmt)
#define D_pLogWarningNA(fmt) pLogWarning(fmt)
#define D_pLogCriticalNA(fmt) pLogCritical(fmt)
#define D_pLogInfoNA(fmt) pLogInfo(fmt)
#define D_pLogFatalNA(fmt) pLogFatal(fmt)
#else
#define D_pLogDebug(fmt, ...) (void)0;
#define D_pLogWarning(fmt, ...) (void)0;
#define D_pLogCritical(fmt, ...) (void)0;
#define D_pLogFatal(fmt, ...) (void)0;
#define D_pLogInfo(fmt, ...) (void)0;
#define D_pLogDebugNA(fmt) (void)0;
#define D_pLogWarningNA(fmt) (void)0;
#define D_pLogCriticalNA(fmt) (void)0;
#define D_pLogFatalNA(fmt) (void)0;
#define D_pLogInfoNA(fmt) (void)0;
#endif

#endif // LOGGER_H


================================================
FILE: lib/Logger/logger_level.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LOGGER_LEVEL_H
#define LOGGER_LEVEL_H

struct PGE_LogLevel
{
    enum Level : int
    {
        Debug    = 5,
        Info     = 4,
        Warning  = 3,
        Critical = 2,
        Fatal    = 1,
        NoLog    = 0,
    };
};

#endif // LOGGER_LEVEL_H


================================================
FILE: lib/Logger/private/logger.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <stdarg.h>
#include "../logger.h"
#include "logger_sets.h"

#ifndef NO_FILE_LOGGING
#   include <chrono>  // chrono::system_clock
#   include <ctime>   // localtime
#   include <DirManager/dirman.h>
#   include <Utils/files.h>
#   include <sorting/tinysort.h>
#endif

#include <fmt_format_ne.h>
#include <fmt/fmt_printf.h>

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_timer.h"

#ifndef MOONDUST_LOGGER_FILENAME_PREFIX
#   error Please define the "-DMOONDUST_LOGGER_FILENAME_PREFIX=<name-of-application>" to specify the log filename prefix
#endif

PGE_LogSetup    g_pLogGlobalSetup;

std::string     LogWriter::m_logDirPath;
std::string     LogWriter::m_logFilePath;
PGE_LogLevel::Level LogWriter::m_logLevel = PGE_LogLevel::NoLog;
int             LogWriter::m_maxFilesCount = 10;
bool            LogWriter::m_enabled = false;
bool            LogWriter::m_enabledStdOut = false;
bool            LogWriter::m_enabledVerboseLogs = false;
uint64_t        LogWriter::m_appStartTicks = 0;

static std::string getRunTimeString()
{
    uint64_t ticks_fms = SDL_GetTicks64() - LogWriter::m_appStartTicks;
    uint64_t ticks_fs = ticks_fms / 1000;
    uint64_t ticks_fm = ticks_fs / 60;
    uint64_t ticks_h = ticks_fm / 60;

    uint64_t ticks_ms = ticks_fms % 1000;
    uint64_t ticks_s = ticks_fs % 60;
    uint64_t ticks_m = ticks_fm % 60;

    if(ticks_h > 0)
        return fmt::sprintf_ne("%02d:%02d:%02d.%03d",
                               (int)ticks_h, (int)ticks_m, (int)ticks_s, (int)ticks_ms);
    else
        return fmt::sprintf_ne("%02d:%02d.%03d",
                               (int)ticks_m, (int)ticks_s, (int)ticks_ms);
}

#if !defined(NO_FILE_LOGGING)
static std::string return_current_time_and_date()
{
    auto now = std::chrono::system_clock::now();
    auto in_time_t = std::chrono::system_clock::to_time_t(now);

#ifdef PGE_MIN_PORT
    // chrono doesn't work reliably here
    time(&in_time_t);
#endif

    char out[24];
    SDL_memset(out, 0, sizeof(out));
    if(0 < strftime(out, sizeof(out), "%Y_%m_%d_%H_%M_%S", std::localtime(&in_time_t)))
        return std::string(out);
    else
        return "0000_00_00_00_00_00";
}

static void cleanUpLogs(const std::string &logsPath, int maxLogs)
{
    if(maxLogs <= 0)
        return; // No limit

    DirMan d(logsPath);
    std::vector<std::string> files, filesPre;
    d.getListOfFiles(filesPre, {".txt"});

    // Be sure that we are looking for our log files and don't touch others
    for(auto &s : filesPre)
    {
        if(SDL_strncasecmp(s.c_str(), MOONDUST_LOGGER_FILENAME_PREFIX "_log_", 13) == 0)
            files.push_back(s);
    }

    // nothing to do, count of log files is fine
    if(static_cast<int>(files.size()) <= (maxLogs - 1))
        return;

    // Sort array
    tinysort(files.begin(), files.end());

    // Keep these files (remove from a deletion list)
    files.erase(files.end() - (maxLogs - 1), files.end());

    for(auto &s : files)
        Files::deleteFile(logsPath + "/" + s);
}
#endif // !NO_FILE_LOGGING


void LoadLogSettings(bool disableStdOut, bool verboseLogs)
{
#if defined(DEBUG_BUILD) || defined(__WIIU__)
    (void)verboseLogs; // unused
    LogWriter::m_enabledVerboseLogs = true; // Enforce verbose log for debug builds or on some platforms like WiiU
#else
    LogWriter::m_enabledVerboseLogs = verboseLogs;
#endif

    LogWriter::m_enabledStdOut = !disableStdOut;
    LogWriter::m_logLevel = g_pLogGlobalSetup.level;

#if !defined(NO_FILE_LOGGING)
    std::string logFileName = fmt::format_ne(MOONDUST_LOGGER_FILENAME_PREFIX "_log_{0}.txt", return_current_time_and_date());
#endif

    LogWriter::m_appStartTicks = SDL_GetTicks64();

#if !defined(NO_FILE_LOGGING)
    const std::string logPath = g_pLogGlobalSetup.logPathDefault;
    DirMan defLogDir(logPath);

    if(!defLogDir.exists())
    {
        if(!defLogDir.mkpath())
            defLogDir.setPath(g_pLogGlobalSetup.logPathFallBack);
    }
#endif // !NO_FILE_LOGGING

#if !defined(NO_FILE_LOGGING)
    LogWriter::m_logDirPath = g_pLogGlobalSetup.logPathCustom.empty() ? defLogDir.absolutePath() : g_pLogGlobalSetup.logPathCustom;
    LogWriter::m_maxFilesCount = g_pLogGlobalSetup.maxFilesCount;

    if(!DirMan::exists(LogWriter::m_logDirPath))
        LogWriter::m_logDirPath = defLogDir.absolutePath();
#endif // !NO_FILE_LOGGING

    LogWriter::m_logLevel = g_pLogGlobalSetup.level;
    LogWriter::m_enabled   = (LogWriter::m_logLevel != PGE_LogLevel::NoLog);

#if !defined(NO_FILE_LOGGING)
    LogWriter::m_logFilePath = LogWriter::m_logDirPath + "/" + logFileName;
    cleanUpLogs(LogWriter::m_logDirPath, LogWriter::m_maxFilesCount);
#else
    LogWriter::m_logFilePath.clear();
#endif // !NO_FILE_LOGGING

    LogWriter::OpenLogFile();
}

void CloseLog()
{
    LogWriter::CloseLog();
}

std::string getLogFilePath()
{
#ifdef NO_FILE_LOGGING
    return "<No log file: Logging was been disabled in this build>";
#else
    return LogWriter::m_logFilePath;
#endif
}

static inline void pLogGeneric(int level, const char *label, const char *format, va_list arg)
{
    if(LogWriter::m_enabledStdOut && LogWriter::m_enabledVerboseLogs)
        LoggerPrivate_pLogConsole(level, label, format, arg);

#ifndef NO_FILE_LOGGING
    if(LogWriter::m_logLevel >= level)
    {
        auto t = getRunTimeString();
        LoggerPrivate_pLogFile(level, label, t.c_str(), format, arg);
    }
#endif
}

void pLogDebug(const char *format, ...)
{
    va_list arg;
    va_start(arg, format);
    pLogGeneric(PGE_LogLevel::Debug, "Debug", format, arg);
    va_end(arg);
}

void pLogWarning(const char *format, ...)
{
    va_list arg;
    va_start(arg, format);
    pLogGeneric(PGE_LogLevel::Warning, "Warning", format, arg);
    va_end(arg);
}

void pLogCritical(const char *format, ...)
{
    va_list arg;
    va_start(arg, format);
    pLogGeneric(PGE_LogLevel::Critical, "Critical", format, arg);
    va_end(arg);
}

void pLogFatal(const char *format, ...)
{
    va_list arg;
    va_start(arg, format);
    pLogGeneric(PGE_LogLevel::Fatal, "Fatal", format, arg);
    va_end(arg);
}

void pLogInfo(const char *format, ...)
{
    va_list arg;
    va_start(arg, format);
    pLogGeneric(PGE_LogLevel::Info, "Info", format, arg);
    va_end(arg);
}

void pLogDebug(const std::string &line)
{
    pLogDebug("%s", line.c_str());
}

void pLogWarning(const std::string &line)
{
    pLogWarning("%s", line.c_str());
}

void pLogCritical(const std::string &line)
{
    pLogCritical("%s", line.c_str());
}

void pLogInfo(const std::string &line)
{
    pLogInfo("%s", line.c_str());
}

void pLogFatal(const std::string &line)
{
    pLogFatal("%s", line.c_str());
}


================================================
FILE: lib/Logger/private/logger_android.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#define LOGGER_INTERNAL
#include "logger_sets.h"
#include "logger_private.h"

#include <mutex>
#include <SDL2/SDL_rwops.h>

#include <android/log.h>

#ifndef NO_FILE_LOGGING
static std::mutex g_lockLocker;
#   define OUT_BUFFER_SIZE 10240
static char       g_outputBuffer[OUT_BUFFER_SIZE];
#   define OUT_BUFFER_STRING_SIZE 10239
//! Output file
static SDL_RWops *s_logout = nullptr;
#endif // NO_FILE_LOGGING

void LogWriter::OpenLogFile()
{
#ifndef NO_FILE_LOGGING
    MUTEXLOCK(mutex);

    if(LogWriter::m_enabledStdOut)
        __android_log_print(ANDROID_LOG_ERROR, "TRACKERS", "LogLevel %d, log file %s\n\n", m_logLevel, m_logFilePath.c_str());

    if(m_enabled)
    {
        s_logout = SDL_RWFromFile(m_logFilePath.c_str(), "a");
        if(!s_logout)
            __android_log_print(ANDROID_LOG_ERROR, "TRACKERS", "Impossible to open %s for write, log printing into the file is disabled!\n", m_logFilePath.c_str());
    }
#endif // NO_FILE_LOGGING
}

void LogWriter::CloseLog()
{
#ifndef NO_FILE_LOGGING
    MUTEXLOCK(mutex);
    if(s_logout)
        SDL_RWclose(s_logout);
    s_logout = nullptr;
#endif // NO_FILE_LOGGING
}

static int pgeToAndroidLL(int level)
{
    switch(level)
    {
    case PGE_LogLevel::NoLog:
        return ANDROID_LOG_INFO;
    case PGE_LogLevel::Fatal:
        return ANDROID_LOG_FATAL;
    default:
    case PGE_LogLevel::Info:
        return ANDROID_LOG_INFO;
    case PGE_LogLevel::Critical:
        return ANDROID_LOG_ERROR;
    case PGE_LogLevel::Warning:
        return ANDROID_LOG_WARN;
    case PGE_LogLevel::Debug:
        return ANDROID_LOG_DEBUG;
    }
}

void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg)
{
    (void)label;
    va_list arg_in;
    va_copy(arg_in, arg);
    __android_log_vprint(pgeToAndroidLL(level), "TRACKERS", format, arg_in);
    va_end(arg_in);
}

#ifndef NO_FILE_LOGGING
void LoggerPrivate_pLogFile(int level, const char *label, const char *in_time, const char *format, va_list arg)
{
    va_list arg_in;
    (void)level;

    if(!s_logout)
        return;

    MUTEXLOCK(mutex);

    va_copy(arg_in, arg);

    int len = SDL_snprintf(g_outputBuffer, OUT_BUFFER_SIZE, "%s [%s]: ", in_time, label);
    if(len > 0)
        SDL_RWwrite(s_logout, g_outputBuffer, 1, (size_t)(len < OUT_BUFFER_STRING_SIZE ? len : OUT_BUFFER_STRING_SIZE));

    len = SDL_vsnprintf(g_outputBuffer, OUT_BUFFER_SIZE, format, arg_in);
    if(len > 0)
        SDL_RWwrite(s_logout, g_outputBuffer, 1, (size_t)(len < OUT_BUFFER_STRING_SIZE ? len : OUT_BUFFER_STRING_SIZE));

    SDL_RWwrite(s_logout, reinterpret_cast<const void *>(OS_NEWLINE), 1, OS_NEWLINE_LEN);
    va_end(arg_in);

/* WORKAROUNDS: flush the output of SDL RWops */
#ifdef HAVE_STDIO_H
    if(s_logout->hidden.stdio.fp)
        fflush(s_logout->hidden.stdio.fp);
#endif
}
#endif // NO_FILE_LOGGING


================================================
FILE: lib/Logger/private/logger_desktop.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#if defined(_WIN32) || defined(__GDK__)
#include <windows.h>
#include <handleapi.h>
#include <fileapi.h>
#endif

#define LOGGER_INTERNAL
#include <SDL2/SDL_rwops.h>

#include "logger_sets.h"
#include "logger_private.h"

#ifndef NO_FILE_LOGGING

#ifndef PGE_NO_THREADING
static std::mutex g_lockLocker;
#endif

#   define OUT_BUFFER_SIZE 10240
static char       g_outputBuffer[OUT_BUFFER_SIZE];
#   define OUT_BUFFER_STRING_SIZE 10239
//! Output file
static SDL_RWops *s_logout = nullptr;
#endif // NO_FILE_LOGGING


void LogWriter::OpenLogFile()
{
#ifndef NO_FILE_LOGGING
    MUTEXLOCK(mutex);

    if(LogWriter::m_enabledStdOut)
    {
        try
        {
            fmt::print(stderr, "LogLevel {0}, log file {1}\n\n", static_cast<int>(m_logLevel), m_logFilePath);
            std::fflush(stderr);
        }
        catch(const fmt::FormatError &err)
        {
            std::fprintf(stderr, "fmt::print failed with exception: %s\n", err.what());
            std::fflush(stderr);
            abort();
        }
    }

    if(m_enabled)
    {
        s_logout = SDL_RWFromFile(m_logFilePath.c_str(), "a");
        if(!s_logout)
        {
            std::fprintf(stderr, "Impossible to open %s for write, log printing into the file is disabled!\n", m_logFilePath.c_str());
            std::fflush(stderr);
        }
    }
#endif // NO_FILE_LOGGING
}

void LogWriter::CloseLog()
{
#ifndef NO_FILE_LOGGING
    MUTEXLOCK(mutex);
    if(s_logout)
        SDL_RWclose(s_logout);
    s_logout = nullptr;
#endif // NO_FILE_LOGGING
}

void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg)
{
    va_list arg_in;
    (void)level;

    va_copy(arg_in, arg);
    std::fprintf(stderr, "%s: ", label);
    std::vfprintf(stderr, format, arg_in);
    std::fprintf(stderr, OS_NEWLINE);
    std::fflush(stderr);
    va_end(arg_in);
}

#ifndef NO_FILE_LOGGING
void LoggerPrivate_pLogFile(int level, const char *label, const char *in_time, const char *format, va_list arg)
{
    va_list arg_in;
    (void)level;

    if(!s_logout)
        return;

    MUTEXLOCK(mutex);

    va_copy(arg_in, arg);

    int len = SDL_snprintf(g_outputBuffer, OUT_BUFFER_SIZE, "%s [%s]: ", in_time, label);
    if(len > 0)
        SDL_RWwrite(s_logout, g_outputBuffer, 1, (size_t)(len < OUT_BUFFER_STRING_SIZE ? len : OUT_BUFFER_STRING_SIZE));

    len = SDL_vsnprintf(g_outputBuffer, OUT_BUFFER_SIZE, format, arg_in);
    if(len > 0)
        SDL_RWwrite(s_logout, g_outputBuffer, 1, (size_t)(len < OUT_BUFFER_STRING_SIZE ? len : OUT_BUFFER_STRING_SIZE));

    SDL_RWwrite(s_logout, reinterpret_cast<const void *>(OS_NEWLINE), 1, OS_NEWLINE_LEN);
    va_end(arg_in);

/* WORKAROUNDS: flush the output of SDL RWops */
#if defined(_WIN32) || defined(__GDK__)
    if(s_logout->hidden.windowsio.h != INVALID_HANDLE_VALUE)
        FlushFileBuffers(s_logout->hidden.windowsio.h);
#elif HAVE_STDIO_H
    if(s_logout->hidden.stdio.fp)
        fflush(s_logout->hidden.stdio.fp);
#endif

}

#endif // NO_FILE_LOGGING


================================================
FILE: lib/Logger/private/logger_dummy.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#define LOGGER_INTERNAL
#include "logger_sets.h"


void LogWriter::OpenLogFile()
{}

void LogWriter::CloseLog()
{}

void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg)
{
    (void)level;
    (void)label;
    (void)format;
    (void)arg;
}

#ifndef NO_FILE_LOGGING
void LoggerPrivate_pLogFile(int level, const char *label, const char *in_time, const char *format, va_list arg)
{
    (void)level;
    (void)label;
    (void)in_time;
    (void)format;
    (void)arg;
}
#endif


================================================
FILE: lib/Logger/private/logger_emscripten.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#define LOGGER_INTERNAL
#include "logger_sets.h"
#include "logger_private.h"

#ifdef __EMSCRIPTEN__
#include <emscripten/trace.h>
#include <emscripten/html5.h>
#define LOG_CHANNEL "Application"
#endif // __EMSCRIPTEN__

#ifndef PGE_NO_THREADING
static std::mutex g_lockLocker;
#endif

#define OUT_BUFFER_SIZE 10240
static char       g_outputBuffer[OUT_BUFFER_SIZE];
static char       g_outputBuffer2[OUT_BUFFER_SIZE];


void LogWriter::OpenLogFile()
{}

void LogWriter::CloseLog()
{}

void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg)
{
    va_list arg_in;

#ifndef PGE_NO_THREADING
    MUTEXLOCK(mutex);
#endif

    va_copy(arg_in, arg);
    int len = std::vsnprintf(g_outputBuffer, OUT_BUFFER_SIZE, format, arg_in);
    if(len > 0)
    {
        int len = std::snprintf(g_outputBuffer2, OUT_BUFFER_SIZE, "%s: %s\n", label, g_outputBuffer);
        if(len > 0)
        {
            if(level == PGE_LogLevel::Critical || level == PGE_LogLevel::Fatal)
                emscripten_console_error(g_outputBuffer2);
            else if(level == PGE_LogLevel::Warning)
                emscripten_console_warn(g_outputBuffer2);
            else
                emscripten_console_log(g_outputBuffer2);
        }
    }
    va_end(arg_in);
    (void)len;
}

#ifndef NO_FILE_LOGGING
void LoggerPrivate_pLogFile(int, const char *, const char *, const char *, va_list)
{}
#endif // NO_FILE_LOGGING


================================================
FILE: lib/Logger/private/logger_min.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#define LOGGER_INTERNAL
#include "logger_sets.h"
#include "logger_private.h"
#include <cstdio>

#ifndef NO_FILE_LOGGING
//! Output file
static FILE* s_logout;
#endif // #ifndef NO_FILE_LOGGING

#ifndef PGE_NO_THREADING
#   ifdef PGE_SDL_MUTEX
    static SDL_mutex *g_lockLocker = nullptr;
#   else
    static std::mutex g_lockLocker;
#   endif
#endif

void LogWriter::OpenLogFile()
{
#if !defined(PGE_NO_THREADING) && defined(PGE_SDL_MUTEX)
    g_lockLocker = SDL_CreateMutex();
#endif

    if(m_enabled)
    {
#ifndef NO_FILE_LOGGING
        s_logout = std::fopen(m_logFilePath.c_str(), "a");
#endif // #ifndef NO_FILE_LOGGING
    }
}

void LogWriter::CloseLog()
{
#if !defined(PGE_NO_THREADING) && defined(PGE_SDL_MUTEX)
    SDL_DestroyMutex(g_lockLocker);
    g_lockLocker = nullptr;
#endif

#ifndef NO_FILE_LOGGING
    if(s_logout)
        std::fclose(s_logout);
    s_logout = nullptr;
#endif // #ifndef NO_FILE_LOGGING
}

void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg)
{
    va_list arg_in;
    (void)level;

    va_copy(arg_in, arg);
    std::printf("%s: ", label);
    std::vprintf(format, arg_in);
    std::printf(OS_NEWLINE);
    va_end(arg_in);
}

#ifndef NO_FILE_LOGGING
void LoggerPrivate_pLogFile(int level, const char *label, const char *in_time, const char *format, va_list arg)
{
    MUTEXLOCK(mutex);
    if(!s_logout)
        return;

    va_list arg_in;
    (void)level;

    va_copy(arg_in, arg);
    std::fprintf(s_logout, "%s [%s]: ", in_time, label);
    std::vfprintf(s_logout, format, arg_in);
    std::fprintf(s_logout, OS_NEWLINE);
    std::fflush(s_logout);
    va_end(arg_in);
}
#endif


================================================
FILE: lib/Logger/private/logger_private.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef LOGGER_INTERNAL
#   error THIS FILE MUST NOT BE INCLUDED OUTSIDE THE LOGGER CODE ITSELF
#endif

#ifndef LOGGER_SETS_H
#include "logger_sets.h"
#endif

#include <fmt_format_ne.h>
#include <fmt/fmt_printf.h>
#include <stdarg.h>
#include <cstdio>

#ifndef PGE_NO_THREADING
#   ifdef PGE_SDL_MUTEX
#       include <SDL2/SDL_mutex.h>
#   else
#       include <mutex>
#   endif
#endif

#include <sstream>
#include <algorithm>

#ifdef _WIN32
#define OS_NEWLINE "\r\n"
#define OS_NEWLINE_LEN 2
#else
#define OS_NEWLINE "\n"
#define OS_NEWLINE_LEN 1
#endif

#ifdef PGE_NO_THREADING

#   define MUTEXLOCK(mn) (void)0

#else

class MutexLocker
{
#ifdef PGE_SDL_MUTEX
    SDL_mutex *m_mutex;
#else
    std::mutex *m_mutex;
#endif

public:
#ifdef PGE_SDL_MUTEX
    MutexLocker(SDL_mutex **mutex)
    {
        m_mutex = *mutex;
        SDL_LockMutex(m_mutex);
    }
#else
    MutexLocker(std::mutex *mutex)
    {
        m_mutex = mutex;
        m_mutex->lock();
    }
#endif

    ~MutexLocker()
    {
#ifdef PGE_SDL_MUTEX
        SDL_UnlockMutex(m_mutex);
#else
        m_mutex->unlock();
#endif
    }
};

#   define MUTEXLOCK(mn) \
    MutexLocker mn(&g_lockLocker); \
    (void)mn

#endif


================================================
FILE: lib/Logger/private/logger_sets.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef LOGGER_SETS_H
#define LOGGER_SETS_H
#pragma once

#include <string>
#include <memory>
#include <stdarg.h>
#include <stdint.h>

#include "../logger.h"

class LogWriter
{
public:
    static std::string  m_logDirPath;
    static std::string  m_logFilePath;
    static PGE_LogLevel::Level m_logLevel;
    static int          m_maxFilesCount;
    //! Is logging system is enabled
    static bool       m_enabled;
    //! Is logging system allowed to output into `stdout`
    static bool       m_enabledStdOut;
    //! Verbose logs to stdOut if possible
    static bool       m_enabledVerboseLogs;

    static uint64_t   m_appStartTicks;

    static void OpenLogFile();
    static void CloseLog();
};

extern void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg);

#ifndef NO_FILE_LOGGING
extern void LoggerPrivate_pLogFile(int level, const char *label, const char *in_time, const char *format, va_list arg);
#endif

#endif // LOGGER_SETS_H


================================================
FILE: lib/Logger/private/logger_vita.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#define LOGGER_INTERNAL
#include "logger_sets.h"
#include "logger_private.h"
#include <cstdio>

#ifdef DEBUG_BUILD
#   include <debugnet.h>
#   ifndef NETDBG_IP_SERVER
#       define NETDBG_IP_SERVER "192.168.1.183"
#   endif
#   ifndef NETDBG_PORT_SERVER
#       define NETDBG_PORT_SERVER 18194
#   endif

#   define VITA_TEMP_BUFFER_SIZE (1024 * 1024)

static char __string_buffer[VITA_TEMP_BUFFER_SIZE - 3];
static char __string_buffer2[VITA_TEMP_BUFFER_SIZE];
static int __vita_debug_setup = 0;
#endif

#ifndef NO_FILE_LOGGING
//! Output file
static FILE* s_logout;
#endif // #ifndef NO_FILE_LOGGING

void LogWriter::OpenLogFile()
{
#ifndef NO_FILE_LOGGING
    if(m_enabled)
        s_logout = std::fopen(m_logFilePath.c_str(), "a");
#endif // #ifndef NO_FILE_LOGGING
}

void LogWriter::CloseLog()
{
#ifndef NO_FILE_LOGGING
    if(s_logout)
        std::fclose(s_logout);
    s_logout = nullptr;
#endif // #ifndef NO_FILE_LOGGING
}

void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg)
{
#ifdef DEBUG_BUILD
    va_list arg_in;
    (void)level;
    (void)label;

    if(__vita_debug_setup == 0)
        debugNetInit(NETDBG_IP_SERVER, NETDBG_PORT_SERVER, DEBUG);

    // Print arg list to first string buffer.
    va_copy(arg_in, arg);
    vsnprintf(__string_buffer, VITA_TEMP_BUFFER_SIZE - 4, format, arg_in);
    va_end(arg_in);
    // Print that string buffer into second string buffer with new line & null termination.
    snprintf(__string_buffer2, VITA_TEMP_BUFFER_SIZE, "%s\n", __string_buffer);
    
    // Print to network.
    debugNetPrintf(DEBUG, __string_buffer2);
#else
    (void)level;
    (void)label;
    (void)format;
    (void)arg;
#endif
}

#ifndef NO_FILE_LOGGING
void LoggerPrivate_pLogFile(int level, const char *label, const char *in_time, const char *format, va_list arg)
{
    if(!s_logout)
        return;

    va_list arg_in;
    (void)level;

    va_copy(arg_in, arg);
    std::fprintf(s_logout, "%s [%s]: ", in_time, label);
    std::vfprintf(s_logout, format, arg_in);
    std::fprintf(s_logout, OS_NEWLINE);
    std::fflush(s_logout);
    va_end(arg_in);
}
#endif


================================================
FILE: lib/Logger/private/logger_wiiu.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#define LOGGER_INTERNAL
#include "logger_sets.h"
#include "logger_private.h"
#include <fmt/fmt_printf.h>
#include <coreinit/debug.h>

#define VITA_TEMP_BUFFER_SIZE (1024 * 1024)

static char s_string_buffer[VITA_TEMP_BUFFER_SIZE - 3];

#ifdef DEBUG_BUILD
#include <stdio.h>
#include <string>

// #define ENABLE_NET_LOG

#   ifdef ENABLE_NET_LOG
#       include <unistd.h>
#       include <sys/socket.h>
#       include <arpa/inet.h>

#       ifndef NETDBG_IP_SERVER
#           define NETDBG_IP_SERVER "172.19.9.141"
#       endif
#       ifndef NETDBG_PORT_SERVER
#           define NETDBG_PORT_SERVER 18194
#       endif

static char s_string_buffer2[VITA_TEMP_BUFFER_SIZE];
static int s_wut_debug_setup = 0;
static int s_socket_desc = 0;
static struct sockaddr_in s_server;
#   endif // ENABLE_NET_LOG
#endif // DEBUG_BUILD

#ifndef NO_FILE_LOGGING
//! Output file
static FILE* s_logout;
#endif // #ifndef NO_FILE_LOGGING

#ifndef PGE_NO_THREADING
#   ifdef PGE_SDL_MUTEX
    static SDL_mutex *g_lockLocker = nullptr;
#   else
    static std::mutex g_lockLocker;
#   endif
#endif

void LogWriter::OpenLogFile()
{
#if !defined(PGE_NO_THREADING) && defined(PGE_SDL_MUTEX)
    OSReport("Debug: Creating the SDL Mutex");
    g_lockLocker = SDL_CreateMutex();
#endif

    if(m_enabled)
    {
#ifndef NO_FILE_LOGGING
        OSReport("Debug: Opening a log file for APPEND: %s\n", m_logFilePath.c_str());
        s_logout = std::fopen(m_logFilePath.c_str(), "a");
#endif // #ifndef NO_FILE_LOGGING
    }
}

void LogWriter::CloseLog()
{
#if !defined(PGE_NO_THREADING) && defined(PGE_SDL_MUTEX)
    OSReport("Debug: Destroying the SDL Mutex");
    SDL_DestroyMutex(g_lockLocker);
    g_lockLocker = nullptr;
#endif

#ifndef NO_FILE_LOGGING
    if(s_logout)
        std::fclose(s_logout);
    s_logout = nullptr;
#endif // #ifndef NO_FILE_LOGGING


#ifdef ENABLE_NET_LOG
    if(s_wut_debug_setup)
    {
        const char *msg = "---- Game disconnected ----\n";
        send(s_socket_desc, msg, strlen(msg) + 1, 0);
        usleep(2000);
        shutdown(s_socket_desc, 2);
        s_socket_desc = 0;
        s_wut_debug_setup = 0;
    }
#endif
}

void LoggerPrivate_pLogConsole(int level, const char *label, const char *format, va_list arg)
{
    va_list arg_in;
    (void)level;
    MUTEXLOCK(mutex);

#ifdef ENABLE_NET_LOG

    // Try to connect the netcat server (run as `nc -nklv 18194`)
    if(!s_wut_debug_setup && s_socket_desc == 0)
    {
        s_socket_desc = socket(AF_INET , SOCK_STREAM , 0);
        if(s_socket_desc != -1)
        {
            s_server.sin_addr.s_addr = inet_addr(NETDBG_IP_SERVER);
            s_server.sin_family = AF_INET;
            s_server.sin_port = htons(NETDBG_PORT_SERVER);

            if(connect(s_socket_desc , (struct sockaddr *)&s_server , sizeof(s_server)) >= 0)
                s_wut_debug_setup = 1;
            else
            {
                shutdown(s_socket_desc, 2);
                s_socket_desc = -1;
            }
        }
    }

    // If success, send log lines to it
    if(s_socket_desc > 0)
    {
        va_copy(arg_in, arg);
        // Print arg list to first string buffer.
        std::vsnprintf(s_string_buffer, VITA_TEMP_BUFFER_SIZE - 4, format, arg_in);
        va_end(arg_in);

        // Print that string buffer into second string buffer with new line & null termination.
        std::snprintf(s_string_buffer2, VITA_TEMP_BUFFER_SIZE, "%s: %s\n", label, s_string_buffer);

        send(s_socket_desc, s_string_buffer2, strlen(s_string_buffer2) + 1, 0);
    }
#else
    va_copy(arg_in, arg);
    // Print arg list to first string buffer.
    std::vsnprintf(s_string_buffer, VITA_TEMP_BUFFER_SIZE - 4, format, arg_in);
    va_end(arg_in);

    // Print that string buffer into the output with new line & null termination.
    OSReport("%s: %s\n", label, s_string_buffer);
#endif
}

#ifndef NO_FILE_LOGGING
void LoggerPrivate_pLogFile(int level, const char *label, const char *in_time, const char *format, va_list arg)
{
    MUTEXLOCK(mutex);
    if(!s_logout)
        return;

    va_list arg_in;
    (void)level;

    va_copy(arg_in, arg);
    std::fprintf(s_logout, "%s [%s]: ", in_time, label);
    std::vfprintf(s_logout, format, arg_in);
    std::fprintf(s_logout, OS_NEWLINE);
    std::fflush(s_logout);
    va_end(arg_in);

}
#endif


================================================
FILE: lib/Utf8Main/utf8main.cmake
================================================
# message("Path to UTF8-Main is [${CMAKE_CURRENT_LIST_DIR}]")
include_directories(${CMAKE_CURRENT_LIST_DIR}/)

set(UTF8MAIN_SRCS)

if(WIN32)
    list(APPEND UTF8MAIN_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/utf8main_win32.cpp
    )
endif()


================================================
FILE: lib/Utf8Main/utf8main.h
================================================
/*
 * utf8main - a small wrapper over entry points
 * to provide the UTF8 encoded main function
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef UTF8MAIN_H
#define UTF8MAIN_H

#ifndef PGE_ENGINE//Don't use in PGE Engine where SDL Main is already in use
//Windows platform
#ifdef _WIN32
//Avoid Qt to steal Main function
#if defined(QT_NEEDS_QMAIN)
#undef main
#endif
//Define custom UTF8 main function which will convert command line arguments into UTF8 and will pass them
#define main UTF8_Main
#endif

#endif

#endif // UTF8MAIN_H


================================================
FILE: lib/Utf8Main/utf8main_win32.cpp
================================================
/*
 * utf8main - a small wrapper over entry points
 * to provide the UTF8 encoded main function
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifdef _WIN32
#include <windows.h>
#include <shellapi.h>
#include <string>
#include <vector>

#ifdef PGE_ENGINE
#   include <SDL2/SDL_main.h>
#else
#   include "utf8main.h"
#endif

#ifndef _In_
#   define _In_
#endif
#ifndef _In_opt_
#   define _In_opt_
#endif

extern int  main(int argc, char *argv[]);

static void buildUtf8Args(std::vector<std::string> &utf8_args)
{
    //Get raw UTF-16 command line
    wchar_t    *cmdLineW = GetCommandLineW();
    int         argc     = 0;
    //Convert it into array of strings
    wchar_t   **argvW    = CommandLineToArgvW(cmdLineW, &argc);

    utf8_args.reserve(argc);
    //Convert every argument into UTF-8
    for(int i = 0; i < argc; i++)
    {
        wchar_t *argW = argvW[i];
        size_t argWlen = wcslen(argW);
        std::string arg;
        arg.resize(argWlen * 2);
        size_t newLen = WideCharToMultiByte(CP_UTF8, 0, argW, static_cast<int>(argWlen), &arg[0], static_cast<int>(arg.size()), 0, 0);
        arg.resize(newLen);
        utf8_args.push_back(arg);
    }
}

#ifdef WIN32_CONSOLE
#undef main
int main()
#   define main UTF8_Main
#else
int WINAPI WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ PSTR, _In_ int)
#endif
{
    //! Storage of UTF8-encoded command line arguments
    std::vector<std::string>  g_utf8_args;
    //! Storage of the pointers to begin of every argument
    std::vector<char *>       g_utf8_argvV;

    buildUtf8Args(g_utf8_args);

#ifdef UTF8Main_Debug
    printf("UTF8 ARGS RAN!\n");
    fflush(stdout);
#endif

    size_t argc = g_utf8_args.size();
    g_utf8_argvV.reserve(argc);
    for(size_t i = 0; i < argc; i++)
        g_utf8_argvV.push_back(&g_utf8_args[i][0]);

    return  main((int)argc, g_utf8_argvV.data());
}
#endif


================================================
FILE: lib/Utils/Utils.cmake
================================================
# message("Path to Utils is [${CMAKE_CURRENT_LIST_DIR}]")
include_directories(${CMAKE_CURRENT_LIST_DIR}/..)

set(UTILS_SRCS)
set(UTILS_LIBS)

list(APPEND UTILS_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/files.cpp
    ${CMAKE_CURRENT_LIST_DIR}/files.h
    ${CMAKE_CURRENT_LIST_DIR}/strings.cpp
    ${CMAKE_CURRENT_LIST_DIR}/strings.h
    ${CMAKE_CURRENT_LIST_DIR}/elapsed_timer.cpp
    ${CMAKE_CURRENT_LIST_DIR}/elapsed_timer.h
    ${CMAKE_CURRENT_LIST_DIR}/dir_list_ci.cpp
    ${CMAKE_CURRENT_LIST_DIR}/dir_list_ci.h
)

if(WIN32)
    list(APPEND UTILS_LIBS shlwapi)
endif()


================================================
FILE: lib/Utils/UtilsSDL.cmake
================================================
# message("Path to UtilsSDL is [${CMAKE_CURRENT_LIST_DIR}]")
include_directories(${CMAKE_CURRENT_LIST_DIR}/../)

set(UTILS_SDL_SRCS)

list(APPEND UTILS_SDL_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/sdl_file.cpp
)



================================================
FILE: lib/Utils/dir_list_ci.cpp
================================================
#include <DirManager/dirman.h>
#include "strings.h"
#include "dir_list_ci.h"

#include <cstring>
#include <algorithm>
#include <utility>


DirListCI::DirListCI(std::string curDir) noexcept
    : m_curDir(std::move(curDir))
{
    if(!m_curDir.empty() && m_curDir.back() != '/')
        m_curDir.push_back('/');

    rescan();
}

void DirListCI::setCurDir(const std::string &path)
{
    auto nPath = path;

    if(!nPath.empty() && nPath.back() != '/')
        nPath.push_back('/');

    if(nPath != m_curDir)
    {
        m_curDir = std::move(nPath);
        rescan();
    }
}

const std::string& DirListCI::getCurDir()
{
    return m_curDir;
}

static void replaceSlashes(std::string &str, const std::string &from)
{
    str.clear();
    if(from.empty())
        return;

    str.reserve(from.size());

    char prevC = '\0';

    for(char c : from)
    {
        if(c == '\\')
            c = '/'; // Replace backslashes
        if(c == '/' && prevC == '/')
            continue; // skip duplicated slashes
        prevC = c;
        str.push_back(c);
    }
}

bool DirListCI::existsCI(const std::string &in_name)
{
    if(in_name.empty())
        return false;

    std::string name;
    replaceSlashes(name, in_name);

    // For sub-directory path, look deeply
    auto subDir = name.find('/');

    if(subDir != std::string::npos)
    {
        auto sdName = resolveDirCase(name.substr(0, subDir));
        auto file = name.substr(subDir + 1);
        auto sdf = m_subDirs.find(sdName);
        // std::string found;

        if(sdf == m_subDirs.end())
        {
            auto f = m_subDirs.emplace(sdName, DirListCIPtr(new DirListCI(m_curDir + sdName)));
            return f.first->second->existsCI(file);
        }
        else
            return sdf->second->existsCI(file);
    }

    // keep MixerX path arguments untouched
    auto pathArgs = name.find('|');
    if(pathArgs != std::string::npos)
    {
        auto n = name.substr(0, pathArgs);
        std::string uppercase_string;
        uppercase_string.resize(n.length());
        std::transform(n.begin(), n.end(), uppercase_string.begin(),
            [](unsigned char c){ return std::toupper(c); });
        auto found = m_fileMap.find(uppercase_string);
        return found != m_fileMap.end();
    }
    else
    {
        std::string uppercase_string;
        uppercase_string.resize(name.length());
        std::transform(name.begin(), name.end(), uppercase_string.begin(),
            [](unsigned char c){ return std::toupper(c); });
        auto found = m_fileMap.find(uppercase_string);
        return found != m_fileMap.end();
    }
}

bool DirListCI::dirExistsCI(const std::string& in_name)
{
    if(in_name.empty())
        return false;

    std::string name;
    replaceSlashes(name, in_name);

    // For sub-directory path, look deeply
    auto subDir = name.find('/');

    if(subDir != std::string::npos)
    {
        auto sdName = resolveDirCase(name.substr(0, subDir));
        auto sdir = name.substr(subDir + 1);
        auto sdf = m_subDirs.find(sdName);
        // std::string found;

        if(sdf == m_subDirs.end())
        {
            auto f = m_subDirs.emplace(sdName, DirListCIPtr(new DirListCI(m_curDir + sdName)));
            return f.first->second->dirExistsCI(sdir);
        }
        else
            return sdf->second->dirExistsCI(sdir);
    }

    std::string uppercase_string;
    uppercase_string.resize(name.length());
    std::transform(name.begin(), name.end(), uppercase_string.begin(),
                   [](unsigned char c){ return std::toupper(c); });
    auto found = m_dirMap.find(uppercase_string);
    return found != m_dirMap.end();
}

std::vector<std::string> DirListCI::getFilesList(const std::string& subDir,
                                                 const std::vector<std::string>& suffix_filters)
{
    std::vector<std::string> ret;

    std::string name;
    replaceSlashes(name, subDir);

    if(!subDir.empty())
    {
        std::string sdName, sdir;
        // For sub-directory path, look deeply
        auto subDirI = name.find('/');

        if(subDirI != std::string::npos)
        {
            sdName = resolveDirCase(name.substr(0, subDirI));
            sdir = name.substr(subDirI + 1);
        }
        else
            sdName = name;

        auto sdf = m_subDirs.find(sdName);
        // std::string found;

        if(sdf == m_subDirs.end())
        {
            auto f = m_subDirs.emplace(sdName, DirListCIPtr(new DirListCI(m_curDir + sdName)));
            return f.first->second->getFilesList(sdir);
        }
        else
            return sdf->second->getFilesList(sdir);
    }

    for(auto &f : m_fileMap)
    {
        if(DirMan::matchSuffixFilters(f.second, suffix_filters))
            ret.push_back(f.second);
    }

    return ret;
}

std::vector<std::string> DirListCI::getFilesList(const std::vector<std::string>& suffix_filters)
{
    return getFilesList(std::string(), suffix_filters);
}

std::string DirListCI::resolveFileCaseExists(const std::string &in_name)
{
    if(in_name.empty())
        return in_name;

    std::string name;
    replaceSlashes(name, in_name);

    // For sub-directory path, look deeply
    auto subDir = name.find('/');
    if(subDir != std::string::npos)
    {
        auto sdName = resolveDirCase(name.substr(0, subDir));
        auto file = name.substr(subDir + 1);
        auto sdf = m_subDirs.find(sdName);
        std::string found;

        if(sdf == m_subDirs.end())
        {
            auto f = m_subDirs.emplace(sdName, DirListCIPtr(new DirListCI(m_curDir + sdName)));
            found = f.first->second->resolveFileCaseExists(file);
        }
        else
            found = sdf->second->resolveFileCaseExists(file);

        if(!sdName.empty() && sdName.back() != '/')
            sdName.push_back('/');

        if(found.empty())
            return std::string();
        else
            return sdName + found;
    }

    // keep MixerX path arguments untouched
    bool hasArgs = true;
    auto fnLen = name.find('|');
    if(fnLen == std::string::npos)
    {
        fnLen = name.size();
        hasArgs = false;
    }

    std::string uppercase_string;
    uppercase_string.resize(fnLen);
    std::transform(name.begin(), name.begin() + fnLen, uppercase_string.begin(),
        [](unsigned char c){ return std::toupper(c); });

    auto found = m_fileMap.find(uppercase_string);
    if(found != m_fileMap.end())
    {
        if(hasArgs)
            return found->second + name.substr(fnLen);
        else
            return found->second;
    }

    return std::string();
}

std::string DirListCI::resolveFileCase(const std::string &in_name)
{
    if(in_name.empty())
        return in_name;

    std::string found = resolveFileCaseExists(in_name);

    // if not found, overwrite with the replace-slash version of the name
    // and return
    if(found.empty())
        replaceSlashes(found, in_name);

    return found;
}

std::string DirListCI::resolveFileCaseAbs(const std::string &in_name)
{
    if(in_name.empty())
        return in_name;

    std::string found = resolveFileCaseExists(in_name);

    // if not found, overwrite with the replace-slash version of the name
    // and return
    if(found.empty())
        replaceSlashes(found, in_name);

    return m_curDir + found;
}

std::string DirListCI::resolveFileCaseExistsAbs(const std::string &in_name)
{
    if(in_name.empty())
        return in_name;

    std::string found = resolveFileCaseExists(in_name);

    // if not found, overwrite with the replace-slash version of the name
    // and return
    if(found.empty())
        return found;

    return m_curDir + found;
}

std::string DirListCI::resolveDirCase(const std::string &name)
{
    if(name.empty())
        return name;

    std::string uppercase_string;
    uppercase_string.resize(name.length());
    std::transform(name.begin(), name.end(), uppercase_string.begin(),
        [](unsigned char c){ return std::toupper(c); });

    auto found = m_dirMap.find(uppercase_string);
    if(found == m_dirMap.end())
        return name;

    return found->second;
}

void DirListCI::rescan()
{
    m_fileMap.clear();
    m_dirMap.clear();
    m_subDirs.clear();

    if(m_curDir.empty())
        return;

    DirMan d(m_curDir);
    std::vector<std::string> fileList;
    std::vector<std::string> dirList;
    d.getListOfFiles(fileList);
    d.getListOfFolders(dirList);

    std::string uppercase_string;

    for(std::string& file : fileList)
    {
        uppercase_string.resize(file.length());
        std::transform(file.begin(), file.end(), uppercase_string.begin(),
            [](unsigned char c){ return std::toupper(c); });
        m_fileMap.emplace(std::make_pair(uppercase_string, file));
    }

    for(std::string& dir : dirList)
    {
        uppercase_string.resize(dir.length());
        std::transform(dir.begin(), dir.end(), uppercase_string.begin(),
            [](unsigned char c){ return std::toupper(c); });
        m_dirMap.emplace(std::make_pair(uppercase_string, dir));
    }
}


================================================
FILE: lib/Utils/dir_list_ci.h
================================================
#ifndef DIRLISTCI_H
#define DIRLISTCI_H

#include <string>
#include <vector>
#include <unordered_map>
#include <memory>

/**
 * @brief Case-Insensitive directory list
 */
class DirListCI
{
    std::string m_curDir;
    std::unordered_map<std::string, std::string> m_fileMap;
    std::unordered_map<std::string, std::string> m_dirMap;
    typedef std::unique_ptr<DirListCI> DirListCIPtr;
    std::unordered_map<std::string, DirListCIPtr> m_subDirs;

public:
    DirListCI(std::string curDir = std::string()) noexcept;
    void setCurDir(const std::string &path);
    const std::string& getCurDir();

    // checks whether a file exists (case-insensitive)
    bool existsCI(const std::string &name);

    // checks whether a directory exists (case-insensitive)
    bool dirExistsCI(const std::string &name);

    // get a list of files at the selected directory
    std::vector<std::string> getFilesList(const std::string &subDir,
                                          const std::vector<std::string> &suffix_filters = std::vector<std::string>());

    std::vector<std::string> getFilesList(const std::vector<std::string> &suffix_filters = std::vector<std::string>());

    // resolves the file's case and returns the original string if failed
    std::string resolveFileCase(const std::string &name);

    // resolves the file's case and returns the original string if failed.
    // returns an absolute path in either case.
    std::string resolveFileCaseAbs(const std::string &name);

    // resolves the file's case and returns an empty string if failed
    std::string resolveFileCaseExists(const std::string &name);

    // resolves the file's case. resturns an absolute path if succeeded, an empty string if failed
    std::string resolveFileCaseExistsAbs(const std::string &name);

    // resolves the dir's case and returns the original string if failed
    std::string resolveDirCase(const std::string &name);

    void rescan();

    inline void invalidate()
    {
        m_curDir.clear();
        rescan();
    }
};

#endif // DIRLISTCI_H


================================================
FILE: lib/Utils/elapsed_timer.cpp
================================================
#include "elapsed_timer.h"

#include <chrono>
#include <assert.h>

struct ElapsedTimer_p
{
    typedef std::chrono::nanoseconds TimeT;
    std::chrono::high_resolution_clock::time_point recent;
};


ElapsedTimer::ElapsedTimer()
{
    p = new ElapsedTimer_p;
    assert(p);
}

ElapsedTimer::ElapsedTimer(const ElapsedTimer &et)
{
    p = new ElapsedTimer_p;
    assert(p);
    p->recent = et.p->recent;
}

ElapsedTimer::~ElapsedTimer()
{
    assert(p);
    delete p;
}

ElapsedTimer & ElapsedTimer::operator=(const ElapsedTimer &et)
{
    assert(this != &et);
    p = new ElapsedTimer_p;
    assert(p);
    p->recent = et.p->recent;
    return *this;
}

void ElapsedTimer::start()
{
    assert(p);
    p->recent = std::chrono::high_resolution_clock::now();
}

void ElapsedTimer::restart()
{
    assert(p);
    p->recent = std::chrono::high_resolution_clock::now();
}

int ElapsedTimer::elapsed() const
{
    assert(p);
    using std::chrono::milliseconds;
    using std::chrono::duration_cast;
    return static_cast<int>(duration_cast<milliseconds>(std::chrono::high_resolution_clock::now() - p->recent).count());
}

int64_t ElapsedTimer::nanoelapsed() const
{
    assert(p);
    using std::chrono::nanoseconds;
    using std::chrono::duration_cast;
    return duration_cast<nanoseconds>(std::chrono::high_resolution_clock::now() - p->recent).count();
}


================================================
FILE: lib/Utils/elapsed_timer.h
================================================
#ifndef ELAPSED_TIMER_H
#define ELAPSED_TIMER_H

#include <cstdint>

struct ElapsedTimer_p;

class ElapsedTimer
{
    ElapsedTimer_p *p = nullptr;
public:
    ElapsedTimer();
    ElapsedTimer(const ElapsedTimer &et);
    ~ElapsedTimer();
    ElapsedTimer & operator=(const ElapsedTimer &et);

    void start();
    void restart();

    int     elapsed() const;
    int64_t nanoelapsed() const;
};

#endif // ELAPSED_TIMER_H


================================================
FILE: lib/Utils/files.cpp
================================================
/*
 * A small crossplatform set of file manipulation functions.
 * All input/output strings are UTF-8 encoded, even on Windows!
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "files.h"
#include "Logger/logger.h"
#include "Archives/archives.h"
#include <stdio.h>
#include <sdl_proxy/sdl_stdinc.h>
#include <SDL2/SDL_rwops.h>

#ifdef _WIN32
#include <windows.h>
#include <shlwapi.h>

static std::wstring Str2WStr(const std::string &path)
{
    std::wstring wpath;
    wpath.resize(path.size());
    int newlen = MultiByteToWideChar(CP_UTF8, 0, path.c_str(), static_cast<int>(path.length()), &wpath[0], static_cast<int>(path.length()));
    wpath.resize(newlen);
    return wpath;
}
#else
#include <unistd.h>
#include <fcntl.h>         // open
#include <string.h>
#include <sys/stat.h>      // fstat
#include <sys/types.h>     // fstat
#include <cstdio>          // BUFSIZ
#endif

#if defined(__CYGWIN__) || defined(__DJGPP__) || defined(__MINGW32__)
#   define IS_PATH_SEPARATOR(c) (((c) == '/') || ((c) == '\\'))
#else
#   define IS_PATH_SEPARATOR(c) ((c) == '/')
#endif

static char fi_path_dot[] = ".";
static char fi_path_root[] = "/";

static char *fi_basename(char *s)
{
    char *rv;

    if(!s || !*s)
        return fi_path_dot;

    rv = s + strlen(s) - 1;

    do
    {
        if(IS_PATH_SEPARATOR(*rv))
            return rv + 1;
        --rv;
    }
    while(rv >= s);

    return s;
}

static char *fi_dirname(char *path)
{
    char *p;

    if(path == NULL || *path == '\0')
        return fi_path_dot;

    p = path + strlen(path) - 1;
    while(IS_PATH_SEPARATOR(*p))
    {
        if(p == path)
            return path;
        *p-- = '\0';
    }

    while(p >= path && !IS_PATH_SEPARATOR(*p))
        p--;

    if(p < path)
        return fi_path_dot;

    if(p == path)
        return fi_path_root;

    *p = '\0';
    return path;
}

Files::Data::Data(Files::Data&& o)
{
    *this = std::move(o);
}

Files::Data::~Data()
{
    if(m_free_me)
        free(const_cast<unsigned char*>(m_data));
}

const Files::Data& Files::Data::operator=(Files::Data&& o)
{
    if(m_free_me)
        free(const_cast<unsigned char*>(m_data));

    m_data = o.m_data;
    m_length = o.m_length;
    m_free_me = o.m_free_me;

    o.m_data = nullptr;
    o.m_length = -1;
    o.m_free_me = false;

    return *this;
}

void Files::Data::init_from_mem(const unsigned char* data, size_t size)
{
    if(m_free_me)
        free(const_cast<unsigned char*>(data));

    m_free_me = false;
    m_data = data;
    m_length = static_cast<long long int>(size);
}

#ifdef FILES_DISOWN_NEEDED
void* Files::Data::disown()
{
    if(!m_free_me)
        return nullptr;

    void* ret = const_cast<uint8_t*>(m_data);

    m_data = nullptr;
    m_length = -1;
    m_free_me = false;

    return ret;
}
#endif

FILE *Files::utf8_fopen(const char *filePath, const char *modes)
{
#ifndef _WIN32
    return ::fopen(filePath, modes);
#else
    wchar_t wfile[MAX_PATH + 1];
    wchar_t wmode[21];
    int wfile_len = (int)strlen(filePath);
    int wmode_len = (int)strlen(modes);
    wfile_len = MultiByteToWideChar(CP_UTF8, 0, filePath, wfile_len, wfile, MAX_PATH);
    wmode_len = MultiByteToWideChar(CP_UTF8, 0, modes, wmode_len, wmode, 20);
    wfile[wfile_len] = L'\0';
    wmode[wmode_len] = L'\0';
    return ::_wfopen(wfile, wmode);
#endif
}

SDL_RWops *Files::open_file(const char *filePath, const char *modes)
{
    if(Archives::is_prefix(filePath[0]))
    {
        if(modes[0] != 'r' || (modes[1] != 'b' && modes[1] != '\0'))
            return nullptr;

        return Archives::open_file(filePath);
    }

    return SDL_RWFromFile(filePath, modes);
}

Files::Data Files::load_file(const char *filePath)
{
    Files::Data ret;

    SDL_RWops *in = Files::open_file(filePath, "rb");
    if(!in)
        return ret;

    off_t size = SDL_RWsize(in);

    // allocate extra byte for null terminator, but don't count it towards size of contained item
    unsigned char* target = (unsigned char*)malloc(size + 1);
    off_t to_read = size;

    if(!target)
    {
        SDL_RWclose(in);
        return ret;
    }

    ret.m_free_me = true;
    ret.m_data = target;
    ret.m_length = size;

    while(to_read)
    {
        size_t bytes_read = SDL_RWread(in, target, 1, to_read);
        if(!bytes_read)
        {
            pLogCritical("I/O error when reading [%s]", filePath);
            SDL_RWclose(in);

            // resets the return value and frees the malloc'd buffer
            ret = Files::Data();

            return ret;
        }

        to_read -= bytes_read;
        target += bytes_read;
    }

    // set null terminator
    *target = 0;

    SDL_RWclose(in);

    return ret;
}

void Files::flush_file(SDL_RWops *f)
{
#ifdef THEXTECH_NO_SDL_BUILD
    if(f->type == SDL_RWOPS_STDFILE)
        ::fflush((FILE*)f->hidden.unknown.data1);
#elif defined(HAVE_STDIO_H)
    if(f->type == SDL_RWOPS_STDFILE)
        ::fflush(f->hidden.stdio.fp);
#endif
}

int Files::skipBom(SDL_RWops* file, const char** charset)
{
    char buf[4];
    auto pos = SDL_RWtell(file);

    // Check for a BOM marker
    if(SDL_RWread(file, buf, 1, 4) == 4)
    {
        if(::memcmp(buf, "\xEF\xBB\xBF", 3) == 0) // UTF-8 is only supported
        {
            if(charset)
                *charset = "[UTF-8 BOM]";
            SDL_RWseek(file, pos + 3, RW_SEEK_SET);
            return CHARSET_UTF8;
        }
        // Unsupported charsets
        else if(::memcmp(buf, "\xFE\xFF", 2) == 0)
        {
            if(charset)
                *charset = "[UTF16-BE BOM]";
            SDL_RWseek(file, pos + 2, RW_SEEK_SET);
            return CHARSET_UTF16BE;
        }
        else if(::memcmp(buf, "\xFF\xFE", 2) == 0)
        {
            if(charset)
                *charset = "[UTF16-LE BOM]";
            SDL_RWseek(file, pos + 2, RW_SEEK_SET);
            return CHARSET_UTF16LE;
        }
        else if(::memcmp(buf, "\x00\x00\xFE\xFF", 4) == 0)
        {
            if(charset)
                *charset = "[UTF32-BE BOM]";
            SDL_RWseek(file, pos + 4, RW_SEEK_SET);
            return CHARSET_UTF32BE;
        }
        else if(::memcmp(buf, "\x00\x00\xFF\xFE", 4) == 0)
        {
            if(charset)
                *charset = "[UTF32-LE BOM]";
            SDL_RWseek(file, pos + 4, RW_SEEK_SET);
            return CHARSET_UTF32LE;
        }
    }

    if(charset)
        *charset = "[NO BOM]";

    // No BOM detected, seek to begining of the file
    SDL_RWseek(file, pos, RW_SEEK_SET);

    return CHARSET_UTF8;
}

bool Files::fileExists(const std::string &path)
{
#if defined(_WIN32)
    if(!Archives::has_prefix(path))
    {
        std::wstring wpath = Str2WStr(path);
        return PathFileExistsW(wpath.c_str()) == TRUE;
    }
#endif

    SDL_RWops *ops = Files::open_file(path, "rb");
    if(ops)
    {
        SDL_RWclose(ops);
        return true;
    }

    return false;
}

bool Files::deleteFile(const std::string &path)
{
#ifdef _WIN32
    std::wstring wpath = Str2WStr(path);
    return (DeleteFileW(wpath.c_str()) == TRUE);
#else
    return ::unlink(path.c_str()) == 0;
#endif
}

bool Files::copyFile(const std::string &to, const std::string &from, bool override)
{
    if(!override && fileExists(to))
        return false;// Don't override exist target if not requested

    bool ret = true;

#ifdef _WIN32

    std::wstring wfrom  = Str2WStr(from);
    std::wstring wto    = Str2WStr(to);
    ret = (bool)CopyFileW(wfrom.c_str(), wto.c_str(), !override);

#else

    char    buf[BUFSIZ];
    ssize_t size;
    ssize_t sizeOut;

    int source  = open(from.c_str(), O_RDONLY, 0);
    if(source == -1)
        return false;

    int dest    = open(to.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0640);
    if(dest == -1)
    {
        close(source);
        return false;
    }

    while((size = read(source, buf, BUFSIZ)) > 0)
    {
        sizeOut = write(dest, buf, static_cast<size_t>(size));
        if(sizeOut != size)
        {
            ret = false;
            break;
        }
    }

    close(source);
    close(dest);
#endif

    return ret;
}

bool Files::moveFile(const std::string& to, const std::string& from, bool override)
{
    bool ret = copyFile(to, from, override);
    if(ret)
        ret &= deleteFile(from);
    return ret;
}


std::string Files::dirname(std::string path)
{
    char *p = strdup(path.c_str());
    char *d = ::fi_dirname(p);
    path = d;
    free(p);
    return path;
}

std::string Files::basename(std::string path)
{
    char *p = strdup(path.c_str());
    char *d = ::fi_basename(p);
    path = d;
    free(p);
    return path;
}

std::string Files::basenameNoSuffix(std::string path)
{
    char *p = strdup(path.c_str());
    char *d = ::fi_basename(p);
    path = d;
    free(p);
    std::string::size_type dot = path.find_last_of('.');
    if(dot != std::string::npos)
        path.resize(dot);
    return path;
}


std::string Files::changeSuffix(std::string path, const std::string &suffix)
{
    size_t pos = path.find_last_of('.');// Find dot
    if((path.size() < suffix.size()) || (pos == std::string::npos))
        path.append(suffix);
    else
        path.replace(pos, suffix.size(), suffix);
    return path;
}

bool Files::hasSuffix(const std::string &path, const std::string &suffix)
{
    if(suffix.size() > path.size())
        return false;

    return (SDL_strncasecmp(path.c_str() + path.size() - suffix.size(), suffix.c_str(), suffix.size()) == 0);
}


bool Files::isAbsolute(const std::string& path)
{
    if(Archives::has_prefix(path))
        return true;

    bool firstCharIsSlash = (path.size() > 0) ? path[0] == '/' : false;
#ifdef _WIN32
    bool containsWinChars = (path.size() > 2) ? (path[1] == ':') && ((path[2] == '\\') || (path[2] == '/')) : false;
    if(firstCharIsSlash || containsWinChars)
    {
        return true;
    }
    return false;
#else
    return firstCharIsSlash;
#endif
}

void Files::getGifMask(std::string& mask, const std::string& front)
{
    mask = front;
    //Make mask filename
    size_t dotPos = mask.find_last_of('.');
    if(dotPos == std::string::npos)
        mask.push_back('m');
    else
        mask.insert(mask.begin() + dotPos, 'm');
}


================================================
FILE: lib/Utils/files.h
================================================
/*
 * A small crossplatform set of file manipulation functions.
 * All input/output strings are UTF-8 encoded, even on Windows!
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef FILES_H
#define FILES_H

#include <string>

struct SDL_RWops;

#if defined(__WII__)
#   define FILES_DISOWN_NEEDED 1
#   define FILES_NODISCARD_ATTR [[nodiscard]]
#else
#   define FILES_NODISCARD_ATTR // Nothing
#endif

namespace Files
{
    // Points to memory representing a loaded file. Does not need to own the memory.
    struct Data
    {
private:
        const unsigned char* m_data = nullptr;
        long long int m_length = -1;
        bool m_free_me = false;
public:
        Data() = default;
        Data(const Data&) = delete;
        Data(Data&&);
        ~Data();

        const Data& operator=(const Data&) = delete;
        const Data& operator=(Data&&);

        void init_from_mem(const unsigned char* data, size_t size);

        inline void take_ownership_of_mem(const unsigned char* data, size_t size)
        {
            init_from_mem(data, size);
            m_free_me = true;
        }

#ifdef FILES_DISOWN_NEEDED
        // if the buffer is malloc-allocated, disowns it and allows the client to take management of it
        FILES_NODISCARD_ATTR void* disown();
#endif

        inline bool valid() const
        {
            return m_length >= 0;
        }

        inline const unsigned char* begin() const
        {
            return m_data;
        }

        inline const unsigned char* end() const
        {
            return m_data + m_length;
        }

        inline const char* c_str() const
        {
            return reinterpret_cast<const char*>(m_data);
        }

        inline size_t size() const
        {
            return (m_length >= 0) ? (size_t)m_length : 0;
        }

        inline size_t empty() const
        {
            return m_length <= 0;
        }

        friend Data load_file(const char *filePath);
    };

    FILE *utf8_fopen(const char *filePath, const char *modes);
    SDL_RWops *open_file(const char *filePath, const char *modes);
    Data load_file(const char *filePath);

    inline SDL_RWops *open_file(const std::string& filePath, const char *modes)
    {
        return open_file(filePath.c_str(), modes);
    }
    inline Data load_file(const std::string& filePath)
    {
        return load_file(filePath.c_str());
    }

    void flush_file(SDL_RWops *f);

    enum Charsets
    {
        CHARSET_UTF8 = 0,
        CHARSET_UTF16BE,
        CHARSET_UTF16LE,
        CHARSET_UTF32BE,
        CHARSET_UTF32LE
    };
    int skipBom(SDL_RWops *file, const char **charset = nullptr);

    bool fileExists(const std::string &path);
    bool deleteFile(const std::string &path);
    bool copyFile(const std::string &to, const std::string &from, bool override = false);
    bool moveFile(const std::string &to, const std::string &from, bool override = false);
    bool isAbsolute(const std::string &path);
    std::string basename(std::string path);
    std::string basenameNoSuffix(std::string path);
    std::string dirname(std::string path);
    std::string changeSuffix(std::string path, const std::string& suffix);
    bool hasSuffix(const std::string &path, const std::string &suffix);
    //Appends "m" into basename of the file name before last dot
    void getGifMask(std::string &mask, const std::string &front);
}

#endif // FILES_H


================================================
FILE: lib/Utils/files_ini.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef THEXTECH_FILES_INI_H
#define THEXTECH_FILES_INI_H

#include <string>
#include <IniProcessor/ini_processing.h>
#include <Utils/files.h>

namespace Files
{
    inline IniProcessing load_ini(const char* name)
    {
        Files::Data data = Files::load_file(name);
        return IniProcessing(data.c_str(), data.size());
    }

    inline IniProcessing load_ini(const std::string& name)
    {
        return load_ini(name.c_str());
    }
}

#endif


================================================
FILE: lib/Utils/openUrl.cmake
================================================
# message("Path to openUrl is [${CMAKE_CURRENT_LIST_DIR}]")
include_directories(${CMAKE_CURRENT_LIST_DIR}/../)

set(OPENURL_SRCS)

list(APPEND OPENURL_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/open_url.cpp
)



================================================
FILE: lib/Utils/open_url.cpp
================================================
/*
 * A small set of additional math functions and templates
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "open_url.h"

/*
    WinAPI implementation
*/
#ifdef _WIN32
#define OPENURL_SUPPORTED
#include <windows.h>
#include <shellapi.h>

void Utils::openUrl(const std::string &url)
{
    std::wstring urlW;
    urlW.resize(url.size());
    int newlen = MultiByteToWideChar(CP_UTF8, 0, url.c_str(), url.length(), &urlW[0], urlW.length());
    urlW.resize(newlen);
    ShellExecuteW(NULL, L"open", urlW.c_str(), NULL, NULL, SW_SHOW);
}
#endif

/*
    Cocoa implementation
*/
#ifdef __APPLE__
#define OPENURL_SUPPORTED
#include <CoreFoundation/CFBundle.h>
#include <ApplicationServices/ApplicationServices.h>

void Utils::openUrl(const std::string &url)
{
    CFURLRef cfurl = CFURLCreateWithBytes(
                         NULL,                        // allocator
                         (UInt8 *)url.c_str(),    // URLBytes
                         url.length(),            // length
                         kCFStringEncodingASCII,      // encoding
                         NULL                         // baseURL
                     );
    LSOpenCFURLRef(cfurl, 0);
    CFRelease(cfurl);
}
#endif

/*
    Linux/FreeBSD implementation
*/
#if defined(__unix__) && (defined(__gnu_linux__) || defined(__FreeBSD__))
#define OPENURL_SUPPORTED
#include <stdlib.h>
#include <string.h>
#include "files.h"

static const char *defaultPaths[] =
{
    "/usr/local/bin/",
    "/usr/bin/",
    "/bin/"
};

static const char *browsers[] =
{
    "firefox",
    "chromium-browser",
    "google-chrome",
    "mozilla",
    "opera"
};

static bool findExec(std::string &exec, const std::string &target)
{
    size_t len = sizeof(defaultPaths)/sizeof(const char*);
    //Is absolute path
    if((target.compare(0, 1, "/") == 0) && (Files::fileExists(target)))
    {
        exec = target;
        return true;
    }

    for(size_t i = 0; i < len; i++)
    {
        if(Files::fileExists(defaultPaths[i] + target))
        {
            exec = defaultPaths[i] + target;
            return true;
        }
    }
    return false;
}

static void execApp(const std::string &prog, const std::string &args)
{
    std::string ex = prog + " " + args + " &";
    if(system(ex.c_str()) != 0)
    {
        fprintf(stderr, "Warning: Opening of URL %s finished with errors\n", args.c_str());
        fflush(stderr);
    }
}

void Utils::openUrl(const std::string &url)
{
    std::string browser;

    if(findExec(browser, "xdg-open"))
    {
        execApp(browser, url);
        return;
    }
    char* envBrowser = nullptr;
    char* envDesktop = nullptr;

    envBrowser = getenv("DEFAULT_BROWSER");
    if(envBrowser)
        envBrowser = getenv("BROWSER");
    if(envBrowser && findExec(browser, envBrowser))
    {
        execApp(browser, url);
        return;
    }

    envDesktop = getenv("XDG_CURRENT_DESKTOP");
    if(envDesktop)
    {
        if(strcmp(envDesktop, "KDE") == 0)
        {
            if(findExec(browser, "kfmclient"))
            {
                std::string args = " exec " + url;
                execApp(browser, args);
                return;
            }
        }

        if(strcmp(envDesktop, "GNOME") == 0)
        {
            if(findExec(browser, "gnome-open"))
            {
                execApp(browser, url);
                return;
            }
        }
    }

    {
        size_t len = sizeof(browsers)/sizeof(const char*);
        for(size_t i = 0; i < len; i++)
        {
            if(findExec(browser, browsers[i]))
            {
                execApp(browser, url);
                return;
            }
        }
    }
}
#endif

/*
    Haiku implementation
*/
#ifdef __HAIKU__
#define OPENURL_SUPPORTED
void Utils::openUrl(const std::string &url)
{
	(void)url;
    //FIXME: Implement this!
}
#endif

/*
    Dummy for unsupported operating systems
*/
#ifndef OPENURL_SUPPORTED
#include <stdio.h>

void Utils::openUrl(const std::string &url)
{
	(void)url;
    fprintf(stderr, "Warning: Opening of URLs by Utils::openUrl() is not supported on this operating system\n");
    fflush(stderr);
}
#endif



================================================
FILE: lib/Utils/open_url.h
================================================
/*
 * A small set of additional math functions and templates
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef OPEN_URL_H
#define OPEN_URL_H

#include <string>

namespace Utils
{
void openUrl(const std::string &url);
}

#endif // OPEN_URL_H


================================================
FILE: lib/Utils/strings.cpp
================================================
/*
 * A small set of extra string processing functions
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "strings.h"
#include <algorithm>
#include <functional>
#include <string>
#include <cstring>
#include <cctype>


bool Strings::startsWith(const std::string &str, char what)
{
    if(str.empty())
        return false;
    return (str.front() == what);
}

bool Strings::startsWith(const std::string &str, const std::string &what)
{
    if(str.size() < what.size())
        return false;
    return (str.substr(0, what.size()).compare(what) == 0);
}

bool Strings::endsWith(const std::string& str, char what)
{
    if(str.empty())
        return false;
    return (str.back() == what);
}

bool Strings::endsWith(const std::string& str, const std::string& what)
{
    if(str.size() < what.size())
        return false;
    return (str.substr( str.size() - what.size(), what.size()).compare(what) == 0);
}

// trim from start (in place)
static inline void ltrim(std::string &s)
{
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
        [](int c)
        {
            return !std::isspace(c);
        }
    ));
}

// trim from end (in place)
static inline void rtrim(std::string &s)
{
    s.erase(std::find_if(s.rbegin(), s.rend(),
        [](int c)
        {
            return !std::isspace(c);
        }
    ).base(), s.end());
}

std::string Strings::trim(std::string str)
{
    ::ltrim(str);
    ::rtrim(str);
    return str;
}
std::string Strings::ltrim(std::string str)
{
    ::rtrim(str);
    return str;
}

std::string Strings::rtrim(std::string str)
{
    ::ltrim(str);
    ::rtrim(str);
    return str;
}

void Strings::doTrim(std::string& str)
{
    ::ltrim(str);
    ::rtrim(str);
}

void Strings::doLTrim(std::string &str)
{
    ::ltrim(str);
}

void Strings::doRTrim(std::string &str)
{
    ::rtrim(str);
}


void Strings::split(Strings::List& out, const std::string& str, char delimiter)
{
    if(str.empty())
        return;

    std::string::size_type beg = 0;
    std::string::size_type end = 0;
    do
    {
        end = str.find(delimiter, beg);
        if(end == std::string::npos)
            end = str.size();
        out.emplace_back(str.substr(beg, end-beg));
        beg = end + 1;
    }
    while(end < str.size() - 1);
}

void Strings::split(Strings::List& out, const std::string& str, const std::string& delimiter)
{
    if(str.empty())
        return;

    std::string::size_type beg = 0;
    std::string::size_type end = 0;
    do
    {
        end = str.find(delimiter, beg);
        if(end == std::string::npos)
            end = str.size();
        out.emplace_back(str.substr(beg, end-beg));
        beg = end + delimiter.size();
    }
    while(end < str.size() - 1);
}

Strings::List Strings::split(const std::string& str, char delimiter)
{
    List res;
    split(res, str, delimiter);
    return res;
}

Strings::List Strings::split(const std::string& str, const std::string& delimiter)
{
    List res;
    split(res, str, delimiter);
    return res;
}

void Strings::replaceInAll(std::string &src, const std::string &from, const std::string &to)
{
    if(from.empty())
        return;

    size_t start_pos = 0;
    while((start_pos = src.find(from, start_pos)) != std::string::npos)
    {
        src.replace(start_pos, from.length(), to);
        start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
    }
}

void Strings::removeInAll(std::string &src, const std::string &substr)
{
    std::string::size_type foundpos = src.find(substr);
    if(foundpos != std::string::npos)
        src.erase(src.begin() + std::string::difference_type(foundpos),
                     src.begin() + std::string::difference_type(foundpos + substr.length()));
}

std::string Strings::removeAll(std::string src, const std::string &substr)
{
    removeInAll(src, substr);
    return src;
}

std::string Strings::replaceAll(std::string src, const std::string &from, const std::string &to)
{
    replaceInAll(src, from, to);
    return src;
}

void Strings::dealloc(std::string& out)
{
    std::string deleter; // Deallocate the string
    std::swap(out, deleter);
}

void Strings::dealloc(std::vector<std::string>& out)
{
    std::vector<std::string> deleter; // Deallocate the string
    std::swap(out, deleter);
}


================================================
FILE: lib/Utils/strings.h
================================================
/*
 * A small set of extra string processing functions
 *
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef STRINGS_H
#define STRINGS_H

#include <string>
#include <vector>

namespace Strings
{
    typedef std::vector<std::string> List;
    bool startsWith(const std::string &str, char what);
    bool startsWith(const std::string &str, const std::string &what);

    bool endsWith(const std::string &str, char what);
    bool endsWith(const std::string &str, const std::string &what);

    std::string trim(std::string str);
    std::string ltrim(std::string str);
    std::string rtrim(std::string str);

    void doTrim(std::string &str);
    void doLTrim(std::string &str);
    void doRTrim(std::string &str);

    void split(List &out, const std::string &str, char delimiter);
    void split(List &out, const std::string &str, const std::string &delimiter);
    List split(const std::string &str, char delimiter);
    List split(const std::string &str, const std::string &delimiter);

    void replaceInAll(std::string &src, const std::string &from, const std::string &to);
    void removeInAll(std::string &src, const std::string &substr);
    std::string replaceAll(std::string src, const std::string &from, const std::string &to);
    std::string removeAll(std::string src, const std::string &substr);

    /**
     * @brief Clears the std::string with the deallocation of the heap
     * @param out The string to deallocate
     */
    void dealloc(std::string &out);

    void dealloc(std::vector<std::string> &out);
}
#endif // STRINGS_H


================================================
FILE: lib/Utils/vptrlist.h
================================================
/*
VPtrList - implementation of PtrList based on std::vector<std::shared_ptr<T>> inherence
implements same API as PtrList, but works faster and has things as std::vector has

Copyright (c) 2017-2026 Vitaliy Novichkov <admin@wohlnet.ru>

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/

#ifndef VPTRLIST_H
#define VPTRLIST_H

#include <vector>
#include <memory>
#include <assert.h>
#include <stddef.h>

#if defined(__EMSCRIPTEN__) || !defined(_WIN32)
#include <sys/types.h>
#endif

#ifdef _MSC_VER
#ifdef _WIN64
typedef long long ssize_t;
#else
typedef int ssize_t;
#endif
#endif

template<class T, typename _Alloc = std::allocator<T>>
class VPtrList : private std::vector<std::unique_ptr<T>>
{
public:
    typedef std::unique_ptr<T> SHptr;
    typedef std::vector<SHptr>              vecPTR;
    typedef typename vecPTR::iterator       S_iterator;
    typedef typename vecPTR::const_iterator S_const_iterator;
    typedef typename vecPTR::reverse_iterator       SR_iterator;
    typedef typename vecPTR::const_reverse_iterator SR_const_iterator;

    typedef T                               value_type;
    typedef typename vecPTR::allocator_type allocator_type;
    typedef size_t                          size_type;
    typedef std::ptrdiff_t                  difference_type;
    typedef T&                              reference;
    typedef const T&                        const_reference;
    typedef typename vecPTR::pointer        pointer;

    template<typename TT, class SIterator>
    class VPtrIterator
    {
#ifdef _MSC_VER
        template<class _T, typename __Alloc>
        friend class VPtrList;
#else
        friend class VPtrList<T, _Alloc>;
#endif
        SIterator p;
    public:
        VPtrIterator(const VPtrIterator&o) : p(o.p) {}
        VPtrIterator(const SIterator &o) : p(o) {}
        virtual ~VPtrIterator() {}

        TT &operator*()
        {
            return *(p.operator*());
        }
        TT *operator->()
        {
            return (p.operator*().get());
        }
        TT &operator[](size_t index)
        {
            return *(*p + index);
        }
        friend VPtrIterator operator+(const VPtrIterator &it, int inc)
        {
            S_iterator i = it.p;
            return iterator(i += inc);
        }
        friend VPtrIterator operator-(const VPtrIterator &it, int inc)
        {
            S_iterator i = it.p;
            return iterator(i -= inc);
        }
        friend VPtrIterator operator+(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return iterator(it1.p + it2.p);
        }
        friend VPtrIterator operator-(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return iterator(it1.p - it2.p);
        }
        friend bool operator==(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return it1.p == it2.p;
        }
        friend bool operator!=(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return it1.p != it2.p;
        }
        friend bool operator>(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return it1.p > it2.p;
        }
        friend bool operator<(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return it1.p < it2.p;
        }
        friend bool operator>=(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return it1.p >= it2.p;
        }
        friend bool operator<=(const VPtrIterator &it1, const VPtrIterator &it2)
        {
            return it1.p <= it2.p;
        }

        VPtrIterator &operator++()
        {
            p++;
            return *this;
        }
        VPtrIterator &operator++(int)
        {
            p++;
            return *this;
        }
        VPtrIterator &operator+=(int inc)
        {
            p += (inc);
            return *this;
        }
        VPtrIterator &operator-=(int dec)
        {
            p -= (dec);
            return *this;
        }
        VPtrIterator &operator+=(const VPtrIterator &inc)
        {
            p += (inc);
            return *this;
        }
        VPtrIterator &operator-=(const VPtrIterator &dec)
        {
            p -= (dec);
            return *this;
        }
    };

    typedef VPtrIterator<T, S_iterator>                 iterator;
    typedef VPtrIterator<const T, S_const_iterator>     const_iterator;

    typedef VPtrIterator<T, SR_iterator>                reverse_iterator;
    typedef VPtrIterator<const T, SR_const_iterator>    const_reverse_iterator;

    iterator begin()
    {
        return vecPTR::begin();
    }
    iterator end()
    {
        return vecPTR::end();
    }
    const_iterator begin() const
    {
        return vecPTR::begin();
    }
    const_iterator end() const
    {
        return vecPTR::end();
    }

    const_iterator cbegin() const
    {
        return vecPTR::cbegin();
    }
    const_iterator cend() const
    {
        return vecPTR::cend();
    }

    reverse_iterator rbegin()
    {
        return vecPTR::begin();
    }
    reverse_iterator rend()
    {
        return vecPTR::rend();
    }
    const_reverse_iterator rbegin() const
    {
        return vecPTR::rbegin();
    }
    const_reverse_iterator rend() const
    {
        return vecPTR::rend();
    }

    const_reverse_iterator crbegin() const
    {
        return vecPTR::crbegin();
    }
    const_reverse_iterator crend() const
    {
        return vecPTR::crend();
    }


    VPtrList() : vecPTR()
    {}

    VPtrList(const VPtrList<T>& o) : vecPTR()
    {
        if (this != &o)
        {
            vecPTR::clear();
            this->append(o);
        }
    }

    VPtrList(std::initializer_list<T> il) : vecPTR()
    {
        this->assign(il);
    }

    VPtrList(size_t size) : vecPTR(size)
    {}


    VPtrList &operator=(const VPtrList &o)
    {
        if (this != &o)
        {
            vecPTR::clear();
            this->append(o);
        }
        return *this;
    }

    template <class InputIterator>
    void assign(InputIterator first, InputIterator last)
    {
        this->reserve(std::distance(first, last));
        while (first < last)
            vecPTR::push_back(SHptr(new T(*(first++))));
    }

    void assign(size_t n, const T& val)
    {
        this->reserve(n);
        while ((n--) > 0)
            vecPTR::push_back(SHptr(new T(val)));
    }

    void assign(std::initializer_list<T> il)
    {
        this->reserve(std::distance(il.begin(), il.end()));
        auto i = il.begin();
        while (i != il.end())
            vecPTR::push_back(SHptr(new T(*(i++))));
    }

    bool empty() const noexcept
    {
        return vecPTR::empty();
    }

    bool isEmpty() const noexcept
    {
        return vecPTR::empty();
    }

    size_t size() const
    {
        return vecPTR::size();
    }

    size_t count() const
    {
        return vecPTR::size();
    }

    size_t max_size() const
    {
        return vecPTR::max_size();
    }

    size_t capacity() const
    {
        return vecPTR::capacity();
    }

    void reserve(size_t _n)
    {
        vecPTR::reserve(_n);
    }

    void resize(size_t _n)
    {
        vecPTR::resize(_n);
    }

    void shrink_to_fit()
    {
        vecPTR::shrink_to_fit();
    }

    SHptr* data()
    {
        return vecPTR::data();
    }

    bool contains(const T &item) const
    {
        return indexOf(item) >= 0;
    }

    ssize_t indexOf(const T &item) const
    {
        size_t s = vecPTR::size();
        const SHptr *d = vecPTR::data();
        size_t i = 0;
        for (; i < s; i++)
        {
            if (*d[i] == item)
                return ssize_t(i);
        }
        return -1;
    }

    ssize_t lastIndexOf(const T &item) const
    {
        ssize_t     s = vecPTR::size();
        const SHptr *d = vecPTR::data();
        ssize_t     i = s - 1;
        for (; i >= 0; i--)
        {
            if (*d[i] == item)
                return ssize_t(i);
        }
        return -1;
    }

    iterator find(const T &item)
    {
        return this->find(item, this->begin());
    }

    iterator find(const T &item, iterator beg)
    {
        iterator i = beg;
        for (; i != end(); i++)
        {
            if (*i == item)
                break;
        }
        return i;
    }

    const_iterator find(const T &item) const
    {
        return this->find(item, this->cbegin());
    }

    const_iterator find(const T &item, const_iterator beg) const
    {
        const_iterator i = beg;
        for (; i != end(); i++)
        {
            if (*i == item)
                break;
        }
        return i;
    }

    iterator find_last_of(const T &item)
    {
        return this->find_last_of(item, this->rbegin());
    }

    iterator find_last_of(const T &item, reverse_iterator beg)
    {
        reverse_iterator i = beg;
        for (; i != end(); i++)
        {
            if (*i == item)
                break;
        }
        return i;
    }

    const_iterator find_last_of(const T &item) const
    {
        return this->find_last_of(item, this->crbegin());
    }

    const_iterator find_last_of(const T &item, const_reverse_iterator beg) const
    {
        const_reverse_iterator i = beg;
        for (; i != end(); i++)
        {
            if (*i == item)
                break;
        }
        return i;
    }

    void clear()
    {
        vecPTR::clear();
    }

    void removeOne(const T &item)
    {
        S_iterator i = vecPTR::begin();
        for (; i != vecPTR::end(); i++)
        {
            if (**i == item)
            {
                vecPTR::erase(i);
                break;
            }
        }
    }

    void removeAll(const T &item)
    {
        S_iterator i = vecPTR::begin();
        for (; i != vecPTR::end();)
        {
            if (**i == item)
                i = vecPTR::erase(i);
            else
                i++;
        }
    }

    iterator erase(iterator pos)
    {
        assert(pos < this->end());
        return iterator(vecPTR::erase(pos.p));
    }

    iterator erase(iterator from, iterator to)
    {
        assert(from < this->end());
        assert(to < this->end());
        assert(from <= to);
        if (from == to)
            return from;
        return iterator(vecPTR::erase(from.p, to.p));
    }

    void removeAt(size_t at)
    {
        vecPTR::erase(vecPTR::begin() + int(at));
    }

    void removeAt(size_t at, size_t num)
    {
        vecPTR::erase(vecPTR::begin() + int(at), vecPTR::begin() + int(at + num));
    }

    void pop_back()
    {
        vecPTR::pop_back();
    }

    void pop_front()
    {
        vecPTR::erase(vecPTR::begin(), vecPTR::begin() + 1);
    }

    void swap(size_t from, size_t to)
    {
        if (from == to)
            return;
        std::swap(*(vecPTR::begin() + from), *(vecPTR::begin() + to));
    }

    void move(size_t from, size_t to)
    {
        size_t m_size = vecPTR::size();
        SHptr *m_data = vecPTR::data();
        (void)m_size;
        assert(m_size > from);
        assert(m_size > to);
        if (from == to)
            return;
        if (from < to)
        {
            SHptr it = std::move(m_data[from]);
            while (from < to)
            {
                m_data[from] = std::move(m_data[from + 1]);
                from++;
            }
            m_data[to] = std::move(it);
        }
        else
        {
            SHptr it = std::move(m_data[from]);
            while (from > to)
            {
                m_data[from] = std::move(m_data[from - 1]);
                from--;
            }
            m_data[to] = std::move(it);
        }
    }

    void push_back(const T &item)
    {
        vecPTR::push_back(SHptr(new T(item)));
    }

    void push_back(T &&item)
    {
        vecPTR::emplace_back(SHptr(new T(std::move(item))));
    }

    template<typename... _Args>
    void emplace_back(_Args&&... __args)
    {
        vecPTR::emplace_back(std::move(SHptr(new T(std::forward<_Args>(__args)...))));
    }

    void push_front(const T &item)
    {
        vecPTR::insert(begin(), SHptr(new T(item)));
    }

    void push_front(T &&item)
    {
        vecPTR::insert(begin(), SHptr(new T(std::move(item))));
    }

    template<typename... _Args>
    iterator emplace(const_iterator pos, _Args&&... __args)
    {
        return vecPTR::emplace(pos.p, std::move(SHptr(new T(std::forward<_Args>(__args)...))));
    }

    void append(const T &item)
    {
        vecPTR::push_back(SHptr(new T(item)));
    }

    void append(const VPtrList<T> &array)
    {
        vecPTR::reserve(array.size());
        for (const T &t : array)
            vecPTR::push_back(SHptr(new T(t)));
    }

    iterator insert(size_t at, const T &item)
    {
        return iterator(vecPTR::insert(vecPTR::begin() + int(at), SHptr(new T(item))));
    }

    iterator insert(const_iterator pos, const T &item)
    {
        iterator(vecPTR::insert(pos.p, SHptr(new T(item))));
    }

    iterator insert(const_iterator pos, T &&item)
    {
        iterator(vecPTR::insert(pos.p, SHptr(new T(std::move(item)))));
    }

    T &last()
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::back();
    }

    T &first()
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::front();
    }

    T &back()
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::back();
    }

    T &front()
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::front();
    }

    const T &last() const
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::back();
    }

    const T &first() const
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::front();
    }

    const T &back() const
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::back();
    }

    const T &front() const
    {
        assert(vecPTR::size() > 0);
        return *vecPTR::front();
    }

    T &at(unsigned int index)
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    T &at(int index)
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    T &at(unsigned long index)
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    T &at(long index)
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    T &at(unsigned long long index)
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    T &at(long long index)
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    const T &at(unsigned int index) const
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    const T &at(int index) const
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    const T &at(unsigned long index) const
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    const T &at(long index) const
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    const T &at(unsigned long long index) const
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }

    const T &at(long long index) const
    {
        return *(vecPTR::at(static_cast<size_t>(index)));
    }


    T &operator[](unsigned int index)
    {
        assert(index < static_cast<unsigned int>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    T &operator[](int index)
    {
        assert(index >= 0);
        assert(index < static_cast<int>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    T &operator[](unsigned long index)
    {
        assert(index < static_cast<unsigned long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    T &operator[](long index)
    {
        assert(index >= 0);
        assert(index < static_cast<unsigned long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    T &operator[](unsigned long long index)
    {
        assert(index < static_cast<unsigned long long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    T &operator[](long long index)
    {
        assert(index >= 0);
        assert(index < static_cast<long long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }


    const T &operator[](unsigned int index) const
    {
        assert(index < static_cast<unsigned int>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    const T &operator[](int index) const
    {
        assert(index >= 0);
        assert(index < static_cast<int>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    const T &operator[](unsigned long index) const
    {
        assert(index < static_cast<unsigned long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    const T &operator[](long index) const
    {
        assert(index >= 0);
        assert(index < static_cast<unsigned long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    const T &operator[](unsigned long long index) const
    {
        assert(index < static_cast<unsigned long long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    const T &operator[](long long index) const
    {
        assert(index >= 0);
        assert(index < static_cast<long long>(vecPTR::size()));
        return *(vecPTR::at(index));
    }

    allocator_type get_allocator() const noexcept
    {
        return vecPTR::get_allocator();
    }
};

template <class T, class Alloc>
inline bool operator== (const VPtrList<T, Alloc>& __x, const VPtrList<T, Alloc>& __y)
{
    return (__x.size() == __y.size()) && std::equal(__x.begin(), __x.end(), __y.begin());
}

template <class T, class Alloc>
bool operator!= (const VPtrList<T, Alloc>& __x, const VPtrList<T, Alloc>& __y)
{
    return !(__x == __y);
}

template <class T, class Alloc>
bool operator<  (const VPtrList<T, Alloc>& __x, const VPtrList<T, Alloc>& __y)
{
    return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
}

template <class T, class Alloc>
bool operator<= (const VPtrList<T, Alloc>& __x, const VPtrList<T, Alloc>& __y)
{
    return !(__y < __x);
}

template <class T, class Alloc>
bool operator>  (const VPtrList<T, Alloc>& __x, const VPtrList<T, Alloc>& __y)
{
    return __y < __x;
}

template <class T, class Alloc>
bool operator>= (const VPtrList<T, Alloc>& __x, const VPtrList<T, Alloc>& __y)
{
    return !(__x < __y);
}

#endif // VPTRLIST_H


================================================
FILE: lib/fixed_point.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "fixed_point.h"

#include "FixPointCS/Fixed64.h"

num_t num_t::dist(num_t dx, num_t dy)
{
    return num_t(Fixed64::Sqrt(dist2(dx, dy).i), nullptr);
}

num_t num_t::idist(num_t dx, num_t dy)
{
    return num_t(Fixed64::RSqrt(dist2(dx, dy).i), nullptr);
}

numf_t numf_t::times(numf_t o) const
{
    int64_t multiplied_24 = (int64_t)i * (int64_t)o.i;

    // banker's rounding
    int64_t multiplied_round = (multiplied_24 + ((int64_t)1 << 23));
    if((multiplied_round & 0x00FFFFFFLL) == 0)
    {
        if(multiplied_round & 0x1000000LL)
            multiplied_round -= 0x1000000LL;
    }

    int64_t multiplied = multiplied_round >> 24;

    return numf_t((int32_t)multiplied, nullptr);
}

numf_t numf_t::divided_by(numf_t o) const
{
    int64_t this_24 = (int64_t)i << 24;
    int64_t divided = this_24 / o.i;
    return numf_t((int32_t)divided, nullptr);
}

num_t num_t::times(num_t o) const
{
    int32_t whole_i = (int32_t)(i >> 32);
    uint32_t frac_i = (uint64_t)(i - whole_i * ((int64_t)1 << 32));

    int32_t whole_o = (int32_t)(o.i >> 32);
    uint32_t frac_o = (uint64_t)(o.i - whole_o * ((int64_t)1 << 32));

    int64_t whole_i_times_o = whole_i * o.i;

    int64_t frac_i_times_whole_o = (int64_t)frac_i * whole_o;

    uint64_t frac_i_times_frac_o_32 = (uint64_t)frac_i * frac_o;

    // banker's rounding
    uint64_t frac_i_times_frac_o_round = (frac_i_times_frac_o_32 + ((uint64_t)1 << 31));
    if((frac_i_times_frac_o_round & 0xFFFFFFFFULL) == 0)
    {
        if(frac_i_times_frac_o_round & 0x100000000ULL)
            frac_i_times_frac_o_round -= 0x100000000ULL;
    }

    int64_t frac_i_times_frac_o = frac_i_times_frac_o_round >> 32;

    return num_t(whole_i_times_o + frac_i_times_whole_o + frac_i_times_frac_o, nullptr);
}

num_t num_t::divided_by(num_t o) const
{
    return num_t(Fixed64::DivPrecise(i, o.i), nullptr);
}

num_t num_t::sqrt(num_t x)
{
    return num_t(Fixed64::Sqrt(x.i), nullptr);
}

num_t num_t::sin(num_t x)
{
    return num_t(Fixed64::Cos(x.i), nullptr);
}

num_t num_t::cos(num_t x)
{
    return num_t(Fixed64::Cos(x.i), nullptr);
}

num_t num_t::atan2(num_t y, num_t x)
{
    return num_t(Fixed64::Atan2(y.i, x.i), nullptr);
}


================================================
FILE: lib/fixed_point.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XT_FIXED_POINT_H
#define XT_FIXED_POINT_H

// FIXME: define q_t: x int, / 10000 _r

#if ((-1) >> 1) == 0
#error "TheXTech requires floor semantics (mandated by C++20 and higher) for signed right shift."
#endif

#include <cstddef>
#include <cstdint>
#include <stdexcept>

struct q_t
{
    const int16_t num;
    const int16_t den;

    constexpr q_t(int16_t num, int16_t den) : num(num), den(den) {}
};

struct qdec_t
{
    int32_t num;

    explicit constexpr qdec_t(int32_t num) : num(num) {}
    qdec_t(const qdec_t &) = default;

    qdec_t& operator=(const qdec_t&) = default;
    qdec_t operator-() const
    {
        return qdec_t(-num);
    }
};

struct qbin_t
{
    const int16_t num;

    explicit constexpr qbin_t(int16_t num) : num(num) {}
    qbin_t operator-() const
    {
        return qbin_t(-num);
    }
};

struct qidec_t
{
    const int32_t num;

    explicit constexpr qidec_t(int32_t num) : num(num) {}
    qidec_t operator-() const
    {
        return qidec_t(-num);
    }
};

struct qibin_t
{
    const int16_t den;

    explicit constexpr qibin_t(int16_t den) : den(den) {}
    qibin_t operator-() const
    {
        return qibin_t(-den);
    }
};

// s8.24 fixed point
struct numf_t
{
public:
    int32_t i;

    numf_t() {}
    constexpr numf_t(const numf_t& o) : i(o.i) {}
    constexpr numf_t(int _i) : i((int32_t)_i << 24) {}
    explicit constexpr numf_t(int32_t _i, std::nullptr_t) : i(_i) {}
    explicit constexpr numf_t(double _i, std::nullptr_t) : i((int32_t)(_i * (1 << 24))) {}

    numf_t& operator=(const numf_t&) = default;

    explicit constexpr operator bool() const
    {
        return (bool)i;
    }

    explicit constexpr operator unsigned char() const
    {
        return i / (1 << 24);
    }

    explicit constexpr operator unsigned short() const
    {
        return i / (1 << 24);
    }

    explicit constexpr operator int32_t() const
    {
        return i / (1 << 24);
    }

    explicit constexpr operator double() const
    {
        return (double)(i) / (1 << 24);
    }

    constexpr numf_t operator-() const
    {
        return numf_t(-i, nullptr);
    }

    constexpr numf_t operator*(int o) const
    {
        return numf_t(i * o, nullptr);
    }

    constexpr numf_t operator/(int o) const
    {
        return numf_t(i / o, nullptr);
    }

    numf_t& operator+=(numf_t o)
    {
        *this = *this + o;
        return *this;
    }

    numf_t& operator-=(numf_t o)
    {
        *this = *this - o;
        return *this;
    }

    constexpr numf_t operator+(numf_t o) const
    {
        return numf_t(i + o.i, nullptr);
    }

    constexpr numf_t operator-(numf_t o) const
    {
        return numf_t(i - o.i, nullptr);
    }

    numf_t times(numf_t o) const;
    numf_t divided_by(numf_t o) const;

    constexpr bool operator<=(const numf_t& o) const { return i <= o.i; }
    constexpr bool operator<(const numf_t& o) const { return i < o.i; }
    constexpr bool operator>=(const numf_t& o) const { return i >= o.i; }
    constexpr bool operator>(const numf_t& o) const { return i > o.i; }
    constexpr bool operator==(const numf_t& o) const { return i == o.i; }
    constexpr bool operator!=(const numf_t& o) const { return i != o.i; }
};

// s32.32 fixed point
struct num_t
{
public:
    int64_t i;

    num_t() {}
    constexpr num_t(const num_t& o) : i(o.i) {}
    constexpr num_t(short _i) : i((int64_t)_i << 32) {}
    constexpr num_t(int _i) : i((int64_t)_i << 32) {}
    constexpr num_t(long _i) : i((int64_t)_i << 32) {}
    constexpr num_t(long long _i) : i((int64_t)_i << 32) {}
    constexpr num_t(unsigned short _i) : i((int64_t)_i << 32) {}
    constexpr num_t(unsigned int _i) : i((int64_t)_i << 32) {}
    constexpr num_t(unsigned long _i) : i((int64_t)_i << 32) {}
    constexpr num_t(unsigned long long _i) : i((int64_t)_i << 32) {}
    constexpr num_t(double _i) = delete;

    explicit constexpr num_t(int64_t _i, std::nullptr_t) : i(_i) {}
    explicit constexpr num_t(double _i, std::nullptr_t) : i((int64_t)(_i * ((int64_t)1 << 32))) {}

    explicit constexpr num_t(numf_t _i) : i(int64_t(_i.i) * 256) {}

    num_t& operator=(const num_t&) = default;

    num_t& operator++()
    {
        i += ((int64_t)1 << 32);
        return *this;
    }

    num_t operator++(int)
    {
        num_t ret = *this;
        i += ((int64_t)1 << 32);
        return ret;
    }

    num_t& operator+=(num_t o)
    {
        *this = *this + o;
        return *this;
    }

    num_t& operator-=(num_t o)
    {
        *this = *this - o;
        return *this;
    }

    // num_t& operator*=(num_t o)
    // {
    //     *this = *this * o;
    //     return *this;
    // }

    num_t& operator*=(int o)
    {
        i *= o;
        return *this;
    }

    num_t& operator/=(int o)
    {
        i /= o;
        return *this;
    }

    constexpr num_t operator+(num_t o) const
    {
        return num_t(i + o.i, nullptr);
    }

    constexpr num_t operator-(num_t o) const
    {
        return num_t(i - o.i, nullptr);
    }

    constexpr num_t operator-() const
    {
        return num_t(-i, nullptr);
    }

    num_t& operator*=(q_t o)
    {
        *this = *this * o;
        return *this;
    }

    num_t& operator*=(qdec_t o)
    {
        *this = *this * o;
        return *this;
    }

    num_t& operator*=(qbin_t o)
    {
        *this = *this * o;
        return *this;
    }

    num_t& operator/=(qidec_t o)
    {
        *this = *this / o;
        return *this;
    }

    num_t& operator/=(qibin_t o)
    {
        *this = *this / o;
        return *this;
    }

    constexpr num_t operator*(q_t o) const
    {
        return num_t(i * o.num / o.den, nullptr);
    }

    constexpr num_t operator/(q_t o) const
    {
        return num_t(i * o.den / o.num, nullptr);
    }

    constexpr num_t operator*(qdec_t o) const
    {
        return num_t(i * o.num / 10000, nullptr);
    }

    constexpr num_t operator/(qidec_t o) const
    {
        return num_t(i * 10000 / o.num, nullptr);
    }

    constexpr num_t operator*(qbin_t o) const
    {
        return num_t(i * o.num / 256, nullptr);
    }

    constexpr num_t operator/(qibin_t o) const
    {
        return num_t(i * o.den / 256, nullptr);
    }

    explicit constexpr operator unsigned char() const
    {
        return i / ((int64_t)1 << 32);
    }

    explicit constexpr operator unsigned short() const
    {
        return i / ((int64_t)1 << 32);
    }

    explicit constexpr operator short() const
    {
        return i / ((int64_t)1 << 32);
    }

    explicit constexpr operator int() const
    {
        return i / ((int64_t)1 << 32);
    }

    explicit constexpr operator long() const
    {
        return i / ((int64_t)1 << 32);
    }

    explicit constexpr operator long long() const
    {
        return i / ((int64_t)1 << 32);
    }

    explicit constexpr operator size_t() const
    {
        return i / ((int64_t)1 << 32);
    }

    explicit constexpr operator double() const
    {
        return (double)(i) / ((int64_t)1 << 32);
    }

    explicit constexpr operator numf_t() const
    {
        // banker's rounding, assume no overflow
        return numf_t((int32_t)(((!(i & 0x17f) && (i & 0x80)) ? i : (i + 0x80)) >> 8), nullptr);
    }

    static inline constexpr num_t from_double(double _i)
    {
        return num_t(_i, nullptr);
    }

    static inline constexpr num_t abs(num_t x)
    {
        return num_t(x.i > 0 ? x.i : -x.i, nullptr);
    }

    static inline constexpr int32_t vb6round(num_t x)
    {
        // first test: does x % 1 == 0.5? second test: does (x + 0.5) % 2 == 1? if both, then subtract 0.5, otherwise add 0.5 and floor
        return ((((x.i + ((int64_t)1 << 31)) & 0xFFFFFFFFLL) == 0) && (((x.i + ((int64_t)1 << 31)) & 0x100000000LL) != 0))
            ? ((x.i - ((int64_t)1 << 31)) >> 32)
            : ((x.i + ((int64_t)1 << 31)) >> 32);
    }

    static inline constexpr int32_t round(num_t x)
    {
        return ((x.i >= 0 ? x.i + ((int64_t)1 << 31) : x.i - ((int64_t)1 << 31)) / ((int64_t)1 << 32));
    }

    static inline constexpr int32_t ceil(num_t x)
    {
        return (x.i + (((int64_t)1 << 32) - 1)) >> 32;
    }

    static inline constexpr int32_t floor(num_t x)
    {
        return (x.i) >> 32;
    }

    static inline constexpr num_t roundn(num_t x)
    {
        return num_t::round(x);
    }

    static inline constexpr num_t PI()
    {
        return num_t(int64_t(13493037705LL), nullptr);
    }

    static inline num_t dist2(num_t dx, num_t dy)
    {
        // FIXME
        return dx.times(dx) + dy.times(dy);
    }

    static inline bool fEqual_f(numf_t x, numf_t y)
    {
        return x == y;
    }

    static inline bool fEqual_f(num_t x, num_t y)
    {
        return x == y;
    }

    static inline bool fEqual_d(num_t x, num_t y)
    {
        return x == y;
    }

    num_t times(num_t o) const;
    num_t divided_by(num_t o) const;

    static num_t dist(num_t dx, num_t dy);
    static num_t idist(num_t dx, num_t dy);

    static num_t sqrt(num_t dx);

    static num_t cos(num_t dx);
    static num_t sin(num_t dx);
    static num_t atan2(num_t y, num_t x);

    explicit constexpr operator bool() const
    {
        return (bool)i;
    }

    constexpr bool operator<=(const num_t& o) const { return i <= o.i; }
    constexpr bool operator<(const num_t& o) const { return i < o.i; }
    constexpr bool operator>=(const num_t& o) const { return i >= o.i; }
    constexpr bool operator>(const num_t& o) const { return i > o.i; }
    constexpr bool operator==(const num_t& o) const { return i == o.i; }
    constexpr bool operator!=(const num_t& o) const { return i != o.i; }
};

static inline constexpr num_t operator ""_n(long double d)
{
    return num_t((double)d, nullptr);
}

static inline constexpr numf_t operator ""_nf(long double d)
{
    return numf_t((double)d, nullptr);
}

static inline constexpr num_t operator ""_n(unsigned long long i)
{
    return (num_t)(int64_t)i;
}

static inline constexpr numf_t operator ""_nf(unsigned long long i)
{
    return (numf_t)(int)i;
}

#ifdef __cpp_consteval
#define maybe_consteval consteval
#else
#define maybe_consteval constexpr
#endif

static inline maybe_consteval qdec_t operator ""_r(long double d)
{
    return
#ifdef __cpp_consteval
        (d == (int)(d * 256) / 256.0l) ? (throw std::logic_error("_r should not be used with multiples of 1/256")) :
        (1 / d == (int)(1 / d)) ? (throw std::logic_error("_r should not be used with inverses of whole numbers")) :
        (d != (int)(d * 10000 + ((d > 0) ? 0.000001 : -0.000001)) / 10000.0l) ? (throw std::logic_error("_r may only be used with multiples of 0.0001")) :
#endif
        qdec_t((int)(d * 10000 + ((d > 0) ? 0.000001 : -0.000001)));
}

static inline maybe_consteval qbin_t operator ""_rb(long double d)
{
    return
#ifdef __cpp_consteval
        (d != (int)(d * 256) / 256.0l) ? (throw std::logic_error("_rb may only be used with multiples of 1/256")) :
        (d >= 128.0 || d <= -128.0) ? (throw std::logic_error("_rb may only be used with numbers between -128 and 128")) :
#endif
        qbin_t((int)(d * 256));
}

static inline maybe_consteval qidec_t operator ""_ri(long double d)
{
    return
#ifdef __cpp_consteval
        ((1.0 / d) == (int)((1.0 / d) * 256) / 256.0l) ? (throw std::logic_error("_ri should not be used with divisors of 256")) :
        (d != (int)(d * 10000 + ((d > 0) ? 0.000001 : -0.000001)) / 10000.0l) ? (throw std::logic_error("_ri may only be used with multiples of 0.0001")) :
#endif
        qidec_t((int)(d * 10000 + ((d > 0) ? 0.000001 : -0.000001)));
}

static inline maybe_consteval qibin_t operator ""_rib(long double d)
{
    return
#ifdef __cpp_consteval
        ((1.0 / d) != (int)((1.0 / d) * 256) / 256.0l) ? (throw std::logic_error("_rib may only be used with divisors of 256")) :
        ((1.0 / d) >= 128.0 || (1.0 / d) <= -128.0) ? (throw std::logic_error("_rib may only be used with numbers with magnitude greater than 1/128")) :
#endif
        qibin_t((int)((1.0 / d) * 256));
}

static inline constexpr num_t operator +(short a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(int a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(long a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(long long a, num_t b) { return (num_t)a + b; }

static inline constexpr num_t operator +(unsigned short a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(unsigned int a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(unsigned long a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(unsigned long long a, num_t b) { return (num_t)a + b; }

static inline constexpr num_t operator -(short a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(int a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(long a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(long long a, num_t b) { return (num_t)a - b; }

static inline constexpr num_t operator -(unsigned short a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(unsigned int a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(unsigned long a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(unsigned long long a, num_t b) { return (num_t)a - b; }

static inline constexpr num_t operator *(short a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(int a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(long a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(long long a, num_t b) { return num_t((int64_t)(b.i * a), nullptr); }

static inline constexpr num_t operator *(unsigned short a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(unsigned int a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(unsigned long a, num_t b) { return num_t((int64_t)(b.i * a), nullptr); }
static inline constexpr num_t operator *(unsigned long long a, num_t b) { return num_t((int64_t)(b.i * a), nullptr); }

static inline constexpr num_t operator *(num_t b, short a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, int a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, long a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, long long a) { return num_t((int64_t)(b.i * a), nullptr); }

static inline constexpr num_t operator *(num_t b, unsigned short a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, unsigned int a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, unsigned long a) { return num_t((int64_t)(b.i * a), nullptr); }
static inline constexpr num_t operator *(num_t b, unsigned long long a) { return num_t((int64_t)(b.i * a), nullptr); }

static inline constexpr num_t operator *(qdec_t a, num_t b) { return b * a; }
static inline constexpr num_t operator *(qbin_t a, num_t b) { return b * a; }

static inline constexpr num_t operator /(num_t a, short b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, int b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, long b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, long long b) { return num_t((int64_t)(a.i / b), nullptr); }

static inline constexpr num_t operator /(num_t a, unsigned short b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, unsigned int b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, unsigned long b) { return num_t((int64_t)(a.i / b), nullptr); }
static inline constexpr num_t operator /(num_t a, unsigned long long b) { return num_t((int64_t)(a.i / b), nullptr); }

// comparison operators

static inline constexpr num_t operator <(short a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(int a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(long a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(long long a, num_t b) { return (num_t)a < b; }

static inline constexpr num_t operator <(unsigned short a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(unsigned int a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(unsigned long a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(unsigned long long a, num_t b) { return (num_t)a < b; }

static inline constexpr num_t operator <=(short a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(int a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(long a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(long long a, num_t b) { return (num_t)a <= b; }

static inline constexpr num_t operator <=(unsigned short a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(unsigned int a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(unsigned long a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(unsigned long long a, num_t b) { return (num_t)a <= b; }

static inline constexpr num_t operator >(short a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(int a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(long a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(long long a, num_t b) { return (num_t)a > b; }

static inline constexpr num_t operator >(unsigned short a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(unsigned int a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(unsigned long a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(unsigned long long a, num_t b) { return (num_t)a > b; }

static inline constexpr num_t operator >=(short a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(int a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(long a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(long long a, num_t b) { return (num_t)a >= b; }

static inline constexpr num_t operator >=(unsigned short a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(unsigned int a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(unsigned long a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(unsigned long long a, num_t b) { return (num_t)a >= b; }

static inline constexpr num_t operator ==(short a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(int a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(long a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(long long a, num_t b) { return (num_t)a == b; }

static inline constexpr num_t operator ==(unsigned short a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(unsigned int a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(unsigned long a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(unsigned long long a, num_t b) { return (num_t)a == b; }

static inline constexpr num_t operator !=(short a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(int a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(long a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(long long a, num_t b) { return (num_t)a != b; }

static inline constexpr num_t operator !=(unsigned short a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(unsigned int a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(unsigned long a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(unsigned long long a, num_t b) { return (num_t)a != b; }

// this operator should be used to indicate that a num_t contains an int and may be treated as an int if needed
using int_ok = int;

// this is used for temporary values that were Singles in VB6
using tempf_t = num_t;

#endif // #ifndef XT_FIXED_POINT_H


================================================
FILE: lib/floating_point.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "floating_point.h"
#include <cmath>
#include <cfenv>

#if defined(VITA) || defined(__3DS__)
#define USE_CUSTOM_TONEAREST
#endif

#ifdef USE_CUSTOM_TONEAREST
#include <pge_tonearest.h>
#endif

int32_t num_t::vb6round(num_t x)
{
#ifdef USE_CUSTOM_TONEAREST
        return pge_toNearest(x.i);
#else
        int round_old = std::fegetround();
        if(round_old == FE_TONEAREST)
            return std::nearbyint(x.i);
        else
        {
            std::fesetround(FE_TONEAREST);
            int32_t ret = std::nearbyint(x.i);
            std::fesetround(round_old);
            return ret;
        }
#endif
}

num_t num_t::dist(num_t dx, num_t dy)
{
    return num_t(std::sqrt(dx.i * dx.i + dy.i * dy.i), nullptr);
}

num_t num_t::idist(num_t dx, num_t dy)
{
    return num_t(1 / std::sqrt(dx.i * dx.i + dy.i * dy.i), nullptr);
}

num_t num_t::times(num_t o) const
{
    return num_t(i * o.i, nullptr);
}

num_t num_t::divided_by(num_t o) const
{
    return num_t(i / o.i, nullptr);
}

num_t num_t::sqrt(num_t x)
{
    return num_t(std::sqrt(x.i), nullptr);
}

num_t num_t::sin(num_t x)
{
    return num_t(std::sin(x.i), nullptr);
}

num_t num_t::cos(num_t x)
{
    return num_t(std::cos(x.i), nullptr);
}

num_t num_t::atan2(num_t y, num_t x)
{
    return num_t(std::atan2(y.i, x.i), nullptr);
}


================================================
FILE: lib/floating_point.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XT_FLOATING_POINT_H
#define XT_FLOATING_POINT_H

#include <stdint.h>
#include <cstddef>
#include <cmath>

struct num_t;

struct num_muldiv_t
{
public:
    double i;

    explicit constexpr num_muldiv_t(long double _i) : i(_i) {}
    explicit constexpr num_muldiv_t(num_t n);

    constexpr num_muldiv_t operator-() const
    {
        return num_muldiv_t(-i);
    }
};

using qdec_t = num_muldiv_t;
using qbin_t = num_muldiv_t;
using qidec_t = num_muldiv_t;
using qibin_t = num_muldiv_t;

struct numf_t
{
public:
    float i;

    numf_t() {}
    constexpr numf_t(const numf_t& o) : i(o.i) {}
    constexpr numf_t(int _i) : i(_i) {}
    constexpr numf_t(long _i) : i(_i) {}
    constexpr numf_t(long long _i) : i(_i) {}
    constexpr numf_t(float _i) = delete;

    explicit constexpr numf_t(float _i, std::nullptr_t) : i(_i) {}

    numf_t& operator=(const numf_t&) = default;

    constexpr bool operator<=(const numf_t& o) const { return i <= o.i; }
    constexpr bool operator<(const numf_t& o) const { return i < o.i; }
    constexpr bool operator>=(const numf_t& o) const { return i >= o.i; }
    constexpr bool operator>(const numf_t& o) const { return i > o.i; }
    constexpr bool operator==(const numf_t& o) const { return i == o.i; }
    constexpr bool operator!=(const numf_t& o) const { return i != o.i; }

    numf_t& operator+=(numf_t o)
    {
        *this = *this + o;
        return *this;
    }

    numf_t& operator-=(numf_t o)
    {
        *this = *this - o;
        return *this;
    }

    numf_t& operator*=(int o)
    {
        i *= o;
        return *this;
    }

    numf_t& operator/=(int o)
    {
        i /= o;
        return *this;
    }

    constexpr numf_t operator+(numf_t o) const
    {
        return numf_t(i + o.i, nullptr);
    }

    constexpr numf_t operator-(numf_t o) const
    {
        return numf_t(i - o.i, nullptr);
    }

    constexpr numf_t operator-() const
    {
        return numf_t(-i, nullptr);
    }

    constexpr numf_t operator*(int o) const
    {
        return numf_t(i * o, nullptr);
    }

    constexpr numf_t operator/(int o) const
    {
        return numf_t(i / o, nullptr);
    }

    explicit constexpr operator unsigned char() const
    {
        return i;
    }

    explicit constexpr operator unsigned short() const
    {
        return i;
    }

    explicit constexpr operator short() const
    {
        return i;
    }

    explicit constexpr operator int() const
    {
        return i;
    }

    explicit constexpr operator long() const
    {
        return i;
    }

    explicit constexpr operator long long() const
    {
        return i;
    }

    explicit constexpr operator double() const
    {
        return i;
    }

    explicit constexpr operator bool() const
    {
        return (bool)i;
    }

    numf_t times(numf_t o) const
    {
        return numf_t(i * o.i, nullptr);
    }

    numf_t divided_by(numf_t o) const
    {
        return numf_t(i / o.i, nullptr);
    }
};

struct num_t
{
public:
    double i;

    num_t() {}
    constexpr num_t(const num_t& o) : i(o.i) {}
    constexpr num_t(short _i) : i(_i) {}
    constexpr num_t(int _i) : i(_i) {}
    constexpr num_t(long _i) : i(_i) {}
    constexpr num_t(long long _i) : i(_i) {}
    constexpr num_t(unsigned short _i) : i(_i) {}
    constexpr num_t(unsigned int _i) : i(_i) {}
    constexpr num_t(unsigned long _i) : i(_i) {}
    constexpr num_t(unsigned long long _i) : i(_i) {}
    constexpr num_t(double _i) = delete;

    constexpr num_t(int64_t _i, std::nullptr_t) : i(_i) {}
    explicit constexpr num_t(long double _i, std::nullptr_t) : i(_i) {}
    explicit constexpr num_t(double _i, std::nullptr_t) : i(_i) {}

    explicit constexpr num_t(numf_t _i) : i(_i.i) {}

    num_t& operator=(const num_t&) = default;

    num_t& operator++()
    {
        i += 1;
        return *this;
    }

    num_t operator++(int)
    {
        num_t ret = *this;
        i += 1;
        return ret;
    }

    num_t& operator+=(num_t o)
    {
        *this = *this + o;
        return *this;
    }

    num_t& operator-=(num_t o)
    {
        *this = *this - o;
        return *this;
    }

    // num_t& operator*=(num_t o)
    // {
    //     *this = *this * o;
    //     return *this;
    // }

    num_t& operator*=(int o)
    {
        i *= o;
        return *this;
    }

    num_t& operator/=(int o)
    {
        i /= o;
        return *this;
    }

    constexpr num_t operator+(num_t o) const
    {
        return num_t(i + o.i, nullptr);
    }

    constexpr num_t operator-(num_t o) const
    {
        return num_t(i - o.i, nullptr);
    }

    constexpr num_t operator-() const
    {
        return num_t(-i, nullptr);
    }

    num_t& operator*=(num_muldiv_t o)
    {
        *this = *this * o;
        return *this;
    }

    num_t& operator/=(num_muldiv_t o)
    {
        *this = *this / o;
        return *this;
    }

    constexpr num_t operator*(num_muldiv_t o) const
    {
        return num_t(i * o.i, nullptr);
    }

    constexpr num_t operator/(num_muldiv_t o) const
    {
        return num_t(i / o.i, nullptr);
    }

    explicit constexpr operator unsigned char() const
    {
        return i;
    }

    explicit constexpr operator unsigned short() const
    {
        return i;
    }

    explicit constexpr operator short() const
    {
        return i;
    }

    explicit constexpr operator int() const
    {
        return i;
    }

    explicit constexpr operator long() const
    {
        return i;
    }

    explicit constexpr operator long long() const
    {
        return i;
    }

    explicit constexpr operator numf_t() const
    {
        return numf_t(i, nullptr);
    }

    explicit constexpr operator double() const
    {
        return i;
    }

    explicit constexpr operator size_t() const
    {
        return i;
    }

    static inline constexpr num_t from_double(double _i)
    {
        return num_t(_i, nullptr);
    }

    static inline constexpr num_t abs(num_t x)
    {
        return num_t(x.i > 0 ? x.i : -x.i, nullptr);
    }

    static inline int32_t round(num_t x)
    {
        return std::round(x.i);
    }

    static inline int32_t ceil(num_t x)
    {
        return std::ceil(x.i);
    }

    static inline int32_t floor(num_t x)
    {
        return std::floor(x.i);
    }

    static inline num_t roundn(num_t x)
    {
        return num_t(std::round(x.i), nullptr);
    }

    static inline constexpr num_t PI()
    {
        return num_t(3.14159265358979323846264338327950288, nullptr);
    }

    static inline num_t dist2(num_t dx, num_t dy)
    {
        return dx.times(dx) + dy.times(dy);
    }

    static inline bool fEqual_d(num_t x, num_t y)
    {
        return (int64_t)std::round(x.i * 1000000) == (int64_t)std::round(y.i * 1000000);
    }

    static inline bool fEqual_f(num_t x, num_t y)
    {
        return (int64_t)std::round(x.i * 10000) == (int64_t)std::round(y.i * 10000);
    }

    static inline bool fEqual_f(numf_t x, numf_t y)
    {
        return (int64_t)std::round(x.i * 10000) == (int64_t)std::round(y.i * 10000);
    }

    num_t times(num_t o) const;
    num_t divided_by(num_t o) const;

    static int32_t vb6round(num_t x);

    static num_t dist(num_t dx, num_t dy);
    static num_t idist(num_t dx, num_t dy);

    static num_t sqrt(num_t dx);

    static num_t cos(num_t dx);
    static num_t sin(num_t dx);
    static num_t atan2(num_t y, num_t x);

    explicit constexpr operator bool() const
    {
        return (bool)i;
    }

    constexpr bool operator<=(const num_t& o) const { return i <= o.i; }
    constexpr bool operator<(const num_t& o) const { return i < o.i; }
    constexpr bool operator>=(const num_t& o) const { return i >= o.i; }
    constexpr bool operator>(const num_t& o) const { return i > o.i; }
    constexpr bool operator==(const num_t& o) const { return i == o.i; }
    constexpr bool operator!=(const num_t& o) const { return i != o.i; }
};

constexpr num_muldiv_t::num_muldiv_t(num_t n) : i(n.i) {}


static inline constexpr num_t operator ""_n(long double d)
{
    return num_t(d, nullptr);
}

static inline constexpr numf_t operator ""_nf(long double d)
{
    return numf_t(d, nullptr);
}

static inline constexpr num_t operator ""_n(unsigned long long i)
{
    return (num_t)(int64_t)i;
}

static inline constexpr numf_t operator ""_nf(unsigned long long i)
{
    return (numf_t)(int)i;
}

static inline constexpr num_muldiv_t operator ""_r(long double d)
{
    return num_muldiv_t(d);
}

static inline constexpr qbin_t operator ""_rb(long double d)
{
    return num_muldiv_t(d);
}

static inline constexpr qidec_t operator ""_ri(long double d)
{
    return num_muldiv_t(d);
}

static inline constexpr qibin_t operator ""_rib(long double d)
{
    return num_muldiv_t(d);
}

static inline constexpr numf_t operator *(int a, numf_t b) { return numf_t(b.i * a, nullptr); }

static inline constexpr num_t operator +(short a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(int a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(long a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(long long a, num_t b) { return (num_t)a + b; }

static inline constexpr num_t operator +(unsigned short a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(unsigned int a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(unsigned long a, num_t b) { return (num_t)a + b; }
static inline constexpr num_t operator +(unsigned long long a, num_t b) { return (num_t)a + b; }

static inline constexpr num_t operator -(short a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(int a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(long a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(long long a, num_t b) { return (num_t)a - b; }

static inline constexpr num_t operator -(unsigned short a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(unsigned int a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(unsigned long a, num_t b) { return (num_t)a - b; }
static inline constexpr num_t operator -(unsigned long long a, num_t b) { return (num_t)a - b; }

static inline constexpr num_t operator *(short a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(int a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(long a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(long long a, num_t b) { return num_t(b.i * a, nullptr); }

static inline constexpr num_t operator *(unsigned short a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(unsigned int a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(unsigned long a, num_t b) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(unsigned long long a, num_t b) { return num_t(b.i * a, nullptr); }

static inline constexpr num_t operator *(num_t b, short a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, int a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, long a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, long long a) { return num_t(b.i * a, nullptr); }

static inline constexpr num_t operator *(num_t b, unsigned short a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, unsigned int a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, unsigned long a) { return num_t(b.i * a, nullptr); }
static inline constexpr num_t operator *(num_t b, unsigned long long a) { return num_t(b.i * a, nullptr); }

static inline constexpr num_t operator *(num_muldiv_t a, num_t b) { return b * a; }

static inline constexpr num_t operator /(num_t a, short b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, int b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, long b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, long long b) { return num_t(a.i / b, nullptr); }

static inline constexpr num_t operator /(num_t a, unsigned short b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, unsigned int b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, unsigned long b) { return num_t(a.i / b, nullptr); }
static inline constexpr num_t operator /(num_t a, unsigned long long b) { return num_t(a.i / b, nullptr); }


// comparison operators

static inline constexpr num_t operator <(short a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(int a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(long a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(long long a, num_t b) { return (num_t)a < b; }

static inline constexpr num_t operator <(unsigned short a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(unsigned int a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(unsigned long a, num_t b) { return (num_t)a < b; }
static inline constexpr num_t operator <(unsigned long long a, num_t b) { return (num_t)a < b; }

static inline constexpr num_t operator <=(short a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(int a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(long a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(long long a, num_t b) { return (num_t)a <= b; }

static inline constexpr num_t operator <=(unsigned short a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(unsigned int a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(unsigned long a, num_t b) { return (num_t)a <= b; }
static inline constexpr num_t operator <=(unsigned long long a, num_t b) { return (num_t)a <= b; }

static inline constexpr num_t operator >(short a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(int a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(long a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(long long a, num_t b) { return (num_t)a > b; }

static inline constexpr num_t operator >(unsigned short a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(unsigned int a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(unsigned long a, num_t b) { return (num_t)a > b; }
static inline constexpr num_t operator >(unsigned long long a, num_t b) { return (num_t)a > b; }

static inline constexpr num_t operator >=(short a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(int a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(long a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(long long a, num_t b) { return (num_t)a >= b; }

static inline constexpr num_t operator >=(unsigned short a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(unsigned int a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(unsigned long a, num_t b) { return (num_t)a >= b; }
static inline constexpr num_t operator >=(unsigned long long a, num_t b) { return (num_t)a >= b; }

static inline constexpr num_t operator ==(short a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(int a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(long a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(long long a, num_t b) { return (num_t)a == b; }

static inline constexpr num_t operator ==(unsigned short a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(unsigned int a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(unsigned long a, num_t b) { return (num_t)a == b; }
static inline constexpr num_t operator ==(unsigned long long a, num_t b) { return (num_t)a == b; }

static inline constexpr num_t operator !=(short a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(int a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(long a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(long long a, num_t b) { return (num_t)a != b; }

static inline constexpr num_t operator !=(unsigned short a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(unsigned int a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(unsigned long a, num_t b) { return (num_t)a != b; }
static inline constexpr num_t operator !=(unsigned long long a, num_t b) { return (num_t)a != b; }

// this operator should be used to indicate that a num_t contains an int and may be treated as an int if needed
using int_ok = num_muldiv_t;

// this is used for temporary values that were Singles in VB6
using tempf_t = numf_t;

#endif // #ifndef XT_FLOATING_POINT_H


================================================
FILE: lib/fmt/CMakeLists.txt
================================================
message(STATUS "CMake version: ${CMAKE_VERSION}")

cmake_minimum_required(VERSION 2.8.12)

if (POLICY CMP0048) # Version variables
  cmake_policy(SET CMP0048 OLD)
endif ()

if (POLICY CMP0063) # Visibility
  cmake_policy(SET CMP0063 OLD)
endif (POLICY CMP0063)

# Determine if fmt is built as a subproject (using add_subdirectory)
# or if it is the master project.
set(MASTER_PROJECT OFF)
if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
  set(MASTER_PROJECT ON)
endif ()

# Joins arguments and places the results in ${result_var}.
function(join result_var)
  set(result )
  foreach (arg ${ARGN})
    set(result "${result}${arg}")
  endforeach ()
  set(${result_var} "${result}" PARENT_SCOPE)
endfunction()

# Set the default CMAKE_BUILD_TYPE to Release.
# This should be done before the project command since the latter can set
# CMAKE_BUILD_TYPE itself (it does so for nmake).
if (NOT CMAKE_BUILD_TYPE)
  join(doc "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
           "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
  set(CMAKE_BUILD_TYPE Release CACHE STRING ${doc})
endif ()

option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)

# Options that control generation of various targets.
option(FMT_DOC "Generate the doc target." ${MASTER_PROJECT})
option(FMT_INSTALL "Generate the install target." ${MASTER_PROJECT})
option(FMT_TEST "Generate the test target." ${MASTER_PROJECT})
option(FMT_USE_CPP11 "Enable the addition of C++11 compiler flags." ON)

project(FMT)

# Starting with cmake 3.0 VERSION is part of the project command.
file(READ fmt/format.h format_h)
if (NOT format_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
  message(FATAL_ERROR "Cannot get FMT_VERSION from format.h.")
endif ()
# Use math to skip leading zeros if any.
math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
                 ${CPACK_PACKAGE_VERSION_PATCH})
message(STATUS "Version: ${FMT_VERSION}")

message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
  "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")

include(cxx11)

if (CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -Wshadow -pedantic)
endif ()

if (MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
  # If Microsoft SDK is installed create script run-msbuild.bat that
  # calls SetEnv.cmd to set up build environment and runs msbuild.
  # It is useful when building Visual Studio projects with the SDK
  # toolchain rather than Visual Studio.
  include(FindSetEnv)
  if (WINSDK_SETENV)
    set(MSBUILD_SETUP "call \"${WINSDK_SETENV}\"")
  endif ()
  # Set FrameworkPathOverride to get rid of MSB3644 warnings.
  set(netfxpath "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.0")
  file(WRITE run-msbuild.bat "
    ${MSBUILD_SETUP}
    ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
endif ()

include(CheckSymbolExists)
if (WIN32)
  check_symbol_exists(open io.h HAVE_OPEN)
else ()
  check_symbol_exists(open fcntl.h HAVE_OPEN)
endif ()

add_subdirectory(fmt)

if (FMT_DOC)
  add_subdirectory(doc)
endif ()

if (FMT_TEST)
  enable_testing()
  add_subdirectory(test)
endif ()

set(gitignore ${PROJECT_SOURCE_DIR}/.gitignore)
if (MASTER_PROJECT AND EXISTS ${gitignore})
  # Get the list of ignored files from .gitignore.
  file (STRINGS ${gitignore} lines)
  LIST(REMOVE_ITEM lines /doc/html)
  foreach (line ${lines})
    string(REPLACE "." "[.]" line "${line}")
    string(REPLACE "*" ".*" line "${line}")
    set(ignored_files ${ignored_files} "${line}$" "${line}/")
  endforeach ()
  set(ignored_files ${ignored_files}
    /.git /breathe /format-benchmark sphinx/ .buildinfo .doctrees)

  set(CPACK_SOURCE_GENERATOR ZIP)
  set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
  set(CPACK_SOURCE_PACKAGE_FILE_NAME fmt-${FMT_VERSION})
  set(CPACK_PACKAGE_NAME fmt)
  set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.rst)
  include(CPack)
endif ()


================================================
FILE: lib/fmt/CONTRIBUTING.rst
================================================
Contributing to fmt
===================

All C++ code must adhere to `Google C++ Style Guide
<https://google.github.io/styleguide/cppguide.html>`_ with the following
exceptions:

* Exceptions are permitted
* snake_case should be used instead of UpperCamelCase for function names

Thanks for contributing!


================================================
FILE: lib/fmt/LICENSE.rst
================================================
Copyright (c) 2012 - 2016, Victor Zverovich

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


================================================
FILE: lib/fmt/README.rst
================================================
{fmt}
=====

.. image:: https://travis-ci.org/fmtlib/fmt.png?branch=master
   :target: https://travis-ci.org/fmtlib/fmt

.. image:: https://ci.appveyor.com/api/projects/status/ehjkiefde6gucy1v
   :target: https://ci.appveyor.com/project/vitaut/fmt
   
.. image:: https://badges.gitter.im/Join%20Chat.svg
   :alt: Join the chat at https://gitter.im/fmtlib/fmt
   :target: https://gitter.im/fmtlib/fmt

**fmt** is an open-source formatting library for C++.
It can be used as a safe alternative to printf or as a fast
alternative to IOStreams.

`Documentation <http://fmtlib.net/latest/>`_

Features
--------

* Two APIs: faster concatenation-based `write API
  <http://fmtlib.net/latest/api.html#write-api>`_ and slower,
  but still very fast, replacement-based `format API
  <http://fmtlib.net/latest/api.html#format-api>`_ with positional arguments
  for localization.
* Write API similar to the one used by IOStreams but stateless allowing
  faster implementation.
* Format API with `format string syntax
  <http://fmtlib.net/latest/syntax.html>`_
  similar to the one used by `str.format
  <https://docs.python.org/2/library/stdtypes.html#str.format>`_ in Python.
* Safe `printf implementation
  <http://fmtlib.net/latest/api.html#printf-formatting-functions>`_
  including the POSIX extension for positional arguments.
* Support for user-defined types.
* High speed: performance of the format API is close to that of
  glibc's `printf <http://en.cppreference.com/w/cpp/io/c/fprintf>`_
  and better than the performance of IOStreams. See `Speed tests`_ and
  `Fast integer to string conversion in C++
  <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_.
* Small code size both in terms of source code (the core library consists of a single
  header file and a single source file) and compiled code.
  See `Compile time and code bloat`_.
* Reliability: the library has an extensive set of `unit tests
  <https://github.com/fmtlib/fmt/tree/master/test>`_.
* Safety: the library is fully type safe, errors in format strings are
  reported using exceptions, automatic memory management prevents buffer
  overflow errors.
* Ease of use: small self-contained code base, no external dependencies,
  permissive BSD `license
  <https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_
* `Portability <http://fmtlib.net/latest/index.html#portability>`_ with consistent output
  across platforms and support for older compilers.
* Clean warning-free codebase even on high warning levels
  (-Wall -Wextra -pedantic).
* Support for wide strings.
* Optional header-only configuration enabled with the ``FMT_HEADER_ONLY`` macro.

See the `documentation <http://fmtlib.net/latest/>`_ for more details.

Examples
--------

This prints ``Hello, world!`` to stdout:

.. code:: c++

    fmt::print("Hello, {}!", "world");  // uses Python-like format string syntax
    fmt::printf("Hello, %s!", "world"); // uses printf format string syntax

Arguments can be accessed by position and arguments' indices can be repeated:

.. code:: c++

    std::string s = fmt::format("{0}{1}{0}", "abra", "cad");
    // s == "abracadabra"

fmt can be used as a safe portable replacement for ``itoa``:

.. code:: c++

    fmt::MemoryWriter w;
    w << 42;           // replaces itoa(42, buffer, 10)
    w << fmt::hex(42); // replaces itoa(42, buffer, 16)
    // access the string using w.str() or w.c_str()

An object of any user-defined type for which there is an overloaded
:code:`std::ostream` insertion operator (``operator<<``) can be formatted:

.. code:: c++

    #include "fmt/ostream.h"

    class Date {
      int year_, month_, day_;
     public:
      Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}

      friend std::ostream &operator<<(std::ostream &os, const Date &d) {
        return os << d.year_ << '-' << d.month_ << '-' << d.day_;
      }
    };

    std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
    // s == "The date is 2012-12-9"

You can use the `FMT_VARIADIC
<http://fmtlib.net/latest/api.html#utilities>`_
macro to create your own functions similar to `format
<http://fmtlib.net/latest/api.html#format>`_ and
`print <http://fmtlib.net/latest/api.html#print>`_
which take arbitrary arguments:

.. code:: c++

    // Prints formatted error message.
    void report_error(const char *format, fmt::ArgList args) {
      fmt::print("Error: ");
      fmt::print(format, args);
    }
    FMT_VARIADIC(void, report_error, const char *)

    report_error("file not found: {}", path);

Note that you only need to define one function that takes ``fmt::ArgList``
argument. ``FMT_VARIADIC`` automatically defines necessary wrappers that
accept variable number of arguments.

Projects using this library
---------------------------

* `0 A.D. <http://play0ad.com/>`_: A free, open-source, cross-platform real-time strategy game

* `AMPL/MP <https://github.com/ampl/mp>`_:
  An open-source library for mathematical programming

* `CUAUV <http://cuauv.org/>`_: Cornell University's autonomous underwater vehicle

* `Drake <http://drake.mit.edu/>`_: A planning, control, and analysis toolbox for nonlinear dynamical systems (MIT)

* `Envoy <https://lyft.github.io/envoy/>`_: C++ L7 proxy and communication bus (Lyft)

* `FiveM <https://fivem.net/>`_: a modification framework for GTA V

* `HarpyWar/pvpgn <https://github.com/pvpgn/pvpgn-server>`_:
  Player vs Player Gaming Network with tweaks

* `KBEngine <http://kbengine.org/>`_: An open-source MMOG server engine

* `Keypirinha <http://keypirinha.com/>`_: A semantic launcher for Windows

* `Kodi <https://kodi.tv/>`_ (formerly xbmc): Home theater software

* `Lifeline <https://github.com/peter-clark/lifeline>`_: A 2D game

* `MongoDB Smasher <https://github.com/duckie/mongo_smasher>`_: A small tool to generate randomized datasets

* `OpenSpace <http://openspaceproject.com/>`_: An open-source astrovisualization framework

* `PenUltima Online (POL) <http://www.polserver.com/>`_:
  An MMO server, compatible with most Ultima Online clients

* `quasardb <https://www.quasardb.net/>`_: A distributed, high-performance, associative database

* `readpe <https://bitbucket.org/sys_dev/readpe>`_: Read Portable Executable

* `redis-cerberus <https://github.com/HunanTV/redis-cerberus>`_: A Redis cluster proxy

* `Saddy <https://github.com/mamontov-cpp/saddy-graphics-engine-2d>`_:
  Small crossplatform 2D graphic engine

* `Salesforce Analytics Cloud <http://www.salesforce.com/analytics-cloud/overview/>`_:
  Business intelligence software

* `Scylla <http://www.scylladb.com/>`_: A Cassandra-compatible NoSQL data store that can handle
  1 million transactions per second on a single server

* `Seastar <http://www.seastar-project.org/>`_: An advanced, open-source C++ framework for
  high-performance server applications on modern hardware

* `spdlog <https://github.com/gabime/spdlog>`_: Super fast C++ logging library

* `Stellar <https://www.stellar.org/>`_: Financial platform

* `Touch Surgery <https://www.touchsurgery.com/>`_: Surgery simulator

* `TrinityCore <https://github.com/TrinityCore/TrinityCore>`_: Open-source MMORPG framework

`More... <https://github.com/search?q=cppformat&type=Code>`_

If you are aware of other projects using this library, please let me know
by `email <mailto:victor.zverovich@gmail.com>`_ or by submitting an
`issue <https://github.com/fmtlib/fmt/issues>`_.

Motivation
----------

So why yet another formatting library?

There are plenty of methods for doing this task, from standard ones like
the printf family of function and IOStreams to Boost Format library and
FastFormat. The reason for creating a new library is that every existing
solution that I found either had serious issues or didn't provide
all the features I needed.

Printf
~~~~~~

The good thing about printf is that it is pretty fast and readily available
being a part of the C standard library. The main drawback is that it
doesn't support user-defined types. Printf also has safety issues although
they are mostly solved with `__attribute__ ((format (printf, ...))
<http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html>`_ in GCC.
There is a POSIX extension that adds positional arguments required for
`i18n <https://en.wikipedia.org/wiki/Internationalization_and_localization>`_
to printf but it is not a part of C99 and may not be available on some
platforms.

IOStreams
~~~~~~~~~

The main issue with IOStreams is best illustrated with an example:

.. code:: c++

    std::cout << std::setprecision(2) << std::fixed << 1.23456 << "\n";

which is a lot of typing compared to printf:

.. code:: c++

    printf("%.2f\n", 1.23456);

Matthew Wilson, the author of FastFormat, referred to this situation with
IOStreams as "chevron hell". IOStreams doesn't support positional arguments
by design.

The good part is that IOStreams supports user-defined types and is safe
although error reporting is awkward.

Boost Format library
~~~~~~~~~~~~~~~~~~~~

This is a very powerful library which supports both printf-like format
strings and positional arguments. The main its drawback is performance.
According to various benchmarks it is much slower than other methods
considered here. Boost Format also has excessive build times and severe
code bloat issues (see `Benchmarks`_).

FastFormat
~~~~~~~~~~

This is an interesting library which is fast, safe and has positional
arguments. However it has significant limitations, citing its author:

    Three features that have no hope of being accommodated within the
    current design are:

    * Leading zeros (or any other non-space padding)
    * Octal/hexadecimal encoding
    * Runtime width/alignment specification

It is also quite big and has a heavy dependency, STLSoft, which might be
too restrictive for using it in some projects.

Loki SafeFormat
~~~~~~~~~~~~~~~

SafeFormat is a formatting library which uses printf-like format strings
and is type safe. It doesn't support user-defined types or positional
arguments. It makes unconventional use of ``operator()`` for passing
format arguments.

Tinyformat
~~~~~~~~~~

This library supports printf-like format strings and is very small and
fast. Unfortunately it doesn't support positional arguments and wrapping
it in C++98 is somewhat difficult. Also its performance and code compactness
are limited by IOStreams.

Boost Spirit.Karma
~~~~~~~~~~~~~~~~~~

This is not really a formatting library but I decided to include it here
for completeness. As IOStreams it suffers from the problem of mixing
verbatim text with arguments. The library is pretty fast, but slower
on integer formatting than ``fmt::Writer`` on Karma's own benchmark,
see `Fast integer to string conversion in C++
<http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_.

Benchmarks
----------

Speed tests
~~~~~~~~~~~

The following speed tests results were generated by building
``tinyformat_test.cpp`` on Ubuntu GNU/Linux 14.04.1 with
``g++-4.8.2 -O3 -DSPEED_TEST -DHAVE_FORMAT``, and taking the best of three
runs.  In the test, the format string ``"%0.10f:%04d:%+g:%s:%p:%c:%%\n"`` or
equivalent is filled 2000000 times with output sent to ``/dev/null``; for
further details see the `source
<https://github.com/fmtlib/format-benchmark/blob/master/tinyformat_test.cpp>`_.

================= ============= ===========
Library           Method        Run Time, s
================= ============= ===========
EGLIBC 2.19       printf          1.30
libstdc++ 4.8.2   std::ostream    1.85
fmt 1.0           fmt::print      1.42
tinyformat 2.0.1  tfm::printf     2.25
Boost Format 1.54 boost::format   9.94
================= ============= ===========

As you can see ``boost::format`` is much slower than the alternative methods; this
is confirmed by `other tests <http://accu.org/index.php/journals/1539>`_.
Tinyformat is quite good coming close to IOStreams.  Unfortunately tinyformat
cannot be faster than the IOStreams because it uses them internally.
Performance of fmt is close to that of printf, being `faster than printf on integer
formatting <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_,
but slower on floating-point formatting which dominates this benchmark.

Compile time and code bloat
~~~~~~~~~~~~~~~~~~~~~~~~~~~

The script `bloat-test.py
<https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py>`_
from `format-benchmark <https://github.com/fmtlib/format-benchmark>`_
tests compile time and code bloat for nontrivial projects.
It generates 100 translation units and uses ``printf()`` or its alternative
five times in each to simulate a medium sized project.  The resulting
executable size and compile time (g++-4.8.1, Ubuntu GNU/Linux 13.10,
best of three) is shown in the following tables.

**Optimized build (-O3)**

============ =============== ==================== ==================
Method       Compile Time, s Executable size, KiB Stripped size, KiB
============ =============== ==================== ==================
printf                   2.6                   41                 30
IOStreams               19.4                   92                 70
fmt                     46.8                   46                 34
tinyformat              64.6                  418                386
Boost Format           222.8                  990                923
============ =============== ==================== ==================

As you can see, fmt has two times less overhead in terms of resulting
code size compared to IOStreams and comes pretty close to ``printf``.
Boost Format has by far the largest overheads.

**Non-optimized build**

============ =============== ==================== ==================
Method       Compile Time, s Executable size, KiB Stripped size, KiB
============ =============== ==================== ==================
printf                   2.1                   41                 30
IOStreams               19.7                   86                 62
fmt                     47.9                  108                 86
tinyformat              27.7                  234                190
Boost Format           122.6                  884                763
============ =============== ==================== ==================

``libc``, ``libstdc++`` and ``libfmt`` are all linked as shared
libraries to compare formatting function overhead only. Boost Format
and tinyformat are header-only libraries so they don't provide any
linkage options.

Running the tests
~~~~~~~~~~~~~~~~~

Please refer to `Building the library`__ for the instructions on how to build
the library and run the unit tests.

__ http://fmtlib.net/latest/usage.html#building-the-library

Benchmarks reside in a separate repository,
`format-benchmarks <https://github.com/fmtlib/format-benchmark>`_,
so to run the benchmarks you first need to clone this repository and
generate Makefiles with CMake::

    $ git clone --recursive https://github.com/fmtlib/format-benchmark.git
    $ cd format-benchmark
    $ cmake .

Then you can run the speed test::

    $ make speed-test

or the bloat test::

    $ make bloat-test

License
-------

fmt is distributed under the BSD `license
<https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_.

The `Format String Syntax
<http://fmtlib.net/latest/syntax.html>`_
section in the documentation is based on the one from Python `string module
documentation <https://docs.python.org/3/library/string.html#module-string>`_
adapted for the current library. For this reason the documentation is
distributed under the Python Software Foundation license available in
`doc/python-license.txt
<https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt>`_.
It only applies if you distribute the documentation of fmt.

Acknowledgments
---------------

The fmt library is maintained by Victor Zverovich (`vitaut <https://github.com/vitaut>`_)
and Jonathan Müller (`foonathan <https://github.com/foonathan>`_) with contributions from many
other people. See `Contributors <https://github.com/fmtlib/fmt/graphs/contributors>`_ and `Releases <https://github.com/fmtlib/fmt/releases>`_ for some of the names. Let us know if your contribution
is not listed or mentioned incorrectly and we'll make it right.

The benchmark section of this readme file and the performance tests are taken
from the excellent `tinyformat <https://github.com/c42f/tinyformat>`_ library
written by Chris Foster.  Boost Format library is acknowledged transitively
since it had some influence on tinyformat.
Some ideas used in the implementation are borrowed from `Loki
<http://loki-lib.sourceforge.net/>`_ SafeFormat and `Diagnostic API
<http://clang.llvm.org/doxygen/classclang_1_1Diagnostic.html>`_ in
`Clang <http://clang.llvm.org/>`_.
Format string syntax and the documentation are based on Python's `str.format
<http://docs.python.org/2/library/stdtypes.html#str.format>`_.
Thanks `Doug Turnbull <https://github.com/softwaredoug>`_ for his valuable
comments and contribution to the design of the type-safe API and
`Gregory Czajkowski <https://github.com/gcflymoto>`_ for implementing binary
formatting. Thanks `Ruslan Baratov <https://github.com/ruslo>`_ for comprehensive
`comparison of integer formatting algorithms <https://github.com/ruslo/int-dec-format-tests>`_
and useful comments regarding performance, `Boris Kaul <https://github.com/localvoid>`_ for
`C++ counting digits benchmark <https://github.com/localvoid/cxx-benchmark-count-digits>`_.
Thanks to `CarterLi <https://github.com/CarterLi>`_ for contributing various
improvements to the code.


================================================
FILE: lib/fmt/README.txt
================================================
===============================================================
It's FMT library to easier format your stuff!
https://github.com/fmtlib/fmt
===============================================================

Current version (which is here at now) is 4.1.0!

===============================================================
What changed from orig version:
===============================================================
- every file begins with "fmt_" and ".cc" has been replaced with ".cpp"
  to avoid any possible conflicts with some project sources
- added `fmt_qformat.h` to support Qt-like formatting ("%1, %2, %3....")

===============================================================
How to easily upgrade this with newer version
===============================================================
1) Download a tarball or repo from official download
2) copy content of "fmt" folder into "orig" you see here
3) run from bash the "update.sh"

Note 1: You must have `sed` as GNU-sed. If you are running BSD or macOS, possibly,
        scrilt will fail to update filename references in each file you see here.

Note 2: If any files are added, please modify `update.sh` to refer them too!



================================================
FILE: lib/fmt/fmt.cmake
================================================
# message("Path to FMT is [${CMAKE_CURRENT_LIST_DIR}]")
include_directories(${CMAKE_CURRENT_LIST_DIR})

set(FMT_SRCS)

list(APPEND FMT_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/fmt_format.cpp
    ${CMAKE_CURRENT_LIST_DIR}/fmt_ostream.cpp
    ${CMAKE_CURRENT_LIST_DIR}/fmt_posix.cpp
)



================================================
FILE: lib/fmt/fmt_container.h
================================================
/*
 Formatting library for C++ - standard container utilities

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_CONTAINER_H_
#define FMT_CONTAINER_H_

#include "fmt_format.h"

namespace fmt {

namespace internal {

/**
  \rst
  A "buffer" that appends data to a standard container (e.g. typically a
  ``std::vector`` or ``std::basic_string``).
  \endrst
 */
template <typename Container>
class ContainerBuffer : public Buffer<typename Container::value_type> {
 private:
  Container& container_;

 protected:
  virtual void grow(std::size_t size) FMT_OVERRIDE {
    container_.resize(size);
    this->ptr_ = &container_[0];
    this->capacity_ = size;
  }

 public:
  explicit ContainerBuffer(Container& container) : container_(container) {
    this->size_ = container_.size();
    if (this->size_ > 0) {
      this->ptr_ = &container_[0];
      this->capacity_ = this->size_;
    }
  }
};
}  // namespace internal

/**
  \rst
  This class template provides operations for formatting and appending data
  to a standard *container* like ``std::vector`` or ``std::basic_string``.

  **Example**::

    void vecformat(std::vector<char>& dest, fmt::BasicCStringRef<char> format,
                   fmt::ArgList args) {
      fmt::BasicContainerWriter<std::vector<char> > appender(dest);
      appender.write(format, args);
    }
    FMT_VARIADIC(void, vecformat, std::vector<char>&,
                 fmt::BasicCStringRef<char>);
  \endrst
 */
template <class Container>
class BasicContainerWriter
  : public BasicWriter<typename Container::value_type> {
 private:
  internal::ContainerBuffer<Container> buffer_;

 public:
  /**
    \rst
    Constructs a :class:`fmt::BasicContainerWriter` object.
    \endrst
   */
  explicit BasicContainerWriter(Container& dest)
  : BasicWriter<typename Container::value_type>(buffer_), buffer_(dest) {}
};

} // namespace fmt

#endif  // FMT_CONTAINER_H_


================================================
FILE: lib/fmt/fmt_format.cpp
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "fmt_format.h"

#include <string.h>

#include <cctype>
#include <cerrno>
#include <climits>
#include <cmath>
#include <cstdarg>
#include <cstddef>  // for std::ptrdiff_t

#if defined(_WIN32) && defined(__MINGW32__)
# include <cstring>
#endif

#if FMT_USE_WINDOWS_H
# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
#  define WIN32_LEAN_AND_MEAN
# endif
# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
#  include <windows.h>
# else
#  define NOMINMAX
#  include <windows.h>
#  undef NOMINMAX
# endif
#endif

#if FMT_EXCEPTIONS
# define FMT_TRY try
# define FMT_CATCH(x) catch (x)
#else
# define FMT_TRY if (true)
# define FMT_CATCH(x) if (false)
#endif

#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4127)  // conditional expression is constant
# pragma warning(disable: 4702)  // unreachable code
// Disable deprecation warning for strerror. The latter is not called but
// MSVC fails to detect it.
# pragma warning(disable: 4996)
#endif

// Dummy implementations of strerror_r and strerror_s called if corresponding
// system functions are not available.
FMT_MAYBE_UNUSED
static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
  return fmt::internal::Null<>();
}
FMT_MAYBE_UNUSED
static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
  return fmt::internal::Null<>();
}

namespace fmt {

FMT_FUNC internal::RuntimeError::~RuntimeError() FMT_DTOR_NOEXCEPT {}
FMT_FUNC FormatError::~FormatError() FMT_DTOR_NOEXCEPT {}
FMT_FUNC SystemError::~SystemError() FMT_DTOR_NOEXCEPT {}

namespace {

#ifndef _MSC_VER
# define FMT_SNPRINTF snprintf
#else  // _MSC_VER
inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
  va_end(args);
  return result;
}
# define FMT_SNPRINTF fmt_snprintf
#endif  // _MSC_VER

#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
# define FMT_SWPRINTF snwprintf
#else
# define FMT_SWPRINTF swprintf
#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)

const char RESET_COLOR[] = "\x1b[0m";

typedef void (*FormatFunc)(Writer &, int, StringRef);

// Portable thread-safe version of strerror.
// Sets buffer to point to a string describing the error code.
// This can be either a pointer to a string stored in buffer,
// or a pointer to some static immutable string.
// Returns one of the following values:
//   0      - success
//   ERANGE - buffer is not large enough to store the error message
//   other  - failure
// Buffer should be at least of size 1.
int safe_strerror(
    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
  FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");

  class StrError {
   private:
    int error_code_;
    char *&buffer_;
    std::size_t buffer_size_;

    // A noop assignment operator to avoid bogus warnings.
    void operator=(const StrError &) {}

    // Handle the result of XSI-compliant version of strerror_r.
    int handle(int result) {
      // glibc versions before 2.13 return result in errno.
      return result == -1 ? errno : result;
    }

    // Handle the result of GNU-specific version of strerror_r.
    int handle(char *message) {
      // If the buffer is full then the message is probably truncated.
      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
        return ERANGE;
      buffer_ = message;
      return 0;
    }

    // Handle the case when strerror_r is not available.
    int handle(internal::Null<>) {
      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
    }

    // Fallback to strerror_s when strerror_r is not available.
    int fallback(int result) {
      // If the buffer is full then the message is probably truncated.
      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
            ERANGE : result;
    }

#ifdef __c2__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif

    // Fallback to strerror if strerror_r and strerror_s are not available.
    int fallback(internal::Null<>) {
      errno = 0;
      buffer_ = strerror(error_code_);
      return errno;
    }

#ifdef __c2__
# pragma clang diagnostic pop
#endif

   public:
    StrError(int err_code, char *&buf, std::size_t buf_size)
      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}

    int run() {
      return handle(strerror_r(error_code_, buffer_, buffer_size_));
    }
  };
  return StrError(error_code, buffer, buffer_size).run();
}

void format_error_code(Writer &out, int error_code,
                       StringRef message) FMT_NOEXCEPT {
  // Report error code making sure that the output fits into
  // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
  // bad_alloc.
  out.clear();
  static const char SEP[] = ": ";
  static const char ERROR_STR[] = "error ";
  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
  typedef internal::IntTraits<int>::MainType MainType;
  MainType abs_value = static_cast<MainType>(error_code);
  if (internal::is_negative(error_code)) {
    abs_value = 0 - abs_value;
    ++error_code_size;
  }
  error_code_size += internal::count_digits(abs_value);
  if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size)
    out << message << SEP;
  out << ERROR_STR << error_code;
  assert(out.size() <= internal::INLINE_BUFFER_SIZE);
}

void report_error(FormatFunc func, int error_code,
                  StringRef message) FMT_NOEXCEPT {
  MemoryWriter full_message;
  func(full_message, error_code, message);
  // Use Writer::data instead of Writer::c_str to avoid potential memory
  // allocation.
  std::fwrite(full_message.data(), full_message.size(), 1, stderr);
  std::fputc('\n', stderr);
}
}  // namespace

FMT_FUNC void SystemError::init(
    int err_code, CStringRef format_str, ArgList args) {
  error_code_ = err_code;
  MemoryWriter w;
  format_system_error(w, err_code, format(format_str, args));
  std::runtime_error &base = *this;
  base = std::runtime_error(w.str());
}

template <typename T>
int internal::CharTraits<char>::format_float(
    char *buffer, std::size_t size, const char *format,
    unsigned width, int precision, T value) {
  if (width == 0) {
    return precision < 0 ?
        FMT_SNPRINTF(buffer, size, format, value) :
        FMT_SNPRINTF(buffer, size, format, precision, value);
  }
  return precision < 0 ?
      FMT_SNPRINTF(buffer, size, format, width, value) :
      FMT_SNPRINTF(buffer, size, format, width, precision, value);
}

template <typename T>
int internal::CharTraits<wchar_t>::format_float(
    wchar_t *buffer, std::size_t size, const wchar_t *format,
    unsigned width, int precision, T value) {
  if (width == 0) {
    return precision < 0 ?
        FMT_SWPRINTF(buffer, size, format, value) :
        FMT_SWPRINTF(buffer, size, format, precision, value);
  }
  return precision < 0 ?
      FMT_SWPRINTF(buffer, size, format, width, value) :
      FMT_SWPRINTF(buffer, size, format, width, precision, value);
}

template <typename T>
const char internal::BasicData<T>::DIGITS[] =
    "0001020304050607080910111213141516171819"
    "2021222324252627282930313233343536373839"
    "4041424344454647484950515253545556575859"
    "6061626364656667686970717273747576777879"
    "8081828384858687888990919293949596979899";

#define FMT_POWERS_OF_10(factor) \
  factor * 10, \
  factor * 100, \
  factor * 1000, \
  factor * 10000, \
  factor * 100000, \
  factor * 1000000, \
  factor * 10000000, \
  factor * 100000000, \
  factor * 1000000000

template <typename T>
const uint32_t internal::BasicData<T>::POWERS_OF_10_32[] = {
  0, FMT_POWERS_OF_10(1)
};

template <typename T>
const uint64_t internal::BasicData<T>::POWERS_OF_10_64[] = {
  0,
  FMT_POWERS_OF_10(1),
  FMT_POWERS_OF_10(ULongLong(1000000000)),
  // Multiply several constants instead of using a single long long constant
  // to avoid warnings about C++98 not supporting long long.
  ULongLong(1000000000) * ULongLong(1000000000) * 10
};

FMT_FUNC void internal::report_unknown_type(char code, const char *type) {
  (void)type;
  if (std::isprint(static_cast<unsigned char>(code))) {
    FMT_THROW(FormatError(
        format("unknown format code '{}' for {}", code, type)));
  }
  FMT_THROW(FormatError(
      format("unknown format code '\\x{:02x}' for {}",
        static_cast<unsigned>(code), type)));
}

#if FMT_USE_WINDOWS_H

FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s) {
  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
  if (s.size() > INT_MAX)
    FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
  int s_size = static_cast<int>(s.size());
  int length = MultiByteToWideChar(
      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
  if (length == 0)
    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
  buffer_.resize(length + 1);
  length = MultiByteToWideChar(
    CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
  if (length == 0)
    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
  buffer_[length] = 0;
}

FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s) {
  if (int error_code = convert(s)) {
    FMT_THROW(WindowsError(error_code,
        "cannot convert string from UTF-16 to UTF-8"));
  }
}

FMT_FUNC int internal::UTF16ToUTF8::convert(WStringRef s) {
  if (s.size() > INT_MAX)
    return ERROR_INVALID_PARAMETER;
  int s_size = static_cast<int>(s.size());
  int length = WideCharToMultiByte(
    CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
  if (length == 0)
    return GetLastError();
  buffer_.resize(length + 1);
  length = WideCharToMultiByte(
    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
  if (length == 0)
    return GetLastError();
  buffer_[length] = 0;
  return 0;
}

FMT_FUNC void WindowsError::init(
    int err_code, CStringRef format_str, ArgList args) {
  error_code_ = err_code;
  MemoryWriter w;
  internal::format_windows_error(w, err_code, format(format_str, args));
  std::runtime_error &base = *this;
  base = std::runtime_error(w.str());
}

FMT_FUNC void internal::format_windows_error(
    Writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
  FMT_TRY {
    MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
    buffer.resize(INLINE_BUFFER_SIZE);
    for (;;) {
      wchar_t *system_message = &buffer[0];
      int result = FormatMessageW(
        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        system_message, static_cast<uint32_t>(buffer.size()), FMT_NULL);
      if (result != 0) {
        UTF16ToUTF8 utf8_message;
        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
          out << message << ": " << utf8_message;
          return;
        }
        break;
      }
      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        break;  // Can't get error message, report error code instead.
      buffer.resize(buffer.size() * 2);
    }
  } FMT_CATCH(...) {}
  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
}

#endif  // FMT_USE_WINDOWS_H

FMT_FUNC void format_system_error(
    Writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
  FMT_TRY {
    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
    buffer.resize(internal::INLINE_BUFFER_SIZE);
    for (;;) {
      char *system_message = &buffer[0];
      int result = safe_strerror(error_code, system_message, buffer.size());
      if (result == 0) {
        out << message << ": " << system_message;
        return;
      }
      if (result != ERANGE)
        break;  // Can't get error message, report error code instead.
      buffer.resize(buffer.size() * 2);
    }
  } FMT_CATCH(...) {}
  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
}

template <typename Char>
void internal::FixedBuffer<Char>::grow(std::size_t) {
  FMT_THROW(std::runtime_error("buffer overflow"));
}

FMT_FUNC internal::Arg internal::FormatterBase::do_get_arg(
    unsigned arg_index, const char *&error) {
  internal::Arg arg = args_[arg_index];
  switch (arg.type) {
  case internal::Arg::NONE:
    error = "argument index out of range";
    break;
  case internal::Arg::NAMED_ARG:
    arg = *static_cast<const internal::Arg*>(arg.pointer);
    break;
  default:
    /*nothing*/;
  }
  return arg;
}

FMT_FUNC void report_system_error(
    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
  // 'fmt::' is for bcc32.
  report_error(format_system_error, error_code, message);
}

#if FMT_USE_WINDOWS_H
FMT_FUNC void report_windows_error(
    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
  // 'fmt::' is for bcc32.
  report_error(internal::format_windows_error, error_code, message);
}
#endif

FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args) {
  MemoryWriter w;
  w.write(format_str, args);
  std::fwrite(w.data(), 1, w.size(), f);
}

FMT_FUNC void print(CStringRef format_str, ArgList args) {
  print(stdout, format_str, args);
}

FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args) {
  char escape[] = "\x1b[30m";
  escape[3] = static_cast<char>('0' + c);
  std::fputs(escape, stdout);
  print(format, args);
  std::fputs(RESET_COLOR, stdout);
}

#ifndef FMT_HEADER_ONLY

template struct internal::BasicData<void>;

// Explicit instantiations for char.

template void internal::FixedBuffer<char>::grow(std::size_t);

template FMT_API int internal::CharTraits<char>::format_float(
    char *buffer, std::size_t size, const char *format,
    unsigned width, int precision, double value);

template FMT_API int internal::CharTraits<char>::format_float(
    char *buffer, std::size_t size, const char *format,
    unsigned width, int precision, long double value);

// Explicit instantiations for wchar_t.

template void internal::FixedBuffer<wchar_t>::grow(std::size_t);

template FMT_API int internal::CharTraits<wchar_t>::format_float(
    wchar_t *buffer, std::size_t size, const wchar_t *format,
    unsigned width, int precision, double value);

template FMT_API int internal::CharTraits<wchar_t>::format_float(
    wchar_t *buffer, std::size_t size, const wchar_t *format,
    unsigned width, int precision, long double value);

#endif  // FMT_HEADER_ONLY

}  // namespace fmt

#ifdef _MSC_VER
# pragma warning(pop)
#endif


================================================
FILE: lib/fmt/fmt_format.h
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_

#define FMT_INCLUDE
#include <cassert>
#include <clocale>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <utility>  // for std::pair
#undef FMT_INCLUDE

// The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 40100

#if defined(__has_include)
# define FMT_HAS_INCLUDE(x) __has_include(x)
#else
# define FMT_HAS_INCLUDE(x) 0
#endif

#if (FMT_HAS_INCLUDE(<string_view>) && __cplusplus > 201402L) || \
    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
# include <string_view>
# define FMT_HAS_STRING_VIEW 1
#else
# define FMT_HAS_STRING_VIEW 0
#endif

#if defined _SECURE_SCL && _SECURE_SCL
# define FMT_SECURE_SCL _SECURE_SCL
#else
# define FMT_SECURE_SCL 0
#endif

#if FMT_SECURE_SCL
# include <iterator>
#endif

#ifdef _MSC_VER
# define FMT_MSC_VER _MSC_VER
#else
# define FMT_MSC_VER 0
#endif

#if FMT_MSC_VER && FMT_MSC_VER <= 1500
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
typedef __int64          intmax_t;
#else
#include <stdint.h>
#endif

#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
# ifdef FMT_EXPORT
#  define FMT_API __declspec(dllexport)
# elif defined(FMT_SHARED)
#  define FMT_API __declspec(dllimport)
# endif
#endif
#ifndef FMT_API
# define FMT_API
#endif

#ifdef __GNUC__
# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
# define FMT_GCC_EXTENSION __extension__
# if FMT_GCC_VERSION >= 406
#  pragma GCC diagnostic push
// Disable the warning about "long long" which is sometimes reported even
// when using __extension__.
#  pragma GCC diagnostic ignored "-Wlong-long"
// Disable the warning about declaration shadowing because it affects too
// many valid cases.
#  pragma GCC diagnostic ignored "-Wshadow"
// Disable the warning about implicit conversions that may change the sign of
// an integer; silencing it otherwise would require many explicit casts.
#  pragma GCC diagnostic ignored "-Wsign-conversion"
# endif
# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
#  define FMT_HAS_GXX_CXX11 1
# endif
#else
# define FMT_GCC_VERSION 0
# define FMT_GCC_EXTENSION
# define FMT_HAS_GXX_CXX11 0
#endif

#if defined(__INTEL_COMPILER)
# define FMT_ICC_VERSION __INTEL_COMPILER
#elif defined(__ICL)
# define FMT_ICC_VERSION __ICL
#endif

#if defined(__clang__) && !defined(FMT_ICC_VERSION)
# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
# pragma clang diagnostic ignored "-Wpadded"
#endif

#ifdef __GNUC_LIBSTD__
# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
#endif

#ifdef __has_feature
# define FMT_HAS_FEATURE(x) __has_feature(x)
#else
# define FMT_HAS_FEATURE(x) 0
#endif

#ifdef __has_builtin
# define FMT_HAS_BUILTIN(x) __has_builtin(x)
#else
# define FMT_HAS_BUILTIN(x) 0
#endif

#ifdef __has_cpp_attribute
# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
# define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif

#if FMT_HAS_CPP_ATTRIBUTE(maybe_unused) && __cplusplus >= 201703L
# define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED
// VC++ 1910 support /std: option and that will set _MSVC_LANG macro
// Clang with Microsoft CodeGen doesn't define _MSVC_LANG macro
#elif defined(_MSVC_LANG) && _MSVC_LANG > 201402 && _MSC_VER >= 1910
# define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED
#endif

#ifdef FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED
# define FMT_MAYBE_UNUSED [[maybe_unused]]
// g++/clang++ also support [[gnu::unused]]. However, we don't use it.
#elif defined(__GNUC__)
# define FMT_MAYBE_UNUSED __attribute__((unused))
#else
# define FMT_MAYBE_UNUSED
#endif

// Use the compiler's attribute noreturn
#if defined(__MINGW32__) || defined(__MINGW64__)
# define FMT_NORETURN __attribute__((noreturn))
#elif FMT_HAS_CPP_ATTRIBUTE(noreturn) && __cplusplus >= 201103L
# define FMT_NORETURN [[noreturn]]
#else
# define FMT_NORETURN
#endif

#ifndef FMT_USE_VARIADIC_TEMPLATES
// Variadic templates are available in GCC since version 4.4
// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
// since version 2013.
# define FMT_USE_VARIADIC_TEMPLATES \
   (FMT_HAS_FEATURE(cxx_variadic_templates) || \
       (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800)
#endif

#ifndef FMT_USE_RVALUE_REFERENCES
// Don't use rvalue references when compiling with clang and an old libstdc++
// as the latter doesn't provide std::move.
# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402
#  define FMT_USE_RVALUE_REFERENCES 0
# else
#  define FMT_USE_RVALUE_REFERENCES \
    (FMT_HAS_FEATURE(cxx_rvalue_references) || \
        (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600)
# endif
#endif

#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700
# define FMT_USE_ALLOCATOR_TRAITS 1
#else
# define FMT_USE_ALLOCATOR_TRAITS 0
#endif

// Check if exceptions are disabled.
#if defined(__GNUC__) && !defined(__EXCEPTIONS)
# define FMT_EXCEPTIONS 0
#endif
#if FMT_MSC_VER && !_HAS_EXCEPTIONS
# define FMT_EXCEPTIONS 0
#endif
#ifndef FMT_EXCEPTIONS
# define FMT_EXCEPTIONS 1
#endif

#ifndef FMT_THROW
# if FMT_EXCEPTIONS
#  define FMT_THROW(x) throw x
# else
#  define FMT_THROW(x) assert(false)
# endif
#endif

// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
#ifndef FMT_USE_NOEXCEPT
# define FMT_USE_NOEXCEPT 0
#endif

#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
    FMT_MSC_VER >= 1900
# define FMT_DETECTED_NOEXCEPT noexcept
#else
# define FMT_DETECTED_NOEXCEPT throw()
#endif

#ifndef FMT_NOEXCEPT
# if FMT_EXCEPTIONS
#  define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
# else
#  define FMT_NOEXCEPT
# endif
#endif

// This is needed because GCC still uses throw() in its headers when exceptions
// are disabled.
#if FMT_GCC_VERSION
# define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT
#else
# define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT
#endif

#ifndef FMT_OVERRIDE
# if (defined(FMT_USE_OVERRIDE) && FMT_USE_OVERRIDE) || FMT_HAS_FEATURE(cxx_override) || \
   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
   FMT_MSC_VER >= 1900
#  define FMT_OVERRIDE override
# else
#  define FMT_OVERRIDE
# endif
#endif

#ifndef FMT_NULL
# if FMT_HAS_FEATURE(cxx_nullptr) || \
   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
   FMT_MSC_VER >= 1600
#  define FMT_NULL nullptr
# else
#  define FMT_NULL NULL
# endif
#endif

// A macro to disallow the copy constructor and operator= functions
// This should be used in the private: declarations for a class
#ifndef FMT_USE_DELETED_FUNCTIONS
# define FMT_USE_DELETED_FUNCTIONS 0
#endif

#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
  (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800
# define FMT_DELETED_OR_UNDEFINED  = delete
# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
    TypeName(const TypeName&) = delete; \
    TypeName& operator=(const TypeName&) = delete
#else
# define FMT_DELETED_OR_UNDEFINED
# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
    TypeName(const TypeName&); \
    TypeName& operator=(const TypeName&)
#endif

#ifndef FMT_USE_DEFAULTED_FUNCTIONS
# define FMT_USE_DEFAULTED_FUNCTIONS 0
#endif

#ifndef FMT_DEFAULTED_COPY_CTOR
# if FMT_USE_DEFAULTED_FUNCTIONS || FMT_HAS_FEATURE(cxx_defaulted_functions) || \
   (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800
#  define FMT_DEFAULTED_COPY_CTOR(TypeName) \
    TypeName(const TypeName&) = default;
# else
#  define FMT_DEFAULTED_COPY_CTOR(TypeName)
# endif
#endif

#ifndef FMT_USE_USER_DEFINED_LITERALS
// All compilers which support UDLs also support variadic templates. This
// makes the fmt::literals implementation easier. However, an explicit check
// for variadic templates is added here just in case.
// For Intel's compiler both it and the system gcc/msc must support UDLs.
# if FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
   (FMT_HAS_FEATURE(cxx_user_literals) || \
     (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \
   (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500)
#  define FMT_USE_USER_DEFINED_LITERALS 1
# else
#  define FMT_USE_USER_DEFINED_LITERALS 0
# endif
#endif

#ifndef FMT_USE_EXTERN_TEMPLATES
# define FMT_USE_EXTERN_TEMPLATES \
    (FMT_CLANG_VERSION >= 209 || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
#endif

#ifdef FMT_HEADER_ONLY
// If header only do not use extern templates.
# undef FMT_USE_EXTERN_TEMPLATES
# define FMT_USE_EXTERN_TEMPLATES 0
#endif

#ifndef FMT_ASSERT
# define FMT_ASSERT(condition, message) assert((condition) && message)
#endif

// __builtin_clz is broken in clang with Microsoft CodeGen:
// https://github.com/fmtlib/fmt/issues/519
#ifndef _MSC_VER
# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
# endif

# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
# endif
#endif

// Some compilers masquerade as both MSVC and GCC-likes or
// otherwise support __builtin_clz and __builtin_clzll, so
// only define FMT_BUILTIN_CLZ using the MSVC intrinsics
// if the clz and clzll builtins are not available.
#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
# include <intrin.h>  // _BitScanReverse, _BitScanReverse64

namespace fmt {
namespace internal {
// avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning
# ifndef __clang__
#  pragma intrinsic(_BitScanReverse)
# endif
inline uint32_t clz(uint32_t x) {
  unsigned long r = 0;
  _BitScanReverse(&r, x);

  assert(x != 0);
  // Static analysis complains about using uninitialized data
  // "r", but the only way that can happen is if "x" is 0,
  // which the callers guarantee to not happen.
# pragma warning(suppress: 6102)
  return 31 - r;
}
# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)

// avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning
# if defined(_WIN64) && !defined(__clang__)
#  pragma intrinsic(_BitScanReverse64)
# endif

inline uint32_t clzll(uint64_t x) {
  unsigned long r = 0;
# ifdef _WIN64
  _BitScanReverse64(&r, x);
# else
  // Scan the high 32 bits.
  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
    return 63 - (r + 32);

  // Scan the low 32 bits.
  _BitScanReverse(&r, static_cast<uint32_t>(x));
# endif

  assert(x != 0);
  // Static analysis complains about using uninitialized data
  // "r", but the only way that can happen is if "x" is 0,
  // which the callers guarantee to not happen.
# pragma warning(suppress: 6102)
  return 63 - r;
}
# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
}
}
#endif

namespace fmt {
namespace internal {
struct DummyInt {
  int data[2];
  operator int() const { return 0; }
};
typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;

// Dummy implementations of system functions such as signbit and ecvt called
// if the latter are not available.
inline DummyInt signbit(...) { return DummyInt(); }
inline DummyInt _ecvt_s(...) { return DummyInt(); }
inline DummyInt isinf(...) { return DummyInt(); }
inline DummyInt _finite(...) { return DummyInt(); }
inline DummyInt isnan(...) { return DummyInt(); }
inline DummyInt _isnan(...) { return DummyInt(); }

// A helper function to suppress bogus "conditional expression is constant"
// warnings.
template <typename T>
inline T const_check(T value) { return value; }
}
}  // namespace fmt

namespace std {
// Standard permits specialization of std::numeric_limits. This specialization
// is used to resolve ambiguity between isinf and std::isinf in glibc:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
// and the same for isnan and signbit.
template <>
class numeric_limits<fmt::internal::DummyInt> :
    public std::numeric_limits<int> {
 public:
  // Portable version of isinf.
  template <typename T>
  static bool isinfinity(T x) {
    using namespace fmt::internal;
    // The resolution "priority" is:
    // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
    if (const_check(sizeof(isinf(x)) == sizeof(bool) ||
                    sizeof(isinf(x)) == sizeof(int))) {
      return isinf(x) != 0;
    }
    return !_finite(static_cast<double>(x));
  }

  // Portable version of isnan.
  template <typename T>
  static bool isnotanumber(T x) {
    using namespace fmt::internal;
    if (const_check(sizeof(isnan(x)) == sizeof(bool) ||
                    sizeof(isnan(x)) == sizeof(int))) {
      return isnan(x) != 0;
    }
    return _isnan(static_cast<double>(x)) != 0;
  }

  // Portable version of signbit.
  static bool isnegative(double x) {
    using namespace fmt::internal;
    if (const_check(sizeof(signbit(x)) == sizeof(bool) ||
                    sizeof(signbit(x)) == sizeof(int))) {
      return signbit(x) != 0;
    }
    if (x < 0) return true;
    if (!isnotanumber(x)) return false;
#ifndef _WIN32
    int dec = 0, sign = 0;
    char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
    _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
    return sign != 0;
#else
    char buffer[2];
    snprintf(buffer, 2, "%g", x);
    return buffer[0] == '-';
#endif
  }
};
}  // namespace std

namespace fmt {

// Fix the warning about long long on older versions of GCC
// that don't support the diagnostic pragma.
FMT_GCC_EXTENSION typedef long long LongLong;
FMT_GCC_EXTENSION typedef unsigned long long ULongLong;

#if FMT_USE_RVALUE_REFERENCES
using std::move;
#endif

template <typename Char>
class BasicWriter;

typedef BasicWriter<char> Writer;
typedef BasicWriter<wchar_t> WWriter;

template <typename Char>
class ArgFormatter;

struct FormatSpec;

template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
class BasicPrintfArgFormatter;

template <typename CharType,
          typename ArgFormatter = fmt::ArgFormatter<CharType> >
class BasicFormatter;

/**
  \rst
  A string reference. It can be constructed from a C string or
  ``std::basic_string``.

  You can use one of the following typedefs for common character types:

  +------------+-------------------------+
  | Type       | Definition              |
  +============+=========================+
  | StringRef  | BasicStringRef<char>    |
  +------------+-------------------------+
  | WStringRef | BasicStringRef<wchar_t> |
  +------------+-------------------------+

  This class is most useful as a parameter type to allow passing
  different types of strings to a function, for example::

    template <typename... Args>
    std::string format(StringRef format_str, const Args & ... args);

    format("{}", 42);
    format(std::string("{}"), 42);
  \endrst
 */
template <typename Char>
class BasicStringRef {
 private:
  const Char *data_;
  std::size_t size_;

 public:
  /** Constructs a string reference object from a C string and a size. */
  BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}

  /**
    \rst
    Constructs a string reference object from a C string computing
    the size with ``std::char_traits<Char>::length``.
    \endrst
   */
  BasicStringRef(const Char *s)
    : data_(s), size_(std::char_traits<Char>::length(s)) {}

  /**
    \rst
    Constructs a string reference from a ``std::basic_string`` object.
    \endrst
   */
  template <typename Allocator>
  BasicStringRef(
      const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
  : data_(s.c_str()), size_(s.size()) {}

#if FMT_HAS_STRING_VIEW
  /**
    \rst
    Constructs a string reference from a ``std::basic_string_view`` object.
    \endrst
   */
  BasicStringRef(
      const std::basic_string_view<Char, std::char_traits<Char>> &s)
  : data_(s.data()), size_(s.size()) {}

  /**
   \rst
   Converts a string reference to an ``std::string_view`` object.
   \endrst
  */
  explicit operator std::basic_string_view<Char>() const FMT_NOEXCEPT {
    return std::basic_string_view<Char>(data_, size_);
  }
#endif

  /**
    \rst
    Converts a string reference to an ``std::string`` object.
    \endrst
   */
  std::basic_string<Char> to_string() const {
    return std::basic_string<Char>(data_, size_);
  }

  /** Returns a pointer to the string data. */
  const Char *data() const { return data_; }

  /** Returns the string size. */
  std::size_t size() const { return size_; }

  // Lexicographically compare this string reference to other.
  int compare(BasicStringRef other) const {
    std::size_t size = size_ < other.size_ ? size_ : other.size_;
    int result = std::char_traits<Char>::compare(data_, other.data_, size);
    if (result == 0)
      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
    return result;
  }

  friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) == 0;
  }
  friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) != 0;
  }
  friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) < 0;
  }
  friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) <= 0;
  }
  friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) > 0;
  }
  friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) >= 0;
  }
};

typedef BasicStringRef<char> StringRef;
typedef BasicStringRef<wchar_t> WStringRef;

/**
  \rst
  A reference to a null terminated string. It can be constructed from a C
  string or ``std::basic_string``.

  You can use one of the following typedefs for common character types:

  +-------------+--------------------------+
  | Type        | Definition               |
  +=============+==========================+
  | CStringRef  | BasicCStringRef<char>    |
  +-------------+--------------------------+
  | WCStringRef | BasicCStringRef<wchar_t> |
  +-------------+--------------------------+

  This class is most useful as a parameter type to allow passing
  different types of strings to a function, for example::

    template <typename... Args>
    std::string format(CStringRef format_str, const Args & ... args);

    format("{}", 42);
    format(std::string("{}"), 42);
  \endrst
 */
template <typename Char>
class BasicCStringRef {
 private:
  const Char *data_;

 public:
  /** Constructs a string reference object from a C string. */
  BasicCStringRef(const Char *s) : data_(s) {}

  /**
    \rst
    Constructs a string reference from a ``std::basic_string`` object.
    \endrst
   */
  template <typename Allocator>
  BasicCStringRef(
      const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
  : data_(s.c_str()) {}

  /** Returns the pointer to a C string. */
  const Char *c_str() const { return data_; }
};

typedef BasicCStringRef<char> CStringRef;
typedef BasicCStringRef<wchar_t> WCStringRef;

/** A formatting error such as invalid format string. */
class FormatError : public std::runtime_error {
 public:
  explicit FormatError(CStringRef message)
  : std::runtime_error(message.c_str()) {}
  FormatError(const FormatError &ferr) : std::runtime_error(ferr) {}
  FMT_API ~FormatError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;
};

namespace internal {

// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
template <typename T>
struct MakeUnsigned { typedef T Type; };

#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
  template <> \
  struct MakeUnsigned<T> { typedef U Type; }

FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);
FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);
FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);

// Casts nonnegative integer to unsigned.
template <typename Int>
inline typename MakeUnsigned<Int>::Type to_unsigned(Int value) {
  FMT_ASSERT(value >= 0, "negative value");
  return static_cast<typename MakeUnsigned<Int>::Type>(value);
}

// The number of characters to store in the MemoryBuffer object itself
// to avoid dynamic memory allocation.
enum { INLINE_BUFFER_SIZE = 500 };

#if FMT_SECURE_SCL
// Use checked iterator to avoid warnings on MSVC.
template <typename T>
inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
  return stdext::checked_array_iterator<T*>(ptr, size);
}
#else
template <typename T>
inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
#endif
}  // namespace internal

/**
  \rst
  A buffer supporting a subset of ``std::vector``'s operations.
  \endrst
 */
template <typename T>
class Buffer {
 private:
  FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);

 protected:
  T *ptr_;
  std::size_t size_;
  std::size_t capacity_;

  Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0)
    : ptr_(ptr), size_(0), capacity_(capacity) {}

  /**
    \rst
    Increases the buffer capacity to hold at least *size* elements updating
    ``ptr_`` and ``capacity_``.
    \endrst
   */
  virtual void grow(std::size_t size) = 0;

 public:
  virtual ~Buffer() {}

  /** Returns the size of this buffer. */
  std::size_t size() const { return size_; }

  /** Returns the capacity of this buffer. */
  std::size_t capacity() const { return capacity_; }

  /**
    Resizes the buffer. If T is a POD type new elements may not be initialized.
   */
  void resize(std::size_t new_size) {
    if (new_size > capacity_)
      grow(new_size);
    size_ = new_size;
  }

  /**
    \rst
    Reserves space to store at least *capacity* elements.
    \endrst
   */
  void reserve(std::size_t capacity) {
    if (capacity > capacity_)
      grow(capacity);
  }

  void clear() FMT_NOEXCEPT { size_ = 0; }

  void push_back(const T &value) {
    if (size_ == capacity_)
      grow(size_ + 1);
    ptr_[size_++] = value;
  }

  /** Appends data to the end of the buffer. */
  template <typename U>
  void append(const U *begin, const U *end);

  T &operator[](std::size_t index) { return ptr_[index]; }
  const T &operator[](std::size_t index) const { return ptr_[index]; }
};

template <typename T>
template <typename U>
void Buffer<T>::append(const U *begin, const U *end) {
  FMT_ASSERT(end >= begin, "negative value");
  std::size_t new_size = size_ + static_cast<std::size_t>(end - begin);
  if (new_size > capacity_)
    grow(new_size);
  std::uninitialized_copy(begin, end,
                          internal::make_ptr(ptr_, capacity_) + size_);
  size_ = new_size;
}

namespace internal {

// A memory buffer for trivially copyable/constructible types with the first
// SIZE elements stored in the object itself.
template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
class MemoryBuffer : private Allocator, public Buffer<T> {
 private:
  T data_[SIZE];

  // Deallocate memory allocated by the buffer.
  void deallocate() {
    if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
  }

 protected:
  void grow(std::size_t size) FMT_OVERRIDE;

 public:
  explicit MemoryBuffer(const Allocator &alloc = Allocator())
      : Allocator(alloc), Buffer<T>(data_, SIZE) {}
  ~MemoryBuffer() FMT_OVERRIDE { deallocate(); }

#if FMT_USE_RVALUE_REFERENCES
 private:
  // Move data from other to this buffer.
  void move(MemoryBuffer &other) {
    Allocator &this_alloc = *this, &other_alloc = other;
    this_alloc = std::move(other_alloc);
    this->size_ = other.size_;
    this->capacity_ = other.capacity_;
    if (other.ptr_ == other.data_) {
      this->ptr_ = data_;
      std::uninitialized_copy(other.data_, other.data_ + this->size_,
                              make_ptr(data_, this->capacity_));
    } else {
      this->ptr_ = other.ptr_;
      // Set pointer to the inline array so that delete is not called
      // when deallocating.
      other.ptr_ = other.data_;
    }
  }

 public:
  MemoryBuffer(MemoryBuffer &&other) {
    move(other);
  }

  MemoryBuffer &operator=(MemoryBuffer &&other) {
    assert(this != &other);
    deallocate();
    move(other);
    return *this;
  }
#endif

  // Returns a copy of the allocator associated with this buffer.
  Allocator get_allocator() const { return *this; }
};

template <typename T, std::size_t SIZE, typename Allocator>
void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
  std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
  if (size > new_capacity)
      new_capacity = size;
#if FMT_USE_ALLOCATOR_TRAITS
  T *new_ptr =
      std::allocator_traits<Allocator>::allocate(*this, new_capacity, FMT_NULL);
#else
  T *new_ptr = this->allocate(new_capacity, FMT_NULL);
#endif
  // The following code doesn't throw, so the raw pointer above doesn't leak.
  std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
                          make_ptr(new_ptr, new_capacity));
  std::size_t old_capacity = this->capacity_;
  T *old_ptr = this->ptr_;
  this->capacity_ = new_capacity;
  this->ptr_ = new_ptr;
  // deallocate may throw (at least in principle), but it doesn't matter since
  // the buffer already uses the new storage and will deallocate it in case
  // of exception.
  if (old_ptr != data_)
    Allocator::deallocate(old_ptr, old_capacity);
}

// A fixed-size buffer.
template <typename Char>
class FixedBuffer : public fmt::Buffer<Char> {
 public:
  FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}

 protected:
  FMT_API void grow(std::size_t size) FMT_OVERRIDE;
};

template <typename Char>
class BasicCharTraits {
 public:
#if FMT_SECURE_SCL
  typedef stdext::checked_array_iterator<Char*> CharPtr;
#else
  typedef Char *CharPtr;
#endif
  static Char cast(int value) { return static_cast<Char>(value); }
};

template <typename Char>
class CharTraits;

template <>
class CharTraits<char> : public BasicCharTraits<char> {
 private:
  // Conversion from wchar_t to char is not allowed.
  static char convert(wchar_t);

 public:
  static char convert(char value) { return value; }

  // Formats a floating-point number.
  template <typename T>
  FMT_API static int format_float(char *buffer, std::size_t size,
      const char *format, unsigned width, int precision, T value);
};

#if FMT_USE_EXTERN_TEMPLATES
extern template int CharTraits<char>::format_float<double>
        (char *buffer, std::size_t size,
         const char* format, unsigned width, int precision, double value);
extern template int CharTraits<char>::format_float<long double>
        (char *buffer, std::size_t size,
         const char* format, unsigned width, int precision, long double value);
#endif

template <>
class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> {
 public:
  static wchar_t convert(char value) { return value; }
  static wchar_t convert(wchar_t value) { return value; }

  template <typename T>
  FMT_API static int format_float(wchar_t *buffer, std::size_t size,
      const wchar_t *format, unsigned width, int precision, T value);
};

#if FMT_USE_EXTERN_TEMPLATES
extern template int CharTraits<wchar_t>::format_float<double>
        (wchar_t *buffer, std::size_t size,
         const wchar_t* format, unsigned width, int precision, double value);
extern template int CharTraits<wchar_t>::format_float<long double>
        (wchar_t *buffer, std::size_t size,
         const wchar_t* format, unsigned width, int precision, long double value);
#endif

// Checks if a number is negative - used to avoid warnings.
template <bool IsSigned>
struct SignChecker {
  template <typename T>
  static bool is_negative(T value) { return value < 0; }
};

template <>
struct SignChecker<false> {
  template <typename T>
  static bool is_negative(T) { return false; }
};

// Returns true if value is negative, false otherwise.
// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
template <typename T>
inline bool is_negative(T value) {
  return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
}

// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
template <bool FitsIn32Bits>
struct TypeSelector { typedef uint32_t Type; };

template <>
struct TypeSelector<false> { typedef uint64_t Type; };

template <typename T>
struct IntTraits {
  // Smallest of uint32_t and uint64_t that is large enough to represent
  // all values of T.
  typedef typename
    TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
};

FMT_API FMT_NORETURN void report_unknown_type(char code, const char *type);

// Static data is placed in this class template to allow header-only
// configuration.
template <typename T = void>
struct FMT_API BasicData {
  static const uint32_t POWERS_OF_10_32[];
  static const uint64_t POWERS_OF_10_64[];
  static const char DIGITS[];
};

#if FMT_USE_EXTERN_TEMPLATES
extern template struct BasicData<void>;
#endif

typedef BasicData<> Data;

#ifdef FMT_BUILTIN_CLZLL
// Returns the number of decimal digits in n. Leading zeros are not counted
// except for n == 0 in which case count_digits returns 1.
inline unsigned count_digits(uint64_t n) {
  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
  return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;
}
#else
// Fallback version of count_digits used when __builtin_clz is not available.
inline unsigned count_digits(uint64_t n) {
  unsigned count = 1;
  for (;;) {
    // Integer division is slow so do it for a group of four digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    if (n < 10) return count;
    if (n < 100) return count + 1;
    if (n < 1000) return count + 2;
    if (n < 10000) return count + 3;
    n /= 10000u;
    count += 4;
  }
}
#endif

#ifdef FMT_BUILTIN_CLZ
// Optional version of count_digits for better performance on 32-bit platforms.
inline unsigned count_digits(uint32_t n) {
  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
  return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1;
}
#endif

// A functor that doesn't add a thousands separator.
struct NoThousandsSep {
  template <typename Char>
  void operator()(Char *) {}
};

// A functor that adds a thousands separator.
class ThousandsSep {
 private:
  fmt::StringRef sep_;

  // Index of a decimal digit with the least significant digit having index 0.
  unsigned digit_index_;

 public:
  explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {}

  template <typename Char>
  void operator()(Char *&buffer) {
    if (++digit_index_ % 3 != 0)
      return;
    buffer -= sep_.size();
    std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
                            internal::make_ptr(buffer, sep_.size()));
  }
};

// Formats a decimal unsigned integer value writing into buffer.
// thousands_sep is a functor that is called after writing each char to
// add a thousands separator if necessary.
template <typename UInt, typename Char, typename ThousandsSep>
inline void format_decimal(Char *buffer, UInt value, unsigned num_digits,
                           ThousandsSep thousands_sep) {
  buffer += num_digits;
  while (value >= 100) {
    // Integer division is slow so do it for a group of two digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    unsigned index = static_cast<unsigned>((value % 100) * 2);
    value /= 100;
    *--buffer = Data::DIGITS[index + 1];
    thousands_sep(buffer);
    *--buffer = Data::DIGITS[index];
    thousands_sep(buffer);
  }
  if (value < 10) {
    *--buffer = static_cast<char>('0' + value);
    return;
  }
  unsigned index = static_cast<unsigned>(value * 2);
  *--buffer = Data::DIGITS[index + 1];
  thousands_sep(buffer);
  *--buffer = Data::DIGITS[index];
}

template <typename UInt, typename Char>
inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
  format_decimal(buffer, value, num_digits, NoThousandsSep());
  return;
}

#ifndef _WIN32
# define FMT_USE_WINDOWS_H 0
#elif !defined(FMT_USE_WINDOWS_H)
# define FMT_USE_WINDOWS_H 1
#endif

// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
// All the functionality that relies on it will be disabled too.
#if FMT_USE_WINDOWS_H
// A converter from UTF-8 to UTF-16.
// It is only provided for Windows since other systems support UTF-8 natively.
class UTF8ToUTF16 {
 private:
  MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;

 public:
  FMT_API explicit UTF8ToUTF16(StringRef s);
  operator WStringRef() const { return WStringRef(&buffer_[0], size()); }
  size_t size() const { return buffer_.size() - 1; }
  const wchar_t *c_str() const { return &buffer_[0]; }
  std::wstring str() const { return std::wstring(&buffer_[0], size()); }
};

// A converter from UTF-16 to UTF-8.
// It is only provided for Windows since other systems support UTF-8 natively.
class UTF16ToUTF8 {
 private:
  MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;

 public:
  UTF16ToUTF8() {}
  FMT_API explicit UTF16ToUTF8(WStringRef s);
  operator StringRef() const { return StringRef(&buffer_[0], size()); }
  size_t size() const { return buffer_.size() - 1; }
  const char *c_str() const { return &buffer_[0]; }
  std::string str() const { return std::string(&buffer_[0], size()); }

  // Performs conversion returning a system error code instead of
  // throwing exception on conversion error. This method may still throw
  // in case of memory allocation error.
  FMT_API int convert(WStringRef s);
};

FMT_API void format_windows_error(fmt::Writer &out, int error_code,
                                  fmt::StringRef message) FMT_NOEXCEPT;
#endif

// A formatting argument value.
struct Value {
  template <typename Char>
  struct StringValue {
    const Char *value;
    std::size_t size;
  };

  typedef void (*FormatFunc)(
      void *formatter, const void *arg, void *format_str_ptr);

  struct CustomValue {
    const void *value;
    FormatFunc format;
  };

  union {
    int int_value;
    unsigned uint_value;
    LongLong long_long_value;
    ULongLong ulong_long_value;
    double double_value;
    long double long_double_value;
    const void *pointer;
    StringValue<char> string;
    StringValue<signed char> sstring;
    StringValue<unsigned char> ustring;
    StringValue<wchar_t> wstring;
    CustomValue custom;
  };

  enum Type {
    NONE, NAMED_ARG,
    // Integer types should go first,
    INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
    // followed by floating-point types.
    DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
    CSTRING, STRING, WSTRING, POINTER, CUSTOM
  };
};

// A formatting argument. It is a trivially copyable/constructible type to
// allow storage in internal::MemoryBuffer.
struct Arg : Value {
  Type type;
};

template <typename Char>
struct NamedArg;
template <typename Char, typename T>
struct NamedArgWithType;

template <typename T = void>
struct Null {};

// A helper class template to enable or disable overloads taking wide
// characters and strings in MakeValue.
template <typename T, typename Char>
struct WCharHelper {
  typedef Null<T> Supported;
  typedef T Unsupported;
};

template <typename T>
struct WCharHelper<T, wchar_t> {
  typedef T Supported;
  typedef Null<T> Unsupported;
};

typedef char Yes[1];
typedef char No[2];

template <typename T>
T &get();

// These are non-members to workaround an overload resolution bug in bcc32.
Yes &convert(fmt::ULongLong);
No &convert(...);

template <typename T, bool ENABLE_CONVERSION>
struct ConvertToIntImpl {
  enum { value = ENABLE_CONVERSION };
};

template <typename T, bool ENABLE_CONVERSION>
struct ConvertToIntImpl2 {
  enum { value = false };
};

template <typename T>
struct ConvertToIntImpl2<T, true> {
  enum {
    // Don't convert numeric types.
    value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
  };
};

template <typename T>
struct ConvertToInt {
  enum {
    enable_conversion = sizeof(fmt::internal::convert(get<T>())) == sizeof(Yes)
  };
  enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
};

#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
  template <> \
  struct ConvertToInt<Type> {  enum { value = 0 }; }

// Silence warnings about convering float to int.
FMT_DISABLE_CONVERSION_TO_INT(float);
FMT_DISABLE_CONVERSION_TO_INT(double);
FMT_DISABLE_CONVERSION_TO_INT(long double);

template <bool B, class T = void>
struct EnableIf {};

template <class T>
struct EnableIf<true, T> { typedef T type; };

template <bool B, class T, class F>
struct Conditional { typedef T type; };

template <class T, class F>
struct Conditional<false, T, F> { typedef F type; };

// For bcc32 which doesn't understand ! in template arguments.
template <bool>
struct Not { enum { value = 0 }; };

template <>
struct Not<false> { enum { value = 1 }; };

template <typename T>
struct FalseType { enum { value = 0 }; };

template <typename T, T> struct LConvCheck {
  LConvCheck(int) {}
};

// Returns the thousands separator for the current locale.
// We check if ``lconv`` contains ``thousands_sep`` because on Android
// ``lconv`` is stubbed as an empty struct.
template <typename LConv>
inline StringRef thousands_sep(
    LConv *lc, LConvCheck<char *LConv::*, &LConv::thousands_sep> = 0) {
  return lc->thousands_sep;
}

inline fmt::StringRef thousands_sep(...) { return ""; }

#define FMT_CONCAT(a, b) a##b

#if FMT_GCC_VERSION >= 303
# define FMT_UNUSED __attribute__((unused))
#else
# define FMT_UNUSED
#endif

#ifndef FMT_USE_STATIC_ASSERT
# define FMT_USE_STATIC_ASSERT 0
#endif

#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
  (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
#else
# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
# define FMT_STATIC_ASSERT(cond, message) \
  typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
#endif

template <typename Formatter>
void format_arg(Formatter&, ...) {
  FMT_STATIC_ASSERT(FalseType<Formatter>::value,
                    "Cannot format argument. To enable the use of ostream "
                    "operator<< include fmt/ostream.h. Otherwise provide "
                    "an overload of format_arg.");
}

// Makes an Arg object from any type.
template <typename Formatter>
class MakeValue : public Arg {
 public:
  typedef typename Formatter::Char Char;

 private:
  // The following two methods are private to disallow formatting of
  // arbitrary pointers. If you want to output a pointer cast it to
  // "void *" or "const void *". In particular, this forbids formatting
  // of "[const] volatile char *" which is printed as bool by iostreams.
  // Do not implement!
  template <typename T>
  MakeValue(const T *value);
  template <typename T>
  MakeValue(T *value);

  // The following methods are private to disallow formatting of wide
  // characters and strings into narrow strings as in
  //   fmt::format("{}", L"test");
  // To fix this, use a wide format string: fmt::format(L"{}", L"test").
#if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED)
  MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
#endif
  MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
  MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
  MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
#if FMT_HAS_STRING_VIEW
  MakeValue(typename WCharHelper<const std::wstring_view &, Char>::Unsupported);
#endif
  MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);

  void set_string(StringRef str) {
    string.value = str.data();
    string.size = str.size();
  }

  void set_string(WStringRef str) {
    wstring.value = str.data();
    wstring.size = str.size();
  }

  // Formats an argument of a custom type, such as a user-defined class.
  template <typename T>
  static void format_custom_arg(
      void *formatter, const void *arg, void *format_str_ptr) {
    format_arg(*static_cast<Formatter*>(formatter),
               *static_cast<const Char**>(format_str_ptr),
               *static_cast<const T*>(arg));
  }

 public:
  MakeValue() {}

#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
  MakeValue(Type value) { field = rhs; } \
  static uint64_t type(Type) { return Arg::TYPE; }

#define FMT_MAKE_VALUE(Type, field, TYPE) \
  FMT_MAKE_VALUE_(Type, field, TYPE, value)

  FMT_MAKE_VALUE(bool, int_value, BOOL)
  FMT_MAKE_VALUE(short, int_value, INT)
  FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
  FMT_MAKE_VALUE(int, int_value, INT)
  FMT_MAKE_VALUE(unsigned, uint_value, UINT)

  MakeValue(long value) {
    // To minimize the number of types we need to deal with, long is
    // translated either to int or to long long depending on its size.
    if (const_check(sizeof(long) == sizeof(int)))
      int_value = static_cast<int>(value);
    else
      long_long_value = value;
  }
  static uint64_t type(long) {
    return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
  }

  MakeValue(unsigned long value) {
    if (const_check(sizeof(unsigned long) == sizeof(unsigned)))
      uint_value = static_cast<unsigned>(value);
    else
      ulong_long_value = value;
  }
  static uint64_t type(unsigned long) {
    return sizeof(unsigned long) == sizeof(unsigned) ?
          Arg::UINT : Arg::ULONG_LONG;
  }

  FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
  FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
  FMT_MAKE_VALUE(float, double_value, DOUBLE)
  FMT_MAKE_VALUE(double, double_value, DOUBLE)
  FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
  FMT_MAKE_VALUE(signed char, int_value, INT)
  FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
  FMT_MAKE_VALUE(char, int_value, CHAR)

#if __cplusplus >= 201103L
  template <
    typename T,
    typename = typename std::enable_if<
      std::is_enum<T>::value && ConvertToInt<T>::value>::type>
   MakeValue(T value) { int_value = value; }

  template <
    typename T,
    typename = typename std::enable_if<
      std::is_enum<T>::value && ConvertToInt<T>::value>::type>
  static uint64_t type(T) { return Arg::INT; }
#endif

#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
  MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
    int_value = value;
  }
  static uint64_t type(wchar_t) { return Arg::CHAR; }
#endif

#define FMT_MAKE_STR_VALUE(Type, TYPE) \
  MakeValue(Type value) { set_string(value); } \
  static uint64_t type(Type) { return Arg::TYPE; }

  FMT_MAKE_VALUE(char *, string.value, CSTRING)
  FMT_MAKE_VALUE(const char *, string.value, CSTRING)
  FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
  FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
  FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
  FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
  FMT_MAKE_STR_VALUE(const std::string &, STRING)
#if FMT_HAS_STRING_VIEW
  FMT_MAKE_STR_VALUE(const std::string_view &, STRING)
#endif
  FMT_MAKE_STR_VALUE(StringRef, STRING)
  FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())

#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
  MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
    set_string(value); \
  } \
  static uint64_t type(Type) { return Arg::TYPE; }

  FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
  FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
  FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
#if FMT_HAS_STRING_VIEW
  FMT_MAKE_WSTR_VALUE(const std::wstring_view &, WSTRING)
#endif
  FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)

  FMT_MAKE_VALUE(void *, pointer, POINTER)
  FMT_MAKE_VALUE(const void *, pointer, POINTER)

  template <typename T>
  MakeValue(const T &value,
            typename EnableIf<Not<
              ConvertToInt<T>::value>::value, int>::type = 0) {
    custom.value = &value;
    custom.format = &format_custom_arg<T>;
  }

  template <typename T>
  static typename EnableIf<Not<ConvertToInt<T>::value>::value, uint64_t>::type
      type(const T &) {
    return Arg::CUSTOM;
  }

  // Additional template param `Char_` is needed here because make_type always
  // uses char.
  template <typename Char_>
  MakeValue(const NamedArg<Char_> &value) { pointer = &value; }
  template <typename Char_, typename T>
  MakeValue(const NamedArgWithType<Char_, T> &value) { pointer = &value; }

  template <typename Char_>
  static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
  template <typename Char_, typename T>
  static uint64_t type(const NamedArgWithType<Char_, T> &) { return Arg::NAMED_ARG; }
};

template <typename Formatter>
class MakeArg : public Arg {
public:
  MakeArg() {
    type = Arg::NONE;
  }

  template <typename T>
  MakeArg(const T &value)
  : Arg(MakeValue<Formatter>(value)) {
    type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));
  }
};

template <typename Char>
struct NamedArg : Arg {
  BasicStringRef<Char> name;

  template <typename T>
  NamedArg(BasicStringRef<Char> argname, const T &value)
  : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
};

template <typename Char, typename T>
struct NamedArgWithType : NamedArg<Char> {
  NamedArgWithType(BasicStringRef<Char> argname, const T &value)
  : NamedArg<Char>(argname, value) {}
};

class RuntimeError : public std::runtime_error {
 protected:
  RuntimeError() : std::runtime_error("") {}
  RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {}
  FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;
};

template <typename Char>
class ArgMap;
}  // namespace internal

/** An argument list. */
class ArgList {
 private:
  // To reduce compiled code size per formatting function call, types of first
  // MAX_PACKED_ARGS arguments are passed in the types_ field.
  uint64_t types_;
  union {
    // If the number of arguments is less than MAX_PACKED_ARGS, the argument
    // values are stored in values_, otherwise they are stored in args_.
    // This is done to reduce compiled code size as storing larger objects
    // may require more code (at least on x86-64) even if the same amount of
    // data is actually copied to stack. It saves ~10% on the bloat test.
    const internal::Value *values_;
    const internal::Arg *args_;
  };

  internal::Arg::Type type(unsigned index) const {
    return type(types_, index);
  }

  template <typename Char>
  friend class internal::ArgMap;

 public:
  // Maximum number of arguments with packed types.
  enum { MAX_PACKED_ARGS = 16 };

  ArgList() : types_(0) {}

  ArgList(ULongLong types, const internal::Value *values)
  : types_(types), values_(values) {}
  ArgList(ULongLong types, const internal::Arg *args)
  : types_(types), args_(args) {}

  uint64_t types() const { return types_; }

  /** Returns the argument at specified index. */
  internal::Arg operator[](unsigned index) const {
    using internal::Arg;
    Arg arg;
    bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
    if (index < MAX_PACKED_ARGS) {
      Arg::Type arg_type = type(index);
      internal::Value &val = arg;
      if (arg_type != Arg::NONE)
        val = use_values ? values_[index] : args_[index];
      arg.type = arg_type;
      return arg;
    }
    if (use_values) {
      // The index is greater than the number of arguments that can be stored
      // in values, so return a "none" argument.
      arg.type = Arg::NONE;
      return arg;
    }
    for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
      if (args_[i].type == Arg::NONE)
        return args_[i];
    }
    return args_[index];
  }

  static internal::Arg::Type type(uint64_t types, unsigned index) {
    unsigned shift = index * 4;
    uint64_t mask = 0xf;
    return static_cast<internal::Arg::Type>(
          (types & (mask << shift)) >> shift);
  }
};

#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call

/**
  \rst
  An argument visitor based on the `curiously recurring template pattern
  <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.

  To use `~fmt::ArgVisitor` define a subclass that implements some or all of the
  visit methods with the same signatures as the methods in `~fmt::ArgVisitor`,
  for example, `~fmt::ArgVisitor::visit_int()`.
  Pass the subclass as the *Impl* template parameter. Then calling
  `~fmt::ArgVisitor::visit` for some argument will dispatch to a visit method
  specific to the argument type. For example, if the argument type is
  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
  will be called. If the subclass doesn't contain a method with this signature,
  then a corresponding method of `~fmt::ArgVisitor` will be called.

  **Example**::

    class MyArgVisitor : public fmt::ArgVisitor<MyArgVisitor, void> {
     public:
      void visit_int(int value) { fmt::print("{}", value); }
      void visit_double(double value) { fmt::print("{}", value ); }
    };
  \endrst
 */
template <typename Impl, typename Result>
class ArgVisitor {
 private:
  typedef internal::Arg Arg;

 public:
  void report_unhandled_arg() {}

  Result visit_unhandled_arg() {
    FMT_DISPATCH(report_unhandled_arg());
    return Result();
  }

  /** Visits an ``int`` argument. **/
  Result visit_int(int value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits a ``long long`` argument. **/
  Result visit_long_long(LongLong value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits an ``unsigned`` argument. **/
  Result visit_uint(unsigned value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits an ``unsigned long long`` argument. **/
  Result visit_ulong_long(ULongLong value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits a ``bool`` argument. **/
  Result visit_bool(bool value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits a ``char`` or ``wchar_t`` argument. **/
  Result visit_char(int value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits an argument of any integral type. **/
  template <typename T>
  Result visit_any_int(T) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a ``double`` argument. **/
  Result visit_double(double value) {
    return FMT_DISPATCH(visit_any_double(value));
  }

  /** Visits a ``long double`` argument. **/
  Result visit_long_double(long double value) {
    return FMT_DISPATCH(visit_any_double(value));
  }

  /** Visits a ``double`` or ``long double`` argument. **/
  template <typename T>
  Result visit_any_double(T) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a null-terminated C string (``const char *``) argument. **/
  Result visit_cstring(const char *) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a string argument. **/
  Result visit_string(Arg::StringValue<char>) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a wide string argument. **/
  Result visit_wstring(Arg::StringValue<wchar_t>) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a pointer argument. **/
  Result visit_pointer(const void *) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits an argument of a custom (user-defined) type. **/
  Result visit_custom(Arg::CustomValue) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /**
    \rst
    Visits an argument dispatching to the appropriate visit method based on
    the argument type. For example, if the argument type is ``double`` then
    the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be
    called.
    \endrst
   */
  Result visit(const Arg &arg) {
    switch (arg.type) {
    case Arg::NONE:
    case Arg::NAMED_ARG:
      FMT_ASSERT(false, "invalid argument type");
      break;
    case Arg::INT:
      return FMT_DISPATCH(visit_int(arg.int_value));
    case Arg::UINT:
      return FMT_DISPATCH(visit_uint(arg.uint_value));
    case Arg::LONG_LONG:
      return FMT_DISPATCH(visit_long_long(arg.long_long_value));
    case Arg::ULONG_LONG:
      return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
    case Arg::BOOL:
      return FMT_DISPATCH(visit_bool(arg.int_value != 0));
    case Arg::CHAR:
      return FMT_DISPATCH(visit_char(arg.int_value));
    case Arg::DOUBLE:
      return FMT_DISPATCH(visit_double(arg.double_value));
    case Arg::LONG_DOUBLE:
      return FMT_DISPATCH(visit_long_double(arg.long_double_value));
    case Arg::CSTRING:
      return FMT_DISPATCH(visit_cstring(arg.string.value));
    case Arg::STRING:
      return FMT_DISPATCH(visit_string(arg.string));
    case Arg::WSTRING:
      return FMT_DISPATCH(visit_wstring(arg.wstring));
    case Arg::POINTER:
      return FMT_DISPATCH(visit_pointer(arg.pointer));
    case Arg::CUSTOM:
      return FMT_DISPATCH(visit_custom(arg.custom));
    }
    return Result();
  }
};

enum Alignment {
  ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
};

// Flags.
enum {
  SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
  CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.
};

// An empty format specifier.
struct EmptySpec {};

// A type specifier.
template <char TYPE>
struct TypeSpec : EmptySpec {
  Alignment align() const { return ALIGN_DEFAULT; }
  unsigned width() const { return 0; }
  int precision() const { return -1; }
  bool flag(unsigned) const { return false; }
  char type() const { return TYPE; }
  char type_prefix() const { return TYPE; }
  char fill() const { return ' '; }
};

// A width specifier.
struct WidthSpec {
  unsigned width_;
  // Fill is always wchar_t and cast to char if necessary to avoid having
  // two specialization of WidthSpec and its subclasses.
  wchar_t fill_;

  WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}

  unsigned width() const { return width_; }
  wchar_t fill() const { return fill_; }
};

// An alignment specifier.
struct AlignSpec : WidthSpec {
  Alignment align_;

  AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
  : WidthSpec(width, fill), align_(align) {}

  Alignment align() const { return align_; }

  int precision() const { return -1; }
};

// An alignment and type specifier.
template <char TYPE>
struct AlignTypeSpec : AlignSpec {
  AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}

  bool flag(unsigned) const { return false; }
  char type() const { return TYPE; }
  char type_prefix() const { return TYPE; }
};

// A full format specifier.
struct FormatSpec : AlignSpec {
  unsigned flags_;
  int precision_;
  char type_;

  FormatSpec(
    unsigned width = 0, char type = 0, wchar_t fill = ' ')
  : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}

  bool flag(unsigned f) const { return (flags_ & f) != 0; }
  int precision() const { return precision_; }
  char type() const { return type_; }
  char type_prefix() const { return type_; }
};

// An integer format specifier.
template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
class IntFormatSpec : public SpecT {
 private:
  T value_;

 public:
  IntFormatSpec(T val, const SpecT &spec = SpecT())
  : SpecT(spec), value_(val) {}

  T value() const { return value_; }
};

// A string format specifier.
template <typename Char>
class StrFormatSpec : public AlignSpec {
 private:
  const Char *str_;

 public:
  template <typename FillChar>
  StrFormatSpec(const Char *str, unsigned width, FillChar fill)
  : AlignSpec(width, fill), str_(str) {
    internal::CharTraits<Char>::convert(FillChar());
  }

  const Char *str() const { return str_; }
};

/**
  Returns an integer format specifier to format the value in base 2.
 */
IntFormatSpec<int, TypeSpec<'b'> > bin(int value);

/**
  Returns an integer format specifier to format the value in base 8.
 */
IntFormatSpec<int, TypeSpec<'o'> > oct(int value);

/**
  Returns an integer format specifier to format the value in base 16 using
  lower-case letters for the digits above 9.
 */
IntFormatSpec<int, TypeSpec<'x'> > hex(int value);

/**
  Returns an integer formatter format specifier to format in base 16 using
  upper-case letters for the digits above 9.
 */
IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);

/**
  \rst
  Returns an integer format specifier to pad the formatted argument with the
  fill character to the specified width using the default (right) numeric
  alignment.

  **Example**::

    MemoryWriter out;
    out << pad(hex(0xcafe), 8, '0');
    // out.str() == "0000cafe"

  \endrst
 */
template <char TYPE_CODE, typename Char>
IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
    int value, unsigned width, Char fill = ' ');

#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
} \
 \
inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
} \
 \
inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
} \
 \
inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
} \
 \
template <char TYPE_CODE> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
      f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
} \
 \
/* For compatibility with older compilers we provide two overloads for pad, */ \
/* one that takes a fill character and one that doesn't. In the future this */ \
/* can be replaced with one overload making the template argument Char      */ \
/* default to char (C++11). */ \
template <char TYPE_CODE, typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
    unsigned width, Char fill) { \
  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
      f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
} \
 \
inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
    TYPE value, unsigned width) { \
  return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
      value, AlignTypeSpec<0>(width, ' ')); \
} \
 \
template <typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
   TYPE value, unsigned width, Char fill) { \
 return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
     value, AlignTypeSpec<0>(width, fill)); \
}

FMT_DEFINE_INT_FORMATTERS(int)
FMT_DEFINE_INT_FORMATTERS(long)
FMT_DEFINE_INT_FORMATTERS(unsigned)
FMT_DEFINE_INT_FORMATTERS(unsigned long)
FMT_DEFINE_INT_FORMATTERS(LongLong)
FMT_DEFINE_INT_FORMATTERS(ULongLong)

/**
  \rst
  Returns a string formatter that pads the formatted argument with the fill
  character to the specified width using the default (left) string alignment.

  **Example**::

    std::string s = str(MemoryWriter() << pad("abc", 8));
    // s == "abc     "

  \endrst
 */
template <typename Char>
inline StrFormatSpec<Char> pad(
    const Char *str, unsigned width, Char fill = ' ') {
  return StrFormatSpec<Char>(str, width, fill);
}

inline StrFormatSpec<wchar_t> pad(
    const wchar_t *str, unsigned width, char fill = ' ') {
  return StrFormatSpec<wchar_t>(str, width, fill);
}

namespace internal {

template <typename Char>
class ArgMap {
 private:
  typedef std::vector<
    std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;
  typedef typename MapType::value_type Pair;

  MapType map_;

 public:
  void init(const ArgList &args);

  const internal::Arg *find(const fmt::BasicStringRef<Char> &name) const {
    // The list is unsorted, so just return the first matching name.
    for (typename MapType::const_iterator it = map_.begin(), end = map_.end();
         it != end; ++it) {
      if (it->first == name)
        return &it->second;
    }
    return FMT_NULL;
  }
};

template <typename Char>
void ArgMap<Char>::init(const ArgList &args) {
  if (!map_.empty())
    return;
  typedef internal::NamedArg<Char> NamedArg;
  const NamedArg *named_arg = FMT_NULL;
  bool use_values =
      args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
  if (use_values) {
    for (unsigned i = 0;/*nothing*/; ++i) {
      internal::Arg::Type arg_type = args.type(i);
      switch (arg_type) {
      case internal::Arg::NONE:
        return;
      case internal::Arg::NAMED_ARG:
        named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
        map_.push_back(Pair(named_arg->name, *named_arg));
        break;
      default:
        /*nothing*/;
      }
    }
    return;
  }
  for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
    internal::Arg::Type arg_type = args.type(i);
    if (arg_type == internal::Arg::NAMED_ARG) {
      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
      map_.push_back(Pair(named_arg->name, *named_arg));
    }
  }
  for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
    switch (args.args_[i].type) {
    case internal::Arg::NONE:
      return;
    case internal::Arg::NAMED_ARG:
      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
      map_.push_back(Pair(named_arg->name, *named_arg));
      break;
    default:
      /*nothing*/;
    }
  }
}

template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
class ArgFormatterBase : public ArgVisitor<Impl, void> {
 private:
  BasicWriter<Char> &writer_;
  Spec &spec_;

  FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);

  void write_pointer(const void *p) {
    spec_.flags_ = HASH_FLAG;
    spec_.type_ = 'x';
    writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
  }

  // workaround MSVC two-phase lookup issue
  typedef internal::Arg Arg;

 protected:
  BasicWriter<Char> &writer() { return writer_; }
  Spec &spec() { return spec_; }

  void write(bool value) {
    const char *str_value = value ? "true" : "false";
    Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
    writer_.write_str(str, spec_);
  }

  void write(const char *value) {
    Arg::StringValue<char> str = {value, value ? std::strlen(value) : 0};
    writer_.write_str(str, spec_);
  }

 public:
  typedef Spec SpecType;

  ArgFormatterBase(BasicWriter<Char> &w, Spec &s)
  : writer_(w), spec_(s) {}

  template <typename T>
  void visit_any_int(T value) { writer_.write_int(value, spec_); }

  template <typename T>
  void visit_any_double(T value) { writer_.write_double(value, spec_); }

  void visit_bool(bool value) {
    if (spec_.type_) {
      visit_any_int(value);
      return;
    }
    write(value);
  }

  void visit_char(int value) {
    if (spec_.type_ && spec_.type_ != 'c') {
      spec_.flags_ |= CHAR_FLAG;
      writer_.write_int(value, spec_);
      return;
    }
    if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
      FMT_THROW(FormatError("invalid format specifier for char"));
    typedef typename BasicWriter<Char>::CharPtr CharPtr;
    Char fill = internal::CharTraits<Char>::cast(spec_.fill());
    CharPtr out = CharPtr();
    const unsigned CHAR_SIZE = 1;
    if (spec_.width_ > CHAR_SIZE) {
      out = writer_.grow_buffer(spec_.width_);
      if (spec_.align_ == ALIGN_RIGHT) {
        std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill);
        out += spec_.width_ - CHAR_SIZE;
      } else if (spec_.align_ == ALIGN_CENTER) {
        out = writer_.fill_padding(out, spec_.width_,
                                   internal::const_check(CHAR_SIZE), fill);
      } else {
        std::uninitialized_fill_n(out + CHAR_SIZE,
                                  spec_.width_ - CHAR_SIZE, fill);
      }
    } else {
      out = writer_.grow_buffer(CHAR_SIZE);
    }
    *out = internal::CharTraits<Char>::cast(value);
  }

  void visit_cstring(const char *value) {
    if (spec_.type_ == 'p')
      return write_pointer(value);
    write(value);
  }

  // Qualification with "internal" here and below is a workaround for nvcc.
  void visit_string(internal::Arg::StringValue<char> value) {
    writer_.write_str(value, spec_);
  }

  using ArgVisitor<Impl, void>::visit_wstring;

  void visit_wstring(internal::Arg::StringValue<Char> value) {
    writer_.write_str(value, spec_);
  }

  void visit_pointer(const void *value) {
    if (spec_.type_ && spec_.type_ != 'p')
      report_unknown_type(spec_.type_, "pointer");
    write_pointer(value);
  }
};

class FormatterBase {
 private:
  ArgList args_;
  int next_arg_index_;

  // Returns the argument with specified index.
  FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);

 protected:
  const ArgList &args() const { return args_; }

  explicit FormatterBase(const ArgList &args) {
    args_ = args;
    next_arg_index_ = 0;
  }

  // Returns the next argument.
  Arg next_arg(const char *&error) {
    if (next_arg_index_ >= 0)
      return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
    error = "cannot switch from manual to automatic argument indexing";
    return Arg();
  }

  // Checks if manual indexing is used and returns the argument with
  // specified index.
  Arg get_arg(unsigned arg_index, const char *&error) {
    return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
  }

  bool check_no_auto_index(const char *&error) {
    if (next_arg_index_ > 0) {
      error = "cannot switch from automatic to manual argument indexing";
      return false;
    }
    next_arg_index_ = -1;
    return true;
  }

  template <typename Char>
  void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
    if (start != end)
      w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
  }
};
}  // namespace internal

/**
  \rst
  An argument formatter based on the `curiously recurring template pattern
  <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.

  To use `~fmt::BasicArgFormatter` define a subclass that implements some or
  all of the visit methods with the same signatures as the methods in
  `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`.
  Pass the subclass as the *Impl* template parameter. When a formatting
  function processes an argument, it will dispatch to a visit method
  specific to the argument type. For example, if the argument type is
  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
  will be called. If the subclass doesn't contain a method with this signature,
  then a corresponding method of `~fmt::BasicArgFormatter` or its superclass
  will be called.
  \endrst
 */
template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char, Spec> {
 private:
  BasicFormatter<Char, Impl> &formatter_;
  const Char *format_;

 public:
  /**
    \rst
    Constructs an argument formatter object.
    *formatter* is a reference to the main formatter object, *spec* contains
    format specifier information for standard argument types, and *fmt* points
    to the part of the format string being parsed for custom argument types.
    \endrst
   */
  BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
                    Spec &spec, const Char *fmt)
  : internal::ArgFormatterBase<Impl, Char, Spec>(formatter.writer(), spec),
    formatter_(formatter), format_(fmt) {}

  /** Formats an argument of a custom (user-defined) type. */
  void visit_custom(internal::Arg::CustomValue c) {
    c.format(&formatter_, c.value, &format_);
  }
};

/** The default argument formatter. */
template <typename Char>
class ArgFormatter :
    public BasicArgFormatter<ArgFormatter<Char>, Char, FormatSpec> {
 public:
  /** Constructs an argument formatter object. */
  ArgFormatter(BasicFormatter<Char> &formatter,
               FormatSpec &spec, const Char *fmt)
  : BasicArgFormatter<ArgFormatter<Char>,
                      Char, FormatSpec>(formatter, spec, fmt) {}
};

/** This template formats data and writes the output to a writer. */
template <typename CharType, typename ArgFormatter>
class BasicFormatter : private internal::FormatterBase {
 public:
  /** The character type for the output. */
  typedef CharType Char;

 private:
  BasicWriter<Char> &writer_;
  internal::ArgMap<Char> map_;

  FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);

  using internal::FormatterBase::get_arg;

  // Checks if manual indexing is used and returns the argument with
  // specified name.
  internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);

  // Parses argument index and returns corresponding argument.
  internal::Arg parse_arg_index(const Char *&s);

  // Parses argument name and returns corresponding argument.
  internal::Arg parse_arg_name(const Char *&s);

 public:
  /**
   \rst
   Constructs a ``BasicFormatter`` object. References to the arguments and
   the writer are stored in the formatter object so make sure they have
   appropriate lifetimes.
   \endrst
   */
  BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
    : internal::FormatterBase(args), writer_(w) {}

  /** Returns a reference to the writer associated with this formatter. */
  BasicWriter<Char> &writer() { return writer_; }

  /** Formats stored arguments and writes the output to the writer. */
  void format(BasicCStringRef<Char> format_str);

  // Formats a single argument and advances format_str, a format string pointer.
  const Char *format(const Char *&format_str, const internal::Arg &arg);
};

// Generates a comma-separated list with results of applying f to
// numbers 0..n-1.
# define FMT_GEN(n, f) FMT_GEN##n(f)
# define FMT_GEN1(f)  f(0)
# define FMT_GEN2(f)  FMT_GEN1(f),  f(1)
# define FMT_GEN3(f)  FMT_GEN2(f),  f(2)
# define FMT_GEN4(f)  FMT_GEN3(f),  f(3)
# define FMT_GEN5(f)  FMT_GEN4(f),  f(4)
# define FMT_GEN6(f)  FMT_GEN5(f),  f(5)
# define FMT_GEN7(f)  FMT_GEN6(f),  f(6)
# define FMT_GEN8(f)  FMT_GEN7(f),  f(7)
# define FMT_GEN9(f)  FMT_GEN8(f),  f(8)
# define FMT_GEN10(f) FMT_GEN9(f),  f(9)
# define FMT_GEN11(f) FMT_GEN10(f), f(10)
# define FMT_GEN12(f) FMT_GEN11(f), f(11)
# define FMT_GEN13(f) FMT_GEN12(f), f(12)
# define FMT_GEN14(f) FMT_GEN13(f), f(13)
# define FMT_GEN15(f) FMT_GEN14(f), f(14)

namespace internal {
inline uint64_t make_type() { return 0; }

template <typename T>
inline uint64_t make_type(const T &arg) {
  return MakeValue< BasicFormatter<char> >::type(arg);
}

template <std::size_t N, bool/*IsPacked*/= (N < ArgList::MAX_PACKED_ARGS)>
struct ArgArray;

template <std::size_t N>
struct ArgArray<N, true/*IsPacked*/> {
  // '+' is used to silence GCC -Wduplicated-branches warning.
  typedef Value Type[N > 0 ? N : +1];

  template <typename Formatter, typename T>
  static Value make(const T &value) {
#ifdef __clang__
    Value result = MakeValue<Formatter>(value);
    // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang:
    // https://github.com/fmtlib/fmt/issues/276
    (void)result.custom.format;
    return result;
#else
    return MakeValue<Formatter>(value);
#endif
  }
};

template <std::size_t N>
struct ArgArray<N, false/*IsPacked*/> {
  typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE

  template <typename Formatter, typename T>
  static Arg make(const T &value) { return MakeArg<Formatter>(value); }
};

#if FMT_USE_VARIADIC_TEMPLATES
template <typename Arg, typename... Args>
inline uint64_t make_type(const Arg &first, const Args & ... tail) {
  return make_type(first) | (make_type(tail...) << 4);
}

#else

struct ArgType {
  uint64_t type;

  ArgType() : type(0) {}

  template <typename T>
  ArgType(const T &arg) : type(make_type(arg)) {}
};

# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()

inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
  return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
      (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
      (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
      (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
}
#endif
}  // namespace internal

# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
# define FMT_MAKE_ARG_TYPE(n) T##n
# define FMT_MAKE_ARG(n) const T##n &v##n
# define FMT_ASSIGN_char(n) \
  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)
# define FMT_ASSIGN_wchar_t(n) \
  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)

#if FMT_USE_VARIADIC_TEMPLATES
// Defines a variadic function returning void.
# define FMT_VARIADIC_VOID(func, arg_type) \
  template <typename... Args> \
  void func(arg_type arg0, const Args & ... args) { \
    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
    typename ArgArray::Type array{ \
      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
    func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \
  }

// Defines a variadic constructor.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
  template <typename... Args> \
  ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
    typename ArgArray::Type array{ \
      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
    func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \
  }

#else

# define FMT_MAKE_REF(n) \
  fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
# define FMT_MAKE_REF2(n) v##n

// Defines a wrapper for a function taking one argument of type arg_type
// and n additional arguments of arbitrary types.
# define FMT_WRAP1(func, arg_type, n) \
  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
  inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
    func(arg1, fmt::ArgList( \
      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
  }

// Emulates a variadic function returning void on a pre-C++11 compiler.
# define FMT_VARIADIC_VOID(func, arg_type) \
  inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
  FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
  FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
  FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
  FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
  FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)

# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
  ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
    func(arg0, arg1, fmt::ArgList( \
      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
  }

// Emulates a variadic constructor on a pre-C++11 compiler.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)
#endif

// Generates a comma-separated list with results of applying f to pairs
// (argument, index).
#define FMT_FOR_EACH1(f, x0) f(x0, 0)
#define FMT_FOR_EACH2(f, x0, x1) \
  FMT_FOR_EACH1(f, x0), f(x1, 1)
#define FMT_FOR_EACH3(f, x0, x1, x2) \
  FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)
#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \
  FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)
#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \
  FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)
#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \
  FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)
#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \
  FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)
#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \
  FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)
#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \
  FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)
#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \
  FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)

/**
 An error returned by an operating system or a language runtime,
 for example a file opening error.
*/
class SystemError : public internal::RuntimeError {
 private:
  FMT_API void init(int err_code, CStringRef format_str, ArgList args);

 protected:
  int error_code_;

  typedef char Char;  // For FMT_VARIADIC_CTOR.

  SystemError() {}

 public:
  /**
   \rst
   Constructs a :class:`fmt::SystemError` object with a description
   formatted with `fmt::format_system_error`. *message* and additional
   arguments passed into the constructor are formatted similarly to
   `fmt::format`.

   **Example**::

     // This throws a SystemError with the description
     //   cannot open file 'madeup': No such file or directory
     // or similar (system message may vary).
     const char *filename = "madeup";
     std::FILE *file = std::fopen(filename, "r");
     if (!file)
       throw fmt::SystemError(errno, "cannot open file '{}'", filename);
   \endrst
  */
  SystemError(int error_code, CStringRef message) {
    init(error_code, message, ArgList());
  }
  FMT_DEFAULTED_COPY_CTOR(SystemError)
  FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)

  FMT_API ~SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;

  int error_code() const { return error_code_; }
};

/**
  \rst
  Formats an error returned by an operating system or a language runtime,
  for example a file opening error, and writes it to *out* in the following
  form:

  .. parsed-literal::
     *<message>*: *<system-message>*

  where *<message>* is the passed message and *<system-message>* is
  the system message corresponding to the error code.
  *error_code* is a system error code as given by ``errno``.
  If *error_code* is not a valid error code such as -1, the system message
  may look like "Unknown error -1" and is platform-dependent.
  \endrst
 */
FMT_API void format_system_error(fmt::Writer &out, int error_code,
                                 fmt::StringRef message) FMT_NOEXCEPT;

/**
  \rst
  This template provides operations for formatting and writing data into
  a character stream. The output is stored in a buffer provided by a subclass
  such as :class:`fmt::BasicMemoryWriter`.

  You can use one of the following typedefs for common character types:

  +---------+----------------------+
  | Type    | Definition           |
  +=========+======================+
  | Writer  | BasicWriter<char>    |
  +---------+----------------------+
  | WWriter | BasicWriter<wchar_t> |
  +---------+----------------------+

  \endrst
 */
template <typename Char>
class BasicWriter {
 private:
  // Output buffer.
  Buffer<Char> &buffer_;

  FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);

  typedef typename internal::CharTraits<Char>::CharPtr CharPtr;

#if FMT_SECURE_SCL
  // Returns pointer value.
  static Char *get(CharPtr p) { return p.base(); }
#else
  static Char *get(Char *p) { return p; }
#endif

  // Fills the padding around the content and returns the pointer to the
  // content area.
  static CharPtr fill_padding(CharPtr buffer,
      unsigned total_size, std::size_t content_size, wchar_t fill);

  // Grows the buffer by n characters and returns a pointer to the newly
  // allocated area.
  CharPtr grow_buffer(std::size_t n) {
    std::size_t size = buffer_.size();
    buffer_.resize(size + n);
    return internal::make_ptr(&buffer_[size], n);
  }

  // Writes an unsigned decimal integer.
  template <typename UInt>
  Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) {
    unsigned num_digits = internal::count_digits(value);
    Char *ptr = get(grow_buffer(prefix_size + num_digits));
    internal::format_decimal(ptr + prefix_size, value, num_digits);
    return ptr;
  }

  // Writes a decimal integer.
  template <typename Int>
  void write_decimal(Int value) {
    typedef typename internal::IntTraits<Int>::MainType MainType;
    MainType abs_value = static_cast<MainType>(value);
    if (internal::is_negative(value)) {
      abs_value = 0 - abs_value;
      *write_unsigned_decimal(abs_value, 1) = '-';
    } else {
      write_unsigned_decimal(abs_value, 0);
    }
  }

  // Prepare a buffer for integer formatting.
  CharPtr prepare_int_buffer(unsigned num_digits,
      const EmptySpec &, const char *prefix, unsigned prefix_size) {
    unsigned size = prefix_size + num_digits;
    CharPtr p = grow_buffer(size);
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    return p + size - 1;
  }

  template <typename Spec>
  CharPtr prepare_int_buffer(unsigned num_digits,
    const Spec &spec, const char *prefix, unsigned prefix_size);

  // Formats an integer.
  template <typename T, typename Spec>
  void write_int(T value, Spec spec);

  // Formats a floating-point number (double or long double).
  template <typename T, typename Spec>
  void write_double(T value, const Spec &spec);

  // Writes a formatted string.
  template <typename StrChar>
  CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);

  template <typename StrChar, typename Spec>
  void write_str(const internal::Arg::StringValue<StrChar> &str,
                 const Spec &spec);

  // This following methods are private to disallow writing wide characters
  // and strings to a char stream. If you want to print a wide string as a
  // pointer as std::ostream does, cast it to const void*.
  // Do not implement!
  void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
  void operator<<(
      typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);

  // Appends floating-point length specifier to the format string.
  // The second argument is only used for overload resolution.
  void append_float_length(Char *&format_ptr, long double) {
    *format_ptr++ = 'L';
  }

  template<typename T>
  void append_float_length(Char *&, T) {}

  template <typename Impl, typename Char_, typename Spec_>
  friend class internal::ArgFormatterBase;

  template <typename Impl, typename Char_, typename Spec_>
  friend class BasicPrintfArgFormatter;

 protected:
  /**
    Constructs a ``BasicWriter`` object.
   */
  explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}

 public:
  /**
    \rst
    Destroys a ``BasicWriter`` object.
    \endrst
   */
  virtual ~BasicWriter() {}

  /**
    Returns the total number of characters written.
   */
  std::size_t size() const { return buffer_.size(); }

  /**
    Returns a pointer to the output buffer content. No terminating null
    character is appended.
   */
  const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; }

  /**
    Returns a pointer to the output buffer content with terminating null
    character appended.
   */
  const Char *c_str() const {
    std::size_t size = buffer_.size();
    buffer_.reserve(size + 1);
    buffer_[size] = '\0';
    return &buffer_[0];
  }

  /**
    \rst
    Returns the content of the output buffer as an `std::string`.
    \endrst
   */
  std::basic_string<Char> str() const {
    return std::basic_string<Char>(&buffer_[0], buffer_.size());
  }

  /**
    \rst
    Writes formatted data.

    *args* is an argument list representing arbitrary arguments.

    **Example**::

       MemoryWriter out;
       out.write("Current point:\n");
       out.write("({:+f}, {:+f})", -3.14, 3.14);

    This will write the following output to the ``out`` object:

    .. code-block:: none

       Current point:
       (-3.140000, +3.140000)

    The output can be accessed using :func:`data()`, :func:`c_str` or
    :func:`str` methods.

    See also :ref:`syntax`.
    \endrst
   */
  void write(BasicCStringRef<Char> format, ArgList args) {
    BasicFormatter<Char>(args, *this).format(format);
  }
  FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)

  BasicWriter &operator<<(int value) {
    write_decimal(value);
    return *this;
  }
  BasicWriter &operator<<(unsigned value) {
    return *this << IntFormatSpec<unsigned>(value);
  }
  BasicWriter &operator<<(long value) {
    write_decimal(value);
    return *this;
  }
  BasicWriter &operator<<(unsigned long value) {
    return *this << IntFormatSpec<unsigned long>(value);
  }
  BasicWriter &operator<<(LongLong value) {
    write_decimal(value);
    return *this;
  }

  /**
    \rst
    Formats *value* and writes it to the stream.
    \endrst
   */
  BasicWriter &operator<<(ULongLong value) {
    return *this << IntFormatSpec<ULongLong>(value);
  }

  BasicWriter &operator<<(double value) {
    write_double(value, FormatSpec());
    return *this;
  }

  /**
    \rst
    Formats *value* using the general format for floating-point numbers
    (``'g'``) and writes it to the stream.
    \endrst
   */
  BasicWriter &operator<<(long double value) {
    write_double(value, FormatSpec());
    return *this;
  }

  /**
    Writes a character to the stream.
   */
  BasicWriter &operator<<(char value) {
    buffer_.push_back(value);
    return *this;
  }

  BasicWriter &operator<<(
      typename internal::WCharHelper<wchar_t, Char>::Supported value) {
    buffer_.push_back(value);
    return *this;
  }

  /**
    \rst
    Writes *value* to the stream.
    \endrst
   */
  BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
    const Char *str = value.data();
    buffer_.append(str, str + value.size());
    return *this;
  }

  BasicWriter &operator<<(
      typename internal::WCharHelper<StringRef, Char>::Supported value) {
    const char *str = value.data();
    buffer_.append(str, str + value.size());
    return *this;
  }

  template <typename T, typename Spec, typename FillChar>
  BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
    internal::CharTraits<Char>::convert(FillChar());
    write_int(spec.value(), spec);
    return *this;
  }

  template <typename StrChar>
  BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
    const StrChar *s = spec.str();
    write_str(s, std::char_traits<Char>::length(s), spec);
    return *this;
  }

  void clear() FMT_NOEXCEPT { buffer_.clear(); }

  Buffer<Char> &buffer() FMT_NOEXCEPT { return buffer_; }
};

template <typename Char>
template <typename StrChar>
typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
      const StrChar *s, std::size_t size, const AlignSpec &spec) {
  CharPtr out = CharPtr();
  if (spec.width() > size) {
    out = grow_buffer(spec.width());
    Char fill = internal::CharTraits<Char>::cast(spec.fill());
    if (spec.align() == ALIGN_RIGHT) {
      std::uninitialized_fill_n(out, spec.width() - size, fill);
      out += spec.width() - size;
    } else if (spec.align() == ALIGN_CENTER) {
      out = fill_padding(out, spec.width(), size, fill);
    } else {
      std::uninitialized_fill_n(out + size, spec.width() - size, fill);
    }
  } else {
    out = grow_buffer(size);
  }
  std::uninitialized_copy(s, s + size, out);
  return out;
}

template <typename Char>
template <typename StrChar, typename Spec>
void BasicWriter<Char>::write_str(
    const internal::Arg::StringValue<StrChar> &s, const Spec &spec) {
  // Check if StrChar is convertible to Char.
  internal::CharTraits<Char>::convert(StrChar());
  if (spec.type_ && spec.type_ != 's')
    internal::report_unknown_type(spec.type_, "string");
  const StrChar *str_value = s.value;
  std::size_t str_size = s.size;
  if (str_size == 0) {
    if (!str_value) {
      FMT_THROW(FormatError("string pointer is null"));
    }
  }
  std::size_t precision = static_cast<std::size_t>(spec.precision_);
  if (spec.precision_ >= 0 && precision < str_size)
    str_size = precision;
  write_str(str_value, str_size, spec);
}

template <typename Char>
typename BasicWriter<Char>::CharPtr
  BasicWriter<Char>::fill_padding(
    CharPtr buffer, unsigned total_size,
    std::size_t content_size, wchar_t fill) {
  std::size_t padding = total_size - content_size;
  std::size_t left_padding = padding / 2;
  Char fill_char = internal::CharTraits<Char>::cast(fill);
  std::uninitialized_fill_n(buffer, left_padding, fill_char);
  buffer += left_padding;
  CharPtr content = buffer;
  std::uninitialized_fill_n(buffer + content_size,
                            padding - left_padding, fill_char);
  return content;
}

template <typename Char>
template <typename Spec>
typename BasicWriter<Char>::CharPtr
  BasicWriter<Char>::prepare_int_buffer(
    unsigned num_digits, const Spec &spec,
    const char *prefix, unsigned prefix_size) {
  unsigned width = spec.width();
  Alignment align = spec.align();
  Char fill = internal::CharTraits<Char>::cast(spec.fill());
  if (spec.precision() > static_cast<int>(num_digits)) {
    // Octal prefix '0' is counted as a digit, so ignore it if precision
    // is specified.
    if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
      --prefix_size;
    unsigned number_size =
        prefix_size + internal::to_unsigned(spec.precision());
    AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
    if (number_size >= width)
      return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
    buffer_.reserve(width);
    unsigned fill_size = width - number_size;
    if (align != ALIGN_LEFT) {
      CharPtr p = grow_buffer(fill_size);
      std::uninitialized_fill(p, p + fill_size, fill);
    }
    CharPtr result = prepare_int_buffer(
        num_digits, subspec, prefix, prefix_size);
    if (align == ALIGN_LEFT) {
      CharPtr p = grow_buffer(fill_size);
      std::uninitialized_fill(p, p + fill_size, fill);
    }
    return result;
  }
  unsigned size = prefix_size + num_digits;
  if (width <= size) {
    CharPtr p = grow_buffer(size);
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    return p + size - 1;
  }
  CharPtr p = grow_buffer(width);
  CharPtr end = p + width;
  if (align == ALIGN_LEFT) {
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    p += size;
    std::uninitialized_fill(p, end, fill);
  } else if (align == ALIGN_CENTER) {
    p = fill_padding(p, width, size, fill);
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    p += size;
  } else {
    if (align == ALIGN_NUMERIC) {
      if (prefix_size != 0) {
        p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
        size -= prefix_size;
      }
    } else {
      std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
    }
    std::uninitialized_fill(p, end - size, fill);
    p = end;
  }
  return p - 1;
}

template <typename Char>
template <typename T, typename Spec>
void BasicWriter<Char>::write_int(T value, Spec spec) {
  unsigned prefix_size = 0;
  typedef typename internal::IntTraits<T>::MainType UnsignedType;
  UnsignedType abs_value = static_cast<UnsignedType>(value);
  char prefix[4] = "";
  if (internal::is_negative(value)) {
    prefix[0] = '-';
    ++prefix_size;
    abs_value = 0 - abs_value;
  } else if (spec.flag(SIGN_FLAG)) {
    prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
    ++prefix_size;
  }
  switch (spec.type()) {
  case 0: case 'd': {
    unsigned num_digits = internal::count_digits(abs_value);
    CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
    internal::format_decimal(get(p), abs_value, 0);
    break;
  }
  case 'x': case 'X': {
    UnsignedType n = abs_value;
    if (spec.flag(HASH_FLAG)) {
      prefix[prefix_size++] = '0';
      prefix[prefix_size++] = spec.type_prefix();
    }
    unsigned num_digits = 0;
    do {
      ++num_digits;
    } while ((n >>= 4) != 0);
    Char *p = get(prepare_int_buffer(
      num_digits, spec, prefix, prefix_size));
    n = abs_value;
    const char *digits = spec.type() == 'x' ?
        "0123456789abcdef" : "0123456789ABCDEF";
    do {
      *p-- = digits[n & 0xf];
    } while ((n >>= 4) != 0);
    break;
  }
  case 'b': case 'B': {
    UnsignedType n = abs_value;
    if (spec.flag(HASH_FLAG)) {
      prefix[prefix_size++] = '0';
      prefix[prefix_size++] = spec.type_prefix();
    }
    unsigned num_digits = 0;
    do {
      ++num_digits;
    } while ((n >>= 1) != 0);
    Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
    n = abs_value;
    do {
      *p-- = static_cast<Char>('0' + (n & 1));
    } while ((n >>= 1) != 0);
    break;
  }
  case 'o': {
    UnsignedType n = abs_value;
    if (spec.flag(HASH_FLAG))
      prefix[prefix_size++] = '0';
    unsigned num_digits = 0;
    do {
      ++num_digits;
    } while ((n >>= 3) != 0);
    Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
    n = abs_value;
    do {
      *p-- = static_cast<Char>('0' + (n & 7));
    } while ((n >>= 3) != 0);
    break;
  }
  case 'n': {
    unsigned num_digits = internal::count_digits(abs_value);
    fmt::StringRef sep = "";
#if !(defined(ANDROID) || defined(__ANDROID__))
    sep = internal::thousands_sep(std::localeconv());
#endif
    unsigned size = static_cast<unsigned>(
          num_digits + sep.size() * ((num_digits - 1) / 3));
    CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
    internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep));
    break;
  }
  default:
    internal::report_unknown_type(
      spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
    break;
  }
}

template <typename Char>
template <typename T, typename Spec>
void BasicWriter<Char>::write_double(T value, const Spec &spec) {
  // Check type.
  char type = spec.type();
  bool upper = false;
  switch (type) {
  case 0:
    type = 'g';
    break;
  case 'e': case 'f': case 'g': case 'a':
    break;
  case 'F':
#if FMT_MSC_VER
    // MSVC's printf doesn't support 'F'.
    type = 'f';
#endif
    // Fall through.
  case 'E': case 'G': case 'A':
    upper = true;
    break;
  default:
    internal::report_unknown_type(type, "double");
    break;
  }

  char sign = 0;
  // Use isnegative instead of value < 0 because the latter is always
  // false for NaN.
  if (internal::FPUtil::isnegative(static_cast<double>(value))) {
    sign = '-';
    value = -value;
  } else if (spec.flag(SIGN_FLAG)) {
    sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
  }

  if (internal::FPUtil::isnotanumber(value)) {
    // Format NaN ourselves because sprintf's output is not consistent
    // across platforms.
    std::size_t nan_size = 4;
    const char *nan = upper ? " NAN" : " nan";
    if (!sign) {
      --nan_size;
      ++nan;
    }
    CharPtr out = write_str(nan, nan_size, spec);
    if (sign)
      *out = sign;
    return;
  }

  if (internal::FPUtil::isinfinity(value)) {
    // Format infinity ourselves because sprintf's output is not consistent
    // across platforms.
    std::size_t inf_size = 4;
    const char *inf = upper ? " INF" : " inf";
    if (!sign) {
      --inf_size;
      ++inf;
    }
    CharPtr out = write_str(inf, inf_size, spec);
    if (sign)
      *out = sign;
    return;
  }

  std::size_t offset = buffer_.size();
  unsigned width = spec.width();
  if (sign) {
    buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
    if (width > 0)
      --width;
    ++offset;
  }

  // Build format string.
  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
  Char format[MAX_FORMAT_SIZE];
  Char *format_ptr = format;
  *format_ptr++ = '%';
  unsigned width_for_sprintf = width;
  if (spec.flag(HASH_FLAG))
    *format_ptr++ = '#';
  if (spec.align() == ALIGN_CENTER) {
    width_for_sprintf = 0;
  } else {
    if (spec.align() == ALIGN_LEFT)
      *format_ptr++ = '-';
    if (width != 0)
      *format_ptr++ = '*';
  }
  if (spec.precision() >= 0) {
    *format_ptr++ = '.';
    *format_ptr++ = '*';
  }

  append_float_length(format_ptr, value);
  *format_ptr++ = type;
  *format_ptr = '\0';

  // Format using snprintf.
  Char fill = internal::CharTraits<Char>::cast(spec.fill());
  unsigned n = 0;
  Char *start = FMT_NULL;
  for (;;) {
    std::size_t buffer_size = buffer_.capacity() - offset;
#if FMT_MSC_VER
    // MSVC's vsnprintf_s doesn't work with zero size, so reserve
    // space for at least one extra character to make the size non-zero.
    // Note that the buffer's capacity will increase by more than 1.
    if (buffer_size == 0) {
      buffer_.reserve(offset + 1);
      buffer_size = buffer_.capacity() - offset;
    }
#endif
    start = &buffer_[offset];
    int result = internal::CharTraits<Char>::format_float(
        start, buffer_size, format, width_for_sprintf, spec.precision(), value);
    if (result >= 0) {
      n = internal::to_unsigned(result);
      if (offset + n < buffer_.capacity())
        break;  // The buffer is large enough - continue with formatting.
      buffer_.reserve(offset + n + 1);
    } else {
      // If result is negative we ask to increase the capacity by at least 1,
      // but as std::vector, the buffer grows exponentially.
      buffer_.reserve(buffer_.capacity() + 1);
    }
  }
  if (sign) {
    if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
        *start != ' ') {
      *(start - 1) = sign;
      sign = 0;
    } else {
      *(start - 1) = fill;
    }
    ++n;
  }
  if (spec.align() == ALIGN_CENTER && spec.width() > n) {
    width = spec.width();
    CharPtr p = grow_buffer(width);
    std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
    fill_padding(p, spec.width(), n, fill);
    return;
  }
  if (spec.fill() != ' ' || sign) {
    while (*start == ' ')
      *start++ = fill;
    if (sign)
      *(start - 1) = sign;
  }
  grow_buffer(n);
}

/**
  \rst
  This class template provides operations for formatting and writing data
  into a character stream. The output is stored in a memory buffer that grows
  dynamically.

  You can use one of the following typedefs for common character types
  and the standard allocator:

  +---------------+-----------------------------------------------------+
  | Type          | Definition                                          |
  +===============+=====================================================+
  | MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |
  +---------------+-----------------------------------------------------+
  | WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
  +---------------+-----------------------------------------------------+

  **Example**::

     MemoryWriter out;
     out << "The answer is " << 42 << "\n";
     out.write("({:+f}, {:+f})", -3.14, 3.14);

  This will write the following output to the ``out`` object:

  .. code-block:: none

     The answer is 42
     (-3.140000, +3.140000)

  The output can be converted to an ``std::string`` with ``out.str()`` or
  accessed as a C string with ``out.c_str()``.
  \endrst
 */
template <typename Char, typename Allocator = std::allocator<Char> >
class BasicMemoryWriter : public BasicWriter<Char> {
 private:
  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;

 public:
  explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
    : BasicWriter<Char>(buffer_), buffer_(alloc) {}

#if FMT_USE_RVALUE_REFERENCES
  /**
    \rst
    Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
    of the other object to it.
    \endrst
   */
  BasicMemoryWriter(BasicMemoryWriter &&other)
    : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
  }

  /**
    \rst
    Moves the content of the other ``BasicMemoryWriter`` object to this one.
    \endrst
   */
  BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
    buffer_ = std::move(other.buffer_);
    return *this;
  }
#endif
};

typedef BasicMemoryWriter<char> MemoryWriter;
typedef BasicMemoryWriter<wchar_t> WMemoryWriter;

/**
  \rst
  This class template provides operations for formatting and writing data
  into a fixed-size array. For writing into a dynamically growing buffer
  use :class:`fmt::BasicMemoryWriter`.

  Any write method will throw ``std::runtime_error`` if the output doesn't fit
  into the array.

  You can use one of the following typedefs for common character types:

  +--------------+---------------------------+
  | Type         | Definition                |
  +==============+===========================+
  | ArrayWriter  | BasicArrayWriter<char>    |
  +--------------+---------------------------+
  | WArrayWriter | BasicArrayWriter<wchar_t> |
  +--------------+---------------------------+
  \endrst
 */
template <typename Char>
class BasicArrayWriter : public BasicWriter<Char> {
 private:
  internal::FixedBuffer<Char> buffer_;

 public:
  /**
   \rst
   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
   given size.
   \endrst
   */
  BasicArrayWriter(Char *array, std::size_t size)
    : BasicWriter<Char>(buffer_), buffer_(array, size) {}

  /**
   \rst
   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
   size known at compile time.
   \endrst
   */
  template <std::size_t SIZE>
  explicit BasicArrayWriter(Char (&array)[SIZE])
    : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
};

typedef BasicArrayWriter<char> ArrayWriter;
typedef BasicArrayWriter<wchar_t> WArrayWriter;

// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_system_error(int error_code,
                                 StringRef message) FMT_NOEXCEPT;

#if FMT_USE_WINDOWS_H

/** A Windows error. */
class WindowsError : public SystemError {
 private:
  FMT_API void init(int error_code, CStringRef format_str, ArgList args);

 public:
  /**
   \rst
   Constructs a :class:`fmt::WindowsError` object with the description
   of the form

   .. parsed-literal::
     *<message>*: *<system-message>*

   where *<message>* is the formatted message and *<system-message>* is the
   system message corresponding to the error code.
   *error_code* is a Windows error code as given by ``GetLastError``.
   If *error_code* is not a valid error code such as -1, the system message
   will look like "error -1".

   **Example**::

     // This throws a WindowsError with the description
     //   cannot open file 'madeup': The system cannot find the file specified.
     // or similar (system message may vary).
     const char *filename = "madeup";
     LPOFSTRUCT of = LPOFSTRUCT();
     HFILE file = OpenFile(filename, &of, OF_READ);
     if (file == HFILE_ERROR) {
       throw fmt::WindowsError(GetLastError(),
                               "cannot open file '{}'", filename);
     }
   \endrst
  */
  WindowsError(int error_code, CStringRef message) {
    init(error_code, message, ArgList());
  }
  FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
};

// Reports a Windows error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_windows_error(int error_code,
                                  StringRef message) FMT_NOEXCEPT;

#endif

enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };

/**
  Formats a string and prints it to stdout using ANSI escape sequences
  to specify color (experimental).
  Example:
    print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
 */
FMT_API void print_colored(Color c, CStringRef format, ArgList args);

/**
  \rst
  Formats arguments and returns the result as a string.

  **Example**::

    std::string message = format("The answer is {}", 42);
  \endrst
*/
inline std::string format(CStringRef format_str, ArgList args) {
  MemoryWriter w;
  w.write(format_str, args);
  return w.str();
}

inline std::wstring format(WCStringRef format_str, ArgList args) {
  WMemoryWriter w;
  w.write(format_str, args);
  return w.str();
}

/**
  \rst
  Prints formatted data to the file *f*.

  **Example**::

    print(stderr, "Don't {}!", "panic");
  \endrst
 */
FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args);

/**
  \rst
  Prints formatted data to ``stdout``.

  **Example**::

    print("Elapsed time: {0:.2f} seconds", 1.23);
  \endrst
 */
FMT_API void print(CStringRef format_str, ArgList args);

/**
  Fast integer formatter.
 */
class FormatInt {
 private:
  // Buffer should be large enough to hold all digits (digits10 + 1),
  // a sign and a null character.
  enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
  mutable char buffer_[BUFFER_SIZE];
  char *str_;

  // Formats value in reverse and returns the number of digits.
  char *format_decimal(ULongLong value) {
    char *buffer_end = buffer_ + BUFFER_SIZE - 1;
    while (value >= 100) {
      // Integer division is slow so do it for a group of two digits instead
      // of for every digit. The idea comes from the talk by Alexandrescu
      // "Three Optimization Tips for C++". See speed-test for a comparison.
      unsigned index = static_cast<unsigned>((value % 100) * 2);
      value /= 100;
      *--buffer_end = internal::Data::DIGITS[index + 1];
      *--buffer_end = internal::Data::DIGITS[index];
    }
    if (value < 10) {
      *--buffer_end = static_cast<char>('0' + value);
      return buffer_end;
    }
    unsigned index = static_cast<unsigned>(value * 2);
    *--buffer_end = internal::Data::DIGITS[index + 1];
    *--buffer_end = internal::Data::DIGITS[index];
    return buffer_end;
  }

  void FormatSigned(LongLong value) {
    ULongLong abs_value = static_cast<ULongLong>(value);
    bool negative = value < 0;
    if (negative)
      abs_value = 0 - abs_value;
    str_ = format_decimal(abs_value);
    if (negative)
      *--str_ = '-';
  }

 public:
  explicit FormatInt(int value) { FormatSigned(value); }
  explicit FormatInt(long value) { FormatSigned(value); }
  explicit FormatInt(LongLong value) { FormatSigned(value); }
  explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
  explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
  explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}

  /** Returns the number of characters written to the output buffer. */
  std::size_t size() const {
    return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
  }

  /**
    Returns a pointer to the output buffer content. No terminating null
    character is appended.
   */
  const char *data() const { return str_; }

  /**
    Returns a pointer to the output buffer content with terminating null
    character appended.
   */
  const char *c_str() const {
    buffer_[BUFFER_SIZE - 1] = '\0';
    return str_;
  }

  /**
    \rst
    Returns the content of the output buffer as an ``std::string``.
    \endrst
   */
  std::string str() const { return std::string(str_, size()); }
};

// Formats a decimal integer value writing into buffer and returns
// a pointer to the end of the formatted string. This function doesn't
// write a terminating null character.
template <typename T>
inline void format_decimal(char *&buffer, T value) {
  typedef typename internal::IntTraits<T>::MainType MainType;
  MainType abs_value = static_cast<MainType>(value);
  if (internal::is_negative(value)) {
    *buffer++ = '-';
    abs_value = 0 - abs_value;
  }
  if (abs_value < 100) {
    if (abs_value < 10) {
      *buffer++ = static_cast<char>('0' + abs_value);
      return;
    }
    unsigned index = static_cast<unsigned>(abs_value * 2);
    *buffer++ = internal::Data::DIGITS[index];
    *buffer++ = internal::Data::DIGITS[index + 1];
    return;
  }
  unsigned num_digits = internal::count_digits(abs_value);
  internal::format_decimal(buffer, abs_value, num_digits);
  buffer += num_digits;
}

/**
  \rst
  Returns a named argument for formatting functions.

  **Example**::

    print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));

  \endrst
 */
template <typename T>
inline internal::NamedArgWithType<char, T> arg(StringRef name, const T &arg) {
  return internal::NamedArgWithType<char, T>(name, arg);
}

template <typename T>
inline internal::NamedArgWithType<wchar_t, T> arg(WStringRef name, const T &arg) {
  return internal::NamedArgWithType<wchar_t, T>(name, arg);
}

// The following two functions are deleted intentionally to disable
// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.
template <typename Char>
void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
template <typename Char>
void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
}

#if FMT_GCC_VERSION
// Use the system_header pragma to suppress warnings about variadic macros
// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't
// work. It is used at the end because we want to suppress as little warnings
// as possible.
# pragma GCC system_header
#endif

// This is used to work around VC++ bugs in handling variadic macros.
#define FMT_EXPAND(args) args

// Returns the number of arguments.
// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s.
#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

#define FMT_FOR_EACH_(N, f, ...) \
  FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))
#define FMT_FOR_EACH(f, ...) \
  FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))

#define FMT_ADD_ARG_NAME(type, index) type arg##index
#define FMT_GET_ARG_NAME(type, index) arg##index

#if FMT_USE_VARIADIC_TEMPLATES
# define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \
  template <typename... Args> \
  ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
      const Args & ... args) Const { \
    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
    typename ArgArray::Type array{ \
      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
      fmt::ArgList(fmt::internal::make_type(args...), array)); \
  }
#else
// Defines a wrapper for a function taking __VA_ARGS__ arguments
// and n additional arguments of arbitrary types.
# define FMT_WRAP(Const, Char, ReturnType, func, call, n, ...) \
  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
      FMT_GEN(n, FMT_MAKE_ARG)) Const { \
    fmt::internal::ArgArray<n>::Type arr; \
    FMT_GEN(n, FMT_ASSIGN_##Char); \
    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
  }

# define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \
  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) Const { \
    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
  } \
  FMT_WRAP(Const, Char, ReturnType, func, call, 1, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 2, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 3, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 4, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 5, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 6, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 7, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 8, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 9, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 10, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 11, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 12, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 13, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 14, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 15, __VA_ARGS__)
#endif  // FMT_USE_VARIADIC_TEMPLATES

/**
  \rst
  Defines a variadic function with the specified return type, function name
  and argument types passed as variable arguments to this macro.

  **Example**::

    void print_error(const char *file, int line, const char *format,
                     fmt::ArgList args) {
      fmt::print("{}: {}: ", file, line);
      fmt::print(format, args);
    }
    FMT_VARIADIC(void, print_error, const char *, int, const char *)

  ``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
  don't implement variadic templates. You don't have to use this macro if
  you don't need legacy compiler support and can use variadic templates
  directly::

    template <typename... Args>
    void print_error(const char *file, int line, const char *format,
                     const Args & ... args) {
      fmt::print("{}: {}: ", file, line);
      fmt::print(format, args...);
    }
  \endrst
 */
#define FMT_VARIADIC(ReturnType, func, ...) \
  FMT_VARIADIC_(, char, ReturnType, func, return func, __VA_ARGS__)

#define FMT_VARIADIC_CONST(ReturnType, func, ...) \
  FMT_VARIADIC_(const, char, ReturnType, func, return func, __VA_ARGS__)

#define FMT_VARIADIC_W(ReturnType, func, ...) \
  FMT_VARIADIC_(, wchar_t, ReturnType, func, return func, __VA_ARGS__)

#define FMT_VARIADIC_CONST_W(ReturnType, func, ...) \
  FMT_VARIADIC_(const, wchar_t, ReturnType, func, return func, __VA_ARGS__)

#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)

#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)

/**
  \rst
  Convenient macro to capture the arguments' names and values into several
  ``fmt::arg(name, value)``.

  **Example**::

    int x = 1, y = 2;
    print("point: ({x}, {y})", FMT_CAPTURE(x, y));
    // same as:
    // print("point: ({x}, {y})", arg("x", x), arg("y", y));

  \endrst
 */
#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)

#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)

namespace fmt {
FMT_VARIADIC(std::string, format, CStringRef)
FMT_VARIADIC_W(std::wstring, format, WCStringRef)
FMT_VARIADIC(void, print, CStringRef)
FMT_VARIADIC(void, print, std::FILE *, CStringRef)
FMT_VARIADIC(void, print_colored, Color, CStringRef)

namespace internal {
template <typename Char>
inline bool is_name_start(Char c) {
  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
}

// Parses an unsigned integer advancing s to the end of the parsed input.
// This function assumes that the first character of s is a digit.
template <typename Char>
unsigned parse_nonnegative_int(const Char *&s) {
  assert('0' <= *s && *s <= '9');
  unsigned value = 0;
  // Convert to unsigned to prevent a warning.
  unsigned max_int = (std::numeric_limits<int>::max)();
  unsigned big = max_int / 10;
  do {
    // Check for overflow.
    if (value > big) {
      value = max_int + 1;
      break;
    }
    value = value * 10 + (*s - '0');
    ++s;
  } while ('0' <= *s && *s <= '9');
  // Convert to unsigned to prevent a warning.
  if (value > max_int)
    FMT_THROW(FormatError("number is too big"));
  return value;
}

inline void require_numeric_argument(const Arg &arg, char spec) {
  if (arg.type > Arg::LAST_NUMERIC_TYPE) {
    std::string message =
        fmt::format("format specifier '{}' requires numeric argument", spec);
    FMT_THROW(fmt::FormatError(message));
  }
}

template <typename Char>
void check_sign(const Char *&s, const Arg &arg) {
  char sign = static_cast<char>(*s);
  require_numeric_argument(arg, sign);
  if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
    FMT_THROW(FormatError(fmt::format(
      "format specifier '{}' requires signed argument", sign)));
  }
  ++s;
}
}  // namespace internal

template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::get_arg(
    BasicStringRef<Char> arg_name, const char *&error) {
  if (check_no_auto_index(error)) {
    map_.init(args());
    const internal::Arg *arg = map_.find(arg_name);
    if (arg)
      return *arg;
    error = "argument not found";
  }
  return internal::Arg();
}

template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s) {
  const char *error = FMT_NULL;
  internal::Arg arg = *s < '0' || *s > '9' ?
        next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
  if (error) {
    FMT_THROW(FormatError(
                *s != '}' && *s != ':' ? "invalid format string" : error));
  }
  return arg;
}

template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s) {
  assert(internal::is_name_start(*s));
  const Char *start = s;
  Char c;
  do {
    c = *++s;
  } while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
  const char *error = FMT_NULL;
  internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
  if (error)
    FMT_THROW(FormatError(error));
  return arg;
}

template <typename Char, typename ArgFormatter>
const Char *BasicFormatter<Char, ArgFormatter>::format(
    const Char *&format_str, const internal::Arg &arg) {
  using internal::Arg;
  const Char *s = format_str;
  typename ArgFormatter::SpecType spec;
  if (*s == ':') {
    if (arg.type == Arg::CUSTOM) {
      arg.custom.format(this, arg.custom.value, &s);
      return s;
    }
    ++s;
    // Parse fill and alignment.
    if (Char c = *s) {
      const Char *p = s + 1;
      spec.align_ = ALIGN_DEFAULT;
      do {
        switch (*p) {
          case '<':
            spec.align_ = ALIGN_LEFT;
            break;
          case '>':
            spec.align_ = ALIGN_RIGHT;
            break;
          case '=':
            spec.align_ = ALIGN_NUMERIC;
            break;
          case '^':
            spec.align_ = ALIGN_CENTER;
            break;
        }
        if (spec.align_ != ALIGN_DEFAULT) {
          if (p != s) {
            if (c == '}') break;
            if (c == '{')
              FMT_THROW(FormatError("invalid fill character '{'"));
            s += 2;
            spec.fill_ = c;
          } else ++s;
          if (spec.align_ == ALIGN_NUMERIC)
            require_numeric_argument(arg, '=');
          break;
        }
      } while (--p >= s);
    }

    // Parse sign.
    switch (*s) {
      case '+':
        check_sign(s, arg);
        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
        break;
      case '-':
        check_sign(s, arg);
        spec.flags_ |= MINUS_FLAG;
        break;
      case ' ':
        check_sign(s, arg);
        spec.flags_ |= SIGN_FLAG;
        break;
    }

    if (*s == '#') {
      require_numeric_argument(arg, '#');
      spec.flags_ |= HASH_FLAG;
      ++s;
    }

    // Parse zero flag.
    if (*s == '0') {
      require_numeric_argument(arg, '0');
      spec.align_ = ALIGN_NUMERIC;
      spec.fill_ = '0';
      ++s;
    }

    // Parse width.
    if ('0' <= *s && *s <= '9') {
      spec.width_ = internal::parse_nonnegative_int(s);
    } else if (*s == '{') {
      ++s;
      Arg width_arg = internal::is_name_start(*s) ?
            parse_arg_name(s) : parse_arg_index(s);
      if (*s++ != '}')
        FMT_THROW(FormatError("invalid format string"));
      ULongLong value = 0;
      switch (width_arg.type) {
      case Arg::INT:
        if (width_arg.int_value < 0)
          FMT_THROW(FormatError("negative width"));
        value = width_arg.int_value;
        break;
      case Arg::UINT:
        value = width_arg.uint_value;
        break;
      case Arg::LONG_LONG:
        if (width_arg.long_long_value < 0)
          FMT_THROW(FormatError("negative width"));
        value = width_arg.long_long_value;
        break;
      case Arg::ULONG_LONG:
        value = width_arg.ulong_long_value;
        break;
      default:
        FMT_THROW(FormatError("width is not integer"));
      }
      unsigned max_int = (std::numeric_limits<int>::max)();
      if (value > max_int)
        FMT_THROW(FormatError("number is too big"));
      spec.width_ = static_cast<int>(value);
    }

    // Parse precision.
    if (*s == '.') {
      ++s;
      spec.precision_ = 0;
      if ('0' <= *s && *s <= '9') {
        spec.precision_ = internal::parse_nonnegative_int(s);
      } else if (*s == '{') {
        ++s;
        Arg precision_arg = internal::is_name_start(*s) ?
              parse_arg_name(s) : parse_arg_index(s);
        if (*s++ != '}')
          FMT_THROW(FormatError("invalid format string"));
        ULongLong value = 0;
        switch (precision_arg.type) {
          case Arg::INT:
            if (precision_arg.int_value < 0)
              FMT_THROW(FormatError("negative precision"));
            value = precision_arg.int_value;
            break;
          case Arg::UINT:
            value = precision_arg.uint_value;
            break;
          case Arg::LONG_LONG:
            if (precision_arg.long_long_value < 0)
              FMT_THROW(FormatError("negative precision"));
            value = precision_arg.long_long_value;
            break;
          case Arg::ULONG_LONG:
            value = precision_arg.ulong_long_value;
            break;
          default:
            FMT_THROW(FormatError("precision is not integer"));
        }
        unsigned max_int = (std::numeric_limits<int>::max)();
        if (value > max_int)
          FMT_THROW(FormatError("number is too big"));
        spec.precision_ = static_cast<int>(value);
      } else {
        FMT_THROW(FormatError("missing precision specifier"));
      }
      if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
        FMT_THROW(FormatError(
            fmt::format("precision not allowed in {} format specifier",
            arg.type == Arg::POINTER ? "pointer" : "integer")));
      }
    }

    // Parse type.
    if (*s != '}' && *s)
      spec.type_ = static_cast<char>(*s++);
  }

  if (*s++ != '}')
    FMT_THROW(FormatError("missing '}' in format string"));

  // Format argument.
  ArgFormatter(*this, spec, s - 1).visit(arg);
  return s;
}

template <typename Char, typename AF>
void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
  const Char *s = format_str.c_str();
  const Char *start = s;
  while (*s) {
    Char c = *s++;
    if (c != '{' && c != '}') continue;
    if (*s == c) {
      write(writer_, start, s);
      start = ++s;
      continue;
    }
    if (c == '}')
      FMT_THROW(FormatError("unmatched '}' in format string"));
    write(writer_, start, s - 1);
    internal::Arg arg = internal::is_name_start(*s) ?
          parse_arg_name(s) : parse_arg_index(s);
    start = s = format(s, arg);
  }
  write(writer_, start, s);
}

template <typename Char, typename It>
struct ArgJoin {
  It first;
  It last;
  BasicCStringRef<Char> sep;

  ArgJoin(It first, It last, const BasicCStringRef<Char>& sep) :
    first(first),
    last(last),
    sep(sep) {}
};

template <typename It>
ArgJoin<char, It> join(It first, It last, const BasicCStringRef<char>& sep) {
  return ArgJoin<char, It>(first, last, sep);
}

template <typename It>
ArgJoin<wchar_t, It> join(It first, It last, const BasicCStringRef<wchar_t>& sep) {
  return ArgJoin<wchar_t, It>(first, last, sep);
}

#if FMT_HAS_GXX_CXX11
template <typename Range>
auto join(const Range& range, const BasicCStringRef<char>& sep)
    -> ArgJoin<char, decltype(std::begin(range))> {
  return join(std::begin(range), std::end(range), sep);
}

template <typename Range>
auto join(const Range& range, const BasicCStringRef<wchar_t>& sep)
    -> ArgJoin<wchar_t, decltype(std::begin(range))> {
  return join(std::begin(range), std::end(range), sep);
}
#endif

template <typename ArgFormatter, typename Char, typename It>
void format_arg(fmt::BasicFormatter<Char, ArgFormatter> &f,
    const Char *&format_str, const ArgJoin<Char, It>& e) {
  const Char* end = format_str;
  if (*end == ':')
    ++end;
  while (*end && *end != '}')
    ++end;
  if (*end != '}')
    FMT_THROW(FormatError("missing '}' in format string"));

  It it = e.first;
  if (it != e.last) {
    const Char* save = format_str;
    f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
    while (it != e.last) {
      f.writer().write(e.sep);
      format_str = save;
      f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
    }
  }
  format_str = end + 1;
}
}  // namespace fmt

#if FMT_USE_USER_DEFINED_LITERALS
namespace fmt {
namespace internal {

template <typename Char>
struct UdlFormat {
  const Char *str;

  template <typename... Args>
  auto operator()(Args && ... args) const
                  -> decltype(format(str, std::forward<Args>(args)...)) {
    return format(str, std::forward<Args>(args)...);
  }
};

template <typename Char>
struct UdlArg {
  const Char *str;

  template <typename T>
  NamedArgWithType<Char, T> operator=(T &&value) const {
    return {str, std::forward<T>(value)};
  }
};

} // namespace internal

inline namespace literals {

/**
  \rst
  C++11 literal equivalent of :func:`fmt::format`.

  **Example**::

    using namespace fmt::literals;
    std::string message = "The answer is {}"_format(42);
  \endrst
 */
inline internal::UdlFormat<char>
operator"" _format(const char *s, std::size_t) { return {s}; }
inline internal::UdlFormat<wchar_t>
operator"" _format(const wchar_t *s, std::size_t) { return {s}; }

/**
  \rst
  C++11 literal equivalent of :func:`fmt::arg`.

  **Example**::

    using namespace fmt::literals;
    print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
  \endrst
 */
inline internal::UdlArg<char>
operator"" _a(const char *s, std::size_t) { return {s}; }
inline internal::UdlArg<wchar_t>
operator"" _a(const wchar_t *s, std::size_t) { return {s}; }

} // inline namespace literals
} // namespace fmt
#endif // FMT_USE_USER_DEFINED_LITERALS

// Restore warnings.
#if FMT_GCC_VERSION >= 406
# pragma GCC diagnostic pop
#endif

#if defined(__clang__) && !defined(FMT_ICC_VERSION)
# pragma clang diagnostic pop
#endif

#ifdef FMT_HEADER_ONLY
# define FMT_FUNC inline
# include "format.cc"
#else
# define FMT_FUNC
#endif

#endif  // FMT_FORMAT_H_


================================================
FILE: lib/fmt/fmt_ostream.cpp
================================================
/*
 Formatting library for C++ - std::ostream support

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#include "fmt_ostream.h"

namespace fmt {

namespace internal {
FMT_FUNC void write(std::ostream &os, Writer &w) {
  const char *data = w.data();
  typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
  UnsignedStreamSize size = w.size();
  UnsignedStreamSize max_size =
      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
  do {
    UnsignedStreamSize n = size <= max_size ? size : max_size;
    os.write(data, static_cast<std::streamsize>(n));
    data += n;
    size -= n;
  } while (size != 0);
}
}

FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) {
  MemoryWriter w;
  w.write(format_str, args);
  internal::write(os, w);
}
}  // namespace fmt


================================================
FILE: lib/fmt/fmt_ostream.h
================================================
/*
 Formatting library for C++ - std::ostream support

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_OSTREAM_H_
#define FMT_OSTREAM_H_

#include "fmt_format.h"
#include <ostream>

namespace fmt {

namespace internal {

template <class Char>
class FormatBuf : public std::basic_streambuf<Char> {
 private:
  typedef typename std::basic_streambuf<Char>::int_type int_type;
  typedef typename std::basic_streambuf<Char>::traits_type traits_type;

  Buffer<Char> &buffer_;

 public:
  FormatBuf(Buffer<Char> &buffer) : buffer_(buffer) {}

 protected:
  // The put-area is actually always empty. This makes the implementation
  // simpler and has the advantage that the streambuf and the buffer are always
  // in sync and sputc never writes into uninitialized memory. The obvious
  // disadvantage is that each call to sputc always results in a (virtual) call
  // to overflow. There is no disadvantage here for sputn since this always
  // results in a call to xsputn.

  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
    if (!traits_type::eq_int_type(ch, traits_type::eof()))
      buffer_.push_back(static_cast<Char>(ch));
    return ch;
  }

  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
    buffer_.append(s, s + count);
    return count;
  }
};

Yes &convert(std::ostream &);

struct DummyStream : std::ostream {
  DummyStream();  // Suppress a bogus warning in MSVC.

  // Hide all operator<< overloads from std::ostream.
  template <typename T>
  typename EnableIf<sizeof(T) == 0>::type operator<<(const T &);
};

No &operator<<(std::ostream &, int);

template <typename T>
struct ConvertToIntImpl<T, true> {
  // Convert to int only if T doesn't have an overloaded operator<<.
  enum {
    value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
  };
};

// Write the content of w to os.
FMT_API void write(std::ostream &os, Writer &w);
}  // namespace internal

// Formats a value.
template <typename Char, typename ArgFormatter_, typename T>
void format_arg(BasicFormatter<Char, ArgFormatter_> &f,
                const Char *&format_str, const T &value) {
  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;

  internal::FormatBuf<Char> format_buf(buffer);
  std::basic_ostream<Char> output(&format_buf);
  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
  output << value;

  BasicStringRef<Char> str(&buffer[0], buffer.size());
  typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
  format_str = f.format(format_str, MakeArg(str));
}

/**
  \rst
  Prints formatted data to the stream *os*.

  **Example**::

    print(cerr, "Don't {}!", "panic");
  \endrst
 */
FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
FMT_VARIADIC(void, print, std::ostream &, CStringRef)
}  // namespace fmt

#ifdef FMT_HEADER_ONLY
# include "ostream.cc"
#endif

#endif  // FMT_OSTREAM_H_


================================================
FILE: lib/fmt/fmt_posix.cpp
================================================
/*
 A C++ interface to POSIX functions.

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

// Disable bogus MSVC warnings.
#ifndef _CRT_SECURE_NO_WARNINGS
# define _CRT_SECURE_NO_WARNINGS
#endif

#include "fmt_posix.h"

#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>

#ifndef _WIN32
# include <unistd.h>
#else
# ifndef WIN32_LEAN_AND_MEAN
#  define WIN32_LEAN_AND_MEAN
# endif
# include <windows.h>
# include <io.h>

# define O_CREAT _O_CREAT
# define O_TRUNC _O_TRUNC

# ifndef S_IRUSR
#  define S_IRUSR _S_IREAD
# endif

# ifndef S_IWUSR
#  define S_IWUSR _S_IWRITE
# endif

# ifdef __MINGW32__
#  define _SH_DENYNO 0x40
# endif

#endif  // _WIN32

#ifdef fileno
# undef fileno
#endif

namespace {
#ifdef _WIN32
// Return type of read and write functions.
typedef int RWResult;

// On Windows the count argument to read and write is unsigned, so convert
// it from size_t preventing integer overflow.
inline unsigned convert_rwcount(std::size_t count) {
  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
}
#else
// Return type of read and write functions.
typedef ssize_t RWResult;

inline std::size_t convert_rwcount(std::size_t count) { return count; }
#endif
}

fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT {
  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
    fmt::report_system_error(errno, "cannot close file");
}

fmt::BufferedFile::BufferedFile(
    fmt::CStringRef filename, fmt::CStringRef mode) {
  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 0);
  if (!file_)
    FMT_THROW(SystemError(errno, "cannot open file {}", filename));
}

void fmt::BufferedFile::close() {
  if (!file_)
    return;
  int result = FMT_SYSTEM(fclose(file_));
  file_ = FMT_NULL;
  if (result != 0)
    FMT_THROW(SystemError(errno, "cannot close file"));
}

// A macro used to prevent expansion of fileno on broken versions of MinGW.
#define FMT_ARGS

int fmt::BufferedFile::fileno() const {
  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
  if (fd == -1)
    FMT_THROW(SystemError(errno, "cannot get file descriptor"));
  return fd;
}

fmt::File::File(fmt::CStringRef path, int oflag) {
  int mode = S_IRUSR | S_IWUSR;
#if defined(_WIN32) && !defined(__MINGW32__)
  fd_ = -1;
  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
#else
  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
#endif
  if (fd_ == -1)
    FMT_THROW(SystemError(errno, "cannot open file {}", path));
}

fmt::File::~File() FMT_NOEXCEPT {
  // Don't retry close in case of EINTR!
  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
    fmt::report_system_error(errno, "cannot close file");
}

void fmt::File::close() {
  if (fd_ == -1)
    return;
  // Don't retry close in case of EINTR!
  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
  int result = FMT_POSIX_CALL(close(fd_));
  fd_ = -1;
  if (result != 0)
    FMT_THROW(SystemError(errno, "cannot close file"));
}

fmt::LongLong fmt::File::size() const {
#ifdef _WIN32
  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
  // is less than 0x0500 as is the case with some default MinGW builds.
  // Both functions support large file sizes.
  DWORD size_upper = 0;
  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
  if (size_lower == INVALID_FILE_SIZE) {
    DWORD error = GetLastError();
    if (error != NO_ERROR)
      FMT_THROW(WindowsError(GetLastError(), "cannot get file size"));
  }
  fmt::ULongLong long_size = size_upper;
  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
#else
  typedef struct stat Stat;
  Stat file_stat = Stat();
  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
    FMT_THROW(SystemError(errno, "cannot get file attributes"));
  FMT_STATIC_ASSERT(sizeof(fmt::LongLong) >= sizeof(file_stat.st_size),
      "return type of File::size is not large enough");
  return file_stat.st_size;
#endif
}

std::size_t fmt::File::read(void *buffer, std::size_t count) {
  RWResult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
  if (result < 0)
    FMT_THROW(SystemError(errno, "cannot read from file"));
  return internal::to_unsigned(result);
}

std::size_t fmt::File::write(const void *buffer, std::size_t count) {
  RWResult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
  if (result < 0)
    FMT_THROW(SystemError(errno, "cannot write to file"));
  return internal::to_unsigned(result);
}

fmt::File fmt::File::dup(int fd) {
  // Don't retry as dup doesn't return EINTR.
  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
  int new_fd = FMT_POSIX_CALL(dup(fd));
  if (new_fd == -1)
    FMT_THROW(SystemError(errno, "cannot duplicate file descriptor {}", fd));
  return File(new_fd);
}

void fmt::File::dup2(int fd) {
  int result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
  if (result == -1) {
    FMT_THROW(SystemError(errno,
      "cannot duplicate file descriptor {} to {}", fd_, fd));
  }
}

void fmt::File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT {
  int result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
  if (result == -1)
    ec = ErrorCode(errno);
}

void fmt::File::pipe(File &read_end, File &write_end) {
  // Close the descriptors first to make sure that assignments don't throw
  // and there are no leaks.
  read_end.close();
  write_end.close();
  int fds[2] = {};
#ifdef _WIN32
  // Make the default pipe capacity same as on Linux 2.6.11+.
  enum { DEFAULT_CAPACITY = 65536 };
  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
#else
  // Don't retry as the pipe function doesn't return EINTR.
  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
  int result = FMT_POSIX_CALL(pipe(fds));
#endif
  if (result != 0)
    FMT_THROW(SystemError(errno, "cannot create pipe"));
  // The following assignments don't throw because read_fd and write_fd
  // are closed.
  read_end = File(fds[0]);
  write_end = File(fds[1]);
}

fmt::BufferedFile fmt::File::fdopen(const char *mode) {
  // Don't retry as fdopen doesn't return EINTR.
  FILE *f = FMT_POSIX_CALL(fdopen(fd_, mode));
  if (!f)
    FMT_THROW(SystemError(errno, "cannot associate stream with file descriptor"));
  BufferedFile file(f);
  fd_ = -1;
  return file;
}

long fmt::getpagesize() {
#ifdef _WIN32
  SYSTEM_INFO si;
  GetSystemInfo(&si);
  return si.dwPageSize;
#else
  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
  if (size < 0)
    FMT_THROW(SystemError(errno, "cannot get memory page size"));
  return size;
#endif
}


================================================
FILE: lib/fmt/fmt_posix.h
================================================
/*
 A C++ interface to POSIX functions.

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_POSIX_H_
#define FMT_POSIX_H_

#if defined(__MINGW32__) || defined(__CYGWIN__)
// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
# undef __STRICT_ANSI__
#endif

#include <errno.h>
#include <fcntl.h>   // for O_RDONLY
#include <locale.h>  // for locale_t
#include <stdio.h>
#include <stdlib.h>  // for strtod_l

#include <cstddef>

#if defined(VITA)
// Under certain circumstances, this function cannot be found on PS Vita.
// Seems to only happen on a CI build.
// extern double strtod_l(const char* _a, const char ** _b, locale_t c);
#endif

#if defined __APPLE__ || defined(__FreeBSD__)
# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
#endif

#include "fmt_format.h"

#ifndef FMT_POSIX
# if defined(_WIN32) && !defined(__MINGW32__)
// Fix warnings about deprecated symbols.
#  define FMT_POSIX(call) _##call
# else
#  define FMT_POSIX(call) call
# endif
#endif

// Calls to system functions are wrapped in FMT_SYSTEM for testability.
#ifdef FMT_SYSTEM
# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#else
# define FMT_SYSTEM(call) call
# ifdef _WIN32
// Fix warnings about deprecated symbols.
#  define FMT_POSIX_CALL(call) ::_##call
# else
#  define FMT_POSIX_CALL(call) ::call
# endif
#endif

// Retries the expression while it evaluates to error_result and errno
// equals to EINTR.
#ifndef _WIN32
# define FMT_RETRY_VAL(result, expression, error_result) \
  do { \
    result = (expression); \
  } while (result == error_result && errno == EINTR)
#else
# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
#endif

#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)

namespace fmt {

// An error code.
class ErrorCode {
 private:
  int value_;

 public:
  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}

  int get() const FMT_NOEXCEPT { return value_; }
};

// A buffered file.
class BufferedFile {
 private:
  FILE *file_;

  friend class File;

  explicit BufferedFile(FILE *f) : file_(f) {}

 public:
  // Constructs a BufferedFile object which doesn't represent any file.
  BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {}

  // Destroys the object closing the file it represents if any.
  FMT_API ~BufferedFile() FMT_NOEXCEPT;

#if !FMT_USE_RVALUE_REFERENCES
  // Emulate a move constructor and a move assignment operator if rvalue
  // references are not supported.

 private:
  // A proxy object to emulate a move constructor.
  // It is private to make it impossible call operator Proxy directly.
  struct Proxy {
    FILE *file;
  };

public:
  // A "move constructor" for moving from a temporary.
  BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {}

  // A "move constructor" for moving from an lvalue.
  BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) {
    f.file_ = FMT_NULL;
  }

  // A "move assignment operator" for moving from a temporary.
  BufferedFile &operator=(Proxy p) {
    close();
    file_ = p.file;
    return *this;
  }

  // A "move assignment operator" for moving from an lvalue.
  BufferedFile &operator=(BufferedFile &other) {
    close();
    file_ = other.file_;
    other.file_ = FMT_NULL;
    return *this;
  }

  // Returns a proxy object for moving from a temporary:
  //   BufferedFile file = BufferedFile(...);
  operator Proxy() FMT_NOEXCEPT {
    Proxy p = {file_};
    file_ = FMT_NULL;
    return p;
  }

#else
 private:
  FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);

 public:
  BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) {
    other.file_ = FMT_NULL;
  }

  BufferedFile& operator=(BufferedFile &&other) {
    close();
    file_ = other.file_;
    other.file_ = FMT_NULL;
    return *this;
  }
#endif

  // Opens a file.
  FMT_API BufferedFile(CStringRef filename, CStringRef mode);

  // Closes the file.
  FMT_API void close();

  // Returns the pointer to a FILE object representing this file.
  FILE *get() const FMT_NOEXCEPT { return file_; }

  // We place parentheses around fileno to workaround a bug in some versions
  // of MinGW that define fileno as a macro.
  FMT_API int (fileno)() const;

  void print(CStringRef format_str, const ArgList &args) {
    fmt::print(file_, format_str, args);
  }
  FMT_VARIADIC(void, print, CStringRef)
};

// A file. Closed file is represented by a File object with descriptor -1.
// Methods that are not declared with FMT_NOEXCEPT may throw
// fmt::SystemError in case of failure. Note that some errors such as
// closing the file multiple times will cause a crash on Windows rather
// than an exception. You can get standard behavior by overriding the
// invalid parameter handler with _set_invalid_parameter_handler.
class File {
 private:
  int fd_;  // File descriptor.

  // Constructs a File object with a given descriptor.
  explicit File(int fd) : fd_(fd) {}

 public:
  // Possible values for the oflag argument to the constructor.
  enum {
    RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
    WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
    RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
  };

  // Constructs a File object which doesn't represent any file.
  File() FMT_NOEXCEPT : fd_(-1) {}

  // Opens a file and constructs a File object representing this file.
  FMT_API File(CStringRef path, int oflag);

#if !FMT_USE_RVALUE_REFERENCES
  // Emulate a move constructor and a move assignment operator if rvalue
  // references are not supported.

 private:
  // A proxy object to emulate a move constructor.
  // It is private to make it impossible call operator Proxy directly.
  struct Proxy {
    int fd;
  };

 public:
  // A "move constructor" for moving from a temporary.
  File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}

  // A "move constructor" for moving from an lvalue.
  File(File &other) FMT_NOEXCEPT : fd_(other.fd_) {
    other.fd_ = -1;
  }

  // A "move assignment operator" for moving from a temporary.
  File &operator=(Proxy p) {
    close();
    fd_ = p.fd;
    return *this;
  }

  // A "move assignment operator" for moving from an lvalue.
  File &operator=(File &other) {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
    return *this;
  }

  // Returns a proxy object for moving from a temporary:
  //   File file = File(...);
  operator Proxy() FMT_NOEXCEPT {
    Proxy p = {fd_};
    fd_ = -1;
    return p;
  }

#else
 private:
  FMT_DISALLOW_COPY_AND_ASSIGN(File);

 public:
  File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) {
    other.fd_ = -1;
  }

  File& operator=(File &&other) {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
    return *this;
  }
#endif

  // Destroys the object closing the file it represents if any.
  FMT_API ~File() FMT_NOEXCEPT;

  // Returns the file descriptor.
  int descriptor() const FMT_NOEXCEPT { return fd_; }

  // Closes the file.
  FMT_API void close();

  // Returns the file size. The size has signed type for consistency with
  // stat::st_size.
  FMT_API LongLong size() const;

  // Attempts to read count bytes from the file into the specified buffer.
  FMT_API std::size_t read(void *buffer, std::size_t count);

  // Attempts to write count bytes from the specified buffer to the file.
  FMT_API std::size_t write(const void *buffer, std::size_t count);

  // Duplicates a file descriptor with the dup function and returns
  // the duplicate as a file object.
  FMT_API static File dup(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
  FMT_API void dup2(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
  FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;

  // Creates a pipe setting up read_end and write_end file objects for reading
  // and writing respectively.
  FMT_API static void pipe(File &read_end, File &write_end);

  // Creates a BufferedFile object associated with this file and detaches
  // this File object from the file.
  FMT_API BufferedFile fdopen(const char *mode);
};

// Returns the memory page size.
long getpagesize();

#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
    !defined(__ANDROID__) && !defined(__CYGWIN__) && \
    !defined(VITA) && \
    !defined(__HAIKU__) && \
    !defined(__SWITCH__) && !defined(__3DS__) && !defined(__WII__) && !defined(__WIIU__) && \
    !defined(PGE_MIN_PORT)
# define FMT_LOCALE
#endif


#ifdef FMT_LOCALE

// A "C" numeric locale.
class Locale {
 private:
# ifdef _MSC_VER
  typedef _locale_t locale_t;

  enum { LC_NUMERIC_MASK = LC_NUMERIC };

  static locale_t newlocale(int category_mask, const char *locale, locale_t) {
    return _create_locale(category_mask, locale);
  }

  static void freelocale(locale_t locale) {
    _free_locale(locale);
  }

  static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
    return _strtod_l(nptr, endptr, locale);
  }
# endif

  locale_t locale_;

  FMT_DISALLOW_COPY_AND_ASSIGN(Locale);

 public:
  typedef locale_t Type;

  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
    if (!locale_)
      FMT_THROW(fmt::SystemError(errno, "cannot create locale"));
  }
  ~Locale() { freelocale(locale_); }

  Type get() const { return locale_; }

  // Converts string to floating-point number and advances str past the end
  // of the parsed input.
  double strtod(const char *&str) const {
    char *end = FMT_NULL;

    double result = strtod_l(str, &end, locale_);
    str = end;
    return result;
  }
};
#endif  // FMT_LOCALE
}  // namespace fmt

#if !FMT_USE_RVALUE_REFERENCES
namespace std {
// For compatibility with C++98.
inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; }
inline fmt::File &move(fmt::File &f) { return f; }
}
#endif

#endif  // FMT_POSIX_H_


================================================
FILE: lib/fmt/fmt_printf.cpp
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#include "fmt_format.h"
#include "fmt_printf.h"

namespace fmt {

template <typename Char>
void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args);

FMT_FUNC int fprintf(std::FILE *f, CStringRef format, ArgList args) {
  MemoryWriter w;
  printf(w, format, args);
  std::size_t size = w.size();
  return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
}

#ifndef FMT_HEADER_ONLY

template void PrintfFormatter<char>::format(CStringRef format);
template void PrintfFormatter<wchar_t>::format(WCStringRef format);

#endif  // FMT_HEADER_ONLY

}  // namespace fmt


================================================
FILE: lib/fmt/fmt_printf.h
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_PRINTF_H_
#define FMT_PRINTF_H_

#include <algorithm>  // std::fill_n
#include <limits>     // std::numeric_limits

#include "fmt_ostream.h"

namespace fmt {
namespace internal {

// Checks if a value fits in int - used to avoid warnings about comparing
// signed and unsigned integers.
template <bool IsSigned>
struct IntChecker {
  template <typename T>
  static bool fits_in_int(T value) {
    unsigned max = std::numeric_limits<int>::max();
    return value <= max;
  }
  static bool fits_in_int(bool) { return true; }
};

template <>
struct IntChecker<true> {
  template <typename T>
  static bool fits_in_int(T value) {
    return value >= std::numeric_limits<int>::min() &&
           value <= std::numeric_limits<int>::max();
  }
  static bool fits_in_int(int) { return true; }
};

class PrecisionHandler : public ArgVisitor<PrecisionHandler, int> {
 public:
  void report_unhandled_arg() {
    FMT_THROW(FormatError("precision is not integer"));
  }

  template <typename T>
  int visit_any_int(T value) {
    if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
      FMT_THROW(FormatError("number is too big"));
    return static_cast<int>(value);
  }
};

// IsZeroInt::visit(arg) returns true iff arg is a zero integer.
class IsZeroInt : public ArgVisitor<IsZeroInt, bool> {
 public:
  template <typename T>
  bool visit_any_int(T value) { return value == 0; }
};

// returns the default type for format specific "%s"
class DefaultType : public ArgVisitor<DefaultType, char> {
 public:
  char visit_char(int) { return 'c'; }

  char visit_bool(bool) { return 's'; }

  char visit_pointer(const void *) { return 'p'; }

  template <typename T>
  char visit_any_int(T) { return 'd'; }

  template <typename T>
  char visit_any_double(T) { return 'g'; }

  char visit_unhandled_arg() { return 's'; }
};

template <typename T, typename U>
struct is_same {
  enum { value = 0 };
};

template <typename T>
struct is_same<T, T> {
  enum { value = 1 };
};

// An argument visitor that converts an integer argument to T for printf,
// if T is an integral type. If T is void, the argument is converted to
// corresponding signed or unsigned type depending on the type specifier:
// 'd' and 'i' - signed, other - unsigned)
template <typename T = void>
class ArgConverter : public ArgVisitor<ArgConverter<T>, void> {
 private:
  internal::Arg &arg_;
  wchar_t type_;

  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);

 public:
  ArgConverter(internal::Arg &arg, wchar_t type)
    : arg_(arg), type_(type) {}

  void visit_bool(bool value) {
    if (type_ != 's')
      visit_any_int(value);
  }

  void visit_char(int value) {
    if (type_ != 's')
      visit_any_int(value);
  }

  template <typename U>
  void visit_any_int(U value) {
    bool is_signed = type_ == 'd' || type_ == 'i';
    if (type_ == 's') {
      is_signed = std::numeric_limits<U>::is_signed;
    }

    using internal::Arg;
    typedef typename internal::Conditional<
        is_same<T, void>::value, U, T>::type TargetType;
    if (const_check(sizeof(TargetType) <= sizeof(int))) {
      // Extra casts are used to silence warnings.
      if (is_signed) {
        arg_.type = Arg::INT;
        arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
      } else {
        arg_.type = Arg::UINT;
        typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
        arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
      }
    } else {
      if (is_signed) {
        arg_.type = Arg::LONG_LONG;
        // glibc's printf doesn't sign extend arguments of smaller types:
        //   std::printf("%lld", -42);  // prints "4294967254"
        // but we don't have to do the same because it's a UB.
        arg_.long_long_value = static_cast<LongLong>(value);
      } else {
        arg_.type = Arg::ULONG_LONG;
        arg_.ulong_long_value =
            static_cast<typename internal::MakeUnsigned<U>::Type>(value);
      }
    }
  }
};

// Converts an integer argument to char for printf.
class CharConverter : public ArgVisitor<CharConverter, void> {
 private:
  internal::Arg &arg_;

  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);

 public:
  explicit CharConverter(internal::Arg &arg) : arg_(arg) {}

  template <typename T>
  void visit_any_int(T value) {
    arg_.type = internal::Arg::CHAR;
    arg_.int_value = static_cast<char>(value);
  }
};

// Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative.
class WidthHandler : public ArgVisitor<WidthHandler, unsigned> {
 private:
  FormatSpec &spec_;

  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);

 public:
  explicit WidthHandler(FormatSpec &spec) : spec_(spec) {}

  void report_unhandled_arg() {
    FMT_THROW(FormatError("width is not integer"));
  }

  template <typename T>
  unsigned visit_any_int(T value) {
    typedef typename internal::IntTraits<T>::MainType UnsignedType;
    UnsignedType width = static_cast<UnsignedType>(value);
    if (internal::is_negative(value)) {
      spec_.align_ = ALIGN_LEFT;
      width = 0 - width;
    }
    unsigned int_max = std::numeric_limits<int>::max();
    if (width > int_max)
      FMT_THROW(FormatError("number is too big"));
    return static_cast<unsigned>(width);
  }
};
}  // namespace internal

/**
  \rst
  A ``printf`` argument formatter based on the `curiously recurring template
  pattern <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.

  To use `~fmt::BasicPrintfArgFormatter` define a subclass that implements some
  or all of the visit methods with the same signatures as the methods in
  `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`.
  Pass the subclass as the *Impl* template parameter. When a formatting
  function processes an argument, it will dispatch to a visit method
  specific to the argument type. For example, if the argument type is
  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
  will be called. If the subclass doesn't contain a method with this signature,
  then a corresponding method of `~fmt::BasicPrintfArgFormatter` or its
  superclass will be called.
  \endrst
 */
template <typename Impl, typename Char, typename Spec>
class BasicPrintfArgFormatter :
    public internal::ArgFormatterBase<Impl, Char, Spec> {
 private:
  void write_null_pointer() {
    this->spec().type_ = 0;
    this->write("(nil)");
  }

  typedef internal::ArgFormatterBase<Impl, Char, Spec> Base;

 public:
  /**
    \rst
    Constructs an argument formatter object.
    *writer* is a reference to the output writer and *spec* contains format
    specifier information for standard argument types.
    \endrst
   */
  BasicPrintfArgFormatter(BasicWriter<Char> &w, Spec &s)
  : internal::ArgFormatterBase<Impl, Char, Spec>(w, s) {}

  /** Formats an argument of type ``bool``. */
  void visit_bool(bool value) {
    Spec &fmt_spec = this->spec();
    if (fmt_spec.type_ != 's')
      return this->visit_any_int(value);
    fmt_spec.type_ = 0;
    this->write(value);
  }

  /** Formats a character. */
  void visit_char(int value) {
    const Spec &fmt_spec = this->spec();
    BasicWriter<Char> &w = this->writer();
    if (fmt_spec.type_ && fmt_spec.type_ != 'c')
      w.write_int(value, fmt_spec);
    typedef typename BasicWriter<Char>::CharPtr CharPtr;
    CharPtr out = CharPtr();
    if (fmt_spec.width_ > 1) {
      Char fill = ' ';
      out = w.grow_buffer(fmt_spec.width_);
      if (fmt_spec.align_ != ALIGN_LEFT) {
        std::fill_n(out, fmt_spec.width_ - 1, fill);
        out += fmt_spec.width_ - 1;
      } else {
        std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
      }
    } else {
      out = w.grow_buffer(1);
    }
    *out = static_cast<Char>(value);
  }

  /** Formats a null-terminated C string. */
  void visit_cstring(const char *value) {
    if (value)
      Base::visit_cstring(value);
    else if (this->spec().type_ == 'p')
      write_null_pointer();
    else
      this->write("(null)");
  }

  /** Formats a pointer. */
  void visit_pointer(const void *value) {
    if (value)
      return Base::visit_pointer(value);
    this->spec().type_ = 0;
    write_null_pointer();
  }

  /** Formats an argument of a custom (user-defined) type. */
  void visit_custom(internal::Arg::CustomValue c) {
    BasicFormatter<Char> formatter(ArgList(), this->writer());
    const Char format_str[] = {'}', 0};
    const Char *format = format_str;
    c.format(&formatter, c.value, &format);
  }
};

/** The default printf argument formatter. */
template <typename Char>
class PrintfArgFormatter :
    public BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec> {
 public:
  /** Constructs an argument formatter object. */
  PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
  : BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec>(w, s) {}
};

/** This template formats data and writes the output to a writer. */
template <typename Char, typename ArgFormatter = PrintfArgFormatter<Char> >
class PrintfFormatter : private internal::FormatterBase {
 private:
  BasicWriter<Char> &writer_;

  void parse_flags(FormatSpec &spec, const Char *&s);

  // Returns the argument with specified index or, if arg_index is equal
  // to the maximum unsigned value, the next argument.
  internal::Arg get_arg(
      const Char *s,
      unsigned arg_index = (std::numeric_limits<unsigned>::max)());

  // Parses argument index, flags and width and returns the argument index.
  unsigned parse_header(const Char *&s, FormatSpec &spec);

 public:
  /**
   \rst
   Constructs a ``PrintfFormatter`` object. References to the arguments and
   the writer are stored in the formatter object so make sure they have
   appropriate lifetimes.
   \endrst
   */
  explicit PrintfFormatter(const ArgList &al, BasicWriter<Char> &w)
    : FormatterBase(al), writer_(w) {}

  /** Formats stored arguments and writes the output to the writer. */
  void format(BasicCStringRef<Char> format_str);
};

template <typename Char, typename AF>
void PrintfFormatter<Char, AF>::parse_flags(FormatSpec &spec, const Char *&s) {
  for (;;) {
    switch (*s++) {
      case '-':
        spec.align_ = ALIGN_LEFT;
        break;
      case '+':
        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
        break;
      case '0':
        spec.fill_ = '0';
        break;
      case ' ':
        spec.flags_ |= SIGN_FLAG;
        break;
      case '#':
        spec.flags_ |= HASH_FLAG;
        break;
      default:
        --s;
        return;
    }
  }
}

template <typename Char, typename AF>
internal::Arg PrintfFormatter<Char, AF>::get_arg(const Char *s,
                                                 unsigned arg_index) {
  (void)s;
  const char *error = FMT_NULL;
  internal::Arg arg = arg_index == std::numeric_limits<unsigned>::max() ?
    next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
  if (error)
    FMT_THROW(FormatError(!*s ? "invalid format string" : error));
  return arg;
}

template <typename Char, typename AF>
unsigned PrintfFormatter<Char, AF>::parse_header(
  const Char *&s, FormatSpec &spec) {
  unsigned arg_index = std::numeric_limits<unsigned>::max();
  Char c = *s;
  if (c >= '0' && c <= '9') {
    // Parse an argument index (if followed by '$') or a width possibly
    // preceded with '0' flag(s).
    unsigned value = internal::parse_nonnegative_int(s);
    if (*s == '$') {  // value is an argument index
      ++s;
      arg_index = value;
    } else {
      if (c == '0')
        spec.fill_ = '0';
      if (value != 0) {
        // Nonzero value means that we parsed width and don't need to
        // parse it or flags again, so return now.
        spec.width_ = value;
        return arg_index;
      }
    }
  }
  parse_flags(spec, s);
  // Parse width.
  if (*s >= '0' && *s <= '9') {
    spec.width_ = internal::parse_nonnegative_int(s);
  } else if (*s == '*') {
    ++s;
    spec.width_ = internal::WidthHandler(spec).visit(get_arg(s));
  }
  return arg_index;
}

template <typename Char, typename AF>
void PrintfFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
  const Char *start = format_str.c_str();
  const Char *s = start;
  while (*s) {
    Char c = *s++;
    if (c != '%') continue;
    if (*s == c) {
      write(writer_, start, s);
      start = ++s;
      continue;
    }
    write(writer_, start, s - 1);

    FormatSpec spec;
    spec.align_ = ALIGN_RIGHT;

    // Parse argument index, flags and width.
    unsigned arg_index = parse_header(s, spec);

    // Parse precision.
    if (*s == '.') {
      ++s;
      if ('0' <= *s && *s <= '9') {
        spec.precision_ = static_cast<int>(internal::parse_nonnegative_int(s));
      } else if (*s == '*') {
        ++s;
        spec.precision_ = internal::PrecisionHandler().visit(get_arg(s));
      } else {
        spec.precision_ = 0;
      }
    }

    using internal::Arg;
    Arg arg = get_arg(s, arg_index);
    if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg))
      spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
    if (spec.fill_ == '0') {
      if (arg.type <= Arg::LAST_NUMERIC_TYPE)
        spec.align_ = ALIGN_NUMERIC;
      else
        spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
    }

    // Parse length and convert the argument to the required type.
    using internal::ArgConverter;
    switch (*s++) {
    case 'h':
      if (*s == 'h')
        ArgConverter<signed char>(arg, *++s).visit(arg);
      else
        ArgConverter<short>(arg, *s).visit(arg);
      break;
    case 'l':
      if (*s == 'l')
        ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
      else
        ArgConverter<long>(arg, *s).visit(arg);
      break;
    case 'j':
      ArgConverter<intmax_t>(arg, *s).visit(arg);
      break;
    case 'z':
      ArgConverter<std::size_t>(arg, *s).visit(arg);
      break;
    case 't':
      ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
      break;
    case 'L':
      // printf produces garbage when 'L' is omitted for long double, no
      // need to do the same.
      break;
    default:
      --s;
      ArgConverter<void>(arg, *s).visit(arg);
    }

    // Parse type.
    if (!*s)
      FMT_THROW(FormatError("invalid format string"));
    spec.type_ = static_cast<char>(*s++);

    if (spec.type_ == 's') {
      // set the format type to the default if 's' is specified
      spec.type_ = internal::DefaultType().visit(arg);
    }

    if (arg.type <= Arg::LAST_INTEGER_TYPE) {
      // Normalize type.
      switch (spec.type_) {
      case 'i': case 'u':
        spec.type_ = 'd';
        break;
      case 'c':
        // TODO: handle wchar_t
        internal::CharConverter(arg).visit(arg);
        break;
      }
    }

    start = s;

    // Format argument.
    AF(writer_, spec).visit(arg);
  }
  write(writer_, start, s);
}

inline void printf(Writer &w, CStringRef format, ArgList args) {
  PrintfFormatter<char>(args, w).format(format);
}
FMT_VARIADIC(void, printf, Writer &, CStringRef)

inline void printf(WWriter &w, WCStringRef format, ArgList args) {
  PrintfFormatter<wchar_t>(args, w).format(format);
}
FMT_VARIADIC(void, printf, WWriter &, WCStringRef)

/**
  \rst
  Formats arguments and returns the result as a string.

  **Example**::

    std::string message = fmt::sprintf("The answer is %d", 42);
  \endrst
*/
inline std::string sprintf(CStringRef format, ArgList args) {
  MemoryWriter w;
  printf(w, format, args);
  return w.str();
}
FMT_VARIADIC(std::string, sprintf, CStringRef)

inline std::wstring sprintf(WCStringRef format, ArgList args) {
  WMemoryWriter w;
  printf(w, format, args);
  return w.str();
}
FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)

/**
  \rst
  Prints formatted data to the file *f*.

  **Example**::

    fmt::fprintf(stderr, "Don't %s!", "panic");
  \endrst
 */
FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args);
FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)

/**
  \rst
  Prints formatted data to ``stdout``.

  **Example**::

    fmt::printf("Elapsed time: %.2f seconds", 1.23);
  \endrst
 */
inline int printf(CStringRef format, ArgList args) {
  return fprintf(stdout, format, args);
}
FMT_VARIADIC(int, printf, CStringRef)

/**
  \rst
  Prints formatted data to the stream *os*.

  **Example**::

    fprintf(cerr, "Don't %s!", "panic");
  \endrst
 */
inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) {
  MemoryWriter w;
  printf(w, format_str, args);
  internal::write(os, w);
  return static_cast<int>(w.size());
}
FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
}  // namespace fmt

#ifdef FMT_HEADER_ONLY
# include "printf.cc"
#endif

#endif  // FMT_PRINTF_H_


================================================
FILE: lib/fmt/fmt_qformat.h
================================================
/*
    A small wrapper from QString's %1....%99 arguments into fmt::format arguments
*/

#ifndef FMT_QFORMAT_H
#define FMT_QFORMAT_H

#include "fmt_format.h"

namespace fmt
{

inline uint32_t getNum(char* &c)
{
    char numbuff[3] = {0, 0, 0};
    size_t len = 0;
    uint32_t num = 0;
    while((len < 2) && isdigit(*c) && *c != '\0')
        numbuff[len++] = *(c++);
    if(len == 1)
        num = uint32_t(numbuff[0] - '0');
    else if(len == 2)
        num = uint32_t(numbuff[0] - '0') + uint32_t(numbuff[1] - '0') * 10;
    return num;
}

template <typename... Args>
std::string qformat(CStringRef format_str, const Args & ... args)
{
    std::string fmt(format_str.c_str());

    for(size_t i = fmt.size() - 1; true; i--)
    {
        if(fmt[i] == '%')
        {
            char* c = &fmt[i + 1];
            uint32_t num = getNum(c);
            if(c == &fmt[i + 1])
                continue;
            if(num == 0)
                continue;
            num--;
            fmt.erase(i, size_t(c - &fmt[i - 1]));
            fmt.insert(i, "{" + std::to_string(num) + "}");
        }
        if(i == 0)
            break;
    }

    std::string out;
    try
    {
        out = format(fmt, std::forward<const Args&>(args)...);
    }
    catch(const FormatError &e)
    {
        out.append(e.what());
        out.append(" [");
        out.append(fmt);
        out.push_back(']');
    }
    return out;
}

}
#endif // FMT_QFORMAT_H


================================================
FILE: lib/fmt/fmt_string.h
================================================
/*
 Formatting library for C++ - string utilities

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifdef FMT_INCLUDE
# error "Add the fmt's parent directory and not fmt itself to includes."
#endif

#ifndef FMT_STRING_H_
#define FMT_STRING_H_

#include "fmt_format.h"

namespace fmt {

namespace internal {

// A buffer that stores data in ``std::basic_string``.
template <typename Char, typename Allocator = std::allocator<Char> >
class StringBuffer : public Buffer<Char> {
 public:
  typedef std::basic_string<Char, std::char_traits<Char>, Allocator> StringType;

 private:
  StringType data_;

 protected:
  virtual void grow(std::size_t size) FMT_OVERRIDE {
    data_.resize(size);
    this->ptr_ = &data_[0];
    this->capacity_ = size;
  }

 public:
  explicit StringBuffer(const Allocator &allocator = Allocator())
  : data_(allocator) {}

  // Moves the data to ``str`` clearing the buffer.
  void move_to(StringType &str) {
    data_.resize(this->size_);
    str.swap(data_);
    this->capacity_ = this->size_ = 0;
    this->ptr_ = FMT_NULL;
  }
};
}  // namespace internal

/**
  \rst
  This class template provides operations for formatting and writing data
  into a character stream. The output is stored in a ``std::basic_string``
  that grows dynamically.

  You can use one of the following typedefs for common character types
  and the standard allocator:

  +---------------+----------------------------+
  | Type          | Definition                 |
  +===============+============================+
  | StringWriter  | BasicStringWriter<char>    |
  +---------------+----------------------------+
  | WStringWriter | BasicStringWriter<wchar_t> |
  +---------------+----------------------------+

  **Example**::

     StringWriter out;
     out << "The answer is " << 42 << "\n";

  This will write the following output to the ``out`` object:

  .. code-block:: none

     The answer is 42

  The output can be moved to a ``std::basic_string`` with ``out.move_to()``.
  \endrst
 */
template <typename Char, typename Allocator = std::allocator<Char> >
class BasicStringWriter : public BasicWriter<Char> {
 private:
  internal::StringBuffer<Char, Allocator> buffer_;

 public:
  /**
    \rst
    Constructs a :class:`fmt::BasicStringWriter` object.
    \endrst
   */
  explicit BasicStringWriter(const Allocator &allocator = Allocator())
  : BasicWriter<Char>(buffer_), buffer_(allocator) {}

  /**
    \rst
    Moves the buffer content to *str* clearing the buffer.
    \endrst
   */
  void move_to(std::basic_string<Char, std::char_traits<Char>, Allocator> &str) {
    buffer_.move_to(str);
  }
};

typedef BasicStringWriter<char> StringWriter;
typedef BasicStringWriter<wchar_t> WStringWriter;

/**
  \rst
  Converts *value* to ``std::string`` using the default format for type *T*.

  **Example**::

    #include "fmt/string.h"

    std::string answer = fmt::to_string(42);
  \endrst
 */
template <typename T>
std::string to_string(const T &value) {
  fmt::MemoryWriter w;
  w << value;
  return w.str();
}

/**
  \rst
  Converts *value* to ``std::wstring`` using the default format for type *T*.

  **Example**::

    #include "fmt/string.h"

    std::wstring answer = fmt::to_wstring(42);
  \endrst
 */
template <typename T>
std::wstring to_wstring(const T &value) {
  fmt::WMemoryWriter w;
  w << value;
  return w.str();
}
}

#endif  // FMT_STRING_H_


================================================
FILE: lib/fmt/fmt_time.h
================================================
/*
 Formatting library for C++ - time formatting

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_TIME_H_
#define FMT_TIME_H_

#include "fmt_format.h"
#include <ctime>

#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4702)  // unreachable code
# pragma warning(disable: 4996)  // "deprecated" functions
#endif

namespace fmt {
template <typename ArgFormatter>
void format_arg(BasicFormatter<char, ArgFormatter> &f,
                const char *&format_str, const std::tm &tm) {
  if (*format_str == ':')
    ++format_str;
  const char *end = format_str;
  while (*end && *end != '}')
    ++end;
  if (*end != '}')
    FMT_THROW(FormatError("missing '}' in format string"));
  internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
  format.append(format_str, end + 1);
  format[format.size() - 1] = '\0';
  Buffer<char> &buffer = f.writer().buffer();
  std::size_t start = buffer.size();
  for (;;) {
    std::size_t size = buffer.capacity() - start;
    std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
    if (count != 0) {
      buffer.resize(start + count);
      break;
    }
    if (size >= format.size() * 256) {
      // If the buffer is 256 times larger than the format string, assume
      // that `strftime` gives an empty result. There doesn't seem to be a
      // better way to distinguish the two cases:
      // https://github.com/fmtlib/fmt/issues/367
      break;
    }
    const std::size_t MIN_GROWTH = 10;
    buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
  }
  format_str = end + 1;
}

namespace internal{
inline Null<> localtime_r(...) { return Null<>(); }
inline Null<> localtime_s(...) { return Null<>(); }
inline Null<> gmtime_r(...) { return Null<>(); }
inline Null<> gmtime_s(...) { return Null<>(); }
}

// Thread-safe replacement for std::localtime
inline std::tm localtime(std::time_t time) {
  struct LocalTime {
    std::time_t time_;
    std::tm tm_;

    LocalTime(std::time_t t): time_(t) {}

    bool run() {
      using namespace fmt::internal;
      return handle(localtime_r(&time_, &tm_));
    }

    bool handle(std::tm *tm) { return tm != FMT_NULL; }

    bool handle(internal::Null<>) {
      using namespace fmt::internal;
      return fallback(localtime_s(&tm_, &time_));
    }

    bool fallback(int res) { return res == 0; }

    bool fallback(internal::Null<>) {
      using namespace fmt::internal;
      std::tm *tm = std::localtime(&time_);
      if (tm) tm_ = *tm;
      return tm != FMT_NULL;
    }
  };
  LocalTime lt(time);
  if (lt.run())
    return lt.tm_;
  // Too big time values may be unsupported.
  FMT_THROW(fmt::FormatError("time_t value out of range"));
  return std::tm();
}

// Thread-safe replacement for std::gmtime
inline std::tm gmtime(std::time_t time) {
  struct GMTime {
    std::time_t time_;
    std::tm tm_;

    GMTime(std::time_t t): time_(t) {}

    bool run() {
      using namespace fmt::internal;
      return handle(gmtime_r(&time_, &tm_));
    }

    bool handle(std::tm *tm) { return tm != FMT_NULL; }

    bool handle(internal::Null<>) {
      using namespace fmt::internal;
      return fallback(gmtime_s(&tm_, &time_));
    }

    bool fallback(int res) { return res == 0; }

    bool fallback(internal::Null<>) {
      std::tm *tm = std::gmtime(&time_);
      if (tm != FMT_NULL) tm_ = *tm;
      return tm != FMT_NULL;
    }
  };
  GMTime gt(time);
  if (gt.run())
    return gt.tm_;
  // Too big time values may be unsupported.
  FMT_THROW(fmt::FormatError("time_t value out of range"));
  return std::tm();
}
} //namespace fmt

#ifdef _MSC_VER
# pragma warning(pop)
#endif

#endif  // FMT_TIME_H_


================================================
FILE: lib/fmt/orig/CMakeLists.txt
================================================
# Define the fmt library, its includes and the needed defines.
# *.cc are added to FMT_HEADERS for the header-only configuration.
set(FMT_HEADERS container.h format.h format.cc ostream.h ostream.cc printf.h
                printf.cc string.h time.h)
if (HAVE_OPEN)
  set(FMT_HEADERS ${FMT_HEADERS} posix.h)
  set(FMT_SOURCES ${FMT_SOURCES} posix.cc)
endif ()

add_library(fmt ${FMT_SOURCES} ${FMT_HEADERS} ../README.rst ../ChangeLog.rst)
add_library(fmt::fmt ALIAS fmt)

# Starting with cmake 3.1 the CXX_STANDARD property can be used instead.
# Note: Don't make -std=c++11 public or interface, since it breaks projects
# that use C++14.
target_compile_options(fmt PRIVATE ${CPP11_FLAG})
if (FMT_PEDANTIC)
  target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
endif ()

target_include_directories(fmt PUBLIC
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
  $<INSTALL_INTERFACE:include>)

set_target_properties(fmt PROPERTIES
  VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR})

if (BUILD_SHARED_LIBS)
  if (UNIX AND NOT APPLE)
    # Fix rpmlint warning:
    # unused-direct-shlib-dependency /usr/lib/libformat.so.1.1.0 /lib/libm.so.6.
    target_link_libraries(fmt -Wl,--as-needed)
  endif ()
  target_compile_definitions(fmt PRIVATE FMT_EXPORT INTERFACE FMT_SHARED)
endif ()

#------------------------------------------------------------------------------
# additionally define a header only library when cmake is new enough
if (CMAKE_VERSION VERSION_GREATER 3.1.0 OR CMAKE_VERSION VERSION_EQUAL 3.1.0)
  add_library(fmt-header-only INTERFACE)
  add_library(fmt::fmt-header-only ALIAS fmt-header-only)

  target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)

  target_include_directories(fmt-header-only INTERFACE
    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
    $<INSTALL_INTERFACE:include>)
endif ()

# Install targets.
if (FMT_INSTALL)
  include(GNUInstallDirs)
  include(CMakePackageConfigHelpers)
  set(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
    "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.")
  set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
  set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
  set(targets_export_name fmt-targets)

  set (INSTALL_TARGETS fmt)
  if (TARGET fmt-header-only)
    set(INSTALL_TARGETS ${INSTALL_TARGETS} fmt-header-only)
  endif ()

  set(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
    "Installation directory for libraries, relative to ${CMAKE_INSTALL_PREFIX}.")

  set(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR}/fmt CACHE STRING
    "Installation directory for include files, relative to ${CMAKE_INSTALL_PREFIX}.")

  # Generate the version, config and target files into the build directory.
  write_basic_package_version_file(
    ${version_config}
    VERSION ${FMT_VERSION}
    COMPATIBILITY AnyNewerVersion)
  configure_package_config_file(
    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
    ${project_config}
    INSTALL_DESTINATION ${FMT_CMAKE_DIR})
  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)

  # Install version, config and target files.
  install(
    FILES ${project_config} ${version_config}
    DESTINATION ${FMT_CMAKE_DIR})
  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
    NAMESPACE fmt::)

  # Install the library and headers.
  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
          DESTINATION ${FMT_LIB_DIR})
  install(FILES ${FMT_HEADERS} DESTINATION ${FMT_INC_DIR})
endif ()


================================================
FILE: lib/fmt/orig/container.h
================================================
/*
 Formatting library for C++ - standard container utilities

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_CONTAINER_H_
#define FMT_CONTAINER_H_

#include "format.h"

namespace fmt {

namespace internal {

/**
  \rst
  A "buffer" that appends data to a standard container (e.g. typically a
  ``std::vector`` or ``std::basic_string``).
  \endrst
 */
template <typename Container>
class ContainerBuffer : public Buffer<typename Container::value_type> {
 private:
  Container& container_;

 protected:
  virtual void grow(std::size_t size) FMT_OVERRIDE {
    container_.resize(size);
    this->ptr_ = &container_[0];
    this->capacity_ = size;
  }

 public:
  explicit ContainerBuffer(Container& container) : container_(container) {
    this->size_ = container_.size();
    if (this->size_ > 0) {
      this->ptr_ = &container_[0];
      this->capacity_ = this->size_;
    }
  }
};
}  // namespace internal

/**
  \rst
  This class template provides operations for formatting and appending data
  to a standard *container* like ``std::vector`` or ``std::basic_string``.

  **Example**::

    void vecformat(std::vector<char>& dest, fmt::BasicCStringRef<char> format,
                   fmt::ArgList args) {
      fmt::BasicContainerWriter<std::vector<char> > appender(dest);
      appender.write(format, args);
    }
    FMT_VARIADIC(void, vecformat, std::vector<char>&,
                 fmt::BasicCStringRef<char>);
  \endrst
 */
template <class Container>
class BasicContainerWriter
  : public BasicWriter<typename Container::value_type> {
 private:
  internal::ContainerBuffer<Container> buffer_;

 public:
  /**
    \rst
    Constructs a :class:`fmt::BasicContainerWriter` object.
    \endrst
   */
  explicit BasicContainerWriter(Container& dest)
  : BasicWriter<typename Container::value_type>(buffer_), buffer_(dest) {}
};

} // namespace fmt

#endif  // FMT_CONTAINER_H_


================================================
FILE: lib/fmt/orig/format.cc
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "format.h"

#include <string.h>

#include <cctype>
#include <cerrno>
#include <climits>
#include <cmath>
#include <cstdarg>
#include <cstddef>  // for std::ptrdiff_t

#if defined(_WIN32) && defined(__MINGW32__)
# include <cstring>
#endif

#if FMT_USE_WINDOWS_H
# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
#  define WIN32_LEAN_AND_MEAN
# endif
# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
#  include <windows.h>
# else
#  define NOMINMAX
#  include <windows.h>
#  undef NOMINMAX
# endif
#endif

#if FMT_EXCEPTIONS
# define FMT_TRY try
# define FMT_CATCH(x) catch (x)
#else
# define FMT_TRY if (true)
# define FMT_CATCH(x) if (false)
#endif

#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4127)  // conditional expression is constant
# pragma warning(disable: 4702)  // unreachable code
// Disable deprecation warning for strerror. The latter is not called but
// MSVC fails to detect it.
# pragma warning(disable: 4996)
#endif

// Dummy implementations of strerror_r and strerror_s called if corresponding
// system functions are not available.
FMT_MAYBE_UNUSED
static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
  return fmt::internal::Null<>();
}
FMT_MAYBE_UNUSED
static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
  return fmt::internal::Null<>();
}

namespace fmt {

FMT_FUNC internal::RuntimeError::~RuntimeError() FMT_DTOR_NOEXCEPT {}
FMT_FUNC FormatError::~FormatError() FMT_DTOR_NOEXCEPT {}
FMT_FUNC SystemError::~SystemError() FMT_DTOR_NOEXCEPT {}

namespace {

#ifndef _MSC_VER
# define FMT_SNPRINTF snprintf
#else  // _MSC_VER
inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
  va_end(args);
  return result;
}
# define FMT_SNPRINTF fmt_snprintf
#endif  // _MSC_VER

#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
# define FMT_SWPRINTF snwprintf
#else
# define FMT_SWPRINTF swprintf
#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)

const char RESET_COLOR[] = "\x1b[0m";

typedef void (*FormatFunc)(Writer &, int, StringRef);

// Portable thread-safe version of strerror.
// Sets buffer to point to a string describing the error code.
// This can be either a pointer to a string stored in buffer,
// or a pointer to some static immutable string.
// Returns one of the following values:
//   0      - success
//   ERANGE - buffer is not large enough to store the error message
//   other  - failure
// Buffer should be at least of size 1.
int safe_strerror(
    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
  FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");

  class StrError {
   private:
    int error_code_;
    char *&buffer_;
    std::size_t buffer_size_;

    // A noop assignment operator to avoid bogus warnings.
    void operator=(const StrError &) {}

    // Handle the result of XSI-compliant version of strerror_r.
    int handle(int result) {
      // glibc versions before 2.13 return result in errno.
      return result == -1 ? errno : result;
    }

    // Handle the result of GNU-specific version of strerror_r.
    int handle(char *message) {
      // If the buffer is full then the message is probably truncated.
      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
        return ERANGE;
      buffer_ = message;
      return 0;
    }

    // Handle the case when strerror_r is not available.
    int handle(internal::Null<>) {
      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
    }

    // Fallback to strerror_s when strerror_r is not available.
    int fallback(int result) {
      // If the buffer is full then the message is probably truncated.
      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
            ERANGE : result;
    }

#ifdef __c2__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif

    // Fallback to strerror if strerror_r and strerror_s are not available.
    int fallback(internal::Null<>) {
      errno = 0;
      buffer_ = strerror(error_code_);
      return errno;
    }

#ifdef __c2__
# pragma clang diagnostic pop
#endif

   public:
    StrError(int err_code, char *&buf, std::size_t buf_size)
      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}

    int run() {
      return handle(strerror_r(error_code_, buffer_, buffer_size_));
    }
  };
  return StrError(error_code, buffer, buffer_size).run();
}

void format_error_code(Writer &out, int error_code,
                       StringRef message) FMT_NOEXCEPT {
  // Report error code making sure that the output fits into
  // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
  // bad_alloc.
  out.clear();
  static const char SEP[] = ": ";
  static const char ERROR_STR[] = "error ";
  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
  typedef internal::IntTraits<int>::MainType MainType;
  MainType abs_value = static_cast<MainType>(error_code);
  if (internal::is_negative(error_code)) {
    abs_value = 0 - abs_value;
    ++error_code_size;
  }
  error_code_size += internal::count_digits(abs_value);
  if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size)
    out << message << SEP;
  out << ERROR_STR << error_code;
  assert(out.size() <= internal::INLINE_BUFFER_SIZE);
}

void report_error(FormatFunc func, int error_code,
                  StringRef message) FMT_NOEXCEPT {
  MemoryWriter full_message;
  func(full_message, error_code, message);
  // Use Writer::data instead of Writer::c_str to avoid potential memory
  // allocation.
  std::fwrite(full_message.data(), full_message.size(), 1, stderr);
  std::fputc('\n', stderr);
}
}  // namespace

FMT_FUNC void SystemError::init(
    int err_code, CStringRef format_str, ArgList args) {
  error_code_ = err_code;
  MemoryWriter w;
  format_system_error(w, err_code, format(format_str, args));
  std::runtime_error &base = *this;
  base = std::runtime_error(w.str());
}

template <typename T>
int internal::CharTraits<char>::format_float(
    char *buffer, std::size_t size, const char *format,
    unsigned width, int precision, T value) {
  if (width == 0) {
    return precision < 0 ?
        FMT_SNPRINTF(buffer, size, format, value) :
        FMT_SNPRINTF(buffer, size, format, precision, value);
  }
  return precision < 0 ?
      FMT_SNPRINTF(buffer, size, format, width, value) :
      FMT_SNPRINTF(buffer, size, format, width, precision, value);
}

template <typename T>
int internal::CharTraits<wchar_t>::format_float(
    wchar_t *buffer, std::size_t size, const wchar_t *format,
    unsigned width, int precision, T value) {
  if (width == 0) {
    return precision < 0 ?
        FMT_SWPRINTF(buffer, size, format, value) :
        FMT_SWPRINTF(buffer, size, format, precision, value);
  }
  return precision < 0 ?
      FMT_SWPRINTF(buffer, size, format, width, value) :
      FMT_SWPRINTF(buffer, size, format, width, precision, value);
}

template <typename T>
const char internal::BasicData<T>::DIGITS[] =
    "0001020304050607080910111213141516171819"
    "2021222324252627282930313233343536373839"
    "4041424344454647484950515253545556575859"
    "6061626364656667686970717273747576777879"
    "8081828384858687888990919293949596979899";

#define FMT_POWERS_OF_10(factor) \
  factor * 10, \
  factor * 100, \
  factor * 1000, \
  factor * 10000, \
  factor * 100000, \
  factor * 1000000, \
  factor * 10000000, \
  factor * 100000000, \
  factor * 1000000000

template <typename T>
const uint32_t internal::BasicData<T>::POWERS_OF_10_32[] = {
  0, FMT_POWERS_OF_10(1)
};

template <typename T>
const uint64_t internal::BasicData<T>::POWERS_OF_10_64[] = {
  0,
  FMT_POWERS_OF_10(1),
  FMT_POWERS_OF_10(ULongLong(1000000000)),
  // Multiply several constants instead of using a single long long constant
  // to avoid warnings about C++98 not supporting long long.
  ULongLong(1000000000) * ULongLong(1000000000) * 10
};

FMT_FUNC void internal::report_unknown_type(char code, const char *type) {
  (void)type;
  if (std::isprint(static_cast<unsigned char>(code))) {
    FMT_THROW(FormatError(
        format("unknown format code '{}' for {}", code, type)));
  }
  FMT_THROW(FormatError(
      format("unknown format code '\\x{:02x}' for {}",
        static_cast<unsigned>(code), type)));
}

#if FMT_USE_WINDOWS_H

FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s) {
  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
  if (s.size() > INT_MAX)
    FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
  int s_size = static_cast<int>(s.size());
  int length = MultiByteToWideChar(
      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
  if (length == 0)
    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
  buffer_.resize(length + 1);
  length = MultiByteToWideChar(
    CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
  if (length == 0)
    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
  buffer_[length] = 0;
}

FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s) {
  if (int error_code = convert(s)) {
    FMT_THROW(WindowsError(error_code,
        "cannot convert string from UTF-16 to UTF-8"));
  }
}

FMT_FUNC int internal::UTF16ToUTF8::convert(WStringRef s) {
  if (s.size() > INT_MAX)
    return ERROR_INVALID_PARAMETER;
  int s_size = static_cast<int>(s.size());
  int length = WideCharToMultiByte(
    CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
  if (length == 0)
    return GetLastError();
  buffer_.resize(length + 1);
  length = WideCharToMultiByte(
    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
  if (length == 0)
    return GetLastError();
  buffer_[length] = 0;
  return 0;
}

FMT_FUNC void WindowsError::init(
    int err_code, CStringRef format_str, ArgList args) {
  error_code_ = err_code;
  MemoryWriter w;
  internal::format_windows_error(w, err_code, format(format_str, args));
  std::runtime_error &base = *this;
  base = std::runtime_error(w.str());
}

FMT_FUNC void internal::format_windows_error(
    Writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
  FMT_TRY {
    MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
    buffer.resize(INLINE_BUFFER_SIZE);
    for (;;) {
      wchar_t *system_message = &buffer[0];
      int result = FormatMessageW(
        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        system_message, static_cast<uint32_t>(buffer.size()), FMT_NULL);
      if (result != 0) {
        UTF16ToUTF8 utf8_message;
        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
          out << message << ": " << utf8_message;
          return;
        }
        break;
      }
      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        break;  // Can't get error message, report error code instead.
      buffer.resize(buffer.size() * 2);
    }
  } FMT_CATCH(...) {}
  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
}

#endif  // FMT_USE_WINDOWS_H

FMT_FUNC void format_system_error(
    Writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
  FMT_TRY {
    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
    buffer.resize(internal::INLINE_BUFFER_SIZE);
    for (;;) {
      char *system_message = &buffer[0];
      int result = safe_strerror(error_code, system_message, buffer.size());
      if (result == 0) {
        out << message << ": " << system_message;
        return;
      }
      if (result != ERANGE)
        break;  // Can't get error message, report error code instead.
      buffer.resize(buffer.size() * 2);
    }
  } FMT_CATCH(...) {}
  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
}

template <typename Char>
void internal::FixedBuffer<Char>::grow(std::size_t) {
  FMT_THROW(std::runtime_error("buffer overflow"));
}

FMT_FUNC internal::Arg internal::FormatterBase::do_get_arg(
    unsigned arg_index, const char *&error) {
  internal::Arg arg = args_[arg_index];
  switch (arg.type) {
  case internal::Arg::NONE:
    error = "argument index out of range";
    break;
  case internal::Arg::NAMED_ARG:
    arg = *static_cast<const internal::Arg*>(arg.pointer);
    break;
  default:
    /*nothing*/;
  }
  return arg;
}

FMT_FUNC void report_system_error(
    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
  // 'fmt::' is for bcc32.
  report_error(format_system_error, error_code, message);
}

#if FMT_USE_WINDOWS_H
FMT_FUNC void report_windows_error(
    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
  // 'fmt::' is for bcc32.
  report_error(internal::format_windows_error, error_code, message);
}
#endif

FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args) {
  MemoryWriter w;
  w.write(format_str, args);
  std::fwrite(w.data(), 1, w.size(), f);
}

FMT_FUNC void print(CStringRef format_str, ArgList args) {
  print(stdout, format_str, args);
}

FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args) {
  char escape[] = "\x1b[30m";
  escape[3] = static_cast<char>('0' + c);
  std::fputs(escape, stdout);
  print(format, args);
  std::fputs(RESET_COLOR, stdout);
}

#ifndef FMT_HEADER_ONLY

template struct internal::BasicData<void>;

// Explicit instantiations for char.

template void internal::FixedBuffer<char>::grow(std::size_t);

template FMT_API int internal::CharTraits<char>::format_float(
    char *buffer, std::size_t size, const char *format,
    unsigned width, int precision, double value);

template FMT_API int internal::CharTraits<char>::format_float(
    char *buffer, std::size_t size, const char *format,
    unsigned width, int precision, long double value);

// Explicit instantiations for wchar_t.

template void internal::FixedBuffer<wchar_t>::grow(std::size_t);

template FMT_API int internal::CharTraits<wchar_t>::format_float(
    wchar_t *buffer, std::size_t size, const wchar_t *format,
    unsigned width, int precision, double value);

template FMT_API int internal::CharTraits<wchar_t>::format_float(
    wchar_t *buffer, std::size_t size, const wchar_t *format,
    unsigned width, int precision, long double value);

#endif  // FMT_HEADER_ONLY

}  // namespace fmt

#ifdef _MSC_VER
# pragma warning(pop)
#endif


================================================
FILE: lib/fmt/orig/format.h
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_

#define FMT_INCLUDE
#include <cassert>
#include <clocale>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <utility>  // for std::pair
#undef FMT_INCLUDE

// The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 40100

#if defined(__has_include)
# define FMT_HAS_INCLUDE(x) __has_include(x)
#else
# define FMT_HAS_INCLUDE(x) 0
#endif

#if (FMT_HAS_INCLUDE(<string_view>) && __cplusplus > 201402L) || \
    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
# include <string_view>
# define FMT_HAS_STRING_VIEW 1
#else
# define FMT_HAS_STRING_VIEW 0
#endif

#if defined _SECURE_SCL && _SECURE_SCL
# define FMT_SECURE_SCL _SECURE_SCL
#else
# define FMT_SECURE_SCL 0
#endif

#if FMT_SECURE_SCL
# include <iterator>
#endif

#ifdef _MSC_VER
# define FMT_MSC_VER _MSC_VER
#else
# define FMT_MSC_VER 0
#endif

#if FMT_MSC_VER && FMT_MSC_VER <= 1500
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
typedef __int64          intmax_t;
#else
#include <stdint.h>
#endif

#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
# ifdef FMT_EXPORT
#  define FMT_API __declspec(dllexport)
# elif defined(FMT_SHARED)
#  define FMT_API __declspec(dllimport)
# endif
#endif
#ifndef FMT_API
# define FMT_API
#endif

#ifdef __GNUC__
# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
# define FMT_GCC_EXTENSION __extension__
# if FMT_GCC_VERSION >= 406
#  pragma GCC diagnostic push
// Disable the warning about "long long" which is sometimes reported even
// when using __extension__.
#  pragma GCC diagnostic ignored "-Wlong-long"
// Disable the warning about declaration shadowing because it affects too
// many valid cases.
#  pragma GCC diagnostic ignored "-Wshadow"
// Disable the warning about implicit conversions that may change the sign of
// an integer; silencing it otherwise would require many explicit casts.
#  pragma GCC diagnostic ignored "-Wsign-conversion"
# endif
# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
#  define FMT_HAS_GXX_CXX11 1
# endif
#else
# define FMT_GCC_VERSION 0
# define FMT_GCC_EXTENSION
# define FMT_HAS_GXX_CXX11 0
#endif

#if defined(__INTEL_COMPILER)
# define FMT_ICC_VERSION __INTEL_COMPILER
#elif defined(__ICL)
# define FMT_ICC_VERSION __ICL
#endif

#if defined(__clang__) && !defined(FMT_ICC_VERSION)
# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
# pragma clang diagnostic ignored "-Wpadded"
#endif

#ifdef __GNUC_LIBSTD__
# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
#endif

#ifdef __has_feature
# define FMT_HAS_FEATURE(x) __has_feature(x)
#else
# define FMT_HAS_FEATURE(x) 0
#endif

#ifdef __has_builtin
# define FMT_HAS_BUILTIN(x) __has_builtin(x)
#else
# define FMT_HAS_BUILTIN(x) 0
#endif

#ifdef __has_cpp_attribute
# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
# define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif

#if FMT_HAS_CPP_ATTRIBUTE(maybe_unused)
# define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED
// VC++ 1910 support /std: option and that will set _MSVC_LANG macro
// Clang with Microsoft CodeGen doesn't define _MSVC_LANG macro
#elif defined(_MSVC_LANG) && _MSVC_LANG > 201402 && _MSC_VER >= 1910
# define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED
#endif

#ifdef FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED
# define FMT_MAYBE_UNUSED [[maybe_unused]]
// g++/clang++ also support [[gnu::unused]]. However, we don't use it.
#elif defined(__GNUC__)
# define FMT_MAYBE_UNUSED __attribute__((unused))
#else
# define FMT_MAYBE_UNUSED
#endif

// Use the compiler's attribute noreturn
#if defined(__MINGW32__) || defined(__MINGW64__)
# define FMT_NORETURN __attribute__((noreturn))
#elif FMT_HAS_CPP_ATTRIBUTE(noreturn) && __cplusplus >= 201103L
# define FMT_NORETURN [[noreturn]]
#else
# define FMT_NORETURN
#endif

#ifndef FMT_USE_VARIADIC_TEMPLATES
// Variadic templates are available in GCC since version 4.4
// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
// since version 2013.
# define FMT_USE_VARIADIC_TEMPLATES \
   (FMT_HAS_FEATURE(cxx_variadic_templates) || \
       (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800)
#endif

#ifndef FMT_USE_RVALUE_REFERENCES
// Don't use rvalue references when compiling with clang and an old libstdc++
// as the latter doesn't provide std::move.
# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402
#  define FMT_USE_RVALUE_REFERENCES 0
# else
#  define FMT_USE_RVALUE_REFERENCES \
    (FMT_HAS_FEATURE(cxx_rvalue_references) || \
        (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600)
# endif
#endif

#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700
# define FMT_USE_ALLOCATOR_TRAITS 1
#else
# define FMT_USE_ALLOCATOR_TRAITS 0
#endif

// Check if exceptions are disabled.
#if defined(__GNUC__) && !defined(__EXCEPTIONS)
# define FMT_EXCEPTIONS 0
#endif
#if FMT_MSC_VER && !_HAS_EXCEPTIONS
# define FMT_EXCEPTIONS 0
#endif
#ifndef FMT_EXCEPTIONS
# define FMT_EXCEPTIONS 1
#endif

#ifndef FMT_THROW
# if FMT_EXCEPTIONS
#  define FMT_THROW(x) throw x
# else
#  define FMT_THROW(x) assert(false)
# endif
#endif

// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
#ifndef FMT_USE_NOEXCEPT
# define FMT_USE_NOEXCEPT 0
#endif

#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
    FMT_MSC_VER >= 1900
# define FMT_DETECTED_NOEXCEPT noexcept
#else
# define FMT_DETECTED_NOEXCEPT throw()
#endif

#ifndef FMT_NOEXCEPT
# if FMT_EXCEPTIONS
#  define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
# else
#  define FMT_NOEXCEPT
# endif
#endif

// This is needed because GCC still uses throw() in its headers when exceptions
// are disabled.
#if FMT_GCC_VERSION
# define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT
#else
# define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT
#endif

#ifndef FMT_OVERRIDE
# if (defined(FMT_USE_OVERRIDE) && FMT_USE_OVERRIDE) || FMT_HAS_FEATURE(cxx_override) || \
   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
   FMT_MSC_VER >= 1900
#  define FMT_OVERRIDE override
# else
#  define FMT_OVERRIDE
# endif
#endif

#ifndef FMT_NULL
# if FMT_HAS_FEATURE(cxx_nullptr) || \
   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
   FMT_MSC_VER >= 1600
#  define FMT_NULL nullptr
# else
#  define FMT_NULL NULL
# endif
#endif

// A macro to disallow the copy constructor and operator= functions
// This should be used in the private: declarations for a class
#ifndef FMT_USE_DELETED_FUNCTIONS
# define FMT_USE_DELETED_FUNCTIONS 0
#endif

#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
  (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800
# define FMT_DELETED_OR_UNDEFINED  = delete
# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
    TypeName(const TypeName&) = delete; \
    TypeName& operator=(const TypeName&) = delete
#else
# define FMT_DELETED_OR_UNDEFINED
# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
    TypeName(const TypeName&); \
    TypeName& operator=(const TypeName&)
#endif

#ifndef FMT_USE_DEFAULTED_FUNCTIONS
# define FMT_USE_DEFAULTED_FUNCTIONS 0
#endif

#ifndef FMT_DEFAULTED_COPY_CTOR
# if FMT_USE_DEFAULTED_FUNCTIONS || FMT_HAS_FEATURE(cxx_defaulted_functions) || \
   (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800
#  define FMT_DEFAULTED_COPY_CTOR(TypeName) \
    TypeName(const TypeName&) = default;
# else
#  define FMT_DEFAULTED_COPY_CTOR(TypeName)
# endif
#endif

#ifndef FMT_USE_USER_DEFINED_LITERALS
// All compilers which support UDLs also support variadic templates. This
// makes the fmt::literals implementation easier. However, an explicit check
// for variadic templates is added here just in case.
// For Intel's compiler both it and the system gcc/msc must support UDLs.
# if FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
   (FMT_HAS_FEATURE(cxx_user_literals) || \
     (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \
   (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500)
#  define FMT_USE_USER_DEFINED_LITERALS 1
# else
#  define FMT_USE_USER_DEFINED_LITERALS 0
# endif
#endif

#ifndef FMT_USE_EXTERN_TEMPLATES
# define FMT_USE_EXTERN_TEMPLATES \
    (FMT_CLANG_VERSION >= 209 || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
#endif

#ifdef FMT_HEADER_ONLY
// If header only do not use extern templates.
# undef FMT_USE_EXTERN_TEMPLATES
# define FMT_USE_EXTERN_TEMPLATES 0
#endif

#ifndef FMT_ASSERT
# define FMT_ASSERT(condition, message) assert((condition) && message)
#endif

// __builtin_clz is broken in clang with Microsoft CodeGen:
// https://github.com/fmtlib/fmt/issues/519
#ifndef _MSC_VER
# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
# endif

# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
# endif
#endif

// Some compilers masquerade as both MSVC and GCC-likes or
// otherwise support __builtin_clz and __builtin_clzll, so
// only define FMT_BUILTIN_CLZ using the MSVC intrinsics
// if the clz and clzll builtins are not available.
#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
# include <intrin.h>  // _BitScanReverse, _BitScanReverse64

namespace fmt {
namespace internal {
// avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning
# ifndef __clang__
#  pragma intrinsic(_BitScanReverse)
# endif
inline uint32_t clz(uint32_t x) {
  unsigned long r = 0;
  _BitScanReverse(&r, x);

  assert(x != 0);
  // Static analysis complains about using uninitialized data
  // "r", but the only way that can happen is if "x" is 0,
  // which the callers guarantee to not happen.
# pragma warning(suppress: 6102)
  return 31 - r;
}
# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)

// avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning
# if defined(_WIN64) && !defined(__clang__)
#  pragma intrinsic(_BitScanReverse64)
# endif

inline uint32_t clzll(uint64_t x) {
  unsigned long r = 0;
# ifdef _WIN64
  _BitScanReverse64(&r, x);
# else
  // Scan the high 32 bits.
  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
    return 63 - (r + 32);

  // Scan the low 32 bits.
  _BitScanReverse(&r, static_cast<uint32_t>(x));
# endif

  assert(x != 0);
  // Static analysis complains about using uninitialized data
  // "r", but the only way that can happen is if "x" is 0,
  // which the callers guarantee to not happen.
# pragma warning(suppress: 6102)
  return 63 - r;
}
# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
}
}
#endif

namespace fmt {
namespace internal {
struct DummyInt {
  int data[2];
  operator int() const { return 0; }
};
typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;

// Dummy implementations of system functions such as signbit and ecvt called
// if the latter are not available.
inline DummyInt signbit(...) { return DummyInt(); }
inline DummyInt _ecvt_s(...) { return DummyInt(); }
inline DummyInt isinf(...) { return DummyInt(); }
inline DummyInt _finite(...) { return DummyInt(); }
inline DummyInt isnan(...) { return DummyInt(); }
inline DummyInt _isnan(...) { return DummyInt(); }

// A helper function to suppress bogus "conditional expression is constant"
// warnings.
template <typename T>
inline T const_check(T value) { return value; }
}
}  // namespace fmt

namespace std {
// Standard permits specialization of std::numeric_limits. This specialization
// is used to resolve ambiguity between isinf and std::isinf in glibc:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
// and the same for isnan and signbit.
template <>
class numeric_limits<fmt::internal::DummyInt> :
    public std::numeric_limits<int> {
 public:
  // Portable version of isinf.
  template <typename T>
  static bool isinfinity(T x) {
    using namespace fmt::internal;
    // The resolution "priority" is:
    // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
    if (const_check(sizeof(isinf(x)) == sizeof(bool) ||
                    sizeof(isinf(x)) == sizeof(int))) {
      return isinf(x) != 0;
    }
    return !_finite(static_cast<double>(x));
  }

  // Portable version of isnan.
  template <typename T>
  static bool isnotanumber(T x) {
    using namespace fmt::internal;
    if (const_check(sizeof(isnan(x)) == sizeof(bool) ||
                    sizeof(isnan(x)) == sizeof(int))) {
      return isnan(x) != 0;
    }
    return _isnan(static_cast<double>(x)) != 0;
  }

  // Portable version of signbit.
  static bool isnegative(double x) {
    using namespace fmt::internal;
    if (const_check(sizeof(signbit(x)) == sizeof(bool) ||
                    sizeof(signbit(x)) == sizeof(int))) {
      return signbit(x) != 0;
    }
    if (x < 0) return true;
    if (!isnotanumber(x)) return false;
    int dec = 0, sign = 0;
    char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
    _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
    return sign != 0;
  }
};
}  // namespace std

namespace fmt {

// Fix the warning about long long on older versions of GCC
// that don't support the diagnostic pragma.
FMT_GCC_EXTENSION typedef long long LongLong;
FMT_GCC_EXTENSION typedef unsigned long long ULongLong;

#if FMT_USE_RVALUE_REFERENCES
using std::move;
#endif

template <typename Char>
class BasicWriter;

typedef BasicWriter<char> Writer;
typedef BasicWriter<wchar_t> WWriter;

template <typename Char>
class ArgFormatter;

struct FormatSpec;

template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
class BasicPrintfArgFormatter;

template <typename CharType,
          typename ArgFormatter = fmt::ArgFormatter<CharType> >
class BasicFormatter;

/**
  \rst
  A string reference. It can be constructed from a C string or
  ``std::basic_string``.

  You can use one of the following typedefs for common character types:

  +------------+-------------------------+
  | Type       | Definition              |
  +============+=========================+
  | StringRef  | BasicStringRef<char>    |
  +------------+-------------------------+
  | WStringRef | BasicStringRef<wchar_t> |
  +------------+-------------------------+

  This class is most useful as a parameter type to allow passing
  different types of strings to a function, for example::

    template <typename... Args>
    std::string format(StringRef format_str, const Args & ... args);

    format("{}", 42);
    format(std::string("{}"), 42);
  \endrst
 */
template <typename Char>
class BasicStringRef {
 private:
  const Char *data_;
  std::size_t size_;

 public:
  /** Constructs a string reference object from a C string and a size. */
  BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}

  /**
    \rst
    Constructs a string reference object from a C string computing
    the size with ``std::char_traits<Char>::length``.
    \endrst
   */
  BasicStringRef(const Char *s)
    : data_(s), size_(std::char_traits<Char>::length(s)) {}

  /**
    \rst
    Constructs a string reference from a ``std::basic_string`` object.
    \endrst
   */
  template <typename Allocator>
  BasicStringRef(
      const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
  : data_(s.c_str()), size_(s.size()) {}

#if FMT_HAS_STRING_VIEW
  /**
    \rst
    Constructs a string reference from a ``std::basic_string_view`` object.
    \endrst
   */
  BasicStringRef(
      const std::basic_string_view<Char, std::char_traits<Char>> &s)
  : data_(s.data()), size_(s.size()) {}

  /**
   \rst
   Converts a string reference to an ``std::string_view`` object.
   \endrst
  */
  explicit operator std::basic_string_view<Char>() const FMT_NOEXCEPT {
    return std::basic_string_view<Char>(data_, size_);
  }
#endif

  /**
    \rst
    Converts a string reference to an ``std::string`` object.
    \endrst
   */
  std::basic_string<Char> to_string() const {
    return std::basic_string<Char>(data_, size_);
  }

  /** Returns a pointer to the string data. */
  const Char *data() const { return data_; }

  /** Returns the string size. */
  std::size_t size() const { return size_; }

  // Lexicographically compare this string reference to other.
  int compare(BasicStringRef other) const {
    std::size_t size = size_ < other.size_ ? size_ : other.size_;
    int result = std::char_traits<Char>::compare(data_, other.data_, size);
    if (result == 0)
      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
    return result;
  }

  friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) == 0;
  }
  friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) != 0;
  }
  friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) < 0;
  }
  friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) <= 0;
  }
  friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) > 0;
  }
  friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) {
    return lhs.compare(rhs) >= 0;
  }
};

typedef BasicStringRef<char> StringRef;
typedef BasicStringRef<wchar_t> WStringRef;

/**
  \rst
  A reference to a null terminated string. It can be constructed from a C
  string or ``std::basic_string``.

  You can use one of the following typedefs for common character types:

  +-------------+--------------------------+
  | Type        | Definition               |
  +=============+==========================+
  | CStringRef  | BasicCStringRef<char>    |
  +-------------+--------------------------+
  | WCStringRef | BasicCStringRef<wchar_t> |
  +-------------+--------------------------+

  This class is most useful as a parameter type to allow passing
  different types of strings to a function, for example::

    template <typename... Args>
    std::string format(CStringRef format_str, const Args & ... args);

    format("{}", 42);
    format(std::string("{}"), 42);
  \endrst
 */
template <typename Char>
class BasicCStringRef {
 private:
  const Char *data_;

 public:
  /** Constructs a string reference object from a C string. */
  BasicCStringRef(const Char *s) : data_(s) {}

  /**
    \rst
    Constructs a string reference from a ``std::basic_string`` object.
    \endrst
   */
  template <typename Allocator>
  BasicCStringRef(
      const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
  : data_(s.c_str()) {}

  /** Returns the pointer to a C string. */
  const Char *c_str() const { return data_; }
};

typedef BasicCStringRef<char> CStringRef;
typedef BasicCStringRef<wchar_t> WCStringRef;

/** A formatting error such as invalid format string. */
class FormatError : public std::runtime_error {
 public:
  explicit FormatError(CStringRef message)
  : std::runtime_error(message.c_str()) {}
  FormatError(const FormatError &ferr) : std::runtime_error(ferr) {}
  FMT_API ~FormatError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;
};

namespace internal {

// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
template <typename T>
struct MakeUnsigned { typedef T Type; };

#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
  template <> \
  struct MakeUnsigned<T> { typedef U Type; }

FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);
FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);
FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);

// Casts nonnegative integer to unsigned.
template <typename Int>
inline typename MakeUnsigned<Int>::Type to_unsigned(Int value) {
  FMT_ASSERT(value >= 0, "negative value");
  return static_cast<typename MakeUnsigned<Int>::Type>(value);
}

// The number of characters to store in the MemoryBuffer object itself
// to avoid dynamic memory allocation.
enum { INLINE_BUFFER_SIZE = 500 };

#if FMT_SECURE_SCL
// Use checked iterator to avoid warnings on MSVC.
template <typename T>
inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
  return stdext::checked_array_iterator<T*>(ptr, size);
}
#else
template <typename T>
inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
#endif
}  // namespace internal

/**
  \rst
  A buffer supporting a subset of ``std::vector``'s operations.
  \endrst
 */
template <typename T>
class Buffer {
 private:
  FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);

 protected:
  T *ptr_;
  std::size_t size_;
  std::size_t capacity_;

  Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0)
    : ptr_(ptr), size_(0), capacity_(capacity) {}

  /**
    \rst
    Increases the buffer capacity to hold at least *size* elements updating
    ``ptr_`` and ``capacity_``.
    \endrst
   */
  virtual void grow(std::size_t size) = 0;

 public:
  virtual ~Buffer() {}

  /** Returns the size of this buffer. */
  std::size_t size() const { return size_; }

  /** Returns the capacity of this buffer. */
  std::size_t capacity() const { return capacity_; }

  /**
    Resizes the buffer. If T is a POD type new elements may not be initialized.
   */
  void resize(std::size_t new_size) {
    if (new_size > capacity_)
      grow(new_size);
    size_ = new_size;
  }

  /**
    \rst
    Reserves space to store at least *capacity* elements.
    \endrst
   */
  void reserve(std::size_t capacity) {
    if (capacity > capacity_)
      grow(capacity);
  }

  void clear() FMT_NOEXCEPT { size_ = 0; }

  void push_back(const T &value) {
    if (size_ == capacity_)
      grow(size_ + 1);
    ptr_[size_++] = value;
  }

  /** Appends data to the end of the buffer. */
  template <typename U>
  void append(const U *begin, const U *end);

  T &operator[](std::size_t index) { return ptr_[index]; }
  const T &operator[](std::size_t index) const { return ptr_[index]; }
};

template <typename T>
template <typename U>
void Buffer<T>::append(const U *begin, const U *end) {
  FMT_ASSERT(end >= begin, "negative value");
  std::size_t new_size = size_ + static_cast<std::size_t>(end - begin);
  if (new_size > capacity_)
    grow(new_size);
  std::uninitialized_copy(begin, end,
                          internal::make_ptr(ptr_, capacity_) + size_);
  size_ = new_size;
}

namespace internal {

// A memory buffer for trivially copyable/constructible types with the first
// SIZE elements stored in the object itself.
template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
class MemoryBuffer : private Allocator, public Buffer<T> {
 private:
  T data_[SIZE];

  // Deallocate memory allocated by the buffer.
  void deallocate() {
    if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
  }

 protected:
  void grow(std::size_t size) FMT_OVERRIDE;

 public:
  explicit MemoryBuffer(const Allocator &alloc = Allocator())
      : Allocator(alloc), Buffer<T>(data_, SIZE) {}
  ~MemoryBuffer() FMT_OVERRIDE { deallocate(); }

#if FMT_USE_RVALUE_REFERENCES
 private:
  // Move data from other to this buffer.
  void move(MemoryBuffer &other) {
    Allocator &this_alloc = *this, &other_alloc = other;
    this_alloc = std::move(other_alloc);
    this->size_ = other.size_;
    this->capacity_ = other.capacity_;
    if (other.ptr_ == other.data_) {
      this->ptr_ = data_;
      std::uninitialized_copy(other.data_, other.data_ + this->size_,
                              make_ptr(data_, this->capacity_));
    } else {
      this->ptr_ = other.ptr_;
      // Set pointer to the inline array so that delete is not called
      // when deallocating.
      other.ptr_ = other.data_;
    }
  }

 public:
  MemoryBuffer(MemoryBuffer &&other) {
    move(other);
  }

  MemoryBuffer &operator=(MemoryBuffer &&other) {
    assert(this != &other);
    deallocate();
    move(other);
    return *this;
  }
#endif

  // Returns a copy of the allocator associated with this buffer.
  Allocator get_allocator() const { return *this; }
};

template <typename T, std::size_t SIZE, typename Allocator>
void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
  std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
  if (size > new_capacity)
      new_capacity = size;
#if FMT_USE_ALLOCATOR_TRAITS
  T *new_ptr =
      std::allocator_traits<Allocator>::allocate(*this, new_capacity, FMT_NULL);
#else
  T *new_ptr = this->allocate(new_capacity, FMT_NULL);
#endif
  // The following code doesn't throw, so the raw pointer above doesn't leak.
  std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
                          make_ptr(new_ptr, new_capacity));
  std::size_t old_capacity = this->capacity_;
  T *old_ptr = this->ptr_;
  this->capacity_ = new_capacity;
  this->ptr_ = new_ptr;
  // deallocate may throw (at least in principle), but it doesn't matter since
  // the buffer already uses the new storage and will deallocate it in case
  // of exception.
  if (old_ptr != data_)
    Allocator::deallocate(old_ptr, old_capacity);
}

// A fixed-size buffer.
template <typename Char>
class FixedBuffer : public fmt::Buffer<Char> {
 public:
  FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}

 protected:
  FMT_API void grow(std::size_t size) FMT_OVERRIDE;
};

template <typename Char>
class BasicCharTraits {
 public:
#if FMT_SECURE_SCL
  typedef stdext::checked_array_iterator<Char*> CharPtr;
#else
  typedef Char *CharPtr;
#endif
  static Char cast(int value) { return static_cast<Char>(value); }
};

template <typename Char>
class CharTraits;

template <>
class CharTraits<char> : public BasicCharTraits<char> {
 private:
  // Conversion from wchar_t to char is not allowed.
  static char convert(wchar_t);

 public:
  static char convert(char value) { return value; }

  // Formats a floating-point number.
  template <typename T>
  FMT_API static int format_float(char *buffer, std::size_t size,
      const char *format, unsigned width, int precision, T value);
};

#if FMT_USE_EXTERN_TEMPLATES
extern template int CharTraits<char>::format_float<double>
        (char *buffer, std::size_t size,
         const char* format, unsigned width, int precision, double value);
extern template int CharTraits<char>::format_float<long double>
        (char *buffer, std::size_t size,
         const char* format, unsigned width, int precision, long double value);
#endif

template <>
class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> {
 public:
  static wchar_t convert(char value) { return value; }
  static wchar_t convert(wchar_t value) { return value; }

  template <typename T>
  FMT_API static int format_float(wchar_t *buffer, std::size_t size,
      const wchar_t *format, unsigned width, int precision, T value);
};

#if FMT_USE_EXTERN_TEMPLATES
extern template int CharTraits<wchar_t>::format_float<double>
        (wchar_t *buffer, std::size_t size,
         const wchar_t* format, unsigned width, int precision, double value);
extern template int CharTraits<wchar_t>::format_float<long double>
        (wchar_t *buffer, std::size_t size,
         const wchar_t* format, unsigned width, int precision, long double value);
#endif

// Checks if a number is negative - used to avoid warnings.
template <bool IsSigned>
struct SignChecker {
  template <typename T>
  static bool is_negative(T value) { return value < 0; }
};

template <>
struct SignChecker<false> {
  template <typename T>
  static bool is_negative(T) { return false; }
};

// Returns true if value is negative, false otherwise.
// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
template <typename T>
inline bool is_negative(T value) {
  return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
}

// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
template <bool FitsIn32Bits>
struct TypeSelector { typedef uint32_t Type; };

template <>
struct TypeSelector<false> { typedef uint64_t Type; };

template <typename T>
struct IntTraits {
  // Smallest of uint32_t and uint64_t that is large enough to represent
  // all values of T.
  typedef typename
    TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
};

FMT_API FMT_NORETURN void report_unknown_type(char code, const char *type);

// Static data is placed in this class template to allow header-only
// configuration.
template <typename T = void>
struct FMT_API BasicData {
  static const uint32_t POWERS_OF_10_32[];
  static const uint64_t POWERS_OF_10_64[];
  static const char DIGITS[];
};

#if FMT_USE_EXTERN_TEMPLATES
extern template struct BasicData<void>;
#endif

typedef BasicData<> Data;

#ifdef FMT_BUILTIN_CLZLL
// Returns the number of decimal digits in n. Leading zeros are not counted
// except for n == 0 in which case count_digits returns 1.
inline unsigned count_digits(uint64_t n) {
  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
  return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;
}
#else
// Fallback version of count_digits used when __builtin_clz is not available.
inline unsigned count_digits(uint64_t n) {
  unsigned count = 1;
  for (;;) {
    // Integer division is slow so do it for a group of four digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    if (n < 10) return count;
    if (n < 100) return count + 1;
    if (n < 1000) return count + 2;
    if (n < 10000) return count + 3;
    n /= 10000u;
    count += 4;
  }
}
#endif

#ifdef FMT_BUILTIN_CLZ
// Optional version of count_digits for better performance on 32-bit platforms.
inline unsigned count_digits(uint32_t n) {
  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
  return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1;
}
#endif

// A functor that doesn't add a thousands separator.
struct NoThousandsSep {
  template <typename Char>
  void operator()(Char *) {}
};

// A functor that adds a thousands separator.
class ThousandsSep {
 private:
  fmt::StringRef sep_;

  // Index of a decimal digit with the least significant digit having index 0.
  unsigned digit_index_;

 public:
  explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {}

  template <typename Char>
  void operator()(Char *&buffer) {
    if (++digit_index_ % 3 != 0)
      return;
    buffer -= sep_.size();
    std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
                            internal::make_ptr(buffer, sep_.size()));
  }
};

// Formats a decimal unsigned integer value writing into buffer.
// thousands_sep is a functor that is called after writing each char to
// add a thousands separator if necessary.
template <typename UInt, typename Char, typename ThousandsSep>
inline void format_decimal(Char *buffer, UInt value, unsigned num_digits,
                           ThousandsSep thousands_sep) {
  buffer += num_digits;
  while (value >= 100) {
    // Integer division is slow so do it for a group of two digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    unsigned index = static_cast<unsigned>((value % 100) * 2);
    value /= 100;
    *--buffer = Data::DIGITS[index + 1];
    thousands_sep(buffer);
    *--buffer = Data::DIGITS[index];
    thousands_sep(buffer);
  }
  if (value < 10) {
    *--buffer = static_cast<char>('0' + value);
    return;
  }
  unsigned index = static_cast<unsigned>(value * 2);
  *--buffer = Data::DIGITS[index + 1];
  thousands_sep(buffer);
  *--buffer = Data::DIGITS[index];
}

template <typename UInt, typename Char>
inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
  format_decimal(buffer, value, num_digits, NoThousandsSep());
  return;
}

#ifndef _WIN32
# define FMT_USE_WINDOWS_H 0
#elif !defined(FMT_USE_WINDOWS_H)
# define FMT_USE_WINDOWS_H 1
#endif

// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
// All the functionality that relies on it will be disabled too.
#if FMT_USE_WINDOWS_H
// A converter from UTF-8 to UTF-16.
// It is only provided for Windows since other systems support UTF-8 natively.
class UTF8ToUTF16 {
 private:
  MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;

 public:
  FMT_API explicit UTF8ToUTF16(StringRef s);
  operator WStringRef() const { return WStringRef(&buffer_[0], size()); }
  size_t size() const { return buffer_.size() - 1; }
  const wchar_t *c_str() const { return &buffer_[0]; }
  std::wstring str() const { return std::wstring(&buffer_[0], size()); }
};

// A converter from UTF-16 to UTF-8.
// It is only provided for Windows since other systems support UTF-8 natively.
class UTF16ToUTF8 {
 private:
  MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;

 public:
  UTF16ToUTF8() {}
  FMT_API explicit UTF16ToUTF8(WStringRef s);
  operator StringRef() const { return StringRef(&buffer_[0], size()); }
  size_t size() const { return buffer_.size() - 1; }
  const char *c_str() const { return &buffer_[0]; }
  std::string str() const { return std::string(&buffer_[0], size()); }

  // Performs conversion returning a system error code instead of
  // throwing exception on conversion error. This method may still throw
  // in case of memory allocation error.
  FMT_API int convert(WStringRef s);
};

FMT_API void format_windows_error(fmt::Writer &out, int error_code,
                                  fmt::StringRef message) FMT_NOEXCEPT;
#endif

// A formatting argument value.
struct Value {
  template <typename Char>
  struct StringValue {
    const Char *value;
    std::size_t size;
  };

  typedef void (*FormatFunc)(
      void *formatter, const void *arg, void *format_str_ptr);

  struct CustomValue {
    const void *value;
    FormatFunc format;
  };

  union {
    int int_value;
    unsigned uint_value;
    LongLong long_long_value;
    ULongLong ulong_long_value;
    double double_value;
    long double long_double_value;
    const void *pointer;
    StringValue<char> string;
    StringValue<signed char> sstring;
    StringValue<unsigned char> ustring;
    StringValue<wchar_t> wstring;
    CustomValue custom;
  };

  enum Type {
    NONE, NAMED_ARG,
    // Integer types should go first,
    INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
    // followed by floating-point types.
    DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
    CSTRING, STRING, WSTRING, POINTER, CUSTOM
  };
};

// A formatting argument. It is a trivially copyable/constructible type to
// allow storage in internal::MemoryBuffer.
struct Arg : Value {
  Type type;
};

template <typename Char>
struct NamedArg;
template <typename Char, typename T>
struct NamedArgWithType;

template <typename T = void>
struct Null {};

// A helper class template to enable or disable overloads taking wide
// characters and strings in MakeValue.
template <typename T, typename Char>
struct WCharHelper {
  typedef Null<T> Supported;
  typedef T Unsupported;
};

template <typename T>
struct WCharHelper<T, wchar_t> {
  typedef T Supported;
  typedef Null<T> Unsupported;
};

typedef char Yes[1];
typedef char No[2];

template <typename T>
T &get();

// These are non-members to workaround an overload resolution bug in bcc32.
Yes &convert(fmt::ULongLong);
No &convert(...);

template <typename T, bool ENABLE_CONVERSION>
struct ConvertToIntImpl {
  enum { value = ENABLE_CONVERSION };
};

template <typename T, bool ENABLE_CONVERSION>
struct ConvertToIntImpl2 {
  enum { value = false };
};

template <typename T>
struct ConvertToIntImpl2<T, true> {
  enum {
    // Don't convert numeric types.
    value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
  };
};

template <typename T>
struct ConvertToInt {
  enum {
    enable_conversion = sizeof(fmt::internal::convert(get<T>())) == sizeof(Yes)
  };
  enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
};

#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
  template <> \
  struct ConvertToInt<Type> {  enum { value = 0 }; }

// Silence warnings about convering float to int.
FMT_DISABLE_CONVERSION_TO_INT(float);
FMT_DISABLE_CONVERSION_TO_INT(double);
FMT_DISABLE_CONVERSION_TO_INT(long double);

template <bool B, class T = void>
struct EnableIf {};

template <class T>
struct EnableIf<true, T> { typedef T type; };

template <bool B, class T, class F>
struct Conditional { typedef T type; };

template <class T, class F>
struct Conditional<false, T, F> { typedef F type; };

// For bcc32 which doesn't understand ! in template arguments.
template <bool>
struct Not { enum { value = 0 }; };

template <>
struct Not<false> { enum { value = 1 }; };

template <typename T>
struct FalseType { enum { value = 0 }; };

template <typename T, T> struct LConvCheck {
  LConvCheck(int) {}
};

// Returns the thousands separator for the current locale.
// We check if ``lconv`` contains ``thousands_sep`` because on Android
// ``lconv`` is stubbed as an empty struct.
template <typename LConv>
inline StringRef thousands_sep(
    LConv *lc, LConvCheck<char *LConv::*, &LConv::thousands_sep> = 0) {
  return lc->thousands_sep;
}

inline fmt::StringRef thousands_sep(...) { return ""; }

#define FMT_CONCAT(a, b) a##b

#if FMT_GCC_VERSION >= 303
# define FMT_UNUSED __attribute__((unused))
#else
# define FMT_UNUSED
#endif

#ifndef FMT_USE_STATIC_ASSERT
# define FMT_USE_STATIC_ASSERT 0
#endif

#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
  (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
#else
# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
# define FMT_STATIC_ASSERT(cond, message) \
  typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
#endif

template <typename Formatter>
void format_arg(Formatter&, ...) {
  FMT_STATIC_ASSERT(FalseType<Formatter>::value,
                    "Cannot format argument. To enable the use of ostream "
                    "operator<< include fmt/ostream.h. Otherwise provide "
                    "an overload of format_arg.");
}

// Makes an Arg object from any type.
template <typename Formatter>
class MakeValue : public Arg {
 public:
  typedef typename Formatter::Char Char;

 private:
  // The following two methods are private to disallow formatting of
  // arbitrary pointers. If you want to output a pointer cast it to
  // "void *" or "const void *". In particular, this forbids formatting
  // of "[const] volatile char *" which is printed as bool by iostreams.
  // Do not implement!
  template <typename T>
  MakeValue(const T *value);
  template <typename T>
  MakeValue(T *value);

  // The following methods are private to disallow formatting of wide
  // characters and strings into narrow strings as in
  //   fmt::format("{}", L"test");
  // To fix this, use a wide format string: fmt::format(L"{}", L"test").
#if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED)
  MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
#endif
  MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
  MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
  MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
#if FMT_HAS_STRING_VIEW
  MakeValue(typename WCharHelper<const std::wstring_view &, Char>::Unsupported);
#endif
  MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);

  void set_string(StringRef str) {
    string.value = str.data();
    string.size = str.size();
  }

  void set_string(WStringRef str) {
    wstring.value = str.data();
    wstring.size = str.size();
  }

  // Formats an argument of a custom type, such as a user-defined class.
  template <typename T>
  static void format_custom_arg(
      void *formatter, const void *arg, void *format_str_ptr) {
    format_arg(*static_cast<Formatter*>(formatter),
               *static_cast<const Char**>(format_str_ptr),
               *static_cast<const T*>(arg));
  }

 public:
  MakeValue() {}

#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
  MakeValue(Type value) { field = rhs; } \
  static uint64_t type(Type) { return Arg::TYPE; }

#define FMT_MAKE_VALUE(Type, field, TYPE) \
  FMT_MAKE_VALUE_(Type, field, TYPE, value)

  FMT_MAKE_VALUE(bool, int_value, BOOL)
  FMT_MAKE_VALUE(short, int_value, INT)
  FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
  FMT_MAKE_VALUE(int, int_value, INT)
  FMT_MAKE_VALUE(unsigned, uint_value, UINT)

  MakeValue(long value) {
    // To minimize the number of types we need to deal with, long is
    // translated either to int or to long long depending on its size.
    if (const_check(sizeof(long) == sizeof(int)))
      int_value = static_cast<int>(value);
    else
      long_long_value = value;
  }
  static uint64_t type(long) {
    return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
  }

  MakeValue(unsigned long value) {
    if (const_check(sizeof(unsigned long) == sizeof(unsigned)))
      uint_value = static_cast<unsigned>(value);
    else
      ulong_long_value = value;
  }
  static uint64_t type(unsigned long) {
    return sizeof(unsigned long) == sizeof(unsigned) ?
          Arg::UINT : Arg::ULONG_LONG;
  }

  FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
  FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
  FMT_MAKE_VALUE(float, double_value, DOUBLE)
  FMT_MAKE_VALUE(double, double_value, DOUBLE)
  FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
  FMT_MAKE_VALUE(signed char, int_value, INT)
  FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
  FMT_MAKE_VALUE(char, int_value, CHAR)

#if __cplusplus >= 201103L
  template <
    typename T,
    typename = typename std::enable_if<
      std::is_enum<T>::value && ConvertToInt<T>::value>::type>
   MakeValue(T value) { int_value = value; }

  template <
    typename T,
    typename = typename std::enable_if<
      std::is_enum<T>::value && ConvertToInt<T>::value>::type>
  static uint64_t type(T) { return Arg::INT; }
#endif

#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
  MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
    int_value = value;
  }
  static uint64_t type(wchar_t) { return Arg::CHAR; }
#endif

#define FMT_MAKE_STR_VALUE(Type, TYPE) \
  MakeValue(Type value) { set_string(value); } \
  static uint64_t type(Type) { return Arg::TYPE; }

  FMT_MAKE_VALUE(char *, string.value, CSTRING)
  FMT_MAKE_VALUE(const char *, string.value, CSTRING)
  FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
  FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
  FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
  FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
  FMT_MAKE_STR_VALUE(const std::string &, STRING)
#if FMT_HAS_STRING_VIEW
  FMT_MAKE_STR_VALUE(const std::string_view &, STRING)
#endif
  FMT_MAKE_STR_VALUE(StringRef, STRING)
  FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())

#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
  MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
    set_string(value); \
  } \
  static uint64_t type(Type) { return Arg::TYPE; }

  FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
  FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
  FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
#if FMT_HAS_STRING_VIEW
  FMT_MAKE_WSTR_VALUE(const std::wstring_view &, WSTRING)
#endif
  FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)

  FMT_MAKE_VALUE(void *, pointer, POINTER)
  FMT_MAKE_VALUE(const void *, pointer, POINTER)

  template <typename T>
  MakeValue(const T &value,
            typename EnableIf<Not<
              ConvertToInt<T>::value>::value, int>::type = 0) {
    custom.value = &value;
    custom.format = &format_custom_arg<T>;
  }

  template <typename T>
  static typename EnableIf<Not<ConvertToInt<T>::value>::value, uint64_t>::type
      type(const T &) {
    return Arg::CUSTOM;
  }

  // Additional template param `Char_` is needed here because make_type always
  // uses char.
  template <typename Char_>
  MakeValue(const NamedArg<Char_> &value) { pointer = &value; }
  template <typename Char_, typename T>
  MakeValue(const NamedArgWithType<Char_, T> &value) { pointer = &value; }

  template <typename Char_>
  static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
  template <typename Char_, typename T>
  static uint64_t type(const NamedArgWithType<Char_, T> &) { return Arg::NAMED_ARG; }
};

template <typename Formatter>
class MakeArg : public Arg {
public:
  MakeArg() {
    type = Arg::NONE;
  }

  template <typename T>
  MakeArg(const T &value)
  : Arg(MakeValue<Formatter>(value)) {
    type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));
  }
};

template <typename Char>
struct NamedArg : Arg {
  BasicStringRef<Char> name;

  template <typename T>
  NamedArg(BasicStringRef<Char> argname, const T &value)
  : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
};

template <typename Char, typename T>
struct NamedArgWithType : NamedArg<Char> {
  NamedArgWithType(BasicStringRef<Char> argname, const T &value)
  : NamedArg<Char>(argname, value) {}
};

class RuntimeError : public std::runtime_error {
 protected:
  RuntimeError() : std::runtime_error("") {}
  RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {}
  FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;
};

template <typename Char>
class ArgMap;
}  // namespace internal

/** An argument list. */
class ArgList {
 private:
  // To reduce compiled code size per formatting function call, types of first
  // MAX_PACKED_ARGS arguments are passed in the types_ field.
  uint64_t types_;
  union {
    // If the number of arguments is less than MAX_PACKED_ARGS, the argument
    // values are stored in values_, otherwise they are stored in args_.
    // This is done to reduce compiled code size as storing larger objects
    // may require more code (at least on x86-64) even if the same amount of
    // data is actually copied to stack. It saves ~10% on the bloat test.
    const internal::Value *values_;
    const internal::Arg *args_;
  };

  internal::Arg::Type type(unsigned index) const {
    return type(types_, index);
  }

  template <typename Char>
  friend class internal::ArgMap;

 public:
  // Maximum number of arguments with packed types.
  enum { MAX_PACKED_ARGS = 16 };

  ArgList() : types_(0) {}

  ArgList(ULongLong types, const internal::Value *values)
  : types_(types), values_(values) {}
  ArgList(ULongLong types, const internal::Arg *args)
  : types_(types), args_(args) {}

  uint64_t types() const { return types_; }

  /** Returns the argument at specified index. */
  internal::Arg operator[](unsigned index) const {
    using internal::Arg;
    Arg arg;
    bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
    if (index < MAX_PACKED_ARGS) {
      Arg::Type arg_type = type(index);
      internal::Value &val = arg;
      if (arg_type != Arg::NONE)
        val = use_values ? values_[index] : args_[index];
      arg.type = arg_type;
      return arg;
    }
    if (use_values) {
      // The index is greater than the number of arguments that can be stored
      // in values, so return a "none" argument.
      arg.type = Arg::NONE;
      return arg;
    }
    for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
      if (args_[i].type == Arg::NONE)
        return args_[i];
    }
    return args_[index];
  }

  static internal::Arg::Type type(uint64_t types, unsigned index) {
    unsigned shift = index * 4;
    uint64_t mask = 0xf;
    return static_cast<internal::Arg::Type>(
          (types & (mask << shift)) >> shift);
  }
};

#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call

/**
  \rst
  An argument visitor based on the `curiously recurring template pattern
  <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.

  To use `~fmt::ArgVisitor` define a subclass that implements some or all of the
  visit methods with the same signatures as the methods in `~fmt::ArgVisitor`,
  for example, `~fmt::ArgVisitor::visit_int()`.
  Pass the subclass as the *Impl* template parameter. Then calling
  `~fmt::ArgVisitor::visit` for some argument will dispatch to a visit method
  specific to the argument type. For example, if the argument type is
  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
  will be called. If the subclass doesn't contain a method with this signature,
  then a corresponding method of `~fmt::ArgVisitor` will be called.

  **Example**::

    class MyArgVisitor : public fmt::ArgVisitor<MyArgVisitor, void> {
     public:
      void visit_int(int value) { fmt::print("{}", value); }
      void visit_double(double value) { fmt::print("{}", value ); }
    };
  \endrst
 */
template <typename Impl, typename Result>
class ArgVisitor {
 private:
  typedef internal::Arg Arg;

 public:
  void report_unhandled_arg() {}

  Result visit_unhandled_arg() {
    FMT_DISPATCH(report_unhandled_arg());
    return Result();
  }

  /** Visits an ``int`` argument. **/
  Result visit_int(int value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits a ``long long`` argument. **/
  Result visit_long_long(LongLong value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits an ``unsigned`` argument. **/
  Result visit_uint(unsigned value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits an ``unsigned long long`` argument. **/
  Result visit_ulong_long(ULongLong value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits a ``bool`` argument. **/
  Result visit_bool(bool value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits a ``char`` or ``wchar_t`` argument. **/
  Result visit_char(int value) {
    return FMT_DISPATCH(visit_any_int(value));
  }

  /** Visits an argument of any integral type. **/
  template <typename T>
  Result visit_any_int(T) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a ``double`` argument. **/
  Result visit_double(double value) {
    return FMT_DISPATCH(visit_any_double(value));
  }

  /** Visits a ``long double`` argument. **/
  Result visit_long_double(long double value) {
    return FMT_DISPATCH(visit_any_double(value));
  }

  /** Visits a ``double`` or ``long double`` argument. **/
  template <typename T>
  Result visit_any_double(T) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a null-terminated C string (``const char *``) argument. **/
  Result visit_cstring(const char *) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a string argument. **/
  Result visit_string(Arg::StringValue<char>) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a wide string argument. **/
  Result visit_wstring(Arg::StringValue<wchar_t>) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits a pointer argument. **/
  Result visit_pointer(const void *) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /** Visits an argument of a custom (user-defined) type. **/
  Result visit_custom(Arg::CustomValue) {
    return FMT_DISPATCH(visit_unhandled_arg());
  }

  /**
    \rst
    Visits an argument dispatching to the appropriate visit method based on
    the argument type. For example, if the argument type is ``double`` then
    the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be
    called.
    \endrst
   */
  Result visit(const Arg &arg) {
    switch (arg.type) {
    case Arg::NONE:
    case Arg::NAMED_ARG:
      FMT_ASSERT(false, "invalid argument type");
      break;
    case Arg::INT:
      return FMT_DISPATCH(visit_int(arg.int_value));
    case Arg::UINT:
      return FMT_DISPATCH(visit_uint(arg.uint_value));
    case Arg::LONG_LONG:
      return FMT_DISPATCH(visit_long_long(arg.long_long_value));
    case Arg::ULONG_LONG:
      return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
    case Arg::BOOL:
      return FMT_DISPATCH(visit_bool(arg.int_value != 0));
    case Arg::CHAR:
      return FMT_DISPATCH(visit_char(arg.int_value));
    case Arg::DOUBLE:
      return FMT_DISPATCH(visit_double(arg.double_value));
    case Arg::LONG_DOUBLE:
      return FMT_DISPATCH(visit_long_double(arg.long_double_value));
    case Arg::CSTRING:
      return FMT_DISPATCH(visit_cstring(arg.string.value));
    case Arg::STRING:
      return FMT_DISPATCH(visit_string(arg.string));
    case Arg::WSTRING:
      return FMT_DISPATCH(visit_wstring(arg.wstring));
    case Arg::POINTER:
      return FMT_DISPATCH(visit_pointer(arg.pointer));
    case Arg::CUSTOM:
      return FMT_DISPATCH(visit_custom(arg.custom));
    }
    return Result();
  }
};

enum Alignment {
  ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
};

// Flags.
enum {
  SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
  CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.
};

// An empty format specifier.
struct EmptySpec {};

// A type specifier.
template <char TYPE>
struct TypeSpec : EmptySpec {
  Alignment align() const { return ALIGN_DEFAULT; }
  unsigned width() const { return 0; }
  int precision() const { return -1; }
  bool flag(unsigned) const { return false; }
  char type() const { return TYPE; }
  char type_prefix() const { return TYPE; }
  char fill() const { return ' '; }
};

// A width specifier.
struct WidthSpec {
  unsigned width_;
  // Fill is always wchar_t and cast to char if necessary to avoid having
  // two specialization of WidthSpec and its subclasses.
  wchar_t fill_;

  WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}

  unsigned width() const { return width_; }
  wchar_t fill() const { return fill_; }
};

// An alignment specifier.
struct AlignSpec : WidthSpec {
  Alignment align_;

  AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
  : WidthSpec(width, fill), align_(align) {}

  Alignment align() const { return align_; }

  int precision() const { return -1; }
};

// An alignment and type specifier.
template <char TYPE>
struct AlignTypeSpec : AlignSpec {
  AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}

  bool flag(unsigned) const { return false; }
  char type() const { return TYPE; }
  char type_prefix() const { return TYPE; }
};

// A full format specifier.
struct FormatSpec : AlignSpec {
  unsigned flags_;
  int precision_;
  char type_;

  FormatSpec(
    unsigned width = 0, char type = 0, wchar_t fill = ' ')
  : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}

  bool flag(unsigned f) const { return (flags_ & f) != 0; }
  int precision() const { return precision_; }
  char type() const { return type_; }
  char type_prefix() const { return type_; }
};

// An integer format specifier.
template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
class IntFormatSpec : public SpecT {
 private:
  T value_;

 public:
  IntFormatSpec(T val, const SpecT &spec = SpecT())
  : SpecT(spec), value_(val) {}

  T value() const { return value_; }
};

// A string format specifier.
template <typename Char>
class StrFormatSpec : public AlignSpec {
 private:
  const Char *str_;

 public:
  template <typename FillChar>
  StrFormatSpec(const Char *str, unsigned width, FillChar fill)
  : AlignSpec(width, fill), str_(str) {
    internal::CharTraits<Char>::convert(FillChar());
  }

  const Char *str() const { return str_; }
};

/**
  Returns an integer format specifier to format the value in base 2.
 */
IntFormatSpec<int, TypeSpec<'b'> > bin(int value);

/**
  Returns an integer format specifier to format the value in base 8.
 */
IntFormatSpec<int, TypeSpec<'o'> > oct(int value);

/**
  Returns an integer format specifier to format the value in base 16 using
  lower-case letters for the digits above 9.
 */
IntFormatSpec<int, TypeSpec<'x'> > hex(int value);

/**
  Returns an integer formatter format specifier to format in base 16 using
  upper-case letters for the digits above 9.
 */
IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);

/**
  \rst
  Returns an integer format specifier to pad the formatted argument with the
  fill character to the specified width using the default (right) numeric
  alignment.

  **Example**::

    MemoryWriter out;
    out << pad(hex(0xcafe), 8, '0');
    // out.str() == "0000cafe"

  \endrst
 */
template <char TYPE_CODE, typename Char>
IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
    int value, unsigned width, Char fill = ' ');

#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
} \
 \
inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
} \
 \
inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
} \
 \
inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
  return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
} \
 \
template <char TYPE_CODE> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
      f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
} \
 \
/* For compatibility with older compilers we provide two overloads for pad, */ \
/* one that takes a fill character and one that doesn't. In the future this */ \
/* can be replaced with one overload making the template argument Char      */ \
/* default to char (C++11). */ \
template <char TYPE_CODE, typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
    unsigned width, Char fill) { \
  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
      f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
} \
 \
inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
    TYPE value, unsigned width) { \
  return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
      value, AlignTypeSpec<0>(width, ' ')); \
} \
 \
template <typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
   TYPE value, unsigned width, Char fill) { \
 return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
     value, AlignTypeSpec<0>(width, fill)); \
}

FMT_DEFINE_INT_FORMATTERS(int)
FMT_DEFINE_INT_FORMATTERS(long)
FMT_DEFINE_INT_FORMATTERS(unsigned)
FMT_DEFINE_INT_FORMATTERS(unsigned long)
FMT_DEFINE_INT_FORMATTERS(LongLong)
FMT_DEFINE_INT_FORMATTERS(ULongLong)

/**
  \rst
  Returns a string formatter that pads the formatted argument with the fill
  character to the specified width using the default (left) string alignment.

  **Example**::

    std::string s = str(MemoryWriter() << pad("abc", 8));
    // s == "abc     "

  \endrst
 */
template <typename Char>
inline StrFormatSpec<Char> pad(
    const Char *str, unsigned width, Char fill = ' ') {
  return StrFormatSpec<Char>(str, width, fill);
}

inline StrFormatSpec<wchar_t> pad(
    const wchar_t *str, unsigned width, char fill = ' ') {
  return StrFormatSpec<wchar_t>(str, width, fill);
}

namespace internal {

template <typename Char>
class ArgMap {
 private:
  typedef std::vector<
    std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;
  typedef typename MapType::value_type Pair;

  MapType map_;

 public:
  void init(const ArgList &args);

  const internal::Arg *find(const fmt::BasicStringRef<Char> &name) const {
    // The list is unsorted, so just return the first matching name.
    for (typename MapType::const_iterator it = map_.begin(), end = map_.end();
         it != end; ++it) {
      if (it->first == name)
        return &it->second;
    }
    return FMT_NULL;
  }
};

template <typename Char>
void ArgMap<Char>::init(const ArgList &args) {
  if (!map_.empty())
    return;
  typedef internal::NamedArg<Char> NamedArg;
  const NamedArg *named_arg = FMT_NULL;
  bool use_values =
      args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
  if (use_values) {
    for (unsigned i = 0;/*nothing*/; ++i) {
      internal::Arg::Type arg_type = args.type(i);
      switch (arg_type) {
      case internal::Arg::NONE:
        return;
      case internal::Arg::NAMED_ARG:
        named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
        map_.push_back(Pair(named_arg->name, *named_arg));
        break;
      default:
        /*nothing*/;
      }
    }
    return;
  }
  for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
    internal::Arg::Type arg_type = args.type(i);
    if (arg_type == internal::Arg::NAMED_ARG) {
      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
      map_.push_back(Pair(named_arg->name, *named_arg));
    }
  }
  for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
    switch (args.args_[i].type) {
    case internal::Arg::NONE:
      return;
    case internal::Arg::NAMED_ARG:
      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
      map_.push_back(Pair(named_arg->name, *named_arg));
      break;
    default:
      /*nothing*/;
    }
  }
}

template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
class ArgFormatterBase : public ArgVisitor<Impl, void> {
 private:
  BasicWriter<Char> &writer_;
  Spec &spec_;

  FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);

  void write_pointer(const void *p) {
    spec_.flags_ = HASH_FLAG;
    spec_.type_ = 'x';
    writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
  }

  // workaround MSVC two-phase lookup issue
  typedef internal::Arg Arg;

 protected:
  BasicWriter<Char> &writer() { return writer_; }
  Spec &spec() { return spec_; }

  void write(bool value) {
    const char *str_value = value ? "true" : "false";
    Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
    writer_.write_str(str, spec_);
  }

  void write(const char *value) {
    Arg::StringValue<char> str = {value, value ? std::strlen(value) : 0};
    writer_.write_str(str, spec_);
  }

 public:
  typedef Spec SpecType;

  ArgFormatterBase(BasicWriter<Char> &w, Spec &s)
  : writer_(w), spec_(s) {}

  template <typename T>
  void visit_any_int(T value) { writer_.write_int(value, spec_); }

  template <typename T>
  void visit_any_double(T value) { writer_.write_double(value, spec_); }

  void visit_bool(bool value) {
    if (spec_.type_) {
      visit_any_int(value);
      return;
    }
    write(value);
  }

  void visit_char(int value) {
    if (spec_.type_ && spec_.type_ != 'c') {
      spec_.flags_ |= CHAR_FLAG;
      writer_.write_int(value, spec_);
      return;
    }
    if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
      FMT_THROW(FormatError("invalid format specifier for char"));
    typedef typename BasicWriter<Char>::CharPtr CharPtr;
    Char fill = internal::CharTraits<Char>::cast(spec_.fill());
    CharPtr out = CharPtr();
    const unsigned CHAR_SIZE = 1;
    if (spec_.width_ > CHAR_SIZE) {
      out = writer_.grow_buffer(spec_.width_);
      if (spec_.align_ == ALIGN_RIGHT) {
        std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill);
        out += spec_.width_ - CHAR_SIZE;
      } else if (spec_.align_ == ALIGN_CENTER) {
        out = writer_.fill_padding(out, spec_.width_,
                                   internal::const_check(CHAR_SIZE), fill);
      } else {
        std::uninitialized_fill_n(out + CHAR_SIZE,
                                  spec_.width_ - CHAR_SIZE, fill);
      }
    } else {
      out = writer_.grow_buffer(CHAR_SIZE);
    }
    *out = internal::CharTraits<Char>::cast(value);
  }

  void visit_cstring(const char *value) {
    if (spec_.type_ == 'p')
      return write_pointer(value);
    write(value);
  }

  // Qualification with "internal" here and below is a workaround for nvcc.
  void visit_string(internal::Arg::StringValue<char> value) {
    writer_.write_str(value, spec_);
  }

  using ArgVisitor<Impl, void>::visit_wstring;

  void visit_wstring(internal::Arg::StringValue<Char> value) {
    writer_.write_str(value, spec_);
  }

  void visit_pointer(const void *value) {
    if (spec_.type_ && spec_.type_ != 'p')
      report_unknown_type(spec_.type_, "pointer");
    write_pointer(value);
  }
};

class FormatterBase {
 private:
  ArgList args_;
  int next_arg_index_;

  // Returns the argument with specified index.
  FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);

 protected:
  const ArgList &args() const { return args_; }

  explicit FormatterBase(const ArgList &args) {
    args_ = args;
    next_arg_index_ = 0;
  }

  // Returns the next argument.
  Arg next_arg(const char *&error) {
    if (next_arg_index_ >= 0)
      return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
    error = "cannot switch from manual to automatic argument indexing";
    return Arg();
  }

  // Checks if manual indexing is used and returns the argument with
  // specified index.
  Arg get_arg(unsigned arg_index, const char *&error) {
    return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
  }

  bool check_no_auto_index(const char *&error) {
    if (next_arg_index_ > 0) {
      error = "cannot switch from automatic to manual argument indexing";
      return false;
    }
    next_arg_index_ = -1;
    return true;
  }

  template <typename Char>
  void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
    if (start != end)
      w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
  }
};
}  // namespace internal

/**
  \rst
  An argument formatter based on the `curiously recurring template pattern
  <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.

  To use `~fmt::BasicArgFormatter` define a subclass that implements some or
  all of the visit methods with the same signatures as the methods in
  `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`.
  Pass the subclass as the *Impl* template parameter. When a formatting
  function processes an argument, it will dispatch to a visit method
  specific to the argument type. For example, if the argument type is
  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
  will be called. If the subclass doesn't contain a method with this signature,
  then a corresponding method of `~fmt::BasicArgFormatter` or its superclass
  will be called.
  \endrst
 */
template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char, Spec> {
 private:
  BasicFormatter<Char, Impl> &formatter_;
  const Char *format_;

 public:
  /**
    \rst
    Constructs an argument formatter object.
    *formatter* is a reference to the main formatter object, *spec* contains
    format specifier information for standard argument types, and *fmt* points
    to the part of the format string being parsed for custom argument types.
    \endrst
   */
  BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
                    Spec &spec, const Char *fmt)
  : internal::ArgFormatterBase<Impl, Char, Spec>(formatter.writer(), spec),
    formatter_(formatter), format_(fmt) {}

  /** Formats an argument of a custom (user-defined) type. */
  void visit_custom(internal::Arg::CustomValue c) {
    c.format(&formatter_, c.value, &format_);
  }
};

/** The default argument formatter. */
template <typename Char>
class ArgFormatter :
    public BasicArgFormatter<ArgFormatter<Char>, Char, FormatSpec> {
 public:
  /** Constructs an argument formatter object. */
  ArgFormatter(BasicFormatter<Char> &formatter,
               FormatSpec &spec, const Char *fmt)
  : BasicArgFormatter<ArgFormatter<Char>,
                      Char, FormatSpec>(formatter, spec, fmt) {}
};

/** This template formats data and writes the output to a writer. */
template <typename CharType, typename ArgFormatter>
class BasicFormatter : private internal::FormatterBase {
 public:
  /** The character type for the output. */
  typedef CharType Char;

 private:
  BasicWriter<Char> &writer_;
  internal::ArgMap<Char> map_;

  FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);

  using internal::FormatterBase::get_arg;

  // Checks if manual indexing is used and returns the argument with
  // specified name.
  internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);

  // Parses argument index and returns corresponding argument.
  internal::Arg parse_arg_index(const Char *&s);

  // Parses argument name and returns corresponding argument.
  internal::Arg parse_arg_name(const Char *&s);

 public:
  /**
   \rst
   Constructs a ``BasicFormatter`` object. References to the arguments and
   the writer are stored in the formatter object so make sure they have
   appropriate lifetimes.
   \endrst
   */
  BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
    : internal::FormatterBase(args), writer_(w) {}

  /** Returns a reference to the writer associated with this formatter. */
  BasicWriter<Char> &writer() { return writer_; }

  /** Formats stored arguments and writes the output to the writer. */
  void format(BasicCStringRef<Char> format_str);

  // Formats a single argument and advances format_str, a format string pointer.
  const Char *format(const Char *&format_str, const internal::Arg &arg);
};

// Generates a comma-separated list with results of applying f to
// numbers 0..n-1.
# define FMT_GEN(n, f) FMT_GEN##n(f)
# define FMT_GEN1(f)  f(0)
# define FMT_GEN2(f)  FMT_GEN1(f),  f(1)
# define FMT_GEN3(f)  FMT_GEN2(f),  f(2)
# define FMT_GEN4(f)  FMT_GEN3(f),  f(3)
# define FMT_GEN5(f)  FMT_GEN4(f),  f(4)
# define FMT_GEN6(f)  FMT_GEN5(f),  f(5)
# define FMT_GEN7(f)  FMT_GEN6(f),  f(6)
# define FMT_GEN8(f)  FMT_GEN7(f),  f(7)
# define FMT_GEN9(f)  FMT_GEN8(f),  f(8)
# define FMT_GEN10(f) FMT_GEN9(f),  f(9)
# define FMT_GEN11(f) FMT_GEN10(f), f(10)
# define FMT_GEN12(f) FMT_GEN11(f), f(11)
# define FMT_GEN13(f) FMT_GEN12(f), f(12)
# define FMT_GEN14(f) FMT_GEN13(f), f(13)
# define FMT_GEN15(f) FMT_GEN14(f), f(14)

namespace internal {
inline uint64_t make_type() { return 0; }

template <typename T>
inline uint64_t make_type(const T &arg) {
  return MakeValue< BasicFormatter<char> >::type(arg);
}

template <std::size_t N, bool/*IsPacked*/= (N < ArgList::MAX_PACKED_ARGS)>
struct ArgArray;

template <std::size_t N>
struct ArgArray<N, true/*IsPacked*/> {
  // '+' is used to silence GCC -Wduplicated-branches warning.
  typedef Value Type[N > 0 ? N : +1];

  template <typename Formatter, typename T>
  static Value make(const T &value) {
#ifdef __clang__
    Value result = MakeValue<Formatter>(value);
    // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang:
    // https://github.com/fmtlib/fmt/issues/276
    (void)result.custom.format;
    return result;
#else
    return MakeValue<Formatter>(value);
#endif
  }
};

template <std::size_t N>
struct ArgArray<N, false/*IsPacked*/> {
  typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE

  template <typename Formatter, typename T>
  static Arg make(const T &value) { return MakeArg<Formatter>(value); }
};

#if FMT_USE_VARIADIC_TEMPLATES
template <typename Arg, typename... Args>
inline uint64_t make_type(const Arg &first, const Args & ... tail) {
  return make_type(first) | (make_type(tail...) << 4);
}

#else

struct ArgType {
  uint64_t type;

  ArgType() : type(0) {}

  template <typename T>
  ArgType(const T &arg) : type(make_type(arg)) {}
};

# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()

inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
  return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
      (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
      (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
      (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
}
#endif
}  // namespace internal

# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
# define FMT_MAKE_ARG_TYPE(n) T##n
# define FMT_MAKE_ARG(n) const T##n &v##n
# define FMT_ASSIGN_char(n) \
  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)
# define FMT_ASSIGN_wchar_t(n) \
  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)

#if FMT_USE_VARIADIC_TEMPLATES
// Defines a variadic function returning void.
# define FMT_VARIADIC_VOID(func, arg_type) \
  template <typename... Args> \
  void func(arg_type arg0, const Args & ... args) { \
    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
    typename ArgArray::Type array{ \
      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
    func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \
  }

// Defines a variadic constructor.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
  template <typename... Args> \
  ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
    typename ArgArray::Type array{ \
      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
    func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \
  }

#else

# define FMT_MAKE_REF(n) \
  fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
# define FMT_MAKE_REF2(n) v##n

// Defines a wrapper for a function taking one argument of type arg_type
// and n additional arguments of arbitrary types.
# define FMT_WRAP1(func, arg_type, n) \
  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
  inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
    func(arg1, fmt::ArgList( \
      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
  }

// Emulates a variadic function returning void on a pre-C++11 compiler.
# define FMT_VARIADIC_VOID(func, arg_type) \
  inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
  FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
  FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
  FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
  FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
  FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)

# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
  ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
    func(arg0, arg1, fmt::ArgList( \
      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
  }

// Emulates a variadic constructor on a pre-C++11 compiler.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
  FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)
#endif

// Generates a comma-separated list with results of applying f to pairs
// (argument, index).
#define FMT_FOR_EACH1(f, x0) f(x0, 0)
#define FMT_FOR_EACH2(f, x0, x1) \
  FMT_FOR_EACH1(f, x0), f(x1, 1)
#define FMT_FOR_EACH3(f, x0, x1, x2) \
  FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)
#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \
  FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)
#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \
  FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)
#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \
  FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)
#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \
  FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)
#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \
  FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)
#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \
  FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)
#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \
  FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)

/**
 An error returned by an operating system or a language runtime,
 for example a file opening error.
*/
class SystemError : public internal::RuntimeError {
 private:
  FMT_API void init(int err_code, CStringRef format_str, ArgList args);

 protected:
  int error_code_;

  typedef char Char;  // For FMT_VARIADIC_CTOR.

  SystemError() {}

 public:
  /**
   \rst
   Constructs a :class:`fmt::SystemError` object with a description
   formatted with `fmt::format_system_error`. *message* and additional
   arguments passed into the constructor are formatted similarly to
   `fmt::format`.

   **Example**::

     // This throws a SystemError with the description
     //   cannot open file 'madeup': No such file or directory
     // or similar (system message may vary).
     const char *filename = "madeup";
     std::FILE *file = std::fopen(filename, "r");
     if (!file)
       throw fmt::SystemError(errno, "cannot open file '{}'", filename);
   \endrst
  */
  SystemError(int error_code, CStringRef message) {
    init(error_code, message, ArgList());
  }
  FMT_DEFAULTED_COPY_CTOR(SystemError)
  FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)

  FMT_API ~SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;

  int error_code() const { return error_code_; }
};

/**
  \rst
  Formats an error returned by an operating system or a language runtime,
  for example a file opening error, and writes it to *out* in the following
  form:

  .. parsed-literal::
     *<message>*: *<system-message>*

  where *<message>* is the passed message and *<system-message>* is
  the system message corresponding to the error code.
  *error_code* is a system error code as given by ``errno``.
  If *error_code* is not a valid error code such as -1, the system message
  may look like "Unknown error -1" and is platform-dependent.
  \endrst
 */
FMT_API void format_system_error(fmt::Writer &out, int error_code,
                                 fmt::StringRef message) FMT_NOEXCEPT;

/**
  \rst
  This template provides operations for formatting and writing data into
  a character stream. The output is stored in a buffer provided by a subclass
  such as :class:`fmt::BasicMemoryWriter`.

  You can use one of the following typedefs for common character types:

  +---------+----------------------+
  | Type    | Definition           |
  +=========+======================+
  | Writer  | BasicWriter<char>    |
  +---------+----------------------+
  | WWriter | BasicWriter<wchar_t> |
  +---------+----------------------+

  \endrst
 */
template <typename Char>
class BasicWriter {
 private:
  // Output buffer.
  Buffer<Char> &buffer_;

  FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);

  typedef typename internal::CharTraits<Char>::CharPtr CharPtr;

#if FMT_SECURE_SCL
  // Returns pointer value.
  static Char *get(CharPtr p) { return p.base(); }
#else
  static Char *get(Char *p) { return p; }
#endif

  // Fills the padding around the content and returns the pointer to the
  // content area.
  static CharPtr fill_padding(CharPtr buffer,
      unsigned total_size, std::size_t content_size, wchar_t fill);

  // Grows the buffer by n characters and returns a pointer to the newly
  // allocated area.
  CharPtr grow_buffer(std::size_t n) {
    std::size_t size = buffer_.size();
    buffer_.resize(size + n);
    return internal::make_ptr(&buffer_[size], n);
  }

  // Writes an unsigned decimal integer.
  template <typename UInt>
  Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) {
    unsigned num_digits = internal::count_digits(value);
    Char *ptr = get(grow_buffer(prefix_size + num_digits));
    internal::format_decimal(ptr + prefix_size, value, num_digits);
    return ptr;
  }

  // Writes a decimal integer.
  template <typename Int>
  void write_decimal(Int value) {
    typedef typename internal::IntTraits<Int>::MainType MainType;
    MainType abs_value = static_cast<MainType>(value);
    if (internal::is_negative(value)) {
      abs_value = 0 - abs_value;
      *write_unsigned_decimal(abs_value, 1) = '-';
    } else {
      write_unsigned_decimal(abs_value, 0);
    }
  }

  // Prepare a buffer for integer formatting.
  CharPtr prepare_int_buffer(unsigned num_digits,
      const EmptySpec &, const char *prefix, unsigned prefix_size) {
    unsigned size = prefix_size + num_digits;
    CharPtr p = grow_buffer(size);
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    return p + size - 1;
  }

  template <typename Spec>
  CharPtr prepare_int_buffer(unsigned num_digits,
    const Spec &spec, const char *prefix, unsigned prefix_size);

  // Formats an integer.
  template <typename T, typename Spec>
  void write_int(T value, Spec spec);

  // Formats a floating-point number (double or long double).
  template <typename T, typename Spec>
  void write_double(T value, const Spec &spec);

  // Writes a formatted string.
  template <typename StrChar>
  CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);

  template <typename StrChar, typename Spec>
  void write_str(const internal::Arg::StringValue<StrChar> &str,
                 const Spec &spec);

  // This following methods are private to disallow writing wide characters
  // and strings to a char stream. If you want to print a wide string as a
  // pointer as std::ostream does, cast it to const void*.
  // Do not implement!
  void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
  void operator<<(
      typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);

  // Appends floating-point length specifier to the format string.
  // The second argument is only used for overload resolution.
  void append_float_length(Char *&format_ptr, long double) {
    *format_ptr++ = 'L';
  }

  template<typename T>
  void append_float_length(Char *&, T) {}

  template <typename Impl, typename Char_, typename Spec_>
  friend class internal::ArgFormatterBase;

  template <typename Impl, typename Char_, typename Spec_>
  friend class BasicPrintfArgFormatter;

 protected:
  /**
    Constructs a ``BasicWriter`` object.
   */
  explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}

 public:
  /**
    \rst
    Destroys a ``BasicWriter`` object.
    \endrst
   */
  virtual ~BasicWriter() {}

  /**
    Returns the total number of characters written.
   */
  std::size_t size() const { return buffer_.size(); }

  /**
    Returns a pointer to the output buffer content. No terminating null
    character is appended.
   */
  const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; }

  /**
    Returns a pointer to the output buffer content with terminating null
    character appended.
   */
  const Char *c_str() const {
    std::size_t size = buffer_.size();
    buffer_.reserve(size + 1);
    buffer_[size] = '\0';
    return &buffer_[0];
  }

  /**
    \rst
    Returns the content of the output buffer as an `std::string`.
    \endrst
   */
  std::basic_string<Char> str() const {
    return std::basic_string<Char>(&buffer_[0], buffer_.size());
  }

  /**
    \rst
    Writes formatted data.

    *args* is an argument list representing arbitrary arguments.

    **Example**::

       MemoryWriter out;
       out.write("Current point:\n");
       out.write("({:+f}, {:+f})", -3.14, 3.14);

    This will write the following output to the ``out`` object:

    .. code-block:: none

       Current point:
       (-3.140000, +3.140000)

    The output can be accessed using :func:`data()`, :func:`c_str` or
    :func:`str` methods.

    See also :ref:`syntax`.
    \endrst
   */
  void write(BasicCStringRef<Char> format, ArgList args) {
    BasicFormatter<Char>(args, *this).format(format);
  }
  FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)

  BasicWriter &operator<<(int value) {
    write_decimal(value);
    return *this;
  }
  BasicWriter &operator<<(unsigned value) {
    return *this << IntFormatSpec<unsigned>(value);
  }
  BasicWriter &operator<<(long value) {
    write_decimal(value);
    return *this;
  }
  BasicWriter &operator<<(unsigned long value) {
    return *this << IntFormatSpec<unsigned long>(value);
  }
  BasicWriter &operator<<(LongLong value) {
    write_decimal(value);
    return *this;
  }

  /**
    \rst
    Formats *value* and writes it to the stream.
    \endrst
   */
  BasicWriter &operator<<(ULongLong value) {
    return *this << IntFormatSpec<ULongLong>(value);
  }

  BasicWriter &operator<<(double value) {
    write_double(value, FormatSpec());
    return *this;
  }

  /**
    \rst
    Formats *value* using the general format for floating-point numbers
    (``'g'``) and writes it to the stream.
    \endrst
   */
  BasicWriter &operator<<(long double value) {
    write_double(value, FormatSpec());
    return *this;
  }

  /**
    Writes a character to the stream.
   */
  BasicWriter &operator<<(char value) {
    buffer_.push_back(value);
    return *this;
  }

  BasicWriter &operator<<(
      typename internal::WCharHelper<wchar_t, Char>::Supported value) {
    buffer_.push_back(value);
    return *this;
  }

  /**
    \rst
    Writes *value* to the stream.
    \endrst
   */
  BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
    const Char *str = value.data();
    buffer_.append(str, str + value.size());
    return *this;
  }

  BasicWriter &operator<<(
      typename internal::WCharHelper<StringRef, Char>::Supported value) {
    const char *str = value.data();
    buffer_.append(str, str + value.size());
    return *this;
  }

  template <typename T, typename Spec, typename FillChar>
  BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
    internal::CharTraits<Char>::convert(FillChar());
    write_int(spec.value(), spec);
    return *this;
  }

  template <typename StrChar>
  BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
    const StrChar *s = spec.str();
    write_str(s, std::char_traits<Char>::length(s), spec);
    return *this;
  }

  void clear() FMT_NOEXCEPT { buffer_.clear(); }

  Buffer<Char> &buffer() FMT_NOEXCEPT { return buffer_; }
};

template <typename Char>
template <typename StrChar>
typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
      const StrChar *s, std::size_t size, const AlignSpec &spec) {
  CharPtr out = CharPtr();
  if (spec.width() > size) {
    out = grow_buffer(spec.width());
    Char fill = internal::CharTraits<Char>::cast(spec.fill());
    if (spec.align() == ALIGN_RIGHT) {
      std::uninitialized_fill_n(out, spec.width() - size, fill);
      out += spec.width() - size;
    } else if (spec.align() == ALIGN_CENTER) {
      out = fill_padding(out, spec.width(), size, fill);
    } else {
      std::uninitialized_fill_n(out + size, spec.width() - size, fill);
    }
  } else {
    out = grow_buffer(size);
  }
  std::uninitialized_copy(s, s + size, out);
  return out;
}

template <typename Char>
template <typename StrChar, typename Spec>
void BasicWriter<Char>::write_str(
    const internal::Arg::StringValue<StrChar> &s, const Spec &spec) {
  // Check if StrChar is convertible to Char.
  internal::CharTraits<Char>::convert(StrChar());
  if (spec.type_ && spec.type_ != 's')
    internal::report_unknown_type(spec.type_, "string");
  const StrChar *str_value = s.value;
  std::size_t str_size = s.size;
  if (str_size == 0) {
    if (!str_value) {
      FMT_THROW(FormatError("string pointer is null"));
    }
  }
  std::size_t precision = static_cast<std::size_t>(spec.precision_);
  if (spec.precision_ >= 0 && precision < str_size)
    str_size = precision;
  write_str(str_value, str_size, spec);
}

template <typename Char>
typename BasicWriter<Char>::CharPtr
  BasicWriter<Char>::fill_padding(
    CharPtr buffer, unsigned total_size,
    std::size_t content_size, wchar_t fill) {
  std::size_t padding = total_size - content_size;
  std::size_t left_padding = padding / 2;
  Char fill_char = internal::CharTraits<Char>::cast(fill);
  std::uninitialized_fill_n(buffer, left_padding, fill_char);
  buffer += left_padding;
  CharPtr content = buffer;
  std::uninitialized_fill_n(buffer + content_size,
                            padding - left_padding, fill_char);
  return content;
}

template <typename Char>
template <typename Spec>
typename BasicWriter<Char>::CharPtr
  BasicWriter<Char>::prepare_int_buffer(
    unsigned num_digits, const Spec &spec,
    const char *prefix, unsigned prefix_size) {
  unsigned width = spec.width();
  Alignment align = spec.align();
  Char fill = internal::CharTraits<Char>::cast(spec.fill());
  if (spec.precision() > static_cast<int>(num_digits)) {
    // Octal prefix '0' is counted as a digit, so ignore it if precision
    // is specified.
    if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
      --prefix_size;
    unsigned number_size =
        prefix_size + internal::to_unsigned(spec.precision());
    AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
    if (number_size >= width)
      return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
    buffer_.reserve(width);
    unsigned fill_size = width - number_size;
    if (align != ALIGN_LEFT) {
      CharPtr p = grow_buffer(fill_size);
      std::uninitialized_fill(p, p + fill_size, fill);
    }
    CharPtr result = prepare_int_buffer(
        num_digits, subspec, prefix, prefix_size);
    if (align == ALIGN_LEFT) {
      CharPtr p = grow_buffer(fill_size);
      std::uninitialized_fill(p, p + fill_size, fill);
    }
    return result;
  }
  unsigned size = prefix_size + num_digits;
  if (width <= size) {
    CharPtr p = grow_buffer(size);
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    return p + size - 1;
  }
  CharPtr p = grow_buffer(width);
  CharPtr end = p + width;
  if (align == ALIGN_LEFT) {
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    p += size;
    std::uninitialized_fill(p, end, fill);
  } else if (align == ALIGN_CENTER) {
    p = fill_padding(p, width, size, fill);
    std::uninitialized_copy(prefix, prefix + prefix_size, p);
    p += size;
  } else {
    if (align == ALIGN_NUMERIC) {
      if (prefix_size != 0) {
        p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
        size -= prefix_size;
      }
    } else {
      std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
    }
    std::uninitialized_fill(p, end - size, fill);
    p = end;
  }
  return p - 1;
}

template <typename Char>
template <typename T, typename Spec>
void BasicWriter<Char>::write_int(T value, Spec spec) {
  unsigned prefix_size = 0;
  typedef typename internal::IntTraits<T>::MainType UnsignedType;
  UnsignedType abs_value = static_cast<UnsignedType>(value);
  char prefix[4] = "";
  if (internal::is_negative(value)) {
    prefix[0] = '-';
    ++prefix_size;
    abs_value = 0 - abs_value;
  } else if (spec.flag(SIGN_FLAG)) {
    prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
    ++prefix_size;
  }
  switch (spec.type()) {
  case 0: case 'd': {
    unsigned num_digits = internal::count_digits(abs_value);
    CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
    internal::format_decimal(get(p), abs_value, 0);
    break;
  }
  case 'x': case 'X': {
    UnsignedType n = abs_value;
    if (spec.flag(HASH_FLAG)) {
      prefix[prefix_size++] = '0';
      prefix[prefix_size++] = spec.type_prefix();
    }
    unsigned num_digits = 0;
    do {
      ++num_digits;
    } while ((n >>= 4) != 0);
    Char *p = get(prepare_int_buffer(
      num_digits, spec, prefix, prefix_size));
    n = abs_value;
    const char *digits = spec.type() == 'x' ?
        "0123456789abcdef" : "0123456789ABCDEF";
    do {
      *p-- = digits[n & 0xf];
    } while ((n >>= 4) != 0);
    break;
  }
  case 'b': case 'B': {
    UnsignedType n = abs_value;
    if (spec.flag(HASH_FLAG)) {
      prefix[prefix_size++] = '0';
      prefix[prefix_size++] = spec.type_prefix();
    }
    unsigned num_digits = 0;
    do {
      ++num_digits;
    } while ((n >>= 1) != 0);
    Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
    n = abs_value;
    do {
      *p-- = static_cast<Char>('0' + (n & 1));
    } while ((n >>= 1) != 0);
    break;
  }
  case 'o': {
    UnsignedType n = abs_value;
    if (spec.flag(HASH_FLAG))
      prefix[prefix_size++] = '0';
    unsigned num_digits = 0;
    do {
      ++num_digits;
    } while ((n >>= 3) != 0);
    Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
    n = abs_value;
    do {
      *p-- = static_cast<Char>('0' + (n & 7));
    } while ((n >>= 3) != 0);
    break;
  }
  case 'n': {
    unsigned num_digits = internal::count_digits(abs_value);
    fmt::StringRef sep = "";
#if !(defined(ANDROID) || defined(__ANDROID__))
    sep = internal::thousands_sep(std::localeconv());
#endif
    unsigned size = static_cast<unsigned>(
          num_digits + sep.size() * ((num_digits - 1) / 3));
    CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
    internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep));
    break;
  }
  default:
    internal::report_unknown_type(
      spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
    break;
  }
}

template <typename Char>
template <typename T, typename Spec>
void BasicWriter<Char>::write_double(T value, const Spec &spec) {
  // Check type.
  char type = spec.type();
  bool upper = false;
  switch (type) {
  case 0:
    type = 'g';
    break;
  case 'e': case 'f': case 'g': case 'a':
    break;
  case 'F':
#if FMT_MSC_VER
    // MSVC's printf doesn't support 'F'.
    type = 'f';
#endif
    // Fall through.
  case 'E': case 'G': case 'A':
    upper = true;
    break;
  default:
    internal::report_unknown_type(type, "double");
    break;
  }

  char sign = 0;
  // Use isnegative instead of value < 0 because the latter is always
  // false for NaN.
  if (internal::FPUtil::isnegative(static_cast<double>(value))) {
    sign = '-';
    value = -value;
  } else if (spec.flag(SIGN_FLAG)) {
    sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
  }

  if (internal::FPUtil::isnotanumber(value)) {
    // Format NaN ourselves because sprintf's output is not consistent
    // across platforms.
    std::size_t nan_size = 4;
    const char *nan = upper ? " NAN" : " nan";
    if (!sign) {
      --nan_size;
      ++nan;
    }
    CharPtr out = write_str(nan, nan_size, spec);
    if (sign)
      *out = sign;
    return;
  }

  if (internal::FPUtil::isinfinity(value)) {
    // Format infinity ourselves because sprintf's output is not consistent
    // across platforms.
    std::size_t inf_size = 4;
    const char *inf = upper ? " INF" : " inf";
    if (!sign) {
      --inf_size;
      ++inf;
    }
    CharPtr out = write_str(inf, inf_size, spec);
    if (sign)
      *out = sign;
    return;
  }

  std::size_t offset = buffer_.size();
  unsigned width = spec.width();
  if (sign) {
    buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
    if (width > 0)
      --width;
    ++offset;
  }

  // Build format string.
  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
  Char format[MAX_FORMAT_SIZE];
  Char *format_ptr = format;
  *format_ptr++ = '%';
  unsigned width_for_sprintf = width;
  if (spec.flag(HASH_FLAG))
    *format_ptr++ = '#';
  if (spec.align() == ALIGN_CENTER) {
    width_for_sprintf = 0;
  } else {
    if (spec.align() == ALIGN_LEFT)
      *format_ptr++ = '-';
    if (width != 0)
      *format_ptr++ = '*';
  }
  if (spec.precision() >= 0) {
    *format_ptr++ = '.';
    *format_ptr++ = '*';
  }

  append_float_length(format_ptr, value);
  *format_ptr++ = type;
  *format_ptr = '\0';

  // Format using snprintf.
  Char fill = internal::CharTraits<Char>::cast(spec.fill());
  unsigned n = 0;
  Char *start = FMT_NULL;
  for (;;) {
    std::size_t buffer_size = buffer_.capacity() - offset;
#if FMT_MSC_VER
    // MSVC's vsnprintf_s doesn't work with zero size, so reserve
    // space for at least one extra character to make the size non-zero.
    // Note that the buffer's capacity will increase by more than 1.
    if (buffer_size == 0) {
      buffer_.reserve(offset + 1);
      buffer_size = buffer_.capacity() - offset;
    }
#endif
    start = &buffer_[offset];
    int result = internal::CharTraits<Char>::format_float(
        start, buffer_size, format, width_for_sprintf, spec.precision(), value);
    if (result >= 0) {
      n = internal::to_unsigned(result);
      if (offset + n < buffer_.capacity())
        break;  // The buffer is large enough - continue with formatting.
      buffer_.reserve(offset + n + 1);
    } else {
      // If result is negative we ask to increase the capacity by at least 1,
      // but as std::vector, the buffer grows exponentially.
      buffer_.reserve(buffer_.capacity() + 1);
    }
  }
  if (sign) {
    if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
        *start != ' ') {
      *(start - 1) = sign;
      sign = 0;
    } else {
      *(start - 1) = fill;
    }
    ++n;
  }
  if (spec.align() == ALIGN_CENTER && spec.width() > n) {
    width = spec.width();
    CharPtr p = grow_buffer(width);
    std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
    fill_padding(p, spec.width(), n, fill);
    return;
  }
  if (spec.fill() != ' ' || sign) {
    while (*start == ' ')
      *start++ = fill;
    if (sign)
      *(start - 1) = sign;
  }
  grow_buffer(n);
}

/**
  \rst
  This class template provides operations for formatting and writing data
  into a character stream. The output is stored in a memory buffer that grows
  dynamically.

  You can use one of the following typedefs for common character types
  and the standard allocator:

  +---------------+-----------------------------------------------------+
  | Type          | Definition                                          |
  +===============+=====================================================+
  | MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |
  +---------------+-----------------------------------------------------+
  | WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
  +---------------+-----------------------------------------------------+

  **Example**::

     MemoryWriter out;
     out << "The answer is " << 42 << "\n";
     out.write("({:+f}, {:+f})", -3.14, 3.14);

  This will write the following output to the ``out`` object:

  .. code-block:: none

     The answer is 42
     (-3.140000, +3.140000)

  The output can be converted to an ``std::string`` with ``out.str()`` or
  accessed as a C string with ``out.c_str()``.
  \endrst
 */
template <typename Char, typename Allocator = std::allocator<Char> >
class BasicMemoryWriter : public BasicWriter<Char> {
 private:
  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;

 public:
  explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
    : BasicWriter<Char>(buffer_), buffer_(alloc) {}

#if FMT_USE_RVALUE_REFERENCES
  /**
    \rst
    Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
    of the other object to it.
    \endrst
   */
  BasicMemoryWriter(BasicMemoryWriter &&other)
    : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
  }

  /**
    \rst
    Moves the content of the other ``BasicMemoryWriter`` object to this one.
    \endrst
   */
  BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
    buffer_ = std::move(other.buffer_);
    return *this;
  }
#endif
};

typedef BasicMemoryWriter<char> MemoryWriter;
typedef BasicMemoryWriter<wchar_t> WMemoryWriter;

/**
  \rst
  This class template provides operations for formatting and writing data
  into a fixed-size array. For writing into a dynamically growing buffer
  use :class:`fmt::BasicMemoryWriter`.

  Any write method will throw ``std::runtime_error`` if the output doesn't fit
  into the array.

  You can use one of the following typedefs for common character types:

  +--------------+---------------------------+
  | Type         | Definition                |
  +==============+===========================+
  | ArrayWriter  | BasicArrayWriter<char>    |
  +--------------+---------------------------+
  | WArrayWriter | BasicArrayWriter<wchar_t> |
  +--------------+---------------------------+
  \endrst
 */
template <typename Char>
class BasicArrayWriter : public BasicWriter<Char> {
 private:
  internal::FixedBuffer<Char> buffer_;

 public:
  /**
   \rst
   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
   given size.
   \endrst
   */
  BasicArrayWriter(Char *array, std::size_t size)
    : BasicWriter<Char>(buffer_), buffer_(array, size) {}

  /**
   \rst
   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
   size known at compile time.
   \endrst
   */
  template <std::size_t SIZE>
  explicit BasicArrayWriter(Char (&array)[SIZE])
    : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
};

typedef BasicArrayWriter<char> ArrayWriter;
typedef BasicArrayWriter<wchar_t> WArrayWriter;

// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_system_error(int error_code,
                                 StringRef message) FMT_NOEXCEPT;

#if FMT_USE_WINDOWS_H

/** A Windows error. */
class WindowsError : public SystemError {
 private:
  FMT_API void init(int error_code, CStringRef format_str, ArgList args);

 public:
  /**
   \rst
   Constructs a :class:`fmt::WindowsError` object with the description
   of the form

   .. parsed-literal::
     *<message>*: *<system-message>*

   where *<message>* is the formatted message and *<system-message>* is the
   system message corresponding to the error code.
   *error_code* is a Windows error code as given by ``GetLastError``.
   If *error_code* is not a valid error code such as -1, the system message
   will look like "error -1".

   **Example**::

     // This throws a WindowsError with the description
     //   cannot open file 'madeup': The system cannot find the file specified.
     // or similar (system message may vary).
     const char *filename = "madeup";
     LPOFSTRUCT of = LPOFSTRUCT();
     HFILE file = OpenFile(filename, &of, OF_READ);
     if (file == HFILE_ERROR) {
       throw fmt::WindowsError(GetLastError(),
                               "cannot open file '{}'", filename);
     }
   \endrst
  */
  WindowsError(int error_code, CStringRef message) {
    init(error_code, message, ArgList());
  }
  FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
};

// Reports a Windows error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_windows_error(int error_code,
                                  StringRef message) FMT_NOEXCEPT;

#endif

enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };

/**
  Formats a string and prints it to stdout using ANSI escape sequences
  to specify color (experimental).
  Example:
    print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
 */
FMT_API void print_colored(Color c, CStringRef format, ArgList args);

/**
  \rst
  Formats arguments and returns the result as a string.

  **Example**::

    std::string message = format("The answer is {}", 42);
  \endrst
*/
inline std::string format(CStringRef format_str, ArgList args) {
  MemoryWriter w;
  w.write(format_str, args);
  return w.str();
}

inline std::wstring format(WCStringRef format_str, ArgList args) {
  WMemoryWriter w;
  w.write(format_str, args);
  return w.str();
}

/**
  \rst
  Prints formatted data to the file *f*.

  **Example**::

    print(stderr, "Don't {}!", "panic");
  \endrst
 */
FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args);

/**
  \rst
  Prints formatted data to ``stdout``.

  **Example**::

    print("Elapsed time: {0:.2f} seconds", 1.23);
  \endrst
 */
FMT_API void print(CStringRef format_str, ArgList args);

/**
  Fast integer formatter.
 */
class FormatInt {
 private:
  // Buffer should be large enough to hold all digits (digits10 + 1),
  // a sign and a null character.
  enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
  mutable char buffer_[BUFFER_SIZE];
  char *str_;

  // Formats value in reverse and returns the number of digits.
  char *format_decimal(ULongLong value) {
    char *buffer_end = buffer_ + BUFFER_SIZE - 1;
    while (value >= 100) {
      // Integer division is slow so do it for a group of two digits instead
      // of for every digit. The idea comes from the talk by Alexandrescu
      // "Three Optimization Tips for C++". See speed-test for a comparison.
      unsigned index = static_cast<unsigned>((value % 100) * 2);
      value /= 100;
      *--buffer_end = internal::Data::DIGITS[index + 1];
      *--buffer_end = internal::Data::DIGITS[index];
    }
    if (value < 10) {
      *--buffer_end = static_cast<char>('0' + value);
      return buffer_end;
    }
    unsigned index = static_cast<unsigned>(value * 2);
    *--buffer_end = internal::Data::DIGITS[index + 1];
    *--buffer_end = internal::Data::DIGITS[index];
    return buffer_end;
  }

  void FormatSigned(LongLong value) {
    ULongLong abs_value = static_cast<ULongLong>(value);
    bool negative = value < 0;
    if (negative)
      abs_value = 0 - abs_value;
    str_ = format_decimal(abs_value);
    if (negative)
      *--str_ = '-';
  }

 public:
  explicit FormatInt(int value) { FormatSigned(value); }
  explicit FormatInt(long value) { FormatSigned(value); }
  explicit FormatInt(LongLong value) { FormatSigned(value); }
  explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
  explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
  explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}

  /** Returns the number of characters written to the output buffer. */
  std::size_t size() const {
    return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
  }

  /**
    Returns a pointer to the output buffer content. No terminating null
    character is appended.
   */
  const char *data() const { return str_; }

  /**
    Returns a pointer to the output buffer content with terminating null
    character appended.
   */
  const char *c_str() const {
    buffer_[BUFFER_SIZE - 1] = '\0';
    return str_;
  }

  /**
    \rst
    Returns the content of the output buffer as an ``std::string``.
    \endrst
   */
  std::string str() const { return std::string(str_, size()); }
};

// Formats a decimal integer value writing into buffer and returns
// a pointer to the end of the formatted string. This function doesn't
// write a terminating null character.
template <typename T>
inline void format_decimal(char *&buffer, T value) {
  typedef typename internal::IntTraits<T>::MainType MainType;
  MainType abs_value = static_cast<MainType>(value);
  if (internal::is_negative(value)) {
    *buffer++ = '-';
    abs_value = 0 - abs_value;
  }
  if (abs_value < 100) {
    if (abs_value < 10) {
      *buffer++ = static_cast<char>('0' + abs_value);
      return;
    }
    unsigned index = static_cast<unsigned>(abs_value * 2);
    *buffer++ = internal::Data::DIGITS[index];
    *buffer++ = internal::Data::DIGITS[index + 1];
    return;
  }
  unsigned num_digits = internal::count_digits(abs_value);
  internal::format_decimal(buffer, abs_value, num_digits);
  buffer += num_digits;
}

/**
  \rst
  Returns a named argument for formatting functions.

  **Example**::

    print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));

  \endrst
 */
template <typename T>
inline internal::NamedArgWithType<char, T> arg(StringRef name, const T &arg) {
  return internal::NamedArgWithType<char, T>(name, arg);
}

template <typename T>
inline internal::NamedArgWithType<wchar_t, T> arg(WStringRef name, const T &arg) {
  return internal::NamedArgWithType<wchar_t, T>(name, arg);
}

// The following two functions are deleted intentionally to disable
// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.
template <typename Char>
void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
template <typename Char>
void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
}

#if FMT_GCC_VERSION
// Use the system_header pragma to suppress warnings about variadic macros
// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't
// work. It is used at the end because we want to suppress as little warnings
// as possible.
# pragma GCC system_header
#endif

// This is used to work around VC++ bugs in handling variadic macros.
#define FMT_EXPAND(args) args

// Returns the number of arguments.
// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s.
#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

#define FMT_FOR_EACH_(N, f, ...) \
  FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))
#define FMT_FOR_EACH(f, ...) \
  FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))

#define FMT_ADD_ARG_NAME(type, index) type arg##index
#define FMT_GET_ARG_NAME(type, index) arg##index

#if FMT_USE_VARIADIC_TEMPLATES
# define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \
  template <typename... Args> \
  ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
      const Args & ... args) Const { \
    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
    typename ArgArray::Type array{ \
      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
      fmt::ArgList(fmt::internal::make_type(args...), array)); \
  }
#else
// Defines a wrapper for a function taking __VA_ARGS__ arguments
// and n additional arguments of arbitrary types.
# define FMT_WRAP(Const, Char, ReturnType, func, call, n, ...) \
  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
      FMT_GEN(n, FMT_MAKE_ARG)) Const { \
    fmt::internal::ArgArray<n>::Type arr; \
    FMT_GEN(n, FMT_ASSIGN_##Char); \
    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
  }

# define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \
  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) Const { \
    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
  } \
  FMT_WRAP(Const, Char, ReturnType, func, call, 1, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 2, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 3, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 4, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 5, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 6, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 7, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 8, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 9, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 10, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 11, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 12, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 13, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 14, __VA_ARGS__) \
  FMT_WRAP(Const, Char, ReturnType, func, call, 15, __VA_ARGS__)
#endif  // FMT_USE_VARIADIC_TEMPLATES

/**
  \rst
  Defines a variadic function with the specified return type, function name
  and argument types passed as variable arguments to this macro.

  **Example**::

    void print_error(const char *file, int line, const char *format,
                     fmt::ArgList args) {
      fmt::print("{}: {}: ", file, line);
      fmt::print(format, args);
    }
    FMT_VARIADIC(void, print_error, const char *, int, const char *)

  ``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
  don't implement variadic templates. You don't have to use this macro if
  you don't need legacy compiler support and can use variadic templates
  directly::

    template <typename... Args>
    void print_error(const char *file, int line, const char *format,
                     const Args & ... args) {
      fmt::print("{}: {}: ", file, line);
      fmt::print(format, args...);
    }
  \endrst
 */
#define FMT_VARIADIC(ReturnType, func, ...) \
  FMT_VARIADIC_(, char, ReturnType, func, return func, __VA_ARGS__)

#define FMT_VARIADIC_CONST(ReturnType, func, ...) \
  FMT_VARIADIC_(const, char, ReturnType, func, return func, __VA_ARGS__)

#define FMT_VARIADIC_W(ReturnType, func, ...) \
  FMT_VARIADIC_(, wchar_t, ReturnType, func, return func, __VA_ARGS__)

#define FMT_VARIADIC_CONST_W(ReturnType, func, ...) \
  FMT_VARIADIC_(const, wchar_t, ReturnType, func, return func, __VA_ARGS__)

#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)

#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)

/**
  \rst
  Convenient macro to capture the arguments' names and values into several
  ``fmt::arg(name, value)``.

  **Example**::

    int x = 1, y = 2;
    print("point: ({x}, {y})", FMT_CAPTURE(x, y));
    // same as:
    // print("point: ({x}, {y})", arg("x", x), arg("y", y));

  \endrst
 */
#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)

#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)

namespace fmt {
FMT_VARIADIC(std::string, format, CStringRef)
FMT_VARIADIC_W(std::wstring, format, WCStringRef)
FMT_VARIADIC(void, print, CStringRef)
FMT_VARIADIC(void, print, std::FILE *, CStringRef)
FMT_VARIADIC(void, print_colored, Color, CStringRef)

namespace internal {
template <typename Char>
inline bool is_name_start(Char c) {
  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
}

// Parses an unsigned integer advancing s to the end of the parsed input.
// This function assumes that the first character of s is a digit.
template <typename Char>
unsigned parse_nonnegative_int(const Char *&s) {
  assert('0' <= *s && *s <= '9');
  unsigned value = 0;
  // Convert to unsigned to prevent a warning.
  unsigned max_int = (std::numeric_limits<int>::max)();
  unsigned big = max_int / 10;
  do {
    // Check for overflow.
    if (value > big) {
      value = max_int + 1;
      break;
    }
    value = value * 10 + (*s - '0');
    ++s;
  } while ('0' <= *s && *s <= '9');
  // Convert to unsigned to prevent a warning.
  if (value > max_int)
    FMT_THROW(FormatError("number is too big"));
  return value;
}

inline void require_numeric_argument(const Arg &arg, char spec) {
  if (arg.type > Arg::LAST_NUMERIC_TYPE) {
    std::string message =
        fmt::format("format specifier '{}' requires numeric argument", spec);
    FMT_THROW(fmt::FormatError(message));
  }
}

template <typename Char>
void check_sign(const Char *&s, const Arg &arg) {
  char sign = static_cast<char>(*s);
  require_numeric_argument(arg, sign);
  if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
    FMT_THROW(FormatError(fmt::format(
      "format specifier '{}' requires signed argument", sign)));
  }
  ++s;
}
}  // namespace internal

template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::get_arg(
    BasicStringRef<Char> arg_name, const char *&error) {
  if (check_no_auto_index(error)) {
    map_.init(args());
    const internal::Arg *arg = map_.find(arg_name);
    if (arg)
      return *arg;
    error = "argument not found";
  }
  return internal::Arg();
}

template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s) {
  const char *error = FMT_NULL;
  internal::Arg arg = *s < '0' || *s > '9' ?
        next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
  if (error) {
    FMT_THROW(FormatError(
                *s != '}' && *s != ':' ? "invalid format string" : error));
  }
  return arg;
}

template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s) {
  assert(internal::is_name_start(*s));
  const Char *start = s;
  Char c;
  do {
    c = *++s;
  } while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
  const char *error = FMT_NULL;
  internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
  if (error)
    FMT_THROW(FormatError(error));
  return arg;
}

template <typename Char, typename ArgFormatter>
const Char *BasicFormatter<Char, ArgFormatter>::format(
    const Char *&format_str, const internal::Arg &arg) {
  using internal::Arg;
  const Char *s = format_str;
  typename ArgFormatter::SpecType spec;
  if (*s == ':') {
    if (arg.type == Arg::CUSTOM) {
      arg.custom.format(this, arg.custom.value, &s);
      return s;
    }
    ++s;
    // Parse fill and alignment.
    if (Char c = *s) {
      const Char *p = s + 1;
      spec.align_ = ALIGN_DEFAULT;
      do {
        switch (*p) {
          case '<':
            spec.align_ = ALIGN_LEFT;
            break;
          case '>':
            spec.align_ = ALIGN_RIGHT;
            break;
          case '=':
            spec.align_ = ALIGN_NUMERIC;
            break;
          case '^':
            spec.align_ = ALIGN_CENTER;
            break;
        }
        if (spec.align_ != ALIGN_DEFAULT) {
          if (p != s) {
            if (c == '}') break;
            if (c == '{')
              FMT_THROW(FormatError("invalid fill character '{'"));
            s += 2;
            spec.fill_ = c;
          } else ++s;
          if (spec.align_ == ALIGN_NUMERIC)
            require_numeric_argument(arg, '=');
          break;
        }
      } while (--p >= s);
    }

    // Parse sign.
    switch (*s) {
      case '+':
        check_sign(s, arg);
        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
        break;
      case '-':
        check_sign(s, arg);
        spec.flags_ |= MINUS_FLAG;
        break;
      case ' ':
        check_sign(s, arg);
        spec.flags_ |= SIGN_FLAG;
        break;
    }

    if (*s == '#') {
      require_numeric_argument(arg, '#');
      spec.flags_ |= HASH_FLAG;
      ++s;
    }

    // Parse zero flag.
    if (*s == '0') {
      require_numeric_argument(arg, '0');
      spec.align_ = ALIGN_NUMERIC;
      spec.fill_ = '0';
      ++s;
    }

    // Parse width.
    if ('0' <= *s && *s <= '9') {
      spec.width_ = internal::parse_nonnegative_int(s);
    } else if (*s == '{') {
      ++s;
      Arg width_arg = internal::is_name_start(*s) ?
            parse_arg_name(s) : parse_arg_index(s);
      if (*s++ != '}')
        FMT_THROW(FormatError("invalid format string"));
      ULongLong value = 0;
      switch (width_arg.type) {
      case Arg::INT:
        if (width_arg.int_value < 0)
          FMT_THROW(FormatError("negative width"));
        value = width_arg.int_value;
        break;
      case Arg::UINT:
        value = width_arg.uint_value;
        break;
      case Arg::LONG_LONG:
        if (width_arg.long_long_value < 0)
          FMT_THROW(FormatError("negative width"));
        value = width_arg.long_long_value;
        break;
      case Arg::ULONG_LONG:
        value = width_arg.ulong_long_value;
        break;
      default:
        FMT_THROW(FormatError("width is not integer"));
      }
      unsigned max_int = (std::numeric_limits<int>::max)();
      if (value > max_int)
        FMT_THROW(FormatError("number is too big"));
      spec.width_ = static_cast<int>(value);
    }

    // Parse precision.
    if (*s == '.') {
      ++s;
      spec.precision_ = 0;
      if ('0' <= *s && *s <= '9') {
        spec.precision_ = internal::parse_nonnegative_int(s);
      } else if (*s == '{') {
        ++s;
        Arg precision_arg = internal::is_name_start(*s) ?
              parse_arg_name(s) : parse_arg_index(s);
        if (*s++ != '}')
          FMT_THROW(FormatError("invalid format string"));
        ULongLong value = 0;
        switch (precision_arg.type) {
          case Arg::INT:
            if (precision_arg.int_value < 0)
              FMT_THROW(FormatError("negative precision"));
            value = precision_arg.int_value;
            break;
          case Arg::UINT:
            value = precision_arg.uint_value;
            break;
          case Arg::LONG_LONG:
            if (precision_arg.long_long_value < 0)
              FMT_THROW(FormatError("negative precision"));
            value = precision_arg.long_long_value;
            break;
          case Arg::ULONG_LONG:
            value = precision_arg.ulong_long_value;
            break;
          default:
            FMT_THROW(FormatError("precision is not integer"));
        }
        unsigned max_int = (std::numeric_limits<int>::max)();
        if (value > max_int)
          FMT_THROW(FormatError("number is too big"));
        spec.precision_ = static_cast<int>(value);
      } else {
        FMT_THROW(FormatError("missing precision specifier"));
      }
      if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
        FMT_THROW(FormatError(
            fmt::format("precision not allowed in {} format specifier",
            arg.type == Arg::POINTER ? "pointer" : "integer")));
      }
    }

    // Parse type.
    if (*s != '}' && *s)
      spec.type_ = static_cast<char>(*s++);
  }

  if (*s++ != '}')
    FMT_THROW(FormatError("missing '}' in format string"));

  // Format argument.
  ArgFormatter(*this, spec, s - 1).visit(arg);
  return s;
}

template <typename Char, typename AF>
void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
  const Char *s = format_str.c_str();
  const Char *start = s;
  while (*s) {
    Char c = *s++;
    if (c != '{' && c != '}') continue;
    if (*s == c) {
      write(writer_, start, s);
      start = ++s;
      continue;
    }
    if (c == '}')
      FMT_THROW(FormatError("unmatched '}' in format string"));
    write(writer_, start, s - 1);
    internal::Arg arg = internal::is_name_start(*s) ?
          parse_arg_name(s) : parse_arg_index(s);
    start = s = format(s, arg);
  }
  write(writer_, start, s);
}

template <typename Char, typename It>
struct ArgJoin {
  It first;
  It last;
  BasicCStringRef<Char> sep;

  ArgJoin(It first, It last, const BasicCStringRef<Char>& sep) :
    first(first),
    last(last),
    sep(sep) {}
};

template <typename It>
ArgJoin<char, It> join(It first, It last, const BasicCStringRef<char>& sep) {
  return ArgJoin<char, It>(first, last, sep);
}

template <typename It>
ArgJoin<wchar_t, It> join(It first, It last, const BasicCStringRef<wchar_t>& sep) {
  return ArgJoin<wchar_t, It>(first, last, sep);
}

#if FMT_HAS_GXX_CXX11
template <typename Range>
auto join(const Range& range, const BasicCStringRef<char>& sep)
    -> ArgJoin<char, decltype(std::begin(range))> {
  return join(std::begin(range), std::end(range), sep);
}

template <typename Range>
auto join(const Range& range, const BasicCStringRef<wchar_t>& sep)
    -> ArgJoin<wchar_t, decltype(std::begin(range))> {
  return join(std::begin(range), std::end(range), sep);
}
#endif

template <typename ArgFormatter, typename Char, typename It>
void format_arg(fmt::BasicFormatter<Char, ArgFormatter> &f,
    const Char *&format_str, const ArgJoin<Char, It>& e) {
  const Char* end = format_str;
  if (*end == ':')
    ++end;
  while (*end && *end != '}')
    ++end;
  if (*end != '}')
    FMT_THROW(FormatError("missing '}' in format string"));

  It it = e.first;
  if (it != e.last) {
    const Char* save = format_str;
    f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
    while (it != e.last) {
      f.writer().write(e.sep);
      format_str = save;
      f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
    }
  }
  format_str = end + 1;
}
}  // namespace fmt

#if FMT_USE_USER_DEFINED_LITERALS
namespace fmt {
namespace internal {

template <typename Char>
struct UdlFormat {
  const Char *str;

  template <typename... Args>
  auto operator()(Args && ... args) const
                  -> decltype(format(str, std::forward<Args>(args)...)) {
    return format(str, std::forward<Args>(args)...);
  }
};

template <typename Char>
struct UdlArg {
  const Char *str;

  template <typename T>
  NamedArgWithType<Char, T> operator=(T &&value) const {
    return {str, std::forward<T>(value)};
  }
};

} // namespace internal

inline namespace literals {

/**
  \rst
  C++11 literal equivalent of :func:`fmt::format`.

  **Example**::

    using namespace fmt::literals;
    std::string message = "The answer is {}"_format(42);
  \endrst
 */
inline internal::UdlFormat<char>
operator"" _format(const char *s, std::size_t) { return {s}; }
inline internal::UdlFormat<wchar_t>
operator"" _format(const wchar_t *s, std::size_t) { return {s}; }

/**
  \rst
  C++11 literal equivalent of :func:`fmt::arg`.

  **Example**::

    using namespace fmt::literals;
    print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
  \endrst
 */
inline internal::UdlArg<char>
operator"" _a(const char *s, std::size_t) { return {s}; }
inline internal::UdlArg<wchar_t>
operator"" _a(const wchar_t *s, std::size_t) { return {s}; }

} // inline namespace literals
} // namespace fmt
#endif // FMT_USE_USER_DEFINED_LITERALS

// Restore warnings.
#if FMT_GCC_VERSION >= 406
# pragma GCC diagnostic pop
#endif

#if defined(__clang__) && !defined(FMT_ICC_VERSION)
# pragma clang diagnostic pop
#endif

#ifdef FMT_HEADER_ONLY
# define FMT_FUNC inline
# include "format.cc"
#else
# define FMT_FUNC
#endif

#endif  // FMT_FORMAT_H_


================================================
FILE: lib/fmt/orig/ostream.cc
================================================
/*
 Formatting library for C++ - std::ostream support

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#include "ostream.h"

namespace fmt {

namespace internal {
FMT_FUNC void write(std::ostream &os, Writer &w) {
  const char *data = w.data();
  typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
  UnsignedStreamSize size = w.size();
  UnsignedStreamSize max_size =
      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
  do {
    UnsignedStreamSize n = size <= max_size ? size : max_size;
    os.write(data, static_cast<std::streamsize>(n));
    data += n;
    size -= n;
  } while (size != 0);
}
}

FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) {
  MemoryWriter w;
  w.write(format_str, args);
  internal::write(os, w);
}
}  // namespace fmt


================================================
FILE: lib/fmt/orig/ostream.h
================================================
/*
 Formatting library for C++ - std::ostream support

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_OSTREAM_H_
#define FMT_OSTREAM_H_

#include "format.h"
#include <ostream>

namespace fmt {

namespace internal {

template <class Char>
class FormatBuf : public std::basic_streambuf<Char> {
 private:
  typedef typename std::basic_streambuf<Char>::int_type int_type;
  typedef typename std::basic_streambuf<Char>::traits_type traits_type;

  Buffer<Char> &buffer_;

 public:
  FormatBuf(Buffer<Char> &buffer) : buffer_(buffer) {}

 protected:
  // The put-area is actually always empty. This makes the implementation
  // simpler and has the advantage that the streambuf and the buffer are always
  // in sync and sputc never writes into uninitialized memory. The obvious
  // disadvantage is that each call to sputc always results in a (virtual) call
  // to overflow. There is no disadvantage here for sputn since this always
  // results in a call to xsputn.

  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
    if (!traits_type::eq_int_type(ch, traits_type::eof()))
      buffer_.push_back(static_cast<Char>(ch));
    return ch;
  }

  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
    buffer_.append(s, s + count);
    return count;
  }
};

Yes &convert(std::ostream &);

struct DummyStream : std::ostream {
  DummyStream();  // Suppress a bogus warning in MSVC.

  // Hide all operator<< overloads from std::ostream.
  template <typename T>
  typename EnableIf<sizeof(T) == 0>::type operator<<(const T &);
};

No &operator<<(std::ostream &, int);

template <typename T>
struct ConvertToIntImpl<T, true> {
  // Convert to int only if T doesn't have an overloaded operator<<.
  enum {
    value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
  };
};

// Write the content of w to os.
FMT_API void write(std::ostream &os, Writer &w);
}  // namespace internal

// Formats a value.
template <typename Char, typename ArgFormatter_, typename T>
void format_arg(BasicFormatter<Char, ArgFormatter_> &f,
                const Char *&format_str, const T &value) {
  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;

  internal::FormatBuf<Char> format_buf(buffer);
  std::basic_ostream<Char> output(&format_buf);
  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
  output << value;

  BasicStringRef<Char> str(&buffer[0], buffer.size());
  typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
  format_str = f.format(format_str, MakeArg(str));
}

/**
  \rst
  Prints formatted data to the stream *os*.

  **Example**::

    print(cerr, "Don't {}!", "panic");
  \endrst
 */
FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
FMT_VARIADIC(void, print, std::ostream &, CStringRef)
}  // namespace fmt

#ifdef FMT_HEADER_ONLY
# include "ostream.cc"
#endif

#endif  // FMT_OSTREAM_H_


================================================
FILE: lib/fmt/orig/posix.cc
================================================
/*
 A C++ interface to POSIX functions.

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

// Disable bogus MSVC warnings.
#ifndef _CRT_SECURE_NO_WARNINGS
# define _CRT_SECURE_NO_WARNINGS
#endif

#include "posix.h"

#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>

#ifndef _WIN32
# include <unistd.h>
#else
# ifndef WIN32_LEAN_AND_MEAN
#  define WIN32_LEAN_AND_MEAN
# endif
# include <windows.h>
# include <io.h>

# define O_CREAT _O_CREAT
# define O_TRUNC _O_TRUNC

# ifndef S_IRUSR
#  define S_IRUSR _S_IREAD
# endif

# ifndef S_IWUSR
#  define S_IWUSR _S_IWRITE
# endif

# ifdef __MINGW32__
#  define _SH_DENYNO 0x40
# endif

#endif  // _WIN32

#ifdef fileno
# undef fileno
#endif

namespace {
#ifdef _WIN32
// Return type of read and write functions.
typedef int RWResult;

// On Windows the count argument to read and write is unsigned, so convert
// it from size_t preventing integer overflow.
inline unsigned convert_rwcount(std::size_t count) {
  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
}
#else
// Return type of read and write functions.
typedef ssize_t RWResult;

inline std::size_t convert_rwcount(std::size_t count) { return count; }
#endif
}

fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT {
  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
    fmt::report_system_error(errno, "cannot close file");
}

fmt::BufferedFile::BufferedFile(
    fmt::CStringRef filename, fmt::CStringRef mode) {
  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 0);
  if (!file_)
    FMT_THROW(SystemError(errno, "cannot open file {}", filename));
}

void fmt::BufferedFile::close() {
  if (!file_)
    return;
  int result = FMT_SYSTEM(fclose(file_));
  file_ = FMT_NULL;
  if (result != 0)
    FMT_THROW(SystemError(errno, "cannot close file"));
}

// A macro used to prevent expansion of fileno on broken versions of MinGW.
#define FMT_ARGS

int fmt::BufferedFile::fileno() const {
  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
  if (fd == -1)
    FMT_THROW(SystemError(errno, "cannot get file descriptor"));
  return fd;
}

fmt::File::File(fmt::CStringRef path, int oflag) {
  int mode = S_IRUSR | S_IWUSR;
#if defined(_WIN32) && !defined(__MINGW32__)
  fd_ = -1;
  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
#else
  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
#endif
  if (fd_ == -1)
    FMT_THROW(SystemError(errno, "cannot open file {}", path));
}

fmt::File::~File() FMT_NOEXCEPT {
  // Don't retry close in case of EINTR!
  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
    fmt::report_system_error(errno, "cannot close file");
}

void fmt::File::close() {
  if (fd_ == -1)
    return;
  // Don't retry close in case of EINTR!
  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
  int result = FMT_POSIX_CALL(close(fd_));
  fd_ = -1;
  if (result != 0)
    FMT_THROW(SystemError(errno, "cannot close file"));
}

fmt::LongLong fmt::File::size() const {
#ifdef _WIN32
  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
  // is less than 0x0500 as is the case with some default MinGW builds.
  // Both functions support large file sizes.
  DWORD size_upper = 0;
  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
  if (size_lower == INVALID_FILE_SIZE) {
    DWORD error = GetLastError();
    if (error != NO_ERROR)
      FMT_THROW(WindowsError(GetLastError(), "cannot get file size"));
  }
  fmt::ULongLong long_size = size_upper;
  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
#else
  typedef struct stat Stat;
  Stat file_stat = Stat();
  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
    FMT_THROW(SystemError(errno, "cannot get file attributes"));
  FMT_STATIC_ASSERT(sizeof(fmt::LongLong) >= sizeof(file_stat.st_size),
      "return type of File::size is not large enough");
  return file_stat.st_size;
#endif
}

std::size_t fmt::File::read(void *buffer, std::size_t count) {
  RWResult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
  if (result < 0)
    FMT_THROW(SystemError(errno, "cannot read from file"));
  return internal::to_unsigned(result);
}

std::size_t fmt::File::write(const void *buffer, std::size_t count) {
  RWResult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
  if (result < 0)
    FMT_THROW(SystemError(errno, "cannot write to file"));
  return internal::to_unsigned(result);
}

fmt::File fmt::File::dup(int fd) {
  // Don't retry as dup doesn't return EINTR.
  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
  int new_fd = FMT_POSIX_CALL(dup(fd));
  if (new_fd == -1)
    FMT_THROW(SystemError(errno, "cannot duplicate file descriptor {}", fd));
  return File(new_fd);
}

void fmt::File::dup2(int fd) {
  int result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
  if (result == -1) {
    FMT_THROW(SystemError(errno,
      "cannot duplicate file descriptor {} to {}", fd_, fd));
  }
}

void fmt::File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT {
  int result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
  if (result == -1)
    ec = ErrorCode(errno);
}

void fmt::File::pipe(File &read_end, File &write_end) {
  // Close the descriptors first to make sure that assignments don't throw
  // and there are no leaks.
  read_end.close();
  write_end.close();
  int fds[2] = {};
#ifdef _WIN32
  // Make the default pipe capacity same as on Linux 2.6.11+.
  enum { DEFAULT_CAPACITY = 65536 };
  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
#else
  // Don't retry as the pipe function doesn't return EINTR.
  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
  int result = FMT_POSIX_CALL(pipe(fds));
#endif
  if (result != 0)
    FMT_THROW(SystemError(errno, "cannot create pipe"));
  // The following assignments don't throw because read_fd and write_fd
  // are closed.
  read_end = File(fds[0]);
  write_end = File(fds[1]);
}

fmt::BufferedFile fmt::File::fdopen(const char *mode) {
  // Don't retry as fdopen doesn't return EINTR.
  FILE *f = FMT_POSIX_CALL(fdopen(fd_, mode));
  if (!f)
    FMT_THROW(SystemError(errno, "cannot associate stream with file descriptor"));
  BufferedFile file(f);
  fd_ = -1;
  return file;
}

long fmt::getpagesize() {
#ifdef _WIN32
  SYSTEM_INFO si;
  GetSystemInfo(&si);
  return si.dwPageSize;
#else
  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
  if (size < 0)
    FMT_THROW(SystemError(errno, "cannot get memory page size"));
  return size;
#endif
}


================================================
FILE: lib/fmt/orig/posix.h
================================================
/*
 A C++ interface to POSIX functions.

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_POSIX_H_
#define FMT_POSIX_H_

#if defined(__MINGW32__) || defined(__CYGWIN__)
// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
# undef __STRICT_ANSI__
#endif

#include <errno.h>
#include <fcntl.h>   // for O_RDONLY
#include <locale.h>  // for locale_t
#include <stdio.h>
#include <stdlib.h>  // for strtod_l

#include <cstddef>

#if defined __APPLE__ || defined(__FreeBSD__)
# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
#endif

#include "format.h"

#ifndef FMT_POSIX
# if defined(_WIN32) && !defined(__MINGW32__)
// Fix warnings about deprecated symbols.
#  define FMT_POSIX(call) _##call
# else
#  define FMT_POSIX(call) call
# endif
#endif

// Calls to system functions are wrapped in FMT_SYSTEM for testability.
#ifdef FMT_SYSTEM
# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#else
# define FMT_SYSTEM(call) call
# ifdef _WIN32
// Fix warnings about deprecated symbols.
#  define FMT_POSIX_CALL(call) ::_##call
# else
#  define FMT_POSIX_CALL(call) ::call
# endif
#endif

// Retries the expression while it evaluates to error_result and errno
// equals to EINTR.
#ifndef _WIN32
# define FMT_RETRY_VAL(result, expression, error_result) \
  do { \
    result = (expression); \
  } while (result == error_result && errno == EINTR)
#else
# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
#endif

#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)

namespace fmt {

// An error code.
class ErrorCode {
 private:
  int value_;

 public:
  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}

  int get() const FMT_NOEXCEPT { return value_; }
};

// A buffered file.
class BufferedFile {
 private:
  FILE *file_;

  friend class File;

  explicit BufferedFile(FILE *f) : file_(f) {}

 public:
  // Constructs a BufferedFile object which doesn't represent any file.
  BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {}

  // Destroys the object closing the file it represents if any.
  FMT_API ~BufferedFile() FMT_NOEXCEPT;

#if !FMT_USE_RVALUE_REFERENCES
  // Emulate a move constructor and a move assignment operator if rvalue
  // references are not supported.

 private:
  // A proxy object to emulate a move constructor.
  // It is private to make it impossible call operator Proxy directly.
  struct Proxy {
    FILE *file;
  };

public:
  // A "move constructor" for moving from a temporary.
  BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {}

  // A "move constructor" for moving from an lvalue.
  BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) {
    f.file_ = FMT_NULL;
  }

  // A "move assignment operator" for moving from a temporary.
  BufferedFile &operator=(Proxy p) {
    close();
    file_ = p.file;
    return *this;
  }

  // A "move assignment operator" for moving from an lvalue.
  BufferedFile &operator=(BufferedFile &other) {
    close();
    file_ = other.file_;
    other.file_ = FMT_NULL;
    return *this;
  }

  // Returns a proxy object for moving from a temporary:
  //   BufferedFile file = BufferedFile(...);
  operator Proxy() FMT_NOEXCEPT {
    Proxy p = {file_};
    file_ = FMT_NULL;
    return p;
  }

#else
 private:
  FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);

 public:
  BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) {
    other.file_ = FMT_NULL;
  }

  BufferedFile& operator=(BufferedFile &&other) {
    close();
    file_ = other.file_;
    other.file_ = FMT_NULL;
    return *this;
  }
#endif

  // Opens a file.
  FMT_API BufferedFile(CStringRef filename, CStringRef mode);

  // Closes the file.
  FMT_API void close();

  // Returns the pointer to a FILE object representing this file.
  FILE *get() const FMT_NOEXCEPT { return file_; }

  // We place parentheses around fileno to workaround a bug in some versions
  // of MinGW that define fileno as a macro.
  FMT_API int (fileno)() const;

  void print(CStringRef format_str, const ArgList &args) {
    fmt::print(file_, format_str, args);
  }
  FMT_VARIADIC(void, print, CStringRef)
};

// A file. Closed file is represented by a File object with descriptor -1.
// Methods that are not declared with FMT_NOEXCEPT may throw
// fmt::SystemError in case of failure. Note that some errors such as
// closing the file multiple times will cause a crash on Windows rather
// than an exception. You can get standard behavior by overriding the
// invalid parameter handler with _set_invalid_parameter_handler.
class File {
 private:
  int fd_;  // File descriptor.

  // Constructs a File object with a given descriptor.
  explicit File(int fd) : fd_(fd) {}

 public:
  // Possible values for the oflag argument to the constructor.
  enum {
    RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
    WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
    RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
  };

  // Constructs a File object which doesn't represent any file.
  File() FMT_NOEXCEPT : fd_(-1) {}

  // Opens a file and constructs a File object representing this file.
  FMT_API File(CStringRef path, int oflag);

#if !FMT_USE_RVALUE_REFERENCES
  // Emulate a move constructor and a move assignment operator if rvalue
  // references are not supported.

 private:
  // A proxy object to emulate a move constructor.
  // It is private to make it impossible call operator Proxy directly.
  struct Proxy {
    int fd;
  };

 public:
  // A "move constructor" for moving from a temporary.
  File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}

  // A "move constructor" for moving from an lvalue.
  File(File &other) FMT_NOEXCEPT : fd_(other.fd_) {
    other.fd_ = -1;
  }

  // A "move assignment operator" for moving from a temporary.
  File &operator=(Proxy p) {
    close();
    fd_ = p.fd;
    return *this;
  }

  // A "move assignment operator" for moving from an lvalue.
  File &operator=(File &other) {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
    return *this;
  }

  // Returns a proxy object for moving from a temporary:
  //   File file = File(...);
  operator Proxy() FMT_NOEXCEPT {
    Proxy p = {fd_};
    fd_ = -1;
    return p;
  }

#else
 private:
  FMT_DISALLOW_COPY_AND_ASSIGN(File);

 public:
  File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) {
    other.fd_ = -1;
  }

  File& operator=(File &&other) {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
    return *this;
  }
#endif

  // Destroys the object closing the file it represents if any.
  FMT_API ~File() FMT_NOEXCEPT;

  // Returns the file descriptor.
  int descriptor() const FMT_NOEXCEPT { return fd_; }

  // Closes the file.
  FMT_API void close();

  // Returns the file size. The size has signed type for consistency with
  // stat::st_size.
  FMT_API LongLong size() const;

  // Attempts to read count bytes from the file into the specified buffer.
  FMT_API std::size_t read(void *buffer, std::size_t count);

  // Attempts to write count bytes from the specified buffer to the file.
  FMT_API std::size_t write(const void *buffer, std::size_t count);

  // Duplicates a file descriptor with the dup function and returns
  // the duplicate as a file object.
  FMT_API static File dup(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
  FMT_API void dup2(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
  FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;

  // Creates a pipe setting up read_end and write_end file objects for reading
  // and writing respectively.
  FMT_API static void pipe(File &read_end, File &write_end);

  // Creates a BufferedFile object associated with this file and detaches
  // this File object from the file.
  FMT_API BufferedFile fdopen(const char *mode);
};

// Returns the memory page size.
long getpagesize();

#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
    !defined(__ANDROID__) && !defined(__CYGWIN__)
# define FMT_LOCALE
#endif

#ifdef FMT_LOCALE
// A "C" numeric locale.
class Locale {
 private:
# ifdef _MSC_VER
  typedef _locale_t locale_t;

  enum { LC_NUMERIC_MASK = LC_NUMERIC };

  static locale_t newlocale(int category_mask, const char *locale, locale_t) {
    return _create_locale(category_mask, locale);
  }

  static void freelocale(locale_t locale) {
    _free_locale(locale);
  }

  static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
    return _strtod_l(nptr, endptr, locale);
  }
# endif

  locale_t locale_;

  FMT_DISALLOW_COPY_AND_ASSIGN(Locale);

 public:
  typedef locale_t Type;

  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
    if (!locale_)
      FMT_THROW(fmt::SystemError(errno, "cannot create locale"));
  }
  ~Locale() { freelocale(locale_); }

  Type get() const { return locale_; }

  // Converts string to floating-point number and advances str past the end
  // of the parsed input.
  double strtod(const char *&str) const {
    char *end = FMT_NULL;
    double result = strtod_l(str, &end, locale_);
    str = end;
    return result;
  }
};
#endif  // FMT_LOCALE
}  // namespace fmt

#if !FMT_USE_RVALUE_REFERENCES
namespace std {
// For compatibility with C++98.
inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; }
inline fmt::File &move(fmt::File &f) { return f; }
}
#endif

#endif  // FMT_POSIX_H_


================================================
FILE: lib/fmt/orig/printf.cc
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#include "format.h"
#include "printf.h"

namespace fmt {

template <typename Char>
void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args);

FMT_FUNC int fprintf(std::FILE *f, CStringRef format, ArgList args) {
  MemoryWriter w;
  printf(w, format, args);
  std::size_t size = w.size();
  return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
}

#ifndef FMT_HEADER_ONLY

template void PrintfFormatter<char>::format(CStringRef format);
template void PrintfFormatter<wchar_t>::format(WCStringRef format);

#endif  // FMT_HEADER_ONLY

}  // namespace fmt


================================================
FILE: lib/fmt/orig/printf.h
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_PRINTF_H_
#define FMT_PRINTF_H_

#include <algorithm>  // std::fill_n
#include <limits>     // std::numeric_limits

#include "ostream.h"

namespace fmt {
namespace internal {

// Checks if a value fits in int - used to avoid warnings about comparing
// signed and unsigned integers.
template <bool IsSigned>
struct IntChecker {
  template <typename T>
  static bool fits_in_int(T value) {
    unsigned max = std::numeric_limits<int>::max();
    return value <= max;
  }
  static bool fits_in_int(bool) { return true; }
};

template <>
struct IntChecker<true> {
  template <typename T>
  static bool fits_in_int(T value) {
    return value >= std::numeric_limits<int>::min() &&
           value <= std::numeric_limits<int>::max();
  }
  static bool fits_in_int(int) { return true; }
};

class PrecisionHandler : public ArgVisitor<PrecisionHandler, int> {
 public:
  void report_unhandled_arg() {
    FMT_THROW(FormatError("precision is not integer"));
  }

  template <typename T>
  int visit_any_int(T value) {
    if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
      FMT_THROW(FormatError("number is too big"));
    return static_cast<int>(value);
  }
};

// IsZeroInt::visit(arg) returns true iff arg is a zero integer.
class IsZeroInt : public ArgVisitor<IsZeroInt, bool> {
 public:
  template <typename T>
  bool visit_any_int(T value) { return value == 0; }
};

// returns the default type for format specific "%s"
class DefaultType : public ArgVisitor<DefaultType, char> {
 public:
  char visit_char(int) { return 'c'; }

  char visit_bool(bool) { return 's'; }

  char visit_pointer(const void *) { return 'p'; }

  template <typename T>
  char visit_any_int(T) { return 'd'; }

  template <typename T>
  char visit_any_double(T) { return 'g'; }

  char visit_unhandled_arg() { return 's'; }
};

template <typename T, typename U>
struct is_same {
  enum { value = 0 };
};

template <typename T>
struct is_same<T, T> {
  enum { value = 1 };
};

// An argument visitor that converts an integer argument to T for printf,
// if T is an integral type. If T is void, the argument is converted to
// corresponding signed or unsigned type depending on the type specifier:
// 'd' and 'i' - signed, other - unsigned)
template <typename T = void>
class ArgConverter : public ArgVisitor<ArgConverter<T>, void> {
 private:
  internal::Arg &arg_;
  wchar_t type_;

  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);

 public:
  ArgConverter(internal::Arg &arg, wchar_t type)
    : arg_(arg), type_(type) {}

  void visit_bool(bool value) {
    if (type_ != 's')
      visit_any_int(value);
  }

  void visit_char(int value) {
    if (type_ != 's')
      visit_any_int(value);
  }

  template <typename U>
  void visit_any_int(U value) {
    bool is_signed = type_ == 'd' || type_ == 'i';
    if (type_ == 's') {
      is_signed = std::numeric_limits<U>::is_signed;
    }

    using internal::Arg;
    typedef typename internal::Conditional<
        is_same<T, void>::value, U, T>::type TargetType;
    if (const_check(sizeof(TargetType) <= sizeof(int))) {
      // Extra casts are used to silence warnings.
      if (is_signed) {
        arg_.type = Arg::INT;
        arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
      } else {
        arg_.type = Arg::UINT;
        typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
        arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
      }
    } else {
      if (is_signed) {
        arg_.type = Arg::LONG_LONG;
        // glibc's printf doesn't sign extend arguments of smaller types:
        //   std::printf("%lld", -42);  // prints "4294967254"
        // but we don't have to do the same because it's a UB.
        arg_.long_long_value = static_cast<LongLong>(value);
      } else {
        arg_.type = Arg::ULONG_LONG;
        arg_.ulong_long_value =
            static_cast<typename internal::MakeUnsigned<U>::Type>(value);
      }
    }
  }
};

// Converts an integer argument to char for printf.
class CharConverter : public ArgVisitor<CharConverter, void> {
 private:
  internal::Arg &arg_;

  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);

 public:
  explicit CharConverter(internal::Arg &arg) : arg_(arg) {}

  template <typename T>
  void visit_any_int(T value) {
    arg_.type = internal::Arg::CHAR;
    arg_.int_value = static_cast<char>(value);
  }
};

// Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative.
class WidthHandler : public ArgVisitor<WidthHandler, unsigned> {
 private:
  FormatSpec &spec_;

  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);

 public:
  explicit WidthHandler(FormatSpec &spec) : spec_(spec) {}

  void report_unhandled_arg() {
    FMT_THROW(FormatError("width is not integer"));
  }

  template <typename T>
  unsigned visit_any_int(T value) {
    typedef typename internal::IntTraits<T>::MainType UnsignedType;
    UnsignedType width = static_cast<UnsignedType>(value);
    if (internal::is_negative(value)) {
      spec_.align_ = ALIGN_LEFT;
      width = 0 - width;
    }
    unsigned int_max = std::numeric_limits<int>::max();
    if (width > int_max)
      FMT_THROW(FormatError("number is too big"));
    return static_cast<unsigned>(width);
  }
};
}  // namespace internal

/**
  \rst
  A ``printf`` argument formatter based on the `curiously recurring template
  pattern <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.

  To use `~fmt::BasicPrintfArgFormatter` define a subclass that implements some
  or all of the visit methods with the same signatures as the methods in
  `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`.
  Pass the subclass as the *Impl* template parameter. When a formatting
  function processes an argument, it will dispatch to a visit method
  specific to the argument type. For example, if the argument type is
  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
  will be called. If the subclass doesn't contain a method with this signature,
  then a corresponding method of `~fmt::BasicPrintfArgFormatter` or its
  superclass will be called.
  \endrst
 */
template <typename Impl, typename Char, typename Spec>
class BasicPrintfArgFormatter :
    public internal::ArgFormatterBase<Impl, Char, Spec> {
 private:
  void write_null_pointer() {
    this->spec().type_ = 0;
    this->write("(nil)");
  }

  typedef internal::ArgFormatterBase<Impl, Char, Spec> Base;

 public:
  /**
    \rst
    Constructs an argument formatter object.
    *writer* is a reference to the output writer and *spec* contains format
    specifier information for standard argument types.
    \endrst
   */
  BasicPrintfArgFormatter(BasicWriter<Char> &w, Spec &s)
  : internal::ArgFormatterBase<Impl, Char, Spec>(w, s) {}

  /** Formats an argument of type ``bool``. */
  void visit_bool(bool value) {
    Spec &fmt_spec = this->spec();
    if (fmt_spec.type_ != 's')
      return this->visit_any_int(value);
    fmt_spec.type_ = 0;
    this->write(value);
  }

  /** Formats a character. */
  void visit_char(int value) {
    const Spec &fmt_spec = this->spec();
    BasicWriter<Char> &w = this->writer();
    if (fmt_spec.type_ && fmt_spec.type_ != 'c')
      w.write_int(value, fmt_spec);
    typedef typename BasicWriter<Char>::CharPtr CharPtr;
    CharPtr out = CharPtr();
    if (fmt_spec.width_ > 1) {
      Char fill = ' ';
      out = w.grow_buffer(fmt_spec.width_);
      if (fmt_spec.align_ != ALIGN_LEFT) {
        std::fill_n(out, fmt_spec.width_ - 1, fill);
        out += fmt_spec.width_ - 1;
      } else {
        std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
      }
    } else {
      out = w.grow_buffer(1);
    }
    *out = static_cast<Char>(value);
  }

  /** Formats a null-terminated C string. */
  void visit_cstring(const char *value) {
    if (value)
      Base::visit_cstring(value);
    else if (this->spec().type_ == 'p')
      write_null_pointer();
    else
      this->write("(null)");
  }

  /** Formats a pointer. */
  void visit_pointer(const void *value) {
    if (value)
      return Base::visit_pointer(value);
    this->spec().type_ = 0;
    write_null_pointer();
  }

  /** Formats an argument of a custom (user-defined) type. */
  void visit_custom(internal::Arg::CustomValue c) {
    BasicFormatter<Char> formatter(ArgList(), this->writer());
    const Char format_str[] = {'}', 0};
    const Char *format = format_str;
    c.format(&formatter, c.value, &format);
  }
};

/** The default printf argument formatter. */
template <typename Char>
class PrintfArgFormatter :
    public BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec> {
 public:
  /** Constructs an argument formatter object. */
  PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
  : BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec>(w, s) {}
};

/** This template formats data and writes the output to a writer. */
template <typename Char, typename ArgFormatter = PrintfArgFormatter<Char> >
class PrintfFormatter : private internal::FormatterBase {
 private:
  BasicWriter<Char> &writer_;

  void parse_flags(FormatSpec &spec, const Char *&s);

  // Returns the argument with specified index or, if arg_index is equal
  // to the maximum unsigned value, the next argument.
  internal::Arg get_arg(
      const Char *s,
      unsigned arg_index = (std::numeric_limits<unsigned>::max)());

  // Parses argument index, flags and width and returns the argument index.
  unsigned parse_header(const Char *&s, FormatSpec &spec);

 public:
  /**
   \rst
   Constructs a ``PrintfFormatter`` object. References to the arguments and
   the writer are stored in the formatter object so make sure they have
   appropriate lifetimes.
   \endrst
   */
  explicit PrintfFormatter(const ArgList &al, BasicWriter<Char> &w)
    : FormatterBase(al), writer_(w) {}

  /** Formats stored arguments and writes the output to the writer. */
  void format(BasicCStringRef<Char> format_str);
};

template <typename Char, typename AF>
void PrintfFormatter<Char, AF>::parse_flags(FormatSpec &spec, const Char *&s) {
  for (;;) {
    switch (*s++) {
      case '-':
        spec.align_ = ALIGN_LEFT;
        break;
      case '+':
        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
        break;
      case '0':
        spec.fill_ = '0';
        break;
      case ' ':
        spec.flags_ |= SIGN_FLAG;
        break;
      case '#':
        spec.flags_ |= HASH_FLAG;
        break;
      default:
        --s;
        return;
    }
  }
}

template <typename Char, typename AF>
internal::Arg PrintfFormatter<Char, AF>::get_arg(const Char *s,
                                                 unsigned arg_index) {
  (void)s;
  const char *error = FMT_NULL;
  internal::Arg arg = arg_index == std::numeric_limits<unsigned>::max() ?
    next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
  if (error)
    FMT_THROW(FormatError(!*s ? "invalid format string" : error));
  return arg;
}

template <typename Char, typename AF>
unsigned PrintfFormatter<Char, AF>::parse_header(
  const Char *&s, FormatSpec &spec) {
  unsigned arg_index = std::numeric_limits<unsigned>::max();
  Char c = *s;
  if (c >= '0' && c <= '9') {
    // Parse an argument index (if followed by '$') or a width possibly
    // preceded with '0' flag(s).
    unsigned value = internal::parse_nonnegative_int(s);
    if (*s == '$') {  // value is an argument index
      ++s;
      arg_index = value;
    } else {
      if (c == '0')
        spec.fill_ = '0';
      if (value != 0) {
        // Nonzero value means that we parsed width and don't need to
        // parse it or flags again, so return now.
        spec.width_ = value;
        return arg_index;
      }
    }
  }
  parse_flags(spec, s);
  // Parse width.
  if (*s >= '0' && *s <= '9') {
    spec.width_ = internal::parse_nonnegative_int(s);
  } else if (*s == '*') {
    ++s;
    spec.width_ = internal::WidthHandler(spec).visit(get_arg(s));
  }
  return arg_index;
}

template <typename Char, typename AF>
void PrintfFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
  const Char *start = format_str.c_str();
  const Char *s = start;
  while (*s) {
    Char c = *s++;
    if (c != '%') continue;
    if (*s == c) {
      write(writer_, start, s);
      start = ++s;
      continue;
    }
    write(writer_, start, s - 1);

    FormatSpec spec;
    spec.align_ = ALIGN_RIGHT;

    // Parse argument index, flags and width.
    unsigned arg_index = parse_header(s, spec);

    // Parse precision.
    if (*s == '.') {
      ++s;
      if ('0' <= *s && *s <= '9') {
        spec.precision_ = static_cast<int>(internal::parse_nonnegative_int(s));
      } else if (*s == '*') {
        ++s;
        spec.precision_ = internal::PrecisionHandler().visit(get_arg(s));
      } else {
        spec.precision_ = 0;
      }
    }

    using internal::Arg;
    Arg arg = get_arg(s, arg_index);
    if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg))
      spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
    if (spec.fill_ == '0') {
      if (arg.type <= Arg::LAST_NUMERIC_TYPE)
        spec.align_ = ALIGN_NUMERIC;
      else
        spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
    }

    // Parse length and convert the argument to the required type.
    using internal::ArgConverter;
    switch (*s++) {
    case 'h':
      if (*s == 'h')
        ArgConverter<signed char>(arg, *++s).visit(arg);
      else
        ArgConverter<short>(arg, *s).visit(arg);
      break;
    case 'l':
      if (*s == 'l')
        ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
      else
        ArgConverter<long>(arg, *s).visit(arg);
      break;
    case 'j':
      ArgConverter<intmax_t>(arg, *s).visit(arg);
      break;
    case 'z':
      ArgConverter<std::size_t>(arg, *s).visit(arg);
      break;
    case 't':
      ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
      break;
    case 'L':
      // printf produces garbage when 'L' is omitted for long double, no
      // need to do the same.
      break;
    default:
      --s;
      ArgConverter<void>(arg, *s).visit(arg);
    }

    // Parse type.
    if (!*s)
      FMT_THROW(FormatError("invalid format string"));
    spec.type_ = static_cast<char>(*s++);

    if (spec.type_ == 's') {
      // set the format type to the default if 's' is specified
      spec.type_ = internal::DefaultType().visit(arg);
    }

    if (arg.type <= Arg::LAST_INTEGER_TYPE) {
      // Normalize type.
      switch (spec.type_) {
      case 'i': case 'u':
        spec.type_ = 'd';
        break;
      case 'c':
        // TODO: handle wchar_t
        internal::CharConverter(arg).visit(arg);
        break;
      }
    }

    start = s;

    // Format argument.
    AF(writer_, spec).visit(arg);
  }
  write(writer_, start, s);
}

inline void printf(Writer &w, CStringRef format, ArgList args) {
  PrintfFormatter<char>(args, w).format(format);
}
FMT_VARIADIC(void, printf, Writer &, CStringRef)

inline void printf(WWriter &w, WCStringRef format, ArgList args) {
  PrintfFormatter<wchar_t>(args, w).format(format);
}
FMT_VARIADIC(void, printf, WWriter &, WCStringRef)

/**
  \rst
  Formats arguments and returns the result as a string.

  **Example**::

    std::string message = fmt::sprintf("The answer is %d", 42);
  \endrst
*/
inline std::string sprintf(CStringRef format, ArgList args) {
  MemoryWriter w;
  printf(w, format, args);
  return w.str();
}
FMT_VARIADIC(std::string, sprintf, CStringRef)

inline std::wstring sprintf(WCStringRef format, ArgList args) {
  WMemoryWriter w;
  printf(w, format, args);
  return w.str();
}
FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)

/**
  \rst
  Prints formatted data to the file *f*.

  **Example**::

    fmt::fprintf(stderr, "Don't %s!", "panic");
  \endrst
 */
FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args);
FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)

/**
  \rst
  Prints formatted data to ``stdout``.

  **Example**::

    fmt::printf("Elapsed time: %.2f seconds", 1.23);
  \endrst
 */
inline int printf(CStringRef format, ArgList args) {
  return fprintf(stdout, format, args);
}
FMT_VARIADIC(int, printf, CStringRef)

/**
  \rst
  Prints formatted data to the stream *os*.

  **Example**::

    fprintf(cerr, "Don't %s!", "panic");
  \endrst
 */
inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) {
  MemoryWriter w;
  printf(w, format_str, args);
  internal::write(os, w);
  return static_cast<int>(w.size());
}
FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
}  // namespace fmt

#ifdef FMT_HEADER_ONLY
# include "printf.cc"
#endif

#endif  // FMT_PRINTF_H_


================================================
FILE: lib/fmt/orig/string.h
================================================
/*
 Formatting library for C++ - string utilities

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifdef FMT_INCLUDE
# error "Add the fmt's parent directory and not fmt itself to includes."
#endif

#ifndef FMT_STRING_H_
#define FMT_STRING_H_

#include "format.h"

namespace fmt {

namespace internal {

// A buffer that stores data in ``std::basic_string``.
template <typename Char, typename Allocator = std::allocator<Char> >
class StringBuffer : public Buffer<Char> {
 public:
  typedef std::basic_string<Char, std::char_traits<Char>, Allocator> StringType;

 private:
  StringType data_;

 protected:
  virtual void grow(std::size_t size) FMT_OVERRIDE {
    data_.resize(size);
    this->ptr_ = &data_[0];
    this->capacity_ = size;
  }

 public:
  explicit StringBuffer(const Allocator &allocator = Allocator())
  : data_(allocator) {}

  // Moves the data to ``str`` clearing the buffer.
  void move_to(StringType &str) {
    data_.resize(this->size_);
    str.swap(data_);
    this->capacity_ = this->size_ = 0;
    this->ptr_ = FMT_NULL;
  }
};
}  // namespace internal

/**
  \rst
  This class template provides operations for formatting and writing data
  into a character stream. The output is stored in a ``std::basic_string``
  that grows dynamically.

  You can use one of the following typedefs for common character types
  and the standard allocator:

  +---------------+----------------------------+
  | Type          | Definition                 |
  +===============+============================+
  | StringWriter  | BasicStringWriter<char>    |
  +---------------+----------------------------+
  | WStringWriter | BasicStringWriter<wchar_t> |
  +---------------+----------------------------+

  **Example**::

     StringWriter out;
     out << "The answer is " << 42 << "\n";

  This will write the following output to the ``out`` object:

  .. code-block:: none

     The answer is 42

  The output can be moved to a ``std::basic_string`` with ``out.move_to()``.
  \endrst
 */
template <typename Char, typename Allocator = std::allocator<Char> >
class BasicStringWriter : public BasicWriter<Char> {
 private:
  internal::StringBuffer<Char, Allocator> buffer_;

 public:
  /**
    \rst
    Constructs a :class:`fmt::BasicStringWriter` object.
    \endrst
   */
  explicit BasicStringWriter(const Allocator &allocator = Allocator())
  : BasicWriter<Char>(buffer_), buffer_(allocator) {}

  /**
    \rst
    Moves the buffer content to *str* clearing the buffer.
    \endrst
   */
  void move_to(std::basic_string<Char, std::char_traits<Char>, Allocator> &str) {
    buffer_.move_to(str);
  }
};

typedef BasicStringWriter<char> StringWriter;
typedef BasicStringWriter<wchar_t> WStringWriter;

/**
  \rst
  Converts *value* to ``std::string`` using the default format for type *T*.

  **Example**::

    #include "fmt/string.h"

    std::string answer = fmt::to_string(42);
  \endrst
 */
template <typename T>
std::string to_string(const T &value) {
  fmt::MemoryWriter w;
  w << value;
  return w.str();
}

/**
  \rst
  Converts *value* to ``std::wstring`` using the default format for type *T*.

  **Example**::

    #include "fmt/string.h"

    std::wstring answer = fmt::to_wstring(42);
  \endrst
 */
template <typename T>
std::wstring to_wstring(const T &value) {
  fmt::WMemoryWriter w;
  w << value;
  return w.str();
}
}

#endif  // FMT_STRING_H_


================================================
FILE: lib/fmt/orig/time.h
================================================
/*
 Formatting library for C++ - time formatting

 Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 For the license information refer to format.h.
 */

#ifndef FMT_TIME_H_
#define FMT_TIME_H_

#include "format.h"
#include <ctime>

#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4702)  // unreachable code
# pragma warning(disable: 4996)  // "deprecated" functions
#endif

namespace fmt {
template <typename ArgFormatter>
void format_arg(BasicFormatter<char, ArgFormatter> &f,
                const char *&format_str, const std::tm &tm) {
  if (*format_str == ':')
    ++format_str;
  const char *end = format_str;
  while (*end && *end != '}')
    ++end;
  if (*end != '}')
    FMT_THROW(FormatError("missing '}' in format string"));
  internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
  format.append(format_str, end + 1);
  format[format.size() - 1] = '\0';
  Buffer<char> &buffer = f.writer().buffer();
  std::size_t start = buffer.size();
  for (;;) {
    std::size_t size = buffer.capacity() - start;
    std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
    if (count != 0) {
      buffer.resize(start + count);
      break;
    }
    if (size >= format.size() * 256) {
      // If the buffer is 256 times larger than the format string, assume
      // that `strftime` gives an empty result. There doesn't seem to be a
      // better way to distinguish the two cases:
      // https://github.com/fmtlib/fmt/issues/367
      break;
    }
    const std::size_t MIN_GROWTH = 10;
    buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
  }
  format_str = end + 1;
}

namespace internal{
inline Null<> localtime_r(...) { return Null<>(); }
inline Null<> localtime_s(...) { return Null<>(); }
inline Null<> gmtime_r(...) { return Null<>(); }
inline Null<> gmtime_s(...) { return Null<>(); }
}

// Thread-safe replacement for std::localtime
inline std::tm localtime(std::time_t time) {
  struct LocalTime {
    std::time_t time_;
    std::tm tm_;

    LocalTime(std::time_t t): time_(t) {}

    bool run() {
      using namespace fmt::internal;
      return handle(localtime_r(&time_, &tm_));
    }

    bool handle(std::tm *tm) { return tm != FMT_NULL; }

    bool handle(internal::Null<>) {
      using namespace fmt::internal;
      return fallback(localtime_s(&tm_, &time_));
    }

    bool fallback(int res) { return res == 0; }

    bool fallback(internal::Null<>) {
      using namespace fmt::internal;
      std::tm *tm = std::localtime(&time_);
      if (tm) tm_ = *tm;
      return tm != FMT_NULL;
    }
  };
  LocalTime lt(time);
  if (lt.run())
    return lt.tm_;
  // Too big time values may be unsupported.
  FMT_THROW(fmt::FormatError("time_t value out of range"));
  return std::tm();
}

// Thread-safe replacement for std::gmtime
inline std::tm gmtime(std::time_t time) {
  struct GMTime {
    std::time_t time_;
    std::tm tm_;

    GMTime(std::time_t t): time_(t) {}

    bool run() {
      using namespace fmt::internal;
      return handle(gmtime_r(&time_, &tm_));
    }

    bool handle(std::tm *tm) { return tm != FMT_NULL; }

    bool handle(internal::Null<>) {
      using namespace fmt::internal;
      return fallback(gmtime_s(&tm_, &time_));
    }

    bool fallback(int res) { return res == 0; }

    bool fallback(internal::Null<>) {
      std::tm *tm = std::gmtime(&time_);
      if (tm != FMT_NULL) tm_ = *tm;
      return tm != FMT_NULL;
    }
  };
  GMTime gt(time);
  if (gt.run())
    return gt.tm_;
  // Too big time values may be unsupported.
  FMT_THROW(fmt::FormatError("time_t value out of range"));
  return std::tm();
}
} //namespace fmt

#ifdef _MSC_VER
# pragma warning(pop)
#endif

#endif  // FMT_TIME_H_


================================================
FILE: lib/fmt/update.sh
================================================
#!/bin/bash

function cpM()
{
    cp orig/$1 $2
}

HEADS=""
function cpH()
{
    cp orig/$1 $2
    HEADS="${HEADS} $1"
}


cpM format.cc       fmt_format.cpp
cpM ostream.cc      fmt_ostream.cpp
cpM posix.cc        fmt_posix.cpp
cpM printf.cc       fmt_printf.cpp

cpH container.h     fmt_container.h
cpH format.h        fmt_format.h
cpH ostream.h       fmt_ostream.h
cpH posix.h         fmt_posix.h
cpH printf.h        fmt_printf.h
cpH string.h        fmt_string.h
cpH time.h          fmt_time.h

for h in $HEADS; do
    for f in *.cpp; do
        sed -i 's/\"'$h'\"/\"fmt_'$h'\"/g' $f
    done
    for f in *.h; do
        sed -i 's/\"'$h'\"/\"fmt_'$h'\"/g' $f
    done
done



================================================
FILE: lib/fmt_format_ne.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#ifndef FMT_FORMAT_NE_H
#define FMT_FORMAT_NE_H

#include <fmt/fmt_format.h>
#include <fmt/fmt_printf.h>
#include "Logger/logger.h"

namespace fmt
{

/*
    Exception-less fmt::format version. Instead of exception, the error message will be logged into file
*/
std::string sprintf_ne(const char *fstr, ...) FORMAT_ATTRIBUTE_PRINTF_12;

template <typename... Args>
std::string format_ne(CStringRef format_str, const Args & ... args)
{
    try
    {
        return format(format_str, std::forward<const Args&>(args)...);
    }
    catch(const FormatError &e)
    {
        std::string out;
        pLogWarning("fmt::format error: Thrown exception [%s] on attempt to process string [%s]",
                    e.what(),
                    format_str.c_str());
        out.append(e.what());
        out.append(" [");
        out.append(format_str.c_str());
        out.push_back(']');
        return out;
    }
    catch(...)
    {
        pLogWarning("fmt::format error: Thrown unknown exception on attempt to process string [%s]", format_str.c_str());
        return "<ERROR OF " + std::string(format_str.c_str()) + ">";
    }
}

}//namespace fmt

#endif // FMT_FORMAT_NE_H


================================================
FILE: lib/fmt_impl.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <stdarg.h>
#include <fmt/fmt_time.h>
#include <fmt/fmt_printf.h>
#include <fmt/fmt_format.h>
#include <fmt/fmt_printf.h>
#include "sdl_proxy/sdl_stdinc.h"
#include "Logger/logger.h"

#include "fmt_format_ne.h"
#include "fmt_time_ne.h"

namespace fmt
{

std::tm localtime_ne(std::time_t time)
{
    try
    {
        return localtime(time);
    }
    catch(const FormatError &e)
    {
        std::tm t;
        std::memset(&t, 0, sizeof(std::tm));
        pLogFatal("fmt::format error: Thrown exception [%s] on attempt to process localtime", e.what());
        return t;
    }
    catch(...)
    {
        std::tm t;
        std::memset(&t, 0, sizeof(std::tm));
        pLogFatal("fmt::format error: Thrown unknown exception on attempt to process localtime");
        return t;
    }
}

std::string sprintf_ne(const char *fstr, ...)
{
    std::string ret;
    va_list arg;
    int len = SDL_strlen(fstr);
    int argLen = 0;

    // Calculate coarse length of arguments
    for(const char *b = fstr; *b; ++b)
    {
        if(*b == '%')
        {
            ++b;
            if(*b == 's')
                argLen += 128; // Reserve ~1000 for every string
            else if(*b == '%')
                continue; // Not an arg!
            else
                argLen += 10;
        }
    }

    ret.resize(len + argLen);

    va_start(arg, fstr);
    len = SDL_vsnprintf(&ret[0], ret.size(), fstr, arg);
    va_end(arg);

    if(len > (int)ret.size())
    {
        ret.resize(len + 1);
        va_start(arg, fstr);
        SDL_vsnprintf(&ret[0], ret.size(), fstr, arg);
        va_end(arg);
    }
    else
        ret.resize(len);

    return ret;
}

}


================================================
FILE: lib/fmt_time_ne.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <fmt/fmt_time.h>
#include <fmt/fmt_printf.h>
#include <Logger/logger.h>

namespace fmt
{
std::tm localtime_ne(std::time_t time);
}


================================================
FILE: lib/forced_int.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef FORCED_INT_H
#define FORCED_INT_H

template<class t_vbint>
struct forced_int
{
private:
    t_vbint i;
public:
    forced_int(t_vbint _i) : i(_i) {}
    forced_int(double _i) = delete;

    forced_int& operator=(t_vbint o)
    {
        i = o;
        return *this;
    }

    forced_int& operator=(double o) = delete;

    forced_int& operator++()
    {
        i++;
        return *this;
    }

    forced_int operator++(int)
    {
        forced_int ret(i);
        i++;
        return ret;
    }

    forced_int& operator+=(t_vbint o)
    {
        i += o;
        return *this;
    }

    forced_int& operator+=(double o) = delete;

    forced_int& operator-=(t_vbint o)
    {
        i -= o;
        return *this;
    }

    forced_int& operator-=(double o) = delete;

    operator t_vbint() const
    {
        return i;
    }
};

#endif // #ifndef FORCED_INT_H


================================================
FILE: lib/gif.h
================================================
//
// gif.h
// by Charlie Tangora
// Public domain.
// Email me : ctangora -at- gmail -dot- com
//
// This file offers a simple, very limited way to create animated GIFs directly in code.
//
// Those looking for particular cleverness are likely to be disappointed; it's pretty
// much a straight-ahead implementation of the GIF format with optional Floyd-Steinberg
// dithering. (It does at least use delta encoding - only the changed portions of each
// frame are saved.)
//
// So resulting files are often quite large. The hope is that it will be handy nonetheless
// as a quick and easily-integrated way for programs to spit out animations.
//
// Only RGBA8 is currently supported as an input format. (The alpha is ignored.)
//
// USAGE:
// Create a GifWriter struct. Pass it to GifBegin() to initialize and write the header.
// Pass subsequent frames to GifWriteFrame().
// Finally, call GifEnd() to close the file handle and free memory.
//

#ifndef gif_h
#define gif_h

#include <SDL2/SDL_rwops.h>   // for SDL_RWops*
#include <string.h>  // for memcpy and bzero
#include <stdint.h>  // for integer typedefs
#include <assert.h>

// Define these macros to hook into a custom memory allocator.
// TEMP_MALLOC and TEMP_FREE will only be called in stack fashion - frees in the reverse order of mallocs
// and any temp memory allocated by a function will be freed before it exits.
// MALLOC and FREE are used only by GifBegin and GifEnd respectively (to allocate a buffer the size of the image, which
// is used to find changed pixels for delta-encoding.)

#ifndef GIF_TEMP_MALLOC
#include <stdlib.h>
#define GIF_TEMP_MALLOC malloc
#endif

#ifndef GIF_TEMP_FREE
#include <stdlib.h>
#define GIF_TEMP_FREE free
#endif

#ifndef GIF_MALLOC
#include <stdlib.h>
#define GIF_MALLOC malloc
#endif

#ifndef GIF_FREE
#include <stdlib.h>
#define GIF_FREE free
#endif

#include "gif_writer.h"

namespace GIF_H
{

static const int kGifTransIndex = 0;

#ifdef GIF_H_BIG_ENDIAN
static const int PIX_R = 3;
static const int PIX_G = 2;
static const int PIX_B = 1;
static const int PIX_I = 0;
#else
static const int PIX_R = 0;
static const int PIX_G = 1;
static const int PIX_B = 2;
static const int PIX_I = 3;
#endif

struct GifPalette
{
    int bitDepth;

    uint8_t r[256];
    uint8_t g[256];
    uint8_t b[256];

    // k-d tree over RGB space, organized in heap fashion
    // i.e. left child of node i is node i*2, right child is node i*2+1
    // nodes 256-511 are implicitly the leaves, containing a color
    uint8_t treeSplitElt[256];
    uint8_t treeSplit[256];
};

// max, min, and abs functions
static int GifIMax(int l, int r) { return l>r?l:r; }
static int GifIMin(int l, int r) { return l<r?l:r; }
static int GifIAbs(int i) { return i<0?-i:i; }

static const int colorDimScales[3] = {14, 20, 17};

// walks the k-d tree to pick the palette entry for a desired color.
// Takes as in/out parameters the current best color and its error -
// only changes them if it finds a better color in its subtree.
// this is the major hotspot in the code at the moment.
static void GifGetClosestPaletteColor(GifPalette* pPal, int r, int g, int b, int& bestInd, int& bestDiff, int treeRoot = 1)
{
    // base case, reached the bottom of the tree
    if(treeRoot > (1<<pPal->bitDepth)-1)
    {
        int ind = treeRoot-(1<<pPal->bitDepth);
        if(ind == kGifTransIndex) return;

        // check whether this color is better than the current winner
        int r_err = r - ((int32_t)pPal->r[ind]);
        int g_err = g - ((int32_t)pPal->g[ind]);
        int b_err = b - ((int32_t)pPal->b[ind]);
        // RED: Increase green importance
        int diff = colorDimScales[0] * GifIAbs(r_err) + colorDimScales[1] * GifIAbs(g_err) + colorDimScales[2] * GifIAbs(b_err);

        if(diff < bestDiff)
        {
            bestInd = ind;
            bestDiff = diff;
        }

        return;
    }

    // take the appropriate color (r, g, or b) for this node of the k-d tree
    int comps[3]; comps[0] = r; comps[1] = g; comps[2] = b;
    int splitComp = comps[pPal->treeSplitElt[treeRoot]];
    int dimScale = colorDimScales[pPal->treeSplitElt[treeRoot]];

    int splitPos = pPal->treeSplit[treeRoot];
    if(splitPos > splitComp)
    {
        // check the left subtree
        GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot*2);
        if( bestDiff > dimScale*(splitPos - splitComp) )
        {
            // cannot prove there's not a better value in the right subtree, check that too
            GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot*2+1);
        }
    }
    else
    {
        GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot*2+1);
        if( bestDiff > dimScale*(splitComp - splitPos) )
        {
            GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot*2);
        }
    }
}

static void GifSwapPixels(uint8_t* image, int pixA, int pixB)
{
    uint8_t rA = image[pixA*4];
    uint8_t gA = image[pixA*4+1];
    uint8_t bA = image[pixA*4+2];
    uint8_t aA = image[pixA*4+3];

    uint8_t rB = image[pixB*4];
    uint8_t gB = image[pixB*4+1];
    uint8_t bB = image[pixB*4+2];
    uint8_t aB = image[pixA*4+3];

    image[pixA*4] = rB;
    image[pixA*4+1] = gB;
    image[pixA*4+2] = bB;
    image[pixA*4+3] = aB;

    image[pixB*4] = rA;
    image[pixB*4+1] = gA;
    image[pixB*4+2] = bA;
    image[pixB*4+3] = aA;
}

// just the partition operation from quicksort
static int GifPartition(uint8_t* image, const int left, const int right, const int elt, int pivotIndex)
{
    const int pivotValue = image[(pivotIndex)*4+elt];
    GifSwapPixels(image, pivotIndex, right-1);
    int storeIndex = left;
    bool split = 0;
    for(int ii=left; ii<right-1; ++ii)
    {
        int arrayVal = image[ii*4+elt];
        if( arrayVal < pivotValue )
        {
            GifSwapPixels(image, ii, storeIndex);
            ++storeIndex;
        }
        else if( arrayVal == pivotValue )
        {
            if(split)
            {
                GifSwapPixels(image, ii, storeIndex);
                ++storeIndex;
            }
            split = !split;
        }
    }
    GifSwapPixels(image, storeIndex, right-1);
    return storeIndex;
}

// Perform an incomplete sort, finding all elements above and below the desired median
static void GifPartitionByMedian(uint8_t* image, int left, int right, int com, int neededCenter)
{
    if(left < right-1)
    {
        int pivotIndex = left + (right-left)/2;

        pivotIndex = GifPartition(image, left, right, com, pivotIndex);

        // Only "sort" the section of the array that contains the median
        if(pivotIndex > neededCenter)
            GifPartitionByMedian(image, left, pivotIndex, com, neededCenter);

        if(pivotIndex < neededCenter)
            GifPartitionByMedian(image, pivotIndex+1, right, com, neededCenter);
    }
}

// Builds a palette by creating a balanced k-d tree of all pixels in the image
static void GifSplitPalette(uint8_t* image, int numPixels, int firstElt, int lastElt, int splitElt, int splitDist, int treeNode, bool buildForDither, GifPalette* pal)
{
    if(lastElt <= firstElt || numPixels == 0)
        return;

    // base case, bottom of the tree
    if(lastElt == firstElt+1)
    {
        if(buildForDither)
        {
            // Dithering needs at least one color as dark as anything
            // in the image and at least one brightest color -
            // otherwise it builds up error and produces strange artifacts
            if( firstElt == 1 )
            {
                // special case: the darkest color in the image
                uint32_t r=255, g=255, b=255;
                for(int ii=0; ii<numPixels; ++ii)
                {
                    r = GifIMin(r, image[ii*4+PIX_R]);
                    g = GifIMin(g, image[ii*4+PIX_G]);
                    b = GifIMin(b, image[ii*4+PIX_B]);
                }

                pal->r[firstElt] = r;
                pal->g[firstElt] = g;
                pal->b[firstElt] = b;

                return;
            }

            if( firstElt == (1 << pal->bitDepth)-1 )
            {
                // special case: the lightest color in the image
                uint32_t r=0, g=0, b=0;
                for(int ii=0; ii<numPixels; ++ii)
                {
                    r = GifIMax(r, image[ii*4+PIX_R]);
                    g = GifIMax(g, image[ii*4+PIX_G]);
                    b = GifIMax(b, image[ii*4+PIX_B]);
                }

                pal->r[firstElt] = r;
                pal->g[firstElt] = g;
                pal->b[firstElt] = b;

                return;
            }
        }

        // otherwise, take the average of all colors in this subcube
        uint64_t r=0, g=0, b=0;
        for(int ii=0; ii<numPixels; ++ii)
        {
            r += image[ii*4+PIX_R];
            g += image[ii*4+PIX_G];
            b += image[ii*4+PIX_B];
        }

        r += numPixels / 2;  // round to nearest
        g += numPixels / 2;
        b += numPixels / 2;

        r /= numPixels;
        g /= numPixels;
        b /= numPixels;

        pal->r[firstElt] = (uint8_t)r;
        pal->g[firstElt] = (uint8_t)g;
        pal->b[firstElt] = (uint8_t)b;

        return;
    }

    // Find the axis with the largest range
    int minR = 255, maxR = 0;
    int minG = 255, maxG = 0;
    int minB = 255, maxB = 0;
    for(int ii=0; ii<numPixels; ++ii)
    {
        int r = image[ii*4+PIX_R];
        int g = image[ii*4+PIX_G];
        int b = image[ii*4+PIX_B];

        if(r > maxR) maxR = r;
        if(r < minR) minR = r;

        if(g > maxG) maxG = g;
        if(g < minG) minG = g;

        if(b > maxB) maxB = b;
        if(b < minB) minB = b;
    }

    int rRange = maxR - minR;
    int gRange = maxG - minG;
    int bRange = maxB - minB;
    rRange *= colorDimScales[0];
    gRange *= colorDimScales[1]; // RED: Modification to increase green importance
    bRange *= colorDimScales[2];

    // and split along that axis. (incidentally, this means this isn't a "proper" k-d tree but I don't know what else to call it)
    int splitCom = 1;
    if(bRange > gRange) splitCom = 2;
    if(rRange > bRange && rRange > gRange) splitCom = 0;

    int subPixelsA = numPixels * (splitElt - firstElt) / (lastElt - firstElt);
    int subPixelsB = numPixels-subPixelsA;

    GifPartitionByMedian(image, 0, numPixels, splitCom, subPixelsA);

    pal->treeSplitElt[treeNode] = splitCom;
    pal->treeSplit[treeNode] = image[subPixelsA*4+splitCom];

    GifSplitPalette(image,              subPixelsA, firstElt, splitElt, splitElt-splitDist, splitDist/2, treeNode*2,   buildForDither, pal);
    GifSplitPalette(image+subPixelsA*4, subPixelsB, splitElt, lastElt,  splitElt+splitDist, splitDist/2, treeNode*2+1, buildForDither, pal);
}

// Finds all pixels that have changed from the previous image and
// moves them to the fromt of th buffer.
// This allows us to build a palette optimized for the colors of the
// changed pixels only.
static int GifPickChangedPixels( const uint8_t* lastFrame, uint8_t* frame, int numPixels )
{
    int numChanged = 0;
    uint8_t* writeIter = frame;

    for (int ii=0; ii<numPixels; ++ii)
    {
        if(lastFrame[PIX_R] != frame[PIX_R] ||
           lastFrame[PIX_G] != frame[PIX_G] ||
           lastFrame[PIX_B] != frame[PIX_B])
        {
            writeIter[PIX_R] = frame[PIX_R];
            writeIter[PIX_G] = frame[PIX_G];
            writeIter[PIX_B] = frame[PIX_B];
            ++numChanged;
            writeIter += 4;
        }
        lastFrame += 4;
        frame += 4;
    }

    return numChanged;
}

// Creates a palette by placing all the image pixels in a k-d tree and then averaging the blocks at the bottom.
// This is known as the "modified median split" technique
static void GifMakePalette( const uint8_t* lastFrame, const uint8_t* nextFrame, uint32_t width, uint32_t height, int bitDepth, bool buildForDither, GifPalette* pPal )
{
    pPal->bitDepth = bitDepth;

    // SplitPalette is destructive (it sorts the pixels by color) so
    // we must create a copy of the image for it to destroy
    int imageSize = width*height*4*sizeof(uint8_t);
    uint8_t* destroyableImage = (uint8_t*)GIF_TEMP_MALLOC(imageSize);
    assert(destroyableImage);
    assert(nextFrame);
    memcpy(destroyableImage, nextFrame, imageSize);

    int numPixels = width*height;
    if(lastFrame)
        numPixels = GifPickChangedPixels(lastFrame, destroyableImage, numPixels);

    const int lastElt = 1 << bitDepth;
    const int splitElt = lastElt/2;
    const int splitDist = splitElt/2;

    GifSplitPalette(destroyableImage, numPixels, 1, lastElt, splitElt, splitDist, 1, buildForDither, pPal);

    GIF_TEMP_FREE(destroyableImage);

    // add the bottom node for the transparency index
    pPal->treeSplit[1 << (bitDepth-1)] = 0;
    pPal->treeSplitElt[1 << (bitDepth-1)] = 0;

    pPal->r[0] = pPal->g[0] = pPal->b[0] = 0;
}

// Implements Floyd-Steinberg dithering, writes palette value to alpha
static void GifDitherImage( const uint8_t* lastFrame, const uint8_t* nextFrame, uint8_t* outFrame, uint32_t width, uint32_t height, GifPalette* pPal )
{
    int numPixels = width*height;

    // quantPixels initially holds color*256 for all pixels
    // The extra 8 bits of precision allow for sub-single-color error values
    // to be propagated
    int32_t* quantPixels = (int32_t*)GIF_TEMP_MALLOC(sizeof(int32_t)*numPixels*4);
    assert(quantPixels);

    for( int ii=0; ii<numPixels*4; ++ii )
    {
        uint8_t pix = nextFrame[ii];
        int32_t pix16 = int32_t(pix) * 256;
        quantPixels[ii] = pix16;
    }

    for( uint32_t yy=0; yy<height; ++yy )
    {
        for( uint32_t xx=0; xx<width; ++xx )
        {
            int32_t* nextPix = quantPixels + 4*(yy*width+xx);
            const uint8_t* lastPix = lastFrame? lastFrame + 4*(yy*width+xx) : NULL;

            // Compute the colors we want (rounding to nearest)
            int32_t rr = (nextPix[0] + 127) / 256;
            int32_t gg = (nextPix[1] + 127) / 256;
            int32_t bb = (nextPix[2] + 127) / 256;

            // if it happens that we want the color from last frame, then just write out
            // a transparent pixel
            if( lastFrame &&
               lastPix[PIX_R] == rr &&
               lastPix[PIX_G] == gg &&
               lastPix[PIX_B] == bb )
            {
                nextPix[0] = rr;
                nextPix[1] = gg;
                nextPix[2] = bb;
                nextPix[3] = kGifTransIndex;
                continue;
            }

            int32_t bestDiff = 1000000;
            int32_t bestInd = kGifTransIndex;

            // Search the palete
            GifGetClosestPaletteColor(pPal, rr, gg, bb, bestInd, bestDiff);

            // Write the result to the temp buffer
            int32_t r_err = nextPix[0] - int32_t(pPal->r[bestInd]) * 256;
            int32_t g_err = nextPix[1] - int32_t(pPal->g[bestInd]) * 256;
            int32_t b_err = nextPix[2] - int32_t(pPal->b[bestInd]) * 256;

            nextPix[0] = pPal->r[bestInd];
            nextPix[1] = pPal->g[bestInd];
            nextPix[2] = pPal->b[bestInd];
            nextPix[3] = bestInd;

            // Propagate the error to the four adjacent locations
            // that we haven't touched yet
            int quantloc_7 = (yy*width+xx+1);
            int quantloc_3 = (yy*width+width+xx-1);
            int quantloc_5 = (yy*width+width+xx);
            int quantloc_1 = (yy*width+width+xx+1);

            if(quantloc_7 < numPixels)
            {
                int32_t* pix7 = quantPixels+4*quantloc_7;
                pix7[0] += GifIMax( -pix7[0], r_err * 7 / 16 );
                pix7[1] += GifIMax( -pix7[1], g_err * 7 / 16 );
                pix7[2] += GifIMax( -pix7[2], b_err * 7 / 16 );
            }

            if(quantloc_3 < numPixels)
            {
                int32_t* pix3 = quantPixels+4*quantloc_3;
                pix3[0] += GifIMax( -pix3[0], r_err * 3 / 16 );
                pix3[1] += GifIMax( -pix3[1], g_err * 3 / 16 );
                pix3[2] += GifIMax( -pix3[2], b_err * 3 / 16 );
            }

            if(quantloc_5 < numPixels)
            {
                int32_t* pix5 = quantPixels+4*quantloc_5;
                pix5[0] += GifIMax( -pix5[0], r_err * 5 / 16 );
                pix5[1] += GifIMax( -pix5[1], g_err * 5 / 16 );
                pix5[2] += GifIMax( -pix5[2], b_err * 5 / 16 );
            }

            if(quantloc_1 < numPixels)
            {
                int32_t* pix1 = quantPixels+4*quantloc_1;
                pix1[0] += GifIMax( -pix1[0], r_err / 16 );
                pix1[1] += GifIMax( -pix1[1], g_err / 16 );
                pix1[2] += GifIMax( -pix1[2], b_err / 16 );
            }
        }
    }

    // Copy the palettized result to the output buffer
    for( int ii=0; ii<numPixels*4; ++ii )
    {
        outFrame[ii] = quantPixels[ii];
    }

    GIF_TEMP_FREE(quantPixels);
}

// Picks palette colors for the image using simple thresholding, no dithering
static void GifThresholdImage( const uint8_t* lastFrame, const uint8_t* nextFrame, uint8_t* outFrame, uint32_t width, uint32_t height, GifPalette* pPal )
{
    uint32_t numPixels = width*height;
    for( uint32_t ii=0; ii<numPixels; ++ii )
    {
        // if a previous color is available, and it matches the current color,
        // set the pixel to transparent
        if(lastFrame &&
           lastFrame[PIX_R] == nextFrame[PIX_R] &&
           lastFrame[PIX_G] == nextFrame[PIX_G] &&
           lastFrame[PIX_B] == nextFrame[PIX_B])
        {
            outFrame[0] = lastFrame[PIX_R];
            outFrame[1] = lastFrame[PIX_G];
            outFrame[2] = lastFrame[PIX_B];
            outFrame[3] = kGifTransIndex;
        }
        else
        {
            // palettize the pixel
            int32_t bestDiff = 1000000;
            int32_t bestInd = 1;
            GifGetClosestPaletteColor(pPal, nextFrame[PIX_R], nextFrame[PIX_G], nextFrame[PIX_B], bestInd, bestDiff);

            bool usedOld = false;
            if (lastFrame)
            {
                // RED: If the chosen one is worse than the old one, don't go with it
                int r_err = (int)lastFrame[PIX_R] - (int)nextFrame[PIX_R];
                int g_err = (int)lastFrame[PIX_G] - (int)nextFrame[PIX_G];
                int b_err = (int)lastFrame[PIX_B] - (int)nextFrame[PIX_B];
                int oldDiff = colorDimScales[0] * GifIAbs(r_err) + colorDimScales[1] * GifIAbs(g_err) + colorDimScales[2] * GifIAbs(b_err);
                if (oldDiff <= bestDiff)
                {
                    outFrame[0] = lastFrame[PIX_R];
                    outFrame[1] = lastFrame[PIX_G];
                    outFrame[2] = lastFrame[PIX_B];
                    outFrame[3] = kGifTransIndex;
                    usedOld = true;
                }
            }

            if (!usedOld)
            {
                // Write the resulting color to the output buffer
                outFrame[0] = pPal->r[bestInd];
                outFrame[1] = pPal->g[bestInd];
                outFrame[2] = pPal->b[bestInd];
                outFrame[3] = bestInd;
            }
        }

        if(lastFrame) lastFrame += 4;
        outFrame += 4;
        nextFrame += 4;
    }
}

// Simple structure to write out the LZW-compressed portion of the image
// one bit at a time
struct GifBitStatus
{
    uint8_t bitIndex;  // how many bits in the partial byte written so far
    uint8_t byte;      // current partial byte

    uint32_t chunkIndex;
    uint8_t chunk[256];   // bytes are written in here until we have 256 of them, then written to the file
};

// insert a single bit
static void GifWriteBit( GifBitStatus& stat, uint32_t bit )
{
    bit = bit & 1;
    bit = bit << stat.bitIndex;
    stat.byte |= bit;

    ++stat.bitIndex;
    if( stat.bitIndex > 7 )
    {
        // move the newly-finished byte to the chunk buffer
        stat.chunk[stat.chunkIndex++] = stat.byte;
        // and start a new byte
        stat.bitIndex = 0;
        stat.byte = 0;
    }
}

// write all bytes so far to the file
static void GifWriteChunk( buf_t& buffer, GifBitStatus& stat )
{
    buffer.push_back(stat.chunkIndex);
    buffer.append(stat.chunk, stat.chunkIndex);

    stat.bitIndex = 0;
    stat.byte = 0;
    stat.chunkIndex = 0;
}

static void GifWriteCode( buf_t& buffer, GifBitStatus& stat, uint32_t code, uint32_t length )
{
    for( uint32_t ii=0; ii<length; ++ii )
    {
        GifWriteBit(stat, code);
        code = code >> 1;

        if( stat.chunkIndex == 255 )
        {
            GifWriteChunk(buffer, stat);
        }
    }
}

// The LZW dictionary is a 256-ary tree constructed as the file is encoded,
// this is one node
struct GifLzwNode
{
    uint16_t m_next[256];
};

// write a 256-color (8-bit) image palette to the file
static void GifWritePalette( const GifPalette* pPal, buf_t& buffer )
{
    buffer.push_back(0);  // first color: transparency
    buffer.push_back(0);
    buffer.push_back(0);

    for(int ii=1; ii<(1 << pPal->bitDepth); ++ii)
    {
        uint32_t r = pPal->r[ii];
        uint32_t g = pPal->g[ii];
        uint32_t b = pPal->b[ii];

        buffer.push_back(r);
        buffer.push_back(g);
        buffer.push_back(b);
    }
}

// write the image header, LZW-compress and write out the image
static void GifWriteLzwImage(SDL_RWops* f, uint8_t* image, uint32_t left, uint32_t top,  uint32_t width, uint32_t height, uint32_t delay, GifPalette* pPal, long int *delaypos, buf_t& buffer)
{
    buffer.clear();

    // graphics control extension
    buffer.push_back(0x21);
    buffer.push_back(0xf9);
    buffer.push_back(0x04);
    buffer.push_back(0x05); // leave prev frame in place, this frame has transparency
    if (delaypos) *delaypos = SDL_RWtell(f);
    buffer.push_back(delay & 0xff);
    buffer.push_back((delay >> 8) & 0xff);
    buffer.push_back(kGifTransIndex); // transparent color index
    buffer.push_back(0);

    buffer.push_back(0x2c); // image descriptor block

    buffer.push_back(left & 0xff);           // corner of image in canvas space
    buffer.push_back((left >> 8) & 0xff);
    buffer.push_back(top & 0xff);
    buffer.push_back((top >> 8) & 0xff);

    buffer.push_back(width & 0xff);          // width and height of image
    buffer.push_back((width >> 8) & 0xff);
    buffer.push_back(height & 0xff);
    buffer.push_back((height >> 8) & 0xff);

    //fputc(0, f); // no local color table, no transparency
    //fputc(0x80, f); // no local color table, but transparency

    buffer.push_back(0x80 + pPal->bitDepth-1); // local color table present, 2 ^ bitDepth entries
    GifWritePalette(pPal, buffer);

    const int minCodeSize = pPal->bitDepth;
    const uint32_t clearCode = 1 << pPal->bitDepth;

    buffer.push_back(minCodeSize); // min code size 8 bits

    GifLzwNode* codetree = (GifLzwNode*)GIF_TEMP_MALLOC(sizeof(GifLzwNode)*4096);
    assert(codetree);

    memset(codetree, 0, sizeof(GifLzwNode)*4096);
    int32_t curCode = -1;
    uint32_t codeSize = minCodeSize+1;
    uint32_t maxCode = clearCode+1;

    GifBitStatus stat;
    stat.byte = 0;
    stat.bitIndex = 0;
    stat.chunkIndex = 0;

    GifWriteCode(buffer, stat, clearCode, codeSize);  // start with a fresh LZW dictionary

    for(uint32_t yy=0; yy<height; ++yy)
    {
        for(uint32_t xx=0; xx<width; ++xx)
        {
            uint8_t nextValue = image[(yy*width+xx)*4+3];

            // "loser mode" - no compression, every single code is followed immediately by a clear
            //WriteCode( f, stat, nextValue, codeSize );
            //WriteCode( f, stat, 256, codeSize );

            if( curCode < 0 )
            {
                // first value in a new run
                curCode = nextValue;
            }
            else if( codetree[curCode].m_next[nextValue] )
            {
                // current run already in the dictionary
                curCode = codetree[curCode].m_next[nextValue];
            }
            else
            {
                // finish the current run, write a code
                GifWriteCode( buffer, stat, curCode, codeSize );

                // insert the new run into the dictionary
                codetree[curCode].m_next[nextValue] = ++maxCode;

                if( maxCode >= (1ul << codeSize) )
                {
                    // dictionary entry count has broken a size barrier,
                    // we need more bits for codes
                    codeSize++;
                }
                if( maxCode == 4095 )
                {
                    // the dictionary is full, clear it out and begin anew
                    GifWriteCode(buffer, stat, clearCode, codeSize); // clear tree

                    memset(codetree, 0, sizeof(GifLzwNode)*4096);
                    curCode = -1;
                    codeSize = minCodeSize+1;
                    maxCode = clearCode+1;
                }

                curCode = nextValue;
            }
        }
    }

    // compression footer
    GifWriteCode( buffer, stat, curCode, codeSize );
    GifWriteCode( buffer, stat, clearCode, codeSize );
    GifWriteCode( buffer, stat, clearCode+1, minCodeSize+1 );

    // write out the last partial chunk
    while( stat.bitIndex ) GifWriteBit(stat, 0);
    if( stat.chunkIndex ) GifWriteChunk(buffer, stat);

    buffer.push_back(0); // image block terminator

    SDL_RWwrite(f, &buffer[0], 1, buffer.size());

    GIF_TEMP_FREE(codetree);
}


// GifWriter moved into the own header

// Creates a gif file.
// The input GIFWriter is assumed to be uninitialized.
// The delay value is the time between frames in hundredths of a second - note that not all viewers pay much attention to this value.
static bool GifBegin( GifWriter* writer, SDL_RWops *file, uint32_t width, uint32_t height, uint32_t delay, int32_t bitDepth = 8, bool dither = false )
{
    (void)bitDepth;
    (void)dither;
    writer->f = file;
    if(!writer->f) return false;

    writer->firstFrame = true;
    writer->delaypos = -1;

    // allocate
    writer->oldImage = (uint8_t*)GIF_MALLOC(width*height*4);

    auto& buffer = writer->buffer;
    buffer.clear();

    buffer.append((const uint8_t*)"GIF89a");

    // screen descriptor
    buffer.push_back(width & 0xff);
    buffer.push_back((width >> 8) & 0xff);
    buffer.push_back(height & 0xff);
    buffer.push_back((height >> 8) & 0xff);

    buffer.push_back(0xf0);  // there is an unsorted global color table of 2 entries
    buffer.push_back(0);     // background color
    buffer.push_back(0);     // pixels are square (we need to specify this because it's 1989)

    // now the "global" palette (really just a dummy palette)
    // color 0: black
    buffer.push_back(0);
    buffer.push_back(0);
    buffer.push_back(0);
    // color 1: also black
    buffer.push_back(0);
    buffer.push_back(0);
    buffer.push_back(0);

    if( delay != 0 )
    {
        // animation header
        buffer.push_back(0x21); // extension
        buffer.push_back(0xff); // application specific
        buffer.push_back(11); // length 11
        buffer.append((const uint8_t*)"NETSCAPE2.0"); // yes, really
        buffer.push_back(3); // 3 bytes of NETSCAPE2.0 data

        buffer.push_back(1); // JUST BECAUSE
        buffer.push_back(0); // loop infinitely (byte 0)
        buffer.push_back(0); // loop infinitely (byte 1)

        buffer.push_back(0); // block terminator
    }

    SDL_RWwrite(writer->f, &buffer[0], 1, buffer.size());

    return true;
}

// Writes out a new frame to a GIF in progress.
// The GIFWriter should have been created by GIFBegin.
// AFAIK, it is legal to use different bit depths for different frames of an image -
// this may be handy to save bits in animations that don't change much.
static bool GifWriteFrame( GifWriter* writer, const uint8_t* image, uint32_t width, uint32_t height, uint32_t delay, int bitDepth = 8, bool dither = false )
{
    if(!writer->f) return false;

    const uint8_t* oldImage = writer->firstFrame? NULL : writer->oldImage;
    writer->firstFrame = false;

    GifPalette pal;
    GifMakePalette((dither? NULL : oldImage), image, width, height, bitDepth, dither, &pal);

    if(dither)
        GifDitherImage(oldImage, image, writer->oldImage, width, height, &pal);
    else
        GifThresholdImage(oldImage, image, writer->oldImage, width, height, &pal);

    GifWriteLzwImage(writer->f, writer->oldImage, 0, 0, width, height, delay, &pal, &writer->delaypos, writer->buffer);

    return true;
}

static void GifOverwriteLastDelay(GifWriter* writer, uint32_t delay)
{
    if (writer->delaypos == -1) return;
    SDL_RWops* f = writer->f;

    long int pos = SDL_RWtell(f);
    SDL_RWseek(f, writer->delaypos, RW_SEEK_SET);
    uint8_t buf[2] = {uint8_t(delay & 0xff), uint8_t((delay >> 8) & 0xff)};
    SDL_RWwrite(f, buf, 1, 2);
    SDL_RWseek(f, pos, RW_SEEK_SET);
}

// Writes the EOF code, closes the file handle, and frees temp memory used by a GIF.
// Many if not most viewers will still display a GIF properly if the EOF code is missing,
// but it's still a good idea to write it out.
static bool GifEnd( GifWriter* writer )
{
    if(!writer->f) return false;

    SDL_RWwrite(writer->f, "\x3b", 1, 1); // end of file
    SDL_RWclose(writer->f);
    GIF_FREE(writer->oldImage);

    writer->f = NULL;
    writer->oldImage = NULL;
    writer->delaypos = -1;

    return true;
}

} // namespace

#endif


================================================
FILE: lib/gif_writer.h
================================================
#ifndef GIF_WRITER_HHHH
#define GIF_WRITER_HHHH

#include <stdint.h>  // for integer typedefs
#include <string>

struct SDL_RWops;

namespace GIF_H
{

using buf_t = std::basic_string<uint8_t>;

struct GifWriter
{
    SDL_RWops* f;
    uint8_t* oldImage;
    bool firstFrame;
    long int delaypos;
    buf_t buffer;
};


}

#endif // GIF_WRITER_HHHH


================================================
FILE: lib/json/LICENSE.MIT
================================================
MIT License 

Copyright (c) 2013-2022 Niels Lohmann

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: lib/json/README.md
================================================
[![JSON for Modern C++](docs/json.gif)](https://github.com/nlohmann/json/releases)

[![Build Status](https://ci.appveyor.com/api/projects/status/1acb366xfyg3qybk/branch/develop?svg=true)](https://ci.appveyor.com/project/nlohmann/json)
[![Ubuntu](https://github.com/nlohmann/json/workflows/Ubuntu/badge.svg)](https://github.com/nlohmann/json/actions?query=workflow%3AUbuntu)
[![macOS](https://github.com/nlohmann/json/workflows/macOS/badge.svg)](https://github.com/nlohmann/json/actions?query=workflow%3AmacOS)
[![Windows](https://github.com/nlohmann/json/workflows/Windows/badge.svg)](https://github.com/nlohmann/json/actions?query=workflow%3AWindows)
[![Coverage Status](https://coveralls.io/repos/github/nlohmann/json/badge.svg?branch=develop)](https://coveralls.io/github/nlohmann/json?branch=develop)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/5550/badge.svg)](https://scan.coverity.com/projects/nlohmann-json)
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/e0d1a9d5d6fd46fcb655c4cb930bb3e8)](https://www.codacy.com/gh/nlohmann/json/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=nlohmann/json&amp;utm_campaign=Badge_Grade)
[![Language grade: C/C++](https://img.shields.io/lgtm/grade/cpp/g/nlohmann/json.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/nlohmann/json/context:cpp)
[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/json.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:json)
[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/1mp10JbaANo6FUc7)
[![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://json.nlohmann.me)
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/nlohmann/json/master/LICENSE.MIT)
[![GitHub Releases](https://img.shields.io/github/release/nlohmann/json.svg)](https://github.com/nlohmann/json/releases)
[![Packaging status](https://repology.org/badge/tiny-repos/nlohmann-json.svg)](https://repology.org/project/nlohmann-json/versions)
[![GitHub Downloads](https://img.shields.io/github/downloads/nlohmann/json/total)](https://github.com/nlohmann/json/releases)
[![GitHub Issues](https://img.shields.io/github/issues/nlohmann/json.svg)](https://github.com/nlohmann/json/issues)
[![Average time to resolve an issue](https://isitmaintained.com/badge/resolution/nlohmann/json.svg)](https://isitmaintained.com/project/nlohmann/json "Average time to resolve an issue")
[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/289/badge)](https://bestpractices.coreinfrastructure.org/projects/289)
[![GitHub Sponsors](https://img.shields.io/badge/GitHub-Sponsors-ff69b4)](https://github.com/sponsors/nlohmann)
[![REUSE status](https://api.reuse.software/badge/github.com/nlohmann/json)](https://api.reuse.software/info/github.com/nlohmann/json)
[![Discord](https://img.shields.io/discord/1003743314341793913)](https://discord.gg/6mrGXKvX7y)

- [Design goals](#design-goals)
- [Sponsors](#sponsors)
- [Support](#support) ([documentation](https://json.nlohmann.me), [FAQ](https://json.nlohmann.me/home/faq/), [discussions](https://github.com/nlohmann/json/discussions), [API](https://json.nlohmann.me/api/basic_json/), [bug issues](https://github.com/nlohmann/json/issues))
- [Examples](#examples)
  - [Read JSON from a file](#read-json-from-a-file)
  - [Creating `json` objects from JSON literals](#creating-json-objects-from-json-literals)
  - [JSON as first-class data type](#json-as-first-class-data-type)
  - [Serialization / Deserialization](#serialization--deserialization)
  - [STL-like access](#stl-like-access)
  - [Conversion from STL containers](#conversion-from-stl-containers)
  - [JSON Pointer and JSON Patch](#json-pointer-and-json-patch)
  - [JSON Merge Patch](#json-merge-patch)
  - [Implicit conversions](#implicit-conversions)
  - [Conversions to/from arbitrary types](#arbitrary-types-conversions)
  - [Specializing enum conversion](#specializing-enum-conversion)
  - [Binary formats (BSON, CBOR, MessagePack, UBJSON, and BJData)](#binary-formats-bson-cbor-messagepack-ubjson-and-bjdata)
- [Supported compilers](#supported-compilers)
- [Integration](#integration)
  - [CMake](#cmake)
  - [Package Managers](#package-managers)
  - [Pkg-config](#pkg-config)
- [License](#license)
- [Contact](#contact)
- [Thanks](#thanks)
- [Used third-party tools](#used-third-party-tools)
- [Projects using JSON for Modern C++](#projects-using-json-for-modern-c)
- [Notes](#notes)
- [Execute unit tests](#execute-unit-tests)

## Design goals

There are myriads of [JSON](https://json.org) libraries out there, and each may even have its reason to exist. Our class had these design goals:

- **Intuitive syntax**. In languages such as Python, JSON feels like a first class data type. We used all the operator magic of modern C++ to achieve the same feeling in your code. Check out the [examples below](#examples) and you'll know what I mean.

- **Trivial integration**. Our whole code consists of a single header file [`json.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json.hpp). That's it. No library, no subproject, no dependencies, no complex build system. The class is written in vanilla C++11. All in all, everything should require no adjustment of your compiler flags or project settings.

- **Serious testing**. Our code is heavily [unit-tested](https://github.com/nlohmann/json/tree/develop/tests/src) and covers [100%](https://coveralls.io/r/nlohmann/json) of the code, including all exceptional behavior. Furthermore, we checked with [Valgrind](https://valgrind.org) and the [Clang Sanitizers](https://clang.llvm.org/docs/index.html) that there are no memory leaks. [Google OSS-Fuzz](https://github.com/google/oss-fuzz/tree/master/projects/json) additionally runs fuzz tests against all parsers 24/7, effectively executing billions of tests so far. To maintain high quality, the project is following the [Core Infrastructure Initiative (CII) best practices](https://bestpractices.coreinfrastructure.org/projects/289).

Other aspects were not so important to us:

- **Memory efficiency**. Each JSON object has an overhead of one pointer (the maximal size of a union) and one enumeration element (1 byte). The default generalization uses the following C++ data types: `std::string` for strings, `int64_t`, `uint64_t` or `double` for numbers, `std::map` for objects, `std::vector` for arrays, and `bool` for Booleans. However, you can template the generalized class `basic_json` to your needs.

- **Speed**. There are certainly [faster JSON libraries](https://github.com/miloyip/nativejson-benchmark#parsing-time) out there. However, if your goal is to speed up your development by adding JSON support with a single header, then this library is the way to go. If you know how to use a `std::vector` or `std::map`, you are already set.

See the [contribution guidelines](https://github.com/nlohmann/json/blob/master/.github/CONTRIBUTING.md#please-dont) for more information.


## Sponsors

You can sponsor this library at [GitHub Sponsors](https://github.com/sponsors/nlohmann).

### :office: Corporate Sponsor

[![](https://upload.wikimedia.org/wikipedia/commons/thumb/9/9e/Codacy-logo-black.svg/320px-Codacy-logo-black.svg.png)](https://github.com/codacy/About)

### :label: Named Sponsors

- [Michael Hartmann](https://github.com/reFX-Mike)
- [Stefan Hagen](https://github.com/sthagen)
- [Steve Sperandeo](https://github.com/homer6)
- [Robert Jefe Lindstädt](https://github.com/eljefedelrodeodeljefe)
- [Steve Wagner](https://github.com/ciroque)

Thanks everyone!

## Support

:question: If you have a **question**, please check if it is already answered in the [**FAQ**](https://json.nlohmann.me/home/faq/) or the [**Q&A**](https://github.com/nlohmann/json/discussions/categories/q-a) section. If not, please [**ask a new question**](https://github.com/nlohmann/json/discussions/new) there.

:books: If you want to **learn more** about how to use the library, check out the rest of the [**README**](#examples), have a look at [**code examples**](https://github.com/nlohmann/json/tree/develop/docs/examples), or browse through the [**help pages**](https://json.nlohmann.me).

:construction: If you want to understand the **API** better, check out the [**API Reference**](https://json.nlohmann.me/api/basic_json/).

:bug: If you found a **bug**, please check the [**FAQ**](https://json.nlohmann.me/home/faq/) if it is a known issue or the result of a design decision. Please also have a look at the [**issue list**](https://github.com/nlohmann/json/issues) before you [**create a new issue**](https://github.com/nlohmann/json/issues/new/choose). Please provide as much information as possible to help us understand and reproduce your issue.

There is also a [**docset**](https://github.com/Kapeli/Dash-User-Contributions/tree/master/docsets/JSON_for_Modern_C%2B%2B) for the documentation browsers [Dash](https://kapeli.com/dash), [Velocity](https://velocity.silverlakesoftware.com), and [Zeal](https://zealdocs.org) that contains the full [documentation](https://json.nlohmann.me) as offline resource.

## Examples

Here are some examples to give you an idea how to use the class.

Beside the examples below, you may want to:

→ Check the [documentation](https://json.nlohmann.me/)\
→ Browse the [standalone example files](https://github.com/nlohmann/json/tree/develop/docs/examples)

Every API function (documented in the [API Documentation](https://json.nlohmann.me/api/basic_json/)) has a corresponding standalone example file. For example, the [`emplace()`](https://json.nlohmann.me/api/basic_json/emplace/) function has a matching [emplace.cpp](https://github.com/nlohmann/json/blob/develop/docs/examples/emplace.cpp) example file.

### Read JSON from a file

The `json` class provides an API for manipulating a JSON value. To create a `json` object by reading a JSON file:

```cpp
#include <fstream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

// ...

std::ifstream f("example.json");
json data = json::parse(f);
```

### Creating `json` objects from JSON literals

Assume you want to create hard-code this literal JSON value in a file, as a `json` object:

```json
{
  "pi": 3.141,
  "happy": true
}
```

There are various options:

```cpp
// Using (raw) string literals and json::parse
json ex1 = json::parse(R"(
  {
    "pi": 3.141,
    "happy": true
  }
)");

// Using user-defined (raw) string literals
using namespace nlohmann::literals;
json ex2 = R"(
  {
    "pi": 3.141,
    "happy": true
  }
)"_json;

// Using initializer lists
json ex3 = {
  {"happy", true},
  {"pi", 3.141},
};
```

### JSON as first-class data type

Here are some examples to give you an idea how to use the class.

Assume you want to create the JSON object

```json
{
  "pi": 3.141,
  "happy": true,
  "name": "Niels",
  "nothing": null,
  "answer": {
    "everything": 42
  },
  "list": [1, 0, 2],
  "object": {
    "currency": "USD",
    "value": 42.99
  }
}
```

With this library, you could write:

```cpp
// create an empty structure (null)
json j;

// add a number that is stored as double (note the implicit conversion of j to an object)
j["pi"] = 3.141;

// add a Boolean that is stored as bool
j["happy"] = true;

// add a string that is stored as std::string
j["name"] = "Niels";

// add another null object by passing nullptr
j["nothing"] = nullptr;

// add an object inside the object
j["answer"]["everything"] = 42;

// add an array that is stored as std::vector (using an initializer list)
j["list"] = { 1, 0, 2 };

// add another object (using an initializer list of pairs)
j["object"] = { {"currency", "USD"}, {"value", 42.99} };

// instead, you could also write (which looks very similar to the JSON above)
json j2 = {
  {"pi", 3.141},
  {"happy", true},
  {"name", "Niels"},
  {"nothing", nullptr},
  {"answer", {
    {"everything", 42}
  }},
  {"list", {1, 0, 2}},
  {"object", {
    {"currency", "USD"},
    {"value", 42.99}
  }}
};
```

Note that in all these cases, you never need to "tell" the compiler which JSON value type you want to use. If you want to be explicit or express some edge cases, the functions [`json::array()`](https://json.nlohmann.me/api/basic_json/array/) and [`json::object()`](https://json.nlohmann.me/api/basic_json/object/) will help:

```cpp
// a way to express the empty array []
json empty_array_explicit = json::array();

// ways to express the empty object {}
json empty_object_implicit = json({});
json empty_object_explicit = json::object();

// a way to express an _array_ of key/value pairs [["currency", "USD"], ["value", 42.99]]
json array_not_object = json::array({ {"currency", "USD"}, {"value", 42.99} });
```

### Serialization / Deserialization

#### To/from strings

You can create a JSON value (deserialization) by appending `_json` to a string literal:

```cpp
// create object from string literal
json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;

// or even nicer with a raw string literal
auto j2 = R"(
  {
    "happy": true,
    "pi": 3.141
  }
)"_json;
```

Note that without appending the `_json` suffix, the passed string literal is not parsed, but just used as JSON string
value. That is, `json j = "{ \"happy\": true, \"pi\": 3.141 }"` would just store the string
`"{ "happy": true, "pi": 3.141 }"` rather than parsing the actual object.

The string literal should be brought into scope with `using namespace nlohmann::literals;`
(see [`json::parse()`](https://json.nlohmann.me/api/operator_literal_json/)).

The above example can also be expressed explicitly using [`json::parse()`](https://json.nlohmann.me/api/basic_json/parse/):

```cpp
// parse explicitly
auto j3 = json::parse(R"({"happy": true, "pi": 3.141})");
```

You can also get a string representation of a JSON value (serialize):

```cpp
// explicit conversion to string
std::string s = j.dump();    // {"happy":true,"pi":3.141}

// serialization with pretty printing
// pass in the amount of spaces to indent
std::cout << j.dump(4) << std::endl;
// {
//     "happy": true,
//     "pi": 3.141
// }
```

Note the difference between serialization and assignment:

```cpp
// store a string in a JSON value
json j_string = "this is a string";

// retrieve the string value
auto cpp_string = j_string.get<std::string>();
// retrieve the string value (alternative when a variable already exists)
std::string cpp_string2;
j_string.get_to(cpp_string2);

// retrieve the serialized value (explicit JSON serialization)
std::string serialized_string = j_string.dump();

// output of original string
std::cout << cpp_string << " == " << cpp_string2 << " == " << j_string.get<std::string>() << '\n';
// output of serialized value
std::cout << j_string << " == " << serialized_string << std::endl;
```

[`.dump()`](https://json.nlohmann.me/api/basic_json/dump/) returns the originally stored string value.

Note the library only supports UTF-8. When you store strings with different encodings in the library, calling [`dump()`](https://json.nlohmann.me/api/basic_json/dump/) may throw an exception unless `json::error_handler_t::replace` or `json::error_handler_t::ignore` are used as error handlers.

#### To/from streams (e.g. files, string streams)

You can also use streams to serialize and deserialize:

```cpp
// deserialize from standard input
json j;
std::cin >> j;

// serialize to standard output
std::cout << j;

// the setw manipulator was overloaded to set the indentation for pretty printing
std::cout << std::setw(4) << j << std::endl;
```

These operators work for any subclasses of `std::istream` or `std::ostream`. Here is the same example with files:

```cpp
// read a JSON file
std::ifstream i("file.json");
json j;
i >> j;

// write prettified JSON to another file
std::ofstream o("pretty.json");
o << std::setw(4) << j << std::endl;
```

Please note that setting the exception bit for `failbit` is inappropriate for this use case. It will result in program termination due to the `noexcept` specifier in use.

#### Read from iterator range

You can also parse JSON from an iterator range; that is, from any container accessible by iterators whose `value_type` is an integral type of 1, 2 or 4 bytes, which will be interpreted as UTF-8, UTF-16 and UTF-32 respectively. For instance, a `std::vector<std::uint8_t>`, or a `std::list<std::uint16_t>`:

```cpp
std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v.begin(), v.end());
```

You may leave the iterators for the range [begin, end):

```cpp
std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v);
```

#### Custom data source

Since the parse function accepts arbitrary iterator ranges, you can provide your own data sources by implementing the `LegacyInputIterator` concept.

```cpp
struct MyContainer {
  void advance();
  const char& get_current();
};

struct MyIterator {
    using difference_type = std::ptrdiff_t;
    using value_type = char;
    using pointer = const char*;
    using reference = const char&;
    using iterator_category = std::input_iterator_tag;

    MyIterator& operator++() {
        MyContainer.advance();
        return *this;
    }

    bool operator!=(const MyIterator& rhs) const {
        return rhs.target != target;
    }

    reference operator*() const {
        return target.get_current();
    }

    MyContainer* target = nullptr;
};

MyIterator begin(MyContainer& tgt) {
    return MyIterator{&tgt};
}

MyIterator end(const MyContainer&) {
    return {};
}

void foo() {
    MyContainer c;
    json j = json::parse(c);
}
```

#### SAX interface

The library uses a SAX-like interface with the following functions:

```cpp
// called when null is parsed
bool null();

// called when a boolean is parsed; value is passed
bool boolean(bool val);

// called when a signed or unsigned integer number is parsed; value is passed
bool number_integer(number_integer_t val);
bool number_unsigned(number_unsigned_t val);

// called when a floating-point number is parsed; value and original string is passed
bool number_float(number_float_t val, const string_t& s);

// called when a string is parsed; value is passed and can be safely moved away
bool string(string_t& val);
// called when a binary value is parsed; value is passed and can be safely moved away
bool binary(binary_t& val);

// called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
bool start_object(std::size_t elements);
bool end_object();
bool start_array(std::size_t elements);
bool end_array();
// called when an object key is parsed; value is passed and can be safely moved away
bool key(string_t& val);

// called when a parse error occurs; byte position, the last token, and an exception is passed
bool parse_error(std::size_t position, const std::string& last_token, const detail::exception& ex);
```

The return value of each function determines whether parsing should proceed.

To implement your own SAX handler, proceed as follows:

1. Implement the SAX interface in a class. You can use class `nlohmann::json_sax<json>` as base class, but you can also use any class where the functions described above are implemented and public.
2. Create an object of your SAX interface class, e.g. `my_sax`.
3. Call `bool json::sax_parse(input, &my_sax)`; where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.

Note the `sax_parse` function only returns a `bool` indicating the result of the last executed SAX event. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).

### STL-like access

We designed the JSON class to behave just like an STL container. In fact, it satisfies the [**ReversibleContainer**](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer) requirement.

```cpp
// create an array using push_back
json j;
j.push_back("foo");
j.push_back(1);
j.push_back(true);

// also use emplace_back
j.emplace_back(1.78);

// iterate the array
for (json::iterator it = j.begin(); it != j.end(); ++it) {
  std::cout << *it << '\n';
}

// range-based for
for (auto& element : j) {
  std::cout << element << '\n';
}

// getter/setter
const auto tmp = j[0].get<std::string>();
j[1] = 42;
bool foo = j.at(2);

// comparison
j == R"(["foo", 1, true, 1.78])"_json;  // true

// other stuff
j.size();     // 4 entries
j.empty();    // false
j.type();     // json::value_t::array
j.clear();    // the array is empty again

// convenience type checkers
j.is_null();
j.is_boolean();
j.is_number();
j.is_object();
j.is_array();
j.is_string();

// create an object
json o;
o["foo"] = 23;
o["bar"] = false;
o["baz"] = 3.141;

// also use emplace
o.emplace("weather", "sunny");

// special iterator member functions for objects
for (json::iterator it = o.begin(); it != o.end(); ++it) {
  std::cout << it.key() << " : " << it.value() << "\n";
}

// the same code as range for
for (auto& el : o.items()) {
  std::cout << el.key() << " : " << el.value() << "\n";
}

// even easier with structured bindings (C++17)
for (auto& [key, value] : o.items()) {
  std::cout << key << " : " << value << "\n";
}

// find an entry
if (o.contains("foo")) {
  // there is an entry with key "foo"
}

// or via find and an iterator
if (o.find("foo") != o.end()) {
  // there is an entry with key "foo"
}

// or simpler using count()
int foo_present = o.count("foo"); // 1
int fob_present = o.count("fob"); // 0

// delete an entry
o.erase("foo");
```


### Conversion from STL containers

Any sequence container (`std::array`, `std::vector`, `std::deque`, `std::forward_list`, `std::list`) whose values can be used to construct JSON values (e.g., integers, floating point numbers, Booleans, string types, or again STL containers described in this section) can be used to create a JSON array. The same holds for similar associative containers (`std::set`, `std::multiset`, `std::unordered_set`, `std::unordered_multiset`), but in these cases the order of the elements of the array depends on how the elements are ordered in the respective STL container.

```cpp
std::vector<int> c_vector {1, 2, 3, 4};
json j_vec(c_vector);
// [1, 2, 3, 4]

std::deque<double> c_deque {1.2, 2.3, 3.4, 5.6};
json j_deque(c_deque);
// [1.2, 2.3, 3.4, 5.6]

std::list<bool> c_list {true, true, false, true};
json j_list(c_list);
// [true, true, false, true]

std::forward_list<int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};
json j_flist(c_flist);
// [12345678909876, 23456789098765, 34567890987654, 45678909876543]

std::array<unsigned long, 4> c_array {{1, 2, 3, 4}};
json j_array(c_array);
// [1, 2, 3, 4]

std::set<std::string> c_set {"one", "two", "three", "four", "one"};
json j_set(c_set); // only one entry for "one" is used
// ["four", "one", "three", "two"]

std::unordered_set<std::string> c_uset {"one", "two", "three", "four", "one"};
json j_uset(c_uset); // only one entry for "one" is used
// maybe ["two", "three", "four", "one"]

std::multiset<std::string> c_mset {"one", "two", "one", "four"};
json j_mset(c_mset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]

std::unordered_multiset<std::string> c_umset {"one", "two", "one", "four"};
json j_umset(c_umset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]
```

Likewise, any associative key-value containers (`std::map`, `std::multimap`, `std::unordered_map`, `std::unordered_multimap`) whose keys can construct an `std::string` and whose values can be used to construct JSON values (see examples above) can be used to create a JSON object. Note that in case of multimaps only one key is used in the JSON object and the value depends on the internal order of the STL container.

```cpp
std::map<std::string, int> c_map { {"one", 1}, {"two", 2}, {"three", 3} };
json j_map(c_map);
// {"one": 1, "three": 3, "two": 2 }

std::unordered_map<const char*, double> c_umap { {"one", 1.2}, {"two", 2.3}, {"three", 3.4} };
json j_umap(c_umap);
// {"one": 1.2, "two": 2.3, "three": 3.4}

std::multimap<std::string, bool> c_mmap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_mmap(c_mmap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}

std::unordered_multimap<std::string, bool> c_ummap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_ummap(c_ummap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}
```

### JSON Pointer and JSON Patch

The library supports **JSON Pointer** ([RFC 6901](https://tools.ietf.org/html/rfc6901)) as alternative means to address structured values. On top of this, **JSON Patch** ([RFC 6902](https://tools.ietf.org/html/rfc6902)) allows describing differences between two JSON values - effectively allowing patch and diff operations known from Unix.

```cpp
// a JSON value
json j_original = R"({
  "baz": ["one", "two", "three"],
  "foo": "bar"
})"_json;

// access members with a JSON pointer (RFC 6901)
j_original["/baz/1"_json_pointer];
// "two"

// a JSON patch (RFC 6902)
json j_patch = R"([
  { "op": "replace", "path": "/baz", "value": "boo" },
  { "op": "add", "path": "/hello", "value": ["world"] },
  { "op": "remove", "path": "/foo"}
])"_json;

// apply the patch
json j_result = j_original.patch(j_patch);
// {
//    "baz": "boo",
//    "hello": ["world"]
// }

// calculate a JSON patch from two JSON values
json::diff(j_result, j_original);
// [
//   { "op":" replace", "path": "/baz", "value": ["one", "two", "three"] },
//   { "op": "remove","path": "/hello" },
//   { "op": "add", "path": "/foo", "value": "bar" }
// ]
```

### JSON Merge Patch

The library supports **JSON Merge Patch** ([RFC 7386](https://tools.ietf.org/html/rfc7386)) as a patch format. Instead of using JSON Pointer (see above) to specify values to be manipulated, it describes the changes using a syntax that closely mimics the document being modified.

```cpp
// a JSON value
json j_document = R"({
  "a": "b",
  "c": {
    "d": "e",
    "f": "g"
  }
})"_json;

// a patch
json j_patch = R"({
  "a":"z",
  "c": {
    "f": null
  }
})"_json;

// apply the patch
j_document.merge_patch(j_patch);
// {
//  "a": "z",
//  "c": {
//    "d": "e"
//  }
// }
```

### Implicit conversions

Supported types can be implicitly converted to JSON values.

It is recommended to **NOT USE** implicit conversions **FROM** a JSON value.
You can find more details about this recommendation [here](https://www.github.com/nlohmann/json/issues/958).
You can switch off implicit conversions by defining `JSON_USE_IMPLICIT_CONVERSIONS` to `0` before including the `json.hpp` header. When using CMake, you can also achieve this by setting the option `JSON_ImplicitConversions` to `OFF`.

```cpp
// strings
std::string s1 = "Hello, world!";
json js = s1;
auto s2 = js.get<std::string>();
// NOT RECOMMENDED
std::string s3 = js;
std::string s4;
s4 = js;

// Booleans
bool b1 = true;
json jb = b1;
auto b2 = jb.get<bool>();
// NOT RECOMMENDED
bool b3 = jb;
bool b4;
b4 = jb;

// numbers
int i = 42;
json jn = i;
auto f = jn.get<double>();
// NOT RECOMMENDED
double f2 = jb;
double f3;
f3 = jb;

// etc.
```

Note that `char` types are not automatically converted to JSON strings, but to integer numbers. A conversion to a string must be specified explicitly:

```cpp
char ch = 'A';                       // ASCII value 65
json j_default = ch;                 // stores integer number 65
json j_string = std::string(1, ch);  // stores string "A"
```

### Arbitrary types conversions

Every type can be serialized in JSON, not just STL containers and scalar types. Usually, you would do something along those lines:

```cpp
namespace ns {
    // a simple struct to model a person
    struct person {
        std::string name;
        std::string address;
        int age;
    };
}

ns::person p = {"Ned Flanders", "744 Evergreen Terrace", 60};

// convert to JSON: copy each value into the JSON object
json j;
j["name"] = p.name;
j["address"] = p.address;
j["age"] = p.age;

// ...

// convert from JSON: copy each value from the JSON object
ns::person p {
    j["name"].get<std::string>(),
    j["address"].get<std::string>(),
    j["age"].get<int>()
};
```

It works, but that's quite a lot of boilerplate... Fortunately, there's a better way:

```cpp
// create a person
ns::person p {"Ned Flanders", "744 Evergreen Terrace", 60};

// conversion: person -> json
json j = p;

std::cout << j << std::endl;
// {"address":"744 Evergreen Terrace","age":60,"name":"Ned Flanders"}

// conversion: json -> person
auto p2 = j.get<ns::person>();

// that's it
assert(p == p2);
```

#### Basic usage

To make this work with one of your types, you only need to provide two functions:

```cpp
using json = nlohmann::json;

namespace ns {
    void to_json(json& j, const person& p) {
        j = json{{"name", p.name}, {"address", p.address}, {"age", p.age}};
    }

    void from_json(const json& j, person& p) {
        j.at("name").get_to(p.name);
        j.at("address").get_to(p.address);
        j.at("age").get_to(p.age);
    }
} // namespace ns
```

That's all! When calling the `json` constructor with your type, your custom `to_json` method will be automatically called.
Likewise, when calling `get<your_type>()` or `get_to(your_type&)`, the `from_json` method will be called.

Some important things:

* Those methods **MUST** be in your type's namespace (which can be the global namespace), or the library will not be able to locate them (in this example, they are in namespace `ns`, where `person` is defined).
* Those methods **MUST** be available (e.g., proper headers must be included) everywhere you use these conversions. Look at [issue 1108](https://github.com/nlohmann/json/issues/1108) for errors that may occur otherwise.
* When using `get<your_type>()`, `your_type` **MUST** be [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible). (There is a way to bypass this requirement described later.)
* In function `from_json`, use function [`at()`](https://json.nlohmann.me/api/basic_json/at/) to access the object values rather than `operator[]`. In case a key does not exist, `at` throws an exception that you can handle, whereas `operator[]` exhibits undefined behavior.
* You do not need to add serializers or deserializers for STL types like `std::vector`: the library already implements these.

#### Simplify your life with macros

If you just want to serialize/deserialize some structs, the `to_json`/`from_json` functions can be a lot of boilerplate.

There are two macros to make your life easier as long as you (1) want to use a JSON object as serialization and (2) want to use the member variable names as object keys in that object:

- `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(name, member1, member2, ...)` is to be defined inside the namespace of the class/struct to create code for.
- `NLOHMANN_DEFINE_TYPE_INTRUSIVE(name, member1, member2, ...)` is to be defined inside the class/struct to create code for. This macro can also access private members.

In both macros, the first parameter is the name of the class/struct, and all remaining parameters name the members.

##### Examples

The `to_json`/`from_json` functions for the `person` struct above can be created with:

```cpp
namespace ns {
    NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)
}
```

Here is an example with private members, where `NLOHMANN_DEFINE_TYPE_INTRUSIVE` is needed:

```cpp
namespace ns {
    class address {
      private:
        std::string street;
        int housenumber;
        int postcode;

      public:
        NLOHMANN_DEFINE_TYPE_INTRUSIVE(address, street, housenumber, postcode)
    };
}
```

#### How do I convert third-party types?

This requires a bit more advanced technique. But first, let's see how this conversion mechanism works:

The library uses **JSON Serializers** to convert types to json.
The default serializer for `nlohmann::json` is `nlohmann::adl_serializer` (ADL means [Argument-Dependent Lookup](https://en.cppreference.com/w/cpp/language/adl)).

It is implemented like this (simplified):

```cpp
template <typename T>
struct adl_serializer {
    static void to_json(json& j, const T& value) {
        // calls the "to_json" method in T's namespace
    }

    static void from_json(const json& j, T& value) {
        // same thing, but with the "from_json" method
    }
};
```

This serializer works fine when you have control over the type's namespace. However, what about `boost::optional` or `std::filesystem::path` (C++17)? Hijacking the `boost` namespace is pretty bad, and it's illegal to add something other than template specializations to `std`...

To solve this, you need to add a specialization of `adl_serializer` to the `nlohmann` namespace, here's an example:

```cpp
// partial specialization (full specialization works too)
namespace nlohmann {
    template <typename T>
    struct adl_serializer<boost::optional<T>> {
        static void to_json(json& j, const boost::optional<T>& opt) {
            if (opt == boost::none) {
                j = nullptr;
            } else {
              j = *opt; // this will call adl_serializer<T>::to_json which will
                        // find the free function to_json in T's namespace!
            }
        }

        static void from_json(const json& j, boost::optional<T>& opt) {
            if (j.is_null()) {
                opt = boost::none;
            } else {
                opt = j.get<T>(); // same as above, but with
                                  // adl_serializer<T>::from_json
            }
        }
    };
}
```

#### How can I use `get()` for non-default constructible/non-copyable types?

There is a way, if your type is [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible). You will need to specialize the `adl_serializer` as well, but with a special `from_json` overload:

```cpp
struct move_only_type {
    move_only_type() = delete;
    move_only_type(int ii): i(ii) {}
    move_only_type(const move_only_type&) = delete;
    move_only_type(move_only_type&&) = default;

    int i;
};

namespace nlohmann {
    template <>
    struct adl_serializer<move_only_type> {
        // note: the return type is no longer 'void', and the method only takes
        // one argument
        static move_only_type from_json(const json& j) {
            return {j.get<int>()};
        }

        // Here's the catch! You must provide a to_json method! Otherwise, you
        // will not be able to convert move_only_type to json, since you fully
        // specialized adl_serializer on that type
        static void to_json(json& j, move_only_type t) {
            j = t.i;
        }
    };
}
```

#### Can I write my own serializer? (Advanced use)

Yes. You might want to take a look at [`unit-udt.cpp`](https://github.com/nlohmann/json/blob/develop/tests/src/unit-udt.cpp) in the test suite, to see a few examples.

If you write your own serializer, you'll need to do a few things:

- use a different `basic_json` alias than `nlohmann::json` (the last template parameter of `basic_json` is the `JSONSerializer`)
- use your `basic_json` alias (or a template parameter) in all your `to_json`/`from_json` methods
- use `nlohmann::to_json` and `nlohmann::from_json` when you need ADL

Here is an example, without simplifications, that only accepts types with a size <= 32, and uses ADL.

```cpp
// You should use void as a second template argument
// if you don't need compile-time checks on T
template<typename T, typename SFINAE = typename std::enable_if<sizeof(T) <= 32>::type>
struct less_than_32_serializer {
    template <typename BasicJsonType>
    static void to_json(BasicJsonType& j, T value) {
        // we want to use ADL, and call the correct to_json overload
        using nlohmann::to_json; // this method is called by adl_serializer,
                                 // this is where the magic happens
        to_json(j, value);
    }

    template <typename BasicJsonType>
    static void from_json(const BasicJsonType& j, T& value) {
        // same thing here
        using nlohmann::from_json;
        from_json(j, value);
    }
};
```

Be **very** careful when reimplementing your serializer, you can stack overflow if you don't pay attention:

```cpp
template <typename T, void>
struct bad_serializer
{
    template <typename BasicJsonType>
    static void to_json(BasicJsonType& j, const T& value) {
      // this calls BasicJsonType::json_serializer<T>::to_json(j, value);
      // if BasicJsonType::json_serializer == bad_serializer ... oops!
      j = value;
    }

    template <typename BasicJsonType>
    static void to_json(const BasicJsonType& j, T& value) {
      // this calls BasicJsonType::json_serializer<T>::from_json(j, value);
      // if BasicJsonType::json_serializer == bad_serializer ... oops!
      value = j.template get<T>(); // oops!
    }
};
```

### Specializing enum conversion

By default, enum values are serialized to JSON as integers. In some cases this could result in undesired behavior. If an enum is modified or re-ordered after data has been serialized to JSON, the later de-serialized JSON data may be undefined or a different enum value than was originally intended.

It is possible to more precisely specify how a given enum is mapped to and from JSON as shown below:

```cpp
// example enum type declaration
enum TaskState {
    TS_STOPPED,
    TS_RUNNING,
    TS_COMPLETED,
    TS_INVALID=-1,
};

// map TaskState values to JSON as strings
NLOHMANN_JSON_SERIALIZE_ENUM( TaskState, {
    {TS_INVALID, nullptr},
    {TS_STOPPED, "stopped"},
    {TS_RUNNING, "running"},
    {TS_COMPLETED, "completed"},
})
```

The `NLOHMANN_JSON_SERIALIZE_ENUM()` macro declares a set of `to_json()` / `from_json()` functions for type `TaskState` while avoiding repetition and boilerplate serialization code.

**Usage:**

```cpp
// enum to JSON as string
json j = TS_STOPPED;
assert(j == "stopped");

// json string to enum
json j3 = "running";
assert(j3.get<TaskState>() == TS_RUNNING);

// undefined json value to enum (where the first map entry above is the default)
json jPi = 3.14;
assert(jPi.get<TaskState>() == TS_INVALID );
```

Just as in [Arbitrary Type Conversions](#arbitrary-types-conversions) above,
- `NLOHMANN_JSON_SERIALIZE_ENUM()` MUST be declared in your enum type's namespace (which can be the global namespace), or the library will not be able to locate it, and it will default to integer serialization.
- It MUST be available (e.g., proper headers must be included) everywhere you use the conversions.

Other Important points:
- When using `get<ENUM_TYPE>()`, undefined JSON values will default to the first pair specified in your map. Select this default pair carefully.
- If an enum or JSON value is specified more than once in your map, the first matching occurrence from the top of the map will be returned when converting to or from JSON.

### Binary formats (BSON, CBOR, MessagePack, UBJSON, and BJData)

Though JSON is a ubiquitous data format, it is not a very compact format suitable for data exchange, for instance over a network. Hence, the library supports [BSON](https://bsonspec.org) (Binary JSON), [CBOR](https://cbor.io) (Concise Binary Object Representation), [MessagePack](https://msgpack.org), [UBJSON](https://ubjson.org) (Universal Binary JSON Specification) and [BJData](https://neurojson.org/bjdata) (Binary JData) to efficiently encode JSON values to byte vectors and to decode such vectors.

```cpp
// create a JSON value
json j = R"({"compact": true, "schema": 0})"_json;

// serialize to BSON
std::vector<std::uint8_t> v_bson = json::to_bson(j);

// 0x1B, 0x00, 0x00, 0x00, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0x00, 0x01, 0x10, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

// roundtrip
json j_from_bson = json::from_bson(v_bson);

// serialize to CBOR
std::vector<std::uint8_t> v_cbor = json::to_cbor(j);

// 0xA2, 0x67, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0xF5, 0x66, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x00

// roundtrip
json j_from_cbor = json::from_cbor(v_cbor);

// serialize to MessagePack
std::vector<std::uint8_t> v_msgpack = json::to_msgpack(j);

// 0x82, 0xA7, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0xC3, 0xA6, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x00

// roundtrip
json j_from_msgpack = json::from_msgpack(v_msgpack);

// serialize to UBJSON
std::vector<std::uint8_t> v_ubjson = json::to_ubjson(j);

// 0x7B, 0x69, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0x54, 0x69, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x69, 0x00, 0x7D

// roundtrip
json j_from_ubjson = json::from_ubjson(v_ubjson);
```

The library also supports binary types from BSON, CBOR (byte strings), and MessagePack (bin, ext, fixext). They are stored by default as `std::vector<std::uint8_t>` to be processed outside the library.

```cpp
// CBOR byte string with payload 0xCAFE
std::vector<std::uint8_t> v = {0x42, 0xCA, 0xFE};

// read value
json j = json::from_cbor(v);

// the JSON value has type binary
j.is_binary(); // true

// get reference to stored binary value
auto& binary = j.get_binary();

// the binary value has no subtype (CBOR has no binary subtypes)
binary.has_subtype(); // false

// access std::vector<std::uint8_t> member functions
binary.size(); // 2
binary[0]; // 0xCA
binary[1]; // 0xFE

// set subtype to 0x10
binary.set_subtype(0x10);

// serialize to MessagePack
auto cbor = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE
```


## Supported compilers

Though it's 2022 already, the support for C++11 is still a bit sparse. Currently, the following compilers are known to work:

- GCC 4.8 - 12.0 (and possibly later)
- Clang 3.4 - 15.0 (and possibly later)
- Apple Clang 9.1 - 13.1 (and possibly later)
- Intel C++ Compiler 17.0.2 (and possibly later)
- Nvidia CUDA Compiler 11.0.221 (and possibly later)
- Microsoft Visual C++ 2015 / Build Tools 14.0.25123.0 (and possibly later)
- Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later)
- Microsoft Visual C++ 2019 / Build Tools 16.3.1+1def00d3d (and possibly later)
- Microsoft Visual C++ 2022 / Build Tools 19.30.30709.0 (and possibly later)

I would be happy to learn about other compilers/versions.

Please note:

- GCC 4.8 has a bug [57824](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57824)): multiline raw strings cannot be the arguments to macros. Don't use multiline raw strings directly in macros with this compiler.
- Android defaults to using very old compilers and C++ libraries. To fix this, add the following to your `Application.mk`. This will switch to the LLVM C++ library, the Clang compiler, and enable C++11 and other features disabled by default.

    ```
    APP_STL := c++_shared
    NDK_TOOLCHAIN_VERSION := clang3.6
    APP_CPPFLAGS += -frtti -fexceptions
    ```

    The code compiles successfully with [Android NDK](https://developer.android.com/ndk/index.html?hl=ml), Revision 9 - 11 (and possibly later) and [CrystaX's Android NDK](https://www.crystax.net/en/android/ndk) version 10.

- For GCC running on MinGW or Android SDK, the error `'to_string' is not a member of 'std'` (or similarly, for `strtod` or `strtof`) may occur. Note this is not an issue with the code,  but rather with the compiler itself. On Android, see above to build with a newer environment.  For MinGW, please refer to [this site](https://tehsausage.com/mingw-to-string) and [this discussion](https://github.com/nlohmann/json/issues/136) for information on how to fix this bug. For Android NDK using `APP_STL := gnustl_static`, please refer to [this discussion](https://github.com/nlohmann/json/issues/219).

- Unsupported versions of GCC and Clang are rejected by `#error` directives. This can be switched off by defining `JSON_SKIP_UNSUPPORTED_COMPILER_CHECK`. Note that you can expect no support in this case.

The following compilers are currently used in continuous integration at [AppVeyor](https://ci.appveyor.com/project/nlohmann/json), [Drone CI](https://cloud.drone.io/nlohmann/json), and [GitHub Actions](https://github.com/nlohmann/json/actions):

| Compiler                                                                                               | Operating System   | CI Provider    |
|--------------------------------------------------------------------------------------------------------|--------------------|----------------|
| Apple Clang 11.0.3 (clang-1103.0.32.62);  Xcode 11.7                                                   | macOS 11.7.1       | GitHub Actions |
| Apple Clang 12.0.0 (clang-1200.0.32.29);  Xcode 12.4                                                   | macOS 11.7.1       | GitHub Actions |
| Apple Clang 12.0.5 (clang-1205.0.22.11);  Xcode 12.5.1                                                 | macOS 11.7.1       | GitHub Actions |
| Apple Clang 13.0.0 (clang-1300.0.29.3);   Xcode 13.0                                                   | macOS 11.7.1       | GitHub Actions |
| Apple Clang 13.0.0 (clang-1300.0.29.3);   Xcode 13.1                                                   | macOS 12.6.1       | GitHub Actions |
| Apple Clang 13.0.0 (clang-1300.0.29.30);  Xcode 13.2.1                                                 | macOS 12.6.1       | GitHub Actions |
| Apple Clang 13.1.6 (clang-1316.0.21.2.3); Xcode 13.3.1                                                 | macOS 12.6.1       | GitHub Actions |
| Apple Clang 13.1.6 (clang-1316.0.21.2.5); Xcode 13.4.1                                                 | macOS 12.6.1       | GitHub Actions |
| Apple Clang 14.0.0 (clang-1400.0.29.102); Xcode 14.0                                                   | macOS 12.6.1       | GitHub Actions |
| Apple Clang 14.0.0 (clang-1400.0.29.102); Xcode 14.0.1                                                 | macOS 12.6.1       | GitHub Actions |
| Apple Clang 14.0.0 (clang-1400.0.29.202); Xcode 14.1                                                   | macOS 12.6.1       | GitHub Actions |
| Clang 3.5.2                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 3.6.2                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 3.7.1                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 3.8.1                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 3.9.1                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 4.0.1                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 5.0.2                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 6.0.1                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 7.0.1                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 8.0.0                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 9.0.0                                                                                            | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 10.0.0                                                                                           | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 10.0.0 with GNU-like command-line                                                                | Windows-10.0.17763 | GitHub Actions |
| Clang 11.0.0 with GNU-like command-line                                                                | Windows-10.0.17763 | GitHub Actions |
| Clang 11.0.0 with MSVC-like command-line                                                               | Windows-10.0.17763 | GitHub Actions |
| Clang 11.0.0                                                                                           | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 12.0.0                                                                                           | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 12.0.0 with GNU-like command-line                                                                | Windows-10.0.17763 | GitHub Actions |
| Clang 13.0.0                                                                                           | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 13.0.0 with GNU-like command-line                                                                | Windows-10.0.17763 | GitHub Actions |
| Clang 14.0.0                                                                                           | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 14.0.0 with GNU-like command-line                                                                | Windows-10.0.17763 | GitHub Actions |
| Clang 15.0.0 with GNU-like command-line                                                                | Windows-10.0.17763 | GitHub Actions |
| Clang 15.0.4                                                                                           | Ubuntu 20.04.3 LTS | GitHub Actions |
| Clang 16.0.0 (16.0.0-++20221031071727+500876226c60-1~exp1~20221031071831.439)                          | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 4.8.5 (Ubuntu 4.8.5-4ubuntu2)                                                                      | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 4.9.4                                                                                              | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 5.5.0                                                                                              | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 6.5.0                                                                                              | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 7.5.0                                                                                              | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 8.1.0 (i686-posix-dwarf-rev0, Built by MinGW-W64 project)                                          | Windows-10.0.17763 | GitHub Actions |
| GCC 8.1.0 (x86_64-posix-seh-rev0, Built by MinGW-W64 project)                                          | Windows-10.0.17763 | GitHub Actions |
| GCC 8.5.0                                                                                              | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 9.5.0                                                                                              | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 10.4.0                                                                                             | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 11.1.0                                                                                             | Ubuntu (aarch64)   | Drone CI       |
| GCC 11.3.0                                                                                             | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 12.2.0                                                                                             | Ubuntu 20.04.3 LTS | GitHub Actions |
| GCC 13.0.0 20220605 (experimental)                                                                     | Ubuntu 20.04.3 LTS | GitHub Actions |
| Intel C++ Compiler 2021.5.0.20211109                                                                   | Ubuntu 20.04.3 LTS | GitHub Actions |
| NVCC 11.0.221                                                                                          | Ubuntu 20.04.3 LTS | GitHub Actions |
| Visual Studio 14 2015 MSVC 19.0.24241.7 (Build Engine version 14.0.25420.1)                            | Windows-6.3.9600   | AppVeyor       |
| Visual Studio 15 2017 MSVC 19.16.27035.0 (Build Engine version 15.9.21+g9802d43bc3 for .NET Framework) | Windows-10.0.14393 | AppVeyor       |
| Visual Studio 16 2019 MSVC 19.28.29912.0 (Build Engine version 16.9.0+57a23d249 for .NET Framework)    | Windows-10.0.17763 | GitHub Actions |
| Visual Studio 16 2019 MSVC 19.28.29912.0 (Build Engine version 16.9.0+57a23d249 for .NET Framework)    | Windows-10.0.17763 | AppVeyor       |
| Visual Studio 17 2022 MSVC 19.30.30709.0 (Build Engine version 17.0.31804.368 for .NET Framework)      | Windows-10.0.20348 | GitHub Actions |


## Integration

[`json.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json.hpp) is the single required file in `single_include/nlohmann` or [released here](https://github.com/nlohmann/json/releases). You need to add

```cpp
#include <nlohmann/json.hpp>

// for convenience
using json = nlohmann::json;
```

to the files you want to process JSON and set the necessary switches to enable C++11 (e.g., `-std=c++11` for GCC and Clang).

You can further use file [`include/nlohmann/json_fwd.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/json_fwd.hpp) for forward-declarations. The installation of json_fwd.hpp (as part of cmake's install step), can be achieved by setting `-DJSON_MultipleHeaders=ON`.

### CMake

You can also use the `nlohmann_json::nlohmann_json` interface target in CMake.  This target populates the appropriate usage requirements for `INTERFACE_INCLUDE_DIRECTORIES` to point to the appropriate include directories and `INTERFACE_COMPILE_FEATURES` for the necessary C++11 flags.

#### External

To use this library from a CMake project, you can locate it directly with `find_package()` and use the namespaced imported target from the generated package configuration:

```cmake
# CMakeLists.txt
find_package(nlohmann_json 3.2.0 REQUIRED)
...
add_library(foo ...)
...
target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)
```

The package configuration file, `nlohmann_jsonConfig.cmake`, can be used either from an install tree or directly out of the build tree.

#### Embedded

To embed the library directly into an existing CMake project, place the entire source tree in a subdirectory and call `add_subdirectory()` in your `CMakeLists.txt` file:

```cmake
# Typically you don't care so much for a third party library's tests to be
# run from your own project's code.
set(JSON_BuildTests OFF CACHE INTERNAL "")

# If you only include this third party in PRIVATE source files, you do not
# need to install it when your main project gets installed.
# set(JSON_Install OFF CACHE INTERNAL "")

# Don't use include(nlohmann_json/CMakeLists.txt) since that carries with it
# unintended consequences that will break the build.  It's generally
# discouraged (although not necessarily well documented as such) to use
# include(...) for pulling in other CMake projects anyways.
add_subdirectory(nlohmann_json)
...
add_library(foo ...)
...
target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)
```

##### Embedded (FetchContent)

Since CMake v3.11,
[FetchContent](https://cmake.org/cmake/help/v3.11/module/FetchContent.html) can
be used to automatically download a release as a dependency at configure time.

Example:
```cmake
include(FetchContent)

FetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.11.2/json.tar.xz)
FetchContent_MakeAvailable(json)

target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)
```

**Note**: It is recommended to use the URL approach described above which is supported as of version 3.10.0. See
<https://json.nlohmann.me/integration/cmake/#fetchcontent> for more information.

#### Supporting Both

To allow your project to support either an externally supplied or an embedded JSON library, you can use a pattern akin to the following:

``` cmake
# Top level CMakeLists.txt
project(FOO)
...
option(FOO_USE_EXTERNAL_JSON "Use an external JSON library" OFF)
...
add_subdirectory(thirdparty)
...
add_library(foo ...)
...
# Note that the namespaced target will always be available regardless of the
# import method
target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)
```
```cmake
# thirdparty/CMakeLists.txt
...
if(FOO_USE_EXTERNAL_JSON)
  find_package(nlohmann_json 3.2.0 REQUIRED)
else()
  set(JSON_BuildTests OFF CACHE INTERNAL "")
  add_subdirectory(nlohmann_json)
endif()
...
```

`thirdparty/nlohmann_json` is then a complete copy of this source tree.

### Package Managers

:beer: If you are using OS X and [Homebrew](https://brew.sh), just type `brew install nlohmann-json` and you're set. If you want the bleeding edge rather than the latest release, use `brew install nlohmann-json --HEAD`. See [nlohmann-json](https://formulae.brew.sh/formula/nlohmann-json) for more information.

If you are using the [Meson Build System](https://mesonbuild.com), add this source tree as a [meson subproject](https://mesonbuild.com/Subprojects.html#using-a-subproject). You may also use the `include.zip` published in this project's [Releases](https://github.com/nlohmann/json/releases) to reduce the size of the vendored source tree. Alternatively, you can get a wrap file by downloading it from [Meson WrapDB](https://wrapdb.mesonbuild.com/nlohmann_json), or simply use `meson wrap install nlohmann_json`. Please see the meson project for any issues regarding the packaging.

The provided `meson.build` can also be used as an alternative to CMake for installing `nlohmann_json` system-wide in which case a pkg-config file is installed. To use it, simply have your build system require the `nlohmann_json` pkg-config dependency. In Meson, it is preferred to use the [`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a subproject fallback, rather than using the subproject directly.

If you are using [Bazel](https://bazel.build/) you can simply reference this repository using `http_archive` or `git_repository` and depend on `@nlohmann_json//:json`.

If you are using [Conan](https://www.conan.io/) to manage your dependencies, merely add [`nlohmann_json/x.y.z`](https://conan.io/center/nlohmann_json) to your `conanfile`'s requires, where `x.y.z` is the release version you want to use. Please file issues [here](https://github.com/conan-io/conan-center-index/issues) if you experience problems with the packages.

If you are using [Spack](https://www.spack.io/) to manage your dependencies, you can use the [`nlohmann-json` package](https://spack.readthedocs.io/en/latest/package_list.html#nlohmann-json). Please see the [spack project](https://github.com/spack/spack) for any issues regarding the packaging.

If you are using [hunter](https://github.com/cpp-pm/hunter) on your project for external dependencies, then you can use the [nlohmann_json package](https://hunter.readthedocs.io/en/latest/packages/pkg/nlohmann_json.html). Please see the hunter project for any issues regarding the packaging.

If you are using [Buckaroo](https://buckaroo.pm), you can install this library's module with `buckaroo add github.com/buckaroo-pm/nlohmann-json`. Please file issues [here](https://github.com/buckaroo-pm/nlohmann-json). There is a demo repo [here](https://github.com/njlr/buckaroo-nholmann-json-example).

If you are using [vcpkg](https://github.com/Microsoft/vcpkg/) on your project for external dependencies, then you can install the [nlohmann-json package](https://github.com/Microsoft/vcpkg/tree/master/ports/nlohmann-json) with `vcpkg install nlohmann-json` and follow the then displayed descriptions. Please see the vcpkg project for any issues regarding the packaging.

If you are using [cget](https://cget.readthedocs.io/en/latest/), you can install the latest development version with `cget install nlohmann/json`. A specific version can be installed with `cget install nlohmann/json@v3.1.0`. Also, the multiple header version can be installed by adding the `-DJSON_MultipleHeaders=ON` flag (i.e., `cget install nlohmann/json -DJSON_MultipleHeaders=ON`).

If you are using [CocoaPods](https://cocoapods.org), you can use the library by adding pod `"nlohmann_json", '~>3.1.2'` to your podfile (see [an example](https://bitbucket.org/benman/nlohmann_json-cocoapod/src/master/)). Please file issues [here](https://bitbucket.org/benman/nlohmann_json-cocoapod/issues?status=new&status=open).

If you are using [NuGet](https://www.nuget.org), you can use the package [nlohmann.json](https://www.nuget.org/packages/nlohmann.json/). Please check [this extensive description](https://github.com/nlohmann/json/issues/1132#issuecomment-452250255) on how to use the package. Please file issues [here](https://github.com/hnkb/nlohmann-json-nuget/issues).

If you are using [conda](https://conda.io/), you can use the package [nlohmann_json](https://github.com/conda-forge/nlohmann_json-feedstock) from [conda-forge](https://conda-forge.org) executing `conda install -c conda-forge nlohmann_json`. Please file issues [here](https://github.com/conda-forge/nlohmann_json-feedstock/issues).

If you are using [MSYS2](https://www.msys2.org/), you can use the [mingw-w64-nlohmann-json](https://packages.msys2.org/base/mingw-w64-nlohmann-json) package, just type `pacman -S mingw-w64-i686-nlohmann-json` or `pacman -S mingw-w64-x86_64-nlohmann-json` for installation. Please file issues [here](https://github.com/msys2/MINGW-packages/issues/new?title=%5Bnlohmann-json%5D) if you experience problems with the packages.

If you are using [MacPorts](https://ports.macports.org), execute `sudo port install nlohmann-json` to install the [nlohmann-json](https://ports.macports.org/port/nlohmann-json/) package.

If you are using [`build2`](https://build2.org), you can use the [`nlohmann-json`](https://cppget.org/nlohmann-json) package from the public repository https://cppget.org or directly from the [package's sources repository](https://github.com/build2-packaging/nlohmann-json). In your project's `manifest` file, just add `depends: nlohmann-json` (probably with some [version constraints](https://build2.org/build2-toolchain/doc/build2-toolchain-intro.xhtml#guide-add-remove-deps)). If you are not familiar with using dependencies in `build2`, [please read this introduction](https://build2.org/build2-toolchain/doc/build2-toolchain-intro.xhtml).
Please file issues [here](https://github.com/build2-packaging/nlohmann-json) if you experience problems with the packages.

If you are using [`wsjcpp`](https://wsjcpp.org), you can use the command `wsjcpp install "https://github.com/nlohmann/json:develop"` to get the latest version. Note you can change the branch ":develop" to an existing tag or another branch.

If you are using [`CPM.cmake`](https://github.com/TheLartians/CPM.cmake), you can check this [`example`](https://github.com/TheLartians/CPM.cmake/tree/master/examples/json). After [adding CPM script](https://github.com/TheLartians/CPM.cmake#adding-cpm) to your project, implement the following snippet to your CMake:

```cmake
CPMAddPackage(
    NAME nlohmann_json
    GITHUB_REPOSITORY nlohmann/json
    VERSION 3.9.1)
```

### Pkg-config

If you are using bare Makefiles, you can use `pkg-config` to generate the include flags that point to where the library is installed:

```sh
pkg-config nlohmann_json --cflags
```

Users of the Meson build system will also be able to use a system-wide library, which will be found by `pkg-config`:

```meson
json = dependency('nlohmann_json', required: true)
```


## License

<img align="right" src="https://opensource.org/trademarks/opensource/OSI-Approved-License-100x137.png">

The class is licensed under the [MIT License](https://opensource.org/licenses/MIT):

Copyright &copy; 2013-2022 [Niels Lohmann](https://nlohmann.me)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

* * *

The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2008-2009 [Björn Hoehrmann](https://bjoern.hoehrmann.de/) <bjoern@hoehrmann.de>

The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)

The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).

The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).

## Contact

If you have questions regarding the library, I would like to invite you to [open an issue at GitHub](https://github.com/nlohmann/json/issues/new/choose). Please describe your request, problem, or question as detailed as possible, and also mention the version of the library you are using as well as the version of your compiler and operating system. Opening an issue at GitHub allows other users and contributors to this library to collaborate. For instance, I have little experience with MSVC, and most issues in this regard have been solved by a growing community. If you have a look at the [closed issues](https://github.com/nlohmann/json/issues?q=is%3Aissue+is%3Aclosed), you will see that we react quite timely in most cases.

Only if your request would contain confidential information, please [send me an email](mailto:mail@nlohmann.me). For encrypted messages, please use [this key](https://keybase.io/nlohmann/pgp_keys.asc).

## Security

[Commits by Niels Lohmann](https://github.com/nlohmann/json/commits) and [releases](https://github.com/nlohmann/json/releases) are signed with this [PGP Key](https://keybase.io/nlohmann/pgp_keys.asc?fingerprint=797167ae41c0a6d9232e48457f3cea63ae251b69).

## Thanks

I deeply appreciate the help of the following people.

<img src="https://raw.githubusercontent.com/nlohmann/json/develop/docs/avatars.png" align="right">

1. [Teemperor](https://github.com/Teemperor) implemented CMake support and lcov integration, realized escape and Unicode handling in the string parser, and fixed the JSON serialization.
2. [elliotgoodrich](https://github.com/elliotgoodrich) fixed an issue with double deletion in the iterator classes.
3. [kirkshoop](https://github.com/kirkshoop) made the iterators of the class composable to other libraries.
4. [wancw](https://github.com/wanwc) fixed a bug that hindered the class to compile with Clang.
5. Tomas Åblad found a bug in the iterator implementation.
6. [Joshua C. Randall](https://github.com/jrandall) fixed a bug in the floating-point serialization.
7. [Aaron Burghardt](https://github.com/aburgh) implemented code to parse streams incrementally. Furthermore, he greatly improved the parser class by allowing the definition of a filter function to discard undesired elements while parsing.
8. [Daniel Kopeček](https://github.com/dkopecek) fixed a bug in the compilation with GCC 5.0.
9. [Florian Weber](https://github.com/Florianjw) fixed a bug in and improved the performance of the comparison operators.
10. [Eric Cornelius](https://github.com/EricMCornelius) pointed out a bug in the handling with NaN and infinity values. He also improved the performance of the string escaping.
11. [易思龙](https://github.com/likebeta) implemented a conversion from anonymous enums.
12. [kepkin](https://github.com/kepkin) patiently pushed forward the support for Microsoft Visual studio.
13. [gregmarr](https://github.com/gregmarr) simplified the implementation of reverse iterators and helped with numerous hints and improvements. In particular, he pushed forward the implementation of user-defined types.
14. [Caio Luppi](https://github.com/caiovlp) fixed a bug in the Unicode handling.
15. [dariomt](https://github.com/dariomt) fixed some typos in the examples.
16. [Daniel Frey](https://github.com/d-frey) cleaned up some pointers and implemented exception-safe memory allocation.
17. [Colin Hirsch](https://github.com/ColinH) took care of a small namespace issue.
18. [Huu Nguyen](https://github.com/whoshuu) correct a variable name in the documentation.
19. [Silverweed](https://github.com/silverweed) overloaded `parse()` to accept an rvalue reference.
20. [dariomt](https://github.com/dariomt) fixed a subtlety in MSVC type support and implemented the `get_ref()` function to get a reference to stored values.
21. [ZahlGraf](https://github.com/ZahlGraf) added a workaround that allows compilation using Android NDK.
22. [whackashoe](https://github.com/whackashoe) replaced a function that was marked as unsafe by Visual Studio.
23. [406345](https://github.com/406345) fixed two small warnings.
24. [Glen Fernandes](https://github.com/glenfe) noted a potential portability problem in the `has_mapped_type` function.
25. [Corbin Hughes](https://github.com/nibroc) fixed some typos in the contribution guidelines.
26. [twelsby](https://github.com/twelsby) fixed the array subscript operator, an issue that failed the MSVC build, and floating-point parsing/dumping. He further added support for unsigned integer numbers and implemented better roundtrip support for parsed numbers.
27. [Volker Diels-Grabsch](https://github.com/vog) fixed a link in the README file.
28. [msm-](https://github.com/msm-) added support for American Fuzzy Lop.
29. [Annihil](https://github.com/Annihil) fixed an example in the README file.
30. [Themercee](https://github.com/Themercee) noted a wrong URL in the README file.
31. [Lv Zheng](https://github.com/lv-zheng) fixed a namespace issue with `int64_t` and `uint64_t`.
32. [abc100m](https://github.com/abc100m) analyzed the issues with GCC 4.8 and proposed a [partial solution](https://github.com/nlohmann/json/pull/212).
33. [zewt](https://github.com/zewt) added useful notes to the README file about Android.
34. [Róbert Márki](https://github.com/robertmrk) added a fix to use move iterators and improved the integration via CMake.
35. [Chris Kitching](https://github.com/ChrisKitching) cleaned up the CMake files.
36. [Tom Needham](https://github.com/06needhamt) fixed a subtle bug with MSVC 2015 which was also proposed by [Michael K.](https://github.com/Epidal).
37. [Mário Feroldi](https://github.com/thelostt) fixed a small typo.
38. [duncanwerner](https://github.com/duncanwerner) found a really embarrassing performance regression in the 2.0.0 release.
39. [Damien](https://github.com/dtoma) fixed one of the last conversion warnings.
40. [Thomas Braun](https://github.com/t-b) fixed a warning in a test case and adjusted MSVC calls in the CI.
41. [Théo DELRIEU](https://github.com/theodelrieu) patiently and constructively oversaw the long way toward [iterator-range parsing](https://github.com/nlohmann/json/issues/290). He also implemented the magic behind the serialization/deserialization of user-defined types and split the single header file into smaller chunks.
42. [Stefan](https://github.com/5tefan) fixed a minor issue in the documentation.
43. [Vasil Dimov](https://github.com/vasild) fixed the documentation regarding conversions from `std::multiset`.
44. [ChristophJud](https://github.com/ChristophJud) overworked the CMake files to ease project inclusion.
45. [Vladimir Petrigo](https://github.com/vpetrigo) made a SFINAE hack more readable and added Visual Studio 17 to the build matrix.
46. [Denis Andrejew](https://github.com/seeekr) fixed a grammar issue in the README file.
47. [Pierre-Antoine Lacaze](https://github.com/palacaze) found a subtle bug in the `dump()` function.
48. [TurpentineDistillery](https://github.com/TurpentineDistillery) pointed to [`std::locale::classic()`](https://en.cppreference.com/w/cpp/locale/locale/classic) to avoid too much locale joggling, found some nice performance improvements in the parser, improved the benchmarking code, and realized locale-independent number parsing and printing.
49. [cgzones](https://github.com/cgzones) had an idea how to fix the Coverity scan.
50. [Jared Grubb](https://github.com/jaredgrubb) silenced a nasty documentation warning.
51. [Yixin Zhang](https://github.com/qwename) fixed an integer overflow check.
52. [Bosswestfalen](https://github.com/Bosswestfalen) merged two iterator classes into a smaller one.
53. [Daniel599](https://github.com/Daniel599) helped to get Travis execute the tests with Clang's sanitizers.
54. [Jonathan Lee](https://github.com/vjon) fixed an example in the README file.
55. [gnzlbg](https://github.com/gnzlbg) supported the implementation of user-defined types.
56. [Alexej Harm](https://github.com/qis) helped to get the user-defined types working with Visual Studio.
57. [Jared Grubb](https://github.com/jaredgrubb) supported the implementation of user-defined types.
58. [EnricoBilla](https://github.com/EnricoBilla) noted a typo in an example.
59. [Martin Hořeňovský](https://github.com/horenmar) found a way for a 2x speedup for the compilation time of the test suite.
60. [ukhegg](https://github.com/ukhegg) found proposed an improvement for the examples section.
61. [rswanson-ihi](https://github.com/rswanson-ihi) noted a typo in the README.
62. [Mihai Stan](https://github.com/stanmihai4) fixed a bug in the comparison with `nullptr`s.
63. [Tushar Maheshwari](https://github.com/tusharpm) added [cotire](https://github.com/sakra/cotire) support to speed up the compilation.
64. [TedLyngmo](https://github.com/TedLyngmo) noted a typo in the README, removed unnecessary bit arithmetic, and fixed some `-Weffc++` warnings.
65. [Krzysztof Woś](https://github.com/krzysztofwos) made exceptions more visible.
66. [ftillier](https://github.com/ftillier) fixed a compiler warning.
67. [tinloaf](https://github.com/tinloaf) made sure all pushed warnings are properly popped.
68. [Fytch](https://github.com/Fytch) found a bug in the documentation.
69. [Jay Sistar](https://github.com/Type1J) implemented a Meson build description.
70. [Henry Lee](https://github.com/HenryRLee) fixed a warning in ICC and improved the iterator implementation.
71. [Vincent Thiery](https://github.com/vthiery) maintains a package for the Conan package manager.
72. [Steffen](https://github.com/koemeet) fixed a potential issue with MSVC and `std::min`.
73. [Mike Tzou](https://github.com/Chocobo1) fixed some typos.
74. [amrcode](https://github.com/amrcode) noted a misleading documentation about comparison of floats.
75. [Oleg Endo](https://github.com/olegendo) reduced the memory consumption by replacing `<iostream>` with `<iosfwd>`.
76. [dan-42](https://github.com/dan-42) cleaned up the CMake files to simplify including/reusing of the library.
77. [Nikita Ofitserov](https://github.com/himikof) allowed for moving values from initializer lists.
78. [Greg Hurrell](https://github.com/wincent) fixed a typo.
79. [Dmitry Kukovinets](https://github.com/DmitryKuk) fixed a typo.
80. [kbthomp1](https://github.com/kbthomp1) fixed an issue related to the Intel OSX compiler.
81. [Markus Werle](https://github.com/daixtrose) fixed a typo.
82. [WebProdPP](https://github.com/WebProdPP) fixed a subtle error in a precondition check.
83. [Alex](https://github.com/leha-bot) noted an error in a code sample.
84. [Tom de Geus](https://github.com/tdegeus) reported some warnings with ICC and helped to fix them.
85. [Perry Kundert](https://github.com/pjkundert) simplified reading from input streams.
86. [Sonu Lohani](https://github.com/sonulohani) fixed a small compilation error.
87. [Jamie Seward](https://github.com/jseward) fixed all MSVC warnings.
88. [Nate Vargas](https://github.com/eld00d) added a Doxygen tag file.
89. [pvleuven](https://github.com/pvleuven) helped to fix a warning in ICC.
90. [Pavel](https://github.com/crea7or) helped to fix some warnings in MSVC.
91. [Jamie Seward](https://github.com/jseward) avoided unnecessary string copies in `find()` and `count()`.
92. [Mitja](https://github.com/Itja) fixed some typos.
93. [Jorrit Wronski](https://github.com/jowr) updated the Hunter package links.
94. [Matthias Möller](https://github.com/TinyTinni) added a `.natvis` for the MSVC debug view.
95. [bogemic](https://github.com/bogemic) fixed some C++17 deprecation warnings.
96. [Eren Okka](https://github.com/erengy) fixed some MSVC warnings.
97. [abolz](https://github.com/abolz) integrated the Grisu2 algorithm for proper floating-point formatting, allowing more roundtrip checks to succeed.
98. [Vadim Evard](https://github.com/Pipeliner) fixed a Markdown issue in the README.
99. [zerodefect](https://github.com/zerodefect) fixed a compiler warning.
100. [Kert](https://github.com/kaidokert) allowed to template the string type in the serialization and added the possibility to override the exceptional behavior.
101. [mark-99](https://github.com/mark-99) helped fixing an ICC error.
102. [Patrik Huber](https://github.com/patrikhuber) fixed links in the README file.
103. [johnfb](https://github.com/johnfb) found a bug in the implementation of CBOR's indefinite length strings.
104. [Paul Fultz II](https://github.com/pfultz2) added a note on the cget package manager.
105. [Wilson Lin](https://github.com/wla80) made the integration section of the README more concise.
106. [RalfBielig](https://github.com/ralfbielig) detected and fixed a memory leak in the parser callback.
107. [agrianius](https://github.com/agrianius) allowed to dump JSON to an alternative string type.
108. [Kevin Tonon](https://github.com/ktonon) overworked the C++11 compiler checks in CMake.
109. [Axel Huebl](https://github.com/ax3l) simplified a CMake check and added support for the [Spack package manager](https://spack.io).
110. [Carlos O'Ryan](https://github.com/coryan) fixed a typo.
111. [James Upjohn](https://github.com/jammehcow) fixed a version number in the compilers section.
112. [Chuck Atkins](https://github.com/chuckatkins) adjusted the CMake files to the CMake packaging guidelines and provided documentation for the CMake integration.
113. [Jan Schöppach](https://github.com/dns13) fixed a typo.
114. [martin-mfg](https://github.com/martin-mfg) fixed a typo.
115. [Matthias Möller](https://github.com/TinyTinni) removed the dependency from `std::stringstream`.
116. [agrianius](https://github.com/agrianius) added code to use alternative string implementations.
117. [Daniel599](https://github.com/Daniel599) allowed to use more algorithms with the `items()` function.
118. [Julius Rakow](https://github.com/jrakow) fixed the Meson include directory and fixed the links to [cppreference.com](cppreference.com).
119. [Sonu Lohani](https://github.com/sonulohani) fixed the compilation with MSVC 2015 in debug mode.
120. [grembo](https://github.com/grembo) fixed the test suite and re-enabled several test cases.
121. [Hyeon Kim](https://github.com/simnalamburt) introduced the macro `JSON_INTERNAL_CATCH` to control the exception handling inside the library.
122. [thyu](https://github.com/thyu) fixed a compiler warning.
123. [David Guthrie](https://github.com/LEgregius) fixed a subtle compilation error with Clang 3.4.2.
124. [Dennis Fischer](https://github.com/dennisfischer) allowed to call `find_package` without installing the library.
125. [Hyeon Kim](https://github.com/simnalamburt) fixed an issue with a double macro definition.
126. [Ben Berman](https://github.com/rivertam) made some error messages more understandable.
127. [zakalibit](https://github.com/zakalibit) fixed a compilation problem with the Intel C++ compiler.
128. [mandreyel](https://github.com/mandreyel) fixed a compilation problem.
129. [Kostiantyn Ponomarenko](https://github.com/koponomarenko) added version and license information to the Meson build file.
130. [Henry Schreiner](https://github.com/henryiii) added support for GCC 4.8.
131. [knilch](https://github.com/knilch0r) made sure the test suite does not stall when run in the wrong directory.
132. [Antonio Borondo](https://github.com/antonioborondo) fixed an MSVC 2017 warning.
133. [Dan Gendreau](https://github.com/dgendreau) implemented the `NLOHMANN_JSON_SERIALIZE_ENUM` macro to quickly define an enum/JSON mapping.
134. [efp](https://github.com/efp) added line and column information to parse errors.
135. [julian-becker](https://github.com/julian-becker) added BSON support.
136. [Pratik Chowdhury](https://github.com/pratikpc) added support for structured bindings.
137. [David Avedissian](https://github.com/davedissian) added support for Clang 5.0.1 (PS4 version).
138. [Jonathan Dumaresq](https://github.com/dumarjo) implemented an input adapter to read from `FILE*`.
139. [kjpus](https://github.com/kjpus) fixed a link in the documentation.
140. [Manvendra Singh](https://github.com/manu-chroma) fixed a typo in the documentation.
141. [ziggurat29](https://github.com/ziggurat29) fixed an MSVC warning.
142. [Sylvain Corlay](https://github.com/SylvainCorlay) added code to avoid an issue with MSVC.
143. [mefyl](https://github.com/mefyl) fixed a bug when JSON was parsed from an input stream.
144. [Millian Poquet](https://github.com/mpoquet) allowed to install the library via Meson.
145. [Michael Behrns-Miller](https://github.com/moodboom) found an issue with a missing namespace.
146. [Nasztanovics Ferenc](https://github.com/naszta) fixed a compilation issue with libc 2.12.
147. [Andreas Schwab](https://github.com/andreas-schwab) fixed the endian conversion.
148. [Mark-Dunning](https://github.com/Mark-Dunning) fixed a warning in MSVC.
149. [Gareth Sylvester-Bradley](https://github.com/garethsb-sony) added `operator/` for JSON Pointers.
150. [John-Mark](https://github.com/johnmarkwayve) noted a missing header.
151. [Vitaly Zaitsev](https://github.com/xvitaly) fixed compilation with GCC 9.0.
152. [Laurent Stacul](https://github.com/stac47) fixed compilation with GCC 9.0.
153. [Ivor Wanders](https://github.com/iwanders) helped to reduce the CMake requirement to version 3.1.
154. [njlr](https://github.com/njlr) updated the Buckaroo instructions.
155. [Lion](https://github.com/lieff) fixed a compilation issue with GCC 7 on CentOS.
156. [Isaac Nickaein](https://github.com/nickaein) improved the integer serialization performance and  implemented the `contains()` function.
157. [past-due](https://github.com/past-due) suppressed an unfixable warning.
158. [Elvis Oric](https://github.com/elvisoric) improved Meson support.
159. [Matěj Plch](https://github.com/Afforix) fixed an example in the README.
160. [Mark Beckwith](https://github.com/wythe) fixed a typo.
161. [scinart](https://github.com/scinart) fixed bug in the serializer.
162. [Patrick Boettcher](https://github.com/pboettch) implemented `push_back()` and `pop_back()` for JSON Pointers.
163. [Bruno Oliveira](https://github.com/nicoddemus) added support for Conda.
164. [Michele Caini](https://github.com/skypjack) fixed links in the README.
165. [Hani](https://github.com/hnkb) documented how to install the library with NuGet.
166. [Mark Beckwith](https://github.com/wythe) fixed a typo.
167. [yann-morin-1998](https://github.com/yann-morin-1998) helped to reduce the CMake requirement to version 3.1.
168. [Konstantin Podsvirov](https://github.com/podsvirov) maintains a package for the MSYS2 software distro.
169. [remyabel](https://github.com/remyabel) added GNUInstallDirs to the CMake files.
170. [Taylor Howard](https://github.com/taylorhoward92) fixed a unit test.
171. [Gabe Ron](https://github.com/Macr0Nerd) implemented the `to_string` method.
172. [Watal M. Iwasaki](https://github.com/heavywatal) fixed a Clang warning.
173. [Viktor Kirilov](https://github.com/onqtam) switched the unit tests from [Catch](https://github.com/philsquared/Catch) to [doctest](https://github.com/onqtam/doctest)
174. [Juncheng E](https://github.com/ejcjason) fixed a typo.
175. [tete17](https://github.com/tete17) fixed a bug in the `contains` function.
176. [Xav83](https://github.com/Xav83) fixed some cppcheck warnings.
177. [0xflotus](https://github.com/0xflotus) fixed some typos.
178. [Christian Deneke](https://github.com/chris0x44) added a const version of `json_pointer::back`.
179. [Julien Hamaide](https://github.com/crazyjul) made the `items()` function work with custom string types.
180. [Evan Nemerson](https://github.com/nemequ) updated fixed a bug in Hedley and updated this library accordingly.
181. [Florian Pigorsch](https://github.com/flopp) fixed a lot of typos.
182. [Camille Bégué](https://github.com/cbegue) fixed an issue in the conversion from  `std::pair` and `std::tuple` to `json`.
183. [Anthony VH](https://github.com/AnthonyVH) fixed a compile error in an enum deserialization.
184. [Yuriy Vountesmery](https://github.com/ua-code-dragon) noted a subtle bug in a preprocessor check.
185. [Chen](https://github.com/dota17) fixed numerous issues in the library.
186. [Antony Kellermann](https://github.com/aokellermann) added a CI step for GCC 10.1.
187. [Alex](https://github.com/gistrec) fixed an MSVC warning.
188. [Rainer](https://github.com/rvjr) proposed an improvement in the floating-point serialization in CBOR.
189. [Francois Chabot](https://github.com/FrancoisChabot) made performance improvements in the input adapters.
190. [Arthur Sonzogni](https://github.com/ArthurSonzogni) documented how the library can be included via `FetchContent`.
191. [Rimas Misevičius](https://github.com/rmisev) fixed an error message.
192. [Alexander Myasnikov](https://github.com/alexandermyasnikov) fixed some examples and a link in the README.
193. [Hubert Chathi](https://github.com/uhoreg) made CMake's version config file architecture-independent.
194. [OmnipotentEntity](https://github.com/OmnipotentEntity) implemented the binary values for CBOR, MessagePack, BSON, and UBJSON.
195. [ArtemSarmini](https://github.com/ArtemSarmini) fixed a compilation issue with GCC 10 and fixed a leak.
196. [Evgenii Sopov](https://github.com/sea-kg) integrated the library to the wsjcpp package manager.
197. [Sergey Linev](https://github.com/linev) fixed a compiler warning.
198. [Miguel Magalhães](https://github.com/magamig) fixed the year in the copyright.
199. [Gareth Sylvester-Bradley](https://github.com/garethsb-sony) fixed a compilation issue with MSVC.
200. [Alexander “weej” Jones](https://github.com/alex-weej) fixed an example in the README.
201. [Antoine Cœur](https://github.com/Coeur) fixed some typos in the documentation.
202. [jothepro](https://github.com/jothepro) updated links to the Hunter package.
203. [Dave Lee](https://github.com/kastiglione) fixed link in the README.
204. [Joël Lamotte](https://github.com/Klaim) added instruction for using Build2's package manager.
205. [Paul Jurczak](https://github.com/pauljurczak) fixed an example in the README.
206. [Sonu Lohani](https://github.com/sonulohani) fixed a warning.
207. [Carlos Gomes Martinho](https://github.com/gocarlos) updated the Conan package source.
208. [Konstantin Podsvirov](https://github.com/podsvirov) fixed the MSYS2 package documentation.
209. [Tridacnid](https://github.com/Tridacnid) improved the CMake tests.
210. [Michael](https://github.com/MBalszun) fixed MSVC warnings.
211. [Quentin Barbarat](https://github.com/quentin-dev) fixed an example in the documentation.
212. [XyFreak](https://github.com/XyFreak) fixed a compiler warning.
213. [TotalCaesar659](https://github.com/TotalCaesar659) fixed links in the README.
214. [Tanuj Garg](https://github.com/tanuj208) improved the fuzzer coverage for UBSAN input.
215. [AODQ](https://github.com/AODQ) fixed a compiler warning.
216. [jwittbrodt](https://github.com/jwittbrodt) made `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE` inline.
217. [pfeatherstone](https://github.com/pfeatherstone) improved the upper bound of arguments of the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
218. [Jan Procházka](https://github.com/jprochazk) fixed a bug in the CBOR parser for binary and string values.
219. [T0b1-iOS](https://github.com/T0b1-iOS) fixed a bug in the new hash implementation.
220. [Matthew Bauer](https://github.com/matthewbauer) adjusted the CBOR writer to create tags for binary subtypes.
221. [gatopeich](https://github.com/gatopeich) implemented an ordered map container for `nlohmann::ordered_json`.
222. [Érico Nogueira Rolim](https://github.com/ericonr) added support for pkg-config.
223. [KonanM](https://github.com/KonanM) proposed an implementation for the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
224. [Guillaume Racicot](https://github.com/gracicot) implemented `string_view` support and allowed C++20 support.
225. [Alex Reinking](https://github.com/alexreinking) improved CMake support for `FetchContent`.
226. [Hannes Domani](https://github.com/ssbssa) provided a GDB pretty printer.
227. Lars Wirzenius reviewed the README file.
228. [Jun Jie](https://github.com/ongjunjie) fixed a compiler path in the CMake scripts.
229. [Ronak Buch](https://github.com/rbuch) fixed typos in the documentation.
230. [Alexander Karzhenkov](https://github.com/karzhenkov) fixed a move constructor and the Travis builds.
231. [Leonardo Lima](https://github.com/leozz37) added CPM.Cmake support.
232. [Joseph Blackman](https://github.com/jbzdarkid) fixed a warning.
233. [Yaroslav](https://github.com/YarikTH) updated doctest and implemented unit tests.
234. [Martin Stump](https://github.com/globberwops) fixed a bug in the CMake files.
235. [Jaakko Moisio](https://github.com/jasujm) fixed a bug in the input adapters.
236. [bl-ue](https://github.com/bl-ue) fixed some Markdown issues in the README file.
237. [William A. Wieselquist](https://github.com/wawiesel) fixed an example from the README.
238. [abbaswasim](https://github.com/abbaswasim) fixed an example from the README.
239. [Remy Jette](https://github.com/remyjette) fixed a warning.
240. [Fraser](https://github.com/frasermarlow) fixed the documentation.
241. [Ben Beasley](https://github.com/musicinmybrain) updated doctest.
242. [Doron Behar](https://github.com/doronbehar) fixed pkg-config.pc.
243. [raduteo](https://github.com/raduteo) fixed a warning.
244. [David Pfahler](https://github.com/theShmoo) added the possibility to compile the library without I/O support.
245. [Morten Fyhn Amundsen](https://github.com/mortenfyhn) fixed a typo.
246. [jpl-mac](https://github.com/jpl-mac) allowed to treat the library as a system header in CMake.
247. [Jason Dsouza](https://github.com/jasmcaus) fixed the indentation of the CMake file.
248. [offa](https://github.com/offa) added a link to Conan Center to the documentation.
249. [TotalCaesar659](https://github.com/TotalCaesar659) updated the links in the documentation to use HTTPS.
250. [Rafail Giavrimis](https://github.com/grafail) fixed the Google Benchmark default branch.
251. [Louis Dionne](https://github.com/ldionne) fixed a conversion operator.
252. [justanotheranonymoususer](https://github.com/justanotheranonymoususer) made the examples in the README more consistent.
253. [Finkman](https://github.com/Finkman) suppressed some `-Wfloat-equal` warnings.
254. [Ferry Huberts](https://github.com/fhuberts) fixed `-Wswitch-enum` warnings.
255. [Arseniy Terekhin](https://github.com/senyai) made the GDB pretty-printer robust against unset variable names.
256. [Amir Masoud Abdol](https://github.com/amirmasoudabdol) updated the Homebrew command as nlohmann/json is now in homebrew-core.
257. [Hallot](https://github.com/Hallot) fixed some `-Wextra-semi-stmt warnings`.
258. [Giovanni Cerretani](https://github.com/gcerretani) fixed `-Wunused` warnings on `JSON_DIAGNOSTICS`.
259. [Bogdan Popescu](https://github.com/Kapeli) hosts the [docset](https://github.com/Kapeli/Dash-User-Contributions/tree/master/docsets/JSON_for_Modern_C%2B%2B) for offline documentation viewers.
260. [Carl Smedstad](https://github.com/carlsmedstad) fixed an assertion error when using `JSON_DIAGNOSTICS`.
261. [miikka75](https://github.com/miikka75) provided an important fix to compile C++17 code with Clang 9.
262. [Maarten Becker](https://github.com/kernie) fixed a warning for shadowed variables.
263. [Cristi Vîjdea](https://github.com/axnsan12) fixed typos in the `operator[]` documentation.
264. [Alex Beregszaszi](https://github.com/axic) fixed spelling mistakes in comments.
265. [Dirk Stolle](https://github.com/striezel) fixed typos in documentation.
266. [Daniel Albuschat](https://github.com/daniel-kun) corrected the parameter name in the `parse` documentation.
267. [Prince Mendiratta](https://github.com/Prince-Mendiratta) fixed a link to the FAQ.
268. [Florian Albrechtskirchinger](https://github.com/falbrechtskirchinger) implemented `std::string_view` support for object keys and made dozens of other improvements.
269. [Qianqian Fang](https://github.com/fangq) implemented the Binary JData (BJData) format.
270. [pketelsen](https://github.com/pketelsen) added macros `NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT` and `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT`.
271. [DarkZeros](https://github.com/DarkZeros) adjusted to code to not clash with Arduino defines.
272. [flagarde](https://github.com/flagarde) fixed the output of `meta()` for MSVC.
273. [Giovanni Cerretani](https://github.com/gcerretani) fixed a check for `std::filesystem`.
274. [Dimitris Apostolou](https://github.com/rex4539) fixed a typo.
275. [Ferry Huberts](https://github.com/fhuberts) fixed a typo.
276. [Michael Nosthoff](https://github.com/heinemml) fixed a typo.
277. [JungHoon Lee](https://github.com/jhnlee) fixed a typo.
278. [Faruk D.](https://github.com/fdiblen) fixed the CITATION.CFF file.
279. [Andrea Cocito](https://github.com/puffetto) added a clarification on macro usage to the documentation.
280. [Krzysiek Karbowiak](https://github.com/kkarbowiak) refactored the tests to use `CHECK_THROWS_WITH_AS`.
281. [Chaoqi Zhang](https://github.com/prncoprs) fixed a typo.
282. [ivanovmp](https://github.com/ivanovmp) fixed a whitespace error.
283. [KsaNL](https://github.com/KsaNL) fixed a build error when including `<windows.h>`.
284. [Andrea Pappacoda](https://github.com/Tachi107) moved `.pc` and `.cmake` files to `share` directory.
285. [Wolf Vollprecht](https://github.com/wolfv) added the `patch_inplace` function.
286. [Jake Zimmerman](https://github.com/jez) highlighted common usage patterns in the README file.
287. [NN](https://github.com/NN---) added the Visual Studio output directory to `.gitignore`.
288. [Romain Reignier](https://github.com/romainreignier) improved the performance the vector output adapter.
289. [Mike](https://github.com/Mike-Leo-Smith) fixed the `std::iterator_traits`.
290. [Richard Hozák](https://github.com/zxey) added macro `JSON_NO_ENUM` to disable default enum conversions.
291. [vakokako](https://github.com/vakokako) fixed tests when compiling with C++20.
292. [Alexander “weej” Jones](https://github.com/alexweej) fixed an example in the README.
293. [Eli Schwartz](https://github.com/eli-schwartz) added more files to the `include.zip` archive.
294. [Kevin Lu](https://github.com/kevinlul) fixed a compilation issue when typedefs with certain names were present.
295. [Trevor Hickey](https://github.com/luxe) improved the description of an example.
296. [Jef LeCompte](https://github.com/jef) updated the year in the README file.
297. [Alexandre Hamez](https://github.com/ahamez) fixed a warning.
298. [Maninderpal Badhan](https://github.com/mbadhan) fixed a typo.
299. [kevin--](https://github.com/kevin--) added a note to an example in the README file.
300. [I](https://github.com/wx257osn2) fixed a typo.
301. [Gregorio Litenstein](https://github.com/Lord-Kamina) fixed the Clang detection.
302. [Andreas Smas](https://github.com/andoma) added a Doozer badge.
303. [WanCW](https://github.com/wancw) fixed the string conversion with Clang.
304. [zhaohuaxishi](https://github.com/zhaohuaxishi) fixed a Doxygen error.
305. [emvivre](https://github.com/emvivre) removed an invalid parameter from CMake.
306. [Tobias Hermann](https://github.com/Dobiasd) fixed a link in the README file.
307. [Michael](https://github.com/traits) fixed a warning.
308. [Ryan Mulder](https://github.com/ryanjmulder) added `ensure_ascii` to the `dump` function.
309. [Muri Nicanor](https://github.com/murinicanor) fixed the `sed` discovery in the Makefile.
310. [David Avedissian](https://github.com/dgavedissian) implemented SFINAE-friendly `iterator_traits`.
311. [AQNOUCH Mohammed](https://github.com/aqnouch) fixed a typo in the README.
312. [Gareth Sylvester-Bradley](https://github.com/garethsb) added `operator/=` and `operator/` to construct JSON pointers.
313. [Michael Macnair](https://github.com/mykter) added support for afl-fuzz testing.
314. [Berkus Decker](https://github.com/berkus) fixed a typo in the README.
315. [Illia Polishchuk](https://github.com/effolkronium) improved the CMake testing.
316. [Ikko Ashimine](https://github.com/eltociear) fixed a typo.

Thanks a lot for helping out! Please [let me know](mailto:mail@nlohmann.me) if I forgot someone.


## Used third-party tools

The library itself consists of a single header file licensed under the MIT license. However, it is built, tested, documented, and whatnot using a lot of third-party tools and services. Thanks a lot!

- [**amalgamate.py - Amalgamate C source and header files**](https://github.com/edlund/amalgamate) to create a single header file
- [**American fuzzy lop**](https://lcamtuf.coredump.cx/afl/) for fuzz testing
- [**AppVeyor**](https://www.appveyor.com) for [continuous integration](https://ci.appveyor.com/project/nlohmann/json) on Windows
- [**Artistic Style**](http://astyle.sourceforge.net) for automatic source code indentation
- [**Clang**](https://clang.llvm.org) for compilation with code sanitizers
- [**CMake**](https://cmake.org) for build automation
- [**Codacy**](https://www.codacy.com) for further [code analysis](https://www.codacy.com/app/nlohmann/json)
- [**Coveralls**](https://coveralls.io) to measure [code coverage](https://coveralls.io/github/nlohmann/json)
- [**Coverity Scan**](https://scan.coverity.com) for [static analysis](https://scan.coverity.com/projects/nlohmann-json)
- [**cppcheck**](http://cppcheck.sourceforge.net) for static analysis
- [**doctest**](https://github.com/onqtam/doctest) for the unit tests
- [**git-update-ghpages**](https://github.com/rstacruz/git-update-ghpages) to upload the documentation to gh-pages
- [**GitHub Changelog Generator**](https://github.com/skywinder/github-changelog-generator) to generate the [ChangeLog](https://github.com/nlohmann/json/blob/develop/ChangeLog.md)
- [**Google Benchmark**](https://github.com/google/benchmark) to implement the benchmarks
- [**Hedley**](https://nemequ.github.io/hedley/) to avoid re-inventing several compiler-agnostic feature macros
- [**lcov**](http://ltp.sourceforge.net/coverage/lcov.php) to process coverage information and create an HTML view
- [**libFuzzer**](https://llvm.org/docs/LibFuzzer.html) to implement fuzz testing for OSS-Fuzz
- [**Material for MkDocs**](https://squidfunk.github.io/mkdocs-material/) for the style of the documentation site
- [**MkDocs**](https://www.mkdocs.org) for the documentation site
- [**OSS-Fuzz**](https://github.com/google/oss-fuzz) for continuous fuzz testing of the library ([project repository](https://github.com/google/oss-fuzz/tree/master/projects/json))
- [**Probot**](https://probot.github.io) for automating maintainer tasks such as closing stale issues, requesting missing information, or detecting toxic comments.
- [**Valgrind**](https://valgrind.org) to check for correct memory management


## Projects using JSON for Modern C++

The library is currently used in Apple macOS Sierra-Monterey and iOS 10-15. I am not sure what they are using the library for, but I am happy that it runs on so many devices.


## Notes

### Character encoding

The library supports **Unicode input** as follows:

- Only **UTF-8** encoded input is supported which is the default encoding for JSON according to [RFC 8259](https://tools.ietf.org/html/rfc8259.html#section-8.1).
- `std::u16string` and `std::u32string` can be parsed, assuming UTF-16 and UTF-32 encoding, respectively. These encodings are not supported when reading from files or other input containers.
- Other encodings such as Latin-1 or ISO 8859-1 are **not** supported and will yield parse or serialization errors.
- [Unicode noncharacters](https://www.unicode.org/faq/private_use.html#nonchar1) will not be replaced by the library.
- Invalid surrogates (e.g., incomplete pairs such as `\uDEAD`) will yield parse errors.
- The strings stored in the library are UTF-8 encoded. When using the default string type (`std::string`), note that its length/size functions return the number of stored bytes rather than the number of characters or glyphs.
- When you store strings with different encodings in the library, calling [`dump()`](https://json.nlohmann.me/api/basic_json/dump/) may throw an exception unless `json::error_handler_t::replace` or `json::error_handler_t::ignore` are used as error handlers.
- To store wide strings (e.g., `std::wstring`), you need to convert them to a UTF-8 encoded `std::string` before, see [an example](https://json.nlohmann.me/home/faq/#wide-string-handling).

### Comments in JSON

This library does not support comments by default. It does so for three reasons:

1. Comments are not part of the [JSON specification](https://tools.ietf.org/html/rfc8259). You may argue that `//` or `/* */` are allowed in JavaScript, but JSON is not JavaScript.
2. This was not an oversight: Douglas Crockford [wrote on this](https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr) in May 2012:

	> I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability.  I know that the lack of comments makes some people sad, but it shouldn't.

	> Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.

3. It is dangerous for interoperability if some libraries would add comment support while others don't. Please check [The Harmful Consequences of the Robustness Principle](https://tools.ietf.org/html/draft-iab-protocol-maintenance-01) on this.

However, you can pass set parameter `ignore_comments` to true in the `parse` function to ignore `//` or `/* */` comments. Comments will then be treated as whitespace.

### Order of object keys

By default, the library does not preserve the **insertion order of object elements**. This is standards-compliant, as the [JSON standard](https://tools.ietf.org/html/rfc8259.html) defines objects as "an unordered collection of zero or more name/value pairs".

If you do want to preserve the insertion order, you can try the type [`nlohmann::ordered_json`](https://github.com/nlohmann/json/issues/2179). Alternatively, you can use a more sophisticated ordered map like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).

### Memory Release

We checked with Valgrind and the Address Sanitizer (ASAN) that there are no memory leaks.

If you find that a parsing program with this library does not release memory, please consider the following case, and it may be unrelated to this library.

**Your program is compiled with glibc.** There is a tunable threshold that glibc uses to decide whether to actually return memory to the system or whether to cache it for later reuse. If in your program you make lots of small allocations and those small allocations are not a contiguous block and are presumably below the threshold, then they will not get returned to the OS.
Here is a related issue [#1924](https://github.com/nlohmann/json/issues/1924).

### Further notes

- The code contains numerous debug **assertions** which can be switched off by defining the preprocessor macro `NDEBUG`, see the [documentation of `assert`](https://en.cppreference.com/w/cpp/error/assert). In particular, note [`operator[]`](https://json.nlohmann.me/api/basic_json/operator%5B%5D/) implements **unchecked access** for const objects: If the given key is not present, the behavior is undefined (think of a dereferenced null pointer) and yields an [assertion failure](https://github.com/nlohmann/json/issues/289) if assertions are switched on. If you are not sure whether an element in an object exists, use checked access with the [`at()` function](https://json.nlohmann.me/api/basic_json/at/). Furthermore, you can define `JSON_ASSERT(x)` to replace calls to `assert(x)`.
- As the exact number type is not defined in the [JSON specification](https://tools.ietf.org/html/rfc8259.html), this library tries to choose the best fitting C++ number type automatically. As a result, the type `double` may be used to store numbers which may yield [**floating-point exceptions**](https://github.com/nlohmann/json/issues/181) in certain rare situations if floating-point exceptions have been unmasked in the calling code. These exceptions are not caused by the library and need to be fixed in the calling code, such as by re-masking the exceptions prior to calling library functions.
- The code can be compiled without C++ **runtime type identification** features; that is, you can use the `-fno-rtti` compiler flag.
- **Exceptions** are used widely within the library. They can, however, be switched off with either using the compiler flag `-fno-exceptions` or by defining the symbol `JSON_NOEXCEPTION`. In this case, exceptions are replaced by `abort()` calls. You can further control this behavior by defining `JSON_THROW_USER` (overriding `throw`), `JSON_TRY_USER` (overriding `try`), and `JSON_CATCH_USER` (overriding `catch`). Note that `JSON_THROW_USER` should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior. Note the explanatory [`what()`](https://en.cppreference.com/w/cpp/error/exception/what) string of exceptions is not available for MSVC if exceptions are disabled, see [#2824](https://github.com/nlohmann/json/discussions/2824).

## Execute unit tests

To compile and run the tests, you need to execute

```sh
$ mkdir build
$ cd build
$ cmake .. -DJSON_BuildTests=On
$ cmake --build .
$ ctest --output-on-failure
```

Note that during the `ctest` stage, several JSON test files are downloaded from an [external repository](https://github.com/nlohmann/json_test_data). If policies forbid downloading artifacts during testing, you can download the files yourself and pass the directory with the test files via `-DJSON_TestDataDirectory=path` to CMake. Then, no Internet connectivity is required. See [issue #2189](https://github.com/nlohmann/json/issues/2189) for more information.

If the test suite is not found, several test suites will fail like this:

```
===============================================================================
json/tests/src/make_test_data_available.hpp:21:
TEST CASE:  check test suite is downloaded

json/tests/src/make_test_data_available.hpp:23: FATAL ERROR: REQUIRE( utils::check_testsuite_downloaded() ) is NOT correct!
  values: REQUIRE( false )
  logged: Test data not found in 'json/cmake-build-debug/json_test_data'.
          Please execute target 'download_test_data' before running this test suite.
          See <https://github.com/nlohmann/json#execute-unit-tests> for more information.

===============================================================================
```

In case you have downloaded the library rather than checked out the code via Git, test `cmake_fetch_content_configure` will fail. Please execute `ctest -LE git_required` to skip these tests. See [issue #2189](https://github.com/nlohmann/json/issues/2189) for more information.

Some tests change the installed files and hence make the whole process not reproducible. Please execute `ctest -LE not_reproducible` to skip these tests. See [issue #2324](https://github.com/nlohmann/json/issues/2324) for more information.

Note you need to call `cmake -LE "not_reproducible|git_required"` to exclude both labels. See [issue #2596](https://github.com/nlohmann/json/issues/2596) for more information.

As Intel compilers use unsafe floating point optimization by default, the unit tests may fail. Use flag [`/fp:precise`](https://software.intel.com/content/www/us/en/develop/documentation/cpp-compiler-developer-guide-and-reference/top/compiler-reference/compiler-options/compiler-option-details/floating-point-options/fp-model-fp.html) then.


================================================
FILE: lib/json/json.hpp
================================================
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT

/****************************************************************************\
 * Note on documentation: The source files contain links to the online      *
 * documentation of the public API at https://json.nlohmann.me. This URL    *
 * contains the most recent documentation and should also be applicable to  *
 * previous versions; documentation for deprecated functions is not         *
 * removed, but marked deprecated. See "Generate documentation" section in  *
 * file docs/README.md.                                                     *
\****************************************************************************/

#ifndef INCLUDE_NLOHMANN_JSON_HPP_
#define INCLUDE_NLOHMANN_JSON_HPP_

#include <algorithm> // all_of, find, for_each
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
#include <functional> // hash, less
#include <initializer_list> // initializer_list
#ifndef JSON_NO_IO
    #include <iosfwd> // istream, ostream
#endif  // JSON_NO_IO
#include <iterator> // random_access_iterator_tag
#include <memory> // unique_ptr
#include <string> // string, stoi, to_string
#include <utility> // declval, forward, move, pair, swap
#include <vector> // vector

// #include <nlohmann/adl_serializer.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <utility>

// #include <nlohmann/detail/abi_macros.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// This file contains all macro definitions affecting or depending on the ABI

#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
            #warning "Already included a different version of the library!"
        #endif
    #endif
#endif

#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)

#ifndef JSON_DIAGNOSTICS
    #define JSON_DIAGNOSTICS 0
#endif

#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
#endif

#if JSON_DIAGNOSTICS
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
#else
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
#endif

#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
#else
    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
#endif

#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
#endif

// Construct the namespace ABI tags component
#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)

#define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)

// Construct the namespace version component
#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
    _v ## major ## _ ## minor ## _ ## patch
#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)

#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
#define NLOHMANN_JSON_NAMESPACE_VERSION
#else
#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
                                           NLOHMANN_JSON_VERSION_MINOR, \
                                           NLOHMANN_JSON_VERSION_PATCH)
#endif

// Combine namespace components
#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)

#ifndef NLOHMANN_JSON_NAMESPACE
#define NLOHMANN_JSON_NAMESPACE               \
    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
            NLOHMANN_JSON_ABI_TAGS,           \
            NLOHMANN_JSON_NAMESPACE_VERSION)
#endif

#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
    namespace nlohmann                               \
    {                                                \
    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
                NLOHMANN_JSON_ABI_TAGS,              \
                NLOHMANN_JSON_NAMESPACE_VERSION)     \
    {
#endif

#ifndef NLOHMANN_JSON_NAMESPACE_END
#define NLOHMANN_JSON_NAMESPACE_END                                     \
    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
    }  // namespace nlohmann
#endif

// #include <nlohmann/detail/conversions/from_json.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <algorithm> // transform
#include <array> // array
#include <forward_list> // forward_list
#include <iterator> // inserter, front_inserter, end
#include <map> // map
#include <string> // string
#include <tuple> // tuple, make_tuple
#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
#include <unordered_map> // unordered_map
#include <utility> // pair, declval
#include <valarray> // valarray

// #include <nlohmann/detail/exceptions.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstddef> // nullptr_t
#include <exception> // exception
#if JSON_DIAGNOSTICS
    #include <numeric> // accumulate
#endif
#include <stdexcept> // runtime_error
#include <string> // to_string
#include <vector> // vector

// #include <nlohmann/detail/value_t.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <array> // array
#include <cstddef> // size_t
#include <cstdint> // uint8_t
#include <string> // string

// #include <nlohmann/detail/macro_scope.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <utility> // declval, pair
// #include <nlohmann/detail/meta/detected.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <type_traits>

// #include <nlohmann/detail/meta/void_t.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// #include <nlohmann/detail/abi_macros.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

template<typename ...Ts> struct make_void
{
    using type = void;
};
template<typename ...Ts> using void_t = typename make_void<Ts...>::type;

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

// https://en.cppreference.com/w/cpp/experimental/is_detected
struct nonesuch
{
    nonesuch() = delete;
    ~nonesuch() = delete;
    nonesuch(nonesuch const&) = delete;
    nonesuch(nonesuch const&&) = delete;
    void operator=(nonesuch const&) = delete;
    void operator=(nonesuch&&) = delete;
};

template<class Default,
         class AlwaysVoid,
         template<class...> class Op,
         class... Args>
struct detector
{
    using value_t = std::false_type;
    using type = Default;
};

template<class Default, template<class...> class Op, class... Args>
struct detector<Default, void_t<Op<Args...>>, Op, Args...>
{
    using value_t = std::true_type;
    using type = Op<Args...>;
};

template<template<class...> class Op, class... Args>
using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;

template<template<class...> class Op, class... Args>
struct is_detected_lazy : is_detected<Op, Args...> { };

template<template<class...> class Op, class... Args>
using detected_t = typename detector<nonesuch, void, Op, Args...>::type;

template<class Default, template<class...> class Op, class... Args>
using detected_or = detector<Default, void, Op, Args...>;

template<class Default, template<class...> class Op, class... Args>
using detected_or_t = typename detected_or<Default, Op, Args...>::type;

template<class Expected, template<class...> class Op, class... Args>
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;

template<class To, template<class...> class Op, class... Args>
using is_detected_convertible =
    std::is_convertible<detected_t<Op, Args...>, To>;

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/thirdparty/hedley/hedley.hpp>


//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
// SPDX-License-Identifier: MIT

/* Hedley - https://nemequ.github.io/hedley
 * Created by Evan Nemerson <evan@nemerson.com>
 */

#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
#if defined(JSON_HEDLEY_VERSION)
    #undef JSON_HEDLEY_VERSION
#endif
#define JSON_HEDLEY_VERSION 15

#if defined(JSON_HEDLEY_STRINGIFY_EX)
    #undef JSON_HEDLEY_STRINGIFY_EX
#endif
#define JSON_HEDLEY_STRINGIFY_EX(x) #x

#if defined(JSON_HEDLEY_STRINGIFY)
    #undef JSON_HEDLEY_STRINGIFY
#endif
#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)

#if defined(JSON_HEDLEY_CONCAT_EX)
    #undef JSON_HEDLEY_CONCAT_EX
#endif
#define JSON_HEDLEY_CONCAT_EX(a,b) a##b

#if defined(JSON_HEDLEY_CONCAT)
    #undef JSON_HEDLEY_CONCAT
#endif
#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)

#if defined(JSON_HEDLEY_CONCAT3_EX)
    #undef JSON_HEDLEY_CONCAT3_EX
#endif
#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c

#if defined(JSON_HEDLEY_CONCAT3)
    #undef JSON_HEDLEY_CONCAT3
#endif
#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)

#if defined(JSON_HEDLEY_VERSION_ENCODE)
    #undef JSON_HEDLEY_VERSION_ENCODE
#endif
#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))

#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
#endif
#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)

#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
#endif
#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)

#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
#endif
#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)

#if defined(JSON_HEDLEY_GNUC_VERSION)
    #undef JSON_HEDLEY_GNUC_VERSION
#endif
#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#elif defined(__GNUC__)
    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
#endif

#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_GNUC_VERSION)
    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_MSVC_VERSION)
    #undef JSON_HEDLEY_MSVC_VERSION
#endif
#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
#elif defined(_MSC_FULL_VER) && !defined(__ICL)
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
#elif defined(_MSC_VER) && !defined(__ICL)
    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
#endif

#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
#endif
#if !defined(JSON_HEDLEY_MSVC_VERSION)
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
#else
    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
#endif

#if defined(JSON_HEDLEY_INTEL_VERSION)
    #undef JSON_HEDLEY_INTEL_VERSION
#endif
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
#elif defined(__INTEL_COMPILER) && !defined(__ICL)
    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
#endif

#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_INTEL_VERSION)
    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
    #undef JSON_HEDLEY_INTEL_CL_VERSION
#endif
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
#endif

#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_PGI_VERSION)
    #undef JSON_HEDLEY_PGI_VERSION
#endif
#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
#endif

#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
    #undef JSON_HEDLEY_PGI_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_PGI_VERSION)
    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_SUNPRO_VERSION)
    #undef JSON_HEDLEY_SUNPRO_VERSION
#endif
#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
#elif defined(__SUNPRO_C)
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
#elif defined(__SUNPRO_CC)
    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
#endif

#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_SUNPRO_VERSION)
    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
#endif
#if defined(__EMSCRIPTEN__)
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
#endif

#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_ARM_VERSION)
    #undef JSON_HEDLEY_ARM_VERSION
#endif
#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
#endif

#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
    #undef JSON_HEDLEY_ARM_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_ARM_VERSION)
    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_IBM_VERSION)
    #undef JSON_HEDLEY_IBM_VERSION
#endif
#if defined(__ibmxl__)
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
#elif defined(__xlC__) && defined(__xlC_ver__)
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
#elif defined(__xlC__)
    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
#endif

#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
    #undef JSON_HEDLEY_IBM_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_IBM_VERSION)
    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TI_VERSION)
    #undef JSON_HEDLEY_TI_VERSION
#endif
#if \
    defined(__TI_COMPILER_VERSION__) && \
    ( \
      defined(__TMS470__) || defined(__TI_ARM__) || \
      defined(__MSP430__) || \
      defined(__TMS320C2000__) \
    )
#if (__TI_COMPILER_VERSION__ >= 16000000)
    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
#endif
#endif

#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
    #undef JSON_HEDLEY_TI_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TI_VERSION)
    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
    #undef JSON_HEDLEY_TI_CL2000_VERSION
#endif
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
#endif

#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TI_CL430_VERSION)
    #undef JSON_HEDLEY_TI_CL430_VERSION
#endif
#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
#endif

#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TI_CL430_VERSION)
    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
    #undef JSON_HEDLEY_TI_ARMCL_VERSION
#endif
#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
#endif

#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
    #undef JSON_HEDLEY_TI_CL6X_VERSION
#endif
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
#endif

#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
    #undef JSON_HEDLEY_TI_CL7X_VERSION
#endif
#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
#endif

#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
    #undef JSON_HEDLEY_TI_CLPRU_VERSION
#endif
#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
#endif

#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_CRAY_VERSION)
    #undef JSON_HEDLEY_CRAY_VERSION
#endif
#if defined(_CRAYC)
    #if defined(_RELEASE_PATCHLEVEL)
        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
    #else
        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
    #endif
#endif

#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_CRAY_VERSION)
    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_IAR_VERSION)
    #undef JSON_HEDLEY_IAR_VERSION
#endif
#if defined(__IAR_SYSTEMS_ICC__)
    #if __VER__ > 1000
        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
    #else
        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
    #endif
#endif

#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
    #undef JSON_HEDLEY_IAR_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_IAR_VERSION)
    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_TINYC_VERSION)
    #undef JSON_HEDLEY_TINYC_VERSION
#endif
#if defined(__TINYC__)
    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
#endif

#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_TINYC_VERSION)
    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_DMC_VERSION)
    #undef JSON_HEDLEY_DMC_VERSION
#endif
#if defined(__DMC__)
    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
#endif

#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
    #undef JSON_HEDLEY_DMC_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_DMC_VERSION)
    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_COMPCERT_VERSION)
    #undef JSON_HEDLEY_COMPCERT_VERSION
#endif
#if defined(__COMPCERT_VERSION__)
    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
#endif

#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_COMPCERT_VERSION)
    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_PELLES_VERSION)
    #undef JSON_HEDLEY_PELLES_VERSION
#endif
#if defined(__POCC__)
    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
#endif

#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_PELLES_VERSION)
    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
    #undef JSON_HEDLEY_MCST_LCC_VERSION
#endif
#if defined(__LCC__) && defined(__LCC_MINOR__)
    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
#endif

#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_GCC_VERSION)
    #undef JSON_HEDLEY_GCC_VERSION
#endif
#if \
    defined(JSON_HEDLEY_GNUC_VERSION) && \
    !defined(__clang__) && \
    !defined(JSON_HEDLEY_INTEL_VERSION) && \
    !defined(JSON_HEDLEY_PGI_VERSION) && \
    !defined(JSON_HEDLEY_ARM_VERSION) && \
    !defined(JSON_HEDLEY_CRAY_VERSION) && \
    !defined(JSON_HEDLEY_TI_VERSION) && \
    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
    !defined(__COMPCERT__) && \
    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
#endif

#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
    #undef JSON_HEDLEY_GCC_VERSION_CHECK
#endif
#if defined(JSON_HEDLEY_GCC_VERSION)
    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
#else
    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
#endif

#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
    #undef JSON_HEDLEY_HAS_ATTRIBUTE
#endif
#if \
  defined(__has_attribute) && \
  ( \
    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
  )
#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
#else
#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
#endif

#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
#endif
#if defined(__has_attribute)
    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
#else
    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
#endif
#if defined(__has_attribute)
    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
#else
    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
#endif
#if \
    defined(__has_cpp_attribute) && \
    defined(__cplusplus) && \
    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
#else
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
#endif

#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
#endif
#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
#elif \
    !defined(JSON_HEDLEY_PGI_VERSION) && \
    !defined(JSON_HEDLEY_IAR_VERSION) && \
    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
#else
    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
#endif

#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
#endif
#if defined(__has_cpp_attribute) && defined(__cplusplus)
    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
#else
    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
#endif
#if defined(__has_cpp_attribute) && defined(__cplusplus)
    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
#else
    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_HAS_BUILTIN)
    #undef JSON_HEDLEY_HAS_BUILTIN
#endif
#if defined(__has_builtin)
    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
#else
    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
#endif

#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
#endif
#if defined(__has_builtin)
    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
#else
    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
#endif
#if defined(__has_builtin)
    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
#else
    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_HAS_FEATURE)
    #undef JSON_HEDLEY_HAS_FEATURE
#endif
#if defined(__has_feature)
    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
#else
    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
#endif

#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
#endif
#if defined(__has_feature)
    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
#else
    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
    #undef JSON_HEDLEY_GCC_HAS_FEATURE
#endif
#if defined(__has_feature)
    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
#else
    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_HAS_EXTENSION)
    #undef JSON_HEDLEY_HAS_EXTENSION
#endif
#if defined(__has_extension)
    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
#else
    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
#endif

#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
#endif
#if defined(__has_extension)
    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
#else
    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
#endif
#if defined(__has_extension)
    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
#else
    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
#endif
#if defined(__has_declspec_attribute)
    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
#else
    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
#endif

#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
#endif
#if defined(__has_declspec_attribute)
    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
#else
    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
#endif
#if defined(__has_declspec_attribute)
    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
#else
    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_HAS_WARNING)
    #undef JSON_HEDLEY_HAS_WARNING
#endif
#if defined(__has_warning)
    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
#else
    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
#endif

#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
    #undef JSON_HEDLEY_GNUC_HAS_WARNING
#endif
#if defined(__has_warning)
    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
#else
    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
    #undef JSON_HEDLEY_GCC_HAS_WARNING
#endif
#if defined(__has_warning)
    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
#else
    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if \
    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
    defined(__clang__) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
#else
    #define JSON_HEDLEY_PRAGMA(value)
#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
#endif
#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
    #undef JSON_HEDLEY_DIAGNOSTIC_POP
#endif
#if defined(__clang__)
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
#elif \
    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
#elif \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
#else
    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
    #define JSON_HEDLEY_DIAGNOSTIC_POP
#endif

/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
#endif
#if defined(__cplusplus)
#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
    xpr \
    JSON_HEDLEY_DIAGNOSTIC_POP
#      else
#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
    xpr \
    JSON_HEDLEY_DIAGNOSTIC_POP
#      endif
#    else
#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
    xpr \
    JSON_HEDLEY_DIAGNOSTIC_POP
#    endif
#  endif
#endif
#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
#endif

#if defined(JSON_HEDLEY_CONST_CAST)
    #undef JSON_HEDLEY_CONST_CAST
#endif
#if defined(__cplusplus)
#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
#elif \
  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
        JSON_HEDLEY_DIAGNOSTIC_PUSH \
        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
        ((T) (expr)); \
        JSON_HEDLEY_DIAGNOSTIC_POP \
    }))
#else
#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
#endif

#if defined(JSON_HEDLEY_REINTERPRET_CAST)
    #undef JSON_HEDLEY_REINTERPRET_CAST
#endif
#if defined(__cplusplus)
    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
#else
    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
#endif

#if defined(JSON_HEDLEY_STATIC_CAST)
    #undef JSON_HEDLEY_STATIC_CAST
#endif
#if defined(__cplusplus)
    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
#else
    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
#endif

#if defined(JSON_HEDLEY_CPP_CAST)
    #undef JSON_HEDLEY_CPP_CAST
#endif
#if defined(__cplusplus)
#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
#    define JSON_HEDLEY_CPP_CAST(T, expr) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
    ((T) (expr)) \
    JSON_HEDLEY_DIAGNOSTIC_POP
#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
#    define JSON_HEDLEY_CPP_CAST(T, expr) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    _Pragma("diag_suppress=Pe137") \
    JSON_HEDLEY_DIAGNOSTIC_POP
#  else
#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
#  endif
#else
#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
#elif \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
#else
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
#elif \
    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
#else
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
#elif \
    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
#else
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
#else
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
#else
    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
#endif

#if defined(JSON_HEDLEY_DEPRECATED)
    #undef JSON_HEDLEY_DEPRECATED
#endif
#if defined(JSON_HEDLEY_DEPRECATED_FOR)
    #undef JSON_HEDLEY_DEPRECATED_FOR
#endif
#if \
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
#elif \
    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
#elif defined(__cplusplus) && (__cplusplus >= 201402L)
    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
#elif \
    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
#elif \
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
#else
    #define JSON_HEDLEY_DEPRECATED(since)
    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
#endif

#if defined(JSON_HEDLEY_UNAVAILABLE)
    #undef JSON_HEDLEY_UNAVAILABLE
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
#else
    #define JSON_HEDLEY_UNAVAILABLE(available_since)
#endif

#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
#endif
#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
#elif defined(_Check_return_) /* SAL */
    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
#else
    #define JSON_HEDLEY_WARN_UNUSED_RESULT
    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
#endif

#if defined(JSON_HEDLEY_SENTINEL)
    #undef JSON_HEDLEY_SENTINEL
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
#else
    #define JSON_HEDLEY_SENTINEL(position)
#endif

#if defined(JSON_HEDLEY_NO_RETURN)
    #undef JSON_HEDLEY_NO_RETURN
#endif
#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
    #define JSON_HEDLEY_NO_RETURN __noreturn
#elif \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
    #define JSON_HEDLEY_NO_RETURN _Noreturn
#elif defined(__cplusplus) && (__cplusplus >= 201103L)
    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
#elif \
    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
#elif \
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
#else
    #define JSON_HEDLEY_NO_RETURN
#endif

#if defined(JSON_HEDLEY_NO_ESCAPE)
    #undef JSON_HEDLEY_NO_ESCAPE
#endif
#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
#else
    #define JSON_HEDLEY_NO_ESCAPE
#endif

#if defined(JSON_HEDLEY_UNREACHABLE)
    #undef JSON_HEDLEY_UNREACHABLE
#endif
#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
    #undef JSON_HEDLEY_UNREACHABLE_RETURN
#endif
#if defined(JSON_HEDLEY_ASSUME)
    #undef JSON_HEDLEY_ASSUME
#endif
#if \
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
#elif \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
    #if defined(__cplusplus)
        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
    #else
        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
    #endif
#endif
#if \
    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
#elif defined(JSON_HEDLEY_ASSUME)
    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
#endif
#if !defined(JSON_HEDLEY_ASSUME)
    #if defined(JSON_HEDLEY_UNREACHABLE)
        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
    #else
        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
    #endif
#endif
#if defined(JSON_HEDLEY_UNREACHABLE)
    #if  \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
    #else
        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
    #endif
#else
    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
#endif
#if !defined(JSON_HEDLEY_UNREACHABLE)
    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
#endif

JSON_HEDLEY_DIAGNOSTIC_PUSH
#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
    #pragma clang diagnostic ignored "-Wpedantic"
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif
#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
    #if defined(__clang__)
        #pragma clang diagnostic ignored "-Wvariadic-macros"
    #elif defined(JSON_HEDLEY_GCC_VERSION)
        #pragma GCC diagnostic ignored "-Wvariadic-macros"
    #endif
#endif
#if defined(JSON_HEDLEY_NON_NULL)
    #undef JSON_HEDLEY_NON_NULL
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
#else
    #define JSON_HEDLEY_NON_NULL(...)
#endif
JSON_HEDLEY_DIAGNOSTIC_POP

#if defined(JSON_HEDLEY_PRINTF_FORMAT)
    #undef JSON_HEDLEY_PRINTF_FORMAT
#endif
#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
#elif \
    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
#else
    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
#endif

#if defined(JSON_HEDLEY_CONSTEXPR)
    #undef JSON_HEDLEY_CONSTEXPR
#endif
#if defined(__cplusplus)
    #if __cplusplus >= 201103L
        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
    #endif
#endif
#if !defined(JSON_HEDLEY_CONSTEXPR)
    #define JSON_HEDLEY_CONSTEXPR
#endif

#if defined(JSON_HEDLEY_PREDICT)
    #undef JSON_HEDLEY_PREDICT
#endif
#if defined(JSON_HEDLEY_LIKELY)
    #undef JSON_HEDLEY_LIKELY
#endif
#if defined(JSON_HEDLEY_UNLIKELY)
    #undef JSON_HEDLEY_UNLIKELY
#endif
#if defined(JSON_HEDLEY_UNPREDICTABLE)
    #undef JSON_HEDLEY_UNPREDICTABLE
#endif
#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
#endif
#if \
  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
#elif \
  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
    (__extension__ ({ \
        double hedley_probability_ = (probability); \
        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
    }))
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
    (__extension__ ({ \
        double hedley_probability_ = (probability); \
        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
    }))
#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
#else
#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
#endif
#if !defined(JSON_HEDLEY_UNPREDICTABLE)
    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
#endif

#if defined(JSON_HEDLEY_MALLOC)
    #undef JSON_HEDLEY_MALLOC
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
#elif \
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_MALLOC __declspec(restrict)
#else
    #define JSON_HEDLEY_MALLOC
#endif

#if defined(JSON_HEDLEY_PURE)
    #undef JSON_HEDLEY_PURE
#endif
#if \
  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
#  define JSON_HEDLEY_PURE __attribute__((__pure__))
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
#elif defined(__cplusplus) && \
    ( \
      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
    )
#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
#else
#  define JSON_HEDLEY_PURE
#endif

#if defined(JSON_HEDLEY_CONST)
    #undef JSON_HEDLEY_CONST
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_CONST __attribute__((__const__))
#elif \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
#else
    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
#endif

#if defined(JSON_HEDLEY_RESTRICT)
    #undef JSON_HEDLEY_RESTRICT
#endif
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
    #define JSON_HEDLEY_RESTRICT restrict
#elif \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
    defined(__clang__) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_RESTRICT __restrict
#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
    #define JSON_HEDLEY_RESTRICT _Restrict
#else
    #define JSON_HEDLEY_RESTRICT
#endif

#if defined(JSON_HEDLEY_INLINE)
    #undef JSON_HEDLEY_INLINE
#endif
#if \
    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
    (defined(__cplusplus) && (__cplusplus >= 199711L))
    #define JSON_HEDLEY_INLINE inline
#elif \
    defined(JSON_HEDLEY_GCC_VERSION) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
    #define JSON_HEDLEY_INLINE __inline__
#elif \
    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_INLINE __inline
#else
    #define JSON_HEDLEY_INLINE
#endif

#if defined(JSON_HEDLEY_ALWAYS_INLINE)
    #undef JSON_HEDLEY_ALWAYS_INLINE
#endif
#if \
  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
#elif \
  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
#elif defined(__cplusplus) && \
    ( \
      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
    )
#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
#else
#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
#endif

#if defined(JSON_HEDLEY_NEVER_INLINE)
    #undef JSON_HEDLEY_NEVER_INLINE
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
#elif \
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
#else
    #define JSON_HEDLEY_NEVER_INLINE
#endif

#if defined(JSON_HEDLEY_PRIVATE)
    #undef JSON_HEDLEY_PRIVATE
#endif
#if defined(JSON_HEDLEY_PUBLIC)
    #undef JSON_HEDLEY_PUBLIC
#endif
#if defined(JSON_HEDLEY_IMPORT)
    #undef JSON_HEDLEY_IMPORT
#endif
#if defined(_WIN32) || defined(__CYGWIN__)
#  define JSON_HEDLEY_PRIVATE
#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
#else
#  if \
    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
    ( \
      defined(__TI_EABI__) && \
      ( \
        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
      ) \
    ) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
#  else
#    define JSON_HEDLEY_PRIVATE
#    define JSON_HEDLEY_PUBLIC
#  endif
#  define JSON_HEDLEY_IMPORT    extern
#endif

#if defined(JSON_HEDLEY_NO_THROW)
    #undef JSON_HEDLEY_NO_THROW
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
#elif \
    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
#else
    #define JSON_HEDLEY_NO_THROW
#endif

#if defined(JSON_HEDLEY_FALL_THROUGH)
    #undef JSON_HEDLEY_FALL_THROUGH
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
#elif defined(__fallthrough) /* SAL */
    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
#else
    #define JSON_HEDLEY_FALL_THROUGH
#endif

#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
    #undef JSON_HEDLEY_RETURNS_NON_NULL
#endif
#if \
    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
#elif defined(_Ret_notnull_) /* SAL */
    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
#else
    #define JSON_HEDLEY_RETURNS_NON_NULL
#endif

#if defined(JSON_HEDLEY_ARRAY_PARAM)
    #undef JSON_HEDLEY_ARRAY_PARAM
#endif
#if \
    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
    !defined(__STDC_NO_VLA__) && \
    !defined(__cplusplus) && \
    !defined(JSON_HEDLEY_PGI_VERSION) && \
    !defined(JSON_HEDLEY_TINYC_VERSION)
    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
#else
    #define JSON_HEDLEY_ARRAY_PARAM(name)
#endif

#if defined(JSON_HEDLEY_IS_CONSTANT)
    #undef JSON_HEDLEY_IS_CONSTANT
#endif
#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
#endif
/* JSON_HEDLEY_IS_CONSTEXPR_ is for
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
    #undef JSON_HEDLEY_IS_CONSTEXPR_
#endif
#if \
    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
#endif
#if !defined(__cplusplus)
#  if \
       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
#if defined(__INTPTR_TYPE__)
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
#else
    #include <stdint.h>
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
#endif
#  elif \
       ( \
          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
          !defined(JSON_HEDLEY_PGI_VERSION) && \
          !defined(JSON_HEDLEY_IAR_VERSION)) || \
       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
#if defined(__INTPTR_TYPE__)
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
#else
    #include <stdint.h>
    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
#endif
#  elif \
       defined(JSON_HEDLEY_GCC_VERSION) || \
       defined(JSON_HEDLEY_INTEL_VERSION) || \
       defined(JSON_HEDLEY_TINYC_VERSION) || \
       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
       defined(__clang__)
#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
        sizeof(void) != \
        sizeof(*( \
                  1 ? \
                  ((void*) ((expr) * 0L) ) : \
((struct { char v[sizeof(void) * 2]; } *) 1) \
                ) \
              ) \
                                            )
#  endif
#endif
#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
    #if !defined(JSON_HEDLEY_IS_CONSTANT)
        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
    #endif
    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
#else
    #if !defined(JSON_HEDLEY_IS_CONSTANT)
        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
    #endif
    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
#endif

#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
    #undef JSON_HEDLEY_BEGIN_C_DECLS
#endif
#if defined(JSON_HEDLEY_END_C_DECLS)
    #undef JSON_HEDLEY_END_C_DECLS
#endif
#if defined(JSON_HEDLEY_C_DECL)
    #undef JSON_HEDLEY_C_DECL
#endif
#if defined(__cplusplus)
    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
    #define JSON_HEDLEY_END_C_DECLS }
    #define JSON_HEDLEY_C_DECL extern "C"
#else
    #define JSON_HEDLEY_BEGIN_C_DECLS
    #define JSON_HEDLEY_END_C_DECLS
    #define JSON_HEDLEY_C_DECL
#endif

#if defined(JSON_HEDLEY_STATIC_ASSERT)
    #undef JSON_HEDLEY_STATIC_ASSERT
#endif
#if \
  !defined(__cplusplus) && ( \
      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
      defined(_Static_assert) \
    )
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
#elif \
  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
#else
#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
#endif

#if defined(JSON_HEDLEY_NULL)
    #undef JSON_HEDLEY_NULL
#endif
#if defined(__cplusplus)
    #if __cplusplus >= 201103L
        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
    #elif defined(NULL)
        #define JSON_HEDLEY_NULL NULL
    #else
        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
    #endif
#elif defined(NULL)
    #define JSON_HEDLEY_NULL NULL
#else
    #define JSON_HEDLEY_NULL ((void*) 0)
#endif

#if defined(JSON_HEDLEY_MESSAGE)
    #undef JSON_HEDLEY_MESSAGE
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
#  define JSON_HEDLEY_MESSAGE(msg) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
    JSON_HEDLEY_PRAGMA(message msg) \
    JSON_HEDLEY_DIAGNOSTIC_POP
#elif \
  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
#else
#  define JSON_HEDLEY_MESSAGE(msg)
#endif

#if defined(JSON_HEDLEY_WARNING)
    #undef JSON_HEDLEY_WARNING
#endif
#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
#  define JSON_HEDLEY_WARNING(msg) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
    JSON_HEDLEY_PRAGMA(clang warning msg) \
    JSON_HEDLEY_DIAGNOSTIC_POP
#elif \
  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
#elif \
  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
#else
#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
#endif

#if defined(JSON_HEDLEY_REQUIRE)
    #undef JSON_HEDLEY_REQUIRE
#endif
#if defined(JSON_HEDLEY_REQUIRE_MSG)
    #undef JSON_HEDLEY_REQUIRE_MSG
#endif
#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
#    define JSON_HEDLEY_REQUIRE(expr) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
    JSON_HEDLEY_DIAGNOSTIC_POP
#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
    JSON_HEDLEY_DIAGNOSTIC_PUSH \
    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
    __attribute__((diagnose_if(!(expr), msg, "error"))) \
    JSON_HEDLEY_DIAGNOSTIC_POP
#  else
#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
#  endif
#else
#  define JSON_HEDLEY_REQUIRE(expr)
#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
#endif

#if defined(JSON_HEDLEY_FLAGS)
    #undef JSON_HEDLEY_FLAGS
#endif
#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
#else
    #define JSON_HEDLEY_FLAGS
#endif

#if defined(JSON_HEDLEY_FLAGS_CAST)
    #undef JSON_HEDLEY_FLAGS_CAST
#endif
#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
        JSON_HEDLEY_DIAGNOSTIC_PUSH \
        _Pragma("warning(disable:188)") \
        ((T) (expr)); \
        JSON_HEDLEY_DIAGNOSTIC_POP \
    }))
#else
#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
#endif

#if defined(JSON_HEDLEY_EMPTY_BASES)
    #undef JSON_HEDLEY_EMPTY_BASES
#endif
#if \
    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
#else
    #define JSON_HEDLEY_EMPTY_BASES
#endif

/* Remaining macros are deprecated. */

#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
#endif
#if defined(__clang__)
    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
#else
    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
#endif

#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
#endif
#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)

#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
#endif
#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)

#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
#endif
#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)

#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
#endif
#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)

#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
#endif
#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)

#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
#endif
#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)

#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
    #undef JSON_HEDLEY_CLANG_HAS_WARNING
#endif
#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)

#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */


// This file contains all internal macro definitions (except those affecting ABI)
// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them

// #include <nlohmann/detail/abi_macros.hpp>


// exclude unsupported compilers
#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
    #if defined(__clang__)
        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
        #endif
    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
        #endif
    #endif
#endif

// C++ language standard detection
// if the user manually specified the used c++ version this is skipped
#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
        #define JSON_HAS_CPP_20
        #define JSON_HAS_CPP_17
        #define JSON_HAS_CPP_14
    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
        #define JSON_HAS_CPP_17
        #define JSON_HAS_CPP_14
    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
        #define JSON_HAS_CPP_14
    #endif
    // the cpp 11 flag is always specified because it is the minimal required version
    #define JSON_HAS_CPP_11
#endif

#ifdef __has_include
    #if __has_include(<version>)
        #include <version>
    #endif
#endif

#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
    #ifdef JSON_HAS_CPP_17
        #if defined(__cpp_lib_filesystem)
            #define JSON_HAS_FILESYSTEM 1
        #elif defined(__cpp_lib_experimental_filesystem)
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
        #elif !defined(__has_include)
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
        #elif __has_include(<filesystem>)
            #define JSON_HAS_FILESYSTEM 1
        #elif __has_include(<experimental/filesystem>)
            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
        #endif

        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
            #undef JSON_HAS_FILESYSTEM
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
        #endif

        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
            #undef JSON_HAS_FILESYSTEM
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
        #endif

        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
        #if defined(__clang_major__) && __clang_major__ < 7
            #undef JSON_HAS_FILESYSTEM
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
        #endif

        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
        #if defined(_MSC_VER) && _MSC_VER < 1914
            #undef JSON_HAS_FILESYSTEM
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
        #endif

        // no filesystem support before iOS 13
        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
            #undef JSON_HAS_FILESYSTEM
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
        #endif

        // no filesystem support before macOS Catalina
        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
            #undef JSON_HAS_FILESYSTEM
            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
        #endif
    #endif
#endif

#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
#endif

#ifndef JSON_HAS_FILESYSTEM
    #define JSON_HAS_FILESYSTEM 0
#endif

#ifndef JSON_HAS_THREE_WAY_COMPARISON
    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
        #define JSON_HAS_THREE_WAY_COMPARISON 1
    #else
        #define JSON_HAS_THREE_WAY_COMPARISON 0
    #endif
#endif

#ifndef JSON_HAS_RANGES
    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
        #define JSON_HAS_RANGES 0
    #elif defined(__cpp_lib_ranges)
        #define JSON_HAS_RANGES 1
    #else
        #define JSON_HAS_RANGES 0
    #endif
#endif

#ifndef JSON_HAS_STATIC_RTTI
    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
        #define JSON_HAS_STATIC_RTTI 1
    #else
        #define JSON_HAS_STATIC_RTTI 0
    #endif
#endif

#ifdef JSON_HAS_CPP_17
    #define JSON_INLINE_VARIABLE inline
#else
    #define JSON_INLINE_VARIABLE
#endif

#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
#else
    #define JSON_NO_UNIQUE_ADDRESS
#endif

// disable documentation warnings on clang
#if defined(__clang__)
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wdocumentation"
    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
#endif

// allow disabling exceptions
#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
    #define JSON_THROW(exception) throw exception
    #define JSON_TRY try
    #define JSON_CATCH(exception) catch(exception)
    #define JSON_INTERNAL_CATCH(exception) catch(exception)
#else
    #include <cstdlib>
    #define JSON_THROW(exception) std::abort()
    #define JSON_TRY if(true)
    #define JSON_CATCH(exception) if(false)
    #define JSON_INTERNAL_CATCH(exception) if(false)
#endif

// override exception macros
#if defined(JSON_THROW_USER)
    #undef JSON_THROW
    #define JSON_THROW JSON_THROW_USER
#endif
#if defined(JSON_TRY_USER)
    #undef JSON_TRY
    #define JSON_TRY JSON_TRY_USER
#endif
#if defined(JSON_CATCH_USER)
    #undef JSON_CATCH
    #define JSON_CATCH JSON_CATCH_USER
    #undef JSON_INTERNAL_CATCH
    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
#endif
#if defined(JSON_INTERNAL_CATCH_USER)
    #undef JSON_INTERNAL_CATCH
    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
#endif

// allow overriding assert
#if !defined(JSON_ASSERT)
    #include <cassert> // assert
    #define JSON_ASSERT(x) assert(x)
#endif

// allow to access some private functions (needed by the test suite)
#if defined(JSON_TESTS_PRIVATE)
    #define JSON_PRIVATE_UNLESS_TESTED public
#else
    #define JSON_PRIVATE_UNLESS_TESTED private
#endif

/*!
@brief macro to briefly define a mapping between an enum and JSON
@def NLOHMANN_JSON_SERIALIZE_ENUM
@since version 3.4.0
*/
#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
    template<typename BasicJsonType>                                                            \
    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
    {                                                                                           \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
        {                                                                                       \
            return ej_pair.first == e;                                                          \
        });                                                                                     \
        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
    }                                                                                           \
    template<typename BasicJsonType>                                                            \
    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
    {                                                                                           \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
        {                                                                                       \
            return ej_pair.second == j;                                                         \
        });                                                                                     \
        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
    }

// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
// may be removed in the future once the class is split.

#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
    template<template<typename, typename, typename...> class ObjectType,   \
             template<typename, typename...> class ArrayType,              \
             class StringType, class BooleanType, class NumberIntegerType, \
             class NumberUnsignedType, class NumberFloatType,              \
             template<typename> class AllocatorType,                       \
             template<typename, typename = void> class JSONSerializer,     \
             class BinaryType,                                             \
             class CustomBaseClass>

#define NLOHMANN_BASIC_JSON_TPL                                            \
    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>

// Macros to simplify conversion from/to types

#define NLOHMANN_JSON_EXPAND( x ) x
#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
        NLOHMANN_JSON_PASTE64, \
        NLOHMANN_JSON_PASTE63, \
        NLOHMANN_JSON_PASTE62, \
        NLOHMANN_JSON_PASTE61, \
        NLOHMANN_JSON_PASTE60, \
        NLOHMANN_JSON_PASTE59, \
        NLOHMANN_JSON_PASTE58, \
        NLOHMANN_JSON_PASTE57, \
        NLOHMANN_JSON_PASTE56, \
        NLOHMANN_JSON_PASTE55, \
        NLOHMANN_JSON_PASTE54, \
        NLOHMANN_JSON_PASTE53, \
        NLOHMANN_JSON_PASTE52, \
        NLOHMANN_JSON_PASTE51, \
        NLOHMANN_JSON_PASTE50, \
        NLOHMANN_JSON_PASTE49, \
        NLOHMANN_JSON_PASTE48, \
        NLOHMANN_JSON_PASTE47, \
        NLOHMANN_JSON_PASTE46, \
        NLOHMANN_JSON_PASTE45, \
        NLOHMANN_JSON_PASTE44, \
        NLOHMANN_JSON_PASTE43, \
        NLOHMANN_JSON_PASTE42, \
        NLOHMANN_JSON_PASTE41, \
        NLOHMANN_JSON_PASTE40, \
        NLOHMANN_JSON_PASTE39, \
        NLOHMANN_JSON_PASTE38, \
        NLOHMANN_JSON_PASTE37, \
        NLOHMANN_JSON_PASTE36, \
        NLOHMANN_JSON_PASTE35, \
        NLOHMANN_JSON_PASTE34, \
        NLOHMANN_JSON_PASTE33, \
        NLOHMANN_JSON_PASTE32, \
        NLOHMANN_JSON_PASTE31, \
        NLOHMANN_JSON_PASTE30, \
        NLOHMANN_JSON_PASTE29, \
        NLOHMANN_JSON_PASTE28, \
        NLOHMANN_JSON_PASTE27, \
        NLOHMANN_JSON_PASTE26, \
        NLOHMANN_JSON_PASTE25, \
        NLOHMANN_JSON_PASTE24, \
        NLOHMANN_JSON_PASTE23, \
        NLOHMANN_JSON_PASTE22, \
        NLOHMANN_JSON_PASTE21, \
        NLOHMANN_JSON_PASTE20, \
        NLOHMANN_JSON_PASTE19, \
        NLOHMANN_JSON_PASTE18, \
        NLOHMANN_JSON_PASTE17, \
        NLOHMANN_JSON_PASTE16, \
        NLOHMANN_JSON_PASTE15, \
        NLOHMANN_JSON_PASTE14, \
        NLOHMANN_JSON_PASTE13, \
        NLOHMANN_JSON_PASTE12, \
        NLOHMANN_JSON_PASTE11, \
        NLOHMANN_JSON_PASTE10, \
        NLOHMANN_JSON_PASTE9, \
        NLOHMANN_JSON_PASTE8, \
        NLOHMANN_JSON_PASTE7, \
        NLOHMANN_JSON_PASTE6, \
        NLOHMANN_JSON_PASTE5, \
        NLOHMANN_JSON_PASTE4, \
        NLOHMANN_JSON_PASTE3, \
        NLOHMANN_JSON_PASTE2, \
        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)

#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);

/*!
@brief macro
@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
@since version 3.9.0
*/
#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }

#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }

#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }

/*!
@brief macro
@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
@since version 3.9.0
*/
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }

#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }

#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }

// inspired from https://stackoverflow.com/a/26745591
// allows to call any std function as if (e.g. with begin):
// using std::begin; begin(x);
//
// it allows using the detected idiom to retrieve the return type
// of such an expression
#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
    namespace detail {                                                            \
    using std::std_name;                                                          \
    \
    template<typename... T>                                                       \
    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
    }                                                                             \
    \
    namespace detail2 {                                                           \
    struct std_name##_tag                                                         \
    {                                                                             \
    };                                                                            \
    \
    template<typename... T>                                                       \
    std_name##_tag std_name(T&&...);                                              \
    \
    template<typename... T>                                                       \
    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
    \
    template<typename... T>                                                       \
    struct would_call_std_##std_name                                              \
    {                                                                             \
        static constexpr auto const value = ::nlohmann::detail::                  \
                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
    };                                                                            \
    } /* namespace detail2 */ \
    \
    template<typename... T>                                                       \
    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
    {                                                                             \
    }

#ifndef JSON_USE_IMPLICIT_CONVERSIONS
    #define JSON_USE_IMPLICIT_CONVERSIONS 1
#endif

#if JSON_USE_IMPLICIT_CONVERSIONS
    #define JSON_EXPLICIT
#else
    #define JSON_EXPLICIT explicit
#endif

#ifndef JSON_DISABLE_ENUM_SERIALIZATION
    #define JSON_DISABLE_ENUM_SERIALIZATION 0
#endif

#ifndef JSON_USE_GLOBAL_UDLS
    #define JSON_USE_GLOBAL_UDLS 1
#endif

#if JSON_HAS_THREE_WAY_COMPARISON
    #include <compare> // partial_ordering
#endif

NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

///////////////////////////
// JSON type enumeration //
///////////////////////////

/*!
@brief the JSON type enumeration

This enumeration collects the different JSON types. It is internally used to
distinguish the stored values, and the functions @ref basic_json::is_null(),
@ref basic_json::is_object(), @ref basic_json::is_array(),
@ref basic_json::is_string(), @ref basic_json::is_boolean(),
@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
@ref basic_json::is_structured() rely on it.

@note There are three enumeration entries (number_integer, number_unsigned, and
number_float), because the library distinguishes these three types for numbers:
@ref basic_json::number_unsigned_t is used for unsigned integers,
@ref basic_json::number_integer_t is used for signed integers, and
@ref basic_json::number_float_t is used for floating-point numbers or to
approximate integers which do not fit in the limits of their respective type.

@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
value with the default value for a given type

@since version 1.0.0
*/
enum class value_t : std::uint8_t
{
    null,             ///< null value
    object,           ///< object (unordered set of name/value pairs)
    array,            ///< array (ordered collection of values)
    string,           ///< string value
    boolean,          ///< boolean value
    number_integer,   ///< number value (signed integer)
    number_unsigned,  ///< number value (unsigned integer)
    number_float,     ///< number value (floating-point)
    binary,           ///< binary array (ordered collection of bytes)
    discarded         ///< discarded by the parser callback function
};

/*!
@brief comparison operator for JSON types

Returns an ordering that is similar to Python:
- order: null < boolean < number < object < array < string < binary
- furthermore, each type is not smaller than itself
- discarded values are not comparable
- binary is represented as a b"" string in python and directly comparable to a
  string; however, making a binary array directly comparable with a string would
  be surprising behavior in a JSON file.

@since version 1.0.0
*/
#if JSON_HAS_THREE_WAY_COMPARISON
    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
#else
    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
#endif
{
    static constexpr std::array<std::uint8_t, 9> order = {{
            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
            6 /* binary */
        }
    };

    const auto l_index = static_cast<std::size_t>(lhs);
    const auto r_index = static_cast<std::size_t>(rhs);
#if JSON_HAS_THREE_WAY_COMPARISON
    if (l_index < order.size() && r_index < order.size())
    {
        return order[l_index] <=> order[r_index]; // *NOPAD*
    }
    return std::partial_ordering::unordered;
#else
    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
#endif
}

// GCC selects the built-in operator< over an operator rewritten from
// a user-defined spaceship operator
// Clang, MSVC, and ICC select the rewritten candidate
// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
inline bool operator<(const value_t lhs, const value_t rhs) noexcept
{
    return std::is_lt(lhs <=> rhs); // *NOPAD*
}
#endif

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/string_escape.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// #include <nlohmann/detail/abi_macros.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/*!
@brief replace all occurrences of a substring by another string

@param[in,out] s  the string to manipulate; changed so that all
               occurrences of @a f are replaced with @a t
@param[in]     f  the substring to replace with @a t
@param[in]     t  the string to replace @a f

@pre The search string @a f must not be empty. **This precondition is
enforced with an assertion.**

@since version 2.0.0
*/
template<typename StringType>
inline void replace_substring(StringType& s, const StringType& f,
                              const StringType& t)
{
    JSON_ASSERT(!f.empty());
    for (auto pos = s.find(f);                // find first occurrence of f
            pos != StringType::npos;          // make sure f was found
            s.replace(pos, f.size(), t),      // replace with t, and
            pos = s.find(f, pos + t.size()))  // find next occurrence of f
    {}
}

/*!
 * @brief string escaping as described in RFC 6901 (Sect. 4)
 * @param[in] s string to escape
 * @return    escaped string
 *
 * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
 */
template<typename StringType>
inline StringType escape(StringType s)
{
    replace_substring(s, StringType{"~"}, StringType{"~0"});
    replace_substring(s, StringType{"/"}, StringType{"~1"});
    return s;
}

/*!
 * @brief string unescaping as described in RFC 6901 (Sect. 4)
 * @param[in] s string to unescape
 * @return    unescaped string
 *
 * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
 */
template<typename StringType>
static void unescape(StringType& s)
{
    replace_substring(s, StringType{"~1"}, StringType{"/"});
    replace_substring(s, StringType{"~0"}, StringType{"~"});
}

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/input/position_t.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstddef> // size_t

// #include <nlohmann/detail/abi_macros.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/// struct to capture the start position of the current token
struct position_t
{
    /// the total number of characters read
    std::size_t chars_read_total = 0;
    /// the number of characters read in the current line
    std::size_t chars_read_current_line = 0;
    /// the number of lines read
    std::size_t lines_read = 0;

    /// conversion to size_t to preserve SAX interface
    constexpr operator size_t() const
    {
        return chars_read_total;
    }
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-FileCopyrightText: 2018 The Abseil Authors
// SPDX-License-Identifier: MIT



#include <array> // array
#include <cstddef> // size_t
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
#include <utility> // index_sequence, make_index_sequence, index_sequence_for

// #include <nlohmann/detail/macro_scope.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

template<typename T>
using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;

#ifdef JSON_HAS_CPP_14

// the following utilities are natively available in C++14
using std::enable_if_t;
using std::index_sequence;
using std::make_index_sequence;
using std::index_sequence_for;

#else

// alias templates to reduce boilerplate
template<bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;

// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.

//// START OF CODE FROM GOOGLE ABSEIL

// integer_sequence
//
// Class template representing a compile-time integer sequence. An instantiation
// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
// type through its template arguments (which is a common need when
// working with C++11 variadic templates). `absl::integer_sequence` is designed
// to be a drop-in replacement for C++14's `std::integer_sequence`.
//
// Example:
//
//   template< class T, T... Ints >
//   void user_function(integer_sequence<T, Ints...>);
//
//   int main()
//   {
//     // user_function's `T` will be deduced to `int` and `Ints...`
//     // will be deduced to `0, 1, 2, 3, 4`.
//     user_function(make_integer_sequence<int, 5>());
//   }
template <typename T, T... Ints>
struct integer_sequence
{
    using value_type = T;
    static constexpr std::size_t size() noexcept
    {
        return sizeof...(Ints);
    }
};

// index_sequence
//
// A helper template for an `integer_sequence` of `size_t`,
// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
// `std::index_sequence`.
template <size_t... Ints>
using index_sequence = integer_sequence<size_t, Ints...>;

namespace utility_internal
{

template <typename Seq, size_t SeqSize, size_t Rem>
struct Extend;

// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
template <typename T, T... Ints, size_t SeqSize>
struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
{
    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
};

template <typename T, T... Ints, size_t SeqSize>
struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
{
    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
};

// Recursion helper for 'make_integer_sequence<T, N>'.
// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
template <typename T, size_t N>
struct Gen
{
    using type =
        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
};

template <typename T>
struct Gen<T, 0>
{
    using type = integer_sequence<T>;
};

}  // namespace utility_internal

// Compile-time sequences of integers

// make_integer_sequence
//
// This template alias is equivalent to
// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
// replacement for C++14's `std::make_integer_sequence`.
template <typename T, T N>
using make_integer_sequence = typename utility_internal::Gen<T, N>::type;

// make_index_sequence
//
// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
// and is designed to be a drop-in replacement for C++14's
// `std::make_index_sequence`.
template <size_t N>
using make_index_sequence = make_integer_sequence<size_t, N>;

// index_sequence_for
//
// Converts a typename pack into an index sequence of the same length, and
// is designed to be a drop-in replacement for C++14's
// `std::index_sequence_for()`
template <typename... Ts>
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;

//// END OF CODE FROM GOOGLE ABSEIL

#endif

// dispatch utility (taken from ranges-v3)
template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
template<> struct priority_tag<0> {};

// taken from ranges-v3
template<typename T>
struct static_const
{
    static JSON_INLINE_VARIABLE constexpr T value{};
};

#ifndef JSON_HAS_CPP_17
    template<typename T>
    constexpr T static_const<T>::value;
#endif

template<typename T, typename... Args>
inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
{
    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
}

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/meta/type_traits.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <limits> // numeric_limits
#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
#include <utility> // declval
#include <tuple> // tuple
#include <string> // char_traits

// #include <nlohmann/detail/iterators/iterator_traits.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <iterator> // random_access_iterator_tag

// #include <nlohmann/detail/abi_macros.hpp>

// #include <nlohmann/detail/meta/void_t.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

template<typename It, typename = void>
struct iterator_types {};

template<typename It>
struct iterator_types <
    It,
    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
    typename It::reference, typename It::iterator_category >>
{
    using difference_type = typename It::difference_type;
    using value_type = typename It::value_type;
    using pointer = typename It::pointer;
    using reference = typename It::reference;
    using iterator_category = typename It::iterator_category;
};

// This is required as some compilers implement std::iterator_traits in a way that
// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
template<typename T, typename = void>
struct iterator_traits
{
};

template<typename T>
struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
            : iterator_types<T>
{
};

template<typename T>
struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
{
    using iterator_category = std::random_access_iterator_tag;
    using value_type = T;
    using difference_type = ptrdiff_t;
    using pointer = T*;
    using reference = T&;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/call_std/begin.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// #include <nlohmann/detail/macro_scope.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN

NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);

NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/meta/call_std/end.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// #include <nlohmann/detail/macro_scope.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN

NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);

NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/detected.hpp>

// #include <nlohmann/json_fwd.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT

#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_

    #include <cstdint> // int64_t, uint64_t
    #include <map> // map
    #include <memory> // allocator
    #include <string> // string
    #include <vector> // vector

    // #include <nlohmann/detail/abi_macros.hpp>


    /*!
    @brief namespace for Niels Lohmann
    @see https://github.com/nlohmann
    @since version 1.0.0
    */
    NLOHMANN_JSON_NAMESPACE_BEGIN

    /*!
    @brief default JSONSerializer template argument

    This serializer ignores the template arguments and uses ADL
    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
    for serialization.
    */
    template<typename T = void, typename SFINAE = void>
    struct adl_serializer;

    /// a class to store JSON values
    /// @sa https://json.nlohmann.me/api/basic_json/
    template<template<typename U, typename V, typename... Args> class ObjectType =
    std::map,
    template<typename U, typename... Args> class ArrayType = std::vector,
    class StringType = std::string, class BooleanType = bool,
    class NumberIntegerType = std::int64_t,
    class NumberUnsignedType = std::uint64_t,
    class NumberFloatType = double,
    template<typename U> class AllocatorType = std::allocator,
    template<typename T, typename SFINAE = void> class JSONSerializer =
    adl_serializer,
    class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
    class CustomBaseClass = void>
    class basic_json;

    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
    /// @sa https://json.nlohmann.me/api/json_pointer/
    template<typename RefStringType>
    class json_pointer;

    /*!
    @brief default specialization
    @sa https://json.nlohmann.me/api/json/
    */
    using json = basic_json<>;

    /// @brief a minimal map-like container that preserves insertion order
    /// @sa https://json.nlohmann.me/api/ordered_map/
    template<class Key, class T, class IgnoredLess, class Allocator>
    struct ordered_map;

    /// @brief specialization that maintains the insertion order of object keys
    /// @sa https://json.nlohmann.me/api/ordered_json/
    using ordered_json = basic_json<nlohmann::ordered_map>;

    NLOHMANN_JSON_NAMESPACE_END

#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_


NLOHMANN_JSON_NAMESPACE_BEGIN
/*!
@brief detail namespace with internal helper functions

This namespace collects functions that should not be exposed,
implementations of some @ref basic_json methods, and meta-programming helpers.

@since version 2.1.0
*/
namespace detail
{

/////////////
// helpers //
/////////////

// Note to maintainers:
//
// Every trait in this file expects a non CV-qualified type.
// The only exceptions are in the 'aliases for detected' section
// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
//
// In this case, T has to be properly CV-qualified to constraint the function arguments
// (e.g. to_json(BasicJsonType&, const T&))

template<typename> struct is_basic_json : std::false_type {};

NLOHMANN_BASIC_JSON_TPL_DECLARATION
struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};

// used by exceptions create() member functions
// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
// false_type otherwise
template<typename BasicJsonContext>
struct is_basic_json_context :
    std::integral_constant < bool,
    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
{};

//////////////////////
// json_ref helpers //
//////////////////////

template<typename>
class json_ref;

template<typename>
struct is_json_ref : std::false_type {};

template<typename T>
struct is_json_ref<json_ref<T>> : std::true_type {};

//////////////////////////
// aliases for detected //
//////////////////////////

template<typename T>
using mapped_type_t = typename T::mapped_type;

template<typename T>
using key_type_t = typename T::key_type;

template<typename T>
using value_type_t = typename T::value_type;

template<typename T>
using difference_type_t = typename T::difference_type;

template<typename T>
using pointer_t = typename T::pointer;

template<typename T>
using reference_t = typename T::reference;

template<typename T>
using iterator_category_t = typename T::iterator_category;

template<typename T, typename... Args>
using to_json_function = decltype(T::to_json(std::declval<Args>()...));

template<typename T, typename... Args>
using from_json_function = decltype(T::from_json(std::declval<Args>()...));

template<typename T, typename U>
using get_template_function = decltype(std::declval<T>().template get<U>());

// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
template<typename BasicJsonType, typename T, typename = void>
struct has_from_json : std::false_type {};

// trait checking if j.get<T> is valid
// use this trait instead of std::is_constructible or std::is_convertible,
// both rely on, or make use of implicit conversions, and thus fail when T
// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
template <typename BasicJsonType, typename T>
struct is_getable
{
    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
};

template<typename BasicJsonType, typename T>
struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{
    using serializer = typename BasicJsonType::template json_serializer<T, void>;

    static constexpr bool value =
        is_detected_exact<void, from_json_function, serializer,
        const BasicJsonType&, T&>::value;
};

// This trait checks if JSONSerializer<T>::from_json(json const&) exists
// this overload is used for non-default-constructible user-defined-types
template<typename BasicJsonType, typename T, typename = void>
struct has_non_default_from_json : std::false_type {};

template<typename BasicJsonType, typename T>
struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{
    using serializer = typename BasicJsonType::template json_serializer<T, void>;

    static constexpr bool value =
        is_detected_exact<T, from_json_function, serializer,
        const BasicJsonType&>::value;
};

// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
template<typename BasicJsonType, typename T, typename = void>
struct has_to_json : std::false_type {};

template<typename BasicJsonType, typename T>
struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
{
    using serializer = typename BasicJsonType::template json_serializer<T, void>;

    static constexpr bool value =
        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
        T>::value;
};

template<typename T>
using detect_key_compare = typename T::key_compare;

template<typename T>
struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};

// obtains the actual object key comparator
template<typename BasicJsonType>
struct actual_object_comparator
{
    using object_t = typename BasicJsonType::object_t;
    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
    using type = typename std::conditional < has_key_compare<object_t>::value,
          typename object_t::key_compare, object_comparator_t>::type;
};

template<typename BasicJsonType>
using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;

/////////////////
// char_traits //
/////////////////

// Primary template of char_traits calls std char_traits
template<typename T>
struct char_traits : std::char_traits<T>
{};

// Explicitly define char traits for unsigned char since it is not standard
template<>
struct char_traits<unsigned char> : std::char_traits<char>
{
    using char_type = unsigned char;
    using int_type = uint64_t;

    // Redefine to_int_type function
    static int_type to_int_type(char_type c) noexcept
    {
        return static_cast<int_type>(c);
    }

    static char_type to_char_type(int_type i) noexcept
    {
        return static_cast<char_type>(i);
    }

    static constexpr int_type eof() noexcept
    {
        return static_cast<int_type>(EOF);
    }
};

// Explicitly define char traits for signed char since it is not standard
template<>
struct char_traits<signed char> : std::char_traits<char>
{
    using char_type = signed char;
    using int_type = uint64_t;

    // Redefine to_int_type function
    static int_type to_int_type(char_type c) noexcept
    {
        return static_cast<int_type>(c);
    }

    static char_type to_char_type(int_type i) noexcept
    {
        return static_cast<char_type>(i);
    }

    static constexpr int_type eof() noexcept
    {
        return static_cast<int_type>(EOF);
    }
};

///////////////////
// is_ functions //
///////////////////

// https://en.cppreference.com/w/cpp/types/conjunction
template<class...> struct conjunction : std::true_type { };
template<class B> struct conjunction<B> : B { };
template<class B, class... Bn>
struct conjunction<B, Bn...>
: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};

// https://en.cppreference.com/w/cpp/types/negation
template<class B> struct negation : std::integral_constant < bool, !B::value > { };

// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
template <typename T>
struct is_default_constructible : std::is_default_constructible<T> {};

template <typename T1, typename T2>
struct is_default_constructible<std::pair<T1, T2>>
            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};

template <typename T1, typename T2>
struct is_default_constructible<const std::pair<T1, T2>>
            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};

template <typename... Ts>
struct is_default_constructible<std::tuple<Ts...>>
            : conjunction<is_default_constructible<Ts>...> {};

template <typename... Ts>
struct is_default_constructible<const std::tuple<Ts...>>
            : conjunction<is_default_constructible<Ts>...> {};

template <typename T, typename... Args>
struct is_constructible : std::is_constructible<T, Args...> {};

template <typename T1, typename T2>
struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};

template <typename T1, typename T2>
struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};

template <typename... Ts>
struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};

template <typename... Ts>
struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};

template<typename T, typename = void>
struct is_iterator_traits : std::false_type {};

template<typename T>
struct is_iterator_traits<iterator_traits<T>>
{
  private:
    using traits = iterator_traits<T>;

  public:
    static constexpr auto value =
        is_detected<value_type_t, traits>::value &&
        is_detected<difference_type_t, traits>::value &&
        is_detected<pointer_t, traits>::value &&
        is_detected<iterator_category_t, traits>::value &&
        is_detected<reference_t, traits>::value;
};

template<typename T>
struct is_range
{
  private:
    using t_ref = typename std::add_lvalue_reference<T>::type;

    using iterator = detected_t<result_of_begin, t_ref>;
    using sentinel = detected_t<result_of_end, t_ref>;

    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
    static constexpr auto is_iterator_begin =
        is_iterator_traits<iterator_traits<iterator>>::value;

  public:
    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
};

template<typename R>
using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;

template<typename T>
using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;

// The following implementation of is_complete_type is taken from
// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
// and is written by Xiang Fan who agreed to using it in this library.

template<typename T, typename = void>
struct is_complete_type : std::false_type {};

template<typename T>
struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};

template<typename BasicJsonType, typename CompatibleObjectType,
         typename = void>
struct is_compatible_object_type_impl : std::false_type {};

template<typename BasicJsonType, typename CompatibleObjectType>
struct is_compatible_object_type_impl <
    BasicJsonType, CompatibleObjectType,
    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
    is_detected<key_type_t, CompatibleObjectType>::value >>
{
    using object_t = typename BasicJsonType::object_t;

    // macOS's is_constructible does not play well with nonesuch...
    static constexpr bool value =
        is_constructible<typename object_t::key_type,
        typename CompatibleObjectType::key_type>::value &&
        is_constructible<typename object_t::mapped_type,
        typename CompatibleObjectType::mapped_type>::value;
};

template<typename BasicJsonType, typename CompatibleObjectType>
struct is_compatible_object_type
    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};

template<typename BasicJsonType, typename ConstructibleObjectType,
         typename = void>
struct is_constructible_object_type_impl : std::false_type {};

template<typename BasicJsonType, typename ConstructibleObjectType>
struct is_constructible_object_type_impl <
    BasicJsonType, ConstructibleObjectType,
    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
    is_detected<key_type_t, ConstructibleObjectType>::value >>
{
    using object_t = typename BasicJsonType::object_t;

    static constexpr bool value =
        (is_default_constructible<ConstructibleObjectType>::value &&
         (std::is_move_assignable<ConstructibleObjectType>::value ||
          std::is_copy_assignable<ConstructibleObjectType>::value) &&
         (is_constructible<typename ConstructibleObjectType::key_type,
          typename object_t::key_type>::value &&
          std::is_same <
          typename object_t::mapped_type,
          typename ConstructibleObjectType::mapped_type >::value)) ||
        (has_from_json<BasicJsonType,
         typename ConstructibleObjectType::mapped_type>::value ||
         has_non_default_from_json <
         BasicJsonType,
         typename ConstructibleObjectType::mapped_type >::value);
};

template<typename BasicJsonType, typename ConstructibleObjectType>
struct is_constructible_object_type
    : is_constructible_object_type_impl<BasicJsonType,
      ConstructibleObjectType> {};

template<typename BasicJsonType, typename CompatibleStringType>
struct is_compatible_string_type
{
    static constexpr auto value =
        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
};

template<typename BasicJsonType, typename ConstructibleStringType>
struct is_constructible_string_type
{
    // launder type through decltype() to fix compilation failure on ICPC
#ifdef __INTEL_COMPILER
    using laundered_type = decltype(std::declval<ConstructibleStringType>());
#else
    using laundered_type = ConstructibleStringType;
#endif

    static constexpr auto value =
        conjunction <
        is_constructible<laundered_type, typename BasicJsonType::string_t>,
        is_detected_exact<typename BasicJsonType::string_t::value_type,
        value_type_t, laundered_type >>::value;
};

template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
struct is_compatible_array_type_impl : std::false_type {};

template<typename BasicJsonType, typename CompatibleArrayType>
struct is_compatible_array_type_impl <
    BasicJsonType, CompatibleArrayType,
    enable_if_t <
    is_detected<iterator_t, CompatibleArrayType>::value&&
    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
// special case for types like std::filesystem::path whose iterator's value_type are themselves
// c.f. https://github.com/nlohmann/json/pull/3073
    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
{
    static constexpr bool value =
        is_constructible<BasicJsonType,
        range_value_t<CompatibleArrayType>>::value;
};

template<typename BasicJsonType, typename CompatibleArrayType>
struct is_compatible_array_type
    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};

template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
struct is_constructible_array_type_impl : std::false_type {};

template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type_impl <
    BasicJsonType, ConstructibleArrayType,
    enable_if_t<std::is_same<ConstructibleArrayType,
    typename BasicJsonType::value_type>::value >>
            : std::true_type {};

template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type_impl <
    BasicJsonType, ConstructibleArrayType,
    enable_if_t < !std::is_same<ConstructibleArrayType,
    typename BasicJsonType::value_type>::value&&
    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
    is_default_constructible<ConstructibleArrayType>::value&&
(std::is_move_assignable<ConstructibleArrayType>::value ||
 std::is_copy_assignable<ConstructibleArrayType>::value)&&
is_detected<iterator_t, ConstructibleArrayType>::value&&
is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
is_detected<range_value_t, ConstructibleArrayType>::value&&
// special case for types like std::filesystem::path whose iterator's value_type are themselves
// c.f. https://github.com/nlohmann/json/pull/3073
!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
        is_complete_type <
        detected_t<range_value_t, ConstructibleArrayType >>::value >>
{
    using value_type = range_value_t<ConstructibleArrayType>;

    static constexpr bool value =
        std::is_same<value_type,
        typename BasicJsonType::array_t::value_type>::value ||
        has_from_json<BasicJsonType,
        value_type>::value ||
        has_non_default_from_json <
        BasicJsonType,
        value_type >::value;
};

template<typename BasicJsonType, typename ConstructibleArrayType>
struct is_constructible_array_type
    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};

template<typename RealIntegerType, typename CompatibleNumberIntegerType,
         typename = void>
struct is_compatible_integer_type_impl : std::false_type {};

template<typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type_impl <
    RealIntegerType, CompatibleNumberIntegerType,
    enable_if_t < std::is_integral<RealIntegerType>::value&&
    std::is_integral<CompatibleNumberIntegerType>::value&&
    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
{
    // is there an assert somewhere on overflows?
    using RealLimits = std::numeric_limits<RealIntegerType>;
    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;

    static constexpr auto value =
        is_constructible<RealIntegerType,
        CompatibleNumberIntegerType>::value &&
        CompatibleLimits::is_integer &&
        RealLimits::is_signed == CompatibleLimits::is_signed;
};

template<typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type
    : is_compatible_integer_type_impl<RealIntegerType,
      CompatibleNumberIntegerType> {};

template<typename BasicJsonType, typename CompatibleType, typename = void>
struct is_compatible_type_impl: std::false_type {};

template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type_impl <
    BasicJsonType, CompatibleType,
    enable_if_t<is_complete_type<CompatibleType>::value >>
{
    static constexpr bool value =
        has_to_json<BasicJsonType, CompatibleType>::value;
};

template<typename BasicJsonType, typename CompatibleType>
struct is_compatible_type
    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};

template<typename T1, typename T2>
struct is_constructible_tuple : std::false_type {};

template<typename T1, typename... Args>
struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};

template<typename BasicJsonType, typename T>
struct is_json_iterator_of : std::false_type {};

template<typename BasicJsonType>
struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};

template<typename BasicJsonType>
struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
{};

// checks if a given type T is a template specialization of Primary
template<template <typename...> class Primary, typename T>
struct is_specialization_of : std::false_type {};

template<template <typename...> class Primary, typename... Args>
struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};

template<typename T>
using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;

// checks if A and B are comparable using Compare functor
template<typename Compare, typename A, typename B, typename = void>
struct is_comparable : std::false_type {};

template<typename Compare, typename A, typename B>
struct is_comparable<Compare, A, B, void_t<
decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
>> : std::true_type {};

template<typename T>
using detect_is_transparent = typename T::is_transparent;

// type trait to check if KeyType can be used as object key (without a BasicJsonType)
// see is_usable_as_basic_json_key_type below
template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
using is_usable_as_key_type = typename std::conditional <
                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
                                   ObjectKeyType>::value)
                              && (!RequireTransparentComparator
                                  || is_detected <detect_is_transparent, Comparator>::value)
                              && !is_json_pointer<KeyType>::value,
                              std::true_type,
                              std::false_type >::type;

// type trait to check if KeyType can be used as object key
// true if:
//   - KeyType is comparable with BasicJsonType::object_t::key_type
//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
//   - the comparator is transparent or RequireTransparentComparator is false
//   - KeyType is not a JSON iterator or json_pointer
template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
using is_usable_as_basic_json_key_type = typename std::conditional <
        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
        RequireTransparentComparator, ExcludeObjectKeyType>::value
        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
        std::true_type,
        std::false_type >::type;

template<typename ObjectType, typename KeyType>
using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));

// type trait to check if object_t has an erase() member functions accepting KeyType
template<typename BasicJsonType, typename KeyType>
using has_erase_with_key_type = typename std::conditional <
                                is_detected <
                                detect_erase_with_key_type,
                                typename BasicJsonType::object_t, KeyType >::value,
                                std::true_type,
                                std::false_type >::type;

// a naive helper to check if a type is an ordered_map (exploits the fact that
// ordered_map inherits capacity() from std::vector)
template <typename T>
struct is_ordered_map
{
    using one = char;

    struct two
    {
        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
    };

    template <typename C> static one test( decltype(&C::capacity) ) ;
    template <typename C> static two test(...);

    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
};

// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
T conditional_static_cast(U value)
{
    return static_cast<T>(value);
}

template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
T conditional_static_cast(U value)
{
    return value;
}

template<typename... Types>
using all_integral = conjunction<std::is_integral<Types>...>;

template<typename... Types>
using all_signed = conjunction<std::is_signed<Types>...>;

template<typename... Types>
using all_unsigned = conjunction<std::is_unsigned<Types>...>;

// there's a disjunction trait in another PR; replace when merged
template<typename... Types>
using same_sign = std::integral_constant < bool,
      all_signed<Types...>::value || all_unsigned<Types...>::value >;

template<typename OfType, typename T>
using never_out_of_range = std::integral_constant < bool,
      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;

template<typename OfType, typename T,
         bool OfTypeSigned = std::is_signed<OfType>::value,
         bool TSigned = std::is_signed<T>::value>
struct value_in_range_of_impl2;

template<typename OfType, typename T>
struct value_in_range_of_impl2<OfType, T, false, false>
{
    static constexpr bool test(T val)
    {
        using CommonType = typename std::common_type<OfType, T>::type;
        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
    }
};

template<typename OfType, typename T>
struct value_in_range_of_impl2<OfType, T, true, false>
{
    static constexpr bool test(T val)
    {
        using CommonType = typename std::common_type<OfType, T>::type;
        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
    }
};

template<typename OfType, typename T>
struct value_in_range_of_impl2<OfType, T, false, true>
{
    static constexpr bool test(T val)
    {
        using CommonType = typename std::common_type<OfType, T>::type;
        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
    }
};

template<typename OfType, typename T>
struct value_in_range_of_impl2<OfType, T, true, true>
{
    static constexpr bool test(T val)
    {
        using CommonType = typename std::common_type<OfType, T>::type;
        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
    }
};

template<typename OfType, typename T,
         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
struct value_in_range_of_impl1;

template<typename OfType, typename T>
struct value_in_range_of_impl1<OfType, T, false>
{
    static constexpr bool test(T val)
    {
        return value_in_range_of_impl2<OfType, T>::test(val);
    }
};

template<typename OfType, typename T>
struct value_in_range_of_impl1<OfType, T, true>
{
    static constexpr bool test(T /*val*/)
    {
        return true;
    }
};

template<typename OfType, typename T>
inline constexpr bool value_in_range_of(T val)
{
    return value_in_range_of_impl1<OfType, T>::test(val);
}

template<bool Value>
using bool_constant = std::integral_constant<bool, Value>;

///////////////////////////////////////////////////////////////////////////////
// is_c_string
///////////////////////////////////////////////////////////////////////////////

namespace impl
{

template<typename T>
inline constexpr bool is_c_string()
{
    using TUnExt = typename std::remove_extent<T>::type;
    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
    using TUnPtr = typename std::remove_pointer<T>::type;
    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
    return
        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
}

}  // namespace impl

// checks whether T is a [cv] char */[cv] char[] C string
template<typename T>
struct is_c_string : bool_constant<impl::is_c_string<T>()> {};

template<typename T>
using is_c_string_uncvref = is_c_string<uncvref_t<T>>;

///////////////////////////////////////////////////////////////////////////////
// is_transparent
///////////////////////////////////////////////////////////////////////////////

namespace impl
{

template<typename T>
inline constexpr bool is_transparent()
{
    return is_detected<detect_is_transparent, T>::value;
}

}  // namespace impl

// checks whether T has a member named is_transparent
template<typename T>
struct is_transparent : bool_constant<impl::is_transparent<T>()> {};

///////////////////////////////////////////////////////////////////////////////

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/string_concat.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstring> // strlen
#include <string> // string
#include <utility> // forward

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/detected.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

inline std::size_t concat_length()
{
    return 0;
}

template<typename... Args>
inline std::size_t concat_length(const char* cstr, const Args& ... rest);

template<typename StringType, typename... Args>
inline std::size_t concat_length(const StringType& str, const Args& ... rest);

template<typename... Args>
inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
{
    return 1 + concat_length(rest...);
}

template<typename... Args>
inline std::size_t concat_length(const char* cstr, const Args& ... rest)
{
    // cppcheck-suppress ignoredReturnValue
    return ::strlen(cstr) + concat_length(rest...);
}

template<typename StringType, typename... Args>
inline std::size_t concat_length(const StringType& str, const Args& ... rest)
{
    return str.size() + concat_length(rest...);
}

template<typename OutStringType>
inline void concat_into(OutStringType& /*out*/)
{}

template<typename StringType, typename Arg>
using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));

template<typename StringType, typename Arg>
using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;

template<typename StringType, typename Arg>
using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());

template<typename StringType, typename Arg>
using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;

template<typename StringType, typename Arg>
using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));

template<typename StringType, typename Arg>
using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;

template<typename StringType, typename Arg>
using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));

template<typename StringType, typename Arg>
using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;

template < typename OutStringType, typename Arg, typename... Args,
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);

template < typename OutStringType, typename Arg, typename... Args,
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
                         && !detect_string_can_append_op<OutStringType, Arg>::value
                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);

template < typename OutStringType, typename Arg, typename... Args,
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
                         && !detect_string_can_append_op<OutStringType, Arg>::value
                         && !detect_string_can_append_iter<OutStringType, Arg>::value
                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);

template<typename OutStringType, typename Arg, typename... Args,
         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
{
    out.append(std::forward<Arg>(arg));
    concat_into(out, std::forward<Args>(rest)...);
}

template < typename OutStringType, typename Arg, typename... Args,
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
{
    out += std::forward<Arg>(arg);
    concat_into(out, std::forward<Args>(rest)...);
}

template < typename OutStringType, typename Arg, typename... Args,
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
                         && !detect_string_can_append_op<OutStringType, Arg>::value
                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
{
    out.append(arg.begin(), arg.end());
    concat_into(out, std::forward<Args>(rest)...);
}

template < typename OutStringType, typename Arg, typename... Args,
           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
                         && !detect_string_can_append_op<OutStringType, Arg>::value
                         && !detect_string_can_append_iter<OutStringType, Arg>::value
                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
{
    out.append(arg.data(), arg.size());
    concat_into(out, std::forward<Args>(rest)...);
}

template<typename OutStringType = std::string, typename... Args>
inline OutStringType concat(Args && ... args)
{
    OutStringType str;
    str.reserve(concat_length(args...));
    concat_into(str, std::forward<Args>(args)...);
    return str;
}

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

////////////////
// exceptions //
////////////////

/// @brief general exception of the @ref basic_json class
/// @sa https://json.nlohmann.me/api/basic_json/exception/
class exception : public std::exception
{
  public:
    /// returns the explanatory string
    const char* what() const noexcept override
    {
        return m.what();
    }

    /// the id of the exception
    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)

  protected:
    JSON_HEDLEY_NON_NULL(3)
    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)

    static std::string name(const std::string& ename, int id_)
    {
        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
    }

    static std::string diagnostics(std::nullptr_t /*leaf_element*/)
    {
        return "";
    }

    template<typename BasicJsonType>
    static std::string diagnostics(const BasicJsonType* leaf_element)
    {
#if JSON_DIAGNOSTICS
        std::vector<std::string> tokens;
        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
        {
            switch (current->m_parent->type())
            {
                case value_t::array:
                {
                    for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
                    {
                        if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
                        {
                            tokens.emplace_back(std::to_string(i));
                            break;
                        }
                    }
                    break;
                }

                case value_t::object:
                {
                    for (const auto& element : *current->m_parent->m_data.m_value.object)
                    {
                        if (&element.second == current)
                        {
                            tokens.emplace_back(element.first.c_str());
                            break;
                        }
                    }
                    break;
                }

                case value_t::null: // LCOV_EXCL_LINE
                case value_t::string: // LCOV_EXCL_LINE
                case value_t::boolean: // LCOV_EXCL_LINE
                case value_t::number_integer: // LCOV_EXCL_LINE
                case value_t::number_unsigned: // LCOV_EXCL_LINE
                case value_t::number_float: // LCOV_EXCL_LINE
                case value_t::binary: // LCOV_EXCL_LINE
                case value_t::discarded: // LCOV_EXCL_LINE
                default:   // LCOV_EXCL_LINE
                    break; // LCOV_EXCL_LINE
            }
        }

        if (tokens.empty())
        {
            return "";
        }

        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
                                   [](const std::string & a, const std::string & b)
        {
            return concat(a, '/', detail::escape(b));
        });
        return concat('(', str, ") ");
#else
        static_cast<void>(leaf_element);
        return "";
#endif
    }

  private:
    /// an exception object as storage for error messages
    std::runtime_error m;
};

/// @brief exception indicating a parse error
/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
class parse_error : public exception
{
  public:
    /*!
    @brief create a parse error exception
    @param[in] id_       the id of the exception
    @param[in] pos       the position where the error occurred (or with
                         chars_read_total=0 if the position cannot be
                         determined)
    @param[in] what_arg  the explanatory string
    @return parse_error object
    */
    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
    {
        const std::string w = concat(exception::name("parse_error", id_), "parse error",
                                     position_string(pos), ": ", exception::diagnostics(context), what_arg);
        return {id_, pos.chars_read_total, w.c_str()};
    }

    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
    {
        const std::string w = concat(exception::name("parse_error", id_), "parse error",
                                     (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
                                     ": ", exception::diagnostics(context), what_arg);
        return {id_, byte_, w.c_str()};
    }

    /*!
    @brief byte index of the parse error

    The byte index of the last read character in the input file.

    @note For an input with n bytes, 1 is the index of the first character and
          n+1 is the index of the terminating null byte or the end of file.
          This also holds true when reading a byte vector (CBOR or MessagePack).
    */
    const std::size_t byte;

  private:
    parse_error(int id_, std::size_t byte_, const char* what_arg)
        : exception(id_, what_arg), byte(byte_) {}

    static std::string position_string(const position_t& pos)
    {
        return concat(" at line ", std::to_string(pos.lines_read + 1),
                      ", column ", std::to_string(pos.chars_read_current_line));
    }
};

/// @brief exception indicating errors with iterators
/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
class invalid_iterator : public exception
{
  public:
    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
    {
        const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
        return {id_, w.c_str()};
    }

  private:
    JSON_HEDLEY_NON_NULL(3)
    invalid_iterator(int id_, const char* what_arg)
        : exception(id_, what_arg) {}
};

/// @brief exception indicating executing a member function with a wrong type
/// @sa https://json.nlohmann.me/api/basic_json/type_error/
class type_error : public exception
{
  public:
    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
    {
        const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
        return {id_, w.c_str()};
    }

  private:
    JSON_HEDLEY_NON_NULL(3)
    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
};

/// @brief exception indicating access out of the defined range
/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
class out_of_range : public exception
{
  public:
    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
    {
        const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
        return {id_, w.c_str()};
    }

  private:
    JSON_HEDLEY_NON_NULL(3)
    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
};

/// @brief exception indicating other library errors
/// @sa https://json.nlohmann.me/api/basic_json/other_error/
class other_error : public exception
{
  public:
    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
    {
        const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
        return {id_, w.c_str()};
    }

  private:
    JSON_HEDLEY_NON_NULL(3)
    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/identity_tag.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// #include <nlohmann/detail/abi_macros.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

// dispatching helper struct
template <class T> struct identity_tag {};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/meta/std_fs.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// #include <nlohmann/detail/macro_scope.hpp>


#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
#include <experimental/filesystem>
NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{
namespace std_fs = std::experimental::filesystem;
}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END
#elif JSON_HAS_FILESYSTEM
#include <filesystem>
NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{
namespace std_fs = std::filesystem;
}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END
#endif

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/string_concat.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
    {
        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
    }
    n = nullptr;
}

// overloads for basic_json template parameters
template < typename BasicJsonType, typename ArithmeticType,
           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
                         int > = 0 >
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
    switch (static_cast<value_t>(j))
    {
        case value_t::number_unsigned:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
            break;
        }
        case value_t::number_integer:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
            break;
        }
        case value_t::number_float:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
            break;
        }

        case value_t::null:
        case value_t::object:
        case value_t::array:
        case value_t::string:
        case value_t::boolean:
        case value_t::binary:
        case value_t::discarded:
        default:
            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
    }
}

template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
    {
        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
    }
    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
}

template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
    {
        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
    }
    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
}

template <
    typename BasicJsonType, typename StringType,
    enable_if_t <
        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
        && !is_json_ref<StringType>::value, int > = 0 >
inline void from_json(const BasicJsonType& j, StringType& s)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
    {
        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
    }

    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
}

template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
{
    get_arithmetic_value(j, val);
}

template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
{
    get_arithmetic_value(j, val);
}

template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
{
    get_arithmetic_value(j, val);
}

#if !JSON_DISABLE_ENUM_SERIALIZATION
template<typename BasicJsonType, typename EnumType,
         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
inline void from_json(const BasicJsonType& j, EnumType& e)
{
    typename std::underlying_type<EnumType>::type val;
    get_arithmetic_value(j, val);
    e = static_cast<EnumType>(val);
}
#endif  // JSON_DISABLE_ENUM_SERIALIZATION

// forward_list doesn't have an insert method
template<typename BasicJsonType, typename T, typename Allocator,
         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }
    l.clear();
    std::transform(j.rbegin(), j.rend(),
                   std::front_inserter(l), [](const BasicJsonType & i)
    {
        return i.template get<T>();
    });
}

// valarray doesn't have an insert method
template<typename BasicJsonType, typename T,
         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }
    l.resize(j.size());
    std::transform(j.begin(), j.end(), std::begin(l),
                   [](const BasicJsonType & elem)
    {
        return elem.template get<T>();
    });
}

template<typename BasicJsonType, typename T, std::size_t N>
auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-> decltype(j.template get<T>(), void())
{
    for (std::size_t i = 0; i < N; ++i)
    {
        arr[i] = j.at(i).template get<T>();
    }
}

template<typename BasicJsonType>
inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
{
    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
}

template<typename BasicJsonType, typename T, std::size_t N>
auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
                          priority_tag<2> /*unused*/)
-> decltype(j.template get<T>(), void())
{
    for (std::size_t i = 0; i < N; ++i)
    {
        arr[i] = j.at(i).template get<T>();
    }
}

template<typename BasicJsonType, typename ConstructibleArrayType,
         enable_if_t<
             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
             int> = 0>
auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
-> decltype(
    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
    j.template get<typename ConstructibleArrayType::value_type>(),
    void())
{
    using std::end;

    ConstructibleArrayType ret;
    ret.reserve(j.size());
    std::transform(j.begin(), j.end(),
                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
    {
        // get<BasicJsonType>() returns *this, this won't call a from_json
        // method when value_type is BasicJsonType
        return i.template get<typename ConstructibleArrayType::value_type>();
    });
    arr = std::move(ret);
}

template<typename BasicJsonType, typename ConstructibleArrayType,
         enable_if_t<
             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
             int> = 0>
inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
                                 priority_tag<0> /*unused*/)
{
    using std::end;

    ConstructibleArrayType ret;
    std::transform(
        j.begin(), j.end(), std::inserter(ret, end(ret)),
        [](const BasicJsonType & i)
    {
        // get<BasicJsonType>() returns *this, this won't call a from_json
        // method when value_type is BasicJsonType
        return i.template get<typename ConstructibleArrayType::value_type>();
    });
    arr = std::move(ret);
}

template < typename BasicJsonType, typename ConstructibleArrayType,
           enable_if_t <
               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
               !is_basic_json<ConstructibleArrayType>::value,
               int > = 0 >
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

    from_json_array_impl(j, arr, priority_tag<3> {});
}

template < typename BasicJsonType, typename T, std::size_t... Idx >
std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
{
    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
}

template < typename BasicJsonType, typename T, std::size_t N >
auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
}

template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
    {
        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
    }

    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
}

template<typename BasicJsonType, typename ConstructibleObjectType,
         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
    {
        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
    }

    ConstructibleObjectType ret;
    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
    using value_type = typename ConstructibleObjectType::value_type;
    std::transform(
        inner_object->begin(), inner_object->end(),
        std::inserter(ret, ret.begin()),
        [](typename BasicJsonType::object_t::value_type const & p)
    {
        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
    });
    obj = std::move(ret);
}

// overload for arithmetic types, not chosen for basic_json template arguments
// (BooleanType, etc..); note: Is it really necessary to provide explicit
// overloads for boolean_t etc. in case of a custom BooleanType which is not
// an arithmetic type?
template < typename BasicJsonType, typename ArithmeticType,
           enable_if_t <
               std::is_arithmetic<ArithmeticType>::value&&
               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
               int > = 0 >
inline void from_json(const BasicJsonType& j, ArithmeticType& val)
{
    switch (static_cast<value_t>(j))
    {
        case value_t::number_unsigned:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
            break;
        }
        case value_t::number_integer:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
            break;
        }
        case value_t::number_float:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
            break;
        }
        case value_t::boolean:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
            break;
        }

        case value_t::null:
        case value_t::object:
        case value_t::array:
        case value_t::string:
        case value_t::binary:
        case value_t::discarded:
        default:
            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
    }
}

template<typename BasicJsonType, typename... Args, std::size_t... Idx>
std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
{
    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
}

template < typename BasicJsonType, class A1, class A2 >
std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
{
    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
}

template<typename BasicJsonType, typename A1, typename A2>
inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
{
    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
}

template<typename BasicJsonType, typename... Args>
std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
{
    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
}

template<typename BasicJsonType, typename... Args>
inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
{
    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
}

template<typename BasicJsonType, typename TupleRelated>
auto from_json(BasicJsonType&& j, TupleRelated&& t)
-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
}

template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
           typename = enable_if_t < !std::is_constructible <
                                        typename BasicJsonType::string_t, Key >::value >>
inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }
    m.clear();
    for (const auto& p : j)
    {
        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
        {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
        }
        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
    }
}

template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
           typename = enable_if_t < !std::is_constructible <
                                        typename BasicJsonType::string_t, Key >::value >>
inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }
    m.clear();
    for (const auto& p : j)
    {
        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
        {
            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
        }
        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
    }
}

#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
template<typename BasicJsonType>
inline void from_json(const BasicJsonType& j, std_fs::path& p)
{
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
    {
        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
    }
    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
}
#endif

struct from_json_fn
{
    template<typename BasicJsonType, typename T>
    auto operator()(const BasicJsonType& j, T&& val) const
    noexcept(noexcept(from_json(j, std::forward<T>(val))))
    -> decltype(from_json(j, std::forward<T>(val)))
    {
        return from_json(j, std::forward<T>(val));
    }
};

}  // namespace detail

#ifndef JSON_HAS_CPP_17
/// namespace to hold default `from_json` function
/// to see why this is required:
/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
{
#endif
JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
    detail::static_const<detail::from_json_fn>::value;
#ifndef JSON_HAS_CPP_17
}  // namespace
#endif

NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/conversions/to_json.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <algorithm> // copy
#include <iterator> // begin, end
#include <string> // string
#include <tuple> // tuple, get
#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
#include <utility> // move, forward, declval, pair
#include <valarray> // valarray
#include <vector> // vector

// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstddef> // size_t
#include <iterator> // input_iterator_tag
#include <string> // string, to_string
#include <tuple> // tuple_size, get, tuple_element
#include <utility> // move

#if JSON_HAS_RANGES
    #include <ranges> // enable_borrowed_range
#endif

// #include <nlohmann/detail/abi_macros.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

template<typename string_type>
void int_to_string( string_type& target, std::size_t value )
{
    // For ADL
    using std::to_string;
    target = to_string(value);
}
template<typename IteratorType> class iteration_proxy_value
{
  public:
    using difference_type = std::ptrdiff_t;
    using value_type = iteration_proxy_value;
    using pointer = value_type *;
    using reference = value_type &;
    using iterator_category = std::input_iterator_tag;
    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;

  private:
    /// the iterator
    IteratorType anchor{};
    /// an index for arrays (used to create key names)
    std::size_t array_index = 0;
    /// last stringified array index
    mutable std::size_t array_index_last = 0;
    /// a string representation of the array index
    mutable string_type array_index_str = "0";
    /// an empty string (to return a reference for primitive values)
    string_type empty_str{};

  public:
    explicit iteration_proxy_value() = default;
    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
             && std::is_nothrow_default_constructible<string_type>::value)
        : anchor(std::move(it))
        , array_index(array_index_)
    {}

    iteration_proxy_value(iteration_proxy_value const&) = default;
    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
    iteration_proxy_value(iteration_proxy_value&&)
    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
    iteration_proxy_value& operator=(iteration_proxy_value&&)
    noexcept(std::is_nothrow_move_assignable<IteratorType>::value
             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
    ~iteration_proxy_value() = default;

    /// dereference operator (needed for range-based for)
    const iteration_proxy_value& operator*() const
    {
        return *this;
    }

    /// increment operator (needed for range-based for)
    iteration_proxy_value& operator++()
    {
        ++anchor;
        ++array_index;

        return *this;
    }

    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
    {
        auto tmp = iteration_proxy_value(anchor, array_index);
        ++anchor;
        ++array_index;
        return tmp;
    }

    /// equality operator (needed for InputIterator)
    bool operator==(const iteration_proxy_value& o) const
    {
        return anchor == o.anchor;
    }

    /// inequality operator (needed for range-based for)
    bool operator!=(const iteration_proxy_value& o) const
    {
        return anchor != o.anchor;
    }

    /// return key of the iterator
    const string_type& key() const
    {
        JSON_ASSERT(anchor.m_object != nullptr);

        switch (anchor.m_object->type())
        {
            // use integer array index as key
            case value_t::array:
            {
                if (array_index != array_index_last)
                {
                    int_to_string( array_index_str, array_index );
                    array_index_last = array_index;
                }
                return array_index_str;
            }

            // use key from the object
            case value_t::object:
                return anchor.key();

            // use an empty key for all primitive types
            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
                return empty_str;
        }
    }

    /// return value of the iterator
    typename IteratorType::reference value() const
    {
        return anchor.value();
    }
};

/// proxy class for the items() function
template<typename IteratorType> class iteration_proxy
{
  private:
    /// the container to iterate
    typename IteratorType::pointer container = nullptr;

  public:
    explicit iteration_proxy() = default;

    /// construct iteration proxy from a container
    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
        : container(&cont) {}

    iteration_proxy(iteration_proxy const&) = default;
    iteration_proxy& operator=(iteration_proxy const&) = default;
    iteration_proxy(iteration_proxy&&) noexcept = default;
    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
    ~iteration_proxy() = default;

    /// return iterator begin (needed for range-based for)
    iteration_proxy_value<IteratorType> begin() const noexcept
    {
        return iteration_proxy_value<IteratorType>(container->begin());
    }

    /// return iterator end (needed for range-based for)
    iteration_proxy_value<IteratorType> end() const noexcept
    {
        return iteration_proxy_value<IteratorType>(container->end());
    }
};

// Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391
template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
{
    return i.key();
}
// Structured Bindings Support
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391
template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
{
    return i.value();
}

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// The Addition to the STD Namespace is required to add
// Structured Bindings Support to the iteration_proxy_value class
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
// And see https://github.com/nlohmann/json/pull/1391
namespace std
{

#if defined(__clang__)
    // Fix: https://github.com/nlohmann/json/issues/1401
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wmismatched-tags"
#endif
template<typename IteratorType>
class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
            : public std::integral_constant<std::size_t, 2> {};

template<std::size_t N, typename IteratorType>
class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
{
  public:
    using type = decltype(
                     get<N>(std::declval <
                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
};
#if defined(__clang__)
    #pragma clang diagnostic pop
#endif

}  // namespace std

#if JSON_HAS_RANGES
    template <typename IteratorType>
    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
#endif

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/std_fs.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

//////////////////
// constructors //
//////////////////

/*
 * Note all external_constructor<>::construct functions need to call
 * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
 * allocated value (e.g., a string). See bug issue
 * https://github.com/nlohmann/json/issues/2865 for more information.
 */

template<value_t> struct external_constructor;

template<>
struct external_constructor<value_t::boolean>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::boolean;
        j.m_data.m_value = b;
        j.assert_invariant();
    }
};

template<>
struct external_constructor<value_t::string>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
        j.m_data.m_value = s;
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
        j.m_data.m_value = std::move(s);
        j.assert_invariant();
    }

    template < typename BasicJsonType, typename CompatibleStringType,
               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
                             int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleStringType& str)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
        j.assert_invariant();
    }
};

template<>
struct external_constructor<value_t::binary>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
        j.m_data.m_value = typename BasicJsonType::binary_t(b);
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
        j.assert_invariant();
    }
};

template<>
struct external_constructor<value_t::number_float>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_float;
        j.m_data.m_value = val;
        j.assert_invariant();
    }
};

template<>
struct external_constructor<value_t::number_unsigned>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_unsigned;
        j.m_data.m_value = val;
        j.assert_invariant();
    }
};

template<>
struct external_constructor<value_t::number_integer>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_integer;
        j.m_data.m_value = val;
        j.assert_invariant();
    }
};

template<>
struct external_constructor<value_t::array>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
        j.m_data.m_value = arr;
        j.set_parents();
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
        j.m_data.m_value = std::move(arr);
        j.set_parents();
        j.assert_invariant();
    }

    template < typename BasicJsonType, typename CompatibleArrayType,
               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
                             int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
    {
        using std::begin;
        using std::end;

        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
        j.set_parents();
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
        j.m_data.m_value = value_t::array;
        j.m_data.m_value.array->reserve(arr.size());
        for (const bool x : arr)
        {
            j.m_data.m_value.array->push_back(x);
            j.set_parent(j.m_data.m_value.array->back());
        }
        j.assert_invariant();
    }

    template<typename BasicJsonType, typename T,
             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
        j.m_data.m_value = value_t::array;
        j.m_data.m_value.array->resize(arr.size());
        if (arr.size() > 0)
        {
            std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
        }
        j.set_parents();
        j.assert_invariant();
    }
};

template<>
struct external_constructor<value_t::object>
{
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
        j.m_data.m_value = obj;
        j.set_parents();
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
        j.m_data.m_value = std::move(obj);
        j.set_parents();
        j.assert_invariant();
    }

    template < typename BasicJsonType, typename CompatibleObjectType,
               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
    {
        using std::begin;
        using std::end;

        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
        j.set_parents();
        j.assert_invariant();
    }
};

/////////////
// to_json //
/////////////

template<typename BasicJsonType, typename T,
         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
inline void to_json(BasicJsonType& j, T b) noexcept
{
    external_constructor<value_t::boolean>::construct(j, b);
}

template < typename BasicJsonType, typename BoolRef,
           enable_if_t <
               ((std::is_same<std::vector<bool>::reference, BoolRef>::value
                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
                                      typename BasicJsonType::boolean_t >::value))
               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
{
    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
}

template<typename BasicJsonType, typename CompatibleString,
         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
inline void to_json(BasicJsonType& j, const CompatibleString& s)
{
    external_constructor<value_t::string>::construct(j, s);
}

template<typename BasicJsonType>
inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
{
    external_constructor<value_t::string>::construct(j, std::move(s));
}

template<typename BasicJsonType, typename FloatType,
         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
inline void to_json(BasicJsonType& j, FloatType val) noexcept
{
    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
}

template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
{
    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
}

template<typename BasicJsonType, typename CompatibleNumberIntegerType,
         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
{
    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
}

#if !JSON_DISABLE_ENUM_SERIALIZATION
template<typename BasicJsonType, typename EnumType,
         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
inline void to_json(BasicJsonType& j, EnumType e) noexcept
{
    using underlying_type = typename std::underlying_type<EnumType>::type;
    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
}
#endif  // JSON_DISABLE_ENUM_SERIALIZATION

template<typename BasicJsonType>
inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
{
    external_constructor<value_t::array>::construct(j, e);
}

template < typename BasicJsonType, typename CompatibleArrayType,
           enable_if_t < is_compatible_array_type<BasicJsonType,
                         CompatibleArrayType>::value&&
                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
                         !is_basic_json<CompatibleArrayType>::value,
                         int > = 0 >
inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
{
    external_constructor<value_t::array>::construct(j, arr);
}

template<typename BasicJsonType>
inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
{
    external_constructor<value_t::binary>::construct(j, bin);
}

template<typename BasicJsonType, typename T,
         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
{
    external_constructor<value_t::array>::construct(j, std::move(arr));
}

template<typename BasicJsonType>
inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
{
    external_constructor<value_t::array>::construct(j, std::move(arr));
}

template < typename BasicJsonType, typename CompatibleObjectType,
           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
{
    external_constructor<value_t::object>::construct(j, obj);
}

template<typename BasicJsonType>
inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
{
    external_constructor<value_t::object>::construct(j, std::move(obj));
}

template <
    typename BasicJsonType, typename T, std::size_t N,
    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
                  int > = 0 >
inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
{
    external_constructor<value_t::array>::construct(j, arr);
}

template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
{
    j = { p.first, p.second };
}

// for https://github.com/nlohmann/json/pull/1134
template<typename BasicJsonType, typename T,
         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
inline void to_json(BasicJsonType& j, const T& b)
{
    j = { {b.key(), b.value()} };
}

template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
{
    j = { std::get<Idx>(t)... };
}

template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
inline void to_json(BasicJsonType& j, const T& t)
{
    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
}

#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
template<typename BasicJsonType>
inline void to_json(BasicJsonType& j, const std_fs::path& p)
{
    j = p.string();
}
#endif

struct to_json_fn
{
    template<typename BasicJsonType, typename T>
    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
    -> decltype(to_json(j, std::forward<T>(val)), void())
    {
        return to_json(j, std::forward<T>(val));
    }
};
}  // namespace detail

#ifndef JSON_HAS_CPP_17
/// namespace to hold default `to_json` function
/// to see why this is required:
/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
{
#endif
JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
    detail::static_const<detail::to_json_fn>::value;
#ifndef JSON_HAS_CPP_17
}  // namespace
#endif

NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/meta/identity_tag.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN

/// @sa https://json.nlohmann.me/api/adl_serializer/
template<typename ValueType, typename>
struct adl_serializer
{
    /// @brief convert a JSON value to any value type
    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
    template<typename BasicJsonType, typename TargetType = ValueType>
    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
    {
        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
    }

    /// @brief convert a JSON value to any value type
    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
    template<typename BasicJsonType, typename TargetType = ValueType>
    static auto from_json(BasicJsonType && j) noexcept(
    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
    {
        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
    }

    /// @brief convert any value type to a JSON value
    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
    template<typename BasicJsonType, typename TargetType = ValueType>
    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
    {
        ::nlohmann::to_json(j, std::forward<TargetType>(val));
    }
};

NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/byte_container_with_subtype.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstdint> // uint8_t, uint64_t
#include <tuple> // tie
#include <utility> // move

// #include <nlohmann/detail/abi_macros.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN

/// @brief an internal type for a backed binary type
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
template<typename BinaryType>
class byte_container_with_subtype : public BinaryType
{
  public:
    using container_type = BinaryType;
    using subtype_type = std::uint64_t;

    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
    byte_container_with_subtype() noexcept(noexcept(container_type()))
        : container_type()
    {}

    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
        : container_type(b)
    {}

    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
        : container_type(std::move(b))
    {}

    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
        : container_type(b)
        , m_subtype(subtype_)
        , m_has_subtype(true)
    {}

    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
        : container_type(std::move(b))
        , m_subtype(subtype_)
        , m_has_subtype(true)
    {}

    bool operator==(const byte_container_with_subtype& rhs) const
    {
        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
    }

    bool operator!=(const byte_container_with_subtype& rhs) const
    {
        return !(rhs == *this);
    }

    /// @brief sets the binary subtype
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
    void set_subtype(subtype_type subtype_) noexcept
    {
        m_subtype = subtype_;
        m_has_subtype = true;
    }

    /// @brief return the binary subtype
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
    constexpr subtype_type subtype() const noexcept
    {
        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
    }

    /// @brief return whether the value has a subtype
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
    constexpr bool has_subtype() const noexcept
    {
        return m_has_subtype;
    }

    /// @brief clears the binary subtype
    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
    void clear_subtype() noexcept
    {
        m_subtype = 0;
        m_has_subtype = false;
    }

  private:
    subtype_type m_subtype = 0;
    bool m_has_subtype = false;
};

NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/conversions/from_json.hpp>

// #include <nlohmann/detail/conversions/to_json.hpp>

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/hash.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstdint> // uint8_t
#include <cstddef> // size_t
#include <functional> // hash

// #include <nlohmann/detail/abi_macros.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

// boost::hash_combine
inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
{
    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
    return seed;
}

/*!
@brief hash a JSON value

The hash function tries to rely on std::hash where possible. Furthermore, the
type of the JSON value is taken into account to have different hash values for
null, 0, 0U, and false, etc.

@tparam BasicJsonType basic_json specialization
@param j JSON value to hash
@return hash value of j
*/
template<typename BasicJsonType>
std::size_t hash(const BasicJsonType& j)
{
    using string_t = typename BasicJsonType::string_t;
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;

    const auto type = static_cast<std::size_t>(j.type());
    switch (j.type())
    {
        case BasicJsonType::value_t::null:
        case BasicJsonType::value_t::discarded:
        {
            return combine(type, 0);
        }

        case BasicJsonType::value_t::object:
        {
            auto seed = combine(type, j.size());
            for (const auto& element : j.items())
            {
                const auto h = std::hash<string_t> {}(element.key());
                seed = combine(seed, h);
                seed = combine(seed, hash(element.value()));
            }
            return seed;
        }

        case BasicJsonType::value_t::array:
        {
            auto seed = combine(type, j.size());
            for (const auto& element : j)
            {
                seed = combine(seed, hash(element));
            }
            return seed;
        }

        case BasicJsonType::value_t::string:
        {
            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
            return combine(type, h);
        }

        case BasicJsonType::value_t::boolean:
        {
            const auto h = std::hash<bool> {}(j.template get<bool>());
            return combine(type, h);
        }

        case BasicJsonType::value_t::number_integer:
        {
            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
            return combine(type, h);
        }

        case BasicJsonType::value_t::number_unsigned:
        {
            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
            return combine(type, h);
        }

        case BasicJsonType::value_t::number_float:
        {
            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
            return combine(type, h);
        }

        case BasicJsonType::value_t::binary:
        {
            auto seed = combine(type, j.get_binary().size());
            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
            seed = combine(seed, h);
            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
            for (const auto byte : j.get_binary())
            {
                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
            }
            return seed;
        }

        default:                   // LCOV_EXCL_LINE
            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
            return 0;              // LCOV_EXCL_LINE
    }
}

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/input/binary_reader.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <algorithm> // generate_n
#include <array> // array
#include <cmath> // ldexp
#include <cstddef> // size_t
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
#include <cstdio> // snprintf
#include <cstring> // memcpy
#include <iterator> // back_inserter
#include <limits> // numeric_limits
#include <string> // char_traits, string
#include <utility> // make_pair, move
#include <vector> // vector

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/input/input_adapters.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <array> // array
#include <cstddef> // size_t
#include <cstring> // strlen
#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
#include <memory> // shared_ptr, make_shared, addressof
#include <numeric> // accumulate
#include <string> // string, char_traits
#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
#include <utility> // pair, declval

#ifndef JSON_NO_IO
    #include <cstdio>   // FILE *
    #include <istream>  // istream
#endif                  // JSON_NO_IO

// #include <nlohmann/detail/iterators/iterator_traits.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/// the supported input formats
enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };

////////////////////
// input adapters //
////////////////////

#ifndef JSON_NO_IO
/*!
Input adapter for stdio file access. This adapter read only 1 byte and do not use any
 buffer. This adapter is a very low level adapter.
*/
class file_input_adapter
{
  public:
    using char_type = char;

    JSON_HEDLEY_NON_NULL(2)
    explicit file_input_adapter(std::FILE* f) noexcept
        : m_file(f)
    {
        JSON_ASSERT(m_file != nullptr);
    }

    // make class move-only
    file_input_adapter(const file_input_adapter&) = delete;
    file_input_adapter(file_input_adapter&&) noexcept = default;
    file_input_adapter& operator=(const file_input_adapter&) = delete;
    file_input_adapter& operator=(file_input_adapter&&) = delete;
    ~file_input_adapter() = default;

    std::char_traits<char>::int_type get_character() noexcept
    {
        return std::fgetc(m_file);
    }

  private:
    /// the file pointer to read from
    std::FILE* m_file;
};

/*!
Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
beginning of input. Does not support changing the underlying std::streambuf
in mid-input. Maintains underlying std::istream and std::streambuf to support
subsequent use of standard std::istream operations to process any input
characters following those used in parsing the JSON input.  Clears the
std::istream flags; any input errors (e.g., EOF) will be detected by the first
subsequent call for input from the std::istream.
*/
class input_stream_adapter
{
  public:
    using char_type = char;

    ~input_stream_adapter()
    {
        // clear stream flags; we use underlying streambuf I/O, do not
        // maintain ifstream flags, except eof
        if (is != nullptr)
        {
            is->clear(is->rdstate() & std::ios::eofbit);
        }
    }

    explicit input_stream_adapter(std::istream& i)
        : is(&i), sb(i.rdbuf())
    {}

    // delete because of pointer members
    input_stream_adapter(const input_stream_adapter&) = delete;
    input_stream_adapter& operator=(input_stream_adapter&) = delete;
    input_stream_adapter& operator=(input_stream_adapter&&) = delete;

    input_stream_adapter(input_stream_adapter&& rhs) noexcept
        : is(rhs.is), sb(rhs.sb)
    {
        rhs.is = nullptr;
        rhs.sb = nullptr;
    }

    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
    // end up as the same value, e.g. 0xFFFFFFFF.
    std::char_traits<char>::int_type get_character()
    {
        auto res = sb->sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
        {
            is->clear(is->rdstate() | std::ios::eofbit);
        }
        return res;
    }

  private:
    /// the associated input stream
    std::istream* is = nullptr;
    std::streambuf* sb = nullptr;
};
#endif  // JSON_NO_IO

// General-purpose iterator-based adapter. It might not be as fast as
// theoretically possible for some containers, but it is extremely versatile.
template<typename IteratorType>
class iterator_input_adapter
{
  public:
    using char_type = typename std::iterator_traits<IteratorType>::value_type;

    iterator_input_adapter(IteratorType first, IteratorType last)
        : current(std::move(first)), end(std::move(last))
    {}

    typename char_traits<char_type>::int_type get_character()
    {
        if (JSON_HEDLEY_LIKELY(current != end))
        {
            auto result = char_traits<char_type>::to_int_type(*current);
            std::advance(current, 1);
            return result;
        }

        return char_traits<char_type>::eof();
    }

  private:
    IteratorType current;
    IteratorType end;

    template<typename BaseInputAdapter, size_t T>
    friend struct wide_string_input_helper;

    bool empty() const
    {
        return current == end;
    }
};

template<typename BaseInputAdapter, size_t T>
struct wide_string_input_helper;

template<typename BaseInputAdapter>
struct wide_string_input_helper<BaseInputAdapter, 4>
{
    // UTF-32
    static void fill_buffer(BaseInputAdapter& input,
                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
                            size_t& utf8_bytes_index,
                            size_t& utf8_bytes_filled)
    {
        utf8_bytes_index = 0;

        if (JSON_HEDLEY_UNLIKELY(input.empty()))
        {
            utf8_bytes[0] = std::char_traits<char>::eof();
            utf8_bytes_filled = 1;
        }
        else
        {
            // get the current character
            const auto wc = input.get_character();

            // UTF-32 to UTF-8 encoding
            if (wc < 0x80)
            {
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                utf8_bytes_filled = 1;
            }
            else if (wc <= 0x7FF)
            {
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
                utf8_bytes_filled = 2;
            }
            else if (wc <= 0xFFFF)
            {
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
                utf8_bytes_filled = 3;
            }
            else if (wc <= 0x10FFFF)
            {
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
                utf8_bytes_filled = 4;
            }
            else
            {
                // unknown character
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                utf8_bytes_filled = 1;
            }
        }
    }
};

template<typename BaseInputAdapter>
struct wide_string_input_helper<BaseInputAdapter, 2>
{
    // UTF-16
    static void fill_buffer(BaseInputAdapter& input,
                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
                            size_t& utf8_bytes_index,
                            size_t& utf8_bytes_filled)
    {
        utf8_bytes_index = 0;

        if (JSON_HEDLEY_UNLIKELY(input.empty()))
        {
            utf8_bytes[0] = std::char_traits<char>::eof();
            utf8_bytes_filled = 1;
        }
        else
        {
            // get the current character
            const auto wc = input.get_character();

            // UTF-16 to UTF-8 encoding
            if (wc < 0x80)
            {
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                utf8_bytes_filled = 1;
            }
            else if (wc <= 0x7FF)
            {
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
                utf8_bytes_filled = 2;
            }
            else if (0xD800 > wc || wc >= 0xE000)
            {
                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
                utf8_bytes_filled = 3;
            }
            else
            {
                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
                {
                    const auto wc2 = static_cast<unsigned int>(input.get_character());
                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
                    utf8_bytes_filled = 4;
                }
                else
                {
                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                    utf8_bytes_filled = 1;
                }
            }
        }
    }
};

// Wraps another input adapter to convert wide character types into individual bytes.
template<typename BaseInputAdapter, typename WideCharType>
class wide_string_input_adapter
{
  public:
    using char_type = char;

    wide_string_input_adapter(BaseInputAdapter base)
        : base_adapter(base) {}

    typename std::char_traits<char>::int_type get_character() noexcept
    {
        // check if buffer needs to be filled
        if (utf8_bytes_index == utf8_bytes_filled)
        {
            fill_buffer<sizeof(WideCharType)>();

            JSON_ASSERT(utf8_bytes_filled > 0);
            JSON_ASSERT(utf8_bytes_index == 0);
        }

        // use buffer
        JSON_ASSERT(utf8_bytes_filled > 0);
        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
        return utf8_bytes[utf8_bytes_index++];
    }

  private:
    BaseInputAdapter base_adapter;

    template<size_t T>
    void fill_buffer()
    {
        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
    }

    /// a buffer for UTF-8 bytes
    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};

    /// index to the utf8_codes array for the next valid byte
    std::size_t utf8_bytes_index = 0;
    /// number of valid bytes in the utf8_codes array
    std::size_t utf8_bytes_filled = 0;
};

template<typename IteratorType, typename Enable = void>
struct iterator_input_adapter_factory
{
    using iterator_type = IteratorType;
    using char_type = typename std::iterator_traits<iterator_type>::value_type;
    using adapter_type = iterator_input_adapter<iterator_type>;

    static adapter_type create(IteratorType first, IteratorType last)
    {
        return adapter_type(std::move(first), std::move(last));
    }
};

template<typename T>
struct is_iterator_of_multibyte
{
    using value_type = typename std::iterator_traits<T>::value_type;
    enum
    {
        value = sizeof(value_type) > 1
    };
};

template<typename IteratorType>
struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
{
    using iterator_type = IteratorType;
    using char_type = typename std::iterator_traits<iterator_type>::value_type;
    using base_adapter_type = iterator_input_adapter<iterator_type>;
    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;

    static adapter_type create(IteratorType first, IteratorType last)
    {
        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
    }
};

// General purpose iterator-based input
template<typename IteratorType>
typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
{
    using factory_type = iterator_input_adapter_factory<IteratorType>;
    return factory_type::create(first, last);
}

// Convenience shorthand from container to iterator
// Enables ADL on begin(container) and end(container)
// Encloses the using declarations in namespace for not to leak them to outside scope

namespace container_input_adapter_factory_impl
{

using std::begin;
using std::end;

template<typename ContainerType, typename Enable = void>
struct container_input_adapter_factory {};

template<typename ContainerType>
struct container_input_adapter_factory< ContainerType,
       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
       {
           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));

           static adapter_type create(const ContainerType& container)
{
    return input_adapter(begin(container), end(container));
}
       };

}  // namespace container_input_adapter_factory_impl

template<typename ContainerType>
typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
{
    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
}

#ifndef JSON_NO_IO
// Special cases with fast paths
inline file_input_adapter input_adapter(std::FILE* file)
{
    return file_input_adapter(file);
}

inline input_stream_adapter input_adapter(std::istream& stream)
{
    return input_stream_adapter(stream);
}

inline input_stream_adapter input_adapter(std::istream&& stream)
{
    return input_stream_adapter(stream);
}
#endif  // JSON_NO_IO

using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));

// Null-delimited strings, and the like.
template < typename CharT,
           typename std::enable_if <
               std::is_pointer<CharT>::value&&
               !std::is_array<CharT>::value&&
               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
               sizeof(typename std::remove_pointer<CharT>::type) == 1,
               int >::type = 0 >
contiguous_bytes_input_adapter input_adapter(CharT b)
{
    auto length = std::strlen(reinterpret_cast<const char*>(b));
    const auto* ptr = reinterpret_cast<const char*>(b);
    return input_adapter(ptr, ptr + length);
}

template<typename T, std::size_t N>
auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
{
    return input_adapter(array, array + N);
}

// This class only handles inputs of input_buffer_adapter type.
// It's required so that expressions like {ptr, len} can be implicitly cast
// to the correct adapter.
class span_input_adapter
{
  public:
    template < typename CharT,
               typename std::enable_if <
                   std::is_pointer<CharT>::value&&
                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
                   int >::type = 0 >
    span_input_adapter(CharT b, std::size_t l)
        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}

    template<class IteratorType,
             typename std::enable_if<
                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
                 int>::type = 0>
    span_input_adapter(IteratorType first, IteratorType last)
        : ia(input_adapter(first, last)) {}

    contiguous_bytes_input_adapter&& get()
    {
        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
    }

  private:
    contiguous_bytes_input_adapter ia;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/input/json_sax.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstddef>
#include <string> // string
#include <utility> // move
#include <vector> // vector

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/string_concat.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN

/*!
@brief SAX interface

This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
Each function is called in different situations while the input is parsed. The
boolean return value informs the parser whether to continue processing the
input.
*/
template<typename BasicJsonType>
struct json_sax
{
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;

    /*!
    @brief a null value was read
    @return whether parsing should proceed
    */
    virtual bool null() = 0;

    /*!
    @brief a boolean value was read
    @param[in] val  boolean value
    @return whether parsing should proceed
    */
    virtual bool boolean(bool val) = 0;

    /*!
    @brief an integer number was read
    @param[in] val  integer value
    @return whether parsing should proceed
    */
    virtual bool number_integer(number_integer_t val) = 0;

    /*!
    @brief an unsigned integer number was read
    @param[in] val  unsigned integer value
    @return whether parsing should proceed
    */
    virtual bool number_unsigned(number_unsigned_t val) = 0;

    /*!
    @brief a floating-point number was read
    @param[in] val  floating-point value
    @param[in] s    raw token value
    @return whether parsing should proceed
    */
    virtual bool number_float(number_float_t val, const string_t& s) = 0;

    /*!
    @brief a string value was read
    @param[in] val  string value
    @return whether parsing should proceed
    @note It is safe to move the passed string value.
    */
    virtual bool string(string_t& val) = 0;

    /*!
    @brief a binary value was read
    @param[in] val  binary value
    @return whether parsing should proceed
    @note It is safe to move the passed binary value.
    */
    virtual bool binary(binary_t& val) = 0;

    /*!
    @brief the beginning of an object was read
    @param[in] elements  number of object elements or -1 if unknown
    @return whether parsing should proceed
    @note binary formats may report the number of elements
    */
    virtual bool start_object(std::size_t elements) = 0;

    /*!
    @brief an object key was read
    @param[in] val  object key
    @return whether parsing should proceed
    @note It is safe to move the passed string.
    */
    virtual bool key(string_t& val) = 0;

    /*!
    @brief the end of an object was read
    @return whether parsing should proceed
    */
    virtual bool end_object() = 0;

    /*!
    @brief the beginning of an array was read
    @param[in] elements  number of array elements or -1 if unknown
    @return whether parsing should proceed
    @note binary formats may report the number of elements
    */
    virtual bool start_array(std::size_t elements) = 0;

    /*!
    @brief the end of an array was read
    @return whether parsing should proceed
    */
    virtual bool end_array() = 0;

    /*!
    @brief a parse error occurred
    @param[in] position    the position in the input where the error occurs
    @param[in] last_token  the last read token
    @param[in] ex          an exception object describing the error
    @return whether parsing should proceed (must return false)
    */
    virtual bool parse_error(std::size_t position,
                             const std::string& last_token,
                             const detail::exception& ex) = 0;

    json_sax() = default;
    json_sax(const json_sax&) = default;
    json_sax(json_sax&&) noexcept = default;
    json_sax& operator=(const json_sax&) = default;
    json_sax& operator=(json_sax&&) noexcept = default;
    virtual ~json_sax() = default;
};

namespace detail
{
/*!
@brief SAX implementation to create a JSON value from SAX events

This class implements the @ref json_sax interface and processes the SAX events
to create a JSON value which makes it basically a DOM parser. The structure or
hierarchy of the JSON value is managed by the stack `ref_stack` which contains
a pointer to the respective array or object for each recursion depth.

After successful parsing, the value that is passed by reference to the
constructor contains the parsed value.

@tparam BasicJsonType  the JSON type
*/
template<typename BasicJsonType>
class json_sax_dom_parser
{
  public:
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;

    /*!
    @param[in,out] r  reference to a JSON value that is manipulated while
                       parsing
    @param[in] allow_exceptions_  whether parse errors yield exceptions
    */
    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
        : root(r), allow_exceptions(allow_exceptions_)
    {}

    // make class move-only
    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    ~json_sax_dom_parser() = default;

    bool null()
    {
        handle_value(nullptr);
        return true;
    }

    bool boolean(bool val)
    {
        handle_value(val);
        return true;
    }

    bool number_integer(number_integer_t val)
    {
        handle_value(val);
        return true;
    }

    bool number_unsigned(number_unsigned_t val)
    {
        handle_value(val);
        return true;
    }

    bool number_float(number_float_t val, const string_t& /*unused*/)
    {
        handle_value(val);
        return true;
    }

    bool string(string_t& val)
    {
        handle_value(val);
        return true;
    }

    bool binary(binary_t& val)
    {
        handle_value(std::move(val));
        return true;
    }

    bool start_object(std::size_t len)
    {
        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));

        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
    }

    bool key(string_t& val)
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_object());

        // add null at given key and store the reference for later
        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
        return true;
    }

    bool end_object()
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_object());

        ref_stack.back()->set_parents();
        ref_stack.pop_back();
        return true;
    }

    bool start_array(std::size_t len)
    {
        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));

        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
    }

    bool end_array()
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_array());

        ref_stack.back()->set_parents();
        ref_stack.pop_back();
        return true;
    }

    template<class Exception>
    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
                     const Exception& ex)
    {
        errored = true;
        static_cast<void>(ex);
        if (allow_exceptions)
        {
            JSON_THROW(ex);
        }
        return false;
    }

    constexpr bool is_errored() const
    {
        return errored;
    }

  private:
    /*!
    @invariant If the ref stack is empty, then the passed value will be the new
               root.
    @invariant If the ref stack contains a value, then it is an array or an
               object to which we can add elements
    */
    template<typename Value>
    JSON_HEDLEY_RETURNS_NON_NULL
    BasicJsonType* handle_value(Value&& v)
    {
        if (ref_stack.empty())
        {
            root = BasicJsonType(std::forward<Value>(v));
            return &root;
        }

        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());

        if (ref_stack.back()->is_array())
        {
            ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
            return &(ref_stack.back()->m_data.m_value.array->back());
        }

        JSON_ASSERT(ref_stack.back()->is_object());
        JSON_ASSERT(object_element);
        *object_element = BasicJsonType(std::forward<Value>(v));
        return object_element;
    }

    /// the parsed JSON value
    BasicJsonType& root;
    /// stack to model hierarchy of values
    std::vector<BasicJsonType*> ref_stack {};
    /// helper to hold the reference for the next object element
    BasicJsonType* object_element = nullptr;
    /// whether a syntax error occurred
    bool errored = false;
    /// whether to throw exceptions in case of errors
    const bool allow_exceptions = true;
};

template<typename BasicJsonType>
class json_sax_dom_callback_parser
{
  public:
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;
    using parser_callback_t = typename BasicJsonType::parser_callback_t;
    using parse_event_t = typename BasicJsonType::parse_event_t;

    json_sax_dom_callback_parser(BasicJsonType& r,
                                 const parser_callback_t cb,
                                 const bool allow_exceptions_ = true)
        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
    {
        keep_stack.push_back(true);
    }

    // make class move-only
    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    ~json_sax_dom_callback_parser() = default;

    bool null()
    {
        handle_value(nullptr);
        return true;
    }

    bool boolean(bool val)
    {
        handle_value(val);
        return true;
    }

    bool number_integer(number_integer_t val)
    {
        handle_value(val);
        return true;
    }

    bool number_unsigned(number_unsigned_t val)
    {
        handle_value(val);
        return true;
    }

    bool number_float(number_float_t val, const string_t& /*unused*/)
    {
        handle_value(val);
        return true;
    }

    bool string(string_t& val)
    {
        handle_value(val);
        return true;
    }

    bool binary(binary_t& val)
    {
        handle_value(std::move(val));
        return true;
    }

    bool start_object(std::size_t len)
    {
        // check callback for object start
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
        keep_stack.push_back(keep);

        auto val = handle_value(BasicJsonType::value_t::object, true);
        ref_stack.push_back(val.second);

        // check object limit
        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
    }

    bool key(string_t& val)
    {
        BasicJsonType k = BasicJsonType(val);

        // check callback for key
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
        key_keep_stack.push_back(keep);

        // add discarded value at given key and store the reference for later
        if (keep && ref_stack.back())
        {
            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
        }

        return true;
    }

    bool end_object()
    {
        if (ref_stack.back())
        {
            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
            {
                // discard object
                *ref_stack.back() = discarded;
            }
            else
            {
                ref_stack.back()->set_parents();
            }
        }

        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(!keep_stack.empty());
        ref_stack.pop_back();
        keep_stack.pop_back();

        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
        {
            // remove discarded value
            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
            {
                if (it->is_discarded())
                {
                    ref_stack.back()->erase(it);
                    break;
                }
            }
        }

        return true;
    }

    bool start_array(std::size_t len)
    {
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
        keep_stack.push_back(keep);

        auto val = handle_value(BasicJsonType::value_t::array, true);
        ref_stack.push_back(val.second);

        // check array limit
        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
        {
            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
    }

    bool end_array()
    {
        bool keep = true;

        if (ref_stack.back())
        {
            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
            if (keep)
            {
                ref_stack.back()->set_parents();
            }
            else
            {
                // discard array
                *ref_stack.back() = discarded;
            }
        }

        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(!keep_stack.empty());
        ref_stack.pop_back();
        keep_stack.pop_back();

        // remove discarded value
        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
        {
            ref_stack.back()->m_data.m_value.array->pop_back();
        }

        return true;
    }

    template<class Exception>
    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
                     const Exception& ex)
    {
        errored = true;
        static_cast<void>(ex);
        if (allow_exceptions)
        {
            JSON_THROW(ex);
        }
        return false;
    }

    constexpr bool is_errored() const
    {
        return errored;
    }

  private:
    /*!
    @param[in] v  value to add to the JSON value we build during parsing
    @param[in] skip_callback  whether we should skip calling the callback
               function; this is required after start_array() and
               start_object() SAX events, because otherwise we would call the
               callback function with an empty array or object, respectively.

    @invariant If the ref stack is empty, then the passed value will be the new
               root.
    @invariant If the ref stack contains a value, then it is an array or an
               object to which we can add elements

    @return pair of boolean (whether value should be kept) and pointer (to the
            passed value in the ref_stack hierarchy; nullptr if not kept)
    */
    template<typename Value>
    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
    {
        JSON_ASSERT(!keep_stack.empty());

        // do not handle this value if we know it would be added to a discarded
        // container
        if (!keep_stack.back())
        {
            return {false, nullptr};
        }

        // create value
        auto value = BasicJsonType(std::forward<Value>(v));

        // check callback
        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);

        // do not handle this value if we just learnt it shall be discarded
        if (!keep)
        {
            return {false, nullptr};
        }

        if (ref_stack.empty())
        {
            root = std::move(value);
            return {true, & root};
        }

        // skip this value if we already decided to skip the parent
        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
        if (!ref_stack.back())
        {
            return {false, nullptr};
        }

        // we now only expect arrays and objects
        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());

        // array
        if (ref_stack.back()->is_array())
        {
            ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
        }

        // object
        JSON_ASSERT(ref_stack.back()->is_object());
        // check if we should store an element for the current key
        JSON_ASSERT(!key_keep_stack.empty());
        const bool store_element = key_keep_stack.back();
        key_keep_stack.pop_back();

        if (!store_element)
        {
            return {false, nullptr};
        }

        JSON_ASSERT(object_element);
        *object_element = std::move(value);
        return {true, object_element};
    }

    /// the parsed JSON value
    BasicJsonType& root;
    /// stack to model hierarchy of values
    std::vector<BasicJsonType*> ref_stack {};
    /// stack to manage which values to keep
    std::vector<bool> keep_stack {};
    /// stack to manage which object keys to keep
    std::vector<bool> key_keep_stack {};
    /// helper to hold the reference for the next object element
    BasicJsonType* object_element = nullptr;
    /// whether a syntax error occurred
    bool errored = false;
    /// callback function
    const parser_callback_t callback = nullptr;
    /// whether to throw exceptions in case of errors
    const bool allow_exceptions = true;
    /// a discarded value for the callback
    BasicJsonType discarded = BasicJsonType::value_t::discarded;
};

template<typename BasicJsonType>
class json_sax_acceptor
{
  public:
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;

    bool null()
    {
        return true;
    }

    bool boolean(bool /*unused*/)
    {
        return true;
    }

    bool number_integer(number_integer_t /*unused*/)
    {
        return true;
    }

    bool number_unsigned(number_unsigned_t /*unused*/)
    {
        return true;
    }

    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
    {
        return true;
    }

    bool string(string_t& /*unused*/)
    {
        return true;
    }

    bool binary(binary_t& /*unused*/)
    {
        return true;
    }

    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
    {
        return true;
    }

    bool key(string_t& /*unused*/)
    {
        return true;
    }

    bool end_object()
    {
        return true;
    }

    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
    {
        return true;
    }

    bool end_array()
    {
        return true;
    }

    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
    {
        return false;
    }
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/input/lexer.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <array> // array
#include <clocale> // localeconv
#include <cstddef> // size_t
#include <cstdio> // snprintf
#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
#include <initializer_list> // initializer_list
#include <string> // char_traits, string
#include <utility> // move
#include <vector> // vector

// #include <nlohmann/detail/input/input_adapters.hpp>

// #include <nlohmann/detail/input/position_t.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

///////////
// lexer //
///////////

template<typename BasicJsonType>
class lexer_base
{
  public:
    /// token types for the parser
    enum class token_type
    {
        uninitialized,    ///< indicating the scanner is uninitialized
        literal_true,     ///< the `true` literal
        literal_false,    ///< the `false` literal
        literal_null,     ///< the `null` literal
        value_string,     ///< a string -- use get_string() for actual value
        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
        value_float,      ///< an floating point number -- use get_number_float() for actual value
        begin_array,      ///< the character for array begin `[`
        begin_object,     ///< the character for object begin `{`
        end_array,        ///< the character for array end `]`
        end_object,       ///< the character for object end `}`
        name_separator,   ///< the name separator `:`
        value_separator,  ///< the value separator `,`
        parse_error,      ///< indicating a parse error
        end_of_input,     ///< indicating the end of the input buffer
        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
    };

    /// return name of values of type token_type (only used for errors)
    JSON_HEDLEY_RETURNS_NON_NULL
    JSON_HEDLEY_CONST
    static const char* token_type_name(const token_type t) noexcept
    {
        switch (t)
        {
            case token_type::uninitialized:
                return "<uninitialized>";
            case token_type::literal_true:
                return "true literal";
            case token_type::literal_false:
                return "false literal";
            case token_type::literal_null:
                return "null literal";
            case token_type::value_string:
                return "string literal";
            case token_type::value_unsigned:
            case token_type::value_integer:
            case token_type::value_float:
                return "number literal";
            case token_type::begin_array:
                return "'['";
            case token_type::begin_object:
                return "'{'";
            case token_type::end_array:
                return "']'";
            case token_type::end_object:
                return "'}'";
            case token_type::name_separator:
                return "':'";
            case token_type::value_separator:
                return "','";
            case token_type::parse_error:
                return "<parse error>";
            case token_type::end_of_input:
                return "end of input";
            case token_type::literal_or_value:
                return "'[', '{', or a literal";
            // LCOV_EXCL_START
            default: // catch non-enum values
                return "unknown token";
                // LCOV_EXCL_STOP
        }
    }
};
/*!
@brief lexical analysis

This class organizes the lexical analysis during JSON deserialization.
*/
template<typename BasicJsonType, typename InputAdapterType>
class lexer : public lexer_base<BasicJsonType>
{
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using char_type = typename InputAdapterType::char_type;
    using char_int_type = typename char_traits<char_type>::int_type;

  public:
    using token_type = typename lexer_base<BasicJsonType>::token_type;

    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
        : ia(std::move(adapter))
        , ignore_comments(ignore_comments_)
        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
    {}

    // delete because of pointer members
    lexer(const lexer&) = delete;
    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    lexer& operator=(lexer&) = delete;
    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    ~lexer() = default;

  private:
    /////////////////////
    // locales
    /////////////////////

    /// return the locale-dependent decimal point
    JSON_HEDLEY_PURE
    static char get_decimal_point() noexcept
    {
        const auto* loc = localeconv();
        JSON_ASSERT(loc != nullptr);
        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
    }

    /////////////////////
    // scan functions
    /////////////////////

    /*!
    @brief get codepoint from 4 hex characters following `\u`

    For input "\u c1 c2 c3 c4" the codepoint is:
      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)

    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
    between the ASCII value of the character and the desired integer value.

    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
            non-hex character)
    */
    int get_codepoint()
    {
        // this function only makes sense after reading `\u`
        JSON_ASSERT(current == 'u');
        int codepoint = 0;

        const auto factors = { 12u, 8u, 4u, 0u };
        for (const auto factor : factors)
        {
            get();

            if (current >= '0' && current <= '9')
            {
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
            }
            else if (current >= 'A' && current <= 'F')
            {
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
            }
            else if (current >= 'a' && current <= 'f')
            {
                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
            }
            else
            {
                return -1;
            }
        }

        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
        return codepoint;
    }

    /*!
    @brief check if the next byte(s) are inside a given range

    Adds the current byte and, for each passed range, reads a new byte and
    checks if it is inside the range. If a violation was detected, set up an
    error message and return false. Otherwise, return true.

    @param[in] ranges  list of integers; interpreted as list of pairs of
                       inclusive lower and upper bound, respectively

    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
         1, 2, or 3 pairs. This precondition is enforced by an assertion.

    @return true if and only if no range violation was detected
    */
    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
    {
        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
        add(current);

        for (auto range = ranges.begin(); range != ranges.end(); ++range)
        {
            get();
            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
            {
                add(current);
            }
            else
            {
                error_message = "invalid string: ill-formed UTF-8 byte";
                return false;
            }
        }

        return true;
    }

    /*!
    @brief scan a string literal

    This function scans a string according to Sect. 7 of RFC 8259. While
    scanning, bytes are escaped and copied into buffer token_buffer. Then the
    function returns successfully, token_buffer is *not* null-terminated (as it
    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
    string.

    @return token_type::value_string if string could be successfully scanned,
            token_type::parse_error otherwise

    @note In case of errors, variable error_message contains a textual
          description.
    */
    token_type scan_string()
    {
        // reset token_buffer (ignore opening quote)
        reset();

        // we entered the function by reading an open quote
        JSON_ASSERT(current == '\"');

        while (true)
        {
            // get next character
            switch (get())
            {
                // end of file while parsing string
                case char_traits<char_type>::eof():
                {
                    error_message = "invalid string: missing closing quote";
                    return token_type::parse_error;
                }

                // closing quote
                case '\"':
                {
                    return token_type::value_string;
                }

                // escapes
                case '\\':
                {
                    switch (get())
                    {
                        // quotation mark
                        case '\"':
                            add('\"');
                            break;
                        // reverse solidus
                        case '\\':
                            add('\\');
                            break;
                        // solidus
                        case '/':
                            add('/');
                            break;
                        // backspace
                        case 'b':
                            add('\b');
                            break;
                        // form feed
                        case 'f':
                            add('\f');
                            break;
                        // line feed
                        case 'n':
                            add('\n');
                            break;
                        // carriage return
                        case 'r':
                            add('\r');
                            break;
                        // tab
                        case 't':
                            add('\t');
                            break;

                        // unicode escapes
                        case 'u':
                        {
                            const int codepoint1 = get_codepoint();
                            int codepoint = codepoint1; // start with codepoint1

                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
                            {
                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
                                return token_type::parse_error;
                            }

                            // check if code point is a high surrogate
                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
                            {
                                // expect next \uxxxx entry
                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
                                {
                                    const int codepoint2 = get_codepoint();

                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
                                    {
                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
                                        return token_type::parse_error;
                                    }

                                    // check if codepoint2 is a low surrogate
                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
                                    {
                                        // overwrite codepoint
                                        codepoint = static_cast<int>(
                                                        // high surrogate occupies the most significant 22 bits
                                                        (static_cast<unsigned int>(codepoint1) << 10u)
                                                        // low surrogate occupies the least significant 15 bits
                                                        + static_cast<unsigned int>(codepoint2)
                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
                                                        // in the result, so we have to subtract with:
                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
                                                        - 0x35FDC00u);
                                    }
                                    else
                                    {
                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
                                        return token_type::parse_error;
                                    }
                                }
                                else
                                {
                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
                                    return token_type::parse_error;
                                }
                            }
                            else
                            {
                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
                                {
                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
                                    return token_type::parse_error;
                                }
                            }

                            // result of the above calculation yields a proper codepoint
                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);

                            // translate codepoint into bytes
                            if (codepoint < 0x80)
                            {
                                // 1-byte characters: 0xxxxxxx (ASCII)
                                add(static_cast<char_int_type>(codepoint));
                            }
                            else if (codepoint <= 0x7FF)
                            {
                                // 2-byte characters: 110xxxxx 10xxxxxx
                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
                            }
                            else if (codepoint <= 0xFFFF)
                            {
                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
                            }
                            else
                            {
                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
                            }

                            break;
                        }

                        // other characters after escape
                        default:
                            error_message = "invalid string: forbidden character after backslash";
                            return token_type::parse_error;
                    }

                    break;
                }

                // invalid control characters
                case 0x00:
                {
                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
                    return token_type::parse_error;
                }

                case 0x01:
                {
                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
                    return token_type::parse_error;
                }

                case 0x02:
                {
                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
                    return token_type::parse_error;
                }

                case 0x03:
                {
                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
                    return token_type::parse_error;
                }

                case 0x04:
                {
                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
                    return token_type::parse_error;
                }

                case 0x05:
                {
                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
                    return token_type::parse_error;
                }

                case 0x06:
                {
                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
                    return token_type::parse_error;
                }

                case 0x07:
                {
                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
                    return token_type::parse_error;
                }

                case 0x08:
                {
                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
                    return token_type::parse_error;
                }

                case 0x09:
                {
                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
                    return token_type::parse_error;
                }

                case 0x0A:
                {
                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
                    return token_type::parse_error;
                }

                case 0x0B:
                {
                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
                    return token_type::parse_error;
                }

                case 0x0C:
                {
                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
                    return token_type::parse_error;
                }

                case 0x0D:
                {
                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
                    return token_type::parse_error;
                }

                case 0x0E:
                {
                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
                    return token_type::parse_error;
                }

                case 0x0F:
                {
                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
                    return token_type::parse_error;
                }

                case 0x10:
                {
                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
                    return token_type::parse_error;
                }

                case 0x11:
                {
                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
                    return token_type::parse_error;
                }

                case 0x12:
                {
                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
                    return token_type::parse_error;
                }

                case 0x13:
                {
                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
                    return token_type::parse_error;
                }

                case 0x14:
                {
                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
                    return token_type::parse_error;
                }

                case 0x15:
                {
                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
                    return token_type::parse_error;
                }

                case 0x16:
                {
                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
                    return token_type::parse_error;
                }

                case 0x17:
                {
                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
                    return token_type::parse_error;
                }

                case 0x18:
                {
                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
                    return token_type::parse_error;
                }

                case 0x19:
                {
                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
                    return token_type::parse_error;
                }

                case 0x1A:
                {
                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
                    return token_type::parse_error;
                }

                case 0x1B:
                {
                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
                    return token_type::parse_error;
                }

                case 0x1C:
                {
                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
                    return token_type::parse_error;
                }

                case 0x1D:
                {
                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
                    return token_type::parse_error;
                }

                case 0x1E:
                {
                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
                    return token_type::parse_error;
                }

                case 0x1F:
                {
                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
                    return token_type::parse_error;
                }

                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
                case 0x20:
                case 0x21:
                case 0x23:
                case 0x24:
                case 0x25:
                case 0x26:
                case 0x27:
                case 0x28:
                case 0x29:
                case 0x2A:
                case 0x2B:
                case 0x2C:
                case 0x2D:
                case 0x2E:
                case 0x2F:
                case 0x30:
                case 0x31:
                case 0x32:
                case 0x33:
                case 0x34:
                case 0x35:
                case 0x36:
                case 0x37:
                case 0x38:
                case 0x39:
                case 0x3A:
                case 0x3B:
                case 0x3C:
                case 0x3D:
                case 0x3E:
                case 0x3F:
                case 0x40:
                case 0x41:
                case 0x42:
                case 0x43:
                case 0x44:
                case 0x45:
                case 0x46:
                case 0x47:
                case 0x48:
                case 0x49:
                case 0x4A:
                case 0x4B:
                case 0x4C:
                case 0x4D:
                case 0x4E:
                case 0x4F:
                case 0x50:
                case 0x51:
                case 0x52:
                case 0x53:
                case 0x54:
                case 0x55:
                case 0x56:
                case 0x57:
                case 0x58:
                case 0x59:
                case 0x5A:
                case 0x5B:
                case 0x5D:
                case 0x5E:
                case 0x5F:
                case 0x60:
                case 0x61:
                case 0x62:
                case 0x63:
                case 0x64:
                case 0x65:
                case 0x66:
                case 0x67:
                case 0x68:
                case 0x69:
                case 0x6A:
                case 0x6B:
                case 0x6C:
                case 0x6D:
                case 0x6E:
                case 0x6F:
                case 0x70:
                case 0x71:
                case 0x72:
                case 0x73:
                case 0x74:
                case 0x75:
                case 0x76:
                case 0x77:
                case 0x78:
                case 0x79:
                case 0x7A:
                case 0x7B:
                case 0x7C:
                case 0x7D:
                case 0x7E:
                case 0x7F:
                {
                    add(current);
                    break;
                }

                // U+0080..U+07FF: bytes C2..DF 80..BF
                case 0xC2:
                case 0xC3:
                case 0xC4:
                case 0xC5:
                case 0xC6:
                case 0xC7:
                case 0xC8:
                case 0xC9:
                case 0xCA:
                case 0xCB:
                case 0xCC:
                case 0xCD:
                case 0xCE:
                case 0xCF:
                case 0xD0:
                case 0xD1:
                case 0xD2:
                case 0xD3:
                case 0xD4:
                case 0xD5:
                case 0xD6:
                case 0xD7:
                case 0xD8:
                case 0xD9:
                case 0xDA:
                case 0xDB:
                case 0xDC:
                case 0xDD:
                case 0xDE:
                case 0xDF:
                {
                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
                    {
                        return token_type::parse_error;
                    }
                    break;
                }

                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
                case 0xE0:
                {
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
                    {
                        return token_type::parse_error;
                    }
                    break;
                }

                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
                case 0xE1:
                case 0xE2:
                case 0xE3:
                case 0xE4:
                case 0xE5:
                case 0xE6:
                case 0xE7:
                case 0xE8:
                case 0xE9:
                case 0xEA:
                case 0xEB:
                case 0xEC:
                case 0xEE:
                case 0xEF:
                {
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
                    {
                        return token_type::parse_error;
                    }
                    break;
                }

                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
                case 0xED:
                {
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
                    {
                        return token_type::parse_error;
                    }
                    break;
                }

                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
                case 0xF0:
                {
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
                    {
                        return token_type::parse_error;
                    }
                    break;
                }

                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
                case 0xF1:
                case 0xF2:
                case 0xF3:
                {
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
                    {
                        return token_type::parse_error;
                    }
                    break;
                }

                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
                case 0xF4:
                {
                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
                    {
                        return token_type::parse_error;
                    }
                    break;
                }

                // remaining bytes (80..C1 and F5..FF) are ill-formed
                default:
                {
                    error_message = "invalid string: ill-formed UTF-8 byte";
                    return token_type::parse_error;
                }
            }
        }
    }

    /*!
     * @brief scan a comment
     * @return whether comment could be scanned successfully
     */
    bool scan_comment()
    {
        switch (get())
        {
            // single-line comments skip input until a newline or EOF is read
            case '/':
            {
                while (true)
                {
                    switch (get())
                    {
                        case '\n':
                        case '\r':
                        case char_traits<char_type>::eof():
                        case '\0':
                            return true;

                        default:
                            break;
                    }
                }
            }

            // multi-line comments skip input until */ is read
            case '*':
            {
                while (true)
                {
                    switch (get())
                    {
                        case char_traits<char_type>::eof():
                        case '\0':
                        {
                            error_message = "invalid comment; missing closing '*/'";
                            return false;
                        }

                        case '*':
                        {
                            switch (get())
                            {
                                case '/':
                                    return true;

                                default:
                                {
                                    unget();
                                    continue;
                                }
                            }
                        }

                        default:
                            continue;
                    }
                }
            }

            // unexpected character after reading '/'
            default:
            {
                error_message = "invalid comment; expecting '/' or '*' after '/'";
                return false;
            }
        }
    }

    JSON_HEDLEY_NON_NULL(2)
    static void strtof(float& f, const char* str, char** endptr) noexcept
    {
        f = std::strtof(str, endptr);
    }

    JSON_HEDLEY_NON_NULL(2)
    static void strtof(double& f, const char* str, char** endptr) noexcept
    {
        f = std::strtod(str, endptr);
    }

    JSON_HEDLEY_NON_NULL(2)
    static void strtof(long double& f, const char* str, char** endptr) noexcept
    {
        f = std::strtold(str, endptr);
    }

    /*!
    @brief scan a number literal

    This function scans a string according to Sect. 6 of RFC 8259.

    The function is realized with a deterministic finite state machine derived
    from the grammar described in RFC 8259. Starting in state "init", the
    input is read and used to determined the next state. Only state "done"
    accepts the number. State "error" is a trap state to model errors. In the
    table below, "anything" means any character but the ones listed before.

    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
    ---------|----------|----------|----------|---------|---------|----------|-----------
    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
    zero     | done     | done     | exponent | done    | done    | decimal1 | done
    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
    any2     | any2     | any2     | done     | done    | done    | done     | done

    The state machine is realized with one label per state (prefixed with
    "scan_number_") and `goto` statements between them. The state machine
    contains cycles, but any cycle can be left when EOF is read. Therefore,
    the function is guaranteed to terminate.

    During scanning, the read bytes are stored in token_buffer. This string is
    then converted to a signed integer, an unsigned integer, or a
    floating-point number.

    @return token_type::value_unsigned, token_type::value_integer, or
            token_type::value_float if number could be successfully scanned,
            token_type::parse_error otherwise

    @note The scanner is independent of the current locale. Internally, the
          locale's decimal point is used instead of `.` to work with the
          locale-dependent converters.
    */
    token_type scan_number()  // lgtm [cpp/use-of-goto]
    {
        // reset token_buffer to store the number's bytes
        reset();

        // the type of the parsed number; initially set to unsigned; will be
        // changed if minus sign, decimal point or exponent is read
        token_type number_type = token_type::value_unsigned;

        // state (init): we just found out we need to scan a number
        switch (current)
        {
            case '-':
            {
                add(current);
                goto scan_number_minus;
            }

            case '0':
            {
                add(current);
                goto scan_number_zero;
            }

            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_any1;
            }

            // all other characters are rejected outside scan_number()
            default:            // LCOV_EXCL_LINE
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
        }

scan_number_minus:
        // state: we just parsed a leading minus sign
        number_type = token_type::value_integer;
        switch (get())
        {
            case '0':
            {
                add(current);
                goto scan_number_zero;
            }

            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_any1;
            }

            default:
            {
                error_message = "invalid number; expected digit after '-'";
                return token_type::parse_error;
            }
        }

scan_number_zero:
        // state: we just parse a zero (maybe with a leading minus sign)
        switch (get())
        {
            case '.':
            {
                add(decimal_point_char);
                goto scan_number_decimal1;
            }

            case 'e':
            case 'E':
            {
                add(current);
                goto scan_number_exponent;
            }

            default:
                goto scan_number_done;
        }

scan_number_any1:
        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
        switch (get())
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_any1;
            }

            case '.':
            {
                add(decimal_point_char);
                goto scan_number_decimal1;
            }

            case 'e':
            case 'E':
            {
                add(current);
                goto scan_number_exponent;
            }

            default:
                goto scan_number_done;
        }

scan_number_decimal1:
        // state: we just parsed a decimal point
        number_type = token_type::value_float;
        switch (get())
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_decimal2;
            }

            default:
            {
                error_message = "invalid number; expected digit after '.'";
                return token_type::parse_error;
            }
        }

scan_number_decimal2:
        // we just parsed at least one number after a decimal point
        switch (get())
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_decimal2;
            }

            case 'e':
            case 'E':
            {
                add(current);
                goto scan_number_exponent;
            }

            default:
                goto scan_number_done;
        }

scan_number_exponent:
        // we just parsed an exponent
        number_type = token_type::value_float;
        switch (get())
        {
            case '+':
            case '-':
            {
                add(current);
                goto scan_number_sign;
            }

            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_any2;
            }

            default:
            {
                error_message =
                    "invalid number; expected '+', '-', or digit after exponent";
                return token_type::parse_error;
            }
        }

scan_number_sign:
        // we just parsed an exponent sign
        switch (get())
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_any2;
            }

            default:
            {
                error_message = "invalid number; expected digit after exponent sign";
                return token_type::parse_error;
            }
        }

scan_number_any2:
        // we just parsed a number after the exponent or exponent sign
        switch (get())
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            {
                add(current);
                goto scan_number_any2;
            }

            default:
                goto scan_number_done;
        }

scan_number_done:
        // unget the character after the number (we only read it to know that
        // we are done scanning a number)
        unget();

        char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
        errno = 0;

        // try to parse integers first and fall back to floats
        if (number_type == token_type::value_unsigned)
        {
            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);

            // we checked the number format before
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());

            if (errno == 0)
            {
                value_unsigned = static_cast<number_unsigned_t>(x);
                if (value_unsigned == x)
                {
                    return token_type::value_unsigned;
                }
            }
        }
        else if (number_type == token_type::value_integer)
        {
            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);

            // we checked the number format before
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());

            if (errno == 0)
            {
                value_integer = static_cast<number_integer_t>(x);
                if (value_integer == x)
                {
                    return token_type::value_integer;
                }
            }
        }

        // this code is reached if we parse a floating-point number or if an
        // integer conversion above failed
        strtof(value_float, token_buffer.data(), &endptr);

        // we checked the number format before
        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());

        return token_type::value_float;
    }

    /*!
    @param[in] literal_text  the literal text to expect
    @param[in] length        the length of the passed literal text
    @param[in] return_type   the token type to return on success
    */
    JSON_HEDLEY_NON_NULL(2)
    token_type scan_literal(const char_type* literal_text, const std::size_t length,
                            token_type return_type)
    {
        JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
        for (std::size_t i = 1; i < length; ++i)
        {
            if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
            {
                error_message = "invalid literal";
                return token_type::parse_error;
            }
        }
        return return_type;
    }

    /////////////////////
    // input management
    /////////////////////

    /// reset token_buffer; current character is beginning of token
    void reset() noexcept
    {
        token_buffer.clear();
        token_string.clear();
        token_string.push_back(char_traits<char_type>::to_char_type(current));
    }

    /*
    @brief get next character from the input

    This function provides the interface to the used input adapter. It does
    not throw in case the input reached EOF, but returns a
    `char_traits<char>::eof()` in that case.  Stores the scanned characters
    for use in error messages.

    @return character read from the input
    */
    char_int_type get()
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;

        if (next_unget)
        {
            // just reset the next_unget variable and work with current
            next_unget = false;
        }
        else
        {
            current = ia.get_character();
        }

        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
        {
            token_string.push_back(char_traits<char_type>::to_char_type(current));
        }

        if (current == '\n')
        {
            ++position.lines_read;
            position.chars_read_current_line = 0;
        }

        return current;
    }

    /*!
    @brief unget current character (read it again on next get)

    We implement unget by setting variable next_unget to true. The input is not
    changed - we just simulate ungetting by modifying chars_read_total,
    chars_read_current_line, and token_string. The next call to get() will
    behave as if the unget character is read again.
    */
    void unget()
    {
        next_unget = true;

        --position.chars_read_total;

        // in case we "unget" a newline, we have to also decrement the lines_read
        if (position.chars_read_current_line == 0)
        {
            if (position.lines_read > 0)
            {
                --position.lines_read;
            }
        }
        else
        {
            --position.chars_read_current_line;
        }

        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
        {
            JSON_ASSERT(!token_string.empty());
            token_string.pop_back();
        }
    }

    /// add a character to token_buffer
    void add(char_int_type c)
    {
        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
    }

  public:
    /////////////////////
    // value getters
    /////////////////////

    /// return integer value
    constexpr number_integer_t get_number_integer() const noexcept
    {
        return value_integer;
    }

    /// return unsigned integer value
    constexpr number_unsigned_t get_number_unsigned() const noexcept
    {
        return value_unsigned;
    }

    /// return floating-point value
    constexpr number_float_t get_number_float() const noexcept
    {
        return value_float;
    }

    /// return current string value (implicitly resets the token; useful only once)
    string_t& get_string()
    {
        return token_buffer;
    }

    /////////////////////
    // diagnostics
    /////////////////////

    /// return position of last read token
    constexpr position_t get_position() const noexcept
    {
        return position;
    }

    /// return the last read token (for errors only).  Will never contain EOF
    /// (an arbitrary value that is not a valid char value, often -1), because
    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
    std::string get_token_string() const
    {
        // escape control characters
        std::string result;
        for (const auto c : token_string)
        {
            if (static_cast<unsigned char>(c) <= '\x1F')
            {
                // escape control characters
                std::array<char, 9> cs{{}};
                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
                result += cs.data();
            }
            else
            {
                // add character as is
                result.push_back(static_cast<std::string::value_type>(c));
            }
        }

        return result;
    }

    /// return syntax error message
    JSON_HEDLEY_RETURNS_NON_NULL
    constexpr const char* get_error_message() const noexcept
    {
        return error_message;
    }

    /////////////////////
    // actual scanner
    /////////////////////

    /*!
    @brief skip the UTF-8 byte order mark
    @return true iff there is no BOM or the correct BOM has been skipped
    */
    bool skip_bom()
    {
        if (get() == 0xEF)
        {
            // check if we completely parse the BOM
            return get() == 0xBB && get() == 0xBF;
        }

        // the first character is not the beginning of the BOM; unget it to
        // process is later
        unget();
        return true;
    }

    void skip_whitespace()
    {
        do
        {
            get();
        }
        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
    }

    token_type scan()
    {
        // initially, skip the BOM
        if (position.chars_read_total == 0 && !skip_bom())
        {
            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
            return token_type::parse_error;
        }

        // read next character and ignore whitespace
        skip_whitespace();

        // ignore comments
        while (ignore_comments && current == '/')
        {
            if (!scan_comment())
            {
                return token_type::parse_error;
            }

            // skip following whitespace
            skip_whitespace();
        }

        switch (current)
        {
            // structural characters
            case '[':
                return token_type::begin_array;
            case ']':
                return token_type::end_array;
            case '{':
                return token_type::begin_object;
            case '}':
                return token_type::end_object;
            case ':':
                return token_type::name_separator;
            case ',':
                return token_type::value_separator;

            // literals
            case 't':
            {
                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
            }
            case 'f':
            {
                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
            }
            case 'n':
            {
                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
            }

            // string
            case '\"':
                return scan_string();

            // number
            case '-':
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                return scan_number();

            // end of input (the null byte is needed when parsing from
            // string literals)
            case '\0':
            case char_traits<char_type>::eof():
                return token_type::end_of_input;

            // error
            default:
                error_message = "invalid literal";
                return token_type::parse_error;
        }
    }

  private:
    /// input adapter
    InputAdapterType ia;

    /// whether comments should be ignored (true) or signaled as errors (false)
    const bool ignore_comments = false;

    /// the current character
    char_int_type current = char_traits<char_type>::eof();

    /// whether the next get() call should just return current
    bool next_unget = false;

    /// the start position of the current token
    position_t position {};

    /// raw input token string (for error messages)
    std::vector<char_type> token_string {};

    /// buffer for variable-length tokens (numbers, strings)
    string_t token_buffer {};

    /// a description of occurred lexer errors
    const char* error_message = "";

    // number values
    number_integer_t value_integer = 0;
    number_unsigned_t value_unsigned = 0;
    number_float_t value_float = 0;

    /// the decimal point
    const char_int_type decimal_point_char = '.';
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/is_sax.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstdint> // size_t
#include <utility> // declval
#include <string> // string

// #include <nlohmann/detail/abi_macros.hpp>

// #include <nlohmann/detail/meta/detected.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

template<typename T>
using null_function_t = decltype(std::declval<T&>().null());

template<typename T>
using boolean_function_t =
    decltype(std::declval<T&>().boolean(std::declval<bool>()));

template<typename T, typename Integer>
using number_integer_function_t =
    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));

template<typename T, typename Unsigned>
using number_unsigned_function_t =
    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));

template<typename T, typename Float, typename String>
using number_float_function_t = decltype(std::declval<T&>().number_float(
                                    std::declval<Float>(), std::declval<const String&>()));

template<typename T, typename String>
using string_function_t =
    decltype(std::declval<T&>().string(std::declval<String&>()));

template<typename T, typename Binary>
using binary_function_t =
    decltype(std::declval<T&>().binary(std::declval<Binary&>()));

template<typename T>
using start_object_function_t =
    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));

template<typename T, typename String>
using key_function_t =
    decltype(std::declval<T&>().key(std::declval<String&>()));

template<typename T>
using end_object_function_t = decltype(std::declval<T&>().end_object());

template<typename T>
using start_array_function_t =
    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));

template<typename T>
using end_array_function_t = decltype(std::declval<T&>().end_array());

template<typename T, typename Exception>
using parse_error_function_t = decltype(std::declval<T&>().parse_error(
        std::declval<std::size_t>(), std::declval<const std::string&>(),
        std::declval<const Exception&>()));

template<typename SAX, typename BasicJsonType>
struct is_sax
{
  private:
    static_assert(is_basic_json<BasicJsonType>::value,
                  "BasicJsonType must be of type basic_json<...>");

    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;
    using exception_t = typename BasicJsonType::exception;

  public:
    static constexpr bool value =
        is_detected_exact<bool, null_function_t, SAX>::value &&
        is_detected_exact<bool, boolean_function_t, SAX>::value &&
        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
        is_detected_exact<bool, start_object_function_t, SAX>::value &&
        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
        is_detected_exact<bool, end_object_function_t, SAX>::value &&
        is_detected_exact<bool, start_array_function_t, SAX>::value &&
        is_detected_exact<bool, end_array_function_t, SAX>::value &&
        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
};

template<typename SAX, typename BasicJsonType>
struct is_sax_static_asserts
{
  private:
    static_assert(is_basic_json<BasicJsonType>::value,
                  "BasicJsonType must be of type basic_json<...>");

    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;
    using exception_t = typename BasicJsonType::exception;

  public:
    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
                  "Missing/invalid function: bool null()");
    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
                  "Missing/invalid function: bool boolean(bool)");
    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
                  "Missing/invalid function: bool boolean(bool)");
    static_assert(
        is_detected_exact<bool, number_integer_function_t, SAX,
        number_integer_t>::value,
        "Missing/invalid function: bool number_integer(number_integer_t)");
    static_assert(
        is_detected_exact<bool, number_unsigned_function_t, SAX,
        number_unsigned_t>::value,
        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
                  number_float_t, string_t>::value,
                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
    static_assert(
        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
        "Missing/invalid function: bool string(string_t&)");
    static_assert(
        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
        "Missing/invalid function: bool binary(binary_t&)");
    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
                  "Missing/invalid function: bool start_object(std::size_t)");
    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
                  "Missing/invalid function: bool key(string_t&)");
    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
                  "Missing/invalid function: bool end_object()");
    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
                  "Missing/invalid function: bool start_array(std::size_t)");
    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
                  "Missing/invalid function: bool end_array()");
    static_assert(
        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
        "Missing/invalid function: bool parse_error(std::size_t, const "
        "std::string&, const exception&)");
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/string_concat.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/// how to treat CBOR tags
enum class cbor_tag_handler_t
{
    error,   ///< throw a parse_error exception in case of a tag
    ignore,  ///< ignore tags
    store    ///< store tags as binary type
};

/*!
@brief determine system byte order

@return true if and only if system's byte order is little endian

@note from https://stackoverflow.com/a/1001328/266378
*/
static inline bool little_endianness(int num = 1) noexcept
{
    return *reinterpret_cast<char*>(&num) == 1;
}

///////////////////
// binary reader //
///////////////////

/*!
@brief deserialization of CBOR, MessagePack, and UBJSON values
*/
template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
class binary_reader
{
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;
    using json_sax_t = SAX;
    using char_type = typename InputAdapterType::char_type;
    using char_int_type = typename char_traits<char_type>::int_type;

  public:
    /*!
    @brief create a binary reader

    @param[in] adapter  input adapter to read from
    */
    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
    {
        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
    }

    // make class move-only
    binary_reader(const binary_reader&) = delete;
    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    binary_reader& operator=(const binary_reader&) = delete;
    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
    ~binary_reader() = default;

    /*!
    @param[in] format  the binary format to parse
    @param[in] sax_    a SAX event processor
    @param[in] strict  whether to expect the input to be consumed completed
    @param[in] tag_handler  how to treat CBOR tags

    @return whether parsing was successful
    */
    JSON_HEDLEY_NON_NULL(3)
    bool sax_parse(const input_format_t format,
                   json_sax_t* sax_,
                   const bool strict = true,
                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        sax = sax_;
        bool result = false;

        switch (format)
        {
            case input_format_t::bson:
                result = parse_bson_internal();
                break;

            case input_format_t::cbor:
                result = parse_cbor_internal(true, tag_handler);
                break;

            case input_format_t::msgpack:
                result = parse_msgpack_internal();
                break;

            case input_format_t::ubjson:
            case input_format_t::bjdata:
                result = parse_ubjson_internal();
                break;

            case input_format_t::json: // LCOV_EXCL_LINE
            default:            // LCOV_EXCL_LINE
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
        }

        // strict mode: next byte must be EOF
        if (result && strict)
        {
            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
            {
                get_ignore_noop();
            }
            else
            {
                get();
            }

            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
            {
                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
            }
        }

        return result;
    }

  private:
    //////////
    // BSON //
    //////////

    /*!
    @brief Reads in a BSON-object and passes it to the SAX-parser.
    @return whether a valid BSON-value was passed to the SAX parser
    */
    bool parse_bson_internal()
    {
        std::int32_t document_size{};
        get_number<std::int32_t, true>(input_format_t::bson, document_size);

        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
        {
            return false;
        }

        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
        {
            return false;
        }

        return sax->end_object();
    }

    /*!
    @brief Parses a C-style string from the BSON input.
    @param[in,out] result  A reference to the string variable where the read
                            string is to be stored.
    @return `true` if the \x00-byte indicating the end of the string was
             encountered before the EOF; false` indicates an unexpected EOF.
    */
    bool get_bson_cstr(string_t& result)
    {
        auto out = std::back_inserter(result);
        while (true)
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
            {
                return false;
            }
            if (current == 0x00)
            {
                return true;
            }
            *out++ = static_cast<typename string_t::value_type>(current);
        }
    }

    /*!
    @brief Parses a zero-terminated string of length @a len from the BSON
           input.
    @param[in] len  The length (including the zero-byte at the end) of the
                    string to be read.
    @param[in,out] result  A reference to the string variable where the read
                            string is to be stored.
    @tparam NumberType The type of the length @a len
    @pre len >= 1
    @return `true` if the string was successfully parsed
    */
    template<typename NumberType>
    bool get_bson_string(const NumberType len, string_t& result)
    {
        if (JSON_HEDLEY_UNLIKELY(len < 1))
        {
            auto last_token = get_token_string();
            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
        }

        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
    }

    /*!
    @brief Parses a byte array input of length @a len from the BSON input.
    @param[in] len  The length of the byte array to be read.
    @param[in,out] result  A reference to the binary variable where the read
                            array is to be stored.
    @tparam NumberType The type of the length @a len
    @pre len >= 0
    @return `true` if the byte array was successfully parsed
    */
    template<typename NumberType>
    bool get_bson_binary(const NumberType len, binary_t& result)
    {
        if (JSON_HEDLEY_UNLIKELY(len < 0))
        {
            auto last_token = get_token_string();
            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
        }

        // All BSON binary values have a subtype
        std::uint8_t subtype{};
        get_number<std::uint8_t>(input_format_t::bson, subtype);
        result.set_subtype(subtype);

        return get_binary(input_format_t::bson, len, result);
    }

    /*!
    @brief Read a BSON document element of the given @a element_type.
    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
    @param[in] element_type_parse_position The position in the input stream,
               where the `element_type` was read.
    @warning Not all BSON element types are supported yet. An unsupported
             @a element_type will give rise to a parse_error.114:
             Unsupported BSON record type 0x...
    @return whether a valid BSON-object/array was passed to the SAX parser
    */
    bool parse_bson_element_internal(const char_int_type element_type,
                                     const std::size_t element_type_parse_position)
    {
        switch (element_type)
        {
            case 0x01: // double
            {
                double number{};
                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }

            case 0x02: // string
            {
                std::int32_t len{};
                string_t value;
                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
            }

            case 0x03: // object
            {
                return parse_bson_internal();
            }

            case 0x04: // array
            {
                return parse_bson_array();
            }

            case 0x05: // binary
            {
                std::int32_t len{};
                binary_t value;
                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
            }

            case 0x08: // boolean
            {
                return sax->boolean(get() != 0);
            }

            case 0x0A: // null
            {
                return sax->null();
            }

            case 0x10: // int32
            {
                std::int32_t value{};
                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
            }

            case 0x12: // int64
            {
                std::int64_t value{};
                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
            }

            default: // anything else not supported (yet)
            {
                std::array<char, 3> cr{{}};
                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
                const std::string cr_str{cr.data()};
                return sax->parse_error(element_type_parse_position, cr_str,
                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
            }
        }
    }

    /*!
    @brief Read a BSON element list (as specified in the BSON-spec)

    The same binary layout is used for objects and arrays, hence it must be
    indicated with the argument @a is_array which one is expected
    (true --> array, false --> object).

    @param[in] is_array Determines if the element list being read is to be
                        treated as an object (@a is_array == false), or as an
                        array (@a is_array == true).
    @return whether a valid BSON-object/array was passed to the SAX parser
    */
    bool parse_bson_element_list(const bool is_array)
    {
        string_t key;

        while (auto element_type = get())
        {
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
            {
                return false;
            }

            const std::size_t element_type_parse_position = chars_read;
            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
            {
                return false;
            }

            if (!is_array && !sax->key(key))
            {
                return false;
            }

            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
            {
                return false;
            }

            // get_bson_cstr only appends
            key.clear();
        }

        return true;
    }

    /*!
    @brief Reads an array from the BSON input and passes it to the SAX-parser.
    @return whether a valid BSON-array was passed to the SAX parser
    */
    bool parse_bson_array()
    {
        std::int32_t document_size{};
        get_number<std::int32_t, true>(input_format_t::bson, document_size);

        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
        {
            return false;
        }

        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
        {
            return false;
        }

        return sax->end_array();
    }

    //////////
    // CBOR //
    //////////

    /*!
    @param[in] get_char  whether a new character should be retrieved from the
                         input (true) or whether the last read character should
                         be considered instead (false)
    @param[in] tag_handler how CBOR tags should be treated

    @return whether a valid CBOR value was passed to the SAX parser
    */
    bool parse_cbor_internal(const bool get_char,
                             const cbor_tag_handler_t tag_handler)
    {
        switch (get_char ? get() : current)
        {
            // EOF
            case char_traits<char_type>::eof():
                return unexpect_eof(input_format_t::cbor, "value");

            // Integer 0x00..0x17 (0..23)
            case 0x00:
            case 0x01:
            case 0x02:
            case 0x03:
            case 0x04:
            case 0x05:
            case 0x06:
            case 0x07:
            case 0x08:
            case 0x09:
            case 0x0A:
            case 0x0B:
            case 0x0C:
            case 0x0D:
            case 0x0E:
            case 0x0F:
            case 0x10:
            case 0x11:
            case 0x12:
            case 0x13:
            case 0x14:
            case 0x15:
            case 0x16:
            case 0x17:
                return sax->number_unsigned(static_cast<number_unsigned_t>(current));

            case 0x18: // Unsigned integer (one-byte uint8_t follows)
            {
                std::uint8_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
            }

            case 0x19: // Unsigned integer (two-byte uint16_t follows)
            {
                std::uint16_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
            }

            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
            {
                std::uint32_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
            }

            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
            {
                std::uint64_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
            }

            // Negative integer -1-0x00..-1-0x17 (-1..-24)
            case 0x20:
            case 0x21:
            case 0x22:
            case 0x23:
            case 0x24:
            case 0x25:
            case 0x26:
            case 0x27:
            case 0x28:
            case 0x29:
            case 0x2A:
            case 0x2B:
            case 0x2C:
            case 0x2D:
            case 0x2E:
            case 0x2F:
            case 0x30:
            case 0x31:
            case 0x32:
            case 0x33:
            case 0x34:
            case 0x35:
            case 0x36:
            case 0x37:
                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));

            case 0x38: // Negative integer (one-byte uint8_t follows)
            {
                std::uint8_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
            }

            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
            {
                std::uint16_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
            }

            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
            {
                std::uint32_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
            }

            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
            {
                std::uint64_t number{};
                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
                        - static_cast<number_integer_t>(number));
            }

            // Binary data (0x00..0x17 bytes follow)
            case 0x40:
            case 0x41:
            case 0x42:
            case 0x43:
            case 0x44:
            case 0x45:
            case 0x46:
            case 0x47:
            case 0x48:
            case 0x49:
            case 0x4A:
            case 0x4B:
            case 0x4C:
            case 0x4D:
            case 0x4E:
            case 0x4F:
            case 0x50:
            case 0x51:
            case 0x52:
            case 0x53:
            case 0x54:
            case 0x55:
            case 0x56:
            case 0x57:
            case 0x58: // Binary data (one-byte uint8_t for n follows)
            case 0x59: // Binary data (two-byte uint16_t for n follow)
            case 0x5A: // Binary data (four-byte uint32_t for n follow)
            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
            case 0x5F: // Binary data (indefinite length)
            {
                binary_t b;
                return get_cbor_binary(b) && sax->binary(b);
            }

            // UTF-8 string (0x00..0x17 bytes follow)
            case 0x60:
            case 0x61:
            case 0x62:
            case 0x63:
            case 0x64:
            case 0x65:
            case 0x66:
            case 0x67:
            case 0x68:
            case 0x69:
            case 0x6A:
            case 0x6B:
            case 0x6C:
            case 0x6D:
            case 0x6E:
            case 0x6F:
            case 0x70:
            case 0x71:
            case 0x72:
            case 0x73:
            case 0x74:
            case 0x75:
            case 0x76:
            case 0x77:
            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
            case 0x7F: // UTF-8 string (indefinite length)
            {
                string_t s;
                return get_cbor_string(s) && sax->string(s);
            }

            // array (0x00..0x17 data items follow)
            case 0x80:
            case 0x81:
            case 0x82:
            case 0x83:
            case 0x84:
            case 0x85:
            case 0x86:
            case 0x87:
            case 0x88:
            case 0x89:
            case 0x8A:
            case 0x8B:
            case 0x8C:
            case 0x8D:
            case 0x8E:
            case 0x8F:
            case 0x90:
            case 0x91:
            case 0x92:
            case 0x93:
            case 0x94:
            case 0x95:
            case 0x96:
            case 0x97:
                return get_cbor_array(
                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);

            case 0x98: // array (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
            }

            case 0x99: // array (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
            }

            case 0x9A: // array (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
            }

            case 0x9B: // array (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
            }

            case 0x9F: // array (indefinite length)
                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);

            // map (0x00..0x17 pairs of data items follow)
            case 0xA0:
            case 0xA1:
            case 0xA2:
            case 0xA3:
            case 0xA4:
            case 0xA5:
            case 0xA6:
            case 0xA7:
            case 0xA8:
            case 0xA9:
            case 0xAA:
            case 0xAB:
            case 0xAC:
            case 0xAD:
            case 0xAE:
            case 0xAF:
            case 0xB0:
            case 0xB1:
            case 0xB2:
            case 0xB3:
            case 0xB4:
            case 0xB5:
            case 0xB6:
            case 0xB7:
                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);

            case 0xB8: // map (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
            }

            case 0xB9: // map (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
            }

            case 0xBA: // map (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
            }

            case 0xBB: // map (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
            }

            case 0xBF: // map (indefinite length)
                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);

            case 0xC6: // tagged item
            case 0xC7:
            case 0xC8:
            case 0xC9:
            case 0xCA:
            case 0xCB:
            case 0xCC:
            case 0xCD:
            case 0xCE:
            case 0xCF:
            case 0xD0:
            case 0xD1:
            case 0xD2:
            case 0xD3:
            case 0xD4:
            case 0xD8: // tagged item (1 bytes follow)
            case 0xD9: // tagged item (2 bytes follow)
            case 0xDA: // tagged item (4 bytes follow)
            case 0xDB: // tagged item (8 bytes follow)
            {
                switch (tag_handler)
                {
                    case cbor_tag_handler_t::error:
                    {
                        auto last_token = get_token_string();
                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
                    }

                    case cbor_tag_handler_t::ignore:
                    {
                        // ignore binary subtype
                        switch (current)
                        {
                            case 0xD8:
                            {
                                std::uint8_t subtype_to_ignore{};
                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            case 0xD9:
                            {
                                std::uint16_t subtype_to_ignore{};
                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            case 0xDA:
                            {
                                std::uint32_t subtype_to_ignore{};
                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            case 0xDB:
                            {
                                std::uint64_t subtype_to_ignore{};
                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            default:
                                break;
                        }
                        return parse_cbor_internal(true, tag_handler);
                    }

                    case cbor_tag_handler_t::store:
                    {
                        binary_t b;
                        // use binary subtype and store in binary container
                        switch (current)
                        {
                            case 0xD8:
                            {
                                std::uint8_t subtype{};
                                get_number(input_format_t::cbor, subtype);
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
                            case 0xD9:
                            {
                                std::uint16_t subtype{};
                                get_number(input_format_t::cbor, subtype);
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
                            case 0xDA:
                            {
                                std::uint32_t subtype{};
                                get_number(input_format_t::cbor, subtype);
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
                            case 0xDB:
                            {
                                std::uint64_t subtype{};
                                get_number(input_format_t::cbor, subtype);
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
                            default:
                                return parse_cbor_internal(true, tag_handler);
                        }
                        get();
                        return get_cbor_binary(b) && sax->binary(b);
                    }

                    default:                 // LCOV_EXCL_LINE
                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
                        return false;        // LCOV_EXCL_LINE
                }
            }

            case 0xF4: // false
                return sax->boolean(false);

            case 0xF5: // true
                return sax->boolean(true);

            case 0xF6: // null
                return sax->null();

            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
            {
                const auto byte1_raw = get();
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
                {
                    return false;
                }
                const auto byte2_raw = get();
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
                {
                    return false;
                }

                const auto byte1 = static_cast<unsigned char>(byte1_raw);
                const auto byte2 = static_cast<unsigned char>(byte2_raw);

                // code from RFC 7049, Appendix D, Figure 3:
                // As half-precision floating-point numbers were only added
                // to IEEE 754 in 2008, today's programming platforms often
                // still only have limited support for them. It is very
                // easy to include at least decoding support for them even
                // without such support. An example of a small decoder for
                // half-precision floating-point numbers in the C language
                // is shown in Fig. 3.
                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
                const double val = [&half]
                {
                    const int exp = (half >> 10u) & 0x1Fu;
                    const unsigned int mant = half & 0x3FFu;
                    JSON_ASSERT(0 <= exp&& exp <= 32);
                    JSON_ASSERT(mant <= 1024);
                    switch (exp)
                    {
                        case 0:
                            return std::ldexp(mant, -24);
                        case 31:
                            return (mant == 0)
                            ? std::numeric_limits<double>::infinity()
                            : std::numeric_limits<double>::quiet_NaN();
                        default:
                            return std::ldexp(mant + 1024, exp - 25);
                    }
                }();
                return sax->number_float((half & 0x8000u) != 0
                                         ? static_cast<number_float_t>(-val)
                                         : static_cast<number_float_t>(val), "");
            }

            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
            {
                float number{};
                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }

            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
            {
                double number{};
                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }

            default: // anything else (0xFF is handled inside the other types)
            {
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
            }
        }
    }

    /*!
    @brief reads a CBOR string

    This function first reads starting bytes to determine the expected
    string length and then copies this number of bytes into a string.
    Additionally, CBOR's strings with indefinite lengths are supported.

    @param[out] result  created string

    @return whether string creation completed
    */
    bool get_cbor_string(string_t& result)
    {
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
        {
            return false;
        }

        switch (current)
        {
            // UTF-8 string (0x00..0x17 bytes follow)
            case 0x60:
            case 0x61:
            case 0x62:
            case 0x63:
            case 0x64:
            case 0x65:
            case 0x66:
            case 0x67:
            case 0x68:
            case 0x69:
            case 0x6A:
            case 0x6B:
            case 0x6C:
            case 0x6D:
            case 0x6E:
            case 0x6F:
            case 0x70:
            case 0x71:
            case 0x72:
            case 0x73:
            case 0x74:
            case 0x75:
            case 0x76:
            case 0x77:
            {
                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
            }

            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
            }

            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
            }

            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
            }

            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
            }

            case 0x7F: // UTF-8 string (indefinite length)
            {
                while (get() != 0xFF)
                {
                    string_t chunk;
                    if (!get_cbor_string(chunk))
                    {
                        return false;
                    }
                    result.append(chunk);
                }
                return true;
            }

            default:
            {
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
            }
        }
    }

    /*!
    @brief reads a CBOR byte array

    This function first reads starting bytes to determine the expected
    byte array length and then copies this number of bytes into the byte array.
    Additionally, CBOR's byte arrays with indefinite lengths are supported.

    @param[out] result  created byte array

    @return whether byte array creation completed
    */
    bool get_cbor_binary(binary_t& result)
    {
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
        {
            return false;
        }

        switch (current)
        {
            // Binary data (0x00..0x17 bytes follow)
            case 0x40:
            case 0x41:
            case 0x42:
            case 0x43:
            case 0x44:
            case 0x45:
            case 0x46:
            case 0x47:
            case 0x48:
            case 0x49:
            case 0x4A:
            case 0x4B:
            case 0x4C:
            case 0x4D:
            case 0x4E:
            case 0x4F:
            case 0x50:
            case 0x51:
            case 0x52:
            case 0x53:
            case 0x54:
            case 0x55:
            case 0x56:
            case 0x57:
            {
                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
            }

            case 0x58: // Binary data (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
                return get_number(input_format_t::cbor, len) &&
                       get_binary(input_format_t::cbor, len, result);
            }

            case 0x59: // Binary data (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
                return get_number(input_format_t::cbor, len) &&
                       get_binary(input_format_t::cbor, len, result);
            }

            case 0x5A: // Binary data (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
                return get_number(input_format_t::cbor, len) &&
                       get_binary(input_format_t::cbor, len, result);
            }

            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
                return get_number(input_format_t::cbor, len) &&
                       get_binary(input_format_t::cbor, len, result);
            }

            case 0x5F: // Binary data (indefinite length)
            {
                while (get() != 0xFF)
                {
                    binary_t chunk;
                    if (!get_cbor_binary(chunk))
                    {
                        return false;
                    }
                    result.insert(result.end(), chunk.begin(), chunk.end());
                }
                return true;
            }

            default:
            {
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
                                        exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr));
            }
        }
    }

    /*!
    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
                    array of indefinite size
    @param[in] tag_handler how CBOR tags should be treated
    @return whether array creation completed
    */
    bool get_cbor_array(const std::size_t len,
                        const cbor_tag_handler_t tag_handler)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
        {
            return false;
        }

        if (len != static_cast<std::size_t>(-1))
        {
            for (std::size_t i = 0; i < len; ++i)
            {
                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
                {
                    return false;
                }
            }
        }
        else
        {
            while (get() != 0xFF)
            {
                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
                {
                    return false;
                }
            }
        }

        return sax->end_array();
    }

    /*!
    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
                    object of indefinite size
    @param[in] tag_handler how CBOR tags should be treated
    @return whether object creation completed
    */
    bool get_cbor_object(const std::size_t len,
                         const cbor_tag_handler_t tag_handler)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
        {
            return false;
        }

        if (len != 0)
        {
            string_t key;
            if (len != static_cast<std::size_t>(-1))
            {
                for (std::size_t i = 0; i < len; ++i)
                {
                    get();
                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
                    {
                        return false;
                    }

                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
                    {
                        return false;
                    }
                    key.clear();
                }
            }
            else
            {
                while (get() != 0xFF)
                {
                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
                    {
                        return false;
                    }

                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
                    {
                        return false;
                    }
                    key.clear();
                }
            }
        }

        return sax->end_object();
    }

    /////////////
    // MsgPack //
    /////////////

    /*!
    @return whether a valid MessagePack value was passed to the SAX parser
    */
    bool parse_msgpack_internal()
    {
        switch (get())
        {
            // EOF
            case char_traits<char_type>::eof():
                return unexpect_eof(input_format_t::msgpack, "value");

            // positive fixint
            case 0x00:
            case 0x01:
            case 0x02:
            case 0x03:
            case 0x04:
            case 0x05:
            case 0x06:
            case 0x07:
            case 0x08:
            case 0x09:
            case 0x0A:
            case 0x0B:
            case 0x0C:
            case 0x0D:
            case 0x0E:
            case 0x0F:
            case 0x10:
            case 0x11:
            case 0x12:
            case 0x13:
            case 0x14:
            case 0x15:
            case 0x16:
            case 0x17:
            case 0x18:
            case 0x19:
            case 0x1A:
            case 0x1B:
            case 0x1C:
            case 0x1D:
            case 0x1E:
            case 0x1F:
            case 0x20:
            case 0x21:
            case 0x22:
            case 0x23:
            case 0x24:
            case 0x25:
            case 0x26:
            case 0x27:
            case 0x28:
            case 0x29:
            case 0x2A:
            case 0x2B:
            case 0x2C:
            case 0x2D:
            case 0x2E:
            case 0x2F:
            case 0x30:
            case 0x31:
            case 0x32:
            case 0x33:
            case 0x34:
            case 0x35:
            case 0x36:
            case 0x37:
            case 0x38:
            case 0x39:
            case 0x3A:
            case 0x3B:
            case 0x3C:
            case 0x3D:
            case 0x3E:
            case 0x3F:
            case 0x40:
            case 0x41:
            case 0x42:
            case 0x43:
            case 0x44:
            case 0x45:
            case 0x46:
            case 0x47:
            case 0x48:
            case 0x49:
            case 0x4A:
            case 0x4B:
            case 0x4C:
            case 0x4D:
            case 0x4E:
            case 0x4F:
            case 0x50:
            case 0x51:
            case 0x52:
            case 0x53:
            case 0x54:
            case 0x55:
            case 0x56:
            case 0x57:
            case 0x58:
            case 0x59:
            case 0x5A:
            case 0x5B:
            case 0x5C:
            case 0x5D:
            case 0x5E:
            case 0x5F:
            case 0x60:
            case 0x61:
            case 0x62:
            case 0x63:
            case 0x64:
            case 0x65:
            case 0x66:
            case 0x67:
            case 0x68:
            case 0x69:
            case 0x6A:
            case 0x6B:
            case 0x6C:
            case 0x6D:
            case 0x6E:
            case 0x6F:
            case 0x70:
            case 0x71:
            case 0x72:
            case 0x73:
            case 0x74:
            case 0x75:
            case 0x76:
            case 0x77:
            case 0x78:
            case 0x79:
            case 0x7A:
            case 0x7B:
            case 0x7C:
            case 0x7D:
            case 0x7E:
            case 0x7F:
                return sax->number_unsigned(static_cast<number_unsigned_t>(current));

            // fixmap
            case 0x80:
            case 0x81:
            case 0x82:
            case 0x83:
            case 0x84:
            case 0x85:
            case 0x86:
            case 0x87:
            case 0x88:
            case 0x89:
            case 0x8A:
            case 0x8B:
            case 0x8C:
            case 0x8D:
            case 0x8E:
            case 0x8F:
                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));

            // fixarray
            case 0x90:
            case 0x91:
            case 0x92:
            case 0x93:
            case 0x94:
            case 0x95:
            case 0x96:
            case 0x97:
            case 0x98:
            case 0x99:
            case 0x9A:
            case 0x9B:
            case 0x9C:
            case 0x9D:
            case 0x9E:
            case 0x9F:
                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));

            // fixstr
            case 0xA0:
            case 0xA1:
            case 0xA2:
            case 0xA3:
            case 0xA4:
            case 0xA5:
            case 0xA6:
            case 0xA7:
            case 0xA8:
            case 0xA9:
            case 0xAA:
            case 0xAB:
            case 0xAC:
            case 0xAD:
            case 0xAE:
            case 0xAF:
            case 0xB0:
            case 0xB1:
            case 0xB2:
            case 0xB3:
            case 0xB4:
            case 0xB5:
            case 0xB6:
            case 0xB7:
            case 0xB8:
            case 0xB9:
            case 0xBA:
            case 0xBB:
            case 0xBC:
            case 0xBD:
            case 0xBE:
            case 0xBF:
            case 0xD9: // str 8
            case 0xDA: // str 16
            case 0xDB: // str 32
            {
                string_t s;
                return get_msgpack_string(s) && sax->string(s);
            }

            case 0xC0: // nil
                return sax->null();

            case 0xC2: // false
                return sax->boolean(false);

            case 0xC3: // true
                return sax->boolean(true);

            case 0xC4: // bin 8
            case 0xC5: // bin 16
            case 0xC6: // bin 32
            case 0xC7: // ext 8
            case 0xC8: // ext 16
            case 0xC9: // ext 32
            case 0xD4: // fixext 1
            case 0xD5: // fixext 2
            case 0xD6: // fixext 4
            case 0xD7: // fixext 8
            case 0xD8: // fixext 16
            {
                binary_t b;
                return get_msgpack_binary(b) && sax->binary(b);
            }

            case 0xCA: // float 32
            {
                float number{};
                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }

            case 0xCB: // float 64
            {
                double number{};
                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }

            case 0xCC: // uint 8
            {
                std::uint8_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
            }

            case 0xCD: // uint 16
            {
                std::uint16_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
            }

            case 0xCE: // uint 32
            {
                std::uint32_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
            }

            case 0xCF: // uint 64
            {
                std::uint64_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
            }

            case 0xD0: // int 8
            {
                std::int8_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
            }

            case 0xD1: // int 16
            {
                std::int16_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
            }

            case 0xD2: // int 32
            {
                std::int32_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
            }

            case 0xD3: // int 64
            {
                std::int64_t number{};
                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
            }

            case 0xDC: // array 16
            {
                std::uint16_t len{};
                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
            }

            case 0xDD: // array 32
            {
                std::uint32_t len{};
                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
            }

            case 0xDE: // map 16
            {
                std::uint16_t len{};
                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
            }

            case 0xDF: // map 32
            {
                std::uint32_t len{};
                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
            }

            // negative fixint
            case 0xE0:
            case 0xE1:
            case 0xE2:
            case 0xE3:
            case 0xE4:
            case 0xE5:
            case 0xE6:
            case 0xE7:
            case 0xE8:
            case 0xE9:
            case 0xEA:
            case 0xEB:
            case 0xEC:
            case 0xED:
            case 0xEE:
            case 0xEF:
            case 0xF0:
            case 0xF1:
            case 0xF2:
            case 0xF3:
            case 0xF4:
            case 0xF5:
            case 0xF6:
            case 0xF7:
            case 0xF8:
            case 0xF9:
            case 0xFA:
            case 0xFB:
            case 0xFC:
            case 0xFD:
            case 0xFE:
            case 0xFF:
                return sax->number_integer(static_cast<std::int8_t>(current));

            default: // anything else
            {
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
            }
        }
    }

    /*!
    @brief reads a MessagePack string

    This function first reads starting bytes to determine the expected
    string length and then copies this number of bytes into a string.

    @param[out] result  created string

    @return whether string creation completed
    */
    bool get_msgpack_string(string_t& result)
    {
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
        {
            return false;
        }

        switch (current)
        {
            // fixstr
            case 0xA0:
            case 0xA1:
            case 0xA2:
            case 0xA3:
            case 0xA4:
            case 0xA5:
            case 0xA6:
            case 0xA7:
            case 0xA8:
            case 0xA9:
            case 0xAA:
            case 0xAB:
            case 0xAC:
            case 0xAD:
            case 0xAE:
            case 0xAF:
            case 0xB0:
            case 0xB1:
            case 0xB2:
            case 0xB3:
            case 0xB4:
            case 0xB5:
            case 0xB6:
            case 0xB7:
            case 0xB8:
            case 0xB9:
            case 0xBA:
            case 0xBB:
            case 0xBC:
            case 0xBD:
            case 0xBE:
            case 0xBF:
            {
                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
            }

            case 0xD9: // str 8
            {
                std::uint8_t len{};
                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
            }

            case 0xDA: // str 16
            {
                std::uint16_t len{};
                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
            }

            case 0xDB: // str 32
            {
                std::uint32_t len{};
                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
            }

            default:
            {
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
            }
        }
    }

    /*!
    @brief reads a MessagePack byte array

    This function first reads starting bytes to determine the expected
    byte array length and then copies this number of bytes into a byte array.

    @param[out] result  created byte array

    @return whether byte array creation completed
    */
    bool get_msgpack_binary(binary_t& result)
    {
        // helper function to set the subtype
        auto assign_and_return_true = [&result](std::int8_t subtype)
        {
            result.set_subtype(static_cast<std::uint8_t>(subtype));
            return true;
        };

        switch (current)
        {
            case 0xC4: // bin 8
            {
                std::uint8_t len{};
                return get_number(input_format_t::msgpack, len) &&
                       get_binary(input_format_t::msgpack, len, result);
            }

            case 0xC5: // bin 16
            {
                std::uint16_t len{};
                return get_number(input_format_t::msgpack, len) &&
                       get_binary(input_format_t::msgpack, len, result);
            }

            case 0xC6: // bin 32
            {
                std::uint32_t len{};
                return get_number(input_format_t::msgpack, len) &&
                       get_binary(input_format_t::msgpack, len, result);
            }

            case 0xC7: // ext 8
            {
                std::uint8_t len{};
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, len) &&
                       get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, len, result) &&
                       assign_and_return_true(subtype);
            }

            case 0xC8: // ext 16
            {
                std::uint16_t len{};
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, len) &&
                       get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, len, result) &&
                       assign_and_return_true(subtype);
            }

            case 0xC9: // ext 32
            {
                std::uint32_t len{};
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, len) &&
                       get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, len, result) &&
                       assign_and_return_true(subtype);
            }

            case 0xD4: // fixext 1
            {
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, 1, result) &&
                       assign_and_return_true(subtype);
            }

            case 0xD5: // fixext 2
            {
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, 2, result) &&
                       assign_and_return_true(subtype);
            }

            case 0xD6: // fixext 4
            {
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, 4, result) &&
                       assign_and_return_true(subtype);
            }

            case 0xD7: // fixext 8
            {
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, 8, result) &&
                       assign_and_return_true(subtype);
            }

            case 0xD8: // fixext 16
            {
                std::int8_t subtype{};
                return get_number(input_format_t::msgpack, subtype) &&
                       get_binary(input_format_t::msgpack, 16, result) &&
                       assign_and_return_true(subtype);
            }

            default:           // LCOV_EXCL_LINE
                return false;  // LCOV_EXCL_LINE
        }
    }

    /*!
    @param[in] len  the length of the array
    @return whether array creation completed
    */
    bool get_msgpack_array(const std::size_t len)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
        {
            return false;
        }

        for (std::size_t i = 0; i < len; ++i)
        {
            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
            {
                return false;
            }
        }

        return sax->end_array();
    }

    /*!
    @param[in] len  the length of the object
    @return whether object creation completed
    */
    bool get_msgpack_object(const std::size_t len)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
        {
            return false;
        }

        string_t key;
        for (std::size_t i = 0; i < len; ++i)
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
            {
                return false;
            }

            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
            {
                return false;
            }
            key.clear();
        }

        return sax->end_object();
    }

    ////////////
    // UBJSON //
    ////////////

    /*!
    @param[in] get_char  whether a new character should be retrieved from the
                         input (true, default) or whether the last read
                         character should be considered instead

    @return whether a valid UBJSON value was passed to the SAX parser
    */
    bool parse_ubjson_internal(const bool get_char = true)
    {
        return get_ubjson_value(get_char ? get_ignore_noop() : current);
    }

    /*!
    @brief reads a UBJSON string

    This function is either called after reading the 'S' byte explicitly
    indicating a string, or in case of an object key where the 'S' byte can be
    left out.

    @param[out] result   created string
    @param[in] get_char  whether a new character should be retrieved from the
                         input (true, default) or whether the last read
                         character should be considered instead

    @return whether string creation completed
    */
    bool get_ubjson_string(string_t& result, const bool get_char = true)
    {
        if (get_char)
        {
            get();  // TODO(niels): may we ignore N here?
        }

        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
        {
            return false;
        }

        switch (current)
        {
            case 'U':
            {
                std::uint8_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'i':
            {
                std::int8_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'I':
            {
                std::int16_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'l':
            {
                std::int32_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'L':
            {
                std::int64_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'u':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint16_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'm':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint32_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'M':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint64_t len{};
                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            default:
                break;
        }
        auto last_token = get_token_string();
        std::string message;

        if (input_format != input_format_t::bjdata)
        {
            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
        }
        else
        {
            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
        }
        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
    }

    /*!
    @param[out] dim  an integer vector storing the ND array dimensions
    @return whether reading ND array size vector is successful
    */
    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
    {
        std::pair<std::size_t, char_int_type> size_and_type;
        size_t dimlen = 0;
        bool no_ndarray = true;

        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
        {
            return false;
        }

        if (size_and_type.first != npos)
        {
            if (size_and_type.second != 0)
            {
                if (size_and_type.second != 'N')
                {
                    for (std::size_t i = 0; i < size_and_type.first; ++i)
                    {
                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
                        {
                            return false;
                        }
                        dim.push_back(dimlen);
                    }
                }
            }
            else
            {
                for (std::size_t i = 0; i < size_and_type.first; ++i)
                {
                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
                    {
                        return false;
                    }
                    dim.push_back(dimlen);
                }
            }
        }
        else
        {
            while (current != ']')
            {
                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
                {
                    return false;
                }
                dim.push_back(dimlen);
                get_ignore_noop();
            }
        }
        return true;
    }

    /*!
    @param[out] result  determined size
    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector
                               or ndarray dimension is not allowed; `false` means ndarray
                               is allowed; for output, `true` means an ndarray is found;
                               is_ndarray can only return `true` when its initial value
                               is `false`
    @param[in] prefix  type marker if already read, otherwise set to 0

    @return whether size determination completed
    */
    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
    {
        if (prefix == 0)
        {
            prefix = get_ignore_noop();
        }

        switch (prefix)
        {
            case 'U':
            {
                std::uint8_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                result = static_cast<std::size_t>(number);
                return true;
            }

            case 'i':
            {
                std::int8_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                if (number < 0)
                {
                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
                }
                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
                return true;
            }

            case 'I':
            {
                std::int16_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                if (number < 0)
                {
                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
                }
                result = static_cast<std::size_t>(number);
                return true;
            }

            case 'l':
            {
                std::int32_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                if (number < 0)
                {
                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
                }
                result = static_cast<std::size_t>(number);
                return true;
            }

            case 'L':
            {
                std::int64_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                if (number < 0)
                {
                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
                }
                if (!value_in_range_of<std::size_t>(number))
                {
                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
                }
                result = static_cast<std::size_t>(number);
                return true;
            }

            case 'u':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint16_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                result = static_cast<std::size_t>(number);
                return true;
            }

            case 'm':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint32_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                result = conditional_static_cast<std::size_t>(number);
                return true;
            }

            case 'M':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint64_t number{};
                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
                {
                    return false;
                }
                if (!value_in_range_of<std::size_t>(number))
                {
                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
                }
                result = detail::conditional_static_cast<std::size_t>(number);
                return true;
            }

            case '[':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array
                {
                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr));
                }
                std::vector<size_t> dim;
                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
                {
                    return false;
                }
                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
                {
                    result = dim.at(dim.size() - 1);
                    return true;
                }
                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format
                {
                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
                    {
                        if ( i == 0 )
                        {
                            result = 0;
                            return true;
                        }
                    }

                    string_t key = "_ArraySize_";
                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
                    {
                        return false;
                    }
                    result = 1;
                    for (auto i : dim)
                    {
                        result *= i;
                        if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type()
                        {
                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
                        }
                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
                        {
                            return false;
                        }
                    }
                    is_ndarray = true;
                    return sax->end_array();
                }
                result = 0;
                return true;
            }

            default:
                break;
        }
        auto last_token = get_token_string();
        std::string message;

        if (input_format != input_format_t::bjdata)
        {
            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
        }
        else
        {
            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
        }
        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
    }

    /*!
    @brief determine the type and size for a container

    In the optimized UBJSON format, a type and a size can be provided to allow
    for a more compact representation.

    @param[out] result  pair of the size and the type
    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector

    @return whether pair creation completed
    */
    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
    {
        result.first = npos; // size
        result.second = 0; // type
        bool is_ndarray = false;

        get_ignore_noop();

        if (current == '$')
        {
            result.second = get();  // must not ignore 'N', because 'N' maybe the type
            if (input_format == input_format_t::bjdata
                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
            {
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
            }

            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
            {
                return false;
            }

            get_ignore_noop();
            if (JSON_HEDLEY_UNLIKELY(current != '#'))
            {
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
                {
                    return false;
                }
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
            }

            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
            if (input_format == input_format_t::bjdata && is_ndarray)
            {
                if (inside_ndarray)
                {
                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
                }
                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
            }
            return is_error;
        }

        if (current == '#')
        {
            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
            if (input_format == input_format_t::bjdata && is_ndarray)
            {
                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
            }
            return is_error;
        }

        return true;
    }

    /*!
    @param prefix  the previously read or set type prefix
    @return whether value creation completed
    */
    bool get_ubjson_value(const char_int_type prefix)
    {
        switch (prefix)
        {
            case char_traits<char_type>::eof():  // EOF
                return unexpect_eof(input_format, "value");

            case 'T':  // true
                return sax->boolean(true);
            case 'F':  // false
                return sax->boolean(false);

            case 'Z':  // null
                return sax->null();

            case 'U':
            {
                std::uint8_t number{};
                return get_number(input_format, number) && sax->number_unsigned(number);
            }

            case 'i':
            {
                std::int8_t number{};
                return get_number(input_format, number) && sax->number_integer(number);
            }

            case 'I':
            {
                std::int16_t number{};
                return get_number(input_format, number) && sax->number_integer(number);
            }

            case 'l':
            {
                std::int32_t number{};
                return get_number(input_format, number) && sax->number_integer(number);
            }

            case 'L':
            {
                std::int64_t number{};
                return get_number(input_format, number) && sax->number_integer(number);
            }

            case 'u':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint16_t number{};
                return get_number(input_format, number) && sax->number_unsigned(number);
            }

            case 'm':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint32_t number{};
                return get_number(input_format, number) && sax->number_unsigned(number);
            }

            case 'M':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                std::uint64_t number{};
                return get_number(input_format, number) && sax->number_unsigned(number);
            }

            case 'h':
            {
                if (input_format != input_format_t::bjdata)
                {
                    break;
                }
                const auto byte1_raw = get();
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
                {
                    return false;
                }
                const auto byte2_raw = get();
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
                {
                    return false;
                }

                const auto byte1 = static_cast<unsigned char>(byte1_raw);
                const auto byte2 = static_cast<unsigned char>(byte2_raw);

                // code from RFC 7049, Appendix D, Figure 3:
                // As half-precision floating-point numbers were only added
                // to IEEE 754 in 2008, today's programming platforms often
                // still only have limited support for them. It is very
                // easy to include at least decoding support for them even
                // without such support. An example of a small decoder for
                // half-precision floating-point numbers in the C language
                // is shown in Fig. 3.
                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
                const double val = [&half]
                {
                    const int exp = (half >> 10u) & 0x1Fu;
                    const unsigned int mant = half & 0x3FFu;
                    JSON_ASSERT(0 <= exp&& exp <= 32);
                    JSON_ASSERT(mant <= 1024);
                    switch (exp)
                    {
                        case 0:
                            return std::ldexp(mant, -24);
                        case 31:
                            return (mant == 0)
                            ? std::numeric_limits<double>::infinity()
                            : std::numeric_limits<double>::quiet_NaN();
                        default:
                            return std::ldexp(mant + 1024, exp - 25);
                    }
                }();
                return sax->number_float((half & 0x8000u) != 0
                                         ? static_cast<number_float_t>(-val)
                                         : static_cast<number_float_t>(val), "");
            }

            case 'd':
            {
                float number{};
                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }

            case 'D':
            {
                double number{};
                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
            }

            case 'H':
            {
                return get_ubjson_high_precision_number();
            }

            case 'C':  // char
            {
                get();
                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
                {
                    return false;
                }
                if (JSON_HEDLEY_UNLIKELY(current > 127))
                {
                    auto last_token = get_token_string();
                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
                }
                string_t s(1, static_cast<typename string_t::value_type>(current));
                return sax->string(s);
            }

            case 'S':  // string
            {
                string_t s;
                return get_ubjson_string(s) && sax->string(s);
            }

            case '[':  // array
                return get_ubjson_array();

            case '{':  // object
                return get_ubjson_object();

            default: // anything else
                break;
        }
        auto last_token = get_token_string();
        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr));
    }

    /*!
    @return whether array creation completed
    */
    bool get_ubjson_array()
    {
        std::pair<std::size_t, char_int_type> size_and_type;
        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
        {
            return false;
        }

        // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata):
        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}

        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
        {
            size_and_type.second &= ~(static_cast<char_int_type>(1) << 8);  // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker
            auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t)
            {
                return p.first < t;
            });
            string_t key = "_ArrayType_";
            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
            {
                auto last_token = get_token_string();
                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
            }

            string_t type = it->second; // sax->string() takes a reference
            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
            {
                return false;
            }

            if (size_and_type.second == 'C')
            {
                size_and_type.second = 'U';
            }

            key = "_ArrayData_";
            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))
            {
                return false;
            }

            for (std::size_t i = 0; i < size_and_type.first; ++i)
            {
                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
                {
                    return false;
                }
            }

            return (sax->end_array() && sax->end_object());
        }

        if (size_and_type.first != npos)
        {
            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
            {
                return false;
            }

            if (size_and_type.second != 0)
            {
                if (size_and_type.second != 'N')
                {
                    for (std::size_t i = 0; i < size_and_type.first; ++i)
                    {
                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
                        {
                            return false;
                        }
                    }
                }
            }
            else
            {
                for (std::size_t i = 0; i < size_and_type.first; ++i)
                {
                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
                    {
                        return false;
                    }
                }
            }
        }
        else
        {
            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
            {
                return false;
            }

            while (current != ']')
            {
                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
                {
                    return false;
                }
                get_ignore_noop();
            }
        }

        return sax->end_array();
    }

    /*!
    @return whether object creation completed
    */
    bool get_ubjson_object()
    {
        std::pair<std::size_t, char_int_type> size_and_type;
        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
        {
            return false;
        }

        // do not accept ND-array size in objects in BJData
        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
        {
            auto last_token = get_token_string();
            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
        }

        string_t key;
        if (size_and_type.first != npos)
        {
            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
            {
                return false;
            }

            if (size_and_type.second != 0)
            {
                for (std::size_t i = 0; i < size_and_type.first; ++i)
                {
                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
                    {
                        return false;
                    }
                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
                    {
                        return false;
                    }
                    key.clear();
                }
            }
            else
            {
                for (std::size_t i = 0; i < size_and_type.first; ++i)
                {
                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
                    {
                        return false;
                    }
                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
                    {
                        return false;
                    }
                    key.clear();
                }
            }
        }
        else
        {
            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
            {
                return false;
            }

            while (current != '}')
            {
                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
                {
                    return false;
                }
                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
                {
                    return false;
                }
                get_ignore_noop();
                key.clear();
            }
        }

        return sax->end_object();
    }

    // Note, no reader for UBJSON binary types is implemented because they do
    // not exist

    bool get_ubjson_high_precision_number()
    {
        // get size of following number string
        std::size_t size{};
        bool no_ndarray = true;
        auto res = get_ubjson_size_value(size, no_ndarray);
        if (JSON_HEDLEY_UNLIKELY(!res))
        {
            return res;
        }

        // get number string
        std::vector<char> number_vector;
        for (std::size_t i = 0; i < size; ++i)
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
            {
                return false;
            }
            number_vector.push_back(static_cast<char>(current));
        }

        // parse number string
        using ia_type = decltype(detail::input_adapter(number_vector));
        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
        const auto result_number = number_lexer.scan();
        const auto number_string = number_lexer.get_token_string();
        const auto result_remainder = number_lexer.scan();

        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;

        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
        {
            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
        }

        switch (result_number)
        {
            case token_type::value_integer:
                return sax->number_integer(number_lexer.get_number_integer());
            case token_type::value_unsigned:
                return sax->number_unsigned(number_lexer.get_number_unsigned());
            case token_type::value_float:
                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
            case token_type::uninitialized:
            case token_type::literal_true:
            case token_type::literal_false:
            case token_type::literal_null:
            case token_type::value_string:
            case token_type::begin_array:
            case token_type::begin_object:
            case token_type::end_array:
            case token_type::end_object:
            case token_type::name_separator:
            case token_type::value_separator:
            case token_type::parse_error:
            case token_type::end_of_input:
            case token_type::literal_or_value:
            default:
                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
        }
    }

    ///////////////////////
    // Utility functions //
    ///////////////////////

    /*!
    @brief get next character from the input

    This function provides the interface to the used input adapter. It does
    not throw in case the input reached EOF, but returns a -'ve valued
    `char_traits<char_type>::eof()` in that case.

    @return character read from the input
    */
    char_int_type get()
    {
        ++chars_read;
        return current = ia.get_character();
    }

    /*!
    @return character read from the input after ignoring all 'N' entries
    */
    char_int_type get_ignore_noop()
    {
        do
        {
            get();
        }
        while (current == 'N');

        return current;
    }

    /*
    @brief read a number from the input

    @tparam NumberType the type of the number
    @param[in] format   the current format (for diagnostics)
    @param[out] result  number of type @a NumberType

    @return whether conversion completed

    @note This function needs to respect the system's endianness, because
          bytes in CBOR, MessagePack, and UBJSON are stored in network order
          (big endian) and therefore need reordering on little endian systems.
          On the other hand, BSON and BJData use little endian and should reorder
          on big endian systems.
    */
    template<typename NumberType, bool InputIsLittleEndian = false>
    bool get_number(const input_format_t format, NumberType& result)
    {
        // step 1: read input into array with system's byte order
        std::array<std::uint8_t, sizeof(NumberType)> vec{};
        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
            {
                return false;
            }

            // reverse byte order prior to conversion if necessary
            if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
            {
                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
            }
            else
            {
                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
            }
        }

        // step 2: convert array into number of type T and return
        std::memcpy(&result, vec.data(), sizeof(NumberType));
        return true;
    }

    /*!
    @brief create a string by reading characters from the input

    @tparam NumberType the type of the number
    @param[in] format the current format (for diagnostics)
    @param[in] len number of characters to read
    @param[out] result string created by reading @a len bytes

    @return whether string creation completed

    @note We can not reserve @a len bytes for the result, because @a len
          may be too large. Usually, @ref unexpect_eof() detects the end of
          the input before we run out of string memory.
    */
    template<typename NumberType>
    bool get_string(const input_format_t format,
                    const NumberType len,
                    string_t& result)
    {
        bool success = true;
        for (NumberType i = 0; i < len; i++)
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
            {
                success = false;
                break;
            }
            result.push_back(static_cast<typename string_t::value_type>(current));
        }
        return success;
    }

    /*!
    @brief create a byte array by reading bytes from the input

    @tparam NumberType the type of the number
    @param[in] format the current format (for diagnostics)
    @param[in] len number of bytes to read
    @param[out] result byte array created by reading @a len bytes

    @return whether byte array creation completed

    @note We can not reserve @a len bytes for the result, because @a len
          may be too large. Usually, @ref unexpect_eof() detects the end of
          the input before we run out of memory.
    */
    template<typename NumberType>
    bool get_binary(const input_format_t format,
                    const NumberType len,
                    binary_t& result)
    {
        bool success = true;
        for (NumberType i = 0; i < len; i++)
        {
            get();
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
            {
                success = false;
                break;
            }
            result.push_back(static_cast<std::uint8_t>(current));
        }
        return success;
    }

    /*!
    @param[in] format   the current format (for diagnostics)
    @param[in] context  further context information (for diagnostics)
    @return whether the last read character is not EOF
    */
    JSON_HEDLEY_NON_NULL(3)
    bool unexpect_eof(const input_format_t format, const char* context) const
    {
        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
        {
            return sax->parse_error(chars_read, "<end of file>",
                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
        }
        return true;
    }

    /*!
    @return a string representation of the last read byte
    */
    std::string get_token_string() const
    {
        std::array<char, 3> cr{{}};
        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
        return std::string{cr.data()};
    }

    /*!
    @param[in] format   the current format
    @param[in] detail   a detailed error message
    @param[in] context  further context information
    @return a message string to use in the parse_error exceptions
    */
    std::string exception_message(const input_format_t format,
                                  const std::string& detail,
                                  const std::string& context) const
    {
        std::string error_msg = "syntax error while parsing ";

        switch (format)
        {
            case input_format_t::cbor:
                error_msg += "CBOR";
                break;

            case input_format_t::msgpack:
                error_msg += "MessagePack";
                break;

            case input_format_t::ubjson:
                error_msg += "UBJSON";
                break;

            case input_format_t::bson:
                error_msg += "BSON";
                break;

            case input_format_t::bjdata:
                error_msg += "BJData";
                break;

            case input_format_t::json: // LCOV_EXCL_LINE
            default:            // LCOV_EXCL_LINE
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
        }

        return concat(error_msg, ' ', context, ": ", detail);
    }

  private:
    static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);

    /// input adapter
    InputAdapterType ia;

    /// the current character
    char_int_type current = char_traits<char_type>::eof();

    /// the number of characters read
    std::size_t chars_read = 0;

    /// whether we can assume little endianness
    const bool is_little_endian = little_endianness();

    /// input format
    const input_format_t input_format = input_format_t::json;

    /// the SAX parser
    json_sax_t* sax = nullptr;

    // excluded markers in bjdata optimized type
#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')

#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
    make_array<bjd_type>(                      \
    bjd_type{'C', "char"},                     \
    bjd_type{'D', "double"},                   \
    bjd_type{'I', "int16"},                    \
    bjd_type{'L', "int64"},                    \
    bjd_type{'M', "uint64"},                   \
    bjd_type{'U', "uint8"},                    \
    bjd_type{'d', "single"},                   \
    bjd_type{'i', "int8"},                     \
    bjd_type{'l', "int32"},                    \
    bjd_type{'m', "uint32"},                   \
    bjd_type{'u', "uint16"})

  JSON_PRIVATE_UNLESS_TESTED:
    // lookup tables
    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;

    using bjd_type = std::pair<char_int_type, string_t>;
    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;

#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
};

#ifndef JSON_HAS_CPP_17
    template<typename BasicJsonType, typename InputAdapterType, typename SAX>
    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
#endif

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/input/input_adapters.hpp>

// #include <nlohmann/detail/input/lexer.hpp>

// #include <nlohmann/detail/input/parser.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cmath> // isfinite
#include <cstdint> // uint8_t
#include <functional> // function
#include <string> // string
#include <utility> // move
#include <vector> // vector

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/input/input_adapters.hpp>

// #include <nlohmann/detail/input/json_sax.hpp>

// #include <nlohmann/detail/input/lexer.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/is_sax.hpp>

// #include <nlohmann/detail/string_concat.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{
////////////
// parser //
////////////

enum class parse_event_t : std::uint8_t
{
    /// the parser read `{` and started to process a JSON object
    object_start,
    /// the parser read `}` and finished processing a JSON object
    object_end,
    /// the parser read `[` and started to process a JSON array
    array_start,
    /// the parser read `]` and finished processing a JSON array
    array_end,
    /// the parser read a key of a value in an object
    key,
    /// the parser finished reading a JSON value
    value
};

template<typename BasicJsonType>
using parser_callback_t =
    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;

/*!
@brief syntax analysis

This class implements a recursive descent parser.
*/
template<typename BasicJsonType, typename InputAdapterType>
class parser
{
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using string_t = typename BasicJsonType::string_t;
    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
    using token_type = typename lexer_t::token_type;

  public:
    /// a parser reading from an input adapter
    explicit parser(InputAdapterType&& adapter,
                    const parser_callback_t<BasicJsonType> cb = nullptr,
                    const bool allow_exceptions_ = true,
                    const bool skip_comments = false)
        : callback(cb)
        , m_lexer(std::move(adapter), skip_comments)
        , allow_exceptions(allow_exceptions_)
    {
        // read first token
        get_token();
    }

    /*!
    @brief public parser interface

    @param[in] strict      whether to expect the last token to be EOF
    @param[in,out] result  parsed JSON value

    @throw parse_error.101 in case of an unexpected token
    @throw parse_error.102 if to_unicode fails or surrogate error
    @throw parse_error.103 if to_unicode fails
    */
    void parse(const bool strict, BasicJsonType& result)
    {
        if (callback)
        {
            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
            sax_parse_internal(&sdp);

            // in strict mode, input must be completely read
            if (strict && (get_token() != token_type::end_of_input))
            {
                sdp.parse_error(m_lexer.get_position(),
                                m_lexer.get_token_string(),
                                parse_error::create(101, m_lexer.get_position(),
                                                    exception_message(token_type::end_of_input, "value"), nullptr));
            }

            // in case of an error, return discarded value
            if (sdp.is_errored())
            {
                result = value_t::discarded;
                return;
            }

            // set top-level value to null if it was discarded by the callback
            // function
            if (result.is_discarded())
            {
                result = nullptr;
            }
        }
        else
        {
            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
            sax_parse_internal(&sdp);

            // in strict mode, input must be completely read
            if (strict && (get_token() != token_type::end_of_input))
            {
                sdp.parse_error(m_lexer.get_position(),
                                m_lexer.get_token_string(),
                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
            }

            // in case of an error, return discarded value
            if (sdp.is_errored())
            {
                result = value_t::discarded;
                return;
            }
        }

        result.assert_invariant();
    }

    /*!
    @brief public accept interface

    @param[in] strict  whether to expect the last token to be EOF
    @return whether the input is a proper JSON text
    */
    bool accept(const bool strict = true)
    {
        json_sax_acceptor<BasicJsonType> sax_acceptor;
        return sax_parse(&sax_acceptor, strict);
    }

    template<typename SAX>
    JSON_HEDLEY_NON_NULL(2)
    bool sax_parse(SAX* sax, const bool strict = true)
    {
        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
        const bool result = sax_parse_internal(sax);

        // strict mode: next byte must be EOF
        if (result && strict && (get_token() != token_type::end_of_input))
        {
            return sax->parse_error(m_lexer.get_position(),
                                    m_lexer.get_token_string(),
                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
        }

        return result;
    }

  private:
    template<typename SAX>
    JSON_HEDLEY_NON_NULL(2)
    bool sax_parse_internal(SAX* sax)
    {
        // stack to remember the hierarchy of structured values we are parsing
        // true = array; false = object
        std::vector<bool> states;
        // value to avoid a goto (see comment where set to true)
        bool skip_to_state_evaluation = false;

        while (true)
        {
            if (!skip_to_state_evaluation)
            {
                // invariant: get_token() was called before each iteration
                switch (last_token)
                {
                    case token_type::begin_object:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
                        {
                            return false;
                        }

                        // closing } -> we are done
                        if (get_token() == token_type::end_object)
                        {
                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
                            {
                                return false;
                            }
                            break;
                        }

                        // parse key
                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
                        }
                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
                        {
                            return false;
                        }

                        // parse separator (:)
                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
                        }

                        // remember we are now inside an object
                        states.push_back(false);

                        // parse values
                        get_token();
                        continue;
                    }

                    case token_type::begin_array:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
                        {
                            return false;
                        }

                        // closing ] -> we are done
                        if (get_token() == token_type::end_array)
                        {
                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
                            {
                                return false;
                            }
                            break;
                        }

                        // remember we are now inside an array
                        states.push_back(true);

                        // parse values (no need to call get_token)
                        continue;
                    }

                    case token_type::value_float:
                    {
                        const auto res = m_lexer.get_number_float();

                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
                        }

                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
                        {
                            return false;
                        }

                        break;
                    }

                    case token_type::literal_false:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::literal_null:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::literal_true:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::value_integer:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::value_string:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::value_unsigned:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::parse_error:
                    {
                        // using "uninitialized" to avoid "expected" message
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
                    }
                    case token_type::end_of_input:
                    {
                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    parse_error::create(101, m_lexer.get_position(),
                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
                        }

                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
                    }
                    case token_type::uninitialized:
                    case token_type::end_array:
                    case token_type::end_object:
                    case token_type::name_separator:
                    case token_type::value_separator:
                    case token_type::literal_or_value:
                    default: // the last token was unexpected
                    {
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
                    }
                }
            }
            else
            {
                skip_to_state_evaluation = false;
            }

            // we reached this line after we successfully parsed a value
            if (states.empty())
            {
                // empty stack: we reached the end of the hierarchy: done
                return true;
            }

            if (states.back())  // array
            {
                // comma -> next value
                if (get_token() == token_type::value_separator)
                {
                    // parse a new value
                    get_token();
                    continue;
                }

                // closing ]
                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
                {
                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
                    {
                        return false;
                    }

                    // We are done with this array. Before we can parse a
                    // new value, we need to evaluate the new state first.
                    // By setting skip_to_state_evaluation to false, we
                    // are effectively jumping to the beginning of this if.
                    JSON_ASSERT(!states.empty());
                    states.pop_back();
                    skip_to_state_evaluation = true;
                    continue;
                }

                return sax->parse_error(m_lexer.get_position(),
                                        m_lexer.get_token_string(),
                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
            }

            // states.back() is false -> object

            // comma -> next value
            if (get_token() == token_type::value_separator)
            {
                // parse key
                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
                {
                    return sax->parse_error(m_lexer.get_position(),
                                            m_lexer.get_token_string(),
                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
                }

                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
                {
                    return false;
                }

                // parse separator (:)
                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                {
                    return sax->parse_error(m_lexer.get_position(),
                                            m_lexer.get_token_string(),
                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
                }

                // parse values
                get_token();
                continue;
            }

            // closing }
            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
            {
                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
                {
                    return false;
                }

                // We are done with this object. Before we can parse a
                // new value, we need to evaluate the new state first.
                // By setting skip_to_state_evaluation to false, we
                // are effectively jumping to the beginning of this if.
                JSON_ASSERT(!states.empty());
                states.pop_back();
                skip_to_state_evaluation = true;
                continue;
            }

            return sax->parse_error(m_lexer.get_position(),
                                    m_lexer.get_token_string(),
                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
        }
    }

    /// get next token from lexer
    token_type get_token()
    {
        return last_token = m_lexer.scan();
    }

    std::string exception_message(const token_type expected, const std::string& context)
    {
        std::string error_msg = "syntax error ";

        if (!context.empty())
        {
            error_msg += concat("while parsing ", context, ' ');
        }

        error_msg += "- ";

        if (last_token == token_type::parse_error)
        {
            error_msg += concat(m_lexer.get_error_message(), "; last read: '",
                                m_lexer.get_token_string(), '\'');
        }
        else
        {
            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
        }

        if (expected != token_type::uninitialized)
        {
            error_msg += concat("; expected ", lexer_t::token_type_name(expected));
        }

        return error_msg;
    }

  private:
    /// callback function
    const parser_callback_t<BasicJsonType> callback = nullptr;
    /// the type of the last read token
    token_type last_token = token_type::uninitialized;
    /// the lexer
    lexer_t m_lexer;
    /// whether to throw exceptions in case of errors
    const bool allow_exceptions = true;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/iterators/internal_iterator.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// #include <nlohmann/detail/abi_macros.hpp>

// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstddef> // ptrdiff_t
#include <limits>  // numeric_limits

// #include <nlohmann/detail/macro_scope.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/*
@brief an iterator for primitive JSON types

This class models an iterator for primitive JSON types (boolean, number,
string). It's only purpose is to allow the iterator/const_iterator classes
to "iterate" over primitive values. Internally, the iterator is modeled by
a `difference_type` variable. Value begin_value (`0`) models the begin,
end_value (`1`) models past the end.
*/
class primitive_iterator_t
{
  private:
    using difference_type = std::ptrdiff_t;
    static constexpr difference_type begin_value = 0;
    static constexpr difference_type end_value = begin_value + 1;

  JSON_PRIVATE_UNLESS_TESTED:
    /// iterator as signed integer type
    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();

  public:
    constexpr difference_type get_value() const noexcept
    {
        return m_it;
    }

    /// set iterator to a defined beginning
    void set_begin() noexcept
    {
        m_it = begin_value;
    }

    /// set iterator to a defined past the end
    void set_end() noexcept
    {
        m_it = end_value;
    }

    /// return whether the iterator can be dereferenced
    constexpr bool is_begin() const noexcept
    {
        return m_it == begin_value;
    }

    /// return whether the iterator is at end
    constexpr bool is_end() const noexcept
    {
        return m_it == end_value;
    }

    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
    {
        return lhs.m_it == rhs.m_it;
    }

    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
    {
        return lhs.m_it < rhs.m_it;
    }

    primitive_iterator_t operator+(difference_type n) noexcept
    {
        auto result = *this;
        result += n;
        return result;
    }

    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
    {
        return lhs.m_it - rhs.m_it;
    }

    primitive_iterator_t& operator++() noexcept
    {
        ++m_it;
        return *this;
    }

    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)
    {
        auto result = *this;
        ++m_it;
        return result;
    }

    primitive_iterator_t& operator--() noexcept
    {
        --m_it;
        return *this;
    }

    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)
    {
        auto result = *this;
        --m_it;
        return result;
    }

    primitive_iterator_t& operator+=(difference_type n) noexcept
    {
        m_it += n;
        return *this;
    }

    primitive_iterator_t& operator-=(difference_type n) noexcept
    {
        m_it -= n;
        return *this;
    }
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/*!
@brief an iterator value

@note This structure could easily be a union, but MSVC currently does not allow
unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
*/
template<typename BasicJsonType> struct internal_iterator
{
    /// iterator for JSON objects
    typename BasicJsonType::object_t::iterator object_iterator {};
    /// iterator for JSON arrays
    typename BasicJsonType::array_t::iterator array_iterator {};
    /// generic iterator for all other types
    primitive_iterator_t primitive_iterator {};
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/iterators/iter_impl.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
#include <type_traits> // conditional, is_const, remove_const

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/iterators/internal_iterator.hpp>

// #include <nlohmann/detail/iterators/primitive_iterator.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

// forward declare, to be able to friend it later on
template<typename IteratorType> class iteration_proxy;
template<typename IteratorType> class iteration_proxy_value;

/*!
@brief a template for a bidirectional iterator for the @ref basic_json class
This class implements a both iterators (iterator and const_iterator) for the
@ref basic_json class.
@note An iterator is called *initialized* when a pointer to a JSON value has
      been set (e.g., by a constructor or a copy assignment). If the iterator is
      default-constructed, it is *uninitialized* and most methods are undefined.
      **The library uses assertions to detect calls on uninitialized iterators.**
@requirement The class satisfies the following concept requirements:
-
[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
  The iterator that can be moved can be moved in both directions (i.e.
  incremented and decremented).
@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
*/
template<typename BasicJsonType>
class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
{
    /// the iterator with BasicJsonType of different const-ness
    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
    /// allow basic_json to access private members
    friend other_iter_impl;
    friend BasicJsonType;
    friend iteration_proxy<iter_impl>;
    friend iteration_proxy_value<iter_impl>;

    using object_t = typename BasicJsonType::object_t;
    using array_t = typename BasicJsonType::array_t;
    // make sure BasicJsonType is basic_json or const basic_json
    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
                  "iter_impl only accepts (const) basic_json");
    // superficial check for the LegacyBidirectionalIterator named requirement
    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");

  public:
    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
    /// A user-defined iterator should provide publicly accessible typedefs named
    /// iterator_category, value_type, difference_type, pointer, and reference.
    /// Note that value_type is required to be non-const, even for constant iterators.
    using iterator_category = std::bidirectional_iterator_tag;

    /// the type of the values when the iterator is dereferenced
    using value_type = typename BasicJsonType::value_type;
    /// a type to represent differences between iterators
    using difference_type = typename BasicJsonType::difference_type;
    /// defines a pointer to the type iterated over (value_type)
    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
          typename BasicJsonType::const_pointer,
          typename BasicJsonType::pointer>::type;
    /// defines a reference to the type iterated over (value_type)
    using reference =
        typename std::conditional<std::is_const<BasicJsonType>::value,
        typename BasicJsonType::const_reference,
        typename BasicJsonType::reference>::type;

    iter_impl() = default;
    ~iter_impl() = default;
    iter_impl(iter_impl&&) noexcept = default;
    iter_impl& operator=(iter_impl&&) noexcept = default;

    /*!
    @brief constructor for a given JSON instance
    @param[in] object  pointer to a JSON object for this iterator
    @pre object != nullptr
    @post The iterator is initialized; i.e. `m_object != nullptr`.
    */
    explicit iter_impl(pointer object) noexcept : m_object(object)
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                m_it.object_iterator = typename object_t::iterator();
                break;
            }

            case value_t::array:
            {
                m_it.array_iterator = typename array_t::iterator();
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                m_it.primitive_iterator = primitive_iterator_t();
                break;
            }
        }
    }

    /*!
    @note The conventional copy constructor and copy assignment are implicitly
          defined. Combined with the following converting constructor and
          assignment, they support: (1) copy from iterator to iterator, (2)
          copy from const iterator to const iterator, and (3) conversion from
          iterator to const iterator. However conversion from const iterator
          to iterator is not defined.
    */

    /*!
    @brief const copy constructor
    @param[in] other const iterator to copy from
    @note This copy constructor had to be defined explicitly to circumvent a bug
          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
          information refer to: https://github.com/nlohmann/json/issues/1608
    */
    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
        : m_object(other.m_object), m_it(other.m_it)
    {}

    /*!
    @brief converting assignment
    @param[in] other const iterator to copy from
    @return const/non-const iterator
    @note It is not checked whether @a other is initialized.
    */
    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
    {
        if (&other != this)
        {
            m_object = other.m_object;
            m_it = other.m_it;
        }
        return *this;
    }

    /*!
    @brief converting constructor
    @param[in] other  non-const iterator to copy from
    @note It is not checked whether @a other is initialized.
    */
    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
        : m_object(other.m_object), m_it(other.m_it)
    {}

    /*!
    @brief converting assignment
    @param[in] other  non-const iterator to copy from
    @return const/non-const iterator
    @note It is not checked whether @a other is initialized.
    */
    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
    {
        m_object = other.m_object;
        m_it = other.m_it;
        return *this;
    }

  JSON_PRIVATE_UNLESS_TESTED:
    /*!
    @brief set the iterator to the first value
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    void set_begin() noexcept
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                m_it.object_iterator = m_object->m_data.m_value.object->begin();
                break;
            }

            case value_t::array:
            {
                m_it.array_iterator = m_object->m_data.m_value.array->begin();
                break;
            }

            case value_t::null:
            {
                // set to end so begin()==end() is true: null is empty
                m_it.primitive_iterator.set_end();
                break;
            }

            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                m_it.primitive_iterator.set_begin();
                break;
            }
        }
    }

    /*!
    @brief set the iterator past the last value
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    void set_end() noexcept
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                m_it.object_iterator = m_object->m_data.m_value.object->end();
                break;
            }

            case value_t::array:
            {
                m_it.array_iterator = m_object->m_data.m_value.array->end();
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                m_it.primitive_iterator.set_end();
                break;
            }
        }
    }

  public:
    /*!
    @brief return a reference to the value pointed to by the iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    reference operator*() const
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
                return m_it.object_iterator->second;
            }

            case value_t::array:
            {
                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
                return *m_it.array_iterator;
            }

            case value_t::null:
                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));

            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
                {
                    return *m_object;
                }

                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
            }
        }
    }

    /*!
    @brief dereference the iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    pointer operator->() const
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
                return &(m_it.object_iterator->second);
            }

            case value_t::array:
            {
                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
                return &*m_it.array_iterator;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
                {
                    return m_object;
                }

                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
            }
        }
    }

    /*!
    @brief post-increment (it++)
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
    {
        auto result = *this;
        ++(*this);
        return result;
    }

    /*!
    @brief pre-increment (++it)
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl& operator++()
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                std::advance(m_it.object_iterator, 1);
                break;
            }

            case value_t::array:
            {
                std::advance(m_it.array_iterator, 1);
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                ++m_it.primitive_iterator;
                break;
            }
        }

        return *this;
    }

    /*!
    @brief post-decrement (it--)
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
    {
        auto result = *this;
        --(*this);
        return result;
    }

    /*!
    @brief pre-decrement (--it)
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl& operator--()
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
            {
                std::advance(m_it.object_iterator, -1);
                break;
            }

            case value_t::array:
            {
                std::advance(m_it.array_iterator, -1);
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                --m_it.primitive_iterator;
                break;
            }
        }

        return *this;
    }

    /*!
    @brief comparison: equal
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
    bool operator==(const IterImpl& other) const
    {
        // if objects are not the same, the comparison is undefined
        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
        {
            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
        }

        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
                return (m_it.object_iterator == other.m_it.object_iterator);

            case value_t::array:
                return (m_it.array_iterator == other.m_it.array_iterator);

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
        }
    }

    /*!
    @brief comparison: not equal
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
    bool operator!=(const IterImpl& other) const
    {
        return !operator==(other);
    }

    /*!
    @brief comparison: smaller
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    bool operator<(const iter_impl& other) const
    {
        // if objects are not the same, the comparison is undefined
        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
        {
            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
        }

        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));

            case value_t::array:
                return (m_it.array_iterator < other.m_it.array_iterator);

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
        }
    }

    /*!
    @brief comparison: less than or equal
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    bool operator<=(const iter_impl& other) const
    {
        return !other.operator < (*this);
    }

    /*!
    @brief comparison: greater than
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    bool operator>(const iter_impl& other) const
    {
        return !operator<=(other);
    }

    /*!
    @brief comparison: greater than or equal
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    bool operator>=(const iter_impl& other) const
    {
        return !operator<(other);
    }

    /*!
    @brief add to iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl& operator+=(difference_type i)
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));

            case value_t::array:
            {
                std::advance(m_it.array_iterator, i);
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                m_it.primitive_iterator += i;
                break;
            }
        }

        return *this;
    }

    /*!
    @brief subtract from iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl& operator-=(difference_type i)
    {
        return operator+=(-i);
    }

    /*!
    @brief add to iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl operator+(difference_type i) const
    {
        auto result = *this;
        result += i;
        return result;
    }

    /*!
    @brief addition of distance and iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    friend iter_impl operator+(difference_type i, const iter_impl& it)
    {
        auto result = it;
        result += i;
        return result;
    }

    /*!
    @brief subtract from iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    iter_impl operator-(difference_type i) const
    {
        auto result = *this;
        result -= i;
        return result;
    }

    /*!
    @brief return difference
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    difference_type operator-(const iter_impl& other) const
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));

            case value_t::array:
                return m_it.array_iterator - other.m_it.array_iterator;

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
                return m_it.primitive_iterator - other.m_it.primitive_iterator;
        }
    }

    /*!
    @brief access to successor
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    reference operator[](difference_type n) const
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_data.m_type)
        {
            case value_t::object:
                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));

            case value_t::array:
                return *std::next(m_it.array_iterator, n);

            case value_t::null:
                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));

            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
                {
                    return *m_object;
                }

                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
            }
        }
    }

    /*!
    @brief return the key of an object iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    const typename object_t::key_type& key() const
    {
        JSON_ASSERT(m_object != nullptr);

        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
        {
            return m_it.object_iterator->first;
        }

        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
    }

    /*!
    @brief return the value of an iterator
    @pre The iterator is initialized; i.e. `m_object != nullptr`.
    */
    reference value() const
    {
        return operator*();
    }

  JSON_PRIVATE_UNLESS_TESTED:
    /// associated JSON instance
    pointer m_object = nullptr;
    /// the actual iterator of the associated instance
    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/iterators/iteration_proxy.hpp>

// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <cstddef> // ptrdiff_t
#include <iterator> // reverse_iterator
#include <utility> // declval

// #include <nlohmann/detail/abi_macros.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

//////////////////////
// reverse_iterator //
//////////////////////

/*!
@brief a template for a reverse iterator class

@tparam Base the base iterator type to reverse. Valid types are @ref
iterator (to create @ref reverse_iterator) and @ref const_iterator (to
create @ref const_reverse_iterator).

@requirement The class satisfies the following concept requirements:
-
[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
  The iterator that can be moved can be moved in both directions (i.e.
  incremented and decremented).
- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
  It is possible to write to the pointed-to element (only if @a Base is
  @ref iterator).

@since version 1.0.0
*/
template<typename Base>
class json_reverse_iterator : public std::reverse_iterator<Base>
{
  public:
    using difference_type = std::ptrdiff_t;
    /// shortcut to the reverse iterator adapter
    using base_iterator = std::reverse_iterator<Base>;
    /// the reference type for the pointed-to element
    using reference = typename Base::reference;

    /// create reverse iterator from iterator
    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
        : base_iterator(it) {}

    /// create reverse iterator from base class
    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}

    /// post-increment (it++)
    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
    {
        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
    }

    /// pre-increment (++it)
    json_reverse_iterator& operator++()
    {
        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
    }

    /// post-decrement (it--)
    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
    {
        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
    }

    /// pre-decrement (--it)
    json_reverse_iterator& operator--()
    {
        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
    }

    /// add to iterator
    json_reverse_iterator& operator+=(difference_type i)
    {
        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
    }

    /// add to iterator
    json_reverse_iterator operator+(difference_type i) const
    {
        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
    }

    /// subtract from iterator
    json_reverse_iterator operator-(difference_type i) const
    {
        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
    }

    /// return difference
    difference_type operator-(const json_reverse_iterator& other) const
    {
        return base_iterator(*this) - base_iterator(other);
    }

    /// access to successor
    reference operator[](difference_type n) const
    {
        return *(this->operator+(n));
    }

    /// return the key of an object iterator
    auto key() const -> decltype(std::declval<Base>().key())
    {
        auto it = --this->base();
        return it.key();
    }

    /// return the value of an iterator
    reference value() const
    {
        auto it = --this->base();
        return it.operator * ();
    }
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/iterators/primitive_iterator.hpp>

// #include <nlohmann/detail/json_custom_base_class.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <type_traits> // conditional, is_same

// #include <nlohmann/detail/abi_macros.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/*!
@brief Default base class of the @ref basic_json class.

So that the correct implementations of the copy / move ctors / assign operators
of @ref basic_json do not require complex case distinctions
(no base class / custom base class used as customization point),
@ref basic_json always has a base class.
By default, this class is used because it is empty and thus has no effect
on the behavior of @ref basic_json.
*/
struct json_default_base {};

template<class T>
using json_base_class = typename std::conditional <
                        std::is_same<T, void>::value,
                        json_default_base,
                        T
                        >::type;

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/json_pointer.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <algorithm> // all_of
#include <cctype> // isdigit
#include <cerrno> // errno, ERANGE
#include <cstdlib> // strtoull
#ifndef JSON_NO_IO
    #include <iosfwd> // ostream
#endif  // JSON_NO_IO
#include <limits> // max
#include <numeric> // accumulate
#include <string> // string
#include <utility> // move
#include <vector> // vector

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/string_concat.hpp>

// #include <nlohmann/detail/string_escape.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN

/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
/// @sa https://json.nlohmann.me/api/json_pointer/
template<typename RefStringType>
class json_pointer
{
    // allow basic_json to access private members
    NLOHMANN_BASIC_JSON_TPL_DECLARATION
    friend class basic_json;

    template<typename>
    friend class json_pointer;

    template<typename T>
    struct string_t_helper
    {
        using type = T;
    };

    NLOHMANN_BASIC_JSON_TPL_DECLARATION
    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
    {
        using type = StringType;
    };

  public:
    // for backwards compatibility accept BasicJsonType
    using string_t = typename string_t_helper<RefStringType>::type;

    /// @brief create JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
    explicit json_pointer(const string_t& s = "")
        : reference_tokens(split(s))
    {}

    /// @brief return a string representation of the JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
    string_t to_string() const
    {
        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
                               string_t{},
                               [](const string_t& a, const string_t& b)
        {
            return detail::concat(a, '/', detail::escape(b));
        });
    }

    /// @brief return a string representation of the JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
    operator string_t() const
    {
        return to_string();
    }

#ifndef JSON_NO_IO
    /// @brief write string representation of the JSON pointer to stream
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
    {
        o << ptr.to_string();
        return o;
    }
#endif

    /// @brief append another JSON pointer at the end of this JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
    json_pointer& operator/=(const json_pointer& ptr)
    {
        reference_tokens.insert(reference_tokens.end(),
                                ptr.reference_tokens.begin(),
                                ptr.reference_tokens.end());
        return *this;
    }

    /// @brief append an unescaped reference token at the end of this JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
    json_pointer& operator/=(string_t token)
    {
        push_back(std::move(token));
        return *this;
    }

    /// @brief append an array index at the end of this JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
    json_pointer& operator/=(std::size_t array_idx)
    {
        return *this /= std::to_string(array_idx);
    }

    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
    friend json_pointer operator/(const json_pointer& lhs,
                                  const json_pointer& rhs)
    {
        return json_pointer(lhs) /= rhs;
    }

    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
    {
        return json_pointer(lhs) /= std::move(token);
    }

    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
    {
        return json_pointer(lhs) /= array_idx;
    }

    /// @brief returns the parent of this JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
    json_pointer parent_pointer() const
    {
        if (empty())
        {
            return *this;
        }

        json_pointer res = *this;
        res.pop_back();
        return res;
    }

    /// @brief remove last reference token
    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
    void pop_back()
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        reference_tokens.pop_back();
    }

    /// @brief return last reference token
    /// @sa https://json.nlohmann.me/api/json_pointer/back/
    const string_t& back() const
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        return reference_tokens.back();
    }

    /// @brief append an unescaped token at the end of the reference pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
    void push_back(const string_t& token)
    {
        reference_tokens.push_back(token);
    }

    /// @brief append an unescaped token at the end of the reference pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
    void push_back(string_t&& token)
    {
        reference_tokens.push_back(std::move(token));
    }

    /// @brief return whether pointer points to the root document
    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
    bool empty() const noexcept
    {
        return reference_tokens.empty();
    }

  private:
    /*!
    @param[in] s  reference token to be converted into an array index

    @return integer representation of @a s

    @throw parse_error.106  if an array index begins with '0'
    @throw parse_error.109  if an array index begins not with a digit
    @throw out_of_range.404 if string @a s could not be converted to an integer
    @throw out_of_range.410 if an array index exceeds size_type
    */
    template<typename BasicJsonType>
    static typename BasicJsonType::size_type array_index(const string_t& s)
    {
        using size_type = typename BasicJsonType::size_type;

        // error condition (cf. RFC 6901, Sect. 4)
        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
        {
            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
        }

        // error condition (cf. RFC 6901, Sect. 4)
        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
        {
            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
        }

        const char* p = s.c_str();
        char* p_end = nullptr;
        errno = 0; // strtoull doesn't reset errno
        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
        if (p == p_end // invalid input or empty string
                || errno == ERANGE // out of range
                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
        {
            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
        }

        // only triggered on special platforms (like 32bit), see also
        // https://github.com/nlohmann/json/pull/2203
        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
        {
            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
        }

        return static_cast<size_type>(res);
    }

  JSON_PRIVATE_UNLESS_TESTED:
    json_pointer top() const
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        json_pointer result = *this;
        result.reference_tokens = {reference_tokens[0]};
        return result;
    }

  private:
    /*!
    @brief create and return a reference to the pointed to value

    @complexity Linear in the number of reference tokens.

    @throw parse_error.109 if array index is not a number
    @throw type_error.313 if value cannot be unflattened
    */
    template<typename BasicJsonType>
    BasicJsonType& get_and_create(BasicJsonType& j) const
    {
        auto* result = &j;

        // in case no reference tokens exist, return a reference to the JSON value
        // j which will be overwritten by a primitive value
        for (const auto& reference_token : reference_tokens)
        {
            switch (result->type())
            {
                case detail::value_t::null:
                {
                    if (reference_token == "0")
                    {
                        // start a new array if reference token is 0
                        result = &result->operator[](0);
                    }
                    else
                    {
                        // start a new object otherwise
                        result = &result->operator[](reference_token);
                    }
                    break;
                }

                case detail::value_t::object:
                {
                    // create an entry in the object
                    result = &result->operator[](reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    // create an entry in the array
                    result = &result->operator[](array_index<BasicJsonType>(reference_token));
                    break;
                }

                /*
                The following code is only reached if there exists a reference
                token _and_ the current value is primitive. In this case, we have
                an error situation, because primitive values may only occur as
                single value; that is, with an empty list of reference tokens.
                */
                case detail::value_t::string:
                case detail::value_t::boolean:
                case detail::value_t::number_integer:
                case detail::value_t::number_unsigned:
                case detail::value_t::number_float:
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
            }
        }

        return *result;
    }

    /*!
    @brief return a reference to the pointed to value

    @note This version does not throw if a value is not present, but tries to
          create nested values instead. For instance, calling this function
          with pointer `"/this/that"` on a null value is equivalent to calling
          `operator[]("this").operator[]("that")` on that value, effectively
          changing the null value to an object.

    @param[in] ptr  a JSON value

    @return reference to the JSON value pointed to by the JSON pointer

    @complexity Linear in the length of the JSON pointer.

    @throw parse_error.106   if an array index begins with '0'
    @throw parse_error.109   if an array index was not a number
    @throw out_of_range.404  if the JSON pointer can not be resolved
    */
    template<typename BasicJsonType>
    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
    {
        for (const auto& reference_token : reference_tokens)
        {
            // convert null values to arrays or objects before continuing
            if (ptr->is_null())
            {
                // check if reference token is a number
                const bool nums =
                    std::all_of(reference_token.begin(), reference_token.end(),
                                [](const unsigned char x)
                {
                    return std::isdigit(x);
                });

                // change value to array for numbers or "-" or to object otherwise
                *ptr = (nums || reference_token == "-")
                       ? detail::value_t::array
                       : detail::value_t::object;
            }

            switch (ptr->type())
            {
                case detail::value_t::object:
                {
                    // use unchecked object access
                    ptr = &ptr->operator[](reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (reference_token == "-")
                    {
                        // explicitly treat "-" as index beyond the end
                        ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
                    }
                    else
                    {
                        // convert array index to number; unchecked access
                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
                    }
                    break;
                }

                case detail::value_t::null:
                case detail::value_t::string:
                case detail::value_t::boolean:
                case detail::value_t::number_integer:
                case detail::value_t::number_unsigned:
                case detail::value_t::number_float:
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
            }
        }

        return *ptr;
    }

    /*!
    @throw parse_error.106   if an array index begins with '0'
    @throw parse_error.109   if an array index was not a number
    @throw out_of_range.402  if the array index '-' is used
    @throw out_of_range.404  if the JSON pointer can not be resolved
    */
    template<typename BasicJsonType>
    BasicJsonType& get_checked(BasicJsonType* ptr) const
    {
        for (const auto& reference_token : reference_tokens)
        {
            switch (ptr->type())
            {
                case detail::value_t::object:
                {
                    // note: at performs range check
                    ptr = &ptr->at(reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
                    {
                        // "-" always fails the range check
                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
                                ") is out of range"), ptr));
                    }

                    // note: at performs range check
                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
                    break;
                }

                case detail::value_t::null:
                case detail::value_t::string:
                case detail::value_t::boolean:
                case detail::value_t::number_integer:
                case detail::value_t::number_unsigned:
                case detail::value_t::number_float:
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
            }
        }

        return *ptr;
    }

    /*!
    @brief return a const reference to the pointed to value

    @param[in] ptr  a JSON value

    @return const reference to the JSON value pointed to by the JSON
    pointer

    @throw parse_error.106   if an array index begins with '0'
    @throw parse_error.109   if an array index was not a number
    @throw out_of_range.402  if the array index '-' is used
    @throw out_of_range.404  if the JSON pointer can not be resolved
    */
    template<typename BasicJsonType>
    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
    {
        for (const auto& reference_token : reference_tokens)
        {
            switch (ptr->type())
            {
                case detail::value_t::object:
                {
                    // use unchecked object access
                    ptr = &ptr->operator[](reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
                    {
                        // "-" cannot be used for const access
                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
                    }

                    // use unchecked array access
                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
                    break;
                }

                case detail::value_t::null:
                case detail::value_t::string:
                case detail::value_t::boolean:
                case detail::value_t::number_integer:
                case detail::value_t::number_unsigned:
                case detail::value_t::number_float:
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
            }
        }

        return *ptr;
    }

    /*!
    @throw parse_error.106   if an array index begins with '0'
    @throw parse_error.109   if an array index was not a number
    @throw out_of_range.402  if the array index '-' is used
    @throw out_of_range.404  if the JSON pointer can not be resolved
    */
    template<typename BasicJsonType>
    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
    {
        for (const auto& reference_token : reference_tokens)
        {
            switch (ptr->type())
            {
                case detail::value_t::object:
                {
                    // note: at performs range check
                    ptr = &ptr->at(reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
                    {
                        // "-" always fails the range check
                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
                                ") is out of range"), ptr));
                    }

                    // note: at performs range check
                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
                    break;
                }

                case detail::value_t::null:
                case detail::value_t::string:
                case detail::value_t::boolean:
                case detail::value_t::number_integer:
                case detail::value_t::number_unsigned:
                case detail::value_t::number_float:
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
            }
        }

        return *ptr;
    }

    /*!
    @throw parse_error.106   if an array index begins with '0'
    @throw parse_error.109   if an array index was not a number
    */
    template<typename BasicJsonType>
    bool contains(const BasicJsonType* ptr) const
    {
        for (const auto& reference_token : reference_tokens)
        {
            switch (ptr->type())
            {
                case detail::value_t::object:
                {
                    if (!ptr->contains(reference_token))
                    {
                        // we did not find the key in the object
                        return false;
                    }

                    ptr = &ptr->operator[](reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
                    {
                        // "-" always fails the range check
                        return false;
                    }
                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
                    {
                        // invalid char
                        return false;
                    }
                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
                    {
                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
                        {
                            // first char should be between '1' and '9'
                            return false;
                        }
                        for (std::size_t i = 1; i < reference_token.size(); i++)
                        {
                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
                            {
                                // other char should be between '0' and '9'
                                return false;
                            }
                        }
                    }

                    const auto idx = array_index<BasicJsonType>(reference_token);
                    if (idx >= ptr->size())
                    {
                        // index out of range
                        return false;
                    }

                    ptr = &ptr->operator[](idx);
                    break;
                }

                case detail::value_t::null:
                case detail::value_t::string:
                case detail::value_t::boolean:
                case detail::value_t::number_integer:
                case detail::value_t::number_unsigned:
                case detail::value_t::number_float:
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
                {
                    // we do not expect primitive values if there is still a
                    // reference token to process
                    return false;
                }
            }
        }

        // no reference token left means we found a primitive value
        return true;
    }

    /*!
    @brief split the string input to reference tokens

    @note This function is only called by the json_pointer constructor.
          All exceptions below are documented there.

    @throw parse_error.107  if the pointer is not empty or begins with '/'
    @throw parse_error.108  if character '~' is not followed by '0' or '1'
    */
    static std::vector<string_t> split(const string_t& reference_string)
    {
        std::vector<string_t> result;

        // special case: empty reference string -> no reference tokens
        if (reference_string.empty())
        {
            return result;
        }

        // check if nonempty reference string begins with slash
        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
        {
            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
        }

        // extract the reference tokens:
        // - slash: position of the last read slash (or end of string)
        // - start: position after the previous slash
        for (
            // search for the first slash after the first character
            std::size_t slash = reference_string.find_first_of('/', 1),
            // set the beginning of the first reference token
            start = 1;
            // we can stop if start == 0 (if slash == string_t::npos)
            start != 0;
            // set the beginning of the next reference token
            // (will eventually be 0 if slash == string_t::npos)
            start = (slash == string_t::npos) ? 0 : slash + 1,
            // find next slash
            slash = reference_string.find_first_of('/', start))
        {
            // use the text between the beginning of the reference token
            // (start) and the last slash (slash).
            auto reference_token = reference_string.substr(start, slash - start);

            // check reference tokens are properly escaped
            for (std::size_t pos = reference_token.find_first_of('~');
                    pos != string_t::npos;
                    pos = reference_token.find_first_of('~', pos + 1))
            {
                JSON_ASSERT(reference_token[pos] == '~');

                // ~ must be followed by 0 or 1
                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
                                         (reference_token[pos + 1] != '0' &&
                                          reference_token[pos + 1] != '1')))
                {
                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
                }
            }

            // finally, store the reference token
            detail::unescape(reference_token);
            result.push_back(reference_token);
        }

        return result;
    }

  private:
    /*!
    @param[in] reference_string  the reference string to the current value
    @param[in] value             the value to consider
    @param[in,out] result        the result object to insert values to

    @note Empty objects or arrays are flattened to `null`.
    */
    template<typename BasicJsonType>
    static void flatten(const string_t& reference_string,
                        const BasicJsonType& value,
                        BasicJsonType& result)
    {
        switch (value.type())
        {
            case detail::value_t::array:
            {
                if (value.m_data.m_value.array->empty())
                {
                    // flatten empty array as null
                    result[reference_string] = nullptr;
                }
                else
                {
                    // iterate array and use index as reference string
                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
                    {
                        flatten(detail::concat(reference_string, '/', std::to_string(i)),
                                value.m_data.m_value.array->operator[](i), result);
                    }
                }
                break;
            }

            case detail::value_t::object:
            {
                if (value.m_data.m_value.object->empty())
                {
                    // flatten empty object as null
                    result[reference_string] = nullptr;
                }
                else
                {
                    // iterate object and use keys as reference string
                    for (const auto& element : *value.m_data.m_value.object)
                    {
                        flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);
                    }
                }
                break;
            }

            case detail::value_t::null:
            case detail::value_t::string:
            case detail::value_t::boolean:
            case detail::value_t::number_integer:
            case detail::value_t::number_unsigned:
            case detail::value_t::number_float:
            case detail::value_t::binary:
            case detail::value_t::discarded:
            default:
            {
                // add primitive value with its reference string
                result[reference_string] = value;
                break;
            }
        }
    }

    /*!
    @param[in] value  flattened JSON

    @return unflattened JSON

    @throw parse_error.109 if array index is not a number
    @throw type_error.314  if value is not an object
    @throw type_error.315  if object values are not primitive
    @throw type_error.313  if value cannot be unflattened
    */
    template<typename BasicJsonType>
    static BasicJsonType
    unflatten(const BasicJsonType& value)
    {
        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
        {
            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
        }

        BasicJsonType result;

        // iterate the JSON object values
        for (const auto& element : *value.m_data.m_value.object)
        {
            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
            {
                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
            }

            // assign value to reference pointed to by JSON pointer; Note that if
            // the JSON pointer is "" (i.e., points to the whole value), function
            // get_and_create returns a reference to result itself. An assignment
            // will then create a primitive value.
            json_pointer(element.first).get_and_create(result) = element.second;
        }

        return result;
    }

    // can't use conversion operator because of ambiguity
    json_pointer<string_t> convert() const&
    {
        json_pointer<string_t> result;
        result.reference_tokens = reference_tokens;
        return result;
    }

    json_pointer<string_t> convert()&&
    {
        json_pointer<string_t> result;
        result.reference_tokens = std::move(reference_tokens);
        return result;
    }

  public:
#if JSON_HAS_THREE_WAY_COMPARISON
    /// @brief compares two JSON pointers for equality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    template<typename RefStringTypeRhs>
    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
    {
        return reference_tokens == rhs.reference_tokens;
    }

    /// @brief compares JSON pointer and string for equality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
    bool operator==(const string_t& rhs) const
    {
        return *this == json_pointer(rhs);
    }

    /// @brief 3-way compares two JSON pointers
    template<typename RefStringTypeRhs>
    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
    {
        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*
    }
#else
    /// @brief compares two JSON pointers for equality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
    // NOLINTNEXTLINE(readability-redundant-declaration)
    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;

    /// @brief compares JSON pointer and string for equality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    template<typename RefStringTypeLhs, typename StringType>
    // NOLINTNEXTLINE(readability-redundant-declaration)
    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                           const StringType& rhs);

    /// @brief compares string and JSON pointer for equality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    template<typename RefStringTypeRhs, typename StringType>
    // NOLINTNEXTLINE(readability-redundant-declaration)
    friend bool operator==(const StringType& lhs,
                           const json_pointer<RefStringTypeRhs>& rhs);

    /// @brief compares two JSON pointers for inequality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
    // NOLINTNEXTLINE(readability-redundant-declaration)
    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;

    /// @brief compares JSON pointer and string for inequality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
    template<typename RefStringTypeLhs, typename StringType>
    // NOLINTNEXTLINE(readability-redundant-declaration)
    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                           const StringType& rhs);

    /// @brief compares string and JSON pointer for inequality
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
    template<typename RefStringTypeRhs, typename StringType>
    // NOLINTNEXTLINE(readability-redundant-declaration)
    friend bool operator!=(const StringType& lhs,
                           const json_pointer<RefStringTypeRhs>& rhs);

    /// @brief compares two JSON pointer for less-than
    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
    // NOLINTNEXTLINE(readability-redundant-declaration)
    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;
#endif

  private:
    /// the reference tokens
    std::vector<string_t> reference_tokens;
};

#if !JSON_HAS_THREE_WAY_COMPARISON
// functions cannot be defined inside class due to ODR violations
template<typename RefStringTypeLhs, typename RefStringTypeRhs>
inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
{
    return lhs.reference_tokens == rhs.reference_tokens;
}

template<typename RefStringTypeLhs,
         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
{
    return lhs == json_pointer<RefStringTypeLhs>(rhs);
}

template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
inline bool operator==(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
{
    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
}

template<typename RefStringTypeLhs, typename RefStringTypeRhs>
inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
{
    return !(lhs == rhs);
}

template<typename RefStringTypeLhs,
         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
{
    return !(lhs == rhs);
}

template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
inline bool operator!=(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
{
    return !(lhs == rhs);
}

template<typename RefStringTypeLhs, typename RefStringTypeRhs>
inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
                      const json_pointer<RefStringTypeRhs>& rhs) noexcept
{
    return lhs.reference_tokens < rhs.reference_tokens;
}
#endif

NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/json_ref.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <initializer_list>
#include <utility>

// #include <nlohmann/detail/abi_macros.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

template<typename BasicJsonType>
class json_ref
{
  public:
    using value_type = BasicJsonType;

    json_ref(value_type&& value)
        : owned_value(std::move(value))
    {}

    json_ref(const value_type& value)
        : value_ref(&value)
    {}

    json_ref(std::initializer_list<json_ref> init)
        : owned_value(init)
    {}

    template <
        class... Args,
        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
    json_ref(Args && ... args)
        : owned_value(std::forward<Args>(args)...)
    {}

    // class should be movable only
    json_ref(json_ref&&) noexcept = default;
    json_ref(const json_ref&) = delete;
    json_ref& operator=(const json_ref&) = delete;
    json_ref& operator=(json_ref&&) = delete;
    ~json_ref() = default;

    value_type moved_or_copied() const
    {
        if (value_ref == nullptr)
        {
            return std::move(owned_value);
        }
        return *value_ref;
    }

    value_type const& operator*() const
    {
        return value_ref ? *value_ref : owned_value;
    }

    value_type const* operator->() const
    {
        return &** this;
    }

  private:
    mutable value_type owned_value = nullptr;
    value_type const* value_ref = nullptr;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/string_concat.hpp>

// #include <nlohmann/detail/string_escape.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/output/binary_writer.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <algorithm> // reverse
#include <array> // array
#include <map> // map
#include <cmath> // isnan, isinf
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
#include <cstring> // memcpy
#include <limits> // numeric_limits
#include <string> // string
#include <utility> // move
#include <vector> // vector

// #include <nlohmann/detail/input/binary_reader.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/output/output_adapters.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <algorithm> // copy
#include <cstddef> // size_t
#include <iterator> // back_inserter
#include <memory> // shared_ptr, make_shared
#include <string> // basic_string
#include <vector> // vector

#ifndef JSON_NO_IO
    #include <ios>      // streamsize
    #include <ostream>  // basic_ostream
#endif  // JSON_NO_IO

// #include <nlohmann/detail/macro_scope.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/// abstract output adapter interface
template<typename CharType> struct output_adapter_protocol
{
    virtual void write_character(CharType c) = 0;
    virtual void write_characters(const CharType* s, std::size_t length) = 0;
    virtual ~output_adapter_protocol() = default;

    output_adapter_protocol() = default;
    output_adapter_protocol(const output_adapter_protocol&) = default;
    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
};

/// a type to simplify interfaces
template<typename CharType>
using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;

/// output adapter for byte vectors
template<typename CharType, typename AllocatorType = std::allocator<CharType>>
class output_vector_adapter : public output_adapter_protocol<CharType>
{
  public:
    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
        : v(vec)
    {}

    void write_character(CharType c) override
    {
        v.push_back(c);
    }

    JSON_HEDLEY_NON_NULL(2)
    void write_characters(const CharType* s, std::size_t length) override
    {
        v.insert(v.end(), s, s + length);
    }

  private:
    std::vector<CharType, AllocatorType>& v;
};

#ifndef JSON_NO_IO
/// output adapter for output streams
template<typename CharType>
class output_stream_adapter : public output_adapter_protocol<CharType>
{
  public:
    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
        : stream(s)
    {}

    void write_character(CharType c) override
    {
        stream.put(c);
    }

    JSON_HEDLEY_NON_NULL(2)
    void write_characters(const CharType* s, std::size_t length) override
    {
        stream.write(s, static_cast<std::streamsize>(length));
    }

  private:
    std::basic_ostream<CharType>& stream;
};
#endif  // JSON_NO_IO

/// output adapter for basic_string
template<typename CharType, typename StringType = std::basic_string<CharType>>
class output_string_adapter : public output_adapter_protocol<CharType>
{
  public:
    explicit output_string_adapter(StringType& s) noexcept
        : str(s)
    {}

    void write_character(CharType c) override
    {
        str.push_back(c);
    }

    JSON_HEDLEY_NON_NULL(2)
    void write_characters(const CharType* s, std::size_t length) override
    {
        str.append(s, length);
    }

  private:
    StringType& str;
};

template<typename CharType, typename StringType = std::basic_string<CharType>>
class output_adapter
{
  public:
    template<typename AllocatorType = std::allocator<CharType>>
    output_adapter(std::vector<CharType, AllocatorType>& vec)
        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}

#ifndef JSON_NO_IO
    output_adapter(std::basic_ostream<CharType>& s)
        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
#endif  // JSON_NO_IO

    output_adapter(StringType& s)
        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}

    operator output_adapter_t<CharType>()
    {
        return oa;
    }

  private:
    output_adapter_t<CharType> oa = nullptr;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/string_concat.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

///////////////////
// binary writer //
///////////////////

/*!
@brief serialization to CBOR and MessagePack values
*/
template<typename BasicJsonType, typename CharType>
class binary_writer
{
    using string_t = typename BasicJsonType::string_t;
    using binary_t = typename BasicJsonType::binary_t;
    using number_float_t = typename BasicJsonType::number_float_t;

  public:
    /*!
    @brief create a binary writer

    @param[in] adapter  output adapter to write to
    */
    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
    {
        JSON_ASSERT(oa);
    }

    /*!
    @param[in] j  JSON value to serialize
    @pre       j.type() == value_t::object
    */
    void write_bson(const BasicJsonType& j)
    {
        switch (j.type())
        {
            case value_t::object:
            {
                write_bson_object(*j.m_data.m_value.object);
                break;
            }

            case value_t::null:
            case value_t::array:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
            }
        }
    }

    /*!
    @param[in] j  JSON value to serialize
    */
    void write_cbor(const BasicJsonType& j)
    {
        switch (j.type())
        {
            case value_t::null:
            {
                oa->write_character(to_char_type(0xF6));
                break;
            }

            case value_t::boolean:
            {
                oa->write_character(j.m_data.m_value.boolean
                                    ? to_char_type(0xF5)
                                    : to_char_type(0xF4));
                break;
            }

            case value_t::number_integer:
            {
                if (j.m_data.m_value.number_integer >= 0)
                {
                    // CBOR does not differentiate between positive signed
                    // integers and unsigned integers. Therefore, we used the
                    // code from the value_t::number_unsigned case here.
                    if (j.m_data.m_value.number_integer <= 0x17)
                    {
                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
                    {
                        oa->write_character(to_char_type(0x18));
                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
                    {
                        oa->write_character(to_char_type(0x19));
                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
                    {
                        oa->write_character(to_char_type(0x1A));
                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
                    }
                    else
                    {
                        oa->write_character(to_char_type(0x1B));
                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
                    }
                }
                else
                {
                    // The conversions below encode the sign in the first
                    // byte, and the value is converted to a positive number.
                    const auto positive_number = -1 - j.m_data.m_value.number_integer;
                    if (j.m_data.m_value.number_integer >= -24)
                    {
                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
                    }
                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
                    {
                        oa->write_character(to_char_type(0x38));
                        write_number(static_cast<std::uint8_t>(positive_number));
                    }
                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
                    {
                        oa->write_character(to_char_type(0x39));
                        write_number(static_cast<std::uint16_t>(positive_number));
                    }
                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
                    {
                        oa->write_character(to_char_type(0x3A));
                        write_number(static_cast<std::uint32_t>(positive_number));
                    }
                    else
                    {
                        oa->write_character(to_char_type(0x3B));
                        write_number(static_cast<std::uint64_t>(positive_number));
                    }
                }
                break;
            }

            case value_t::number_unsigned:
            {
                if (j.m_data.m_value.number_unsigned <= 0x17)
                {
                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
                }
                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    oa->write_character(to_char_type(0x18));
                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
                }
                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    oa->write_character(to_char_type(0x19));
                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
                }
                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    oa->write_character(to_char_type(0x1A));
                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
                }
                else
                {
                    oa->write_character(to_char_type(0x1B));
                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                }
                break;
            }

            case value_t::number_float:
            {
                if (std::isnan(j.m_data.m_value.number_float))
                {
                    // NaN is 0xf97e00 in CBOR
                    oa->write_character(to_char_type(0xF9));
                    oa->write_character(to_char_type(0x7E));
                    oa->write_character(to_char_type(0x00));
                }
                else if (std::isinf(j.m_data.m_value.number_float))
                {
                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
                    oa->write_character(to_char_type(0xf9));
                    oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
                    oa->write_character(to_char_type(0x00));
                }
                else
                {
                    write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
                }
                break;
            }

            case value_t::string:
            {
                // step 1: write control byte and the string length
                const auto N = j.m_data.m_value.string->size();
                if (N <= 0x17)
                {
                    write_number(static_cast<std::uint8_t>(0x60 + N));
                }
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    oa->write_character(to_char_type(0x78));
                    write_number(static_cast<std::uint8_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    oa->write_character(to_char_type(0x79));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    oa->write_character(to_char_type(0x7A));
                    write_number(static_cast<std::uint32_t>(N));
                }
                // LCOV_EXCL_START
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
                {
                    oa->write_character(to_char_type(0x7B));
                    write_number(static_cast<std::uint64_t>(N));
                }
                // LCOV_EXCL_STOP

                // step 2: write the string
                oa->write_characters(
                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }

            case value_t::array:
            {
                // step 1: write control byte and the array size
                const auto N = j.m_data.m_value.array->size();
                if (N <= 0x17)
                {
                    write_number(static_cast<std::uint8_t>(0x80 + N));
                }
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    oa->write_character(to_char_type(0x98));
                    write_number(static_cast<std::uint8_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    oa->write_character(to_char_type(0x99));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    oa->write_character(to_char_type(0x9A));
                    write_number(static_cast<std::uint32_t>(N));
                }
                // LCOV_EXCL_START
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
                {
                    oa->write_character(to_char_type(0x9B));
                    write_number(static_cast<std::uint64_t>(N));
                }
                // LCOV_EXCL_STOP

                // step 2: write each element
                for (const auto& el : *j.m_data.m_value.array)
                {
                    write_cbor(el);
                }
                break;
            }

            case value_t::binary:
            {
                if (j.m_data.m_value.binary->has_subtype())
                {
                    if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
                    {
                        write_number(static_cast<std::uint8_t>(0xd8));
                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
                    }
                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
                    {
                        write_number(static_cast<std::uint8_t>(0xd9));
                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
                    }
                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
                    {
                        write_number(static_cast<std::uint8_t>(0xda));
                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
                    }
                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
                    {
                        write_number(static_cast<std::uint8_t>(0xdb));
                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
                    }
                }

                // step 1: write control byte and the binary array size
                const auto N = j.m_data.m_value.binary->size();
                if (N <= 0x17)
                {
                    write_number(static_cast<std::uint8_t>(0x40 + N));
                }
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    oa->write_character(to_char_type(0x58));
                    write_number(static_cast<std::uint8_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    oa->write_character(to_char_type(0x59));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    oa->write_character(to_char_type(0x5A));
                    write_number(static_cast<std::uint32_t>(N));
                }
                // LCOV_EXCL_START
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
                {
                    oa->write_character(to_char_type(0x5B));
                    write_number(static_cast<std::uint64_t>(N));
                }
                // LCOV_EXCL_STOP

                // step 2: write each element
                oa->write_characters(
                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
                    N);

                break;
            }

            case value_t::object:
            {
                // step 1: write control byte and the object size
                const auto N = j.m_data.m_value.object->size();
                if (N <= 0x17)
                {
                    write_number(static_cast<std::uint8_t>(0xA0 + N));
                }
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    oa->write_character(to_char_type(0xB8));
                    write_number(static_cast<std::uint8_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    oa->write_character(to_char_type(0xB9));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    oa->write_character(to_char_type(0xBA));
                    write_number(static_cast<std::uint32_t>(N));
                }
                // LCOV_EXCL_START
                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
                {
                    oa->write_character(to_char_type(0xBB));
                    write_number(static_cast<std::uint64_t>(N));
                }
                // LCOV_EXCL_STOP

                // step 2: write each element
                for (const auto& el : *j.m_data.m_value.object)
                {
                    write_cbor(el.first);
                    write_cbor(el.second);
                }
                break;
            }

            case value_t::discarded:
            default:
                break;
        }
    }

    /*!
    @param[in] j  JSON value to serialize
    */
    void write_msgpack(const BasicJsonType& j)
    {
        switch (j.type())
        {
            case value_t::null: // nil
            {
                oa->write_character(to_char_type(0xC0));
                break;
            }

            case value_t::boolean: // true and false
            {
                oa->write_character(j.m_data.m_value.boolean
                                    ? to_char_type(0xC3)
                                    : to_char_type(0xC2));
                break;
            }

            case value_t::number_integer:
            {
                if (j.m_data.m_value.number_integer >= 0)
                {
                    // MessagePack does not differentiate between positive
                    // signed integers and unsigned integers. Therefore, we used
                    // the code from the value_t::number_unsigned case here.
                    if (j.m_data.m_value.number_unsigned < 128)
                    {
                        // positive fixnum
                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
                    {
                        // uint 8
                        oa->write_character(to_char_type(0xCC));
                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
                    {
                        // uint 16
                        oa->write_character(to_char_type(0xCD));
                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
                    {
                        // uint 32
                        oa->write_character(to_char_type(0xCE));
                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
                    {
                        // uint 64
                        oa->write_character(to_char_type(0xCF));
                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
                    }
                }
                else
                {
                    if (j.m_data.m_value.number_integer >= -32)
                    {
                        // negative fixnum
                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
                    {
                        // int 8
                        oa->write_character(to_char_type(0xD0));
                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
                    {
                        // int 16
                        oa->write_character(to_char_type(0xD1));
                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
                    {
                        // int 32
                        oa->write_character(to_char_type(0xD2));
                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
                    }
                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
                    {
                        // int 64
                        oa->write_character(to_char_type(0xD3));
                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
                    }
                }
                break;
            }

            case value_t::number_unsigned:
            {
                if (j.m_data.m_value.number_unsigned < 128)
                {
                    // positive fixnum
                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
                }
                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    // uint 8
                    oa->write_character(to_char_type(0xCC));
                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
                }
                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    // uint 16
                    oa->write_character(to_char_type(0xCD));
                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
                }
                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    // uint 32
                    oa->write_character(to_char_type(0xCE));
                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
                }
                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
                {
                    // uint 64
                    oa->write_character(to_char_type(0xCF));
                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
                }
                break;
            }

            case value_t::number_float:
            {
                write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
                break;
            }

            case value_t::string:
            {
                // step 1: write control byte and the string length
                const auto N = j.m_data.m_value.string->size();
                if (N <= 31)
                {
                    // fixstr
                    write_number(static_cast<std::uint8_t>(0xA0 | N));
                }
                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    // str 8
                    oa->write_character(to_char_type(0xD9));
                    write_number(static_cast<std::uint8_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    // str 16
                    oa->write_character(to_char_type(0xDA));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    // str 32
                    oa->write_character(to_char_type(0xDB));
                    write_number(static_cast<std::uint32_t>(N));
                }

                // step 2: write the string
                oa->write_characters(
                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }

            case value_t::array:
            {
                // step 1: write control byte and the array size
                const auto N = j.m_data.m_value.array->size();
                if (N <= 15)
                {
                    // fixarray
                    write_number(static_cast<std::uint8_t>(0x90 | N));
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    // array 16
                    oa->write_character(to_char_type(0xDC));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    // array 32
                    oa->write_character(to_char_type(0xDD));
                    write_number(static_cast<std::uint32_t>(N));
                }

                // step 2: write each element
                for (const auto& el : *j.m_data.m_value.array)
                {
                    write_msgpack(el);
                }
                break;
            }

            case value_t::binary:
            {
                // step 0: determine if the binary type has a set subtype to
                // determine whether or not to use the ext or fixext types
                const bool use_ext = j.m_data.m_value.binary->has_subtype();

                // step 1: write control byte and the byte string length
                const auto N = j.m_data.m_value.binary->size();
                if (N <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    std::uint8_t output_type{};
                    bool fixed = true;
                    if (use_ext)
                    {
                        switch (N)
                        {
                            case 1:
                                output_type = 0xD4; // fixext 1
                                break;
                            case 2:
                                output_type = 0xD5; // fixext 2
                                break;
                            case 4:
                                output_type = 0xD6; // fixext 4
                                break;
                            case 8:
                                output_type = 0xD7; // fixext 8
                                break;
                            case 16:
                                output_type = 0xD8; // fixext 16
                                break;
                            default:
                                output_type = 0xC7; // ext 8
                                fixed = false;
                                break;
                        }

                    }
                    else
                    {
                        output_type = 0xC4; // bin 8
                        fixed = false;
                    }

                    oa->write_character(to_char_type(output_type));
                    if (!fixed)
                    {
                        write_number(static_cast<std::uint8_t>(N));
                    }
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    const std::uint8_t output_type = use_ext
                                                     ? 0xC8 // ext 16
                                                     : 0xC5; // bin 16

                    oa->write_character(to_char_type(output_type));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    const std::uint8_t output_type = use_ext
                                                     ? 0xC9 // ext 32
                                                     : 0xC6; // bin 32

                    oa->write_character(to_char_type(output_type));
                    write_number(static_cast<std::uint32_t>(N));
                }

                // step 1.5: if this is an ext type, write the subtype
                if (use_ext)
                {
                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
                }

                // step 2: write the byte string
                oa->write_characters(
                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
                    N);

                break;
            }

            case value_t::object:
            {
                // step 1: write control byte and the object size
                const auto N = j.m_data.m_value.object->size();
                if (N <= 15)
                {
                    // fixmap
                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
                }
                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
                {
                    // map 16
                    oa->write_character(to_char_type(0xDE));
                    write_number(static_cast<std::uint16_t>(N));
                }
                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
                {
                    // map 32
                    oa->write_character(to_char_type(0xDF));
                    write_number(static_cast<std::uint32_t>(N));
                }

                // step 2: write each element
                for (const auto& el : *j.m_data.m_value.object)
                {
                    write_msgpack(el.first);
                    write_msgpack(el.second);
                }
                break;
            }

            case value_t::discarded:
            default:
                break;
        }
    }

    /*!
    @param[in] j  JSON value to serialize
    @param[in] use_count   whether to use '#' prefixes (optimized format)
    @param[in] use_type    whether to use '$' prefixes (optimized format)
    @param[in] add_prefix  whether prefixes need to be used for this value
    @param[in] use_bjdata  whether write in BJData format, default is false
    */
    void write_ubjson(const BasicJsonType& j, const bool use_count,
                      const bool use_type, const bool add_prefix = true,
                      const bool use_bjdata = false)
    {
        switch (j.type())
        {
            case value_t::null:
            {
                if (add_prefix)
                {
                    oa->write_character(to_char_type('Z'));
                }
                break;
            }

            case value_t::boolean:
            {
                if (add_prefix)
                {
                    oa->write_character(j.m_data.m_value.boolean
                                        ? to_char_type('T')
                                        : to_char_type('F'));
                }
                break;
            }

            case value_t::number_integer:
            {
                write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
                break;
            }

            case value_t::number_unsigned:
            {
                write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
                break;
            }

            case value_t::number_float:
            {
                write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
                break;
            }

            case value_t::string:
            {
                if (add_prefix)
                {
                    oa->write_character(to_char_type('S'));
                }
                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
                oa->write_characters(
                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }

            case value_t::array:
            {
                if (add_prefix)
                {
                    oa->write_character(to_char_type('['));
                }

                bool prefix_required = true;
                if (use_type && !j.m_data.m_value.array->empty())
                {
                    JSON_ASSERT(use_count);
                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
                    {
                        return ubjson_prefix(v, use_bjdata) == first_prefix;
                    });

                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type

                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
                    {
                        prefix_required = false;
                        oa->write_character(to_char_type('$'));
                        oa->write_character(first_prefix);
                    }
                }

                if (use_count)
                {
                    oa->write_character(to_char_type('#'));
                    write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
                }

                for (const auto& el : *j.m_data.m_value.array)
                {
                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);
                }

                if (!use_count)
                {
                    oa->write_character(to_char_type(']'));
                }

                break;
            }

            case value_t::binary:
            {
                if (add_prefix)
                {
                    oa->write_character(to_char_type('['));
                }

                if (use_type && !j.m_data.m_value.binary->empty())
                {
                    JSON_ASSERT(use_count);
                    oa->write_character(to_char_type('$'));
                    oa->write_character('U');
                }

                if (use_count)
                {
                    oa->write_character(to_char_type('#'));
                    write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
                }

                if (use_type)
                {
                    oa->write_characters(
                        reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
                        j.m_data.m_value.binary->size());
                }
                else
                {
                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
                    {
                        oa->write_character(to_char_type('U'));
                        oa->write_character(j.m_data.m_value.binary->data()[i]);
                    }
                }

                if (!use_count)
                {
                    oa->write_character(to_char_type(']'));
                }

                break;
            }

            case value_t::object:
            {
                if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end())
                {
                    if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
                    {
                        break;
                    }
                }

                if (add_prefix)
                {
                    oa->write_character(to_char_type('{'));
                }

                bool prefix_required = true;
                if (use_type && !j.m_data.m_value.object->empty())
                {
                    JSON_ASSERT(use_count);
                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
                    const bool same_prefix = std::all_of(j.begin(), j.end(),
                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
                    {
                        return ubjson_prefix(v, use_bjdata) == first_prefix;
                    });

                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type

                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
                    {
                        prefix_required = false;
                        oa->write_character(to_char_type('$'));
                        oa->write_character(first_prefix);
                    }
                }

                if (use_count)
                {
                    oa->write_character(to_char_type('#'));
                    write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
                }

                for (const auto& el : *j.m_data.m_value.object)
                {
                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
                    oa->write_characters(
                        reinterpret_cast<const CharType*>(el.first.c_str()),
                        el.first.size());
                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata);
                }

                if (!use_count)
                {
                    oa->write_character(to_char_type('}'));
                }

                break;
            }

            case value_t::discarded:
            default:
                break;
        }
    }

  private:
    //////////
    // BSON //
    //////////

    /*!
    @return The size of a BSON document entry header, including the id marker
            and the entry name size (and its null-terminator).
    */
    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
    {
        const auto it = name.find(static_cast<typename string_t::value_type>(0));
        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
        {
            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
            static_cast<void>(j);
        }

        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
    }

    /*!
    @brief Writes the given @a element_type and @a name to the output adapter
    */
    void write_bson_entry_header(const string_t& name,
                                 const std::uint8_t element_type)
    {
        oa->write_character(to_char_type(element_type)); // boolean
        oa->write_characters(
            reinterpret_cast<const CharType*>(name.c_str()),
            name.size() + 1u);
    }

    /*!
    @brief Writes a BSON element with key @a name and boolean value @a value
    */
    void write_bson_boolean(const string_t& name,
                            const bool value)
    {
        write_bson_entry_header(name, 0x08);
        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
    }

    /*!
    @brief Writes a BSON element with key @a name and double value @a value
    */
    void write_bson_double(const string_t& name,
                           const double value)
    {
        write_bson_entry_header(name, 0x01);
        write_number<double>(value, true);
    }

    /*!
    @return The size of the BSON-encoded string in @a value
    */
    static std::size_t calc_bson_string_size(const string_t& value)
    {
        return sizeof(std::int32_t) + value.size() + 1ul;
    }

    /*!
    @brief Writes a BSON element with key @a name and string value @a value
    */
    void write_bson_string(const string_t& name,
                           const string_t& value)
    {
        write_bson_entry_header(name, 0x02);

        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
        oa->write_characters(
            reinterpret_cast<const CharType*>(value.c_str()),
            value.size() + 1);
    }

    /*!
    @brief Writes a BSON element with key @a name and null value
    */
    void write_bson_null(const string_t& name)
    {
        write_bson_entry_header(name, 0x0A);
    }

    /*!
    @return The size of the BSON-encoded integer @a value
    */
    static std::size_t calc_bson_integer_size(const std::int64_t value)
    {
        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
               ? sizeof(std::int32_t)
               : sizeof(std::int64_t);
    }

    /*!
    @brief Writes a BSON element with key @a name and integer @a value
    */
    void write_bson_integer(const string_t& name,
                            const std::int64_t value)
    {
        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
        {
            write_bson_entry_header(name, 0x10); // int32
            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
        }
        else
        {
            write_bson_entry_header(name, 0x12); // int64
            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
        }
    }

    /*!
    @return The size of the BSON-encoded unsigned integer in @a j
    */
    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
    {
        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
               ? sizeof(std::int32_t)
               : sizeof(std::int64_t);
    }

    /*!
    @brief Writes a BSON element with key @a name and unsigned @a value
    */
    void write_bson_unsigned(const string_t& name,
                             const BasicJsonType& j)
    {
        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
        {
            write_bson_entry_header(name, 0x10 /* int32 */);
            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
        }
        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
        {
            write_bson_entry_header(name, 0x12 /* int64 */);
            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
        }
        else
        {
            JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
        }
    }

    /*!
    @brief Writes a BSON element with key @a name and object @a value
    */
    void write_bson_object_entry(const string_t& name,
                                 const typename BasicJsonType::object_t& value)
    {
        write_bson_entry_header(name, 0x03); // object
        write_bson_object(value);
    }

    /*!
    @return The size of the BSON-encoded array @a value
    */
    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
    {
        std::size_t array_index = 0ul;

        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
        {
            return result + calc_bson_element_size(std::to_string(array_index++), el);
        });

        return sizeof(std::int32_t) + embedded_document_size + 1ul;
    }

    /*!
    @return The size of the BSON-encoded binary array @a value
    */
    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
    {
        return sizeof(std::int32_t) + value.size() + 1ul;
    }

    /*!
    @brief Writes a BSON element with key @a name and array @a value
    */
    void write_bson_array(const string_t& name,
                          const typename BasicJsonType::array_t& value)
    {
        write_bson_entry_header(name, 0x04); // array
        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);

        std::size_t array_index = 0ul;

        for (const auto& el : value)
        {
            write_bson_element(std::to_string(array_index++), el);
        }

        oa->write_character(to_char_type(0x00));
    }

    /*!
    @brief Writes a BSON element with key @a name and binary value @a value
    */
    void write_bson_binary(const string_t& name,
                           const binary_t& value)
    {
        write_bson_entry_header(name, 0x05);

        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));

        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
    }

    /*!
    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
    @return The calculated size for the BSON document entry for @a j with the given @a name.
    */
    static std::size_t calc_bson_element_size(const string_t& name,
            const BasicJsonType& j)
    {
        const auto header_size = calc_bson_entry_header_size(name, j);
        switch (j.type())
        {
            case value_t::object:
                return header_size + calc_bson_object_size(*j.m_data.m_value.object);

            case value_t::array:
                return header_size + calc_bson_array_size(*j.m_data.m_value.array);

            case value_t::binary:
                return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);

            case value_t::boolean:
                return header_size + 1ul;

            case value_t::number_float:
                return header_size + 8ul;

            case value_t::number_integer:
                return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);

            case value_t::number_unsigned:
                return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);

            case value_t::string:
                return header_size + calc_bson_string_size(*j.m_data.m_value.string);

            case value_t::null:
                return header_size + 0ul;

            // LCOV_EXCL_START
            case value_t::discarded:
            default:
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                return 0ul;
                // LCOV_EXCL_STOP
        }
    }

    /*!
    @brief Serializes the JSON value @a j to BSON and associates it with the
           key @a name.
    @param name The name to associate with the JSON entity @a j within the
                current BSON document
    */
    void write_bson_element(const string_t& name,
                            const BasicJsonType& j)
    {
        switch (j.type())
        {
            case value_t::object:
                return write_bson_object_entry(name, *j.m_data.m_value.object);

            case value_t::array:
                return write_bson_array(name, *j.m_data.m_value.array);

            case value_t::binary:
                return write_bson_binary(name, *j.m_data.m_value.binary);

            case value_t::boolean:
                return write_bson_boolean(name, j.m_data.m_value.boolean);

            case value_t::number_float:
                return write_bson_double(name, j.m_data.m_value.number_float);

            case value_t::number_integer:
                return write_bson_integer(name, j.m_data.m_value.number_integer);

            case value_t::number_unsigned:
                return write_bson_unsigned(name, j);

            case value_t::string:
                return write_bson_string(name, *j.m_data.m_value.string);

            case value_t::null:
                return write_bson_null(name);

            // LCOV_EXCL_START
            case value_t::discarded:
            default:
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                return;
                // LCOV_EXCL_STOP
        }
    }

    /*!
    @brief Calculates the size of the BSON serialization of the given
           JSON-object @a j.
    @param[in] value  JSON value to serialize
    @pre       value.type() == value_t::object
    */
    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
    {
        const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
                                          [](size_t result, const typename BasicJsonType::object_t::value_type & el)
        {
            return result += calc_bson_element_size(el.first, el.second);
        });

        return sizeof(std::int32_t) + document_size + 1ul;
    }

    /*!
    @param[in] value  JSON value to serialize
    @pre       value.type() == value_t::object
    */
    void write_bson_object(const typename BasicJsonType::object_t& value)
    {
        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);

        for (const auto& el : value)
        {
            write_bson_element(el.first, el.second);
        }

        oa->write_character(to_char_type(0x00));
    }

    //////////
    // CBOR //
    //////////

    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
    {
        return to_char_type(0xFA);  // Single-Precision Float
    }

    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
    {
        return to_char_type(0xFB);  // Double-Precision Float
    }

    /////////////
    // MsgPack //
    /////////////

    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
    {
        return to_char_type(0xCA);  // float 32
    }

    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
    {
        return to_char_type(0xCB);  // float 64
    }

    ////////////
    // UBJSON //
    ////////////

    // UBJSON: write number (floating point)
    template<typename NumberType, typename std::enable_if<
                 std::is_floating_point<NumberType>::value, int>::type = 0>
    void write_number_with_ubjson_prefix(const NumberType n,
                                         const bool add_prefix,
                                         const bool use_bjdata)
    {
        if (add_prefix)
        {
            oa->write_character(get_ubjson_float_prefix(n));
        }
        write_number(n, use_bjdata);
    }

    // UBJSON: write number (unsigned integer)
    template<typename NumberType, typename std::enable_if<
                 std::is_unsigned<NumberType>::value, int>::type = 0>
    void write_number_with_ubjson_prefix(const NumberType n,
                                         const bool add_prefix,
                                         const bool use_bjdata)
    {
        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('i'));  // int8
            }
            write_number(static_cast<std::uint8_t>(n), use_bjdata);
        }
        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('U'));  // uint8
            }
            write_number(static_cast<std::uint8_t>(n), use_bjdata);
        }
        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('I'));  // int16
            }
            write_number(static_cast<std::int16_t>(n), use_bjdata);
        }
        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
            }
            write_number(static_cast<std::uint16_t>(n), use_bjdata);
        }
        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('l'));  // int32
            }
            write_number(static_cast<std::int32_t>(n), use_bjdata);
        }
        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
            }
            write_number(static_cast<std::uint32_t>(n), use_bjdata);
        }
        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('L'));  // int64
            }
            write_number(static_cast<std::int64_t>(n), use_bjdata);
        }
        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('M'));  // uint64 - bjdata only
            }
            write_number(static_cast<std::uint64_t>(n), use_bjdata);
        }
        else
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('H'));  // high-precision number
            }

            const auto number = BasicJsonType(n).dump();
            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
            for (std::size_t i = 0; i < number.size(); ++i)
            {
                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
            }
        }
    }

    // UBJSON: write number (signed integer)
    template < typename NumberType, typename std::enable_if <
                   std::is_signed<NumberType>::value&&
                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
    void write_number_with_ubjson_prefix(const NumberType n,
                                         const bool add_prefix,
                                         const bool use_bjdata)
    {
        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('i'));  // int8
            }
            write_number(static_cast<std::int8_t>(n), use_bjdata);
        }
        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('U'));  // uint8
            }
            write_number(static_cast<std::uint8_t>(n), use_bjdata);
        }
        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('I'));  // int16
            }
            write_number(static_cast<std::int16_t>(n), use_bjdata);
        }
        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
            }
            write_number(static_cast<uint16_t>(n), use_bjdata);
        }
        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('l'));  // int32
            }
            write_number(static_cast<std::int32_t>(n), use_bjdata);
        }
        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
            }
            write_number(static_cast<uint32_t>(n), use_bjdata);
        }
        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('L'));  // int64
            }
            write_number(static_cast<std::int64_t>(n), use_bjdata);
        }
        // LCOV_EXCL_START
        else
        {
            if (add_prefix)
            {
                oa->write_character(to_char_type('H'));  // high-precision number
            }

            const auto number = BasicJsonType(n).dump();
            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
            for (std::size_t i = 0; i < number.size(); ++i)
            {
                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
            }
        }
        // LCOV_EXCL_STOP
    }

    /*!
    @brief determine the type prefix of container values
    */
    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
    {
        switch (j.type())
        {
            case value_t::null:
                return 'Z';

            case value_t::boolean:
                return j.m_data.m_value.boolean ? 'T' : 'F';

            case value_t::number_integer:
            {
                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
                {
                    return 'i';
                }
                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
                {
                    return 'U';
                }
                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
                {
                    return 'I';
                }
                if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
                {
                    return 'u';
                }
                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
                {
                    return 'l';
                }
                if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
                {
                    return 'm';
                }
                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
                {
                    return 'L';
                }
                // anything else is treated as high-precision number
                return 'H'; // LCOV_EXCL_LINE
            }

            case value_t::number_unsigned:
            {
                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
                {
                    return 'i';
                }
                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
                {
                    return 'U';
                }
                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
                {
                    return 'I';
                }
                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
                {
                    return 'u';
                }
                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
                {
                    return 'l';
                }
                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
                {
                    return 'm';
                }
                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
                {
                    return 'L';
                }
                if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
                {
                    return 'M';
                }
                // anything else is treated as high-precision number
                return 'H'; // LCOV_EXCL_LINE
            }

            case value_t::number_float:
                return get_ubjson_float_prefix(j.m_data.m_value.number_float);

            case value_t::string:
                return 'S';

            case value_t::array: // fallthrough
            case value_t::binary:
                return '[';

            case value_t::object:
                return '{';

            case value_t::discarded:
            default:  // discarded values
                return 'N';
        }
    }

    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
    {
        return 'd';  // float 32
    }

    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
    {
        return 'D';  // float 64
    }

    /*!
    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
    */
    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)
    {
        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},
            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'}
        };

        string_t key = "_ArrayType_";
        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
        if (it == bjdtype.end())
        {
            return true;
        }
        CharType dtype = it->second;

        key = "_ArraySize_";
        std::size_t len = (value.at(key).empty() ? 0 : 1);
        for (const auto& el : value.at(key))
        {
            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
        }

        key = "_ArrayData_";
        if (value.at(key).size() != len)
        {
            return true;
        }

        oa->write_character('[');
        oa->write_character('$');
        oa->write_character(dtype);
        oa->write_character('#');

        key = "_ArraySize_";
        write_ubjson(value.at(key), use_count, use_type, true,  true);

        key = "_ArrayData_";
        if (dtype == 'U' || dtype == 'C')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'i')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'u')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'I')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'm')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'l')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'M')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'L')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'd')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
            }
        }
        else if (dtype == 'D')
        {
            for (const auto& el : value.at(key))
            {
                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
            }
        }
        return false;
    }

    ///////////////////////
    // Utility functions //
    ///////////////////////

    /*
    @brief write a number to output input
    @param[in] n number of type @a NumberType
    @param[in] OutputIsLittleEndian Set to true if output data is
                                 required to be little endian
    @tparam NumberType the type of the number

    @note This function needs to respect the system's endianness, because bytes
          in CBOR, MessagePack, and UBJSON are stored in network order (big
          endian) and therefore need reordering on little endian systems.
          On the other hand, BSON and BJData use little endian and should reorder
          on big endian systems.
    */
    template<typename NumberType>
    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
    {
        // step 1: write number to array of length NumberType
        std::array<CharType, sizeof(NumberType)> vec{};
        std::memcpy(vec.data(), &n, sizeof(NumberType));

        // step 2: write array to output (with possible reordering)
        if (is_little_endian != OutputIsLittleEndian)
        {
            // reverse byte order prior to conversion if necessary
            std::reverse(vec.begin(), vec.end());
        }

        oa->write_characters(vec.data(), sizeof(NumberType));
    }

    void write_compact_float(const number_float_t n, detail::input_format_t format)
    {
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
        {
            oa->write_character(format == detail::input_format_t::cbor
                                ? get_cbor_float_prefix(static_cast<float>(n))
                                : get_msgpack_float_prefix(static_cast<float>(n)));
            write_number(static_cast<float>(n));
        }
        else
        {
            oa->write_character(format == detail::input_format_t::cbor
                                ? get_cbor_float_prefix(n)
                                : get_msgpack_float_prefix(n));
            write_number(n);
        }
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
    }

  public:
    // The following to_char_type functions are implement the conversion
    // between uint8_t and CharType. In case CharType is not unsigned,
    // such a conversion is required to allow values greater than 128.
    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
    template < typename C = CharType,
               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
    static constexpr CharType to_char_type(std::uint8_t x) noexcept
    {
        return *reinterpret_cast<char*>(&x);
    }

    template < typename C = CharType,
               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
    static CharType to_char_type(std::uint8_t x) noexcept
    {
        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
        CharType result;
        std::memcpy(&result, &x, sizeof(x));
        return result;
    }

    template<typename C = CharType,
             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
    static constexpr CharType to_char_type(std::uint8_t x) noexcept
    {
        return x;
    }

    template < typename InputCharType, typename C = CharType,
               enable_if_t <
                   std::is_signed<C>::value &&
                   std::is_signed<char>::value &&
                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
                   > * = nullptr >
    static constexpr CharType to_char_type(InputCharType x) noexcept
    {
        return x;
    }

  private:
    /// whether we can assume little endianness
    const bool is_little_endian = little_endianness();

    /// the output
    output_adapter_t<CharType> oa = nullptr;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/output/output_adapters.hpp>

// #include <nlohmann/detail/output/serializer.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de>
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <algorithm> // reverse, remove, fill, find, none_of
#include <array> // array
#include <clocale> // localeconv, lconv
#include <cmath> // labs, isfinite, isnan, signbit
#include <cstddef> // size_t, ptrdiff_t
#include <cstdint> // uint8_t
#include <cstdio> // snprintf
#include <limits> // numeric_limits
#include <string> // string, char_traits
#include <iomanip> // setfill, setw
#include <type_traits> // is_same
#include <utility> // move

// #include <nlohmann/detail/conversions/to_chars.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <array> // array
#include <cmath>   // signbit, isfinite
#include <cstdint> // intN_t, uintN_t
#include <cstring> // memcpy, memmove
#include <limits> // numeric_limits
#include <type_traits> // conditional

// #include <nlohmann/detail/macro_scope.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/*!
@brief implements the Grisu2 algorithm for binary to decimal floating-point
conversion.

This implementation is a slightly modified version of the reference
implementation which may be obtained from
http://florian.loitsch.com/publications (bench.tar.gz).

The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.

For a detailed description of the algorithm see:

[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
    Language Design and Implementation, PLDI 2010
[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
    Design and Implementation, PLDI 1996
*/
namespace dtoa_impl
{

template<typename Target, typename Source>
Target reinterpret_bits(const Source source)
{
    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");

    Target target;
    std::memcpy(&target, &source, sizeof(Source));
    return target;
}

struct diyfp // f * 2^e
{
    static constexpr int kPrecision = 64; // = q

    std::uint64_t f = 0;
    int e = 0;

    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}

    /*!
    @brief returns x - y
    @pre x.e == y.e and x.f >= y.f
    */
    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
    {
        JSON_ASSERT(x.e == y.e);
        JSON_ASSERT(x.f >= y.f);

        return {x.f - y.f, x.e};
    }

    /*!
    @brief returns x * y
    @note The result is rounded. (Only the upper q bits are returned.)
    */
    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
    {
        static_assert(kPrecision == 64, "internal error");

        // Computes:
        //  f = round((x.f * y.f) / 2^q)
        //  e = x.e + y.e + q

        // Emulate the 64-bit * 64-bit multiplication:
        //
        // p = u * v
        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
        //
        // (Since Q might be larger than 2^32 - 1)
        //
        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
        //
        // (Q_hi + H does not overflow a 64-bit int)
        //
        //   = p_lo + 2^64 p_hi

        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
        const std::uint64_t u_hi = x.f >> 32u;
        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
        const std::uint64_t v_hi = y.f >> 32u;

        const std::uint64_t p0 = u_lo * v_lo;
        const std::uint64_t p1 = u_lo * v_hi;
        const std::uint64_t p2 = u_hi * v_lo;
        const std::uint64_t p3 = u_hi * v_hi;

        const std::uint64_t p0_hi = p0 >> 32u;
        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
        const std::uint64_t p1_hi = p1 >> 32u;
        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
        const std::uint64_t p2_hi = p2 >> 32u;

        std::uint64_t Q = p0_hi + p1_lo + p2_lo;

        // The full product might now be computed as
        //
        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
        // p_lo = p0_lo + (Q << 32)
        //
        // But in this particular case here, the full p_lo is not required.
        // Effectively we only need to add the highest bit in p_lo to p_hi (and
        // Q_hi + 1 does not overflow).

        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up

        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);

        return {h, x.e + y.e + 64};
    }

    /*!
    @brief normalize x such that the significand is >= 2^(q-1)
    @pre x.f != 0
    */
    static diyfp normalize(diyfp x) noexcept
    {
        JSON_ASSERT(x.f != 0);

        while ((x.f >> 63u) == 0)
        {
            x.f <<= 1u;
            x.e--;
        }

        return x;
    }

    /*!
    @brief normalize x such that the result has the exponent E
    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
    */
    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
    {
        const int delta = x.e - target_exponent;

        JSON_ASSERT(delta >= 0);
        JSON_ASSERT(((x.f << delta) >> delta) == x.f);

        return {x.f << delta, target_exponent};
    }
};

struct boundaries
{
    diyfp w;
    diyfp minus;
    diyfp plus;
};

/*!
Compute the (normalized) diyfp representing the input number 'value' and its
boundaries.

@pre value must be finite and positive
*/
template<typename FloatType>
boundaries compute_boundaries(FloatType value)
{
    JSON_ASSERT(std::isfinite(value));
    JSON_ASSERT(value > 0);

    // Convert the IEEE representation into a diyfp.
    //
    // If v is denormal:
    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
    // If v is normalized:
    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))

    static_assert(std::numeric_limits<FloatType>::is_iec559,
                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");

    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
    constexpr int      kMinExp    = 1 - kBias;
    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)

    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;

    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
    const std::uint64_t E = bits >> (kPrecision - 1);
    const std::uint64_t F = bits & (kHiddenBit - 1);

    const bool is_denormal = E == 0;
    const diyfp v = is_denormal
                    ? diyfp(F, kMinExp)
                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);

    // Compute the boundaries m- and m+ of the floating-point value
    // v = f * 2^e.
    //
    // Determine v- and v+, the floating-point predecessor and successor if v,
    // respectively.
    //
    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
    //
    //      v+ = v + 2^e
    //
    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
    // between m- and m+ round to v, regardless of how the input rounding
    // algorithm breaks ties.
    //
    //      ---+-------------+-------------+-------------+-------------+---  (A)
    //         v-            m-            v             m+            v+
    //
    //      -----------------+------+------+-------------+-------------+---  (B)
    //                       v-     m-     v             m+            v+

    const bool lower_boundary_is_closer = F == 0 && E > 1;
    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
    const diyfp m_minus = lower_boundary_is_closer
                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
                          : diyfp(2 * v.f - 1, v.e - 1); // (A)

    // Determine the normalized w+ = m+.
    const diyfp w_plus = diyfp::normalize(m_plus);

    // Determine w- = m- such that e_(w-) = e_(w+).
    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);

    return {diyfp::normalize(v), w_minus, w_plus};
}

// Given normalized diyfp w, Grisu needs to find a (normalized) cached
// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
// within a certain range [alpha, gamma] (Definition 3.2 from [1])
//
//      alpha <= e = e_c + e_w + q <= gamma
//
// or
//
//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
//                          <= f_c * f_w * 2^gamma
//
// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
//
//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
//
// or
//
//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
//
// The choice of (alpha,gamma) determines the size of the table and the form of
// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
// in practice:
//
// The idea is to cut the number c * w = f * 2^e into two parts, which can be
// processed independently: An integral part p1, and a fractional part p2:
//
//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
//              = (f div 2^-e) + (f mod 2^-e) * 2^e
//              = p1 + p2 * 2^e
//
// The conversion of p1 into decimal form requires a series of divisions and
// modulos by (a power of) 10. These operations are faster for 32-bit than for
// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
// achieved by choosing
//
//      -e >= 32   or   e <= -32 := gamma
//
// In order to convert the fractional part
//
//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
//
// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
// d[-i] are extracted in order:
//
//      (10 * p2) div 2^-e = d[-1]
//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
//
// The multiplication by 10 must not overflow. It is sufficient to choose
//
//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
//
// Since p2 = f mod 2^-e < 2^-e,
//
//      -e <= 60   or   e >= -60 := alpha

constexpr int kAlpha = -60;
constexpr int kGamma = -32;

struct cached_power // c = f * 2^e ~= 10^k
{
    std::uint64_t f;
    int e;
    int k;
};

/*!
For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
satisfies (Definition 3.2 from [1])

     alpha <= e_c + e + q <= gamma.
*/
inline cached_power get_cached_power_for_binary_exponent(int e)
{
    // Now
    //
    //      alpha <= e_c + e + q <= gamma                                    (1)
    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
    //
    // and since the c's are normalized, 2^(q-1) <= f_c,
    //
    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
    //      ==> 2^(alpha - e - 1) <= c
    //
    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
    //
    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
    //        = ceil( (alpha - e - 1) * log_10(2) )
    //
    // From the paper:
    // "In theory the result of the procedure could be wrong since c is rounded,
    //  and the computation itself is approximated [...]. In practice, however,
    //  this simple function is sufficient."
    //
    // For IEEE double precision floating-point numbers converted into
    // normalized diyfp's w = f * 2^e, with q = 64,
    //
    //      e >= -1022      (min IEEE exponent)
    //           -52        (p - 1)
    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
    //           -11        (normalize the diyfp)
    //         = -1137
    //
    // and
    //
    //      e <= +1023      (max IEEE exponent)
    //           -52        (p - 1)
    //           -11        (normalize the diyfp)
    //         = 960
    //
    // This binary exponent range [-1137,960] results in a decimal exponent
    // range [-307,324]. One does not need to store a cached power for each
    // k in this range. For each such k it suffices to find a cached power
    // such that the exponent of the product lies in [alpha,gamma].
    // This implies that the difference of the decimal exponents of adjacent
    // table entries must be less than or equal to
    //
    //      floor( (gamma - alpha) * log_10(2) ) = 8.
    //
    // (A smaller distance gamma-alpha would require a larger table.)

    // NB:
    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.

    constexpr int kCachedPowersMinDecExp = -300;
    constexpr int kCachedPowersDecStep = 8;

    static constexpr std::array<cached_power, 79> kCachedPowers =
    {
        {
            { 0xAB70FE17C79AC6CA, -1060, -300 },
            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
            { 0xBE5691EF416BD60C, -1007, -284 },
            { 0x8DD01FAD907FFC3C,  -980, -276 },
            { 0xD3515C2831559A83,  -954, -268 },
            { 0x9D71AC8FADA6C9B5,  -927, -260 },
            { 0xEA9C227723EE8BCB,  -901, -252 },
            { 0xAECC49914078536D,  -874, -244 },
            { 0x823C12795DB6CE57,  -847, -236 },
            { 0xC21094364DFB5637,  -821, -228 },
            { 0x9096EA6F3848984F,  -794, -220 },
            { 0xD77485CB25823AC7,  -768, -212 },
            { 0xA086CFCD97BF97F4,  -741, -204 },
            { 0xEF340A98172AACE5,  -715, -196 },
            { 0xB23867FB2A35B28E,  -688, -188 },
            { 0x84C8D4DFD2C63F3B,  -661, -180 },
            { 0xC5DD44271AD3CDBA,  -635, -172 },
            { 0x936B9FCEBB25C996,  -608, -164 },
            { 0xDBAC6C247D62A584,  -582, -156 },
            { 0xA3AB66580D5FDAF6,  -555, -148 },
            { 0xF3E2F893DEC3F126,  -529, -140 },
            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
            { 0x87625F056C7C4A8B,  -475, -124 },
            { 0xC9BCFF6034C13053,  -449, -116 },
            { 0x964E858C91BA2655,  -422, -108 },
            { 0xDFF9772470297EBD,  -396, -100 },
            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
            { 0xF8A95FCF88747D94,  -343,  -84 },
            { 0xB94470938FA89BCF,  -316,  -76 },
            { 0x8A08F0F8BF0F156B,  -289,  -68 },
            { 0xCDB02555653131B6,  -263,  -60 },
            { 0x993FE2C6D07B7FAC,  -236,  -52 },
            { 0xE45C10C42A2B3B06,  -210,  -44 },
            { 0xAA242499697392D3,  -183,  -36 },
            { 0xFD87B5F28300CA0E,  -157,  -28 },
            { 0xBCE5086492111AEB,  -130,  -20 },
            { 0x8CBCCC096F5088CC,  -103,  -12 },
            { 0xD1B71758E219652C,   -77,   -4 },
            { 0x9C40000000000000,   -50,    4 },
            { 0xE8D4A51000000000,   -24,   12 },
            { 0xAD78EBC5AC620000,     3,   20 },
            { 0x813F3978F8940984,    30,   28 },
            { 0xC097CE7BC90715B3,    56,   36 },
            { 0x8F7E32CE7BEA5C70,    83,   44 },
            { 0xD5D238A4ABE98068,   109,   52 },
            { 0x9F4F2726179A2245,   136,   60 },
            { 0xED63A231D4C4FB27,   162,   68 },
            { 0xB0DE65388CC8ADA8,   189,   76 },
            { 0x83C7088E1AAB65DB,   216,   84 },
            { 0xC45D1DF942711D9A,   242,   92 },
            { 0x924D692CA61BE758,   269,  100 },
            { 0xDA01EE641A708DEA,   295,  108 },
            { 0xA26DA3999AEF774A,   322,  116 },
            { 0xF209787BB47D6B85,   348,  124 },
            { 0xB454E4A179DD1877,   375,  132 },
            { 0x865B86925B9BC5C2,   402,  140 },
            { 0xC83553C5C8965D3D,   428,  148 },
            { 0x952AB45CFA97A0B3,   455,  156 },
            { 0xDE469FBD99A05FE3,   481,  164 },
            { 0xA59BC234DB398C25,   508,  172 },
            { 0xF6C69A72A3989F5C,   534,  180 },
            { 0xB7DCBF5354E9BECE,   561,  188 },
            { 0x88FCF317F22241E2,   588,  196 },
            { 0xCC20CE9BD35C78A5,   614,  204 },
            { 0x98165AF37B2153DF,   641,  212 },
            { 0xE2A0B5DC971F303A,   667,  220 },
            { 0xA8D9D1535CE3B396,   694,  228 },
            { 0xFB9B7CD9A4A7443C,   720,  236 },
            { 0xBB764C4CA7A44410,   747,  244 },
            { 0x8BAB8EEFB6409C1A,   774,  252 },
            { 0xD01FEF10A657842C,   800,  260 },
            { 0x9B10A4E5E9913129,   827,  268 },
            { 0xE7109BFBA19C0C9D,   853,  276 },
            { 0xAC2820D9623BF429,   880,  284 },
            { 0x80444B5E7AA7CF85,   907,  292 },
            { 0xBF21E44003ACDD2D,   933,  300 },
            { 0x8E679C2F5E44FF8F,   960,  308 },
            { 0xD433179D9C8CB841,   986,  316 },
            { 0x9E19DB92B4E31BA9,  1013,  324 },
        }
    };

    // This computation gives exactly the same results for k as
    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
    // for |e| <= 1500, but doesn't require floating-point operations.
    // NB: log_10(2) ~= 78913 / 2^18
    JSON_ASSERT(e >= -1500);
    JSON_ASSERT(e <=  1500);
    const int f = kAlpha - e - 1;
    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);

    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
    JSON_ASSERT(index >= 0);
    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());

    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
    JSON_ASSERT(kAlpha <= cached.e + e + 64);
    JSON_ASSERT(kGamma >= cached.e + e + 64);

    return cached;
}

/*!
For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
For n == 0, returns 1 and sets pow10 := 1.
*/
inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
{
    // LCOV_EXCL_START
    if (n >= 1000000000)
    {
        pow10 = 1000000000;
        return 10;
    }
    // LCOV_EXCL_STOP
    if (n >= 100000000)
    {
        pow10 = 100000000;
        return  9;
    }
    if (n >= 10000000)
    {
        pow10 = 10000000;
        return  8;
    }
    if (n >= 1000000)
    {
        pow10 = 1000000;
        return  7;
    }
    if (n >= 100000)
    {
        pow10 = 100000;
        return  6;
    }
    if (n >= 10000)
    {
        pow10 = 10000;
        return  5;
    }
    if (n >= 1000)
    {
        pow10 = 1000;
        return  4;
    }
    if (n >= 100)
    {
        pow10 = 100;
        return  3;
    }
    if (n >= 10)
    {
        pow10 = 10;
        return  2;
    }

    pow10 = 1;
    return 1;
}

inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
                         std::uint64_t rest, std::uint64_t ten_k)
{
    JSON_ASSERT(len >= 1);
    JSON_ASSERT(dist <= delta);
    JSON_ASSERT(rest <= delta);
    JSON_ASSERT(ten_k > 0);

    //               <--------------------------- delta ---->
    //                                  <---- dist --------->
    // --------------[------------------+-------------------]--------------
    //               M-                 w                   M+
    //
    //                                  ten_k
    //                                <------>
    //                                       <---- rest ---->
    // --------------[------------------+----+--------------]--------------
    //                                  w    V
    //                                       = buf * 10^k
    //
    // ten_k represents a unit-in-the-last-place in the decimal representation
    // stored in buf.
    // Decrement buf by ten_k while this takes buf closer to w.

    // The tests are written in this order to avoid overflow in unsigned
    // integer arithmetic.

    while (rest < dist
            && delta - rest >= ten_k
            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
    {
        JSON_ASSERT(buf[len - 1] != '0');
        buf[len - 1]--;
        rest += ten_k;
    }
}

/*!
Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
*/
inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
                             diyfp M_minus, diyfp w, diyfp M_plus)
{
    static_assert(kAlpha >= -60, "internal error");
    static_assert(kGamma <= -32, "internal error");

    // Generates the digits (and the exponent) of a decimal floating-point
    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
    //
    //               <--------------------------- delta ---->
    //                                  <---- dist --------->
    // --------------[------------------+-------------------]--------------
    //               M-                 w                   M+
    //
    // Grisu2 generates the digits of M+ from left to right and stops as soon as
    // V is in [M-,M+].

    JSON_ASSERT(M_plus.e >= kAlpha);
    JSON_ASSERT(M_plus.e <= kGamma);

    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)

    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
    //
    //      M+ = f * 2^e
    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
    //         = p1 + p2 * 2^e

    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);

    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e

    // 1)
    //
    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]

    JSON_ASSERT(p1 > 0);

    std::uint32_t pow10{};
    const int k = find_largest_pow10(p1, pow10);

    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
    //
    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
    //
    //      M+ = p1                                             + p2 * 2^e
    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
    //
    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
    //
    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
    //
    // but stop as soon as
    //
    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e

    int n = k;
    while (n > 0)
    {
        // Invariants:
        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
        //      pow10 = 10^(n-1) <= p1 < 10^n
        //
        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
        //
        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
        //
        JSON_ASSERT(d <= 9);
        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
        //
        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
        //
        p1 = r;
        n--;
        //
        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
        //      pow10 = 10^n
        //

        // Now check if enough digits have been generated.
        // Compute
        //
        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
        //
        // Note:
        // Since rest and delta share the same exponent e, it suffices to
        // compare the significands.
        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
        if (rest <= delta)
        {
            // V = buffer * 10^n, with M- <= V <= M+.

            decimal_exponent += n;

            // We may now just stop. But instead look if the buffer could be
            // decremented to bring V closer to w.
            //
            // pow10 = 10^n is now 1 ulp in the decimal representation V.
            // The rounding procedure works with diyfp's with an implicit
            // exponent of e.
            //
            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
            //
            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
            grisu2_round(buffer, length, dist, delta, rest, ten_n);

            return;
        }

        pow10 /= 10;
        //
        //      pow10 = 10^(n-1) <= p1 < 10^n
        // Invariants restored.
    }

    // 2)
    //
    // The digits of the integral part have been generated:
    //
    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
    //         = buffer            + p2 * 2^e
    //
    // Now generate the digits of the fractional part p2 * 2^e.
    //
    // Note:
    // No decimal point is generated: the exponent is adjusted instead.
    //
    // p2 actually represents the fraction
    //
    //      p2 * 2^e
    //          = p2 / 2^-e
    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
    //
    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
    //
    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
    //
    // using
    //
    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
    //                = (                   d) * 2^-e + (                   r)
    //
    // or
    //      10^m * p2 * 2^e = d + r * 2^e
    //
    // i.e.
    //
    //      M+ = buffer + p2 * 2^e
    //         = buffer + 10^-m * (d + r * 2^e)
    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
    //
    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e

    JSON_ASSERT(p2 > delta);

    int m = 0;
    for (;;)
    {
        // Invariant:
        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
        //
        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
        p2 *= 10;
        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
        //
        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
        //
        JSON_ASSERT(d <= 9);
        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
        //
        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
        //
        p2 = r;
        m++;
        //
        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
        // Invariant restored.

        // Check if enough digits have been generated.
        //
        //      10^-m * p2 * 2^e <= delta * 2^e
        //              p2 * 2^e <= 10^m * delta * 2^e
        //                    p2 <= 10^m * delta
        delta *= 10;
        dist  *= 10;
        if (p2 <= delta)
        {
            break;
        }
    }

    // V = buffer * 10^-m, with M- <= V <= M+.

    decimal_exponent -= m;

    // 1 ulp in the decimal representation is now 10^-m.
    // Since delta and dist are now scaled by 10^m, we need to do the
    // same with ulp in order to keep the units in sync.
    //
    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
    //
    const std::uint64_t ten_m = one.f;
    grisu2_round(buffer, length, dist, delta, p2, ten_m);

    // By construction this algorithm generates the shortest possible decimal
    // number (Loitsch, Theorem 6.2) which rounds back to w.
    // For an input number of precision p, at least
    //
    //      N = 1 + ceil(p * log_10(2))
    //
    // decimal digits are sufficient to identify all binary floating-point
    // numbers (Matula, "In-and-Out conversions").
    // This implies that the algorithm does not produce more than N decimal
    // digits.
    //
    //      N = 17 for p = 53 (IEEE double precision)
    //      N = 9  for p = 24 (IEEE single precision)
}

/*!
v = buf * 10^decimal_exponent
len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10.
*/
JSON_HEDLEY_NON_NULL(1)
inline void grisu2(char* buf, int& len, int& decimal_exponent,
                   diyfp m_minus, diyfp v, diyfp m_plus)
{
    JSON_ASSERT(m_plus.e == m_minus.e);
    JSON_ASSERT(m_plus.e == v.e);

    //  --------(-----------------------+-----------------------)--------    (A)
    //          m-                      v                       m+
    //
    //  --------------------(-----------+-----------------------)--------    (B)
    //                      m-          v                       m+
    //
    // First scale v (and m- and m+) such that the exponent is in the range
    // [alpha, gamma].

    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);

    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k

    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
    const diyfp w       = diyfp::mul(v,       c_minus_k);
    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);

    //  ----(---+---)---------------(---+---)---------------(---+---)----
    //          w-                      w                       w+
    //          = c*m-                  = c*v                   = c*m+
    //
    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
    // w+ are now off by a small amount.
    // In fact:
    //
    //      w - v * 10^k < 1 ulp
    //
    // To account for this inaccuracy, add resp. subtract 1 ulp.
    //
    //  --------+---[---------------(---+---)---------------]---+--------
    //          w-  M-                  w                   M+  w+
    //
    // Now any number in [M-, M+] (bounds included) will round to w when input,
    // regardless of how the input rounding algorithm breaks ties.
    //
    // And digit_gen generates the shortest possible such number in [M-, M+].
    // Note that this does not mean that Grisu2 always generates the shortest
    // possible number in the interval (m-, m+).
    const diyfp M_minus(w_minus.f + 1, w_minus.e);
    const diyfp M_plus (w_plus.f  - 1, w_plus.e );

    decimal_exponent = -cached.k; // = -(-k) = k

    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
}

/*!
v = buf * 10^decimal_exponent
len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10.
*/
template<typename FloatType>
JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
                  "internal error: not enough precision");

    JSON_ASSERT(std::isfinite(value));
    JSON_ASSERT(value > 0);

    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
    // decimal representations are not exactly "short".
    //
    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
    // does.
    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
    // representation using the corresponding std::from_chars function recovers value exactly". That
    // indicates that single precision floating-point numbers should be recovered using
    // 'std::strtof'.
    //
    // NB: If the neighbors are computed for single-precision numbers, there is a single float
    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
    //     value is off by 1 ulp.
#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
    const boundaries w = compute_boundaries(static_cast<double>(value));
#else
    const boundaries w = compute_boundaries(value);
#endif

    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
}

/*!
@brief appends a decimal representation of e to buf
@return a pointer to the element following the exponent.
@pre -1000 < e < 1000
*/
JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_RETURNS_NON_NULL
inline char* append_exponent(char* buf, int e)
{
    JSON_ASSERT(e > -1000);
    JSON_ASSERT(e <  1000);

    if (e < 0)
    {
        e = -e;
        *buf++ = '-';
    }
    else
    {
        *buf++ = '+';
    }

    auto k = static_cast<std::uint32_t>(e);
    if (k < 10)
    {
        // Always print at least two digits in the exponent.
        // This is for compatibility with printf("%g").
        *buf++ = '0';
        *buf++ = static_cast<char>('0' + k);
    }
    else if (k < 100)
    {
        *buf++ = static_cast<char>('0' + k / 10);
        k %= 10;
        *buf++ = static_cast<char>('0' + k);
    }
    else
    {
        *buf++ = static_cast<char>('0' + k / 100);
        k %= 100;
        *buf++ = static_cast<char>('0' + k / 10);
        k %= 10;
        *buf++ = static_cast<char>('0' + k);
    }

    return buf;
}

/*!
@brief prettify v = buf * 10^decimal_exponent

If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
notation. Otherwise it will be printed in exponential notation.

@pre min_exp < 0
@pre max_exp > 0
*/
JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_RETURNS_NON_NULL
inline char* format_buffer(char* buf, int len, int decimal_exponent,
                           int min_exp, int max_exp)
{
    JSON_ASSERT(min_exp < 0);
    JSON_ASSERT(max_exp > 0);

    const int k = len;
    const int n = len + decimal_exponent;

    // v = buf * 10^(n-k)
    // k is the length of the buffer (number of decimal digits)
    // n is the position of the decimal point relative to the start of the buffer.

    if (k <= n && n <= max_exp)
    {
        // digits[000]
        // len <= max_exp + 2

        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
        // Make it look like a floating-point number (#362, #378)
        buf[n + 0] = '.';
        buf[n + 1] = '0';
        return buf + (static_cast<size_t>(n) + 2);
    }

    if (0 < n && n <= max_exp)
    {
        // dig.its
        // len <= max_digits10 + 1

        JSON_ASSERT(k > n);

        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
        buf[n] = '.';
        return buf + (static_cast<size_t>(k) + 1U);
    }

    if (min_exp < n && n <= 0)
    {
        // 0.[000]digits
        // len <= 2 + (-min_exp - 1) + max_digits10

        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
        buf[0] = '0';
        buf[1] = '.';
        std::memset(buf + 2, '0', static_cast<size_t>(-n));
        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
    }

    if (k == 1)
    {
        // dE+123
        // len <= 1 + 5

        buf += 1;
    }
    else
    {
        // d.igitsE+123
        // len <= max_digits10 + 1 + 5

        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
        buf[1] = '.';
        buf += 1 + static_cast<size_t>(k);
    }

    *buf++ = 'e';
    return append_exponent(buf, n - 1);
}

}  // namespace dtoa_impl

/*!
@brief generates a decimal representation of the floating-point number value in [first, last).

The format of the resulting decimal representation is similar to printf's %g
format. Returns an iterator pointing past-the-end of the decimal representation.

@note The input number must be finite, i.e. NaN's and Inf's are not supported.
@note The buffer must be large enough.
@note The result is NOT null-terminated.
*/
template<typename FloatType>
JSON_HEDLEY_NON_NULL(1, 2)
JSON_HEDLEY_RETURNS_NON_NULL
char* to_chars(char* first, const char* last, FloatType value)
{
    static_cast<void>(last); // maybe unused - fix warning
    JSON_ASSERT(std::isfinite(value));

    // Use signbit(value) instead of (value < 0) since signbit works for -0.
    if (std::signbit(value))
    {
        value = -value;
        *first++ = '-';
    }

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
    if (value == 0) // +-0
    {
        *first++ = '0';
        // Make it look like a floating-point number (#362, #378)
        *first++ = '.';
        *first++ = '0';
        return first;
    }
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);

    // Compute v = buffer * 10^decimal_exponent.
    // The decimal digits are stored in the buffer, which needs to be interpreted
    // as an unsigned decimal integer.
    // len is the length of the buffer, i.e. the number of decimal digits.
    int len = 0;
    int decimal_exponent = 0;
    dtoa_impl::grisu2(first, len, decimal_exponent, value);

    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);

    // Format the buffer like printf("%.*g", prec, value)
    constexpr int kMinExp = -4;
    // Use digits10 here to increase compatibility with version 2.
    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;

    JSON_ASSERT(last - first >= kMaxExp + 2);
    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);

    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
}

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/output/binary_writer.hpp>

// #include <nlohmann/detail/output/output_adapters.hpp>

// #include <nlohmann/detail/string_concat.hpp>

// #include <nlohmann/detail/value_t.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

///////////////////
// serialization //
///////////////////

/// how to treat decoding errors
enum class error_handler_t
{
    strict,  ///< throw a type_error exception in case of invalid UTF-8
    replace, ///< replace invalid UTF-8 sequences with U+FFFD
    ignore   ///< ignore invalid UTF-8 sequences
};

template<typename BasicJsonType>
class serializer
{
    using string_t = typename BasicJsonType::string_t;
    using number_float_t = typename BasicJsonType::number_float_t;
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using binary_char_t = typename BasicJsonType::binary_t::value_type;
    static constexpr std::uint8_t UTF8_ACCEPT = 0;
    static constexpr std::uint8_t UTF8_REJECT = 1;

  public:
    /*!
    @param[in] s  output stream to serialize to
    @param[in] ichar  indentation character to use
    @param[in] error_handler_  how to react on decoding errors
    */
    serializer(output_adapter_t<char> s, const char ichar,
               error_handler_t error_handler_ = error_handler_t::strict)
        : o(std::move(s))
        , loc(std::localeconv())
        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
        , indent_char(ichar)
        , indent_string(512, indent_char)
        , error_handler(error_handler_)
    {}

    // delete because of pointer members
    serializer(const serializer&) = delete;
    serializer& operator=(const serializer&) = delete;
    serializer(serializer&&) = delete;
    serializer& operator=(serializer&&) = delete;
    ~serializer() = default;

    /*!
    @brief internal implementation of the serialization function

    This function is called by the public member function dump and organizes
    the serialization internally. The indentation level is propagated as
    additional parameter. In case of arrays and objects, the function is
    called recursively.

    - strings and object keys are escaped using `escape_string()`
    - integer numbers are converted implicitly via `operator<<`
    - floating-point numbers are converted to a string using `"%g"` format
    - binary values are serialized as objects containing the subtype and the
      byte array

    @param[in] val               value to serialize
    @param[in] pretty_print      whether the output shall be pretty-printed
    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
    in the output are escaped with `\uXXXX` sequences, and the result consists
    of ASCII characters only.
    @param[in] indent_step       the indent level
    @param[in] current_indent    the current indent level (only used internally)
    */
    void dump(const BasicJsonType& val,
              const bool pretty_print,
              const bool ensure_ascii,
              const unsigned int indent_step,
              const unsigned int current_indent = 0)
    {
        switch (val.m_data.m_type)
        {
            case value_t::object:
            {
                if (val.m_data.m_value.object->empty())
                {
                    o->write_characters("{}", 2);
                    return;
                }

                if (pretty_print)
                {
                    o->write_characters("{\n", 2);

                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
                    }

                    // first n-1 elements
                    auto i = val.m_data.m_value.object->cbegin();
                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
                    {
                        o->write_characters(indent_string.c_str(), new_indent);
                        o->write_character('\"');
                        dump_escaped(i->first, ensure_ascii);
                        o->write_characters("\": ", 3);
                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
                        o->write_characters(",\n", 2);
                    }

                    // last element
                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
                    o->write_characters(indent_string.c_str(), new_indent);
                    o->write_character('\"');
                    dump_escaped(i->first, ensure_ascii);
                    o->write_characters("\": ", 3);
                    dump(i->second, true, ensure_ascii, indent_step, new_indent);

                    o->write_character('\n');
                    o->write_characters(indent_string.c_str(), current_indent);
                    o->write_character('}');
                }
                else
                {
                    o->write_character('{');

                    // first n-1 elements
                    auto i = val.m_data.m_value.object->cbegin();
                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
                    {
                        o->write_character('\"');
                        dump_escaped(i->first, ensure_ascii);
                        o->write_characters("\":", 2);
                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
                        o->write_character(',');
                    }

                    // last element
                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
                    o->write_character('\"');
                    dump_escaped(i->first, ensure_ascii);
                    o->write_characters("\":", 2);
                    dump(i->second, false, ensure_ascii, indent_step, current_indent);

                    o->write_character('}');
                }

                return;
            }

            case value_t::array:
            {
                if (val.m_data.m_value.array->empty())
                {
                    o->write_characters("[]", 2);
                    return;
                }

                if (pretty_print)
                {
                    o->write_characters("[\n", 2);

                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
                    }

                    // first n-1 elements
                    for (auto i = val.m_data.m_value.array->cbegin();
                            i != val.m_data.m_value.array->cend() - 1; ++i)
                    {
                        o->write_characters(indent_string.c_str(), new_indent);
                        dump(*i, true, ensure_ascii, indent_step, new_indent);
                        o->write_characters(",\n", 2);
                    }

                    // last element
                    JSON_ASSERT(!val.m_data.m_value.array->empty());
                    o->write_characters(indent_string.c_str(), new_indent);
                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);

                    o->write_character('\n');
                    o->write_characters(indent_string.c_str(), current_indent);
                    o->write_character(']');
                }
                else
                {
                    o->write_character('[');

                    // first n-1 elements
                    for (auto i = val.m_data.m_value.array->cbegin();
                            i != val.m_data.m_value.array->cend() - 1; ++i)
                    {
                        dump(*i, false, ensure_ascii, indent_step, current_indent);
                        o->write_character(',');
                    }

                    // last element
                    JSON_ASSERT(!val.m_data.m_value.array->empty());
                    dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);

                    o->write_character(']');
                }

                return;
            }

            case value_t::string:
            {
                o->write_character('\"');
                dump_escaped(*val.m_data.m_value.string, ensure_ascii);
                o->write_character('\"');
                return;
            }

            case value_t::binary:
            {
                if (pretty_print)
                {
                    o->write_characters("{\n", 2);

                    // variable to hold indentation for recursive calls
                    const auto new_indent = current_indent + indent_step;
                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
                    {
                        indent_string.resize(indent_string.size() * 2, ' ');
                    }

                    o->write_characters(indent_string.c_str(), new_indent);

                    o->write_characters("\"bytes\": [", 10);

                    if (!val.m_data.m_value.binary->empty())
                    {
                        for (auto i = val.m_data.m_value.binary->cbegin();
                                i != val.m_data.m_value.binary->cend() - 1; ++i)
                        {
                            dump_integer(*i);
                            o->write_characters(", ", 2);
                        }
                        dump_integer(val.m_data.m_value.binary->back());
                    }

                    o->write_characters("],\n", 3);
                    o->write_characters(indent_string.c_str(), new_indent);

                    o->write_characters("\"subtype\": ", 11);
                    if (val.m_data.m_value.binary->has_subtype())
                    {
                        dump_integer(val.m_data.m_value.binary->subtype());
                    }
                    else
                    {
                        o->write_characters("null", 4);
                    }
                    o->write_character('\n');
                    o->write_characters(indent_string.c_str(), current_indent);
                    o->write_character('}');
                }
                else
                {
                    o->write_characters("{\"bytes\":[", 10);

                    if (!val.m_data.m_value.binary->empty())
                    {
                        for (auto i = val.m_data.m_value.binary->cbegin();
                                i != val.m_data.m_value.binary->cend() - 1; ++i)
                        {
                            dump_integer(*i);
                            o->write_character(',');
                        }
                        dump_integer(val.m_data.m_value.binary->back());
                    }

                    o->write_characters("],\"subtype\":", 12);
                    if (val.m_data.m_value.binary->has_subtype())
                    {
                        dump_integer(val.m_data.m_value.binary->subtype());
                        o->write_character('}');
                    }
                    else
                    {
                        o->write_characters("null}", 5);
                    }
                }
                return;
            }

            case value_t::boolean:
            {
                if (val.m_data.m_value.boolean)
                {
                    o->write_characters("true", 4);
                }
                else
                {
                    o->write_characters("false", 5);
                }
                return;
            }

            case value_t::number_integer:
            {
                dump_integer(val.m_data.m_value.number_integer);
                return;
            }

            case value_t::number_unsigned:
            {
                dump_integer(val.m_data.m_value.number_unsigned);
                return;
            }

            case value_t::number_float:
            {
                dump_float(val.m_data.m_value.number_float);
                return;
            }

            case value_t::discarded:
            {
                o->write_characters("<discarded>", 11);
                return;
            }

            case value_t::null:
            {
                o->write_characters("null", 4);
                return;
            }

            default:            // LCOV_EXCL_LINE
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
        }
    }

  JSON_PRIVATE_UNLESS_TESTED:
    /*!
    @brief dump escaped string

    Escape a string by replacing certain special characters by a sequence of an
    escape character (backslash) and another character and other control
    characters by a sequence of "\u" followed by a four-digit hex
    representation. The escaped string is written to output stream @a o.

    @param[in] s  the string to escape
    @param[in] ensure_ascii  whether to escape non-ASCII characters with
                             \uXXXX sequences

    @complexity Linear in the length of string @a s.
    */
    void dump_escaped(const string_t& s, const bool ensure_ascii)
    {
        std::uint32_t codepoint{};
        std::uint8_t state = UTF8_ACCEPT;
        std::size_t bytes = 0;  // number of bytes written to string_buffer

        // number of bytes written at the point of the last valid byte
        std::size_t bytes_after_last_accept = 0;
        std::size_t undumped_chars = 0;

        for (std::size_t i = 0; i < s.size(); ++i)
        {
            const auto byte = static_cast<std::uint8_t>(s[i]);

            switch (decode(state, codepoint, byte))
            {
                case UTF8_ACCEPT:  // decode found a new code point
                {
                    switch (codepoint)
                    {
                        case 0x08: // backspace
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'b';
                            break;
                        }

                        case 0x09: // horizontal tab
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 't';
                            break;
                        }

                        case 0x0A: // newline
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'n';
                            break;
                        }

                        case 0x0C: // formfeed
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'f';
                            break;
                        }

                        case 0x0D: // carriage return
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'r';
                            break;
                        }

                        case 0x22: // quotation mark
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = '\"';
                            break;
                        }

                        case 0x5C: // reverse solidus
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = '\\';
                            break;
                        }

                        default:
                        {
                            // escape control characters (0x00..0x1F) or, if
                            // ensure_ascii parameter is used, non-ASCII characters
                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
                            {
                                if (codepoint <= 0xFFFF)
                                {
                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
                                                                      static_cast<std::uint16_t>(codepoint)));
                                    bytes += 6;
                                }
                                else
                                {
                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
                                    bytes += 12;
                                }
                            }
                            else
                            {
                                // copy byte to buffer (all previous bytes
                                // been copied have in default case above)
                                string_buffer[bytes++] = s[i];
                            }
                            break;
                        }
                    }

                    // write buffer and reset index; there must be 13 bytes
                    // left, as this is the maximal number of bytes to be
                    // written ("\uxxxx\uxxxx\0") for one code point
                    if (string_buffer.size() - bytes < 13)
                    {
                        o->write_characters(string_buffer.data(), bytes);
                        bytes = 0;
                    }

                    // remember the byte position of this accept
                    bytes_after_last_accept = bytes;
                    undumped_chars = 0;
                    break;
                }

                case UTF8_REJECT:  // decode found invalid UTF-8 byte
                {
                    switch (error_handler)
                    {
                        case error_handler_t::strict:
                        {
                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
                        }

                        case error_handler_t::ignore:
                        case error_handler_t::replace:
                        {
                            // in case we saw this character the first time, we
                            // would like to read it again, because the byte
                            // may be OK for itself, but just not OK for the
                            // previous sequence
                            if (undumped_chars > 0)
                            {
                                --i;
                            }

                            // reset length buffer to the last accepted index;
                            // thus removing/ignoring the invalid characters
                            bytes = bytes_after_last_accept;

                            if (error_handler == error_handler_t::replace)
                            {
                                // add a replacement character
                                if (ensure_ascii)
                                {
                                    string_buffer[bytes++] = '\\';
                                    string_buffer[bytes++] = 'u';
                                    string_buffer[bytes++] = 'f';
                                    string_buffer[bytes++] = 'f';
                                    string_buffer[bytes++] = 'f';
                                    string_buffer[bytes++] = 'd';
                                }
                                else
                                {
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
                                }

                                // write buffer and reset index; there must be 13 bytes
                                // left, as this is the maximal number of bytes to be
                                // written ("\uxxxx\uxxxx\0") for one code point
                                if (string_buffer.size() - bytes < 13)
                                {
                                    o->write_characters(string_buffer.data(), bytes);
                                    bytes = 0;
                                }

                                bytes_after_last_accept = bytes;
                            }

                            undumped_chars = 0;

                            // continue processing the string
                            state = UTF8_ACCEPT;
                            break;
                        }

                        default:            // LCOV_EXCL_LINE
                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
                    }
                    break;
                }

                default:  // decode found yet incomplete multi-byte code point
                {
                    if (!ensure_ascii)
                    {
                        // code point will not be escaped - copy byte to buffer
                        string_buffer[bytes++] = s[i];
                    }
                    ++undumped_chars;
                    break;
                }
            }
        }

        // we finished processing the string
        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
        {
            // write buffer
            if (bytes > 0)
            {
                o->write_characters(string_buffer.data(), bytes);
            }
        }
        else
        {
            // we finish reading, but do not accept: string was incomplete
            switch (error_handler)
            {
                case error_handler_t::strict:
                {
                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
                }

                case error_handler_t::ignore:
                {
                    // write all accepted bytes
                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
                    break;
                }

                case error_handler_t::replace:
                {
                    // write all accepted bytes
                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
                    // add a replacement character
                    if (ensure_ascii)
                    {
                        o->write_characters("\\ufffd", 6);
                    }
                    else
                    {
                        o->write_characters("\xEF\xBF\xBD", 3);
                    }
                    break;
                }

                default:            // LCOV_EXCL_LINE
                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
            }
        }
    }

  private:
    /*!
    @brief count digits

    Count the number of decimal (base 10) digits for an input unsigned integer.

    @param[in] x  unsigned integer number to count its digits
    @return    number of decimal digits
    */
    inline unsigned int count_digits(number_unsigned_t x) noexcept
    {
        unsigned int n_digits = 1;
        for (;;)
        {
            if (x < 10)
            {
                return n_digits;
            }
            if (x < 100)
            {
                return n_digits + 1;
            }
            if (x < 1000)
            {
                return n_digits + 2;
            }
            if (x < 10000)
            {
                return n_digits + 3;
            }
            x = x / 10000u;
            n_digits += 4;
        }
    }

    /*!
     * @brief convert a byte to a uppercase hex representation
     * @param[in] byte byte to represent
     * @return representation ("00".."FF")
     */
    static std::string hex_bytes(std::uint8_t byte)
    {
        std::string result = "FF";
        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
        result[0] = nibble_to_hex[byte / 16];
        result[1] = nibble_to_hex[byte % 16];
        return result;
    }

    // templates to avoid warnings about useless casts
    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
    bool is_negative_number(NumberType x)
    {
        return x < 0;
    }

    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
    bool is_negative_number(NumberType /*unused*/)
    {
        return false;
    }

    /*!
    @brief dump an integer

    Dump a given integer to output stream @a o. Works internally with
    @a number_buffer.

    @param[in] x  integer number (signed or unsigned) to dump
    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
    */
    template < typename NumberType, detail::enable_if_t <
                   std::is_integral<NumberType>::value ||
                   std::is_same<NumberType, number_unsigned_t>::value ||
                   std::is_same<NumberType, number_integer_t>::value ||
                   std::is_same<NumberType, binary_char_t>::value,
                   int > = 0 >
    void dump_integer(NumberType x)
    {
        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
        {
            {
                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
            }
        };

        // special case for "0"
        if (x == 0)
        {
            o->write_character('0');
            return;
        }

        // use a pointer to fill the buffer
        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)

        number_unsigned_t abs_value;

        unsigned int n_chars{};

        if (is_negative_number(x))
        {
            *buffer_ptr = '-';
            abs_value = remove_sign(static_cast<number_integer_t>(x));

            // account one more byte for the minus sign
            n_chars = 1 + count_digits(abs_value);
        }
        else
        {
            abs_value = static_cast<number_unsigned_t>(x);
            n_chars = count_digits(abs_value);
        }

        // spare 1 byte for '\0'
        JSON_ASSERT(n_chars < number_buffer.size() - 1);

        // jump to the end to generate the string from backward,
        // so we later avoid reversing the result
        buffer_ptr += n_chars;

        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
        while (abs_value >= 100)
        {
            const auto digits_index = static_cast<unsigned>((abs_value % 100));
            abs_value /= 100;
            *(--buffer_ptr) = digits_to_99[digits_index][1];
            *(--buffer_ptr) = digits_to_99[digits_index][0];
        }

        if (abs_value >= 10)
        {
            const auto digits_index = static_cast<unsigned>(abs_value);
            *(--buffer_ptr) = digits_to_99[digits_index][1];
            *(--buffer_ptr) = digits_to_99[digits_index][0];
        }
        else
        {
            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
        }

        o->write_characters(number_buffer.data(), n_chars);
    }

    /*!
    @brief dump a floating-point number

    Dump a given floating-point number to output stream @a o. Works internally
    with @a number_buffer.

    @param[in] x  floating-point number to dump
    */
    void dump_float(number_float_t x)
    {
        // NaN / inf
        if (!std::isfinite(x))
        {
            o->write_characters("null", 4);
            return;
        }

        // If number_float_t is an IEEE-754 single or double precision number,
        // use the Grisu2 algorithm to produce short numbers which are
        // guaranteed to round-trip, using strtof and strtod, resp.
        //
        // NB: The test below works if <long double> == <double>.
        static constexpr bool is_ieee_single_or_double
            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);

        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
    }

    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
    {
        auto* begin = number_buffer.data();
        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);

        o->write_characters(begin, static_cast<size_t>(end - begin));
    }

    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
    {
        // get number of digits for a float -> text -> float round-trip
        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;

        // the actual conversion
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);

        // negative value indicates an error
        JSON_ASSERT(len > 0);
        // check if buffer was large enough
        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());

        // erase thousands separator
        if (thousands_sep != '\0')
        {
            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
            std::fill(end, number_buffer.end(), '\0');
            JSON_ASSERT((end - number_buffer.begin()) <= len);
            len = (end - number_buffer.begin());
        }

        // convert decimal point to '.'
        if (decimal_point != '\0' && decimal_point != '.')
        {
            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
            if (dec_pos != number_buffer.end())
            {
                *dec_pos = '.';
            }
        }

        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));

        // determine if we need to append ".0"
        const bool value_is_int_like =
            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
                         [](char c)
        {
            return c == '.' || c == 'e';
        });

        if (value_is_int_like)
        {
            o->write_characters(".0", 2);
        }
    }

    /*!
    @brief check whether a string is UTF-8 encoded

    The function checks each byte of a string whether it is UTF-8 encoded. The
    result of the check is stored in the @a state parameter. The function must
    be called initially with state 0 (accept). State 1 means the string must
    be rejected, because the current byte is not allowed. If the string is
    completely processed, but the state is non-zero, the string ended
    prematurely; that is, the last byte indicated more bytes should have
    followed.

    @param[in,out] state  the state of the decoding
    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
    @param[in] byte       next byte to decode
    @return               new state

    @note The function has been edited: a std::array is used.

    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
    */
    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
    {
        static const std::array<std::uint8_t, 400> utf8d =
        {
            {
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
            }
        };

        JSON_ASSERT(byte < utf8d.size());
        const std::uint8_t type = utf8d[byte];

        codep = (state != UTF8_ACCEPT)
                ? (byte & 0x3fu) | (codep << 6u)
                : (0xFFu >> type) & (byte);

        const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
        JSON_ASSERT(index < utf8d.size());
        state = utf8d[index];
        return state;
    }

    /*
     * Overload to make the compiler happy while it is instantiating
     * dump_integer for number_unsigned_t.
     * Must never be called.
     */
    number_unsigned_t remove_sign(number_unsigned_t x)
    {
        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
        return x; // LCOV_EXCL_LINE
    }

    /*
     * Helper function for dump_integer
     *
     * This function takes a negative signed integer and returns its absolute
     * value as unsigned integer. The plus/minus shuffling is necessary as we can
     * not directly remove the sign of an arbitrary signed integer as the
     * absolute values of INT_MIN and INT_MAX are usually not the same. See
     * #1708 for details.
     */
    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
    {
        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
    }

  private:
    /// the output of the serializer
    output_adapter_t<char> o = nullptr;

    /// a (hopefully) large enough character buffer
    std::array<char, 64> number_buffer{{}};

    /// the locale
    const std::lconv* loc = nullptr;
    /// the locale's thousand separator character
    const char thousands_sep = '\0';
    /// the locale's decimal point character
    const char decimal_point = '\0';

    /// string buffer
    std::array<char, 512> string_buffer{{}};

    /// the indentation character
    const char indent_char;
    /// the indentation string
    string_t indent_string;

    /// error_handler how to react on decoding errors
    const error_handler_t error_handler;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END

// #include <nlohmann/detail/value_t.hpp>

// #include <nlohmann/json_fwd.hpp>

// #include <nlohmann/ordered_map.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#include <functional> // equal_to, less
#include <initializer_list> // initializer_list
#include <iterator> // input_iterator_tag, iterator_traits
#include <memory> // allocator
#include <stdexcept> // for out_of_range
#include <type_traits> // enable_if, is_convertible
#include <utility> // pair
#include <vector> // vector

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>


NLOHMANN_JSON_NAMESPACE_BEGIN

/// ordered_map: a minimal map-like container that preserves insertion order
/// for use within nlohmann::basic_json<ordered_map>
template <class Key, class T, class IgnoredLess = std::less<Key>,
          class Allocator = std::allocator<std::pair<const Key, T>>>
                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
{
    using key_type = Key;
    using mapped_type = T;
    using Container = std::vector<std::pair<const Key, T>, Allocator>;
    using iterator = typename Container::iterator;
    using const_iterator = typename Container::const_iterator;
    using size_type = typename Container::size_type;
    using value_type = typename Container::value_type;
#ifdef JSON_HAS_CPP_14
    using key_compare = std::equal_to<>;
#else
    using key_compare = std::equal_to<Key>;
#endif

    // Explicit constructors instead of `using Container::Container`
    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
    ordered_map() noexcept(noexcept(Container())) : Container{} {}
    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
    template <class It>
    ordered_map(It first, It last, const Allocator& alloc = Allocator())
        : Container{first, last, alloc} {}
    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
        : Container{init, alloc} {}

    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return {it, false};
            }
        }
        Container::emplace_back(key, std::forward<T>(t));
        return {std::prev(this->end()), true};
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    std::pair<iterator, bool> emplace(KeyType && key, T && t)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return {it, false};
            }
        }
        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
        return {std::prev(this->end()), true};
    }

    T& operator[](const key_type& key)
    {
        return emplace(key, T{}).first->second;
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    T & operator[](KeyType && key)
    {
        return emplace(std::forward<KeyType>(key), T{}).first->second;
    }

    const T& operator[](const key_type& key) const
    {
        return at(key);
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    const T & operator[](KeyType && key) const
    {
        return at(std::forward<KeyType>(key));
    }

    T& at(const key_type& key)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return it->second;
            }
        }

        JSON_THROW(std::out_of_range("key not found"));
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return it->second;
            }
        }

        JSON_THROW(std::out_of_range("key not found"));
    }

    const T& at(const key_type& key) const
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return it->second;
            }
        }

        JSON_THROW(std::out_of_range("key not found"));
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return it->second;
            }
        }

        JSON_THROW(std::out_of_range("key not found"));
    }

    size_type erase(const key_type& key)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                // Since we cannot move const Keys, re-construct them in place
                for (auto next = it; ++next != this->end(); ++it)
                {
                    it->~value_type(); // Destroy but keep allocation
                    new (&*it) value_type{std::move(*next)};
                }
                Container::pop_back();
                return 1;
            }
        }
        return 0;
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                // Since we cannot move const Keys, re-construct them in place
                for (auto next = it; ++next != this->end(); ++it)
                {
                    it->~value_type(); // Destroy but keep allocation
                    new (&*it) value_type{std::move(*next)};
                }
                Container::pop_back();
                return 1;
            }
        }
        return 0;
    }

    iterator erase(iterator pos)
    {
        return erase(pos, std::next(pos));
    }

    iterator erase(iterator first, iterator last)
    {
        if (first == last)
        {
            return first;
        }

        const auto elements_affected = std::distance(first, last);
        const auto offset = std::distance(Container::begin(), first);

        // This is the start situation. We need to delete elements_affected
        // elements (3 in this example: e, f, g), and need to return an
        // iterator past the last deleted element (h in this example).
        // Note that offset is the distance from the start of the vector
        // to first. We will need this later.

        // [ a, b, c, d, e, f, g, h, i, j ]
        //               ^        ^
        //             first    last

        // Since we cannot move const Keys, we re-construct them in place.
        // We start at first and re-construct (viz. copy) the elements from
        // the back of the vector. Example for first iteration:

        //               ,--------.
        //               v        |   destroy e and re-construct with h
        // [ a, b, c, d, e, f, g, h, i, j ]
        //               ^        ^
        //               it       it + elements_affected

        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
        {
            it->~value_type(); // destroy but keep allocation
            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
        }

        // [ a, b, c, d, h, i, j, h, i, j ]
        //               ^        ^
        //             first    last

        // remove the unneeded elements at the end of the vector
        Container::resize(this->size() - static_cast<size_type>(elements_affected));

        // [ a, b, c, d, h, i, j ]
        //               ^        ^
        //             first    last

        // first is now pointing past the last deleted element, but we cannot
        // use this iterator, because it may have been invalidated by the
        // resize call. Instead, we can return begin() + offset.
        return Container::begin() + offset;
    }

    size_type count(const key_type& key) const
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return 1;
            }
        }
        return 0;
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return 1;
            }
        }
        return 0;
    }

    iterator find(const key_type& key)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return it;
            }
        }
        return Container::end();
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return it;
            }
        }
        return Container::end();
    }

    const_iterator find(const key_type& key) const
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, key))
            {
                return it;
            }
        }
        return Container::end();
    }

    std::pair<iterator, bool> insert( value_type&& value )
    {
        return emplace(value.first, std::move(value.second));
    }

    std::pair<iterator, bool> insert( const value_type& value )
    {
        for (auto it = this->begin(); it != this->end(); ++it)
        {
            if (m_compare(it->first, value.first))
            {
                return {it, false};
            }
        }
        Container::push_back(value);
        return {--this->end(), true};
    }

    template<typename InputIt>
    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
            std::input_iterator_tag>::value>::type;

    template<typename InputIt, typename = require_input_iter<InputIt>>
    void insert(InputIt first, InputIt last)
    {
        for (auto it = first; it != last; ++it)
        {
            insert(*it);
        }
    }

private:
    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
};

NLOHMANN_JSON_NAMESPACE_END


#if defined(JSON_HAS_CPP_17)
    #if JSON_HAS_STATIC_RTTI
        #include <any>
    #endif
    #include <string_view>
#endif

/*!
@brief namespace for Niels Lohmann
@see https://github.com/nlohmann
@since version 1.0.0
*/
NLOHMANN_JSON_NAMESPACE_BEGIN

/*!
@brief a class to store JSON values

@internal
@invariant The member variables @a m_value and @a m_type have the following
relationship:
- If `m_type == value_t::object`, then `m_value.object != nullptr`.
- If `m_type == value_t::array`, then `m_value.array != nullptr`.
- If `m_type == value_t::string`, then `m_value.string != nullptr`.
The invariants are checked by member function assert_invariant().

@note ObjectType trick from https://stackoverflow.com/a/9860911
@endinternal

@since version 1.0.0

@nosubgrouping
*/
NLOHMANN_BASIC_JSON_TPL_DECLARATION
class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
    : public ::nlohmann::detail::json_base_class<CustomBaseClass>
{
  private:
    template<detail::value_t> friend struct detail::external_constructor;

    template<typename>
    friend class ::nlohmann::json_pointer;
    // can be restored when json_pointer backwards compatibility is removed
    // friend ::nlohmann::json_pointer<StringType>;

    template<typename BasicJsonType, typename InputType>
    friend class ::nlohmann::detail::parser;
    friend ::nlohmann::detail::serializer<basic_json>;
    template<typename BasicJsonType>
    friend class ::nlohmann::detail::iter_impl;
    template<typename BasicJsonType, typename CharType>
    friend class ::nlohmann::detail::binary_writer;
    template<typename BasicJsonType, typename InputType, typename SAX>
    friend class ::nlohmann::detail::binary_reader;
    template<typename BasicJsonType>
    friend class ::nlohmann::detail::json_sax_dom_parser;
    template<typename BasicJsonType>
    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
    friend class ::nlohmann::detail::exception;

    /// workaround type for MSVC
    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
    using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;

  JSON_PRIVATE_UNLESS_TESTED:
    // convenience aliases for types residing in namespace detail;
    using lexer = ::nlohmann::detail::lexer_base<basic_json>;

    template<typename InputAdapterType>
    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
        InputAdapterType adapter,
        detail::parser_callback_t<basic_json>cb = nullptr,
        const bool allow_exceptions = true,
        const bool ignore_comments = false
                                 )
    {
        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
                std::move(cb), allow_exceptions, ignore_comments);
    }

  private:
    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
    template<typename BasicJsonType>
    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
    template<typename BasicJsonType>
    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
    template<typename Iterator>
    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;

    template<typename CharType>
    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;

    template<typename InputType>
    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;

  JSON_PRIVATE_UNLESS_TESTED:
    using serializer = ::nlohmann::detail::serializer<basic_json>;

  public:
    using value_t = detail::value_t;
    /// JSON Pointer, see @ref nlohmann::json_pointer
    using json_pointer = ::nlohmann::json_pointer<StringType>;
    template<typename T, typename SFINAE>
    using json_serializer = JSONSerializer<T, SFINAE>;
    /// how to treat decoding errors
    using error_handler_t = detail::error_handler_t;
    /// how to treat CBOR tags
    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
    /// helper type for initializer lists of basic_json values
    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;

    using input_format_t = detail::input_format_t;
    /// SAX interface type, see @ref nlohmann::json_sax
    using json_sax_t = json_sax<basic_json>;

    ////////////////
    // exceptions //
    ////////////////

    /// @name exceptions
    /// Classes to implement user-defined exceptions.
    /// @{

    using exception = detail::exception;
    using parse_error = detail::parse_error;
    using invalid_iterator = detail::invalid_iterator;
    using type_error = detail::type_error;
    using out_of_range = detail::out_of_range;
    using other_error = detail::other_error;

    /// @}

    /////////////////////
    // container types //
    /////////////////////

    /// @name container types
    /// The canonic container types to use @ref basic_json like any other STL
    /// container.
    /// @{

    /// the type of elements in a basic_json container
    using value_type = basic_json;

    /// the type of an element reference
    using reference = value_type&;
    /// the type of an element const reference
    using const_reference = const value_type&;

    /// a type to represent differences between iterators
    using difference_type = std::ptrdiff_t;
    /// a type to represent container sizes
    using size_type = std::size_t;

    /// the allocator type
    using allocator_type = AllocatorType<basic_json>;

    /// the type of an element pointer
    using pointer = typename std::allocator_traits<allocator_type>::pointer;
    /// the type of an element const pointer
    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;

    /// an iterator for a basic_json container
    using iterator = iter_impl<basic_json>;
    /// a const iterator for a basic_json container
    using const_iterator = iter_impl<const basic_json>;
    /// a reverse iterator for a basic_json container
    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
    /// a const reverse iterator for a basic_json container
    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;

    /// @}

    /// @brief returns the allocator associated with the container
    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
    static allocator_type get_allocator()
    {
        return allocator_type();
    }

    /// @brief returns version information on the library
    /// @sa https://json.nlohmann.me/api/basic_json/meta/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json meta()
    {
        basic_json result;

        result["copyright"] = "(C) 2013-2023 Niels Lohmann";
        result["name"] = "JSON for Modern C++";
        result["url"] = "https://github.com/nlohmann/json";
        result["version"]["string"] =
            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));
        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;

#ifdef _WIN32
        result["platform"] = "win32";
#elif defined __linux__
        result["platform"] = "linux";
#elif defined __APPLE__
        result["platform"] = "apple";
#elif defined __unix__
        result["platform"] = "unix";
#else
        result["platform"] = "unknown";
#endif

#if defined(__ICC) || defined(__INTEL_COMPILER)
        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
#elif defined(__clang__)
        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
#elif defined(__GNUC__) || defined(__GNUG__)
        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
                    std::to_string(__GNUC__), '.',
                    std::to_string(__GNUC_MINOR__), '.',
                    std::to_string(__GNUC_PATCHLEVEL__))
            }
        };
#elif defined(__HP_cc) || defined(__HP_aCC)
        result["compiler"] = "hp"
#elif defined(__IBMCPP__)
        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
#elif defined(_MSC_VER)
        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
#elif defined(__PGI)
        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
#elif defined(__SUNPRO_CC)
        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
#else
        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
#endif

#if defined(_MSVC_LANG)
        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
#elif defined(__cplusplus)
        result["compiler"]["c++"] = std::to_string(__cplusplus);
#else
        result["compiler"]["c++"] = "unknown";
#endif
        return result;
    }

    ///////////////////////////
    // JSON value data types //
    ///////////////////////////

    /// @name JSON value data types
    /// The data types to store a JSON value. These types are derived from
    /// the template arguments passed to class @ref basic_json.
    /// @{

    /// @brief default object key comparator type
    /// The actual object key comparator type (@ref object_comparator_t) may be
    /// different.
    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
#if defined(JSON_HAS_CPP_14)
    // use of transparent comparator avoids unnecessary repeated construction of temporaries
    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
    using default_object_comparator_t = std::less<>;
#else
    using default_object_comparator_t = std::less<StringType>;
#endif

    /// @brief a type for an object
    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
    using object_t = ObjectType<StringType,
          basic_json,
          default_object_comparator_t,
          AllocatorType<std::pair<const StringType,
          basic_json>>>;

    /// @brief a type for an array
    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;

    /// @brief a type for a string
    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
    using string_t = StringType;

    /// @brief a type for a boolean
    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
    using boolean_t = BooleanType;

    /// @brief a type for a number (integer)
    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
    using number_integer_t = NumberIntegerType;

    /// @brief a type for a number (unsigned)
    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
    using number_unsigned_t = NumberUnsignedType;

    /// @brief a type for a number (floating-point)
    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
    using number_float_t = NumberFloatType;

    /// @brief a type for a packed binary type
    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;

    /// @brief object key comparator type
    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;

    /// @}

  private:

    /// helper for exception-safe object creation
    template<typename T, typename... Args>
    JSON_HEDLEY_RETURNS_NON_NULL
    static T* create(Args&& ... args)
    {
        AllocatorType<T> alloc;
        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;

        auto deleter = [&](T * obj)
        {
            AllocatorTraits::deallocate(alloc, obj, 1);
        };
        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
        JSON_ASSERT(obj != nullptr);
        return obj.release();
    }

    ////////////////////////
    // JSON value storage //
    ////////////////////////

  JSON_PRIVATE_UNLESS_TESTED:
    /*!
    @brief a JSON value

    The actual storage for a JSON value of the @ref basic_json class. This
    union combines the different storage types for the JSON value types
    defined in @ref value_t.

    JSON type | value_t type    | used type
    --------- | --------------- | ------------------------
    object    | object          | pointer to @ref object_t
    array     | array           | pointer to @ref array_t
    string    | string          | pointer to @ref string_t
    boolean   | boolean         | @ref boolean_t
    number    | number_integer  | @ref number_integer_t
    number    | number_unsigned | @ref number_unsigned_t
    number    | number_float    | @ref number_float_t
    binary    | binary          | pointer to @ref binary_t
    null      | null            | *no value is stored*

    @note Variable-length types (objects, arrays, and strings) are stored as
    pointers. The size of the union should not exceed 64 bits if the default
    value types are used.

    @since version 1.0.0
    */
    union json_value
    {
        /// object (stored with pointer to save storage)
        object_t* object;
        /// array (stored with pointer to save storage)
        array_t* array;
        /// string (stored with pointer to save storage)
        string_t* string;
        /// binary (stored with pointer to save storage)
        binary_t* binary;
        /// boolean
        boolean_t boolean;
        /// number (integer)
        number_integer_t number_integer;
        /// number (unsigned integer)
        number_unsigned_t number_unsigned;
        /// number (floating-point)
        number_float_t number_float;

        /// default constructor (for null values)
        json_value() = default;
        /// constructor for booleans
        json_value(boolean_t v) noexcept : boolean(v) {}
        /// constructor for numbers (integer)
        json_value(number_integer_t v) noexcept : number_integer(v) {}
        /// constructor for numbers (unsigned)
        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
        /// constructor for numbers (floating-point)
        json_value(number_float_t v) noexcept : number_float(v) {}
        /// constructor for empty values of a given type
        json_value(value_t t)
        {
            switch (t)
            {
                case value_t::object:
                {
                    object = create<object_t>();
                    break;
                }

                case value_t::array:
                {
                    array = create<array_t>();
                    break;
                }

                case value_t::string:
                {
                    string = create<string_t>("");
                    break;
                }

                case value_t::binary:
                {
                    binary = create<binary_t>();
                    break;
                }

                case value_t::boolean:
                {
                    boolean = static_cast<boolean_t>(false);
                    break;
                }

                case value_t::number_integer:
                {
                    number_integer = static_cast<number_integer_t>(0);
                    break;
                }

                case value_t::number_unsigned:
                {
                    number_unsigned = static_cast<number_unsigned_t>(0);
                    break;
                }

                case value_t::number_float:
                {
                    number_float = static_cast<number_float_t>(0.0);
                    break;
                }

                case value_t::null:
                {
                    object = nullptr;  // silence warning, see #821
                    break;
                }

                case value_t::discarded:
                default:
                {
                    object = nullptr;  // silence warning, see #821
                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
                    {
                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
                    }
                    break;
                }
            }
        }

        /// constructor for strings
        json_value(const string_t& value) : string(create<string_t>(value)) {}

        /// constructor for rvalue strings
        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}

        /// constructor for objects
        json_value(const object_t& value) : object(create<object_t>(value)) {}

        /// constructor for rvalue objects
        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}

        /// constructor for arrays
        json_value(const array_t& value) : array(create<array_t>(value)) {}

        /// constructor for rvalue arrays
        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}

        /// constructor for binary arrays
        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}

        /// constructor for rvalue binary arrays
        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}

        /// constructor for binary arrays (internal type)
        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}

        /// constructor for rvalue binary arrays (internal type)
        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}

        void destroy(value_t t)
        {
            if (
                (t == value_t::object && object == nullptr) ||
                (t == value_t::array && array == nullptr) ||
                (t == value_t::string && string == nullptr) ||
                (t == value_t::binary && binary == nullptr)
            )
            {
                //not initialized (e.g. due to exception in the ctor)
                return;
            }
            if (t == value_t::array || t == value_t::object)
            {
                // flatten the current json_value to a heap-allocated stack
                std::vector<basic_json> stack;

                // move the top-level items to stack
                if (t == value_t::array)
                {
                    stack.reserve(array->size());
                    std::move(array->begin(), array->end(), std::back_inserter(stack));
                }
                else
                {
                    stack.reserve(object->size());
                    for (auto&& it : *object)
                    {
                        stack.push_back(std::move(it.second));
                    }
                }

                while (!stack.empty())
                {
                    // move the last item to local variable to be processed
                    basic_json current_item(std::move(stack.back()));
                    stack.pop_back();

                    // if current_item is array/object, move
                    // its children to the stack to be processed later
                    if (current_item.is_array())
                    {
                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));

                        current_item.m_data.m_value.array->clear();
                    }
                    else if (current_item.is_object())
                    {
                        for (auto&& it : *current_item.m_data.m_value.object)
                        {
                            stack.push_back(std::move(it.second));
                        }

                        current_item.m_data.m_value.object->clear();
                    }

                    // it's now safe that current_item get destructed
                    // since it doesn't have any children
                }
            }

            switch (t)
            {
                case value_t::object:
                {
                    AllocatorType<object_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
                    break;
                }

                case value_t::array:
                {
                    AllocatorType<array_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
                    break;
                }

                case value_t::string:
                {
                    AllocatorType<string_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
                    break;
                }

                case value_t::binary:
                {
                    AllocatorType<binary_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
                    break;
                }

                case value_t::null:
                case value_t::boolean:
                case value_t::number_integer:
                case value_t::number_unsigned:
                case value_t::number_float:
                case value_t::discarded:
                default:
                {
                    break;
                }
            }
        }
    };

  private:
    /*!
    @brief checks the class invariants

    This function asserts the class invariants. It needs to be called at the
    end of every constructor to make sure that created objects respect the
    invariant. Furthermore, it has to be called each time the type of a JSON
    value is changed, because the invariant expresses a relationship between
    @a m_type and @a m_value.

    Furthermore, the parent relation is checked for arrays and objects: If
    @a check_parents true and the value is an array or object, then the
    container's elements must have the current value as parent.

    @param[in] check_parents  whether the parent relation should be checked.
               The value is true by default and should only be set to false
               during destruction of objects when the invariant does not
               need to hold.
    */
    void assert_invariant(bool check_parents = true) const noexcept
    {
        JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
        JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
        JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
        JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);

#if JSON_DIAGNOSTICS
        JSON_TRY
        {
            // cppcheck-suppress assertWithSideEffect
            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
            {
                return j.m_parent == this;
            }));
        }
        JSON_CATCH(...) {} // LCOV_EXCL_LINE
#endif
        static_cast<void>(check_parents);
    }

    void set_parents()
    {
#if JSON_DIAGNOSTICS
        switch (m_data.m_type)
        {
            case value_t::array:
            {
                for (auto& element : *m_data.m_value.array)
                {
                    element.m_parent = this;
                }
                break;
            }

            case value_t::object:
            {
                for (auto& element : *m_data.m_value.object)
                {
                    element.second.m_parent = this;
                }
                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
                break;
        }
#endif
    }

    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
    {
#if JSON_DIAGNOSTICS
        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
        {
            (it + i)->m_parent = this;
        }
#else
        static_cast<void>(count_set_parents);
#endif
        return it;
    }

    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
    {
#if JSON_DIAGNOSTICS
        if (old_capacity != static_cast<std::size_t>(-1))
        {
            // see https://github.com/nlohmann/json/issues/2838
            JSON_ASSERT(type() == value_t::array);
            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
            {
                // capacity has changed: update all parents
                set_parents();
                return j;
            }
        }

        // ordered_json uses a vector internally, so pointers could have
        // been invalidated; see https://github.com/nlohmann/json/issues/2962
#ifdef JSON_HEDLEY_MSVC_VERSION
#pragma warning(push )
#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
#endif
        if (detail::is_ordered_map<object_t>::value)
        {
            set_parents();
            return j;
        }
#ifdef JSON_HEDLEY_MSVC_VERSION
#pragma warning( pop )
#endif

        j.m_parent = this;
#else
        static_cast<void>(j);
        static_cast<void>(old_capacity);
#endif
        return j;
    }

  public:
    //////////////////////////
    // JSON parser callback //
    //////////////////////////

    /// @brief parser event types
    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
    using parse_event_t = detail::parse_event_t;

    /// @brief per-element parser callback type
    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
    using parser_callback_t = detail::parser_callback_t<basic_json>;

    //////////////////
    // constructors //
    //////////////////

    /// @name constructors and destructors
    /// Constructors of class @ref basic_json, copy/move constructor, copy
    /// assignment, static functions creating objects, and the destructor.
    /// @{

    /// @brief create an empty value with a given type
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(const value_t v)
        : m_data(v)
    {
        assert_invariant();
    }

    /// @brief create a null object
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
        : basic_json(value_t::null)
    {
        assert_invariant();
    }

    /// @brief create a JSON value from compatible types
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    template < typename CompatibleType,
               typename U = detail::uncvref_t<CompatibleType>,
               detail::enable_if_t <
                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
                                           std::forward<CompatibleType>(val))))
    {
        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
        set_parents();
        assert_invariant();
    }

    /// @brief create a JSON value from an existing one
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    template < typename BasicJsonType,
               detail::enable_if_t <
                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
    basic_json(const BasicJsonType& val)
    {
        using other_boolean_t = typename BasicJsonType::boolean_t;
        using other_number_float_t = typename BasicJsonType::number_float_t;
        using other_number_integer_t = typename BasicJsonType::number_integer_t;
        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
        using other_string_t = typename BasicJsonType::string_t;
        using other_object_t = typename BasicJsonType::object_t;
        using other_array_t = typename BasicJsonType::array_t;
        using other_binary_t = typename BasicJsonType::binary_t;

        switch (val.type())
        {
            case value_t::boolean:
                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
                break;
            case value_t::number_float:
                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
                break;
            case value_t::number_integer:
                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
                break;
            case value_t::number_unsigned:
                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
                break;
            case value_t::string:
                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
                break;
            case value_t::object:
                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
                break;
            case value_t::array:
                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
                break;
            case value_t::binary:
                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
                break;
            case value_t::null:
                *this = nullptr;
                break;
            case value_t::discarded:
                m_data.m_type = value_t::discarded;
                break;
            default:            // LCOV_EXCL_LINE
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
        }
        JSON_ASSERT(m_data.m_type == val.type());
        set_parents();
        assert_invariant();
    }

    /// @brief create a container (array or object) from an initializer list
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(initializer_list_t init,
               bool type_deduction = true,
               value_t manual_type = value_t::array)
    {
        // check if each element is an array with two elements whose first
        // element is a string
        bool is_an_object = std::all_of(init.begin(), init.end(),
                                        [](const detail::json_ref<basic_json>& element_ref)
        {
            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
            // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
        });

        // adjust type if type deduction is not wanted
        if (!type_deduction)
        {
            // if array is wanted, do not create an object though possible
            if (manual_type == value_t::array)
            {
                is_an_object = false;
            }

            // if object is wanted but impossible, throw an exception
            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
            {
                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
            }
        }

        if (is_an_object)
        {
            // the initializer list is a list of pairs -> create object
            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;

            for (auto& element_ref : init)
            {
                auto element = element_ref.moved_or_copied();
                m_data.m_value.object->emplace(
                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
                    std::move((*element.m_data.m_value.array)[1]));
            }
        }
        else
        {
            // the initializer list describes an array -> create array
            m_data.m_type = value_t::array;
            m_data.m_value.array = create<array_t>(init.begin(), init.end());
        }

        set_parents();
        assert_invariant();
    }

    /// @brief explicitly create a binary array (without subtype)
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json binary(const typename binary_t::container_type& init)
    {
        auto res = basic_json();
        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = init;
        return res;
    }

    /// @brief explicitly create a binary array (with subtype)
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = binary_t(init, subtype);
        return res;
    }

    /// @brief explicitly create a binary array
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json binary(typename binary_t::container_type&& init)
    {
        auto res = basic_json();
        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = std::move(init);
        return res;
    }

    /// @brief explicitly create a binary array (with subtype)
    /// @sa https://json.nlohmann.me/api/basic_json/binary/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = binary_t(std::move(init), subtype);
        return res;
    }

    /// @brief explicitly create an array from an initializer list
    /// @sa https://json.nlohmann.me/api/basic_json/array/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json array(initializer_list_t init = {})
    {
        return basic_json(init, false, value_t::array);
    }

    /// @brief explicitly create an object from an initializer list
    /// @sa https://json.nlohmann.me/api/basic_json/object/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json object(initializer_list_t init = {})
    {
        return basic_json(init, false, value_t::object);
    }

    /// @brief construct an array with count copies of given value
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(size_type cnt, const basic_json& val):
        m_data{cnt, val}
    {
        set_parents();
        assert_invariant();
    }

    /// @brief construct a JSON container given an iterator range
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    template < class InputIT, typename std::enable_if <
                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
    basic_json(InputIT first, InputIT last)
    {
        JSON_ASSERT(first.m_object != nullptr);
        JSON_ASSERT(last.m_object != nullptr);

        // make sure iterator fits the current value
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
        }

        // copy type from first iterator
        m_data.m_type = first.m_object->m_data.m_type;

        // check if iterator range is complete for primitive values
        switch (m_data.m_type)
        {
            case value_t::boolean:
            case value_t::number_float:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::string:
            {
                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
                                         || !last.m_it.primitive_iterator.is_end()))
                {
                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
                }
                break;
            }

            case value_t::null:
            case value_t::object:
            case value_t::array:
            case value_t::binary:
            case value_t::discarded:
            default:
                break;
        }

        switch (m_data.m_type)
        {
            case value_t::number_integer:
            {
                m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
                break;
            }

            case value_t::number_unsigned:
            {
                m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
                break;
            }

            case value_t::number_float:
            {
                m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
                break;
            }

            case value_t::boolean:
            {
                m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
                break;
            }

            case value_t::string:
            {
                m_data.m_value = *first.m_object->m_data.m_value.string;
                break;
            }

            case value_t::object:
            {
                m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
                                        last.m_it.object_iterator);
                break;
            }

            case value_t::array:
            {
                m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
                                                       last.m_it.array_iterator);
                break;
            }

            case value_t::binary:
            {
                m_data.m_value = *first.m_object->m_data.m_value.binary;
                break;
            }

            case value_t::null:
            case value_t::discarded:
            default:
                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
        }

        set_parents();
        assert_invariant();
    }

    ///////////////////////////////////////
    // other constructors and destructor //
    ///////////////////////////////////////

    template<typename JsonRef,
             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}

    /// @brief copy constructor
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(const basic_json& other)
        : json_base_class_t(other)
    {
        m_data.m_type = other.m_data.m_type;
        // check of passed value is valid
        other.assert_invariant();

        switch (m_data.m_type)
        {
            case value_t::object:
            {
                m_data.m_value = *other.m_data.m_value.object;
                break;
            }

            case value_t::array:
            {
                m_data.m_value = *other.m_data.m_value.array;
                break;
            }

            case value_t::string:
            {
                m_data.m_value = *other.m_data.m_value.string;
                break;
            }

            case value_t::boolean:
            {
                m_data.m_value = other.m_data.m_value.boolean;
                break;
            }

            case value_t::number_integer:
            {
                m_data.m_value = other.m_data.m_value.number_integer;
                break;
            }

            case value_t::number_unsigned:
            {
                m_data.m_value = other.m_data.m_value.number_unsigned;
                break;
            }

            case value_t::number_float:
            {
                m_data.m_value = other.m_data.m_value.number_float;
                break;
            }

            case value_t::binary:
            {
                m_data.m_value = *other.m_data.m_value.binary;
                break;
            }

            case value_t::null:
            case value_t::discarded:
            default:
                break;
        }

        set_parents();
        assert_invariant();
    }

    /// @brief move constructor
    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
    basic_json(basic_json&& other) noexcept
        : json_base_class_t(std::forward<json_base_class_t>(other)),
          m_data(std::move(other.m_data))
    {
        // check that passed value is valid
        other.assert_invariant(false);

        // invalidate payload
        other.m_data.m_type = value_t::null;
        other.m_data.m_value = {};

        set_parents();
        assert_invariant();
    }

    /// @brief copy assignment
    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
    basic_json& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value&&
        std::is_nothrow_move_assignable<value_t>::value&&
        std::is_nothrow_move_constructible<json_value>::value&&
        std::is_nothrow_move_assignable<json_value>::value&&
        std::is_nothrow_move_assignable<json_base_class_t>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_data.m_type, other.m_data.m_type);
        swap(m_data.m_value, other.m_data.m_value);
        json_base_class_t::operator=(std::move(other));

        set_parents();
        assert_invariant();
        return *this;
    }

    /// @brief destructor
    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
    ~basic_json() noexcept
    {
        assert_invariant(false);
    }

    /// @}

  public:
    ///////////////////////
    // object inspection //
    ///////////////////////

    /// @name object inspection
    /// Functions to inspect the type of a JSON value.
    /// @{

    /// @brief serialization
    /// @sa https://json.nlohmann.me/api/basic_json/dump/
    string_t dump(const int indent = -1,
                  const char indent_char = ' ',
                  const bool ensure_ascii = false,
                  const error_handler_t error_handler = error_handler_t::strict) const
    {
        string_t result;
        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);

        if (indent >= 0)
        {
            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
        }
        else
        {
            s.dump(*this, false, ensure_ascii, 0);
        }

        return result;
    }

    /// @brief return the type of the JSON value (explicit)
    /// @sa https://json.nlohmann.me/api/basic_json/type/
    constexpr value_t type() const noexcept
    {
        return m_data.m_type;
    }

    /// @brief return whether type is primitive
    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
    constexpr bool is_primitive() const noexcept
    {
        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
    }

    /// @brief return whether type is structured
    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
    constexpr bool is_structured() const noexcept
    {
        return is_array() || is_object();
    }

    /// @brief return whether value is null
    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
    constexpr bool is_null() const noexcept
    {
        return m_data.m_type == value_t::null;
    }

    /// @brief return whether value is a boolean
    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
    constexpr bool is_boolean() const noexcept
    {
        return m_data.m_type == value_t::boolean;
    }

    /// @brief return whether value is a number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
    constexpr bool is_number() const noexcept
    {
        return is_number_integer() || is_number_float();
    }

    /// @brief return whether value is an integer number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
    constexpr bool is_number_integer() const noexcept
    {
        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
    }

    /// @brief return whether value is an unsigned integer number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
    constexpr bool is_number_unsigned() const noexcept
    {
        return m_data.m_type == value_t::number_unsigned;
    }

    /// @brief return whether value is a floating-point number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
    constexpr bool is_number_float() const noexcept
    {
        return m_data.m_type == value_t::number_float;
    }

    /// @brief return whether value is an object
    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
    constexpr bool is_object() const noexcept
    {
        return m_data.m_type == value_t::object;
    }

    /// @brief return whether value is an array
    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
    constexpr bool is_array() const noexcept
    {
        return m_data.m_type == value_t::array;
    }

    /// @brief return whether value is a string
    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
    constexpr bool is_string() const noexcept
    {
        return m_data.m_type == value_t::string;
    }

    /// @brief return whether value is a binary array
    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
    constexpr bool is_binary() const noexcept
    {
        return m_data.m_type == value_t::binary;
    }

    /// @brief return whether value is discarded
    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
    constexpr bool is_discarded() const noexcept
    {
        return m_data.m_type == value_t::discarded;
    }

    /// @brief return the type of the JSON value (implicit)
    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
    constexpr operator value_t() const noexcept
    {
        return m_data.m_type;
    }

    /// @}

  private:
    //////////////////
    // value access //
    //////////////////

    /// get a boolean (explicit)
    boolean_t get_impl(boolean_t* /*unused*/) const
    {
        if (JSON_HEDLEY_LIKELY(is_boolean()))
        {
            return m_data.m_value.boolean;
        }

        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
    }

    /// get a pointer to the value (object)
    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
    {
        return is_object() ? m_data.m_value.object : nullptr;
    }

    /// get a pointer to the value (object)
    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
    {
        return is_object() ? m_data.m_value.object : nullptr;
    }

    /// get a pointer to the value (array)
    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
    {
        return is_array() ? m_data.m_value.array : nullptr;
    }

    /// get a pointer to the value (array)
    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
    {
        return is_array() ? m_data.m_value.array : nullptr;
    }

    /// get a pointer to the value (string)
    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
    {
        return is_string() ? m_data.m_value.string : nullptr;
    }

    /// get a pointer to the value (string)
    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
    {
        return is_string() ? m_data.m_value.string : nullptr;
    }

    /// get a pointer to the value (boolean)
    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
    {
        return is_boolean() ? &m_data.m_value.boolean : nullptr;
    }

    /// get a pointer to the value (boolean)
    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
    {
        return is_boolean() ? &m_data.m_value.boolean : nullptr;
    }

    /// get a pointer to the value (integer number)
    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
    {
        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
    }

    /// get a pointer to the value (integer number)
    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
    {
        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
    }

    /// get a pointer to the value (unsigned number)
    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
    {
        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
    }

    /// get a pointer to the value (unsigned number)
    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
    {
        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
    }

    /// get a pointer to the value (floating-point number)
    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
    {
        return is_number_float() ? &m_data.m_value.number_float : nullptr;
    }

    /// get a pointer to the value (floating-point number)
    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
    {
        return is_number_float() ? &m_data.m_value.number_float : nullptr;
    }

    /// get a pointer to the value (binary)
    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
    {
        return is_binary() ? m_data.m_value.binary : nullptr;
    }

    /// get a pointer to the value (binary)
    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
    {
        return is_binary() ? m_data.m_value.binary : nullptr;
    }

    /*!
    @brief helper function to implement get_ref()

    This function helps to implement get_ref() without code duplication for
    const and non-const overloads

    @tparam ThisType will be deduced as `basic_json` or `const basic_json`

    @throw type_error.303 if ReferenceType does not match underlying value
    type of the current JSON
    */
    template<typename ReferenceType, typename ThisType>
    static ReferenceType get_ref_impl(ThisType& obj)
    {
        // delegate the call to get_ptr<>()
        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();

        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
        {
            return *ptr;
        }

        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
    }

  public:
    /// @name value access
    /// Direct access to the stored value of a JSON value.
    /// @{

    /// @brief get a pointer value (implicit)
    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
    template<typename PointerType, typename std::enable_if<
                 std::is_pointer<PointerType>::value, int>::type = 0>
    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
    {
        // delegate the call to get_impl_ptr<>()
        return get_impl_ptr(static_cast<PointerType>(nullptr));
    }

    /// @brief get a pointer value (implicit)
    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
    template < typename PointerType, typename std::enable_if <
                   std::is_pointer<PointerType>::value&&
                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
    {
        // delegate the call to get_impl_ptr<>() const
        return get_impl_ptr(static_cast<PointerType>(nullptr));
    }

  private:
    /*!
    @brief get a value (explicit)

    Explicit type conversion between the JSON value and a compatible value
    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
    The value is converted by calling the @ref json_serializer<ValueType>
    `from_json()` method.

    The function is equivalent to executing
    @code {.cpp}
    ValueType ret;
    JSONSerializer<ValueType>::from_json(*this, ret);
    return ret;
    @endcode

    This overloads is chosen if:
    - @a ValueType is not @ref basic_json,
    - @ref json_serializer<ValueType> has a `from_json()` method of the form
      `void from_json(const basic_json&, ValueType&)`, and
    - @ref json_serializer<ValueType> does not have a `from_json()` method of
      the form `ValueType from_json(const basic_json&)`

    @tparam ValueType the returned value type

    @return copy of the JSON value, converted to @a ValueType

    @throw what @ref json_serializer<ValueType> `from_json()` method throws

    @liveexample{The example below shows several conversions from JSON values
    to other types. There a few things to note: (1) Floating-point numbers can
    be converted to integers\, (2) A JSON array can be converted to a standard
    `std::vector<short>`\, (3) A JSON object can be converted to C++
    associative containers such as `std::unordered_map<std::string\,
    json>`.,get__ValueType_const}

    @since version 2.1.0
    */
    template < typename ValueType,
               detail::enable_if_t <
                   detail::is_default_constructible<ValueType>::value&&
                   detail::has_from_json<basic_json_t, ValueType>::value,
                   int > = 0 >
    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
    {
        auto ret = ValueType();
        JSONSerializer<ValueType>::from_json(*this, ret);
        return ret;
    }

    /*!
    @brief get a value (explicit); special case

    Explicit type conversion between the JSON value and a compatible value
    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
    The value is converted by calling the @ref json_serializer<ValueType>
    `from_json()` method.

    The function is equivalent to executing
    @code {.cpp}
    return JSONSerializer<ValueType>::from_json(*this);
    @endcode

    This overloads is chosen if:
    - @a ValueType is not @ref basic_json and
    - @ref json_serializer<ValueType> has a `from_json()` method of the form
      `ValueType from_json(const basic_json&)`

    @note If @ref json_serializer<ValueType> has both overloads of
    `from_json()`, this one is chosen.

    @tparam ValueType the returned value type

    @return copy of the JSON value, converted to @a ValueType

    @throw what @ref json_serializer<ValueType> `from_json()` method throws

    @since version 2.1.0
    */
    template < typename ValueType,
               detail::enable_if_t <
                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
                   int > = 0 >
    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
    {
        return JSONSerializer<ValueType>::from_json(*this);
    }

    /*!
    @brief get special-case overload

    This overloads converts the current @ref basic_json in a different
    @ref basic_json type

    @tparam BasicJsonType == @ref basic_json

    @return a copy of *this, converted into @a BasicJsonType

    @complexity Depending on the implementation of the called `from_json()`
                method.

    @since version 3.2.0
    */
    template < typename BasicJsonType,
               detail::enable_if_t <
                   detail::is_basic_json<BasicJsonType>::value,
                   int > = 0 >
    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
    {
        return *this;
    }

    /*!
    @brief get special-case overload

    This overloads avoids a lot of template boilerplate, it can be seen as the
    identity method

    @tparam BasicJsonType == @ref basic_json

    @return a copy of *this

    @complexity Constant.

    @since version 2.1.0
    */
    template<typename BasicJsonType,
             detail::enable_if_t<
                 std::is_same<BasicJsonType, basic_json_t>::value,
                 int> = 0>
    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
    {
        return *this;
    }

    /*!
    @brief get a pointer value (explicit)
    @copydoc get()
    */
    template<typename PointerType,
             detail::enable_if_t<
                 std::is_pointer<PointerType>::value,
                 int> = 0>
    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
    {
        // delegate the call to get_ptr
        return get_ptr<PointerType>();
    }

  public:
    /*!
    @brief get a (pointer) value (explicit)

    Performs explicit type conversion between the JSON value and a compatible value if required.

    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
    No copies are made.

    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
    from the current @ref basic_json.

    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
    method.

    @tparam ValueTypeCV the provided value type
    @tparam ValueType the returned value type

    @return copy of the JSON value, converted to @tparam ValueType if necessary

    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required

    @since version 2.1.0
    */
    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
#if defined(JSON_HAS_CPP_14)
    constexpr
#endif
    auto get() const noexcept(
    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
    {
        // we cannot static_assert on ValueTypeCV being non-const, because
        // there is support for get<const basic_json_t>(), which is why we
        // still need the uncvref
        static_assert(!std::is_reference<ValueTypeCV>::value,
                      "get() cannot be used with reference types, you might want to use get_ref()");
        return get_impl<ValueType>(detail::priority_tag<4> {});
    }

    /*!
    @brief get a pointer value (explicit)

    Explicit pointer access to the internally stored JSON value. No copies are
    made.

    @warning The pointer becomes invalid if the underlying JSON object
    changes.

    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
    @ref number_unsigned_t, or @ref number_float_t.

    @return pointer to the internally stored JSON value if the requested
    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise

    @complexity Constant.

    @liveexample{The example below shows how pointers to internal values of a
    JSON value can be requested. Note that no type conversions are made and a
    `nullptr` is returned if the value and the requested pointer type does not
    match.,get__PointerType}

    @sa see @ref get_ptr() for explicit pointer-member access

    @since version 1.0.0
    */
    template<typename PointerType, typename std::enable_if<
                 std::is_pointer<PointerType>::value, int>::type = 0>
    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
    {
        // delegate the call to get_ptr
        return get_ptr<PointerType>();
    }

    /// @brief get a value (explicit)
    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
    template < typename ValueType,
               detail::enable_if_t <
                   !detail::is_basic_json<ValueType>::value&&
                   detail::has_from_json<basic_json_t, ValueType>::value,
                   int > = 0 >
    ValueType & get_to(ValueType& v) const noexcept(noexcept(
                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
    {
        JSONSerializer<ValueType>::from_json(*this, v);
        return v;
    }

    // specialization to allow calling get_to with a basic_json value
    // see https://github.com/nlohmann/json/issues/2175
    template<typename ValueType,
             detail::enable_if_t <
                 detail::is_basic_json<ValueType>::value,
                 int> = 0>
    ValueType & get_to(ValueType& v) const
    {
        v = *this;
        return v;
    }

    template <
        typename T, std::size_t N,
        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
        detail::enable_if_t <
            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
    noexcept(noexcept(JSONSerializer<Array>::from_json(
                          std::declval<const basic_json_t&>(), v)))
    {
        JSONSerializer<Array>::from_json(*this, v);
        return v;
    }

    /// @brief get a reference value (implicit)
    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
    template<typename ReferenceType, typename std::enable_if<
                 std::is_reference<ReferenceType>::value, int>::type = 0>
    ReferenceType get_ref()
    {
        // delegate call to get_ref_impl
        return get_ref_impl<ReferenceType>(*this);
    }

    /// @brief get a reference value (implicit)
    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
    template < typename ReferenceType, typename std::enable_if <
                   std::is_reference<ReferenceType>::value&&
                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
    ReferenceType get_ref() const
    {
        // delegate call to get_ref_impl
        return get_ref_impl<ReferenceType>(*this);
    }

    /*!
    @brief get a value (implicit)

    Implicit type conversion between the JSON value and a compatible value.
    The call is realized by calling @ref get() const.

    @tparam ValueType non-pointer type compatible to the JSON value, for
    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
    `std::vector` types for JSON arrays. The character type of @ref string_t
    as well as an initializer list of this type is excluded to avoid
    ambiguities as these types implicitly convert to `std::string`.

    @return copy of the JSON value, converted to type @a ValueType

    @throw type_error.302 in case passed type @a ValueType is incompatible
    to the JSON value type (e.g., the JSON value is of type boolean, but a
    string is requested); see example below

    @complexity Linear in the size of the JSON value.

    @liveexample{The example below shows several conversions from JSON values
    to other types. There a few things to note: (1) Floating-point numbers can
    be converted to integers\, (2) A JSON array can be converted to a standard
    `std::vector<short>`\, (3) A JSON object can be converted to C++
    associative containers such as `std::unordered_map<std::string\,
    json>`.,operator__ValueType}

    @since version 1.0.0
    */
    template < typename ValueType, typename std::enable_if <
                   detail::conjunction <
                       detail::negation<std::is_pointer<ValueType>>,
                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,
                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
                                        detail::negation<detail::is_basic_json<ValueType>>,
                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
                                                detail::negation<std::is_same<ValueType, std::string_view>>,
#endif
#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
                                                detail::negation<std::is_same<ValueType, std::any>>,
#endif
                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
                                                >::value, int >::type = 0 >
                                        JSON_EXPLICIT operator ValueType() const
    {
        // delegate the call to get<>() const
        return get<ValueType>();
    }

    /// @brief get a binary value
    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
    binary_t& get_binary()
    {
        if (!is_binary())
        {
            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
        }

        return *get_ptr<binary_t*>();
    }

    /// @brief get a binary value
    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
    const binary_t& get_binary() const
    {
        if (!is_binary())
        {
            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
        }

        return *get_ptr<const binary_t*>();
    }

    /// @}

    ////////////////////
    // element access //
    ////////////////////

    /// @name element access
    /// Access to the JSON value.
    /// @{

    /// @brief access specified array element with bounds checking
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    reference at(size_type idx)
    {
        // at only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            JSON_TRY
            {
                return set_parent(m_data.m_value.array->at(idx));
            }
            JSON_CATCH (std::out_of_range&)
            {
                // create better exception explanation
                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
            }
        }
        else
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }
    }

    /// @brief access specified array element with bounds checking
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    const_reference at(size_type idx) const
    {
        // at only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            JSON_TRY
            {
                return m_data.m_value.array->at(idx);
            }
            JSON_CATCH (std::out_of_range&)
            {
                // create better exception explanation
                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
            }
        }
        else
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }
    }

    /// @brief access specified object element with bounds checking
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    reference at(const typename object_t::key_type& key)
    {
        // at only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }

        auto it = m_data.m_value.object->find(key);
        if (it == m_data.m_value.object->end())
        {
            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
        }
        return set_parent(it->second);
    }

    /// @brief access specified object element with bounds checking
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    reference at(KeyType && key)
    {
        // at only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }

        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
        if (it == m_data.m_value.object->end())
        {
            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
        }
        return set_parent(it->second);
    }

    /// @brief access specified object element with bounds checking
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    const_reference at(const typename object_t::key_type& key) const
    {
        // at only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }

        auto it = m_data.m_value.object->find(key);
        if (it == m_data.m_value.object->end())
        {
            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
        }
        return it->second;
    }

    /// @brief access specified object element with bounds checking
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    const_reference at(KeyType && key) const
    {
        // at only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }

        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
        if (it == m_data.m_value.object->end())
        {
            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
        }
        return it->second;
    }

    /// @brief access specified array element
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    reference operator[](size_type idx)
    {
        // implicitly convert null value to an empty array
        if (is_null())
        {
            m_data.m_type = value_t::array;
            m_data.m_value.array = create<array_t>();
            assert_invariant();
        }

        // operator[] only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            // fill up array with null values if given idx is outside range
            if (idx >= m_data.m_value.array->size())
            {
#if JSON_DIAGNOSTICS
                // remember array size & capacity before resizing
                const auto old_size = m_data.m_value.array->size();
                const auto old_capacity = m_data.m_value.array->capacity();
#endif
                m_data.m_value.array->resize(idx + 1);

#if JSON_DIAGNOSTICS
                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
                {
                    // capacity has changed: update all parents
                    set_parents();
                }
                else
                {
                    // set parent for values added above
                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
                }
#endif
                assert_invariant();
            }

            return m_data.m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
    }

    /// @brief access specified array element
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    const_reference operator[](size_type idx) const
    {
        // const operator[] only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            return m_data.m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
    }

    /// @brief access specified object element
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    reference operator[](typename object_t::key_type key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
            return set_parent(result.first->second);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

    /// @brief access specified object element
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    const_reference operator[](const typename object_t::key_type& key) const
    {
        // const operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto it = m_data.m_value.object->find(key);
            JSON_ASSERT(it != m_data.m_value.object->end());
            return it->second;
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
    // (they seemingly cannot be constrained to resolve the ambiguity)
    template<typename T>
    reference operator[](T* key)
    {
        return operator[](typename object_t::key_type(key));
    }

    template<typename T>
    const_reference operator[](T* key) const
    {
        return operator[](typename object_t::key_type(key));
    }

    /// @brief access specified object element
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
    reference operator[](KeyType && key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
            return set_parent(result.first->second);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

    /// @brief access specified object element
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
    const_reference operator[](KeyType && key) const
    {
        // const operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
            JSON_ASSERT(it != m_data.m_value.object->end());
            return it->second;
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

  private:
    template<typename KeyType>
    using is_comparable_with_object_key = detail::is_comparable <
        object_comparator_t, const typename object_t::key_type&, KeyType >;

    template<typename ValueType>
    using value_return_type = std::conditional <
        detail::is_c_string_uncvref<ValueType>::value,
        string_t, typename std::decay<ValueType>::type >;

  public:
    /// @brief access specified object element with default value
    /// @sa https://json.nlohmann.me/api/basic_json/value/
    template < class ValueType, detail::enable_if_t <
                   !detail::is_transparent<object_comparator_t>::value
                   && detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
    {
        // value only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            // if key is found, return value and given default value otherwise
            const auto it = find(key);
            if (it != end())
            {
                return it->template get<ValueType>();
            }

            return default_value;
        }

        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
    }

    /// @brief access specified object element with default value
    /// @sa https://json.nlohmann.me/api/basic_json/value/
    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
               detail::enable_if_t <
                   !detail::is_transparent<object_comparator_t>::value
                   && detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
    {
        // value only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            // if key is found, return value and given default value otherwise
            const auto it = find(key);
            if (it != end())
            {
                return it->template get<ReturnType>();
            }

            return std::forward<ValueType>(default_value);
        }

        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
    }

    /// @brief access specified object element with default value
    /// @sa https://json.nlohmann.me/api/basic_json/value/
    template < class ValueType, class KeyType, detail::enable_if_t <
                   detail::is_transparent<object_comparator_t>::value
                   && !detail::is_json_pointer<KeyType>::value
                   && is_comparable_with_object_key<KeyType>::value
                   && detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    ValueType value(KeyType && key, const ValueType& default_value) const
    {
        // value only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            // if key is found, return value and given default value otherwise
            const auto it = find(std::forward<KeyType>(key));
            if (it != end())
            {
                return it->template get<ValueType>();
            }

            return default_value;
        }

        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
    }

    /// @brief access specified object element via JSON Pointer with default value
    /// @sa https://json.nlohmann.me/api/basic_json/value/
    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
               detail::enable_if_t <
                   detail::is_transparent<object_comparator_t>::value
                   && !detail::is_json_pointer<KeyType>::value
                   && is_comparable_with_object_key<KeyType>::value
                   && detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    ReturnType value(KeyType && key, ValueType && default_value) const
    {
        // value only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            // if key is found, return value and given default value otherwise
            const auto it = find(std::forward<KeyType>(key));
            if (it != end())
            {
                return it->template get<ReturnType>();
            }

            return std::forward<ValueType>(default_value);
        }

        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
    }

    /// @brief access specified object element via JSON Pointer with default value
    /// @sa https://json.nlohmann.me/api/basic_json/value/
    template < class ValueType, detail::enable_if_t <
                   detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
    {
        // value only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            // if pointer resolves a value, return it or use default value
            JSON_TRY
            {
                return ptr.get_checked(this).template get<ValueType>();
            }
            JSON_INTERNAL_CATCH (out_of_range&)
            {
                return default_value;
            }
        }

        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
    }

    /// @brief access specified object element via JSON Pointer with default value
    /// @sa https://json.nlohmann.me/api/basic_json/value/
    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
               detail::enable_if_t <
                   detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    ReturnType value(const json_pointer& ptr, ValueType && default_value) const
    {
        // value only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            // if pointer resolves a value, return it or use default value
            JSON_TRY
            {
                return ptr.get_checked(this).template get<ReturnType>();
            }
            JSON_INTERNAL_CATCH (out_of_range&)
            {
                return std::forward<ValueType>(default_value);
            }
        }

        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
    }

    template < class ValueType, class BasicJsonType, detail::enable_if_t <
                   detail::is_basic_json<BasicJsonType>::value
                   && detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
    {
        return value(ptr.convert(), default_value);
    }

    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
               detail::enable_if_t <
                   detail::is_basic_json<BasicJsonType>::value
                   && detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
    {
        return value(ptr.convert(), std::forward<ValueType>(default_value));
    }

    /// @brief access the first element
    /// @sa https://json.nlohmann.me/api/basic_json/front/
    reference front()
    {
        return *begin();
    }

    /// @brief access the first element
    /// @sa https://json.nlohmann.me/api/basic_json/front/
    const_reference front() const
    {
        return *cbegin();
    }

    /// @brief access the last element
    /// @sa https://json.nlohmann.me/api/basic_json/back/
    reference back()
    {
        auto tmp = end();
        --tmp;
        return *tmp;
    }

    /// @brief access the last element
    /// @sa https://json.nlohmann.me/api/basic_json/back/
    const_reference back() const
    {
        auto tmp = cend();
        --tmp;
        return *tmp;
    }

    /// @brief remove element given an iterator
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
    template < class IteratorType, detail::enable_if_t <
                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
    IteratorType erase(IteratorType pos)
    {
        // make sure iterator fits the current value
        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
        {
            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
        }

        IteratorType result = end();

        switch (m_data.m_type)
        {
            case value_t::boolean:
            case value_t::number_float:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::string:
            case value_t::binary:
            {
                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
                {
                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
                }

                if (is_string())
                {
                    AllocatorType<string_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
                    m_data.m_value.string = nullptr;
                }
                else if (is_binary())
                {
                    AllocatorType<binary_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
                    m_data.m_value.binary = nullptr;
                }

                m_data.m_type = value_t::null;
                assert_invariant();
                break;
            }

            case value_t::object:
            {
                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
                break;
            }

            case value_t::array:
            {
                result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
                break;
            }

            case value_t::null:
            case value_t::discarded:
            default:
                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        return result;
    }

    /// @brief remove elements given an iterator range
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
    template < class IteratorType, detail::enable_if_t <
                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
    IteratorType erase(IteratorType first, IteratorType last)
    {
        // make sure iterator fits the current value
        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
        {
            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
        }

        IteratorType result = end();

        switch (m_data.m_type)
        {
            case value_t::boolean:
            case value_t::number_float:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::string:
            case value_t::binary:
            {
                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
                                       || !last.m_it.primitive_iterator.is_end()))
                {
                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
                }

                if (is_string())
                {
                    AllocatorType<string_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
                    m_data.m_value.string = nullptr;
                }
                else if (is_binary())
                {
                    AllocatorType<binary_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
                    m_data.m_value.binary = nullptr;
                }

                m_data.m_type = value_t::null;
                assert_invariant();
                break;
            }

            case value_t::object:
            {
                result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
                                              last.m_it.object_iterator);
                break;
            }

            case value_t::array:
            {
                result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
                                             last.m_it.array_iterator);
                break;
            }

            case value_t::null:
            case value_t::discarded:
            default:
                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        return result;
    }

  private:
    template < typename KeyType, detail::enable_if_t <
                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
    size_type erase_internal(KeyType && key)
    {
        // this erase only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        return m_data.m_value.object->erase(std::forward<KeyType>(key));
    }

    template < typename KeyType, detail::enable_if_t <
                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
    size_type erase_internal(KeyType && key)
    {
        // this erase only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
        if (it != m_data.m_value.object->end())
        {
            m_data.m_value.object->erase(it);
            return 1;
        }
        return 0;
    }

  public:

    /// @brief remove element from a JSON object given a key
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
    size_type erase(const typename object_t::key_type& key)
    {
        // the indirection via erase_internal() is added to avoid making this
        // function a template and thus de-rank it during overload resolution
        return erase_internal(key);
    }

    /// @brief remove element from a JSON object given a key
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    size_type erase(KeyType && key)
    {
        return erase_internal(std::forward<KeyType>(key));
    }

    /// @brief remove element from a JSON array given an index
    /// @sa https://json.nlohmann.me/api/basic_json/erase/
    void erase(const size_type idx)
    {
        // this erase only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
            {
                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
            }

            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
        }
        else
        {
            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }
    }

    /// @}

    ////////////
    // lookup //
    ////////////

    /// @name lookup
    /// @{

    /// @brief find an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/find/
    iterator find(const typename object_t::key_type& key)
    {
        auto result = end();

        if (is_object())
        {
            result.m_it.object_iterator = m_data.m_value.object->find(key);
        }

        return result;
    }

    /// @brief find an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/find/
    const_iterator find(const typename object_t::key_type& key) const
    {
        auto result = cend();

        if (is_object())
        {
            result.m_it.object_iterator = m_data.m_value.object->find(key);
        }

        return result;
    }

    /// @brief find an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/find/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    iterator find(KeyType && key)
    {
        auto result = end();

        if (is_object())
        {
            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
        }

        return result;
    }

    /// @brief find an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/find/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    const_iterator find(KeyType && key) const
    {
        auto result = cend();

        if (is_object())
        {
            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
        }

        return result;
    }

    /// @brief returns the number of occurrences of a key in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/count/
    size_type count(const typename object_t::key_type& key) const
    {
        // return 0 for all nonobject types
        return is_object() ? m_data.m_value.object->count(key) : 0;
    }

    /// @brief returns the number of occurrences of a key in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/count/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    size_type count(KeyType && key) const
    {
        // return 0 for all nonobject types
        return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
    }

    /// @brief check the existence of an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
    bool contains(const typename object_t::key_type& key) const
    {
        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
    }

    /// @brief check the existence of an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    bool contains(KeyType && key) const
    {
        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
    }

    /// @brief check the existence of an element in a JSON object given a JSON pointer
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
    bool contains(const json_pointer& ptr) const
    {
        return ptr.contains(this);
    }

    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
    {
        return ptr.contains(this);
    }

    /// @}

    ///////////////
    // iterators //
    ///////////////

    /// @name iterators
    /// @{

    /// @brief returns an iterator to the first element
    /// @sa https://json.nlohmann.me/api/basic_json/begin/
    iterator begin() noexcept
    {
        iterator result(this);
        result.set_begin();
        return result;
    }

    /// @brief returns an iterator to the first element
    /// @sa https://json.nlohmann.me/api/basic_json/begin/
    const_iterator begin() const noexcept
    {
        return cbegin();
    }

    /// @brief returns a const iterator to the first element
    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
    const_iterator cbegin() const noexcept
    {
        const_iterator result(this);
        result.set_begin();
        return result;
    }

    /// @brief returns an iterator to one past the last element
    /// @sa https://json.nlohmann.me/api/basic_json/end/
    iterator end() noexcept
    {
        iterator result(this);
        result.set_end();
        return result;
    }

    /// @brief returns an iterator to one past the last element
    /// @sa https://json.nlohmann.me/api/basic_json/end/
    const_iterator end() const noexcept
    {
        return cend();
    }

    /// @brief returns an iterator to one past the last element
    /// @sa https://json.nlohmann.me/api/basic_json/cend/
    const_iterator cend() const noexcept
    {
        const_iterator result(this);
        result.set_end();
        return result;
    }

    /// @brief returns an iterator to the reverse-beginning
    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
    reverse_iterator rbegin() noexcept
    {
        return reverse_iterator(end());
    }

    /// @brief returns an iterator to the reverse-beginning
    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
    const_reverse_iterator rbegin() const noexcept
    {
        return crbegin();
    }

    /// @brief returns an iterator to the reverse-end
    /// @sa https://json.nlohmann.me/api/basic_json/rend/
    reverse_iterator rend() noexcept
    {
        return reverse_iterator(begin());
    }

    /// @brief returns an iterator to the reverse-end
    /// @sa https://json.nlohmann.me/api/basic_json/rend/
    const_reverse_iterator rend() const noexcept
    {
        return crend();
    }

    /// @brief returns a const reverse iterator to the last element
    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
    const_reverse_iterator crbegin() const noexcept
    {
        return const_reverse_iterator(cend());
    }

    /// @brief returns a const reverse iterator to one before the first
    /// @sa https://json.nlohmann.me/api/basic_json/crend/
    const_reverse_iterator crend() const noexcept
    {
        return const_reverse_iterator(cbegin());
    }

  public:
    /// @brief wrapper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
    ///             version 4.0.0 of the library. Please use @ref items() instead;
    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
    {
        return ref.items();
    }

    /// @brief wrapper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
    ///         version 4.0.0 of the library. Please use @ref items() instead;
    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
    {
        return ref.items();
    }

    /// @brief helper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
    iteration_proxy<iterator> items() noexcept
    {
        return iteration_proxy<iterator>(*this);
    }

    /// @brief helper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
    iteration_proxy<const_iterator> items() const noexcept
    {
        return iteration_proxy<const_iterator>(*this);
    }

    /// @}

    //////////////
    // capacity //
    //////////////

    /// @name capacity
    /// @{

    /// @brief checks whether the container is empty.
    /// @sa https://json.nlohmann.me/api/basic_json/empty/
    bool empty() const noexcept
    {
        switch (m_data.m_type)
        {
            case value_t::null:
            {
                // null values are empty
                return true;
            }

            case value_t::array:
            {
                // delegate call to array_t::empty()
                return m_data.m_value.array->empty();
            }

            case value_t::object:
            {
                // delegate call to object_t::empty()
                return m_data.m_value.object->empty();
            }

            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                // all other types are nonempty
                return false;
            }
        }
    }

    /// @brief returns the number of elements
    /// @sa https://json.nlohmann.me/api/basic_json/size/
    size_type size() const noexcept
    {
        switch (m_data.m_type)
        {
            case value_t::null:
            {
                // null values are empty
                return 0;
            }

            case value_t::array:
            {
                // delegate call to array_t::size()
                return m_data.m_value.array->size();
            }

            case value_t::object:
            {
                // delegate call to object_t::size()
                return m_data.m_value.object->size();
            }

            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                // all other types have size 1
                return 1;
            }
        }
    }

    /// @brief returns the maximum possible number of elements
    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
    size_type max_size() const noexcept
    {
        switch (m_data.m_type)
        {
            case value_t::array:
            {
                // delegate call to array_t::max_size()
                return m_data.m_value.array->max_size();
            }

            case value_t::object:
            {
                // delegate call to object_t::max_size()
                return m_data.m_value.object->max_size();
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                // all other types have max_size() == size()
                return size();
            }
        }
    }

    /// @}

    ///////////////
    // modifiers //
    ///////////////

    /// @name modifiers
    /// @{

    /// @brief clears the contents
    /// @sa https://json.nlohmann.me/api/basic_json/clear/
    void clear() noexcept
    {
        switch (m_data.m_type)
        {
            case value_t::number_integer:
            {
                m_data.m_value.number_integer = 0;
                break;
            }

            case value_t::number_unsigned:
            {
                m_data.m_value.number_unsigned = 0;
                break;
            }

            case value_t::number_float:
            {
                m_data.m_value.number_float = 0.0;
                break;
            }

            case value_t::boolean:
            {
                m_data.m_value.boolean = false;
                break;
            }

            case value_t::string:
            {
                m_data.m_value.string->clear();
                break;
            }

            case value_t::binary:
            {
                m_data.m_value.binary->clear();
                break;
            }

            case value_t::array:
            {
                m_data.m_value.array->clear();
                break;
            }

            case value_t::object:
            {
                m_data.m_value.object->clear();
                break;
            }

            case value_t::null:
            case value_t::discarded:
            default:
                break;
        }
    }

    /// @brief add an object to an array
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
    void push_back(basic_json&& val)
    {
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
        }

        // transform null object into an array
        if (is_null())
        {
            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
            assert_invariant();
        }

        // add element to array (move semantics)
        const auto old_capacity = m_data.m_value.array->capacity();
        m_data.m_value.array->push_back(std::move(val));
        set_parent(m_data.m_value.array->back(), old_capacity);
        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
    }

    /// @brief add an object to an array
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
    reference operator+=(basic_json&& val)
    {
        push_back(std::move(val));
        return *this;
    }

    /// @brief add an object to an array
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
    void push_back(const basic_json& val)
    {
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
        }

        // transform null object into an array
        if (is_null())
        {
            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
            assert_invariant();
        }

        // add element to array
        const auto old_capacity = m_data.m_value.array->capacity();
        m_data.m_value.array->push_back(val);
        set_parent(m_data.m_value.array->back(), old_capacity);
    }

    /// @brief add an object to an array
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
    reference operator+=(const basic_json& val)
    {
        push_back(val);
        return *this;
    }

    /// @brief add an object to an object
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
    void push_back(const typename object_t::value_type& val)
    {
        // push_back only works for null objects or objects
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
        {
            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
        }

        // transform null object into an object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
            assert_invariant();
        }

        // add element to object
        auto res = m_data.m_value.object->insert(val);
        set_parent(res.first->second);
    }

    /// @brief add an object to an object
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
    reference operator+=(const typename object_t::value_type& val)
    {
        push_back(val);
        return *this;
    }

    /// @brief add an object to an object
    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
    void push_back(initializer_list_t init)
    {
        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
        {
            basic_json&& key = init.begin()->moved_or_copied();
            push_back(typename object_t::value_type(
                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
        }
        else
        {
            push_back(basic_json(init));
        }
    }

    /// @brief add an object to an object
    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
    reference operator+=(initializer_list_t init)
    {
        push_back(init);
        return *this;
    }

    /// @brief add an object to an array
    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
    template<class... Args>
    reference emplace_back(Args&& ... args)
    {
        // emplace_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
        }

        // transform null object into an array
        if (is_null())
        {
            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
            assert_invariant();
        }

        // add element to array (perfect forwarding)
        const auto old_capacity = m_data.m_value.array->capacity();
        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
        return set_parent(m_data.m_value.array->back(), old_capacity);
    }

    /// @brief add an object to an object if key does not exist
    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
    template<class... Args>
    std::pair<iterator, bool> emplace(Args&& ... args)
    {
        // emplace only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
        {
            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
        }

        // transform null object into an object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
            assert_invariant();
        }

        // add element to array (perfect forwarding)
        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
        set_parent(res.first->second);

        // create result iterator and set iterator to the result of emplace
        auto it = begin();
        it.m_it.object_iterator = res.first;

        // return pair of iterator and boolean
        return {it, res.second};
    }

    /// Helper for insertion of an iterator
    /// @note: This uses std::distance to support GCC 4.8,
    ///        see https://github.com/nlohmann/json/pull/1257
    template<typename... Args>
    iterator insert_iterator(const_iterator pos, Args&& ... args)
    {
        iterator result(this);
        JSON_ASSERT(m_data.m_value.array != nullptr);

        auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
        m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
        result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;

        // This could have been written as:
        // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.

        set_parents();
        return result;
    }

    /// @brief inserts element into array
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
    iterator insert(const_iterator pos, const basic_json& val)
    {
        // insert only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            // check if iterator pos fits to this JSON value
            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
            {
                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
            }

            // insert to array and return iterator
            return insert_iterator(pos, val);
        }

        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
    }

    /// @brief inserts element into array
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
    iterator insert(const_iterator pos, basic_json&& val)
    {
        return insert(pos, val);
    }

    /// @brief inserts copies of element into array
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
    {
        // insert only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            // check if iterator pos fits to this JSON value
            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
            {
                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
            }

            // insert to array and return iterator
            return insert_iterator(pos, cnt, val);
        }

        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
    }

    /// @brief inserts range of elements into array
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
    {
        // insert only works for arrays
        if (JSON_HEDLEY_UNLIKELY(!is_array()))
        {
            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
        }

        // check if iterator pos fits to this JSON value
        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
        {
            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
        }

        // check if range iterators belong to the same JSON object
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
        }

        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
        {
            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
        }

        // insert to array and return iterator
        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
    }

    /// @brief inserts elements from initializer list into array
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
    iterator insert(const_iterator pos, initializer_list_t ilist)
    {
        // insert only works for arrays
        if (JSON_HEDLEY_UNLIKELY(!is_array()))
        {
            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
        }

        // check if iterator pos fits to this JSON value
        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
        {
            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
        }

        // insert to array and return iterator
        return insert_iterator(pos, ilist.begin(), ilist.end());
    }

    /// @brief inserts range of elements into object
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
    void insert(const_iterator first, const_iterator last)
    {
        // insert only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
        }

        // check if range iterators belong to the same JSON object
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
        }

        // passed iterators must belong to objects
        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
        {
            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
        }

        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
    }

    /// @brief updates a JSON object from another object, overwriting existing keys
    /// @sa https://json.nlohmann.me/api/basic_json/update/
    void update(const_reference j, bool merge_objects = false)
    {
        update(j.begin(), j.end(), merge_objects);
    }

    /// @brief updates a JSON object from another object, overwriting existing keys
    /// @sa https://json.nlohmann.me/api/basic_json/update/
    void update(const_iterator first, const_iterator last, bool merge_objects = false)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
        }

        // check if range iterators belong to the same JSON object
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
        }

        // passed iterators must belong to objects
        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
        {
            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
        }

        for (auto it = first; it != last; ++it)
        {
            if (merge_objects && it.value().is_object())
            {
                auto it2 = m_data.m_value.object->find(it.key());
                if (it2 != m_data.m_value.object->end())
                {
                    it2->second.update(it.value(), true);
                    continue;
                }
            }
            m_data.m_value.object->operator[](it.key()) = it.value();
#if JSON_DIAGNOSTICS
            m_data.m_value.object->operator[](it.key()).m_parent = this;
#endif
        }
    }

    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    void swap(reference other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value&&
        std::is_nothrow_move_assignable<value_t>::value&&
        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
        std::is_nothrow_move_assignable<json_value>::value
    )
    {
        std::swap(m_data.m_type, other.m_data.m_type);
        std::swap(m_data.m_value, other.m_data.m_value);

        set_parents();
        other.set_parents();
        assert_invariant();
    }

    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    friend void swap(reference left, reference right) noexcept (
        std::is_nothrow_move_constructible<value_t>::value&&
        std::is_nothrow_move_assignable<value_t>::value&&
        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
        std::is_nothrow_move_assignable<json_value>::value
    )
    {
        left.swap(right);
    }

    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
    {
        // swap only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            using std::swap;
            swap(*(m_data.m_value.array), other);
        }
        else
        {
            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
        }
    }

    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
    {
        // swap only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            using std::swap;
            swap(*(m_data.m_value.object), other);
        }
        else
        {
            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
        }
    }

    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
    {
        // swap only works for strings
        if (JSON_HEDLEY_LIKELY(is_string()))
        {
            using std::swap;
            swap(*(m_data.m_value.string), other);
        }
        else
        {
            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
        }
    }

    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
    {
        // swap only works for strings
        if (JSON_HEDLEY_LIKELY(is_binary()))
        {
            using std::swap;
            swap(*(m_data.m_value.binary), other);
        }
        else
        {
            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
        }
    }

    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
    {
        // swap only works for strings
        if (JSON_HEDLEY_LIKELY(is_binary()))
        {
            using std::swap;
            swap(*(m_data.m_value.binary), other);
        }
        else
        {
            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
        }
    }

    /// @}

    //////////////////////////////////////////
    // lexicographical comparison operators //
    //////////////////////////////////////////

    /// @name lexicographical comparison operators
    /// @{

    // note parentheses around operands are necessary; see
    // https://github.com/nlohmann/json/issues/1530
#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
    const auto lhs_type = lhs.type();                                                                    \
    const auto rhs_type = rhs.type();                                                                    \
    \
    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \
    {                                                                                                    \
        switch (lhs_type)                                                                                \
        {                                                                                                \
            case value_t::array:                                                                         \
                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
                \
            case value_t::object:                                                                        \
                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
                \
            case value_t::null:                                                                          \
                return (null_result);                                                                    \
                \
            case value_t::string:                                                                        \
                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
                \
            case value_t::boolean:                                                                       \
                return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean);                                   \
                \
            case value_t::number_integer:                                                                \
                return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer);                     \
                \
            case value_t::number_unsigned:                                                               \
                return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned);                   \
                \
            case value_t::number_float:                                                                  \
                return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float);                         \
                \
            case value_t::binary:                                                                        \
                return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary);                                   \
                \
            case value_t::discarded:                                                                     \
            default:                                                                                     \
                return (unordered_result);                                                               \
        }                                                                                                \
    }                                                                                                    \
    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
    {                                                                                                    \
        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
    }                                                                                                    \
    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
    {                                                                                                    \
        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
    }                                                                                                    \
    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
    {                                                                                                    \
        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
    }                                                                                                    \
    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
    {                                                                                                    \
        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
    }                                                                                                    \
    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
    {                                                                                                    \
        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
    }                                                                                                    \
    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
    {                                                                                                    \
        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
    }                                                                                                    \
    else if(compares_unordered(lhs, rhs))\
    {\
        return (unordered_result);\
    }\
    \
    return (default_result);

  JSON_PRIVATE_UNLESS_TESTED:
    // returns true if:
    // - any operand is NaN and the other operand is of number type
    // - any operand is discarded
    // in legacy mode, discarded values are considered ordered if
    // an operation is computed as an odd number of inverses of others
    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
    {
        if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
                || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
        {
            return true;
        }
#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
#else
        static_cast<void>(inverse);
        return lhs.is_discarded() || rhs.is_discarded();
#endif
    }

  private:
    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
    {
        return compares_unordered(*this, rhs, inverse);
    }

  public:
#if JSON_HAS_THREE_WAY_COMPARISON
    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    bool operator==(const_reference rhs) const noexcept
    {
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        const_reference lhs = *this;
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
    }

    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
    bool operator==(ScalarType rhs) const noexcept
    {
        return *this == basic_json(rhs);
    }

    /// @brief comparison: not equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    bool operator!=(const_reference rhs) const noexcept
    {
        if (compares_unordered(rhs, true))
        {
            return false;
        }
        return !operator==(rhs);
    }

    /// @brief comparison: 3-way
    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
    {
        const_reference lhs = *this;
        // default_result is used if we cannot compare values. In that case,
        // we compare types.
        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
                                std::partial_ordering::equivalent,
                                std::partial_ordering::unordered,
                                lhs_type <=> rhs_type) // *NOPAD*
    }

    /// @brief comparison: 3-way
    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
    {
        return *this <=> basic_json(rhs); // *NOPAD*
    }

#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
    // all operators that are computed as an odd number of inverses of others
    // need to be overloaded to emulate the legacy comparison behavior

    /// @brief comparison: less than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
    bool operator<=(const_reference rhs) const noexcept
    {
        if (compares_unordered(rhs, true))
        {
            return false;
        }
        return !(rhs < *this);
    }

    /// @brief comparison: less than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
    bool operator<=(ScalarType rhs) const noexcept
    {
        return *this <= basic_json(rhs);
    }

    /// @brief comparison: greater than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
    bool operator>=(const_reference rhs) const noexcept
    {
        if (compares_unordered(rhs, true))
        {
            return false;
        }
        return !(*this < rhs);
    }

    /// @brief comparison: greater than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
    bool operator>=(ScalarType rhs) const noexcept
    {
        return *this >= basic_json(rhs);
    }
#endif
#else
    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
    {
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
    }

    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
    {
        return lhs == basic_json(rhs);
    }

    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
    {
        return basic_json(lhs) == rhs;
    }

    /// @brief comparison: not equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
    {
        if (compares_unordered(lhs, rhs, true))
        {
            return false;
        }
        return !(lhs == rhs);
    }

    /// @brief comparison: not equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
    {
        return lhs != basic_json(rhs);
    }

    /// @brief comparison: not equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
    {
        return basic_json(lhs) != rhs;
    }

    /// @brief comparison: less than
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
    {
        // default_result is used if we cannot compare values. In that case,
        // we compare types. Note we have to call the operator explicitly,
        // because MSVC has problems otherwise.
        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
    }

    /// @brief comparison: less than
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
    {
        return lhs < basic_json(rhs);
    }

    /// @brief comparison: less than
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
    {
        return basic_json(lhs) < rhs;
    }

    /// @brief comparison: less than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
    {
        if (compares_unordered(lhs, rhs, true))
        {
            return false;
        }
        return !(rhs < lhs);
    }

    /// @brief comparison: less than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
    {
        return lhs <= basic_json(rhs);
    }

    /// @brief comparison: less than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
    {
        return basic_json(lhs) <= rhs;
    }

    /// @brief comparison: greater than
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
    {
        // double inverse
        if (compares_unordered(lhs, rhs))
        {
            return false;
        }
        return !(lhs <= rhs);
    }

    /// @brief comparison: greater than
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
    {
        return lhs > basic_json(rhs);
    }

    /// @brief comparison: greater than
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
    {
        return basic_json(lhs) > rhs;
    }

    /// @brief comparison: greater than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
    {
        if (compares_unordered(lhs, rhs, true))
        {
            return false;
        }
        return !(lhs < rhs);
    }

    /// @brief comparison: greater than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
    {
        return lhs >= basic_json(rhs);
    }

    /// @brief comparison: greater than or equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
    {
        return basic_json(lhs) >= rhs;
    }
#endif

#undef JSON_IMPLEMENT_OPERATOR

    /// @}

    ///////////////////
    // serialization //
    ///////////////////

    /// @name serialization
    /// @{
#ifndef JSON_NO_IO
    /// @brief serialize to stream
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
    {
        // read width member and use it as indentation parameter if nonzero
        const bool pretty_print = o.width() > 0;
        const auto indentation = pretty_print ? o.width() : 0;

        // reset width to 0 for subsequent calls to this stream
        o.width(0);

        // do the actual serialization
        serializer s(detail::output_adapter<char>(o), o.fill());
        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
        return o;
    }

    /// @brief serialize to stream
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
    ///             version 4.0.0 of the library. Please use
    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
    ///             replace calls like `j >> o;` with `o << j;`.
    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
    {
        return o << j;
    }
#endif  // JSON_NO_IO
    /// @}

    /////////////////////
    // deserialization //
    /////////////////////

    /// @name deserialization
    /// @{

    /// @brief deserialize from a compatible input
    /// @sa https://json.nlohmann.me/api/basic_json/parse/
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json parse(InputType&& i,
                            const parser_callback_t cb = nullptr,
                            const bool allow_exceptions = true,
                            const bool ignore_comments = false)
    {
        basic_json result;
        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
        return result;
    }

    /// @brief deserialize from a pair of character iterators
    /// @sa https://json.nlohmann.me/api/basic_json/parse/
    template<typename IteratorType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json parse(IteratorType first,
                            IteratorType last,
                            const parser_callback_t cb = nullptr,
                            const bool allow_exceptions = true,
                            const bool ignore_comments = false)
    {
        basic_json result;
        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
        return result;
    }

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
    static basic_json parse(detail::span_input_adapter&& i,
                            const parser_callback_t cb = nullptr,
                            const bool allow_exceptions = true,
                            const bool ignore_comments = false)
    {
        basic_json result;
        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
        return result;
    }

    /// @brief check if the input is valid JSON
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
    template<typename InputType>
    static bool accept(InputType&& i,
                       const bool ignore_comments = false)
    {
        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
    }

    /// @brief check if the input is valid JSON
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
    template<typename IteratorType>
    static bool accept(IteratorType first, IteratorType last,
                       const bool ignore_comments = false)
    {
        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
    }

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
    static bool accept(detail::span_input_adapter&& i,
                       const bool ignore_comments = false)
    {
        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
    }

    /// @brief generate SAX events
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
    template <typename InputType, typename SAX>
    JSON_HEDLEY_NON_NULL(2)
    static bool sax_parse(InputType&& i, SAX* sax,
                          input_format_t format = input_format_t::json,
                          const bool strict = true,
                          const bool ignore_comments = false)
    {
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        return format == input_format_t::json
               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
    }

    /// @brief generate SAX events
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
    template<class IteratorType, class SAX>
    JSON_HEDLEY_NON_NULL(3)
    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
                          input_format_t format = input_format_t::json,
                          const bool strict = true,
                          const bool ignore_comments = false)
    {
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        return format == input_format_t::json
               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
    }

    /// @brief generate SAX events
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
    ///             version 4.0.0 of the library. Please use
    ///             sax_parse(ptr, ptr + len) instead.
    template <typename SAX>
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
    JSON_HEDLEY_NON_NULL(2)
    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
                          input_format_t format = input_format_t::json,
                          const bool strict = true,
                          const bool ignore_comments = false)
    {
        auto ia = i.get();
        return format == input_format_t::json
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
    }
#ifndef JSON_NO_IO
    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
    ///             version 4.0.0 of the library. Please use
    ///             operator>>(std::istream&, basic_json&) instead; that is,
    ///             replace calls like `j << i;` with `i >> j;`.
    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
    friend std::istream& operator<<(basic_json& j, std::istream& i)
    {
        return operator>>(i, j);
    }

    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
    friend std::istream& operator>>(std::istream& i, basic_json& j)
    {
        parser(detail::input_adapter(i)).parse(false, j);
        return i;
    }
#endif  // JSON_NO_IO
    /// @}

    ///////////////////////////
    // convenience functions //
    ///////////////////////////

    /// @brief return the type as string
    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
    JSON_HEDLEY_RETURNS_NON_NULL
    const char* type_name() const noexcept
    {
        switch (m_data.m_type)
        {
            case value_t::null:
                return "null";
            case value_t::object:
                return "object";
            case value_t::array:
                return "array";
            case value_t::string:
                return "string";
            case value_t::boolean:
                return "boolean";
            case value_t::binary:
                return "binary";
            case value_t::discarded:
                return "discarded";
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            default:
                return "number";
        }
    }

  JSON_PRIVATE_UNLESS_TESTED:
    //////////////////////
    // member variables //
    //////////////////////

    struct data
    {
        /// the type of the current element
        value_t m_type = value_t::null;

        /// the value of the current element
        json_value m_value = {};

        data(const value_t v)
            : m_type(v), m_value(v)
        {
        }

        data(size_type cnt, const basic_json& val)
            : m_type(value_t::array)
        {
            m_value.array = create<array_t>(cnt, val);
        }

        data() noexcept = default;
        data(data&&) noexcept = default;
        data(const data&) noexcept = delete;
        data& operator=(data&&) noexcept = delete;
        data& operator=(const data&) noexcept = delete;

        ~data() noexcept
        {
            m_value.destroy(m_type);
        }
    };

    data m_data = {};

#if JSON_DIAGNOSTICS
    /// a pointer to a parent value (for debugging purposes)
    basic_json* m_parent = nullptr;
#endif

    //////////////////////////////////////////
    // binary serialization/deserialization //
    //////////////////////////////////////////

    /// @name binary serialization/deserialization support
    /// @{

  public:
    /// @brief create a CBOR serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
        to_cbor(j, result);
        return result;
    }

    /// @brief create a CBOR serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
    {
        binary_writer<std::uint8_t>(o).write_cbor(j);
    }

    /// @brief create a CBOR serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
    {
        binary_writer<char>(o).write_cbor(j);
    }

    /// @brief create a MessagePack serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
        to_msgpack(j, result);
        return result;
    }

    /// @brief create a MessagePack serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
    {
        binary_writer<std::uint8_t>(o).write_msgpack(j);
    }

    /// @brief create a MessagePack serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
    {
        binary_writer<char>(o).write_msgpack(j);
    }

    /// @brief create a UBJSON serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
            const bool use_size = false,
            const bool use_type = false)
    {
        std::vector<std::uint8_t> result;
        to_ubjson(j, result, use_size, use_type);
        return result;
    }

    /// @brief create a UBJSON serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
                          const bool use_size = false, const bool use_type = false)
    {
        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
    }

    /// @brief create a UBJSON serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
                          const bool use_size = false, const bool use_type = false)
    {
        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
    }

    /// @brief create a BJData serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
            const bool use_size = false,
            const bool use_type = false)
    {
        std::vector<std::uint8_t> result;
        to_bjdata(j, result, use_size, use_type);
        return result;
    }

    /// @brief create a BJData serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
                          const bool use_size = false, const bool use_type = false)
    {
        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
    }

    /// @brief create a BJData serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
                          const bool use_size = false, const bool use_type = false)
    {
        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
    }

    /// @brief create a BSON serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
    static std::vector<std::uint8_t> to_bson(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
        to_bson(j, result);
        return result;
    }

    /// @brief create a BSON serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
    {
        binary_writer<std::uint8_t>(o).write_bson(j);
    }

    /// @brief create a BSON serialization of a given JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
    {
        binary_writer<char>(o).write_bson(j);
    }

    /// @brief create a JSON value from an input in CBOR format
    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_cbor(InputType&& i,
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in CBOR format
    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
    template<typename IteratorType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_cbor(IteratorType first, IteratorType last,
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
    static basic_json from_cbor(const T* ptr, std::size_t len,
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
    }

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
    static basic_json from_cbor(detail::span_input_adapter&& i,
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = i.get();
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format
    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_msgpack(InputType&& i,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format
    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
    template<typename IteratorType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_msgpack(IteratorType first, IteratorType last,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
    static basic_json from_msgpack(const T* ptr, std::size_t len,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
    {
        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
    }

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
    static basic_json from_msgpack(detail::span_input_adapter&& i,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = i.get();
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_ubjson(InputType&& i,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
    template<typename IteratorType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_ubjson(IteratorType first, IteratorType last,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
    static basic_json from_ubjson(const T* ptr, std::size_t len,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
    {
        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
    }

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
    static basic_json from_ubjson(detail::span_input_adapter&& i,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = i.get();
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_bjdata(InputType&& i,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
    template<typename IteratorType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_bjdata(IteratorType first, IteratorType last,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_bson(InputType&& i,
                                const bool strict = true,
                                const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
    template<typename IteratorType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json from_bson(IteratorType first, IteratorType last,
                                const bool strict = true,
                                const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
    static basic_json from_bson(const T* ptr, std::size_t len,
                                const bool strict = true,
                                const bool allow_exceptions = true)
    {
        return from_bson(ptr, ptr + len, strict, allow_exceptions);
    }

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
    static basic_json from_bson(detail::span_input_adapter&& i,
                                const bool strict = true,
                                const bool allow_exceptions = true)
    {
        basic_json result;
        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
        auto ia = i.get();
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
        return res ? result : basic_json(value_t::discarded);
    }
    /// @}

    //////////////////////////
    // JSON Pointer support //
    //////////////////////////

    /// @name JSON Pointer functions
    /// @{

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    reference operator[](const json_pointer& ptr)
    {
        return ptr.get_unchecked(this);
    }

    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
    {
        return ptr.get_unchecked(this);
    }

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
    const_reference operator[](const json_pointer& ptr) const
    {
        return ptr.get_unchecked(this);
    }

    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
    {
        return ptr.get_unchecked(this);
    }

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    reference at(const json_pointer& ptr)
    {
        return ptr.get_checked(this);
    }

    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
    {
        return ptr.get_checked(this);
    }

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
    const_reference at(const json_pointer& ptr) const
    {
        return ptr.get_checked(this);
    }

    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
    {
        return ptr.get_checked(this);
    }

    /// @brief return flattened JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
    basic_json flatten() const
    {
        basic_json result(value_t::object);
        json_pointer::flatten("", *this, result);
        return result;
    }

    /// @brief unflatten a previously flattened JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
    basic_json unflatten() const
    {
        return json_pointer::unflatten(*this);
    }

    /// @}

    //////////////////////////
    // JSON Patch functions //
    //////////////////////////

    /// @name JSON Patch functions
    /// @{

    /// @brief applies a JSON patch in-place without copying the object
    /// @sa https://json.nlohmann.me/api/basic_json/patch/
    void patch_inplace(const basic_json& json_patch)
    {
        basic_json& result = *this;
        // the valid JSON Patch operations
        enum class patch_operations {add, remove, replace, move, copy, test, invalid};

        const auto get_op = [](const std::string & op)
        {
            if (op == "add")
            {
                return patch_operations::add;
            }
            if (op == "remove")
            {
                return patch_operations::remove;
            }
            if (op == "replace")
            {
                return patch_operations::replace;
            }
            if (op == "move")
            {
                return patch_operations::move;
            }
            if (op == "copy")
            {
                return patch_operations::copy;
            }
            if (op == "test")
            {
                return patch_operations::test;
            }

            return patch_operations::invalid;
        };

        // wrapper for "add" operation; add value at ptr
        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
        {
            // adding to the root of the target document means replacing it
            if (ptr.empty())
            {
                result = val;
                return;
            }

            // make sure the top element of the pointer exists
            json_pointer const top_pointer = ptr.top();
            if (top_pointer != ptr)
            {
                result.at(top_pointer);
            }

            // get reference to parent of JSON pointer ptr
            const auto last_path = ptr.back();
            ptr.pop_back();
            // parent must exist when performing patch add per RFC6902 specs
            basic_json& parent = result.at(ptr);

            switch (parent.m_data.m_type)
            {
                case value_t::null:
                case value_t::object:
                {
                    // use operator[] to add value
                    parent[last_path] = val;
                    break;
                }

                case value_t::array:
                {
                    if (last_path == "-")
                    {
                        // special case: append to back
                        parent.push_back(val);
                    }
                    else
                    {
                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
                        {
                            // avoid undefined behavior
                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
                        }

                        // default case: insert add offset
                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
                    }
                    break;
                }

                // if there exists a parent it cannot be primitive
                case value_t::string: // LCOV_EXCL_LINE
                case value_t::boolean: // LCOV_EXCL_LINE
                case value_t::number_integer: // LCOV_EXCL_LINE
                case value_t::number_unsigned: // LCOV_EXCL_LINE
                case value_t::number_float: // LCOV_EXCL_LINE
                case value_t::binary: // LCOV_EXCL_LINE
                case value_t::discarded: // LCOV_EXCL_LINE
                default:            // LCOV_EXCL_LINE
                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
            }
        };

        // wrapper for "remove" operation; remove value at ptr
        const auto operation_remove = [this, & result](json_pointer & ptr)
        {
            // get reference to parent of JSON pointer ptr
            const auto last_path = ptr.back();
            ptr.pop_back();
            basic_json& parent = result.at(ptr);

            // remove child
            if (parent.is_object())
            {
                // perform range check
                auto it = parent.find(last_path);
                if (JSON_HEDLEY_LIKELY(it != parent.end()))
                {
                    parent.erase(it);
                }
                else
                {
                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
                }
            }
            else if (parent.is_array())
            {
                // note erase performs range check
                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
            }
        };

        // type check: top level value must be an array
        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
        {
            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
        }

        // iterate and apply the operations
        for (const auto& val : json_patch)
        {
            // wrapper to get a value for an operation
            const auto get_value = [&val](const std::string & op,
                                          const std::string & member,
                                          bool string_type) -> basic_json &
            {
                // find value
                auto it = val.m_data.m_value.object->find(member);

                // context-sensitive error message
                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\'');

                // check if desired value is present
                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
                {
                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
                }

                // check if result is of type string
                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
                {
                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
                }

                // no error: return value
                return it->second;
            };

            // type check: every element of the array must be an object
            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
            {
                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
            }

            // collect mandatory members
            const auto op = get_value("op", "op", true).template get<std::string>();
            const auto path = get_value(op, "path", true).template get<std::string>();
            json_pointer ptr(path);

            switch (get_op(op))
            {
                case patch_operations::add:
                {
                    operation_add(ptr, get_value("add", "value", false));
                    break;
                }

                case patch_operations::remove:
                {
                    operation_remove(ptr);
                    break;
                }

                case patch_operations::replace:
                {
                    // the "path" location must exist - use at()
                    result.at(ptr) = get_value("replace", "value", false);
                    break;
                }

                case patch_operations::move:
                {
                    const auto from_path = get_value("move", "from", true).template get<std::string>();
                    json_pointer from_ptr(from_path);

                    // the "from" location must exist - use at()
                    basic_json const v = result.at(from_ptr);

                    // The move operation is functionally identical to a
                    // "remove" operation on the "from" location, followed
                    // immediately by an "add" operation at the target
                    // location with the value that was just removed.
                    operation_remove(from_ptr);
                    operation_add(ptr, v);
                    break;
                }

                case patch_operations::copy:
                {
                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
                    const json_pointer from_ptr(from_path);

                    // the "from" location must exist - use at()
                    basic_json const v = result.at(from_ptr);

                    // The copy is functionally identical to an "add"
                    // operation at the target location using the value
                    // specified in the "from" member.
                    operation_add(ptr, v);
                    break;
                }

                case patch_operations::test:
                {
                    bool success = false;
                    JSON_TRY
                    {
                        // check if "value" matches the one at "path"
                        // the "path" location must exist - use at()
                        success = (result.at(ptr) == get_value("test", "value", false));
                    }
                    JSON_INTERNAL_CATCH (out_of_range&)
                    {
                        // ignore out of range errors: success remains false
                    }

                    // throw an exception if test fails
                    if (JSON_HEDLEY_UNLIKELY(!success))
                    {
                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
                    }

                    break;
                }

                case patch_operations::invalid:
                default:
                {
                    // op must be "add", "remove", "replace", "move", "copy", or
                    // "test"
                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
                }
            }
        }
    }

    /// @brief applies a JSON patch to a copy of the current object
    /// @sa https://json.nlohmann.me/api/basic_json/patch/
    basic_json patch(const basic_json& json_patch) const
    {
        basic_json result = *this;
        result.patch_inplace(json_patch);
        return result;
    }

    /// @brief creates a diff as a JSON patch
    /// @sa https://json.nlohmann.me/api/basic_json/diff/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static basic_json diff(const basic_json& source, const basic_json& target,
                           const std::string& path = "")
    {
        // the patch
        basic_json result(value_t::array);

        // if the values are the same, return empty patch
        if (source == target)
        {
            return result;
        }

        if (source.type() != target.type())
        {
            // different types: replace value
            result.push_back(
            {
                {"op", "replace"}, {"path", path}, {"value", target}
            });
            return result;
        }

        switch (source.type())
        {
            case value_t::array:
            {
                // first pass: traverse common elements
                std::size_t i = 0;
                while (i < source.size() && i < target.size())
                {
                    // recursive call to compare array values at index i
                    auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i)));
                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                    ++i;
                }

                // We now reached the end of at least one array
                // in a second pass, traverse the remaining elements

                // remove my remaining elements
                const auto end_index = static_cast<difference_type>(result.size());
                while (i < source.size())
                {
                    // add operations in reverse order to avoid invalid
                    // indices
                    result.insert(result.begin() + end_index, object(
                    {
                        {"op", "remove"},
                        {"path", detail::concat(path, '/', std::to_string(i))}
                    }));
                    ++i;
                }

                // add other remaining elements
                while (i < target.size())
                {
                    result.push_back(
                    {
                        {"op", "add"},
                        {"path", detail::concat(path, "/-")},
                        {"value", target[i]}
                    });
                    ++i;
                }

                break;
            }

            case value_t::object:
            {
                // first pass: traverse this object's elements
                for (auto it = source.cbegin(); it != source.cend(); ++it)
                {
                    // escape the key name to be used in a JSON patch
                    const auto path_key = detail::concat(path, '/', detail::escape(it.key()));

                    if (target.find(it.key()) != target.end())
                    {
                        // recursive call to compare object values at key it
                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                    }
                    else
                    {
                        // found a key that is not in o -> remove it
                        result.push_back(object(
                        {
                            {"op", "remove"}, {"path", path_key}
                        }));
                    }
                }

                // second pass: traverse other object's elements
                for (auto it = target.cbegin(); it != target.cend(); ++it)
                {
                    if (source.find(it.key()) == source.end())
                    {
                        // found a key that is not in this -> add it
                        const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
                        result.push_back(
                        {
                            {"op", "add"}, {"path", path_key},
                            {"value", it.value()}
                        });
                    }
                }

                break;
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                // both primitive type: replace value
                result.push_back(
                {
                    {"op", "replace"}, {"path", path}, {"value", target}
                });
                break;
            }
        }

        return result;
    }
    /// @}

    ////////////////////////////////
    // JSON Merge Patch functions //
    ////////////////////////////////

    /// @name JSON Merge Patch functions
    /// @{

    /// @brief applies a JSON Merge Patch
    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
    void merge_patch(const basic_json& apply_patch)
    {
        if (apply_patch.is_object())
        {
            if (!is_object())
            {
                *this = object();
            }
            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
            {
                if (it.value().is_null())
                {
                    erase(it.key());
                }
                else
                {
                    operator[](it.key()).merge_patch(it.value());
                }
            }
        }
        else
        {
            *this = apply_patch;
        }
    }

    /// @}
};

/// @brief user-defined to_string function for JSON values
/// @sa https://json.nlohmann.me/api/basic_json/to_string/
NLOHMANN_BASIC_JSON_TPL_DECLARATION
std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
{
    return j.dump();
}

inline namespace literals
{
inline namespace json_literals
{

/// @brief user-defined string literal for JSON values
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
JSON_HEDLEY_NON_NULL(1)
#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
#else
    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
#endif
{
    return nlohmann::json::parse(s, s + n);
}

/// @brief user-defined string literal for JSON pointer
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
JSON_HEDLEY_NON_NULL(1)
#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
#else
    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
#endif
{
    return nlohmann::json::json_pointer(std::string(s, n));
}

}  // namespace json_literals
}  // namespace literals
NLOHMANN_JSON_NAMESPACE_END

///////////////////////
// nonmember support //
///////////////////////

namespace std // NOLINT(cert-dcl58-cpp)
{

/// @brief hash value for JSON objects
/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
NLOHMANN_BASIC_JSON_TPL_DECLARATION
struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
{
    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
    {
        return nlohmann::detail::hash(j);
    }
};

// specialization for std::less<value_t>
template<>
struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
{
    /*!
    @brief compare two value_t enum values
    @since version 3.0.0
    */
    bool operator()(::nlohmann::detail::value_t lhs,
                    ::nlohmann::detail::value_t rhs) const noexcept
    {
#if JSON_HAS_THREE_WAY_COMPARISON
        return std::is_lt(lhs <=> rhs); // *NOPAD*
#else
        return ::nlohmann::detail::operator<(lhs, rhs);
#endif
    }
};

// C++20 prohibit function specialization in the std namespace.
#ifndef JSON_HAS_CPP_20

/// @brief exchanges the values of two JSON objects
/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
NLOHMANN_BASIC_JSON_TPL_DECLARATION
inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
{
    j1.swap(j2);
}

#endif

}  // namespace std

#if JSON_USE_GLOBAL_UDLS
    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
    #else
        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
    #endif
#endif

// #include <nlohmann/detail/macro_unscope.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



// restore clang diagnostic settings
#if defined(__clang__)
    #pragma clang diagnostic pop
#endif

// clean up
#undef JSON_ASSERT
#undef JSON_INTERNAL_CATCH
#undef JSON_THROW
#undef JSON_PRIVATE_UNLESS_TESTED
#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
#undef NLOHMANN_BASIC_JSON_TPL
#undef JSON_EXPLICIT
#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
#undef JSON_INLINE_VARIABLE
#undef JSON_NO_UNIQUE_ADDRESS
#undef JSON_DISABLE_ENUM_SERIALIZATION
#undef JSON_USE_GLOBAL_UDLS

#ifndef JSON_TEST_KEEP_MACROS
    #undef JSON_CATCH
    #undef JSON_TRY
    #undef JSON_HAS_CPP_11
    #undef JSON_HAS_CPP_14
    #undef JSON_HAS_CPP_17
    #undef JSON_HAS_CPP_20
    #undef JSON_HAS_FILESYSTEM
    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
    #undef JSON_HAS_THREE_WAY_COMPARISON
    #undef JSON_HAS_RANGES
    #undef JSON_HAS_STATIC_RTTI
    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
#endif

// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT



#undef JSON_HEDLEY_ALWAYS_INLINE
#undef JSON_HEDLEY_ARM_VERSION
#undef JSON_HEDLEY_ARM_VERSION_CHECK
#undef JSON_HEDLEY_ARRAY_PARAM
#undef JSON_HEDLEY_ASSUME
#undef JSON_HEDLEY_BEGIN_C_DECLS
#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
#undef JSON_HEDLEY_CLANG_HAS_FEATURE
#undef JSON_HEDLEY_CLANG_HAS_WARNING
#undef JSON_HEDLEY_COMPCERT_VERSION
#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
#undef JSON_HEDLEY_CONCAT
#undef JSON_HEDLEY_CONCAT3
#undef JSON_HEDLEY_CONCAT3_EX
#undef JSON_HEDLEY_CONCAT_EX
#undef JSON_HEDLEY_CONST
#undef JSON_HEDLEY_CONSTEXPR
#undef JSON_HEDLEY_CONST_CAST
#undef JSON_HEDLEY_CPP_CAST
#undef JSON_HEDLEY_CRAY_VERSION
#undef JSON_HEDLEY_CRAY_VERSION_CHECK
#undef JSON_HEDLEY_C_DECL
#undef JSON_HEDLEY_DEPRECATED
#undef JSON_HEDLEY_DEPRECATED_FOR
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
#undef JSON_HEDLEY_DIAGNOSTIC_POP
#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
#undef JSON_HEDLEY_DMC_VERSION
#undef JSON_HEDLEY_DMC_VERSION_CHECK
#undef JSON_HEDLEY_EMPTY_BASES
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#undef JSON_HEDLEY_END_C_DECLS
#undef JSON_HEDLEY_FLAGS
#undef JSON_HEDLEY_FLAGS_CAST
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
#undef JSON_HEDLEY_GCC_HAS_BUILTIN
#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_GCC_HAS_EXTENSION
#undef JSON_HEDLEY_GCC_HAS_FEATURE
#undef JSON_HEDLEY_GCC_HAS_WARNING
#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
#undef JSON_HEDLEY_GCC_VERSION
#undef JSON_HEDLEY_GCC_VERSION_CHECK
#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
#undef JSON_HEDLEY_GNUC_HAS_FEATURE
#undef JSON_HEDLEY_GNUC_HAS_WARNING
#undef JSON_HEDLEY_GNUC_VERSION
#undef JSON_HEDLEY_GNUC_VERSION_CHECK
#undef JSON_HEDLEY_HAS_ATTRIBUTE
#undef JSON_HEDLEY_HAS_BUILTIN
#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_HAS_EXTENSION
#undef JSON_HEDLEY_HAS_FEATURE
#undef JSON_HEDLEY_HAS_WARNING
#undef JSON_HEDLEY_IAR_VERSION
#undef JSON_HEDLEY_IAR_VERSION_CHECK
#undef JSON_HEDLEY_IBM_VERSION
#undef JSON_HEDLEY_IBM_VERSION_CHECK
#undef JSON_HEDLEY_IMPORT
#undef JSON_HEDLEY_INLINE
#undef JSON_HEDLEY_INTEL_CL_VERSION
#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
#undef JSON_HEDLEY_INTEL_VERSION
#undef JSON_HEDLEY_INTEL_VERSION_CHECK
#undef JSON_HEDLEY_IS_CONSTANT
#undef JSON_HEDLEY_IS_CONSTEXPR_
#undef JSON_HEDLEY_LIKELY
#undef JSON_HEDLEY_MALLOC
#undef JSON_HEDLEY_MCST_LCC_VERSION
#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
#undef JSON_HEDLEY_MESSAGE
#undef JSON_HEDLEY_MSVC_VERSION
#undef JSON_HEDLEY_MSVC_VERSION_CHECK
#undef JSON_HEDLEY_NEVER_INLINE
#undef JSON_HEDLEY_NON_NULL
#undef JSON_HEDLEY_NO_ESCAPE
#undef JSON_HEDLEY_NO_RETURN
#undef JSON_HEDLEY_NO_THROW
#undef JSON_HEDLEY_NULL
#undef JSON_HEDLEY_PELLES_VERSION
#undef JSON_HEDLEY_PELLES_VERSION_CHECK
#undef JSON_HEDLEY_PGI_VERSION
#undef JSON_HEDLEY_PGI_VERSION_CHECK
#undef JSON_HEDLEY_PREDICT
#undef JSON_HEDLEY_PRINTF_FORMAT
#undef JSON_HEDLEY_PRIVATE
#undef JSON_HEDLEY_PUBLIC
#undef JSON_HEDLEY_PURE
#undef JSON_HEDLEY_REINTERPRET_CAST
#undef JSON_HEDLEY_REQUIRE
#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
#undef JSON_HEDLEY_REQUIRE_MSG
#undef JSON_HEDLEY_RESTRICT
#undef JSON_HEDLEY_RETURNS_NON_NULL
#undef JSON_HEDLEY_SENTINEL
#undef JSON_HEDLEY_STATIC_ASSERT
#undef JSON_HEDLEY_STATIC_CAST
#undef JSON_HEDLEY_STRINGIFY
#undef JSON_HEDLEY_STRINGIFY_EX
#undef JSON_HEDLEY_SUNPRO_VERSION
#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
#undef JSON_HEDLEY_TINYC_VERSION
#undef JSON_HEDLEY_TINYC_VERSION_CHECK
#undef JSON_HEDLEY_TI_ARMCL_VERSION
#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
#undef JSON_HEDLEY_TI_CL2000_VERSION
#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
#undef JSON_HEDLEY_TI_CL430_VERSION
#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
#undef JSON_HEDLEY_TI_CL6X_VERSION
#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
#undef JSON_HEDLEY_TI_CL7X_VERSION
#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
#undef JSON_HEDLEY_TI_CLPRU_VERSION
#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
#undef JSON_HEDLEY_TI_VERSION
#undef JSON_HEDLEY_TI_VERSION_CHECK
#undef JSON_HEDLEY_UNAVAILABLE
#undef JSON_HEDLEY_UNLIKELY
#undef JSON_HEDLEY_UNPREDICTABLE
#undef JSON_HEDLEY_UNREACHABLE
#undef JSON_HEDLEY_UNREACHABLE_RETURN
#undef JSON_HEDLEY_VERSION
#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
#undef JSON_HEDLEY_VERSION_DECODE_MINOR
#undef JSON_HEDLEY_VERSION_DECODE_REVISION
#undef JSON_HEDLEY_VERSION_ENCODE
#undef JSON_HEDLEY_WARNING
#undef JSON_HEDLEY_WARN_UNUSED_RESULT
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
#undef JSON_HEDLEY_FALL_THROUGH



#endif  // INCLUDE_NLOHMANN_JSON_HPP_


================================================
FILE: lib/json/json_rwops_input.hpp
================================================
#ifndef PRIV_RVOPS_PATCH
#define PRIV_RVOPS_PATCH

#   ifndef JSON_NO_IO
#include <string>
#include <SDL2/SDL_rwops.h>

#ifdef NLOHMANN_JSON_NAMESPACE_BEGIN
#   error Include this file BEFORE the <json/json.hpp>!
#endif

#define NLOHMANN_JSON_NAMESPACE_NO_VERSION 1 // Disable versioning

namespace nlohmann
{
#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
inline namespace json_abi
#else
inline namespace json_abi_v3_11_3
#endif
{
namespace detail
{


static constexpr size_t s_rwops_input_adapter_buffer_size = 2048;

namespace rwops
{
    // Primary template of char_traits calls std char_traits
    template<typename T>
    struct char_traits : std::char_traits<T>
    {};

    // Explicitly define char traits for unsigned char since it is not standard
    template<>
    struct char_traits<unsigned char> : std::char_traits<char>
    {
        using char_type = unsigned char;
        using int_type = uint64_t;

        // Redefine to_int_type function
        static int_type to_int_type(char_type c) noexcept
        {
            return static_cast<int_type>(c);
        }

        static char_type to_char_type(int_type i) noexcept
        {
            return static_cast<char_type>(i);
        }

        static constexpr int_type eof() noexcept
        {
            return static_cast<int_type>(EOF);
        }
    };
}

/*!
Input adapter for SDL_RWops file access. Uses a 2KB cache.
*/
class rwops_input_adapter
{
public:
    using char_type = uint8_t;

    explicit rwops_input_adapter(SDL_RWops* rwops) noexcept
        : m_rwops(rwops) {}

    // make class move-only
    rwops_input_adapter(const rwops_input_adapter&) = delete;
    rwops_input_adapter(rwops_input_adapter&&) noexcept = default;
    rwops_input_adapter& operator=(const rwops_input_adapter&) = delete;
    rwops_input_adapter& operator=(rwops_input_adapter&&) = delete;
    ~rwops_input_adapter() = default;

    rwops::char_traits<uint8_t>::int_type get_character() noexcept
    {
        if(m_temp_buf_cur >= m_temp_buf_end)
        {
            m_temp_buf_cur = 0;
            m_temp_buf_end = SDL_RWread(m_rwops, &m_temp_buf[0], 1, sizeof(m_temp_buf));

            if(m_temp_buf_end == 0)
                return rwops::char_traits<uint8_t>::eof();
        }

        return m_temp_buf[m_temp_buf_cur++];
    }

private:
    /// the rwops stream to read from
    SDL_RWops* m_rwops;

    uint8_t m_temp_buf[s_rwops_input_adapter_buffer_size];
    int m_temp_buf_cur = 0;
    int m_temp_buf_end = 0;
};

inline rwops_input_adapter input_adapter(SDL_RWops* rwops)
{
    return rwops_input_adapter(rwops);
}



} // namespace detail
} // inline namespace json_abi
} // namespace nlohmann

#   endif // #ifndef JSON_NO_IO
#endif // PRIV_RVOPS_PATCH


================================================
FILE: lib/md5/LICENSE
================================================
The MIT License (MIT)

Copyright (c) 2015 Michael

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.



================================================
FILE: lib/md5/README
================================================
https://github.com/CommanderBubble/MD5

========================================================

This library is inspired by the one found at http://256.com/sources/md5/ by Gray Watson. It was written as the aforementioned library is under the GPL license and has the annoying RSA preamble; this has been written from reading the specification document, and does NOT use the provided code, and is distributed under the MIT licence. This notice serves as indication of the program's origins.

This SHOULD be cross-compatible, but is untested on anything other than windows under msys2/mingw.

* Introduction

This is a C++ class that implements the Message Digest Algorithm MD5.  The purpose of the algorithm is to calculate a hash of given bit string. MD5 produces a 16 byte (128 bit) hash.
The MD5 hash has been proven to be cryptographically vulnerable to various attacks (google them), and as such should not be used for security purposes. The intended purpose of this library is for file verification.

* Building The Library

The provided makefile will produce a static lib to link against.
To build it follow these steps:
	1) autoreconf
	2) configure
	3) make
	4) make install
	
You can then 'make check' to run the library's self checks

By default the library will compile with the CXXFLAGS '-g -O2'. For a production library without the debugging symbols, call
make CXXFLAGS=<your_flags_here>

Additionally, the test program can be used as a simple hashing application.
Calling 'md5_t -r -' will generate a signature on the data read from standard in.
Calling 'md5_t -r filename' will generate a signature from the contents of a file.

* Class Usage

All functions and constants live in the md5 namespace, or are prefaced by MD5_ if they are in the public namespace.

The class is called md5_t.  The API consists of five methods:

md5::md5_t() is the class constructor.

void md5_t::process(const void* input, const unsigned int input_length)
  Processes bytes into the hash.
  - input is a pointer to the first byte to be added. The bytes are not modified.
  - input_length is the number of bytes to process. The value is not modified.

void md5_t::finish(void* signature_ = NULL)
  Completes the hashing process and (optionally) returns the final hash.  The md5 instance cannot be used to calculate a new hash after this call.
  - signature_ is a pointer to a (minimum) 20-byte char array.

if you have all the data available to process at initialisation time, the c=object can be constructed as
void md5_t::md5(const void* input, const unsigned int input_length, void* signature = NULL)
  - input is a pointer to the first byte to be added. The bytes are not modified.
  - input_length is the number of bytes to process. The value is not modified.

There are two functions to retrieve the stored signature and string from the object:

void md5_t::get_sig(void* signature_)
  Returns the previously calculated signature. can only be used after calling finish().
  - signature_ is a pointer to a (minimum) 16-byte char array.
  
void md5_t::get_string(void* str_)
  Returns the previously calculated signature in readable hex format.
  - str_ is a pointer to a (minimum) 33-byte char array.
  
We also provide two auxiliary functions for converting hashes to strings and strings to hashes, for example if the object has expired. These are not class functions, and can be used without ever creating an object if you already have a signature or string.

void md5::sig_to_string(const void* signature_, char* str_)
  Is a utility method that turns a digest into a human-readable string
  - signature_ is a pointer to the char array containing the signature. The bytes are not modified.
  - str_ is a pointer to the char array for the string to be placed into. it must have room for at least 33 bytes; this is the caller's responsibility.

void md5::sig_from_string(void* signature_, const char* str_)
  Is a utility method that turns a digest into a human-readable string
  - signature_ is a pointer to the char array to place the signature in. it must behave room for at least 16 bytes; this is the caller's responsibility.
  - str_ is a pointer to the char array containing the string. The bytes are not modified.


* Example

The following program will print one line to stdout:
900150983cd24fb0d6963f7d28e17f72

#include <string.h>
#include <cstdlib>
#include <iostream>

#include <md5.h>

int main(int argc, char** argv) {
	const char* BYTES = "abc";

	md5::md5_t md5;
	md5.process(BYTES, strlen(BYTES));
	md5.finish();

	char str[MD5_STRING_SIZE];

	md5.get_string(str);

	for (unsigned int i = 0; i < MD5_STRING_SIZE; i++)
		std::cout << str[i];
}


================================================
FILE: lib/md5/md5.cmake
================================================
include_directories(${CMAKE_CURRENT_LIST_DIR}/)

set(MD5_SRCS)

list(APPEND MD5_SRCS
    ${CMAKE_CURRENT_LIST_DIR}/md5.cpp
    ${CMAKE_CURRENT_LIST_DIR}/md5tools.cpp
)


================================================
FILE: lib/md5/md5.cpp
================================================
#include <cassert>
#include <cstring>
#include <iostream>

// #include "conf.h" //TheXTech Absolutely useless header, no macros used from it
#include "md5.h"
#include "md5_loc.h"

namespace md5 {
    /****************************** Public Functions ******************************/

    /*
     * md5_t
     *
     * DESCRIPTION:
     *
     * Initialize structure containing state of MD5 computation. (RFC 1321,
     * 3.3: Step 3).  This is for progressive MD5 calculations only.  If
     * you have the complete string available, call it as below.
     * process should be called for each bunch of bytes and after the
     * last process call, finish should be called to get the signature.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * None.
     */
    md5_t::md5_t() {
        initialise();
    }

    /*
     * md5_t
     *
     * DESCRIPTION:
     *
     * This function is used to calculate a MD5 signature for a buffer of
     * bytes.  If you only have part of a buffer that you want to process
     * then md5_t, process, and finish should be used.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * buffer - A buffer of bytes whose MD5 signature we are calculating.
     *
     * input_length - The length of the buffer.
     *
     * signature - A 16 byte buffer that will contain the MD5 signature.
     */
    md5_t::md5_t(const void* input, const unsigned int input_length, void* signature) {
        /* initialize the computation context */
        initialise();

        /* process whole buffer but last input_length % MD5_BLOCK bytes */
        process(input, input_length);

        /* put result in desired memory area */
        finish(signature);
    }

    /*
     * process
     *
     * DESCRIPTION:
     *
     * This function is used to progressively calculate a MD5 signature some
     * number of bytes at a time.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * buffer - A buffer of bytes whose MD5 signature we are calculating.
     *
     * input_length - The length of the buffer.
     */
    void md5_t::process(const void* input, const unsigned int input_length) {
        if (!finished) {
            unsigned int processed = 0;

            /*
             * If we have any data stored from a previous call to process then we use these
             * bytes first, and the new data is large enough to create a complete block then
             * we process these bytes first.
             */
            if (stored_size && input_length + stored_size >= md5::BLOCK_SIZE) {
                unsigned char block[md5::BLOCK_SIZE];
                memcpy(block, stored, stored_size);
                memcpy(block + stored_size, input, md5::BLOCK_SIZE - stored_size);
                processed = md5::BLOCK_SIZE - stored_size;
                stored_size = 0;
                process_block(block);
            }

            /*
             * While there is enough data to create a complete block, process it.
             */
            while (processed + md5::BLOCK_SIZE <= input_length) {
                process_block((unsigned char*)input + processed);
                processed += md5::BLOCK_SIZE;
            }

            /*
             * If there are any unprocessed bytes left over that do not create a complete block
             * then we store these bytes for processing next time.
             */
            if (processed != input_length) {
                memcpy(stored + stored_size, (char*)input + processed, input_length - processed);
                stored_size += input_length - processed;
            } else {
                stored_size = 0;
            }
        } else {
            // throw error when trying to process after completion?
        }
    }

    /*
     * finish
     *
     * DESCRIPTION:
     *
     * Finish a progressing MD5 calculation and copy the resulting MD5
     * signature into the result buffer which should be 16 bytes
     * (MD5_SIZE).  After this call, the MD5 structure cannot process
	 * additional bytes.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * signature - A 16 byte buffer that will contain the MD5 signature.
     */
    void md5_t::finish(void* signature_) {
        if (!finished) {
            if (message_length[0] + stored_size < message_length[0])
                message_length[1]++;
            message_length[0] += stored_size;

            int pad = md5::BLOCK_SIZE - (sizeof(unsigned int) * 2) - stored_size;
            if (pad <= 0)
                pad += md5::BLOCK_SIZE;

            /*
             * Modified from a fixed array to this assignment and memset to be
             * more flexible with block-sizes -- Gray 10/97.
             */
            if (pad > 0) {
                stored[stored_size] = 0x80;
                if (pad > 1)
                    memset(stored + stored_size + 1, 0, pad - 1);
                stored_size += pad;
            }

            /*
             * Put the 64-bit file length in _bits_ (i.e. *8) at the end of the
             * buffer. appears to be in beg-endian format in the buffer?
             */
            unsigned int size_low = ((message_length[0] & 0x1FFFFFFF) << 3);
            memcpy(stored + stored_size, &size_low, sizeof(unsigned int));
            stored_size += sizeof(unsigned int);

            /* shift the high word over by 3 and add in the top 3 bits from the low */
            unsigned int size_high = (message_length[1] << 3) | ((message_length[0] & 0xE0000000) >> 29);
            memcpy(stored + stored_size, &size_high, sizeof(unsigned int));
            stored_size += sizeof(unsigned int);

            /*
             * process the last block of data.
             * if the length of the message was already exactly sized, then we have
             * 2 messages to process
             */
            process_block(stored);
            if (stored_size > md5::BLOCK_SIZE)
                process_block(stored + md5::BLOCK_SIZE);

            /* Arrange the results into a signature */
            get_result(static_cast<void*>(signature));

            /* store the signature into a readable sring */
            sig_to_string(signature, str, MD5_STRING_SIZE);

            if (signature_ != NULL) {
                memcpy(signature_, static_cast<void*>(signature), MD5_SIZE);
            }

            finished = true;
        } else {
            // add error?
        }
    }

    /*
     * get_sig
     *
     * DESCRIPTION:
     *
     * Retrieves the previously calculated signature from the MD5 object.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * signature_ - A 16 byte buffer that will contain the MD5 signature.
     */
    void md5_t::get_sig(void* signature_) {
        if (finished) {
            memcpy(signature_, signature, MD5_SIZE);
        } else {
            //error?
        }
    }

    /*
     * get_string
     *
     * DESCRIPTION:
     *
     * Retrieves the previously calculated signature from the MD5 object in
     * printable format.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * str_ - a string of characters which should be at least 33 bytes long
     * (2 characters per MD5 byte and 1 for the \0).
     */
    void md5_t::get_string(void* str_) {
        if (finished) {
            memcpy(str_, str, MD5_STRING_SIZE);
        } else {
            // error?
        }
    }

    /****************************** Private Functions ******************************/

    /*
     * initialise
     *
     * DESCRIPTION:
     *
     * Initialize structure containing state of MD5 computation. (RFC 1321,
     * 3.3: Step 3).
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * None.
     */
    void md5_t::initialise() {
        /*
         * ensures that unsigned int is 4 bytes on this platform, will need modifying
         * if we are to use on a different sized platform.
         */
        assert(MD5_SIZE == 16);

        A = 0x67452301;
        B = 0xefcdab89;
        C = 0x98badcfe;
        D = 0x10325476;

        message_length[0] = 0;
        message_length[1] = 0;
        stored_size = 0;

        memset(stored, 0,BLOCK_SIZE * 2);
        memset(signature, 0,MD5_SIZE);
        memset(str, 0,MD5_STRING_SIZE);

        finished = false;
    }

    /*
     * process_block
     *
     * DESCRIPTION:
     *
     * Process a block of bytes into a MD5 state structure.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * buffer - A buffer of bytes whose MD5 signature we are calculating.
     *
     * input_length - The length of the buffer.
     */
    void md5_t::process_block(const unsigned char* block) {
    /* Process each 16-word block. */

        /*
         * we check for when the lower word rolls over, and increment the
         * higher word. we do not need to worry if the higher word rolls over
         * as only the two words we maintain are needed in the function later
         */
        if (message_length[0] + md5::BLOCK_SIZE < message_length[0])
            message_length[1]++;
        message_length[0] += BLOCK_SIZE;

        // Copy the block into X. */
        unsigned int X[16];
        for (unsigned int i = 0; i < 16; i++) {
            memcpy(X + i, block + 4 * i, 4);
        }

        /* Save A as AA, B as BB, C as CC, and D as DD. */
        unsigned int AA = A, BB = B, CC = C, DD = D;

        /* Round 1
         * Let [abcd k s i] denote the operation
         * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s)
         * Do the following 16 operations
         * [ABCD  0  7  1]  [DABC  1 12  2]  [CDAB  2 17  3]  [BCDA  3 22  4]
         * [ABCD  4  7  5]  [DABC  5 12  6]  [CDAB  6 17  7]  [BCDA  7 22  8]
         * [ABCD  8  7  9]  [DABC  9 12 10]  [CDAB 10 17 11]  [BCDA 11 22 12]
         * [ABCD 12  7 13]  [DABC 13 12 14]  [CDAB 14 17 15]  [BCDA 15 22 16]
         */
        md5::FF(A, B, C, D, X[0 ], 0, 0 );
        md5::FF(D, A, B, C, X[1 ], 1, 1 );
        md5::FF(C, D, A, B, X[2 ], 2, 2 );
        md5::FF(B, C, D, A, X[3 ], 3, 3 );
        md5::FF(A, B, C, D, X[4 ], 0, 4 );
        md5::FF(D, A, B, C, X[5 ], 1, 5 );
        md5::FF(C, D, A, B, X[6 ], 2, 6 );
        md5::FF(B, C, D, A, X[7 ], 3, 7 );
        md5::FF(A, B, C, D, X[8 ], 0, 8 );
        md5::FF(D, A, B, C, X[9 ], 1, 9 );
        md5::FF(C, D, A, B, X[10], 2, 10);
        md5::FF(B, C, D, A, X[11], 3, 11);
        md5::FF(A, B, C, D, X[12], 0, 12);
        md5::FF(D, A, B, C, X[13], 1, 13);
        md5::FF(C, D, A, B, X[14], 2, 14);
        md5::FF(B, C, D, A, X[15], 3, 15);

        /* Round 2
         * Let [abcd k s i] denote the operation
         * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s)
         * Do the following 16 operations
         * [ABCD  1  5 17]  [DABC  6  9 18]  [CDAB 11 14 19]  [BCDA  0 20 20]
         * [ABCD  5  5 21]  [DABC 10  9 22]  [CDAB 15 14 23]  [BCDA  4 20 24]
         * [ABCD  9  5 25]  [DABC 14  9 26]  [CDAB  3 14 27]  [BCDA  8 20 28]
         * [ABCD 13  5 29]  [DABC  2  9 30]  [CDAB  7 14 31]  [BCDA 12 20 32]
         */
        md5::GG(A, B, C, D, X[1 ], 0, 16);
        md5::GG(D, A, B, C, X[6 ], 1, 17);
        md5::GG(C, D, A, B, X[11], 2, 18);
        md5::GG(B, C, D, A, X[0 ], 3, 19);
        md5::GG(A, B, C, D, X[5 ], 0, 20);
        md5::GG(D, A, B, C, X[10], 1, 21);
        md5::GG(C, D, A, B, X[15], 2, 22);
        md5::GG(B, C, D, A, X[4 ], 3, 23);
        md5::GG(A, B, C, D, X[9 ], 0, 24);
        md5::GG(D, A, B, C, X[14], 1, 25);
        md5::GG(C, D, A, B, X[3 ], 2, 26);
        md5::GG(B, C, D, A, X[8 ], 3, 27);
        md5::GG(A, B, C, D, X[13], 0, 28);
        md5::GG(D, A, B, C, X[2 ], 1, 29);
        md5::GG(C, D, A, B, X[7 ], 2, 30);
        md5::GG(B, C, D, A, X[12], 3, 31);

        /* Round 3
         * Let [abcd k s i] denote the operation
         * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s)
         * Do the following 16 operations
         * [ABCD  5  4 33]  [DABC  8 11 34]  [CDAB 11 16 35]  [BCDA 14 23 36]
         * [ABCD  1  4 37]  [DABC  4 11 38]  [CDAB  7 16 39]  [BCDA 10 23 40]
         * [ABCD 13  4 41]  [DABC  0 11 42]  [CDAB  3 16 43]  [BCDA  6 23 44]
         * [ABCD  9  4 45]  [DABC 12 11 46]  [CDAB 15 16 47]  [BCDA  2 23 48]
         */
        md5::HH(A, B, C, D, X[5 ], 0, 32);
        md5::HH(D, A, B, C, X[8 ], 1, 33);
        md5::HH(C, D, A, B, X[11], 2, 34);
        md5::HH(B, C, D, A, X[14], 3, 35);
        md5::HH(A, B, C, D, X[1 ], 0, 36);
        md5::HH(D, A, B, C, X[4 ], 1, 37);
        md5::HH(C, D, A, B, X[7 ], 2, 38);
        md5::HH(B, C, D, A, X[10], 3, 39);
        md5::HH(A, B, C, D, X[13], 0, 40);
        md5::HH(D, A, B, C, X[0 ], 1, 41);
        md5::HH(C, D, A, B, X[3 ], 2, 42);
        md5::HH(B, C, D, A, X[6 ], 3, 43);
        md5::HH(A, B, C, D, X[9 ], 0, 44);
        md5::HH(D, A, B, C, X[12], 1, 45);
        md5::HH(C, D, A, B, X[15], 2, 46);
        md5::HH(B, C, D, A, X[2 ], 3, 47);

        /* Round 4
         * Let [abcd k s i] denote the operation
         * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s)
         * Do the following 16 operations
         * [ABCD  0  6 49]  [DABC  7 10 50]  [CDAB 14 15 51]  [BCDA  5 21 52]
         * [ABCD 12  6 53]  [DABC  3 10 54]  [CDAB 10 15 55]  [BCDA  1 21 56]
         * [ABCD  8  6 57]  [DABC 15 10 58]  [CDAB  6 15 59]  [BCDA 13 21 60]
         * [ABCD  4  6 61]  [DABC 11 10 62]  [CDAB  2 15 63]  [BCDA  9 21 64]
         */
        md5::II(A, B, C, D, X[0 ], 0, 48);
        md5::II(D, A, B, C, X[7 ], 1, 49);
        md5::II(C, D, A, B, X[14], 2, 50);
        md5::II(B, C, D, A, X[5 ], 3, 51);
        md5::II(A, B, C, D, X[12], 0, 52);
        md5::II(D, A, B, C, X[3 ], 1, 53);
        md5::II(C, D, A, B, X[10], 2, 54);
        md5::II(B, C, D, A, X[1 ], 3, 55);
        md5::II(A, B, C, D, X[8 ], 0, 56);
        md5::II(D, A, B, C, X[15], 1, 57);
        md5::II(C, D, A, B, X[6 ], 2, 58);
        md5::II(B, C, D, A, X[13], 3, 59);
        md5::II(A, B, C, D, X[4 ], 0, 60);
        md5::II(D, A, B, C, X[11], 1, 61);
        md5::II(C, D, A, B, X[2 ], 2, 62);
        md5::II(B, C, D, A, X[9 ], 3, 63);

        /* Then perform the following additions. (That is increment each
        of the four registers by the value it had before this block
        was started.) */
        A += AA;
        B += BB;
        C += CC;
        D += DD;
    }

    /*
     * get_result
     *
     * DESCRIPTION:
     *
     * Copy the resulting MD5 signature into the first 16 bytes (MD5_SIZE)
     * of the result buffer.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * result - A 16 byte buffer that will contain the MD5 signature.
     */
    void md5_t::get_result(void *result) {
        memcpy((char*)result, &A, sizeof(unsigned int));
        memcpy((char*)result + sizeof(unsigned int), &B, sizeof(unsigned int));
        memcpy((char*)result + 2 * sizeof(unsigned int), &C, sizeof(unsigned int));
        memcpy((char*)result + 3 * sizeof(unsigned int), &D, sizeof(unsigned int));
    }

    /****************************** Exported Functions ******************************/

    /*
     * sig_to_string
     *
     * DESCRIPTION:
     *
     * Convert a MD5 signature in a 16 byte buffer into a hexadecimal string
     * representation.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * signature_ - a 16 byte buffer that contains the MD5 signature.
     *
     * str_ - a string of charactes which should be at least 33 bytes long (2
     * characters per MD5 byte and 1 for the \0).
     *
     * str_len - the length of the string.
     */
    void sig_to_string(const void* signature_, char* str_, const int str_len) {
        unsigned char* sig_p;
        char* str_p;
        char* max_p;
        unsigned int high, low;

        str_p = str_;
        max_p = str_ + str_len;

        for (sig_p = (unsigned char*)signature_; sig_p < (unsigned char*)signature_ + MD5_SIZE; sig_p++) {
            high = *sig_p / 16;
            low = *sig_p % 16;
            /* account for 2 chars */
            if (str_p + 1 >= max_p) {
                break;
            }
            *str_p++ = md5::HEX_STRING[high];
            *str_p++ = md5::HEX_STRING[low];
        }
        /* account for 2 chars */
        if (str_p < max_p) {
            *str_p++ = '\0';
        }
    }

    /*
     * sig_from_string
     *
     * DESCRIPTION:
     *
     * Convert a MD5 signature from a hexadecimal string representation into
     * a 16 byte buffer.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * signature_ - A 16 byte buffer that will contain the MD5 signature.
     *
     * str_ - A string of charactes which _must_ be at least 32 bytes long (2
     * characters per MD5 byte).
     */
    void sig_from_string(void* signature_, const char* str_) {
        unsigned char *sig_p;
        const char *str_p;
        char* hex;
        unsigned int high, low, val;

        hex = (char*)md5::HEX_STRING;
        sig_p = static_cast<unsigned char*>(signature_);

        for (str_p = str_; str_p < str_ + MD5_SIZE * 2; str_p += 2) {
            high = strchr(hex, *str_p) - hex;
            low = strchr(hex, *(str_p + 1)) - hex;
            val = high * 16 + low;
            *sig_p++ = val;
        }
    }
} // namespace md5



================================================
FILE: lib/md5/md5.h
================================================
#ifndef __MD5_H__
#define __MD5_H__

#include <stddef.h>

/*
 * Size of a standard MD5 signature in bytes.  This definition is for
 * external programs only.  The MD5 routines themselves reference the
 * signature as 4 unsigned 32-bit integers.
 */
const unsigned int MD5_SIZE = (4 * sizeof(unsigned int));   /* 16 */
const unsigned int MD5_STRING_SIZE = 2 * MD5_SIZE + 1;      /* 33 */

 namespace md5 {
    /*
     * The MD5 algorithm works on blocks of characters of 64 bytes.  This
     * is an internal value only and is not necessary for external use.
     */
    const unsigned int BLOCK_SIZE = 64;

    class md5_t {
        public:
            /*
             * md5_t
             *
             * DESCRIPTION:
             *
             * Initialize structure containing state of MD5 computation. (RFC 1321,
             * 3.3: Step 3).  This is for progressive MD5 calculations only.  If
             * you have the complete string available, call it as below.
             * process should be called for each bunch of bytes and after the last
             * process call, finish should be called to get the signature.
             *
             * RETURNS:
             *
             * None.
             *
             * ARGUMENTS:
             *
             * None.
             */
            md5_t();

            /*
             * md5_t
             *
             * DESCRIPTION:
             *
             * This function is used to calculate a MD5 signature for a buffer of
             * bytes.  If you only have part of a buffer that you want to process
             * then md5_t, process, and finish should be used.
             *
             * RETURNS:
             *
             * None.
             *
             * ARGUMENTS:
             *
             * input - A buffer of bytes whose MD5 signature we are calculating.
             *
             * input_length - The length of the buffer.
             *
             * signature_ - A 16 byte buffer that will contain the MD5 signature.
             */
            md5_t(const void* input, const unsigned int input_length, void* signature_ = NULL);

            /*
             * process
             *
             * DESCRIPTION:
             *
             * This function is used to progressively calculate an MD5 signature some
             * number of bytes at a time.
             *
             * RETURNS:
             *
             * None.
             *
             * ARGUMENTS:
             *
             * input - A buffer of bytes whose MD5 signature we are calculating.
             *
             * input_length - The length of the buffer.
             */
            void process(const void* input, const unsigned int input_length);

            /*
             * finish
             *
             * DESCRIPTION:
             *
             * Finish a progressing MD5 calculation and copy the resulting MD5
             * signature into the result buffer which should be 16 bytes
             * (MD5_SIZE).  After this call, the MD5 structure cannot be used
             * to calculate a new md5, it can only return its signature.
             *
             * RETURNS:
             *
             * None.
             *
             * ARGUMENTS:
             *
             * signature_ - A 16 byte buffer that will contain the MD5 signature.
             */
            void finish(void* signature_ = NULL);

            /*
             * get_sig
             *
             * DESCRIPTION:
             *
             * Retrieves the previously calculated signature from the MD5 object.
             *
             * RETURNS:
             *
             * None.
             *
             * ARGUMENTS:
             *
             * signature_ - A 16 byte buffer that will contain the MD5 signature.
             */
            void get_sig(void* signature_);

            /*
             * get_string
             *
             * DESCRIPTION:
             *
             * Retrieves the previously calculated signature from the MD5 object in
             * printable format.
             *
             * RETURNS:
             *
             * None.
             *
             * ARGUMENTS:
             *
             * str_ - a string of characters which should be at least 33 bytes long
             * (2 characters per MD5 byte and 1 for the \0).
             */
            void get_string(void* str_);

        private:
            /* internal functions */
            void initialise();
            void process_block(const unsigned char*);
            void get_result(void*);

            unsigned int A;                             /* accumulator 1 */
            unsigned int B;                             /* accumulator 2 */
            unsigned int C;                             /* accumulator 3 */
            unsigned int D;                             /* accumulator 4 */

            unsigned int message_length[2];             /* length of data */
            unsigned int stored_size;                   /* length of stored bytes */
            unsigned char stored[md5::BLOCK_SIZE * 2];  /* stored bytes */

            bool finished;                              /* object state */

            char signature[MD5_SIZE];                   /* stored signature */
            char str[MD5_STRING_SIZE];                  /* stored plain text hash */
    };

    /*
     * sig_to_string
     *
     * DESCRIPTION:
     *
     * Convert a MD5 signature in a 16 byte buffer into a hexadecimal string
     * representation.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * signature - a 16 byte buffer that contains the MD5 signature.
     *
     * str - a string of characters which should be at least 33 bytes long (2
     * characters per MD5 byte and 1 for the \0).
     *
     * str_len - the length of the string.
     */
    extern void sig_to_string(const void* signature, char* str, const int str_len);

    /*
     * sig_from_string
     *
     * DESCRIPTION:
     *
     * Convert a MD5 signature from a hexadecimal string representation into
     * a 16 byte buffer.
     *
     * RETURNS:
     *
     * None.
     *
     * ARGUMENTS:
     *
     * signature - A 16 byte buffer that will contain the MD5 signature.
     *
     * str - A string of charactes which _must_ be at least 32 bytes long (2
     * characters per MD5 byte).
     */
    extern void sig_from_string(void* signature, const char* str);
} // namespace md5

#endif /* ! __MD5_H__ */


================================================
FILE: lib/md5/md5_loc.h
================================================
/*
 * Local defines for the md5 functions.
 *
 * $Id: md5_loc.h,v 1.5 2010-05-07 13:58:18 gray Exp $
 */

#ifndef __MD5_LOC_H__
#define __MD5_LOC_H__

/*
 * We don't include "conf.h" here because it gets included before this file in md5.cpp so the defines
 * are correctly determing before they are checked.
 */
 #if MD5_DEBUG
    #include <iostream>
#endif // MD5_DEBUG

/// For now we are assuming everything is in little endian byte-order

namespace md5
{
    /*
     * NOTE: the following is assumed to generate a 32-bit unsigned data
     * type.
     */
    const unsigned int X_UINT32_MAX = 4294967295U;

    /*
     * T denotes the integer part of the i-th element of the function:
     * T[i] = 4294967296 * abs(sin(i)), where i is in radians.
     */
    const unsigned int T[64] = {
        0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
        0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
        0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
        0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
        0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
        0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
        0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
        0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
    };

    /*
     * Constants for the MD5 Transform routine as defined in RFC 1321
     */
    const unsigned int S1[4] = {7, 12, 17, 22};
    const unsigned int S2[4] = {5, 9,  14, 20};
    const unsigned int S3[4] = {4, 11, 16, 23};
    const unsigned int S4[4] = {6, 10, 15, 21};

    /*
     * Function to perform the cyclic left rotation of blocks of data
     */
    inline unsigned int cyclic_left_rotate(unsigned int data, unsigned int shift_bits) {
        return (data << shift_bits) | (data >> (32 - shift_bits));
    }

    inline unsigned int F(unsigned int x, unsigned int y, unsigned int z) {return (x & y) | (~x & z);}
    inline unsigned int G(unsigned int x, unsigned int y, unsigned int z) {return (x & z) | (y & ~z);}
    inline unsigned int H(unsigned int x, unsigned int y, unsigned int z) {return x ^ y ^ z;}
    inline unsigned int I(unsigned int x, unsigned int y, unsigned int z) {return y ^ (x | ~z);}

    inline void FF(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int Xk, unsigned int s, unsigned int i) {
        #if MD5_DEBUG
            std::cout << "\nA: " << a << "\nB: " << b << "\nC: " << c << "\nD: " << d << "\nX[" << i << "]: " << Xk << "\ns: " << S1[s] << "\nT: " << T[i] << "\n";
        #endif

        a += F(b,c,d) + Xk + T[i];
        a = cyclic_left_rotate(a, S1[s]);
        a += b;

        #if MD5_DEBUG
            std::cout << "A = " << a << "\n";
        #endif
    }

    inline void GG(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int Xk, unsigned int s, unsigned int i) {
        #if MD5_DEBUG
            std::cout << "\nA: " << a << "\nB: " << b << "\nC: " << c << "\nD: " << d << "\nX[" << i - 16 << "]: " << Xk << "\ns: " << S2[s] << "\nT: " << T[i] << "\n";
        #endif // MD5_DEBUG

        a += G(b,c,d) + Xk + T[i];
        a = cyclic_left_rotate(a, S2[s]);
        a += b;

        #if MD5_DEBUG
            std::cout << "A = " << a << "\n";
        #endif // MD5_DEBUG
    }

    inline void HH(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int Xk, unsigned int s, unsigned int i) {
        #if MD5_DEBUG
            std::cout << "\nA: " << a << "\nB: " << b << "\nC: " << c << "\nD: " << d << "\nX[" << i - 32 << "]: " << Xk << "\ns: " << S3[s] << "\nT: " << T[i] << "\n";
        #endif // MD5_DEBUG

        a += H(b,c,d) + Xk + T[i];
        a = cyclic_left_rotate(a, S3[s]);
        a += b;

        #if MD5_DEBUG
            std::cout << "A = " << a << "\n";
        #endif // MD5_DEBUG
    }
    inline void II(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int Xk, unsigned int s, unsigned int i) {
        #if MD5_DEBUG
            std::cout << "\nA: " << a << "\nB: " << b << "\nC: " << c << "\nD: " << d << "\nX[" << i - 48 << "]: " << Xk << "\ns: " << S4[s] << "\nT: " << T[i] << "\n";
        #endif // MD5_DEBUG

        a += I(b,c,d) + Xk + T[i];
        a = cyclic_left_rotate(a, S4[s]);
        a += b;

        #if MD5_DEBUG
            std::cout << "A = " << a << "\n";
        #endif // MD5_DEBUG
    }

    /*
     * Define my endian-ness.  Could not do in a portable manner using the
     * include files -- grumble.
     */
    #if MD5_BIG_ENDIAN

    /*
     * big endian - big is better
     */
    #define MD5_SWAP(n) (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))

    #else

    /*
     * little endian
     */
    #define MD5_SWAP(n) (n)

    #endif // MD5_BIG_ENDIAN

    const char* HEX_STRING = "0123456789abcdef";    /* to convert to hex */
}

#endif /* ! __MD5_LOC_H__ */


================================================
FILE: lib/md5/md5tools.cpp
================================================
#include "md5tools.hpp"
#include "../Utils/files.h"
#include <SDL2/SDL_rwops.h>


std::string md5::string_to_hash(const std::string &input)
{
    std::string out;
    md5::md5_t h;

    h.process((const void*)input.c_str(), (int)input.size());
    h.finish();

    out.resize(MD5_STRING_SIZE - 1);

    h.get_string(&out[0]);

    return out;
}

uint32_t md5::string_to_u32(const std::string &input)
{
    md5::md5_t h;

    h.process((const void*)input.c_str(), (int)input.size());
    h.finish();

    uint8_t out[16];

    h.get_sig(out);

    return out[0] | ((uint32_t)out[1] << 8) | ((uint32_t)out[2] << 16) | ((uint32_t)out[3] << 24);
}

std::string md5::file_to_hash(const std::string &filePath)
{
    char block[BLOCK_SIZE];
    std::string out;
    SDL_RWops *f = Files::open_file(filePath, "rb");
    size_t got;

    if(!f)
        return out;

    md5::md5_t h;

    do
    {
        got = SDL_RWread(f, (void*)block, 1, 64);
        h.process((const void*)block, (int)got);
    } while(got == 64);

    h.finish();
    out.resize(MD5_STRING_SIZE - 1);
    h.get_string(&out[0]);

    SDL_RWclose(f);

    return out;
}

std::string md5::mem_to_hash(const void *data, size_t size)
{
    std::string out;
    md5::md5_t h;

    h.process((const void*)data, (int)size);
    h.finish();
    out.resize(MD5_STRING_SIZE - 1);
    h.get_string(&out[0]);

    return out;
}

std::string md5::file_to_hashGC(const std::string &filePath)
{
    std::string out = file_to_hash(filePath);

    for(size_t i = 0; i < out.size(); ++i)
        out[i] = std::toupper(out[i]);

    return out;
}


================================================
FILE: lib/md5/md5tools.hpp
================================================
#include <string>
#include <cstdint>
#include "md5.h"

namespace md5
{
extern uint32_t    string_to_u32(const std::string &input);
extern std::string string_to_hash(const std::string &input);
extern std::string file_to_hash(const std::string &filePath);
extern std::string file_to_hashGC(const std::string &filePath);
extern std::string mem_to_hash(const void *data, size_t size);
}


================================================
FILE: lib/numeric_types.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XT_NUMERIC_TYPES_H
#define XT_NUMERIC_TYPES_H

#ifdef THEXTECH_FIXED_POINT
#   include "fixed_point.h"
#else
#	include "floating_point.h"
#endif

#endif // #ifndef XT_NUMERIC_TYPES_H


================================================
FILE: lib/pcg/LICENSE.txt
================================================
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "{}"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright {yyyy} {name of copyright owner}

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.


================================================
FILE: lib/pcg/README.md
================================================
# PCG Random Number Generation, C++ Edition

[PCG-Random website]: http://www.pcg-random.org

This code provides an implementation of the PCG family of random number
generators, which are fast, statistically excellent, and offer a number of
useful features.

Full details can be found at the [PCG-Random website].  This version
of the code provides many family members -- if you just want one
simple generator, you may prefer the minimal C version of the library.

There are two kinds of generator, normal generators and extended generators.
Extended generators provide *k* dimensional equidistribution and can perform
party tricks, but generally speaking most people only need the normal
generators.

There are two ways to access the generators, using a convenience typedef
or by using the underlying templates directly (similar to C++11's `std::mt19937` typedef vs its `std::mersenne_twister_engine` template).  For most users, the convenience typedef is what you want, and probably you're fine with `pcg32` for 32-bit numbers.  If you want 64-bit numbers, either use `pcg64` (or, if you're on a 32-bit system, making 64 bits from two calls to `pcg32_k2` may be faster).

## Documentation and Examples

Visit [PCG-Random website] for information on how to use this library, or look
at the sample code in the `sample` directory -- hopefully it should be fairly
self explanatory.

## Building

The code is written in C++11, as an include-only library (i.e., there is
nothing you need to build).  There are some provided demo programs and tests
however.  On a Unix-style system (e.g., Linux, Mac OS X) you should be able
to just type type

    make

To build the demo programs.

## Testing

Run

    make test

## Directory Structure

The directories are arranged as follows:

* `include` -- contains `pcg_random.hpp` and supporting include files
* `test-high` -- test code for the high-level API where the functions have
  shorter, less scary-looking names.
* `sample` -- sample code, some similar to the code in `test-high` but more 
  human readable, some other examples too


================================================
FILE: lib/pcg/pcg_extras.hpp
================================================
/*
 * PCG Random Number Generation for C++
 *
 * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For additional information about the PCG random number generation scheme,
 * including its license and other licensing options, visit
 *
 *     http://www.pcg-random.org
 */

/*
 * This file provides support code that is useful for random-number generation
 * but not specific to the PCG generation scheme, including:
 *      - 128-bit int support for platforms where it isn't available natively
 *      - bit twiddling operations
 *      - I/O of 128-bit and 8-bit integers
 *      - Handling the evilness of SeedSeq
 *      - Support for efficiently producing random numbers less than a given
 *        bound
 */

#ifndef PCG_EXTRAS_HPP_INCLUDED
#define PCG_EXTRAS_HPP_INCLUDED 1

#include <cinttypes>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <limits>
// #include <iostream>
#include <type_traits>
#include <utility>
// #include <locale>
#include <iterator>
#include <utility>

#ifdef __GNUC__
    #include <cxxabi.h>
#endif

/*
 * Abstractions for compiler-specific directives
 */

#ifdef __GNUC__
    #define PCG_NOINLINE __attribute__((noinline))
#else
    #define PCG_NOINLINE
#endif


namespace pcg_extras {

/*
 * We often need to represent a "number of bits".  When used normally, these
 * numbers are never greater than 128, so an unsigned char is plenty.
 * If you're using a nonstandard generator of a larger size, you can set
 * PCG_BITCOUNT_T to have it define it as a larger size.  (Some compilers
 * might produce faster code if you set it to an unsigned int.)
 */

#ifndef PCG_BITCOUNT_T
    typedef uint8_t bitcount_t;
#else
    typedef PCG_BITCOUNT_T bitcount_t;
#endif

/*
 * C++ requires us to be able to serialize RNG state by printing or reading
 * it from a stream.  Because we use 128-bit ints, we also need to be able
 * ot print them, so here is code to do so.
 *
 * This code provides enough functionality to print 128-bit ints in decimal
 * and zero-padded in hex.  It's not a full-featured implementation.
 */

/*
 * Likewise, if people use tiny rngs, we'll be serializing uint8_t.
 * If we just used the provided IO operators, they'd read/write chars,
 * not ints, so we need to define our own.  We *can* redefine this operator
 * here because we're in our own namespace.
 */

/* Unfortunately, the above functions don't get found in preference to the
 * built in ones, so we create some more specific overloads that will.
 * Ugh.
 */



/*
 * Useful bitwise operations.
 */

/*
 * XorShifts are invertable, but they are someting of a pain to invert.
 * This function backs them out.  It's used by the whacky "inside out"
 * generator defined later.
 */

template <typename itype>
inline itype unxorshift(itype x, bitcount_t bits, bitcount_t shift)
{
    if (2*shift >= bits) {
        return x ^ (x >> shift);
    }
    itype lowmask1 = (itype(1U) << (bits - shift*2)) - 1;
    itype highmask1 = ~lowmask1;
    itype top1 = x;
    itype bottom1 = x & lowmask1;
    top1 ^= top1 >> shift;
    top1 &= highmask1;
    x = top1 | bottom1;
    itype lowmask2 = (itype(1U) << (bits - shift)) - 1;
    itype bottom2 = x & lowmask2;
    bottom2 = unxorshift(bottom2, bits - shift, shift);
    bottom2 &= lowmask1;
    return top1 | bottom2;
}

/*
 * Rotate left and right.
 *
 * In ideal world, compilers would spot idiomatic rotate code and convert it
 * to a rotate instruction.  Of course, opinions vary on what the correct
 * idiom is and how to spot it.  For clang, sometimes it generates better
 * (but still crappy) code if you define PCG_USE_ZEROCHECK_ROTATE_IDIOM.
 */

template <typename itype>
inline itype rotl(itype value, bitcount_t rot)
{
    constexpr bitcount_t bits = sizeof(itype) * 8;
    constexpr bitcount_t mask = bits - 1;
#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
    return rot ? (value << rot) | (value >> (bits - rot)) : value;
#else
    return (value << rot) | (value >> ((- rot) & mask));
#endif
}

template <typename itype>
inline itype rotr(itype value, bitcount_t rot)
{
    constexpr bitcount_t bits = sizeof(itype) * 8;
    constexpr bitcount_t mask = bits - 1;
#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
    return rot ? (value >> rot) | (value << (bits - rot)) : value;
#else
    return (value >> rot) | (value << ((- rot) & mask));
#endif
}

/* Unfortunately, both Clang and GCC sometimes perform poorly when it comes
 * to properly recognizing idiomatic rotate code, so for we also provide
 * assembler directives (enabled with PCG_USE_INLINE_ASM).  Boo, hiss.
 * (I hope that these compilers get better so that this code can die.)
 *
 * These overloads will be preferred over the general template code above.
 */
#if PCG_USE_INLINE_ASM && __GNUC__ && (__x86_64__  || __i386__)

inline uint8_t rotr(uint8_t value, bitcount_t rot)
{
    asm ("rorb   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
    return value;
}

inline uint16_t rotr(uint16_t value, bitcount_t rot)
{
    asm ("rorw   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
    return value;
}

inline uint32_t rotr(uint32_t value, bitcount_t rot)
{
    asm ("rorl   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
    return value;
}

#if __x86_64__
inline uint64_t rotr(uint64_t value, bitcount_t rot)
{
    asm ("rorq   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
    return value;
}
#endif // __x86_64__

#endif // PCG_USE_INLINE_ASM


/*
 * The C++ SeedSeq concept (modelled by seed_seq) can fill an array of
 * 32-bit integers with seed data, but sometimes we want to produce
 * larger or smaller integers.
 *
 * The following code handles this annoyance.
 *
 * uneven_copy will copy an array of 32-bit ints to an array of larger or
 * smaller ints (actually, the code is general it only needing forward
 * iterators).  The copy is identical to the one that would be performed if
 * we just did memcpy on a standard little-endian machine, but works
 * regardless of the endian of the machine (or the weirdness of the ints
 * involved).
 *
 * generate_to initializes an array of integers using a SeedSeq
 * object.  It is given the size as a static constant at compile time and
 * tries to avoid memory allocation.  If we're filling in 32-bit constants
 * we just do it directly.  If we need a separate buffer and it's small,
 * we allocate it on the stack.  Otherwise, we fall back to heap allocation.
 * Ugh.
 *
 * generate_one produces a single value of some integral type using a
 * SeedSeq object.
 */

 /* uneven_copy helper, case where destination ints are less than 32 bit. */

template<class SrcIter, class DestIter>
SrcIter uneven_copy_impl(
    SrcIter src_first, DestIter dest_first, DestIter dest_last,
    std::true_type)
{
    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
    typedef typename std::iterator_traits<DestIter>::value_type dest_t;

    constexpr bitcount_t SRC_SIZE  = sizeof(src_t);
    constexpr bitcount_t DEST_SIZE = sizeof(dest_t);
    constexpr bitcount_t DEST_BITS = DEST_SIZE * 8;
    constexpr bitcount_t SCALE     = SRC_SIZE / DEST_SIZE;

    size_t count = 0;
    src_t value;

    while (dest_first != dest_last) {
        if ((count++ % SCALE) == 0)
            value = *src_first++;       // Get more bits
        else
            value >>= DEST_BITS;        // Move down bits

        *dest_first++ = dest_t(value);  // Truncates, ignores high bits.
    }
    return src_first;
}

 /* uneven_copy helper, case where destination ints are more than 32 bit. */

template<class SrcIter, class DestIter>
SrcIter uneven_copy_impl(
    SrcIter src_first, DestIter dest_first, DestIter dest_last,
    std::false_type)
{
    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
    typedef typename std::iterator_traits<DestIter>::value_type dest_t;

    constexpr auto SRC_SIZE  = sizeof(src_t);
    constexpr auto SRC_BITS  = SRC_SIZE * 8;
    constexpr auto DEST_SIZE = sizeof(dest_t);
    constexpr auto SCALE     = (DEST_SIZE+SRC_SIZE-1) / SRC_SIZE;

    while (dest_first != dest_last) {
        dest_t value(0UL);
        unsigned int shift = 0;

        for (size_t i = 0; i < SCALE; ++i) {
            value |= dest_t(*src_first++) << shift;
            shift += SRC_BITS;
        }

        *dest_first++ = value;
    }
    return src_first;
}

/* uneven_copy, call the right code for larger vs. smaller */

template<class SrcIter, class DestIter>
inline SrcIter uneven_copy(SrcIter src_first,
                           DestIter dest_first, DestIter dest_last)
{
    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
    typedef typename std::iterator_traits<DestIter>::value_type dest_t;

    constexpr bool DEST_IS_SMALLER = sizeof(dest_t) < sizeof(src_t);

    return uneven_copy_impl(src_first, dest_first, dest_last,
                            std::integral_constant<bool, DEST_IS_SMALLER>{});
}

/* generate_to, fill in a fixed-size array of integral type using a SeedSeq
 * (actually works for any random-access iterator)
 */

template <size_t size, typename SeedSeq, typename DestIter>
inline void generate_to_impl(SeedSeq&& generator, DestIter dest,
                             std::true_type)
{
    generator.generate(dest, dest+size);
}

template <size_t size, typename SeedSeq, typename DestIter>
void generate_to_impl(SeedSeq&& generator, DestIter dest,
                      std::false_type)
{
    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
    constexpr auto DEST_SIZE = sizeof(dest_t);
    constexpr auto GEN_SIZE  = sizeof(uint32_t);

    constexpr bool GEN_IS_SMALLER = GEN_SIZE < DEST_SIZE;
    constexpr size_t FROM_ELEMS =
        GEN_IS_SMALLER
            ? size * ((DEST_SIZE+GEN_SIZE-1) / GEN_SIZE)
            : (size + (GEN_SIZE / DEST_SIZE) - 1)
                / ((GEN_SIZE / DEST_SIZE) + GEN_IS_SMALLER);
                        //  this odd code ^^^^^^^^^^^^^^^^^ is work-around for
                        //  a bug: http://llvm.org/bugs/show_bug.cgi?id=21287

    if (FROM_ELEMS <= 1024) {
        uint32_t buffer[FROM_ELEMS];
        generator.generate(buffer, buffer+FROM_ELEMS);
        uneven_copy(buffer, dest, dest+size);
    } else {
        uint32_t* buffer = (uint32_t*) malloc(GEN_SIZE * FROM_ELEMS);
        generator.generate(buffer, buffer+FROM_ELEMS);
        uneven_copy(buffer, dest, dest+size);
        free(buffer);
    }
}

template <size_t size, typename SeedSeq, typename DestIter>
inline void generate_to(SeedSeq&& generator, DestIter dest)
{
    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
    constexpr bool IS_32BIT = sizeof(dest_t) == sizeof(uint32_t);

    generate_to_impl<size>(std::forward<SeedSeq>(generator), dest,
                           std::integral_constant<bool, IS_32BIT>{});
}

/* generate_one, produce a value of integral type using a SeedSeq
 * (optionally, we can have it produce more than one and pick which one
 * we want)
 */

template <typename UInt, size_t i = 0UL, size_t N = i+1UL, typename SeedSeq>
inline UInt generate_one(SeedSeq&& generator)
{
    UInt result[N];
    generate_to<N>(std::forward<SeedSeq>(generator), result);
    return result[i];
}

template <typename RngType>
auto bounded_rand(RngType& rng, typename RngType::result_type upper_bound)
        -> typename RngType::result_type
{
    typedef typename RngType::result_type rtype;
    rtype threshold = (RngType::max() - RngType::min() + rtype(1) - upper_bound)
                    % upper_bound;
    for (;;) {
        rtype r = rng() - RngType::min();
        if (r >= threshold)
            return r % upper_bound;
    }
}

template <typename Iter, typename RandType>
void shuffle(Iter from, Iter to, RandType&& rng)
{
    typedef typename std::iterator_traits<Iter>::difference_type delta_t;
    auto count = to - from;
    while (count > 1) {
        delta_t chosen(bounded_rand(rng, count));
        --count;
        --to;
        using std::swap;
        swap(*(from+chosen), *to);
    }
}

/*
 * Although std::seed_seq is useful, it isn't everything.  Often we want to
 * initialize a random-number generator some other way, such as from a random
 * device.
 *
 * Technically, it does not meet the requirements of a SeedSequence because
 * it lacks some of the rarely-used member functions (some of which would
 * be impossible to provide).  However the C++ standard is quite specific
 * that actual engines only called the generate method, so it ought not to be
 * a problem in practice.
 */

template <typename RngType>
class seed_seq_from {
private:
    RngType rng_;

    typedef uint_least32_t result_type;

public:
    template<typename... Args>
    seed_seq_from(Args&&... args) :
        rng_(std::forward<Args>(args)...)
    {
        // Nothing (else) to do...
    }

    template<typename Iter>
    void generate(Iter start, Iter finish)
    {
        for (auto i = start; i != finish; ++i)
            *i = result_type(rng_());
    }

    constexpr size_t size() const
    {
        return (sizeof(typename RngType::result_type) > sizeof(result_type)
                && RngType::max() > ~size_t(0UL))
             ? ~size_t(0UL)
             : size_t(RngType::max());
    }
};

/*
 * Sometimes you might want a distinct seed based on when the program
 * was compiled.  That way, a particular instance of the program will
 * behave the same way, but when recompiled it'll produce a different
 * value.
 */

template <typename IntType>
struct static_arbitrary_seed {
private:
    static constexpr IntType fnv(IntType hash, const char* pos) {
        return *pos == '\0'
             ? hash
             : fnv((hash * IntType(16777619U)) ^ *pos, (pos+1));
    }

public:
    static constexpr IntType value = fnv(IntType(2166136261U ^ sizeof(IntType)),
                        __DATE__ __TIME__ __FILE__);
};

// Sometimes, when debugging or testing, it's handy to be able print the name
// of a (in human-readable form).  This code allows the idiom:
//
//      cout << printable_typename<my_foo_type_t>()
//
// to print out my_foo_type_t (or its concrete type if it is a synonym)

template <typename T>
struct printable_typename {};

} // namespace pcg_extras

#endif // PCG_EXTRAS_HPP_INCLUDED


================================================
FILE: lib/pcg/pcg_random.hpp
================================================
// Modified 2021 by ds-sloth, only to reduce the number of definitions to those needed for our use case.

/*
 * PCG Random Number Generation for C++
 *
 * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For additional information about the PCG random number generation scheme,
 * including its license and other licensing options, visit
 *
 *     http://www.pcg-random.org
 */

/*
 * This code provides the reference implementation of the PCG family of
 * random number generators.  The code is complex because it implements
 *
 *      - several members of the PCG family, specifically members corresponding
 *        to the output functions:
 *             - XSH RR         (good for 64-bit state, 32-bit output)
 *             - XSH RS         (good for 64-bit state, 32-bit output)
 *             - XSL RR         (good for 128-bit state, 64-bit output)
 *             - RXS M XS       (statistically most powerful generator)
 *             - XSL RR RR      (good for 128-bit state, 128-bit output)
 *             - and RXS, RXS M, XSH, XSL       (mostly for testing)
 *      - at potentially *arbitrary* bit sizes
 *      - with four different techniques for random streams (MCG, one-stream
 *        LCG, settable-stream LCG, unique-stream LCG)
 *      - and the extended generation schemes allowing arbitrary periods
 *      - with all features of C++11 random number generation (and more),
 *        some of which are somewhat painful, including
 *            - initializing with a SeedSequence which writes 32-bit values
 *              to memory, even though the state of the generator may not
 *              use 32-bit values (it might use smaller or larger integers)
 *            - I/O for RNGs and a prescribed format, which needs to handle
 *              the issue that 8-bit and 128-bit integers don't have working
 *              I/O routines (e.g., normally 8-bit = char, not integer)
 *            - equality and inequality for RNGs
 *      - and a number of convenience typedefs to mask all the complexity
 *
 * The code employes a fairly heavy level of abstraction, and has to deal
 * with various C++ minutia.  If you're looking to learn about how the PCG
 * scheme works, you're probably best of starting with one of the other
 * codebases (see www.pcg-random.org).  But if you're curious about the
 * constants for the various output functions used in those other, simpler,
 * codebases, this code shows how they are calculated.
 *
 * On the positive side, at least there are convenience typedefs so that you
 * can say
 *
 *      pcg32 myRNG;
 *
 * rather than:
 *
 *      pcg_detail::engine<
 *          uint32_t,                                           // Output Type
 *          uint64_t,                                           // State Type
 *          pcg_detail::xsh_rr_mixin<uint32_t, uint64_t>, true, // Output Func
 *          pcg_detail::specific_stream<uint64_t>,              // Stream Kind
 *          pcg_detail::default_multiplier<uint64_t>            // LCG Mult
 *      > myRNG;
 *
 */

#ifndef PCG_RAND_HPP_INCLUDED
#define PCG_RAND_HPP_INCLUDED 1

#include <cinttypes>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <limits>
// #include <iostream>
#include <type_traits>
#include <utility>
// #include <locale>
#include <new>
#include <stdexcept>

/*
 * The pcg_extras namespace contains some support code that is likley to
 * be useful for a variety of RNGs, including:
 *      - 128-bit int support for platforms where it isn't available natively
 *      - bit twiddling operations
 *      - I/O of 128-bit and 8-bit integers
 *      - Handling the evilness of SeedSeq
 *      - Support for efficiently producing random numbers less than a given
 *        bound
 */

#include "pcg_extras.hpp"

namespace pcg_detail {

using namespace pcg_extras;

/*
 * The LCG generators need some constants to function.  This code lets you
 * look up the constant by *type*.  For example
 *
 *      default_multiplier<uint32_t>::multiplier()
 *
 * gives you the default multipler for 32-bit integers.  We use the name
 * of the constant and not a generic word like value to allow these classes
 * to be used as mixins.
 */

template <typename T>
struct default_multiplier {
    // Not defined for an arbitrary type
};

template <typename T>
struct default_increment {
    // Not defined for an arbitrary type
};

#define PCG_DEFINE_CONSTANT(type, what, kind, constant) \
        template <>                                     \
        struct what ## _ ## kind<type> {                \
            static constexpr type kind() {              \
                return constant;                        \
            }                                           \
        };

PCG_DEFINE_CONSTANT(uint8_t,  default, multiplier, 141U)
PCG_DEFINE_CONSTANT(uint8_t,  default, increment,  77U)

PCG_DEFINE_CONSTANT(uint16_t, default, multiplier, 12829U)
PCG_DEFINE_CONSTANT(uint16_t, default, increment,  47989U)

PCG_DEFINE_CONSTANT(uint32_t, default, multiplier, 747796405U)
PCG_DEFINE_CONSTANT(uint32_t, default, increment,  2891336453U)

PCG_DEFINE_CONSTANT(uint64_t, default, multiplier, 6364136223846793005ULL)
PCG_DEFINE_CONSTANT(uint64_t, default, increment,  1442695040888963407ULL)

#ifdef PCG_HAS_ALWAYS_INLINE
#define PCG_ALWAYS_INLINE __attribute__((always_inline))
#else
#define PCG_ALWAYS_INLINE inline
#endif



/*
 * Each PCG generator is available in four variants, based on how it applies
 * the additive constant for its underlying LCG; the variations are:
 *
 *     single stream   - all instances use the same fixed constant, thus
 *                       the RNG always somewhere in same sequence
 *     mcg             - adds zero, resulting in a single stream and reduced
 *                       period
 *     specific stream - the constant can be changed at any time, selecting
 *                       a different random sequence
 *     unique stream   - the constant is based on the memory addresss of the
 *                       object, thus every RNG has its own unique sequence
 *
 * This variation is provided though mixin classes which define a function
 * value called increment() that returns the nesessary additive constant.
 */



/*
 * unique stream
 */


template <typename itype>
class unique_stream {
protected:
    static constexpr bool is_mcg = false;

    // Is never called, but is provided for symmetry with specific_stream
    void set_stream(...)
    {
        abort();
    }

public:
    typedef itype state_type;

    constexpr itype increment() const {
        return itype(reinterpret_cast<unsigned long>(this) | 1);
    }

    constexpr itype stream() const
    {
         return increment() >> 1;
    }

    static constexpr bool can_specify_stream = false;

    static constexpr size_t streams_pow2()
    {
        return (sizeof(itype) < sizeof(size_t) ? sizeof(itype)
                                               : sizeof(size_t))*8 - 1u;
    }

protected:
    constexpr unique_stream() = default;
};


/*
 * no stream (mcg)
 */

template <typename itype>
class no_stream {
protected:
    static constexpr bool is_mcg = true;

    // Is never called, but is provided for symmetry with specific_stream
    void set_stream(...)
    {
        abort();
    }

public:
    typedef itype state_type;

    static constexpr itype increment() {
        return 0;
    }

    static constexpr bool can_specify_stream = false;

    static constexpr size_t streams_pow2()
    {
        return 0u;
    }

protected:
    constexpr no_stream() = default;
};


/*
 * single stream/sequence (oneseq)
 */

template <typename itype>
class oneseq_stream : public default_increment<itype> {
protected:
    static constexpr bool is_mcg = false;

    // Is never called, but is provided for symmetry with specific_stream
    void set_stream(...)
    {
        abort();
    }

public:
    typedef itype state_type;

    static constexpr itype stream()
    {
         return default_increment<itype>::increment() >> 1;
    }

    static constexpr bool can_specify_stream = false;

    static constexpr size_t streams_pow2()
    {
        return 0u;
    }

protected:
    constexpr oneseq_stream() = default;
};


/*
 * specific stream
 */

template <typename itype>
class specific_stream {
protected:
    static constexpr bool is_mcg = false;

    itype inc_ = default_increment<itype>::increment();

public:
    typedef itype state_type;
    typedef itype stream_state;

    constexpr itype increment() const {
        return inc_;
    }

    itype stream()
    {
         return inc_ >> 1;
    }

    void set_stream(itype specific_seq)
    {
         inc_ = (specific_seq << 1) | 1;
    }

    static constexpr bool can_specify_stream = true;

    static constexpr size_t streams_pow2()
    {
        return (sizeof(itype)*8) - 1u;
    }

protected:
    specific_stream() = default;

    specific_stream(itype specific_seq)
        : inc_((specific_seq << 1) | itype(1U))
    {
        // Nothing (else) to do.
    }
};


/*
 * This is where it all comes together.  This function joins together three
 * mixin classes which define
 *    - the LCG additive constant (the stream)
 *    - the LCG multiplier
 *    - the output function
 * in addition, we specify the type of the LCG state, and the result type,
 * and whether to use the pre-advance version of the state for the output
 * (increasing instruction-level parallelism) or the post-advance version
 * (reducing register pressure).
 *
 * Given the high level of parameterization, the code has to use some
 * template-metaprogramming tricks to handle some of the suble variations
 * involved.
 */

template <typename xtype, typename itype,
          typename output_mixin,
          bool output_previous = true,
          typename stream_mixin = oneseq_stream<itype>,
          typename multiplier_mixin = default_multiplier<itype> >
class engine : protected output_mixin,
               public stream_mixin,
               protected multiplier_mixin {
protected:
    itype state_;

    struct can_specify_stream_tag {};
    struct no_specifiable_stream_tag {};

    using stream_mixin::increment;
    using multiplier_mixin::multiplier;

public:
    typedef xtype result_type;
    typedef itype state_type;

    static constexpr size_t period_pow2()
    {
        return sizeof(state_type)*8 - 2*stream_mixin::is_mcg;
    }

    // It would be nice to use std::numeric_limits for these, but
    // we can't be sure that it'd be defined for the 128-bit types.

    static constexpr result_type min()
    {
        return result_type(0UL);
    }

    static constexpr result_type max()
    {
        return ~result_type(0UL);
    }

protected:
    itype bump(itype state)
    {
        return state * multiplier() + increment();
    }

    itype base_generate()
    {
        return state_ = bump(state_);
    }

    itype base_generate0()
    {
        itype old_state = state_;
        state_ = bump(state_);
        return old_state;
    }

public:
    result_type operator()()
    {
        if (output_previous)
            return this->output(base_generate0());
        else
            return this->output(base_generate());
    }

    result_type operator()(result_type upper_bound)
    {
        return bounded_rand(*this, upper_bound);
    }

protected:
    static itype advance(itype state, itype delta,
                         itype cur_mult, itype cur_plus);

    static itype distance(itype cur_state, itype newstate, itype cur_mult,
                          itype cur_plus, itype mask = ~itype(0U));

    itype distance(itype newstate, itype mask = ~itype(0U)) const
    {
        return distance(state_, newstate, multiplier(), increment(), mask);
    }

public:
    void advance(itype delta)
    {
        state_ = advance(state_, delta, this->multiplier(), this->increment());
    }

    void backstep(itype delta)
    {
        advance(-delta);
    }

    void discard(itype delta)
    {
        advance(delta);
    }

    bool wrapped()
    {
        if (stream_mixin::is_mcg) {
            // For MCGs, the low order two bits never change. In this
            // implementation, we keep them fixed at 3 to make this test
            // easier.
            return state_ == 3;
        } else {
            return state_ == 0;
        }
    }

    engine(itype state = itype(0xcafef00dd15ea5e5ULL))
        : state_(this->is_mcg ? state|state_type(3U)
                              : bump(state + this->increment()))
    {
        // Nothing else to do.
    }

    // This function may or may not exist.  It thus has to be a template
    // to use SFINAE; users don't have to worry about its template-ness.

    template <typename sm = stream_mixin>
    engine(itype state, typename sm::stream_state stream_seed)
        : stream_mixin(stream_seed),
          state_(this->is_mcg ? state|state_type(3U)
                              : bump(state + this->increment()))
    {
        // Nothing else to do.
    }

    template<typename SeedSeq>
    engine(SeedSeq&& seedSeq, typename std::enable_if<
                  !stream_mixin::can_specify_stream
               && !std::is_convertible<SeedSeq, itype>::value
               && !std::is_convertible<SeedSeq, engine>::value,
               no_specifiable_stream_tag>::type = {})
        : engine(generate_one<itype>(std::forward<SeedSeq>(seedSeq)))
    {
        // Nothing else to do.
    }

    template<typename SeedSeq>
    engine(SeedSeq&& seedSeq, typename std::enable_if<
                   stream_mixin::can_specify_stream
               && !std::is_convertible<SeedSeq, itype>::value
               && !std::is_convertible<SeedSeq, engine>::value,
        can_specify_stream_tag>::type = {})
        : engine(generate_one<itype,1,2>(seedSeq),
                 generate_one<itype,0,2>(seedSeq))
    {
        // Nothing else to do.
    }


    template<typename... Args>
    void seed(Args&&... args)
    {
        new (this) engine(std::forward<Args>(args)...);
    }

    template <typename xtype1, typename itype1,
              typename output_mixin1, bool output_previous1,
              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
    friend bool operator==(const engine<xtype1,itype1,
                                     output_mixin1,output_previous1,
                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
                           const engine<xtype1,itype1,
                                     output_mixin1,output_previous1,
                                     stream_mixin_rhs, multiplier_mixin_rhs>&);

    template <typename xtype1, typename itype1,
              typename output_mixin1, bool output_previous1,
              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
    friend itype1 operator-(const engine<xtype1,itype1,
                                     output_mixin1,output_previous1,
                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
                            const engine<xtype1,itype1,
                                     output_mixin1,output_previous1,
                                     stream_mixin_rhs, multiplier_mixin_rhs>&);
};

template <typename xtype, typename itype,
          typename output_mixin, bool output_previous,
          typename stream_mixin, typename multiplier_mixin>
itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
             multiplier_mixin>::advance(
    itype state, itype delta, itype cur_mult, itype cur_plus)
{
    // The method used here is based on Brown, "Random Number Generation
    // with Arbitrary Stride,", Transactions of the American Nuclear
    // Society (Nov. 1994).  The algorithm is very similar to fast
    // exponentiation.
    //
    // Even though delta is an unsigned integer, we can pass a
    // signed integer to go backwards, it just goes "the long way round".

    constexpr itype ZERO = 0u;  // itype may be a non-trivial types, so
    constexpr itype ONE  = 1u;  // we define some ugly constants.
    itype acc_mult = 1;
    itype acc_plus = 0;
    while (delta > ZERO) {
       if (delta & ONE) {
          acc_mult *= cur_mult;
          acc_plus = acc_plus*cur_mult + cur_plus;
       }
       cur_plus = (cur_mult+ONE)*cur_plus;
       cur_mult *= cur_mult;
       delta >>= 1;
    }
    return acc_mult * state + acc_plus;
}

template <typename xtype, typename itype,
          typename output_mixin, bool output_previous,
          typename stream_mixin, typename multiplier_mixin>
itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
               multiplier_mixin>::distance(
    itype cur_state, itype newstate, itype cur_mult, itype cur_plus, itype mask)
{
    constexpr itype ONE  = 1u;  // itype could be weird, so use constant
    itype the_bit = stream_mixin::is_mcg ? itype(4u) : itype(1u);
    itype distance = 0u;
    while ((cur_state & mask) != (newstate & mask)) {
       if ((cur_state & the_bit) != (newstate & the_bit)) {
           cur_state = cur_state * cur_mult + cur_plus;
           distance |= the_bit;
       }
       assert((cur_state & the_bit) == (newstate & the_bit));
       the_bit <<= 1;
       cur_plus = (cur_mult+ONE)*cur_plus;
       cur_mult *= cur_mult;
    }
    return stream_mixin::is_mcg ? distance >> 2 : distance;
}

template <typename xtype, typename itype,
          typename output_mixin, bool output_previous,
          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
itype operator-(const engine<xtype,itype,
                               output_mixin,output_previous,
                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
               const engine<xtype,itype,
                               output_mixin,output_previous,
                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
{
    if (lhs.multiplier() != rhs.multiplier()
        || lhs.increment() != rhs.increment())
        throw std::logic_error("incomparable generators");
    return rhs.distance(lhs.state_);
}


template <typename xtype, typename itype,
          typename output_mixin, bool output_previous,
          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
bool operator==(const engine<xtype,itype,
                               output_mixin,output_previous,
                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
                const engine<xtype,itype,
                               output_mixin,output_previous,
                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
{
    return    (lhs.multiplier() == rhs.multiplier())
           && (lhs.increment()  == rhs.increment())
           && (lhs.state_       == rhs.state_);
}

template <typename xtype, typename itype,
          typename output_mixin, bool output_previous,
          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
inline bool operator!=(const engine<xtype,itype,
                               output_mixin,output_previous,
                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
                       const engine<xtype,itype,
                               output_mixin,output_previous,
                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
{
    return !operator==(lhs,rhs);
}


template <typename xtype, typename itype,
         template<typename XT,typename IT> class output_mixin,
         bool output_previous = (sizeof(itype) <= 8)>
using oneseq_base  = engine<xtype, itype,
                        output_mixin<xtype, itype>, output_previous,
                        oneseq_stream<itype> >;

template <typename xtype, typename itype,
         template<typename XT,typename IT> class output_mixin,
         bool output_previous = (sizeof(itype) <= 8)>
using unique_base = engine<xtype, itype,
                         output_mixin<xtype, itype>, output_previous,
                         unique_stream<itype> >;

template <typename xtype, typename itype,
         template<typename XT,typename IT> class output_mixin,
         bool output_previous = (sizeof(itype) <= 8)>
using setseq_base = engine<xtype, itype,
                         output_mixin<xtype, itype>, output_previous,
                         specific_stream<itype> >;

template <typename xtype, typename itype,
         template<typename XT,typename IT> class output_mixin,
         bool output_previous = (sizeof(itype) <= 8)>
using mcg_base = engine<xtype, itype,
                      output_mixin<xtype, itype>, output_previous,
                      no_stream<itype> >;

/*
 * OUTPUT FUNCTIONS.
 *
 * These are the core of the PCG generation scheme.  They specify how to
 * turn the base LCG's internal state into the output value of the final
 * generator.
 *
 * They're implemented as mixin classes.
 *
 * All of the classes have code that is written to allow it to be applied
 * at *arbitrary* bit sizes, although in practice they'll only be used at
 * standard sizes supported by C++.
 */

/*
 * XSH RS -- high xorshift, followed by a random shift
 *
 * Fast.  A good performer.
 */

template <typename xtype, typename itype>
struct xsh_rs_mixin {
    static xtype output(itype internal)
    {
        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype) * 8);
        constexpr bitcount_t sparebits   = bits - xtypebits;
        constexpr bitcount_t opbits =
                              sparebits-5 >= 64 ? 5
                            : sparebits-4 >= 32 ? 4
                            : sparebits-3 >= 16 ? 3
                            : sparebits-2 >= 4  ? 2
                            : sparebits-1 >= 1  ? 1
                            :                     0;
        constexpr bitcount_t mask = (1 << opbits) - 1;
        constexpr bitcount_t maxrandshift  = mask;
        constexpr bitcount_t topspare     = opbits;
        constexpr bitcount_t bottomspare = sparebits - topspare;
        constexpr bitcount_t xshift     = topspare + (xtypebits+maxrandshift)/2;
        bitcount_t rshift =
            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
        internal ^= internal >> xshift;
        xtype result = xtype(internal >> (bottomspare - maxrandshift + rshift));
        return result;
    }
};

/*
 * XSH RR -- high xorshift, followed by a random rotate
 *
 * Fast.  A good performer.  Slightly better statistically than XSH RS.
 */

template <typename xtype, typename itype>
struct xsh_rr_mixin {
    static xtype output(itype internal)
    {
        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
        constexpr bitcount_t sparebits   = bits - xtypebits;
        constexpr bitcount_t wantedopbits =
                              xtypebits >= 128 ? 7
                            : xtypebits >=  64 ? 6
                            : xtypebits >=  32 ? 5
                            : xtypebits >=  16 ? 4
                            :                    3;
        constexpr bitcount_t opbits =
                              sparebits >= wantedopbits ? wantedopbits
                                                        : sparebits;
        constexpr bitcount_t amplifier = wantedopbits - opbits;
        constexpr bitcount_t mask = (1 << opbits) - 1;
        constexpr bitcount_t topspare    = opbits;
        constexpr bitcount_t bottomspare = sparebits - topspare;
        constexpr bitcount_t xshift      = (topspare + xtypebits)/2;
        bitcount_t rot = opbits ? bitcount_t(internal >> (bits - opbits)) & mask
                                : 0;
        bitcount_t amprot = (rot << amplifier) & mask;
        internal ^= internal >> xshift;
        xtype result = xtype(internal >> bottomspare);
        result = rotr(result, amprot);
        return result;
    }
};

/*
 * RXS -- random xorshift
 */

template <typename xtype, typename itype>
struct rxs_mixin {
static xtype output_rxs(itype internal)
    {
        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
        constexpr bitcount_t shift       = bits - xtypebits;
        constexpr bitcount_t extrashift  = (xtypebits - shift)/2;
        bitcount_t rshift = shift > 64+8 ? (internal >> (bits - 6)) & 63
                       : shift > 32+4 ? (internal >> (bits - 5)) & 31
                       : shift > 16+2 ? (internal >> (bits - 4)) & 15
                       : shift >  8+1 ? (internal >> (bits - 3)) & 7
                       : shift >  4+1 ? (internal >> (bits - 2)) & 3
                       : shift >  2+1 ? (internal >> (bits - 1)) & 1
                       :              0;
        internal ^= internal >> (shift + extrashift - rshift);
        xtype result = internal >> rshift;
        return result;
    }
};

/*
 * RXS M XS -- random xorshift, mcg multiply, fixed xorshift
 *
 * The most statistically powerful generator, but all those steps
 * make it slower than some of the others.  We give it the rottenest jobs.
 *
 * Because it's usually used in contexts where the state type and the
 * result type are the same, it is a permutation and is thus invertable.
 * We thus provide a function to invert it.  This function is used to
 * for the "inside out" generator used by the extended generator.
 */

/* Defined type-based concepts for the multiplication step.  They're actually
 * all derived by truncating the 128-bit, which was computed to be a good
 * "universal" constant.
 */

template <typename T>
struct mcg_multiplier {
    // Not defined for an arbitrary type
};

template <typename T>
struct mcg_unmultiplier {
    // Not defined for an arbitrary type
};

PCG_DEFINE_CONSTANT(uint8_t,  mcg, multiplier,   217U)
PCG_DEFINE_CONSTANT(uint8_t,  mcg, unmultiplier, 105U)

PCG_DEFINE_CONSTANT(uint16_t, mcg, multiplier,   62169U)
PCG_DEFINE_CONSTANT(uint16_t, mcg, unmultiplier, 28009U)

PCG_DEFINE_CONSTANT(uint32_t, mcg, multiplier,   277803737U)
PCG_DEFINE_CONSTANT(uint32_t, mcg, unmultiplier, 2897767785U)

PCG_DEFINE_CONSTANT(uint64_t, mcg, multiplier,   12605985483714917081ULL)
PCG_DEFINE_CONSTANT(uint64_t, mcg, unmultiplier, 15009553638781119849ULL)


template <typename xtype, typename itype>
struct rxs_m_xs_mixin {
    static xtype output(itype internal)
    {
        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
                                 : xtypebits >=  64 ? 5
                                 : xtypebits >=  32 ? 4
                                 : xtypebits >=  16 ? 3
                                 :                    2;
        constexpr bitcount_t shift = bits - xtypebits;
        constexpr bitcount_t mask = (1 << opbits) - 1;
        bitcount_t rshift =
            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
        internal ^= internal >> (opbits + rshift);
        internal *= mcg_multiplier<itype>::multiplier();
        xtype result = internal >> shift;
        result ^= result >> ((2U*xtypebits+2U)/3U);
        return result;
    }

    static itype unoutput(itype internal)
    {
        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t opbits = bits >= 128 ? 6
                                 : bits >=  64 ? 5
                                 : bits >=  32 ? 4
                                 : bits >=  16 ? 3
                                 :               2;
        constexpr bitcount_t mask = (1 << opbits) - 1;

        internal = unxorshift(internal, bits, (2U*bits+2U)/3U);

        internal *= mcg_unmultiplier<itype>::unmultiplier();

        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
        internal = unxorshift(internal, bits, opbits + rshift);

        return internal;
    }
};


/*
 * RXS M -- random xorshift, mcg multiply
 */

template <typename xtype, typename itype>
struct rxs_m_mixin {
    static xtype output(itype internal)
    {
        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
                                 : xtypebits >=  64 ? 5
                                 : xtypebits >=  32 ? 4
                                 : xtypebits >=  16 ? 3
                                 :                    2;
        constexpr bitcount_t shift = bits - xtypebits;
        constexpr bitcount_t mask = (1 << opbits) - 1;
        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
        internal ^= internal >> (opbits + rshift);
        internal *= mcg_multiplier<itype>::multiplier();
        xtype result = internal >> shift;
        return result;
    }
};

/*
 * XSL RR -- fixed xorshift (to low bits), random rotate
 *
 * Useful for 128-bit types that are split across two CPU registers.
 */

template <typename xtype, typename itype>
struct xsl_rr_mixin {
    static xtype output(itype internal)
    {
        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t sparebits = bits - xtypebits;
        constexpr bitcount_t wantedopbits = xtypebits >= 128 ? 7
                                       : xtypebits >=  64 ? 6
                                       : xtypebits >=  32 ? 5
                                       : xtypebits >=  16 ? 4
                                       :                    3;
        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
                                                             : sparebits;
        constexpr bitcount_t amplifier = wantedopbits - opbits;
        constexpr bitcount_t mask = (1 << opbits) - 1;
        constexpr bitcount_t topspare = sparebits;
        constexpr bitcount_t bottomspare = sparebits - topspare;
        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;

        bitcount_t rot =
            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
        bitcount_t amprot = (rot << amplifier) & mask;
        internal ^= internal >> xshift;
        xtype result = xtype(internal >> bottomspare);
        result = rotr(result, amprot);
        return result;
    }
};


/*
 * XSL RR RR -- fixed xorshift (to low bits), random rotate (both parts)
 *
 * Useful for 128-bit types that are split across two CPU registers.
 * If you really want an invertable 128-bit RNG, I guess this is the one.
 */

template <typename T> struct halfsize_trait {};
template <> struct halfsize_trait<uint64_t>  { typedef uint32_t type; };
template <> struct halfsize_trait<uint32_t>  { typedef uint16_t type; };
template <> struct halfsize_trait<uint16_t>  { typedef uint8_t type;  };

template <typename xtype, typename itype>
struct xsl_rr_rr_mixin {
    typedef typename halfsize_trait<itype>::type htype;

    static itype output(itype internal)
    {
        constexpr bitcount_t htypebits = bitcount_t(sizeof(htype) * 8);
        constexpr bitcount_t bits      = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t sparebits = bits - htypebits;
        constexpr bitcount_t wantedopbits = htypebits >= 128 ? 7
                                       : htypebits >=  64 ? 6
                                       : htypebits >=  32 ? 5
                                       : htypebits >=  16 ? 4
                                       :                    3;
        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
                                                                : sparebits;
        constexpr bitcount_t amplifier = wantedopbits - opbits;
        constexpr bitcount_t mask = (1 << opbits) - 1;
        constexpr bitcount_t topspare = sparebits;
        constexpr bitcount_t xshift = (topspare + htypebits) / 2;

        bitcount_t rot =
            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
        bitcount_t amprot = (rot << amplifier) & mask;
        internal ^= internal >> xshift;
        htype lowbits = htype(internal);
        lowbits = rotr(lowbits, amprot);
        htype highbits = htype(internal >> topspare);
        bitcount_t rot2 = lowbits & mask;
        bitcount_t amprot2 = (rot2 << amplifier) & mask;
        highbits = rotr(highbits, amprot2);
        return (itype(highbits) << topspare) ^ itype(lowbits);
    }
};


/*
 * XSH -- fixed xorshift (to high bits)
 *
 * You shouldn't use this at 64-bits or less.
 */

template <typename xtype, typename itype>
struct xsh_mixin {
    static xtype output(itype internal)
    {
        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t sparebits = bits - xtypebits;
        constexpr bitcount_t topspare = 0;
        constexpr bitcount_t bottomspare = sparebits - topspare;
        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;

        internal ^= internal >> xshift;
        xtype result = internal >> bottomspare;
        return result;
    }
};

/*
 * XSL -- fixed xorshift (to low bits)
 *
 * You shouldn't use this at 64-bits or less.
 */

template <typename xtype, typename itype>
struct xsl_mixin {
    inline xtype output(itype internal)
    {
        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
        constexpr bitcount_t sparebits = bits - xtypebits;
        constexpr bitcount_t topspare = sparebits;
        constexpr bitcount_t bottomspare = sparebits - topspare;
        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;

        internal ^= internal >> xshift;
        xtype result = internal >> bottomspare;
        return result;
    }
};

/* ---- End of Output Functions ---- */


template <typename baseclass>
struct inside_out : private baseclass {
    inside_out() = delete;

    typedef typename baseclass::result_type result_type;
    typedef typename baseclass::state_type  state_type;
    static_assert(sizeof(result_type) == sizeof(state_type),
                  "Require a RNG whose output function is a permutation");

    static bool external_step(result_type& randval, size_t i)
    {
        state_type state = baseclass::unoutput(randval);
        state = state * baseclass::multiplier() + baseclass::increment()
                + state_type(i*2);
        result_type result = baseclass::output(state);
        randval = result;
        state_type zero =
            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
        return result == zero;
    }

    static bool external_advance(result_type& randval, size_t i,
                                 result_type delta, bool forwards = true)
    {
        state_type state = baseclass::unoutput(randval);
        state_type mult  = baseclass::multiplier();
        state_type inc   = baseclass::increment() + state_type(i*2);
        state_type zero =
            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
        state_type dist_to_zero = baseclass::distance(state, zero, mult, inc);
        bool crosses_zero =
            forwards ? dist_to_zero <= delta
                     : (-dist_to_zero) <= delta;
        if (!forwards)
            delta = -delta;
        state = baseclass::advance(state, delta, mult, inc);
        randval = baseclass::output(state);
        return crosses_zero;
    }
};


template <bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass, typename extvalclass, bool kdd = true>
class extended : public baseclass {
public:
    typedef typename baseclass::state_type  state_type;
    typedef typename baseclass::result_type result_type;
    typedef inside_out<extvalclass> insideout;

private:
    static constexpr bitcount_t rtypebits = sizeof(result_type)*8;
    static constexpr bitcount_t stypebits = sizeof(state_type)*8;

    static constexpr bitcount_t tick_limit_pow2 = 64U;

    static constexpr size_t table_size  = 1UL << table_pow2;
    static constexpr size_t table_shift = stypebits - table_pow2;
    static constexpr state_type table_mask =
        (state_type(1U) << table_pow2) - state_type(1U);

    static constexpr bool   may_tick  =
        (advance_pow2 < stypebits) && (advance_pow2 < tick_limit_pow2);
    static constexpr size_t tick_shift = stypebits - advance_pow2;
    static constexpr state_type tick_mask  =
        may_tick ? state_type(
                       (uint64_t(1) << (advance_pow2*may_tick)) - 1)
                                        // ^-- stupidity to appease GCC warnings
                 : ~state_type(0U);

    static constexpr bool may_tock = stypebits < tick_limit_pow2;

    result_type data_[table_size];

    PCG_NOINLINE void advance_table();

    PCG_NOINLINE void advance_table(state_type delta, bool isForwards = true);

    result_type& get_extended_value()
    {
        state_type state = this->state_;
        if (kdd && baseclass::is_mcg) {
            // The low order bits of an MCG are constant, so drop them.
            state >>= 2;
        }
        size_t index       = kdd ? state &  table_mask
                                 : state >> table_shift;

        if (may_tick) {
            bool tick = kdd ? (state & tick_mask) == state_type(0u)
                            : (state >> tick_shift) == state_type(0u);
            if (tick)
                    advance_table();
        }
        if (may_tock) {
            bool tock = state == state_type(0u);
            if (tock)
                advance_table();
        }
        return data_[index];
    }

public:
    static constexpr size_t period_pow2()
    {
        return baseclass::period_pow2() + table_size*extvalclass::period_pow2();
    }

    PCG_ALWAYS_INLINE result_type operator()()
    {
        result_type rhs = get_extended_value();
        result_type lhs = this->baseclass::operator()();
        return lhs ^ rhs;
    }

    result_type operator()(result_type upper_bound)
    {
        return bounded_rand(*this, upper_bound);
    }

    void set(result_type wanted)
    {
        result_type& rhs = get_extended_value();
        result_type lhs = this->baseclass::operator()();
        rhs = lhs ^ wanted;
    }

    void advance(state_type distance, bool forwards = true);

    void backstep(state_type distance)
    {
        advance(distance, false);
    }

    extended(const result_type* data)
        : baseclass()
    {
        datainit(data);
    }

    extended(const result_type* data, state_type seed)
        : baseclass(seed)
    {
        datainit(data);
    }

    // This function may or may not exist.  It thus has to be a template
    // to use SFINAE; users don't have to worry about its template-ness.

    template <typename bc = baseclass>
    extended(const result_type* data, state_type seed,
            typename bc::stream_state stream_seed)
        : baseclass(seed, stream_seed)
    {
        datainit(data);
    }

    extended()
        : baseclass()
    {
        selfinit();
    }

    extended(state_type seed)
        : baseclass(seed)
    {
        selfinit();
    }

    // This function may or may not exist.  It thus has to be a template
    // to use SFINAE; users don't have to worry about its template-ness.

    template <typename bc = baseclass>
    extended(state_type seed, typename bc::stream_state stream_seed)
        : baseclass(seed, stream_seed)
    {
        selfinit();
    }

private:
    void selfinit();
    void datainit(const result_type* data);

public:

    template<typename SeedSeq, typename = typename std::enable_if<
           !std::is_convertible<SeedSeq, result_type>::value
        && !std::is_convertible<SeedSeq, extended>::value>::type>
    extended(SeedSeq&& seedSeq)
        : baseclass(seedSeq)
    {
        generate_to<table_size>(seedSeq, data_);
    }

    template<typename... Args>
    void seed(Args&&... args)
    {
        new (this) extended(std::forward<Args>(args)...);
    }

    template <bitcount_t table_pow2_, bitcount_t advance_pow2_,
              typename baseclass_, typename extvalclass_, bool kdd_>
    friend bool operator==(const extended<table_pow2_, advance_pow2_,
                                              baseclass_, extvalclass_, kdd_>&,
                           const extended<table_pow2_, advance_pow2_,
                                              baseclass_, extvalclass_, kdd_>&);


};


template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename baseclass, typename extvalclass, bool kdd>
void extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::datainit(
         const result_type* data)
{
    for (size_t i = 0; i < table_size; ++i)
        data_[i] = data[i];
}

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename baseclass, typename extvalclass, bool kdd>
void extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::selfinit()
{
    // We need to fill the extended table with something, and we have
    // very little provided data, so we use the base generator to
    // produce values.  Although not ideal (use a seed sequence, folks!),
    // unexpected correlations are mitigated by
    //      - using XOR differences rather than the number directly
    //      - the way the table is accessed, its values *won't* be accessed
    //        in the same order the were written.
    //      - any strange correlations would only be apparent if we
    //        were to backstep the generator so that the base generator
    //        was generating the same values again
    result_type xdiff = baseclass::operator()() - baseclass::operator()();
    for (size_t i = 0; i < table_size; ++i) {
        data_[i] = baseclass::operator()() ^ xdiff;
    }
}

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename baseclass, typename extvalclass, bool kdd>
bool operator==(const extended<table_pow2, advance_pow2,
                               baseclass, extvalclass, kdd>& lhs,
                const extended<table_pow2, advance_pow2,
                               baseclass, extvalclass, kdd>& rhs)
{
    auto& base_lhs = static_cast<const baseclass&>(lhs);
    auto& base_rhs = static_cast<const baseclass&>(rhs);
    return base_lhs == base_rhs
        && !memcmp((void*) lhs.data_, (void*) rhs.data_, sizeof(lhs.data_));
}

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename baseclass, typename extvalclass, bool kdd>
inline bool operator!=(const extended<table_pow2, advance_pow2,
                                      baseclass, extvalclass, kdd>& lhs,
                       const extended<table_pow2, advance_pow2,
                                      baseclass, extvalclass, kdd>& rhs)
{
    return lhs != rhs;
}

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename baseclass, typename extvalclass, bool kdd>
void
extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table()
{
    bool carry = false;
    for (size_t i = 0; i < table_size; ++i) {
        if (carry) {
            carry = insideout::external_step(data_[i],i+1);
        }
        bool carry2 = insideout::external_step(data_[i],i+1);
        carry = carry || carry2;
    }
}

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename baseclass, typename extvalclass, bool kdd>
void
extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table(
        state_type delta, bool isForwards)
{
    typedef typename baseclass::state_type   base_state_t;
    typedef typename extvalclass::state_type ext_state_t;
    constexpr bitcount_t basebits = sizeof(base_state_t)*8;
    constexpr bitcount_t extbits  = sizeof(ext_state_t)*8;
    static_assert(basebits <= extbits || advance_pow2 > 0,
                  "Current implementation might overflow its carry");

    base_state_t carry = 0;
    for (size_t i = 0; i < table_size; ++i) {
        base_state_t total_delta = carry + delta;
        ext_state_t  trunc_delta = ext_state_t(total_delta);
        if (basebits > extbits) {
            carry = total_delta >> extbits;
        } else {
            carry = 0;
        }
        carry +=
            insideout::external_advance(data_[i],i+1, trunc_delta, isForwards);
    }
}

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename baseclass, typename extvalclass, bool kdd>
void extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance(
    state_type distance, bool forwards)
{
    static_assert(kdd,
        "Efficient advance is too hard for non-kdd extension. "
        "For a weak advance, cast to base class");
    state_type zero =
        baseclass::is_mcg ? this->state_ & state_type(3U) : state_type(0U);
    if (may_tick) {
        state_type ticks = distance >> (advance_pow2*may_tick);
                                        // ^-- stupidity to appease GCC
                                        // warnings
        state_type adv_mask =
            baseclass::is_mcg ? tick_mask << 2 : tick_mask;
        state_type next_advance_distance = this->distance(zero, adv_mask);
        if (!forwards)
            next_advance_distance = (-next_advance_distance) & tick_mask;
        if (next_advance_distance < (distance & tick_mask)) {
            ++ticks;
        }
        if (ticks)
            advance_table(ticks, forwards);
    }
    if (forwards) {
        if (may_tock && this->distance(zero) <= distance)
            advance_table();
        baseclass::advance(distance);
    } else {
        if (may_tock && -(this->distance(zero)) <= distance)
            advance_table(state_type(1U), false);
        baseclass::advance(-distance);
    }
}

} // namespace pcg_detail

namespace pcg_engines {

using namespace pcg_detail;

/* Predefined types for XSH RS */

typedef oneseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  oneseq_xsh_rs_16_8;
typedef oneseq_base<uint16_t, uint32_t, xsh_rs_mixin>  oneseq_xsh_rs_32_16;
typedef oneseq_base<uint32_t, uint64_t, xsh_rs_mixin>  oneseq_xsh_rs_64_32;

typedef unique_base<uint8_t,  uint16_t, xsh_rs_mixin>  unique_xsh_rs_16_8;
typedef unique_base<uint16_t, uint32_t, xsh_rs_mixin>  unique_xsh_rs_32_16;
typedef unique_base<uint32_t, uint64_t, xsh_rs_mixin>  unique_xsh_rs_64_32;

typedef setseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  setseq_xsh_rs_16_8;
typedef setseq_base<uint16_t, uint32_t, xsh_rs_mixin>  setseq_xsh_rs_32_16;
typedef setseq_base<uint32_t, uint64_t, xsh_rs_mixin>  setseq_xsh_rs_64_32;

typedef mcg_base<uint8_t,  uint16_t, xsh_rs_mixin>  mcg_xsh_rs_16_8;
typedef mcg_base<uint16_t, uint32_t, xsh_rs_mixin>  mcg_xsh_rs_32_16;
typedef mcg_base<uint32_t, uint64_t, xsh_rs_mixin>  mcg_xsh_rs_64_32;

/* Predefined types for XSH RR */

typedef oneseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  oneseq_xsh_rr_16_8;
typedef oneseq_base<uint16_t, uint32_t, xsh_rr_mixin>  oneseq_xsh_rr_32_16;
typedef oneseq_base<uint32_t, uint64_t, xsh_rr_mixin>  oneseq_xsh_rr_64_32;

typedef unique_base<uint8_t,  uint16_t, xsh_rr_mixin>  unique_xsh_rr_16_8;
typedef unique_base<uint16_t, uint32_t, xsh_rr_mixin>  unique_xsh_rr_32_16;
typedef unique_base<uint32_t, uint64_t, xsh_rr_mixin>  unique_xsh_rr_64_32;

typedef setseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  setseq_xsh_rr_16_8;
typedef setseq_base<uint16_t, uint32_t, xsh_rr_mixin>  setseq_xsh_rr_32_16;
typedef setseq_base<uint32_t, uint64_t, xsh_rr_mixin>  setseq_xsh_rr_64_32;

typedef mcg_base<uint8_t,  uint16_t, xsh_rr_mixin>  mcg_xsh_rr_16_8;
typedef mcg_base<uint16_t, uint32_t, xsh_rr_mixin>  mcg_xsh_rr_32_16;
typedef mcg_base<uint32_t, uint64_t, xsh_rr_mixin>  mcg_xsh_rr_64_32;


/* Predefined types for RXS M XS */

typedef oneseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>   oneseq_rxs_m_xs_8_8;
typedef oneseq_base<uint16_t, uint16_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_16_16;
typedef oneseq_base<uint32_t, uint32_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_32_32;
typedef oneseq_base<uint64_t, uint64_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_64_64;

typedef unique_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  unique_rxs_m_xs_8_8;
typedef unique_base<uint16_t, uint16_t, rxs_m_xs_mixin> unique_rxs_m_xs_16_16;
typedef unique_base<uint32_t, uint32_t, rxs_m_xs_mixin> unique_rxs_m_xs_32_32;
typedef unique_base<uint64_t, uint64_t, rxs_m_xs_mixin> unique_rxs_m_xs_64_64;

typedef setseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  setseq_rxs_m_xs_8_8;
typedef setseq_base<uint16_t, uint16_t, rxs_m_xs_mixin> setseq_rxs_m_xs_16_16;
typedef setseq_base<uint32_t, uint32_t, rxs_m_xs_mixin> setseq_rxs_m_xs_32_32;
typedef setseq_base<uint64_t, uint64_t, rxs_m_xs_mixin> setseq_rxs_m_xs_64_64;

                // MCG versions don't make sense here, so aren't defined.

/* Predefined types for XSL RR (only defined for "large" types) */

typedef oneseq_base<uint32_t, uint64_t, xsl_rr_mixin>  oneseq_xsl_rr_64_32;

typedef unique_base<uint32_t, uint64_t, xsl_rr_mixin>  unique_xsl_rr_64_32;

typedef setseq_base<uint32_t, uint64_t, xsl_rr_mixin>  setseq_xsl_rr_64_32;

typedef mcg_base<uint32_t, uint64_t, xsl_rr_mixin>  mcg_xsl_rr_64_32;


/* Predefined types for XSL RR RR (only defined for "large" types) */

typedef oneseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
    oneseq_xsl_rr_rr_64_64;

typedef unique_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
    unique_xsl_rr_rr_64_64;

typedef setseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
    setseq_xsl_rr_rr_64_64;

                // MCG versions don't make sense here, so aren't defined.

/* Extended generators */

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename BaseRNG, bool kdd = true>
using ext_std8 = extended<table_pow2, advance_pow2, BaseRNG,
                          oneseq_rxs_m_xs_8_8, kdd>;

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename BaseRNG, bool kdd = true>
using ext_std16 = extended<table_pow2, advance_pow2, BaseRNG,
                           oneseq_rxs_m_xs_16_16, kdd>;

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename BaseRNG, bool kdd = true>
using ext_std32 = extended<table_pow2, advance_pow2, BaseRNG,
                           oneseq_rxs_m_xs_32_32, kdd>;

template <bitcount_t table_pow2, bitcount_t advance_pow2,
          typename BaseRNG, bool kdd = true>
using ext_std64 = extended<table_pow2, advance_pow2, BaseRNG,
                           oneseq_rxs_m_xs_64_64, kdd>;


template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using ext_oneseq_rxs_m_xs_32_32 =
          ext_std32<table_pow2, advance_pow2, oneseq_rxs_m_xs_32_32, kdd>;

template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using ext_mcg_xsh_rs_64_32 =
          ext_std32<table_pow2, advance_pow2, mcg_xsh_rs_64_32, kdd>;

template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using ext_oneseq_xsh_rs_64_32 =
          ext_std32<table_pow2, advance_pow2, oneseq_xsh_rs_64_32, kdd>;

template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
using ext_setseq_xsh_rr_64_32 =
          ext_std32<table_pow2, advance_pow2, setseq_xsh_rr_64_32, kdd>;

} // namespace pcg_engines

typedef pcg_engines::setseq_xsh_rr_64_32        pcg32;
typedef pcg_engines::oneseq_xsh_rr_64_32        pcg32_oneseq;
typedef pcg_engines::unique_xsh_rr_64_32        pcg32_unique;
typedef pcg_engines::mcg_xsh_rs_64_32           pcg32_fast;

typedef pcg_engines::setseq_rxs_m_xs_8_8        pcg8_once_insecure;
typedef pcg_engines::setseq_rxs_m_xs_16_16      pcg16_once_insecure;
typedef pcg_engines::setseq_rxs_m_xs_32_32      pcg32_once_insecure;
typedef pcg_engines::setseq_rxs_m_xs_64_64      pcg64_once_insecure;

typedef pcg_engines::oneseq_rxs_m_xs_8_8        pcg8_oneseq_once_insecure;
typedef pcg_engines::oneseq_rxs_m_xs_16_16      pcg16_oneseq_once_insecure;
typedef pcg_engines::oneseq_rxs_m_xs_32_32      pcg32_oneseq_once_insecure;
typedef pcg_engines::oneseq_rxs_m_xs_64_64      pcg64_oneseq_once_insecure;


// These two extended RNGs provide two-dimensionally equidistributed
// 32-bit generators.  pcg32_k2_fast occupies the same space as pcg64,
// and can be called twice to generate 64 bits, but does not required
// 128-bit math; on 32-bit systems, it's faster than pcg64 as well.

typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,true>     pcg32_k2;
typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,true>     pcg32_k2_fast;

// These eight extended RNGs have about as much state as arc4random
//
//  - the k variants are k-dimensionally equidistributed
//  - the c variants offer better crypographic security
//
// (just how good the cryptographic security is is an open question)

typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,true>     pcg32_k64;
typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,true>        pcg32_k64_oneseq;
typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,true>     pcg32_k64_fast;

typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,false>    pcg32_c64;
typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,false>    pcg32_c64_oneseq;
typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,false>       pcg32_c64_fast;

// These eight extended RNGs have more state than the Mersenne twister
//
//  - the k variants are k-dimensionally equidistributed
//  - the c variants offer better crypographic security
//
// (just how good the cryptographic security is is an open question)

typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,true>    pcg32_k1024;
typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,true>    pcg32_k1024_fast;

typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,false>   pcg32_c1024;
typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,false>   pcg32_c1024_fast;

// These generators have an insanely huge period (2^524352), and is suitable
// for silly party tricks, such as dumping out 64 KB ZIP files at an arbitrary
// point in the future.   [Actually, over the full period of the generator, it
// will produce every 64 KB ZIP file 2^64 times!]

typedef pcg_engines::ext_setseq_xsh_rr_64_32<14,16,true>    pcg32_k16384;
typedef pcg_engines::ext_oneseq_xsh_rs_64_32<14,32,true>    pcg32_k16384_fast;

#endif // PCG_RAND_HPP_INCLUDED


================================================
FILE: lib/pcg/pcg_uint128.hpp
================================================
/*
 * PCG Random Number Generation for C++
 *
 * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For additional information about the PCG random number generation scheme,
 * including its license and other licensing options, visit
 *
 *     http://www.pcg-random.org
 */

/*
 * This code provides a a C++ class that can provide 128-bit (or higher)
 * integers.  To produce 2K-bit integers, it uses two K-bit integers,
 * placed in a union that allowes the code to also see them as four K/2 bit
 * integers (and access them either directly name, or by index).
 *
 * It may seem like we're reinventing the wheel here, because several
 * libraries already exist that support large integers, but most existing
 * libraries provide a very generic multiprecision code, but here we're
 * operating at a fixed size.  Also, most other libraries are fairly
 * heavyweight.  So we use a direct implementation.  Sadly, it's much slower
 * than hand-coded assembly or direct CPU support.
 */

#ifndef PCG_UINT128_HPP_INCLUDED
#define PCG_UINT128_HPP_INCLUDED 1

#include <cstdint>
#include <cstdio>
#include <cassert>
#include <climits>
#include <utility>
#include <initializer_list>
#include <type_traits>

/*
 * We want to lay the type out the same way that a native type would be laid
 * out, which means we must know the machine's endian, at compile time.
 * This ugliness attempts to do so.
 */

#ifndef PCG_LITTLE_ENDIAN
    #if defined(__BYTE_ORDER__)
        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
            #define PCG_LITTLE_ENDIAN 1
        #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
            #define PCG_LITTLE_ENDIAN 0
        #else
            #error __BYTE_ORDER__ does not match a standard endian, pick a side
        #endif
    #elif __LITTLE_ENDIAN__ || _LITTLE_ENDIAN
        #define PCG_LITTLE_ENDIAN 1
    #elif __BIG_ENDIAN__ || _BIG_ENDIAN
        #define PCG_LITTLE_ENDIAN 0
    #elif __x86_64 || __x86_64__ || __i386 || __i386__
        #define PCG_LITTLE_ENDIAN 1
    #elif __powerpc__ || __POWERPC__ || __ppc__ || __PPC__ \
          || __m68k__ || __mc68000__
        #define PCG_LITTLE_ENDIAN 0
    #else
        #error Unable to determine target endianness
    #endif
#endif

namespace pcg_extras {

// Recent versions of GCC have intrinsics we can use to quickly calculate
// the number of leading and trailing zeros in a number.  If possible, we
// use them, otherwise we fall back to old-fashioned bit twiddling to figure
// them out.

#ifndef PCG_BITCOUNT_T
    typedef uint8_t bitcount_t;
#else
    typedef PCG_BITCOUNT_T bitcount_t;
#endif

/*
 * Provide some useful helper functions
 *      * flog2                 floor(log2(x))
 *      * trailingzeros         number of trailing zero bits
 */

#ifdef __GNUC__         // Any GNU-compatible compiler supporting C++11 has
                        // some useful intrinsics we can use.

inline bitcount_t flog2(uint32_t v)
{
    return 31 - __builtin_clz(v);
}

inline bitcount_t trailingzeros(uint32_t v)
{
    return __builtin_ctz(v);
}

inline bitcount_t flog2(uint64_t v)
{
#if UINT64_MAX == ULONG_MAX
    return 63 - __builtin_clzl(v);
#elif UINT64_MAX == ULLONG_MAX
    return 63 - __builtin_clzll(v);
#else
    #error Cannot find a function for uint64_t
#endif
}

inline bitcount_t trailingzeros(uint64_t v)
{
#if UINT64_MAX == ULONG_MAX
    return __builtin_ctzl(v);
#elif UINT64_MAX == ULLONG_MAX
    return __builtin_ctzll(v);
#else
    #error Cannot find a function for uint64_t
#endif
}

#else                   // Otherwise, we fall back to bit twiddling
                        // implementations

inline bitcount_t flog2(uint32_t v)
{
    // Based on code by Eric Cole and Mark Dickinson, which appears at
    // https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn

    static const uint8_t multiplyDeBruijnBitPos[32] = {
      0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
      8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
    };

    v |= v >> 1; // first round down to one less than a power of 2
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;

    return multiplyDeBruijnBitPos[(uint32_t)(v * 0x07C4ACDDU) >> 27];
}

inline bitcount_t trailingzeros(uint32_t v)
{
    static const uint8_t multiplyDeBruijnBitPos[32] = {
      0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
      31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
    };

    return multiplyDeBruijnBitPos[((uint32_t)((v & -v) * 0x077CB531U)) >> 27];
}

inline bitcount_t flog2(uint64_t v)
{
    uint32_t high = v >> 32;
    uint32_t low  = uint32_t(v);

    return high ? 32+flog2(high) : flog2(low);
}

inline bitcount_t trailingzeros(uint64_t v)
{
    uint32_t high = v >> 32;
    uint32_t low  = uint32_t(v);

    return low ? trailingzeros(low) : trailingzeros(high)+32;
}

#endif

template <typename UInt>
inline bitcount_t clog2(UInt v)
{
    return flog2(v) + ((v & (-v)) != v);
}

template <typename UInt>
inline UInt addwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
{
    UInt half_result = y + carryin;
    UInt result = x + half_result;
    *carryout = (half_result < y) || (result < x);
    return result;
}

template <typename UInt>
inline UInt subwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
{
    UInt half_result = y + carryin;
    UInt result = x - half_result;
    *carryout = (half_result < y) || (result > x);
    return result;
}


template <typename UInt, typename UIntX2>
class uint_x4 {
// private:
public:
    union {
#if PCG_LITTLE_ENDIAN
        struct {
            UInt v0, v1, v2, v3;
        } w;
        struct {
            UIntX2 v01, v23;
        } d;
#else
        struct {
            UInt v3, v2, v1, v0;
        } w;
        struct {
            UIntX2 v23, v01;
        } d;
#endif
        // For the array access versions, the code that uses the array
        // must handle endian itself.  Yuck.
        UInt wa[4];
        UIntX2 da[2];
    };

public:
    uint_x4() = default;

    constexpr uint_x4(UInt v3, UInt v2, UInt v1, UInt v0)
#if PCG_LITTLE_ENDIAN
       : w{v0, v1, v2, v3}
#else
       : w{v3, v2, v1, v0}
#endif
    {
        // Nothing (else) to do
    }

    constexpr uint_x4(UIntX2 v23, UIntX2 v01)
#if PCG_LITTLE_ENDIAN
       : d{v01,v23}
#else
       : d{v23,v01}
#endif
    {
        // Nothing (else) to do
    }

    template<class Integral,
             typename std::enable_if<(std::is_integral<Integral>::value
                                      && sizeof(Integral) <= sizeof(UIntX2))
                                    >::type* = nullptr>
    constexpr uint_x4(Integral v01)
#if PCG_LITTLE_ENDIAN
       : d{UIntX2(v01),0UL}
#else
       : d{0UL,UIntX2(v01)}
#endif
    {
        // Nothing (else) to do
    }

    explicit constexpr operator uint64_t() const
    {
        return d.v01;
    }

    explicit constexpr operator uint32_t() const
    {
        return w.v0;
    }

    explicit constexpr operator int() const
    {
        return w.v0;
    }

    explicit constexpr operator uint16_t() const
    {
        return w.v0;
    }

    explicit constexpr operator uint8_t() const
    {
        return w.v0;
    }

    typedef typename std::conditional<std::is_same<uint64_t,
                                                   unsigned long>::value,
                                      unsigned long long,
                                      unsigned long>::type
            uint_missing_t;

    explicit constexpr operator uint_missing_t() const
    {
        return d.v01;
    }

    explicit constexpr operator bool() const
    {
        return d.v01 || d.v23;
    }

    template<typename U, typename V>
    friend uint_x4<U,V> operator*(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend std::pair< uint_x4<U,V>,uint_x4<U,V> >
        divmod(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator+(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator-(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator<<(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator>>(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator&(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator|(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator^(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bool operator==(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bool operator!=(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bool operator<(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bool operator<=(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bool operator>(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bool operator>=(const uint_x4<U,V>&, const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator~(const uint_x4<U,V>&);

    template<typename U, typename V>
    friend uint_x4<U,V> operator-(const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bitcount_t flog2(const uint_x4<U,V>&);

    template<typename U, typename V>
    friend bitcount_t trailingzeros(const uint_x4<U,V>&);

    uint_x4& operator*=(const uint_x4& rhs)
    {
        uint_x4 result = *this * rhs;
        return *this = result;
    }

    uint_x4& operator/=(const uint_x4& rhs)
    {
        uint_x4 result = *this / rhs;
        return *this = result;
    }

    uint_x4& operator%=(const uint_x4& rhs)
    {
        uint_x4 result = *this % rhs;
        return *this = result;
    }

    uint_x4& operator+=(const uint_x4& rhs)
    {
        uint_x4 result = *this + rhs;
        return *this = result;
    }

    uint_x4& operator-=(const uint_x4& rhs)
    {
        uint_x4 result = *this - rhs;
        return *this = result;
    }

    uint_x4& operator&=(const uint_x4& rhs)
    {
        uint_x4 result = *this & rhs;
        return *this = result;
    }

    uint_x4& operator|=(const uint_x4& rhs)
    {
        uint_x4 result = *this | rhs;
        return *this = result;
    }

    uint_x4& operator^=(const uint_x4& rhs)
    {
        uint_x4 result = *this ^ rhs;
        return *this = result;
    }

    uint_x4& operator>>=(bitcount_t shift)
    {
        uint_x4 result = *this >> shift;
        return *this = result;
    }

    uint_x4& operator<<=(bitcount_t shift)
    {
        uint_x4 result = *this << shift;
        return *this = result;
    }

};

template<typename U, typename V>
bitcount_t flog2(const uint_x4<U,V>& v)
{
#if PCG_LITTLE_ENDIAN
    for (uint8_t i = 4; i !=0; /* dec in loop */) {
        --i;
#else
    for (uint8_t i = 0; i < 4; ++i) {
#endif
        if (v.wa[i] == 0)
             continue;
        return flog2(v.wa[i]) + (sizeof(U)*CHAR_BIT)*i;
    }
    abort();
}

template<typename U, typename V>
bitcount_t trailingzeros(const uint_x4<U,V>& v)
{
#if PCG_LITTLE_ENDIAN
    for (uint8_t i = 0; i < 4; ++i) {
#else
    for (uint8_t i = 4; i !=0; /* dec in loop */) {
        --i;
#endif
        if (v.wa[i] != 0)
            return trailingzeros(v.wa[i]) + (sizeof(U)*CHAR_BIT)*i;
    }
    return (sizeof(U)*CHAR_BIT)*4;
}

template <typename UInt, typename UIntX2>
std::pair< uint_x4<UInt,UIntX2>, uint_x4<UInt,UIntX2> >
    divmod(const uint_x4<UInt,UIntX2>& orig_dividend,
           const uint_x4<UInt,UIntX2>& divisor)
{
    // If the dividend is less than the divisor, the answer is always zero.
    // This takes care of boundary cases like 0/x (which would otherwise be
    // problematic because we can't take the log of zero.  (The boundary case
    // of division by zero is undefined.)
    if (orig_dividend < divisor)
        return { uint_x4<UInt,UIntX2>(0UL), orig_dividend };

    auto dividend = orig_dividend;

    auto log2_divisor  = flog2(divisor);
    auto log2_dividend = flog2(dividend);
    // assert(log2_dividend >= log2_divisor);
    bitcount_t logdiff = log2_dividend - log2_divisor;

    constexpr uint_x4<UInt,UIntX2> ONE(1UL);
    if (logdiff == 0)
        return { ONE, dividend - divisor };

    // Now we change the log difference to
    //  floor(log2(divisor)) - ceil(log2(dividend))
    // to ensure that we *underestimate* the result.
    logdiff -= 1;

    uint_x4<UInt,UIntX2> quotient(0UL);

    auto qfactor = ONE << logdiff;
    auto factor  = divisor << logdiff;

    do {
        dividend -= factor;
        quotient += qfactor;
        while (dividend < factor) {
            factor  >>= 1;
            qfactor >>= 1;
        }
    } while (dividend >= divisor);

    return { quotient, dividend };
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator/(const uint_x4<UInt,UIntX2>& dividend,
                               const uint_x4<UInt,UIntX2>& divisor)
{
    return divmod(dividend, divisor).first;
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator%(const uint_x4<UInt,UIntX2>& dividend,
                               const uint_x4<UInt,UIntX2>& divisor)
{
    return divmod(dividend, divisor).second;
}


template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator*(const uint_x4<UInt,UIntX2>& a,
                               const uint_x4<UInt,UIntX2>& b)
{
    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
    bool carryin = false;
    bool carryout;
    UIntX2 a0b0 = UIntX2(a.w.v0) * UIntX2(b.w.v0);
    r.w.v0 = UInt(a0b0);
    r.w.v1 = UInt(a0b0 >> 32);

    UIntX2 a1b0 = UIntX2(a.w.v1) * UIntX2(b.w.v0);
    r.w.v2 = UInt(a1b0 >> 32);
    r.w.v1 = addwithcarry(r.w.v1, UInt(a1b0), carryin, &carryout);
    carryin = carryout;
    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
    carryin = carryout;
    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);

    UIntX2 a0b1 = UIntX2(a.w.v0) * UIntX2(b.w.v1);
    carryin = false;
    r.w.v2 = addwithcarry(r.w.v2, UInt(a0b1 >> 32), carryin, &carryout);
    carryin = carryout;
    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);

    carryin = false;
    r.w.v1 = addwithcarry(r.w.v1, UInt(a0b1), carryin, &carryout);
    carryin = carryout;
    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
    carryin = carryout;
    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);

    UIntX2 a1b1 = UIntX2(a.w.v1) * UIntX2(b.w.v1);
    carryin = false;
    r.w.v2 = addwithcarry(r.w.v2, UInt(a1b1), carryin, &carryout);
    carryin = carryout;
    r.w.v3 = addwithcarry(r.w.v3, UInt(a1b1 >> 32), carryin, &carryout);

    r.d.v23 += a.d.v01 * b.d.v23 + a.d.v23 * b.d.v01;

    return r;
}


template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator+(const uint_x4<UInt,UIntX2>& a,
                               const uint_x4<UInt,UIntX2>& b)
{
    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};

    bool carryin = false;
    bool carryout;
    r.w.v0 = addwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
    carryin = carryout;
    r.w.v1 = addwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
    carryin = carryout;
    r.w.v2 = addwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
    carryin = carryout;
    r.w.v3 = addwithcarry(a.w.v3, b.w.v3, carryin, &carryout);

    return r;
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& a,
                               const uint_x4<UInt,UIntX2>& b)
{
    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};

    bool carryin = false;
    bool carryout;
    r.w.v0 = subwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
    carryin = carryout;
    r.w.v1 = subwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
    carryin = carryout;
    r.w.v2 = subwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
    carryin = carryout;
    r.w.v3 = subwithcarry(a.w.v3, b.w.v3, carryin, &carryout);

    return r;
}


template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator&(const uint_x4<UInt,UIntX2>& a,
                               const uint_x4<UInt,UIntX2>& b)
{
    return uint_x4<UInt,UIntX2>(a.d.v23 & b.d.v23, a.d.v01 & b.d.v01);
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator|(const uint_x4<UInt,UIntX2>& a,
                               const uint_x4<UInt,UIntX2>& b)
{
    return uint_x4<UInt,UIntX2>(a.d.v23 | b.d.v23, a.d.v01 | b.d.v01);
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator^(const uint_x4<UInt,UIntX2>& a,
                               const uint_x4<UInt,UIntX2>& b)
{
    return uint_x4<UInt,UIntX2>(a.d.v23 ^ b.d.v23, a.d.v01 ^ b.d.v01);
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator~(const uint_x4<UInt,UIntX2>& v)
{
    return uint_x4<UInt,UIntX2>(~v.d.v23, ~v.d.v01);
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& v)
{
    return uint_x4<UInt,UIntX2>(0UL,0UL) - v;
}

template <typename UInt, typename UIntX2>
bool operator==(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
{
    return (a.d.v01 == b.d.v01) && (a.d.v23 == b.d.v23);
}

template <typename UInt, typename UIntX2>
bool operator!=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
{
    return !operator==(a,b);
}


template <typename UInt, typename UIntX2>
bool operator<(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
{
    return (a.d.v23 < b.d.v23)
           || ((a.d.v23 == b.d.v23) && (a.d.v01 < b.d.v01));
}

template <typename UInt, typename UIntX2>
bool operator>(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
{
    return operator<(b,a);
}

template <typename UInt, typename UIntX2>
bool operator<=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
{
    return !(operator<(b,a));
}

template <typename UInt, typename UIntX2>
bool operator>=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
{
    return !(operator<(a,b));
}



template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator<<(const uint_x4<UInt,UIntX2>& v,
                                const bitcount_t shift)
{
    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
    const bitcount_t bits    = sizeof(UInt) * CHAR_BIT;
    const bitcount_t bitmask = bits - 1;
    const bitcount_t shiftdiv = shift / bits;
    const bitcount_t shiftmod = shift & bitmask;

    if (shiftmod) {
        UInt carryover = 0;
#if PCG_LITTLE_ENDIAN
        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
#else
        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
            --out, --in;
#endif
            r.wa[out] = (v.wa[in] << shiftmod) | carryover;
            carryover = (v.wa[in] >> (bits - shiftmod));
        }
    } else {
#if PCG_LITTLE_ENDIAN
        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
#else
        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
            --out, --in;
#endif
            r.wa[out] = v.wa[in];
        }
    }

    return r;
}

template <typename UInt, typename UIntX2>
uint_x4<UInt,UIntX2> operator>>(const uint_x4<UInt,UIntX2>& v,
                                const bitcount_t shift)
{
    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
    const bitcount_t bits    = sizeof(UInt) * CHAR_BIT;
    const bitcount_t bitmask = bits - 1;
    const bitcount_t shiftdiv = shift / bits;
    const bitcount_t shiftmod = shift & bitmask;

    if (shiftmod) {
        UInt carryover = 0;
#if PCG_LITTLE_ENDIAN
        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
            --out, --in;
#else
        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
#endif
            r.wa[out] = (v.wa[in] >> shiftmod) | carryover;
            carryover = (v.wa[in] << (bits - shiftmod));
        }
    } else {
#if PCG_LITTLE_ENDIAN
        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
            --out, --in;
#else
        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
#endif
            r.wa[out] = v.wa[in];
        }
    }

    return r;
}

} // namespace pcg_extras

#endif // PCG_UINT128_HPP_INCLUDED


================================================
FILE: lib/pge_cpu_arch.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#if defined(_X86_) || defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) || defined(_M_IX86)
#   define PGE_CPU_x86
#   define PGE_CPU_x86_32
#elif defined(__x86_64__) || defined(__amd64__) || defined(_WIN64) || defined(_M_X64) || defined(_M_AMD64)
#   define PGE_CPU_x86
#   define PGE_CPU_x86_64
#elif defined(__arm__) || defined(__TARGET_ARCH_ARM) || defined(__ARM_ARCH)
#   if defined(__ARM_ARCH_8__) \
     || defined(__ARM_ARCH_8A) \
     || defined(__ARM_ARCH_8A__) \
     || defined(__ARM_ARCH_8R__) \
     || defined(__ARM_ARCH_8M__) \
     || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 8) \
     || (defined(__ARM_ARCH) && __ARM_ARCH >= 8) || defined(_M_ARM64) || defined(_M_ARM64EC)
#       define PGE_CPU_ARM64
#       define PGE_CPU_ARMv8
#   elif defined(__ARM_ARCH_7__) \
       || defined(__ARM_ARCH_7A__) \
       || defined(__ARM_ARCH_7R__) \
       || defined(__ARM_ARCH_7M__) \
       || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 7) \
       || (defined(__ARM_ARCH) && __ARM_ARCH >= 7)
#       define PGE_CPU_ARM32
#       define PGE_CPU_ARMv7
#   elif defined(__ARM_ARCH_6__) \
       || defined(__ARM_ARCH_6J__) \
       || defined(__ARM_ARCH_6T2__) \
       || defined(__ARM_ARCH_6Z__) \
       || defined(__ARM_ARCH_6K__) \
       || defined(__ARM_ARCH_6ZK__) \
       || defined(__ARM_ARCH_6M__) \
       || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 6) \
       || (defined(__ARM_ARCH) && __ARM_ARCH >= 6)
#       define PGE_CPU_ARM32
#       define PGE_CPU_ARMv6
#   elif defined(__ARM_ARCH_5TEJ__) \
      || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 5)
#       define PGE_CPU_ARM32
#       define PGE_CPU_ARMv5
#   else
#       define PGE_CPU_ARM32
#   endif
#elif defined(__mips__) || defined(__mips) || defined(__MIPS__)
#       define PGE_CPU_MIPS
#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) \
   || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \
   || defined(_M_MPPC) || defined(_M_PPC)
#   if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
#       define PGE_CPU_PPC
#       define PGE_CPU_PPC64
#   else
#       define PGE_CPU_PPC
#       define PGE_CPU_PPC32
#   endif
#elif defined(__riscv) // FIXME: Adjust if any extra macros needed
#   if defined(__riscv64)
#       define PGE_CPU_RISCV
#       define PGE_CPU_RISCV64
#   elif defined(__riscv32)
#       define PGE_CPU_RISCV
#       define PGE_CPU_RISCV32
#   endif
#elif defined(__loongarch64)
#       define PGE_CPU_LOONGARCH
#       define PGE_CPU_LOONGARCH64
#elif defined(__loongarch)
#       define PGE_CPU_LOONGARCH
#       define PGE_CPU_LOONGARCH32
#else
#       define PGE_CPU_UNKNOWN
#       warning CPU is unknown! Please add missing architecture!
#endif


================================================
FILE: lib/pge_delay.h
================================================
#ifndef PGE_DELAY_H
#define PGE_DELAY_H

#ifdef __EMSCRIPTEN__
#   include <emscripten.h>
#   define PGE_Delay(x) emscripten_sleep(x)
#elif defined(__3DS__)
#   include <3ds.h>
#   define PGE_Delay(x) svcSleepThread((uint64_t)(x) * 1000000)
#elif defined(__WII__)
extern "C" void udelay(unsigned us);
#   define PGE_Delay(x) udelay((x) * 1000)
#else
#   include "sdl_proxy/sdl_timer.h"
#   define PGE_Delay(x) SDL_Delay(x)
#endif

#endif // PGE_DELAY_H


================================================
FILE: lib/pge_tonearest.h
================================================
// This code was taken and adapted from LLVM project:

//===-- Nearest integer floating-point operations ---------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// https://github.com/llvm/llvm-project/blob/main/libc/utils/FPUtil/NearestIntegerOperations.h

#pragma once
#ifndef PGE_TO_NEAREST
#define PGE_TO_NEAREST

#include <cstdint>
#include "sdl_proxy/sdl_stdinc.h"

#if defined(arm) && !defined(__SOFTFP__) && !defined(__VFP_FP__) && !defined(__MAVERICK__)
inline void swap_halfes(uint64_t &x)
{
    uint64_t y = ((x & 0xFFFFFFFF00000000) >> 32) & 0xFFFFFFFF;
    x = ((x << 32) & 0xFFFFFFFF00000000) & y;
}
#else // Do nothing
#   define swap_halfes(x)
#endif

namespace PgeFloatProp
{

static const uint32_t bitWidth = sizeof(uint64_t) << 3;

static const uint32_t mantissaWidth = 52;
static const uint32_t exponentWidth = 11;
static const uint64_t mantissaMask = (uint64_t(1) << mantissaWidth) - 1;
static const uint64_t signMask = uint64_t(1) << (exponentWidth + mantissaWidth);
static const uint64_t exponentMask = ~(signMask | mantissaMask);
static const uint32_t exponentBias = 1023;

// If a number x is a NAN, then it is a quiet NAN if:
//   QuietNaNMask & bits(x) != 0
// Else, it is a signalling NAN.
static const uint64_t quietNaNMask = 0x0008000000000000ULL;

}

union PgeFPBits
{
    uint64_t bits;

    void setMantissa(uint64_t mantVal)
    {
        swap_halfes(bits);
        mantVal &= (PgeFloatProp::mantissaMask);
        bits &= ~(PgeFloatProp::mantissaMask);
        bits |= mantVal;
        swap_halfes(bits);
    }

    uint64_t getMantissa() const
    {
        uint64_t ret = bits;
        swap_halfes(ret);
        return ret & PgeFloatProp::mantissaMask;
    }

    void setUnbiasedExponent(uint64_t expVal)
    {
        swap_halfes(bits);
        expVal = (expVal << (PgeFloatProp::mantissaWidth)) & PgeFloatProp::exponentMask;
        bits &= ~(PgeFloatProp::exponentMask);
        bits |= expVal;
        swap_halfes(bits);
    }

    uint16_t getUnbiasedExponent() const
    {
        uint64_t ret = bits;
        swap_halfes(ret);
        return uint16_t((ret & PgeFloatProp::exponentMask) >>
                        (PgeFloatProp::mantissaWidth));
    }

    void setSign(bool signVal)
    {
        swap_halfes(bits);
        bits &= ~(PgeFloatProp::signMask);
        uint64_t sign = uint64_t(signVal) << (PgeFloatProp::bitWidth - 1);
        bits |= sign;
        swap_halfes(bits);
    }

    bool getSign() const
    {
        uint64_t ret = bits;
        swap_halfes(ret);
        return ((ret & PgeFloatProp::signMask) >> (PgeFloatProp::bitWidth - 1));
    }
    double val;

    static const int exponentBias = (1 << (PgeFloatProp::exponentWidth - 1)) - 1;
    static const int maxExponent = (1 << PgeFloatProp::exponentWidth) - 1;

    static const uint64_t minSubnormal = uint64_t(1);
    static const uint64_t maxSubnormal = (uint64_t(1) << PgeFloatProp::mantissaWidth) - 1;
    static const uint64_t minNormal = (uint64_t(1) << PgeFloatProp::mantissaWidth);
    static const uint64_t maxNormal = ((uint64_t(maxExponent) - 1) << PgeFloatProp::mantissaWidth) | maxSubnormal;

    explicit PgeFPBits(double x) : val(x) {}
    explicit PgeFPBits(uint64_t x) : bits(x) {}

    PgeFPBits() : bits(0) {}

    explicit operator double()
    {
        return val;
    }

    uint64_t uintval() const
    {
        uint64_t ret = bits;
        swap_halfes(ret);
        return ret;
    }

    int getExponent() const
    {
        return int(getUnbiasedExponent()) - exponentBias;
    }

    bool isZero() const
    {
        return getMantissa() == 0 && getUnbiasedExponent() == 0;
    }

    bool isInf() const
    {
        return getMantissa() == 0 && getUnbiasedExponent() == maxExponent;
    }

    bool isNaN() const
    {
        return getUnbiasedExponent() == maxExponent && getMantissa() != 0;
    }

    bool isInfOrNaN() const
    {
        return getUnbiasedExponent() == maxExponent;
    }

    static PgeFPBits zero()
    {
        return PgeFPBits();
    }

    static PgeFPBits negZero()
    {
        return PgeFPBits(uint64_t(1) << (sizeof(uint64_t) * 8 - 1));
    }

    static PgeFPBits inf()
    {
        PgeFPBits bits;
        bits.setUnbiasedExponent(maxExponent);
        return bits;
    }

    static PgeFPBits negInf()
    {
        PgeFPBits bits = inf();
        bits.setSign(1);
        return bits;
    }

    static double buildNaN(uint64_t v)
    {
        PgeFPBits bits = inf();
        bits.setMantissa(v);
        return double(bits);
    }
};


SDL_FORCE_INLINE double pge_toNearest(double x)
{
    PgeFPBits bits(x);

    // If x is infinity NaN or zero, return it.
    if(bits.isInfOrNaN() || bits.isZero())
        return x;

    bool isNeg = bits.getSign();
    int exponent = bits.getExponent();

    // If the exponent is greater than the most negative mantissa
    // exponent, then x is already an integer.
    if(exponent >= (int)PgeFloatProp::mantissaWidth)
        return x;

    if(exponent <= -1)
    {
        if(exponent <= -2 || bits.getMantissa() == 0)
            return isNeg ? (-0.0) : (0.0); // abs(x) <= 0.5
        else
            return isNeg ? (-1.0) : (1.0); // abs(x) > 0.5
    }

    uint32_t trimSize = PgeFloatProp::mantissaWidth - exponent;
    PgeFPBits newBits = bits;
    newBits.setMantissa((bits.getMantissa() >> trimSize) << trimSize);
    double truncValue = double(newBits);

    if(truncValue == x)
        return x;

    uint64_t trimValue = bits.getMantissa() & ((uint64_t(1) << trimSize) - 1);
    uint64_t halfValue = (uint64_t(1) << (trimSize - 1));
    // If exponent is 0, trimSize will be equal to the mantissa width, and
    // truncIsOdd` will not be correct. So, we handle it as a special case
    // below.
    uint64_t truncIsOdd = newBits.getMantissa() & (uint64_t(1) << trimSize);

    if(trimValue > halfValue)
        return isNeg ? truncValue - double(1.0) : truncValue + double(1.0);
    else if(trimValue == halfValue)
    {
        if(exponent == 0)
            return isNeg ? double(-2.0) : double(2.0);
        if(truncIsOdd)
            return isNeg ? truncValue - double(1.0) : truncValue + double(1.0);
        else
            return truncValue;
    }
    else
        return truncValue;
}

#endif // #ifndef PGE_TO_NEAREST


================================================
FILE: lib/pge_video_rec/pge-video-rec.cmake
================================================
set(VIDEO_REC_SRCS)
set(VIDEO_REC_INCS)
set(VIDEO_REC_LIBS)
set(VIDEO_REC_DEPS)

if(NOT EMSCRIPTEN AND
   NOT NINTENDO_3DS AND
   NOT NINTENDO_WII AND
   NOT NINTENDO_WIIU AND
   NOT PGE_MIN_PORT AND
   NOT THEXTECH_CLI_BUILD)
    option(PGE_ENABLE_VIDEO_REC "Enable the PGE video recording system" ON)
else()
    set(PGE_ENABLE_VIDEO_REC OFF)
endif()


if(PGE_ENABLE_VIDEO_REC)
    option(PGE_VIDEO_REC_PREFER_GIF "Prefer GIF even if WEBM is available" ON)

    list(APPEND VIDEO_REC_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/pge_video_rec.h
        ${CMAKE_CURRENT_LIST_DIR}/pge_video_sink.cpp
        ${CMAKE_CURRENT_LIST_DIR}/pge_record_gif.cpp
    )

    set(PGE_VIDEO_REC_WEBM_SUPPORTED OFF)

    if(NOT PGE_VIDEO_REC_PREFER_GIF)
        find_path(AVCODEC_INCLUDE_DIR NAMES libavcodec/avcodec.h PATH_SUFFIXES ffmpeg)
        find_library(AVCODEC_LIBRARY avcodec)

        find_path(AVFORMAT_INCLUDE_DIR libavformat/avformat.h PATH_SUFFIXES ffmpeg)
        find_library(AVFORMAT_LIBRARY avformat)

        find_path(AVUTIL_INCLUDE_DIR libavutil/avutil.h PATH_SUFFIXES ffmpeg)
        find_library(AVUTIL_LIBRARY avutil)

        find_path(SWSCALE_INCLUDE_DIR libswscale/swscale.h PATH_SUFFIXES ffmpeg)
        find_library(SWSCALE_LIBRARY swscale)

        find_path(SWRESAMPLE_INCLUDE_DIR libswresample/swresample.h PATH_SUFFIXES ffmpeg)
        find_library(SWRESAMPLE_LIBRARY swresample)

        if(AVCODEC_INCLUDE_DIR AND AVCODEC_LIBRARY AND
           AVFORMAT_INCLUDE_DIR AND AVFORMAT_LIBRARY AND
           SWSCALE_INCLUDE_DIR AND SWSCALE_LIBRARY AND
           SWRESAMPLE_INCLUDE_DIR AND SWRESAMPLE_LIBRARY)
            set(PGE_VIDEO_REC_WEBM_SUPPORTED ON)
            set(VIDEO_REC_INCS
                ${AVCODEC_INCLUDE_DIR}
                ${AVFORMAT_INCLUDE_DIR}
                ${AVUTIL_INCLUDE_DIR}
                ${SWSCALE_INCLUDE_DIR}
                ${SWRESAMPLE_INCLUDE_DIR}
            )
            set(VIDEO_REC_LIBS
                ${SWSCALE_LIBRARY}
                ${SWRESAMPLE_LIBRARY}
                ${AVFORMAT_LIBRARY}
                ${AVCODEC_LIBRARY}
                ${AVUTIL_LIBRARY}
            )

            if(VITA)
                find_library(FFMPEG_LAME_LIBRARY REQUIRED mp3lame)
                list(APPEND VIDEO_REC_LIBS ${FFMPEG_LAME_LIBRARY})
            endif()
        endif()
    endif()

    if(PGE_VIDEO_REC_WEBM_SUPPORTED)
        message("== PGE video record will be statically built using system FFMPEG libraries")
        list(APPEND VIDEO_REC_SRCS
            ${CMAKE_CURRENT_LIST_DIR}/pge_record_vp8.cpp
        )
    else()
        message("== PGE video record will be built without WEBM support")
    endif()
endif()


================================================
FILE: lib/pge_video_rec/pge_record_gif.cpp
================================================
/*
 *
 * Copyright (c) 2020-2024 ds-sloth and Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <SDL2/SDL_mutex.h>
#include <Utils/files.h>
#include <pge_delay.h>

#include "gif.h"

#include "pge_video_rec.h"


struct PGE_VideoRecording_GIF : public PGE_VideoRecording
{
    PGE_VideoRecording_GIF() : PGE_VideoRecording() {}
    virtual ~PGE_VideoRecording_GIF() = default;

    GIF_H::GifWriter  writer      = {nullptr, nullptr, true, false, {}};
    unsigned char padding[7] = {0, 0, 0, 0, 0, 0, 0};

    // returns the best file extension for the recording type
    virtual const char* extension() const override;

    // should be called by a main thread, returns false on failure
    virtual bool initialize(const char* filename) override;

    // should be called by an encoding thread, terminates once the empty end frame has been dequeued.
    virtual bool encoding_thread() override;
};

const char* PGE_VideoRecording_GIF::extension() const
{
    return "gif";
}

bool PGE_VideoRecording_GIF::initialize(const char* filename)
{
    SDL_RWops *gifFile = Files::open_file(filename, "wb");

    if(!gifFile)
        return false;

    return GIF_H::GifBegin(&writer, gifFile, spec.frame_w, spec.frame_h, 100 / spec.frame_rate, false);
}

bool PGE_VideoRecording_GIF::encoding_thread()
{
    (void)(GIF_H::GifOverwriteLastDelay);// shut up a warning about unused function

    int frame_i = 0;

    while(true)
    {
        if(!has_frame())
        {
            if(exit_requested)
                break;

            PGE_Delay(1);
            continue;
        }

        auto sh = dequeue_frame();

        if(sh.end_frame)
            break;

        GifWriteFrame(&writer, sh.pixels.data(),
                      unsigned(spec.frame_w),
                      unsigned(spec.frame_h),
                      ((frame_i + 1) * 100 / spec.frame_rate) - (frame_i * 100 / spec.frame_rate), 8, false);

        frame_i++;
    }

    // Once GIF recorder was been disabled, finalize it
    GIF_H::GifEnd(&writer);

    return true;
}

std::unique_ptr<PGE_VideoRecording> PGE_new_recording_GIF(const PGE_VideoSpec& spec)
{
    std::unique_ptr<PGE_VideoRecording> ret(new PGE_VideoRecording_GIF());
    ret->spec = spec;
    ret->spec.audio_enabled = false;
    return ret;
}


================================================
FILE: lib/pge_video_rec/pge_record_vp8.cpp
================================================
/*
 *
 * Copyright (c) 2020-2024 ds-sloth and Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


/*
 * This file incorporates substantial portions of libavformat's example mux.c
 *
 * Copyright (c) 2003 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

extern "C"
{
#include <stdint.h>
#include <libavutil/avassert.h>
#include <libavutil/channel_layout.h>
#include <libavutil/opt.h>
#include <libavutil/mathematics.h>
#include <libavutil/timestamp.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
}

#include <SDL2/SDL_assert.h>
#include <SDL2/SDL_mutex.h>
#include <SDL2/SDL_audio.h>

#include <Utils/files.h>
#include <pge_delay.h>
#include <Logger/logger.h>

#include "pge_video_rec.h"

#define HAS_CHANNELLAYOUT (LIBAVUTIL_VERSION_MAJOR >= 58)

#undef av_err2str

static char s_errbuf[(AV_ERROR_MAX_STRING_SIZE > 512) ? AV_ERROR_MAX_STRING_SIZE : 512];

inline const char* av_err2str(int errnum)
{
    return av_make_error_string(s_errbuf, AV_ERROR_MAX_STRING_SIZE, errnum);
}

static std::string av_log_buffer;
static SDL_mutex* av_log_mutex = nullptr;

static void av_log_callback_pLog(void* avcl, int level, const char* fmt, va_list vl)
{
    if(av_log_mutex)
        SDL_LockMutex(av_log_mutex);

    // prepare the log buffer with the label
    static const char log_label[] = {'P', 'G', 'E', 'V', 'i', 'd', 'e', 'o', 'R', 'e', 'c', ':', ' ', '(', 'f', 'f', 'm', 'p', 'e', 'g', ')', ' '};

    if(av_log_buffer.size() < sizeof(log_label))
    {
        av_log_buffer.resize(sizeof(log_label));
        memcpy(&av_log_buffer[0], log_label, sizeof(log_label));
    }

    // add AV Class name to buffer
    AVClass* avc = avcl ? *(AVClass**)avcl : NULL;

    if(avc)
    {
        s_errbuf[0] = '\0';
        snprintf(s_errbuf, sizeof(s_errbuf), "[%s @ %p] ", avc->item_name(avcl), avcl);

        av_log_buffer += s_errbuf;
    }

    // add message to buffer
    s_errbuf[0] = '\0';
    vsnprintf(s_errbuf, sizeof(s_errbuf), fmt, vl);

    av_log_buffer += s_errbuf;

    // look for newlines
    size_t cutpoint = sizeof(log_label);

    for(size_t checkpoint = 0; checkpoint < av_log_buffer.size(); ++checkpoint)
    {
        if(av_log_buffer[checkpoint] != '\n')
            continue;

        // print the line from cutpoint to checkpoint
        av_log_buffer[checkpoint] = '\0';

        // add "PGEVideoRec: "
        if(cutpoint >= sizeof(log_label))
        {
            memcpy(&av_log_buffer[cutpoint - sizeof(log_label)], log_label, sizeof(log_label));
            cutpoint -= sizeof(log_label);
        }

        switch(level)
        {
        case(AV_LOG_PANIC):
            pLogFatal("%s", av_log_buffer.c_str() + cutpoint);
            break;

        case(AV_LOG_FATAL):
            pLogCritical("%s", av_log_buffer.c_str() + cutpoint);
            break;

        case(AV_LOG_ERROR):
        case(AV_LOG_WARNING):
            pLogWarning("%s", av_log_buffer.c_str() + cutpoint);
            break;

        case(AV_LOG_INFO):
        case(AV_LOG_VERBOSE):
            pLogDebug("%s", av_log_buffer.c_str() + cutpoint);
            break;

        case(AV_LOG_DEBUG):
        default:
            // do nothing
            break;
        }

        cutpoint = checkpoint + 1;
    }

    av_log_buffer.erase(av_log_buffer.begin() + sizeof(log_label), av_log_buffer.begin() + cutpoint);

    if(av_log_mutex)
        SDL_UnlockMutex(av_log_mutex);
}


// a wrapper around a single output AVStream
struct OutputStream
{
    AVStream* st = nullptr;
    AVCodecContext* enc = nullptr;

    /* pts of the next frame that will be generated */
    int64_t next_pts = 0;
    int samples_count = 0;

    AVFrame* frame = nullptr;
    AVFrame* tmp_frame = nullptr;

    AVPacket* tmp_pkt = nullptr;

    struct SwsContext* sws_ctx = nullptr;
    struct SwrContext* swr_ctx = nullptr;
};

struct PGE_VideoRecording_VP8 : public PGE_VideoRecording
{
    OutputStream video_st;
    OutputStream audio_st;
    AVFormatContext* oc = nullptr;
#if HAS_CHANNELLAYOUT
    AVChannelLayout src_ch_layout;
#else
    int64_t src_ch_layout;
#endif
    AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_NONE;

    PGE_VideoFrame current_frame;
    PGE_VideoFrame next_frame;
    PGE_AudioChunk current_chunk;
    decltype(current_chunk.audio_buffer.begin()) current_chunk_offset = current_chunk.audio_buffer.end();

    uint64_t first_timestamp = 0;

    PGE_VideoRecording_VP8();
    virtual ~PGE_VideoRecording_VP8();

    void clean_up();

    // returns the best file extension for the recording type
    virtual const char* extension() const override;

    // should be called by a main thread, returns false on failure
    virtual bool initialize(const char* filename) override;

    // should be called by an encoding thread, terminates once the empty end frame has been dequeued.
    virtual bool encoding_thread() override;

    // returns true if the sample format is valid
    bool set_src_sample_fmt();
};

bool PGE_VideoRecording_VP8::set_src_sample_fmt()
{
    switch(spec.audio_sample_format)
    {
    case AUDIO_U8:
        src_sample_fmt = AV_SAMPLE_FMT_U8;
        break;

    case AUDIO_S16SYS:
        src_sample_fmt = AV_SAMPLE_FMT_S16;
        break;

    case AUDIO_S32SYS:
        src_sample_fmt = AV_SAMPLE_FMT_S32;
        break;

    case AUDIO_F32SYS:
        src_sample_fmt = AV_SAMPLE_FMT_FLT;
        break;

    default:
        return false;
    }

#if HAS_CHANNELLAYOUT
    av_channel_layout_default(&src_ch_layout, spec.audio_channel_count);
#else
    src_ch_layout = av_get_default_channel_layout(spec.audio_channel_count);
#endif

    return true;
}

static int write_frame(AVFormatContext* fmt_ctx, AVCodecContext* c,
                       AVStream* st, AVFrame* frame, AVPacket* pkt)
{
    int ret;

    // send the frame to the encoder
    ret = avcodec_send_frame(c, frame);

    if(ret < 0)
    {
        pLogWarning("PGEVideoRec: error sending a frame to the encoder: %s",
                    av_err2str(ret));
        return 1;
    }

    while(ret >= 0)
    {
        ret = avcodec_receive_packet(c, pkt);

        if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if(ret < 0)
        {
            pLogWarning("PGEVideoRec: error encoding a frame: %s", av_err2str(ret));
            return 1;
        }

        /* rescale output packet timestamp values from codec to stream timebase */
        av_packet_rescale_ts(pkt, c->time_base, st->time_base);
        pkt->stream_index = st->index;

        /* Write the compressed frame to the media file. */
        // log_packet(fmt_ctx, pkt);
        ret = av_interleaved_write_frame(fmt_ctx, pkt);

        /* pkt is now blank (av_interleaved_write_frame() takes ownership of
         * its contents and resets pkt), so that no unreferencing is necessary.
         * THIS would be different if one used av_write_frame(). */
        if(ret < 0)
        {
            pLogWarning("PGEVideoRec: error while writing output packet: %s", av_err2str(ret));
            return 1;
        }
    }

    return ret == AVERROR_EOF ? 1 : 0;
}

/* Add an output stream. */
static bool init_stream(OutputStream* ost, AVFormatContext* oc,
                        const AVCodec** codec, enum AVCodecID codec_id)
{
    /* find the encoder */
    *codec = avcodec_find_encoder(codec_id);

    if(!(*codec))
    {
        pLogWarning("PGEVideoRec: Could not find encoder for '%s'", avcodec_get_name(codec_id));
        return false;
    }

    ost->tmp_pkt = av_packet_alloc();

    if(!ost->tmp_pkt)
    {
        pLogWarning("PGEVideoRec: Could not allocate AVPacket");
        return false;
    }

    ost->st = avformat_new_stream(oc, NULL);

    if(!ost->st)
    {
        pLogWarning("PGEVideoRec: Could not allocate stream");
        return false;
    }

    ost->st->id = oc->nb_streams - 1;

    ost->enc = avcodec_alloc_context3(*codec);

    if(!ost->enc)
    {
        pLogWarning("PGEVideoRec: Could not alloc an encoding context");
        return false;
    }

    /* Some formats want stream headers to be separate. */
    if(oc->oformat->flags & AVFMT_GLOBALHEADER)
        ost->enc->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

    // uncertain whether this is needed
    // ost->enc->codec_id = codec_id;

    return true;
}

/**************************************************************/
/* audio output */

static AVFrame* alloc_audio_frame(AVCodecContext* enc, int nb_samples)
{
    AVFrame* frame = av_frame_alloc();

    if(!frame)
    {
        pLogWarning("PGEVideoRec: Error allocating an audio frame");
        return NULL;
    }


    frame->format = enc->sample_fmt;
#if HAS_CHANNELLAYOUT
    av_channel_layout_copy(&frame->ch_layout, &enc->ch_layout);
#else
    frame->channel_layout = enc->channel_layout;
#endif
    frame->sample_rate = enc->sample_rate;
    frame->nb_samples = nb_samples;

    if(nb_samples)
    {
        if(av_frame_get_buffer(frame, 0) < 0)
        {
            pLogWarning("PGEVideoRec: Error allocating an audio buffer");
            return NULL;
        }
    }

    return frame;
}

static bool open_audio(const PGE_VideoRecording_VP8* THIS,
                       const AVCodec* codec,
                       OutputStream* ost, AVDictionary* opt_arg)
{
    int nb_samples;
    int ret;
    AVDictionary* opt = NULL;

    // fill parameters
    ost->enc->sample_fmt  = codec->sample_fmts ? codec->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
    ost->enc->bit_rate    = 64000;
    ost->enc->sample_rate = THIS->spec.audio_sample_rate;

    // restrict sample rate to supported list
    if(codec->supported_samplerates)
    {
        bool sample_rate_supported = false;

        for(int i = 0; codec->supported_samplerates[i]; i++)
        {
            if(codec->supported_samplerates[i] == THIS->spec.audio_sample_rate)
            {
                sample_rate_supported = true;
                break;
            }
        }

        if(!sample_rate_supported)
            ost->enc->sample_rate = codec->supported_samplerates[0];
    }

#if HAS_CHANNELLAYOUT
    const AVChannelLayout& layout = (THIS->spec.audio_channel_count == 1) ? AVChannelLayout AV_CHANNEL_LAYOUT_MONO : AVChannelLayout AV_CHANNEL_LAYOUT_STEREO;
    av_channel_layout_copy(&ost->enc->ch_layout, &layout);
#else
    ost->enc->channel_layout = (THIS->spec.audio_channel_count == 1) ? av_get_default_channel_layout(1) : av_get_default_channel_layout(2);
#endif

    ost->st->time_base = AVRational { 1, ost->enc->sample_rate };

    /* open it */
    av_dict_copy(&opt, opt_arg, 0);
    ret = avcodec_open2(ost->enc, codec, &opt);
    av_dict_free(&opt);

    if(ret < 0)
    {
        pLogWarning("PGEVideoRec: Could not open audio codec: %s", av_err2str(ret));
        return false;
    }

    /* init signal generator */

    if(ost->enc->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
        nb_samples = 10000;
    else
        nb_samples = ost->enc->frame_size;

    ost->frame     = alloc_audio_frame(ost->enc, nb_samples);

    if(!ost->frame)
        return false;

    /* copy the stream parameters to the muxer */
    ret = avcodec_parameters_from_context(ost->st->codecpar, ost->enc);

    if(ret < 0)
    {
        pLogWarning("PGEVideoRec: Could not copy the stream parameters");
        return false;
    }

    /* create resampler context */
    ost->swr_ctx = swr_alloc();

    if(!ost->swr_ctx)
    {
        pLogWarning("PGEVideoRec: Could not allocate resampler context");
        return false;
    }

    /* set options */
#if HAS_CHANNELLAYOUT
    av_opt_set_chlayout(ost->swr_ctx, "in_chlayout",       &THIS->src_ch_layout,          0);
    av_opt_set_chlayout(ost->swr_ctx, "out_chlayout",      &ost->enc->ch_layout,          0);
#else
    av_opt_set_channel_layout(ost->swr_ctx, "in_channel_layout",  THIS->src_ch_layout,          0);
    av_opt_set_channel_layout(ost->swr_ctx, "out_channel_layout", ost->enc->channel_layout,     0);
#endif
    av_opt_set_int(ost->swr_ctx, "in_sample_rate",     THIS->spec.audio_sample_rate, 0);
    av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt",      THIS->src_sample_fmt,         0);
    av_opt_set_int(ost->swr_ctx, "out_sample_rate",    ost->enc->sample_rate,        0);
    av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt",     ost->enc->sample_fmt,         0);

    /* initialize the resampling context */
    if((ret = swr_init(ost->swr_ctx)) < 0)
    {
        pLogWarning("PGEVideoRec: Failed to initialize the resampling context");
        return false;
    }

    return true;
}

/* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
 * 'nb_channels' channels. */
static AVFrame* get_audio_frame(PGE_VideoRecording_VP8* THIS, OutputStream* ost)
{
    AVFrame* frame = ost->frame;

    /* when we pass a frame to the encoder, it may keep a reference to it
     * internally;
     * make sure we do not overwrite it here
     */
    int ret = av_frame_make_writable(ost->frame);

    if(ret < 0)
    {
        pLogWarning("PGEVideoRec: av_frame_make_writable failed");
        return NULL;
    }

    int samples_left = frame->nb_samples;

    int dest_active = 0;

    uint8_t* dest[8] = {0, 0, 0, 0, 0, 0, 0, 0};

    for(int i = 0; i < 8 && i < AV_NUM_DATA_POINTERS; i++)
    {
        dest[i] = frame->data[i];

        if(dest[i])
            dest_active++;
    }

#if HAS_CHANNELLAYOUT
    int num_channels = frame->ch_layout.nb_channels;
#else
    int num_channels = av_get_channel_layout_nb_channels(frame->channel_layout);
#endif

    if(dest_active != 1 && dest_active != num_channels)
    {
        pLogWarning("PGEVideoRec: invalid number of channels in dest buffer");
        return NULL;
    }

    ptrdiff_t dest_bytes_per_sample = av_get_bytes_per_sample((AVSampleFormat)frame->format);

    if(dest_active == 1)
        dest_bytes_per_sample *= num_channels;

    ptrdiff_t src_bytes_per_sample = THIS->spec.audio_channel_count * av_get_bytes_per_sample(THIS->src_sample_fmt);
    bool first_loop = true;

    while(samples_left > 0)
    {
        const uint8_t* src[1] = {NULL};
        int src_samples = 0;

        // use remaining samples from buffer if possible
        if(!first_loop || swr_get_out_samples(ost->swr_ctx, 0) < samples_left)
        {
            // poll from game audio if buffer is empty
            while(!THIS->has_audio())
            {
                // no more samples
                if(THIS->exit_requested)
                    return NULL;

                PGE_Delay(1);
                continue;
            }

            THIS->current_chunk = THIS->dequeue_audio();
            THIS->current_chunk_offset = THIS->current_chunk.audio_buffer.begin();

            src[0] = {THIS->current_chunk.audio_buffer.data()};
            src_samples = THIS->current_chunk.audio_buffer.size() / src_bytes_per_sample;
        }

        first_loop = false;

        /* convert to destination format */
        int samples_done = swr_convert(ost->swr_ctx,
                                       dest, samples_left,
                                       src, src_samples);

        if(samples_done < 0)
        {
            pLogWarning("PGEVideoRec: error during resampling");
            return NULL;
        }

        for(int i = 0; i < 8; i++)
        {
            if(dest[i])
                dest[i] += dest_bytes_per_sample * samples_done;
        }

        samples_left -= samples_done;
    }

    return frame;
}

/*
 * encode one audio frame and send it to the muxer
 * return 1 when encoding is finished, 0 otherwise
 */
static int write_audio_frame(PGE_VideoRecording_VP8* THIS, AVFormatContext* oc, OutputStream* ost)
{
    AVCodecContext* c;
    AVFrame* frame;

    c = ost->enc;

    frame = get_audio_frame(THIS, ost);

    if(!frame)
        return 1;

    frame->pts = ost->next_pts;
    ost->samples_count += frame->nb_samples;
    ost->next_pts = av_rescale_q(ost->samples_count, AVRational {1, c->sample_rate}, c->time_base);

    return write_frame(oc, c, ost->st, frame, ost->tmp_pkt);
}

/**************************************************************/
/* video output */

static AVFrame* alloc_frame(enum AVPixelFormat pix_fmt, int width, int height)
{
    AVFrame* frame;
    int ret;

    frame = av_frame_alloc();

    if(!frame)
        return NULL;

    frame->format = pix_fmt;
    frame->width  = width;
    frame->height = height;

    /* allocate the buffers for the frame data */
    ret = av_frame_get_buffer(frame, 0);

    if(ret < 0)
    {
        av_frame_free(&frame);
        frame = NULL;
    }

    return frame;
}

static bool open_video(PGE_VideoRecording_VP8* THIS, const AVCodec* codec,
                       OutputStream* ost, AVDictionary* opt_arg)
{
    // initialize parameters

    /* Resolution must be a multiple of two. */
    if(THIS->spec.downscale_video)
    {
        ost->enc->width    = THIS->spec.frame_w / 4 * 2;
        ost->enc->height   = THIS->spec.frame_h / 4 * 2;
    }
    else
    {
        ost->enc->width    = THIS->spec.frame_w / 2 * 2;
        ost->enc->height   = THIS->spec.frame_h / 2 * 2;
    }

    ost->enc->bit_rate = 8000000;
    /* timebase: THIS is the fundamental unit of time (in seconds) in terms
     * of which frame timestamps are represented. For fixed-fps content,
     * timebase should be 1/framerate and timestamp increments should be
     * identical to 1. */
    ost->st->time_base = AVRational { 1, THIS->spec.frame_rate };
    ost->enc->time_base       = ost->st->time_base;

    // c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
    ost->enc->pix_fmt       = AV_PIX_FMT_YUV420P;

    // initialize codec parameters
    int ret;
    AVCodecContext* c = ost->enc;
    AVDictionary* opt = NULL;

    av_dict_copy(&opt, opt_arg, 0);
    av_dict_set(&opt, "deadline", "good", 0);
    av_dict_set(&opt, "cpu-used", "5", 0);
    av_dict_set_int(&opt, "crf", THIS->spec.video_quality, 0);

    /* open the codec */
    ret = avcodec_open2(c, codec, &opt);
    av_dict_free(&opt);

    if(ret < 0)
    {
        pLogWarning("PGEVideoRec: could not open video codec: %s", av_err2str(ret));
        return false;
    }

    /* allocate and init a re-usable frame */
    ost->frame = alloc_frame(c->pix_fmt, c->width, c->height);

    if(!ost->frame)
    {
        pLogWarning("PGEVideoRec: could not allocate output video frame");
        return false;
    }

    /* If the output format is not RGB24, then a temporary RGB24
     * picture is needed too. It is then converted to the required
     * output format. */
    ost->tmp_frame = NULL;

    if(c->pix_fmt != AV_PIX_FMT_RGB24)
    {
        ost->tmp_frame = alloc_frame(AV_PIX_FMT_RGB24, c->width, c->height);

        if(!ost->tmp_frame)
        {
            pLogWarning("PGEVideoRec: could not allocate output video frame");
            return false;
        }
    }

    /* copy the stream parameters to the muxer */
    ret = avcodec_parameters_from_context(ost->st->codecpar, c);

    if(ret < 0)
    {
        pLogWarning("PGEVideoRec: could not copy stream parameters");
        return false;
    }

    return true;
}

/* Prepare a dummy image. */
static void fill_rgb_image(AVFrame* pict, uint8_t* src,
                           int width, int height, int src_stride)
{
    int x, y;

    // i = frame_index;

    /* Y */
    for(y = 0; y < height; y++)
    {
        for(x = 0; x < width; x++)
        {
            pict->data[0][y * pict->linesize[0] + x * 3 + 0] = src[y * src_stride + (x) * 4 + 0];
            pict->data[0][y * pict->linesize[0] + x * 3 + 1] = src[y * src_stride + (x) * 4 + 1];
            pict->data[0][y * pict->linesize[0] + x * 3 + 2] = src[y * src_stride + (x) * 4 + 2];
        }
    }
}

/* Prepare a dummy image. */
static void fill_rgb_image_downscale(AVFrame* pict, uint8_t* src,
                                     int width, int height, int src_stride)
{
    int x, y;

    // i = frame_index;
    int stride = 2 * src_stride;

    /* Y */
    for(y = 0; y < height; y++)
    {
        for(x = 0; x < width; x++)
        {
            pict->data[0][y * pict->linesize[0] + x * 3 + 0] = src[y * stride + x * 8 + 0];
            pict->data[0][y * pict->linesize[0] + x * 3 + 1] = src[y * stride + x * 8 + 1];
            pict->data[0][y * pict->linesize[0] + x * 3 + 2] = src[y * stride + x * 8 + 2];
        }
    }
}

static AVFrame* get_video_frame(PGE_VideoRecording_VP8* THIS, OutputStream* ost)
{
    AVCodecContext* c = ost->enc;

    /* find a next frame */
    while(THIS->first_timestamp == 0 || av_compare_ts(ost->next_pts, ost->enc->time_base,
            THIS->next_frame.timestamp - THIS->first_timestamp, AVRational { 1, 1000000 }) >= 0)
    {
        if(THIS->next_frame.end_frame)
            return NULL;

        THIS->current_frame = std::move(THIS->next_frame);

        while(!THIS->has_frame())
        {
            // no more samples
            if(THIS->exit_requested)
                return NULL;

            PGE_Delay(1);
            continue;
        }

        THIS->next_frame = THIS->dequeue_frame();

        if(THIS->first_timestamp == 0)
            THIS->first_timestamp = THIS->next_frame.timestamp;
    }

    /* check if we want to generate more frames */
    // if (ost->next_pts > ost->input->frame_count)
    //     return NULL;

    /* when we pass a frame to the encoder, it may keep a reference to it
     * internally; make sure we do not overwrite it here */
    if(av_frame_make_writable(ost->frame) < 0)
        return NULL;

    if(c->pix_fmt != AV_PIX_FMT_RGB24)
    {
        /* as we only generate a RGB24 picture, we must convert it
         * to the codec pixel format if needed */
        if(!ost->sws_ctx)
        {
            ost->sws_ctx = sws_getContext(c->width, c->height,
                                          AV_PIX_FMT_RGB24,
                                          c->width, c->height,
                                          c->pix_fmt,
                                          SWS_BICUBIC, NULL, NULL, NULL);

            if(!ost->sws_ctx)
            {
                pLogWarning("Could not initialize the conversion context");
                return NULL;
            }
        }

        (THIS->spec.downscale_video ? fill_rgb_image_downscale : fill_rgb_image)(ost->tmp_frame, THIS->current_frame.pixels.data(), c->width, c->height, THIS->spec.frame_pitch);
        sws_scale(ost->sws_ctx, (const uint8_t* const*) ost->tmp_frame->data,
                  ost->tmp_frame->linesize, 0, c->height, ost->frame->data,
                  ost->frame->linesize);
    }
    else
    {
        (THIS->spec.downscale_video ? fill_rgb_image_downscale : fill_rgb_image)(ost->frame, THIS->current_frame.pixels.data(), c->width, c->height, THIS->spec.frame_pitch);
    }

    ost->frame->pts = ost->next_pts;

    while(av_compare_ts(ost->next_pts, ost->enc->time_base,
                        THIS->next_frame.timestamp - THIS->first_timestamp, AVRational{ 1, 1000000 }) < 0)
    {
        ost->next_pts++;
    }

    return ost->frame;
}

/*
 * encode one video frame and send it to the muxer
 * return 1 when encoding is finished, 0 otherwise
 */
static int write_video_frame(PGE_VideoRecording_VP8* THIS, AVFormatContext* oc, OutputStream* ost)
{
    auto video_frame = get_video_frame(THIS, ost);

    if(!video_frame)
        return 1;

    return write_frame(oc, ost->enc, ost->st, video_frame, ost->tmp_pkt);
}

static void close_stream(OutputStream* ost)
{
    avcodec_free_context(&ost->enc);
    av_frame_free(&ost->frame);
    av_frame_free(&ost->tmp_frame);
    av_packet_free(&ost->tmp_pkt);
    sws_freeContext(ost->sws_ctx);
    ost->sws_ctx = NULL;
    swr_free(&ost->swr_ctx);
    ost->st = nullptr;
}


const char* PGE_VideoRecording_VP8::extension() const
{
    return "webm";
}

bool PGE_VideoRecording_VP8::initialize(const char* filename)
{
    pLogInfo("PGEVideoRec: starting VP8/opus recording to [%s]", filename);

    const AVCodec* audio_codec, *video_codec;
    int ret;
    AVDictionary* opt = NULL;

    /* allocate the output media context */
    avformat_alloc_output_context2(&oc, NULL, "webm", filename);

    if(!oc)
        return false;

    const AVOutputFormat* fmt = oc->oformat;

    /* Add the audio and video streams using the default format codecs
     * and initialize the codecs. */
    if(fmt->video_codec == AV_CODEC_ID_NONE || !init_stream(&video_st, oc, &video_codec, AV_CODEC_ID_VP8))
    {
        clean_up();
        return false;
    }

    if(spec.audio_enabled && fmt->audio_codec != AV_CODEC_ID_NONE && set_src_sample_fmt())
    {
        if(!init_stream(&audio_st, oc, &audio_codec, fmt->audio_codec))
        {
            spec.audio_enabled = false;
            close_stream(&audio_st);
        }
    }
    else
        spec.audio_enabled = false;

    /* Now that all the parameters are set, we can open the audio and
     * video codecs and allocate the necessary encode buffers. */
    if(video_st.st)
    {
        if(!open_video(this, video_codec, &video_st, opt))
        {
            clean_up();
            return false;
        }
    }

    if(spec.audio_enabled && audio_st.st)
    {
        if(!open_audio(this, audio_codec, &audio_st, opt))
            spec.audio_enabled = false;
    }

    av_dump_format(oc, 0, filename, 1);

    /* open the output file, if needed */
    if(!(fmt->flags & AVFMT_NOFILE))
    {
        ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
        if(ret < 0)
        {
            pLogWarning("PGEVideoRec: could not open destination [%s]: %s", filename, av_err2str(ret));
            clean_up();
            return false;
        }
    }

    /* Write the stream header, if any. */
    ret = avformat_write_header(oc, &opt);

    if(ret < 0)
    {
        pLogWarning("PGEVideoRec: could not write headers: %s", av_err2str(ret));
        clean_up();
        return false;
    }

    return true;
}

bool PGE_VideoRecording_VP8::encoding_thread()
{
    bool have_video = video_st.st;
    bool have_audio = audio_st.st;

    bool encode_video = have_video;
    bool encode_audio = have_audio;

    while(encode_video || encode_audio)
    {
        /* select the stream to encode */
        if(encode_video && (!encode_audio || av_compare_ts(video_st.next_pts, video_st.enc->time_base, audio_st.next_pts, audio_st.enc->time_base) <= 0))
            encode_video = !write_video_frame(this, oc, &video_st);
        else
            encode_audio = !write_audio_frame(this, oc, &audio_st);
    }

    av_write_trailer(oc);

    clean_up();

    return true;
}

PGE_VideoRecording_VP8::PGE_VideoRecording_VP8() :
    PGE_VideoRecording()
{
    SDL_assert_release(!av_log_mutex); // only one PGE_VideoRecording_VP8 instance may exist at once
    av_log_mutex = SDL_CreateMutex();
}

PGE_VideoRecording_VP8::~PGE_VideoRecording_VP8()
{
    clean_up();

    SDL_DestroyMutex(av_log_mutex);
    av_log_mutex = nullptr;
}

void PGE_VideoRecording_VP8::clean_up()
{
    if(video_st.st)
        close_stream(&video_st);

    if(audio_st.st)
        close_stream(&audio_st);

    if(oc)
    {
        if(!(oc->oformat->flags & AVFMT_NOFILE))
            avio_closep(&oc->pb); /* Close the output file. */

        avformat_free_context(oc);
        oc = nullptr;
    }

#if HAS_CHANNELLAYOUT
    av_channel_layout_uninit(&src_ch_layout);
#endif
}

std::unique_ptr<PGE_VideoRecording> PGE_new_recording_VP8(const PGE_VideoSpec& spec)
{
    av_log_set_callback(av_log_callback_pLog);
    std::unique_ptr<PGE_VideoRecording> ret(new PGE_VideoRecording_VP8());
    ret->spec = spec;
    // ret->spec.audio_enabled = false;
    return ret;
}


================================================
FILE: lib/pge_video_rec/pge_video_rec.h
================================================
/*
 *
 * Copyright (c) 2024 ds-sloth and Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef PGE_VIDEO_REC_H
#define PGE_VIDEO_REC_H

#include <cstdint>
#include <memory>
#include <vector>
#include <deque>

struct SDL_mutex;
struct SDL_Thread;

struct PGE_VideoFrame
{
    std::vector<uint8_t> pixels;
    uint64_t timestamp = 0;
    bool end_frame = false;

    PGE_VideoFrame(const PGE_VideoFrame&) = delete;
    PGE_VideoFrame& operator=(const PGE_VideoFrame&) = delete;

    PGE_VideoFrame() = default;
    PGE_VideoFrame(PGE_VideoFrame&&) = default;
    PGE_VideoFrame& operator=(PGE_VideoFrame&&) = default;
};

struct PGE_AudioChunk
{
    std::vector<uint8_t> audio_buffer;

    PGE_AudioChunk(const PGE_AudioChunk&) = delete;
    PGE_AudioChunk& operator=(const PGE_AudioChunk&) = delete;

    PGE_AudioChunk() = default;
    PGE_AudioChunk(PGE_AudioChunk&&) = default;
    PGE_AudioChunk& operator=(PGE_AudioChunk&&) = default;
};

struct PGE_VideoSpec
{
    //! width of frame in pixels
    int frame_w = 0;

    //! height of frame in pixels
    int frame_h = 0;

    //! pitch of frame in bytes
    int frame_pitch = 0;

    //! video framerate in FPS
    int frame_rate = 0;

    //! video quality for FFMPEG. lower is better
    int video_quality = 10;

    //! whether video should be scaled down by 2x
    bool downscale_video = false;

    //! whether the video should include audio
    bool audio_enabled = false;

    //! audio sample rate in Hz
    int audio_sample_rate = 0;

    //! audio channel count
    int audio_channel_count = 0;

    //! audio sample format (uses SDL_MixerX sample formats)
    int audio_sample_format = 0;
};


/*!
 * \brief Abstract class representing a video sink (implemented in pge_video_sink.cpp)
 */
class PGE_VideoSink
{
private:
    std::deque<PGE_VideoFrame> queue_frame;
    SDL_mutex* mutex_frame = nullptr;

    std::deque<PGE_AudioChunk> queue_audio;
    SDL_mutex* mutex_audio = nullptr;

public:
    PGE_VideoSpec spec;

    PGE_VideoSink();
    virtual ~PGE_VideoSink();

    bool has_frame();
    int frame_backlog();
    int enqueue_frame(PGE_VideoFrame&& frame, int max_backlog);
    PGE_VideoFrame dequeue_frame();

    bool has_audio();
    void enqueue_audio(PGE_AudioChunk&& chunk);
    PGE_AudioChunk dequeue_audio();
};

/*!
 * \brief Abstract class representing a video recording
 */
struct PGE_VideoRecording : public PGE_VideoSink
{
    bool exit_requested = false;

    // returns the best file extension for the recording type
    virtual const char* extension() const = 0;

    // should be called by a main thread, returns false on failure
    virtual bool initialize(const char* filename) = 0;

    // should be called by an encoding thread, terminates once the empty end frame has been dequeued.
    virtual bool encoding_thread() = 0;
};

std::unique_ptr<PGE_VideoRecording> PGE_new_recording_GIF(const PGE_VideoSpec& spec);
std::unique_ptr<PGE_VideoRecording> PGE_new_recording_VP8(const PGE_VideoSpec& spec);

#endif // PGE_VIDEO_REC_H


================================================
FILE: lib/pge_video_rec/pge_video_sink.cpp
================================================
/*
 *
 * Copyright (c) 2020-2024 ds-sloth and Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "pge_video_rec.h"
#include <SDL2/SDL_mutex.h>

PGE_VideoSink::PGE_VideoSink()
{
    mutex_frame = SDL_CreateMutex();
    mutex_audio = SDL_CreateMutex();
}

PGE_VideoSink::~PGE_VideoSink()
{
    if(mutex_frame)
        SDL_DestroyMutex(mutex_frame);

    mutex_frame = nullptr;

    if(mutex_audio)
        SDL_DestroyMutex(mutex_audio);

    mutex_audio = nullptr;
}

bool PGE_VideoSink::has_frame()
{
    SDL_LockMutex(mutex_frame);
    bool ret = !queue_frame.empty();
    SDL_UnlockMutex(mutex_frame);
    return ret;
}

int PGE_VideoSink::frame_backlog()
{
    SDL_LockMutex(mutex_frame);
    int ret = queue_frame.size();
    SDL_UnlockMutex(mutex_frame);
    return ret;
}

int PGE_VideoSink::enqueue_frame(PGE_VideoFrame&& frame, int max_backlog)
{
    SDL_LockMutex(mutex_frame);
    int backlog_size = queue_frame.size();

    if(max_backlog >= 0 && backlog_size < max_backlog)
    {
        queue_frame.push_back(std::move(frame));
        backlog_size += 1;
    }

    SDL_UnlockMutex(mutex_frame);

    return backlog_size;
}

PGE_VideoFrame PGE_VideoSink::dequeue_frame()
{
    SDL_LockMutex(mutex_frame);
    PGE_VideoFrame ret = std::move(queue_frame.front());
    queue_frame.pop_front();
    SDL_UnlockMutex(mutex_frame);
    return ret;
}

bool PGE_VideoSink::has_audio()
{
    SDL_LockMutex(mutex_audio);
    bool ret = !queue_audio.empty();
    SDL_UnlockMutex(mutex_audio);
    return ret;
}

void PGE_VideoSink::enqueue_audio(PGE_AudioChunk&& chunk)
{
    SDL_LockMutex(mutex_audio);
    queue_audio.push_back(std::move(chunk));
    SDL_UnlockMutex(mutex_audio);
}

PGE_AudioChunk PGE_VideoSink::dequeue_audio()
{
    SDL_LockMutex(mutex_audio);
    PGE_AudioChunk ret = std::move(queue_audio.front());
    queue_audio.pop_front();
    SDL_UnlockMutex(mutex_audio);
    return ret;
}


================================================
FILE: lib/sdl_proxy/16m/std_16m.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../sdl_timer.h"

#include <nds.h>

#ifndef __CALICO__

uint32_t curTime_ticks = 0u;
bool inited = false;

void s_updateTimer()
{
    if(!inited)
    {
        timerStart(1, ClockDivider_1024, 0, nullptr);
        timerStart(2, (ClockDivider)TIMER_CASCADE, 0, nullptr);
        inited = true;
    }

    curTime_ticks = TIMER_DATA(1) + (TIMER_DATA(2) << 16);
}

uint32_t SDL_GetTicks()
{
    s_updateTimer();

    return (uint64_t)curTime_ticks * 1000 / (BUS_CLOCK>>10);
}

uint64_t SDL_GetMicroTicks()
{
    s_updateTimer();

    return (uint64_t)curTime_ticks * 1000000 / (BUS_CLOCK>>10);
}

void SDL_Delay(int ms)
{
    uint64_t want = SDL_GetMicroTicks() + ms * 1000;

    while(SDL_GetMicroTicks() < want)
        swiDelay(0x126f); // ~120us
}

#endif

#ifdef __CALICO__

uint32_t SDL_GetTicks()
{
    return (uint64_t)tickGetCount() * 1000 / TICK_FREQ;
}

uint64_t SDL_GetMicroTicks()
{
    return (uint64_t)tickGetCount() * 1000000 / TICK_FREQ;
}

void SDL_Delay(int ms)
{
    threadSleep(ms * 1000);
}

#endif


================================================
FILE: lib/sdl_proxy/3ds/3ds-audio-lib.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <string.h>
#include "3ds-audio-lib.h"
#include <tremor/ivorbisfile.h>
#include <3ds.h>
#include <cstdlib>
#include <gme/gme.h>

#include <Logger/logger.h>

volatile SimpleChannel channels[NUM_CHANNELS];
char* audio_buffer = NULL;

LightEvent sound_event;
Thread sound_thread;
volatile bool sound_quit = false;  // Quit flag
void (*channel_done_callback)(int) = nullptr;


void myAudioCallback(void* const /*nul_*/)
{
    if(sound_quit)
        return;

    LightEvent_Signal(&sound_event);
}

inline SoundId getSoundId(volatile SimpleChannel* channel)
{
    return channel->channel_id + channel->index * 32;
}

inline volatile SimpleChannel* validateSoundId(SoundId id)
{
    if(id == INVALID_ID) return nullptr;

    int channel_id = id % 32;
    SoundId index = id / 32;

    if(channels[channel_id].index == index)
    {
        return &channels[channel_id];
    }

    return nullptr;
}

// should only be called by the audio thread if it is running
void closeChannel(volatile SimpleChannel* channel)
{
    if(channel->format == FORMAT_PCM_FILE && channel->data_pointer != nullptr)
    {
        fclose((FILE*)channel->data_pointer);
    }

    if(channel->format == FORMAT_OGG_FILE && channel->data_pointer != nullptr)
    {
        ov_clear((OggVorbis_File*)channel->data_pointer);
        free(channel->data_pointer);
        // OGG does not free its pointer.
    }

    if(channel->format == FORMAT_GME_FILE && channel->data_pointer != nullptr)
    {
        gme_delete((Music_Emu*)channel->data_pointer);
        // GME frees its pointer.
    }

    // DO NOT free the data pointer if it is a PCM_MEM because it is shared.
    channel->data_pointer = nullptr;
    channel->index ++;

    if(channel_done_callback)
        channel_done_callback(channel->channel_id);
}

// returns true on success, false on failure
bool fillBuffer(volatile SimpleChannel* channel, volatile ndspWaveBuf* wavebuf)
{
    if(wavebuf->status != NDSP_WBUF_DONE) return false;

    // load data into wavebuf...
    if(channel->format == FORMAT_PCM_FILE && channel->data_pointer != nullptr)
    {
        uint32_t* buffer_loc = (uint32_t*)wavebuf->data_pcm16;  // in 2x16-bit samples
        wavebuf->nsamples = 0;
        size_t samplesToRead = BUFFER_SIZE / sizeof(*buffer_loc);

        while(samplesToRead > 0)
        {
            int samples = fread(buffer_loc, sizeof(*buffer_loc), samplesToRead, (FILE*)channel->data_pointer);

            if(samples == 0)
            {
                if(channel->loops == 0)
                {
                    closeChannel(channel);
                    break;
                }
                else
                {
                    if(channel->loops > 0)
                        channel->loops -= 1;

                    fseek((FILE*)channel->data_pointer, channel->data_idx, SEEK_SET);
                }
            }

            wavebuf->nsamples += samples;
            buffer_loc += samples;
            samplesToRead -= samples;
        }

        if(channel->stereo)
        {
            ndspChnWaveBufAdd(channel->channel_id, (ndspWaveBuf*)wavebuf);
            DSP_FlushDataCache(wavebuf->data_pcm16,
                               wavebuf->nsamples * sizeof(*buffer_loc));
        }
        else
        {
            wavebuf->nsamples *= 2;
            ndspChnWaveBufAdd(channel->channel_id, (ndspWaveBuf*)wavebuf);
            DSP_FlushDataCache(wavebuf->data_pcm16,
                               wavebuf->nsamples / 2 * sizeof(*buffer_loc));
        }

        return true;
    }

    if(channel->format == FORMAT_PCM_MEM && channel->data_pointer != nullptr)
    {
        size_t bytesToCopy = (channel->data_size - channel->data_idx);

        if(bytesToCopy == 0)
        {
            if(channel->loops == 0)
            {
                closeChannel(channel);
                return true;
            }
            else
            {
                if(channel->loops > 0)
                    channel->loops -= 1;

                channel->data_idx = 0;
                bytesToCopy = channel->data_size;
            }
        }

        if(bytesToCopy > BUFFER_SIZE) bytesToCopy = BUFFER_SIZE;

        memcpy(wavebuf->data_pcm16, (char*)channel->data_pointer + channel->data_idx, bytesToCopy);
        channel->data_idx += bytesToCopy;

        if(channel->stereo)
        {
            wavebuf->nsamples = bytesToCopy / 4;
            ndspChnWaveBufAdd(channel->channel_id, (ndspWaveBuf*)wavebuf);
            DSP_FlushDataCache(wavebuf->data_pcm16, bytesToCopy);
        }
        else
        {
            wavebuf->nsamples = bytesToCopy / 2;
            ndspChnWaveBufAdd(channel->channel_id, (ndspWaveBuf*)wavebuf);
            DSP_FlushDataCache(wavebuf->data_pcm16, bytesToCopy);
        }

        return true;
    }

    if(channel->format == FORMAT_OGG_FILE && channel->data_pointer != nullptr)
    {
        char* buffer_loc = (char*)wavebuf->data_pcm16;  // in 2x16-bit samples
        wavebuf->nsamples = 0;
        size_t samplesToRead = BUFFER_SIZE;

        while(samplesToRead > 0)
        {
            // Decode bufferSize samples from opusFile_ into buffer,
            // storing the number of samples that were decoded (or error)
            int samples = ov_read((OggVorbis_File*)channel->data_pointer, buffer_loc, samplesToRead, nullptr);

            if(samples == 0)
            {
                if(channel->loops == 0)
                {
                    closeChannel(channel);
                    break;
                }
                else
                {
                    if(channel->loops > 0)
                        channel->loops -= 1;

                    ov_pcm_seek((OggVorbis_File*)channel->data_pointer, 0);
                }
            }

            wavebuf->nsamples += samples;
            buffer_loc += samples;
            samplesToRead -= samples;
        }

        // depends strongly on stereo-ness......
        if(channel->stereo)
        {
            wavebuf->nsamples /= 4;
            ndspChnWaveBufAdd(channel->channel_id, (ndspWaveBuf*)wavebuf);
            DSP_FlushDataCache(wavebuf->data_pcm16,
                               wavebuf->nsamples * 4);
        }
        else
        {
            wavebuf->nsamples /= 2;
            ndspChnWaveBufAdd(channel->channel_id, (ndspWaveBuf*)wavebuf);
            DSP_FlushDataCache(wavebuf->data_pcm16,
                               wavebuf->nsamples * 2);
        }

        return true;
    }

    if(channel->format == FORMAT_GME_FILE && channel->data_pointer != nullptr)
    {
        short* buffer_loc = (short*)wavebuf->data_pcm16;  // in 2x16-bit samples
        size_t samplesToRead = BUFFER_SIZE / sizeof(short);

        if(gme_track_ended((Music_Emu*)channel->data_pointer))
        {
            if(channel->loops == 0)
            {
                closeChannel(channel);
                return false;
            }
            else
            {
                if(channel->loops > 0)
                    channel->loops -= 1;

                gme_start_track((Music_Emu*)channel->data_pointer, 0);
            }
        }

        gme_play((Music_Emu*)channel->data_pointer, samplesToRead, buffer_loc);

        wavebuf->nsamples = samplesToRead / 2;
        ndspChnWaveBufAdd(channel->channel_id, (ndspWaveBuf*)wavebuf);
        DSP_FlushDataCache(wavebuf->data_pcm16,
                           wavebuf->nsamples * 4);
        return true;
    }

    return false;
}

void audioThread(void* /*nul_*/)
{
    while(!sound_quit)
    {
        for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
        {
            volatile SimpleChannel* channel = &channels[ci];

            if(channel->kill && channel->format != FORMAT_LOADING)
            {
                closeChannel(channel);
                ndspChnWaveBufClear(channel->channel_id);

                channel->format = FORMAT_FREE;
                channel->kill = false;
            }
            else if(channel->format != FORMAT_FREE && channel->format != FORMAT_LOADING)
            {
                for(size_t wi = 0; wi < NUM_BUFFERS; wi++)
                {
                    ndspWaveBuf* wavebuf = (ndspWaveBuf*) & (channel->wavebufs[wi]);

                    if(wavebuf->status != NDSP_WBUF_DONE) continue;

                    if(!fillBuffer(channel, wavebuf) && !ndspChnIsPlaying(channel->channel_id))
                        channel->format = FORMAT_FREE;

                    // printf("Responding at %llu...\n", osGetTime());
                }
            }
        }

        LightEvent_Wait(&sound_event);
    }
}

int loadWaveFileData(FILE* f, uint16_t* nChannels, uint32_t* sampleRate, uint32_t* length, uint32_t* restart_pos)
{
    // all of this is little endian code
    fseek(f, 22, SEEK_SET);
    fread(nChannels, 2, 1, f);
    fread(sampleRate, 4, 1, f);

    uint32_t chunktype = 0;
    uint32_t chunksize = 0;

    int i = 0;

    // find correct header
    uint32_t read_pos = 36;

    do
    {
        read_pos += chunksize;
        fseek(f, read_pos, SEEK_SET);
        fread(&chunktype, 4, 1, f);
        fread(&chunksize, 4, 1, f);
        i++;
        read_pos += 8;
    }
    while(chunktype != 0x61746164 && i < 10);

    if(i == 10)
    {
        *nChannels = 0;
        chunksize = 0;
        read_pos = 0;
    }

    if(length)
        *length = chunksize;

    if(restart_pos)
        *restart_pos = read_pos;

    return 0;
}

SoundId playSoundWAV(const char* path, int loops)
{
    // printf("Playin sound %s\n", path);
    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        volatile SimpleChannel* channel = &channels[ci];

        if(channel->format != FORMAT_FREE) continue;

        FILE* f = fopen(path, "rb");

        if(!f)
            return INVALID_ID;

        uint16_t nChannels;
        uint32_t sampleRate;
        uint32_t restart_pos;

        loadWaveFileData(f, &nChannels, &sampleRate, nullptr, &restart_pos);

        if(nChannels == 0 || nChannels > 2 || restart_pos < 44)
        {
            fclose(f);
            return INVALID_ID;
        }

        ndspChnReset(ci);
        ndspChnSetInterp(ci, NDSP_INTERP_POLYPHASE);
        ndspChnSetRate(channel->channel_id, sampleRate);

        channel->data_pointer = f;
        channel->data_idx = restart_pos;

        if(nChannels == 2)
        {
            ndspChnSetFormat(channel->channel_id, NDSP_FORMAT_STEREO_PCM16);
            channel->stereo = true;
        }
        else
        {
            ndspChnSetFormat(channel->channel_id, NDSP_FORMAT_MONO_PCM16);
            channel->stereo = false;
        }

        channel->format = FORMAT_PCM_FILE;
        channel->loops = loops;
        LightEvent_Signal(&sound_event);
        return getSoundId(channel);
    }

    return INVALID_ID;
}

SoundId playSoundMem(const WaveObject* wave, int loops)
{
    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        volatile SimpleChannel* channel = &channels[ci];

        if(channel->format != FORMAT_FREE) continue;

        ndspChnReset(ci);
        ndspChnSetInterp(ci, NDSP_INTERP_POLYPHASE);
        channel->data_pointer = (void*) wave->data;
        channel->data_idx = 0;
        channel->data_size = wave->length;

        if(wave->stereo)
        {
            ndspChnSetFormat(channel->channel_id, NDSP_FORMAT_STEREO_PCM16);
            channel->stereo = true;
        }
        else
        {
            ndspChnSetFormat(channel->channel_id, NDSP_FORMAT_MONO_PCM16);
            channel->stereo = false;
        }

        ndspChnSetRate(channel->channel_id, wave->sampleRate);
        channel->format = FORMAT_PCM_MEM;
        channel->loops = loops;
        LightEvent_Signal(&sound_event);
        return getSoundId(channel);
    }

    return INVALID_ID;
}

void loadOGG_Thread(void* passed_val)
{
    volatile SimpleChannel* channel = (volatile SimpleChannel*) passed_val;
    FILE* f = (FILE*) channel->data_pointer;
    channel->data_pointer = nullptr;

    OggVorbis_File* vf = (OggVorbis_File*)malloc(sizeof(OggVorbis_File));

    if(!vf)
    {
        fclose(f);
        channel->format = FORMAT_FREE;
        return;
    }

    if(ov_open(f, vf, nullptr, 0))
    {
        free(vf);
        fclose(f);
        channel->format = FORMAT_FREE;
        return;
    }

    int ci = channel->channel_id;

    ndspChnReset(ci);
    ndspChnSetInterp(ci, NDSP_INTERP_POLYPHASE);

    vorbis_info* vi = ov_info(vf, -1);

    if(vi->channels == 2)
    {
        ndspChnSetFormat(channel->channel_id, NDSP_FORMAT_STEREO_PCM16);
        channel->stereo = true;
    }
    else if(vi->channels == 1)
    {
        ndspChnSetFormat(channel->channel_id, NDSP_FORMAT_MONO_PCM16);
        channel->stereo = false;
    }
    else
    {
        ov_clear(vf);
        free(vf);
        channel->format = FORMAT_FREE;
        return;
    }

    ndspChnSetRate(channel->channel_id, vi->rate);
    channel->data_pointer = (void*)vf;
    channel->format = FORMAT_OGG_FILE;
    LightEvent_Signal(&sound_event);
}

SoundId playSoundOGG(const char* path, int loops)
{
    // printf("Playin music %s\n", path);
    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        volatile SimpleChannel* channel = &channels[ci];

        if(channel->format != FORMAT_FREE) continue;

        FILE* f = fopen(path, "rb");

        if(!f) return INVALID_ID;

        channel->loops = loops;
        channel->format = FORMAT_LOADING;
        channel->data_pointer = (void*)f;
        SoundId uniquePlayId = getSoundId(channel);

        // Set the thread priority to the main thread's priority ...
        int32_t priority = 0x30;
        svcGetThreadPriority(&priority, CUR_THREAD_HANDLE);
        // ... then add 1, as higher number => lower actual priority ...
        priority += 1;
        // ... finally, clamp it between 0x18 and 0x3F to guarantee that it's valid.
        priority = priority < 0x18 ? 0x18 : priority;
        priority = priority > 0x3F ? 0x3F : priority;

        Thread load_thread;
        load_thread = threadCreate(loadOGG_Thread, (void*)channel,
                                   THREAD_STACK_SZ, priority,
                                   0, true);

        if(load_thread)
            return uniquePlayId;
        else
        {
            fclose(f);
            channel->data_pointer = nullptr;
            channel->format = FORMAT_FREE;
        }
    }

    return INVALID_ID;
}

// void loadChannelGME(volatile SimpleChannel* channel)
// {

// }

SoundId playSoundGME(const char* path, int loops)
{
    // printf("Playin music GME %s\n", path);
    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        volatile SimpleChannel* channel = &channels[ci];

        if(channel->format != FORMAT_FREE) continue;

        channel->format = FORMAT_LOADING;
        channel->loops = loops;
        gme_open_file(path, (Music_Emu**) & (channel->data_pointer), 24000);

        if(!channel->data_pointer)
        {
            channel->format = FORMAT_FREE;
            return INVALID_ID;
        }

        ndspChnReset(ci);
        ndspChnSetInterp(ci, NDSP_INTERP_POLYPHASE);

        ndspChnSetFormat(ci, NDSP_FORMAT_STEREO_PCM16);
        ndspChnSetRate(channel->channel_id, 24000);

        channel->format = FORMAT_GME_FILE;
        SoundId uniquePlayId = getSoundId(channel);
        return uniquePlayId;
    }

    return INVALID_ID;
}

// Thanks ThiefMaster!
// https://stackoverflow.com/questions/5309471/getting-file-extension-in-c
const char* get_filename_ext(const char* filename)
{
    const char* dot = strrchr(filename, '.');

    if(!dot || dot == filename) return "";

    return dot + 1;
}

SoundId playSoundAuto(const char* path, int loops)
{
    const char* ext = get_filename_ext(path);

    if(!strcasecmp(ext, "ogg"))
        return playSoundOGG(path, loops);

    if(!strcasecmp(ext, "mp3"))
        return playSoundOGG(path, loops);

    if(!strcasecmp(ext, "wav"))
        return playSoundWAV(path, loops);
    else
        return playSoundGME(path, loops);
}

bool audioInit()
{
    LightEvent_Init(&sound_event, RESET_ONESHOT);
    ndspInit();

    ndspSetOutputMode(NDSP_OUTPUT_STEREO);

    // Allocate audio buffer
    const size_t bufferSize = BUFFER_SIZE * NUM_CHANNELS * NUM_BUFFERS;
    audio_buffer = (char*)linearAlloc(bufferSize);

    if(!audio_buffer)
    {
        pLogWarning("Failed to allocate audio buffer");
        return false;
    }

    // Reset callback function
    channel_done_callback = nullptr;

    // initialize channels and wavebufs
    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        channels[ci].channel_id = ci;
        channels[ci].format = FORMAT_FREE;
        channels[ci].index = 1;
        channels[ci].data_pointer = NULL;

        ndspChnReset(ci);
        ndspChnSetInterp(ci, NDSP_INTERP_POLYPHASE);

        memset((void*) &channels[ci].wavebufs, 0, sizeof(channels[ci].wavebufs));

        for(size_t wi = 0; wi < NUM_BUFFERS; wi++)
        {
            channels[ci].wavebufs[wi].data_vaddr = audio_buffer + BUFFER_SIZE * (ci * NUM_BUFFERS + wi);
            channels[ci].wavebufs[wi].status = NDSP_WBUF_DONE;
        }
    }

    // begin setting up threading structure...
    ndspSetCallback(myAudioCallback, NULL);

    // Thanks to @mkst from sm64 3ds port
    int cpu = 0; // application core

    if(R_SUCCEEDED(APT_SetAppCpuTimeLimit(30)))
        cpu = 1; // system core

    // Set the thread priority to the main thread's priority ...
    int32_t priority = 0x30;
    svcGetThreadPriority(&priority, CUR_THREAD_HANDLE);
    // ... then subtract 1, as lower number => higher actual priority ...
    priority -= 1;
    // ... finally, clamp it between 0x18 and 0x3F to guarantee that it's valid.
    priority = priority < 0x18 ? 0x18 : priority;
    priority = priority > 0x3F ? 0x3F : priority;

    sound_thread = threadCreate(audioThread, NULL,
                                THREAD_STACK_SZ, priority,
                                cpu, true);

    if(sound_thread)
        pLogDebug("Created audio thread at %p on %s core", (void*)sound_thread, cpu ? "os" : "application");
    else
        pLogWarning("Failed to create audio thread");

    return (bool)sound_thread;
}

// Audio de-initialisation code
// Stops playback and frees the primary audio buffer
void audioExit()
{
    sound_quit = true;
    LightEvent_Signal(&sound_event);

    // Free the audio thread
    threadJoin(sound_thread, UINT64_MAX);
    threadFree(sound_thread);

    // reset channel done callback
    channel_done_callback = nullptr;

    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        closeChannel(&channels[ci]);
        ndspChnReset(channels[ci].channel_id);
    }

    linearFree(audio_buffer);

    ndspExit();
}

void audioPause()
{
    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        ndspChnSetPaused(ci, true);
    }
}

void audioResume()
{
    for(size_t ci = 0; ci < NUM_CHANNELS; ci++)
    {
        ndspChnSetPaused(ci, false);
    }
}

bool audioPauseSingle(SoundId soundId)
{
    volatile SimpleChannel* channel = validateSoundId(soundId);

    if(channel)
        ndspChnSetPaused(channel->channel_id, true);

    return channel;
}

bool audioResumeSingle(SoundId soundId)
{
    volatile SimpleChannel* channel = validateSoundId(soundId);

    if(channel)
        ndspChnSetPaused(channel->channel_id, false);

    return channel;
}

bool audioSoundPlaying(SoundId soundId)
{
    return validateSoundId(soundId);
}

void killSound(SoundId soundId)
{
    volatile SimpleChannel* channel = validateSoundId(soundId);

    if(channel) channel->kill = true;
}

WaveObject* audioLoadWave(const char* path)
{
    FILE* f = fopen(path, "rb");

    if(!f) return nullptr;

    WaveObject* wave = (WaveObject*) malloc(sizeof(WaveObject));
    uint16_t nChannels;

    loadWaveFileData(f, &nChannels, &wave->sampleRate, &wave->length, nullptr);

    if(nChannels == 2)
        wave->stereo = true;
    else if(nChannels == 1)
        wave->stereo = false;
    else
    {
        free(wave);
        fclose(f);
        return nullptr;
    }

    if(wave->length > 256 * 1024)
    {
        free(wave);
        fclose(f);
        return nullptr;
    }

    char* temp_buf = (char*) malloc(wave->length);

    if(!temp_buf)
    {
        free(wave);
        fclose(f);
        return nullptr;
    }

    wave->data = temp_buf;
    uint32_t to_read = wave->length;

    while(to_read)
    {
        unsigned int samples_read = fread(temp_buf, 1, to_read, f);

        if(!samples_read) break;

        to_read -= samples_read;
        temp_buf += samples_read;
    }

    fclose(f);

    if(!to_read)
    {
        return wave;
    }
    else
    {
        free((void*)wave->data);
        free(wave);
        return nullptr;
    }
}

void audioFreeWave(WaveObject* wave)
{
    free((void*)wave->data);
    free(wave);
}

void audioSetChannelDoneCallback(void (*cb)(int))
{
    channel_done_callback = cb;
}


================================================
FILE: lib/sdl_proxy/3ds/3ds-audio-lib.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <3ds.h>

#ifndef NUM_CHANNELS
// must *never* exceed 32
#define NUM_CHANNELS 16
#define NUM_BUFFERS 4
#define BUFFER_SIZE (128 * (44100 / 1000))

#define THREAD_STACK_SZ 32 * 1024

#endif

typedef uintptr_t SoundId;

typedef enum _CHANNEL_FORMAT
{
    FORMAT_FREE = 1 << 0,
    FORMAT_LOADING = 1 << 1,
    FORMAT_PCM_FILE = 1 << 2,
    FORMAT_OGG_FILE = 1 << 3,
    FORMAT_PCM_MEM = 1 << 4,
    FORMAT_GME_FILE = 1 << 5,
} CHANNEL_FORMAT;

typedef struct _SimpleChannel
{
    int channel_id;
    CHANNEL_FORMAT format;
    void* data_pointer;
    size_t data_idx;
    size_t data_size;
    ndspWaveBuf wavebufs[NUM_BUFFERS];
    bool kill;
    bool stereo;
    int loops;
    SoundId index;
} SimpleChannel;

typedef struct _WaveObject
{
    bool stereo;
    uint32_t sampleRate;
    const char* data;
    uint32_t length;
} WaveObject;

static const SoundId INVALID_ID = 0;

bool audioInit();

// Audio de-initialisation code
// Stops playback and frees the primary audio buffer
void audioExit();

void audioPause();
void audioResume();

bool audioPauseSingle(SoundId soundId);
bool audioResumeSingle(SoundId soundId);

bool audioSoundPlaying(SoundId soundId);

const char* get_filename_ext(const char* filename);

SoundId playSoundWAV(const char* path, int loops = 0);

SoundId playSoundMem(const WaveObject* wave, int loops = 0);

SoundId playSoundOGG(const char* path, int loops = -1);

SoundId playSoundGME(const char* path, int loops = -1);

SoundId playSoundAuto(const char* path, int loops = -1);

void killSound(SoundId soundId);

WaveObject* audioLoadWave(const char* path);

void audioFreeWave(WaveObject* wave);

void audioSetChannelDoneCallback(void (*cb)(int));


================================================
FILE: lib/sdl_proxy/3ds/mixer_3ds.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef __3DS__
#error This file should only be built on 3DS.
#endif

#include <string>
#include <set>
#include <unordered_map>

#include <cstring>
#include <cstdlib>

#include "../mixer.h"
#include "3ds-audio-lib.h"

static SoundId* cur_sound = nullptr;

static std::set<const std::string*> sound_stream_paths;
static std::set<const std::string*> music_stream_paths;
static std::unordered_map<const std::string*, SoundId> sound_id_music_map;


static bool MixPlatform_NoPreload(const char* path)
{
    // if path is not WAV, for now
    const char* ext = get_filename_ext(path);

    if(strcasecmp(ext, "wav"))
        return true;
    else
        return false;
}

int MixPlatform_PlayStream(int channel, const char* path, int loops)
{
    if(!cur_sound || channel < 0)
    {
        playSoundAuto(path, loops);
    }
    else
    {
        killSound(cur_sound[channel]);
        cur_sound[channel] = playSoundAuto(path, loops);
    }

    return 0;
}


int Mix_Init(int flags)
{
    // These codecs only supported
    return flags & (MIX_INIT_OGG);
}

void Mix_Quit()
{
    for(auto* it : sound_stream_paths)
        delete it;

    sound_stream_paths.clear();

    for(auto* it : music_stream_paths)
        delete it;

    music_stream_paths.clear();

    sound_id_music_map.clear();
}

int Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize)
{
    (void)frequency;
    (void)format;
    (void)channels;
    (void)chunksize;

    return audioInit() ? 0 : -1;
}

int Mix_QuerySpecEx(SDL_AudioSpec* out_spec)
{
    memset(out_spec, 0, sizeof(SDL_AudioSpec));
    out_spec->channels = 2;
    out_spec->samples = 2048;
    out_spec->freq = 32728;
    out_spec->format = AUDIO_S16SYS;
    return 0;
}

void Mix_CloseAudio()
{
    if(cur_sound)
    {
        free(cur_sound);
        cur_sound = nullptr;
    }

    audioExit();
}

int Mix_VolumeMusic(int volume)
{
    (void)volume;
    return volume;
}

int Mix_AllocateChannels(int numchans)
{
    (void)numchans;
    return 0;
}

Mix_Chunk* Mix_LoadWAV(const char* path)
{
    // remove arguments from path
    char* path2 = strdup(path);

    if(path2)
    {
        for(int i = 0; path2[i] != '\0'; i++)
        {
            if(path2[i] == '|')
                path2[i] = '\0';
        }
    }

    const char* path_use = path2 ? path2 : path;

    Mix_Chunk* ret;

    if(MixPlatform_NoPreload(path_use) || (ret = (Mix_Chunk*)audioLoadWave(path_use)) == nullptr)
    {
        const std::string* s = new(std::nothrow) const std::string(path_use);

        if(!s)
            return nullptr;

        sound_stream_paths.insert(s);
        ret = (Mix_Chunk*)s;
    }

    if(path2)
        free(path2);

    return ret;
}

const char* Mix_GetError()
{
    return "";
}

inline SoundId playSoundMaybeStream(Mix_Chunk* chunk, int loops)
{
    auto it = sound_stream_paths.find((const std::string*)chunk);

    if(it != sound_stream_paths.end())
    {
        return playSoundAuto(((const std::string*)chunk)->c_str(), loops);
    }

    return playSoundMem((WaveObject*)chunk, loops);
}

int Mix_PlayChannel(int channel, Mix_Chunk* chunk, int loops)
{
    if(!cur_sound || channel < 0)
    {
        playSoundMaybeStream(chunk, loops);
        return 0;
    }

    killSound(cur_sound[channel]);
    cur_sound[channel] = playSoundMaybeStream(chunk, loops);
    return 0;
}

int Mix_PlayChannelVol(int channel, Mix_Chunk* chunk, int loops, int volume)
{
    (void)volume;
    return Mix_PlayChannel(channel, chunk, loops);
}

int Mix_SetPanning(int channel, uint8_t left, uint8_t right)
{
    UNUSED(channel);
    UNUSED(left);
    UNUSED(right);
    return -1;
}

int Mix_ReserveChannels(int channels)
{
    cur_sound = (SoundId*)malloc(sizeof(SoundId) * channels);

    for(int i = 0; i < channels; i++)
    {
        cur_sound[i] = INVALID_ID;
    }

    return 0;
}

void Mix_PauseAudio(int pause)
{
    if(pause)
        audioPause();
    else
        audioResume();
}

Mix_Music* Mix_LoadMUS(const char* path)
{
    Mix_Music* ret;
    // remove arguments from path
    char* path2 = strdup(path);

    if(path2)
    {
        for(int i = 0; path2[i] != '\0'; i++)
        {
            if(path2[i] == '|')
                path2[i] = '\0';
        }
    }

    const char* path_use = path2 ? path2 : path;

    const std::string* s = new(std::nothrow) const std::string(path_use);

    if(!s)
        return nullptr;

    music_stream_paths.insert(s);
    ret = (Mix_Music*)s;

    if(path2)
        free(path2);

    return ret;
}

int Mix_VolumeMusicStream(Mix_Music* music, int volume)
{
    (void)music;
    (void)volume;
    return 0;
}

int Mix_HaltMusicStream(Mix_Music* music)
{
    killSound((SoundId)music);
    return 0;
}
int Mix_FadeOutMusicStream(Mix_Music* music, int ms)
{
    (void)ms;
    killSound((SoundId)music);
    return 0;
}
int Mix_HaltChannel(int channel)
{
    if(cur_sound && channel >= 0)
        killSound(cur_sound[channel]);

    return 0;
}

int Mix_PlayingMusicStream(Mix_Music* music)
{
    return audioSoundPlaying((SoundId)music);
}

int Mix_PausedMusicStream(Mix_Music* music)
{
    return audioSoundPlaying((SoundId)music);
}

int Mix_PauseMusicStream(Mix_Music* music)
{
    return (bool)audioPauseSingle((SoundId)music);
}

int Mix_ResumeMusicStream(Mix_Music* music)
{
    return (bool)audioResumeSingle((SoundId)music);
}

int Mix_PlayMusic(Mix_Music* music, int loops)
{
    const std::string* path_use = reinterpret_cast<const std::string*>(music);

    SoundId ret = playSoundAuto(path_use->c_str(), loops);
    sound_id_music_map.insert({path_use, ret});

    return 0;
}

int Mix_PlayMusicStream(Mix_Music* music, int loops)
{
    return Mix_PlayMusic(music, loops);
}

int Mix_SetFreeOnStop(Mix_Music* music, int free_on_stop)
{
    const std::string* path_use = reinterpret_cast<const std::string*>(music);

    if(free_on_stop)
        sound_id_music_map.erase(path_use);

    return 0;
}

int Mix_FadeInMusic(Mix_Music* music, int loops, int fadeInMs)
{
    (void)fadeInMs;
    return Mix_PlayMusic(music, loops);
}

const char* Mix_GetMusicTitle(Mix_Music* music)
{
    (void)music;
    return "";
}

int Mix_GetMusicTracks(Mix_Music* music)
{
    (void)music;
    return 1;
}

int Mix_SetMusicTrackMute(Mix_Music* music, int track, int mute)
{
    (void)music;
    (void)track;
    (void)mute;
    return 0;
}

void Mix_FreeMusic(Mix_Music* music)
{
    const std::string* path_use = reinterpret_cast<const std::string*>(music);
    auto f = sound_id_music_map.find(path_use);

    if(f != sound_id_music_map.end())
    {
        killSound(f->second);
        sound_id_music_map.erase(f);
    }

    auto it = music_stream_paths.find(path_use);

    if(it != music_stream_paths.end())
    {
        music_stream_paths.erase(it);
        delete path_use;
    }
}

void Mix_FreeChunk(Mix_Chunk* chunk)
{
    auto it = sound_stream_paths.find(reinterpret_cast<const std::string*>(chunk));

    if(it != sound_stream_paths.end())
    {
        sound_stream_paths.erase(it);
        delete(const std::string*)chunk;
        return;
    }

    audioFreeWave(reinterpret_cast<WaveObject*>(chunk));
}

void Mix_GME_SetSpcEchoDisabled(Mix_Music* music, int disable)
{
    (void)music;
    (void)disable;
}

void Mix_RegisterEffect(int chan, Mix_EffectFunc_t f, Mix_EffectDone_t d, void* arg)
{
    (void)chan;
    (void)f;
    (void)d;
    (void)arg;
}

void Mix_UnregisterEffect(int chan, Mix_EffectFunc_t f)
{
    (void)chan;
    (void)f;
}

void Mix_ChannelFinished(void (*cb)(int))
{
    audioSetChannelDoneCallback(cb);
}

void Mix_ADLMIDI_setEmulator(int emu)
{
    (void)emu;
}

void Mix_ADLMIDI_setChipsCount(int chips)
{
    (void)chips;
}

void Mix_OPNMIDI_setEmulator(int emu)
{
    (void)emu;
}

void Mix_OPNMIDI_setChipsCount(int chips)
{
    (void)chips;
}



================================================
FILE: lib/sdl_proxy/3ds/std_3ds.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <ctime>
#include <cstdio>
#include <3ds.h>

#include "../sdl_timer.h"

uint32_t __stacksize__ = 0x00020000;

uint64_t originalTime = -1u;
uint64_t originalMicroTime = -1u;

osTimeRef_s tr;

uint64_t SDL_GetMicroTicks()
{
    if(originalMicroTime == -1u)
    {
        originalMicroTime = svcGetSystemTick();
        tr = osGetTimeRef();
    }

    return (uint64_t)(svcGetSystemTick() - originalTime) * 1000000 / tr.sysclock_hz;
}


================================================
FILE: lib/sdl_proxy/_trash/mixer_mixerx.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "sound.h"

#include <SDL2/SDL.h>
#include <SDL2/SDL_timer.h>
#include <SDL2/SDL_mixer_ext.h>
#include <string>
#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "core/msgbox.h"

static const int maxSfxChannels = 91;

static const char *audio_format_to_string(SDL_AudioFormat f)
{
    switch(f)
    {
    default:
        return "<unknown>";
    case AUDIO_U8:
        return "U8";
    case AUDIO_S8:
        return "S8";
    case AUDIO_S16LSB:
        return "S16-LE";
    case AUDIO_S16MSB:
        return "S16-BE";
    case AUDIO_U16LSB:
        return "U16-LE";
    case AUDIO_U16MSB:
        return "U16-BE";
    case AUDIO_S32LSB:
        return "S32-LE";
    case AUDIO_S32MSB:
        return "S32-BE";
    case AUDIO_F32LSB:
        return "F32-LE";
    case AUDIO_F32MSB:
        return "F32-BE";
    }
}

bool MixPlatform_Init(AudioSetup_t& obtained)
{
    int ret;
    const int initFlags = MIX_INIT_MID | MIX_INIT_MOD | MIX_INIT_FLAC | MIX_INIT_OGG | MIX_INIT_OPUS | MIX_INIT_MP3;

    pLogDebug("Opening sound (wanted: rate=%d hz, format=%s, channels=%d, buffer=%d frames)...",
              g_audioSetup.sampleRate,
              audio_format_to_string(g_audioSetup.format),
              g_audioSetup.channels,
              g_audioSetup.bufferSize);

    ret = Mix_Init(initFlags);

    if(ret != initFlags)
    {
        pLogWarning("MixerX: Some modules aren't properly initialized");
        if((initFlags & MIX_INIT_MID) != MIX_INIT_MID)
            pLogWarning("MixerX: Failed to initialize MIDI module");
        if((initFlags & MIX_INIT_MOD) != MIX_INIT_MOD)
            pLogWarning("MixerX: Failed to initialize Tracker music module");
        if((initFlags & MIX_INIT_FLAC) != MIX_INIT_FLAC)
            pLogWarning("MixerX: Failed to initialize FLAC module");
        if((initFlags & MIX_INIT_OGG) != MIX_INIT_OGG)
            pLogWarning("MixerX: Failed to initialize OGG Vorbis module");
        if((initFlags & MIX_INIT_OPUS) != MIX_INIT_OPUS)
            pLogWarning("MixerX: Failed to initialize Opus module");
        if((initFlags & MIX_INIT_MP3) != MIX_INIT_MP3)
            pLogWarning("MixerX: Failed to initialize MP3 module");
    }

    ret = Mix_OpenAudio(g_audioSetup.sampleRate,
                        g_audioSetup.format,
                        g_audioSetup.channels,
                        g_audioSetup.bufferSize);

    if(ret < 0)
    {
        std::string msg = fmt::format_ne("Can't open audio stream, continuing without audio: ({0})", Mix_GetError());
        pLogCritical(msg.c_str());
        XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR, "Sound opening error", msg.c_str());
        return false;
    }

    SDL_AudioSpec ob;
    ret = Mix_QuerySpecEx(&ob);

    if(ret == 0)
    {
        pLogCritical("Failed to call the Mix_QuerySpec!");
        obtained = g_audioSetup;
    }
    else
    {
        obtained.sampleRate = ob.freq;
        obtained.format = ob.format;
        obtained.channels = ob.channels;
        obtained.bufferSize = ob.samples;

        pLogDebug("Sound opened (obtained: rate=%d hz, format=%s, channels=%d, buffer=%d frames)...",
                  obtained.sampleRate,
                  audio_format_to_string(obtained.format),
                  obtained.channels,
                  obtained.bufferSize);
    }

#ifdef __3DS__
    // Set fastest emulators to be default
    Mix_OPNMIDI_setEmulator(OPNMIDI_OPN2_EMU_GENS);
    Mix_OPNMIDI_setChipsCount(2);
    Mix_ADLMIDI_setEmulator(ADLMIDI_OPL3_EMU_DOSBOX);
    Mix_ADLMIDI_setChipsCount(2);
#endif

    Mix_VolumeMusic(MIX_MAX_VOLUME);
    Mix_AllocateChannels(maxSfxChannels);

    return true;
}

void MixPlatform_Quit()
{
    Mix_CloseAudio();
    Mix_Quit();
}

int MixPlatform_PlayStream(int channel, const char *path, int loops)
{
    int ret;
    (void)channel;

    Mix_Music *mus = Mix_LoadMUS(path);

    if(!mus)
        return -1;

    ret = Mix_PlayMusicStream(mus, loops);

    if(ret < 0)
        Mix_FreeMusic(mus);
    else
        Mix_SetFreeOnStop(mus, 1);

    return ret;
}


================================================
FILE: lib/sdl_proxy/_trash/sdl_assert.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_ASSERT_HHHHHH
#define SDL_ASSERT_HHHHHH

#if defined(PGE_MIN_PORT) && !defined(__WII__)
#include "core/null/sdl_null_assert.h"
#else
#include "core/sdl/sdl_sdl_assert.h"
#endif

#endif // #ifndef SDL_ASSERT_HHHHHH


================================================
FILE: lib/sdl_proxy/_trash/sdl_atomic.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_ATOMIC_HHHHHH
#define SDL_ATOMIC_HHHHHH

#if defined(PGE_MIN_PORT) && !defined(__WII__)
#include "core/null/sdl_null_atomic.h"
#else
#include "core/sdl/sdl_sdl_atomic.h"
#endif

#endif // #ifndef SDL_ATOMIC_HHHHHH


================================================
FILE: lib/sdl_proxy/_trash/sdl_head.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_HEAD_HHHHHH
#define SDL_HEAD_HHHHHH

#if defined(PGE_MIN_PORT) && !defined(__WII__)
#include "core/null/sdl_null_atomic.h"
#else
#include <SDL2/SDL.h>
#endif

#endif // #ifndef SDL_ATOMIC_HHHHHH


================================================
FILE: lib/sdl_proxy/_trash/sdl_stdinc.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_STDINC_HHHHHH
#define SDL_STDINC_HHHHHH

#if defined(PGE_MIN_PORT) && !defined(__WII__)
#include "core/null/sdl_null_stdinc.h"
#else
#include "core/sdl/sdl_sdl_stdinc.h"
#endif

#include <cstdint>

#ifdef SDL_min
#   undef SDL_min
#endif

#ifdef SDL_max
#   undef SDL_max
#endif

#ifdef SDL_SwapLE32
#   undef SDL_SwapLE32
#endif

#ifdef SDL_SwapBE32
#   undef SDL_SwapBE32
#endif

#ifdef THEXTECH_BIG_ENDIAN
// based on SDL formula
inline uint32_t SDL_SwapLE32(uint32_t x)
{
    return static_cast<uint32_t>(((x << 24) | ((x << 8) & 0x00FF0000) |
                                ((x >> 8) & 0x0000FF00) | (x >> 24)));
}
inline uint32_t SDL_SwapBE32(uint32_t x)
{
    return x;
}
#else
inline uint32_t SDL_SwapLE32(uint32_t x)
{
    return x;
}
inline uint32_t SDL_SwapBE32(uint32_t x)
{
    return static_cast<uint32_t>(((x << 24) | ((x << 8) & 0x00FF0000) |
                                ((x >> 8) & 0x0000FF00) | (x >> 24)));
}
#endif


template<class value_t>
inline value_t SDL_min(value_t x, value_t y)
{
    return x < y ? x : y;
}

template<class value_t>
inline value_t SDL_max(value_t x, value_t y)
{
    return x > y ? x : y;
}

SDL_IMPORT(free)

SDL_IMPORT(memset)
SDL_IMPORT(memcpy)
SDL_IMPORT(memcmp)
SDL_IMPORT(strdup)
SDL_IMPORT(strlen)
SDL_IMPORT(strtol)
SDL_IMPORT(atoi)
SDL_IMPORT(atof)
SDL_IMPORT(sscanf)
SDL_IMPORT(strcasecmp)
SDL_IMPORT(strncasecmp)

SDL_IMPORT(strlcpy)
SDL_IMPORT(strstr)

SDL_IMPORT(pow)

SDL_IMPORT_MATH(fabs)
SDL_IMPORT_MATH(floor)
SDL_IMPORT_MATH(ceil)

#endif // #ifndef SDL_STDINC_HHHHHH


================================================
FILE: lib/sdl_proxy/_trash/sdl_timer.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_TIMER_HHHHHH
#define SDL_TIMER_HHHHHH

#if defined(PGE_MIN_PORT) && !defined(__WII__)
#include "core/null/sdl_null.h"
#else
#include "core/sdl/sdl_sdl_timer.h"
#endif

#ifndef SDL_timer_h_
extern uint32_t SDL_GetTicks();
#endif
extern uint64_t SDL_GetMicroTicks();

#endif // #ifndef SDL_TIMER_HHHHHH


================================================
FILE: lib/sdl_proxy/base/std_base.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Utils/elapsed_timer.h>

#include "../sdl_timer.h"

static ElapsedTimer s_timer;
static bool s_init = false;

uint64_t SDL_GetMicroTicks()
{
    if(!s_init)
    {
        s_timer.start();
        s_init = true;
    }

    return s_timer.nanoelapsed() / 1000;
}


================================================
FILE: lib/sdl_proxy/mixer.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef MIXER_HHHHH
#define MIXER_HHHHH

#include <cstdint>

// for AudioSetup_t
#include "sound.h"
#include "sdl_audio.h"

#ifdef CUSTOM_AUDIO

struct Mix_Music;
struct Mix_Chunk;
struct SDL_RWops;

#ifndef MIX_CHANNELS
#define MIX_CHANNELS    8
#endif

/* Good default values for a PC soundcard */
#define MIX_DEFAULT_FREQUENCY   44100
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
#define MIX_DEFAULT_FORMAT      AUDIO_S16LSB
#else
#define MIX_DEFAULT_FORMAT      AUDIO_S16MSB
#endif
#define MIX_DEFAULT_CHANNELS    2
#define MIX_MAX_VOLUME          SDL_MIX_MAXVOLUME /* Volume of a chunk */

extern "C" {

/**
 * Initialization flags
 */
typedef enum
{
    MIX_INIT_FLAC   = 0x00000001,
    MIX_INIT_MOD    = 0x00000002,
    MIX_INIT_MP3    = 0x00000008,
    MIX_INIT_OGG    = 0x00000010,
    MIX_INIT_MID    = 0x00000020,
    MIX_INIT_OPUS   = 0x00000040
} MIX_InitFlags;

/* OPL3 chip emulators for ADLMIDI */
typedef enum {
    ADLMIDI_OPL3_EMU_DEFAULT = -1,
    ADLMIDI_OPL3_EMU_NUKED = 0,
    ADLMIDI_OPL3_EMU_NUKED_1_7_4,
    ADLMIDI_OPL3_EMU_DOSBOX,
    ADLMIDI_OPL3_EMU_OPAL,
    ADLMIDI_OPL3_EMU_JAVA
} Mix_ADLMIDI_Emulator;

/* OPN2 chip emulators for OPNMIDI */
typedef enum {
    OPNMIDI_OPN2_EMU_DEFAULT = -1,
    OPNMIDI_OPN2_EMU_MAME_OPN2 = 0,
    OPNMIDI_OPN2_EMU_NUKED,
    OPNMIDI_OPN2_EMU_GENS,
    OPNMIDI_OPN2_EMU_GX, /* Caution: THIS emulator is inavailable by default */
    OPNMIDI_OPN2_EMU_NP2,
    OPNMIDI_OPN2_EMU_MAME_OPNA,
    OPNMIDI_OPN2_EMU_PMDWIN,
    /* Deprecated */
    OPNMIDI_OPN2_EMU_MIME = 0 /*!!!TYPO!!!*/
} Mix_OPNMIDI_Emulator;

extern int Mix_Init(int flags);

extern void Mix_Quit(void);

extern int Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize);
extern void Mix_CloseAudio(void);

extern int Mix_VolumeMusic(int volume);
extern int Mix_AllocateChannels(int numchans);

extern int Mix_QuerySpecEx(SDL_AudioSpec *out_spec);

extern const char* Mix_GetError();

extern int Mix_ReserveChannels(int channels);
extern void Mix_PauseAudio(int pause);


extern Mix_Music* Mix_LoadMUS(const char* path);
extern Mix_Chunk* Mix_LoadWAV(const char* path);

extern Mix_Music* Mix_LoadMUS_RW(struct SDL_RWops*, int);
extern Mix_Chunk* Mix_LoadWAV_RW(struct SDL_RWops*, int);

extern Mix_Music* Mix_LoadMUS_RW_ARG(struct SDL_RWops*, int, const char*);

extern double Mix_MusicDuration(Mix_Music* music);

extern int Mix_VolumeMusicStream(Mix_Music* music, int volume);
extern int Mix_HaltMusicStream(Mix_Music* music);
extern int Mix_FadeOutMusicStream(Mix_Music* music, int ms);
extern int Mix_HaltChannel(int channel);

extern int Mix_PlayChannel(int channel, Mix_Chunk *chunk, int loops);
extern int Mix_PlayChannelVol(int which, Mix_Chunk *chunk, int loops, int volume);

extern int Mix_SetPanning(int which, uint8_t left, uint8_t right);

extern int Mix_PlayingMusicStream(Mix_Music* music);

extern int Mix_RewindMusicStream(Mix_Music* music);
extern int Mix_SetMusicEffectPanning(Mix_Music* music, uint8_t left, uint8_t right);

extern int Mix_PlayMusic(Mix_Music *music, int loops);
extern int Mix_FadeInMusic(Mix_Music* music, int loops, int fadeInMs);
extern int Mix_SetFreeOnStop(Mix_Music *music, int free_on_stop);

extern int Mix_FadeOutMusic(int fadeInMs);

extern int Mix_PlayMusicStream(Mix_Music *music, int loops);

extern int Mix_PausedMusicStream(Mix_Music *music);
extern int Mix_PauseMusicStream(Mix_Music *music);
extern int Mix_ResumeMusicStream(Mix_Music *music);

extern int Mix_GetMusicTracks(Mix_Music* music);
extern const char* Mix_GetMusicTitle(Mix_Music* music);

extern int Mix_SetMusicTrackMute(Mix_Music* music, int track, int mute);

extern void Mix_FreeMusic(Mix_Music* music);
extern void Mix_FreeChunk(Mix_Chunk* chunk);

extern void Mix_ChannelFinished(void (*callback)(int));

#ifdef THEXTECH_ENABLE_AUDIO_FX

#define MIX_CHANNEL_POST   -2

typedef void( *  Mix_EffectFunc_t) (int chan, void *stream, int len, void *udata);
typedef void( *  Mix_EffectDone_t) (int chan, void *udata);

extern void Mix_GME_SetSpcEchoDisabled(Mix_Music* music, int disable);
extern void Mix_RegisterEffect(int chan, Mix_EffectFunc_t f, Mix_EffectDone_t d, void *arg);
extern void Mix_UnregisterEffect(int chan, Mix_EffectFunc_t f);

extern void Mix_ADLMIDI_setEmulator(int emu);
extern void Mix_ADLMIDI_setChipsCount(int chips);

extern void Mix_OPNMIDI_setEmulator(int emu);
extern void Mix_OPNMIDI_setChipsCount(int chips);

#endif // #ifdef THEXTECH_ENABLE_AUDIO_FX

} // extern "C"

#else // #ifdef CUSTOM_AUDIO

#include <SDL2/SDL_mixer_ext.h>

#endif

#endif // #ifndef MIXER_HHHHH


================================================
FILE: lib/sdl_proxy/null/mixer_null.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include <string>
#include <set>

#include <cstring>
#include <cstdlib>
#include <SDL2/SDL_rwops.h>

#include "../mixer.h"
#include "globals.h"

int Mix_Init(int flags)
{
    UNUSED(flags);
    return 0; // Always fail
}

void Mix_Quit()
{}

int Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize)
{
    (void)frequency;
    (void)format;
    (void)channels;
    (void)chunksize;

    return -1; // Always fail
}

int Mix_QuerySpecEx(SDL_AudioSpec* out_spec)
{
    memset(out_spec, 0, sizeof(SDL_AudioSpec));
    out_spec->channels = 2;
    out_spec->samples = 2048;
    out_spec->freq = 32728;
    out_spec->format = AUDIO_S16SYS;
    return 0;
}

void Mix_CloseAudio()
{}

int Mix_VolumeMusic(int volume)
{
    (void)volume;
    return volume;
}

int Mix_AllocateChannels(int numchans)
{
    (void)numchans;
    return 0;
}

Mix_Chunk* Mix_LoadWAV(const char* path)
{
    UNUSED(path);
    return nullptr; // Always fail
}

double Mix_MusicDuration(Mix_Music* music)
{
    UNUSED(music);
    return 0;
}

const char* Mix_GetError()
{
    return "";
}

int Mix_PlayChannel(int channel, Mix_Chunk* chunk, int loops)
{
    UNUSED(channel);
    UNUSED(chunk);
    UNUSED(loops);
    return 0;
}

#ifndef Mix_PlayChannelVol
int Mix_PlayChannelVol(int channel, Mix_Chunk* chunk, int loops, int volume)
{
    UNUSED(channel);
    UNUSED(chunk);
    UNUSED(loops);
    UNUSED(volume);
    return -1;
}
#else
int Mix_PlayChannelTimedVolume(int channel, Mix_Chunk* chunk, int loops, int ticks, int volume)
{
    UNUSED(channel);
    UNUSED(chunk);
    UNUSED(loops);
    UNUSED(ticks);
    UNUSED(volume);
    return -1;
}
#endif

int Mix_SetPanning(int channel, uint8_t left, uint8_t right)
{
    UNUSED(channel);
    UNUSED(left);
    UNUSED(right);
    return -1;
}

int Mix_ReserveChannels(int channels)
{
    UNUSED(channels);
    return 0;
}

void Mix_PauseAudio(int pause)
{
    UNUSED(pause);
}

Mix_Music* Mix_LoadMUS(const char* path)
{
    UNUSED(path);
    return nullptr; // Always fail
}

Mix_Music* Mix_LoadMUS_RW(struct SDL_RWops* rwops, int free_me)
{
    if(free_me)
        SDL_RWclose(rwops);

    return nullptr;
}

Mix_Chunk* Mix_LoadWAV_RW(struct SDL_RWops* rwops, int free_me)
{
    if(free_me)
        SDL_RWclose(rwops);

    return nullptr;
}

Mix_Music* Mix_LoadMUS_RW_ARG(struct SDL_RWops* rwops, int free_me, const char*)
{
    if(free_me)
        SDL_RWclose(rwops);

    return nullptr;
}

int Mix_VolumeMusicStream(Mix_Music* music, int volume)
{
    (void)music;
    (void)volume;
    return 0;
}

int Mix_HaltMusicStream(Mix_Music* music)
{
    UNUSED(music);
    return 0;
}
int Mix_FadeOutMusicStream(Mix_Music* music, int ms)
{
    UNUSED(ms);
    UNUSED(music);
    return 0;
}
int Mix_HaltChannel(int channel)
{
    UNUSED(channel);
    return 0;
}

int Mix_PlayingMusicStream(Mix_Music* music)
{
    UNUSED(music);
    return -1;
}

int Mix_PausedMusicStream(Mix_Music* music)
{
    UNUSED(music);
    return -1;
}

int Mix_RewindMusicStream(Mix_Music* music)
{
    UNUSED(music);
    return -1;
}

int Mix_SetMusicEffectPanning(Mix_Music* music, uint8_t left, uint8_t right)
{
    UNUSED(music);
    UNUSED(left);
    UNUSED(right);
    return -1;
}

int Mix_PauseMusicStream(Mix_Music* music)
{
    UNUSED(music);
    return 0;
}

int Mix_ResumeMusicStream(Mix_Music* music)
{
    UNUSED(music);
    return 0;
}

int Mix_PlayMusic(Mix_Music* music, int loops)
{
    UNUSED(music);
    UNUSED(loops);
    return 0;
}

int Mix_PlayMusicStream(Mix_Music* music, int loops)
{
    UNUSED(music);
    UNUSED(loops);
    return -1;
}

int Mix_SetFreeOnStop(Mix_Music* music, int free_on_stop)
{
    UNUSED(music);
    UNUSED(free_on_stop);
    return 0;
}

int Mix_FadeInMusic(Mix_Music* music, int loops, int fadeInMs)
{
    UNUSED(music);
    UNUSED(loops);
    UNUSED(fadeInMs);
    return -1;
}

const char* Mix_GetMusicTitle(Mix_Music* music)
{
    UNUSED(music);
    return "";
}

int Mix_GetMusicTracks(Mix_Music* music)
{
    UNUSED(music);
    return 1;
}

int Mix_SetMusicTrackMute(Mix_Music* music, int track, int mute)
{
    (void)music;
    (void)track;
    (void)mute;
    return 0;
}

void Mix_FreeMusic(Mix_Music* music)
{
    UNUSED(music);
}

void Mix_FreeChunk(Mix_Chunk* chunk)
{
    UNUSED(chunk);
}

void Mix_GME_SetSpcEchoDisabled(Mix_Music* music, int disable)
{
    (void)music;
    (void)disable;
}

#ifdef THEXTECH_ENABLE_AUDIO_FX
void Mix_RegisterEffect(int chan, Mix_EffectFunc_t f, Mix_EffectDone_t d, void* arg)
{
    (void)chan;
    (void)f;
    (void)d;
    (void)arg;
}

void Mix_UnregisterEffect(int chan, Mix_EffectFunc_t f)
{
    (void)chan;
    (void)f;
}
#endif

void Mix_ChannelFinished(void (*cb)(int))
{
    UNUSED(cb);
}

void Mix_ADLMIDI_setEmulator(int emu)
{
    (void)emu;
}

void Mix_ADLMIDI_setChipsCount(int chips)
{
    (void)chips;
}

void Mix_OPNMIDI_setEmulator(int emu)
{
    (void)emu;
}

void Mix_OPNMIDI_setChipsCount(int chips)
{
    (void)chips;
}


================================================
FILE: lib/sdl_proxy/null/sdl_null.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef STD_NULL_H
#define STD_NULL_H

#include <cstdio>
#include <cstdint>
#include <cmath>
#include <cstring>

#ifndef UNUSED // To avoid IDE-side errors
#define UNUSED(x) (void)x
#endif

typedef int64_t Sint64;
typedef uint64_t Uint64;
typedef int32_t Sint32;
typedef uint32_t Uint32;
typedef int16_t Sint16;
typedef uint16_t Uint16;
typedef int8_t Sint8;
typedef uint8_t Uint8;

#define SDL_IMPORT(func) static constexpr auto& SDL_ ## func = func;
#define SDL_IMPORT_MATH(func) inline double SDL_ ## func(double arg) { return std::func(arg); }

#define SDL_INLINE inline
#define SDL_FORCE_INLINE static inline

inline const char* SDL_strstr(const char* haystack, const char* needle)
{
    return strstr(haystack, needle);
}

inline char* SDL_strstr(char* haystack, const char* needle)
{
    return strstr(haystack, needle);
}

inline size_t SDL_strlcpy(char* dst, const char* src, size_t maxlen)
{
    size_t srclen = strlen(src);
    if(maxlen > 0)
    {
        size_t len = srclen < maxlen - 1 ? srclen : maxlen - 1;
        memcpy(dst, src, len);
        dst[len] = '\0';
    }
    return srclen;
}

inline double SDL_pow(double x, double y)
{
    return std::pow(x, y);
}

#endif // #ifndef STD_NULL_H


================================================
FILE: lib/sdl_proxy/null/std_null.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../sdl_timer.h"

uint32_t curTime = 0u;

uint32_t SDL_GetTicks()
{
   return ++curTime;
}

uint64_t SDL_GetMicroTicks()
{
    return curTime * 1000;
}

void SDL_Delay(int ms)
{
   (void)ms;
}


================================================
FILE: lib/sdl_proxy/sdl_assert.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_SDL_ASSERT_H
#define SDL_SDL_ASSERT_H

#if defined(SDLRPOXY_NULL)

#   include <assert.h>

#   define SDL_assert(x)         assert(x)

// Doesn't work as intended (trigger a fail on release builds), this is just a dummy
#ifndef NDEBUG
#   define SDL_assert_release(x) assert(x)
#else
#   define SDL_assert_release(x) (void)(x)
#endif

#else

#include <SDL2/SDL_assert.h>

#endif

#endif // #ifndef SDL_SDL_ASSERT_H


================================================
FILE: lib/sdl_proxy/sdl_atomic.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_SDL_ATOMIC_H
#define SDL_SDL_ATOMIC_H

#if defined(SDLRPOXY_NULL)
using SDL_atomic_t = volatile int;

inline void SDL_AtomicSet(SDL_atomic_t* loc, int value)
{
    *loc = value;
}

inline int SDL_AtomicGet(const SDL_atomic_t* loc)
{
    return *loc;
}

#else
#   include <SDL2/SDL_atomic.h>
#endif

#endif // #ifndef SDL_SDL_ATOMIC_H


================================================
FILE: lib/sdl_proxy/sdl_audio.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_SDL_AUDIO_H
#define SDL_SDL_AUDIO_H

#ifndef SDLRPOXY_NULL
#   include <SDL2/SDL_audio.h>
#endif


#ifdef SDLRPOXY_NULL

#include "sdl_types.h"

/* @{ */
#define AUDIO_U8        0x0008
#define AUDIO_S8        0x8008
#define AUDIO_U16LSB    0x0010
#define AUDIO_S16LSB    0x8010
#define AUDIO_U16MSB    0x1010
#define AUDIO_S16MSB    0x9010
#define AUDIO_U16       AUDIO_U16LSB
#define AUDIO_S16       AUDIO_S16LSB
/* @} */

/* @{ */
#define AUDIO_S32LSB    0x8020
#define AUDIO_S32MSB    0x9020
#define AUDIO_S32       AUDIO_S32LSB
/* @} */

/* @{ */
#define AUDIO_F32LSB    0x8120
#define AUDIO_F32MSB    0x9120
#define AUDIO_F32       AUDIO_F32LSB
/* @} */

/* @{ */
#ifndef THEXTECH_BIG_ENDIAN
#define AUDIO_U16SYS    AUDIO_U16LSB
#define AUDIO_S16SYS    AUDIO_S16LSB
#define AUDIO_S32SYS    AUDIO_S32LSB
#define AUDIO_F32SYS    AUDIO_F32LSB
#else
#define AUDIO_U16SYS    AUDIO_U16MSB
#define AUDIO_S16SYS    AUDIO_S16MSB
#define AUDIO_S32SYS    AUDIO_S32MSB
#define AUDIO_F32SYS    AUDIO_F32MSB
#endif
/* @} */

#define SDL_AudioFormat Uint16
typedef void* SDL_AudioCallback;

#define SDL_MIX_MAXVOLUME 1

/**
 *  The calculated values in this structure are calculated by SDL_OpenAudio().
 *
 *  For multi-channel audio, the default SDL channel mapping is:
 *  2:  FL FR                       (stereo)
 *  3:  FL FR LFE                   (2.1 surround)
 *  4:  FL FR BL BR                 (quad)
 *  5:  FL FR FC BL BR              (quad + center)
 *  6:  FL FR FC LFE SL SR          (5.1 surround - last two can also be BL BR)
 *  7:  FL FR FC LFE BC SL SR       (6.1 surround)
 *  8:  FL FR FC LFE BL BR SL SR    (7.1 surround)
 */
typedef struct SDL_AudioSpec
{
    int freq;                   /**< DSP frequency -- samples per second */
    SDL_AudioFormat format;     /**< Audio data format */
    Uint8 channels;             /**< Number of channels: 1 mono, 2 stereo */
    Uint8 silence;              /**< Audio buffer silence value (calculated) */
    Uint16 samples;             /**< Audio buffer size in sample FRAMES (total samples divided by channel count) */
    Uint16 padding;             /**< Necessary for some compile environments */
    Uint32 size;                /**< Audio buffer size in bytes (calculated) */
    SDL_AudioCallback callback; /**< Callback that feeds the audio device (NULL to use SDL_QueueAudio()). */
    void *userdata;             /**< Userdata passed to callback (ignored for NULL callbacks). */
} SDL_AudioSpec;
#endif /* SDLRPOXY_NULL */

#endif // #ifndef SDL_SDL_AUDIO_H


================================================
FILE: lib/sdl_proxy/sdl_common.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_COMMON_HHHHH
#define SDL_COMMON_HHHHH

#define SDL_IMPORT(func) /* func */
#define SDL_IMPORT_MATH(func) /* func */

#endif // #ifndef SDL_COMMON_HHHHH


================================================
FILE: lib/sdl_proxy/sdl_filesystem.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_SDL_FILESYSTEM_H
#define SDL_SDL_FILESYSTEM_H

#if !defined(SDLRPOXY_NULL)

#include <SDL2/SDL_filesystem.h>

#else

inline char* SDL_GetBasePath()
{
    return nullptr;
}

#endif

#endif // #ifndef SDL_SDL_FILESYSTEM_H


================================================
FILE: lib/sdl_proxy/sdl_head.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_HEAD_HHHHHH
#define SDL_HEAD_HHHHHH

#if defined(SDLRPOXY_NULL)
#include "sdl_types.h"
#include "sdl_stdinc.h"
#include "sdl_timer.h"
#include "sdl_assert.h"
#include "sdl_atomic.h"
#include "sdl_audio.h"
#else
#include <SDL2/SDL.h>
#endif

#endif // #ifndef SDL_ATOMIC_HHHHHH


================================================
FILE: lib/sdl_proxy/sdl_proxy.cmake
================================================
include_directories(${CMAKE_CURRENT_LIST_DIR}/)

set(SDLPROXY_SRCS)

file(GLOB SDLPROXY_HEADS
    ${CMAKE_CURRENT_LIST_DIR}/*.h
    ${CMAKE_CURRENT_LIST_DIR}/null/*.h
)

list(APPEND SDLPROXY_SRCS ${SDLPROXY_HEADS})

if(NINTENDO_3DS)
    add_definitions(-DSDLRPOXY_3DS)
    list(APPEND SDLPROXY_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/3ds/std_3ds.cpp
    )

    if(THEXTECH_CUSTOM_AUDIO_LIBRARY)
        add_definitions(-DCUSTOM_AUDIO)
        set(THEXTECH_NO_MIXER_X ON)
        list(APPEND SDLPROXY_SRCS
            ${CMAKE_CURRENT_LIST_DIR}/3ds/mixer_3ds.cpp
            ${CMAKE_CURRENT_LIST_DIR}/3ds/3ds-audio-lib.cpp
        )
    endif()
elseif(NINTENDO_WII)
    add_definitions(-DSDLRPOXY_WII)
    list(APPEND SDLPROXY_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/wii/std_wii.cpp
    )
elseif(NINTENDO_DS)
    add_definitions(-DSDLRPOXY_NULL)
    list(APPEND SDLPROXY_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/16m/std_16m.cpp
    )
elseif(THEXTECH_NO_SDL_BUILD)
    add_definitions(-DSDLRPOXY_NULL)
    add_definitions(-DCUSTOM_AUDIO)
    set(THEXTECH_NO_MIXER_X ON)
    list(APPEND SDLPROXY_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/null/std_null.cpp
        ${CMAKE_CURRENT_LIST_DIR}/null/mixer_null.cpp
    )
elseif(THEXTECH_CLI_BUILD)
    add_definitions(-DSDLRPOXY_SDL2)
    add_definitions(-DCUSTOM_AUDIO)
    set(THEXTECH_NO_MIXER_X ON)
    list(APPEND SDLPROXY_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/base/std_base.cpp
        ${CMAKE_CURRENT_LIST_DIR}/null/mixer_null.cpp
    )
else()
    add_definitions(-DSDLRPOXY_SDL2)
    list(APPEND SDLPROXY_SRCS
        ${CMAKE_CURRENT_LIST_DIR}/base/std_base.cpp
    )
endif()


================================================
FILE: lib/sdl_proxy/sdl_stdinc.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_SDL_STDINC_H
#define SDL_SDL_STDINC_H

#if !defined(SDLRPOXY_NULL)

#include <SDL2/SDL_stdinc.h>

#ifdef _MSC_VER
// Workaround for MSVC where SDL_sscanf fails to parse a string
// See details: https://github.com/libsdl-org/SDL/issues/8423
#   define XTECH_sscanf sscanf
#else
#   define XTECH_sscanf SDL_sscanf
#endif

#else // USING POSIX FUNCTIONS ONLY

#include "null/sdl_null.h"

#include <cstdint>

#define XTECH_sscanf sscanf

#define SDL_vsnprintf  vsnprintf
#define SDL_snprintf   snprintf

#ifdef SDL_min
#   undef SDL_min
#endif

#ifdef SDL_max
#   undef SDL_max
#endif

#ifdef SDL_SwapLE32
#   undef SDL_SwapLE32
#endif

#ifdef SDL_SwapBE32
#   undef SDL_SwapBE32
#endif

#ifdef THEXTECH_BIG_ENDIAN
// based on SDL formula
inline uint32_t SDL_SwapLE32(uint32_t x)
{
    return static_cast<uint32_t>(((x << 24) | ((x << 8) & 0x00FF0000) |
                                ((x >> 8) & 0x0000FF00) | (x >> 24)));
}
inline uint32_t SDL_SwapBE32(uint32_t x)
{
    return x;
}
#else
inline uint32_t SDL_SwapLE32(uint32_t x)
{
    return x;
}
inline uint32_t SDL_SwapBE32(uint32_t x)
{
    return static_cast<uint32_t>(((x << 24) | ((x << 8) & 0x00FF0000) |
                                ((x >> 8) & 0x0000FF00) | (x >> 24)));
}
#endif


#define SDL_GetError() "<SDL Error API is unavailable>"
#define SDL_ClearError() (void)0
inline void SDL_SetError(const char *fmt, ...) { (void)fmt; /* Do Nothing!*/ }


template<class value_t>
inline value_t SDL_min(value_t x, value_t y)
{
    return x < y ? x : y;
}

template<class value_t>
inline value_t SDL_max(value_t x, value_t y)
{
    return x > y ? x : y;
}

inline double SDL_fmod(double x, double y)
{
    return fmod(x, y);
}

inline int SDL_abs(int i)
{
    return (i < 0) ? -i : i;
}

SDL_IMPORT(malloc)
SDL_IMPORT(free)

SDL_IMPORT(memset)
SDL_IMPORT(memcpy)
SDL_IMPORT(memcmp)
SDL_IMPORT(strdup)
SDL_IMPORT(strlen)
SDL_IMPORT(strtol)
SDL_IMPORT(atoi)
SDL_IMPORT(atof)
SDL_IMPORT(sscanf)
SDL_IMPORT(strcmp)
SDL_IMPORT(strncmp)
SDL_IMPORT(strcasecmp)
SDL_IMPORT(strncasecmp)
SDL_IMPORT(getenv)

SDL_IMPORT_MATH(fabs)
SDL_IMPORT_MATH(floor)
SDL_IMPORT_MATH(ceil)
SDL_IMPORT_MATH(round)
SDL_IMPORT_MATH(sqrt)

#endif

#endif // #ifndef SDL_SDL_STDINC_H


================================================
FILE: lib/sdl_proxy/sdl_timer.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_SDL_TIMER_H
#define SDL_SDL_TIMER_H

#ifndef SDLRPOXY_NULL

#include <SDL2/SDL_version.h>
#include <SDL2/SDL_timer.h>

#if !SDL_VERSION_ATLEAST(2, 0, 18)
// This call has been introduced in SDL 2.0.18. For the older SDL2, have a fallback!
inline uint64_t SDL_GetTicks64()
{
    return (uint64_t)SDL_GetTicks();
}
#endif

#else

#include <cstdint>

#ifndef SDL_timer_h_
extern uint32_t SDL_GetTicks();

inline uint64_t SDL_GetTicks64()
{
    return (uint64_t)SDL_GetTicks();
}
#endif

void SDL_Delay(int ms);

#endif

extern uint64_t SDL_GetMicroTicks();

#endif // #ifndef SDL_SDL_TIMER_H


================================================
FILE: lib/sdl_proxy/sdl_types.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_SDL_TYPES_H
#define SDL_SDL_TYPES_H

#if defined(SDLRPOXY_NULL)
#include <cstdint>

#ifndef UNUSED // To avoid IDE-side errors
#   define UNUSED(x) (void)x
#endif

typedef int64_t Sint64;
typedef uint64_t Uint64;
typedef int32_t Sint32;
typedef uint32_t Uint32;
typedef int16_t Sint16;
typedef uint16_t Uint16;
typedef int8_t Sint8;
typedef uint8_t Uint8;

#define SDL_INLINE inline
#define SDL_FORCE_INLINE static inline

#else
#include <SDL2/SDL_types.h>
#endif

#endif // #ifndef SDL_SDL_TYPES_H


================================================
FILE: lib/sdl_proxy/wii/std_wii.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../sdl_timer.h"

#include <gccore.h>
#include <ogc/lwp_watchdog.h>

uint64_t startTime = -1;

//uint32_t SDL_GetTicks()
//{
//    if(startTime == (uint64_t)-1)
//    {
//        startTime = gettime();
//    }
//    return diff_msec(startTime, gettime());
//}

uint64_t SDL_GetMicroTicks()
{
    if(startTime == (uint64_t)-1)
        startTime = gettime();

    return diff_usec(startTime, gettime());
}


================================================
FILE: lib/sdl_proxy_rwops/CMakeLists.txt
================================================
# A minimal shim to allow a platform unsupported by SDL2 to use the SDL_RWops interface
# Copyright 2024 ds-sloth
# Released under GPLv3.0 or later

cmake_minimum_required(VERSION 3.5...3.10)

if(POLICY CMP0069) # Allow CMAKE_INTERPROCEDURAL_OPTIMIZATION (lto) to be set
    cmake_policy(SET CMP0069 NEW)
endif()

project(sdl_proxy_rwops CXX)

add_library(sdl_proxy_rwops STATIC EXCLUDE_FROM_ALL
    sdl_proxy_rwops.c
    sdl_proxy_rwops_file.c
)

target_include_directories(sdl_proxy_rwops PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)


================================================
FILE: lib/sdl_proxy_rwops/include/SDL2/SDL_rwops.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SDL_PROXY_RWOPS_H
#define SDL_PROXY_RWOPS_H

#include <stdint.h>
#include <stddef.h>
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

/* RWops Types */
#define SDL_RWOPS_UNKNOWN   0U  /**< Unknown stream type */
#define SDL_RWOPS_STDFILE   2U  /**< Stdio file */

#define RW_SEEK_CUR SEEK_CUR
#define RW_SEEK_SET SEEK_SET
#define RW_SEEK_END SEEK_END

typedef struct SDL_RWops
{
    /**
     *  Return the size of the file in this rwops, or -1 if unknown
     */
    int64_t (* size) (struct SDL_RWops * context);

    /**
     *  Seek to `offset` relative to `whence`, one of stdio's whence values:
     *  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
     *
     *  \return the final offset in the data stream, or -1 on error.
     */
    int64_t (* seek) (struct SDL_RWops * context, int64_t offset,
                             int whence);

    /**
     *  Read up to `maxnum` objects each of size `size` from the data
     *  stream to the area pointed at by `ptr`.
     *
     *  \return the number of objects read, or 0 at error or end of file.
     */
    size_t (* read) (struct SDL_RWops * context, void *ptr,
                             size_t size, size_t maxnum);

    /**
     *  Write exactly `num` objects each of size `size` from the area
     *  pointed at by `ptr` to data stream.
     *
     *  \return the number of objects written, or 0 at error or end of file.
     */
    size_t (* write) (struct SDL_RWops * context, const void *ptr,
                              size_t size, size_t num);

    /**
     *  Close and free an allocated SDL_RWops structure.
     *
     *  \return 0 if successful or -1 on write error when flushing data.
     */
    int (* close) (struct SDL_RWops * context);

    int type;

    union
    {
      struct
      {
          void *data1;
      } unknown;
    } hidden;
} SDL_RWops;

SDL_RWops* SDL_AllocRW();
void SDL_FreeRW(SDL_RWops * area);
SDL_RWops* SDL_RWFromFile(const char* pathname, const char* mode);

#ifdef __cplusplus
} // extern "C"
#endif

/* C declarations or C++ inline definitions of standard RWops functions */
#include "_priv_rwops_funcs.h"

#endif /* #ifndef SDL_PROXY_RWOPS_H */


================================================
FILE: lib/sdl_proxy_rwops/include/SDL2/_priv_rwops_funcs.h
================================================
#ifdef RWOPS_C_DEFINITIONS
/* non-inline definitions of normal RWops functions for C */
#    define RWOPS_PREFIX
#    define RWOPS_BODY(x) x
#elif defined(__cplusplus)
// inline definitions of normal RWops functions for C++
#    define RWOPS_PREFIX inline
#    define RWOPS_BODY(x) x
#else
/* non-inline declarations of normal RWops functions for C */
#    define RWOPS_PREFIX
#    define RWOPS_BODY(x) ;
#endif

RWOPS_PREFIX int64_t SDL_RWsize(SDL_RWops* stream)
RWOPS_BODY({
    return stream->size(stream);
})

RWOPS_PREFIX int64_t SDL_RWseek(SDL_RWops* stream, int64_t offset, int whence)
RWOPS_BODY({
    return stream->seek(stream, offset, whence);
})

RWOPS_PREFIX size_t SDL_RWread(SDL_RWops* stream, void* ptr, size_t size, size_t nmemb)
RWOPS_BODY({
    return stream->read(stream, ptr, size, nmemb);
})

RWOPS_PREFIX size_t SDL_RWwrite(SDL_RWops* stream, const void* ptr, size_t size, size_t nmemb)
RWOPS_BODY({
    return stream->write(stream, ptr, size, nmemb);
})

RWOPS_PREFIX int SDL_RWclose(SDL_RWops* stream)
RWOPS_BODY({
    if(!stream)
        return 0;

    int ret = stream->close(stream);
    SDL_FreeRW(stream);
    return ret;
})

RWOPS_PREFIX long SDL_RWtell(SDL_RWops* stream)
RWOPS_BODY({
    return stream->seek(stream, 0, RW_SEEK_CUR);
})

#undef RWOPS_PREFIX
#undef RWOPS_BODY


================================================
FILE: lib/sdl_proxy_rwops/sdl_proxy_rwops.c
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <malloc.h>
#include <SDL2/SDL_rwops.h>

SDL_RWops* SDL_AllocRW()
{
    return (SDL_RWops*)(malloc(sizeof(SDL_RWops)));
}

void SDL_FreeRW(SDL_RWops * area)
{
    free(area);
}

/* C definitions of standard RWops functions */
#define RWOPS_C_DEFINITIONS
#include <SDL2/_priv_rwops_funcs.h>


================================================
FILE: lib/sdl_proxy_rwops/sdl_proxy_rwops_file.c
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <SDL2/SDL_rwops.h>

#ifdef _WIN32
#include <windows.h>
#include <shlwapi.h>
#else
#include <stdio.h>
#endif

/* from files.cpp */
static inline FILE *utf8_fopen(const char *filePath, const char *modes)
{
#ifndef _WIN32
    return fopen(filePath, modes);
#else
    wchar_t wfile[MAX_PATH + 1];
    wchar_t wmode[21];
    int wfile_len = (int)strlen(filePath);
    int wmode_len = (int)strlen(modes);
    wfile_len = MultiByteToWideChar(CP_UTF8, 0, filePath, wfile_len, wfile, MAX_PATH);
    wmode_len = MultiByteToWideChar(CP_UTF8, 0, modes, wmode_len, wmode, 20);
    wfile[wfile_len] = L'\0';
    wmode[wmode_len] = L'\0';
    return _wfopen(wfile, wmode);
#endif
}

static int64_t s_file_size(SDL_RWops* stream)
{
    if(!stream || !stream->hidden.unknown.data1)
        return -1;

    long curpos = ftell(stream->hidden.unknown.data1);

    fseek(stream->hidden.unknown.data1, 0, SEEK_END);
    int64_t filesize = (int64_t)(ftell(stream->hidden.unknown.data1));

    fseek(stream->hidden.unknown.data1, curpos, SEEK_SET);

    return filesize;
}

static int64_t s_file_seek(SDL_RWops* stream, int64_t offset, int whence)
{
    if(whence == RW_SEEK_CUR && offset == 0)
    {
        // skip the seek
    }
    else if(fseek(stream->hidden.unknown.data1, offset, whence))
        return -1;

    return ftell(stream->hidden.unknown.data1);
}

static size_t s_file_read(SDL_RWops* stream, void* ptr, size_t size, size_t nmemb)
{
    return fread(ptr, size, nmemb, stream->hidden.unknown.data1);
}

static size_t s_file_write(SDL_RWops* stream, const void* ptr, size_t size, size_t nmemb)
{
    return fwrite(ptr, size, nmemb, stream->hidden.unknown.data1);
}

static int s_file_close(SDL_RWops* stream)
{
    return fclose(stream->hidden.unknown.data1);
}

SDL_RWops* SDL_RWFromFile(const char* pathname, const char* mode)
{
    FILE* f = utf8_fopen(pathname, mode);
    if(!f)
        return NULL;

    SDL_RWops* ret = SDL_AllocRW();

    if(!ret)
    {
        fclose(f);
        return NULL;
    }

    ret->size = s_file_size;
    ret->seek = s_file_seek;
    ret->read = s_file_read;
    ret->write = s_file_write;
    ret->close = s_file_close;

    ret->type = SDL_RWOPS_STDFILE;
    ret->hidden.unknown.data1 = f;

    return ret;
}


================================================
FILE: lib/sorting/pdqsort.h
================================================
/*
    pdqsort.h - Pattern-defeating quicksort.

    Copyright (c) 2021 Orson Peters

    This software is provided 'as-is', without any express or implied warranty. In no event will the
    authors be held liable for any damages arising from the use of this software.

    Permission is granted to anyone to use this software for any purpose, including commercial
    applications, and to alter it and redistribute it freely, subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not claim that you wrote the
       original software. If you use this software in a product, an acknowledgment in the product
       documentation would be appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must not be misrepresented as
       being the original software.

    3. This notice may not be removed or altered from any source distribution.

    In use by TheXTech and/or Moondust projects. Sourced from https://github.com/orlp/pdqsort, revision b1ef26a5. Not yet modified.
*/


#ifndef PDQSORT_H
#define PDQSORT_H

#include <algorithm>
#include <cstddef>
#include <functional>
#include <utility>
#include <iterator>

#if __cplusplus >= 201103L
    #include <cstdint>
    #include <type_traits>
    #define PDQSORT_PREFER_MOVE(x) std::move(x)
#else
    #define PDQSORT_PREFER_MOVE(x) (x)
#endif


namespace pdqsort_detail {
    enum {
        // Partitions below this size are sorted using insertion sort.
        insertion_sort_threshold = 24,

        // Partitions above this size use Tukey's ninther to select the pivot.
        ninther_threshold = 128,

        // When we detect an already sorted partition, attempt an insertion sort that allows this
        // amount of element moves before giving up.
        partial_insertion_sort_limit = 8,

        // Must be multiple of 8 due to loop unrolling, and < 256 to fit in unsigned char.
        block_size = 64,

        // Cacheline size, assumes power of two.
        cacheline_size = 64

    };

#if __cplusplus >= 201103L
    template<class T> struct is_default_compare : std::false_type { };
    template<class T> struct is_default_compare<std::less<T>> : std::true_type { };
    template<class T> struct is_default_compare<std::greater<T>> : std::true_type { };
#endif

    // Returns floor(log2(n)), assumes n > 0.
    template<class T>
    inline int log2(T n) {
        int log = 0;
        while (n >>= 1) ++log;
        return log;
    }

    // Sorts [begin, end) using insertion sort with the given comparison function.
    template<class Iter, class Compare>
    inline void insertion_sort(Iter begin, Iter end, Compare comp) {
        typedef typename std::iterator_traits<Iter>::value_type T;
        if (begin == end) return;

        for (Iter cur = begin + 1; cur != end; ++cur) {
            Iter sift = cur;
            Iter sift_1 = cur - 1;

            // Compare first so we can avoid 2 moves for an element already positioned correctly.
            if (comp(*sift, *sift_1)) {
                T tmp = PDQSORT_PREFER_MOVE(*sift);

                do { *sift-- = PDQSORT_PREFER_MOVE(*sift_1); }
                while (sift != begin && comp(tmp, *--sift_1));

                *sift = PDQSORT_PREFER_MOVE(tmp);
            }
        }
    }

    // Sorts [begin, end) using insertion sort with the given comparison function. Assumes
    // *(begin - 1) is an element smaller than or equal to any element in [begin, end).
    template<class Iter, class Compare>
    inline void unguarded_insertion_sort(Iter begin, Iter end, Compare comp) {
        typedef typename std::iterator_traits<Iter>::value_type T;
        if (begin == end) return;

        for (Iter cur = begin + 1; cur != end; ++cur) {
            Iter sift = cur;
            Iter sift_1 = cur - 1;

            // Compare first so we can avoid 2 moves for an element already positioned correctly.
            if (comp(*sift, *sift_1)) {
                T tmp = PDQSORT_PREFER_MOVE(*sift);

                do { *sift-- = PDQSORT_PREFER_MOVE(*sift_1); }
                while (comp(tmp, *--sift_1));

                *sift = PDQSORT_PREFER_MOVE(tmp);
            }
        }
    }

    // Attempts to use insertion sort on [begin, end). Will return false if more than
    // partial_insertion_sort_limit elements were moved, and abort sorting. Otherwise it will
    // successfully sort and return true.
    template<class Iter, class Compare>
    inline bool partial_insertion_sort(Iter begin, Iter end, Compare comp) {
        typedef typename std::iterator_traits<Iter>::value_type T;
        if (begin == end) return true;
        
        std::size_t limit = 0;
        for (Iter cur = begin + 1; cur != end; ++cur) {
            Iter sift = cur;
            Iter sift_1 = cur - 1;

            // Compare first so we can avoid 2 moves for an element already positioned correctly.
            if (comp(*sift, *sift_1)) {
                T tmp = PDQSORT_PREFER_MOVE(*sift);

                do { *sift-- = PDQSORT_PREFER_MOVE(*sift_1); }
                while (sift != begin && comp(tmp, *--sift_1));

                *sift = PDQSORT_PREFER_MOVE(tmp);
                limit += cur - sift;
            }
            
            if (limit > partial_insertion_sort_limit) return false;
        }

        return true;
    }

    template<class Iter, class Compare>
    inline void sort2(Iter a, Iter b, Compare comp) {
        if (comp(*b, *a)) std::iter_swap(a, b);
    }

    // Sorts the elements *a, *b and *c using comparison function comp.
    template<class Iter, class Compare>
    inline void sort3(Iter a, Iter b, Iter c, Compare comp) {
        sort2(a, b, comp);
        sort2(b, c, comp);
        sort2(a, b, comp);
    }

    template<class T>
    inline T* align_cacheline(T* p) {
#if defined(UINTPTR_MAX) && __cplusplus >= 201103L
        std::uintptr_t ip = reinterpret_cast<std::uintptr_t>(p);
#else
        std::size_t ip = reinterpret_cast<std::size_t>(p);
#endif
        ip = (ip + cacheline_size - 1) & -cacheline_size;
        return reinterpret_cast<T*>(ip);
    }

    template<class Iter>
    inline void swap_offsets(Iter first, Iter last,
                             unsigned char* offsets_l, unsigned char* offsets_r,
                             size_t num, bool use_swaps) {
        typedef typename std::iterator_traits<Iter>::value_type T;
        if (use_swaps) {
            // This case is needed for the descending distribution, where we need
            // to have proper swapping for pdqsort to remain O(n).
            for (size_t i = 0; i < num; ++i) {
                std::iter_swap(first + offsets_l[i], last - offsets_r[i]);
            }
        } else if (num > 0) {
            Iter l = first + offsets_l[0]; Iter r = last - offsets_r[0];
            T tmp(PDQSORT_PREFER_MOVE(*l)); *l = PDQSORT_PREFER_MOVE(*r);
            for (size_t i = 1; i < num; ++i) {
                l = first + offsets_l[i]; *r = PDQSORT_PREFER_MOVE(*l);
                r = last - offsets_r[i]; *l = PDQSORT_PREFER_MOVE(*r);
            }
            *r = PDQSORT_PREFER_MOVE(tmp);
        }
    }

    // Partitions [begin, end) around pivot *begin using comparison function comp. Elements equal
    // to the pivot are put in the right-hand partition. Returns the position of the pivot after
    // partitioning and whether the passed sequence already was correctly partitioned. Assumes the
    // pivot is a median of at least 3 elements and that [begin, end) is at least
    // insertion_sort_threshold long. Uses branchless partitioning.
    template<class Iter, class Compare>
    inline std::pair<Iter, bool> partition_right_branchless(Iter begin, Iter end, Compare comp) {
        typedef typename std::iterator_traits<Iter>::value_type T;

        // Move pivot into local for speed.
        T pivot(PDQSORT_PREFER_MOVE(*begin));
        Iter first = begin;
        Iter last = end;

        // Find the first element greater than or equal than the pivot (the median of 3 guarantees
        // this exists).
        while (comp(*++first, pivot));

        // Find the first element strictly smaller than the pivot. We have to guard this search if
        // there was no element before *first.
        if (first - 1 == begin) while (first < last && !comp(*--last, pivot));
        else                    while (                !comp(*--last, pivot));

        // If the first pair of elements that should be swapped to partition are the same element,
        // the passed in sequence already was correctly partitioned.
        bool already_partitioned = first >= last;
        if (!already_partitioned) {
            std::iter_swap(first, last);
            ++first;

            // The following branchless partitioning is derived from "BlockQuicksort: How Branch
            // Mispredictions don’t affect Quicksort" by Stefan Edelkamp and Armin Weiss, but
            // heavily micro-optimized.
            unsigned char offsets_l_storage[block_size + cacheline_size];
            unsigned char offsets_r_storage[block_size + cacheline_size];
            unsigned char* offsets_l = align_cacheline(offsets_l_storage);
            unsigned char* offsets_r = align_cacheline(offsets_r_storage);

            Iter offsets_l_base = first;
            Iter offsets_r_base = last;
            size_t num_l, num_r, start_l, start_r;
            num_l = num_r = start_l = start_r = 0;
            
            while (first < last) {
                // Fill up offset blocks with elements that are on the wrong side.
                // First we determine how much elements are considered for each offset block.
                size_t num_unknown = last - first;
                size_t left_split = num_l == 0 ? (num_r == 0 ? num_unknown / 2 : num_unknown) : 0;
                size_t right_split = num_r == 0 ? (num_unknown - left_split) : 0;

                // Fill the offset blocks.
                if (left_split >= block_size) {
                    for (size_t i = 0; i < block_size;) {
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                    }
                } else {
                    for (size_t i = 0; i < left_split;) {
                        offsets_l[num_l] = i++; num_l += !comp(*first, pivot); ++first;
                    }
                }

                if (right_split >= block_size) {
                    for (size_t i = 0; i < block_size;) {
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                    }
                } else {
                    for (size_t i = 0; i < right_split;) {
                        offsets_r[num_r] = ++i; num_r += comp(*--last, pivot);
                    }
                }

                // Swap elements and update block sizes and first/last boundaries.
                size_t num = std::min(num_l, num_r);
                swap_offsets(offsets_l_base, offsets_r_base,
                             offsets_l + start_l, offsets_r + start_r,
                             num, num_l == num_r);
                num_l -= num; num_r -= num;
                start_l += num; start_r += num;

                if (num_l == 0) {
                    start_l = 0;
                    offsets_l_base = first;
                }
                
                if (num_r == 0) {
                    start_r = 0;
                    offsets_r_base = last;
                }
            }

            // We have now fully identified [first, last)'s proper position. Swap the last elements.
            if (num_l) {
                offsets_l += start_l;
                while (num_l--) std::iter_swap(offsets_l_base + offsets_l[num_l], --last);
                first = last;
            }
            if (num_r) {
                offsets_r += start_r;
                while (num_r--) std::iter_swap(offsets_r_base - offsets_r[num_r], first), ++first;
                last = first;
            }
        }

        // Put the pivot in the right place.
        Iter pivot_pos = first - 1;
        *begin = PDQSORT_PREFER_MOVE(*pivot_pos);
        *pivot_pos = PDQSORT_PREFER_MOVE(pivot);

        return std::make_pair(pivot_pos, already_partitioned);
    }



    // Partitions [begin, end) around pivot *begin using comparison function comp. Elements equal
    // to the pivot are put in the right-hand partition. Returns the position of the pivot after
    // partitioning and whether the passed sequence already was correctly partitioned. Assumes the
    // pivot is a median of at least 3 elements and that [begin, end) is at least
    // insertion_sort_threshold long.
    template<class Iter, class Compare>
    inline std::pair<Iter, bool> partition_right(Iter begin, Iter end, Compare comp) {
        typedef typename std::iterator_traits<Iter>::value_type T;
        
        // Move pivot into local for speed.
        T pivot(PDQSORT_PREFER_MOVE(*begin));

        Iter first = begin;
        Iter last = end;

        // Find the first element greater than or equal than the pivot (the median of 3 guarantees
        // this exists).
        while (comp(*++first, pivot));

        // Find the first element strictly smaller than the pivot. We have to guard this search if
        // there was no element before *first.
        if (first - 1 == begin) while (first < last && !comp(*--last, pivot));
        else                    while (                !comp(*--last, pivot));

        // If the first pair of elements that should be swapped to partition are the same element,
        // the passed in sequence already was correctly partitioned.
        bool already_partitioned = first >= last;
        
        // Keep swapping pairs of elements that are on the wrong side of the pivot. Previously
        // swapped pairs guard the searches, which is why the first iteration is special-cased
        // above.
        while (first < last) {
            std::iter_swap(first, last);
            while (comp(*++first, pivot));
            while (!comp(*--last, pivot));
        }

        // Put the pivot in the right place.
        Iter pivot_pos = first - 1;
        *begin = PDQSORT_PREFER_MOVE(*pivot_pos);
        *pivot_pos = PDQSORT_PREFER_MOVE(pivot);

        return std::make_pair(pivot_pos, already_partitioned);
    }

    // Similar function to the one above, except elements equal to the pivot are put to the left of
    // the pivot and it doesn't check or return if the passed sequence already was partitioned.
    // Since this is rarely used (the many equal case), and in that case pdqsort already has O(n)
    // performance, no block quicksort is applied here for simplicity.
    template<class Iter, class Compare>
    inline Iter partition_left(Iter begin, Iter end, Compare comp) {
        typedef typename std::iterator_traits<Iter>::value_type T;

        T pivot(PDQSORT_PREFER_MOVE(*begin));
        Iter first = begin;
        Iter last = end;
        
        while (comp(pivot, *--last));

        if (last + 1 == end) while (first < last && !comp(pivot, *++first));
        else                 while (                !comp(pivot, *++first));

        while (first < last) {
            std::iter_swap(first, last);
            while (comp(pivot, *--last));
            while (!comp(pivot, *++first));
        }

        Iter pivot_pos = last;
        *begin = PDQSORT_PREFER_MOVE(*pivot_pos);
        *pivot_pos = PDQSORT_PREFER_MOVE(pivot);

        return pivot_pos;
    }


    template<class Iter, class Compare, bool Branchless>
    inline void pdqsort_loop(Iter begin, Iter end, Compare comp, int bad_allowed, bool leftmost = true) {
        typedef typename std::iterator_traits<Iter>::difference_type diff_t;

        // Use a while loop for tail recursion elimination.
        while (true) {
            diff_t size = end - begin;

            // Insertion sort is faster for small arrays.
            if (size < insertion_sort_threshold) {
                if (leftmost) insertion_sort(begin, end, comp);
                else unguarded_insertion_sort(begin, end, comp);
                return;
            }

            // Choose pivot as median of 3 or pseudomedian of 9.
            diff_t s2 = size / 2;
            if (size > ninther_threshold) {
                sort3(begin, begin + s2, end - 1, comp);
                sort3(begin + 1, begin + (s2 - 1), end - 2, comp);
                sort3(begin + 2, begin + (s2 + 1), end - 3, comp);
                sort3(begin + (s2 - 1), begin + s2, begin + (s2 + 1), comp);
                std::iter_swap(begin, begin + s2);
            } else sort3(begin + s2, begin, end - 1, comp);

            // If *(begin - 1) is the end of the right partition of a previous partition operation
            // there is no element in [begin, end) that is smaller than *(begin - 1). Then if our
            // pivot compares equal to *(begin - 1) we change strategy, putting equal elements in
            // the left partition, greater elements in the right partition. We do not have to
            // recurse on the left partition, since it's sorted (all equal).
            if (!leftmost && !comp(*(begin - 1), *begin)) {
                begin = partition_left(begin, end, comp) + 1;
                continue;
            }

            // Partition and get results.
            std::pair<Iter, bool> part_result =
                Branchless ? partition_right_branchless(begin, end, comp)
                           : partition_right(begin, end, comp);
            Iter pivot_pos = part_result.first;
            bool already_partitioned = part_result.second;

            // Check for a highly unbalanced partition.
            diff_t l_size = pivot_pos - begin;
            diff_t r_size = end - (pivot_pos + 1);
            bool highly_unbalanced = l_size < size / 8 || r_size < size / 8;

            // If we got a highly unbalanced partition we shuffle elements to break many patterns.
            if (highly_unbalanced) {
                // If we had too many bad partitions, switch to heapsort to guarantee O(n log n).
                if (--bad_allowed == 0) {
                    std::make_heap(begin, end, comp);
                    std::sort_heap(begin, end, comp);
                    return;
                }

                if (l_size >= insertion_sort_threshold) {
                    std::iter_swap(begin,             begin + l_size / 4);
                    std::iter_swap(pivot_pos - 1, pivot_pos - l_size / 4);

                    if (l_size > ninther_threshold) {
                        std::iter_swap(begin + 1,         begin + (l_size / 4 + 1));
                        std::iter_swap(begin + 2,         begin + (l_size / 4 + 2));
                        std::iter_swap(pivot_pos - 2, pivot_pos - (l_size / 4 + 1));
                        std::iter_swap(pivot_pos - 3, pivot_pos - (l_size / 4 + 2));
                    }
                }
                
                if (r_size >= insertion_sort_threshold) {
                    std::iter_swap(pivot_pos + 1, pivot_pos + (1 + r_size / 4));
                    std::iter_swap(end - 1,                   end - r_size / 4);
                    
                    if (r_size > ninther_threshold) {
                        std::iter_swap(pivot_pos + 2, pivot_pos + (2 + r_size / 4));
                        std::iter_swap(pivot_pos + 3, pivot_pos + (3 + r_size / 4));
                        std::iter_swap(end - 2,             end - (1 + r_size / 4));
                        std::iter_swap(end - 3,             end - (2 + r_size / 4));
                    }
                }
            } else {
                // If we were decently balanced and we tried to sort an already partitioned
                // sequence try to use insertion sort.
                if (already_partitioned && partial_insertion_sort(begin, pivot_pos, comp)
                                        && partial_insertion_sort(pivot_pos + 1, end, comp)) return;
            }
                
            // Sort the left partition first using recursion and do tail recursion elimination for
            // the right-hand partition.
            pdqsort_loop<Iter, Compare, Branchless>(begin, pivot_pos, comp, bad_allowed, leftmost);
            begin = pivot_pos + 1;
            leftmost = false;
        }
    }
}


template<class Iter, class Compare>
inline void pdqsort(Iter begin, Iter end, Compare comp) {
    if (begin == end) return;

#if __cplusplus >= 201103L
    pdqsort_detail::pdqsort_loop<Iter, Compare,
        pdqsort_detail::is_default_compare<typename std::decay<Compare>::type>::value &&
        std::is_arithmetic<typename std::iterator_traits<Iter>::value_type>::value>(
        begin, end, comp, pdqsort_detail::log2(end - begin));
#else
    pdqsort_detail::pdqsort_loop<Iter, Compare, false>(
        begin, end, comp, pdqsort_detail::log2(end - begin));
#endif
}

template<class Iter>
inline void pdqsort(Iter begin, Iter end) {
    typedef typename std::iterator_traits<Iter>::value_type T;
    pdqsort(begin, end, std::less<T>());
}

template<class Iter, class Compare>
inline void pdqsort_branchless(Iter begin, Iter end, Compare comp) {
    if (begin == end) return;
    pdqsort_detail::pdqsort_loop<Iter, Compare, true>(
        begin, end, comp, pdqsort_detail::log2(end - begin));
}

template<class Iter>
inline void pdqsort_branchless(Iter begin, Iter end) {
    typedef typename std::iterator_traits<Iter>::value_type T;
    pdqsort_branchless(begin, end, std::less<T>());
}


#undef PDQSORT_PREFER_MOVE

#endif


================================================
FILE: lib/sorting/tinysort.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef THEXTECH_TINY_SORT_H
#define THEXTECH_TINY_SORT_H

#include <functional>
#include <iterator>

// an extremely simple insertion sort implementation intended for correctness as a stable sort, and code size.
// DO NOT USE IF PERFORMANCE IS IMPORTANT.
template<class it, class compare_func>
inline void tinysort(it begin, it end, compare_func comp)
{
    if(begin == end)
        return;

    typedef typename std::iterator_traits<it>::value_type T;

    for(it i = begin + 1; i != end; ++i)
    {
        T x = std::move(*i);

        it j;
        for(j = i; j > begin && comp(x, *(j - 1)); --j)
            *j = std::move(*(j - 1));

        *j = std::move(x);
    }
}

template<class it>
inline void tinysort(it begin, it end)
{
    typedef typename std::iterator_traits<it>::value_type T;
    tinysort(begin, end, std::less<T>());
}

#endif // #ifndef THEXTECH_TINY_SORT_H


================================================
FILE: lib/tclap/Arg.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  Arg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno .
 *  Copyright (c) 2017 Google Inc.
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_ARG_H
#define TCLAP_ARG_H

#ifdef HAVE_TCLAP_CONFIG_H
#include <tclap/TCLAPConfig.h>
#endif

#include <tclap/ArgException.h>
#include <tclap/ArgTraits.h>
#include <tclap/CmdLineInterface.h>
#include <tclap/StandardTraits.h>
#include <tclap/Visitor.h>
#include <tclap/sstream.h>

#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <string>
#include <vector>

namespace TCLAP {

/**
 * A virtual base class that defines the essential data for all arguments.
 * This class, or one of its existing children, must be subclassed to do
 * anything.
 */
class Arg {
private:
    /**
     * Prevent accidental copying.
     */
    Arg(const Arg &rhs);

    /**
     * Prevent accidental copying.
     */
    Arg &operator=(const Arg &rhs);

    /**
     * The delimiter that separates an argument flag/name from the
     * value.
     */
    static char &delimiterRef() {
        static char delim = ' ';
        return delim;
    }

protected:
    /**
     * The single char flag used to identify the argument.
     * This value (preceded by a dash {-}), can be used to identify
     * an argument on the command line.  The _flag can be blank,
     * in fact this is how unlabeled args work.  Unlabeled args must
     * override appropriate functions to get correct handling. Note
     * that the _flag does NOT include the dash as part of the flag.
     */
    std::string _flag;

    /**
     * A single word namd identifying the argument.
     * This value (preceded by two dashed {--}) can also be used
     * to identify an argument on the command line.  Note that the
     * _name does NOT include the two dashes as part of the _name. The
     * _name cannot be blank.
     */
    std::string _name;

    /**
     * Description of the argument.
     */
    std::string _description;

    /**
     * Indicating whether the argument is required.
     */
    const bool _required;

    /**
     * Label to be used in usage description.  Normally set to
     * "required", but can be changed when necessary.
     */
    std::string _requireLabel;

    /**
     * Indicates whether a value is required for the argument.
     * Note that the value may be required but the argument/value
     * combination may not be, as specified by _required.
     */
    bool _valueRequired;

    /**
     * Indicates whether the argument has been set.
     * Indicates that a value on the command line has matched the
     * name/flag of this argument and the values have been set accordingly.
     */
    bool _alreadySet;

    /** Indicates the value specified to set this flag (like -a or --all).
     */
    std::string _setBy;

    /**
     * A pointer to a visitor object.
     * The visitor allows special handling to occur as soon as the
     * argument is matched.  This defaults to NULL and should not
     * be used unless absolutely necessary.
     */
    Visitor *_visitor;

    /**
     * Whether this argument can be ignored, if desired.
     */
    bool _ignoreable;

    bool _acceptsMultipleValues;

    /**
     * Indicates if the argument is visible in the help output (e.g.,
     * when specifying --help).
     */
    bool _visibleInHelp;

    /**
     * Performs the special handling described by the Visitor.
     */
    void _checkWithVisitor() const;

    /**
     * Primary constructor. YOU (yes you) should NEVER construct an Arg
     * directly, this is a base class that is extended by various children
     * that are meant to be used.  Use SwitchArg, ValueArg, MultiArg,
     * UnlabeledValueArg, or UnlabeledMultiArg instead.
     *
     * \param flag - The flag identifying the argument.
     * \param name - The name identifying the argument.
     * \param desc - The description of the argument, used in the usage.
     * \param req - Whether the argument is required.
     * \param valreq - Whether the a value is required for the argument.
     * \param v - The visitor checked by the argument. Defaults to NULL.
     */
    Arg(const std::string &flag, const std::string &name,
        const std::string &desc, bool req, bool valreq, Visitor *v = NULL);

public:
    /**
     * Destructor.
     */
    virtual ~Arg();

    /**
     * Adds this to the specified list of Args.
     * \param argList - The list to add this to.
     */
    virtual void addToList(std::list<Arg *> &argList) const;

    /**
     * The delimiter that separates an argument flag/name from the
     * value.
     */
    static char delimiter() { return delimiterRef(); }

    /**
     * The char used as a place holder when SwitchArgs are combined.
     * Currently set to the bell char (ASCII 7).
     */
    static char blankChar() { return '\a'; }

/**
 * The char that indicates the beginning of a flag.  Defaults to '-', but
 * clients can define TCLAP_FLAGSTARTCHAR to override.
 */
#ifndef TCLAP_FLAGSTARTCHAR
#define TCLAP_FLAGSTARTCHAR '-'
#endif
    static char flagStartChar() { return TCLAP_FLAGSTARTCHAR; }

/**
 * The sting that indicates the beginning of a flag.  Defaults to "-", but
 * clients can define TCLAP_FLAGSTARTSTRING to override. Should be the same
 * as TCLAP_FLAGSTARTCHAR.
 */
#ifndef TCLAP_FLAGSTARTSTRING
#define TCLAP_FLAGSTARTSTRING "-"
#endif
    static const std::string flagStartString() { return TCLAP_FLAGSTARTSTRING; }

/**
 * The sting that indicates the beginning of a name.  Defaults to "--", but
 *  clients can define TCLAP_NAMESTARTSTRING to override.
 */
#ifndef TCLAP_NAMESTARTSTRING
#define TCLAP_NAMESTARTSTRING "--"
#endif
    static const std::string nameStartString() { return TCLAP_NAMESTARTSTRING; }

    /**
     * The name used to identify the ignore rest argument.
     */
    static const std::string ignoreNameString() { return "ignore_rest"; }

    /**
     * Sets the delimiter for all arguments.
     * \param c - The character that delimits flags/names from values.
     */
    static void setDelimiter(char c) { delimiterRef() = c; }

    /**
     * Pure virtual method meant to handle the parsing and value assignment
     * of the string on the command line.
     * \param i - Pointer the the current argument in the list.
     * \param args - Mutable list of strings. What is
     * passed in from main.
     */
    virtual bool processArg(int *i, std::vector<std::string> &args) = 0;

    /**
     * Operator ==.
     * Equality operator. Must be virtual to handle unlabeled args.
     * \param a - The Arg to be compared to this.
     */
    virtual bool operator==(const Arg &a) const;

    /**
     * Returns the argument flag.
     */
    const std::string &getFlag() const;

    /**
     * Returns the argument name.
     */
    const std::string &getName() const;

    /**
     * Returns the argument description.
     */
    std::string getDescription() const { return getDescription(_required); }

    /**
     * Returns the argument description.
     *
     * @param required if the argument should be treated as
     * required when described.
     */
    std::string getDescription(bool required) const {
        return (required ? "(" + _requireLabel + ") " : "") + _description;
    }

    /**
     * Indicates whether the argument is required.
     */
    virtual bool isRequired() const;

    /**
     * Indicates whether a value must be specified for argument.
     */
    bool isValueRequired() const;

    /**
     * Indicates whether the argument has already been set.  Only true
     * if the arg has been matched on the command line.
     */
    bool isSet() const;

    /**
     * Returns the value specified to set this flag (like -a or --all).
     */
    const std::string &setBy() const { return _setBy; }

    /**
     * Indicates whether the argument can be ignored, if desired.
     */
    bool isIgnoreable() const;

    /**
     * A method that tests whether a string matches this argument.
     * This is generally called by the processArg() method.  This
     * method could be re-implemented by a child to change how
     * arguments are specified on the command line.
     * \param s - The string to be compared to the flag/name to determine
     * whether the arg matches.
     */
    virtual bool argMatches(const std::string &s) const;

    /**
     * Returns a simple string representation of the argument.
     * Primarily for debugging.
     */
    virtual std::string toString() const;

    /**
     * Returns a short ID for the usage.
     * \param valueId - The value used in the id.
     */
    virtual std::string shortID(const std::string &valueId = "val") const;

    /**
     * Returns a long ID for the usage.
     * \param valueId - The value used in the id.
     */
    virtual std::string longID(const std::string &valueId = "val") const;

    /**
     * Trims a value off of the flag.
     * \param flag - The string from which the flag and value will be
     * trimmed. Contains the flag once the value has been trimmed.
     * \param value - Where the value trimmed from the string will
     * be stored.
     */
    virtual void trimFlag(std::string &flag, std::string &value) const;

    /**
     * Checks whether a given string has blank chars, indicating that
     * it is a combined SwitchArg.  If so, return true, otherwise return
     * false.
     * \param s - string to be checked.
     */
    bool _hasBlanks(const std::string &s) const;

    /**
     * Used for MultiArgs to determine whether args can still be
     * set.
     */
    virtual bool allowMore();

    /**
     * Use by output classes to determine whether an Arg accepts
     * multiple values.
     */
    virtual bool acceptsMultipleValues();

    /**
     * Clears the Arg object and allows it to be reused by new
     * command lines.
     */
    virtual void reset();

    /**
     * Hide this argument from the help output (e.g., when
     * specifying the --help flag or on error.
     */
    virtual void hideFromHelp(bool hide = true) { _visibleInHelp = !hide; }

    /**
     * Returns true if this Arg is visible in the help output.
     */
    virtual bool visibleInHelp() const { return _visibleInHelp; }

    virtual bool hasLabel() const { return true; }
};

/**
 * Typedef of an Arg list iterator.
 */
typedef std::list<Arg *>::const_iterator ArgListIterator;

/**
 * Typedef of an Arg vector iterator.
 */
typedef std::vector<Arg *>::const_iterator ArgVectorIterator;

/**
 * Typedef of a Visitor list iterator.
 */
typedef std::list<Visitor *>::const_iterator VisitorListIterator;

/*
 * Extract a value of type T from it's string representation contained
 * in strVal. The ValueLike parameter used to select the correct
 * specialization of ExtractValue depending on the value traits of T.
 * ValueLike traits use operator>> to assign the value from strVal.
 */
template <typename T>
void ExtractValue(T &destVal, const std::string &strVal, ValueLike vl) {
    static_cast<void>(vl);  // Avoid warning about unused vl
    istringstream is(strVal.c_str());

    int valuesRead = 0;
    while (is.good()) {
        if (is.peek() != EOF)
#ifdef TCLAP_SETBASE_ZERO
            is >> std::setbase(0) >> destVal;
#else
            is >> destVal;
#endif
        else
            break;

        valuesRead++;
    }

    if (is.fail())
        throw(
            ArgParseException("Couldn't read argument value "
                              "from string '" +
                              strVal + "'"));

    if (valuesRead > 1)
        throw(
            ArgParseException("More than one valid value parsed from "
                              "string '" +
                              strVal + "'"));
}

/*
 * Extract a value of type T from it's string representation contained
 * in strVal. The ValueLike parameter used to select the correct
 * specialization of ExtractValue depending on the value traits of T.
 * StringLike uses assignment (operator=) to assign from strVal.
 */
template <typename T>
void ExtractValue(T &destVal, const std::string &strVal, StringLike sl) {
    static_cast<void>(sl);  // Avoid warning about unused sl
    SetString(destVal, strVal);
}

//////////////////////////////////////////////////////////////////////
// BEGIN Arg.cpp
//////////////////////////////////////////////////////////////////////

inline Arg::Arg(const std::string &flag, const std::string &name,
                const std::string &desc, bool req, bool valreq, Visitor *v)
    : _flag(flag),
      _name(name),
      _description(desc),
      _required(req),
      _requireLabel("required"),
      _valueRequired(valreq),
      _alreadySet(false),
      _setBy(),
      _visitor(v),
      _ignoreable(true),
      _acceptsMultipleValues(false),
      _visibleInHelp(true) {
    if (_flag.length() > 1)
        throw(SpecificationException(
            "Argument flag can only be one character long", toString()));

    if (_name != ignoreNameString() &&
        (_flag == Arg::flagStartString() || _flag == Arg::nameStartString() ||
         _flag == " "))
        throw(SpecificationException(
            "Argument flag cannot be either '" + Arg::flagStartString() +
                "' or '" + Arg::nameStartString() + "' or a space.",
            toString()));

    if ((_name.substr(0, Arg::flagStartString().length()) ==
         Arg::flagStartString()) ||
        (_name.substr(0, Arg::nameStartString().length()) ==
         Arg::nameStartString()) ||
        (_name.find(" ", 0) != std::string::npos))
        throw(SpecificationException("Argument name begin with either '" +
                                         Arg::flagStartString() + "' or '" +
                                         Arg::nameStartString() + "' or space.",
                                     toString()));
}

inline Arg::~Arg() {}

inline std::string Arg::shortID(const std::string &valueId) const {
    std::string id = "";

    if (_flag != "")
        id = Arg::flagStartString() + _flag;
    else
        id = Arg::nameStartString() + _name;

    if (_valueRequired) id += std::string(1, Arg::delimiter()) + valueId;

    return id;
}

inline std::string Arg::longID(const std::string &valueId) const {
    std::string id = "";

    if (_flag != "") {
        id += Arg::flagStartString() + _flag;

        if (_valueRequired) id += std::string(1, Arg::delimiter()) + valueId;

        id += ",  ";
    }

    id += Arg::nameStartString() + _name;

    if (_valueRequired) id += std::string(1, Arg::delimiter()) + valueId;

    return id;
}

inline bool Arg::operator==(const Arg &a) const {
    if ((_flag != "" && _flag == a._flag) || _name == a._name)
        return true;
    else
        return false;
}

inline const std::string &Arg::getFlag() const { return _flag; }

inline const std::string &Arg::getName() const { return _name; }

inline bool Arg::isRequired() const { return _required; }

inline bool Arg::isValueRequired() const { return _valueRequired; }

inline bool Arg::isSet() const { return _alreadySet; }

inline bool Arg::isIgnoreable() const { return _ignoreable; }

inline bool Arg::argMatches(const std::string &argFlag) const {
    if ((argFlag == Arg::flagStartString() + _flag && _flag != "") ||
        argFlag == Arg::nameStartString() + _name)
        return true;
    else
        return false;
}

inline std::string Arg::toString() const {
    std::string s = "";

    if (_flag != "") s += Arg::flagStartString() + _flag + " ";

    s += "(" + Arg::nameStartString() + _name + ")";

    return s;
}

inline void Arg::_checkWithVisitor() const {
    if (_visitor != NULL) _visitor->visit();
}

/**
 * Implementation of trimFlag.
 */
inline void Arg::trimFlag(std::string &flag, std::string &value) const {
    int stop = 0;
    for (int i = 0; static_cast<unsigned int>(i) < flag.length(); i++)
        if (flag[i] == Arg::delimiter()) {
            stop = i;
            break;
        }

    if (stop > 1) {
        value = flag.substr(stop + 1);
        flag = flag.substr(0, stop);
    }
}

/**
 * Implementation of _hasBlanks.
 */
inline bool Arg::_hasBlanks(const std::string &s) const {
    for (int i = 1; static_cast<unsigned int>(i) < s.length(); i++)
        if (s[i] == Arg::blankChar()) return true;

    return false;
}

/**
 * Overridden by Args that need to added to the end of the list.
 */
inline void Arg::addToList(std::list<Arg *> &argList) const {
    argList.push_front(const_cast<Arg *>(this));
}

inline bool Arg::allowMore() { return false; }

inline bool Arg::acceptsMultipleValues() { return _acceptsMultipleValues; }

inline void Arg::reset() { _alreadySet = false; }

//////////////////////////////////////////////////////////////////////
// END Arg.cpp
//////////////////////////////////////////////////////////////////////

}  // namespace TCLAP

#endif  // TCLAP_ARG_H


================================================
FILE: lib/tclap/ArgContainer.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  ArgContainer.h
 *
 *  Copyright (c) 2018 Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_ARG_CONTAINER_H
#define TCLAP_ARG_CONTAINER_H

namespace TCLAP {

class Arg;

/**
 * Interface that allows adding an Arg to a "container".
 *
 * A container does not have to be a container in the C++ standard
 * library sense, just something that wants to hold on to references
 * to Arg's. The container does not own the added Arg's and it is the
 * user's responsibility to ensure the life time (scope) of the Arg's
 * outlives any operations on the container.
 */
class ArgContainer {
public:
    virtual ~ArgContainer() {}

    /**
     * Adds an argument. Ownership is not transfered.
     * \param a - Argument to be added.
     */
    virtual ArgContainer &add(Arg &a) = 0;

    /**
     * Adds an argument. Ownership is not transfered.
     * \param a - Argument to be added.
     */
    virtual ArgContainer &add(Arg *a) = 0;
};

}  // namespace TCLAP

#endif  // TCLAP_ARG_CONTAINER_H


================================================
FILE: lib/tclap/ArgException.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  ArgException.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2017 Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_ARG_EXCEPTION_H
#define TCLAP_ARG_EXCEPTION_H

#include <exception>
#include <string>

namespace TCLAP {

/**
 * A simple class that defines and argument exception.  Should be caught
 * whenever a CmdLine is created and parsed.
 */
class ArgException : public std::exception {
public:
    /**
     * Constructor.
     * \param text - The text of the exception.
     * \param id - The text identifying the argument source.
     * \param td - Text describing the type of ArgException it is.
     * of the exception.
     */
    ArgException(const std::string &text = "undefined exception",
                 const std::string &id = "undefined",
                 const std::string &td = "Generic ArgException")
        : std::exception(),
          _errorText(text),
          _argId(id),
          _typeDescription(td) {}

    /**
     * Destructor.
     */
    virtual ~ArgException() throw() {}

    /**
     * Returns the error text.
     */
    std::string error() const { return (_errorText); }

    /**
     * Returns the argument id.
     */
    std::string argId() const {
        if (_argId == "undefined")
            return " ";
        else
            return ("Argument: " + _argId);
    }

    /**
     * Returns the arg id and error text.
     */
    const char *what() const throw() {
        static std::string ex;
        ex = _argId + " -- " + _errorText;
        return ex.c_str();
    }

    /**
     * Returns the type of the exception.  Used to explain and distinguish
     * between different child exceptions.
     */
    std::string typeDescription() const { return _typeDescription; }

private:
    /**
     * The text of the exception message.
     */
    std::string _errorText;

    /**
     * The argument related to this exception.
     */
    std::string _argId;

    /**
     * Describes the type of the exception.  Used to distinguish
     * between different child exceptions.
     */
    std::string _typeDescription;
};

/**
 * Thrown from within the child Arg classes when it fails to properly
 * parse the argument it has been passed.
 */
class ArgParseException : public ArgException {
public:
    /**
     * Constructor.
     * \param text - The text of the exception.
     * \param id - The text identifying the argument source
     * of the exception.
     */
    ArgParseException(const std::string &text = "undefined exception",
                      const std::string &id = "undefined")
        : ArgException(text, id,
                       std::string("Exception found while parsing ") +
                           std::string("the value the Arg has been passed.")) {}
};

/**
 * Thrown from CmdLine when the arguments on the command line are not
 * properly specified, e.g. too many arguments, required argument missing, etc.
 */
class CmdLineParseException : public ArgException {
public:
    /**
     * Constructor.
     * \param text - The text of the exception.
     * \param id - The text identifying the argument source
     * of the exception.
     */
    CmdLineParseException(const std::string &text = "undefined exception",
                          const std::string &id = "undefined")
        : ArgException(text, id,
                       std::string("Exception found when the values ") +
                           std::string("on the command line do not meet ") +
                           std::string("the requirements of the defined ") +
                           std::string("Args.")) {}
};

/**
 * Thrown from Arg and CmdLine when an Arg is improperly specified, e.g.
 * same flag as another Arg, same name, etc.
 */
class SpecificationException : public ArgException {
public:
    /**
     * Constructor.
     * \param text - The text of the exception.
     * \param id - The text identifying the argument source
     * of the exception.
     */
    SpecificationException(const std::string &text = "undefined exception",
                           const std::string &id = "undefined")
        : ArgException(text, id,
                       std::string("Exception found when an Arg object ") +
                           std::string("is improperly defined by the ") +
                           std::string("developer.")) {}
};

/**
 * Thrown when TCLAP thinks the program should exit.
 *
 * For example after parse error this exception will be thrown (and
 * normally caught). This allows any resource to be clened properly
 * before exit.
 *
 * If exception handling is disabled (CmdLine::setExceptionHandling),
 * this exception will propagate to the call site, allowing the
 * program to catch it and avoid program termination, or do it's own
 * cleanup. See for example, https://sourceforge.net/p/tclap/bugs/29.
 */
class ExitException {
public:
    explicit ExitException(int estat) : _estat(estat) {}

    int getExitStatus() const { return _estat; }

private:
    int _estat;
};

}  // namespace TCLAP

#endif  // TCLAP_ARG_EXCEPTION_H


================================================
FILE: lib/tclap/ArgGroup.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  ArgGroup.h
 *
 *  Copyright (c) 2017 Google LLC.
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_ARG_GROUP_H
#define TCLAP_ARG_GROUP_H

#include <tclap/Arg.h>
#include <tclap/ArgContainer.h>
#include <tclap/CmdLineInterface.h>

#include <list>
#include <string>

namespace TCLAP {

/**
 * ArgGroup is the base class for implementing groups of arguments
 * that are mutually exclusive (it replaces the deprecated xor
 * handler). It is not expected to be used directly, rather one of the
 * EitherOf or OneOf derived classes are used.
 */
class ArgGroup : public ArgContainer {
public:
    typedef std::list<Arg *> Container;
    typedef Container::iterator iterator;
    typedef Container::const_iterator const_iterator;

    virtual ~ArgGroup() {}

    /// Add an argument to this arg group
    virtual ArgContainer &add(Arg &arg) { return add(&arg); }

    /// Add an argument to this arg group
    virtual ArgContainer &add(Arg *arg);

    /**
     * Validates that the constraints of the ArgGroup are satisfied.
     *
     * @internal
     * Throws an CmdLineParseException if there is an issue (except
     * missing required argument, in which case true is returned).
     *
     * @retval true iff a required argument was missing.
     */
    virtual bool validate() = 0;

    /**
     * Returns true if this argument group is required
     *
     * @internal
     */
    virtual bool isRequired() const = 0;

    /**
     * Returns true if this argument group is exclusive.
     *
     * @internal
     * Being exclusive means there is a constraint so that some
     * arguments cannot be selected at the same time.
     */
    virtual bool isExclusive() const = 0;

    /**
     * Used by the parser to connect itself to this arg group.
     *
     * @internal
     * This is needed so that existing and subsequently added args (in
     * this arg group) are also added to the parser (and checked for
     * consistency with other args).
     */
    void setParser(CmdLineInterface &parser) {
        if (_parser) {
            throw SpecificationException("Arg group can have only one parser");
        }

        _parser = &parser;
        for (iterator it = begin(); it != end(); ++it) {
            parser.addToArgList(*it);
        }
    }

    /**
     * If arguments in this group should show up as grouped in help.
     */
    virtual bool showAsGroup() const { return true; }

    /// Returns the argument group's name.
    const std::string getName() const;

    iterator begin() { return _args.begin(); }
    iterator end() { return _args.end(); }
    const_iterator begin() const { return _args.begin(); }
    const_iterator end() const { return _args.end(); }

protected:
    // No direct instantiation
    ArgGroup() : _parser(0), _args() {}

private:
    explicit ArgGroup(const ArgGroup &);
    ArgGroup &operator=(const ArgGroup &);  // no copy

protected:
    CmdLineInterface *_parser;
    Container _args;
};

/**
 * Implements common functionality for exclusive argument groups.
 *
 * @internal
 */
class ExclusiveArgGroup : public ArgGroup {
public:
    inline bool validate();
    bool isExclusive() const { return true; }
    ArgContainer &add(Arg &arg) { return add(&arg); }
    ArgContainer &add(Arg *arg) {
        if (arg->isRequired()) {
            throw SpecificationException(
                "Required arguments are not allowed"
                " in an exclusive grouping.",
                arg->longID());
        }

        return ArgGroup::add(arg);
    }

protected:
    ExclusiveArgGroup() {}
    explicit ExclusiveArgGroup(CmdLineInterface &parser) { parser.add(*this); }
};

/**
 * Implements a group of arguments where at most one can be selected.
 */
class EitherOf : public ExclusiveArgGroup {
public:
    EitherOf() {}
    explicit EitherOf(CmdLineInterface &parser) : ExclusiveArgGroup(parser) {}

    bool isRequired() const { return false; }
};

/**
 * Implements a group of arguments where exactly one must be
 * selected. This corresponds to the deprecated "xoradd".
 */
class OneOf : public ExclusiveArgGroup {
public:
    OneOf() {}
    explicit OneOf(CmdLineInterface &parser) : ExclusiveArgGroup(parser) {}

    bool isRequired() const { return true; }
};

/**
 * Implements a group of arguments where any combination is possible
 * (including all or none). This is mostly used in case one optional
 * argument allows additional arguments to be specified (for example
 * [-c [-de] [-n <int>]]).
 */
class AnyOf : public ArgGroup {
public:
    AnyOf() {}
    explicit AnyOf(CmdLineInterface &parser) { parser.add(*this); }

    bool validate() { return false; /* All good */ }
    bool isExclusive() const { return false; }
    bool isRequired() const { return false; }
};

inline ArgContainer &ArgGroup::add(Arg *arg) {
    for (iterator it = begin(); it != end(); it++) {
        if (*arg == **it) {
            throw SpecificationException(
                "Argument with same flag/name already exists!", arg->longID());
        }
    }

    _args.push_back(arg);
    if (_parser) {
        _parser->addToArgList(arg);
    }

    return *this;
}

inline bool ExclusiveArgGroup::validate() {
    Arg *arg = NULL;
    std::string flag;

    for (const_iterator it = begin(); it != end(); ++it) {
        if ((*it)->isSet()) {
            if (arg != NULL && !(*arg == **it)) {
                // We found a matching argument, but one was
                // already found previously.
                throw CmdLineParseException(
                    "Only one is allowed.",
                    flag + " AND " + (*it)->setBy() + " provided.");
            }

            arg = *it;
            flag = arg->setBy();
        }
    }

    return isRequired() && !arg;
}

inline const std::string ArgGroup::getName() const {
    std::string name;
    std::string sep = "{";  // TODO: this should change for
                            // non-exclusive arg groups
    for (const_iterator it = begin(); it != end(); ++it) {
        name += sep + (*it)->getName();
        sep = " | ";
    }

    return name + '}';
}

/// @internal
inline int CountVisibleArgs(const ArgGroup &g) {
    int visible = 0;
    for (ArgGroup::const_iterator it = g.begin(); it != g.end(); ++it) {
        if ((*it)->visibleInHelp()) {
            visible++;
        }
    }

    return visible;
}

}  // namespace TCLAP

#endif  // TCLAP_ARG_GROUP_H


================================================
FILE: lib/tclap/ArgTraits.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  ArgTraits.h
 *
 *  Copyright (c) 2007, Daniel Aarno, Michael E. Smoot .
 *  Copyright (c) 2017 Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

// This is an internal tclap file, you should probably not have to
// include this directly

#ifndef TCLAP_ARG_TRAITS_H
#define TCLAP_ARG_TRAITS_H

namespace TCLAP {

// We use two empty structs to get compile type specialization
// function to work

/**
 * A value like argument value type is a value that can be set using
 * operator>>. This is the default value type.
 */
struct ValueLike {
    typedef ValueLike ValueCategory;
    virtual ~ValueLike() {}
};

/**
 * A string like argument value type is a value that can be set using
 * operator=(string). Useful if the value type contains spaces which
 * will be broken up into individual tokens by operator>>.
 */
struct StringLike {
    virtual ~StringLike() {}
};

/**
 * A class can inherit from this object to make it have string like
 * traits. This is a compile time thing and does not add any overhead
 * to the inherenting class.
 */
struct StringLikeTrait {
    typedef StringLike ValueCategory;
    virtual ~StringLikeTrait() {}
};

/**
 * A class can inherit from this object to make it have value like
 * traits. This is a compile time thing and does not add any overhead
 * to the inherenting class.
 */
struct ValueLikeTrait {
    typedef ValueLike ValueCategory;
    virtual ~ValueLikeTrait() {}
};

/**
 * Arg traits are used to get compile type specialization when parsing
 * argument values. Using an ArgTraits you can specify the way that
 * values gets assigned to any particular type during parsing. The two
 * supported types are StringLike and ValueLike. ValueLike is the
 * default and means that operator>> will be used to assign values to
 * the type.
 */
template <typename T>
class ArgTraits {
    // This is a bit silly, but what we want to do is:
    // 1) If there exists a specialization of ArgTraits for type X,
    // use it.
    //
    // 2) If no specialization exists but X has the typename
    // X::ValueCategory, use the specialization for X::ValueCategory.
    //
    // 3) If neither (1) nor (2) defines the trait, use the default
    // which is ValueLike.

    // This is the "how":
    //
    // test<T>(0) (where 0 is the NULL ptr) will match
    // test(typename C::ValueCategory*) iff type T has the
    // corresponding typedef. If it does not test(...) will be
    // matched. This allows us to determine if T::ValueCategory
    // exists by checking the sizeof for the test function (return
    // value must have different sizeof).
    template <typename C>
    static short test(typename C::ValueCategory *);  // NOLINT
    template <typename C>
    static long test(...);                                             // NOLINT
    static const bool hasTrait = sizeof(test<T>(0)) == sizeof(short);  // NOLINT

    template <typename C, bool>
    struct DefaultArgTrait {
        typedef ValueLike ValueCategory;
    };

    template <typename C>
    struct DefaultArgTrait<C, true> {
        typedef typename C::ValueCategory ValueCategory;
    };

public:
    typedef typename DefaultArgTrait<T, hasTrait>::ValueCategory ValueCategory;
};

}  // namespace TCLAP

#endif  // TCLAP_ARG_TRAITS_H


================================================
FILE: lib/tclap/CmdLine.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  CmdLine.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2018, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_CMD_LINE_H
#define TCLAP_CMD_LINE_H

#include <tclap/MultiSwitchArg.h>
#include <tclap/SwitchArg.h>
#include <tclap/UnlabeledMultiArg.h>
#include <tclap/UnlabeledValueArg.h>

#include <tclap/HelpVisitor.h>
#include <tclap/IgnoreRestVisitor.h>
#include <tclap/VersionVisitor.h>

#include <tclap/CmdLineOutput.h>
#include <tclap/StdOutput.h>

#include <tclap/Constraint.h>
#include <tclap/ValuesConstraint.h>

#include <tclap/ArgGroup.h>
#include <tclap/DeferDelete.h>

#include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <string>
#include <vector>

namespace TCLAP {

class StandaloneArgs : public AnyOf {
public:
    StandaloneArgs() {}

    ArgContainer &add(Arg *arg) {
        // std::cerr << "Adding " << arg->getName() << " to StandaloneArgs\n";
        for (iterator it = begin(); it != end(); it++) {
            if (*arg == **it) {
                throw SpecificationException(
                    "Argument with same flag/name already exists!",
                    arg->longID());
            }
        }

        _args.push_back(arg);

        return *this;
    }

    bool showAsGroup() const { return false; }
};

/**
 * The base class that manages the command line definition and passes
 * along the parsing to the appropriate Arg classes.
 */
class CmdLine : public CmdLineInterface {
protected:
    /**
     * The list of arguments that will be tested against the
     * command line.
     */
    std::list<Arg *> _argList;

    StandaloneArgs _standaloneArgs;
    StandaloneArgs _autoArgs;  // --help, --version, etc

    /**
     * Some args have set constraints on them (i.e., exactly or at
     * most one must be specified.
     */
    std::list<ArgGroup *> _argGroups;

    /**
     * The name of the program.  Set to argv[0].
     */
    std::string _progName;

    /**
     * A message used to describe the program.  Used in the usage output.
     */
    std::string _message;

    /**
     * The version to be displayed with the --version switch.
     */
    std::string _version;

    /**
     * The number of arguments that are required to be present on
     * the command line. This is set dynamically, based on the
     * Args added to the CmdLine object.
     */
    int _numRequired;

    /**
     * The character that is used to separate the argument flag/name
     * from the value.  Defaults to ' ' (space).
     */
    char _delimiter;

    /**
     * Add pointers that should be deleted as part of cleanup when
     * this object is destroyed.
     * @internal.
     */
    DeferDelete _deleteOnExit;

    /**
     * Default output handler if nothing is specified.
     */
    StdOutput _defaultOutput;

    /**
     * Object that handles all output for the CmdLine.
     */
    CmdLineOutput *_output;

    /**
     * Should CmdLine handle parsing exceptions internally?
     */
    bool _handleExceptions;

    /**
     * Throws an exception listing the missing args.
     */
    void missingArgsException(const std::list<ArgGroup *> &missing);

    /**
     * Checks whether a name/flag string matches entirely matches
     * the Arg::blankChar.  Used when multiple switches are combined
     * into a single argument.
     * \param s - The message to be used in the usage.
     */
    bool _emptyCombined(const std::string &s);

private:
    /**
     * Prevent accidental copying.
     */
    CmdLine(const CmdLine &rhs);
    CmdLine &operator=(const CmdLine &rhs);

    /**
     * Encapsulates the code common to the constructors
     * (which is all of it).
     */
    void _constructor();

    /**
     * Whether or not to automatically create help and version switches.
     */
    bool _helpAndVersion;

    /**
     * Whether or not to ignore unmatched args.
     */
    bool _ignoreUnmatched;

    /**
     * Ignoring arguments (e.g., after we have seen "--")
     */
    bool _ignoring;

public:
    /**
     * Command line constructor. Defines how the arguments will be
     * parsed.
     * \param message - The message to be used in the usage
     * output.
     * \param delimiter - The character that is used to separate
     * the argument flag/name from the value.  Defaults to ' ' (space).
     * \param version - The version number to be used in the
     * --version switch.
     * \param helpAndVersion - Whether or not to create the Help and
     * Version switches. Defaults to true.
     */
    CmdLine(const std::string &message, const char delimiter = ' ',
            const std::string &version = "none", bool helpAndVersion = true);

    /**
     * Deletes any resources allocated by a CmdLine object.
     */
    virtual ~CmdLine() {}

    /**
     * Adds an argument to the list of arguments to be parsed.
     *
     * @param a - Argument to be added.
     * @retval A reference to this so that add calls can be chained
     */
    ArgContainer &add(Arg &a);

    /**
     * An alternative add.  Functionally identical.
     *
     * @param a - Argument to be added.
     * @retval A reference to this so that add calls can be chained
     */
    ArgContainer &add(Arg *a);

    /**
     * Adds an argument group to the list of arguments to be parsed.
     *
     * All arguments in the group are added and the ArgGroup
     * object will validate that the input matches its
     * constraints.
     *
     * @param args - Argument group to be added.
     * @retval A reference to this so that add calls can be chained
     */
    ArgContainer &add(ArgGroup &args);

    // Internal, do not use
    void addToArgList(Arg *a);

    /**
     * \deprecated Use OneOf instead.
     */
    void xorAdd(Arg &a, Arg &b);

    /**
     * \deprecated Use OneOf instead.
     */
    void xorAdd(const std::vector<Arg *> &xors);

    /**
     * Parses the command line.
     * \param argc - Number of arguments.
     * \param argv - Array of arguments.
     */
    void parse(int argc, const char *const *argv);

    /**
     * Parses the command line.
     * \param args - A vector of strings representing the args.
     * args[0] is still the program name.
     */
    void parse(std::vector<std::string> &args);

    void setOutput(CmdLineOutput *co);

    std::string getVersion() const { return _version; }

    std::string getProgramName() const { return _progName; }

    // TOOD: Get rid of getArgList
    std::list<Arg *> getArgList() const { return _argList; }
    std::list<ArgGroup *> getArgGroups() {
        std::list<ArgGroup *> groups = _argGroups;
        groups.push_back(&_autoArgs);
        return groups;
    }

    char getDelimiter() const { return _delimiter; }
    std::string getMessage() const { return _message; }
    bool hasHelpAndVersion() const { return _helpAndVersion; }

    /**
     * Disables or enables CmdLine's internal parsing exception handling.
     *
     * @param state Should CmdLine handle parsing exceptions internally?
     */
    void setExceptionHandling(const bool state);

    /**
     * Returns the current state of the internal exception handling.
     *
     * @retval true Parsing exceptions are handled internally.
     * @retval false Parsing exceptions are propagated to the caller.
     */
    bool hasExceptionHandling() const { return _handleExceptions; }

    /**
     * Allows the CmdLine object to be reused.
     */
    void reset();

    /**
     * Allows unmatched args to be ignored. By default false.
     *
     * @param ignore If true the cmdline will ignore any unmatched args
     * and if false it will behave as normal.
     */
    void ignoreUnmatched(const bool ignore);

    void beginIgnoring() { _ignoring = true; }
    bool ignoreRest() { return _ignoring; }
};

///////////////////////////////////////////////////////////////////////////////
// Begin CmdLine.cpp
///////////////////////////////////////////////////////////////////////////////

inline CmdLine::CmdLine(const std::string &m, char delim, const std::string &v,
                        bool help)
    : _argList(),
      _standaloneArgs(),
      _autoArgs(),
      _argGroups(),
      _progName("not_set_yet"),
      _message(m),
      _version(v),
      _numRequired(0),
      _delimiter(delim),
      _deleteOnExit(),
      _defaultOutput(),
      _output(&_defaultOutput),
      _handleExceptions(true),
      _helpAndVersion(help),
      _ignoreUnmatched(false),
      _ignoring(false) {
    _constructor();
}

inline void CmdLine::_constructor() {
    Arg::setDelimiter(_delimiter);

    Visitor *v;
    add(_standaloneArgs);
    _autoArgs.setParser(*this);
    // add(_autoArgs);

    v = new IgnoreRestVisitor(*this);
    SwitchArg *ignore = new SwitchArg(
        Arg::flagStartString(), Arg::ignoreNameString(),
        "Ignores the rest of the labeled arguments following this flag.", false,
        v);
    _deleteOnExit(ignore);
    _deleteOnExit(v);
    _autoArgs.add(ignore);
    addToArgList(ignore);

    if (_helpAndVersion) {
        v = new HelpVisitor(this, &_output);
        SwitchArg *help = new SwitchArg(
            "h", "help", "Displays usage information and exits.", false, v);
        _deleteOnExit(help);
        _deleteOnExit(v);

        v = new VersionVisitor(this, &_output);
        SwitchArg *vers = new SwitchArg(
            "", "version", "Displays version information and exits.", false, v);
        _deleteOnExit(vers);
        _deleteOnExit(v);

        // A bit of a hack on the order to make tests easier to fix,
        // to be reverted
        _autoArgs.add(vers);
        addToArgList(vers);
        _autoArgs.add(help);
        addToArgList(help);
    }
}

inline void CmdLine::xorAdd(const std::vector<Arg *> &args) {
    OneOf *group = new OneOf(*this);
    _deleteOnExit(group);

    for (std::vector<Arg *>::const_iterator it = args.begin(); it != args.end();
         ++it) {
        group->add(**it);
    }
}

inline void CmdLine::xorAdd(Arg &a, Arg &b) {
    std::vector<Arg *> ors;
    ors.push_back(&a);
    ors.push_back(&b);
    xorAdd(ors);
}

inline ArgContainer &CmdLine::add(ArgGroup &args) {
    args.setParser(*this);
    _argGroups.push_back(&args);

    return *this;
}

inline ArgContainer &CmdLine::add(Arg &a) { return add(&a); }

// TODO: Rename this to something smarter or refactor this logic so
// it's not needed.
inline void CmdLine::addToArgList(Arg *a) {
    for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
        if (*a == *(*it))
            throw(SpecificationException(
                "Argument with same flag/name already exists!", a->longID()));

    a->addToList(_argList);

    if (a->isRequired()) _numRequired++;
}

inline ArgContainer &CmdLine::add(Arg *a) {
    addToArgList(a);
    _standaloneArgs.add(a);

    return *this;
}

inline void CmdLine::parse(int argc, const char *const *argv) {
    // this step is necessary so that we have easy access to
    // mutable strings.
    std::vector<std::string> args;
    for (int i = 0; i < argc; i++) args.push_back(argv[i]);

    parse(args);
}

inline void CmdLine::parse(std::vector<std::string> &args) {
    bool shouldExit = false;
    int estat = 0;

    try {
        if (args.empty()) {
            // Workaround for some platforms such as consoles
            _progName = "program";
        } else {
            // TODO(macbishop): Maybe store the full name somewhere?
            _progName = basename(args.front());
            args.erase(args.begin());
        }

        int requiredCount = 0;
        std::list<ArgGroup *> missingArgGroups;

        // Check that the right amount of arguments are provided for
        // each ArgGroup, and if there are any required arguments
        // missing, store them for later. Other errors will cause an
        // exception to be thrown and parse will exit early.
        /*
        for (std::list<ArgGroup*>::iterator it = _argGroups.begin();
             it != _argGroups.end(); ++it) {
            bool missingRequired = (*it)->validate(args);
            if (missingRequired) {
                missingArgGroups.push_back(*it);
            }
        }
        */

        for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++) {
            bool matched = false;
            for (ArgListIterator it = _argList.begin(); it != _argList.end();
                 it++) {
                Arg &arg = **it;
                // We check if the argument was already set (e.g., for
                // a Multi-Arg) since then we don't want to count it
                // as required again. This is a hack/workaround to
                // make isRequired() imutable so it can be used to
                // display help correctly (also it's a good idea).
                //
                // TODO: This logic should probably be refactored to
                // remove this logic from here.
                bool alreadySet = arg.isSet();
                bool ignore = arg.isIgnoreable() && ignoreRest();
                if (!ignore && arg.processArg(&i, args)) {
                    requiredCount += (!alreadySet && arg.isRequired()) ? 1 : 0;
                    matched = true;
                    break;
                }
            }

            // checks to see if the argument is an empty combined
            // switch and if so, then we've actually matched it
            if (!matched && _emptyCombined(args[i])) matched = true;

            if (!matched && !ignoreRest() && !_ignoreUnmatched)
                throw(
                    CmdLineParseException("Couldn't find match "
                                          "for argument",
                                          args[i]));
        }

        // Once all arguments have been parsed, check that we don't
        // violate any constraints.
        for (std::list<ArgGroup *>::iterator it = _argGroups.begin();
             it != _argGroups.end(); ++it) {
            bool missingRequired = (*it)->validate();
            if (missingRequired) {
                missingArgGroups.push_back(*it);
            }
        }

        if (requiredCount < _numRequired || !missingArgGroups.empty()) {
            missingArgsException(missingArgGroups);
        }

        if (requiredCount > _numRequired) {
            throw(CmdLineParseException("Too many arguments!"));
        }
    } catch (ArgException &e) {
        // If we're not handling the exceptions, rethrow.
        if (!_handleExceptions) {
            throw;
        }

        try {
            _output->failure(*this, e);
        } catch (ExitException &ee) {
            estat = ee.getExitStatus();
            shouldExit = true;
        }
    } catch (ExitException &ee) {
        // If we're not handling the exceptions, rethrow.
        if (!_handleExceptions) {
            throw;
        }

        estat = ee.getExitStatus();
        shouldExit = true;
    }

    if (shouldExit) exit(estat);
}

inline bool CmdLine::_emptyCombined(const std::string &s) {
    if (s.length() > 0 && s[0] != Arg::flagStartChar()) return false;

    for (int i = 1; static_cast<unsigned int>(i) < s.length(); i++)
        if (s[i] != Arg::blankChar()) return false;

    return true;
}

inline void CmdLine::missingArgsException(
    const std::list<ArgGroup *> &missing) {
    int count = 0;

    std::string missingArgList;
    for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++) {
        if ((*it)->isRequired() && !(*it)->isSet()) {
            missingArgList += (*it)->getName();
            missingArgList += ", ";
            count++;
        }
    }

    for (std::list<ArgGroup *>::const_iterator it = missing.begin();
         it != missing.end(); it++) {
        missingArgList += (*it)->getName();
        missingArgList += ", ";
        count++;
    }

    missingArgList = missingArgList.substr(0, missingArgList.length() - 2);

    std::string msg;
    if (count > 1)
        msg = "Required arguments missing: ";
    else
        msg = "Required argument missing: ";

    msg += missingArgList;

    throw(CmdLineParseException(msg));
}

inline void CmdLine::setOutput(CmdLineOutput *co) { _output = co; }

inline void CmdLine::setExceptionHandling(const bool state) {
    _handleExceptions = state;
}

inline void CmdLine::reset() {
    // TODO: This is no longer correct (or perhaps we don't need "reset")
    for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
        (*it)->reset();

    _progName.clear();
}

inline void CmdLine::ignoreUnmatched(const bool ignore) {
    _ignoreUnmatched = ignore;
}

///////////////////////////////////////////////////////////////////////////////
// End CmdLine.cpp
///////////////////////////////////////////////////////////////////////////////

}  // namespace TCLAP

#endif  // TCLAP_CMD_LINE_H


================================================
FILE: lib/tclap/CmdLineInterface.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  CmdLineInterface.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_CMD_LINE_INTERFACE_H
#define TCLAP_CMD_LINE_INTERFACE_H

#include <tclap/ArgContainer.h>

#include <algorithm>
#include <iostream>
#include <list>
#include <string>
#include <vector>

namespace TCLAP {

class Arg;
class ArgGroup;
class CmdLineOutput;

/**
 * The base class that manages the command line definition and passes
 * along the parsing to the appropriate Arg classes.
 */
class CmdLineInterface : public ArgContainer {
public:
    /**
     * Destructor
     */
    virtual ~CmdLineInterface() {}

    /**
     * Adds an argument. Ownership is not transfered.
     * @param a - Argument to be added.
     * @retval A reference to this so that add calls can be chained
     */
    virtual ArgContainer &add(Arg &a) = 0;

    /**
     * Adds an argument. Ownership is not transfered.
     * @param a - Argument to be added.
     * @retval A reference to this so that add calls can be chained
     */
    virtual ArgContainer &add(Arg *a) = 0;

    // TODO: Rename this to something smarter or refactor this logic so
    // it's not needed.
    // Internal - do not use
    virtual void addToArgList(Arg *a) = 0;

    /**
     * Adds an argument group to the list of arguments to be parsed.
     *
     * All arguments in the group are added and the ArgGroup
     * object will validate that the input matches its
     * constraints.
     *
     * @param args - Argument group to be added.
     * @retval A reference to this so that add calls can be chained
     */
    virtual ArgContainer &add(ArgGroup &args) = 0;

    /**
     * \deprecated Use OneOf instead.
     */
    virtual void xorAdd(Arg &a, Arg &b) = 0;

    /**
     * \deprecated Use OneOf instead.
     */
    virtual void xorAdd(const std::vector<Arg *> &xors) = 0;

    /**
     * Parses the command line.
     * \param argc - Number of arguments.
     * \param argv - Array of arguments.
     */
    virtual void parse(int argc, const char *const *argv) = 0;

    /**
     * Parses the command line.
     * \param args - A vector of strings representing the args.
     * args[0] is still the program name.
     */
    void parse(std::vector<std::string> &args);

    /**
     * \param co - CmdLineOutput object that we want to use instead.
     */
    virtual void setOutput(CmdLineOutput *co) = 0;

    /**
     * Returns the version string.
     */
    virtual std::string getVersion() const = 0;

    /**
     * Returns the program name string.
     */
    virtual std::string getProgramName() const = 0;

    /**
     * Returns the list of ArgGroups.
     */
    virtual std::list<ArgGroup *> getArgGroups() = 0;
    virtual std::list<Arg *> getArgList() const = 0;  // TODO: get rid of this

    /**
     * Returns the delimiter string.
     */
    virtual char getDelimiter() const = 0;

    /**
     * Returns the message string.
     */
    virtual std::string getMessage() const = 0;

    /**
     * Indicates whether or not the help and version switches were created
     * automatically.
     */
    virtual bool hasHelpAndVersion() const = 0;

    /**
     * Resets the instance as if it had just been constructed so that the
     * instance can be reused.
     */
    virtual void reset() = 0;

    /**
     * Begin ignoring arguments since the "--" argument was specified.
     * \internal
     */
    virtual void beginIgnoring() = 0;

    /**
     * Whether to ignore the rest.
     * \internal
     */
    virtual bool ignoreRest() = 0;
};

}  // namespace TCLAP

#endif  // TCLAP_CMD_LINE_INTERFACE_H


================================================
FILE: lib/tclap/CmdLineOutput.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  CmdLineOutput.h
 *
 *  Copyright (c) 2004, Michael E. Smoot
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_CMD_LINE_OUTPUT_H
#define TCLAP_CMD_LINE_OUTPUT_H

#include <tclap/Arg.h>
#include <tclap/ArgGroup.h>

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <list>
#include <string>
#include <vector>

namespace TCLAP {

class CmdLineInterface;
class ArgException;

/**
 * The interface that any output object must implement.
 */
class CmdLineOutput {
public:
    /**
     * Virtual destructor.
     */
    virtual ~CmdLineOutput() {}

    /**
     * Generates some sort of output for the USAGE.
     * \param c - The CmdLine object the output is generated for.
     */
    virtual void usage(CmdLineInterface &c) = 0;

    /**
     * Generates some sort of output for the version.
     * \param c - The CmdLine object the output is generated for.
     */
    virtual void version(CmdLineInterface &c) = 0;

    /**
     * Generates some sort of output for a failure.
     * \param c - The CmdLine object the output is generated for.
     * \param e - The ArgException that caused the failure.
     */
    virtual void failure(CmdLineInterface &c, ArgException &e) = 0;
};

inline bool isInArgGroup(const Arg *arg, const std::list<ArgGroup *> &argSets) {
    for (std::list<ArgGroup *>::const_iterator it = argSets.begin();
         it != argSets.end(); ++it) {
        if (std::find((*it)->begin(), (*it)->end(), arg) != (*it)->end()) {
            return true;
        }
    }
    return false;
}

inline void removeArgsInArgGroups(std::list<Arg *> &argList,
                                  const std::list<ArgGroup *> &argSets) {
    for (std::list<Arg *>::iterator it = argList.begin();
         it != argList.end();) {
        if (isInArgGroup(*it, argSets)) {
            it = argList.erase(it);
        } else {
            ++it;
        }
    }
}

inline std::string basename(std::string s) {
    // TODO(macbishop): See if we can make this more robust
    size_t p = s.find_last_of("/\\");
    if (p != std::string::npos) {
        s.erase(0, p + 1);
    }

    p = s.rfind(".exe");
    if (p == s.length() - 4) {
        s.erase(s.length() - 4);
    }

    return s;
}

}  // namespace TCLAP

#endif  // TCLAP_CMD_LINE_OUTPUT_H


================================================
FILE: lib/tclap/Constraint.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  Constraint.h
 *
 *  Copyright (c) 2005, Michael E. Smoot
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_CONSTRAINT_H
#define TCLAP_CONSTRAINT_H

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <list>
#include <stdexcept>
#include <string>
#include <vector>

namespace TCLAP {

/**
 * The interface that defines the interaction between the Arg and Constraint.
 */
template <class T>
class Constraint {
public:
    /**
     * Returns a description of the Constraint.
     */
    virtual std::string description() const = 0;

    /**
     * Returns the short ID for the Constraint.
     */
    virtual std::string shortID() const = 0;

    /**
     * The method used to verify that the value parsed from the command
     * line meets the constraint.
     * \param value - The value that will be checked.
     */
    virtual bool check(const T &value) const = 0;

    /**
     * Destructor.
     * Silences warnings about Constraint being a base class with virtual
     * functions but without a virtual destructor.
     */
    virtual ~Constraint() { ; }

    static std::string shortID(Constraint<T> *constraint) {
        if (!constraint)
            throw std::logic_error(
                "Cannot create a ValueArg with a NULL constraint");
        return constraint->shortID();
    }
};

}  // namespace TCLAP

#endif  // TCLAP_CONSTRAINT_H


================================================
FILE: lib/tclap/DeferDelete.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  DeferDelete.h
 *
 *  Copyright (c) 2020, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_DEFER_DELETE_H
#define TCLAP_DEFER_DELETE_H

namespace TCLAP {

/**
 * DeferDelete can be used by objects that need to allocate arbitrary other
 * objects to live for the duration of the first object. Any object
 * added to DeferDelete (by calling operator()) will be deleted when
 * the DeferDelete object is destroyed.
 */
class DeferDelete {
    class DeletableBase {
    public:
        virtual ~DeletableBase() {}
    };

    template <typename T>
    class Deletable : public DeletableBase {
    public:
        Deletable(T *o) : _o(o) {}
        virtual ~Deletable() { delete _o; }

    private:
        Deletable(const Deletable<T> &) {}
        Deletable<T> operator=(const Deletable<T> &) {}

        T *_o;
    };

    std::list<DeletableBase *> _toBeDeleted;

public:
    DeferDelete() : _toBeDeleted() {}
    ~DeferDelete() {
        for (std::list<DeletableBase *>::iterator it = _toBeDeleted.begin();
             it != _toBeDeleted.end(); ++it) {
            delete *it;
        }
    }

    template <typename T>
    void operator()(T *toDelete) {
        _toBeDeleted.push_back(new Deletable<T>(toDelete));
    }
};

}  // namespace TCLAP

#endif  // TCLAP_DEFER_DELETE_H


================================================
FILE: lib/tclap/DocBookOutput.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  DocBookOutput.h
 *
 *  Copyright (c) 2004, Michael E. Smoot
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_DOC_BOOK_OUTPUT_H
#define TCLAP_DOC_BOOK_OUTPUT_H

#include <tclap/Arg.h>
#include <tclap/CmdLineInterface.h>
#include <tclap/CmdLineOutput.h>

#include <algorithm>
#include <iostream>
#include <list>
#include <string>
#include <vector>

namespace TCLAP {

/**
 * A class that generates DocBook output for usage() method for the
 * given CmdLine and its Args.
 */
class DocBookOutput : public CmdLineOutput {
public:
    /**
     * Prints the usage to stdout.  Can be overridden to
     * produce alternative behavior.
     * \param c - The CmdLine object the output is generated for.
     */
    virtual void usage(CmdLineInterface &c);

    /**
     * Prints the version to stdout. Can be overridden
     * to produce alternative behavior.
     * \param c - The CmdLine object the output is generated for.
     */
    virtual void version(CmdLineInterface &c);

    /**
     * Prints (to stderr) an error message, short usage
     * Can be overridden to produce alternative behavior.
     * \param c - The CmdLine object the output is generated for.
     * \param e - The ArgException that caused the failure.
     */
    virtual void failure(CmdLineInterface &c, ArgException &e);

    DocBookOutput() : theDelimiter('=') {}

protected:
    /**
     * Substitutes the char r for string x in string s.
     * \param s - The string to operate on.
     * \param r - The char to replace.
     * \param x - What to replace r with.
     */
    void substituteSpecialChars(std::string &s, char r,
                                const std::string &x) const;
    void removeChar(std::string &s, char r) const;

    void printShortArg(Arg *it, bool required);
    void printLongArg(const ArgGroup &it) const;

    char theDelimiter;
};

inline void DocBookOutput::version(CmdLineInterface &_cmd) {
    std::cout << _cmd.getVersion() << std::endl;
}

namespace internal {
const char *GroupChoice(const ArgGroup &group) {
    if (!group.showAsGroup()) {
        return "plain";
    }

    if (group.isRequired()) {
        return "req";
    }

    return "opt";
}
}  // namespace internal

inline void DocBookOutput::usage(CmdLineInterface &_cmd) {
    std::list<ArgGroup *> argSets = _cmd.getArgGroups();
    std::string progName = _cmd.getProgramName();
    std::string xversion = _cmd.getVersion();
    theDelimiter = _cmd.getDelimiter();

    std::cout << "<?xml version='1.0'?>\n";
    std::cout
        << "<!DOCTYPE refentry PUBLIC \"-//OASIS//DTD DocBook XML V4.2//EN\"\n";
    std::cout
        << "\t\"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd\">\n\n";

    std::cout << "<refentry>\n";

    std::cout << "<refmeta>\n";
    std::cout << "<refentrytitle>" << progName << "</refentrytitle>\n";
    std::cout << "<manvolnum>1</manvolnum>\n";
    std::cout << "</refmeta>\n";

    std::cout << "<refnamediv>\n";
    std::cout << "<refname>" << progName << "</refname>\n";
    std::cout << "<refpurpose>" << _cmd.getMessage() << "</refpurpose>\n";
    std::cout << "</refnamediv>\n";

    std::cout << "<refsynopsisdiv>\n";
    std::cout << "<cmdsynopsis>\n";

    std::cout << "<command>" << progName << "</command>\n";

    for (std::list<ArgGroup *>::iterator sit = argSets.begin();
         sit != argSets.end(); ++sit) {
        int visible = CountVisibleArgs(**sit);
        if (visible > 1) {
            std::cout << "<group choice='" << internal::GroupChoice(**sit)
                      << "'>\n";
        }
        for (ArgGroup::iterator it = (*sit)->begin(); it != (*sit)->end();
             ++it) {
            if (!(*it)->visibleInHelp()) {
                continue;
            }

            printShortArg(*it, (*it)->isRequired() ||
                                   (visible == 1 && (**sit).isRequired()));
        }
        if (visible > 1) {
            std::cout << "</group>\n";
        }
    }

    std::cout << "</cmdsynopsis>\n";
    std::cout << "</refsynopsisdiv>\n";

    std::cout << "<refsect1>\n";
    std::cout << "<title>Description</title>\n";
    std::cout << "<para>\n";
    std::cout << _cmd.getMessage() << '\n';
    std::cout << "</para>\n";
    std::cout << "</refsect1>\n";

    std::cout << "<refsect1>\n";
    std::cout << "<title>Options</title>\n";

    std::cout << "<variablelist>\n";

    for (std::list<ArgGroup *>::iterator sit = argSets.begin();
         sit != argSets.end(); ++sit) {
        printLongArg(**sit);
    }

    std::cout << "</variablelist>\n";
    std::cout << "</refsect1>\n";

    std::cout << "<refsect1>\n";
    std::cout << "<title>Version</title>\n";
    std::cout << "<para>\n";
    std::cout << xversion << '\n';
    std::cout << "</para>\n";
    std::cout << "</refsect1>\n";

    std::cout << "</refentry>" << std::endl;
}

inline void DocBookOutput::failure(CmdLineInterface &_cmd, ArgException &e) {
    static_cast<void>(_cmd);  // unused
    std::cout << e.what() << std::endl;
    throw ExitException(1);
}

inline void DocBookOutput::substituteSpecialChars(std::string &s, char r,
                                                  const std::string &x) const {
    size_t p;
    while ((p = s.find_first_of(r)) != std::string::npos) {
        s.erase(p, 1);
        s.insert(p, x);
    }
}

inline void DocBookOutput::removeChar(std::string &s, char r) const {
    size_t p;
    while ((p = s.find_first_of(r)) != std::string::npos) {
        s.erase(p, 1);
    }
}

inline void DocBookOutput::printShortArg(Arg *a, bool required) {
    std::string lt = "&lt;";
    std::string gt = "&gt;";

    std::string id = a->shortID();
    substituteSpecialChars(id, '<', lt);
    substituteSpecialChars(id, '>', gt);
    removeChar(id, '[');
    removeChar(id, ']');

    std::string choice = "opt";
    if (required) {
        choice = "plain";
    }

    std::cout << "<arg choice='" << choice << '\'';
    if (a->acceptsMultipleValues()) std::cout << " rep='repeat'";

    std::cout << '>';
    if (!a->getFlag().empty())
        std::cout << a->flagStartChar() << a->getFlag();
    else
        std::cout << a->nameStartString() << a->getName();
    if (a->isValueRequired()) {
        std::string arg = a->shortID();
        removeChar(arg, '[');
        removeChar(arg, ']');
        removeChar(arg, '<');
        removeChar(arg, '>');
        removeChar(arg, '.');
        arg.erase(0, arg.find_last_of(theDelimiter) + 1);
        std::cout << theDelimiter;
        std::cout << "<replaceable>" << arg << "</replaceable>";
    }
    std::cout << "</arg>" << std::endl;
}

inline void DocBookOutput::printLongArg(const ArgGroup &group) const {
    const std::string lt = "&lt;";
    const std::string gt = "&gt;";

    bool forceRequired = group.isRequired() && CountVisibleArgs(group) == 1;
    for (ArgGroup::const_iterator it = group.begin(); it != group.end(); ++it) {
        Arg &a = **it;
        if (!a.visibleInHelp()) {
            continue;
        }

        std::string desc = a.getDescription(forceRequired || a.isRequired());
        substituteSpecialChars(desc, '<', lt);
        substituteSpecialChars(desc, '>', gt);

        std::cout << "<varlistentry>\n";

        if (!a.getFlag().empty()) {
            std::cout << "<term>\n";
            std::cout << "<option>";
            std::cout << a.flagStartChar() << a.getFlag();
            std::cout << "</option>\n";
            std::cout << "</term>\n";
        }

        std::cout << "<term>\n";
        std::cout << "<option>";
        std::cout << a.nameStartString() << a.getName();
        if (a.isValueRequired()) {
            std::string arg = a.shortID();
            removeChar(arg, '[');
            removeChar(arg, ']');
            removeChar(arg, '<');
            removeChar(arg, '>');
            removeChar(arg, '.');
            arg.erase(0, arg.find_last_of(theDelimiter) + 1);
            std::cout << theDelimiter;
            std::cout << "<replaceable>" << arg << "</replaceable>";
        }

        std::cout << "</option>\n";
        std::cout << "</term>\n";

        std::cout << "<listitem>\n";
        std::cout << "<para>\n";
        std::cout << desc << '\n';
        std::cout << "</para>\n";
        std::cout << "</listitem>\n";

        std::cout << "</varlistentry>" << std::endl;
    }
}

}  // namespace TCLAP
#endif  // TCLAP_DOC_BOOK_OUTPUT_H


================================================
FILE: lib/tclap/HelpVisitor.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  HelpVisitor.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_HELP_VISITOR_H
#define TCLAP_HELP_VISITOR_H

#include <tclap/CmdLineInterface.h>
#include <tclap/CmdLineOutput.h>
#include <tclap/Visitor.h>

namespace TCLAP {

/**
 * A Visitor object that calls the usage method of the given CmdLineOutput
 * object for the specified CmdLine object.
 */
class HelpVisitor : public Visitor {
private:
    /**
     * Prevent accidental copying.
     */
    HelpVisitor(const HelpVisitor &rhs);
    HelpVisitor &operator=(const HelpVisitor &rhs);

protected:
    /**
     * The CmdLine the output will be generated for.
     */
    CmdLineInterface *_cmd;

    /**
     * The output object.
     */
    CmdLineOutput **_out;

public:
    /**
     * Constructor.
     * \param cmd - The CmdLine the output will be generated for.
     * \param out - The type of output.
     */
    HelpVisitor(CmdLineInterface *cmd, CmdLineOutput **out)
        : Visitor(), _cmd(cmd), _out(out) {}

    /**
     * Calls the usage method of the CmdLineOutput for the
     * specified CmdLine.
     */
    void visit() {
        (*_out)->usage(*_cmd);
        throw ExitException(0);
    }
};
}  // namespace TCLAP

#endif  // TCLAP_HELP_VISITOR_H


================================================
FILE: lib/tclap/IgnoreRestVisitor.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  IgnoreRestVisitor.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2020, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_IGNORE_REST_VISITOR_H
#define TCLAP_IGNORE_REST_VISITOR_H

#include <tclap/CmdLineInterface.h>
#include <tclap/Visitor.h>

namespace TCLAP {

/**
 * A Visitor that tells the CmdLine to begin ignoring arguments after
 * this one is parsed.
 */
class IgnoreRestVisitor : public Visitor {
public:
    IgnoreRestVisitor(CmdLineInterface &cmdLine)
        : Visitor(), cmdLine_(cmdLine) {}
    void visit() { cmdLine_.beginIgnoring(); }

private:
    CmdLineInterface &cmdLine_;
};
}  // namespace TCLAP

#endif  // TCLAP_IGNORE_REST_VISITOR_H


================================================
FILE: lib/tclap/MultiArg.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  MultiArg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_MULTI_ARG_H
#define TCLAP_MULTI_ARG_H

#include <tclap/Arg.h>
#include <tclap/Constraint.h>

#include <string>
#include <vector>

namespace TCLAP {
/**
 * An argument that allows multiple values of type T to be specified.  Very
 * similar to a ValueArg, except a vector of values will be returned
 * instead of just one.
 */
template <class T>
class MultiArg : public Arg {
public:
    typedef std::vector<T> container_type;
    typedef typename container_type::iterator iterator;
    typedef typename container_type::const_iterator const_iterator;

protected:
    /**
     * The list of values parsed from the CmdLine.
     */
    std::vector<T> _values;

    /**
     * The description of type T to be used in the usage.
     */
    std::string _typeDesc;

    /**
     * A list of constraint on this Arg.
     */
    Constraint<T> *_constraint;

    /**
     * Extracts the value from the string.
     * Attempts to parse string as type T, if this fails an exception
     * is thrown.
     * \param val - The string to be read.
     */
    void _extractValue(const std::string &val);

    /**
     * Used by MultiArg to decide whether to keep parsing for this
     * arg.
     */
    bool _allowMore;

public:
    /**
     * Constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    MultiArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, const std::string &typeDesc,
             Visitor *v = NULL);

    /**
     * Constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    MultiArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, const std::string &typeDesc,
             ArgContainer &parser, Visitor *v = NULL);

    /**
     * Constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    MultiArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, Constraint<T> *constraint,
             Visitor *v = NULL);

    /**
     * Constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    MultiArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, Constraint<T> *constraint,
             ArgContainer &parser, Visitor *v = NULL);

    /**
     * Handles the processing of the argument.
     * This re-implements the Arg version of this method to set the
     * _value of the argument appropriately.  It knows the difference
     * between labeled and unlabeled.
     * \param i - Pointer the the current argument in the list.
     * \param args - Mutable list of strings. Passed from main().
     */
    virtual bool processArg(int *i, std::vector<std::string> &args);

    /**
     * Returns a vector of type T containing the values parsed from
     * the command line.
     */
    const std::vector<T> &getValue() const { return _values; }

    /**
     * Returns an iterator over the values parsed from the command
     * line.
     */
    const_iterator begin() const { return _values.begin(); }

    /**
     * Returns the end of the values parsed from the command
     * line.
     */
    const_iterator end() const { return _values.end(); }

    /**
     * Returns the a short id string.  Used in the usage.
     * \param val - value to be used.
     */
    virtual std::string shortID(const std::string &val = "val") const;

    /**
     * Returns the a long id string.  Used in the usage.
     * \param val - value to be used.
     */
    virtual std::string longID(const std::string &val = "val") const;

    virtual bool allowMore();

    virtual void reset();

private:
    /**
     * Prevent accidental copying
     */
    MultiArg<T>(const MultiArg<T> &rhs);
    MultiArg<T> &operator=(const MultiArg<T> &rhs);
};

template <class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req,
                      const std::string &typeDesc, Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _values(std::vector<T>()),
      _typeDesc(typeDesc),
      _constraint(NULL),
      _allowMore(false) {
    _acceptsMultipleValues = true;
}

template <class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req,
                      const std::string &typeDesc, ArgContainer &parser,
                      Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _values(std::vector<T>()),
      _typeDesc(typeDesc),
      _constraint(NULL),
      _allowMore(false) {
    parser.add(this);
    _acceptsMultipleValues = true;
}

/**
 *
 */
template <class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req,
                      Constraint<T> *constraint, Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _values(std::vector<T>()),
      _typeDesc(Constraint<T>::shortID(constraint)),
      _constraint(constraint),
      _allowMore(false) {
    _acceptsMultipleValues = true;
}

template <class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req,
                      Constraint<T> *constraint, ArgContainer &parser,
                      Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _values(std::vector<T>()),
      _typeDesc(Constraint<T>::shortID(constraint)),
      _constraint(constraint),
      _allowMore(false) {
    parser.add(this);
    _acceptsMultipleValues = true;
}

template <class T>
bool MultiArg<T>::processArg(int *i, std::vector<std::string> &args) {
    if (_hasBlanks(args[*i])) return false;

    std::string flag = args[*i];
    std::string value = "";

    trimFlag(flag, value);

    if (argMatches(flag)) {
        if (Arg::delimiter() != ' ' && value == "")
            throw(ArgParseException(
                "Couldn't find delimiter for this argument!", toString()));

        // always take the first one, regardless of start string
        if (value == "") {
            (*i)++;
            if (static_cast<unsigned int>(*i) < args.size())
                _extractValue(args[*i]);
            else
                throw(ArgParseException("Missing a value for this argument!",
                                        toString()));
        } else {
            _extractValue(value);
        }

        _alreadySet = true;
        _setBy = flag;
        _checkWithVisitor();

        return true;
    } else {
        return false;
    }
}

/**
 *
 */
template <class T>
std::string MultiArg<T>::shortID(const std::string &val) const {
    static_cast<void>(val);  // Ignore input, don't warn
    return Arg::shortID("<" + _typeDesc + ">") + " ...";
}

/**
 *
 */
template <class T>
std::string MultiArg<T>::longID(const std::string &val) const {
    static_cast<void>(val);  // Ignore input, don't warn
    return Arg::longID("<" + _typeDesc + ">") + "  (accepted multiple times)";
}

template <class T>
void MultiArg<T>::_extractValue(const std::string &val) {
    try {
        T tmp;
        ExtractValue(tmp, val, typename ArgTraits<T>::ValueCategory());
        _values.push_back(tmp);
    } catch (ArgParseException &e) {
        throw ArgParseException(e.error(), toString());
    }

    if (_constraint != NULL)
        if (!_constraint->check(_values.back()))
            throw(CmdLineParseException(
                "Value '" + val +
                    "' does not meet constraint: " + _constraint->description(),
                toString()));
}

template <class T>
bool MultiArg<T>::allowMore() {
    bool am = _allowMore;
    _allowMore = true;
    return am;
}

template <class T>
void MultiArg<T>::reset() {
    Arg::reset();
    _values.clear();
}

}  // namespace TCLAP

#endif  // TCLAP_MULTI_ARG_H


================================================
FILE: lib/tclap/MultiSwitchArg.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  MultiSwitchArg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2005, Michael E. Smoot, Daniel Aarno, Erik Zeek.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_MULTI_SWITCH_ARG_H
#define TCLAP_MULTI_SWITCH_ARG_H

#include <tclap/SwitchArg.h>

#include <string>
#include <vector>

namespace TCLAP {

/**
 * A multiple switch argument.  If the switch is set on the command line, then
 * the getValue method will return the number of times the switch appears.
 */
class MultiSwitchArg : public SwitchArg {
protected:
    /**
     * The value of the switch.
     */
    int _value;

    /**
     * Used to support the reset() method so that ValueArg can be
     * reset to their constructed value.
     */
    int _default;

public:
    /**
     * MultiSwitchArg constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param init - Optional. The initial/default value of this Arg.
     * Defaults to 0.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    MultiSwitchArg(const std::string &flag, const std::string &name,
                   const std::string &desc, int init = 0, Visitor *v = NULL);

    /**
     * MultiSwitchArg constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param init - Optional. The initial/default value of this Arg.
     * Defaults to 0.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    MultiSwitchArg(const std::string &flag, const std::string &name,
                   const std::string &desc, ArgContainer &parser, int init = 0,
                   Visitor *v = NULL);

    /**
     * Handles the processing of the argument.
     * This re-implements the SwitchArg version of this method to set the
     * _value of the argument appropriately.
     * \param i - Pointer the the current argument in the list.
     * \param args - Mutable list of strings. Passed
     * in from main().
     */
    virtual bool processArg(int *i, std::vector<std::string> &args);

    /**
     * Returns int, the number of times the switch has been set.
     */
    int getValue() const { return _value; }

    /**
     * Returns the shortID for this Arg.
     */
    std::string shortID(const std::string &val) const;

    /**
     * Returns the longID for this Arg.
     */
    std::string longID(const std::string &val) const;

    void reset();
};

inline MultiSwitchArg::MultiSwitchArg(const std::string &flag,
                                      const std::string &name,
                                      const std::string &desc, int init,
                                      Visitor *v)
    : SwitchArg(flag, name, desc, false, v), _value(init), _default(init) {}

inline MultiSwitchArg::MultiSwitchArg(const std::string &flag,
                                      const std::string &name,
                                      const std::string &desc,
                                      ArgContainer &parser, int init,
                                      Visitor *v)
    : SwitchArg(flag, name, desc, false, v), _value(init), _default(init) {
    parser.add(this);
}

inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string> &args) {
    if (argMatches(args[*i])) {
        // so the isSet() method will work
        _alreadySet = true;
        _setBy = args[*i];

        // Matched argument: increment value.
        ++_value;

        _checkWithVisitor();

        return true;
    } else if (combinedSwitchesMatch(args[*i])) {
        // so the isSet() method will work
        _alreadySet = true;

        // Matched argument: increment value.
        ++_value;

        // Check for more in argument and increment value.
        while (combinedSwitchesMatch(args[*i])) ++_value;

        _checkWithVisitor();

        return false;
    } else {
        return false;
    }
}

inline std::string MultiSwitchArg::shortID(const std::string &val) const {
    return Arg::shortID(val) + " ...";
}

inline std::string MultiSwitchArg::longID(const std::string &val) const {
    return Arg::longID(val) + "  (accepted multiple times)";
}

inline void MultiSwitchArg::reset() {
    MultiSwitchArg::_value = MultiSwitchArg::_default;
}

}  // namespace TCLAP

#endif  // TCLAP_MULTI_SWITCH_ARG_H


================================================
FILE: lib/tclap/OptionalUnlabeledTracker.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  OptionalUnlabeledTracker.h
 *
 *  Copyright (c) 2005, Michael E. Smoot .
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_OPTIONAL_UNLABELED_TRACKER_H
#define TCLAP_OPTIONAL_UNLABELED_TRACKER_H

#include <string>

namespace TCLAP {

class OptionalUnlabeledTracker {
public:
    static void check(bool req, const std::string &argName);

    static void gotOptional() { alreadyOptionalRef() = true; }

    static bool &alreadyOptional() { return alreadyOptionalRef(); }

private:
    static bool &alreadyOptionalRef() {
        static bool ct = false;
        return ct;
    }
};

inline void OptionalUnlabeledTracker::check(bool req,
                                            const std::string &argName) {
    if (OptionalUnlabeledTracker::alreadyOptional())
        throw(SpecificationException(
            "You can't specify ANY Unlabeled Arg following an optional "
            "Unlabeled Arg",
            argName));

    if (!req) OptionalUnlabeledTracker::gotOptional();
}

}  // namespace TCLAP

#endif  // TCLAP_OPTIONAL_UNLABELED_TRACKER_H


================================================
FILE: lib/tclap/README
================================================
TCLAP - Templatized Command Line Argument Parser

This is a simple C++ library that facilitates parsing command line
arguments in a type independent manner. It doesn't conform exactly
to either the GNU or POSIX standards, although it is close. See
docs/manual.html for descriptions of how things work or look at the
simple examples in the examples dir.

Any and all feedback is welcome at https://sf.net/p/tclap/discussion/


================================================
FILE: lib/tclap/StandardTraits.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  StandardTraits.h
 *
 *  Copyright (c) 2007, Daniel Aarno, Michael E. Smoot .
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

// This is an internal tclap file, you should probably not have to
// include this directly

#ifndef TCLAP_STANDARD_TRAITS_H
#define TCLAP_STANDARD_TRAITS_H

#include <string>

// If Microsoft has already typedef'd wchar_t as an unsigned
// short, then compiles will break because it's as if we're
// creating ArgTraits twice for unsigned short. Thus...
#ifdef _MSC_VER
#ifndef _NATIVE_WCHAR_T_DEFINED
#define TCLAP_DONT_DECLARE_WCHAR_T_ARGTRAITS
#endif
#endif

namespace TCLAP {

// Integer types (signed, unsigned and bool) and floating point types all
// have value-like semantics.

// Strings have string like argument traits.
template <>
struct ArgTraits<std::string> {
    typedef StringLike ValueCategory;
};

template <typename T>
void SetString(T &dst, const std::string &src) {
    dst = src;
}

}  // namespace TCLAP

#endif  // TCLAP_STANDARD_TRAITS_H


================================================
FILE: lib/tclap/StdOutput.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  StdOutput.h
 *
 *  Copyright (c) 2004, Michael E. Smoot
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_STD_OUTPUT_H
#define TCLAP_STD_OUTPUT_H

#include <tclap/Arg.h>
#include <tclap/ArgGroup.h>
#include <tclap/CmdLineInterface.h>
#include <tclap/CmdLineOutput.h>

#include <algorithm>
#include <cctype>
#include <iostream>
#include <list>
#include <string>
#include <utility>
#include <vector>

namespace TCLAP {

/**
 * A class that isolates any output from the CmdLine object so that it
 * may be easily modified.
 */
class StdOutput : public CmdLineOutput {
public:
    /**
     * Prints the usage to stdout.  Can be overridden to
     * produce alternative behavior.
     * \param c - The CmdLine object the output is generated for.
     */
    virtual void usage(CmdLineInterface &c);

    /**
     * Prints the version to stdout. Can be overridden
     * to produce alternative behavior.
     * \param c - The CmdLine object the output is generated for.
     */
    virtual void version(CmdLineInterface &c);

    /**
     * Prints (to stderr) an error message, short usage
     * Can be overridden to produce alternative behavior.
     * \param c - The CmdLine object the output is generated for.
     * \param e - The ArgException that caused the failure.
     */
    virtual void failure(CmdLineInterface &c, ArgException &e);

protected:
    /**
     * Writes a brief usage message with short args.
     * \param c - The CmdLine object the output is generated for.
     * \param os - The stream to write the message to.
     */
    void _shortUsage(CmdLineInterface &c, std::ostream &os) const;

    /**
     * Writes a longer usage message with long and short args,
     * provides descriptions and prints message.
     * \param c - The CmdLine object the output is generated for.
     * \param os - The stream to write the message to.
     */
    void _longUsage(CmdLineInterface &c, std::ostream &os) const;

    /**
     * This function inserts line breaks and indents long strings
     * according the  params input. It will only break lines at spaces,
     * commas and pipes.
     * \param os - The stream to be printed to.
     * \param s - The string to be printed.
     * \param maxWidth - The maxWidth allowed for the output line.
     * \param indentSpaces - The number of spaces to indent the first line.
     * \param secondLineOffset - The number of spaces to indent the second
     * and all subsequent lines in addition to indentSpaces.
     */
    void spacePrint(std::ostream &os, const std::string &s, int maxWidth,
                    int indentSpaces, int secondLineOffset) const;
};

inline void StdOutput::version(CmdLineInterface &_cmd) {
    std::string progName = _cmd.getProgramName();
    std::string xversion = _cmd.getVersion();

    std::cout << std::endl
              << progName << "  version: " << xversion << std::endl
              << std::endl;
}

inline void StdOutput::usage(CmdLineInterface &_cmd) {
    std::cout << std::endl << "USAGE: " << std::endl << std::endl;

    _shortUsage(_cmd, std::cout);

    std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;

    _longUsage(_cmd, std::cout);

    std::cout << std::endl;
}

inline void StdOutput::failure(CmdLineInterface &_cmd, ArgException &e) {
    std::string progName = _cmd.getProgramName();

    std::cerr << "PARSE ERROR: " << e.argId() << std::endl
              << "             " << e.error() << std::endl
              << std::endl;

    if (_cmd.hasHelpAndVersion()) {
        std::cerr << "Brief USAGE: " << std::endl;

        _shortUsage(_cmd, std::cerr);

        std::cerr << std::endl
                  << "For complete USAGE and HELP type: " << std::endl
                  << "   " << progName << " " << Arg::nameStartString()
                  << "help" << std::endl
                  << std::endl;
    } else {
        usage(_cmd);
    }

    throw ExitException(1);
}

// TODO: Remove this
inline void removeChar(std::string &s, char r) {
    size_t p;
    while ((p = s.find_first_of(r)) != std::string::npos) {
        s.erase(p, 1);
    }
}

inline bool cmpSwitch(const char &a, const char &b) {
    int lowa = std::tolower(a);
    int lowb = std::tolower(b);

    if (lowa == lowb) {
        return a < b;
    }

    return lowa < lowb;
}

namespace internal {
inline bool IsVisibleShortSwitch(const Arg &arg) {
    return !(arg.getName() == Arg::ignoreNameString() ||
             arg.isValueRequired() || arg.getFlag() == "") &&
           arg.visibleInHelp();
}

inline bool IsVisibleLongSwitch(const Arg &arg) {
    return (arg.getName() != Arg::ignoreNameString() &&
            !arg.isValueRequired() && arg.getFlag() == "" &&
            arg.visibleInHelp());
}

inline bool IsVisibleOption(const Arg &arg) {
    return (arg.getName() != Arg::ignoreNameString() && arg.isValueRequired() &&
            arg.hasLabel() && arg.visibleInHelp());
}

inline bool CompareShortID(const Arg *a, const Arg *b) {
    if (a->getFlag() == "" && b->getFlag() != "") {
        return false;
    }
    if (b->getFlag() == "" && a->getFlag() != "") {
        return true;
    }

    return a->shortID() < b->shortID();
}

// TODO: Fix me not to put --gopt before -f
inline bool CompareOptions(std::pair<const Arg *, bool> a,
                           std::pair<const Arg *, bool> b) {
    // First optional, then required
    if (!a.second && b.second) {
        return true;
    }
    if (a.second && !b.second) {
        return false;
    }

    return CompareShortID(a.first, b.first);
}
}  // namespace internal

/**
 * Usage statements should look like the manual pages.  Options w/o
 * operands come first, in alphabetical order inside a single set of
 * braces, upper case before lower case (AaBbCc...).  Next are options
 * with operands, in the same order, each in braces.  Then required
 * arguments in the order they are specified, followed by optional
 * arguments in the order they are specified.  A bar (`|') separates
 * either/or options/arguments, and multiple options/arguments which
 * are specified together are placed in a single set of braces.
 *
 * Use getprogname() instead of hardcoding the program name.
 *
 * "usage: f [-aDde] [-b b_arg] [-m m_arg] req1 req2 [opt1 [opt2]]\n"
 * "usage: f [-a | -b] [-c [-de] [-n number]]\n"
 */
inline void StdOutput::_shortUsage(CmdLineInterface &_cmd,
                                   std::ostream &os) const {
    std::list<ArgGroup *> argSets = _cmd.getArgGroups();

    std::ostringstream outp;
    outp << _cmd.getProgramName() + " ";

    std::string switches = Arg::flagStartString();

    std::list<ArgGroup *> exclusiveGroups;
    std::list<ArgGroup *> nonExclusiveGroups;
    for (std::list<ArgGroup *>::iterator sit = argSets.begin();
         sit != argSets.end(); ++sit) {
        if (CountVisibleArgs(**sit) <= 0) {
            continue;
        }

        if ((*sit)->isExclusive()) {
            exclusiveGroups.push_back(*sit);
        } else {
            nonExclusiveGroups.push_back(*sit);
        }
    }

    // Move "exclusive groups" that have at most a single item to
    // non-exclusive groups as exclusivit doesn't make sense with a
    // single option. This can happen if args are hidden in help for
    // example.
    for (std::list<ArgGroup *>::iterator it = exclusiveGroups.begin();
         it != exclusiveGroups.end();) {
        if (CountVisibleArgs(**it) < 2) {
            nonExclusiveGroups.push_back(*it);
            it = exclusiveGroups.erase(it);
        } else {
            ++it;
        }
    }

    // First short switches (needs to be special because they are all
    // stuck together).
    for (std::list<ArgGroup *>::iterator sit = nonExclusiveGroups.begin();
         sit != nonExclusiveGroups.end(); ++sit) {
        for (ArgGroup::iterator it = (*sit)->begin(); it != (*sit)->end();
             ++it) {
            if (internal::IsVisibleShortSwitch(**it)) {
                switches += (*it)->getFlag();
            }
        }

        std::sort(switches.begin(), switches.end(), cmpSwitch);
    }

    outp << " [" << switches << ']';

    // Now do long switches (e.g., --version, but no -v)
    std::vector<Arg *> longSwitches;
    for (std::list<ArgGroup *>::iterator sit = nonExclusiveGroups.begin();
         sit != nonExclusiveGroups.end(); ++sit) {
        for (ArgGroup::iterator it = (*sit)->begin(); it != (*sit)->end();
             ++it) {
            Arg &arg = **it;
            if (internal::IsVisibleLongSwitch(arg)) {
                longSwitches.push_back(&arg);
            }
        }
    }

    std::sort(longSwitches.begin(), longSwitches.end(),
              internal::CompareShortID);
    for (std::vector<Arg *>::const_iterator it = longSwitches.begin();
         it != longSwitches.end(); ++it) {
        outp << " [" << (**it).shortID() << ']';
    }

    // Now do all exclusive groups
    for (std::list<ArgGroup *>::iterator sit = exclusiveGroups.begin();
         sit != exclusiveGroups.end(); ++sit) {
        ArgGroup &argGroup = **sit;
        outp << (argGroup.isRequired() ? " {" : " [");

        std::vector<Arg *> args;
        for (ArgGroup::iterator it = argGroup.begin(); it != argGroup.end();
             ++it) {
            if ((**it).visibleInHelp()) {
                args.push_back(*it);
            }
        }

        std::sort(args.begin(), args.end(), internal::CompareShortID);
        std::string sep = "";
        for (std::vector<Arg *>::const_iterator it = args.begin();
             it != args.end(); ++it) {
            outp << sep << (**it).shortID();
            sep = "|";
        }

        outp << (argGroup.isRequired() ? '}' : ']');
    }

    // Next do options, we sort them later by optional first.
    std::vector<std::pair<const Arg *, bool> > options;
    for (std::list<ArgGroup *>::iterator sit = nonExclusiveGroups.begin();
         sit != nonExclusiveGroups.end(); ++sit) {
        for (ArgGroup::iterator it = (*sit)->begin(); it != (*sit)->end();
             ++it) {
            Arg &arg = **it;
            int visible = CountVisibleArgs(**sit);
            bool required = arg.isRequired();
            if (internal::IsVisibleOption(arg)) {
                if (visible == 1 && (**sit).isRequired()) {
                    required = true;
                }

                options.push_back(std::make_pair(&arg, required));
            }
        }
    }

    std::sort(options.begin(), options.end(), internal::CompareOptions);
    for (std::vector<std::pair<const Arg *, bool> >::const_iterator it =
             options.begin();
         it != options.end(); ++it) {
        const Arg &arg = *it->first;
        bool required = it->second;
        outp << (required ? " " : " [");
        outp << arg.shortID();
        outp << (required ? "" : "]");
    }

    // Next do argsuments ("unlabled") in order of definition
    for (std::list<ArgGroup *>::iterator sit = nonExclusiveGroups.begin();
         sit != nonExclusiveGroups.end(); ++sit) {
        for (ArgGroup::iterator it = (*sit)->begin(); it != (*sit)->end();
             ++it) {
            Arg &arg = **it;
            if (arg.getName() == Arg::ignoreNameString()) {
                continue;
            }

            if (arg.isValueRequired() && !arg.hasLabel() &&
                arg.visibleInHelp()) {
                outp << (arg.isRequired() ? " " : " [");
                outp << arg.shortID();
                outp << (arg.isRequired() ? "" : "]");
            }
        }
    }

    // if the program name is too long, then adjust the second line offset
    int secondLineOffset = static_cast<int>(_cmd.getProgramName().length()) + 2;
    if (secondLineOffset > 75 / 2) secondLineOffset = static_cast<int>(75 / 2);

    spacePrint(os, outp.str(), 75, 3, secondLineOffset);
}

inline void StdOutput::_longUsage(CmdLineInterface &_cmd,
                                  std::ostream &os) const {
    std::string message = _cmd.getMessage();
    std::list<ArgGroup *> argSets = _cmd.getArgGroups();

    std::list<Arg *> unlabled;
    for (std::list<ArgGroup *>::iterator sit = argSets.begin();
         sit != argSets.end(); ++sit) {
        ArgGroup &argGroup = **sit;

        int visible = CountVisibleArgs(argGroup);
        bool exclusive = visible > 1 && argGroup.isExclusive();
        bool forceRequired = visible == 1 && argGroup.isRequired();
        if (exclusive) {
            spacePrint(os, argGroup.isRequired() ? "One of:" : "Either of:", 75,
                       3, 0);
        }

        for (ArgGroup::iterator it = argGroup.begin(); it != argGroup.end();
             ++it) {
            Arg &arg = **it;
            if (!arg.visibleInHelp()) {
                continue;
            }

            if (!arg.hasLabel()) {
                unlabled.push_back(&arg);
                continue;
            }

            bool required = arg.isRequired() || forceRequired;
            if (exclusive) {
                spacePrint(os, arg.longID(), 75, 6, 3);
                spacePrint(os, arg.getDescription(required), 75, 8, 0);
            } else {
                spacePrint(os, arg.longID(), 75, 3, 3);
                spacePrint(os, arg.getDescription(required), 75, 5, 0);
            }
            os << '\n';
        }
    }

    for (ArgListIterator it = unlabled.begin(); it != unlabled.end(); ++it) {
        const Arg &arg = **it;
        spacePrint(os, arg.longID(), 75, 3, 3);
        spacePrint(os, arg.getDescription(), 75, 5, 0);
        os << '\n';
    }

    if (!message.empty()) {
        spacePrint(os, message, 75, 3, 0);
    }

    os.flush();
}

namespace {
inline void fmtPrintLine(std::ostream &os, const std::string &s, int maxWidth,
                         int indentSpaces, int secondLineOffset) {
    const std::string splitChars(" ,|");
    int maxChars = maxWidth - indentSpaces;
    std::string indentString(indentSpaces, ' ');
    int from = 0;
    int to = 0;
    int end = (int)s.length();
    for (;;) {
        if (end - from <= maxChars) {
            // Rest of string fits on line, just print the remainder
            os << indentString << s.substr(from) << std::endl;
            return;
        }

        // Find the next place where it is good to break the string
        // (to) by finding the place where it is too late (tooFar) and
        // taking the previous one.
        int tooFar = to;
        while (tooFar - from <= maxChars &&
               static_cast<std::size_t>(tooFar) != std::string::npos) {
            to = tooFar;
            tooFar = s.find_first_of(splitChars, (int)to + 1);
        }

        if (to == from) {
            // In case there was no good place to break the string,
            // just break it in the middle of a word at line length.
            to = from + maxChars - 1;
        }

        if (s[to] != ' ') {
            // Include delimiter before line break, unless it's a space
            to++;
        }

        os << indentString << s.substr(from, to - from) << '\n';

        // Avoid printing extra white space at start of a line
        for (; s[to] == ' '; to++) {
        }
        from = to;

        if (secondLineOffset != 0) {
            // Adjust offset for following lines
            indentString.insert(indentString.end(), secondLineOffset, ' ');
            maxChars -= secondLineOffset;
            secondLineOffset = 0;
        }
    }
}
}  // namespace

inline void StdOutput::spacePrint(std::ostream &os, const std::string &s,
                                  int maxWidth, int indentSpaces,
                                  int secondLineOffset) const {
    std::stringstream ss(s);
    std::string line;
    std::getline(ss, line);
    fmtPrintLine(os, line, maxWidth, indentSpaces, secondLineOffset);
    indentSpaces += secondLineOffset;

    while (std::getline(ss, line)) {
        fmtPrintLine(os, line, maxWidth, indentSpaces, 0);
    }
}

}  // namespace TCLAP

#endif  // TCLAP_STD_OUTPUT_H


================================================
FILE: lib/tclap/SwitchArg.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  SwitchArg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_SWITCH_ARG_H
#define TCLAP_SWITCH_ARG_H

#include <tclap/Arg.h>

#include <string>
#include <vector>

namespace TCLAP {

/**
 * A simple switch argument.  If the switch is set on the command line, then
 * the getValue method will return the opposite of the default value for the
 * switch.
 */
class SwitchArg : public Arg {
protected:
    /**
     * The value of the switch.
     */
    bool _value;

    /**
     * Used to support the reset() method so that ValueArg can be
     * reset to their constructed value.
     */
    bool _default;

public:
    /**
     * SwitchArg constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param def - The default value for this Switch.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    SwitchArg(const std::string &flag, const std::string &name,
              const std::string &desc, bool def = false, Visitor *v = NULL);

    /**
     * SwitchArg constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param def - The default value for this Switch.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    SwitchArg(const std::string &flag, const std::string &name,
              const std::string &desc, ArgContainer &parser, bool def = false,
              Visitor *v = NULL);

    /**
     * Handles the processing of the argument.
     * This re-implements the Arg version of this method to set the
     * _value of the argument appropriately.
     * \param i - Pointer the the current argument in the list.
     * \param args - Mutable list of strings. Passed
     * in from main().
     */
    virtual bool processArg(int *i, std::vector<std::string> &args);

    /**
     * Checks a string to see if any of the chars in the string
     * match the flag for this Switch.
     */
    bool combinedSwitchesMatch(std::string &combined);

    /**
     * Returns bool, whether or not the switch has been set.
     */
    bool getValue() const { return _value; }

    /**
     * A SwitchArg can be used as a boolean, indicating
     * whether or not the switch has been set. This is the
     * same as calling getValue()
     */
    operator bool() const { return _value; }

    virtual void reset();

private:
    /**
     * Checks to see if we've found the last match in
     * a combined string.
     */
    bool lastCombined(std::string &combined);

    /**
     * Does the common processing of processArg.
     */
    void commonProcessing();
};

//////////////////////////////////////////////////////////////////////
// BEGIN SwitchArg.cpp
//////////////////////////////////////////////////////////////////////
inline SwitchArg::SwitchArg(const std::string &flag, const std::string &name,
                            const std::string &desc, bool default_val,
                            Visitor *v)
    : Arg(flag, name, desc, false, false, v),
      _value(default_val),
      _default(default_val) {}

inline SwitchArg::SwitchArg(const std::string &flag, const std::string &name,
                            const std::string &desc, ArgContainer &parser,
                            bool default_val, Visitor *v)
    : Arg(flag, name, desc, false, false, v),
      _value(default_val),
      _default(default_val) {
    parser.add(this);
}

inline bool SwitchArg::lastCombined(std::string &combinedSwitches) {
    for (unsigned int i = 1; i < combinedSwitches.length(); i++)
        if (combinedSwitches[i] != Arg::blankChar()) return false;

    return true;
}

inline bool SwitchArg::combinedSwitchesMatch(std::string &combinedSwitches) {
    // make sure this is actually a combined switch
    if (combinedSwitches.length() > 0 &&
        combinedSwitches[0] != Arg::flagStartString()[0])
        return false;

    // make sure it isn't a long name
    if (combinedSwitches.substr(0, Arg::nameStartString().length()) ==
        Arg::nameStartString())
        return false;

    // make sure the delimiter isn't in the string
    if (combinedSwitches.find_first_of(Arg::delimiter()) != std::string::npos)
        return false;

    // ok, we're not specifying a ValueArg, so we know that we have
    // a combined switch list.
    for (unsigned int i = 1; i < combinedSwitches.length(); i++) {
        if (_flag.length() > 0 && combinedSwitches[i] == _flag[0] &&
            _flag[0] != Arg::flagStartString()[0]) {
            // update the combined switches so this one is no longer
            // present this is necessary so that no unlabeled args are
            // matched later in the processing.
            // combinedSwitches.erase(i,1);
            _setBy = Arg::flagStartString() + combinedSwitches[i];
            combinedSwitches[i] = Arg::blankChar();
            return true;
        }
    }

    // none of the switches passed in the list match.
    return false;
}

inline void SwitchArg::commonProcessing() {
    if (_alreadySet)
        throw(CmdLineParseException("Argument already set!", toString()));

    _alreadySet = true;

    if (_value == true)
        _value = false;
    else
        _value = true;

    _checkWithVisitor();
}

inline bool SwitchArg::processArg(int *i, std::vector<std::string> &args) {
    if (argMatches(args[*i])) {
        // The whole string matches the flag or name string
        _setBy = args[*i];
        commonProcessing();

        return true;
    } else if (combinedSwitchesMatch(args[*i])) {
        // A substring matches the flag as part of a combination
        // check again to ensure we don't misinterpret
        // this as a MultiSwitchArg
        if (combinedSwitchesMatch(args[*i]))
            throw(CmdLineParseException("Argument already set!", toString()));

        commonProcessing();

        // We only want to return true if we've found the last combined
        // match in the string, otherwise we return true so that other
        // switches in the combination will have a chance to match.
        return lastCombined(args[*i]);
    }

    return false;
}

inline void SwitchArg::reset() {
    Arg::reset();
    _value = _default;
}

}  // namespace TCLAP

#endif  // TCLAP_SWITCH_ARG_H


================================================
FILE: lib/tclap/UnlabeledMultiArg.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  UnlabeledMultiArg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_UNLABELED_MULTI_ARG_H
#define TCLAP_UNLABELED_MULTI_ARG_H

#include <tclap/MultiArg.h>
#include <tclap/OptionalUnlabeledTracker.h>

#include <list>
#include <string>
#include <vector>

namespace TCLAP {

/**
 * Just like a MultiArg, except that the arguments are unlabeled.  Basically,
 * this Arg will slurp up everything that hasn't been matched to another
 * Arg.
 */
template <class T>
class UnlabeledMultiArg : public MultiArg<T> {
    // If compiler has two stage name lookup (as gcc >= 3.4 does)
    // this is required to prevent undef. symbols
    using MultiArg<T>::_ignoreable;
    using MultiArg<T>::_hasBlanks;
    using MultiArg<T>::_extractValue;
    using MultiArg<T>::_typeDesc;
    using MultiArg<T>::_name;
    using MultiArg<T>::_description;
    using MultiArg<T>::_alreadySet;
    using MultiArg<T>::_setBy;
    using MultiArg<T>::toString;

public:
    /**
     * Constructor.
     * \param name - The name of the Arg. Note that this is used for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     *  line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param ignoreable - Whether or not this argument can be ignored
     * using the "--" flag.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    UnlabeledMultiArg(const std::string &name, const std::string &desc,
                      bool req, const std::string &typeDesc,
                      bool ignoreable = false, Visitor *v = NULL);
    /**
     * Constructor.
     * \param name - The name of the Arg. Note that this is used for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     *  line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param ignoreable - Whether or not this argument can be ignored
     * using the "--" flag.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    UnlabeledMultiArg(const std::string &name, const std::string &desc,
                      bool req, const std::string &typeDesc,
                      ArgContainer &parser, bool ignoreable = false,
                      Visitor *v = NULL);

    /**
     * Constructor.
     * \param name - The name of the Arg. Note that this is used for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     *  line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param ignoreable - Whether or not this argument can be ignored
     * using the "--" flag.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    UnlabeledMultiArg(const std::string &name, const std::string &desc,
                      bool req, Constraint<T> *constraint,
                      bool ignoreable = false, Visitor *v = NULL);

    /**
     * Constructor.
     * \param name - The name of the Arg. Note that this is used for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     *  line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param ignoreable - Whether or not this argument can be ignored
     * using the "--" flag.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    UnlabeledMultiArg(const std::string &name, const std::string &desc,
                      bool req, Constraint<T> *constraint, ArgContainer &parser,
                      bool ignoreable = false, Visitor *v = NULL);

    /**
     * Handles the processing of the argument.
     * This re-implements the Arg version of this method to set the
     * _value of the argument appropriately.  It knows the difference
     * between labeled and unlabeled.
     * \param i - Pointer the the current argument in the list.
     * \param args - Mutable list of strings. Passed from main().
     */
    virtual bool processArg(int *i, std::vector<std::string> &args);

    /**
     * Returns the a short id string.  Used in the usage.
     */
    virtual std::string shortID(const std::string &) const {
        return Arg::getName() + " ...";
    }

    /**
     * Returns the a long id string.  Used in the usage.
     * \param val - value to be used.
     */
    virtual std::string longID(const std::string &) const {
        return Arg::getName() + " (accepted multiple times) <" + _typeDesc +
               ">";
    }

    /**
     * Operator ==.
     * \param a - The Arg to be compared to this.
     */
    virtual bool operator==(const Arg &a) const;

    /**
     * Pushes this to back of list rather than front.
     * \param argList - The list this should be added to.
     */
    virtual void addToList(std::list<Arg *> &argList) const;

    virtual bool hasLabel() const { return false; }
};

template <class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        const std::string &typeDesc,
                                        bool ignoreable, Visitor *v)
    : MultiArg<T>("", name, desc, req, typeDesc, v) {
    _ignoreable = ignoreable;
    OptionalUnlabeledTracker::check(true, toString());
}

template <class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        const std::string &typeDesc,
                                        ArgContainer &parser, bool ignoreable,
                                        Visitor *v)
    : MultiArg<T>("", name, desc, req, typeDesc, v) {
    _ignoreable = ignoreable;
    OptionalUnlabeledTracker::check(true, toString());
    parser.add(this);
}

template <class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        Constraint<T> *constraint,
                                        bool ignoreable, Visitor *v)
    : MultiArg<T>("", name, desc, req, constraint, v) {
    _ignoreable = ignoreable;
    OptionalUnlabeledTracker::check(true, toString());
}

template <class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        Constraint<T> *constraint,
                                        ArgContainer &parser, bool ignoreable,
                                        Visitor *v)
    : MultiArg<T>("", name, desc, req, constraint, v) {
    _ignoreable = ignoreable;
    OptionalUnlabeledTracker::check(true, toString());
    parser.add(this);
}

template <class T>
bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string> &args) {
    if (_hasBlanks(args[*i])) return false;

    // never ignore an unlabeled multi arg

    // always take the first value, regardless of the start string
    _extractValue(args[(*i)]);

    /*
    // continue taking args until we hit the end or a start string
    while ( (unsigned int)(*i)+1 < args.size() &&
            args[(*i)+1].find_first_of( Arg::flagStartString() ) != 0 &&
            args[(*i)+1].find_first_of( Arg::nameStartString() ) != 0 )
        _extractValue( args[++(*i)] );
    */

    _alreadySet = true;
    _setBy = args[*i];

    return true;
}

template <class T>
bool UnlabeledMultiArg<T>::operator==(const Arg &a) const {
    if (_name == a.getName() || _description == a.getDescription())
        return true;
    else
        return false;
}

template <class T>
void UnlabeledMultiArg<T>::addToList(std::list<Arg *> &argList) const {
    argList.push_back(const_cast<Arg *>(static_cast<const Arg *const>(this)));
}
}  // namespace TCLAP

#endif  // TCLAP_UNLABELED_MULTI_ARG_H


================================================
FILE: lib/tclap/UnlabeledValueArg.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  UnlabeledValueArg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_UNLABELED_VALUE_ARG_H
#define TCLAP_UNLABELED_VALUE_ARG_H

#include <tclap/OptionalUnlabeledTracker.h>
#include <tclap/ValueArg.h>

#include <list>
#include <string>
#include <vector>

namespace TCLAP {

/**
 * The basic unlabeled argument that parses a value.
 * This is a template class, which means the type T defines the type
 * that a given object will attempt to parse when an UnlabeledValueArg
 * is reached in the list of args that the CmdLine iterates over.
 */
template <class T>
class UnlabeledValueArg : public ValueArg<T> {
    // If compiler has two stage name lookup (as gcc >= 3.4 does)
    // this is required to prevent undef. symbols
    using ValueArg<T>::_ignoreable;
    using ValueArg<T>::_hasBlanks;
    using ValueArg<T>::_extractValue;
    using ValueArg<T>::_typeDesc;
    using ValueArg<T>::_name;
    using ValueArg<T>::_description;
    using ValueArg<T>::_alreadySet;
    using ValueArg<T>::_setBy;
    using ValueArg<T>::toString;

public:
    /**
     * UnlabeledValueArg constructor.
     * \param name - A one word name for the argument.  Note that this is used
     * for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param ignoreable - Allows you to specify that this argument can be
     * ignored if the '--' flag is set.  This defaults to false (cannot
     * be ignored) and should  generally stay that way unless you have
     * some special need for certain arguments to be ignored.
     * \param v - Optional Visitor.  You should leave this blank unless
     * you have a very good reason.
     */
    UnlabeledValueArg(const std::string &name, const std::string &desc,
                      bool req, T value, const std::string &typeDesc,
                      bool ignoreable = false, Visitor *v = NULL);

    /**
     * UnlabeledValueArg constructor.
     * \param name - A one word name for the argument.  Note that this is used
     * for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param ignoreable - Allows you to specify that this argument can be
     * ignored if the '--' flag is set.  This defaults to false (cannot
     * be ignored) and should  generally stay that way unless you have
     * some special need for certain arguments to be ignored.
     * \param v - Optional Visitor.  You should leave this blank unless
     * you have a very good reason.
     */
    UnlabeledValueArg(const std::string &name, const std::string &desc,
                      bool req, T value, const std::string &typeDesc,
                      CmdLineInterface &parser, bool ignoreable = false,
                      Visitor *v = NULL);

    /**
     * UnlabeledValueArg constructor.
     * \param name - A one word name for the argument.  Note that this is used
     * for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param ignoreable - Allows you to specify that this argument can be
     * ignored if the '--' flag is set.  This defaults to false (cannot
     * be ignored) and should  generally stay that way unless you have
     * some special need for certain arguments to be ignored.
     * \param v - Optional Visitor.  You should leave this blank unless
     * you have a very good reason.
     */
    UnlabeledValueArg(const std::string &name, const std::string &desc,
                      bool req, T value, Constraint<T> *constraint,
                      bool ignoreable = false, Visitor *v = NULL);

    /**
     * UnlabeledValueArg constructor.
     * \param name - A one word name for the argument.  Note that this is used
     * for
     * identification, not as a long flag.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param ignoreable - Allows you to specify that this argument can be
     * ignored if the '--' flag is set.  This defaults to false (cannot
     * be ignored) and should  generally stay that way unless you have
     * some special need for certain arguments to be ignored.
     * \param v - Optional Visitor.  You should leave this blank unless
     * you have a very good reason.
     */
    UnlabeledValueArg(const std::string &name, const std::string &desc,
                      bool req, T value, Constraint<T> *constraint,
                      CmdLineInterface &parser, bool ignoreable = false,
                      Visitor *v = NULL);

    /**
     * Handles the processing of the argument.
     * This re-implements the Arg version of this method to set the
     * _value of the argument appropriately.  Handling specific to
     * unlabeled arguments.
     * \param i - Pointer the the current argument in the list.
     * \param args - Mutable list of strings.
     */
    virtual bool processArg(int *i, std::vector<std::string> &args);

    /**
     * Overrides shortID for specific behavior.
     */
    virtual std::string shortID(const std::string &) const {
        return Arg::getName();
    }

    /**
     * Overrides longID for specific behavior.
     */
    virtual std::string longID(const std::string &) const {
        return Arg::getName() + " <" + _typeDesc + ">";
    }

    /**
     * Overrides operator== for specific behavior.
     */
    virtual bool operator==(const Arg &a) const;

    /**
     * Instead of pushing to the front of list, push to the back.
     * \param argList - The list to add this to.
     */
    virtual void addToList(std::list<Arg *> &argList) const;

    virtual bool hasLabel() const { return false; }
};

/**
 * Constructor implementation.
 */
template <class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        T val, const std::string &typeDesc,
                                        bool ignoreable, Visitor *v)
    : ValueArg<T>("", name, desc, req, val, typeDesc, v) {
    _ignoreable = ignoreable;

    OptionalUnlabeledTracker::check(req, toString());
}

template <class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        T val, const std::string &typeDesc,
                                        CmdLineInterface &parser,
                                        bool ignoreable, Visitor *v)
    : ValueArg<T>("", name, desc, req, val, typeDesc, v) {
    _ignoreable = ignoreable;
    OptionalUnlabeledTracker::check(req, toString());
    parser.add(this);
}

/**
 * Constructor implementation.
 */
template <class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        T val, Constraint<T> *constraint,
                                        bool ignoreable, Visitor *v)
    : ValueArg<T>("", name, desc, req, val, constraint, v) {
    _ignoreable = ignoreable;
    OptionalUnlabeledTracker::check(req, toString());
}

template <class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name,
                                        const std::string &desc, bool req,
                                        T val, Constraint<T> *constraint,
                                        CmdLineInterface &parser,
                                        bool ignoreable, Visitor *v)
    : ValueArg<T>("", name, desc, req, val, constraint, v) {
    _ignoreable = ignoreable;
    OptionalUnlabeledTracker::check(req, toString());
    parser.add(this);
}

/**
 * Implementation of processArg().
 */
template <class T>
bool UnlabeledValueArg<T>::processArg(int *i, std::vector<std::string> &args) {
    if (_alreadySet) return false;

    if (_hasBlanks(args[*i])) return false;

    // never ignore an unlabeled arg

    _extractValue(args[*i]);
    _alreadySet = true;
    _setBy = args[*i];
    return true;
}

/**
 * Overriding operator== for specific behavior.
 */
template <class T>
bool UnlabeledValueArg<T>::operator==(const Arg &a) const {
    if (_name == a.getName() || _description == a.getDescription())
        return true;
    else
        return false;
}

template <class T>
void UnlabeledValueArg<T>::addToList(std::list<Arg *> &argList) const {
    argList.push_back(const_cast<Arg *>(static_cast<const Arg *const>(this)));
}
}  // namespace TCLAP

#endif  // TCLAP_UNLABELED_VALUE_ARG_H


================================================
FILE: lib/tclap/ValueArg.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  ValueArg.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_VALUE_ARG_H
#define TCLAP_VALUE_ARG_H

#include <tclap/Arg.h>
#include <tclap/Constraint.h>

#include <string>
#include <vector>

namespace TCLAP {

/**
 * The basic labeled argument that parses a value.
 * This is a template class, which means the type T defines the type
 * that a given object will attempt to parse when the flag/name is matched
 * on the command line.  While there is nothing stopping you from creating
 * an unflagged ValueArg, it is unwise and would cause significant problems.
 * Instead use an UnlabeledValueArg.
 */
template <class T>
class ValueArg : public Arg {
protected:
    /**
     * The value parsed from the command line.
     * Can be of any type, as long as the >> operator for the type
     * is defined.
     */
    T _value;

    /**
     * Used to support the reset() method so that ValueArg can be
     * reset to their constructed value.
     */
    T _default;

    /**
     * A human readable description of the type to be parsed.
     * This is a hack, plain and simple.  Ideally we would use RTTI to
     * return the name of type T, but until there is some sort of
     * consistent support for human readable names, we are left to our
     * own devices.
     */
    std::string _typeDesc;

    /**
     * A Constraint this Arg must conform to.
     */
    Constraint<T> *_constraint;

    /**
     * Extracts the value from the string.
     * Attempts to parse string as type T, if this fails an exception
     * is thrown.
     * \param val - value to be parsed.
     */
    void _extractValue(const std::string &val);

public:
    /**
     * Labeled ValueArg constructor.
     * You could conceivably call this constructor with a blank flag,
     * but that would make you a bad person.  It would also cause
     * an exception to be thrown.   If you want an unlabeled argument,
     * use the other constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    ValueArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, T value,
             const std::string &typeDesc, Visitor *v = NULL);

    /**
     * Labeled ValueArg constructor.
     * You could conceivably call this constructor with a blank flag,
     * but that would make you a bad person.  It would also cause
     * an exception to be thrown.   If you want an unlabeled argument,
     * use the other constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param typeDesc - A short, human readable description of the
     * type that this object expects.  This is used in the generation
     * of the USAGE statement.  The goal is to be helpful to the end user
     * of the program.
     * \param parser - A CmdLine parser object to add this Arg to
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    ValueArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, T value,
             const std::string &typeDesc, ArgContainer &parser,
             Visitor *v = NULL);

    /**
     * Labeled ValueArg constructor.
     * You could conceivably call this constructor with a blank flag,
     * but that would make you a bad person.  It would also cause
     * an exception to be thrown.   If you want an unlabeled argument,
     * use the other constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param parser - A CmdLine parser object to add this Arg to.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    ValueArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, T value,
             Constraint<T> *constraint, ArgContainer &parser,
             Visitor *v = NULL);

    /**
     * Labeled ValueArg constructor.
     * You could conceivably call this constructor with a blank flag,
     * but that would make you a bad person.  It would also cause
     * an exception to be thrown.   If you want an unlabeled argument,
     * use the other constructor.
     * \param flag - The one character flag that identifies this
     * argument on the command line.
     * \param name - A one word name for the argument.  Can be
     * used as a long flag on the command line.
     * \param desc - A description of what the argument is for or
     * does.
     * \param req - Whether the argument is required on the command
     * line.
     * \param value - The default value assigned to this argument if it
     * is not present on the command line.
     * \param constraint - A pointer to a Constraint object used
     * to constrain this Arg.
     * \param v - An optional visitor.  You probably should not
     * use this unless you have a very good reason.
     */
    ValueArg(const std::string &flag, const std::string &name,
             const std::string &desc, bool req, T value,
             Constraint<T> *constraint, Visitor *v = NULL);

    /**
     * Handles the processing of the argument.
     * This re-implements the Arg version of this method to set the
     * _value of the argument appropriately.  It knows the difference
     * between labeled and unlabeled.
     * \param i - Pointer the the current argument in the list.
     * \param args - Mutable list of strings. Passed
     * in from main().
     */
    virtual bool processArg(int *i, std::vector<std::string> &args);

    /**
     * Returns the value of the argument.
     */
    const T &getValue() const { return _value; }

    /**
     * A ValueArg can be used as as its value type (T) This is the
     * same as calling getValue()
     */
    operator const T &() const { return getValue(); }

    /**
     * Specialization of shortID.
     * \param val - value to be used.
     */
    virtual std::string shortID(const std::string &val = "val") const;

    /**
     * Specialization of longID.
     * \param val - value to be used.
     */
    virtual std::string longID(const std::string &val = "val") const;

    virtual void reset();

private:
    /**
     * Prevent accidental copying
     */
    ValueArg<T>(const ValueArg<T> &rhs);
    ValueArg<T> &operator=(const ValueArg<T> &rhs);
};

/**
 * Constructor implementation.
 */
template <class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req, T val,
                      const std::string &typeDesc, Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _value(val),
      _default(val),
      _typeDesc(typeDesc),
      _constraint(NULL) {}

template <class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req, T val,
                      const std::string &typeDesc, ArgContainer &parser,
                      Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _value(val),
      _default(val),
      _typeDesc(typeDesc),
      _constraint(NULL) {
    parser.add(this);
}

template <class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req, T val,
                      Constraint<T> *constraint, Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _value(val),
      _default(val),
      _typeDesc(Constraint<T>::shortID(constraint)),
      _constraint(constraint) {}

template <class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name,
                      const std::string &desc, bool req, T val,
                      Constraint<T> *constraint, ArgContainer &parser,
                      Visitor *v)
    : Arg(flag, name, desc, req, true, v),
      _value(val),
      _default(val),
      _typeDesc(Constraint<T>::shortID(constraint)),
      _constraint(constraint) {
    parser.add(this);
}

/**
 * Implementation of processArg().
 */
template <class T>
bool ValueArg<T>::processArg(int *i, std::vector<std::string> &args) {
    if (_hasBlanks(args[*i])) return false;

    std::string flag = args[*i];

    std::string value = "";
    trimFlag(flag, value);

    if (argMatches(flag)) {
        if (_alreadySet) {
            throw(CmdLineParseException("Argument already set!", toString()));
        }

        if (Arg::delimiter() != ' ' && value == "")
            throw(ArgParseException(
                "Couldn't find delimiter for this argument!", toString()));

        if (value == "") {
            (*i)++;
            if (static_cast<unsigned int>(*i) < args.size())
                _extractValue(args[*i]);
            else
                throw(ArgParseException("Missing a value for this argument!",
                                        toString()));
        } else {
            _extractValue(value);
        }

        _alreadySet = true;
        _setBy = flag;
        _checkWithVisitor();
        return true;
    } else {
        return false;
    }
}

/**
 * Implementation of shortID.
 */
template <class T>
std::string ValueArg<T>::shortID(const std::string &) const {
    return Arg::shortID("<" + _typeDesc + ">");
}

/**
 * Implementation of longID.
 */
template <class T>
std::string ValueArg<T>::longID(const std::string &) const {
    return Arg::longID("<" + _typeDesc + ">");
}

template <class T>
void ValueArg<T>::_extractValue(const std::string &val) {
    try {
        ExtractValue(_value, val, typename ArgTraits<T>::ValueCategory());
    } catch (ArgParseException &e) {
        throw ArgParseException(e.error(), toString());
    }

    if (_constraint != NULL)
        if (!_constraint->check(_value))
            throw(CmdLineParseException("Value '" + val +
                                            +"' does not meet constraint: " +
                                            _constraint->description(),
                                        toString()));
}

template <class T>
void ValueArg<T>::reset() {
    Arg::reset();
    _value = _default;
}

}  // namespace TCLAP

#endif  // TCLAP_VALUE_ARG_H


================================================
FILE: lib/tclap/ValuesConstraint.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  ValuesConstraint.h
 *
 *  Copyright (c) 2005, Michael E. Smoot
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_VALUES_CONSTRAINT_H
#define TCLAP_VALUES_CONSTRAINT_H

#include <tclap/Constraint.h>
#include <tclap/sstream.h>

#include <string>
#include <vector>

namespace TCLAP {

/**
 * A Constraint that constrains the Arg to only those values specified
 * in the constraint.
 */
template <class T>
class ValuesConstraint : public Constraint<T> {
public:
    /**
     * Constructor.
     * \param allowed - vector of allowed values.
     */
    explicit ValuesConstraint(std::vector<T> &allowed);

    /**
     * Virtual destructor.
     */
    virtual ~ValuesConstraint() {}

    /**
     * Returns a description of the Constraint.
     */
    virtual std::string description() const;

    /**
     * Returns the short ID for the Constraint.
     */
    virtual std::string shortID() const;

    /**
     * The method used to verify that the value parsed from the command
     * line meets the constraint.
     * \param value - The value that will be checked.
     */
    virtual bool check(const T &value) const;

protected:
    /**
     * The list of valid values.
     */
    std::vector<T> _allowed;

    /**
     * The string used to describe the allowed values of this constraint.
     */
    std::string _typeDesc;
};

template <class T>
ValuesConstraint<T>::ValuesConstraint(std::vector<T> &allowed)
    : _allowed(allowed), _typeDesc("") {
    for (unsigned int i = 0; i < _allowed.size(); i++) {
        std::ostringstream os;
        os << _allowed[i];

        std::string temp(os.str());

        if (i > 0) _typeDesc += "|";
        _typeDesc += temp;
    }
}

template <class T>
bool ValuesConstraint<T>::check(const T &val) const {
    if (std::find(_allowed.begin(), _allowed.end(), val) == _allowed.end())
        return false;
    else
        return true;
}

template <class T>
std::string ValuesConstraint<T>::shortID() const {
    return _typeDesc;
}

template <class T>
std::string ValuesConstraint<T>::description() const {
    return _typeDesc;
}

}  // namespace TCLAP
#endif  // TCLAP_VALUES_CONSTRAINT_H


================================================
FILE: lib/tclap/VersionVisitor.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  VersionVisitor.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_VERSION_VISITOR_H
#define TCLAP_VERSION_VISITOR_H

#include <tclap/CmdLineInterface.h>
#include <tclap/CmdLineOutput.h>
#include <tclap/Visitor.h>

namespace TCLAP {

/**
 * A Visitor that will call the version method of the given CmdLineOutput
 * for the specified CmdLine object and then exit.
 */
class VersionVisitor : public Visitor {
private:
    /**
     * Prevent accidental copying
     */
    VersionVisitor(const VersionVisitor &rhs);
    VersionVisitor &operator=(const VersionVisitor &rhs);

protected:
    /**
     * The CmdLine of interest.
     */
    CmdLineInterface *_cmd;

    /**
     * The output object.
     */
    CmdLineOutput **_out;

public:
    /**
     * Constructor.
     * \param cmd - The CmdLine the output is generated for.
     * \param out - The type of output.
     */
    VersionVisitor(CmdLineInterface *cmd, CmdLineOutput **out)
        : Visitor(), _cmd(cmd), _out(out) {}

    /**
     * Calls the version method of the output object using the
     * specified CmdLine.
     */
    void visit() {
        (*_out)->version(*_cmd);
        throw ExitException(0);
    }
};
}  // namespace TCLAP

#endif  // TCLAP_VERSION_VISITOR_H


================================================
FILE: lib/tclap/Visitor.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  Visitor.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_VISITOR_H
#define TCLAP_VISITOR_H

namespace TCLAP {

/**
 * A base class that defines the interface for visitors.
 */
class Visitor {
public:
    /**
     * Constructor. Does nothing.
     */
    Visitor() {}

    /**
     * Destructor. Does nothing.
     */
    virtual ~Visitor() {}

    /**
     * This method (to implemented by children) will be
     * called when the visitor is visited.
     */
    virtual void visit() = 0;
};
}  // namespace TCLAP

#endif  // TCLAP_VISITOR_H


================================================
FILE: lib/tclap/sstream.h
================================================
// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-

/******************************************************************************
 *
 *  file:  sstream.h
 *
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno .
 *  Copyright (c) 2017 Google Inc.
 *  All rights reserved.
 *
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/

#ifndef TCLAP_SSTREAM_H
#define TCLAP_SSTREAM_H

#if !defined(TCLAP_HAVE_STRSTREAM)
// Assume sstream is available if strstream is not specified
// (https://sourceforge.net/p/tclap/bugs/23/)
#define TCLAP_HAVE_SSTREAM
#endif

#if defined(TCLAP_HAVE_SSTREAM)
#include <sstream>
namespace TCLAP {
typedef std::istringstream istringstream;
typedef std::ostringstream ostringstream;
}  // namespace TCLAP
#elif defined(TCLAP_HAVE_STRSTREAM)
#include <strstream>
namespace TCLAP {
typedef std::istrstream istringstream;
typedef std::ostrstream ostringstream;
}  // namespace TCLAP
#else
#error "Need a stringstream (sstream or strstream) to compile!"
#endif

#endif  // TCLAP_SSTREAM_H


================================================
FILE: lib/tclap/tclap.cmake
================================================
include(CheckCXXSourceCompiles)

add_definitions(-DTCLAP_VERSION_MAJOR=1 -DTCLAP_VERSION_MINOR=4)

check_cxx_source_compiles("#include <strstream>
int main() { std::istrstream iss; return 0; }" TCLAP_HAVE_STRSTREAM)
if(TCLAP_HAVE_STRSTREAM)
    message("-- found TCLAP_HAVE_STRSTREAM")
    add_definitions(-DTCLAP_HAVE_STRSTREAM)
endif()

#check_cxx_source_compiles("#include <sstream>
#int main() { std::istringstream iss; return 0; }" TCLAP_HAVE_SSTREAM)
#if(TCLAP_HAVE_SSTREAM)
#    message("-- found TCLAP_HAVE_SSTREAM")
#    add_definitions(-DTCLAP_HAVE_SSTREAM)
#endif()
#

================================================
FILE: lib/util.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */


#include "util.h"
#include <Utils/files.h>
#include <Utils/strings.h>
#include <algorithm>
#include <cstdlib>
#include <array>

#include "sdl_proxy/sdl_stdinc.h"

#ifdef _WIN32
#include <windows.h>
#endif

static const std::array<unsigned char, 65> base64_chars{
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
        "0123456789+/"};

static inline bool is_base64(unsigned char c)
{
    return (isalnum(c) || (c == '+') || (c == '/'));
}

std::string util::filePath(const std::string &s)
{
    std::string t = s;
    std::replace(t.begin(), t.end(), '\\', '_');
    std::replace(t.begin(), t.end(), '/', '_');
    std::replace(t.begin(), t.end(), ':', '_');
    std::replace(t.begin(), t.end(), '*', '_');
    std::replace(t.begin(), t.end(), '?', '_');
    std::replace(t.begin(), t.end(), '\"', '_');
    std::replace(t.begin(), t.end(), '<', '_');
    std::replace(t.begin(), t.end(), '>', '_');
    std::replace(t.begin(), t.end(), '|', '_');
    return t;
}

bool util::strempty(const char *str)
{
    if(str)
    {
        if(SDL_strlen(str))
            return true;
    }

    return false;
}

std::string util::resolveRelativeOrAbsolute(const std::string &path, const std::vector<std::string> &relativeLookup)
{
    if(path.empty())
        return "";
    if(path[0] == ':')
        return path;

    if(Files::isAbsolute(path))
    {
        if(Files::fileExists(path))
            return path;
    }
    else
    {
        for(const std::string &nextpath : relativeLookup)
        {
            std::string newCompletePath = nextpath + "/" + path;
            if(Files::fileExists(newCompletePath))
                return newCompletePath;
        }
    }

    return "";
}

template<class TList>
inline void CSV2IntArr_CODE(const std::string &source, TList &dest, const typename TList::value_type &def)
{
    typedef typename TList::value_type T;

    if(!source.empty())
    {
        Strings::List tmlL;
        Strings::split(tmlL, source, ',');

        for(std::string &fr : tmlL)
        {
            try
            {
                if(std::is_same<T, int>::value)
                    dest.push_back(std::atoi(fr.c_str()));
                else
                    dest.push_back(int(std::strtod(fr.c_str(), nullptr)));
            }
            catch(...)
            {
                continue;
            }
            dest.pop_back();
        }

        if(dest.empty()) dest.push_back(def);
    }
    else
        dest.push_back(def);
}

void util::CSV2IntArr(const std::string &source, std::vector<int> &dest)
{
    CSV2IntArr_CODE(source, dest, 0);
}

void util::CSV2DoubleArr(const std::string &source, std::vector<double> &dest)
{
    CSV2IntArr_CODE(source, dest, 0.0);
}

void util::base64_encode(std::string &ret, const unsigned char *bytes_to_encode, size_t in_len)
{
    int i = 0;
    int j = 0;
    unsigned char char_array_3[3];
    unsigned char char_array_4[4];

    while(in_len--)
    {
        char_array_3[i++] = *(bytes_to_encode++);

        if(i == 3)
        {
            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = static_cast<unsigned char>(
                                  (static_cast<unsigned int>(char_array_3[0] & 0x03) << 4) +
                                  (static_cast<unsigned int>(char_array_3[1] & 0xf0) >> 4)
                              );
            char_array_4[2] = static_cast<unsigned char>(
                                  (static_cast<unsigned int>(char_array_3[1] & 0x0f) << 2) +
                                  (static_cast<unsigned int>(char_array_3[2] & 0xc0) >> 6)
                              );
            char_array_4[3] = char_array_3[2] & 0x3f;

            for(i = 0; (i < 4) ; i++)
                ret += static_cast<char>(base64_chars[char_array_4[i]]);

            i = 0;
        }
    }

    if(i)
    {
        for(j = i; j < 3; j++)
            char_array_3[j] = '\0';

        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = static_cast<unsigned char>(
                              (static_cast<unsigned int>(char_array_3[0] & 0x03) << 4) +
                              (static_cast<unsigned int>(char_array_3[1] & 0xf0) >> 4)
                          );
        char_array_4[2] = static_cast<unsigned char>(
                              (static_cast<unsigned int>(char_array_3[1] & 0x0f) << 2) +
                              (static_cast<unsigned int>(char_array_3[2] & 0xc0) >> 6)
                          );
        char_array_4[3] = char_array_3[2] & 0x3f;

        for(j = 0; (j < i + 1); j++)
            ret += static_cast<char>(base64_chars[char_array_4[j]]);

        while((i++ < 3))
            ret += '=';
    }
}

void util::base64_decode(std::string &ret, const std::string &encoded_string)
{
    size_t in_len = encoded_string.size();
    int i = 0;
    int j = 0;
    size_t in_ = 0;
    unsigned char char_array_4[4], char_array_3[3];

    while(in_len-- && (encoded_string[in_] != '=') && is_base64(static_cast<unsigned char>(encoded_string[in_])))
    {
        char_array_4[i++] = static_cast<unsigned char>(encoded_string[in_]);
        in_++;

        if(i == 4)
        {
            for(i = 0; i < 4; i++)
                char_array_4[i] = static_cast<unsigned char>(std::find(base64_chars.begin(), base64_chars.end(), char_array_4[i]) - base64_chars.begin());

            char_array_3[0] = static_cast<unsigned char>(
                                  static_cast<unsigned int>(char_array_4[0] << 2) +
                                  static_cast<unsigned int>((char_array_4[1] & 0x30) >> 4)
                              );
            char_array_3[1] = static_cast<unsigned char>(
                                  static_cast<unsigned int>((char_array_4[1] & 0xf) << 4) +
                                  static_cast<unsigned int>((char_array_4[2] & 0x3c) >> 2)
                              );
            char_array_3[2] = static_cast<unsigned char>(
                                  static_cast<unsigned int>((char_array_4[2] & 0x3) << 6) +
                                  static_cast<unsigned int>(char_array_4[3])
                              );

            for(i = 0; (i < 3); i++)
                ret += static_cast<char>(char_array_3[i]);

            i = 0;
        }
    }

    if(i)
    {
        for(j = i; j < 4; j++)
            char_array_4[j] = 0;

        for(j = 0; j < 4; j++)
            char_array_4[j] = static_cast<unsigned char>(std::find(base64_chars.begin(), base64_chars.end(), char_array_4[j]) - base64_chars.begin());

        char_array_3[0] = static_cast<unsigned char>(
                              static_cast<unsigned int>(char_array_4[0] << 2) +
                              static_cast<unsigned int>((char_array_4[1] & 0x30) >> 4)
                          );
        char_array_3[1] = static_cast<unsigned char>(
                              static_cast<unsigned int>((char_array_4[1] & 0xf) << 4) +
                              static_cast<unsigned int>((char_array_4[2] & 0x3c) >> 2)
                          );
        char_array_3[2] = static_cast<unsigned char>(
                              static_cast<unsigned int>((char_array_4[2] & 0x3) << 6) +
                              static_cast<unsigned int>(char_array_4[3])
                          );

        for(j = 0; (j < i - 1); j++)
            ret += static_cast<char>(char_array_3[j]);
    }

    //Remove zero from end
    if(ret.size() > 0)
    {
        if(ret[ret.size() - 1] == '\0')
            ret.resize(ret.size() - 1);
    }
}



size_t charsets_utils::utf8len(const char *s)
{
    size_t len = 0;

    while(*s)
        len += (*(s++) & 0xC0) != 0x80;

    return len;
}


int charsets_utils::UTF8Str_To_WStr(std::wstring &dest, const std::string &source)
{
#ifdef _WIN32
    dest.resize(source.length());
    int newSize = MultiByteToWideChar(CP_UTF8, 0, source.c_str(), (int)source.length(), (wchar_t *)dest.c_str(), (int)source.length());
    dest.resize(newSize);
    return newSize;
#else
    (void)dest;
    (void)source;
    return static_cast<int>(utf8len(source.c_str()));
#endif
}

int charsets_utils::WStr_To_UTF8Str(std::string &dest, const std::wstring &source)
{
#ifdef _WIN32
    int dest_len = (int)source.length() * 4;
    dest.resize(dest_len);
    dest_len = WideCharToMultiByte(CP_UTF8, 0, source.c_str(), (int)source.length(), (LPSTR)dest.c_str(), dest_len, NULL, NULL);
    dest.resize(dest_len);
    return dest_len;
#else
    (void)dest;
    (void)source;
    return static_cast<int>(source.size());
#endif
}


================================================
FILE: lib/util.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */


#ifndef UTIL_H
#define UTIL_H

#include <string>
#include <vector>

//#include <luabind/luabind.hpp>
//#include <lua_includes/lua.hpp>

#ifdef Q_CC_GNU
#define gcc_force_inline __attribute__((always_inline, gnu_inline))
#else
#define gcc_force_inline
#endif

namespace util
{
std::string filePath(const std::string &s);
bool strempty(const char *str);

std::string resolveRelativeOrAbsolute(const std::string &path, const std::vector<std::string> &relativeLookup);

void CSV2IntArr(const std::string &source, std::vector<int> &dest);
void CSV2DoubleArr(const std::string &source, std::vector<double> &dest);
void base64_encode(std::string &ret, const unsigned char *bytes_to_encode, size_t in_len);
void base64_decode(std::string &ret, std::string const &encoded_string);

template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
void clear_mem(std::vector<_Tp, _Alloc> &v)
{
    std::vector<_Tp, _Alloc> blank;
    std::swap(v, blank);
}

inline void clear_mem(std::string &v)
{
    std::string blank;
    std::swap(v, blank);
}

inline void clear_mem(std::wstring &v)
{
    std::wstring blank;
    std::swap(v, blank);
}

} // util

namespace varadic_util
{

template<int ...>
struct seq { };

template<int N, int ...S>
struct gens : gens < N - 1, N - 1, S... > { };

template<int ...S>
struct gens<0, S...>
{
    typedef seq<S...> type;
};

} // varadic_util



//namespace luabind_utils
//{
//template<typename T>
//static inline gcc_force_inline std::vector<T> convArrayTo(luabind::object &obj)
//{
//    std::vector<T> container;
//    for(luabind::iterator it(obj), end; it != end; ++it)
//    {
//        try
//        {
//            container.push_back(luabind::object_cast<T>(*it));
//        }
//        catch(luabind::cast_failed & /*e*/) { }
//    }
//    return container;
//}
//}

namespace charsets_utils
{
/*!
 * \brief returns length of UTF8 string line
 * \param Input 8-bit string in UTF8 codepage
 * \return number of characters (not a bytes!)
 */
size_t utf8len(const char *s);
int UTF8Str_To_WStr(std::wstring &dest, const std::string  &source);
int WStr_To_UTF8Str(std::string  &dest, const std::wstring &source);

} // charsets_utils

#endif // UTIL_H


================================================
FILE: pge_version.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */


#ifndef GLOBAL_PGE_VERSION
#define GLOBAL_PGE_VERSION

#ifdef PGE_TOOLCHAIN_VERSION_1
#   define V_VP1 PGE_TOOLCHAIN_VERSION_1
#else
#   define V_VP1 0
#endif

#ifdef PGE_TOOLCHAIN_VERSION_2
#   define V_VP2 PGE_TOOLCHAIN_VERSION_2
#else
#   define V_VP2 0
#endif

#ifdef PGE_TOOLCHAIN_VERSION_3
#   define V_VP3 PGE_TOOLCHAIN_VERSION_3
#else
#   define V_VP3 0
#endif

#ifdef PGE_TOOLCHAIN_VERSION_4
#   define V_VP4 PGE_TOOLCHAIN_VERSION_4
#else
#   define V_VP4 0
#endif

#ifdef PGE_CONFIG_PACK_API_VERSION
#   define V_CP_API PGE_CONFIG_PACK_API_VERSION
#else
#   define V_CP_API 0
#endif

#ifdef PGE_TOOLCHAIN_VERSION_REL
#   define V_TOOLCHAIN_RELEASE PGE_TOOLCHAIN_VERSION_REL
#else
#   define V_TOOLCHAIN_RELEASE "-unk" //"-alpha","-beta","-dev", or "" aka "release"
#endif

#define GEN_VERSION_NUMBER_2(v1,v2)     v1 "." v2
#define GEN_VERSION_NUMBER_3(v1,v2,v3)  v1 "." v2 "." v3
#define GEN_VERSION_NUMBER_4(v1,v2,v3,v4)  v1 "." v2 "." v3 "." v4

#define STR_VALUE_REAL(arg)  #arg
#define STR_VALUE(verf)      STR_VALUE_REAL(verf)
#define V_VP1_s STR_VALUE(V_VP1)
#define V_VP2_s STR_VALUE(V_VP2)
#define V_VP3_s STR_VALUE(V_VP3)
#define V_VP4_s STR_VALUE(V_VP4)
#if V_VP4 == 0
#   if V_VP3 == 0
#       define V_PROJECT_VERSION_NUM GEN_VERSION_NUMBER_2(V_VP1_s, V_VP2_s)
#   else
#       define V_PROJECT_VERSION_NUM GEN_VERSION_NUMBER_3(V_VP1_s, V_VP2_s, V_VP3_s)
#   endif
#else
#   define V_PROJECT_VERSION_NUM GEN_VERSION_NUMBER_4(V_VP1_s, V_VP2_s, V_VP3_s, V_VP4_s)
#endif



// --------------- Version of whole project ---------------

#define V_VERSION V_PROJECT_VERSION_NUM
#define V_RELEASE "" //Developing state (for release this field must be empty)

#define V_COPYRIGHT "2020-2026 by Wohlstand"

#define V_COMPANY "Moondust Team"

#define V_PGE_URL "wohlsoft.ru"

#define V_PRODUCT_NAME "Moondust"



// --------------- OPERATING SYSTEM ---------------

#if defined(_WIN64)
#   if defined(_M_ARM64)
#       define OPERATION_SYSTEM "Windows ARM64"
#   else
#       define OPERATION_SYSTEM "Windows x64"
#   endif
#elif defined(_WIN32)
#   define OPERATION_SYSTEM "Windows"
#elif defined __APPLE__
#   include <TargetConditionals.h>
#   if TARGET_IPHONE_SIMULATOR
#       define OPERATION_SYSTEM "iOS Simulator"
#   elif TARGET_OS_IPHONE
#       define OPERATION_SYSTEM "iOS"
#   else
#       define OPERATION_SYSTEM "macOS"
#   endif
#elif defined __FreeBSD__
#   define OPERATION_SYSTEM "FreeBSD"
#elif defined __gnu_linux__
#   define OPERATION_SYSTEM "GNU/Linux"
#elif defined __HAIKU__
#   define OPERATION_SYSTEM "Haiku"
#elif defined __EMSCRIPTEN__
#   define OPERATION_SYSTEM "Emscripten"
#elif defined(__ANDROID__)
#   define OPERATION_SYSTEM "Android"
#elif defined __WII__
#   define OPERATION_SYSTEM "Wii System"
#elif defined __16M__
#   define OPERATION_SYSTEM "DSi System"
#elif defined __3DS__
#   define OPERATION_SYSTEM "3DS System"
#elif defined __SWITCH__
#   define OPERATION_SYSTEM "Nintendo Switch"
#elif defined __vita__
#   define OPERATION_SYSTEM "Live Area (PS Vita)"
#else
#   define OPERATION_SYSTEM "Other"
#endif




// --------------- Processor Architecture ---------------

#if defined(_X86_) || defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) || defined(_M_IX86)
#   define FILE_CPU "x86 (32-bit)"
#elif defined(__x86_64__) || defined(__amd64__) || defined(_WIN64) || defined(_M_X64) || defined(_M_AMD64)
#   define FILE_CPU "x86_64 (64-bit)"
#elif defined(__arm__) || defined(__TARGET_ARCH_ARM) || defined(__ARM_ARCH)
#   if defined(__ARM_ARCH_8__) \
     || defined(__ARM_ARCH_8A) \
     || defined(__ARM_ARCH_8A__) \
     || defined(__ARM_ARCH_8R__) \
     || defined(__ARM_ARCH_8M__) \
     || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 8) \
     || (defined(__ARM_ARCH) && __ARM_ARCH >= 8) || defined(_M_ARM64) || defined(_M_ARM64EC)
#       define FILE_CPU "ARM64 (64-bit)"
#   elif defined(__ARM_ARCH_7__) \
       || defined(__ARM_ARCH_7A__) \
       || defined(__ARM_ARCH_7R__) \
       || defined(__ARM_ARCH_7M__) \
       || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 7) \
       || (defined(__ARM_ARCH) && __ARM_ARCH >= 7)
#       define FILE_CPU "ARMv7 (32-bit)"
#   elif defined(__ARM_ARCH_6__) \
       || defined(__ARM_ARCH_6J__) \
       || defined(__ARM_ARCH_6T2__) \
       || defined(__ARM_ARCH_6Z__) \
       || defined(__ARM_ARCH_6K__) \
       || defined(__ARM_ARCH_6ZK__) \
       || defined(__ARM_ARCH_6M__) \
       || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 6) \
       || (defined(__ARM_ARCH) && __ARM_ARCH >= 6)
#       define FILE_CPU "ARMv6 (32-bit)"
#   elif defined(__ARM_ARCH_5TEJ__) \
      || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 5)
#       define FILE_CPU "ARMv5 (32-bit)"
#   else
#       define FILE_CPU "ARM (Unknown)"
#   endif
#elif defined(__mips__) || defined(__mips) || defined(__MIPS__)
#   define FILE_CPU "MIPS"
#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) \
   || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \
   || defined(_M_MPPC) || defined(_M_PPC)
#   if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
#       define FILE_CPU "PowerPC (64-bit)"
#   else
#       define FILE_CPU "PowerPC (32-bit)"
#   endif
#elif defined(__riscv) // FIXME: Adjust if any extra macros needed
#   if __riscv_xlen == 64
#       define FILE_CPU "RISC-V (64-bit)"
#   elif __riscv_xlen == 32
#       define FILE_CPU "RISC-V (32-bit)"
#   endif
#elif defined(__loongarch64)
#       define FILE_CPU "LoongArch (64-bit)"
#elif defined(__loongarch)
#       define FILE_CPU "LoongArch (32-bit)"
#else
#   define FILE_CPU "unknown"
#endif



// --------------- Date and time of the build ---------------
#ifndef DISABLE_XTECH_BUILD_DATE
#   define V_DATE_OF_BUILD __DATE__ " " __TIME__
#else
#   define V_DATE_OF_BUILD "<Build timestamp disabled>"
#endif



#endif // GLOBAL_PGE_VERSION


================================================
FILE: repo.sh
================================================
#!/bin/bash

bak=~+

function checkState()
{
    if [[ $? -eq 0 ]]
    then
        printf "=== \E[37;42mOK!\E[0m ===\n\n"
    else
        printf "\n=== AN ERROR OCCURRED! ===\n\n"
        cd ${bak}
        exit 1
    fi
}

flag_pack_src=false
flag_pack_src_gz=false
flag_pack_src_zip=false


for var in "$@"
do
    case "$var" in
        lupdate)
            #dummy
        ;;
        lrelease)
            #dummy
        ;;
        --help)
            echo ""
            printf "=== \e[44mRepo maintenance helper script for TheXTech\e[0m ===\n"
            echo ""
            echo "--- Actions ---"
            printf " \E[1;4mupdate-submodules\E[0m- Pull all submodules up to their latest states\n"
            printf " \E[1;4mrepair-submodules\E[0m- Repair invalid or broken submodules\n"
            printf " \E[1;4m--help\E[0m           - Print this manual\n"
            printf " \E[1;4mpack-src\E[0m         - Create the source code archive\n"
            printf "                    (git-archive-all is required!)\n"
            if [[ "$(which git-archive-all)" == "" ]]; then
                printf " \E[0;4;41;37m<git-archive-all is not installed!>\E[0m\n"
            fi
            echo ""
            exit 1
            ;;

        update-submodules)
            PATH=${PATH}:$PWD/utils
            git submodule foreach submodule-update.sh "$PWD/.gitmodules"

            # EXTRA update Java files of Android project
            printf "\n\n"
            echo "Synchronize SDL Java headers..."
            rm -vf android-project/thextech/src/main/java/org/libsdl/app/*.java
            cp -v 3rdparty/AudioCodecs/SDL2/android-java-files/*.java android-project/thextech/src/main/java/org/libsdl/app
            exit 0
            ;;

        repair-submodules)
            PATH=${PATH}:$PWD/utils
            echo "=== Cleaning-up old state..."
            git submodule foreach 'pwd; rm -Rf * .git*;'
            echo "=== Fetching new submodules..."
            git submodule init
            git submodule update
            echo ""
            git submodule foreach submodule-update.sh "$PWD/.gitmodules"
            echo ""
            echo "==== Fixed! ===="
            exit 0;
            ;;

        pack-src)
            flag_pack_src=true
            ;;
        gz)
            flag_pack_src_gz=true
            ;;
        zip)
            flag_pack_src_zip=true
            ;;

        *)
            echo "--------------------------------------------------------------------"
            echo "Invalid argument '$var', please type '$0 --help' to get the usage."
            echo "--------------------------------------------------------------------"
            exit 1;
        ;;
    esac
done

# ===== Source code packer =====
if ${flag_pack_src} ; then
    if [[ ! -d build-archives ]]; then
        mkdir build-archives
    fi
    if ${flag_pack_src_gz} ; then
        ARFORMAT=tar.gz
    elif ${flag_pack_src_zip} ; then
        ARFORMAT=zip
    else
        ARFORMAT=tar.bz2
    fi

    echo "Packing source code..."
    git archive-all -v --force-submodules build-archives/thextech-full-src.${ARFORMAT}
    checkState

    printf "\n=== Packed! ===\n\n"
    cd ${bak}

    exit 0;
fi


================================================
FILE: resources/PkgInfo
================================================
APPLTXTH

================================================
FILE: resources/_dev_scripts/snd_id_2_enum.sh
================================================
#!/bin/bash

ARR="SFX_Jump SFX_Stomp SFX_BlockHit SFX_BlockSmashed SFX_PlayerShrink SFX_PlayerGrow SFX_Mushroom SFX_PlayerDied SFX_ShellHit SFX_Skid SFX_DropItem SFX_GotItem SFX_Camera SFX_Coin SFX_1up SFX_Lava SFX_Warp SFX_Fireball SFX_CardRouletteClear SFX_BossBeat SFX_DungeonClear SFX_Bullet SFX_Grab SFX_Spring SFX_HammerToss SFX_Slide SFX_NewPath SFX_LevelSelect SFX_Do SFX_Pause SFX_Key SFX_PSwitch SFX_Tail SFX_Raccoon SFX_Boot SFX_Smash SFX_Twomp SFX_BirdoSpit SFX_BirdoHit SFX_CrystalBallExit SFX_BirdoBeat SFX_BigFireball SFX_Fireworks SFX_BowserKilled SFX_GameBeat SFX_Door SFX_Message SFX_Yoshi SFX_YoshiHurt SFX_YoshiTongue SFX_YoshiEgg SFX_GotStar SFX_ZeldaKill SFX_PlayerDied2 SFX_YoshiSwallow SFX_SonicRing SFX_DryBones SFX_Checkpoint SFX_DraginCoin SFX_TapeExit SFX_Blaarg SFX_WartBubbles SFX_WartKilled SFX_SMBlockHit SFX_SMKilled SFX_SMHurt SFX_SMGlass SFX_SMBossHit SFX_SMCry SFX_SMExplosion SFX_Climbing SFX_Swim SFX_Grab2 SFX_Saw SFX_Throw SFX_PlayerHit SFX_ZeldaStab SFX_ZeldaHurt SFX_ZeldaHeart SFX_ZeldaDied SFX_ZeldaRupee SFX_ZeldaFire SFX_ZeldaItem SFX_ZeldaKey SFX_ZeldaShield SFX_ZeldaDash SFX_ZeldaFairy SFX_ZeldaGrass SFX_ZeldaHit SFX_ZeldaSwordBeam SFX_Bubble SFX_PSwitchTimeout SFX_SwooperFlap SFX_Iceball SFX_Freeze SFX_Icebreak SFX_PlayerHammer SFX_SproutVine"

count=1
for q in $ARR; do
    echo "$q - $count"
    find . -type f -name "*.cpp" -exec ./snd_id_sed.sh {} $count $q \;
    count=$((count + 1))
done


================================================
FILE: resources/_dev_scripts/snd_id_sed.sh
================================================
#!/bin/bash
echo "$1 ($2 -> $3)"
sed -i "s/PlaySound($2)/PlaySound($3)/g" $1


================================================
FILE: resources/_dev_scripts/xserver.py
================================================
#!/usr/bin/python3

# Copyright (C) 2025 ds-sloth
#
# 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 3 of the License, or
# 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, see <http://www.gnu.org/licenses/>.

import selectors
import socket
import time
import heapq
import threading
import random
import os

# roughly, an enum of header bytes for events (*control channel*)
# HEADER_CLIENT_JOIN = 1
# HEADER_CLIENT_LOSS = 2
# HEADER_TEXT_EVENT = 3
HEADER_FRAME_COMPLETE = 4
# HEADER_YOU_ARE = 5
# HEADER_RAND_SEED = 6
# HEADER_TIME_IS = 7
HEADER_LEFT_ROOM = 8

HEADER_ROOM_KEY = 9
HEADER_ROOM_INFO = 10

HEADER_CREATE_ROOM = 11
HEADER_JOIN_ROOM = 12

HEADER_DATA_CHANNEL = 13
HEADER_ACK = 14

HEADER_PUT_SESSION = 15
HEADER_GET_SESSION = 16

# an enum of header bytes for messages (*data channel*)
MESSAGE_FRAME_BEGIN = 32 # meta-message: the following messages belong to the named frame
MESSAGE_ADD_CLIENT = 33
MESSAGE_DROP_CLIENT = 34
MESSAGE_FRAME_END = 35 # meta-message (TCP only): the previously named frame is now complete
MESSAGE_TRANSMIT_START = 36 # meta-message (UDP only): transmission is only valid if this frame has passed, generally acknowledges receipt of messages up to the named frame

def display_room_key(room_key):
    if len(room_key) != 4:
        return ''

    room_key_int = (room_key[0] << 24) + (room_key[1] << 16) + (room_key[2] << 8) + (room_key[3] << 0)

    if (room_key_int & (192 << 24)):
        return ''

    chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ346789'

    letters = ''.join([chars[(room_key_int >> off) % 32] for off in (25, 20, 15, 10, 5, 0)])
    return letters[:3] + '-' + letters[3:]

class Connection:
    def __init__(self, server, conn, address):
        self.server = server
        self.conn = conn
        self.data_conn = None
        self.address = address

        self.session_key = b'\0\0\0\0'

        # session config state
        self.providing_session = False
        self.receiving_session = False
        self.session_received = 0

        # room state
        self.room = None
        self.id = 0
        self.acked_to = 0
        self.acked_frame = -1
        self.double_acked_frame = -60
        self.warned_frame = 0

        self.tcp_send_start = 0
        self.tcp_send_end = 0
        self.tcp_sent_frame = -1

        self.tcp_frame_in_progress = []
        self.tcp_frame_no = -1

        # UDP state
        self.udp_dest = None
        self.udp_recv = []
        self.udp_send = b''

    def set_room(self, room, id):
        self.providing_session = False
        self.receiving_session = False
        self.session_received = 0

        self.room = room
        self.id = id
        self.acked_to = -1
        self.acked_frame = -1
        self.double_acked_frame = -60
        self.warned_frame = 0

        self.tcp_send_start = 0
        self.tcp_send_end = 0
        self.tcp_sent_frame = -1

    def read_in_room(self):
        # special case for when uploading a session object
        if self.providing_session:
            try:
                self.room.session_config += self.conn.recv(self.room.session_config_length - len(self.room.session_config))
            except BlockingIOError:
                pass

            if len(self.room.session_config) < self.room.session_config_length:
                return

            # acknowledge receipt of session config
            self.conn.sendall(bytes([HEADER_GET_SESSION]))
            self.receiving_session = False

        # conn is the socket object
        try:
            header = self.conn.recv(1)
        except BlockingIOError:
            return

        if len(header) != 1:
            self.room.kill(self)
            return

        if header[0] == HEADER_PUT_SESSION:
            session_config_length = self.conn.recv(4)
            if len(session_config_length) != 4 or self.room.session_config_length != 0:
                self.room.kill(self)
                return

            self.providing_session = True
            self.room.session_config_length = (session_config_length[0] << 24) + (session_config_length[1] << 16) + (session_config_length[2] << 8) + (session_config_length[3] << 0)
            return self.read_in_room()

        if header[0] == HEADER_GET_SESSION:
            self.receiving_session = True
            self.session_received = -1
            return

        try:
            header += self.conn.recv(3)
        except BlockingIOError:
            pass
        if len(header) != 4:
            self.room.kill(self)
            return

        if header == b'\0\0\0\0':
            self.room.unregister(self)

            self.room = None
            self.server.register(self)

            self.conn.sendall(bytes([HEADER_LEFT_ROOM]))
            self.data_conn.close()
            self.data_conn = None

            return

    def read_data(self):
        # conn is the socket object
        while True:
            try:
                message = self.data_conn.recv(4)
            except BlockingIOError:
                break

            if len(message) != 4:
                self.room.kill(self)
                return

            if message[0] == MESSAGE_FRAME_BEGIN or message[0] == MESSAGE_FRAME_END:
                if self.tcp_frame_no > self.acked_frame:
                    self.acked_frame = self.tcp_frame_no

                    for msg in self.tcp_frame_in_progress:
                        self.room.enqueue_text_event(self.tcp_frame_no, self.id, msg)
                        print("Got 1 new event from TCP")

                    self.tcp_frame_in_progress = []

                self.tcp_frame_no = -1

            frame_no = message[1] * 256 * 256 + message[2] * 256 + message[3]
            if message[0] == MESSAGE_FRAME_BEGIN:
                self.tcp_frame_no = frame_no
                if frame_no - 1 > self.acked_frame:
                    self.acked_frame = frame_no - 1
                else:
                    if frame_no > self.acked_frame:
                        self.acked_frame = frame_no
            elif self.tcp_frame_no > self.acked_frame:
                self.tcp_frame_in_progress.append(message)

    def read_data_udp(self, msg):
        if len(msg) % 4 != 0:
            self.room.kill(self)
            return

        udp_frame_index = -1
        for i in range(0, len(msg), 4):
            message = msg[i : i + 4]

            if message[0] == MESSAGE_FRAME_BEGIN or message[0] == MESSAGE_FRAME_END:
                udp_frame_index = message[1] * 256 * 256 + message[2] * 256 + message[3]
                if message[0] == MESSAGE_FRAME_END and udp_frame_index > self.acked_frame:
                    self.acked_frame = udp_frame_index
                elif udp_frame_index - 1 > self.acked_frame:
                    self.acked_frame = udp_frame_index - 1
            else:
                if udp_frame_index > self.acked_frame:
                    self.room.enqueue_text_event(udp_frame_index, self.id, message)
                    print("Got 1 new event from UDP")

    def set_data_conn(self, data_conn):
        if self.data_conn:
            return

        self.data_conn = data_conn
        if self.room:
            self.room.selector.register(self.data_conn, selectors.EVENT_READ, self.read_data)

    def read_in_lobby(self):
        header = self.conn.recv(1)
        if len(header) != 1:
            self.server.kill(self)
            return

        if header[0] == HEADER_ROOM_INFO:
            room_key = self.conn.recv(4)
            if len(room_key) != 4:
                self.server.kill(self)
                return

            room = self.server.load_room(room_key)
            if not room or room.room_key != room_key:
                self.conn.sendall(bytes([HEADER_ROOM_INFO]) + room_key + b'\0\0\0\0\0\0\0\0\0\0\0\0')
                return

            self.conn.sendall(bytes([HEADER_ROOM_INFO]) + room.room_key + room.room_info)
        elif header[0] == HEADER_JOIN_ROOM:
            room_key = self.conn.recv(4)
            if len(room_key) != 4:
                self.server.kill(self)
                return

            room = self.server.load_room(room_key)
            if not room:
                self.conn.sendall(bytes([HEADER_ROOM_KEY]) + b'\0' * 12)
                return

            self.server.unregister(self)
            room.add(self)
        elif header[0] == HEADER_CREATE_ROOM:
            room_info = self.conn.recv(12)

            room = self.server.create_room(room_info)
            if not room:
                self.conn.sendall(bytes([HEADER_ROOM_KEY]) + b'\0' * 12)
                return

            self.server.unregister(self)
            room.add(self)
        elif header[0] == HEADER_DATA_CHANNEL:
            # unregister as a normal client
            self.server.unregister(self)
            self.server.unregister_session(self.session_key)
            self.session_key = b'\0\0\0\0'

            # transfer the conn to the correct client (if it exists)
            session_key = self.conn.recv(4)
            main_client = self.server.find_session(session_key)
            if main_client:
                main_client.set_data_conn(self.conn)

            self.conn = None

    def read(self):
        if self.room is not None:
            self.read_in_room()
            return

        self.read_in_lobby()

class Room:
    def __init__(self, server, room_key):
        # reference to the main server
        self.server = server
        self.frame_length = self.server.frame_length

        # this object will tell us when any network events have occurred for this room's clients
        self.selector = selectors.DefaultSelector()

        # room information
        self.room_key = room_key
        assert(len(room_key) == 4)

        self.room_info = b'\0\0\0\0\0\0\0\0\0\0\0\0'

        # room state
        self.frame_no = 0
        self.session_config_length = 0
        self.session_config = bytes()
        self.sent_history = bytes()

        # this is a list of clients added by the main thread
        self.added_clients = []
        self.kill_timer = 0
        self.killed = False
        self.kill_lock = threading.Lock()

        # this is a list of clients
        self.clients = []
        self.freed_clients = set()
        self.newly_freed_clients = set()

        # this is the current frame, and a queue of events
        self.event_queue = []

    def enqueue_text_event(self, frame_no, id, event_text):
        # force event to happen in future (if client has lag)
        if frame_no < self.frame_no:
            frame_no = self.frame_no

        # encode event
        if len(event_text) != 4:
            print(f"Warning: invalid event length {len(event_text)}, 4 expected.")
            return
        if event_text[1] != id:
            # figure this out...
            print(f"Warning: invalid event client ID {event_text[1]}, {id} expected.")
            return

        # add to queue
        heapq.heappush(self.event_queue, (frame_no, event_text))

    def unregister(self, client):
        # free client's network state
        try:
            self.selector.unregister(client.conn)
        except KeyError:
            pass
        except ValueError:
            pass

        try:
            self.selector.unregister(client.data_conn)
        except KeyError:
            pass
        except ValueError:
            pass

        # get client's ID
        dead_id = client.id

        # if the client is not in the correct location in the client list, return
        if not self.clients[dead_id] is client:
            return

        # create loss event and add to queue
        serialized_event = bytes([MESSAGE_DROP_CLIENT, 255, 0, dead_id])
        heapq.heappush(self.event_queue, (self.frame_no, serialized_event))

        # remove reference to this client
        self.clients[dead_id] = None

        # mark client as newly dead (can't re-use ID this frame)
        self.newly_freed_clients.add(dead_id)

    def kill(self, client):
        self.unregister(client)
        client.conn.close()
        if client.data_conn:
            client.data_conn.close()

        if client.providing_session and len(self.session_config) < self.session_config_length:
            self.session_config = bytes()
            self.session_config_length = 0

    def add(self, client):
        # find an ID and slot for the client
        if self.freed_clients:
            new_id = min(self.freed_clients)
            self.freed_clients.discard(new_id)
        else:
            new_id = len(self.clients)
            self.clients.append(None)

        # add the client to the room
        client.set_room(self, new_id)
        self.clients[new_id] = client

        # create join event and add to queue
        serialized_event = bytes([MESSAGE_ADD_CLIENT, 255, 0, new_id])
        heapq.heappush(self.event_queue, (self.frame_no, serialized_event))

        # tell the client who they are, what the current time is, and the room's key (may throw)
        if client.session_key == b'\0\0\0\0':
            self.server.create_session(client)

        client.conn.sendall(bytes([
            HEADER_ROOM_KEY, self.room_key[0], self.room_key[1], self.room_key[2], self.room_key[3],
            new_id,
            self.frame_no // (256 * 256), (self.frame_no // 256) % 256, self.frame_no % 256,
            client.session_key[0], client.session_key[1], client.session_key[2], client.session_key[3],
            ]))
        client.acked_to = 0
        client.acked_frame = -1
        client.double_acked_frame = -60
        client.warned_frame = self.frame_no
        client.tcp_sent_frame = -1

        # register this socket's events to go to the client
        self.selector.register(client.conn, selectors.EVENT_READ, client.read)
        if client.data_conn:
            self.selector.register(client.data_conn, selectors.EVENT_READ, client.read_data)

    def transmit(self, client):
        # send UDP
        if client.udp_send and client.udp_dest:
            self.server.udp_socket.sendto(client.udp_send, client.udp_dest)
            # print('Sending', list(client.udp_send))

        # send TCP
        if client.data_conn and (client.tcp_send_start < client.tcp_send_end or (not client.udp_dest and client.tcp_send_end == len(self.sent_history))):
            try:
                client.tcp_send_start += client.data_conn.send(self.sent_history[client.tcp_send_start:client.tcp_send_end])
                if client.tcp_send_start == len(self.sent_history):
                    client.data_conn.sendall(bytes([MESSAGE_FRAME_END, self.frame_no // (256 * 256), (self.frame_no // 256) % 256, self.frame_no % 256]))
                    client.tcp_send_end = 0
            except BlockingIOError:
                pass
            except ConnectionResetError:
                pass
            except BrokenPipeError:
                pass

    def process_frame(self):
        # print(f"Debug: starting processing for frame {self.frame_no}")

        # thread-safe way of adopting added clients queue
        added_clients = self.added_clients
        self.added_clients = []

        for client in added_clients:
            try:
                self.add(client)
            except Exception as e:
                print(e)
                self.kill(client)

        # sync all network events
        events = self.selector.select(0)

        for key, mask in events:
            # mask is the event that was triggered (always selectors.EVENT_READ)
            callback = key.data
            try:
                callback()
            except Exception as e:
                print(e)
                self.kill(callback.__self__)

        # sync UDP events
        for client in self.clients:
            if client is None:
                continue

            got = client.udp_recv
            client.udp_recv = []

            for msg in got:
                client.read_data_udp(msg)

        # don't run anything until we have a session_config
        if not self.session_config or len(self.session_config) < self.session_config_length:
            return

        # skip the frame if nobody is connected
        if not self.newly_freed_clients:
            has_any_client = False

            for client in self.clients:
                if client is None:
                    continue

                has_any_client = True
                break

            if not has_any_client:
                return

        # increment the frame number
        self.frame_no += 1

        # combine all events from this frame
        serialized_events = bytes()

        while self.event_queue and self.event_queue[0][0] <= self.frame_no:
            event_to_send = heapq.heappop(self.event_queue)

            event_frame = event_to_send[0]
            serialized_event = event_to_send[1]

            serialized_events += serialized_event

            # debug info
            # if serialized_event[0] == HEADER_CLIENT_JOIN:
            #     print(f"Debug: sending CLIENT_JOIN ({serialized_event[1]})")
            # elif serialized_event[0] == HEADER_CLIENT_LOSS:
            #     print(f"Debug: sending CLIENT_LOSS ({serialized_event[1]})")
            print(f"Debug: sending TEXT_EVENT (from {serialized_event[1]}): {list(serialized_event)}")

            if event_frame != self.frame_no:
                print(f"Warning: sent an event for frame {event_to_send[0]} on frame {self.frame_no}. This is not a normal lag situation.")

        # add the frame-begin event
        if serialized_events:
            serialized_events = bytes([MESSAGE_FRAME_BEGIN, self.frame_no // (256 * 256), (self.frame_no // 256) % 256, self.frame_no % 256]) + serialized_events

        # actually send the frame's events to all client sockets
        self.sent_history += serialized_events

        for client in self.clients:
            if client is None:
                continue

            if client.receiving_session:
                if client.session_received == -1:
                    client.conn.sendall(bytes([HEADER_PUT_SESSION,
                        (self.session_config_length // (256 * 256 * 256)) % 256,
                        (self.session_config_length // (      256 * 256)) % 256,
                        (self.session_config_length //             (256)) % 256,
                        (self.session_config_length                     ) % 256]))
                    client.session_received = 0

                try:
                    client.session_received += client.conn.send(self.session_config[client.session_received:])
                except BlockingIOError:
                    pass

                if client.session_received == self.session_config_length:
                    client.receiving_session = False
                else:
                    continue

            if client.acked_to != -1 and (client.data_conn or client.udp_dest):
                # adjust sent_to based on acked frame
                if client.udp_dest and client.acked_frame >= 0:
                    while client.acked_to + 4 <= len(self.sent_history):
                        if self.sent_history[client.acked_to] == MESSAGE_FRAME_BEGIN and \
                                self.sent_history[client.acked_to + 1 : client.acked_to + 4] >= bytes([client.acked_frame // (256 * 256), (client.acked_frame // 256) % 256, client.acked_frame % 256]):
                            break
                        client.acked_to += 4

                MTU_size = 250
                if client.udp_dest and len(self.sent_history) - client.acked_to <= MTU_size - 8:
                    start = max(client.acked_frame, client.tcp_sent_frame + 1)
                    if start >= 0:
                        ack = bytes([MESSAGE_TRANSMIT_START, start // (256 * 256), (start // 256) % 256, start % 256])
                    else:
                        ack = bytes()
                    client.udp_send = ack + self.sent_history[client.acked_to:] + bytes([MESSAGE_FRAME_END, self.frame_no // (256 * 256), (self.frame_no // 256) % 256, self.frame_no % 256])
                # add the tail of the room history to the TCP send queue
                else:
                    if client.tcp_send_start == client.tcp_send_end:
                        client.tcp_send_start = client.acked_to
                    client.tcp_send_end = len(self.sent_history)
                    client.acked_to = client.tcp_send_end
                    client.tcp_sent_frame = self.frame_no
                    client.udp_send = bytes()

                self.transmit(client)

            # warn clients if they are falling behind (in the future, this will happen based on whether the UDP MTU has been exceeded)
            if self.frame_no - max(client.acked_frame, client.warned_frame) > 20:
                # print('Warning client of catchup', self.frame_no, client.acked_frame, client.warned_frame)
                try:
                    client.conn.sendall(bytes([HEADER_FRAME_COMPLETE, self.frame_no // (256 * 256), (self.frame_no // 256) % 256, self.frame_no % 256]))
                except BlockingIOError:
                    pass
                except ConnectionResetError:
                    pass
                except BrokenPipeError:
                    pass
                client.warned_frame = self.frame_no

            # TCP mode: double-ack clients to let them know their latency
            if client.acked_frame - client.double_acked_frame > 60:
                print('Client latency appears to be', self.frame_no - client.acked_frame)
                try:
                    client.conn.sendall(bytes([HEADER_ACK, client.acked_frame // (256 * 256), (client.acked_frame // 256) % 256, client.acked_frame % 256]))
                except BlockingIOError:
                    pass
                except ConnectionResetError:
                    pass
                except BrokenPipeError:
                    pass
                client.double_acked_frame = client.acked_frame

        # update the free client ID list
        self.freed_clients.update(self.newly_freed_clients)
        self.newly_freed_clients = set()

    def frame_loop(self):
        while True:
            start_time = time.time()
            self.process_frame()
            end_time = time.time()

            proc_time = end_time - start_time

            if(proc_time > self.frame_length):
                print(f'Warning: overlong frame {self.frame_no - 1} ({proc_time}s > {self.frame_length}s)')
            else:
                time.sleep(self.frame_length - proc_time)
                # for i in range(2):
                #     time.sleep((self.frame_length - proc_time) / 2)

                #     for client in self.clients:
                #         if client is None:
                #             continue
                #         self.transmit(client)


class Server:
    def __init__(self, bind_address, bind_port, frame_length):
        self.frame_length = frame_length

        # this object will tell us when any network events have occurred
        self.selector = selectors.DefaultSelector()

        # this is the TCP server socket
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.bind((bind_address, bind_port))
        self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.socket.listen(100)
        self.socket.setblocking(False)
        self.selector.register(self.socket, selectors.EVENT_READ, self.accept)

        self.udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.udp_socket.bind((bind_address, bind_port))
        self.udp_socket.setblocking(False)
        self.selector.register(self.udp_socket, selectors.EVENT_READ, self.read_udp)

        # dictionary of loaded rooms
        self.loaded_rooms = {}
        self.room_insertion_lock = threading.Lock()

        # dictionary of active sessions
        self.sessions = {}
        self.session_kill_list = [] # eventually, add a timeout list for unexpectedly disconnected sessions here
        self.sessions_lock = threading.Lock()

        # dictionary of UDP connections to clients (FIXME: need to timeout and deallocate these when client sessions are killed)
        self.udp_connections = {}

        # directory to store saved rooms
        self.room_directory = '/tmp/py'
        os.makedirs(self.room_directory, exist_ok=True)

        # FIXME: add some rate-limiting system soon

    def insert_room(self, new_room):
        with self.room_insertion_lock:
            if not new_room.room_key in self.loaded_rooms:
                self.loaded_rooms[new_room.room_key] = new_room
                threading.Thread(target=new_room.frame_loop, daemon=True).start()

    def create_room(self, room_info):
        while True:
            room_key = bytes([random.randint(0, 63), random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)])
            display_key = display_room_key(room_key)

            if room_key == b'\0\0\0\0':
                continue

            try:
                open(self.room_directory + display_key, 'x').close()
            except FileExistsError:
                pass
            else:
                break

        print("Creating room", display_key)

        new_room = Room(self, room_key)
        new_room.room_info = room_info
        self.insert_room(new_room)

        return new_room

    def create_session(self, client):
        with self.sessions_lock:
            while True:
                session_key = bytes([random.randint(128, 255), random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)])

                if session_key in self.sessions:
                    continue

                break

            self.sessions[session_key] = client
            client.session_key = session_key

    def find_session(self, session_key):
        with self.sessions_lock:
            if session_key in self.sessions:
                return self.sessions[session_key]

        return None

    def unregister_session(self, session_key):
        with self.sessions_lock:
            if session_key in self.sessions:
                del self.sessions[session_key]

    def load_room(self, room_key):
        display_key = display_room_key(room_key)

        try:
            room = self.loaded_rooms[room_key]

            with room.kill_lock:
                if not room.killed:
                    room.kill_timer = 0
                    return room

            room = None
        except KeyError:
            pass

        display_key = display_room_key(room_key)

        if not display_key or not os.path.exists(self.room_directory + display_key) or os.path.getsize(self.room_directory + display_key) == 0:
            return None

        loading_room = Room(self, room_key)
        loading_room.load_from_file()

        self.insert_room(loading_room)
        return self.loaded_rooms[room_key]

    def accept(self):
        # create and set up the new socket
        conn, address = self.socket.accept()
        conn.setblocking(False)
        conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)

        # add a client
        new_client = Connection(self, conn, address)

        # wait for events on this client
        self.selector.register(new_client.conn, selectors.EVENT_READ, new_client.read)

    def read_udp(self):
        data, addr = self.udp_socket.recvfrom(256)

        if addr in self.udp_connections and data[0] < 128:
            self.udp_connections[addr].udp_recv.append(data)
        elif len(data) == 4 and not addr in self.udp_connections:
            print(data, addr)
            client = self.find_session(data)
            if client:
                self.udp_connections[addr] = client
                client.udp_dest = addr
                client.udp_recv = []
                client.udp_send = b''

    def unregister(self, client):
        try:
            self.selector.unregister(client.conn)
        except KeyError:
            pass
        except ValueError:
            pass

    def kill(self, client):
        self.unregister(client)
        client.conn.close()

        if client.data_conn:
            client.data_conn.close()

    def process(self):
        # sync all network events
        events = self.selector.select(None)

        for key, mask in events:
            # mask is the event that was triggered (always selectors.EVENT_READ)
            callback = key.data
            try:
                callback()
            except Exception as e:
                print(e)
                # don't kill self on failed accept, just ignore
                if callback.__self__ is not self:
                    self.kill(callback.__self__)

    def main_loop(self):
        while True:
            self.process()


# this is what happens when you run the script directly
if __name__ == '__main__':
    import sys

    server = Server(sys.argv[1] if len(sys.argv) >= 2 else '0.0.0.0', 4305, 0.0156)
    server.main_loop()


================================================
FILE: resources/emscripten/manifest.json.in
================================================
{
  "name": "${THEXTECH_MANIFEST_NAME_OUT}",
  "id": "${THEXTECH_MANIFEST_ID_OUT}",
  "description": "${THEXTECH_MANIFEST_DESC_OUT}",
  "display": "fullscreen",
  "orientation": "landscape-primary",
  "scope": "${THEXTECH_DEPLOY_URL}",
  "start_url": "${THEXTECH_DEPLOY_URL}index.html",
  "icons": [
    {
      "src": "thextech_32.png",
      "sizes": "32x32",
      "type": "image/png"
    },
    {
      "src": "thextech_256.png",
      "sizes": "256x256",
      "type": "image/png"
    }
  ]
}


================================================
FILE: resources/emscripten/shell_minimal.html
================================================
<!doctype html>
<html lang="en-us">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <link rel="shortcut icon" href="favicon.ico" type="image/x-icon">
    <link rel="manifest" href="manifest.json" />
    <script type="text/javascript">
      if('serviceWorker' in navigator)
      {
        window.addEventListener('load', function()
        {
          navigator.serviceWorker.register('sw.js');
        });
      }
    </script>
    <title>TheXTech Engine</title>
    <style>
      .emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; }
      textarea.emscripten { font-family: monospace; width: 80%; }
      div.emscripten { text-align: center; }
      div.emscripten_border { border: 1px solid black; }
      /* the canvas *must not* have any border or padding, or mouse coords will be wrong */
      canvas.emscripten { border: 0px none; background-color: black; }

      body { margin: 0; }

      .spinner {
        height: 50px;
        width: 50px;
        margin: 0px auto;
        -webkit-animation: rotation .8s linear infinite;
        -moz-animation: rotation .8s linear infinite;
        -o-animation: rotation .8s linear infinite;
        animation: rotation 0.8s linear infinite;
        border-left: 10px solid rgb(0,150,240);
        border-right: 10px solid rgb(0,150,240);
        border-bottom: 10px solid rgb(0,150,240);
        border-top: 10px solid rgb(100,0,200);
        border-radius: 100%;
        background-color: rgb(200,100,250);
      }
      @-webkit-keyframes rotation {
        from {-webkit-transform: rotate(0deg);}
        to {-webkit-transform: rotate(360deg);}
      }
      @-moz-keyframes rotation {
        from {-moz-transform: rotate(0deg);}
        to {-moz-transform: rotate(360deg);}
      }
      @-o-keyframes rotation {
        from {-o-transform: rotate(0deg);}
        to {-o-transform: rotate(360deg);}
      }
      @keyframes rotation {
        from {transform: rotate(0deg);}
        to {transform: rotate(360deg);}
      }

    </style>
  </head>
  <body>
    <hr/>
    <figure style="overflow:visible;" id="spinner"><div class="spinner"></div><center style="margin-top:0.5em"><strong>TheXTech on emscripten</strong></center></figure>
    <div class="emscripten" id="status">Downloading...</div>
    <div class="emscripten">
      <progress value="0" max="100" id="progress" hidden=1></progress>
    </div>
    <div class="emscripten_border">
      <canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()" tabindex=-1></canvas>
      <div id="exit-msg" style="position:absolute;top:25%;text-align:center;width:100%;display:none">Game finished.<br/>Close or refresh the page to exit.</div>
    </div>
    <hr/>
    <script type='text/javascript'>
      var statusElement = document.getElementById('status');
      var progressElement = document.getElementById('progress');
      var spinnerElement = document.getElementById('spinner');

      var Module = {
        preRun: [],
        postRun: [],
        print: (function() {
          return function(text) {
            if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' ');
            console.log(text);
          };
        })(),
        canvas: (() => {
          var canvas = document.getElementById('canvas');

          // As a default initial behavior, pop up an alert when webgl context is lost. To make your
          // application robust, you may want to override this behavior before shipping!
          // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
          canvas.addEventListener("webglcontextlost", (e) => { alert('WebGL context lost. You will need to reload the page.'); e.preventDefault(); }, false);

          return canvas;
        })(),
        setStatus: (text) => {
          if (!Module.setStatus.last) Module.setStatus.last = { time: Date.now(), text: '' };
          if (text === Module.setStatus.last.text) return;
          var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
          var now = Date.now();
          if (m && now - Module.setStatus.last.time < 30) return; // if this is a progress update, skip it if too soon
          Module.setStatus.last.time = now;
          Module.setStatus.last.text = text;
          if (m) {
            text = m[1];
            progressElement.value = parseInt(m[2])*100;
            progressElement.max = parseInt(m[4])*100;
            progressElement.hidden = false;
            spinnerElement.hidden = false;
          } else {
            progressElement.value = null;
            progressElement.max = null;
            progressElement.hidden = true;
            if (!text) spinnerElement.hidden = true;
          }
          statusElement.innerHTML = text;
        },
        totalDependencies: 0,
        monitorRunDependencies: (left) => {
          this.totalDependencies = Math.max(this.totalDependencies, left);
          Module.setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.');
        }
      };
      Module.setStatus('Downloading...');
      window.onerror = () => {
        Module.setStatus('Exception thrown, see JavaScript console');
        spinnerElement.style.display = 'none';
        Module.setStatus = (text) => {
          if (text) console.error('[post-exception status] ' + text);
        };
      };
    </script>
    {{{ SCRIPT }}}
  </body>
</html>


================================================
FILE: resources/emscripten/sw.js.in
================================================
// service worker with a cache-first model, with atomic updates based on service worker version
// based closely on the designs from https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers

// configuration
const app_id = "${THEXTECH_MANIFEST_ID_OUT}"
const current_version = "${THEXTECH_MANIFEST_ID_OUT}-${GIT_COMMIT_HASH}";
const scope = "${THEXTECH_DEPLOY_URL}";
const executable_name = "${THEXTECH_EXECUTABLE_NAME}";


// code for installation
const cache_resources = async (resources) => {
  const cache = await caches.open(current_version);
  console.info("TheXTech service worker update to " + current_version + " initialized: starting download. (" + new Date() + ")");
  await cache.addAll(resources);
  console.info("TheXTech service worker update to " + current_version + ": download complete. (" + new Date() + ")");
};

// make sure that all resources have been downloaded / cached upon installation of new SW version
self.addEventListener("install", (event) => {
  event.waitUntil(
    cache_resources([
      scope,
      scope + "favicon.ico",
      scope + "index.html",
      scope + executable_name + ".js",
      scope + executable_name + ".wasm",
      scope + executable_name + ".data",
    ]),
  );
});


// code for activation

// clear previously cached versions of the game on update
const clear_cache = async (key) => {
  await caches.delete(key);
};

const clear_other_caches = async () => {
  const keyList = await caches.keys();
  const cachesToDelete = keyList.filter((key) => (key.startsWith(app_id) && key != current_version));
  await Promise.all(cachesToDelete.map(clear_cache));
  console.info("TheXTech service worker update to " + current_version + ": update activated. (" + new Date() + ")");
  console.info("Deleted old caches: " + cachesToDelete);
};

// delete all other caches upon activation (do NOT claim clients; wait for the old service worker to die naturally)
self.addEventListener("activate", (event) => {
  event.waitUntil(clear_other_caches());
});


// code for fetches
const cache_response = async (request, response) => {
  const cache = await caches.open(current_version);
  await cache.put(request, response);
};

// cache-first strategy based on MDN's tutorial
const cache_first = async (request) => {
  // First try to get the resource from the cache
  const cache = await caches.open(current_version);
  const responseFromCache = await cache.match(request);
  if (responseFromCache) {
    console.info("Cache hit!");
    return responseFromCache;
  }

  // Next try to get the resource from the network
  try {
    const responseFromNetwork = await fetch(request);
    // response may be used only once
    // we need to save clone to put one copy in cache
    // and serve second one
    cache_response(request, responseFromNetwork.clone());
    console.info("Cache miss, got!");
    return responseFromNetwork;
  } catch (error) {
    console.info("Cache miss, failed!");

    // there is nothing we can do, but we must always
    // return a Response object
    return new Response("Resource not available: " + error, {
      status: 408,
      headers: { "Content-Type": "text/plain" },
    });
  }
};

// fetch handler, use cache first
self.addEventListener("fetch", function (event) {
  console.info("TheXTech service worker. Fetch: " + event.request.url + " with mode:" + event.request.mode);
  event.respondWith(cache_first(event.request));
});


================================================
FILE: resources/flatpak/appdata.xml.in
================================================
<?xml version="1.0" encoding="UTF-8"?>
<component type="desktop-application">
  <id>@THEXTECH_EXECUTABLE_NAME@</id>
  
  <name>@DESKTOP_NAME@</name>
  <summary>@DESKTOP_COMMENT@</summary>
  <developer_name>Wohlsoft</developer_name>
  <url type="homepage">https://github.com/Wohlstand/TheXTech/</url>

  <metadata_license>CC-BY-SA-4.0</metadata_license>
  <project_license>GPL-3.0-or-later</project_license>
  
  <recommends>
    <display_length compare="ge">800</display_length>
  </recommends>
  <supports>
    <control>pointing</control>
    <control>keyboard</control>
    <control>touch</control>
    <control>gamepad</control>
  </supports>
  
  <description>
    <p>
      @FLATPAK_DESCRIPTION@
    </p>
  </description>
  
  <launchable type="desktop-id">@THEXTECH_EXECUTABLE_NAME@.desktop</launchable>
</component>


================================================
FILE: resources/flatpak/build.yml
================================================
id: ru.wohlsoft.TheXTech
default-branch: dev
runtime: org.freedesktop.Platform
runtime-version: "22.08"
sdk: org.freedesktop.Sdk
command: ru.wohlsoft.TheXTech
modules:
  - buildsystem: cmake-ninja
    name: thextech
    sources:
      - type: git
        url: https://github.com/TheXTech/TheXTech
        branch: main
    config-opts:
      - -DCMAKE_BUILD_TYPE=MinSizeRel
      - -DTHEXTECH_EXECUTABLE_NAME=ru.wohlsoft.TheXTech
      - -DPGE_SHARED_SDLMIXER=Off
      - -DFLATPAK_BUILD=On
      - -DOVERRIDE_GIT_BRANCH=
finish-args:
  # remove this after the new paths update, use $XDG_DATA_HOME inside the sandbox instead
  - --filesystem=host
  - --device=dri
  # drop to --device=input once supported on Ubuntu and Debian
  - --device=all
  - --socket=x11
  - --socket=wayland
  # set fallback-x11 whenever we have SDL client-side decorations on Wayland GNOME
  # - --socket=fallback-x11
  - --socket=pulseaudio
  - --share=ipc


================================================
FILE: resources/haiku/PackageInfo.in
================================================
name                  thextech_bin
version               @THEXTECH_HAIKU_VERSION_STRING@
architecture          @TARGET_PROCESSOR@
summary               "TheXTech runtime package"
description           "@XTECH_HAIKU_SHORT_DESC@"
packager              "Vitaliy Novichkov <admin@wohlnet.ru>"
vendor                "TheXTech Developers Team"
licenses {
    "GNU GPL v3"
}
copyrights {
    "Copyright (C) 2020-@XTECH_HAIKU_COPYRIGHT_YEAR@ by Vitaliy Novichkov <admin@wohlnet.ru>"
}
provides {
    thextech_bin = @THEXTECH_HAIKU_VERSION_STRING@
}
requires {
    haiku >= r1~beta5_hrev57937-129
    libsdl2 >= 2.30.10-1
}
urls {
# TheXTech Project page
    "https://wohlsoft.ru/projects/TheXTech/"
# Source code repository
    "https://github.com/TheXTech/TheXTech"
}
source-urls {
# Source code repository
    "https://github.com/TheXTech/TheXTech"
}


================================================
FILE: resources/haiku/icon.rdef
================================================
resource app_flags B_SINGLE_LAUNCH;

resource vector_icon array {
	$"6E6369660E03191AAC01362A1B3303438BFF03FDF1B803FFAB8803D5BA66051A"
	$"05FF035D4C4802001602BC058BBCD61B3CD61BBC058B4BB02C48C0C9004DFFFF"
	$"05000566041AFD02001602BC058BBCD61B3CD61BBC058B4C0AD1470D12004DFF"
	$"FF1A0605FF01B450C4ADB450C4ADB868CA27CB3BC49DC825C9D7CE50BF13BFD6"
	$"B31CCA08B31CB532B31CB450C4ADB10ABFF4B450C4ADC4AD020FBFF6C299BFF6"
	$"C299BDB2C299B949C36BBB6DC2C9B837C3BBB674C4CDB736C41CB624C52EB634"
	$"C610B5F3C59FB674C6A1B7A653B715C701B888C7B3BA5BC834B96AC7F3BC4FC8"
	$"94C036C8B4BE43C8C5C24AC8B4C682C7E3C47EC874C753C7A2C8E6C6E1C83553"
	$"C947C690C9A8C59FC9B850C9B8C52EC8F6C47DC957C4CDC855C40CC6F3C38BC7"
	$"A4C3CBC570C30AC24AC2A9C3DDC2C9C189C299BFF6C299C0B7C299BFF6C299BF"
	$"F6C299BFF6C299BFF6C2990606FF07C5F8B9C7C5F8B9C7C5F8BD25BFB9BFDFC3"
	$"2CBFDFBC46BFDFB97BB9C7B97BBD25B97BB66ABFB9B3AFBC46B3AFC32CB3AFC5"
	$"F8B9C7C5F8B66AC5F8B9C7B9C70605FF01CA00B8E0CA00B8E0C988BA09C98DBD"
	$"39C959BB94C9D6BF84CBFDC252CAD0C16DCC8FBF75CA00B8E0CBD9BBDCCA00B8"
	$"E0B8E00605FF01B587B8F5B587B8F5B39EBBFCB360C247B2E3BF94B493C168B5"
	$"DFBD3EB58CBF84B61EBBA3B587B8F5B5F4BA23B587B8F5B8F50007B8F9CA27B8"
	$"F9CA27B8F9CA88BFE6CC2BBAFDCC2BC4BFCC2BC672CA27C611CAA8C753C946C7"
	$"8450C7A4C650C784C5CFC006C36BC43EC38BBB6DC34AB827C5EFB827C5EFB7C7"
	$"C732B8F9CA27B858C996B8F9CA270606FF07C626C859C626C859C626C91AC4CE"
	$"C9B5C58CC9B5C410C9B5C376C859C376C91AC376C799C4CEC6FEC410C6FEC58C"
	$"C6FEC626C859C626C799C626C859C8590606FF07BC03C859BC03C859BC03C91A"
	$"BAABC9B5BB69C9B5B9EDC9B5B953C859B953C91AB953C799BAABC6FEB9EDC6FE"
	$"BB69C6FEBC03C859BC03C799BC03C859C8590007B8F9CA27B8F9CA27B8F9CA88"
	$"BFE6CC2BBAFDCC2BC4BFCC2BC672CA27C611CAA8C753C946C78450C7A4C650C7"
	$"84C5CFC006C36BC43EC38BBB6DC34AB827C5EFB827C5EFB7C7C732B8F9CA27B8"
	$"58C996B8F9CA27060AFEFF07BCEBC4F6BCEBC4F6BCEBC4F6BD41C4F6BD87C53C"
	$"BD87C515BD87C617BD87C7CEBD87C6F2BD87C7F4BCEBC813BD41C813BCEBC813"
	$"BCEBC813BCEBC813BC94C813BC4FC7CEBC4FC7F4BC4FC6F2BC4FC53CBC4FC617"
	$"BC4FC515BCEBC4F6BC94C4F6BCEBC4F6C4F60209BC49C667BC49C667BC49C64A"
	$"BC49C60FBC49C62CBC65C61DBC9DC638BC81C62BBCCBC64DBD2EC67CBD0FC66C"
	$"BD3FC685BD62C696BD51C68DBD3CC69BBCF0C6A6BD16C6A0BCACC6B0BC63C6BA"
	$"BC6EC6BABC5BC6BABC49C6BABC52C6BABC49C69FBC49C667BC49C683BC49C667"
	$"060AFEFF07C232C4F6C232C4F6C232C4F6C288C4F6C2CEC53CC2CEC515C2CEC6"
	$"17C2CEC7CEC2CEC6F2C2CEC7F4C232C813C288C813C232C813C232C813C232C8"
	$"13C1DCC813C196C7CEC196C7F4C196C6F2C196C53CC196C617C196C515C232C4"
	$"F6C1DCC4F6C232C4F6C4F60209C191C667C191C667C191C64AC191C60FC191C6"
	$"2CC1ADC61DC1E4C638C1C9C62BC213C64DC276C67CC257C66CC287C685C2AAC6"
	$"96C299C68DC284C69BC238C6A6C25EC6A0C1F4C6B0C1ABC6BAC1B6C6BAC1A2C6"
	$"BAC191C6BAC19AC6BAC191C69FC191C667C191C683C191C6670004C0F3C7D9C0"
	$"F3C7D9C124C87AC07FC996C0F6C92FC009C9FDBEEEC99ABF66C9FFBE76C936BE"
	$"74C7E0BE45C882BE74C7E00221C66BC6E0C66BC6E0C6BBC6E1C75BC6E3C70BC6"
	$"E2C75AC722C75AC7A0C75AC761C789C7B3C7E8C7D954C7C6C811C7AEC864C756"
	$"C83BC782C89FC793C915C80EC8DAC7D1C8E9C835C89256C8BEC85CC8A7C8B3C8"
	$"D0C911C8BCC8E2C90FC911C98BC911C94DC911C98BC964C989CA0AC98AC9B7C9"
	$"4DCA0BC8D4CA0CC911CA0BC8C0CA38C897CA8EC8ABCA63C8C2CABBC919CB14C8"
	$"EE5CC8E0CB51C86DCBCAC8A6CB8DC841CB9CC7EACB42C815CB6FC7BBCB56C75E"
	$"CB7CC78DCB69C75DCBB9C75BCC33C75CCBF6C70BCC33C66BCC32C6BBCC32C66C"
	$"CBF7C66ECB80C66DCBBCC63DCB6BC5DDCB40C60DCB55C5B3CB6CC55DCBC4C588"
	$"CB98C523CB8BC4ADCB1AC4E8CB53C4DACAECC534CA90C507CABEC522CA63C4FD"
	$"CA09C50FCA36C4BECA09C441CA09C47FCA09C440C9B5C43EC90DC43FC961C47C"
	$"C90DC4F9C90DC4BAC90DC50DC8E2C535C88BC521C8B7C50CC85AC4BAC7F9C4E3"
	$"C82AC4EFC7C4C559C758C524C78EC584C784C5DBC7DBC5B0C7B0C60BC7C5C66B"
	$"C79AC63BC7B0C66BC75CC66BC6E0C66BC71EC66BC6E00221C66BC6E0C66BC6E0"
	$"C6BBC6E1C75BC6E3C70BC6E2C75AC722C75AC7A0C75AC761C789C7B3C7E8C7D9"
	$"54C7C6C811C7AEC864C756C83BC782C89FC793C915C80EC8DAC7D1C8E9C835C8"
	$"9256C8BEC85CC8A7C8B3C8D0C911C8BCC8E2C90FC911C98BC911C94DC911C98B"
	$"C964C989CA0AC98AC9B7C94DCA0BC8D4CA0CC911CA0BC8C0CA38C897CA8EC8AB"
	$"CA63C8C2CABBC919CB14C8EE5CC8E0CB51C86DCBCAC8A6CB8DC841CB9CC7EACB"
	$"42C815CB6FC7BBCB56C75ECB7CC78DCB69C75DCBB9C75BCC33C75CCBF6C70BCC"
	$"33C66BCC32C6BBCC32C66CCBF7C66ECB80C66DCBBCC63DCB6BC5DDCB40C60DCB"
	$"55C5B3CB6CC55DCBC4C588CB98C523CB8BC4ADCB1AC4E8CB53C4DACAECC534CA"
	$"90C507CABEC522CA63C4FDCA09C50FCA36C4BECA09C441CA09C47FCA09C440C9"
	$"B5C43EC90DC43FC961C47CC90DC4F9C90DC4BAC90DC50DC8E2C535C88BC521C8"
	$"B7C50CC85AC4BAC7F9C4E3C82AC4EFC7C4C559C758C524C78EC584C784C5DBC7"
	$"DBC5B0C7B0C60BC7C5C66BC79AC63BC7B0C66BC75CC66BC6E0C66BC71EC66BC6"
	$"E00606FF07C82EC98AC82EC98AC82ECA40C6E4CAD3C79BCAD3C62ECAD3C59BC9"
	$"8AC59BCA40C59BC8D3C6E4C840C62EC840C79BC840C82EC98AC82EC8D3C82EC9"
	$"8AC98A0606FF07C82EC98AC82EC98AC82ECA40C6E4CAD3C79BCAD3C62ECAD3C5"
	$"9BC98AC59BCA40C59BC8D3C6E4C840C62EC840C79BC840C82EC98AC82EC8D3C8"
	$"2EC98AC98A0606FF07C6FAC98AC6FAC98AC6FAC995C6E4C99FC6F0C99FC6D9C9"
	$"9FC6CFC98AC6CFC995C6CFC97EC6E4C974C6D9C974C6F0C974C6FAC98AC6FAC9"
	$"7EC6FAC98AC98A0606FF07C6FAC98AC6FAC98AC6FAC995C6E4C99FC6F0C99FC6"
	$"D9C99FC6CFC98AC6CFC995C6CFC97EC6E4C974C6D9C974C6F0C974C6FAC98AC6"
	$"FAC97EC6FAC98AC98A0221C8F2C2F6C8F2C2F6C942C2F8C9E1C2FAC992C2F9C9"
	$"E1C339C9E0C3B7C9E1C378CA10C3CACA6EC3F0CA3FC3DDCA98C3C4CAEBC36CCA"
	$"C1C398CB26C3AACB9CC424CB61C3E7CB70C44BCB19C49ACB45C473CB2EC4C9CB"
	$"57C527CB42C4F8CB95C527CC12C527CBD4C527CC11C57ACC1050CC11C5CDCBD4"
	$"C621CB5BC622CB97C622CB47C64ECB1DC6A5CB32C679CB49C6D1CBA0C72BCB75"
	$"C6FECB67C767CAF3C7E0CB2DC7A3CAC8C7B3CA71C758CA9CC786CA42C76CC9E5"
	$"C793CA14C77FC9E4C7CFC9E2C849C9E3C80CC992C849C8F2C848C942C849C8F3"
	$"C80DC8F4C797C8F4C7D2C8C4C781C864C756C894C76CC839C782C7E4C7DAC80F"
	$"C7AEC7AAC7A1C734C730C76FC769C761C702C7BBC6A7C78EC6D5C7A8C67AC784"
	$"50C796C64DC74550C6C750C70650C6C6C5CCC6C5C524C6C6C578C703C524C780"
	$"C524C741C524C794C4F8C7BCC4A1C7A8C4CDC793C471C741C40FC76AC440C776"
	$"C3DAC7E0C36FC7ABC3A4C80BC39AC862C3F2C837C3C6C892C3DCC8F2C3B0C8C2"
	$"C3C6C8F2C372C8F2C2F6C8F2C334C8F2C2F60221C8F2C2F6C8F2C2F6C942C2F8"
	$"C9E1C2FAC992C2F9C9E1C339C9E0C3B7C9E1C378CA10C3CACA6EC3F0CA3FC3DD"
	$"CA98C3C4CAEBC36CCAC1C398CB26C3AACB9CC424CB61C3E7CB70C44BCB19C49A"
	$"CB45C473CB2EC4C9CB57C527CB42C4F8CB95C527CC12C527CBD4C527CC11C57A"
	$"CC1050CC11C5CDCBD4C621CB5BC622CB97C622CB47C64ECB1DC6A5CB32C679CB"
	$"49C6D1CBA0C72BCB75C6FECB67C767CAF3C7E0CB2DC7A3CAC8C7B3CA71C758CA"
	$"9CC786CA42C76CC9E5C793CA14C77FC9E4C7CFC9E2C849C9E3C80CC992C849C8"
	$"F2C848C942C849C8F3C80DC8F4C797C8F4C7D2C8C4C781C864C756C894C76CC8"
	$"39C782C7E4C7DAC80FC7AEC7AAC7A1C734C730C76FC769C761C702C7BBC6A7C7"
	$"8EC6D5C7A8C67AC78450C796C64DC74550C6C750C70650C6C6C5CCC6C5C524C6"
	$"C6C578C703C524C780C524C741C524C794C4F8C7BCC4A1C7A8C4CDC793C471C7"
	$"41C40FC76AC440C776C3DAC7E0C36FC7ABC3A4C80BC39AC862C3F2C837C3C6C8"
	$"92C3DCC8F2C3B0C8C2C3C6C8F2C372C8F2C2F6C8F2C334C8F2C2F60606FF07CA"
	$"B5C5A0CAB5C5A0CAB5C656C96BC6EACA21C6EAC8B5C6EAC822C5A0C822C656C8"
	$"22C4EAC96BC456C8B5C456CA21C456CAB5C5A0CAB5C4EACAB5C5A0C5A00606FF"
	$"07CAB5C5A0CAB5C5A0CAB5C656C96BC6EACA21C6EAC8B5C6EAC822C5A0C822C6"
	$"56C822C4EAC96BC456C8B5C456CA21C456CAB5C5A0CAB5C4EACAB5C5A0C5A006"
	$"06FF07C981C5A0C981C5A0C981C5ACC96BC5B6C977C5B6C95FC5B6C956C5A0C9"
	$"56C5ACC956C594C96BC58AC95FC58AC977C58AC981C5A0C981C594C981C5A0C5"
	$"A00606FF07C981C5A0C981C5A0C981C5ACC96BC5B6C977C5B6C95FC5B6C956C5"
	$"A0C956C5ACC956C594C96BC58AC95FC58AC977C58AC981C5A0C981C594C981C5"
	$"A0C5A01A0A000100000A010101000A020102000A020103000A020104000A0301"
	$"05000A040106000A040107000A0501081001178000040A060109000A07010A00"
	$"0A06010B000A07010C000A08010D000A09010E000A0A010F1001178000040A0B"
	$"0110000A0C01111001178002040A0B0112000A0C01131001178002040A0D0114"
	$"000A0A01151001178000040A0B0116000A0C01171001178002040A0B0118000A"
	$"0C0119100117800204"
};


================================================
FILE: resources/icon/make_icns.sh
================================================
#!/bin/bash

TYPE="thextech"
if [[ "$TYPE" == "" ]]; then
echo "Error: empty name!"
exit 1
fi

mkdir $TYPE".iconset"
cp $TYPE"_16.png" $TYPE".iconset/icon_16x16.png"
sips -Z 32 $TYPE".iconset/icon_16x16.png" --out $TYPE".iconset/icon_16x16@2x.png"
cp $TYPE"_32.png" $TYPE".iconset/icon_32x32.png"
sips -Z 64 $TYPE".iconset/icon_32x32.png" --out $TYPE".iconset/icon_32x32@2x.png"
cp $TYPE"_48.png" $TYPE".iconset/icon_48x48.png"
sips -Z 96 $TYPE".iconset/icon_48x48.png" --out $TYPE".iconset/icon_48x48@2x.png"
cp $TYPE"_128.png" $TYPE".iconset/icon_128x128.png"
cp $TYPE"_256.png" $TYPE".iconset/icon_256x256.png"
cp $TYPE"_256.png" $TYPE".iconset/icon_128x128@2x.png"
cp $TYPE"_512.png" $TYPE".iconset/icon_256x256@2x.png"
#sips -Z 512 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_256x256@2x.png"
#sips -Z 512 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_512x512.png"
#sips -Z 128 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_128x128.png"

echo "makeIcon..."

iconutil -c icns $TYPE".iconset"
mv $TYPE".icns" ../

rm -Rf $TYPE".iconset"


================================================
FILE: resources/icon/make_icns_linux.sh
================================================
#!/bin/bash

# This script requires ImageMagick and icnsutils packages being installed

TYPE="thextech"
if [[ "$TYPE" == "" ]]; then
echo "Error: empty name!"
exit 1
fi

mkdir $TYPE".iconset"
cp $TYPE"_16.png" $TYPE".iconset/icon_16x16.png"
cp $TYPE"_32.png" $TYPE".iconset/icon_32x32.png"
# convert $TYPE".iconset/icon_32x32.png" -scale 64 $TYPE".iconset/icon_64x64.png"
cp $TYPE"_48.png" $TYPE".iconset/icon_48x48.png"
# convert $TYPE".iconset/icon_48x48.png" -scale 96 $TYPE".iconset/icon_96x96.png"
cp $TYPE"_128.png" $TYPE".iconset/icon_128x128.png"
cp $TYPE"_256.png" $TYPE".iconset/icon_256x256.png"
cp $TYPE"_512.png" $TYPE".iconset/icon_512x512.png"
#convert $TYPE".iconset/icon_256x256.png" -scale 512 $TYPE".iconset/icon_256x256@2x.png"
#sips -Z 512 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_256x256@2x.png"
#sips -Z 512 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_512x512.png"
#sips -Z 128 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_128x128.png"

#read -n 1

echo "makeIcon..."

png2icns $TYPE.icns $TYPE".iconset/icon_"*.png
mv $TYPE".icns" ../

rm -Rf $TYPE".iconset"


================================================
FILE: resources/languages/assets_bg.json
================================================
{
    "character": {
        "name2": "",
        "name5": "",
        "name3": "",
        "name1": "",
        "name4": ""
    },
    "editor": {
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "background2": {
            "fam-set1": {
                "bg2-10": "",
                "bg2-7": "",
                "bg2-9": "",
                "bg2-8": "",
                "bg2-50": "",
                "header": "",
                "bg2-41": "",
                "bg2-51": ""
            },
            "fam-set2": {
                "bg2-57": "",
                "bg2-48": "",
                "bg2-53": "",
                "bg2-49": "",
                "bg2-25": "",
                "bg2-54": "",
                "bg2-52": "",
                "bg2-5": "",
                "bg2-44": "",
                "header": ""
            },
            "fam-set3": {
                "bg2-13": "",
                "bg2-21": "",
                "bg2-4": "",
                "bg2-15": "",
                "bg2-36": "",
                "header": "",
                "bg2-6": "",
                "bg2-3": "",
                "bg2-39": "",
                "bg2-20": "",
                "bg2-38": "",
                "bg2-26": "",
                "bg2-1": "",
                "bg2-24": "",
                "bg2-23": "",
                "bg2-27": "",
                "bg2-22": "",
                "bg2-37": "",
                "bg2-35": "",
                "bg2-2": "",
                "bg2-14": "",
                "bg2-17": "",
                "bg2-56": ""
            },
            "fam-misc": {
                "header": "",
                "bg2-16": "",
                "bg2-46": "",
                "bg2-47": "",
                "bg2-40": "",
                "bg2-45": ""
            },
            "fam-set4": {
                "bg2-28": "",
                "bg2-32": "",
                "header": "",
                "bg2-33": "",
                "bg2-30": "",
                "bg2-55": "",
                "bg2-58": "",
                "bg2-11": "",
                "bg2-12": "",
                "bg2-19": "",
                "bg2-18": "",
                "bg2-42": "",
                "bg2-29": "",
                "bg2-43": "",
                "bg2-31": "",
                "bg2-34": ""
            },
            "auto": {
                "bg2-0": ""
            }
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "",
        "wordFails": "",
        "wordStarAccusativePlural": "",
        "wordStarAccusativeDualOrCounter": ""
    },
    "languageName": ""
}


================================================
FILE: resources/languages/assets_de.json
================================================
{
    "languageName": "Deutsch",
    "editor": {
        "background2": {
            "fam-misc": {
                "bg2-40": "Geheime Mine",
                "bg2-46": "Raumschiff",
                "bg2-47": "Raumbasis",
                "bg2-16": "Weltraum-Krater",
                "bg2-45": "Weltraum-Sumpf",
                "header": "Versch."
            },
            "fam-set1": {
                "bg2-41": "Burg",
                "bg2-50": "Pilze",
                "bg2-51": "Wüste",
                "bg2-7": "Unterirdisch",
                "bg2-8": "Nacht",
                "bg2-9": "Nacht 2",
                "bg2-10": "Oberwelt",
                "header": "Set 1"
            },
            "fam-set2": {
                "bg2-25": "Unterirdisch",
                "bg2-44": "Burg",
                "bg2-49": "Nacht - Hügel",
                "bg2-5": "Bäume",
                "bg2-52": "Nacht - Wüste",
                "bg2-53": "Klippe",
                "bg2-54": "Lagerhaus",
                "bg2-57": "Kerker",
                "bg2-48": "Wolken",
                "header": ""
            },
            "fam-set3": {
                "bg2-13": "Wolken",
                "bg2-14": "Wüste",
                "bg2-1": "Blöcke",
                "bg2-15": "Dungeon 2",
                "bg2-17": "Schiff",
                "bg2-2": "Hügel",
                "bg2-20": "Wald",
                "bg2-21": "Kampf",
                "bg2-22": "Wasserfall",
                "bg2-23": "Panzer",
                "bg2-24": "Endboss",
                "bg2-26": "Pilz-Dealer",
                "bg2-27": "Burg",
                "bg2-35": "Schnee-Bäume",
                "bg2-36": "Wolken 2",
                "bg2-37": "Schnee-Hügel",
                "bg2-38": "Höhle",
                "bg2-39": "Höhle 2",
                "bg2-4": "Röhren",
                "bg2-56": "Unterwasser",
                "header": "",
                "bg2-6": "",
                "bg2-3": ""
            },
            "auto": {
                "bg2-0": "Keine"
            },
            "fam-set4": {
                "bg2-11": "Hügel",
                "bg2-12": "Bäume",
                "bg2-18": "Villa",
                "bg2-19": "Wald",
                "bg2-29": "Nacht",
                "bg2-30": "Höhle",
                "bg2-31": "Wolken",
                "bg2-28": "",
                "bg2-32": "",
                "header": "",
                "bg2-33": "",
                "bg2-55": "",
                "bg2-58": "",
                "bg2-42": "",
                "bg2-43": "",
                "bg2-34": ""
            }
        },
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "character": {
        "name1": "Charakter1",
        "name2": "Charakter2",
        "name3": "Charakter3",
        "name4": "Character4",
        "name5": "Charakter5"
    },
    "objects": {
        "wordStarAccusativeSingular": "",
        "wordStarAccusativeDualOrCounter": "",
        "wordFails": "",
        "wordStarAccusativePlural": ""
    }
}


================================================
FILE: resources/languages/assets_en.json
================================================
{
    "character": {
        "name1": "Char1",
        "name2": "Char2",
        "name3": "Char3",
        "name4": "Char4",
        "name5": "Char5"
    },
    "editor": {
        "background2": {
            "auto": {
                "bg2-0": "None"
            },
            "fam-misc": {
                "bg2-16": "Space Crater",
                "bg2-40": "Secret Mine",
                "bg2-45": "Space Swamp",
                "bg2-46": "Space Ship",
                "bg2-47": "Space Base",
                "header": "Misc."
            },
            "fam-set1": {
                "bg2-10": "Overworld",
                "bg2-41": "Castle",
                "bg2-50": "Mushrooms",
                "bg2-51": "Desert",
                "bg2-7": "Underground",
                "bg2-8": "Night",
                "bg2-9": "Night 2",
                "header": "Set 1"
            },
            "fam-set2": {
                "bg2-25": "Underground",
                "bg2-44": "Castle",
                "bg2-48": "Clouds",
                "bg2-49": "Night - Hills",
                "bg2-5": "Trees",
                "bg2-52": "Night - Desert",
                "bg2-53": "Cliff",
                "bg2-54": "Warehouse",
                "bg2-57": "Dungeon",
                "header": "Set 2"
            },
            "fam-set3": {
                "bg2-1": "Blocks",
                "bg2-13": "Clouds",
                "bg2-14": "Desert",
                "bg2-15": "Dungeon 2",
                "bg2-17": "Ship",
                "bg2-2": "Hills",
                "bg2-20": "Forest",
                "bg2-21": "Battle",
                "bg2-22": "Waterfall",
                "bg2-23": "Tanks",
                "bg2-24": "Final Boss",
                "bg2-26": "Shroom Dealer",
                "bg2-27": "Castle",
                "bg2-3": "Dungeon",
                "bg2-35": "Snow Trees",
                "bg2-36": "Clouds 2",
                "bg2-37": "Snow Hills",
                "bg2-38": "Cave",
                "bg2-39": "Cave 2",
                "bg2-4": "Pipes",
                "bg2-56": "Underwater",
                "bg2-6": "Bonus",
                "header": "Set 3"
            },
            "fam-set4": {
                "bg2-11": "Hills",
                "bg2-12": "Trees",
                "bg2-18": "Mansion",
                "bg2-19": "Forest",
                "bg2-28": "Bonus",
                "bg2-29": "Night",
                "bg2-30": "Cave",
                "bg2-31": "Clouds",
                "bg2-32": "Hills 2",
                "bg2-33": "Hills 4",
                "bg2-34": "Hills 3",
                "bg2-42": "Castle",
                "bg2-43": "Castle 2",
                "bg2-55": "Underwater",
                "bg2-58": "Desert Night",
                "header": "Set 4"
            }
        },
        "bgo": {
            "fam-art2": "Art",
            "fam-bars4": "Bars",
            "fam-clouds1": "Clouds",
            "fam-doors2": "Doors",
            "fam-doors4": "Doors",
            "fam-exit3": "Exit",
            "fam-fences1": "Fences",
            "fam-fences4": "Fences",
            "fam-ghost4": "Ghost",
            "fam-hut1": "Hut",
            "fam-key4": "Key",
            "fam-misc4": "Misc",
            "fam-plants1": "Plants",
            "fam-plants2": "Plants",
            "fam-plants3": "Plants",
            "fam-plants4": "Plants",
            "fam-platform4": "Plat",
            "fam-sandbg3": "Sand BG",
            "fam-sandfg3": "FG",
            "fam-space5": "Space Bug",
            "fam-structures3": "Structures",
            "fam-temple5": "Temple",
            "fam-tiles3": "Tiles",
            "fam-water1": "Water",
            "fam-water2": "Water",
            "fam-water3": "Water",
            "fam-water4": "Water"
        },
        "block": {
            "fam-bonus3": "Bonus",
            "fam-bonus4": "Bonus",
            "fam-bricks5": "Brick",
            "fam-castle2": "Castle",
            "fam-castle4": "Castle",
            "fam-cave3": "Cave",
            "fam-cave4": "Cave",
            "fam-char5": "Char",
            "fam-clouds1": "Clouds",
            "fam-desert3": "Desert",
            "fam-dungeon1": "Dungeon",
            "fam-dungeon3": "Dungeon",
            "fam-grass3": "Grass",
            "fam-grass4": "Grass",
            "fam-house3": "House",
            "fam-hurts3": "Hurts",
            "fam-lava4": "Lava and Hurts",
            "fam-mansion4": "Mansion",
            "fam-metal5-1": "Plates",
            "fam-metal5-3": "Misc",
            "fam-misc1": "Misc",
            "fam-misc2": "Misc",
            "fam-misc3": "Misc 3",
            "fam-misc4": "Misc",
            "fam-overworld1": "Overworld",
            "fam-overworld2": "Overworld",
            "fam-pipes1": "Pipes",
            "fam-pipes3": "Pipes",
            "fam-pipes4": "Pipes",
            "fam-pipes5-2": "Pipes",
            "fam-pipes5-3": "Long Pipes",
            "fam-ruins5": "Ruins",
            "fam-sized1": "Sized",
            "fam-sized2": "Sized",
            "fam-sized3": "Sized 3",
            "fam-sized4": "Sized",
            "fam-special1": "Special",
            "fam-special2": "Special",
            "fam-special3": "Special",
            "fam-special4": "Special",
            "fam-steampunk3": "Steampunk",
            "fam-switch4": "Switch",
            "fam-underground1": "Underground",
            "fam-underground2": "Underground",
            "fam-water3": "Water",
            "fam-wood2": "Wood",
            "fam-wood3": "Wood",
            "fam-woods4": "Woods"
        },
        "exit-codes": {
            "1": "Roulette",
            "2": "Orb #16",
            "3": "Leave",
            "4": "Key",
            "5": "Orb #41",
            "6": "Warp",
            "7": "Collect",
            "8": "Bar end",
            "any": "Any",
            "none": "None",
            "9": "code9"
        },
        "music": {
            "auto": {
                "music0": "None",
                "music24": "Custom"
            },
            "fam-64": {
                "header": "64",
                "music14": "Desert",
                "music26": "Castle",
                "music27": "Main Theme",
                "music35": "Snow",
                "music36": "Boss",
                "music49": "Water",
                "music50": "Cave"
            },
            "fam-fight": {
                "header": "Fight",
                "music19": "Steampunk",
                "music39": "Temple",
                "music40": "Knight",
                "music52": "Underground",
                "music53": "Pinball"
            },
            "fam-misc": {
                "header": "Misc.",
                "music13": "New Overworld",
                "music18": "Beach",
                "music20": "Fusion Reactor",
                "music23": "Heroic Woods",
                "music37": "Ice Mountain",
                "music38": "Jungle Village",
                "music55": "Title Theme",
                "music56": "Bouncy Race",
                "music8": "Cornered!"
            },
            "fam-rpg": {
                "header": "RPG",
                "music16": "Forest",
                "music21": "Battle",
                "music30": "Bachelor Pad",
                "music31": "Seaside",
                "music32": "Pond",
                "music33": "Clouds",
                "music34": "Town"
            },
            "fam-set1": {
                "header": "Set 1",
                "music42": "Dungeon",
                "music46": "Water",
                "music7": "Underground",
                "music9": "Overworld"
            },
            "fam-set2": {
                "header": "Set 2",
                "music15": "Boss",
                "music25": "Underground",
                "music43": "Final Boss",
                "music5": "Overworld"
            },
            "fam-set3": {
                "header": "Set 3",
                "music1": "Overworld",
                "music2": "Sky",
                "music3": "Dungeon",
                "music4": "Underground",
                "music47": "Water",
                "music54": "Roaming Enemy",
                "music6": "Boss"
            },
            "fam-space": {
                "header": "Space",
                "music11": "Red Swamp",
                "music12": "Crater",
                "music22": "Space Charge",
                "music44": "Item Room",
                "music45": "Final Boss"
            },
            "fam-world": {
                "header": "World",
                "music10": "Overworld",
                "music17": "Mansion",
                "music28": "Sky",
                "music29": "Cave",
                "music41": "Dungeon",
                "music48": "Water",
                "music51": "Boss"
            }
        },
        "npc": {
            "fam-blocks2": "Blocks",
            "fam-blocks3": "Blocks",
            "fam-boss1": "Boss",
            "fam-boss2": "Boss",
            "fam-boss3": "Boss",
            "fam-boss4": "Boss",
            "fam-boss5": "Boss",
            "fam-char3": "Char",
            "fam-char5": "Char",
            "fam-ckpt4": "Ckpt",
            "fam-enemies1": "Enemies",
            "fam-enemies2": "Enemies",
            "fam-enemies3": "Enemies",
            "fam-enemies4": "Enemies",
            "fam-enemies5": "Enemies",
            "fam-exit2": "Exit",
            "fam-exit3": "Exit",
            "fam-exit4": "Exit",
            "fam-items1": "Items",
            "fam-items2": "Items",
            "fam-items3": "Items",
            "fam-items4": "Items",
            "fam-items5": "Items",
            "fam-pet4": "Pet",
            "fam-plant3": "Plant",
            "fam-plat1": "Plat",
            "fam-plat3": "Plat",
            "fam-plat4": "Plat",
            "fam-shell1": "Shell",
            "fam-shell3": "Shell",
            "fam-sign4": "Sign",
            "fam-switch5": "Switch",
            "fam-veg2": "Veg",
            "fam-vine1": "Vine",
            "fam-vine2": "Vine",
            "fam-vine3": "Vine",
            "fam-vine4": "Vine",
            "fam-warp2": "Warp"
        },
        "sound": {
            "auto": {
                "sound0": "None"
            },
            "fam-boss": {
                "header": "Boss",
                "sound38": "Bird Spit",
                "sound39": "Bird Hit",
                "sound41": "Bird Beat",
                "sound44": "Turtle Killed",
                "sound62": "Frog Bubbles",
                "sound63": "Frog Killed",
                "sound67": "Glass Break",
                "sound68": "Space Boss Hit",
                "sound69": "Space Boss Cry",
                "sound70": "Space Boss Kill"
            },
            "fam-hero": {
                "header": "Hero",
                "sound53": "Hero NPC Kill",
                "sound77": "Hero Stab",
                "sound78": "Hero Hurt",
                "sound79": "Get Heart",
                "sound80": "Hero Died",
                "sound81": "Get Gem",
                "sound82": "Hero Fire",
                "sound83": "Hero Item",
                "sound84": "Get Key",
                "sound85": "Shield Block",
                "sound86": "Hermes Boots",
                "sound87": "Fly",
                "sound88": "Mow Lawn"
            },
            "fam-item": {
                "header": "Item",
                "sound14": "Coin",
                "sound16": "Lava",
                "sound22": "Bullet",
                "sound3": "Block Hit",
                "sound32": "Switch",
                "sound37": "Crusher",
                "sound4": "Block Smashed",
                "sound42": "Big Fireball",
                "sound43": "Fireworks",
                "sound51": "Egg Hatch",
                "sound56": "Ring",
                "sound57": "Skeleton",
                "sound58": "Checkpoint",
                "sound59": "Collectible",
                "sound61": "Lava Creature",
                "sound64": "Space Block Hit",
                "sound65": "Space NPC Kill",
                "sound66": "Space NPC Hurt",
                "sound7": "Powerup",
                "sound74": "Saw",
                "sound9": "Shell Kick"
            },
            "fam-jingle": {
                "header": "Jingle",
                "sound19": "Roulette Exit",
                "sound20": "Defeat Boss",
                "sound21": "Dungeon Clear",
                "sound31": "Key Exit",
                "sound40": "Ball Exit",
                "sound45": "Game Beat",
                "sound52": "Got Star Exit",
                "sound60": "Bar Exit",
                "sound8": "Player Died"
            },
            "fam-pet": {
                "header": "Pet",
                "sound36": "Pet Stomp",
                "sound48": "Pet Mount",
                "sound49": "Pet Hurt",
                "sound50": "Pet Tongue",
                "sound55": "Pet Swallow"
            },
            "fam-player": {
                "header": "Player",
                "sound1": "Jump",
                "sound10": "Skid",
                "sound12": "Got Item",
                "sound15": "1up",
                "sound17": "Warp",
                "sound18": "Fireball",
                "sound2": "Stomp",
                "sound23": "Grab",
                "sound24": "Spring",
                "sound25": "Hammer Toss",
                "sound33": "Tail",
                "sound34": "Racoon",
                "sound35": "Lose Boot",
                "sound46": "Door",
                "sound5": "Shrink",
                "sound54": "Player Died 2",
                "sound6": "Grow",
                "sound71": "Climbing",
                "sound72": "Swim",
                "sound73": "Light Grab",
                "sound75": "Throw Veggie",
                "sound76": "Lose Heart"
            },
            "fam-ui": {
                "header": "UI",
                "sound11": "Drop Item",
                "sound13": "Camera",
                "sound26": "Slide",
                "sound29": "Do",
                "sound30": "Pause",
                "sound47": "Message"
            },
            "fam-world": {
                "header": "World",
                "sound27": "New Path",
                "sound28": "Level Select"
            }
        },
        "tile": {
            "fam-clouds4": "Clouds",
            "fam-desert1": "Dust",
            "fam-dirt2": "Dead Grass",
            "fam-granite3": "Granite",
            "fam-grass1": "Old Grass",
            "fam-grass2": "Happy Grass",
            "fam-lava3": "Lava",
            "fam-lilac4": "Lilac Wall",
            "fam-marble3": "Marble",
            "fam-snow1": "Old Snow",
            "fam-stonewall3": "Stone Wall",
            "fam-wall2": "Dirt Wall"
        },
        "worldMusic": {
            "auto": {
                "wmusic0": "None"
            },
            "fam-new": {
                "header": "New",
                "wmusic5": "Theme"
            },
            "fam-set3": {
                "header": "Set 3",
                "wmusic1": "World 1",
                "wmusic10": "World 6",
                "wmusic11": "World 5",
                "wmusic2": "World 4",
                "wmusic3": "World 7",
                "wmusic6": "World 2",
                "wmusic8": "World 3",
                "wmusic9": "World 8"
            },
            "fam-world": {
                "header": "World",
                "wmusic12": "Special",
                "wmusic13": "Dungeon",
                "wmusic14": "Sky",
                "wmusic15": "Island",
                "wmusic16": "Cave",
                "wmusic4": "Theme",
                "wmusic7": "Forest"
            }
        }
    },
    "languageName": "English",
    "objects": {
        "wordFails": "FAILS",
        "wordStarAccusativeDualOrCounter": "<Unused in English, translate as \"stars\" in Dual form if your language has dual form (the number between plural and singular); If your language has counter word, use counter word instead>",
        "wordStarAccusativePlural": "stars",
        "wordStarAccusativeSingular": "star"
    }
}


================================================
FILE: resources/languages/assets_es.json
================================================
{
    "editor": {
        "background2": {
            "fam-set1": {
                "bg2-50": "Champiñones",
                "bg2-7": "Subterráneo",
                "bg2-8": "Noche",
                "bg2-41": "Castillo",
                "bg2-51": "Desierto",
                "bg2-9": "Noche 2",
                "bg2-10": "",
                "header": ""
            },
            "fam-set2": {
                "bg2-25": "Subterráneo",
                "bg2-44": "Castillo",
                "bg2-48": "Nubes",
                "bg2-57": "Calabozo",
                "bg2-52": "Noche - Desierto",
                "bg2-5": "Árboles",
                "bg2-53": "",
                "bg2-49": "",
                "bg2-54": "",
                "header": ""
            },
            "fam-misc": {
                "bg2-16": "Cráter espacial",
                "bg2-40": "Mina secreta",
                "bg2-47": "Base espacial",
                "bg2-46": "Nave espacial",
                "bg2-45": "Pantano espacial",
                "header": ""
            },
            "auto": {
                "bg2-0": "Ninguno"
            },
            "fam-set3": {
                "bg2-13": "Nubes",
                "bg2-21": "Batalla",
                "bg2-4": "Tuberías",
                "bg2-15": "Calabozo 2",
                "bg2-36": "Nubes 2",
                "bg2-3": "Calabozo",
                "bg2-39": "Cueva 2",
                "bg2-20": "Bosque",
                "bg2-38": "Cueva",
                "bg2-1": "Bloques",
                "bg2-24": "Jefe Final",
                "bg2-23": "Tanques",
                "bg2-27": "Castillo",
                "bg2-22": "Cascada",
                "bg2-37": "Colinas de Nieve",
                "bg2-35": "Árboles de Nieve",
                "bg2-2": "Colinas",
                "bg2-14": "Desierto",
                "bg2-17": "Nave",
                "bg2-56": "Bajo el agua",
                "header": "",
                "bg2-6": "",
                "bg2-26": ""
            },
            "fam-set4": {
                "bg2-32": "Colinas 2",
                "bg2-33": "Colinas 4",
                "bg2-30": "Cueva",
                "bg2-55": "Bajo el agua",
                "bg2-58": "Noche del Desierto",
                "bg2-11": "Colinas",
                "bg2-12": "Árboles",
                "bg2-19": "Árboles",
                "bg2-18": "Mansión",
                "bg2-42": "Castillo",
                "bg2-29": "Noche",
                "bg2-43": "Castillo 2",
                "bg2-31": "Nubes",
                "bg2-34": "Colinas 3",
                "bg2-28": "",
                "header": ""
            }
        },
        "music": {
            "fam-64": {
                "music50": "Cueva",
                "music14": "Desierto",
                "music35": "Nieve",
                "music26": "Castillo",
                "music36": "Jefe",
                "music49": "Agua",
                "music27": "Tema central",
                "header": ""
            },
            "fam-misc": {
                "music55": "Tema del título",
                "music38": "Aldea de la jungla",
                "music18": "Playa",
                "music56": "Carrera de obstáculos",
                "music8": "¡Acorralado!",
                "music37": "Montaña de Hielo",
                "music23": "",
                "music20": "",
                "header": "",
                "music13": ""
            },
            "fam-fight": {
                "music39": "Templo",
                "header": "Batalla",
                "music40": "Caballero",
                "music52": "Subterráneo",
                "music53": "",
                "music19": ""
            },
            "auto": {
                "music0": "Ninguna",
                "music24": "Personalizada"
            },
            "fam-space": {
                "music11": "Pantano Rojo",
                "music22": "Carga Espacial",
                "header": "Espacio",
                "music44": "Cuarto de Objeto",
                "music12": "Cráter",
                "music45": ""
            },
            "fam-rpg": {
                "music33": "Nubes",
                "music34": "Ciudad",
                "music30": "",
                "music31": "",
                "header": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "Jefe Final",
                "music25": "Subterráneo",
                "music15": "",
                "header": "",
                "music5": ""
            },
            "fam-set3": {
                "music2": "Cielo",
                "music3": "Calabozo",
                "music6": "Jefe",
                "music4": "Subterráneo",
                "music47": "Agua",
                "music1": "",
                "music54": "",
                "header": ""
            },
            "fam-set1": {
                "music46": "Agua",
                "music42": "Calabozo",
                "music7": "Subterráneo",
                "header": "",
                "music9": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            }
        },
        "block": {
            "fam-cave4": "Cueva",
            "fam-water3": "Agua",
            "fam-pipes3": "Tuberías",
            "fam-pipes1": "Tuberías",
            "fam-pipes4": "Tuberías",
            "fam-desert3": "Desierto",
            "fam-wood2": "Madera",
            "fam-dungeon3": "Calabozo",
            "fam-clouds1": "Nubes",
            "fam-dungeon1": "Calabozo",
            "fam-grass4": "Césped",
            "fam-mansion4": "Mansión",
            "fam-special2": "Especial",
            "fam-pipes5-2": "Tuberías",
            "fam-bricks5": "Ladrillo",
            "fam-special4": "Especial",
            "fam-woods4": "Maderas",
            "fam-ruins5": "Ruinas",
            "fam-grass3": "Césped",
            "fam-house3": "Casa",
            "fam-special3": "Especial",
            "fam-cave3": "Cueva",
            "fam-wood3": "Madera",
            "fam-castle4": "Castillo",
            "fam-special1": "Especial",
            "fam-castle2": "Castillo",
            "fam-underground2": "Subterráneo",
            "fam-underground1": "Subterráneo",
            "fam-steampunk3": "",
            "fam-misc4": "",
            "fam-sized1": "",
            "fam-pipes5-3": "",
            "fam-overworld2": "",
            "fam-overworld1": "",
            "fam-hurts3": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-switch4": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-bonus4": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-sized2": ""
        },
        "bgo": {
            "fam-key4": "Llave",
            "fam-water3": "Agua",
            "fam-water4": "Agua",
            "fam-water1": "Agua",
            "fam-tiles3": "Baldosas",
            "fam-temple5": "Templo",
            "fam-structures3": "Estructuras",
            "fam-plants2": "Plantas 2",
            "fam-exit3": "Salida",
            "fam-water2": "Agua",
            "fam-plants4": "Plantas",
            "fam-bars4": "Barras",
            "fam-clouds1": "Nubes",
            "fam-plants1": "Plantas",
            "fam-doors4": "Puertas",
            "fam-plants3": "Plantas",
            "fam-fences1": "Cercas",
            "fam-fences4": "Cercas",
            "fam-doors2": "Puertas",
            "fam-ghost4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-art2": "",
            "fam-platform4": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": ""
        },
        "exit-codes": {
            "5": "Orbe #41",
            "any": "Cualquiera",
            "6": "Pasaje",
            "4": "Llave",
            "1": "Ruleta",
            "2": "Orbe #16",
            "none": "Ninguno",
            "8": "Final de Barra",
            "7": "",
            "3": "",
            "9": ""
        },
        "worldMusic": {
            "fam-world": {
                "wmusic16": "Cueva",
                "wmusic14": "Cielo",
                "wmusic15": "Isla",
                "wmusic7": "Bosque",
                "header": "Mundo",
                "wmusic12": "Especial",
                "wmusic13": "",
                "wmusic4": ""
            },
            "fam-set3": {
                "wmusic1": "Mundo 1",
                "wmusic3": "Mundo 7",
                "wmusic10": "Mundo 6",
                "wmusic11": "Mundo 5",
                "wmusic2": "Mundo 4",
                "wmusic9": "Mundo 8",
                "wmusic8": "Mundo 3",
                "wmusic6": "Mundo 2",
                "header": ""
            },
            "fam-new": {
                "header": "Nuevo",
                "wmusic5": ""
            },
            "auto": {
                "wmusic0": "Ninguno"
            }
        },
        "sound": {
            "fam-world": {
                "header": "Mundo",
                "sound28": "",
                "sound27": ""
            },
            "fam-ui": {
                "sound13": "Cámara",
                "sound11": "Soltar Objeto",
                "sound47": "Mensaje",
                "sound30": "Pausa",
                "header": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-player": {
                "sound75": "Lanzar Vegetal",
                "sound76": "Perder Corazón",
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            }
        },
        "tile": {
            "fam-wall2": "Pared de Tierra",
            "fam-stonewall3": "Pared de Piedra",
            "fam-lava3": "Lava",
            "fam-dirt2": "Césped Muerto",
            "fam-clouds4": "Nubes",
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-grass2": "",
            "fam-snow1": ""
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        }
    },
    "languageName": "Español",
    "objects": {
        "wordStarAccusativeSingular": "estrella",
        "wordFails": "Fallas",
        "wordStarAccusativePlural": "estrellas",
        "wordStarAccusativeDualOrCounter": ""
    },
    "character": {
        "name2": "",
        "name5": "",
        "name3": "",
        "name1": "",
        "name4": ""
    }
}


================================================
FILE: resources/languages/assets_fr.json
================================================
{
    "editor": {
        "background2": {
            "fam-set3": {
                "bg2-35": "Arbres Enneigés",
                "bg2-36": "Nuages 2",
                "bg2-39": "Grotte 2",
                "bg2-37": "Collines Enneigées",
                "bg2-4": "Tuyaux",
                "bg2-6": "Bonus",
                "bg2-56": "Sous-marin",
                "header": "Set 3",
                "bg2-1": "Blocs",
                "bg2-13": "Nuages",
                "bg2-14": "Désert",
                "bg2-15": "Donjon 2",
                "bg2-17": "Vaisseau",
                "bg2-22": "Chute d'eau",
                "bg2-23": "Tanks",
                "bg2-2": "Collines",
                "bg2-20": "Forêt",
                "bg2-21": "Bataille",
                "bg2-24": "Boss Final",
                "bg2-26": "Marchand de Champis",
                "bg2-27": "Château",
                "bg2-3": "Donjon",
                "bg2-38": "Grotte"
            },
            "fam-set4": {
                "bg2-55": "Sous-marin",
                "bg2-42": "Château",
                "bg2-11": "Collines",
                "bg2-12": "Arbres",
                "bg2-30": "Grotte",
                "bg2-29": "Nuit",
                "bg2-58": "Nuit Déserte",
                "bg2-32": "Collines 2",
                "bg2-33": "Collines 4",
                "bg2-34": "Collines 3",
                "bg2-43": "Château 2",
                "header": "Set 4",
                "bg2-18": "Manoir",
                "bg2-19": "Forêt",
                "bg2-28": "Bonus",
                "bg2-31": "Nuages"
            },
            "fam-misc": {
                "bg2-16": "Cratère Spacial",
                "bg2-40": "Mine Secrète",
                "bg2-45": "Marais Spacial",
                "bg2-46": "Vaisseau Spatial",
                "bg2-47": "Base Spaciale",
                "header": "Autre"
            },
            "fam-set1": {
                "bg2-10": "Plein Air",
                "bg2-41": "Château",
                "bg2-50": "Champignons",
                "bg2-51": "Désert",
                "bg2-7": "Souterrain",
                "bg2-8": "Nuit",
                "bg2-9": "Nuit 2",
                "header": "Set 1"
            },
            "fam-set2": {
                "bg2-25": "Souterrain",
                "bg2-44": "Château",
                "bg2-48": "Nuages",
                "bg2-49": "Nuit - Collines",
                "bg2-5": "Arbres",
                "bg2-52": "Nuit - Désert",
                "bg2-53": "Falaise",
                "bg2-54": "Entrepôt",
                "bg2-57": "Donjon",
                "header": "Set 2"
            },
            "auto": {
                "bg2-0": "Aucun"
            }
        },
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "character": {
        "name1": "Pers1",
        "name2": "Pers2",
        "name3": "Pers3",
        "name4": "Pers4",
        "name5": "Pers5"
    },
    "objects": {
        "wordStarAccusativeSingular": "",
        "wordFails": "",
        "wordStarAccusativePlural": "",
        "wordStarAccusativeDualOrCounter": ""
    },
    "languageName": ""
}


================================================
FILE: resources/languages/assets_hu.json
================================================
{
    "character": {
        "name2": "",
        "name5": "",
        "name3": "",
        "name1": "",
        "name4": ""
    },
    "editor": {
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "background2": {
            "fam-set1": {
                "bg2-10": "",
                "bg2-7": "",
                "bg2-9": "",
                "bg2-8": "",
                "bg2-50": "",
                "header": "",
                "bg2-41": "",
                "bg2-51": ""
            },
            "fam-set2": {
                "bg2-57": "",
                "bg2-48": "",
                "bg2-53": "",
                "bg2-49": "",
                "bg2-25": "",
                "bg2-54": "",
                "bg2-52": "",
                "bg2-5": "",
                "bg2-44": "",
                "header": ""
            },
            "fam-set3": {
                "bg2-13": "",
                "bg2-21": "",
                "bg2-4": "",
                "bg2-15": "",
                "bg2-36": "",
                "header": "",
                "bg2-6": "",
                "bg2-3": "",
                "bg2-39": "",
                "bg2-20": "",
                "bg2-38": "",
                "bg2-26": "",
                "bg2-1": "",
                "bg2-24": "",
                "bg2-23": "",
                "bg2-27": "",
                "bg2-22": "",
                "bg2-37": "",
                "bg2-35": "",
                "bg2-2": "",
                "bg2-14": "",
                "bg2-17": "",
                "bg2-56": ""
            },
            "fam-misc": {
                "header": "",
                "bg2-16": "",
                "bg2-46": "",
                "bg2-47": "",
                "bg2-40": "",
                "bg2-45": ""
            },
            "fam-set4": {
                "bg2-28": "",
                "bg2-32": "",
                "header": "",
                "bg2-33": "",
                "bg2-30": "",
                "bg2-55": "",
                "bg2-58": "",
                "bg2-11": "",
                "bg2-12": "",
                "bg2-19": "",
                "bg2-18": "",
                "bg2-42": "",
                "bg2-29": "",
                "bg2-43": "",
                "bg2-31": "",
                "bg2-34": ""
            },
            "auto": {
                "bg2-0": ""
            }
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "",
        "wordFails": "",
        "wordStarAccusativePlural": "",
        "wordStarAccusativeDualOrCounter": ""
    },
    "languageName": ""
}


================================================
FILE: resources/languages/assets_it.json
================================================
{
    "editor": {
        "background2": {
            "fam-set1": {
                "bg2-51": "Deserto",
                "bg2-9": "Notte 2",
                "bg2-10": "Aria aperta",
                "bg2-41": "Castello",
                "bg2-50": "Funghi",
                "bg2-7": "Sotterraneo",
                "bg2-8": "Notte",
                "header": "Set 1"
            },
            "fam-set3": {
                "bg2-13": "Nuvole",
                "bg2-36": "Nuvole 2",
                "bg2-38": "Caverna",
                "bg2-39": "Caverna 2",
                "bg2-4": "Tubi",
                "bg2-6": "Bonus",
                "bg2-56": "Sott'acqua",
                "bg2-1": "Blocchi",
                "bg2-14": "Deserto",
                "bg2-17": "Nave",
                "bg2-2": "Colline",
                "bg2-20": "Foresta",
                "bg2-21": "Battaglia",
                "bg2-22": "Cascata",
                "bg2-23": "Carri armati",
                "bg2-24": "Boss finale",
                "bg2-27": "Castello",
                "bg2-35": "Alberi innevati",
                "bg2-37": "Colline innevate",
                "bg2-15": "Cripta 2",
                "bg2-3": "Cripta",
                "header": "Set 3",
                "bg2-26": ""
            },
            "auto": {
                "bg2-0": "Nessuno"
            },
            "fam-misc": {
                "bg2-16": "Cratere spaziale",
                "bg2-40": "Miniera segreta",
                "bg2-46": "Nave spaziale",
                "bg2-45": "Palude spaziale",
                "bg2-47": "Base spaziale",
                "header": "Varie"
            },
            "fam-set4": {
                "bg2-11": "Colline",
                "bg2-12": "Alberi",
                "bg2-18": "Villa",
                "bg2-28": "Bonus",
                "bg2-19": "Foresta",
                "bg2-31": "Nuvole",
                "bg2-29": "Notte",
                "bg2-34": "Colline 3",
                "bg2-30": "Caverna",
                "bg2-32": "Colline 2",
                "bg2-33": "Colline 4",
                "bg2-42": "Castello",
                "bg2-43": "Castello 2",
                "bg2-55": "Sott'acqua",
                "bg2-58": "Deserto (notte)",
                "header": "Set 4"
            },
            "fam-set2": {
                "bg2-25": "Sotterraneo",
                "bg2-44": "Castello",
                "bg2-48": "Nuvole",
                "bg2-49": "Notte - Colline",
                "bg2-5": "Alberi",
                "bg2-52": "Notte - Deserto",
                "bg2-53": "Scogliera",
                "bg2-54": "Magazzino",
                "bg2-57": "Cripta",
                "header": "Set 2"
            }
        },
        "bgo": {
            "fam-key4": "Chiave",
            "fam-hut1": "Capanna",
            "fam-misc4": "Varie",
            "fam-plants1": "Piante",
            "fam-plants2": "Piante",
            "fam-temple5": "Tempio",
            "fam-plants3": "Piante",
            "fam-plants4": "Piante",
            "fam-structures3": "Strutture",
            "fam-clouds1": "Nuvole",
            "fam-doors2": "Porte",
            "fam-doors4": "Porte",
            "fam-exit3": "Uscita",
            "fam-fences1": "Recinzioni",
            "fam-fences4": "Recinzioni",
            "fam-ghost4": "Fantasma",
            "fam-tiles3": "Blocchi",
            "fam-water1": "Acqua",
            "fam-water2": "Acqua",
            "fam-water3": "Acqua",
            "fam-water4": "Acqua",
            "fam-sandbg3": "",
            "fam-art2": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-space5": "",
            "fam-sandfg3": ""
        },
        "block": {
            "fam-special3": "Speciale",
            "fam-misc1": "Varie",
            "fam-misc4": "Varie",
            "fam-pipes4": "Tubi",
            "fam-special1": "Speciale",
            "fam-pipes5-2": "Tubi",
            "fam-special2": "Speciale",
            "fam-special4": "Speciale",
            "fam-underground1": "Sotterraneo",
            "fam-underground2": "Sotterraneo",
            "fam-wood2": "Legno",
            "fam-water3": "Acqua",
            "fam-bonus3": "Bonus",
            "fam-bonus4": "Bonus",
            "fam-bricks5": "Mattone",
            "fam-castle2": "Castello",
            "fam-castle4": "Castello",
            "fam-cave3": "Caverna",
            "fam-cave4": "Caverna",
            "fam-clouds1": "Nuvole",
            "fam-desert3": "Deserto",
            "fam-grass3": "Erba",
            "fam-grass4": "Erba",
            "fam-house3": "Casa",
            "fam-mansion4": "Villa",
            "fam-metal5-3": "Varie",
            "fam-dungeon1": "Cripta",
            "fam-dungeon3": "Cripta",
            "fam-char5": "Personaggio",
            "fam-misc2": "Varie",
            "fam-misc3": "Varie 3",
            "fam-overworld1": "Aria aperta",
            "fam-overworld2": "Aria aperta",
            "fam-pipes1": "Tubi",
            "fam-pipes3": "Tubi",
            "fam-pipes5-3": "Tubi lunghi",
            "fam-ruins5": "Rovine",
            "fam-wood3": "Legno",
            "fam-woods4": "Bosco",
            "fam-steampunk3": "",
            "fam-sized1": "",
            "fam-hurts3": "",
            "fam-sized4": "",
            "fam-switch4": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-sized2": ""
        },
        "music": {
            "fam-misc": {
                "header": "Varie",
                "music37": "Montagna ghiacciata",
                "music18": "Spiaggia",
                "music23": "Bosco eroico",
                "music38": "Villaggio della giungla",
                "music55": "Tema del titolo",
                "music56": "",
                "music20": "",
                "music8": "",
                "music13": ""
            },
            "fam-fight": {
                "music52": "Sotterraneo",
                "music39": "Tempio",
                "music40": "Cavaliere",
                "music53": "",
                "music19": "",
                "header": ""
            },
            "fam-rpg": {
                "music34": "Città",
                "header": "RPG",
                "music16": "Foresta",
                "music21": "Battaglia",
                "music31": "Mare",
                "music32": "Stagno",
                "music33": "Nuvole",
                "music30": ""
            },
            "fam-set3": {
                "music1": "Aria aperta",
                "music3": "Cripta",
                "music4": "Sotterraneo",
                "header": "Set 3",
                "music2": "",
                "music6": "",
                "music54": "",
                "music47": ""
            },
            "fam-world": {
                "music10": "Aria aperta",
                "music41": "Cripta",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-64": {
                "music14": "Deserto",
                "music26": "Castello",
                "music27": "Tema principale",
                "music35": "Neve",
                "music36": "Boss",
                "music49": "Acqua",
                "music50": "Caverna",
                "header": ""
            },
            "fam-set1": {
                "music42": "Cripta",
                "music9": "Aria aperta",
                "music7": "Sotterraneo",
                "header": "Set 1",
                "music46": ""
            },
            "fam-set2": {
                "music5": "Aria aperta",
                "music25": "Sotterraneo",
                "header": "Set 2",
                "music43": "",
                "music15": ""
            },
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "worldMusic": {
            "fam-set3": {
                "header": "Set 3",
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "Cripta",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "npc": {
            "fam-char3": "Personaggio",
            "fam-char5": "Personaggio",
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "exit-codes": {
            "4": "Chiave",
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        }
    },
    "character": {
        "name1": "Personaggio1",
        "name2": "Personaggio2",
        "name3": "Personaggio3",
        "name4": "Personaggio4",
        "name5": "Personaggio5"
    },
    "objects": {
        "wordStarAccusativePlural": "stelle",
        "wordStarAccusativeSingular": "stella",
        "wordStarAccusativeDualOrCounter": "",
        "wordFails": ""
    },
    "languageName": ""
}


================================================
FILE: resources/languages/assets_ja.json
================================================
{
    "character": {
        "name2": "Char2",
        "name5": "Char5",
        "name3": "Char3",
        "name1": "Char1",
        "name4": "Char4"
    },
    "editor": {
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "オブジェ",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "background2": {
            "fam-set1": {
                "bg2-10": "地上",
                "bg2-7": "地下",
                "bg2-9": "夜 2",
                "bg2-8": "夜",
                "bg2-50": "キノコ",
                "header": "セット 1",
                "bg2-41": "お城",
                "bg2-51": "さばく"
            },
            "fam-set2": {
                "bg2-57": "ダンジョン",
                "bg2-48": "雲の上",
                "bg2-53": "ガケ",
                "bg2-49": "夜の丘",
                "bg2-25": "地下",
                "bg2-54": "倉庫",
                "bg2-52": "夜のさばく",
                "bg2-5": "森",
                "bg2-44": "お城",
                "header": "セット 2"
            },
            "fam-set3": {
                "bg2-13": "くもの上",
                "bg2-21": "バトルコース",
                "bg2-4": "下水道",
                "bg2-15": "ダンジョン 2",
                "bg2-36": "くもの上 2",
                "header": "セット 3",
                "bg2-6": "ボーナス",
                "bg2-3": "ダンジョン",
                "bg2-39": "洞窟 2",
                "bg2-20": "森",
                "bg2-38": "洞窟",
                "bg2-26": "キノピオハウス",
                "bg2-1": "ブロック",
                "bg2-24": "ラスボス",
                "bg2-23": "戦車",
                "bg2-27": "お城",
                "bg2-22": "滝",
                "bg2-37": "雪国の丘",
                "bg2-35": "雪国の林",
                "bg2-2": "丘",
                "bg2-14": "さばく",
                "bg2-17": "飛行船",
                "bg2-56": "水中"
            },
            "fam-misc": {
                "header": "その他",
                "bg2-16": "宇宙クレーター",
                "bg2-46": "宇宙船",
                "bg2-47": "うちゅう基地",
                "bg2-40": "ヒミツの坑道",
                "bg2-45": "宇宙の沼地"
            },
            "fam-set4": {
                "bg2-28": "宮殿",
                "bg2-32": "丘 2",
                "header": "セット 4",
                "bg2-33": "丘 4",
                "bg2-30": "洞窟",
                "bg2-55": "水中",
                "bg2-58": "夜のさばく",
                "bg2-11": "丘",
                "bg2-12": "森",
                "bg2-19": "夜の森",
                "bg2-18": "おばけやしき",
                "bg2-42": "お城",
                "bg2-29": "夜",
                "bg2-43": "お城 2",
                "bg2-31": "くもの上",
                "bg2-34": "丘3"
            },
            "auto": {
                "bg2-0": "なし"
            }
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "スター",
        "wordStarAccusativeDualOrCounter": "スター",
        "wordFails": "ミス数",
        "wordStarAccusativePlural": "スター"
    },
    "languageName": "日本語"
}


================================================
FILE: resources/languages/assets_ko.json
================================================
{
    "editor": {
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "세계 5",
                "wmusic10": "세계 6",
                "wmusic2": "세계 4",
                "wmusic1": "세계 1",
                "wmusic9": "세계 8",
                "header": "세트 3",
                "wmusic3": "세계 7",
                "wmusic8": "세계 3",
                "wmusic6": "세계 2"
            },
            "fam-world": {
                "wmusic13": "지하 감옥",
                "wmusic4": "테마",
                "header": "세계",
                "wmusic12": "특수",
                "wmusic16": "동굴",
                "wmusic14": "하늘",
                "wmusic15": "섬",
                "wmusic7": "숲"
            },
            "auto": {
                "wmusic0": "없음"
            },
            "fam-new": {
                "header": "새로운",
                "wmusic5": "테마"
            }
        },
        "music": {
            "fam-space": {
                "music11": "붉은 늪",
                "music22": "우주 임무",
                "header": "우주",
                "music45": "마지막 보스",
                "music44": "아이템 방",
                "music12": "분화구"
            },
            "fam-64": {
                "music50": "동굴",
                "music14": "사막",
                "music35": "눈",
                "music26": "성",
                "music36": "보스",
                "music49": "물",
                "music27": "주요 테마",
                "header": "64"
            },
            "fam-misc": {
                "music55": "타이틀 테마",
                "music56": "활기 넘치는 경주",
                "music37": "얼어붙은 산",
                "music38": "정글 마을",
                "music23": "영웅의 숲",
                "music18": "해변",
                "music20": "핵융합로",
                "header": "기타",
                "music8": "궁지에 몰렸다!",
                "music13": "새로운 저승"
            },
            "fam-rpg": {
                "music33": "구름",
                "music30": "학사 패드",
                "music31": "해안",
                "header": "롤플레잉 게임",
                "music34": "마을",
                "music21": "전투",
                "music16": "숲",
                "music32": "연못"
            },
            "fam-set2": {
                "music43": "마지막 보스",
                "music15": "보스",
                "header": "세트 2",
                "music5": "저승",
                "music25": "지하"
            },
            "fam-world": {
                "music41": "지하 감옥",
                "music10": "저승",
                "header": "세계",
                "music28": "하늘",
                "music51": "보스",
                "music48": "물",
                "music29": "동굴",
                "music17": "맨션"
            },
            "fam-set3": {
                "music2": "하늘",
                "music3": "지하 감옥",
                "music1": "저승",
                "music6": "보스",
                "music54": "배회하는 적",
                "header": "세트 3",
                "music4": "지하",
                "music47": "물"
            },
            "fam-set1": {
                "header": "세트 1",
                "music9": "저승",
                "music46": "물",
                "music42": "지하 감옥",
                "music7": "지하"
            },
            "fam-fight": {
                "music53": "핀볼",
                "music39": "사원",
                "music19": "스팀펑크",
                "header": "싸움",
                "music40": "기사",
                "music52": "지하"
            },
            "auto": {
                "music0": "없음",
                "music24": "커스텀"
            }
        },
        "block": {
            "fam-steampunk3": "스팀펑크",
            "fam-cave4": "동굴",
            "fam-misc4": "기타",
            "fam-water3": "물",
            "fam-sized1": "크기",
            "fam-pipes3": "파이프",
            "fam-pipes1": "파이프",
            "fam-pipes5-3": "긴 파이프",
            "fam-pipes4": "파이프",
            "fam-desert3": "사막",
            "fam-overworld2": "저승",
            "fam-wood2": "목재",
            "fam-underground2": "지하",
            "fam-overworld1": "저승",
            "fam-dungeon3": "지하 감옥",
            "fam-hurts3": "상처",
            "fam-clouds1": "구름",
            "fam-dungeon1": "지하 감옥",
            "fam-sized4": "크기",
            "fam-bonus3": "보너스",
            "fam-grass4": "잔디",
            "fam-mansion4": "맨션",
            "fam-special2": "특수",
            "fam-switch4": "스위치",
            "fam-pipes5-2": "파이프",
            "fam-bricks5": "벽돌",
            "fam-special4": "특수",
            "fam-woods4": "목재",
            "fam-ruins5": "유적",
            "fam-grass3": "잔디",
            "fam-misc2": "기타",
            "fam-char5": "캐릭터",
            "fam-misc3": "기타 3",
            "fam-metal5-3": "기타",
            "fam-house3": "집",
            "fam-special3": "특수",
            "fam-bonus4": "보너스",
            "fam-underground1": "지하",
            "fam-cave3": "동굴",
            "fam-wood3": "목재",
            "fam-sized3": "크기 3",
            "fam-lava4": "용암과 상처",
            "fam-metal5-1": "접시",
            "fam-misc1": "기타",
            "fam-castle4": "성",
            "fam-special1": "특수",
            "fam-sized2": "크기",
            "fam-castle2": "성"
        },
        "bgo": {
            "fam-ghost4": "유령",
            "fam-key4": "열쇠",
            "fam-misc4": "기타",
            "fam-sandbg3": "모래 BG",
            "fam-water3": "물",
            "fam-water4": "물",
            "fam-water1": "물",
            "fam-tiles3": "타일",
            "fam-temple5": "사원",
            "fam-art2": "예술",
            "fam-structures3": "구조",
            "fam-plants2": "식물",
            "fam-exit3": "종료",
            "fam-water2": "물",
            "fam-plants4": "식물",
            "fam-bars4": "막대",
            "fam-platform4": "플랫폼",
            "fam-clouds1": "구름",
            "fam-plants1": "식물",
            "fam-doors4": "문",
            "fam-plants3": "식물",
            "fam-fences1": "울타리",
            "fam-hut1": "오두막",
            "fam-space5": "우주벌레",
            "fam-sandfg3": "전망",
            "fam-fences4": "울타리",
            "fam-doors2": "문"
        },
        "background2": {
            "fam-set1": {
                "bg2-10": "저승",
                "bg2-7": "지하",
                "bg2-9": "밤 2",
                "bg2-8": "밤",
                "bg2-50": "버섯",
                "header": "세트 1",
                "bg2-41": "성",
                "bg2-51": "사막"
            },
            "fam-set2": {
                "bg2-57": "지하 감옥",
                "bg2-48": "구름",
                "bg2-53": "절벽",
                "bg2-49": "밤 - 언덕",
                "bg2-25": "지하",
                "bg2-54": "창고",
                "bg2-52": "밤 - 사막",
                "bg2-5": "나무",
                "bg2-44": "성",
                "header": "세트 2"
            },
            "fam-set3": {
                "bg2-13": "구름",
                "bg2-21": "전투",
                "bg2-4": "파이프",
                "bg2-15": "지하 감옥 2",
                "bg2-36": "구름 2",
                "header": "세트 3",
                "bg2-6": "보너스",
                "bg2-3": "지하 감옥",
                "bg2-39": "동굴 2",
                "bg2-20": "숲",
                "bg2-38": "동굴",
                "bg2-26": "버섯 딜러",
                "bg2-1": "블록",
                "bg2-24": "최종 보스",
                "bg2-23": "탱크",
                "bg2-27": "성",
                "bg2-22": "폭포",
                "bg2-37": "언 덮힌 언덕",
                "bg2-35": "눈 덮힌 나무",
                "bg2-2": "언덕",
                "bg2-14": "사막",
                "bg2-17": "배",
                "bg2-56": "수중"
            },
            "fam-misc": {
                "header": "기타",
                "bg2-16": "우주 분화구",
                "bg2-46": "우주선",
                "bg2-47": "우주 기지",
                "bg2-40": "비밀 광산",
                "bg2-45": "우주 늪"
            },
            "fam-set4": {
                "bg2-28": "보너스",
                "bg2-32": "언덕 2",
                "header": "세트 4",
                "bg2-33": "언덕 4",
                "bg2-30": "동굴",
                "bg2-55": "수중",
                "bg2-58": "사막의 밤",
                "bg2-11": "언덕",
                "bg2-12": "나무",
                "bg2-19": "숲",
                "bg2-18": "맨션",
                "bg2-42": "성",
                "bg2-29": "밤",
                "bg2-43": "성 2",
                "bg2-31": "구름",
                "bg2-34": "언덕 3"
            },
            "auto": {
                "bg2-0": "없음"
            }
        },
        "npc": {
            "fam-sign4": "표시",
            "fam-plat3": "플랫폼",
            "fam-blocks2": "블록",
            "fam-enemies5": "적",
            "fam-shell1": "조개",
            "fam-boss5": "보스",
            "fam-veg2": "채소",
            "fam-boss1": "보스",
            "fam-boss4": "보스",
            "fam-char3": "캐릭터",
            "fam-warp2": "워프",
            "fam-shell3": "조개",
            "fam-plant3": "식물",
            "fam-vine1": "덩굴",
            "fam-items1": "아이템",
            "fam-exit3": "종료",
            "fam-boss2": "보스",
            "fam-enemies3": "적",
            "fam-exit4": "종료",
            "fam-boss3": "보스",
            "fam-vine3": "덩굴",
            "fam-plat4": "플랫폼",
            "fam-plat1": "플랫폼",
            "fam-char5": "캐릭터",
            "fam-pet4": "애완 동물",
            "fam-items5": "아이템",
            "fam-items3": "아이템",
            "fam-blocks3": "블록",
            "fam-enemies1": "적",
            "fam-enemies2": "적",
            "fam-ckpt4": "체크포인트",
            "fam-vine4": "덩굴",
            "fam-switch5": "스위치",
            "fam-vine2": "덩굴",
            "fam-exit2": "종료",
            "fam-items2": "아이템",
            "fam-items4": "아이템",
            "fam-enemies4": "적"
        },
        "sound": {
            "fam-player": {
                "sound54": "플레이어 사망 2",
                "sound24": "스프링",
                "sound73": "가볍게 붙잡다",
                "sound12": "아이템 획득",
                "sound34": "너구리",
                "sound75": "채소 던지기",
                "sound72": "수영",
                "header": "플레이어",
                "sound25": "망치 던지기",
                "sound18": "파이어볼",
                "sound35": "부츠 분실",
                "sound46": "문",
                "sound15": "생명력+1",
                "sound76": "낙담",
                "sound5": "수축",
                "sound71": "등산",
                "sound33": "꼬리",
                "sound1": "점프",
                "sound23": "붙잡다",
                "sound17": "워프",
                "sound10": "미끄러짐",
                "sound6": "성장",
                "sound2": "쿵쿵"
            },
            "auto": {
                "sound0": "없음"
            },
            "fam-jingle": {
                "sound8": "플레이어 사망",
                "sound20": "보스 격파",
                "sound60": "막대 종료",
                "sound45": "게임 우승",
                "header": "징글",
                "sound52": "별 종료 획득",
                "sound40": "공 종료",
                "sound31": "열쇠 종료",
                "sound19": "룰렛 종료",
                "sound21": "지하 감옥 클리어"
            },
            "fam-boss": {
                "sound67": "깨진 유리",
                "sound41": "새 퍼덕임",
                "sound69": "우주 보스 울기",
                "sound39": "새 공격",
                "sound38": "새 침",
                "sound70": "우주 보스 처치",
                "sound44": "거북이 처치",
                "header": "보스",
                "sound63": "개구리 처치",
                "sound68": "우주 보스 히트",
                "sound62": "개구리 거품"
            },
            "fam-hero": {
                "sound83": "영웅 아이템",
                "sound84": "열쇠 획득",
                "sound88": "잔디깎기",
                "sound86": "헤르메스 부츠",
                "sound87": "비행",
                "header": "영웅",
                "sound82": "영웅의 불",
                "sound80": "영웅 사망",
                "sound77": "영웅 찌르기",
                "sound81": "보석 획득",
                "sound85": "방패 블록",
                "sound53": "영웅 NPC 처치",
                "sound78": "영웅 상처",
                "sound79": "하트 획득"
            },
            "fam-item": {
                "sound4": "블록 박살",
                "sound14": "동전",
                "sound22": "총알",
                "sound16": "용암",
                "sound61": "용암 생물",
                "sound74": "톱",
                "sound9": "조개 킥",
                "sound64": "우주 블록 격파",
                "sound3": "블록 격파",
                "sound56": "고리",
                "sound7": "파워업",
                "sound59": "소장용",
                "header": "아이템",
                "sound65": "우주 NPC 처치",
                "sound32": "스위치",
                "sound51": "계란 해치",
                "sound57": "해골",
                "sound66": "우주 NPC 상처",
                "sound43": "불꽃",
                "sound42": "큰 파이어볼",
                "sound58": "체크포인트",
                "sound37": "파쇄기"
            },
            "fam-pet": {
                "sound55": "애완 동물 제비",
                "sound48": "애완동물 장착",
                "sound49": "애완 동물 상처",
                "sound50": "애완 동물 혀",
                "header": "애완 동물",
                "sound36": "애완동물 쿵쿵"
            },
            "fam-ui": {
                "sound11": "아이템 내려놓기",
                "header": "사용자 인터페이스",
                "sound13": "카메라",
                "sound30": "일시정지",
                "sound47": "메세지",
                "sound29": "행동",
                "sound26": "스크롤"
            },
            "fam-world": {
                "header": "세계",
                "sound28": "레벨 선택",
                "sound27": "새로운 경로"
            }
        },
        "tile": {
            "fam-desert1": "먼지",
            "fam-lilac4": "라일락 벽",
            "fam-grass1": "오래된 잔디",
            "fam-dirt2": "죽은 잔디",
            "fam-marble3": "대리석",
            "fam-granite3": "화강암",
            "fam-stonewall3": "돌벽",
            "fam-clouds4": "구름",
            "fam-grass2": "행복한 잔디",
            "fam-snow1": "오래된 눈",
            "fam-wall2": "흙벽",
            "fam-lava3": "용암"
        },
        "exit-codes": {
            "7": "수집",
            "5": "오브 #41",
            "any": "어느",
            "6": "워프",
            "3": "출구",
            "4": "열쇠",
            "8": "막대 끝",
            "1": "룰렛",
            "2": "오브 #16",
            "none": "없음",
            "9": ""
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "별",
        "wordStarAccusativeDualOrCounter": "<영어에서는 사용되지 않음, 귀하의 언어에 이중 형식 (복수와 단수 사이의 숫자)이 있는 경우 이중 형식에서 \"별\"로 번역하세요. 귀하의 언어에 반대 단어가 있는 경우 대신 반대 단어를 사용하세요.>",
        "wordFails": "실패",
        "wordStarAccusativePlural": "별"
    },
    "character": {
        "name1": "캐릭터1",
        "name2": "캐릭터2",
        "name3": "캐릭터3",
        "name4": "캐릭터4",
        "name5": "캐릭터5"
    },
    "languageName": "한국어"
}


================================================
FILE: resources/languages/assets_nb-no.json
================================================
{
    "character": {
        "name2": "",
        "name5": "",
        "name3": "",
        "name1": "",
        "name4": ""
    },
    "editor": {
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "background2": {
            "fam-set1": {
                "bg2-10": "",
                "bg2-7": "",
                "bg2-9": "",
                "bg2-8": "",
                "bg2-50": "",
                "header": "",
                "bg2-41": "",
                "bg2-51": ""
            },
            "fam-set2": {
                "bg2-57": "",
                "bg2-48": "",
                "bg2-53": "",
                "bg2-49": "",
                "bg2-25": "",
                "bg2-54": "",
                "bg2-52": "",
                "bg2-5": "",
                "bg2-44": "",
                "header": ""
            },
            "fam-set3": {
                "bg2-13": "",
                "bg2-21": "",
                "bg2-4": "",
                "bg2-15": "",
                "bg2-36": "",
                "header": "",
                "bg2-6": "",
                "bg2-3": "",
                "bg2-39": "",
                "bg2-20": "",
                "bg2-38": "",
                "bg2-26": "",
                "bg2-1": "",
                "bg2-24": "",
                "bg2-23": "",
                "bg2-27": "",
                "bg2-22": "",
                "bg2-37": "",
                "bg2-35": "",
                "bg2-2": "",
                "bg2-14": "",
                "bg2-17": "",
                "bg2-56": ""
            },
            "fam-misc": {
                "header": "",
                "bg2-16": "",
                "bg2-46": "",
                "bg2-47": "",
                "bg2-40": "",
                "bg2-45": ""
            },
            "fam-set4": {
                "bg2-28": "",
                "bg2-32": "",
                "header": "",
                "bg2-33": "",
                "bg2-30": "",
                "bg2-55": "",
                "bg2-58": "",
                "bg2-11": "",
                "bg2-12": "",
                "bg2-19": "",
                "bg2-18": "",
                "bg2-42": "",
                "bg2-29": "",
                "bg2-43": "",
                "bg2-31": "",
                "bg2-34": ""
            },
            "auto": {
                "bg2-0": ""
            }
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "",
        "wordFails": "",
        "wordStarAccusativePlural": "",
        "wordStarAccusativeDualOrCounter": ""
    },
    "languageName": ""
}


================================================
FILE: resources/languages/assets_pl.json
================================================
{
    "character": {
        "name2": "",
        "name5": "",
        "name3": "",
        "name1": "",
        "name4": ""
    },
    "editor": {
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "background2": {
            "fam-set1": {
                "bg2-10": "",
                "bg2-7": "",
                "bg2-9": "",
                "bg2-8": "",
                "bg2-50": "",
                "header": "",
                "bg2-41": "",
                "bg2-51": ""
            },
            "fam-set2": {
                "bg2-57": "",
                "bg2-48": "",
                "bg2-53": "",
                "bg2-49": "",
                "bg2-25": "",
                "bg2-54": "",
                "bg2-52": "",
                "bg2-5": "",
                "bg2-44": "",
                "header": ""
            },
            "fam-set3": {
                "bg2-13": "",
                "bg2-21": "",
                "bg2-4": "",
                "bg2-15": "",
                "bg2-36": "",
                "header": "",
                "bg2-6": "",
                "bg2-3": "",
                "bg2-39": "",
                "bg2-20": "",
                "bg2-38": "",
                "bg2-26": "",
                "bg2-1": "",
                "bg2-24": "",
                "bg2-23": "",
                "bg2-27": "",
                "bg2-22": "",
                "bg2-37": "",
                "bg2-35": "",
                "bg2-2": "",
                "bg2-14": "",
                "bg2-17": "",
                "bg2-56": ""
            },
            "fam-misc": {
                "header": "",
                "bg2-16": "",
                "bg2-46": "",
                "bg2-47": "",
                "bg2-40": "",
                "bg2-45": ""
            },
            "fam-set4": {
                "bg2-28": "",
                "bg2-32": "",
                "header": "",
                "bg2-33": "",
                "bg2-30": "",
                "bg2-55": "",
                "bg2-58": "",
                "bg2-11": "",
                "bg2-12": "",
                "bg2-19": "",
                "bg2-18": "",
                "bg2-42": "",
                "bg2-29": "",
                "bg2-43": "",
                "bg2-31": "",
                "bg2-34": ""
            },
            "auto": {
                "bg2-0": ""
            }
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "",
        "wordStarAccusativeDualOrCounter": "",
        "wordFails": "",
        "wordStarAccusativePlural": ""
    },
    "languageName": ""
}


================================================
FILE: resources/languages/assets_pt-br.json
================================================
{
    "editor": {
        "sound": {
            "fam-boss": {
                "sound67": "Quebra Vidro",
                "sound70": "Morte do Chefe Espacial",
                "sound38": "Cuspe de Pássaro",
                "sound39": "Batida do Pássaro",
                "sound41": "Pássaro Derrotado",
                "sound44": "Tartaruga Morta",
                "header": "Chefe",
                "sound62": "Bolhas de Sapo",
                "sound68": "Bateu Chefe Espacial",
                "sound63": "Sapo Morto",
                "sound69": "Grito do Chefe Espacial"
            },
            "fam-hero": {
                "sound53": "Morte do NPC de Herói",
                "sound79": "Pegar Coração",
                "sound81": "Pegar Gema",
                "sound82": "Fogo do Herói",
                "sound83": "Item do Herói",
                "sound84": "Pegar Chave",
                "sound86": "Botas de Hermes",
                "sound87": "Voar",
                "header": "Herói",
                "sound77": "Estocada do Herói",
                "sound78": "Herói Machucado",
                "sound80": "Morte do Herói",
                "sound85": "Defesa com Escudo",
                "sound88": "Cortar Grama"
            },
            "fam-item": {
                "header": "Item",
                "sound16": "Lava",
                "sound22": "Bala",
                "sound32": "Altern",
                "sound37": "Quebrador",
                "sound42": "Bola de Fogo Grande",
                "sound43": "Fogos de Artificio",
                "sound58": "Ponto de Ressurgimento",
                "sound14": "Moeda",
                "sound3": "Bater Bloco",
                "sound4": "Bloco Esmagado",
                "sound51": "Ovo Chocado",
                "sound56": "Anel",
                "sound57": "Esqueleto",
                "sound59": "Coletável",
                "sound66": "Machucar NPC Espacial",
                "sound7": "Aumento de Poder",
                "sound74": "Serra",
                "sound9": "Chutar Casco",
                "sound61": "Criatura de Lava",
                "sound64": "Bateu Bloco Espacial",
                "sound65": "NPC Espacial Morto"
            },
            "fam-jingle": {
                "sound21": "Masmorra Completa",
                "sound31": "Saída da Chave",
                "header": "Toque",
                "sound19": "Saída da Roleta",
                "sound20": "Derrota do Chefe",
                "sound40": "Saída da Bola",
                "sound45": "Jogo Superado",
                "sound52": "Pegou uma Estrela de Saída",
                "sound60": "Barra de Saída",
                "sound8": "Morte de Jogador"
            },
            "fam-pet": {
                "sound36": "Pisoteada do Mascote",
                "sound48": "Montar no Mascote",
                "sound55": "Mascote Engolindo",
                "header": "Mascote",
                "sound50": "Língua do Mascote",
                "sound49": "Mascote Machucado"
            },
            "fam-player": {
                "sound1": "Pulo",
                "sound10": "Desliza",
                "sound12": "Pegou Item",
                "sound18": "Bola de Fogo",
                "sound25": "Jogada de Martelo",
                "sound34": "Guaxinim",
                "sound75": "Jogar Vegetal",
                "sound17": "Teleporte",
                "header": "Jogador",
                "sound15": "1 Vida",
                "sound2": "Pisoteada",
                "sound24": "Mola",
                "sound23": "Agarrar",
                "sound33": "Cauda",
                "sound35": "Perdeu Bota",
                "sound5": "Encolheu",
                "sound73": "Levemente Agarrado",
                "sound76": "Perdeu Coração",
                "sound6": "Cresceu",
                "sound71": "Subindo",
                "sound72": "Nadando",
                "sound46": "Porta",
                "sound54": "Morte de Jogador (2)"
            },
            "fam-ui": {
                "header": "Interface",
                "sound47": "Mensagem",
                "sound11": "Queda de Item",
                "sound13": "Câmera",
                "sound26": "Escorregar",
                "sound30": "Pausa",
                "sound29": "Fazer"
            },
            "fam-world": {
                "sound27": "Novo Caminho",
                "sound28": "Seleção de Nível",
                "header": "Mundo"
            },
            "auto": {
                "sound0": "Nenhum"
            }
        },
        "tile": {
            "fam-dirt2": "Grama Morta",
            "fam-granite3": "Granito",
            "fam-lava3": "Lava",
            "fam-lilac4": "Parede Lilás",
            "fam-grass1": "Grama Antiga",
            "fam-snow1": "Neve Antiga",
            "fam-clouds4": "Nuvens",
            "fam-desert1": "Areia",
            "fam-grass2": "Grama Viva",
            "fam-marble3": "Mármore",
            "fam-stonewall3": "Parede de Pedra",
            "fam-wall2": "Parede de Terra"
        },
        "worldMusic": {
            "fam-world": {
                "wmusic7": "Floresta",
                "wmusic12": "Especial",
                "header": "Mundo",
                "wmusic14": "Céu",
                "wmusic13": "Masmorra",
                "wmusic15": "Ilha",
                "wmusic16": "Caverna",
                "wmusic4": "Tema"
            },
            "auto": {
                "wmusic0": "Nenhum"
            },
            "fam-new": {
                "header": "Novo",
                "wmusic5": "Tema"
            },
            "fam-set3": {
                "wmusic11": "Mundo 5",
                "header": "Conjunto 3",
                "wmusic2": "Mundo 4",
                "wmusic1": "Mundo 1",
                "wmusic10": "Mundo 6",
                "wmusic3": "Mundo 7",
                "wmusic6": "Mundo 2",
                "wmusic8": "Mundo 3",
                "wmusic9": "Mundo 8"
            }
        },
        "background2": {
            "fam-misc": {
                "bg2-16": "Cratera Espacial",
                "bg2-40": "Mina Secreta",
                "bg2-45": "Pântano Espacial",
                "bg2-46": "Nave Espacial",
                "header": "Outro",
                "bg2-47": "Base Espacial"
            },
            "fam-set1": {
                "bg2-41": "Castelo",
                "bg2-50": "Cogumelos",
                "bg2-51": "Deserto",
                "bg2-7": "Subterrâneo",
                "bg2-8": "Noite",
                "bg2-9": "Noite (2)",
                "bg2-10": "Mundo sup",
                "header": "Conjunto 1"
            },
            "fam-set2": {
                "bg2-25": "Subterrâneo",
                "bg2-44": "Castelo",
                "bg2-48": "Nuvens",
                "bg2-49": "Noite - Colinas",
                "bg2-5": "Árvores",
                "bg2-53": "Penhasco",
                "bg2-54": "Armazém",
                "bg2-57": "Masmorra",
                "bg2-52": "Noite - Deserto",
                "header": "Conjunto 2"
            },
            "fam-set3": {
                "bg2-1": "Blocos",
                "bg2-15": "Masmorra (2)",
                "bg2-20": "Floresta",
                "bg2-22": "Cachoeira",
                "bg2-23": "Tanques",
                "bg2-27": "Castelo",
                "bg2-3": "Masmorra",
                "bg2-36": "Nuvens (2)",
                "bg2-38": "Caverna",
                "bg2-39": "Caverna (2)",
                "bg2-56": "Subaquático",
                "bg2-6": "Bônus",
                "bg2-4": "Canos",
                "header": "Conjunto 3",
                "bg2-13": "Nuvens",
                "bg2-14": "Deserto",
                "bg2-17": "Navio",
                "bg2-2": "Colinas",
                "bg2-21": "Batalha",
                "bg2-24": "Chefe Final",
                "bg2-26": "Vendedor de Cogumelos",
                "bg2-35": "Árvores na Neve",
                "bg2-37": "Colinas com Neve"
            },
            "fam-set4": {
                "bg2-18": "Mansão",
                "bg2-31": "Nuvens",
                "bg2-34": "Colinas (3)",
                "bg2-12": "Árvores",
                "bg2-11": "Colinas",
                "bg2-19": "Floresta",
                "bg2-28": "Bônus",
                "bg2-29": "Noite",
                "bg2-30": "Caverna",
                "bg2-32": "Colinas (2)",
                "bg2-33": "Colinas (4)",
                "bg2-42": "Castelo",
                "bg2-43": "Castelo (2)",
                "bg2-55": "Subaquático",
                "bg2-58": "Deserto a Noite",
                "header": "Conjunto 4"
            },
            "auto": {
                "bg2-0": "Nenhum"
            }
        },
        "bgo": {
            "fam-art2": "Arte",
            "fam-clouds1": "Nuvens",
            "fam-fences1": "Cercas",
            "fam-ghost4": "Fantasma",
            "fam-hut1": "Cabana",
            "fam-key4": "Chave",
            "fam-misc4": "Outros",
            "fam-plants1": "Plantas",
            "fam-plants2": "Plantas",
            "fam-sandbg3": "Areia",
            "fam-temple5": "Templo",
            "fam-water1": "Água",
            "fam-water3": "Água",
            "fam-water4": "Água",
            "fam-bars4": "Barras",
            "fam-doors2": "Portas",
            "fam-doors4": "Portas",
            "fam-exit3": "Saída",
            "fam-fences4": "Cercas",
            "fam-space5": "Inseto Espacial",
            "fam-structures3": "Estruturas",
            "fam-tiles3": "Peças",
            "fam-water2": "Água",
            "fam-platform4": "Plat",
            "fam-plants3": "Plantas",
            "fam-plants4": "Plantas",
            "fam-sandfg3": "Primeiro Plano"
        },
        "block": {
            "fam-bonus4": "Bônus",
            "fam-bricks5": "Tijolo",
            "fam-grass3": "Grama",
            "fam-grass4": "Grama",
            "fam-house3": "Casa",
            "fam-mansion4": "Mansão",
            "fam-metal5-3": "Outros",
            "fam-misc1": "Outros",
            "fam-misc2": "Outros",
            "fam-misc3": "Outros (3)",
            "fam-pipes1": "Canos",
            "fam-pipes3": "Canos",
            "fam-pipes4": "Canos",
            "fam-pipes5-2": "Canos",
            "fam-sized1": "Redimen",
            "fam-sized2": "Redimen",
            "fam-sized4": "Redimen",
            "fam-special2": "Especial",
            "fam-special4": "Especial",
            "fam-steampunk3": "Tecnavapor",
            "fam-switch4": "Altern",
            "fam-underground1": "Subterrâneo",
            "fam-water3": "Água",
            "fam-wood2": "Madeira",
            "fam-wood3": "Madeira",
            "fam-bonus3": "Bônus",
            "fam-castle2": "Castelo",
            "fam-castle4": "Castelo",
            "fam-cave3": "Caverna",
            "fam-dungeon1": "Masmorra",
            "fam-char5": "Personagem",
            "fam-clouds1": "Nuvens",
            "fam-desert3": "Deserto",
            "fam-dungeon3": "Masmorra",
            "fam-hurts3": "Danoso",
            "fam-lava4": "Lava e Danosos",
            "fam-special3": "Especial",
            "fam-metal5-1": "Placas",
            "fam-sized3": "Redimen(3)",
            "fam-special1": "Especial",
            "fam-misc4": "Outros",
            "fam-overworld1": "Mundo sup",
            "fam-overworld2": "Mundo sup",
            "fam-underground2": "Subterrâneo",
            "fam-ruins5": "Ruinas",
            "fam-woods4": "Madeiras",
            "fam-cave4": "Caverna",
            "fam-pipes5-3": "Canos Longos"
        },
        "exit-codes": {
            "1": "Roleta",
            "2": "Esfera #16",
            "4": "Chave",
            "5": "Esfera #41",
            "6": "Teleporte",
            "3": "Deixar",
            "7": "Coletar",
            "8": "Barra de Fim",
            "none": "Nenhum",
            "any": "Qualquer",
            "9": "Código9"
        },
        "music": {
            "fam-64": {
                "header": "SM64",
                "music26": "Castelo",
                "music36": "Chefe",
                "music49": "Água",
                "music50": "Caverna",
                "music14": "Deserto",
                "music27": "Tema Principal",
                "music35": "Neve"
            },
            "fam-fight": {
                "music19": "Tecnavapor",
                "music40": "Cavaleiro",
                "music52": "Subterrâneo",
                "music53": "Pinball",
                "header": "Luta",
                "music39": "Templo"
            },
            "fam-misc": {
                "header": "Outro",
                "music13": "NSMB Mun.Sup",
                "music18": "Praia",
                "music20": "Reator de Fusão",
                "music23": "Florestas Heróicas",
                "music37": "Montanhas do Gelo",
                "music38": "Aldeia da Selva",
                "music55": "Tema do Título",
                "music56": "Corrida Saltitante",
                "music8": "Encurralado!"
            },
            "fam-rpg": {
                "header": "RPG",
                "music16": "Floresta",
                "music21": "Batalha",
                "music31": "Beira-mar",
                "music32": "Lago",
                "music33": "Nuvens",
                "music34": "Cidade",
                "music30": "Bacharelado"
            },
            "fam-set2": {
                "music43": "Chefe Final",
                "music15": "Chefe",
                "header": "Conjunto 2",
                "music5": "Mundo sup",
                "music25": "Subterrâneo"
            },
            "fam-set3": {
                "music1": "Mundo sup",
                "music2": "Céu",
                "music4": "Subterrâneo",
                "music54": "Inimigo Errante",
                "music6": "Chefe",
                "music3": "Masmorra",
                "music47": "Água",
                "header": "Conjunto 3"
            },
            "fam-space": {
                "header": "Espaço",
                "music11": "Pântano Vermelho",
                "music12": "Cratera",
                "music22": "Carga Espacial",
                "music44": "Sala de Itens",
                "music45": "Chefe Final"
            },
            "fam-world": {
                "header": "Mundo",
                "music10": "Mundo sup",
                "music17": "Mansão",
                "music28": "Céu",
                "music29": "Caverna",
                "music41": "Masmorra",
                "music51": "Chefe",
                "music48": "Água"
            },
            "auto": {
                "music24": "Personalizado",
                "music0": "Nenhum"
            },
            "fam-set1": {
                "header": "Conjunto 1",
                "music7": "Subterrâneo",
                "music42": "Masmorra",
                "music46": "Água",
                "music9": "Mundo sup"
            }
        },
        "npc": {
            "fam-boss1": "Chefe",
            "fam-boss3": "Chefe",
            "fam-char3": "Personagem",
            "fam-char5": "Personagem",
            "fam-enemies4": "Inimigos",
            "fam-exit2": "Saída",
            "fam-exit3": "Saída",
            "fam-exit4": "Saída",
            "fam-items1": "Itens",
            "fam-items4": "Itens",
            "fam-pet4": "Mascote",
            "fam-plant3": "Planta",
            "fam-plat1": "Plat",
            "fam-shell1": "Casco",
            "fam-shell3": "Casco",
            "fam-sign4": "Sinais",
            "fam-veg2": "Vegetal",
            "fam-vine1": "Vinha",
            "fam-blocks2": "Blocos",
            "fam-blocks3": "Blocos",
            "fam-boss2": "Chefe",
            "fam-boss4": "Chefe",
            "fam-switch5": "Altern",
            "fam-boss5": "Chefe",
            "fam-ckpt4": "Ress",
            "fam-enemies1": "Inimigos",
            "fam-enemies2": "Inimigos",
            "fam-enemies3": "Inimigos",
            "fam-enemies5": "Inimigos",
            "fam-items5": "Itens",
            "fam-items2": "Itens",
            "fam-items3": "Itens",
            "fam-plat3": "Plat",
            "fam-plat4": "Plat",
            "fam-vine2": "Vinha",
            "fam-vine3": "Vinha",
            "fam-vine4": "Vinha",
            "fam-warp2": "Telep"
        }
    },
    "character": {
        "name3": "Personagem 3",
        "name4": "Personagem 4",
        "name5": "Personagem 5",
        "name1": "Personagem 1",
        "name2": "Personagem 2"
    },
    "languageName": "Português-BR",
    "objects": {
        "wordFails": "FALHAS",
        "wordStarAccusativePlural": "Estrelas",
        "wordStarAccusativeSingular": "Estrela",
        "wordStarAccusativeDualOrCounter": "<Não usado no Inglês e Português, Seria como \"Pares de Estrelas\" se a linguagem tiver isso especificado (Numeral entre Singular e Plural); Se sua linguagem tiver contra palavra, use-a aqui>"
    }
}


================================================
FILE: resources/languages/assets_pt.json
================================================
{
    "character": {
        "name1": "Personagem 1",
        "name2": "Personagem 2",
        "name3": "Personagem 3",
        "name4": "Personagem 4",
        "name5": "Personagem 5"
    },
    "editor": {
        "background2": {
            "auto": {
                "bg2-0": "Nenhum"
            },
            "fam-misc": {
                "bg2-16": "Cratera Espacial",
                "bg2-45": "Pântano Espacial",
                "bg2-40": "Mina Secreta",
                "bg2-46": "Nave Espacial",
                "bg2-47": "Base Espacial",
                "header": "Outro"
            },
            "fam-set1": {
                "bg2-10": "Mundo sup",
                "bg2-41": "Castelo",
                "bg2-50": "Cogumelos",
                "bg2-7": "Subterrâneo",
                "bg2-8": "Noite",
                "bg2-51": "Deserto",
                "bg2-9": "Noite (2)",
                "header": "Conjunto 1"
            },
            "fam-set2": {
                "bg2-25": "Subterrâneo",
                "bg2-44": "Castelo",
                "bg2-48": "Nuvens",
                "bg2-49": "Noite - Colinas",
                "bg2-5": "Árvores",
                "bg2-52": "Noite - Deserto",
                "bg2-53": "Penhasco",
                "bg2-54": "Armazém",
                "bg2-57": "Masmorra",
                "header": "Conjunto 2"
            },
            "fam-set3": {
                "bg2-1": "Blocos",
                "bg2-13": "Nuvens",
                "bg2-14": "Deserto",
                "bg2-15": "Masmorra (2)",
                "bg2-17": "Navio",
                "bg2-2": "Colinas",
                "bg2-20": "Floresta",
                "bg2-21": "Batalha",
                "bg2-22": "Cachoeira",
                "bg2-23": "Tanques",
                "bg2-24": "Chefe Final",
                "bg2-26": "Vendedor de Cogumelos",
                "bg2-27": "Castelo",
                "bg2-3": "Masmorra",
                "bg2-35": "Árvores com Neve",
                "bg2-36": "Nuvens (2)",
                "bg2-37": "Colinas com Neve",
                "bg2-38": "Caverna",
                "bg2-39": "Caverna (2)",
                "bg2-4": "Canos",
                "bg2-56": "Subaquático",
                "bg2-6": "Bônus",
                "header": "Conjunto 3"
            },
            "fam-set4": {
                "bg2-11": "Colinas",
                "bg2-12": "Árvores",
                "bg2-18": "Mansão",
                "bg2-19": "Floresta",
                "bg2-28": "Bônus",
                "bg2-29": "Noite",
                "bg2-30": "Caverna",
                "bg2-31": "Nuvens",
                "bg2-32": "Colinas (2)",
                "bg2-33": "Colinas (4)",
                "bg2-34": "Colinas (3)",
                "bg2-42": "Castelo",
                "bg2-43": "Castelo (2)",
                "bg2-55": "Subaquático",
                "bg2-58": "Deserto a Noite",
                "header": "Conjunto 4"
            }
        },
        "bgo": {
            "fam-clouds1": "Nuvens",
            "fam-art2": "Arte",
            "fam-bars4": "Barras",
            "fam-doors2": "Portas",
            "fam-doors4": "Portas",
            "fam-exit3": "Saída",
            "fam-fences1": "Cercas",
            "fam-fences4": "Cercas",
            "fam-ghost4": "Fantasma",
            "fam-hut1": "Cabana",
            "fam-key4": "Chave",
            "fam-misc4": "Outros",
            "fam-plants1": "Plantas",
            "fam-plants2": "Plantas",
            "fam-plants3": "Plantas",
            "fam-plants4": "Plantas",
            "fam-platform4": "Plat",
            "fam-sandbg3": "Areia",
            "fam-sandfg3": "Primeiro Plano",
            "fam-space5": "Inseto Espacial",
            "fam-structures3": "Estruturas",
            "fam-temple5": "Templo",
            "fam-tiles3": "Peças",
            "fam-water1": "Água",
            "fam-water2": "Água",
            "fam-water3": "Água",
            "fam-water4": "Água"
        },
        "block": {
            "fam-cave4": "Caverna",
            "fam-bonus3": "Bônus",
            "fam-bonus4": "Bônus",
            "fam-bricks5": "Tijolo",
            "fam-castle2": "Castelo",
            "fam-castle4": "Castelo",
            "fam-cave3": "Caverna",
            "fam-char5": "Personagem",
            "fam-clouds1": "Nuvens",
            "fam-desert3": "Deserto",
            "fam-dungeon1": "Masmorra",
            "fam-house3": "Casa",
            "fam-dungeon3": "Masmorra",
            "fam-grass3": "Grama",
            "fam-grass4": "Grama",
            "fam-hurts3": "Danoso",
            "fam-lava4": "Lava e Danosos",
            "fam-mansion4": "Mansão",
            "fam-metal5-1": "Placas",
            "fam-metal5-3": "Outros",
            "fam-misc1": "Outros",
            "fam-misc2": "Outros",
            "fam-misc3": "Outros (3)",
            "fam-misc4": "Outros",
            "fam-overworld1": "Mundo sup",
            "fam-overworld2": "Mundo sup",
            "fam-pipes1": "Canos",
            "fam-pipes3": "Canos",
            "fam-pipes4": "Canos",
            "fam-pipes5-2": "Canos",
            "fam-pipes5-3": "Canos Longos",
            "fam-ruins5": "Ruinas",
            "fam-sized1": "Redimen",
            "fam-sized2": "Redimen",
            "fam-sized3": "Redimen(3)",
            "fam-sized4": "Redimen",
            "fam-special1": "Especial",
            "fam-special2": "Especial",
            "fam-special3": "Especial",
            "fam-special4": "Especial",
            "fam-steampunk3": "Tecnavapor",
            "fam-switch4": "Altern",
            "fam-underground1": "Subterrâneo",
            "fam-underground2": "Subterrâneo",
            "fam-water3": "Água",
            "fam-wood2": "Madeira",
            "fam-wood3": "Madeira",
            "fam-woods4": "Madeiras"
        },
        "exit-codes": {
            "1": "Roleta",
            "2": "Esfera #16",
            "3": "Deixar",
            "4": "Chave",
            "5": "Esfera #41",
            "6": "Teleporte",
            "7": "Coletar",
            "8": "Barra de Fim",
            "any": "Qualquer",
            "none": "Nenhum",
            "9": ""
        },
        "music": {
            "auto": {
                "music0": "Nenhum",
                "music24": "Personalizado"
            },
            "fam-64": {
                "header": "SM64",
                "music14": "Deserto",
                "music26": "Castelo",
                "music27": "Tema Principal",
                "music35": "Neve",
                "music36": "Chefe",
                "music49": "Água",
                "music50": "Caverna"
            },
            "fam-fight": {
                "header": "Luta",
                "music19": "Tecnavapor",
                "music39": "Templo",
                "music40": "Cavaleiro",
                "music52": "Subterrâneo",
                "music53": "Pinball"
            },
            "fam-misc": {
                "music13": "NSMB Mun.Sup",
                "header": "Outro",
                "music18": "Praia",
                "music20": "Reator de Fusão",
                "music23": "Florestas Heróicas",
                "music37": "Montanhas do Gelo",
                "music8": "Encurralado!",
                "music38": "Aldeia da Selva",
                "music55": "Tema do Título",
                "music56": "Corrida Saltitante"
            },
            "fam-rpg": {
                "header": "RPG",
                "music16": "Floresta",
                "music21": "Batalha",
                "music30": "Bacharelado",
                "music31": "Beira-mar",
                "music32": "Lago",
                "music33": "Nuvens",
                "music34": "Cidade"
            },
            "fam-set1": {
                "header": "Conjunto 1",
                "music42": "Masmorra",
                "music46": "Água",
                "music7": "Subterrâneo",
                "music9": "Mundo sup"
            },
            "fam-set2": {
                "header": "Conjunto 2",
                "music15": "Chefe",
                "music25": "Subterrâneo",
                "music43": "Chefe Final",
                "music5": "Mundo sup"
            },
            "fam-set3": {
                "header": "Conjunto 3",
                "music1": "Mundo sup",
                "music2": "Céu",
                "music3": "Masmorra",
                "music4": "Subterrâneo",
                "music47": "Água",
                "music54": "Inimigo Errante",
                "music6": "Chefe"
            },
            "fam-space": {
                "header": "Espaço",
                "music11": "Pântano Vermelho",
                "music12": "Cratera",
                "music22": "Carga Espacial",
                "music44": "Sala de Itens",
                "music45": "Chefe Final"
            },
            "fam-world": {
                "header": "Mundo",
                "music10": "Mundo sup",
                "music17": "Mansão",
                "music28": "Céu",
                "music29": "Caverna",
                "music41": "Masmorra",
                "music48": "Água",
                "music51": "Chefe"
            }
        },
        "npc": {
            "fam-blocks2": "Blocos",
            "fam-blocks3": "Blocos",
            "fam-boss1": "Chefe",
            "fam-boss2": "Chefe",
            "fam-boss3": "Chefe",
            "fam-char5": "Personagem",
            "fam-ckpt4": "Ress",
            "fam-enemies1": "Inimigos",
            "fam-boss4": "Chefe",
            "fam-boss5": "Chefe",
            "fam-char3": "Personagem",
            "fam-enemies2": "Inimigos",
            "fam-enemies3": "Inimigos",
            "fam-enemies4": "Inimigos",
            "fam-enemies5": "Inimigos",
            "fam-items2": "Itens",
            "fam-items3": "Itens",
            "fam-exit2": "Saída",
            "fam-exit3": "Saída",
            "fam-exit4": "Saída",
            "fam-items1": "Itens",
            "fam-items4": "Itens",
            "fam-items5": "Itens",
            "fam-pet4": "Mascote",
            "fam-plant3": "Planta",
            "fam-plat1": "Plat",
            "fam-plat3": "Plat",
            "fam-plat4": "Plat",
            "fam-shell1": "Casco",
            "fam-shell3": "Casco",
            "fam-sign4": "Sinais",
            "fam-switch5": "Altern",
            "fam-veg2": "Vegetal",
            "fam-vine1": "Vinha",
            "fam-vine2": "Vinha",
            "fam-vine3": "Vinha",
            "fam-vine4": "Vinha",
            "fam-warp2": "Telep"
        },
        "sound": {
            "auto": {
                "sound0": "Nenhum"
            },
            "fam-boss": {
                "sound38": "Cuspe de Pássaro",
                "sound39": "Choque de Pássaro",
                "header": "Chefe",
                "sound41": "Pássaro Derrotado",
                "sound44": "Tartaruga Morta",
                "sound62": "Bolhas de Sapo",
                "sound63": "Sapo Morto",
                "sound67": "Quebra Vidro",
                "sound68": "Bateu Chefe Espacial",
                "sound69": "Grito do Chefe Espacial",
                "sound70": "Morte do Chefe Espacial"
            },
            "fam-hero": {
                "header": "Herói",
                "sound53": "Morte do NPC de Herói",
                "sound77": "Estocada do Herói",
                "sound78": "Herói Machucado",
                "sound79": "Apanhar Coração",
                "sound80": "Morte do Herói",
                "sound81": "Apanhar Gema",
                "sound82": "Fogo do Herói",
                "sound83": "Item do Herói",
                "sound84": "Apanhar Chave",
                "sound85": "Defesa com Escudo",
                "sound86": "Botas de Hermes",
                "sound87": "Voar",
                "sound88": "Cortar Grama"
            },
            "fam-item": {
                "header": "Item",
                "sound14": "Moeda",
                "sound32": "Altern",
                "sound16": "Lava",
                "sound22": "Bala",
                "sound3": "Bater Bloco",
                "sound37": "Quebrador",
                "sound4": "Bloco Esmagado",
                "sound42": "Bola de Fogo Grande",
                "sound43": "Fogos de Artificio",
                "sound56": "Anel",
                "sound57": "Esqueleto",
                "sound51": "Ovo Chocado",
                "sound58": "Ponto de Ressurgimento",
                "sound59": "Coletável",
                "sound61": "Criatura de Lava",
                "sound64": "Bateu Bloco Espacial",
                "sound65": "NPC Espacial Morto",
                "sound66": "Machucar NPC Espacial",
                "sound7": "Aumento de Poder",
                "sound74": "Serra",
                "sound9": "Chutar Casco"
            },
            "fam-jingle": {
                "header": "Toque",
                "sound19": "Saída da Roleta",
                "sound20": "Derrota do Chefe",
                "sound21": "Masmorra Completa",
                "sound31": "Saída da Chave",
                "sound40": "Saída da Bola",
                "sound45": "Jogo Superado",
                "sound52": "Pegou uma Estrela de Saída",
                "sound60": "Barra de Saída",
                "sound8": "Morte de Jogador"
            },
            "fam-pet": {
                "sound48": "Montar no Mascote",
                "sound49": "Mascote Machucado",
                "sound50": "Língua do Mascote",
                "sound55": "Mascote Engolindo",
                "header": "Mascote",
                "sound36": "Pisoteada do Mascote"
            },
            "fam-player": {
                "header": "Jogador",
                "sound1": "Pulo",
                "sound10": "Desliza",
                "sound12": "Pegou Item",
                "sound17": "Teleporte",
                "sound15": "1 Vida",
                "sound18": "Bola de Fogo",
                "sound2": "Pisoteada",
                "sound23": "Agarrar",
                "sound24": "Mola",
                "sound25": "Jogada de Martelo",
                "sound33": "Cauda",
                "sound34": "Guaxinim",
                "sound35": "Perdeu Bota",
                "sound46": "Porta",
                "sound5": "Encolheu",
                "sound54": "Morte de Jogador (2)",
                "sound6": "Cresceu",
                "sound71": "Subindo",
                "sound72": "Nadando",
                "sound73": "Levemente Agarrado",
                "sound75": "Jogar Vegetal",
                "sound76": "Perdeu Coração"
            },
            "fam-ui": {
                "header": "Interface",
                "sound11": "Queda de Item",
                "sound13": "Câmara",
                "sound26": "Escorregar",
                "sound29": "Fazer",
                "sound30": "Pausa",
                "sound47": "Mensagem"
            },
            "fam-world": {
                "header": "Mundo",
                "sound27": "Novo Caminho",
                "sound28": "Seleção de Nível"
            }
        },
        "tile": {
            "fam-desert1": "Areia",
            "fam-dirt2": "Grama Morta",
            "fam-granite3": "Granito",
            "fam-grass1": "Grama Antiga",
            "fam-grass2": "Grama Viva",
            "fam-lava3": "Lava",
            "fam-lilac4": "Parede Lilás",
            "fam-clouds4": "Nuvens",
            "fam-marble3": "Mármore",
            "fam-snow1": "Neve Antiga",
            "fam-stonewall3": "Parede de Pedra",
            "fam-wall2": "Parede de Terra"
        },
        "worldMusic": {
            "auto": {
                "wmusic0": "Nenhum"
            },
            "fam-new": {
                "header": "Novo",
                "wmusic5": "Tema"
            },
            "fam-set3": {
                "wmusic11": "Mundo 5",
                "header": "Conjunto 3",
                "wmusic1": "Mundo 1",
                "wmusic10": "Mundo 6",
                "wmusic2": "Mundo 4",
                "wmusic3": "Mundo 7",
                "wmusic6": "Mundo 2",
                "wmusic8": "Mundo 3",
                "wmusic9": "Mundo 8"
            },
            "fam-world": {
                "header": "Mundo",
                "wmusic12": "Especial",
                "wmusic13": "Masmorra",
                "wmusic14": "Céu",
                "wmusic15": "Ilha",
                "wmusic16": "Caverna",
                "wmusic4": "Tema",
                "wmusic7": "Floresta"
            }
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "Estrela",
        "wordFails": "FALHAS",
        "wordStarAccusativeDualOrCounter": "<Não usado no Inglês e Português, Seria como \"Pares de Estrelas\" se a língua o tiver especificado (Numeral entre Singular e Plural); Se a sua língua tiver contra palavra, use-a aqui>",
        "wordStarAccusativePlural": "Estrelas"
    },
    "languageName": "Português"
}


================================================
FILE: resources/languages/assets_ru.json
================================================
{
    "character": {
        "name1": "Перс1",
        "name2": "Перс2",
        "name3": "Перс3",
        "name4": "Перс4",
        "name5": "Перс5"
    },
    "editor": {
        "background2": {
            "auto": {
                "bg2-0": "Нет"
            },
            "fam-misc": {
                "bg2-16": "Космич. кратер",
                "bg2-40": "Секретный рудник",
                "bg2-45": "Космич. болото",
                "bg2-46": "Космич. корабль",
                "bg2-47": "Космич. база",
                "header": "Прочее"
            },
            "fam-set1": {
                "bg2-10": "Надземный мир",
                "bg2-41": "Замок",
                "bg2-50": "Грибы",
                "bg2-51": "Пустыня",
                "bg2-7": "Подземелье",
                "bg2-8": "Ночь",
                "bg2-9": "Ночь 2",
                "header": "Набор 1"
            },
            "fam-set2": {
                "bg2-25": "Подземелье",
                "bg2-44": "Замок",
                "bg2-48": "Облака",
                "bg2-49": "Ночь - холмы",
                "bg2-5": "Деревья",
                "bg2-52": "Ночь - пустыня",
                "bg2-53": "Утёс",
                "bg2-54": "Склад",
                "bg2-57": "Темница",
                "header": "Набор 2"
            },
            "fam-set3": {
                "bg2-1": "Блоки",
                "bg2-13": "Облака",
                "bg2-14": "Пустыня",
                "bg2-15": "Темница 2",
                "bg2-17": "Корабль",
                "bg2-2": "Холмы",
                "bg2-20": "Лес",
                "bg2-21": "Битва",
                "bg2-22": "Водопад",
                "bg2-23": "Танки",
                "bg2-24": "Финальный босс",
                "bg2-26": "Грибной торговец",
                "bg2-27": "Замок",
                "bg2-3": "Темница",
                "bg2-35": "Снежные деревья",
                "bg2-36": "Облака 2",
                "bg2-37": "Снежные холмы",
                "bg2-38": "Пещера",
                "bg2-39": "Пещера 2",
                "bg2-4": "Трубы",
                "bg2-56": "Под водой",
                "bg2-6": "Бонус",
                "header": "Набор 3"
            },
            "fam-set4": {
                "bg2-11": "Холмы",
                "bg2-12": "Деревья",
                "bg2-18": "Особняк",
                "bg2-19": "Лес",
                "bg2-28": "Бонус",
                "bg2-29": "Ночь",
                "bg2-30": "Пещера",
                "bg2-31": "Облака",
                "bg2-32": "Холмы 2",
                "bg2-33": "Холмы 4",
                "bg2-34": "Холмы 3",
                "bg2-42": "Замок",
                "bg2-43": "Замок 2",
                "bg2-55": "Под водой",
                "bg2-58": "Ночь в пустыне",
                "header": "Набор 4"
            }
        },
        "bgo": {
            "fam-art2": "Искусство",
            "fam-bars4": "Брусья",
            "fam-clouds1": "Облака",
            "fam-doors2": "Двери",
            "fam-doors4": "Двери",
            "fam-exit3": "Выход",
            "fam-fences1": "Заборы",
            "fam-fences4": "Заборы",
            "fam-ghost4": "Призрак",
            "fam-hut1": "Хижина",
            "fam-key4": "Ключ",
            "fam-misc4": "Прочее",
            "fam-plants1": "Растения",
            "fam-plants2": "Растения",
            "fam-plants3": "Растения",
            "fam-plants4": "Растения",
            "fam-platform4": "Плат.",
            "fam-sandbg3": "Песочн. Ф.",
            "fam-sandfg3": "П.",
            "fam-space5": "Космич. жук",
            "fam-structures3": "Структуры",
            "fam-temple5": "Храм",
            "fam-tiles3": "Плитки",
            "fam-water1": "Вода",
            "fam-water2": "Вода",
            "fam-water3": "Вода",
            "fam-water4": "Вода"
        },
        "block": {
            "fam-bonus3": "Бонус",
            "fam-bonus4": "Бонус",
            "fam-bricks5": "Кирпич",
            "fam-castle2": "Замок",
            "fam-castle4": "Замок",
            "fam-cave3": "Пещера",
            "fam-cave4": "Пезера",
            "fam-char5": "Перс.",
            "fam-clouds1": "Облака",
            "fam-desert3": "Пустыня",
            "fam-dungeon1": "Темница",
            "fam-dungeon3": "Темница",
            "fam-grass3": "Трава",
            "fam-grass4": "Трава",
            "fam-house3": "Дом",
            "fam-hurts3": "Боль",
            "fam-lava4": "Лава и Боль",
            "fam-mansion4": "Особняк",
            "fam-metal5-1": "Пластины",
            "fam-metal5-3": "Прочее",
            "fam-misc1": "Прочее",
            "fam-misc2": "Прочее",
            "fam-misc3": "Прочее 3",
            "fam-misc4": "Прочее",
            "fam-overworld1": "Надземный мир",
            "fam-overworld2": "Надземный мир",
            "fam-pipes1": "Трубы",
            "fam-pipes3": "Трубы",
            "fam-pipes4": "Трубы",
            "fam-pipes5-2": "Трубы",
            "fam-pipes5-3": "Длинные трубы",
            "fam-ruins5": "Руины",
            "fam-sized1": "Измен.",
            "fam-sized2": "Измен.",
            "fam-sized3": "Измен. 3",
            "fam-sized4": "Измен.",
            "fam-special1": "Особый",
            "fam-special2": "Особый",
            "fam-special3": "Особый",
            "fam-special4": "Особый",
            "fam-steampunk3": "Стимпанк",
            "fam-switch4": "Переключ.",
            "fam-underground1": "Подземелье",
            "fam-underground2": "Подземелье",
            "fam-water3": "Вода",
            "fam-wood2": "Дерево",
            "fam-wood3": "Дерево",
            "fam-woods4": "Рощи"
        },
        "exit-codes": {
            "1": "Рулетка",
            "2": "Сфера №16",
            "3": "Выход",
            "4": "Ключ",
            "5": "Сфера №41",
            "6": "Проход",
            "7": "Сбор",
            "8": "Брус",
            "any": "Любой",
            "none": "Нет",
            "9": "код9"
        },
        "music": {
            "auto": {
                "music0": "Нет",
                "music24": "Своя"
            },
            "fam-64": {
                "header": "64",
                "music14": "Пустыня",
                "music26": "Замок",
                "music27": "Главная тема",
                "music35": "Снег",
                "music36": "Босс",
                "music49": "Вода",
                "music50": "Пещера"
            },
            "fam-fight": {
                "header": "Бой",
                "music19": "Стимпанк",
                "music39": "Храм",
                "music40": "Рыцарь",
                "music52": "Подземелье",
                "music53": "Пинбол"
            },
            "fam-misc": {
                "header": "Прочее.",
                "music13": "Новый надземный мир",
                "music18": "Пляж",
                "music20": "Термояд. реактор",
                "music23": "Героич. рощи",
                "music37": "Ледяные горы",
                "music38": "Джунгл. деревня",
                "music55": "Титульная тема",
                "music56": "Прыгучая гонка",
                "music8": "В углу!"
            },
            "fam-rpg": {
                "header": "Ролевая игра",
                "music16": "Лес",
                "music21": "Битва",
                "music30": "Холостятский дом",
                "music31": "Приморье",
                "music32": "Пруд",
                "music33": "Облака",
                "music34": "Город"
            },
            "fam-set1": {
                "header": "Набор 1",
                "music42": "Темница",
                "music46": "Вода",
                "music7": "Подземелье",
                "music9": "Надземный мир"
            },
            "fam-set2": {
                "header": "Набор 2",
                "music15": "Босс",
                "music25": "Подземелье",
                "music43": "Последний босс",
                "music5": "Надземный мир"
            },
            "fam-set3": {
                "header": "Набор 3",
                "music1": "Надземный мир",
                "music2": "Небо",
                "music3": "Темница",
                "music4": "Подземелье",
                "music47": "Вода",
                "music54": "Бродячий враг",
                "music6": "Босс"
            },
            "fam-space": {
                "header": "Космос",
                "music11": "Красное болото",
                "music12": "Кратер",
                "music22": "Космич. заряд",
                "music44": "Сокровищница",
                "music45": "Последний босс"
            },
            "fam-world": {
                "header": "Мир",
                "music10": "Надземный мир",
                "music17": "Особняк",
                "music28": "Небо",
                "music29": "Пещера",
                "music41": "Темница",
                "music48": "Вода",
                "music51": "Босс"
            }
        },
        "npc": {
            "fam-blocks2": "Блоки",
            "fam-blocks3": "Блоки",
            "fam-boss1": "Босс",
            "fam-boss2": "Босс",
            "fam-boss3": "Босс",
            "fam-boss4": "Босс",
            "fam-boss5": "Босс",
            "fam-char3": "Перс.",
            "fam-char5": "Перс.",
            "fam-ckpt4": "Конт.",
            "fam-enemies1": "Враги",
            "fam-enemies2": "Враги",
            "fam-enemies3": "Враги",
            "fam-enemies4": "Враги",
            "fam-enemies5": "Враги",
            "fam-exit2": "Выход",
            "fam-exit3": "Выход",
            "fam-exit4": "Выход",
            "fam-items1": "Предметы",
            "fam-items2": "Предметы",
            "fam-items3": "Предметы",
            "fam-items4": "Предметы",
            "fam-items5": "Предметы",
            "fam-pet4": "Питомец",
            "fam-plant3": "Растение",
            "fam-plat1": "Платформа",
            "fam-plat3": "Платформа",
            "fam-plat4": "Платформа",
            "fam-shell1": "Панцирь",
            "fam-shell3": "Панцирь",
            "fam-sign4": "Знак",
            "fam-switch5": "Перекл.",
            "fam-veg2": "Овощ",
            "fam-vine1": "Лоза",
            "fam-vine2": "Лоза",
            "fam-vine3": "Лоза",
            "fam-vine4": "Лоза",
            "fam-warp2": "Проход"
        },
        "sound": {
            "auto": {
                "sound0": "Нет"
            },
            "fam-boss": {
                "header": "Босс",
                "sound38": "Птичий плевок",
                "sound39": "Удар по птице",
                "sound41": "Птица повержена",
                "sound44": "Черепаха убита",
                "sound62": "Лягушачьи пузыри",
                "sound63": "Лягушка убита",
                "sound67": "Битое стекло",
                "sound68": "Удар по космич. боссу",
                "sound69": "Крик комсич. босса",
                "sound70": "Комсмич. босс убит"
            },
            "fam-hero": {
                "header": "Герой",
                "sound53": "НИП убит ероем",
                "sound77": "Удар героя",
                "sound78": "Боль героя",
                "sound79": "Взятие сердца",
                "sound80": "Гибель героя",
                "sound81": "Взятие др.камня",
                "sound82": "Огонь героя",
                "sound83": "Взятие предмета",
                "sound84": "Взятие ключа",
                "sound85": "Удар по щиту",
                "sound86": "Сапоги Гермеса",
                "sound87": "Полёт",
                "sound88": "Стрижка газона"
            },
            "fam-item": {
                "header": "Предмет",
                "sound14": "Монетка",
                "sound16": "Лава",
                "sound22": "Пуля",
                "sound3": "Удар по блоку",
                "sound32": "Переключатель",
                "sound37": "Давилка",
                "sound4": "Блок разбит",
                "sound42": "Большой огненный заряд",
                "sound43": "Фейерверки",
                "sound51": "Вылупление из яйца",
                "sound56": "Кольцо",
                "sound57": "Скелет",
                "sound58": "Контрольная точка",
                "sound59": "Собираемое",
                "sound61": "Лавовое существо",
                "sound64": "Удар по космич. блоку",
                "sound65": "Гибель космич. НИПа",
                "sound66": "Удар по космич. НИПу",
                "sound7": "Усилитель",
                "sound74": "Пила",
                "sound9": "Пинок по панцирю"
            },
            "fam-jingle": {
                "header": "Туш",
                "sound19": "Выход рулеткой",
                "sound20": "Победа над боссом",
                "sound21": "Очистка темницы",
                "sound31": "Выход ключём",
                "sound40": "Выход шаром",
                "sound45": "Игра пройдена",
                "sound52": "Взятие звезды",
                "sound60": "Выход брусом",
                "sound8": "Игрок погиб"
            },
            "fam-pet": {
                "header": "Питомец",
                "sound36": "Топот питомца",
                "sound48": "Оседлание питомца",
                "sound49": "Питомцу больно",
                "sound50": "Язык питомца",
                "sound55": "Питомец проглотил"
            },
            "fam-player": {
                "header": "Игрок",
                "sound1": "Прыг",
                "sound10": "Скольжение",
                "sound12": "Взятие предмета",
                "sound15": "+1 жизнь",
                "sound17": "Проход",
                "sound18": "Огненный шар",
                "sound2": "Топ",
                "sound23": "Захват",
                "sound24": "Пружина",
                "sound25": "Бросок молота",
                "sound33": "Хвост",
                "sound34": "Енот",
                "sound35": "Потеря сапога",
                "sound46": "Дверь",
                "sound5": "Уменьшение",
                "sound54": "Гибель игрока 2",
                "sound6": "Рост",
                "sound71": "Лазание",
                "sound72": "Плавание",
                "sound73": "Лёгкий захват",
                "sound75": "Бросок овоща",
                "sound76": "Потеря сердца"
            },
            "fam-ui": {
                "header": "Польз. интерфейс",
                "sound11": "Сброс предмета",
                "sound13": "Камера",
                "sound26": "Прокрутка",
                "sound29": "Действие",
                "sound30": "Пауза",
                "sound47": "Сообщение"
            },
            "fam-world": {
                "header": "Мир",
                "sound27": "Новый путь",
                "sound28": "Выбор уровня"
            }
        },
        "tile": {
            "fam-clouds4": "Облака",
            "fam-desert1": "Пыль",
            "fam-dirt2": "Мётрвая трава",
            "fam-granite3": "Гранит",
            "fam-grass1": "Старая трава",
            "fam-grass2": "Счастливая трава",
            "fam-lava3": "Лава",
            "fam-lilac4": "Сиреневая стена",
            "fam-marble3": "Мрамор",
            "fam-snow1": "Старый снег",
            "fam-stonewall3": "Каменная стена",
            "fam-wall2": "Грязная стена"
        },
        "worldMusic": {
            "auto": {
                "wmusic0": "Нет"
            },
            "fam-new": {
                "header": "Новый",
                "wmusic5": "Тема"
            },
            "fam-set3": {
                "header": "Набор 3",
                "wmusic1": "Мир 1",
                "wmusic10": "Мир 6",
                "wmusic11": "Мир 5",
                "wmusic2": "Мир 4",
                "wmusic3": "Мир 7",
                "wmusic6": "Мир 2",
                "wmusic8": "Мир 3",
                "wmusic9": "Мир 8"
            },
            "fam-world": {
                "header": "Мир",
                "wmusic12": "Особый",
                "wmusic13": "Темница",
                "wmusic14": "Небо",
                "wmusic15": "Остров",
                "wmusic16": "Пещера",
                "wmusic4": "Тема",
                "wmusic7": "Лес"
            }
        }
    },
    "languageName": "Русский",
    "objects": {
        "wordFails": "Неудачи",
        "wordStarAccusativeDualOrCounter": "звезды",
        "wordStarAccusativePlural": "звёзд",
        "wordStarAccusativeSingular": "звезду"
    }
}


================================================
FILE: resources/languages/assets_ta.json
================================================
{
    "languageName": "தமிழ்",
    "editor": {
        "background2": {
            "fam-misc": {
                "bg2-40": "இரகசிய சுரங்கம்",
                "bg2-45": "விண்வெளி சதுப்பு நிலம்",
                "bg2-46": "விண்வெளி கப்பல்",
                "bg2-47": "விண்வெளி அடிப்படை",
                "header": "தவறான.",
                "bg2-16": "விண்வெளி பள்ளம்"
            },
            "fam-set1": {
                "bg2-10": "ஓவர் உலக",
                "bg2-41": "கோட்டை",
                "bg2-50": "காளான்கள்",
                "bg2-51": "பாலைவனம்",
                "bg2-7": "நிலத்தடி",
                "bg2-8": "இரவு",
                "bg2-9": "இரவு 2",
                "header": "செட் 1"
            },
            "fam-set2": {
                "bg2-44": "கோட்டை",
                "bg2-48": "மேகங்கள்",
                "bg2-49": "இரவு - மலைகள்",
                "bg2-5": "மரங்கள்",
                "bg2-52": "இரவு - பாலைவனம்",
                "bg2-25": "நிலத்தடி",
                "bg2-53": "குன்றின்",
                "bg2-54": "கிடங்கு",
                "bg2-57": "நிலவறை",
                "header": "செட் 2"
            },
            "fam-set3": {
                "bg2-26": "ச்ரூம் வணிகர்",
                "bg2-27": "கோட்டை",
                "bg2-3": "நிலவறை",
                "bg2-37": "ச்னோ இல்ச்",
                "bg2-38": "குகை",
                "bg2-39": "குகை 2",
                "bg2-1": "தொகுதிகள்",
                "bg2-13": "மேகங்கள்",
                "bg2-14": "பாலைவனம்",
                "bg2-15": "நிலவறை 2",
                "bg2-17": "கப்பல்",
                "bg2-2": "மலைகள்",
                "bg2-20": "காடு",
                "bg2-21": "போர்",
                "bg2-22": "நீர்வீழ்ச்சி",
                "bg2-23": "டாங்கிகள்",
                "bg2-24": "இறுதி முதலாளி",
                "bg2-35": "பனி மரங்கள்",
                "bg2-36": "மேகங்கள் 2",
                "bg2-4": "குழல்கள்",
                "bg2-56": "நீருக்கடியில்",
                "bg2-6": "போனச்",
                "header": "செட் 3"
            },
            "fam-set4": {
                "bg2-11": "மலைகள்",
                "bg2-58": "பாலைவன இரவு",
                "bg2-30": "குகை",
                "bg2-31": "மேகங்கள்",
                "bg2-32": "இல்ச் 2",
                "bg2-55": "நீருக்கடியில்",
                "bg2-12": "மரங்கள்",
                "bg2-18": "மாளிகை",
                "bg2-19": "காடு",
                "bg2-28": "போனச்",
                "bg2-29": "இரவு",
                "bg2-33": "மலைகள் 4",
                "bg2-34": "மலைகள் 3",
                "bg2-42": "கோட்டை",
                "bg2-43": "கோட்டை 2",
                "header": "செட் 4"
            },
            "auto": {
                "bg2-0": "எதுவுமில்லை"
            }
        },
        "bgo": {
            "fam-art2": "கலை",
            "fam-bars4": "பார்கள்",
            "fam-clouds1": "மேகங்கள்",
            "fam-doors2": "கதவுகள்",
            "fam-doors4": "கதவுகள்",
            "fam-exit3": "வெளியேறு",
            "fam-fences1": "வேலிகள்",
            "fam-misc4": "இதர",
            "fam-plants1": "தாவரங்கள்",
            "fam-plants3": "தாவரங்கள்",
            "fam-plants4": "தாவரங்கள்",
            "fam-platform4": "தட்டு",
            "fam-sandbg3": "மணல் பி.சி.",
            "fam-sandfg3": "Fg",
            "fam-space5": "விண்வெளி பிழை",
            "fam-water4": "நீர்",
            "fam-fences4": "வேலிகள்",
            "fam-ghost4": "பேய்",
            "fam-hut1": "குடிசை",
            "fam-key4": "விசை",
            "fam-plants2": "தாவரங்கள்",
            "fam-structures3": "கட்டமைப்புகள்",
            "fam-temple5": "கோயில்",
            "fam-tiles3": "ஓடுகள்",
            "fam-water1": "நீர்",
            "fam-water2": "நீர்",
            "fam-water3": "நீர்"
        },
        "block": {
            "fam-bonus3": "போனச்",
            "fam-bonus4": "போனச்",
            "fam-clouds1": "மேகங்கள்",
            "fam-desert3": "பாலைவனம்",
            "fam-grass3": "புல்",
            "fam-grass4": "புல்",
            "fam-house3": "வீடு",
            "fam-hurts3": "வலிக்கிறது",
            "fam-lava4": "எரிமலை மற்றும் வலிக்கிறது",
            "fam-mansion4": "மாளிகை",
            "fam-metal5-1": "தட்டுகள்",
            "fam-metal5-3": "இதர",
            "fam-misc1": "இதர",
            "fam-misc2": "இதர",
            "fam-special1": "சிறப்பு",
            "fam-special2": "சிறப்பு",
            "fam-special3": "சிறப்பு",
            "fam-steampunk3": "ச்டீம்பங்க்",
            "fam-pipes5-2": "குழல்கள்",
            "fam-switch4": "ஆளி, நிலைமாறி",
            "fam-underground1": "நிலத்தடி",
            "fam-underground2": "நிலத்தடி",
            "fam-pipes5-3": "நீண்ட குழாய்கள்",
            "fam-sized4": "அளவு",
            "fam-water3": "நீர்",
            "fam-wood2": "மரம்",
            "fam-wood3": "மரம்",
            "fam-woods4": "வூட்ச்",
            "fam-bricks5": "செங்கல்",
            "fam-castle2": "கோட்டை",
            "fam-castle4": "கோட்டை",
            "fam-cave3": "குகை",
            "fam-cave4": "குகை",
            "fam-char5": "சார்",
            "fam-dungeon1": "நிலவறை",
            "fam-dungeon3": "நிலவறை",
            "fam-misc3": "மற்ற 3",
            "fam-misc4": "இதர",
            "fam-overworld1": "ஓவர் உலக",
            "fam-overworld2": "ஓவர் உலக",
            "fam-pipes1": "குழல்கள்",
            "fam-pipes3": "குழல்கள்",
            "fam-pipes4": "குழல்கள்",
            "fam-ruins5": "இடிபாடுகள்",
            "fam-sized1": "அளவு",
            "fam-sized2": "அளவு",
            "fam-sized3": "அளவு 3",
            "fam-special4": "சிறப்பு"
        },
        "exit-codes": {
            "1": "சில்லி",
            "6": "வார்ப்",
            "7": "சேகரிக்கவும்",
            "8": "பார் முடிவு",
            "any": "ஏதேனும்",
            "none": "எதுவுமில்லை",
            "2": "உருண்டை #16",
            "3": "விடுப்பு",
            "4": "விசை",
            "5": "ORB #41",
            "9": "குறியீடு9"
        },
        "music": {
            "auto": {
                "music0": "எதுவுமில்லை",
                "music24": "தனிப்பயன்"
            },
            "fam-64": {
                "music14": "பாலைவனம்",
                "music26": "கோட்டை",
                "music27": "முக்கிய கருப்பொருள்",
                "music50": "குகை",
                "header": "64",
                "music35": "பனி",
                "music36": "பாச்",
                "music49": "நீர்"
            },
            "fam-fight": {
                "header": "சண்டை",
                "music19": "ச்டீம்பங்க்",
                "music39": "கோயில்",
                "music40": "நைட்",
                "music52": "நிலத்தடி",
                "music53": "பின்பால்"
            },
            "fam-misc": {
                "music13": "புதிய ஓவர் உலக",
                "music18": "கடற்கரை",
                "music20": "இணைவு உலை",
                "music37": "பனி மலை",
                "music38": "சங்கிள் சிற்றூர்",
                "music55": "தலைப்பு கருப்பொருள்",
                "music56": "பவுன்சி ரேச்",
                "music8": "மூலைவிட்ட!",
                "header": "தவறான.",
                "music23": "வீர காடுகள்"
            },
            "fam-rpg": {
                "music30": "இளங்கலை திண்டு",
                "music32": "குளம்",
                "music33": "மேகங்கள்",
                "music34": "நகரம்",
                "header": "Rpg",
                "music16": "காடு",
                "music21": "போர்",
                "music31": "கடலோர"
            },
            "fam-set1": {
                "header": "செட் 1",
                "music42": "நிலவறை",
                "music46": "நீர்",
                "music7": "நிலத்தடி",
                "music9": "ஓவர் உலக"
            },
            "fam-set2": {
                "header": "செட் 2",
                "music15": "பாச்",
                "music25": "நிலத்தடி",
                "music43": "இறுதி முதலாளி",
                "music5": "ஓவர் உலக"
            },
            "fam-set3": {
                "music1": "ஓவர் உலக",
                "music2": "வானம்",
                "music3": "நிலவறை",
                "music4": "நிலத்தடி",
                "music54": "ரோமிங் எதிரி",
                "music6": "பாச்",
                "header": "செட் 3",
                "music47": "நீர்"
            },
            "fam-space": {
                "header": "இடைவெளி",
                "music11": "சிவப்பு சதுப்பு நிலம்",
                "music12": "க்ரேட்டர்",
                "music22": "விண்வெளி கட்டணம்",
                "music44": "உருப்படி அறை",
                "music45": "இறுதி முதலாளி"
            },
            "fam-world": {
                "music17": "மாளிகை",
                "music28": "வானம்",
                "music29": "குகை",
                "music41": "நிலவறை",
                "music48": "நீர்",
                "music51": "பாச்",
                "header": "உலகம்",
                "music10": "ஓவர் உலக"
            }
        },
        "npc": {
            "fam-blocks2": "தொகுதிகள்",
            "fam-boss4": "பாச்",
            "fam-enemies1": "எதிரிகள்",
            "fam-enemies2": "எதிரிகள்",
            "fam-enemies3": "எதிரிகள்",
            "fam-enemies5": "எதிரிகள்",
            "fam-exit2": "வெளியேறு",
            "fam-exit3": "வெளியேறு",
            "fam-exit4": "வெளியேறு",
            "fam-items1": "உருப்படிகள்",
            "fam-items2": "உருப்படிகள்",
            "fam-items5": "உருப்படிகள்",
            "fam-pet4": "செல்லப்பிள்ளை",
            "fam-plant3": "ஆலை",
            "fam-plat1": "தட்டு",
            "fam-plat3": "தட்டு",
            "fam-veg2": "காய்கறி",
            "fam-vine1": "கொடியின்",
            "fam-vine2": "கொடியின்",
            "fam-vine3": "கொடியின்",
            "fam-vine4": "கொடியின்",
            "fam-warp2": "வார்ப்",
            "fam-blocks3": "தொகுதிகள்",
            "fam-boss1": "பாச்",
            "fam-boss2": "பாச்",
            "fam-boss3": "பாச்",
            "fam-boss5": "பாச்",
            "fam-char3": "சார்",
            "fam-char5": "சார்",
            "fam-ckpt4": "நுகர்வு",
            "fam-enemies4": "எதிரிகள்",
            "fam-items3": "உருப்படிகள்",
            "fam-items4": "உருப்படிகள்",
            "fam-plat4": "தட்டு",
            "fam-shell1": "ஓடு",
            "fam-shell3": "ஓடு",
            "fam-sign4": "அடையாளம்",
            "fam-switch5": "ஆளி, நிலைமாறி"
        },
        "sound": {
            "auto": {
                "sound0": "எதுவுமில்லை"
            },
            "fam-boss": {
                "header": "பாச்",
                "sound44": "ஆமை கொல்லப்பட்டது",
                "sound62": "தவளை குமிழ்கள்",
                "sound38": "பறவை துப்புதல்",
                "sound39": "பறவை செய்",
                "sound41": "பறவை துடிப்பு",
                "sound63": "தவளை கொல்லப்பட்டது",
                "sound67": "கண்ணாடி இடைவெளி",
                "sound68": "விண்வெளி முதலாளி செய்",
                "sound69": "விண்வெளி முதலாளி அழுகை",
                "sound70": "விண்வெளி முதலாளி கொலை"
            },
            "fam-hero": {
                "header": "ஈரோ",
                "sound53": "ஈரோ என்.பி.சி கொலை",
                "sound80": "ஈரோ இறந்தார்",
                "sound82": "ஈரோ தீ",
                "sound83": "ஈரோ உருப்படி",
                "sound84": "சாவியைப் பெறுங்கள்",
                "sound85": "கேடயத் தொகுதி",
                "sound86": "எர்ம்ச் பூட்ச்",
                "sound87": "பறக்க",
                "sound88": "மூவ் புல்வெளி",
                "sound77": "ஈரோ குத்துங்கள்",
                "sound78": "ஈரோ காயப்படுத்தினார்",
                "sound79": "இதயத்தைப் பெறுங்கள்",
                "sound81": "ரத்தினத்தைப் பெறுங்கள்"
            },
            "fam-item": {
                "sound37": "நொறுக்கி",
                "sound4": "தொகுதி அடித்து நொறுக்கப்பட்டது",
                "sound43": "பட்டாசு",
                "sound51": "முட்டை அட்ச்",
                "sound56": "வளையம்",
                "sound57": "எலும்புக் கூடு",
                "sound58": "சோதனைச் சாவடி",
                "sound59": "தொகுக்கக்கூடிய",
                "sound61": "லாவா உயிரினங்கள்",
                "sound64": "விண்வெளி தொகுதி செய்",
                "sound7": "பவர்அப்",
                "sound74": "பார்த்தேன்",
                "sound9": "செல் கிக்",
                "header": "உருப்படி",
                "sound14": "நாணயம்",
                "sound16": "எரிமலைக்குழம்பு, பாறைக்குழம்பு",
                "sound22": "புல்லட்",
                "sound3": "தொகுதி செய்",
                "sound32": "ஆளி, நிலைமாறி",
                "sound42": "பெரிய ஃபயர்பால்",
                "sound65": "விண்வெளி NPC கொலை",
                "sound66": "விண்வெளி NPC உடல்"
            },
            "fam-jingle": {
                "sound20": "மொழி தோற்கடிக்கவும்",
                "sound21": "நிலவறை தெளிவாக",
                "sound31": "விசை வெளியேறுதல்",
                "sound40": "பந்து வெளியேறுதல்",
                "sound60": "பார் வெளியேறுதல்",
                "sound8": "வீரர் இறந்தார்",
                "header": "சிங்கிள்",
                "sound19": "சில்லி வெளியேறுதல்",
                "sound45": "விளையாட்டு துடிப்பு",
                "sound52": "நட்சத்திர வெளியேறுதல் கிடைத்தது"
            },
            "fam-pet": {
                "header": "செல்லப்பிள்ளை",
                "sound48": "செல்லப்பிராணி மவுண்ட்",
                "sound49": "செல்லப்பிராணி உடல்",
                "sound50": "செல்லப்பிராணி நாக்கு",
                "sound36": "செல்லப்பிராணி ச்டாம்ப்",
                "sound55": "செல்லப்பிராணி விழுங்குதல்"
            },
            "fam-player": {
                "sound1": "தாவு",
                "sound10": "சறுக்கல்",
                "sound12": "உருப்படி கிடைத்தது",
                "sound2": "ச்டாம்ப்",
                "sound23": "பிடுங்க",
                "sound25": "சுத்தி டாச்",
                "sound33": "வால்",
                "sound34": "அணில்கரடி",
                "sound35": "துவக்கத்தை இழக்க",
                "sound46": "கதவு",
                "sound5": "சுருங்கவும்",
                "sound54": "வீரர் இறந்தார் 2",
                "sound6": "வளர",
                "sound71": "ஏறுதல்",
                "sound72": "நீச்சல்",
                "header": "வீரர்",
                "sound15": "1up",
                "sound17": "வார்ப்",
                "sound18": "ஃபயர்பால்",
                "sound24": "வேனில்",
                "sound73": "ஒளி கிராப்",
                "sound75": "காய்கறி எறியுங்கள்",
                "sound76": "இதயத்தை இழக்க"
            },
            "fam-ui": {
                "header": "இடைமுகம்",
                "sound11": "உருப்படியை கைவிடுங்கள்",
                "sound13": "கேமரா",
                "sound26": "ச்லைடு",
                "sound29": "வெற்றி",
                "sound30": "இடைநிறுத்தம்",
                "sound47": "செய்தி"
            },
            "fam-world": {
                "header": "உலகம்",
                "sound27": "புதிய பாதை",
                "sound28": "நிலை தேர்ந்தெடுக்கவும்"
            }
        },
        "tile": {
            "fam-dirt2": "இறந்த புல்",
            "fam-granite3": "கிரானைட்",
            "fam-grass1": "பழைய புல்",
            "fam-grass2": "மகிழ்ச்சியான புல்",
            "fam-lava3": "எரிமலைக்குழம்பு, பாறைக்குழம்பு",
            "fam-lilac4": "இளஞ்சிவப்பு சுவர்",
            "fam-marble3": "பளிங்கு",
            "fam-snow1": "பழைய பனி",
            "fam-stonewall3": "கல் சுவர்",
            "fam-wall2": "அழுக்கு சுவர்",
            "fam-clouds4": "மேகங்கள்",
            "fam-desert1": "தூசு"
        },
        "worldMusic": {
            "auto": {
                "wmusic0": "எதுவுமில்லை"
            },
            "fam-new": {
                "header": "புதிய",
                "wmusic5": "கருப்பொருள்"
            },
            "fam-set3": {
                "wmusic2": "உலகம் 4",
                "wmusic3": "உலகம் 7",
                "header": "செட் 3",
                "wmusic1": "உலகம் 1",
                "wmusic10": "உலகம் 6",
                "wmusic11": "உலகம் 5",
                "wmusic6": "உலகம் 2",
                "wmusic8": "உலகம் 3",
                "wmusic9": "உலகம் 8"
            },
            "fam-world": {
                "wmusic13": "நிலவறை",
                "wmusic14": "வானம்",
                "wmusic15": "தீவு",
                "wmusic16": "குகை",
                "wmusic4": "கருப்பொருள்",
                "wmusic7": "காடு",
                "header": "உலகம்",
                "wmusic12": "சிறப்பு"
            }
        }
    },
    "objects": {
        "wordFails": "தோல்வியுற்றது",
        "wordStarAccusativeDualOrCounter": "<ஆங்கிலத்தில் பயன்படுத்தப்படாதது, உங்கள் மொழியில் இரட்டை வடிவம் இருந்தால் (பன்மை மற்றும் ஒருமைப்பாட்டிற்கு இடையிலான எண்ணிக்கை) இருந்தால் \"நட்சத்திரங்கள்\" என்று மொழிபெயர்க்கவும்; உங்கள் மொழியில் எதிர் சொல் இருந்தால், அதற்கு பதிலாக எதிர் வார்த்தையைப் பயன்படுத்தவும்>",
        "wordStarAccusativePlural": "நட்சத்திரங்கள்",
        "wordStarAccusativeSingular": "விண்மீன்"
    },
    "character": {
        "name1": "எழுத்து1",
        "name2": "எழுத்து2",
        "name3": "தெரு",
        "name4": "எழுத்து4",
        "name5": "கார்"
    }
}


================================================
FILE: resources/languages/assets_tr.json
================================================
{
    "character": {
        "name1": "Karakter1",
        "name2": "Karakter2",
        "name3": "Karakter3",
        "name4": "Karakter4",
        "name5": "Karakter5"
    },
    "editor": {
        "background2": {
            "auto": {
                "bg2-0": "Hiç"
            },
            "fam-misc": {
                "bg2-16": "Uzay Krateri",
                "bg2-40": "Gizli Maden",
                "bg2-45": "Uzay Bataklığı",
                "bg2-46": "Uzay Gemisi",
                "bg2-47": "Uzay Üssü",
                "header": "Diğer Şeyler"
            },
            "fam-set1": {
                "bg2-10": "Ana Dünya",
                "bg2-41": "Kale",
                "bg2-50": "Mantarlar",
                "bg2-51": "Çöl",
                "bg2-7": "Yer Altı",
                "bg2-8": "Gece",
                "bg2-9": "Gece 2",
                "header": "Set 1"
            },
            "fam-set2": {
                "bg2-25": "Yer Altı",
                "bg2-44": "Kale",
                "bg2-48": "Bulutlar",
                "bg2-49": "Bayır - Gece",
                "bg2-5": "Koru",
                "bg2-52": "Çöl - Gece",
                "bg2-53": "Uçurum",
                "bg2-54": "Depo",
                "bg2-57": "Zindan",
                "header": "Set 2"
            },
            "fam-set3": {
                "bg2-1": "Bloklar",
                "bg2-13": "Bulutlar",
                "bg2-14": "Çöl",
                "bg2-15": "Zindan 2",
                "bg2-17": "Gemi",
                "bg2-2": "Bayır",
                "bg2-20": "Orman",
                "bg2-21": "Çatışma",
                "bg2-22": "Şelale",
                "bg2-23": "Tanklar",
                "bg2-24": "Son Boss",
                "bg2-26": "Mantar Tüccarı",
                "bg2-27": "Kale",
                "bg2-3": "Zindan",
                "bg2-35": "Karlı Koru",
                "bg2-36": "Bulutlar 2",
                "bg2-37": "Karlı Bayırlar",
                "bg2-38": "Mağara",
                "bg2-39": "Mağara 2",
                "bg2-4": "Borular",
                "bg2-56": "Su Altı",
                "bg2-6": "Bonus",
                "header": "Set 3"
            },
            "fam-set4": {
                "bg2-11": "Bayır",
                "bg2-12": "Koru",
                "bg2-18": "Malikane",
                "bg2-19": "Orman",
                "bg2-28": "Bonus",
                "bg2-29": "Gece",
                "bg2-30": "Mağara",
                "bg2-31": "Bulutlar",
                "bg2-32": "Bayır 2",
                "bg2-33": "Bayır 4",
                "bg2-34": "Bayır 3",
                "bg2-42": "Kale",
                "bg2-43": "Kale 2",
                "bg2-55": "Su Altı",
                "bg2-58": "Çöl - Gece",
                "header": "Set 4"
            }
        },
        "bgo": {
            "fam-art2": "Sanat",
            "fam-bars4": "Direkler",
            "fam-clouds1": "Bulutlar",
            "fam-doors2": "Kapılar",
            "fam-doors4": "Kapılar",
            "fam-exit3": "Çıkış",
            "fam-fences1": "Çit",
            "fam-fences4": "Çit",
            "fam-ghost4": "Hayalet",
            "fam-hut1": "Baraka",
            "fam-key4": "Anahtar",
            "fam-misc4": "Diğer Şeyler",
            "fam-plants1": "Bitkiler",
            "fam-plants2": "Bitkiler",
            "fam-plants3": "Bitkiler",
            "fam-plants4": "Bitkiler",
            "fam-platform4": "Platform",
            "fam-sandbg3": "Kum AP",
            "fam-sandfg3": "ÖP",
            "fam-space5": "Uzay Böceği",
            "fam-structures3": "Yapılar",
            "fam-temple5": "Tapınak",
            "fam-tiles3": "Tilelar",
            "fam-water1": "Su",
            "fam-water2": "Su",
            "fam-water3": "Su",
            "fam-water4": "Su"
        },
        "block": {
            "fam-bonus3": "Bonus",
            "fam-bonus4": "Bonus",
            "fam-bricks5": "Tuğla",
            "fam-castle2": "Kale",
            "fam-castle4": "Kale",
            "fam-cave3": "Mağara",
            "fam-cave4": "Mağara",
            "fam-char5": "Karakter",
            "fam-clouds1": "Bulutlar",
            "fam-desert3": "Çöl",
            "fam-dungeon1": "Zindan",
            "fam-dungeon3": "Zindan",
            "fam-grass3": "Çimen",
            "fam-grass4": "Çimen",
            "fam-house3": "Ev",
            "fam-hurts3": "Hasar",
            "fam-lava4": "Lav ve Hasar",
            "fam-mansion4": "Malikane",
            "fam-metal5-1": "Demir Levha",
            "fam-metal5-3": "Diğer Şeyler",
            "fam-misc1": "Diğer Şeyler",
            "fam-misc2": "Diğer Şeyler",
            "fam-misc3": "Diğer Şeyler 3",
            "fam-misc4": "Diğer Şeyler",
            "fam-overworld1": "Ana Dünya",
            "fam-overworld2": "Ana Dünya",
            "fam-pipes1": "Borular",
            "fam-pipes3": "Borular",
            "fam-pipes4": "Borular",
            "fam-pipes5-2": "Borular",
            "fam-pipes5-3": "Uzun Borular",
            "fam-ruins5": "Enkaz",
            "fam-sized1": "Boyutlandır",
            "fam-sized2": "Boyutlandır",
            "fam-sized3": "Boyutlandır",
            "fam-sized4": "Boyutlandır",
            "fam-special1": "Özel",
            "fam-special2": "Özel",
            "fam-special3": "Özel",
            "fam-special4": "Özel",
            "fam-steampunk3": "Steampunk",
            "fam-switch4": "Şalter",
            "fam-underground1": "Yer Altı",
            "fam-underground2": "Yer Altı",
            "fam-water3": "Su",
            "fam-wood2": "Odun",
            "fam-wood3": "Odun",
            "fam-woods4": "Odunlar"
        },
        "exit-codes": {
            "1": "Rulet",
            "2": "Orb #16",
            "3": "Çık",
            "4": "Anahtar",
            "5": "Orb #41",
            "6": "Işınlanma",
            "7": "Topla",
            "8": "Direk Sonu",
            "any": "Herhangi",
            "none": "Hiç",
            "9": ""
        },
        "music": {
            "auto": {
                "music0": "Hiç",
                "music24": "Custom"
            },
            "fam-64": {
                "header": "64",
                "music14": "Çöl",
                "music26": "Kale",
                "music27": "Ana Tema",
                "music35": "Kar",
                "music36": "Boss",
                "music49": "Su",
                "music50": "Mağara"
            },
            "fam-fight": {
                "header": "Uçuş",
                "music19": "Steampunk",
                "music39": "Tapınak",
                "music40": "Şovalye",
                "music52": "Yer Altı",
                "music53": "Pinball"
            },
            "fam-misc": {
                "header": "Diğer Şeyler",
                "music13": "Yeni Ana Dünya",
                "music18": "Sahil",
                "music20": "Füzyon Reaktörü",
                "music23": "Yiğit Ormanı",
                "music37": "Buz Dağı",
                "music38": "Orman Dağı",
                "music55": "Başlık Teması",
                "music56": "Zıp Zıp Yarış",
                "music8": "Köşeye Sıkıştın!"
            },
            "fam-rpg": {
                "header": "RYO",
                "music16": "Orman",
                "music21": "Çatışma",
                "music30": "Bekar Evi",
                "music31": "Deniz Kenarı",
                "music32": "Gölet",
                "music33": "Bulutlar",
                "music34": "Kasaba"
            },
            "fam-set1": {
                "header": "Set 1",
                "music42": "Zindan",
                "music46": "Su",
                "music7": "Yer Altı",
                "music9": "Ana Dünya"
            },
            "fam-set2": {
                "header": "Set 2",
                "music15": "Boss",
                "music25": "Yer Altı",
                "music43": "Son Boss",
                "music5": "Ana Dünya"
            },
            "fam-set3": {
                "header": "Set 3",
                "music1": "Ana Dünya",
                "music2": "Gökyüzü",
                "music3": "Zindan",
                "music4": "Yer Altı",
                "music47": "Su",
                "music54": "Dolaşan Düşman",
                "music6": "Boss"
            },
            "fam-space": {
                "header": "Uzay",
                "music11": "Kızıl Bataklık",
                "music12": "Krater",
                "music22": "Uzay Şarj",
                "music44": "Eşya Odası",
                "music45": "Son Boss"
            },
            "fam-world": {
                "header": "Dünya",
                "music10": "Ana Dünya",
                "music17": "Malikane",
                "music28": "Gökyüzü",
                "music29": "Mağara",
                "music41": "Zindan",
                "music48": "Su",
                "music51": "Boss"
            }
        },
        "npc": {
            "fam-blocks2": "Blok",
            "fam-blocks3": "Blok",
            "fam-boss1": "Boss",
            "fam-boss2": "Boss",
            "fam-boss3": "Boss",
            "fam-boss4": "Boss",
            "fam-boss5": "Boss",
            "fam-char3": "Karakter",
            "fam-char5": "Karakter",
            "fam-ckpt4": "KntrlNkts",
            "fam-enemies1": "Düşmanlar",
            "fam-enemies2": "Düşmanlar",
            "fam-enemies3": "Düşmanlar",
            "fam-enemies4": "Düşmanlar",
            "fam-enemies5": "Düşmanlar",
            "fam-exit2": "Çıkış",
            "fam-exit3": "Çıkış",
            "fam-exit4": "Çıkış",
            "fam-items1": "Eşyalar",
            "fam-items2": "Eşyalar",
            "fam-items3": "Eşyalar",
            "fam-items4": "Eşyalar",
            "fam-items5": "Eşyalar",
            "fam-pet4": "Hayvan",
            "fam-plant3": "Bitki",
            "fam-plat1": "Platform",
            "fam-plat3": "Platform",
            "fam-plat4": "Platform",
            "fam-shell1": "Kabuk",
            "fam-shell3": "Kabuk",
            "fam-sign4": "Tabela",
            "fam-switch5": "Şalter",
            "fam-veg2": "Sebze",
            "fam-vine1": "Sarmaşık",
            "fam-vine2": "Sarmaşık",
            "fam-vine3": "Sarmaşık",
            "fam-vine4": "Sarmaşık",
            "fam-warp2": "Işınlanma"
        },
        "sound": {
            "auto": {
                "sound0": "Hiç"
            },
            "fam-boss": {
                "header": "Boss",
                "sound38": "Kuş Tükürüğü",
                "sound39": "Kuş Vuruldu",
                "sound41": "Kuş Yenildi",
                "sound44": "Kaplumbağa Öldü",
                "sound62": "Kurbağa Baloncuğu",
                "sound63": "Kurbağa Öldü",
                "sound67": "Cam Kırıldı",
                "sound68": "Uzay Boss Vuruldu",
                "sound69": "Uzay Boss Ağlama",
                "sound70": "Uzay Boss Öldü"
            },
            "fam-hero": {
                "header": "Kahraman",
                "sound53": "Kahraman NPC Öldü",
                "sound77": "Kahraman Bıçak",
                "sound78": "Kahraman Hasar",
                "sound79": "Kalp Al",
                "sound80": "Kahraman Öldü",
                "sound81": "Mücevher Al",
                "sound82": "Kahraman Ateş",
                "sound83": "Kahraman Eşya",
                "sound84": "Anahtar Al",
                "sound85": "Kalkan Bloklama",
                "sound86": "Hermes Botları",
                "sound87": "Uçmak",
                "sound88": "Çimen Biç"
            },
            "fam-item": {
                "header": "Eşya",
                "sound14": "Para",
                "sound16": "Lav",
                "sound22": "Mermi",
                "sound3": "Bloğa Vuruldu",
                "sound32": "Şalter",
                "sound37": "Parçalayıcı",
                "sound4": "Blok Kırıldı",
                "sound42": "Büyük Ateş Topu",
                "sound43": "Havai Fişek",
                "sound51": "Yumurta Kırılması",
                "sound56": "Yüzük",
                "sound57": "İskelet",
                "sound58": "Checkpoint",
                "sound59": "Toplanabilir",
                "sound61": "Lav Canavarı",
                "sound64": "Uzay Bloğa Vuruldu",
                "sound65": "Uzay NPC Öldü",
                "sound66": "Uzay NPC Hasar",
                "sound7": "Powerup",
                "sound74": "Testere",
                "sound9": "Kabuğa Tekme"
            },
            "fam-jingle": {
                "header": "Tını",
                "sound19": "Rulet Çıkışı",
                "sound20": "Boss Yenme",
                "sound21": "Zinden Bitirme",
                "sound31": "Anahtar Çıkışı",
                "sound40": "Top Çıkışı",
                "sound45": "Oyun Bitirme",
                "sound52": "Yıldız Çıkışı",
                "sound60": "Direk Çıkışı",
                "sound8": "Oyuncu Öldü"
            },
            "fam-pet": {
                "header": "Hayvan",
                "sound36": "Hayvan Ezmek",
                "sound48": "Hayvan Binmek",
                "sound49": "Hayvan Hasar",
                "sound50": "Hayvan Dili",
                "sound55": "Hayvan Yutmak"
            },
            "fam-player": {
                "header": "Oyuncu",
                "sound1": "Atlamak",
                "sound10": "Patinaj",
                "sound12": "Eyşa Almak",
                "sound15": "1up",
                "sound17": "Işınlanma",
                "sound18": "Ateş Topu",
                "sound2": "Ezilme",
                "sound23": "Tutmak",
                "sound24": "Fırlamak",
                "sound25": "Çekiç Fırlatmak",
                "sound33": "Kuyruk",
                "sound34": "Rakun",
                "sound35": "Bot Kaybetmek",
                "sound46": "Kapı",
                "sound5": "Küçülmek",
                "sound54": "Oyuncu Öldü 2",
                "sound6": "Büyümek",
                "sound71": "Tırmanmak",
                "sound72": "Yüzmek",
                "sound73": "Hafif Tutmak",
                "sound75": "Sebze Fırlatmak",
                "sound76": "Kalp Kaybetmek"
            },
            "fam-ui": {
                "header": "Arayüz",
                "sound11": "Eşya Bırakmak",
                "sound13": "Kamera",
                "sound26": "Kaymak",
                "sound29": "Yap",
                "sound30": "Durdurmak",
                "sound47": "Mesaj"
            },
            "fam-world": {
                "header": "Dünya",
                "sound27": "Yeni Yol",
                "sound28": "Seviye Seçmek"
            }
        },
        "tile": {
            "fam-clouds4": "Bulutlar",
            "fam-desert1": "Toz",
            "fam-dirt2": "Solmuş Çimen",
            "fam-granite3": "Granit",
            "fam-grass1": "Eski Çimen",
            "fam-grass2": "Mutlu Çimen",
            "fam-lava3": "Lav",
            "fam-lilac4": "Lila duvar",
            "fam-marble3": "Mermer",
            "fam-snow1": "Eski Kar",
            "fam-stonewall3": "Taş Duvar",
            "fam-wall2": "Kum Duvar"
        },
        "worldMusic": {
            "auto": {
                "wmusic0": "Hiç"
            },
            "fam-new": {
                "header": "Yeni",
                "wmusic5": "Tema"
            },
            "fam-set3": {
                "header": "Set 3",
                "wmusic1": "Dünya 1",
                "wmusic10": "Dünya 6",
                "wmusic11": "Dünya 5",
                "wmusic2": "Dünya 4",
                "wmusic3": "Dünya 7",
                "wmusic6": "Dünya 2",
                "wmusic8": "Dünya 3",
                "wmusic9": "Dünya 8"
            },
            "fam-world": {
                "header": "Dünya",
                "wmusic12": "Özel",
                "wmusic13": "Zindan",
                "wmusic14": "Gökyüzü",
                "wmusic15": "Ada",
                "wmusic16": "Mağara",
                "wmusic4": "Tema",
                "wmusic7": "Orman"
            }
        }
    },
    "languageName": "Türkçe",
    "objects": {
        "wordFails": "HATALAR",
        "wordStarAccusativeDualOrCounter": "",
        "wordStarAccusativePlural": "Yıldızlar",
        "wordStarAccusativeSingular": "Yıldız"
    }
}


================================================
FILE: resources/languages/assets_uk.json
================================================
{
    "character": {
        "name2": "",
        "name5": "",
        "name3": "",
        "name1": "",
        "name4": ""
    },
    "editor": {
        "worldMusic": {
            "fam-set3": {
                "wmusic11": "",
                "wmusic10": "",
                "wmusic2": "",
                "wmusic1": "",
                "wmusic9": "",
                "header": "",
                "wmusic3": "",
                "wmusic8": "",
                "wmusic6": ""
            },
            "fam-world": {
                "wmusic13": "",
                "wmusic4": "",
                "header": "",
                "wmusic12": "",
                "wmusic16": "",
                "wmusic14": "",
                "wmusic15": "",
                "wmusic7": ""
            },
            "auto": {
                "wmusic0": ""
            },
            "fam-new": {
                "header": "",
                "wmusic5": ""
            }
        },
        "music": {
            "fam-space": {
                "music11": "",
                "music22": "",
                "header": "",
                "music45": "",
                "music44": "",
                "music12": ""
            },
            "fam-64": {
                "music50": "",
                "header": "",
                "music14": "",
                "music35": "",
                "music26": "",
                "music36": "",
                "music49": "",
                "music27": ""
            },
            "fam-misc": {
                "music55": "",
                "music56": "",
                "music37": "",
                "music38": "",
                "music23": "",
                "music18": "",
                "music20": "",
                "header": "",
                "music8": "",
                "music13": ""
            },
            "fam-rpg": {
                "music33": "",
                "music30": "",
                "music31": "",
                "header": "",
                "music34": "",
                "music21": "",
                "music16": "",
                "music32": ""
            },
            "fam-set2": {
                "music43": "",
                "music15": "",
                "header": "",
                "music5": "",
                "music25": ""
            },
            "fam-world": {
                "music41": "",
                "music10": "",
                "header": "",
                "music28": "",
                "music51": "",
                "music48": "",
                "music29": "",
                "music17": ""
            },
            "fam-set3": {
                "music2": "",
                "music3": "",
                "music1": "",
                "music6": "",
                "music54": "",
                "header": "",
                "music4": "",
                "music47": ""
            },
            "fam-set1": {
                "header": "",
                "music9": "",
                "music46": "",
                "music42": "",
                "music7": ""
            },
            "fam-fight": {
                "music53": "",
                "music39": "",
                "music19": "",
                "header": "",
                "music40": "",
                "music52": ""
            },
            "auto": {
                "music0": "",
                "music24": ""
            }
        },
        "block": {
            "fam-steampunk3": "",
            "fam-cave4": "",
            "fam-misc4": "",
            "fam-water3": "",
            "fam-sized1": "",
            "fam-pipes3": "",
            "fam-pipes1": "",
            "fam-pipes5-3": "",
            "fam-pipes4": "",
            "fam-desert3": "",
            "fam-overworld2": "",
            "fam-wood2": "",
            "fam-underground2": "",
            "fam-overworld1": "",
            "fam-dungeon3": "",
            "fam-hurts3": "",
            "fam-clouds1": "",
            "fam-dungeon1": "",
            "fam-sized4": "",
            "fam-bonus3": "",
            "fam-grass4": "",
            "fam-mansion4": "",
            "fam-special2": "",
            "fam-switch4": "",
            "fam-pipes5-2": "",
            "fam-bricks5": "",
            "fam-special4": "",
            "fam-woods4": "",
            "fam-ruins5": "",
            "fam-grass3": "",
            "fam-misc2": "",
            "fam-char5": "",
            "fam-misc3": "",
            "fam-metal5-3": "",
            "fam-house3": "",
            "fam-special3": "",
            "fam-bonus4": "",
            "fam-underground1": "",
            "fam-cave3": "",
            "fam-wood3": "",
            "fam-sized3": "",
            "fam-lava4": "",
            "fam-metal5-1": "",
            "fam-misc1": "",
            "fam-castle4": "",
            "fam-special1": "",
            "fam-sized2": "",
            "fam-castle2": ""
        },
        "bgo": {
            "fam-ghost4": "",
            "fam-key4": "",
            "fam-misc4": "",
            "fam-sandbg3": "",
            "fam-water3": "",
            "fam-water4": "",
            "fam-water1": "",
            "fam-tiles3": "",
            "fam-temple5": "",
            "fam-art2": "",
            "fam-structures3": "",
            "fam-plants2": "",
            "fam-exit3": "",
            "fam-water2": "",
            "fam-plants4": "",
            "fam-bars4": "",
            "fam-platform4": "",
            "fam-clouds1": "",
            "fam-plants1": "",
            "fam-doors4": "",
            "fam-plants3": "",
            "fam-fences1": "",
            "fam-hut1": "",
            "fam-space5": "",
            "fam-sandfg3": "",
            "fam-fences4": "",
            "fam-doors2": ""
        },
        "background2": {
            "fam-set1": {
                "bg2-10": "",
                "bg2-7": "",
                "bg2-9": "",
                "bg2-8": "",
                "bg2-50": "",
                "header": "",
                "bg2-41": "",
                "bg2-51": ""
            },
            "fam-set2": {
                "bg2-57": "",
                "bg2-48": "",
                "bg2-53": "",
                "bg2-49": "",
                "bg2-25": "",
                "bg2-54": "",
                "bg2-52": "",
                "bg2-5": "",
                "bg2-44": "",
                "header": ""
            },
            "fam-set3": {
                "bg2-13": "",
                "bg2-21": "",
                "bg2-4": "",
                "bg2-15": "",
                "bg2-36": "",
                "header": "",
                "bg2-6": "",
                "bg2-3": "",
                "bg2-39": "",
                "bg2-20": "",
                "bg2-38": "",
                "bg2-26": "",
                "bg2-1": "",
                "bg2-24": "",
                "bg2-23": "",
                "bg2-27": "",
                "bg2-22": "",
                "bg2-37": "",
                "bg2-35": "",
                "bg2-2": "",
                "bg2-14": "",
                "bg2-17": "",
                "bg2-56": ""
            },
            "fam-misc": {
                "header": "",
                "bg2-16": "",
                "bg2-46": "",
                "bg2-47": "",
                "bg2-40": "",
                "bg2-45": ""
            },
            "fam-set4": {
                "bg2-28": "",
                "bg2-32": "",
                "header": "",
                "bg2-33": "",
                "bg2-30": "",
                "bg2-55": "",
                "bg2-58": "",
                "bg2-11": "",
                "bg2-12": "",
                "bg2-19": "",
                "bg2-18": "",
                "bg2-42": "",
                "bg2-29": "",
                "bg2-43": "",
                "bg2-31": "",
                "bg2-34": ""
            },
            "auto": {
                "bg2-0": ""
            }
        },
        "npc": {
            "fam-sign4": "",
            "fam-plat3": "",
            "fam-blocks2": "",
            "fam-enemies5": "",
            "fam-shell1": "",
            "fam-boss5": "",
            "fam-veg2": "",
            "fam-boss1": "",
            "fam-boss4": "",
            "fam-char3": "",
            "fam-warp2": "",
            "fam-shell3": "",
            "fam-plant3": "",
            "fam-vine1": "",
            "fam-items1": "",
            "fam-exit3": "",
            "fam-boss2": "",
            "fam-enemies3": "",
            "fam-exit4": "",
            "fam-boss3": "",
            "fam-vine3": "",
            "fam-plat4": "",
            "fam-plat1": "",
            "fam-char5": "",
            "fam-pet4": "",
            "fam-items5": "",
            "fam-items3": "",
            "fam-blocks3": "",
            "fam-enemies1": "",
            "fam-enemies2": "",
            "fam-ckpt4": "",
            "fam-vine4": "",
            "fam-switch5": "",
            "fam-vine2": "",
            "fam-exit2": "",
            "fam-items2": "",
            "fam-items4": "",
            "fam-enemies4": ""
        },
        "sound": {
            "fam-player": {
                "sound54": "",
                "sound24": "",
                "sound73": "",
                "sound12": "",
                "sound34": "",
                "sound75": "",
                "sound72": "",
                "header": "",
                "sound25": "",
                "sound18": "",
                "sound35": "",
                "sound46": "",
                "sound15": "",
                "sound76": "",
                "sound5": "",
                "sound71": "",
                "sound33": "",
                "sound1": "",
                "sound23": "",
                "sound17": "",
                "sound10": "",
                "sound6": "",
                "sound2": ""
            },
            "auto": {
                "sound0": ""
            },
            "fam-jingle": {
                "sound8": "",
                "sound20": "",
                "sound60": "",
                "sound45": "",
                "header": "",
                "sound52": "",
                "sound40": "",
                "sound31": "",
                "sound19": "",
                "sound21": ""
            },
            "fam-boss": {
                "sound67": "",
                "sound41": "",
                "sound69": "",
                "sound39": "",
                "sound38": "",
                "sound70": "",
                "sound44": "",
                "header": "",
                "sound63": "",
                "sound68": "",
                "sound62": ""
            },
            "fam-hero": {
                "sound83": "",
                "sound84": "",
                "sound88": "",
                "sound86": "",
                "sound87": "",
                "header": "",
                "sound82": "",
                "sound80": "",
                "sound77": "",
                "sound81": "",
                "sound85": "",
                "sound53": "",
                "sound78": "",
                "sound79": ""
            },
            "fam-item": {
                "sound4": "",
                "sound14": "",
                "sound22": "",
                "sound16": "",
                "sound61": "",
                "sound74": "",
                "sound9": "",
                "sound64": "",
                "sound3": "",
                "sound56": "",
                "sound7": "",
                "sound59": "",
                "header": "",
                "sound65": "",
                "sound32": "",
                "sound51": "",
                "sound57": "",
                "sound66": "",
                "sound43": "",
                "sound42": "",
                "sound58": "",
                "sound37": ""
            },
            "fam-pet": {
                "sound55": "",
                "sound48": "",
                "sound49": "",
                "sound50": "",
                "header": "",
                "sound36": ""
            },
            "fam-ui": {
                "sound11": "",
                "header": "",
                "sound13": "",
                "sound30": "",
                "sound47": "",
                "sound29": "",
                "sound26": ""
            },
            "fam-world": {
                "header": "",
                "sound28": "",
                "sound27": ""
            }
        },
        "tile": {
            "fam-desert1": "",
            "fam-lilac4": "",
            "fam-grass1": "",
            "fam-dirt2": "",
            "fam-marble3": "",
            "fam-granite3": "",
            "fam-stonewall3": "",
            "fam-clouds4": "",
            "fam-grass2": "",
            "fam-snow1": "",
            "fam-wall2": "",
            "fam-lava3": ""
        },
        "exit-codes": {
            "7": "",
            "5": "",
            "any": "",
            "6": "",
            "3": "",
            "4": "",
            "8": "",
            "1": "",
            "2": "",
            "none": "",
            "9": ""
        }
    },
    "objects": {
        "wordStarAccusativeSingular": "",
        "wordFails": "",
        "wordStarAccusativePlural": "",
        "wordStarAccusativeDualOrCounter": ""
    },
    "languageName": ""
}


================================================
FILE: resources/languages/assets_zh-cn.json
================================================
{
    "character": {
        "name1": "角色1",
        "name2": "角色2",
        "name3": "角色3",
        "name4": "角色4",
        "name5": "角色5"
    },
    "editor": {
        "background2": {
            "auto": {
                "bg2-0": "无"
            },
            "fam-misc": {
                "bg2-16": "宇宙中心",
                "bg2-40": "隐秘矿洞",
                "bg2-45": "太空沼泽",
                "bg2-46": "宇宙飞船",
                "bg2-47": "太空基地",
                "header": "其他"
            },
            "fam-set1": {
                "bg2-10": "山脉",
                "bg2-41": "城堡",
                "bg2-50": "蘑菇",
                "bg2-51": "沙漠",
                "bg2-7": "地下",
                "bg2-8": "夜晚1",
                "bg2-9": "夜晚2",
                "header": "第一组"
            },
            "fam-set2": {
                "bg2-25": "地下",
                "bg2-44": "城堡",
                "bg2-48": "天上遗迹",
                "bg2-49": "夜晚山脉",
                "bg2-5": "树林",
                "bg2-52": "夜晚沙漠",
                "bg2-53": "悬崖",
                "bg2-54": "仓库",
                "bg2-57": "地牢",
                "header": "超马USA"
            },
            "fam-set3": {
                "bg2-1": "砖块",
                "bg2-13": "山丘",
                "bg2-14": "沙漠",
                "bg2-15": "地牢2",
                "bg2-17": "飞船内部",
                "bg2-2": "天空",
                "bg2-20": "森林",
                "bg2-21": "对战",
                "bg2-22": "瀑布",
                "bg2-23": "坦克",
                "bg2-24": "最终Boss",
                "bg2-26": "蘑菇小屋",
                "bg2-27": "城堡",
                "bg2-3": "城堡",
                "bg2-35": "雪中树林",
                "bg2-36": "天空2",
                "bg2-37": "雪中山丘",
                "bg2-38": "洞窟1",
                "bg2-39": "洞窟2",
                "bg2-4": "水管",
                "bg2-56": "水下",
                "bg2-6": "奖励",
                "header": "超马三代"
            },
            "fam-set4": {
                "bg2-11": "山脉1",
                "bg2-12": "树林",
                "bg2-18": "幽灵屋",
                "bg2-19": "森林",
                "bg2-28": "奖励",
                "bg2-29": "夜晚",
                "bg2-30": "洞窟",
                "bg2-31": "天空",
                "bg2-32": "山脉2",
                "bg2-33": "山脉4",
                "bg2-34": "山脉3",
                "bg2-42": "城堡1",
                "bg2-43": "城堡2",
                "bg2-55": "水下",
                "bg2-58": "夜晚沙漠",
                "header": "超马世界"
            }
        },
        "bgo": {
            "fam-art2": "家具",
            "fam-bars4": "栏杆",
            "fam-clouds1": "云朵",
            "fam-doors2": "门",
            "fam-doors4": "门",
            "fam-exit3": "出口",
            "fam-fences1": "栅栏",
            "fam-fences4": "网",
            "fam-ghost4": "幽灵",
            "fam-hut1": "小屋",
            "fam-key4": "钥匙",
            "fam-misc4": "其他",
            "fam-plants1": "植物",
            "fam-plants2": "植物",
            "fam-plants3": "植物",
            "fam-plants4": "植物",
            "fam-platform4": "平台",
            "fam-sandbg3": "流沙背景",
            "fam-sandfg3": "前景",
            "fam-space5": "宇宙生物",
            "fam-structures3": "建筑",
            "fam-temple5": "寺庙",
            "fam-tiles3": "图块",
            "fam-water1": "水",
            "fam-water2": "水",
            "fam-water3": "水",
            "fam-water4": "水"
        },
        "block": {
            "fam-bonus3": "奖励",
            "fam-bonus4": "奖励",
            "fam-bricks5": "砖块",
            "fam-castle2": "城堡",
            "fam-castle4": "城堡",
            "fam-cave3": "洞窟",
            "fam-cave4": "洞窟",
            "fam-char5": "玩家",
            "fam-clouds1": "云朵",
            "fam-desert3": "沙漠",
            "fam-dungeon1": "城堡",
            "fam-dungeon3": "城堡",
            "fam-grass3": "草地",
            "fam-grass4": "草地",
            "fam-house3": "小屋",
            "fam-hurts3": "伤害",
            "fam-lava4": "岩浆",
            "fam-mansion4": "幽灵屋",
            "fam-metal5-1": "金属",
            "fam-metal5-3": "其他",
            "fam-misc1": "其他",
            "fam-misc2": "其他",
            "fam-misc3": "其他",
            "fam-misc4": "其他",
            "fam-overworld1": "地面",
            "fam-overworld2": "地面",
            "fam-pipes1": "水管",
            "fam-pipes3": "水管",
            "fam-pipes4": "水管",
            "fam-pipes5-2": "水管",
            "fam-pipes5-3": "长水管",
            "fam-ruins5": "遗迹",
            "fam-sized1": "可调整",
            "fam-sized2": "可调整",
            "fam-sized3": "可调整",
            "fam-sized4": "可调整",
            "fam-special1": "特殊",
            "fam-special2": "特殊",
            "fam-special3": "特殊",
            "fam-special4": "特殊",
            "fam-steampunk3": "飞船",
            "fam-switch4": "开关",
            "fam-underground1": "地下",
            "fam-underground2": "地下",
            "fam-water3": "水下",
            "fam-wood2": "木头",
            "fam-wood3": "木头",
            "fam-woods4": "森林"
        },
        "exit-codes": {
            "1": "转盘",
            "2": "16号水晶球",
            "3": "离开",
            "4": "钥匙",
            "5": "41号水晶球",
            "6": "传送",
            "7": "收集星星",
            "8": "终点杆",
            "any": "任意",
            "none": "无",
            "9": "过关代码#9"
        },
        "music": {
            "auto": {
                "music0": "无音乐",
                "music24": "自定义"
            },
            "fam-64": {
                "header": "SM64",
                "music14": "沙漠",
                "music26": "城堡",
                "music27": "主题曲",
                "music35": "雪地",
                "music36": "战斗",
                "music49": "水下",
                "music50": "洞窟"
            },
            "fam-fight": {
                "header": "任斗",
                "music19": "蒸汽机",
                "music39": "寺庙",
                "music40": "梅塔骑士的逆袭",
                "music52": "地下",
                "music53": "瓦路易吉弹珠台"
            },
            "fam-misc": {
                "header": "其他",
                "music13": "新大陆",
                "music18": "沙滩",
                "music20": "酷霸王的要塞",
                "music23": "勇气森林",
                "music37": "冰山",
                "music38": "丛林村庄",
                "music55": "标题画面",
                "music56": "蘑菇峡谷",
                "music8": "克尼利亚"
            },
            "fam-rpg": {
                "header": "SMRPG",
                "music16": "森林",
                "music21": "战斗",
                "music30": "小屋",
                "music31": "海滨",
                "music32": "池塘",
                "music33": "天空",
                "music34": "小镇"
            },
            "fam-set1": {
                "header": "超马一代",
                "music42": "城堡",
                "music46": "水下",
                "music7": "地下",
                "music9": "地面"
            },
            "fam-set2": {
                "header": "超马USA",
                "music15": "战斗",
                "music25": "地下",
                "music43": "决战",
                "music5": "地面"
            },
            "fam-set3": {
                "header": "超马三代",
                "music1": "地面",
                "music2": "天空",
                "music3": "城堡",
                "music4": "地下",
                "music47": "水下",
                "music54": "遭遇敌人",
                "music6": "战斗"
            },
            "fam-space": {
                "header": "密特罗德",
                "music11": "布林斯塔地下",
                "music12": "火山口",
                "music22": "布林斯塔",
                "music44": "道具室",
                "music45": "母脑"
            },
            "fam-world": {
                "header": "超马世界",
                "music10": "地面",
                "music17": "幽灵屋",
                "music28": "天空",
                "music29": "洞窟",
                "music41": "城堡",
                "music48": "水下",
                "music51": "战斗"
            }
        },
        "npc": {
            "fam-blocks2": "砖块",
            "fam-blocks3": "砖块",
            "fam-boss1": "Boss",
            "fam-boss2": "Boss",
            "fam-boss3": "Boss",
            "fam-boss4": "Boss",
            "fam-boss5": "Boss",
            "fam-char3": "人物",
            "fam-char5": "人物",
            "fam-ckpt4": "检查点",
            "fam-enemies1": "敌人",
            "fam-enemies2": "敌人",
            "fam-enemies3": "敌人",
            "fam-enemies4": "敌人",
            "fam-enemies5": "敌人",
            "fam-exit2": "出口",
            "fam-exit3": "出口",
            "fam-exit4": "出口",
            "fam-items1": "道具",
            "fam-items2": "道具",
            "fam-items3": "道具",
            "fam-items4": "道具",
            "fam-items5": "道具",
            "fam-pet4": "坐骑",
            "fam-plant3": "植物",
            "fam-plat1": "平台",
            "fam-plat3": "平台",
            "fam-plat4": "平台",
            "fam-shell1": "龟壳",
            "fam-shell3": "龟壳",
            "fam-sign4": "标牌",
            "fam-switch5": "开关",
            "fam-veg2": "蔬菜",
            "fam-vine1": "藤蔓",
            "fam-vine2": "藤蔓",
            "fam-vine3": "藤蔓",
            "fam-vine4": "藤蔓",
            "fam-warp2": "传送门"
        },
        "sound": {
            "auto": {
                "sound0": "无"
            },
            "fam-boss": {
                "header": "Boss",
                "sound38": "鸟吐出物品",
                "sound39": "撞击鸟",
                "sound41": "鸟阵亡",
                "sound44": "乌龟阵亡",
                "sound62": "青蛙泡泡",
                "sound63": "青蛙阵亡",
                "sound67": "玻璃破碎",
                "sound68": "太空Boss被撞击",
                "sound69": "太空Boss哭泣",
                "sound70": "太空Boss阵亡"
            },
            "fam-hero": {
                "header": "英雄",
                "sound53": "击杀英雄NPC",
                "sound77": "英雄击剑",
                "sound78": "英雄受伤",
                "sound79": "获得体力",
                "sound80": "英雄阵亡",
                "sound81": "获得宝石",
                "sound82": "英雄发射",
                "sound83": "英雄获得道具",
                "sound84": "获得钥匙",
                "sound85": "护盾抵挡",
                "sound86": "赫尔墨斯之靴",
                "sound87": "飞行",
                "sound88": "割草"
            },
            "fam-item": {
                "header": "物品",
                "sound14": "金币",
                "sound16": "岩浆",
                "sound22": "炮弹",
                "sound3": "撞击砖块",
                "sound32": "开关",
                "sound37": "压饼机",
                "sound4": "击碎砖块",
                "sound42": "火焰",
                "sound43": "焰火",
                "sound51": "蛋孵化",
                "sound56": "指环",
                "sound57": "骷髅",
                "sound58": "检查点",
                "sound59": "可收集的物品",
                "sound61": "岩浆生物",
                "sound64": "撞击太空砖块",
                "sound65": "击杀太空NPC",
                "sound66": "太空NPC受伤",
                "sound7": "力量提升",
                "sound74": "链锯",
                "sound9": "踢龟壳"
            },
            "fam-jingle": {
                "header": "短曲",
                "sound19": "转盘通关",
                "sound20": "击败Boss",
                "sound21": "城堡通关",
                "sound31": "钥匙通关",
                "sound40": "水晶球通关",
                "sound45": "全游戏通关",
                "sound52": "获得星星通关",
                "sound60": "终点杆通关",
                "sound8": "玩家阵亡"
            },
            "fam-pet": {
                "header": "坐骑",
                "sound36": "坐骑踩敌人",
                "sound48": "骑上坐骑",
                "sound49": "坐骑受伤",
                "sound50": "坐骑伸出舌头",
                "sound55": "坐骑吃东西"
            },
            "fam-player": {
                "header": "玩家",
                "sound1": "跳跃",
                "sound10": "滑行",
                "sound12": "获得道具",
                "sound15": "生命+1",
                "sound17": "传送",
                "sound18": "火球发射",
                "sound2": "踩敌人",
                "sound23": "拿起道具",
                "sound24": "弹簧",
                "sound25": "投掷锤子",
                "sound33": "尾巴",
                "sound34": "浣熊",
                "sound35": "靴子丢失",
                "sound46": "门",
                "sound5": "变小",
                "sound54": "玩家阵亡2",
                "sound6": "变大",
                "sound71": "攀爬",
                "sound72": "游泳",
                "sound73": "轻拿道具",
                "sound75": "投掷蔬菜",
                "sound76": "损失体力"
            },
            "fam-ui": {
                "header": "用户界面",
                "sound11": "取出道具",
                "sound13": "镜像",
                "sound26": "选择",
                "sound29": "确定",
                "sound30": "暂停",
                "sound47": "信息提示"
            },
            "fam-world": {
                "header": "世界地图",
                "sound27": "路线开启",
                "sound28": "进入关卡"
            }
        },
        "tile": {
            "fam-clouds4": "云朵",
            "fam-desert1": "灰尘",
            "fam-dirt2": "枯草",
            "fam-granite3": "花岗石",
            "fam-grass1": "复古草地",
            "fam-grass2": "快乐草地",
            "fam-lava3": "岩浆",
            "fam-lilac4": "紫色墙壁",
            "fam-marble3": "大理石",
            "fam-snow1": "复古雪地",
            "fam-stonewall3": "石制墙壁",
            "fam-wall2": "灰尘墙壁"
        },
        "worldMusic": {
            "auto": {
                "wmusic0": "无音乐"
            },
            "fam-new": {
                "header": "新大陆",
                "wmusic5": "主题曲"
            },
            "fam-set3": {
                "header": "超马三代",
                "wmusic1": "第一世界",
                "wmusic10": "第六世界",
                "wmusic11": "第五世界",
                "wmusic2": "第四世界",
                "wmusic3": "第七世界",
                "wmusic6": "第二世界",
                "wmusic8": "第三世界",
                "wmusic9": "第八世界"
            },
            "fam-world": {
                "header": "超马世界",
                "wmusic12": "特殊",
                "wmusic13": "城堡",
                "wmusic14": "天空",
                "wmusic15": "小岛",
                "wmusic16": "洞窟",
                "wmusic4": "主题曲",
                "wmusic7": "森林"
            }
        }
    },
    "languageName": "简体中文",
    "objects": {
        "wordFails": "失败次数",
        "wordStarAccusativeDualOrCounter": "颗",
        "wordStarAccusativePlural": "星星",
        "wordStarAccusativeSingular": "星星"
    }
}


================================================
FILE: resources/languages/assets_zh-tw.json
================================================
{
    "character": {
        "name1": "角色1",
        "name2": "角色2",
        "name3": "角色3",
        "name4": "角色4",
        "name5": "角色5"
    },
    "editor": {
        "background2": {
            "auto": {
                "bg2-0": "無"
            },
            "fam-misc": {
                "bg2-16": "宇宙中心",
                "bg2-40": "隱祕礦洞",
                "bg2-45": "太空沼澤",
                "bg2-46": "宇宙飛船",
                "bg2-47": "太空基地",
                "header": "其他"
            },
            "fam-set1": {
                "bg2-10": "山脈",
                "bg2-41": "城堡",
                "bg2-50": "蘑菇",
                "bg2-51": "沙漠",
                "bg2-7": "地下",
                "bg2-8": "夜晚1",
                "bg2-9": "夜晚2",
                "header": "超瑪一代"
            },
            "fam-set2": {
                "bg2-25": "地下",
                "bg2-44": "城堡",
                "bg2-48": "天上遺蹟",
                "bg2-49": "夜晚山脈",
                "bg2-5": "樹林",
                "bg2-52": "夜晚沙漠",
                "bg2-53": "懸崖",
                "bg2-54": "倉庫",
                "bg2-57": "地牢",
                "header": "超瑪USA"
            },
            "fam-set3": {
                "bg2-1": "磚塊",
                "bg2-13": "山丘",
                "bg2-14": "沙漠",
                "bg2-15": "地牢2",
                "bg2-17": "輪船內部",
                "bg2-2": "天空",
                "bg2-20": "森林",
                "bg2-21": "對戰",
                "bg2-22": "瀑布",
                "bg2-23": "坦克",
                "bg2-24": "最終Boss",
                "bg2-26": "蘑菇小屋",
                "bg2-27": "城堡",
                "bg2-3": "城堡",
                "bg2-35": "雪中樹林",
                "bg2-36": "天空2",
                "bg2-37": "雪中山丘",
                "bg2-38": "洞窟1",
                "bg2-39": "洞窟2",
                "bg2-4": "水管",
                "bg2-56": "水下",
                "bg2-6": "獎勵",
                "header": "超瑪三代"
            },
            "fam-set4": {
                "bg2-11": "山脈1",
                "bg2-12": "樹林",
                "bg2-18": "幽靈屋",
                "bg2-19": "森林",
                "bg2-28": "獎勵",
                "bg2-29": "夜晚",
                "bg2-30": "洞窟",
                "bg2-31": "天空",
                "bg2-32": "山脈2",
                "bg2-33": "山脈4",
                "bg2-34": "山脈3",
                "bg2-42": "城堡1",
                "bg2-43": "城堡2",
                "bg2-55": "水下",
                "bg2-58": "夜晚沙漠",
                "header": "超瑪世界"
            }
        },
        "bgo": {
            "fam-art2": "傢俱",
            "fam-bars4": "欄杆",
            "fam-clouds1": "雲朵",
            "fam-doors2": "門",
            "fam-doors4": "門",
            "fam-exit3": "出口",
            "fam-fences1": "柵欄",
            "fam-fences4": "網",
            "fam-ghost4": "幽靈",
            "fam-hut1": "小屋",
            "fam-key4": "鑰匙",
            "fam-misc4": "其他",
            "fam-plants1": "植物",
            "fam-plants2": "植物",
            "fam-plants3": "植物",
            "fam-plants4": "植物",
            "fam-platform4": "平臺",
            "fam-sandbg3": "流沙背景",
            "fam-sandfg3": "前景",
            "fam-space5": "宇宙生物",
            "fam-structures3": "建築",
            "fam-temple5": "寺廟",
            "fam-tiles3": "圖塊",
            "fam-water1": "水",
            "fam-water2": "水",
            "fam-water3": "水",
            "fam-water4": "水"
        },
        "block": {
            "fam-bonus3": "獎勵",
            "fam-bonus4": "獎勵",
            "fam-bricks5": "磚塊",
            "fam-castle2": "城堡",
            "fam-castle4": "城堡",
            "fam-cave3": "洞窟",
            "fam-cave4": "洞窟",
            "fam-char5": "玩家",
            "fam-clouds1": "雲朵",
            "fam-desert3": "沙漠",
            "fam-dungeon1": "城堡",
            "fam-dungeon3": "城堡",
            "fam-grass3": "草地",
            "fam-grass4": "草地",
            "fam-house3": "小屋",
            "fam-hurts3": "傷害",
            "fam-lava4": "岩漿",
            "fam-mansion4": "幽靈屋",
            "fam-metal5-1": "金屬",
            "fam-metal5-3": "其他",
            "fam-misc1": "其他",
            "fam-misc2": "其他",
            "fam-misc3": "其他",
            "fam-misc4": "其他",
            "fam-overworld1": "地面",
            "fam-overworld2": "地面",
            "fam-pipes1": "水管",
            "fam-pipes3": "水管",
            "fam-pipes4": "水管",
            "fam-pipes5-2": "水管",
            "fam-pipes5-3": "長水管",
            "fam-ruins5": "遺蹟",
            "fam-sized1": "可調整",
            "fam-sized2": "可調整",
            "fam-sized3": "可調整",
            "fam-sized4": "可調整",
            "fam-special1": "特殊",
            "fam-special2": "特殊",
            "fam-special3": "特殊",
            "fam-special4": "特殊",
            "fam-steampunk3": "飛船",
            "fam-switch4": "開關",
            "fam-underground1": "地下",
            "fam-underground2": "地下",
            "fam-water3": "水下",
            "fam-wood2": "木頭",
            "fam-wood3": "木頭",
            "fam-woods4": "森林"
        },
        "exit-codes": {
            "1": "轉盤",
            "2": "16號水晶球",
            "3": "離開",
            "4": "鑰匙",
            "5": "41號水晶球",
            "6": "傳送",
            "7": "收集星星",
            "8": "終點杆",
            "any": "任意",
            "none": "無",
            "9": "過關代碼#9"
        },
        "music": {
            "auto": {
                "music0": "無音樂",
                "music24": "自定義"
            },
            "fam-64": {
                "header": "64",
                "music14": "沙漠",
                "music26": "城堡",
                "music27": "主題曲",
                "music35": "雪地",
                "music36": "戰鬥",
                "music49": "水下",
                "music50": "洞窟"
            },
            "fam-fight": {
                "header": "任鬥",
                "music19": "蒸汽機",
                "music39": "寺廟",
                "music40": "騎士",
                "music52": "地下",
                "music53": "彈珠台"
            },
            "fam-misc": {
                "header": "其他",
                "music13": "新大陸",
                "music18": "沙灘",
                "music20": "庫巴的要塞",
                "music23": "勇氣森林",
                "music37": "冰山",
                "music38": "叢林村莊",
                "music55": "標題畫面",
                "music56": "蘑菇峽谷",
                "music8": "絕境！"
            },
            "fam-rpg": {
                "header": "RPG",
                "music16": "森林",
                "music21": "戰鬥",
                "music30": "小屋",
                "music31": "海濱",
                "music32": "池塘",
                "music33": "天空",
                "music34": "小鎮"
            },
            "fam-set1": {
                "header": "超瑪一代",
                "music42": "城堡",
                "music46": "水下",
                "music7": "地下",
                "music9": "地面"
            },
            "fam-set2": {
                "header": "超瑪USA",
                "music15": "戰鬥",
                "music25": "地下",
                "music43": "決戰",
                "music5": "地面"
            },
            "fam-set3": {
                "header": "超瑪三代",
                "music1": "地面",
                "music2": "天空",
                "music3": "城堡",
                "music4": "地下",
                "music47": "水下",
                "music54": "遭遇敵人",
                "music6": "戰鬥"
            },
            "fam-space": {
                "header": "超銀",
                "music11": "紅色沼澤地",
                "music12": "火山口",
                "music22": "太空任務",
                "music44": "道具室",
                "music45": "決戰"
            },
            "fam-world": {
                "header": "超瑪世界",
                "music10": "地面",
                "music17": "幽靈屋",
                "music28": "天空",
                "music29": "洞窟",
                "music41": "城堡",
                "music48": "水下",
                "music51": "戰鬥"
            }
        },
        "npc": {
            "fam-blocks2": "磚塊",
            "fam-blocks3": "磚塊",
            "fam-boss1": "Boss",
            "fam-boss2": "Boss",
            "fam-boss3": "Boss",
            "fam-boss4": "Boss",
            "fam-boss5": "Boss",
            "fam-char3": "人物",
            "fam-char5": "人物",
            "fam-ckpt4": "檢查點",
            "fam-enemies1": "敵人",
            "fam-enemies2": "敵人",
            "fam-enemies3": "敵人",
            "fam-enemies4": "敵人",
            "fam-enemies5": "敵人",
            "fam-exit2": "出口",
            "fam-exit3": "出口",
            "fam-exit4": "出口",
            "fam-items1": "道具",
            "fam-items2": "道具",
            "fam-items3": "道具",
            "fam-items4": "道具",
            "fam-items5": "道具",
            "fam-pet4": "坐騎",
            "fam-plant3": "植物",
            "fam-plat1": "平臺",
            "fam-plat3": "平臺",
            "fam-plat4": "平臺",
            "fam-shell1": "龜殼",
            "fam-shell3": "龜殼",
            "fam-sign4": "標牌",
            "fam-switch5": "開關",
            "fam-veg2": "蔬菜",
            "fam-vine1": "藤蔓",
            "fam-vine2": "藤蔓",
            "fam-vine3": "藤蔓",
            "fam-vine4": "藤蔓",
            "fam-warp2": "傳送門"
        },
        "sound": {
            "auto": {
                "sound0": "無"
            },
            "fam-boss": {
                "header": "Boss",
                "sound38": "鳥吐出物品",
                "sound39": "撞擊鳥",
                "sound41": "鳥陣亡",
                "sound44": "烏龜陣亡",
                "sound62": "青蛙泡泡",
                "sound63": "青蛙陣亡",
                "sound67": "玻璃破碎",
                "sound68": "太空Boss被撞擊",
                "sound69": "太空Boss哭泣",
                "sound70": "太空Boss陣亡"
            },
            "fam-hero": {
                "header": "英雄",
                "sound53": "擊殺英雄NPC",
                "sound77": "英雄擊劍",
                "sound78": "英雄受傷",
                "sound79": "獲得體力",
                "sound80": "英雄陣亡",
                "sound81": "獲得寶石",
                "sound82": "英雄發射",
                "sound83": "英雄獲得道具",
                "sound84": "獲得鑰匙",
                "sound85": "護盾抵擋",
                "sound86": "赫爾墨斯之靴",
                "sound87": "飛行",
                "sound88": "割草"
            },
            "fam-item": {
                "header": "物品",
                "sound14": "金幣",
                "sound16": "岩漿",
                "sound22": "炮彈",
                "sound3": "撞擊磚塊",
                "sound32": "開關",
                "sound37": "壓餅機",
                "sound4": "擊碎磚塊",
                "sound42": "火焰",
                "sound43": "焰火",
                "sound51": "蛋孵化",
                "sound56": "指環",
                "sound57": "骷髏",
                "sound58": "檢查點",
                "sound59": "可收集的物品",
                "sound61": "岩漿生物",
                "sound64": "撞擊太空磚塊",
                "sound65": "擊殺太空NPC",
                "sound66": "太空NPC受傷",
                "sound7": "力量提升",
                "sound74": "鏈鋸",
                "sound9": "踢龜殼"
            },
            "fam-jingle": {
                "header": "短曲",
                "sound19": "轉盤通關",
                "sound20": "擊敗Boss",
                "sound21": "城堡通關",
                "sound31": "鑰匙通關",
                "sound40": "水晶球通關",
                "sound45": "全遊戲通關",
                "sound52": "獲得星星通關",
                "sound60": "終點杆通關",
                "sound8": "玩家陣亡"
            },
            "fam-pet": {
                "header": "坐騎",
                "sound36": "坐騎踩敵人",
                "sound48": "騎上坐騎",
                "sound49": "坐騎受傷",
                "sound50": "坐騎伸出舌頭",
                "sound55": "坐騎吃東西"
            },
            "fam-player": {
                "header": "玩家",
                "sound1": "跳躍",
                "sound10": "滑行",
                "sound12": "獲得道具",
                "sound15": "生命+1",
                "sound17": "傳送",
                "sound18": "火球發射",
                "sound2": "踩敵人",
                "sound23": "拿起道具",
                "sound24": "彈簧",
                "sound25": "投擲錘子",
                "sound33": "尾巴",
                "sound34": "浣熊",
                "sound35": "靴子丟失",
                "sound46": "門",
                "sound5": "變小",
                "sound54": "玩家陣亡2",
                "sound6": "變大",
                "sound71": "攀爬",
                "sound72": "游泳",
                "sound73": "輕拿道具",
                "sound75": "投擲蔬菜",
                "sound76": "損失體力"
            },
            "fam-ui": {
                "header": "用戶界面",
                "sound11": "取出道具",
                "sound13": "鏡像",
                "sound26": "選擇",
                "sound29": "確定",
                "sound30": "暫停",
                "sound47": "信息提示"
            },
            "fam-world": {
                "header": "世界地圖",
                "sound27": "路線開啟",
                "sound28": "進入關卡"
            }
        },
        "tile": {
            "fam-clouds4": "雲朵",
            "fam-desert1": "灰塵",
            "fam-dirt2": "枯草",
            "fam-granite3": "花崗石",
            "fam-grass1": "復古草地",
            "fam-grass2": "快樂草地",
            "fam-lava3": "岩漿",
            "fam-lilac4": "紫色牆壁",
            "fam-marble3": "大理石",
            "fam-snow1": "復古雪地",
            "fam-stonewall3": "石制牆壁",
            "fam-wall2": "灰塵牆壁"
        },
        "worldMusic": {
            "auto": {
                "wmusic0": "無音樂"
            },
            "fam-new": {
                "header": "新大陸",
                "wmusic5": "主題曲"
            },
            "fam-set3": {
                "header": "超瑪三代",
                "wmusic1": "第一世界",
                "wmusic10": "第六世界",
                "wmusic11": "第五世界",
                "wmusic2": "第四世界",
                "wmusic3": "第七世界",
                "wmusic6": "第二世界",
                "wmusic8": "第三世界",
                "wmusic9": "第八世界"
            },
            "fam-world": {
                "header": "世界",
                "wmusic12": "特殊",
                "wmusic13": "城堡",
                "wmusic14": "天空",
                "wmusic15": "小島",
                "wmusic16": "洞窟",
                "wmusic4": "主題曲",
                "wmusic7": "森林"
            }
        }
    },
    "languageName": "繁體中文",
    "objects": {
        "wordFails": "失敗次數",
        "wordStarAccusativeDualOrCounter": "顆",
        "wordStarAccusativePlural": "星星",
        "wordStarAccusativeSingular": "星星"
    }
}


================================================
FILE: resources/languages/thextech_bg.json
================================================
{
    "menu": {
        "editor": {
            "battles": "",
            "errorMissingResources": "",
            "newWorld": "",
            "promptNewWorldName": "",
            "makeFor": ""
        },
        "options": {
            "advanced": {
                "render": {
                    "opengl11-tip": "",
                    "hw": "",
                    "_name": "",
                    "opengles": "",
                    "opengles-tip": "",
                    "opengles11": "",
                    "sdl-tip": "",
                    "sw": "",
                    "opengles11-tip": "",
                    "sdl": "",
                    "opengl-tip": "",
                    "opengl": "",
                    "opengl11": ""
                },
                "_tooltip": "",
                "log-level": {
                    "warning": "",
                    "debug": "",
                    "none": "",
                    "fatal": "",
                    "info": "",
                    "critical": "",
                    "_name": ""
                },
                "webm-recording": "",
                "internal-res-4p": {
                    "default": "",
                    "fhd": "",
                    "qsmbx": "",
                    "qhd": "",
                    "_name": ""
                },
                "_header": "",
                "record-gameplay-data": "",
                "advanced-audio": "",
                "advanced-video": "",
                "audio-channels": {
                    "mono": "",
                    "_name": "",
                    "stereo": ""
                },
                "audio-format": {
                    "_tooltip": "",
                    "_name": ""
                },
                "audio-sample-rate": {
                    "22050": "",
                    "16000": "",
                    "32000": "",
                    "11025": "",
                    "44100": "",
                    "48000": "",
                    "_name": ""
                },
                "audio-buffer-size": {
                    "_tooltip": "",
                    "_name": ""
                },
                "scale-down-textures": {
                    "none-tip": "",
                    "none": "",
                    "all": "",
                    "all-tip": "",
                    "_name": "",
                    "_tooltip": "",
                    "safe": "",
                    "safe-tip": ""
                },
                "choose-assets-on-launch": "",
                "audio-enable": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "video": {
                "show-fails-counter": "",
                "internal-res": {
                    "3ds": "",
                    "smbx-wide": "",
                    "nds": "",
                    "_tooltip": "",
                    "vga": "",
                    "hello": "",
                    "snes": "",
                    "hd": "",
                    "dynamic": "",
                    "gba": "",
                    "smbx": "",
                    "_name": ""
                },
                "battery-status": {
                    "fullscreen-tip": "",
                    "_name": "",
                    "fullscreen": "",
                    "off": "",
                    "on": "",
                    "low": "",
                    "low-tip": ""
                },
                "scale-mode": {
                    "2x": "",
                    "1x": "",
                    "0_5x": "",
                    "full": "",
                    "integer": "",
                    "nearest": "",
                    "center": "",
                    "linear": "",
                    "_name": "",
                    "3x": ""
                },
                "show-fails-counter-tip": "",
                "info-meta": "",
                "info-run": "",
                "info-game": "",
                "enable-inter-level-fade-effect": "",
                "fullscreen": "",
                "effects": "",
                "show-episode-title": {
                    "off": "",
                    "_name": "",
                    "top": "",
                    "bottom-tip": "",
                    "bottom": "",
                    "top-tip": ""
                },
                "_header": "",
                "3d-compat-mode": "",
                "show-playtime-counter": {
                    "_tooltip": "",
                    "_name": "",
                    "animated": "",
                    "off": "",
                    "off-tip": "",
                    "animated-tip": "",
                    "opaque": "",
                    "transparent": ""
                },
                "show-medals-counter": "",
                "show-medals-counter-tip": "",
                "show-fps": "",
                "video-system": "",
                "show-screen-shake": "",
                "world-map-stars-show": "",
                "world-map-stars-show-tip": "",
                "display-controllers": "",
                "3d-compat-mode-tip": ""
            },
            "episode-options": {
                "creator-compat": {
                    "_tooltip": "",
                    "disable": "",
                    "enable": "",
                    "file-only": "",
                    "_name": ""
                },
                "playstyle": {
                    "_name": "",
                    "classic": "",
                    "classic-tip": "",
                    "modern-tip": "",
                    "vanilla": "",
                    "vanilla-tip": "",
                    "modern": ""
                },
                "_header": "",
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "main": {
                "background-work": "",
                "background-work-tip": "",
                "four-screen-mode": {
                    "_name": "",
                    "split": "",
                    "shared": ""
                },
                "multiplayer": "",
                "two-screen-mode": {
                    "smbx": "",
                    "split": "",
                    "shared": "",
                    "_name": "",
                    "topbottom": ""
                },
                "language": "",
                "frame-skip": "",
                "discord-rpc": "",
                "timing": "",
                "_header": "",
                "vsync": "",
                "unlimited-framerate": ""
            },
            "speedrun": {
                "mode": {
                    "2": "",
                    "1": "",
                    "3": "",
                    "_name": "",
                    "0": ""
                }
            },
            "restartEngine": "",
            "audio": {
                "sfx-pet-beat": "",
                "audio-music-volume": "",
                "audio-prefs": "",
                "audio-sfx-volume": "",
                "sfx-pet-beat-tip": "",
                "sfx-spatial-audio": "",
                "sfx-spatial-audio-tip": "",
                "sfx-modern": "",
                "_header": "",
                "sfx-modern-tip": "",
                "sfx-audio-fx": ""
            },
            "compatibility": {
                "reset-all": "",
                "autocode": "",
                "_tooltip": "",
                "bugfixes": "",
                "features": "",
                "_header": ""
            },
            "controls": {
                "_header": ""
            },
            "view-credits": {
                "_header": ""
            }
        },
        "controls": {
            "options": {
                "batteryStatus": "",
                "rumble": "",
                "maxPlayers": "",
                "textEntryStyle": ""
            },
            "hotkeys": {
                "toggleHUD": "",
                "fullscreen": "",
                "recordGif": "",
                "legacyPause": "",
                "debugInfo": "",
                "enterCheats": "",
                "screenshot": "",
                "vanillaCam": ""
            },
            "profile": {
                "playerControls": "",
                "deleteProfile": "",
                "cursorControls": "",
                "hotkeys": "",
                "renameProfile": "",
                "editorControls": ""
            },
            "tDS": {
                "buttonA": "",
                "tStick": "",
                "dPad": "",
                "buttonY": "",
                "buttonSelect": "",
                "buttonB": "",
                "buttonZL": "",
                "casePen": "",
                "buttonX": "",
                "buttonR": "",
                "buttonL": "",
                "buttonStart": "",
                "cStick": "",
                "buttonZR": ""
            },
            "touchscreen": {
                "option": {
                    "resetLayout": "",
                    "scaleDPad": "",
                    "showCodeButton": "",
                    "feedbackLength": "",
                    "layoutStyle": "",
                    "feedbackStrength": "",
                    "interfaceStyle": "",
                    "holdRun": "",
                    "sStartSpacing": "",
                    "scaleFactor": "",
                    "scaleButtons": ""
                },
                "style": {
                    "XODA": "",
                    "ABXY": "",
                    "actions": ""
                },
                "layout": {
                    "phoneOld": "",
                    "standard": "",
                    "tabletOld": "",
                    "tinyOld": "",
                    "tight": "",
                    "longOld": "",
                    "phabletOld": ""
                }
            },
            "types": {
                "keyboard": "",
                "touchscreen": "",
                "gamepad": "",
                "oldJoystick": ""
            },
            "wii": {
                "nunchuck": {
                    "buttonC": "",
                    "buttonZ": "",
                    "prefixN": ""
                },
                "classic": {
                    "rStick": "",
                    "buttonLT": "",
                    "buttonRT": "",
                    "buttonZL": "",
                    "lStick": "",
                    "buttonZR": "",
                    "buttonY": "",
                    "buttonX": ""
                },
                "phraseNewNunchuck": "",
                "wiimote": {
                    "dPad": "",
                    "caseIR": "",
                    "shake": "",
                    "button2": "",
                    "buttonB": "",
                    "buttonMinus": "",
                    "buttonHome": "",
                    "buttonPlus": "",
                    "buttonA": "",
                    "button1": ""
                },
                "typeWiimote": "",
                "phraseNewClassic": "",
                "typeNunchuck": "",
                "typeClassic": "",
                "typeGamecube": ""
            },
            "buttons": {
                "altJump": "",
                "left": "",
                "jump": "",
                "up": "",
                "run": "",
                "start": "",
                "altRun": "",
                "down": "",
                "drop": "",
                "right": ""
            },
            "caseInvalid": "",
            "cursor": {
                "primary": "",
                "down": "",
                "tertiary": "",
                "right": "",
                "secondary": "",
                "up": "",
                "left": ""
            },
            "editor": {
                "scrollLeft": "",
                "scrollDown": "",
                "scrollRight": "",
                "scrollUp": "",
                "modeErase": "",
                "switchScreens": "",
                "testPlay": "",
                "prevSection": "",
                "nextSection": "",
                "modeSelect": "",
                "fastScroll": ""
            },
            "joystickSimpleEditor": "",
            "phraseNewProfOldJoy": "",
            "wordProfiles": "",
            "controlsDeviceTypes": "",
            "controlsReallyDeleteProfile": "",
            "controlsNewProfile": "",
            "controlsTitle": "",
            "caseTouch": "",
            "caseMouse": "",
            "controlsConnected": "",
            "controlsDeleteKey": "",
            "wordButtons": "",
            "controlsInUse": "",
            "controlsNotInUse": ""
        },
        "battle": {
            "errorNoLevels": ""
        },
        "abbrevMilliseconds": "",
        "character": {
            "selectCharacter": ""
        },
        "caseNone": "",
        "main": {
            "mainBattleGame": "",
            "mainMultiplayerGame": "",
            "mainExit": "",
            "main1PlayerGame": "",
            "mainEditor": "",
            "mainPlayEpisode": "",
            "mainOptions": ""
        },
        "game": {
            "gameSlotContinue": "",
            "gameSlotNew": "",
            "gameBattleRandom": "",
            "gameCopySave": "",
            "gameEraseSlot": "",
            "phraseTime": "",
            "phraseScore": "",
            "gameSourceSlot": "",
            "gameNoEpisodesToPlay": "",
            "gameEraseSave": "",
            "gameNoBattleLevels": "",
            "gameTargetSlot": "",
            "warnEpCompat": ""
        },
        "wordPlayer": "",
        "wordProfile": "",
        "loading": "",
        "wordOn": "",
        "wordOff": "",
        "wordNo": "",
        "wordHide": "",
        "wordBack": "",
        "wordYes": "",
        "wordResume": "",
        "wordWaiting": "",
        "wordShow": ""
    },
    "editor": {
        "file": {
            "convert": {
                "descNew": ""
            },
            "formatModern": "",
            "labelCurrentFile": "",
            "sectionWorld": "",
            "optionActionWithoutSave": "",
            "confirmConfirmAction": "",
            "actionClearWorld": "",
            "actionClearLevel": "",
            "confirmConvertFormatTo": "",
            "commandOpen": "",
            "commandSave": "",
            "commandSaveAs": "",
            "commandNew": "",
            "formatLegacy": "",
            "optionCancelConversion": "",
            "sectionLevel": "",
            "optionCancelAction": "",
            "optionYesSaveThenAction": "",
            "optionProceedWithConversion": "",
            "actionOpen": "",
            "confirmSaveBeforeAction": "",
            "actionRevert": "",
            "actionExit": "",
            "labelFormat": ""
        },
        "labelSortLayer": "",
        "labelSortOffset": "",
        "layers": {
            "abbrevAttLayer": "",
            "deletion": {
                "preserveLayerContents": "",
                "confirmPreserve": "",
                "confirmDelete": "",
                "header": "",
                "cancel": ""
            },
            "default": "",
            "header": "",
            "label": "",
            "labelAttachedLayer": "",
            "itemNewLayer": "",
            "labelAttached": "",
            "labelMoveLayer": "",
            "promptLayerName": "",
            "desc": {
                "att": ""
            }
        },
        "letterCoordY": "",
        "letterCoordX": "",
        "letterDown": "",
        "npc": {
            "ai": {
                "jump": "",
                "aiIs": "",
                "headerCustomAi": "",
                "target": "",
                "swim": "",
                "use1_0Ai": "",
                "UD": "",
                "leap": "",
                "LR": ""
            },
            "gen": {
                "header": "",
                "effectIs": "",
                "direction": "",
                "effectShoot": "",
                "effectWarp": ""
            },
            "inertNice": "",
            "props": {
                "active": "",
                "facing": "",
                "attachSurface": ""
            },
            "abbrevGen": "",
            "stuckStop": "",
            "inContainer": "",
            "tooltipExpandSection": ""
        },
        "level": {
            "gameStart": "",
            "bigBG": "",
            "alwaysVis": "",
            "pathUnlocks": "",
            "pathBG": "",
            "levelName": "",
            "startPos": ""
        },
        "phraseCountMore": "",
        "phraseDelayIsMs": "",
        "phraseSectionIndex": "",
        "phraseTextOf": "",
        "section": {
            "offscreenExit": "",
            "scroll": "",
            "setBounds": "",
            "vertWrap": "",
            "noTurnBack": "",
            "horizWrap": "",
            "underwater": ""
        },
        "select": {
            "sectionBlankPropBlank": "",
            "soundForEventN": "",
            "worldMusic": "",
            "warpTransitEffect": "",
            "pathBlankUnlock": "",
            "allSectPropBlankForEventN": "",
            "sectBlankPropBlankForEventN": ""
        },
        "testPlay": {
            "char": "",
            "magicHand": "",
            "boot": "",
            "power": "",
            "pet": ""
        },
        "tooltip": {
            "erase": "",
            "blocks": "",
            "layers": "",
            "scenes": "",
            "warps": "",
            "file": "",
            "area": "",
            "music": "",
            "settings": "",
            "water": "",
            "levels": "",
            "NPCs": "",
            "BGOs": "",
            "events": "",
            "paths": "",
            "tiles": "",
            "eraseAll": "",
            "select": "",
            "show": ""
        },
        "warp": {
            "transit": {
                "name3": "",
                "name1": "",
                "name2": "",
                "name4": "",
                "name5": "",
                "name0": ""
            },
            "item": "",
            "showStartScene": "",
            "to": "",
            "title": "",
            "effect": "",
            "cannonExit": "",
            "toMap": "",
            "twoWay": "",
            "out": "",
            "placing": "",
            "needStarCount": "",
            "speed": "",
            "style": {
                "blipInstant": "",
                "pipe": "",
                "door": "",
                "style": "",
                "portal": ""
            },
            "starLockMessage": "",
            "target": "",
            "in": "",
            "lvlWarp": "",
            "showStarCount": "",
            "needKey": "",
            "needFloor": "",
            "ride": "",
            "allow": "",
            "dir": ""
        },
        "wordEvent": {
            "genitive": "",
            "nominative": "",
            "typeLabel": ""
        },
        "world": {
            "allowChars": "",
            "hubWorld": "",
            "totalStars": "",
            "retryOnFail": "",
            "name": "",
            "introLevel": "",
            "phraseCreditIndex": ""
        },
        "water": {
            "title": ""
        },
        "wordInstant": "",
        "wordHeight": "",
        "wordEnabled": "",
        "wordWidth": "",
        "events": {
            "controlsForEventN": "",
            "bounds": {
                "changeAllSectionBoundsToCurrent": "",
                "changeSectionBoundsToCurrent": "",
                "shouldEvent": ""
            },
            "deletion": {
                "confirm": "",
                "deletingEvent": "",
                "cancel": ""
            },
            "header": "",
            "headerTriggerEvent": "",
            "letter": {
                "destroy": "",
                "hit": "",
                "enter": "",
                "activate": "",
                "death": "",
                "talk": "",
                "layerClear": ""
            },
            "layers": {
                "headerMove": "",
                "headerHide": "",
                "headerShow": "",
                "headerToggle": ""
            },
            "sections": {
                "actionKeep": "",
                "phraseAllSections": "",
                "propBackground": "",
                "propBounds": "",
                "actionSet": "",
                "actionReset": "",
                "propMusic": ""
            },
            "props": {
                "sound": "",
                "autostart": "",
                "layerSmoke": "",
                "controls": "",
                "endGame": ""
            },
            "desc": {
                "destroy": "",
                "death": "",
                "phraseTriggersWhenTemplate": "",
                "phraseTriggersAfterTemplate": "",
                "activate": "",
                "layerClear": "",
                "enter": "",
                "hit": "",
                "talk": ""
            },
            "label": {
                "death": "",
                "talk": "",
                "next": "",
                "layerClear": "",
                "enter": "",
                "destroy": "",
                "hit": "",
                "activate": ""
            },
            "settingsForEvent": "",
            "promptEventText": "",
            "itemNewEvent": "",
            "promptEventName": ""
        },
        "phraseGenericIndex": "",
        "block": {
            "letterWidth": "",
            "slick": "",
            "invis": "",
            "letterHeight": "",
            "canBreakTooltip": "",
            "pickContents": "",
            "inside": "",
            "canBreak": ""
        },
        "browser": {
            "newFile": "",
            "askOverwriteFile": "",
            "itemNewFile": "",
            "saveFile": "",
            "openFile": "",
            "itemNewFolder": ""
        },
        "mapPos": "",
        "wordMode": "",
        "wordNPC": {
            "genitive": "",
            "nominative": ""
        },
        "wordText": "",
        "letterUp": "",
        "letterLeft": "",
        "letterRight": "",
        "phraseWarpIndex": "",
        "toggleMagicBlock": "",
        "wordCoins": "",
        "pageBlankOfBlank": "",
        "phraseAreYouSure": "",
        "phraseRadiusIndex": ""
    },
    "game": {
        "connect": {
            "splitPressSelect_2": "",
            "dropAddTitle": "",
            "phraseDropMe": "",
            "phrasePressAButton": "",
            "phraseTestControls": "",
            "phraseWaitingForInput": "",
            "wordDisconnect": "",
            "reconnectTitle": "",
            "phraseTestProfile": "",
            "phraseDropPX": "",
            "phraseStartToResume": "",
            "phraseStartToForceRes": "",
            "phraseSetControls": "",
            "phraseHoldStart": "",
            "phraseChangeChar": "",
            "phraseForceResume": "",
            "splitPressSelect_1": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "pause": {
            "restartLevel": "",
            "continue": "",
            "saveAndContinue": "",
            "saveAndQuit": "",
            "returnToEditor": "",
            "quit": "",
            "enterCode": "",
            "quitTesting": "",
            "resetCheckpoints": "",
            "playerSetup": ""
        },
        "hint": {
            "no-lives-new": "",
            "no-lives-old": "",
            "char5-bombs": "",
            "gray-bricks": "",
            "rainbow-surf": "",
            "heavy-duck": "",
            "shoe-block": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "error": {
            "openFileFailed": "",
            "warpNeedStarCount": "",
            "errorInvalidEnterWarp": "",
            "errorNoStartPoint": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "msgbox": {
            "sysInfoTitle": "",
            "sysInfoWarning": "",
            "sysInfoError": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "languageName": "",
    "outro": {
        "nameVitalyNovichkov": "",
        "originalBy": "",
        "cppPortDevelopers": "",
        "qualityControl": "",
        "levelDesign": "",
        "gameCredits": "",
        "customSprites": "",
        "specialThanks": "",
        "engineCredits": "",
        "nameAndrewSpinks": "",
        "psVitaPortBy": ""
    },
    "pluralRules": ""
}


================================================
FILE: resources/languages/thextech_de.json
================================================
{
    "languageName": "Deutsch",
    "editor": {
        "browser": {
            "askOverwriteFile": "{0} überschreiben?",
            "itemNewFile": "<Neue Datei>",
            "itemNewFolder": "<Neuer Ordner>",
            "newFile": "Neue Datei",
            "openFile": "Datei öffnen",
            "saveFile": "Datei speichern"
        },
        "events": {
            "header": "Ereignisse:",
            "itemNewEvent": "<Neues Ereignis>",
            "bounds": {
                "changeAllSectionBoundsToCurrent": "Alle Sekt. Grenzen zur jetzigen ändern?",
                "changeSectionBoundsToCurrent": "{0} Sekt. Grenzen zur Jetzigen ändern?",
                "shouldEvent": "Sollte Event {0}"
            },
            "controlsForEventN": "Steuerung für Event {0}",
            "deletion": {
                "cancel": "Nein: Event nicht löschen",
                "confirm": "Ja: Event löschen",
                "deletingEvent": "Event {0} wird gelöscht"
            },
            "desc": {
                "activate": "NPC betritt Bildschirm",
                "death": "NPC stirbt",
                "destroy": "Block wird zerstört",
                "enter": "Warp wird betreten",
                "hit": "Block wird getroffen",
                "layerClear": "alles in der Objektebene ist verschwunden",
                "phraseTriggersAfterTemplate": "{0} wird {1} ms nach Event {2} ausgelöst",
                "phraseTriggersWhenTemplate": "{0} wird ausgelöst wenn {1}",
                "talk": "Spieler redet mit NPC"
            },
            "headerTriggerEvent": "Auslöser:",
            "label": {
                "activate": "Aktivieren",
                "death": "Tod",
                "destroy": "Zerstören",
                "enter": "Betreten",
                "hit": "Treffer",
                "layerClear": "Ebene leeren",
                "next": "Weiter",
                "talk": "Sprechen"
            },
            "layers": {
                "headerHide": "Verstecken:",
                "headerMove": "Bewegen:",
                "headerShow": "Zeigen:",
                "headerToggle": "Umschalten:"
            },
            "letter": {
                "activate": "A:",
                "death": "T:",
                "destroy": "Z:",
                "enter": "B:",
                "hit": "G:",
                "layerClear": "E:",
                "talk": "S:"
            },
            "promptEventName": "Event Name",
            "promptEventText": "Event Text",
            "props": {
                "controls": "Steuerung",
                "endGame": "Spiel beenden",
                "layerSmoke": "Rauch",
                "autostart": "",
                "sound": ""
            },
            "sections": {
                "actionKeep": "Behalten",
                "actionReset": "Zurücksetzen",
                "propBounds": "",
                "propMusic": "",
                "propBackground": "",
                "actionSet": "",
                "phraseAllSections": ""
            },
            "settingsForEvent": ""
        },
        "block": {
            "canBreak": "Zerstörbar",
            "canBreakTooltip": "Klassisch: Wird nach einem Treffer zerstört",
            "inside": "Inhalt:",
            "invis": "N. Sicht",
            "pickContents": "Wähle Block Inhalt",
            "slick": "Glatt",
            "letterHeight": "H ",
            "letterWidth": "B "
        },
        "layers": {
            "promptLayerName": "",
            "label": "",
            "deletion": {
                "header": "",
                "confirmDelete": "",
                "preserveLayerContents": "",
                "confirmPreserve": "",
                "cancel": ""
            },
            "header": "",
            "labelAttachedLayer": "",
            "labelMoveLayer": "",
            "desc": {
                "att": ""
            },
            "default": "",
            "itemNewLayer": "",
            "abbrevAttLayer": "",
            "labelAttached": ""
        },
        "warp": {
            "needStarCount": "",
            "item": "",
            "lvlWarp": "",
            "needKey": "",
            "placing": "",
            "to": "",
            "showStartScene": "",
            "twoWay": "",
            "needFloor": "",
            "style": {
                "door": "",
                "blipInstant": "",
                "pipe": "",
                "portal": "",
                "style": ""
            },
            "transit": {
                "name2": "",
                "name1": "",
                "name0": "",
                "name3": "",
                "name4": "",
                "name5": ""
            },
            "dir": "",
            "cannonExit": "",
            "allow": "",
            "in": "",
            "out": "",
            "starLockMessage": "",
            "title": "",
            "showStarCount": "",
            "effect": "",
            "target": "",
            "speed": "",
            "toMap": "",
            "ride": ""
        },
        "letterRight": "",
        "wordHeight": "",
        "file": {
            "commandSave": "",
            "convert": {
                "descNew": ""
            },
            "formatLegacy": "",
            "commandOpen": "",
            "labelFormat": "",
            "actionOpen": "",
            "optionCancelAction": "",
            "commandSaveAs": "",
            "actionRevert": "",
            "optionYesSaveThenAction": "",
            "optionActionWithoutSave": "",
            "confirmConvertFormatTo": "",
            "sectionWorld": "",
            "commandNew": "",
            "actionClearWorld": "",
            "optionProceedWithConversion": "",
            "confirmConfirmAction": "",
            "confirmSaveBeforeAction": "",
            "optionCancelConversion": "",
            "actionClearLevel": "",
            "actionExit": "",
            "sectionLevel": "",
            "labelCurrentFile": "",
            "formatModern": ""
        },
        "wordWidth": "",
        "select": {
            "warpTransitEffect": "",
            "soundForEventN": "",
            "pathBlankUnlock": "",
            "allSectPropBlankForEventN": "",
            "worldMusic": "",
            "sectBlankPropBlankForEventN": "",
            "sectionBlankPropBlank": ""
        },
        "tooltip": {
            "BGOs": "",
            "events": "",
            "eraseAll": "",
            "music": "",
            "erase": "",
            "settings": "",
            "NPCs": "",
            "water": "",
            "show": "",
            "paths": "",
            "tiles": "",
            "levels": "",
            "layers": "",
            "warps": "",
            "blocks": "",
            "file": "",
            "select": "",
            "scenes": "",
            "area": ""
        },
        "npc": {
            "ai": {
                "aiIs": "",
                "target": "",
                "swim": "",
                "jump": "",
                "leap": "",
                "UD": "",
                "headerCustomAi": "",
                "use1_0Ai": "",
                "LR": ""
            },
            "tooltipExpandSection": "",
            "stuckStop": "",
            "gen": {
                "header": "",
                "effectShoot": "",
                "direction": "",
                "effectWarp": "",
                "effectIs": ""
            },
            "props": {
                "attachSurface": "",
                "facing": "",
                "active": ""
            },
            "abbrevGen": "",
            "inertNice": "",
            "inContainer": ""
        },
        "letterLeft": "",
        "level": {
            "startPos": "",
            "pathBG": "",
            "pathUnlocks": "",
            "levelName": "",
            "gameStart": "",
            "alwaysVis": "",
            "bigBG": ""
        },
        "testPlay": {
            "magicHand": "",
            "power": "",
            "char": "",
            "pet": "",
            "boot": ""
        },
        "wordInstant": "",
        "letterDown": "",
        "mapPos": "",
        "world": {
            "introLevel": "",
            "hubWorld": "",
            "name": "",
            "phraseCreditIndex": "",
            "totalStars": "",
            "retryOnFail": "",
            "allowChars": ""
        },
        "letterCoordX": "",
        "water": {
            "title": ""
        },
        "wordMode": "",
        "phraseTextOf": "",
        "wordEnabled": "",
        "wordEvent": {
            "nominative": "",
            "typeLabel": "",
            "genitive": ""
        },
        "phraseSectionIndex": "",
        "wordCoins": "",
        "section": {
            "horizWrap": "",
            "setBounds": "",
            "noTurnBack": "",
            "underwater": "",
            "offscreenExit": "",
            "vertWrap": "",
            "scroll": ""
        },
        "phraseGenericIndex": "",
        "letterUp": "",
        "phraseCountMore": "",
        "wordNPC": {
            "nominative": "",
            "genitive": ""
        },
        "phraseRadiusIndex": "",
        "pageBlankOfBlank": "",
        "phraseWarpIndex": "",
        "labelSortLayer": "",
        "phraseAreYouSure": "",
        "toggleMagicBlock": "",
        "phraseDelayIsMs": "",
        "letterCoordY": "",
        "wordText": "",
        "labelSortOffset": ""
    },
    "menu": {
        "controls": {
            "touchscreen": {
                "option": {
                    "sStartSpacing": "",
                    "scaleFactor": "",
                    "resetLayout": "",
                    "layoutStyle": "",
                    "interfaceStyle": "",
                    "feedbackStrength": "",
                    "scaleButtons": "",
                    "scaleDPad": "",
                    "feedbackLength": "",
                    "holdRun": "",
                    "showCodeButton": ""
                },
                "layout": {
                    "phabletOld": "",
                    "longOld": "",
                    "tight": "",
                    "phoneOld": "",
                    "standard": "",
                    "tinyOld": "",
                    "tabletOld": ""
                },
                "style": {
                    "actions": "",
                    "XODA": "",
                    "ABXY": ""
                }
            },
            "profile": {
                "cursorControls": "",
                "playerControls": "",
                "renameProfile": "",
                "hotkeys": "",
                "deleteProfile": "",
                "editorControls": ""
            },
            "wii": {
                "typeClassic": "",
                "typeNunchuck": "",
                "wiimote": {
                    "caseIR": "",
                    "buttonPlus": "",
                    "buttonMinus": "",
                    "button1": "",
                    "buttonHome": "",
                    "buttonB": "",
                    "shake": "",
                    "button2": "",
                    "buttonA": "",
                    "dPad": ""
                },
                "classic": {
                    "lStick": "",
                    "buttonY": "",
                    "buttonRT": "",
                    "rStick": "",
                    "buttonLT": "",
                    "buttonX": "",
                    "buttonZR": "",
                    "buttonZL": ""
                },
                "phraseNewClassic": "",
                "nunchuck": {
                    "buttonC": "",
                    "buttonZ": "",
                    "prefixN": ""
                },
                "phraseNewNunchuck": "",
                "typeGamecube": "",
                "typeWiimote": ""
            },
            "tDS": {
                "buttonY": "",
                "cStick": "",
                "buttonB": "",
                "dPad": "",
                "tStick": "",
                "buttonZL": "",
                "casePen": "",
                "buttonStart": "",
                "buttonZR": "",
                "buttonA": "",
                "buttonSelect": "",
                "buttonX": "",
                "buttonL": "",
                "buttonR": ""
            },
            "buttons": {
                "altJump": "",
                "start": "",
                "down": "",
                "jump": "",
                "drop": "",
                "run": "",
                "altRun": "",
                "up": "",
                "left": "",
                "right": ""
            },
            "hotkeys": {
                "debugInfo": "",
                "vanillaCam": "",
                "screenshot": "",
                "recordGif": "",
                "fullscreen": "",
                "toggleHUD": "",
                "legacyPause": "",
                "enterCheats": ""
            },
            "types": {
                "oldJoystick": "",
                "keyboard": "",
                "touchscreen": "",
                "gamepad": ""
            },
            "editor": {
                "modeSelect": "",
                "scrollUp": "",
                "prevSection": "",
                "scrollRight": "",
                "switchScreens": "",
                "modeErase": "",
                "nextSection": "",
                "fastScroll": "",
                "scrollLeft": "",
                "testPlay": "",
                "scrollDown": ""
            },
            "cursor": {
                "left": "",
                "up": "",
                "down": "",
                "tertiary": "",
                "primary": "",
                "right": "",
                "secondary": ""
            },
            "wordProfiles": "",
            "controlsInUse": "",
            "controlsNewProfile": "",
            "options": {
                "batteryStatus": "",
                "textEntryStyle": "",
                "rumble": "",
                "maxPlayers": ""
            },
            "controlsDeleteKey": "",
            "controlsConnected": "",
            "controlsNotInUse": "",
            "controlsDeviceTypes": "",
            "phraseNewProfOldJoy": "",
            "caseInvalid": "",
            "joystickSimpleEditor": "",
            "caseTouch": "",
            "controlsReallyDeleteProfile": "",
            "controlsTitle": "",
            "caseMouse": "",
            "wordButtons": ""
        },
        "game": {
            "gameNoBattleLevels": "",
            "gameSourceSlot": "",
            "gameEraseSave": "",
            "warnEpCompat": "",
            "gameBattleRandom": "",
            "gameTargetSlot": "",
            "gameSlotContinue": "",
            "gameSlotNew": "",
            "phraseScore": "",
            "gameNoEpisodesToPlay": "",
            "phraseTime": "",
            "gameEraseSlot": "",
            "gameCopySave": ""
        },
        "options": {
            "advanced": {
                "_header": "",
                "choose-assets-on-launch": "",
                "_tooltip": "",
                "render": {
                    "opengles11-tip": "",
                    "opengl": "",
                    "opengl11": "",
                    "hw": "",
                    "opengl11-tip": "",
                    "opengles11": "",
                    "sdl-tip": "",
                    "opengles-tip": "",
                    "sw": "",
                    "opengles": "",
                    "_name": "",
                    "sdl": "",
                    "opengl-tip": ""
                },
                "audio-sample-rate": {
                    "32000": "",
                    "16000": "",
                    "_name": "",
                    "22050": "",
                    "44100": "",
                    "11025": "",
                    "48000": ""
                },
                "audio-format": {
                    "_tooltip": "",
                    "_name": ""
                },
                "log-level": {
                    "none": "",
                    "warning": "",
                    "fatal": "",
                    "debug": "",
                    "info": "",
                    "_name": "",
                    "critical": ""
                },
                "internal-res-4p": {
                    "default": "",
                    "qhd": "",
                    "fhd": "",
                    "_name": "",
                    "qsmbx": ""
                },
                "scale-down-textures": {
                    "safe": "",
                    "_name": "",
                    "_tooltip": "",
                    "all": "",
                    "safe-tip": "",
                    "none-tip": "",
                    "none": "",
                    "all-tip": ""
                },
                "audio-channels": {
                    "mono": "",
                    "stereo": "",
                    "_name": ""
                },
                "webm-recording": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "record-gameplay-data": "",
                "inaccurate-gifs": "",
                "audio-buffer-size": {
                    "_tooltip": "",
                    "_name": ""
                },
                "advanced-video": "",
                "audio-enable": "",
                "advanced-audio": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "video": {
                "internal-res": {
                    "smbx-wide": "",
                    "_tooltip": "",
                    "3ds": "",
                    "vga": "",
                    "snes": "",
                    "gba": "",
                    "hello": "",
                    "dynamic": "",
                    "hd": "",
                    "nds": "",
                    "_name": "",
                    "smbx": ""
                },
                "effects": "",
                "info-meta": "",
                "show-fails-counter-tip": "",
                "display-controllers": "",
                "world-map-stars-show-tip": "",
                "show-playtime-counter": {
                    "_tooltip": "",
                    "animated": "",
                    "_name": "",
                    "opaque": "",
                    "off-tip": "",
                    "off": "",
                    "transparent": "",
                    "animated-tip": ""
                },
                "_header": "",
                "show-episode-title": {
                    "top-tip": "",
                    "bottom-tip": "",
                    "bottom": "",
                    "top": "",
                    "_name": "",
                    "off": ""
                },
                "battery-status": {
                    "_name": "",
                    "low-tip": "",
                    "fullscreen-tip": "",
                    "on": "",
                    "low": "",
                    "fullscreen": "",
                    "off": ""
                },
                "scale-mode": {
                    "full": "",
                    "0_5x": "",
                    "2x": "",
                    "center": "",
                    "nearest": "",
                    "1x": "",
                    "linear": "",
                    "_name": "",
                    "integer": "",
                    "3x": ""
                },
                "fullscreen": "",
                "3d-compat-mode-tip": "",
                "info-game": "",
                "show-medals-counter": "",
                "info-run": "",
                "show-fps": "",
                "show-medals-counter-tip": "",
                "show-screen-shake": "",
                "3d-compat-mode": "",
                "video-system": "",
                "enable-inter-level-fade-effect": "",
                "show-fails-counter": "",
                "world-map-stars-show": ""
            },
            "compatibility": {
                "_header": "",
                "reset-all": "",
                "autocode": "",
                "_tooltip": "",
                "features": "",
                "bugfixes": ""
            },
            "main": {
                "two-screen-mode": {
                    "split": "",
                    "shared": "",
                    "topbottom": "",
                    "smbx": "",
                    "_name": ""
                },
                "background-work": "",
                "language": "",
                "unlimited-framerate": "",
                "_header": "",
                "four-screen-mode": {
                    "split": "",
                    "_name": "",
                    "shared": ""
                },
                "background-work-tip": "",
                "timing": "",
                "vsync": "",
                "multiplayer": "",
                "discord-rpc": "",
                "frame-skip": ""
            },
            "episode-options": {
                "_header": "",
                "playstyle": {
                    "classic-tip": "",
                    "vanilla-tip": "",
                    "vanilla": "",
                    "classic": "",
                    "modern": "",
                    "_name": "",
                    "modern-tip": ""
                },
                "creator-compat": {
                    "_name": "",
                    "disable": "",
                    "file-only": "",
                    "enable": "",
                    "_tooltip": ""
                },
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "audio": {
                "audio-sfx-volume": "",
                "_header": "",
                "audio-prefs": "",
                "sfx-audio-fx": "",
                "sfx-pet-beat": "",
                "audio-music-volume": "",
                "sfx-spatial-audio-tip": "",
                "sfx-pet-beat-tip": "",
                "sfx-spatial-audio": "",
                "sfx-modern": "",
                "sfx-modern-tip": ""
            },
            "speedrun": {
                "mode": {
                    "2": "",
                    "0": "",
                    "_name": "",
                    "3": "",
                    "1": ""
                }
            },
            "view-credits": {
                "_header": ""
            },
            "restartEngine": "",
            "controls": {
                "_header": ""
            }
        },
        "character": {
            "selectCharacter": ""
        },
        "wordHide": "",
        "wordWaiting": "",
        "main": {
            "mainEditor": "",
            "main1PlayerGame": "",
            "mainMultiplayerGame": "",
            "mainBattleGame": "",
            "mainPlayEpisode": "",
            "mainOptions": "",
            "mainExit": ""
        },
        "editor": {
            "makeFor": "",
            "newWorld": "",
            "errorMissingResources": "",
            "promptNewWorldName": "",
            "battles": ""
        },
        "wordPlayer": "",
        "wordBack": "",
        "battle": {
            "errorNoLevels": ""
        },
        "wordOn": "",
        "wordProfile": "",
        "loading": "",
        "wordShow": "",
        "caseNone": "",
        "wordNo": "",
        "wordYes": "",
        "abbrevMilliseconds": "",
        "wordResume": "",
        "wordOff": ""
    },
    "game": {
        "connect": {
            "phraseTestControls": "",
            "phraseChangeChar": "",
            "phraseTestProfile": "",
            "phrasePressAButton": "",
            "phraseSetControls": "",
            "splitPressSelect_2": "",
            "dropAddTitle": "",
            "phraseDropPX": "",
            "phraseStartToForceRes": "",
            "phraseForceResume": "",
            "splitPressSelect_1": "",
            "wordDisconnect": "",
            "phraseDropMe": "",
            "phraseStartToResume": "",
            "phraseHoldStart": "",
            "phraseWaitingForInput": "",
            "reconnectTitle": ""
        },
        "error": {
            "errorInvalidEnterWarp": "",
            "openFileFailed": "",
            "warpNeedStarCount": "",
            "errorNoStartPoint": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "pause": {
            "playerSetup": "",
            "restartLevel": "",
            "quit": "",
            "enterCode": "",
            "saveAndContinue": "",
            "resetCheckpoints": "",
            "saveAndQuit": "",
            "returnToEditor": "",
            "continue": "",
            "quitTesting": ""
        },
        "msgbox": {
            "sysInfoWarning": "",
            "sysInfoTitle": "",
            "sysInfoError": ""
        },
        "hint": {
            "heavy-duck": "",
            "char5-bombs": "",
            "shoe-block": "",
            "pound-altrun": "",
            "rainbow-surf": "",
            "pound-down": "",
            "no-lives-new": "",
            "gray-bricks": "",
            "no-lives-old": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "outro": {
        "originalBy": "",
        "qualityControl": "",
        "cppPortDevelopers": "",
        "nameAndrewSpinks": "",
        "customSprites": "",
        "specialThanks": "",
        "psVitaPortBy": "",
        "engineCredits": "",
        "levelDesign": "",
        "nameVitalyNovichkov": "",
        "gameCredits": ""
    },
    "pluralRules": ""
}


================================================
FILE: resources/languages/thextech_en.json
================================================
{
    "editor": {
        "block": {
            "canBreak": "Can Break",
            "canBreakTooltip": "Legacy: breaks when hit",
            "inside": "Inside:",
            "invis": "Invis",
            "letterHeight": "H ",
            "letterWidth": "W ",
            "pickContents": "Pick block contents",
            "slick": "Slick"
        },
        "browser": {
            "askOverwriteFile": "Overwrite {0}?",
            "itemNewFile": "<New File>",
            "itemNewFolder": "<New Folder>",
            "newFile": "New file",
            "openFile": "Open file",
            "saveFile": "Save file"
        },
        "events": {
            "bounds": {
                "changeAllSectionBoundsToCurrent": "Change all sect bounds to current?",
                "changeSectionBoundsToCurrent": "Change sect {0} bounds to current?",
                "shouldEvent": "Should Event {0}"
            },
            "controlsForEventN": "Controls for event {0}",
            "deletion": {
                "cancel": "No: do not delete event",
                "confirm": "Yes: delete event",
                "deletingEvent": "Deleting event {0}"
            },
            "desc": {
                "activate": "NPC enters the screen",
                "death": "NPC dies",
                "destroy": "block is destroyed",
                "enter": "warp is entered",
                "hit": "block is hit",
                "layerClear": "everything in object layer is gone",
                "phraseTriggersAfterTemplate": "{0} triggers {1} ms after event {2} occurs",
                "phraseTriggersWhenTemplate": "{0} triggers when {1}",
                "talk": "player talks to NPC"
            },
            "header": "Events:",
            "headerTriggerEvent": "Trigger:",
            "itemNewEvent": "<New Event>",
            "label": {
                "activate": "Activate",
                "death": "Death",
                "destroy": "Destroy",
                "enter": "Enter",
                "hit": "Hit",
                "layerClear": "Layer Clear",
                "next": "Next",
                "talk": "Talk"
            },
            "layers": {
                "headerHide": "Hide:",
                "headerMove": "Move:",
                "headerShow": "Show:",
                "headerToggle": "Toggle:"
            },
            "letter": {
                "activate": "A:",
                "death": "D:",
                "destroy": "D:",
                "enter": "E:",
                "hit": "H:",
                "layerClear": "L:",
                "talk": "T:"
            },
            "promptEventName": "Event name",
            "promptEventText": "Event text",
            "props": {
                "autostart": "Autostart",
                "controls": "Controls",
                "endGame": "End Game",
                "layerSmoke": "Smoke",
                "sound": "Sound"
            },
            "sections": {
                "actionKeep": "Keep",
                "actionReset": "Reset",
                "actionSet": "Set",
                "phraseAllSections": "All Sections",
                "propBackground": "BG",
                "propBounds": "Bounds",
                "propMusic": "Music"
            },
            "settingsForEvent": "Settings for event {0}"
        },
        "file": {
            "actionClearLevel": "Clear Level",
            "actionClearWorld": "Clear World",
            "actionExit": "Exit",
            "actionOpen": "Open",
            "actionRevert": "Revert",
            "commandNew": "New",
            "commandOpen": "Open...",
            "commandSave": "Save",
            "commandSaveAs": "Save as...",
            "confirmConfirmAction": "Are you sure you want to {0}?",
            "confirmConvertFormatTo": "Convert format to {0}?",
            "confirmSaveBeforeAction": "Save before you {0}?",
            "convert": {
                "descNew": "The file extension will change but the old file will NOT be deleted.\n\nPlease check for lost features after saving."
            },
            "formatLegacy": "Legacy",
            "formatModern": "Modern",
            "labelCurrentFile": "Current file: ",
            "labelFormat": "Format:",
            "optionActionWithoutSave": "{0} without saving",
            "optionCancelAction": "Cancel: do not {0}",
            "optionCancelConversion": "Cancel conversion",
            "optionProceedWithConversion": "Proceed with conversion",
            "optionYesSaveThenAction": "Yes: save then {0}",
            "sectionLevel": "Level",
            "sectionWorld": "World"
        },
        "labelSortLayer": "Sort Layer:",
        "labelSortOffset": "Sort Offset:",
        "layers": {
            "abbrevAttLayer": "Att: ",
            "default": "Default",
            "deletion": {
                "cancel": "Cancel: do not delete layer",
                "confirmDelete": "No: *DELETE ALL CONTENTS*",
                "confirmPreserve": "Yes: move to default layer",
                "header": "Deleting layer {0}",
                "preserveLayerContents": "Preserve layer contents?"
            },
            "desc": {
                "att": "Whenever the NPC moves, the attached layer moves following it"
            },
            "header": "Layers:",
            "itemNewLayer": "<New Layer>",
            "label": "Layer:",
            "labelAttached": "Attached:",
            "labelAttachedLayer": "Attached Layer:",
            "labelMoveLayer": "Move Layer:",
            "promptLayerName": "Layer name"
        },
        "letterCoordX": "X",
        "letterCoordY": "Y",
        "letterDown": "D",
        "letterLeft": "L",
        "letterRight": "R",
        "letterUp": "U",
        "level": {
            "alwaysVis": "Always Vis",
            "bigBG": "Big BG",
            "gameStart": "Game Start",
            "levelName": "Level Name",
            "pathBG": "Path BG",
            "pathUnlocks": "Path Unlocks",
            "startPos": "Start Pos"
        },
        "mapPos": "Map Pos:",
        "npc": {
            "abbrevGen": "Gen",
            "ai": {
                "LR": "LR",
                "UD": "UD",
                "aiIs": "AI: {0}",
                "headerCustomAi": "Custom AI:",
                "jump": "Jump",
                "leap": "Leap",
                "swim": "Swim",
                "target": "Target",
                "use1_0Ai": "Use 1.0 AI?"
            },
            "gen": {
                "direction": "Direction",
                "effectIs": "Effect: {0}",
                "effectShoot": "Shoot",
                "effectWarp": "Warp",
                "header": "Generator Settings"
            },
            "inContainer": "In",
            "inertNice": "Nice",
            "props": {
                "active": "Active",
                "attachSurface": "Attach",
                "facing": "Facing"
            },
            "stuckStop": "Stop",
            "tooltipExpandSection": "Expand section"
        },
        "pageBlankOfBlank": "Page {0} of {1}",
        "phraseAreYouSure": "Are you sure?",
        "phraseCountMore": "{0} More",
        "phraseDelayIsMs": "Delay: {0} ms",
        "phraseGenericIndex": "Number {0}",
        "phraseRadiusIndex": "Radius {0}",
        "phraseSectionIndex": "Section {0}",
        "phraseTextOf": "{0} Text",
        "phraseWarpIndex": "Warp {0}",
        "section": {
            "horizWrap": "Horiz. Wrap",
            "vertWrap": "Vert. Wrap",
            "noTurnBack": "No Turn Back",
            "offscreenExit": "Offscreen Exit",
            "scroll": "Scroll",
            "setBounds": "Set Bounds",
            "underwater": "Underwater"
        },
        "select": {
            "allSectPropBlankForEventN": "All Sect {0} for {1}",
            "pathBlankUnlock": "Path {0} Unlock By",
            "sectBlankPropBlankForEventN": "Sect {0} {1} for {2}",
            "sectionBlankPropBlank": "Section {0} {1}",
            "soundForEventN": "Sound for Event {0}",
            "warpTransitEffect": "Warp Transition Effect",
            "worldMusic": "World Music"
        },
        "testPlay": {
            "boot": "Boot",
            "char": "Char",
            "magicHand": "Magic Hand",
            "pet": "Pet",
            "power": "Power"
        },
        "toggleMagicBlock": "Magic Block",
        "tooltip": {
            "BGOs": "BGOs",
            "NPCs": "NPCs",
            "area": "Area",
            "blocks": "Blocks",
            "erase": "Erase",
            "eraseAll": "Erase All",
            "events": "Events",
            "file": "File",
            "layers": "Layers",
            "levels": "Levels",
            "music": "Music",
            "paths": "Paths",
            "scenes": "Scenes",
            "select": "Select",
            "settings": "Settings",
            "show": "Show",
            "tiles": "Tiles",
            "warps": "Warps",
            "water": "Water"
        },
        "warp": {
            "allow": "Allow:",
            "cannonExit": "Cannon Exit",
            "dir": "Dir.",
            "effect": "Effect:",
            "in": "In",
            "item": "Item",
            "lvlWarp": "Lvl Warp",
            "needFloor": "Need Floor",
            "needKey": "Need Key",
            "needStarCount": "Need {0} {1}",
            "out": "Out",
            "placing": "Placing:",
            "ride": "Ride",
            "showStarCount": "Show Star Count",
            "showStartScene": "Show Start Scene",
            "speed": "Speed ",
            "starLockMessage": "Star lock msg",
            "style": {
                "blipInstant": "Blip",
                "door": "Door",
                "pipe": "Pipe",
                "portal": "Port",
                "style": "Style: "
            },
            "target": "Target: ",
            "title": "Warp Settings",
            "to": "To: {0}",
            "toMap": "To Map",
            "transit": {
                "name0": "NONE",
                "name1": "SCROLL",
                "name2": "FADE",
                "name3": "CIRCLE",
                "name4": "FLIP (H)",
                "name5": "FLIP (V)"
            },
            "twoWay": "Two-Way"
        },
        "water": {
            "title": "Water Settings"
        },
        "wordCoins": "Coins",
        "wordEnabled": "Enabled",
        "wordEvent": {
            "genitive": "Event",
            "nominative": "Event",
            "typeLabel": "{0} Event:"
        },
        "wordHeight": "Height",
        "wordInstant": "Instant",
        "wordMode": "Mode",
        "wordNPC": {
            "genitive": "NPC",
            "nominative": "NPC"
        },
        "wordText": "Text",
        "wordWidth": "Width",
        "world": {
            "allowChars": "Allow Chars",
            "hubWorld": "Hub World",
            "introLevel": "Intro Level",
            "name": "World Name",
            "phraseCreditIndex": "World Credit Line {0}:",
            "retryOnFail": "Retry On Fail",
            "totalStars": "Total Stars: "
        }
    },
    "game": {
        "connect": {
            "dropAddTitle": "Drop/Add Players",
            "phraseChangeChar": "Change Char",
            "phraseDropMe": "Drop Me",
            "phraseDropPX": "Drop P{0}",
            "phraseForceResume": "Force Resume",
            "phraseHoldStart": "Hold Start",
            "phrasePressAButton": "Press A Button",
            "phraseSetControls": "Set Controls",
            "phraseStartToForceRes": "Press Start to Force Resume",
            "phraseStartToResume": "Press Start to Resume",
            "phraseTestControls": "Test Controls",
            "phraseTestProfile": "Test Profile",
            "phraseWaitingForInput": "Waiting for input device...",
            "reconnectTitle": "Reconnect",
            "splitPressSelect_1": "Press Select for",
            "splitPressSelect_2": "Controls Options",
            "wordDisconnect": "Disconnect"
        },
        "error": {
            "errorInvalidEnterWarp": "Can't start the level because of an invalid entrance warp {1} was specified.\nTotal warp entries: {2}\n\nFile: {0}",
            "errorNoStartPoint": "Can't start the level because of no available start points placed or entrance warp specified.\n\nFile: {0}",
            "openFileFailed": "Can't open \"{0}\": file doesn't exist or corrupted.",
            "warpNeedStarCount": "You need {0} {1} to enter.",
            "IPCTimeOut": "No responce from the connected Editor. Game will be closed.",
            "openIPCDataFailed": "Can't proceed received file data because of corruption or other errors.",
            "errorTooOldEngine": "Content requires a newer engine feature level ({0}) than the current version ({1}). Please update TheXTech.",
            "errorTooOldGameAssets": "Content requires a newer asset pack feature level ({0}) than the current asset pack ({1}). Please upgrade your game asset pack."
        },
        "hint": {
            "pound-altrun": "Press Alt Run to pound downwards!",
            "pound-down": "Press Down to pound downwards!",
            "no-lives-new": "No coins left? Take a loan! Just watch your score...",
            "no-lives-old": "Be careful - Game Over is imminent!",
            "rainbow-surf": "Grab, run, hold down, and let go to surf.",
            "char5-bombs": "Press Run to collect and Alt Run to throw.",
            "heavy-duck": "Duck to block most - but not all - flames!",
            "shoe-block": "Wearing this blocks most - but not all - flames!",
            "gray-bricks": "Some blocks are vulnerable to special powers."
        },
        "message": {
            "scanningLevels": "Scanning levels..."
        },
        "format": {
            "minutesSeconds": "{0}m{1}s"
        },
        "pause": {
            "continue": "Continue",
            "playerSetup": "Player Setup",
            "enterCode": "Enter Code",
            "quit": "Quit",
            "quitTesting": "Quit Testing",
            "resetCheckpoints": "Reset Checkpoints",
            "restartLevel": "Restart Level",
            "returnToEditor": "Return to Editor",
            "saveAndContinue": "Save and Continue",
            "saveAndQuit": "Save and Quit"
        },
        "msgbox": {
            "sysInfoError": "Error!",
            "sysInfoTitle": "Info",
            "sysInfoWarning": "Warning!"
        },
        "screenPaused": "Paused",
        "ipcStatus": {
            "dataAccepted": "Data accepted, the parsing started...",
            "dataTransferStarted": "Started data tansfer...",
            "dataValid": "Accepted data is valid",
            "errorTimeout": "ERROR: Wait time out.",
            "loadingdone": "Done. Starting game...",
            "waitingInput": "Waiting for input data..."
        },
        "loader": {
            "statusAssetPacks": "Asset packs",
            "statusFinishing": "Finishing...",
            "statusGameInfo": "Game info",
            "statusLoadData": "Loading data...",
            "statusLoadFile": "Load: {0}",
            "statusTranslations": "Translations",
            "loading": "Loading..."
        }
    },
    "languageName": "English",
    "menu": {
        "abbrevMilliseconds": "MS",
        "battle": {
            "errorNoLevels": "Can't start battle because of no levels available"
        },
        "caseNone": "<None>",
        "character": {
            "selectCharacter": "{0} game"
        },
        "controls": {
            "buttons": {
                "altJump": "Alt Jump",
                "altRun": "Alt Run",
                "down": "Down",
                "drop": "Drop Item",
                "jump": "Jump",
                "left": "Left",
                "right": "Right",
                "run": "Run",
                "start": "Start",
                "up": "Up"
            },
            "caseInvalid": "(Invalid)",
            "caseMouse": "(Mouse)",
            "caseTouch": "(Touch)",
            "controlsConnected": "Connected:",
            "controlsDeleteKey": "(Alt Jump to Delete)",
            "controlsDeleteKey2": "(Alt Run to Delete)",
            "controlsDeviceTypes": "Device Types",
            "controlsInUse": "(In Use)",
            "controlsNewProfile": "<New Profile>",
            "controlsNotInUse": "(Not In Use)",
            "controlsReallyDeleteProfile": "Really delete profile?",
            "controlsTitle": "Controls",
            "cursor": {
                "down": "Mouse Down",
                "left": "Mouse Left",
                "primary": "Primary",
                "right": "Mouse Right",
                "secondary": "Secondary",
                "tertiary": "Tertiary",
                "up": "Mouse Up"
            },
            "editor": {
                "fastScroll": "Fast Scrl",
                "modeErase": "Mode Erase",
                "modeSelect": "Mode Select",
                "nextSection": "Next Sect",
                "prevSection": "Prev Sect",
                "scrollDown": "Scrl Down",
                "scrollLeft": "Scrl Left",
                "scrollRight": "Scrl Right",
                "scrollUp": "Scrl Up",
                "switchScreens": "Show Pane",
                "testPlay": "Test Play"
            },
            "hotkeys": {
                "debugInfo": "Debug Info",
                "enterCheats": "Enter Code",
                "fullscreen": "Fullscreen",
                "legacyPause": "Old Pause",
                "recordGif": "Record GIF",
                "screenshot": "Screenshot",
                "toggleHUD": "Toggle HUD",
                "vanillaCam": "Vanilla Cam"
            },
            "options": {
                "batteryStatus": "Battery Status",
                "maxPlayers": "Max Players",
                "rumble": "Rumble",
                "altMenuControls": "Alt Menu Controls",
                "textEntryStyle": "Text Entry Style"
            },
            "joystickSimpleEditor": "Simple Editor Controls",
            "phraseNewProfOldJoy": "New Profile for Old Joystick",
            "profile": {
                "cursorControls": "Cursor controls",
                "deleteProfile": "Delete profile",
                "editorControls": "Editor controls",
                "hotkeys": "Hotkeys",
                "playerControls": "Player controls",
                "renameProfile": "Rename profile"
            },
            "tDS": {
                "buttonA": "A",
                "buttonB": "B",
                "buttonL": "L",
                "buttonR": "R",
                "buttonSelect": "Select",
                "buttonStart": "Start",
                "buttonX": "X",
                "buttonY": "Y",
                "buttonZL": "ZL",
                "buttonZR": "ZR",
                "cStick": "C-Stick",
                "casePen": "(Pen)",
                "dPad": "D-Pad",
                "tStick": "Thumb"
            },
            "touchscreen": {
                "layout": {
                    "longOld": "Long (Old)",
                    "phabletOld": "Phablet (Old)",
                    "phoneOld": "Phone (Old)",
                    "standard": "Standard",
                    "tabletOld": "Tablet (Old)",
                    "tight": "Tight",
                    "tinyOld": "Tiny (Old)"
                },
                "option": {
                    "feedbackLength": "Feedback Length",
                    "feedbackStrength": "Feedback Strength",
                    "holdRun": "Hold Run on Start",
                    "interfaceStyle": "Interface Style",
                    "layoutStyle": "Layout Style",
                    "resetLayout": "Reset Layout",
                    "sStartSpacing": "S-Start Spacing",
                    "scaleButtons": "Scale Buttons",
                    "scaleDPad": "Scale D-Pad",
                    "scaleFactor": "Scale Factor",
                    "showCodeButton": "Show Code Button"
                },
                "style": {
                    "ABXY": "ABXY",
                    "XODA": "XODA",
                    "actions": "Actions"
                }
            },
            "types": {
                "gamepad": "Gamepad",
                "keyboard": "Keyboard",
                "oldJoystick": "Old Joy",
                "touchscreen": "Touchscreen"
            },
            "wii": {
                "classic": {
                    "buttonLT": "LT",
                    "buttonRT": "RT",
                    "buttonX": "X",
                    "buttonY": "Y",
                    "buttonZL": "ZL",
                    "buttonZR": "ZR",
                    "lStick": "L-Pad",
                    "rStick": "R-Pad"
                },
                "nunchuck": {
                    "buttonC": "C",
                    "buttonZ": "Z",
                    "prefixN": "N"
                },
                "phraseNewClassic": "New Classic Profile",
                "phraseNewNunchuck": "New Nunchuck Profile",
                "typeClassic": "Classic",
                "typeNunchuck": "Nunchuck",
                "typeWiimote": "Wiimote",
                "typeGamecube": "GameCube",
                "wiimote": {
                    "button1": "1",
                    "button2": "2",
                    "buttonA": "A",
                    "buttonB": "B",
                    "buttonHome": "Home",
                    "buttonMinus": "-",
                    "buttonPlus": "+",
                    "caseIR": "(IR)",
                    "dPad": "D-Pad",
                    "shake": "Shake"
                }
            },
            "wordButtons": "Buttons",
            "wordProfiles": "Profiles"
        },
        "editor": {
            "errorMissingResources": "Sorry! You are missing {0}, required for the in-game editor.",
            "battles": "<Battle Levels>",
            "makeFor": "Make for:",
            "newWorld": "<New World>",
            "promptNewWorldName": "New world name"
        },
        "game": {
            "gameBattleRandom": "Random Level",
            "gameCopySave": "Copy save",
            "gameEraseSave": "Erase save",
            "gameEraseSlot": "Select the slot to erase",
            "gameNoBattleLevels": "<No battle levels>",
            "gameNoEpisodesToPlay": "<No episodes to play>",
            "warnEpCompat": "This episode was made for a different branch of SMBX and may not work properly.",
            "gameSlotContinue": "SLOT {0} ... {1}%",
            "gameSlotNew": "SLOT {0} ... NEW GAME",
            "gameSourceSlot": "Select the source slot",
            "gameTargetSlot": "Now select the target",
            "phraseScore": "Score: {0}",
            "phraseTime": "Time: {0}"
        },
        "loading": "Loading...",
        "main": {
            "main1PlayerGame": "1 Player Game",
            "mainBattleGame": "Battle Game",
            "mainEditor": "Editor",
            "mainExit": "Exit",
            "mainMultiplayerGame": "2 Player Game",
            "mainOptions": "Options",
            "mainPlayEpisode": "Play Episode"
        },
        "options": {
            "restartEngine": "Restart engine for changes to take effect.",
            "advanced": {
                "_header": "Advanced",
                "_tooltip": "Technical options for internal operations",
                "advanced-audio": "Audio",
                "advanced-video": "Video",
                "audio-buffer-size": {
                    "_name": "Buffer size",
                    "_tooltip": "Increase for fewer pops but more lag"
                },
                "audio-channels": {
                    "_name": "Channels",
                    "mono": "Mono",
                    "stereo": "Stereo"
                },
                "audio-enable": "Enable",
                "audio-format": {
                    "_name": "Audio format",
                    "_tooltip": "Format for sound driver"
                },
                "audio-sample-rate": {
                    "11025": "11025 Hz",
                    "16000": "16000 Hz",
                    "22050": "22050 Hz",
                    "32000": "32000 Hz",
                    "44100": "44100 Hz",
                    "48000": "48000 Hz",
                    "_name": "Sample rate"
                },
                "choose-assets-on-launch": "Choose assets on launch",
                "log-level": {
                    "_name": "Log level",
                    "critical": "Critical",
                    "debug": "Debug",
                    "fatal": "Fatal",
                    "info": "Info",
                    "none": "None",
                    "warning": "Warning"
                },
                "record-gameplay-data": "Record gameplay",
                "render": {
                    "_name": "Render mode",
                    "hw": "Auto",
                    "opengl": "OpenGL 3+",
                    "opengl-tip": "Desktop API with support for all new visual effects and full accuracy to SMBX64",
                    "opengl11": "OpenGL 1.1",
                    "opengl11-tip": "Legacy desktop API with full accuracy to SMBX64",
                    "opengles": "OpenGL ES 2+",
                    "opengles-tip": "Mobile API with support for all new visual effects and high accuracy to SMBX64",
                    "opengles11": "OpenGL ES 1.1+",
                    "opengles11-tip": "Legacy mobile API with full accuracy to SMBX64",
                    "sdl": "SDL2",
                    "sdl-tip": "Basic cross-platform render API",
                    "sw": "Software"
                },
                "scale-down-textures": {
                    "_name": "Scale down images",
                    "_tooltip": "Store images as 1x to save memory",
                    "all": "All",
                    "all-tip": "Less loading stutter than 'Safe'",
                    "none": "None",
                    "none-tip": "Least loading stutter",
                    "safe": "Safe",
                    "safe-tip": "Checks if images are in 2x format"
                },
                "use-native-osk": "Native OSK",
                "inaccurate-gifs": "Inaccurate GIFs",
                "inaccurate-gifs-tip": "Allows 3D effect when GIFs are present",
                "webm-recording": "WEBM recording",
                "internal-res-4p": {
                    "_name": "4P split screen size",
                    "default": "Default",
                    "fhd": "1920x1080 (FHD)",
                    "qhd": "2560x1440 (QHD)",
                    "qsmbx": "1600x1200 (QSMBX)"
                },
                "fullscreen-type": {
                    "_name": "Fullscreen type",
                    "auto": "Auto",
                    "desktop": "Desktop",
                    "desktop-tip": "Keep the current screen resolution",
                    "exclusive": "Exclusive",
                    "exclusive-tip": "Set physical screen resolution"
                },
                "fullscreen-depth": {
                    "16": "16-bit",
                    "32": "32-bit",
                    "_name": "Exclusive bit depth",
                    "auto": "Auto"
                },
                "fullscreen-res": "Exclusive res"
            },
            "audio": {
                "_header": "Audio",
                "audio-music-volume": "Music volume",
                "audio-prefs": "Preferences",
                "audio-sfx-volume": "SFX volume",
                "sfx-audio-fx": "Echo effects",
                "sfx-modern": "Modern SFX",
                "sfx-modern-tip": "Use sounds added in TheXTech",
                "sfx-pet-beat": "Pet grooves",
                "sfx-pet-beat-tip": "Play special groove when riding a pet",
                "sfx-spatial-audio": "Spatial audio",
                "sfx-spatial-audio-tip": "Reduce volume of offscreen sounds"
            },
            "compatibility": {
                "_header": "Session Tweaks",
                "_tooltip": "Options for compat or debugging",
                "autocode": "Autocode",
                "bugfixes": "Bugfixes",
                "features": "Features",
                "reset-all": "Reset All"
            },
            "controls": {
                "_header": "Controls"
            },
            "episode-options": {
                "_header": "Episode Options",
                "creator-compat": {
                    "_name": "Creator compat",
                    "_tooltip": "Logic tweaks by content creator",
                    "disable": "Disable",
                    "enable": "Enable",
                    "file-only": "File only"
                },
                "playstyle": {
                    "_name": "Playstyle",
                    "classic": "Classic",
                    "classic-tip": "Minimal updates",
                    "modern": "Modern",
                    "modern-tip": "All updates",
                    "vanilla": "Vanilla",
                    "vanilla-tip": "No updates"
                },
                "hub-resume": "Save warp in hub",
                "hub-resume-tip": "Resume play at the last warp you entered"
            },
            "main": {
                "_header": "Main",
                "background-work": "Run in background",
                "background-work-tip": "Play with joystick while game is unfocused",
                "four-screen-mode": {
                    "_name": "4P screen mode",
                    "shared": "Shared",
                    "split": "Split"
                },
                "frame-skip": "Frameskip",
                "discord-rpc": "Discord Integration",
                "language": "Language",
                "multiplayer": "Multiplayer",
                "timing": "Frame Timing",
                "two-screen-mode": {
                    "_name": "2P screen mode",
                    "shared": "Shared",
                    "smbx": "SMBX",
                    "split": "Left/Right",
                    "topbottom": "Top/Bottom"
                },
                "unlimited-framerate": "Unlimited framerate",
                "vsync": "V-Sync"
            },
            "video": {
                "_header": "Video",
                "battery-status": {
                    "_name": "Device battery status",
                    "fullscreen": "Fullscreen",
                    "fullscreen-tip": "Show when the game is fullscreen",
                    "low": "Low",
                    "low-tip": "Show when the battery is low",
                    "off": "Off",
                    "on": "Always"
                },
                "display-controllers": "Controls activity",
                "effects": "Screen Effects",
                "enable-inter-level-fade-effect": "Fade transitions",
                "fullscreen": "Fullscreen",
                "info-game": "Onscreen game info",
                "info-meta": "Onscreen meta info",
                "info-run": "Onscreen run info",
                "internal-res": {
                    "3ds": "800x480 (3DS)",
                    "_name": "Screen size",
                    "_tooltip": "Resolution of gameplay field",
                    "dynamic": "Dynamic",
                    "gba": "480x320 (GBA)",
                    "hd": "1280x720 (HD)",
                    "hello": "768x432 (HELLO)",
                    "nds": "512x384 (NDS)",
                    "smbx": "800x600 (SMBX)",
                    "smbx-wide": "SMBX (wide)",
                    "snes": "512x448 (SNES)",
                    "vga": "640x480 (VGA)"
                },
                "scale-mode": {
                    "0_5x": "0.5x",
                    "1x": "1x",
                    "2x": "2x",
                    "_name": "Scale mode",
                    "integer": "Integer",
                    "linear": "Smooth",
                    "nearest": "Nearest",
                    "full": "Full",
                    "center": "Center",
                    "3x": "3x"
                },
                "show-episode-title": {
                    "_name": "Episode name",
                    "bottom": "Bottom",
                    "bottom-tip": "Show above speedrun timer",
                    "off": "Off",
                    "top": "Top",
                    "top-tip": "Show above HUD at high resolution"
                },
                "3d-compat-mode": "3D compat mode",
                "3d-compat-mode-tip": "Draw all objects in one 3D plane",
                "show-fails-counter": "Fails counter",
                "show-fails-counter-tip": "Show fails on the episode and current level",
                "show-fps": "Framerate",
                "show-medals-counter": "Medals counter",
                "show-medals-counter-tip": "Show medals in HUD and at level entrance",
                "show-playtime-counter": {
                    "_name": "Playtime counter",
                    "_tooltip": "Show time spent on the episode and current attempt",
                    "animated": "Animated",
                    "animated-tip": "Adds a rainbow effect on level end",
                    "off": "Off",
                    "off-tip": "Show only during speedruns",
                    "opaque": "Opaque",
                    "transparent": "Transparent"
                },
                "show-screen-shake": "Screen shake",
                "video-system": "System",
                "world-map-stars-show": "World map stars",
                "world-map-stars-show-tip": "Show collected stars above levels"
            },
            "view-credits": {
                "_header": "View Credits"
            },
            "speedrun": {
                "mode": {
                    "0": "0",
                    "1": "1",
                    "2": "2",
                    "3": "3",
                    "_name": "Speedrun mode"
                }
            }
        },
        "wordBack": "Back",
        "wordHide": "Hide",
        "wordNo": "No",
        "wordOff": "Off",
        "wordOn": "On",
        "wordPlayer": "Player",
        "wordProfile": "Profile",
        "wordResume": "Resume",
        "wordShow": "Show",
        "wordWaiting": "Waiting",
        "wordYes": "Yes"
    },
    "outro": {
        "cppPortDevelopers": "C++ port developers:",
        "customSprites": "Custom Sprites:",
        "engineCredits": "Engine credits:",
        "gameCredits": "Game credits:",
        "levelDesign": "Level Design:",
        "nameAndrewSpinks": "Andrew Spinks",
        "nameVitalyNovichkov": "Vitaly Novichkov",
        "originalBy": "Original VB6 code By:",
        "psVitaPortBy": "PS Vita Port By:",
        "qualityControl": "Quality Control:",
        "specialThanks": "Special Thanks:"
    },
    "pluralRules": "one-is-singular"
}


================================================
FILE: resources/languages/thextech_es.json
================================================
{
    "editor": {
        "block": {
            "canBreak": "Se rompe",
            "canBreakTooltip": "Legado: se rompe cuando es golpeado",
            "inside": "Tiene:",
            "invis": "Invis",
            "slick": "Resbala",
            "pickContents": "Elegir contenido del bloque",
            "letterHeight": "Al",
            "letterWidth": "An"
        },
        "browser": {
            "askOverwriteFile": "Sobreescribir {0}?",
            "itemNewFile": "<Nuevo archivo>",
            "itemNewFolder": "<Nueva carpeta>",
            "newFile": "Nuevo archivo",
            "openFile": "Abrir archivo",
            "saveFile": "Guardar archivo"
        },
        "events": {
            "controlsForEventN": "Controles para evento {0}",
            "header": "Eventos:",
            "deletion": {
                "cancel": "No: No eliminar evento",
                "confirm": "Sí: Eliminar evento",
                "deletingEvent": "Eliminando evento {0}"
            },
            "desc": {
                "death": "NPC muere",
                "destroy": "Bloque es destruido",
                "hit": "Bloque es golpeado",
                "phraseTriggersWhenTemplate": "{0} desencadena cuando {1}",
                "talk": "Jugador habla a NPC",
                "phraseTriggersAfterTemplate": "{0} se activa {1} ms después del evento {2}",
                "activate": "NPC entra en la pantalla",
                "enter": "se ingresa al pasaje",
                "layerClear": "todo en la capa de objetos se ha ido"
            },
            "itemNewEvent": "<Nuevo evento>",
            "label": {
                "activate": "Activar",
                "destroy": "Destruir",
                "death": "Morir",
                "enter": "Ingresar",
                "hit": "Golpe",
                "next": "Siguiente",
                "talk": "Hablar",
                "layerClear": "Capa limpia"
            },
            "sections": {
                "phraseAllSections": "Todas las secciones",
                "propMusic": "Música",
                "actionReset": "Reiniciar",
                "actionSet": "Establecer",
                "actionKeep": "Mantener",
                "propBackground": "Fondo",
                "propBounds": "Límites"
            },
            "headerTriggerEvent": "Activa evento:",
            "letter": {
                "hit": "G:",
                "death": "M:",
                "talk": "H:",
                "enter": "I:",
                "destroy": "D:",
                "layerClear": "C:",
                "activate": "A:"
            },
            "promptEventText": "Texto del evento",
            "props": {
                "autostart": "Comenzar Automáticamente",
                "controls": "Controles",
                "endGame": "Final del Juego",
                "sound": "Sonido",
                "layerSmoke": "Humo"
            },
            "settingsForEvent": "Ajustes para el Evento {0}",
            "bounds": {
                "shouldEvent": "Debería el Evento {0}",
                "changeAllSectionBoundsToCurrent": "Cambiar todos los límites de la sección a los actuales?",
                "changeSectionBoundsToCurrent": "Cambiar los límites de la sección {0} a los actuales?"
            },
            "promptEventName": "Nombre del evento",
            "layers": {
                "headerMove": "Mover:",
                "headerHide": "Esconde:",
                "headerToggle": "Alternar:",
                "headerShow": "Muestra:"
            }
        },
        "file": {
            "actionExit": "Salir",
            "actionOpen": "Abrir",
            "actionRevert": "Revertir",
            "commandNew": "Nuevo",
            "commandOpen": "Abrir...",
            "commandSave": "Guardar",
            "formatModern": "Moderno",
            "optionCancelConversion": "Cancelar conversión",
            "commandSaveAs": "Guardar como...",
            "confirmConfirmAction": "¿Estás seguro de que quieres {0}?",
            "formatLegacy": "Legado",
            "optionActionWithoutSave": "{0} sin guardar",
            "optionProceedWithConversion": "Proceder con la conversión",
            "sectionLevel": "Nivel",
            "sectionWorld": "Mundo",
            "confirmConvertFormatTo": "Convertir formato a {0}?",
            "confirmSaveBeforeAction": "¿Guardar antes de {0}?",
            "labelFormat": "Formato:",
            "optionCancelAction": "Cancelar: no {0}",
            "optionYesSaveThenAction": "Sí: guardar entonces {0}",
            "actionClearWorld": "Mundo terminado",
            "actionClearLevel": "Nivel terminado",
            "labelCurrentFile": "Archivo actual: ",
            "convert": {
                "descNew": "La extensión de archivo cambiará, pero el archivo viejo NO SERÁ ELIMINADO.\n\nPor favor, revise las características perdidas después de guardar."
            }
        },
        "layers": {
            "deletion": {
                "cancel": "Cancelar: No eliminar capa",
                "header": "Eliminando capa {0}",
                "confirmDelete": "No: *BORRAR TODO EL CONTENIDO*",
                "preserveLayerContents": "¿Conservar el contenido de las capas?",
                "confirmPreserve": "Sí: pasar a la capa por defecto"
            },
            "header": "Capas:",
            "itemNewLayer": "<Nueva capa>",
            "label": "Capa:",
            "promptLayerName": "Nombre de la capa",
            "labelAttachedLayer": "Capa adjunta:",
            "labelMoveLayer": "Mover capa:",
            "desc": {
                "att": "Cada vez que el NPC se mueve, la capa adjunta se mueve siguiéndolo"
            },
            "default": "Por defecto",
            "abbrevAttLayer": "Att: ",
            "labelAttached": "Adjunto:"
        },
        "level": {
            "levelName": "Nombre del nivel",
            "startPos": "Pos Inicio",
            "pathBG": "Ruta BG",
            "pathUnlocks": "Desbloqueo de rutas",
            "gameStart": "Inicio del juego",
            "alwaysVis": "Siempre Vis",
            "bigBG": "Gran BG"
        },
        "wordEvent": {
            "typeLabel": "Evento {0}:",
            "nominative": "Evento",
            "genitive": "Evento"
        },
        "warp": {
            "needStarCount": "Requiere {0} {1}",
            "placing": "Colocación:",
            "to": "Hacia: {0}",
            "showStartScene": "Mostrar escena de inicio",
            "twoWay": "Dos-vías",
            "needFloor": "Necesita suelo",
            "style": {
                "door": "Puerta",
                "pipe": "Tubería",
                "portal": "Puerto",
                "style": "Estilo: ",
                "blipInstant": "Instantáneo"
            },
            "cannonExit": "Salida del cañón",
            "transit": {
                "name1": "DESPLAZAMIENTO",
                "name3": "CÍRCULO",
                "name2": "DESVANECER",
                "name0": "NADA",
                "name4": "VOLTEAR (H)",
                "name5": "VOLTEAR (V)"
            },
            "allow": "Permitir:",
            "starLockMessage": "Mensaje de bloqueo de estrella",
            "showStarCount": "Mostrar recuento de estrellas",
            "effect": "Efecto:",
            "target": "Objetivo: ",
            "speed": "Velocidad ",
            "toMap": "Hacia el Mapa",
            "item": "Objeto",
            "needKey": "Requiere Llave",
            "in": "Entrada",
            "out": "Salida",
            "title": "Configuración de Pasaje",
            "ride": "Montar",
            "lvlWarp": "Pasaje de Nivel",
            "dir": "Dir."
        },
        "letterRight": "R",
        "select": {
            "warpTransitEffect": "Efecto de transición Warp",
            "soundForEventN": "Sonido para Evento {0}",
            "pathBlankUnlock": "Ruta {0} Desbloquear Por",
            "worldMusic": "Música del mundo",
            "sectionBlankPropBlank": "Sección {0} {1}",
            "sectBlankPropBlankForEventN": "{1} de Secc {0} para {2}",
            "allSectPropBlankForEventN": "{1} de Todas SS para {2}"
        },
        "tooltip": {
            "BGOs": "BGOs",
            "events": "Eventos",
            "eraseAll": "Borrar todo",
            "music": "Música",
            "erase": "Borrar",
            "settings": "Ajustes",
            "water": "Agua",
            "show": "Mostrar",
            "paths": "Caminos",
            "levels": "Niveles",
            "layers": "Capas",
            "file": "Archivo",
            "select": "Seleccione",
            "scenes": "Escenas",
            "tiles": "Baldosas",
            "warps": "Pasajes",
            "blocks": "Bloques",
            "area": "Área",
            "NPCs": "NPCs"
        },
        "npc": {
            "ai": {
                "aiIs": "AI: {0}",
                "target": "Objetivo",
                "swim": "Nadar",
                "jump": "Saltar",
                "leap": "Salto",
                "UD": "UD",
                "headerCustomAi": "IA personalizada:",
                "use1_0Ai": "¿Usar IA 1.0?",
                "LR": "LR"
            },
            "tooltipExpandSection": "Ampliar sección",
            "stuckStop": "Detener",
            "gen": {
                "header": "Ajustes del generador",
                "effectShoot": "Dispara a",
                "direction": "Dirección",
                "effectWarp": "Warp",
                "effectIs": "Efecto: {0}"
            },
            "props": {
                "attachSurface": "Adjuntar",
                "facing": "Frente a",
                "active": "Activo"
            },
            "abbrevGen": "Gen",
            "inertNice": "Bonito",
            "inContainer": "En"
        },
        "letterLeft": "L",
        "testPlay": {
            "magicHand": "Mano mágica",
            "power": "Potencia",
            "char": "Pers",
            "pet": "Mascota",
            "boot": "Bota"
        },
        "letterDown": "D",
        "mapPos": "Mapa Pos:",
        "letterCoordX": "X",
        "water": {
            "title": "Ajustes de agua"
        },
        "phraseTextOf": "{0} Texto",
        "wordEnabled": "Activado",
        "phraseSectionIndex": "Sección {0}",
        "wordCoins": "Monedas",
        "section": {
            "setBounds": "Establecer límites",
            "noTurnBack": "Sin vuelta atrás",
            "underwater": "Bajo el agua",
            "offscreenExit": "Salida fuera de pantalla",
            "scroll": "Desplácese por",
            "horizWrap": "Env. Horizontal",
            "vertWrap": "Env. Vertical"
        },
        "phraseGenericIndex": "Número {0}",
        "letterUp": "U",
        "phraseCountMore": "{0} Más",
        "phraseRadiusIndex": "Radio {0}",
        "pageBlankOfBlank": "Página {0} de {1}",
        "phraseWarpIndex": "Pasaje {0}",
        "phraseAreYouSure": "¿Seguro?",
        "toggleMagicBlock": "Bloque mágico",
        "phraseDelayIsMs": "Retraso: {0} ms",
        "letterCoordY": "Y",
        "wordHeight": "Alto",
        "wordWidth": "Ancho",
        "wordInstant": "Instante",
        "world": {
            "introLevel": "Nivel de Introducción",
            "name": "Nombre del Mundo",
            "phraseCreditIndex": "Línea {0} de Créditos del Mundo:",
            "retryOnFail": "Reintentar En Fallo",
            "allowChars": "Permitir Personajes",
            "totalStars": "Estrellas en total: ",
            "hubWorld": "Mundo de Centro"
        },
        "wordMode": "Modo",
        "wordText": "Texto",
        "labelSortLayer": "Ordenar Capa:",
        "labelSortOffset": "Ordenar Desplazamiento:",
        "wordNPC": {
            "genitive": "NPC",
            "nominative": "NPC"
        }
    },
    "menu": {
        "game": {
            "gameNoBattleLevels": "<Sin niveles de batalla>",
            "gameSourceSlot": "Seleccione la ranura de origen",
            "gameEraseSave": "Borrar guardar",
            "gameBattleRandom": "Nivel aleatorio",
            "gameTargetSlot": "Ahora seleccione el objetivo",
            "gameSlotContinue": "SLOT {0} ... {1}%",
            "gameSlotNew": "SLOT {0} ... NUEVO",
            "phraseScore": "Puntuación: {0}",
            "gameNoEpisodesToPlay": "<Sin episodios que reproducir>",
            "phraseTime": "Tiempo: {0}",
            "gameEraseSlot": "Seleccione la ranura que desea borrar",
            "gameCopySave": "Copiar guardar",
            "warnEpCompat": "Este episodio se hizo para una rama diferente de SMBX y tal vez no funcionará bien."
        },
        "editor": {
            "newWorld": "<Nuevo Mundo>",
            "errorMissingResources": "Lo sentimos. Te falta {0}, necesario para el editor del juego.",
            "promptNewWorldName": "Nombre del mundo nuevo",
            "battles": "<Niveles de Batalla>",
            "makeFor": "Hacer para:"
        },
        "wordHide": "Ocultar",
        "options": {
            "restartEngine": "Reinicie el motor para que los cambios surtan efecto.",
            "advanced": {
                "render": {
                    "opengl": "OpenGL 3+",
                    "opengles-tip": "",
                    "sdl-tip": "",
                    "opengl11-tip": "",
                    "sdl": "SDL2",
                    "opengles": "OpenGL ES 2+",
                    "_name": "Moda de renderizado",
                    "opengles11": "OpenGL ES 1.1+",
                    "opengles11-tip": "",
                    "sw": "Software",
                    "hw": "Auto",
                    "opengl-tip": "",
                    "opengl11": "OpenGL 1.1"
                },
                "scale-down-textures": {
                    "all-tip": "Menos tartamudeo al cargar que 'Seguras'",
                    "none": "Ningunas",
                    "_tooltip": "Almacenar las imágenes a 1x para ahorrar la memoria",
                    "all": "Todas",
                    "_name": "Reducir imágenes",
                    "none-tip": "Lo menos tartamudeo al cargar",
                    "safe": "Seguras",
                    "safe-tip": "Verifica que las imágenes estén en formato 2x"
                },
                "audio-sample-rate": {
                    "48000": "48000 Hz",
                    "32000": "32000 Hz",
                    "11025": "11025 Hz",
                    "44100": "44100 Hz",
                    "_name": "Frecuencia de muestreo",
                    "16000": "16000 Hz",
                    "22050": "22050 Hz"
                },
                "choose-assets-on-launch": "Seleccionar activos en lanzar",
                "log-level": {
                    "_name": "Nivel de registrar",
                    "critical": "Crítico",
                    "none": "Nada",
                    "info": "Info",
                    "fatal": "Fatal",
                    "warning": "Aviso",
                    "debug": "Depurar"
                },
                "audio-channels": {
                    "mono": "Mono",
                    "stereo": "Stereo",
                    "_name": "Canales"
                },
                "internal-res-4p": {
                    "qhd": "2560x1440 (QHD)",
                    "_name": "Tamaño de pantalla dividida 4P",
                    "default": "Por defecto",
                    "fhd": "1920x1080 (FHD)",
                    "qsmbx": "1600x1200 (QSMBX)"
                },
                "webm-recording": "Grabación WEBM",
                "advanced-audio": "Áudio",
                "advanced-video": "Video",
                "_header": "Avanzado",
                "_tooltip": "Opciones tecnicales para las operaciones internales",
                "record-gameplay-data": "Grabar jugación",
                "audio-buffer-size": {
                    "_tooltip": "Aumenta para menos estallidos pero más retraso",
                    "_name": "Tamaño de búfer"
                },
                "audio-format": {
                    "_name": "Formato de áudio",
                    "_tooltip": "Formato para controlador de sondio"
                },
                "audio-enable": "Activar",
                "use-native-osk": "Teclado del sistema",
                "inaccurate-gifs-tip": "Permite efecto 3D cuando hay imagenes GIF",
                "inaccurate-gifs": "GIF inexactos",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "audio": {
                "sfx-audio-fx": "Efectos de eco",
                "sfx-modern": "Sonidos modernos",
                "audio-prefs": "Preferencias",
                "sfx-modern-tip": "Usar sonidos añadidos en TheXTech",
                "audio-sfx-volume": "Volumen de sonidos",
                "sfx-spatial-audio-tip": "Reducir el volumen de sonidos lejos",
                "sfx-spatial-audio": "Áudio espacial",
                "sfx-pet-beat-tip": "Reproducir un ritmo especial a montar una mascota",
                "sfx-pet-beat": "Ritmo de mascota",
                "audio-music-volume": "Volumen de música",
                "_header": "Áudio"
            },
            "episode-options": {
                "creator-compat": {
                    "_name": "Compat de creador",
                    "file-only": "Sólo archivo",
                    "enable": "Activar",
                    "disable": "Desactivar",
                    "_tooltip": "Ajustes logicales por el creador del contenido"
                },
                "_header": "Opciones de Episodio",
                "playstyle": {
                    "_name": "Estilo de juego",
                    "modern": "Moderno",
                    "classic": "Clásico",
                    "classic-tip": "Actualizaciones minimales",
                    "vanilla-tip": "Ningunas actualizaciones",
                    "modern-tip": "Todas actualizaciones",
                    "vanilla": "Vainilla"
                },
                "hub-resume-tip": "Resumir el juego en la próxima pasaja ingresada",
                "hub-resume": "Grabar pasaja en centro"
            },
            "video": {
                "effects": "Efectos de Pantalla",
                "enable-inter-level-fade-effect": "Transiciones",
                "info-meta": "Info. en pantalla de sistema",
                "internal-res": {
                    "vga": "640x480 (VGA)",
                    "snes": "512x448 (SNES)",
                    "hd": "1280x720 (HD)",
                    "_tooltip": "Resolución del campo de jugación",
                    "dynamic": "Dinámico",
                    "hello": "768x432 (HELLO)",
                    "gba": "480x320 (GBA)",
                    "_name": "Tamaño de pantalla",
                    "3ds": "800x480 (3DS)",
                    "smbx": "800x600 (SMBX)",
                    "smbx-wide": "SMBX (ancha)",
                    "nds": "512x384 (NDS)"
                },
                "scale-mode": {
                    "1x": "1x",
                    "0_5x": "0,5x",
                    "_name": "Modo de escala",
                    "2x": "2x",
                    "nearest": "Cercana",
                    "full": "Completa",
                    "center": "Centrada",
                    "linear": "Lineal",
                    "integer": "Entera",
                    "3x": ""
                },
                "info-game": "Info. en pantalla de juego",
                "show-playtime-counter": {
                    "off-tip": "Muestra sólo en las carreras rápidas",
                    "_tooltip": "Muestra el tiempo pasado en el episodio y el intento actual",
                    "opaque": "Opaco",
                    "_name": "Temporizador de carrera",
                    "transparent": "Transparente",
                    "animated-tip": "Añade un efecto arcoiris a completar un nivel",
                    "animated": "Animado",
                    "off": "Desactivado"
                },
                "3d-compat-mode-tip": "Dibuja todos objetos en un solo plano 3D",
                "show-fails-counter": "Contador de fallos",
                "show-episode-title": {
                    "_name": "Nombre del episodio",
                    "top": "Superior",
                    "top-tip": "Muestra sobre HUD a alta resolución",
                    "off": "Desactivado",
                    "bottom-tip": "Muestra sobre temporizador de carrera",
                    "bottom": "Inferior"
                },
                "video-system": "Sistema",
                "world-map-stars-show-tip": "Muestra estrellas recogidas sobre los niveles",
                "world-map-stars-show": "Estrellas en mapa mundial",
                "battery-status": {
                    "fullscreen": "Pantalla completa",
                    "_name": "Estado de pila",
                    "off": "Nunca",
                    "fullscreen-tip": "Muestra cuando el juego está en pantalla completa",
                    "on": "Siempre",
                    "low": "Bajo",
                    "low-tip": "Muestra cuando el nivel de la pila está bajo"
                },
                "_header": "Video",
                "show-medals-counter": "Contador de medallas",
                "show-fps": "Frecuencia de cuadros",
                "show-medals-counter-tip": "Muestra las medallas en el HUD y en las entradas de nivel",
                "show-fails-counter-tip": "Muestra los fallos en el episodio y el nivel actual",
                "info-run": "Info. en pantalla de carrera",
                "3d-compat-mode": "Modo de compat 3D",
                "fullscreen": "Pantalla completa",
                "show-screen-shake": "Movimiento de pantalla",
                "display-controllers": "Actividad de controles"
            },
            "view-credits": {
                "_header": "Ver Créditos"
            },
            "speedrun": {
                "mode": {
                    "_name": "Modo de carrera rápida",
                    "3": "3",
                    "2": "2",
                    "0": "0",
                    "1": "1"
                }
            },
            "compatibility": {
                "_header": "Ajustes de sesión",
                "_tooltip": "Opciones para compat o depuración",
                "reset-all": "Restablecar todo",
                "features": "Funciones nuevas",
                "bugfixes": "Corrección de errores",
                "autocode": "Autocode"
            },
            "controls": {
                "_header": "Controles"
            },
            "main": {
                "four-screen-mode": {
                    "_name": "Modo de pantalla 4P",
                    "split": "Dividida",
                    "shared": "Compartida"
                },
                "background-work-tip": "Jugar con joystick cuando el juego está en segundo plano",
                "background-work": "Continuar en fondo",
                "vsync": "V-Sync",
                "discord-rpc": "Integración con Discord",
                "frame-skip": "Saltado de cuadro",
                "_header": "Principal",
                "language": "Idioma",
                "two-screen-mode": {
                    "_name": "Modo de pantalla 2P",
                    "split": "Izq/Der",
                    "topbottom": "Arriba/Abajo",
                    "smbx": "SMBX",
                    "shared": "Compartida"
                },
                "timing": "Sincronización de Cuadros",
                "multiplayer": "Multijugador",
                "unlimited-framerate": "Modo turbo"
            }
        },
        "wordWaiting": "En espera",
        "main": {
            "mainEditor": "Editor",
            "main1PlayerGame": "Juego para 1 jugador",
            "mainMultiplayerGame": "Juego para 2 jugadores",
            "mainBattleGame": "Juego de batalla",
            "mainOptions": "Opciones",
            "mainExit": "Salir",
            "mainPlayEpisode": "Jugar Episodio"
        },
        "controls": {
            "wii": {
                "wiimote": {
                    "caseIR": "(IR)",
                    "buttonPlus": "+",
                    "buttonMinus": "-",
                    "buttonHome": "Inicio",
                    "shake": "Agitar",
                    "dPad": "D-Pad",
                    "buttonA": "A",
                    "buttonB": "B",
                    "button1": "1",
                    "button2": "2"
                },
                "classic": {
                    "buttonLT": "LT",
                    "buttonY": "Y",
                    "rStick": "R-Joy",
                    "buttonX": "X",
                    "buttonZR": "ZR",
                    "buttonRT": "RT",
                    "buttonZL": "ZL",
                    "lStick": "L-Joy"
                },
                "nunchuck": {
                    "prefixN": "N",
                    "buttonZ": "Z",
                    "buttonC": "C"
                },
                "typeClassic": "Classic",
                "typeNunchuck": "Nunchuk",
                "phraseNewNunchuck": "Nuevo Perfil Nunchuk",
                "typeWiimote": "Wii Remote",
                "phraseNewClassic": "Nuevo Perfil Classic",
                "typeGamecube": ""
            },
            "wordProfiles": "Perfiles",
            "wordButtons": "Botones",
            "buttons": {
                "altJump": "Salto Alt",
                "start": "Comenzar",
                "down": "Abajo",
                "jump": "Saltar",
                "drop": "Soltar Objeto",
                "run": "Correr",
                "altRun": "Correr Alt",
                "up": "Arriba",
                "left": "Izquierda",
                "right": "Derecha"
            },
            "controlsInUse": "(En uso)",
            "controlsNewProfile": "<Nuevo Perfil>",
            "controlsDeleteKey": "(Salto Alt para Borrar)",
            "controlsDeleteKey2": "(Correr Alt para Borrar)",
            "controlsNotInUse": "(No en uso)",
            "tDS": {
                "buttonStart": "Comenzar",
                "casePen": "(Lápiz)",
                "cStick": "Palanca C",
                "buttonL": "L",
                "buttonB": "B",
                "buttonR": "R",
                "dPad": "Cruz de control",
                "buttonY": "Y",
                "buttonZR": "ZR",
                "buttonZL": "ZL",
                "buttonA": "A",
                "buttonSelect": "Select",
                "buttonX": "X",
                "tStick": "Deslizante"
            },
            "controlsDeviceTypes": "Tipos de Dispositivo",
            "caseInvalid": "(Inválido)",
            "controlsReallyDeleteProfile": "¿Realmente eliminar perfil?",
            "controlsTitle": "Controles",
            "touchscreen": {
                "option": {
                    "holdRun": "Mantener \"Correr\" al Comenzar",
                    "showCodeButton": "Mostrar Botón de Código",
                    "feedbackLength": "Duración de Vibración",
                    "interfaceStyle": "Estilo de Botones",
                    "resetLayout": "Restablecer Diseño",
                    "layoutStyle": "Estilo de Diseño",
                    "feedbackStrength": "Fuerza de Vibración",
                    "scaleButtons": "Escala de Botones",
                    "scaleDPad": "Escala de Cruceta",
                    "sStartSpacing": "S-Start Espaciado",
                    "scaleFactor": "Factor de Escala"
                },
                "layout": {
                    "standard": "Estándar",
                    "phabletOld": "Phablet (Legado)",
                    "tight": "Ajustado",
                    "tabletOld": "Tableta (Legado)",
                    "phoneOld": "Móbil (Legado)",
                    "tinyOld": "Diminuto (Old)",
                    "longOld": "Largo (Legado)"
                },
                "style": {
                    "ABXY": "ABXY",
                    "actions": "Acciones",
                    "XODA": "XODA"
                }
            },
            "cursor": {
                "secondary": "Secundario",
                "tertiary": "Terciario",
                "primary": "Primario",
                "left": "Ratón Izquierdo",
                "right": "Ratón Derecho",
                "down": "Ratón Abajo",
                "up": "Ratón Arriba"
            },
            "hotkeys": {
                "screenshot": "Captura de Pantalla",
                "debugInfo": "Información de Depuración",
                "enterCheats": "Introducir Código",
                "fullscreen": "Pantalla Completa",
                "toggleHUD": "Alternar HUD",
                "recordGif": "Grabar GIF",
                "vanillaCam": "Vainilla Cam",
                "legacyPause": "Pausa Legada"
            },
            "profile": {
                "deleteProfile": "Eliminar perfil",
                "cursorControls": "Controles de cursor",
                "playerControls": "Controles del juego",
                "renameProfile": "Renombrar perfil",
                "editorControls": "Controles de editor",
                "hotkeys": "Teclas rápidas"
            },
            "types": {
                "keyboard": "Teclado",
                "touchscreen": "Pantalla Táctil",
                "oldJoystick": "Joy Legado",
                "gamepad": "Joystick"
            },
            "caseTouch": "(Táctil)",
            "options": {
                "batteryStatus": "Estado de Batería",
                "rumble": "Vibración",
                "textEntryStyle": "Estilo de entrada de texto",
                "maxPlayers": "Max de Jugadores"
            },
            "editor": {
                "testPlay": "Juego de Prueba",
                "scrollLeft": "Despl Izq",
                "scrollRight": "Despl Der",
                "scrollDown": "Despl Abajo",
                "modeErase": "Modo Borrar",
                "switchScreens": "Mostrar Panel",
                "fastScroll": "Apurarse",
                "modeSelect": "Modo Sel.",
                "nextSection": "Secc Prox",
                "prevSection": "Secc Ult",
                "scrollUp": "Despl Arr"
            },
            "controlsConnected": "Conectado:",
            "joystickSimpleEditor": "Controles de Editor Sensillos",
            "caseMouse": "(Ratón)",
            "phraseNewProfOldJoy": "Perfil nuevo para joystick legado"
        },
        "wordPlayer": "Jugador",
        "wordBack": "Volver",
        "wordOn": "Encendido",
        "wordProfile": "Perfil",
        "loading": "Cargando...",
        "wordShow": "Mostrar",
        "wordNo": "No",
        "wordYes": "Si",
        "wordOff": "Apagado",
        "character": {
            "selectCharacter": "Juego de {0}"
        },
        "battle": {
            "errorNoLevels": "Imposible comenzar batalla debido a que no hay niveles disponibles"
        },
        "caseNone": "<Ninguno>",
        "wordResume": "Reanudar",
        "abbrevMilliseconds": "MS"
    },
    "outro": {
        "originalBy": "Código original VB6 Por:",
        "cppPortDevelopers": "Desarrolladores de puertos C++:",
        "nameAndrewSpinks": "Andrew Spinks",
        "customSprites": "Sprites personalizados:",
        "specialThanks": "Agradecimientos especiales:",
        "psVitaPortBy": "Puerto PS Vita Por:",
        "engineCredits": "Créditos del motor:",
        "levelDesign": "Diseño de niveles:",
        "nameVitalyNovichkov": "Vitaly Novichkov",
        "gameCredits": "Créditos del juego:",
        "qualityControl": "Control de Calidad:"
    },
    "pluralRules": "one-is-singular",
    "game": {
        "connect": {
            "phraseTestControls": "Probar Controles",
            "phraseChangeChar": "Cambiar Personaje",
            "phrasePressAButton": "Presiona un Botón",
            "splitPressSelect_2": "Opciones de Controles",
            "dropAddTitle": "Quitar/Añadir Jugadores",
            "phraseStartToForceRes": "Presiona Comenzar para Forzar Resumir",
            "splitPressSelect_1": "Presiona Select para",
            "wordDisconnect": "Desconectar",
            "phraseStartToResume": "Presiona Comenzar para Resumir",
            "phraseHoldStart": "Mantén Comenzar",
            "phraseWaitingForInput": "Esperando un dispositivo de entrada...",
            "reconnectTitle": "Reconectar",
            "phraseSetControls": "Establecer Controles",
            "phraseDropMe": "Soltarme",
            "phraseDropPX": "Soltar a P{0}",
            "phraseTestProfile": "Probar Perfil",
            "phraseForceResume": "Forzar Resumir"
        },
        "error": {
            "errorInvalidEnterWarp": "Imposible comenzar el nivel debido a que un pasaje de entrada inválido {1} fue especificado.\nTotal Pasajes de Entrada: {2}\n\nArchivo: {0}",
            "openFileFailed": "Imposible abrir \"{0}\": El archivo está corrupto o no existe.",
            "warpNeedStarCount": "Necesitas {0} {1} para entrar.",
            "errorNoStartPoint": "Imposible empezar nivel debido a que no hay puntos de comienzo colocados ni pasajes de entrada especificados.\n\nArchivo: {0}",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "pause": {
            "restartLevel": "Reiniciar Nivel",
            "quit": "Salir",
            "saveAndContinue": "Guardar y Continuar",
            "resetCheckpoints": "Reiniciar Puntos de Control",
            "saveAndQuit": "Guardar y Salir",
            "returnToEditor": "Regresar al Editor",
            "continue": "Continuar",
            "quitTesting": "Dejar de Probar",
            "enterCode": "Introducir Código",
            "playerSetup": "Ordenar Jugadores"
        },
        "message": {
            "scanningLevels": "Escaneando niveles..."
        },
        "hint": {
            "no-lives-old": "Caución - ¡el final se acerca!",
            "gray-bricks": "Algunos bloques se pueden romper por poderes especiales.",
            "char5-bombs": "Presiona Correr para recogerlas y Correr Alt para tirarlas.",
            "heavy-duck": "¡Agáchate para bloquear muchas - pero no todas - llamas!",
            "rainbow-surf": "Cógelo, corre, mantén pulsado abajo, y déjalo para hacer surf.",
            "no-lives-new": "¿No tienes moneda? ¡Toma un préstamo! Pero cuídate el puntaje...",
            "shoe-block": "¡Ponerse esto bloquea muchas - pero no todas - llamas!",
            "pound-altrun": "¡Presiona Correr Alt para golpear el suelo!",
            "pound-down": "¡Presiona Abajo para golpear el suelo!"
        },
        "format": {
            "minutesSeconds": "{0}mm{1}ss"
        },
        "msgbox": {
            "sysInfoWarning": "¡Aviso!",
            "sysInfoTitle": "Información",
            "sysInfoError": "¡Error!"
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "languageName": "Español"
}


================================================
FILE: resources/languages/thextech_fr.json
================================================
{
    "editor": {
        "file": {
            "convert": {
                "descNew": "L'extension de fichier va changer mais l'ancien fichier ne vas PAS être supprimé.\n\nVeuillez vérifier des éventuelles pertes après sauvegarde."
            },
            "actionClearWorld": "Écraser Monde",
            "labelCurrentFile": "Fichier actuel :",
            "labelFormat": "Format :",
            "formatLegacy": "Classique",
            "sectionWorld": "Monde",
            "optionCancelConversion": "Annuler conversion",
            "formatModern": "Moderne",
            "sectionLevel": "Niveau",
            "optionCancelAction": "Annuler : ne pas {0}",
            "optionProceedWithConversion": "Continuer conversion",
            "optionYesSaveThenAction": "Oui : sauvegarder puis {0}",
            "actionRevert": "Annuler",
            "commandSave": "Sauvegarder",
            "commandNew": "Nouveau",
            "actionOpen": "Ouvrir",
            "actionExit": "Quitter",
            "commandSaveAs": "Sauv. en tant que...",
            "confirmSaveBeforeAction": "Sauvegarder avant d' {0} ?",
            "actionClearLevel": "Écraser Niveau",
            "confirmConvertFormatTo": "Convertir le format en {0} ?",
            "optionActionWithoutSave": "{0} sans sauvegarder",
            "confirmConfirmAction": "Êtes-vous sûr de vouloir {0} ?",
            "commandOpen": "Ouvrir..."
        },
        "level": {
            "startPos": "",
            "alwaysVis": "",
            "bigBG": "",
            "pathBG": "",
            "levelName": "",
            "pathUnlocks": "",
            "gameStart": ""
        },
        "mapPos": "",
        "phraseDelayIsMs": "",
        "phraseCountMore": "",
        "section": {
            "scroll": "",
            "setBounds": "",
            "vertWrap": "",
            "offscreenExit": "",
            "noTurnBack": "",
            "underwater": "",
            "horizWrap": ""
        },
        "warp": {
            "style": {
                "blipInstant": "",
                "pipe": "",
                "door": "",
                "style": "",
                "portal": ""
            },
            "needStarCount": "",
            "placing": "",
            "effect": "",
            "dir": "",
            "out": "",
            "cannonExit": "",
            "ride": "",
            "item": "",
            "allow": "",
            "in": "",
            "showStartScene": "",
            "showStarCount": "",
            "speed": "",
            "starLockMessage": "",
            "target": "",
            "toMap": "",
            "transit": {
                "name0": "",
                "name1": "",
                "name4": "",
                "name2": "",
                "name3": "",
                "name5": ""
            },
            "to": "",
            "title": "",
            "twoWay": "",
            "needFloor": "",
            "needKey": "",
            "lvlWarp": ""
        },
        "tooltip": {
            "area": "",
            "eraseAll": "",
            "erase": "",
            "events": "",
            "music": "",
            "layers": "",
            "file": "",
            "paths": "",
            "settings": "",
            "scenes": "",
            "NPCs": "",
            "levels": "",
            "BGOs": "",
            "blocks": "",
            "select": "",
            "show": "",
            "tiles": "",
            "warps": "",
            "water": ""
        },
        "testPlay": {
            "magicHand": "",
            "char": "",
            "power": "",
            "pet": "",
            "boot": ""
        },
        "world": {
            "retryOnFail": "",
            "phraseCreditIndex": "",
            "totalStars": "",
            "introLevel": "",
            "name": "",
            "allowChars": "",
            "hubWorld": ""
        },
        "events": {
            "controlsForEventN": "Contrôles de l'événement {0}",
            "deletion": {
                "confirm": "Oui : supprimer l'événement",
                "deletingEvent": "Suppression de l'évènement {0}",
                "cancel": "Non : ne pas supprimer l'événement"
            },
            "header": "Événements :",
            "label": {
                "layerClear": "Nettoyer Couche",
                "next": "Suivant",
                "activate": "Activation",
                "death": "Mort",
                "talk": "Parler",
                "destroy": "Détruire",
                "enter": "Entrer",
                "hit": "Frapper"
            },
            "headerTriggerEvent": "Déclencheur :",
            "itemNewEvent": "<Nouvel Événement>",
            "letter": {
                "death": "M :",
                "enter": "E :",
                "destroy": "D :",
                "activate": "A :",
                "layerClear": "N :",
                "talk": "P :",
                "hit": "F :"
            },
            "desc": {
                "phraseTriggersAfterTemplate": "{0} se déclenche {1} ms après l'événement {2}",
                "talk": "joueur parle à PNJ",
                "activate": "PNJ apparaît à l'écran",
                "phraseTriggersWhenTemplate": "{0} we déclenche quand {1}",
                "destroy": "bloc est détruit",
                "layerClear": "tout dans la couche objet est parti",
                "enter": "téléport est entré",
                "hit": "bloc est frappé",
                "death": "PNJ meurt"
            },
            "layers": {
                "headerMove": "Déplacer :",
                "headerHide": "Cacher :",
                "headerShow": "Montrer :",
                "headerToggle": "Activer :"
            },
            "props": {
                "sound": "Son",
                "layerSmoke": "Fumée",
                "controls": "Contrôles",
                "endGame": "Fin du Jeu",
                "autostart": "Auto-démarrage"
            },
            "bounds": {
                "shouldEvent": "L'Évènement {0} devrait-il",
                "changeAllSectionBoundsToCurrent": "Changer toutes les sect. liées à l'actuel ?",
                "changeSectionBoundsToCurrent": "Changer toutes les {0} sect. liées à l'actuel ?"
            },
            "sections": {
                "phraseAllSections": "Toutes Sections",
                "propBounds": "Bords",
                "actionSet": "Set",
                "actionReset": "Réinit",
                "propBackground": "Arr-Plan",
                "propMusic": "Musique",
                "actionKeep": "Garder"
            },
            "promptEventText": "Texte de l'évènement",
            "promptEventName": "Nom de l'évènement",
            "settingsForEvent": "Paramètres pour l'événement {0}"
        },
        "phraseGenericIndex": "",
        "select": {
            "pathBlankUnlock": "",
            "warpTransitEffect": "",
            "sectionBlankPropBlank": "",
            "allSectPropBlankForEventN": "",
            "soundForEventN": "",
            "sectBlankPropBlankForEventN": "",
            "worldMusic": ""
        },
        "block": {
            "invis": "Invis.",
            "letterWidth": "L ",
            "canBreakTooltip": "Classique : se brise une fois frappé",
            "pickContents": "Prendre contenu du bloc",
            "slick": "Gliss.",
            "canBreak": "Cassable",
            "inside": "Cont. :",
            "letterHeight": "H "
        },
        "browser": {
            "openFile": "Ouvrir fichier",
            "itemNewFolder": "<Nouveau Dossier>",
            "newFile": "Nouveau fichier",
            "saveFile": "Sauvegarder fichier",
            "askOverwriteFile": "Écraser {0} ?",
            "itemNewFile": "<Nouveau Fichier>"
        },
        "layers": {
            "deletion": {
                "cancel": "Annuler : ne pas supprimer couche",
                "confirmDelete": "Non : *TOUT SUPPRIMER*",
                "confirmPreserve": "Oui : déplacer à couche par défaut",
                "header": "Supprimer couche {0}",
                "preserveLayerContents": "Garder contenu de la couche ?"
            },
            "header": "",
            "default": "Par Défaut",
            "abbrevAttLayer": "Att : ",
            "desc": {
                "att": ""
            },
            "label": "",
            "labelAttached": "",
            "labelAttachedLayer": "",
            "promptLayerName": "",
            "labelMoveLayer": "",
            "itemNewLayer": ""
        },
        "npc": {
            "ai": {
                "UD": "",
                "target": "",
                "use1_0Ai": "",
                "jump": "",
                "swim": "",
                "leap": "",
                "headerCustomAi": "",
                "LR": "",
                "aiIs": ""
            },
            "gen": {
                "direction": "",
                "header": "",
                "effectIs": "",
                "effectShoot": "",
                "effectWarp": ""
            },
            "inertNice": "",
            "props": {
                "facing": "",
                "attachSurface": "",
                "active": ""
            },
            "stuckStop": "",
            "tooltipExpandSection": "",
            "abbrevGen": "",
            "inContainer": ""
        },
        "phraseRadiusIndex": "",
        "wordEvent": {
            "genitive": "",
            "nominative": "",
            "typeLabel": ""
        },
        "wordEnabled": "",
        "letterRight": "",
        "letterLeft": "",
        "wordCoins": "",
        "labelSortLayer": "Trier Couche :",
        "labelSortOffset": "Trier Décalage :",
        "letterCoordX": "",
        "letterDown": "",
        "letterCoordY": "",
        "phraseAreYouSure": "",
        "pageBlankOfBlank": "",
        "phraseTextOf": "",
        "toggleMagicBlock": "",
        "wordHeight": "",
        "wordInstant": "",
        "water": {
            "title": ""
        },
        "wordNPC": {
            "nominative": "",
            "genitive": ""
        },
        "wordText": "",
        "wordMode": "",
        "wordWidth": "",
        "phraseSectionIndex": "",
        "phraseWarpIndex": "",
        "letterUp": ""
    },
    "game": {
        "connect": {
            "phraseWaitingForInput": "",
            "reconnectTitle": "",
            "splitPressSelect_2": "",
            "phraseSetControls": "",
            "phraseTestProfile": "",
            "phraseChangeChar": "",
            "phraseDropPX": "",
            "phraseDropMe": "",
            "dropAddTitle": "",
            "phrasePressAButton": "",
            "phraseTestControls": "",
            "phraseForceResume": "",
            "phraseHoldStart": "",
            "phraseStartToResume": "",
            "splitPressSelect_1": "",
            "phraseStartToForceRes": "",
            "wordDisconnect": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "hint": {
            "no-lives-new": "",
            "no-lives-old": "",
            "gray-bricks": "",
            "char5-bombs": "",
            "rainbow-surf": "",
            "heavy-duck": "",
            "shoe-block": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "error": {
            "openFileFailed": "",
            "errorNoStartPoint": "",
            "warpNeedStarCount": "",
            "errorInvalidEnterWarp": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "pause": {
            "enterCode": "",
            "continue": "",
            "quit": "",
            "playerSetup": "",
            "returnToEditor": "",
            "saveAndContinue": "",
            "saveAndQuit": "",
            "quitTesting": "",
            "restartLevel": "",
            "resetCheckpoints": ""
        },
        "msgbox": {
            "sysInfoWarning": "",
            "sysInfoError": "",
            "sysInfoTitle": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "menu": {
        "battle": {
            "errorNoLevels": ""
        },
        "controls": {
            "buttons": {
                "run": "",
                "jump": "",
                "left": "",
                "altRun": "",
                "altJump": "",
                "drop": "",
                "up": "",
                "down": "",
                "right": "",
                "start": ""
            },
            "hotkeys": {
                "legacyPause": "",
                "fullscreen": "",
                "screenshot": "",
                "enterCheats": "",
                "debugInfo": "",
                "toggleHUD": "",
                "recordGif": "",
                "vanillaCam": ""
            },
            "editor": {
                "scrollRight": "",
                "modeErase": "",
                "scrollLeft": "",
                "prevSection": "",
                "scrollDown": "",
                "nextSection": "",
                "modeSelect": "",
                "switchScreens": "",
                "testPlay": "",
                "scrollUp": "",
                "fastScroll": ""
            },
            "tDS": {
                "buttonZR": "",
                "buttonStart": "",
                "buttonSelect": "",
                "cStick": "",
                "tStick": "",
                "dPad": "",
                "buttonZL": "",
                "casePen": "",
                "buttonA": "",
                "buttonB": "",
                "buttonY": "",
                "buttonX": "",
                "buttonL": "",
                "buttonR": ""
            },
            "cursor": {
                "tertiary": "",
                "left": "",
                "down": "",
                "secondary": "",
                "primary": "",
                "right": "",
                "up": ""
            },
            "profile": {
                "playerControls": "",
                "deleteProfile": "",
                "editorControls": "",
                "hotkeys": "",
                "cursorControls": "",
                "renameProfile": ""
            },
            "touchscreen": {
                "layout": {
                    "tabletOld": "",
                    "phoneOld": "",
                    "standard": "",
                    "phabletOld": "",
                    "tinyOld": "",
                    "tight": "",
                    "longOld": ""
                },
                "option": {
                    "feedbackStrength": "",
                    "scaleFactor": "",
                    "holdRun": "",
                    "interfaceStyle": "",
                    "layoutStyle": "",
                    "resetLayout": "",
                    "scaleDPad": "",
                    "scaleButtons": "",
                    "showCodeButton": "",
                    "sStartSpacing": "",
                    "feedbackLength": ""
                },
                "style": {
                    "ABXY": "",
                    "XODA": "",
                    "actions": ""
                }
            },
            "types": {
                "touchscreen": "",
                "oldJoystick": "",
                "gamepad": "",
                "keyboard": ""
            },
            "wii": {
                "nunchuck": {
                    "buttonC": "",
                    "prefixN": "",
                    "buttonZ": ""
                },
                "classic": {
                    "buttonLT": "",
                    "buttonRT": "",
                    "buttonX": "",
                    "buttonY": "",
                    "lStick": "",
                    "buttonZL": "",
                    "rStick": "",
                    "buttonZR": ""
                },
                "wiimote": {
                    "buttonB": "",
                    "buttonA": "",
                    "buttonHome": "",
                    "buttonPlus": "",
                    "buttonMinus": "",
                    "caseIR": "",
                    "shake": "",
                    "dPad": "",
                    "button2": "",
                    "button1": ""
                },
                "typeClassic": "",
                "typeWiimote": "",
                "phraseNewNunchuck": "",
                "phraseNewClassic": "",
                "typeNunchuck": "",
                "typeGamecube": ""
            },
            "joystickSimpleEditor": "",
            "wordProfiles": "",
            "caseInvalid": "",
            "controlsTitle": "",
            "options": {
                "rumble": "",
                "batteryStatus": "",
                "maxPlayers": "",
                "textEntryStyle": ""
            },
            "controlsInUse": "",
            "phraseNewProfOldJoy": "",
            "wordButtons": "",
            "caseMouse": "",
            "controlsDeleteKey": "",
            "caseTouch": "",
            "controlsNewProfile": "",
            "controlsConnected": "",
            "controlsReallyDeleteProfile": "",
            "controlsNotInUse": "",
            "controlsDeviceTypes": ""
        },
        "options": {
            "advanced": {
                "render": {
                    "_name": "",
                    "opengles11-tip": "",
                    "opengles11": "",
                    "opengles-tip": "",
                    "opengl11": "",
                    "opengl-tip": "",
                    "sdl": "",
                    "sdl-tip": "",
                    "sw": "",
                    "opengles": "",
                    "opengl11-tip": "",
                    "hw": "",
                    "opengl": ""
                },
                "audio-buffer-size": {
                    "_name": "",
                    "_tooltip": ""
                },
                "audio-channels": {
                    "stereo": "",
                    "mono": "",
                    "_name": ""
                },
                "audio-enable": "",
                "audio-format": {
                    "_name": "",
                    "_tooltip": ""
                },
                "audio-sample-rate": {
                    "16000": "",
                    "48000": "",
                    "_name": "",
                    "22050": "",
                    "11025": "",
                    "32000": "",
                    "44100": ""
                },
                "log-level": {
                    "info": "",
                    "debug": "",
                    "none": "",
                    "fatal": "",
                    "critical": "",
                    "_name": "",
                    "warning": ""
                },
                "scale-down-textures": {
                    "_tooltip": "",
                    "all-tip": "",
                    "all": "",
                    "_name": "",
                    "safe": "",
                    "none-tip": "",
                    "safe-tip": "",
                    "none": ""
                },
                "webm-recording": "",
                "_header": "",
                "advanced-video": "",
                "advanced-audio": "",
                "_tooltip": "",
                "choose-assets-on-launch": "",
                "internal-res-4p": {
                    "qsmbx": "",
                    "fhd": "",
                    "_name": "",
                    "qhd": "",
                    "default": ""
                },
                "record-gameplay-data": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "episode-options": {
                "playstyle": {
                    "vanilla": "",
                    "modern-tip": "",
                    "modern": "",
                    "vanilla-tip": "",
                    "classic-tip": "",
                    "_name": "",
                    "classic": ""
                },
                "_header": "",
                "creator-compat": {
                    "enable": "",
                    "file-only": "",
                    "_name": "",
                    "_tooltip": "",
                    "disable": ""
                },
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "main": {
                "discord-rpc": "",
                "four-screen-mode": {
                    "_name": "",
                    "split": "",
                    "shared": ""
                },
                "background-work": "",
                "frame-skip": "",
                "_header": "",
                "background-work-tip": "",
                "two-screen-mode": {
                    "_name": "",
                    "shared": "",
                    "smbx": "",
                    "split": "",
                    "topbottom": ""
                },
                "timing": "",
                "multiplayer": "",
                "language": "",
                "unlimited-framerate": "",
                "vsync": ""
            },
            "restartEngine": "",
            "audio": {
                "sfx-spatial-audio-tip": "",
                "sfx-spatial-audio": "",
                "sfx-pet-beat-tip": "",
                "sfx-audio-fx": "",
                "sfx-modern": "",
                "_header": "",
                "audio-prefs": "",
                "audio-music-volume": "",
                "audio-sfx-volume": "",
                "sfx-pet-beat": "",
                "sfx-modern-tip": ""
            },
            "video": {
                "internal-res": {
                    "dynamic": "",
                    "gba": "",
                    "hd": "",
                    "vga": "",
                    "snes": "",
                    "_tooltip": "",
                    "_name": "",
                    "3ds": "",
                    "hello": "",
                    "smbx": "",
                    "nds": "",
                    "smbx-wide": ""
                },
                "scale-mode": {
                    "integer": "",
                    "nearest": "",
                    "center": "",
                    "2x": "",
                    "full": "",
                    "0_5x": "",
                    "1x": "",
                    "linear": "",
                    "_name": "",
                    "3x": ""
                },
                "show-episode-title": {
                    "off": "",
                    "bottom-tip": "",
                    "_name": "",
                    "bottom": "",
                    "top": "",
                    "top-tip": ""
                },
                "show-fails-counter-tip": "",
                "show-fails-counter": "",
                "show-fps": "",
                "3d-compat-mode": "",
                "3d-compat-mode-tip": "",
                "show-playtime-counter": {
                    "_name": "",
                    "animated": "",
                    "_tooltip": "",
                    "off": "",
                    "off-tip": "",
                    "opaque": "",
                    "transparent": "",
                    "animated-tip": ""
                },
                "show-medals-counter-tip": "",
                "show-medals-counter": "",
                "show-screen-shake": "",
                "battery-status": {
                    "low-tip": "",
                    "on": "",
                    "fullscreen-tip": "",
                    "fullscreen": "",
                    "_name": "",
                    "low": "",
                    "off": ""
                },
                "_header": "",
                "effects": "",
                "display-controllers": "",
                "info-meta": "",
                "fullscreen": "",
                "info-game": "",
                "enable-inter-level-fade-effect": "",
                "info-run": "",
                "world-map-stars-show": "",
                "video-system": "",
                "world-map-stars-show-tip": ""
            },
            "compatibility": {
                "features": "",
                "_tooltip": "",
                "_header": "",
                "reset-all": "",
                "autocode": "",
                "bugfixes": ""
            },
            "speedrun": {
                "mode": {
                    "3": "",
                    "2": "",
                    "_name": "",
                    "1": "",
                    "0": ""
                }
            },
            "controls": {
                "_header": ""
            },
            "view-credits": {
                "_header": ""
            }
        },
        "caseNone": "",
        "game": {
            "gameBattleRandom": "",
            "gameCopySave": "",
            "gameNoEpisodesToPlay": "",
            "gameNoBattleLevels": "",
            "gameSlotNew": "",
            "gameTargetSlot": "",
            "gameSourceSlot": "",
            "phraseTime": "",
            "gameEraseSlot": "",
            "phraseScore": "",
            "gameSlotContinue": "",
            "gameEraseSave": "",
            "warnEpCompat": ""
        },
        "editor": {
            "battles": "",
            "newWorld": "",
            "makeFor": "",
            "promptNewWorldName": "",
            "errorMissingResources": ""
        },
        "wordOn": "",
        "main": {
            "mainMultiplayerGame": "",
            "mainPlayEpisode": "",
            "mainOptions": "",
            "main1PlayerGame": "",
            "mainBattleGame": "",
            "mainExit": "",
            "mainEditor": ""
        },
        "abbrevMilliseconds": "",
        "character": {
            "selectCharacter": ""
        },
        "loading": "",
        "wordHide": "",
        "wordNo": "",
        "wordYes": "",
        "wordBack": "",
        "wordOff": "",
        "wordResume": "",
        "wordProfile": "",
        "wordPlayer": "",
        "wordWaiting": "",
        "wordShow": ""
    },
    "pluralRules": "",
    "languageName": "",
    "outro": {
        "levelDesign": "",
        "nameVitalyNovichkov": "",
        "psVitaPortBy": "",
        "originalBy": "",
        "qualityControl": "",
        "specialThanks": "",
        "gameCredits": "",
        "nameAndrewSpinks": "",
        "engineCredits": "",
        "customSprites": "",
        "cppPortDevelopers": ""
    }
}


================================================
FILE: resources/languages/thextech_hu.json
================================================
{
    "menu": {
        "game": {
            "gameTargetSlot": "",
            "gameSourceSlot": "",
            "gameSlotNew": "",
            "gameNoEpisodesToPlay": "",
            "gameCopySave": "",
            "gameBattleRandom": "",
            "phraseTime": "",
            "gameSlotContinue": "",
            "gameEraseSlot": "",
            "gameEraseSave": "",
            "phraseScore": "",
            "gameNoBattleLevels": "",
            "warnEpCompat": ""
        },
        "options": {
            "advanced": {
                "scale-down-textures": {
                    "_tooltip": "",
                    "none-tip": "",
                    "none": "",
                    "all-tip": "",
                    "safe-tip": "",
                    "safe": "",
                    "all": "",
                    "_name": ""
                },
                "render": {
                    "sw": "",
                    "sdl-tip": "",
                    "_name": "",
                    "opengl": "",
                    "opengl-tip": "",
                    "hw": "",
                    "opengles-tip": "",
                    "opengles11-tip": "",
                    "opengles": "",
                    "opengl11-tip": "",
                    "opengl11": "",
                    "sdl": "",
                    "opengles11": ""
                },
                "audio-buffer-size": {
                    "_name": "",
                    "_tooltip": ""
                },
                "log-level": {
                    "info": "",
                    "none": "",
                    "critical": "",
                    "fatal": "",
                    "_name": "",
                    "debug": "",
                    "warning": ""
                },
                "_header": "",
                "_tooltip": "",
                "advanced-audio": "",
                "advanced-video": "",
                "audio-format": {
                    "_tooltip": "",
                    "_name": ""
                },
                "audio-enable": "",
                "audio-sample-rate": {
                    "32000": "",
                    "22050": "",
                    "_name": "",
                    "44100": "",
                    "48000": "",
                    "16000": "",
                    "11025": ""
                },
                "audio-channels": {
                    "mono": "",
                    "_name": "",
                    "stereo": ""
                },
                "choose-assets-on-launch": "",
                "internal-res-4p": {
                    "qsmbx": "",
                    "qhd": "",
                    "default": "",
                    "fhd": "",
                    "_name": ""
                },
                "record-gameplay-data": "",
                "webm-recording": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "speedrun": {
                "mode": {
                    "2": "",
                    "3": "",
                    "1": "",
                    "0": "",
                    "_name": ""
                }
            },
            "audio": {
                "audio-music-volume": "",
                "_header": "",
                "sfx-spatial-audio-tip": "",
                "sfx-spatial-audio": "",
                "sfx-modern": "",
                "sfx-pet-beat-tip": "",
                "sfx-pet-beat": "",
                "sfx-modern-tip": "",
                "sfx-audio-fx": "",
                "audio-sfx-volume": "",
                "audio-prefs": ""
            },
            "compatibility": {
                "_header": "",
                "_tooltip": "",
                "autocode": "",
                "reset-all": "",
                "bugfixes": "",
                "features": ""
            },
            "episode-options": {
                "_header": "",
                "playstyle": {
                    "_name": "",
                    "classic": "",
                    "classic-tip": "",
                    "modern-tip": "",
                    "vanilla": "",
                    "modern": "",
                    "vanilla-tip": ""
                },
                "creator-compat": {
                    "_tooltip": "",
                    "_name": "",
                    "file-only": "",
                    "enable": "",
                    "disable": ""
                },
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "main": {
                "background-work-tip": "",
                "background-work": "",
                "two-screen-mode": {
                    "shared": "",
                    "smbx": "",
                    "split": "",
                    "topbottom": "",
                    "_name": ""
                },
                "four-screen-mode": {
                    "_name": "",
                    "shared": "",
                    "split": ""
                },
                "multiplayer": "",
                "language": "",
                "unlimited-framerate": "",
                "vsync": "",
                "discord-rpc": "",
                "frame-skip": "",
                "timing": "",
                "_header": ""
            },
            "video": {
                "enable-inter-level-fade-effect": "",
                "info-game": "",
                "battery-status": {
                    "fullscreen-tip": "",
                    "_name": "",
                    "fullscreen": "",
                    "on": "",
                    "low-tip": "",
                    "off": "",
                    "low": ""
                },
                "internal-res": {
                    "_name": "",
                    "3ds": "",
                    "hd": "",
                    "smbx-wide": "",
                    "vga": "",
                    "snes": "",
                    "_tooltip": "",
                    "dynamic": "",
                    "hello": "",
                    "smbx": "",
                    "nds": "",
                    "gba": ""
                },
                "info-meta": "",
                "info-run": "",
                "scale-mode": {
                    "0_5x": "",
                    "nearest": "",
                    "2x": "",
                    "linear": "",
                    "1x": "",
                    "full": "",
                    "center": "",
                    "_name": "",
                    "integer": "",
                    "3x": ""
                },
                "show-episode-title": {
                    "bottom-tip": "",
                    "off": "",
                    "top": "",
                    "top-tip": "",
                    "bottom": "",
                    "_name": ""
                },
                "show-playtime-counter": {
                    "_name": "",
                    "animated": "",
                    "_tooltip": "",
                    "off": "",
                    "animated-tip": "",
                    "off-tip": "",
                    "opaque": "",
                    "transparent": ""
                },
                "show-screen-shake": "",
                "world-map-stars-show": "",
                "video-system": "",
                "world-map-stars-show-tip": "",
                "fullscreen": "",
                "_header": "",
                "3d-compat-mode": "",
                "3d-compat-mode-tip": "",
                "show-fails-counter": "",
                "show-medals-counter-tip": "",
                "show-fails-counter-tip": "",
                "display-controllers": "",
                "effects": "",
                "show-fps": "",
                "show-medals-counter": ""
            },
            "view-credits": {
                "_header": ""
            },
            "restartEngine": "",
            "controls": {
                "_header": ""
            }
        },
        "controls": {
            "buttons": {
                "altRun": "",
                "start": "",
                "altJump": "",
                "left": "",
                "right": "",
                "drop": "",
                "jump": "",
                "up": "",
                "down": "",
                "run": ""
            },
            "controlsConnected": "",
            "options": {
                "batteryStatus": "",
                "maxPlayers": "",
                "rumble": "",
                "textEntryStyle": ""
            },
            "hotkeys": {
                "screenshot": "",
                "toggleHUD": "",
                "recordGif": "",
                "debugInfo": "",
                "enterCheats": "",
                "fullscreen": "",
                "legacyPause": "",
                "vanillaCam": ""
            },
            "profile": {
                "renameProfile": "",
                "playerControls": "",
                "deleteProfile": "",
                "cursorControls": "",
                "hotkeys": "",
                "editorControls": ""
            },
            "tDS": {
                "casePen": "",
                "dPad": "",
                "buttonZL": "",
                "buttonA": "",
                "buttonB": "",
                "buttonZR": "",
                "tStick": "",
                "buttonSelect": "",
                "cStick": "",
                "buttonR": "",
                "buttonL": "",
                "buttonX": "",
                "buttonY": "",
                "buttonStart": ""
            },
            "controlsNewProfile": "",
            "controlsInUse": "",
            "touchscreen": {
                "layout": {
                    "tinyOld": "",
                    "standard": "",
                    "phoneOld": "",
                    "phabletOld": "",
                    "longOld": "",
                    "tabletOld": "",
                    "tight": ""
                },
                "option": {
                    "interfaceStyle": "",
                    "scaleFactor": "",
                    "feedbackStrength": "",
                    "layoutStyle": "",
                    "holdRun": "",
                    "feedbackLength": "",
                    "sStartSpacing": "",
                    "showCodeButton": "",
                    "scaleButtons": "",
                    "scaleDPad": "",
                    "resetLayout": ""
                },
                "style": {
                    "actions": "",
                    "ABXY": "",
                    "XODA": ""
                }
            },
            "types": {
                "touchscreen": "",
                "gamepad": "",
                "oldJoystick": "",
                "keyboard": ""
            },
            "wii": {
                "classic": {
                    "lStick": "",
                    "buttonX": "",
                    "buttonRT": "",
                    "buttonY": "",
                    "buttonLT": "",
                    "buttonZR": "",
                    "buttonZL": "",
                    "rStick": ""
                },
                "phraseNewNunchuck": "",
                "wiimote": {
                    "button1": "",
                    "buttonMinus": "",
                    "buttonA": "",
                    "dPad": "",
                    "caseIR": "",
                    "buttonPlus": "",
                    "shake": "",
                    "button2": "",
                    "buttonHome": "",
                    "buttonB": ""
                },
                "typeWiimote": "",
                "typeNunchuck": "",
                "phraseNewClassic": "",
                "nunchuck": {
                    "prefixN": "",
                    "buttonZ": "",
                    "buttonC": ""
                },
                "typeClassic": "",
                "typeGamecube": ""
            },
            "joystickSimpleEditor": "",
            "caseMouse": "",
            "cursor": {
                "down": "",
                "primary": "",
                "left": "",
                "secondary": "",
                "up": "",
                "right": "",
                "tertiary": ""
            },
            "controlsTitle": "",
            "editor": {
                "scrollRight": "",
                "scrollUp": "",
                "scrollLeft": "",
                "modeErase": "",
                "fastScroll": "",
                "testPlay": "",
                "switchScreens": "",
                "scrollDown": "",
                "prevSection": "",
                "modeSelect": "",
                "nextSection": ""
            },
            "controlsReallyDeleteProfile": "",
            "phraseNewProfOldJoy": "",
            "wordButtons": "",
            "wordProfiles": "",
            "caseTouch": "",
            "controlsNotInUse": "",
            "controlsDeviceTypes": "",
            "caseInvalid": "",
            "controlsDeleteKey": ""
        },
        "editor": {
            "battles": "",
            "newWorld": "",
            "promptNewWorldName": "",
            "errorMissingResources": "",
            "makeFor": ""
        },
        "character": {
            "selectCharacter": ""
        },
        "main": {
            "mainBattleGame": "",
            "mainPlayEpisode": "",
            "mainMultiplayerGame": "",
            "mainExit": "",
            "main1PlayerGame": "",
            "mainOptions": "",
            "mainEditor": ""
        },
        "wordBack": "",
        "wordHide": "",
        "wordResume": "",
        "wordOff": "",
        "wordProfile": "",
        "battle": {
            "errorNoLevels": ""
        },
        "caseNone": "",
        "abbrevMilliseconds": "",
        "wordOn": "",
        "wordPlayer": "",
        "wordNo": "",
        "wordWaiting": "",
        "wordYes": "",
        "loading": "",
        "wordShow": ""
    },
    "editor": {
        "file": {
            "formatLegacy": "",
            "convert": {
                "descNew": ""
            },
            "actionClearLevel": "",
            "actionClearWorld": "",
            "actionRevert": "",
            "commandSave": "",
            "commandSaveAs": "",
            "commandOpen": "",
            "commandNew": "",
            "confirmConfirmAction": "",
            "confirmSaveBeforeAction": "",
            "confirmConvertFormatTo": "",
            "optionCancelAction": "",
            "sectionLevel": "",
            "formatModern": "",
            "labelCurrentFile": "",
            "labelFormat": "",
            "optionCancelConversion": "",
            "actionExit": "",
            "optionYesSaveThenAction": "",
            "optionActionWithoutSave": "",
            "sectionWorld": "",
            "optionProceedWithConversion": "",
            "actionOpen": ""
        },
        "layers": {
            "desc": {
                "att": ""
            },
            "labelMoveLayer": "",
            "promptLayerName": "",
            "deletion": {
                "confirmPreserve": "",
                "header": "",
                "preserveLayerContents": "",
                "confirmDelete": "",
                "cancel": ""
            },
            "label": "",
            "itemNewLayer": "",
            "labelAttached": "",
            "default": "",
            "labelAttachedLayer": "",
            "abbrevAttLayer": "",
            "header": ""
        },
        "npc": {
            "ai": {
                "UD": "",
                "LR": "",
                "swim": "",
                "leap": "",
                "target": "",
                "use1_0Ai": "",
                "aiIs": "",
                "jump": "",
                "headerCustomAi": ""
            },
            "gen": {
                "direction": "",
                "effectIs": "",
                "effectShoot": "",
                "effectWarp": "",
                "header": ""
            },
            "props": {
                "attachSurface": "",
                "facing": "",
                "active": ""
            },
            "stuckStop": "",
            "inContainer": "",
            "inertNice": "",
            "tooltipExpandSection": "",
            "abbrevGen": ""
        },
        "pageBlankOfBlank": "",
        "phraseAreYouSure": "",
        "phraseCountMore": "",
        "phraseGenericIndex": "",
        "phraseWarpIndex": "",
        "section": {
            "underwater": "",
            "vertWrap": "",
            "horizWrap": "",
            "noTurnBack": "",
            "scroll": "",
            "offscreenExit": "",
            "setBounds": ""
        },
        "select": {
            "sectBlankPropBlankForEventN": "",
            "allSectPropBlankForEventN": "",
            "soundForEventN": "",
            "pathBlankUnlock": "",
            "sectionBlankPropBlank": "",
            "worldMusic": "",
            "warpTransitEffect": ""
        },
        "testPlay": {
            "magicHand": "",
            "char": "",
            "pet": "",
            "boot": "",
            "power": ""
        },
        "tooltip": {
            "eraseAll": "",
            "file": "",
            "area": "",
            "erase": "",
            "blocks": "",
            "paths": "",
            "levels": "",
            "layers": "",
            "events": "",
            "music": "",
            "scenes": "",
            "select": "",
            "tiles": "",
            "water": "",
            "warps": "",
            "BGOs": "",
            "NPCs": "",
            "show": "",
            "settings": ""
        },
        "warp": {
            "transit": {
                "name2": "",
                "name5": "",
                "name4": "",
                "name3": "",
                "name1": "",
                "name0": ""
            },
            "lvlWarp": "",
            "ride": "",
            "placing": "",
            "in": "",
            "twoWay": "",
            "item": "",
            "dir": "",
            "needKey": "",
            "out": "",
            "needStarCount": "",
            "title": "",
            "effect": "",
            "allow": "",
            "cannonExit": "",
            "toMap": "",
            "style": {
                "pipe": "",
                "portal": "",
                "blipInstant": "",
                "door": "",
                "style": ""
            },
            "target": "",
            "to": "",
            "needFloor": "",
            "showStartScene": "",
            "showStarCount": "",
            "starLockMessage": "",
            "speed": ""
        },
        "wordCoins": "",
        "wordEnabled": "",
        "water": {
            "title": ""
        },
        "wordNPC": {
            "genitive": "",
            "nominative": ""
        },
        "wordMode": "",
        "world": {
            "retryOnFail": "",
            "totalStars": "",
            "phraseCreditIndex": "",
            "allowChars": "",
            "hubWorld": "",
            "name": "",
            "introLevel": ""
        },
        "events": {
            "controlsForEventN": "",
            "bounds": {
                "shouldEvent": "",
                "changeSectionBoundsToCurrent": "",
                "changeAllSectionBoundsToCurrent": ""
            },
            "deletion": {
                "cancel": "",
                "deletingEvent": "",
                "confirm": ""
            },
            "header": "",
            "label": {
                "activate": "",
                "enter": "",
                "destroy": "",
                "death": "",
                "hit": "",
                "next": "",
                "layerClear": "",
                "talk": ""
            },
            "itemNewEvent": "",
            "headerTriggerEvent": "",
            "layers": {
                "headerMove": "",
                "headerHide": "",
                "headerShow": "",
                "headerToggle": ""
            },
            "letter": {
                "enter": "",
                "layerClear": "",
                "hit": "",
                "activate": "",
                "destroy": "",
                "death": "",
                "talk": ""
            },
            "promptEventText": "",
            "props": {
                "autostart": "",
                "controls": "",
                "endGame": "",
                "layerSmoke": "",
                "sound": ""
            },
            "promptEventName": "",
            "sections": {
                "actionReset": "",
                "actionSet": "",
                "propBackground": "",
                "propBounds": "",
                "propMusic": "",
                "actionKeep": "",
                "phraseAllSections": ""
            },
            "settingsForEvent": "",
            "desc": {
                "talk": "",
                "phraseTriggersWhenTemplate": "",
                "layerClear": "",
                "death": "",
                "enter": "",
                "hit": "",
                "destroy": "",
                "activate": "",
                "phraseTriggersAfterTemplate": ""
            }
        },
        "block": {
            "canBreak": "",
            "inside": "",
            "letterHeight": "",
            "letterWidth": "",
            "canBreakTooltip": "",
            "invis": "",
            "slick": "",
            "pickContents": ""
        },
        "browser": {
            "newFile": "",
            "itemNewFolder": "",
            "askOverwriteFile": "",
            "itemNewFile": "",
            "saveFile": "",
            "openFile": ""
        },
        "letterCoordY": "",
        "letterLeft": "",
        "letterUp": "",
        "letterRight": "",
        "level": {
            "pathUnlocks": "",
            "startPos": "",
            "gameStart": "",
            "alwaysVis": "",
            "bigBG": "",
            "levelName": "",
            "pathBG": ""
        },
        "phraseDelayIsMs": "",
        "phraseSectionIndex": "",
        "wordEvent": {
            "nominative": "",
            "genitive": "",
            "typeLabel": ""
        },
        "labelSortLayer": "",
        "mapPos": "",
        "letterCoordX": "",
        "letterDown": "",
        "wordHeight": "",
        "wordInstant": "",
        "toggleMagicBlock": "",
        "wordWidth": "",
        "labelSortOffset": "",
        "phraseTextOf": "",
        "wordText": "",
        "phraseRadiusIndex": ""
    },
    "game": {
        "connect": {
            "dropAddTitle": "",
            "phraseDropMe": "",
            "phraseChangeChar": "",
            "phraseForceResume": "",
            "phraseDropPX": "",
            "reconnectTitle": "",
            "phraseStartToResume": "",
            "phrasePressAButton": "",
            "phraseStartToForceRes": "",
            "phraseSetControls": "",
            "phraseHoldStart": "",
            "splitPressSelect_1": "",
            "splitPressSelect_2": "",
            "phraseTestProfile": "",
            "phraseWaitingForInput": "",
            "wordDisconnect": "",
            "phraseTestControls": ""
        },
        "error": {
            "errorInvalidEnterWarp": "",
            "openFileFailed": "",
            "errorNoStartPoint": "",
            "warpNeedStarCount": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "hint": {
            "no-lives-new": "",
            "no-lives-old": "",
            "char5-bombs": "",
            "gray-bricks": "",
            "heavy-duck": "",
            "rainbow-surf": "",
            "shoe-block": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "pause": {
            "playerSetup": "",
            "continue": "",
            "resetCheckpoints": "",
            "returnToEditor": "",
            "restartLevel": "",
            "quitTesting": "",
            "quit": "",
            "enterCode": "",
            "saveAndQuit": "",
            "saveAndContinue": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "msgbox": {
            "sysInfoWarning": "",
            "sysInfoTitle": "",
            "sysInfoError": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "languageName": "",
    "outro": {
        "cppPortDevelopers": "",
        "gameCredits": "",
        "levelDesign": "",
        "nameAndrewSpinks": "",
        "nameVitalyNovichkov": "",
        "specialThanks": "",
        "customSprites": "",
        "originalBy": "",
        "engineCredits": "",
        "qualityControl": "",
        "psVitaPortBy": ""
    },
    "pluralRules": ""
}


================================================
FILE: resources/languages/thextech_it.json
================================================
{
    "editor": {
        "file": {
            "convert": {
                "descNew": "L'estensione del file cambierà, ma il vecchio file NON verrà eliminato.\n\nControlla se ci sono elementi persi dopo il salvataggio."
            },
            "optionProceedWithConversion": "Procedi con la conversione",
            "optionYesSaveThenAction": "Sì: salva e {0}",
            "confirmConfirmAction": "Sei sicuro di {0}?",
            "optionCancelConversion": "Cancella conversione",
            "formatModern": "Versione Moderna (PGE-X)",
            "formatLegacy": "Versione Vecchia (SMBX64)",
            "labelFormat": "Formato:",
            "optionActionWithoutSave": "{0} senza salvare",
            "optionCancelAction": "Cancella: non {0}",
            "labelCurrentFile": "File attuale:",
            "sectionLevel": "Livello",
            "sectionWorld": "Mondo",
            "actionClearLevel": "Cancella Livello",
            "actionClearWorld": "Cancella il mondo",
            "actionExit": "Uscire",
            "actionOpen": "Aprire",
            "actionRevert": "Ritornare",
            "commandNew": "Nuovo",
            "commandOpen": "Apri...",
            "commandSave": "Salva",
            "commandSaveAs": "Salva come...",
            "confirmConvertFormatTo": "Convertire il formato a {0}?",
            "confirmSaveBeforeAction": "Salvare prima di {0}?"
        },
        "layers": {
            "abbrevAttLayer": "Att:",
            "deletion": {
                "header": "Rimozione strato {0}",
                "preserveLayerContents": "Preservare i contenuti dello strato?",
                "confirmPreserve": "Sì: muovi sullo strato predefinito",
                "cancel": "Cancella: non eliminare lo strato",
                "confirmDelete": "No: *CANCELLA TUTTI I CONTENTUTI*"
            },
            "labelAttached": "Attaccato:",
            "default": "Predefinito",
            "desc": {
                "att": "Ogni volta che NPC si muove, lo strato attaccato si muoverà seguendolo"
            },
            "header": "Strati:",
            "label": "Strato:",
            "itemNewLayer": "<Nuovo Strato>",
            "labelMoveLayer": "Muovi Strato:",
            "promptLayerName": "Nome dello strato",
            "labelAttachedLayer": "Strati Attaccato:"
        },
        "letterCoordX": "X (orizzontale)",
        "letterCoordY": "Y (verticale)",
        "letterDown": "D",
        "npc": {
            "ai": {
                "UD": "Su-Giù",
                "target": "Bersaglio",
                "LR": "Sinistra-Destra",
                "swim": "Nuota",
                "aiIs": "IA: {0}",
                "headerCustomAi": "IA Perosonalizzata:",
                "jump": "Salta",
                "use1_0Ai": "Usare IA 1.0?",
                "leap": ""
            },
            "gen": {
                "effectWarp": "Warp",
                "header": "Impostazioni Generatore",
                "direction": "Direzione",
                "effectIs": "Effetto: {0}",
                "effectShoot": "Spara"
            },
            "inContainer": "In",
            "inertNice": "Amichevole",
            "props": {
                "active": "Attivo",
                "facing": "Affacciato",
                "attachSurface": "Attacca"
            },
            "abbrevGen": "Generatore",
            "stuckStop": "Fermo",
            "tooltipExpandSection": "Sezione di espansione"
        },
        "events": {
            "deletion": {
                "deletingEvent": "Rimozione Evento {0}",
                "cancel": "No: non eliminare l'evento",
                "confirm": "Sì: elimina l'evento"
            },
            "desc": {
                "activate": "Quando gli NPC entrano nello schermo",
                "death": "Quando NPC muore",
                "destroy": "Quando il blocco è distrutto",
                "enter": "Quando si è entrati nella warp",
                "hit": "Quando il blocco viene colpito",
                "layerClear": "Quando lo strato è vuoto",
                "phraseTriggersWhenTemplate": "{0} bersagli quando {1}",
                "talk": "Quando il giocatore parla con NPC",
                "phraseTriggersAfterTemplate": ""
            },
            "sections": {
                "actionSet": "Imposta",
                "actionKeep": "Mantieni",
                "actionReset": "Ripristina",
                "phraseAllSections": "Tutte le sezioni",
                "propBackground": "Sfondo",
                "propMusic": "Musica",
                "propBounds": ""
            },
            "bounds": {
                "changeAllSectionBoundsToCurrent": "Vuoi cambiare tutte le sezioni collegate a quella attuale?",
                "shouldEvent": "",
                "changeSectionBoundsToCurrent": "Vuoi cambiare la sezione {0} collegate a quella attuale?"
            },
            "controlsForEventN": "Controlli per evento {0}",
            "header": "Eventi:",
            "headerTriggerEvent": "Bersaglio:",
            "itemNewEvent": "<Nuovo Evento>",
            "label": {
                "activate": "Attiva",
                "death": "Morte",
                "destroy": "Distruggi",
                "enter": "Entra",
                "hit": "Colpisci",
                "layerClear": "Strato Vuoto",
                "next": "Prossimo",
                "talk": "Parla"
            },
            "layers": {
                "headerHide": "Nascondi:",
                "headerMove": "Muovi:",
                "headerShow": "Mostra:",
                "headerToggle": "Attivazione:"
            },
            "letter": {
                "activate": "A:",
                "death": "D:",
                "destroy": "D:",
                "enter": "E:",
                "hit": "H:",
                "layerClear": "L:",
                "talk": "T:"
            },
            "promptEventName": "Nome dell'evento",
            "promptEventText": "Testo dell'evento",
            "props": {
                "autostart": "Avvio Automatico",
                "controls": "Controlli",
                "endGame": "Fine Gioco",
                "layerSmoke": "Fumo",
                "sound": "Suono"
            },
            "settingsForEvent": "Impostazioni per evento {0}"
        },
        "level": {
            "gameStart": "Inizio Gioco",
            "startPos": "Posizione d'inizio",
            "levelName": "Nome Livello",
            "pathUnlocks": "Quando il percorso si sblocca",
            "alwaysVis": "",
            "bigBG": "",
            "pathBG": ""
        },
        "block": {
            "pickContents": "Scegli il contenuto del blocco",
            "canBreak": "Distrugge",
            "canBreakTooltip": "Viene distrutto quando colpito",
            "inside": "Dentro:",
            "letterHeight": "H",
            "letterWidth": "W",
            "slick": "Scivola",
            "invis": "Invisib"
        },
        "browser": {
            "askOverwriteFile": "Vuoi Sovrascrivere{0}?",
            "itemNewFile": "<Nuovo File>",
            "itemNewFolder": "<Nuova Cartella>",
            "newFile": "Nuovo File",
            "openFile": "Apri File",
            "saveFile": "Salva File"
        },
        "letterLeft": "L",
        "letterRight": "R",
        "letterUp": "U",
        "mapPos": "Posizione Mappa:",
        "pageBlankOfBlank": "Pagina {0} di {1}",
        "phraseAreYouSure": "Sei sicuro?",
        "phraseCountMore": "{0} Altro",
        "phraseDelayIsMs": "Ritardo: {0} ms",
        "phraseGenericIndex": "Numero {0}",
        "labelSortLayer": "Livello Strato:",
        "labelSortOffset": "",
        "phraseSectionIndex": "",
        "phraseWarpIndex": "",
        "phraseTextOf": "",
        "section": {
            "horizWrap": "",
            "vertWrap": "",
            "offscreenExit": "",
            "setBounds": "",
            "scroll": "",
            "underwater": "",
            "noTurnBack": ""
        },
        "warp": {
            "transit": {
                "name3": "",
                "name2": "",
                "name0": "",
                "name1": "",
                "name5": "",
                "name4": ""
            },
            "item": "",
            "needKey": "",
            "cannonExit": "",
            "lvlWarp": "",
            "needFloor": "",
            "in": "",
            "showStarCount": "",
            "ride": "",
            "showStartScene": "",
            "speed": "",
            "starLockMessage": "",
            "allow": "",
            "dir": "",
            "effect": "",
            "out": "",
            "placing": "",
            "needStarCount": "",
            "style": {
                "blipInstant": "",
                "pipe": "",
                "door": "",
                "portal": "",
                "style": ""
            },
            "toMap": "",
            "twoWay": "",
            "title": "",
            "target": "",
            "to": ""
        },
        "wordEnabled": "",
        "tooltip": {
            "settings": "",
            "select": "",
            "scenes": "",
            "BGOs": "",
            "events": "",
            "NPCs": "",
            "file": "",
            "music": "",
            "levels": "",
            "paths": "",
            "layers": "",
            "show": "",
            "tiles": "",
            "warps": "",
            "water": "",
            "blocks": "",
            "area": "",
            "eraseAll": "",
            "erase": ""
        },
        "select": {
            "allSectPropBlankForEventN": "",
            "sectionBlankPropBlank": "",
            "warpTransitEffect": "",
            "sectBlankPropBlankForEventN": "",
            "soundForEventN": "",
            "pathBlankUnlock": "",
            "worldMusic": ""
        },
        "wordWidth": "",
        "wordEvent": {
            "typeLabel": "",
            "nominative": "",
            "genitive": ""
        },
        "wordInstant": "",
        "wordMode": "",
        "world": {
            "allowChars": "",
            "hubWorld": "",
            "introLevel": "",
            "phraseCreditIndex": "",
            "name": "",
            "totalStars": "",
            "retryOnFail": ""
        },
        "phraseRadiusIndex": "",
        "testPlay": {
            "power": "",
            "magicHand": "",
            "pet": "",
            "char": "",
            "boot": ""
        },
        "toggleMagicBlock": "",
        "wordCoins": "",
        "wordHeight": "",
        "wordNPC": {
            "nominative": "",
            "genitive": ""
        },
        "wordText": "",
        "water": {
            "title": ""
        }
    },
    "menu": {
        "options": {
            "advanced": {
                "audio-format": {
                    "_name": "",
                    "_tooltip": ""
                },
                "audio-enable": "",
                "log-level": {
                    "fatal": "",
                    "info": "",
                    "warning": "",
                    "none": "",
                    "critical": "",
                    "debug": "",
                    "_name": ""
                },
                "render": {
                    "opengles-tip": "",
                    "opengles11": "",
                    "opengles11-tip": "",
                    "sdl-tip": "",
                    "hw": "",
                    "opengl-tip": "",
                    "opengl": "",
                    "opengl11": "",
                    "opengl11-tip": "",
                    "sdl": "",
                    "_name": "",
                    "opengles": "",
                    "sw": ""
                },
                "_header": "",
                "audio-channels": {
                    "stereo": "",
                    "_name": "",
                    "mono": ""
                },
                "audio-sample-rate": {
                    "16000": "",
                    "22050": "",
                    "32000": "",
                    "48000": "",
                    "44100": "",
                    "11025": "",
                    "_name": ""
                },
                "record-gameplay-data": "",
                "scale-down-textures": {
                    "all": "",
                    "all-tip": "",
                    "none": "",
                    "_name": "",
                    "_tooltip": "",
                    "none-tip": "",
                    "safe": "",
                    "safe-tip": ""
                },
                "internal-res-4p": {
                    "fhd": "",
                    "default": "",
                    "_name": "",
                    "qhd": "",
                    "qsmbx": ""
                },
                "_tooltip": "",
                "advanced-video": "",
                "advanced-audio": "",
                "audio-buffer-size": {
                    "_name": "",
                    "_tooltip": ""
                },
                "choose-assets-on-launch": "",
                "webm-recording": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "audio": {
                "sfx-audio-fx": "",
                "sfx-modern": "",
                "sfx-pet-beat": "",
                "sfx-spatial-audio": "",
                "sfx-spatial-audio-tip": "",
                "_header": "",
                "audio-prefs": "",
                "audio-music-volume": "",
                "audio-sfx-volume": "",
                "sfx-modern-tip": "",
                "sfx-pet-beat-tip": ""
            },
            "episode-options": {
                "creator-compat": {
                    "disable": "",
                    "_tooltip": "",
                    "_name": "",
                    "file-only": "",
                    "enable": ""
                },
                "playstyle": {
                    "vanilla-tip": "",
                    "vanilla": "",
                    "modern-tip": "",
                    "classic-tip": "",
                    "classic": "",
                    "_name": "",
                    "modern": ""
                },
                "_header": "",
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "video": {
                "scale-mode": {
                    "_name": "",
                    "center": "",
                    "0_5x": "",
                    "integer": "",
                    "2x": "",
                    "1x": "",
                    "nearest": "",
                    "full": "",
                    "linear": "",
                    "3x": ""
                },
                "battery-status": {
                    "low-tip": "",
                    "on": "",
                    "low": "",
                    "off": "",
                    "fullscreen-tip": "",
                    "fullscreen": "",
                    "_name": ""
                },
                "effects": "",
                "info-run": "",
                "show-medals-counter-tip": "",
                "show-medals-counter": "",
                "show-playtime-counter": {
                    "animated": "",
                    "_tooltip": "",
                    "_name": "",
                    "off": "",
                    "animated-tip": "",
                    "off-tip": "",
                    "opaque": "",
                    "transparent": ""
                },
                "show-screen-shake": "",
                "world-map-stars-show-tip": "",
                "video-system": "",
                "world-map-stars-show": "",
                "internal-res": {
                    "hd": "",
                    "_tooltip": "",
                    "dynamic": "",
                    "3ds": "",
                    "_name": "",
                    "gba": "",
                    "snes": "",
                    "vga": "",
                    "smbx-wide": "",
                    "nds": "",
                    "hello": "",
                    "smbx": ""
                },
                "info-game": "",
                "info-meta": "",
                "display-controllers": "",
                "fullscreen": "",
                "_header": "",
                "enable-inter-level-fade-effect": "",
                "show-episode-title": {
                    "top": "",
                    "_name": "",
                    "bottom-tip": "",
                    "off": "",
                    "bottom": "",
                    "top-tip": ""
                },
                "3d-compat-mode-tip": "",
                "show-fails-counter-tip": "",
                "show-fails-counter": "",
                "show-fps": "",
                "3d-compat-mode": ""
            },
            "main": {
                "four-screen-mode": {
                    "_name": "",
                    "split": "",
                    "shared": ""
                },
                "two-screen-mode": {
                    "smbx": "",
                    "split": "",
                    "topbottom": "",
                    "_name": "",
                    "shared": ""
                },
                "_header": "",
                "discord-rpc": "",
                "frame-skip": "",
                "timing": "",
                "vsync": "",
                "multiplayer": "",
                "background-work": "",
                "language": "",
                "background-work-tip": "",
                "unlimited-framerate": ""
            },
            "view-credits": {
                "_header": ""
            },
            "restartEngine": "",
            "speedrun": {
                "mode": {
                    "0": "",
                    "1": "",
                    "_name": "",
                    "3": "",
                    "2": ""
                }
            },
            "compatibility": {
                "bugfixes": "",
                "autocode": "",
                "_tooltip": "",
                "_header": "",
                "reset-all": "",
                "features": ""
            },
            "controls": {
                "_header": ""
            }
        },
        "main": {
            "mainMultiplayerGame": "",
            "main1PlayerGame": "",
            "mainEditor": "",
            "mainExit": "",
            "mainBattleGame": "",
            "mainOptions": "",
            "mainPlayEpisode": ""
        },
        "controls": {
            "controlsInUse": "",
            "controlsDeleteKey": "",
            "controlsDeviceTypes": "",
            "editor": {
                "scrollDown": "",
                "scrollLeft": "",
                "prevSection": "",
                "nextSection": "",
                "switchScreens": "",
                "modeErase": "",
                "modeSelect": "",
                "scrollRight": "",
                "fastScroll": "",
                "scrollUp": "",
                "testPlay": ""
            },
            "tDS": {
                "buttonZR": "",
                "buttonL": "",
                "buttonB": "",
                "casePen": "",
                "tStick": "",
                "dPad": "",
                "buttonY": "",
                "buttonX": "",
                "buttonA": "",
                "buttonZL": "",
                "buttonStart": "",
                "buttonR": "",
                "buttonSelect": "",
                "cStick": ""
            },
            "wii": {
                "typeWiimote": "",
                "classic": {
                    "buttonX": "",
                    "buttonRT": "",
                    "buttonLT": "",
                    "buttonY": "",
                    "lStick": "",
                    "buttonZR": "",
                    "rStick": "",
                    "buttonZL": ""
                },
                "nunchuck": {
                    "prefixN": "",
                    "buttonZ": "",
                    "buttonC": ""
                },
                "wiimote": {
                    "button1": "",
                    "caseIR": "",
                    "shake": "",
                    "dPad": "",
                    "buttonMinus": "",
                    "button2": "",
                    "buttonHome": "",
                    "buttonB": "",
                    "buttonPlus": "",
                    "buttonA": ""
                },
                "phraseNewClassic": "",
                "phraseNewNunchuck": "",
                "typeClassic": "",
                "typeNunchuck": "",
                "typeGamecube": ""
            },
            "caseMouse": "",
            "profile": {
                "cursorControls": "",
                "editorControls": "",
                "playerControls": "",
                "hotkeys": "",
                "renameProfile": "",
                "deleteProfile": ""
            },
            "phraseNewProfOldJoy": "",
            "hotkeys": {
                "debugInfo": "",
                "enterCheats": "",
                "toggleHUD": "",
                "legacyPause": "",
                "fullscreen": "",
                "recordGif": "",
                "screenshot": "",
                "vanillaCam": ""
            },
            "cursor": {
                "left": "",
                "primary": "",
                "secondary": "",
                "right": "",
                "tertiary": "",
                "up": "",
                "down": ""
            },
            "buttons": {
                "left": "",
                "altJump": "",
                "altRun": "",
                "drop": "",
                "jump": "",
                "down": "",
                "right": "",
                "run": "",
                "up": "",
                "start": ""
            },
            "touchscreen": {
                "layout": {
                    "tinyOld": "",
                    "tight": "",
                    "longOld": "",
                    "phoneOld": "",
                    "phabletOld": "",
                    "tabletOld": "",
                    "standard": ""
                },
                "option": {
                    "feedbackLength": "",
                    "feedbackStrength": "",
                    "holdRun": "",
                    "interfaceStyle": "",
                    "scaleDPad": "",
                    "scaleButtons": "",
                    "layoutStyle": "",
                    "sStartSpacing": "",
                    "resetLayout": "",
                    "showCodeButton": "",
                    "scaleFactor": ""
                },
                "style": {
                    "ABXY": "",
                    "actions": "",
                    "XODA": ""
                }
            },
            "wordButtons": "",
            "joystickSimpleEditor": "",
            "types": {
                "touchscreen": "",
                "gamepad": "",
                "oldJoystick": "",
                "keyboard": ""
            },
            "controlsNewProfile": "",
            "controlsReallyDeleteProfile": "",
            "controlsNotInUse": "",
            "controlsTitle": "",
            "wordProfiles": "",
            "options": {
                "batteryStatus": "",
                "textEntryStyle": "",
                "rumble": "",
                "maxPlayers": ""
            },
            "controlsConnected": "",
            "caseTouch": "",
            "caseInvalid": ""
        },
        "wordPlayer": "",
        "wordProfile": "",
        "game": {
            "gameSourceSlot": "",
            "gameBattleRandom": "",
            "gameEraseSave": "",
            "gameNoEpisodesToPlay": "",
            "gameSlotContinue": "",
            "gameEraseSlot": "",
            "gameNoBattleLevels": "",
            "phraseTime": "",
            "gameSlotNew": "",
            "gameTargetSlot": "",
            "phraseScore": "",
            "gameCopySave": "",
            "warnEpCompat": ""
        },
        "caseNone": "",
        "editor": {
            "battles": "",
            "errorMissingResources": "",
            "promptNewWorldName": "",
            "newWorld": "",
            "makeFor": ""
        },
        "wordOff": "",
        "wordOn": "",
        "wordNo": "",
        "character": {
            "selectCharacter": ""
        },
        "battle": {
            "errorNoLevels": ""
        },
        "abbrevMilliseconds": "",
        "loading": "",
        "wordYes": "",
        "wordWaiting": "",
        "wordResume": "",
        "wordShow": "",
        "wordBack": "",
        "wordHide": ""
    },
    "game": {
        "connect": {
            "phraseDropPX": "",
            "phraseForceResume": "",
            "dropAddTitle": "",
            "phraseHoldStart": "",
            "phraseDropMe": "",
            "phraseChangeChar": "",
            "phraseStartToResume": "",
            "phraseStartToForceRes": "",
            "phraseSetControls": "",
            "phrasePressAButton": "",
            "phraseTestControls": "",
            "splitPressSelect_2": "",
            "splitPressSelect_1": "",
            "reconnectTitle": "",
            "phraseTestProfile": "",
            "wordDisconnect": "",
            "phraseWaitingForInput": ""
        },
        "pause": {
            "saveAndContinue": "",
            "continue": "",
            "playerSetup": "",
            "quit": "",
            "enterCode": "",
            "resetCheckpoints": "",
            "restartLevel": "",
            "quitTesting": "",
            "returnToEditor": "",
            "saveAndQuit": ""
        },
        "error": {
            "warpNeedStarCount": "",
            "openFileFailed": "",
            "errorInvalidEnterWarp": "",
            "errorNoStartPoint": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "hint": {
            "no-lives-old": "",
            "no-lives-new": "",
            "char5-bombs": "",
            "gray-bricks": "",
            "rainbow-surf": "",
            "heavy-duck": "",
            "shoe-block": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "msgbox": {
            "sysInfoError": "",
            "sysInfoTitle": "",
            "sysInfoWarning": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "outro": {
        "qualityControl": "",
        "cppPortDevelopers": "",
        "engineCredits": "",
        "specialThanks": "",
        "psVitaPortBy": "",
        "originalBy": "",
        "nameVitalyNovichkov": "",
        "nameAndrewSpinks": "",
        "levelDesign": "",
        "gameCredits": "",
        "customSprites": ""
    },
    "languageName": "",
    "pluralRules": ""
}


================================================
FILE: resources/languages/thextech_ja.json
================================================
{
    "game": {
        "connect": {
            "dropAddTitle": "プレイヤー数の へんこう",
            "phraseChangeChar": "キャラクターの へんこう",
            "phraseDropMe": "ゲームから ぬける",
            "phraseDropPX": "P{0}をゲームから ぬけさせる",
            "phraseForceResume": "強制的に 再開",
            "phraseHoldStart": "スタートボタンを ながおし",
            "phrasePressAButton": "Aボタンを おしてください",
            "phraseSetControls": "操作を せっていする",
            "phraseStartToForceRes": "スタートボタンをおして 強制的に再開",
            "phraseStartToResume": "スタートボタンをおして 再開",
            "phraseTestControls": "テスト コントロール",
            "phraseTestProfile": "テスト プロファイル",
            "phraseWaitingForInput": "入力を まっています...",
            "reconnectTitle": "再せつぞく する",
            "splitPressSelect_1": "選択してください",
            "splitPressSelect_2": "そうさ 設定",
            "wordDisconnect": "せつだん する"
        },
        "error": {
            "warpNeedStarCount": "ここに入るには {0}個の{1}がひつようです。",
            "errorInvalidEnterWarp": "無効な入口ワープ{1}が指定されたため、コースを開始できませんでした。\nワープエントリの合計数: {2}\n\nファイルパス: {0}",
            "openFileFailed": "\"{0}\"をひらけませんでした。\nファイルが存在しないか、こわれています。",
            "errorNoStartPoint": "利用可能なスタートポイント、または入口ワープがセットされていないため、コースを開始できませんでした。\n\nファイルパス:{0}",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "データが破損しているか、何らかの不具合があるため、受信したデータを処理できません。",
            "IPCTimeOut": "エディターが応答しませんでした。ゲームを終了します。",
            "errorTooOldEngine": ""
        },
        "hint": {
            "pound-altrun": "オルトダッシュで ヒップドロップだ！",
            "pound-down": "下を押して ヒップドロップだ！",
            "no-lives-new": "ライフがもうない？ まえがりに なるよ！ スコアに きをつけて...",
            "no-lives-old": "気を付けて...もうすぐ ゲームオーバーだぞ！",
            "rainbow-surf": "つかんで、はしって、下に入力して コウラをはなせば サーフィンだ！",
            "char5-bombs": "ダッシュボタンで バクダンを回収できる。オルトダッシュで はっしゃだ！",
            "heavy-duck": "しゃがめば ほとんどの炎を ブロックできる！",
            "shoe-block": "履いていれば ほとんどの炎を ブロックできる！",
            "gray-bricks": "いくつかのブロックは\nとくしゅなアイテムで\nこわせるぞ！"
        },
        "message": {
            "scanningLevels": "レベルをスキャン中..."
        },
        "format": {
            "minutesSeconds": "{0}分{1}秒"
        },
        "pause": {
            "continue": "ゲームを つづける",
            "playerSetup": "プレイヤー数の 変更",
            "enterCode": "コードを 入力する",
            "quit": "ゲームを やめる",
            "quitTesting": "テストを やめる",
            "resetCheckpoints": "チェックポイントを リセットする",
            "restartLevel": "コースを やりなおす",
            "returnToEditor": "エディターに もどる",
            "saveAndContinue": "セーブして つづける",
            "saveAndQuit": "セーブして やめる"
        },
        "screenPaused": "ポーズちゅう",
        "msgbox": {
            "sysInfoWarning": "注意！",
            "sysInfoTitle": "情報",
            "sysInfoError": "エラー！"
        },
        "loader": {
            "statusLoadData": "データを読み込み中...",
            "statusGameInfo": "ゲーム情報",
            "statusLoadFile": "ロード中:{0}",
            "statusFinishing": "完了中です...",
            "statusAssetPacks": "アセットパック",
            "statusTranslations": "翻訳",
            "loading": "ロード中..."
        },
        "ipcStatus": {
            "loadingdone": "完了しました。ゲームを開始中です...",
            "dataAccepted": "データを受信しました。解析中です...",
            "dataTransferStarted": "データの移行を開始中...",
            "errorTimeout": "エラー:タイムアウトしました。",
            "dataValid": "受け取ったデータは有効です",
            "waitingInput": "入力データをまっています..."
        }
    },
    "languageName": "日本語",
    "menu": {
        "abbrevMilliseconds": "MS",
        "battle": {
            "errorNoLevels": "コースがないため バトルモードをあそべません。"
        },
        "caseNone": "<なし>",
        "controls": {
            "buttons": {
                "altJump": "オルト ジャンプ",
                "altRun": "オルト ダッシュ",
                "down": "下",
                "drop": "ストックアイテム",
                "jump": "ジャンプ",
                "left": "左",
                "right": "右",
                "run": "ダッシュ",
                "start": "スタート",
                "up": "上"
            },
            "caseInvalid": "(無効)",
            "caseMouse": "(マウス)",
            "caseTouch": "(タッチ)",
            "controlsConnected": "接続中:",
            "controlsDeleteKey": "(オルトジャンプで削除)",
            "controlsDeviceTypes": "デバイスの 種類",
            "controlsInUse": "(使用中)",
            "controlsNewProfile": "<あたらしいプロファイルをつくる>",
            "controlsNotInUse": "(使用していません)",
            "controlsReallyDeleteProfile": "ほんとうにこのプロファイルを消しますか？",
            "controlsTitle": "そうさ設定",
            "cursor": {
                "down": "マウス 下",
                "left": "マウス 左",
                "primary": "左クリック",
                "right": "マウス 右",
                "secondary": "右クリック",
                "tertiary": "中クリック",
                "up": "マウス 上"
            },
            "hotkeys": {
                "debugInfo": "デバッグじょうほう",
                "enterCheats": "コードにゅうりょく",
                "fullscreen": "フルスクリーン",
                "legacyPause": "旧ポーズ画面",
                "recordGif": "GIFをほぞん",
                "screenshot": "スクリーンショット",
                "toggleHUD": "HUDのきりかえ",
                "vanillaCam": "バニラ カメラ"
            },
            "options": {
                "batteryStatus": "バッテリー状態",
                "maxPlayers": "最大人数",
                "rumble": "振動",
                "textEntryStyle": "テキスト入力方法",
                "altMenuControls": "メニューそうさのボタンを反転する"
            },
            "joystickSimpleEditor": "シンプルな エディター操作",
            "phraseNewProfOldJoy": "古いジョイスティック向けプロファイルをつくる",
            "profile": {
                "cursorControls": "カーソルの そうさ設定",
                "deleteProfile": "プロファイルを 削除",
                "editorControls": "エディターの そうさ設定",
                "hotkeys": "ホットキー",
                "playerControls": "プレイヤーの そうさ設定",
                "renameProfile": "プロファイルの おなまえ変更"
            },
            "tDS": {
                "buttonSelect": "セレクト",
                "buttonStart": "スタート",
                "cStick": "Cスティック",
                "dPad": "十字キー",
                "tStick": "スライドパッド",
                "buttonY": "Y",
                "buttonB": "B",
                "buttonZL": "ZL",
                "casePen": "(タッチペン)",
                "buttonZR": "ZR",
                "buttonA": "A",
                "buttonX": "X",
                "buttonL": "L",
                "buttonR": "R"
            },
            "touchscreen": {
                "layout": {
                    "longOld": "ロング(旧)",
                    "phabletOld": "ファブレット(旧)",
                    "phoneOld": "スマホ(旧)",
                    "standard": "スタンダード",
                    "tabletOld": "タブレット(旧)",
                    "tight": "タイト",
                    "tinyOld": "小さめ(旧)"
                },
                "option": {
                    "feedbackLength": "振動の ながさ",
                    "feedbackStrength": "振動の つよさ",
                    "holdRun": "ゲーム開始時に ダッシュボタンをホールド",
                    "interfaceStyle": "インターフェース スタイル",
                    "layoutStyle": "レイアウト スタイル",
                    "resetLayout": "レイアウトを リセット",
                    "sStartSpacing": "スタート・セレクトボタンの幅",
                    "scaleButtons": "ボタンの大きさをかえる",
                    "scaleDPad": "十字キーの大きさをかえる",
                    "scaleFactor": "拡大係数",
                    "showCodeButton": "コード入力ボタンを表示する"
                },
                "style": {
                    "actions": "アクションを表示",
                    "XODA": "XODA",
                    "ABXY": "ABXY"
                }
            },
            "types": {
                "gamepad": "コントローラー",
                "keyboard": "キーボード",
                "oldJoystick": "旧ジョイスティック",
                "touchscreen": "タッチスクリーン"
            },
            "wii": {
                "phraseNewClassic": "あたらしいクラシックコントローラー プロファイルをつくる",
                "phraseNewNunchuck": "あたらしいヌンチャク プロファイルをつくる",
                "typeClassic": "クラシック コントローラー",
                "typeNunchuck": "ヌンチャク",
                "typeWiimote": "Wiiリモコン",
                "typeGamecube": "GCコントローラー",
                "wiimote": {
                    "buttonHome": "ホーム",
                    "dPad": "十字キー",
                    "shake": "リモコンを振る",
                    "caseIR": "(センサー)",
                    "buttonPlus": "",
                    "buttonMinus": "",
                    "button1": "",
                    "buttonB": "",
                    "button2": "",
                    "buttonA": ""
                },
                "classic": {
                    "lStick": "",
                    "buttonY": "",
                    "buttonRT": "",
                    "rStick": "",
                    "buttonLT": "",
                    "buttonX": "",
                    "buttonZR": "",
                    "buttonZL": ""
                },
                "nunchuck": {
                    "buttonC": "",
                    "buttonZ": "",
                    "prefixN": ""
                }
            },
            "wordButtons": "ボタン",
            "wordProfiles": "プロファイル",
            "editor": {
                "modeSelect": "モードせんたく",
                "scrollUp": "上にスクロール",
                "prevSection": "まえの領域",
                "scrollRight": "右にスクロール",
                "switchScreens": "パネルを表示",
                "modeErase": "さくじょモード",
                "nextSection": "つぎの領域",
                "fastScroll": "スクロール速度アップ",
                "scrollLeft": "左にスクロール",
                "testPlay": "テストプレイ",
                "scrollDown": "下にスクロール"
            },
            "controlsDeleteKey2": "(オルトダッシュで削除)"
        },
        "game": {
            "gameBattleRandom": "ランダムコース",
            "gameCopySave": "セーブをコピーする",
            "gameEraseSave": "セーブをけす",
            "gameEraseSlot": "削除するスロットを 選択してください",
            "gameNoBattleLevels": "<バトルコースがありません>",
            "gameNoEpisodesToPlay": "<エピソードがありません>",
            "warnEpCompat": "このエピソードはほかのSMBXバージョン向けにつくられているため うまく遊べないかもしれません。",
            "gameSlotContinue": "スロット {0} ... {1}%",
            "gameSlotNew": "スロット {0} ... NEW GAME",
            "gameSourceSlot": "コピーするセーブを えらんでください",
            "gameTargetSlot": "どこに コピーする？",
            "phraseScore": "スコア: {0}",
            "phraseTime": "プレイ時間: {0}"
        },
        "loading": "ロード中...",
        "main": {
            "main1PlayerGame": "1プレイヤー ゲーム",
            "mainBattleGame": "バトル ゲーム",
            "mainEditor": "ステージ エディター",
            "mainExit": "ゲームを やめる",
            "mainMultiplayerGame": "2プレイヤー ゲーム",
            "mainOptions": "設定",
            "mainPlayEpisode": "エピソードを あそぶ"
        },
        "options": {
            "restartEngine": "変更は再起動後に有効になります。",
            "advanced": {
                "_header": "高度な設定",
                "_tooltip": "ゲームをこまかく変える 技術的な設定です。",
                "advanced-audio": "音声",
                "advanced-video": "映像",
                "audio-buffer-size": {
                    "_name": "バッファサイズ",
                    "_tooltip": "あげればあげるほどポップ音がへりますが、ゲームの負荷がより重くなります"
                },
                "audio-channels": {
                    "_name": "チャンネル",
                    "mono": "モノラル",
                    "stereo": "ステレオ"
                },
                "audio-enable": "有効",
                "audio-format": {
                    "_name": "オーディオフォーマット",
                    "_tooltip": "サウンドドライバーのフォーマットをえらびます。"
                },
                "audio-sample-rate": {
                    "_name": "サンプルレート",
                    "32000": "",
                    "16000": "",
                    "22050": "",
                    "44100": "",
                    "11025": "",
                    "48000": ""
                },
                "log-level": {
                    "_name": "ログレベル",
                    "critical": "致命的",
                    "debug": "デバッグ",
                    "fatal": "重大",
                    "info": "情報のみ",
                    "none": "なし",
                    "warning": "警告"
                },
                "record-gameplay-data": "ゲームプレイを録画",
                "render": {
                    "_name": "描画モード",
                    "hw": "自動",
                    "opengl-tip": "すべてのあたらしい視覚エフェクトとSMBX64への完全な正確性をサポートしたデスクトップAPIです。",
                    "opengl11-tip": "SMBX64への完全な正確性のみをサポートしたふるいデスクトップAPIです。",
                    "opengles-tip": "すべてのあたらしい視覚エフェクトとSMBX64への高い正確性をサポートしたモバイルAPIです。",
                    "opengles11-tip": "SMBX64への完全な正確性のみをサポートしたふるいモバイルAPIです。",
                    "sdl-tip": "基本のクロスプラットフォーム描画APIです。",
                    "opengl": "",
                    "opengl11": "",
                    "opengles11": "",
                    "sw": "",
                    "opengles": "",
                    "sdl": ""
                },
                "scale-down-textures": {
                    "_name": "画像をスケールダウンする",
                    "_tooltip": "画像の解像度を1xとしてメモリを保全します。",
                    "all": "すべて",
                    "all-tip": "「安全」よりもスタッタリングがすくないです。",
                    "none": "None",
                    "none-tip": "ロード中のスタッタリングがもっともすくないです。",
                    "safe": "安全",
                    "safe-tip": "画像が2xになっているときチェックします。"
                },
                "inaccurate-gifs": "ふせいかくなGIF",
                "inaccurate-gifs-tip": "GIFが描画されたときの3Dエフェクトを許可します。",
                "webm-recording": "WEBMで録画",
                "internal-res-4p": {
                    "_name": "4人プレイ時の画面サイズ",
                    "default": "デフォルト",
                    "qhd": "",
                    "fhd": "",
                    "qsmbx": ""
                },
                "fullscreen-type": {
                    "_name": "フルスクリーンタイプ",
                    "auto": "自動",
                    "desktop": "デスクトップ",
                    "desktop-tip": "現在の画面解像度を保持します。いわゆる｢ボーダーレス｣です。",
                    "exclusive": "占有モード",
                    "exclusive-tip": "物理的に画面解像度を変更します。よくあるフルスクリーンです。"
                },
                "fullscreen-depth": {
                    "auto": "自動",
                    "16": "16ビット",
                    "_name": "占有モード時の色深度",
                    "32": "32ビット"
                },
                "choose-assets-on-launch": "起動時に ゲームをえらぶ",
                "use-native-osk": "内部キーボードを優先する",
                "fullscreen-res": "占有モード時の解像度"
            },
            "audio": {
                "_header": "音声",
                "audio-music-volume": "音楽のボリューム",
                "audio-prefs": "オーディオせってい",
                "audio-sfx-volume": "効果音のボリューム",
                "sfx-audio-fx": "エコー効果",
                "sfx-modern": "モダンな効果音",
                "sfx-modern-tip": "TheXTechで追加された あたらしい効果音を使います。",
                "sfx-pet-beat": "ペット・グルーブ",
                "sfx-pet-beat-tip": "ペットにのっているあいだ、とくべつなグルーブが再生されます。",
                "sfx-spatial-audio": "立体音響",
                "sfx-spatial-audio-tip": "画面外の音をちいさくします。"
            },
            "controls": {
                "_header": "そうさ設定"
            },
            "episode-options": {
                "_header": "エピソードせってい",
                "playstyle": {
                    "_name": "プレイスタイル",
                    "classic": "クラシック",
                    "classic-tip": "限定的なアップデートのみ",
                    "modern": "モダン",
                    "modern-tip": "すべてのアップデート",
                    "vanilla": "バニラ",
                    "vanilla-tip": "アップデートなし"
                },
                "hub-resume": "ワールドマップでのワープをほぞん",
                "hub-resume-tip": "さいごに入ったワープからゲームを再開します。",
                "creator-compat": {
                    "_name": "",
                    "disable": "",
                    "file-only": "",
                    "enable": "",
                    "_tooltip": ""
                }
            },
            "main": {
                "_header": "メイン",
                "background-work": "バックグラウンドで実行",
                "background-work-tip": "非フォーカス中でもジョイスティックでゲームをプレイできるようにします。",
                "four-screen-mode": {
                    "_name": "4Pゲームの画面モード",
                    "shared": "共有",
                    "split": "分割"
                },
                "frame-skip": "フレームスキップ",
                "language": "言語",
                "multiplayer": "マルチプレイヤー",
                "timing": "フレームタイミング",
                "two-screen-mode": {
                    "_name": "2Pゲームの画面モード",
                    "shared": "共有",
                    "smbx": "SMBXスタイル",
                    "split": "左右分割",
                    "topbottom": "上下分割"
                },
                "unlimited-framerate": "フレームレートのせいげんを解除",
                "vsync": "垂直同期",
                "discord-rpc": "Discordに表示"
            },
            "video": {
                "_header": "映像",
                "battery-status": {
                    "_name": "デバイスのバッテリー残量",
                    "fullscreen": "フルスクリーン時",
                    "fullscreen-tip": "フルスクリーンのときのみ表示します。",
                    "low": "残量低下時",
                    "low-tip": "バッテリー残量低下時にのみ表示します。",
                    "off": "オフ",
                    "on": "常時"
                },
                "display-controllers": "操作を表示",
                "effects": "画面効果",
                "enable-inter-level-fade-effect": "コース移行時にフェード",
                "fullscreen": "フルスクリーン",
                "info-game": "画面上のゲーム情報",
                "info-meta": "画面上のメタ情報",
                "info-run": "画面上のラン情報",
                "internal-res": {
                    "3ds": "800x480 (3DS)",
                    "_name": "画面サイズ",
                    "_tooltip": "ゲーム画面の解像度をへんこうします。",
                    "dynamic": "ダイナミック",
                    "smbx-wide": "",
                    "vga": "",
                    "snes": "",
                    "gba": "",
                    "hello": "",
                    "hd": "",
                    "nds": "",
                    "smbx": ""
                },
                "scale-mode": {
                    "_name": "スケールモード",
                    "integer": "整数",
                    "linear": "スムーズ",
                    "nearest": "二アレスト",
                    "full": "フル",
                    "center": "中心",
                    "0_5x": "",
                    "2x": "",
                    "1x": "",
                    "3x": ""
                },
                "show-episode-title": {
                    "_name": "エピソード名",
                    "bottom": "下部",
                    "bottom-tip": "スピードランタイマーの上に表示します。",
                    "off": "オフ",
                    "top": "上部",
                    "top-tip": "画面上部に表示します。"
                },
                "3d-compat-mode": "3D互換モード",
                "3d-compat-mode-tip": "1つの3D平面上にすべてのオブジェクトを描画します。",
                "show-fails-counter": "ミスカウンター",
                "show-fails-counter-tip": "現在のコースとエピソード全体それぞれの合計ミス数を表示します。",
                "show-fps": "フレームレート",
                "show-medals-counter": "メダルカウンター",
                "show-medals-counter-tip": "コース入り口でHUDにメダルを表示します。",
                "show-playtime-counter": {
                    "_name": "プレイ時間カウンター",
                    "_tooltip": "現在のコースとエピソード全体それぞれの経過時間を表示します。",
                    "animated": "アニメーション",
                    "animated-tip": "コースクリア時にカウンターが虹色に光ります。",
                    "off": "オフ",
                    "off-tip": "スピードラン中のみ表示します。",
                    "opaque": "不透明",
                    "transparent": "半透明"
                },
                "show-screen-shake": "画面の揺れ",
                "video-system": "システム",
                "world-map-stars-show": "ワールドマップでのスターカウンター",
                "world-map-stars-show-tip": "コースで集めたスターのかずをワールドマップでも表示します。"
            },
            "view-credits": {
                "_header": "クレジットを見る"
            },
            "speedrun": {
                "mode": {
                    "_name": "スピードラン モード",
                    "2": "",
                    "0": "",
                    "3": "",
                    "1": ""
                }
            },
            "compatibility": {
                "_header": "セッションの調整",
                "reset-all": "",
                "autocode": "",
                "_tooltip": "",
                "features": "",
                "bugfixes": ""
            }
        },
        "wordBack": "もどる",
        "wordHide": "非表示",
        "wordNo": "いいえ",
        "wordOff": "オフ",
        "wordOn": "オン",
        "wordPlayer": "プレイヤー",
        "wordProfile": "プロファイル",
        "wordResume": "再開",
        "wordShow": "表示",
        "wordWaiting": "待機中",
        "wordYes": "はい",
        "character": {
            "selectCharacter": "{0}のゲーム"
        },
        "editor": {
            "makeFor": "ワールドスタイル:",
            "newWorld": "<あたらしいワールドを つくる>",
            "errorMissingResources": "ざんねん！ゲーム内エディターに必要な {0}が見つかりませんでした。",
            "promptNewWorldName": "あたらしいワールドの名前",
            "battles": "<バトル コース>"
        }
    },
    "outro": {
        "cppPortDevelopers": "C++移植 開発者",
        "customSprites": "カスタムスプライト",
        "engineCredits": "エンジン",
        "gameCredits": "ゲーム",
        "levelDesign": "レベルデザイン",
        "nameVitalyNovichkov": "ノヴィチコーフ・ヴィターリ",
        "originalBy": "オリジナル VB6コード",
        "psVitaPortBy": "PSVita 移植",
        "qualityControl": "品質管理",
        "specialThanks": "スペシャルサンクス",
        "nameAndrewSpinks": "アンドリュー・スピンクス"
    },
    "pluralRules": "singular-only",
    "editor": {
        "layers": {
            "promptLayerName": "",
            "label": "",
            "deletion": {
                "header": "",
                "confirmDelete": "",
                "preserveLayerContents": "",
                "confirmPreserve": "",
                "cancel": ""
            },
            "header": "",
            "labelAttachedLayer": "",
            "labelMoveLayer": "",
            "desc": {
                "att": ""
            },
            "default": "",
            "itemNewLayer": "",
            "abbrevAttLayer": "",
            "labelAttached": ""
        },
        "warp": {
            "needStarCount": "",
            "item": "",
            "lvlWarp": "",
            "needKey": "",
            "placing": "",
            "to": "",
            "showStartScene": "",
            "twoWay": "",
            "needFloor": "",
            "style": {
                "door": "",
                "blipInstant": "",
                "pipe": "",
                "portal": "",
                "style": ""
            },
            "transit": {
                "name2": "",
                "name1": "",
                "name0": "",
                "name3": "",
                "name4": "",
                "name5": ""
            },
            "dir": "",
            "cannonExit": "",
            "allow": "",
            "in": "",
            "out": "",
            "starLockMessage": "",
            "title": "",
            "showStarCount": "",
            "effect": "",
            "target": "",
            "speed": "",
            "toMap": "",
            "ride": ""
        },
        "letterRight": "",
        "wordHeight": "",
        "file": {
            "commandSave": "保存",
            "convert": {
                "descNew": "ファイル拡張子は変更されますが、ふるいファイルは削除されません。\n\n保存した後、消えた機能がないか確認してください。"
            },
            "formatLegacy": "レガシー",
            "commandOpen": "開く...",
            "labelFormat": "形式:",
            "actionOpen": "ひらく",
            "optionCancelAction": "キャンセル:{0}しない",
            "commandSaveAs": "名前をつけて保存...",
            "actionRevert": "もとにもどす",
            "optionYesSaveThenAction": "はい:セーブして {0}",
            "optionActionWithoutSave": "セーブしないで {0}",
            "confirmConvertFormatTo": "形式を {0}にへんこうする？",
            "sectionWorld": "ワールド",
            "commandNew": "新規",
            "actionClearWorld": "ワールドをリセット",
            "optionProceedWithConversion": "変換する",
            "confirmConfirmAction": "ほんとうに {0}？",
            "confirmSaveBeforeAction": "{0}前に セーブする？",
            "optionCancelConversion": "変換をやめる",
            "actionClearLevel": "コースをリセット",
            "actionExit": "やめる",
            "sectionLevel": "コース",
            "labelCurrentFile": "げんざいのファイル:",
            "formatModern": "モダン"
        },
        "events": {
            "sections": {
                "propBounds": "境界",
                "propMusic": "おんがく",
                "propBackground": "背景",
                "actionKeep": "そのまま",
                "actionReset": "リセット",
                "actionSet": "セット",
                "phraseAllSections": "すべてのセクション"
            },
            "label": {
                "next": "次",
                "layerClear": "レイヤークリア",
                "destroy": "破壊",
                "death": "やられ",
                "activate": "有効化",
                "hit": "ヒット",
                "enter": "入場",
                "talk": "会話"
            },
            "letter": {
                "enter": "入:",
                "activate": "き:",
                "talk": "会:",
                "death": "や:",
                "hit": "ヒ:",
                "layerClear": "レ:",
                "destroy": "破:"
            },
            "layers": {
                "headerShow": "表示:",
                "headerHide": "隠す:",
                "headerMove": "移動:",
                "headerToggle": "きりかえ:"
            },
            "desc": {
                "activate": "NPCが画面に入ったとき",
                "destroy": "ブロックが破壊されたとき",
                "hit": "ブロックにヒットしたとき",
                "layerClear": "オブジェクトレイヤーから すべてがなくなったとき",
                "enter": "ワープに入ったとき",
                "phraseTriggersAfterTemplate": "{0}が イベント{2}の発生後 {1}ミリ秒で はっせいする",
                "death": "NPCがやられたとき",
                "phraseTriggersWhenTemplate": "{0} は {1} のときにはっせいする",
                "talk": "プレイヤーがNPCに話しかけたとき"
            },
            "promptEventText": "イベント文",
            "props": {
                "layerSmoke": "スモーク",
                "endGame": "エピソードを終える",
                "controls": "そうさ",
                "autostart": "自動スタート",
                "sound": "効果音"
            },
            "itemNewEvent": "<あたらしい イベント>",
            "bounds": {
                "changeAllSectionBoundsToCurrent": "すべてのセクション領域の現在に変更しますか？",
                "changeSectionBoundsToCurrent": "{0}のセクション境界の現在に変更しますか？",
                "shouldEvent": "イベント {0}を"
            },
            "promptEventName": "イベント名",
            "headerTriggerEvent": "トリガー:",
            "header": "イベント:",
            "deletion": {
                "confirm": "はい:イベントを さくじょする",
                "cancel": "いいえ:イベントを さくじょしない",
                "deletingEvent": "イベント {0}をさくじょ中..."
            },
            "controlsForEventN": "イベント {0}を操作:",
            "settingsForEvent": "イベント {0}の せってい"
        },
        "wordWidth": "",
        "select": {
            "warpTransitEffect": "",
            "soundForEventN": "",
            "pathBlankUnlock": "",
            "allSectPropBlankForEventN": "",
            "worldMusic": "",
            "sectBlankPropBlankForEventN": "",
            "sectionBlankPropBlank": ""
        },
        "tooltip": {
            "BGOs": "",
            "events": "",
            "eraseAll": "",
            "music": "",
            "erase": "",
            "settings": "",
            "NPCs": "",
            "water": "",
            "show": "",
            "paths": "",
            "tiles": "",
            "levels": "",
            "layers": "",
            "warps": "",
            "blocks": "",
            "file": "",
            "select": "",
            "scenes": "",
            "area": ""
        },
        "npc": {
            "ai": {
                "aiIs": "",
                "target": "",
                "swim": "",
                "jump": "",
                "leap": "",
                "UD": "",
                "headerCustomAi": "",
                "use1_0Ai": "",
                "LR": ""
            },
            "tooltipExpandSection": "",
            "stuckStop": "",
            "gen": {
                "header": "",
                "effectShoot": "",
                "direction": "",
                "effectWarp": "",
                "effectIs": ""
            },
            "props": {
                "attachSurface": "",
                "facing": "",
                "active": ""
            },
            "abbrevGen": "",
            "inertNice": "",
            "inContainer": ""
        },
        "block": {
            "invis": "とうめい化",
            "canBreak": "破壊可能",
            "letterHeight": "たて",
            "letterWidth": "よこ",
            "slick": "すべりやすい",
            "canBreakTooltip": "レガシー:ヒット時に破壊",
            "pickContents": "ブロックの中身を\nえらんでください",
            "inside": "なかみ:"
        },
        "letterLeft": "",
        "browser": {
            "askOverwriteFile": "{0}を\n上書きして よろしいですか？",
            "openFile": "ファイルを ひらく",
            "itemNewFolder": "<あたらしい フォルダー>",
            "itemNewFile": "<あたらしい ファイル>",
            "saveFile": "ファイルを ほぞん",
            "newFile": "あたらしい ファイル"
        },
        "level": {
            "startPos": "",
            "pathBG": "",
            "pathUnlocks": "",
            "levelName": "",
            "gameStart": "",
            "alwaysVis": "",
            "bigBG": ""
        },
        "testPlay": {
            "magicHand": "",
            "power": "",
            "char": "",
            "pet": "",
            "boot": ""
        },
        "wordInstant": "",
        "letterDown": "",
        "mapPos": "",
        "world": {
            "introLevel": "",
            "hubWorld": "",
            "name": "",
            "phraseCreditIndex": "",
            "totalStars": "",
            "retryOnFail": "",
            "allowChars": ""
        },
        "letterCoordX": "",
        "water": {
            "title": ""
        },
        "wordMode": "",
        "phraseTextOf": "",
        "wordEnabled": "",
        "wordEvent": {
            "nominative": "",
            "typeLabel": "",
            "genitive": ""
        },
        "phraseSectionIndex": "",
        "wordCoins": "",
        "section": {
            "horizWrap": "",
            "setBounds": "",
            "noTurnBack": "",
            "underwater": "",
            "offscreenExit": "",
            "vertWrap": "",
            "scroll": ""
        },
        "phraseGenericIndex": "",
        "letterUp": "",
        "phraseCountMore": "",
        "wordNPC": {
            "nominative": "",
            "genitive": ""
        },
        "phraseRadiusIndex": "",
        "pageBlankOfBlank": "",
        "phraseWarpIndex": "",
        "labelSortLayer": "レイヤーソート:",
        "phraseAreYouSure": "",
        "toggleMagicBlock": "",
        "phraseDelayIsMs": "",
        "letterCoordY": "",
        "wordText": "",
        "labelSortOffset": "ソート補正:"
    }
}


================================================
FILE: resources/languages/thextech_ko.json
================================================
{
    "editor": {
        "layers": {
            "promptLayerName": "레이어 이름",
            "label": "레이어:",
            "deletion": {
                "header": "레이어 {0} 삭제 중",
                "confirmDelete": "아니요: *모든 콘텐츠 삭제*",
                "preserveLayerContents": "레이어 내용을 보존하겠습니까?",
                "confirmPreserve": "예: 기본 레이어로 이동",
                "cancel": "취소: 레이어를 삭제하지 않음"
            },
            "header": "레이어:",
            "labelAttachedLayer": "첨부 레이어:",
            "labelMoveLayer": "이동 레이어:",
            "desc": {
                "att": "NPC가 움직일 때마다 부착된 레이어도 따라 움직임"
            },
            "default": "기본값",
            "itemNewLayer": "<새로운 레이어>",
            "abbrevAttLayer": "공격: ",
            "labelAttached": "첨부:"
        },
        "block": {
            "invis": "보이지 않음",
            "canBreak": "깨질 수 있음",
            "letterHeight": "높이",
            "letterWidth": "폭",
            "canBreakTooltip": "구버전: 부딪히면 부서진다",
            "pickContents": "블록 내용 선택",
            "inside": "내부:",
            "slick": "미끄러움"
        },
        "file": {
            "labelFormat": "형식:",
            "optionCancelAction": "취소: {0}하지 마세요",
            "optionYesSaveThenAction": "예: 저장한 다음 {0}",
            "optionActionWithoutSave": "저장하지 않고 {0}",
            "sectionWorld": "세계",
            "optionProceedWithConversion": "변환 진행",
            "optionCancelConversion": "변환 취소",
            "sectionLevel": "레벨",
            "labelCurrentFile": "현재 파일: ",
            "formatLegacy": "레거시",
            "formatModern": "최신",
            "actionClearLevel": "레벨 지움",
            "actionClearWorld": "세계 지움",
            "actionExit": "종료",
            "actionOpen": "열기",
            "actionRevert": "복귀",
            "commandNew": "새로운",
            "commandOpen": "열기...",
            "commandSave": "저장",
            "commandSaveAs": "다른 이름으로 저장...",
            "confirmConfirmAction": "정말 {0} 할까요?",
            "confirmConvertFormatTo": "형식을 {0} 변환할까요?",
            "confirmSaveBeforeAction": "{0} 전에 저장할까요?",
            "convert": {
                "descNew": "파일 확장명은 변경되지만 이전 파일은 삭제되지 않습니다.\n\n저장 후 손실된 기능을 확인하십시오."
            }
        },
        "warp": {
            "speed": "속도 ",
            "title": "워프 설정",
            "toMap": "지도로",
            "transit": {
                "name0": "없음",
                "name1": "스크롤",
                "name3": "원",
                "name4": "뒤집기 (수평)",
                "name2": "페이드",
                "name5": "뒤집기 (수직)"
            },
            "twoWay": "양방향",
            "style": {
                "style": "스타일: ",
                "portal": "포트",
                "blipInstant": "순간이동",
                "door": "문",
                "pipe": "파이프"
            },
            "target": "대상: ",
            "cannonExit": "대포 출구",
            "dir": "방향",
            "effect": "효과:",
            "in": "입구",
            "item": "아이템",
            "lvlWarp": "레벨 워프",
            "needFloor": "바닥 필요",
            "needKey": "열쇠 필요",
            "needStarCount": "{0} {1} 필요",
            "out": "출구",
            "placing": "장소:",
            "ride": "타다",
            "showStarCount": "별 개수 표시",
            "showStartScene": "시작 장면 표시",
            "starLockMessage": "별 잠금 메시지",
            "to": "보내기: {0}",
            "allow": "허용:"
        },
        "water": {
            "title": "물 설정"
        },
        "wordEvent": {
            "nominative": "이벤트",
            "typeLabel": "{0} 이벤트:",
            "genitive": "이벤트"
        },
        "wordInstant": "즉시",
        "wordMode": "모드",
        "wordNPC": {
            "genitive": "NPC",
            "nominative": "NPC"
        },
        "wordText": "텍스트",
        "wordWidth": "폭",
        "world": {
            "hubWorld": "허브 월드",
            "name": "월드 이름",
            "retryOnFail": "실패 시 재시도",
            "totalStars": "모은 별: ",
            "allowChars": "캐릭터 허용",
            "phraseCreditIndex": "월드 크레딧 라인 {0}:",
            "introLevel": "인트로 레벨"
        },
        "wordCoins": "동전",
        "wordEnabled": "활성화",
        "wordHeight": "높이",
        "labelSortLayer": "레이어 정렬:",
        "labelSortOffset": "오프셋 정렬:",
        "letterCoordX": "X",
        "letterCoordY": "Y",
        "letterDown": "D",
        "level": {
            "levelName": "레벨 이름",
            "pathUnlocks": "잠금 해제 경로",
            "pathBG": "배경 경로",
            "startPos": "시작 위치",
            "alwaysVis": "항상 표시",
            "bigBG": "큰 배경",
            "gameStart": "게임 시작"
        },
        "mapPos": "지도 위치:",
        "npc": {
            "abbrevGen": "생성기",
            "ai": {
                "LR": "LR",
                "UD": "UD",
                "aiIs": "AI: {0}",
                "headerCustomAi": "커스텀 AI:",
                "jump": "점프",
                "leap": "뛰다",
                "swim": "수영",
                "use1_0Ai": "1.0 AI 사용?",
                "target": "대상"
            },
            "gen": {
                "effectIs": "효과: {0}",
                "effectShoot": "발사",
                "effectWarp": "워프",
                "direction": "방향",
                "header": "생성기 설정"
            },
            "props": {
                "active": "활동적",
                "attachSurface": "위치",
                "facing": "방향"
            },
            "inContainer": "포함",
            "inertNice": "좋음",
            "tooltipExpandSection": "확장 섹션",
            "stuckStop": "정지"
        },
        "pageBlankOfBlank": "{0} 의 {1} 페이지",
        "phraseAreYouSure": "확실한가요?",
        "phraseCountMore": "{0} 더 많은",
        "phraseDelayIsMs": "지연: {0} ms",
        "phraseGenericIndex": "숫자 {0}",
        "phraseRadiusIndex": "반경 {0}",
        "phraseSectionIndex": "섹션 {0}",
        "phraseTextOf": "{0} 텍스트",
        "phraseWarpIndex": "워프 {0}",
        "section": {
            "horizWrap": "수평 워프",
            "noTurnBack": "되돌릴 수 없음",
            "offscreenExit": "오프스크린 종료",
            "scroll": "스크롤",
            "setBounds": "경계 설정",
            "underwater": "수중",
            "vertWrap": "수직 순환"
        },
        "select": {
            "sectBlankPropBlankForEventN": "{2}에 대한 {0} {1} 섹션",
            "sectionBlankPropBlank": "{0} {1} 섹션",
            "soundForEventN": "이벤트 {0} 사운드",
            "warpTransitEffect": "워프 전환 효과",
            "worldMusic": "세계 음악",
            "pathBlankUnlock": "경로 {0} 잠금 해제 기준",
            "allSectPropBlankForEventN": "{1}에 대한 모든 섹션 {0}"
        },
        "testPlay": {
            "boot": "부트",
            "char": "캐릭터",
            "magicHand": "매직 핸드",
            "pet": "애완동물",
            "power": "파워"
        },
        "toggleMagicBlock": "매직 블록",
        "tooltip": {
            "BGOs": "배경 개체",
            "NPCs": "NPC",
            "area": "영역",
            "erase": "지움",
            "events": "이벤트",
            "file": "파일",
            "levels": "레벨",
            "music": "음악",
            "paths": "경로",
            "select": "선택",
            "warps": "워프",
            "water": "물",
            "show": "표시",
            "blocks": "블록",
            "eraseAll": "모두 지움",
            "layers": "레이어",
            "scenes": "장면",
            "settings": "설정",
            "tiles": "타일"
        },
        "letterLeft": "L",
        "letterRight": "R",
        "events": {
            "headerTriggerEvent": "전환:",
            "itemNewEvent": "<새 이벤트>",
            "layers": {
                "headerShow": "표시:",
                "headerMove": "이동:",
                "headerHide": "숨김:",
                "headerToggle": "전환:"
            },
            "label": {
                "activate": "활성화",
                "death": "죽음",
                "destroy": "파괴",
                "enter": "진입",
                "hit": "영향",
                "layerClear": "레이어 지움",
                "next": "다음",
                "talk": "대화"
            },
            "deletion": {
                "confirm": "예: 이벤트 삭제",
                "deletingEvent": "이벤트 {0} 삭제 중",
                "cancel": "아니요: 이벤트를을 삭제하지 않음"
            },
            "desc": {
                "activate": "NPC가 화면에 들어옴",
                "death": "NPC 죽음",
                "destroy": "블록이 파괴됨",
                "enter": "워프가 입력됨",
                "hit": "블록이 맞음",
                "layerClear": "개체 레이어의 모든 항목이 사라짐",
                "phraseTriggersAfterTemplate": "{0}은 이벤트 {2} 발생 후 {1}초 후에 전환",
                "phraseTriggersWhenTemplate": "{0}는 {1}일 때 전환",
                "talk": "플레이어가 NPC와 대화"
            },
            "header": "이벤트:",
            "bounds": {
                "changeAllSectionBoundsToCurrent": "모든 섹션 경계를 현재 설정으로 변경할까요?",
                "changeSectionBoundsToCurrent": "{0} 섹션 경계를 현재 설정으로 변경할까요?",
                "shouldEvent": "이벤트가 {0}이어야 함"
            },
            "controlsForEventN": "이벤트 {0}에 대한 컨트롤",
            "letter": {
                "activate": "A:",
                "death": "D:",
                "destroy": "D:",
                "enter": "E:",
                "hit": "H:",
                "layerClear": "L:",
                "talk": "T:"
            },
            "props": {
                "layerSmoke": "연기",
                "sound": "사운드",
                "autostart": "자동시작",
                "controls": "컨트롤",
                "endGame": "게임 클리어"
            },
            "sections": {
                "actionKeep": "유지",
                "actionReset": "재설정",
                "actionSet": "설정",
                "phraseAllSections": "모든 섹션",
                "propBackground": "배경",
                "propBounds": "경계",
                "propMusic": "음악"
            },
            "settingsForEvent": "이벤트 {0}에 대한 설정",
            "promptEventName": "이벤트 이름",
            "promptEventText": "이벤트 텍스트"
        },
        "browser": {
            "saveFile": "저장 파일",
            "itemNewFolder": "<새 폴더>",
            "newFile": "새 파일",
            "openFile": "파일 열기",
            "askOverwriteFile": "{0}을(를) 덮어쓸까요?",
            "itemNewFile": "<새 파일>"
        },
        "letterUp": "U"
    },
    "menu": {
        "game": {
            "gameNoBattleLevels": "<전투 레벨 없음>",
            "gameSourceSlot": "소스 슬롯 선택",
            "gameEraseSave": "저장 지우기",
            "gameTargetSlot": "이제 대상을 선택",
            "gameSlotContinue": "슬롯 {0} ... {1}%",
            "gameSlotNew": "슬롯 {0} ... 새로운 게임",
            "phraseScore": "점수: {0}",
            "gameNoEpisodesToPlay": "<재생할 에피소드 없음>",
            "phraseTime": "시간: {0}",
            "gameEraseSlot": "삭제할 슬롯 선택",
            "gameBattleRandom": "랜덤 레벨",
            "gameCopySave": "저장 복사",
            "warnEpCompat": ""
        },
        "wordHide": "숨김",
        "options": {
            "restartEngine": "변경 사항을 적용하려면 엔진을 다시 시작하세요.",
            "advanced": {
                "render": {
                    "opengl11-tip": "",
                    "sw": "",
                    "opengles11-tip": "",
                    "opengl-tip": "",
                    "sdl": "",
                    "_name": "렌더 모드",
                    "opengl": "",
                    "hw": "자동",
                    "sdl-tip": "",
                    "opengl11": "",
                    "opengles": "",
                    "opengles11": "",
                    "opengles-tip": ""
                },
                "scale-down-textures": {
                    "_name": "",
                    "all": "",
                    "safe": "",
                    "all-tip": "",
                    "none-tip": "",
                    "none": "",
                    "safe-tip": "",
                    "_tooltip": ""
                },
                "advanced-audio": "",
                "webm-recording": "",
                "_header": "",
                "_tooltip": "",
                "audio-channels": {
                    "mono": "",
                    "stereo": "",
                    "_name": ""
                },
                "audio-format": {
                    "_name": "",
                    "_tooltip": ""
                },
                "audio-enable": "",
                "audio-sample-rate": {
                    "11025": "",
                    "48000": "",
                    "_name": "",
                    "32000": "",
                    "16000": "",
                    "22050": "",
                    "44100": ""
                },
                "log-level": {
                    "debug": "",
                    "_name": "",
                    "fatal": "",
                    "critical": "",
                    "info": "",
                    "warning": "",
                    "none": ""
                },
                "audio-buffer-size": {
                    "_tooltip": "",
                    "_name": ""
                },
                "record-gameplay-data": "",
                "internal-res-4p": {
                    "fhd": "",
                    "qsmbx": "",
                    "qhd": "",
                    "default": "",
                    "_name": ""
                },
                "choose-assets-on-launch": "",
                "advanced-video": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "main": {
                "unlimited-framerate": "",
                "timing": "",
                "four-screen-mode": {
                    "_name": "",
                    "split": "",
                    "shared": ""
                },
                "multiplayer": "",
                "language": "언어",
                "vsync": "",
                "two-screen-mode": {
                    "shared": "",
                    "split": "",
                    "smbx": "",
                    "topbottom": "",
                    "_name": ""
                },
                "background-work-tip": "",
                "background-work": "",
                "_header": "",
                "discord-rpc": "",
                "frame-skip": ""
            },
            "video": {
                "battery-status": {
                    "low": "",
                    "_name": "",
                    "off": "",
                    "on": "",
                    "fullscreen": "전체화면",
                    "fullscreen-tip": "",
                    "low-tip": ""
                },
                "enable-inter-level-fade-effect": "",
                "show-episode-title": {
                    "_name": "",
                    "bottom-tip": "",
                    "top": "",
                    "off": "",
                    "bottom": "",
                    "top-tip": ""
                },
                "internal-res": {
                    "gba": "",
                    "vga": "",
                    "_name": "",
                    "3ds": "",
                    "_tooltip": "",
                    "nds": "",
                    "dynamic": "",
                    "smbx": "",
                    "hello": "",
                    "hd": "",
                    "snes": "",
                    "smbx-wide": ""
                },
                "scale-mode": {
                    "integer": "정수",
                    "center": "",
                    "_name": "스케일",
                    "nearest": "가장 가까운",
                    "1x": "",
                    "0_5x": "",
                    "full": "",
                    "linear": "이중선형",
                    "2x": "",
                    "3x": ""
                },
                "_header": "",
                "display-controllers": "",
                "info-run": "",
                "info-meta": "",
                "effects": "",
                "fullscreen": "전체화면",
                "show-fails-counter": "",
                "3d-compat-mode-tip": "",
                "show-fails-counter-tip": "",
                "3d-compat-mode": "",
                "show-fps": "",
                "show-playtime-counter": {
                    "animated-tip": "",
                    "_name": "",
                    "_tooltip": "",
                    "off": "",
                    "animated": "",
                    "off-tip": "",
                    "transparent": "",
                    "opaque": ""
                },
                "show-medals-counter-tip": "",
                "show-medals-counter": "",
                "video-system": "",
                "show-screen-shake": "",
                "world-map-stars-show": "",
                "world-map-stars-show-tip": "",
                "info-game": ""
            },
            "controls": {
                "_header": ""
            },
            "episode-options": {
                "_header": "",
                "creator-compat": {
                    "_name": "",
                    "file-only": "",
                    "enable": "",
                    "disable": "",
                    "_tooltip": ""
                },
                "playstyle": {
                    "modern-tip": "",
                    "modern": "",
                    "classic": "",
                    "classic-tip": "",
                    "vanilla": "",
                    "vanilla-tip": "",
                    "_name": ""
                },
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "speedrun": {
                "mode": {
                    "_name": "",
                    "3": "",
                    "2": "",
                    "1": "",
                    "0": ""
                }
            },
            "audio": {
                "_header": "",
                "audio-sfx-volume": "",
                "audio-prefs": "",
                "sfx-pet-beat": "",
                "sfx-spatial-audio": "",
                "sfx-pet-beat-tip": "",
                "audio-music-volume": "",
                "sfx-modern": "",
                "sfx-modern-tip": "",
                "sfx-spatial-audio-tip": "",
                "sfx-audio-fx": ""
            },
            "compatibility": {
                "_header": "",
                "features": "",
                "bugfixes": "",
                "_tooltip": "",
                "autocode": "",
                "reset-all": ""
            },
            "view-credits": {
                "_header": "크레딧 보기"
            }
        },
        "wordWaiting": "대기 중",
        "main": {
            "mainEditor": "편집기",
            "main1PlayerGame": "1 인용 게임",
            "mainMultiplayerGame": "2 인용 게임",
            "mainBattleGame": "전투 게임",
            "mainOptions": "옵션",
            "mainExit": "종료",
            "mainPlayEpisode": "에피소드 재생"
        },
        "controls": {
            "editor": {
                "scrollUp": "위로 스크롤",
                "prevSection": "이전 섹션",
                "scrollRight": "오른쪽으로 스크롤",
                "scrollLeft": "왼쪽으로 스크롤",
                "scrollDown": "스크롤 다운",
                "fastScroll": "빠른 스크롤",
                "modeErase": "지우기 모드",
                "modeSelect": "선택 모드",
                "nextSection": "다음 선택",
                "switchScreens": "창 표시",
                "testPlay": "재생 테스트"
            },
            "buttons": {
                "jump": "점프",
                "altRun": "대체 실행",
                "down": "아래",
                "drop": "아이템 삭제",
                "altJump": "대체 점프",
                "right": "오른쪽",
                "up": "위쪽",
                "left": "왼쪽",
                "run": "실행",
                "start": "시작"
            },
            "controlsConnected": "연결됨:",
            "controlsDeviceTypes": "장치 유형",
            "controlsInUse": "(사용)",
            "controlsNewProfile": "<새 프로파일>",
            "cursor": {
                "up": "마우스 위쪽",
                "right": "마우스 오른쪽",
                "tertiary": "3차",
                "secondary": "2차",
                "down": "마우스 아래쪽",
                "left": "마우스 왼쪽",
                "primary": "1차"
            },
            "controlsDeleteKey": "(대체 점프로 삭제)",
            "controlsDeleteKey2": "(대체 실행로 삭제)",
            "caseInvalid": "(유효하지 않음)",
            "caseMouse": "(마우스)",
            "caseTouch": "(터치)",
            "controlsNotInUse": "(사용하지 않음)",
            "controlsReallyDeleteProfile": "프로파일을 삭제하겠습니까?",
            "controlsTitle": "컨트롤",
            "hotkeys": {
                "fullscreen": "전체화면",
                "debugInfo": "디버그 정보",
                "enterCheats": "코드 입력",
                "legacyPause": "이전 일시 중지",
                "recordGif": "GIF 녹화",
                "screenshot": "스크린샷",
                "toggleHUD": "상태 표시줄 토글",
                "vanillaCam": ""
            },
            "tDS": {
                "buttonA": "A",
                "buttonB": "B",
                "buttonY": "Y",
                "buttonZL": "ZL",
                "cStick": "C-스틱",
                "casePen": "(펜)",
                "dPad": "십자패드",
                "tStick": "썸네일",
                "buttonStart": "시작",
                "buttonX": "X",
                "buttonL": "L",
                "buttonR": "R",
                "buttonSelect": "선택",
                "buttonZR": "ZR"
            },
            "phraseNewProfOldJoy": "이전 조이스틱의 새 프로파일",
            "profile": {
                "playerControls": "플레이어 컨트롤",
                "renameProfile": "프로파일 이름바꾸기",
                "editorControls": "편집기 컨트롤",
                "cursorControls": "커서 컨트롤",
                "hotkeys": "단축키",
                "deleteProfile": "프로파일 삭제"
            },
            "touchscreen": {
                "layout": {
                    "longOld": "와이드 (이전)",
                    "phabletOld": "패블릿 (이전)",
                    "phoneOld": "폰 (이전)",
                    "standard": "보통",
                    "tabletOld": "태블릿 (이전)",
                    "tight": "빽빽이",
                    "tinyOld": "아주 작음 (이전)"
                },
                "option": {
                    "feedbackStrength": "피드백 강도",
                    "holdRun": "시작 시 실행 보류",
                    "interfaceStyle": "인터페이스 스타일",
                    "layoutStyle": "레이아웃 스타일",
                    "scaleDPad": "스케일 십자패드",
                    "scaleFactor": "스케일 팩터",
                    "showCodeButton": "코드 버튼 표시",
                    "scaleButtons": "스케일 버튼",
                    "feedbackLength": "피드백 길이",
                    "resetLayout": "레이아웃 재설정",
                    "sStartSpacing": "S-시작 간격"
                },
                "style": {
                    "actions": "동작",
                    "ABXY": "ABXY",
                    "XODA": "XODA"
                }
            },
            "types": {
                "touchscreen": "터치스크린",
                "gamepad": "게임패드",
                "keyboard": "키보드",
                "oldJoystick": "오래된 조이스틱"
            },
            "wii": {
                "classic": {
                    "buttonLT": "LT",
                    "buttonRT": "RT",
                    "buttonX": "X",
                    "buttonY": "Y",
                    "buttonZL": "ZL",
                    "buttonZR": "ZR",
                    "lStick": "L-패드",
                    "rStick": "R-패드"
                },
                "nunchuck": {
                    "buttonC": "C",
                    "buttonZ": "Z",
                    "prefixN": "N"
                },
                "wiimote": {
                    "buttonA": "A",
                    "button1": "1",
                    "button2": "2",
                    "buttonB": "B",
                    "buttonHome": "Home",
                    "buttonMinus": "-",
                    "buttonPlus": "+",
                    "caseIR": "(IR)",
                    "dPad": "십자패드",
                    "shake": "진동"
                },
                "phraseNewNunchuck": "새 눈챠크 프로파일",
                "phraseNewClassic": "새 클래식 프로파일",
                "typeClassic": "클래식",
                "typeNunchuck": "눈챠크",
                "typeWiimote": "위모트",
                "typeGamecube": ""
            },
            "options": {
                "textEntryStyle": "텍스트 입력 스타일",
                "maxPlayers": "최대 플레이어",
                "rumble": "진동",
                "batteryStatus": "배터리 상태"
            },
            "wordButtons": "버튼",
            "wordProfiles": "프로파일",
            "joystickSimpleEditor": ""
        },
        "wordPlayer": "플레이어",
        "wordBack": "뒤로가기",
        "wordOn": "켬",
        "wordProfile": "프로파일",
        "loading": "불러오기 중...",
        "wordShow": "표시",
        "wordNo": "아니오",
        "wordYes": "예",
        "wordResume": "다시 시작",
        "wordOff": "끔",
        "abbrevMilliseconds": "초",
        "battle": {
            "errorNoLevels": "레벨이 없어서 전투를 시작할 수 없음"
        },
        "caseNone": "<없음>",
        "character": {
            "selectCharacter": "{0} 게임"
        },
        "editor": {
            "battles": "<전투 레벨>",
            "errorMissingResources": "죄송합니다! 게임 내 편집기에 필요한 {0}이 누락되었습니다.",
            "newWorld": "<새로운 세계>",
            "promptNewWorldName": "새로운 세계 이름",
            "makeFor": ""
        }
    },
    "outro": {
        "originalBy": "원본 VB6 코드 게시자:",
        "cppPortDevelopers": "C++ 포트 개발자:",
        "nameAndrewSpinks": "앤드류 스핑크스",
        "customSprites": "커스텀 스프라이트:",
        "specialThanks": "특별히 감사한 분들:",
        "psVitaPortBy": "PS 비타 포트 게시자:",
        "engineCredits": "엔진 크레딧:",
        "levelDesign": "레벨 디자인:",
        "nameVitalyNovichkov": "비탈리 노비치코프",
        "gameCredits": "게임 크레딧:",
        "qualityControl": "품질 제어:"
    },
    "pluralRules": "singular-only",
    "languageName": "한국어",
    "game": {
        "connect": {
            "phraseTestProfile": "프로파일 테스트",
            "phraseDropMe": "게임에서 나가기",
            "phraseDropPX": "플레이어 {0} 삭제",
            "phraseForceResume": "강제 시작",
            "phraseHoldStart": "시작 보류",
            "phraseSetControls": "컨트롤 설정",
            "phraseStartToForceRes": "강제 시작시 Start 누름",
            "phraseStartToResume": "시작시 Start 누름",
            "phraseWaitingForInput": "입력 장치를 기다리는 중...",
            "reconnectTitle": "다시 연결",
            "dropAddTitle": "플레이어 삭제/추가",
            "phraseChangeChar": "캐릭터 변경",
            "phrasePressAButton": "A 버튼 누름",
            "phraseTestControls": "컨트롤 테스트",
            "splitPressSelect_1": "선택을 누름",
            "splitPressSelect_2": "컨트롤 옵션",
            "wordDisconnect": "연결 끊기"
        },
        "error": {
            "warpNeedStarCount": "입력하려면 {0} {1}이(가) 필요합니다.",
            "errorInvalidEnterWarp": "잘못된 입구 워프 {1}이(가) 지정되었기 때문에 레벨을 시작할 수 없습니다.\n총 워프 항목: {2}\n\n파일: {0}",
            "openFileFailed": "\"{0}\"을(를) 열 수 없습니다. 파일이 존재하지 않거나 손상되었습니다.",
            "errorNoStartPoint": "사용 가능한 시작점이 배치되지 않았거나 입구 워프가 지정되어 있지 않아 레벨을 시작할 수 없습니다.\n\n파일: {0}",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "pause": {
            "continue": "계속하기",
            "quit": "종료",
            "quitTesting": "종료 테스트",
            "enterCode": "코드 입력",
            "saveAndQuit": "저장하고 종료",
            "resetCheckpoints": "체크포인트 재설정",
            "restartLevel": "레벨 재시작",
            "returnToEditor": "편집기로 돌아가기",
            "saveAndContinue": "저장하고 계속하기",
            "playerSetup": "플레이어 설정"
        },
        "msgbox": {
            "sysInfoError": "오류입니다!",
            "sysInfoTitle": "",
            "sysInfoWarning": ""
        },
        "message": {
            "scanningLevels": "레벨 스캔 중..."
        },
        "format": {
            "minutesSeconds": "{0}분{1}초"
        },
        "hint": {
            "no-lives-new": "실패하면 점수가 재설정됩니다.",
            "no-lives-old": "실패하면 게임이 끝납니다.",
            "rainbow-surf": "잡고, 달리고, 누르고, 놓아서 서핑하세요.",
            "char5-bombs": "모으려면 Run을 누르고, 던지려면 Alt Run을 누르세요.",
            "gray-bricks": "",
            "heavy-duck": "",
            "shoe-block": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    }
}


================================================
FILE: resources/languages/thextech_nb-no.json
================================================
{
    "menu": {
        "options": {
            "audio": {
                "sfx-pet-beat": "",
                "audio-prefs": "",
                "sfx-pet-beat-tip": "",
                "_header": "",
                "audio-music-volume": "",
                "sfx-modern-tip": "",
                "audio-sfx-volume": "",
                "sfx-audio-fx": "",
                "sfx-modern": "",
                "sfx-spatial-audio-tip": "",
                "sfx-spatial-audio": ""
            },
            "video": {
                "battery-status": {
                    "fullscreen-tip": "",
                    "fullscreen": "",
                    "on": "",
                    "off": "",
                    "_name": "",
                    "low": "",
                    "low-tip": ""
                },
                "3d-compat-mode-tip": "",
                "enable-inter-level-fade-effect": "",
                "show-medals-counter-tip": "",
                "scale-mode": {
                    "full": "",
                    "center": "",
                    "1x": "",
                    "2x": "",
                    "integer": "",
                    "0_5x": "",
                    "_name": "",
                    "nearest": "",
                    "linear": "",
                    "3x": ""
                },
                "show-playtime-counter": {
                    "off-tip": "",
                    "_name": "",
                    "off": "",
                    "animated": "",
                    "animated-tip": "",
                    "transparent": "",
                    "opaque": "",
                    "_tooltip": ""
                },
                "_header": "",
                "info-game": "",
                "fullscreen": "",
                "info-meta": "",
                "internal-res": {
                    "dynamic": "",
                    "3ds": "",
                    "_name": "",
                    "hd": "",
                    "smbx": "",
                    "nds": "",
                    "smbx-wide": "",
                    "hello": "",
                    "vga": "",
                    "snes": "",
                    "gba": "",
                    "_tooltip": ""
                },
                "show-fails-counter": "",
                "show-fails-counter-tip": "",
                "world-map-stars-show": "",
                "show-screen-shake": "",
                "show-fps": "",
                "world-map-stars-show-tip": "",
                "show-medals-counter": "",
                "info-run": "",
                "display-controllers": "",
                "effects": "",
                "show-episode-title": {
                    "_name": "",
                    "bottom": "",
                    "bottom-tip": "",
                    "off": "",
                    "top-tip": "",
                    "top": ""
                },
                "video-system": "",
                "3d-compat-mode": ""
            },
            "advanced": {
                "advanced-audio": "",
                "webm-recording": "",
                "render": {
                    "opengles11": "",
                    "sdl": "",
                    "opengles11-tip": "",
                    "sw": "",
                    "hw": "",
                    "_name": "",
                    "opengl": "",
                    "opengl11": "",
                    "opengl-tip": "",
                    "sdl-tip": "",
                    "opengl11-tip": "",
                    "opengles": "",
                    "opengles-tip": ""
                },
                "log-level": {
                    "none": "",
                    "info": "",
                    "critical": "",
                    "fatal": "",
                    "debug": "",
                    "_name": "",
                    "warning": ""
                },
                "_header": "",
                "audio-format": {
                    "_tooltip": "",
                    "_name": ""
                },
                "audio-sample-rate": {
                    "16000": "",
                    "11025": "",
                    "_name": "",
                    "48000": "",
                    "44100": "",
                    "22050": "",
                    "32000": ""
                },
                "choose-assets-on-launch": "",
                "advanced-video": "",
                "_tooltip": "",
                "audio-buffer-size": {
                    "_tooltip": "",
                    "_name": ""
                },
                "scale-down-textures": {
                    "_name": "",
                    "_tooltip": "",
                    "all": "",
                    "all-tip": "",
                    "none-tip": "",
                    "safe": "",
                    "safe-tip": "",
                    "none": ""
                },
                "record-gameplay-data": "",
                "internal-res-4p": {
                    "default": "",
                    "fhd": "",
                    "_name": "",
                    "qsmbx": "",
                    "qhd": ""
                },
                "audio-channels": {
                    "mono": "",
                    "_name": "",
                    "stereo": ""
                },
                "audio-enable": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "main": {
                "two-screen-mode": {
                    "smbx": "",
                    "_name": "",
                    "shared": "",
                    "topbottom": "",
                    "split": ""
                },
                "frame-skip": "",
                "_header": "",
                "four-screen-mode": {
                    "shared": "",
                    "_name": "",
                    "split": ""
                },
                "timing": "",
                "unlimited-framerate": "",
                "background-work-tip": "",
                "background-work": "",
                "language": "",
                "multiplayer": "",
                "discord-rpc": "",
                "vsync": ""
            },
            "episode-options": {
                "playstyle": {
                    "modern-tip": "",
                    "vanilla": "",
                    "vanilla-tip": "",
                    "modern": "",
                    "_name": "",
                    "classic-tip": "",
                    "classic": ""
                },
                "creator-compat": {
                    "file-only": "",
                    "_name": "",
                    "disable": "",
                    "_tooltip": "",
                    "enable": ""
                },
                "_header": "",
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "speedrun": {
                "mode": {
                    "0": "",
                    "2": "",
                    "1": "",
                    "3": "",
                    "_name": ""
                }
            },
            "restartEngine": "",
            "view-credits": {
                "_header": ""
            },
            "controls": {
                "_header": ""
            },
            "compatibility": {
                "autocode": "",
                "_tooltip": "",
                "bugfixes": "",
                "_header": "",
                "features": "",
                "reset-all": ""
            }
        },
        "game": {
            "gameSlotNew": "",
            "gameEraseSlot": "",
            "gameNoEpisodesToPlay": "",
            "gameSlotContinue": "",
            "phraseScore": "",
            "gameCopySave": "",
            "phraseTime": "",
            "gameEraseSave": "",
            "gameTargetSlot": "",
            "gameBattleRandom": "",
            "gameNoBattleLevels": "",
            "gameSourceSlot": "",
            "warnEpCompat": ""
        },
        "loading": "",
        "wordPlayer": "",
        "controls": {
            "editor": {
                "scrollLeft": "",
                "scrollDown": "",
                "scrollRight": "",
                "nextSection": "",
                "testPlay": "",
                "fastScroll": "",
                "modeErase": "",
                "prevSection": "",
                "switchScreens": "",
                "modeSelect": "",
                "scrollUp": ""
            },
            "tDS": {
                "casePen": "",
                "buttonStart": "",
                "tStick": "",
                "dPad": "",
                "buttonA": "",
                "buttonY": "",
                "buttonB": "",
                "buttonR": "",
                "buttonSelect": "",
                "buttonL": "",
                "buttonZR": "",
                "buttonX": "",
                "buttonZL": "",
                "cStick": ""
            },
            "touchscreen": {
                "option": {
                    "feedbackStrength": "",
                    "scaleButtons": "",
                    "showCodeButton": "",
                    "feedbackLength": "",
                    "holdRun": "",
                    "interfaceStyle": "",
                    "scaleFactor": "",
                    "sStartSpacing": "",
                    "resetLayout": "",
                    "scaleDPad": "",
                    "layoutStyle": ""
                },
                "style": {
                    "actions": "",
                    "XODA": "",
                    "ABXY": ""
                },
                "layout": {
                    "tight": "",
                    "phabletOld": "",
                    "longOld": "",
                    "phoneOld": "",
                    "tinyOld": "",
                    "tabletOld": "",
                    "standard": ""
                }
            },
            "types": {
                "keyboard": "",
                "gamepad": "",
                "oldJoystick": "",
                "touchscreen": ""
            },
            "controlsNotInUse": "",
            "wii": {
                "classic": {
                    "buttonY": "",
                    "buttonZL": "",
                    "lStick": "",
                    "rStick": "",
                    "buttonX": "",
                    "buttonZR": "",
                    "buttonLT": "",
                    "buttonRT": ""
                },
                "phraseNewClassic": "",
                "wiimote": {
                    "buttonA": "",
                    "button2": "",
                    "button1": "",
                    "dPad": "",
                    "buttonB": "",
                    "buttonHome": "",
                    "buttonMinus": "",
                    "buttonPlus": "",
                    "shake": "",
                    "caseIR": ""
                },
                "typeNunchuck": "",
                "nunchuck": {
                    "buttonC": "",
                    "buttonZ": "",
                    "prefixN": ""
                },
                "phraseNewNunchuck": "",
                "typeClassic": "",
                "typeWiimote": "",
                "typeGamecube": ""
            },
            "wordProfiles": "",
            "buttons": {
                "jump": "",
                "altJump": "",
                "right": "",
                "altRun": "",
                "drop": "",
                "up": "",
                "down": "",
                "left": "",
                "run": "",
                "start": ""
            },
            "cursor": {
                "down": "",
                "tertiary": "",
                "left": "",
                "right": "",
                "up": "",
                "secondary": "",
                "primary": ""
            },
            "profile": {
                "cursorControls": "",
                "deleteProfile": "",
                "renameProfile": "",
                "playerControls": "",
                "editorControls": "",
                "hotkeys": ""
            },
            "hotkeys": {
                "legacyPause": "",
                "recordGif": "",
                "toggleHUD": "",
                "screenshot": "",
                "vanillaCam": "",
                "fullscreen": "",
                "enterCheats": "",
                "debugInfo": ""
            },
            "joystickSimpleEditor": "",
            "controlsDeviceTypes": "",
            "controlsConnected": "",
            "controlsDeleteKey": "",
            "options": {
                "batteryStatus": "",
                "textEntryStyle": "",
                "maxPlayers": "",
                "rumble": ""
            },
            "phraseNewProfOldJoy": "",
            "wordButtons": "",
            "controlsInUse": "",
            "caseInvalid": "",
            "caseMouse": "",
            "caseTouch": "",
            "controlsNewProfile": "",
            "controlsReallyDeleteProfile": "",
            "controlsTitle": ""
        },
        "main": {
            "mainExit": "",
            "mainBattleGame": "",
            "main1PlayerGame": "",
            "mainMultiplayerGame": "",
            "mainOptions": "",
            "mainEditor": "",
            "mainPlayEpisode": ""
        },
        "wordResume": "",
        "editor": {
            "makeFor": "",
            "errorMissingResources": "",
            "newWorld": "",
            "battles": "",
            "promptNewWorldName": ""
        },
        "battle": {
            "errorNoLevels": ""
        },
        "wordProfile": "",
        "wordOff": "",
        "wordNo": "",
        "wordHide": "",
        "wordWaiting": "",
        "wordShow": "",
        "wordOn": "",
        "wordYes": "",
        "character": {
            "selectCharacter": ""
        },
        "caseNone": "",
        "abbrevMilliseconds": "",
        "wordBack": ""
    },
    "outro": {
        "qualityControl": "",
        "nameVitalyNovichkov": "",
        "levelDesign": "",
        "originalBy": "",
        "cppPortDevelopers": "",
        "engineCredits": "",
        "specialThanks": "",
        "nameAndrewSpinks": "",
        "psVitaPortBy": "",
        "gameCredits": "",
        "customSprites": ""
    },
    "editor": {
        "file": {
            "convert": {
                "descNew": ""
            },
            "optionCancelConversion": "",
            "actionRevert": "",
            "commandNew": "",
            "optionCancelAction": "",
            "optionYesSaveThenAction": "",
            "sectionLevel": "",
            "confirmConfirmAction": "",
            "formatLegacy": "",
            "labelCurrentFile": "",
            "labelFormat": "",
            "formatModern": "",
            "optionProceedWithConversion": "",
            "sectionWorld": "",
            "optionActionWithoutSave": "",
            "actionExit": "",
            "actionClearWorld": "",
            "confirmSaveBeforeAction": "",
            "actionClearLevel": "",
            "confirmConvertFormatTo": "",
            "commandSave": "",
            "commandOpen": "",
            "commandSaveAs": "",
            "actionOpen": ""
        },
        "phraseAreYouSure": "",
        "npc": {
            "ai": {
                "target": "",
                "LR": "",
                "swim": "",
                "use1_0Ai": "",
                "jump": "",
                "aiIs": "",
                "headerCustomAi": "",
                "leap": "",
                "UD": ""
            },
            "inertNice": "",
            "gen": {
                "header": "",
                "effectWarp": "",
                "effectIs": "",
                "effectShoot": "",
                "direction": ""
            },
            "inContainer": "",
            "props": {
                "attachSurface": "",
                "active": "",
                "facing": ""
            },
            "stuckStop": "",
            "tooltipExpandSection": "",
            "abbrevGen": ""
        },
        "pageBlankOfBlank": "",
        "section": {
            "noTurnBack": "",
            "horizWrap": "",
            "setBounds": "",
            "vertWrap": "",
            "underwater": "",
            "scroll": "",
            "offscreenExit": ""
        },
        "phraseWarpIndex": "",
        "toggleMagicBlock": "",
        "tooltip": {
            "area": "",
            "file": "",
            "erase": "",
            "blocks": "",
            "eraseAll": "",
            "scenes": "",
            "events": "",
            "paths": "",
            "select": "",
            "settings": "",
            "warps": "",
            "water": "",
            "music": "",
            "levels": "",
            "layers": "",
            "show": "",
            "tiles": "",
            "BGOs": "",
            "NPCs": ""
        },
        "warp": {
            "allow": "",
            "transit": {
                "name1": "",
                "name5": "",
                "name3": "",
                "name2": "",
                "name4": "",
                "name0": ""
            },
            "dir": "",
            "cannonExit": "",
            "effect": "",
            "lvlWarp": "",
            "showStarCount": "",
            "speed": "",
            "starLockMessage": "",
            "style": {
                "pipe": "",
                "door": "",
                "blipInstant": "",
                "portal": "",
                "style": ""
            },
            "target": "",
            "toMap": "",
            "twoWay": "",
            "to": "",
            "title": "",
            "needStarCount": "",
            "needFloor": "",
            "out": "",
            "needKey": "",
            "showStartScene": "",
            "item": "",
            "ride": "",
            "placing": "",
            "in": ""
        },
        "world": {
            "totalStars": "",
            "name": "",
            "retryOnFail": "",
            "phraseCreditIndex": "",
            "hubWorld": "",
            "introLevel": "",
            "allowChars": ""
        },
        "select": {
            "pathBlankUnlock": "",
            "allSectPropBlankForEventN": "",
            "sectionBlankPropBlank": "",
            "soundForEventN": "",
            "warpTransitEffect": "",
            "sectBlankPropBlankForEventN": "",
            "worldMusic": ""
        },
        "water": {
            "title": ""
        },
        "wordCoins": "",
        "wordEvent": {
            "genitive": "",
            "nominative": "",
            "typeLabel": ""
        },
        "wordEnabled": "",
        "wordNPC": {
            "genitive": "",
            "nominative": ""
        },
        "events": {
            "controlsForEventN": "",
            "deletion": {
                "deletingEvent": "",
                "cancel": "",
                "confirm": ""
            },
            "header": "",
            "label": {
                "activate": "",
                "destroy": "",
                "enter": "",
                "talk": "",
                "next": "",
                "hit": "",
                "layerClear": "",
                "death": ""
            },
            "layers": {
                "headerMove": "",
                "headerHide": "",
                "headerToggle": "",
                "headerShow": ""
            },
            "sections": {
                "actionKeep": "",
                "actionReset": "",
                "propMusic": "",
                "actionSet": "",
                "phraseAllSections": "",
                "propBackground": "",
                "propBounds": ""
            },
            "settingsForEvent": "",
            "desc": {
                "phraseTriggersAfterTemplate": "",
                "enter": "",
                "talk": "",
                "layerClear": "",
                "activate": "",
                "hit": "",
                "death": "",
                "destroy": "",
                "phraseTriggersWhenTemplate": ""
            },
            "letter": {
                "activate": "",
                "hit": "",
                "death": "",
                "destroy": "",
                "enter": "",
                "layerClear": "",
                "talk": ""
            },
            "props": {
                "autostart": "",
                "controls": "",
                "endGame": "",
                "sound": "",
                "layerSmoke": ""
            },
            "promptEventText": "",
            "bounds": {
                "shouldEvent": "",
                "changeSectionBoundsToCurrent": "",
                "changeAllSectionBoundsToCurrent": ""
            },
            "headerTriggerEvent": "",
            "itemNewEvent": "",
            "promptEventName": ""
        },
        "block": {
            "canBreak": "",
            "inside": "",
            "pickContents": "",
            "canBreakTooltip": "",
            "letterWidth": "",
            "slick": "",
            "letterHeight": "",
            "invis": ""
        },
        "browser": {
            "openFile": "",
            "saveFile": "",
            "askOverwriteFile": "",
            "newFile": "",
            "itemNewFile": "",
            "itemNewFolder": ""
        },
        "layers": {
            "deletion": {
                "preserveLayerContents": "",
                "cancel": "",
                "confirmPreserve": "",
                "header": "",
                "confirmDelete": ""
            },
            "default": "",
            "label": "",
            "itemNewLayer": "",
            "header": "",
            "desc": {
                "att": ""
            },
            "labelAttached": "",
            "promptLayerName": "",
            "labelMoveLayer": "",
            "labelAttachedLayer": "",
            "abbrevAttLayer": ""
        },
        "letterCoordY": "",
        "phraseDelayIsMs": "",
        "phraseTextOf": "",
        "testPlay": {
            "pet": "",
            "boot": "",
            "char": "",
            "power": "",
            "magicHand": ""
        },
        "wordHeight": "",
        "level": {
            "levelName": "",
            "pathUnlocks": "",
            "startPos": "",
            "alwaysVis": "",
            "bigBG": "",
            "pathBG": "",
            "gameStart": ""
        },
        "labelSortLayer": "",
        "letterDown": "",
        "letterCoordX": "",
        "letterUp": "",
        "letterRight": "",
        "letterLeft": "",
        "mapPos": "",
        "phraseGenericIndex": "",
        "phraseSectionIndex": "",
        "phraseRadiusIndex": "",
        "phraseCountMore": "",
        "wordInstant": "",
        "wordMode": "",
        "wordText": "",
        "wordWidth": "",
        "labelSortOffset": ""
    },
    "game": {
        "connect": {
            "splitPressSelect_1": "",
            "reconnectTitle": "",
            "dropAddTitle": "",
            "wordDisconnect": "",
            "phraseDropPX": "",
            "phraseForceResume": "",
            "phraseStartToResume": "",
            "phraseTestControls": "",
            "phraseTestProfile": "",
            "phraseDropMe": "",
            "splitPressSelect_2": "",
            "phraseWaitingForInput": "",
            "phraseStartToForceRes": "",
            "phraseSetControls": "",
            "phrasePressAButton": "",
            "phraseChangeChar": "",
            "phraseHoldStart": ""
        },
        "error": {
            "warpNeedStarCount": "",
            "openFileFailed": "",
            "errorNoStartPoint": "",
            "errorInvalidEnterWarp": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "hint": {
            "no-lives-new": "",
            "no-lives-old": "",
            "char5-bombs": "",
            "gray-bricks": "",
            "rainbow-surf": "",
            "heavy-duck": "",
            "shoe-block": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "pause": {
            "quitTesting": "",
            "continue": "",
            "resetCheckpoints": "",
            "quit": "",
            "restartLevel": "",
            "saveAndContinue": "",
            "enterCode": "",
            "saveAndQuit": "",
            "returnToEditor": "",
            "playerSetup": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "msgbox": {
            "sysInfoTitle": "",
            "sysInfoWarning": "",
            "sysInfoError": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "pluralRules": "",
    "languageName": ""
}


================================================
FILE: resources/languages/thextech_pl.json
================================================
{
    "menu": {
        "options": {
            "advanced": {
                "advanced-video": "",
                "choose-assets-on-launch": "",
                "log-level": {
                    "fatal": "",
                    "critical": "",
                    "warning": "",
                    "info": "",
                    "_name": "",
                    "debug": "",
                    "none": ""
                },
                "render": {
                    "_name": "",
                    "hw": "",
                    "opengl11-tip": "",
                    "opengl-tip": "",
                    "opengl11": "",
                    "sdl-tip": "",
                    "sdl": "",
                    "opengles": "",
                    "opengles11": "",
                    "opengles-tip": "",
                    "opengl": "",
                    "sw": "",
                    "opengles11-tip": ""
                },
                "audio-sample-rate": {
                    "22050": "",
                    "16000": "",
                    "11025": "",
                    "48000": "",
                    "_name": "",
                    "32000": "",
                    "44100": ""
                },
                "audio-channels": {
                    "mono": "",
                    "_name": "",
                    "stereo": ""
                },
                "scale-down-textures": {
                    "_tooltip": "",
                    "_name": "",
                    "safe": "",
                    "none-tip": "",
                    "none": "",
                    "safe-tip": "",
                    "all-tip": "",
                    "all": ""
                },
                "record-gameplay-data": "",
                "webm-recording": "",
                "internal-res-4p": {
                    "qhd": "",
                    "qsmbx": "",
                    "default": "",
                    "_name": "",
                    "fhd": ""
                },
                "_header": "",
                "audio-buffer-size": {
                    "_name": "",
                    "_tooltip": ""
                },
                "audio-format": {
                    "_tooltip": "",
                    "_name": ""
                },
                "advanced-audio": "",
                "_tooltip": "",
                "audio-enable": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "episode-options": {
                "creator-compat": {
                    "disable": "",
                    "file-only": "",
                    "enable": "",
                    "_name": "",
                    "_tooltip": ""
                },
                "playstyle": {
                    "modern-tip": "",
                    "vanilla": "",
                    "_name": "",
                    "classic-tip": "",
                    "classic": "",
                    "vanilla-tip": "",
                    "modern": ""
                },
                "_header": "",
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "speedrun": {
                "mode": {
                    "1": "",
                    "0": "",
                    "_name": "",
                    "3": "",
                    "2": ""
                }
            },
            "video": {
                "world-map-stars-show-tip": "",
                "show-playtime-counter": {
                    "off-tip": "",
                    "_tooltip": "",
                    "_name": "",
                    "animated-tip": "",
                    "off": "",
                    "animated": "",
                    "opaque": "",
                    "transparent": ""
                },
                "show-episode-title": {
                    "top": "",
                    "bottom": "",
                    "_name": "",
                    "bottom-tip": "",
                    "off": "",
                    "top-tip": ""
                },
                "show-medals-counter": "",
                "effects": "",
                "info-meta": "",
                "internal-res": {
                    "3ds": "",
                    "_tooltip": "",
                    "_name": "",
                    "smbx": "",
                    "hello": "",
                    "hd": "",
                    "nds": "",
                    "smbx-wide": "",
                    "vga": "",
                    "snes": "",
                    "gba": "",
                    "dynamic": ""
                },
                "info-run": "",
                "fullscreen": "",
                "enable-inter-level-fade-effect": "",
                "scale-mode": {
                    "_name": "",
                    "integer": "",
                    "2x": "",
                    "full": "",
                    "center": "",
                    "1x": "",
                    "linear": "",
                    "nearest": "",
                    "0_5x": "",
                    "3x": ""
                },
                "display-controllers": "",
                "info-game": "",
                "show-medals-counter-tip": "",
                "battery-status": {
                    "fullscreen-tip": "",
                    "_name": "",
                    "fullscreen": "",
                    "low-tip": "",
                    "on": "",
                    "off": "",
                    "low": ""
                },
                "_header": "",
                "3d-compat-mode": "",
                "show-fails-counter": "",
                "show-fails-counter-tip": "",
                "3d-compat-mode-tip": "",
                "show-fps": "",
                "show-screen-shake": "",
                "video-system": "",
                "world-map-stars-show": ""
            },
            "restartEngine": "",
            "compatibility": {
                "features": "",
                "bugfixes": "",
                "reset-all": "",
                "autocode": "",
                "_tooltip": "",
                "_header": ""
            },
            "main": {
                "two-screen-mode": {
                    "topbottom": "",
                    "smbx": "",
                    "shared": "",
                    "split": "",
                    "_name": ""
                },
                "_header": "",
                "background-work-tip": "",
                "four-screen-mode": {
                    "_name": "",
                    "split": "",
                    "shared": ""
                },
                "unlimited-framerate": "",
                "background-work": "",
                "frame-skip": "",
                "discord-rpc": "",
                "multiplayer": "",
                "timing": "",
                "language": "",
                "vsync": ""
            },
            "audio": {
                "_header": "",
                "audio-music-volume": "",
                "sfx-modern": "",
                "sfx-audio-fx": "",
                "audio-sfx-volume": "",
                "sfx-modern-tip": "",
                "sfx-pet-beat": "",
                "sfx-spatial-audio-tip": "",
                "sfx-pet-beat-tip": "",
                "sfx-spatial-audio": "",
                "audio-prefs": ""
            },
            "controls": {
                "_header": ""
            },
            "view-credits": {
                "_header": ""
            }
        },
        "controls": {
            "buttons": {
                "altJump": "",
                "down": "",
                "drop": "",
                "run": "",
                "altRun": "",
                "start": "",
                "up": "",
                "right": "",
                "left": "",
                "jump": ""
            },
            "hotkeys": {
                "enterCheats": "",
                "toggleHUD": "",
                "fullscreen": "",
                "debugInfo": "",
                "legacyPause": "",
                "screenshot": "",
                "recordGif": "",
                "vanillaCam": ""
            },
            "cursor": {
                "down": "",
                "primary": "",
                "up": "",
                "left": "",
                "tertiary": "",
                "secondary": "",
                "right": ""
            },
            "editor": {
                "testPlay": "",
                "scrollUp": "",
                "modeSelect": "",
                "prevSection": "",
                "nextSection": "",
                "modeErase": "",
                "switchScreens": "",
                "scrollRight": "",
                "fastScroll": "",
                "scrollLeft": "",
                "scrollDown": ""
            },
            "touchscreen": {
                "layout": {
                    "tight": "",
                    "tabletOld": "",
                    "phoneOld": "",
                    "phabletOld": "",
                    "standard": "",
                    "longOld": "",
                    "tinyOld": ""
                },
                "option": {
                    "sStartSpacing": "",
                    "layoutStyle": "",
                    "resetLayout": "",
                    "scaleDPad": "",
                    "interfaceStyle": "",
                    "holdRun": "",
                    "scaleFactor": "",
                    "showCodeButton": "",
                    "feedbackStrength": "",
                    "feedbackLength": "",
                    "scaleButtons": ""
                },
                "style": {
                    "XODA": "",
                    "ABXY": "",
                    "actions": ""
                }
            },
            "types": {
                "gamepad": "",
                "keyboard": "",
                "touchscreen": "",
                "oldJoystick": ""
            },
            "caseMouse": "",
            "options": {
                "batteryStatus": "",
                "textEntryStyle": "",
                "maxPlayers": "",
                "rumble": ""
            },
            "profile": {
                "cursorControls": "",
                "playerControls": "",
                "deleteProfile": "",
                "renameProfile": "",
                "hotkeys": "",
                "editorControls": ""
            },
            "tDS": {
                "buttonX": "",
                "buttonB": "",
                "buttonL": "",
                "buttonR": "",
                "buttonStart": "",
                "dPad": "",
                "buttonA": "",
                "buttonSelect": "",
                "buttonY": "",
                "tStick": "",
                "buttonZL": "",
                "casePen": "",
                "buttonZR": "",
                "cStick": ""
            },
            "wii": {
                "wiimote": {
                    "shake": "",
                    "buttonA": "",
                    "button1": "",
                    "buttonMinus": "",
                    "buttonPlus": "",
                    "button2": "",
                    "buttonB": "",
                    "caseIR": "",
                    "dPad": "",
                    "buttonHome": ""
                },
                "nunchuck": {
                    "buttonC": "",
                    "buttonZ": "",
                    "prefixN": ""
                },
                "phraseNewClassic": "",
                "typeWiimote": "",
                "typeNunchuck": "",
                "typeClassic": "",
                "classic": {
                    "buttonLT": "",
                    "buttonRT": "",
                    "buttonY": "",
                    "buttonZR": "",
                    "buttonZL": "",
                    "lStick": "",
                    "buttonX": "",
                    "rStick": ""
                },
                "phraseNewNunchuck": "",
                "typeGamecube": ""
            },
            "controlsNewProfile": "",
            "phraseNewProfOldJoy": "",
            "joystickSimpleEditor": "",
            "wordProfiles": "",
            "controlsDeviceTypes": "",
            "controlsInUse": "",
            "controlsNotInUse": "",
            "caseTouch": "",
            "caseInvalid": "",
            "controlsReallyDeleteProfile": "",
            "controlsConnected": "",
            "controlsDeleteKey": "",
            "controlsTitle": "",
            "wordButtons": ""
        },
        "game": {
            "gameTargetSlot": "",
            "gameNoBattleLevels": "",
            "gameEraseSave": "",
            "gameCopySave": "",
            "gameEraseSlot": "",
            "gameNoEpisodesToPlay": "",
            "phraseTime": "",
            "phraseScore": "",
            "gameSlotNew": "",
            "gameSlotContinue": "",
            "gameSourceSlot": "",
            "gameBattleRandom": "",
            "warnEpCompat": ""
        },
        "wordProfile": "",
        "abbrevMilliseconds": "",
        "wordNo": "",
        "wordWaiting": "",
        "battle": {
            "errorNoLevels": ""
        },
        "caseNone": "",
        "character": {
            "selectCharacter": ""
        },
        "main": {
            "mainExit": "",
            "mainEditor": "",
            "mainMultiplayerGame": "",
            "mainBattleGame": "",
            "mainOptions": "",
            "mainPlayEpisode": "",
            "main1PlayerGame": ""
        },
        "wordYes": "",
        "editor": {
            "errorMissingResources": "",
            "makeFor": "",
            "battles": "",
            "newWorld": "",
            "promptNewWorldName": ""
        },
        "wordOff": "",
        "wordPlayer": "",
        "wordBack": "",
        "wordOn": "",
        "wordShow": "",
        "wordResume": "",
        "loading": "",
        "wordHide": ""
    },
    "editor": {
        "file": {
            "convert": {
                "descNew": ""
            },
            "actionRevert": "",
            "confirmSaveBeforeAction": "",
            "labelCurrentFile": "",
            "formatModern": "",
            "sectionLevel": "",
            "sectionWorld": "",
            "labelFormat": "",
            "optionYesSaveThenAction": "",
            "optionCancelConversion": "",
            "optionProceedWithConversion": "",
            "actionClearLevel": "",
            "actionExit": "",
            "actionOpen": "",
            "confirmConvertFormatTo": "",
            "commandOpen": "",
            "commandSave": "",
            "optionCancelAction": "",
            "commandSaveAs": "",
            "actionClearWorld": "",
            "optionActionWithoutSave": "",
            "formatLegacy": "",
            "confirmConfirmAction": "",
            "commandNew": ""
        },
        "layers": {
            "deletion": {
                "confirmDelete": "",
                "preserveLayerContents": "",
                "header": "",
                "confirmPreserve": "",
                "cancel": ""
            },
            "labelMoveLayer": "",
            "promptLayerName": "",
            "abbrevAttLayer": "",
            "default": "",
            "labelAttached": "",
            "itemNewLayer": "",
            "label": "",
            "header": "",
            "labelAttachedLayer": "",
            "desc": {
                "att": ""
            }
        },
        "letterCoordX": "",
        "level": {
            "startPos": "",
            "gameStart": "",
            "bigBG": "",
            "pathBG": "",
            "levelName": "",
            "alwaysVis": "",
            "pathUnlocks": ""
        },
        "npc": {
            "abbrevGen": "",
            "ai": {
                "LR": "",
                "swim": "",
                "target": "",
                "jump": "",
                "UD": "",
                "use1_0Ai": "",
                "leap": "",
                "headerCustomAi": "",
                "aiIs": ""
            },
            "inertNice": "",
            "gen": {
                "direction": "",
                "effectIs": "",
                "effectShoot": "",
                "effectWarp": "",
                "header": ""
            },
            "stuckStop": "",
            "props": {
                "facing": "",
                "attachSurface": "",
                "active": ""
            },
            "tooltipExpandSection": "",
            "inContainer": ""
        },
        "select": {
            "warpTransitEffect": "",
            "worldMusic": "",
            "sectBlankPropBlankForEventN": "",
            "allSectPropBlankForEventN": "",
            "sectionBlankPropBlank": "",
            "soundForEventN": "",
            "pathBlankUnlock": ""
        },
        "testPlay": {
            "power": "",
            "boot": "",
            "char": "",
            "pet": "",
            "magicHand": ""
        },
        "tooltip": {
            "erase": "",
            "BGOs": "",
            "NPCs": "",
            "blocks": "",
            "file": "",
            "settings": "",
            "layers": "",
            "select": "",
            "music": "",
            "eraseAll": "",
            "events": "",
            "levels": "",
            "scenes": "",
            "paths": "",
            "show": "",
            "warps": "",
            "water": "",
            "tiles": "",
            "area": ""
        },
        "warp": {
            "allow": "",
            "toMap": "",
            "transit": {
                "name0": "",
                "name4": "",
                "name5": "",
                "name1": "",
                "name3": "",
                "name2": ""
            },
            "speed": "",
            "cannonExit": "",
            "dir": "",
            "twoWay": "",
            "title": "",
            "effect": "",
            "item": "",
            "out": "",
            "in": "",
            "placing": "",
            "lvlWarp": "",
            "showStarCount": "",
            "showStartScene": "",
            "ride": "",
            "starLockMessage": "",
            "style": {
                "blipInstant": "",
                "style": "",
                "door": "",
                "pipe": "",
                "portal": ""
            },
            "to": "",
            "needFloor": "",
            "needStarCount": "",
            "target": "",
            "needKey": ""
        },
        "wordText": "",
        "wordWidth": "",
        "events": {
            "deletion": {
                "deletingEvent": "",
                "cancel": "",
                "confirm": ""
            },
            "desc": {
                "enter": "",
                "death": "",
                "hit": "",
                "destroy": "",
                "phraseTriggersAfterTemplate": "",
                "layerClear": "",
                "talk": "",
                "phraseTriggersWhenTemplate": "",
                "activate": ""
            },
            "label": {
                "hit": "",
                "talk": "",
                "next": "",
                "enter": "",
                "layerClear": "",
                "destroy": "",
                "death": "",
                "activate": ""
            },
            "letter": {
                "activate": "",
                "death": "",
                "destroy": "",
                "talk": "",
                "enter": "",
                "layerClear": "",
                "hit": ""
            },
            "promptEventText": "",
            "sections": {
                "actionKeep": "",
                "propMusic": "",
                "actionSet": "",
                "actionReset": "",
                "propBackground": "",
                "phraseAllSections": "",
                "propBounds": ""
            },
            "props": {
                "sound": "",
                "controls": "",
                "endGame": "",
                "layerSmoke": "",
                "autostart": ""
            },
            "bounds": {
                "shouldEvent": "",
                "changeSectionBoundsToCurrent": "",
                "changeAllSectionBoundsToCurrent": ""
            },
            "header": "",
            "headerTriggerEvent": "",
            "layers": {
                "headerShow": "",
                "headerToggle": "",
                "headerMove": "",
                "headerHide": ""
            },
            "promptEventName": "",
            "controlsForEventN": "",
            "itemNewEvent": "",
            "settingsForEvent": ""
        },
        "letterLeft": "",
        "letterDown": "",
        "mapPos": "",
        "phraseGenericIndex": "",
        "world": {
            "retryOnFail": "",
            "totalStars": "",
            "introLevel": "",
            "allowChars": "",
            "hubWorld": "",
            "phraseCreditIndex": "",
            "name": ""
        },
        "section": {
            "vertWrap": "",
            "scroll": "",
            "offscreenExit": "",
            "noTurnBack": "",
            "horizWrap": "",
            "setBounds": "",
            "underwater": ""
        },
        "toggleMagicBlock": "",
        "wordCoins": "",
        "wordEnabled": "",
        "wordNPC": {
            "genitive": "",
            "nominative": ""
        },
        "wordEvent": {
            "genitive": "",
            "nominative": "",
            "typeLabel": ""
        },
        "labelSortLayer": "",
        "labelSortOffset": "",
        "letterUp": "",
        "letterRight": "",
        "letterCoordY": "",
        "pageBlankOfBlank": "",
        "phraseCountMore": "",
        "phraseRadiusIndex": "",
        "phraseAreYouSure": "",
        "phraseSectionIndex": "",
        "phraseTextOf": "",
        "phraseWarpIndex": "",
        "wordInstant": "",
        "wordHeight": "",
        "wordMode": "",
        "block": {
            "letterWidth": "",
            "slick": "",
            "pickContents": "",
            "canBreak": "",
            "canBreakTooltip": "",
            "inside": "",
            "letterHeight": "",
            "invis": ""
        },
        "browser": {
            "itemNewFolder": "",
            "newFile": "",
            "openFile": "",
            "saveFile": "",
            "itemNewFile": "",
            "askOverwriteFile": ""
        },
        "water": {
            "title": ""
        },
        "phraseDelayIsMs": ""
    },
    "game": {
        "format": {
            "minutesSeconds": ""
        },
        "pause": {
            "returnToEditor": "",
            "continue": "",
            "enterCode": "",
            "restartLevel": "",
            "quit": "",
            "resetCheckpoints": "",
            "saveAndContinue": "",
            "playerSetup": "",
            "quitTesting": "",
            "saveAndQuit": ""
        },
        "connect": {
            "phraseChangeChar": "",
            "phraseHoldStart": "",
            "phraseWaitingForInput": "",
            "phraseStartToResume": "",
            "phraseSetControls": "",
            "phraseStartToForceRes": "",
            "reconnectTitle": "",
            "phrasePressAButton": "",
            "wordDisconnect": "",
            "splitPressSelect_1": "",
            "splitPressSelect_2": "",
            "dropAddTitle": "",
            "phraseDropMe": "",
            "phraseDropPX": "",
            "phraseForceResume": "",
            "phraseTestProfile": "",
            "phraseTestControls": ""
        },
        "error": {
            "warpNeedStarCount": "",
            "errorInvalidEnterWarp": "",
            "openFileFailed": "",
            "errorNoStartPoint": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "hint": {
            "no-lives-new": "",
            "no-lives-old": "",
            "char5-bombs": "",
            "gray-bricks": "",
            "shoe-block": "",
            "rainbow-surf": "",
            "heavy-duck": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "msgbox": {
            "sysInfoWarning": "",
            "sysInfoTitle": "",
            "sysInfoError": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "outro": {
        "qualityControl": "",
        "specialThanks": "",
        "levelDesign": "",
        "nameVitalyNovichkov": "",
        "customSprites": "",
        "nameAndrewSpinks": "",
        "originalBy": "",
        "engineCredits": "",
        "gameCredits": "",
        "cppPortDevelopers": "",
        "psVitaPortBy": ""
    },
    "pluralRules": "",
    "languageName": ""
}


================================================
FILE: resources/languages/thextech_pt-br.json
================================================
{
    "editor": {
        "file": {
            "convert": {
                "descNew": "A extensão será alterada, mas o arquivo NÃO será deletado.\n\nPor favor, confira os recursos que serão perdidos antes."
            },
            "formatLegacy": "Antigo (SMBX-64)",
            "formatModern": "Moderno (PGE-X)",
            "labelCurrentFile": "Arquivo atual: \\",
            "labelFormat": "Formato:",
            "optionActionWithoutSave": "{0} sem guardar",
            "optionCancelAction": "Cancelar: não {0}",
            "optionCancelConversion": "Cancelar conversão",
            "optionProceedWithConversion": "Confirmar conversão",
            "optionYesSaveThenAction": "SIM: Guardar, depois {0}",
            "sectionLevel": "Nível",
            "actionOpen": "Abrir",
            "confirmConfirmAction": "Certeza que quer {0}?",
            "confirmConvertFormatTo": "Converter para {0}?",
            "confirmSaveBeforeAction": "Guardar antes de {0}?",
            "sectionWorld": "Mundo",
            "actionClearLevel": "Limpar Nível",
            "actionClearWorld": "Limpar Mundo",
            "actionExit": "Sair",
            "commandNew": "Novo",
            "commandOpen": "Abrir...",
            "commandSave": "Guardar",
            "commandSaveAs": "Guardar como...",
            "actionRevert": "Redefinir"
        },
        "labelSortLayer": "Organizar Camadas:",
        "layers": {
            "abbrevAttLayer": "Anexa: ",
            "default": "Padrão",
            "deletion": {
                "cancel": "Cancelar: Não apagar camada",
                "confirmDelete": "NÃO: *APAGA TODO O CONTEÚDO*",
                "preserveLayerContents": "Preservar o conteúdo da camada?",
                "confirmPreserve": "SIM: Mover para a camada padrão",
                "header": "Apagando camada {0}"
            },
            "header": "Camadas:",
            "itemNewLayer": "<Nova Camada>",
            "label": "Camada:",
            "labelAttached": "Anexado:",
            "labelAttachedLayer": "Camada Anexada:",
            "labelMoveLayer": "Mover Camada:",
            "promptLayerName": "Nome da camada",
            "desc": {
                "att": "Quando o NPC se mover, a camada anexada o seguira"
            }
        },
        "letterCoordY": "Y",
        "letterDown": "B",
        "letterLeft": "E",
        "letterUp": "C",
        "level": {
            "alwaysVis": "Sempre Vis",
            "bigBG": "Cam.Grande",
            "gameStart": "Iniciar Jogo",
            "levelName": "Nome do Nível",
            "pathBG": "Caminho",
            "pathUnlocks": "Caminhos Desbloq.",
            "startPos": "Pos. Inicial"
        },
        "mapPos": "Pos. Mapa:",
        "npc": {
            "inertNice": "Amig",
            "props": {
                "active": "Ativo",
                "attachSurface": "Anexa",
                "facing": "Olhando"
            },
            "inContainer": "-",
            "stuckStop": "Fica",
            "ai": {
                "LR": "Esq-Dir",
                "UD": "Cim-Bai",
                "aiIs": "IA: {0}",
                "headerCustomAi": "IA Person.:",
                "leap": "Saltar",
                "swim": "Nadar",
                "target": "Perseguir",
                "jump": "Pular",
                "use1_0Ai": "Usar IA 1.0?"
            },
            "gen": {
                "effectWarp": "Telep",
                "effectIs": "Efeito: {0}",
                "effectShoot": "Atirar",
                "header": "Config. de Gerador",
                "direction": "Direção"
            },
            "abbrevGen": "Gera.",
            "tooltipExpandSection": "Expandir Seção"
        },
        "phraseAreYouSure": "Tem certeza?",
        "phraseCountMore": "Mais {0}",
        "phraseDelayIsMs": "Interv.: {0} ms",
        "phraseRadiusIndex": "Raio {0}",
        "phraseSectionIndex": "Seção {0}",
        "section": {
            "horizWrap": "Ligar Esq-Dir",
            "noTurnBack": "Sem Volta",
            "offscreenExit": "Sair Pela Borda",
            "scroll": "Deslizar",
            "setBounds": "Def. Bordas",
            "underwater": "Subaquático",
            "vertWrap": "TP. Vertical"
        },
        "select": {
            "pathBlankUnlock": "Caminho {0} Desbloqueia Por",
            "sectionBlankPropBlank": "Seção {0}{1}",
            "allSectPropBlankForEventN": "Todas Seções {0} para {1}",
            "sectBlankPropBlankForEventN": "Seção {0} {1} para {2}",
            "soundForEventN": "Som para Evento {0}",
            "warpTransitEffect": "Efeito de Transição do Teleporte",
            "worldMusic": "Música do Mundo"
        },
        "testPlay": {
            "boot": "Bota",
            "char": "Pers",
            "magicHand": "Mão Mágica",
            "pet": "Mont.",
            "power": "Poder"
        },
        "tooltip": {
            "area": "Área",
            "erase": "Apagar",
            "NPCs": "NPCs",
            "music": "Música",
            "scenes": "Cenário",
            "BGOs": "Obj. de Fundo",
            "eraseAll": "Apagar Tudo",
            "blocks": "Blocos",
            "file": "Arquivo",
            "layers": "Camadas",
            "levels": "Níveis",
            "paths": "Caminhos",
            "select": "Selecionar",
            "show": "Mostrar",
            "settings": "Configurações",
            "tiles": "Peças",
            "warps": "Teleportes",
            "water": "Água",
            "events": "Eventos"
        },
        "warp": {
            "effect": "Efeito:",
            "in": "Ent.",
            "out": "Saí.",
            "placing": "Colocando:",
            "ride": "Montar",
            "speed": "Velocidade ",
            "style": {
                "blipInstant": "Inst.",
                "door": "Porta",
                "portal": "Port",
                "style": "Estilo: ",
                "pipe": "Cano"
            },
            "to": "A: {0}",
            "toMap": "Para Mapa",
            "transit": {
                "name1": "DESLIZAR",
                "name4": "VIRAR (H)",
                "name0": "NENHUM",
                "name2": "TRANSIÇÃO",
                "name3": "CÍRCULO",
                "name5": "VIRAR (V)"
            },
            "twoWay": "Ida-Volta",
            "cannonExit": "Saí. Canhão",
            "allow": "Permitir:",
            "dir": "Dire.",
            "item": "Item",
            "needStarCount": "Precisa de {0} {1}",
            "lvlWarp": "Tele.Nív.",
            "needFloor": "Precisa de Chão",
            "needKey": "Precisa de Chave",
            "showStarCount": "Mostrar Estrelas",
            "showStartScene": "Mostrar Cena Inicial",
            "starLockMessage": "Mens. de Bloq. de Estrela",
            "target": "Abre: ",
            "title": "Config. de Teleporte"
        },
        "water": {
            "title": "Config. de Água"
        },
        "wordEvent": {
            "typeLabel": "Evento {0}:",
            "nominative": "Evento",
            "genitive": "Evento"
        },
        "wordInstant": "Instantâneo",
        "wordNPC": {
            "nominative": "NPC",
            "genitive": "NPC"
        },
        "wordText": "Texto",
        "wordWidth": "Largura",
        "world": {
            "hubWorld": "Mundo Central",
            "introLevel": "Nível Inicial",
            "name": "Nome do Mundo",
            "allowChars": "Jogáveis",
            "phraseCreditIndex": "Linha {0} - Créditos do Mundo:",
            "totalStars": "Núm.Estrelas:",
            "retryOnFail": "AutoRessurgir"
        },
        "block": {
            "canBreak": "Quebrável",
            "pickContents": "Escolha o conteúdo do bloco",
            "canBreakTooltip": "Antigo \"Quebrar ao bater\"",
            "inside": "Contém:",
            "letterHeight": "A-",
            "letterWidth": "L-",
            "slick": "Escorr.",
            "invis": "Inv."
        },
        "events": {
            "desc": {
                "hit": "bater no bloco",
                "layerClear": "tudo na camada de objetos estiver limpa",
                "phraseTriggersAfterTemplate": "{0} ativa {1} ms depois do evento {2}",
                "phraseTriggersWhenTemplate": "{0} ativa quando {1}",
                "talk": "o jogador fala com o NPC",
                "death": "o NPC morre",
                "destroy": "o bloco é destruído",
                "enter": "entrar no teleporte",
                "activate": "o NPC entrar na tela"
            },
            "deletion": {
                "cancel": "NÃO: Não apagar o evento",
                "confirm": "SIM: Apagar o evento",
                "deletingEvent": "Apagando o evento {0}"
            },
            "header": "Evento:",
            "headerTriggerEvent": "Ativação:",
            "itemNewEvent": "<Novo Evento>",
            "label": {
                "activate": "Ativar",
                "death": "Morte",
                "layerClear": "Camada Limpa",
                "destroy": "Destruir",
                "enter": "Entrar",
                "hit": "Bater",
                "next": "Próximo",
                "talk": "Falar"
            },
            "layers": {
                "headerMove": "Mover:",
                "headerHide": "Esconder:",
                "headerShow": "Mostrar:",
                "headerToggle": "Alternar:"
            },
            "letter": {
                "enter": "E:",
                "layerClear": "L:",
                "activate": "A:",
                "death": "M:",
                "destroy": "D:",
                "hit": "B:",
                "talk": "F:"
            },
            "props": {
                "sound": "Som",
                "autostart": "Ao iniciar",
                "controls": "Control.",
                "endGame": "Fin.Jogo",
                "layerSmoke": "Fumaça"
            },
            "sections": {
                "actionKeep": "Manter",
                "actionReset": "Rein.",
                "actionSet": "Def.",
                "phraseAllSections": "Todas as Seções",
                "propBackground": "Fundo",
                "propBounds": "Bordas",
                "propMusic": "Música"
            },
            "promptEventName": "Nome do evento",
            "promptEventText": "Texto do evento",
            "bounds": {
                "changeAllSectionBoundsToCurrent": "Mudar todos os limites de borda da seção atual?",
                "changeSectionBoundsToCurrent": "Mudar os limites de borda da seção {0} aos valores atuais?",
                "shouldEvent": "Editar Evento {0}"
            },
            "controlsForEventN": "Controles para o evento {0}",
            "settingsForEvent": "Config. do evento {0}"
        },
        "browser": {
            "itemNewFile": "<Novo Arquivo>",
            "askOverwriteFile": "Sobrescrever {0}?",
            "itemNewFolder": "<Nova Pasta>",
            "openFile": "Abrir arquivo",
            "newFile": "Criar arquivo",
            "saveFile": "Guardar arquivo"
        },
        "labelSortOffset": "Organizar Deslocamento (Offset):",
        "letterCoordX": "X",
        "letterRight": "D",
        "pageBlankOfBlank": "Pagina {0} de {1}",
        "phraseGenericIndex": "Número {0}",
        "phraseTextOf": "Texto - {0}",
        "phraseWarpIndex": "Teleporte {0}",
        "toggleMagicBlock": "Bloco Mágico",
        "wordEnabled": "Ativado",
        "wordCoins": "Moedas",
        "wordHeight": "Altura",
        "wordMode": "Modo"
    },
    "game": {
        "connect": {
            "phraseHoldStart": "Pressione Start",
            "splitPressSelect_2": "Opções de Controle",
            "dropAddTitle": "Ger. Jogadores",
            "phraseChangeChar": "Mudar Personagem",
            "phraseDropMe": "Retirar",
            "phraseDropPX": "Tirar J{0}",
            "phraseForceResume": "Forçar Continuação",
            "phrasePressAButton": "Pressione A",
            "phraseSetControls": "Definir Controles",
            "phraseStartToForceRes": "Pressione Start para Forçar Continuar",
            "phraseStartToResume": "Pressione Start para Continuar",
            "phraseTestControls": "Testar Controles",
            "phraseTestProfile": "Testar Perfil",
            "phraseWaitingForInput": "Esperando por Controles...",
            "reconnectTitle": "Reconectar",
            "splitPressSelect_1": "Pressione Select para",
            "wordDisconnect": "Desconectar"
        },
        "error": {
            "errorInvalidEnterWarp": "Não foi possível iniciar o nível devido a um teleporte de entrada invalido em {1}.\nTotal de entradas no teleporte: {2}\n\nArquivo: {0}",
            "errorNoStartPoint": "Não foi possível iniciar o nível por este nível não conter ponto de inicio ou entradas de teleporte especificadas.\n\nArquivo: {0}",
            "openFileFailed": "\"{0}\" não foi aberto: Arquivo inexistente ou corrompido.",
            "warpNeedStarCount": "Você precisa de\n{0} {1} para entrar.",
            "errorTooOldGameAssets": "O conteúdo requer um pacote de recursos de fase mais recente ({0}) do que o pacote de recursos atual ({1}). Atualize seu pacote de recursos do jogo.",
            "IPCTimeOut": "Sem Resposta do editor conectado o jogo será fechado",
            "errorTooOldEngine": "O conteúdo requer um nível de recurso de mecanismo mais recente ({0}) do que a versão atual ({1}). Atualize o TheXTech.",
            "openIPCDataFailed": ""
        },
        "message": {
            "scanningLevels": "Buscando níveis..."
        },
        "pause": {
            "playerSetup": "Configurar Jogadores",
            "enterCode": "Comandos",
            "returnToEditor": "Retornar ao Editor",
            "saveAndContinue": "Guardar e Continuar",
            "saveAndQuit": "Guardar e Sair",
            "quit": "Sair",
            "quitTesting": "Sair do Teste",
            "resetCheckpoints": "Reiniciar Ponto de Ressurgimento",
            "continue": "Continuar",
            "restartLevel": "Reiniciar Nível"
        },
        "format": {
            "minutesSeconds": "{0}m{1}s"
        },
        "hint": {
            "no-lives-old": "Cuidado - Fim de Jogo iminente!",
            "no-lives-new": "Sem moedas? Empréstimo! Olhe para sua pontuação...",
            "char5-bombs": "Pressione Correr para segurar e Correr ALT para jogar.",
            "gray-bricks": "Alguns blocos são vulneráveis a habilidades.",
            "rainbow-surf": "Pegue, corra, abaixe, e então surfe.",
            "shoe-block": "Vestindo isso ficará imune a - quase todos - fogos!",
            "heavy-duck": "Abaixe para se proteger de - nem todos - fogos!",
            "pound-altrun": "Use Correr ALT para Ground Pound!",
            "pound-down": "Use Baixo para Ground Pound!"
        },
        "msgbox": {
            "sysInfoError": "Erro!",
            "sysInfoTitle": "Informação",
            "sysInfoWarning": "Aviso!"
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "menu": {
        "controls": {
            "touchscreen": {
                "style": {
                    "XODA": "𐄂○□△",
                    "ABXY": "ABXY",
                    "actions": "Ações"
                },
                "layout": {
                    "tinyOld": "Pequeno (Antigo)",
                    "longOld": "Longo (Antigo)",
                    "phabletOld": "Phablet (Antigo)",
                    "phoneOld": "Telefone (Antigo)",
                    "tabletOld": "Tablet (Antigo)",
                    "tight": "Apertado",
                    "standard": "Def. Padrão"
                },
                "option": {
                    "feedbackLength": "Duração da Vibração",
                    "feedbackStrength": "Força da Vibração",
                    "holdRun": "Segurar \"Correr\" ao Iniciar",
                    "interfaceStyle": "Estilo da interface",
                    "layoutStyle": "Estilo do Layout",
                    "resetLayout": "Reiniciar Layout",
                    "scaleButtons": "Escala dos Botões",
                    "scaleDPad": "Escala do Direcional",
                    "scaleFactor": "Fator de Escala",
                    "showCodeButton": "Mostrar Botão de Comandos",
                    "sStartSpacing": "Espaçamento S-Start"
                }
            },
            "phraseNewProfOldJoy": "Novo Perfil para Joystick Antigo",
            "wii": {
                "typeNunchuck": "Nunchuck",
                "wiimote": {
                    "caseIR": "(Infravermelho)",
                    "shake": "Sacudir",
                    "button1": "1",
                    "button2": "2",
                    "buttonA": "A",
                    "buttonB": "B",
                    "buttonHome": "Bot. Home",
                    "dPad": "Direcionais",
                    "buttonMinus": "-",
                    "buttonPlus": "+"
                },
                "classic": {
                    "buttonLT": "LT",
                    "buttonRT": "RT",
                    "buttonX": "X",
                    "buttonY": "Y",
                    "buttonZL": "ZL",
                    "buttonZR": "ZR",
                    "lStick": "Direcional Esq",
                    "rStick": "Direcional Dir"
                },
                "nunchuck": {
                    "buttonC": "C",
                    "buttonZ": "Z",
                    "prefixN": "N"
                },
                "phraseNewClassic": "Novo Perfil - Classic",
                "phraseNewNunchuck": "Novo Perfil - Nunchuck",
                "typeClassic": "Classic",
                "typeWiimote": "Wiimote",
                "typeGamecube": ""
            },
            "hotkeys": {
                "enterCheats": "Comandos",
                "fullscreen": "Tela Cheia",
                "debugInfo": "Depurar",
                "legacyPause": "Pausa Alt",
                "recordGif": "Gravar GIF",
                "screenshot": "Capt. Tela",
                "toggleHUD": "Interface",
                "vanillaCam": "Câmera Vanilla"
            },
            "tDS": {
                "buttonA": "A",
                "buttonB": "B",
                "buttonR": "R",
                "buttonZL": "ZL",
                "buttonZR": "ZR",
                "casePen": "(Stylus)",
                "buttonL": "L",
                "buttonSelect": "Select",
                "buttonStart": "Start",
                "buttonX": "X",
                "buttonY": "Y",
                "cStick": "Analógico-C",
                "dPad": "Direcionais",
                "tStick": "Bot. do Analógico"
            },
            "cursor": {
                "down": "Mouse Baixo",
                "left": "Mouse Esq",
                "right": "Mouse Dir",
                "up": "Mouse Cima",
                "primary": "Primário",
                "secondary": "Secundário",
                "tertiary": "Terciário"
            },
            "buttons": {
                "altJump": "Pulo Alt",
                "altRun": "Correr Alt",
                "down": "Baixo",
                "drop": "Cham.Item",
                "jump": "Pular",
                "left": "Esquerda",
                "right": "Direita",
                "start": "Iniciar",
                "up": "Cima",
                "run": "Correr"
            },
            "caseInvalid": "(Invalido)",
            "caseMouse": "(Mouse)",
            "caseTouch": "(Toque)",
            "controlsConnected": "Conectado:",
            "controlsDeviceTypes": "Tipos de Dispositivos",
            "controlsInUse": "(Em Uso)",
            "controlsNewProfile": "<Novo Perfil>",
            "controlsNotInUse": "(Não Usado)",
            "controlsReallyDeleteProfile": "Apagar perfil?",
            "controlsTitle": "Controles",
            "editor": {
                "fastScroll": "Desl. Rápido",
                "switchScreens": "Painel",
                "nextSection": "Prox. Seção",
                "scrollLeft": "Desl. Esq",
                "scrollRight": "Desl. Dir",
                "scrollUp": "Desl. Acima",
                "testPlay": "Rodar Teste",
                "modeErase": "M Apagar",
                "modeSelect": "M Selec",
                "prevSection": "Seção Anter",
                "scrollDown": "Desl. Abaixo"
            },
            "options": {
                "batteryStatus": "Estado da Bateria",
                "maxPlayers": "Jogadores Máximos",
                "rumble": "Vibrar",
                "textEntryStyle": "Estilo de Entrada de Texto"
            },
            "profile": {
                "hotkeys": "Atalhos",
                "cursorControls": "Controles do cursor",
                "deleteProfile": "Apagar Perfil",
                "editorControls": "Controles do editor",
                "playerControls": "Controles do jogador",
                "renameProfile": "Renomear perfil"
            },
            "wordButtons": "Botões",
            "wordProfiles": "Perfis",
            "types": {
                "touchscreen": "Tela de Toque",
                "keyboard": "Teclado",
                "gamepad": "Controle",
                "oldJoystick": "Joystick Antigo"
            },
            "controlsDeleteKey": "(Pulo Alt para Apagar)",
            "controlsDeleteKey2": "(Correr Alt para Apagar)",
            "joystickSimpleEditor": ""
        },
        "game": {
            "gameBattleRandom": "Nível Aleatório",
            "gameCopySave": "Copiar Jogo",
            "gameEraseSave": "Apagar Jogo",
            "gameEraseSlot": "Selecione um Jogo para apagar",
            "gameSlotNew": "JOGO {0} ... NOVO JOGO",
            "gameNoBattleLevels": "<Sem níveis de batalha>",
            "gameNoEpisodesToPlay": "<Sem episódios para jogar>",
            "gameSourceSlot": "Selecione o Jogo de origem",
            "gameTargetSlot": "Agora, o Jogo de destino",
            "phraseScore": "Pontos: {0}",
            "phraseTime": "Tempo: {0}",
            "gameSlotContinue": "JOGO {0} ... {1}%",
            "warnEpCompat": "Este episódio foi feito para uma versão diferente de SMBX e pode não funcionar como esperado."
        },
        "main": {
            "mainPlayEpisode": "Jogar Episódio",
            "main1PlayerGame": "Um Jogador",
            "mainEditor": "Editor",
            "mainOptions": "Opções",
            "mainBattleGame": "Modo Batalha",
            "mainExit": "Sair",
            "mainMultiplayerGame": "Dois Jogadores"
        },
        "options": {
            "restartEngine": "Reinicie a Engine para aplicar as mudanças.",
            "advanced": {
                "audio-enable": "Ativar",
                "audio-format": {
                    "_tooltip": "Formato para driver de som",
                    "_name": "Formato de áudio"
                },
                "audio-sample-rate": {
                    "11025": "11025 Hz",
                    "_name": "Taxa de amostragem",
                    "22050": "22050 Hz",
                    "16000": "16000 Hz",
                    "32000": "32000 Hz",
                    "44100": "44100 Hz",
                    "48000": "48000 Hz"
                },
                "render": {
                    "opengl11": "OpenGL 1.1",
                    "hw": "Automático",
                    "opengl": "OpenGL 3+",
                    "opengles11-tip": "",
                    "_name": "Modo de renderização",
                    "opengl-tip": "",
                    "opengles-tip": "",
                    "opengles": "OpenGL ES 2+",
                    "opengl11-tip": "",
                    "sdl": "SDL2",
                    "sdl-tip": "",
                    "sw": "Software",
                    "opengles11": "OpenGL ES 1.1+"
                },
                "webm-recording": "",
                "internal-res-4p": {
                    "qhd": "2560x1440 (QHD)",
                    "fhd": "1920x1080 (FHD)",
                    "default": "Padrão",
                    "qsmbx": "1600x1200 (QSMBX)",
                    "_name": ""
                },
                "_tooltip": "Opções técnicas para operações internas",
                "_header": "Avançado",
                "advanced-video": "Vídeo",
                "advanced-audio": "Áudio",
                "audio-buffer-size": {
                    "_tooltip": "Aumente para menos engasgos a custo de desempenho",
                    "_name": "Buffer"
                },
                "audio-channels": {
                    "stereo": "Estéreo",
                    "mono": "Mono",
                    "_name": "Canais"
                },
                "log-level": {
                    "_name": "Nível de depuração (log)",
                    "debug": "Depuração",
                    "critical": "Crítico",
                    "fatal": "Fatal",
                    "info": "Informação",
                    "warning": "Aviso",
                    "none": "Nada"
                },
                "choose-assets-on-launch": "Escolher assets ao iniciar",
                "record-gameplay-data": "Gravar jogatina",
                "scale-down-textures": {
                    "_tooltip": "Armazena imagens como 1x para economizar memória",
                    "_name": "Reduzir escala das imagens",
                    "safe-tip": "Verifica se as imagens estão no formato 2x",
                    "safe": "Seguro",
                    "none-tip": "Menos travamentos",
                    "none": "Nenhum",
                    "all-tip": "Menos travamentos no carregamento do que 'Seguro'",
                    "all": "Todas"
                },
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "main": {
                "_header": "Principal",
                "background-work": "",
                "four-screen-mode": {
                    "_name": "",
                    "shared": "",
                    "split": ""
                },
                "discord-rpc": "Integração com Discord",
                "multiplayer": "",
                "frame-skip": "",
                "language": "Idioma",
                "vsync": "",
                "timing": "",
                "two-screen-mode": {
                    "split": "",
                    "smbx": "",
                    "topbottom": "",
                    "_name": "",
                    "shared": ""
                },
                "unlimited-framerate": "",
                "background-work-tip": ""
            },
            "video": {
                "internal-res": {
                    "smbx-wide": "",
                    "_name": "Tamanho da tela",
                    "hello": "768x432 (HELLO)",
                    "nds": "512x384 (NDS)",
                    "_tooltip": "",
                    "dynamic": "Dinâmico",
                    "hd": "1280x720 (HD)",
                    "gba": "480x320 (GBA)",
                    "smbx": "800x600 (SMBX)",
                    "snes": "512x448 (SNES)",
                    "vga": "640x480 (VGA)",
                    "3ds": "800x480 (3DS)"
                },
                "show-episode-title": {
                    "bottom": "",
                    "bottom-tip": "",
                    "off": "",
                    "_name": "",
                    "top": "",
                    "top-tip": ""
                },
                "scale-mode": {
                    "integer": "",
                    "1x": "1x",
                    "center": "",
                    "0_5x": "0,5x",
                    "nearest": "",
                    "full": "",
                    "linear": "",
                    "2x": "2x",
                    "_name": "",
                    "3x": ""
                },
                "show-fails-counter-tip": "",
                "enable-inter-level-fade-effect": "",
                "show-fails-counter": "",
                "battery-status": {
                    "off": "Desligado",
                    "on": "Sempre",
                    "low-tip": "",
                    "_name": "",
                    "fullscreen": "",
                    "fullscreen-tip": "",
                    "low": ""
                },
                "show-playtime-counter": {
                    "opaque": "",
                    "transparent": "",
                    "_name": "",
                    "animated": "",
                    "animated-tip": "",
                    "off": "",
                    "off-tip": "",
                    "_tooltip": ""
                },
                "effects": "",
                "display-controllers": "",
                "info-game": "",
                "info-run": "",
                "info-meta": "",
                "fullscreen": "",
                "show-fps": "",
                "video-system": "",
                "show-screen-shake": "",
                "world-map-stars-show": "",
                "_header": "Vídeo",
                "show-medals-counter-tip": "",
                "3d-compat-mode-tip": "",
                "world-map-stars-show-tip": "",
                "show-medals-counter": "",
                "3d-compat-mode": ""
            },
            "speedrun": {
                "mode": {
                    "0": "0",
                    "_name": "",
                    "2": "2",
                    "3": "3",
                    "1": "1"
                }
            },
            "audio": {
                "sfx-audio-fx": "Efeitos de eco",
                "sfx-spatial-audio": "Som espacial",
                "sfx-modern": "Efeitos modernos",
                "sfx-modern-tip": "",
                "sfx-pet-beat": "",
                "audio-sfx-volume": "Volume dos efeitos",
                "_header": "Áudio",
                "audio-prefs": "Referências",
                "audio-music-volume": "Volume da música",
                "sfx-spatial-audio-tip": "Reduz o volume de sons fora da tela",
                "sfx-pet-beat-tip": ""
            },
            "episode-options": {
                "creator-compat": {
                    "_name": "",
                    "file-only": "",
                    "enable": "",
                    "disable": "",
                    "_tooltip": ""
                },
                "_header": "",
                "playstyle": {
                    "modern": "",
                    "_name": "",
                    "classic-tip": "",
                    "classic": "",
                    "vanilla-tip": "",
                    "vanilla": "",
                    "modern-tip": ""
                },
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "compatibility": {
                "reset-all": "",
                "autocode": "",
                "bugfixes": "",
                "_tooltip": "",
                "_header": "",
                "features": ""
            },
            "controls": {
                "_header": "Controles"
            },
            "view-credits": {
                "_header": "Ver créditos"
            }
        },
        "editor": {
            "errorMissingResources": "Desculpe! {0} esta faltando, é necessário para o editor no jogo.",
            "battles": "<Níveis de Batalha>",
            "newWorld": "<Novo Mundo>",
            "promptNewWorldName": "Nome do novo mundo",
            "makeFor": "Fazer para:"
        },
        "wordBack": "Voltar",
        "wordWaiting": "Esperando",
        "loading": "Carregando...",
        "abbrevMilliseconds": "MS",
        "battle": {
            "errorNoLevels": "Não foi possível iniciar uma batalha por falta de níveis"
        },
        "caseNone": "<Nenhum>",
        "character": {
            "selectCharacter": "Jogo do {0}"
        },
        "wordHide": "Esconder",
        "wordNo": "Não",
        "wordOff": "Desl.",
        "wordOn": "Ligado",
        "wordPlayer": "Jogador",
        "wordProfile": "Perfil",
        "wordResume": "Continuar",
        "wordShow": "Mostrar",
        "wordYes": "Sim"
    },
    "languageName": "Português-BR",
    "outro": {
        "specialThanks": "Agradecimentos Especiais:",
        "cppPortDevelopers": "Desenvolvedores da versão C++:",
        "customSprites": "Sprite Personalizado:",
        "engineCredits": "Créditos da Engine:",
        "gameCredits": "Créditos do jogo:",
        "levelDesign": "Design de níveis:",
        "nameAndrewSpinks": "Andrew Spinks",
        "nameVitalyNovichkov": "Novichkov Vitaliy",
        "originalBy": "Código original VB6 Por:",
        "psVitaPortBy": "Port para PS Vita Por:",
        "qualityControl": "Controle de Qualidade:"
    },
    "pluralRules": "one-is-singular"
}


================================================
FILE: resources/languages/thextech_pt.json
================================================
{
    "editor": {
        "block": {
            "pickContents": "Escolha o conteúdo do bloco",
            "canBreak": "Quebrável",
            "canBreakTooltip": "Antigo \"Quebra ao bater\"",
            "inside": "Contém:",
            "invis": "Inv.",
            "letterHeight": "A",
            "letterWidth": "L",
            "slick": "Escorr."
        },
        "browser": {
            "askOverwriteFile": "Sobrescrever {0}?",
            "itemNewFile": "<Novo Ficheiro>",
            "itemNewFolder": "<Nova Pasta>",
            "newFile": "Criar ficheiro",
            "openFile": "Abrir ficheiro",
            "saveFile": "Guardar ficheiro"
        },
        "events": {
            "bounds": {
                "changeAllSectionBoundsToCurrent": "Mudar todos os limites de borda da secção atual?",
                "changeSectionBoundsToCurrent": "Mudar os limites de borda da secção {0} aos valores atuais?",
                "shouldEvent": "Editar Evento {0}"
            },
            "controlsForEventN": "Controles para o evento {0}",
            "deletion": {
                "cancel": "NÃO: Não apagar o evento",
                "confirm": "SIM: Apagar o evento",
                "deletingEvent": "A apagar o evento {0}"
            },
            "desc": {
                "activate": "o NPC entrar no ecrã",
                "enter": "entrar no teleporte",
                "death": "o NPC morre",
                "destroy": "o bloco é destruído",
                "hit": "bater no bloco",
                "layerClear": "tudo na camada de objetos estiver limpa",
                "phraseTriggersAfterTemplate": "{0} ativa {1} ms depois do evento {2}",
                "phraseTriggersWhenTemplate": "{0} ativa quando {1}",
                "talk": "o jogador fala com o NPC"
            },
            "header": "Evento:",
            "headerTriggerEvent": "Ativação:",
            "itemNewEvent": "<Novo Evento>",
            "label": {
                "activate": "Ativar",
                "death": "Morte",
                "destroy": "Destruir",
                "enter": "Entrar",
                "hit": "Bater",
                "layerClear": "Camada Limpa",
                "next": "Próximo",
                "talk": "Falar"
            },
            "layers": {
                "headerHide": "Esconder:",
                "headerMove": "Mover:",
                "headerShow": "Mostrar:",
                "headerToggle": "Alternar:"
            },
            "letter": {
                "activate": "A:",
                "death": "M:",
                "destroy": "D:",
                "enter": "E:",
                "hit": "B:",
                "layerClear": "L:",
                "talk": "F:"
            },
            "promptEventName": "Nome do evento",
            "promptEventText": "Texto do evento",
            "props": {
                "autostart": "Ao iniciar",
                "controls": "Control.",
                "endGame": "Fin.Jogo",
                "layerSmoke": "Fumo",
                "sound": "Som"
            },
            "sections": {
                "actionKeep": "Manter",
                "actionReset": "Rein.",
                "actionSet": "Def.",
                "phraseAllSections": "Todas as Secções",
                "propBackground": "Fundo",
                "propBounds": "Bordas",
                "propMusic": "Música"
            },
            "settingsForEvent": "Config. do evento {0}"
        },
        "file": {
            "actionClearLevel": "Limpar Nível",
            "actionClearWorld": "Limpar Mundo",
            "actionExit": "Sair",
            "actionOpen": "Abrir",
            "actionRevert": "Redefinir",
            "commandNew": "Novo",
            "commandOpen": "Abrir...",
            "commandSave": "Guardar",
            "commandSaveAs": "Guardar como...",
            "confirmConfirmAction": "Certeza que quer {0}?",
            "confirmConvertFormatTo": "Converter para {0}?",
            "confirmSaveBeforeAction": "Guardar antes de {0}?",
            "formatLegacy": "Antigo (SMBX-64)",
            "convert": {
                "descNew": "A extensão será alterada, mas o ficheiro NÃO será deletado.\n\nPor favor, confira os recursos que serão perdidos antes."
            },
            "formatModern": "Moderno (PGE-X)",
            "labelCurrentFile": "Ficheiro atual: \\",
            "labelFormat": "Formato:",
            "optionActionWithoutSave": "{0} sem guardar",
            "optionCancelAction": "Cancelar: não {0}",
            "optionCancelConversion": "Cancelar conversão",
            "optionProceedWithConversion": "Confirmar conversão",
            "optionYesSaveThenAction": "SIM: Guardar, depois {0}",
            "sectionLevel": "Nível",
            "sectionWorld": "Mundo"
        },
        "labelSortLayer": "Organizar Camadas:",
        "labelSortOffset": "Organizar Deslocamento (Offset):",
        "layers": {
            "abbrevAttLayer": "Anexa: ",
            "default": "Padrão",
            "deletion": {
                "cancel": "Cancelar: Não apagar camada",
                "confirmDelete": "NÃO: *APAGA TODO O CONTEÚDO*",
                "confirmPreserve": "SIM: Mover para a camada padrão",
                "header": "A apagar camada {0}",
                "preserveLayerContents": "Preservar o conteúdo da camada?"
            },
            "desc": {
                "att": "Quando o NPC se mover, a camada anexada o seguira"
            },
            "header": "Camadas:",
            "itemNewLayer": "<Nova Camada>",
            "label": "Camada:",
            "labelAttached": "Anexado:",
            "labelAttachedLayer": "Camada Anexada:",
            "labelMoveLayer": "Mover Camada:",
            "promptLayerName": "Nome da camada"
        },
        "letterCoordX": "X",
        "letterCoordY": "Y",
        "letterDown": "B",
        "letterLeft": "E",
        "letterRight": "D",
        "letterUp": "C",
        "level": {
            "alwaysVis": "Sempre Vis",
            "bigBG": "Cam.Grande",
            "gameStart": "Iniciar Jogo",
            "levelName": "Nome do Nível",
            "pathBG": "Caminho",
            "pathUnlocks": "Caminhos Desbloq.",
            "startPos": "Pos. Inicial"
        },
        "mapPos": "Pos. Mapa:",
        "npc": {
            "abbrevGen": "Gera.",
            "ai": {
                "LR": "Esq-Dir",
                "UD": "Cim-Bai",
                "aiIs": "IA: {0}",
                "headerCustomAi": "IA Person.:",
                "jump": "Pular",
                "leap": "Saltar",
                "swim": "Nadar",
                "target": "Perseguir",
                "use1_0Ai": "Usar IA 1.0?"
            },
            "gen": {
                "direction": "Direção",
                "effectIs": "Efeito: {0}",
                "effectShoot": "Atirar",
                "effectWarp": "Telep",
                "header": "Config. de Gerador"
            },
            "inContainer": "-",
            "inertNice": "Amig",
            "props": {
                "active": "Ativo",
                "attachSurface": "Anexa",
                "facing": "A olhar"
            },
            "stuckStop": "Fica",
            "tooltipExpandSection": "Expandir Secção"
        },
        "pageBlankOfBlank": "Pagina {0} de {1}",
        "phraseAreYouSure": "Tem certeza?",
        "section": {
            "noTurnBack": "Sem Volta",
            "offscreenExit": "Sair Pela Borda",
            "scroll": "Deslizar",
            "horizWrap": "Ligar Esq-Dir",
            "setBounds": "Def. Bordas",
            "underwater": "Subaquático",
            "vertWrap": "TP. Vertical"
        },
        "select": {
            "sectionBlankPropBlank": "Secção {0}{1}",
            "soundForEventN": "Som para Evento {0}",
            "warpTransitEffect": "Efeito de Transição do Teleporte",
            "worldMusic": "Música do Mundo",
            "allSectPropBlankForEventN": "Todas Secções {0} para {1}",
            "pathBlankUnlock": "Caminho {0} Desbloqueia Por",
            "sectBlankPropBlankForEventN": "Secção {0} {1} para {2}"
        },
        "testPlay": {
            "boot": "Bota",
            "char": "Pers",
            "magicHand": "Mão Mágica",
            "pet": "Mont.",
            "power": "Poder"
        },
        "toggleMagicBlock": "Bloco Mágico",
        "tooltip": {
            "BGOs": "Obj. de Fundo",
            "NPCs": "NPCs",
            "area": "Área",
            "blocks": "Blocos",
            "erase": "Apagar",
            "eraseAll": "Apagar Tudo",
            "events": "Eventos",
            "file": "Ficheiro",
            "layers": "Camadas",
            "levels": "Níveis",
            "music": "Música",
            "paths": "Caminhos",
            "scenes": "Cenário",
            "select": "Selecionar",
            "settings": "Configurações",
            "show": "Mostrar",
            "tiles": "Peças",
            "warps": "Teleportes",
            "water": "Água"
        },
        "warp": {
            "dir": "Dire.",
            "effect": "Efeito:",
            "in": "Ent.",
            "item": "Item",
            "lvlWarp": "Tele.Nív.",
            "needFloor": "Precisa de Chão",
            "needKey": "Precisa de Chave",
            "needStarCount": "Precisa de {0} {1}",
            "out": "Saí.",
            "placing": "A pôr:",
            "ride": "Montar",
            "showStarCount": "Mostrar Estrelas",
            "showStartScene": "Mostrar Cena Inicial",
            "speed": "Velocidade ",
            "starLockMessage": "Mens. de Bloq. de Estrela",
            "style": {
                "blipInstant": "Inst.",
                "door": "Porta",
                "pipe": "Cano",
                "portal": "Port",
                "style": "Estilo: "
            },
            "target": "Abre: ",
            "title": "Config. de Teleporte",
            "to": "A: {0}",
            "toMap": "Para Mapa",
            "transit": {
                "name0": "NENHUM",
                "name1": "DESLIZAR",
                "name2": "TRANSIÇÃO",
                "name3": "CÍRCULO",
                "name4": "VIRAR (H)",
                "name5": "VIRAR (V)"
            },
            "twoWay": "Ida-Volta",
            "allow": "Permitir:",
            "cannonExit": "Saí. Canhão"
        },
        "water": {
            "title": "Config. de Água"
        },
        "wordCoins": "Moedas",
        "wordEnabled": "Ativado",
        "wordEvent": {
            "genitive": "Evento",
            "nominative": "Evento",
            "typeLabel": "Evento {0}:"
        },
        "world": {
            "phraseCreditIndex": "Linha {0} - Créditos do Mundo:",
            "retryOnFail": "AutoRessurgir",
            "totalStars": "Núm.Estrelas:",
            "allowChars": "Jogáveis",
            "hubWorld": "Mundo Central",
            "introLevel": "Nível Inicial",
            "name": "Nome do Mundo"
        },
        "phraseCountMore": "Mais {0}",
        "phraseDelayIsMs": "Interv.: {0} ms",
        "phraseGenericIndex": "Número {0}",
        "phraseRadiusIndex": "Raio {0}",
        "phraseSectionIndex": "Secção {0}",
        "phraseTextOf": "Texto - {0}",
        "phraseWarpIndex": "Teleporte {0}",
        "wordHeight": "Altura",
        "wordInstant": "Instantâneo",
        "wordMode": "Modo",
        "wordNPC": {
            "genitive": "NPC",
            "nominative": "NPC"
        },
        "wordText": "Texto",
        "wordWidth": "Largura"
    },
    "game": {
        "connect": {
            "dropAddTitle": "Ger. Jogadores",
            "phraseChangeChar": "Mudar Personagem",
            "phraseDropMe": "Retirar",
            "phraseDropPX": "Tirar J{0}",
            "phraseForceResume": "Forçar Continuação",
            "phraseHoldStart": "Pressione Start",
            "phrasePressAButton": "Pressione A",
            "phraseSetControls": "Definir Controles",
            "phraseStartToForceRes": "Pressione Start para Forçar Continuar",
            "phraseStartToResume": "Pressione Start para Continuar",
            "phraseTestControls": "Testar Controles",
            "phraseTestProfile": "Testar Perfil",
            "phraseWaitingForInput": "A esperar por Controles...",
            "reconnectTitle": "Reconectar",
            "splitPressSelect_1": "Pressione Select para",
            "splitPressSelect_2": "Opções de Controle",
            "wordDisconnect": "Desconectar"
        },
        "pause": {
            "continue": "Continuar",
            "restartLevel": "Reiniciar Nível",
            "resetCheckpoints": "Reiniciar Ponto de Ressurgimento",
            "returnToEditor": "Retornar ao Editor",
            "saveAndContinue": "Guardar e Continuar",
            "playerSetup": "Configurar Jogadores",
            "enterCode": "Entrar Códigos",
            "quit": "Sair",
            "quitTesting": "Sair do Teste",
            "saveAndQuit": "Guardar e Sair"
        },
        "message": {
            "scanningLevels": "A buscar níveis..."
        },
        "format": {
            "minutesSeconds": "{0}m{1}s"
        },
        "error": {
            "errorInvalidEnterWarp": "Não foi possível iniciar o nível devido a um teleporte de entrada invalido em {1}.\nTotal de entradas no teleporte: {2}\n\nFicheiro: {0}",
            "errorNoStartPoint": "Não foi possível iniciar o nível por este nível não conter ponto de inicio ou entradas de teleporte especificadas.\n\nFicheiro: {0}",
            "openFileFailed": "\"{0}\" não foi aberto: Ficheiro inexistente ou corrompido.",
            "warpNeedStarCount": "Precisa de\n{0} {1} para entrar.",
            "errorTooOldGameAssets": "O conteúdo requer um pacote de recursos de fase mais recente ({0}) do que o pacote de recursos atual ({1}). Atualize o seu pacote de recursos do jogo.",
            "openIPCDataFailed": "",
            "IPCTimeOut": "Sem resposta do editor conectado. O jogo irá ser fechado.",
            "errorTooOldEngine": "O conteúdo requer um nível de recurso de mecanismo mais recente ({0}) do que a versão atual ({1}). Atualize o TheXTech."
        },
        "hint": {
            "no-lives-new": "Sem moedas? Empréstimo! Olhe à sua pontuação...",
            "no-lives-old": "Cuidado - Fim de Jogo iminente!",
            "gray-bricks": "Alguns blocos são vulneráveis a habilidades.",
            "char5-bombs": "Pressione Correr para segurar e Correr ALT para jogar.",
            "rainbow-surf": "Apanhe, corra, abaixe e depois surfe.",
            "shoe-block": "Usar isto bloqueia a maioria das - mas não todas - chamas!",
            "heavy-duck": "Pato para bloquear a maioria das - mas não todas - chamas!",
            "pound-altrun": "Pressione Alt Run para bater para baixo!",
            "pound-down": "Pressione para baixo para bater para baixo!"
        },
        "msgbox": {
            "sysInfoTitle": "Informação",
            "sysInfoWarning": "Aviso!",
            "sysInfoError": "Erro!"
        },
        "loader": {
            "statusLoadData": "A carregar dados…",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "A terminar...",
            "statusAssetPacks": "",
            "statusTranslations": "Traduções"
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "Dados aceites, a análise começou...",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": "À espera de dados de entrada..."
        },
        "screenPaused": "Pausado"
    },
    "menu": {
        "abbrevMilliseconds": "MS",
        "battle": {
            "errorNoLevels": "Não foi possível iniciar uma batalha por falta de níveis"
        },
        "caseNone": "<Nenhum>",
        "character": {
            "selectCharacter": "Jogo do {0}"
        },
        "controls": {
            "buttons": {
                "altJump": "Pulo Alt",
                "altRun": "Correr Alt",
                "down": "Baixo",
                "drop": "Cham.Item",
                "jump": "Pular",
                "left": "Esquerda",
                "right": "Direita",
                "run": "Correr",
                "start": "Iniciar",
                "up": "Cima"
            },
            "editor": {
                "scrollDown": "Desl. Abaixo",
                "scrollLeft": "Desl. Esq",
                "fastScroll": "Desl. Rápido",
                "modeErase": "M Apagar",
                "modeSelect": "M Selec",
                "nextSection": "Prox. Secção",
                "prevSection": "Secção Anter",
                "scrollRight": "Desl. Dir",
                "scrollUp": "Desl. Acima",
                "switchScreens": "Painel",
                "testPlay": "Jogo Teste"
            },
            "hotkeys": {
                "enterCheats": "Entrar códigos",
                "fullscreen": "Ecrã interio",
                "recordGif": "Gravar GIF",
                "screenshot": "Capt. Ecrã",
                "toggleHUD": "Interface",
                "debugInfo": "Depurar",
                "legacyPause": "Pausa Alt",
                "vanillaCam": "Câmara vanilla"
            },
            "options": {
                "batteryStatus": "Estado da Pilha",
                "maxPlayers": "Jogadores Máximos",
                "rumble": "Vibrar",
                "textEntryStyle": "Estilo de Entrada de Texto"
            },
            "profile": {
                "editorControls": "Controles do editor",
                "cursorControls": "Controles do cursor",
                "deleteProfile": "Apagar Perfil",
                "hotkeys": "Atalhos",
                "playerControls": "Controles do jogador",
                "renameProfile": "Renomear perfil"
            },
            "tDS": {
                "buttonL": "L",
                "buttonR": "R",
                "buttonSelect": "Select",
                "buttonA": "A",
                "buttonB": "B",
                "buttonStart": "Start",
                "buttonX": "X",
                "buttonY": "Y",
                "buttonZL": "ZL",
                "buttonZR": "ZR",
                "cStick": "Analógico-C",
                "casePen": "(Stylus)",
                "dPad": "Direcionais",
                "tStick": "Bot. do Analógico"
            },
            "phraseNewProfOldJoy": "Novo Perfil para Joystick Antigo",
            "touchscreen": {
                "option": {
                    "feedbackLength": "Duração da Vibração",
                    "feedbackStrength": "Força da Vibração",
                    "holdRun": "Segurar \"Correr\" ao Iniciar",
                    "interfaceStyle": "Estilo da interface",
                    "layoutStyle": "Estilo do Layout",
                    "resetLayout": "Reiniciar Layout",
                    "scaleButtons": "Escala dos Botões",
                    "scaleDPad": "Escala do Direcional",
                    "scaleFactor": "Fator de Escala",
                    "sStartSpacing": "Espaçamento S-Start",
                    "showCodeButton": "Mostrar Botão de Comandos"
                },
                "layout": {
                    "tight": "Apertado",
                    "tinyOld": "Pequeno (Antigo)",
                    "longOld": "Longo (Antigo)",
                    "phabletOld": "Phablet (Antigo)",
                    "phoneOld": "Telefone (Antigo)",
                    "standard": "Def. Padrão",
                    "tabletOld": "Tablet (Antigo)"
                },
                "style": {
                    "ABXY": "ABXY",
                    "XODA": "𐄂○□△",
                    "actions": "Ações"
                }
            },
            "wii": {
                "wiimote": {
                    "buttonA": "A",
                    "buttonB": "B",
                    "buttonHome": "Bot. Home",
                    "buttonMinus": "-",
                    "button1": "1",
                    "button2": "2",
                    "buttonPlus": "+",
                    "caseIR": "(Infravermelho)",
                    "dPad": "Direcionais",
                    "shake": "Sacudir"
                },
                "classic": {
                    "buttonLT": "LT",
                    "buttonRT": "RT",
                    "buttonX": "X",
                    "buttonY": "Y",
                    "buttonZL": "ZL",
                    "buttonZR": "ZR",
                    "lStick": "Direcional Esq",
                    "rStick": "Direcional Dir"
                },
                "nunchuck": {
                    "buttonC": "C",
                    "buttonZ": "Z",
                    "prefixN": "N"
                },
                "phraseNewClassic": "Novo Perfil - Classic",
                "phraseNewNunchuck": "Novo Perfil - Nunchuck",
                "typeClassic": "Classic",
                "typeNunchuck": "Nunchuck",
                "typeWiimote": "Wiimote",
                "typeGamecube": "GameCube"
            },
            "cursor": {
                "up": "Rato Cima",
                "down": "Rato Baixo",
                "left": "Rato Esq",
                "primary": "Primário",
                "right": "Rato Dir",
                "secondary": "Secundário",
                "tertiary": "Terciário"
            },
            "types": {
                "keyboard": "Teclado",
                "oldJoystick": "Joystick Antigo",
                "gamepad": "Controle",
                "touchscreen": "Ecrã de Toque"
            },
            "wordProfiles": "Perfis",
            "caseInvalid": "(Invalido)",
            "caseMouse": "(Rato)",
            "caseTouch": "(Toque)",
            "controlsConnected": "Conectado:",
            "controlsDeleteKey": "(Pulo Alt para Apagar)",
            "controlsDeleteKey2": "(Correr Alt para Apagar)",
            "controlsDeviceTypes": "Tipos de Dispositivos",
            "controlsInUse": "(Em Uso)",
            "controlsNewProfile": "<Novo Perfil>",
            "controlsNotInUse": "(Não Usado)",
            "controlsReallyDeleteProfile": "Apagar perfil?",
            "controlsTitle": "Controles",
            "wordButtons": "Botões",
            "joystickSimpleEditor": ""
        },
        "editor": {
            "promptNewWorldName": "Nome do novo mundo",
            "errorMissingResources": "Desculpe! {0} falta, é necessário para o editor no jogo.",
            "battles": "<Níveis de Batalha>",
            "newWorld": "<Novo Mundo>",
            "makeFor": ""
        },
        "game": {
            "gameEraseSlot": "Selecione um Jogo para apagar",
            "gameNoBattleLevels": "<Sem níveis de batalha>",
            "gameNoEpisodesToPlay": "<Sem episódios para jogar>",
            "gameSlotContinue": "JOGO {0} ... {1}%",
            "gameSlotNew": "JOGO {0} ... NOVO JOGO",
            "gameTargetSlot": "Agora, o Jogo de destino",
            "phraseScore": "Pontos: {0}",
            "phraseTime": "Tempo: {0}",
            "gameBattleRandom": "Nível Aleatório",
            "gameCopySave": "Copiar Jogo",
            "gameEraseSave": "Apagar Jogo",
            "gameSourceSlot": "Selecione o Jogo de origem",
            "warnEpCompat": ""
        },
        "loading": "A carregar...",
        "main": {
            "main1PlayerGame": "Um Jogador",
            "mainBattleGame": "Modo Batalha",
            "mainEditor": "Editor",
            "mainExit": "Sair",
            "mainMultiplayerGame": "Dois Jogadores",
            "mainOptions": "Opções",
            "mainPlayEpisode": "Jogar Episódio"
        },
        "options": {
            "restartEngine": "Reinicie a Engine para aplicar as mudanças.",
            "advanced": {
                "render": {
                    "opengl-tip": "",
                    "opengl11-tip": "",
                    "opengles": "OpenGL ES 2+",
                    "opengl11": "OpenGL 1.1",
                    "opengles11-tip": "",
                    "hw": "Automático",
                    "_name": "Modo de renderização",
                    "opengl": "OpenGL 3+",
                    "opengles-tip": "",
                    "sdl": "SDL2",
                    "opengles11": "OpenGL ES 1.1+",
                    "sdl-tip": "",
                    "sw": "Software"
                },
                "audio-channels": {
                    "mono": "Mono",
                    "_name": "Canais",
                    "stereo": "Estéreo"
                },
                "audio-buffer-size": {
                    "_tooltip": "Aumente para menos engasgos a custo de desempenho",
                    "_name": "Tamanho do buffer"
                },
                "audio-sample-rate": {
                    "16000": "16000 Hz",
                    "22050": "22050 Hz",
                    "_name": "Taxa de amostragem",
                    "11025": "11025 Hz",
                    "32000": "32000 Hz",
                    "44100": "44100 Hz",
                    "48000": "48000 Hz"
                },
                "choose-assets-on-launch": "Escolher assets ao iniciar",
                "audio-format": {
                    "_tooltip": "Formato para driver de som",
                    "_name": "Formato de áudio"
                },
                "log-level": {
                    "critical": "Crítico",
                    "_name": "Nível de depuração (log)",
                    "debug": "Depuração",
                    "info": "Informação",
                    "none": "Nada",
                    "fatal": "Fatal",
                    "warning": "Aviso"
                },
                "webm-recording": "",
                "internal-res-4p": {
                    "qsmbx": "1600x1200 (QSMBX)",
                    "default": "Padrão",
                    "qhd": "2560x1440 (QHD)",
                    "_name": "",
                    "fhd": "1920x1080 (FHD)"
                },
                "advanced-audio": "Áudio",
                "_tooltip": "Opções técnicas para operações internas",
                "advanced-video": "Vídeo",
                "_header": "Avançado",
                "record-gameplay-data": "Gravar jogatina",
                "scale-down-textures": {
                    "_tooltip": "Armazena imagens como 1x para economizar memória",
                    "_name": "Reduzir escala das imagens",
                    "all-tip": "Menos travamentos no carregamento do que 'Seguro'",
                    "all": "Todas",
                    "none": "Nenhum",
                    "none-tip": "Menos travamentos",
                    "safe-tip": "Verifica se as imagens estão no formato 2x",
                    "safe": "Seguro"
                },
                "audio-enable": "Ativar",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "Tipo de ecrã inteiro",
                    "exclusive": "Exclusivo",
                    "desktop-tip": "",
                    "desktop": "Área de trabalho",
                    "exclusive-tip": "",
                    "auto": "Auto"
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "GIFs imprecisos",
                "fullscreen-depth": {
                    "16": "16-bit",
                    "auto": "Auto",
                    "_name": "",
                    "32": "32-bit"
                },
                "fullscreen-res": ""
            },
            "main": {
                "two-screen-mode": {
                    "topbottom": "",
                    "shared": "Partilhado",
                    "split": "Esquerda/direita",
                    "smbx": "",
                    "_name": ""
                },
                "language": "Idioma",
                "discord-rpc": "Integração com Discord",
                "timing": "",
                "multiplayer": "Multijogador",
                "unlimited-framerate": "",
                "background-work-tip": "",
                "background-work": "",
                "_header": "Principal",
                "frame-skip": "",
                "four-screen-mode": {
                    "split": "",
                    "shared": "Partilhado",
                    "_name": ""
                },
                "vsync": "V-Sync"
            },
            "audio": {
                "sfx-pet-beat-tip": "",
                "sfx-pet-beat": "",
                "sfx-modern-tip": "",
                "_header": "Áudio",
                "sfx-modern": "Efeitos modernos",
                "audio-music-volume": "Volume da música",
                "sfx-audio-fx": "Efeitos de eco",
                "audio-sfx-volume": "Volume dos efeitos",
                "audio-prefs": "Referências",
                "sfx-spatial-audio": "Som espacial",
                "sfx-spatial-audio-tip": "Reduz o volume de sons fora do ecrã"
            },
            "speedrun": {
                "mode": {
                    "0": "0",
                    "2": "2",
                    "1": "1",
                    "3": "",
                    "_name": ""
                }
            },
            "view-credits": {
                "_header": "Ver créditos"
            },
            "video": {
                "world-map-stars-show-tip": "",
                "battery-status": {
                    "off": "Desligado",
                    "on": "Sempre",
                    "_name": "",
                    "low-tip": "",
                    "low": "Baixo",
                    "fullscreen-tip": "",
                    "fullscreen": "Ecrã inteiro"
                },
                "internal-res": {
                    "hd": "1280x720 (HD)",
                    "hello": "768x432 (HELLO)",
                    "gba": "480x320 (GBA)",
                    "dynamic": "Dinâmico",
                    "_tooltip": "",
                    "_name": "Tamanho do ecrã",
                    "3ds": "800x480 (3DS)",
                    "vga": "640x480 (VGA)",
                    "nds": "512x384 (NDS)",
                    "smbx": "800x600 (SMBX)",
                    "snes": "512x448 (SNES)",
                    "smbx-wide": ""
                },
                "_header": "Vídeo",
                "fullscreen": "Ecrã inteiro",
                "enable-inter-level-fade-effect": "",
                "info-game": "",
                "scale-mode": {
                    "1x": "1x",
                    "2x": "2x",
                    "integer": "Inteiros",
                    "_name": "Modo de escala",
                    "0_5x": "0,5x",
                    "center": "Centro",
                    "linear": "Suave",
                    "nearest": "",
                    "full": "",
                    "3x": ""
                },
                "show-episode-title": {
                    "bottom-tip": "",
                    "_name": "",
                    "off": "Desligado",
                    "bottom": "",
                    "top-tip": "",
                    "top": ""
                },
                "3d-compat-mode": "",
                "show-playtime-counter": {
                    "_name": "",
                    "transparent": "Transparente",
                    "animated": "",
                    "_tooltip": "",
                    "opaque": "Opaco",
                    "animated-tip": "",
                    "off": "Desl.",
                    "off-tip": ""
                },
                "show-medals-counter-tip": "",
                "show-screen-shake": "",
                "video-system": "Sistema",
                "world-map-stars-show": "",
                "info-run": "",
                "info-meta": "",
                "display-controllers": "",
                "effects": "",
                "3d-compat-mode-tip": "",
                "show-fails-counter": "",
                "show-medals-counter": "",
                "show-fails-counter-tip": "",
                "show-fps": ""
            },
            "controls": {
                "_header": "Controlos"
            },
            "episode-options": {
                "_header": "",
                "creator-compat": {
                    "_tooltip": "",
                    "_name": "",
                    "disable": "Desativar",
                    "enable": "Ativar",
                    "file-only": "Somente ficheiro"
                },
                "playstyle": {
                    "_name": "",
                    "classic-tip": "Atualizações minimais",
                    "classic": "Classic",
                    "modern": "Moderno (PGE-X)",
                    "modern-tip": "Todas atualizações",
                    "vanilla-tip": "Nenhumas atualizações",
                    "vanilla": ""
                },
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "compatibility": {
                "_header": "",
                "features": "Funcionalidades",
                "bugfixes": "",
                "reset-all": "",
                "autocode": "",
                "_tooltip": ""
            }
        },
        "wordBack": "Voltar",
        "wordHide": "Esconder",
        "wordOff": "Desl.",
        "wordWaiting": "À espera",
        "wordOn": "Ligado",
        "wordPlayer": "Jogador",
        "wordProfile": "Perfil",
        "wordResume": "Continuar",
        "wordShow": "Mostrar",
        "wordYes": "Sim",
        "wordNo": "Não"
    },
    "outro": {
        "cppPortDevelopers": "Programadores da versão C++:",
        "customSprites": "Sprite Personalizado:",
        "engineCredits": "Créditos da Engine:",
        "gameCredits": "Créditos do jogo:",
        "levelDesign": "Design de níveis:",
        "nameAndrewSpinks": "Andrew Spinks",
        "nameVitalyNovichkov": "Novichkov Vitaliy",
        "originalBy": "Código original VB6 Por:",
        "psVitaPortBy": "Port para PS Vita Por:",
        "qualityControl": "Controle de Qualidade:",
        "specialThanks": "Agradecimentos Especiais:"
    },
    "pluralRules": "one-is-singular",
    "languageName": "Português"
}


================================================
FILE: resources/languages/thextech_ru.json
================================================
{
    "editor": {
        "block": {
            "canBreak": "Можн. слом.",
            "canBreakTooltip": "Устар.: ломается при ударе",
            "inside": "Содерж.:",
            "invis": "Невид.",
            "letterHeight": "В ",
            "letterWidth": "Ш ",
            "pickContents": "Выберите содержимое блока",
            "slick": "Лёд"
        },
        "browser": {
            "askOverwriteFile": "Заменить {0}?",
            "itemNewFile": "<Нов. файл>",
            "itemNewFolder": "<Нов. папка>",
            "newFile": "Новый файл",
            "openFile": "Открыть файл",
            "saveFile": "Сохранить файл"
        },
        "events": {
            "bounds": {
                "changeAllSectionBoundsToCurrent": "изменить все границы секции к текущим?",
                "changeSectionBoundsToCurrent": "изменить границы секции {0} к текущим?",
                "shouldEvent": "Должно ли событие {0}"
            },
            "controlsForEventN": "Авто-управление персонажем по событию \"{0}\"",
            "deletion": {
                "cancel": "Нет: не удалять событие",
                "confirm": "Да: удалить событие",
                "deletingEvent": "Удалить событие {0}"
            },
            "desc": {
                "activate": "НИП появится на экране",
                "death": "НИП умрёт",
                "destroy": "блок будет разрушен",
                "enter": "игрок войдёт в проход",
                "hit": "по блоку ударят",
                "layerClear": "слой будет очищен от объектов",
                "phraseTriggersAfterTemplate": "Событие \"{0}\", которое сработает через {1} мс. после события \\\"{2}\\\"",
                "phraseTriggersWhenTemplate": "{0}: Сработает, когда {1}",
                "talk": "игрок поговорит с НИП"
            },
            "header": "Событ.:",
            "headerTriggerEvent": "Триггер:",
            "itemNewEvent": "<Новое событие>",
            "label": {
                "activate": "Активация",
                "death": "Смерть",
                "destroy": "Разруш.",
                "enter": "Вход",
                "hit": "Удар",
                "layerClear": "Слой чист",
                "next": "След.",
                "talk": "Поговорить"
            },
            "layers": {
                "headerHide": "Скрыть:",
                "headerMove": "Движение:",
                "headerShow": "Показать:",
                "headerToggle": "Переключ.:"
            },
            "letter": {
                "activate": "Ак:",
                "death": "См:",
                "destroy": "Ун:",
                "enter": "Вх:",
                "hit": "Ур:",
                "layerClear": "Сл:",
                "talk": "Гв:"
            },
            "promptEventName": "Имя события:",
            "promptEventText": "Текст события:",
            "props": {
                "autostart": "Автозап.",
                "controls": "Авто-уп.",
                "endGame": "Зав.игр.",
                "sound": "Звук",
                "layerSmoke": "Дым"
            },
            "sections": {
                "actionKeep": "Ост.",
                "actionReset": "Сброс",
                "actionSet": "Назн.",
                "phraseAllSections": "Все секции",
                "propBackground": "Фон",
                "propBounds": "Границы",
                "propMusic": "Музыка"
            },
            "settingsForEvent": "Настройки события \"{0}\""
        },
        "file": {
            "actionClearLevel": "Стереть уровень",
            "actionClearWorld": "Стереть мир",
            "actionExit": "Выйти",
            "actionOpen": "Открыть",
            "actionRevert": "Откатить",
            "commandNew": "Новый",
            "commandOpen": "Открыть...",
            "commandSave": "Сохранить",
            "commandSaveAs": "Сохранить как...",
            "confirmConfirmAction": "Вы уверены, что хотите {0}?",
            "confirmConvertFormatTo": "Преобразовать в {0} формат?",
            "confirmSaveBeforeAction": "Сохранить, прежде чем {0}?",
            "convert": {
                "descNew": "Расширение имени файла будет изменено, однако старый файл СОХРАНИТСЯ.\n\nНе забудьте проверить файл на предмет потерянной функциональности после сохранения."
            },
            "formatLegacy": "Устаревший",
            "formatModern": "Современный",
            "labelCurrentFile": "Текущий файл:",
            "labelFormat": "Формат:",
            "optionActionWithoutSave": "{0} без сохранения?",
            "optionCancelAction": "Отмена действия: {0}",
            "optionCancelConversion": "Отмена преобразования",
            "optionProceedWithConversion": "Выполнить с преобразованием",
            "optionYesSaveThenAction": "Да: сохран., прежде чем {0}",
            "sectionLevel": "Уровень",
            "sectionWorld": "Мир"
        },
        "layers": {
            "abbrevAttLayer": "Прис.: ",
            "default": "По-умолч.",
            "deletion": {
                "cancel": "Отмена: не удалять слой",
                "confirmDelete": "Нет: *УДАЛИТЬ ВСЁ СОДЕРЖИМОЕ*",
                "confirmPreserve": "Да: перемест.. в основной слой",
                "header": "Удаление слоя {0}",
                "preserveLayerContents": "Сохранить содержимое слоя?"
            },
            "desc": {
                "att": "Пока НИП движется, присоединён- ный слой следует за ним"
            },
            "header": "Слои:",
            "itemNewLayer": "<Нов. слой>",
            "label": "Слой:",
            "labelAttached": "Присоед.:",
            "labelAttachedLayer": "Присоед. слой:",
            "labelMoveLayer": "Движение слоя:",
            "promptLayerName": "Имя слоя"
        },
        "letterCoordX": "X",
        "letterCoordY": "Y",
        "letterDown": "Н",
        "letterLeft": "Л",
        "letterRight": "П",
        "letterUp": "В",
        "level": {
            "alwaysVis": "Всегда вид.",
            "bigBG": "Большой фон",
            "gameStart": "Начало игры",
            "levelName": "Имя уровня",
            "pathBG": "Фон-путь",
            "pathUnlocks": "Разблок.путей",
            "startPos": "Нач. позиция"
        },
        "mapPos": "Позиция:",
        "npc": {
            "abbrevGen": "Ген.",
            "ai": {
                "LR": "ЛП",
                "UD": "ВН",
                "aiIs": "ИИ: {0}",
                "headerCustomAi": "Свой ИИ:",
                "jump": "Прыг",
                "leap": "Скок",
                "swim": "Плав.",
                "target": "Цель",
                "use1_0Ai": "Исп. ИИ 1.0?"
            },
            "gen": {
                "direction": "Направление",
                "effectIs": "Эффект: {0}",
                "effectShoot": "Выстрел",
                "effectWarp": "Выползание",
                "header": "Настройки генератора"
            },
            "inContainer": "В",
            "inertNice": "Друг",
            "props": {
                "active": "Актив.",
                "attachSurface": "Прис.",
                "facing": "Напр."
            },
            "stuckStop": "Стоп",
            "tooltipExpandSection": "Расширить секцию"
        },
        "pageBlankOfBlank": "Стр. {0} из {1}",
        "phraseAreYouSure": "Вы уверены?",
        "phraseCountMore": "Ещё {0}",
        "phraseDelayIsMs": "Период: {0} мс",
        "phraseGenericIndex": "Номер {0}",
        "phraseRadiusIndex": "Радиус {0}",
        "phraseSectionIndex": "Секция {0}",
        "phraseTextOf": "Текст \"{0}\"",
        "phraseWarpIndex": "Проход {0}",
        "section": {
            "horizWrap": "Гор. перенос",
            "noTurnBack": "Только вправо",
            "offscreenExit": "Выход за экран",
            "scroll": "Прокрутка",
            "setBounds": "Уст. границы",
            "underwater": "Под водой",
            "vertWrap": "Верт.Прох."
        },
        "select": {
            "allSectPropBlankForEventN": "{0} всех секций для \"{1}\"",
            "pathBlankUnlock": "Разблок. путь {0}:",
            "sectBlankPropBlankForEventN": "{1} секции {0} для \"{2}\"",
            "sectionBlankPropBlank": "{1} секции {0}",
            "soundForEventN": "Звук для события \"{0}\"",
            "warpTransitEffect": "Эффект перехода прохода",
            "worldMusic": "Музыка мира"
        },
        "testPlay": {
            "boot": "Сапог",
            "char": "Перс.",
            "magicHand": "Хватайка",
            "pet": "Конь",
            "power": "Сила"
        },
        "toggleMagicBlock": "Волшебный блок",
        "tooltip": {
            "BGOs": "Фоновые объекты",
            "NPCs": "Неигровые персонажи",
            "blocks": "Блоки",
            "erase": "Ластик",
            "eraseAll": "Стереть всё",
            "events": "События",
            "file": "Файл",
            "layers": "Слои",
            "levels": "Уровни",
            "music": "Музыка",
            "paths": "Пути",
            "scenes": "Декорации",
            "select": "Выбор",
            "settings": "Настройки",
            "show": "Показать",
            "tiles": "Ландшафт",
            "warps": "Проходы",
            "water": "Вода",
            "area": "Район"
        },
        "warp": {
            "allow": "Разр.",
            "cannonExit": "Выход-пушка",
            "dir": "Напр.",
            "effect": "Эффект:",
            "in": "Вх.",
            "item": "Вещь",
            "lvlWarp": "Ц.проход",
            "needFloor": "Нужна земля",
            "needKey": "Запереть",
            "needStarCount": "Нужно {0} {1}",
            "out": "Вых.",
            "placing": "Размещение:",
            "ride": "Езд.",
            "showStarCount": "Показ. звёзды",
            "showStartScene": "Показ. н.сцену",
            "speed": "Сила ",
            "starLockMessage": "Сообщ. о звзд.",
            "style": {
                "blipInstant": "Мгнв.",
                "door": "Дверь",
                "pipe": "Труба",
                "portal": "Портал",
                "style": "Стиль:"
            },
            "target": "Цель: ",
            "title": "Настр. прохода",
            "to": "К: {0}",
            "toMap": "В мир",
            "transit": {
                "name0": "НЕТ",
                "name1": "ПРОКР.",
                "name2": "ПЕРЕЛ.",
                "name3": "КРУГ",
                "name4": "ОТР. (Г)",
                "name5": "ОТР. (В)"
            },
            "twoWay": "Дву-напр."
        },
        "water": {
            "title": "Настройки воды"
        },
        "wordCoins": "Монетки",
        "wordEnabled": "Включено",
        "wordEvent": {
            "genitive": "События",
            "nominative": "Событие",
            "typeLabel": "Событие \"{0}\":"
        },
        "wordHeight": "Высота",
        "wordInstant": "Мгновенно",
        "wordMode": "Режим",
        "wordNPC": {
            "genitive": "НИПа",
            "nominative": "НИП"
        },
        "wordText": "Текст",
        "wordWidth": "Ширина",
        "world": {
            "allowChars": "Разр. перс.",
            "hubWorld": "Коридорный мир",
            "introLevel": "Урвоень-вступление",
            "name": "Название мира",
            "phraseCreditIndex": "Титры, стрка {0}:",
            "retryOnFail": "Переигр. сразу",
            "totalStars": "Всего звёзд:"
        },
        "labelSortLayer": "Слой сорт.:",
        "labelSortOffset": "Смещ.Сорт:"
    },
    "game": {
        "connect": {
            "dropAddTitle": "Доб./Убрать игроков",
            "phraseChangeChar": "Сменить персонажа",
            "phraseDropMe": "Убрать себя",
            "phraseDropPX": "Убрать игрока {0}",
            "phraseForceResume": "Принуд. возобновить",
            "phraseHoldStart": "Удерж. Старт",
            "phrasePressAButton": "Нажмите кнопку A",
            "phraseSetControls": "Назначить управление",
            "phraseStartToForceRes": "Нажмите Start, чтобы принуд. возобн.",
            "phraseStartToResume": "Нажмите Start, чтобы возобновить",
            "phraseTestControls": "Проверить управление",
            "phraseWaitingForInput": "Ожидание устройств ввода..",
            "reconnectTitle": "Переподключить",
            "splitPressSelect_1": "Нажмите Select, чтобы",
            "splitPressSelect_2": "Настройки управления",
            "wordDisconnect": "Отключить",
            "phraseTestProfile": "Тест профиля"
        },
        "error": {
            "errorInvalidEnterWarp": "Невозможно запустить уровень, потому что указан некорректный входной проход {1}.\nВсего проходов: {2}\n\nФайл: {0}",
            "errorNoStartPoint": "Невозможно запустить уровень из-за отсутствия начальных точек, либо не указан входной проход.\n\nФайл: {0}",
            "openFileFailed": "Не удаётся открыть \"{0}\": файл не существует или повреждён.",
            "warpNeedStarCount": "Чтобы войти, нужно найти\n{0} {1}.",
            "IPCTimeOut": "Нет ответа от подключённого редактора. Игра будет закрыта.",
            "openIPCDataFailed": "Невозможно обработать принятые данные файла из-за повреждений либо других ошибок.",
            "errorTooOldEngine": "Контент требует более новую версию функционала ({0}), чем текущая версия ({1}). Пожалуйста, обновите TheXTech.",
            "errorTooOldGameAssets": "Контент требует более новый уровень функционала ({0}), чем заявлено в текущем пакете игровых ресурсов ({1}). Пожалуйста, обновите Ваш набор игровых ресурсов."
        },
        "pause": {
            "continue": "Продолжить",
            "enterCode": "Ввести код",
            "quit": "Выйти",
            "quitTesting": "Закрыть тест",
            "resetCheckpoints": "Сбросить контр. точки",
            "restartLevel": "Начать сначала",
            "returnToEditor": "Назад в редактор",
            "saveAndContinue": "Сохранить и продолжить",
            "saveAndQuit": "Сохранить и выйти",
            "playerSetup": "Настройки игрока"
        },
        "msgbox": {
            "sysInfoError": "Ошибка!",
            "sysInfoTitle": "Информация",
            "sysInfoWarning": "Предупреждение!"
        },
        "message": {
            "scanningLevels": "Чтение уровней..."
        },
        "format": {
            "minutesSeconds": "{0}м{1}с"
        },
        "hint": {
            "no-lives-new": "Не осталось монет? Возьмите в кредит! Следите за своим счётом...",
            "no-lives-old": "Будьте осторожны: конец игры неизбежен!",
            "rainbow-surf": "Захвати, беги, зажми \"вниз\", и выпусти: поедешь с ветерком.",
            "char5-bombs": "Нажмите БЕГ, чтобы подобрать, и Альт-БЕГ, чтобы швырнуть.",
            "gray-bricks": "Некоторые блоки можно сломать с помощью особых усилителей.",
            "heavy-duck": "Пригнитесь, чтобы защититься от огня (но не от любого)!",
            "shoe-block": "Одев это, можно защититься от огня (но не от любого)!",
            "pound-down": "Нажмите Вниз, чтобы сотрясти землю!",
            "pound-altrun": "Нажмите Альт-Бег, чтобы сотрясти землю!"
        },
        "screenPaused": "Игра приостановлена",
        "ipcStatus": {
            "dataAccepted": "Данные приняты, началась обработка...",
            "dataTransferStarted": "Началась передача данных...",
            "dataValid": "Принятые данные корректны",
            "errorTimeout": "ОШИБКА: Время ожидания истекло.",
            "loadingdone": "Готово. Теперь запускаем игру...",
            "waitingInput": "Ожидание входящих данных..."
        },
        "loader": {
            "statusAssetPacks": "Наборы ресурсов",
            "statusFinishing": "Завершение...",
            "statusGameInfo": "Информация об игре",
            "statusLoadData": "Загрузка данных...",
            "statusLoadFile": "Загрузка: {0}",
            "statusTranslations": "Переводы",
            "loading": "Загрузка..."
        }
    },
    "languageName": "Русский",
    "menu": {
        "abbrevMilliseconds": "мс",
        "battle": {
            "errorNoLevels": "Невозможно начать битву потому что нету доступных уровней"
        },
        "caseNone": "<Нет>",
        "character": {
            "selectCharacter": "Играть, как {0}"
        },
        "controls": {
            "buttons": {
                "altJump": "Альт-Прыг",
                "altRun": "Альт-Бег",
                "down": "Вниз",
                "drop": "Выброс",
                "jump": "Прыжок",
                "left": "Влево",
                "right": "Впаво",
                "run": "Бег",
                "start": "Старт",
                "up": "Вверх"
            },
            "caseInvalid": "(Некор.)",
            "caseMouse": "(Мышь)",
            "caseTouch": "(Сенсор)",
            "controlsConnected": "Подключено:",
            "controlsDeleteKey": "(Альт-Прыжок чтобы сбросить)",
            "controlsDeviceTypes": "Типы устройств",
            "controlsInUse": "(Используется)",
            "controlsNewProfile": "<Новый профиль>",
            "controlsNotInUse": "(Не используется)",
            "controlsReallyDeleteProfile": "Действительно удалить профиль?",
            "controlsTitle": "Управление",
            "cursor": {
                "down": "Мышь вниз",
                "left": "Мышь влево",
                "primary": "Первичн.",
                "right": "Мышь вправо",
                "secondary": "Вторичн.",
                "tertiary": "Третичн.",
                "up": "Мышь вверх"
            },
            "editor": {
                "fastScroll": "Быс.прокр.",
                "modeErase": "Ластик",
                "modeSelect": "Выбор",
                "nextSection": "След.сект.",
                "prevSection": "Пред.сект.",
                "scrollDown": "Пр.вниз",
                "scrollLeft": "Пр.влево",
                "scrollRight": "Пр.вправо",
                "scrollUp": "Пр.вверх",
                "switchScreens": "Панель",
                "testPlay": "Тест-игра"
            },
            "hotkeys": {
                "debugInfo": "Отл.инф.",
                "enterCheats": "Ввести код",
                "fullscreen": "Полн.экран",
                "legacyPause": "Ст.пауза",
                "recordGif": "Зап.GIF",
                "screenshot": "Снимок",
                "toggleHUD": "Пер.пан.",
                "vanillaCam": "Классич. камера"
            },
            "options": {
                "batteryStatus": "Состояние батареи",
                "maxPlayers": "Макс. игроков",
                "rumble": "Вибрация",
                "textEntryStyle": "Тип ввода текста",
                "altMenuControls": "Альт. управление меню"
            },
            "phraseNewProfOldJoy": "Новый профиль для ст.джойстика",
            "profile": {
                "cursorControls": "Указатель",
                "deleteProfile": "Удалить профиль",
                "editorControls": "Редактор",
                "hotkeys": "Горчие клавиши",
                "playerControls": "Игровое управление",
                "renameProfile": "Переименовать профиль"
            },
            "tDS": {
                "buttonA": "A",
                "buttonB": "B",
                "buttonL": "L",
                "buttonR": "R",
                "buttonSelect": "SELECT",
                "buttonStart": "Старт",
                "buttonX": "X",
                "buttonY": "Y",
                "buttonZL": "ZL",
                "buttonZR": "ZR",
                "cStick": "C-Stick",
                "casePen": "(Перо)",
                "dPad": "Крест.",
                "tStick": "Джойстик"
            },
            "touchscreen": {
                "layout": {
                    "longOld": "Длинная (ст.)",
                    "phabletOld": "Фаблет (ст.)",
                    "phoneOld": "Телефон (ст.)",
                    "standard": "Обычная",
                    "tabletOld": "Планшет (ст.)",
                    "tight": "Плотная",
                    "tinyOld": "Кроха (ст.)"
                },
                "option": {
                    "feedbackLength": "Длительность отдачи",
                    "feedbackStrength": "Сила отдачи",
                    "holdRun": "Удержание БЕГа при запуске",
                    "interfaceStyle": "Стиль кнопок",
                    "layoutStyle": "Вид раскладки",
                    "resetLayout": "Сбросить раскладку",
                    "sStartSpacing": "Расстояние Выбор-Старт",
                    "scaleButtons": "Масштаб кнопок",
                    "scaleDPad": "Масштаб крестовины",
                    "scaleFactor": "Общий масштаб",
                    "showCodeButton": "Показать кнопку кода"
                },
                "style": {
                    "ABXY": "ABXY",
                    "XODA": "XODA",
                    "actions": "Дейсвтия"
                }
            },
            "types": {
                "gamepad": "Геймпад",
                "keyboard": "Клавиатура",
                "oldJoystick": "Ст.джойстик",
                "touchscreen": "Сенсор"
            },
            "wii": {
                "classic": {
                    "buttonLT": "LT",
                    "buttonRT": "RT",
                    "buttonX": "X",
                    "buttonY": "Y",
                    "buttonZL": "ZL",
                    "buttonZR": "ZR",
                    "lStick": "Л.Джой.",
                    "rStick": "П.Джой."
                },
                "nunchuck": {
                    "buttonC": "C",
                    "buttonZ": "Z",
                    "prefixN": "N"
                },
                "phraseNewClassic": "Нов. профиль Classic",
                "phraseNewNunchuck": "Нов. профиль Nunchack",
                "typeClassic": "Classic",
                "typeNunchuck": "Nunchack",
                "typeWiimote": "Wiimote",
                "wiimote": {
                    "button1": "1",
                    "button2": "2",
                    "buttonA": "A",
                    "buttonB": "B",
                    "buttonHome": "Дом",
                    "buttonMinus": "-",
                    "buttonPlus": "+",
                    "caseIR": "(ИК)",
                    "dPad": "Крест.",
                    "shake": "Встряска"
                },
                "typeGamecube": "GameCube"
            },
            "wordButtons": "Кнопки",
            "wordProfiles": "Профили",
            "joystickSimpleEditor": "Простое управление редактором",
            "controlsDeleteKey2": "(Альт-Бег, чтобы удалить)"
        },
        "editor": {
            "errorMissingResources": "Извините, но для встроенного редактора не хватает файла {0}.",
            "newWorld": "<Новый мир>",
            "promptNewWorldName": "Имя нового мира",
            "battles": "<Уровни для битв>",
            "makeFor": "Создать для:"
        },
        "game": {
            "gameBattleRandom": "Случайный уровень",
            "gameCopySave": "Скопир. сохранение",
            "gameEraseSave": "Стереть сохранение",
            "gameEraseSlot": "Какое сохранение стереть?",
            "gameNoBattleLevels": "<Нету уровней битвы>",
            "gameNoEpisodesToPlay": "<Эпизоды отсутствуют>",
            "gameSlotContinue": "Слот {0} ... {1}%",
            "gameSlotNew": "Слот {0} ... Новая игра",
            "gameSourceSlot": "Что скопировать?",
            "gameTargetSlot": "Куда скопировать?",
            "phraseScore": "Счёт: {0}",
            "phraseTime": "Время: {0}",
            "warnEpCompat": "Данный эпизод создан для другой ветки SMBX и может работать неправильно."
        },
        "loading": "Загрузка...",
        "main": {
            "main1PlayerGame": "Одиночная игра",
            "mainBattleGame": "Битва",
            "mainEditor": "Редактор",
            "mainExit": "Выйти",
            "mainMultiplayerGame": "Игра вдвоём",
            "mainOptions": "Настройки",
            "mainPlayEpisode": "Сыграть в эпизод"
        },
        "options": {
            "restartEngine": "Перезагрузите игру, чтобы применить изменения.",
            "advanced": {
                "audio-buffer-size": {
                    "_tooltip": "Увеличьте, чтобы уменьшить обрывы, но при этом звук будет сильнее отставать",
                    "_name": "Размер буфера"
                },
                "audio-sample-rate": {
                    "11025": "11025 Гц",
                    "32000": "32000 Гц",
                    "44100": "44100 Гц",
                    "22050": "22050 Гц",
                    "48000": "48100 Гц",
                    "16000": "16000 Гц",
                    "_name": "Частота дискретизации"
                },
                "audio-channels": {
                    "_name": "Каналы",
                    "mono": "Моно",
                    "stereo": "Стерео"
                },
                "log-level": {
                    "_name": "Уровень отчётов",
                    "none": "Откл.",
                    "critical": "Критические",
                    "debug": "Отладка",
                    "fatal": "Фатальные",
                    "info": "Инфо",
                    "warning": "Предупреждения"
                },
                "render": {
                    "hw": "Авто",
                    "opengles-tip": "Мобильный интерфейс, поддерживающий все новые эффекты и высокую точность SMBX64",
                    "sw": "Программный",
                    "_name": "Режим отрисовки",
                    "opengl-tip": "Настольный интерфейс с поддержкой всех графических эфектов SMBX64 с максимальной точностью",
                    "opengl11-tip": "Устаревший настольный интерфейс с точной поддержкой SMBX64",
                    "opengl": "OpenGL 3+",
                    "opengles": "OpenGL ES 2+",
                    "opengles11-tip": "Устаревший мобильный интерфейс с полной поддержкой SMBX64",
                    "sdl": "SDL2",
                    "sdl-tip": "Базовый кросс-платформенный интерфейс отрисовки",
                    "opengles11": "OpenGL ES 1.1+",
                    "opengl11": "OpenGL 1.1"
                },
                "scale-down-textures": {
                    "all": "Всё",
                    "all-tip": "Меньше тормозов при загрузке, чем \"Безопасно\"",
                    "_name": "Уменьшать картинки",
                    "none": "Не уменьшать",
                    "none-tip": "Меньше всего тормозов при загрузке",
                    "safe": "Безопасно",
                    "_tooltip": "Для экономии оперативной памяти, картинки будут уменьшаться в два раза при загрузке",
                    "safe-tip": "Проверяет, является ли картинка увеличенного в 2 раза формата"
                },
                "_header": "Продвинутое",
                "_tooltip": "Технические настройки для внутренней работы",
                "advanced-audio": "Аудио",
                "advanced-video": "Видео",
                "audio-enable": "Включить",
                "audio-format": {
                    "_name": "Формат аудио",
                    "_tooltip": "Формат для звукового драйвера"
                },
                "choose-assets-on-launch": "Выбирать игру при запуске",
                "record-gameplay-data": "Запись игрового процесса",
                "webm-recording": "Запись WebM",
                "internal-res-4p": {
                    "_name": "Размер разделения экрана на 4И",
                    "default": "По-умолчанию",
                    "fhd": "1920x1080 (FHD)",
                    "qhd": "2560x1440 (QHD)",
                    "qsmbx": "1600x1200 (QSMBX)"
                },
                "use-native-osk": "Системная экранная клавиатура",
                "inaccurate-gifs-tip": "Разрешает 3D-эффект в присутствии GIF-текстур",
                "inaccurate-gifs": "Неточные GIFы",
                "fullscreen-type": {
                    "desktop": "Растяжение",
                    "desktop-tip": "Окно будет растянуто без изменения разрешения экрана",
                    "exclusive": "Весь экран",
                    "auto": "Авто",
                    "exclusive-tip": "Захват всего экрана со сменой видео-режима",
                    "_name": "Тип полного экрана"
                },
                "fullscreen-depth": {
                    "16": "16-бит",
                    "32": "32-бит",
                    "_name": "Глубина цвета в п/э режиме",
                    "auto": "Авто"
                },
                "fullscreen-res": "Разрешение п/э"
            },
            "audio": {
                "_header": "Аудио",
                "audio-music-volume": "Громкость музыки",
                "audio-prefs": "Свойства",
                "audio-sfx-volume": "Громкость звука",
                "sfx-audio-fx": "Эхо-эфекты",
                "sfx-modern": "Новые звуки",
                "sfx-spatial-audio": "Пространственный звук",
                "sfx-modern-tip": "Использовать новые звуки, добавленные в TheXTech",
                "sfx-pet-beat": "Тема питомца",
                "sfx-spatial-audio-tip": "Глушить громкость заэкранных источников",
                "sfx-pet-beat-tip": "Проигрывать особую музыкальную тему во время верховой езды на питомце"
            },
            "compatibility": {
                "_header": "Настройки сеанса",
                "reset-all": "Сбросить всё",
                "bugfixes": "Исправления ошибок",
                "_tooltip": "Настройки совместимости или отладки",
                "autocode": "Автокод",
                "features": "Возможности"
            },
            "controls": {
                "_header": "Управление"
            },
            "episode-options": {
                "_header": "Настройки эпизода",
                "creator-compat": {
                    "_tooltip": "Калибровка логики от авторов контента",
                    "enable": "Включить",
                    "_name": "Калибровка от авторов",
                    "disable": "Выключить",
                    "file-only": "Только файл"
                },
                "playstyle": {
                    "_name": "Стиль игры",
                    "classic": "Классический",
                    "classic-tip": "Минимум обновлений",
                    "modern": "Современный",
                    "modern-tip": "Все обновления",
                    "vanilla": "Ванильный",
                    "vanilla-tip": "Без обновлений"
                },
                "hub-resume": "Запоминать проход в корридорах",
                "hub-resume-tip": "Позволяет возобновить игру у недавнего прохода, куда вы входили"
            },
            "main": {
                "four-screen-mode": {
                    "split": "Разбивка",
                    "_name": "Режим экрана для 4И",
                    "shared": "Общий"
                },
                "frame-skip": "Пропуск кадров",
                "discord-rpc": "Интеграция с Discord",
                "language": "Язык",
                "unlimited-framerate": "Неограниченная частота кадров",
                "vsync": "Верт. синхронизация",
                "_header": "Основные",
                "background-work": "Фоновая работа",
                "background-work-tip": "В игру можно будет играть джойстиком даже при отсутствии фокуса",
                "multiplayer": "Несколько игроков",
                "timing": "Синхронизация кадров",
                "two-screen-mode": {
                    "_name": "Режим экрана для 2И",
                    "shared": "Общий",
                    "smbx": "Как в SMBX",
                    "split": "Лево/Право",
                    "topbottom": "Верх/Низ"
                }
            },
            "video": {
                "_header": "Видео",
                "battery-status": {
                    "_name": "Состояние батареи устройства",
                    "fullscreen": "Полный экран",
                    "low": "Низкий заряд",
                    "off": "Скрыт",
                    "fullscreen-tip": "Показать только в полноэкранном режиме",
                    "low-tip": "Показать, когда заряд будет низкий",
                    "on": "Всегда"
                },
                "info-run": "Информация об игровом процессе",
                "internal-res": {
                    "3ds": "800x480 (3DS)",
                    "_name": "Размер экрана",
                    "smbx-wide": "SMBX (широкий)",
                    "gba": "480x320 (GBA)",
                    "_tooltip": "Разрешение игрового поля",
                    "dynamic": "Динамическое",
                    "hd": "1280x720 (HD)",
                    "snes": "512x448 (SNES)",
                    "vga": "640x480 (VGA)",
                    "hello": "768x432 (HELLO)",
                    "nds": "512x384 (NDS)",
                    "smbx": "800x600 (SMBX)"
                },
                "scale-mode": {
                    "integer": "Целочисленный",
                    "linear": "Сглаженный",
                    "nearest": "Чёткий",
                    "full": "Полный",
                    "center": "Центр",
                    "_name": "Режим масштабирования",
                    "2x": "2x",
                    "0_5x": "0.5x",
                    "1x": "1x",
                    "3x": "3x"
                },
                "show-episode-title": {
                    "bottom": "Снизу",
                    "bottom-tip": "Показать над секундомером",
                    "top": "Сверху",
                    "off": "Скрыто",
                    "top-tip": "Отобразить над индикаторной панелью",
                    "_name": "Название эпизода"
                },
                "3d-compat-mode": "Режим совместимости 3D",
                "show-medals-counter": "Показать счётчик медалей",
                "show-medals-counter-tip": "Отобразить медали на индикаторной панели и над входом на уровень",
                "show-playtime-counter": {
                    "_name": "Счётчик игрового времени",
                    "animated": "Анимированный",
                    "off": "Выключен",
                    "off-tip": "Отображать только в режиме прохождения на скорость",
                    "opaque": "Непрозрачный",
                    "transparent": "Прозрачный",
                    "animated-tip": "Добавляет радужный эффект в конце уровня",
                    "_tooltip": "Отображает время, потраченное на прохождение эпизода и текущую попытку"
                },
                "show-screen-shake": "Встряски экрана",
                "info-meta": "Мета-информация",
                "show-fails-counter-tip": "Отображает счётчик неудач за весь эпизод и за текущий уровень",
                "effects": "Экранные эфекты",
                "display-controllers": "Состояние контроллера",
                "fullscreen": "Полный экран",
                "info-game": "Состояние игры",
                "enable-inter-level-fade-effect": "Плавные переходы",
                "3d-compat-mode-tip": "Отрисовать все объекты на одном 3D-плане",
                "show-fails-counter": "Показать счётчик неудач",
                "show-fps": "Частота кадров",
                "video-system": "Система",
                "world-map-stars-show-tip": "Отображает собранные звёзды над уровнями",
                "world-map-stars-show": "Показывать звёзды на карте мира"
            },
            "view-credits": {
                "_header": "Показать титры"
            },
            "speedrun": {
                "mode": {
                    "0": "0 (Выкл.)",
                    "1": "1 (Соврем.)",
                    "2": "2 (Классич.)",
                    "3": "3 (Ориг.)",
                    "_name": "Режим прохождения на скорость"
                }
            }
        },
        "wordBack": "Назад",
        "wordHide": "Скрыть",
        "wordNo": "Нет",
        "wordOff": "Выкл.",
        "wordOn": "Вкл.",
        "wordPlayer": "Игрок",
        "wordProfile": "Профиль",
        "wordResume": "Возобновить",
        "wordShow": "Показать",
        "wordWaiting": "Ждём",
        "wordYes": "Да"
    },
    "outro": {
        "cppPortDevelopers": "Разработчики C++-порта:",
        "customSprites": "Доп-спрайты:",
        "engineCredits": "Создатели движка:",
        "gameCredits": "Создатели игры:",
        "levelDesign": "Дизайн уровней:",
        "nameAndrewSpinks": "Эндрю Спинкс",
        "nameVitalyNovichkov": "Новичков Виталий",
        "originalBy": "Автор оригинала на VB6:",
        "psVitaPortBy": "Автор порта на PS Vita:",
        "qualityControl": "Контроль качества:",
        "specialThanks": "Особые благодарности:"
    },
    "pluralRules": "slavic"
}


================================================
FILE: resources/languages/thextech_ta.json
================================================
{
    "editor": {
        "block": {
            "canBreak": "உடையும்",
            "letterHeight": "ம",
            "letterWidth": "W",
            "canBreakTooltip": "மரபு: அடிக்கும்போது உடைகிறது",
            "inside": "உள்ளே:",
            "invis": "இன்விச்",
            "pickContents": "தொகுதி உள்ளடக்கங்களைத் தேர்ந்தெடுங்கள்",
            "slick": "மென்மை"
        },
        "events": {
            "bounds": {
                "shouldEvent": "நிகழ்வு {0}",
                "changeSectionBoundsToCurrent": "பிரிவு {0} வரம்புகளை மின்னோட்டத்திற்கு மாற்றவா?",
                "changeAllSectionBoundsToCurrent": "அனைத்து பிரிவு வரம்புகளையும் மின்னோட்டத்திற்கு மாற்றவா?"
            },
            "headerTriggerEvent": "தூண்டுதல்:",
            "itemNewEvent": "<புதிய நிகழ்வு>",
            "label": {
                "destroy": "அழிக்கவும்",
                "enter": "உள்ளிடவும்",
                "hit": "செய்",
                "layerClear": "அடுக்கு தெளிவாக",
                "next": "அடுத்தது",
                "talk": "பேச்சு",
                "activate": "செயல்படுத்து",
                "death": "இறப்பு"
            },
            "layers": {
                "headerHide": "மறை:",
                "headerMove": "நகர்த்து:",
                "headerShow": "காட்டு:",
                "headerToggle": "தடுமாறுங்கள்:"
            },
            "letter": {
                "enter": "இ:",
                "hit": "எச்:",
                "activate": "அ:",
                "death": "ம:",
                "destroy": "ஒ:",
                "layerClear": "எல்:",
                "talk": "பே:"
            },
            "promptEventName": "நிகழ்வு பெயர்",
            "promptEventText": "நிகழ்வு உரை",
            "props": {
                "controls": "கட்டுப்பாடுகள்",
                "endGame": "இறுதி விளையாட்டு",
                "layerSmoke": "புகை",
                "autostart": "ஆட்டோச்டார்ட்",
                "sound": "ஒலி"
            },
            "sections": {
                "propBackground": "பி.சி.",
                "actionKeep": "வைத்திருங்கள்",
                "actionReset": "மீட்டமை",
                "actionSet": "கணம்",
                "phraseAllSections": "அனைத்து பிரிவுகளும்",
                "propBounds": "எல்லைகள்",
                "propMusic": "இசை"
            },
            "controlsForEventN": "நிகழ்வுக்கான கட்டுப்பாடுகள் {0}",
            "deletion": {
                "cancel": "இல்லை: நிகழ்வை நீக்க வேண்டாம்",
                "confirm": "ஆம்: நிகழ்வை நீக்கு",
                "deletingEvent": "நிகழ்வை நீக்குதல் {0}"
            },
            "desc": {
                "activate": "NPC திரையில் நுழைகிறது",
                "death": "NPC இறந்துவிடுகிறது",
                "destroy": "தொகுதி அழிக்கப்படுகிறது",
                "enter": "வார்ப் நுழைந்தது",
                "hit": "தொகுதி செய் பெறுகிறது",
                "phraseTriggersAfterTemplate": "{0} தூண்டுதல்கள் {1} எம்.எச். நிகழ்வுக்குப் பிறகு {2} நிகழ்கிறது",
                "phraseTriggersWhenTemplate": "{0} {1} போது தூண்டுகிறது",
                "layerClear": "பொருள் அடுக்கில் உள்ள அனைத்தும் போய்விட்டன",
                "talk": "வீரர் NPC உடன் பேசுகிறார்"
            },
            "header": "நிகழ்வுகள்:",
            "settingsForEvent": "நிகழ்வுக்கான அமைப்புகள் {0}"
        },
        "file": {
            "actionClearLevel": "தெளிவான நிலை",
            "commandSave": "சேமி",
            "actionExit": "வெளியேறு",
            "actionOpen": "திற",
            "actionRevert": "மாற்றியமைக்கவும்",
            "commandNew": "புதிய",
            "commandOpen": "திறந்த ...",
            "commandSaveAs": "சேமி ...",
            "confirmConfirmAction": "நீங்கள் நிச்சயமாக {0} செய்ய விரும்புகிறீர்களா?",
            "confirmConvertFormatTo": "வடிவத்தை {0} ஆக மாற்றவா?",
            "formatLegacy": "மரபு",
            "optionActionWithoutSave": "{0} சேமிக்காமல்",
            "optionYesSaveThenAction": "ஆம்: சேமி {0}",
            "sectionLevel": "நிலை",
            "sectionWorld": "உலகம்",
            "actionClearWorld": "உலகத்தை அழிக்கவும்",
            "confirmSaveBeforeAction": "உங்களுக்கு முன் சேமிக்கவும் {0}?",
            "convert": {
                "descNew": "கோப்பு நீட்டிப்பு மாறும், ஆனால் பழைய கோப்பு நீக்கப்படாது.\n\n சேமித்த பிறகு இழந்த அம்சங்களை சரிபார்க்கவும்."
            },
            "formatModern": "நவீன",
            "labelCurrentFile": "தற்போதைய கோப்பு:",
            "labelFormat": "வடிவம்:",
            "optionCancelAction": "ரத்துசெய்: {0} வேண்டாம்",
            "optionCancelConversion": "மாற்றத்தை ரத்துசெய்",
            "optionProceedWithConversion": "மாற்றத்துடன் தொடரவும்"
        },
        "labelSortLayer": "வரிசை அடுக்கு:",
        "labelSortOffset": "வரிசைப்படுத்தல் ஆஃப்செட்:",
        "layers": {
            "deletion": {
                "cancel": "ரத்துசெய்: அடுக்கை நீக்க வேண்டாம்",
                "confirmDelete": "இல்லை: *எல்லா உள்ளடக்கங்களையும் நீக்கு *",
                "confirmPreserve": "ஆம்: இயல்புநிலை அடுக்குக்கு நகர்த்தவும்",
                "header": "அடுக்கு நீக்குதல் {0}",
                "preserveLayerContents": "அடுக்கு உள்ளடக்கங்களைப் பாதுகாக்கவா?"
            },
            "labelAttachedLayer": "இணைக்கப்பட்ட அடுக்கு:",
            "labelMoveLayer": "அடுக்கை நகர்த்தவும்:",
            "promptLayerName": "அடுக்கு பெயர்",
            "abbrevAttLayer": "க்கு:",
            "default": "இயல்புநிலை",
            "header": "அடுக்குகள்:",
            "itemNewLayer": "<புதிய அடுக்கு>",
            "label": "அடுக்கு:",
            "desc": {
                "att": "NPC நகரும் போதெல்லாம், இணைக்கப்பட்ட அடுக்கு அதைப் பின்பற்றுகிறது"
            },
            "labelAttached": "இணைக்கப்பட்டுள்ளது:"
        },
        "letterCoordX": "ஃச்",
        "npc": {
            "ai": {
                "target": "இலக்கு",
                "use1_0Ai": "1.0 பயன்படுத்தவா?",
                "LR": "எல்.ஆர்",
                "UD": "Ud",
                "aiIs": "AI: {0}",
                "headerCustomAi": "தனிப்பயன் AI:",
                "jump": "தாவு",
                "leap": "பாய்ச்சல்",
                "swim": "நீச்சல்"
            },
            "gen": {
                "direction": "திசை",
                "effectWarp": "வார்ப்",
                "header": "செனரேட்டர் அமைப்புகள்",
                "effectIs": "விளைவு: {0}",
                "effectShoot": "தண்டுக் கிளை"
            },
            "inContainer": "இல்",
            "abbrevGen": "கென்",
            "inertNice": "நல்லது",
            "props": {
                "active": "செயலில்",
                "attachSurface": "இணைக்கவும்",
                "facing": "எதிர்கொள்ளும்"
            },
            "stuckStop": "நிறுத்து",
            "tooltipExpandSection": "பிரிவு விரிவாக்க"
        },
        "phraseGenericIndex": "எண் {0}",
        "phraseRadiusIndex": "ஆரம் {0}",
        "phraseSectionIndex": "பிரிவு {0}",
        "phraseTextOf": "{0} உரை",
        "section": {
            "scroll": "சுருள்",
            "setBounds": "எல்லைகளை அமைக்கவும்",
            "underwater": "நீருக்கடியில்",
            "horizWrap": "மஞ்சள். மடக்கு",
            "vertWrap": "வெர்ட். மடக்கு",
            "noTurnBack": "திரும்பவில்லை",
            "offscreenExit": "ஆஃப்ச்கிரீன் வெளியேறுதல்"
        },
        "select": {
            "pathBlankUnlock": "பாதை {0} திறக்கவும்",
            "worldMusic": "உலக இசை",
            "allSectPropBlankForEventN": "{1} க்கு அனைத்து தேர்வு {0}",
            "sectBlankPropBlankForEventN": "{2} க்கு தேர்வு {0} {1}",
            "sectionBlankPropBlank": "பிரிவு {0} {1}",
            "soundForEventN": "நிகழ்வுக்கான ஒலி {0}",
            "warpTransitEffect": "வார்ப் மாற்றம் விளைவு"
        },
        "testPlay": {
            "boot": "துவக்க",
            "char": "சார்",
            "magicHand": "மேசிக் கை",
            "power": "விசை",
            "pet": "செல்லப்பிள்ளை"
        },
        "tooltip": {
            "BGOs": "BGOS",
            "NPCs": "NPCS",
            "scenes": "காட்சிகள்",
            "area": "பகுதி",
            "blocks": "தொகுதிகள்",
            "erase": "அழிக்கவும்",
            "eraseAll": "அனைத்தையும் அழிக்கவும்",
            "file": "கோப்பு",
            "events": "நிகழ்வுகள்",
            "layers": "அடுக்குகள்",
            "levels": "நிலைகள்",
            "music": "இசை",
            "paths": "பாதைகள்",
            "select": "தேர்ந்தெடு",
            "settings": "அமைப்புகள்",
            "show": "காட்டு",
            "tiles": "ஓடுகள்",
            "warps": "வார்ப்ச்",
            "water": "நீர்"
        },
        "warp": {
            "cannonExit": "பீரங்கி வெளியேறுதல்",
            "dir": "இயக்குனர்",
            "item": "உருப்படி",
            "lvlWarp": "எல்விஎல் வார்ப்",
            "showStartScene": "தொடக்க காட்சியைக் காட்டு",
            "speed": "விரைவு",
            "style": {
                "blipInstant": "தட்டச்சு",
                "door": "கதவு",
                "pipe": "புழம்பு",
                "portal": "துறைமுகம்",
                "style": "ச்டைல்:"
            },
            "transit": {
                "name2": "மங்கல்",
                "name0": "எதுவுமில்லை",
                "name1": "சுருள்",
                "name3": "வட்டம்",
                "name4": "(ம) புரட்டல்",
                "name5": "புரட்டுதல் (வி)"
            },
            "allow": "அனுமதிக்கவும்:",
            "effect": "விளைவு:",
            "in": "இல்",
            "needFloor": "தளம் தேவை",
            "needKey": "திறவுகோல் தேவை",
            "needStarCount": "{0} {1} தேவை",
            "out": "வெளியே",
            "placing": "வைப்பது:",
            "ride": "சவாரி",
            "showStarCount": "நட்சத்திர எண்ணிக்கையைக் காட்டு",
            "starLockMessage": "ச்டார் லாக் எம்.எச்.சி.",
            "target": "இலக்கு:",
            "title": "வார்ப் அமைப்புகள்",
            "to": "க்கு: {0}",
            "toMap": "வரைபடத்திற்கு",
            "twoWay": "இரு வழி"
        },
        "wordEvent": {
            "genitive": "நிகழ்வு",
            "nominative": "நிகழ்வு",
            "typeLabel": "{0} நிகழ்வு:"
        },
        "browser": {
            "itemNewFolder": "<புதிய கோப்புறை>",
            "newFile": "புதிய கோப்பு",
            "askOverwriteFile": "மேலெழுதும் {0}?",
            "itemNewFile": "<புதிய கோப்பு>",
            "openFile": "கோப்பை திற",
            "saveFile": "கோப்பை சேமி"
        },
        "letterCoordY": "ஒய்",
        "letterDown": "டி",
        "level": {
            "startPos": "POS ஐத் தொடங்குங்கள்",
            "alwaysVis": "எப்போதும் காண்",
            "bigBG": "பெரிய பின்னணி",
            "gameStart": "விளையாடத் தொடக்கு",
            "levelName": "நிலை பெயர்",
            "pathBG": "பாதை பின்னணி",
            "pathUnlocks": "பாதை திறத்தல்"
        },
        "mapPos": "வரைபடம் போச்:",
        "letterLeft": "எல்",
        "letterRight": "ஆர்",
        "letterUp": "உ",
        "pageBlankOfBlank": "{1} இன் பக்கம் {0}",
        "phraseAreYouSure": "நீங்கள் உறுதியாக இருக்கிறீர்களா?",
        "phraseCountMore": "{0} மேலும்",
        "phraseDelayIsMs": "தாமதம்: {0} எம்.எச்",
        "phraseWarpIndex": "வார்ப் {0}",
        "toggleMagicBlock": "மேசிக் தொகுதி",
        "water": {
            "title": "நீர் அமைப்புகள்"
        },
        "wordCoins": "நாணயங்கள்",
        "wordEnabled": "இயக்கப்பட்டது",
        "wordHeight": "உயரம்",
        "wordInstant": "உடனடி",
        "wordMode": "பயன்முறை",
        "wordNPC": {
            "genitive": "NPC",
            "nominative": "NPC"
        },
        "wordText": "உரை",
        "wordWidth": "அகலம்",
        "world": {
            "allowChars": "எழுத்துக்களை அனுமதிக்கவும்",
            "hubWorld": "மைய உலகம்",
            "introLevel": "அறிமுக நிலை",
            "name": "உலக பெயர்",
            "phraseCreditIndex": "உலக கடன் வரி {0}:",
            "retryOnFail": "தோல்வியுற்றதை மீண்டும் முயற்சிக்கவும்",
            "totalStars": "மொத்த நட்சத்திரங்கள்:"
        }
    },
    "game": {
        "connect": {
            "phraseDropPX": "P ஐ விடுங்கள் p {0}",
            "phraseStartToForceRes": "விண்ணப்பத்தை கட்டாயப்படுத்தத் தொடங்குங்கள்",
            "dropAddTitle": "வீரர்களை கைவிடவும்/சேர்க்கவும்",
            "phraseChangeChar": "கரியை மாற்றவும்",
            "phraseDropMe": "என்னை விடுங்கள்",
            "phraseForceResume": "படை மீண்டும் தொடங்குகிறது",
            "phraseHoldStart": "தொடக்கத்தை வைத்திருங்கள்",
            "phrasePressAButton": "ஒரு பொத்தானை அழுத்தவும்",
            "phraseSetControls": "கட்டுப்பாடுகளை அமைக்கவும்",
            "phraseTestControls": "சோதனை கட்டுப்பாடுகள்",
            "phraseStartToResume": "மீண்டும் தொடங்கத் தொடங்குங்கள்",
            "phraseTestProfile": "சோதனை சுயவிவரம்",
            "phraseWaitingForInput": "உள்ளீட்டு சாதனத்திற்காக காத்திருக்கிறது ...",
            "reconnectTitle": "மீண்டும் இணைக்கவும்",
            "splitPressSelect_1": "தேர்வு என்பதை அழுத்தவும்",
            "splitPressSelect_2": "விருப்பங்களை கட்டுப்படுத்துகிறது",
            "wordDisconnect": "துண்டிக்கவும்"
        },
        "error": {
            "errorNoStartPoint": "கிடைக்கக்கூடிய தொடக்க புள்ளிகள் அல்லது நுழைவு வார்ப் குறிப்பிடப்படாததால் மட்டத்தைத் தொடங்க முடியாது.\n\n கோப்பு: {0}",
            "errorInvalidEnterWarp": "தவறான நுழைவு வார்ப் {1} குறிப்பிடப்பட்டதால் மட்டத்தைத் தொடங்க முடியாது.\n மொத்த வார்ப் உள்ளீடுகள்: {2}\n\n கோப்பு: {0}",
            "openFileFailed": "\"{0}\" ஐ திறக்க முடியாது: கோப்பு இல்லை அல்லது சிதைக்கப்படவில்லை.",
            "warpNeedStarCount": "நுழைய உங்களுக்கு {0} {1} தேவை.",
            "errorTooOldGameAssets": "உள்ளடக்கத்திற்கு தற்போதைய சொத்து தொகுப்பை ({1}) விட புதிய சொத்து தொகுப்பு அம்ச நிலை ({0}) தேவை. உங்கள் கேம் அசெட் பேக்கை மேம்படுத்தவும்.",
            "openIPCDataFailed": "ஊழல் அல்லது பிற பிழைகள் காரணமாக பெறப்பட்ட கோப்புத் தரவைத் தொடர முடியாது.",
            "IPCTimeOut": "இணைக்கப்பட்ட எடிட்டரிடமிருந்து பதில் இல்லை. விளையாட்டு மூடப்படும்.",
            "errorTooOldEngine": "உள்ளடக்கத்திற்கு தற்போதைய பதிப்பை ({1}) விட புதிய எஞ்சின் அம்ச நிலை ({0}) தேவை. தயவுசெய்து TheXTech ஐப் புதுப்பிக்கவும்."
        },
        "message": {
            "scanningLevels": "அளவை ச்கேனிங் ..."
        },
        "format": {
            "minutesSeconds": "{0} m {1} s"
        },
        "msgbox": {
            "sysInfoError": "பிழை!",
            "sysInfoTitle": "தகவல்",
            "sysInfoWarning": "எச்சரிக்கை!"
        },
        "hint": {
            "pound-altrun": "கீழ்நோக்கி பவுண்டுக்கு ஆல்ட் ரன் அழுத்தவும்!",
            "pound-down": "கீழ்நோக்கி பவுண்டுக்கு கீழே அழுத்தவும்!",
            "no-lives-new": "நாணயங்கள் எதுவும் இல்லை? கடன் எடுத்துக் கொள்ளுங்கள்! உங்கள் மதிப்பெண்ணைப் பாருங்கள் ...",
            "no-lives-old": "கவனமாக இருங்கள் - கேம் ஓவர் உடனடி!",
            "rainbow-surf": "பிடிக்கவும், ஓடுங்கள், பிடிக்கவும், சர்ஃப் செல்லவும்.",
            "char5-bombs": "சேகரிக்க ரன் அழுத்தவும், வீசவும் ஆல்ட் ரன்.",
            "heavy-duck": "பெரும்பாலானவர்களைத் தடுக்க வாத்து - ஆனால் அனைத்தும் இல்லை - தீப்பிழம்புகள்!",
            "shoe-block": "இந்த தொகுதிகளை மிகவும் அணிந்துகொள்வது - ஆனால் அனைத்தும் இல்லை - தீப்பிழம்புகள்!",
            "gray-bricks": "சில தொகுதிகள் சிறப்பு சக்திகளுக்கு பாதிக்கப்படக்கூடியவை."
        },
        "pause": {
            "continue": "தொடரவும்",
            "playerSetup": "பிளேயர் அமைப்பு",
            "enterCode": "குறியீட்டை உள்ளிடவும்",
            "quit": "வெளியேறு",
            "quitTesting": "பரிசோதனையை விட்டுவிடுங்கள்",
            "resetCheckpoints": "சோதனைச் சாவடிகளை மீட்டமைக்கவும்",
            "restartLevel": "அளவை மறுதொடக்கம் செய்யுங்கள்",
            "returnToEditor": "எடிட்டருக்குத் திரும்பு",
            "saveAndContinue": "சேமித்து தொடரவும்",
            "saveAndQuit": "சேமித்து வெளியேறவும்"
        },
        "screenPaused": "இடைநிறுத்தப்பட்டது",
        "loader": {
            "statusLoadData": "தரவை ஏற்றுகிறது...",
            "statusGameInfo": "விளையாட்டு செய்தி",
            "statusLoadFile": "ஏற்ற: {0}",
            "statusFinishing": "முடிக்கிறது...",
            "statusAssetPacks": "சொத்து தொகுப்புகள்",
            "statusTranslations": "மொழிபெயர்ப்புகள்",
            "loading": "ஏற்றுகிறது..."
        },
        "ipcStatus": {
            "loadingdone": "முடிந்தது. ஆட்டம் தொடங்குகிறது...",
            "dataAccepted": "தரவு ஏற்றுக்கொள்ளப்பட்டது, பாகுபடுத்தல் தொடங்கியது...",
            "dataTransferStarted": "தரவு பரிமாற்றத்தைத் தொடங்கு...",
            "errorTimeout": "பிழை: நேரம் முடிந்தது.",
            "dataValid": "ஏற்றுக்கொள்ளப்பட்ட தரவு செல்லுபடியாகும்",
            "waitingInput": "உள்ளீட்டு தரவுக்காக காத்திருக்கிறது..."
        }
    },
    "menu": {
        "controls": {
            "buttons": {
                "down": "கீழே",
                "altJump": "ஆல்ட் சம்ப்",
                "altRun": "அனைத்து ரன்",
                "drop": "உருப்படியை கைவிடுங்கள்",
                "jump": "தாவு",
                "left": "இடது",
                "right": "வலது",
                "run": "ஓடு",
                "start": "தொடங்கு",
                "up": "மேலே"
            },
            "controlsReallyDeleteProfile": "உண்மையில் சுயவிவரத்தை நீக்கவா?",
            "controlsTitle": "கட்டுப்பாடுகள்",
            "hotkeys": {
                "legacyPause": "பழைய இடைநிறுத்தம்",
                "vanillaCam": "வெண்ணிலா கேம்",
                "debugInfo": "பிழைத்திருத்த செய்தி",
                "enterCheats": "குறியீட்டை உள்ளிடவும்",
                "fullscreen": "முழு திரை",
                "recordGif": "பதிவு gif",
                "screenshot": "திரைக்காட்சி",
                "toggleHUD": "HUD ஐ மாற்றவும்"
            },
            "options": {
                "batteryStatus": "பேட்டர் நிலை",
                "maxPlayers": "எம்எக்ச் பிளேயர்",
                "rumble": "ரம்பிள்",
                "textEntryStyle": "உரை நுழைவு நடை",
                "altMenuControls": "மாற்று பட்டியல் கட்டுப்பாடுகள்"
            },
            "tDS": {
                "buttonR": "ஆர்",
                "buttonSelect": "தேர்ந்தெடு",
                "buttonStart": "தொடங்கு",
                "buttonZR": "Zr",
                "cStick": "சி-ச்டிக்",
                "buttonA": "ஏ",
                "buttonB": "பி",
                "buttonL": "எல்",
                "buttonX": "ஃச்",
                "buttonY": "ஒய்",
                "buttonZL": "Zl",
                "casePen": "(பேனா)",
                "dPad": "டி-பேட்",
                "tStick": "கட்டைவிரல்"
            },
            "touchscreen": {
                "option": {
                    "interfaceStyle": "இடைமுக நடை",
                    "layoutStyle": "தளவமைப்பு நடை",
                    "resetLayout": "தளவமைப்பை மீட்டமைக்கவும்",
                    "feedbackLength": "கருத்து நீளம்",
                    "holdRun": "தொடக்கத்தில் ரன் வைத்திருங்கள்",
                    "feedbackStrength": "கருத்து வலிமை",
                    "sStartSpacing": "எச்-ச்டார்ட் இடைவெளி",
                    "scaleButtons": "அளவிலான பொத்தான்கள்",
                    "scaleFactor": "அளவிலான காரணி",
                    "scaleDPad": "அளவிலான டி-பேட்",
                    "showCodeButton": "குறியீடு பொத்தானைக் காட்டு"
                },
                "layout": {
                    "phoneOld": "தொலைபேசி (பழையது)",
                    "standard": "தரநிலை",
                    "longOld": "நீண்ட (பழைய)",
                    "phabletOld": "பேப்லெட் (பழைய)",
                    "tabletOld": "டேப்லெட் (பழையது)",
                    "tight": "இறுக்கமான",
                    "tinyOld": "சிறிய (பழைய)"
                },
                "style": {
                    "ABXY": "Abxy",
                    "XODA": "காட்",
                    "actions": "செயல்கள்"
                }
            },
            "wii": {
                "classic": {
                    "buttonLT": "Lt",
                    "lStick": "எல்-பேட்",
                    "buttonRT": "Rt",
                    "buttonX": "ஃச்",
                    "buttonY": "ஒய்",
                    "buttonZL": "Zl",
                    "buttonZR": "Zr",
                    "rStick": "ஆர்-பேட்"
                },
                "phraseNewClassic": "புதிய கிளாசிக் சுயவிவரம்",
                "phraseNewNunchuck": "புதிய நன்சக் சுயவிவரம்",
                "typeClassic": "கிளாசிக்",
                "wiimote": {
                    "buttonB": "பி",
                    "buttonHome": "வீடு",
                    "buttonMinus": "-",
                    "buttonPlus": "+",
                    "button1": "1",
                    "button2": "2",
                    "buttonA": "ஏ",
                    "caseIR": "(மற்றும்)",
                    "dPad": "டி-பேட்",
                    "shake": "குலுக்கல்"
                },
                "nunchuck": {
                    "buttonC": "சி",
                    "buttonZ": "சட்",
                    "prefixN": "என்"
                },
                "typeNunchuck": "சங்கிலித் தண்டுகள்",
                "typeWiimote": "வைமோட்",
                "typeGamecube": "கேம்க்யூப்"
            },
            "caseInvalid": "(தவறானது)",
            "caseMouse": "(சுட்டி)",
            "caseTouch": "(தொடு)",
            "controlsConnected": "இணைக்கப்பட்டுள்ளது:",
            "controlsDeleteKey": "(நீக்க ஆல்ட் சம்ப்)",
            "controlsDeleteKey2": "(நீக்க அனைத்து ரன்)",
            "controlsDeviceTypes": "சாதன வகைகள்",
            "controlsInUse": "(பயன்பாட்டில்)",
            "controlsNewProfile": "<புதிய சுயவிவரம்>",
            "controlsNotInUse": "(பயன்பாட்டில் இல்லை)",
            "cursor": {
                "down": "சுட்டி கீழே",
                "right": "சுட்டி சரியானது",
                "secondary": "இரண்டாம் நிலை",
                "left": "சுட்டி இடது",
                "primary": "முதன்மை",
                "tertiary": "மூன்றாம் நிலை",
                "up": "சுட்டி அப்"
            },
            "editor": {
                "fastScroll": "வேகமான scrl",
                "modeSelect": "பயன்முறை தேர்ந்தெடுக்கவும்",
                "nextSection": "அடுத்த பிரிவு",
                "prevSection": "முந்தைய பிரிவு",
                "scrollDown": "Scrl கீழே",
                "scrollLeft": "Scrl இடது",
                "scrollRight": "Scrl சரி",
                "modeErase": "பயன்முறை அழித்தல்",
                "scrollUp": "Scrl மேலே",
                "switchScreens": "பலகம் காட்டு",
                "testPlay": "சோதனை நாடகம்"
            },
            "phraseNewProfOldJoy": "பழைய சாய்ச்டிக் புதிய சுயவிவரம்",
            "profile": {
                "cursorControls": "கர்சர் கட்டுப்பாடுகள்",
                "deleteProfile": "சுயவிவரத்தை நீக்கு",
                "editorControls": "ஆசிரியர் கட்டுப்பாடுகள்",
                "hotkeys": "ஆட்கீச்",
                "playerControls": "பிளேயர் கட்டுப்பாடுகள்",
                "renameProfile": "சுயவிவரத்தை மறுபெயரிடுங்கள்"
            },
            "joystickSimpleEditor": "எளிய எடிட்டர் கட்டுப்பாடுகள்",
            "types": {
                "oldJoystick": "பழைய மகிழ்ச்சி",
                "gamepad": "கேம்பேட்",
                "keyboard": "விசைப்பலகை",
                "touchscreen": "தொடுதிரை"
            },
            "wordProfiles": "சுயவிவரங்கள்",
            "wordButtons": "பொத்தான்கள்"
        },
        "game": {
            "gameBattleRandom": "சீரற்ற நிலை",
            "gameCopySave": "சேமி நகல்",
            "gameEraseSave": "சேமி",
            "phraseTime": "நேரம்: {0}",
            "gameEraseSlot": "அழிக்க ச்லாட்டைத் தேர்ந்தெடுக்கவும்",
            "gameNoBattleLevels": "<போர் நிலைகள் இல்லை>",
            "gameNoEpisodesToPlay": "<விளையாடுவதற்கு அத்தியாயங்கள் இல்லை>",
            "warnEpCompat": "இந்த அத்தியாயம் SMBX இன் வேறு கிளைக்காக உருவாக்கப்பட்டது மற்றும் சரியாக வேலை செய்யாமல் போகலாம்.",
            "gameSlotContinue": "ச்லாட் {0} ... {1}%",
            "gameSlotNew": "ச்லாட் {0} ... புதிய விளையாட்டு",
            "gameSourceSlot": "மூல ச்லாட்டைத் தேர்ந்தெடுக்கவும்",
            "gameTargetSlot": "இப்போது இலக்கைத் தேர்ந்தெடுக்கவும்",
            "phraseScore": "ச்கோர்: {0}"
        },
        "loading": "ஏற்றுகிறது ...",
        "options": {
            "advanced": {
                "_header": "மேம்பட்ட",
                "_tooltip": "உள் செயல்பாடுகளுக்கான தொழில்நுட்ப விருப்பங்கள்",
                "audio-buffer-size": {
                    "_tooltip": "குறைவான பாப்சுக்கு அதிகரிப்பு ஆனால் அதிக பின்னடைவு",
                    "_name": "இடையக அளவு"
                },
                "audio-channels": {
                    "_name": "சேனல்கள்",
                    "mono": "மோனோ",
                    "stereo": "ச்டீரியோ"
                },
                "audio-enable": "இயக்கு",
                "audio-sample-rate": {
                    "16000": "16000 எர்ட்ச்",
                    "22050": "22050 எர்ட்ச்",
                    "_name": "மாதிரி வீதம்",
                    "11025": "11025 எர்ட்ச்",
                    "32000": "32000 எர்ட்ச்",
                    "44100": "44100 எர்ட்ச்",
                    "48000": "48000 எர்ட்ச்"
                },
                "log-level": {
                    "warning": "எச்சரிக்கை",
                    "_name": "பதிவு நிலை",
                    "critical": "விமர்சன",
                    "debug": "பிழைத்திருத்தம்",
                    "fatal": "அபாயகரமான",
                    "info": "தகவல்",
                    "none": "எதுவுமில்லை"
                },
                "record-gameplay-data": "விளையாட்டுப் பதிவு",
                "render": {
                    "hw": "தானி",
                    "opengl": "Opengl 3+",
                    "opengl11": "Opengl 1.1",
                    "_name": "பயன்முறையை வழங்கவும்",
                    "opengl-tip": "அனைத்து புதிய காட்சி விளைவுகளுக்கும் ஆதரவுடன் டெச்க்டாப் பநிஇ மற்றும் SMBX64 க்கு முழு துல்லியம்",
                    "opengl11-tip": "SMBX64 க்கு முழு துல்லியத்துடன் மரபு டெச்க்டாப் பநிஇ",
                    "opengles": "ஓபன்சிஎல் 2+ ஆகும்",
                    "opengles-tip": "அனைத்து புதிய காட்சி விளைவுகளுக்கும் ஆதரவுடன் மொபைல் பநிஇ மற்றும் SMBX64 க்கு அதிக துல்லியம்",
                    "opengles11": "ஓபன்சிஎல் 1.1+ ஆகும்",
                    "opengles11-tip": "SMBX64 க்கு முழு துல்லியத்துடன் மரபு மொபைல் பநிஇ",
                    "sdl": "SDL2",
                    "sdl-tip": "அடிப்படை குறுக்கு-தளம் வழங்கல் பநிஇ",
                    "sw": "மென்பொருள்"
                },
                "scale-down-textures": {
                    "none": "எதுவுமில்லை",
                    "_tooltip": "நினைவகத்தை சேமிக்க படங்களை 1x ஆக சேமிக்கவும்",
                    "all": "அனைத்தும்",
                    "all-tip": "'பாதுகாப்பானது' என்பதை விட குறைவான ஏற்றுதல் திணறல்",
                    "_name": "படங்களை அளவிடவும்",
                    "none-tip": "குறைந்தது ஏற்றுதல் திணறல்",
                    "safe": "பாதுகாப்பானது",
                    "safe-tip": "படங்கள் 2x வடிவத்தில் இருந்தால் சரிபார்க்கிறது"
                },
                "inaccurate-gifs-tip": "GIF கள் இருக்கும்போது 3D விளைவை அனுமதிக்கிறது",
                "choose-assets-on-launch": "துவக்கத்தில் சொத்துக்களைத் தேர்வுசெய்க",
                "advanced-audio": "ஆடியோ",
                "advanced-video": "ஒளிதோற்றம்",
                "audio-format": {
                    "_name": "ஆடியோ வடிவம்",
                    "_tooltip": "ஒலி இயக்கி வடிவம்"
                },
                "use-native-osk": "சொந்த ஓச்க்",
                "inaccurate-gifs": "தவறான GIF கள்",
                "webm-recording": "வெப்எம் பதிவு",
                "internal-res-4p": {
                    "_name": "4p பிளவு திரை அளவு",
                    "default": "இயல்புநிலை",
                    "fhd": "1920x1080 (FHD)",
                    "qhd": "2560x1440 (QHD)",
                    "qsmbx": "1600x1200 (QSMBX)"
                },
                "fullscreen-type": {
                    "_name": "முழுத்திரை வகை",
                    "auto": "தானி",
                    "desktop": "டெச்க்டாப்",
                    "desktop-tip": "தற்போதைய திரை தெளிவுத்திறனை வைத்திருங்கள்",
                    "exclusive": "பிரத்தியேக",
                    "exclusive-tip": "உடல் திரை தெளிவுத்திறனை அமைக்கவும்"
                },
                "fullscreen-depth": {
                    "16": "16-பிட்",
                    "32": "32-பிட்",
                    "_name": "பிரத்யேக பிட் ஆழம்",
                    "auto": "தானி"
                },
                "fullscreen-res": "பிரத்யேக ரெச்"
            },
            "audio": {
                "sfx-spatial-audio-tip": "ஆஃப்ச்கிரீன் ஒலிகளின் அளவைக் குறைக்கவும்",
                "_header": "ஆடியோ",
                "audio-music-volume": "இசை தொகுதி",
                "audio-prefs": "விருப்பத்தேர்வுகள்",
                "audio-sfx-volume": "SFX தொகுதி",
                "sfx-audio-fx": "எதிரொலி விளைவுகள்",
                "sfx-modern": "நவீன எச்.எஃப்.எக்ச்",
                "sfx-modern-tip": "Textech இல் சேர்க்கப்பட்ட ஒலிகளைப் பயன்படுத்தவும்",
                "sfx-pet-beat": "செல்லப்பிராணி பள்ளங்கள்",
                "sfx-spatial-audio": "இடஞ்சார்ந்த ஆடியோ",
                "sfx-pet-beat-tip": "செல்லப்பிராணியை சவாரி செய்யும் போது சிறப்பு பள்ளம் விளையாடுங்கள்"
            },
            "episode-options": {
                "creator-compat": {
                    "disable": "முடக்கு",
                    "_name": "படைப்பாளி இணைத்தல்",
                    "_tooltip": "உள்ளடக்க படைப்பாளரின் வழக்கு மாற்றங்கள்",
                    "enable": "இயக்கு",
                    "file-only": "கோப்பு மட்டுமே"
                },
                "playstyle": {
                    "_name": "பிளேச்டைல்",
                    "classic-tip": "குறைந்தபட்ச புதுப்பிப்புகள்",
                    "classic": "கிளாசிக்",
                    "modern": "நவீன",
                    "modern-tip": "அனைத்து புதுப்பிப்புகளும்",
                    "vanilla": "வெண்ணிலா",
                    "vanilla-tip": "புதுப்பிப்புகள் இல்லை"
                },
                "_header": "அத்தியாயம் விருப்பங்கள்",
                "hub-resume": "வார்ப் அப்பில் சேமிக்கவும்",
                "hub-resume-tip": "நீங்கள் நுழைந்த கடைசி போரில் மீண்டும் விளையாடுங்கள்"
            },
            "main": {
                "background-work": "பின்னணியில் இயக்கவும்",
                "four-screen-mode": {
                    "split": "பிளவு",
                    "_name": "4p திரை பயன்முறை",
                    "shared": "பகிரப்பட்டது"
                },
                "multiplayer": "மல்டிபிளேயர்",
                "timing": "சட்ட நேரம்",
                "_header": "முக்கிய",
                "background-work-tip": "விளையாட்டு கவனம் செலுத்தாமல் இருக்கும்போது சாய்ச்டிக் உடன் விளையாடுங்கள்",
                "frame-skip": "பிரேம்கிப்",
                "discord-rpc": "முரண்பாடு ஒருங்கிணைப்பு",
                "language": "மொழி",
                "two-screen-mode": {
                    "_name": "2p திரை பயன்முறை",
                    "shared": "பகிரப்பட்டது",
                    "smbx": "SMBX",
                    "split": "இடது/வலது",
                    "topbottom": "மேல்/கீழ்"
                },
                "unlimited-framerate": "வரம்பற்ற ஃப்ரேம்ரேட்",
                "vsync": "வி-ஒத்திசைவு"
            },
            "video": {
                "battery-status": {
                    "off": "அணை",
                    "_name": "சாதன பேட்டரி நிலை",
                    "fullscreen": "முழு திரை",
                    "fullscreen-tip": "விளையாட்டு முழுத்திரையாக இருக்கும்போது காண்பி",
                    "low": "குறைந்த",
                    "low-tip": "பேட்டரி குறைவாக இருக்கும்போது காண்பி",
                    "on": "எப்போதும்"
                },
                "internal-res": {
                    "3ds": "800x480 (3DS)",
                    "_name": "திரை அளவு",
                    "_tooltip": "விளையாட்டு புலத்தின் தீர்மானம்",
                    "dynamic": "மாறும்",
                    "gba": "480x320 (பெறுங்கள்)",
                    "hd": "1280x720 (எச்டி)",
                    "hello": "768x432 (அலோ)",
                    "nds": "512x384 (என்.டி.எச்)",
                    "smbx": "800x600 (SMBX)",
                    "snes": "512x448 (SNES)",
                    "smbx-wide": "SMBX (அகலம்)",
                    "vga": "640x480 (விசிஏ)"
                },
                "scale-mode": {
                    "0_5x": "0.5x",
                    "1x": "1x",
                    "_name": "அளவிலான பயன்முறை",
                    "integer": "முழு எண்",
                    "linear": "மென்மையான",
                    "nearest": "அருகில்",
                    "2x": "ஃச்",
                    "full": "முழு",
                    "center": "நடுவண்",
                    "3x": "Zks"
                },
                "show-episode-title": {
                    "off": "அணை",
                    "top": "மேலே",
                    "top-tip": "உயர் தெளிவுத்திறனில் HUD க்கு மேலே காண்பி",
                    "_name": "அத்தியாயம் பெயர்",
                    "bottom": "கீழே",
                    "bottom-tip": "ச்பீட்ரன் டைமருக்கு மேலே காட்டவும்"
                },
                "3d-compat-mode": "3D இணைத்தல் பயன்முறை",
                "show-medals-counter-tip": "HUD மற்றும் நிலை நுழைவாயிலில் பதக்கங்களைக் காட்டு",
                "show-playtime-counter": {
                    "animated-tip": "நிலை முடிவில் வானவில் விளைவைச் சேர்க்கிறது",
                    "_name": "பிளே டைம் கவுண்டர்",
                    "_tooltip": "அத்தியாயம் மற்றும் தற்போதைய முயற்சியில் செலவழித்த நேரத்தைக் காட்டு",
                    "animated": "அனிமேசன்",
                    "off": "அணை",
                    "off-tip": "ச்பீட்ரன்களின் போது மட்டுமே காட்டு",
                    "opaque": "ஒளிபுகா",
                    "transparent": "வெளிப்படையானது"
                },
                "_header": "ஒளிதோற்றம்",
                "effects": "திரை விளைவுகள்",
                "display-controllers": "செயல்பாட்டைக் கட்டுப்படுத்துகிறது",
                "enable-inter-level-fade-effect": "மங்கலான மாற்றங்கள்",
                "fullscreen": "முழு திரை",
                "info-game": "திரை விளையாட்டு செய்தி",
                "info-meta": "திரை மேவு செய்தி",
                "info-run": "திரை ரன் செய்தி",
                "3d-compat-mode-tip": "அனைத்து பொருட்களையும் ஒரு 3D விமானத்தில் வரையவும்",
                "show-fails-counter": "எதிர் தோல்வி",
                "show-fails-counter-tip": "அத்தியாயம் மற்றும் தற்போதைய மட்டத்தில் சோ தோல்வியடைகிறது",
                "show-fps": "பிரேம்ரேட்",
                "show-medals-counter": "பதக்கங்கள் கவுண்டர்",
                "show-screen-shake": "திரை குலுக்கல்",
                "video-system": "மண்டலம்",
                "world-map-stars-show": "உலக வரைபட நட்சத்திரங்கள்",
                "world-map-stars-show-tip": "சேகரிக்கப்பட்ட நட்சத்திரங்களை மட்டங்களுக்கு மேலே காட்டு"
            },
            "speedrun": {
                "mode": {
                    "0": "0",
                    "1": "1",
                    "2": "2",
                    "3": "3",
                    "_name": "ச்பீட்ரன் பயன்முறை"
                }
            },
            "restartEngine": "மாற்றங்கள் நடைமுறைக்கு வர இயந்திரத்தை மறுதொடக்கம் செய்யுங்கள்.",
            "compatibility": {
                "_header": "அமர்வு மாற்றங்கள்",
                "_tooltip": "இணைத்தல் அல்லது பிழைத்திருத்தத்திற்கான விருப்பங்கள்",
                "autocode": "ஆட்டோகோட்",
                "bugfixes": "பிழைத்திருத்தங்கள்",
                "features": "நற்பொருத்தங்கள்",
                "reset-all": "அனைத்தையும் மீட்டமைக்கவும்"
            },
            "controls": {
                "_header": "கட்டுப்பாடுகள்"
            },
            "view-credits": {
                "_header": "வரவுகளைக் காண்க"
            }
        },
        "wordYes": "ஆம்",
        "abbrevMilliseconds": "எம்.எச்",
        "battle": {
            "errorNoLevels": "எந்த நிலைகளும் கிடைக்காததால் போரைத் தொடங்க முடியாது"
        },
        "caseNone": "<இல்லை>",
        "character": {
            "selectCharacter": "{0} விளையாட்டு"
        },
        "editor": {
            "errorMissingResources": "மன்னிக்கவும்! விளையாட்டு எடிட்டருக்கு தேவைப்படும் {0} ஐ நீங்கள் காணவில்லை.",
            "battles": "<போர் நிலைகள்>",
            "makeFor": "செய்யுங்கள்:",
            "newWorld": "<புதிய உலகம்>",
            "promptNewWorldName": "புதிய உலக பெயர்"
        },
        "main": {
            "main1PlayerGame": "1 பிளேயர் விளையாட்டு",
            "mainBattleGame": "போர் விளையாட்டு",
            "mainEditor": "திருத்தி",
            "mainExit": "வெளியேறு",
            "mainMultiplayerGame": "2 பிளேயர் விளையாட்டு",
            "mainOptions": "விருப்பங்கள்",
            "mainPlayEpisode": "அத்தியாயம் விளையாடுங்கள்"
        },
        "wordBack": "பின்",
        "wordHide": "மறை",
        "wordNo": "இல்லை",
        "wordOff": "அணை",
        "wordOn": "ஆன்",
        "wordPlayer": "வீரர்",
        "wordProfile": "சுயவிவரம்",
        "wordResume": "மீண்டும் தொடங்குங்கள்",
        "wordShow": "காட்டு",
        "wordWaiting": "காத்திருக்கிறது"
    },
    "outro": {
        "engineCredits": "இயந்திர வரவு:",
        "nameVitalyNovichkov": "விட்டலி நோவாச்ச்கோவ்",
        "cppPortDevelopers": "சி ++ துறைமுகம் டெவலப்பர்கள்:",
        "customSprites": "தனிப்பயன் உருவங்கள்:",
        "gameCredits": "விளையாட்டு வரவு:",
        "levelDesign": "நிலை வடிவமைப்பு:",
        "nameAndrewSpinks": "ஆண்ட்ரூ சூரரிமாச்சிலை",
        "originalBy": "அசல் விபி 6 குறியீடு:",
        "psVitaPortBy": "பி.எச். வீடா போர்ட்:",
        "qualityControl": "தரக் கட்டுப்பாடு:",
        "specialThanks": "சிறப்பு நன்றி:"
    },
    "pluralRules": "ஒன்று-ஒற்றை",
    "languageName": "தமிழ்"
}


================================================
FILE: resources/languages/thextech_tr.json
================================================
{
    "editor": {
        "block": {
            "canBreak": "Kırılabilir",
            "canBreakTooltip": "Legacy: vurunca kırılır",
            "inside": "İçinde:",
            "invis": "Görmez",
            "letterHeight": "Y",
            "letterWidth": "G",
            "pickContents": "Blok içeriği seç",
            "slick": "Kaygan"
        },
        "browser": {
            "askOverwriteFile": "Üzerine Yaz {0}?",
            "itemNewFile": "<Yeni Dosya>",
            "itemNewFolder": "<Yeni Klâsör>",
            "newFile": "Yeni dosya",
            "openFile": "Dosyayı aç",
            "saveFile": "Dosyayı kaydet"
        },
        "events": {
            "bounds": {
                "changeAllSectionBoundsToCurrent": "Bütün kısımları buna dönüştür?",
                "changeSectionBoundsToCurrent": "{0} kısımının ayarlarını buna bağla?",
                "shouldEvent": "{0} Olayı Şunu Yapmalı Mı"
            },
            "controlsForEventN": "'{0}' olayı için kontroller",
            "deletion": {
                "cancel": "Hayır: olayı silme",
                "confirm": "Evet: olayı sil",
                "deletingEvent": "{0} olayı siliniyor"
            },
            "desc": {
                "activate": "NPC ekrana girer",
                "death": "NPC ölür",
                "destroy": "blok yok edildi",
                "enter": "ışınlanma girildi",
                "hit": "bloğa vurulduğunda",
                "layerClear": "obje katmanındaki her şey temizlendiğinde",
                "phraseTriggersAfterTemplate": "{2} yaşandıktan ms sonra {0} etkinleştirir {1}'i",
                "phraseTriggersWhenTemplate": "{1} {0}'i etkinleştir",
                "talk": "NPC ile konuşulduğunda"
            },
            "header": "Olaylar:",
            "headerTriggerEvent": "Etkinleştir:",
            "itemNewEvent": "<Yeni Olay>",
            "label": {
                "activate": "Aktifleştir",
                "death": "Ölüm",
                "destroy": "Yok Et",
                "enter": "Giriş",
                "hit": "Vuruldu",
                "layerClear": "Katmanı Temizle",
                "next": "Sonraki",
                "talk": "Konuş"
            },
            "layers": {
                "headerHide": "Gizle:",
                "headerMove": "Hareket Ettir:",
                "headerShow": "Göster:",
                "headerToggle": "Geçiş Yap:"
            },
            "letter": {
                "activate": "A:",
                "death": "Ö:",
                "destroy": "Y:",
                "enter": "G:",
                "hit": "V:",
                "layerClear": "Ka:",
                "talk": "Ko:"
            },
            "promptEventName": "Olay adı",
            "promptEventText": "Olay metni",
            "props": {
                "autostart": "OtoBaşla",
                "controls": "Kontroller",
                "endGame": "Oyun sonu",
                "sound": "Ses",
                "layerSmoke": "Duman"
            },
            "sections": {
                "actionKeep": "Tut",
                "actionReset": "Sıfırla",
                "actionSet": "Ayarla",
                "phraseAllSections": "Bütün Kısımlar",
                "propBackground": "AP",
                "propBounds": "Sınırlar",
                "propMusic": "Müzik"
            },
            "settingsForEvent": "{0} olayının ayarları"
        },
        "file": {
            "actionClearLevel": "Seviyeyi Temizle",
            "actionClearWorld": "Dünyayı Temizle",
            "actionExit": "Çıkış",
            "actionOpen": "Aç",
            "actionRevert": "Geri Al",
            "commandNew": "Yeni",
            "commandOpen": "Aç...",
            "commandSave": "Kaydet",
            "commandSaveAs": "Farklı Kaydet...",
            "confirmConfirmAction": "{0} yapmak istediğine emin misin?",
            "confirmConvertFormatTo": "{0} formatına dönüştürülsün mü?",
            "confirmSaveBeforeAction": "{0} yapmadan kaydet?",
            "formatLegacy": "Legacy",
            "formatModern": "Modern",
            "labelCurrentFile": "Şu anki dosya:",
            "labelFormat": "Biçim:",
            "optionActionWithoutSave": "Kaydetmeden {0}",
            "optionCancelAction": "İptal: {0} yapma",
            "optionCancelConversion": "Dönüştürmeyi iptal et",
            "optionProceedWithConversion": "Dönüştürmeye devam et",
            "optionYesSaveThenAction": "Evet: kaydet ve {0}",
            "sectionLevel": "Seviye",
            "sectionWorld": "Dünya",
            "convert": {
                "descNew": "Dosya uzantısı değişecek ama eski dosya SİLİNMEYECEK.\n\nLütfen kaydettikten sonra kaybolmuş özelliklere bakın."
            }
        },
        "layers": {
            "abbrevAttLayer": "Takılı: ",
            "default": "Varsayılan",
            "deletion": {
                "cancel": "İptal: katmanı silme",
                "confirmDelete": "Hayır: *BÜTÜN İÇERİĞİ SİL*",
                "confirmPreserve": "Evet: varsayılan katmana taşı",
                "header": "{0} katmanı siliniyor",
                "preserveLayerContents": "Katman içeriği korunsun mu?"
            },
            "desc": {
                "att": "NPC hareket ettiği zaman bağlı olduğu katman onu takip eder"
            },
            "header": "Katmanlar:",
            "itemNewLayer": "<Yeni Katman>",
            "label": "Katman:",
            "labelAttached": "Bağlı Olduğu:",
            "labelAttachedLayer": "Bağlı Olduğu Katman:",
            "labelMoveLayer": "Katmanı Hareket Ettir:",
            "promptLayerName": "Katman adı"
        },
        "letterCoordX": "X",
        "letterCoordY": "Y",
        "letterDown": "A",
        "letterLeft": "So",
        "letterRight": "Sa",
        "letterUp": "Y",
        "level": {
            "alwaysVis": "Hep Görün",
            "bigBG": "Büyük AP",
            "gameStart": "Oyun Başlar",
            "levelName": "Seviye İsmi",
            "pathBG": "Yol AP",
            "pathUnlocks": "Yol Anahtarları",
            "startPos": "Başlangıç Pozisyonu"
        },
        "mapPos": "Harita Pozisyonu",
        "npc": {
            "abbrevGen": "Üret",
            "ai": {
                "LR": "SağSol",
                "UD": "YukAş",
                "aiIs": "AI: {0}",
                "headerCustomAi": "Custom AI:",
                "jump": "Atla",
                "leap": "Sıçra",
                "swim": "Yüz",
                "target": "Hedef",
                "use1_0Ai": "1.0 AI Kullan"
            },
            "gen": {
                "direction": "Yönü",
                "effectIs": "Efekt: {0}",
                "effectShoot": "Ateşle",
                "effectWarp": "Işınla",
                "header": "Jeneratör Ayarları"
            },
            "inContainer": "İçi",
            "inertNice": "Dost",
            "props": {
                "active": "",
                "attachSurface": "",
                "facing": "Yönü"
            },
            "stuckStop": "Dur",
            "tooltipExpandSection": "Kısmı Genişlet"
        },
        "pageBlankOfBlank": "Sayfa {0} de {1}",
        "phraseAreYouSure": "Emin misin?",
        "phraseCountMore": "{0} Daha",
        "phraseDelayIsMs": "{0} ms Ertele",
        "phraseRadiusIndex": "",
        "phraseSectionIndex": "Kısım {0}",
        "phraseTextOf": "",
        "phraseWarpIndex": "",
        "section": {
            "horizWrap": "",
            "noTurnBack": "",
            "offscreenExit": "",
            "scroll": "",
            "setBounds": "",
            "underwater": "",
            "vertWrap": ""
        },
        "select": {
            "allSectPropBlankForEventN": "",
            "pathBlankUnlock": "",
            "sectBlankPropBlankForEventN": "",
            "sectionBlankPropBlank": "",
            "soundForEventN": "",
            "warpTransitEffect": "",
            "worldMusic": ""
        },
        "testPlay": {
            "boot": "",
            "char": "",
            "magicHand": "",
            "pet": "",
            "power": ""
        },
        "toggleMagicBlock": "Büyülü Blok",
        "tooltip": {
            "BGOs": "",
            "NPCs": "",
            "blocks": "",
            "erase": "",
            "eraseAll": "",
            "events": "",
            "file": "Dosya",
            "layers": "",
            "levels": "",
            "music": "",
            "paths": "",
            "scenes": "",
            "select": "",
            "settings": "",
            "show": "",
            "tiles": "Tilelar",
            "warps": "",
            "water": "",
            "area": ""
        },
        "warp": {
            "allow": "",
            "cannonExit": "",
            "dir": "",
            "effect": "",
            "in": "",
            "item": "",
            "lvlWarp": "",
            "needFloor": "",
            "needKey": "",
            "needStarCount": "",
            "out": "",
            "placing": "",
            "ride": "",
            "showStarCount": "",
            "showStartScene": "",
            "speed": "",
            "starLockMessage": "",
            "style": {
                "blipInstant": "",
                "door": "",
                "pipe": "",
                "portal": "",
                "style": ""
            },
            "target": "",
            "title": "",
            "to": "",
            "toMap": "",
            "transit": {
                "name0": "",
                "name1": "",
                "name2": "",
                "name3": "",
                "name4": "",
                "name5": ""
            },
            "twoWay": ""
        },
        "water": {
            "title": ""
        },
        "wordCoins": "",
        "wordEnabled": "",
        "wordEvent": {
            "genitive": "",
            "nominative": "",
            "typeLabel": ""
        },
        "wordHeight": "",
        "wordInstant": "",
        "wordMode": "",
        "wordNPC": {
            "genitive": "",
            "nominative": ""
        },
        "wordText": "",
        "wordWidth": "",
        "world": {
            "allowChars": "",
            "hubWorld": "",
            "introLevel": "",
            "name": "",
            "phraseCreditIndex": "",
            "retryOnFail": "",
            "totalStars": ""
        },
        "labelSortLayer": "Katmanları Sırala:",
        "labelSortOffset": "",
        "phraseGenericIndex": ""
    },
    "game": {
        "connect": {
            "dropAddTitle": "",
            "phraseChangeChar": "",
            "phraseDropMe": "",
            "phraseDropPX": "",
            "phraseForceResume": "",
            "phraseHoldStart": "",
            "phrasePressAButton": "",
            "phraseSetControls": "",
            "phraseStartToForceRes": "",
            "phraseStartToResume": "",
            "phraseTestControls": "",
            "phraseWaitingForInput": "",
            "reconnectTitle": "",
            "splitPressSelect_1": "",
            "splitPressSelect_2": "",
            "wordDisconnect": "",
            "phraseTestProfile": "Test Profili"
        },
        "error": {
            "openFileFailed": "",
            "warpNeedStarCount": "",
            "errorInvalidEnterWarp": "",
            "errorNoStartPoint": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "pause": {
            "continue": "",
            "enterCode": "",
            "quit": "",
            "quitTesting": "",
            "resetCheckpoints": "",
            "restartLevel": "",
            "returnToEditor": "",
            "saveAndContinue": "",
            "saveAndQuit": "",
            "playerSetup": ""
        },
        "hint": {
            "char5-bombs": "",
            "gray-bricks": "",
            "rainbow-surf": "",
            "shoe-block": "",
            "heavy-duck": "",
            "no-lives-old": "",
            "no-lives-new": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "msgbox": {
            "sysInfoWarning": "",
            "sysInfoError": "",
            "sysInfoTitle": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "languageName": "Türkçe",
    "menu": {
        "abbrevMilliseconds": "",
        "battle": {
            "errorNoLevels": ""
        },
        "caseNone": "",
        "character": {
            "selectCharacter": ""
        },
        "controls": {
            "buttons": {
                "altJump": "",
                "altRun": "",
                "down": "",
                "drop": "",
                "jump": "",
                "left": "",
                "right": "",
                "run": "",
                "start": "",
                "up": ""
            },
            "caseInvalid": "",
            "caseMouse": "",
            "caseTouch": "",
            "controlsConnected": "",
            "controlsDeleteKey": "",
            "controlsDeviceTypes": "",
            "controlsInUse": "",
            "controlsNewProfile": "",
            "controlsNotInUse": "",
            "controlsReallyDeleteProfile": "",
            "controlsTitle": "",
            "cursor": {
                "down": "",
                "left": "",
                "primary": "",
                "right": "",
                "secondary": "",
                "tertiary": "",
                "up": ""
            },
            "editor": {
                "fastScroll": "",
                "modeErase": "",
                "modeSelect": "",
                "nextSection": "",
                "prevSection": "",
                "scrollDown": "",
                "scrollLeft": "",
                "scrollRight": "",
                "scrollUp": "",
                "switchScreens": "",
                "testPlay": ""
            },
            "hotkeys": {
                "debugInfo": "",
                "enterCheats": "",
                "fullscreen": "",
                "legacyPause": "",
                "recordGif": "",
                "screenshot": "",
                "toggleHUD": "",
                "vanillaCam": ""
            },
            "options": {
                "batteryStatus": "",
                "maxPlayers": "",
                "rumble": "",
                "textEntryStyle": ""
            },
            "phraseNewProfOldJoy": "",
            "profile": {
                "cursorControls": "",
                "deleteProfile": "",
                "editorControls": "",
                "hotkeys": "",
                "playerControls": "",
                "renameProfile": ""
            },
            "tDS": {
                "buttonA": "",
                "buttonB": "",
                "buttonL": "",
                "buttonR": "",
                "buttonSelect": "",
                "buttonStart": "",
                "buttonX": "",
                "buttonY": "",
                "buttonZL": "",
                "buttonZR": "",
                "cStick": "",
                "casePen": "",
                "dPad": "",
                "tStick": ""
            },
            "touchscreen": {
                "layout": {
                    "longOld": "",
                    "phabletOld": "",
                    "phoneOld": "",
                    "standard": "",
                    "tabletOld": "",
                    "tight": "",
                    "tinyOld": ""
                },
                "option": {
                    "feedbackLength": "",
                    "feedbackStrength": "",
                    "holdRun": "",
                    "interfaceStyle": "",
                    "layoutStyle": "",
                    "resetLayout": "",
                    "sStartSpacing": "",
                    "scaleButtons": "",
                    "scaleDPad": "",
                    "scaleFactor": "",
                    "showCodeButton": ""
                },
                "style": {
                    "ABXY": "",
                    "XODA": "",
                    "actions": ""
                }
            },
            "types": {
                "gamepad": "",
                "keyboard": "",
                "oldJoystick": "",
                "touchscreen": ""
            },
            "wii": {
                "classic": {
                    "buttonLT": "",
                    "buttonRT": "",
                    "buttonX": "",
                    "buttonY": "",
                    "buttonZL": "",
                    "buttonZR": "",
                    "lStick": "",
                    "rStick": ""
                },
                "nunchuck": {
                    "buttonC": "",
                    "buttonZ": "",
                    "prefixN": ""
                },
                "phraseNewClassic": "",
                "phraseNewNunchuck": "",
                "typeClassic": "",
                "typeNunchuck": "",
                "typeWiimote": "",
                "wiimote": {
                    "button1": "",
                    "button2": "",
                    "buttonA": "",
                    "buttonB": "",
                    "buttonHome": "",
                    "buttonMinus": "-",
                    "buttonPlus": "",
                    "caseIR": "",
                    "dPad": "",
                    "shake": "Salla"
                },
                "typeGamecube": ""
            },
            "wordButtons": "",
            "wordProfiles": "",
            "joystickSimpleEditor": ""
        },
        "editor": {
            "errorMissingResources": "",
            "newWorld": "",
            "promptNewWorldName": "",
            "battles": "",
            "makeFor": ""
        },
        "game": {
            "gameBattleRandom": "",
            "gameCopySave": "",
            "gameEraseSave": "",
            "gameEraseSlot": "",
            "gameNoBattleLevels": "",
            "gameNoEpisodesToPlay": "",
            "gameSlotContinue": "",
            "gameSlotNew": "",
            "gameSourceSlot": "",
            "gameTargetSlot": "",
            "phraseScore": "",
            "phraseTime": "",
            "warnEpCompat": ""
        },
        "loading": "",
        "main": {
            "main1PlayerGame": "",
            "mainBattleGame": "",
            "mainEditor": "",
            "mainExit": "",
            "mainMultiplayerGame": "",
            "mainOptions": "",
            "mainPlayEpisode": ""
        },
        "options": {
            "advanced": {
                "advanced-video": "Video",
                "advanced-audio": "Ses",
                "audio-format": {
                    "_name": "Ses formatı",
                    "_tooltip": ""
                },
                "render": {
                    "opengl": "",
                    "opengl-tip": "",
                    "opengl11-tip": "",
                    "opengl11": "",
                    "opengles11": "",
                    "sw": "",
                    "sdl-tip": "",
                    "opengles11-tip": "",
                    "sdl": "",
                    "opengles-tip": "",
                    "hw": "",
                    "_name": "",
                    "opengles": ""
                },
                "log-level": {
                    "debug": "",
                    "fatal": "",
                    "_name": "",
                    "critical": "",
                    "warning": "",
                    "info": "",
                    "none": ""
                },
                "audio-sample-rate": {
                    "_name": "",
                    "48000": "",
                    "11025": "",
                    "22050": "",
                    "16000": "",
                    "32000": "",
                    "44100": ""
                },
                "scale-down-textures": {
                    "_name": "",
                    "all": "",
                    "_tooltip": "",
                    "none-tip": "",
                    "safe-tip": "",
                    "safe": "",
                    "all-tip": "",
                    "none": ""
                },
                "webm-recording": "",
                "internal-res-4p": {
                    "qhd": "",
                    "_name": "",
                    "fhd": "",
                    "default": "",
                    "qsmbx": ""
                },
                "_header": "",
                "_tooltip": "",
                "audio-buffer-size": {
                    "_name": "",
                    "_tooltip": ""
                },
                "audio-channels": {
                    "mono": "",
                    "_name": "",
                    "stereo": ""
                },
                "choose-assets-on-launch": "",
                "audio-enable": "",
                "record-gameplay-data": "",
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "episode-options": {
                "creator-compat": {
                    "_tooltip": "",
                    "disable": "",
                    "_name": "",
                    "enable": "",
                    "file-only": ""
                },
                "_header": "Bölüm Ayarları",
                "playstyle": {
                    "modern-tip": "",
                    "classic": "",
                    "classic-tip": "",
                    "vanilla": "",
                    "modern": "",
                    "vanilla-tip": "",
                    "_name": ""
                },
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "main": {
                "background-work": "",
                "four-screen-mode": {
                    "shared": "",
                    "_name": "",
                    "split": ""
                },
                "frame-skip": "",
                "vsync": "",
                "two-screen-mode": {
                    "topbottom": "",
                    "split": "",
                    "shared": "",
                    "_name": "",
                    "smbx": ""
                },
                "background-work-tip": "",
                "timing": "",
                "multiplayer": "",
                "language": "",
                "_header": "",
                "unlimited-framerate": "",
                "discord-rpc": ""
            },
            "video": {
                "internal-res": {
                    "hd": "",
                    "hello": "",
                    "smbx": "",
                    "dynamic": "",
                    "_tooltip": "",
                    "_name": "",
                    "gba": "",
                    "snes": "",
                    "vga": "",
                    "smbx-wide": "",
                    "3ds": "",
                    "nds": ""
                },
                "effects": "",
                "scale-mode": {
                    "_name": "",
                    "center": "",
                    "2x": "",
                    "1x": "",
                    "0_5x": "",
                    "nearest": "",
                    "full": "",
                    "linear": "",
                    "integer": "",
                    "3x": "3x"
                },
                "info-meta": "",
                "show-episode-title": {
                    "_name": "Bölüm adı",
                    "bottom": "Alt",
                    "top": "Üst",
                    "off": "Kapalı",
                    "top-tip": "",
                    "bottom-tip": "Speedrun sayacının üzerinde göster"
                },
                "show-playtime-counter": {
                    "opaque": "Opak",
                    "animated-tip": "Seviye sonuna gökkuşağı efekti ekle",
                    "off": "Kapalı",
                    "off-tip": "Sadece speedrun esnasında göster",
                    "_tooltip": "",
                    "_name": "Oynama sayısı sayacı",
                    "transparent": "Yarı şeffaf",
                    "animated": ""
                },
                "_header": "",
                "world-map-stars-show-tip": "Toplanmış yıldızları seviye üzerinde göster",
                "3d-compat-mode-tip": "Bütün objeleri bir 3D düzlemde çiz",
                "battery-status": {
                    "_name": "",
                    "low-tip": "",
                    "low": "",
                    "fullscreen-tip": "",
                    "fullscreen": "",
                    "off": "",
                    "on": ""
                },
                "info-run": "",
                "display-controllers": "",
                "enable-inter-level-fade-effect": "",
                "fullscreen": "",
                "info-game": "",
                "3d-compat-mode": "",
                "show-screen-shake": "Ekran sallanması",
                "world-map-stars-show": "Dünya haritası yıldızları",
                "video-system": "Sistem",
                "show-medals-counter-tip": "",
                "show-fps": "Framerate",
                "show-fails-counter-tip": "",
                "show-medals-counter": "Madalya sayacı",
                "show-fails-counter": "Hata sayacı"
            },
            "speedrun": {
                "mode": {
                    "3": "3",
                    "_name": "Speedrun modu",
                    "0": "0",
                    "2": "2",
                    "1": "1"
                }
            },
            "audio": {
                "sfx-modern-tip": "",
                "audio-sfx-volume": "",
                "sfx-modern": "",
                "audio-prefs": "",
                "sfx-spatial-audio-tip": "",
                "sfx-audio-fx": "",
                "sfx-spatial-audio": "",
                "sfx-pet-beat": "",
                "sfx-pet-beat-tip": "",
                "_header": "",
                "audio-music-volume": ""
            },
            "controls": {
                "_header": ""
            },
            "compatibility": {
                "bugfixes": "",
                "_header": "",
                "reset-all": "",
                "features": "",
                "autocode": "",
                "_tooltip": ""
            },
            "view-credits": {
                "_header": ""
            },
            "restartEngine": ""
        },
        "wordBack": "Geri",
        "wordHide": "Gizle",
        "wordNo": "Hayır",
        "wordOff": "Kapalı",
        "wordOn": "Açık",
        "wordPlayer": "Oyuncu",
        "wordProfile": "Profil",
        "wordResume": "Devam Et",
        "wordShow": "Göster",
        "wordWaiting": "Bekleniyor",
        "wordYes": "Evet"
    },
    "outro": {
        "cppPortDevelopers": "C++ portunun geliştiricileri:",
        "customSprites": "",
        "engineCredits": "",
        "gameCredits": "",
        "levelDesign": "Seviye Tasarımı:",
        "nameAndrewSpinks": "Andrew Spinks",
        "nameVitalyNovichkov": "Vitaly Novichkov",
        "originalBy": "Orijinal VB6 kodu:",
        "psVitaPortBy": "PS Vita Portu:",
        "specialThanks": "Özel Teşekkürler:",
        "qualityControl": "Kalite Kontrol:"
    },
    "pluralRules": ""
}


================================================
FILE: resources/languages/thextech_uk.json
================================================
{
    "outro": {
        "cppPortDevelopers": "",
        "qualityControl": "",
        "nameVitalyNovichkov": "",
        "psVitaPortBy": "",
        "customSprites": "",
        "levelDesign": "",
        "gameCredits": "",
        "nameAndrewSpinks": "",
        "engineCredits": "",
        "originalBy": "",
        "specialThanks": ""
    },
    "menu": {
        "options": {
            "advanced": {
                "_header": "",
                "audio-enable": "",
                "render": {
                    "opengles11": "",
                    "opengles": "",
                    "opengles11-tip": "",
                    "opengles-tip": "",
                    "opengl": "",
                    "hw": "",
                    "opengl-tip": "",
                    "opengl11": "",
                    "sdl-tip": "",
                    "sdl": "",
                    "sw": "",
                    "_name": "",
                    "opengl11-tip": ""
                },
                "scale-down-textures": {
                    "_tooltip": "",
                    "safe": "",
                    "all": "",
                    "safe-tip": "",
                    "none-tip": "",
                    "_name": "",
                    "all-tip": "",
                    "none": ""
                },
                "audio-sample-rate": {
                    "11025": "",
                    "32000": "",
                    "22050": "",
                    "44100": "",
                    "48000": "",
                    "_name": "",
                    "16000": ""
                },
                "audio-format": {
                    "_tooltip": "",
                    "_name": ""
                },
                "internal-res-4p": {
                    "fhd": "",
                    "default": "",
                    "_name": "",
                    "qsmbx": "",
                    "qhd": ""
                },
                "webm-recording": "",
                "advanced-video": "",
                "advanced-audio": "",
                "audio-channels": {
                    "_name": "",
                    "mono": "",
                    "stereo": ""
                },
                "log-level": {
                    "debug": "",
                    "none": "",
                    "warning": "",
                    "info": "",
                    "critical": "",
                    "_name": "",
                    "fatal": ""
                },
                "record-gameplay-data": "",
                "choose-assets-on-launch": "",
                "_tooltip": "",
                "audio-buffer-size": {
                    "_name": "",
                    "_tooltip": ""
                },
                "use-native-osk": "",
                "fullscreen-type": {
                    "_name": "",
                    "exclusive": "",
                    "desktop-tip": "",
                    "desktop": "",
                    "exclusive-tip": "",
                    "auto": ""
                },
                "inaccurate-gifs-tip": "",
                "inaccurate-gifs": "",
                "fullscreen-depth": {
                    "16": "",
                    "auto": "",
                    "_name": "",
                    "32": ""
                },
                "fullscreen-res": ""
            },
            "main": {
                "multiplayer": "",
                "two-screen-mode": {
                    "topbottom": "",
                    "split": "",
                    "shared": "",
                    "_name": "",
                    "smbx": ""
                },
                "unlimited-framerate": "",
                "timing": "",
                "four-screen-mode": {
                    "shared": "",
                    "_name": "",
                    "split": ""
                },
                "background-work-tip": "",
                "background-work": "",
                "_header": "",
                "frame-skip": "",
                "language": "",
                "discord-rpc": "",
                "vsync": ""
            },
            "audio": {
                "_header": "",
                "sfx-modern-tip": "",
                "sfx-modern": "",
                "audio-prefs": "",
                "sfx-audio-fx": "",
                "audio-sfx-volume": "",
                "audio-music-volume": "",
                "sfx-spatial-audio-tip": "",
                "sfx-spatial-audio": "",
                "sfx-pet-beat-tip": "",
                "sfx-pet-beat": ""
            },
            "compatibility": {
                "_tooltip": "",
                "_header": "",
                "autocode": "",
                "bugfixes": "",
                "features": "",
                "reset-all": ""
            },
            "video": {
                "_header": "",
                "scale-mode": {
                    "0_5x": "",
                    "1x": "",
                    "full": "",
                    "center": "",
                    "2x": "",
                    "_name": "",
                    "nearest": "",
                    "integer": "",
                    "linear": "",
                    "3x": ""
                },
                "internal-res": {
                    "nds": "",
                    "hello": "",
                    "vga": "",
                    "smbx-wide": "",
                    "3ds": "",
                    "smbx": "",
                    "_name": "",
                    "_tooltip": "",
                    "dynamic": "",
                    "gba": "",
                    "snes": "",
                    "hd": ""
                },
                "show-episode-title": {
                    "_name": "",
                    "off": "",
                    "bottom": "",
                    "bottom-tip": "",
                    "top-tip": "",
                    "top": ""
                },
                "enable-inter-level-fade-effect": "",
                "battery-status": {
                    "_name": "",
                    "fullscreen-tip": "",
                    "low-tip": "",
                    "on": "",
                    "low": "",
                    "off": "",
                    "fullscreen": ""
                },
                "fullscreen": "",
                "show-playtime-counter": {
                    "off-tip": "",
                    "off": "",
                    "animated-tip": "",
                    "transparent": "",
                    "opaque": "",
                    "_tooltip": "",
                    "_name": "",
                    "animated": ""
                },
                "world-map-stars-show": "",
                "world-map-stars-show-tip": "",
                "show-fails-counter-tip": "",
                "show-fails-counter": "",
                "3d-compat-mode-tip": "",
                "show-fps": "",
                "show-medals-counter": "",
                "effects": "",
                "display-controllers": "",
                "3d-compat-mode": "",
                "show-medals-counter-tip": "",
                "video-system": "",
                "info-game": "",
                "info-run": "",
                "show-screen-shake": "",
                "info-meta": ""
            },
            "controls": {
                "_header": ""
            },
            "restartEngine": "",
            "episode-options": {
                "creator-compat": {
                    "_name": "",
                    "_tooltip": "",
                    "disable": "",
                    "enable": "",
                    "file-only": ""
                },
                "playstyle": {
                    "vanilla": "",
                    "modern": "",
                    "modern-tip": "",
                    "vanilla-tip": "",
                    "_name": "",
                    "classic": "",
                    "classic-tip": ""
                },
                "_header": "",
                "hub-resume-tip": "",
                "hub-resume": ""
            },
            "speedrun": {
                "mode": {
                    "0": "",
                    "1": "",
                    "_name": "",
                    "2": "",
                    "3": ""
                }
            },
            "view-credits": {
                "_header": ""
            }
        },
        "wordBack": "",
        "wordNo": "",
        "controls": {
            "controlsTitle": "",
            "editor": {
                "modeSelect": "",
                "modeErase": "",
                "scrollDown": "",
                "fastScroll": "",
                "switchScreens": "",
                "scrollUp": "",
                "prevSection": "",
                "nextSection": "",
                "scrollRight": "",
                "testPlay": "",
                "scrollLeft": ""
            },
            "options": {
                "rumble": "",
                "maxPlayers": "",
                "batteryStatus": "",
                "textEntryStyle": ""
            },
            "tDS": {
                "buttonL": "",
                "buttonStart": "",
                "tStick": "",
                "casePen": "",
                "buttonR": "",
                "buttonY": "",
                "buttonZR": "",
                "buttonZL": "",
                "buttonSelect": "",
                "cStick": "",
                "buttonX": "",
                "buttonB": "",
                "buttonA": "",
                "dPad": ""
            },
            "touchscreen": {
                "option": {
                    "scaleFactor": "",
                    "layoutStyle": "",
                    "scaleButtons": "",
                    "interfaceStyle": "",
                    "sStartSpacing": "",
                    "resetLayout": "",
                    "showCodeButton": "",
                    "holdRun": "",
                    "feedbackLength": "",
                    "scaleDPad": "",
                    "feedbackStrength": ""
                },
                "layout": {
                    "phabletOld": "",
                    "longOld": "",
                    "tabletOld": "",
                    "tight": "",
                    "phoneOld": "",
                    "standard": "",
                    "tinyOld": ""
                },
                "style": {
                    "XODA": "",
                    "ABXY": "",
                    "actions": ""
                }
            },
            "types": {
                "touchscreen": "",
                "gamepad": "",
                "keyboard": "",
                "oldJoystick": ""
            },
            "wii": {
                "typeWiimote": "",
                "classic": {
                    "buttonX": "",
                    "buttonZL": "",
                    "buttonY": "",
                    "buttonZR": "",
                    "lStick": "",
                    "rStick": "",
                    "buttonRT": "",
                    "buttonLT": ""
                },
                "phraseNewNunchuck": "",
                "wiimote": {
                    "buttonPlus": "",
                    "buttonMinus": "",
                    "buttonHome": "",
                    "caseIR": "",
                    "buttonB": "",
                    "shake": "",
                    "button1": "",
                    "buttonA": "",
                    "dPad": "",
                    "button2": ""
                },
                "typeNunchuck": "",
                "phraseNewClassic": "",
                "typeClassic": "",
                "nunchuck": {
                    "buttonC": "",
                    "prefixN": "",
                    "buttonZ": ""
                },
                "typeGamecube": ""
            },
            "wordButtons": "",
            "hotkeys": {
                "screenshot": "",
                "toggleHUD": "",
                "recordGif": "",
                "fullscreen": "",
                "enterCheats": "",
                "debugInfo": "",
                "legacyPause": "",
                "vanillaCam": ""
            },
            "profile": {
                "deleteProfile": "",
                "cursorControls": "",
                "hotkeys": "",
                "editorControls": "",
                "playerControls": "",
                "renameProfile": ""
            },
            "joystickSimpleEditor": "",
            "buttons": {
                "down": "",
                "up": "",
                "run": "",
                "drop": "",
                "altJump": "",
                "altRun": "",
                "left": "",
                "jump": "",
                "start": "",
                "right": ""
            },
            "cursor": {
                "left": "",
                "down": "",
                "primary": "",
                "tertiary": "",
                "right": "",
                "secondary": "",
                "up": ""
            },
            "controlsDeleteKey": "",
            "caseMouse": "",
            "caseInvalid": "",
            "phraseNewProfOldJoy": "",
            "wordProfiles": "",
            "controlsReallyDeleteProfile": "",
            "controlsNotInUse": "",
            "controlsNewProfile": "",
            "controlsInUse": "",
            "controlsConnected": "",
            "caseTouch": "",
            "controlsDeviceTypes": ""
        },
        "editor": {
            "battles": "",
            "promptNewWorldName": "",
            "makeFor": "",
            "newWorld": "",
            "errorMissingResources": ""
        },
        "game": {
            "gameSlotNew": "",
            "gameSourceSlot": "",
            "gameEraseSlot": "",
            "gameNoBattleLevels": "",
            "gameNoEpisodesToPlay": "",
            "gameSlotContinue": "",
            "gameBattleRandom": "",
            "phraseTime": "",
            "gameCopySave": "",
            "gameEraseSave": "",
            "phraseScore": "",
            "gameTargetSlot": "",
            "warnEpCompat": ""
        },
        "main": {
            "mainEditor": "",
            "mainExit": "",
            "mainBattleGame": "",
            "main1PlayerGame": "",
            "mainMultiplayerGame": "",
            "mainOptions": "",
            "mainPlayEpisode": ""
        },
        "character": {
            "selectCharacter": ""
        },
        "battle": {
            "errorNoLevels": ""
        },
        "wordResume": "",
        "wordShow": "",
        "wordWaiting": "",
        "wordYes": "",
        "loading": "",
        "wordProfile": "",
        "wordOn": "",
        "wordOff": "",
        "wordPlayer": "",
        "wordHide": "",
        "abbrevMilliseconds": "",
        "caseNone": ""
    },
    "editor": {
        "file": {
            "sectionWorld": "",
            "convert": {
                "descNew": ""
            },
            "confirmConfirmAction": "",
            "commandSave": "",
            "commandSaveAs": "",
            "confirmConvertFormatTo": "",
            "formatLegacy": "",
            "optionActionWithoutSave": "",
            "labelCurrentFile": "",
            "optionYesSaveThenAction": "",
            "optionCancelAction": "",
            "optionCancelConversion": "",
            "optionProceedWithConversion": "",
            "actionClearLevel": "",
            "actionExit": "",
            "commandNew": "",
            "confirmSaveBeforeAction": "",
            "commandOpen": "",
            "labelFormat": "",
            "sectionLevel": "",
            "actionClearWorld": "",
            "actionOpen": "",
            "formatModern": "",
            "actionRevert": ""
        },
        "layers": {
            "deletion": {
                "confirmDelete": "",
                "confirmPreserve": "",
                "preserveLayerContents": "",
                "header": "",
                "cancel": ""
            },
            "desc": {
                "att": ""
            },
            "labelAttachedLayer": "",
            "labelMoveLayer": "",
            "labelAttached": "",
            "promptLayerName": "",
            "abbrevAttLayer": "",
            "default": "",
            "label": "",
            "header": "",
            "itemNewLayer": ""
        },
        "letterLeft": "",
        "letterRight": "",
        "level": {
            "bigBG": "",
            "pathBG": "",
            "levelName": "",
            "startPos": "",
            "gameStart": "",
            "pathUnlocks": "",
            "alwaysVis": ""
        },
        "npc": {
            "ai": {
                "LR": "",
                "UD": "",
                "aiIs": "",
                "swim": "",
                "target": "",
                "jump": "",
                "leap": "",
                "headerCustomAi": "",
                "use1_0Ai": ""
            },
            "abbrevGen": "",
            "inContainer": "",
            "props": {
                "active": "",
                "attachSurface": "",
                "facing": ""
            },
            "inertNice": "",
            "stuckStop": "",
            "gen": {
                "effectIs": "",
                "effectWarp": "",
                "effectShoot": "",
                "header": "",
                "direction": ""
            },
            "tooltipExpandSection": ""
        },
        "mapPos": "",
        "pageBlankOfBlank": "",
        "phraseAreYouSure": "",
        "phraseRadiusIndex": "",
        "phraseDelayIsMs": "",
        "phraseCountMore": "",
        "phraseWarpIndex": "",
        "section": {
            "horizWrap": "",
            "offscreenExit": "",
            "noTurnBack": "",
            "vertWrap": "",
            "underwater": "",
            "setBounds": "",
            "scroll": ""
        },
        "select": {
            "allSectPropBlankForEventN": "",
            "pathBlankUnlock": "",
            "sectBlankPropBlankForEventN": "",
            "sectionBlankPropBlank": "",
            "soundForEventN": "",
            "worldMusic": "",
            "warpTransitEffect": ""
        },
        "warp": {
            "style": {
                "door": "",
                "pipe": "",
                "blipInstant": "",
                "portal": "",
                "style": ""
            },
            "dir": "",
            "out": "",
            "needStarCount": "",
            "ride": "",
            "transit": {
                "name3": "",
                "name5": "",
                "name4": "",
                "name2": "",
                "name1": "",
                "name0": ""
            },
            "allow": "",
            "speed": "",
            "target": "",
            "starLockMessage": "",
            "title": "",
            "effect": "",
            "item": "",
            "in": "",
            "showStartScene": "",
            "showStarCount": "",
            "toMap": "",
            "to": "",
            "needFloor": "",
            "needKey": "",
            "lvlWarp": "",
            "twoWay": "",
            "cannonExit": "",
            "placing": ""
        },
        "water": {
            "title": ""
        },
        "wordEvent": {
            "genitive": "",
            "nominative": "",
            "typeLabel": ""
        },
        "wordNPC": {
            "genitive": "",
            "nominative": ""
        },
        "wordHeight": "",
        "wordInstant": "",
        "wordWidth": "",
        "tooltip": {
            "BGOs": "",
            "NPCs": "",
            "erase": "",
            "area": "",
            "blocks": "",
            "paths": "",
            "water": "",
            "eraseAll": "",
            "file": "",
            "layers": "",
            "select": "",
            "settings": "",
            "show": "",
            "warps": "",
            "tiles": "",
            "scenes": "",
            "levels": "",
            "events": "",
            "music": ""
        },
        "toggleMagicBlock": "",
        "testPlay": {
            "magicHand": "",
            "char": "",
            "boot": "",
            "power": "",
            "pet": ""
        },
        "wordText": "",
        "events": {
            "controlsForEventN": "",
            "bounds": {
                "changeSectionBoundsToCurrent": "",
                "shouldEvent": "",
                "changeAllSectionBoundsToCurrent": ""
            },
            "deletion": {
                "cancel": "",
                "confirm": "",
                "deletingEvent": ""
            },
            "label": {
                "destroy": "",
                "death": "",
                "hit": "",
                "enter": "",
                "talk": "",
                "next": "",
                "activate": "",
                "layerClear": ""
            },
            "layers": {
                "headerToggle": "",
                "headerShow": "",
                "headerMove": "",
                "headerHide": ""
            },
            "promptEventName": "",
            "letter": {
                "talk": "",
                "layerClear": "",
                "enter": "",
                "hit": "",
                "activate": "",
                "destroy": "",
                "death": ""
            },
            "props": {
                "autostart": "",
                "endGame": "",
                "sound": "",
                "layerSmoke": "",
                "controls": ""
            },
            "sections": {
                "phraseAllSections": "",
                "actionSet": "",
                "propBackground": "",
                "actionKeep": "",
                "actionReset": "",
                "propMusic": "",
                "propBounds": ""
            },
            "desc": {
                "phraseTriggersAfterTemplate": "",
                "layerClear": "",
                "enter": "",
                "hit": "",
                "death": "",
                "activate": "",
                "phraseTriggersWhenTemplate": "",
                "destroy": "",
                "talk": ""
            },
            "itemNewEvent": "",
            "settingsForEvent": "",
            "header": "",
            "promptEventText": "",
            "headerTriggerEvent": ""
        },
        "phraseGenericIndex": "",
        "block": {
            "canBreak": "",
            "canBreakTooltip": "",
            "inside": "",
            "invis": "",
            "letterHeight": "",
            "pickContents": "",
            "slick": "",
            "letterWidth": ""
        },
        "browser": {
            "askOverwriteFile": "",
            "itemNewFolder": "",
            "itemNewFile": "",
            "openFile": "",
            "newFile": "",
            "saveFile": ""
        },
        "letterDown": "",
        "letterCoordY": "",
        "letterCoordX": "",
        "wordMode": "",
        "phraseSectionIndex": "",
        "phraseTextOf": "",
        "world": {
            "allowChars": "",
            "name": "",
            "totalStars": "",
            "hubWorld": "",
            "introLevel": "",
            "retryOnFail": "",
            "phraseCreditIndex": ""
        },
        "wordCoins": "",
        "wordEnabled": "",
        "letterUp": "",
        "labelSortOffset": "",
        "labelSortLayer": ""
    },
    "game": {
        "connect": {
            "wordDisconnect": "",
            "phraseHoldStart": "",
            "dropAddTitle": "",
            "phraseTestControls": "",
            "splitPressSelect_1": "",
            "phraseChangeChar": "",
            "phraseDropMe": "",
            "splitPressSelect_2": "",
            "phraseTestProfile": "",
            "phraseStartToResume": "",
            "phraseStartToForceRes": "",
            "phraseSetControls": "",
            "phraseWaitingForInput": "",
            "reconnectTitle": "",
            "phrasePressAButton": "",
            "phraseDropPX": "",
            "phraseForceResume": ""
        },
        "format": {
            "minutesSeconds": ""
        },
        "error": {
            "openFileFailed": "",
            "errorInvalidEnterWarp": "",
            "warpNeedStarCount": "",
            "errorNoStartPoint": "",
            "errorTooOldGameAssets": "",
            "openIPCDataFailed": "",
            "IPCTimeOut": "",
            "errorTooOldEngine": ""
        },
        "hint": {
            "no-lives-old": "",
            "gray-bricks": "",
            "char5-bombs": "",
            "shoe-block": "",
            "heavy-duck": "",
            "rainbow-surf": "",
            "no-lives-new": "",
            "pound-altrun": "",
            "pound-down": ""
        },
        "pause": {
            "enterCode": "",
            "saveAndContinue": "",
            "saveAndQuit": "",
            "quit": "",
            "resetCheckpoints": "",
            "restartLevel": "",
            "quitTesting": "",
            "returnToEditor": "",
            "playerSetup": "",
            "continue": ""
        },
        "msgbox": {
            "sysInfoError": "",
            "sysInfoTitle": "",
            "sysInfoWarning": ""
        },
        "message": {
            "scanningLevels": ""
        },
        "loader": {
            "statusLoadData": "",
            "statusGameInfo": "",
            "statusLoadFile": "",
            "statusFinishing": "",
            "statusAssetPacks": "",
            "statusTranslations": ""
        },
        "ipcStatus": {
            "loadingdone": "",
            "dataAccepted": "",
            "dataTransferStarted": "",
            "errorTimeout": "",
            "dataValid": "",
            "waitingInput": ""
        },
        "screenPaused": ""
    },
    "languageName": "",
    "pluralRules": ""
}


================================================
FILE: resources/languages/thextech_zh-cn.json
================================================
{
    "editor": {
        "block": {
            "canBreak": "可顶碎",
            "canBreakTooltip": "旧版本：顶砖块后将会破碎",
            "inside": "包含：",
            "invis": "隐形",
            "letterHeight": "高 ",
            "letterWidth": "宽 ",
            "pickContents": "选择砖块包含道具",
            "slick": "打滑"
        },
        "browser": {
            "askOverwriteFile": "是否覆盖文件{0}？",
            "itemNewFile": "<新文件>",
            "itemNewFolder": "<新建文件夹>",
            "newFile": "新建文件",
            "openFile": "打开文件",
            "saveFile": "删除文件"
        },
        "events": {
            "bounds": {
                "changeAllSectionBoundsToCurrent": "改变所有场景范围到当前设置吗？",
                "changeSectionBoundsToCurrent": "改变场景{0}的范围到当前设置吗？",
                "shouldEvent": "要使事件{0}"
            },
            "controlsForEventN": "强制按下玩家按键：{0}",
            "deletion": {
                "cancel": "否：不删除事件",
                "confirm": "是：删除事件",
                "deletingEvent": "删除{0}事件"
            },
            "desc": {
                "activate": "NPC在当前画面出现时",
                "death": "NPC死亡时",
                "destroy": "砖块破碎时",
                "enter": "进入传送点时",
                "hit": "砖块被撞击时",
                "layerClear": "当前图层中的对象为空时",
                "phraseTriggersAfterTemplate": "将于事件：{2}经过{1}毫秒之后，触发{0}事件",
                "phraseTriggersWhenTemplate": "{0}：{1}触发该事件",
                "talk": "和NPC对话后"
            },
            "header": "事件：",
            "headerTriggerEvent": "触发",
            "itemNewEvent": "<新事件>",
            "label": {
                "activate": "出现",
                "death": "死亡",
                "destroy": "破碎",
                "enter": "进入传送点",
                "hit": "撞击",
                "layerClear": "空白图层",
                "next": "下一个",
                "talk": "对话"
            },
            "layers": {
                "headerHide": "隐藏：",
                "headerMove": "移动：",
                "headerShow": "显示：",
                "headerToggle": "切换："
            },
            "letter": {
                "activate": "出：",
                "death": "死：",
                "destroy": "碎：",
                "enter": "进：",
                "hit": "撞：",
                "layerClear": "空：",
                "talk": "话："
            },
            "promptEventName": "事件名称：",
            "promptEventText": "文字信息：",
            "props": {
                "autostart": "进入关卡时执行事件",
                "controls": "按键",
                "endGame": "游戏通关",
                "sound": "声音",
                "layerSmoke": "图层烟雾效果"
            },
            "sections": {
                "actionKeep": "当前",
                "actionReset": "默认",
                "actionSet": "指定",
                "phraseAllSections": "所有场景",
                "propBackground": "背景图片",
                "propBounds": "场景范围",
                "propMusic": "音乐"
            },
            "settingsForEvent": "{0}事件选项"
        },
        "file": {
            "actionClearLevel": "清除关卡",
            "actionClearWorld": "清除大地图",
            "actionExit": "退出",
            "actionOpen": "打开",
            "actionRevert": "恢复",
            "commandNew": "新建",
            "commandOpen": "打开...",
            "commandSave": "保存",
            "commandSaveAs": "另存为...",
            "confirmConfirmAction": "您确定要{0}吗？",
            "confirmConvertFormatTo": "是否转换格式到{0}？",
            "confirmSaveBeforeAction": "{0}前是否保存文件？",
            "convert": {
                "descNew": "文件格式将会转换，但不会删除源文件。\n\n请在保存文件之后检查不支持的功能。"
            },
            "formatLegacy": "旧版本",
            "formatModern": "新版本",
            "labelCurrentFile": "当前文件：",
            "labelFormat": "格式：",
            "optionActionWithoutSave": "否：{0}而不保存文件",
            "optionCancelAction": "取消：返回上一级菜单",
            "optionCancelConversion": "取消转换",
            "optionProceedWithConversion": "确认转换",
            "optionYesSaveThenAction": "是：{0}并保存文件",
            "sectionLevel": "关卡",
            "sectionWorld": "大地图"
        },
        "layers": {
            "abbrevAttLayer": "跟随：",
            "default": "默认",
            "deletion": {
                "cancel": "取消：返回上一级菜单",
                "confirmDelete": "否：*删除全部对象*",
                "confirmPreserve": "是：移动到默认图层",
                "header": "删除{0}图层",
                "preserveLayerContents": "是否保留图层对象？"
            },
            "desc": {
                "att": "当NPC移动时，图层也将随之移动"
            },
            "header": "图层：",
            "itemNewLayer": "<新图层>",
            "label": "图层：",
            "labelAttached": "跟随：",
            "labelAttachedLayer": "跟随图层：",
            "labelMoveLayer": "移动图层：",
            "promptLayerName": "图层名称"
        },
        "letterCoordX": "X",
        "letterCoordY": "Y",
        "letterDown": "下",
        "letterLeft": "左",
        "letterRight": "右",
        "letterUp": "上",
        "level": {
            "alwaysVis": "总是可见",
            "bigBG": "大背景",
            "gameStart": "游戏起点",
            "levelName": "关卡名称",
            "pathBG": "路线背景",
            "pathUnlocks": "路线开启",
            "startPos": "游戏起点"
        },
        "mapPos": "地图位置：",
        "npc": {
            "abbrevGen": "生成器",
            "ai": {
                "LR": "左右",
                "UD": "上下",
                "aiIs": "动作：{0}",
                "headerCustomAi": "自定义动作：",
                "jump": "跳跃",
                "leap": "飞跃",
                "swim": "游泳",
                "target": "跟踪",
                "use1_0Ai": "使用1.0 AI？"
            },
            "gen": {
                "direction": "方向",
                "effectIs": "特效：{0}",
                "effectShoot": "喷射",
                "effectWarp": "水管",
                "header": "生成器选项"
            },
            "inContainer": "包含",
            "inertNice": "友好",
            "props": {
                "active": "启动",
                "attachSurface": "位置",
                "facing": "方向"
            },
            "stuckStop": "静止",
            "tooltipExpandSection": "扩展场景"
        },
        "pageBlankOfBlank": "第{0}/{1}页",
        "phraseAreYouSure": "您确定吗？",
        "phraseCountMore": "更多{0}",
        "phraseDelayIsMs": "延迟：{0}毫秒",
        "phraseGenericIndex": "编号：{0}",
        "phraseRadiusIndex": "半径：{0}",
        "phraseSectionIndex": "场景{0}",
        "phraseTextOf": "{0}的文字信息",
        "phraseWarpIndex": "传送点{0}号",
        "section": {
            "horizWrap": "横向循环",
            "noTurnBack": "单向卷轴",
            "offscreenExit": "场景边缘出口",
            "scroll": "强制卷轴",
            "setBounds": "设置范围",
            "underwater": "水下",
            "vertWrap": "纵向循环"
        },
        "select": {
            "allSectPropBlankForEventN": "更改所有场景{0}于{1}事件",
            "pathBlankUnlock": "路线向{0}开启条件",
            "sectBlankPropBlankForEventN": "更改场景{0}的{1}于{2}事件",
            "sectionBlankPropBlank": "场景{0}{1}",
            "soundForEventN": "执行{0}事件时播放声音",
            "warpTransitEffect": "过渡效果",
            "worldMusic": "大地图音乐"
        },
        "testPlay": {
            "boot": "靴子",
            "char": "角色",
            "magicHand": "鼠标",
            "pet": "坐骑",
            "power": "状态"
        },
        "toggleMagicBlock": "智能编辑模式",
        "tooltip": {
            "BGOs": "背景对象",
            "NPCs": "NPC",
            "blocks": "砖块",
            "erase": "删除",
            "eraseAll": "删除全部",
            "events": "事件",
            "file": "文件",
            "layers": "图层",
            "levels": "关卡",
            "music": "音乐",
            "paths": "路线",
            "scenes": "风景",
            "select": "选择",
            "settings": "设置",
            "show": "显示",
            "tiles": "地形",
            "warps": "传送点",
            "water": "水流",
            "area": "地图区域"
        },
        "warp": {
            "allow": "允许：",
            "cannonExit": "水管炮出口",
            "dir": "方向",
            "effect": "过渡效果：",
            "in": "入口",
            "item": "携带道具",
            "lvlWarp": "传送到另一关卡",
            "needFloor": "需要站立",
            "needKey": "需要钥匙",
            "needStarCount": "需要{0}{2}{1}",
            "out": "出口",
            "placing": "放置：",
            "ride": "坐骑",
            "showStarCount": "显示星星数量",
            "showStartScene": "显示开场界面",
            "speed": "速度：",
            "starLockMessage": "需要星星时的信息",
            "style": {
                "blipInstant": "瞬移",
                "door": "门",
                "pipe": "水管",
                "portal": "传送门",
                "style": "传送类别："
            },
            "target": "目标：",
            "title": "传送点",
            "to": "传送到：{0}",
            "toMap": "传送到大地图",
            "transit": {
                "name0": "无",
                "name1": "滚动",
                "name2": "淡入淡出",
                "name3": "圆形",
                "name4": "水平翻转",
                "name5": "垂直翻转"
            },
            "twoWay": "双向传送"
        },
        "water": {
            "title": "流体"
        },
        "wordCoins": "金币",
        "wordEnabled": "已启用",
        "wordEvent": {
            "genitive": "事件",
            "nominative": "事件",
            "typeLabel": "触发{0}事件："
        },
        "wordHeight": "高",
        "wordInstant": "立即",
        "wordMode": "流体类型",
        "wordNPC": {
            "genitive": "NPC",
            "nominative": "NPC"
        },
        "wordText": "信息",
        "wordWidth": "宽",
        "world": {
            "allowChars": "可用角色",
            "hubWorld": "禁用大地图",
            "introLevel": "开场关卡",
            "name": "地图名称",
            "phraseCreditIndex": "地图制作团队 第{0}行：",
            "retryOnFail": "失败之后重新开始",
            "totalStars": "总星星数："
        },
        "labelSortLayer": "叠放图层：",
        "labelSortOffset": "叠放次序："
    },
    "game": {
        "connect": {
            "dropAddTitle": "加入/离开游戏",
            "phraseChangeChar": "更换角色",
            "phraseDropMe": "离开游戏",
            "phraseDropPX": "移除玩家{0}的游戏",
            "phraseForceResume": "强制恢复游戏",
            "phraseHoldStart": "按住开始键",
            "phrasePressAButton": "按下一个按键",
            "phraseSetControls": "设置按键",
            "phraseStartToForceRes": "按开始键强制恢复游戏",
            "phraseStartToResume": "按开始键恢复游戏",
            "phraseTestControls": "测试按键",
            "phraseWaitingForInput": "等待玩家加入……",
            "reconnectTitle": "重新连接",
            "splitPressSelect_1": "按选择键",
            "splitPressSelect_2": "进入按键选项设置",
            "wordDisconnect": "断开",
            "phraseTestProfile": "测试配置"
        },
        "error": {
            "errorInvalidEnterWarp": "作为关卡起点的传送点{1}号不存在，因此无法进入关卡。\n传送点总数：{2}\n\n文件：{0}",
            "errorNoStartPoint": "未放置玩家起点或传送点入口，因此无法进入关卡。\n\n文件：{0}",
            "openFileFailed": "无法打开文件\"{0}\"：文件不存在或已损坏。",
            "warpNeedStarCount": "你需要{0}{2}{1}才能进入此传送点。",
            "IPCTimeOut": "加载编辑器时无响应，即将退出游戏。",
            "openIPCDataFailed": "无法接收文件数据：文件可能已损坏，或者发生其他错误。",
            "errorTooOldEngine": "该文件需要版本{0}或更高版本的TheXTech引擎才能正常运作，当前TheXTech引擎版本为{1}。请更新引擎。",
            "errorTooOldGameAssets": "该文件需要版本{0}或更高版本的游戏组件才能正常运作，当前游戏组件版本为{1}。请更新游戏组件。"
        },
        "format": {
            "minutesSeconds": "{0}分{1}秒"
        },
        "pause": {
            "continue": "继续游戏",
            "enterCode": "输入指令",
            "quit": "退出",
            "quitTesting": "结束测试",
            "resetCheckpoints": "重置中间点",
            "restartLevel": "重新开始",
            "returnToEditor": "返回编辑器",
            "saveAndContinue": "保存并继续",
            "saveAndQuit": "保存并退出",
            "playerSetup": "玩家选项"
        },
        "msgbox": {
            "sysInfoError": "错误！",
            "sysInfoTitle": "信息",
            "sysInfoWarning": "警告！"
        },
        "message": {
            "scanningLevels": "扫描关卡中……"
        },
        "hint": {
            "no-lives-old": "注意：如果本次通关失败，游戏将会结束！",
            "no-lives-new": "即使本次通关失败，也不会发生什么事情的；但请留意您的得分。",
            "rainbow-surf": "在拿起彩虹龟壳的时候，按下“下”键，开始冲浪吧！",
            "char5-bombs": "按下“奔跑”键可收集炸弹，按下“第二奔跑”键可投掷炸弹。",
            "gray-bricks": "神秘力量可以破坏部分砖块。",
            "heavy-duck": "玩家下蹲时，可以抵挡大多数火焰！",
            "shoe-block": "穿上鞋子时，可以抵挡大多数火焰！",
            "pound-altrun": "按下“第二奔跑”键，进行震地！",
            "pound-down": "按下“下”键，进行震地！"
        },
        "screenPaused": "游戏暂停",
        "ipcStatus": {
            "dataAccepted": "已接收到数据，开始解析……",
            "dataTransferStarted": "开始传输数据……",
            "dataValid": "接收的数据是有效数据",
            "errorTimeout": "错误：等待超时。",
            "loadingdone": "加载完成，即将开始游戏……",
            "waitingInput": "等待玩家按键输入……"
        },
        "loader": {
            "statusAssetPacks": "游戏组件",
            "statusFinishing": "完成加载……",
            "statusGameInfo": "游戏信息",
            "statusLoadData": "正在加载数据……",
            "statusLoadFile": "正在加载：{0}",
            "statusTranslations": "翻译",
            "loading": "加载中……"
        }
    },
    "languageName": "简体中文",
    "menu": {
        "abbrevMilliseconds": "毫秒",
        "battle": {
            "errorNoLevels": "对战关卡列表为空，无法进入对战模式。"
        },
        "caseNone": "<无>",
        "character": {
            "selectCharacter": "{0}游戏"
        },
        "controls": {
            "buttons": {
                "altJump": "第二跳跃",
                "altRun": "第二奔跑",
                "down": "下",
                "drop": "取出道具",
                "jump": "跳跃",
                "left": "左",
                "right": "右",
                "run": "奔跑",
                "start": "开始",
                "up": "上"
            },
            "caseInvalid": "（无效）",
            "caseMouse": "（鼠标）",
            "caseTouch": "（触屏）",
            "controlsConnected": "已连接：",
            "controlsDeleteKey": "（按第二跳跃键清除）",
            "controlsDeleteKey2": "（按第二奔跑键清除）",
            "controlsDeviceTypes": "设备类型",
            "controlsInUse": "（已使用）",
            "controlsNewProfile": "<新建配置>",
            "controlsNotInUse": "（未使用）",
            "controlsReallyDeleteProfile": "是否删除配置？",
            "controlsTitle": "按键选项",
            "cursor": {
                "down": "鼠标向下移动",
                "left": "鼠标向左移动",
                "primary": "鼠标左键",
                "right": "鼠标向右移动",
                "secondary": "鼠标右键",
                "tertiary": "鼠标滚轮",
                "up": "鼠标向上移动"
            },
            "editor": {
                "fastScroll": "快速滚动",
                "modeErase": "橡皮擦",
                "modeSelect": "选择模式",
                "nextSection": "下一场景",
                "prevSection": "上一场景",
                "scrollDown": "向下滚动",
                "scrollLeft": "向左滚动",
                "scrollRight": "向右滚动",
                "scrollUp": "向上滚动",
                "switchScreens": "显示面板",
                "testPlay": "测试关卡"
            },
            "hotkeys": {
                "debugInfo": "调试信息",
                "enterCheats": "输入作弊指令",
                "fullscreen": "全屏",
                "legacyPause": "旧版暂停菜单",
                "recordGif": "GIF 动画录制",
                "screenshot": "截图",
                "toggleHUD": "状态栏切换",
                "vanillaCam": "原始画面大小"
            },
            "options": {
                "batteryStatus": "电池状态",
                "maxPlayers": "玩家上限",
                "rumble": "Rumble控制器",
                "textEntryStyle": "文字输入使用设备",
                "altMenuControls": "切换确定/返回按键"
            },
            "phraseNewProfOldJoy": "新建老式手柄配置",
            "profile": {
                "cursorControls": "鼠标控制",
                "deleteProfile": "删除配置",
                "editorControls": "编辑器控制",
                "hotkeys": "热键",
                "playerControls": "玩家控制",
                "renameProfile": "重命名配置"
            },
            "tDS": {
                "buttonA": "A",
                "buttonB": "B",
                "buttonL": "L",
                "buttonR": "R",
                "buttonSelect": "选择",
                "buttonStart": "开始",
                "buttonX": "X",
                "buttonY": "Y",
                "buttonZL": "ZL",
                "buttonZR": "ZR",
                "cStick": "右摇杆",
                "casePen": "(触控笔)",
                "dPad": "方向键",
                "tStick": "左摇杆"
            },
            "touchscreen": {
                "layout": {
                    "longOld": "宽屏（旧）",
                    "phabletOld": "大平板（旧）",
                    "phoneOld": "手机（旧）",
                    "standard": "普通",
                    "tabletOld": "平板（旧）",
                    "tight": "大号",
                    "tinyOld": "小号（旧）"
                },
                "option": {
                    "feedbackLength": "震动时长",
                    "feedbackStrength": "震动强度",
                    "holdRun": "启动时自动按住奔跑键",
                    "interfaceStyle": "按钮样式",
                    "layoutStyle": "按键样式",
                    "resetLayout": "重置布局",
                    "sStartSpacing": "选择/开始键间距",
                    "scaleButtons": "按钮缩放",
                    "scaleDPad": "方向键缩放",
                    "scaleFactor": "按键全局缩放",
                    "showCodeButton": "显示作弊指令按钮"
                },
                "style": {
                    "ABXY": "ABXY",
                    "XODA": "XODA",
                    "actions": "动作"
                }
            },
            "types": {
                "gamepad": "手柄",
                "keyboard": "键盘",
                "oldJoystick": "老式手柄",
                "touchscreen": "触屏"
            },
            "wii": {
                "classic": {
                    "buttonLT": "LT",
                    "buttonRT": "RT",
                    "buttonX": "X",
                    "buttonY": "Y",
                    "buttonZL": "ZL",
                    "buttonZR": "ZR",
                    "lStick": "左摇杆",
                    "rStick": "右摇杆"
                },
                "nunchuck": {
                    "buttonC": "C",
                    "buttonZ": "Z",
                    "prefixN": "N"
                },
                "phraseNewClassic": "新建经典手柄配置",
                "phraseNewNunchuck": "新建双节棍控制器配置",
                "typeClassic": "经典手柄",
                "typeNunchuck": "双节棍控制器",
                "typeWiimote": "Wii遥控器",
                "wiimote": {
                    "button1": "1",
                    "button2": "2",
                    "buttonA": "A",
                    "buttonB": "B",
                    "buttonHome": "Home",
                    "buttonMinus": "-",
                    "buttonPlus": "+",
                    "caseIR": "（IR）",
                    "dPad": "十字键",
                    "shake": "摇晃"
                },
                "typeGamecube": "GC控制器"
            },
            "wordButtons": "按键",
            "wordProfiles": "配置",
            "joystickSimpleEditor": "简易编辑器控制模式"
        },
        "editor": {
            "errorMissingResources": "抱歉，需要文件：{0}，才能进入编辑器。",
            "newWorld": "<创建新地图>",
            "promptNewWorldName": "新地图名称",
            "battles": "<创建对战模式关卡>",
            "makeFor": "目标引擎："
        },
        "game": {
            "gameBattleRandom": "随机关卡",
            "gameCopySave": "复制存档",
            "gameEraseSave": "删除存档",
            "gameEraseSlot": "选择要删除的存档",
            "gameNoBattleLevels": "<对战关卡列表为空>",
            "gameNoEpisodesToPlay": "<地图列表为空>",
            "gameSlotContinue": "存档 {0} ... {1}%",
            "gameSlotNew": "存档 {0} ... 新游戏",
            "gameSourceSlot": "选择源存档",
            "gameTargetSlot": "选择目标存档",
            "phraseScore": "得分：{0}",
            "phraseTime": "时间：{0}",
            "warnEpCompat": "警告：该地图使用其他分支的SMBX引擎制作，在该引擎下可能无法正常运作。"
        },
        "loading": "加载中...",
        "main": {
            "main1PlayerGame": "单人游戏",
            "mainBattleGame": "对战模式",
            "mainEditor": "编辑器",
            "mainExit": "退出",
            "mainMultiplayerGame": "双人游戏",
            "mainOptions": "游戏选项",
            "mainPlayEpisode": "选择地图进行游戏"
        },
        "options": {
            "restartEngine": "重启引擎后生效",
            "advanced": {
                "audio-channels": {
                    "stereo": "立体声",
                    "_name": "输出声道",
                    "mono": "单声道"
                },
                "audio-buffer-size": {
                    "_tooltip": "降低未预期的噪音，增加延迟",
                    "_name": "缓冲大小"
                },
                "_tooltip": "有关内部操作的技术性设置选项",
                "advanced-video": "视频选项",
                "audio-enable": "启用声音",
                "audio-format": {
                    "_name": "音频格式",
                    "_tooltip": "声卡驱动音频格式"
                },
                "audio-sample-rate": {
                    "44100": "44100赫兹",
                    "48000": "48000赫兹",
                    "_name": "采样率",
                    "16000": "16000赫兹",
                    "32000": "32000赫兹",
                    "11025": "11025赫兹",
                    "22050": "22050赫兹"
                },
                "choose-assets-on-launch": "启动程序时，弹出选择组件界面",
                "log-level": {
                    "critical": "紧急状态",
                    "fatal": "异常中止",
                    "info": "信息",
                    "warning": "警告",
                    "debug": "调试",
                    "none": "关闭",
                    "_name": "日志记录等级"
                },
                "record-gameplay-data": "生成录像",
                "render": {
                    "_name": "图形渲染类型",
                    "hw": "自动选择",
                    "opengl": "OpenGL 3+",
                    "opengl-tip": "使用新版电脑渲染器，用于最精确的SMBX64模拟，并支持增强视觉效果。",
                    "opengl11-tip": "使用旧版电脑渲染器，仅用于最精确的SMBX64模拟，不支持增强视觉效果。",
                    "opengles-tip": "使用新版手机渲染器，用于高精确度的SMBX64模拟，并支持增强视觉效果。",
                    "opengles11-tip": "使用旧版手机渲染器，仅用于最精确的SMBX64模拟，不支持增强视觉效果。",
                    "sdl": "SDL2",
                    "sw": "软件渲染器",
                    "opengl11": "OpenGL 1.1",
                    "opengles": "OpenGL ES 2+",
                    "opengles11": "OpenGL ES 1.1+",
                    "sdl-tip": "使用SDL2，基础跨平台渲染器。"
                },
                "scale-down-textures": {
                    "_name": "缩小图片",
                    "all": "全部",
                    "none": "无",
                    "safe": "仅点阵2x",
                    "all-tip": "缩小全部图片：加载卡顿的概率比“仅点阵2x”低",
                    "none-tip": "不缩小任何图片：加载卡顿的概率更低",
                    "safe-tip": "仅点阵2x：如果图片为点阵2x，将缩小一半",
                    "_tooltip": "将图片缩小一半以释放内存"
                },
                "_header": "高级选项",
                "advanced-audio": "音频选项",
                "webm-recording": "录制WEBM视频",
                "internal-res-4p": {
                    "_name": "四人分屏模式画面大小",
                    "qhd": "2560x1440（QHD）",
                    "qsmbx": "1600x1200（QSMBX）",
                    "default": "默认",
                    "fhd": "1920x1080（FHD）"
                },
                "use-native-osk": "启用内置虚拟键盘",
                "inaccurate-gifs-tip": "当GIF图片文件存在时，启用3D效果",
                "inaccurate-gifs": "错误GIF图片渲染",
                "fullscreen-type": {
                    "desktop-tip": "以当前分辨率显示",
                    "desktop": "电脑",
                    "auto": "自动选择",
                    "_name": "全屏模式显示类型",
                    "exclusive-tip": "设置实际画面大小",
                    "exclusive": "独立设置"
                },
                "fullscreen-depth": {
                    "auto": "自动",
                    "_name": "位深",
                    "16": "16位",
                    "32": "32位"
                },
                "fullscreen-res": "分辨率"
            },
            "audio": {
                "_header": "音频选项",
                "sfx-audio-fx": "回音效果",
                "sfx-modern": "播放新增的声音",
                "sfx-modern-tip": "播放TheXTech引擎新增的声音",
                "sfx-pet-beat": "坐骑节奏",
                "sfx-pet-beat-tip": "骑上坐骑时，播放特殊节奏",
                "sfx-spatial-audio-tip": "减少画面外环境的音量",
                "audio-prefs": "偏好设置",
                "audio-music-volume": "音乐音量",
                "audio-sfx-volume": "声音音量",
                "sfx-spatial-audio": "三维音频"
            },
            "compatibility": {
                "_header": "游戏微调选项",
                "autocode": "LunaScript代码",
                "reset-all": "重置全部",
                "features": "新特性",
                "_tooltip": "兼容模式或调试模式选项，仅对当前游戏生效",
                "bugfixes": "BUG修复"
            },
            "controls": {
                "_header": "按键选项"
            },
            "episode-options": {
                "_header": "地图选项",
                "creator-compat": {
                    "_name": "创作者模式",
                    "_tooltip": "创作者相关的逻辑微调",
                    "disable": "关闭",
                    "enable": "开启",
                    "file-only": "仅文件"
                },
                "playstyle": {
                    "_name": "游戏模式",
                    "classic": "经典模式",
                    "modern": "现代模式",
                    "vanilla": "怀旧模式",
                    "classic-tip": "开启部分游戏更新",
                    "modern-tip": "开启全部游戏更新",
                    "vanilla-tip": "关闭全部游戏更新"
                },
                "hub-resume": "中心关卡：传送点记忆",
                "hub-resume-tip": "从上次进入的传送点继续游戏"
            },
            "main": {
                "_header": "常规选项",
                "background-work": "后台运行",
                "background-work-tip": "窗口未激活时，可通过手柄游玩",
                "four-screen-mode": {
                    "shared": "同屏",
                    "split": "分屏",
                    "_name": "四人游戏画面模式"
                },
                "frame-skip": "跳帧",
                "discord-rpc": "在Discord中显示",
                "multiplayer": "多人游戏",
                "timing": "帧数控制",
                "two-screen-mode": {
                    "_name": "双人游戏画面模式",
                    "shared": "同屏",
                    "smbx": "SMBX",
                    "topbottom": "上下分屏",
                    "split": "左右分屏"
                },
                "unlimited-framerate": "禁用锁帧",
                "vsync": "垂直同步",
                "language": "语言"
            },
            "video": {
                "_header": "视频选项",
                "battery-status": {
                    "fullscreen": "全屏时显示",
                    "fullscreen-tip": "全屏游戏时，显示电池电量",
                    "_name": "电池状态",
                    "low": "仅在低电量时显示",
                    "low-tip": "在电池电量低时，显示电池电量",
                    "off": "隐藏",
                    "on": "显示"
                },
                "display-controllers": "显示按键",
                "effects": "画面效果",
                "fullscreen": "全屏模式",
                "info-game": "画面中游戏信息",
                "info-meta": "画面中元数据信息",
                "info-run": "画面中运行时信息",
                "internal-res": {
                    "3ds": "800x480 (3DS)",
                    "_name": "画面大小",
                    "_tooltip": "设置游戏画面大小",
                    "dynamic": "自适应",
                    "vga": "640x480（VGA）",
                    "hd": "1280x720（高清）",
                    "gba": "480x320（GBA）",
                    "nds": "512x384（DS）",
                    "snes": "512x448（SFC）",
                    "hello": "768x432（HELLO引擎）",
                    "smbx-wide": "SMBX（宽屏）",
                    "smbx": "800x600（SMBX）"
                },
                "enable-inter-level-fade-effect": "过渡效果",
                "show-episode-title": {
                    "bottom": "底部",
                    "off": "隐藏",
                    "_name": "显示当前地图",
                    "bottom-tip": "在秒表计时器的上方显示当前地图",
                    "top-tip": "在游戏画面大小较大时，在状态栏上方显示当前地图",
                    "top": "顶部"
                },
                "show-playtime-counter": {
                    "_tooltip": "显示当前地图和当前关卡的游玩时间",
                    "animated-tip": "过关时，为秒表计时器添加彩虹特效",
                    "off": "关闭",
                    "off-tip": "仅在速通时显示秒表计时器",
                    "opaque": "开启（不透明）",
                    "transparent": "开启（透明）",
                    "_name": "秒表计时器",
                    "animated": "动态特效"
                },
                "video-system": "系统选项",
                "show-screen-shake": "画面震动",
                "world-map-stars-show": "大地图上显示星星数量",
                "world-map-stars-show-tip": "在关卡上方显示已收集星星数量",
                "show-fps": "显示帧数",
                "scale-mode": {
                    "integer": "整数",
                    "center": "中心",
                    "0_5x": "0.5倍",
                    "2x": "2倍",
                    "_name": "图像缩放",
                    "1x": "1倍",
                    "nearest": "最近邻居",
                    "full": "完全缩放",
                    "linear": "双线性",
                    "3x": "3倍"
                },
                "3d-compat-mode": "三维兼容模式",
                "3d-compat-mode-tip": "在同一个三维平面下绘制所有对象",
                "show-fails-counter": "显示失败次数",
                "show-fails-counter-tip": "显示当前关卡和当前地图的失败次数",
                "show-medals-counter": "显示奖牌数量",
                "show-medals-counter-tip": "当玩家在关卡入口处时，在状态栏上显示奖牌数量"
            },
            "view-credits": {
                "_header": "查看制作团队"
            },
            "speedrun": {
                "mode": {
                    "_name": "秒表计时模式",
                    "0": "0（默认）",
                    "1": "1（现代）",
                    "3": "3（怀旧）",
                    "2": "2（经典）"
                }
            }
        },
        "wordBack": "返回",
        "wordHide": "隐藏",
        "wordNo": "否",
        "wordOff": "关闭",
        "wordOn": "开启",
        "wordPlayer": "玩家",
        "wordProfile": "配置",
        "wordResume": "恢复游戏",
        "wordShow": "显示",
        "wordWaiting": "等待",
        "wordYes": "是"
    },
    "outro": {
        "cppPortDevelopers": "C++移植开发人员：",
        "customSprites": "自定义素材：",
        "engineCredits": "引擎制作人员名单：",
        "gameCredits": "游戏制作人员名单:",
        "levelDesign": "关卡设计：",
        "nameAndrewSpinks": "安德鲁·斯宾克斯",
        "nameVitalyNovichkov": "维塔利·诺维奇科夫",
        "originalBy": "原始VB6代码：",
        "psVitaPortBy": "PS Vita移植：",
        "specialThanks": "特别鸣谢：",
        "qualityControl": "品质管理："
    },
    "pluralRules": "singular-only"
}


================================================
FILE: resources/languages/thextech_zh-tw.json
================================================
{
    "editor": {
        "block": {
            "canBreak": "可頂碎",
            "canBreakTooltip": "舊版本：頂磚塊後將會破碎",
            "inside": "包含：",
            "invis": "隱形",
            "letterHeight": "高 ",
            "letterWidth": "寬 ",
            "pickContents": "選擇磚塊包含道具",
            "slick": "打滑"
        },
        "browser": {
            "askOverwriteFile": "是否覆蓋檔案{0}？",
            "itemNewFile": "<新建檔案>",
            "itemNewFolder": "<新建資料夾>",
            "newFile": "新建檔案",
            "openFile": "打開檔案",
            "saveFile": "刪除檔案"
        },
        "events": {
            "bounds": {
                "changeAllSectionBoundsToCurrent": "改變所有場景範圍到當前設定嗎？",
                "changeSectionBoundsToCurrent": "改變場景{0}的範圍到當前設定嗎？",
                "shouldEvent": "要使事件{0}"
            },
            "controlsForEventN": "強制按下玩家按鍵：{0}",
            "deletion": {
                "cancel": "否：不刪除事件",
                "confirm": "是：刪除事件",
                "deletingEvent": "刪除{0}事件"
            },
            "desc": {
                "activate": "NPC在當前畫面出現時",
                "death": "NPC死亡時",
                "destroy": "磚塊破碎時",
                "enter": "進入傳送點時",
                "hit": "磚塊被撞擊時",
                "layerClear": "當前圖層中的對象爲空時",
                "phraseTriggersAfterTemplate": "將於事件：{2}經過{1}毫秒之後，觸發{0}事件",
                "phraseTriggersWhenTemplate": "{0}：{1}觸發該事件",
                "talk": "和NPC對話後"
            },
            "header": "事件：",
            "headerTriggerEvent": "觸發",
            "itemNewEvent": "<新事件>",
            "label": {
                "activate": "出現",
                "death": "死亡",
                "destroy": "破碎",
                "enter": "進入傳送點",
                "hit": "撞擊",
                "layerClear": "空白圖層",
                "next": "下一個",
                "talk": "對話"
            },
            "layers": {
                "headerHide": "隱藏：",
                "headerMove": "移動：",
                "headerShow": "顯示：",
                "headerToggle": "切換："
            },
            "letter": {
                "activate": "出：",
                "death": "死：",
                "destroy": "碎：",
                "enter": "進：",
                "hit": "撞：",
                "layerClear": "空：",
                "talk": "話："
            },
            "promptEventName": "事件名稱：",
            "promptEventText": "文字信息：",
            "props": {
                "autostart": "進入關卡時執行事件",
                "controls": "按鍵",
                "endGame": "遊戲通關",
                "sound": "音效",
                "layerSmoke": "圖層煙霧效果"
            },
            "sections": {
                "actionKeep": "當前",
                "actionReset": "默認",
                "actionSet": "指定",
                "phraseAllSections": "所有場景",
                "propBackground": "背景圖片",
                "propBounds": "場景範圍",
                "propMusic": "音樂"
            },
            "settingsForEvent": "{0}事件選項"
        },
        "file": {
            "actionClearLevel": "清除關卡",
            "actionClearWorld": "清除大地圖",
            "actionExit": "退出",
            "actionOpen": "打開",
            "actionRevert": "恢復",
            "commandNew": "新建",
            "commandOpen": "打開...",
            "commandSave": "保存",
            "commandSaveAs": "另存爲...",
            "confirmConfirmAction": "您確定要{0}嗎？",
            "confirmConvertFormatTo": "是否轉換格式到{0}？",
            "confirmSaveBeforeAction": "{0}前是否保存檔案？",
            "convert": {
                "descNew": "檔案格式將會轉換，但不會刪除原始檔。\n\n請在保存檔案之後檢查不支持的功能。"
            },
            "formatLegacy": "舊版本",
            "formatModern": "新版本",
            "labelCurrentFile": "當前檔案：",
            "labelFormat": "格式：",
            "optionActionWithoutSave": "否：{0}而不保存檔案",
            "optionCancelAction": "取消：返回上一級菜單",
            "optionCancelConversion": "取消轉換",
            "optionProceedWithConversion": "確認轉換",
            "optionYesSaveThenAction": "是：{0}並保存檔案",
            "sectionLevel": "關卡",
            "sectionWorld": "大地圖"
        },
        "layers": {
            "abbrevAttLayer": "跟隨：",
            "default": "缺省",
            "deletion": {
                "cancel": "取消：返回上一級菜單",
                "confirmDelete": "否：*刪除全部對象*",
                "confirmPreserve": "是：移動到缺省圖層",
                "header": "刪除{0}圖層",
                "preserveLayerContents": "是否保留圖層對象？"
            },
            "desc": {
                "att": "當 NPC 移動時，圖層也將隨之移動"
            },
            "header": "圖層：",
            "itemNewLayer": "<新圖層>",
            "label": "圖層：",
            "labelAttached": "跟隨：",
            "labelAttachedLayer": "跟隨圖層：",
            "labelMoveLayer": "移動圖層：",
            "promptLayerName": "圖層名稱"
        },
        "letterCoordX": "X",
        "letterCoordY": "Y",
        "letterDown": "下",
        "letterLeft": "左",
        "letterRight": "右",
        "letterUp": "上",
        "level": {
            "alwaysVis": "總是可見",
            "bigBG": "大背景",
            "gameStart": "遊戲起點",
            "levelName": "關卡名稱",
            "pathBG": "路線背景",
            "pathUnlocks": "路線開啓",
            "startPos": "遊戲起點"
        },
        "mapPos": "地圖位置：",
        "npc": {
            "abbrevGen": "生成器",
            "ai": {
                "LR": "左右",
                "UD": "上下",
                "aiIs": "動作：{0}",
                "headerCustomAi": "自定義動作：",
                "jump": "跳躍",
                "leap": "飛躍",
                "swim": "游泳",
                "target": "目標",
                "use1_0Ai": "使用1.0 AI？"
            },
            "gen": {
                "direction": "方向",
                "effectIs": "特效：{0}",
                "effectShoot": "噴射",
                "effectWarp": "水管",
                "header": "生成器選項"
            },
            "inContainer": "包含",
            "inertNice": "友好",
            "props": {
                "active": "啓動",
                "attachSurface": "位置",
                "facing": "方向"
            },
            "stuckStop": "靜止",
            "tooltipExpandSection": "擴展場景"
        },
        "pageBlankOfBlank": "第{0}/{1}頁",
        "phraseAreYouSure": "您確定嗎？",
        "phraseCountMore": "更多{0}",
        "phraseDelayIsMs": "延遲：{0}毫秒",
        "phraseGenericIndex": "編號：{0}",
        "phraseRadiusIndex": "半徑：{0}",
        "phraseSectionIndex": "場景{0}",
        "phraseTextOf": "{0}的文字信息",
        "phraseWarpIndex": "傳送點{0}號",
        "section": {
            "horizWrap": "橫向循環",
            "noTurnBack": "單向卷軸",
            "offscreenExit": "場景邊緣出口",
            "scroll": "強制卷軸",
            "setBounds": "設定範圍",
            "underwater": "水下",
            "vertWrap": "縱向循環"
        },
        "select": {
            "allSectPropBlankForEventN": "更改所有場景{0}於{1}事件",
            "pathBlankUnlock": "路線向{0}開啓條件",
            "sectBlankPropBlankForEventN": "更改場景{0}的{1}於{2}事件",
            "sectionBlankPropBlank": "場景{0}{1}",
            "soundForEventN": "執行{0}事件時播放聲音",
            "warpTransitEffect": "過渡效果",
            "worldMusic": "大地圖音樂"
        },
        "testPlay": {
            "boot": "靴子",
            "char": "角色",
            "magicHand": "鼠標",
            "pet": "坐騎",
            "power": "狀態"
        },
        "toggleMagicBlock": "智能編輯模式",
        "tooltip": {
            "BGOs": "背景對象",
            "NPCs": "NPC",
            "blocks": "磚塊",
            "erase": "刪除",
            "eraseAll": "刪除全部",
            "events": "事件",
            "file": "檔案",
            "layers": "圖層",
            "levels": "關卡",
            "music": "音樂",
            "paths": "路線",
            "scenes": "風景",
            "select": "選擇",
            "settings": "設定",
            "show": "顯示",
            "tiles": "地形",
            "warps": "傳送點",
            "water": "水流",
            "area": "地圖區域"
        },
        "warp": {
            "allow": "允許：",
            "cannonExit": "水管炮出口",
            "dir": "方向",
            "effect": "過渡效果：",
            "in": "入口",
            "item": "攜帶道具",
            "lvlWarp": "傳送到另一關卡",
            "needFloor": "需要站立",
            "needKey": "需要鑰匙",
            "needStarCount": "需要{0}{2}{1}",
            "out": "出口",
            "placing": "放置：",
            "ride": "坐騎",
            "showStarCount": "顯示星星數量",
            "showStartScene": "顯示開場界面",
            "speed": "速度：",
            "starLockMessage": "需要星星時的信息",
            "style": {
                "blipInstant": "瞬移",
                "door": "門",
                "pipe": "水管",
                "portal": "傳送門",
                "style": "傳送類別："
            },
            "target": "目標：",
            "title": "傳送點",
            "to": "傳送到：{0}",
            "toMap": "傳送到大地圖",
            "transit": {
                "name0": "無",
                "name1": "滾動",
                "name2": "淡入淡出",
                "name3": "圓形",
                "name4": "水平翻轉",
                "name5": "垂直翻轉"
            },
            "twoWay": "雙向傳送"
        },
        "water": {
            "title": "流體"
        },
        "wordCoins": "金幣",
        "wordEnabled": "已啓用",
        "wordEvent": {
            "genitive": "事件",
            "nominative": "事件",
            "typeLabel": "觸發{0}事件："
        },
        "wordHeight": "高",
        "wordInstant": "立即",
        "wordMode": "流體類型",
        "wordNPC": {
            "genitive": "NPC",
            "nominative": "NPC"
        },
        "wordText": "信息",
        "wordWidth": "寬",
        "world": {
            "allowChars": "可用角色",
            "hubWorld": "禁用大地圖",
            "introLevel": "開場關卡",
            "name": "地圖名稱",
            "phraseCreditIndex": "地圖製作團隊 第{0}行：",
            "retryOnFail": "失敗之後重新開始",
            "totalStars": "總星星數："
        },
        "labelSortOffset": "疊放次序：",
        "labelSortLayer": "疊放圖層："
    },
    "game": {
        "connect": {
            "dropAddTitle": "加入/離開遊戲",
            "phraseChangeChar": "更換角色",
            "phraseDropMe": "離開遊戲",
            "phraseDropPX": "移除玩家{0}的遊戲",
            "phraseForceResume": "強制恢復遊戲",
            "phraseHoldStart": "按住開始鍵",
            "phrasePressAButton": "按下一個按鍵",
            "phraseSetControls": "設定按鍵",
            "phraseStartToForceRes": "按開始鍵強制恢復遊戲",
            "phraseStartToResume": "按開始鍵恢復遊戲",
            "phraseTestControls": "測試按鍵",
            "phraseWaitingForInput": "等待玩家加入……",
            "reconnectTitle": "重新連接",
            "splitPressSelect_1": "按選擇鍵",
            "splitPressSelect_2": "進入按鍵選項設定",
            "wordDisconnect": "斷開",
            "phraseTestProfile": "測試配置"
        },
        "error": {
            "errorInvalidEnterWarp": "作爲關卡起點的傳送點{1}號不存在，因此無法進入關卡。\n傳送點總數：{2}\n\n檔案：{0}",
            "errorNoStartPoint": "未放置玩家起點或傳送點入口，因此無法進入關卡。\n\n檔案：{0}",
            "openFileFailed": "無法打開檔案\"{0}\"：檔案不存在或已損壞。",
            "warpNeedStarCount": "你需要{0}{2}{1}才能進入此傳送點。",
            "openIPCDataFailed": "無法接收檔案數據：檔案可能已損壞，或者發生其他錯誤。",
            "IPCTimeOut": "載入編輯器時無響應，即將退出遊戲。",
            "errorTooOldEngine": "該檔案需要版本{0}或更高版本的TheXTech引擎才能正常運作，當前TheXTech引擎版本為{1}。請更新引擎。",
            "errorTooOldGameAssets": "該檔案需要版本{0}或更高版本的遊戲組件才能正常運作，當前遊戲組件版本為{1}。請更新遊戲組件。"
        },
        "pause": {
            "continue": "繼續遊戲",
            "enterCode": "輸入指令",
            "quit": "退出",
            "quitTesting": "結束測試",
            "resetCheckpoints": "重置中間點",
            "restartLevel": "重新開始",
            "returnToEditor": "返回編輯器",
            "saveAndContinue": "保存並繼續",
            "saveAndQuit": "保存並退出",
            "playerSetup": "玩家設定"
        },
        "msgbox": {
            "sysInfoError": "錯誤！",
            "sysInfoWarning": "警告！",
            "sysInfoTitle": "信息"
        },
        "format": {
            "minutesSeconds": "{0}分{1}秒"
        },
        "message": {
            "scanningLevels": "掃描關卡中……"
        },
        "hint": {
            "no-lives-old": "注意：如果本次通關失敗，遊戲將會結束！",
            "no-lives-new": "即使本次通關失敗，也沒什麼事情發生；請注意查看您的積分……",
            "char5-bombs": "按下“奔跑”鍵可收集炸彈，按下“第二奔跑”鍵可投擲炸彈。",
            "gray-bricks": "神秘力量可以破壞部分磚塊。",
            "rainbow-surf": "在拿起彩虹龜殼的時候，按下“下”鍵，開始衝浪吧！",
            "shoe-block": "穿上鞋子時，可以抵擋大多數火焰！",
            "heavy-duck": "玩家下蹲時，可以抵擋大多數火焰！",
            "pound-altrun": "按下“第二奔跑”鍵，進行震地！",
            "pound-down": "按下“下”鍵，進行震地！"
        },
        "screenPaused": "遊戲暫停",
        "ipcStatus": {
            "waitingInput": "等待玩家按鍵輸入……",
            "loadingdone": "載入完成，即將開始遊戲……",
            "errorTimeout": "錯誤：等待超時。",
            "dataValid": "接收的數據是有效數據",
            "dataTransferStarted": "開始傳輸數據……",
            "dataAccepted": "已接收到數據，開始解析……"
        },
        "loader": {
            "statusAssetPacks": "遊戲組件",
            "statusFinishing": "完成加載……",
            "statusGameInfo": "遊戲信息",
            "statusLoadData": "正在加載數據……",
            "statusLoadFile": "正在加載：{0}",
            "statusTranslations": "翻譯",
            "loading": "加載中……"
        }
    },
    "languageName": "繁體中文",
    "menu": {
        "abbrevMilliseconds": "毫秒",
        "battle": {
            "errorNoLevels": "對戰關卡列表爲空，無法進入對戰模式。"
        },
        "caseNone": "<無>",
        "character": {
            "selectCharacter": "{0}遊戲"
        },
        "controls": {
            "buttons": {
                "altJump": "第二跳躍",
                "altRun": "第二奔跑",
                "down": "下",
                "drop": "取出道具",
                "jump": "跳躍",
                "left": "左",
                "right": "右",
                "run": "奔跑",
                "start": "開始",
                "up": "上"
            },
            "caseInvalid": "（無效）",
            "caseMouse": "（鼠標）",
            "caseTouch": "（觸屏）",
            "controlsConnected": "已連接：",
            "controlsDeleteKey": "（按第二跳躍鍵清除）",
            "controlsDeleteKey2": "（按第二奔跑鍵清除）",
            "controlsDeviceTypes": "設備類型",
            "controlsInUse": "（已使用）",
            "controlsNewProfile": "<新建配置>",
            "controlsNotInUse": "（未使用）",
            "controlsReallyDeleteProfile": "是否刪除配置？",
            "controlsTitle": "按鍵配置",
            "cursor": {
                "down": "鼠標向下移動",
                "left": "鼠標向左移動",
                "primary": "鼠標左鍵",
                "right": "鼠標向右移動",
                "secondary": "鼠標右鍵",
                "tertiary": "鼠標滾輪",
                "up": "鼠標向上移動"
            },
            "editor": {
                "fastScroll": "快速滾動",
                "modeErase": "橡皮擦",
                "modeSelect": "選擇模式",
                "nextSection": "下一場景",
                "prevSection": "上一場景",
                "scrollDown": "向下滾動",
                "scrollLeft": "向左滾動",
                "scrollRight": "向右滾動",
                "scrollUp": "向上滾動",
                "switchScreens": "顯示面板",
                "testPlay": "測試關卡"
            },
            "hotkeys": {
                "debugInfo": "調試信息",
                "enterCheats": "輸入作弊指令",
                "fullscreen": "全屏",
                "legacyPause": "舊版暫停菜單",
                "recordGif": "GIF 動畫錄製",
                "screenshot": "截圖",
                "toggleHUD": "狀態欄切換",
                "vanillaCam": "原始畫面大小"
            },
            "options": {
                "batteryStatus": "電池狀態",
                "maxPlayers": "玩家上限",
                "rumble": "Rumble控制器",
                "textEntryStyle": "文字輸入使用設備",
                "altMenuControls": "切換確定/返回按鍵"
            },
            "phraseNewProfOldJoy": "新建老式手柄配置",
            "profile": {
                "cursorControls": "鼠標控制",
                "deleteProfile": "刪除配置",
                "editorControls": "編輯器控制",
                "hotkeys": "熱鍵",
                "playerControls": "玩家控制",
                "renameProfile": "重命名配置"
            },
            "tDS": {
                "buttonA": "A",
                "buttonB": "B",
                "buttonL": "L",
                "buttonR": "R",
                "buttonSelect": "選擇",
                "buttonStart": "開始",
                "buttonX": "X",
                "buttonY": "Y",
                "buttonZL": "ZL",
                "buttonZR": "ZR",
                "cStick": "右搖桿",
                "casePen": "(觸控筆)",
                "dPad": "方向鍵",
                "tStick": "左搖桿"
            },
            "touchscreen": {
                "layout": {
                    "longOld": "寬屏（舊）",
                    "phabletOld": "大平板（舊）",
                    "phoneOld": "手機（舊）",
                    "standard": "普通",
                    "tabletOld": "平板（舊）",
                    "tight": "大號",
                    "tinyOld": "小號（舊）"
                },
                "option": {
                    "feedbackLength": "震動時長",
                    "feedbackStrength": "震動強度",
                    "holdRun": "啓動時自動按住奔跑鍵",
                    "interfaceStyle": "按鈕樣式",
                    "layoutStyle": "按鍵樣式",
                    "resetLayout": "重置佈局",
                    "sStartSpacing": "選擇/開始鍵間距",
                    "scaleButtons": "按鈕縮放",
                    "scaleDPad": "方向鍵縮放",
                    "scaleFactor": "按鍵全局縮放",
                    "showCodeButton": "顯示作弊指令按鈕"
                },
                "style": {
                    "ABXY": "ABXY",
                    "XODA": "XODA",
                    "actions": "動作"
                }
            },
            "types": {
                "gamepad": "手柄",
                "keyboard": "鍵盤",
                "oldJoystick": "老式手柄",
                "touchscreen": "觸屏"
            },
            "wii": {
                "classic": {
                    "buttonLT": "LT",
                    "buttonRT": "RT",
                    "buttonX": "X",
                    "buttonY": "Y",
                    "buttonZL": "ZL",
                    "buttonZR": "ZR",
                    "lStick": "左搖桿",
                    "rStick": "右搖桿"
                },
                "nunchuck": {
                    "buttonC": "C",
                    "buttonZ": "Z",
                    "prefixN": "N"
                },
                "phraseNewClassic": "新建經典手柄配置",
                "phraseNewNunchuck": "新建雙節棍控制器配置",
                "typeClassic": "經典手柄",
                "typeNunchuck": "雙節棍控制器",
                "typeWiimote": "Wii遙控器",
                "wiimote": {
                    "button1": "1",
                    "button2": "2",
                    "buttonA": "A",
                    "buttonB": "B",
                    "buttonHome": "Home",
                    "buttonMinus": "-",
                    "buttonPlus": "+",
                    "caseIR": "（IR）",
                    "dPad": "十字鍵",
                    "shake": "搖晃"
                },
                "typeGamecube": "GC控制器"
            },
            "wordButtons": "按鍵",
            "wordProfiles": "配置",
            "joystickSimpleEditor": "簡單編輯器控制模式"
        },
        "editor": {
            "errorMissingResources": "抱歉，需要檔案：{0}，才能進入編輯器。",
            "newWorld": "<新地圖>",
            "promptNewWorldName": "新地圖名稱",
            "battles": "<對戰關卡>",
            "makeFor": "目標引擎："
        },
        "game": {
            "gameBattleRandom": "隨機關卡",
            "gameCopySave": "複製存檔",
            "gameEraseSave": "刪除存檔",
            "gameEraseSlot": "選擇要刪除的存檔",
            "gameNoBattleLevels": "<對戰關卡列表爲空>",
            "gameNoEpisodesToPlay": "<地圖列表爲空>",
            "gameSlotContinue": "存檔 {0} ... {1}%",
            "gameSlotNew": "存檔 {0} ... 新遊戲",
            "gameSourceSlot": "選擇源存檔",
            "gameTargetSlot": "選擇目標存檔",
            "phraseScore": "積分：{0}",
            "phraseTime": "時間：{0}",
            "warnEpCompat": "警告：該地圖使用其他分支的SMBX引擎製作，在該引擎下可能無法正常運作。"
        },
        "loading": "加載中...",
        "main": {
            "main1PlayerGame": "單人遊戲",
            "mainBattleGame": "對戰模式",
            "mainEditor": "編輯器",
            "mainExit": "退出",
            "mainMultiplayerGame": "雙人遊戲",
            "mainOptions": "遊戲選項",
            "mainPlayEpisode": "開始遊戲"
        },
        "options": {
            "restartEngine": "重啓引擎后生效",
            "advanced": {
                "scale-down-textures": {
                    "all-tip": "縮小全部圖片：載入卡頓的機率比“僅點陣2x”低",
                    "none-tip": "不縮小任何圖片：載入卡頓的機率更低",
                    "_tooltip": "將圖片縮小一半以釋放內存",
                    "none": "無",
                    "_name": "縮小圖片",
                    "safe": "僅點陣2x",
                    "safe-tip": "僅點陣2x：如果圖片為點陣2x，將縮小一半",
                    "all": "全部"
                },
                "audio-enable": "啟用聲音",
                "render": {
                    "sdl-tip": "使用SDL2，基礎跨平臺渲染器。",
                    "_name": "圖形渲染類型",
                    "hw": "自動選擇",
                    "sw": "軟件渲染器",
                    "opengl": "OpenGL 3+",
                    "opengl11": "OpenGL 1.1",
                    "opengl-tip": "使用新版電腦渲染器，用於最精確的SMBX64模擬，並支持增強視覺效果。",
                    "opengl11-tip": "使用舊版電腦渲染器，僅用於最精確的SMBX64模擬，不支持增強視覺效果。",
                    "opengles": "OpenGL ES 2+",
                    "opengles11": "OpenGL ES 1.1+",
                    "opengles-tip": "使用新版手機渲染器，用於高精確度的SMBX64模擬，並支持增強視覺效果。",
                    "opengles11-tip": "使用舊版手機渲染器，僅用於最精確的SMBX64模擬，不支援增強視覺效果。",
                    "sdl": "SDL2"
                },
                "_header": "高階設定",
                "_tooltip": "有關內部操作的技術性設定選項",
                "advanced-audio": "音訊選項",
                "advanced-video": "視訊選項",
                "log-level": {
                    "debug": "調試",
                    "fatal": "異常中止",
                    "none": "關閉",
                    "_name": "日誌記錄等級",
                    "critical": "緊急狀態",
                    "info": "信息",
                    "warning": "警告"
                },
                "record-gameplay-data": "生成録像",
                "audio-channels": {
                    "mono": "單聲道",
                    "stereo": "立體聲",
                    "_name": "輸出聲道"
                },
                "audio-buffer-size": {
                    "_name": "緩衝大小",
                    "_tooltip": "降低未預期的噪音，增加延遲"
                },
                "audio-format": {
                    "_name": "音訊格式",
                    "_tooltip": "音效卡驅動音訊格式"
                },
                "audio-sample-rate": {
                    "11025": "11025赫茲",
                    "16000": "16000赫茲",
                    "22050": "22050赫茲",
                    "32000": "32000赫茲",
                    "44100": "44100赫茲",
                    "48000": "48000赫茲",
                    "_name": "取樣率"
                },
                "choose-assets-on-launch": "啟動程序時，彈出選擇組件介面",
                "webm-recording": "録製WEBM視訊",
                "internal-res-4p": {
                    "fhd": "1920x1080（FHD）",
                    "qhd": "2560x1440（QHD）",
                    "qsmbx": "1600x1200（QSMBX）",
                    "_name": "四人分屏模式畫面大小",
                    "default": "缺省"
                },
                "use-native-osk": "啓用內置虛擬鍵盤",
                "inaccurate-gifs": "錯誤GIF圖片渲染",
                "inaccurate-gifs-tip": "當GIF圖片檔案存在時，啟用3D效果",
                "fullscreen-type": {
                    "_name": "全屏模式顯示類型",
                    "auto": "自動選擇",
                    "desktop": "電腦",
                    "desktop-tip": "以當前分辨率顯示",
                    "exclusive-tip": "設置實際畫面大小",
                    "exclusive": "獨立設置"
                },
                "fullscreen-depth": {
                    "32": "32位",
                    "_name": "位深",
                    "16": "16位",
                    "auto": "自動"
                },
                "fullscreen-res": "分辨率"
            },
            "audio": {
                "audio-sfx-volume": "聲音音量",
                "sfx-modern": "播放新增的聲音",
                "sfx-audio-fx": "迴音效果",
                "sfx-modern-tip": "播放TheXTech引擎新增的聲音",
                "sfx-pet-beat": "坐騎節奏",
                "sfx-spatial-audio": "三維音訊",
                "sfx-spatial-audio-tip": "減少畫面外環境的音量",
                "audio-prefs": "偏好設定",
                "audio-music-volume": "音樂音量",
                "sfx-pet-beat-tip": "騎上坐騎時，播放特殊節奏",
                "_header": "音訊選項"
            },
            "compatibility": {
                "features": "新特性",
                "_header": "遊戲微調選項",
                "_tooltip": "兼容模式或調試模式選項，僅對當前遊戲生效",
                "bugfixes": "BUG修復",
                "autocode": "LunaScript代碼",
                "reset-all": "重置全部"
            },
            "episode-options": {
                "creator-compat": {
                    "enable": "開啓",
                    "disable": "關閉",
                    "_tooltip": "創作者相關的邏輯微調",
                    "_name": "創作者模式",
                    "file-only": "僅檔案"
                },
                "_header": "地圖選項",
                "playstyle": {
                    "_name": "遊戲模式",
                    "classic": "經典模式",
                    "classic-tip": "開啟部分遊戲更新",
                    "modern": "現代模式",
                    "modern-tip": "開啟全部遊戲更新",
                    "vanilla-tip": "關閉全部遊戲更新",
                    "vanilla": "懷舊模式"
                },
                "hub-resume": "中心關卡：傳送點記憶",
                "hub-resume-tip": "從上次進入的傳送點繼續遊戲"
            },
            "main": {
                "two-screen-mode": {
                    "topbottom": "上下分屏",
                    "_name": "雙人遊戲畫面模式",
                    "shared": "同屏",
                    "smbx": "SMBX",
                    "split": "左右分屏"
                },
                "unlimited-framerate": "禁用鎖幀",
                "_header": "常規選項",
                "background-work": "後臺執行",
                "background-work-tip": "窗口未激活時，可通過手柄遊玩",
                "four-screen-mode": {
                    "_name": "四人遊戲畫面模式",
                    "shared": "同屏",
                    "split": "分屏"
                },
                "frame-skip": "跳幀",
                "multiplayer": "多人遊戲",
                "timing": "幀數控制",
                "discord-rpc": "在Discord中顯示",
                "language": "語言",
                "vsync": "垂直同步"
            },
            "video": {
                "battery-status": {
                    "fullscreen-tip": "全屏遊戲時，顯示電池電量",
                    "_name": "電池狀態",
                    "on": "顯示",
                    "fullscreen": "全屏時顯示",
                    "low": "僅在低電量時顯示",
                    "low-tip": "在電池電量低時，顯示電池電量",
                    "off": "隱藏"
                },
                "info-meta": "畫面中元數據信息",
                "show-episode-title": {
                    "bottom": "底部",
                    "off": "隱藏",
                    "top": "頂部",
                    "bottom-tip": "在秒錶計時器的上方顯示當前地圖",
                    "top-tip": "在遊戲畫面大小較大時，在狀態列上方顯示當前地圖",
                    "_name": "顯示當前地圖"
                },
                "show-fails-counter": "顯示失敗次數",
                "show-playtime-counter": {
                    "_name": "秒錶計時器",
                    "off-tip": "僅在速通時顯示秒錶計時器",
                    "animated": "動態特效",
                    "_tooltip": "顯示當前地圖和當前關卡的遊玩時間",
                    "transparent": "開啟（透明）",
                    "opaque": "開啟（不透明）",
                    "off": "關閉",
                    "animated-tip": "過關時，為秒錶計時器新增彩虹特效"
                },
                "world-map-stars-show": "大地圖上顯示星星數量",
                "video-system": "系統選項",
                "show-screen-shake": "畫面震動",
                "show-medals-counter": "顯示獎牌數量",
                "3d-compat-mode": "三維兼容模式",
                "3d-compat-mode-tip": "在同一個三維平面下繪製所有物件",
                "world-map-stars-show-tip": "在關卡上方顯示已收集星星數量",
                "show-fps": "顯示幀數",
                "show-medals-counter-tip": "當玩家在關卡入口處時，在狀態列上顯示獎牌數量",
                "show-fails-counter-tip": "顯示當前關卡和當前地圖的失敗次數",
                "effects": "畫面效果",
                "enable-inter-level-fade-effect": "過渡效果",
                "fullscreen": "全屏模式",
                "display-controllers": "顯示按鍵",
                "internal-res": {
                    "nds": "512x384（DS）",
                    "hd": "1280x720（高清）",
                    "gba": "480x320（GBA）",
                    "dynamic": "自適應",
                    "hello": "768x432（HELLO引擎）",
                    "3ds": "800x480 (3DS)",
                    "_name": "畫面大小",
                    "_tooltip": "設定遊戲畫面大小",
                    "smbx-wide": "SMBX（寬屏）",
                    "snes": "512x448（SFC）",
                    "vga": "640x480（VGA）",
                    "smbx": "800x600（SMBX）"
                },
                "_header": "視訊選項",
                "info-game": "畫面中游戲信息",
                "info-run": "畫面中執行時信息",
                "scale-mode": {
                    "0_5x": "0.5倍",
                    "1x": "1倍",
                    "2x": "2倍",
                    "_name": "圖像縮放",
                    "integer": "整數",
                    "linear": "雙綫性",
                    "nearest": "最近鄰居",
                    "full": "完全縮放",
                    "center": "中心",
                    "3x": "3倍"
                }
            },
            "view-credits": {
                "_header": "查看製作團隊"
            },
            "controls": {
                "_header": "按鍵選項"
            },
            "speedrun": {
                "mode": {
                    "0": "0（默認）",
                    "1": "1（現代）",
                    "2": "2（經典）",
                    "3": "3（懷舊）",
                    "_name": "秒錶計時模式"
                }
            }
        },
        "wordBack": "返回",
        "wordHide": "隱藏",
        "wordNo": "否",
        "wordOff": "關閉",
        "wordOn": "開啓",
        "wordPlayer": "玩家",
        "wordProfile": "配置",
        "wordResume": "恢復遊戲",
        "wordShow": "顯示",
        "wordWaiting": "等待",
        "wordYes": "是"
    },
    "outro": {
        "cppPortDevelopers": "C++移植開發人員：",
        "customSprites": "自定義素材：",
        "engineCredits": "引擎製作人員名單：",
        "gameCredits": "遊戲製作人員名單:",
        "levelDesign": "關卡設計：",
        "nameAndrewSpinks": "安德魯·斯賓克斯",
        "nameVitalyNovichkov": "維塔利·諾維奇科夫",
        "originalBy": "原始VB6代碼：",
        "psVitaPortBy": "PS Vita移植：",
        "specialThanks": "特別鳴謝：",
        "qualityControl": "品質管理："
    },
    "pluralRules": "singular-only"
}


================================================
FILE: resources/switch/Important.txt
================================================
The valid icon must be:
- Should be a JPEG format
- No EXIF included, absolutely
- 256x256 size


================================================
FILE: resources/thextech.plist.in
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleDocumentTypes</key>
	<array>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>lvl</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_lvl.icns</string>
			<key>CFBundleTypeName</key>
			<string>SMBX64/38A Level File</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>lvlx</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_lvlx.icns</string>
			<key>CFBundleTypeName</key>
			<string>Moondust Level File</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>wld</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_wld.icns</string>
			<key>CFBundleTypeName</key>
			<string>SMBX64/38A World map file</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>wldx</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_wldx.icns</string>
			<key>CFBundleTypeName</key>
			<string>Moondust World map file</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
	</array>
	<key>CFBundleExecutable</key>
	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
	<key>CFBundleIconFile</key>
	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
	<key>CFBundleName</key>
	<string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
	<key>CFBundleIdentifier</key>
	<string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
	<key>CFBundleShortVersionString</key>
	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
	<key>CFBundleVersion</key>
	<string>${MACOSX_BUNDLE_LONG_VERSION_STRING}</string>
	<key>CFBundleSignature</key>
	<string>TXTH</string>
	<key>LSApplicationCategoryType</key>
	<string>public.app-category.arcade-games</string>
	<key>LSMinimumSystemVersion</key>
	<string>10.7</string>
	<key>CFBundlePackageType</key>
	<string>APPL</string>
	<key>NSPrincipalClass</key>
	<string>TheXTechApplication</string>
	<key>NSHighResolutionCapable</key>
	<true/>
</dict>
</plist>


================================================
FILE: resources/thextech.plist.tiger.in
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleDocumentTypes</key>
	<array>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>lvl</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_lvl.icns</string>
			<key>CFBundleTypeName</key>
			<string>SMBX64/38A Level File</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>lvlx</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_lvlx.icns</string>
			<key>CFBundleTypeName</key>
			<string>Moondust Level File</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>wld</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_wld.icns</string>
			<key>CFBundleTypeName</key>
			<string>SMBX64/38A World map file</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
		<dict>
			<key>CFBundleTypeExtensions</key>
			<array>
				<string>wldx</string>
			</array>
			<key>CFBundleTypeIconFile</key>
			<string>file_wldx.icns</string>
			<key>CFBundleTypeName</key>
			<string>Moondust World map file</string>
			<key>CFBundleTypeRole</key>
			<string>Viewer</string>
			<key>LSHandlerRank</key>
			<string>Owner</string>
		</dict>
	</array>
	<key>CFBundleExecutable</key>
	<string>@THEXTECH_EXECUTABLE_NAME_OUT@</string>
	<key>CFBundleIconFile</key>
	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
	<key>CFBundleName</key>
	<string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
	<key>CFBundleIdentifier</key>
	<string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
	<key>CFBundleShortVersionString</key>
	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
	<key>CFBundleVersion</key>
	<string>${MACOSX_BUNDLE_LONG_VERSION_STRING}</string>
	<key>CFBundleSignature</key>
	<string>TXTH</string>
	<key>LSApplicationCategoryType</key>
	<string>public.app-category.arcade-games</string>
	<key>LSMinimumSystemVersion</key>
	<string>@THEXTECH_MACOS_MIN_VERSION@</string>
	<key>CFBundlePackageType</key>
	<string>APPL</string>
	<key>NSPrincipalClass</key>
	<string>TheXTechApplication</string>
	<key>NSHighResolutionCapable</key>
	<true/>
</dict>
</plist>


================================================
FILE: resources/thextech.rc
================================================
IDI_ICON1               ICON    DISCARDABLE     "thextech.ico"

#include <windows.h>
#include "../version.h"

VS_VERSION_INFO     VERSIONINFO
FILEVERSION         V_VF1, V_VF2, V_VF3, V_VF4
PRODUCTVERSION      V_VP1, V_VP2, V_VP3, V_VP4
FILEFLAGSMASK       0x3fL
FILEFLAGS           0
FILEOS              VOS_NT_WINDOWS32
FILETYPE            VFT_APP
FILESUBTYPE         VFT2_UNKNOWN
BEGIN
BLOCK   "VarFileInfo"
BEGIN
    VALUE   "Translation",  0x409,  1200
END
BLOCK   "StringFileInfo"
BEGIN
    BLOCK   "040904b0"
    BEGIN
        VALUE   "CompanyName",      V_COMPANY
        VALUE   "FileDescription",  V_FILE_DESC
        VALUE   "FileVersion",      V_FILE_VERSION V_FILE_RELEASE
        VALUE   "InternalName",     V_INTERNAL_NAME
        VALUE   "LegalCopyright",   V_COPYRIGHT
        VALUE   "OriginalFilename", V_ORIGINAL_NAME
        VALUE   "ProductName",      V_PRODUCT_NAME
        VALUE   "ProductVersion",   V_VERSION V_RELEASE
    END
END
END


================================================
FILE: resources/tiger/TheXTechRun.in
================================================
#!/bin/sh

number=$(ps aux | grep -v grep | grep -ci X11)

if [ $number -le 0 ]; then
    hadHomeInit=false

    if [ -f ~/.xinitrc ]; then
        F=`mktemp -t ~/.xinitrc-XXXX`
        cp -f ~/.xinitrc $F
        hadHomeInit=true
    else
        F=/etc/X11/xinit/xinitrc
        cp -f $F ~/.xinitrc
    fi

    sed -ie 's/^ *xterm/#xterm/' ~/.xinitrc

    open /Applications/Utilities/X11.app

    sleep 4

    if $hadHomeInit ; then
        mv -f $F ~/.xinitrc
    else
        rm -f ~/.xinitrc
    fi
fi

SCRIPTPATH=`dirname "$0"`
cd $SCRIPTPATH

./@THEXTECH_BUNDLE_NAME@ &

exit 0


================================================
FILE: resources/vita/frag.cgf
================================================

float4 main(
    float4 fragColor : COLOR,
    float2 texCoord : TEXCOORD0,
    uniform int useTexture,
    uniform sampler2D ourTexture
) : COLOR
{
    if(useTexture == 1)
    {
        float4 texSamp = tex2D(ourTexture, texCoord) * fragColor;
        return texSamp;
    }
    else
        return fragColor;
}

================================================
FILE: resources/vita/sce_sys/livearea/contents/template.xml.in
================================================
<?xml version="1.0" encoding="utf-8"?>

<livearea style="a1" format-ver="01.00" content-rev="1">
	<!-- <livearea-background> -->
		<!-- <image>bg.png</image> -->
	<!-- </livearea-background> -->
	
	<gate>
		<startup-image>startup.png</startup-image>
	</gate>
	
	<frame id="frame1">
		<liveitem>
			<text>
				<str size="20" color="#ffffff" shadow="on">@XTECH_VITA_AUTHORS@</str>
			</text>
		</liveitem>
	</frame>

	<frame id="frame2">
		<liveitem>
			<text>
				<str size="20" color="#ffffff" shadow="on">@XTECH_VITA_SHORT_DESC@</str>
			</text>
		</liveitem>
	</frame>

</livearea>


================================================
FILE: resources/vita/vert.cgv
================================================
void main(
    float2 aPosition,
    float2 vTexCoord,
    float4 vColor,
    uniform float4x4 mvp,
    uniform float4x4 _rot,
    uniform float4x4 _scale,
    float4 out vertPos : POSITION,
    float4 out fragColor : COLOR,
    float2 out texCoord : TEXCOORD0
)
{
    vertPos = mul(mul(mul(float4(aPosition, 0.f, 1.f), _scale), _rot), mvp);
    fragColor = vColor;
    texCoord = vTexCoord;
}

================================================
FILE: resources/wii/meta.xml.in
================================================
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<app version="1">
	<name>TheXTech</name>
	<coder>Wohlstand and ds-sloth</coder>
	<version>@THEXTECH_VERSION_STRING@</version>
	<release_date>@XTECH_WIIMETA_RELEASE_DATE@</release_date>
	<short_description>@XTECH_WIIMETA_SHORT_DESC@</short_description>
	<long_description>A free and open-source game engine for platforming games. This is a full source code port of the Super Mario Bros. X (SMBX) 1.3 game engine originally developed by Andrew Spinks from 2009 to 2011, and its unofficial continuation after the VB6 source code was released in 2020.

https://wohlsoft.ru/projects/TheXTech/
https://github.com/TheXTech/TheXTech
</long_description>
	<no_ios_reload/>
</app>


================================================
FILE: resources/wiiu/meta.xml.in
================================================
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<app version="1">
    <name>TheXTech</name>
    <coder>Wohlstand and ds-sloth</coder>
    <version>@THEXTECH_VERSION_STRING@</version>
    <release_date>@XTECH_WIIMETA_RELEASE_DATE@</release_date>
    <short_description>The platforming game engine.</short_description>
    <long_description><![CDATA[This is the free and open-source game engine for Mario-like platforming games. This is a complete and extended source code port of the Super Mario Bros. X 1.3 game engine (later just "SMBX") (originally developed by Andrew Spinks in 2009), and its direct unofficial continuation after development halted in the 2011th year.

https://wohlsoft.ru/projects/TheXTech/
https://github.com/Wohlstand/TheXTech]]></long_description>
</app>


================================================
FILE: script/CMakeLists.txt
================================================
cmake_minimum_required (VERSION 3.5)
project(PGEFileLibrary C CXX)

if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
    message("== Using default build configuration which is a Release!")
endif()

if(POLICY CMP0077) # Allow external configuring when building as sub-directory
    cmake_policy(SET CMP0077 NEW)
endif()

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_DEBUG_POSTFIX "d")

include(../cmake/build_props.cmake)

pge_cxx_standard(11)

set(LIB_XTECHLUA_SRCS
    src/xtech_lua_main.cpp
)

add_library(XTechLua STATIC
    ${LIB_XTECHLUA_SRCS}
)

target_include_directories(XTechLua PRIVATE
    include src lib
    ${TheXTech_SOURCE_DIR}/src
    ${TheXTech_SOURCE_DIR}/lib
    "${DEPENDENCIES_INSTALL_DIR}/include"
    ${A2XT_INCS}
)

add_dependencies(XTechLua LuaBind_Local ${A2XT_DEPS})


================================================
FILE: script/include/xtech_lua_main.h
================================================
#ifndef LUA_MAIN_HHH
#define LUA_MAIN_HHH

extern bool xtech_lua_init();
extern bool xtech_lua_quit();

#endif // LUA_MAIN_HHH


================================================
FILE: script/src/xtech_lua_main.cpp
================================================
#include "xtech_lua_main.h"


bool xtech_lua_init()
{
    return true;
}

bool xtech_lua_quit()
{
    return true;
}


================================================
FILE: src/blk_id.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef ENUMBLKID_HHH
#define ENUMBLKID_HHH

enum BLKID
{
    BLKID_SPIN_BLOCK = 90,
    BLKID_RED_BRICK = 186,
    BLKID_GRY_BRICK = 457,

    // these can be expanded into user-modifiable ranges in the future.
    // currently the "CONV" blocks can't be placed or modified in any way by the user
    BLKID_CONVEYOR_L_START = 701,
    BLKID_CONVEYOR_L_CONV = 701,
    BLKID_CONVEYOR_L_END = 701,

    BLKID_CONVEYOR_R_START = 702,
    BLKID_CONVEYOR_R_CONV = 702,
    BLKID_CONVEYOR_R_END = 702,
};


#endif // ENUMBLKID_HHH


================================================
FILE: src/blocks.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <algorithm>

#include "sdl_proxy/sdl_stdinc.h"

#include "globals.h"
#include "frame_timer.h"
#include "blocks.h"
#include "sound.h"
#include "graphics.h"
#include "effect.h"
#include "collision.h"
#include "npc.h"
#include "npc_id.h"
#include "eff_id.h"
#include "blk_id.h"
#include "npc_traits.h"
#include "player.h"
#include "sorting.h"
#include "layers.h"
#include "config.h"
#include "editor.h"
#include "game_main.h"

#include "graphics/gfx_update.h"
#include "npc/npc_queues.h"
#include "main/trees.h"
#include "main/game_loop_interrupt.h"

void s_makeCoin(Block_t& b)
{
    Coins += 1;
    if(Coins >= 100)
        Got100Coins();

    PlaySoundSpatial(SFX_Coin, b.Location);
    NewEffect(EFFID_COIN_BLOCK_S3, b.Location);
}

static int s_findNearbyPlayer(const Location_t& loc)
{
    if(numPlayers == 1)
        return 1;

    int target_plr = 1;
    num_t min_dist = 0;

    for(int B = 1; B <= numPlayers; B++)
    {
        const Player_t& player = Player[B];
        if(!player.Dead)
        {
            num_t dx = loc.minus_center_x(player.Location);
            num_t dy = loc.minus_center_y(player.Location);
            num_t dist = num_t::dist2(dx, dy);
            if(min_dist == 0 || dist < min_dist)
            {
                min_dist = dist;
                target_plr = B;
            }
        }
    }

    return target_plr;
}

// initial value for ScreensLeft -- sets bit for each screen that has players
static uint16_t s_InitScreensLeft()
{
    uint16_t ScreensLeft = 0;

    uint16_t cur_bit = 1;
    for(int i = 0; i < maxNetplayClients; i++, cur_bit <<= 1)
    {
        if(Screens[i].player_count)
            ScreensLeft |= cur_bit;
    }

    return ScreensLeft;
}

void BlockHit(int A, bool HitDown, int whatPlayer)
{
    // int tempPlayer = 0;
    // bool makeShroom = false; // if true make a mushroom
    int newBlock = 0; // what the block should turn into if anything
    // int C = 0;
//    int B = 0;
    // Block_t blankBlock;
    int oldSpecial = 0; // previous .Special
    // bool tempBool = false;
    // Location_t tempLocation;

    auto &b = Block[A];

    if(BattleMode && b.RespawnDelay_ScreensLeft == 0)
        b.RespawnDelay_ScreensLeft = 1;

    // if(whatPlayer != 0)
    //     Controls::Rumble(whatPlayer, 10, .1);

    // character switch blocks
    if((b.Type >= 622 && b.Type <= 625) || b.Type == 631)
    {
        if(whatPlayer == 0)
        {
            return;
        }
        else
        {
            b.Special = 0;

            // note: this line was previously inside the below for loop
            SavedChar[Player[whatPlayer].Character] = Player[whatPlayer];

            // mark characters in current use as unavailable
            for(auto B = 1; B <= numPlayers; B++)
            {
                switch(Player[B].Character)
                {
                case 1: BlockFrame[622] = 4; break;
                case 2: BlockFrame[623] = 4; break;
                case 3: BlockFrame[624] = 4; break;
                case 4: BlockFrame[625] = 4; break;
                case 5: BlockFrame[631] = 4; break;
                default: break;
                }
            }

            if(BlockFrame[b.Type] < 4)
            {
                // UnDuck whatPlayer // (commented since SMBX64)

                int transform_to = 0;

                switch(b.Type)
                {
                case 622: transform_to = 1; break;
                case 623: transform_to = 2; break;
                case 624: transform_to = 3; break;
                case 625: transform_to = 4; break;
                case 631: transform_to = 5; break;
                default: break;
                }

                // moved SwapCharacter logic into player.cpp

                if(transform_to)
                    SwapCharacter(whatPlayer, transform_to, true);

                PlaySoundSpatial(SFX_Transform, b.Location);
            }
            else
            {
                return;
            }
        }
    }

    oldSpecial = b.Special;

    // if(b.ShakeY != 0 || b.ShakeY2 != 0 || b.ShakeY3 != 0) // if the block has just been hit, ignore
    if(b.ShakeCounter != 0) // if the block has just been hit, ignore
    {
        if(b.RapidHit > 0 && IF_INRANGE(whatPlayer, 1, maxPlayers) && Player[whatPlayer].Character == 4)
            b.RapidHit = iRand(3) + 1;
        return;
    }

    b.Invis = false;

    // check if block with contents is blocked from below, if so cancel hit from above
    if(HitDown && b.Special > 0)
    {
        // tempBool = false; // unused since SMBX64, must have been replaced with the simple modification of HitDown

        // this is symmetric to the original transformation on the *other* block's location, but much cheaper
        const auto query_loc = newLoc(b.Location.X + 4, b.Location.Y + 16, b.Location.Width - 8, b.Location.Height);

        for(int B : treeBlockQuery(query_loc, SORTMODE_NONE))
        {
            if(B != A)
            {
                const auto &bLoc = Block[B].Location;
                // if(CheckCollision(b.Location, newLoc(bLoc.X + 4, bLoc.Y - 16, bLoc.Width - 8, bLoc.Height)))
                if(CheckCollision(query_loc, bLoc))
                {
                    HitDown = false;
                    break;
                }
            }
        }
    }

    if(b.Special == 1000 + NPCID_RED_VINE_TOP_S3 || b.Special == 1000 + NPCID_GRN_VINE_TOP_S3 || b.Special == 1000 + NPCID_GRN_VINE_TOP_S4)
        HitDown = false;


    // Shake the block
    if(b.Type == 4 || b.Type == 615 || b.Type == 55 ||
       b.Type == 60 || b.Type == 90 || b.Type == 159 ||
       b.Type == 169 || b.Type == 170 || b.Type == 173 ||
       b.Type == 176 || b.Type == 179 || b.Type == 188 ||
       b.Type == 226 || b.Type == 281 || b.Type == 282 ||
       b.Type == 283 || (b.Type >= 622 && b.Type <= 625))
    {
        if(!HitDown)
            BlockShakeUp(A);
        else
            BlockShakeDown(A);
    }


    if(b.Type == 169)
    {
        PlaySoundSpatial(SFX_PSwitch, b.Location);
        BeltDirection = -BeltDirection; // for the blet direction changing block

        for(auto B = 1; B <= numBlock; B++)
        {
            if(Block[B].Type >= BLKID_CONVEYOR_L_START && Block[B].Type <= BLKID_CONVEYOR_L_END)
            {
                Block[B].Type += BLKID_CONVEYOR_R_START - BLKID_CONVEYOR_L_START;
                Block[B].Location.SpeedX = (num_t)Layer[Block[B].Layer].ApplySpeedX + 0.8_n;
            }
            else if(Block[B].Type >= BLKID_CONVEYOR_R_START && Block[B].Type <= BLKID_CONVEYOR_R_END)
            {
                Block[B].Type -= BLKID_CONVEYOR_R_START - BLKID_CONVEYOR_L_START;
                Block[B].Location.SpeedX = (num_t)Layer[Block[B].Layer].ApplySpeedX - 0.8_n;
            }
        }
    }


    // note: these four cases were previously handled using separate code
    NPCID switch_npc = NPCID_NULL;

    if(b.Type == 170)
        switch_npc = NPCID_YEL_PLATFORM;
    else if(b.Type == 173)
        switch_npc = NPCID_BLU_PLATFORM;
    else if(b.Type == 176)
        switch_npc = NPCID_GRN_PLATFORM;
    else if(b.Type == 179)
        switch_npc = NPCID_RED_PLATFORM;

    if(switch_npc != NPCID_NULL) // switch blocks
    {
        PlaySoundSpatial(SFX_PSwitch, b.Location);
        for(auto B = 1; B <= numBlock; B++)
        {
            if(Block[B].Type == b.Type + 1)
                Block[B].Type = b.Type + 2;
            else if(Block[B].Type == b.Type + 2)
                Block[B].Type = b.Type + 1;
        }

        for(auto B = 1; B <= numNPCs; B++)
        {
            if(NPC[B].Type == switch_npc)
                NPC[B].Direction = -NPC[B].Direction;
        }
    }

    // Find out what the block should turn into
    if(b.Type == 88 || b.Type == 90 || b.Type == 89 || b.Type == 171 || b.Type == 174 || b.Type == 177 || b.Type == 180) // SMW
        newBlock = 89;
    else if(b.Type == 188 || b.Type == 192 || b.Type == 193 || b.Type == 60 || b.Type == 369) // SMB1
        newBlock = 192;
    else if(b.Type == 224 || b.Type == 225 || b.Type == 226) // Large SMB3 blocks
        newBlock = 225;
    else if(b.Type == 159) // SMB3 Battle Block
        newBlock = 159;
    else // Everything else defaults to SMB3
        newBlock = 2;

    if(b.Special > 0 && b.Special < 100) // Block has coins
    {
        if(whatPlayer > 0 && Player[whatPlayer].Character == 4)
            b.RapidHit = iRand(3) + 1;

        if(!HitDown)
            BlockShakeUp(A);
        else
            BlockShakeDown(A);


        // chars 2 and 5 make all coins come out at once
        if(whatPlayer > 0 && (Player[whatPlayer].Character == 2 || Player[whatPlayer].Character == 5))
        {
            // check if blocked from above
            bool blocked_above = false;
            const auto query_loc = newLoc(b.Location.X + 1, b.Location.Y - 31, 30, 30);

            for(int B : treeBlockQuery(query_loc, SORTMODE_NONE))
            {
                if(B != A && !Block[B].Hidden && !BlockOnlyHitspot1[Block[B].Type] && !BlockIsSizable[Block[B].Type])
                {
                    // if(CheckCollision(Block[B].Location, newLoc(b.Location.X + 1, b.Location.Y - 31, 30, 30)))
                    if(CheckCollision(Block[B].Location, query_loc))
                    {
                        blocked_above = true;
                        break;
                    }
                }
            }

            if(!blocked_above)
            {
                for(auto B = 1; B <= b.Special; B++)
                {
                    numNPCs++;
                    auto &nn = NPC[numNPCs];

                    nn.Active = true;
                    nn.TimeLeft = 100;

                    if(newBlock == 89)
                        nn.Type = NPCID_COIN_S4;
                    else if(newBlock == 192)
                        nn.Type = NPCID_COIN_S1;
                    else
                        nn.Type = NPCID_COIN_S3;

                    if(Player[whatPlayer].Character == 5)
                    {
                        nn.Type = NPCID_GEM_1;
                        if(iRand(20) < 3)
                            nn.Type = NPCID_GEM_5;
                        if(iRand(60) < 3)
                            nn.Type = NPCID_GEM_20;
                        PlaySoundSpatial(SFX_HeroRupee, b.Location);
                    }
                    else
                    {
                        PlaySoundSpatial(SFX_Coin, b.Location);
                    }

                    auto &nLoc = nn.Location;
                    nLoc.Width = nn->TWidth;
                    nLoc.Height = nn->THeight;
                    nLoc.X = b.Location.X + (b.Location.Width - nLoc.Width) / 2;
                    nLoc.Y = b.Location.Y - nLoc.Height - 0.01_n;
                    nLoc.SpeedX = dRand() * 3 - 1.5_n;
                    nLoc.SpeedY = -(dRand() * 4) - 3;
                    if(HitDown)
                    {
                        nLoc.SpeedY = -nLoc.SpeedY / 2;
                        nLoc.Y = b.Location.Y + b.Location.Height;
                    }

                    nn.Special = 1;
                    nn.Immune = 20;
                    syncLayers_NPC(numNPCs);
                    CheckSectionNPC(numNPCs);

                    if(B > 20 || (Player[whatPlayer].Character == 5 && B > 5))
                        break;
                }
                b.Special = 0;
            }
            else
            {
                s_makeCoin(b);
                b.Special -= 1;
            }
        }
        else if(b.RapidHit > 0) // (whatPlayer > 0 And Player(whatPlayer).Character = 3)
        {
            // check if anything is blocking from above
            bool blocked_above = false;
            const auto query_loc = newLoc(b.Location.X + 1, b.Location.Y - 31, 30, 30);

            for(int B : treeBlockQuery(query_loc, SORTMODE_NONE))
            {
                if(B != A && !Block[B].Hidden && !(BlockOnlyHitspot1[Block[B].Type] && !BlockIsSizable[Block[B].Type]))
                {
                    if(CheckCollision(Block[B].Location, query_loc))
                    {
                        blocked_above = true;
                        break;
                    }
                }
            }

            if(!blocked_above)
            {
                numNPCs++;
                auto &nn = NPC[numNPCs];
                nn.Active = true;
                nn.TimeLeft = 100;

                // NOTE: This code was already broken by Redigit. It should spawn a coin depending on thematic block
#if 0 // Useless code, needs a fix. Right now its broken by overriding by constant value
                if(newBlock == 89)
                {
                    nn.Type = NPCID_COIN_S4;
                }
                else if(newBlock == 192)
                {
                    nn.Type = NPCID_COIN_S1;
                }
                else
                {
                    nn.Type = NPCID_COIN_S3;
                }
#endif
                nn.Type = NPCID_COIN_S2;

                nn.Location.Width = nn->TWidth;
                nn.Location.Height = nn->THeight;
                nn.Location.X = b.Location.X + (b.Location.Width - nn.Location.Width) / 2;
                nn.Location.Y = b.Location.Y - nn.Location.Height - 0.01_n;
                nn.Location.SpeedX = dRand() * 3 - 1.5_n;
                nn.Location.SpeedY = -(dRand() * 4) - 3;
                nn.Special = 1;
                nn.Immune = 20;
                PlaySoundSpatial(SFX_Coin, b.Location);
                syncLayers_NPC(numNPCs);
                CheckSectionNPC(numNPCs);
                b.Special -= 1;
            }
            else
            {
                s_makeCoin(b);
                b.Special -= 1;
            }
        }
        else
        {
            s_makeCoin(b);
            b.Special -= 1;
        }

        if(b.Special == 0 && b.Type != 55)
        {
            b.Type = newBlock;
            b.Location.Height = BlockHeight[newBlock];
            b.Location.Width = BlockWidth[newBlock];
        }
    }
    else if(b.Special >= 100) // New spawn code
    {
        // represents behavior for ancient 101 / 104 / 201 Special values (other ancient values replaced in OpenLevel)
        bool is_ancient = false;

        NPCID C = NPCID_NULL;

        if(b.Special >= 1000)
        {
            C = NPCID(b.Special - 1000); // this finds the NPC type and puts in the variable C
        }
        else if(b.Special == 201)
        {
            C = NPCID_LIFE_S3;
            is_ancient = true;
        }
        else if(b.Special == 104)
        {
            C = NPCID_GRN_BOOT;
            is_ancient = true;
        }
        else if(b.Special == 110)
        {
            if(InvincibilityTime)
                C = NPCID_INVINCIBILITY_POWER;
            else
                C = NPCID_NULL;
        }
        else // b.Special == 101
        {
            C = NPCID_FODDER_S3;
            is_ancient = true;
        }

        // NEW: logic to allow "important" NPCs to spawn multiple times, once per screen, in NetPlay
        // Intentionally excludes keys and coin/timer switches because those could be used to defeat puzzles
        if(!BattleMode && (NPCTraits[C].IsABonus || NPCLongLife(C) || C == NPCID_RANDOM_POWER || C == NPCID_NULL))
        {
            if(!b.RespawnDelay_ScreensLeft)
                b.RespawnDelay_ScreensLeft = s_InitScreensLeft();

            int use_player = whatPlayer;
            if(use_player <= 0)
            {
                // find nearest player
                use_player = s_findNearbyPlayer(b.Location);
            }

            // find player's screen index
            uint16_t screen_index = ScreenIdxByPlayer(use_player);
            uint16_t screen_index_bit = (1U << screen_index);

            if(screen_index >= 16)
            {
                // invalid screen index, cancel the block for everyone
                b.RespawnDelay_ScreensLeft = 0;
            }
            else if(b.RespawnDelay_ScreensLeft & screen_index_bit)
            {
                // cancel the block just for this player's screen
                b.RespawnDelay_ScreensLeft &= ~screen_index_bit;
            }
            else
            {
                // screen has already hit block, don't make anything!
                return;
            }
        }

        if(!HitDown)
            BlockShakeUp(A);
        else
            BlockShakeDown(A);

        // cancel block, unless some other screen will get to hit it later
        if(BattleMode || b.RespawnDelay_ScreensLeft == 0)
        {
            b.Special = 0;

            if(b.Type != 55) // 55 is the bouncy note block
            {
                b.Type = newBlock;
                b.Location.Height = BlockHeight[newBlock];

                // Was always set in SMBX64. Doing this check here keeps the easy bonus pickup and prevents movement. -- ds-sloth
                if(!g_config.fix_restored_block_move || !b.getShrinkResized())
                    b.Location.Width = BlockWidth[newBlock];
            }
        }

        // Shake code was duplicated for some reason in ancient code, but that had no effect

#if 0 // Completely disable the DEAD the code that spawns the player
        if(NPCIsABonus(C) && C != 169 && C != 170) // check to see if it should spawn a dead player
        {
            tempPlayer = CheckDead();
            if(g_ClonedPlayerMode)
            {
                tempPlayer = 0;
            }
        }

        // don't spawn players from blocks anymore
        tempPlayer = 0;

        if(tempPlayer == 0) // Spawn the npc
#endif
        // Spawn the npc
        if(C < 1 || C > maxNPCType)
            s_makeCoin(b);
        else
        {
            numNPCs++; // create a new NPC
            auto &nn = NPC[numNPCs];
            nn.Active = true;
            nn.TimeLeft = 1000;

            if(is_ancient)
                nn.TimeLeft = 100;

            // always give char 5 or big player full power
            bool player_gets_full = (whatPlayer > 0 && (Player[whatPlayer].State > 1 || Player[whatPlayer].Character == 5));

            // replacement index if full powerup should not be received
            NPCID replacement = C;

            if(g_ClonedPlayerMode || BattleMode || player_gets_full)
            {
                // never replace if cloned player, in battle mode, or the player that hit the block should get the full powerup
            }
            else if(C == NPCID_FIRE_POWER_S3 || C == NPCID_LEAF_POWER || C == NPCID_ICE_POWER_S3 || C == NPCID_ICE_POWER_S4 || C == NPCID_CYCLONE_POWER || C == NPCID_AQUATIC_POWER)
                replacement = NPCID_POWER_S3;
            else if(C == NPCID_FIRE_POWER_S4)
                replacement = NPCID_POWER_S4;
            else if(C == NPCID_FIRE_POWER_S1)
                replacement = NPCID_POWER_S1;

            if(NPCIsYoshi(C))
            {
                nn.Type = NPCID_ITEM_POD;
                nn.Special = C;
            }
            else if(replacement != C)
            {
                // if any player is small, then replace the NPC
                bool do_replace = false;

                for(auto B = 1; B <= numPlayers; B++)
                {
                    if(Player[B].State == 1 && Player[B].Character != 5)
                    {
                        do_replace = true;
                        break;
                    }
                }

                if(!do_replace)
                    nn.Type = C;
                else
                    nn.Type = replacement;
            }
            else
            {
                nn.Type = C;
            }

            // replace random power immediately
            if(nn.Type == NPCID_RANDOM_POWER)
                nn.Type = RandomBonus();

            CharStuff(numNPCs);

            // note: minor SMBX64 bugfix, should be nn->TWidth in case nn's type has changed
            nn.Location.Width = (g_config.fix_npc_emerge_size) ? nn->TWidth : NPCWidth(C);

            // bug from ancient 101 case
            if(is_ancient && C == NPCID_FODDER_S3)
                nn.Location.Width = NPCWidth(NPCID_POWER_S3);

            // Make block a bit smaller to allow player take a bonus easier (Redigit's idea)
            if(!is_ancient && num_t::fEqual_d(b.Location.Width, 32.0_n))
            {
                // set value directly to make sure Location.Width == 31.9 heuristic works on low-mem builds
                // b.Location.Width -= 0.1;
                b.Location.Width = 31.9_n;

                b.Location.X += 0.05_n;
                b.setShrinkResized();
            }

            nn.Location.Height = 0;
            nn.Location.X = (b.Location.X + (b.Location.Width - nn.Location.Width) / 2);
            nn.Location.SpeedX = 0;
            nn.Location.SpeedY = 0;

            // direction set to -1 if ancient boot block (104 case)
            if(is_ancient && C == NPCID_GRN_BOOT)
                nn.Direction = -1;

            if(NPCIsYoshi(C)) // if the npc is pet then set the color of the pod
            {
                if(C == NPCID_PET_BLUE)
                    nn.Frame = 1;
                else if(C == NPCID_PET_YELLOW)
                    nn.Frame = 2;
                else if(C == NPCID_PET_RED)
                    nn.Frame = 3;
                else if(C == NPCID_PET_BLACK)
                    nn.Frame = 4;
                else if(C == NPCID_PET_PURPLE)
                    nn.Frame = 5;
                else if(C == NPCID_PET_PINK)
                    nn.Frame = 6;
            }

            if(!HitDown)
            {
                nn.Location.Y = b.Location.Y; // - 0.1
                nn.Location.Height = 0;

                // old behavior was never changed for ancient 101 / 104 / 201 cases
                if(is_ancient)
                    nn.Location.Y = b.Location.Y - 0.1_n;

                if(NPCIsYoshi(C))
                {
                    nn.Effect = NPCEFF_NORMAL;
                    nn.Location.Height = 32;
                    nn.Location.Y = b.Location.Y - 32;
                }
                else if(nn.Type == NPCID_LEAF_POWER || nn.Type == NPCID_CYCLONE_POWER)
                {
                    nn.Effect = NPCEFF_NORMAL;
                    nn.Location.Y = b.Location.Y - 32;
                    nn.Location.SpeedY = -6;
                    nn.Location.Height = NPCHeight(C);
                    // PlaySound(SFX_ItemEmerge); // Don't play mushroom sound on leaf, like in original SMB3 (Redigit's comment)
                }
                else
                {
                    nn.Effect = NPCEFF_EMERGE_UP;
                    switch(C)
                    {
                    case NPCID_GRN_VINE_TOP_S3:
                    case NPCID_RED_VINE_TOP_S3:
                    case NPCID_GRN_VINE_TOP_S4:
                        PlaySoundSpatial(SFX_SproutVine, b.Location);
                        break;
                    default:
                        PlaySoundSpatial(SFX_ItemEmerge, b.Location);
                        break;
                    }
                }
            }
            else
            {
                nn.Location.Y = b.Location.Y + 4;
                nn.Location.Height = NPCHeight(C);

                // hardcoded to 32 in ancient 101 / 104 / 201 cases
                if(is_ancient)
                    nn.Location.Height = 32;

                nn.Effect = NPCEFF_EMERGE_DOWN;
                PlaySoundSpatial(SFX_ItemEmerge, b.Location);
            }

            nn.Effect2 = 0;
            syncLayers_NPC(numNPCs);
            CheckSectionNPC(numNPCs);

            if(is_ancient)
            {
                // the logic is the next clause didn't exist in ancient cases
            }
            else if(NPCLongLife(nn.Type))
            {
                nn.TimeLeft = Physics.NPCTimeOffScreen * 20;
            }
        }
#if 0 // don't spawn players from blocks anymore
        else // Spawn the player
        {
            PlaySound(SFX_ItemEmerge);
            Player[tempPlayer].State = 1;
            Player[tempPlayer].Location.Width = Physics.PlayerWidth[Player[tempPlayer].Character][Player[tempPlayer].State];
            Player[tempPlayer].Location.Height = Physics.PlayerHeight[Player[tempPlayer].Character][Player[tempPlayer].State];
            Player[tempPlayer].Frame = 1;
            Player[tempPlayer].Dead = false;
            Player[tempPlayer].Location.X = b.Location.X + (b.Location.Width - Player[tempPlayer].Location.Width) / 2;
            if(!HitDown)
            {
                Player[tempPlayer].Location.Y = b.Location.Y - 0.1 - Player[tempPlayer].Location.Height;
            }
            else
            {
                Player[tempPlayer].Location.Y = b.Location.Y + 0.1 + b.Location.Height;
            }
            Player[tempPlayer].Location.SpeedX = 0;
            Player[tempPlayer].Location.SpeedY = 0;
            Player[tempPlayer].Immune = 150;
        }
#endif

    }

    // There was a long passage of dead code that handled the (b.Special >= 100 && b.Special < 1000) cases here
    // No longer needed -- most of these numbers are replaced with normal NPC ID at OpenLevel side in SMBX 1.3, and the others have been added to the above code.

    if(PSwitchTime > 0 && newBlock == 89 && b.Special == 0 && oldSpecial > 0)
    {
        numNPCs++;
        auto &nn = NPC[numNPCs];
        nn.Active = true;
        nn.TimeLeft = 1;
        nn.Type = NPCID_COIN_S4;
        // nn.coinSwitchBlockType = 89;
        // this value has been moved to Damage for coins
        nn.Damage = 89;
        nn.Location = b.Location;
        nn.Location.Width = nn->TWidth;
        nn.Location.Height = nn->THeight;
        nn.Location.X += (b.Location.Width - nn.Location.Width) / 2;
        nn.Location.Y -= 0.01_n;
        nn.DefaultLocationX = nn.Location.X;
        nn.DefaultLocationY = nn.Location.Y;
        nn.DefaultType = nn.Type;
        syncLayers_NPC(numNPCs);
        CheckSectionNPC(numNPCs);
        b = Block_t();
        // Prevent possible crash on render (#1136)
        invalidateDrawBlocks();

        // After additional research: consider syncing the erased block to keep logic working as expected.
        // Right now some normal expectations (quadtree, layer list) may be violated, but the block's position is not immediately synced in SMBX 1.3.
        // syncLayersTrees_Block(A);
    }

    if(b.Type == 90)
        BlockHitHard(A);
}

enum BlockShakeProgram : uint8_t
{
    SHAKE_UPDOWN12_BEG = 16 + 0,
    SHAKE_UPDOWN12_MID = 16 + 6,
    SHAKE_UPDOWN12_END = 16 + 12,

    SHAKE_DOWNUP12_BEG = 32 + 0,
    SHAKE_DOWNUP12_MID = 32 + 6,
    SHAKE_DOWNUP12_END = 32 + 12,

    SHAKE_UPDOWN06_BEG = 48 + 0,
    SHAKE_UPDOWN06_MID = 48 + 3,
    SHAKE_UPDOWN06_END = 48 + 6,
};

void BlockShakeUp(int A)
{
    if(Block[A].Hidden)
        return;

    if(iBlocks >= maxBlocks)
        return; // iBlock array overflown

    // Block[A].ShakeY = -12; // Go up
    // Block[A].ShakeY2 = 12; // Come back down
    // Block[A].ShakeY3 = 0;

    Block[A].ShakeCounter = SHAKE_UPDOWN12_BEG;
    Block[A].ShakeOffset = 0;

    if(A != iBlock[iBlocks])
    {
        iBlocks++;
        iBlock[iBlocks] = A;
    }
}

void BlockShakeUpPow(int A)
{
    if(Block[A].Hidden)
        return;

    if(iBlocks >= maxBlocks)
        return; // iBlock array overflown

    // Block[A].ShakeY = -6; // Go up
    // Block[A].ShakeY2 = 6; // Come back down
    // Block[A].ShakeY3 = 0;

    Block[A].ShakeCounter = SHAKE_UPDOWN06_BEG;
    Block[A].ShakeOffset = 0;

    if(A != iBlock[iBlocks])
    {
        iBlocks++;
        iBlock[iBlocks] = A;
    }
}

void BlockShakeDown(int A)
{
    if(Block[A].Hidden)
        return;

    if(iBlocks >= maxBlocks)
        return; // iBlock array overflown

    // Block[A].ShakeY = 12; // Go down
    // Block[A].ShakeY2 = -12; // Come back up
    // Block[A].ShakeY3 = 0;

    Block[A].ShakeCounter = SHAKE_DOWNUP12_BEG;
    Block[A].ShakeOffset = 0;

    if(A != iBlock[iBlocks])
    {
        iBlocks++;
        iBlock[iBlocks] = A;
    }
}

void BlockHitHard(int A)
{
    if(Block[A].Hidden)
        return;

    if(Block[A].Type == 90 && !Block[A].forceSmashable)
    {
        // Block(A).Hidden = True
        // NewEffect 82, Block(A).Location, , A
        // PlaySound 3
    }
    else
    {
        Block[A].Kill = true;

        if(iBlocks < maxBlocks)
        {
            iBlocks++;
            iBlock[iBlocks] = A;
        }
    }
}

void SafelyKillBlock(int A)
{
    auto& block = Block[A];

    if(block.Hidden)
        return;

    // emulate old immediate kill behavior if it is safe to do so
    if(g_config.playstyle == Config_t::MODE_VANILLA && block.TriggerDeath == EVENT_NONE && block.TriggerLast == EVENT_NONE)
    {
        KillBlock(A, true);
        return;
    }

    block.Kill = 9;
    if(iBlocks < maxBlocks)
    {
        iBlocks++;
        iBlock[iBlocks] = A;
    }
}

bool KillBlock(int A, bool Splode)
{
    Block_t blankBlock;
    bool tempBool = false;

    Block_t& b = Block[A];

    switch(g_gameLoopInterrupt.site)
    {
    case GameLoopInterrupt::UpdateBlocks_KillBlock:
    case GameLoopInterrupt::UpdateBlocks_SwitchOff_KillBlock:
        if(g_gameLoopInterrupt.bool1)
            goto resume_TriggerLast;
        else
            goto resume_TriggerDeath;
    default:
        break;
    }

    if(Block[A].Hidden)
        return false;

    if(BattleMode && Block[A].RespawnDelay_ScreensLeft == 0)
        Block[A].RespawnDelay_ScreensLeft = 1;

    if(Splode)
    {
        if(Block[A].Type == 526)
            PlaySoundSpatial(SFX_SMBlockHit, b.Location);
        else if(Block[A].Type == 186)
            PlaySoundSpatial(SFX_Fireworks, b.Location);
        else
            PlaySoundSpatial(SFX_BlockSmashed, b.Location); // Block smashed

        // Create the break effect
        if(Block[A].Type == 60)
            NewEffect(EFFID_BLU_BLOCK_SMASH, Block[A].Location);
        else if(Block[A].Type == 188)
            NewEffect(EFFID_BLOCK_S1_SMASH, Block[A].Location);
        else if(Block[A].Type == 457)
            NewEffect(EFFID_GRY_BLOCK_SMASH, Block[A].Location);
        else if(Block[A].Type == 526)
            NewEffect(EFFID_SPACE_BLOCK_SMASH, Block[A].Location);
        else if(Block[A].Type == 293)
            NewEffect(EFFID_DIRT_BLOCK_SMASH, Block[A].Location);
        else
            NewEffect(EFFID_BLOCK_SMASH, Block[A].Location);
    }

    if(LevelEditor)
    {
        if(numBlock > 0)
        {
            Block[A] = Block[numBlock];
            Block[numBlock] = blankBlock;
            numBlock--;
            syncLayersTrees_Block(A);
            syncLayersTrees_Block(numBlock + 1);
        }

        return false;
    }

    Score += 50;

    if(Block[A].TriggerDeath != EVENT_NONE)
    {
        eventindex_t resume_index;
        resume_index = ProcEvent_Safe(false, Block[A].TriggerDeath, 0);
        while(resume_index != EVENT_NONE)
        {
            g_gameLoopInterrupt.C = resume_index;
            g_gameLoopInterrupt.bool1 = false; // marks as TriggerDeath
            return true;

resume_TriggerDeath:
            resume_index = g_gameLoopInterrupt.C;
            g_gameLoopInterrupt.site = GameLoopInterrupt::None;

            resume_index = ProcEvent_Safe(true, resume_index, 0);
        }
    }

    if(Block[A].TriggerLast != EVENT_NONE)
    {
        tempBool = false;

        if(Block[A].Layer != LAYER_NONE)
        {
            int C = Block[A].Layer;

            for(int npc : Layer[C].NPCs)
            {
                if(!NPC[npc].Generator)
                {
                    tempBool = true;
                    break;
                }
            }

            if(!tempBool)
            {
                for(int other_block : Layer[C].blocks)
                {
                    if(other_block != A)
                    {
                        tempBool = true;
                        break;
                    }
                }
            }
        }

        if(!tempBool)
        {
            eventindex_t resume_index;
            resume_index = ProcEvent_Safe(false, Block[A].TriggerLast, 0);
            while(resume_index != EVENT_NONE)
            {
                g_gameLoopInterrupt.C = resume_index;
                g_gameLoopInterrupt.bool1 = true; // marks as TriggerLast
                return true;

resume_TriggerLast:
                resume_index = g_gameLoopInterrupt.C;
                g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                resume_index = ProcEvent_Safe(true, resume_index, 0);
            }
        }
    }

    Block[A].Hidden = true;
    Block[A].Layer = LAYER_DESTROYED_BLOCKS;
    Block[A].Kill = false;
    syncLayersTrees_Block(A);

    return false;
}

void BlockFrames()
{
    int A = 0;

    bool pChar[maxPlayers] = {false};
    bool tempBool = false;
    SDL_memset(pChar, 0, sizeof(pChar));

    if(FreezeNPCs)
        return;

    // Update block frame counter
    BlockFrame2[4] += 1;
    if(BlockFrame2[4] == 8)
        BlockFrame2[4] = 0;

    BlockFrame2[5] += 1;
    if(BlockFrame2[5] == 8)
        BlockFrame2[5] = 0;

    BlockFrame2[30] += 1;
    if(BlockFrame2[30] == 8)
        BlockFrame2[30] = 0;

    BlockFrame2[55] += 1;
    if(BlockFrame2[55] == 8)
        BlockFrame2[55] = 0;

    BlockFrame2[88] += 1;
    if(BlockFrame2[88] == 8)
        BlockFrame2[88] = 0;

    BlockFrame2[109] += 1;
    if(BlockFrame2[109] == 4)
        BlockFrame2[109] = 0;

    BlockFrame2[371] += 1;
    if(BlockFrame2[371] == 8)
        BlockFrame2[371] = 0;

    BlockFrame2[379] += 1;
    if(BlockFrame2[379] >= 12)
        BlockFrame2[379] = 0;

    // Check if the block type is ready for the next frame
    if(BlockFrame2[4] == 0)
    {
        BlockFrame[4] += 1;
        if(BlockFrame[4] == 4)
            BlockFrame[4] = 0;
    }

    if(BlockFrame2[5] == 0)
    {
        BlockFrame[5] += 1;
        if(BlockFrame[5] == 4)
            BlockFrame[5] = 0;
    }

    BlockFrame[598] = BlockFrame[5];
    BlockFrame[511] = BlockFrame[5];
    BlockFrame[169] = BlockFrame[5];
    BlockFrame[173] = BlockFrame[5];
    BlockFrame[176] = BlockFrame[5];
    BlockFrame[179] = BlockFrame[5];
    BlockFrame[193] = BlockFrame[5];
    BlockFrame[389] = BlockFrame[5];
    BlockFrame[391] = BlockFrame[5];
    BlockFrame[392] = BlockFrame[5];
    BlockFrame[404] = BlockFrame[5];
    BlockFrame[459] = BlockFrame[5];
    BlockFrame[460] = BlockFrame[5];
    BlockFrame[461] = BlockFrame[5];
    BlockFrame[462] = BlockFrame[5];
    BlockFrame[463] = BlockFrame[5];
    BlockFrame[464] = BlockFrame[5];
    BlockFrame[465] = BlockFrame[5];
    BlockFrame[466] = BlockFrame[5];
    BlockFrame[468] = BlockFrame[5];
    BlockFrame[469] = BlockFrame[5];
    BlockFrame[470] = BlockFrame[5];
    BlockFrame[471] = BlockFrame[5];
    BlockFrame[472] = BlockFrame[5];
    BlockFrame[473] = BlockFrame[5];
    BlockFrame[474] = BlockFrame[5];
    BlockFrame[475] = BlockFrame[5];
    BlockFrame[476] = BlockFrame[5];
    BlockFrame[477] = BlockFrame[5];
    BlockFrame[478] = BlockFrame[5];
    BlockFrame[479] = BlockFrame[5];
    BlockFrame[480] = BlockFrame[5];
    BlockFrame[481] = BlockFrame[5];
    BlockFrame[482] = BlockFrame[5];
    BlockFrame[483] = BlockFrame[5];
    BlockFrame[484] = BlockFrame[5];
    BlockFrame[485] = BlockFrame[5];
    BlockFrame[486] = BlockFrame[5];
    BlockFrame[487] = BlockFrame[5];
    BlockFrame[622] = BlockFrame[5];
    BlockFrame[623] = BlockFrame[5];
    BlockFrame[624] = BlockFrame[5];
    BlockFrame[625] = BlockFrame[5];
    BlockFrame[631] = BlockFrame[5];

    for(A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Character == 1)
            BlockFrame[622] = 4;

        if(Player[A].Character == 2)
            BlockFrame[623] = 4;

        if(Player[A].Character == 3)
            BlockFrame[624] = 4;

        if(Player[A].Character == 4)
            BlockFrame[625] = 4;

        if(Player[A].Character == 5)
            BlockFrame[631] = 4;
    }

    BlockFrame2[626] += 1;
    if(BlockFrame2[626] < 8)
        BlockFrame[626] = 3;
    else if(BlockFrame2[626] < 16)
        BlockFrame[626] = 2;
    else if(BlockFrame2[626] < 23)
        BlockFrame[626] = 1;
    else
    {
        BlockFrame2[626] = 0;
        BlockFrame[626] = 1;
    }

    BlockFrame[627] = BlockFrame[626];
    BlockFrame[628] = BlockFrame[626];
    BlockFrame[629] = BlockFrame[626];
    BlockFrame[632] = BlockFrame[626];

    for(A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Character <= 5)
            pChar[Player[A].Character] = true;
    }

    if(!pChar[1])
        BlockFrame[626] = 0;

    if(!pChar[2])
        BlockFrame[627] = 0;

    if(!pChar[3])
        BlockFrame[628] = 0;

    if(!pChar[4])
        BlockFrame[629] = 0;

    if(!pChar[5])
        BlockFrame[632] = 0;

    if(BlockFrame2[30] == 0)
    {
        BlockFrame[30] += 1;
        if(BlockFrame[30] == 4)
            BlockFrame[30] = 0;
    }

    if(BlockFrame2[55] == 0)
    {
        BlockFrame[55] += 1;
        if(BlockFrame[55] == 4)
            BlockFrame[55] = 0;
    }

    if(BlockFrame2[88] == 0)
    {
        BlockFrame[88] += 1;
        if(BlockFrame[88] == 4)
            BlockFrame[88] = 0;
    }

    BlockFrame[170] = BlockFrame[88];

    if(BlockFrame2[109] == 0)
    {
        BlockFrame[109] += 1;
        if(BlockFrame[109] == 8)
            BlockFrame[109] = 0;
    }

    if(BlockFrame2[371] == 0)
    {
        BlockFrame[371] += 1;
        if(BlockFrame[371] == 8)
            BlockFrame[371] = 0;
    }

    if(BlockFrame2[379] == 0)
    {
        BlockFrame[379] += 1;
        if(BlockFrame[379] == 4)
            BlockFrame[379] = 0;
    }

    BlockFrame[380] = BlockFrame[379];
    BlockFrame[381] = BlockFrame[379];
    BlockFrame[382] = BlockFrame[379];

    BlockFrame2[530] += 1;

    if(BlockFrame2[530] <= 8)
        BlockFrame[530] = 0;
    else if(BlockFrame2[530] <= 16)
        BlockFrame[530] = 1;
    else if(BlockFrame2[530] <= 24)
        BlockFrame[530] = 2;
    else if(BlockFrame2[530] <= 32)
        BlockFrame[530] = 3;
    else if(BlockFrame2[530] <= 40)
        BlockFrame[530] = 2;
    else if(BlockFrame2[530] <= 48)
        BlockFrame[530] = 1;
    else
    {
        BlockFrame[530] = 0;
        BlockFrame2[530] = 0;
    }

    if(LevelEditor && !TestLevel)
        BlockFrame[458] = 5;
    else
    {
        tempBool = false;
        for(A = 1; A <= numPlayers; A++)
        {
            if(Player[A].Stoned)
            {
                tempBool = true;
                break;
            }
        }

        if(BlockFrame[458] < 5 && tempBool)
        {
            BlockFrame2[458] += 1;
            if(BlockFrame2[458] >= 4)
            {
                BlockFrame2[458] = 0;
                BlockFrame[458] += 1;
            }
        }
        else if(BlockFrame[458] > 0 && !tempBool)
        {
            BlockFrame2[458] += 1;
            if(BlockFrame2[458] >= 4)
            {
                BlockFrame2[458] = 0;
                BlockFrame[458] -= 1;
            }
        }
        else
            BlockFrame2[458] = 0;
    }
}

bool PSwitch(bool enabled);

bool UpdateBlocks()
{
    int B = 0;
    if(FreezeNPCs)
        return false;

    switch(g_gameLoopInterrupt.site)
    {
    case GameLoopInterrupt::UpdateBlocks_KillBlock:
    case GameLoopInterrupt::UpdateBlocks_TriggerHit:
        goto resume_iBlocks;
    case GameLoopInterrupt::UpdateBlocks_SwitchOn:
        goto resume_SwitchOn;
    case GameLoopInterrupt::UpdateBlocks_SwitchOff:
    case GameLoopInterrupt::UpdateBlocks_SwitchOff_KillBlock:
        goto resume_SwitchOff;
    default:
        break;
    }

    BlockFrames();

    if(BattleMode)
    {
        for(int A = 1; A <= numBlock; A++)
        {
            auto &b = Block[A];
            // respawn
            if(b.RespawnDelay_ScreensLeft > 0)
            {
                b.RespawnDelay_ScreensLeft += 1;
                if(b.RespawnDelay_ScreensLeft >= 65 * 60)
                {
                    if(b.DefaultType > 0 || b.DefaultSpecial > 0 || b.Layer == LAYER_DESTROYED_BLOCKS)
                    {
                        for(B = 1; B <= numPlayers; B++)
                        {
                            if(CheckCollision(b.Location, newLoc(Player[B].Location.X - 64, Player[B].Location.Y - 64, 128, 128)))
                            {
                                B = 0;
                                break;
                            }
                        }

                        if(B > 0)
                        {
                            if(b.Layer == LAYER_DESTROYED_BLOCKS)
                                b.Layer = LAYER_DEFAULT;

                            if(b.Hidden)
                            {
                                syncLayersTrees_Block_SetHidden(A);

                                if(!b.Hidden) // -V547 // False positive: the b.Hidden gets changed inside syncLayersTrees_Block_SetHidden() call
                                    NewEffect(EFFID_SMOKE_S3_CENTER, b.Location);
                            }
                            else
                            {
                                syncLayersTrees_Block(A);
                            }

                            if(b.Type != b.DefaultType || b.Special != b.DefaultSpecial)
                            {
                                if(b.Type != b.DefaultType)
                                    NewEffect(EFFID_SMOKE_S3_CENTER, b.Location);
                                b.Special = b.DefaultSpecial;
                                b.Type = b.DefaultType;
                            }

                            b.RespawnDelay_ScreensLeft = 0;
                        }
                        else
                            b.RespawnDelay_ScreensLeft = 65 * 30;
                    }
                    else
                        b.RespawnDelay_ScreensLeft = 0;
                }
            }
        }
    }

    int A;
    for(A = 1; A <= iBlocks; A++)
    {
        bool is_resume;
        if(false)
        {
resume_iBlocks:
            A = g_gameLoopInterrupt.A;
            is_resume = true;
        }
        else
            is_resume = false;

        auto &ib = Block[iBlock[A]];

        if(is_resume)
        {
            switch(g_gameLoopInterrupt.site)
            {
            case GameLoopInterrupt::UpdateBlocks_KillBlock:
                goto resume_KillBlock;
            case GameLoopInterrupt::UpdateBlocks_TriggerHit:
                goto resume_TriggerHit;
            default:
                break;
            }
        }

        // Update the shake effect
        if(ib.Hidden)
        {
            // ib.ShakeY = 0;
            // ib.ShakeY2 = 0;
            // ib.ShakeY3 = 0;

            ib.ShakeCounter = 0;
            ib.ShakeOffset = 0;
        }

        // check modBlocks.bas for the old shake logic
#if 0
        if(ib.ShakeY < 0) // Block Shake Up
        else if(ib.ShakeY > 0) // Block Shake Down
        else if(ib.ShakeY2 > 0) // Come back down
        else if(ib.ShakeY2 < 0) // Go back up
#endif

        if(ib.ShakeCounter != 0)
        {
            if(    (ib.ShakeCounter >= SHAKE_UPDOWN06_BEG && ib.ShakeCounter < SHAKE_UPDOWN06_MID)
                || (ib.ShakeCounter >= SHAKE_UPDOWN12_BEG && ib.ShakeCounter < SHAKE_UPDOWN12_MID)
                || (ib.ShakeCounter >= SHAKE_DOWNUP12_MID && ib.ShakeCounter < SHAKE_DOWNUP12_END))
            {
                ib.ShakeOffset -= 2;
            }
            else
                ib.ShakeOffset += 2;

            ib.ShakeCounter++;

            // do hit events at the middle of the shake program
            if(    ib.ShakeCounter == SHAKE_UPDOWN06_MID
                || ib.ShakeCounter == SHAKE_UPDOWN12_MID
                || ib.ShakeCounter == SHAKE_DOWNUP12_MID)
            {
                if(ib.TriggerHit != EVENT_NONE)
                {
                    eventindex_t resume_index;
                    resume_index = ProcEvent_Safe(false, ib.TriggerHit, 0);
                    while(resume_index != EVENT_NONE)
                    {
                        g_gameLoopInterrupt.C = resume_index;
                        g_gameLoopInterrupt.A = A;
                        g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateBlocks_TriggerHit;
                        return true;

resume_TriggerHit:
                        resume_index = g_gameLoopInterrupt.C;
                        g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                        resume_index = ProcEvent_Safe(true, resume_index, 0);
                    }
                }

                // on/off block
                if(ib.Type == 282)
                    ib.Type = 283;
                else if(ib.Type == 283)
                    ib.Type = 282;

                // spin block
                if(ib.Type == 90 && (ib.ShakeCounter == SHAKE_DOWNUP12_MID || ib.Special == 0) && !ib.forceSmashable)
                {
                    ib.Hidden = true;
                    invalidateDrawBlocks();
                    if(NewEffect(EFFID_SPINBLOCK, ib.Location, 1))
                        Effect[numEffects].NewNpc = iBlock[A];
                    ib.ShakeCounter = 0;
                    ib.ShakeOffset = 0;
                }
            }

            // finish the shake program
            if(    ib.ShakeCounter == SHAKE_UPDOWN06_END
                || ib.ShakeCounter == SHAKE_UPDOWN12_END
                || ib.ShakeCounter == SHAKE_DOWNUP12_END)
            {
                SDL_assert(ib.ShakeOffset == 0);

                if(ib.RapidHit > 0 && ib.Special > 0 && ib.ShakeCounter != SHAKE_DOWNUP12_END)
                {
                    ib.ShakeCounter = 0;

                    BlockHit(iBlock[A]);
                    ib.RapidHit -= 1;
                }
                else
                    ib.ShakeCounter = 0;
            }
        }

        if(ib.ShakeOffset != 0)
        {
            Location_t query_loc = ib.Location;
            query_loc.Y += ib.ShakeOffset;

            for(int B : treeNPCQuery(query_loc, SORTMODE_ID))
            {
                if(NPC[B].Active && NPC[B].Killed == 0 && NPC[B].Effect == NPCEFF_NORMAL && NPC[B].HoldingPlayer == 0 && (!NPC[B]->NoClipping || NPC[B]->IsACoin))
                {
                    if(ib.ShakeOffset <= 0 || NPC[B]->IsACoin)
                    {
                        if(ShakeCollision(NPC[B].Location, ib))
                        {
                            if(iBlock[A] != NPC[B].tempBlock && ib.tempBlockNpcIdx != B)
                            {
                                if(!BlockIsSizable[ib.Type] && !BlockOnlyHitspot1[ib.Type])
                                    NPCHit(B, 2, iBlock[A]);
                                else if(ib.Location.Y + 1 >= NPC[B].Location.Y + NPC[B].Location.Height - 1)
                                    NPCHit(B, 2, iBlock[A]);
                            }
                        }
                    }
                }
            }

            for(auto B = 1; B <= numPlayers; B++)
            {
                if(!Player[B].Dead)
                {
                    if(Player[B].Effect == PLREFF_NORMAL && ib.Type != 55)
                    {
                        if(ShakeCollision(Player[B].Location, ib))
                        {
                            if((!BlockIsSizable[ib.Type] && !BlockOnlyHitspot1[ib.Type]) || (ib.Location.Y + 1 >= Player[B].Location.Y + Player[B].Location.Height - 1))
                            {
                                Player[B].Location.SpeedY = Physics.PlayerJumpVelocity;
                                Player[B].StandUp = true;
                                PlaySoundSpatial(SFX_Stomp, Player[B].Location);
                            }
                        }
                    }
                }
            }
        }

        if(ib.Kill) // See if block should be broke
        {
            bool just_kill_it, is_breakable;
            {
                just_kill_it = (ib.Kill == 9);
                is_breakable = BlockIsBreakable(ib);
            }

            ib.Kill = false;

            if(is_breakable || just_kill_it)
            {
                if(false)
                {
resume_KillBlock:
                    (void)nullptr;
                }

                if(KillBlock(iBlock[A])) // Destroy the block
                {
                    g_gameLoopInterrupt.A = A;
                    g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateBlocks_KillBlock;
                    return true;
                }
            }
        }
    }

    for(auto A = iBlocks; A >= 1; A--)
    {
        auto &ib = Block[iBlock[A]];

        // if(ib.ShakeY1 == 0 && ib.ShakeY2 == 0 && ib.ShakeY3 == 0)
        if(ib.ShakeCounter == 0)
        {
            iBlock[A] = iBlock[iBlocks];
            iBlocks -= 1;
        }
    }

    if(PSwitchTime > 0)
    {
        if(PSwitchTime == Physics.NPCPSwitch)
        {
            StopMusic();
            StartMusic(-1);

            if(PSwitchPlayer >= 1 && PSwitchPlayer <= numPlayers)
                PlaySoundSpatial(SFX_PSwitch, Player[PSwitchPlayer].Location);
            else
                PlaySound(SFX_PSwitch);

resume_SwitchOn:
            if(PSwitch(true))
                return true;
        }

        PSwitchTime--;

        if(PSwitchTime == 195)
            PlaySound(SFX_CoinSwitchTimeout);

        if(PSwitchTime <= 1)
        {
resume_SwitchOff:
            if(PSwitch(false))
                return true;

            SwitchEndResumeMusic();
        }
    }

    return false;
}

void SwitchEndResumeMusic()
{
    StopMusic();

    if(InvincibilityTime)
    {
        StartMusic(-1);
        return;
    }

    int switch_player_section = Player[PSwitchPlayer].Section;

#ifndef THEXTECH_ENABLE_SDL_NET
    // originally, just used section of the player that triggered the switch
    StartMusic(switch_player_section);
#else
    // now, prefer that section if it's onscreen, but fallback to section of first onscreen player
    for(int i = l_screen->player_count - 1; i >= 0; i--)
    {
        int pi_section = Player[l_screen->players[i]].Section;
        if(i == 0 || pi_section == switch_player_section)
        {
            StartMusic(pi_section);
            return;
        }
    }
#endif
}

bool PSwitch(bool enabled)
{
    int A = 0;
    // int B = 0;
    Block_t blankBlock;
    eventindex_t resume_index = EVENT_NONE;

    switch(g_gameLoopInterrupt.site)
    {
    case GameLoopInterrupt::UpdateBlocks_SwitchOn:
    case GameLoopInterrupt::UpdateBlocks_SwitchOff:
        goto resume_ProcEvent;
    case GameLoopInterrupt::UpdateBlocks_SwitchOff_KillBlock:
        goto resume_KillBlock;
    default:
        break;
    }

    if(enabled)
    {
        for(A = 1; A <= numNPCs; A++)
        {
            bool transform = NPC[A]->IsACoin && NPC[A].coinSwitchBlockType() == 0 && !NPC[A].Hidden && NPC[A].Special == 0 && !NPC[A].Wings;

            if(NPC[A].Type == NPCID_MEDAL && g_config.fix_special_coin_switch)
                transform = false;

            if(transform)
            {
                if(numBlock < maxBlocks)
                {
                    numBlock++;
                    auto &nb = Block[numBlock];

                    if((NPC[A].Type == NPCID_GEM_1 || NPC[A].Type == NPCID_GEM_5 || NPC[A].Type == NPCID_GEM_20) && NPC[A].DefaultType != 0)
                        NPC[A].Type = NPC[A].DefaultType;

                    if(NPC[A].Type == NPCID_COIN_S4 || NPC[A].Type == NPCID_COIN_5)
                        nb.Type = 89;
                    else if(NPC[A].Type == NPCID_COIN_S1)
                        nb.Type = 188;
                    else if(NPC[A].Type == NPCID_RED_COIN)
                        nb.Type = 280;
                    else if(NPC[A].Type == NPCID_COIN_S2)
                        nb.Type = 293;
                    else
                        nb.Type = 4;

                    nb.TriggerDeath = NPC[A].TriggerDeath;
                    nb.TriggerLast = NPC[A].TriggerLast;
                    nb.Layer = NPC[A].Layer;
                    nb.Invis = false;
                    nb.Hidden = false;
                    nb.Location = NPC[A].Location;
                    nb.Location.Width = BlockWidth[nb.Type];
                    nb.Location.Height = BlockHeight[nb.Type];
                    nb.Location.X += (NPC[A].Location.Width - nb.Location.Width) / 2;
                    nb.Location.SpeedX = 0;
                    nb.Location.SpeedY = 0;
                    nb.Special = -NPC[A].Variant; // NEW: store Variant to preserve medals tracking
                    nb.Kill = false;
                    nb.coinSwitchNpcType = NPC[A].Type;

                    if(g_config.fix_switched_block_clipping)
                    {
                        nb.tempBlockNpcIdx = 0;
                        nb.tempBlockNpcType = NPCID_NULL;
                        nb.tempBlockVehiclePlr = 0;
                        nb.tempBlockVehicleYOffset = 0;
                    }

                    syncLayersTrees_Block(numBlock);
                }

                NPC[A].Killed = 9;
                NPCQueues::Killed.push_back(A);
            }
        }

        // From release v1.3.6.1 to release v1.3.7, this section had a much more complex routine
        // because I was trying to emulate sorting here without the blocks actually being sorted.
        // However, the blocks ARE sorted in compat mode since v1.3.6.1, so the code was actually
        // overcomplicated. -- ds-sloth

        // make the NPCs and kill the blocks
        for(A = numBlock; A >= 1; A--)
        {
            if(BlockPSwitch[Block[A].Type] && Block[A].Special == 0 && Block[A].coinSwitchNpcType == 0 && !Block[A].Hidden)
            {
                if(numNPCs < maxNPCs)
                {
                    numNPCs++;
                    auto &nn = NPC[numNPCs];
                    nn.Active = true;
                    nn.TimeLeft = 1;

                    if(Block[A].Type == 89)
                        nn.Type = NPCID_COIN_S4;
                    else if(Block[A].Type == 188 || Block[A].Type == 60)
                        nn.Type = NPCID_COIN_S1;
                    else if(Block[A].Type == 280)
                        nn.Type = NPCID_RED_COIN;
                    else if(Block[A].Type == 293)
                        nn.Type = NPCID_COIN_S2;
                    else
                        nn.Type = NPCID_COIN_S3;

                    nn.Layer = Block[A].Layer;
                    nn.TriggerDeath = Block[A].TriggerDeath;
                    nn.TriggerLast = Block[A].TriggerLast;
                    // nn.coinSwitchBlockType = Block[A].Type;
                    // this value has been moved to Damage for coins
                    nn.Damage = Block[A].Type;
                    nn.Hidden = false;
                    nn.Location = Block[A].Location;
                    nn.Location.SpeedX = 0;
                    nn.Location.SpeedY = 0;
                    nn.Location.Width = nn->TWidth;
                    nn.Location.Height = nn->THeight;
                    nn.Location.X += (Block[A].Location.Width - nn.Location.Width) / 2;
                    nn.DefaultLocationX = nn.Location.X;
                    nn.DefaultLocationY = nn.Location.Y;
                    nn.DefaultType = nn.Type;

                    // WARNING: this is new logic from #167. Check in case of any inconsistencies after Coin Switch is activated.
                    if(nn->TFrames > 0)
                    {
                        nn.Direction = 1;
                        nn.Frame = EditorNPCFrame(nn.Type, nn.Direction);
                        nn.DefaultDirection = nn.Direction;
                    }

                    syncLayers_NPC(numNPCs);
                    CheckSectionNPC(numNPCs);

                    Block[A] = Block[numBlock];
                    Block[numBlock] = blankBlock;
                    numBlock--;

                    // make sure that iBlock isn't forgotten (this is done for all blocks below if the compat flag is set)
                    if(!g_config.emulate_classic_block_order && iBlocks <= maxBlocks)
                    {
                        iBlocks++;
                        iBlock[iBlocks] = A;
                    }

                    syncLayersTrees_Block(A);
                    syncLayersTrees_Block(numBlock + 1);
                }
                else
                    break;
            }
        }

        resume_index = ProcEvent_Safe(false, EVENT_PSWITCH_START, 0, EventContext::CoinSwitch);
    }
    else
    {
        for(A = 1; A <= numNPCs; A++)
        {
            if(NPC[A].coinSwitchBlockType() > 0)
            {
                if(numBlock < maxBlocks)
                {
                    numBlock++;
                    auto &nb = Block[numBlock];
                    nb.Layer = NPC[A].Layer;
                    nb.TriggerDeath = NPC[A].TriggerDeath;
                    nb.TriggerLast = NPC[A].TriggerLast;
                    nb.Hidden = NPC[A].Hidden;
                    nb.Invis = false;
                    nb.Type = NPC[A].coinSwitchBlockType();
                    nb.Location = NPC[A].Location;
                    nb.Location.SpeedX = 0;
                    nb.Location.SpeedY = 0;
                    nb.Location.Width = BlockWidth[nb.Type];
                    nb.Location.Height = BlockHeight[nb.Type];
                    nb.Location.X += (NPC[A].Location.Width - nb.Location.Width) / 2;
                    nb.Special = 0;
                    nb.Kill = false;

                    if(g_config.fix_switched_block_clipping)
                    {
                        nb.coinSwitchNpcType = NPCID_NULL;
                        nb.tempBlockNpcIdx = 0;
                        nb.tempBlockNpcType = NPCID_NULL;
                        nb.tempBlockVehiclePlr = 0;
                        nb.tempBlockVehicleYOffset = 0;
                    }

                    syncLayersTrees_Block(numBlock);
                }
                NPC[A].Killed = 9;
                NPCQueues::Killed.push_back(A);
            }
        }


        // See comment in the previous section. There was a much more complicated routine here for some versions. -- ds-sloth

        // restore the NPCs
        for(A = numBlock; A >= 1; A--)
        {
            if(Block[A].coinSwitchNpcType > 0 && !Block[A].Hidden)
            {
                if(numNPCs >= maxNPCs)
                    break;

                // scoping nn
                {
                    numNPCs++;
                    auto &nn = NPC[numNPCs];
                    nn.Layer = Block[A].Layer;
                    nn.TriggerDeath = Block[A].TriggerDeath;
                    nn.TriggerLast = Block[A].TriggerLast;
                    nn.Active = true;
                    nn.TimeLeft = 1;
                    nn.Hidden = Block[A].Hidden;
                    nn.Type = Block[A].coinSwitchNpcType;
                    nn.Location = Block[A].Location;
                    nn.Location.SpeedX = 0;
                    nn.Location.SpeedY = 0;
                    nn.Location.Width = nn->TWidth;
                    nn.Location.Height = nn->THeight;
                    nn.Location.X += (Block[A].Location.Width - nn.Location.Width) / 2;
                    nn.DefaultLocationX = nn.Location.X;
                    nn.DefaultLocationY = nn.Location.Y;
                    nn.DefaultType = nn.Type;
                    nn.Variant = -Block[A].Special;

                    // WARNING: this is new logic from #167. Check in case of any inconsistencies after Coin Switch is activated.
                    if(nn->TFrames > 0)
                    {
                        nn.Direction = 1;
                        nn.Frame = EditorNPCFrame(nn.Type, nn.Direction);
                        nn.DefaultDirection = nn.Direction;
                    }

                    syncLayers_NPC(numNPCs);
                    CheckSectionNPC(numNPCs);
                    nn.Killed = 0;
                }

                if(false)
                {
resume_KillBlock:
                    A = g_gameLoopInterrupt.A;
                }

                if(KillBlock(A, false))
                {
                    g_gameLoopInterrupt.A = A;
                    g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateBlocks_SwitchOff_KillBlock;
                    return true;
                }

                Block[A].Layer = LAYER_USED_P_SWITCH;
                syncLayersTrees_Block(A);
                // this is as close to a permanent death as blocks get in the game,
                // because this layer usually doesn't exist
            }
        }

        resume_index = ProcEvent_Safe(false, EVENT_PSWITCH_END, 0, EventContext::CoinSwitch);
    }

    while(resume_index != EVENT_NONE)
    {
        g_gameLoopInterrupt.C = resume_index;
        g_gameLoopInterrupt.site = (enabled) ? GameLoopInterrupt::UpdateBlocks_SwitchOn : GameLoopInterrupt::UpdateBlocks_SwitchOff;
        return true;

resume_ProcEvent:
        resume_index = g_gameLoopInterrupt.C;
        g_gameLoopInterrupt.site = GameLoopInterrupt::None;

        resume_index = ProcEvent_Safe(true, resume_index, 0, EventContext::CoinSwitch);
    }

    // qSortBlocksX(1, numBlock);
    // B = 1;

    // for(A = 2; A <= numBlock; A++)
    // {
    //     if(Block[A].Location.X > Block[B].Location.X)
    //     {
    //         qSortBlocksY(B, A - 1);
    //         B = A;
    //     }
    // }

    // qSortBlocksY(B, A - 1);
    // FindSBlocks();
    // FindBlocks();
    // SO expensive, can't wait to get rid of this.
    // syncLayersTrees_AllBlocks();

    if(g_config.emulate_classic_block_order)
    {
        // Doing this just to replicate some unusual, unpredictable glitches
        // that sometimes occur when blocks' relative order is changing during the level

        qSortBlocksX(1, numBlock);
        int B = 1;

        for(A = 2; A <= numBlock; A++)
        {
            if(Block[A].Location.X > Block[B].Location.X)
            {
                qSortBlocksY(B, A - 1);
                B = A;
            }
        }

        qSortBlocksY(B, A - 1);

        syncLayersTrees_AllBlocks();

        BlocksSorted = true;

        // make sure that iBlock references weren't broken if blocks got sorted
        iBlocks = numBlock;
        for(A = 1; A <= numBlock; A++)
            iBlock[A] = A;
    }

    resetFrameTimer();

    return false;
}

void PowBlock()
{
    // For NetPlay: make this only affect screens where the earthquake block NPC is near at least one vScreen

    int numScreens = 0;
    int Z = 0;

    PlaySound(SFX_Stone);

    // Shake blocks. This isn't just cosmetic, it damages NPCs, so we should check the canonical screens here.

    for(int screen_i = 0; screen_i < c_screenCount; screen_i++)
    {
        Screen_t& screen = Screens[screen_i];

        if(!screen.is_active())
            continue;

        // use modern screen iteration bounds
        if(g_config.allow_multires)
        {
            Z = screen.active_begin() + 1;
            numScreens = screen.active_end();
        }
        // buggy original code, doesn't correctly handle SingleCoop
        else
        {
            Z = 1;
            numScreens = 1;

            if(!LevelEditor)
            {
                if(screen.Type == 1 || screen.Type == 4)
                    numScreens = 2;

                if(screen.Type == 5)
                {
                    DynamicScreen(screen);
                    if(screen.vScreen(2).Visible)
                        numScreens = 2;
                }
            }
        }

        for(; Z <= numScreens; Z++)
        {
            uint8_t vscreen_Z = screen.vScreen_refs[Z - 1];
            const vScreen_t& vscreen = vScreen[vscreen_Z];
            const Location_t query_loc = newLoc(-vscreen.X, -vscreen.Y, vscreen.Width, vscreen.Height);

            for(int A : treeBlockQuery(query_loc, SORTMODE_COMPAT))
            {
                if(vScreenCollision(vscreen_Z, Block[A].Location))
                {
                    if(!Block[A].Hidden)
                        BlockShakeUpPow(A);
                }
            }

            // force-activate coins on the canonical screens
            if(g_config.allow_multires && screen.is_canonical())
            {
                for(int A : treeNPCQuery(query_loc, SORTMODE_NONE))
                {
                    if(!NPC[A].Active && NPC[A]->IsACoin)
                    {
                        NPC[A].JustActivated = vscreen_Z;

                        NPCQueues::Active.insert(A);
                        NPC[A].Active = true;

                        NPC[A].TimeLeft = Physics.NPCTimeOffScreen;
                    }
                }
            }
        }

        if(!g_config.allow_multires)
            break;
    }

    for(int A : NPCQueues::Active.no_change)
    {
        if(NPC[A].Active)
        {
            if(NPC[A]->IsACoin)
            {
                NPC[A].Wings = WING_NONE;
                NPC[A].Special = 1;
                NPC[A].Location.SpeedX = dRand() - 0.5_n;
            }
        }
    }

    doShakeScreen(20, SHAKE_RANDOM);
}

bool BlockCheckPlayerFilter(int blockIdx, int playerIdx)
{
    auto block = Block[blockIdx].Type;
    auto player = Player[playerIdx].Character;

    switch(block)
    {
    case 626:
        return (player == 1);
    case 627:
        return (player == 2);
    case 628:
        return (player == 3);
    case 629:
        return (player == 4);
    case 632:
        return (player == 5);
    }

    return false;
}


================================================
FILE: src/blocks.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef BLOCKS_H
#define BLOCKS_H

#include "globals.h"

inline bool BlockTypeBreakable(int Type)
{
    return (Type == 4 || Type == 60 ||
       Type == 90 || Type == 188 ||
       Type == 226 || Type == 293 ||
       Type == 526);
}

inline bool BlockIsBreakable(const Block_t& block)
{
    return BlockTypeBreakable(block.Type) && block.Special <= 0;
}

// Check is this a player filter block that matches a character and must be ignored in checks
bool BlockCheckPlayerFilter(int blockIdx, int playerIdx);

//! The block was hit by a player
void BlockHit(int A, bool HitDown = false, int whatPlayer = 0);
//! Shake the block up
void BlockShakeUp(int A);
//! Shake the block up
void BlockShakeUpPow(int A);
//! Shake the block down
void BlockShakeDown(int A);

void BlockHitHard(int A);
//! Safely destroy a block
void SafelyKillBlock(int A);
//! Unsafely destroy a block; returns true if this procedure should be resumed. (this procedure will become private)
bool KillBlock(int A, bool Splode = true);
// update the frames for animated blocks
void BlockFrames();
//! Update the blocks; returns true if this procedure should be resumed.
bool UpdateBlocks();

//! turns all the blocks to coins and vice versa (now private, because it can interrupt the gameplay logic)
// bool PSwitch(bool enabled);
//! drops coins and shakes all blocks on screen when player throws a POW block
void PowBlock();

// Extra: restore the normal music after a switch ends
void SwitchEndResumeMusic();

#endif // BLOCKS_H


================================================
FILE: src/capabilities.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../version.h"
#include "capabilities.h"


const char *const g_capabilities =
    "{"
        "\"version\" : \"" V_LATEST_STABLE "\","
        "\"ipc-protocols\" : ["
            "\"moondust-stdinout\","
            "\"--END--\""
        "],"
        "\"arguments\" : ["
            "\"c\","
            "\"u\","
            "\"game-dirname\","
            "\"frameskip\","
            "\"no-frameskip\","
            "\"no-sound\","
            "\"never-pause\","
            "\"bg-input\","
            "\"vsync\","
            "\"render\","
            "\"leveltest\","
            "\"num-players\","
            "\"start-warp\","
            "\"battle\","
            "\"player1\","
            "\"player2\","
            "\"god-mode\","
            "\"grab-all\","
            "\"show-fps\","
            "\"max-fps\","
            "\"magic-hand\","
            "\"editor\","
            "\"interprocessing\","
            "\"compat-level\","
            "\"speed-run-mode\","
            "\"speed-run-semitransparent\","
            "\"speed-run-blink-mode\","
            "\"show-controls\","
            "\"show-battery-status\","
            "\"save-slot\","
            "\"export-lang\","
            "\"lang\","
            "\"verbose\","
            "\"levelpath\","
            "\"--END--\""
        "],"
        "\"renders\" : ["
            "\"sw\","
            "\"hw\","
            "\"vsync\","
            "\"sdl\","
#ifdef THEXTECH_BUILD_GL_DESKTOP_MODERN
            "\"opengl\","
#endif
#ifdef THEXTECH_BUILD_GL_ES_MODERN
            "\"opengles\","
#endif
#ifdef THEXTECH_BUILD_GL_DESKTOP_LEGACY
            "\"opengl11\","
#endif
#ifdef THEXTECH_BUILD_GL_ES_LEGACY
            "\"opengles11\","
#endif
            "\"--END--\""
        "],"
        "\"features\" : ["
            "\"stars-number\","
            "\"editor\","
            "\"test-level-file\","
            "\"test-level-ipc\","
            "\"test-world-file\","
            "\"vsync-flag\","
            "\"ipc-lvlx-multipart\","
            "\"ipc-player-health\","
            "\"ipc-player-item\","
            "\"--END--\""
        "]"
    "}";


================================================
FILE: src/capabilities.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef CAPABILITIES_H
#define CAPABILITIES_H

extern const char *const g_capabilities;

#endif // CAPABILITIES_H


================================================
FILE: src/change_res.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "config.h"
#include "change_res.h"
#include "load_gfx.h"
#include "graphics.h"
#include "sound.h"
#include "game_main.h"
#include "message.h"
#include "main/screen_asset_pack.h"
#include "core/render.h"
#include "core/window.h"
#include "core/render.h"
#ifdef __EMSCRIPTEN__
#include "core/events.h"
#endif

void SyncSysCursorDisplay()
{
    bool hide_cursor = false;

    // hide cursor in fullscreen
    if(XWindow::isFullScreen())
        hide_cursor = true;

    // hide cursor in game states that have own cursor
    if(GameMenu || MagicHand || LevelEditor || ScreenAssetPack::g_LoopActive)
        hide_cursor = true;

    // hide cursor in pause states that have own cursor
    if(GamePaused == PauseCode::Options || GamePaused == PauseCode::DropAdd || GamePaused == PauseCode::TextEntry)
        hide_cursor = true;

    if(hide_cursor)
    {
        XWindow::setCursor(CURSOR_NONE);
        XWindow::showCursor(0);
    }
    else
    {
        XWindow::setCursor(CURSOR_DEFAULT);
        XWindow::showCursor(1);
    }
}

void SetOrigRes()
{
    XWindow::setFullScreen(false);

#ifndef __EMSCRIPTEN__
    if(g_config.scale_mode == Config_t::SCALE_FIXED_05X)
        XWindow::setWindowSize(XRender::TargetW / 2, XRender::TargetH / 2);
    else if(g_config.scale_mode == Config_t::SCALE_FIXED_2X)
        XWindow::setWindowSize(XRender::TargetW * 2, XRender::TargetH * 2);
    else if(g_config.scale_mode == Config_t::SCALE_FIXED_3X)
        XWindow::setWindowSize(XRender::TargetW * 3, XRender::TargetH * 3);
    else
        XWindow::setWindowSize(XRender::TargetW, XRender::TargetH);
#endif

#ifdef __EMSCRIPTEN__
    XEvents::eventResize();
#endif

    if(LoadingInProcess)
        UpdateLoad();

    SyncSysCursorDisplay();
}

void ChangeRes(int, int, int, int)
{
    XWindow::setFullScreen(true);

    if(LoadingInProcess)
        UpdateLoad();

    SyncSysCursorDisplay();
}

//void SaveIt(int ScX, int ScY, int ScC, int ScF, std::string ScreenChanged)
//{

//}

void UpdateInternalRes()
{
    // bool ignore_compat = LevelEditor || (GameMenu && g_config.speedrun_mode.m_set < ConfigSetLevel::cmdline);
    bool ignore_compat = LevelEditor;

    int req_w = g_config.internal_res.m_value.first;
    int req_h = g_config.internal_res.m_value.second;

#ifndef PGE_MIN_PORT
    if(l_screen->Type == ScreenTypes::Quad && g_config.internal_res_4p.m_value.first != 0)
    {
        req_w = g_config.internal_res_4p.m_value.first;
        req_h = g_config.internal_res_4p.m_value.second;
        ignore_compat = true;
    }
#endif

    // use the correct canonical screen's resolution here
    int canon_w = l_screen->canonical_screen().W;
    int canon_h = l_screen->canonical_screen().H;

    if(!g_config.allow_multires && !ignore_compat)
    {
        if((req_w != 0 && req_w < canon_w) || (req_h != 0 && req_h < canon_h))
        {
            req_w = canon_w;
            req_h = canon_h;
        }
    }

    if(!XRender::is_nullptr() && (req_w == 0 || req_h == 0))
    {
        int int_w, int_h, orig_int_h;

        XRender::getRenderSize(&int_w, &int_h);
        orig_int_h = int_h;

        // set internal height first
        if(req_h != 0)
        {
            int_h = req_h;
        }
        else if(g_config.scale_mode == Config_t::SCALE_FIXED_05X)
        {
            int_h *= 2;
        }
        else if(g_config.scale_mode == Config_t::SCALE_FIXED_2X)
        {
            int_h /= 2;
        }
        else if(g_config.scale_mode == Config_t::SCALE_FIXED_3X)
        {
            int_h /= 3;
        }
        else if(g_config.scale_mode == Config_t::SCALE_DYNAMIC_INTEGER)
        {
            if(int_h >= 600)
            {
                // constrains height to be in the 600-720p range
                int scale_factor = int_h / 600;
                int_h /= scale_factor;
            }
        }

        // minimum height constraint
        if(int_h < 320)
            int_h = 320;

        // maximum height constraint
        if(int_h > 720 && req_h <= 720)
            int_h = 720;

        // now, set width based on height and scaling mode
        if(g_config.scale_mode == Config_t::SCALE_FIXED_05X)
        {
            int_w *= 2;
        }
        else if(g_config.scale_mode == Config_t::SCALE_FIXED_1X)
        {
            // keep as-is
            // int_w = int_w;
        }
        else if(g_config.scale_mode == Config_t::SCALE_FIXED_2X)
        {
            int_w /= 2;
        }
        else if(g_config.scale_mode == Config_t::SCALE_FIXED_3X)
        {
            int_w /= 3;
        }
        else if(g_config.scale_mode == Config_t::SCALE_DYNAMIC_INTEGER)
        {
            int scale_factor = orig_int_h / int_h;
            if(scale_factor == 0)
            {
                // keep as-is
                // int_w = int_w;
            }
            else if(int_w / scale_factor >= 800)
            {
                int_w /= scale_factor;
            }
            else
            {
                // scale based on width
                int scale_factor = int_w / 800;
                if(scale_factor != 0)
                    int_w /= scale_factor;

                // rescale the height if possible
                if(scale_factor != 0 && req_h == 0)
                {
                    int_h = orig_int_h / scale_factor;
                    if(int_h < 600)
                        int_h = 600;
                    if(int_h > 720)
                        int_h = 720;
                }
            }
        }
        else
        {
            int_w = (int_w * int_h) / orig_int_h;
        }

        // force >800x600 resolution if required
        if(!g_config.allow_multires && !ignore_compat)
        {
            if(int_w < canon_w)
            {
                int_h = (int_h * canon_w) / int_w;
                int_w = canon_w;
                if(int_h > 720)
                    int_h = 720;
            }

            if(int_h < canon_h)
            {
                int_w = (int_w * canon_h) / int_h;
                int_h = canon_h;
            }
        }

        // minimum width constraint
        if(int_w < 480)
            int_w = 480;

        // maximum 2.4 (cinematic) aspect ratio
        if(int_w > int_h * 24 / 10)
            int_w = int_h * 24 / 10;

        // force even dimensions
        int_w -= int_w & 1;
        int_h -= int_h & 1;

        XRender::TargetW = int_w;
        XRender::TargetH = int_h;
    }
    else
    {
        XRender::TargetW = req_w;
        XRender::TargetH = req_h;

        if(XRender::TargetW == 0)
            XRender::TargetW = (XRender::TargetH * 16 / 9) & ~1;

        if(XRender::TargetH == 0)
        {
            XRender::TargetW = 1280;
            XRender::TargetH = 720;
        }
    }

    if(LevelEditor || MagicHand)
    {
        XRender::TargetW = SDL_max(XRender::TargetW, 640);
        XRender::TargetH = SDL_max(XRender::TargetH, 480);
    }

    int new_CameraOverscanX = (g_config.allow_multires || ignore_compat) ? XRender::TargetCameraOverscanX : 0;
    XRender::TargetW += new_CameraOverscanX * 2;

    // DONE: above should tweak render target resolution. This should tweak game's screen resolution.
    int new_ScreenW, new_ScreenH;
    if(!GameMenu && !GameOutro && !LevelEditor && !BattleMode && g_VanillaCam)
    {
        XRender::TargetW = SDL_max(XRender::TargetW, canon_w);
        XRender::TargetH = SDL_max(XRender::TargetH, canon_h);
        new_ScreenW = canon_w;
        new_ScreenH = canon_h;
    }
    else if(ignore_compat || (g_config.allow_multires && g_config.dynamic_camera_logic))
    {
        new_ScreenW = XRender::TargetW;
        new_ScreenH = XRender::TargetH;
    }
    else if(g_config.allow_multires)
    {
        new_ScreenW = SDL_min(XRender::TargetW, canon_w);
        new_ScreenH = SDL_min(XRender::TargetH, canon_h);
    }
    else
    {
        new_ScreenW = canon_w;
        new_ScreenH = canon_h;
    }

    if(l_screen->W != new_ScreenW)
        XMessage::PushMessage({XMessage::Type::screen_w, (uint8_t)(new_ScreenW / 256), (uint8_t)(new_ScreenW % 256)});
    if(l_screen->H != new_ScreenH)
        XMessage::PushMessage({XMessage::Type::screen_h, (uint8_t)(new_ScreenH / 256), (uint8_t)(new_ScreenH % 256)});
    if(l_screen->CameraOverscanX != new_CameraOverscanX)
        XMessage::PushMessage({XMessage::Type::camera_overscan_x, 0, (uint8_t)new_CameraOverscanX});
    if(XRender::is_nullptr() || !GameIsActive)
        return;

    XRender::updateViewport();

    // recenter the game menu graphics
    if(GameMenu && (l_screen->W != new_ScreenW || l_screen->H != new_ScreenH))
    {
        l_screen->W = new_ScreenW;
        l_screen->H = new_ScreenH;

        SetupScreens();
        CenterScreens();
        GameMenu = false;
        GetvScreenAverage(Screens[0].vScreen(1));
        if(!Screens[0].is_canonical())
            GetvScreenAverage(Screens[0].canonical_screen().vScreen(1));
        GameMenu = true;
    }

    // disable world map qScreen if active
    if(LevelSelect && qScreen)
        qScreen = false;
}

void UpdateWindowRes()
{
    if(XWindow::is_nullptr() || XWindow::isFullScreen() || XWindow::isMaximized())
        return;

    int h = g_config.internal_res.m_value.second;
    if(h == 0)
        return;

    int w = g_config.internal_res.m_value.first;

    if(w == 0 && h == XRender::TargetH)
        w = XRender::TargetW;
    else if(w == 0)
        return;

    if(g_config.scale_mode == Config_t::SCALE_FIXED_05X)
        XWindow::setWindowSize(w / 2, h / 2);
    else if(g_config.scale_mode == Config_t::SCALE_FIXED_2X)
        XWindow::setWindowSize(w * 2, h * 2);
    else if(g_config.scale_mode == Config_t::SCALE_FIXED_3X)
        XWindow::setWindowSize(w * 3, h * 3);
    else
        XWindow::setWindowSize(w, h);
}



================================================
FILE: src/change_res.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CHANGE_RES_H
#define CHANGE_RES_H

// New: sync whether the window's cursor should be shown
void SyncSysCursorDisplay();

//void GetCurrentRes(); // Useless
void SetOrigRes();
void ChangeRes(int ScreenX, int ScreenY, int ScreenColor, int ScreenFreq);

// New: update the internal game resolution and scaling based on game window size and preferences
// Calls XRender::updateViewport on completion
void UpdateInternalRes();

// New: update the window size based on internal resolution and scaling factor
// Only active for windowed mode with 0.5x, 1x, or 2x scaling
void UpdateWindowRes();

#endif // CHANGE_RES_H


================================================
FILE: src/cmd_line_setup.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CMD_LINE_SETUP_H
#define CMD_LINE_SETUP_H

#include <string>

struct CmdLineSetup_t
{
    //! Is a level testing mode
    bool testLevelMode = false;
    //! Level file to test
    std::string testLevel;
    //! Replay file to run
    std::string testReplay;
    //! Number of players for level test
    int testNumPlayers = 1;
    //! Save slot to use for world test
    int testSave = 0;
    //! Run a test in battle mode
    bool testBattleMode = false;

    //! Custom-specified asset pack name or path
    std::string assetPack;

    //! Enable interprocessing communication with the Moondust Editor
    bool interprocess = false;

    //! Allow playable character grab everything
    bool testGrabAll = false;
    //! Make playable character be inmortal
    bool testGodMode = false;
    //! Enable magic-hand functionality
    bool testMagicHand = false;
    //! Open in editor
    bool testEditor = false;

    //! Force log output into console
    bool verboseLogging = false;
};

#endif // CMD_LINE_SETUP_H


================================================
FILE: src/collision.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "collision.h"

// Intersect collisions
bool CheckCollisionIntersect(const Location_t &Loc1, const Location_t &Loc2)
{
    if(Loc1.Y < Loc2.Y)
        return false;

    if(Loc1.Y + Loc1.Height > Loc2.Y + Loc2.Height)
        return false;

    if(Loc1.X < Loc2.X)
        return false;

    if(Loc1.X + Loc1.Width > Loc2.X + Loc2.Width)
        return false;

    return true;
}


// Make the game easier for the people who whine about the detection being 'off'
bool n00bCollision(const Location_t &Loc1, const Location_t &Loc2)
{
    bool tempn00bCollision = false;
    num_t EZ = 2;

    if(Loc2.Width >= 32 - EZ * 2 && Loc2.Height >= 32 - EZ * 2)
    {
        if(Loc1.Y + Loc1.Height - EZ >= Loc2.Y)
        {
            if(Loc1.Y + EZ <= Loc2.Y + Loc2.Height)
            {
                if(Loc1.X + EZ <= Loc2.X + Loc2.Width)
                {
                    if(Loc1.X + Loc1.Width - EZ >= Loc2.X)
                    {
                        tempn00bCollision = true;
                    }
                }
            }
        }
    }
    else
    {
        if(Loc1.Y + Loc1.Height >= Loc2.Y)
        {
            if(Loc1.Y <= Loc2.Y + Loc2.Height)
            {
                if(Loc1.X <= Loc2.X + Loc2.Width)
                {
                    if(Loc1.X + Loc1.Width >= Loc2.X)
                    {
                        tempn00bCollision = true;
                    }
                }
            }
        }
    }

    return tempn00bCollision;
}

#if 0
// Used when a NPC is activated to see if it should spawn
bool NPCStartCollision(const Location_t &Loc1, const Location_t &Loc2)
{
    bool tempNPCStartCollision = false;
    if(Loc1.X < Loc2.X + Loc2.Width)
    {
        if(Loc1.X + Loc1.Width > Loc2.X)
        {
            if(Loc1.Y < Loc2.Y + Loc2.Height)
            {
                if(Loc1.Y + Loc1.Height > Loc2.Y)
                {
                    tempNPCStartCollision = true;
                }
            }
        }
    }
    return tempNPCStartCollision;
}
#endif

// Warp point collisions
bool WarpCollision(const Location_t &Loc1, const SpeedlessLocation_t &entrance, int direction)
{
    bool hasCollision = false;

    num_t X2 = 0;
    num_t Y2 = 0;

    if(direction == 3)
    {
        X2 = 0;
        Y2 = 32;
    }
    else if(direction == 1)
    {
        X2 = 0;
        Y2 = -30;
    }
    else if(direction == 2)
    {
        X2 = -31;
        Y2 = 32;
    }
    else if(direction == 4)
    {
        X2 = 31;
        Y2 = 32;
    }

    if(Loc1.X <= entrance.X + entrance.Width + X2)
    {
        if(Loc1.X + Loc1.Width >= entrance.X + X2)
        {
            if(Loc1.Y <= entrance.Y + entrance.Height + Y2)
            {
                if(Loc1.Y + Loc1.Height >= entrance.Y + Y2)
                {
                    hasCollision = true;
                }
            }
        }
    }

    return hasCollision;
}

// Whats side the collision happened
int FindCollision(const Location_t &Loc1, const Location_t &Loc2)
{
    int tempFindCollision = COLLISION_NONE;

    if(Loc1.Y + Loc1.Height - Loc1.SpeedY <= Loc2.Y - Loc2.SpeedY)
    {
        tempFindCollision = COLLISION_TOP;
    }
    else if(Loc1.X - Loc1.SpeedX >= Loc2.X + Loc2.Width - Loc2.SpeedX)
    {
        tempFindCollision = COLLISION_RIGHT;
    }
    else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X - Loc2.SpeedX)
    {
        tempFindCollision = COLLISION_LEFT;
    }
    else if(Loc1.Y - Loc1.SpeedY > Loc2.Y + Loc2.Height - Loc2.SpeedY - 0.1_n)
    {
        tempFindCollision = COLLISION_BOTTOM;
    }
    else
    {
        tempFindCollision = COLLISION_CENTER;
    }

    return tempFindCollision;
}

// Whats side the collision happened for belts
int FindCollisionBelt(const Location_t &Loc1, const Location_t &Loc2, tempf_t BeltSpeed)
{
    int tempFindCollisionBelt = COLLISION_NONE;

    if(Loc1.Y + Loc1.Height - Loc1.SpeedY <= Loc2.Y - Loc2.SpeedY)
    {
        tempFindCollisionBelt = COLLISION_TOP;
    }
    else if(Loc1.X - Loc1.SpeedX - (num_t)BeltSpeed >= Loc2.X + Loc2.Width - Loc2.SpeedX)
    {
        tempFindCollisionBelt = COLLISION_RIGHT;
    }
    else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X - Loc2.SpeedX)
    {
        tempFindCollisionBelt = COLLISION_LEFT;
    }
    else if(Loc1.Y - Loc1.SpeedY - (num_t)BeltSpeed > Loc2.Y + Loc2.Height - Loc2.SpeedY - 0.1_n)
    {
        tempFindCollisionBelt = COLLISION_BOTTOM;
    }
    else
    {
        tempFindCollisionBelt = COLLISION_CENTER;
    }

    return tempFindCollisionBelt;
}

// Whats side the collision happened for NPCs
int NPCFindCollision(const Location_t &Loc1, const Location_t &Loc2)
{
    int tempNPCFindCollision = COLLISION_NONE;

    if(Loc1.Y + Loc1.Height - Loc1.SpeedY <= Loc2.Y - Loc2.SpeedY + 4)
    {
        tempNPCFindCollision = COLLISION_TOP;
    }
    else if(Loc1.X - Loc1.SpeedX >= Loc2.X + Loc2.Width - Loc2.SpeedX)
    {
        tempNPCFindCollision = COLLISION_RIGHT;
    }
    else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X - Loc2.SpeedX)
    {
        tempNPCFindCollision = COLLISION_LEFT;
    }
    else if(Loc1.Y - Loc1.SpeedY > Loc2.Y + Loc2.Height - Loc2.SpeedY - 0.1_n)
    {
        tempNPCFindCollision = COLLISION_BOTTOM;
    }
    else
    {
        tempNPCFindCollision = COLLISION_CENTER;
    }

    return tempNPCFindCollision;
}

// Easy mode collision for jumping on NPCs
int EasyModeCollision(const Location_t &Loc1, const Location_t &Loc2, bool StandOn)
{
    int tempEasyModeCollision = COLLISION_NONE;

    if(!FreezeNPCs)
    {
        if(Loc1.Y + Loc1.Height - Loc1.SpeedY <= Loc2.Y - Loc2.SpeedY + 10)
        {
            if(Loc1.SpeedY > Loc2.SpeedY || StandOn)
            {
                tempEasyModeCollision = COLLISION_TOP;
            }
            else
            {
                tempEasyModeCollision = COLLISION_NONE;
            }
        }
        else if(Loc1.X - Loc1.SpeedX >= Loc2.X + Loc2.Width - Loc2.SpeedX)
        {
            tempEasyModeCollision = COLLISION_RIGHT;
        }
        else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X - Loc2.SpeedX)
        {
            tempEasyModeCollision = COLLISION_LEFT;
        }
        else if(Loc1.Y - Loc1.SpeedY >= Loc2.Y + Loc2.Height - Loc2.SpeedY)
        {
            tempEasyModeCollision = COLLISION_BOTTOM;
        }
        else
        {
            tempEasyModeCollision = COLLISION_CENTER;
        }
    }
    else
    {
        if(Loc1.Y + Loc1.Height - Loc1.SpeedY <= Loc2.Y + 10)
        {
            tempEasyModeCollision = COLLISION_TOP;
        }
        else if(Loc1.X - Loc1.SpeedX >= Loc2.X + Loc2.Width)
        {
            tempEasyModeCollision = COLLISION_RIGHT;
        }
        else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X)
        {
            tempEasyModeCollision = COLLISION_LEFT;
        }
        else if(Loc1.Y - Loc1.SpeedY >= Loc2.Y + Loc2.Height)
        {
            tempEasyModeCollision = COLLISION_BOTTOM;
        }
        else
        {
            tempEasyModeCollision = COLLISION_CENTER;
        }
    }

    return tempEasyModeCollision;
}

// Easy mode collision for jumping on NPCs while on yoshi/boot
int BootCollision(const Location_t &Loc1, const Location_t &Loc2, bool StandOn)
{
    int tempBootCollision = COLLISION_NONE;

    if(!FreezeNPCs)
    {
        if(Loc1.Y + Loc1.Height - Loc1.SpeedY <= Loc2.Y - Loc2.SpeedY + 16)
        {
            if(Loc1.SpeedY > Loc2.SpeedY || StandOn)
            {
                tempBootCollision = COLLISION_TOP;
            }
            else
            {
                tempBootCollision = COLLISION_NONE;
            }
        }
        else if(Loc1.X - Loc1.SpeedX >= Loc2.X + Loc2.Width - Loc2.SpeedX)
        {
            tempBootCollision = COLLISION_RIGHT;
        }
        else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X - Loc2.SpeedX)
        {
            tempBootCollision = COLLISION_LEFT;
        }
        else if(Loc1.Y - Loc1.SpeedY >= Loc2.Y + Loc2.Height - Loc2.SpeedY)
        {
            tempBootCollision = COLLISION_BOTTOM;
        }
        else
        {
            tempBootCollision = COLLISION_CENTER;
        }
    }
    else
    {
        if(Loc1.Y + Loc1.Height - Loc1.SpeedY <= Loc2.Y + 16)
        {
            tempBootCollision = COLLISION_TOP;
        }
        else if(Loc1.X - Loc1.SpeedX >= Loc2.X + Loc2.Width)
        {
            tempBootCollision = COLLISION_RIGHT;
        }
        else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X)
        {
            tempBootCollision = COLLISION_LEFT;
        }
        else if(Loc1.Y - Loc1.SpeedY >= Loc2.Y + Loc2.Height)
        {
            tempBootCollision = COLLISION_BOTTOM;
        }
        else
        {
            tempBootCollision = COLLISION_CENTER;
        }
    }

    return tempBootCollision;

}

// Cursor collision
bool CursorCollision(const Location_t &Loc1, const Location_t &Loc2)
{
    return (Loc1.X <= Loc2.X + Loc2.Width - 1) &&
           (Loc1.X + Loc1.Width >= Loc2.X + 1) &&
           (Loc1.Y <= Loc2.Y + Loc2.Height - 1) &&
           (Loc1.Y + Loc1.Height >= Loc2.Y + 1);
}
bool CursorCollision(const Location_t &Loc1, const SpeedlessLocation_t &Loc2)
{
    return (Loc1.X <= Loc2.X + Loc2.Width - 1) &&
           (Loc1.X + Loc1.Width >= Loc2.X + 1) &&
           (Loc1.Y <= Loc2.Y + Loc2.Height - 1) &&
           (Loc1.Y + Loc1.Height >= Loc2.Y + 1);
}
bool CursorCollision(const Location_t &Loc1, const TinyLocation_t &Loc2)
{
    return (Loc1.X <= Loc2.X + Loc2.Width - 1) &&
           (Loc1.X + Loc1.Width >= Loc2.X + 1) &&
           (Loc1.Y <= Loc2.Y + Loc2.Height - 1) &&
           (Loc1.Y + Loc1.Height >= Loc2.Y + 1);
}

// Shakey block collision
bool ShakeCollision(const Location_t &Loc1, const Block_t &b)
{
    const Location_t &Loc2 = b.Location;

    bool tempShakeCollision = false;

    if(Loc1.X + 1 <= Loc2.X + Loc2.Width)
    {
        if(Loc1.X + Loc1.Width - 1 >= Loc2.X)
        {
            if(Loc1.Y <= Loc2.Y + Loc2.Height + b.ShakeOffset)
            {
                if(Loc1.Y + Loc1.Height >= Loc2.Y + b.ShakeOffset)
                {
                    tempShakeCollision = true;
                }
            }
        }
    }

    return tempShakeCollision;
}

// vScreen collisions
bool vScreenCollision(int A, const Location_t &Loc2)
{
    if(A == 0)
        return true;

    return (-vScreen[A].X <= Loc2.X + Loc2.Width) &&
           (-vScreen[A].X + vScreen[A].Width >= Loc2.X) &&
           (-vScreen[A].Y <= Loc2.Y + Loc2.Height) &&
           (-vScreen[A].Y + vScreen[A].Height >= Loc2.Y);
}

bool vScreenCollision(int A, const SpeedlessLocation_t &Loc2)
{
    if(A == 0)
        return true;

    return (-vScreen[A].X <= Loc2.X + Loc2.Width) &&
           (-vScreen[A].X + vScreen[A].Width >= Loc2.X) &&
           (-vScreen[A].Y <= Loc2.Y + Loc2.Height) &&
           (-vScreen[A].Y + vScreen[A].Height >= Loc2.Y);
}

bool vScreenCollision(int A, const TinyLocation_t &Loc2)
{
    if(A == 0)
        return true;

    return (-vScreen[A].X <= Loc2.X + Loc2.Width) &&
           (-vScreen[A].X + vScreen[A].Width >= Loc2.X) &&
           (-vScreen[A].Y <= Loc2.Y + Loc2.Height) &&
           (-vScreen[A].Y + vScreen[A].Height >= Loc2.Y);
}

#if 0
// vScreen collisions 2
bool vScreenCollision2(int A, const Location_t &Loc2)
{
    return (-vScreen[A].X + 64 <= Loc2.X + Loc2.Width) &&
           (-vScreen[A].X + vScreen[A].Width - 64 >= Loc2.X) &&
           (-vScreen[A].Y + 96 <= Loc2.Y + Loc2.Height) &&
           (-vScreen[A].Y + vScreen[A].Height - 64 >= Loc2.Y);
}

bool vScreenCollision2(int A, const SpeedlessLocation_t &Loc2)
{
    return (-vScreen[A].X + 64 <= Loc2.X + Loc2.Width) &&
           (-vScreen[A].X + vScreen[A].Width - 64 >= Loc2.X) &&
           (-vScreen[A].Y + 96 <= Loc2.Y + Loc2.Height) &&
           (-vScreen[A].Y + vScreen[A].Height - 64 >= Loc2.Y);
}

bool vScreenCollision2(int A, const TinyLocation_t &Loc2)
{
    return (-vScreen[A].X + 64 <= Loc2.X + Loc2.Width) &&
           (-vScreen[A].X + vScreen[A].Width - 64 >= Loc2.X) &&
           (-vScreen[A].Y + 96 <= Loc2.Y + Loc2.Height) &&
           (-vScreen[A].Y + vScreen[A].Height - 64 >= Loc2.Y);
}
#endif

// Collision detection for blocks. Prevents walking on walls.
bool WalkingCollision(const Location_t &Loc1, const Location_t &Loc2)
{
    bool tempWalkingCollision = false;

    if(Loc1.X <= Loc2.X + Loc2.Width + Loc1.SpeedX)
    {
        if(Loc1.X + Loc1.Width >= Loc2.X + Loc1.SpeedX)
        {
            tempWalkingCollision = true;
        }
    }

    return tempWalkingCollision;
}

// Collision detection for blocks. Lets NPCs fall through cracks.
#if 0
bool WalkingCollision2(const Location_t &Loc1, const Location_t &Loc2)
{
    bool tempWalkingCollision2 = false;

    if(Loc1.X <= Loc2.X + Loc2.Width - Loc1.SpeedX - 1)
    {
        if(Loc1.X + Loc1.Width >= Loc2.X - Loc1.SpeedX + 1)
        {
            tempWalkingCollision2 = true;
        }
    }

    return tempWalkingCollision2;
}
#endif

// Factors in beltspeed
bool WalkingCollision3(const Location_t &Loc1, const Location_t &Loc2, tempf_t BeltSpeed)
{
    bool tempWalkingCollision3 = false;

    if(Loc1.X <= Loc2.X + Loc2.Width - (Loc1.SpeedX + (num_t)BeltSpeed) - 1)
    {
        if(Loc1.X + Loc1.Width >= Loc2.X - (Loc1.SpeedX + (num_t)BeltSpeed) + 1)
        {
            tempWalkingCollision3 = true;
        }
    }

    return tempWalkingCollision3;
}

// Helps the player to walk over 1 unit cracks
int FindRunningCollision(const Location_t &Loc1, const Location_t &Loc2, num_t BeltSpeedX)
{
    int tempFindRunningCollision = COLLISION_NONE;

    if(Loc1.Y + Loc1.Height - Loc1.SpeedY - 2.5_n <= Loc2.Y - Loc2.SpeedY)
    {
        tempFindRunningCollision = COLLISION_TOP;
    }
    else if(Loc1.X - Loc1.SpeedX >= Loc2.X + Loc2.Width - (Loc2.SpeedX - BeltSpeedX))
    {
        tempFindRunningCollision = COLLISION_RIGHT;
    }
    else if(Loc1.X + Loc1.Width - Loc1.SpeedX <= Loc2.X - (Loc2.SpeedX - BeltSpeedX))
    {
        tempFindRunningCollision = COLLISION_LEFT;
    }
    else if(Loc1.Y - Loc1.SpeedY >= Loc2.Y + Loc2.Height - Loc2.SpeedY)
    {
        tempFindRunningCollision = COLLISION_BOTTOM;
    }
    else
    {
        tempFindRunningCollision = COLLISION_CENTER;
    }

    return tempFindRunningCollision;
}

// Determines if an NPC should turnaround
#if 0
bool ShouldTurnAround(const Location_t &Loc1, const Location_t &Loc2, float Direction)
{
    bool tempShouldTurnAround = false;
    tempShouldTurnAround = true;

    if(Loc1.Y + Loc1.Height + 8 <= Loc2.Y + Loc2.Height)
    {
        if(Loc1.Y + Loc1.Height + 8 >= Loc2.Y)
        {
            if(Loc1.X + Loc1.Width * 0.5 + (8 * Direction) <= Loc2.X + Loc2.Width)
            {
                if(Loc1.X + Loc1.Width * 0.5 + (8 * Direction) >= Loc2.X)
                {
                    if(Loc2.Y > Loc1.Y + Loc1.Height - 8)
                    {
                        tempShouldTurnAround = false;
                    }
                }
            }
        }
    }

    return tempShouldTurnAround;
}
#endif

// Determines if an NPC can come out of a pipe
bool CanComeOut(const Location_t &Loc1, const Location_t &Loc2)
{
    bool tempCanComeOut = false;
    tempCanComeOut = true;

    if(Loc1.X <= Loc2.X + Loc2.Width + 32)
    {
        if(Loc1.X + Loc1.Width >= Loc2.X - 32)
        {
            if(Loc1.Y <= Loc2.Y + Loc2.Height + 300)
            {
                if(Loc1.Y + Loc1.Height >= Loc2.Y - 300)
                {
                    tempCanComeOut = false;
                }
            }
        }
    }

    return tempCanComeOut;
}

// Fixes NPCs sinking through the ground
bool CheckHitSpot1(const Location_t &Loc1, const Location_t &Loc2)
{
    bool tempCheckHitSpot1 = false;

    if(Loc1.Y + Loc1.Height - Loc1.SpeedY - Physics.NPCGravity <= Loc2.Y - Loc2.SpeedY)
    {
        tempCheckHitSpot1 = true;
    }

    return tempCheckHitSpot1;
}

num_t blockGetTopYTouching(const Block_t &block, const Location_t& loc)
{
    // Get slope type
    int blockType = block.Type;
    int slopeDirection;

    if((blockType >= 1) && (blockType <= maxBlockType))
    {
        slopeDirection = BlockSlope[blockType];
    }
    else
    {
        slopeDirection = 0;
    }

    // The simple case, no slope
    if(slopeDirection == 0)
    {
        return block.Location.Y;
    }

    // The degenerate case, no width
    if(block.Location.Width <= 0)
    {
        return block.Location.Y;
    }

    // The following uses a slope calculation like 1.3 does

    // Get right or left x coordinate as relevant for the slope direction
    num_t refX = loc.X;
    if(slopeDirection < 0)
        refX += loc.Width;

    // Get how far along the slope we are in the x direction
    num_t slope = (refX - block.Location.X) / (int_ok)block.Location.Width;
    if(slopeDirection < 0) slope = 1 - slope;
    if(slope < 0) slope = 0;
    if(slope > 1) slope = 1;

    // Determine the y coordinate
    return block.Location.Y + (int_ok)block.Location.Height * slope;
}

bool CompareWalkBlock(int oldBlockIdx, int newBlockIdx, const Location_t &referenceLoc)
{
    if(oldBlockIdx > numBlock)
        return false;
    if(newBlockIdx > numBlock)
        return false;

    const Block_t& oldBlock = Block[oldBlockIdx];
    const Block_t& newBlock = Block[newBlockIdx];

    num_t newBlockY = blockGetTopYTouching(newBlock, referenceLoc);
    num_t oldBlockY = blockGetTopYTouching(oldBlock, referenceLoc);

    if(newBlockY < oldBlockY)
    {
        // New block is higher, replace
        return true;
    }
    else if(newBlockY > oldBlockY)
    {
        // New block is lower, don't replace
        return false;
    }

    // Break tie based on if one is moving upward faster
    num_t newBlockSpeedY = newBlock.Location.SpeedY;
    num_t oldBlockSpeedY = oldBlock.Location.SpeedY;

    if(newBlockSpeedY < oldBlockSpeedY)
    {
        // New block is moving more upward, replace
        return true;
    }
    else if(newBlockSpeedY > oldBlockSpeedY)
    {
        // New block is moving more downward, don't replace
        return false;
    }

    num_t refX = referenceLoc.X + referenceLoc.Width / 2;

    // Break tie based on which of blocks intersects the center point
    bool oldIntersects = referenceLoc.X >= oldBlock.Location.X && referenceLoc.X + referenceLoc.Width <= oldBlock.Location.X + oldBlock.Location.Width;
    bool newIntersects = referenceLoc.X >= newBlock.Location.X && referenceLoc.X + referenceLoc.Width <= newBlock.Location.X + newBlock.Location.Width;

    if(newIntersects && !oldIntersects)
    {
        // New block intersects
        return true;
    }
    else if(!newIntersects && oldIntersects)
    {
        // Old block intersects
        return false;
    }

    // Break tie based on x-proximity
    num_t newBlockDist = num_t::abs((newBlock.Location.X + newBlock.Location.Width / 2) - refX);
    num_t oldBlockDist = num_t::abs((oldBlock.Location.X + oldBlock.Location.Width / 2) - refX);

    if(newBlockDist < oldBlockDist)
    {
        // New block is closer, replace
        return true;
    }

    if(newBlockDist > oldBlockDist)
    {
        // New block further, don't replace
        return false;
    }

    // Break tie based on narrower width (more specific match)
    num_t newBlockWidth = newBlock.Location.Width;
    num_t oldBlockWidth = oldBlock.Location.Width;

    if(newBlockWidth < oldBlockWidth)
    {
        // New block is narrower, replace
        return true;
    }

    if(newBlockWidth > oldBlockWidth)
    {
        // New block wider, don't replace
        return false;
    }

    // Still tied? Let's just not replace
    return false;
}

void CompareNpcWalkBlock(int &tempHitBlock, int &tempHitOldBlock,
                         num_t &tempHit,   num_t &tempHitOld,
                         int &tempHitIsSlope, NPC_t *npc)
{
    int oldBlockIdx  = tempHitOldBlock;
    int newBlockIdx  = tempHitBlock;
    Location_t &loc = npc->Location;

    // If no temp block was already set, just exit
    if(tempHitOldBlock == 0)
    {
        // tempHitBlock is set, don't revert
        tempHitIsSlope = 0;
        if(npc->Slope && (npc->Slope != newBlockIdx))
        {
            if(CompareWalkBlock(npc->Slope, newBlockIdx, loc) != 0)
            {
                npc->Slope = 0;
            }
        }
        return;
    }

    // Compare blocks
    int compareResult = CompareWalkBlock(oldBlockIdx, newBlockIdx, loc);

    // Revert to the old block if the comparison says we shouldn't replace
    if(compareResult == 0)
    {
        // We shouldn't replace, so revert variables
        tempHitBlock = tempHitOldBlock;
        tempHit = tempHitOld;
    }
    else
    {
        // tempHitBlock is set, don't revert
        tempHitIsSlope = 0;
        if(npc->Slope && (npc->Slope != newBlockIdx))
        {
            if(CompareWalkBlock(npc->Slope, newBlockIdx, loc) != 0)
            {
                npc->Slope = 0;
            }
        }
    }
}

bool SectionCollision(const int section, const Location_t &loc)
{
    const auto &sec = level[section];
    const num_t gap = 64;

    if(loc.X + loc.Width < sec.X - gap)
        return false;

    if(loc.X > sec.Width + gap)
        return false;

    if(loc.Y + loc.Height < sec.Y - gap)
        return false;

    if(loc.Y > sec.Height)
        return false;

    return true;
}


================================================
FILE: src/collision.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef COLLISION_H
#define COLLISION_H

#include "location.h"

struct NPC_t;
struct Block_t;

enum CollisionSpot
{
    COLLISION_NONE = 0,
    COLLISION_TOP = 1,
    COLLISION_RIGHT = 2,
    COLLISION_BOTTOM = 3,
    COLLISION_LEFT = 4,
    COLLISION_CENTER = 5
};

// Public Function CheckCollision(Loc1 As Location, Loc2 As Location) As Boolean 'Normal collisions
// Normal collisions
template<class T1, class T2>
bool CheckCollision(const T1 &Loc1, const T2 &Loc2)
{
    return (Loc1.Y + Loc1.Height >= Loc2.Y) &&
           (Loc1.Y <= Loc2.Y + Loc2.Height) &&
           (Loc1.X <= Loc2.X + Loc2.Width) &&
           (Loc1.X + Loc1.Width >= Loc2.X);
}
// Intersect collision
bool CheckCollisionIntersect(const Location_t &Loc1, const Location_t &Loc2);
// Public Function n00bCollision(Loc1 As Location, Loc2 As Location) As Boolean 'Make the game easier for the people who whine about the detection being 'off'
// Make the game easier for the people who whine about the detection being 'off'
bool n00bCollision(const Location_t &Loc1, const Location_t &Loc2);
// Public Function NPCStartCollision(Loc1 As Location, Loc2 As Location) As Boolean 'Used when a NPC is activated to see if it should spawn
// Used when a NPC is activated to see if it should spawn
// bool NPCStartCollision(const Location_t &Loc1, const Location_t &Loc2);
// Public Function WarpCollision(Loc1 As Location, A As Integer) As Boolean  'Warp point collisions
// Warp point collisions
bool WarpCollision(const Location_t &Loc1, const SpeedlessLocation_t &entrance, int direction);
// Public Function FindCollision(Loc1 As Location, Loc2 As Location) As Integer 'Whats side the collision happened
// Whats side the collision happened
int FindCollision(const Location_t &Loc1, const Location_t &Loc2);
// Public Function FindCollisionBelt(Loc1 As Location, Loc2 As Location, BeltSpeed As Single) As Integer  'Whats side the collision happened for belts
// Whats side the collision happened for belts
int FindCollisionBelt(const Location_t &Loc1, const Location_t &Loc2, tempf_t BeltSpeed);
// Public Function NPCFindCollision(Loc1 As Location, Loc2 As Location) As Integer 'Whats side the collision happened for NPCs
// Whats side the collision happened for NPCs
int NPCFindCollision(const Location_t &Loc1, const Location_t &Loc2);
// Public Function EasyModeCollision(Loc1 As Location, Loc2 As Location, Optional StandOn As Boolean = False) As Integer  'Easy mode collision for jumping on NPCs
// Easy mode collision for jumping on NPCs
int EasyModeCollision(const Location_t &Loc1, const Location_t &Loc2, bool StandOn);
// Public Function BootCollision(Loc1 As Location, Loc2 As Location, Optional StandOn As Boolean = False) As Integer 'Easy mode collision for jumping on NPCs while on yoshi/boot
// Easy mode collision for jumping on NPCs while on yoshi/boot
int BootCollision(const Location_t &Loc1, const Location_t &Loc2, bool StandOn);
// Public Function CursorCollision(Loc1 As Location, Loc2 As Location) As Boolean 'Cursor collision
// Cursor collision
bool CursorCollision(const Location_t &Loc1, const Location_t &Loc2);
bool CursorCollision(const Location_t &Loc1, const SpeedlessLocation_t &Loc2);
bool CursorCollision(const Location_t &Loc1, const TinyLocation_t &Loc2);
// Public Function ShakeCollision(Loc1 As Location, Loc2 As Location, ShakeY3 As Integer) As Boolean 'Shakey block collision
// Shakey block collision
bool ShakeCollision(const Location_t &Loc1, const Block_t &b);
// Public Function vScreenCollision(A As Integer, Loc2 As Location) As Boolean  'vScreen collisions
// vScreen collisions
bool vScreenCollision(int A, const Location_t &Loc2);
bool vScreenCollision(int A, const SpeedlessLocation_t &Loc2);
bool vScreenCollision(int A, const TinyLocation_t &Loc2);
// Public Function vScreenCollision2(A As Integer, Loc2 As Location) As Boolean  'vScreen collisions 2
// vScreen collisions 2
// bool vScreenCollision2(int A, const Location_t &Loc2);
// bool vScreenCollision2(int A, const SpeedlessLocation_t &Loc2);
// bool vScreenCollision2(int A, const TinyLocation_t &Loc2);
// Public Function WalkingCollision(Loc1 As Location, Loc2 As Location) As Boolean 'Collision detection for blocks. Prevents walking on walls.
// Collision detection for blocks. Prevents walking on walls.
bool WalkingCollision(const Location_t &Loc1, const Location_t &Loc2);
// Public Function WalkingCollision2(Loc1 As Location, Loc2 As Location) As Boolean 'Collision detection for blocks. Lets NPCs fall through cracks.
// Collision detection for blocks. Lets NPCs fall through cracks.
// bool WalkingCollision2(const Location_t &Loc1, const Location_t &Loc2);
// Public Function WalkingCollision3(Loc1 As Location, Loc2 As Location, BeltSpeed As Single) As Boolean 'Factors in beltspeed
// Factors in beltspeed
bool WalkingCollision3(const Location_t &Loc1, const Location_t &Loc2, tempf_t BeltSpeed);
// Public Function FindRunningCollision(Loc1 As Location, Loc2 As Location) As Integer 'Helps the player to walk over 1 unit cracks
// Helps the player to walk over 1 unit cracks
// NEW: BeltSpeedX accounts for the speed of a conveyor belt when testing side collisions
int FindRunningCollision(const Location_t &Loc1, const Location_t &Loc2, num_t BeltSpeedX);
// Public Function ShouldTurnAround(Loc1 As Location, Loc2 As Location, Direction As Single) As Boolean  'Determines if an NPC should turnaround
// Determines if an NPC should turnaround
// bool ShouldTurnAround(const Location_t &Loc1, const Location_t &Loc2, float Direction);
// Public Function CanComeOut(Loc1 As Location, Loc2 As Location) As Boolean  'Determines if an NPC can come out of a pipe
// Determines if an NPC can come out of a pipe
bool CanComeOut(const Location_t &Loc1, const Location_t &Loc2);
// Public Function CheckHitSpot1(Loc1 As Location, Loc2 As Location) As Boolean  'Fixes NPCs sinking through the ground
// Fixes NPCs sinking through the ground
bool CheckHitSpot1(const Location_t &Loc1, const Location_t &Loc2);

num_t blockGetTopYTouching(const Block_t &block, const Location_t& loc);

bool CompareWalkBlock(int oldBlockIdx, int newBlockIdx, const Location_t &referenceLoc);

void CompareNpcWalkBlock(int &tempHitBlock, int &tempHitOldBlock,
                         num_t &tempHit,   num_t &tempHitOld,
                         int &tempHitIsSlope, NPC_t *npc);

bool SectionCollision(const int section, const Location_t &loc);

#endif // COLLISION_H


================================================
FILE: src/compat.cpp
================================================


================================================
FILE: src/compat.h
================================================


================================================
FILE: src/config/config_base.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <set>

#include <fmt_format_ne.h>

#include "config/config_base.hpp"
#include "config.h"

#include "main/translate.h"

// can't include config_impl.hpp to avoid multiple declarations

// config_base.cpp
extern ConfigSetLevel g_configWriteLevel;

// config_main.cpp
extern bool g_configInTransaction;
extern std::set<BaseConfigOption_t<true>*> g_configModified;


ConfigSetLevel g_configWriteLevel = ConfigSetLevel::debug;

ConfigChangeSentinel::ConfigChangeSentinel(ConfigSetLevel level)
{
    m_prev_level = g_configWriteLevel;
    g_configWriteLevel = level;
}

ConfigChangeSentinel::~ConfigChangeSentinel()
{
    g_configWriteLevel = m_prev_level;
}


// base config
BaseConfigOption_t<false>::BaseConfigOption_t(_Config_t<false>* parent, uint8_t scope,
    const char* internal_name, const char* display_name, const char* display_tooltip,
    void (*onupdate)(), bool (*active)(), bool (*validate)(void*))
 : m_index(parent->m_options.size()),
   m_scope(scope),
   m_internal_name(internal_name),
   m_display_name(display_name ? display_name : ""),
   m_display_tooltip(display_tooltip ? display_tooltip : ""),
   m_onupdate(onupdate),
   m_active(active),
   m_validate(validate)
{
    parent->m_options.push_back(this);
}

void BaseConfigOption_t<false>::make_translation(XTechTranslate& translate, const char* cur_section_id)
{
    if((m_scope & Options_t::Scope::MakeTranslation) == 0)
        return;

    XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s.%s", cur_section_id, m_internal_name), &m_display_name);

    if(!m_display_tooltip.empty())
        XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s.%s-tip", cur_section_id, m_internal_name), &m_display_tooltip);
}

BaseConfigOption_t<true>::BaseConfigOption_t(_Config_t<true>* parent) : m_index(parent->m_options.size())
{
    parent->m_options.push_back(this);

    if(!parent->m_base)
        return;
    if((size_t)m_index >= parent->m_base->m_options.size())
        return;
    m_base = parent->m_base->m_options[m_index];
}

bool BaseConfigOption_t<true>::is_main() const
{
    return (size_t)this >= (size_t)(&g_config) && (size_t)this < (size_t)(&g_config) + sizeof(_Config_t<true>);
}

void BaseConfigOption_t<true>::_on_change()
{
    if(m_base && m_base->m_onupdate && is_main())
    {
        if(g_configInTransaction)
            g_configModified.insert(this);
        else
            m_base->m_onupdate();
    }
}


const std::string& BaseConfigOption_t<true>::get_display_name(std::string& out) const
{
    if(!m_base || m_base->m_display_name.empty())
        return out = "(INVALID)";

    return out = m_base->m_display_name;
}

const std::string& BaseConfigOption_t<true>::get_tooltip(std::string& out) const
{
    if(!m_base || m_base->m_display_tooltip.empty())
        return out = "";

    return out = m_base->m_display_tooltip;
}

void ConfigSection_t<false>::make_translation(XTechTranslate& translate, const char* cur_section_id)
{
    if(this != &g_options.compat && (m_scope & Options_t::Scope::MakeTranslation) == 0)
        return;

    XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s._header", cur_section_id), &m_display_name);

    if(!m_display_tooltip.empty())
        XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s._tooltip", cur_section_id), &m_display_tooltip);
}


================================================
FILE: src/config/config_base.hpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

// again, want all Config objects to share:
//   internal names, display names, tooltips, default values, compat values, value internal names, display names, tooltips

// want the specific Config objects to have:
//   current values, whether they are set

#pragma once
#ifndef CONFIG_BASE_HPP
#define CONFIG_BASE_HPP

#include <cstdint>
#include <string>
#include <vector>
#include <array>
#include <unordered_map>

class IniProcessing;
class XTechTranslate;

// There are two versions of each class, one to represent the read-only information about an option,
//   and another to represent a particular setting of the option.

template<bool writable>
class BaseConfigOption_t;

template<bool writable>
class ConfigSection_t;

template<bool writable>
class ConfigSubSection_t;

template<bool writable, class value_t>
class ConfigOption_t;

template<bool writable, class value_t>
class ConfigEnumOption_t;

template<bool writable, class value_t>
class ConfigRangeOption_t;

template<bool writable>
class ConfigLanguage_t;

template<bool writable>
class ConfigFullscreenRes_t;

template<bool writable>
class ConfigSetupEnum_t;

template<bool writable>
class _Config_t;

// helper classes

enum class ConfigSetLevel : uint8_t
{
    unset = 0,
    set, // used by sub-configs
    game_defaults,
    game_info,
    user_config,
    bugfix_defaults,
    ep_compat,
    file_compat,
    ep_config, // per-save configuration of an episode (very limited)
    cmdline,
    cheat,
    speedrun,
    compat,
    script,
    debug,
};

class ConfigChangeSentinel
{
    ConfigSetLevel m_prev_level;

public:
    ConfigChangeSentinel(ConfigSetLevel set_level);
    ~ConfigChangeSentinel();
};


// the compat modes are identical to the NetPlay and speedrun presets
enum class CompatMode
{
    off,       // use the user's config and the creator compat
    modern,    // force modern defaults for all user settings, do use creator compats
    classic,   // disable all standard bugfixes, force critical updates and gameplay enhancements on, do use creator compats
    smbx64,    // disable all bugfixes and gameplay enhancements, do not use creator compats
};

enum class CompatClass
{
    pure_preference,      // user-side preference (or gameinfo value) that does not impact game logic at all
    critical_update,      // performance- and flexibility-critical enhancements and bugfixes that prevent predictable unfair deaths, disabled in SMBX64 compat mode only
    standard_update,      // ordinary fixes of vanilla bugs that get disabled during non-modern gameplay; these are determined by a user's Modern / Classic setting for a world even when compat mode is off
};


template<class value_t>
struct ConfigCompatInfo_t
{
    const CompatClass mode = CompatClass::pure_preference;
    const value_t prev_value = value_t();

    ConfigCompatInfo_t() {}

    ConfigCompatInfo_t(CompatClass mode, value_t prev_value)
        : mode(mode), prev_value(prev_value) {}
};

template<class value_t>
struct ConfigEnumValueInfo_t
{
    const value_t m_value;
    bool m_is_translatable = true;
    const char* m_internal_name;
    std::string m_display_name;
    std::string m_display_tooltip;

    ConfigEnumValueInfo_t(const value_t value, const char* internal_name, const char* display_name = "", const char* display_tooltip = "")
        : m_value(value), m_internal_name(internal_name), m_display_name(display_name ? display_name : ""), m_display_tooltip(display_tooltip ? display_tooltip : "") {}

    ConfigEnumValueInfo_t(const value_t value, bool is_translatable, const char* internal_name, const char* display_name = "")
        : m_value(value), m_is_translatable(is_translatable), m_internal_name(internal_name), m_display_name(display_name ? display_name : ""), m_display_tooltip("") {}
};

template<class value_t>
struct ConfigRangeInfo_t
{
    const value_t min;
    const value_t max;
    const value_t step;

    ConfigRangeInfo_t(const value_t min, const value_t max, const value_t step)
        : min(min), max(max), step(step) {}
};

// read-only classes

template<>
class BaseConfigOption_t<false>
{
public:
    const int16_t m_index;
    const uint8_t m_scope;

    const char* m_internal_name;
    std::string m_display_name;
    std::string m_display_tooltip;

    void (*m_onupdate)();
    bool (*m_active)();
    bool (*m_validate)(void*);

    // adds self to the parent's list
    BaseConfigOption_t(_Config_t<false>* parent, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)(), bool (*active)(), bool (*validate)(void*));

    virtual ~BaseConfigOption_t() = default;

    virtual void make_translation(XTechTranslate& translate, const char* cur_section_id);
};

template<class value_t>
class ConfigOption_t<false, value_t> : public BaseConfigOption_t<false>
{
public:
    value_t m_default_value;
    ConfigCompatInfo_t<value_t> m_compat_info;

    ConfigOption_t(_Config_t<false>* parent, const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            BaseConfigOption_t(parent, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate),
            m_default_value(default_value),
            m_compat_info(compat_info) {}
};

template<class value_t>
class ConfigEnumOption_t<false, value_t> : public ConfigOption_t<false, value_t>
{
public:
    using BaseConfigOption_t<false>::m_internal_name;
    using BaseConfigOption_t<false>::m_display_name;
    using BaseConfigOption_t<false>::m_display_tooltip;

    std::vector<ConfigEnumValueInfo_t<value_t>> m_enum_values;

    ConfigEnumOption_t(_Config_t<false>* parent,
        const std::vector<ConfigEnumValueInfo_t<value_t>>& enum_values,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<false, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate),
            m_enum_values(enum_values) {}

    virtual void make_translation(XTechTranslate& translate, const char* cur_section_id) override;
};

template<class value_t>
class ConfigRangeOption_t<false, value_t> : public ConfigOption_t<false, value_t>
{
public:
    using BaseConfigOption_t<false>::m_internal_name;
    using BaseConfigOption_t<false>::m_display_name;
    using BaseConfigOption_t<false>::m_display_tooltip;

    ConfigRangeInfo_t<value_t> m_range_info;

    ConfigRangeOption_t(_Config_t<false>* parent,
        const ConfigRangeInfo_t<value_t>& range_info,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<false, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate),
            m_range_info(range_info) {}
};

template<>
class ConfigLanguage_t<false> : public ConfigOption_t<false, std::string>
{
    using value_t = std::string;

public:
    ConfigLanguage_t(_Config_t<false>* parent,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<false, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate)  {}
};

template<>
class ConfigFullscreenRes_t<false> : public ConfigOption_t<false, std::pair<int, int>>
{
    using value_t = std::pair<int, int>;

public:
    ConfigFullscreenRes_t(_Config_t<false>* parent,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<false, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate)  {}
};

template<>
class ConfigSetupEnum_t<false> : public ConfigEnumOption_t<false, int>
{
    using ConfigEnumOption_t<false, int>::ConfigEnumOption_t;
};

template<>
class ConfigSection_t<false> : public BaseConfigOption_t<false>
{
public:
    ConfigSection_t(_Config_t<false>* parent, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip = nullptr) :
        BaseConfigOption_t<false>(parent, scope,
            internal_name, display_name, display_tooltip,
            nullptr, nullptr, nullptr) {}

    virtual void make_translation(XTechTranslate& translate, const char* cur_section_id) override;
};

template<>
class ConfigSubSection_t<false> : public BaseConfigOption_t<false>
{
public:
    ConfigSubSection_t(_Config_t<false>* parent,
        const char* internal_name, const char* display_name, const char* display_tooltip = nullptr) :
        BaseConfigOption_t<false>(parent, 0xff,
            internal_name, display_name, display_tooltip,
            nullptr, nullptr, nullptr) {}
};

// writable classes

template<>
class BaseConfigOption_t<true>
{
public:
    const BaseConfigOption_t<false>* m_base = nullptr;
    const int16_t m_index;
    ConfigSetLevel m_set = ConfigSetLevel::unset;

    // adds self to the parent's list
    BaseConfigOption_t(_Config_t<true>* parent);

    BaseConfigOption_t(_Config_t<true>* parent, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)(), bool (*active)(), bool (*validate)(void*)) :
            BaseConfigOption_t(parent)
    { (void)scope, (void)internal_name; (void)display_name; (void)display_tooltip; (void)onupdate; (void)active; (void)validate; }

    // returns whether this is a member of g_config or not
    bool is_main() const;

    // executes hooks if appropriate
    void _on_change();

    inline bool is_set() const
    {
        return m_set != ConfigSetLevel::unset;
    }

    virtual bool operator==(const BaseConfigOption_t<true>& o) const { (void)o; return false; }

    inline void unset() { m_set = ConfigSetLevel::unset; }

    virtual bool rotate_left() { return false; }
    virtual bool rotate_right() { return false; }
    virtual bool change() { return rotate_right(); }

    virtual void set_from_default(ConfigSetLevel set_level) { (void)set_level; }
    virtual void update_from_ini(IniProcessing* ini, ConfigSetLevel set_level) { (void)ini; (void)set_level; }

    virtual void disable_bugfixes(ConfigSetLevel set_level) { (void)set_level; }

    virtual void update_from_compat(CompatMode compat_mode, ConfigSetLevel set_level) { (void)compat_mode; (void)set_level; }
    virtual void update_from(const BaseConfigOption_t<true>& o, ConfigSetLevel set_level) { (void)o; (void)set_level; }

    virtual void save_to_ini(IniProcessing* ini) { (void)ini; }

    const std::string& get_display_name(std::string& out) const;
    virtual const std::string& get_display_value(std::string& out) const { out.clear(); return out; }

    const std::string& get_tooltip(std::string& out) const;
    virtual const std::string& get_value_tooltip(std::string& out) const { out.clear(); return out; }
};

template<class value_t>
class ConfigOption_t<true, value_t> : public BaseConfigOption_t<true>
{
public:
    value_t m_value;

    ConfigOption_t(_Config_t<true>* parent, const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            BaseConfigOption_t<true>(parent) { (void)default_value; (void)compat_info; (void)scope; (void)internal_name; (void)display_name; (void)display_tooltip; (void)onupdate; (void)active; (void)validate; }

    virtual bool operator==(const BaseConfigOption_t<true>& o) const override;

    inline operator value_t() const
    {
        return m_value;
    }

    virtual bool rotate_left() override;
    virtual bool rotate_right() override;
    virtual bool change() override;

    const ConfigOption_t<true, value_t>& operator=(value_t value);

    virtual void set_from_default(ConfigSetLevel set_level) override;
    virtual void update_from_ini(IniProcessing* ini, ConfigSetLevel set_level) override;

    virtual void disable_bugfixes(ConfigSetLevel set_level) override;

    virtual void update_from_compat(CompatMode compat_mode, ConfigSetLevel set_level) override;
    virtual void update_from(const BaseConfigOption_t<true>& o, ConfigSetLevel set_level) override;

    virtual void save_to_ini(IniProcessing* ini) override;

    virtual const std::string& get_display_value(std::string& out) const override;
};

template<class value_t>
class ConfigEnumOption_t<true, value_t> : public ConfigOption_t<true, value_t>
{
public:
    using BaseConfigOption_t<true>::is_set;
    using BaseConfigOption_t<true>::m_set;
    using ConfigOption_t<true, value_t>::m_value;
    using BaseConfigOption_t<true>::m_base;
    using ConfigOption_t<true, value_t>::operator=;
    using BaseConfigOption_t<true>::_on_change;

    ConfigEnumOption_t(_Config_t<true>* parent,
        const std::vector<ConfigEnumValueInfo_t<value_t>>& enum_values,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<true, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate) { (void)enum_values; }

    virtual bool rotate_left() override;
    virtual bool rotate_right() override;

    virtual void update_from_ini(IniProcessing* ini, ConfigSetLevel set_level) override;

    virtual void save_to_ini(IniProcessing* ini) override;

    virtual const std::string& get_display_value(std::string& out) const override;
    virtual const std::string& get_value_tooltip(std::string& out) const override;
};

template<class value_t>
class ConfigRangeOption_t<true, value_t> : public ConfigOption_t<true, value_t>
{
public:
    using BaseConfigOption_t<true>::is_set;
    using BaseConfigOption_t<true>::m_set;
    using ConfigOption_t<true, value_t>::m_value;
    using BaseConfigOption_t<true>::m_base;
    using ConfigOption_t<true, value_t>::operator=;
    using BaseConfigOption_t<true>::_on_change;

    ConfigRangeOption_t(_Config_t<true>* parent,
        const ConfigRangeInfo_t<value_t>& range_info,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<true, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate) { (void)range_info; }

    virtual bool rotate_left() override;
    virtual bool rotate_right() override;
};

template<>
class ConfigLanguage_t<true> : public ConfigOption_t<true, std::string>
{
    using value_t = std::string;

public:
    using BaseConfigOption_t<true>::m_set;
    using BaseConfigOption_t<true>::m_base;
    using ConfigOption_t<true, value_t>::operator=;

    ConfigLanguage_t(_Config_t<true>* parent,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<true, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate) {}

    virtual bool rotate_left() override;
    virtual bool rotate_right() override;
    virtual bool change() override;

    virtual const std::string& get_display_value(std::string& out) const override;
};

#ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED
template<>
class ConfigFullscreenRes_t<true> : public ConfigOption_t<true, std::pair<int, int>>
{
    using value_t = std::pair<int, int>;

public:
    using BaseConfigOption_t<true>::m_set;
    using BaseConfigOption_t<true>::m_base;
    using ConfigOption_t<true, value_t>::operator=;

    ConfigFullscreenRes_t(_Config_t<true>* parent,
        const value_t default_value,
        const ConfigCompatInfo_t<value_t>& compat_info, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip,
        void (*onupdate)() = nullptr, bool (*active)() = nullptr, bool (*validate)(void*) = nullptr) :
            ConfigOption_t<true, value_t>(parent, default_value, compat_info, scope,
                internal_name, display_name, display_tooltip,
                onupdate, active, validate) {}

    size_t find_cur_index();

    virtual bool rotate_left() override;
    virtual bool rotate_right() override;
    virtual bool change() override;
};
#endif // RENDER_FULLSCREEN_TYPES_SUPPORTED

template<>
class ConfigSetupEnum_t<true> : public ConfigEnumOption_t<true, int>
{
public:
    using ConfigEnumOption_t<true, int>::ConfigEnumOption_t;
    using ConfigEnumOption_t<true, int>::operator=;

    virtual const std::string& get_display_value(std::string& out) const override;

    int obtained = -1;
};

template<>
class ConfigSection_t<true> : public BaseConfigOption_t<true>
{
public:
    const ConfigSection_t<false>* m_base = nullptr;

    ConfigSection_t(_Config_t<true>* parent, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip = nullptr);

    virtual void update_from_ini(IniProcessing* ini, ConfigSetLevel set_level) override;
    virtual void save_to_ini(IniProcessing* ini) override { update_from_ini(ini, ConfigSetLevel::unset); };
};

template<>
class ConfigSubSection_t<true> : public BaseConfigOption_t<true>
{
public:
    const ConfigSubSection_t<false>* m_base = nullptr;

    ConfigSubSection_t(_Config_t<true>* parent,
        const char* internal_name, const char* display_name, const char* display_tooltip = nullptr);
};

#endif // CONFIG_BASE_HPP


================================================
FILE: src/config/config_hooks.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>
#include <Logger/private/logger_sets.h>

#include "core/msgbox.h"
#include "core/events.h"
#ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED
#   include "core/window.h"
#endif

#include "config.h"
#include "config/config_hooks.h"

#include "main/translate.h"
#include "main/menu_main.h"
#include "main/screen_options.h"

#include "message.h"
#include "frm_main.h"
#include "change_res.h"
#include "globals.h"
#include "game_main.h"
#include "sound.h"
#include "graphics.h"
#include "player.h"

#include "Integrator/integrator.h"

#ifndef THEXTECH_NO_SDL_BUILD
#include <Graphics/graphics_funcs.h>
#endif

#ifdef __3DS__
#include "core/render.h"
#include "main/cheat_code.h"
#endif


// config_main.cpp
extern bool g_configInTransaction;

void config_res_set()
{
    g_VanillaCam = false;
    if(GameIsActive && (GameMenu || GamePaused == PauseCode::Options || g_config.internal_res.m_set == ConfigSetLevel::cheat))
        UpdateWindowRes();
    UpdateInternalRes();
}

void config_rendermode_set()
{
    if(!GameIsActive)
        return;

    bool res = g_frmMain.restartRenderer();

    if(res)
        PlaySoundMenu(SFX_PSwitch);
}

void config_fullscreen_set()
{
    if(!GameIsActive)
        return;

    if(g_config.fullscreen)
        ChangeRes(0, 0, 0, 0);
    else
        SetOrigRes();

    XEvents::doEvents();
}

#ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED
void config_video_mode_set()
{
    if(!GameIsActive)
        return;

    AbstractWindow_t::VideoModeRes res;
    uint8_t depth;
    res.w = g_config.fullscreen_res.m_value.first;
    res.h = g_config.fullscreen_res.m_value.second;

    XWindow::setVideoMode(res, g_config.fullscreen_depth);

    XWindow::getCurrentVideoMode(res, depth);
    g_config.fullscreen_depth.obtained = depth;
}

void config_fullscreen_type_set()
{
    if(!GameIsActive)
        return;

    XWindow::setFullScreenType(g_config.fullscreen_type);
}
#endif // RENDER_FULLSCREEN_TYPES_SUPPORTED

void config_mountdrums_set()
{
    if(!GameIsActive)
        return;

    UpdateYoshiMusic();
}

void config_screenmode_set()
{
    XMessage::PushMessage({XMessage::Type::multiplayer_prefs, (uint8_t)g_config.two_screen_mode.m_value, (uint8_t)g_config.four_screen_mode.m_value});
}

void config_audiofx_set()
{
    if(!GameIsActive)
        return;

    if(!LevelSelect && !LevelEditor)
        UpdateSoundFX(Player[1].Section);
}

void config_audio_set()
{
    if(!GameIsActive)
        return;

    RestartMixerX();

    if(GameMenu || !LevelSelect)
        UpdateSoundFX(Player[1].Section);
}

void config_music_volume_set()
{
    if(!GameIsActive)
        return;

    UpdateMusicVolume();
}

void config_language_set()
{
    if(!GameIsActive)
        return;

    ReloadTranslations();

    OptionsScreen::ResetStrings();
}

void config_log_level_set()
{
    g_pLogGlobalSetup.level = (PGE_LogLevel::Level)(int)g_config.log_level;
    LogWriter::m_logLevel = g_pLogGlobalSetup.level;
    pLogInfo("Updated log level to %d", (int)g_config.log_level);
}

void config_integrations_set()
{
    Integrator::quitIntegrations();
    Integrator::initIntegrations();
}

#ifdef __3DS__
void config_3ds_inaccurate_gifs_set()
{
    if(g_ForceBitmaskMerge == g_config.inaccurate_gifs)
        return;

    g_ForceBitmaskMerge = g_config.inaccurate_gifs;
    XRender::unloadGifTextures();
}
#endif

void config_compat_changed()
{
    if(!g_configInTransaction)
        UpdateConfig();
}



================================================
FILE: src/config/config_hooks.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CONFIG_HOOKS_H
#define CONFIG_HOOKS_H

void config_res_set();
void config_asset_pack_set();
void config_language_set();
void config_rendermode_set();
void config_fullscreen_set();
#ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED
void config_video_mode_set();
void config_fullscreen_type_set();
#endif
void config_mountdrums_set();
void config_screenmode_set();
void config_audiofx_set();
void config_audio_set();
void config_music_volume_set();
void config_log_level_set();
void config_integrations_set();
void config_3ds_inaccurate_gifs_set();
void config_compat_changed();

#endif


================================================
FILE: src/config/config_impl.hpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

// included in config_main.cpp

#pragma once
#ifndef CONFIG_IMPL_HPP
#define CONFIG_IMPL_HPP

#include <set>

#include <fmt_format_ne.h>
#include <IniProcessor/ini_processing.h>

#include "config/config_base.hpp"
#include "main/screen_textentry.h"
#include "game_main.h"

#include "core/language.h"
#include "core/window.h"
#include "fontman/font_manager.h"

#include "main/translate.h"
#include "main/menu_main.h"

// config_base.cpp
extern ConfigSetLevel g_configWriteLevel;

// config_main.cpp
extern bool g_configInTransaction;
extern std::set<BaseConfigOption_t<true>*> g_configModified;

// implementation for ConfigOption_t<true, value_t>

template<class value_t>
bool ConfigOption_t<true, value_t>::operator==(const BaseConfigOption_t<true>& o) const
{
    const ConfigOption_t<true, value_t>* other = dynamic_cast<const ConfigOption_t<true, value_t>*>(&o);

    if(!other)
        return false;

    if(!is_set() || !other->is_set())
        return false;

    return this->m_value == other->m_value;
}

template<class value_t>
bool ConfigOption_t<true, value_t>::rotate_left()
{
    return BaseConfigOption_t<true>::rotate_left();
}

template<class value_t>
bool ConfigOption_t<true, value_t>::rotate_right()
{
    return BaseConfigOption_t<true>::rotate_right();
}

template<class value_t>
bool ConfigOption_t<true, value_t>::change()
{
    return BaseConfigOption_t<true>::change();
}

template<class value_t>
const ConfigOption_t<true, value_t>& ConfigOption_t<true, value_t>::operator=(value_t value)
{
    if(g_configWriteLevel < m_set)
        return *this;

    m_set = g_configWriteLevel;

    if(m_value != value)
    {
        m_value = value;
        _on_change();
    }

    return *this;
}

// force the compiler to instantiate these
template const ConfigOption_t<true, bool>& ConfigOption_t<true, bool>::operator=(bool value);
template const ConfigOption_t<true, int>& ConfigOption_t<true, int>::operator=(int value);
template const ConfigOption_t<true, std::pair<int, int>>& ConfigOption_t<true, std::pair<int, int>>::operator=(std::pair<int, int> value);
template const ConfigOption_t<true, std::string>& ConfigOption_t<true, std::string>::operator=(std::string value);

template<class value_t>
void ConfigOption_t<true, value_t>::set_from_default(ConfigSetLevel level)
{
    if(level < m_set)
        return;

    if(!m_base)
        return;

    const ConfigOption_t<false, value_t>* base = dynamic_cast<const ConfigOption_t<false, value_t>*>(m_base);

    if(!base)
        return;

    *this = base->m_default_value;

    m_set = level;
}

template<class value_t>
void ConfigOption_t<true, value_t>::disable_bugfixes(ConfigSetLevel level)
{
    if(level < m_set)
        return;

    if(!m_base)
        return;

    const ConfigOption_t<false, value_t>* base = dynamic_cast<const ConfigOption_t<false, value_t>*>(m_base);

    if(!base)
        return;

    if(g_config.playstyle == Config_t::MODE_MODERN)
        return;

    if(base->m_compat_info.mode == CompatClass::pure_preference)
        return;

    if(g_config.playstyle != Config_t::MODE_VANILLA && base->m_compat_info.mode == CompatClass::critical_update)
        return;

    *this = base->m_compat_info.prev_value;

    m_set = level;
}

template<class value_t>
void ConfigOption_t<true, value_t>::update_from_ini(IniProcessing* ini, ConfigSetLevel level)
{
    if(level < m_set)
        return;

    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    if(!ini->hasKey(m_base->m_internal_name))
        return;

    value_t read_value{};
    ini->read(m_base->m_internal_name, read_value, read_value);

    *this = read_value;
    m_set = level;
}

template<class value_t>
void ConfigOption_t<true, value_t>::update_from_compat(CompatMode compat_mode, ConfigSetLevel level)
{
    if(level < m_set)
        return;

    if(!m_base)
        return;

    const ConfigOption_t<false, value_t>* base = dynamic_cast<const ConfigOption_t<false, value_t>*>(m_base);

    if(!base)
        return;

    if(base->m_compat_info.mode == CompatClass::pure_preference)
        return;

    bool use_modern = (base->m_compat_info.mode == CompatClass::critical_update && compat_mode < CompatMode::smbx64)
        || (base->m_compat_info.mode == CompatClass::standard_update && compat_mode < CompatMode::classic);

    if(use_modern)
        *this = base->m_default_value;
    else
        *this = base->m_compat_info.prev_value;

    m_set = level;
}

template<class value_t>
void ConfigOption_t<true, value_t>::update_from(const BaseConfigOption_t<true>& o, ConfigSetLevel level)
{
    if(level < m_set)
        return;

    const ConfigOption_t<true, value_t>* o_conv = dynamic_cast<const ConfigOption_t<true, value_t>*>(&o);

    if(!o_conv)
        return;

    if(!o_conv->is_set())
        return;

    *this = (value_t)*o_conv;
    m_set = level;
}

template<class value_t>
void ConfigOption_t<true, value_t>::save_to_ini(IniProcessing* ini)
{
    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    if(is_set())
        ini->setValue(m_base->m_internal_name, m_value);
    else
        ini->clearValue(m_base->m_internal_name);
}

template<class value_t>
const std::string& ConfigOption_t<true, value_t>::get_display_value(std::string& out) const
{
    out = std::to_string(m_value);
    return out;
}

// specializer for strings
template<>
bool ConfigOption_t<true, std::string>::change()
{
    if(!m_base)
        return false;

    m_value = TextEntryScreen::Run(m_base->m_display_name, m_value);

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}


template<>
const std::string& ConfigOption_t<true, std::string>::get_display_value(std::string& out) const
{
    if(m_value.empty())
        return (out = "<NONE>");

    out = m_value;
    return out;
}

// specializer for resolution
template<>
const std::string& ConfigOption_t<true, std::pair<int, int>>::get_display_value(std::string& out) const
{
    out = fmt::sprintf_ne("%dx%d", m_value.first, m_value.second);
    return out;
}

template<>
void ConfigOption_t<true, std::pair<int, int>>::update_from_ini(IniProcessing* ini, ConfigSetLevel level)
{
    if(level < m_set)
        return;

    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    if(!ini->hasKey(m_base->m_internal_name))
        return;

    std::string read_value;
    ini->read(m_base->m_internal_name, read_value, read_value);

    int arg1, h;
    int argcount = sscanf(read_value.c_str(), "%dx%d", &arg1, &h);

    if(argcount < 1)
        return;

    if(argcount == 2)
        *this = {arg1, h};
    else
        *this = {0, arg1};

    m_set = level;
}

template<>
void ConfigOption_t<true, std::pair<int, int>>::save_to_ini(IniProcessing* ini)
{
    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    if(is_set())
    {
        std::string out = fmt::sprintf_ne("%dx%d", m_value.first, m_value.second);
        ini->setValue(m_base->m_internal_name, out);
    }
    else
        ini->clearValue(m_base->m_internal_name);
}

// specializer for the bitblit triple
template<>
const std::string& ConfigOption_t<true, std::array<uint8_t, 3>>::get_display_value(std::string& out) const
{
    out = fmt::sprintf_ne("%u,%u,%u", (unsigned)m_value[0], (unsigned)m_value[1], (unsigned)m_value[2]);
    return out;
}

template<>
void ConfigOption_t<true, std::array<uint8_t, 3>>::update_from_ini(IniProcessing* ini, ConfigSetLevel level)
{
    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    if(!ini->hasKey(m_base->m_internal_name))
        return;

    *this = {0, 0, 0};

    m_set = level;
}

template<>
void ConfigOption_t<true, std::array<uint8_t, 3>>::save_to_ini(IniProcessing* ini)
{
    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    if(is_set())
    {
        ini->setValue(m_base->m_internal_name, "unimplemented");
    }
    else
        ini->clearValue(m_base->m_internal_name);
}

// specialized implementation for ConfigOption_t<true, bool>

template<>
bool ConfigOption_t<true, bool>::rotate_left()
{
    m_value = !m_value;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

template<>
bool ConfigOption_t<true, bool>::rotate_right()
{
    return rotate_left();
}

template<>
const std::string& ConfigOption_t<true, bool>::get_display_value(std::string& out) const
{
    if(FontManager::hasTtfSupport())
        out = m_value ? "✓" : "×";
    else
        out = m_value ? "+" : "-";

    return out;
}


// implementation for ConfigEnumOption_t<false, value_t>

template<class value_t>
void ConfigEnumOption_t<false, value_t>::make_translation(XTechTranslate& translate, const char* cur_section_id)
{
    if((ConfigOption_t<false, value_t>::m_scope & Options_t::Scope::MakeTranslation) == 0)
        return;

    XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s.%s._name", cur_section_id, m_internal_name), &m_display_name);

    // some obscure behavior of the GCC version in Ubuntu 16.04 necessitates qualifying m_display_tooltip with the base class scope
    if(!BaseConfigOption_t<false>::m_display_tooltip.empty())
        XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s.%s._tooltip", cur_section_id, m_internal_name), &m_display_tooltip);

    for(auto& value : m_enum_values)
    {
        if(!value.m_is_translatable)
            continue;

        if(!value.m_display_name.empty())
            XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s.%s.%s", cur_section_id, m_internal_name, value.m_internal_name), &value.m_display_name);

        if(!value.m_display_tooltip.empty())
            XTechTranslate::insert(translate.m_engineMap, fmt::sprintf_ne("menu.options.%s.%s.%s-tip", cur_section_id, m_internal_name, value.m_internal_name), &value.m_display_tooltip);
    }
}


// implementation for ConfigEnumOption_t<true, value_t>

template<class value_t>
void ConfigEnumOption_t<true, value_t>::update_from_ini(IniProcessing* ini, ConfigSetLevel level)
{
    if(level < m_set)
        return;

    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    const ConfigEnumOption_t<false, value_t>* base = dynamic_cast<const ConfigEnumOption_t<false, value_t>*>(m_base);

    if(!base)
        return;

    if(!ini->hasKey(base->m_internal_name))
        return;

    std::string key_name;
    ini->read(base->m_internal_name, key_name, key_name);

    for(const ConfigEnumValueInfo_t<value_t>& val : base->m_enum_values)
    {
        if(!strcmp(key_name.c_str(), val.m_internal_name))
        {
            ConfigOption_t<true, value_t>::operator=(val.m_value);
            m_set = level;
            return;
        }
    }

    ConfigOption_t<true, value_t>::operator=(base->m_default_value);
    m_set = level;
}

template<class value_t>
void ConfigEnumOption_t<true, value_t>::save_to_ini(IniProcessing* ini)
{
    if(!ini || !m_base || !m_base->m_internal_name)
        return;

    if(!is_set())
    {
        ini->clearValue(m_base->m_internal_name);
        return;
    }

    const ConfigEnumOption_t<false, value_t>* base = dynamic_cast<const ConfigEnumOption_t<false, value_t>*>(m_base);

    if(!base)
        return;

    for(const ConfigEnumValueInfo_t<value_t>& val : base->m_enum_values)
    {
        if((value_t)*this == val.m_value)
        {
            ini->setValue(base->m_internal_name, val.m_internal_name);
            return;
        }
    }

    ConfigOption_t<true, value_t>::save_to_ini(ini);
}

template<class value_t>
bool ConfigEnumOption_t<true, value_t>::rotate_left()
{
    const ConfigEnumOption_t<false, value_t>* base = dynamic_cast<const ConfigEnumOption_t<false, value_t>*>(m_base);

    if(!base || base->m_enum_values.size() > 255)
        return false;

    uint8_t found_i = 0;

    for(uint8_t i = 0; i < base->m_enum_values.size(); i++)
    {
        if((value_t)*this == base->m_enum_values[i].m_value)
        {
            found_i = i;
            break;
        }
    }

    uint8_t current_i = found_i;

    // loop until we find one with a display name -> not an alias
    do
    {
        if(current_i == 0)
            current_i = base->m_enum_values.size();

        current_i--;
    }
    while(base->m_enum_values[current_i].m_display_name.empty() && current_i != found_i);

    // possibly misconfigured
    if(current_i == found_i)
    {
        pLogDebug("Cycled through enum option [%s] without finding new value", base->m_display_name.c_str());
        return false;
    }

    m_value = base->m_enum_values[current_i].m_value;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

template<class value_t>
bool ConfigEnumOption_t<true, value_t>::rotate_right()
{
    const ConfigEnumOption_t<false, value_t>* base = dynamic_cast<const ConfigEnumOption_t<false, value_t>*>(m_base);

    if(!base || base->m_enum_values.size() > 255)
        return false;

    uint8_t found_i = 0;

    for(uint8_t i = 0; i < base->m_enum_values.size(); i++)
    {
        if((value_t)*this == base->m_enum_values[i].m_value)
        {
            found_i = i;
            break;
        }
    }

    uint8_t current_i = found_i;

    // loop until we find one with a display name -> not an alias
    do
    {
        current_i++;

        if(current_i == base->m_enum_values.size())
            current_i = 0;
    }
    while(base->m_enum_values[current_i].m_display_name.empty() && current_i != found_i);

    // possibly misconfigured
    if(current_i == found_i)
    {
        pLogDebug("Cycled through enum option [%s] without finding new value", base->m_display_name.c_str());
        return false;
    }

    m_value = base->m_enum_values[current_i].m_value;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

template<class value_t>
const std::string& ConfigEnumOption_t<true, value_t>::get_display_value(std::string& out) const
{
    const ConfigEnumOption_t<false, value_t>* base = dynamic_cast<const ConfigEnumOption_t<false, value_t>*>(m_base);

    if(!base)
        return out = "INVALID";

    bool found = false;

    for(const ConfigEnumValueInfo_t<value_t>& val : base->m_enum_values)
    {
        if((value_t)*this == val.m_value)
        {
            if(!val.m_display_name.empty())
                out = val.m_display_name;
            else if(val.m_internal_name)
                out = val.m_internal_name;
            else
                continue;

            found = true;
            break;
        }
    }

    if(!found)
        ConfigOption_t<true, value_t>::get_display_value(out);

    return out;
}

template<class value_t>
const std::string& ConfigEnumOption_t<true, value_t>::get_value_tooltip(std::string& out) const
{
    const ConfigEnumOption_t<false, value_t>* base = dynamic_cast<const ConfigEnumOption_t<false, value_t>*>(m_base);

    if(!base)
        return out = "";

    for(const ConfigEnumValueInfo_t<value_t>& val : base->m_enum_values)
    {
        if((value_t)*this == val.m_value)
        {
            if(!val.m_display_tooltip.empty())
                return out = val.m_display_tooltip;
            else
                return out = "";
        }
    }

    return out = "";
}


// implementation for ConfigRangeOption_t<true, value_t>

template<class value_t>
bool ConfigRangeOption_t<true, value_t>::rotate_left()
{
    const ConfigRangeOption_t<false, value_t>* base = dynamic_cast<const ConfigRangeOption_t<false, value_t>*>(m_base);

    if(!base)
        return false;

    m_value -= base->m_range_info.step;
    if(m_value < base->m_range_info.min)
        m_value = base->m_range_info.max;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

template<class value_t>
bool ConfigRangeOption_t<true, value_t>::rotate_right()
{
    const ConfigRangeOption_t<false, value_t>* base = dynamic_cast<const ConfigRangeOption_t<false, value_t>*>(m_base);

    if(!base)
        return false;

    m_value += base->m_range_info.step;
    if(m_value > base->m_range_info.max)
        m_value = base->m_range_info.min;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}


// implementation for ConfigLanguage_t<true>

bool ConfigLanguage_t<true>::rotate_left()
{
    std::string old_value = m_value;
    XLanguage::rotateLanguage(m_value, -1);

    if(m_value == old_value)
        return false;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

bool ConfigLanguage_t<true>::rotate_right()
{
    std::string old_value = m_value;
    XLanguage::rotateLanguage(m_value, 1);

    if(m_value == old_value)
        return false;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

bool ConfigLanguage_t<true>::change()
{
    return rotate_right();
}

const std::string& ConfigLanguage_t<true>::get_display_value(std::string& out) const
{
    out = g_mainMenu.languageName;
    out += " (";
    out += m_value;
    out += ")";

    return out;
}


// implementation for ConfigFullscreenRes_t<true>
#ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED

size_t ConfigFullscreenRes_t<true>::find_cur_index()
{
    const std::vector<AbstractWindow_t::VideoModeRes>& res = g_window->getAvailableVideoResolutions();

    for(size_t i = 0; i < res.size(); i++)
    {
        if(res[i].w == m_value.first && res[i].h == m_value.second)
            return i;
    }

    return res.size();
}

bool ConfigFullscreenRes_t<true>::rotate_left()
{
    const std::vector<AbstractWindow_t::VideoModeRes>& res = g_window->getAvailableVideoResolutions();

    value_t old_value = m_value;

    if(res.size() == 0)
        return false;

    size_t new_idx = find_cur_index() - 1;
    if(new_idx >= res.size())
        new_idx = res.size() - 1;

    m_value.first = res[new_idx].w;
    m_value.second = res[new_idx].h;

    if(m_value == old_value)
        return false;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

bool ConfigFullscreenRes_t<true>::rotate_right()
{
    const std::vector<AbstractWindow_t::VideoModeRes>& res = g_window->getAvailableVideoResolutions();

    value_t old_value = m_value;

    if(res.size() == 0)
        return false;

    size_t new_idx = find_cur_index() + 1;
    if(new_idx >= res.size())
        new_idx = 0;

    m_value.first = res[new_idx].w;
    m_value.second = res[new_idx].h;

    if(m_value == old_value)
        return false;

    if(!is_set())
        m_set = ConfigSetLevel::set;

    _on_change();

    return true;
}

bool ConfigFullscreenRes_t<true>::change()
{
    return rotate_right();
}

#endif // #ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED


// implementation for ConfigSetupEnum_t<true>
const std::string& ConfigSetupEnum_t<true>::get_display_value(std::string& out) const
{
    ConfigEnumOption_t<true, int>::get_display_value(out);

#ifndef RENDER_CUSTOM
    const ConfigEnumOption_t<false, int>* base = dynamic_cast<const ConfigEnumOption_t<false, int>*>(m_base);

    // special case for "auto" values (always 0)
    if(base && m_value == 0 && obtained > 0)
    {
        out += " (";

        for(const ConfigEnumValueInfo_t<int>& val : base->m_enum_values)
        {
            if(obtained == val.m_value)
            {
                if(!val.m_display_name.empty())
                    out += val.m_display_name;
                else if(val.m_internal_name)
                    out += val.m_internal_name;
                else
                    continue;

                break;
            }
        }

        out += ")";
    }
#endif

    return out;
}


// implementation for ConfigEnumOption_t<true, value_t>

// implementation for ConfigSection_t<true>

ConfigSection_t<true>::ConfigSection_t(_Config_t<true>* parent, uint8_t scope,
        const char* internal_name, const char* display_name, const char* display_tooltip) :
        BaseConfigOption_t<true>(parent)
{
    (void)internal_name; (void)display_name; (void)display_tooltip; (void)scope;

    if(!parent->m_base)
        return;
    if((size_t)m_index >= parent->m_base->m_options.size())
        return;
    m_base = dynamic_cast<ConfigSection_t<false>*>(parent->m_base->m_options[m_index]);
}

void ConfigSection_t<true>::update_from_ini(IniProcessing* ini, ConfigSetLevel level)
{
    (void)level;

    if(!ini || !m_base)
        return;

    ini->endGroup();
    ini->beginGroup(m_base->m_internal_name);
}

// implementation for ConfigSubSection_t<true>

ConfigSubSection_t<true>::ConfigSubSection_t(_Config_t<true>* parent,
        const char* internal_name, const char* display_name, const char* display_tooltip) :
        BaseConfigOption_t(parent)
{
    (void)internal_name; (void)display_name; (void)display_tooltip;

    if(!parent->m_base)
        return;
    if((size_t)m_index >= parent->m_base->m_options.size())
        return;
    m_base = dynamic_cast<ConfigSubSection_t<false>*>(parent->m_base->m_options[m_index]);
}

#endif // #CONFIG_IMPL_HPP


================================================
FILE: src/config/config_legacy_compat.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <IniProcessor/ini_processing.h>
#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "globals.h"
#include "config.h"

#include "main/menu_main.h"
#include "main/screen_prompt.h"

template<>
void Config_t::LoadLegacyCompat(IniProcessing* ini, ConfigSetLevel level)
{
    ini->beginGroup("compatibility");
    {
        std::string buffer;
        if(ini->hasKey("enable-last-warp-hub-resume"))
        {
            ini->read("enable-last-warp-hub-resume", enable_last_warp_hub_resume.m_value, true);
            enable_last_warp_hub_resume.m_set = level;
        }
    }
    ini->endGroup();

    if(!ini->beginGroup("fails-counter"))
    {
        ini->beginGroup("death-counter"); // Backup fallback
    }
    {
        std::string buffer;
        if(ini->hasKey("enabled"))
        {
            ini->read("enabled", enable_fails_tracking.m_value, true);
            enable_fails_tracking.m_set = level;
        }

        // note: title attribute has been removed, now belongs to gameinfo.ini only.
    }
    ini->endGroup();

    ini->beginGroup("luna-script");
    {
        std::string enable_luna_value;
        ini->read("enable-engine", enable_luna_value, "unspecified");
        if(enable_luna_value != "unspecified")
        {
            luna_enable_engine = (enable_luna_value == "enable" || enable_luna_value == "true");
            luna_enable_engine.m_set = level;
        }

        if(ini->hasKey("allow-level-codes"))
        {
            ini->read("allow-level-codes", luna_allow_level_codes.m_value, false);
            luna_allow_level_codes.m_set = level;
        }
    }
    ini->endGroup();
}


================================================
FILE: src/config/config_main.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <PGE_File_Formats/file_formats.h>
#include <IniProcessor/ini_processing.h>
#include <Utils/files_ini.h>
#include <fmt_format_ne.h>

#include "config.h"
#include "message.h"
#include "config/config_impl.hpp"
#include "main/game_info.h"
#include "globals.h"
#include "global_dirs.h"
#include "main/menu_main.h"
#include "sound.h"

static int s_backup_bugfixes = Config_t::MODE_MODERN;
static int s_backup_creator_compat = Config_t::CREATORCOMPAT_ENABLE;

template<>
void Config_t::Clear()
{
    // only update backup variables for main config class
    if(this == &g_config)
    {
        if(playstyle.m_set == ConfigSetLevel::ep_config)
            s_backup_bugfixes = playstyle;

        if(GameMenu)
            s_backup_creator_compat = Config_t::CREATORCOMPAT_ENABLE;
        else
        {
            if(creator_compat.m_set == ConfigSetLevel::ep_config)
                s_backup_creator_compat = creator_compat;
        }
    }

    for(BaseConfigOption_t<true>* option : m_options)
    {
        // allow speedrun mode to be kept throughout a menu quit
        if(option == &speedrun_mode)
            continue;

        switch(option->m_set)
        {
        case ConfigSetLevel::cmdline:
        case ConfigSetLevel::debug:
            // allow these levels to always be kept
            break;
        case ConfigSetLevel::ep_config:
        case ConfigSetLevel::cheat:
            // allow these levels to be kept for the duration of a run
            if(!GameMenu)
                break;
            // fallthrough
        default:
            option->unset();
        }
    }

    // restore episode config
    playstyle.m_value = s_backup_bugfixes;
    playstyle.m_set = ConfigSetLevel::ep_config;

    creator_compat.m_value = s_backup_creator_compat;
    creator_compat.m_set = ConfigSetLevel::ep_config;
}

template<>
void Config_t::UpdateFromIni(IniProcessing* ini, ConfigSetLevel level)
{
    for(BaseConfigOption_t<true>* option : m_options)
        option->update_from_ini(ini, level);
}

template<>
void Config_t::SaveToIni(IniProcessing* ini)
{
    for(BaseConfigOption_t<true>* option : m_options)
        option->save_to_ini(ini);
}

template<>
void Config_t::SaveEpisodeConfig(saveUserData& userdata)
{
    saveUserData::DataSection ep_config;
    ep_config.name = "_xt_ep_conf";
    ep_config.location = saveUserData::DATA_GLOBAL;

    if(speedrun_mode.m_set >= ConfigSetLevel::ep_config)
        ep_config.data.emplace_back(saveUserData::DataEntry{"speedrun-mode", std::to_string(speedrun_mode.m_value)});

    int playstyle_value = (playstyle.m_set == ConfigSetLevel::ep_config) ? playstyle : s_backup_bugfixes;
    ep_config.data.emplace_back(saveUserData::DataEntry{"playstyle", (playstyle_value == MODE_VANILLA) ? "vanilla" : ((playstyle_value == MODE_CLASSIC) ? "classic" : "modern")});

    int creator_compat_value = (creator_compat.m_set == ConfigSetLevel::ep_config) ? creator_compat : s_backup_creator_compat;
    ep_config.data.emplace_back(saveUserData::DataEntry{"creator-compat", (creator_compat_value == CREATORCOMPAT_DISABLE) ? "disable" : ((creator_compat_value == CREATORCOMPAT_FILEONLY) ? "file-only" : "enable")});

    if(enable_last_warp_hub_resume.m_set == ConfigSetLevel::ep_config)
        ep_config.data.emplace_back(saveUserData::DataEntry{"hub-resume", (enable_last_warp_hub_resume.m_value) ? "on" : "off"});

    userdata.store.push_back(ep_config);
}

template<>
void Config_t::LoadEpisodeConfig(const saveUserData& userdata)
{
    for(const auto& section : userdata.store)
    {
        if(section.name != "_xt_ep_conf" || section.location != saveUserData::DATA_GLOBAL)
            continue;

        for(const auto& entry : section.data)
        {
            if(entry.key == "speedrun-mode")
            {
                if(speedrun_mode.m_set <= ConfigSetLevel::ep_config)
                {
                    speedrun_mode.m_value = std::atoi(entry.value.c_str());
                    if(speedrun_mode.m_value < 0 || speedrun_mode.m_value > 4)
                        speedrun_mode.m_value = 0;

                    speedrun_mode.m_set = ConfigSetLevel::ep_config;
                }
            }
            else if(entry.key == "playstyle")
            {
                if(entry.value == "vanilla")
                    playstyle.m_value = MODE_VANILLA;
                else if(entry.value == "classic")
                    playstyle.m_value = MODE_CLASSIC;
                else
                    playstyle.m_value = MODE_MODERN;

                playstyle.m_set = ConfigSetLevel::ep_config;
            }
            else if(entry.key == "creator-compat")
            {
                if(entry.value == "disable")
                    creator_compat.m_value = CREATORCOMPAT_DISABLE;
                else if(entry.value == "file-only")
                    creator_compat.m_value = CREATORCOMPAT_FILEONLY;
                else
                    creator_compat.m_value = CREATORCOMPAT_ENABLE;

                creator_compat.m_set = ConfigSetLevel::ep_config;
            }
            else if(entry.key == "hub-resume")
            {
                if(entry.value == "off")
                    enable_last_warp_hub_resume.m_value = false;
                else
                    enable_last_warp_hub_resume.m_value = true;

                enable_last_warp_hub_resume.m_set = ConfigSetLevel::ep_config;
            }
        }

        break;
    }
}

template<>
void Config_t::SetFromDefaults(ConfigSetLevel level)
{
    for(BaseConfigOption_t<true>* option : m_options)
        option->set_from_default(level);
}

template<>
void Config_t::DisableBugfixes(ConfigSetLevel level)
{
    for(BaseConfigOption_t<true>* option : m_options)
        option->disable_bugfixes(level);
}

template<>
void Config_t::UpdateFrom(const Config_t& o, ConfigSetLevel level)
{
    size_t i = 0;
    for(BaseConfigOption_t<true>* option : m_options)
    {
        if(i >= o.m_options.size())
            break;

        if(m_base->m_options[i] && (m_base->m_options[i]->m_scope & o.m_scope) && o.m_options[i])
            option->update_from(*o.m_options[i], level);

        i++;
    }
}

template<>
void Config_t::UpdateFromCompat(CompatMode compat_mode, ConfigSetLevel level)
{
    for(BaseConfigOption_t<true>* option : m_options)
        option->update_from_compat(compat_mode, level);
}

template<>
void Options_t::reset_options()
{
    // invoke destructor
    this->~Options_t();

    // invoke constructor
    new(this) Options_t();
}

template<>
void Options_t::make_translation(XTechTranslate& translate)
{
    const char* cur_section_id = "";

    for(BaseConfigOption_t<false>* option : m_options)
    {
        bool is_section = dynamic_cast<ConfigSection_t<false>*>(option);

        // switch to the section's header
        if(is_section)
            cur_section_id = option->m_internal_name;

        option->make_translation(translate, cur_section_id);
    }
}

static void s_GameInfoActivitySetup(IniProcessing& ini)
{
    if(ini.contains("activity-setup") && (GameOutro || GameMenu))
    {
        if(!g_gameInfo.activity_settings_in_compat)
        {
            g_gameInfo.ResetIntroActivitySettings();
            g_gameInfo.ResetOutroActivitySettings();
            g_gameInfo.activity_settings_in_compat = true;
        }

        ini.beginGroup("activity-setup");

        if(GameOutro)
            g_gameInfo.LoadOutroActivitySettings(ini);
        else if(GameMenu)
            g_gameInfo.LoadIntroActivitySettings(ini);

        ini.endGroup();
    }
}

void LoadCustomConfig()
{
    std::string episodeCompat, customCompat, episodeConfig, customConfig, userEpConfig;

    g_dirEpisode.setCurDir(FileNamePath);
    g_dirCustom.setCurDir(FileNamePath + FileName);

    g_config_episode_creator.Clear();
    g_config_file_creator.Clear();

    // Episode-wide custom creator setup
    episodeCompat = g_dirEpisode.resolveFileCaseExistsAbs("compat.ini");
    // Level-wide custom creator setup
    customCompat = g_dirCustom.resolveFileCaseExistsAbs("compat.ini");

    if(g_gameInfo.activity_settings_in_compat)
    {
        g_gameInfo.ResetIntroActivitySettings();
        g_gameInfo.ResetOutroActivitySettings();
    }

    if(!episodeCompat.empty())
    {
        IniProcessing ini = Files::load_ini(episodeCompat);
        g_config_episode_creator.LoadLegacyCompat(&ini, ConfigSetLevel::ep_compat);
        g_config_episode_creator.UpdateFromIni(&ini, ConfigSetLevel::ep_compat);

        // pass activity-setup keys to GameInfo
        s_GameInfoActivitySetup(ini);
    }

    if(!customCompat.empty())
    {
        IniProcessing ini = Files::load_ini(customCompat);
        g_config_file_creator.LoadLegacyCompat(&ini, ConfigSetLevel::file_compat);
        g_config_file_creator.UpdateFromIni(&ini, ConfigSetLevel::file_compat);

        // pass activity-setup keys to GameInfo
        s_GameInfoActivitySetup(ini);
    }

    UpdateConfig();
}

void ResetCustomConfig()
{
    g_config_episode_creator.Clear();
    g_config_file_creator.Clear();

    UpdateConfig();
}

void UpdateConfig()
{
    // do not allow UpdateConfig to call itself recursively
    static Config_t g_config_backup(g_options, Config_t::Scope::All);
    static bool extra_request = false;

    if(g_configInTransaction)
    {
        extra_request = true;
        return;
    }

    // initialize transaction
    g_configInTransaction = true;

    g_config_backup.Clear();
    g_config_backup.UpdateFrom(g_config);

    // start filling in the config
    g_config.Clear();
    g_config.SetFromDefaults(ConfigSetLevel::game_defaults);

    // scoping for a sentinel for audio defaults
    {
        ConfigChangeSentinel sent(ConfigSetLevel::game_defaults);

#ifndef THEXTECH_NO_SDL_BUILD
        g_config.audio_channels = g_audioDefaults.channels;
        g_config.audio_sample_rate = g_audioDefaults.sampleRate;
        g_config.audio_buffer_size = g_audioDefaults.bufferSize;
        g_config.audio_format = g_audioDefaults.format;
#endif
    }

    // load from all levels of config
    g_config.UpdateFrom(g_config_game_user, ConfigSetLevel::user_config);

    g_config.DisableBugfixes(ConfigSetLevel::bugfix_defaults);

    if(g_config.creator_compat == Config_t::CREATORCOMPAT_ENABLE)
        g_config.UpdateFrom(g_config_episode_creator, ConfigSetLevel::ep_compat);

    if(g_config.creator_compat != Config_t::CREATORCOMPAT_DISABLE)
        g_config.UpdateFrom(g_config_file_creator, ConfigSetLevel::file_compat);

    // also do the speedrun, including compat...
    if(g_config.speedrun_mode >= 1) // Always show FPS and don't pause the game work when focusing other windows
    {
        ConfigChangeSentinel sent(ConfigSetLevel::speedrun);

#ifndef NO_WINDOW_FOCUS_TRACKING
        g_config.background_work = true;
#endif
        g_config.show_fps = true;
        g_config.enable_frameskip = false;
        if(g_config.speedrun_mode == 1)
            g_config.compatibility_mode = Config_t::COMPAT_MODERN;
        else
            g_config.compatibility_mode = g_config.speedrun_mode - 1;
        g_config.enable_playtime_tracking = true;
    }

    if(XMessage::GetStatus() != XMessage::Status::local)
    {
        ConfigChangeSentinel sent(ConfigSetLevel::speedrun);

#ifndef NO_WINDOW_FOCUS_TRACKING
        g_config.background_work = true;
#endif

        g_config.enable_frameskip = true;
        g_config.unlimited_framerate = true;
        // g_config.render_vsync = false;
    }

    if(g_config.compatibility_mode)
    {
        ConfigChangeSentinel sent(ConfigSetLevel::compat);

        CompatMode compat_mode = CompatMode::off;

        if(g_config.compatibility_mode == Config_t::COMPAT_SMBX13)
        {
            compat_mode = CompatMode::smbx64;
            g_config.playstyle = Config_t::MODE_VANILLA;
        }
        else if(g_config.compatibility_mode == Config_t::COMPAT_CLASSIC)
        {
            compat_mode = CompatMode::classic;
            g_config.playstyle = Config_t::MODE_CLASSIC;
        }
        else if(g_config.compatibility_mode == Config_t::COMPAT_MODERN)
        {
            compat_mode = CompatMode::modern;
            g_config.playstyle = Config_t::MODE_MODERN;
        }

        g_config.UpdateFromCompat(compat_mode, ConfigSetLevel::compat);
    }

    for(const BaseConfigOption_t<true>* changed_opt : g_configModified)
    {
        size_t index = std::find(g_config.m_options.begin(), g_config.m_options.end(), changed_opt) - g_config.m_options.begin();
        if(index >= g_config_backup.m_options.size())
            continue;

        if(!(*changed_opt == *g_config_backup.m_options[index]))
            changed_opt->m_base->m_onupdate();
    }

    g_configModified.clear();
    g_configInTransaction = false;

    if(extra_request)
    {
        extra_request = 0;
        UpdateConfig();
    }
}

bool g_configInTransaction = false;
std::set<BaseConfigOption_t<true>*> g_configModified;

Options_t g_options;

// <defaults>                                                                     1
Config_t g_config_game_user(g_options, Config_t::Scope::Config);               // 3
Config_t g_config_episode_creator(g_options, Config_t::Scope::CreatorEpisode); // 4
Config_t g_config_file_creator(g_options, Config_t::Scope::CreatorFile);       // 6
// <compat>                                                                       9

// const std::vector<const Config_t*> g_config_levels =
// {
//     &g_gameInfo, &g_config_game_user,
//     &g_config_episode_creator, &g_config_episode_user,
//     &g_config_file_creator, &g_config_file_user,
//     &g_config_cmdline
// };

Config_t g_config(g_options, Config_t::Scope::All);


================================================
FILE: src/config.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CONFIG_MAIN_H
#define CONFIG_MAIN_H

#include <PGE_File_Formats/file_formats.h>

#include "sdl_proxy/sdl_audio.h"
#include "sound.h"
#include "screen.h"

#include "Logger/logger_level.h"

#include "config/config_base.hpp"
#include "config/config_hooks.h"

struct saveUserData;

template<bool writable>
class _Config_t
{
public:
    struct Scope
    {
        enum
        {
            None = 0,
            // UserGlobal = 1 << 0,
            // UserEpisode = 1 << 1,
            // UserFile = 1 << 2,

            // UserLocal = UserEpisode | UserFile,
            Config = 1 << 0,
            EpisodeOptions = 1 << 1,

            UserVisible = Config | EpisodeOptions,

            // Assets = 1 << 2,

            CreatorEpisode = 1 << 3,
            CreatorFile = 1 << 4,

            Creator = CreatorEpisode | CreatorFile,
            // Creator = CreatorGlobal | CreatorLocal,

            TranslateOnly = 1 << 5,

            MakeTranslation = UserVisible | TranslateOnly,

            // Episode = UserEpisode | CreatorEpisode,
            // File = UserFile | CreatorFile,
            // Local = Episode | File,
            // Global = UserGlobal | CreatorGlobal,
            All = 0xff,
        };
    };

protected:
    template<class value_t> using opt = ConfigOption_t<writable, value_t>;
    template<class value_t> using opt_enum = ConfigEnumOption_t<writable, value_t>;
    template<class value_t> using opt_range = ConfigRangeOption_t<writable, value_t>;
    using section = ConfigSection_t<writable>;
    using subsection = ConfigSubSection_t<writable>;
    using language_t = ConfigLanguage_t<writable>;
    using setup_enum_t = ConfigSetupEnum_t<writable>;

    template<class value_t>
    static constexpr value_t defaults(value_t value)
    {
        return value;
    }

public:
    const _Config_t<false>* m_base = nullptr;
    std::vector<BaseConfigOption_t<writable>*> m_options;
    uint8_t m_scope = Scope::All;

    _Config_t() {}
    _Config_t(const _Config_t<false>& base, uint8_t scope) : m_base(&base), m_scope(scope) {}

    void Clear();

    void LoadLegacyCompat(IniProcessing* ini, ConfigSetLevel level = ConfigSetLevel::set);

    void SetFromDefaults(ConfigSetLevel level = ConfigSetLevel::set);

    void DisableBugfixes(ConfigSetLevel level = ConfigSetLevel::set);

    void UpdateFromIni(IniProcessing* ini, ConfigSetLevel level = ConfigSetLevel::set);
    void UpdateFrom(const _Config_t<true>& other, ConfigSetLevel level = ConfigSetLevel::set);
    void UpdateFromCompat(CompatMode compat_mode, ConfigSetLevel level = ConfigSetLevel::set);

    void LoadEpisodeConfig(const saveUserData& userdata);

    void SaveToIni(IniProcessing* ini);
    void SaveEpisodeConfig(saveUserData& userdata);

    // for translations (note: you'll get a linker error if you invoke these on a writable Config_t.)
    void reset_options();
    void make_translation(XTechTranslate& translate);


    /* ---- Main ----*/
    section main{this, Scope::All, "main", "Main", nullptr};

    language_t language{this, defaults(std::string("auto")), {}, Scope::Config,
        "language", "Language", nullptr,
        config_language_set};

#ifdef ENABLE_XTECH_DISCORD_RPC
    opt<bool> discord_rpc{this, defaults(false), {}, Scope::Config,
        "discord-rpc", "Discord Integration", nullptr,
        config_integrations_set};
#endif

#ifndef NO_WINDOW_FOCUS_TRACKING
    opt<bool> background_work{this, defaults(false), {}, Scope::Config,
        "background-work", "Run in background", "Play with joystick while game is unfocused"};
#else
    static constexpr bool background_work = true;
#endif

    static constexpr bool enable_editor = true;

    /* ---- Main - Frame Timing ----*/
    subsection main_frame_timing{this, "timing", "Frame Timing"};

    opt<bool> enable_frameskip{this, defaults(false), {}, Scope::Config,
        "frame-skip", "Frameskip", nullptr};

    opt<bool> unlimited_framerate{this, defaults(false), {}, Scope::Config,
        "unlimited-framerate", "Unlimited framerate", nullptr};

    opt<bool> render_vsync{this, defaults(false), {}, Scope::Config,
        "vsync", "V-Sync", nullptr,
        config_res_set};

    /* ---- Main - Multiplayer ----*/
    subsection main_multiplayer{this, "multiplayer", "Multiplayer"};

    opt_enum<int> two_screen_mode{this,
        {
            {MultiplayerPrefs::Dynamic, "smbx", "SMBX"},
            {MultiplayerPrefs::Shared, "shared", "Shared"},
            {MultiplayerPrefs::Split, "split", "Left/Right"},
            {MultiplayerPrefs::TopBottom, "topbottom", "Top/Bottom"},
        },
        defaults(MultiplayerPrefs::Dynamic), {CompatClass::critical_update, MultiplayerPrefs::Dynamic}, Scope::Config,
        "two-screen-mode", "2P screen mode", nullptr,
        config_screenmode_set
    };

    opt_enum<int> four_screen_mode{this,
        {
            {MultiplayerPrefs::Shared, "shared", "Shared"},
            {MultiplayerPrefs::Split, "split", "Split"},
        },
        defaults(MultiplayerPrefs::Shared), {CompatClass::critical_update, MultiplayerPrefs::Shared}, Scope::Config,
        "four-screen-mode", "4P screen mode", nullptr,
        config_screenmode_set
    };


    /* ---- Video ----*/
    section video{this, Scope::Config, "video", "Video", nullptr};

    /* ---- Video - System ----*/
    subsection video_system{this, "video-system", "System"};

#ifndef RENDER_FULLSCREEN_ALWAYS
    opt<bool> fullscreen{this, defaults(false), {}, Scope::Config,
        "fullscreen", "Fullscreen", nullptr,
        config_fullscreen_set};
#else
    static constexpr bool fullscreen = true;
#endif

    opt_enum<std::pair<int, int>> internal_res{this,
        {
            {{480, 320}, "gba", "480x320 (GBA)"},
            {{512, 384}, "nds", "512x384 (NDS)"},
            {{512, 448}, "snes", "512x448 (SNES)"},
            {{640, 480}, "vga", "640x480 (VGA)"},
            {{768, 432}, "hello", "768x432 (HELLO)"},
            {{800, 480}, "3ds", "800x480 (3DS)"},
            {{800, 600}, "smbx", "800x600 (SMBX)"},
#ifndef __16M__
            {{0, 600}, "smbx-wide", "SMBX (wide)"},
#endif
            {{1280, 720}, "hd", "1280x720 (HD)"},
            {{0, 0}, "dynamic", "Dynamic"},
        },
        defaults(std::pair<int, int>({0, 0})), {}, Scope::Config,
        "internal-res", "Screen size", "Resolution of gameplay field",
        config_res_set
    };

    enum ScaleModes
    {
        SCALE_DYNAMIC_INTEGER = -3,
        SCALE_DYNAMIC_NEAREST = -2,
        SCALE_DYNAMIC_LINEAR = -1,
        SCALE_FIXED_05X = 0,
        SCALE_FIXED_1X = 1,
        SCALE_FIXED_2X = 2,
        SCALE_FIXED_3X = 3,
    };

#if defined(__WII__) || !defined(PGE_MIN_PORT)
    opt_enum<int> scale_mode{this,
        {
#   ifdef __WII__
            {SCALE_DYNAMIC_NEAREST, "full", "Full"},
            {SCALE_FIXED_1X, "center", "Center"},
#   else
            {SCALE_DYNAMIC_INTEGER, "integer", "Integer"},
            {SCALE_DYNAMIC_NEAREST, "nearest", "Nearest"},
            {SCALE_DYNAMIC_LINEAR, "linear", "Smooth"},
            {SCALE_FIXED_05X, "0_5x", "0.5x"},
            {SCALE_FIXED_1X, "1x", "1x"},
            {SCALE_FIXED_2X, "2x", "2x"},
            {SCALE_FIXED_3X, "3x", "3x"},
#   endif
        },
        defaults(SCALE_DYNAMIC_NEAREST), {}, Scope::Config,
        "scale-mode", "Scale mode", nullptr,
        config_res_set
    };
#else
    static constexpr int scale_mode = SCALE_DYNAMIC_NEAREST;
#endif

#ifdef __3DS__
    opt<bool> td_compat_mode{this, defaults(false), {}, Scope::Config,
        "3d-compat-mode", "3D compat mode", "Draw all objects in one 3D plane"};
#endif

    /* ---- Video - Meta Info ----*/
    subsection info_meta{this, "info-meta", "Onscreen meta info"};

    static constexpr bool show_backdrop = true;

    opt<bool> show_controllers{this, defaults(false), {}, Scope::Config,
        "display-controllers", "Controls activity", nullptr};

    opt<bool> show_fps{this, defaults(false), {}, Scope::Config,
        "show-fps", "Framerate", nullptr};

    enum
    {
        BATTERY_STATUS_OFF = 0,
        BATTERY_STATUS_LOW,
        BATTERY_STATUS_FULLSCREEN,
        BATTERY_STATUS_ALWAYS_ON,
    };

#if !defined(__WII__) && !defined(__WIIU__)
    opt_enum<int> show_battery_status{this,
        {
            {BATTERY_STATUS_OFF, "off", "Off", nullptr},
            {BATTERY_STATUS_LOW, "low", "Low", "Show when the battery is low"},
#ifndef RENDER_FULLSCREEN_ALWAYS
            {BATTERY_STATUS_FULLSCREEN, "fullscreen", "Fullscreen", "Show when the game is fullscreen"},
#endif
            {BATTERY_STATUS_ALWAYS_ON, "on", "Always", nullptr},
        },
        defaults<int>(BATTERY_STATUS_OFF), {}, Scope::Config,
        "battery-status", "Device battery status", nullptr};
#else
    static constexpr bool show_battery_status = BATTERY_STATUS_OFF;
#endif

    /* ---- Video - Game Info ----*/
    subsection info_game{this, "info-game", "Onscreen game info"};

    opt<bool> show_fails_counter{this, defaults(false), {}, Scope::Config,
        "show-fails-counter", "Fails counter", "Show fails on the episode and current level"};

    enum
    {
        MEDALS_SHOW_OFF = 0,
        MEDALS_SHOW_GOT,
        MEDALS_SHOW_COUNTS,
        MEDALS_SHOW_FULL,
    };
#if 0
    opt_enum<int> medals_show_policy{this,
        {
            {MEDALS_SHOW_OFF, "hide", "Off", "Don't show medals"},
            {MEDALS_SHOW_GOT, "collected-only", "Collected", "Show counts of gotten medals"},
            {MEDALS_SHOW_COUNTS, "counts-only", "Counts", "Show counts of gotten and available medals"},
            {MEDALS_SHOW_FULL, "show-full", "Full", "Show order of gotten and available medals"},
        },
        defaults<int>(MEDALS_SHOW_FULL), {}, Scope::Config,
        "show-medals-policy", "Medals policy"};
#else
    static constexpr int medals_show_policy = MEDALS_SHOW_FULL;
#endif

    opt<bool> show_medals_counter{this,
        defaults<bool>(true), {CompatClass::pure_preference, false}, Scope::Config,
        "show-medals-counter", "Medals counter", "Show medals in HUD and at level entrance"};

    // used elsewhere to track creator-specified options
    enum
    {
        MAP_STARS_UNSPECIFIED = 0,
        MAP_STARS_HIDE,
        MAP_STARS_COLLECTED,
        MAP_STARS_SHOW,
    };

    opt<bool> world_map_stars_show{this, defaults(true), {CompatClass::pure_preference, false}, Scope::Config,
        "world-map-stars-show", "World map stars", "Show collected stars above levels"};

    /* ---- Video - Run Info ----*/
    subsection info_run{this, "info-run", "Onscreen run info"};

    enum
    {
        EPISODE_TITLE_OFF = 0,
        EPISODE_TITLE_TOP,
        EPISODE_TITLE_BOTTOM,
    };
    opt_enum<int> show_episode_title{this,
        {
            {EPISODE_TITLE_OFF, "off", "Off"},
            {EPISODE_TITLE_TOP, "top", "Top", "Show above HUD at high resolution"},
            {EPISODE_TITLE_BOTTOM, "bottom", "Bottom", "Show above speedrun timer"},
            {EPISODE_TITLE_BOTTOM, "transparent"},
            {EPISODE_TITLE_BOTTOM, "on"},
        },
        defaults(EPISODE_TITLE_OFF), {}, Scope::Config,
        "show-episode-title", "Episode name", nullptr};

    enum
    {
        PLAYTIME_COUNTER_OFF = 0,
        PLAYTIME_COUNTER_SUBTLE = 1,
        PLAYTIME_COUNTER_OPAQUE,
        PLAYTIME_COUNTER_ANIMATED,
    };
    opt_enum<int> show_playtime_counter{this,
        {
            {PLAYTIME_COUNTER_OFF, "off", "Off", "Show only during speedruns"},
            {PLAYTIME_COUNTER_SUBTLE, "transparent", "Transparent", nullptr},
            {PLAYTIME_COUNTER_SUBTLE, "subtle"},
            {PLAYTIME_COUNTER_OPAQUE, "opaque", "Opaque", nullptr},
            {PLAYTIME_COUNTER_ANIMATED, "animated", "Animated", "Adds a rainbow effect on level end"},
        },
        defaults(PLAYTIME_COUNTER_OFF), {}, Scope::Config,
        "show-playtime-counter", "Playtime counter", "Show time spent on the episode and current attempt"};

    /* ---- Video - Effects ----*/
    subsection effects{this, "effects", "Screen Effects"};

    opt<bool> show_screen_shake{this,
        defaults(true), {CompatClass::pure_preference, true}, Scope::Config,
        "show-screen-shake", "Screen shake", nullptr};

    opt<bool> EnableInterLevelFade{this, defaults(true), {CompatClass::pure_preference, false}, Scope::Config,
        "enable-inter-level-fade-effect", "Fade transitions", nullptr};


    /* ---- Audio ----*/
    section audio{this, Scope::Config, "audio", "Audio", nullptr};

#ifndef __16M__
    opt_range<int> audio_mus_volume{this, {0, 100, 5}, defaults(100), {}, Scope::Config,
        "audio-music-volume", "Music volume", nullptr,
        config_music_volume_set};

    opt_range<int> audio_sfx_volume{this, {0, 100, 5}, defaults(100), {}, Scope::Config,
        "audio-sfx-volume", "SFX volume", nullptr};
#endif

    /* ---- Audio - Preferences ----*/
    subsection audio_preferences{this, "audio-prefs", "Preferences"};

    opt<bool> sfx_modern{this, defaults(true), {CompatClass::pure_preference, false}, Scope::Config,
        "sfx-modern", "Modern SFX", "Use sounds added in TheXTech"};

#if 0
    enum
    {
        MOUNTDRUMS_NEVER = 0,
        MOUNTDRUMS_NORMAL,
        MOUNTDRUMS_ALWAYS
    };
    opt_enum<int> sfx_mount_drums{this,
        {
            {MOUNTDRUMS_NEVER, "never", "Never", "Never plays the special drums"},
            {MOUNTDRUMS_NORMAL, "normal", "Normal", "Plays the special drums when you are riding a pet mount"},
            {MOUNTDRUMS_ALWAYS, "always", "Always", "Always plays the special drums"},
        },
        defaults<int>(MOUNTDRUMS_NORMAL), {CompatClass::pure_preference, MOUNTDRUMS_NEVER}, Scope::Config,
        "sfx-mount-drums", "Mount drums", "Should special drums play while the player is riding a pet?",
        config_mountdrums_set};
#endif

#ifndef __16M__
    opt<bool> sfx_pet_beat{this, defaults(true), {CompatClass::pure_preference, false}, Scope::Config,
        "sfx-pet-beat", "Pet grooves", "Play special groove when riding a pet",
        config_mountdrums_set};
#endif

#ifdef THEXTECH_ENABLE_AUDIO_FX

#   ifdef __3DS__
    static constexpr bool sfx_audio_fx_default = false;
#   else
    static constexpr bool sfx_audio_fx_default = true;
#   endif

    opt<bool> sfx_audio_fx{this, defaults(sfx_audio_fx_default), {CompatClass::pure_preference, false}, Scope::Config,
        "sfx-audio-fx", "Echo effects", nullptr,
        config_audiofx_set};
#endif

    opt<bool> sfx_spatial_audio{this, defaults(true), {CompatClass::pure_preference, false}, Scope::Config,
        "sfx-spatial-audio", "Spatial audio", "Reduce volume of offscreen sounds"};


    /* ---- Controls ----*/
    section controls{this, Scope::Config, "controls", "Controls"};


    /* ---- Advanced ----*/
    section advanced{this, Scope::Config, "advanced", "Advanced", "Technical options for internal operations"};

    // static constexpr bool record_gameplay_data = false;

    opt<bool> pick_assets_on_start{this, defaults(true), {}, Scope::Config,
        "choose-assets-on-launch", "Choose assets on launch", nullptr};

    opt<bool> record_gameplay_data{this, defaults(false), {}, Scope::Config,
        "record-gameplay-data", "Record gameplay", nullptr};

    opt_enum<int> log_level{this,
        {
            {PGE_LogLevel::NoLog, "none", "None", nullptr},
            {PGE_LogLevel::Fatal, "fatal", "Fatal", nullptr},
            {PGE_LogLevel::Critical, "critical", "Critical", nullptr},
            {PGE_LogLevel::Warning, "warning", "Warning", nullptr},
            {PGE_LogLevel::Info, "info", "Info", nullptr},
            {PGE_LogLevel::Debug, "debug", "Debug", nullptr},
            {PGE_LogLevel::NoLog, "0", nullptr, nullptr},
            {PGE_LogLevel::Fatal, "1", nullptr, nullptr},
            {PGE_LogLevel::Critical, "2", nullptr, nullptr},
            {PGE_LogLevel::Warning, "3", nullptr, nullptr},
            {PGE_LogLevel::Info, "4", nullptr, nullptr},
            {PGE_LogLevel::Debug, "5", nullptr, nullptr},
        },
#if defined(DEBUG_BUILD)
        defaults(PGE_LogLevel::Debug),
#else
        defaults(PGE_LogLevel::Info),
#endif
        {}, Scope::Config,
        "log-level", "Log level", nullptr,
        config_log_level_set};

#if defined(__ANDROID__) || defined(__3DS__)
    opt<bool> use_native_osk{this, defaults(false), {}, Scope::Config,
        "use-native-osk", "Native OSK", nullptr};
#endif

#ifdef PGE_VIDEO_REC_WEBM_SUPPORTED
    opt<bool> webm_recording{this, defaults(true), {}, Scope::Config,
        "webm-recording", "WEBM recording", nullptr};
#endif

    /* ---- Advanced - Video ----*/
    subsection advanced_video{this, "advanced-video", "Video"};

#ifdef __3DS__
    opt<bool> inaccurate_gifs{this, defaults(false), {}, Scope::Config,
        "inaccurate-gifs", "Inaccurate GIFs", "Allows 3D effect when GIFs are present",
        config_3ds_inaccurate_gifs_set};
#endif

#ifndef RENDER_CUSTOM
    enum RenderMode_t
    {
        RENDER_ACCELERATED_AUTO = 0,
        RENDER_ACCELERATED_SDL,
        RENDER_ACCELERATED_OPENGL,
        RENDER_ACCELERATED_OPENGL_ES,
        RENDER_ACCELERATED_OPENGL_LEGACY,
        RENDER_ACCELERATED_OPENGL_ES_LEGACY,
        RENDER_SOFTWARE,
        RENDER_END
    };
    setup_enum_t render_mode{this,
        {
            {RENDER_SOFTWARE, "sw", "Software", nullptr},
            {RENDER_ACCELERATED_AUTO, "hw", "Auto", ""},
            {RENDER_ACCELERATED_SDL, "sdl", "SDL2", "Basic cross-platform render API"},
#ifdef THEXTECH_BUILD_GL_DESKTOP_MODERN
            {RENDER_ACCELERATED_OPENGL, "opengl", "OpenGL 3+", "Desktop API with support for all new visual effects and full accuracy to SMBX64"},
#endif
#ifdef THEXTECH_BUILD_GL_ES_MODERN
            {RENDER_ACCELERATED_OPENGL_ES, "opengles", "OpenGL ES 2+", "Mobile API with support for all new visual effects and high accuracy to SMBX64"},
#endif
#ifdef THEXTECH_BUILD_GL_DESKTOP_LEGACY
            {RENDER_ACCELERATED_OPENGL_LEGACY, "opengl11", "OpenGL 1.1", "Legacy desktop API with full accuracy to SMBX64"},
#endif
#ifdef THEXTECH_BUILD_GL_ES_LEGACY
            {RENDER_ACCELERATED_OPENGL_ES_LEGACY, "opengles11", "OpenGL ES 1.1", "Legacy mobile API with full accuracy to SMBX64"},
#endif
            {RENDER_SOFTWARE, "0"},
            {RENDER_ACCELERATED_SDL, "1"},
        },
        defaults(RENDER_ACCELERATED_AUTO), {}, Scope::Config,
        "render", "Render mode", nullptr,
        config_rendermode_set};
#endif

#ifndef PGE_MIN_PORT
    enum ScaleDownTextures
    {
        SCALE_DOWN_NONE = 0,
        SCALE_DOWN_SAFE = 1,
        SCALE_DOWN_ALL = 2,
    };

    opt_enum<int> scale_down_textures{this,
        {
            {SCALE_DOWN_NONE, "none", "None", "Least loading stutter"},
            {SCALE_DOWN_SAFE, "safe", "Safe", "Checks if images are in 2x format"},
            {SCALE_DOWN_ALL, "all", "All", "Less loading stutter than 'Safe'"},
        },
        defaults(SCALE_DOWN_SAFE), {}, Scope::Config,
        "scale-down-textures", "Scale down images", "Store images as 1x to save memory"};
#endif

#ifndef PGE_MIN_PORT
    opt_enum<std::pair<int, int>> internal_res_4p{this,
        {
            {{0, 0}, "default", "Default"},
            {{1920, 1080}, "fhd", "1920x1080 (FHD)"},
            {{1600, 1200}, "qsmbx", "1600x1200 (QSMBX)"},
            {{2560, 1440}, "qhd", "2560x1440 (QHD)"},
        },
        defaults(std::pair<int, int>({0, 0})), {}, Scope::Config,
        "internal-res-4p", "4P split screen size", nullptr,
        config_res_set
    };
#endif

#ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED
    enum FullScreenType
    {
        FULLSCREEN_TYPE_AUTO = 0,
        FULLSCREEN_TYPE_DESKTOP = 1,
        FULLSCREEN_TYPE_EXCLUSIVE = 2
    };
    setup_enum_t fullscreen_type{this,
        {
            {FULLSCREEN_TYPE_AUTO, "auto", "Auto", nullptr},
            {FULLSCREEN_TYPE_DESKTOP, "desktop", "Desktop", "Keep the current screen resolution"},
            {FULLSCREEN_TYPE_EXCLUSIVE, "exclusive", "Exclusive", "Set physical screen resolution"},
        },
        defaults(FULLSCREEN_TYPE_AUTO), {},
        Scope::Config,
        "fullscreen-type", "Fullscreen type", nullptr,
        config_fullscreen_type_set
    };

    using fullscreen_res_t = ConfigFullscreenRes_t<writable>;

    fullscreen_res_t fullscreen_res{this, defaults(std::pair<int, int>{800, 600}), {}, Scope::Config,
        "fullscreen-res", "Exclusive res", nullptr,
        config_video_mode_set
    };

    setup_enum_t fullscreen_depth{this,
        {
            {0, "auto", "Auto", nullptr},
            {16, "16", "16-bit", nullptr},
            {32, "32", "32-bit", nullptr},
        },
        defaults(0), {}, Scope::Config,
        "fullscreen-depth", "Exclusive bit depth", nullptr,
        config_video_mode_set
    };
#endif // RENDER_FULLSCREEN_TYPES_SUPPORTED

#ifndef THEXTECH_NO_SDL_BUILD
    /* ---- Advanced - Audio ----*/
    subsection advanced_audio{this, "advanced-audio", "Audio"};

    opt<bool> audio_enable{this, defaults(true), {}, Scope::Config,
        "audio-enable", "Enable", nullptr,
        config_audio_set};

    setup_enum_t audio_channels{this,
        {
            {1, "mono", "Mono", nullptr},
            {2, "stereo", "Stereo", nullptr},
        },
        defaults(g_audioDefaults.channels), {}, Scope::Config,
        "audio-channels", "Channels", nullptr,
        config_audio_set};

    setup_enum_t audio_sample_rate{this,
        {
            {11025, "11025", "11025 Hz", nullptr},
            {16000, "16000", "16000 Hz", nullptr},
            {22050, "22050", "22050 Hz", nullptr},
            {32000, "32000", "32000 Hz", nullptr},
            {44100, "44100", "44100 Hz", nullptr},
            {48000, "48000", "48000 Hz", nullptr},
        },
        defaults(g_audioDefaults.sampleRate), {}, Scope::Config,
        "audio-sample-rate", "Sample rate", nullptr,
        config_audio_set};

    setup_enum_t audio_format{this,
        {
            {AUDIO_S8, false, "s8", "s8"},
            {AUDIO_S8, false, "pcm_s8"},

            {AUDIO_U8, false, "u8", "u8"},
            {AUDIO_U8, false, "pcm_u8"},

            {AUDIO_S16SYS, false, "s16", "s16"},
            {AUDIO_S16SYS, false, "pcm_s16"},
#       if AUDIO_S16LSB != AUDIO_S16SYS
            {AUDIO_S16LSB, false, "s16le", "s16le"},
            {AUDIO_S16LSB, false, "pcm_s16le"},
#       else
            {AUDIO_S16MSB, false, "s16be", "s16be"},
            {AUDIO_S16MSB, false, "pcm_s16be"},
#       endif

            {AUDIO_U16SYS, false, "u16", "u16"},
            {AUDIO_U16SYS, false, "pcm_u16"},
#       if AUDIO_U16LSB != AUDIO_U16SYS
            {AUDIO_U16LSB, false, "u16le", "u16le"},
            {AUDIO_U16LSB, false, "pcm_u16le"},
#       else
            {AUDIO_U16MSB, false, "u16be", "u16be"},
            {AUDIO_U16MSB, false, "pcm_u16be"},
#       endif

            {AUDIO_S32SYS, false, "s32", "s32"},
            {AUDIO_S32SYS, false, "pcm_s32"},
#       if AUDIO_S32LSB != AUDIO_S32SYS
            {AUDIO_S32LSB, false, "s32le", "s32le"},
            {AUDIO_S32LSB, false, "pcm_s32le"},
#       else
            {AUDIO_S32MSB, false, "s32be", "s32be"},
            {AUDIO_S32MSB, false, "pcm_s32be"},
#       endif

            {AUDIO_F32SYS, false, "float32", "float32"},
            {AUDIO_F32SYS, false, "pcm_f32"},
#       if AUDIO_F32LSB != AUDIO_F32SYS
            {AUDIO_F32LSB, false, "float32le", "float32le"},
            {AUDIO_F32LSB, false, "pcm_f32le"},
#       else
            {AUDIO_F32MSB, false, "float32be", "float32be"},
            {AUDIO_F32MSB, false, "pcm_f32be"},
#       endif
        },
        defaults(g_audioDefaults.format), {}, Scope::Config,
        "audio-format", "Audio format", "Format for sound driver",
        config_audio_set};

    setup_enum_t audio_buffer_size{this,
        {
            {512, false, "512", "512"},
            {768, false, "768", "768"},
            {1024, false, "1024", "1024"},
            {1536, false, "1536", "1536"},
            {2048, false, "2048", "2048"},
            {4096, false, "4096", "4096"},
        },
        defaults(g_audioDefaults.bufferSize), {}, Scope::Config,
        "audio-buffer-size", "Buffer size", "Increase for fewer pops but more lag",
        config_audio_set};
#else
    static constexpr int audio_sample_rate = 44100;
    static constexpr int audio_format = AUDIO_F32SYS;
    static constexpr int audio_buffer_size = 1024;
#endif


    /* ---- Episode options ----*/
    section episode_options{this, Scope::EpisodeOptions, "episode-options", "Episode Options"};

    enum
    {
        MODE_MODERN = 0,
        MODE_CLASSIC,
        MODE_VANILLA,
    };
    opt_enum<int> playstyle{this,
        {
            {MODE_MODERN, "modern", "Modern", "All updates"},
            {MODE_CLASSIC, "classic", "Classic", "Minimal updates"},
            {MODE_VANILLA, "vanilla", "Vanilla", "No updates"},
        },
        defaults(MODE_MODERN), {CompatClass::pure_preference, MODE_VANILLA}, Scope::EpisodeOptions,
        "playstyle", "Playstyle", nullptr,
        config_compat_changed};

    enum
    {
        CREATORCOMPAT_ENABLE = 0,
        CREATORCOMPAT_FILEONLY,
        CREATORCOMPAT_DISABLE,
    };
    opt_enum<int> creator_compat{this,
        {
            {CREATORCOMPAT_ENABLE, "enable", "Enable", nullptr},
            {CREATORCOMPAT_FILEONLY, "file-only", "File only", nullptr},
            {CREATORCOMPAT_DISABLE, "disable", "Disable", nullptr},
        },
        defaults(CREATORCOMPAT_ENABLE), {CompatClass::critical_update, CREATORCOMPAT_DISABLE}, Scope::EpisodeOptions,
        "creator-compat", "Creator compat", "Logic tweaks by content creator"};

    opt<bool> enable_last_warp_hub_resume{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorEpisode | Scope::EpisodeOptions,
        "hub-resume", "Save warp in hub", "Resume play at the last warp you entered"};

    // /* ---- Prefs - Effects ----*/
    // subsection effects{this, "effects", "Visual Effects"};



    /* ---- Compatibility ----*/
    section compat{this, Scope::All, "compatibility", "Session Tweaks", "Options for compat or debugging"};

    subsection reset_all{this, "reset-all", "Reset All"};

    // TODO: make sure that Modern / Classic do not override compat.ini settings
    enum
    {
        COMPAT_OFF = 0,
        COMPAT_CLASSIC,
        COMPAT_SMBX13,
        COMPAT_MODERN,
    };
    opt_enum<int> compatibility_mode{this,
        {
            {COMPAT_OFF, "off", "Off", nullptr},
            {COMPAT_OFF, "native"},
            {COMPAT_MODERN, "modern", "Modern", nullptr},
            {COMPAT_CLASSIC, "classic", "Classic", nullptr},
            {COMPAT_SMBX13, "smbx13", "Vanilla", nullptr},
            // {COMPAT_CONTENT, "content", "Content", "Preserves the gameplay of the version for which the content was released"},
        },
        defaults(COMPAT_OFF), {}, Scope::None,
        "compatibility-mode", "Compat mode", "Overrides settings (even custom ones in a world or level) to guarantee behavior compatible with an older fan game"};

    /* ---- Compatibility - Features ----*/
    subsection compat_features{this, "features", "Features"};

    opt<bool> allow_drop_add{this, defaults(true), {CompatClass::critical_update, false}, Scope::None,
        "allow-drop-add", "Allow drop/add", "Allow players to be dropped/added from the pause menu item during gameplay"};
    opt<bool> multiplayer_pause_controls{this, defaults(true), {CompatClass::critical_update, false}, Scope::None,
        "multiplayer-pause-controls", "Multiplayer pause controls", "Allows players other than P1 to pause the game and control the pause menu"};

    opt<bool> world_map_lvlname_marquee{this, defaults(false), {CompatClass::pure_preference, false}, Scope::CreatorEpisode,
    "world-map-lvlname-marquee", "Level name marquee", "In the world map, use a marquee effect for the level name instead of splitting it over two lines"};

    opt<bool> fix_vanilla_checkpoints{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-vanilla-checkpoints", "Fix vanilla checkpoints", "Resume from the most recently touched checkpoint after death"};
    opt<bool> disable_background2_tiling{this, defaults(false), {CompatClass::standard_update, true}, Scope::Creator,
        "disable-background2-tiling", "Disable BG tiling", "Disable tiling of the level background texture if it causes visual disturbances"};
    opt<bool> modern_section_change{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "modern-section-change", "Modern section change", "Animate sections resizing when they shrink or during 2-player mode"};

    opt<bool> extra_screen_shake{this, defaults(true), {CompatClass::critical_update, false}, Scope::Creator,
        "extra-screen-shake", "Extra screen shake", "Shake screen for large enemy and player ground pounds"};

    opt<bool> enable_playtime_tracking{this, defaults(true), {CompatClass::pure_preference, false}, Scope::CreatorFile,
        "enable-playtime-tracking", "Playtime tracking", "Record the amount of time spent playing an episode"};
    opt<bool> enable_fails_tracking{this, defaults(true), {CompatClass::pure_preference, false}, Scope::CreatorFile,
        "enable-fails-tracking", "Fails tracking", "Record the number of fails on the current level and world"};

    opt<bool> world_map_fast_move{this, defaults(true), {CompatClass::standard_update, false}, Scope::Creator,
        "world-map-fast-move", "Automatic movement", "Moves automatically between forks on the path"};

    // opt<bool> modern_item_drop{this, defaults(true), {CompatClass::standard_update, false}, Scope::Creator,
    //     "modern-item-drop", "Modern item drop", "Experimental implementation of modern item drop"};
    opt<bool> small_screen_cam{this, defaults(true), {CompatClass::standard_update, false}, Scope::None,
        "small-screen-cam", "Small screen camera", "Camera panning and control"};

    opt<bool> disable_spin_jump{this, defaults(false), {CompatClass::critical_update, false}, Scope::Creator,
        "disable-spin-jump", "Disable spin jump", "The alt jump key should trigger an ordinary jump instead of a spin jump"};

    opt<bool> no_shell_grab_top{this, defaults(false), {CompatClass::critical_update, false}, Scope::CreatorEpisode,
        "no-shell-grab-top", "No shell grab from top", nullptr};

    opt<bool> alt_powerdown{this, defaults(false), {CompatClass::critical_update, false}, Scope::CreatorEpisode,
        "alt-powerdown", "Alt powerdown (chars 1+2)", nullptr};

    /* ---- Compatibility - Autocode ----*/
    subsection compat_autocode{this, "autocode", "Autocode"};

    // Luna
    opt<bool> luna_enable_engine{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "luna-script-enable-engine", "Enable engine", nullptr};
    opt<bool> luna_allow_level_codes{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "luna-script-allow-level-codes", "Allow level codes", nullptr};
    static constexpr bool autocode_translate_coords = true;
    // opt<bool> autocode_translate_coords{this, defaults(true), {}, Scope::CreatorFile,
    //     "autocode-translate-coords", "Translate coords", "Translate the coordinates of autocode screen-space objects based on the HUD location"};

    /* ---- Compatibility - Bugfixes ----*/
    subsection bugfixes{this, "bugfixes", "Bugfixes"};

    // <1.3.4
    opt<bool> fix_restored_block_move{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-restored-block-move", "Fix restored block move", "Don't move powerup blocks to the right when they are hit after restoring"};
    opt<bool> fix_player_slope_speed{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-player-slope-speed", "Player slope speed", nullptr};
    // 1.3.4
    opt<bool> fix_player_filter_bounce{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-player-filter-bounce", "Player filter bounce", "Fix a glitch where player could clip downwards"};
    opt<bool> fix_player_clip_wall_at_npc{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-player-clip-wall-at-npc", "Player clip wall at NPC", nullptr};
    opt<bool> fix_player_downward_clip{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-player-downward-clip", "Player downward clip", nullptr};
    opt<bool> fix_npc_downward_clip{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-npc-downward-clip", "NPC downward clip", nullptr};
    opt<bool> fix_npc247_collapse{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-npc247-collapse", "NPC 247 collapse", "Prevents the stacked spiky plants from collapsing incorrectly"};
    opt<bool> fix_platforms_acceleration{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-platform-acceleration", "Platform acceleration", nullptr};
    opt<bool> fix_npc55_kick_ice_blocks{this, defaults(false), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-npc55-kick-ice-blocks", "NPC55 kick ice blocks", "NPC55 should kick ice blocks like NPC119"};
    opt<bool> fix_climb_invisible_fences{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-climb-invisible-fences", "Don't climb hidden fences", nullptr};
    opt<bool> fix_climb_bgo_speed_adding{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-climb-bgo-speed-adding", "Climb BGO speed adding", nullptr};
    opt<bool> enable_climb_bgo_layer_move{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "enable-climb-bgo-layer-move", "Move with climbable BGOs", "Player will move together with the climbable BGO on the moving layer as on vines"};
    opt<bool> fix_skull_raft{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-skull-raft", "Skull raft", nullptr};
    opt<bool> fix_char3_escape_shell_surf{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-char3-escape-shell-surf", "Char 3 escape shell surf", nullptr};
    opt<bool> fix_plant_wobble{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-plant-wobble", "Fix plant wobble", "Plants should correctly resize instead of appearing to change size / position"};
    opt<bool> fix_powerup_lava_bug{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-powerup-lava-bug", "Fix powerup lava bug", "Powerups should be destroyed when hitting lava instead of surviving depending on the current NPC array"};
    // opt<bool> fix_keyhole_framerate{this, defaults(true), {VER_THEXTECH134, CompatClass::critical_update, false}, Scope::CreatorFile,
    //     "fix-keyhole-framerate", "Fix keyhole framerate", nullptr};
    // 1.3.5
    opt<bool> fix_char5_vehicle_climb{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-char5-vehicle-climb", "Fix char 5 car fairy", nullptr};
    opt<bool> fix_vehicle_char_switch{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-vehicle-char-switch", "Don't switch character by car", nullptr};
    opt<bool> fix_autoscroll_speed{this, defaults(false), {CompatClass::pure_preference, false}, Scope::CreatorFile,
        "fix-autoscroll-speed", "[Deprecated] autoscroll speed", nullptr};
    opt<bool> fix_submerged_splash_effect{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-submerged-splash-effect", "Fix submerged splash effect", "Don't make a splash effect for items already underwater"};
    // 1.3.5.1
    opt<bool> fix_squid_stomp_effect{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-squid-stomp-effect", "Fix calamari stomp effect", nullptr};
    // deprecated, fixed non-vanilla bug
    // opt<bool> keep_bullet_bill_dir{this, defaults(true), {VER_THEXTECH1351, CompatClass::critical_update, false}, Scope::CreatorFile,
    //     "keep-bullet-bill-direction", "Keep bullet dir", nullptr};
    opt<bool> fix_special_coin_switch{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-special-coin-switch", "Preserve special coins", "Don't turn special coins into blocks when pressing switch"};
    // 1.3.5.2
    opt<bool> fix_bat_start_while_inactive{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-bat-start-while-inactive", "Bat start", "Don't activate the bats until they are onscreen"};
    // 1.3.5.3
    opt<bool> fix_npc_activation_event_loop_bug{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-npc-activation-event-loop-bug", "NPC activation loop", "Fixes softlock bug that results when NPCs activate each other in a loop"};
    // 1.3.6
    opt<bool> fix_fairy_stuck_in_pipe{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-fairy-stuck-in-pipe", "Fairy stuck in pipe", nullptr};
    opt<bool> fix_flamethrower_gravity{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-flamethrower-gravity", "Flamethrower gravity", "Should this have even been made?"};
    // 1.3.6.1
    opt<bool> fix_npc_ceiling_speed{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-npc-ceiling-speed", "Fix NPC ceiling speed", "Don't stick a thrown NPC to ceiling when a layer is moving"};
    opt<bool> emulate_classic_block_order{this, defaults(false), {CompatClass::critical_update, true}, Scope::CreatorFile,
        "emulate-classic-block-order", "Emulate classic block order", "Use the classic game's block sorting methods internally for frame-perfect compatibility"};
    opt<bool> custom_powerup_collect_score{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "custom-powerup-collect-score", "Custom powerup collect score", "Collected powerups give score from npc-X.txt"};
    opt<bool> fix_player_crush_death{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-player-crush-death", "Fix player crush death", "Player should not be crushed by corners of slopes or by hitting a horizontally moving ceiling"};
    opt<bool> fix_pound_skip_warp{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-pound-skip-warp", "Fix pound skip warp", "Pound move should not skip instant / portal warps"};
    opt<bool> fix_held_item_cancel{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-held-item-cancel", "Fix held item cancel", "Do not cancel held item hitting hostile NPC that intersects with an immune NPC"};
    opt<bool> fix_frame_perfect_despawn{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-frame-perfect-despawn", "Fix frame perfect despawn", "If NPC comes onscreen later in the same frame it timed out, should still be able to spawn"};

    // TODO: implement proper read/write operations
    // opt<std::array<uint8_t, 3>> bitblit_background_colour{this, defaults<std::array<uint8_t, 3>>({0, 0, 0}), {VER_THEXTECH1361}, Scope::CreatorFile,
    //     "bitblit-background-colour", "Bitblit background colour", "Background colour for legacy transparency effects", config_bitblit_background_set};

    // 1.3.6.3
    opt<bool> pound_by_alt_run{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "pound-by-alt-run", "Pound by alt run", "Use Alt Run for Pound action when player is in a purple pet mount"};

    // 1.3.6.5
    opt<bool> fix_visual_bugs{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-visual-bugs", "Fix visual bugs", "Fix misc visual bugs from SMBX 1.3"};
    opt<bool> fix_npc_emerge_size{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-npc-emerge-size", "Fix NPC emerge size", "Fix size of NPC emerging from a block"};
    opt<bool> fix_switched_block_clipping{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-switched-block-clipping", "Fix switched block clipping", "Don't let blocks become intangible to NPCs after coin switch"};

    // 1.3.6.6
    opt<bool> fix_vehicle_altjump_bug{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-vehicle-altjump-bug", "Fix vehicle AltJump bug", "Don't become vulnerable after AltJump into car"};
    opt<bool> fix_vehicle_altjump_lock{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-vehicle-altjump-lock", "Fix vehicle AltJump lock", "Don't get stuck in car entered while holding AltJump"};
    // player can be stuck when hit by an NPC while digging dirt (#125)
    opt<bool> fix_player_stuck_on_dirt{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-player-stuck-on-dirt", "Fix player stuck on dirt", "Don't get stuck when digging dirt"};

    // 1.3.7
    opt<bool> fix_npc_camera_logic{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-npc-camera-logic", "Fix NPC camera logic", "NPCs should support more than two cameras"};
    opt<bool> fix_multiplayer_targeting{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-multiplayer-targeting", "Fix NPC targeting", "Updated NPC targeting logic in multiplayer"};
    opt<bool> allow_multires{this, defaults(true), {CompatClass::critical_update, false}, Scope::Creator,
        "allow-multires", "Allow multires", "Allows the gameplay field to be <800x600", config_res_set};
    opt<bool> dynamic_camera_logic{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "dynamic-camera-logic", "Dynamic camera logic", "Allow a non-800x600 camera for most logic, and only use the event logic camera in rare cases",
        config_res_set};
    opt<bool> fix_attlayer_reset{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-attlayer-reset", "Fix AttLayer reset", "Resets an att. layer when its NPC dies"};
    opt<bool> fix_medal_kill{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-medal-kill", "Fix medal kill", "Count a medal as collected when player kills it"};
    opt<bool> fix_event_swap_bug{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-event-swap-bug", "Fix event swap bug", "Don't overwrite pending events when multiple events triggered in a frame"};

    // if we make the scope below be Scope::CreatorEpisode, episodes can force this in both modern / classic mode
    opt<bool> modern_lives_system{this, defaults(true), {CompatClass::critical_update, false}, Scope::None,
        "modern-lives-system", "Modern lives system", "Allow negative lives instead of returning to the main menu"};

    // 1.3.7.1
    opt<bool> fix_player_grab_clip{this, defaults(true), {CompatClass::critical_update, false}, Scope::CreatorFile,
        "fix-player-grab-clip", "Fix player grab clip", "Don't clip downwards on powerup while digging"};

    // 1.3.7.3
    opt<bool> fix_char_pass_balls{this, defaults(true), {CompatClass::standard_update, false}, Scope::CreatorFile,
        "fix-char-pass-balls", "Fix char-pass balls", "Fix char 2-4's iceballs and char 5's fire/iceballs on char-pass blocks"};

    // 1.3.8
    opt<bool> new_conveyor_belts{this, defaults(true), {CompatClass::standard_update, false}, Scope::Creator,
        "new-conveyor-belts", "New conveyor belts", "Update belts to faster and more stable logic"};
    opt<bool> optimize_coins{this, defaults(true), {CompatClass::critical_update, false}, Scope::Creator,
        "optimize-coins", "Optimize coins", "Speed up the game when many coins are onscreen"};
    opt<bool> fix_timestop_respawn{this, defaults(true), {CompatClass::standard_update, false}, Scope::Creator,
        "fix-timestop-respawn", "Fix timestop respawn", "Allow NPCs to respawn during timestop"};

    /* ---- Compatibility - Speedrun ----*/

    section speedrun{this, Scope::CreatorEpisode, "speedrun", "Speedrun"};

    opt_enum<int> speedrun_mode{this,
        {
            {0, "0", "0", nullptr},
            {1, "1", "1", nullptr},
            {2, "2", "2", nullptr},
            {3, "3", "3", nullptr},
        },
        defaults<int>(0), {}, Scope::EpisodeOptions,
        "mode", "Speedrun mode", nullptr,
        config_compat_changed};

    enum
    {
        SPEEDRUN_STOP_NONE = 0,
        SPEEDRUN_STOP_EVENT,
        SPEEDRUN_STOP_LEAVE_LEVEL,
        SPEEDRUN_STOP_ENTER_LEVEL
    };
    opt_enum<int> speedrun_stop_timer_by{this,
        {
            {SPEEDRUN_STOP_NONE, "none", "Off", nullptr},
            {SPEEDRUN_STOP_EVENT, "event", "Event (specify)", nullptr},
            {SPEEDRUN_STOP_LEAVE_LEVEL, "leave", "Leave level (specify)", nullptr},
            {SPEEDRUN_STOP_ENTER_LEVEL, "enter", "Enter level (specify)", nullptr},
        },
        defaults<int>(SPEEDRUN_STOP_NONE), {}, Scope::CreatorEpisode,
        "stop-timer-by", "Stop speedrun timer on", "This triggers the speedrun timer to stop"};
    opt<std::string> speedrun_stop_timer_at{this, defaults<std::string>("Boss Dead"), {}, Scope::CreatorEpisode,
        "stop-timer-at", "Stop speedrun timer event/level", "If above is 'Event' or 'Level', this specifies which"};

    /* ---- View Credits ----*/
    section view_credits{this, Scope::All, "view-credits", "View Credits"};
};

void OpenConfig();
void LoadCustomConfig();
void ResetCustomConfig();
void UpdateConfig();
void SaveConfig();

using Options_t = _Config_t<false>;
using Config_t = _Config_t<true>;

// extern const std::vector<const Config_t*> g_config_levels;

extern _Config_t<false> g_options;

// <defaults>                                1
extern Config_t g_config_game_user;       // 3
extern Config_t g_config_episode_creator; // 4
// extern Config_t g_config_episode_user;    // 5
extern Config_t g_config_file_creator;    // 6
// extern Config_t g_config_cmdline;         // 7 // temporary
// <cmdline>                                10
// <usertest>                               11
// <cheats>                                 12
// <compat>                                 13

extern Config_t g_config;

#endif // CONFIG_MAIN_H


================================================
FILE: src/control/con_control.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CON_CONTROL_H
#define CON_CONTROL_H

#include <cstdint>
#include <string>

//Public Type conKeyboard  'Input settings for the keyboard
struct ConKeyboard_t
{
//    Up As Integer
    int Up = 0;
//    Down As Integer
    int Down = 0;
//    Left As Integer
    int Left = 0;
//    Right As Integer
    int Right = 0;
//    Jump As Integer
    int Jump = 0;
//    AltJump As Integer
    int AltJump = 0;
//    Run As Integer
    int Run = 0;
//    AltRun As Integer
    int AltRun = 0;
//    Drop As Integer
    int Drop = 0;
//    Start As Integer
    int Start = 0;
//End Type
};

struct KM_Key
{
    // SDL_Joystick control
    int val = -1;
    int id = -1;
    int type = -1;

    // SDL_GameController control
    int ctrl_val = -1;
    int ctrl_id = -1;
    int ctrl_type = -1;
};

//Public Type conJoystick   'Input settings for the joystick
struct ConJoystick_t
{
// EXTRA
    bool isValid = false;
    bool isGameController = false;
    bool isHaptic = false;

    enum CtrlTypes
    {
        NoControl=-1,
        JoyAxis=0,
        JoyBallX,
        JoyBallY,
        JoyHat,
        JoyButton,
        CtrlButton,
        CtrlAxis
    };

    KM_Key Up;
    KM_Key Down;
    KM_Key Left;
    KM_Key Right;

//    Jump As Integer
    KM_Key Jump;
//    Run As Integer
    KM_Key Run;
//    Drop As Integer
    KM_Key Drop;
//    Start As Integer
    KM_Key Start;
//    AltJump As Integer
    KM_Key AltJump;
//    AltRun As Integer
    KM_Key AltRun;
//End Type
};

#endif // CON_CONTROL_H


================================================
FILE: src/control/controls.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>

#include <AppPath/app_path.h>
#include <Utils/files.h>
#include <IniProcessor/ini_processing.h>

#include "../config.h"
#include "../controls.h"
#include "../main/record.h"
#include "../main/speedrunner.h"
#include "message.h"
#include "change_res.h"

#include "core/render.h"
#include "core/window.h"

// for hotkeys screen
#include "main/menu_controls.h"
#include "../game_main.h"
#include "main/screen_textentry.h"
#include "main/screen_quickreconnect.h"
#include "main/screen_pause.h"
#include "main/cheat_code.h"
#include "main/menu_main.h"
#include "main/translate.h"
#include "main/game_strings.h"
#include "../graphics.h"
#include "../frame_timer.h"

#include "control/controls_methods.h"
#include "control/controls_strings.h"

#include <Logger/logger.h>


Controls_t& operator|=(Controls_t& o1, const Controls_t& o2)
{
    o1.Up |= o2.Up;
    o1.Down |= o2.Down;
    o1.Left |= o2.Left;
    o1.Right |= o2.Right;

    o1.Jump |= o2.Jump;
    o1.AltJump |= o2.AltJump;

    o1.Run |= o2.Run;
    o1.AltRun |= o2.AltRun;

    o1.Drop |= o2.Drop;
    o1.Start |= o2.Start;

    return o1;
}

ControlsStrings_t g_controlsStrings;


namespace Controls
{

std::vector<InputMethod*> g_InputMethods;
std::vector<InputMethodType*> g_InputMethodTypes;
bool g_renderTouchscreen = false;
HotkeysPressed_t g_hotkeysPressed;
static HotkeysPressed_t s_hotkeysPressedOld;
bool g_disallowHotkeys = false;

std::array<Controls_t, maxLocalPlayers> g_RawControls;

std::array<std::string, PlayerControls::Buttons::MAX> PlayerControls::g_button_name_UI;
std::array<std::string, CursorControls::Buttons::MAX> CursorControls::g_button_name_UI;
std::array<std::string, EditorControls::Buttons::MAX> EditorControls::g_button_name_UI;
std::array<std::string, Hotkeys::Buttons::MAX> Hotkeys::g_button_name_UI;

void Hotkeys::Activate(size_t i, int player)
{
    if(g_disallowHotkeys || g_pollingInput)
        return;

    g_disallowHotkeys = true;

    switch(i)
    {
#ifndef RENDER_FULLSCREEN_ALWAYS
    case Buttons::Fullscreen:
        ChangeScreen();
        return;
#endif

#ifdef USE_SCREENSHOTS_AND_RECS
    case Buttons::Screenshot:
        TakeScreen = true;
        return;
#endif

#ifdef PGE_ENABLE_VIDEO_REC
    case Buttons::RecordGif:
        XRender::toggleGifRecorder();
        return;
#endif

#ifdef DEBUG_BUILD
    case Buttons::ReloadLanguage:
    {
        ReloadTranslations();
        return;
    }
#endif

    case Buttons::VanillaCam:
        if(!GameMenu && !GameOutro && !LevelEditor && !BattleMode && !qScreen && (g_VanillaCam || l_screen->W != l_screen->canonical_screen().W || l_screen->H != l_screen->canonical_screen().H))
        {
            g_VanillaCam = !g_VanillaCam;
            SoundPause[SFX_Camera] = 0;
            PlaySoundMenu(SFX_Camera);
            UpdateInternalRes();
        }
        else
        {
            PlaySoundMenu(SFX_BlockHit);
        }

        return;

    case Buttons::DebugInfo:
        g_stats.next_page();
        return;

    case Buttons::EnterCheats:
        l_SharedControls.Pause = true;
        l_SharedControls.ForcePause = true;
        PauseScreen::UnlockCheats();
        return;

    case Buttons::ToggleHUD:
        ShowOnScreenHUD = !ShowOnScreenHUD;
        return;

    case Buttons::LegacyPause:
        if(player == 0)
            l_SharedControls.Pause = true;

        l_SharedControls.LegacyPause = true;
        return;

    default:
        return;
    }
}

/*====================================================*\
|| implementation for InputMethod                     ||
\*====================================================*/

InputMethod::~InputMethod() {}

// Used for battery, latency, etc
// If the char* member is dynamically generated, you MUST use an instance-owned buffer
// This will NOT be freed
// returning a null pointer is allowed
StatusInfo InputMethod::GetStatus()
{
    return StatusInfo();
}

// Optional function allowing developer to consume an SDL event (on SDL clients)
//     usually used for hotkeys or for connect/disconnect events.
// Called (1) in order of InputMethodTypes, then (2) in order of InputMethods
// Returns true if event is consumed, false if other InputMethodTypes and InputMethods
//     should receive it.
bool InputMethod::ConsumeEvent(const SDL_Event* ev)
{
    UNUSED(ev);
    return false;
}


/*====================================================*\
|| implementation for InputMethodProfile              ||
\*====================================================*/

InputMethodProfile::~InputMethodProfile() {}

void InputMethodProfile::SaveConfig_All(IniProcessing* ctl)
{
    if(this->Type->RumbleSupported())
        ctl->setValue("enable-rumble", this->m_rumbleEnabled);

    if(this->Type->PowerStatusSupported())
        ctl->setValue("show-power-status", this->m_showPowerStatus);

    ctl->setValue("alt-menu-controls", this->m_altMenuControls);

    this->SaveConfig(ctl);
}

void InputMethodProfile::LoadConfig_All(IniProcessing* ctl)
{
    if(this->Type->RumbleSupported())
        ctl->read("enable-rumble", this->m_rumbleEnabled, this->m_rumbleEnabled);

    if(this->Type->PowerStatusSupported())
        ctl->read("show-power-status", this->m_showPowerStatus, this->m_showPowerStatus);

    // defaults to false to avoid changes when users upgrade from earlier versions of TheXTech
    ctl->read("alt-menu-controls", this->m_altMenuControls, false);

    this->LoadConfig(ctl);
}

// How many per-type special options are there?
size_t InputMethodProfile::GetOptionCount()
{
    size_t shared_options_count = CommonOptions::COUNT;

    if(!this->Type->RumbleSupported())
        shared_options_count -= 1;

    if(!this->Type->PowerStatusSupported())
        shared_options_count -= 1;

    return shared_options_count + this->GetOptionCount_Custom();
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount() returns 0.
// get a char* describing the option
const char* InputMethodProfile::GetOptionName(size_t i)
{
    if(!this->Type->RumbleSupported() && (int)i >= CommonOptions::rumble)
        i += 1;

    if(!this->Type->PowerStatusSupported() && (int)i >= CommonOptions::show_power_status)
        i += 1;

    if(i >= CommonOptions::COUNT)
        return this->GetOptionName_Custom(i - CommonOptions::COUNT);

    if(i == CommonOptions::rumble)
        return g_mainMenu.controlsOptionRumble.c_str();
    else if(i == CommonOptions::show_power_status)
        return g_mainMenu.controlsOptionBatteryStatus.c_str();
    else if(i == CommonOptions::alt_menu_controls) // -V547 Should be here to fail when adding new enum fields
        return g_mainMenu.controlsOptionAltMenuControls.c_str();
    else
        return nullptr;
}
// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodProfile::GetOptionValue(size_t i)
{
    if(!this->Type->RumbleSupported() && (int)i >= CommonOptions::rumble)
        i += 1;

    if(!this->Type->PowerStatusSupported() && (int)i >= CommonOptions::show_power_status)
        i += 1;

    if(i >= CommonOptions::COUNT)
        return this->GetOptionValue_Custom(i - CommonOptions::COUNT);

    if(i == CommonOptions::rumble)
    {
        if(this->m_rumbleEnabled)
            return g_mainMenu.wordOn.c_str();
        else
            return g_mainMenu.wordOff.c_str();
    }
    else if(i == CommonOptions::show_power_status)
    {
        if(this->m_showPowerStatus)
            return g_mainMenu.wordShow.c_str();
        else
            return g_mainMenu.wordHide.c_str();
    }
    else if(i == CommonOptions::alt_menu_controls) // -V547 Should be here to fail when adding new enum fields
    {
        if(this->m_altMenuControls)
            return g_mainMenu.wordOn.c_str();
        else
            return g_mainMenu.wordOff.c_str();
    }
    else
        return nullptr;
}
// called when A is pressed; allowed to interrupt main game loop
bool InputMethodProfile::OptionChange(size_t i)
{
    if(!this->Type->RumbleSupported() && (int)i >= CommonOptions::rumble)
        i += 1;

    if(!this->Type->PowerStatusSupported() && (int)i >= CommonOptions::show_power_status)
        i += 1;

    if(i >= CommonOptions::COUNT)
        return this->OptionChange_Custom(i - CommonOptions::COUNT);

    if(i == CommonOptions::rumble)
    {
        this->m_rumbleEnabled = !this->m_rumbleEnabled;

        for(InputMethod* m : g_InputMethods)
        {
            if(!m || m->Profile != this)
                continue;

            if(this->m_rumbleEnabled)
                m->Rumble(200, .5);
        }

        return true;
    }
    else if(i == CommonOptions::show_power_status)
    {
        this->m_showPowerStatus = !this->m_showPowerStatus;
        return true;
    }
    else if(i == CommonOptions::alt_menu_controls) // -V547 Should be here to fail when adding new enum fields
    {
        this->m_altMenuControls = !this->m_altMenuControls;
        return true;
    }
    else
    {
        return false;
    }
}
// called when left is pressed
bool InputMethodProfile::OptionRotateLeft(size_t i)
{
    int i_proc = (int)i;

    if(!this->Type->RumbleSupported() && (int)i_proc >= CommonOptions::rumble)
        i_proc += 1;

    if(!this->Type->PowerStatusSupported() && (int)i_proc >= CommonOptions::show_power_status)
        i_proc += 1;

    if(i_proc >= CommonOptions::COUNT)
        return this->OptionRotateLeft_Custom(i_proc - CommonOptions::COUNT);

    return this->OptionChange(i);
}
// called when right is pressed
bool InputMethodProfile::OptionRotateRight(size_t i)
{
    int i_proc = (int)i;

    if(!this->Type->RumbleSupported() && (int)i_proc >= CommonOptions::rumble)
        i_proc += 1;

    if(!this->Type->PowerStatusSupported() && (int)i_proc >= CommonOptions::show_power_status)
        i_proc += 1;

    if(i_proc >= CommonOptions::COUNT)
        return this->OptionRotateRight_Custom(i_proc - CommonOptions::COUNT);

    return this->OptionChange(i);
}

// How many per-type special options are there?
size_t InputMethodProfile::GetOptionCount_Custom()
{
    return 0;
}

// get a nullable char* describing the option
const char* InputMethodProfile::GetOptionName_Custom(size_t i)
{
    UNUSED(i);
    return nullptr;
}
// get a nullable char* describing the current option value
// must be allocated in static or instance memory
const char* InputMethodProfile::GetOptionValue_Custom(size_t i)
{
    UNUSED(i);
    return nullptr;
}
// called when A is pressed; allowed to interrupt main game loop
bool InputMethodProfile::OptionChange_Custom(size_t i)
{
    UNUSED(i);
    return false;
}
// called when left is pressed
bool InputMethodProfile::OptionRotateLeft_Custom(size_t i)
{
    UNUSED(i);
    return false;
}
// called when right is pressed
bool InputMethodProfile::OptionRotateRight_Custom(size_t i)
{
    UNUSED(i);
    return false;
}

/*====================================================*\
|| implementation for InputMethodType                 ||
\*====================================================*/

InputMethodType::~InputMethodType()
{
    for(InputMethodProfile* p : this->m_profiles)
        delete p;

    this->m_profiles.clear();
}

const std::string& InputMethodType::LocalName() const
{
    return this->Name;
}

std::vector<InputMethodProfile*> InputMethodType::GetProfiles()
{
    return this->m_profiles;
}

InputMethodProfile* InputMethodType::AddProfile()
{
    InputMethodProfile* profile = this->AllocateProfile();

    if(!profile)
        return nullptr;

    profile->Type = this;
    this->m_profiles.push_back((InputMethodProfile*) profile);
    profile->Name = this->LocalName() + " " + std::to_string(this->m_profiles.size());

    return profile;
}

// be extremely careful never to delete a profile that is in use
bool InputMethodType::DeleteProfile(InputMethodProfile* profile, const std::vector<InputMethod*>& active_methods)
{
    if(!profile)
        return false;

    // delete from m_profiles
    std::vector<InputMethodProfile*>::iterator loc = std::find(this->m_profiles.begin(), this->m_profiles.end(), profile);

    if(loc == this->m_profiles.end())
        return false;

    for(InputMethod* method : active_methods)
    {
        if(!method)
            continue;

        if(method->Profile == profile)
            DeleteInputMethod(method);
    }

    for(int i = 0; i < maxLocalPlayers; i++)
    {
        if(this->m_defaultProfiles[i] == profile)
        {
            // m_defaultProfiles is nullable, so this is okay
            this->m_defaultProfiles[i] = nullptr;
        }
    }

    if(!this->DeleteProfile_Custom(profile, active_methods))
        return false;

    this->m_profiles.erase(loc);

    // deallocate
    delete profile;

    return true;
}

bool InputMethodType::ClearProfiles(const std::vector<InputMethod*>& active_methods)
{
    // clear existing profiles safely
    size_t i = 0;

    while(i < this->m_profiles.size())
    {
        // only increment the index when deletion fails
        if(!this->DeleteProfile(this->m_profiles[i], active_methods))
            i++;
    }

    // succeeded if all were cleared successfully
    return (i == 0);
}

bool InputMethodType::SetProfile(InputMethod* method, int player_no, InputMethodProfile* profile, const std::vector<InputMethod*>& active_methods)
{
    if(player_no < 0 || player_no >= maxLocalPlayers || !profile)
        return false;

    if(!this->TestProfileType(profile))
        return false;

    if(!this->SetProfile_Custom(method, player_no, profile, active_methods))
        return false;

    this->SetDefaultProfile(player_no, profile);
    method->Profile = profile;

    return true;
}

void InputMethodType::SetDefaultProfile(int player_no, InputMethodProfile* profile)
{
    if(player_no < 0 || player_no >= maxLocalPlayers || !profile)
        return;

    this->m_defaultProfiles[player_no] = profile;
}

InputMethodProfile* InputMethodType::GetDefaultProfile(int player_no)
{
    if(player_no < 0 || player_no >= maxLocalPlayers)
        return nullptr;

    // still possibly a null pointer
    return this->m_defaultProfiles[player_no];
}

void InputMethodType::SaveConfig(IniProcessing* ctl)
{
    ctl->beginGroup(this->Name);
    this->SaveConfig_Custom(ctl);

    // save the number of profiles
    ctl->setValue("n-profiles", this->m_profiles.size());

    // save the default (most recent) profile for each player
    for(int i = 0; i < maxLocalPlayers; i++)
    {
        InputMethodProfile* default_profile = this->m_defaultProfiles[i];
        std::string default_profile_key = "default-profile-" + std::to_string(i + 1);

        if(default_profile == nullptr)
        {
            ctl->setValue(default_profile_key.c_str(), -1);
            continue;
        }

        std::vector<InputMethodProfile*>::iterator loc = std::find(this->m_profiles.begin(), this->m_profiles.end(), default_profile);
        size_t index = loc - this->m_profiles.begin();

        if(index == this->m_profiles.size())
            ctl->setValue(default_profile_key.c_str(), -1);
        else
            ctl->setValue(default_profile_key.c_str(), index);
    }

    ctl->endGroup();

    // save each profile
    for(size_t i = 0; i < this->m_profiles.size(); i++)
    {
        ctl->beginGroup(this->Name + "-" + std::to_string(i + 1));
        ctl->setValue("name", this->m_profiles[i]->Name);
        this->m_profiles[i]->SaveConfig_All(ctl);
        ctl->endGroup();
    }
}

void InputMethodType::LoadConfig(IniProcessing* ctl)
{
    int n_profiles;
    int n_existing = (int)this->m_profiles.size(); // should usually be zero

    ctl->beginGroup(this->Name);
    ctl->read("n-profiles", n_profiles, 2);
    ctl->endGroup();

    for(int i = 0; i < n_profiles; i++)
    {
        std::string group_name = this->Name + "-" + std::to_string(i + n_existing + 1);

        // look for legacy profile if there is no modern profile
        if(!ctl->contains(group_name))
        {
            if(!this->LegacyName.empty())
            {
                group_name = "player-" + std::to_string(i + 1) + "-" + this->LegacyName;

                if(!ctl->contains(group_name))
                    continue;
            }
            else
                continue;
        }

        // found a profile in the INI, now allocate and load it
        InputMethodProfile* new_profile = this->AddProfile();

        if(new_profile)
        {
            ctl->beginGroup(group_name);
            new_profile->LoadConfig_All(ctl);
            ctl->read("name", new_profile->Name, this->LocalName() + " " + std::to_string(i + n_existing + 1));
            ctl->endGroup();
        }
    }

    // load the default recent profile for each player
    ctl->beginGroup(this->Name);

    for(int i = 0; i < maxLocalPlayers; i++)
    {
        std::string default_profile_key = "default-profile-" + std::to_string(i + 1);
        int index;
        ctl->read(default_profile_key.c_str(), index, -1);

        if(index == -1)
        {
            this->m_defaultProfiles[i] = nullptr;
        }
        else
        {
            index += n_existing;
            if(index < (int)this->m_profiles.size())
                this->m_defaultProfiles[i] = this->m_profiles[index];
            else
            {
                pLogWarning("Attempt to get the profile index %d out of range (m_profiles size: %d)", index, (int)this->m_profiles.size());
                this->m_defaultProfiles[i] = nullptr;
            }
        }
    }

    this->LoadConfig_Custom(ctl);
    ctl->endGroup();
}

// optionally overriden methods

bool InputMethodType::ConsumeEvent(const SDL_Event* ev)
{
    UNUSED(ev);
    return false;
}

bool InputMethodType::SetProfile_Custom(InputMethod* method, int player_no, InputMethodProfile* profile, const std::vector<InputMethod*>& active_methods)
{
    (void)active_methods;

    if(!method || !profile || player_no < 0 || player_no >= maxLocalPlayers)
        return false;

    return true;
}

bool InputMethodType::DeleteProfile_Custom(InputMethodProfile* profile, const std::vector<InputMethod*>& active_methods)
{
    UNUSED(profile);
    UNUSED(active_methods);
    return true;
}

// How many per-type special options are there?
size_t InputMethodType::GetOptionCount()
{
    return 0;
}

// get a nullable char* describing the option
const char* InputMethodType::GetOptionName(size_t i)
{
    UNUSED(i);
    return nullptr;
}
// get a nullable char* describing the current option value
// must be allocated in static or instance memory
const char* InputMethodType::GetOptionValue(size_t i)
{
    UNUSED(i);
    return nullptr;
}
// called when A is pressed; allowed to interrupt main game loop
bool InputMethodType::OptionChange(size_t i)
{
    UNUSED(i);
    return false;
}
// called when left is pressed
bool InputMethodType::OptionRotateLeft(size_t i)
{
    UNUSED(i);
    return false;
}
// called when right is pressed
bool InputMethodType::OptionRotateRight(size_t i)
{
    UNUSED(i);
    return false;
}

void InputMethodType::SaveConfig_Custom(IniProcessing* ctl)
{
    UNUSED(ctl);
    // must be implemented if user has created special options
    SDL_assert_release(this->GetOptionCount() == 0);
}
void InputMethodType::LoadConfig_Custom(IniProcessing* ctl)
{
    UNUSED(ctl);
    // must be implemented if user has created special options
    SDL_assert_release(this->GetOptionCount() == 0);
}

/*====================================================*\
|| implementation for global functions                ||
\*====================================================*/

void InitStrings()
{
    // initialize the strings for localization
    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
        PlayerControls::g_button_name_UI[i] = PlayerControls::GetButtonName_UI_Init(i);

    for(size_t i = 0; i < CursorControls::n_buttons; i++)
        CursorControls::g_button_name_UI[i] = CursorControls::GetButtonName_UI_Init(i);

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
        EditorControls::g_button_name_UI[i] = EditorControls::GetButtonName_UI_Init(i);

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
        Hotkeys::g_button_name_UI[i] = Hotkeys::GetButtonName_UI_Init(i);
}

/*====================================================*\
||                                                    ||
||         ADD EVERY NEW INPUT METHOD HERE,           ||
||           IF SUPPORTED AT COMPILE TIME             ||
||                                                    ||
\*====================================================*/

// allocate InputMethodTypes according to system configuration
void Init()
{
#ifdef INPUT_3DS_H
    g_InputMethodTypes.push_back(new InputMethodType_3DS);
#endif
#ifdef INPUT_WII_H
    g_InputMethodTypes.push_back(new InputMethodType_Wii);
#endif
#ifdef INPUT_WII_GC_H
    g_InputMethodTypes.push_back(new InputMethodType_GameCube);
#endif
#ifdef INPUT_16M_H
    g_InputMethodTypes.push_back(new InputMethodType_16M);
#endif
#ifdef KEYBOARD_H
    g_InputMethodTypes.push_back(new InputMethodType_Keyboard);
#endif
#ifdef JOYSTICK_H
    g_InputMethodTypes.push_back(new InputMethodType_Joystick);
#endif
#ifdef TOUCHSCREEN_H
    g_InputMethodTypes.push_back(new InputMethodType_TouchScreen);
#endif

    InitStrings();

    // not yet ready for prime time
    // g_InputMethodTypes.push_back(new InputMethodType_Duplicate);
    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        g_hotkeysPressed[i] = -1;
        s_hotkeysPressedOld[i] = -1;
    }
}

void Quit()
{
    ClearInputMethods();

    for(InputMethodType* type : g_InputMethodTypes)
        delete type;

    g_InputMethodTypes.clear();
}

// (for SDL clients) process SDL_Event using active InputMethodTypes
// return true if successfully processed, false if unrecognized
bool ProcessEvent(const SDL_Event* ev)
{
    for(InputMethodType* type : g_InputMethodTypes)
    {
        if(type && type->ConsumeEvent(ev))
            return true;
    }

    for(InputMethod* method : g_InputMethods)
    {
        if(method && method->ConsumeEvent(ev))
            return true;
    }

    return false;
}

// 1. Calls the UpdateControlsPre hooks of loaded InputMethodTypes
//    a. Syncs hardware state as needed
// 2. Updates Player and Editor controls by calling currently bound InputMethods
//    a. May call or set changeScreen, frmMain.toggleGifRecorder, TakeScreen, g_stats.enabled, etc
// 3. Calls the UpdateControlsPost hooks of loaded InputMethodTypes
//    a. May call or set changeScreen, frmMain.toggleGifRecorder, TakeScreen, g_stats.enabled, etc
//    b. May update l_SharedControls or SharedCursor using hardcoded keys
// 4. Updates speedrun and recording modules
// 5. Resolves inconsistent control states (Left+Right, etc)
bool Update(bool check_lost_devices)
{
    bool okay = true;
    bool prev_okay = true;

    // track whether shared controls buttons were pressed last frame, to modify the global versions
    bool old_shared_pause = l_SharedControls.Pause;
    bool old_shared_legacy = l_SharedControls.LegacyPause;
    bool old_shared_force = l_SharedControls.ForcePause;

    // reset per-frame state for SharedCursor
    SharedCursor.Move = false;
    SharedCursor.Primary = false;
    SharedCursor.Secondary = false;
    SharedCursor.Tertiary = false;
    SharedCursor.ScrollUp = false;
    SharedCursor.ScrollDown = false;
    // reset l_SharedControls
    l_SharedControls = SharedControls_t();

    // reset EditorControls
    ::EditorControls = EditorControls_t();

    for(InputMethodType* type : g_InputMethodTypes)
        type->UpdateControlsPre();

    Controls_t blankControls = Controls_t();

    for(int i = 0; i < l_screen->player_count; i++)
    {
        Controls_t newControls = blankControls;

        CursorControls_t& cursor = SharedCursor;
        EditorControls_t& editor = ::EditorControls;

        if(i < (int)g_InputMethods.size() && g_InputMethods[i])
        {
            InputMethod* method = g_InputMethods[i];

            if(!method->Update(i + 1, newControls, cursor, editor, g_hotkeysPressed) && check_lost_devices)
            {
                okay = false;
                DeleteInputMethod(method);
                // the method pointer is no longer valid
            }
        }
        else
            prev_okay = false;

        if(g_hotkeysPressed[Hotkeys::Buttons::LegacyPause] == i + 1)
            newControls.Start = true;

        // push messages corresponding to controls press / release
        XMessage::PushControls(i, newControls);
    }

    for(InputMethodType* type : g_InputMethodTypes)
        type->UpdateControlsPost();

    // call pause screen logic if needed (this is needed for pause screen to use local controls state to trigger events)
    if(GamePaused == PauseCode::PauseScreen)
        PauseScreen::ControlsLogic();

    // trigger hotkeys
    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        if(s_hotkeysPressedOld[i] != g_hotkeysPressed[i] && g_hotkeysPressed[i] != -1)
            Hotkeys::Activate(i, g_hotkeysPressed[i]);

        s_hotkeysPressedOld[i] = g_hotkeysPressed[i];
        g_hotkeysPressed[i] = -1;
    }

    // push shared controls
    if(l_SharedControls.Pause && !old_shared_pause)
        XMessage::PushMessage({XMessage::Type::shared_controls, 0, 0});

    if(l_SharedControls.LegacyPause && !old_shared_legacy)
        XMessage::PushMessage({XMessage::Type::shared_controls, 0, 1});

    if(l_SharedControls.ForcePause && !old_shared_force)
        XMessage::PushMessage({XMessage::Type::shared_controls, 0, 2});

    SharedPause = false;
    SharedPauseLegacy = false;
    SharedPauseForce = false;

    // sync any messages, and reset player controls to raw controls
    XMessage::Tick();

    if(SharedCursor.Move)
    {
        if(SharedCursor.X >= 0 && SharedCursor.Y >= 0)
        {
            int window_x, window_y;
            XRender::mapFromScreen((int)SharedCursor.X, (int)SharedCursor.Y, &window_x, &window_y);
            XWindow::placeCursor(window_x, window_y);
        }
    }

    // sync controls
    Record::Sync();

    for(int i = 0; i < l_screen->player_count; i++)
        speedRun_syncControlKeys(i, Player[l_screen->players[i]].Controls);

    // resolve invalid states and override players without controls
    For(B, 1, numPlayers)
    {
        // erase for non-existant players during main menu and outro
        if((GameMenu || GameOutro) && B > (int)g_InputMethods.size())
            Player[B].Controls = blankControls;

        // override in ClonedPlayerMode and SingleCoop mode (slightly different from original case which checked if numPlayers != 2)
        if((g_ClonedPlayerMode || SingleCoop) && B > 1)
        {
            // new location for cloned player code ("superbdemo128", was misplaced in ClownCar previously)
            Player[B].Controls = Player[1].Controls;

            // allow pausing in SingleCoop
            if(SingleCoop)
                Player[B].UnStart |= Player[1].UnStart;

            continue;
        }

        auto& p = Player[B];
        Controls_t& c = p.Controls;

        if(!c.Start && !c.Jump)
            p.UnStart = true;

        if(c.Up && c.Down)
        {
            c.Up = false;
            c.Down = false;
        }

        if(c.Left && c.Right)
        {
            c.Left = false;
            c.Right = false;
        }

        // don't remap AltRun when player has Statue power
        if(!(p.State == 5 && p.Mount == 0) && c.AltRun)
            c.Run = true;

        if(ForcedControls && GamePaused == PauseCode::None)
            c = ForcedControl;
    }

    // single coop code -- may want to revise
    if(SingleCoop > 0)
    {
        if(numPlayers == 1 || g_ClonedPlayerMode)
            SingleCoop = 0;

        if(SingleCoop == 1)
            Player[2].Controls = blankControls;
        else
            Player[1].Controls = blankControls;
    }

    For(A, 1, numPlayers)
    {
        {
            Player_t& p = Player[A];

            if(p.SpinJump)
                p.Direction = (p.SpinFrame < 4 || p.SpinFrame > 9) ? -1 : 1;
        }
    }

    // indicate if some control slots are missing
    if(!prev_okay && !SingleCoop && !GameMenu && !LevelEditor && !Record::replay_file && check_lost_devices)
        okay = false;

    g_disallowHotkeys = false;

    return okay;
}

void SaveConfig(IniProcessing* ctl)
{
    for(InputMethodType* type : g_InputMethodTypes)
        type->SaveConfig(ctl);
}

void LoadConfig(IniProcessing* ctl)
{
    for(InputMethodType* type : g_InputMethodTypes)
    {
        type->ClearProfiles(g_InputMethods);
        type->LoadConfig(ctl);
    }
}

void SaveConfig()
{
    std::string controlsPath = AppPathManager::settingsControlsFileSTD();
    IniProcessing controls(controlsPath);
    SaveConfig(&controls);
    controls.writeIniFile();
    AppPathManager::syncFs();

    pLogDebug("Saved control mappings: %s", controlsPath.c_str());
}

void LoadConfig()
{
    std::string configPath = AppPathManager::settingsFileSTD();
    std::string controlsPath = AppPathManager::settingsControlsFileSTD();

    // Keep backward compatibility and restore old mappings from the "thextech.ini"
    const std::string *load_path = Files::fileExists(controlsPath) ? &controlsPath :
        Files::fileExists(configPath) ? &configPath : nullptr;

    if(!load_path)
    {
        // make a new empty config file
        SaveConfig();
    }
    else
    {
        IniProcessing controls(*load_path);
        LoadConfig(&controls);
    }
}

InputMethod* PollInputMethod() noexcept
{
    // don't poll unless there is a free slot
    size_t player_no = 0;

    while(player_no < g_InputMethods.size() && g_InputMethods[player_no] != nullptr)
        player_no ++;

    if(player_no >= maxLocalPlayers)
        return nullptr;

    // try all input method types
    InputMethod* new_method = nullptr;

    for(InputMethodType* type : g_InputMethodTypes)
    {
        new_method = type->Poll(g_InputMethods);

        if(new_method)
            break;
    }

    if(!new_method)
        return nullptr;

    // check that the InputMethodType properly assigned itself as the new InputMethod's Type
    SDL_assert_release(new_method->Type != nullptr); // InputMethodType did not assign itself as Type for new InputMethod

    if(!new_method->Type)
        return nullptr;

    // tentatively add to the input method list so we can call SetInputMethodProfile
    if(player_no < g_InputMethods.size())
        g_InputMethods[player_no] = new_method;
    else
        g_InputMethods.push_back(new_method);

    // if a profile has already been assigned, activate any hooks possible
    if(new_method->Profile)
        SetInputMethodProfile((int)player_no, new_method->Profile);

    // try a number of ways of assigning a profile if one has not already been assigned
    std::vector<InputMethodProfile*> profiles = new_method->Type->GetProfiles();

    // fallback 1: last profile used by this player index
    if(!new_method->Profile)
    {
        InputMethodProfile* default_profile = new_method->Type->GetDefaultProfile((int)player_no);

        if(default_profile)
            SetInputMethodProfile((int)player_no, default_profile);
    }

    // fallback 2: find first unused profile
    if(!new_method->Profile)
    {
        size_t i;

        for(i = 0; i < profiles.size(); i++)
        {
            bool unused = true;

            for(InputMethod* other_method : g_InputMethods)
            {
                if(other_method && other_method->Profile == profiles[i])
                {
                    unused = false;
                    break;
                }
            }

            if(unused)
                break;
        }

        if(i != profiles.size())
            SetInputMethodProfile((int)player_no, profiles[i]);
    }

    // fallback 3: use first profile
    if(!new_method->Profile && !profiles.empty())
        SetInputMethodProfile((int)player_no, profiles[0]);

    // fallback 4: new default profile
    if(!new_method->Profile)
        SetInputMethodProfile((int)player_no, new_method->Type->AddProfile());

    // should only STILL be null if something is very wrong (alloc failed, etc)
    if(!new_method->Profile)
    {
        pLogWarning("Failed to find/alloc/set profile for new %s.",
                    new_method->Type->Name.c_str());
        delete new_method;
        return nullptr;
    }

    pLogDebug("Just activated new %s '%s' with profile '%s'.",
              new_method->Type->Name.c_str(),
              new_method->Name.c_str(),
              new_method->Profile->Name.c_str());

    return new_method;
}

void DeleteInputMethod(InputMethod* method)
{
    if(!method)
        return;

    std::vector<InputMethod*>::iterator loc = std::find(g_InputMethods.begin(), g_InputMethods.end(), method);

    while(loc != g_InputMethods.end())
    {
        *loc = nullptr;
        loc = std::find(g_InputMethods.begin(), g_InputMethods.end(), method);
    }

    pLogDebug("Just disconnected %s '%s' with profile '%s'.",
              method->Type->Name.c_str(),  method->Name.c_str(), method->Profile->Name.c_str());
    delete method;
}

void DeleteInputMethodSlot(int slot)
{
    if(slot < 0 || (size_t)slot > g_InputMethods.size())
        return;

    if(g_InputMethods[slot] != nullptr)
        DeleteInputMethod(g_InputMethods[slot]);

    g_InputMethods.erase(g_InputMethods.begin() + slot);
}

bool SetInputMethodProfile(int player_no, InputMethodProfile* profile)
{
    if(player_no >= (int)g_InputMethods.size() || !g_InputMethods[player_no] || !profile)
        return false;

    InputMethod* method = g_InputMethods[player_no];

    if(!method->Type)
        return false;

    return method->Type->SetProfile(method, player_no, profile, g_InputMethods);
}

bool SetInputMethodProfile(InputMethod* method, InputMethodProfile* profile)
{
    if(!method || !profile || !method->Type)
        return false;

    std::vector<InputMethod*>::iterator loc = std::find(g_InputMethods.begin(), g_InputMethods.end(), method);
    size_t player_no = loc - g_InputMethods.begin();

    if(player_no == g_InputMethods.size())
        return false;

    return method->Type->SetProfile(method, (int)player_no, profile, g_InputMethods);
}

void ClearInputMethods()
{
    for(size_t i = 0; i < g_InputMethods.size(); i++)
        DeleteInputMethod(g_InputMethods[i]);

    g_InputMethods.clear();
}

void RemoveNullInputMethods()
{
    // remove any null input methods
    for(size_t i = 0; i < Controls::g_InputMethods.size(); )
    {
        if(Controls::g_InputMethods[i])
            i++;
        else
            Controls::DeleteInputMethodSlot(i);
    }
}

MenuControls_t GetMenuControls(int limit_player)
{
    MenuControls_t ret;
    ret.Up = l_SharedControls.MenuUp;
    ret.Down = l_SharedControls.MenuDown;
    ret.Left = l_SharedControls.MenuLeft;
    ret.Right = l_SharedControls.MenuRight;
    ret.Home = SharedCursor.Tertiary;

    ret.Do = l_SharedControls.MenuDo || l_SharedControls.Pause;
    ret.Back = l_SharedControls.MenuBack;

    ret.Erase = false;

    for(size_t i = 0; l_screen && i < (size_t)l_screen->player_count; i++)
    {
        if(limit_player != 0 && l_screen->players[i] != limit_player)
            continue;

        const Controls_t &c = g_RawControls[i];

        // alt menu controls: Jump is back, AltJump is Do
        if(i < g_InputMethods.size() && g_InputMethods[i] && g_InputMethods[i]->Profile && g_InputMethods[i]->Profile->m_altMenuControls)
        {
            ret.Back |= c.Jump;
            ret.Do |= c.AltJump;
        }
        // normal menu controls: Jump is Do, AltJump is Back
        else
        {
            ret.Do |= c.Jump;
            ret.Back |= c.AltJump;
        }

        ret.Do |= c.Start;
        ret.Back |= c.Run;

        ret.Up |= c.Up;
        ret.Down |= c.Down;
        ret.Left |= c.Left;
        ret.Right |= c.Right;

        ret.Home |= c.Drop;
        ret.Erase |= c.AltRun;
    }

    return ret;
}


// player is 1-indexed :(
void Rumble(int player, int ms, float strength)
{
    if(GameMenu || GameOutro)
        return;

    const Screen_t& screen = ScreenByPlayer(player);

    if(&screen != l_screen)
        return;

    int l_player_i = 0;
    while(l_player_i < screen.player_count && player != screen.players[l_player_i])
        l_player_i++;

    if(l_player_i == screen.player_count)
        return;

    if(l_player_i >= (int)g_InputMethods.size())
        return;

    if(!g_InputMethods[l_player_i])
        return;

    if(!g_InputMethods[l_player_i]->Profile)
        return;

    if(!g_InputMethods[l_player_i]->Profile->m_rumbleEnabled)
        return;

    g_InputMethods[l_player_i]->Rumble(ms, strength);
}

void RumbleAllPlayers(int ms, float strength)
{
    if(GameMenu || GameOutro)
        return;

    for(InputMethod* method : g_InputMethods)
    {
        if(!method)
            continue;

        if(!method->Profile)
            continue;

        if(!method->Profile->m_rumbleEnabled)
            continue;

        method->Rumble(ms, strength);
    }
}


StatusInfo GetStatus(int l_player_i)
{
    // return something blank if player doesn't exist
    if(l_player_i < 0 || l_player_i >= (int)g_InputMethods.size() || g_InputMethods[l_player_i] == nullptr)
        return StatusInfo();

    // return something blank if l_player_i doesn't want to show status
    if(!g_InputMethods[l_player_i]->Profile || !g_InputMethods[l_player_i]->Profile->m_showPowerStatus)
        return StatusInfo();

    return g_InputMethods[l_player_i]->GetStatus();
}


void RenderTouchControls()
{
#ifdef TOUCHSCREEN_H
    // only want to render when the touchscreen is in use
    InputMethod_TouchScreen* active_touchscreen = nullptr;
    int player_no = 1;

    for(size_t i = 0; i < g_InputMethods.size(); i++)
    {
        InputMethod* method = g_InputMethods[i];

        if(!method)
            continue;

        auto* m = dynamic_cast<InputMethod_TouchScreen*>(method);
        if(m)
        {
            active_touchscreen = m;
            player_no = (int)i + 1;
            break;
        }
    }

    if(!g_renderTouchscreen)
        return;

    InputMethodType_TouchScreen* touchscreen = nullptr;

    if(active_touchscreen)
        touchscreen = dynamic_cast<InputMethodType_TouchScreen*>(active_touchscreen->Type);
    else
    {
        for(InputMethodType* type : g_InputMethodTypes)
        {
            if(!type)
                continue;

            auto* t = dynamic_cast<InputMethodType_TouchScreen*>(type);
            if(t)
            {
                touchscreen = t;
                break;
            }
        }
    }

    if(!touchscreen)
        return;

    touchscreen->m_controller.render(player_no);
#endif // #ifdef TOUCHSCREEN_H
}

void UpdateTouchScreenSize()
{
#ifdef TOUCHSCREEN_H
    InputMethodType_TouchScreen* touchscreen = nullptr;

    for(InputMethodType* type : g_InputMethodTypes)
    {
        if(!type)
            continue;

        auto* t = dynamic_cast<InputMethodType_TouchScreen*>(type);

        if(t)
        {
            touchscreen = t;
            break;
        }
    }

    if(!touchscreen)
        return;

    touchscreen->m_controller.updateScreenSize();
#endif // #ifdef TOUCHSCREEN_H
}

void LoadTouchScreenGFX()
{
#ifdef TOUCHSCREEN_H
    InputMethodType_TouchScreen* touchscreen = nullptr;

    for(InputMethodType* type : g_InputMethodTypes)
    {
        if(!type)
            continue;

        auto* t = dynamic_cast<InputMethodType_TouchScreen*>(type);

        if(t)
        {
            touchscreen = t;
            break;
        }
    }

    if(!touchscreen)
        return;

    touchscreen->m_controller.loadGFX();
#endif // #ifdef TOUCHSCREEN_H
}

} // namespace Controls



================================================
FILE: src/control/controls_methods.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef CONTROLS_METHODS_H
#define CONTROLS_METHODS_H

#if   defined(__3DS__)

#include "control/input_3ds.h"

#elif defined(__WII__)

#include "control/input_wii.h"
#include "control/input_wii_gc.h"

#elif defined(__16M__)

#include "control/input_16m.h"

#elif !defined(THEXTECH_NO_SDL_BUILD) && !defined(THEXTECH_CLI_BUILD)

#include "control/keyboard.h"
#include "control/joystick.h"
#include "control/touchscreen.h"

#endif

#include "control/duplicate.h"

#endif // #ifndef CONTROLS_METHODS_H


================================================
FILE: src/control/controls_strings.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef CONTROLS_STRINGS_H
#define CONTROLS_STRINGS_H

#include <string>

#include "control/controls_methods.h"

// configuration: build all strings if lang tools enabled, otherwise just the needed ones
#if !defined(THEXTECH_DISABLE_LANG_TOOLS) || defined(INPUT_16M_H) || defined(INPUT_3DS_H)
#define CONTROLS_16M_STRINGS
#endif

#if !defined(THEXTECH_DISABLE_LANG_TOOLS) || defined(INPUT_3DS_H)
#define CONTROLS_3DS_STRINGS
#endif

#if !defined(THEXTECH_DISABLE_LANG_TOOLS) || defined(INPUT_WII_H)
#define CONTROLS_WII_STRINGS
#endif

#if !defined(THEXTECH_DISABLE_LANG_TOOLS) || defined(KEYBOARD_H)
#define CONTROLS_KEYBOARD_STRINGS
#endif

#if !defined(THEXTECH_DISABLE_LANG_TOOLS) || defined(TOUCHSCREEN_H)
#define CONTROLS_TOUCHSCREEN_STRINGS
#endif

#if !defined(THEXTECH_DISABLE_LANG_TOOLS) || defined(JOYSTICK_H)
#define CONTROLS_JOYSTICK_STRINGS
#endif


struct ControlsStrings_t
{

    std::string sharedCaseInvalid = "(Invalid)";
    std::string sharedOptionMaxPlayers = "Max Players";

#ifdef CONTROLS_KEYBOARD_STRINGS
    std::string nameKeyboard = "Keyboard";
    std::string keyboardOptionTextEntryStyle = "Text Entry Style";
    std::string caseMouse = "(Mouse)";
#endif

#if defined(CONTROLS_KEYBOARD_STRINGS) || defined(CONTROLS_JOYSTICK_STRINGS)
    std::string nameGamepad = "Gamepad";
#endif

#if defined(CONTROLS_JOYSTICK_STRINGS)
    std::string nameOldJoy = "Old Joy";
    std::string phraseNewProfOldJoy = "New Profile for Old Joystick";
#endif

#if defined(CONTROLS_JOYSTICK_STRINGS) || defined(CONTROLS_WII_STRINGS)
    std::string joystickSimpleEditor = "Simple Editor Controls";
#endif

#ifdef CONTROLS_TOUCHSCREEN_STRINGS
    std::string nameTouchscreen = "Touchscreen";
    std::string caseTouch = "(Touch)";


    std::string touchscreenOptionLayoutStyle = "Layout Style";
    std::string touchscreenOptionScaleFactor = "Scale Factor";
    std::string touchscreenOptionScaleDPad = "Scale D-Pad";
    std::string touchscreenOptionScaleButtons = "Scale Buttons";
    std::string touchscreenOptionSStartSpacing = "S-Start Spacing";
    std::string touchscreenOptionResetLayout = "Reset Layout";
    std::string touchscreenOptionInterfaceStyle = "Interface Style";
    std::string touchscreenOptionFeedbackStrength = "Feedback Strength";
    std::string touchscreenOptionFeedbackLength = "Feedback Length";
    std::string touchscreenOptionHoldRun = "Hold Run on Start";
    std::string touchscreenOptionShowCodeButton = "Show Code Button";


    std::string touchscreenLayoutTight = "Tight";
    std::string touchscreenLayoutTinyOld = "Tiny (Old)";
    std::string touchscreenLayoutPhoneOld = "Phone (Old)";
    std::string touchscreenLayoutLongOld = "Long (Old)";
    std::string touchscreenLayoutPhabletOld = "Phablet (Old)";
    std::string touchscreenLayoutTabletOld = "Tablet (Old)";
    std::string touchscreenLayoutStandard = "Standard";

    std::string touchscreenStyleActions = "Actions";
    std::string touchscreenStyleABXY = "ABXY";
    std::string touchscreenStyleXODA = "XODA";
#endif

#ifdef CONTROLS_16M_STRINGS
    std::string tdsButtonA = "A";
    std::string tdsButtonB = "B";
    std::string tdsButtonX = "X";
    std::string tdsButtonY = "Y";
    std::string tdsButtonL = "L";
    std::string tdsButtonR = "R";
    std::string tdsButtonSelect = "Select";
    std::string tdsButtonStart = "Start";

    std::string tdsCasePen = "(Pen)";
#endif // #ifdef CONTROLS_16M_STRINGS

#if defined(CONTROLS_3DS_STRINGS)
    std::string tdsDpad = "D-Pad";
    std::string tdsTstick = "Thumb";
    std::string tdsCstick = "C-Stick";
    std::string tdsButtonZL = "ZL";
    std::string tdsButtonZR = "ZR";
#endif // #ifdef CONTROLS_3DS_STRINGS

#ifdef CONTROLS_WII_STRINGS
    std::string wiiTypeWiimote = "Wiimote";

    std::string wiiDpad = "D-Pad";

    std::string wiiButtonA = "A";
    std::string wiiButtonB = "B";
    std::string wiiButtonMinus = "-";
    std::string wiiButtonPlus = "+";
    std::string wiiButtonHome = "Home";
    std::string wiiButton2 = "2";
    std::string wiiButton1 = "1";
    std::string wiiShake = "Shake";

    std::string wiiTypeNunchuck = "Nunchuck";
    std::string wiiPhraseNewNunchuck = "New Nunchuck Profile";

    std::string wiiPrefixNunchuck = "N";

    std::string wiiButtonZ = "Z";
    std::string wiiButtonC = "C";

    std::string wiiTypeClassic = "Classic";
    std::string wiiPhraseNewClassic = "New Classic Profile";

    std::string wiiLStick = "L-Pad";
    std::string wiiRStick = "R-Pad";

    std::string wiiButtonZL = "ZL";
    std::string wiiButtonZR = "ZR";
    std::string wiiButtonLT = "LT";
    std::string wiiButtonRT = "RT";
    std::string wiiButtonX = "X";
    std::string wiiButtonY = "Y";

    std::string wiiCaseIR = "(IR)";

    std::string wiiTypeGamecube = "GameCube";

#endif // #ifdef CONTROLS_WII_STRINGS


};

extern ControlsStrings_t g_controlsStrings;

#endif // #ifndef CONTROLS_STRINGS_H


================================================
FILE: src/control/duplicate.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>

#include "duplicate.h"
#include "../globals.h"

namespace Controls
{

/*====================================================*\
|| implementation for InputMethod_Duplicate         ||
\*====================================================*/

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_Duplicate::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    if(this->player_no < 1 || this->player_no > maxLocalPlayers)
        return false;

    if(this->player_no - 1 >= (int)g_InputMethods.size())
        return false;

    if(!g_InputMethods[this->player_no - 1])
        return false;

    c = Player[this->player_no].Controls;

    UNUSED(player);
    UNUSED(m);
    UNUSED(e);
    UNUSED(h);

    return true;
}

void InputMethod_Duplicate::Rumble(int ms, float strength)
{
    Controls::Rumble(this->player_no, ms, strength);
}

/*====================================================*\
|| implementation for InputMethodProfile_Duplicate  ||
\*====================================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_Duplicate::InputMethodProfile_Duplicate()
{}

bool InputMethodProfile_Duplicate::PollPrimaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

bool InputMethodProfile_Duplicate::PollSecondaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

bool InputMethodProfile_Duplicate::DeletePrimaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

bool InputMethodProfile_Duplicate::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

const char* InputMethodProfile_Duplicate::NamePrimaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return "(DUP)";
}

const char* InputMethodProfile_Duplicate::NameSecondaryButton(ControlsClass c, size_t i)
{
    (void)c;
    (void)i;
    return "";
}

void InputMethodProfile_Duplicate::SaveConfig(IniProcessing* ctl)
{
    UNUSED(ctl);
}

void InputMethodProfile_Duplicate::LoadConfig(IniProcessing* ctl)
{
    UNUSED(ctl);
}

/*====================================================*\
|| implementation for InputMethodType_Duplicate     ||
\*====================================================*/

InputMethodProfile* InputMethodType_Duplicate::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_Duplicate;
}

InputMethodType_Duplicate::InputMethodType_Duplicate()
{
    this->Name = "Duplicate";
}

bool InputMethodType_Duplicate::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_Duplicate*>(profile);
}

bool InputMethodType_Duplicate::RumbleSupported()
{
    return true;
}

void InputMethodType_Duplicate::UpdateControlsPre()
{}

void InputMethodType_Duplicate::UpdateControlsPost()
{}

InputMethod* InputMethodType_Duplicate::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    int found = 0;

    for(int p = 1; p <= maxLocalPlayers; p++)
    {
        if(p > numPlayers)
            continue;

        if(!Player[p].Controls.Drop || !Player[p].Controls.Up)
            continue;

        if(p - 1 >= (int)active_methods.size())
            continue;

        if(!active_methods[p - 1])
            continue;

        bool allowed = true;

        for(InputMethod* method : active_methods)
        {
            if(!method)
                continue;

            InputMethod_Duplicate* m = dynamic_cast<InputMethod_Duplicate*>(method);

            if(m && m->player_no == p)
            {
                allowed = false;
                break;
            }
        }

        if(!allowed)
            continue;

        found = p;
        break;
    }

    InputMethod_Duplicate* method = new(std::nothrow) InputMethod_Duplicate;

    if(!method)
        return nullptr;

    method->player_no = found;

    method->Name = "Duplicate P" + std::to_string(found);
    method->Type = this;

    return (InputMethod*)method;
}

/*-----------------------*\
|| OPTIONAL METHODS      ||
\*-----------------------*/

// How many per-type special options are there?
size_t InputMethodType_Duplicate::GetOptionCount()
{
    return 1;
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount() returns 0.
// get a char* describing the option
const char* InputMethodType_Duplicate::GetOptionName(size_t i)
{
    if(i == 0)
        return "PRESS DROP & UP";

    return nullptr;
}

// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodType_Duplicate::GetOptionValue(size_t i)
{
    UNUSED(i);
    return nullptr;
}

// called when A is pressed; allowed to interrupt main game loop
bool InputMethodType_Duplicate::OptionChange(size_t i)
{
    UNUSED(i);
    return false;
}

// called when left is pressed
bool InputMethodType_Duplicate::OptionRotateLeft(size_t i)
{
    UNUSED(i);
    return false;
}

// called when right is pressed
bool InputMethodType_Duplicate::OptionRotateRight(size_t i)
{
    UNUSED(i);
    return false;
}

void InputMethodType_Duplicate::SaveConfig_Custom(IniProcessing* ctl)
{
    UNUSED(ctl);
}

void InputMethodType_Duplicate::LoadConfig_Custom(IniProcessing* ctl)
{
    UNUSED(ctl);
}

} // namespace Controls


================================================
FILE: src/control/duplicate.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef DUPLICATE_H
#define DUPLICATE_H

#include "../controls.h"

namespace Controls
{

class InputMethod_Duplicate : public InputMethod
{
public:
    using InputMethod::Type;
    using InputMethod::Profile;

    int player_no = 1;

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);
};

class InputMethodProfile_Duplicate : public InputMethodProfile
{
public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    InputMethodProfile_Duplicate();

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);
};

class InputMethodType_Duplicate : public InputMethodType
{
private:
    InputMethodProfile *AllocateProfile() noexcept;

public:
    using InputMethodType::Name;
    using InputMethodType::m_profiles;

    InputMethodType_Duplicate();

    bool TestProfileType(InputMethodProfile *profile);
    bool RumbleSupported();

    void UpdateControlsPre();
    void UpdateControlsPost();

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept;

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
public:
    // How many per-type special options are there?
    size_t GetOptionCount();
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount() returns 0.
    // get a char* describing the option
    const char *GetOptionName(size_t i);
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange(size_t i);
    // called when left is pressed
    bool OptionRotateLeft(size_t i);
    // called when right is pressed
    bool OptionRotateRight(size_t i);

protected:
    void SaveConfig_Custom(IniProcessing *ctl);
    void LoadConfig_Custom(IniProcessing *ctl);
};

} // namespace Controls

#endif // DUPLICATE_H


================================================
FILE: src/control/input_16m.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>
#include <nds.h>

#include "globals.h"
#include "game_main.h"

#include "core/render.h"
#include "editor/new_editor.h"

#include "controls.h"
#include "control/input_16m.h"
#include "control/controls_strings.h"

#include "main/menu_main.h"

#define buttonRight Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Right]
#define buttonLeft  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Left]
#define buttonUp    Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Up]
#define buttonDown  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Down]

const std::string* KEYNAMES[32] = {
 &g_controlsStrings.tdsButtonA,   &g_controlsStrings.tdsButtonB, &g_controlsStrings.tdsButtonSelect, &g_controlsStrings.tdsButtonStart,
 &buttonRight,                    &buttonLeft,                   &buttonUp,                     &buttonDown,
 &g_controlsStrings.tdsButtonR,   &g_controlsStrings.tdsButtonL, &g_controlsStrings.tdsButtonX, &g_controlsStrings.tdsButtonY,
 &g_mainMenu.caseNone,            &g_mainMenu.caseNone,          &g_mainMenu.caseNone,          &g_mainMenu.caseNone,
 &g_mainMenu.caseNone,            &g_mainMenu.caseNone,          &g_mainMenu.caseNone,          &g_mainMenu.caseNone,
 &g_controlsStrings.tdsCasePen,   &g_mainMenu.caseNone,          &g_mainMenu.caseNone,          &g_mainMenu.caseNone,
 &g_mainMenu.caseNone,            &g_mainMenu.caseNone,          &g_mainMenu.caseNone,          &g_mainMenu.caseNone,
 &g_mainMenu.caseNone,            &g_mainMenu.caseNone,          &g_mainMenu.caseNone,          &g_mainMenu.caseNone
};

enum KEYID {
 KEYID_A=0,
 KEYID_B=1,
 KEYID_SELECT=2,
 KEYID_START=3,
 KEYID_RIGHT=4,
 KEYID_LEFT=5,
 KEYID_UP=6,
 KEYID_DOWN=7,
 KEYID_R=8,
 KEYID_L=9,
 KEYID_X=10,
 KEYID_Y=11,

 KEYID_TOUCH=20,
};

namespace Controls
{

// helper functions


/*===============================================*\
|| implementation for InputMethod_16M            ||
\*===============================================*/

InputMethod_16M::~InputMethod_16M()
{
    InputMethodType_16M* t = dynamic_cast<InputMethodType_16M*>(this->Type);

    if(!t)
        return;

    t->m_numPlayers --;
}

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_16M::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    InputMethodType_16M* k = dynamic_cast<InputMethodType_16M*>(this->Type);
    InputMethodProfile_16M* p = dynamic_cast<InputMethodProfile_16M*>(this->Profile);

    if(!k || !p)
        return false;

    uint32_t keys_held = keysCurrent();

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_start;
        size_t key_max;
        bool activate = false;

        if(a == 0)
        {
            keys = p->m_keys;
            keys2 = p->m_keys2;
            key_start = 0;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = p->m_cursor_keys2;
            key_start = 4;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = p->m_editor_keys;
            keys2 = p->m_editor_keys2;
            key_start = 4;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = p->m_hotkeys;
            keys2 = p->m_hotkeys2;
            key_start = 0;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = key_start; i < key_max; i++)
        {
            int key;

            if(keys)
                key = keys[i];
            else
                key = null_key;

            int key2 = keys2[i];

            bool* b;

            if(a == 0)
            {
                b = &PlayerControls::GetButton(c, i);
                *b = false;
            }
            else if(a == 1)
            {
                b = &CursorControls::GetButton(m, i);
            }
            else if(a == 2)
            {
                b = &EditorControls::GetButton(e, i);
            }
            else
            {
                b = &activate;
                *b = false;
            }

            if(key != null_key && BIT(key) & keys_held)
                *b = true;
            else if(key2 != null_key && BIT(key2) & keys_held)
                *b = true;

            if(a == 3 && *b)
                h[i] = player;
        }
    }

    num_t* const scroll[4] = {&e.ScrollUp, &e.ScrollDown, &e.ScrollLeft, &e.ScrollRight};

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_editor_keys[i];
        int key2 = p->m_editor_keys2[i];

        if(key != null_key && BIT(key) & keys_held)
            *scroll[i] += 10;
        else if(key2 != null_key && BIT(key2) & keys_held)
            *scroll[i] += 10;
    }

    bool cursor[4];

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_cursor_keys2[i];
        cursor[i] = (key != null_key && BIT(key) & keys_held);
    }

    // Cursor control (UDLR)
    if(cursor[0] || cursor[1] || cursor[2] || cursor[3])
    {
        if(m.X < 0)
            m.X = XRender::TargetW / 2;

        if(m.Y < 0)
            m.Y = XRender::TargetH / 2;

        if(cursor[3])
            m.X += 16;

        if(cursor[2])
            m.X -= 16;

        if(cursor[1])
            m.Y += 16;

        if(cursor[0])
            m.Y -= 16;

        if(m.X < 0)
            m.X = 0;
        else if(m.X >= XRender::TargetW)
            m.X = XRender::TargetW - 1;

        if(m.Y < 0)
            m.Y = 0;
        else if(m.Y >= XRender::TargetH)
            m.Y = XRender::TargetH - 1;

        m.Move = true;
    }

    // one may uncomment this to quickly simulate controller disconnection for debugging purposes
    // if(c.Up && c.Down)
    //     return false;

    return true;
}

void InputMethod_16M::Rumble(int ms, float strength)
{
    UNUSED(ms);
    UNUSED(strength);
}

StatusInfo InputMethod_16M::GetStatus()
{
    return XPower::devicePowerStatus();
}

/*===============================================*\
|| implementation for InputMethodProfile_16M     ||
\*===============================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_16M::InputMethodProfile_16M()
{
    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
    {
        this->m_keys[i] = null_key;
        this->m_keys2[i] = null_key;
    }

    for(size_t i = 0; i < CursorControls::n_buttons; i++)
        this->m_cursor_keys2[i] = null_key;

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
    {
        this->m_editor_keys[i] = null_key;
        this->m_editor_keys2[i] = null_key;
    }

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        this->m_hotkeys[i] = null_key;
        this->m_hotkeys2[i] = null_key;
    }

    this->m_keys[PlayerControls::Buttons::Up] = KEYID_UP;
    this->m_keys[PlayerControls::Buttons::Down] = KEYID_DOWN;
    this->m_keys[PlayerControls::Buttons::Left] = KEYID_LEFT;
    this->m_keys[PlayerControls::Buttons::Right] = KEYID_RIGHT;
    this->m_keys[PlayerControls::Buttons::Jump] = KEYID_B;
    this->m_keys[PlayerControls::Buttons::AltJump] = KEYID_A;
    this->m_keys[PlayerControls::Buttons::Run] = KEYID_Y;
    this->m_keys[PlayerControls::Buttons::AltRun] = KEYID_X;
    this->m_keys[PlayerControls::Buttons::Drop] = KEYID_SELECT;
    this->m_keys[PlayerControls::Buttons::Start] = KEYID_START;

    this->m_editor_keys[EditorControls::Buttons::ScrollUp] = KEYID_UP;
    this->m_editor_keys[EditorControls::Buttons::ScrollDown] = KEYID_DOWN;
    this->m_editor_keys[EditorControls::Buttons::ScrollLeft] = KEYID_LEFT;
    this->m_editor_keys[EditorControls::Buttons::ScrollRight] = KEYID_RIGHT;
    this->m_editor_keys[EditorControls::Buttons::FastScroll] = KEYID_A;
    this->m_editor_keys[EditorControls::Buttons::ModeSelect] = KEYID_B;
    this->m_editor_keys[EditorControls::Buttons::ModeErase] = KEYID_Y;
    this->m_editor_keys[EditorControls::Buttons::PrevSection] = KEYID_L;
    this->m_editor_keys[EditorControls::Buttons::NextSection] = KEYID_R;
    this->m_editor_keys[EditorControls::Buttons::SwitchScreens] = KEYID_SELECT;
    this->m_editor_keys[EditorControls::Buttons::TestPlay] = KEYID_START;

    this->m_hotkeys[Hotkeys::Buttons::VanillaCam] = KEYID_L;

    this->m_altMenuControls = true;
}

bool InputMethodProfile_16M::PollPrimaryButton(ControlsClass c, size_t i)
{
    if(c == ControlsClass::Cursor)
        return true;

    // note: m_canPoll is initialized to false
    InputMethodType_16M* k = dynamic_cast<InputMethodType_16M*>(this->Type);

    if(!k)
        return false;

    uint32_t keys_held = keysCurrent();

    int key;

    for(key = 0; key < 32; key++)
    {
        if(BIT(key) & keys_held)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == 32)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    this->m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        // BAD!
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key
    // if a button's secondary key (including the current one) is the new key, delete it.
    // if a button's primary key (excluding the current one) is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, replace it with the button the player is replacing.
    for(size_t j = 0; j < key_max; j++)
    {
        if(keys2[j] == key)
            keys2[j] = null_key;
        else if(i != j && keys[j] == key)
        {
            if(keys2[j] != null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else
                keys[j] = keys[i];
        }
    }

    keys[i] = key;
    return true;
}

bool InputMethodProfile_16M::PollSecondaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    InputMethodType_16M* k = dynamic_cast<InputMethodType_16M*>(this->Type);

    if(!k)
        return false;

    uint32_t keys_held = keysCurrent();

    int key;

    for(key = 0; key < 32; key++)
    {
        if(BIT(key) & keys_held)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == 32)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = nullptr;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        // BAD!
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key

    // if the current button's primary key is the new key,
    //     delete its secondary key instead of setting it.
    if(keys && keys[i] == key)
    {
        keys2[i] = null_key;
        return true;
    }

    // if another button's secondary key is the new key, delete it.
    // if another button's primary key is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, if this button's secondary key is defined, overwrite the other's with this.
    //     if all else fails, overwrite the other button's with this button's PRIMARY key and assign
    //         this button's PRIMARY key instead

    bool can_do_secondary = true;

    for(size_t j = 0; j < key_max; j++)
    {
        if(i != j && keys2[j] == key)
        {
            keys2[j] = null_key;
        }
        else if(keys && i != j && keys[j] == key)
        {
            if(keys2[j] != null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else if(keys2[i] != null_key)
            {
                keys[j] = keys2[i];
            }
            else
            {
                keys[j] = keys[i];
                can_do_secondary = false;
            }
        }
    }

    if(can_do_secondary)
        keys2[i] = key;
    else if(keys)
        keys[i] = key;

    return true;
}

bool InputMethodProfile_16M::DeletePrimaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
    }
    else if(c == ControlsClass::Cursor)
    {
        return false;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
    }
    else
    {
        // BAD!
        return false;
    }

    if(keys2[i] != null_key)
    {
        keys[i] = keys2[i];
        keys2[i] = null_key;
        return true;
    }

    if(c == ControlsClass::Player)
        return false;

    if(keys[i] != null_key)
    {
        keys[i] = null_key;
        return true;
    }

    return false;
}

bool InputMethodProfile_16M::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    int* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return false;

    if(keys2[i] != null_key)
    {
        keys2[i] = null_key;
        return true;
    }

    return false;
}

const char* InputMethodProfile_16M::NamePrimaryButton(ControlsClass c, size_t i)
{
    int* keys;

    if(c == ControlsClass::Player)
        keys = this->m_keys;
    else if(c == ControlsClass::Cursor)
        return g_controlsStrings.tdsCasePen.c_str();
    else if(c == ControlsClass::Editor)
        keys = this->m_editor_keys;
    else if(c == ControlsClass::Hotkey)
        keys = this->m_hotkeys;
    else
        return "";

    if(keys[i] == null_key)
        return g_mainMenu.caseNone.c_str();

    if(keys[i] < 0 || keys[i] >= 32)
        return g_controlsStrings.sharedCaseInvalid.c_str();

    return KEYNAMES[keys[i]]->c_str();
}

const char* InputMethodProfile_16M::NameSecondaryButton(ControlsClass c, size_t i)
{
    int* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return "";

    if(keys2[i] == null_key)
        return "";

    if(keys2[i] < 0 || keys2[i] >= 32)
        return g_controlsStrings.sharedCaseInvalid.c_str();

    return KEYNAMES[keys2[i]]->c_str();
}

void InputMethodProfile_16M::SaveConfig(IniProcessing* ctl)
{
    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->setValue(name, keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            ctl->setValue(name2, keys2[i]);
        }
    }
}

void InputMethodProfile_16M::LoadConfig(IniProcessing* ctl)
{
    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->read(name, keys[i], keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            ctl->read(name2, keys2[i], keys2[i]);
        }
    }
}

/*===============================================*\
|| implementation for InputMethodType_16M        ||
\*===============================================*/

InputMethodProfile* InputMethodType_16M::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_16M;
}

InputMethodType_16M::InputMethodType_16M()
{
    this->Name = "NDS";
}

InputMethodType_16M::~InputMethodType_16M()
{
}

bool InputMethodType_16M::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_16M*>(profile);
}

bool InputMethodType_16M::RumbleSupported()
{
    return false;
}

void InputMethodType_16M::UpdateControlsPre()
{
    scanKeys();
}

void InputMethodType_16M::UpdateControlsPost()
{
    uint32_t keys_pressed = keysDown();
    uint32_t keys_held = keysCurrent();

    // handle the mouse
    int tx, ty;
    touchPosition pos;
    touchRead(&pos);
    XRender::mapToScreen(pos.px, pos.py, &tx, &ty);

    if(keys_pressed & KEY_TOUCH)
    {
        if((LevelEditor || MagicHand) && ty > 40 && !editorScreen.active)
        {
            int distance2 = (m_lastTouchX - tx)*(m_lastTouchX - tx)
                + (m_lastTouchY - ty)*(m_lastTouchY - ty);

            if(distance2 < 64)
                m_click_accepted = true;
            else
                m_click_accepted = false;
        }
        else
            m_click_accepted = true;
    }

    if(keys_held & KEY_TOUCH)
    {
        if(tx - m_lastTouchX < -1 || tx - m_lastTouchX > 1
            || ty - m_lastTouchY < -1 || ty - m_lastTouchY > 1)
        {
            SharedCursor.Move = true;
            SharedCursor.X = tx;
            SharedCursor.Y = ty;

            m_lastTouchX = tx;
            m_lastTouchY = ty;
        }

        if(m_click_accepted)
        {
            SharedCursor.Primary = true;
        }
    }
}

InputMethod* InputMethodType_16M::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    if(this->m_numPlayers != this->m_lastNumPlayers)
    {
        // this ensures that keys that were held when a keyboard method was removed cannot be polled to add that method back
        if(this->m_numPlayers < this->m_lastNumPlayers)
            this->m_canPoll = false;

        this->m_lastNumPlayers = this->m_numPlayers;
    }

    if(this->m_numPlayers >= m_maxPlayers)
    {
        // ban polling in case things change
        this->m_canPoll = false;
        return nullptr;
    }

    uint32_t keys_held = keysCurrent();

    // ban attachment from active profile, must find new profile
    int key;
    InputMethodProfile* target_profile = nullptr;

    for(key = 0; key < 32; key++)
    {
        if((BIT(key) & keys_held) == 0)
            continue;

        bool allowed = true;

        // ban attachment from active profile
        for(InputMethod* method : active_methods)
        {
            if(!allowed)
                break;

            if(!method)
                continue;

            InputMethodProfile_16M* p = dynamic_cast<InputMethodProfile_16M*>(method->Profile);

            if(!p)
                continue;

            for(size_t i = 0; i < PlayerControls::n_buttons; i++)
            {
                if(p->m_keys[i] == key || p->m_keys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }

            if(LevelEditor)
            {
                for(size_t i = 0; i < EditorControls::n_buttons; i++)
                {
                    if(p->m_editor_keys[i] == key || p->m_editor_keys2[i] == key)
                    {
                        allowed = false;
                        break;
                    }
                }
            }

            for(size_t i = 0; i < CursorControls::n_buttons; i++)
            {
                if(p->m_cursor_keys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }

            for(size_t i = 0; i < Hotkeys::n_buttons; i++)
            {
                if(p->m_hotkeys[i] == key || p->m_hotkeys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }
        }

        if(!allowed)
            continue;

        // which player index is connecting?
        int my_index = 0;

        for(const InputMethod* method : active_methods)
        {
            if(!method)
                break;

            my_index ++;
        }

        // try to find profile matching the keypress
        for(int i = -1; i < (int)this->m_profiles.size(); i++)
        {
            // start with the most recent profile for this player index
            InputMethodProfile* profile;

            if(i == -1)
                profile = this->GetDefaultProfile(my_index);
            else
                profile = this->m_profiles[i];

            if(!profile)
                continue;

            InputMethodProfile_16M* p = dynamic_cast<InputMethodProfile_16M*>(profile);

            if(!p)
                continue;

            for(size_t j = 0; j < PlayerControls::n_buttons; j++)
            {
                if(p->m_keys[j] == key || p->m_keys2[j] == key)
                {
                    target_profile = profile;
                    break;
                }
            }

            if(target_profile)
                break;
        }

        if(target_profile || this->m_profiles.empty())
            break;
    }

    // if didn't find any key allow poll in future but return false
    if(key == 32)
    {
        this->m_canPoll = true;
        return nullptr;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return nullptr;

    // we're going to create a new keyboard!
    // reset canPoll for next time
    this->m_canPoll = false;

    InputMethod_16M* method = new(std::nothrow) InputMethod_16M;

    if(!method)
        return nullptr;

    method->Name = this->Name;
    method->Type = this;
    method->Profile = target_profile;

    this->m_numPlayers ++;

    return (InputMethod*)method;
}

/*-----------------------*\
|| OPTIONAL METHODS      ||
\*-----------------------*/
bool InputMethodType_16M::ConsumeEvent(const SDL_Event* ev)
{
    UNUSED(ev);
    return false;
}

// optional function allowing developer to associate device information with profile, etc
bool InputMethodType_16M::SetProfile_Custom(InputMethod* method, int player_no, InputMethodProfile* profile,
        const std::vector<InputMethod*>& active_methods)
{
    if(!method || !profile || player_no < 0 || player_no >= maxLocalPlayers)
        return false;

    // prevent duplicates of a profile from ever being set
    for(InputMethod* o_method : active_methods)
    {
        if(!o_method)
            continue;

        if(o_method != method && o_method->Profile == profile)
            return false;
    }

    m_canPoll = false;
    return true;
}

// How many per-type special options are there?
size_t InputMethodType_16M::GetOptionCount()
{
    return 1;
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount() returns 0.
// get a char* describing the option
const char* InputMethodType_16M::GetOptionName(size_t i)
{
    if(i == 0)
        return g_controlsStrings.sharedOptionMaxPlayers.c_str();

    return nullptr;
}

// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodType_16M::GetOptionValue(size_t i)
{
    if(i == 0)
    {
        static char buf[3];
        snprintf(buf, 3, "%d", this->m_maxPlayers);
        return buf;
    }

    return nullptr;
}

// called when A is pressed; allowed to interrupt main game loop
bool InputMethodType_16M::OptionChange(size_t i)
{
    if(i == 0)
    {
        this->m_maxPlayers ++;

        if(this->m_maxPlayers > 2)
            this->m_maxPlayers = 1;

        return true;
    }

    return false;
}

// called when left is pressed
bool InputMethodType_16M::OptionRotateLeft(size_t i)
{
    if(i == 0)
    {
        if(this->m_maxPlayers > 1)
        {
            this->m_maxPlayers --;
            return true;
        }
    }

    return false;
}

// called when right is pressed
bool InputMethodType_16M::OptionRotateRight(size_t i)
{
    if(i == 0)
    {
        if(this->m_maxPlayers < 2)
        {
            this->m_maxPlayers ++;
            return true;
        }
    }

    return false;
}

void InputMethodType_16M::SaveConfig_Custom(IniProcessing* ctl)
{
    ctl->setValue("max-players", this->m_maxPlayers);
}

void InputMethodType_16M::LoadConfig_Custom(IniProcessing* ctl)
{
    ctl->read("max-players", this->m_maxPlayers, 2);
}

} // namespace Controls


================================================
FILE: src/control/input_16m.h
================================================
#ifndef INPUT_16M_H
#define INPUT_16M_H

#include "../controls.h"

namespace Controls
{

constexpr int null_key = -1;

class InputMethod_16M : public InputMethod
{
public:
    using InputMethod::Type;
    using InputMethod::Profile;

    ~InputMethod_16M();

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);

    StatusInfo GetStatus();
};

class InputMethodProfile_16M : public InputMethodProfile
{
private:
    bool m_canPoll = false;

public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    int m_keys[PlayerControls::n_buttons] = {null_key};
    int m_keys2[PlayerControls::n_buttons] = {null_key};

    int m_editor_keys[EditorControls::n_buttons] = {null_key};
    int m_editor_keys2[EditorControls::n_buttons] = {null_key};

    int m_cursor_keys2[CursorControls::n_buttons] = {null_key};

    int m_hotkeys[Hotkeys::n_buttons] = {null_key};
    int m_hotkeys2[Hotkeys::n_buttons] = {null_key};

    InputMethodProfile_16M();

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);
};

class InputMethodType_16M : public InputMethodType
{
private:
    bool m_canPoll = false;

    int m_lastNumPlayers = 0;
    uint16_t m_lastTouchX = 0;
    uint16_t m_lastTouchY = 0;
    bool m_click_accepted = false;

    InputMethodProfile *AllocateProfile() noexcept;

public:
    int m_numPlayers = 0;

    // options
    int m_maxPlayers = 1;

    using InputMethodType::Name;
    using InputMethodType::m_profiles;

    InputMethodType_16M();
    ~InputMethodType_16M();

    bool TestProfileType(InputMethodProfile *profile);
    bool RumbleSupported();

    void UpdateControlsPre();
    void UpdateControlsPost();

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept;

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
protected:
    // optional function allowing developer to associate device information with profile, etc
    // if developer wants to forbid assignment, return false
    bool SetProfile_Custom(InputMethod *method, int player_no, InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods);

public:
    bool ConsumeEvent(const SDL_Event *ev);

    // How many per-type special options are there?
    size_t GetOptionCount();
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount() returns 0.
    // get a char* describing the option
    const char *GetOptionName(size_t i);
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange(size_t i);
    // called when left is pressed
    bool OptionRotateLeft(size_t i);
    // called when right is pressed
    bool OptionRotateRight(size_t i);

protected:
    void SaveConfig_Custom(IniProcessing *ctl);
    void LoadConfig_Custom(IniProcessing *ctl);
};

} // namespace Controls

#endif // #ifndef INPUT_16M_H


================================================
FILE: src/control/input_3ds.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <3ds.h>
#include <algorithm>

#include "globals.h"
#include "game_main.h"

#include "core/render.h"
#include "editor/new_editor.h"

#include "controls.h"
#include "control/input_3ds.h"

#include "control/controls_strings.h"

#include "main/menu_main.h"

#include <Logger/logger.h>

static std::string s_buffer;

#define buttonRight Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Right]
#define buttonLeft  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Left]
#define buttonUp    Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Up]
#define buttonDown  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Down]

const std::string* KEYNAMES[32] = {
 &g_controlsStrings.tdsButtonA,   &g_controlsStrings.tdsButtonB, &g_controlsStrings.tdsButtonSelect, &g_controlsStrings.tdsButtonStart,
 &buttonRight,                    &buttonLeft,                   &buttonUp,                     &buttonDown,
 &g_controlsStrings.tdsButtonR,   &g_controlsStrings.tdsButtonL, &g_controlsStrings.tdsButtonX, &g_controlsStrings.tdsButtonY,
 &g_mainMenu.caseNone,            &g_mainMenu.caseNone,          &g_controlsStrings.tdsButtonZL, &g_controlsStrings.tdsButtonZR,
 &g_mainMenu.caseNone,            &g_mainMenu.caseNone,          &g_mainMenu.caseNone,          &g_mainMenu.caseNone,
 &g_controlsStrings.tdsCasePen,   &g_mainMenu.caseNone,          &g_mainMenu.caseNone,          &g_mainMenu.caseNone,
 &buttonRight,                    &buttonLeft,                   &buttonUp,                     &buttonDown,
 &buttonRight,                    &buttonLeft,                   &buttonUp,                     &buttonDown,
};

enum KEYID {
    KEYID_A=0,
    KEYID_B=1,
    KEYID_SELECT=2,
    KEYID_START=3,
    KEYID_DRIGHT=4,
    KEYID_DLEFT=5,
    KEYID_DUP=6,
    KEYID_DDOWN=7,
    KEYID_R=8,
    KEYID_L=9,
    KEYID_X=10,
    KEYID_Y=11,
    KEYID_ZL=14,
    KEYID_ZR=15,

    KEYID_TOUCH=20,
    KEYID_CSTICK_RIGHT=24,
    KEYID_CSTICK_LEFT=25,
    KEYID_CSTICK_UP=26,
    KEYID_CSTICK_DOWN=27,
    KEYID_PAD_RIGHT=28,
    KEYID_PAD_LEFT=29,
    KEYID_PAD_UP=30,
    KEYID_PAD_DOWN=31
};

namespace Controls
{

// helper functions


/*===============================================*\
|| implementation for InputMethod_3DS            ||
\*===============================================*/

InputMethod_3DS::~InputMethod_3DS()
{
    InputMethodType_3DS* t = dynamic_cast<InputMethodType_3DS*>(this->Type);

    if(!t)
        return;

    t->m_numPlayers --;
}

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_3DS::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    InputMethodType_3DS* k = dynamic_cast<InputMethodType_3DS*>(this->Type);
    InputMethodProfile_3DS* p = dynamic_cast<InputMethodProfile_3DS*>(this->Profile);

    if(!k || !p)
        return false;

    uint32_t keys_held = hidKeysHeld();

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_start;
        size_t key_max;
        bool activate = false;

        if(a == 0)
        {
            keys = p->m_keys;
            keys2 = p->m_keys2;
            key_start = 0;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = p->m_cursor_keys2;
            key_start = 4;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = p->m_editor_keys;
            keys2 = p->m_editor_keys2;
            key_start = 4;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = p->m_hotkeys;
            keys2 = p->m_hotkeys2;
            key_start = 0;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = key_start; i < key_max; i++)
        {
            int key;

            if(keys)
                key = keys[i];
            else
                key = null_key;

            int key2 = keys2[i];

            bool* b;

            if(a == 0)
            {
                b = &PlayerControls::GetButton(c, i);
                *b = false;
            }
            else if(a == 1)
            {
                b = &CursorControls::GetButton(m, i);
            }
            else if(a == 2)
            {
                b = &EditorControls::GetButton(e, i);
            }
            else
            {
                b = &activate;
                *b = false;
            }

            if(key != null_key && BIT(key) & keys_held)
                *b = true;
            else if(key2 != null_key && BIT(key2) & keys_held)
                *b = true;

            if(a == 3 && *b)
                h[i] = player;
        }
    }

    num_t* const scroll[4] = {&e.ScrollUp, &e.ScrollDown, &e.ScrollLeft, &e.ScrollRight};

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_editor_keys[i];
        int key2 = p->m_editor_keys2[i];

        if(key != null_key && BIT(key) & keys_held)
            *scroll[i] += 10;
        else if(key2 != null_key && BIT(key2) & keys_held)
            *scroll[i] += 10;
    }

    bool cursor[4];

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_cursor_keys2[i];
        cursor[i] = (key != null_key && BIT(key) & keys_held);
    }

    // Cursor control (UDLR)
    if(cursor[0] || cursor[1] || cursor[2] || cursor[3])
    {
        if(m.X < 0)
            m.X = XRender::TargetW / 2;

        if(m.Y < 0)
            m.Y = XRender::TargetH / 2;

        if(cursor[3])
            m.X += 16;

        if(cursor[2])
            m.X -= 16;

        if(cursor[1])
            m.Y += 16;

        if(cursor[0])
            m.Y -= 16;

        if(m.X < 0)
            m.X = 0;
        else if(m.X >= XRender::TargetW)
            m.X = XRender::TargetW - 1;

        if(m.Y < 0)
            m.Y = 0;
        else if(m.Y >= XRender::TargetH)
            m.Y = XRender::TargetH - 1;

        m.Move = true;
    }

    // one may uncomment this to quickly simulate controller disconnection for debugging purposes
    // if(c.Up && c.Down)
    //     return false;

    return true;
}

void InputMethod_3DS::Rumble(int ms, float strength)
{
    UNUSED(ms);
    UNUSED(strength);
}

StatusInfo InputMethod_3DS::GetStatus()
{
    return XPower::devicePowerStatus();
}

/*===============================================*\
|| implementation for InputMethodProfile_3DS     ||
\*===============================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_3DS::InputMethodProfile_3DS()
{
    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
    {
        this->m_keys[i] = null_key;
        this->m_keys2[i] = null_key;
    }

    for(size_t i = 0; i < CursorControls::n_buttons; i++)
        this->m_cursor_keys2[i] = null_key;

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
    {
        this->m_editor_keys[i] = null_key;
        this->m_editor_keys2[i] = null_key;
    }

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        this->m_hotkeys[i] = null_key;
        this->m_hotkeys2[i] = null_key;
    }

    this->m_keys[PlayerControls::Buttons::Up] = KEYID_DUP;
    this->m_keys[PlayerControls::Buttons::Down] = KEYID_DDOWN;
    this->m_keys[PlayerControls::Buttons::Left] = KEYID_DLEFT;
    this->m_keys[PlayerControls::Buttons::Right] = KEYID_DRIGHT;
    this->m_keys[PlayerControls::Buttons::Jump] = KEYID_B;
    this->m_keys[PlayerControls::Buttons::AltJump] = KEYID_A;
    this->m_keys[PlayerControls::Buttons::Run] = KEYID_Y;
    this->m_keys[PlayerControls::Buttons::AltRun] = KEYID_X;
    this->m_keys[PlayerControls::Buttons::Drop] = KEYID_SELECT;
    this->m_keys[PlayerControls::Buttons::Start] = KEYID_START;

    this->m_keys2[PlayerControls::Buttons::Up] = KEYID_PAD_UP;
    this->m_keys2[PlayerControls::Buttons::Down] = KEYID_PAD_DOWN;
    this->m_keys2[PlayerControls::Buttons::Left] = KEYID_PAD_LEFT;
    this->m_keys2[PlayerControls::Buttons::Right] = KEYID_PAD_RIGHT;

    this->m_editor_keys[EditorControls::Buttons::ScrollUp] = KEYID_PAD_UP;
    this->m_editor_keys[EditorControls::Buttons::ScrollDown] = KEYID_PAD_DOWN;
    this->m_editor_keys[EditorControls::Buttons::ScrollLeft] = KEYID_PAD_LEFT;
    this->m_editor_keys[EditorControls::Buttons::ScrollRight] = KEYID_PAD_RIGHT;
    this->m_editor_keys[EditorControls::Buttons::FastScroll] = KEYID_L;
    this->m_editor_keys[EditorControls::Buttons::ModeSelect] = KEYID_B;
    this->m_editor_keys[EditorControls::Buttons::ModeErase] = KEYID_Y;
    this->m_editor_keys[EditorControls::Buttons::PrevSection] = KEYID_DLEFT;
    this->m_editor_keys[EditorControls::Buttons::NextSection] = KEYID_DRIGHT;
    this->m_editor_keys[EditorControls::Buttons::SwitchScreens] = KEYID_SELECT;
    this->m_editor_keys[EditorControls::Buttons::TestPlay] = KEYID_START;

    this->m_hotkeys[Hotkeys::Buttons::VanillaCam] = KEYID_L;

    this->m_altMenuControls = true;
}

bool InputMethodProfile_3DS::PollPrimaryButton(ControlsClass c, size_t i)
{
    if(c == ControlsClass::Cursor)
        return true;

    // note: m_canPoll is initialized to false
    InputMethodType_3DS* k = dynamic_cast<InputMethodType_3DS*>(this->Type);

    if(!k)
        return false;

    uint32_t keys_held = hidKeysHeld();

    int key;

    for(key = 0; key < 32; key++)
    {
        if(BIT(key) & keys_held)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == 32)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    this->m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling 3DS primary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key
    // if a button's secondary key (including the current one) is the new key, delete it.
    // if a button's primary key (excluding the current one) is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, replace it with the button the player is replacing.
    for(size_t j = 0; j < key_max; j++)
    {
        if(keys2[j] == key)
            keys2[j] = null_key;
        else if(i != j && keys[j] == key)
        {
            if(keys2[j] != null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else
                keys[j] = keys[i];
        }
    }

    keys[i] = key;
    return true;
}

bool InputMethodProfile_3DS::PollSecondaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    InputMethodType_3DS* k = dynamic_cast<InputMethodType_3DS*>(this->Type);

    if(!k)
        return false;

    uint32_t keys_held = hidKeysHeld();

    int key;

    for(key = 0; key < 32; key++)
    {
        if(BIT(key) & keys_held)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == 32)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = nullptr;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling 3DS secondary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key

    // if the current button's primary key is the new key,
    //     delete its secondary key instead of setting it.
    if(keys && keys[i] == key)
    {
        keys2[i] = null_key;
        return true;
    }

    // if another button's secondary key is the new key, delete it.
    // if another button's primary key is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, if this button's secondary key is defined, overwrite the other's with this.
    //     if all else fails, overwrite the other button's with this button's PRIMARY key and assign
    //         this button's PRIMARY key instead

    bool can_do_secondary = true;

    for(size_t j = 0; j < key_max; j++)
    {
        if(i != j && keys2[j] == key)
        {
            keys2[j] = null_key;
        }
        else if(keys && i != j && keys[j] == key)
        {
            if(keys2[j] != null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else if(keys2[i] != null_key)
            {
                keys[j] = keys2[i];
            }
            else
            {
                keys[j] = keys[i];
                can_do_secondary = false;
            }
        }
    }

    if(can_do_secondary)
        keys2[i] = key;
    else if(keys)
        keys[i] = key;

    return true;
}

bool InputMethodProfile_3DS::DeletePrimaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
    }
    else if(c == ControlsClass::Cursor)
    {
        return false;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
    }
    else
    {
        D_pLogWarning("Attempted to delete 3DS input binding of disallowed controls class %d\n", (int)c);
        return false;
    }

    if(keys2[i] != null_key)
    {
        keys[i] = keys2[i];
        keys2[i] = null_key;
        return true;
    }

    if(c == ControlsClass::Player)
        return false;

    if(keys[i] != null_key)
    {
        keys[i] = null_key;
        return true;
    }

    return false;
}

bool InputMethodProfile_3DS::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    int* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return false;

    if(keys2[i] != null_key)
    {
        keys2[i] = null_key;
        return true;
    }

    return false;
}

const char* InputMethodProfile_3DS::NamePrimaryButton(ControlsClass c, size_t i)
{
    int* keys;

    if(c == ControlsClass::Player)
        keys = this->m_keys;
    else if(c == ControlsClass::Cursor)
        return g_controlsStrings.tdsCasePen.c_str();
    else if(c == ControlsClass::Editor)
        keys = this->m_editor_keys;
    else if(c == ControlsClass::Hotkey)
        keys = this->m_hotkeys;
    else
        return "";

    if(keys[i] == null_key)
        return g_mainMenu.caseNone.c_str();

    if(keys[i] < 0 || keys[i] >= 32)
        return g_controlsStrings.sharedCaseInvalid.c_str();

    if(keys[i] >= KEYID_DRIGHT && keys[i] <= KEYID_DDOWN)
    {
        s_buffer = g_controlsStrings.tdsDpad + " " + *KEYNAMES[keys[i]];
        return s_buffer.c_str();
    }

    if(keys[i] >= KEYID_CSTICK_RIGHT && keys[i] <= KEYID_CSTICK_DOWN)
    {
        s_buffer = g_controlsStrings.tdsCstick + " " + *KEYNAMES[keys[i]];
        return s_buffer.c_str();
    }

    if(keys[i] >= KEYID_PAD_RIGHT && keys[i] <= KEYID_PAD_DOWN)
    {
        s_buffer = g_controlsStrings.tdsTstick + " " + *KEYNAMES[keys[i]];
        return s_buffer.c_str();
    }

    return KEYNAMES[keys[i]]->c_str();
}

const char* InputMethodProfile_3DS::NameSecondaryButton(ControlsClass c, size_t i)
{
    int* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return "";

    if(keys2[i] == null_key)
        return "";

    if(keys2[i] < 0 || keys2[i] >= 32)
        return g_controlsStrings.sharedCaseInvalid.c_str();

    if(keys2[i] >= KEYID_DRIGHT && keys2[i] <= KEYID_DDOWN)
    {
        s_buffer = g_controlsStrings.tdsDpad + " " + *KEYNAMES[keys2[i]];
        return s_buffer.c_str();
    }

    if(keys2[i] >= KEYID_CSTICK_RIGHT && keys2[i] <= KEYID_CSTICK_DOWN)
    {
        s_buffer = g_controlsStrings.tdsCstick + " " + *KEYNAMES[keys2[i]];
        return s_buffer.c_str();
    }

    if(keys2[i] >= KEYID_PAD_RIGHT && keys2[i] <= KEYID_PAD_DOWN)
    {
        s_buffer = g_controlsStrings.tdsTstick + " " + *KEYNAMES[keys2[i]];
        return s_buffer.c_str();
    }

    return KEYNAMES[keys2[i]]->c_str();
}

void InputMethodProfile_3DS::SaveConfig(IniProcessing* ctl)
{
    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->setValue(name, keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            ctl->setValue(name2, keys2[i]);
        }
    }
}

void InputMethodProfile_3DS::LoadConfig(IniProcessing* ctl)
{
    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->read(name, keys[i], keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            ctl->read(name2, keys2[i], keys2[i]);
        }
    }
}

/*===============================================*\
|| implementation for InputMethodType_3DS        ||
\*===============================================*/

InputMethodProfile* InputMethodType_3DS::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_3DS;
}

InputMethodType_3DS::InputMethodType_3DS()
{
    this->Name = "3DS";
    hidInit();
}

InputMethodType_3DS::~InputMethodType_3DS()
{
    hidExit();
}

bool InputMethodType_3DS::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_3DS*>(profile);
}

bool InputMethodType_3DS::RumbleSupported()
{
    return false;
}

void InputMethodType_3DS::UpdateControlsPre()
{
    hidScanInput();
}

void InputMethodType_3DS::UpdateControlsPost()
{
    uint32_t keys_pressed = hidKeysDown();
    uint32_t keys_held = hidKeysHeld();

    // handle the mouse
    int tx, ty;
    touchPosition pos;
    hidTouchRead(&pos);
    XRender::mapToScreen(pos.px, pos.py, &tx, &ty);

    if(keys_pressed & KEY_TOUCH)
    {
        if((LevelEditor || MagicHand) && ty > 40 && !editorScreen.active)
        {
            int distance2 = (m_lastTouchX - tx)*(m_lastTouchX - tx)
                + (m_lastTouchY - ty)*(m_lastTouchY - ty);

            if(distance2 < 64)
                m_click_accepted = true;
            else
                m_click_accepted = false;
        }
        else
            m_click_accepted = true;
    }

    if(keys_held & KEY_TOUCH)
    {
        if(tx - m_lastTouchX < -1 || tx - m_lastTouchX > 1
            || ty - m_lastTouchY < -1 || ty - m_lastTouchY > 1)
        {
            SharedCursor.Move = true;
            SharedCursor.X = tx;
            SharedCursor.Y = ty;

            m_lastTouchX = tx;
            m_lastTouchY = ty;
        }

        if(m_click_accepted)
        {
            SharedCursor.Primary = true;
        }
    }
}

InputMethod* InputMethodType_3DS::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    if(this->m_numPlayers != this->m_lastNumPlayers)
    {
        // this ensures that keys that were held when a keyboard method was removed cannot be polled to add that method back
        if(this->m_numPlayers < this->m_lastNumPlayers)
            this->m_canPoll = false;

        this->m_lastNumPlayers = this->m_numPlayers;
    }

    if(this->m_numPlayers >= m_maxPlayers)
    {
        // ban polling in case things change
        this->m_canPoll = false;
        return nullptr;
    }

    uint32_t keys_held = hidKeysHeld();

    // ban attachment from active profile, must find new profile
    int key;
    InputMethodProfile* target_profile = nullptr;

    for(key = 0; key < 32; key++)
    {
        if((BIT(key) & keys_held) == 0)
            continue;

        bool allowed = true;

        // ban attachment from active profile
        for(InputMethod* method : active_methods)
        {
            if(!allowed)
                break;

            if(!method)
                continue;

            InputMethodProfile_3DS* p = dynamic_cast<InputMethodProfile_3DS*>(method->Profile);

            if(!p)
                continue;

            for(size_t i = 0; i < PlayerControls::n_buttons; i++)
            {
                if(p->m_keys[i] == key || p->m_keys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }

            if(LevelEditor)
            {
                for(size_t i = 0; i < EditorControls::n_buttons; i++)
                {
                    if(p->m_editor_keys[i] == key || p->m_editor_keys2[i] == key)
                    {
                        allowed = false;
                        break;
                    }
                }
            }

            for(size_t i = 0; i < CursorControls::n_buttons; i++)
            {
                if(p->m_cursor_keys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }

            for(size_t i = 0; i < Hotkeys::n_buttons; i++)
            {
                if(p->m_hotkeys[i] == key || p->m_hotkeys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }
        }

        if(!allowed)
            continue;

        // which player index is connecting?
        int my_index = 0;

        for(const InputMethod* method : active_methods)
        {
            if(!method)
                break;

            my_index ++;
        }

        // try to find profile matching the keypress
        for(int i = -1; i < (int)this->m_profiles.size(); i++)
        {
            // start with the most recent profile for this player index
            InputMethodProfile* profile;

            if(i == -1)
                profile = this->GetDefaultProfile(my_index);
            else
                profile = this->m_profiles[i];

            if(!profile)
                continue;

            InputMethodProfile_3DS* p = dynamic_cast<InputMethodProfile_3DS*>(profile);

            if(!p)
                continue;

            for(size_t j = 0; j < PlayerControls::n_buttons; j++)
            {
                if(p->m_keys[j] == key || p->m_keys2[j] == key)
                {
                    target_profile = profile;
                    break;
                }
            }

            if(target_profile)
                break;
        }

        if(target_profile || this->m_profiles.empty())
            break;
    }

    // if didn't find any key allow poll in future but return false
    if(key == 32)
    {
        this->m_canPoll = true;
        return nullptr;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return nullptr;

    // we're going to create a new keyboard!
    // reset canPoll for next time
    this->m_canPoll = false;

    InputMethod_3DS* method = new(std::nothrow) InputMethod_3DS;

    if(!method)
        return nullptr;

    method->Name = this->Name;
    method->Type = this;
    method->Profile = target_profile;

    this->m_numPlayers ++;

    return (InputMethod*)method;
}

/*-----------------------*\
|| OPTIONAL METHODS      ||
\*-----------------------*/
bool InputMethodType_3DS::ConsumeEvent(const SDL_Event* ev)
{
    UNUSED(ev);
    return false;
}

// optional function allowing developer to associate device information with profile, etc
bool InputMethodType_3DS::SetProfile_Custom(InputMethod* method, int player_no, InputMethodProfile* profile,
        const std::vector<InputMethod*>& active_methods)
{
    if(!method || !profile || player_no < 0 || player_no >= maxLocalPlayers)
        return false;

    // prevent duplicates of a profile from ever being set
    for(InputMethod* o_method : active_methods)
    {
        if(!o_method)
            continue;

        if(o_method != method && o_method->Profile == profile)
            return false;
    }

    m_canPoll = false;
    return true;
}

// How many per-type special options are there?
size_t InputMethodType_3DS::GetOptionCount()
{
    return 1;
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount() returns 0.
// get a char* describing the option
const char* InputMethodType_3DS::GetOptionName(size_t i)
{
    if(i == 0)
        return g_controlsStrings.sharedOptionMaxPlayers.c_str();

    return nullptr;
}

// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodType_3DS::GetOptionValue(size_t i)
{
    if(i == 0)
    {
        static char buf[3];
        snprintf(buf, 3, "%d", this->m_maxPlayers);
        return buf;
    }

    return nullptr;
}

// called when A is pressed; allowed to interrupt main game loop
bool InputMethodType_3DS::OptionChange(size_t i)
{
    if(i == 0)
    {
        this->m_maxPlayers ++;

        if(this->m_maxPlayers > 2)
            this->m_maxPlayers = 1;

        return true;
    }

    return false;
}

// called when left is pressed
bool InputMethodType_3DS::OptionRotateLeft(size_t i)
{
    if(i == 0)
    {
        if(this->m_maxPlayers > 1)
        {
            this->m_maxPlayers --;
            return true;
        }
    }

    return false;
}

// called when right is pressed
bool InputMethodType_3DS::OptionRotateRight(size_t i)
{
    if(i == 0)
    {
        if(this->m_maxPlayers < 2)
        {
            this->m_maxPlayers ++;
            return true;
        }
    }

    return false;
}

void InputMethodType_3DS::SaveConfig_Custom(IniProcessing* ctl)
{
    ctl->setValue("max-players", this->m_maxPlayers);
}

void InputMethodType_3DS::LoadConfig_Custom(IniProcessing* ctl)
{
    ctl->read("max-players", this->m_maxPlayers, 2);
}

} // namespace Controls


================================================
FILE: src/control/input_3ds.h
================================================
#ifndef INPUT_3DS_H
#define INPUT_3DS_H

#include "../controls.h"

namespace Controls
{

constexpr int null_key = -1;

class InputMethod_3DS : public InputMethod
{
public:
    using InputMethod::Type;
    using InputMethod::Profile;

    ~InputMethod_3DS();

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);

    StatusInfo GetStatus();
};

class InputMethodProfile_3DS : public InputMethodProfile
{
private:
    bool m_canPoll = false;

public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    int m_keys[PlayerControls::n_buttons] = {null_key};
    int m_keys2[PlayerControls::n_buttons] = {null_key};

    int m_editor_keys[EditorControls::n_buttons] = {null_key};
    int m_editor_keys2[EditorControls::n_buttons] = {null_key};

    int m_cursor_keys2[CursorControls::n_buttons] = {null_key};

    int m_hotkeys[Hotkeys::n_buttons] = {null_key};
    int m_hotkeys2[Hotkeys::n_buttons] = {null_key};

    InputMethodProfile_3DS();

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);
};

class InputMethodType_3DS : public InputMethodType
{
private:
    bool m_canPoll = false;

    int m_lastNumPlayers = 0;
    uint16_t m_lastTouchX = 0;
    uint16_t m_lastTouchY = 0;
    bool m_click_accepted = false;

    InputMethodProfile *AllocateProfile() noexcept;

public:
    int m_numPlayers = 0;

    // options
    int m_maxPlayers = 2;

    using InputMethodType::Name;
    using InputMethodType::m_profiles;

    InputMethodType_3DS();
    ~InputMethodType_3DS();

    bool TestProfileType(InputMethodProfile *profile);
    bool RumbleSupported();

    void UpdateControlsPre();
    void UpdateControlsPost();

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept;

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
protected:
    // optional function allowing developer to associate device information with profile, etc
    // if developer wants to forbid assignment, return false
    bool SetProfile_Custom(InputMethod *method, int player_no, InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods);

public:
    bool ConsumeEvent(const SDL_Event *ev);

    // How many per-type special options are there?
    size_t GetOptionCount();
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount() returns 0.
    // get a char* describing the option
    const char *GetOptionName(size_t i);
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange(size_t i);
    // called when left is pressed
    bool OptionRotateLeft(size_t i);
    // called when right is pressed
    bool OptionRotateRight(size_t i);

protected:
    void SaveConfig_Custom(IniProcessing *ctl);
    void LoadConfig_Custom(IniProcessing *ctl);
};

} // namespace Controls

#endif // #ifndef INPUT_3DS_H


================================================
FILE: src/control/input_wii.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>

#include "globals.h"
#include "game_main.h"

#include "core/render.h"

#include "controls.h"
#include "control/input_wii.h"

#include "control/controls_strings.h"
#include "main/menu_main.h"

#include <Logger/logger.h>

#include <wiiuse/wpad.h>


#define WPAD_STICK_LL  0x2000
#define WPAD_STICK_LR  0x4000
#define WPAD_STICK_LU  0x6000
// not technically legal.
#define WPAD_STICK_LD  0x7000
#define WPAD_STICK_RL  0xA000
#define WPAD_STICK_RR  0xC000
#define WPAD_STICK_RU  0xE000
// not technically legal.
#define WPAD_STICK_RD  0xF000

#define WPAD_SHAKE     0x1FFF

#define buttonRight Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Right]
#define buttonLeft  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Left]
#define buttonUp    Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Up]
#define buttonDown  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Down]

bool is_direction(const std::string* s)
{
    return s == &buttonLeft || s == &buttonDown || s == &buttonUp || s == &buttonRight;
}

static constexpr std::array<const uint32_t, 12> wiimote_buttons =      {WPAD_BUTTON_2,                 WPAD_BUTTON_1,                 WPAD_BUTTON_B,                 WPAD_BUTTON_A,                 WPAD_BUTTON_MINUS,                 WPAD_BUTTON_HOME,                 WPAD_BUTTON_LEFT, WPAD_BUTTON_RIGHT, WPAD_BUTTON_DOWN, WPAD_BUTTON_UP, WPAD_BUTTON_PLUS,                 WPAD_SHAKE};
static const std::array<const std::string*, 12> wiimote_button_names = {&g_controlsStrings.wiiButton2, &g_controlsStrings.wiiButton1, &g_controlsStrings.wiiButtonB, &g_controlsStrings.wiiButtonA, &g_controlsStrings.wiiButtonMinus, &g_controlsStrings.wiiButtonHome, &buttonLeft,      &buttonRight,      &buttonDown,      &buttonUp,      &g_controlsStrings.wiiButtonPlus, &g_controlsStrings.wiiShake};

static constexpr std::array<const uint32_t, 6> nunchuck_buttons =      {WPAD_STICK_LL, WPAD_STICK_LR, WPAD_STICK_LU, WPAD_STICK_LD, WPAD_NUNCHUK_BUTTON_Z,         WPAD_NUNCHUK_BUTTON_C};
static const std::array<const std::string*, 6> nunchuck_button_names = {&buttonLeft,   &buttonRight,  &buttonUp,     &buttonDown,   &g_controlsStrings.wiiButtonZ, &g_controlsStrings.wiiButtonC};

static constexpr std::array<const uint32_t, 23> classic_buttons = {WPAD_CLASSIC_BUTTON_UP, WPAD_CLASSIC_BUTTON_LEFT, WPAD_CLASSIC_BUTTON_ZR,         WPAD_CLASSIC_BUTTON_X,         WPAD_CLASSIC_BUTTON_A,         WPAD_CLASSIC_BUTTON_Y,
    WPAD_CLASSIC_BUTTON_B,         WPAD_CLASSIC_BUTTON_ZL,         WPAD_CLASSIC_BUTTON_FULL_R,     WPAD_CLASSIC_BUTTON_PLUS,         WPAD_CLASSIC_BUTTON_HOME,         WPAD_CLASSIC_BUTTON_MINUS,         WPAD_CLASSIC_BUTTON_FULL_L,     WPAD_CLASSIC_BUTTON_DOWN,
    WPAD_CLASSIC_BUTTON_RIGHT, WPAD_STICK_LL, WPAD_STICK_LR, WPAD_STICK_LU, WPAD_STICK_LD, WPAD_STICK_RL, WPAD_STICK_RR, WPAD_STICK_RU, WPAD_STICK_RD};
static const std::array<const std::string*, 23> classic_button_names = {&buttonUp,         &buttonLeft,              &g_controlsStrings.wiiButtonZR, &g_controlsStrings.wiiButtonX, &g_controlsStrings.wiiButtonA, &g_controlsStrings.wiiButtonY,
    &g_controlsStrings.wiiButtonB, &g_controlsStrings.wiiButtonZL, &g_controlsStrings.wiiButtonRT, &g_controlsStrings.wiiButtonPlus, &g_controlsStrings.wiiButtonHome, &g_controlsStrings.wiiButtonMinus, &g_controlsStrings.wiiButtonLT, &buttonDown,
    &buttonRight,              &buttonLeft,   &buttonRight,  &buttonUp,     &buttonDown,   &buttonLeft,   &buttonRight,  &buttonUp,     &buttonDown};

static std::string s_buffer;

static const char* s_get_name(uint32_t button, uint8_t expansion)
{
    if(button == Controls::null_but)
        return nullptr;

    // main Wiimote buttons
    if(button < WPAD_STICK_LL)
    {
        auto i = std::find(wiimote_buttons.begin(), wiimote_buttons.end(), button);
        if(i == wiimote_buttons.end())
            return g_controlsStrings.sharedCaseInvalid.c_str();

        int index = i - wiimote_buttons.begin();
        if(is_direction(wiimote_button_names[index]))
        {
            s_buffer = g_controlsStrings.wiiDpad + " " + *wiimote_button_names[index];
            return s_buffer.c_str();
        }

        return wiimote_button_names[index]->c_str();
    }

    // nunchuck buttons
    if(expansion == WPAD_EXP_NUNCHUK)
    {
        auto i = std::find(nunchuck_buttons.begin(), nunchuck_buttons.end(), button);
        if(i == nunchuck_buttons.end())
            return g_controlsStrings.sharedCaseInvalid.c_str();

        int index = i - nunchuck_buttons.begin();
        if(is_direction(nunchuck_button_names[index]))
        {
            s_buffer = g_controlsStrings.wiiPrefixNunchuck + " " + *nunchuck_button_names[index];
            return s_buffer.c_str();
        }

        return nunchuck_button_names[index]->c_str();
    }

    // classic buttons
    if(expansion == WPAD_EXP_CLASSIC)
    {
        auto i = std::find(classic_buttons.begin(), classic_buttons.end(), button);
        if(i == classic_buttons.end())
            return g_controlsStrings.sharedCaseInvalid.c_str();

        int index = i - classic_buttons.begin();
        if(is_direction(classic_button_names[index]))
        {
            const std::string& prefix = (button >= WPAD_STICK_RL && button <= WPAD_STICK_RD) ? g_controlsStrings.wiiRStick
                : (button >= WPAD_STICK_LL && button <= WPAD_STICK_LD) ? g_controlsStrings.wiiLStick
                : g_controlsStrings.wiiDpad;
            s_buffer = prefix + " " + *classic_button_names[index];
            return s_buffer.c_str();
        }

        return classic_button_names[index]->c_str();
    }

    return g_controlsStrings.sharedCaseInvalid.c_str();
}

static inline num_t i_get_thumb_dbl(WPADData* data, uint32_t button, uint8_t expansion)
{
    const joystick_t& js = (expansion == WPAD_EXP_NUNCHUK)
        ? data->exp.nunchuk.js
        : ((button < WPAD_STICK_RL)
            ? data->exp.classic.ljs
            : data->exp.classic.rjs);

    if(button >= 0x8000)
        button -= 0x8000;

    int max, center, val;
    if(button == WPAD_STICK_LL)
    {
        center = js.center.x;
        max = js.min.x;
        val = js.pos.x;
    }
    else if(button == WPAD_STICK_LR)
    {
        center = js.center.x;
        max = js.max.x;
        val = js.pos.x;
    }
    else if(button == WPAD_STICK_LU)
    {
        center = js.center.y;
        max = js.max.y;
        val = js.pos.y;
    }
    else // (button == WPAD_STICK_LD)
    {
        center = js.center.y;
        max = js.min.y;
        val = js.pos.y;
    }

    num_t decode = (num_t)(val - center) / (max - center);
    decode -= 0.1_n;
    decode /= 0.9_ri;
    if(decode < 0.1_n)
        decode = 0;

    return decode;
}

static bool s_get_button(WPADData* data, uint32_t button, uint8_t expansion)
{
    (void)expansion;

    if(button == Controls::null_but)
        return false;

    // intelligent sideways controls
    if(button >= WPAD_BUTTON_LEFT && button <= WPAD_BUTTON_UP && expansion == WPAD_EXP_NONE)
    {
        bool probably_sideways = (!GameMenu && !LevelEditor && !MagicHand && (GamePaused == PauseCode::None || GamePaused == PauseCode::PauseScreen || GamePaused == PauseCode::Message));
        probably_sideways |= !data->ir.valid;

        if(probably_sideways)
        {
            switch(button)
            {
            case WPAD_BUTTON_LEFT:
                button = WPAD_BUTTON_UP;
                break;
            case WPAD_BUTTON_DOWN:
                button = WPAD_BUTTON_LEFT;
                break;
            case WPAD_BUTTON_RIGHT:
                button = WPAD_BUTTON_DOWN;
                break;
            case WPAD_BUTTON_UP:
                button = WPAD_BUTTON_RIGHT;
                break;
            }
        }
    }

    if(button < WPAD_SHAKE)
        return button & data->btns_h;

    if(button == WPAD_SHAKE)
        return data->gforce.z < 0.0f || data->gforce.z > 2.0f;

    // thumbstick button
    if(button <= WPAD_STICK_RU)
        return i_get_thumb_dbl(data, button, expansion) > 0.25_n;

    // expansion button, WPAD makes this easy :)
    return button & data->btns_h;

    return false;
}

static num_t s_get_button_dbl(WPADData* data, uint32_t button, uint8_t expansion)
{
    if(button >= WPAD_STICK_LL && button <= WPAD_STICK_RU)
    {
        return i_get_thumb_dbl(data, button, expansion);
    }

    if(s_get_button(data, button, expansion))
        return 0.5_n;
    else
        return 0.0_n;
}

namespace XRender
{
    extern int g_rmode_w, g_rmode_h;
};

namespace Controls
{

/*===============================================*\
|| implementation for InputMethod_Wii            ||
\*===============================================*/

InputMethod_Wii::InputMethod_Wii(int chn) : m_chn(chn)
{
}

InputMethod_Wii::~InputMethod_Wii()
{
    InputMethodType_Wii* t = dynamic_cast<InputMethodType_Wii*>(this->Type);

    if(!t)
        return;

    t->m_canPoll = false;
}

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_Wii::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    InputMethodProfile_Wii* p = dynamic_cast<InputMethodProfile_Wii*>(this->Profile);

    if(!p)
        return false;

    WPADData* data = WPAD_Data(m_chn);
    if(!data)
        return false;

    if(data->err || !data->data_present)
        return false;

    if(data->exp.type != p->m_expansion)
    {
        pLogDebug("Disconnected input profile %s from Wiimote index %d because of extension mismatch: (Wiimote %d, profile %d). This usually happens because an extension has been connected or disconnected.", p->Name.c_str(), m_chn, (int)data->exp.type, (int)p->m_expansion);
        return false;
    }

    if(m_rumble_ticks)
    {
        m_rumble_ticks--;
        if(!m_rumble_ticks)
            WPAD_Rumble(m_chn, 0);
    }

    float shake_accum_target = fabs(data->gforce.z - 1.0f);

    if(shake_accum_target > m_shake_accum)
        m_shake_accum = shake_accum_target;
    else if(m_shake_accum > 0.05)
        m_shake_accum -= 0.05;

    m_battery_status = data->battery_level;

    bool probably_sideways = (!GameMenu && !LevelEditor && !MagicHand && (GamePaused == PauseCode::None || GamePaused == PauseCode::PauseScreen || GamePaused == PauseCode::Message));
    probably_sideways |= !data->ir.valid;

    for(int a = 0; a < 4; a++)
    {
        uint32_t* keys;
        uint32_t* keys2;
        size_t key_start;
        size_t key_max;
        bool activate = false;

        if(a == 0)
        {
            keys = p->m_keys;
            keys2 = p->m_keys2;
            key_start = 0;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = p->m_cursor_keys2;
            key_start = 4;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = p->m_editor_keys;
            keys2 = p->m_editor_keys2;
            key_start = 4;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = p->m_hotkeys;
            keys2 = p->m_hotkeys2;
            key_start = 0;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = key_start; i < key_max; i++)
        {
            uint32_t key;

            if(keys)
                key = keys[i];
            else
                key = null_but;

            uint32_t key2 = keys2[i];

            if(p->m_expansion == WPAD_EXP_NONE)
            {
                // don't use A/B as cursor controls if in sideways mode
                if(probably_sideways && a == 1)
                {
                    continue;
                }

                // don't use A/B as AltJump / AltRun if in IR mode
                if(!probably_sideways && a != 1)
                {
                    if(key == p->m_cursor_keys2[CursorControls::Primary] || key == p->m_cursor_keys2[CursorControls::Secondary])
                        key = null_but;
                    if(key2 == p->m_cursor_keys2[CursorControls::Primary] || key == p->m_cursor_keys2[CursorControls::Secondary])
                        key2 = null_but;
                }
            }

            bool* b;

            if(a == 0)
            {
                b = &PlayerControls::GetButton(c, i);
                *b = false;
            }
            else if(a == 1)
            {
                b = &CursorControls::GetButton(m, i);
            }
            else if(a == 2)
            {
                b = &EditorControls::GetButton(e, i);
            }
            else
            {
                b = &activate;
                *b = false;
            }

            if((key == WPAD_SHAKE && m_shake_accum > 1.0) || s_get_button(data, key, p->m_expansion))
                *b = true;
            else if((key2 == WPAD_SHAKE && m_shake_accum > 1.0) || s_get_button(data, key2, p->m_expansion))
                *b = true;

            if(a == 3 && *b)
                h[i] = player;
        }
    }

    num_t* const scroll[4] = {&e.ScrollUp, &e.ScrollDown, &e.ScrollLeft, &e.ScrollRight};

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_editor_keys[i];
        int key2 = p->m_editor_keys2[i];

        *scroll[i] += s_get_button_dbl(data, key, p->m_expansion) * 32;
        *scroll[i] += s_get_button_dbl(data, key2, p->m_expansion) * 32;
    }

    num_t cursor[4];

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_cursor_keys2[i];
        cursor[i] = s_get_button_dbl(data, key, p->m_expansion) * 32;
    }

    // Cursor control (UDLR)
    if(cursor[0] || cursor[1] || cursor[2] || cursor[3])
    {
        if(m.X < 0)
            m.X = XRender::TargetW / 2;

        if(m.Y < 0)
            m.Y = XRender::TargetH / 2;

        m.X += cursor[3];
        m.X -= cursor[2];
        m.Y += cursor[1];
        m.Y -= cursor[0];

        if(m.X < 0)
            m.X = 0;
        else if(m.X >= XRender::TargetW)
            m.X = XRender::TargetW - 1;

        if(m.Y < 0)
            m.Y = 0;
        else if(m.Y >= XRender::TargetH)
            m.Y = XRender::TargetH - 1;

        m.Move = true;
    }

    return true;
}

void InputMethod_Wii::Rumble(int ms, float strength)
{
    UNUSED(strength);

    WPAD_Rumble(m_chn, 1);

    m_rumble_ticks = ms / 15 + 1;
}

StatusInfo InputMethod_Wii::GetStatus()
{
    StatusInfo res;

    res.power_status = StatusInfo::POWER_DISCHARGING;

    res.power_level = numf_t(m_battery_status) / 105;

    return res;
}

/*===============================================*\
|| implementation for InputMethodProfile_Wii     ||
\*===============================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_Wii::InputMethodProfile_Wii(uint8_t expansion)
{
    this->InitAs(expansion);
}

void InputMethodProfile_Wii::InitAs(uint8_t expansion)
{
    this->m_expansion = expansion;

    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
    {
        this->m_keys[i] = null_but;
        this->m_keys2[i] = null_but;
    }

    for(size_t i = 0; i < CursorControls::n_buttons; i++)
        this->m_cursor_keys2[i] = null_but;

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
    {
        this->m_editor_keys[i] = null_but;
        this->m_editor_keys2[i] = null_but;
    }

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        this->m_hotkeys[i] = null_but;
        this->m_hotkeys2[i] = null_but;
    }

    if(m_expansion == WPAD_EXP_NUNCHUK)
    {
        this->m_keys[PlayerControls::Buttons::Up] = WPAD_STICK_LU;
        this->m_keys[PlayerControls::Buttons::Down] = WPAD_STICK_LD;
        this->m_keys[PlayerControls::Buttons::Left] = WPAD_STICK_LL;
        this->m_keys[PlayerControls::Buttons::Right] = WPAD_STICK_LR;
        this->m_keys[PlayerControls::Buttons::Jump] = WPAD_BUTTON_A;
        this->m_keys[PlayerControls::Buttons::AltJump] = WPAD_NUNCHUK_BUTTON_C;
        this->m_keys[PlayerControls::Buttons::Run] = WPAD_BUTTON_B;
        this->m_keys[PlayerControls::Buttons::AltRun] = WPAD_NUNCHUK_BUTTON_Z;
        this->m_keys[PlayerControls::Buttons::Drop] = WPAD_BUTTON_MINUS;
        this->m_keys[PlayerControls::Buttons::Start] = WPAD_BUTTON_PLUS;

        this->m_keys2[PlayerControls::Buttons::Drop] = WPAD_BUTTON_DOWN;

        this->m_editor_keys[EditorControls::Buttons::ScrollUp] = WPAD_STICK_LU;
        this->m_editor_keys[EditorControls::Buttons::ScrollDown] = WPAD_STICK_LD;
        this->m_editor_keys[EditorControls::Buttons::ScrollLeft] = WPAD_STICK_LL;
        this->m_editor_keys[EditorControls::Buttons::ScrollRight] = WPAD_STICK_LR;
        this->m_editor_keys[EditorControls::Buttons::FastScroll] = WPAD_NUNCHUK_BUTTON_Z;
        this->m_editor_keys[EditorControls::Buttons::ModeErase] = WPAD_NUNCHUK_BUTTON_C;
        this->m_editor_keys[EditorControls::Buttons::PrevSection] = WPAD_BUTTON_MINUS;
        this->m_editor_keys[EditorControls::Buttons::NextSection] = WPAD_BUTTON_PLUS;
        this->m_editor_keys[EditorControls::Buttons::SwitchScreens] = WPAD_BUTTON_1;
        this->m_editor_keys[EditorControls::Buttons::TestPlay] = WPAD_BUTTON_2;

        this->m_cursor_keys2[CursorControls::Buttons::Primary] = WPAD_BUTTON_A;
        this->m_cursor_keys2[CursorControls::Buttons::Secondary] = WPAD_BUTTON_B;
    }
    else if(m_expansion == WPAD_EXP_CLASSIC)
    {
        this->m_keys[PlayerControls::Buttons::Up] = WPAD_STICK_LU;
        this->m_keys[PlayerControls::Buttons::Down] = WPAD_STICK_LD;
        this->m_keys[PlayerControls::Buttons::Left] = WPAD_STICK_LL;
        this->m_keys[PlayerControls::Buttons::Right] = WPAD_STICK_LR;
        this->m_keys[PlayerControls::Buttons::Jump] = WPAD_CLASSIC_BUTTON_B;
        this->m_keys[PlayerControls::Buttons::AltJump] = WPAD_CLASSIC_BUTTON_A;
        this->m_keys[PlayerControls::Buttons::Run] = WPAD_CLASSIC_BUTTON_Y;
        this->m_keys[PlayerControls::Buttons::AltRun] = WPAD_CLASSIC_BUTTON_X;
        this->m_keys[PlayerControls::Buttons::Drop] = WPAD_CLASSIC_BUTTON_MINUS;
        this->m_keys[PlayerControls::Buttons::Start] = WPAD_CLASSIC_BUTTON_PLUS;

        this->m_keys2[PlayerControls::Buttons::Up] = WPAD_CLASSIC_BUTTON_UP;
        this->m_keys2[PlayerControls::Buttons::Down] = WPAD_CLASSIC_BUTTON_DOWN;
        this->m_keys2[PlayerControls::Buttons::Left] = WPAD_CLASSIC_BUTTON_LEFT;
        this->m_keys2[PlayerControls::Buttons::Right] = WPAD_CLASSIC_BUTTON_RIGHT;

        this->m_editor_keys[EditorControls::Buttons::ScrollUp] = WPAD_STICK_LU;
        this->m_editor_keys[EditorControls::Buttons::ScrollDown] = WPAD_STICK_LD;
        this->m_editor_keys[EditorControls::Buttons::ScrollLeft] = WPAD_STICK_LL;
        this->m_editor_keys[EditorControls::Buttons::ScrollRight] = WPAD_STICK_LR;
        this->m_editor_keys[EditorControls::Buttons::FastScroll] = WPAD_CLASSIC_BUTTON_ZL;
        this->m_editor_keys[EditorControls::Buttons::ModeErase] = WPAD_CLASSIC_BUTTON_ZR;
        this->m_editor_keys[EditorControls::Buttons::PrevSection] = WPAD_CLASSIC_BUTTON_B;
        this->m_editor_keys[EditorControls::Buttons::NextSection] = WPAD_CLASSIC_BUTTON_A;
        this->m_editor_keys[EditorControls::Buttons::SwitchScreens] = WPAD_CLASSIC_BUTTON_MINUS;
        this->m_editor_keys[EditorControls::Buttons::TestPlay] = WPAD_CLASSIC_BUTTON_PLUS;

        this->m_cursor_keys2[CursorControls::Buttons::CursorUp] = WPAD_STICK_RU;
        this->m_cursor_keys2[CursorControls::Buttons::CursorDown] = WPAD_STICK_RD;
        this->m_cursor_keys2[CursorControls::Buttons::CursorLeft] = WPAD_STICK_RL;
        this->m_cursor_keys2[CursorControls::Buttons::CursorRight] = WPAD_STICK_RR;
        this->m_cursor_keys2[CursorControls::Buttons::Primary] = WPAD_CLASSIC_BUTTON_FULL_R;
        this->m_cursor_keys2[CursorControls::Buttons::Secondary] = WPAD_CLASSIC_BUTTON_FULL_L;

        this->m_altMenuControls = true;
    }
    else
    {
        this->m_keys[PlayerControls::Buttons::Up] = WPAD_BUTTON_UP;
        this->m_keys[PlayerControls::Buttons::Down] = WPAD_BUTTON_DOWN;
        this->m_keys[PlayerControls::Buttons::Left] = WPAD_BUTTON_LEFT;
        this->m_keys[PlayerControls::Buttons::Right] = WPAD_BUTTON_RIGHT;
        this->m_keys[PlayerControls::Buttons::Jump] = WPAD_BUTTON_2;
        this->m_keys[PlayerControls::Buttons::AltJump] = WPAD_BUTTON_A;
        this->m_keys[PlayerControls::Buttons::Run] = WPAD_BUTTON_1;
        this->m_keys[PlayerControls::Buttons::AltRun] = WPAD_BUTTON_B;
        this->m_keys[PlayerControls::Buttons::Drop] = WPAD_BUTTON_MINUS;
        this->m_keys[PlayerControls::Buttons::Start] = WPAD_BUTTON_PLUS;

        this->m_keys2[PlayerControls::Buttons::AltJump] = WPAD_SHAKE;

        this->m_editor_keys[EditorControls::Buttons::ScrollUp] = WPAD_BUTTON_UP;
        this->m_editor_keys[EditorControls::Buttons::ScrollDown] = WPAD_BUTTON_DOWN;
        this->m_editor_keys[EditorControls::Buttons::ScrollLeft] = WPAD_BUTTON_LEFT;
        this->m_editor_keys[EditorControls::Buttons::ScrollRight] = WPAD_BUTTON_RIGHT;
        this->m_editor_keys[EditorControls::Buttons::FastScroll] = WPAD_BUTTON_1;
        this->m_editor_keys[EditorControls::Buttons::PrevSection] = WPAD_BUTTON_MINUS;
        this->m_editor_keys[EditorControls::Buttons::NextSection] = WPAD_BUTTON_PLUS;
        this->m_editor_keys[EditorControls::Buttons::SwitchScreens] = WPAD_BUTTON_HOME;
        this->m_editor_keys[EditorControls::Buttons::TestPlay] = WPAD_BUTTON_2;

        this->m_cursor_keys2[CursorControls::Buttons::Primary] = WPAD_BUTTON_A;
        this->m_cursor_keys2[CursorControls::Buttons::Secondary] = WPAD_BUTTON_B;
    }
}

bool InputMethodProfile_Wii::PollPrimaryButton(ControlsClass c, size_t i)
{
    if(c == ControlsClass::Cursor)
        return true;

    // note: m_canPoll is initialized to false
    uint32_t key = null_but;

    for(int chn = 0; chn < 4; chn++)
    {
        WPADData* data = WPAD_Data(chn);

        if(!data)
            continue;

        if(data->err)
            continue;

        if(data->exp.type != m_expansion)
            continue;

        for(uint32_t but : wiimote_buttons)
        {
            if(s_get_button(data, but, m_expansion))
            {
                key = but;
                break;
            }
        }

        if(data->exp.type == WPAD_EXP_NUNCHUK)
        {
            for(uint32_t but : nunchuck_buttons)
            {
                if(s_get_button(data, but, data->exp.type))
                {
                    key = but;
                    break;
                }
            }
        }

        if(data->exp.type == WPAD_EXP_CLASSIC)
        {
            for(uint32_t but : classic_buttons)
            {
                if(s_get_button(data, but, data->exp.type))
                {
                    key = but;
                    break;
                }
            }
        }

        if(key != null_but)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == null_but)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    this->m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    uint32_t* keys;
    uint32_t* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Wii primary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key
    // if a button's secondary key (including the current one) is the new key, delete it.
    // if a button's primary key (excluding the current one) is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, replace it with the button the player is replacing.
    for(size_t j = 0; j < key_max; j++)
    {
        if(keys2[j] == key)
            keys2[j] = null_but;
        else if(i != j && keys[j] == key)
        {
            if(keys2[j] != null_but)
            {
                keys[j] = keys2[j];
                keys2[j] = null_but;
            }
            else
                keys[j] = keys[i];
        }
    }

    keys[i] = key;
    return true;
}

bool InputMethodProfile_Wii::PollSecondaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    uint32_t key = null_but;

    for(int chn = 0; chn < 4; chn++)
    {
        WPADData* data = WPAD_Data(chn);

        if(!data)
            continue;

        if(data->err)
            continue;

        if(data->exp.type != m_expansion)
            continue;

        for(uint32_t but : wiimote_buttons)
        {
            if(s_get_button(data, but, m_expansion))
            {
                key = but;
                break;
            }
        }

        if(data->exp.type == WPAD_EXP_NUNCHUK)
        {
            for(uint32_t but : nunchuck_buttons)
            {
                if(s_get_button(data, but, data->exp.type))
                {
                    key = but;
                    break;
                }
            }
        }

        if(data->exp.type == WPAD_EXP_CLASSIC)
        {
            for(uint32_t but : classic_buttons)
            {
                if(s_get_button(data, but, data->exp.type))
                {
                    key = but;
                    break;
                }
            }
        }

        if(key != null_but)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == null_but)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    uint32_t* keys;
    uint32_t* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = nullptr;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Wii secondary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key

    // if the current button's primary key is the new key,
    //     delete its secondary key instead of setting it.
    if(keys && keys[i] == key)
    {
        keys2[i] = null_but;
        return true;
    }

    // if another button's secondary key is the new key, delete it.
    // if another button's primary key is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, if this button's secondary key is defined, overwrite the other's with this.
    //     if all else fails, overwrite the other button's with this button's PRIMARY key and assign
    //         this button's PRIMARY key instead

    bool can_do_secondary = true;

    for(size_t j = 0; j < key_max; j++)
    {
        if(i != j && keys2[j] == key)
        {
            keys2[j] = null_but;
        }
        else if(keys && i != j && keys[j] == key)
        {
            if(keys2[j] != null_but)
            {
                keys[j] = keys2[j];
                keys2[j] = null_but;
            }
            else if(keys2[i] != null_but)
            {
                keys[j] = keys2[i];
            }
            else
            {
                keys[j] = keys[i];
                can_do_secondary = false;
            }
        }
    }

    if(can_do_secondary)
        keys2[i] = key;
    else if(keys)
        keys[i] = key;

    return true;
}

bool InputMethodProfile_Wii::DeletePrimaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    uint32_t* keys;
    uint32_t* keys2;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
    }
    else if(c == ControlsClass::Cursor)
    {
        return false;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
    }
    else
    {
        D_pLogWarning("Attempted to delete Wii primary button with disallowed controls class %d\n", (int)c);
        return false;
    }

    if(keys2[i] != null_but)
    {
        keys[i] = keys2[i];
        keys2[i] = null_but;
        return true;
    }

    if(c == ControlsClass::Player)
        return false;

    if(keys[i] != null_but)
    {
        keys[i] = null_but;
        return true;
    }

    return false;
}

bool InputMethodProfile_Wii::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    uint32_t* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return false;

    if(keys2[i] != null_but)
    {
        keys2[i] = null_but;
        return true;
    }

    return false;
}

const char* InputMethodProfile_Wii::NamePrimaryButton(ControlsClass c, size_t i)
{
    uint32_t* keys;

    if(c == ControlsClass::Player)
        keys = this->m_keys;
    else if(c == ControlsClass::Cursor)
    {
        if(i < CursorControls::Buttons::Primary)
            return g_controlsStrings.wiiCaseIR.c_str();
        else
            return g_mainMenu.caseNone.c_str();
    }
    else if(c == ControlsClass::Editor)
        keys = this->m_editor_keys;
    else if(c == ControlsClass::Hotkey)
        keys = this->m_hotkeys;
    else
        return "";

    const char* ret = s_get_name(keys[i], m_expansion);

    if(!ret)
        return g_mainMenu.caseNone.c_str();

    return ret;
}

const char* InputMethodProfile_Wii::NameSecondaryButton(ControlsClass c, size_t i)
{
    uint32_t* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return "";

    const char* ret = s_get_name(keys2[i], m_expansion);

    if(!ret)
        return "";

    return ret;
}

void InputMethodProfile_Wii::SaveConfig(IniProcessing* ctl)
{
    ctl->setValue("expansion", (int)this->m_expansion);

    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        uint32_t* keys;
        uint32_t* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->setValue(name, keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            ctl->setValue(name2, keys2[i]);
        }
    }
}

void InputMethodProfile_Wii::LoadConfig(IniProcessing* ctl)
{
    int expansion;
    ctl->read("expansion", expansion, WPAD_EXP_NONE);

    this->m_expansion = expansion;

    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        uint32_t* keys;
        uint32_t* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->read(name, keys[i], keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            ctl->read(name2, keys2[i], keys2[i]);
        }
    }
}

/*===============================================*\
|| implementation for InputMethodType_Wii        ||
\*===============================================*/

InputMethodProfile* InputMethodType_Wii::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_Wii(WPAD_EXP_NONE);
}

InputMethodType_Wii::InputMethodType_Wii()
{
    this->Name = "Wii";
    WPAD_Init();
    for(int chn = 0; chn < 4; chn++)
    {
        WPAD_SetDataFormat(chn, WPAD_FMT_BTNS_ACC_IR);
        WPAD_SetVRes(chn, XRender::g_rmode_w, XRender::g_rmode_h);
    }
}

InputMethodType_Wii::~InputMethodType_Wii()
{
    WPAD_Shutdown();
}

bool InputMethodType_Wii::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_Wii*>(profile);
}

bool InputMethodType_Wii::RumbleSupported()
{
    return true;
}

bool InputMethodType_Wii::PowerStatusSupported()
{
    return true;
}

void InputMethodType_Wii::UpdateControlsPre()
{
    WPAD_ScanPads();
}

void InputMethodType_Wii::UpdateControlsPost()
{
    int active_chn = -1;
    int scr_x = -10;
    int scr_y = -10;

    for(int i = 0; i < 4; i++)
    {
        WPADData* data = WPAD_Data(i);

        if(!data)
            continue;

        if(data->err || !data->data_present)
            m_chnConnected[i] = 0;
        else if(m_chnConnected[i] < 8)
        {
            m_chnConnected[i]++;

            // fixes bug where Wiimote could be stuck in Rumble state if it had previously died while Rumble was active
            WPAD_Rumble(i, 0);
        }

        if(data->ir.valid)
        {
            int phys_x = data->ir.x;
            int phys_y = data->ir.y;

            XRender::mapToScreen(phys_x, phys_y, &scr_x, &scr_y);
            active_chn = i;

            break;
        }
    }

    if(active_chn == -1 && m_irActiveChn != -1)
    {
        SharedCursor.GoOffscreen();
        return;
    }

    if(scr_x - m_irLastX <= -1 || scr_x - m_irLastX >= 1 ||
       scr_y - m_irLastY <= -1 || scr_y - m_irLastY >= 1 ||
       active_chn != m_irActiveChn)
    {
        m_irLastX = scr_x;
        m_irLastY = scr_y;
        m_irActiveChn = active_chn;
        SharedCursor.Move = true;
        SharedCursor.X = scr_x;
        SharedCursor.Y = scr_y;
    }

    // editor edge scrolling logic, held back for now.
    // I'll try to rework the IR logic above, manually converting to screen coordinates using smooth_valid and sx/sy.
    // See ir_correct_for_bounds and ir_convert_to_vres at https://github.com/devkitPro/libogc/blob/master/wiiuse/ir.c
    // Just need to make very slightly less stringent valid conditions
    // Try to allow up to 128px offset from screen in any direction.
    if(LevelEditor && false)
    {
        if(scr_x < 64)
            ::EditorControls.ScrollLeft += SDL_min((64 - scr_x) / 2, 32);
        else if(scr_x > XRender::TargetW - 64)
            ::EditorControls.ScrollRight += SDL_min((scr_x - (XRender::TargetW - 64)) / 2, 32);

        if(scr_y < 0)
            ::EditorControls.ScrollUp += SDL_min((0 - scr_y) / 2, 32);
        else if(scr_y > XRender::TargetH - 64)
            ::EditorControls.ScrollDown += SDL_min((scr_y - (XRender::TargetH - 64)) / 2, 32);
    }
}

InputMethod* InputMethodType_Wii::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    std::array<bool, 4> in_use = {false};

    for(InputMethod* method : active_methods)
    {
        InputMethod_Wii* m = dynamic_cast<InputMethod_Wii*>(method);
        if(!m)
            continue;

        if(m->m_chn >= 0 || m->m_chn < 4)
            in_use[m->m_chn] = true;
    }

    int chn = 0;
    uint8_t expansion = 0;

    for(chn = 0; chn < 4; chn++)
    {
        if(in_use[chn])
            continue;

        WPADData* data = WPAD_Data(chn);

        if(!data)
            continue;

        if(data->err)
            continue;

        if(!data->data_present)
            continue;

        // newly connected wiimote
        bool newly_connected = (m_chnConnected[chn] < 8);

        uint32_t key = null_but;

        for(uint32_t but : wiimote_buttons)
        {
            if(s_get_button(data, but, data->exp.type))
            {
                key = but;
                break;
            }
        }

        if(data->exp.type == WPAD_EXP_NUNCHUK)
        {
            for(uint32_t but : nunchuck_buttons)
            {
                if(s_get_button(data, but, data->exp.type))
                {
                    key = but;
                    break;
                }
            }
        }

        if(data->exp.type == WPAD_EXP_CLASSIC)
        {
            for(uint32_t but : classic_buttons)
            {
                if(s_get_button(data, but, data->exp.type))
                {
                    key = but;
                    break;
                }
            }
        }

        if(key != null_but || newly_connected)
        {
            expansion = data->exp.type;
            break;
        }
    }

    // if didn't find any wiimote allow poll in future but return false
    if(chn == 4)
    {
        this->m_canPoll = true;
        return nullptr;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return nullptr;

    // we're going to create a new wiimote!
    // reset canPoll for next time
    this->m_canPoll = false;

    InputMethod_Wii* method = new(std::nothrow) InputMethod_Wii(chn);

    if(!method)
        return nullptr;

    if(expansion == WPAD_EXP_NUNCHUK)
        method->Name = g_controlsStrings.wiiTypeNunchuck;
    else if(expansion == WPAD_EXP_CLASSIC)
        method->Name = g_controlsStrings.wiiTypeClassic;
    else
        method->Name = g_controlsStrings.wiiTypeWiimote;

    method->Name += " ";
    method->Name += std::to_string(chn + 1);
    method->Type = this;

    // now, cleverly find a profile!

    // 1. cleverly look for profile by GUID and player...
    uint16_t new_index = expansion * 256 + 1;

    for(const InputMethod* m : active_methods)
    {
        if(!m)
            break;

        new_index += 1;
    }

    std::unordered_map<uint16_t, InputMethodProfile*>::iterator found
        = this->m_lastProfileByPlayerAndExp.find(new_index);

    // ...then by just expansion index.
    if(found == this->m_lastProfileByPlayerAndExp.end())
        found = this->m_lastProfileByPlayerAndExp.find(expansion * 256);

    if(found != this->m_lastProfileByPlayerAndExp.end())
        method->Profile = found->second;

    // 2. find first profile appropriate to the expansion of the controller
    if(!method->Profile)
    {
        for(InputMethodProfile* p_ : this->m_profiles)
        {
            InputMethodProfile_Wii* p = dynamic_cast<InputMethodProfile_Wii*>(p_);

            if(!p)
                continue;

            if(p->m_expansion == expansion)
            {
                method->Profile = p_;
                break;
            }
        }

        // 3. make appropriate new profile (note that allocs could fail, that will be cleaned up later)
        if(!method->Profile)
        {
            method->Profile = new(std::nothrow) InputMethodProfile_Wii(expansion);
            if(method->Profile)
            {
                method->Profile->Name = method->Name;
                method->Profile->Type = this;
                this->m_profiles.push_back(method->Profile);
            }
        }
    }

    if(method->Profile)
    {
        this->m_lastProfileByPlayerAndExp[new_index] = method->Profile;
        this->m_lastProfileByPlayerAndExp[expansion * 256] = method->Profile;
    }

    return (InputMethod*)method;
}

InputMethodProfile* InputMethodType_Wii::AddNunchuckProfile()
{
    InputMethodProfile* p_ = this->AddProfile();
    auto* p = dynamic_cast<InputMethodProfile_Wii*>(p_);

    if(!p)
        return nullptr;

    p->InitAs(WPAD_EXP_NUNCHUK);
    p->Name = g_controlsStrings.wiiTypeNunchuck + " " + std::to_string(this->m_profiles.size());

    return p_;
}

InputMethodProfile* InputMethodType_Wii::AddClassicProfile()
{
    InputMethodProfile* p_ = this->AddProfile();
    auto* p = dynamic_cast<InputMethodProfile_Wii*>(p_);

    if(!p)
        return nullptr;

    p->InitAs(WPAD_EXP_CLASSIC);
    p->Name = g_controlsStrings.wiiTypeClassic + " " + std::to_string(this->m_profiles.size());

    return p_;
}

/*-----------------------*\
|| OPTIONAL METHODS      ||
\*-----------------------*/
bool InputMethodType_Wii::ConsumeEvent(const SDL_Event* ev)
{
    UNUSED(ev);
    return false;
}

// optional function allowing developer to associate device information with profile, etc
bool InputMethodType_Wii::SetProfile_Custom(InputMethod* method, int player_no, InputMethodProfile* profile,
        const std::vector<InputMethod*>& active_methods)
{
    UNUSED(active_methods);

    if(!method || !profile || player_no < 0 || player_no >= maxLocalPlayers)
        return false;

    InputMethod_Wii* m = dynamic_cast<InputMethod_Wii*>(method);
    InputMethodProfile_Wii* p = dynamic_cast<InputMethodProfile_Wii*>(profile);

    if(!m || !p || m->m_chn < 0 || m->m_chn >= 4)
        return false;

    WPADData* data = WPAD_Data(m->m_chn);

    if(!data || data->err || data->exp.type != p->m_expansion)
        return false;

    this->m_lastProfileByPlayerAndExp[p->m_expansion * 256 + player_no + 1] = profile;
    this->m_lastProfileByPlayerAndExp[p->m_expansion * 256] = profile;

    m_canPoll = false;
    return true;
}

// unregisters any references to the profile before final deallocation
// returns false to prevent deletion if this is impossible
bool InputMethodType_Wii::DeleteProfile_Custom(InputMethodProfile* profile, const std::vector<InputMethod*>& active_methods)
{
    UNUSED(active_methods);

    for(auto it = m_lastProfileByPlayerAndExp.begin(); it != m_lastProfileByPlayerAndExp.end();)
    {
        if(it->second == profile)
        {
            pLogDebug("Unsetting default profile for index '%x' on deletion of '%s'.", (unsigned int)it->first, profile->Name.c_str());
            it = m_lastProfileByPlayerAndExp.erase(it);
        }
        else
            ++it;
    }

    return true;
}

// How many per-type special options are there?
size_t InputMethodType_Wii::GetOptionCount()
{
    return 2;
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount() returns 0.
// get a char* describing the option
const char* InputMethodType_Wii::GetOptionName(size_t i)
{
    if(i == 0)
        return g_controlsStrings.wiiPhraseNewNunchuck.c_str();
    else if(i == 1)
        return g_controlsStrings.wiiPhraseNewClassic.c_str();

    return nullptr;
}

// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodType_Wii::GetOptionValue(size_t i)
{
    (void)i;
    return nullptr;
}

// called when A is pressed; allowed to interrupt main game loop
bool InputMethodType_Wii::OptionChange(size_t i)
{
    if(i == 0 && this->AddNunchuckProfile())
        return true;
    else if(i == 1 && this->AddClassicProfile())
        return true;

    return false;
}

void InputMethodType_Wii::SaveConfig_Custom(IniProcessing* ctl)
{
    std::string name = "last-profile-";
    int uuid_begin = name.size();

    // set all default controller profiles
    for(auto it = m_lastProfileByPlayerAndExp.begin(); it != m_lastProfileByPlayerAndExp.end(); ++it)
    {
        std::vector<InputMethodProfile*>::iterator loc = std::find(this->m_profiles.begin(), this->m_profiles.end(), it->second);
        size_t index = loc - this->m_profiles.begin();

        ctl->setValue(name.replace(uuid_begin, std::string::npos, std::to_string(it->first)).c_str(), index);
    }
}

void InputMethodType_Wii::LoadConfig_Custom(IniProcessing* ctl)
{
    // load all default controller profiles
    std::vector<std::string> keys = ctl->allKeys();
    std::string keyNeed = "last-profile-";

    for(std::string& k : keys)
    {
        std::string::size_type r = k.find(keyNeed);

        if(r != std::string::npos && r == 0)
        {
            std::string type_index_str = k.substr(13); // length of "last-profile-"
            uint32_t type_index = strtoul(type_index_str.c_str(), nullptr, 10);

            int prof_index;
            ctl->read(k.c_str(), prof_index, -1);

            if(prof_index >= 0 && prof_index < (int)this->m_profiles.size() && this->m_profiles[prof_index])
            {
                this->m_lastProfileByPlayerAndExp[type_index] = this->m_profiles[prof_index];
                pLogDebug("Set default profile for '%u' to '%s'.", type_index, this->m_profiles[prof_index]->Name.c_str());
            }
        }
    }
}

} // namespace Controls


================================================
FILE: src/control/input_wii.h
================================================
#ifndef INPUT_WII_H
#define INPUT_WII_H

#include <unordered_map>
#include <utility>
#include <array>

#include "../controls.h"

namespace Controls
{

constexpr uint32_t null_but = -1;

class InputMethod_Wii : public InputMethod
{
public:
    int m_chn = 0;
    int m_rumble_ticks = 0;
    uint8_t m_battery_status = 0;
    double m_shake_accum = 0.0;

    using InputMethod::Type;
    using InputMethod::Profile;

    InputMethod_Wii(int chn);
    ~InputMethod_Wii();

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);

    StatusInfo GetStatus();
};

class InputMethodProfile_Wii : public InputMethodProfile
{
private:
    std::unordered_map<uint16_t, InputMethodProfile *> m_lastProfileByPlayerAndExp;
    bool m_canPoll = false;

public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    uint8_t m_expansion = 0;

    uint32_t m_keys[PlayerControls::n_buttons] = {null_but};
    uint32_t m_keys2[PlayerControls::n_buttons] = {null_but};

    uint32_t m_editor_keys[EditorControls::n_buttons] = {null_but};
    uint32_t m_editor_keys2[EditorControls::n_buttons] = {null_but};

    uint32_t m_cursor_keys2[CursorControls::n_buttons] = {null_but};

    uint32_t m_hotkeys[Hotkeys::n_buttons] = {null_but};
    uint32_t m_hotkeys2[Hotkeys::n_buttons] = {null_but};

    InputMethodProfile_Wii(uint8_t expansion);

    void InitAs(uint8_t expansion);

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);
};

class InputMethodType_Wii : public InputMethodType
{
private:
    std::unordered_map<uint16_t, InputMethodProfile *> m_lastProfileByPlayerAndExp;

    InputMethodProfile *AllocateProfile() noexcept;

public:
    bool m_canPoll = false;
    int m_irActiveChn = -1;
    int m_irLastX = -10;
    int m_irLastY = -10;

    // how many frames has the wiimote been connected?
    std::array<uint8_t, 4> m_chnConnected{0};

    using InputMethodType::Name;
    using InputMethodType::m_profiles;

    InputMethodType_Wii();
    ~InputMethodType_Wii();

    bool TestProfileType(InputMethodProfile *profile);
    bool RumbleSupported();
    bool PowerStatusSupported() override;

    void UpdateControlsPre();
    void UpdateControlsPost();

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept;

    /*-----------------------*\
    || CUSTOM METHODS        ||
    \*-----------------------*/
    InputMethodProfile *AddNunchuckProfile();
    InputMethodProfile *AddClassicProfile();

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
protected:
    // optional function allowing developer to associate device information with profile, etc
    // if developer wants to forbid assignment, return false
    bool SetProfile_Custom(InputMethod *method, int player_no, InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods) override;
    // unregisters any references to the profile before final deallocation
    // returns false to prevent deletion if this is impossible
    bool DeleteProfile_Custom(InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods) override;

public:
    bool ConsumeEvent(const SDL_Event *ev);

    // How many per-type special options are there?
    size_t GetOptionCount();
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount() returns 0.
    // get a char* describing the option
    const char *GetOptionName(size_t i);
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange(size_t i);

protected:
    void SaveConfig_Custom(IniProcessing *ctl);
    void LoadConfig_Custom(IniProcessing *ctl);
};

} // namespace Controls

#endif // #ifndef INPUT_WII_H


================================================
FILE: src/control/input_wii_gc.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>

#include "globals.h"
#include "game_main.h"

#include "core/render.h"

#include "controls.h"
#include "control/input_wii_gc.h"

#include "control/controls_strings.h"
#include "main/menu_main.h"
#include "game_main.h"

#include <Logger/logger.h>

#include <ogc/pad.h>

#define PAD_STICK_LL  0x2000
#define PAD_STICK_LR  0x4000
#define PAD_STICK_LU  0x6000
// not technically legal.
#define PAD_STICK_LD  0x7000
#define PAD_STICK_RL  0xA000
#define PAD_STICK_RR  0xC000
#define PAD_STICK_RU  0xE000
// not technically legal.
#define PAD_STICK_RD  0xF000

#define buttonRight Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Right]
#define buttonLeft  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Left]
#define buttonUp    Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Up]
#define buttonDown  Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Down]

static constexpr uint32_t null_key = -1;

static constexpr std::array<const uint32_t, 21> gamecube_buttons = {
    PAD_BUTTON_LEFT,
    PAD_BUTTON_RIGHT,
    PAD_BUTTON_DOWN,
    PAD_BUTTON_UP,
    PAD_TRIGGER_Z,
    PAD_TRIGGER_R,
    PAD_TRIGGER_L,
    PAD_BUTTON_A,
    PAD_BUTTON_B,
    PAD_BUTTON_X,
    PAD_BUTTON_Y,
    PAD_BUTTON_MENU,
    PAD_BUTTON_START,
    PAD_STICK_LL,
    PAD_STICK_LR,
    PAD_STICK_LU,
    PAD_STICK_LD,
    PAD_STICK_RL,
    PAD_STICK_RR,
    PAD_STICK_RU,
    PAD_STICK_RD,
};

static const std::array<const std::string*, 21> gamecube_button_names = {
    &buttonLeft,
    &buttonRight,
    &buttonDown,
    &buttonUp,
    &g_controlsStrings.wiiButtonZ,
    &g_controlsStrings.wiiButtonRT,
    &g_controlsStrings.wiiButtonLT,
    &g_controlsStrings.wiiButtonA,
    &g_controlsStrings.wiiButtonB,
    &g_controlsStrings.wiiButtonX,
    &g_controlsStrings.wiiButtonY,
    &g_controlsStrings.wiiButtonHome,
    &g_controlsStrings.wiiButtonPlus,
    &buttonLeft,
    &buttonRight,
    &buttonUp,
    &buttonDown,
    &buttonLeft,
    &buttonRight,
    &buttonUp,
    &buttonDown,
};

static std::string s_buffer;

static const char* s_get_name(uint32_t key)
{
    if(key == null_key)
        return g_mainMenu.caseNone.c_str();

    auto it = std::find(gamecube_buttons.begin(), gamecube_buttons.end(), key);
    if(it == gamecube_buttons.end())
        return g_controlsStrings.sharedCaseInvalid.c_str();

    int i = it - gamecube_buttons.begin();

    if(key <= PAD_BUTTON_UP)
        s_buffer = g_controlsStrings.wiiDpad;
    else if(key >= PAD_STICK_LL && key < PAD_STICK_RL)
        s_buffer = g_controlsStrings.wiiLStick;
    else if(key >= PAD_STICK_RL)
        s_buffer = g_controlsStrings.wiiRStick;
    else
        s_buffer.clear();

    if(!s_buffer.empty())
        s_buffer += ' ';

    s_buffer += *gamecube_button_names[i];
    return s_buffer.c_str();
}

namespace Controls
{

/*====================================================*\
|| implementation for InputMethod_GameCube            ||
\*====================================================*/

static inline num_t s_s8_to_dbl(int8_t in)
{
    if(in <= 32)
        return 0;

    return SDL_min(num_t(in - 32) / 64, 1.0_n);
}

static inline num_t s_get_thumb_dbl(const PADStatus* data, uint32_t button)
{
    switch(button)
    {
    case(PAD_STICK_LL):
        return s_s8_to_dbl(-data->stickX);
    case(PAD_STICK_LR):
        return s_s8_to_dbl( data->stickX);
    case(PAD_STICK_LU):
        return s_s8_to_dbl( data->stickY);
    case(PAD_STICK_LD):
        return s_s8_to_dbl(-data->stickY);
    case(PAD_STICK_RL):
        return s_s8_to_dbl(-data->substickX);
    case(PAD_STICK_RR):
        return s_s8_to_dbl( data->substickX);
    case(PAD_STICK_RU):
        return s_s8_to_dbl( data->substickY);
    case(PAD_STICK_RD):
        return s_s8_to_dbl(-data->substickY);
    default:
        return 0;
    }
}

static bool s_get_button(const PADStatus* data, uint32_t button)
{
    if(button == null_key)
        return false;

    if(button < PAD_STICK_LL)
        return (button & data->button);

    // thumbstick button
    if(button <= PAD_STICK_RD)
        return s_get_thumb_dbl(data, button) > 0.25_n;

    return false;
}

static num_t s_get_button_dbl(const PADStatus* data, uint32_t button)
{
    if(button >= PAD_STICK_LL && button <= PAD_STICK_RD)
        return s_get_thumb_dbl(data, button);

    if(s_get_button(data, button))
        return 0.5_n;
    else
        return 0.0_n;
}

/*====================================================*\
|| implementation for InputMethod_GameCube            ||
\*====================================================*/

InputMethod_GameCube::~InputMethod_GameCube()
{
    InputMethodType_GameCube* t = dynamic_cast<InputMethodType_GameCube*>(this->Type);

    if(!t)
        return;

    t->m_canPoll = false;
}

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_GameCube::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    InputMethodProfile_GameCube* p = dynamic_cast<InputMethodProfile_GameCube*>(this->Profile);
    InputMethodType_GameCube* t = dynamic_cast<InputMethodType_GameCube*>(this->Type);

    if(!p || !t || m_chn < 0 || m_chn >= 4)
        return false;

    const PADStatus* data = &t->m_status[m_chn];
    if(!data)
        return false;

    if(data->err != PAD_ERR_NONE)
        return false;

    if(m_rumble_ticks)
    {
        m_rumble_ticks--;
        if(!m_rumble_ticks)
            PAD_ControlMotor(m_chn, PAD_MOTOR_STOP);
    }

    for(int a = 0; a < 4; a++)
    {
        uint32_t* keys;
        uint32_t* keys2;
        size_t key_start;
        size_t key_max;
        bool activate = false;

        if(a == 0)
        {
            keys = p->m_keys;
            keys2 = p->m_keys2;
            key_start = 0;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = p->m_cursor_keys;
            keys2 = p->m_cursor_keys2;
            key_start = 4;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = p->m_editor_keys;
            keys2 = p->m_editor_keys2;
            key_start = 4;
            key_max = EditorControls::n_buttons;

            if(p->m_simple_editor && LevelEditor && GamePaused == PauseCode::None)
                continue;
        }
        else
        {
            keys = p->m_hotkeys;
            keys2 = p->m_hotkeys2;
            key_start = 0;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = key_start; i < key_max; i++)
        {
            uint32_t key;

            if(keys)
                key = keys[i];
            else
                key = null_key;

            uint32_t key2 = keys2[i];

            bool* b;

            if(a == 0)
            {
                b = &PlayerControls::GetButton(c, i);
                *b = false;
            }
            else if(a == 1)
            {
                b = &CursorControls::GetButton(m, i);
            }
            else if(a == 2)
            {
                b = &EditorControls::GetButton(e, i);
            }
            else
            {
                b = &activate;
                *b = false;
            }

            if(s_get_button(data, key))
                *b = true;
            else if(s_get_button(data, key2))
                *b = true;

            if(a == 3 && *b)
                h[i] = player;
        }
    }

    // simple editor controls
    if(p->m_simple_editor && LevelEditor && GamePaused == PauseCode::None)
    {
        CursorControls::GetButton(m, CursorControls::Buttons::Primary) = PlayerControls::GetButton(c, PlayerControls::Buttons::Jump);
        CursorControls::GetButton(m, CursorControls::Buttons::Secondary) = false;
        CursorControls::GetButton(m, CursorControls::Buttons::Tertiary) = false;

        EditorControls::GetButton(e, EditorControls::FastScroll) = false;
        EditorControls::GetButton(e, EditorControls::PrevSection) = false;
        EditorControls::GetButton(e, EditorControls::NextSection) = false;

        EditorControls::GetButton(e, EditorControls::ModeSelect) |= PlayerControls::GetButton(c, PlayerControls::Buttons::Run);
        EditorControls::GetButton(e, EditorControls::ModeErase) |= PlayerControls::GetButton(c, PlayerControls::Buttons::AltJump);
        EditorControls::GetButton(e, EditorControls::SwitchScreens) |= PlayerControls::GetButton(c, PlayerControls::Buttons::Drop);
        EditorControls::GetButton(e, EditorControls::TestPlay) |= PlayerControls::GetButton(c, PlayerControls::Buttons::Start);
    }

    // analogue controls
    num_t cursor[4] = {0, 0, 0, 0};
    num_t scroll[4] = {0, 0, 0, 0};

    for(int i = 0; i < 4; i++)
    {
        if(p->m_simple_editor && LevelEditor && GamePaused == PauseCode::None)
        {
            cursor[i] += s_get_button_dbl(data, p->m_keys[i]);
            cursor[i] += s_get_button_dbl(data, p->m_keys2[i]);
        }
        else
        {
            scroll[i] += s_get_button_dbl(data, p->m_editor_keys[i]);
            scroll[i] += s_get_button_dbl(data, p->m_editor_keys2[i]);
            cursor[i] += s_get_button_dbl(data, p->m_cursor_keys[i]);
            cursor[i] += s_get_button_dbl(data, p->m_cursor_keys2[i]);
        }
    }

    // Scroll control (UDLR)
    num_t* const scroll_dest[4] = {&e.ScrollUp, &e.ScrollDown, &e.ScrollLeft, &e.ScrollRight};
    for(int i = 0; i < 4; i++)
        *scroll_dest[i] += scroll[i] * 10;

    // Cursor control (UDLR)
    if(cursor[0] || cursor[1] || cursor[2] || cursor[3])
    {
        bool edge_scroll = LevelEditor && !MagicHand;

        if(m.X < 0)
            m.X = XRender::TargetW / 2;

        if(m.Y < 0)
            m.Y = XRender::TargetH / 2;

        m.X += (cursor[3] - cursor[2]) * 16;
        m.Y += (cursor[1] - cursor[0]) * 16;

        if(m.X < 0)
        {
            if(edge_scroll)
                e.ScrollLeft += -m.X;

            m.X = 0;
        }
        else if(m.X >= XRender::TargetW)
        {
            if(edge_scroll)
                e.ScrollRight += m.X - (XRender::TargetW - 1);

            m.X = XRender::TargetW - 1;
        }

        if(m.Y < 0)
        {
            if(edge_scroll)
                e.ScrollUp += -m.Y;

            m.Y = 0;
        }
        else if(m.Y >= XRender::TargetH)
        {
            if(edge_scroll)
                e.ScrollDown += m.Y - (XRender::TargetH - 1);

            m.Y = XRender::TargetH - 1;
        }

        m.Move = true;
    }

    return true;
}

void InputMethod_GameCube::Rumble(int ms, float strength)
{
    UNUSED(strength);

    PAD_ControlMotor(m_chn, PAD_MOTOR_RUMBLE);

    m_rumble_ticks = ms / 15 + 1;
}

StatusInfo InputMethod_GameCube::GetStatus()
{
    StatusInfo res;
    res.power_status = StatusInfo::POWER_WIRED;

    return res;
}

/*====================================================*\
|| implementation for InputMethodProfile_GameCube     ||
\*====================================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_GameCube::InputMethodProfile_GameCube()
{
    this->m_simple_editor = true;

    this->m_keys[PlayerControls::Buttons::Up] = PAD_BUTTON_UP;
    this->m_keys[PlayerControls::Buttons::Down] = PAD_BUTTON_DOWN;
    this->m_keys[PlayerControls::Buttons::Left] = PAD_BUTTON_LEFT;
    this->m_keys[PlayerControls::Buttons::Right] = PAD_BUTTON_RIGHT;

    this->m_keys[PlayerControls::Buttons::Jump] = PAD_BUTTON_A;
    this->m_keys[PlayerControls::Buttons::AltJump] = PAD_BUTTON_X;
    this->m_keys[PlayerControls::Buttons::Run] = PAD_BUTTON_B;
    this->m_keys[PlayerControls::Buttons::AltRun] = PAD_BUTTON_Y;

    this->m_keys[PlayerControls::Buttons::Drop] = PAD_TRIGGER_Z;
    this->m_keys[PlayerControls::Buttons::Start] = PAD_BUTTON_START;

    // clear all of them, then fill in some of them
    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
        this->m_keys2[i] = null_key;

    this->m_keys2[PlayerControls::Buttons::Up] = PAD_STICK_LU;
    this->m_keys2[PlayerControls::Buttons::Down] = PAD_STICK_LD;
    this->m_keys2[PlayerControls::Buttons::Left] = PAD_STICK_LL;
    this->m_keys2[PlayerControls::Buttons::Right] = PAD_STICK_LR;

    this->m_keys2[PlayerControls::Buttons::AltJump] = PAD_TRIGGER_R;
    this->m_keys2[PlayerControls::Buttons::AltRun] = PAD_TRIGGER_L;

    // clear all of the non-standard controls, then fill in some of them
    for(size_t i = 0; i < CursorControls::n_buttons; i++)
    {
        this->m_cursor_keys[i] = null_key;
        this->m_cursor_keys2[i] = null_key;
    }

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
    {
        this->m_editor_keys[i] = null_key;
        this->m_editor_keys2[i] = null_key;
    }

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        this->m_hotkeys[i] = null_key;
        this->m_hotkeys2[i] = null_key;
    }

    this->m_cursor_keys[CursorControls::Buttons::CursorUp] = PAD_STICK_RU;
    this->m_cursor_keys[CursorControls::Buttons::CursorDown] = PAD_STICK_RD;
    this->m_cursor_keys[CursorControls::Buttons::CursorLeft] = PAD_STICK_RL;
    this->m_cursor_keys[CursorControls::Buttons::CursorRight] = PAD_STICK_RR;
}

bool InputMethodProfile_GameCube::PollPrimaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    InputMethodType_GameCube* t = dynamic_cast<InputMethodType_GameCube*>(this->Type);

    if(!t)
        return true;

    if(this->m_simple_editor && c == ControlsClass::Editor)
        return true;

    uint32_t key = t->PollKeyAll();

    // if didn't find any key, allow poll in future but return false
    if(key == null_key)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    this->m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    uint32_t* keys;
    uint32_t* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = this->m_cursor_keys;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Joystick primary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key
    // if a button's secondary key (including the current one) is the new key, delete it.
    // if a button's primary key (excluding the current one) is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, replace it with the button the player is replacing.
    for(size_t j = 0; j < key_max; j++)
    {
        if(keys2[j] == key)
        {
            keys2[j] = null_key;
        }
        else if(i != j && keys[j] == key)
        {
            if(keys2[j] == null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else
            {
                keys[j] = keys[i];
            }
        }
    }

    keys[i] = key;
    return true;
}

bool InputMethodProfile_GameCube::PollSecondaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    InputMethodType_GameCube* t = dynamic_cast<InputMethodType_GameCube*>(this->Type);

    if(!t)
        return true;

    if(this->m_simple_editor && c == ControlsClass::Editor)
        return true;

    uint32_t key = t->PollKeyAll();

    // if didn't find any key, allow poll in future but return false
    if(key == null_key)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    uint32_t* keys;
    uint32_t* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = this->m_cursor_keys;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Joystick secondary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key

    // if the current button's primary key is the new key,
    //     delete its secondary key instead of setting it.
    if(keys[i] == key)
    {
        keys2[i] = null_key;
        return true;
    }

    // if another button's secondary key is the new key, delete it.
    // if another button's primary key is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, if this button's secondary key is defined, overwrite the other's with this.
    //     if all else fails, overwrite the other button's with this button's PRIMARY key and assign
    //         this button's PRIMARY key instead

    bool can_do_secondary = true;

    for(size_t j = 0; j < key_max; j++)
    {
        if(i != j && keys2[j] == key)
        {
            keys2[j] = null_key;
        }
        else if(i != j && keys[j] == key)
        {
            if(keys2[j] != null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else if(keys2[i] != null_key)
            {
                keys[j] = keys2[i];
            }
            else
            {
                keys[j] = keys[i];
                can_do_secondary = false;
            }
        }
    }

    if(can_do_secondary)
        keys2[i] = key;
    else
        keys[i] = key;

    return true;
}

bool InputMethodProfile_GameCube::DeletePrimaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    uint32_t* keys;
    uint32_t* keys2;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = this->m_cursor_keys;
        keys2 = this->m_cursor_keys2;
    }
    else if(c == ControlsClass::Editor)
    {
        if(this->m_simple_editor)
            return false;

        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
    }
    else
    {
        D_pLogWarning("Attempted to delete Joystick primary button with disallowed controls class %d\n", (int)c);
        return false;
    }

    if(keys2[i] != null_key)
    {
        keys[i] = keys2[i];
        keys2[i] = null_key;
        return true;
    }

    if(c == ControlsClass::Player)
        return false;

    if(keys[i] != null_key)
    {
        keys[i] = null_key;
        return true;
    }

    return false;
}

bool InputMethodProfile_GameCube::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    uint32_t* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
    {
        if(this->m_simple_editor)
            return false;

        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return false; // BAD!

    if(keys2[i] != null_key)
    {
        keys2[i] = null_key;
        return true;
    }

    return false;
}

const char* InputMethodProfile_GameCube::NamePrimaryButton(ControlsClass c, size_t i)
{
    uint32_t* keys;

    if(c == ControlsClass::Player)
        keys = this->m_keys;
    else if(c == ControlsClass::Cursor)
        keys = this->m_cursor_keys;
    else if(c == ControlsClass::Editor && this->m_simple_editor)
    {
        keys = this->m_keys;

        if(i == EditorControls::Buttons::ModeSelect)
            i = PlayerControls::Buttons::Run;
        else if(i == EditorControls::Buttons::ModeErase)
            i = PlayerControls::Buttons::AltJump;
        else if(i == EditorControls::Buttons::SwitchScreens)
            i = PlayerControls::Buttons::Drop;
        else if(i == EditorControls::Buttons::TestPlay)
            i = PlayerControls::Buttons::Start;
        else
            return g_mainMenu.caseNone.c_str();
    }
    else if(c == ControlsClass::Editor)
        keys = this->m_editor_keys;
    else if(c == ControlsClass::Hotkey)
        keys = this->m_hotkeys;
    else
        return "";

    return s_get_name(keys[i]);
}

const char* InputMethodProfile_GameCube::NameSecondaryButton(ControlsClass c, size_t i)
{
    uint32_t* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor && this->m_simple_editor)
    {
        keys2 = this->m_keys2;

        if(i == EditorControls::Buttons::ModeSelect)
            i = PlayerControls::Buttons::Run;
        else if(i == EditorControls::Buttons::ModeErase)
            i = PlayerControls::Buttons::AltJump;
        else if(i == EditorControls::Buttons::SwitchScreens)
            i = PlayerControls::Buttons::Drop;
        else if(i == EditorControls::Buttons::TestPlay)
            i = PlayerControls::Buttons::Start;
        else
            return "";
    }
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return "";

    return s_get_name(keys2[i]);
}

void InputMethodProfile_GameCube::SaveConfig(IniProcessing* ctl)
{
    std::string name;

    for(int a = 0; a < 4; a++)
    {
        uint32_t* keys;
        uint32_t* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = this->m_cursor_keys;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            ctl->setValue(name.c_str(), keys[i]);

            name += '2';

            ctl->setValue(name.c_str(), keys2[i]);
        }
    }

    ctl->setValue("simple-editor", this->m_simple_editor);
}

void InputMethodProfile_GameCube::LoadConfig(IniProcessing* ctl)
{
    std::string name;

    for(int a = 0; a < 4; a++)
    {
        uint32_t* keys;
        uint32_t* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = this->m_cursor_keys;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            ctl->read(name.c_str(), keys[i], keys[i]);

            name += '2';

            ctl->read(name.c_str(), keys2[i], keys2[i]);
        }
    }

    ctl->read("simple-editor", this->m_simple_editor, true);
}

size_t InputMethodProfile_GameCube::GetOptionCount_Custom()
{
    return 1;
}

const char *InputMethodProfile_GameCube::GetOptionName_Custom(size_t i)
{
    UNUSED(i);

    return g_controlsStrings.joystickSimpleEditor.c_str();
}

const char *InputMethodProfile_GameCube::GetOptionValue_Custom(size_t i)
{
    UNUSED(i);

    if(this->m_simple_editor)
        return g_mainMenu.wordOn.c_str();
    else
        return g_mainMenu.wordOff.c_str();
}

bool InputMethodProfile_GameCube::OptionChange_Custom(size_t i)
{
    return this->OptionRotateRight_Custom(i);
}

bool InputMethodProfile_GameCube::OptionRotateLeft_Custom(size_t i)
{
    return this->OptionRotateRight_Custom(i);
}

bool InputMethodProfile_GameCube::OptionRotateRight_Custom(size_t i)
{
    UNUSED(i);

    this->m_simple_editor = !this->m_simple_editor;

    return true;
}

/*====================================================*\
|| implementation for InputMethodType_GameCube        ||
\*====================================================*/

InputMethodProfile* InputMethodType_GameCube::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_GameCube;
}

InputMethodType_GameCube::InputMethodType_GameCube()
{
    this->Name = "GameCube";
    PAD_Init();
}

InputMethodType_GameCube::~InputMethodType_GameCube()
{
}

const std::string& InputMethodType_GameCube::LocalName() const
{
    return g_controlsStrings.wiiTypeGamecube;
}

bool InputMethodType_GameCube::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_GameCube*>(profile);
}

bool InputMethodType_GameCube::RumbleSupported()
{
    return true;
}

bool InputMethodType_GameCube::PowerStatusSupported()
{
    return false;
}

void InputMethodType_GameCube::UpdateControlsPre()
{
    PAD_Read(m_status_raw);

    for(int chn = 0; chn < 4; chn++)
    {
        if(m_status_raw[chn].err == PAD_ERR_NONE || m_status_raw[chn].err == PAD_ERR_NO_CONTROLLER)
            m_status[chn] = m_status_raw[chn];
    }

    for(int chn = 0; chn < 4; chn++)
    {
        if(m_status[chn].err != PAD_ERR_NONE)
            m_chnConnected[chn] = 0;
        else if(m_chnConnected[chn] < 8)
            m_chnConnected[chn]++;
    }
}

void InputMethodType_GameCube::UpdateControlsPost() {}

InputMethod* InputMethodType_GameCube::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    std::array<bool, 4> in_use = {false};

    for(InputMethod* method : active_methods)
    {
        InputMethod_GameCube* m = dynamic_cast<InputMethod_GameCube*>(method);
        if(!m)
            continue;

        if(m->m_chn >= 0 || m->m_chn < 4)
            in_use[m->m_chn] = true;
    }

    int chn = 0;

    for(chn = 0; chn < 4; chn++)
    {
        if(in_use[chn])
            continue;

        const PADStatus* data = &m_status[chn];

        if(data->err != PAD_ERR_NONE)
            continue;

        // newly connected controller
        bool newly_connected = (m_chnConnected[chn] < 8);

        uint32_t key = null_key;

        for(uint32_t but : gamecube_buttons)
        {
            if(s_get_button(data, but))
            {
                key = but;
                break;
            }
        }

        if(key != null_key || newly_connected)
            break;
    }

    // if didn't find any controller allow poll in future but return false
    if(chn == 4)
    {
        this->m_canPoll = true;
        return nullptr;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return nullptr;

    // we're going to create a new gamecube controller!
    // reset canPoll for next time
    this->m_canPoll = false;

    InputMethod_GameCube* method = new(std::nothrow) InputMethod_GameCube(chn);

    if(!method)
        return nullptr;

    method->Name = g_controlsStrings.wiiTypeGamecube;

    method->Name += " ";
    method->Name += std::to_string(chn + 1);
    method->Type = this;

    return (InputMethod*)method;
}

uint32_t InputMethodType_GameCube::PollKeyAll() const
{
    for(int chn = 0; chn < 4; chn++)
    {
        const PADStatus* data = &m_status[chn];

        if(data->err != PAD_ERR_NONE)
            continue;

        for(uint32_t but : gamecube_buttons)
        {
            if(s_get_button(data, but))
                return but;
        }
    }

    return null_key;
}

} // namespace Controls


================================================
FILE: src/control/input_wii_gc.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef INPUT_WII_GC_H
#define INPUT_WII_GC_H

#include "../controls.h"
#include "control/input_wii.h"

#include <string>

namespace Controls
{

class InputMethod_GameCube : public InputMethod
{
public:
    using InputMethod::Type;
    using InputMethod::Profile;

    int m_chn = 0;
    int m_rumble_ticks = 0;

    InputMethod_GameCube(int chn) : m_chn(chn) {}
    ~InputMethod_GameCube();

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);

    StatusInfo GetStatus();
};

class InputMethodProfile_GameCube : public InputMethodProfile
{
private:
    bool m_canPoll = false;

public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    // current settings
    bool m_simple_editor = true;

    // primary keys (also controller keys in legacy mode)
    uint32_t m_keys[PlayerControls::n_buttons];
    // secondary keys (also joystick keys in legacy mode)
    uint32_t m_keys2[PlayerControls::n_buttons];

    // cursor keys
    uint32_t m_cursor_keys[CursorControls::n_buttons];
    uint32_t m_cursor_keys2[CursorControls::n_buttons];

    // editor keys
    uint32_t m_editor_keys[EditorControls::n_buttons];
    uint32_t m_editor_keys2[EditorControls::n_buttons];

    // hotkeys
    uint32_t m_hotkeys[Hotkeys::n_buttons];
    uint32_t m_hotkeys2[Hotkeys::n_buttons];

    InputMethodProfile_GameCube();

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);

public:
    // How many per-type special options are there?
    size_t GetOptionCount_Custom();
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount_Custom() returns 0.
    // get a char* describing the option
    const char *GetOptionName_Custom(size_t i);
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue_Custom(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange_Custom(size_t i);
    // called when left is pressed
    bool OptionRotateLeft_Custom(size_t i);
    // called when right is pressed
    bool OptionRotateRight_Custom(size_t i);
};

class InputMethodType_GameCube : public InputMethodType
{
private:
    InputMethodProfile *AllocateProfile() noexcept override;

public:
    using InputMethodType::Name;
    using InputMethodType::m_profiles;

    bool m_canPoll = false;

    PADStatus m_status_raw[4];
    PADStatus m_status[4];

    // how many frames has the controller been connected?
    std::array<uint8_t, 4> m_chnConnected{0};

    InputMethodType_GameCube();
    ~InputMethodType_GameCube();

    const std::string& LocalName() const override;

    bool TestProfileType(InputMethodProfile *profile) override;
    bool RumbleSupported() override;
    bool PowerStatusSupported() override;

    void UpdateControlsPre() override;
    void UpdateControlsPost() override;

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept override;

    uint32_t PollKeyAll() const;
};

} // namespace Controls

#endif // #ifndef INPUT_WII_GC_H


================================================
FILE: src/control/joystick.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>

#include <SDL2/SDL_version.h>
#include <SDL2/SDL_joystick.h>
#include <SDL2/SDL_gamecontroller.h>
#include <SDL2/SDL_haptic.h>
#include <SDL2/SDL_events.h>

#ifdef VITA
#    include <vitasdk.h>
#endif

#include <Utils/strings.h>
#include <Logger/logger.h>

#include "core/render.h"

#include "config.h"
#include "../controls.h"
#include "joystick.h"

#include "main/menu_main.h"
#include "control/controls_strings.h"
#include "game_main.h"

namespace Controls
{

// hardcoded list of GUIDs that prefer alt (Japanese) menu control layout -- middle 16 bytes only
static const char* s_alt_guids_16[] =
{
    "7e05000006030000", // Wii Classic Controller
    "7e05000030030000", // Wii U Pro Controller
    "7e05000006200000", // Switch 1 Joy-Con (L)
    "7e05000007200000", // Switch 1 Joy-Con (R)
    "7e05000008200000", // Switch 1 Joy-Cons
    "7e05000009200000", // Switch 1 Pro Controller
    "7e05000017200000", // Switch 1 SNES Controller
    "7e05000069200000", // Switch 2 Pro Controller
    "d620000013a70000", // PowerA Switch 1 Controller
    "d620000011a70000", // PowerA Core Plus Switch 1 Controller
    "4c69632050726f20", // Switch 1 Pro Controller (alt GUID)
#ifdef __WIIU__ // Special GUIDs on Wii U
    "5769692055204761", // Wii U GamePad (on Wii U)
    "5769692055205072", // Wii U Pro Controller (on Wii U)
    "57696920436c6173", // Wii Classic Controller (on Wii U)
#endif
#ifdef __SWITCH__ // Special GUIDs on Switch 1
    "5377697463682043", // Switch 1 virtual controller
#endif
};

static const char* s_alt_guids_32[] =
{
    "050000005769696d6f74652028313800", // Wii U Pro Controller (alt GUID)
};

// hardcoded list of Wii Remote GUIDs for special layout -- middle 16 bytes only
static const char *s_wii_remote_guids_32[] =
{
    "050000005769696d6f74652028303000",
    "050000007e0500000603000000060000",
#ifdef __WIIU__
    "000000005769692052656d6f74650000", // Wii Remote (on Wii U)
#endif
};

static const char *s_wii_nunchack_guids_32[] =
{
#ifdef __WIIU__
    "00000000576969204e756e6368756b00", // Wii Remote + Nunchack (on Wii U)
    "0000bce1576969204e756e6368756b00", // Wii Remote + Nunchack (on Wii U)
#endif
    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Dummy, remove if any non-Wii-U entries will be added
};

static bool s_AltControlsDefault(const std::string& guid)
{
    if(guid.size() != 32)
        return false;

    for(size_t i = 0; i < sizeof(s_alt_guids_32) / sizeof(const char*); i++)
    {
        if(SDL_memcmp(guid.c_str(), s_alt_guids_32[i], 32) == 0)
            return true;
    }

    for(size_t i = 0; i < sizeof(s_alt_guids_16) / sizeof(const char*); i++)
    {
        if(SDL_memcmp(guid.c_str() + 8, s_alt_guids_16[i], 16) == 0)
            return true;
    }

    return false;
}

static bool s_WiiRemoteControlsDefault(const std::string& guid)
{
    if(guid.size() != 32)
        return false;

    for(size_t i = 0; i < sizeof(s_wii_remote_guids_32) / sizeof(const char*); i++)
    {
        if(SDL_memcmp(guid.c_str(), s_wii_remote_guids_32[i], 32) == 0)
            return true;
    }

    return false;
}

static bool s_WiiRemoteNunchackControlsDefault(const std::string& guid)
{
    if(guid.size() != 32)
        return false;

    for(size_t i = 0; i < sizeof(s_wii_nunchack_guids_32) / sizeof(const char*); i++)
    {
        if(SDL_memcmp(guid.c_str(), s_wii_nunchack_guids_32[i], 32) == 0)
            return true;
    }

    return false;
}

/*====================================================*\
|| implementation for InputMethod_Joystick            ||
\*====================================================*/

static void s_updateJoystickKey(SDL_Joystick* j, bool& key, const KM_Key& mkey)
{
    Sint32 val = 0, dx = 0, dy = 0;
    Sint16 val_initial = 0;
    bool key_new = false;

    switch(mkey.type)
    {
    case KM_Key::JoyAxis:
        //Note: SDL_JoystickGetAxisInitialState is a new API function added into dev version
        //      and doesn't available in already released assemblies
        if(SDL_JoystickGetAxisInitialState(j, mkey.id, &val_initial) == SDL_FALSE)
        {
            key_new = false;
            break;
        }

        val = SDL_JoystickGetAxis(j, mkey.id);

        if(SDL_abs(val) <= 15000)
            key_new = false;
        else if(mkey.val > val_initial)
            key_new = (val > val_initial);
        else if(mkey.val < val_initial)
            key_new = (val < val_initial);
        else
            key_new = false;

        break;

    case KM_Key::JoyBallX:
        SDL_JoystickGetBall(j, mkey.id, &dx, &dy);

        if(mkey.id > 0)
            key_new = (dx > 0);
        else if(mkey.id < 0)
            key_new = (dx < 0);
        else key_new = false;

        break;

    case KM_Key::JoyBallY:
        SDL_JoystickGetBall(j, mkey.id, &dx, &dy);

        if(mkey.id > 0)
            key_new = (dy > 0);
        else if(mkey.id < 0)
            key_new = (dy < 0);
        else key_new = false;

        break;

    case KM_Key::JoyHat:
        val = (Sint32)SDL_JoystickGetHat(j, mkey.id);
        key_new = ((val & mkey.val)) != 0;
        break;

    case KM_Key::JoyButton:
        key_new = (0 != (Sint32)SDL_JoystickGetButton(j, mkey.id));
        break;

    default:
        key_new = false;
        break;
    }

    key |= key_new;
}

static void s_updateCtrlKey(SDL_GameController* c, bool& key, const KM_Key& mkey)
{
    bool key_new = false;

    switch(mkey.type)
    {
    // using brackets to scope val
    case KM_Key::CtrlAxis:
    {
        Sint32 val = SDL_GameControllerGetAxis(c, (SDL_GameControllerAxis)mkey.id);

        if(SDL_abs(val) <= 15000)
            key_new = false;
        else if(mkey.val > 0)
            key_new = (val > 0);
        else if(mkey.val < 0)
            key_new = (val < 0);
        else
            key_new = false;

        break;
    }

    case KM_Key::CtrlButton:
        key_new = (SDL_GameControllerGetButton(c, (SDL_GameControllerButton)mkey.id) != 0);
        break;

    default:
        key_new = false;
        break;
    }

    key |= key_new;
}

static void s_updateJoystickAnalogue(SDL_Joystick* j, num_t& amount, const KM_Key& mkey, num_t digital_amount = 1)
{
    Sint32 val = 0, dx = 0, dy = 0;
    Sint16 val_initial = 0;
    num_t amount_new = 0;

    switch(mkey.type)
    {
    case KM_Key::JoyAxis:
        //Note: SDL_JoystickGetAxisInitialState is a new API function added into dev version
        //      and doesn't available in already released assemblies
        if(SDL_JoystickGetAxisInitialState(j, mkey.id, &val_initial) == SDL_FALSE)
        {
            amount_new = 0;
            break;
        }

        val = SDL_JoystickGetAxis(j, mkey.id);

        if(SDL_abs(val) <= 15000)
        {
            amount_new = 0;
        }
        else if(mkey.val > val_initial)
        {
            amount_new = num_t(val - val_initial) / (32768 - val_initial);
            num_t other_amount_new = num_t(val - 15000) / (32768 - 15000);

            if(other_amount_new > 0 && other_amount_new < amount_new)
                amount_new = other_amount_new;
        }
        else if(mkey.val < val_initial)
        {
            amount_new = num_t(val_initial - val) / (val_initial + 32768);
            num_t other_amount_new = num_t(-val - 15000) / (32768 - 15000);

            if(other_amount_new > 0 && other_amount_new < amount_new)
                amount_new = other_amount_new;
        }
        else
        {
            amount_new = 0;
        }

        break;

    case KM_Key::JoyBallX:
        SDL_JoystickGetBall(j, mkey.id, &dx, &dy);

        if(mkey.id > 0)
            amount_new = num_t(dx) / 32;
        else if(mkey.id < 0)
            amount_new = num_t(-dx) / 32;
        else
            amount_new = 0;

        break;

    case KM_Key::JoyBallY:
        SDL_JoystickGetBall(j, mkey.id, &dx, &dy);

        if(mkey.id > 0)
            amount_new = num_t(dy) / 32;
        else if(mkey.id < 0)
            amount_new = num_t(dy) / 32;
        else
            amount_new = 0;

        break;

    case KM_Key::JoyHat:
        val = (Sint32)SDL_JoystickGetHat(j, mkey.id);

        if((val & mkey.val))
            amount_new = digital_amount;

        break;

    case KM_Key::JoyButton:
        if((Sint32)SDL_JoystickGetButton(j, mkey.id))
            amount_new = digital_amount;

        break;

    default:
        amount_new = 0;
        break;
    }

    if(amount_new > 0)
        amount = amount_new;
}

static void s_updateCtrlAnalogue(SDL_GameController* c, num_t& amount, const KM_Key& mkey, num_t digital_amount = 1)
{
    num_t amount_new = 0;

    switch(mkey.type)
    {
    // using brackets to scope val
    case KM_Key::CtrlAxis:
    {
        Sint32 val = SDL_GameControllerGetAxis(c, (SDL_GameControllerAxis)mkey.id);

        if(SDL_abs(val) <= 15000)
            amount_new = 0;
        else if(mkey.val > 0)
            amount_new = num_t(val - 15000) / (32768 - 15000);
        else if(mkey.val < 0)
            amount_new = num_t(-val - 15000) / (32768 - 15000);
        else
            amount_new = 0;

        break;
    }

    case KM_Key::CtrlButton:
        if(SDL_GameControllerGetButton(c, (SDL_GameControllerButton)mkey.id) != 0)
            amount_new = digital_amount;

        break;

    default:
        amount_new = 0;
        break;
    }

    if(amount_new > 0)
        amount = amount_new;
}

static bool s_bindJoystickKey(SDL_Joystick* joy, KM_Key& k)
{
    Sint32 val = 0;
    Sint16 val_initial = 0;
    int dx = 0, dy = 0;
    int balls = SDL_JoystickNumBalls(joy);
    int hats = SDL_JoystickNumHats(joy);
    int buttons = SDL_JoystickNumButtons(joy);
    int axes = SDL_JoystickNumAxes(joy);

    for(int i = 0; i < buttons; i++)
    {
        val = SDL_JoystickGetButton(joy, i);

        if(val != 0)
        {
            k.val = val;
            k.id = i;
            k.type = (int)KM_Key::JoyButton;
            return true;
        }
    }

    for(int i = 0; i < hats; i++)
    {
        val = SDL_JoystickGetHat(joy, i);

        if(val != 0)
        {
            k.val = val;
            k.id = i;
            k.type = (int)KM_Key::JoyHat;
            return true;
        }
    }

    for(int i = 0; i < axes; i++)
    {
        //Note: The SDL 2.0.6 and higher is requires to support this function
        if(SDL_JoystickGetAxisInitialState(joy, i, &val_initial) == SDL_FALSE)
            break;

        val = SDL_JoystickGetAxis(joy, i);

        if(SDL_abs(val) > 15000 && val != (Sint32)val_initial)
        {
            k.val = val;
            k.id = i;
            k.type = (int)KM_Key::JoyAxis;
            return true;
        }
    }

    for(int i = 0; i < balls; i++)
    {
        dx = 0;
        dy = 0;
        SDL_JoystickGetBall(joy, i, &dx, &dy);

        if(dx != 0)
        {
            k.val = dx;
            k.id = i;
            k.type = (int)KM_Key::JoyBallX;
            return true;
        }
        else if(dy != 0)
        {
            k.val = dy;
            k.id = i;
            k.type = (int)KM_Key::JoyBallY;
            return true;
        }
    }

    k.val = 0;
    k.id = 0;
    k.type = (int)KM_Key::NoControl;
    return false;
}

static bool s_bindControllerKey(SDL_GameController* ctrl, KM_Key& k)
{
    Sint32 val = 0;

    for(int i = 0; i < SDL_CONTROLLER_BUTTON_MAX; i++)
    {
        val = SDL_GameControllerGetButton(ctrl, (SDL_GameControllerButton)i);

        if(val != 0)
        {
            k.val = val;
            k.id = i;
            k.type = (int)KM_Key::CtrlButton;
            return true;
        }
    }

    for(int i = 0; i < SDL_CONTROLLER_AXIS_MAX; i++)
    {
        val = SDL_GameControllerGetAxis(ctrl, (SDL_GameControllerAxis)i);

        if(SDL_abs(val) > 15000)
        {
            k.val = val;
            k.id = i;
            k.type = (int)KM_Key::CtrlAxis;
            return true;
        }
    }

    k.val = 0;
    k.id = 0;
    k.type = (int)KM_Key::NoControl;
    return false;
}

/*====================================================*\
|| implementation for InputMethod_Joystick            ||
\*====================================================*/

InputMethod_Joystick::~InputMethod_Joystick()
{
    if(this->m_devices)
        this->m_devices->can_poll = false;
}

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_Joystick::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    InputMethodProfile_Joystick* p = dynamic_cast<InputMethodProfile_Joystick*>(this->Profile);

    if(!p || !this->m_devices)
        return false;

    if(!SDL_JoystickGetAttached(this->m_devices->joy))
    {
        // note: the joystick is owned by the InputMethodType, not the InputMethod.
        this->m_devices = nullptr;
        return false;
    }

    for(int a = 0; a < 4; a++)
    {
        KM_Key* keys;
        KM_Key* keys2;
        size_t key_start;
        size_t key_max;
        bool activate = false;

        if(a == 0)
        {
            keys = p->m_keys;
            keys2 = p->m_keys2;
            key_start = 0;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = p->m_cursor_keys;
            keys2 = p->m_cursor_keys2;
            key_start = 4;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = p->m_editor_keys;
            keys2 = p->m_editor_keys2;
            key_start = 4;
            key_max = EditorControls::n_buttons;

            if(p->m_simple_editor && LevelEditor && GamePaused == PauseCode::None)
                continue;
        }
        else
        {
            keys = p->m_hotkeys;
            keys2 = p->m_hotkeys2;
            key_start = 0;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = key_start; i < key_max; i++)
        {
            const KM_Key& key = keys[i];
            const KM_Key& key2 = keys2[i];
            bool* b;

            if(a == 0)
            {
                b = &PlayerControls::GetButton(c, i);
                *b = false;
            }
            else if(a == 1)
            {
                b = &CursorControls::GetButton(m, i);
            }
            else if(a == 2)
            {
                b = &EditorControls::GetButton(e, i);
            }
            else
            {
                b = &activate;
                *b = false;
            }

            if(p->m_controllerProfile && this->m_devices->ctrl)
            {
                s_updateCtrlKey(this->m_devices->ctrl, *b, key);
                s_updateCtrlKey(this->m_devices->ctrl, *b, key2);
            }
            else
            {
                s_updateJoystickKey(this->m_devices->joy, *b, key);
                s_updateJoystickKey(this->m_devices->joy, *b, key2);
            }

            if(a == 3 && *b)
                h[i] = player;
        }
    }

    // simple editor controls
    if(p->m_simple_editor && LevelEditor && GamePaused == PauseCode::None)
    {
        CursorControls::GetButton(m, CursorControls::Buttons::Primary) = PlayerControls::GetButton(c, PlayerControls::Buttons::Jump);
        CursorControls::GetButton(m, CursorControls::Buttons::Secondary) = false;
        CursorControls::GetButton(m, CursorControls::Buttons::Tertiary) = false;

        EditorControls::GetButton(e, EditorControls::FastScroll) = false;
        EditorControls::GetButton(e, EditorControls::PrevSection) = false;
        EditorControls::GetButton(e, EditorControls::NextSection) = false;

        EditorControls::GetButton(e, EditorControls::ModeSelect) |= PlayerControls::GetButton(c, PlayerControls::Buttons::Run);
        EditorControls::GetButton(e, EditorControls::ModeErase) |= PlayerControls::GetButton(c, PlayerControls::Buttons::AltJump);
        EditorControls::GetButton(e, EditorControls::SwitchScreens) |= PlayerControls::GetButton(c, PlayerControls::Buttons::Drop);
        EditorControls::GetButton(e, EditorControls::TestPlay) |= PlayerControls::GetButton(c, PlayerControls::Buttons::Start);
    }

    // analogue controls
    num_t cursor[4] = {0, 0, 0, 0};
    num_t scroll[4] = {0, 0, 0, 0};

    if(p->m_controllerProfile && this->m_devices->ctrl)
    {
        for(int i = 0; i < 4; i++)
        {
            if(p->m_simple_editor && LevelEditor && GamePaused == PauseCode::None)
            {
                s_updateCtrlAnalogue(this->m_devices->ctrl, cursor[i], p->m_keys[i], 0.5_n);
                s_updateCtrlAnalogue(this->m_devices->ctrl, cursor[i], p->m_keys2[i], 0.5_n);
            }
            else
            {
                s_updateCtrlAnalogue(this->m_devices->ctrl, cursor[i], p->m_cursor_keys[i]);
                s_updateCtrlAnalogue(this->m_devices->ctrl, cursor[i], p->m_cursor_keys2[i]);
                s_updateCtrlAnalogue(this->m_devices->ctrl, scroll[i], p->m_editor_keys[i]);
                s_updateCtrlAnalogue(this->m_devices->ctrl, scroll[i], p->m_editor_keys2[i]);
            }
        }
    }
    else
    {
        for(int i = 0; i < 4; i++)
        {
            if(p->m_simple_editor && LevelEditor && GamePaused == PauseCode::None)
            {
                s_updateJoystickAnalogue(this->m_devices->joy, cursor[i], p->m_keys[i], 0.5_n);
                s_updateJoystickAnalogue(this->m_devices->joy, cursor[i], p->m_keys2[i], 0.5_n);
            }
            else
            {
                s_updateJoystickAnalogue(this->m_devices->joy, cursor[i], p->m_cursor_keys[i]);
                s_updateJoystickAnalogue(this->m_devices->joy, cursor[i], p->m_cursor_keys2[i]);
                s_updateJoystickAnalogue(this->m_devices->joy, scroll[i], p->m_editor_keys[i]);
                s_updateJoystickAnalogue(this->m_devices->joy, scroll[i], p->m_editor_keys2[i]);
            }
        }
    }

    // Scroll control (UDLR)
    num_t* const scroll_dest[4] = {&e.ScrollUp, &e.ScrollDown, &e.ScrollLeft, &e.ScrollRight};
    for(int i = 0; i < 4; i++)
        *scroll_dest[i] += scroll[i] * 10;

    // Cursor control (UDLR)
    if(cursor[0] || cursor[1] || cursor[2] || cursor[3])
    {
        bool edge_scroll = LevelEditor && !MagicHand;

        if(m.X < 0)
            m.X = XRender::TargetW / 2;

        if(m.Y < 0)
            m.Y = XRender::TargetH / 2;

        m.X += (cursor[3] - cursor[2]) * 16;
        m.Y += (cursor[1] - cursor[0]) * 16;

        if(m.X < 0)
        {
            if(edge_scroll)
                e.ScrollLeft += -m.X;

            m.X = 0;
        }
        else if(m.X >= XRender::TargetW)
        {
            if(edge_scroll)
                e.ScrollRight += m.X - (XRender::TargetW - 1);

            m.X = XRender::TargetW - 1;
        }

        if(m.Y < 0)
        {
            if(edge_scroll)
                e.ScrollUp += -m.Y;

            m.Y = 0;
        }
        else if(m.Y >= XRender::TargetH)
        {
            if(edge_scroll)
                e.ScrollDown += m.Y - (XRender::TargetH - 1);

            m.Y = XRender::TargetH - 1;
        }

        m.Move = true;
    }

    return true;
}

void InputMethod_Joystick::Rumble(int ms, float strength)
{
    if(!this->m_devices)
        return;

    if(this->m_devices->haptic)
    {
        pLogDebug("Trying to use SDL haptic rumble: %dms %f", ms, strength);

        if(SDL_HapticRumblePlay(this->m_devices->haptic, strength, ms) == 0)
            return;
    }

    int intStrength = (int)(0xFFFF * strength + 0.5f);

    if(intStrength > 0xFFFF)
        intStrength = 0xFFFF;

    if(intStrength < 0)
        intStrength = 0;

#if SDL_VERSION_ATLEAST(2, 0, 12)
    if(this->m_devices->joy)
    {
        pLogDebug("Trying to use SDL joystick rumble: %dms %f", ms, strength);
        SDL_JoystickRumble(this->m_devices->joy, intStrength, intStrength, ms);
    }
#endif
}

StatusInfo InputMethod_Joystick::GetStatus()
{
    StatusInfo res;

    if(!this->m_devices)
        return res;

    uint32_t ticks = SDL_GetTicks();

    if(this->m_last_power_check > 10000)
    {
        SDL_JoystickPowerLevel level = SDL_JoystickCurrentPowerLevel(this->m_devices->joy);

        if(level == SDL_JOYSTICK_POWER_UNKNOWN)
        {
            res.power_status = StatusInfo::POWER_UNKNOWN;
        }
        else if(level == SDL_JOYSTICK_POWER_WIRED)
        {
            res.power_status = StatusInfo::POWER_WIRED;
        }
        else if(level == SDL_JOYSTICK_POWER_MAX)
        {
            res.power_status = StatusInfo::POWER_CHARGED;
            res.power_level = 1.0_nf;
        }
        else
        {
            res.power_status = StatusInfo::POWER_DISCHARGING;

            if(level == SDL_JOYSTICK_POWER_EMPTY)
                res.power_level = 0.15_nf;

            if(level == SDL_JOYSTICK_POWER_LOW)
                res.power_level = 0.3_nf;

            if(level == SDL_JOYSTICK_POWER_MEDIUM)
                res.power_level = 0.6_nf;

            if(level == SDL_JOYSTICK_POWER_FULL)
                res.power_level = 0.9_nf;
        }

        m_last_power_check = ticks;
        m_recent_status = res;
    }

    return m_recent_status;
}

/*====================================================*\
|| implementation for InputMethodProfile_Joystick     ||
\*====================================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_Joystick::InputMethodProfile_Joystick()
{
    this->InitAsController(INIT_AS_DEFAULT);
    this->m_showPowerStatus = false;
}

void InputMethodProfile_Joystick::InitAsJoystick()
{
    this->m_controllerProfile = false;
    this->m_keys[PlayerControls::Buttons::Up].assign(KM_Key::JoyHat, 0, SDL_HAT_UP);
    this->m_keys[PlayerControls::Buttons::Down].assign(KM_Key::JoyHat, 0, SDL_HAT_DOWN);
    this->m_keys[PlayerControls::Buttons::Left].assign(KM_Key::JoyHat, 0, SDL_HAT_LEFT);
    this->m_keys[PlayerControls::Buttons::Right].assign(KM_Key::JoyHat, 0, SDL_HAT_RIGHT);
    this->m_keys[PlayerControls::Buttons::Jump].assign(KM_Key::JoyButton, 0, 1);
    this->m_keys[PlayerControls::Buttons::AltJump].assign(KM_Key::JoyButton, 1, 1);
    this->m_keys[PlayerControls::Buttons::Run].assign(KM_Key::JoyButton, 2, 1);
    this->m_keys[PlayerControls::Buttons::AltRun].assign(KM_Key::JoyButton, 3, 1);
    this->m_keys[PlayerControls::Buttons::Drop].assign(KM_Key::JoyButton, 6, 1);
    this->m_keys[PlayerControls::Buttons::Start].assign(KM_Key::JoyButton, 7, 1);

    // clear all of them, then fill in some of them
    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
        this->m_keys2[i].assign(KM_Key::NoControl, -1, -1);

    this->m_keys2[PlayerControls::Buttons::Up].assign(KM_Key::JoyAxis, 1, -1);
    this->m_keys2[PlayerControls::Buttons::Down].assign(KM_Key::JoyAxis, 1, 1);
    this->m_keys2[PlayerControls::Buttons::Left].assign(KM_Key::JoyAxis, 0, -1);
    this->m_keys2[PlayerControls::Buttons::Right].assign(KM_Key::JoyAxis, 0, 1);
    this->m_keys2[PlayerControls::Buttons::AltRun].assign(KM_Key::JoyButton, 4, 1);
    this->m_keys2[PlayerControls::Buttons::AltJump].assign(KM_Key::JoyButton, 5, 1);

    // clear all of the non-standard controls, then fill in some of them
    for(size_t i = 0; i < CursorControls::n_buttons; i++)
    {
        this->m_cursor_keys[i].assign(KM_Key::NoControl, -1, -1);
        this->m_cursor_keys2[i].assign(KM_Key::NoControl, -1, -1);
    }

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
    {
        this->m_editor_keys[i].assign(KM_Key::NoControl, -1, -1);
        this->m_editor_keys2[i].assign(KM_Key::NoControl, -1, -1);
    }

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        this->m_hotkeys[i].assign(KM_Key::NoControl, -1, -1);
        this->m_hotkeys2[i].assign(KM_Key::NoControl, -1, -1);
    }

    this->m_cursor_keys[CursorControls::Buttons::CursorUp].assign(KM_Key::JoyAxis, 3, -1);
    this->m_cursor_keys[CursorControls::Buttons::CursorDown].assign(KM_Key::JoyAxis, 3, 1);
    this->m_cursor_keys[CursorControls::Buttons::CursorLeft].assign(KM_Key::JoyAxis, 2, -1);
    this->m_cursor_keys[CursorControls::Buttons::CursorRight].assign(KM_Key::JoyAxis, 2, 1);
    this->m_cursor_keys[CursorControls::Buttons::Primary].assign(KM_Key::JoyAxis, 4, 1);
    this->m_cursor_keys[CursorControls::Buttons::Secondary].assign(KM_Key::JoyAxis, 5, 1);
}

void InputMethodProfile_Joystick::InitAsController(InitAs init_as)
{
    this->m_controllerProfile = true;

    this->m_keys[PlayerControls::Buttons::Up].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_DPAD_UP, 1);
    this->m_keys[PlayerControls::Buttons::Down].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_DPAD_DOWN, 1);
    this->m_keys[PlayerControls::Buttons::Left].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_DPAD_LEFT, 1);
    this->m_keys[PlayerControls::Buttons::Right].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, 1);

    if(init_as == INIT_AS_ALT)
    {
        this->m_keys[PlayerControls::Buttons::Jump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_B, 1);
        this->m_keys[PlayerControls::Buttons::AltJump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_A, 1);
        this->m_keys[PlayerControls::Buttons::Run].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_Y, 1);
        this->m_keys[PlayerControls::Buttons::AltRun].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_X, 1);
        this->m_altMenuControls = true;
    }
    else if(init_as == INIT_AS_WII_REMOTE)
    {
        this->m_keys[PlayerControls::Buttons::Jump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_X, 1);
        this->m_keys[PlayerControls::Buttons::AltJump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_A, 1);
        this->m_keys[PlayerControls::Buttons::Run].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_Y, 1);
        this->m_keys[PlayerControls::Buttons::AltRun].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_B, 1);
    }
    else if(init_as == INIT_AS_WII_REMOTE_WITH_NUNCHACK)
    {
        this->m_keys[PlayerControls::Buttons::Jump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_A, 1);
        this->m_keys[PlayerControls::Buttons::AltJump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_X, 1);
        this->m_keys[PlayerControls::Buttons::Run].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_B, 1);
        this->m_keys[PlayerControls::Buttons::AltRun].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_Y, 1);
    }
    else
    {
        this->m_keys[PlayerControls::Buttons::Jump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_A, 1);
        this->m_keys[PlayerControls::Buttons::AltJump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_B, 1);
        this->m_keys[PlayerControls::Buttons::Run].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_X, 1);
        this->m_keys[PlayerControls::Buttons::AltRun].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_Y, 1);

#ifdef VITA
        // Vita's layout under SDL is normal (Cross/A button is South), but Japanese Vitas do use the alt menu controls (Circle button advances in menus)
        int enter_button = SCE_SYSTEM_PARAM_ENTER_BUTTON_CROSS;
        sceAppUtilSystemParamGetInt(SCE_SYSTEM_PARAM_ID_ENTER_BUTTON, &enter_button);
        if(enter_button == SCE_SYSTEM_PARAM_ENTER_BUTTON_CIRCLE)
            this->m_altMenuControls = true;
#endif
    }

    const char *init_as_str;
    switch(init_as)
    {
    default:
        init_as_str = "Standard";
        break;

    case INIT_AS_ALT:
        init_as_str = "Alt";
        break;

    case INIT_AS_WII_REMOTE:
        init_as_str = "Wii Remote";
        break;

    case INIT_AS_WII_REMOTE_WITH_NUNCHACK:
        init_as_str = "Wii Remote + Nunchuk";
        break;
    }

    pLogDebug("Initializing controller with mode: [%s] controls and [%s] menus.",
        init_as_str,
        this->m_altMenuControls ? "Alt" : "Standard");

    this->m_keys[PlayerControls::Buttons::Drop].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_BACK, 1);
    this->m_keys[PlayerControls::Buttons::Start].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_START, 1);

    // clear all of them, then fill in some of them
    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
        this->m_keys2[i].assign(KM_Key::NoControl, -1, -1);

    this->m_keys2[PlayerControls::Buttons::Up].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_LEFTY, -1);
    this->m_keys2[PlayerControls::Buttons::Down].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_LEFTY, 1);
    this->m_keys2[PlayerControls::Buttons::Left].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_LEFTX, -1);
    this->m_keys2[PlayerControls::Buttons::Right].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_LEFTX, 1);

    if(init_as == INIT_AS_WII_REMOTE_WITH_NUNCHACK)
    {
        this->m_keys2[PlayerControls::Buttons::AltRun].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, 1);
        this->m_keys2[PlayerControls::Buttons::AltJump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, 1);
    }
    else
    {
        this->m_keys2[PlayerControls::Buttons::AltRun].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, 1);
        this->m_keys2[PlayerControls::Buttons::AltJump].assign(KM_Key::CtrlButton, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, 1);
    }

    // clear all of the non-standard controls, then fill in some of them
    for(size_t i = 0; i < CursorControls::n_buttons; i++)
    {
        this->m_cursor_keys[i].assign(KM_Key::NoControl, -1, -1);
        this->m_cursor_keys2[i].assign(KM_Key::NoControl, -1, -1);
    }

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
    {
        this->m_editor_keys[i].assign(KM_Key::NoControl, -1, -1);
        this->m_editor_keys2[i].assign(KM_Key::NoControl, -1, -1);
    }

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        this->m_hotkeys[i].assign(KM_Key::NoControl, -1, -1);
        this->m_hotkeys2[i].assign(KM_Key::NoControl, -1, -1);
    }

    this->m_cursor_keys[CursorControls::Buttons::CursorUp].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_RIGHTY, -1);
    this->m_cursor_keys[CursorControls::Buttons::CursorDown].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_RIGHTY, 1);
    this->m_cursor_keys[CursorControls::Buttons::CursorLeft].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_RIGHTX, -1);
    this->m_cursor_keys[CursorControls::Buttons::CursorRight].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_RIGHTX, 1);
    this->m_cursor_keys[CursorControls::Buttons::Primary].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, 1);
    this->m_cursor_keys[CursorControls::Buttons::Secondary].assign(KM_Key::CtrlAxis, SDL_CONTROLLER_AXIS_TRIGGERLEFT, 1);
}

bool InputMethodProfile_Joystick::PollPrimaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    InputMethodType_Joystick* t = dynamic_cast<InputMethodType_Joystick*>(this->Type);

    if(!t)
        return true;

    if(this->m_simple_editor && c == ControlsClass::Editor)
        return true;

    KM_Key key = this->m_controllerProfile ?
                 t->PollControllerKeyAll() :
                 t->PollJoystickKeyAll();

    // if didn't find any key, allow poll in future but return false
    if(key.type == KM_Key::NoControl)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    this->m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    KM_Key* keys;
    KM_Key* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = this->m_cursor_keys;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Joystick primary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key
    // if a button's secondary key (including the current one) is the new key, delete it.
    // if a button's primary key (excluding the current one) is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, replace it with the button the player is replacing.
    for(size_t j = 0; j < key_max; j++)
    {
        if(keys2[j] == key)
        {
            keys2[j] = KM_Key();
        }
        else if(i != j && keys[j] == key)
        {
            if(keys2[j].type != KM_Key::NoControl)
            {
                keys[j] = keys2[j];
                keys2[j] = KM_Key();
            }
            else
            {
                keys[j] = keys[i];
            }
        }
    }

    keys[i] = key;
    return true;
}

bool InputMethodProfile_Joystick::PollSecondaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    InputMethodType_Joystick* t = dynamic_cast<InputMethodType_Joystick*>(this->Type);

    if(!t)
        return true;

    if(this->m_simple_editor && c == ControlsClass::Editor)
        return true;

    KM_Key key;

    if(this->m_controllerProfile)
        key = t->PollControllerKeyAll();
    else
        key = t->PollJoystickKeyAll();

    // if didn't find any key, allow poll in future but return false
    if(key.type == KM_Key::NoControl)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    KM_Key* keys;
    KM_Key* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = this->m_cursor_keys;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Joystick secondary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key

    // if the current button's primary key is the new key,
    //     delete its secondary key instead of setting it.
    if(keys[i] == key)
    {
        keys2[i] = KM_Key();
        return true;
    }

    // if another button's secondary key is the new key, delete it.
    // if another button's primary key is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, if this button's secondary key is defined, overwrite the other's with this.
    //     if all else fails, overwrite the other button's with this button's PRIMARY key and assign
    //         this button's PRIMARY key instead

    bool can_do_secondary = true;

    for(size_t j = 0; j < key_max; j++)
    {
        if(i != j && keys2[j] == key)
        {
            keys2[j] = KM_Key();
        }
        else if(i != j && keys[j] == key)
        {
            if(keys2[j].type != KM_Key::NoControl)
            {
                keys[j] = keys2[j];
                keys2[j] = KM_Key();
            }
            else if(keys2[i].type != KM_Key::NoControl)
            {
                keys[j] = keys2[i];
            }
            else
            {
                keys[j] = keys[i];
                can_do_secondary = false;
            }
        }
    }

    if(can_do_secondary)
        keys2[i] = key;
    else
        keys[i] = key;

    return true;
}

bool InputMethodProfile_Joystick::DeletePrimaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    KM_Key* keys;
    KM_Key* keys2;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = this->m_cursor_keys;
        keys2 = this->m_cursor_keys2;
    }
    else if(c == ControlsClass::Editor)
    {
        if(this->m_simple_editor)
            return false;

        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
    }
    else
    {
        D_pLogWarning("Attempted to delete Joystick primary button with disallowed controls class %d\n", (int)c);
        return false;
    }

    if(keys2[i].type != KM_Key::NoControl)
    {
        keys[i] = keys2[i];
        keys2[i] = KM_Key();
        return true;
    }

    if(c == ControlsClass::Player)
        return false;

    if(keys[i].type != KM_Key::NoControl)
    {
        keys[i] = KM_Key();
        return true;
    }

    return false;
}

bool InputMethodProfile_Joystick::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    KM_Key* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
    {
        if(this->m_simple_editor)
            return false;

        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return false; // BAD!

    if(keys2[i].type != KM_Key::NoControl)
    {
        keys2[i] = KM_Key();
        return true;
    }

    return false;
}

static char s_buttonNameBuffer[16] = "XXXXXXXXXXXXXXX";

static const char* s_nameButton(const KM_Key& k)
{
    switch(k.type)
    {
    case KM_Key::NoControl:
        return "NONE";
        break;

    case KM_Key::CtrlButton:
        return SDL_GameControllerGetStringForButton((SDL_GameControllerButton)k.id);
        break;

    case KM_Key::CtrlAxis:
        if(k.val < 0)
            snprintf(s_buttonNameBuffer, 15, "%s-", SDL_GameControllerGetStringForAxis((SDL_GameControllerAxis)k.id));
        else
            snprintf(s_buttonNameBuffer, 15, "%s+", SDL_GameControllerGetStringForAxis((SDL_GameControllerAxis)k.id));

        break;

    case KM_Key::JoyButton:
        snprintf(s_buttonNameBuffer, 15, "BUT %d", k.id);
        break;

    case KM_Key::JoyAxis:
        if(k.val < 0)
            snprintf(s_buttonNameBuffer, 15, "AX %d-", k.id);
        else
            snprintf(s_buttonNameBuffer, 15, "AX %d+", k.id);

        break;

    case KM_Key::JoyBallX:
        if(k.val < 0)
            snprintf(s_buttonNameBuffer, 15, "BALL %dX-", k.id);
        else
            snprintf(s_buttonNameBuffer, 15, "BALL %dX+", k.id);

        break;

    case KM_Key::JoyBallY:
        if(k.val < 0)
            snprintf(s_buttonNameBuffer, 15, "BALL %dY-", k.id);
        else
            snprintf(s_buttonNameBuffer, 15, "BALL %dY+", k.id);

        break;

    case KM_Key::JoyHat:
        if(k.val == SDL_HAT_UP)
            snprintf(s_buttonNameBuffer, 15, "HAT %dU", k.id);
        else if(k.val == SDL_HAT_DOWN)
            snprintf(s_buttonNameBuffer, 15, "HAT %dD", k.id);
        else if(k.val == SDL_HAT_LEFT)
            snprintf(s_buttonNameBuffer, 15, "HAT %dL", k.id);
        else if(k.val == SDL_HAT_RIGHT)
            snprintf(s_buttonNameBuffer, 15, "HAT %dR", k.id);
        else
            snprintf(s_buttonNameBuffer, 15, "HAT %d %d", k.id, k.val);

        break;

    default:
        return "INVALID";
        break;
    }

    return s_buttonNameBuffer;
}

const char* InputMethodProfile_Joystick::NamePrimaryButton(ControlsClass c, size_t i)
{
    KM_Key* keys;

    if(c == ControlsClass::Player)
        keys = this->m_keys;
    else if(c == ControlsClass::Cursor)
        keys = this->m_cursor_keys;
    else if(c == ControlsClass::Editor && this->m_simple_editor)
    {
        keys = this->m_keys;

        if(i == EditorControls::Buttons::ModeSelect)
            i = PlayerControls::Buttons::Run;
        else if(i == EditorControls::Buttons::ModeErase)
            i = PlayerControls::Buttons::AltJump;
        else if(i == EditorControls::Buttons::SwitchScreens)
            i = PlayerControls::Buttons::Drop;
        else if(i == EditorControls::Buttons::TestPlay)
            i = PlayerControls::Buttons::Start;
        else
            return g_mainMenu.caseNone.c_str();
    }
    else if(c == ControlsClass::Editor)
        keys = this->m_editor_keys;
    else if(c == ControlsClass::Hotkey)
        keys = this->m_hotkeys;
    else
        return "";

    return s_nameButton(keys[i]);
}

const char* InputMethodProfile_Joystick::NameSecondaryButton(ControlsClass c, size_t i)
{
    KM_Key* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor && this->m_simple_editor)
    {
        keys2 = this->m_keys2;

        if(i == EditorControls::Buttons::ModeSelect)
            i = PlayerControls::Buttons::Run;
        else if(i == EditorControls::Buttons::ModeErase)
            i = PlayerControls::Buttons::AltJump;
        else if(i == EditorControls::Buttons::SwitchScreens)
            i = PlayerControls::Buttons::Drop;
        else if(i == EditorControls::Buttons::TestPlay)
            i = PlayerControls::Buttons::Start;
        else
            return "";
    }
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return "";

    return s_nameButton(keys2[i]);
}

void InputMethodProfile_Joystick::SaveConfig(IniProcessing* ctl)
{
    std::string name;

    for(int a = 0; a < 4; a++)
    {
        KM_Key* keys;
        KM_Key* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = this->m_cursor_keys;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            size_t orig_l = name.size();

            ctl->setValue(name.replace(orig_l, std::string::npos, "-type").c_str(),
                          keys[i].type);
            ctl->setValue(name.replace(orig_l, std::string::npos, "-id").c_str(),
                          keys[i].id);
            ctl->setValue(name.replace(orig_l, std::string::npos, "-val").c_str(),
                          keys[i].val);

            ctl->setValue(name.replace(orig_l, std::string::npos, "2-type").c_str(),
                          keys2[i].type);
            ctl->setValue(name.replace(orig_l, std::string::npos, "2-id").c_str(),
                          keys2[i].id);
            ctl->setValue(name.replace(orig_l, std::string::npos, "2-val").c_str(),
                          keys2[i].val);
        }
    }

    ctl->setValue("old-joystick", !this->m_controllerProfile);
    ctl->setValue("simple-editor", this->m_simple_editor);
}

void InputMethodProfile_Joystick::LoadConfig(IniProcessing* ctl)
{
    std::string name;

    for(int a = 0; a < 4; a++)
    {
        KM_Key* keys;
        KM_Key* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = this->m_cursor_keys;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            size_t orig_l = name.size();

            ctl->read(name.replace(orig_l, std::string::npos, "-type").c_str(),
                      keys[i].type, keys[i].type);
            ctl->read(name.replace(orig_l, std::string::npos, "-id").c_str(),
                      keys[i].id, keys[i].id);
            ctl->read(name.replace(orig_l, std::string::npos, "-val").c_str(),
                      keys[i].val, keys[i].val);

            ctl->read(name.replace(orig_l, std::string::npos, "2-type").c_str(),
                      keys2[i].type, keys2[i].type);
            ctl->read(name.replace(orig_l, std::string::npos, "2-id").c_str(),
                      keys2[i].id, keys2[i].id);
            ctl->read(name.replace(orig_l, std::string::npos, "2-val").c_str(),
                      keys2[i].val, keys2[i].val);
        }
    }

    bool legacyProfile;
    ctl->read("old-joystick", legacyProfile, false);
    this->m_controllerProfile = !legacyProfile;

    ctl->read("simple-editor", this->m_simple_editor, true);
}

void InputMethodProfile_Joystick::SaveConfig_Legacy(IniProcessing* ctl)
{
    std::string name;

    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
    {
        name = PlayerControls::GetButtonName_INI(i);
        size_t orig_l = name.size();

        ctl->setValue(name.replace(orig_l, std::string::npos, "-ctrl-type").c_str(),
                      this->m_keys[i].type);
        ctl->setValue(name.replace(orig_l, std::string::npos, "-ctrl-id").c_str(),
                      this->m_keys[i].id);
        ctl->setValue(name.replace(orig_l, std::string::npos, "-ctrl-val").c_str(),
                      this->m_keys[i].val);

        ctl->setValue(name.replace(orig_l, std::string::npos, "-type").c_str(),
                      this->m_keys2[i].type);
        ctl->setValue(name.replace(orig_l, std::string::npos, "-id").c_str(),
                      this->m_keys2[i].id);
        ctl->setValue(name.replace(orig_l, std::string::npos, "-val").c_str(),
                      this->m_keys2[i].val);
    }
}

size_t InputMethodProfile_Joystick::GetOptionCount_Custom()
{
    return 1;
}

const char *InputMethodProfile_Joystick::GetOptionName_Custom(size_t i)
{
    UNUSED(i);

    return g_controlsStrings.joystickSimpleEditor.c_str();
}

const char *InputMethodProfile_Joystick::GetOptionValue_Custom(size_t i)
{
    UNUSED(i);

    if(this->m_simple_editor)
        return g_mainMenu.wordOn.c_str();
    else
        return g_mainMenu.wordOff.c_str();
}

bool InputMethodProfile_Joystick::OptionChange_Custom(size_t i)
{
    return this->OptionRotateRight_Custom(i);
}

bool InputMethodProfile_Joystick::OptionRotateLeft_Custom(size_t i)
{
    return this->OptionRotateRight_Custom(i);
}

bool InputMethodProfile_Joystick::OptionRotateRight_Custom(size_t i)
{
    UNUSED(i);

    this->m_simple_editor = !this->m_simple_editor;

    return true;
}

/*====================================================*\
|| implementation for InputMethodType_Joystick        ||
\*====================================================*/

InputMethodProfile* InputMethodType_Joystick::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_Joystick;
}

InputMethodType_Joystick::InputMethodType_Joystick()
{
    this->Name = "Joystick";

    SDL_JoystickEventState(SDL_ENABLE);

#ifdef __WIIU__
    // Wii Remote
    SDL_GameControllerAddMapping("000000005769692052656d6f74650000,"
                                 "Wii Remote,"
                                 "crc:1d69,"
                                 "x:b7,y:b6,"
                                 "a:b0,b:b1,"
                                 "back:b11,start:b10,"
                                 "dpdown:b12,dpleft:b13,dpright:b15,dpup:b14,");

    // Wii Remote + Nunchack
    SDL_GameControllerAddMapping("00000000576969204e756e6368756b00,"
                                 "Wii Remote + Nunchuk,"
                                 "crc:bce1,"
                                 "a:b0,b:b1,"
                                 "x:b6,y:b7,"
                                 "leftshoulder:b2,rightshoulder:b3,"
                                 "lefttrigger:b8,righttrigger:b9,"
                                 "back:b11,start:b10,"
                                 "dpdown:b15,dpleft:b12,dpright:b14,dpup:b13,"
                                 "leftstick:b4,rightstick:b5,"
                                 "leftx:a0,lefty:a1,"
                                 "rightx:a2,righty:a3,");

    SDL_GameControllerAddMapping("0000bce1576969204e756e6368756b00,"
                                 "Wii Remote + Nunchuk,"
                                 "crc:bce1,"
                                 "a:b0,b:b1,"
                                 "x:b6,y:b7,"
                                 "leftshoulder:b2,rightshoulder:b3,"
                                 "lefttrigger:b8,righttrigger:b9,"
                                 "back:b11,start:b10,"
                                 "dpdown:b15,dpleft:b12,dpright:b14,dpup:b13,"
                                 "leftstick:b4,rightstick:b5,"
                                 "leftx:a0,lefty:a1,"
                                 "rightx:a2,righty:a3,");
#endif

#ifdef __SWITCH__
    // Sets the correct mapping for Switch controllers
    SDL_GameControllerAddMapping("000038f853776974636820436f6e7400,"
                                 "Switch Controller,"
                                 "a:b0,b:b1,x:b2,y:b3,"
                                 "back:b11,start:b10,"
                                 "dpdown:b15,dpleft:b12,dpright:b14,dpup:b13,"
                                 "leftshoulder:b6,rightshoulder:b7,"
                                 "lefttrigger:b8,righttrigger:b9,"
                                 "leftstick:b4,rightstick:b5,"
                                 "leftx:a0,lefty:a1,"
                                 "rightx:a2,righty:a3,");
#endif

    int num = SDL_NumJoysticks();

    for(int i = 0; i < num; ++i)
        this->OpenJoystick(i);
}

InputMethodType_Joystick::~InputMethodType_Joystick()
{
    this->m_lastProfileByGUID.clear();

    // A single pass would be much more efficient,
    // but I want to avoid duplicating code
    // and this only happens on program exit.
    std::vector<int> open_joystick_ids;

    for(const std::pair<const int, JoystickDevices*>& p : this->m_availableJoysticks)
        open_joystick_ids.push_back(p.first);

    for(int joystick_id : open_joystick_ids)
        this->CloseJoystick(joystick_id);
}

const std::string& InputMethodType_Joystick::LocalName() const
{
    return g_controlsStrings.nameGamepad;
}

bool InputMethodType_Joystick::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_Joystick*>(profile);
}

bool InputMethodType_Joystick::RumbleSupported()
{
    return true;
}

bool InputMethodType_Joystick::PowerStatusSupported()
{
    return true;
}

void InputMethodType_Joystick::UpdateControlsPre() {}
void InputMethodType_Joystick::UpdateControlsPost() {}

static std::string s_GetJoystickName(SDL_Joystick* joy)
{
    // initialize with SDL name
    const char* sdl_name = SDL_JoystickName(joy);
    std::string raw_name = sdl_name ? sdl_name : "";

    // split into words
    Strings::List words = Strings::split(raw_name, ' ');

    // reconstruct, while abbreviating certain words
    std::string name = "";

    size_t index = 0;
    for(std::string& s : words)
    {
        if(s.empty())
            continue;

        // abbreviated words
        if(SDL_strcasecmp(s.c_str(), "generic") == 0)
            s.resize(3);
        else if(SDL_strcasecmp(s.c_str(), "nintendo") == 0)
            s.resize(1);
        else if(SDL_strcasecmp(s.c_str(), "microsoft") == 0)
            s.resize(1);
        else if(SDL_strcasecmp(s.c_str(), "sony") == 0)
            s.resize(1);
        else if(SDL_strcasecmp(s.c_str(), "playstation") == 0)
            s = "PS";
        else if(SDL_strcasecmp(s.c_str(), "controller") == 0)
            s.resize(1);
        else if(SDL_strcasecmp(s.c_str(), "joystick") == 0)
            s.resize(3);
        else if(SDL_strcasecmp(s.c_str(), "standard") == 0)
            s = "Std";
        // skip connection methods
        else if(SDL_strcasecmp(s.c_str(), "usb") == 0)
            continue;
        else if(SDL_strcasecmp(s.c_str(), "bluetooth") == 0)
            continue;
        else if(SDL_strcasecmp(s.c_str(), "hid") == 0)
            continue;

        // skip duplicate words post conversion
        for(size_t i = 0; i < index; ++i)
        {
            if(SDL_strcasecmp(s.c_str(), words[i].c_str()) == 0)
                continue;
        }
        index++;

        // stop early if reconstructed string would become too long
        if(!name.empty() && name.size() + s.size() > 10)
            break;

        // add to reconstructed string
        name += s;
        name += " ";
    }

    // strip trailing spaces
    while(!name.empty() && name[name.size() - 1] == ' ')
        name.resize(name.size() - 1);

    // cutoff word if needed
    if(name.size() > 10)
        name.resize(10);

    // fix empty names
    if(name.empty())
        name = "Joystick";

    pLogDebug("Shortened joystick name: raw name was [%s], short name is [%s]", raw_name.c_str(), name.c_str());

    return name;
}

InputMethod* InputMethodType_Joystick::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    JoystickDevices* active_joystick = nullptr;

    for(std::pair<const int, JoystickDevices*>& p : this->m_availableJoysticks)
    {
        SDL_Joystick* joy = p.second->joy;
        SDL_GameController* ctrl = p.second->ctrl;
        bool duplicate = false;

        for(InputMethod* method : active_methods)
        {
            InputMethod_Joystick* m = dynamic_cast<InputMethod_Joystick*>(method);

            if(!m)
                continue;

            if(m->m_devices == p.second)
            {
                duplicate = true;
                break;
            }
        }

        // don't want any duplicates!
        if(duplicate)
            continue;

        KM_Key k;
        if(ctrl)
            s_bindControllerKey(ctrl, k);
        else
            s_bindJoystickKey(joy, k);

        // can_poll is set as false on joystick initialization and unbinding
        if(k.type == KM_Key::NoControl)
            p.second->can_poll = true;
        else if(p.second->can_poll)
        {
            active_joystick = p.second;
            break;
        }
    }

    // if didn't find any joystick return false right now
    if(!active_joystick)
        return nullptr;

    // we're going to create a new joystick!
    InputMethod_Joystick* method = new(std::nothrow) InputMethod_Joystick;

    // alloc failed :(
    if(!method)
        return nullptr;

    method->Type = this;
    method->Name = s_GetJoystickName(active_joystick->joy);
    method->m_devices = active_joystick;

    // In this section, we find the default profile for this controller/player combination...!

    // first, figure out what the player index will be
    int my_index = 0;

    for(const InputMethod* m : active_methods)
    {
        if(!m)
            break;

        my_index ++;
    }

    // 1. cleverly look for profile by GUID and player...
    std::unordered_map<std::string, InputMethodProfile*>::iterator found
        = this->m_lastProfileByGUID.find(std::to_string(my_index + 1) + "-" + active_joystick->guid);

    // ...then by just GUID.
    if(found == this->m_lastProfileByGUID.end())
        found = this->m_lastProfileByGUID.find(active_joystick->guid);

    // and finally by middle 16 chars of GUID
    if(found == this->m_lastProfileByGUID.end() && active_joystick->guid.size() == 32)
    {
        for(found = this->m_lastProfileByGUID.begin(); found != this->m_lastProfileByGUID.end(); ++found)
        {
            if(found->first.size() == 32 && memcmp(found->first.c_str() + 8, active_joystick->guid.c_str() + 8, 16) == 0)
                break;
        }
    }

    if(found != this->m_lastProfileByGUID.end())
        method->Profile = found->second;

#if 0
    // Inappropriate method that causes different types of controllers to share a profile

    // 2. find first profile appropriate to the controller-ness (controller vs joystick) of the controller
    if(!method->Profile)
    {
        for(InputMethodProfile* p_ : this->m_profiles)
        {
            InputMethodProfile_Joystick* p = dynamic_cast<InputMethodProfile_Joystick*>(p_);

            if(!p)
                continue;

            // if((active_joystick->ctrl && p->m_controllerProfile) || (!active_joystick->ctrl && !p->m_controllerProfile))
            if((active_joystick->ctrl != nullptr) == p->m_controllerProfile)
            {
                method->Profile = p_;
                break;
            }
        }

        // the following block (2) was previously a backup for this block

    }
#endif

    // 2. make appropriate new profile (note that allocs could fail, that will be cleaned up later)
    if(!method->Profile)
    {
        if(active_joystick->ctrl)
        {
            method->Profile = this->AddProfile();

            // Detect whether alt controls are appropriate here given a hardcoded list of GUIDs.
            if(s_AltControlsDefault(active_joystick->guid))
            {
                pLogInfo("New controller profile will use alt menu controls layout [Controller GUID: %s]", active_joystick->guid.c_str());

                auto* p = dynamic_cast<InputMethodProfile_Joystick*>(method->Profile);
                if(p)
                    p->InitAsController(InputMethodProfile_Joystick::INIT_AS_ALT);
            }
            else if(s_WiiRemoteControlsDefault(active_joystick->guid))
            {
                pLogInfo("New controller profile will use Wii Remote controls layout [Controller GUID: %s]", active_joystick->guid.c_str());

                auto* p = dynamic_cast<InputMethodProfile_Joystick*>(method->Profile);
                if(p)
                    p->InitAsController(InputMethodProfile_Joystick::INIT_AS_WII_REMOTE);
            }
            else if(s_WiiRemoteNunchackControlsDefault(active_joystick->guid))
            {
                pLogInfo("New controller profile will use Wii Remote with Nunchuk controls layout [Controller GUID: %s]", active_joystick->guid.c_str());

                auto* p = dynamic_cast<InputMethodProfile_Joystick*>(method->Profile);
                if(p)
                    p->InitAsController(InputMethodProfile_Joystick::INIT_AS_WII_REMOTE_WITH_NUNCHACK);
            }
            else
                pLogDebug("New controller profile will use standard menu controls layout [Controller GUID: %s]", active_joystick->guid.c_str());
        }
        else
            method->Profile = this->AddOldJoystickProfile();

        if(method->Profile)
            method->Profile->Name = method->Name;
    }

    return (InputMethod*)method;
}


/*-----------------------*\
|| CUSTOM METHODS        ||
\*-----------------------*/

KM_Key InputMethodType_Joystick::PollJoystickKeyAll()
{
    KM_Key k;

    for(std::pair<const int, JoystickDevices*>& p : this->m_availableJoysticks)
    {
        if(p.second->joy)
            s_bindJoystickKey(p.second->joy, k);

        if(k.type != KM_Key::NoControl)
            break;
    }

    return k;
}

KM_Key InputMethodType_Joystick::PollControllerKeyAll()
{
    KM_Key k;

    for(std::pair<const int, JoystickDevices*>& p : this->m_availableJoysticks)
    {
        if(p.second->ctrl)
            s_bindControllerKey(p.second->ctrl, k);

        if(k.type != KM_Key::NoControl)
            break;
    }

    return k;
}


/*-----------------------*\
|| CUSTOM METHODS        ||
\*-----------------------*/

bool InputMethodType_Joystick::OpenJoystick(int joystick_index)
{
    pLogDebug("Opening joystick id %d...", joystick_index);
    SDL_Joystick* joy = SDL_JoystickOpen(joystick_index);

    if(!joy)
    {
        pLogDebug("  could not open.");
        return false;
    }

    pLogDebug("  successfully opened!");
    pLogDebug("  Name: %s", SDL_JoystickName(joy));

    std::string guid;
    // explicitly scoping this buffer
    {
        SDL_JoystickGUID guid_bytes = SDL_JoystickGetGUID(joy);
        char guid_chars[35];
        SDL_JoystickGetGUIDString(guid_bytes, guid_chars, 35);
        pLogDebug("  GUID: %s", guid_chars);
        guid = guid_chars;
    }
    pLogDebug("  Number of Axes: %d", SDL_JoystickNumAxes(joy));
    pLogDebug("  Number of Buttons: %d", SDL_JoystickNumButtons(joy));
    pLogDebug("  Number of Balls: %d", SDL_JoystickNumBalls(joy));

    KM_Key key;
    s_bindJoystickKey(joy, key);

    if(key.type == KM_Key::NoControl)
        pLogDebug("  No buttons held");
    else if(key.type < 5)
    {
        const char* helper[] = {"Ax", "Bx", "By", "Hat", "But"};
        pLogDebug("  Button held: %s %d %d", helper[key.type], key.id, key.val);
    }

    JoystickDevices* devices = new(std::nothrow) JoystickDevices;

    if(!devices)
    {
        SDL_JoystickClose(joy);
        pLogDebug("  could not allocate devices struct (out of memory).");
        return false;
    }

    devices->joy = joy;
    devices->guid = std::move(guid);

    if(SDL_IsGameController(joystick_index))
    {
        pLogDebug("  claims to be a game controller...");
        devices->ctrl = SDL_GameControllerOpen(joystick_index);

        if(devices->ctrl)
        {
            pLogDebug("    successfully opened game controller!");

            s_bindControllerKey(devices->ctrl, key);

            if(key.type == KM_Key::NoControl)
                pLogDebug("    No buttons held");
            else
                pLogDebug("    Button held: %s", s_nameButton(key));
        }
        else
            pLogDebug("    could not open.");
    }
    else
        pLogDebug("  is not a game controller.");

    if(SDL_JoystickIsHaptic(joy))
    {
        pLogDebug("  claims to support haptic...");
        devices->haptic = SDL_HapticOpenFromJoystick(joy);

        if(!devices->haptic)
        {
            pLogDebug("    could not open haptic!");
        }
        else if(!SDL_HapticRumbleSupported(devices->haptic) || SDL_HapticRumbleInit(devices->haptic) != 0)
        {
            pLogDebug("    could not init haptic rumble!");
            SDL_HapticClose(devices->haptic);
            devices->haptic = nullptr;
        }
        else
        {
            pLogDebug("    successfully initialized haptic rumble!");
        }
    }
    else
        pLogDebug("  does not support haptic.");

    int id = SDL_JoystickInstanceID(joy);
    pLogDebug("  received ID %d. adding to poll list!", id);

    this->m_availableJoysticks.emplace(id, devices);

    return true;
}

bool InputMethodType_Joystick::CloseJoystick(int instance_id)
{
    pLogDebug("joystick with ID %d removed.", instance_id);
    auto found = this->m_availableJoysticks.find(instance_id);

    if(found == this->m_availableJoysticks.end())
    {
        pLogDebug("  could not find!");
        return false;
    }

    JoystickDevices* devices = found->second;

    for(InputMethod* method : g_InputMethods)
    {
        auto* m = dynamic_cast<InputMethod_Joystick*>(method);

        if(!m)
            continue;

        if(m->m_devices == devices)
        {
            pLogDebug("  unset m_devices of InputMethod '%s' using Profile '%s'.", m->Name.c_str(), m->Profile->Name.c_str());
            m->m_devices = nullptr;
        }
    }

    if(devices->haptic)
        SDL_HapticClose(devices->haptic);

    if(devices->ctrl)
        SDL_GameControllerClose(devices->ctrl);

    SDL_JoystickClose(devices->joy);
    delete devices;

    this->m_availableJoysticks.erase(found);

    return true;
}

InputMethodProfile* InputMethodType_Joystick::AddOldJoystickProfile()
{
    InputMethodProfile* p_ = this->AddProfile();
    auto* p = dynamic_cast<InputMethodProfile_Joystick*>(p_);

    if(!p)
        return nullptr;

    p->InitAsJoystick();
    p->Name = g_controlsStrings.nameOldJoy + " " + std::to_string(this->m_profiles.size());

    return p_;
}

/*-----------------------*\
|| OPTIONAL METHODS      ||
\*-----------------------*/

// optional function allowing developer to associate device information with profile, etc
// if developer wants to forbid assignment, return false
bool InputMethodType_Joystick::SetProfile_Custom(InputMethod* method, int player_no, InputMethodProfile* profile, const std::vector<InputMethod*>& active_methods)
{
    (void)active_methods;

    auto* m = dynamic_cast<InputMethod_Joystick*>(method);
    auto* p = dynamic_cast<InputMethodProfile_Joystick*>(profile);

    if(!m || !p || !m->m_devices)
        return false;

    // only allow controllerProfiles for controllers, joystick profiles for old joysticks
    // C++ has no proper logical XOR operator, so two lines
    if(p->m_controllerProfile && !m->m_devices->ctrl)
        return false;

    if(!p->m_controllerProfile && m->m_devices->ctrl)
        return false;

    // set in map!
    this->m_lastProfileByGUID[std::to_string(player_no + 1) + "-" + m->m_devices->guid] = profile;
    this->m_lastProfileByGUID[m->m_devices->guid] = profile;

    pLogDebug("Setting default controller for GUID '%s' and player %d to %s.",
              m->m_devices->guid.c_str(), player_no, profile->Name.c_str());

    return true;
}

// unregisters any references to the profile before final deallocation
// returns false to prevent deletion if this is impossible
bool InputMethodType_Joystick::DeleteProfile_Custom(InputMethodProfile* profile, const std::vector<InputMethod*>& active_methods)
{
    UNUSED(active_methods);

    for(auto it = m_lastProfileByGUID.begin(); it != m_lastProfileByGUID.end();)
    {
        if(it->second == profile)
        {
            pLogDebug("Unsetting default controller for GUID '%s'.", it->first.c_str());
            it = m_lastProfileByGUID.erase(it);
        }
        else
            ++it;
    }

    return true;
}

// Optional function allowing developer to consume an SDL event (on SDL clients)
//     usually used for hotkeys or for connect/disconnect events.
// Called (1) in order of InputMethodTypes, then (2) in order of InputMethods
// Returns true if event is consumed, false if other InputMethodTypes and InputMethods
//     should receive it.
bool InputMethodType_Joystick::ConsumeEvent(const SDL_Event* ev)
{
    if(ev->type == SDL_JOYDEVICEADDED)
    {
        this->OpenJoystick(ev->jdevice.which);
        return true;
    }
    else if(ev->type == SDL_JOYDEVICEREMOVED)
    {
        this->CloseJoystick(ev->jdevice.which);
        return true;
    }

    return false;
}

// How many per-type special options are there?
size_t InputMethodType_Joystick::GetOptionCount()
{
    return 1;
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount() returns 0.
// get a char* describing the option
const char* InputMethodType_Joystick::GetOptionName(size_t i)
{
    if(i == 0)
        return g_controlsStrings.phraseNewProfOldJoy.c_str();
    else
        return nullptr;
}

// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodType_Joystick::GetOptionValue(size_t i)
{
    (void)i;
    return nullptr;
}

// called when A is pressed; allowed to interrupt main game loop
bool InputMethodType_Joystick::OptionChange(size_t i)
{
    if(i == 0 && this->AddOldJoystickProfile())
        return true;

    return false;
}

void InputMethodType_Joystick::SaveConfig_Custom(IniProcessing* ctl)
{
    std::string name = "last-profile-";
    int uuid_begin = (int)name.size();

    // clear any old default controller profiles (keeping a copy of the set of keys in a stack-allocated vector)
    std::vector<std::string> keys_to_clear = ctl->allKeys();
    for(const std::string& key : keys_to_clear)
    {
        // delete any key with the prefix "last-profile-"
        if(SDL_strncmp(key.c_str(), name.c_str(), name.size()) == 0)
            ctl->clearValue(key.c_str());
    }

    // set all default controller profiles
    for(auto it = m_lastProfileByGUID.begin(); it != m_lastProfileByGUID.end(); ++it)
    {
        auto loc = std::find(this->m_profiles.begin(), this->m_profiles.end(), it->second);
        size_t index = loc - this->m_profiles.begin();

        if(index != this->m_profiles.size())
            ctl->setValue(name.replace(uuid_begin, std::string::npos, it->first).c_str(), index);
    }
}

void InputMethodType_Joystick::LoadConfig_Custom(IniProcessing* ctl)
{
    // load all default controller profiles
    std::vector<std::string> keys = ctl->allKeys();
    std::string keyNeed = "last-profile-";

    for(std::string& k : keys)
    {
        std::string::size_type r = k.find(keyNeed);

        if(/*r != std::string::npos &&*/ r == 0)
        {
            std::string guid = k.substr(13); // length of "last-profile-"
            int index;
            ctl->read(k.c_str(), index, -1);

            if(index >= 0 && index < (int)this->m_profiles.size() && this->m_profiles[index])
            {
                this->m_lastProfileByGUID[guid] = this->m_profiles[index];
                pLogDebug("Set default profile for '%s' to '%s'.", guid.c_str(), this->m_profiles[index]->Name.c_str());
            }
        }
    }

    ctl->endGroup();

    ctl->beginGroup(this->Name);
}

} // namespace Controls


================================================
FILE: src/control/joystick.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef JOYSTICK_H
#define JOYSTICK_H

#include "../controls.h"

#include <string>
#include <set>
#include <unordered_map>
#include <SDL2/SDL_timer.h>

typedef struct _SDL_Joystick SDL_Joystick;
typedef struct _SDL_GameController SDL_GameController;
typedef struct _SDL_Haptic SDL_Haptic;

namespace Controls
{

struct JoystickDevices
{
    SDL_Joystick *joy = nullptr;
    SDL_GameController *ctrl = nullptr;
    SDL_Haptic *haptic = nullptr;

    bool can_poll = false;
    std::string guid;
};

struct KM_Key
{
    enum CtrlTypes
    {
        NoControl = -1,
        JoyAxis = 0,
        JoyBallX,
        JoyBallY,
        JoyHat,
        JoyButton,
        CtrlButton,
        CtrlAxis
    };

    // SDL_Joystick control or SDL_GameController control, depending on context
    int val = -1;
    int id = -1;
    int type = -1;

    inline bool operator==(const KM_Key &o)
    {
        return o.id == id && o.val == val && o.type == type;
    }

    inline void assign(int i_type, int i_id, int i_val)
    {
        this->type = i_type;
        this->id = i_id;
        this->val = i_val;
    }
};

class InputMethod_Joystick : public InputMethod
{
private:
    uint32_t m_last_power_check = -10000;
    StatusInfo m_recent_status;

public:
    JoystickDevices *m_devices;

    using InputMethod::Type;
    using InputMethod::Profile;

    ~InputMethod_Joystick();

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);

    StatusInfo GetStatus();
};

class InputMethodProfile_Joystick : public InputMethodProfile
{
private:
    bool m_canPoll = false;

public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    bool m_controllerProfile = false;

    // current settings
    bool m_simple_editor = true;

    // primary keys (also controller keys in legacy mode)
    KM_Key m_keys[PlayerControls::n_buttons];
    // secondary keys (also joystick keys in legacy mode)
    KM_Key m_keys2[PlayerControls::n_buttons];

    // cursor keys
    KM_Key m_cursor_keys[CursorControls::n_buttons];
    KM_Key m_cursor_keys2[CursorControls::n_buttons];

    // editor keys
    KM_Key m_editor_keys[EditorControls::n_buttons];
    KM_Key m_editor_keys2[EditorControls::n_buttons];

    // hotkeys
    KM_Key m_hotkeys[Hotkeys::n_buttons];
    KM_Key m_hotkeys2[Hotkeys::n_buttons];

    InputMethodProfile_Joystick();

    enum InitAs
    {
        INIT_AS_DEFAULT = 0,
        INIT_AS_ALT,
        INIT_AS_WII_REMOTE,
        INIT_AS_WII_REMOTE_WITH_NUNCHACK,
    };

    void InitAsJoystick();
    void InitAsController(InitAs init_as);
    void SaveConfig_Legacy(IniProcessing *ctl);
    void LoadConfig_Legacy(IniProcessing *ctl);

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);

public:
    // How many per-type special options are there?
    size_t GetOptionCount_Custom();
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount_Custom() returns 0.
    // get a char* describing the option
    const char *GetOptionName_Custom(size_t i);
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue_Custom(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange_Custom(size_t i);
    // called when left is pressed
    bool OptionRotateLeft_Custom(size_t i);
    // called when right is pressed
    bool OptionRotateRight_Custom(size_t i);
};

class InputMethodType_Joystick : public InputMethodType
{
private:
    std::unordered_map<int, JoystickDevices *> m_availableJoysticks;
    std::unordered_map<std::string, InputMethodProfile *> m_lastProfileByGUID;

    InputMethodProfile *AllocateProfile() noexcept override;

    /*-----------------------*\
    || CUSTOM METHODS        ||
    \*-----------------------*/
    bool OpenJoystick(int joystick_index);
    bool CloseJoystick(int instance_id);

public:
    using InputMethodType::Name;
    using InputMethodType::m_profiles;

    InputMethodType_Joystick();
    ~InputMethodType_Joystick();

    const std::string& LocalName() const override;

    bool TestProfileType(InputMethodProfile *profile) override;
    bool RumbleSupported() override;
    bool PowerStatusSupported() override;

    void UpdateControlsPre() override;
    void UpdateControlsPost() override;

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept override;

    /*-----------------------*\
    || CUSTOM METHODS        ||
    \*-----------------------*/
    KM_Key PollJoystickKeyAll();
    KM_Key PollControllerKeyAll();
    InputMethodProfile *AddOldJoystickProfile();

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
protected:
    // optional function allowing developer to associate device information with profile, etc
    // if developer wants to forbid assignment, return false
    bool SetProfile_Custom(InputMethod *method, int player_no, InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods) override;
    // unregisters any references to the profile before final deallocation
    // returns false to prevent deletion if this is impossible
    bool DeleteProfile_Custom(InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods) override;
public:
    bool ConsumeEvent(const SDL_Event *ev) override;

public:
    // How many per-type special options are there?
    size_t GetOptionCount() override;
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount() returns 0.
    // get a char* describing the option
    const char *GetOptionName(size_t i) override;
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue(size_t i) override;
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange(size_t i) override;

protected:
    void SaveConfig_Custom(IniProcessing *ctl) override;
    void LoadConfig_Custom(IniProcessing *ctl) override;

};

} // namespace Controls

#endif // #ifndef JOYSTICK_H


================================================
FILE: src/control/keyboard.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <SDL2/SDL_scancode.h>
#include <SDL2/SDL_power.h>
#include <SDL2/SDL_keyboard.h>
#include <SDL2/SDL_mouse.h>
#include <SDL2/SDL_events.h>
#include "sdl_proxy/sdl_timer.h"

#include "../controls.h"
#include "../globals.h"
#include "keyboard.h"
#include "../main/screen_textentry.h"
#include "../game_main.h"

#include "core/render.h"
#include "core/window.h"
#include "core/power.h"

#include "main/cheat_code.h"
#include "main/menu_main.h"

#include "control/controls_strings.h"

#include <Logger/logger.h>

namespace Controls
{

bool g_cancelDoubleClick = false;

// helper functions


/*====================================================*\
|| implementation for InputMethod_Keyboard            ||
\*====================================================*/

InputMethod_Keyboard::~InputMethod_Keyboard()
{
    InputMethodType_Keyboard* t = dynamic_cast<InputMethodType_Keyboard*>(this->Type);

    if(!t)
        return;

    t->m_numKeyboards --;
}

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_Keyboard::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    InputMethodType_Keyboard* k = dynamic_cast<InputMethodType_Keyboard*>(this->Type);
    InputMethodProfile_Keyboard* p = dynamic_cast<InputMethodProfile_Keyboard*>(this->Profile);

    if(!k || !p)
        return false;

    if(k->m_directText && GamePaused == PauseCode::TextEntry)
        return true;

    // consume parent's precise scrolling
    if(k->m_scroll_x_precise < 0)
        e.ScrollLeft -= num_t::from_double(k->m_scroll_x_precise) * 32;
    else if(k->m_scroll_x_precise > 0)
        e.ScrollRight += num_t::from_double(k->m_scroll_x_precise) * 32;

    if(k->m_scroll_y_precise < 0)
        e.ScrollUp -= num_t::from_double(k->m_scroll_y_precise) * 32;
    else if(k->m_scroll_y_precise > 0)
        e.ScrollDown += num_t::from_double(k->m_scroll_y_precise) * 32;

    k->m_scroll_x_precise = 0;
    k->m_scroll_y_precise = 0;

    // check for alt press (disables some keys)
    bool altPressed = (k->m_keyboardState[SDL_SCANCODE_LALT] ||
                       k->m_keyboardState[SDL_SCANCODE_RALT] ||
                       k->m_keyboardState[SDL_SCANCODE_LCTRL] ||
                       k->m_keyboardState[SDL_SCANCODE_RCTRL]);

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_start;
        size_t key_max;
        bool activate = false;

        if(a == 0)
        {
            keys = p->m_keys;
            keys2 = p->m_keys2;
            key_start = 0;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = p->m_cursor_keys2;
            key_start = 4;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = p->m_editor_keys;
            keys2 = p->m_editor_keys2;
            key_start = 4;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = p->m_hotkeys;
            keys2 = p->m_hotkeys2;
            key_start = 0;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = key_start; i < key_max; i++)
        {
            int key;

            if(keys)
                key = keys[i];
            else
                key = null_key;

            int key2 = keys2[i];

            if(altPressed && (key == SDL_SCANCODE_F || key == SDL_SCANCODE_RETURN))
                key = null_key;

            if(altPressed && (key2 == SDL_SCANCODE_F || key2 == SDL_SCANCODE_RETURN))
                key2 = null_key;

            bool* b;

            if(a == 0)
            {
                b = &PlayerControls::GetButton(c, i);
                *b = false;
            }
            else if(a == 1)
            {
                b = &CursorControls::GetButton(m, i);
            }
            else if(a == 2)
            {
                b = &EditorControls::GetButton(e, i);
            }
            else
            {
                b = &activate;
                *b = false;
            }

            if(key != null_key && k->m_keyboardState[key] != 0)
                *b = true;
            else if(key2 != null_key && k->m_keyboardState[key2] != 0)
                *b = true;

            if(a == 3 && *b)
                h[i] = player;
        }
    }

    num_t* const scroll[4] = {&e.ScrollUp, &e.ScrollDown, &e.ScrollLeft, &e.ScrollRight};

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_editor_keys[i];
        int key2 = p->m_editor_keys2[i];

        if(key != null_key && k->m_keyboardState[key] != 0)
            *scroll[i] += 10;
        else if(key2 != null_key && k->m_keyboardState[key2] != 0)
            *scroll[i] += 10;
    }

    bool cursor[4];

    for(int i = 0; i < 4; i++)
    {
        int key = p->m_cursor_keys2[i];
        cursor[i] = (key != null_key && k->m_keyboardState[key]);
    }

    // Cursor control (UDLR)
    if(cursor[0] || cursor[1] || cursor[2] || cursor[3])
    {
        bool edge_scroll = LevelEditor && !MagicHand;

        if(m.X < 0)
            m.X = XRender::TargetW / 2;

        if(m.Y < 0)
            m.Y = XRender::TargetH / 2;

        if(cursor[3])
            m.X += 16;

        if(cursor[2])
            m.X -= 16;

        if(cursor[1])
            m.Y += 16;

        if(cursor[0])
            m.Y -= 16;

        if(m.X < 0)
        {
            if(edge_scroll)
                e.ScrollLeft += -m.X;

            m.X = 0;
        }
        else if(m.X >= XRender::TargetW)
        {
            if(edge_scroll)
                e.ScrollRight += m.X - (XRender::TargetW - 1);

            m.X = XRender::TargetW - 1;
        }

        if(m.Y < 0)
        {
            if(edge_scroll)
                e.ScrollUp += -m.Y;

            m.Y = 0;
        }
        else if(m.Y >= XRender::TargetH)
        {
            if(edge_scroll)
                e.ScrollDown += m.Y - (XRender::TargetH - 1);

            m.Y = XRender::TargetH - 1;
        }

        m.Move = true;
    }

    // one may uncomment this to quickly simulate controller disconnection for debugging purposes
    // if(c.Up && c.Down)
    //     return false;

    return true;
}

void InputMethod_Keyboard::Rumble(int ms, float strength)
{
    UNUSED(ms);
    UNUSED(strength);
}

StatusInfo InputMethod_Keyboard::GetStatus()
{
    return XPower::devicePowerStatus();
}

/*====================================================*\
|| implementation for InputMethodProfile_Keyboard     ||
\*====================================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_Keyboard::InputMethodProfile_Keyboard()
{
    for(size_t i = 0; i < PlayerControls::n_buttons; i++)
    {
        this->m_keys[i] = null_key;
        this->m_keys2[i] = null_key;
    }

    for(size_t i = 0; i < CursorControls::n_buttons; i++)
        this->m_cursor_keys2[i] = null_key;

    for(size_t i = 0; i < EditorControls::n_buttons; i++)
    {
        this->m_editor_keys[i] = null_key;
        this->m_editor_keys2[i] = null_key;
    }

    for(size_t i = 0; i < Hotkeys::n_buttons; i++)
    {
        this->m_hotkeys[i] = null_key;
        this->m_hotkeys2[i] = null_key;
    }

    this->m_keys[PlayerControls::Buttons::Up] = SDL_SCANCODE_UP;
    this->m_keys[PlayerControls::Buttons::Down] = SDL_SCANCODE_DOWN;
    this->m_keys[PlayerControls::Buttons::Left] = SDL_SCANCODE_LEFT;
    this->m_keys[PlayerControls::Buttons::Right] = SDL_SCANCODE_RIGHT;
    this->m_keys[PlayerControls::Buttons::Jump] = SDL_SCANCODE_Z;
    this->m_keys[PlayerControls::Buttons::AltJump] = SDL_SCANCODE_A;
    this->m_keys[PlayerControls::Buttons::Run] = SDL_SCANCODE_X;
    this->m_keys[PlayerControls::Buttons::AltRun] = SDL_SCANCODE_S;
    this->m_keys[PlayerControls::Buttons::Drop] = SDL_SCANCODE_LSHIFT;
    this->m_keys2[PlayerControls::Buttons::Drop] = SDL_SCANCODE_RSHIFT;
    this->m_keys[PlayerControls::Buttons::Start] = SDL_SCANCODE_RETURN;

    this->m_editor_keys[EditorControls::Buttons::ScrollUp] = SDL_SCANCODE_UP;
    this->m_editor_keys[EditorControls::Buttons::ScrollDown] = SDL_SCANCODE_DOWN;
    this->m_editor_keys[EditorControls::Buttons::ScrollLeft] = SDL_SCANCODE_LEFT;
    this->m_editor_keys[EditorControls::Buttons::ScrollRight] = SDL_SCANCODE_RIGHT;
    this->m_editor_keys[EditorControls::Buttons::FastScroll] = SDL_SCANCODE_LSHIFT;
    this->m_editor_keys[EditorControls::Buttons::ModeSelect] = SDL_SCANCODE_Z;
    this->m_editor_keys[EditorControls::Buttons::ModeErase] = SDL_SCANCODE_X;
    this->m_editor_keys[EditorControls::Buttons::PrevSection] = SDL_SCANCODE_A;
    this->m_editor_keys[EditorControls::Buttons::NextSection] = SDL_SCANCODE_S;
    this->m_editor_keys[EditorControls::Buttons::SwitchScreens] = SDL_SCANCODE_RSHIFT;
    this->m_editor_keys[EditorControls::Buttons::TestPlay] = SDL_SCANCODE_RETURN;

    // ALSO UPDATE InputMethodType_Keyboard::DefaultHotkey
    this->m_hotkeys[Hotkeys::Buttons::ToggleHUD] = SDL_SCANCODE_F1;
    this->m_hotkeys[Hotkeys::Buttons::DebugInfo] = SDL_SCANCODE_F3;
#ifndef RENDER_FULLSCREEN_ALWAYS
    this->m_hotkeys[Hotkeys::Buttons::Fullscreen] = SDL_SCANCODE_F7;
#endif

#ifndef PGE_ENABLE_VIDEO_REC
    // nothing to define
#elif defined(__APPLE__) // on macOS the F11 key is reserved by the "Show Desktop" global action
    this->m_hotkeys[Hotkeys::Buttons::RecordGif] = SDL_SCANCODE_F10;
#else
    this->m_hotkeys[Hotkeys::Buttons::RecordGif] = SDL_SCANCODE_F11;
#endif

#ifdef USE_SCREENSHOTS_AND_RECS
    this->m_hotkeys[Hotkeys::Buttons::Screenshot] = SDL_SCANCODE_F12;
    this->m_hotkeys2[Hotkeys::Buttons::Screenshot] = SDL_SCANCODE_F2;
#endif

#ifdef DEBUG_BUILD
    this->m_hotkeys[Hotkeys::Buttons::ReloadLanguage] = SDL_SCANCODE_F5;
#endif
}

bool InputMethodProfile_Keyboard::PollPrimaryButton(ControlsClass c, size_t i)
{
    if(c == ControlsClass::Cursor)
        return true;

    // note: m_canPoll is initialized to false
    InputMethodType_Keyboard* k = dynamic_cast<InputMethodType_Keyboard*>(this->Type);

    if(!k)
        return false;

    int key;

    for(key = 0; key < k->m_keyboardStateSize; key++)
    {
        if(k->m_keyboardState[key] != 0)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == k->m_keyboardStateSize)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    this->m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Keyboard primary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key
    // if a button's secondary key (including the current one) is the new key, delete it.
    // if a button's primary key (excluding the current one) is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, replace it with the button the player is replacing.
    for(size_t j = 0; j < key_max; j++)
    {
        if(keys2[j] == key)
            keys2[j] = null_key;
        else if(i != j && keys[j] == key)
        {
            if(keys2[j] != null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else
                keys[j] = keys[i];
        }
    }

    keys[i] = key;
    return true;
}

bool InputMethodProfile_Keyboard::PollSecondaryButton(ControlsClass c, size_t i)
{
    // note: m_canPoll is initialized to false
    InputMethodType_Keyboard* k = dynamic_cast<InputMethodType_Keyboard*>(this->Type);

    if(!k)
        return false;

    int key;

    for(key = 0; key < k->m_keyboardStateSize; key++)
    {
        if(k->m_keyboardState[key] != 0)
            break;
    }

    // if didn't find any key, allow poll in future but return false
    if(key == k->m_keyboardStateSize)
    {
        this->m_canPoll = true;
        return false;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return false;

    // we will assign the key!
    // reset canPoll for next time
    m_canPoll = false;

    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;
    size_t key_max;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
        key_max = PlayerControls::n_buttons;
    }
    else if(c == ControlsClass::Cursor)
    {
        keys = nullptr;
        keys2 = this->m_cursor_keys2;
        key_max = CursorControls::n_buttons;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
        key_max = EditorControls::n_buttons;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
        key_max = Hotkeys::n_buttons;
    }
    else
    {
        D_pLogWarning("Polling Keyboard secondary button with disallowed controls class %d\n", (int)c);
        return true;
    }

    // minor switching algorithm to ensure that every button always has at least one key
    // and no button ever has a non-unique key

    // if the current button's primary key is the new key,
    //     delete its secondary key instead of setting it.
    if(keys && keys[i] == key)
    {
        keys2[i] = null_key;
        return true;
    }

    // if another button's secondary key is the new key, delete it.
    // if another button's primary key is the new key,
    //     and it has a secondary key, overwrite it with the secondary key.
    //     otherwise, if this button's secondary key is defined, overwrite the other's with this.
    //     if all else fails, overwrite the other button's with this button's PRIMARY key and assign
    //         this button's PRIMARY key instead

    bool can_do_secondary = true;

    for(size_t j = 0; j < key_max; j++)
    {
        if(i != j && keys2[j] == key)
        {
            keys2[j] = null_key;
        }
        else if(keys && i != j && keys[j] == key)
        {
            if(keys2[j] != null_key)
            {
                keys[j] = keys2[j];
                keys2[j] = null_key;
            }
            else if(keys2[i] != null_key)
            {
                keys[j] = keys2[i];
            }
            else
            {
                keys[j] = keys[i];
                can_do_secondary = false;
            }
        }
    }

    if(can_do_secondary)
        keys2[i] = key;
    else if(keys)
        keys[i] = key;

    return true;
}

bool InputMethodProfile_Keyboard::DeletePrimaryButton(ControlsClass c, size_t i)
{
    // resolve the particular primary and secondary key arrays
    int* keys;
    int* keys2;

    if(c == ControlsClass::Player)
    {
        keys = this->m_keys;
        keys2 = this->m_keys2;
    }
    else if(c == ControlsClass::Cursor)
    {
        return false;
    }
    else if(c == ControlsClass::Editor)
    {
        keys = this->m_editor_keys;
        keys2 = this->m_editor_keys2;
    }
    else if(c == ControlsClass::Hotkey)
    {
        keys = this->m_hotkeys;
        keys2 = this->m_hotkeys2;
    }
    else
    {
        D_pLogWarning("Attempted to delete Keyboard primary button with disallowed controls class %d\n", (int)c);
        return false;
    }

    if(keys2[i] != null_key)
    {
        keys[i] = keys2[i];
        keys2[i] = null_key;
        return true;
    }

    if(c == ControlsClass::Player)
        return false;

    if(keys[i] != null_key)
    {
        keys[i] = null_key;
        return true;
    }

    return false;
}

bool InputMethodProfile_Keyboard::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    int* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return false;

    if(keys2[i] != null_key)
    {
        keys2[i] = null_key;
        return true;
    }

    return false;
}

const char* InputMethodProfile_Keyboard::NamePrimaryButton(ControlsClass c, size_t i)
{
    int* keys;

    if(c == ControlsClass::Player)
        keys = this->m_keys;
    else if(c == ControlsClass::Cursor)
        return g_controlsStrings.caseMouse.c_str();
    else if(c == ControlsClass::Editor)
        keys = this->m_editor_keys;
    else if(c == ControlsClass::Hotkey)
        keys = this->m_hotkeys;
    else
        return "";

    if(keys[i] == null_key)
        return g_mainMenu.caseNone.c_str();

    return SDL_GetScancodeName((SDL_Scancode)keys[i]);
}

const char* InputMethodProfile_Keyboard::NameSecondaryButton(ControlsClass c, size_t i)
{
    int* keys2;

    if(c == ControlsClass::Player)
        keys2 = this->m_keys2;
    else if(c == ControlsClass::Cursor)
        keys2 = this->m_cursor_keys2;
    else if(c == ControlsClass::Editor)
        keys2 = this->m_editor_keys2;
    else if(c == ControlsClass::Hotkey)
        keys2 = this->m_hotkeys2;
    else
        return "";

    if(keys2[i] == null_key)
        return "";

    return SDL_GetScancodeName((SDL_Scancode)keys2[i]);
}

void InputMethodProfile_Keyboard::SaveConfig(IniProcessing* ctl)
{
    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->setValue(name, keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            ctl->setValue(name2, keys2[i]);
        }
    }
}

void InputMethodProfile_Keyboard::LoadConfig(IniProcessing* ctl)
{
    char name2[20];

    for(int a = 0; a < 4; a++)
    {
        int* keys;
        int* keys2;
        size_t key_max;

        if(a == 0)
        {
            keys = this->m_keys;
            keys2 = this->m_keys2;
            key_max = PlayerControls::n_buttons;
        }
        else if(a == 1)
        {
            keys = nullptr;
            keys2 = this->m_cursor_keys2;
            key_max = CursorControls::n_buttons;
        }
        else if(a == 2)
        {
            keys = this->m_editor_keys;
            keys2 = this->m_editor_keys2;
            key_max = EditorControls::n_buttons;
        }
        else
        {
            keys = this->m_hotkeys;
            keys2 = this->m_hotkeys2;
            key_max = Hotkeys::n_buttons;
        }

        for(size_t i = 0; i < key_max; i++)
        {
            const char* name;

            if(a == 0)
                name = PlayerControls::GetButtonName_INI(i);
            else if(a == 1)
                name = CursorControls::GetButtonName_INI(i);
            else if(a == 2)
                name = EditorControls::GetButtonName_INI(i);
            else
                name = Hotkeys::GetButtonName_INI(i);

            if(keys)
                ctl->read(name, keys[i], keys[i]);

            for(size_t c = 0; c < 20; c++)
            {
                if(c + 2 == 20 || name[c] == '\0')
                {
                    name2[c] = '2';
                    name2[c + 1] = '\0';
                    break;
                }

                name2[c] = name[c];
            }

            // only add RSHIFT secondary key during conversion if current primary key is LSHIFT
            int def = keys2[i];

            if(a == 0 && i == PlayerControls::Buttons::Drop && keys[i] != SDL_SCANCODE_LSHIFT)
                def = null_key;

            ctl->read(name2, keys2[i], def);
        }
    }
}

/*====================================================*\
|| implementation for InputMethodType_Keyboard        ||
\*====================================================*/

InputMethodProfile* InputMethodType_Keyboard::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_Keyboard;
}

InputMethodType_Keyboard::InputMethodType_Keyboard()
{
    this->m_keyboardState = SDL_GetKeyboardState(&this->m_keyboardStateSize);
    this->Name = "Keyboard";
    this->LegacyName = "keyboard";
}

const std::string& InputMethodType_Keyboard::LocalName() const
{
    return g_controlsStrings.nameKeyboard;
}

bool InputMethodType_Keyboard::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_Keyboard*>(profile);
}

bool InputMethodType_Keyboard::RumbleSupported()
{
    return false;
}

void InputMethodType_Keyboard::UpdateControlsPre() {}
void InputMethodType_Keyboard::UpdateControlsPost()
{
    if(this->m_touchscreenActive && g_renderTouchscreen)
    {
        // let the touchscreen input method handle the mouse
    }
    // handle the mouse
    else if(SDL_GetMouseFocus())
    {
        int window_x, window_y;
        Uint32 buttons = SDL_GetMouseState(&window_x, &window_y);

        static int last_window_x = -1, last_window_y = -1;
        bool allow_move = false;

        // only allow move if both the window coordinates and the gamespace coordinates changed (prevents fake move when resolution changes)
        if(last_window_x != window_x || last_window_y != window_y)
        {
            last_window_x = window_x;
            last_window_y = window_y;
            allow_move = true;
        }

        SDL_Point p;
        XRender::mapToScreen(window_x, window_y, &p.x, &p.y);
        static SDL_Point last_p;

        if(p.x - last_p.x <= -1 || p.x - last_p.x >= 1 ||
           p.y - last_p.y <= -1 || p.y - last_p.y >= 1)
        {
            last_p = p;

            if(allow_move)
                SharedCursor.Move = true;

            SharedCursor.X = p.x;
            SharedCursor.Y = p.y;
        }

        if(buttons & SDL_BUTTON_LMASK)
            SharedCursor.Primary = true;

        if(buttons & SDL_BUTTON_RMASK)
            SharedCursor.Secondary = true;

        if(buttons & SDL_BUTTON_MMASK)
            SharedCursor.Tertiary = true;
    }
    else if(XWindow::hasWindowInputFocus() && !SharedCursor.Move && (SharedCursor.X >= 0 || SharedCursor.Y >= 0))
    {
        SharedCursor.GoOffscreen();
    }

    if(this->m_scroll >= 1)
    {
        this->m_scroll -= 1;
        SharedCursor.ScrollDown |= true;
    }
    else if(this->m_scroll <= -1)
    {
        this->m_scroll += 1;
        SharedCursor.ScrollUp |= true;
    }

    if(this->m_directText && GamePaused == PauseCode::TextEntry)
    {
        this->m_canPoll = false;
        return;
    }

    bool altPressed = this->m_keyboardState[SDL_SCANCODE_LALT] ||
                      this->m_keyboardState[SDL_SCANCODE_RALT];
    bool escBackPressed = this->m_keyboardState[SDL_SCANCODE_ESCAPE];
    bool escPausePressed = this->m_keyboardState[SDL_SCANCODE_ESCAPE];
    bool returnPressed = this->m_keyboardState[SDL_SCANCODE_RETURN];
    bool spacePressed = this->m_keyboardState[SDL_SCANCODE_SPACE];
    bool upPressed = this->m_keyboardState[SDL_SCANCODE_UP];
    bool downPressed = this->m_keyboardState[SDL_SCANCODE_DOWN];
    bool leftPressed = this->m_keyboardState[SDL_SCANCODE_LEFT];
    bool rightPressed = this->m_keyboardState[SDL_SCANCODE_RIGHT];

    // disable the shared keys if they are currently in use
    for(InputMethod* method : g_InputMethods)
    {
        if(!method)
            continue;

        InputMethodProfile* p = method->Profile;
        InputMethodProfile_Keyboard* profile = dynamic_cast<InputMethodProfile_Keyboard*>(p);

        if(!profile)
            continue;

        for(size_t i = 0; i < PlayerControls::n_buttons; i++)
        {
            if(profile->m_keys[i] == SDL_SCANCODE_ESCAPE || profile->m_keys2[i] == SDL_SCANCODE_ESCAPE)
            {
                // allow escape to count even when it is a player's start key, important for correct menu behavior
                if(i != PlayerControls::Buttons::Start)
                    escBackPressed = false;

                escPausePressed = false;
            }

            if(profile->m_keys[i] == SDL_SCANCODE_RETURN || profile->m_keys2[i] == SDL_SCANCODE_RETURN)
                returnPressed = false;

            if(profile->m_keys[i] == SDL_SCANCODE_SPACE || profile->m_keys2[i] == SDL_SCANCODE_SPACE)
                spacePressed = false;

            if(profile->m_keys[i] == SDL_SCANCODE_UP || profile->m_keys2[i] == SDL_SCANCODE_UP)
                upPressed = false;

            if(profile->m_keys[i] == SDL_SCANCODE_DOWN || profile->m_keys2[i] == SDL_SCANCODE_DOWN)
                downPressed = false;

            if(profile->m_keys[i] == SDL_SCANCODE_LEFT || profile->m_keys2[i] == SDL_SCANCODE_LEFT)
                leftPressed = false;

            if(profile->m_keys[i] == SDL_SCANCODE_RIGHT || profile->m_keys2[i] == SDL_SCANCODE_RIGHT)
                rightPressed = false;
        }
    }

#ifdef __ANDROID__ // Quit credits on BACK key press
    bool backPressed = this->m_keyboardState[SDL_SCANCODE_AC_BACK];
#else
    bool backPressed = false;
#endif

    l_SharedControls.QuitCredits |= (spacePressed || backPressed);
    l_SharedControls.QuitCredits |= (returnPressed && !altPressed);
    l_SharedControls.QuitCredits |= (escBackPressed && !altPressed);

    l_SharedControls.Pause |= backPressed;
    l_SharedControls.Pause |= (escPausePressed && !altPressed);

    l_SharedControls.MenuUp |= upPressed;
    l_SharedControls.MenuDown |= downPressed;
    l_SharedControls.MenuLeft |= leftPressed;
    l_SharedControls.MenuRight |= rightPressed;
    l_SharedControls.MenuDo |= (returnPressed && !altPressed) || spacePressed;
    l_SharedControls.MenuBack |= backPressed;
    l_SharedControls.MenuBack |= (escBackPressed && !altPressed);
}

// this is challenging for the keyboard because we don't want to allocate 20 copies of it
InputMethod* InputMethodType_Keyboard::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    if(this->m_numKeyboards != this->m_lastNumKeyboards)
    {
        // this ensures that keys that were held when a keyboard method was removed cannot be polled to add that method back
        if(this->m_numKeyboards < this->m_lastNumKeyboards)
            this->m_canPoll = false;

        this->m_lastNumKeyboards = this->m_numKeyboards;
    }

    if(this->m_numKeyboards >= m_maxKeyboards)
    {
        // ban polling in case things change
        this->m_canPoll = false;
        return nullptr;
    }


    // ban attachment from active profile, must find new profile
    int key;
    InputMethodProfile* target_profile = nullptr;

    for(key = 0; key < this->m_keyboardStateSize; key++)
    {
        if(!this->m_keyboardState[key])
            continue;

        bool allowed = true;

        if(key == SDL_SCANCODE_LALT || key == SDL_SCANCODE_RALT || key == SDL_SCANCODE_LCTRL || key == SDL_SCANCODE_RCTRL || key == SDL_SCANCODE_ESCAPE)
            allowed = false;

        // ban attachment from active profile
        for(InputMethod* method : active_methods)
        {
            if(!allowed)
                break;

            if(!method)
                continue;

            InputMethodProfile_Keyboard* p = dynamic_cast<InputMethodProfile_Keyboard*>(method->Profile);

            if(!p)
                continue;

            for(size_t i = 0; i < PlayerControls::n_buttons; i++)
            {
                if(p->m_keys[i] == key || p->m_keys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }

            if(LevelEditor)
            {
                for(size_t i = 0; i < EditorControls::n_buttons; i++)
                {
                    if(p->m_editor_keys[i] == key || p->m_editor_keys2[i] == key)
                    {
                        allowed = false;
                        break;
                    }
                }
            }

            for(size_t i = 0; i < CursorControls::n_buttons; i++)
            {
                if(p->m_cursor_keys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }

            for(size_t i = 0; i < Hotkeys::n_buttons; i++)
            {
                if(p->m_hotkeys[i] == key || p->m_hotkeys2[i] == key)
                {
                    allowed = false;
                    break;
                }
            }
        }

        if(!allowed)
            continue;

        // which player index is connecting?
        int my_index = 0;

        for(const InputMethod* method : active_methods)
        {
            if(!method)
                break;

            my_index ++;
        }

        // try to find profile matching the keypress
        for(int i = -1; i < (int)this->m_profiles.size(); i++)
        {
            // start with the most recent profile for this player index
            InputMethodProfile* profile;

            if(i == -1)
                profile = this->GetDefaultProfile(my_index);
            else
                profile = this->m_profiles[i];

            if(!profile)
                continue;

            InputMethodProfile_Keyboard* p = dynamic_cast<InputMethodProfile_Keyboard*>(profile);

            if(!p)
                continue;

            for(size_t j = 0; j < PlayerControls::n_buttons; j++)
            {
                if(p->m_keys[j] == key || p->m_keys2[j] == key)
                {
                    target_profile = profile;
                    break;
                }
            }

            if(target_profile)
                break;
        }

        if(target_profile || this->m_profiles.empty())
            break;
    }

    // if didn't find any key allow poll in future but return false
    if(key == this->m_keyboardStateSize)
    {
        this->m_canPoll = true;
        return nullptr;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return nullptr;

    // we're going to create a new keyboard!
    // reset canPoll for next time
    this->m_canPoll = false;

    InputMethod_Keyboard* method = new(std::nothrow) InputMethod_Keyboard;

    if(!method)
        return nullptr;

    method->Name = this->LocalName();
    method->Type = this;
    method->Profile = target_profile;

    this->m_numKeyboards ++;

    return (InputMethod*)method;
}

/*-----------------------*\
|| OPTIONAL METHODS      ||
\*-----------------------*/
bool InputMethodType_Keyboard::DefaultHotkey(const SDL_Event* ev)
{
    const SDL_KeyboardEvent& evt = ev->key;

    int KeyCode = evt.keysym.scancode;

#ifndef RENDER_FULLSCREEN_ALWAYS
    bool ctrlF = ((evt.keysym.mod & KMOD_CTRL) != 0 && evt.keysym.scancode == SDL_SCANCODE_F);
    bool altEnter = ((evt.keysym.mod & KMOD_ALT) != 0 && (evt.keysym.scancode == SDL_SCANCODE_RETURN || evt.keysym.scancode == SDL_SCANCODE_KP_ENTER));

    if(ctrlF || altEnter)
        g_hotkeysPressed[Hotkeys::Buttons::Fullscreen] = 0;
#endif

    bool use_defaults = false;

    if(this->m_numKeyboards == 0)
        use_defaults = true;

    if(this->m_directText && GamePaused == PauseCode::TextEntry)
        use_defaults = true;

    if(use_defaults && evt.repeat == 0)
    {
        // ALSO UPDATE InputMethodProfile_Keyboard::InputMethodProfile_Keyboard
        if(KeyCode == SDL_SCANCODE_F3)
            g_hotkeysPressed[Hotkeys::Buttons::DebugInfo] = 0;
        else if(KeyCode == SDL_SCANCODE_F1)
            g_hotkeysPressed[Hotkeys::Buttons::ToggleHUD] = 0;

#ifdef USE_SCREENSHOTS_AND_RECS
        else if(KeyCode == SDL_SCANCODE_F12 || KeyCode == SDL_SCANCODE_F2)
            g_hotkeysPressed[Hotkeys::Buttons::Screenshot] = 0;
#endif

#ifdef PGE_ENABLE_VIDEO_REC
#   ifdef __APPLE__
        else if(KeyCode == SDL_SCANCODE_F10) // Reserved by macOS as "show desktop"
#   else
        else if(KeyCode == SDL_SCANCODE_F11)
#   endif
            g_hotkeysPressed[Hotkeys::Buttons::RecordGif] = 0;
#endif
    }

    if(this->m_directText && GamePaused == PauseCode::TextEntry)
        return false;

    SDL_Scancode KeyASCII = evt.keysym.scancode;

    // classic cheat codes
    switch(KeyASCII)
    {
    case SDL_SCANCODE_A:
        CheatCode('a');
        break;

    case SDL_SCANCODE_B:
        CheatCode('b');
        break;

    case SDL_SCANCODE_C:
        CheatCode('c');
        break;

    case SDL_SCANCODE_D:
        CheatCode('d');
        break;

    case SDL_SCANCODE_E:
        CheatCode('e');
        break;

    case SDL_SCANCODE_F:
        CheatCode('f');
        break;

    case SDL_SCANCODE_G:
        CheatCode('g');
        break;

    case SDL_SCANCODE_H:
        CheatCode('h');
        break;

    case SDL_SCANCODE_I:
        CheatCode('i');
        break;

    case SDL_SCANCODE_J:
        CheatCode('j');
        break;

    case SDL_SCANCODE_K:
        CheatCode('k');
        break;

    case SDL_SCANCODE_L:
        CheatCode('l');
        break;

    case SDL_SCANCODE_M:
        CheatCode('m');
        break;

    case SDL_SCANCODE_N:
        CheatCode('n');
        break;

    case SDL_SCANCODE_O:
        CheatCode('o');
        break;

    case SDL_SCANCODE_P:
        CheatCode('p');
        break;

    case SDL_SCANCODE_Q:
        CheatCode('q');
        break;

    case SDL_SCANCODE_R:
        CheatCode('r');
        break;

    case SDL_SCANCODE_S:
        CheatCode('s');
        break;

    case SDL_SCANCODE_T:
        CheatCode('t');
        break;

    case SDL_SCANCODE_U:
        CheatCode('u');
        break;

    case SDL_SCANCODE_V:
        CheatCode('v');
        break;

    case SDL_SCANCODE_W:
        CheatCode('w');
        break;

    case SDL_SCANCODE_X:
        CheatCode('x');
        break;

    case SDL_SCANCODE_Y:
        CheatCode('y');
        break;

    case SDL_SCANCODE_Z:
        CheatCode('z');
        break;

    case SDL_SCANCODE_1:
        CheatCode('1');
        break;

    case SDL_SCANCODE_2:
        CheatCode('2');
        break;

    case SDL_SCANCODE_3:
        CheatCode('3');
        break;

    case SDL_SCANCODE_4:
        CheatCode('4');
        break;

    case SDL_SCANCODE_5:
        CheatCode('5');
        break;

    case SDL_SCANCODE_6:
        CheatCode('6');
        break;

    case SDL_SCANCODE_7:
        CheatCode('7');
        break;

    case SDL_SCANCODE_8:
        CheatCode('8');
        break;

    case SDL_SCANCODE_9:
        CheatCode('9');
        break;

    case SDL_SCANCODE_0:
        CheatCode('0');
        break;

    case SDL_SCANCODE_SEMICOLON:
        CheatCode(';');
        break; // for AZERTY support

    default:
        CheatCode(' ');
        break;
    }

    return true;
}

bool InputMethodType_Keyboard::ConsumeEvent(const SDL_Event* ev)
{
    switch(ev->type)
    {
    case SDL_MOUSEWHEEL:
        if(ev->wheel.which != SDL_TOUCH_MOUSEID)
        {
            // scrolling up results in traversing items backwards
            this->m_scroll -= ev->wheel.y;

#if SDL_VERSION_ATLEAST(2,0,18)
            SDL_version ver;
            SDL_GetVersion(&ver);

            if(int(ver.major) * 0x10000 + int(ver.minor) * 0x100 + int(ver.patch) >= 2 * 0x10000 + 0 * 0x100 + 18)
            {
                this->m_scroll_x_precise += ev->wheel.preciseX;
                this->m_scroll_y_precise -= ev->wheel.preciseY;
            }
            else
#endif
            {
                this->m_scroll_x_precise += ev->wheel.x;
                this->m_scroll_y_precise -= ev->wheel.y;
            }

            return true;
        }
        else
            return false;

    case SDL_MOUSEBUTTONUP:
#ifndef RENDER_FULLSCREEN_ALWAYS
        if(ev->button.button == SDL_BUTTON_LEFT && ev->button.which != SDL_TOUCH_MOUSEID)
        {
            bool doubleClick = (this->m_lastMousePress + 300) >= SDL_GetTicks();
            this->m_lastMousePress = SDL_GetTicks();

            if(doubleClick && !MagicHand && !LevelEditor && !g_cancelDoubleClick)
            {
                this->m_lastMousePress = 0;
                g_hotkeysPressed[Hotkeys::Buttons::Fullscreen] = 0;
                return true;
            }

            g_cancelDoubleClick = false;
        }
#endif

    // intentional fallthrough
    case SDL_MOUSEBUTTONDOWN:
        if(ev->button.which == SDL_TOUCH_MOUSEID)
            this->m_touchscreenActive = true;
        else
            this->m_touchscreenActive = false;

        break;

    case SDL_MOUSEMOTION:
        if(ev->motion.which == SDL_TOUCH_MOUSEID)
            this->m_touchscreenActive = true;
        else
            this->m_touchscreenActive = false;

        break;

    case SDL_TEXTINPUT:
        if(this->m_directText && GamePaused == PauseCode::TextEntry)
        {
            TextEntryScreen::Insert(ev->text.text);
            return true;
        }

        return false;

    case SDL_KEYDOWN:
        if(this->DefaultHotkey(ev))
            return true;

        if(this->m_directText && GamePaused == PauseCode::TextEntry)
        {
            if(ev->key.keysym.scancode == SDL_SCANCODE_RETURN || ev->key.keysym.scancode == SDL_SCANCODE_KP_ENTER)
                TextEntryScreen::Commit();
            else if(ev->key.keysym.scancode == SDL_SCANCODE_LEFT)
                TextEntryScreen::CursorLeft();
            else if(ev->key.keysym.scancode == SDL_SCANCODE_RIGHT)
                TextEntryScreen::CursorRight();
            else if(ev->key.keysym.scancode == SDL_SCANCODE_BACKSPACE)
                TextEntryScreen::Backspace();

            return true;
        }

        return false;

    default:
        return false;
    }

    return false;
}

// optional function allowing developer to associate device information with profile, etc
bool InputMethodType_Keyboard::SetProfile_Custom(InputMethod* method, int player_no, InputMethodProfile* profile,
        const std::vector<InputMethod*>& active_methods)
{
    if(!method || !profile || player_no < 0 || player_no >= maxLocalPlayers)
        return false;

    // prevent duplicates of a profile from ever being set
    for(InputMethod* o_method : active_methods)
    {
        if(!o_method)
            continue;

        if(o_method != method && o_method->Profile == profile)
            return false;
    }

    m_canPoll = false;
    return true;
}

// How many per-type special options are there?
size_t InputMethodType_Keyboard::GetOptionCount()
{
    return 2;
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount() returns 0.
// get a char* describing the option
const char* InputMethodType_Keyboard::GetOptionName(size_t i)
{
    if(i == 0)
        return g_controlsStrings.sharedOptionMaxPlayers.c_str();

    if(i == 1)
        return g_controlsStrings.keyboardOptionTextEntryStyle.c_str();

    return nullptr;
}

// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodType_Keyboard::GetOptionValue(size_t i)
{
    if(i == 0)
    {
        static char buf[3];
        snprintf(buf, 3, "%d", this->m_maxKeyboards);
        return buf;
    }

    if(i == 1)
    {
        if(this->m_directText)
            return g_controlsStrings.nameKeyboard.c_str();
        else
            return g_controlsStrings.nameGamepad.c_str();
    }

    return nullptr;
}

// called when A is pressed; allowed to interrupt main game loop
bool InputMethodType_Keyboard::OptionChange(size_t i)
{
    if(i == 0)
    {
        this->m_maxKeyboards ++;

        if(this->m_maxKeyboards > maxLocalPlayers)
            this->m_maxKeyboards = 0;

        return true;
    }

    if(i == 1)
    {
        this->m_directText = !this->m_directText;
        return true;
    }

    return false;
}

// called when left is pressed
bool InputMethodType_Keyboard::OptionRotateLeft(size_t i)
{
    if(i == 0)
    {
        if(this->m_maxKeyboards > 0)
        {
            this->m_maxKeyboards --;
            return true;
        }
    }

    if(i == 1)
    {
        this->m_directText = !this->m_directText;
        return true;
    }

    return false;
}

// called when right is pressed
bool InputMethodType_Keyboard::OptionRotateRight(size_t i)
{
    if(i == 0)
    {
        if(this->m_maxKeyboards < maxLocalPlayers)
        {
            this->m_maxKeyboards ++;
            return true;
        }
    }

    if(i == 1)
    {
        this->m_directText = !this->m_directText;
        return true;
    }

    return false;
}

void InputMethodType_Keyboard::SaveConfig_Custom(IniProcessing* ctl)
{
    ctl->setValue("max-keyboards", this->m_maxKeyboards);
    ctl->setValue("direct-text-entry", this->m_directText);
}

void InputMethodType_Keyboard::LoadConfig_Custom(IniProcessing* ctl)
{
    ctl->read("max-keyboards", this->m_maxKeyboards, maxLocalPlayers);
    ctl->read("direct-text-entry", this->m_directText, true);
}

} // namespace Controls


================================================
FILE: src/control/keyboard.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef KEYBOARD_H
#define KEYBOARD_H

#include "../controls.h"

namespace Controls
{

extern bool g_cancelDoubleClick;

constexpr int null_key = -1;

class InputMethod_Keyboard : public InputMethod
{
public:
    using InputMethod::Type;
    using InputMethod::Profile;

    ~InputMethod_Keyboard();

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);

    StatusInfo GetStatus();
};

class InputMethodProfile_Keyboard : public InputMethodProfile
{
private:
    bool m_canPoll = false;

public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    int m_keys[PlayerControls::n_buttons] = {null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key};
    int m_keys2[PlayerControls::n_buttons] = {null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key};

    int m_editor_keys[EditorControls::n_buttons] = {null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key};
    int m_editor_keys2[EditorControls::n_buttons] = {null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key, null_key};

    int m_cursor_keys2[CursorControls::n_buttons] = {null_key, null_key, null_key, null_key, null_key, null_key, null_key};

    int m_hotkeys[Hotkeys::n_buttons];
    int m_hotkeys2[Hotkeys::n_buttons];

    InputMethodProfile_Keyboard();

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);
};

class InputMethodType_Keyboard : public InputMethodType
{
private:
    bool m_canPoll = false;

    int m_lastNumKeyboards = 0;
    bool m_touchscreenActive = false;

#ifndef RENDER_FULLSCREEN_ALWAYS
    Uint32 m_lastMousePress = 0;
#endif

    int m_scroll = 0;

    InputMethodProfile *AllocateProfile() noexcept override;

public:
    int m_numKeyboards = 0;

    // options
    int m_maxKeyboards = 2;
    bool m_directText = true;

    using InputMethodType::m_profiles;

    const uint8_t *m_keyboardState;
    int m_keyboardStateSize = 0;


    // used by input methods for scrolling in editor
    float m_scroll_x_precise = 0.0;
    float m_scroll_y_precise = 0.0;


    InputMethodType_Keyboard();

    const std::string& LocalName() const override;

    bool TestProfileType(InputMethodProfile *profile) override;
    bool RumbleSupported() override;

    void UpdateControlsPre() override;
    void UpdateControlsPost() override;

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept override;

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
protected:
    // optional function allowing developer to associate device information with profile, etc
    // if developer wants to forbid assignment, return false
    bool SetProfile_Custom(InputMethod *method, int player_no, InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods) override;

public:
    bool DefaultHotkey(const SDL_Event *ev);
    bool ConsumeEvent(const SDL_Event *ev) override;

    // How many per-type special options are there?
    size_t GetOptionCount() override;
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount() returns 0.
    // get a char* describing the option
    const char *GetOptionName(size_t i) override;
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue(size_t i) override;
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange(size_t i) override;
    // called when left is pressed
    bool OptionRotateLeft(size_t i) override;
    // called when right is pressed
    bool OptionRotateRight(size_t i) override;

protected:
    void SaveConfig_Custom(IniProcessing *ctl) override;
    void LoadConfig_Custom(IniProcessing *ctl) override;
};

} // namespace Controls

#endif // #ifndef KEYBOARD_H


================================================
FILE: src/control/touchscreen.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <SDL2/SDL.h>

#include <Logger/logger.h>
#ifdef __ANDROID__
#   include <Utils/files.h>
#endif

#include "AppPath/app_path.h"

#include "touchscreen.h"
#include "../globals.h"
// #include "config.h" // Not used
#include "../game_main.h"
#include "../player.h"
#include "../core/render.h"
#include "../core/window.h"

#include "main/menu_main.h"
#include "main/screen_asset_pack.h"
#include "control/controls_strings.h"

#include "core/power.h"

#include "editor/new_editor.h"

#include <SDL2/SDL_haptic.h>


#ifdef __ANDROID__
#   include <jni.h>

static double s_screenSize = -1;
static double s_screenWidth = -1;
static double s_screenHeight = -1;

extern "C" JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_setScreenSize(
    JNIEnv* env,
    jclass type,
    jdouble screenSize,
    jdouble screenWidth,
    jdouble screenHeight
)
{
    (void)env;
    (void)type;
    s_screenSize = screenSize;
    s_screenWidth = screenWidth;
    s_screenHeight = screenHeight;
}

extern "C" JNIEXPORT void JNICALL
Java_org_libsdl_app_SDLActivity_thextechDebugLog(
    JNIEnv* env,
    jclass clazz,
    jstring line_j)
{
    const char *line;
    (void)clazz;
    line = env->GetStringUTFChars(line_j, nullptr);
    pLogDebug("Java-Side: %s", line);
    env->ReleaseStringUTFChars(line_j, line);
}

#endif

namespace Controls
{

/*------------------------------------------*\
|| implementation for TouchScreenGFX_t      ||
\*------------------------------------------*/

void TouchScreenGFX_t::loadImage(StdPicture& img, const std::string& fileName)
{
    std::string imgPath = m_gfxPath + fileName;

#ifdef __ANDROID__
    if(!Files::fileExists(imgPath)) // If not exists at assets, do load bundled
        imgPath = "buttons/" + fileName;
#endif

    // pLogDebug("Loading texture %s...", imgPath.c_str());
    img.reset();
    XRender::lazyLoadPicture(img, imgPath);

    if(!img.inited)
    {
        if(m_loadErrors == 0)
            pLogWarning("Failed to load texture: %s...", imgPath.c_str());

        m_loadErrors++;
    }
}

TouchScreenGFX_t::TouchScreenGFX_t()
{
    m_success = false;
}

void TouchScreenGFX_t::loadAll()
{
    m_loadErrors = 0;
    m_success = true;

    // Loading a touch-screen buttons from assets
    loadImage(touch[BUTTON_START], "Start.png");
    loadImage(touch[BUTTON_LEFT], "Left.png");
    loadImage(touch[BUTTON_LEFT_CHAR], "Left_char.png");
    loadImage(touch[BUTTON_RIGHT], "Right.png");
    loadImage(touch[BUTTON_RIGHT_CHAR], "Right_char.png");
    loadImage(touch[BUTTON_UP], "Up.png");
    loadImage(touch[BUTTON_DOWN], "Down.png");
    loadImage(touch[BUTTON_UPLEFT], "UpLeft.png");
    loadImage(touch[BUTTON_UPRIGHT], "UpRight.png");
    loadImage(touch[BUTTON_DOWNLEFT], "DownLeft.png");
    loadImage(touch[BUTTON_DOWNRIGHT], "DownRight.png");
    loadImage(touch[BUTTON_A], "A.png");
    loadImage(touch[BUTTON_A_PS], "A_ps.png");
    loadImage(touch[BUTTON_A_BLANK], "A_blank.png");
    loadImage(touch[BUTTON_A_DO], "A_do.png");
    loadImage(touch[BUTTON_A_ENTER], "A_enter.png");
    loadImage(touch[BUTTON_A_JUMP], "A_jump.png");
    loadImage(touch[BUTTON_B], "V.png");
    loadImage(touch[BUTTON_B_PS], "V_ps.png");
    loadImage(touch[BUTTON_B_BLANK], "V_blank.png");
    loadImage(touch[BUTTON_B_JUMP], "V_jump.png");
    loadImage(touch[BUTTON_B_SPINJUMP], "V_spinjump.png");
    loadImage(touch[BUTTON_X], "X.png");
    loadImage(touch[BUTTON_X_PS], "X_ps.png");
    loadImage(touch[BUTTON_X_BACK], "X_back.png");
    loadImage(touch[BUTTON_X_BLANK], "X_blank.png");
    loadImage(touch[BUTTON_X_BOMB], "X_bomb.png");
    loadImage(touch[BUTTON_X_BUMERANG], "X_bumerang.png");
    loadImage(touch[BUTTON_X_FIRE], "X_fire.png");
    loadImage(touch[BUTTON_X_HAMMER], "X_hammer.png");
    loadImage(touch[BUTTON_X_RUN], "X_run.png");
    loadImage(touch[BUTTON_X_SWORD], "X_sword.png");
    loadImage(touch[BUTTON_Y], "Y.png");
    loadImage(touch[BUTTON_Y_PS], "Y_ps.png");
    loadImage(touch[BUTTON_Y_BLANK], "Y_blank.png");
    loadImage(touch[BUTTON_Y_BOMB], "Y_bomb.png");
    loadImage(touch[BUTTON_Y_BUMERANG], "Y_bumerang.png");
    loadImage(touch[BUTTON_Y_FIRE], "Y_fire.png");
    loadImage(touch[BUTTON_Y_HAMMER], "Y_hammer.png");
    loadImage(touch[BUTTON_Y_RUN], "Y_run.png");
    loadImage(touch[BUTTON_Y_STATUE], "Y_statue.png");
    loadImage(touch[BUTTON_Y_SWORD], "Y_sword.png");
    loadImage(touch[BUTTON_DROP], "Select.png");
    loadImage(touch[BUTTON_HOLD_RUN_OFF], "RunOff.png");
    loadImage(touch[BUTTON_HOLD_RUN_ON], "RunOn.png");
    loadImage(touch[BUTTON_VIEW_TOGGLE_OFF], "KeysShowOff.png");
    loadImage(touch[BUTTON_VIEW_TOGGLE_ON], "KeysShow.png");
    loadImage(touch[BUTTON_ANALOG_BORDER], "SBorder.png");
    loadImage(touch[BUTTON_ANALOG_STICK], "AStick.png");
    loadImage(touch[BUTTON_ENTER_CHEATS], "EnterCheats.png");

    if(m_loadErrors > 0)
        m_success = false;

    if(m_loadErrors > 1)
        pLogWarning("and %d other file(s)", m_loadErrors - 1);
}

void TouchScreenGFX_t::load()
{
    m_gfxPath = AppPath + "graphics/touchscreen/";
    loadAll();

    // try loading from other paths if unsuccessful
    for(const auto& root_ : AppPathManager::assetsSearchPath())
    {
        if(m_success)
            break;

        m_gfxPath = root_.first + "graphics/touchscreen/";
        loadAll();
    }

    if(m_success)
        pLogDebug("Loaded touchscreen GFX from %s", m_gfxPath.c_str());
    else
        pLogWarning("Touch-screen controller cannot be used due to missing assets.");
}

/*------------------------------------------*\
|| implementation for TouchScreenController ||
\*------------------------------------------*/

bool TouchScreenController::touchSupported()
{
    if(m_touchDevicesCount <= 0)
        return false;

    if(!m_GFX.m_success)
        return false;

    return true;
}

int TouchScreenController::numDevices() const
{
    return m_touchDevicesCount;
}

bool TouchScreenController::touchOn()
{
    for(auto it = m_devices.begin(); it != m_devices.end(); ++it)
    {
        int fingers = SDL_GetNumTouchFingers(it->id);
        if(fingers > 0)
            return true;
    }

    return false;
}

TouchScreenController::FingerState::FingerState()
{
    for(int i = key_BEGIN; i < key_END; i++)
    {
        heldKey[i] = false;
        heldKeyPrev[i] = false;
    }
}

TouchScreenController::FingerState::FingerState(const FingerState& fs)
{
    alive = fs.alive;

    for(int i = key_BEGIN; i < key_END; i++)
    {
        heldKey[i] = fs.heldKey[i];
        heldKeyPrev[i] = fs.heldKeyPrev[i];
    }
}

TouchScreenController::FingerState& TouchScreenController::FingerState::operator=(const FingerState& fs)
{
    alive = fs.alive;

    for(int i = key_BEGIN; i < key_END; i++)
    {
        heldKey[i] = fs.heldKey[i];
        heldKeyPrev[i] = fs.heldKeyPrev[i];
    }

    return *this;
}

static int buttonLeft(int player_no, int style)
{
    (void)player_no;
    (void)style;

    if(SwapCharAllowed() && GamePaused == PauseCode::PauseScreen)
        return TouchScreenGFX_t::BUTTON_LEFT_CHAR;
    else
        return TouchScreenGFX_t::BUTTON_LEFT;
}

static int buttonRight(int player_no, int style)
{
    (void)player_no;
    (void)style;

    if(SwapCharAllowed() && GamePaused == PauseCode::PauseScreen)
        return TouchScreenGFX_t::BUTTON_RIGHT_CHAR;
    else
        return TouchScreenGFX_t::BUTTON_RIGHT;
}

static int buttonA(int player_no, int style)
{
    (void)player_no;

    switch(style)
    {
    case TouchScreenController::style_abxy:
        return TouchScreenGFX_t::BUTTON_A;

    case TouchScreenController::style_xoda:
        return TouchScreenGFX_t::BUTTON_A_PS;

    default:
    case TouchScreenController::style_actions:
        if(GamePaused != PauseCode::None || GameMenu)
            return TouchScreenGFX_t::BUTTON_A_DO;
        else if(GameOutro)
            return TouchScreenGFX_t::BUTTON_A_BLANK;
        else if(LevelSelect)
            return TouchScreenGFX_t::BUTTON_A_ENTER;
        else
            return TouchScreenGFX_t::BUTTON_A_JUMP;
    }
}

static int buttonX(int player_no, int style)
{
    switch(style)
    {
    case TouchScreenController::style_abxy:
        return TouchScreenGFX_t::BUTTON_X;

    case TouchScreenController::style_xoda:
        return TouchScreenGFX_t::BUTTON_X_PS;

    default:
    case TouchScreenController::style_actions:
        if(GamePaused != PauseCode::None || GameMenu)
            return TouchScreenGFX_t::BUTTON_X_BACK;
        else if(LevelSelect || GameOutro)
            return TouchScreenGFX_t::BUTTON_X_BLANK;
        else
        {
            if(numPlayers >= player_no)
            {
                auto& p = Player[player_no];

                if(p.Character == 5 || p.State == 4 || p.State == 5)
                    return TouchScreenGFX_t::BUTTON_X_SWORD;
                else if(p.State < 3)
                    return TouchScreenGFX_t::BUTTON_X_RUN;
                else if(p.State == 3 || p.State == 7)
                    return TouchScreenGFX_t::BUTTON_X_FIRE;
                else if(p.State == 6)
                {
                    switch(p.Character)
                    {
                    default:
                    case 1:
                    case 2:
                        return TouchScreenGFX_t::BUTTON_X_HAMMER;

                    case 3:
                        return TouchScreenGFX_t::BUTTON_X_BOMB;

                    case 4:
                        return TouchScreenGFX_t::BUTTON_X_BUMERANG;

                    case 5:
                        return TouchScreenGFX_t::BUTTON_X_SWORD;
                    }
                }
            }

            return TouchScreenGFX_t::BUTTON_X_BLANK;
        }
    }
}

static int buttonB(int player_no, int style)
{
    switch(style)
    {
    case TouchScreenController::style_abxy:
        return TouchScreenGFX_t::BUTTON_B;

    case TouchScreenController::style_xoda:
        return TouchScreenGFX_t::BUTTON_B_PS;

    default:
    case TouchScreenController::style_actions:
        if(LevelSelect || GamePaused != PauseCode::None || GameMenu || GameOutro)
            return TouchScreenGFX_t::BUTTON_B_BLANK;
        else
        {
            if(numPlayers >= player_no)
            {
                auto& p = Player[player_no];

                if(p.Character <= 2 || p.Character == 4)
                    return TouchScreenGFX_t::BUTTON_B_SPINJUMP;
                else
                    return TouchScreenGFX_t::BUTTON_B_JUMP;
            }

            return TouchScreenGFX_t::BUTTON_B_BLANK;
        }
    }
}

static int buttonY(int player_no, int style)
{
    switch(style)
    {
    case TouchScreenController::style_abxy:
        return TouchScreenGFX_t::BUTTON_Y;

    case TouchScreenController::style_xoda:
        return TouchScreenGFX_t::BUTTON_Y_PS;

    default:
    case TouchScreenController::style_actions:
        if(LevelSelect || GamePaused != PauseCode::None || GameMenu || GameOutro)
            return TouchScreenGFX_t::BUTTON_Y_BLANK;
        else
        {
            if(numPlayers >= player_no)
            {
                auto& p = Player[player_no];

                if(p.State == 5)
                    return TouchScreenGFX_t::BUTTON_Y_STATUE;

                if(p.Character == 5 || p.State == 4)
                    return TouchScreenGFX_t::BUTTON_Y_SWORD;
                else if(p.State < 3)
                    return TouchScreenGFX_t::BUTTON_Y_RUN;
                else if(p.State == 3 || p.State == 7)
                    return TouchScreenGFX_t::BUTTON_Y_FIRE;
                else if(p.State == 6)
                {
                    switch(p.Character)
                    {
                    default:
                    case 1:
                    case 2:
                        return TouchScreenGFX_t::BUTTON_Y_HAMMER;

                    case 3:
                        return TouchScreenGFX_t::BUTTON_Y_BOMB;

                    case 4:
                        return TouchScreenGFX_t::BUTTON_Y_BUMERANG;

                    case 5:
                        return TouchScreenGFX_t::BUTTON_Y_SWORD;
                    }
                }
            }

            return TouchScreenGFX_t::BUTTON_Y_BLANK;
        }
    }
}


static struct TouchKeyMap
{
    enum anchor
    {
        T = 0,
        B,
        L = 0,
        R,
        C
    };

    struct KeyPos
    {
        anchor xa;
        anchor ya;
        float x1;
        float y1;
        float x2;
        float y2;
        TouchScreenController::commands cmd;
    };

    //! Width of canvas area
    float touchCanvasWidth = 1024.0f;
    //! Height of canvas area
    float touchCanvasHeight = 600.0f;

    //! List of key hit boxes
    KeyPos touchKeysMap[TouchScreenController::key_END];

    TouchKeyMap()
    {
        static_assert(sizeof(touchKeysMap) == TouchScreenController::key_END * sizeof(KeyPos),
                      "The size of touchscreen keys pam must have the size of key_END multiplied to size of KeyPos");

        for(int it = TouchScreenController::key_BEGIN; it < TouchScreenController::key_END; it++)
        {
            auto& p = touchKeysMap[it];
            p.cmd = static_cast<TouchScreenController::commands>(it);
            SDL_assert(p.cmd >= TouchScreenController::key_BEGIN && p.cmd < TouchScreenController::key_END);
        }
    }

    /**
     * \brief Change size of virtual canvas
     * @param width Width of touchable canvas
     * @param height Height of touchable canvas
     */
    void setCanvasSize(float width, float height)
    {
        touchCanvasWidth = width;
        touchCanvasHeight = height;
    }

    /**
     * \brief Change hitbox of key
     * @param cmd Command
     * @param left Left side position
     * @param top Top side position
     * @param right Right side position
     * @param bottom Bottom side position
     */
    void setKeyPos(TouchScreenController::commands cmd, float left, float top, float right, float bottom)
    {
        if(cmd < TouchScreenController::key_BEGIN || cmd >= TouchScreenController::key_END)
            return;

        SDL_assert_release(touchKeysMap[cmd].cmd == cmd);

        auto& key = touchKeysMap[cmd];
        key.x1 = left;
        key.y1 = top;
        key.x2 = right;
        key.y2 = bottom;
    }

    /**
     * \brief Find keys are touched by one finger
     * @param x X position of finger
     * @param y Y position of finger
     * @param keys Destination array to write captured keys
     * @return Count of keys are got touched
     */
    int findTouchKeys(float x, float y, TouchScreenController::FingerState& fs)
    {
        // const size_t touchKeyMapSize = sizeof(touchKeysMap) / sizeof(KeyPos);
        int count = 0;
        x *= touchCanvasWidth;
        y *= touchCanvasHeight;

        for(const auto& p : touchKeysMap)
        {
            SDL_assert(p.cmd >= TouchScreenController::key_BEGIN && p.cmd < TouchScreenController::key_END);
            fs.heldKey[p.cmd] = false;

            bool coll_normal = (x >= p.x1 && x <= p.x2 && y >= p.y1 && y <= p.y2);

            // special overlap for face buttons
            bool is_button = (p.cmd == TouchScreenController::key_jump || p.cmd == TouchScreenController::key_altjump
                            || p.cmd == TouchScreenController::key_run || p.cmd == TouchScreenController::key_altrun);

            float w_extra = (p.x2 - p.x1) * 0.25;
            float h_extra = (p.y2 - p.y1) * 0.1;
            bool coll_button = (x >= p.x1 - w_extra && x <= p.x2 + w_extra && y >= p.y1 - h_extra && y <= p.y2 + h_extra);

            if(coll_normal || (is_button && coll_button))
            {
                fs.heldKey[p.cmd] = true;
                count++;
            }
        }

        return count;
    }

} g_touchKeyMap;

/*-----------------------Screen size depending layouts ----------------------------------*/
/************************************************
 * Please use this tool to edit these layouts:  *
 * https://github.com/Wohlstand/TouchpadTuner   *
 ************************************************/

static const TouchKeyMap::KeyPos c_4_tinyPhoneMap[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::L, TouchKeyMap::T, 335.0f, 12.0f, 451.0f, 52.0f, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::T, 11.0f, 262.0f, 91.0f, 342.0f, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::T, 171.0f, 262.0f, 251.0f, 342.0f, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::T, 91.0f, 182.0f, 171.0f, 262.0f, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::T, 91.0f, 342.0f, 171.0f, 422.0f, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::T, 11.0f, 182.0f, 91.0f, 262.0f, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::T, 171.0f, 182.0f, 251.0f, 262.0f, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::T, 11.0f, 342.0f, 91.0f, 422.0f, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::T, 171.0f, 342.0f, 251.0f, 422.0f, TouchScreenController::key_downright},
    {TouchKeyMap::L, TouchKeyMap::T, 396.0f, 276.0f, 493.0f, 373.0f, TouchScreenController::key_run},
    {TouchKeyMap::L, TouchKeyMap::T, 512.0f, 307.0f, 609.0f, 404.0f, TouchScreenController::key_jump},
    {TouchKeyMap::L, TouchKeyMap::T, 416.0f, 163.0f, 513.0f, 260.0f, TouchScreenController::key_altrun},
    {TouchKeyMap::L, TouchKeyMap::T, 531.0f, 191.0f, 628.0f, 288.0f, TouchScreenController::key_altjump},
    {TouchKeyMap::L, TouchKeyMap::T, 196.0f, 12.0f, 312.0f, 52.0f, TouchScreenController::key_drop},
    {TouchKeyMap::L, TouchKeyMap::T, 494.0f, 50.0f, 618.0f, 97.0f, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 10.0f, 64.0f, 64.0f, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 66.0f, 64.0f, 110.0f, TouchScreenController::key_enterCheats},
};

static const TouchKeyMap::KeyPos c_averagePhoneMap[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::L, TouchKeyMap::T, 542.0f, 537.0f, 693.0f, 587.0f, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::T, 1.0f, 410.0f, 83.0f, 492.0f, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::T, 165.0f, 410.0f, 247.0f, 492.0f, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::T, 83.0f, 328.0f, 165.0f, 410.0f, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::T, 83.0f, 492.0f, 165.0f, 574.0f, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::T, 1.0f, 328.0f, 83.0f, 410.0f, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::T, 165.0f, 328.0f, 247.0f, 410.0f, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::T, 1.0f, 492.0f, 83.0f, 574.0f, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::T, 165.0f, 492.0f, 247.0f, 574.0f, TouchScreenController::key_downright},
    {TouchKeyMap::L, TouchKeyMap::T, 764.0f, 403.0f, 868.0f, 507.0f, TouchScreenController::key_run},
    {TouchKeyMap::L, TouchKeyMap::T, 885.0f, 436.0f, 989.0f, 540.0f, TouchScreenController::key_jump},
    {TouchKeyMap::L, TouchKeyMap::T, 786.0f, 287.0f, 890.0f, 391.0f, TouchScreenController::key_altrun},
    {TouchKeyMap::L, TouchKeyMap::T, 904.0f, 317.0f, 1008.0f, 421.0f, TouchScreenController::key_altjump},
    {TouchKeyMap::L, TouchKeyMap::T, 331.0f, 537.0f, 482.0f, 587.0f, TouchScreenController::key_drop},
    {TouchKeyMap::L, TouchKeyMap::T, 827.0f, 129.0f, 943.0f, 169.0f, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 10.0f, 70.0f, 70.0f, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 74.0f, 70.0f, 134.0f, TouchScreenController::key_enterCheats},
};

static const TouchKeyMap::KeyPos c_averagePhoneLongMap[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::L, TouchKeyMap::T, 727.0f, 632.0f, 911.0f, 691.0f, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::T, 5.0f, 444.0f, 106.0f, 545.0f, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::T, 207.0f, 444.0f, 308.0f, 545.0f, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::T, 106.0f, 343.0f, 207.0f, 444.0f, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::T, 106.0f, 545.0f, 207.0f, 646.0f, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::T, 5.0f, 343.0f, 106.0f, 444.0f, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::T, 207.0f, 343.0f, 308.0f, 444.0f, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::T, 5.0f, 545.0f, 106.0f, 646.0f, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::T, 207.0f, 545.0f, 308.0f, 646.0f, TouchScreenController::key_downright},
    {TouchKeyMap::L, TouchKeyMap::T, 1055.0f, 500.0f, 1183.0f, 628.0f, TouchScreenController::key_run},
    {TouchKeyMap::L, TouchKeyMap::T, 1218.0f, 537.0f, 1346.0f, 665.0f, TouchScreenController::key_jump},
    {TouchKeyMap::L, TouchKeyMap::T, 1085.0f, 351.0f, 1213.0f, 479.0f, TouchScreenController::key_altrun},
    {TouchKeyMap::L, TouchKeyMap::T, 1242.0f, 389.0f, 1370.0f, 517.0f, TouchScreenController::key_altjump},
    {TouchKeyMap::L, TouchKeyMap::T, 474.0f, 632.0f, 658.0f, 691.0f, TouchScreenController::key_drop},
    {TouchKeyMap::L, TouchKeyMap::T, 1178.0f, 214.0f, 1315.0f, 275.0f, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 10.0f, 85.0f, 85.0f, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 90.0f, 85.0f, 165.0f, TouchScreenController::key_enterCheats},
};

static const TouchKeyMap::KeyPos c_7_tablet[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::L, TouchKeyMap::T, 636.0f, 544.0f, 775.0f, 582.0f, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::T, 3.0f, 430.0f, 76.0f, 503.0f, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::T, 149.0f, 430.0f, 222.0f, 503.0f, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::T, 76.0f, 357.0f, 149.0f, 430.0f, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::T, 76.0f, 503.0f, 149.0f, 576.0f, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::T, 3.0f, 357.0f, 76.0f, 430.0f, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::T, 149.0f, 357.0f, 222.0f, 430.0f, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::T, 3.0f, 503.0f, 76.0f, 576.0f, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::T, 149.0f, 503.0f, 222.0f, 576.0f, TouchScreenController::key_downright},
    {TouchKeyMap::L, TouchKeyMap::T, 797.0f, 439.0f, 887.0f, 529.0f, TouchScreenController::key_run},
    {TouchKeyMap::L, TouchKeyMap::T, 897.0f, 463.0f, 987.0f, 553.0f, TouchScreenController::key_jump},
    {TouchKeyMap::L, TouchKeyMap::T, 819.0f, 341.0f, 909.0f, 431.0f, TouchScreenController::key_altrun},
    {TouchKeyMap::L, TouchKeyMap::T, 919.0f, 363.0f, 1009.0f, 453.0f, TouchScreenController::key_altjump},
    {TouchKeyMap::L, TouchKeyMap::T, 257.0f, 544.0f, 396.0f, 582.0f, TouchScreenController::key_drop},
    {TouchKeyMap::L, TouchKeyMap::T, 873.0f, 226.0f, 968.0f, 258.0f, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 10.0f, 58.0f, 58.0f, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 64.0f, 58.0f, 112.0f, TouchScreenController::key_enterCheats},
};

static const TouchKeyMap::KeyPos c_10_6_tablet[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::L, TouchKeyMap::T, 869.0f, 753.0f, 1002.0f, 785.0f, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::T, 19.0f, 591.0f, 89.0f, 661.0f, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::T, 159.0f, 591.0f, 229.0f, 661.0f, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::T, 89.0f, 521.0f, 159.0f, 591.0f, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::T, 89.0f, 661.0f, 159.0f, 731.0f, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::T, 19.0f, 521.0f, 89.0f, 591.0f, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::T, 159.0f, 521.0f, 229.0f, 591.0f, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::T, 19.0f, 661.0f, 89.0f, 731.0f, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::T, 159.0f, 661.0f, 229.0f, 731.0f, TouchScreenController::key_downright},
    {TouchKeyMap::L, TouchKeyMap::T, 1047.0f, 588.0f, 1137.0f, 678.0f, TouchScreenController::key_run},
    {TouchKeyMap::L, TouchKeyMap::T, 1159.0f, 624.0f, 1249.0f, 714.0f, TouchScreenController::key_jump},
    {TouchKeyMap::L, TouchKeyMap::T, 1067.0f, 477.0f, 1157.0f, 567.0f, TouchScreenController::key_altrun},
    {TouchKeyMap::L, TouchKeyMap::T, 1179.0f, 505.0f, 1269.0f, 595.0f, TouchScreenController::key_altjump},
    {TouchKeyMap::L, TouchKeyMap::T, 256.0f, 753.0f, 389.0f, 785.0f, TouchScreenController::key_drop},
    {TouchKeyMap::L, TouchKeyMap::T, 1131.0f, 387.0f, 1225.0f, 426.0f, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 10.0f, 57.0f, 57.0f, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 10.0f, 60.0f, 57.0f, 107.0f, TouchScreenController::key_enterCheats},
};

// watch your aspect ratios. they are preserved now!

// based on c_10_6_tablet; no longer used.
#if 0
static const TouchKeyMap::KeyPos c_smallAutoMap[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::C, TouchKeyMap::B, 0.04, -0.08, 0.15, -0.04, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::B, 0.015, -0.245, 0.105, -0.155, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::B, 0.195, -0.245, 0.285, -0.155, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::B, 0.105, -0.335, 0.195, -0.245, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::B, 0.105, -0.155, 0.195, -0.065, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::B, 0.015, -0.335, 0.105, -0.245, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::B, 0.195, -0.335, 0.285, -0.245, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::B, 0.015, -0.155, 0.105, -0.065, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::B, 0.195, -0.155, 0.285, -0.065, TouchScreenController::key_downright},
    {TouchKeyMap::R, TouchKeyMap::B, -0.265, -0.215, -0.165, -0.115, TouchScreenController::key_run},
    {TouchKeyMap::R, TouchKeyMap::B, -0.15, -0.20, -0.05, -0.10, TouchScreenController::key_jump},
    {TouchKeyMap::R, TouchKeyMap::B, -0.25, -0.33, -0.15, -0.23, TouchScreenController::key_altrun},
    {TouchKeyMap::R, TouchKeyMap::B, -0.135, -0.315, -0.035, -0.215, TouchScreenController::key_altjump},
    {TouchKeyMap::C, TouchKeyMap::B, -0.1525, -0.08, -0.0375, -0.04, TouchScreenController::key_drop},
    {TouchKeyMap::R, TouchKeyMap::B, -0.12, -0.40, -0.045, -0.36, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 0.01, 0.01, 0.07, 0.07, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 0.01, 0.08, 0.07, 0.14, TouchScreenController::key_enterCheats},
};
#endif

// based on c_averagePhoneMap
static const TouchKeyMap::KeyPos c_standardAutoMap[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::R, TouchKeyMap::B, -0.555f, -0.07f, -0.39f, -0.01f, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::B, 0.01f, -0.34f, 0.15f, -0.20f, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::B, 0.29f, -0.34f, 0.43f, -0.20f, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::B, 0.15f, -0.48f, 0.29f, -0.34f, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::B, 0.15f, -0.20f, 0.29f, -0.06f, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::B, 0.01f, -0.48f, 0.15f, -0.34f, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::B, 0.29f, -0.48f, 0.43f, -0.34f, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::B, 0.01f, -0.20f, 0.15f, -0.06f, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::B, 0.29f, -0.20f, 0.43f, -0.06f, TouchScreenController::key_downright},
    {TouchKeyMap::R, TouchKeyMap::B, -0.375f, -0.275f, -0.225f, -0.125f, TouchScreenController::key_run},
    {TouchKeyMap::R, TouchKeyMap::B, -0.20f, -0.25f, -0.05f, -0.10f, TouchScreenController::key_jump},
    {TouchKeyMap::R, TouchKeyMap::B, -0.35f, -0.45f, -0.20f, -0.30f, TouchScreenController::key_altrun},
    {TouchKeyMap::R, TouchKeyMap::B, -0.175f, -0.425f, -0.025f, -0.275f, TouchScreenController::key_altjump},
    {TouchKeyMap::L, TouchKeyMap::B, 0.44f, -0.07f, 0.6125f, -0.01f, TouchScreenController::key_drop},
    {TouchKeyMap::R, TouchKeyMap::B, -0.20f, -0.56f, -0.05f, -0.48f, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 0.02f, 0.02f, 0.12f, 0.12f, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 0.02f, 0.14f, 0.12f, 0.24f, TouchScreenController::key_enterCheats},
};

// based on c_4_tinyPhoneMap
static const TouchKeyMap::KeyPos c_tightAutoMap[TouchScreenController::key_END] =
{
    /* Note that order of keys must match the TouchScreenController::commands enum!!! */
    {TouchKeyMap::R, TouchKeyMap::T, -0.50f, 0.02f, -0.17f, 0.14f, TouchScreenController::key_start},
    {TouchKeyMap::L, TouchKeyMap::B, 0.01f, -0.37f, 0.18f, -0.20f, TouchScreenController::key_left},
    {TouchKeyMap::L, TouchKeyMap::B, 0.35f, -0.37f, 0.52f, -0.20f, TouchScreenController::key_right},
    {TouchKeyMap::L, TouchKeyMap::B, 0.18f, -0.54f, 0.35f, -0.37f, TouchScreenController::key_up},
    {TouchKeyMap::L, TouchKeyMap::B, 0.18f, -0.20f, 0.35f, -0.03f, TouchScreenController::key_down},
    {TouchKeyMap::L, TouchKeyMap::B, 0.01f, -0.54f, 0.18f, -0.37f, TouchScreenController::key_upleft},
    {TouchKeyMap::L, TouchKeyMap::B, 0.35f, -0.54f, 0.52f, -0.37f, TouchScreenController::key_upright},
    {TouchKeyMap::L, TouchKeyMap::B, 0.01f, -0.20f, 0.18f, -0.03f, TouchScreenController::key_downleft},
    {TouchKeyMap::L, TouchKeyMap::B, 0.35f, -0.20f, 0.52f, -0.03f, TouchScreenController::key_downright},
    {TouchKeyMap::R, TouchKeyMap::B, -0.48f, -0.25f, -0.28f, -0.05f, TouchScreenController::key_run},
    {TouchKeyMap::R, TouchKeyMap::B, -0.25f, -0.22f, -0.05f, -0.02f, TouchScreenController::key_jump},
    {TouchKeyMap::R, TouchKeyMap::B, -0.45f, -0.48f, -0.25f, -0.28f, TouchScreenController::key_altrun},
    {TouchKeyMap::R, TouchKeyMap::B, -0.22f, -0.45f, -0.02f, -0.25f, TouchScreenController::key_altjump},
    {TouchKeyMap::L, TouchKeyMap::T, 0.165f, 0.02f, 0.50f, 0.14f, TouchScreenController::key_drop},
    {TouchKeyMap::R, TouchKeyMap::B, -0.245f, -0.62f, -0.02f, -0.50f, TouchScreenController::key_holdRun},
    {TouchKeyMap::L, TouchKeyMap::T, 0.02f, 0.02f, 0.14f, 0.14f, TouchScreenController::key_toggleKeysView},
    {TouchKeyMap::L, TouchKeyMap::T, 0.02f, 0.16f, 0.14f, 0.28f, TouchScreenController::key_enterCheats},
};
/*---------------------------------------------------------------------------------------*/

// figures out the ratio between sides (such that smaller, usually y, axis size is 1)
//   then handles all of the bottom/right anchored items
static void updateTouchMap(int preferredLayout,
                           float screenWidth, float screenHeight,
                           int scaleFactor,
                           int scaleFactorDPad,
                           int scaleFactorButtons,
                           int ssSpacing)
{
    switch(preferredLayout)
    {
    case(TouchScreenController::layout_old_tiny):
        SDL_memcpy(g_touchKeyMap.touchKeysMap, c_4_tinyPhoneMap, sizeof(g_touchKeyMap.touchKeysMap));
        g_touchKeyMap.touchCanvasWidth = 640.f;
        g_touchKeyMap.touchCanvasHeight = 480.f;
        break;

    case(TouchScreenController::layout_old_average):
        SDL_memcpy(g_touchKeyMap.touchKeysMap, c_averagePhoneMap, sizeof(g_touchKeyMap.touchKeysMap));
        g_touchKeyMap.touchCanvasWidth = 1024.f;
        g_touchKeyMap.touchCanvasHeight = 600.f;
        break;

    case(TouchScreenController::layout_old_long):
        SDL_memcpy(g_touchKeyMap.touchKeysMap, c_averagePhoneLongMap, sizeof(g_touchKeyMap.touchKeysMap));
        g_touchKeyMap.touchCanvasWidth = 1396.0f;
        g_touchKeyMap.touchCanvasHeight = 720.0f;
        break;

    case(TouchScreenController::layout_old_phablet):
        SDL_memcpy(g_touchKeyMap.touchKeysMap, c_7_tablet, sizeof(g_touchKeyMap.touchKeysMap));
        g_touchKeyMap.touchCanvasWidth = 1024.f;
        g_touchKeyMap.touchCanvasHeight = 600.f;
        break;

    case(TouchScreenController::layout_old_tablet):
        SDL_memcpy(g_touchKeyMap.touchKeysMap, c_10_6_tablet, sizeof(g_touchKeyMap.touchKeysMap));
        g_touchKeyMap.touchCanvasWidth = 1300.f;
        g_touchKeyMap.touchCanvasHeight = 812.f;
        break;

    case(TouchScreenController::layout_tight):
        SDL_memcpy(g_touchKeyMap.touchKeysMap, c_tightAutoMap, sizeof(g_touchKeyMap.touchKeysMap));
        break;

    case(TouchScreenController::layout_standard):
    default:
        SDL_memcpy(g_touchKeyMap.touchKeysMap, c_standardAutoMap, sizeof(g_touchKeyMap.touchKeysMap));
        break;
    }

    // legacy layout
    if(g_touchKeyMap.touchKeysMap[TouchScreenController::key_start].x1 > 2.f)
        return;

    if(screenWidth > screenHeight)
    {
        g_touchKeyMap.touchCanvasWidth = screenWidth / screenHeight;
        g_touchKeyMap.touchCanvasHeight = 1.f;
    }
    else
    {
        g_touchKeyMap.touchCanvasWidth = 1.f;
        g_touchKeyMap.touchCanvasHeight = screenHeight / screenWidth;
    }

    for(int i = 0; i < TouchScreenController::key_END; i++)
    {
        g_touchKeyMap.touchKeysMap[i].x1 *= scaleFactor / 100.f;
        g_touchKeyMap.touchKeysMap[i].x2 *= scaleFactor / 100.f;
        g_touchKeyMap.touchKeysMap[i].y1 *= scaleFactor / 100.f;
        g_touchKeyMap.touchKeysMap[i].y2 *= scaleFactor / 100.f;

        if(i >= TouchScreenController::key_left && i <= TouchScreenController::key_downright)
        {
            g_touchKeyMap.touchKeysMap[i].x1 *= scaleFactorDPad / 100.f;
            g_touchKeyMap.touchKeysMap[i].x2 *= scaleFactorDPad / 100.f;
            g_touchKeyMap.touchKeysMap[i].y1 *= scaleFactorDPad / 100.f;
            g_touchKeyMap.touchKeysMap[i].y2 *= scaleFactorDPad / 100.f;
        }
        else if(i >= TouchScreenController::key_run && i <= TouchScreenController::key_altjump)
        {
            g_touchKeyMap.touchKeysMap[i].x1 *= scaleFactorButtons / 100.f;
            g_touchKeyMap.touchKeysMap[i].x2 *= scaleFactorButtons / 100.f;
            g_touchKeyMap.touchKeysMap[i].y1 *= scaleFactorButtons / 100.f;
            g_touchKeyMap.touchKeysMap[i].y2 *= scaleFactorButtons / 100.f;
        }

        if(g_touchKeyMap.touchKeysMap[i].xa == TouchKeyMap::R)
        {
            g_touchKeyMap.touchKeysMap[i].x1 += g_touchKeyMap.touchCanvasWidth;
            g_touchKeyMap.touchKeysMap[i].x2 += g_touchKeyMap.touchCanvasWidth;
        }
        else if(g_touchKeyMap.touchKeysMap[i].xa == TouchKeyMap::C)
        {
            g_touchKeyMap.touchKeysMap[i].x1 += g_touchKeyMap.touchCanvasWidth / 2;
            g_touchKeyMap.touchKeysMap[i].x2 += g_touchKeyMap.touchCanvasWidth / 2;
        }

        if(g_touchKeyMap.touchKeysMap[i].ya == TouchKeyMap::B)
        {
            g_touchKeyMap.touchKeysMap[i].y1 += g_touchKeyMap.touchCanvasHeight;
            g_touchKeyMap.touchKeysMap[i].y2 += g_touchKeyMap.touchCanvasHeight;
        }
        else if(g_touchKeyMap.touchKeysMap[i].ya == TouchKeyMap::C)
        {
            g_touchKeyMap.touchKeysMap[i].y1 += g_touchKeyMap.touchCanvasHeight / 2;
            g_touchKeyMap.touchKeysMap[i].y2 += g_touchKeyMap.touchCanvasHeight / 2;
        }

        // Don't let hold-run button go lower than buttons
        if(i == TouchScreenController::key_holdRun)
        {
            if(g_touchKeyMap.touchKeysMap[i].ya == TouchKeyMap::B)
            {
                float yb1 = g_touchKeyMap.touchKeysMap[TouchScreenController::key_altrun].y1;
                float yb2 = g_touchKeyMap.touchKeysMap[TouchScreenController::key_altjump].y1;
                float yb = SDL_min(yb1, yb2) - 0.05f;

                // is aligning needed?
                if(yb < g_touchKeyMap.touchKeysMap[i].y2)
                {
                    float o = g_touchKeyMap.touchKeysMap[i].y2;
                    g_touchKeyMap.touchKeysMap[i].y2 = yb;
                    g_touchKeyMap.touchKeysMap[i].y1 += (g_touchKeyMap.touchKeysMap[i].y2 - o);
                }
            }
        }
        // Compute spacing between start and select
        else if(ssSpacing != 100 && (i == TouchScreenController::key_start || i == TouchScreenController::key_drop))
        {
            if(g_touchKeyMap.touchKeysMap[i].xa == TouchKeyMap::L)
            {
                float o = g_touchKeyMap.touchKeysMap[i].x1;
                g_touchKeyMap.touchKeysMap[i].x1 *= 1.0f / (ssSpacing / 100.f);
                g_touchKeyMap.touchKeysMap[i].x2 += (g_touchKeyMap.touchKeysMap[i].x1 - o);
            }

            if(g_touchKeyMap.touchKeysMap[i].xa == TouchKeyMap::R)
            {
                float o = g_touchKeyMap.touchKeysMap[i].x2;
                float off = g_touchKeyMap.touchCanvasWidth - g_touchKeyMap.touchKeysMap[i].x2;
                off *= 1.0f / (ssSpacing / 100.f);
                g_touchKeyMap.touchKeysMap[i].x2 = g_touchKeyMap.touchCanvasWidth - off;
                g_touchKeyMap.touchKeysMap[i].x1 += (g_touchKeyMap.touchKeysMap[i].x2 - o);
            }
        }
    }
}


void TouchScreenController::doVibration()
{
    if(!m_vibrator)
        return;

    if(m_feedback_strength == 0.f)
        return;

    SDL_HapticRumblePlay(m_vibrator, m_feedback_strength, m_feedback_length);
    D_pLogDebug("TouchScreen: Vibration %g, %d ms", m_feedback_strength, m_feedback_length);
}

TouchScreenController::~TouchScreenController()
{
    if(m_vibrator)
        SDL_HapticClose(m_vibrator);

    m_vibrator = nullptr;
}

TouchScreenController::TouchScreenController() noexcept
{
    updateScreenSize();

    pLogDebug("Initialization of touch-screen controller...");

    scanTouchDevices();

    for(auto &d : m_devices)
    {
        for(int key = key_BEGIN; key < key_END; ++key)
            d.keysHeld[key] = false;
    }

    m_vibrator = nullptr;
    int numHaptics = SDL_NumHaptics();

    const std::array<const char*, 3> allowlist = {
        "VIBRATOR_SERVICE", // Android haptics device
        "spmi_haptics",     // device name on sdm845 linux
        "gpio-vibrator",    // device name on PinePhone and some Raspberry Pi-based devices
    };

    for(int i = 0; i < numHaptics; ++i)
    {
        bool is_allowed = false;
        for(const char* allowed_device : allowlist)
        {
            if(SDL_strcmp(SDL_HapticName(i), allowed_device) == 0)
            {
                is_allowed = true;
                break;
            }
        }

        if(is_allowed)
        {
            m_vibrator = SDL_HapticOpen(i);

            if(m_vibrator)
            {
                pLogDebug("TouchScreen: Opened haptics device %d [%s]", i, SDL_HapticName(i));
                SDL_HapticRumbleInit(m_vibrator);
                break;
            }
            else
                pLogWarning("TouchScreen: Can't open haptics device %d [%s]", i, SDL_HapticName(i));
        }
        else
            pLogInfo("TouchScreen: ignoring haptics device [%s]", SDL_HapticName(i));
    }
}

void TouchScreenController::scanTouchDevices()
{
    m_touchDevicesCount = SDL_GetNumTouchDevices();

    if(m_touchDevicesCount > 0)
    {
        pLogDebug("Found %d touch devices, screen size: %d x %d",
                  m_touchDevicesCount,
                  m_screenWidth, m_screenHeight);

        m_devices.clear();
        m_devices.resize(m_touchDevicesCount);

        for(int i = 0; i < m_touchDevicesCount; ++i)
        {
            auto &d = m_devices[i];
            d.id = SDL_GetTouchDevice(i);

// At the SDL2 older than 2.30.8 is a bug that valid touch device was treated as invalid on Vita. This problem had been resolved since 2.30.8.
// A similar problem appears at the 3DS on SDL2 before the 2.30.11
#if (!defined(VITA) || SDL_VERSION_ATLEAST(2, 30, 8)) && (!defined(__3DS__) || SDL_VERSION_ATLEAST(2, 30, 11))
            if(!d.id) // Invalid touch device, will be dropped from the list
            {
                d.id = -1;
                pLogDebug("Touch device %d: <Invalid device>", i);
                continue;
            }
#endif

#if SDL_VERSION_ATLEAST(2, 0, 10)
            const char *typeText = "Invalid type";
            SDL_TouchDeviceType ty = SDL_GetTouchDeviceType(d.id);

            switch(ty)
            {
            default:
            case SDL_TOUCH_DEVICE_INVALID: // invalid
                break;
            case SDL_TOUCH_DEVICE_DIRECT:
                typeText = "Direct touch type";
                break;
            case SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE:
                typeText = "Indiriect absolute type";
                break;
            case SDL_TOUCH_DEVICE_INDIRECT_RELATIVE:
                typeText = "Indiriect relative type";
                break;
            }

            pLogDebug("Touch device %d (id=%d): %s", i, (int)d.id, typeText);

            if(ty != SDL_TOUCH_DEVICE_DIRECT)
            {
                d.id = -1; // Drop any indirect devices
                continue;
            }
#endif

            SDL_memset(d.keysHeld, 0, sizeof(d.keysHeld));
        }

        // Remove unnecessary devices from the list
        for(auto it = m_devices.begin(); it != m_devices.end(); )
        {
            if(it->id == -1)
                it = m_devices.erase(it);
            else
                ++it;
        }

        // Set number of touch devices to be equal to the `m_devices`
        m_touchDevicesCount = (int)m_devices.size();
    }

    pLogDebug("Totally loaded valid touch devices: %d", (int)m_devices.size());
}

void TouchScreenController::updateScreenSize()
{
    XWindow::getWindowSize(&m_screenWidth, &m_screenHeight);
    XRender::getRenderSize(&m_renderWidth, &m_renderHeight);

    updateTouchMap(m_layout,
                   m_renderWidth, m_renderHeight,
                   m_scale_factor,
                   m_scale_factor_dpad,
                   m_scale_factor_buttons,
                   m_scale_factor_ss_spacing);
}

static void updateKeyValue(bool& key, bool state)
{
    key = state;
    D_pLogDebug("= Touch key: State=%d", (int)key);
}

static void updateFingerKeyState(TouchScreenController::FingerState& st,
                                 Controls_t& keys, int keyCommand, bool setState, TouchScreenController::ExtraKeys_t& extraSt)
{
    st.alive = (setState != 0);

    if(keyCommand >= static_cast<int>(TouchScreenController::key_BEGIN) && keyCommand < static_cast<int>(TouchScreenController::key_END))
    {
        switch(keyCommand)
        {
        case TouchScreenController::key_left:
            updateKeyValue(keys.Left, setState);
            break;

        case TouchScreenController::key_right:
            updateKeyValue(keys.Right, setState);
            break;

        case TouchScreenController::key_up:
            updateKeyValue(keys.Up, setState);
            break;

        case TouchScreenController::key_down:
            updateKeyValue(keys.Down, setState);
            break;

        case TouchScreenController::key_upleft:
            updateKeyValue(keys.Up, setState);
            updateKeyValue(keys.Left, setState);
            break;

        case TouchScreenController::key_upright:
            updateKeyValue(keys.Up, setState);
            updateKeyValue(keys.Right, setState);
            break;

        case TouchScreenController::key_downleft:
            updateKeyValue(keys.Down, setState);
            updateKeyValue(keys.Left, setState);
            break;

        case TouchScreenController::key_downright:
            updateKeyValue(keys.Down, setState);
            updateKeyValue(keys.Right, setState);
            break;

        case TouchScreenController::key_jump:
            updateKeyValue(keys.Jump, setState);
            break;

        case TouchScreenController::key_altjump:
            updateKeyValue(keys.AltJump, setState);
            break;

        case TouchScreenController::key_run:
            extraSt.keyRunOnce = (setState & !keys.Run);
            updateKeyValue(keys.Run, setState);
            break;

        case TouchScreenController::key_altrun:
            extraSt.keyAltRunOnce = (setState & !keys.AltRun);
            updateKeyValue(keys.AltRun, setState);
            break;

        case TouchScreenController::key_drop:
            updateKeyValue(keys.Drop, setState);
            break;

        case TouchScreenController::key_start:
            updateKeyValue(keys.Start, setState);
            break;

        case TouchScreenController::key_toggleKeysView:
            extraSt.keyToggleViewOnce = (setState & !extraSt.keyToggleView);
            extraSt.keyToggleView = setState;
            break;

        case TouchScreenController::key_holdRun:
            extraSt.keyHoldRunOnce = (setState & !extraSt.keyHoldRun);
            extraSt.keyHoldRun = setState;
            break;

        case TouchScreenController::key_enterCheats:
            extraSt.keyCheats = setState;
            break;

        default:
            break;
        }
    }
    else
        st.alive = false;
}

void TouchScreenController::processTouchDevice(TouchDevice_t& dev)
{
    auto& m_fingers = dev.fingers;
    auto& keysHeld = dev.keysHeld;
    auto& current_extra_keys = dev.extra_keys;
    auto& current_keys = dev.current_keys;
    int  fingers = SDL_GetNumTouchFingers(dev.id);

    for(auto& m_finger : m_fingers)
    {
        // Mark as "dead"
        m_finger.second.alive = false;
    }

    int n_real_fingers = 0;
    double total_finger_x = 0;
    double total_finger_y = 0;

    for(int i = 0; i < fingers; i++)
    {
        SDL_Finger* f = SDL_GetTouchFinger(dev.id, i);

        if(!f) //Skip a wrong finger
            continue;

        SDL_FingerID finger_id = f->id;
        float finger_x = f->x, finger_y = f->y, finger_pressure = f->pressure;
        (void)finger_pressure;

        n_real_fingers++;
        total_finger_x += finger_x;
        total_finger_y += finger_y;

        // track which finger is controlling the cursor
        if(!m_wasScrolling && (m_cursorFinger == -1 || m_cursorFinger == finger_id))
        {
            m_cursorActive = true;
            m_cursorFinger = finger_id;
            int cX, cY;
            XRender::mapToScreen(finger_x * m_screenWidth, finger_y * m_screenHeight, &cX, &cY);
            m_cursorX = cX;
            m_cursorY = cY;
        }

        auto found = m_fingers.find(finger_id);

        if(found != m_fingers.end())
        {
            FingerState& fs = found->second;
            int keysCount = g_touchKeyMap.findTouchKeys(finger_x, finger_y, fs);

            for(int key = key_BEGIN; key < key_END; ++key)
            {
                if(fs.ignore)
                    break;

                if(m_touchHidden && key != key_toggleKeysView)
                    continue;

                if(fs.heldKeyPrev[key] && !fs.heldKey[key]) // set key off
                {
                    updateFingerKeyState(fs, current_keys, key, false, current_extra_keys);
                    D_pLogDebug("= Finger Key ID=%d released (move)", static_cast<int>(key));
                    keysHeld[key] = false;
                    fs.heldKeyPrev[key] = fs.heldKey[key];
                }
                else if(fs.heldKey[key]) // set key on and keep alive
                {
                    if(!fs.heldKeyPrev[key] /*&& fs.heldKey[key]*/) // Already true because of condition from above
                        doVibration(); // Vibrate when key gets on

                    updateFingerKeyState(fs, current_keys, key, true, current_extra_keys);
                    D_pLogDebug("= Finger Key ID=%d pressed (move)", static_cast<int>(key));
                    keysHeld[key] = true;
                    fs.heldKeyPrev[key] = fs.heldKey[key];
                }
            }

            fs.alive = (keysCount > 0);
        }
        else
        {
            // Detect which key is pressed, and press it
            FingerState st;
            int keysCount = g_touchKeyMap.findTouchKeys(finger_x, finger_y, st);

            for(int key = key_BEGIN; key < key_END; key++)
            {
                if(m_touchHidden && key != key_toggleKeysView)
                    continue;

                if(st.heldKey[key]) // set key on
                {
                    updateFingerKeyState(st, current_keys, key, true, current_extra_keys);
                    D_pLogDebug("= Finger Key ID=%d pressed (put)", static_cast<int>(key));
                    doVibration();
                    keysHeld[key] = true;
                    st.heldKeyPrev[key] = st.heldKey[key];
                }
            }

            st.alive = (keysCount > 0);

            if(st.alive)
            {
                D_pLogDebug("= Finger ID=%d came", static_cast<int>(finger_id));
                m_fingers.insert({finger_id, st});
            }
        }

        D_pLogDebug("= Finger press: ID=%d, X=%.04f, Y=%.04f, P=%.04f",
                    static_cast<int>(finger_id), finger_x, finger_y, finger_pressure);
    }

    for(auto it = m_fingers.begin(); it != m_fingers.end();)
    {
        if(!it->second.alive)
        {
            for(int key = key_BEGIN; key < key_END; key++)
            {
                if(it->second.heldKey[key]) // Key was previously held
                {
                    updateFingerKeyState(it->second, current_keys, key, false, current_extra_keys);
                    D_pLogDebug("= Finger Key ID=%d released (take)", static_cast<int>(key));
                    keysHeld[key] = false;
                }
            }

            D_pLogDebug("= Finger ID=%d has gone", static_cast<int>(it->first));

            it = m_fingers.erase(it);
            continue;
        }

        ++it;
    }

    if(n_real_fingers > 1 && LevelEditor && !editorScreen.active)
    {
        int MeanX, MeanY;
        XRender::mapToScreen(total_finger_x / n_real_fingers * m_screenWidth, total_finger_y / n_real_fingers * m_screenHeight, &MeanX, &MeanY);

        if(m_wasScrolling)
        {
            m_scrollX += m_lastMeanX - MeanX;
            m_scrollY += m_lastMeanY - MeanY;
        }

        m_lastMeanX = MeanX;
        m_lastMeanY = MeanY;
        m_scrollActive = true;
    }

    // Merge per-device states into common states:
    for(int key = key_BEGIN; key < key_END; ++key)
        m_keysHeld[key] |= keysHeld[key];

    m_current_keys |= current_keys;
    m_current_extra_keys |= current_extra_keys;
}

void TouchScreenController::update()
{
    if(!touchSupported())
        return;

    if(this->m_active_method)
    {
        auto* p = dynamic_cast<InputMethodProfile_TouchScreen*>(this->m_active_method->Profile);

        if(p)
        {
            this->m_touchpad_style = p->m_touchpad_style;
            this->m_enable_enter_cheats = p->m_enable_enter_cheats;

            if(p->m_device_count <= 0)
                p->m_device_count = this->m_touchDevicesCount;

            if(this->m_feedback_strength != p->m_feedback_strength
               || this->m_feedback_length != p->m_feedback_length)
            {
                this->m_feedback_strength = p->m_feedback_strength;
                this->m_feedback_length = p->m_feedback_length;
                this->doVibration();
            }

            if(this->m_hold_run != p->m_hold_run)
            {
                this->m_hold_run = p->m_hold_run;
                this->m_runHeld = this->m_hold_run;
            }

            if(this->m_layout != p->m_layout)
            {
                this->m_layout = p->m_layout;
                this->updateScreenSize();
            }

            if(this->m_scale_factor != p->m_scale_factor)
            {
                this->m_scale_factor = p->m_scale_factor;
                this->updateScreenSize();
            }

            if(this->m_scale_factor_dpad != p->m_scale_factor_dpad)
            {
                this->m_scale_factor_dpad = p->m_scale_factor_dpad;
                this->updateScreenSize();
            }

            if(this->m_scale_factor_buttons != p->m_scale_factor_buttons)
            {
                this->m_scale_factor_buttons = p->m_scale_factor_buttons;
                this->updateScreenSize();
            }

            if(this->m_scale_factor_ss_spacing != p->m_scale_factor_ss_spacing)
            {
                this->m_scale_factor_ss_spacing = p->m_scale_factor_ss_spacing;
                this->updateScreenSize();
            }
        }
    }


    bool cursor_was_held = m_cursorActive;
    m_cursorActive = false;
    m_scrollActive = false;

    m_scrollX = 0;
    m_scrollY = 0;

    for(int key = key_BEGIN; key < key_END; ++key)
        m_keysHeld[key] = false;

    m_current_extra_keys = ExtraKeys_t();
    m_current_keys = Controls_t();

    // Process all working touch devices
    for(auto& d : m_devices)
        processTouchDevice(d);

    // handle cursor for double-tap logic
    if(!m_cursorActive && cursor_was_held)
    {
        m_lastCursorX = m_cursorX;
        m_lastCursorY = m_cursorY;
        m_cursorFinger = -1;
    }


    // handle scrolling and scroll momentum

    if(m_scrollActive && m_wasScrolling)
    {
        m_scrollMomentumX = m_lastScrollX;
        m_scrollMomentumY = m_lastScrollY;
    }

    if(m_scrollActive)
    {
        // need two counters because of an SDL bug where the frame
        // a finger it is lifted its finger still exists at its old location
        m_lastScrollX = m_scrollX;
        m_lastScrollY = m_scrollY;
    }

    m_wasScrolling = m_scrollActive;

    if(!m_scrollActive && m_scrollMomentumX != 0)
    {
        m_scrollMomentumX *= 0.97_r;
        m_scrollX += m_scrollMomentumX;
        if(m_scrollMomentumX > -0.1_n && m_scrollMomentumX < 0.1_n)
            m_scrollMomentumX = 0;
    }

    if(!m_scrollActive && m_scrollMomentumY != 0)
    {
        m_scrollMomentumY *= 0.97_r;
        m_scrollY += m_scrollMomentumY;
        if(m_scrollMomentumY > -0.1_n && m_scrollMomentumY < 0.1_n)
            m_scrollMomentumY = 0;
    }

    // handle special keys
    if(m_current_extra_keys.keyToggleViewOnce)
    {
        m_touchHidden = !m_touchHidden;

        if(!m_touchHidden)
            SharedCursor.GoOffscreen();
    }

    if(m_current_extra_keys.keyHoldRunOnce)
        m_runHeld = !m_runHeld;
}

void TouchScreenController::render(int player_no)
{
    if(!touchSupported())
        return;

    int style = m_touchpad_style;

    for(int key = key_BEGIN; key < key_END; key++)
    {
        if((m_touchHidden && key != TouchScreenController::key_toggleKeysView) || (LoadingInProcess && !ScreenAssetPack::g_LoopActive) || LevelEditor)
            continue;

        const auto& k = g_touchKeyMap.touchKeysMap[key];
        int x1 = round((k.x1 / g_touchKeyMap.touchCanvasWidth) * float(m_renderWidth));
        int y1 = round((k.y1 / g_touchKeyMap.touchCanvasHeight) * float(m_renderHeight));
        int x2 = round((k.x2 / g_touchKeyMap.touchCanvasWidth) * float(m_renderWidth));
        int y2 = round((k.y2 / g_touchKeyMap.touchCanvasHeight) * float(m_renderHeight));
        int w = x2 - x1;
        int h = y2 - y1;

        const uint8_t a = XTColor::from_num(m_keysHeld[key] ? 0.9_n : 0.3_n);

        switch(key)
        {
        case TouchScreenController::key_toggleKeysView:
            XRender::renderTextureScale(x1, y1, w, h,
                                        m_GFX.touch[m_touchHidden ? TouchScreenGFX_t::BUTTON_VIEW_TOGGLE_OFF : TouchScreenGFX_t::BUTTON_VIEW_TOGGLE_ON],
                                        XTAlpha(a));
            break;

        case TouchScreenController::key_start:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_START], XTAlpha(a));
            break;

        case TouchScreenController::key_drop:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_DROP], XTAlpha(a));
            break;

        case TouchScreenController::key_up:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_UP], XTAlpha(a));
            break;

        case TouchScreenController::key_left:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[buttonLeft(player_no, style)], XTAlpha(a));
            break;

        case TouchScreenController::key_right:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[buttonRight(player_no, style)], XTAlpha(a));
            break;

        case TouchScreenController::key_down:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_DOWN], XTAlpha(a));
            break;

        case TouchScreenController::key_upleft:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_UPLEFT], XTAlpha(a));
            break;

        case TouchScreenController::key_upright:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_UPRIGHT], XTAlpha(a));
            break;

        case TouchScreenController::key_downleft:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_DOWNLEFT], XTAlpha(a));
            break;

        case TouchScreenController::key_downright:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_DOWNRIGHT], XTAlpha(a));
            break;

        case TouchScreenController::key_holdRun:
            XRender::renderTextureScale(x1, y1, w, h,
                                        m_GFX.touch[m_runHeld ? TouchScreenGFX_t::BUTTON_HOLD_RUN_ON : TouchScreenGFX_t::BUTTON_HOLD_RUN_OFF],
                                        XTAlpha(a));
            break;

        case TouchScreenController::key_jump:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[buttonA(player_no, style)], XTAlpha(a));
            break;

        case TouchScreenController::key_run:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[buttonX(player_no, style)], XTAlpha(a));
            break;

        case TouchScreenController::key_altjump:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[buttonB(player_no, style)], XTAlpha(a));
            break;

        case TouchScreenController::key_altrun:
            XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[buttonY(player_no, style)], XTAlpha(a));
            break;

        case TouchScreenController::key_enterCheats:
            if(m_enable_enter_cheats)
                XRender::renderTextureScale(x1, y1, w, h, m_GFX.touch[TouchScreenGFX_t::BUTTON_ENTER_CHEATS], XTAlpha(a));

            break;

        default:
            XRender::renderRect(x1, y1, w, h, {255, 0, 0, 80});
            break;
        }
    }
}

void TouchScreenController::resetState()
{
    this->update();

    for(auto &d : m_devices)
    {
        for(auto& state : d.fingers)
            state.second.ignore = true;
        d.current_keys = Controls_t();
        d.extra_keys = ExtraKeys_t();
        SDL_memset(d.keysHeld, 0, sizeof(d.keysHeld));
    }

    m_current_keys = Controls_t();
    m_current_extra_keys = ExtraKeys_t();
    SDL_memset(m_keysHeld, 0, sizeof(m_keysHeld));
}

/*====================================================*\
|| implementation for InputMethod_TouchScreen         ||
\*====================================================*/

InputMethod_TouchScreen::~InputMethod_TouchScreen()
{
    InputMethodType_TouchScreen* t = dynamic_cast<InputMethodType_TouchScreen*>(this->Type);

    if(!t)
        return;

    if(t->m_controller.m_active_method == this)
        t->m_controller.m_active_method = nullptr;
}

// Update functions that set player controls (and editor controls)
// based on current device input. Return false if device lost.
bool InputMethod_TouchScreen::Update(int player, Controls_t& c, CursorControls_t& m, EditorControls_t& e, HotkeysPressed_t& h)
{
    auto* t = dynamic_cast<InputMethodType_TouchScreen*>(this->Type);

    if(!t)
        return false;

    if(!t->m_controller.touchSupported())
        return false;

    c = t->m_controller.m_current_keys;

    const TouchScreenController::ExtraKeys_t& te = t->m_controller.m_current_extra_keys;

    if(GamePaused == PauseCode::None && !GameMenu && !GameOutro && !LevelSelect && t->m_controller.m_runHeld)
    {
        // Alt Run functions as normal
        if(c.AltRun)
        {
            // make sure Alt Run activates properly
            if(te.keyAltRunOnce)
                c.AltRun = false;
            c.Run = false;
        }
        else if(te.keyRunOnce)
            c.Run = false;
        else
            c.Run |= true;
    }

    // use the touchscreen as a mouse if the buttons are currently hidden, or we are in LevelEditor mode
    bool allowed = t->m_controller.m_touchHidden || LevelEditor;

    if(allowed && t->m_controller.m_scrollActive)
    {
        m.GoOffscreen();
        m.Move = true;
    }
    else if(allowed && t->m_controller.m_cursorActive)
    {
        if(LevelEditor || MagicHand)
        {
            // hold to preview, double-tap to click in main editor screen
            if(editorScreen.active || t->m_controller.m_cursorY < 40)
            {
                m.Primary = true;
            }
            else if(t->m_controller.m_lastCursorX == -42
                || (t->m_controller.m_cursorX - t->m_controller.m_lastCursorX > -10
                && t->m_controller.m_cursorX - t->m_controller.m_lastCursorX < 10
                && t->m_controller.m_cursorY - t->m_controller.m_lastCursorY > -10
                && t->m_controller.m_cursorY - t->m_controller.m_lastCursorY < 10))
            {
                m.Primary = true;
                // special value to allow drags
                t->m_controller.m_lastCursorX = -42;
            }
        }
        else
        {
            m.Primary = true;
        }

        if(t->m_controller.m_cursorX - m.X <= -1 || t->m_controller.m_cursorX - m.X >= 1
           || t->m_controller.m_cursorY - m.Y <= -1 || t->m_controller.m_cursorY - m.Y >= 1)
        {
            m.Move = true;
            m.X = t->m_controller.m_cursorX;
            m.Y = t->m_controller.m_cursorY;
        }

        m.Touch = true;
    }

    // update editor scroll
    if(t->m_controller.m_scrollX < 0)
        e.ScrollLeft += -t->m_controller.m_scrollX;
    else if(t->m_controller.m_scrollX > 0)
        e.ScrollRight += t->m_controller.m_scrollX;
    if(t->m_controller.m_scrollY < 0)
        e.ScrollUp += -t->m_controller.m_scrollY;
    else if(t->m_controller.m_scrollY > 0)
        e.ScrollDown += t->m_controller.m_scrollY;

    if(t->m_controller.m_current_extra_keys.keyCheats && t->m_controller.m_enable_enter_cheats)
        h[Hotkeys::Buttons::EnterCheats] = player;

    // auto show/hide depending on context
    if(m_wasTextEntry && GamePaused != PauseCode::TextEntry)
    {
        t->m_controller.m_touchHidden = false;
        m_wasTextEntry = false;
    }
    else if(!m_wasTextEntry && GamePaused == PauseCode::TextEntry)
    {
        t->m_controller.m_touchHidden = true;
        m_wasTextEntry = true;
    }

    return true;
}

void InputMethod_TouchScreen::Rumble(int ms, float strength)
{
    InputMethodType_TouchScreen* t = dynamic_cast<InputMethodType_TouchScreen*>(this->Type);

    if(!t)
        return;

    if(!t->m_controller.touchSupported())
        return;

    if(!t->m_controller.m_vibrator)
        return;

    pLogDebug("Trying to use SDL haptic rumble: %dms %f", ms, strength);

    if(SDL_HapticRumblePlay(t->m_controller.m_vibrator, strength, ms) == 0)
        return;
}

StatusInfo InputMethod_TouchScreen::GetStatus()
{
    return XPower::devicePowerStatus();
}

/*====================================================*\
|| implementation for InputMethodProfile_TouchScreen  ||
\*====================================================*/

// the job of this function is to initialize the class in a consistent state
InputMethodProfile_TouchScreen::InputMethodProfile_TouchScreen()
{
    this->m_showPowerStatus = false;

#ifdef __ANDROID__
    if(s_screenSize >= 9.0) // Big tablets
    {
        m_default_layout = TouchScreenController::layout_standard;
        m_default_scale_factor = 65;
        m_default_scale_factor_dpad = 80;
        m_default_scale_factor_buttons = 105;
        m_default_scale_factor_ss_spacing = 110;
    }
    else if(s_screenSize >= 7.0) // Middle tablets
    {
        m_default_layout = TouchScreenController::layout_standard;
        m_default_scale_factor = 95;
        m_default_scale_factor_dpad = 80;
        m_default_scale_factor_buttons = 105;
        m_default_scale_factor_ss_spacing = 95;
    }
    else if(s_screenSize < 4.0) // Very small phones
    {
        m_default_layout = TouchScreenController::layout_tight;
        m_default_scale_factor = 100;
        m_default_scale_factor_dpad = 110;
        m_default_scale_factor_buttons = 135;
        m_default_scale_factor_ss_spacing = 75;
    }
    else // All other devices
    {
        // Longer screens (big ration between sides, more like a stick)
        if((s_screenWidth / s_screenHeight) > 1.6f)
        {
            m_default_layout = TouchScreenController::layout_standard;
            m_default_scale_factor = 135;
            m_default_scale_factor_dpad = 80;
            m_default_scale_factor_buttons = 100;
            m_default_scale_factor_ss_spacing = 100;
        }
        else // Shorter screens (smaller ratio between sides, more like a square)
        {
            m_default_layout = TouchScreenController::layout_standard;
            m_default_scale_factor = 135;
            m_default_scale_factor_dpad = 80;
            m_default_scale_factor_buttons = 100;
            m_default_scale_factor_ss_spacing = 90;
        }
    }
#endif
}

bool InputMethodProfile_TouchScreen::PollPrimaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

bool InputMethodProfile_TouchScreen::PollSecondaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

bool InputMethodProfile_TouchScreen::DeletePrimaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

bool InputMethodProfile_TouchScreen::DeleteSecondaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return true;
}

const char* InputMethodProfile_TouchScreen::NamePrimaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return g_controlsStrings.caseTouch.c_str();
}

const char* InputMethodProfile_TouchScreen::NameSecondaryButton(ControlsClass c, size_t i)
{
    UNUSED(c);
    UNUSED(i);
    return "";
}

void InputMethodProfile_TouchScreen::SaveConfig(IniProcessing* ctl)
{
    ctl->setValue("ui-layout", this->m_layout);
    ctl->setValue("scale-factor", this->m_scale_factor);
    ctl->setValue("scale-factor-dpad", this->m_scale_factor_dpad);
    ctl->setValue("scale-factor-buttons", this->m_scale_factor_buttons);
    ctl->setValue("scale-factor-ss-spacing", this->m_scale_factor_ss_spacing);
    ctl->setValue("ui-style", this->m_touchpad_style);
    ctl->setValue("vibration-strength", this->m_feedback_strength);
    ctl->setValue("vibration-length", this->m_feedback_length);
    ctl->setValue("hold-run", this->m_hold_run);
    ctl->setValue("enable-enter-cheats", this->m_enable_enter_cheats);
}

void InputMethodProfile_TouchScreen::LoadConfig(IniProcessing* ctl)
{
    ctl->read("ui-layout", this->m_layout, this->m_default_layout);

    if(this->m_layout >= TouchScreenController::layout_END)
        this->m_layout = this->m_default_layout;

    ctl->read("scale-factor", this->m_scale_factor, this->m_default_scale_factor);
    ctl->read("scale-factor-dpad", this->m_scale_factor_dpad, this->m_default_scale_factor_dpad);
    ctl->read("scale-factor-buttons", this->m_scale_factor_buttons, this->m_default_scale_factor_buttons);
    ctl->read("scale-factor-ss-spacing", this->m_scale_factor_ss_spacing, this->m_default_scale_factor_ss_spacing);
    ctl->read("ui-style", this->m_touchpad_style, TouchScreenController::style_actions);
    ctl->read("vibration-strength", this->m_feedback_strength, 0.f);
    ctl->read("vibration-length", this->m_feedback_length, 12);
    ctl->read("hold-run", this->m_hold_run, false);
    ctl->read("enable-enter-cheats", this->m_enable_enter_cheats, false);
}

// How many per-type special options are there?
size_t InputMethodProfile_TouchScreen::GetOptionCount_Custom()
{
    return Options::COUNT;
}

// Methods to manage per-profile options
// It is guaranteed that none of these will be called if
// GetOptionCount_Custom() returns 0.
// get a char* describing the option
const char* InputMethodProfile_TouchScreen::GetOptionName_Custom(size_t i)
{
    switch(i)
    {
    case Options::layout:
        return g_controlsStrings.touchscreenOptionLayoutStyle.c_str();

    case Options::scale_factor:
        return g_controlsStrings.touchscreenOptionScaleFactor.c_str();

    case Options::scale_factor_dpad:
        return g_controlsStrings.touchscreenOptionScaleDPad.c_str();

    case Options::scale_factor_buttons:
        return g_controlsStrings.touchscreenOptionScaleButtons.c_str();

    case Options::scale_factor_ss_spacing:
        return g_controlsStrings.touchscreenOptionSStartSpacing.c_str();

    case Options::reset_layout:
        return g_controlsStrings.touchscreenOptionResetLayout.c_str();

    case Options::style:
        return g_controlsStrings.touchscreenOptionInterfaceStyle.c_str();

    case Options::fb_strength:
        return g_controlsStrings.touchscreenOptionFeedbackStrength.c_str();

    case Options::fb_length:
        return g_controlsStrings.touchscreenOptionFeedbackLength.c_str();

    case Options::hold_run:
        return g_controlsStrings.touchscreenOptionHoldRun.c_str();

    case Options::enable_enter_cheats:
        return g_controlsStrings.touchscreenOptionShowCodeButton.c_str();
    }

    return nullptr;
}

// get a char* describing the current option value
// must be allocated in static or instance memory
// WILL NOT be freed
const char* InputMethodProfile_TouchScreen::GetOptionValue_Custom(size_t i)
{
    static char length_buf[8];
    static std::string delay_buf;

    switch(i)
    {
    case Options::layout:
        if(this->m_layout == TouchScreenController::layout_tight)
            return g_controlsStrings.touchscreenLayoutTight.c_str();
        else if(this->m_layout == TouchScreenController::layout_old_tiny)
            return g_controlsStrings.touchscreenLayoutTinyOld.c_str();
        else if(this->m_layout == TouchScreenController::layout_old_average)
            return g_controlsStrings.touchscreenLayoutPhoneOld.c_str();
        else if(this->m_layout == TouchScreenController::layout_old_long)
            return g_controlsStrings.touchscreenLayoutLongOld.c_str();
        else if(this->m_layout == TouchScreenController::layout_old_phablet)
            return g_controlsStrings.touchscreenLayoutPhabletOld.c_str();
        else if(this->m_layout == TouchScreenController::layout_old_tablet)
            return g_controlsStrings.touchscreenLayoutTabletOld.c_str();
        else
            return g_controlsStrings.touchscreenLayoutStandard.c_str();

    case Options::scale_factor:
        SDL_snprintf(length_buf, 8, "%d%%", this->m_scale_factor);
        return length_buf;

    case Options::scale_factor_dpad:
        SDL_snprintf(length_buf, 8, "%d%%", this->m_scale_factor_dpad);
        return length_buf;

    case Options::scale_factor_buttons:
        SDL_snprintf(length_buf, 8, "%d%%", this->m_scale_factor_buttons);
        return length_buf;

    case Options::scale_factor_ss_spacing:
        SDL_snprintf(length_buf, 8, "%d%%", this->m_scale_factor_ss_spacing);
        return length_buf;

    case Options::style:
        if(this->m_touchpad_style == TouchScreenController::style_actions)
            return g_controlsStrings.touchscreenStyleActions.c_str();
        else if(this->m_touchpad_style == TouchScreenController::style_abxy)
            return g_controlsStrings.touchscreenStyleABXY.c_str();
        else
            return g_controlsStrings.touchscreenStyleXODA.c_str();

    case Options::fb_strength:
        if(this->m_feedback_strength == 0.f)
            return g_mainMenu.wordOff.c_str();
        else if(this->m_feedback_strength == 0.25f)
            return "25%";
        else if(this->m_feedback_strength == 0.50f)
            return "50%";
        else if(this->m_feedback_strength == 0.75f)
            return "75%";
        else
            return "100%";

    case Options::fb_length:
        delay_buf = std::to_string(this->m_feedback_length);
        delay_buf += " ";
        delay_buf += g_mainMenu.abbrevMilliseconds;
        return delay_buf.c_str();

    case Options::hold_run:
        if(this->m_hold_run)
            return g_mainMenu.wordOn.c_str();
        else
            return g_mainMenu.wordOff.c_str();

    case Options::enable_enter_cheats:
        if(this->m_enable_enter_cheats)
            return g_mainMenu.wordOn.c_str();
        else
            return g_mainMenu.wordOff.c_str();
    }

    return nullptr;
}

// called when A is pressed; allowed to interrupt main game loop
bool InputMethodProfile_TouchScreen::OptionChange_Custom(size_t i)
{
    switch(i)
    {
    case Options::reset_layout:
        this->m_layout = this->m_default_layout;
        this->m_scale_factor = this->m_default_scale_factor;
        this->m_scale_factor_dpad = this->m_default_scale_factor_dpad;
        this->m_scale_factor_buttons = this->m_default_scale_factor_buttons;
        this->m_scale_factor_ss_spacing = this->m_default_scale_factor_ss_spacing;
        return true;

    default:
        return this->OptionRotateRight_Custom(i);
    }
}

// called when left is pressed
bool InputMethodProfile_TouchScreen::OptionRotateLeft_Custom(size_t i)
{
    switch(i)
    {
    case Options::layout:
        if(this->m_layout > 0)
            this->m_layout--;
        else
            this->m_layout = TouchScreenController::layout_END - 1;

        return true;

    case Options::scale_factor:
        if(this->m_scale_factor > 50)
        {
            this->m_scale_factor -= 5;
            return true;
        }
        else
            return false;

    case Options::scale_factor_dpad:
        if(this->m_scale_factor_dpad > 50)
        {
            this->m_scale_factor_dpad -= 5;
            return true;
        }
        else
            return false;

    case Options::scale_factor_buttons:
        if(this->m_scale_factor_buttons > 50)
        {
            this->m_scale_factor_buttons -= 5;
            return true;
        }
        else
            return false;

    case Options::scale_factor_ss_spacing:
        if(this->m_scale_factor_ss_spacing > 20)
        {
            this->m_scale_factor_ss_spacing -= 5;
            return true;
        }
        else
            return false;

    case Options::style:
        if(this->m_touchpad_style > 0)
            this->m_touchpad_style--;
        else
            this->m_touchpad_style = TouchScreenController::style_END - 1;

        return true;

    case Options::fb_strength:
        if(this->m_feedback_strength > 0.f)
        {
            this->m_feedback_strength -= 0.25f;
            return true;
        }

        return false;

    case Options::fb_length:
        if(this->m_feedback_length > 2)
        {
            this->m_feedback_length -= 2;
            return true;
        }

        return false;

    case Options::hold_run:
        this->m_hold_run = !this->m_hold_run;
        return true;

    case Options::enable_enter_cheats:
        this->m_enable_enter_cheats = !this->m_enable_enter_cheats;
        return true;
    }

    return false;
}

// called when right is pressed
bool InputMethodProfile_TouchScreen::OptionRotateRight_Custom(size_t i)
{
    switch(i)
    {
    case Options::layout:
        this->m_layout++;

        if(this->m_layout >= TouchScreenController::layout_END)
            this->m_layout = 0;

        return true;

    case Options::scale_factor:
        if(this->m_scale_factor < 150)
        {
            this->m_scale_factor += 5;
            return true;
        }
        else
            return false;

    case Options::scale_factor_dpad:
        if(this->m_scale_factor_dpad < 150)
        {
            this->m_scale_factor_dpad += 5;
            return true;
        }
        else
            return false;

    case Options::scale_factor_buttons:
        if(this->m_scale_factor_buttons < 150)
        {
            this->m_scale_factor_buttons += 5;
            return true;
        }
        else
            return false;

    case Options::scale_factor_ss_spacing:
        if(this->m_scale_factor_ss_spacing < 110)
        {
            this->m_scale_factor_ss_spacing += 5;
            return true;
        }
        else
            return false;

    case Options::style:
        this->m_touchpad_style ++;

        if(this->m_touchpad_style >= TouchScreenController::style_END)
            this->m_touchpad_style = 0;

        return true;

    case Options::fb_strength:
        if(this->m_feedback_strength < 1.f)
        {
            this->m_feedback_strength += 0.25f;
            return true;
        }

        return false;

    case Options::fb_length:
        this->m_feedback_length += 2;
        return true;

    case Options::hold_run:
        this->m_hold_run = !this->m_hold_run;
        return true;

    case Options::enable_enter_cheats:
        this->m_enable_enter_cheats = !this->m_enable_enter_cheats;
        return true;
    }

    return false;
}

/*====================================================*\
|| implementation for InputMethodType_TouchScreen     ||
\*====================================================*/

InputMethodProfile* InputMethodType_TouchScreen::AllocateProfile() noexcept
{
    return (InputMethodProfile*) new(std::nothrow) InputMethodProfile_TouchScreen;
}

InputMethodType_TouchScreen::InputMethodType_TouchScreen()
{
    this->Name = "Touchscreen";
}

const std::string& InputMethodType_TouchScreen::LocalName() const
{
    return g_controlsStrings.nameTouchscreen;
}

bool InputMethodType_TouchScreen::TestProfileType(InputMethodProfile* profile)
{
    return (bool)dynamic_cast<InputMethodProfile_TouchScreen*>(profile);
}

bool InputMethodType_TouchScreen::RumbleSupported()
{
    return true;
}

bool InputMethodType_TouchScreen::ConsumeEvent(const SDL_Event* ev)
{
    // update the touch devices count as needed
    if(ev->type == SDL_FINGERDOWN && !this->m_controller.touchSupported())
        this->m_controller.scanTouchDevices();

    return false;
}

void InputMethodType_TouchScreen::UpdateControlsPre()
{
    this->m_controller.update();
}

void InputMethodType_TouchScreen::UpdateControlsPost()
{
    bool method_exists = false;

    for(InputMethod* m : g_InputMethods)
    {
        if(m)
        {
            method_exists = true;
            break;
        }
    }

    // deactivate the touchscreen rendering when there is no longer an active touchscreen,
    //   but some other input method exists (ie, not the transition between menu and player add)
    if(method_exists && this->m_controller.m_active_method == nullptr && g_renderTouchscreen)
        g_renderTouchscreen = false;
}

InputMethod* InputMethodType_TouchScreen::Poll(const std::vector<InputMethod*>& active_methods) noexcept
{
    int n_touchscreens = 0;

    for(InputMethod* method : active_methods)
    {
        if(!method)
            continue;

        InputMethod_TouchScreen* m = dynamic_cast<InputMethod_TouchScreen*>(method);

        if(m)
            n_touchscreens ++;
    }

    if(n_touchscreens > 0)
    {
        this->m_canPoll = false;
        return nullptr;
    }

    if(!this->m_controller.touchSupported())
    {
        this->m_canPoll = false;
        return nullptr;
    }

    // if didn't find any touch, allow poll in future but return nullptr
    if(!this->m_controller.touchOn())
    {
        this->m_canPoll = true;
        return nullptr;
    }

    // if poll not allowed, return false
    if(!this->m_canPoll)
        return nullptr;

    // we're going to create a touchscreen method!
    // reset canPoll for next time
    this->m_canPoll = false;

    InputMethod_TouchScreen* method = new(std::nothrow) InputMethod_TouchScreen;

    if(!method)
        return nullptr;

    if(!g_renderTouchscreen)
    {
        this->m_controller.resetState();
        SharedCursor.GoOffscreen();
    }

    method->Name = this->LocalName();
    method->Type = this;

    this->m_controller.m_active_method = method;
    g_renderTouchscreen = true;

    return (InputMethod*)method;
}

TouchScreenController::ExtraKeys_t& TouchScreenController::ExtraKeys_t::operator|=(const ExtraKeys_t& o)
{
    keyToggleView |= o.keyToggleView;
    keyToggleViewOnce |= o.keyToggleViewOnce;

    keyHoldRun |= o.keyHoldRun;
    keyHoldRunOnce |= o.keyHoldRunOnce;

    keyRunOnce |= o.keyRunOnce;
    keyAltRunOnce |= o.keyAltRunOnce;

    keyCheats |= o.keyCheats;

    return *this;
}

} // namespace Controls


================================================
FILE: src/control/touchscreen.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef TOUCHSCREEN_H
#define TOUCHSCREEN_H

#include <map>
#include <string>
#include <vector>

#include <SDL2/SDL_touch.h>

#include "../controls.h"
#include "../std_picture.h"

typedef struct _SDL_Haptic SDL_Haptic;

namespace Controls
{


// forward declaration for the TouchScreenController
class InputMethod_TouchScreen;

/*!
 * \brief A basic class including graphics for touchscreen controller
 */

class TouchScreenGFX_t
{
    void loadImage(StdPicture &img, const std::string &fileName);
    std::string m_gfxPath;
    int m_loadErrors = 0;

    void loadAll();

public:
    bool m_success = false;

    TouchScreenGFX_t();

    //! (re)load the touchscreen graphics from the current asset pack
    void load();

    enum
    {
        BUTTON_START = 0,
        BUTTON_LEFT,
        BUTTON_LEFT_CHAR,
        BUTTON_RIGHT,
        BUTTON_RIGHT_CHAR,
        BUTTON_UP,
        BUTTON_DOWN,
        BUTTON_UPLEFT,
        BUTTON_UPRIGHT,
        BUTTON_DOWNLEFT,
        BUTTON_DOWNRIGHT,
        BUTTON_A,
        BUTTON_A_PS,
        BUTTON_A_BLANK,
        BUTTON_A_DO,
        BUTTON_A_ENTER,
        BUTTON_A_JUMP,
        BUTTON_B,
        BUTTON_B_PS,
        BUTTON_B_BLANK,
        BUTTON_B_JUMP,
        BUTTON_B_SPINJUMP,
        BUTTON_X,
        BUTTON_X_PS,
        BUTTON_X_BACK,
        BUTTON_X_BLANK,
        BUTTON_X_BOMB,
        BUTTON_X_BUMERANG,
        BUTTON_X_FIRE,
        BUTTON_X_HAMMER,
        BUTTON_X_RUN,
        BUTTON_X_SWORD,
        BUTTON_Y,
        BUTTON_Y_PS,
        BUTTON_Y_BLANK,
        BUTTON_Y_BOMB,
        BUTTON_Y_BUMERANG,
        BUTTON_Y_FIRE,
        BUTTON_Y_HAMMER,
        BUTTON_Y_RUN,
        BUTTON_Y_STATUE,
        BUTTON_Y_SWORD,
        BUTTON_DROP,
        BUTTON_HOLD_RUN_OFF,
        BUTTON_HOLD_RUN_ON,
        BUTTON_VIEW_TOGGLE_OFF,
        BUTTON_VIEW_TOGGLE_ON,
        BUTTON_ANALOG_BORDER,
        BUTTON_ANALOG_STICK,
        BUTTON_ENTER_CHEATS,
        BUTTONS_END
    };
    StdPicture touch[BUTTONS_END];
};

/*!
 * \brief A mobile touch-screen controller which reads state of the keyboard device
 */
class TouchScreenController
{
    //! Count of touch devices
    int m_touchDevicesCount = 0;
    //! Physical screen width (touchscreen coords)
    int m_screenWidth = 0;
    //! Physical screen height (touchscreen coords)
    int m_screenHeight = 0;
    //! Physical screen width (render coords)
    int m_renderWidth = 0;
    //! Physical screen height (render coords)
    int m_renderHeight = 0;
    //! Graphics for controller
    TouchScreenGFX_t m_GFX;

public:
    //! Vibrator used with the touch device as rumble and/or feedback
    SDL_Haptic *m_vibrator = nullptr;

    /*!
     * \brief Is touch-screen supported?
     */
    bool touchSupported();

    /*!
     * \brief Number of detected touchscreen devices
     * \return Count of devices detected
     */
    int numDevices() const;

    /*!
     * \brief Is touch-screen being touched?
     */
    bool touchOn();

    enum commands
    {
        key_BEGIN = 0,
        key_start = 0,
        key_left,
        key_right,
        key_up,
        key_down,
        key_upleft,
        key_upright,
        key_downleft,
        key_downright,
        key_run,
        key_jump,
        key_altrun,
        key_altjump,
        key_drop,
        key_holdRun,
        key_toggleKeysView,
        key_enterCheats,
        key_END
    };

    enum styles
    {
        style_actions = 0,
        style_abxy,
        style_xoda,
        style_END
    };

    enum layouts
    {
        layout_standard = 0,
        layout_tight,
        layout_old_tiny,
        layout_old_average,
        layout_old_long,
        layout_old_phablet,
        layout_old_tablet,
        layout_END
    };

    // touchscreen settings (duplicated from InputMethodProfile_TouchScreen)
    //! Current layout type
    int m_layout = TouchScreenController::layout_standard;
    //! General scale factor
    int m_scale_factor = 100;
    //! D-Pad exclusive scale factor
    int m_scale_factor_dpad = 100;
    //! Buttons scale factor
    int m_scale_factor_buttons = 100;
    //! Spacing between Select and Start
    int m_scale_factor_ss_spacing = 100;
    //! Current touchpad style
    int m_touchpad_style = TouchScreenController::style_actions;
    //! Feedback strength
    float m_feedback_strength = 0.f;
    //! Feedback length in milliseconds
    int m_feedback_length = 12;
    //! Hold run enabled
    bool m_hold_run = false;
    //! Show the enter cheats button
    bool m_enable_enter_cheats = false;

    // active InputMethod (nullable, used for configuration)
    InputMethod *m_active_method = nullptr;

    //! In-game controls pressed
    Controls_t m_current_keys;
    bool m_keysHeld[key_END] = {false};

    bool m_cursorActive = false;
    SDL_FingerID m_cursorFinger = -1;
    int m_cursorX = 0, m_cursorY = 0;
    int m_lastCursorX = -32;
    int m_lastCursorY = -32;

    bool m_scrollActive = false;
    bool m_wasScrolling = false;
    int m_lastMeanX = 0, m_lastMeanY = 0;
    num_t m_scrollX = 0, m_scrollY = 0;
    // needed because of an SDL bug where the frame a finger it is lifted its finger still exists at its old location
    num_t m_lastScrollX = 0, m_lastScrollY = 0;
    num_t m_scrollMomentumX = 0, m_scrollMomentumY = 0;

    struct ExtraKeys_t
    {
        bool keyToggleView = false;
        bool keyToggleViewOnce = false;

        bool keyHoldRun = false;
        bool keyHoldRunOnce = false;

        bool keyRunOnce = false;
        bool keyAltRunOnce = false;

        bool keyCheats = false;

        ExtraKeys_t &operator|=(const ExtraKeys_t& o);
    } m_current_extra_keys;

    //! Touch can be hidden by left-top corner to use virtual mouse
    bool       m_touchHidden = false;
    bool       m_runHeld = false;

    struct FingerState
    {
        bool alive = false;
        bool ignore = false;
        bool heldKey[key_END] = {};
        bool heldKeyPrev[key_END] = {};

        FingerState();
        FingerState(const FingerState &fs);
        FingerState &operator=(const FingerState &fs);
    };

private:
    typedef std::map<SDL_FingerID, FingerState> FingersMap;

    struct TouchDevice_t
    {
        //! Touch device ID
        SDL_TouchID id = -1;
        //! Registered finger states
        FingersMap  fingers;
        //! States for control keys
        Controls_t current_keys;
        //! States for extra keys
        ExtraKeys_t extra_keys;
        //! Held finger states
        bool keysHeld[key_END] = {false};
    };

    std::vector<TouchDevice_t> m_devices;

    void doVibration();

    /*!
     * \brief Read current state of touch controller
     */
    void processTouchDevice(TouchDevice_t &dev);

public:
    /*!
     * \brief Constructor
     */
    TouchScreenController() noexcept;

    /*!
     * \brief Destructor
     */
    ~TouchScreenController();

    void scanTouchDevices();

    void updateScreenSize();

    void update();

    void render(int player_no);

    void resetState();

    inline void loadGFX()
    {
        m_GFX.load();
    }
};

class InputMethod_TouchScreen : public InputMethod
{
    bool m_wasTextEntry = false;

public:
    using InputMethod::Type;
    using InputMethod::Profile;

    ~InputMethod_TouchScreen();

    // Update functions that set player controls (and editor controls)
    // based on current device input. Return false if device lost.
    bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h);

    void Rumble(int ms, float strength);

    StatusInfo GetStatus();
};

class InputMethodProfile_TouchScreen : public InputMethodProfile
{
public:
    using InputMethodProfile::Name;
    using InputMethodProfile::Type;

    // touchscreen settings
    /* Screen-size depend defaults (computed on load) */
    int m_default_layout = TouchScreenController::layout_standard;
    int m_default_scale_factor = 100;
    int m_default_scale_factor_dpad = 100;
    int m_default_scale_factor_buttons = 100;
    int m_default_scale_factor_ss_spacing = 100;

    /* Current settings */
    //! Current layout type
    int m_layout = TouchScreenController::layout_standard;
    //! General scale factor
    int m_scale_factor = 100;
    //! D-Pad exclusive scale factor
    int m_scale_factor_dpad = 100;
    //! Buttons scale factor
    int m_scale_factor_buttons = 100;
    //! Spacing between Select and Start
    int m_scale_factor_ss_spacing = 100;
    //! Current touchpad style
    int m_touchpad_style = TouchScreenController::style_actions;
    float m_feedback_strength = 0.f;
    int m_feedback_length = 12;
    bool m_hold_run = false;
    bool m_enable_enter_cheats = false;
    //! Count of touch devices, gets filled on initialization
    int m_device_count = 0;

    InputMethodProfile_TouchScreen();

    // Polls a new (secondary) device button for the i'th player button
    // Returns true on success and false if no button pressed
    // Never allows two player buttons to bind to the same device button
    bool PollPrimaryButton(ControlsClass c, size_t i);
    bool PollSecondaryButton(ControlsClass c, size_t i);

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    bool DeletePrimaryButton(ControlsClass c, size_t i);

    // Deletes a secondary device button for the i'th button of class c
    bool DeleteSecondaryButton(ControlsClass c, size_t i);

    // Gets strings for the device buttons currently used for the i'th button of class c
    const char *NamePrimaryButton(ControlsClass c, size_t i);
    const char *NameSecondaryButton(ControlsClass c, size_t i);

    // one can assume that the IniProcessing* is already in the correct group
    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
    struct Options
    {
        enum o
        {
            layout,
            scale_factor,
            scale_factor_dpad,
            scale_factor_buttons,
            scale_factor_ss_spacing,
            reset_layout,
            style,
            fb_strength,
            fb_length,
            hold_run,
            enable_enter_cheats,
            COUNT
        };
    };

public:
    // How many per-type special options are there?
    size_t GetOptionCount_Custom();
    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount_Custom() returns 0.
    // get a char* describing the option
    const char *GetOptionName_Custom(size_t i);
    // get a char* describing the current option value
    // must be allocated in static or instance memory
    // WILL NOT be freed
    const char *GetOptionValue_Custom(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange_Custom(size_t i);
    // called when left is pressed
    bool OptionRotateLeft_Custom(size_t i);
    // called when right is pressed
    bool OptionRotateRight_Custom(size_t i);
};

class InputMethodType_TouchScreen : public InputMethodType
{
private:
    bool m_canPoll = false;

    InputMethodProfile *AllocateProfile() noexcept override;

public:
    using InputMethodType::Name;
    using InputMethodType::m_profiles;

    TouchScreenController m_controller;

    InputMethodType_TouchScreen();

    const std::string& LocalName() const override;

    bool TestProfileType(InputMethodProfile *profile) override;
    bool RumbleSupported() override;
    bool ConsumeEvent(const SDL_Event *ev) override;

    void UpdateControlsPre() override;
    void UpdateControlsPost() override;

    // null if no input method is ready
    // allocates the new InputMethod on the heap
    InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept override;
};

} // namespace Controls

#endif // TOUCHSCREEN_H


================================================
FILE: src/control/touchscreen.txt
================================================
{542.0f, 537.0f, 693.0f,  587.0f, TouchScreenController::key_start},
{1.0f, 410.0f, 83.0f,  492.0f, TouchScreenController::key_left},
{165.0f, 410.0f, 247.0f,  492.0f, TouchScreenController::key_right},
{83.0f, 328.0f, 165.0f,  410.0f, TouchScreenController::key_up},
{83.0f, 492.0f, 165.0f,  574.0f, TouchScreenController::key_down},
{1.0f, 328.0f, 83.0f,  410.0f, TouchScreenController::key_upleft},
{165.0f, 328.0f, 247.0f,  410.0f, TouchScreenController::key_upright},
{1.0f, 492.0f, 83.0f,  574.0f, TouchScreenController::key_downleft},
{165.0f, 492.0f, 247.0f,  574.0f, TouchScreenController::key_downright},
{770.0f, 396.0f, 877.0f,  487.0f, TouchScreenController::key_run},
{888.0f, 431.0f, 995.0f,  522.0f, TouchScreenController::key_jump},
{780.0f, 290.0f, 887.0f,  381.0f, TouchScreenController::key_altrun},
{898.0f, 325.0f, 1005.0f,  416.0f, TouchScreenController::key_altjump},
{331.0f, 537.0f, 482.0f,  587.0f, TouchScreenController::key_drop},
{807.0f, 150.0f, 914.0f,  180.0f, TouchScreenController::key_holdRun},
{10.0f, 10.0f, 70.0f,  70.0f, TouchScreenController::key_toggleKeysView},


================================================
FILE: src/control_types.h
================================================
#ifndef CONTROL_TYPES_H

#define CONTROL_TYPES_H

#include "numeric_types.h"

// Controls for the player
struct Controls_t
{
    bool Up = false;
    bool Down = false;
    bool Left = false;
    bool Right = false;
    bool Jump = false;
    bool AltJump = false;
    bool Run = false;
    bool AltRun = false;
    bool Drop = false;
    bool Start = false;
};

// For controls hard-coded into devices,
// like escape key on keyboard and back key on Android
struct SharedControls_t
{
    bool Pause = false;
    bool LegacyPause = false; // modifier, only set if Pause is also set
    bool ForcePause = false; // modifier, only set by the enter cheats hotkey to allow pausing at certain times
    bool QuitCredits = false;
    bool MenuUp = false;
    bool MenuDown = false;
    bool MenuLeft = false;
    bool MenuRight = false;
    bool MenuDo = false;
    bool MenuBack = false;
};

// Control struct combined from shared controls and individual player controls, based on player controls' requested layout
struct MenuControls_t
{
    bool Up = false;
    bool Down = false;
    bool Left = false;
    bool Right = false;
    bool Do = false;
    bool Back = false;
    bool Erase = false;
    bool Home = false;
};

// Each player has one; there is also a shared fallback mouse
struct CursorControls_t
{
    // using direct touch device; affects rendering
    bool Touch = false;
    // moved this frame
    bool Move = false;
    // position of cursor in screen coordinates
    num_t X = -4000.0_n;
    num_t Y = -4000.0_n;
    // "left button" down
    bool Primary = false;
    // "right button" down
    bool Secondary = false;
    // "middle button" down
    bool Tertiary = false;
    // scroll up / down
    bool ScrollUp = false;
    bool ScrollDown = false;

    // call to easily send cursor offscreen (on disconnect, etc)
    inline void GoOffscreen()
    {
        X = -4000.0_n;
        Y = -4000.0_n;
        Move = true;
    }
};

// Controls for the editor
struct EditorControls_t
{
    num_t ScrollUp = 0.0_n;
    num_t ScrollDown = 0.0_n;
    num_t ScrollLeft = 0.0_n;
    num_t ScrollRight = 0.0_n;

    bool FastScroll = false;

    bool ModeSelect = false;
    bool ModeErase = false;

    bool NextSection = false;
    bool PrevSection = false;

    bool SwitchScreens = false;
    bool TestPlay = false;
};

#endif // #ifndef CONTROL_TYPES_H


================================================
FILE: src/controls.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CONTROLS_H
#define CONTROLS_H

// forward declaration since some clients do not have SDL
typedef union SDL_Event SDL_Event;

#include <string>
#include <array>
#include <vector>

#include <IniProcessor/ini_processing.h>

#include "sdl_proxy/sdl_types.h"
#include "sdl_proxy/sdl_assert.h"

#include "globals.h"
#include "core/power.h"

extern Controls_t &operator|=(Controls_t &o1, const Controls_t &o2);

namespace Controls
{

using XPower::StatusInfo;

class InputMethod;
class InputMethodProfile;
class InputMethodType;

enum class ControlsClass
{
    None, Player, Cursor, Editor, Hotkey
};

// utility functions to access information from the Controls_t struct
namespace PlayerControls
{
// These attributes should be used by Input Methods and the game when possible
// to allow them to function even if the controls structures change.

// enumerate of the Player key indices (which are almost never used)
enum Buttons : size_t
{
    Up = 0, Down, Left, Right, Jump, AltJump, Run, AltRun, Drop, Start, MAX
};

static constexpr size_t n_buttons = Buttons::MAX;

inline const char *GetButtonName_INI(size_t i)
{
    switch(i)
    {
    case Buttons::Up:
        return "up";
    case Buttons::Down:
        return "down";
    case Buttons::Left:
        return "left";
    case Buttons::Right:
        return "right";
    case Buttons::Jump:
        return "jump";
    case Buttons::AltJump:
        return "altjump";
    case Buttons::Run:
        return "run";
    case Buttons::AltRun:
        return "altrun";
    case Buttons::Drop:
        return "drop";
    case Buttons::Start:
        return "start";
    default:
        return "NULL";
    }
}

inline const char *GetButtonName_UI_Init(size_t i)
{
    switch(i)
    {
    case Buttons::Up:
        return "Up";
    case Buttons::Down:
        return "Down";
    case Buttons::Left:
        return "Left";
    case Buttons::Right:
        return "Right";
    case Buttons::Jump:
        return "Jump";
    case Buttons::AltJump:
        return "Alt Jump";
    case Buttons::Run:
        return "Run";
    case Buttons::AltRun:
        return "Alt Run";
    case Buttons::Drop:
        return "Drop Item";
    case Buttons::Start:
        return "Start";
    default:
        return "NULL";
    }
}

extern std::array<std::string, Buttons::MAX> g_button_name_UI;

inline const char *GetButtonName_UI(size_t i)
{
    if(i < Buttons::MAX)
        return g_button_name_UI[i].c_str();

    return "NULL";
}

// convenience function for accessing a button index
inline bool &GetButton(Controls_t &c, size_t i)
{
    switch(i)
    {
    case Buttons::Up:
        return c.Up;
    case Buttons::Down:
        return c.Down;
    case Buttons::Left:
        return c.Left;
    case Buttons::Right:
        return c.Right;
    case Buttons::Jump:
        return c.Jump;
    case Buttons::AltJump:
        return c.AltJump;
    case Buttons::Run:
        return c.Run;
    case Buttons::AltRun:
        return c.AltRun;
    case Buttons::Drop:
        return c.Drop;
    case Buttons::Start:
        return c.Start;
    default:
        SDL_assert(false); // -V654 // Made especially to fail on abnormal value
        return c.Start;
    }
}

inline bool GetButton(const Controls_t &c, size_t i)
{
    return GetButton(const_cast<Controls_t&>(c), i);
}

} // namespace (Controls::)PlayerControls

// utility functions to access information from the CursorControls_t struct
// note that CursorX and CursorY are analogue and do not directly correspond with
// the virtual buttons CursorUp, CursorDown, CursorLeft, and CursorRight
namespace CursorControls
{
// These attributes should be used by Input Methods and the game when possible
// to allow them to function even if the controls structures change.

// enumerate of the Cursor key indices (which are almost never used)
enum Buttons : size_t
{
    CursorUp = 0, CursorDown, CursorLeft, CursorRight, Primary,
    Secondary, Tertiary, MAX
};

static constexpr size_t n_buttons = Buttons::MAX;


inline const char *GetButtonName_INI(size_t i)
{
    switch(i)
    {
    case Buttons::CursorUp:
        return "cursor-up";
    case Buttons::CursorDown:
        return "cursor-down";
    case Buttons::CursorLeft:
        return "cursor-left";
    case Buttons::CursorRight:
        return "cursor-right";
    case Buttons::Primary:
        return "primary";
    case Buttons::Secondary:
        return "secondary";
    case Buttons::Tertiary:
        return "tertiary";
    default:
        return "NULL";
    }
}

inline const char *GetButtonName_UI_Init(size_t i)
{
    switch(i)
    {
    case Buttons::CursorUp:
        return "Mouse Up";
    case Buttons::CursorDown:
        return "Mouse Down";
    case Buttons::CursorLeft:
        return "Mouse Left";
    case Buttons::CursorRight:
        return "Mouse Right";
    case Buttons::Primary:
        return "Primary";
    case Buttons::Secondary:
        return "Secondary";
    case Buttons::Tertiary:
        return "Tertiary";
    default:
        return "NULL";
    }
}

extern std::array<std::string, Buttons::MAX> g_button_name_UI;

inline const char *GetButtonName_UI(size_t i)
{
    if(i < Buttons::MAX)
        return g_button_name_UI[i].c_str();

    return "NULL";
}

// convenience function for accessing a button index
inline bool &GetButton(CursorControls_t &c, size_t i)
{
    switch(i)
    {
    case Buttons::Primary:
        return c.Primary;
    case Buttons::Secondary:
        return c.Secondary;
    case Buttons::Tertiary:
        return c.Tertiary;
    case Buttons::CursorUp:
    case Buttons::CursorDown:
    case Buttons::CursorLeft:
    case Buttons::CursorRight:
    default:
        SDL_assert(false); // -V654 // Made especially to fail on abnormal value
        return c.Primary;
    }
}
} // namespace (Controls::)CursorControls

// utility functions to access information from the EditorControls_t struct
// note that ScrollUp, ScrollDown, ScrollLeft, and ScrollRight are analogue and are set separately
namespace EditorControls
{
// These attributes should be used by Input Methods and the game when possible
// to allow them to function even if the controls structures change.

// enumerate of the Editor key indices (which are almost never used)
enum Buttons : size_t
{
    ScrollUp = 0, ScrollDown, ScrollLeft, ScrollRight, FastScroll,
    ModeSelect, ModeErase, PrevSection, NextSection, SwitchScreens, TestPlay, MAX
};

static constexpr size_t n_buttons = Buttons::MAX;

inline const char *GetButtonName_INI(size_t i)
{
    switch(i)
    {
    case Buttons::ScrollUp:
        return "scroll-up";
    case Buttons::ScrollDown:
        return "scroll-down";
    case Buttons::ScrollLeft:
        return "scroll-left";
    case Buttons::ScrollRight:
        return "scroll-right";
    case Buttons::FastScroll:
        return "fast-scroll";
    case Buttons::ModeSelect:
        return "mode-select";
    case Buttons::ModeErase:
        return "mode-erase";
    case Buttons::PrevSection:
        return "prev-section";
    case Buttons::NextSection:
        return "next-section";
    case Buttons::SwitchScreens:
        return "switch-screens";
    case Buttons::TestPlay:
        return "test-play";
    default:
        return "NULL";
    }
}

inline const char *GetButtonName_UI_Init(size_t i)
{
    switch(i)
    {
    case Buttons::ScrollUp:
        return "Scrl Up";
    case Buttons::ScrollDown:
        return "Scrl Down";
    case Buttons::ScrollLeft:
        return "Scrl Left";
    case Buttons::ScrollRight:
        return "Scrl Right";
    case Buttons::FastScroll:
        return "Fast Scrl";
    case Buttons::ModeSelect:
        return "Mode Select";
    case Buttons::ModeErase:
        return "Mode Erase";
    case Buttons::PrevSection:
        return "Prev Sect";
    case Buttons::NextSection:
        return "Next Sect";
    case Buttons::SwitchScreens:
        return "Show Pane";
    case Buttons::TestPlay:
        return "Test Play";
    default:
        return "NULL";
    }
}

extern std::array<std::string, Buttons::MAX> g_button_name_UI;

inline const char *GetButtonName_UI(size_t i)
{
    if(i < Buttons::MAX)
        return g_button_name_UI[i].c_str();

    return "NULL";
}

// convenience function for accessing a button index
inline bool &GetButton(EditorControls_t &c, size_t i)
{
    switch(i)
    {
    case Buttons::FastScroll:
        return c.FastScroll;
    case Buttons::ModeSelect:
        return c.ModeSelect;
    case Buttons::ModeErase:
        return c.ModeErase;
    case Buttons::PrevSection:
        return c.PrevSection;
    case Buttons::NextSection:
        return c.NextSection;
    case Buttons::SwitchScreens:
        return c.SwitchScreens;
    case Buttons::TestPlay:
        return c.TestPlay;
    case Buttons::ScrollUp:
    case Buttons::ScrollDown:
    case Buttons::ScrollLeft:
    case Buttons::ScrollRight:
    default:
        SDL_assert(false); // -V654 // Made especially to fail on abnormal value
        return c.FastScroll;
    }
}
} // namespace (Controls::)EditorControls

// utility functions to handle hotkeys. can accommodate new hotkeys.
namespace Hotkeys
{
// These attributes should be used by Input Methods and the game when possible
// to allow them to function even when hotkeys change / are added.

// enumerate of the Hotkey indices (which are almost never used)
enum Buttons : size_t
{
#ifndef RENDER_FULLSCREEN_ALWAYS
    Fullscreen,
#endif
#ifdef USE_SCREENSHOTS_AND_RECS
    Screenshot,
#endif
#ifdef PGE_ENABLE_VIDEO_REC
    RecordGif,
#endif
    VanillaCam,
    DebugInfo, EnterCheats,
    ToggleHUD, LegacyPause,
#ifdef DEBUG_BUILD
    ReloadLanguage,
#endif
    MAX
};

constexpr size_t n_buttons = Buttons::MAX;

inline const char *GetButtonName_INI(size_t i)
{
    switch(i)
    {
#ifndef RENDER_FULLSCREEN_ALWAYS
    case Buttons::Fullscreen:
        return "fullscreen";
#endif
#ifdef USE_SCREENSHOTS_AND_RECS
    case Buttons::Screenshot:
        return "screenshot";
#endif
#ifdef PGE_ENABLE_VIDEO_REC
    case Buttons::RecordGif:
        return "record-gif";
#endif
    case Buttons::VanillaCam:
        return "vanilla-cam";
    case Buttons::DebugInfo:
        return "debug-info";
    case Buttons::EnterCheats:
        return "enter-cheats";
    case Buttons::ToggleHUD:
        return "toggle-hud";
    case Buttons::LegacyPause:
        return "legacy-pause";
#ifdef DEBUG_BUILD
    case Buttons::ReloadLanguage:
        return "reload-language";
#endif
    default:
        return "NULL";
    }
}

inline const char *GetButtonName_UI_Init(size_t i)
{
    switch(i)
    {
#ifndef RENDER_FULLSCREEN_ALWAYS
    case Buttons::Fullscreen:
        return "Fullscreen";
#endif
#ifdef USE_SCREENSHOTS_AND_RECS
    case Buttons::Screenshot:
        return "Screenshot";
#endif
#ifdef PGE_ENABLE_VIDEO_REC
    case Buttons::RecordGif:
        return "Record GIF";
#endif
    case Buttons::DebugInfo:
        return "Debug Info";
    case Buttons::VanillaCam:
        return "Vanilla Cam";
    case Buttons::EnterCheats:
        return "Enter Code";
    case Buttons::ToggleHUD:
        return "Toggle HUD";
    case Buttons::LegacyPause:
        return "Old Pause";
#ifdef DEBUG_BUILD
    case Buttons::ReloadLanguage:
        return "Reload lang";
#endif
    default:
        return "NULL";
    }
}

extern std::array<std::string, Buttons::MAX> g_button_name_UI;

inline const char *GetButtonName_UI(size_t i)
{
    if(i < Buttons::MAX)
        return g_button_name_UI[i].c_str();

    return "NULL";
}

// function for activating a hotkey
void Activate(size_t i, int player = 0);
} // namespace (Controls::)Hotkeys

using HotkeysPressed_t = std::array<int, Hotkeys::n_buttons>;

// represents a particular bound input method
class InputMethod
{
public:
    // not required to be unique
    std::string Name;

    // Once an InputMethod has been returned by PollInputMethod,
    //     the developer may trust that neither of these are null.
    // The InputMethodType is responsible for setting Type to itself.
    InputMethodType *Type = nullptr;
    // PollInputMethod is responsible for setting Profile;
    //     but the game may later change it depending on user interaction.
    InputMethodProfile *Profile = nullptr;

    // true if it's been explicitly used by any player since being added
    bool used_for_player = false;

    virtual ~InputMethod();

    // Update function that sets player controls, cursor controls, and editor controls,
    // as well as optionally processing hotkeys, based on current device input.
    // Remember that hotkeys should only process once per hotkey press, so it may be easier
    // to put them in ConsumeEvent.
    // Return false if device lost.
    virtual bool Update(int player, Controls_t &c, CursorControls_t &m, EditorControls_t &e, HotkeysPressed_t &h) = 0;

    virtual void Rumble(int ms, float strength) = 0;

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/

    // Used for battery, latency, etc
    // If the char* member is dynamically generated, you MUST use an instance-owned buffer
    // This will NOT be freed
    // returning a null pointer is allowed
    virtual StatusInfo GetStatus();

    // Optional function allowing developer to consume an SDL event (on SDL clients)
    //     usually used for hotkeys or for connect/disconnect events.
    // Called (1) in order of InputMethodTypes, then (2) in order of InputMethods
    // Returns true if event is consumed, false if other InputMethodTypes and InputMethods
    //     should receive it.
    virtual bool ConsumeEvent(const SDL_Event *ev);
};

// represents an input method profile for a particular input class
// some input method classes (keyboard) might disallow multiple
//   players using the same input profile, others (gamepad)
//   might disallow them using the same hardware device
class InputMethodProfile
{
public:
    // strongly encouraged to be unique, but nothing will break if it isn't
    std::string Name;

    // The InputMethodType that creates an InputMethodProfile
    // is responsible for setting Type to itself.
    InputMethodType *Type = nullptr;

    virtual ~InputMethodProfile();

    /*----------------------*\
    || SHARED CONFIGURATION ||
    \*----------------------*/

    struct CommonOptions
    {
        enum co
        {
            rumble = 0,
            show_power_status,
            alt_menu_controls,
            COUNT
        };
    };

    bool m_rumbleEnabled = false;
    bool m_showPowerStatus = false;
    bool m_altMenuControls = false;

    // assume that the IniProcessing* is already in the correct group
    // saves/loads the shared options and calls the device-specific Save/LoadConfig
    void SaveConfig_All(IniProcessing *ctl);
    void LoadConfig_All(IniProcessing *ctl);

    // each of these delegate to the _Custom methods.
    // How many per-profile special options are there?
    size_t GetOptionCount();

    // Methods to manage per-profile options
    // get a nullable char* describing the option
    const char *GetOptionName(size_t i);
    // get a nullable char* describing the current option value
    // must be allocated in static or instance memory
    const char *GetOptionValue(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    bool OptionChange(size_t i);
    // called when left is pressed
    bool OptionRotateLeft(size_t i);
    // called when right is pressed
    bool OptionRotateRight(size_t i);

    /*-------------------------*\
    || PURE VIRTUAL FUNCTIONS  ||
    \*-------------------------*/
    // Polls a new primary/secondary device button for the i'th button of class c
    // Returns true on success and false if no button currently pressed
    // Never allows two player buttons to bind to the same device button
    // Expected to use ALL of the devices available to the InputMethodType
    virtual bool PollPrimaryButton(ControlsClass c, size_t i) = 0;
    virtual bool PollSecondaryButton(ControlsClass c, size_t i) = 0;

    // Deletes a primary button for the i'th button of class c (only called for non-Player buttons)
    virtual bool DeletePrimaryButton(ControlsClass c, size_t i) = 0;

    // Deletes a secondary device button for the i'th button of class c
    virtual bool DeleteSecondaryButton(ControlsClass c, size_t i) = 0;

    // Gets strings for the device buttons currently used for the i'th button of class c
    virtual const char *NamePrimaryButton(ControlsClass c, size_t i) = 0;
    virtual const char *NameSecondaryButton(ControlsClass c, size_t i) = 0;

    // assume that the IniProcessing* is already in the correct group
    // saves/loads the controls and the device-specific options
    virtual void SaveConfig(IniProcessing *ctl) = 0;
    virtual void LoadConfig(IniProcessing *ctl) = 0;

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
    // How many device-specific per-profile special options are there?
    virtual size_t GetOptionCount_Custom();

    // Methods to manage device-specific per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount_Custom() returns 0.
    // get a nullable char* describing the option
    virtual const char *GetOptionName_Custom(size_t i);
    // get a nullable char* describing the current option value
    // must be allocated in static or instance memory
    virtual const char *GetOptionValue_Custom(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    virtual bool OptionChange_Custom(size_t i);
    // called when left is pressed
    virtual bool OptionRotateLeft_Custom(size_t i);
    // called when right is pressed
    virtual bool OptionRotateRight_Custom(size_t i);
};

// represents a class of input devices, such as keyboard, SDL gamepad,
//   or 3DS input. one of each class is instantiated in Controls::Init()
class InputMethodType
{
protected:
    // OWNED by InputMethodType
    std::vector<InputMethodProfile *> m_profiles;
    // nullable
    InputMethodProfile *m_defaultProfiles[maxLocalPlayers] = {nullptr};

    /*-------------------------*\
    || PURE VIRTUAL FUNCTION   ||
    \*-------------------------*/
    // function that must be declared per-type because each
    //     InputMethodType has its own InputMethodProfile class.
    virtual InputMethodProfile *AllocateProfile() noexcept = 0;

public:
    // absolutely required to be unique, because it is used to identify configuration. DO NOT LOCALIZE.
    std::string Name;
    // not required to be defined, refers to original "player-X-keyboard", etc, configurations.
    std::string LegacyName;

    // InputMethodType frees its InputMethodProfiles in its destructor
    virtual ~InputMethodType();

    // returns localized name based on translations, possibly to name individual methods and profiles
    virtual const std::string& LocalName() const;

    std::vector<InputMethodProfile *> GetProfiles();
    // returns a pointer to the new profile on success
    InputMethodProfile *AddProfile();
    // ensures that the profile is not in use by any active methods, and that it is not a default profile.
    // returns false if this would delete the last remaining profile, and any are in use.
    bool DeleteProfile(InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods);
    // succeeds and returns true if no profiles are in use.
    // otherwise, leaves one profile allocated.
    bool ClearProfiles(const std::vector<InputMethod *> &active_methods);

protected:
    void SetDefaultProfile(int player_no, InputMethodProfile *profile);
public:
    InputMethodProfile *GetDefaultProfile(int player_no);
    bool SetProfile(InputMethod *method, int player_no, InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods);

    void SaveConfig(IniProcessing *ctl);
    void LoadConfig(IniProcessing *ctl);

    /*-------------------------*\
    || PURE VIRTUAL FUNCTIONS  ||
    \*-------------------------*/
    // Tests whether a profile is of the corresponding type using RTTI
    virtual bool TestProfileType(InputMethodProfile *profile) = 0;

    // Returns true if Rumble is ever supported
    virtual bool RumbleSupported() = 0;

    // Returns true if Power Status is ever supported
    virtual bool PowerStatusSupported()
    {
        return false;
    }

    // Hooks that are called before and after Player controls are updated
    // Update any information that the InputMethods will reference
    virtual void UpdateControlsPre() = 0;
    // Do post-update calls to global methods,
    //     emergency sets of the menu controls, etc.
    // This is where shared controls should be modified.
    virtual void UpdateControlsPost() = 0;

    // null if no new input method is ready
    // allocates the new InputMethod on the heap
    // do not activate any methods using controllers or keysets that are already in active_methods
    // must set the InputMethod's Name, and set its Type to the InputMethod Type
    // may optionally set the InputMethod's Profile
    virtual InputMethod *Poll(const std::vector<InputMethod *> &active_methods) noexcept = 0;

    /*-----------------------*\
    || OPTIONAL METHODS      ||
    \*-----------------------*/
public:
    // Optional function allowing developer to consume an SDL event (on SDL clients)
    //     usually used for hotkeys or for connect/disconnect events.
    // Called (1) in order of InputMethodTypes, then (2) in order of InputMethods
    // Returns true if event is consumed, false if other InputMethodTypes and InputMethods
    //     should receive it.
    virtual bool ConsumeEvent(const SDL_Event *ev);

protected:
    // optional function allowing developer to associate device information with profile, etc
    // if developer wants to forbid assignment, return false
    virtual bool SetProfile_Custom(InputMethod *method, int player_no, InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods);
    // unregisters any references to the profile before final deallocation
    // returns false to prevent deletion if this is impossible
    virtual bool DeleteProfile_Custom(InputMethodProfile *profile, const std::vector<InputMethod *> &active_methods);

public:
    // How many per-type special options are there?
    virtual size_t GetOptionCount();

    // Methods to manage per-profile options
    // It is guaranteed that none of these will be called if
    // GetOptionCount() returns 0.
    // get a (nullable) char* describing the option
    virtual const char *GetOptionName(size_t i);
    // get a (nullable) char* describing the current option value
    // if not null, must be allocated in static or instance memory
    // WILL NOT be freed
    virtual const char *GetOptionValue(size_t i);
    // called when A is pressed; allowed to interrupt main game loop
    virtual bool OptionChange(size_t i);
    // called when left is pressed
    virtual bool OptionRotateLeft(size_t i);
    // called when right is pressed
    virtual bool OptionRotateRight(size_t i);

protected:
    virtual void SaveConfig_Custom(IniProcessing *ctl);
    virtual void LoadConfig_Custom(IniProcessing *ctl);
};

// initialize the strings for localization (normally called by Init())
void InitStrings();

// allocate InputMethodTypes according to system configuration
void Init();

// free all InputMethodTypes, InputMethodProfiles (implicitly), and InputMethods
void Quit();

// (for SDL clients) process SDL_Event using active InputMethodTypes
// return true if successfully processed, false if unrecognized
bool ProcessEvent(const SDL_Event *ev);

// 1. Calls the UpdateControlsPre hooks of currently active InputMethodTypes
//    a. Syncs hardware state as needed
// 2. Updates Player and Editor controls by calling currently bound InputMethods
//    a. May call or set changeScreen, frmMain.toggleGifRecorder, TakeScreen, g_stats.enabled, etc
// 3. Calls the UpdateControlsPost hooks of currently active InputMethodTypes
//    a. May call or set changeScreen, frmMain.toggleGifRecorder, TakeScreen, g_stats.enabled, etc
//    b. If GameMenu or GameOutro is set, may update controls or Menu variables using hardcoded keys
// 4. Updates speedrun and recording modules
// 5. Resolves inconsistent control states (Left+Right, etc)
//
// If `check_lost_devices` is set and any of the devices were lost, removes the corresponding input method and returns false.
bool Update(bool check_lost_devices = true);

void SaveConfig(IniProcessing *ctl);
void LoadConfig(IniProcessing *ctl);
void SaveConfig();
void LoadConfig();

// null if no input method is ready and being pressed
// allocates the new InputMethod on the heap
InputMethod *PollInputMethod() noexcept;
void DeleteInputMethod(InputMethod *method);
void DeleteInputMethodSlot(int slot);
bool SetInputMethodProfile(int slot, InputMethodProfile *profile);
bool SetInputMethodProfile(InputMethod *method, InputMethodProfile *profile);
void ClearInputMethods();
void RemoveNullInputMethods();

// Resolve current menu controls
MenuControls_t GetMenuControls(int limit_player = 0);

// player is 1-indexed as an actual player here
void Rumble(int player, int ms, float strength);
void RumbleAllPlayers(int ms, float strength);

// player is 0-indexed as an input method here
StatusInfo GetStatus(int l_player_i);

void RenderTouchControls();
void UpdateTouchScreenSize();
void LoadTouchScreenGFX();

// global variables at bottom

// a nulled pointer in here signifies a player whose controller has disconnected
extern std::vector<InputMethod *> g_InputMethods;
// no nulled pointers here
extern std::vector<InputMethodType *> g_InputMethodTypes;
extern bool g_renderTouchscreen;
extern HotkeysPressed_t g_hotkeysPressed;
extern bool g_disallowHotkeys;

// FIXME: this should become read-only and be renamed LocalControls, and there should be a separate NetControls (indexed by player) that occurs post XMessage, used by the speedrun controls display.
// raw controls values for the current locally-connected players, with no processing. may be publicly accessed only for menu logic
extern std::array<Controls_t, maxLocalPlayers> g_RawControls;

} // namespace Controls

#endif // CONTROLS_H


================================================
FILE: src/custom.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "global_dirs.h"
#include "load_gfx.h"

#include "sdl_proxy/sdl_stdinc.h"

#include "custom.h"
#include "config.h"
#include "npc_traits.h"
#include "npc_id.h"
#include "blk_id.h"

#include <utility>

#include <IniProcessor/ini_processing.h>
#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <Utils/dir_list_ci.h>
#include <PGE_File_Formats/file_formats.h>
#include <fmt_format_ne.h>


static struct PlayerBackup
{
    struct FramePos
    {
        int8_t x;
        int8_t y;
    } p[maxPlayerFrames + 1];

    struct Calibration
    {
        vbint_t w;
        vbint_t h;
        vbint_t h_duck;
        vbint_t grubX;
        vbint_t grubY;
    } c[numStates];
} s_playerFramesBackup[numCharacters];

typedef RangeArrI<int8_t, 0, maxPlayerFrames, 0> PlayerOffsetArray;

static PlayerOffsetArray *s_playerFrameX[numCharacters + 1] = {
    nullptr, &MarioFrameX, &LuigiFrameX, &PeachFrameX, &ToadFrameX, &LinkFrameX
};
static PlayerOffsetArray *s_playerFrameY[numCharacters + 1] = {
    nullptr, &MarioFrameY, &LuigiFrameY, &PeachFrameY, &ToadFrameY, &LinkFrameY
};

const char *s_playerFileName[] = {nullptr, "mario", "luigi", "peach", "toad", "link"};


static struct NPCDefaults_t
{
    RangeArr<NPCTraits_t, 0, maxNPCType> NPCTraits;
//End Type
} s_NPCDefaults;


void LoadCustomNPC(int A, std::string cFileName);
void LoadCustomPlayer(int character, int state, std::string cFileName);


void SavePlayerDefaults()
{
    pLogDebug("Saving Player defaults...");

    DirListCI PlayerDir;
    std::string PlayerPathRes;

    // Load global customization configs first
    for(int C = 1; C <= numCharacters; ++C)
    {
        PlayerDir.setCurDir(AppPath + "graphics/" + s_playerFileName[C]);

        for(int S = 1; S <= numStates; ++S)
        {
            // Global override of player setup
            PlayerPathRes = PlayerDir.resolveFileCaseExistsAbs(fmt::sprintf_ne("%s-%d.ini", s_playerFileName[C], S));
            if(!PlayerPathRes.empty())
                LoadCustomPlayer(C, S, PlayerPathRes);
        }
    }

    // Then, backup all parameters
    for(int p = 1; p <= numCharacters; ++p)
    {
        auto &pb = s_playerFramesBackup[p - 1];
        for(int j = 0; j <= maxPlayerFrames; ++j)
        {
            pb.p[j].x = (*s_playerFrameX[p])[j];
            pb.p[j].y = (*s_playerFrameY[p])[j];
        }

        for(int j = 1; j <= numStates; ++j)
        {
            pb.c[j - 1].w = Physics.PlayerWidth[p][j];
            pb.c[j - 1].h = Physics.PlayerHeight[p][j];
            pb.c[j - 1].h_duck = Physics.PlayerDuckHeight[p][j];
            pb.c[j - 1].grubX = Physics.PlayerGrabSpotX[p][j];
            pb.c[j - 1].grubY = Physics.PlayerGrabSpotY[p][j];
        }
    }
}

void LoadPlayerDefaults()
{
    pLogDebug("Restoring Player defaults...");

    for(int p = 1; p <= numCharacters; ++p)
    {
        auto &pb = s_playerFramesBackup[p - 1];
        for(int j = 0; j <= maxPlayerFrames; ++j)
        {
            (*s_playerFrameX[p])[j] = pb.p[j].x;
            (*s_playerFrameY[p])[j] = pb.p[j].y;
        }

        for(int j = 1; j <= numStates; ++j)
        {
            Physics.PlayerWidth[p][j] = pb.c[j - 1].w;
            Physics.PlayerHeight[p][j] = pb.c[j - 1].h;
            Physics.PlayerDuckHeight[p][j] = pb.c[j - 1].h_duck;
            Physics.PlayerGrabSpotX[p][j] = pb.c[j - 1].grubX;
            Physics.PlayerGrabSpotY[p][j] = pb.c[j - 1].grubY;
        }
    }
}

/**
 * @brief Applies bug-fixes to default settings of NPC objects according to compatibility settings
 */
SDL_FORCE_INLINE void loadNpcSetupFixes()
{
    // TODO: Implement settings fixing logic here!
    if(g_config.custom_powerup_collect_score)
    {
        NPCTraits[9].Score = 6; // Set Default Scores for PowerUps (6=1000)
        NPCTraits[184].Score = 6; // Mushrooms
        NPCTraits[185].Score = 6;
        NPCTraits[249].Score = 6;
        NPCTraits[250].Score = 6;
        NPCTraits[14].Score = 6; // Fire Flowers
        NPCTraits[182].Score = 6;
        NPCTraits[183].Score = 6;
        NPCTraits[34].Score = 6; // Leaf
        NPCTraits[169].Score = 6; // Tanooki
        NPCTraits[170].Score = 6; // Hammer Suit
        NPCTraits[264].Score = 6; // Ice Flowers
        NPCTraits[277].Score = 6;
    }
}

void SaveNPCDefaults()
{
    DirListCI NPCDir = DirListCI(AppPath + "graphics/npc/");
    std::string npcPathRes;

    for(int A = 1; A <= maxNPCType; A++)
    {
        // Global override of NPC setup
        npcPathRes = NPCDir.resolveFileCaseExistsAbs(fmt::sprintf_ne("npc-%d.txt", A));

        if(!npcPathRes.empty())
            LoadCustomNPC(A, npcPathRes);

        s_NPCDefaults.NPCTraits[A] = NPCTraits[A];
    }
}

void LoadNPCDefaults()
{
    int A = 0;
    for(A = 1; A <= maxNPCType; A++)
        NPCTraits[A] = s_NPCDefaults.NPCTraits[A];

    BlockWidth[BLKID_CONVEYOR_L_CONV] = 32;
    BlockWidth[BLKID_CONVEYOR_R_CONV] = 32;
    BlockHeight[BLKID_CONVEYOR_L_CONV] = 32;
    BlockHeight[BLKID_CONVEYOR_R_CONV] = 32;

    loadNpcSetupFixes();
}

void FindCustomPlayers(const char* preview_players_from)
{
    pLogDebug("Trying to load custom Player configs...");

    std::string playerPath, playerPathC;

    if(preview_players_from)
        g_dirEpisode.setCurDir(preview_players_from);
    else
    {
        g_dirEpisode.setCurDir(FileNamePath);
        g_dirCustom.setCurDir(FileNamePath + FileName);
    }

    for(int C = 1; C <= numCharacters; ++C)
    {
        for(int S = 1; S <= numStates; ++S)
        {
            const auto pFile = fmt::sprintf_ne("%s-%d.ini", s_playerFileName[C], S);
            // Episode-wide custom player setup
            playerPath = g_dirEpisode.resolveFileCaseExistsAbs(pFile);

            // Level-wide custom player setup
            if(!preview_players_from)
                playerPathC = g_dirCustom.resolveFileCaseExistsAbs(pFile);

            if(!playerPath.empty())
                LoadCustomPlayer(C, S, playerPath);
            if(!playerPathC.empty())
                LoadCustomPlayer(C, S, playerPathC);
        }
    }
}

static inline int convIndexCoorToSpriteIndex(short x, short y)
{
    return (y + 10 * x) - 49;
}

void LoadCustomPlayer(int character, int state, std::string cFileName)
{
    pLogDebug("Loading %s...", cFileName.c_str());

    IniProcessing hitBoxFile = Files::load_ini(cFileName);
    if(!hitBoxFile.isOpened())
    {
        pLogWarning("Can't open the player calibration file: %s", cFileName.c_str());
        return;
    }

    const short UNDEFINED = 0x7FFF;
    short width = UNDEFINED;
    short height = UNDEFINED;
    short height_duck = UNDEFINED;
    short grab_offset_x = UNDEFINED;
    short grab_offset_y = UNDEFINED;
    bool isUsed = true;
    short offsetX = UNDEFINED;
    short offsetY = UNDEFINED;

    hitBoxFile.beginGroup("common");
    //normal
    hitBoxFile.read("width", width, UNDEFINED);
    hitBoxFile.read("height", height, UNDEFINED);
    //duck
    hitBoxFile.read("height-duck", height_duck, UNDEFINED);

    //grab offsets
    hitBoxFile.read("grab-offset-x", grab_offset_x, UNDEFINED);
    hitBoxFile.read("grab-offset-y", grab_offset_y, UNDEFINED);

    hitBoxFile.endGroup();

    for(int x = 0; x < 10; x++)
    {
        for(int y = 0; y < 10; y++)
        {
            isUsed = true;
            offsetX = UNDEFINED;
            offsetY = UNDEFINED;

            std::string tFrame = fmt::format("frame-{0}-{1}", x, y);

            if(!hitBoxFile.contains(tFrame))
                continue; // Skip not existing frame

            hitBoxFile.beginGroup(tFrame);
            hitBoxFile.read("used", isUsed, true);
            if(isUsed) //--> skip this frame
            {
                //Offset relative to
                hitBoxFile.read("offsetX", offsetX, UNDEFINED);
                hitBoxFile.read("offsetY", offsetY, UNDEFINED);
                if(offsetX != UNDEFINED && offsetY != UNDEFINED)
                {
                    (*s_playerFrameX[character])[convIndexCoorToSpriteIndex(x, y) + state * 100] = -offsetX;
                    (*s_playerFrameY[character])[convIndexCoorToSpriteIndex(x, y) + state * 100] = -offsetY;
                }
            }
            hitBoxFile.endGroup();
        }
    }

    if(width != UNDEFINED)
        Physics.PlayerWidth[character][state] = width;
    if(height != UNDEFINED)
        Physics.PlayerHeight[character][state] = height;
    if(height_duck != UNDEFINED)
        Physics.PlayerDuckHeight[character][state] = height_duck;
    if(grab_offset_x != UNDEFINED)
        Physics.PlayerGrabSpotX[character][state] = grab_offset_x;
    if(grab_offset_y != UNDEFINED)
        Physics.PlayerGrabSpotY[character][state] = grab_offset_y;
}

void FindCustomNPCs(/*std::string cFilePath*/)
{
    pLogDebug("Trying to load custom NPC configs...");

    //const std::string GfxRoot = AppPath + "graphics/";
    std::string /*npcPathG,*/ npcPath, npcPathC;
    // DirMan searchDir(FileNamePath);
//    std::set<std::string> existingFiles;
//    std::vector<std::string> files;
//    searchDir.getListOfFiles(files, {".txt"});
//    for(auto &p : files)
//        existingFiles.insert(FileNamePath + p);

    g_dirEpisode.setCurDir(FileNamePath);
    g_dirCustom.setCurDir(FileNamePath + FileName);

//    if(DirMan::exists(FileNamePath + FileName))
//    {
//        DirMan searchDataDir(FileNamePath + FileName);
//        searchDataDir.getListOfFiles(files, {".png", ".gif"});
//        for(auto &p : files)
//            existingFiles.insert(FileNamePath + FileName  + "/"+ p);
//    }

    for(int A = 1; A <= maxNPCType; ++A)
    {
        const auto nFile = fmt::sprintf_ne("npc-%d.txt", A);
        // Episode-wide custom NPC setup
        npcPath = g_dirEpisode.resolveFileCaseExistsAbs(nFile);
        // Level-wide custom NPC setup
        npcPathC = g_dirCustom.resolveFileCaseExistsAbs(nFile);

        if(!npcPath.empty())
            LoadCustomNPC(A, npcPath);
        if(!npcPathC.empty())
            LoadCustomNPC(A, npcPathC);
    }
}

void LoadCustomNPC(int A, std::string cFileName)
{
    NPCConfigFile npc;
    SDL_RWops* rwops = Files::open_file(cFileName, "r");
    PGE_FileFormats_misc::RWopsTextInput in(rwops, std::move(cFileName));
    FileFormats::ReadNpcTXTFile(in, npc, true);

    auto& traits = NPCTraits[A];

    if(npc.en_gfxoffsetx)
        traits.FrameOffsetX = npc.gfxoffsetx;
    if(npc.en_gfxoffsety)
        traits.FrameOffsetY = npc.gfxoffsety;
    if(npc.en_width)
        traits.TWidth = int(npc.width);
    if(npc.en_height)
        traits.THeight = int(npc.height);
    if(npc.en_gfxwidth)
        traits.WidthGFX = int(npc.gfxwidth);
    if(npc.en_gfxheight)
        traits.HeightGFX = int(npc.gfxheight);
    if(npc.en_score)
        traits.Score = int(npc.score);
    if(npc.en_playerblock)
        traits.MovesPlayer = npc.playerblock;
    if(npc.en_playerblocktop)
        traits.CanWalkOn = npc.playerblocktop;
    if(npc.en_npcblock)
        traits.IsABlock = npc.npcblock;
    if(npc.en_npcblocktop)
        traits.IsAHit1Block = npc.npcblocktop;
    if(npc.en_grabside)
        traits.IsGrabbable = npc.grabside;
    if(npc.en_grabtop)
        traits.GrabFromTop = npc.grabtop;
    if(npc.en_jumphurt)
        traits.JumpHurt = npc.jumphurt;
    if(npc.en_nohurt)
        traits.WontHurt = npc.nohurt;
    if(npc.en_noblockcollision)
        traits.NoClipping = npc.noblockcollision;
    if(npc.en_cliffturn)
        traits.TurnsAtCliffs = npc.cliffturn;
    if(npc.en_noyoshi)
        traits.NoYoshi = npc.noyoshi;
    if(npc.en_foreground)
        traits.Foreground = npc.foreground;
    if(npc.en_speed)
        traits.Speedvar = (numf_t)num_t::from_double((float)npc.speed);
    if(npc.en_nofireball)
        traits.NoFireBall = npc.nofireball;
    if(npc.en_noiceball)
        traits.NoIceBall = npc.noiceball;
    if(npc.en_nogravity)
        traits.NoGravity = npc.nogravity;
    if(npc.en_frames)
        traits.TFrames = int(npc.frames);
    if(npc.en_framespeed)
        traits.FrameSpeed = int(npc.framespeed);
    if(npc.en_framestyle)
        traits.FrameStyle = int(npc.framestyle);
    if(npc.en_usedefaultcam)
        traits.UseDefaultCam = npc.usedefaultcam;

    if(A == NPCID_CONVEYOR)
    {
        BlockWidth[BLKID_CONVEYOR_L_CONV] = traits.TWidth;
        BlockWidth[BLKID_CONVEYOR_R_CONV] = traits.TWidth;

        BlockHeight[BLKID_CONVEYOR_L_CONV] = traits.THeight;
        BlockHeight[BLKID_CONVEYOR_R_CONV] = traits.THeight;
    }
}

void LoadCustomPlayerPreviews(const char* preview_players_from)
{
    FindCustomPlayers(preview_players_from);
    LoadCustomGFX(false, preview_players_from);
}

void UnloadCustomPlayerPreviews()
{
    LoadPlayerDefaults();
    UnloadPlayerPreviewGFX();
}


================================================
FILE: src/custom.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CUSTOM_H
#define CUSTOM_H

#include <string>


void SavePlayerDefaults();
void LoadPlayerDefaults();

// Public Sub SaveNPCDefaults()
void SaveNPCDefaults();

// Public Sub LoadNPCDefaults()
void LoadNPCDefaults();


void FindCustomPlayers(const char* preview_players_from = nullptr);
// Public Sub FindCustomNPCs(Optional cFilePath As String = "")
//void FindCustomNPCs(std::string cFilePath = "");
void FindCustomNPCs();

// Private Sub LoadCustomNPC(A As Integer, cFileName As String)

// public-facing functions used by the main menu to load and unload previews of the custom players
void LoadCustomPlayerPreviews(const char* preview_players_from);
void UnloadCustomPlayerPreviews();

#endif // CUSTOM_H


================================================
FILE: src/draw_planes.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef DRAW_PLANES_H
#define DRAW_PLANES_H

enum PLANE
{

    PLANE_INTERNAL_BG    = 0x00, // reserved for engine-internal purposes

    PLANE_GAME_BACKDROP  = 0x08, // backdrop, drawn behind level / world map screens

    PLANE_LVL_3D_NEG2    = 0x00, // start of -2 plane on 3DS (level)
    PLANE_LVL_BG         = 0x10, // level background (background2)
    PLANE_LVL_3D_NEG1    = 0x18, // start of -1 plane on 3DS (level)
    PLANE_LVL_BGO_LOW    = 0x18, // special BGOs drawn below sizables
    PLANE_LVL_SBLOCK     = 0x20, // sizable blocks only
    PLANE_LVL_BGO_NORM   = 0x28, // includes locks at +1
    PLANE_LVL_3D_MAIN    = 0x30, // start of +0 plane on 3DS (level)
    PLANE_LVL_NPC_BG     = 0x30, // NPCs drawn below blocks (includes warping NPCs)
    PLANE_LVL_PLR_WARP   = 0x38, // players warping and their held items
    PLANE_LVL_BLK_NORM   = 0x40, // normal blocks
    PLANE_LVL_EFF_LOW    = 0x48, // low effects
    PLANE_LVL_NPC_LOW    = 0x50, // low NPCs (includes frozen NPCs at +1)
    PLANE_LVL_NPC_NORM   = 0x58, // includes NPC chat indicators
    PLANE_LVL_PLR_NORM   = 0x60, // player graphics (including mounts and held NPCs)
    PLANE_LVL_BGO_FG     = 0x68, // foreground BGOs
    PLANE_LVL_NPC_FG     = 0x70, // foreground NPCs
    PLANE_LVL_BLK_HURTS  = 0x78, // lava and spike blocks
    PLANE_LVL_BGO_TOP    = 0x80, // special BGOs drawn above hurt blocks and FG NPCs
    PLANE_LVL_EFF_NORM   = 0x88, // normal effects
    PLANE_LVL_INFO       = 0x90, // level info, currently includes warp info (star count), editor water rects, and editor info
    PLANE_LVL_SECTION_FG = 0x98, // highest game-space draws, includes Luna draws, Section FX
    PLANE_LVL_3D_POS1    = 0xA0, // start of +1 plane on 3DS (level)
    PLANE_LVL_HUD        = 0xA0, // includes dropped NPCs (at +1), and level vScreen fader (at -1)
    PLANE_LVL_META       = 0xA8, // information drawn above the HUD but still in the vScreen

    PLANE_WLD_3D_NEG2    = 0x00, // start of -2 plane on 3DS (world)
    PLANE_WLD_BG         = 0x10, // reserved for future background draws on the world map
    PLANE_WLD_3D_NEG1    = 0x18, // start of -1 plane on 3DS (world)
    PLANE_WLD_TIL        = 0x18, // world map tiles
    PLANE_WLD_SCN        = 0x20, // world map scenes
    PLANE_WLD_PTH        = 0x28, // world map paths
    PLANE_WLD_LVL        = 0x30, // world map levels
    PLANE_WLD_PLR        = 0x38, // world map players
    PLANE_WLD_3D_MAIN    = 0x88, // start of +0 plane on 3DS (world)
    PLANE_WLD_EFF        = 0x88, // world map effects (editor-exclusive)
    PLANE_WLD_INFO       = 0x90, // world map info, currently includes level info (star count), editor music boxes, and editor info
    PLANE_WLD_FRAME      = 0x98, // world map frame, drawn below HUD
    PLANE_WLD_3D_POS1    = 0xA0, // start of +1 plane on 3DS (world)
    PLANE_WLD_HUD        = 0xA0, // world map HUD (player preview, level title, etc)
    PLANE_WLD_META       = 0xA8, // information drawn above the HUD but still in the screen (currently unused)

    PLANE_GAME_META      = 0xC8, // information drawn above the game but below menus
    PLANE_GAME_MENUS     = 0xD0, // game menus drawn above everything (including main menu, pause menu, message box, etc)
    PLANE_GAME_FADER     = 0xD8, // game screen fader
    PLANE_INTERNAL_FG    = 0xF0, // reserved for engine-internal purposes
};


#endif


================================================
FILE: src/editor/editor.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#ifdef THEXTECH_INTERPROC_SUPPORTED
#   include <InterProcess/intproc.h>
#endif
#include <Logger/logger.h>
#include <Utils/elapsed_timer.h>
#include <pge_delay.h>
#include <fmt_format_ne.h>

#include "globals.h"
#include "config.h"
#include "editor.h"
#include "graphics.h"
#include "sound.h"
#include "collision.h"
#include "npc.h"
#include "blocks.h"
#include "sorting.h"
#include "player.h"
#include "effect.h"
#include "layers.h"
#include "game_main.h"
#include "change_res.h"
#include "main/level_file.h"
#include "main/cheat_code.h"
#include "main/trees.h"
#include "main/game_globals.h"
#include "main/screen_connect.h"
#include "main/screen_quickreconnect.h"
#include "main/game_strings.h"
#include "main/speedrunner.h"
#include "load_gfx.h"
#include "core/render.h"
#include "core/window.h"
#include "core/events.h"
#include "fontman/font_manager.h"
#include "npc/section_overlap.h"

#include "controls.h"

#include "pseudo_vb.h"
#include "npc_traits.h"
#include "npc_id.h"
#include "eff_id.h"

#include "write_level.h"
#include "write_world.h"
#include "editor/new_editor.h"

#include "editor/magic_block.h"
#include "editor/editor_custom.h"

#include <PGE_File_Formats/file_formats.h>

// static int ScrollDelay = 0; // slows down the camera movement when scrolling through a level
//Public Declare Function GetCursorPos Lib "user32" (lpPoint As POINTAPI) As long long;

std::string Backup_FullFileName;

bool MouseCancel = false;
bool HasCursor = false;
// bool NoReallyKillIt = false; //Unused
int curSection = 0;

bool enableAutoAlign = true;

int last_vScreenX[maxSections+1];
int last_vScreenY[maxSections+1];

// backup values
int curSection_b = 0;
int last_vScreenX_b[maxSections+1];
int last_vScreenY_b[maxSections+1];

// number of frames to show section
int editor_section_toast = 0;

// buffer for scrolling since we can only scroll in 32-pixel increments
num_t scroll_buffer_x = 0;
num_t scroll_buffer_y = 0;

// to prevent constant replacement of tiled items during "replace_existing" mode
Location_t last_EC_loc;

// the first f stands for "fixed"
constexpr bool ffEqual(num_t i, num_t j)
{
    return (i - j > -0.1_n) && (i - j < 0.1_n);
}

void ResetSectionScrolls()
{
    int p1_section = 0;

    // use screen 0 for section scrolls
    const Screen_t& screen = Screens[0];

    for(int i = 0; i <= maxSections; i++)
    {
        // initialize the section
        if(LevelREAL[i].Height == LevelREAL[i].Y)
        {
            LevelREAL[i].Height = (-200000 + 20000 * i);
            LevelREAL[i].Y = LevelREAL[i].Height - 600;
            LevelREAL[i].X = (-200000 + 20000 * i);
            LevelREAL[i].Width = LevelREAL[i].X + 800;

            // initialize player positions
            if(i == 0)
            {
                for(int p = 1; p <= 2; p++)
                {
                    PlayerStart[p].Width = Physics.PlayerWidth[p][2];
                    PlayerStart[p].Height = Physics.PlayerHeight[p][2];
                    PlayerStart[p].X = LevelREAL[i].X + 128 - 64 * (p - 1);
                    PlayerStart[p].Y = LevelREAL[i].Height - 32 - PlayerStart[p].Height;
                }
            }

            level[i] = static_cast<SpeedlessLocation_t>(LevelREAL[i]);
        }

        // normally start at bottom-left
        last_vScreenY[i] = -(LevelREAL[i].Height - screen.H);
        last_vScreenX[i] = -(LevelREAL[i].X);

        // if player start is in section, start there instead
        for(int p = 1; p <= 2; p++)
        {
            if(PlayerStart[p].X >= LevelREAL[i].X && PlayerStart[p].X + PlayerStart[p].Width <= LevelREAL[i].Width
                && PlayerStart[p].Y >= LevelREAL[i].Y && PlayerStart[p].Y + PlayerStart[p].Height <= LevelREAL[i].Height)
            {
                // center on player
                last_vScreenX[i] = -(PlayerStart[p].X + PlayerStart[p].Width / 2 - screen.W / 2);
                last_vScreenY[i] = -(PlayerStart[p].Y + PlayerStart[p].Height / 2 - screen.H / 2);

                // check section bounds
                if(-last_vScreenX[i] < LevelREAL[i].X)
                    last_vScreenX[i] = -LevelREAL[i].X;
                else if(-last_vScreenX[i] + screen.W > LevelREAL[i].Width)
                    last_vScreenX[i] = -(LevelREAL[i].Width - screen.W);

                if(-last_vScreenY[i] < LevelREAL[i].Y)
                    last_vScreenY[i] = -LevelREAL[i].Y;
                else if(-last_vScreenY[i] + screen.H > LevelREAL[i].Height)
                    last_vScreenY[i] = -(LevelREAL[i].Height - screen.H);

                // save P1 section
                if(p == 1)
                    p1_section = i;

                // don't check other player
                break;
            }
        }

        // center on section if screen bigger
        if(LevelREAL[i].Width - LevelREAL[i].X < screen.W)
            last_vScreenX[i] += screen.W / 2 - (LevelREAL[i].Width - LevelREAL[i].X) / 2;
        if(LevelREAL[i].Height - LevelREAL[i].Y < screen.H)
            last_vScreenY[i] = -LevelREAL[i].Y + screen.H / 2 - (LevelREAL[i].Height - LevelREAL[i].Y) / 2;

        // align to grid
        last_vScreenY[i] = ((last_vScreenY[i] + 8 + 16) / 32) * 32 - 8;
        last_vScreenX[i] = ((last_vScreenX[i] + 16) / 32) * 32;
    }

    curSection = p1_section;
    vScreen[1].Y = last_vScreenY[curSection];
    vScreen[1].X = last_vScreenX[curSection];
}

void SetSection(int i)
{
    if(curMusic != bgMusic[i])
        StartMusic(i);
    else if(bgMusic[i] == 24)
    {
        if(curSection >= 0)
            if(CustomMusic[curSection] != CustomMusic[i])
                StartMusic(i);
    }

    if(curSection != i)
    {
        PlaySound(SFX_Slide);
        editor_section_toast = 66;
    }

    last_vScreenY[curSection] = (int)vScreen[1].Y;
    last_vScreenX[curSection] = (int)vScreen[1].X;
    curSection = i;
    vScreen[1].Y = last_vScreenY[curSection];
    vScreen[1].X = last_vScreenX[curSection];
}

void EditorBackup()
{
    last_vScreenY[curSection] = (int)vScreen[1].Y;
    last_vScreenX[curSection] = (int)vScreen[1].X;
    for(int i = 0; i <= maxSections; i++)
    {
        last_vScreenX_b[i] = last_vScreenX[i];
        last_vScreenY_b[i] = last_vScreenY[i];
    }
    curSection_b = curSection;
}

void EditorRestore()
{
    for(int i = 0; i <= maxSections; i++)
    {
        last_vScreenX[i] = last_vScreenX_b[i];
        last_vScreenY[i] = last_vScreenY_b[i];
    }
    curSection = curSection_b;
    vScreen[1].X = last_vScreenX_b[curSection];
    vScreen[1].Y = last_vScreenY_b[curSection];
    SetSection(curSection);
    vScreen[1].X = last_vScreenX_b[curSection];
    vScreen[1].Y = last_vScreenY_b[curSection];
}

void EditorCursor_t::ClearStrings()
{
    FreeS(this->NPC.Text);
    FreeS(this->Warp.StarsMsg);
    FreeS(this->Warp.level);
    FreeS(this->WorldMusic.MusicFile);
}

enum InteractFlags
{
    IF_AltMode =  1,
    IF_ResizeT =  2,
    IF_ResizeB =  4,
    IF_ResizeL =  8,
    IF_ResizeR = 16,
};

void UpdateInteract();
template<class LocType>
void InteractResize(LocType& loc, int min, int snap);

void InteractResizeSection(IntegerLocation_t& section);

// this sub handles the level editor
// it is still called when the player is testing a level in the editor in windowed mode
void UpdateEditor()
{
    if(!MagicHand)
        Controls::PollInputMethod();

    int A = 0;
    // int B = 0;
//    int C = 0;
    int qLevel = 0;
    bool CanPlace = false; // Determines if something is in the way
//    bool grabBool = false;
    Location_t tempLocation;
//    if(Debugger == true)
//        frmLevelDebugger::UpdateDisplay;
    GameMenu = false;

    GetEditorControls();

    if(!SharedCursor.Primary && !EditorControls.SwitchScreens && !EditorControls.TestPlay)
    {
        MouseRelease = true;
        MouseCancel = false;
        if(EditorCursor.SubMode > 0 && EditorCursor.Mode == OptCursor_t::LVL_ERASER)
            EditorCursor.SubMode = 0;
    }

    if(EditorCursor.Y < 40)
    {
        MouseCancel = true;
        EditorCursor.InteractMode = 0;
        EditorCursor.InteractFlags = 0;
        EditorCursor.InteractIndex = 0;
    }

    bool MouseClick_Current = SharedCursor.Primary && !MouseCancel;

    if(LevelEditor)
        numPlayers = 0;

    if(MagicHand)
    {
        // keep the cursor's position correct when the player moves!
        MouseMove(EditorCursor.X, EditorCursor.Y, true);
    }
    else
    {
        FreezeNPCs = false;
        LevelMacro = LEVELMACRO_OFF;
        LevelMacroCounter = 0;
    }

    if(!MagicHand)
    {
        if(EditorControls.PrevSection && !WorldEditor)
        {
            if(ScrollRelease)
            {
                ScrollRelease = false;
                if(curSection != 0)
                    SetSection(curSection - 1);
            }
        }
        else if(EditorControls.NextSection && !WorldEditor)
        {
            if(ScrollRelease)
            {
                ScrollRelease = false;
                if(curSection != maxSections)
                    SetSection(curSection + 1);
            }
        }
        else
            ScrollRelease = true;

        vScreen[1].Y = num_t::floor((vScreen[1].Y + 8) / 32) * 32 - 8;
        vScreen[1].X = num_t::floor(vScreen[1].X / 32) * 32;
    }
    else
    {
        curSection = Player[1].Section;
    }


    // if(!XWindow::hasWindowMouseFocus() || SharedCursor.X < 0 || SharedCursor.Y > XRender::TargetW || SharedCursor.Y < 0 || SharedCursor.Y > XRender::TargetH)
    //     HideCursor();

    if(LevelEditor || MagicHand)
    {
        int scroll_required = EditorControls.FastScroll ? 16 : 32;

        if(MagicHand)
        {
            scroll_buffer_x = 0;
            scroll_buffer_y = 0;
        }

        // if(ScrollDelay <= 0)
        {
            int to_scroll_x = (int)(scroll_buffer_x / scroll_required);
            int to_scroll_y = (int)(scroll_buffer_y / scroll_required);

            if(to_scroll_x)
            {
                vScreen[1].X -= 32 * to_scroll_x;
                EditorCursor.Location.X += 32 * to_scroll_x;
                scroll_buffer_x -= to_scroll_x * scroll_required;
            }

            if(to_scroll_y)
            {
                vScreen[1].Y -= 32 * to_scroll_y;
                EditorCursor.Location.Y += 32 * to_scroll_y;
                scroll_buffer_y -= to_scroll_y * scroll_required;
            }
        }
        // else
        //     ScrollDelay -= 1;
        SetCursor();

        // this is where objects are placed/grabbed/deleted

#ifdef THEXTECH_INTERPROC_SUPPORTED
        if(IntProc::isEnabled())
            UpdateInterprocess();
#endif

        UpdateInteract();

        if(MouseClick_Current && !editorScreen.active && EditorCursor.Y > 40)
        {
            CanPlace = true;
            if(EditorCursor.Mode == OptCursor_t::LVL_SELECT)
            {
                if(EditorCursor.InteractMode == OptCursor_t::LVL_PLAYERSTART) // Player start points
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);

                    EditorCursor.Mode = OptCursor_t::LVL_PLAYERSTART;
                    EditorCursor.SubMode = 3 + A;

                    EditorCursor.Location = PlayerStart[A];
                    PlayerStart[A] = PlayerStart_t();
                    MouseMove(EditorCursor.X, EditorCursor.Y);
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }
                else if(EditorCursor.InteractMode == OptCursor_t::LVL_SECTION)
                {
                    MouseRelease = false;
                    InteractResizeSection(LevelREAL[curSection]);
                    level[curSection] = static_cast<SpeedlessLocation_t>(LevelREAL[curSection]);
                    UpdateSectionOverlaps(curSection);
                }

                // event section resize
                if(EditorCursor.InteractMode == OptCursor_t::LVL_EVENTS)
                {
                    int A = EditorCursor.InteractIndex;
                    InteractResizeSection(Events[A].section[curSection].position);
                    MouseRelease = false;
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_NPCS) // NPCs
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);

                    EditorCursor.Mode = OptCursor_t::LVL_NPCS;
                    EditorCursor.NPC = NPC[A];
                    EditorCursor.NPC.Hidden = false;
                    EditorCursor.Layer = NPC[A].Layer;
                    EditorCursor.Location = NPC[A].Location;
                    EditorCursor.Location.X = NPC[A].Location.X;
                    EditorCursor.Location.Y = NPC[A].Location.Y;
                    SetCursor();
                    ResetNPC(EditorCursor.NPC.Type);

                    NPC[A].DefaultType = NPCID_NULL;
                    KillNPC(A, 9);

                    editorScreen.FocusNPC();
                    MouseRelease = false;
                    MouseCancel = true;

#ifdef THEXTECH_INTERPROC_SUPPORTED
                    if(IntProc::isEnabled()) // Report the taken block into the Editor
                    {
                        LevelNPC n;
                        n.id = EditorCursor.NPC.Type;
                        n.direct = EditorCursor.NPC.Direction;

                        n.generator = EditorCursor.NPC.Generator;
                        if(n.generator)
                        {
                            n.generator_direct = EditorCursor.NPC.GeneratorDirection();
                            n.generator_type = EditorCursor.NPC.GeneratorEffect();
                            n.generator_period = EditorCursor.NPC.GeneratorTimeMax();
                        }

                        if(n.id == NPCID_ITEM_BURIED || n.id == NPCID_ITEM_POD || n.id == NPCID_ITEM_BUBBLE || n.id == NPCID_ITEM_THROWER)
                            n.contents = EditorCursor.NPC.Special;

                        if(n.id == NPCID_DOOR_MAKER || n.id == NPCID_MAGIC_DOOR || (n.id == NPCID_ITEM_BURIED && EditorCursor.NPC.Special == NPCID_DOOR_MAKER))
                            n.special_data = EditorCursor.NPC.Variant;

                        if(NPCIsAParaTroopa((NPCID)n.id) || NPCTraits[n.id].IsFish || n.id == NPCID_FIRE_CHAIN)
                            n.special_data = EditorCursor.NPC.Special;

                        if(n.id == NPCID_VILLAIN_S3)
                            n.special_data = EditorCursor.NPC.Variant;

                        if(EditorCursor.NPC.Wings)
                            n.wings_type = (int)EditorCursor.NPC.DefaultWings;

                        n.msg = GetS(EditorCursor.NPC.Text);
                        n.friendly = EditorCursor.NPC.Inert;
                        n.nomove = EditorCursor.NPC.Stuck;
                        n.is_boss = EditorCursor.NPC.Legacy;

                        n.layer = GetL(EditorCursor.NPC.Layer);
                        n.event_activate = GetE(EditorCursor.NPC.TriggerActivate);
                        n.event_die = GetE(EditorCursor.NPC.TriggerDeath);
                        n.event_emptylayer = GetE(EditorCursor.NPC.TriggerLast);
                        n.event_talk = GetE(EditorCursor.NPC.TriggerTalk);
                        n.attach_layer = GetL(EditorCursor.NPC.AttLayer);
                        IntProc::sendTakenNPC(n);
                    }
#endif
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_BLOCKS && EditorCursor.InteractFlags > 1) // resizing block
                {
                    MouseRelease = false;

                    Location_t& iLoc = Block[EditorCursor.InteractIndex].Location;
                    InteractResize(iLoc, 64, 32);

                    syncLayersTrees_Block(EditorCursor.InteractIndex);
                }
                else if(EditorCursor.InteractMode == OptCursor_t::LVL_BLOCKS) // Blocks
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);

                    EditorCursor.Mode = OptCursor_t::LVL_BLOCKS;
                    EditorCursor.Block = Block[A];
                    EditorCursor.Layer = Block[A].Layer;
                    EditorCursor.Location.X = Block[A].Location.X;
                    EditorCursor.Location.Y = Block[A].Location.Y;
                    EditorCursor.Location.Width = Block[A].Location.Width;
                    EditorCursor.Location.Height = Block[A].Location.Height;
                    SetCursor();

                    Location_t loc = Block[A].Location;
                    int type = Block[A].Type;
                    KillBlock(A, false);

                    MagicBlock::MagicBlock(type, loc);

                    editorScreen.FocusBlock();
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */

#ifdef THEXTECH_INTERPROC_SUPPORTED
                    if(IntProc::isEnabled()) // Report the taken block into the Editor
                    {
                        LevelBlock block;
                        block.id = EditorCursor.Block.Type;
                        block.w = (int)EditorCursor.Location.Width;
                        block.h = (int)EditorCursor.Location.Height;
                        block.invisible = EditorCursor.Block.Invis;
                        block.slippery = EditorCursor.Block.Slippy;
                        block.layer = GetL(EditorCursor.Block.Layer);
                        if(EditorCursor.Block.Special >= 1000)
                            block.npc_id = EditorCursor.Block.Special - 1000;
                        else if(EditorCursor.Block.Special <= 0)
                            block.npc_id = 0;
                        else if(EditorCursor.Block.Special < 1000)
                            block.npc_id = -EditorCursor.Block.Special;
                        block.event_hit = GetE(EditorCursor.Block.TriggerHit);
                        block.event_emptylayer = GetE(EditorCursor.Block.TriggerLast);
                        block.event_destroy = GetE(EditorCursor.Block.TriggerDeath);
                        IntProc::sendTakenBlock(block);
                    }
#endif // THEXTECH_INTERPROC_SUPPORTED
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_WARPS && EditorCursor.InteractFlags > 1) // resizing warps
                {
                    MouseRelease = false;

                    SpeedlessLocation_t& iLoc = (EditorCursor.InteractFlags & IF_AltMode) ? Warp[EditorCursor.InteractIndex].Exit : Warp[EditorCursor.InteractIndex].Entrance;
                    InteractResize(iLoc, 32, 32);
                }
                else if(EditorCursor.InteractMode == OptCursor_t::LVL_WARPS) // Warps
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);
                    MouseRelease = false;
                    EditorCursor.Mode = OptCursor_t::LVL_WARPS;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */

                    if(EditorCursor.InteractFlags == 0)
                    {
                        Warp[A].PlacedEnt = false;
                        EditorCursor.SubMode = 1;
                        EditorCursor.Location.Width = Warp[A].Entrance.Width;
                        EditorCursor.Location.Height = Warp[A].Entrance.Height;

                        if(Warp[A].LevelEnt || EditorCursor.Warp.MapWarp || EditorCursor.Warp.level != STRINGINDEX_NONE)
                            Warp[A].PlacedExit = false;
                    }
                    else
                    {
                        Warp[A].PlacedExit = false;
                        EditorCursor.SubMode = 2;
                        EditorCursor.Location.Width = Warp[A].Exit.Width;
                        EditorCursor.Location.Height = Warp[A].Exit.Height;

                        // TODO: additional testing of these situations
                        if(Warp[A].LevelEnt || EditorCursor.Warp.MapWarp || EditorCursor.Warp.level != STRINGINDEX_NONE)
                            Warp[A].PlacedEnt = false;
                    }

                    EditorCursor.Warp = Warp[A];
                    EditorCursor.Layer = EditorCursor.Warp.Layer;

                    if(!Warp[A].PlacedEnt && !Warp[A].PlacedExit)
                        KillWarp(A);
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_BGOS) // BGOs
                {
                    int A = EditorCursor.InteractIndex;

                    PlaySound(SFX_Grab);

                    EditorCursor.Mode = OptCursor_t::LVL_BGOS;
                    EditorCursor.Background = Background[A];
                    EditorCursor.Layer = Background[A].Layer;
                    EditorCursor.Location.X = Background[A].Location.X;
                    EditorCursor.Location.Y = Background[A].Location.Y;
                    SetCursor();

                    Location_t loc = static_cast<Location_t>(Background[A].Location);
                    int type = Background[A].Type;

                    Background[A] = Background[numBackground];
                    numBackground--;

                    editorScreen.FocusBGO();
                    if(MagicHand)
                    {
                        qSortBackgrounds(1, numBackground);
                        UpdateBackgrounds();
                        syncLayers_AllBGOs();
                    }
                    else
                    {
                        syncLayers_BGO(A);
                        syncLayers_BGO(numBackground+1);
                    }

                    MagicBlock::MagicBackground(type, loc);

                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */

#ifdef THEXTECH_INTERPROC_SUPPORTED
                    if(IntProc::isEnabled()) // Report the taken block into the Editor
                    {
                        LevelBGO b;
                        b.id = EditorCursor.Background.Type;
                        b.layer = GetL(EditorCursor.Background.Layer);
                        b.z_mode = EditorCursor.Background.GetCustomLayer();
                        b.z_offset = EditorCursor.Background.GetCustomOffset();
                        IntProc::sendTakenBGO(b);
                    }
#endif // THEXTECH_INTERPROC_SUPPORTED
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_WATER && EditorCursor.InteractFlags > 1) // resizing water
                {
                    MouseRelease = false;

                    SpeedlessLocation_t& iLoc = Water[EditorCursor.InteractIndex].Location;
                    InteractResize(iLoc, 32, 32);

                    syncLayers_Water(EditorCursor.InteractIndex);
                }
                else if(EditorCursor.InteractMode == OptCursor_t::LVL_WATER) // water
                {
                    int A = EditorCursor.InteractIndex;

                    PlaySound(SFX_Grab);
                    EditorCursor.Mode = OptCursor_t::LVL_WATER;
                    EditorCursor.Location = static_cast<Location_t>(Water[A].Location);
                    EditorCursor.Layer = Water[A].Layer;
                    EditorCursor.Water = Water[A];
                    Water[A] = Water[numWater];
                    numWater--;
                    syncLayers_Water(A);
                    syncLayers_Water(numWater+1);
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_AREA && EditorCursor.InteractFlags > 1) // resizing world map area
                {
                    MouseRelease = false;

                    TinyLocation_t& iLoc = WorldArea[EditorCursor.InteractIndex].Location;
                    InteractResize(iLoc, 32, 32);
                }
                else if(EditorCursor.InteractMode == OptCursor_t::WLD_AREA) // World map areas
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);
                    EditorCursor.Mode = OptCursor_t::WLD_AREA;
                    EditorCursor.Location = static_cast<Location_t>(WorldArea[A].Location);
                    SetCursor();
                    EditorCursor.WorldArea = WorldArea[A];
                    if(A != numWorldAreas)
                        WorldArea[A] = WorldArea[numWorldAreas];
                    numWorldAreas--;
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_MUSIC) // World map music
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);
                    EditorCursor.Mode = OptCursor_t::WLD_MUSIC;
                    EditorCursor.Location = static_cast<Location_t>(WorldMusic[A].Location);
                    SetCursor();
                    EditorCursor.WorldMusic = WorldMusic[A];
                    if(A != numWorldMusic)
                    {
                        WorldMusic[A] = WorldMusic[numWorldMusic];
                        treeWorldMusicUpdate(&WorldMusic[A]);
                    }
                    treeWorldMusicRemove(&WorldMusic[numWorldMusic]);
                    numWorldMusic--;
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_PATHS) // World paths
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);
                    EditorCursor.Mode = OptCursor_t::WLD_PATHS;
                    EditorCursor.Location = static_cast<Location_t>(WorldPath[A].Location);
                    EditorCursor.WorldPath = WorldPath[A];
                    SetCursor();
                    if(A != numWorldPaths)
                    {
                        WorldPath[A] = WorldPath[numWorldPaths];
                        treeWorldPathUpdate(&WorldPath[A]);
                    }
                    treeWorldPathRemove(&WorldPath[numWorldPaths]);
                    numWorldPaths--;
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_SCENES) // World scenes
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);
                    EditorCursor.Mode = OptCursor_t::WLD_SCENES;
                    EditorCursor.Location = static_cast<Location_t>(Scene[A].Location);
                    EditorCursor.Scene = Scene[A];
                    SetCursor();
                    MouseMove(EditorCursor.X, EditorCursor.Y);
                    // this maintains the order of the scenes
                    // but makes for a hellish quadtree update
                    for(int B = A; B < numScenes; B++)
                    {
                        Scene[B] = Scene[B + 1];
                        treeWorldSceneUpdate(&Scene[B]);
                    }
                    treeWorldSceneRemove(&Scene[numScenes]);
                    numScenes--;
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_LEVELS) // World map level points
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);
                    EditorCursor.Mode = OptCursor_t::WLD_LEVELS;
                    EditorCursor.Location = static_cast<Location_t>(WorldLevel[A].Location);
                    EditorCursor.WorldLevel = WorldLevel[A];
                    SetCursor();
                    if(A != numWorldLevels)
                    {
                        WorldLevel[A] = WorldLevel[numWorldLevels];
                        treeWorldLevelUpdate(&WorldLevel[A]);
                    }
                    treeWorldLevelRemove(&WorldLevel[numWorldLevels]);
                    numWorldLevels--;
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_TILES) // World map tiles
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Grab);
                    EditorCursor.Mode = OptCursor_t::WLD_TILES;
                    EditorCursor.Location = static_cast<Location_t>(Tile[A].Location);
                    EditorCursor.Tile = Tile[A];
                    SetCursor();

                    Location_t loc = static_cast<Location_t>(Tile[A].Location);
                    int type = Tile[A].Type;

                    if(A != numTiles)
                    {
                        Tile[A] = Tile[numTiles];
                        treeWorldTileUpdate(&Tile[A]);
                    }
                    treeWorldTileRemove(&Tile[numTiles]);

                    numTiles--;

                    MagicBlock::MagicTile(type, loc);

                    editorScreen.FocusTile();
                    MouseRelease = false;
                    MouseCancel = true; /* Simulate "Focus out" inside of SMBX Editor */
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::LVL_ERASER && (SharedCursor.Move || MouseRelease)) // Eraser
            {
                if(EditorCursor.InteractMode == OptCursor_t::LVL_NPCS)
                {
                    int A = EditorCursor.InteractIndex;

                    if(iRand(2) == 0)
                        NPC[A].Location.SpeedX = Physics.NPCShellSpeed / 2;
                    else
                        NPC[A].Location.SpeedX = -Physics.NPCShellSpeed / 2;

                    NPC[A].DefaultType = NPCID_NULL;
                    if(NPC[A]->IsABonus || NPC[A]->IsACoin)
                        KillNPC(A, 4); // Kill the bonus/coin
                    else
                        KillNPC(A, 2); // Kill the NPC

                    MouseRelease = false;

                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::LVL_NPCS;
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_BLOCKS)
                {
                    int A = EditorCursor.InteractIndex;

                    Location_t loc = Block[A].Location;
                    int type = Block[A].Type;
                    KillBlock(A);

                    MagicBlock::MagicBlock(type, loc);

                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::LVL_BLOCKS;
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_WARPS)
                {
                    int A = EditorCursor.InteractIndex;
                    KillWarp(A);
                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::LVL_WARPS;
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_BGOS)
                {
                    int A = EditorCursor.InteractIndex;

                    Location_t loc = static_cast<Location_t>(Background[A].Location);
                    int type = Background[A].Type;

                    NewEffect(EFFID_SMOKE_S3_CENTER, loc);
                    PlaySound(SFX_Smash);

                    Background[A] = Background[numBackground];
                    numBackground--;

                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::LVL_BGOS;

                    if(MagicHand)
                    {
                        qSortBackgrounds(1, numBackground);
                        UpdateBackgrounds();
                        syncLayers_AllBGOs();
                        syncLayers_BGO(numBackground + 1);
                    }
                    else
                    {
                        syncLayers_BGO(A);
                        syncLayers_BGO(numBackground + 1);
                    }

                    MagicBlock::MagicBackground(type, loc);
                }

                if(EditorCursor.InteractMode == OptCursor_t::LVL_WATER)
                {
                    int A = EditorCursor.InteractIndex;
                    PlaySound(SFX_Smash);
                    Water[A] = Water[numWater];
                    numWater--;
                    syncLayers_Water(A);
                    syncLayers_Water(numWater + 1);
                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::LVL_WATER;
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_AREA)
                {
                    int A = EditorCursor.InteractIndex;
                    tempLocation = static_cast<Location_t>(WorldArea[A].Location);
                    for(int X = 16; X < WorldArea[A].Location.Width; X += 32)
                    {
                        for(int Y = 16; Y < WorldArea[A].Location.Height; Y += 32)
                        {
                            tempLocation.X += X - EffectWidth[EFFID_SMOKE_S3] / 2;
                            tempLocation.Y += Y - EffectHeight[EFFID_SMOKE_S3] / 2;
                            NewEffect(EFFID_SMOKE_S3, tempLocation);
                        }
                    }

                    PlaySound(SFX_ShellHit);
                    if(A != numWorldAreas)
                        WorldArea[A] = WorldArea[numWorldAreas];
                    numWorldAreas--;
                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::WLD_AREA;
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_MUSIC)
                {
                    int A = EditorCursor.InteractIndex;
                    tempLocation = static_cast<Location_t>(WorldMusic[A].Location);
                    NewEffect(EFFID_SMOKE_S3_CENTER, tempLocation);
                    PlaySound(SFX_ShellHit);
                    if(A != numWorldMusic)
                    {
                        WorldMusic[A] = WorldMusic[numWorldMusic];
                        treeWorldMusicUpdate(&WorldMusic[A]);
                    }
                    treeWorldMusicRemove(&WorldMusic[numWorldMusic]);
                    numWorldMusic--;
                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::WLD_MUSIC;
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_PATHS)
                {
                    int A = EditorCursor.InteractIndex;
                    tempLocation = static_cast<Location_t>(WorldPath[A].Location);
                    NewEffect(EFFID_SMOKE_S3_CENTER, tempLocation);
                    PlaySound(SFX_ShellHit);
                    if(A != numWorldPaths)
                    {
                        WorldPath[A] = WorldPath[numWorldPaths];
                        treeWorldPathUpdate(&WorldPath[A]);
                    }
                    treeWorldPathRemove(&WorldPath[numWorldPaths]);
                    numWorldPaths--;
                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::WLD_PATHS;
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_SCENES)
                {
                    int A = EditorCursor.InteractIndex;
                    tempLocation = static_cast<Location_t>(Scene[A].Location);
                    NewEffect(EFFID_SMOKE_S3_CENTER, tempLocation);
                    PlaySound(SFX_ShellHit);
                    for(int B = A; B < numScenes; B++)
                    {
                        Scene[B] = Scene[B + 1];
                        treeWorldSceneUpdate(&Scene[B]);
                    }
                    treeWorldSceneRemove(&Scene[numScenes]);
                    numScenes--;
                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::WLD_SCENES;
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_LEVELS)
                {
                    int A = EditorCursor.InteractIndex;
                    tempLocation = static_cast<Location_t>(WorldLevel[A].Location);
                    NewEffect(EFFID_SMOKE_S3_CENTER, tempLocation);
                    PlaySound(SFX_ShellHit);
                    if(A != numWorldLevels)
                    {
                        WorldLevel[A] = WorldLevel[numWorldLevels];
                        treeWorldLevelUpdate(&WorldLevel[A]);
                    }
                    treeWorldLevelRemove(&WorldLevel[numWorldLevels]);
                    numWorldLevels--;
                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::WLD_LEVELS;
                }

                if(EditorCursor.InteractMode == OptCursor_t::WLD_TILES)
                {
                    int A = EditorCursor.InteractIndex;
                    Location_t loc = static_cast<Location_t>(Tile[A].Location);
                    NewEffect(EFFID_SMOKE_S3_CENTER, loc);
                    PlaySound(SFX_ShellHit);

                    int type = Tile[A].Type;

                    if(A != numTiles)
                    {
                        Tile[A] = Tile[numTiles];
                        treeWorldTileUpdate(&Tile[A]);
                    }
                    treeWorldTileRemove(&Tile[numTiles]);

                    numTiles--;

                    MagicBlock::MagicTile(type, loc);

                    MouseRelease = false;
                    if(EditorCursor.SubMode == 0)
                        EditorCursor.SubMode = OptCursor_t::WLD_TILES;
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::LVL_WATER) // Water
            {
                if(MouseRelease)
                {
                    MouseRelease = false;
                    CanPlace = true;
                    for(A = 1; A <= numWater; A++)
                    {
                        if(ffEqual(Water[A].Location.X, EditorCursor.Location.X) &&
                           ffEqual(Water[A].Location.Y, EditorCursor.Location.Y) &&
                           ffEqual(Water[A].Location.Height, EditorCursor.Location.Height) &&
                           ffEqual(Water[A].Location.Width, EditorCursor.Location.Width))
                        {
                            CanPlace = false;
                            break;
                        }
                    }

                    if(CanPlace)
                    {
                        numWater++;
                        Water[numWater] = EditorCursor.Water;
                        syncLayers_Water(numWater);
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::LVL_BLOCKS) // Blocks
            {
                for(A = numBlock; A >= 1; A--)
                {
                    if(!MouseRelease || (!BlockIsSizable[Block[A].Type] && !BlockIsSizable[EditorCursor.Block.Type]))
                    {
                        // ignore sizable background blocks in Magic Block mode
                        if(MagicBlock::enabled && BlockIsSizable[Block[A].Type] && !BlockIsSizable[EditorCursor.Block.Type])
                            continue;

                        if(CursorCollision(EditorCursor.Location, Block[A].Location) && !Block[A].Hidden)
                        {
                            if(!(MagicBlock::enabled && MagicBlock::replace_existing) || (!MouseRelease && CheckCollision(Block[A].Location, last_EC_loc)))
                            {
                                CanPlace = false;
                                break;
                            }
                            else
                            {
                                Location_t loc = Block[A].Location;
                                int type = Block[A].Type;
                                KillBlock(A, false);
                                MagicBlock::MagicBlock(type, loc);
                            }
                        }
                    }
                    else
                    {
                        if(Block[A].Type == EditorCursor.Block.Type)
                        {
                            if(ffEqual(EditorCursor.Location.X, Block[A].Location.X) &&
                               ffEqual(EditorCursor.Location.Y, Block[A].Location.Y))
                            {
                                if(MouseRelease)
                                    pLogDebug("Sizable block was rejected at block at EC Loc (%d, %d), other block loc (%d, %d)", (int)EditorCursor.Location.X, (int)EditorCursor.Location.Y, (int)Block[A].Location.X, (int)Block[A].Location.Y);

                                CanPlace = false;
                                break;
                            }
                        }
                    }
                }

                if(CanPlace)
                {
                    last_EC_loc = EditorCursor.Location;
                    last_EC_loc.X += 1;
                    last_EC_loc.Y += 1;
                    last_EC_loc.Width -= 2;
                    last_EC_loc.Height -= 2;
                }

                if(!BlockIsSizable[EditorCursor.Block.Type] && EditorCursor.Block.Type != 370 && CanPlace)
                {
                    for(A = 1; A <= numNPCs; A++)
                    {
                        if(NPC[A].Type != NPCID_ITEM_BURIED && NPC[A].Type != NPCID_FIRE_DISK && NPC[A].Type != NPCID_FIRE_CHAIN)
                        {
                            if(CursorCollision(EditorCursor.Location, NPC[A].Location) && !NPC[A].Hidden && NPC[A].Active)
                            {
                                CanPlace = false;
                                break;
                            }
                        }
                    }
                    for(A = 1; A <= 2; A++)
                    {
                        if(CursorCollision(EditorCursor.Location, PlayerStart[A]) && !MagicHand)
                        {
                            CanPlace = false;
                            break;
                        }
                    }
                }

                if(CanPlace) // Nothing is in the way
                {
//                    if(frmBlocks::chkFill.Value == 1)
//                    {
//                        BlockFill(EditorCursor.Block.Location); // and nuke an application with memory overflow error >:D
//                        if(MagicHand == true)
//                        {
//                            for(A = -FLBlocks; A <= FLBlocks; A++)
//                            {
//                                FirstBlock[A] = 1;
//                                LastBlock[A] = numBlock;
//                            }
//                            BlocksSorted = false;
//                        }
//                        FindSBlocks();
//                    }
//                    else
                    {
                        if(numBlock < maxBlocks) // Not out of blocks
                        {
                            MouseRelease = false;
                            numBlock++;
                            Block[numBlock] = EditorCursor.Block;
                            Block[numBlock].DefaultType = Block[numBlock].Type;
                            Block[numBlock].DefaultSpecial = Block[numBlock].Special;
                            syncLayersTrees_Block(numBlock);

                            MagicBlock::MagicBlock(numBlock);
#if 0
                            if(MagicHand)
                            {
                                for(A = -FLBlocks; A <= FLBlocks; A++)
                                {
                                    FirstBlock[A] = 1;
                                    LastBlock[A] = numBlock;
                                }
                                BlocksSorted = false;
                            }
#endif
                        }
                        // FindSBlocks();
//                        if(nPlay.Online == true)
//                            Netplay::sendData Netplay::AddBlock(numBlock);
                    }

                }
            }
            else if(EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART && !MagicHand) // player start points
            {
                if(EditorCursor.SubMode >= 4)
                {
                    // printf("Trying to place player at %f, %f...\n", EditorCursor.Location.X, EditorCursor.Location.Y);
                    int B = EditorCursor.SubMode - 3;

                    for(A = 1; A <= 2; A++)
                    {
                        if(CursorCollision(EditorCursor.Location, PlayerStart[A]) && A != B)
                            CanPlace = false;
                    }
                    for(A = 1; A <= numBlock; A++)
                    {
                        if(CursorCollision(EditorCursor.Location, Block[A].Location) && !Block[A].Hidden && !Block[A].Invis && !BlockIsSizable[Block[A].Type] && !BlockNoClipping[Block[A].Type] && BlockOnlyHitspot1[Block[A].Type] == false && BlockSlope[Block[A].Type] == 0 && BlockSlope2[Block[A].Type] == 0)
                        {
                            CanPlace = false;
                            break;
                        }
                    }
                    if(CanPlace)
                    {
                        if(EditorCursor.SubMode == 4)
                            PlayerStart[1] = EditorCursor.Location;
                        else
                            PlayerStart[2] = EditorCursor.Location;
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::LVL_BGOS) // Backgrounds
            {
                for(A = 1; A <= numBackground; A++)
                {
                    const int ctype = EditorCursor.Background.Type;
                    const int btype = Background[A].Type;
                    bool same_type = (ctype == btype);

                    if(MagicBlock::enabled && ctype > 0 && ctype <= maxBackgroundType && btype > 0 && btype <= maxBackgroundType
                        && EditorCustom::bgo_family_by_type[ctype - 1] != EditorCustom::FAMILY_NONE
                        && EditorCustom::bgo_family_by_type[ctype - 1] == EditorCustom::bgo_family_by_type[btype - 1])
                    {
                        same_type = true;
                    }

                    if(same_type)
                    {
                        if(CursorCollision(EditorCursor.Location, Background[A].Location) && !Background[A].Hidden)
                        {
                            CanPlace = false;
                            break;
                        }
                    }
                }

                if(CanPlace) // Nothing is in the way
                {
                    if(numBackground < maxBackgrounds) // Not out of backgrounds
                    {
                        numBackground++;
                        Background[numBackground] = EditorCursor.Background;
                        syncLayers_BGO(numBackground);

                        MagicBlock::MagicBackground(numBackground);

                        if(MagicHand)
                        {
                            qSortBackgrounds(1, numBackground);
                            UpdateBackgrounds();
                            // ugh
                            syncLayers_AllBGOs();
                        }
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::LVL_NPCS) // NPCs
            {
                if(EditorCursor.NPC.Type != NPCID_ITEM_BURIED && EditorCursor.NPC.Type != NPCID_FIRE_DISK && EditorCursor.NPC.Type != NPCID_FIRE_CHAIN)
                {
                    for(A = 1; A <= numBlock; A++)
                    {
                        if(!BlockIsSizable[Block[A].Type] && !Block[A].Hidden && BlockSlope[Block[A].Type] == 0 && BlockSlope2[Block[A].Type] == 0)
                        {
                            if(CursorCollision(EditorCursor.Location, Block[A].Location))
                            {
                                CanPlace = false;
                                break;
                            }
                        }
                    }
                }

                for(A = 1; A <= numNPCs; A++)
                {
                    if(CursorCollision(EditorCursor.Location, NPC[A].Location) && !NPC[A].Hidden && NPC[A].Active && (NPC[A].Type != NPCID_LIFT_SAND || EditorCursor.NPC.Type == NPCID_LIFT_SAND))
                    {
                        if(!NPC[A].Generator || NPC[A].Type == EditorCursor.NPC.Type)
                        {
                            if((EditorCursor.NPC.Type != NPCID_BOSS_CASE && NPC[A].Type != NPCID_BOSS_CASE) || (EditorCursor.NPC.Type == NPCID_BOSS_CASE && NPC[A].Type == NPCID_BOSS_CASE))
                            {
                                if(!NPC[A]->IsAVine)
                                {
                                    CanPlace = false;
                                    break;
                                }
                            }
                        }
                    }
                }

                for(A = 1; A <= 2; A++)
                {
                    if(CursorCollision(EditorCursor.Location, PlayerStart[A]) && !MagicHand)
                        CanPlace = false;
                }

                if(!MouseRelease)
                    CanPlace = false;

                if(CanPlace) // Nothing is in the way
                {
                    if(numNPCs < maxNPCs - 20) // Not out of npcs
                    {
                        MouseRelease = false;
                        numNPCs++;
//                        if(frmNPCs::Bubble.Caption == "Yes" && frmNPCs::optNPCDirection(1).Value == true)
//                        {
//                            EditorCursor.NPC.Direction = 0;
//                            EditorCursor.NPC.DefaultDirection = 0;
//                        }

                        NPC[numNPCs] = EditorCursor.NPC;
                        if(NPC[numNPCs].Text != STRINGINDEX_NONE)
                        {
                            NPC[numNPCs].Text = STRINGINDEX_NONE;
                            SetS(NPC[numNPCs].Text, GetS(EditorCursor.NPC.Text));
                        }
//                        Netplay::sendData Netplay::AddNPC(numNPCs);
                        if(!MagicHand)
                        {
                            // ugh
                            NPCSort();
                            syncLayers_AllNPCs();
                        }

                        if(MagicHand)
                        {
                            auto &n = NPC[numNPCs];
                            n.FrameCount = 0;
                            n.Active = true;
                            n.TimeLeft = 10;
                            n.DefaultDirection = n.Direction;
                            n.DefaultLocationX = n.Location.X;
                            n.DefaultLocationY = n.Location.Y;
                            n.DefaultSpecial = n.Special;
                            CheckSectionNPC(numNPCs);
                        }
                        syncLayers_NPC(numNPCs);
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::LVL_WARPS) // Warps
            {
                // find an incomplete warp slot
                int numWarpsMax = numWarps + 1;
                for(A = 1; A <= numWarpsMax; A++)
                {
                    if(!Warp[A].PlacedEnt || !Warp[A].PlacedExit)
                        break;
                }

                if(A > numWarps)
                    numWarps = A;

                if(EditorCursor.SubMode == 1 || EditorCursor.Warp.level != STRINGINDEX_NONE || EditorCursor.Warp.LevelEnt || EditorCursor.Warp.MapWarp)
                {
                    EditorCursor.Warp.Entrance = static_cast<SpeedlessLocation_t>(EditorCursor.Location);
                    MouseCancel = true;
                    MouseRelease = false;
                    EditorCursor.Warp.PlacedEnt = true;
                }
                if(EditorCursor.SubMode == 2 || EditorCursor.Warp.level != STRINGINDEX_NONE || EditorCursor.Warp.LevelEnt || EditorCursor.Warp.MapWarp)
                {
                    EditorCursor.Warp.Exit = static_cast<SpeedlessLocation_t>(EditorCursor.Location);
                    MouseCancel = true;
                    MouseRelease = false;
                    EditorCursor.Warp.PlacedExit = true;
                }

                Warp[A] = EditorCursor.Warp;
                Warp[A].Layer = EditorCursor.Layer;

                // de-duplicate strings
                if(Warp[A].level != STRINGINDEX_NONE)
                {
                    Warp[A].level = STRINGINDEX_NONE;
                    SetS(Warp[A].level, GetS(EditorCursor.Warp.level));
                }
                if(Warp[A].StarsMsg != STRINGINDEX_NONE)
                {
                    Warp[A].StarsMsg = STRINGINDEX_NONE;
                    SetS(Warp[A].StarsMsg, GetS(EditorCursor.Warp.StarsMsg));
                }

                if(Warp[A].PlacedEnt && Warp[A].PlacedExit)
                {
                    EditorCursor.Warp.PlacedEnt = false;
                    EditorCursor.Warp.PlacedExit = false;
                    EditorCursor.SubMode = 1;
                }
                else if(Warp[A].PlacedEnt)
                    EditorCursor.SubMode = 2;
                else
                    EditorCursor.SubMode = 1;

                syncLayers_Warp(A);
//                if(nPlay.Online == true)
//                    Netplay::sendData Netplay::AddWarp[A];
            }
            else if(EditorCursor.Mode == OptCursor_t::WLD_TILES) // Tiles
            {
                for(A = numTiles; A >= 1; A--)
                {
                    if(CursorCollision(EditorCursor.Location, Tile[A].Location))
                    {
                        if(!(MagicBlock::enabled && MagicBlock::replace_existing) || (!MouseRelease && CheckCollision(Tile[A].Location, last_EC_loc)))
                        {
                            CanPlace = false;
                            break;
                        }
                        else
                        {
                            Location_t loc = static_cast<Location_t>(Tile[A].Location);
                            int type = Tile[A].Type;

                            if(A != numTiles)
                            {
                                Tile[A] = Tile[numTiles];
                                treeWorldTileUpdate(&Tile[A]);
                            }
                            treeWorldTileRemove(&Tile[numTiles]);
                            numTiles--;

                            MagicBlock::MagicTile(type, loc);
                        }
                    }
                }

                MouseRelease = false;

                if(CanPlace) // Nothing is in the way
                {
                    last_EC_loc = EditorCursor.Location;
                    last_EC_loc.X += 1;
                    last_EC_loc.Y += 1;
                    last_EC_loc.Width -= 2;
                    last_EC_loc.Height -= 2;

                    if(numTiles < maxTiles) // Not out of blocks
                    {
                        numTiles++;
                        Tile[numTiles] = EditorCursor.Tile;
                        treeWorldTileAdd(&Tile[numTiles]);

                        MagicBlock::MagicTile(numTiles);
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::WLD_SCENES) // Scenery
            {
                for(A = 1; A <= numScenes; A++)
                {
                    if(CursorCollision(EditorCursor.Location, Scene[A].Location))
                    {
                        if(EditorCursor.Scene.Type == Scene[A].Type)
                        {
                            if(ffEqual(EditorCursor.Scene.Location.X, Scene[A].Location.X) &&
                               ffEqual(EditorCursor.Scene.Location.Y, Scene[A].Location.Y))
                            {
                                CanPlace = false;
                                break;
                            }
                        }
                    }
                }

                for(A = 1; A <= numWorldLevels; A++)
                {
                    if(CursorCollision(EditorCursor.Location, WorldLevel[A].Location))
                    {
                        CanPlace = false;
                        break;
                    }
                }

                if(CanPlace)
                {
                    if(numScenes < maxScenes)
                    {
                        numScenes++;
                        Scene[numScenes] = EditorCursor.Scene;
                        treeWorldSceneAdd(&Scene[numScenes]);
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::WLD_LEVELS) // Level
            {
                // can do something fancy with the quadtrees here

                for(A = 1; A <= numWorldPaths; A++)
                {
                    if(CursorCollision(EditorCursor.Location, WorldPath[A].Location))
                    {
                        CanPlace = false;
                        break;
                    }
                }

                for(A = 1; A <= numScenes; A++)
                {
                    if(CursorCollision(EditorCursor.Location, Scene[A].Location))
                    {
                        CanPlace = false;
                        break;
                    }
                }

                for(A = 1; A <= numWorldLevels; A++)
                {
                    if(CursorCollision(EditorCursor.Location, WorldLevel[A].Location))
                    {
                        CanPlace = false;
                        qLevel = A;
                        UNUSED(qLevel);
                        break;
                    }
                }

                if(CanPlace)
                {
                    if(numWorldLevels < maxWorldLevels)
                    {
                        numWorldLevels++;
                        WorldLevel[numWorldLevels] = EditorCursor.WorldLevel;
                        treeWorldLevelAdd(&WorldLevel[numWorldLevels]);
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::WLD_PATHS) // Paths
            {
                // can do something fancy with the quadtrees here

                for(A = 1; A <= numWorldPaths; A++)
                {
                    if(CursorCollision(EditorCursor.Location, WorldPath[A].Location))
                    {
                        CanPlace = false;
                        break;
                    }
                }

                for(A = 1; A <= numWorldLevels; A++)
                {
                    if(CursorCollision(EditorCursor.Location, WorldLevel[A].Location))
                    {
                        CanPlace = false;
                        break;
                    }
                }

                if(CanPlace)
                {
                    if(numWorldPaths < maxWorldPaths)
                    {
                        numWorldPaths++;
                        WorldPath[numWorldPaths] = EditorCursor.WorldPath;
                        treeWorldPathAdd(&WorldPath[numWorldPaths]);
                    }
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::WLD_MUSIC) // Music
            {
                for(A = 1; A <= numWorldMusic; A++)
                {
                    if(CursorCollision(EditorCursor.Location, WorldMusic[A].Location))
                    {
                        CanPlace = false;
                        break;
                    }
                }

                if(CanPlace)
                {
                    EditorCursor.WorldMusic.Location = static_cast<TinyLocation_t>(EditorCursor.Location);
                    numWorldMusic++;
                    WorldMusic[numWorldMusic] = EditorCursor.WorldMusic;
                    // de-duplicate music file
                    if(EditorCursor.WorldMusic.MusicFile != STRINGINDEX_NONE)
                    {
                        WorldMusic[numWorldMusic].MusicFile = STRINGINDEX_NONE;
                        SetS(WorldMusic[numWorldMusic].MusicFile, GetS(EditorCursor.WorldMusic.MusicFile));
                    }
                    treeWorldMusicAdd(&WorldMusic[numWorldMusic]);
                }
            }
            else if(EditorCursor.Mode == OptCursor_t::WLD_AREA && MouseRelease) // Areas
            {
                for(A = 1; A <= numWorldAreas; A++)
                {
                    if(CursorCollision(EditorCursor.Location,
                        newLoc(WorldArea[A].Location.X, WorldArea[A].Location.Y, 32, 32)))
                    {
                        CanPlace = false;
                        break;
                    }
                }

                if(CanPlace)
                {
                    EditorCursor.WorldArea.Location.X = (int)EditorCursor.Location.X;
                    EditorCursor.WorldArea.Location.Y = (int)EditorCursor.Location.Y;
                    numWorldAreas++;
                    WorldArea[numWorldAreas] = EditorCursor.WorldArea;
                    MouseRelease = false;
                }
            }
        }

        if(!MagicHand)
        {
            for(A = 1; A <= numNPCs; A++)
            {
                // .Frame = EditorNPCFrame(.Type, .Direction)
                NPCFrames(A);
            }
        }
    }

#ifdef THEXTECH_INTERPROC_SUPPORTED
    if(!MagicHand || !IntProc::isEnabled())
#endif
    {
        editorScreen.UpdateEditorScreen(EditorScreen::CallMode::Logic);
    }
}

#ifdef THEXTECH_INTERPROC_SUPPORTED
void UpdateInterprocess()
{
    if(!IntProc::hasCommand())
        return;

    IntProc::cmdLock();

    //Recive external commands!
    switch(IntProc::commandType())
    {
    case IntProc::MsgBox:
    {
        g_MessageType = MESSAGE_TYPE_SYS_INFO;
        MessageText = IntProc::getCMD();
        PauseGame(PauseCode::Message);
        break;
    }

    case IntProc::Cheat:
    {
        cheats_setBuffer(IntProc::getCMD(), false);
        break;
    }

    case IntProc::SetLayer:
    {
        EditorCursor.Layer = FindLayer(IntProc::getCMD());

        EditorCursor.Block.Layer = EditorCursor.Layer;
        EditorCursor.Background.Layer = EditorCursor.Layer;
        EditorCursor.NPC.Layer = EditorCursor.Layer;
        break;
    }

    case IntProc::SetNumStars:
    {
        auto s = IntProc::getCMD();
        int starsNew = SDL_atoi(s.c_str());
        if(numStars < starsNew) // Can't decrease stars number
        {
            numStars = starsNew;
            CheckAfterStarTake(true);
        }
        break;
    }

    case IntProc::PlaceItem:
    {
        std::string raw = IntProc::getCMD();
        pLogDebug(raw);
        LevelData got;
        PGE_FileFormats_misc::RawTextInput raw_file(&raw);
        FileFormats::ReadExtendedLvlFile(raw_file, got);

        if(!got.meta.ReadFileValid)
        {
            pLogDebug(got.meta.ERROR_info);
            break;
        }

        if(raw.compare(0, 11, "BLOCK_PLACE") == 0)
        {
            if(got.blocks.empty())
                break;

            const LevelBlock &b = got.blocks[0];

            if(EditorCursor.Mode != OptCursor_t::LVL_BLOCKS ||
               EditorCursor.Block.Type != int(b.id))
                PlaySound(SFX_Grab);

            EditorCursor.Layer = FindLayer(b.layer);

            EditorCursor.Mode = OptCursor_t::LVL_BLOCKS;
            EditorCursor.Block = Block_t();
            EditorCursor.Block.Type = int(b.id);
            EditorCursor.Location.X = b.x;
            EditorCursor.Location.Y = b.y;
            EditorCursor.Location.Width = b.w;
            EditorCursor.Location.Height = b.h;
            if(EditorCursor.Block.Type <= maxBlockType && BlockIsSizable[EditorCursor.Block.Type])
            {
                EditorCursor.Block.Location.Width = 128;
                EditorCursor.Block.Location.Height = 128;
                EditorCursor.Location.Width = 128;
                EditorCursor.Location.Height = 128;
            }
            EditorCursor.Block.Invis = b.invisible;
            EditorCursor.Block.Slippy = b.slippery;
            EditorCursor.Block.Special = b.npc_id > 0 ? int(b.npc_id + 1000) : int(-b.npc_id);
            EditorCursor.Block.Layer = FindLayer(b.layer);
            EditorCursor.Block.TriggerHit = FindEvent(b.event_hit);
            EditorCursor.Block.TriggerLast = FindEvent(b.event_emptylayer);
            EditorCursor.Block.TriggerDeath = FindEvent(b.event_destroy);

            if(EditorCursor.Block.Type > maxBlockType) // Avoid out of range crash
                EditorCursor.Block.Type = 1;

            SetCursor();
        }
        else if(raw.compare(0, 9, "BGO_PLACE") == 0)
        {
            if(got.bgo.empty())
                break;

            const LevelBGO &b = got.bgo[0];

            if(EditorCursor.Mode != OptCursor_t::LVL_BGOS ||
               EditorCursor.Background.Type != int(b.id))
                PlaySound(SFX_Grab);

            EditorCursor.Layer = FindLayer(b.layer);

            EditorCursor.Mode = OptCursor_t::LVL_BGOS;
            EditorCursor.Background = Background_t();
            EditorCursor.Background.Type = int(b.id);
            EditorCursor.Location.X = b.x;
            EditorCursor.Location.Y = b.y;
            EditorCursor.Background.Layer = FindLayer(b.layer);
            EditorCursor.Background.SetSortPriority(b.z_mode, std::round(b.z_offset));

            if(EditorCursor.Background.Type > maxBackgroundType) // Avoid out of range crash
                EditorCursor.Background.Type = 1;

            SetCursor();
        }
        else if(raw.compare(0, 9, "NPC_PLACE") == 0)
        {
            if(got.npc.empty())
                break;

            const LevelNPC &n = got.npc[0];

            if(EditorCursor.Mode != OptCursor_t::LVL_NPCS ||
               EditorCursor.NPC.Type != int(n.id))
                PlaySound(SFX_Grab);

            EditorCursor.Layer = FindLayer(n.layer);

            EditorCursor.Mode = OptCursor_t::LVL_NPCS;
            EditorCursor.NPC = NPC_t();
            EditorCursor.NPC.Type = NPCID(n.id);
            EditorCursor.NPC.Hidden = false;
            EditorCursor.Location.X = n.x;
            EditorCursor.Location.Y = n.y;
            EditorCursor.NPC.Direction = n.direct;

            if(n.id > maxNPCType) // Avoid out of range crash
                EditorCursor.NPC.Type = NPCID(1);

            if(NPCIsContainer(EditorCursor.NPC))
            {
                EditorCursor.NPC.Special = (vbint_t)n.contents;
                EditorCursor.NPC.DefaultSpecial = EditorCursor.NPC.Special;
            }

            if(EditorCursor.NPC.Type == NPCID_DOOR_MAKER || EditorCursor.NPC.Type == NPCID_MAGIC_DOOR || (EditorCursor.NPC.Type == NPCID_ITEM_BURIED && EditorCursor.NPC.Special == NPCID_DOOR_MAKER))
                EditorCursor.NPC.Variant = (vbint_t)n.special_data;

            if(NPCIsAParaTroopa(EditorCursor.NPC))
            {
                EditorCursor.NPC.Special = (vbint_t)n.special_data;
                EditorCursor.NPC.DefaultSpecial = EditorCursor.NPC.Special;
            }

            if(EditorCursor.NPC->IsFish)
            {
                EditorCursor.NPC.Special = (vbint_t)n.special_data;
                EditorCursor.NPC.DefaultSpecial = EditorCursor.NPC.Special;
            }

            if(EditorCursor.NPC.Type == NPCID_FIRE_CHAIN)
            {
                EditorCursor.NPC.Special = (vbint_t)n.special_data;
                EditorCursor.NPC.DefaultSpecial = EditorCursor.NPC.Special;
            }

            if(EditorCursor.NPC.Type == NPCID_VILLAIN_S3)
            {
                if(n.special_data >= 0 && n.special_data < 256)
                    EditorCursor.NPC.Variant = (uint8_t)n.special_data;
                else
                    pLogWarning("Out of range Variant value %ld from IntProc", (long)n.special_data);
            }

            EditorCursor.NPC.Generator = n.generator;
            if(EditorCursor.NPC.Generator)
            {
                // EditorCursor.NPC.GeneratorDirection = n.generator_direct;
                // EditorCursor.NPC.GeneratorEffect = n.generator_type;
                EditorCursor.NPC.Special3 = ((uint16_t)(uint8_t)n.generator_direct << 8) + (uint8_t)n.generator_type;
                EditorCursor.NPC.GeneratorTimeMax() = n.generator_period;
            }

            if(!n.msg.empty())
                SetS(EditorCursor.NPC.Text, n.msg);

            EditorCursor.NPC.Inert = n.friendly;
            if(EditorCursor.NPC.Type == NPCID_SIGN)
                EditorCursor.NPC.Inert = true;
            EditorCursor.NPC.Stuck = n.nomove;
            EditorCursor.NPC.DefaultStuck = EditorCursor.NPC.Stuck;

            EditorCursor.NPC.DefaultWings = (WingBehaviors)n.wings_type;
            EditorCursor.NPC.Wings = EditorCursor.NPC.DefaultWings;

            EditorCursor.NPC.Legacy = n.is_boss;

            EditorCursor.NPC.Layer = FindLayer(n.layer);
            EditorCursor.NPC.TriggerActivate = FindEvent(n.event_activate);
            EditorCursor.NPC.TriggerDeath = FindEvent(n.event_die);
            EditorCursor.NPC.TriggerTalk = FindEvent(n.event_talk);
            EditorCursor.NPC.TriggerLast = FindEvent(n.event_emptylayer);
            EditorCursor.NPC.AttLayer = FindLayer(n.attach_layer);

            EditorCursor.NPC.DefaultType = EditorCursor.NPC.Type;
            EditorCursor.NPC.Location.Width = EditorCursor.NPC->TWidth;
            EditorCursor.NPC.Location.Height = EditorCursor.NPC->THeight;
            EditorCursor.NPC.DefaultLocationX = EditorCursor.NPC.Location.X;
            EditorCursor.NPC.DefaultLocationY = EditorCursor.NPC.Location.Y;
            EditorCursor.NPC.DefaultDirection = EditorCursor.NPC.Direction;
            EditorCursor.NPC.TimeLeft = 1;
            EditorCursor.NPC.Active = true;
            EditorCursor.NPC.JustActivated = 1;
            SetCursor();
        }
        else
            PlaySound(SFX_Fireworks);

        break;
    }
    }

    IntProc::cmdUnLock();
}
#endif // THEXTECH_INTERPROC_SUPPORTED

// int EditorNPCFrame(const NPCID A, vbint_t C, int N)
// {
//     return EditorNPCFrame(A, C, N);
// }

int EditorNPCFrame(const NPCID A, vbint_t& C, int N)
{
    int ret = 0;
// find the default left/right frames for NPCs

    if(A > maxNPCType)
        return ret;
    int B = 0;
    int D = 0;
    int E = 0;
    B = C;
    while(B == 0)
        B = iRand(3) - 1;

    if(!LevelEditor)
        C = B;
    if(A == 241)
        ret = 4;
    if(A == 195)
        ret = 3;

    // suits
    if(N > 0)
    {
        if(A == 169 || A == 170)
        {
            E = 0;
            for(D = 1; D <= numPlayers; D++)
            {
                if(!Player[D].Dead && Player[D].Section == NPC[N].Section && Player[D].Character != 3 &&
                    Player[D].Character != 4 && Player[D].TimeToLive == 0)
                {
                    // this logic is expensive and broken but must be kept because this NPC's frame affects the RNG state (via effect spawning)
                    int dist = (int)(num_t::abs(NPC[N].Location.minus_center_x(Player[D].Location))
                        + num_t::abs(NPC[N].Location.minus_center_y(Player[D].Location)));

                    // dist should get compared to E, but instead it's compared to D
                    if(E == 0 || dist < D)
                    {
                        E = dist;
                        if(Player[D].Character == 5)
                            ret = 1;
                        else
                            ret = 0;
                    }
                }
            }
        }
    }


    if(A == 135 || A == 4 || A == 6 || A == 19 || A == 20 || A == 23 || A == 25 || A == 28 || A == 36 || A == 38 ||
       A == 42 || A == 43 || A == 44 || A == 193 || A == 35 || A == 191 || A == 52 || A == 72 || A == 77 || A == 108 ||
       (A >= 109 && A <= 112) || (A >= 121 && A <= 124) || A == 125 || (A >= 129 && A <= 132) || A == 136 || A == 158 ||
        A == 164 || A == 163 || A == 162 || A == 165 || A == 166 || A == 189 || A == 199 || A == 209 || A == 207 ||
        A == 229 || A == 230 || A == 232 || A == 236 || A == 233 || A == 173 || A == 175 || A == 177 ||
        A == 178 || A == 176) // Koopa troopas / Shy guy
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 2;
    }

    // Bullet Bills
    if(A == 17 || A == 18 || A == 29 || A == 31 || A == 84 || A == 94 || A == 198 ||
       NPCIsYoshi(A) || A == 101 || A == 102 || A == 181 || A == 81)
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 1;
    }

    // Hammer Bros.
    if(A == 29 || A == 55 || A == 75 || A == 78 || A == 168 || A == 234)
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 3;
    }

    if(A == 34)
    {
        if(int(B) == -1)
            ret = 1;
        else
            ret = 0;
    }

    if(A == 201)
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 8;
    }

    if(A == 137)
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 6;
    }

    if(A == 86 || (A >= 117 && A <= 120) || A == 200)
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 5;
    }

    // winged koopa / bob-omb buddy
    if(A == 76 || A == 107 || A == 160 || A == 161 || A == 167 || A == 203 || A == 204)
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 4;
    }

    // Birdo
    if(A == 39 || A == 208)
    {
        if(int(B) == -1)
            ret = 0;
        else
            ret = 5;
    }

    if(A == 45)
        ret = BlockFrame[4];

    if(A == 56)
    {
        ret = SpecialFrame[2];
        if(int(B) == 1)
            ret += 4;
    }

    if(A == 57) // smb3 belt
    {
        if(int(B) == -1)
            ret = SpecialFrame[4];
        else
            ret = 3 - SpecialFrame[4];
    }

    if(A == 60 || A == 62 || A == 64 || A == 66)
    {
        if(int(B) == -1)
            ret = 1;
    }

    return ret;
}

inline void s_CloseProps()
{
#ifdef THEXTECH_INTERPROC_SUPPORTED
    // Tell the IPC Editor to close the properties dialog
    if(IntProc::isWorking())
        IntProc::sendCloseProperties();
#endif
}

void GetEditorControls()
{
    if(GamePaused != PauseCode::None)
    {
        if(HasCursor)
            HideCursor();
        return;
    }

    if(SharedCursor.Move)
        MouseMove((int)SharedCursor.X, (int)SharedCursor.Y);

    if(SharedCursor.Secondary || (EditorControls.ModeSelect && !MagicHand))
    {
        if(EditorCursor.Mode != OptCursor_t::LVL_SELECT && EditorCursor.Mode != OptCursor_t::LVL_ERASER)
            s_CloseProps();

        EditorCursor.Mode = OptCursor_t::LVL_SELECT;
        SetCursor();
    }

    if(SharedCursor.Tertiary || (EditorControls.ModeErase && !MagicHand))
    {
        if(EditorCursor.Mode != OptCursor_t::LVL_SELECT && EditorCursor.Mode != OptCursor_t::LVL_ERASER)
            s_CloseProps();

        EditorCursor.Mode = OptCursor_t::LVL_ERASER;
        SetCursor();
    }

    if(MagicHand)
        return;

    if(!WorldEditor && EditorControls.TestPlay && MouseRelease)
    {
        EditorBackup();
        Backup_FullFileName = FullFileName;
        FullFileName = FullFileName + "tst";
        SaveLevel(FullFileName, FileFormat);

        if(g_config.EnableInterLevelFade)
            g_levelScreenFader.setupFader(4, 0, 65, ScreenFader::S_FADE);
        else
            g_levelScreenFader.setupFader(65, 0, 65, ScreenFader::S_FADE);
        editorWaitForFade();

        // force reconnect on leveltest start
        Controls::ClearInputMethods();

        HasCursor = false;
        zTestLevel(editorScreen.test_magic_hand);
    }
    if(EditorControls.SwitchScreens && MouseRelease)
    {
#ifdef __3DS__
        int win_x, win_y;
        XRender::mapFromScreen((int)SharedCursor.X, (int)SharedCursor.Y, &win_x, &win_y);
#endif

        editorScreen.active = !editorScreen.active;

#ifdef __3DS__
        int m_x, m_y;
        XRender::mapToScreen(win_x, win_y, &m_x, &m_y);
        SharedCursor.X = m_x;
        SharedCursor.Y = m_y;
        MouseMove(m_x, m_y);
#endif

        HasCursor = false;
        MouseRelease = false;
        MenuMouseRelease = false;
        PlaySound(SFX_Pause);
    }

    if(EditorControls.ScrollDown || EditorControls.ScrollUp || EditorControls.ScrollLeft || EditorControls.ScrollRight)
    {
        scroll_buffer_x += EditorControls.ScrollRight;
        scroll_buffer_x -= EditorControls.ScrollLeft;
        scroll_buffer_y += EditorControls.ScrollDown;
        scroll_buffer_y -= EditorControls.ScrollUp;
    }
    else
    {
        scroll_buffer_x = 0;
        scroll_buffer_y = 0;
    }
}

void SetCursor()
{
//    EditorCursor.Layer = frmLayers::lstLayer::List(frmLayers::lstLayer::ListIndex);
    if(EditorCursor.Mode == OptCursor_t::LVL_ERASER) // Eraser
    {
        EditorCursor.Location.Width = 18;
        EditorCursor.Location.Height = 8;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_SELECT || EditorCursor.Mode == 14) // Selection
    {
        EditorCursor.Location.Width = 4;
        EditorCursor.Location.Height = 4;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_WATER) // Water
    {
//        EditorCursor.Location.Height = frmWater::WaterH * 32;
//        EditorCursor.Location.Width = frmWater::WaterW * 32;
        if(EditorCursor.Water.Location.Width < 32)
            EditorCursor.Water.Location.Width = 32;
        if(EditorCursor.Water.Location.Height < 32)
            EditorCursor.Water.Location.Height = 32;
        EditorCursor.Location.Height = EditorCursor.Water.Location.Height;
        EditorCursor.Location.Width = EditorCursor.Water.Location.Width;
        EditorCursor.Water.Location.X = EditorCursor.Location.X;
        EditorCursor.Water.Location.Y = EditorCursor.Location.Y;
        // EditorCursor.Water.Buoy = 0; // frmWater.scrBuoy / 100
        EditorCursor.Water.Layer = EditorCursor.Layer;
//        if(frmWater::Quicksand.Caption == "Yes")
            // EditorCursor.Water.Quicksand = false;
//        else
//            EditorCursor.Water.Quicksand = false;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_BLOCKS) // Blocks
    {
        if(EditorCursor.Block.Type <= 0)
            EditorCursor.Block.Type = 1;
        if(EditorCursor.Block.Type > maxBlockType)
            EditorCursor.Block.Type = 1;

        EditorCursor.Block.Location.X = EditorCursor.Location.X;
        EditorCursor.Block.Location.Y = EditorCursor.Location.Y;
        EditorCursor.Block.Layer = EditorCursor.Layer;
//        EditorCursor.Block.TriggerHit = frmAdvancedBlock::TriggerHit.Text;
//        EditorCursor.Block.TriggerDeath = frmAdvancedBlock::TriggerDeath.Text;
//        EditorCursor.Block.TriggerLast = frmAdvancedBlock::TriggerLast.Text;
//        for(A = 1; A <= frmBlocks::Block.Count; A++)
//        {
//            if(frmBlocks::Block(A).Value == true && frmBlocks::Block(A).Visible == true)
//            {
//                EditorCursor.Block.Type = A;
//                break;
//            }
//        }
        if(!BlockIsSizable[EditorCursor.Block.Type])
        {
            if(EditorCursor.Block.Location.Width <= 0)
            {
                if(BlockWidth[EditorCursor.Block.Type] > 0)
                    EditorCursor.Block.Location.Width = BlockWidth[EditorCursor.Block.Type];
                else
                    EditorCursor.Block.Location.Width = 32;
            }

            if(EditorCursor.Block.Location.Height <= 0)
            {
                if(BlockHeight[EditorCursor.Block.Type] > 0)
                    EditorCursor.Block.Location.Height = BlockHeight[EditorCursor.Block.Type];
                else
                    EditorCursor.Block.Location.Height = 32;
            }
        }

        EditorCursor.Location.Width = EditorCursor.Block.Location.Width;
        EditorCursor.Location.Height = EditorCursor.Block.Location.Height;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART) // Level
    {
        if(EditorCursor.SubMode == 4)
        {
            EditorCursor.Location.Width = Physics.PlayerWidth[1][2]; // Mario
            EditorCursor.Location.Height = Physics.PlayerHeight[1][2];
        }
        else if(EditorCursor.SubMode == 5)
        {
            EditorCursor.Location.Width = Physics.PlayerWidth[2][2]; // Luigi
            EditorCursor.Location.Height = Physics.PlayerHeight[2][2];
        }
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_BGOS) // Background
    {
        if(EditorCursor.Background.Type <= 0)
            EditorCursor.Background.Type = 1;
        if(EditorCursor.Background.Type > maxBackgroundType)
            EditorCursor.Background.Type = 1;

        EditorCursor.Background.Layer = EditorCursor.Layer;
        EditorCursor.Background.Location.X = EditorCursor.Location.X;
        EditorCursor.Background.Location.Y = EditorCursor.Location.Y;
        EditorCursor.Background.Location.Width = BackgroundWidth[EditorCursor.Background.Type];
        EditorCursor.Background.Location.Height = BackgroundHeight[EditorCursor.Background.Type];
        EditorCursor.Location.Width = EditorCursor.Background.Location.Width;
        EditorCursor.Location.Height = EditorCursor.Background.Location.Height;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_NPCS) // NPCs
    {
        NPCID t = EditorCursor.NPC.Type;

        // Container NPCs are handled elsewhere in new editor
        if(MagicHand)
        {
            if(!NPCIsContainer(EditorCursor.NPC) && !NPCTraits[t].IsFish && !NPCIsAParaTroopa(t) && t != NPCID_FIRE_CHAIN)
                EditorCursor.NPC.Special = 0;
        }

        EditorCursor.NPC.Special2 = 0;
        EditorCursor.NPC.Special5 = 0;

        if(!EditorCursor.NPC.Generator)
        {
            EditorCursor.NPC.Special3 = 0;
            EditorCursor.NPC.Special4 = 0;
        }

        // EditorCursor.NPC.Special6 = 0;
        EditorCursor.NPC.SpecialX = 0;
        EditorCursor.NPC.SpecialY = 0;
        EditorCursor.NPC.Layer = EditorCursor.Layer;
        EditorCursor.NPC.Location = EditorCursor.Location;

        if(EditorCursor.NPC->TWidth > 0)
            EditorCursor.NPC.Location.Width = EditorCursor.NPC->TWidth;
        else
            EditorCursor.NPC.Location.Width = 32;
        if(EditorCursor.NPC->THeight > 0)
            EditorCursor.NPC.Location.Height = EditorCursor.NPC->THeight;
        else
            EditorCursor.NPC.Location.Height = 32;
        EditorCursor.Location.Width = EditorCursor.NPC.Location.Width;
        EditorCursor.Location.Height = EditorCursor.NPC.Location.Height;

        EditorCursor.Location.SpeedX = 0;
        EditorCursor.Location.SpeedY = 0;

        EditorCursor.NPC.Frame = EditorNPCFrame(EditorCursor.NPC.Type, EditorCursor.NPC.Direction);
        EditorCursor.NPC.Active = true;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_WARPS) // Warps
    {
        EditorCursor.Warp.Layer = EditorCursor.Layer;
        if(EditorCursor.Location.Width < 32)
            EditorCursor.Location.Width = 32;
        if(EditorCursor.Location.Height < 32)
            EditorCursor.Location.Height = 32;
        // EditorCursor.Warp is now the canonical Warp object.
        // It stores the warp's entrance and exit until the warp is placed,
        // instead of finding and modifying an existing warp.
        // EditorCursor.Warp.Entrance = EditorCursor.Location;
        // EditorCursor.Warp.Exit = EditorCursor.Location;
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_TILES) // Tiles
    {
        if(EditorCursor.Tile.Type == 0)
            EditorCursor.Tile.Type = 1;
        EditorCursor.Location.Width = TileWidth[EditorCursor.Tile.Type];
        EditorCursor.Location.Height = TileHeight[EditorCursor.Tile.Type];
        EditorCursor.Tile.Location = static_cast<TinyLocation_t>(EditorCursor.Location);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_SCENES) // Scene
    {
        if(EditorCursor.Scene.Type == 0)
            EditorCursor.Scene.Type = 1;
        EditorCursor.Location.Width = SceneWidth[EditorCursor.Scene.Type];
        EditorCursor.Location.Height = SceneHeight[EditorCursor.Scene.Type];
        EditorCursor.Scene.Location = static_cast<TinyLocation_t>(EditorCursor.Location);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_LEVELS) // Levels
    {
        if(EditorCursor.WorldLevel.Type == 0)
            EditorCursor.WorldLevel.Type = 1;
        EditorCursor.Location.Width = 32;
        EditorCursor.Location.Height = 32;
        EditorCursor.WorldLevel.Location = static_cast<TinyLocation_t>(EditorCursor.Location);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_PATHS) // Paths
    {
        if(EditorCursor.WorldPath.Type == 0)
            EditorCursor.WorldPath.Type = 1;
        EditorCursor.Location.Width = 32;
        EditorCursor.Location.Height = 32;
        EditorCursor.WorldPath.Location = static_cast<TinyLocation_t>(EditorCursor.Location);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_MUSIC) // World Music
    {
        EditorCursor.Location.Height = 32;
        EditorCursor.Location.Width = 32;
        EditorCursor.WorldMusic.Location = static_cast<TinyLocation_t>(EditorCursor.Location);
        // make it play the music
        if(g_isWorldMusicNotSame(EditorCursor.WorldMusic))
            g_playWorldMusic(EditorCursor.WorldMusic);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_AREA) // World Area
    {
        EditorCursor.Location.Height = 32;
        EditorCursor.Location.Width = 32;
        EditorCursor.WorldArea.Location.X = (int)EditorCursor.Location.X;
        EditorCursor.WorldArea.Location.Y = (int)EditorCursor.Location.Y;

        if(EditorCursor.WorldArea.Location.Width < 32)
            EditorCursor.WorldArea.Location.Width = 32;

        if(EditorCursor.WorldArea.Location.Height < 32)
            EditorCursor.WorldArea.Location.Height = 32;
    }
}

void PositionCursor()
{
//    if(EditorCursor.Mode == 4 && frmNPCs::Buried.Caption == "Yes")
//        EditorCursor.Location.Y += 16;

    if(EditorCursor.Mode == OptCursor_t::LVL_SELECT)
        return;

    if(!enableAutoAlign)
    {
        EditorCursor.Location.X += -EditorCursor.Location.Width + 4;
        EditorCursor.Location.Y += -EditorCursor.Location.Height + 12;
        return;
    }

    if(EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART)
        EditorCursor.Location.X -= 14;

    if(EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART || EditorCursor.Mode == OptCursor_t::LVL_NPCS)
    {
        if(!(EditorCursor.Mode == OptCursor_t::LVL_NPCS && EditorCursor.NPC.Type == 52))
        {
            num_t odd_width = EditorCursor.Location.Width - num_t::floor(EditorCursor.Location.Width / 32) * 32;
            num_t odd_height = EditorCursor.Location.Height - num_t::floor(EditorCursor.Location.Height / 32) * 32;

            if(odd_width != 0)
            {
                if(EditorCursor.Location.Width > 32)
                    EditorCursor.Location.X += -odd_width / 2;
                else
                    EditorCursor.Location.X += 16 - odd_width / 2;
            }

            if(odd_height != 0)
                EditorCursor.Location.Y += -odd_height;
        }
    }

    if(EditorCursor.Mode == OptCursor_t::LVL_BGOS)
    {
        if(EditorCursor.Background.Type == 13) // End level container
        {
            EditorCursor.Location.X -= 12;
            EditorCursor.Location.Y -= 12;
        }
        if(EditorCursor.Background.Type == 156 || EditorCursor.Background.Type == 157)
            EditorCursor.Location.Y += 16;
    }

    else if(EditorCursor.Mode == OptCursor_t::LVL_NPCS)
    {
        if(EditorCursor.NPC.Type == 245 || EditorCursor.NPC.Type == 8 ||
           EditorCursor.NPC.Type == 270 || EditorCursor.NPC.Type == 93 ||
           EditorCursor.NPC.Type == 180 || EditorCursor.NPC.Type == 179 ||
           EditorCursor.NPC.Type == 37 || EditorCursor.NPC.Type == 51) // Piranha Plants
            EditorCursor.Location.X += 16;
        else if(EditorCursor.NPC.Type == 197)
        {
            EditorCursor.Location.X -= 8;
            EditorCursor.Location.Y += 16;
        }

//        if(frmNPCs::Buried.Caption == "Yes")
        if(EditorCursor.NPC.Type == NPCID_ITEM_BURIED)
        {
            if(!enableAutoAlign)
                EditorCursor.Location.Y += 0/*16*/;
            else
                EditorCursor.Location.Y += 16/*32*/;
        }
        else if(EditorCursor.NPC.Type == 105)
            EditorCursor.Location.Y += 22;
        else if(EditorCursor.NPC.Type == 106)
            EditorCursor.Location.Y += 16;
        else if(EditorCursor.NPC.Type == 260)
            EditorCursor.Location.Y -= 8;
    }

    if(EditorCursor.Mode == OptCursor_t::LVL_NPCS)
    {
        if(EditorCursor.NPC->THeight < 32)
            EditorCursor.Location.Y += 32;
    }
}

void HideCursor()
{
    // printf("Hiding cursor...\n");
    EditorCursor.Location.X = vScreen[1].X - 800;
    EditorCursor.X = (int)EditorCursor.Location.X;
    EditorCursor.Location.Y = vScreen[1].Y - 600;
    EditorCursor.Y = (int)EditorCursor.Location.Y;
    HasCursor = false;
    EditorControls.ScrollDown = false;
    EditorControls.ScrollRight = false;
    SharedCursor.Primary = false;
    MouseCancel = true;
    EditorControls.ScrollLeft = false;
    EditorControls.ScrollUp = false;
    SharedCursor.GoOffscreen();
}

void KillWarp(int A)
{
    Warp_t blankWarp;
    Warp[A] = Warp[numWarps];
    Warp[numWarps] = blankWarp;
    numWarps--;
    syncLayers_Warp(A);
    syncLayers_Warp(numWarps+1);
}

void zTestLevel(bool magicHand, bool interProcess)
{
    int A = 0;
    Player_t blankPlayer;
    qScreen = false;
    qScreen_canonical = false;

#ifndef THEXTECH_INTERPROC_SUPPORTED
    UNUSED(interProcess);
#endif

    for(A = 1; A <= numCharacters; A++)
    {
        SavedChar[A] = blankPlayer;
        SavedChar[A].State = 1;
        SavedChar[A].Character = A;
    }

    if(numPlayers == 0)
        numPlayers = editorScreen.num_test_players;

    if(BattleMode && numPlayers < 2)
        numPlayers = 2;

    for(A = 1; A <= numNPCs; A++)
    {
        auto &n = NPC[A];
        // If .Generator = True Then
        n.TimeLeft = 0;
        n.Active = false;
        // End If
    }

    GamePaused = PauseCode::None;
    MessageText.clear();
//  frmNPCs::chkMessage.Value = 0;
    for(int i = 1; i <= numPlayers; i++)
    {
        BattleLives[i] = 3;
        Player[i].Hearts = 1;
    }
    BattleIntro = 150;
    BattleWinner = 0;
    BattleOutro = 0;
//  frmLevelEditor::mnuOnline.Enabled = false;
    StopMusic();
    Score = 0;
    Coins = 0;
    Lives = 3;
    g_100s = 3;

    if(Checkpoint.empty()) // Don't reset players when resume at the checkpoint
    {
        if(g_ClonedPlayerMode)
        {
            for(A = 1; A <= numPlayers; A++)
            {
                Player[A] = Player_t();
                Player[A].Hearts = testPlayer[1].Hearts;
                Player[A].State = testPlayer[1].State;
                Player[A].HeldBonus = testPlayer[1].HeldBonus;
                Player[A].Dead = false;
                Player[A].Mount = testPlayer[1].Mount;
                Player[A].MountType = testPlayer[1].MountType;
                Player[A].Character = testPlayer[1].Character;
                Player[A].UnStart = false;
                if(Player[A].Character == 0)
                    Player[A].Character = 1;
            }
        }
        else
        {
            for(A = numPlayers; A >= 1; A--)
            {
                Player[A] = Player_t();
                Player[A].Hearts = testPlayer[A].Hearts;
                Player[A].State = testPlayer[A].State;
                Player[A].HeldBonus = testPlayer[A].HeldBonus;
                Player[A].Dead = false;
                Player[A].Mount = testPlayer[A].Mount;
                Player[A].MountType = testPlayer[A].MountType;
                Player[A].Character = testPlayer[A].Character;
                if(Player[A].Character == 0)
                    Player[A].Character = A;
                SavedChar[Player[A].Character] = Player[A];
                Player[A].UnStart = false;
            }
        }

        StartWarp = testStartWarp;
    }

    LevelEditor = false;
    TestLevel = true;

    // assign players to screens
    InitScreens();
    for(A = 1; A <= numPlayers; A++)
    {
        Screens_AssignPlayer(A, *l_screen);
        if(g_ClonedPlayerMode)
            break;
    }

    UpdateInternalRes();
    XMessage::PushMessage({XMessage::Type::multiplayer_prefs, (uint8_t)g_config.two_screen_mode.m_value, (uint8_t)g_config.four_screen_mode.m_value});

    SetupPlayers();
    MagicHand = magicHand;
    FontManager::clearAllCustomFonts();

    // this clears the cached medals and stars data from the level
    LevelWarpSaveEntries.clear();

    // dead code, TestFullscreen never set
#if 0
    if(TestFullscreen)
    {
#ifndef RENDER_FULLSCREEN_ALWAYS
        ChangeScreen();
#endif
        XEvents::doEvents();
        MagicHand = false;
    }
#endif

    // in speedrun mode, confirm that controls are set up before game starts
    if((int)g_config.speedrun_mode != 0 && !Controls::Update())
    {
        ClearLevel();
        // force players offscreen
        for(int i = 1; i <= maxLocalPlayers; i++)
            Player[i].Location.X = -20000;

        LevelBeatCode = BEATCODE_SETUP;
        QuickReconnectScreen::g_active = true;
        PauseGame(PauseCode::PauseScreen);
        LevelBeatCode = BEATCODE_NONE;
    }

#ifdef THEXTECH_INTERPROC_SUPPORTED
    if(interProcess)
    {
        pLogDebug("ICP: Requesting editor for a file....");
        IntProc::sendMessage("CMD:CONNECT_TO_ENGINE");
        ElapsedTimer time;
        time.start();
        //wait for accepting of level data
        // bool timeOut = false;
        int attempts = 0;

        pLogDebug("ICP: Waiting reply....");
        IntProc::setState(g_gameStrings.ipcStatusWaitingInput);
        while(!IntProc::hasLevelData())
        {
            UpdateLoadREAL();

            //Abort loading process and exit from game if window was closed
            if(!GameIsActive)
                return;

            if(!IntProc::levelReceivingInProcess() && time.elapsed() > 1500)
            {
                pLogDebug("ICP: Waiting #%d....", attempts);
                IntProc::sendMessage("CMD:CONNECT_TO_ENGINE"); // Re-ask again
                time.restart();
                attempts += 1;
            }

            if(attempts > 4)
            {
                pLogWarning("ICP: Wait timeout");
                // timeOut = true;
                IntProc::setState(g_gameStrings.ipcStatusErrorTimeout);
                MessageText = g_gameStrings.errorIPCTimeOut;
                UpdateLoadREAL();
                g_MessageType = MESSAGE_TYPE_SYS_WARNING;
                PauseGame(PauseCode::Message);
                // PGE_Delay(1000);
                GameIsActive = false;
                return;
            }

            PGE_Delay(2);
        }

        UpdateLoadREAL();

        if(!OpenLevelData(IntProc::editor->m_acceptedLevel, IntProc::editor->m_accepted_lvl_path)) //-V560
        {
            pLogWarning("Bad file format!");
            pLogDebug("ERROR: Bad data format");
            UpdateLoadREAL();
            ReportLoadFailure("<Interprocess>", true);
            // PGE_Delay(1000);
            GameIsActive = false;
            return;
        }

        pLogDebug("ICP: Done, starting a game....");
        IntProc::setState(g_gameStrings.ipcStatusLoadingDone);
        UpdateLoadREAL();

        OpenLevelDataPost();
    }
    else
#endif // THEXTECH_INTERPROC_SUPPORTED
    {
        if(!OpenLevel(FullFileName))
        {
            ReportLoadFailure(FullFileName);
            ErrorQuit = true;
        }
    }

    // reset Drop/Add allowed characters
    ConnectScreen::SaveChars();

    int waitms = ((int)g_config.speedrun_mode != 0) ? 750 : 0;
    GameThing(waitms, 0);

    SetupScreens();
    LevelSelect = false;
    EndLevel = false;
    editorScreen.active = false;
    ReturnWarp = 0;

    EditorCursor.Mode = OptCursor_t::LVL_SELECT;
}

static constexpr int s_resize_border = 8;

template<class LocType>
static inline int s_find_flags(const LocType& loc)
{
    // require cursor to be at least nearby
    if(    EditorCursor.Location.X < loc.X - s_resize_border
        || EditorCursor.Location.X > loc.X + loc.Width + s_resize_border
        || EditorCursor.Location.Y < loc.Y - s_resize_border
        || EditorCursor.Location.Y > loc.Y + loc.Height + s_resize_border)
    {
        return 0;
    }

    int found_flags = 0;

    if(EditorCursor.Location.X < loc.X + s_resize_border)
        found_flags |= IF_ResizeL;
    else if(EditorCursor.Location.X > loc.X + loc.Width - s_resize_border)
        found_flags |= IF_ResizeR;

    if(EditorCursor.Location.Y < loc.Y + s_resize_border)
        found_flags |= IF_ResizeT;
    else if(EditorCursor.Location.Y > loc.Y + loc.Height - s_resize_border)
        found_flags |= IF_ResizeB;

    return found_flags;
}

static inline int s_find_flags_section(const IntegerLocation_t& loc)
{
    // require cursor to be at least nearby
    if(    EditorCursor.Location.X < loc.X - s_resize_border
        || EditorCursor.Location.X > loc.Width + s_resize_border
        || EditorCursor.Location.Y < loc.Y - s_resize_border
        || EditorCursor.Location.Y > loc.Height + s_resize_border)
    {
        return 0;
    }

    int found_flags = 0;

    if(EditorCursor.Location.X < loc.X + s_resize_border)
        found_flags |= IF_ResizeL;
    else if(EditorCursor.Location.X > loc.Width - s_resize_border)
        found_flags |= IF_ResizeR;

    if(EditorCursor.Location.Y < loc.Y + s_resize_border)
        found_flags |= IF_ResizeT;
    else if(EditorCursor.Location.Y > loc.Height - s_resize_border)
        found_flags |= IF_ResizeB;

    return found_flags;
}

void UpdateInteract()
{
    // only update items in select mode (mouse up or just pressed) or erase mode
    bool mouse_held = (SharedCursor.Primary && !MouseRelease);
    bool select_mode = EditorCursor.Mode == OptCursor_t::LVL_SELECT;
    bool erase_mode = EditorCursor.Mode == OptCursor_t::LVL_ERASER;

    if(select_mode && mouse_held)
        return;

    EditorCursor.InteractMode = 0;
    EditorCursor.InteractFlags = 0;
    EditorCursor.InteractIndex = 0;
    EditorCursor.InteractX = (int)EditorCursor.Location.X;
    EditorCursor.InteractY = (int)EditorCursor.Location.Y;

     if(!select_mode && !erase_mode)
        return;

    if(MouseCancel)
        return;

   // class filter for eraser
    int need_class = 0;
    if(erase_mode && EditorCursor.SubMode > 0)
        need_class = EditorCursor.SubMode;

    if(!WorldEditor)
    {
        // player start points
        if(!MagicHand && select_mode)
        {
            for(int A = 1; A <= 2; A++)
            {
                if(CursorCollision(EditorCursor.Location, PlayerStart[A]))
                {
                    EditorCursor.InteractMode = OptCursor_t::LVL_PLAYERSTART;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // NPCs
        // never sizable, so only do this if nothing found yet
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::LVL_NPCS))
        {
            for(int A : treeNPCQuery(EditorCursor.Location, SORTMODE_ID))
            {
                Location_t tempLocation = NPC[A].Location;

                if(NPC[A].Type == NPCID_ITEM_BURIED) // Herb's container offset
                    tempLocation.Y -= 16;

                if(CursorCollision(EditorCursor.Location, tempLocation) && !NPC[A].Hidden)
                {
                    EditorCursor.InteractMode = OptCursor_t::LVL_NPCS;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // non-sizable blocks (same condition)
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::LVL_BLOCKS))
        {
            for(int A : treeBlockQuery(EditorCursor.Location, SORTMODE_ID))
            {
                if(BlockIsSizable[Block[A].Type])
                    continue;

                if(CursorCollision(EditorCursor.Location, Block[A].Location) && !Block[A].Hidden)
                {
                    EditorCursor.InteractMode = OptCursor_t::LVL_BLOCKS;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // warps (now sizable)
        if(!MagicHand && ((select_mode && EditorCursor.InteractFlags < 2) || EditorCursor.InteractMode == 0) && (!need_class || need_class == OptCursor_t::LVL_WARPS))
        {
            for(int A = 1; A <= numWarps; A++)
            {
                if(Warp[A].Hidden)
                    continue;

                int entr_flags = (select_mode) ? s_find_flags(Warp[A].Entrance) : 0;
                int exit_flags = (select_mode) ? s_find_flags(Warp[A].Exit) : 0;
                if(entr_flags || (EditorCursor.InteractMode == 0 && CursorCollision(EditorCursor.Location, Warp[A].Entrance)))
                {
                    EditorCursor.InteractMode = OptCursor_t::LVL_WARPS;
                    EditorCursor.InteractFlags = entr_flags;
                    EditorCursor.InteractIndex = A;
                    break;
                }
                else if(exit_flags || (EditorCursor.InteractMode == 0 && CursorCollision(EditorCursor.Location, Warp[A].Exit)))
                {
                    EditorCursor.InteractMode = OptCursor_t::LVL_WARPS;
                    EditorCursor.InteractFlags = IF_AltMode | exit_flags;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // BGOs
        // never sizable, so only do this if nothing found yet
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::LVL_BGOS))
        {
            // more difficult to iterate backwards, but that's what we need to do here
            auto sentinel = treeBackgroundQuery(EditorCursor.Location, SORTMODE_Z);
            for(auto i = sentinel.end(); i > sentinel.begin();)
            {
                int A = *(--i);

                if(CursorCollision(EditorCursor.Location, Background[A].Location) && !Background[A].Hidden)
                {
                    EditorCursor.InteractMode = OptCursor_t::LVL_BGOS;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // Sizable blocks
        // now things get exciting
        if(((select_mode && EditorCursor.InteractFlags < 2) || EditorCursor.InteractMode == 0)
            && (!need_class || need_class == OptCursor_t::LVL_BLOCKS)) // Sizable blocks
        {
            auto sentinel = treeBlockQuery(EditorCursor.Location, SORTMODE_Z);
            for(auto i = sentinel.end(); i > sentinel.begin();)
            {
                int A = *(--i);

                if(!BlockIsSizable[Block[A].Type] || Block[A].Hidden)
                    continue;

                int found_flags = (select_mode) ? s_find_flags(Block[A].Location) : 0;

                if(found_flags || CursorCollision(EditorCursor.Location, Block[A].Location))
                {
                    if(found_flags || EditorCursor.InteractMode == 0)
                    {
                        EditorCursor.InteractMode = OptCursor_t::LVL_BLOCKS;
                        EditorCursor.InteractFlags = found_flags;
                        EditorCursor.InteractIndex = A;
                        break;
                    }
                }
            }
        }

        // Water boxes
        // can resize
        if(!MagicHand
            && ((select_mode && EditorCursor.InteractFlags < 2) || EditorCursor.InteractMode == 0)
            && (!need_class || need_class == OptCursor_t::LVL_WATER))
        {
            for(int A : treeWaterQuery(EditorCursor.Location, SORTMODE_ID))
            {
                if(Water[A].Hidden)
                    continue;

                int found_flags = (select_mode) ? s_find_flags(Water[A].Location) : 0;

                if(found_flags || CursorCollision(EditorCursor.Location, Water[A].Location))
                {
                    if(found_flags || EditorCursor.InteractMode == 0)
                    {
                        EditorCursor.InteractMode = OptCursor_t::LVL_WATER;
                        EditorCursor.InteractFlags = found_flags;
                        EditorCursor.InteractIndex = A;
                        break;
                    }
                }
            }
        }

        // event section borders
        if(!MagicHand && select_mode && EditorCursor.InteractFlags < 2)
        {
            for(int A = numEvents - 1; A >= 0; A--)
            {
                const auto& sectPos = Events[A].section[curSection].position;
                if(sectPos.X == EventSection_t::LESet_Nothing || sectPos.X == EventSection_t::LESet_ResetDefault)
                    continue;

                int found_flags = s_find_flags_section(sectPos);

                if(found_flags)
                {
                    EditorCursor.InteractMode = OptCursor_t::LVL_EVENTS;
                    EditorCursor.InteractFlags = found_flags;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // section borders
        if(!MagicHand && select_mode && EditorCursor.InteractFlags < 2)
        {
            int found_flags = s_find_flags_section(LevelREAL[curSection]);

            if(found_flags)
            {
                EditorCursor.InteractMode = OptCursor_t::LVL_SECTION;
                EditorCursor.InteractFlags = found_flags;
                EditorCursor.InteractIndex = 0;
            }
        }
    }
    else
    {
        // world map areas
        // can resize
        if(((select_mode && EditorCursor.InteractFlags < 2) || EditorCursor.InteractMode == 0)
             && (!need_class || need_class == OptCursor_t::WLD_AREA))
        {
            for(int A = numWorldAreas; A >= 1; A--)
            {
                int found_flags = (select_mode) ? s_find_flags(WorldArea[A].Location) : 0;

                // count as collision if on corner, or if in top-left
                if(found_flags || (EditorCursor.InteractMode == 0 && CursorCollision(EditorCursor.Location, newLoc(WorldArea[A].Location.X, WorldArea[A].Location.Y, 32, 32))))
                {
                    EditorCursor.InteractMode = OptCursor_t::WLD_AREA;
                    EditorCursor.InteractFlags = found_flags;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // world map music
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::WLD_MUSIC))
        {
            for(int A : treeWorldMusicQuery(static_cast<TinyLocation_t>(EditorCursor.Location), SORTMODE_NONE))
            {
                if(CursorCollision(EditorCursor.Location, WorldMusic[A].Location))
                {
                    EditorCursor.InteractMode = OptCursor_t::WLD_MUSIC;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // world paths
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::WLD_PATHS))
        {
            for(int A : treeWorldPathQuery(static_cast<TinyLocation_t>(EditorCursor.Location), SORTMODE_NONE))
            {
                if(CursorCollision(EditorCursor.Location, WorldPath[A].Location))
                {
                    EditorCursor.InteractMode = OptCursor_t::WLD_PATHS;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // world sceneries
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::WLD_SCENES))
        {
            // harder to go backwards, but that's all we're doing here.
            // it's a good thing that the sentinel's scope ends quickly,
            // otherwise it would take a long time for the result vector
            // to rejoin the pool. -- ds-sloth
            auto sentinel = treeWorldSceneQuery(static_cast<TinyLocation_t>(EditorCursor.Location), SORTMODE_ID);
            for(auto i = sentinel.end(); i > sentinel.begin();)
            {
                int A = *(--i);

                if(CursorCollision(EditorCursor.Location, Scene[A].Location))
                {
                    EditorCursor.InteractMode = OptCursor_t::WLD_SCENES;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // world levels
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::WLD_LEVELS))
        {
            for(int A : treeWorldLevelQuery(static_cast<TinyLocation_t>(EditorCursor.Location), SORTMODE_NONE))
            {
                if(CursorCollision(EditorCursor.Location, WorldLevel[A].Location))
                {
                    EditorCursor.InteractMode = OptCursor_t::WLD_LEVELS;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }

        // world tiles
        if(EditorCursor.InteractMode == 0 && (!need_class || need_class == OptCursor_t::WLD_TILES))
        {
            for(int A : treeWorldTileQuery(static_cast<TinyLocation_t>(EditorCursor.Location), SORTMODE_NONE))
            {
                if(CursorCollision(EditorCursor.Location, Tile[A].Location))
                {
                    EditorCursor.InteractMode = OptCursor_t::WLD_TILES;
                    EditorCursor.InteractFlags = 0;
                    EditorCursor.InteractIndex = A;
                    break;
                }
            }
        }
    }
}

template<class LocType>
void InteractResize(LocType& loc, int min, int snap)
{
    if(EditorCursor.InteractFlags & IF_ResizeL)
    {
        num_t dl = EditorCursor.Location.X - loc.X;
        if(dl > snap && loc.Width > min)
        {
            loc.X += snap;
            loc.Width -= snap;
            PlaySound(SFX_Saw);
        }
        else if(dl < -snap)
        {
            loc.X -= snap;
            loc.Width += snap;
            PlaySound(SFX_Saw);
        }
    }

    if(EditorCursor.InteractFlags & IF_ResizeR)
    {
        num_t dr = EditorCursor.Location.X - (loc.X + loc.Width);
        if(dr < -snap && loc.Width > min)
        {
            loc.Width -= snap;
            PlaySound(SFX_Saw);
        }
        else if(dr > snap)
        {
            loc.Width += snap;
            PlaySound(SFX_Saw);
        }
    }

    if(EditorCursor.InteractFlags & IF_ResizeT)
    {
        num_t dt = EditorCursor.Location.Y - loc.Y;
        if(dt > snap && loc.Height > min)
        {
            loc.Y += snap;
            loc.Height -= snap;
            PlaySound(SFX_Saw);
        }
        else if(dt < -snap)
        {
            loc.Y -= snap;
            loc.Height += snap;
            PlaySound(SFX_Saw);
        }
    }

    if(EditorCursor.InteractFlags & IF_ResizeB)
    {
        num_t db = EditorCursor.Location.Y - (loc.Y + loc.Height);
        if(db < -snap && loc.Height > min)
        {
            loc.Height -= snap;
            PlaySound(SFX_Saw);
        }
        else if(db > snap)
        {
            loc.Height += snap;
            PlaySound(SFX_Saw);
        }
    }
}

void InteractResizeSection(IntegerLocation_t& section)
{
    bool resized = false;

    if(EditorCursor.InteractFlags & IF_ResizeT)
    {
        int new_Y = num_t::round(EditorCursor.Location.Y / 32) * 32;
        if(section.Height - new_Y < 600)
            new_Y = section.Height - 600;

        if(new_Y != section.Y)
        {
            section.Y = new_Y;
            resized = true;
        }
    }

    if(EditorCursor.InteractFlags & IF_ResizeL)
    {
        int new_X = num_t::round(EditorCursor.Location.X / 32) * 32;
        if(section.Width - new_X < 800)
            new_X = section.Width - 800;

        if(new_X != section.X)
        {
            section.X = new_X;
            resized = true;
        }
    }

    if(EditorCursor.InteractFlags & IF_ResizeR)
    {
        int new_Width = num_t::round(EditorCursor.Location.X / 32) * 32;
        if(new_Width - section.X < 800)
            new_Width = section.X + 800;

        if(new_Width != section.Width)
        {
            section.Width = new_Width;
            resized = true;
        }
    }

    if(EditorCursor.InteractFlags & IF_ResizeB)
    {
        int new_Height = num_t::round(EditorCursor.Location.Y / 32) * 32;
        if(new_Height - section.Y < 600)
            new_Height = section.Y + 600;

        if(new_Height != section.Height)
        {
            section.Height = new_Height;
            resized = true;
        }
    }

    if(resized)
        PlaySound(SFX_Saw);
}

void MouseMove(int X, int Y, bool /*nCur*/)
{
    EditorCursor.X = X;
    EditorCursor.Y = Y;

    HasCursor = true;

    // figure out which VScreen to use
    int A = 1;
    if(SingleCoop > 0)
        A = SingleCoop;
    else if(l_screen->Type == 5 && vScreen[2].Visible)
    {
        if(X < vScreen[2].TargetX() + vScreen[2].Width)
        {
            if(X > vScreen[2].TargetX())
            {
                if(Y < vScreen[2].TargetY() + vScreen[2].Height)
                {
                    if(Y > vScreen[2].TargetY())
                        A = 2;
                }
            }
        }
    }
    else
        A = 1;

    X -= vScreen[A].TargetX();
    Y -= vScreen[A].TargetY();

    if(XRender::TargetOverscanX && WorldEditor)
        X -= XRender::TargetOverscanX;

    num_t lX = 0, lY = 0;

    // translate into layer coordinates to snap to layer's grid
    if(MagicHand && EditorCursor.Layer != LAYER_NONE)
    {
        lX = 32 - (Layer[EditorCursor.Layer].OffsetX - num_t::floor(Layer[EditorCursor.Layer].OffsetX / 32) * 32);
        lY = 32 - (Layer[EditorCursor.Layer].OffsetY - num_t::floor(Layer[EditorCursor.Layer].OffsetY / 32) * 32);
        X += (int)lX;
        Y += (int)lY;
    }

    if(EditorCursor.Mode == OptCursor_t::LVL_ERASER || EditorCursor.Mode == OptCursor_t::LVL_SELECT /*|| frmLevelEditor::chkAlign.Value == 0*/)
    {
        EditorCursor.Location.X = X - vScreen[A].X;
        EditorCursor.Location.Y = Y - vScreen[A].Y;
        PositionCursor();
    }
    else
    {
        int vScreenX = num_t::floor(vScreen[A].X / 32) * 32;
        int vScreenY = num_t::floor((vScreen[A].Y + 8) / 32) * 32 - 8;

        X += (int)(vScreenX - vScreen[A].X);
        Y += (int)(vScreenY - vScreen[A].Y);

        // 16x16 alignment
        if(
            (EditorCursor.Mode == OptCursor_t::LVL_BLOCKS &&
            (EditorCursor.Block.Type == 534 || EditorCursor.Block.Type == 535 ||
             EditorCursor.Block.Type == 536 || EditorCursor.Block.Type == 537)) ||

             EditorCursor.Mode == OptCursor_t::LVL_WARPS ||

            (EditorCursor.Mode == OptCursor_t::LVL_NPCS &&
             EditorCursor.NPC.Type == 52) ||

            (EditorCursor.Mode == OptCursor_t::LVL_BGOS &&
             (EditorCursor.Background.Type == 71 ||
              EditorCursor.Background.Type == 72 ||
              EditorCursor.Background.Type == 73 ||
              EditorCursor.Background.Type == 141 ||
              EditorCursor.Background.Type == 74 ||
              EditorCursor.Background.Type == 70 ||
              EditorCursor.Background.Type == 100)) ||

              (EditorCursor.Mode == OptCursor_t::LVL_NPCS &&
               (EditorCursor.NPC.Generator ||
                EditorCursor.NPC.Type == 209 || EditorCursor.NPC.Type == 256 ||
                EditorCursor.NPC.Type == 257 || EditorCursor.NPC.Type == 260))
        )
        {
            if(!(ffEqual(EditorCursor.Location.X, (X / 16) * 16 - vScreenX) &&
                 ffEqual(EditorCursor.Location.Y, ((Y + 8) / 16) * 16 - vScreenY - 8)) )
            {
                EditorCursor.Location.X = (X / 16) * 16 - vScreenX;
                EditorCursor.Location.Y = ((Y + 8) / 16) * 16 - vScreenY - 8;
                PositionCursor();
            }
        }
        else if(EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART)
        {
            if(!(EditorCursor.Location.X == (X / 8) * 8 - vScreenX && EditorCursor.Location.Y == (Y / 8) * 8 - vScreenY))
            {
                EditorCursor.Location.X = (X / 8) * 8 - vScreenX;
                EditorCursor.Location.Y = (Y / 8) * 8 - vScreenY;
                PositionCursor();
            }
        }
        else if(EditorCursor.Mode == OptCursor_t::WLD_SCENES)
        {
            EditorCursor.Location.X = (X / 16) * 16 - vScreenX;
            EditorCursor.Location.Y = ((Y + 8) / 16) * 16 - vScreenY - 8;
            PositionCursor();
        }
        else if(EditorCursor.Mode == OptCursor_t::LVL_WATER)
        {
            EditorCursor.Location.X = (X / 16) * 16 - vScreenX;
            EditorCursor.Location.Y = ((Y + 8) / 16) * 16 - vScreenY - 8;
            PositionCursor();
        }
        else // Everything also align as 32x32
        {
            EditorCursor.Location.X = (X / 32) * 32 - vScreenX;
            EditorCursor.Location.Y = ((Y + 8) / 32) * 32 - vScreenY - 8;
            PositionCursor();
        }
    }
//    if(nPlay.Online == true && nCur == true)
//    {
//        if(nPlay.Mode == 0)
//            Netplay::sendData "f" + std::to_string(X) - vScreenX(A) + "|" + std::to_string(Y) - vScreenY(A); // Netplay
//        else
//        {
//            SetCursor();
//            Netplay::sendData std::string("f") + "0|" + std::to_string(X) - vScreenX(A) + "|" + std::to_string(Y) - vScreenY(A); // Netplay
//        }
//    }

    // translate from layer coordinates to screen coordinates
    if(MagicHand && EditorCursor.Layer != LAYER_NONE)
    {
        EditorCursor.Location.X -= lX;
        EditorCursor.Location.Y -= lY;
    }
}

void ResetNPC(NPCID A)
{
    NPC_t blankNPC;
    NPC[0] = blankNPC;
    NPC[0].Frame = EditorNPCFrame(A, EditorCursor.NPC.Direction);
    EditorCursor.NPC.Frame = NPC[0].Frame;
    EditorCursor.NPC.FrameCount = NPC[0].FrameCount;
    NPC[0].Frame = 0;
}


================================================
FILE: src/editor/editor_custom.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>
#include <IniProcessor/ini_processing.h>
#include <Utils/files_ini.h>

#include <fmt_format_ne.h>

#include <sorting/tinysort.h>

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_assert.h"

#include "main/translate.h"

#include "editor/editor_custom.h"

#include "sound.h"

namespace EditorCustom
{

static std::vector<ItemFamily*> s_ordered_block_families;
std::vector<ItemFamily> block_families;
std::array<uint8_t, maxBlockType> block_family_by_type;
std::vector<ItemPage_t> block_pages;


static std::vector<ItemFamily*> s_ordered_bgo_families;
std::vector<ItemFamily> bgo_families;
std::array<uint8_t, maxBackgroundType> bgo_family_by_type;
std::vector<ItemPage_t> bgo_pages;


static std::vector<ItemFamily*> s_ordered_npc_families;
std::vector<ItemFamily> npc_families;
std::array<uint8_t, maxNPCType> npc_family_by_type;
std::vector<ItemPage_t> npc_pages;


static std::vector<ItemFamily*> s_ordered_tile_families;
std::vector<ItemFamily> tile_families;
std::array<uint8_t, maxTileType> tile_family_by_type;
std::vector<ItemPage_t> tile_pages;


ItemList_t sound_list;
ItemList_t music_list;
ItemList_t wmusic_list;
ItemList_t bg2_list;

std::vector<std::string> list_level_exit_names(11);

static constexpr uint8_t LOADED_ALL = 7;
uint8_t loaded = 0;


// implementation for ItemType_t
ItemType_t::ItemType_t(int type, const char* sides, slope_t slope, int width, int height, int group)
    : type(type), group(group), temp_flag(false), slope(slope), width(width), height(height)
{
    set_adj(sides);
}

void ItemType_t::set_adj(const char* sides)
{
    has_1 = false;
    has_2 = false;
    has_3 = false;
    has_4 = false;
    has_6 = false;
    has_7 = false;
    has_8 = false;
    has_9 = false;

    if(!sides)
        return;

    for(const char* c = sides; *c != '\0'; c++)
    {
        switch(*c)
        {
        case '1':
            has_1 = true;
            break;
        case '2':
            has_2 = true;
            break;
        case '3':
            has_3 = true;
            break;
        case '4':
            has_4 = true;
            break;
        case '6':
            has_6 = true;
            break;
        case '7':
            has_7 = true;
            break;
        case '8':
            has_8 = true;
            break;
        case '9':
            has_9 = true;
            break;
        default:
            break;
        }
    }
}


// implementation for LayoutPod_t
LayoutPod_t::LayoutPod_t()
{
    x = 0;
    y = 0;
    rows = 0;
    cols = 0;
}

LayoutPod_t::LayoutPod_t(int rows, int cols)
{
    x = 0;
    y = 0;
    resize(rows, cols);
}

void LayoutPod_t::resize(int _rows, int _cols)
{
    types.clear();
    types.resize(_rows * _cols);
    rows = _rows;
    cols = _cols;
}

void LayoutPod_t::compact()
{
    // the cheap one first
    for(int row = rows - 1; row >= 0; row--)
    {
        bool empty = true;
        for(int col = 0; col < cols; col++)
        {
            if(types[row * cols + col])
            {
                empty = false;
                break;
            }
        }

        if(empty)
        {
            types.erase(types.begin() + row * cols, types.begin() + (row + 1) * cols);
            rows--;
        }
    }

    // the expensive one second
    for(int col = cols - 1; col >= 0; col--)
    {
        bool empty = true;
        for(int row = 0; row < rows; row++)
        {
            if(types[row * cols + col])
            {
                empty = false;
                break;
            }
        }

        if(empty)
        {
            for(int row = 0; row < rows; row++)
            {
                for(int col2 = 0; col2 < cols; col2++)
                {
                    // before col-erase, shift everything back [row] elements
                    if(col2 < col)
                        types[row * (cols - 1) + col2] = types[row * cols + col2];
                    // after, shift everything back [row + 1] elements
                    else if(col2 > col)
                        types[row * (cols - 1) + col2 - 1] = types[row * cols + col2];
                }
            }

            cols--;
            types.resize(rows * cols);
        }
    }
}

// implementation for ItemFamily
void ItemFamily::make_layout_pods()
{
    if(is_misc && req_layout_pods.empty())
        return;

    temp_layout_pods.clear();

    for(const LayoutPod_t& pod : req_layout_pods)
    {
        for(int type : pod.types)
        {
            for(ItemType_t& t2 : types)
            {
                if(t2.type == type)
                    t2.temp_flag = true;
            }
        }

        temp_layout_pods.push_back(pod);
    }

    LayoutPod_t current_pod_external;
    LayoutPod_t current_pod_internal;
    LayoutPod_t current_pod_hstrip;
    LayoutPod_t current_pod_vstrip;

    LayoutPod_t trash_pod;

    bool types_left = true;

    // default-initializes to the standard (no group, no slope, width/height 1)
    ItemType_t current_exemplar;

    while(types_left)
    {
        types_left = false;

        if(current_exemplar.slope == ItemType_t::no_slope)
            current_pod_external.resize(3, 3);
        else
            current_pod_external.resize(2, 2);

        current_pod_internal.resize(2, 2);
        current_pod_hstrip.resize(1, 3);
        current_pod_vstrip.resize(3, 1);

        for(ItemType_t& t : types)
        {
            if(t.group != current_exemplar.group || t.slope != current_exemplar.slope
                || t.width != current_exemplar.width || t.height != current_exemplar.height)
            {
                continue;
            }

            if(t.temp_flag)
                continue;

            t.temp_flag = true;
            for(ItemType_t& t2 : types)
            {
                if(t2.type == t.type)
                    t2.temp_flag = true;
            }

            int* pos = nullptr;

            // 4 tiles in the internal pod
            // bottomright
            if(t.has_1 && t.has_2 && !t.has_3 && t.has_4 && t.has_6 && t.has_7 && t.has_8 && t.has_9)
                pos = &current_pod_internal.types[3];
            // bottomleft
            else if(!t.has_1 && t.has_2 && t.has_3 && t.has_4 && t.has_6 && t.has_7 && t.has_8 && t.has_9)
                pos = &current_pod_internal.types[2];
            // topright
            else if(t.has_1 && t.has_2 && t.has_3 && t.has_4 && t.has_6 && t.has_7 && t.has_8 && !t.has_9)
                pos = &current_pod_internal.types[1];
            // topleft
            else if(t.has_1 && t.has_2 && t.has_3 && t.has_4 && t.has_6 && !t.has_7 && t.has_8 && t.has_9)
                pos = &current_pod_internal.types[0];

            if(!pos && current_exemplar.slope == ItemType_t::no_slope)
            {
                // 9 tiles in the external pod

                // topleft
                if(!t.has_1 && t.has_2 && t.has_3 && !t.has_4 && t.has_6 && !t.has_7 && !t.has_8 && !t.has_9)
                    pos = &current_pod_external.types[0];
                // top
                else if(t.has_1 && t.has_2 && t.has_3 && t.has_4 && t.has_6 && !t.has_7 && !t.has_8 && !t.has_9)
                    pos = &current_pod_external.types[1];
                // topright
                else if(t.has_1 && t.has_2 && !t.has_3 && t.has_4 && !t.has_6 && !t.has_7 && !t.has_8 && !t.has_9)
                    pos = &current_pod_external.types[2];
                // midleft
                else if(!t.has_1 && t.has_2 && t.has_3 && !t.has_4 && t.has_6 && !t.has_7 && t.has_8 && t.has_9)
                    pos = &current_pod_external.types[3];
                // mid
                else if(t.has_1 && t.has_2 && t.has_3 && t.has_4 && t.has_6 && t.has_7 && t.has_8 && t.has_9)
                    pos = &current_pod_external.types[4];
                // midright
                else if(t.has_1 && t.has_2 && !t.has_3 && t.has_4 && !t.has_6 && t.has_7 && t.has_8 && !t.has_9)
                    pos = &current_pod_external.types[5];
                // bottomleft
                else if(!t.has_1 && !t.has_2 && !t.has_3 && !t.has_4 && t.has_6 && !t.has_7 && t.has_8 && t.has_9)
                    pos = &current_pod_external.types[6];
                // bottom
                else if(!t.has_1 && !t.has_2 && !t.has_3 && t.has_4 && t.has_6 && t.has_7 && t.has_8 && t.has_9)
                    pos = &current_pod_external.types[7];
                // bottomright
                else if(!t.has_1 && !t.has_2 && !t.has_3 && t.has_4 && !t.has_6 && t.has_7 && t.has_8 && !t.has_9)
                    pos = &current_pod_external.types[8];

                // 3 tiles in the horizontal strip pod
                // left
                else if(!t.has_1 && !t.has_2 && !t.has_3 && !t.has_4 && t.has_6 && !t.has_7 && !t.has_8 && !t.has_9)
                    pos = &current_pod_hstrip.types[0];
                // center
                else if(!t.has_1 && !t.has_2 && !t.has_3 && t.has_4 && t.has_6 && !t.has_7 && !t.has_8 && !t.has_9)
                    pos = &current_pod_hstrip.types[1];
                // right
                else if(!t.has_1 && !t.has_2 && !t.has_3 && t.has_4 && !t.has_6 && !t.has_7 && !t.has_8 && !t.has_9)
                    pos = &current_pod_hstrip.types[2];

                // 3 tiles in the vertical strip pod
                // top
                else if(!t.has_1 && t.has_2 && !t.has_3 && !t.has_4 && !t.has_6 && !t.has_7 && !t.has_8 && !t.has_9)
                    pos = &current_pod_vstrip.types[0];
                // center
                else if(!t.has_1 && t.has_2 && !t.has_3 && !t.has_4 && !t.has_6 && !t.has_7 && t.has_8 && !t.has_9)
                    pos = &current_pod_vstrip.types[1];
                // bottom
                else if(!t.has_1 && !t.has_2 && !t.has_3 && !t.has_4 && !t.has_6 && !t.has_7 && t.has_8 && !t.has_9)
                    pos = &current_pod_vstrip.types[2];
            }
            else if(!pos)
            {
                // topleft
                if(t.has_2 && t.has_3 && !t.has_4 && t.has_6 && !t.has_7 && !t.has_8)
                    pos = &current_pod_external.types[0];
                // topright
                else if(t.has_1 && t.has_2 && t.has_4 && !t.has_6 && !t.has_8 && !t.has_9)
                    pos = &current_pod_external.types[1];
                // bottomleft
                else if(!t.has_1 && !t.has_2 && !t.has_4 && t.has_6 && t.has_8 && t.has_9)
                    pos = &current_pod_external.types[2];
                // bottomright
                else if(!t.has_2 && !t.has_3 && t.has_4 && !t.has_6 && t.has_7 && t.has_8)
                    pos = &current_pod_external.types[3];
            }

            if(pos && *pos == 0)
                *pos = t.type;
            else
                trash_pod.types.push_back(t.type);
        }

        // find a new exemplar (can't do this during, since temp_flag is set for some during)
        for(ItemType_t& t : types)
        {
            if(t.group != current_exemplar.group || t.slope != current_exemplar.slope
                || t.width != current_exemplar.width || t.height != current_exemplar.height)
            {
                if(!t.temp_flag)
                {
                    current_exemplar = t;
                    types_left = true;
                    break;
                }
            }
        }

        current_pod_external.compact();
        if(!current_pod_external.types.empty())
            temp_layout_pods.push_back(current_pod_external);

        current_pod_internal.compact();
        if(!current_pod_internal.types.empty())
            temp_layout_pods.push_back(current_pod_internal);

        current_pod_hstrip.compact();
        if(!current_pod_hstrip.types.empty())
            temp_layout_pods.push_back(current_pod_hstrip);

        current_pod_vstrip.compact();
        if(!current_pod_vstrip.types.empty())
            temp_layout_pods.push_back(current_pod_vstrip);
    }

    trash_pod.rows = 1;
    trash_pod.cols = (int)trash_pod.types.size();

    // order the pods by size
    tinysort(temp_layout_pods.begin(), temp_layout_pods.end(),
    [](const LayoutPod_t& a, const LayoutPod_t& b)
    {
        return a.rows > b.rows || (a.rows == b.rows && a.cols > b.cols);
    });

    if(!trash_pod.types.empty())
    {
        for(int t : trash_pod.types)
        {
            temp_layout_pods.push_back(LayoutPod_t(1, 1));
            temp_layout_pods[temp_layout_pods.size() - 1].types[0] = t;
        }
    }

    for(ItemType_t& t : types)
        t.temp_flag = false;
}

bool ItemFamily::make_layout(int layout_width)
{
    if(temp_layout_pods.empty())
    {
        layout_pod.resize((int)types.size() / layout_width + 1, layout_width);

        layout_pod.types.resize(0);
        for(ItemType_t t : types)
            layout_pod.types.push_back(t.type);
        layout_pod.types.resize((types.size() / layout_width + 1) * layout_width);

        layout_pod.compact();

        return true;
    }

    // make a layout using these pods
    // place them where they fit
    layout_pod.resize(3, layout_width);

    for(LayoutPod_t& pod : temp_layout_pods)
    {
        int x, y;

        bool okay = false;

        int prows = pod.rows;
        int pcols = pod.cols;

        // rotate if needed
        if(layout_width < pcols && prows == 1)
        {
            prows = pcols;
            pcols = 1;
        }


        for(y = 0; y < 10; y++)
        {
            for(x = 0; x + pcols <= layout_width; x++)
            {
                if(y + prows > layout_pod.rows)
                {
                    layout_pod.rows = y + prows;
                    layout_pod.types.resize(layout_pod.rows * layout_pod.cols);
                }

                okay = true;
                for(int y2 = 0; y2 < prows; y2++)
                {
                    for(int x2 = 0; x2 < pcols; x2++)
                    {
                        if(layout_pod.types[(y + y2) * layout_pod.cols + (x + x2)])
                        {
                            okay = false;
                            break;
                        }
                    }
                    if(!okay)
                        break;
                }

                if(okay)
                    break;
            }
            if(okay)
                break;
        }

        if(!okay)
        {
            layout_pod.resize(types.size() / layout_width + 1, layout_width);
            return false;
        }

        for(int y2 = 0; y2 < prows; y2++)
        {
            for(int x2 = 0; x2 < pcols; x2++)
                layout_pod.types[(y + y2) * layout_pod.cols + (x + x2)] = pod.types[y2 * pcols + x2];
        }
    }

    layout_pod.compact();

    return true;
}


// implementation for ItemList_t

void ItemList_t::make_layout(int rows)
{
    // first, remove any existing padding
    for(int i = (int)indices.size() - 1; i >= 0; i--)
    {
        if(indices[i] == -1 && names[i].empty())
        {
            indices.erase(indices.begin() + i);
            names.erase(names.begin() + i);
        }
    }

    // now, add any padding needed
    for(size_t i = 0; i < indices.size(); i++)
    {
        if(indices[i] == -1 && !names[i].empty() && (i + 1) % rows == 0)
        {
            indices.insert(indices.begin() + i, -1);
            names.insert(names.begin() + i, std::string());
        }
    }
}

void ItemList_t::make_translation(XTechTranslate& translate, const char* group, const char* prefix, const std::vector<std::pair<ListItemFamily_t, std::string>>& families)
{
    int header = -1;

    for(size_t i = 0; i < indices.size(); i++)
    {
        if(indices[i] != -1)
        {
            if(header < 0)
                XTechTranslate::insert(translate.m_assetsMap, fmt::sprintf_ne("editor.%s.auto.%s%d", group, prefix, (int)indices[i]), &names[i]);
            else if(header < (int)families.size())
                XTechTranslate::insert(translate.m_assetsMap, fmt::sprintf_ne("editor.%s.%s.%s%d", group, families[header].second.c_str(), prefix, (int)indices[i]), &names[i]);
            else
                XTechTranslate::insert(translate.m_assetsMap, fmt::sprintf_ne("editor.%s.fam%d.%s%d", group, header, prefix, (int)indices[i]), &names[i]);
        }
        else if(!names[i].empty())
        {
            header++;

            if(header < (int)families.size())
                XTechTranslate::insert(translate.m_assetsMap, fmt::sprintf_ne("editor.%s.%s.header", group, families[header].second.c_str()), &names[i]);
            else
                XTechTranslate::insert(translate.m_assetsMap, fmt::sprintf_ne("editor.%s.fam%d.header", group, header), &names[i]);
        }
    }
}


// general-purpose layout functions

std::vector<ItemFamily*>::iterator make_page(std::vector<ItemFamily*>::iterator begin, std::vector<ItemFamily*>::iterator end,
    int width, int height)
{
    tinysort(begin, end,
    [](const ItemFamily* a, const ItemFamily* b)
    {
        return a->category < b->category
            || (a->category == b->category &&
                a->types.size() > b->types.size());
    });

    int page_category = -1;

    // row - half row, because of titles
    int start_section_row = 0;
    int current_row = 0;
    int main_width = width;

    std::vector<std::array<int, 4>> lost_margins;

    auto unplaced = begin;
    auto orig_end = end;

    while(unplaced != end)
    {
        ItemFamily& family = **unplaced;

        if(page_category == -1)
            page_category = family.category;
        else if(family.category != page_category)
            break;

        bool okay = false;

        if(current_row != start_section_row)
        {
            // try to fill a margin, if it exists
            okay = family.make_layout(width - main_width - 1);
            int r_height = family.layout_pod.rows * 2 + 1;

            if(okay && r_height <= current_row - start_section_row)
            {
                int min_width = family.layout_pod.cols;
                int min_height = family.layout_pod.rows;
                while(min_width > 1)
                {
                    min_width--;
                    okay = family.make_layout(min_width);
                    if(!okay || family.layout_pod.rows > min_height)
                    {
                        min_width++;
                        okay = family.make_layout(min_width);
                        break;
                    }
                }
                r_height = family.layout_pod.rows * 2 + 1;

                family.X = main_width + 1;
                family.Y = start_section_row;

                int margin_size_tall = (width - main_width - 1) * (current_row - start_section_row - r_height);
                int margin_size_wide = (width - main_width - family.layout_pod.cols - 2) * (current_row - start_section_row);

                // pick the bigger continued margin
                if(margin_size_tall >= margin_size_wide)
                {
                    lost_margins.push_back({start_section_row, current_row, main_width + family.layout_pod.cols + 2, width});
                    start_section_row += r_height;
                }
                else
                {
                    lost_margins.push_back({start_section_row + r_height, current_row, main_width + 1, main_width + 1 + family.layout_pod.cols});
                    main_width += family.layout_pod.cols + 1;
                }

                ++unplaced;
                continue;
            }

            // we'll be below the margin

            // pick whether to fill the row (use width) or keep the margin (use main_width)
            family.make_layout(width);
            int height_full = family.layout_pod.rows * 2 + 1;

            okay = family.make_layout(main_width);
            int height_main = family.layout_pod.rows * 2 + 1;

            int margin_size = (width - main_width - 1) * (current_row - start_section_row);

            if(!okay || height_main * main_width > height_full * width + margin_size)
            {
                // discard the margin
                // (added to lost margins later)
                okay = family.make_layout(width);
            }
        }
        else
        {
            okay = family.make_layout(width);
        }

        // figure out the minimum height and width at which it gets this height
        int min_height = family.layout_pod.rows;

        // skip if we can't fit it
        if((!okay || current_row + (min_height * 2 + 1) > height * 2) && current_row != 0)
        {
            std::rotate(unplaced, unplaced + 1, end);
            end--;
            continue;
        }
        // if there isn't enough room for another one below, allow it to be taller
        else if(current_row + (min_height * 2 + 1) + 4 == height * 2)
        {
            min_height += 2;
        }
        // if there isn't enough room for another one below, allow it to be taller
        else if(current_row + (min_height * 2 + 1) + 3 == height * 2)
        {
            min_height++;
        }
        // if there isn't enough room for another one below, allow it to be taller
        else if(current_row + (min_height * 2 + 1) + 2 == height * 2)
        {
            min_height++;
        }

        int min_width = family.layout_pod.cols;
        while(min_width > 1)
        {
            min_width--;
            okay = family.make_layout(min_width);
            if(!okay || family.layout_pod.rows > min_height)
            {
                min_width++;
                okay = family.make_layout(min_width);
                break;
            }
        }

        min_height = family.layout_pod.rows;

        // convert to half-rows, add title
        min_height = min_height * 2 + 1;

        family.X = 0;
        family.Y = current_row;

        // consume the entire rows
        if(min_width >= width - 1)
        {
            if(current_row != start_section_row)
                lost_margins.push_back({start_section_row, current_row, main_width + 1, width});

            current_row += min_height;
            start_section_row = current_row;
            main_width = width;
        }
        // start a margin
        else if(current_row == start_section_row)
        {
            current_row += min_height;
            main_width = min_width;
        }
        // decide what happens to the margin
        else
        {
            // pick the bigger continued margin, or just cancel
            int margin_size_tall = (width - main_width - 1) * (min_height + current_row - start_section_row);
            int margin_size_wide = (width - min_width - 1) * (min_height);

            // just cancel
            // if(margin_size_tall < 4 && margin_size_wide < 4)
            // {
            //     current_row += min_height;
            //     start_section_row = current_row;
            //     main_width = width;
            // }
            // make a wide margin, starting on the current row
            if(margin_size_wide >= margin_size_tall)
            {
                lost_margins.push_back({start_section_row, current_row, main_width + 1, width});

                start_section_row = current_row;
                current_row += min_height;
                main_width = min_width;
            }
            // make a tall margin, keeping start row and width the same
            else
            {
                if(min_width + 1 != main_width)
                    lost_margins.push_back({current_row, current_row + min_height, min_width + 1, main_width});

                current_row += min_height;
            }
        }

        ++unplaced;
    }

    // try to fill lost margins if possible
    if(current_row != start_section_row)
    {
        lost_margins.push_back({start_section_row, height * 2, main_width + 1, width});
    }

    // grow lost margins to screen height
    for(auto& i: lost_margins)
    {
        if(i[1] == current_row)
            i[1] = height * 2;
    }

    // grow any combined margins
    tinysort(lost_margins.begin(), lost_margins.end(),
    [](const std::array<int, 4>& a, const std::array<int, 4>& b)
    {
        return a[2] < b[2];
    });

    for(auto& i : lost_margins)
    {
        for(auto& j : lost_margins)
        {
            if((i[3] == j[2] || i[3] + 1 == j[2]) && i[0] == j[0] && i[1] == j[1])
            {
                i[3] = j[3];
                j[2] = j[3] + 1;
            }
        }
    }

    tinysort(lost_margins.begin(), lost_margins.end(),
    [](const std::array<int, 4>& a, const std::array<int, 4>& b)
    {
        return a[0] < b[0];
    });

    for(auto& i : lost_margins)
    {
        for(auto& j : lost_margins)
        {
            if(i[1] == j[0] && i[2] == j[2] && i[3] == j[3])
            {
                i[1] = j[1];
                j[0] = j[1];
            }
        }
    }

    // remove bad lost margins
    for(size_t x = 0; x < lost_margins.size(); x++)
    {
        const auto& i = lost_margins[x];
        if((i[1] - i[0]) < 3 || (i[3] - i[2]) < 1)
        {
            lost_margins[x] = lost_margins[lost_margins.size() - 1];
            lost_margins.resize(lost_margins.size() - 1);
        }
    }

    // do it!
    end = orig_end;

    tinysort(unplaced, end,
    [](const ItemFamily* a, const ItemFamily* b)
    {
        return a->category < b->category
            || (a->category == b->category &&
                (a->is_misc < b->is_misc
                    || (a->is_misc == b->is_misc && a->types.size() > b->types.size())));
    });

    while(unplaced != end)
    {
        ItemFamily& family = **unplaced;

        if(family.category != page_category)
            break;

        bool placed = false;

        tinysort(lost_margins.begin(), lost_margins.end(),
        [](const std::array<int, 4>& a, const std::array<int, 4>& b)
        {
            return ((a[1] - a[0]) * (a[3] - a[2])) < ((b[1] - b[0]) * (b[3] - b[2]));
        });

        for(size_t x = 0; x < lost_margins.size(); x++)
        {
            auto i = lost_margins[x];
            if((i[1] - i[0]) * (i[3] - i[2]) < (int)family.types.size() * 2)
                continue;

            bool okay = family.make_layout(i[3] - i[2]);

            if(!okay || family.layout_pod.rows * 2 + 1 > i[1] - i[0])
                continue;

            int min_height = family.layout_pod.rows;
            int min_width = family.layout_pod.cols;
            while(min_width > 1)
            {
                min_width--;
                okay = family.make_layout(min_width);
                if(!okay || family.layout_pod.rows > min_height)
                {
                    min_width++;
                    okay = family.make_layout(min_width);
                    break;
                }
            }

            family.X = i[2];
            family.Y = i[0];

            if(family.layout_pod.cols + 1 < i[3] - i[2])
                lost_margins.push_back({i[0], i[1], i[2] + family.layout_pod.cols + 1, i[3]});

            if(family.layout_pod.rows * 2 + 1 < i[1] - i[0])
                lost_margins.push_back({i[0] + family.layout_pod.rows * 2 + 1, i[1], i[2], i[3]});

            lost_margins[x] = lost_margins[lost_margins.size() - 1];
            lost_margins.resize(lost_margins.size() - 1);

            placed = true;
            break;
        }

        if(!placed)
        {
            std::rotate(unplaced, unplaced + 1, end);
            end--;
            continue;
        }

        ++unplaced;
    }

    return unplaced;
}

void make_pages(std::vector<ItemFamily*>& families, std::vector<ItemPage_t>& pages, int width, int height)
{
    pages.clear();

    auto unplaced = families.begin();

    while(unplaced != families.end())
    {
        auto unplaced_new = make_page(unplaced, families.end(), width, height);

        if(unplaced_new == unplaced)
        {
            pLogCritical("Block page layout algorithm failed.");
            break;
        }

        pages.emplace_back();
        ItemPage_t& new_page = pages[pages.size() - 1];
        new_page.begin = unplaced;
        new_page.end = unplaced_new;
        new_page.category = (**unplaced).category;
        new_page.icon = 0;

        // find icon if one of the families has a custom icon
        for(auto f = new_page.begin; f != new_page.end; f++)
        {
            if((**f).icon)
            {
                new_page.icon = (**f).icon;
                break;
            }
        }

        for(auto f = new_page.begin; f != new_page.end; ++f)
        {
            // find icon if none of the families has a custom icon
            if(!new_page.icon && !(**f).types.empty())
                new_page.icon = (**f).types[0].type;

            // add reference to page
            (**f).page = (int8_t)pages.size();
        }

        // don't generate fully empty page
        if(!new_page.icon)
            pages.pop_back();

        unplaced = unplaced_new;
    }
}


void Load(XTechTranslate* translate)
{
    block_families.clear();
    bgo_families.clear();
    npc_families.clear();
    tile_families.clear();

    sound_list.clear();
    music_list.clear();
    wmusic_list.clear();
    bg2_list.clear();

    loaded = 0;


    pLogDebug("Loading editor.ini...");

    IniProcessing editor = Files::load_ini(AppPath + "editor.ini");

    std::vector<int> temp_ints;
    std::vector<int> temp_layout_pod_indices;
    std::string temp_str;

    // will be added to the global list and then destroyed
    std::vector<std::pair<ListItemFamily_t, std::string>> sound_families;
    std::vector<std::pair<ListItemFamily_t, std::string>> music_families;
    std::vector<std::pair<ListItemFamily_t, std::string>> wmusic_families;
    std::vector<std::pair<ListItemFamily_t, std::string>> bg2_families;

    // needed to form the translations correctly
    std::vector<std::string> block_family_keys;
    std::vector<std::string> bgo_family_keys;
    std::vector<std::string> npc_family_keys;
    std::vector<std::string> tile_family_keys;

    for(const std::string& group : editor.childGroups())
    {
        ItemFamily* f_ptr = nullptr;
        ListItemFamily_t* l_ptr = nullptr;
        const char* prefix = "";
        int prefix_length = 3;
        int max_item_type = 0;
        bool has_slope = false;

        if(SDL_strncasecmp(group.c_str(), "blkfam", 6) == 0)
        {
            block_families.emplace_back();
            f_ptr = &block_families[block_families.size() - 1];
            prefix = "blk";
            max_item_type = maxBlockType;
            has_slope = true;
            block_family_keys.push_back(group.c_str() + prefix_length);
        }
        else if(SDL_strncasecmp(group.c_str(), "bgofam", 6) == 0)
        {
            bgo_families.emplace_back();
            f_ptr = &bgo_families[bgo_families.size() - 1];
            prefix = "bgo";
            max_item_type = maxBackgroundType;
            bgo_family_keys.push_back(group.c_str() + prefix_length);
        }
        else if(SDL_strncasecmp(group.c_str(), "npcfam", 6) == 0)
        {
            npc_families.emplace_back();
            f_ptr = &npc_families[npc_families.size() - 1];
            prefix = "npc";
            max_item_type = maxNPCType;
            npc_family_keys.push_back(group.c_str() + prefix_length);
        }
        else if(SDL_strncasecmp(group.c_str(), "tilefam", 7) == 0)
        {
            tile_families.emplace_back();
            f_ptr = &tile_families[tile_families.size() - 1];
            prefix = "tile";
            prefix_length = 4;
            max_item_type = maxTileType;
            tile_family_keys.push_back(group.c_str() + prefix_length);
        }
        else if(SDL_strncasecmp(group.c_str(), "sndfam", 6) == 0)
        {
            sound_families.emplace_back();
            l_ptr = &sound_families[sound_families.size() - 1].first;
            prefix = "snd";
            sound_families[sound_families.size() - 1].second = group.c_str() + prefix_length;
        }
        else if(SDL_strncasecmp(group.c_str(), "musfam", 6) == 0)
        {
            music_families.emplace_back();
            l_ptr = &music_families[music_families.size() - 1].first;
            prefix = "mus";
            music_families[music_families.size() - 1].second = group.c_str() + prefix_length;
        }
        else if(SDL_strncasecmp(group.c_str(), "wmusfam", 7) == 0)
        {
            wmusic_families.emplace_back();
            l_ptr = &wmusic_families[wmusic_families.size() - 1].first;
            prefix = "wmus";
            prefix_length = 4;
            wmusic_families[wmusic_families.size() - 1].second = group.c_str() + prefix_length;
        }
        else if(SDL_strncasecmp(group.c_str(), "bg2fam", 6) == 0)
        {
            bg2_families.emplace_back();
            l_ptr = &bg2_families[bg2_families.size() - 1].first;
            prefix = "bg2";
            bg2_families[bg2_families.size() - 1].second = group.c_str() + prefix_length;
        }
        else if(SDL_strcasecmp(group.c_str(), "exit-codes") == 0)
        {
            // handled above to ensure we get failsafes
        }
        else
        {
            pLogWarning("Ignoring invalid group %s.", group.c_str());
        }

        // handling for Lists
        if(l_ptr)
        {
            editor.beginGroup(group);

            ListItemFamily_t& f = *l_ptr;

            editor.read("name", f.name, "...");
            editor.read("sort-index", f.sort_index, 0);

            temp_ints.clear();
            editor.read("members", temp_ints, temp_ints);
            for(int i : temp_ints)
            {
                if(i > 0 && i <= 127)
                {
                    f.indices.push_back(i);
                    f.names.push_back(fmt::sprintf_ne("%s %d", prefix, i));
                }
            }

            for(const std::string& key : editor.allKeys())
            {
                if(SDL_strncasecmp(key.c_str(), "name", 4) == 0)
                    continue;

                if(SDL_strncasecmp(key.c_str(), "sort-index", 10) == 0)
                    continue;

                if(SDL_strncasecmp(key.c_str(), "members", 7) == 0)
                    continue;

                if(SDL_strncasecmp(key.c_str(), prefix, prefix_length) != 0)
                {
                    pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                    continue;
                }

                const char* startptr = key.c_str() + prefix_length;

                const char* endptr;

                int i = strtol(startptr, const_cast<char**>(&endptr), 0);
                if(endptr == startptr)
                {
                    pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                    continue;
                }

                if(i < 0)
                    i = -i;

                if(i < 1 || i > 127)
                {
                    pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                    continue;
                }

                if(*endptr == '\0')
                {
                    pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                    continue;
                }
                if(*endptr == '-')
                    endptr++;

                if(SDL_strncasecmp(endptr, "name", 4) != 0)
                {
                    pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                    continue;
                }

                // find the item
                std::string* str = nullptr;
                for(size_t ind = 0; ind < f.indices.size(); ind++)
                {
                    if(f.indices[ind] == i)
                    {
                        str = &f.names[ind];
                        break;
                    }
                }

                if(!str)
                {
                    f.indices.push_back(i);
                    f.names.push_back(fmt::sprintf_ne("%s %d", prefix, i));
                    str = &f.names[f.names.size() - 1];
                }

                editor.read(key.c_str(), *str, *str);
            }
        }

        // handling for ordinary Families
        if(f_ptr)
        {
            temp_layout_pod_indices.clear();

            editor.beginGroup(group);

            ItemFamily& f = *f_ptr;

            editor.read("name", f.name, "");

            int temp_int;
            editor.read("category", temp_int, 0);
            if(temp_int > -128 && temp_int < 128)
            {
                f.category = temp_int;
            }
            else
            {
                f.category = 0;
                pLogWarning("Ignoring invalid category index %d for family %s (max 127)", temp_int, f.name.c_str());
            }

            editor.read("icon", temp_int, 0);
            if(temp_int >= 0 && temp_int <= max_item_type)
            {
                f.icon = temp_int;
            }
            else
            {
                f.icon = 0;
                pLogWarning("Ignoring invalid icon %d for family %s (max %d)", temp_int, f.name.c_str(), max_item_type);
            }

            f.is_misc = true;

            temp_ints.clear();
            editor.read("members", temp_ints, temp_ints);
            for(int i : temp_ints)
            {
                if(i > 0 && i <= max_item_type)
                    f.types.push_back(ItemType_t(i));
            }

            // first pass for the blocks, second pass to add alternate group and adj values
            for(int alt = 0; alt < 2; alt++)
            {
                for(const std::string& key : editor.allKeys())
                {
                    if(SDL_strncasecmp(key.c_str(), "name", 4) == 0)
                        continue;

                    if(SDL_strncasecmp(key.c_str(), "cate", 4) == 0)
                        continue;

                    if(SDL_strncasecmp(key.c_str(), "memb", 4) == 0)
                        continue;

                    if(SDL_strncasecmp(key.c_str(), "misc", 4) == 0)
                        continue;

                    if(SDL_strncasecmp(key.c_str(), "icon", 4) == 0)
                        continue;

                    if(SDL_strncasecmp(key.c_str(), "behi", 4) == 0)
                        continue;

                    bool pod_mode = false;

                    if(SDL_strncasecmp(key.c_str(), "pod", 3) == 0)
                    {
                        if(alt)
                            continue;
                        else
                            pod_mode = true;
                    }
                    else if(SDL_strncasecmp(key.c_str(), prefix, prefix_length) != 0)
                    {
                        pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                        continue;
                    }

                    const char* startptr = key.c_str() + prefix_length;
                    if(pod_mode)
                        startptr = key.c_str() + 3;

                    const char* endptr;

                    int i = strtol(startptr, const_cast<char**>(&endptr), 0);
                    if(endptr == startptr)
                    {
                        pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                        continue;
                    }

                    if(i < 0)
                        i = -i;

                    if(!pod_mode && (i < 1 || i > max_item_type))
                        continue;

                    if(*endptr == '\0')
                    {
                        pLogWarning("Ignoring invalid key %s in family %s", key.c_str(), group.c_str());
                        continue;
                    }
                    if(*endptr == '-')
                        endptr++;

                    // handle pods
                    if(pod_mode)
                    {
                        size_t ind;
                        for(ind = 0; ind < temp_layout_pod_indices.size(); ind++)
                        {
                            if(temp_layout_pod_indices[ind] == i)
                                break;
                        }

                        if(ind == temp_layout_pod_indices.size())
                        {
                            temp_layout_pod_indices.push_back(i);
                            f.req_layout_pods.emplace_back();
                        }

                        LayoutPod_t& pod = f.req_layout_pods[ind];

                        if(SDL_strncasecmp(endptr, "mem", 3) == 0)
                        {
                            pod.types.clear();
                            editor.read(key.c_str(), pod.types, pod.types);
                            for(int j : pod.types)
                            {
                                // add to family types if needed
                                if(j > 0 && j <= max_item_type)
                                {
                                    bool found = false;
                                    for(ItemType_t& t_i : f.types)
                                    {
                                        if(t_i.type == j)
                                        {
                                            found = true;
                                            break;
                                        }
                                    }
                                    if(!found)
                                        f.types.push_back(ItemType_t(j));
                                }
                            }

                            if(pod.cols <= 0)
                                pod.cols = 4;

                            pod.rows = (pod.types.size() - 1) / pod.cols + 1;
                            pod.types.resize(pod.rows * pod.cols);
                        }
                        else if(SDL_strncasecmp(endptr, "col", 3) == 0 || SDL_strncasecmp(endptr, "wid", 3) == 0)
                        {
                            int old_cols = pod.cols;

                            editor.read(key.c_str(), pod.cols, pod.cols);

                            if(pod.cols <= 0)
                                pod.cols = old_cols;

                            if(!pod.types.empty() && pod.cols > 0)
                            {
                                pod.rows = pod.types.size() / pod.cols + 1;
                                pod.types.resize(pod.rows * pod.cols);
                            }
                        }
                        else
                        {
                            pLogWarning("Ignoring group %s key %s", group.c_str(), key.c_str());
                            continue;
                        }

                        continue;
                    }

                    // deal with these in the second pass
                    if(SDL_strncasecmp(endptr, "alt", 3) == 0)
                    {
                        if(alt)
                        {
                            endptr += 3;

                            if(*endptr == '\0')
                            {
                                pLogWarning("Ignoring invalid key %s", key.c_str());
                                continue;
                            }
                            if(*endptr == '-')
                                endptr++;
                        }
                        else
                            continue;
                    }
                    else if(alt)
                    {
                        continue;
                    }

                    // find the item
                    ItemType_t* t = nullptr;
                    for(ItemType_t& t_i : f.types)
                    {
                        if(t_i.type == i)
                        {
                            t = &t_i;
                            break;
                        }
                    }

                    if(alt)
                    {
                        if(!t)
                        {
                            pLogWarning("Ignoring alt key %s for non-existent item %d", key.c_str(), i);
                            continue;
                        }
                        else
                        {
                            // add a copy to the end of the array
                            f.types.push_back(*t);
                            t = &f.types[f.types.size() - 1];
                        }
                    }
                    else if(!t)
                    {
                        f.types.push_back(ItemType_t(i));
                        t = &f.types[f.types.size() - 1];
                    }

                    if(SDL_strncasecmp(endptr, "adj", 3) == 0)
                    {
                        f.is_misc = false;

                        editor.read(key.c_str(), temp_str, "");
                        t->set_adj(temp_str.c_str());
                    }
                    else if(SDL_strncasecmp(endptr, "gr", 2) == 0)
                    {
                        int temp;
                        editor.read(key.c_str(), temp, 1);
                        if(temp < 0 || temp >= 16)
                            pLogWarning("Ignoring invalid group %d for item %d (max 15)", temp, i);
                        else
                            t->group = temp;
                    }
                    else if(has_slope && SDL_strncasecmp(endptr, "sl", 2) == 0)
                    {
                        int temp;
                        editor.read(key.c_str(), temp, 0);

                        switch(temp)
                        {
                        case 0:
                            t->slope = ItemType_t::no_slope;
                            break;
                        case 1:
                            t->slope = ItemType_t::slope_1;
                            break;
                        case 2:
                            t->slope = ItemType_t::slope_2;
                            break;
                        case 4:
                            t->slope = ItemType_t::slope_4;
                            break;
                        default:
                            pLogWarning("Ignoring invalid slope %d for item %d", temp, i);
                        }
                    }
                    else if(alt)
                    {
                        pLogWarning("Ignoring invalid alt key %s", key.c_str());
                        continue;
                    }
                    else if(SDL_strncasecmp(endptr, "w", 1) == 0)
                    {
                        int temp;
                        editor.read(key.c_str(), temp, 1);
                        if(temp < 0 || temp >= 8)
                            pLogWarning("Ignoring invalid width %d for item %d (max 7)", temp, i);
                        else
                            t->width = temp;
                    }
                    else if(SDL_strncasecmp(endptr, "h", 1) == 0)
                    {
                        int temp;
                        editor.read(key.c_str(), temp, 1);
                        if(temp < 0 || temp >= 8)
                            pLogWarning("Ignoring invalid height %d for item %d (max 7)", temp, i);
                        else
                            t->height = temp;
                    }
                    else
                    {
                        pLogWarning("Ignoring invalid key %s for item %d in family %s", key.c_str(), i, group.c_str());
                    }
                }
            }

#if 0
            for(ItemType_t& t : f.types)
            {
                printf("Itemtype %d (gp %d, slope %d, wh %d%d)", t.type, t.group, (int)t.slope, t.width, t.height);
                printf(" adj ");
                if(t.has_1) printf("1");
                if(t.has_2) printf("2");
                if(t.has_3) printf("3");
                if(t.has_4) printf("4");
                if(t.has_6) printf("6");
                if(t.has_7) printf("7");
                if(t.has_8) printf("8");
                if(t.has_9) printf("9");
                printf("\n");
            }
#endif

            editor.read("misc", f.is_misc, f.is_misc);
            editor.read("behind", f.behind_mode, false);
            f.make_layout_pods();
        }
    }

    // Process exit codes
    editor.beginGroup("exit-codes");

    editor.read("any", list_level_exit_names[0], "Any");
    editor.read("none", list_level_exit_names[1], "None");

    XTechTranslate::insert(translate->m_assetsMap, fmt::sprintf_ne("editor.exit-codes.%s", "any"), &(list_level_exit_names[0]));
    XTechTranslate::insert(translate->m_assetsMap, fmt::sprintf_ne("editor.exit-codes.%s", "none"), &(list_level_exit_names[1]));

    for(size_t i = 1; i + 1 < list_level_exit_names.size(); i++)
    {
        const std::string s = fmt::sprintf_ne("code%zu", i);
        editor.read(s.c_str(), list_level_exit_names[i + 1], s);
        XTechTranslate::insert(translate->m_assetsMap, fmt::sprintf_ne("editor.exit-codes.%zu", i), &(list_level_exit_names[i + 1]));
    }

    editor.endGroup();


    // process Blocks
    if(!block_families.empty())
        loaded++;

    s_ordered_block_families.clear();
    for(ItemFamily& family : block_families)
    {
        s_ordered_block_families.push_back(&family);
    }

    make_pages(s_ordered_block_families, block_pages, 11, 11);

    for(int i = 0; i < maxBlockType; i++)
    {
        block_family_by_type[i] = FAMILY_NONE;
    }

    SDL_assert_release(block_families.size() < 255); // Max of uint8_t

    for(uint8_t family = (uint8_t)block_families.size() - 1; family != FAMILY_NONE; family--)
    {
        for(ItemType_t t : block_families[family].types)
            block_family_by_type[t.type - 1] = family;
    }

    bool blocks_begun = false;
    for(int i = maxBlockType - 1; i >= 0; i--)
    {
        if(block_family_by_type[i] != FAMILY_NONE)
            blocks_begun = true;
        else if(blocks_begun)
            pLogWarning("Can't find family for block type %d", i + 1);
    }

    // add Blocks to translations
    if(translate)
    {
        for(uint8_t i = 0; i < block_families.size(); i++)
            XTechTranslate::insert(translate->m_assetsMap, fmt::sprintf_ne("editor.block.%s", block_family_keys[i].c_str()), &(block_families[i].name));
    }


    // process BGOs
    if(!bgo_families.empty())
        loaded++;

    s_ordered_bgo_families.clear();
    for(ItemFamily& family : bgo_families)
    {
        s_ordered_bgo_families.push_back(&family);
    }

    make_pages(s_ordered_bgo_families, bgo_pages, 11, 11);

    for(int i = 0; i < maxBackgroundType; i++)
    {
        bgo_family_by_type[i] = FAMILY_NONE;
    }

    SDL_assert_release(bgo_families.size() < 255); // Max of uint8_t

    for(uint8_t family = (uint8_t)bgo_families.size() - 1; family != FAMILY_NONE; family--)
    {
        for(ItemType_t t : bgo_families[family].types)
            bgo_family_by_type[t.type - 1] = family;
    }

    bool bgos_begun = false;
    for(int i = maxBackgroundType - 1; i >= 0; i--)
    {
        if(bgo_family_by_type[i] != FAMILY_NONE)
            bgos_begun = true;
        // don't worry about locked types
        else if(bgos_begun && i + 1 != 160 && i + 1 != 98)
            pLogWarning("Can't find family for BGO type %d", i + 1);
    }

    // add BGOs to translations
    if(translate)
    {
        for(uint8_t i = 0; i < bgo_families.size(); i++)
            XTechTranslate::insert(translate->m_assetsMap, fmt::sprintf_ne("editor.bgo.%s", bgo_family_keys[i].c_str()), &(bgo_families[i].name));
    }


    // process NPCs
    if(!npc_families.empty())
        loaded++;

    s_ordered_npc_families.clear();
    for(ItemFamily& family : npc_families)
    {
        s_ordered_npc_families.push_back(&family);
    }

    make_pages(s_ordered_npc_families, npc_pages, 10, 11);

    // Not an off-by-one error, this is zero-indexed
    for(int i = 0; i < maxNPCType; i++)
    {
        npc_family_by_type[i] = FAMILY_NONE;
    }

    SDL_assert_release(npc_families.size() < 255); // Max of uint8_t

    for(uint8_t family = (uint8_t)npc_families.size() - 1; family != FAMILY_NONE; family--)
    {
        for(ItemType_t t : npc_families[family].types)
            npc_family_by_type[t.type - 1] = family;
    }

#if 0
    // no warnings for NPCs because many are not included

    bool npcs_begun = false;
    for(int i = maxNPCType - 1; i >= 0; i--)
    {
        if(npc_family_by_type[i] != FAMILY_NONE)
            npcs_begun = true;
        else if(npcs_begun)
            pLogWarning("Can't find family for NPC type %d", i + 1);
    }
#endif

    // add NPCs to translations
    if(translate)
    {
        for(uint8_t i = 0; i < npc_families.size(); i++)
            XTechTranslate::insert(translate->m_assetsMap, fmt::sprintf_ne("editor.npc.%s", npc_family_keys[i].c_str()), &(npc_families[i].name));
    }


    // process tiles
    if(!tile_families.empty())
        loaded++;

    s_ordered_tile_families.clear();
    for(ItemFamily& family : tile_families)
    {
        s_ordered_tile_families.push_back(&family);
    }

    make_pages(s_ordered_tile_families, tile_pages, 15, 11);

    for(int i = 0; i < maxTileType; i++)
    {
        tile_family_by_type[i] = FAMILY_NONE;
    }

    SDL_assert_release(tile_families.size() < 255); // Max of uint8_t

    for(uint8_t family = (uint8_t)tile_families.size() - 1; family != FAMILY_NONE; family--)
    {
        for(ItemType_t t : tile_families[family].types)
            tile_family_by_type[t.type - 1] = family;
    }

    bool tiles_begun = false;
    for(int i = maxTileType - 1; i >= 0; i--)
    {
        if(tile_family_by_type[i] != FAMILY_NONE)
            tiles_begun = true;
        else if(tiles_begun)
            pLogWarning("Can't find family for tile type %d", i + 1);
    }

    // add tiles to translations
    if(translate)
    {
        for(uint8_t i = 0; i < tile_families.size(); i++)
            XTechTranslate::insert(translate->m_assetsMap, fmt::sprintf_ne("editor.tile.%s", tile_family_keys[i].c_str()), &(tile_families[i].name));
    }


    // process bg2s
    if(!bg2_families.empty())
    {
        loaded++;

        tinysort(bg2_families.begin(), bg2_families.end(),
        [](const std::pair<ListItemFamily_t, std::string>& a, const std::pair<ListItemFamily_t, std::string>& b)
        {
            return a.first.sort_index < b.first.sort_index;
        });

        size_t length = 1;
        for(const std::pair<ListItemFamily_t, std::string>& p : bg2_families)
        {
            const ListItemFamily_t& f = p.first;
            length += 1 + f.indices.size();
        }

        bg2_list.indices.reserve(length);
        bg2_list.names.reserve(length);

        bg2_list.indices.push_back(0);
        bg2_list.names.push_back("None");

        for(std::pair<ListItemFamily_t, std::string>& p : bg2_families)
        {
            ListItemFamily_t& f = p.first;

            bg2_list.indices.push_back(-1);
            bg2_list.names.push_back(std::move(f.name));

            for(const int16_t i : f.indices)
                bg2_list.indices.push_back(i);

            for(std::string& s : f.names)
                bg2_list.names.push_back(std::move(s));
        }

        bg2_list.make_layout(10);

        // add to translation engine
        if(translate)
            bg2_list.make_translation(*translate, "background2", "bg2-", bg2_families);
    }


    // process music
    if(!music_families.empty())
    {
        loaded++;

        tinysort(music_families.begin(), music_families.end(),
        [](const std::pair<ListItemFamily_t, std::string>& a, const std::pair<ListItemFamily_t, std::string>& b)
        {
            return a.first.sort_index < b.first.sort_index;
        });

        size_t length = 2;
        for(const std::pair<ListItemFamily_t, std::string>& p : music_families)
        {
            const ListItemFamily_t& f = p.first;
            length += 1 + f.indices.size();
        }

        music_list.indices.reserve(length);
        music_list.names.reserve(length);

        music_list.indices.push_back(0);
        music_list.names.push_back("None");

        music_list.indices.push_back(24);
        music_list.names.push_back("Custom");

        for(std::pair<ListItemFamily_t, std::string>& p : music_families)
        {
            ListItemFamily_t& f = p.first;

            music_list.indices.push_back(-1);
            music_list.names.push_back(std::move(f.name));

            for(const int16_t i : f.indices)
                music_list.indices.push_back(i);

            for(std::string& s : f.names)
                music_list.names.push_back(std::move(s));
        }

        music_list.make_layout(10);

        // add to translation engine
        if(translate)
            music_list.make_translation(*translate, "music", "music", music_families);
    }

    // process world music
    if(!wmusic_families.empty())
    {
        tinysort(wmusic_families.begin(), wmusic_families.end(),
        [](const std::pair<ListItemFamily_t, std::string>& a, const std::pair<ListItemFamily_t, std::string>& b)
        {
            return a.first.sort_index < b.first.sort_index;
        });

        size_t length = 1;
        for(const std::pair<ListItemFamily_t, std::string>& p : wmusic_families)
        {
            const ListItemFamily_t& f = p.first;
            length += 1 + f.indices.size();
        }

        wmusic_list.indices.reserve(length);
        wmusic_list.names.reserve(length);

        wmusic_list.indices.push_back(0);
        wmusic_list.names.push_back("None");

        for(std::pair<ListItemFamily_t, std::string>& p : wmusic_families)
        {
            ListItemFamily_t& f = p.first;

            wmusic_list.indices.push_back(-1);
            wmusic_list.names.push_back(std::move(f.name));

            for(const int16_t i : f.indices)
                wmusic_list.indices.push_back(i);

            for(std::string& s : f.names)
                wmusic_list.names.push_back(std::move(s));
        }

        wmusic_list.make_layout(10);

        // add to translation engine
        if(translate)
            wmusic_list.make_translation(*translate, "worldMusic", "wmusic", wmusic_families);
    }

    // process sounds
    if(!sound_families.empty())
    {
        loaded++;

        tinysort(sound_families.begin(), sound_families.end(),
        [](const std::pair<ListItemFamily_t, std::string>& a, const std::pair<ListItemFamily_t, std::string>& b)
        {
            return a.first.sort_index < b.first.sort_index;
        });

        size_t length = 1;
        for(const std::pair<ListItemFamily_t, std::string>& p : sound_families)
        {
            const ListItemFamily_t& f = p.first;
            length += 1 + f.indices.size();
        }

        sound_list.indices.reserve(length);
        sound_list.names.reserve(length);

        sound_list.indices.push_back(0);
        sound_list.names.push_back("None");

        for(std::pair<ListItemFamily_t, std::string>& p : sound_families)
        {
            ListItemFamily_t& f = p.first;

            sound_list.indices.push_back(-1);
            sound_list.names.push_back(std::move(f.name));

            for(const int16_t i : f.indices)
                sound_list.indices.push_back(i);

            for(std::string& s : f.names)
                sound_list.names.push_back(std::move(s));
        }

        sound_list.make_layout(10);

        // add to translation engine
        if(translate)
            sound_list.make_translation(*translate, "sound", "sound", sound_families);
    }

    // report loading status
    if(loaded == 0)
        pLogWarning("Could not load editor.ini, editor disabled");
    else if(loaded < LOADED_ALL)
        pLogWarning("editor.ini seems incomplete");
}

} // namespace EditorCustom


================================================
FILE: src/editor/editor_custom.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef EDITOR_CUSTOM_H
#define EDITOR_CUSTOM_H

#include <vector>
#include <array>

#include "globals.h"


class XTechTranslate;


namespace EditorCustom
{

struct ItemType_t
{
    enum slope_t
    {
        no_slope = 0,
        slope_1 = 1,
        slope_2 = 2,
        slope_4 = 3
    };

    int type : 11;
    int group : 4;
    bool temp_flag : 1;

    // uses numpad coordinates
    bool has_1 : 1;
    bool has_2 : 1;
    bool has_3 : 1;
    bool has_4 : 1;
    bool has_6 : 1;
    bool has_7 : 1;
    bool has_8 : 1;
    bool has_9 : 1;

    slope_t slope : 2;
    unsigned width : 3;
    unsigned height : 3;

    ItemType_t(int type = 0, const char* sides = nullptr, slope_t slope = no_slope, int width = 1, int height = 1, int special = 0);

    void set_adj(const char* sides);
};

struct LayoutPod_t
{
    std::vector<int> types;
    int x;
    int y;
    int rows;
    int cols;

    LayoutPod_t();
    LayoutPod_t(int rows, int cols);
    void resize(int rows, int cols);
    void compact();
};

class ItemFamily
{
public:
    // user-supplied
    std::string name;

    std::vector<ItemType_t> types;
    std::vector<LayoutPod_t> req_layout_pods;

    // automatically generated
    std::vector<LayoutPod_t> temp_layout_pods;
    LayoutPod_t layout_pod;

    int8_t page = 0;
    int8_t X = 0;
    int8_t Y = 0;

    // user-supplied
    int16_t icon = 0;
    int8_t category = 0;
    bool is_misc = true;
    bool behind_mode = false;


    void make_layout_pods();
    bool make_layout(int layout_width);
};

struct ItemPage_t
{
    std::vector<ItemFamily*>::iterator begin;
    std::vector<ItemFamily*>::iterator end;

    int16_t icon;
    int8_t category;
};

struct ListItemFamily_t
{
    std::string name;
    int sort_index = 0;

    std::vector<int16_t> indices;
    std::vector<std::string> names;
};

struct ItemList_t
{
    std::vector<int16_t> indices;
    std::vector<std::string> names;

    inline void clear()
    {
        indices.clear();
        names.clear();
    }

    void make_layout(int rows);

    void make_translation(XTechTranslate& translate, const char* group, const char* prefix, const std::vector<std::pair<ListItemFamily_t, std::string>>& families);
};

void Load(XTechTranslate* translate = nullptr);

constexpr uint8_t PAGE_NONE = 255;
constexpr uint8_t FAMILY_NONE = 255;

extern std::vector<ItemFamily> block_families;
extern std::vector<ItemPage_t> block_pages;
extern std::array<uint8_t, maxBlockType> block_family_by_type;


extern std::vector<ItemFamily> bgo_families;
extern std::vector<ItemPage_t> bgo_pages;
extern std::array<uint8_t, maxBackgroundType> bgo_family_by_type;

extern std::vector<ItemFamily> npc_families;
extern std::vector<ItemPage_t> npc_pages;
extern std::array<uint8_t, maxNPCType> npc_family_by_type;

extern std::vector<ItemFamily> tile_families;
extern std::vector<ItemPage_t> tile_pages;
extern std::array<uint8_t, maxTileType> tile_family_by_type;


extern ItemList_t sound_list;
extern ItemList_t music_list;
extern ItemList_t wmusic_list;
extern ItemList_t bg2_list;


// has fixed size of 10
extern std::vector<std::string> list_level_exit_names;


// tracks loading state
extern uint8_t loaded;

} // namespace EditorCustom

#endif // EDITOR_CUSTOM_H


================================================
FILE: src/editor/editor_strings.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "editor/editor_strings.h"

EditorContent g_editorStrings;

void initEditorStrings()
{
    g_editorStrings.phraseAreYouSure = "Are you sure?";
    g_editorStrings.pageBlankOfBlank = "Page {0} of {1}";

    g_editorStrings.pickBlockContents = "Pick block contents";

    g_editorStrings.blockLetterWidth  = "W ";
    g_editorStrings.blockLetterHeight = "H ";
    g_editorStrings.blockCanBreak = "Can Break";
    g_editorStrings.blockTooltipCanBreak = "Legacy: breaks when hit";
    g_editorStrings.blockSlick = "Slick";
    g_editorStrings.blockInvis = "Invis";
    g_editorStrings.blockInside = "Inside:";

    g_editorStrings.warpTitle = "Warp Settings";
    g_editorStrings.warpPlacing = "Placing:";
    g_editorStrings.warpIn = "In";
    g_editorStrings.warpOut = "Out";
    g_editorStrings.warpDir = "Dir.";
    g_editorStrings.warpTwoWay = "Two-Way";
    g_editorStrings.warpStyle = "Style: ";
    g_editorStrings.warpStylePipe = "Pipe";
    g_editorStrings.warpStyleDoor = "Door";
    g_editorStrings.warpStyleBlipInstant = "Blip";
    g_editorStrings.warpStylePortal = "Port";
    g_editorStrings.warpEffect = "Effect:";
    g_editorStrings.warpAllow = "Allow:";
    g_editorStrings.warpItem = "Item";
    g_editorStrings.warpRide = "Ride";
    g_editorStrings.warpCannonExit = "Cannon Exit";
    g_editorStrings.warpSpeed = "Speed ";
    g_editorStrings.warpNeedStarCount = "Need {0} {1}";
    g_editorStrings.warpNeedKey = "Need Key";
    g_editorStrings.warpNeedFloor = "Need Floor";
    g_editorStrings.warpStarLockMessage = "Star lock msg";
    g_editorStrings.warpToMap = "To Map";
    g_editorStrings.warpLvlWarp = "Lvl Warp";
    g_editorStrings.warpTarget = "Target: ";
    g_editorStrings.warpTo = "To: {0}";
    g_editorStrings.warpShowStartScene = "Show Start Scene";
    g_editorStrings.warpShowStarCount = "Show Star Count";

    g_editorStrings.waterTitle = "Water Settings";

    g_editorStrings.npcInContainer = "In";
    g_editorStrings.npcInertNice = "Nice";
    g_editorStrings.npcStuckStop = "Stop";
    g_editorStrings.npcAbbrevGen = "Gen";
    g_editorStrings.npcPropertyActive = "Active";
    g_editorStrings.npcPropertyAttachSurface = "Attach";
    g_editorStrings.npcPropertyFacing = "Facing";

    g_editorStrings.npcAiIs = "AI: {0}";
    g_editorStrings.npcAiTarget = "Target";
    g_editorStrings.npcAiJump = "Jump";
    g_editorStrings.npcAiLeap = "Leap";
    g_editorStrings.npcAiSwim = "Swim";
    g_editorStrings.npcAiLR = "LR";
    g_editorStrings.npcAiUD = "UD";

    g_editorStrings.npcCustomAi = "Custom AI:";

    g_editorStrings.npcUse1_0Ai = "Use 1.0 AI?";
    g_editorStrings.npcTooltipExpandSection = "Expand section";

    g_editorStrings.npcGenHeader = "Generator Settings";
    g_editorStrings.npcGenDirection = "Direction";
    g_editorStrings.npcGenEffectIs = "Effect: {0}";
    g_editorStrings.npcGenEffectWarp = "Warp";
    g_editorStrings.npcGenEffectShoot = "Shoot";

    g_editorStrings.wordNPC = "NPC";
    g_editorStrings.wordNPCGenitive = "NPC";

    g_editorStrings.wordEvent = "Event";
    g_editorStrings.wordEventGenitive = "Event";
    g_editorStrings.phraseTypeLabelEvent = "{0} Event:";

    g_editorStrings.wordCoins = "Coins";

    g_editorStrings.wordEnabled = "Enabled";
    g_editorStrings.wordText = "Text";
    g_editorStrings.wordInstant = "Instant";
    g_editorStrings.wordMode = "Mode";
    g_editorStrings.wordHeight = "Height";
    g_editorStrings.wordWidth = "Width";

    g_editorStrings.labelSortLayer = "Sort Layer:";
    g_editorStrings.labelSortOffset = "Sort Offset:";

    g_editorStrings.phraseTextOf = "{0} Text";
    g_editorStrings.phraseSectionIndex = "Section {0}";
    g_editorStrings.phraseRadiusIndex = "Radius {0}";
    g_editorStrings.phraseWarpIndex = "Warp {0}";
    g_editorStrings.phraseGenericIndex = "Number {0}";
    g_editorStrings.phraseCountMore = "{0} More";
    g_editorStrings.phraseDelayIsMs = "Delay: {0} ms";
    g_editorStrings.mapPos = "Map Pos:";

    g_editorStrings.letterUp = "U";
    g_editorStrings.letterDown = "D";
    g_editorStrings.letterLeft = "L";
    g_editorStrings.letterRight = "R";
    g_editorStrings.letterCoordX = "X";
    g_editorStrings.letterCoordY = "Y";

    g_editorStrings.toggleMagicBlock = "Magic Block";

    g_editorStrings.testMagicHand = "Magic Hand";
    g_editorStrings.testChar = "Char";
    g_editorStrings.testPower = "Power";
    g_editorStrings.testBoot = "Boot";
    g_editorStrings.testPet = "Pet";

    g_editorStrings.eventsHeader = "Events:";

    g_editorStrings.eventsLetterActivate = "A:";
    g_editorStrings.eventsLetterDeath = "D:";
    g_editorStrings.eventsLetterTalk = "T:";
    g_editorStrings.eventsLetterLayerClear = "L:";
    g_editorStrings.eventsLetterHit = "H:";
    g_editorStrings.eventsLetterDestroy = "D:";
    g_editorStrings.eventsLetterEnter = "E:";

    g_editorStrings.eventsLabelNext = "Next";
    g_editorStrings.eventsLabelActivate = "Activate";
    g_editorStrings.eventsLabelDeath = "Death";
    g_editorStrings.eventsLabelTalk = "Talk";
    g_editorStrings.eventsLabelLayerClear = "Layer Clear";
    g_editorStrings.eventsLabelHit = "Hit";
    g_editorStrings.eventsLabelDestroy = "Destroy";
    g_editorStrings.eventsLabelEnter = "Enter";

    g_editorStrings.eventsDescActivate = "NPC enters the screen";
    g_editorStrings.eventsDescDeath = "NPC dies";
    g_editorStrings.eventsDescTalk = "player talks to NPC";
    g_editorStrings.eventsDescLayerClear = "everything in object layer is gone";
    g_editorStrings.eventsDescHit = "block is hit";
    g_editorStrings.eventsDescDestroy = "block is destroyed";
    g_editorStrings.eventsDescEnter = "warp is entered";

    g_editorStrings.eventsDescPhraseTriggersWhenTemplate = "{0} triggers when {1}";
    g_editorStrings.eventsDescPhraseTriggersAfterTemplate = "{0} triggers {1} ms after event {2} occurs";

    g_editorStrings.eventsDeletingEvent = "Deleting event {0}";
    g_editorStrings.eventsDeletionConfirm = "Yes: delete event";
    g_editorStrings.eventsDeletionCancel = "No: do not delete event";

    g_editorStrings.eventsPromptEventText = "Event text";
    g_editorStrings.eventsPromptEventName = "Event name";
    g_editorStrings.eventsItemNewEvent = "<New Event>";

    g_editorStrings.eventsControlsForEvent = "Controls for event {0}";
    g_editorStrings.eventsSettingsForEvent = "Settings for event";
    g_editorStrings.eventsHeaderShow = "Show:";
    g_editorStrings.eventsHeaderHide = "Hide:";
    g_editorStrings.eventsHeaderToggle = "Toggle:";
    g_editorStrings.eventsHeaderMove = "Move:";

    g_editorStrings.eventsActionKeep = "Keep";
    g_editorStrings.eventsActionReset = "Reset";
    g_editorStrings.eventsActionSet = "Set";

    g_editorStrings.eventsCaseMusic = "Music";
    g_editorStrings.eventsCaseBackground = "BG";
    g_editorStrings.eventsCaseBounds = "Bounds";

    g_editorStrings.eventsPhraseAllSections = "All Sections";

    g_editorStrings.eventsPropAutostart = "Autostart";
    g_editorStrings.eventsPropSound = "Sound";
    g_editorStrings.eventsPropEndGame = "End Game";
    g_editorStrings.eventsPropControls = "Controls";
    g_editorStrings.eventsPropLayerSmoke = "Smoke";

    g_editorStrings.eventsHeaderTriggerEvent = "Trigger:";

    g_editorStrings.levelName = "Level Name";
    g_editorStrings.levelStartPos = "Start Pos";
    g_editorStrings.levelPathBG = "Path BG";
    g_editorStrings.levelBigBG = "Big BG";
    g_editorStrings.levelGameStart = "Game Start";
    g_editorStrings.levelAlwaysVis = "Always Vis";
    g_editorStrings.levelPathUnlocks = "Path Unlocks";

    g_editorStrings.sectionScroll = "Scroll";
    g_editorStrings.sectionHorizWrap = "Horiz. Wrap";
    g_editorStrings.sectionVertWrap = "Vert. Wrap";
    g_editorStrings.sectionUnderwater = "Underwater";
    g_editorStrings.sectionNoTurnBack = "No Turn Back";
    g_editorStrings.sectionOffscreenExit = "Offscreen Exit";

    g_editorStrings.worldName = "World Name";
    g_editorStrings.worldIntroLevel = "Intro Level";
    g_editorStrings.worldHubWorld = "Hub World";
    g_editorStrings.worldRetryOnFail = "Retry On Fail";
    g_editorStrings.worldTotalStars = "Total Stars: ";
    g_editorStrings.worldAllowChars = "Allow Chars";
    g_editorStrings.worldCreditIndex = "World Credit Line {0}:";

    g_editorStrings.selectSoundForEvent = "Sound for Event {0}";
    g_editorStrings.selectSectBlankPropBlankForEvent = "Sect {0} {1} for {2}";
    g_editorStrings.selectAllSectPropBlankForEvent = "All Sect {0} for {1}";
    g_editorStrings.selectSectionBlankPropBlank = "Section {0} {1}";
    g_editorStrings.selectPathBlankUnlock = "Path {0} Unlock By";
    g_editorStrings.selectWarpTransitionEffect = "Warp Transition Effect";
    g_editorStrings.selectWorldMusic = "World Music";

    g_editorStrings.layersHeader = "Layers:";

    g_editorStrings.labelLayer = "Layer:";
    g_editorStrings.layersLabelAttached = "Attached:";
    g_editorStrings.layersAbbrevAttLayer = "Att: ";
    g_editorStrings.layersLayerDefault = "Default";

    g_editorStrings.layersLabelAttachedLayer = "Attached Layer:";
    g_editorStrings.layersLabelMoveLayer = "Move Layer:";

    g_editorStrings.layersDeletionHeader = "Deleting layer {0}";
    g_editorStrings.layersDeletionPreserveLayerContents = "Preserve layer contents?";
    g_editorStrings.layersDeletionConfirmPreserve = "Yes: move to default layer";
    g_editorStrings.layersDeletionConfirmDelete = "No: *DELETE ALL CONTENTS*";
    g_editorStrings.layersDeletionCancel = "Cancel: do not delete layer";

    g_editorStrings.layersDescAtt = "Whenever the NPC moves, the attached layer moves following it";

    g_editorStrings.layersPromptLayerName = "Layer name";
    g_editorStrings.layersItemNewLayer = "<New Layer>";

    g_editorStrings.fileActionClearLevel = "Clear Level";
    g_editorStrings.fileActionClearWorld = "Clear World";
    g_editorStrings.fileActionOpen = "Open";
    g_editorStrings.fileActionRevert = "Revert";
    g_editorStrings.fileActionExit = "Exit";
    g_editorStrings.fileConfirmationSaveBeforeAction = "Save before you {0}?";
    g_editorStrings.fileConfirmationConfirmAction = "Are you sure you want to {0}?";
    g_editorStrings.fileConfirmationConvertFormatTo = "Convert format to {0}?";
    g_editorStrings.fileOptionYesSaveThenAction = "Yes: save then {0}";
    g_editorStrings.fileOptionActionWithoutSave = "{0} without saving";
    g_editorStrings.fileOptionCancelAction = "Cancel: do not {0}";
    g_editorStrings.fileOptionProceedWithConversion = "Proceed with conversion";
    g_editorStrings.fileOptionCancelConversion = "Cancel conversion";

    g_editorStrings.fileLabelCurrentFile = "Current file: ";
    g_editorStrings.fileLabelFormat = "Format:";

    g_editorStrings.fileFormatModern = "Modern";
    g_editorStrings.fileFormatLegacy = "Legacy";

    g_editorStrings.fileSectionLevel = "Level";
    g_editorStrings.fileSectionWorld = "World";
    g_editorStrings.fileCommandNew = "New";
    g_editorStrings.fileCommandOpen = "Open...";
    g_editorStrings.fileCommandSave = "Save";
    g_editorStrings.fileCommandSaveAs = "Save as...";

    g_editorStrings.fileConvertDesc = "The file extension will change but the old file will NOT be deleted.\n\nPlease check for lost features after saving.";

#if 0
    g_editorStrings.fileConvert38aUnsupported = "The SMBX38-A format is not supported for conversion.";
    g_editorStrings.fileConvertFormatUnknown = "Requested format is unknown.";

    g_editorStrings.fileConvertFeatureWarpTransit = "A warp uses new transition effect.";
    g_editorStrings.fileConvertFeatureWarpNeedsStand = "A warp requires player to stand.";
    g_editorStrings.fileConvertFeatureWarpCannonExit = "A warp has the cannon exit effect.";
    g_editorStrings.fileConvertFeatureWarpEnterEvent = "A warp triggers an event on entry.";
    g_editorStrings.fileConvertFeatureWarpCustomStarsMsg = "A warp has a custom stars message.";
    g_editorStrings.fileConvertFeatureWarpNoPrintStars = "A warp hides target level stars.";
    g_editorStrings.fileConvertFeatureWarpNoStartScene = "A level warp skips the start scene.";
    g_editorStrings.fileConvertFeatureWarpPortal = "A warp uses the portal effect.";

    g_editorStrings.fileConvertFeatureEventCustomMusic = "An event sets music to a file.";
    g_editorStrings.fileConvertFeatureEventAutoscroll = "An event uses modern autoscroll.";

    g_editorStrings.fileConvertFeatureNPCVariant = "An NPC uses a behavior variant.";
    g_editorStrings.fileConvertFeatureBlockForceSmashable = "A spin block uses legacy smash.";
    g_editorStrings.fileConvertFeatureBgoOrder = "A BGO uses custom draw order.";

    g_editorStrings.fileConvertFeatureCustomWorldMusic = "Uses custom world music file.";
    g_editorStrings.fileConvertFeatureWorldStarDisplay = "Uses world setting for star display.";
    g_editorStrings.fileConvertFeatureLevelStarDisplay = "A level uses setting for star display.";
    g_editorStrings.fileConvertFeatureWorldMapSections = "The world includes world map sections.";
#endif

    g_editorStrings.browserNewFile = "New file";
    g_editorStrings.browserSaveFile = "Save file";
    g_editorStrings.browserOpenFile = "Open file";

    g_editorStrings.browserItemNewFile = "<New File>";
    g_editorStrings.browserItemNewFolder = "<New Folder>";

    g_editorStrings.browserAskOverwriteFile = "Overwrite {0}?";

    g_editorStrings.tooltipSelect = "Select";
    g_editorStrings.tooltipErase = "Erase";
    g_editorStrings.tooltipEraseAll = "Erase All";
    g_editorStrings.tooltipBlocks = "Blocks";
    g_editorStrings.tooltipBGOs = "BGOs";
    g_editorStrings.tooltipNPCs = "NPCs";
    g_editorStrings.tooltipWarps = "Warps";
    g_editorStrings.tooltipWater = "Water";
    g_editorStrings.tooltipSettings = "Settings";
    g_editorStrings.tooltipLayers = "Layers";
    g_editorStrings.tooltipEvents = "Events";
    g_editorStrings.tooltipTiles = "Tiles";
    g_editorStrings.tooltipScenes = "Scenes";
    g_editorStrings.tooltipLevels = "Levels";
    g_editorStrings.tooltipPaths = "Paths";
    g_editorStrings.tooltipMusic = "Music";
    g_editorStrings.tooltipArea = "Area";
    g_editorStrings.tooltipFile = "File";
    g_editorStrings.tooltipShow = "Show";

    g_editorStrings.listWarpTransitNames = {"NONE", "SCROLL", "FADE", "CIRCLE", "FLIP (H)", "FLIP (V)"};
}


================================================
FILE: src/editor/editor_strings.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef EDITOR_STRINGS_H
#define EDITOR_STRINGS_H

#include <string>
#include <vector>

struct EditorContent
{
    std::string phraseAreYouSure;
    std::string pageBlankOfBlank;

    std::string pickBlockContents;

    std::string blockLetterWidth;
    std::string blockLetterHeight;
    std::string blockCanBreak;
    std::string blockTooltipCanBreak;
    std::string blockSlick;
    std::string blockInvis;
    std::string blockInside;

    std::string warpTitle;
    std::string warpPlacing;
    std::string warpIn;
    std::string warpOut;
    std::string warpDir;
    std::string warpTwoWay;
    std::string warpStyle;
    std::string warpStylePipe;
    std::string warpStyleDoor;
    std::string warpStyleBlipInstant;
    std::string warpStylePortal;
    std::string warpEffect;
    std::string warpAllow;
    std::string warpItem;
    std::string warpRide;
    std::string warpCannonExit;
    std::string warpSpeed;
    std::string warpNeedStarCount;
    std::string warpNeedKey;
    std::string warpNeedFloor;
    std::string warpStarLockMessage;
    std::string warpToMap;
    std::string warpLvlWarp;
    std::string warpTarget;
    std::string warpTo;
    std::string warpShowStartScene;
    std::string warpShowStarCount;

    std::string waterTitle;

    std::string npcInContainer;
    std::string npcInertNice;
    std::string npcStuckStop;
    std::string npcAbbrevGen;
    std::string npcPropertyActive;
    std::string npcPropertyAttachSurface;
    std::string npcPropertyFacing;

    std::string npcAiIs;
    std::string npcAiTarget;
    std::string npcAiJump;
    std::string npcAiLeap;
    std::string npcAiSwim;
    std::string npcAiLR;
    std::string npcAiUD;

    std::string npcCustomAi;

    std::string npcUse1_0Ai;
    std::string npcTooltipExpandSection;

    std::string npcGenHeader;
    std::string npcGenDirection;
    std::string npcGenEffectIs;
    std::string npcGenEffectWarp;
    std::string npcGenEffectShoot;

    std::string wordNPC;
    std::string wordNPCGenitive;

    std::string wordEvent;
    std::string wordEventGenitive;
    std::string phraseTypeLabelEvent;

    std::string wordCoins;

    std::string wordEnabled;
    std::string wordText;
    std::string wordInstant;
    std::string wordMode;
    std::string wordHeight;
    std::string wordWidth;

    std::string labelSortLayer;
    std::string labelSortOffset;

    std::string phraseTextOf;
    std::string phraseSectionIndex;
    std::string phraseRadiusIndex;
    std::string phraseWarpIndex;
    std::string phraseGenericIndex;
    std::string phraseCountMore;
    std::string phraseDelayIsMs;
    std::string mapPos;

    std::string letterUp;
    std::string letterDown;
    std::string letterLeft;
    std::string letterRight;
    std::string letterCoordX;
    std::string letterCoordY;

    std::string toggleMagicBlock;

    std::string testMagicHand;
    std::string testChar;
    std::string testPower;
    std::string testBoot;
    std::string testPet;

    std::string eventsHeader;

    std::string eventsLetterActivate;
    std::string eventsLetterDeath;
    std::string eventsLetterTalk;
    std::string eventsLetterLayerClear;
    std::string eventsLetterHit;
    std::string eventsLetterDestroy;
    std::string eventsLetterEnter;

    std::string eventsLabelNext;
    std::string eventsLabelActivate;
    std::string eventsLabelDeath;
    std::string eventsLabelTalk;
    std::string eventsLabelLayerClear;
    std::string eventsLabelHit;
    std::string eventsLabelDestroy;
    std::string eventsLabelEnter;

    std::string eventsDescActivate;
    std::string eventsDescDeath;
    std::string eventsDescTalk;
    std::string eventsDescLayerClear;
    std::string eventsDescHit;
    std::string eventsDescDestroy;
    std::string eventsDescEnter;

    std::string eventsDescPhraseTriggersWhenTemplate;
    std::string eventsDescPhraseTriggersAfterTemplate;

    std::string eventsDeletingEvent;
    std::string eventsDeletionConfirm;
    std::string eventsDeletionCancel;

    std::string eventsPromptEventText;
    std::string eventsPromptEventName;
    std::string eventsItemNewEvent;

    std::string eventsControlsForEvent;
    std::string eventsSettingsForEvent;
    std::string eventsHeaderShow;
    std::string eventsHeaderHide;
    std::string eventsHeaderToggle;
    std::string eventsHeaderMove;

    std::string eventsActionKeep;
    std::string eventsActionReset;
    std::string eventsActionSet;

    std::string eventsCaseMusic;
    std::string eventsCaseBackground;
    std::string eventsCaseBounds;

    std::string eventsPhraseAllSections;

    std::string eventsPropAutostart;
    std::string eventsPropSound;
    std::string eventsPropEndGame;
    std::string eventsPropControls;
    std::string eventsPropLayerSmoke;

    std::string eventsHeaderTriggerEvent;

    std::string levelName;
    std::string levelStartPos;
    std::string levelPathBG;
    std::string levelBigBG;
    std::string levelGameStart;
    std::string levelAlwaysVis;
    std::string levelPathUnlocks;

    std::string sectionScroll;
    std::string sectionHorizWrap;
    std::string sectionVertWrap;
    std::string sectionUnderwater;
    std::string sectionNoTurnBack;
    std::string sectionOffscreenExit;

    std::string worldName;
    std::string worldIntroLevel;
    std::string worldHubWorld;
    std::string worldRetryOnFail;
    std::string worldTotalStars;
    std::string worldAllowChars;
    std::string worldCreditIndex;

    std::string selectSoundForEvent;
    std::string selectSectBlankPropBlankForEvent;
    std::string selectAllSectPropBlankForEvent;
    std::string selectSectionBlankPropBlank;
    std::string selectPathBlankUnlock;
    std::string selectWarpTransitionEffect;
    std::string selectWorldMusic;

    std::string layersHeader;

    std::string labelLayer;
    std::string layersLabelAttached;
    std::string layersAbbrevAttLayer;
    std::string layersLayerDefault;

    std::string layersLabelAttachedLayer;
    std::string layersLabelMoveLayer;

    std::string layersDeletionHeader;
    std::string layersDeletionPreserveLayerContents;
    std::string layersDeletionConfirmPreserve;
    std::string layersDeletionConfirmDelete;
    std::string layersDeletionCancel;

    std::string layersDescAtt;

    std::string layersPromptLayerName;
    std::string layersItemNewLayer;

    std::string fileActionClearLevel;
    std::string fileActionClearWorld;
    std::string fileActionOpen;
    std::string fileActionRevert;
    std::string fileActionExit;
    std::string fileConfirmationSaveBeforeAction;
    std::string fileConfirmationConfirmAction;
    std::string fileConfirmationConvertFormatTo;
    std::string fileOptionYesSaveThenAction;
    std::string fileOptionActionWithoutSave;
    std::string fileOptionCancelAction;
    std::string fileOptionProceedWithConversion;
    std::string fileOptionCancelConversion;

    std::string fileLabelCurrentFile;
    std::string fileLabelFormat;

    std::string fileFormatModern;
    std::string fileFormatLegacy;

    std::string fileSectionLevel;
    std::string fileSectionWorld;
    std::string fileCommandNew;
    std::string fileCommandOpen;
    std::string fileCommandSave;
    std::string fileCommandSaveAs;

    std::string fileConvertDesc;

#if 0
    std::string fileConvertNoIssues;
    std::string fileConvertFeaturesWillBeLost;

    std::string fileConvert38aUnsupported;
    std::string fileConvertFormatUnknown;

    std::string fileConvertFeatureWarpTransit;
    std::string fileConvertFeatureWarpNeedsStand;
    std::string fileConvertFeatureWarpCannonExit;
    std::string fileConvertFeatureWarpEnterEvent;
    std::string fileConvertFeatureWarpCustomStarsMsg;
    std::string fileConvertFeatureWarpNoPrintStars;
    std::string fileConvertFeatureWarpNoStartScene;
    std::string fileConvertFeatureWarpPortal;

    std::string fileConvertFeatureEventCustomMusic;
    std::string fileConvertFeatureEventAutoscroll;

    std::string fileConvertFeatureNPCVariant;
    std::string fileConvertFeatureBlockForceSmashable;
    std::string fileConvertFeatureBgoOrder;

    std::string fileConvertFeatureCustomWorldMusic;
    std::string fileConvertFeatureWorldStarDisplay;
    std::string fileConvertFeatureLevelStarDisplay;
    std::string fileConvertFeatureWorldMapSections;
#endif

    std::string browserNewFile;
    std::string browserSaveFile;
    std::string browserOpenFile;

    std::string browserItemNewFile;
    std::string browserItemNewFolder;

    std::string browserAskOverwriteFile;

    std::string tooltipSelect;
    std::string tooltipErase;
    std::string tooltipEraseAll;
    std::string tooltipBlocks;
    std::string tooltipBGOs;
    std::string tooltipNPCs;
    std::string tooltipWarps;
    std::string tooltipWater;
    std::string tooltipSettings;
    std::string tooltipLayers;
    std::string tooltipEvents;
    std::string tooltipTiles;
    std::string tooltipScenes;
    std::string tooltipLevels;
    std::string tooltipPaths;
    std::string tooltipMusic;
    std::string tooltipArea;
    std::string tooltipFile;
    std::string tooltipShow;

    std::vector<std::string> listWarpTransitNames{6};
};

extern EditorContent g_editorStrings;

void initEditorStrings();

#endif // EDITOR_STRINGS_H


================================================
FILE: src/editor/magic_block.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <vector>
#include <array>
#include <algorithm>

#include <Logger/logger.h>

#include "globals.h"
#include "collision.h"
#include "main/trees.h"

#include "editor/magic_block.h"
#include "editor/editor_custom.h"
#include "editor.h"

#include "rand.h"

namespace MagicBlock
{

using namespace EditorCustom;


bool enabled = false;
bool replace_existing = true;
// bool advanced_mode = false;
bool count_level_edges = true;

// CrossEffectLevel check_level = LEVEL_FAMILY;
// CrossEffectLevel change_level = LEVEL_FAMILY;



static int s_score_match(const ItemType_t candidate, const ItemType_t target)
{
    // don't consider it if width or height mismatched
    if(candidate.width != target.width)
        return -1;
    if(candidate.height != target.height)
        return -1;

    // don't consider it if group subcategory mismatched
    if(candidate.group != target.group)
        return -1;

    int score = 0;

    // penalize 6 for unmatched UDLR, 2 for unmatched diagonal
    if(candidate.has_4 != target.has_4)
        score += 8;
    if(candidate.has_8 != target.has_8)
        score += 8;
    if(candidate.has_6 != target.has_6)
        score += 8;
    if(candidate.has_2 != target.has_2)
        score += 8;

    if(candidate.has_1 != target.has_1)
        score += 2;
    if(candidate.has_3 != target.has_3)
        score += 2;
    if(candidate.has_7 != target.has_7)
        score += 2;
    if(candidate.has_9 != target.has_9)
        score += 2;

    // care just a tad more about top
    if(candidate.has_8 != target.has_8)
        score += 1;

    // especially penalize missing connections
    if(target.has_4 && !candidate.has_4)
        score += 4;
    if(target.has_8 && !candidate.has_8)
        score += 4;
    if(target.has_6 && !candidate.has_6)
        score += 4;
    if(target.has_2 && !candidate.has_2)
        score += 4;

    if(target.has_1 && !candidate.has_1)
        score += 1;
    if(target.has_3 && !candidate.has_3)
        score += 1;
    if(target.has_7 && !candidate.has_7)
        score += 1;
    if(target.has_9 && !candidate.has_9)
        score += 1;

    // penalize 3 for unmatched slope existence, additional 1 for unmatched slope number
    if((target.slope == ItemType_t::no_slope) && (candidate.slope != ItemType_t::no_slope))
        score += 3;
    if(candidate.slope != target.slope)
        score += 1;

    return score;
}

ItemType_t s_match_type(const ItemFamily& family, const ItemType_t inferred_type)
{
    ItemType_t best_type;
    int best_score = -1;

#if 0
    printf("Has inferred adjacency: ");
    if(inferred_type.has_1) printf("1");
    if(inferred_type.has_2) printf("2");
    if(inferred_type.has_3) printf("3");
    if(inferred_type.has_4) printf("4");
    if(inferred_type.has_6) printf("6");
    if(inferred_type.has_7) printf("7");
    if(inferred_type.has_8) printf("8");
    if(inferred_type.has_9) printf("9");
    printf(" (slope %d)\n", inferred_type.slope);
    printf("Self is %d\n", inferred_type.type);
#endif

    for(const ItemType_t t : family.types)
    {
        if(t.type == inferred_type.type)
        {
            best_type = t;
            best_score = s_score_match(t, inferred_type);
            // printf("Initial self best is %d\n", best_score);
            break;
        }
    }

    int matches = 1;

    for(const ItemType_t t : family.types)
    {
        int score = s_score_match(t, inferred_type);

        if(score == -1)
            continue;

        // printf("%d score is %d\n", t.type, score);

        if(best_score == -1 || score < best_score)
        {
            best_type = t;
            best_score = score;
        }
        else if(score == best_score && best_type.type != inferred_type.type)
        {
            matches++;

            if(t.type == inferred_type.type || iRand(matches) == 0)
                best_type = t;
        }
    }

    return best_type;
}

template<class ItemRef_t>
TreeResult_Sentinel<ItemRef_t> treeQuery(const Location_t& loc, int sort_mode);

template<>
TreeResult_Sentinel<BlockRef_t> treeQuery<BlockRef_t>(const Location_t& loc, int sort_mode)
{
    return treeBlockQuery(loc, sort_mode);
}

template<>
TreeResult_Sentinel<TileRef_t> treeQuery<TileRef_t>(const Location_t& loc, int sort_mode)
{
    return treeWorldTileQuery(static_cast<TinyLocation_t>(loc), sort_mode);
}

template<>
TreeResult_Sentinel<BackgroundRef_t> treeQuery<BackgroundRef_t>(const Location_t& loc, int sort_mode)
{
    return treeBackgroundQuery(loc, sort_mode);
}

template<class ItemRef_t>
bool s_check_hidden(ItemRef_t B)
{
    return B->Hidden;
}

template<>
bool s_check_hidden(TileRef_t B)
{
    UNUSED(B);
    return false;
}

template<class ItemRef_t>
bool s_check_sizable(ItemRef_t B)
{
    UNUSED(B);
    return false;
}

template<>
bool s_check_sizable(BlockRef_t B)
{
    return BlockIsSizable[B->Type];
}

template<class ItemRef_t>
static inline bool s_ban_slope(ItemRef_t B, int dir)
{
    UNUSED(B);
    UNUSED(dir);
    return false;
}

template<>
inline bool s_ban_slope(BlockRef_t B, int dir)
{
    int t = B->Type;

    // for cases on left, ban .\ and */ slopes
    if(dir == 1 || dir == 4 || dir == 7)
    {
        if(BlockSlope[t] > 0 || BlockSlope2[t] < 0)
            return true;
    }

    // for cases on right, ban /. and \* slopes
    if(dir == 3 || dir == 6 || dir == 9)
    {
        if(BlockSlope[t] < 0 || BlockSlope2[t] > 0)
            return true;
    }

    // for cases above, ban \* and */ slopes
    if(dir == 7 || dir == 8 || dir == 9)
    {
        if(BlockSlope2[t])
            return true;
    }

    // for cases below, ban /. and .\ slopes
    if(dir == 1 || dir == 2 || dir == 3)
    {
        if(BlockSlope[t])
            return true;
    }

    return false;
}

template<class ItemRef_t>
struct MagicInfo {};

template<>
struct MagicInfo<BlockRef_t>
{
    static const int maxType = maxBlockType;
    static constexpr const int& numItem = numBlock;
    static constexpr std::vector<ItemFamily>& families = block_families;
    static constexpr const std::array<uint8_t, maxType>& family_by_type = block_family_by_type;
};

template<>
struct MagicInfo<TileRef_t>
{
    static const int maxType = maxTileType;
    static constexpr const int& numItem = numTiles;
    static constexpr std::vector<ItemFamily>& families = tile_families;
    static constexpr const std::array<uint8_t, maxType>& family_by_type = tile_family_by_type;
};

template<>
struct MagicInfo<BackgroundRef_t>
{
    static const int maxType = maxBackgroundType;
    static constexpr const int& numItem = numBackground;
    static constexpr std::vector<ItemFamily>& families = bgo_families;
    static constexpr const std::array<uint8_t, maxType>& family_by_type = bgo_family_by_type;
};

template<class ItemRef_t>
int s_pick_type(ItemFamily& family, ItemRef_t A)
{
    const CrossEffectLevel check_level = family.behind_mode ? LEVEL_ALL : LEVEL_FAMILY;
    constexpr bool advanced_mode = false;

    ItemType_t inferred_type;

    inferred_type.type = A->Type;
    inferred_type.width = num_t::round(A->Location.Width / 32);
    inferred_type.height = num_t::round(A->Location.Height / 32);

    for(ItemType_t t : family.types)
    {
        if(t.type == A->Type)
        {
            inferred_type.group = t.group;
            inferred_type.slope = t.slope;
            break;
        }
    }

    Location_t tempLoc = static_cast<Location_t>(A->Location);

    // 7 (top-left)
    tempLoc.X -= 31;
    tempLoc.Width = 30;
    tempLoc.Y -= 31;
    tempLoc.Height = 30;

    if(count_level_edges && !WorldEditor && (tempLoc.X + tempLoc.Width < level[curSection].X || tempLoc.Y + tempLoc.Height < level[curSection].Y))
        inferred_type.has_7 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            if(s_check_sizable(B))
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_3 || !advanced_mode)
                    {
                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 7)))
            {
                inferred_type.has_7 = true;
                break;
            }
        }
    }

    // 8 (top)
    tempLoc.X = A->Location.X + 1;
    tempLoc.Width = A->Location.Width - 2;

    if(count_level_edges && !WorldEditor && tempLoc.Y + tempLoc.Height < level[curSection].Y)
        inferred_type.has_8 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            if(s_check_sizable(B))
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_2 || !advanced_mode)
                    {
                        if((t.has_1 || t.has_3) && !t.has_8 && t.slope > inferred_type.slope)
                            inferred_type.slope = t.slope;

                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 8)))
            {
                inferred_type.has_8 = true;
                break;
            }
        }
    }

    // 9 (top-right)
    tempLoc.X = A->Location.X + A->Location.Width + 1;
    tempLoc.Width = 30;

    if(count_level_edges && !WorldEditor && (tempLoc.X > level[curSection].Width || tempLoc.Y + tempLoc.Height < level[curSection].Y))
        inferred_type.has_9 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            if(s_check_sizable(B))
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_1 || !advanced_mode)
                    {
                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 9)))
            {
                inferred_type.has_9 = true;
                break;
            }
        }
    }

    // 6 (right)
    tempLoc.Y = A->Location.Y + 1;
    tempLoc.Height = A->Location.Height - 2;

    if(count_level_edges && !WorldEditor && tempLoc.X > level[curSection].Width)
        inferred_type.has_6 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            if(s_check_sizable(B))
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_4 || !advanced_mode)
                    {
                        if((t.has_1 || t.has_7) && !t.has_6 && t.slope > inferred_type.slope)
                            inferred_type.slope = t.slope;

                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 6)))
            {
                inferred_type.has_6 = true;
                break;
            }
        }
    }

    // 3 (bottom-right)
    tempLoc.Y = A->Location.Y + A->Location.Height + 1;
    tempLoc.Height = 30;

    if(count_level_edges && !WorldEditor && (tempLoc.X > level[curSection].Width || tempLoc.Y > level[curSection].Height))
        inferred_type.has_3 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            // count only the top of a sizable as a collision
            if(s_check_sizable(B) && A->Location.Y >= B->Location.Y)
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_7 || !advanced_mode)
                    {
                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 3)))
            {
                inferred_type.has_3 = true;
                break;
            }
        }
    }

    // 2 (bottom)
    tempLoc.X = A->Location.X + 1;
    tempLoc.Width = A->Location.Width - 2;

    if(count_level_edges && !WorldEditor && tempLoc.Y > level[curSection].Height)
        inferred_type.has_2 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            // count only the top of a sizable as a collision
            if(s_check_sizable(B) && A->Location.Y >= B->Location.Y)
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_8 || !advanced_mode)
                    {
                        if((t.has_7 || t.has_9) && !t.has_2 && t.slope > inferred_type.slope)
                            inferred_type.slope = t.slope;

                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 2)))
            {
                inferred_type.has_2 = true;
                break;
            }
        }
    }

    // 1 (bottom-left)
    tempLoc.X = A->Location.X - 31;
    tempLoc.Width = 30;

    if(count_level_edges && !WorldEditor && (tempLoc.X + tempLoc.Width < level[curSection].X || tempLoc.Y > level[curSection].Height))
        inferred_type.has_1 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            // count only the top of a sizable as a collision
            if(s_check_sizable(B) && A->Location.Y >= B->Location.Y)
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_9 || !advanced_mode)
                    {
                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 1)))
            {
                inferred_type.has_1 = true;
                break;
            }
        }
    }

    // 4 (left)
    tempLoc.Y = A->Location.Y + 1;
    tempLoc.Height = A->Location.Height - 2;

    if(count_level_edges && !WorldEditor && tempLoc.X + tempLoc.Width < level[curSection].X)
        inferred_type.has_4 = true;
    else for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
    {
        if(A != B && !s_check_hidden(B) && CheckCollision(tempLoc, B->Location))
        {
            if(s_check_sizable(B))
                continue;

            bool hit = false;
            for(ItemType_t t : family.types)
            {
                if(t.type == B->Type && (check_level != LEVEL_GROUP || t.group == inferred_type.group))
                {
                    if(t.has_6 || !advanced_mode)
                    {
                        if((t.has_3 || t.has_9) && !t.has_4 && t.slope > inferred_type.slope)
                            inferred_type.slope = t.slope;

                        hit = true;
                        break;
                    }
                }
            }

            if(hit || (check_level == LEVEL_ALL && !s_ban_slope(B, 4)))
            {
                inferred_type.has_4 = true;
                break;
            }
        }
    }

    return s_match_type(family, inferred_type).type;
}


template<class ItemRef_t>
void s_apply_type(ItemRef_t B, int type)
{
    B->Type = type;
}

template<>
void s_apply_type(BlockRef_t B, int type)
{
    if(B->Slippy ==
        (B->Type == 189 || B->Type == 190 || B->Type == 191
            || B->Type == 270 || B->Type == 271 || B->Type == 272
            || B->Type == 620 || B->Type == 621 || B->Type == 633
            || B->Type == 634 || B->Type == 241 || B->Type == 242))
    {
        B->Slippy = (type == 189 || type == 190 || type == 191 || type == 270 || type == 271 || type == 272 || type == 620 || type == 621 || type == 633 || type == 634 || type == 241 || type == 242);
    }

    B->Type = type;
}

template<class ItemRef_t>
void MagicItem(int Type, Location_t loc)
{
    constexpr CrossEffectLevel change_level = LEVEL_FAMILY;

    using ItemInfo = MagicInfo<ItemRef_t>;

    if(Type < 1 || Type > ItemInfo::maxType)
        return;

    uint8_t family = ItemInfo::family_by_type[Type - 1];

    if(family == FAMILY_NONE)
        return;

    if(change_level != LEVEL_ALL && ItemInfo::families[family].is_misc)
        return;

    int group = 0;

    for(const ItemType_t& t : ItemInfo::families[family].types)
    {
        if(t.type == Type)
        {
            group = t.group;
            break;
        }
    }

    // first, transform all nearby blocks, then transform the block itself
    Location_t tempLoc = loc;
    tempLoc.X -= 31;
    tempLoc.Y -= 31;
    tempLoc.Width += 62;
    tempLoc.Height += 62;

    for(int i = 0; i < 2; i++)
    {
        for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
        {
            if(B->Type < 1 || B->Type > ItemInfo::maxType)
                continue;

            uint8_t family_b = ItemInfo::family_by_type[B->Type - 1];

            if(family_b == FAMILY_NONE)
                continue;

            if(change_level != LEVEL_ALL && family_b != family && !ItemInfo::families[family_b].behind_mode)
                continue;

            if(!CheckCollision(tempLoc, B->Location))
                continue;

            if(change_level >= LEVEL_GROUP)
            {
                bool group_match = false;
                for(const ItemType_t& t : ItemInfo::families[family_b].types)
                {
                    if(t.type == B->Type && t.group == group)
                    {
                        group_match = true;
                        break;
                    }
                }

                if(!group_match)
                    continue;
            }

            int new_type = s_pick_type(ItemInfo::families[family_b], B);
            if(new_type != 0)
                s_apply_type(B, new_type);
        }
    }
}

template<class ItemRef_t>
void MagicItem(ItemRef_t A)
{
    constexpr CrossEffectLevel change_level = LEVEL_FAMILY;

    using ItemInfo = MagicInfo<ItemRef_t>;

    if((int)A < 1 || (int)A > ItemInfo::numItem)
        return;
    if(A->Type < 1 || A->Type > ItemInfo::maxType)
        return;

    uint8_t family = ItemInfo::family_by_type[A->Type - 1];

    if(family == FAMILY_NONE)
        return;

    if(change_level != LEVEL_ALL && ItemInfo::families[family].is_misc)
        return;

    int group = 0;

    for(const ItemType_t& t : ItemInfo::families[family].types)
    {
        if(t.type == A->Type)
        {
            group = t.group;
            break;
        }
    }

    // first, transform all nearby blocks, then transform the block itself
    Location_t tempLoc = static_cast<Location_t>(A->Location);
    tempLoc.X -= 31;
    tempLoc.Y -= 31;
    tempLoc.Width += 62;
    tempLoc.Height += 62;

    for(int i = 0; i < 2; i++)
    {
        for(ItemRef_t B : treeQuery<ItemRef_t>(tempLoc, SORTMODE_NONE))
        {
            if(B == A)
                continue;

            if(B->Type < 1 || B->Type > ItemInfo::maxType)
                continue;

            uint8_t family_b = ItemInfo::family_by_type[B->Type - 1];

            if(family_b == FAMILY_NONE)
                continue;

            if(change_level != LEVEL_ALL && family_b != family && !ItemInfo::families[family_b].behind_mode)
                continue;

            if(!CheckCollision(tempLoc, B->Location))
                continue;

            if(change_level == LEVEL_GROUP)
            {
                bool group_match = false;
                for(const ItemType_t& t : ItemInfo::families[family_b].types)
                {
                    if(t.type == B->Type && t.group == group)
                    {
                        group_match = true;
                        break;
                    }
                }

                if(!group_match)
                    continue;
            }

            int new_type = s_pick_type(ItemInfo::families[family_b], B);
            if(new_type != 0)
                s_apply_type(B, new_type);
        }

        int new_type = s_pick_type(ItemInfo::families[family], A);
        if(new_type != 0)
            s_apply_type(A, new_type);
    }
}

void MagicBlock(int Type, Location_t loc)
{
    if(!enabled)
        return;

    MagicItem<BlockRef_t>(Type, loc);
}

void MagicBlock(BlockRef_t A)
{
    if(!enabled)
        return;

    MagicItem(A);
}

void MagicBackground(int Type, Location_t loc)
{
    if(!enabled)
        return;

    MagicItem<BackgroundRef_t>(Type, loc);
}

void MagicBackground(BackgroundRef_t A)
{
    if(!enabled)
        return;

    MagicItem(A);
}

void MagicTile(int Type, Location_t loc)
{
    if(!enabled)
        return;

    MagicItem<TileRef_t>(Type, loc);
}

void MagicTile(TileRef_t A)
{
    if(!enabled)
        return;

    MagicItem(A);
}

} // namespace MagicBlock


================================================
FILE: src/editor/magic_block.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef MAGIC_BLOCK_H
#define MAGIC_BLOCK_H

#include <vector>
#include <array>

#include "globals.h"


namespace MagicBlock
{

enum CrossEffectLevel
{
    LEVEL_ALL,
    LEVEL_FAMILY,
    LEVEL_GROUP
};

extern bool enabled;
extern bool replace_existing;
// extern bool advanced_mode;
extern bool count_level_edges;
// extern CrossEffectLevel check_level;
// extern CrossEffectLevel change_level;

void MagicBlock(BlockRef_t A);
void MagicBlock(int Type, Location_t loc);

void MagicBackground(BackgroundRef_t A);
void MagicBackground(int Type, Location_t loc);

void MagicTile(TileRef_t A);
void MagicTile(int Type, Location_t loc);

} // namespace MagicBlock

#endif // MAGIC_BLOCK_H


================================================
FILE: src/editor/new_editor.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <sorting/tinysort.h>

#include <PGE_File_Formats/file_formats.h>
#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_stdinc.h"
#include <Integrator/integrator.h>
#include <fontman/font_manager.h>
#include "Utils/files.h"

#include "core/render.h"

#include "../globals.h"
#include "../gfx.h"
#include "../layers.h"
#include "../graphics.h"
#include "../sound.h"
#include "../main/level_file.h"
#include "../main/world_file.h"
#include "../game_main.h"
#include "main/game_globals.h"
#include "main/world_globals.h"

#include "config.h"
#include "npc.h"
#include "npc_id.h"
#include "npc_traits.h"
#include "npc_special_data.h"
#include "controls.h"

#include "editor.h"
#include "editor/new_editor.h"
#include "editor/write_level.h"
#include "editor/write_world.h"

#include "editor/magic_block.h"
#include "editor/editor_custom.h"
#include "editor/editor_strings.h"

#include "main/menu_main.h"
#include "main/screen_textentry.h"
#include "main/game_info.h"
#include "main/translate.h"


template<typename... Args>
inline void SuperPrintR(EditorScreen::CallMode mode, Args... args)
{
    if(mode == EditorScreen::CallMode::Render)
        SuperPrint(args...);
}

template<typename... Args>
inline void SuperPrintRightR(EditorScreen::CallMode mode, Args... args)
{
    if(mode == EditorScreen::CallMode::Render)
        SuperPrintRightAlign(args...);
}

template<typename... Args>
inline void SuperPrintCenterR(EditorScreen::CallMode mode, Args... args)
{
    if(mode == EditorScreen::CallMode::Render)
        SuperPrintCenter(args...);
}

inline PGE_Size FontManager_printTextOptiPxR(EditorScreen::CallMode mode,
                                             std::string text,
                                             int x, int y,
                                             size_t max_pixels_lenght,
                                             int font = FontManager::DefaultRaster,
                                             XTColor color = XTColor(),
                                             uint32_t ttf_FontSize = 14)
{
    if(mode == EditorScreen::CallMode::Render)
        return FontManager::printTextOptiPx(text, x, y,
                                            max_pixels_lenght,
                                            font, color, ttf_FontSize);
    else
        return FontManager::optimizeTextPx(text, max_pixels_lenght, font, ttf_FontSize);
}

constexpr auto LESet_Nothing = EventSection_t::LESet_Nothing;
constexpr auto LESet_ResetDefault = EventSection_t::LESet_ResetDefault;

constexpr int e_ScreenW = 640;
constexpr int e_ScreenH = 480;

static const std::vector<std::string> c_musicFormats =
{
    // MPEG 1 Layer III (LibMAD)
    ".mp3",

    // OGG Vorbis, FLAC, amd Opus (LibOGG, LibVorbis, LibFLAC, libOpus)
    ".ogg", ".flac", ".opus",

    // Uncompressed audio data
    ".wav", ".aiff",

    // MIDI
    ".mid", ".midi", ".rmi", ".mus", ".kar", ".xmi", ".cmf",

    // Id Music File (OPL2 raw) / Imago Orpheus (Tracker music)
    ".imf", ".wlf",

    // Modules (Tracker music)
    ".mod", ".it", ".s3m", ".669", ".med", ".xm", ".amf",
    ".apun", ".dsm", ".far", ".gdm", ".mtm",
    ".okt", ".stm", ".stx", ".ult", ".uni", ".mptm",

    // GAME EMU (Chiptunes)
    ".ay", ".gbs", ".gym", ".hes", ".kss", ".nsf",
    ".nsfe", ".sap", ".spc", ".vgm", ".vgz",

    // PXTONE
    ".pttune", ".ptcop"
};

int e_CursorX, e_CursorY;

void DisableCursorNew()
{
    EditorCursor.Location.X = vScreen[1].X - 800;
    EditorCursor.X = (int)EditorCursor.Location.X;
    EditorCursor.Location.Y = vScreen[1].Y - 600;
    EditorCursor.Y = (int)EditorCursor.Location.Y;
    HasCursor = false;

    e_CursorX = -50;
    e_CursorY = -50;
}

static numf_t s_divide_by_ten(int n)
{
    return numf_t(n) / 10;
}

static void s_fix_mouse_pos()
{
    MouseMove((int)SharedCursor.X, (int)SharedCursor.Y);
}

// static const std::vector<std::string> list_backgrounds_names = {"None", "Set 1", "Underground", "Night", "Night 2", "Overworld", "Castle", "Mushrooms", "Desert", "", "Set 2", "Trees", "Underground", "Castle", "Clouds", "Night - Hills", "Night - Desert", "Cliff", "Warehouse", "Dungeon", "Set 3", "Blocks", "Hills", "Dungeon", "Pipes", "Bonus", "Clouds", "Desert", "Dungeon 2", "Ship", "Forest", "Battle", "Waterfall", "Tanks", "Final Boss", "Shroom Dealer", "Castle", "Snow Trees", "Clouds 2", "Snow Hills", "Cave", "Cave 2", "Underwater", "World", "Trees", "Mansion", "Forest", "Bonus", "Night", "Cave", "Clouds", "Hills", "Hills 2", "Hills 4", "Hills 3", "Castle", "Castle 2", "Underwater", "Desert Night", "", "Misc.", "Space Base", "Space Ship", "Space Swamp", "Space Crater", "Secret Mine"};
// static const std::vector<int16_t> list_backgrounds_indices = {0, -1, 7, 8, 9, 10, 41, 50, 51, -1, -1, 5, 25, 44, 48, 49, 52, 53, 54, 57, -1, 1, 2, 3, 4, 6, 13, 14, 15, 17, 20, 21, 22, 23, 24, 26, 27, 35, 36, 37, 38, 39, 56, -1, 12, 18, 19, 28, 29, 30, 31, 11, 32, 33, 34, 42, 43, 55, 58, -1, -1, 47, 46, 45, 16, 40};

// static const std::vector<std::string> list_music_names = {"None", "Custom", "Set 1", "Overworld", "Underground", "Dungeon", "Water", "Set 2", "Overworld", "Underground", "Boss", "Final Boss", "Set 3", "Overworld", "Sky", "Underground", "Dungeon", "Water", "Roaming Enemy", "Boss", "World", "Overworld", "Mansion", "Sky", "Cave", "Dungeon", "Water", "Boss", "RPG", "Bachelor Pad", "Town", "Forest", "Seaside", "Pond", "Clouds", "Battle", "64", "Main Theme", "Cave", "Snow", "Desert", "Water", "Castle", "Boss", "Fight", "Knight", "Underground", "Temple", "Steampunk", "Pinball", "Space", "Red Swamp", "Crater", "Item Room", "Final Boss", "Remake", "Misc.", "Jungle Village", "Ice Mountain", "Title Theme", "Beach", "Fusion Reactor", "Bouncy Race", "Remake", "Heroic Woods", "Cornered!"};
// static const std::vector<int16_t> list_music_indices = {0, 24, -1, 9, 7, 42, 46, -1, 5, 25, 15, 43, -1, 1, 2, 4, 3, 47, 54, 6, -1, 10, 17, 28, 29, 41, 48, 51, -1, 30, 34, 16, 31, 32, 33, 21, -1, 27, 50, 35, 14, 49, 26, 36, -1, 40, 52, 39, 19, 53, -1, 11, 12, 44, 45, 22, -1, 38, 37, 55, 18, 20, 56, 13, 23, 8};

// static const std::vector<std::string> list_world_music_names = {"None", "SET 3", "World 1", "World 2", "World 3", "World 4", "World 5", "World 6", "World 7", "World 8", "WORLD", "Theme", "Cave", "Island", "Forest", "Dungeon", "Sky", "Special", "NEW", "Theme"};
// static const std::vector<int16_t> list_world_music_indices = {0, -1, 1, 6, 8, 2, 11, 10, 3, 9, -1, 4, 16, 15, 7, 13, 14, 12, -1, 5};

// static const std::array<std::string, 10> list_level_exit_names = {"ANY", "NONE", "ROULETTE", "? ORB", "LEAVE", "KEYHOLE", "CLEAR ORB", "WARP", "STAR", "BAR END"};

const char* e_tooltip = nullptr;

void EditorScreen::EnsureWorld()
{
    if(WorldEditor) return;
    ClearLevel();
    WorldEditor = true;
}

void EditorScreen::EnsureLevel()
{
    if(!WorldEditor) return;
    ClearWorld();
    WorldEditor = false;
}

void EditorScreen::ResetCursor()
{
    EditorCursor.Mode = OptCursor_t::LVL_SELECT;
    EditorCursor.InteractMode = 0;
    EditorCursor.InteractFlags = 0;
    EditorCursor.InteractIndex = 0;

    EditorCursor.Block = Block_t();
    EditorCursor.Block.Type = 1;
    EditorCursor.Background = Background_t();
    EditorCursor.Background.Type = 1;
    EditorCursor.Background.SetSortPriority(0, 0);
    EditorCursor.NPC = NPC_t();
    EditorCursor.NPC.Type = NPCID(1);
    EditorCursor.NPC.Direction = -1;
    EditorCursor.Water = Water_t();
    EditorCursor.Warp = Warp_t();
    EditorCursor.Warp.WarpNPC = true;
    EditorCursor.Warp.Direction = 3;
    EditorCursor.Warp.Direction2 = 3;
    EditorCursor.Warp.MapX = -1;
    EditorCursor.Warp.MapY = -1;
    EditorCursor.Warp.Effect = 1;

    EditorCursor.Tile = Tile_t();
    EditorCursor.Tile.Type = 1;
    EditorCursor.Scene = Scene_t();
    EditorCursor.Scene.Type = 1;
    EditorCursor.WorldLevel = WorldLevel_t();
    EditorCursor.WorldLevel.Type = 1;
    EditorCursor.WorldLevel.WarpX = -1;
    EditorCursor.WorldLevel.WarpY = -1;
    EditorCursor.WorldPath = WorldPath_t();
    EditorCursor.WorldPath.Type = 1;
    EditorCursor.WorldMusic = WorldMusic_t();

    m_special_page = SPECIAL_PAGE_NONE;
    m_special_subpage = 0;
    m_NPC_page = 0;
    m_Block_page = 0;
    m_BGO_page = 0;
    m_Warp_page = WARP_PAGE_MAIN;
    m_layers_page = 0;
    m_events_page = 0;
    m_sounds_page = 0;
    m_tile_page = 0;
    m_music_page = 0;
    m_background_page = 0;
    m_current_event = 0;

    MagicBlock::enabled = false;

    if(testStartWarp > numWarps && LevelEditor)
        testStartWarp = numWarps;

    FocusNPC();
    FocusBlock();
    FocusBGO();
    FocusTile();
}

bool AllowBubble()
{
    int type;

    if(NPCIsContainer(EditorCursor.NPC))
        type = EditorCursor.NPC.Special;
    else
        type = EditorCursor.NPC.Type;

    if(type == NPCID_BOMB)
        return true;

    if(NPCHeight(type) > 36 || NPCWidth(type) > 36
        || NPCWidthGFX(type) > 36 || NPCHeightGFX(type) > 36)
    {
        int W = NPCWidth(type);
        int H = NPCHeight(type);

        if(NPCWidthGFX(type) > W)
            W = NPCWidthGFX(type);

        if(NPCHeightGFX(type) > H)
            H = NPCHeightGFX(type);

        if((W <= 32 && H <= 54) || (H <= 32 && W <= 54))
            return true;
        else
            return false;
    }
    else
        return true;
}

void SetEditorNPCType(NPCID type)
{
    NPCID prev_type;

    if(NPCIsContainer(EditorCursor.NPC))
    {
        prev_type = NPCID(EditorCursor.NPC.Special);
        EditorCursor.NPC.Special = type;
    }
    else
    {
        prev_type = EditorCursor.NPC.Type;
        EditorCursor.NPC.Type = type;

        // can't have a murderous default, reset to 1 for ParaTroopas
        if(NPCIsAParaTroopa(type) && !NPCIsAParaTroopa(prev_type))
            EditorCursor.NPC.Special = 1;

        // reset special for NPCs that don't allow it
        if(!(NPCTraits[type].IsFish || NPCIsAParaTroopa(type) || type == NPCID_FIRE_CHAIN))
            EditorCursor.NPC.Special = 0;

        // reset special if it's out of range
        if(!(type == NPCID_FIRE_CHAIN) && EditorCursor.NPC.Special > 5)
            EditorCursor.NPC.Special = 0;
    }

    if(NPCBansWings(EditorCursor.NPC))
    {
        EditorCursor.NPC.Wings = WING_NONE;
        EditorCursor.NPC.DefaultWings = WING_NONE;
    }

    // reset legacy for the NPCs that don't allow it
    if(!(type == NPCID_MINIBOSS || type == NPCID_SPIT_BOSS || type == NPCID_VILLAIN_S3))
        EditorCursor.NPC.Legacy = false;

    // reset Variant data across different NPCs
    if(find_Variant_Data(prev_type) != find_Variant_Data(type))
    {
        if(FileFormat == FileFormats::LVL_PGEX)
            EditorCursor.NPC.Variant = find_modern_Variant(type);
        else
            EditorCursor.NPC.Variant = 0;
    }

    // reset Variant data for NPCs that don't support it
    if(find_Variant_Data(type) == nullptr && !(type == NPCID_STAR_COLLECT || type == NPCID_STAR_EXIT || type == NPCID_MEDAL || type == NPCID_MAGIC_DOOR || type == NPCID_DOOR_MAKER))
        EditorCursor.NPC.Variant = 0;

    // turn into new type if can't be in bubble anymore
    if(EditorCursor.NPC.Type == NPCID_ITEM_BUBBLE && !AllowBubble())
    {
        EditorCursor.NPC.Type = type;
        EditorCursor.NPC.Special = 0;
    }

    // force a direction if they don't allow neutral direction (conveyers, moving platform blocks)
    if(EditorCursor.NPC.Direction == 0 && (type == 57 || type == 60 || type == 62 || type == 64 || type == 66))
        EditorCursor.NPC.Direction = -1;

    ResetNPC(type);
}

void SetEditorBlockType(int type)
{
    if(BlockIsSizable[type])
    {
        if(EditorCursor.Block.Location.Width < 64)
            EditorCursor.Block.Location.Width = 64;
        if(EditorCursor.Block.Location.Height < 64)
            EditorCursor.Block.Location.Height = 64;
    }
    else
    {
        EditorCursor.Block.Location.Width = 0;
        EditorCursor.Block.Location.Height = 0;
    }

    if(type == 5 || type == 88 || type == 193 || type == 224)
    {
        if(EditorCursor.Block.Special == 0)
            EditorCursor.Block.Special = 1;
    }
    else if(type != 60 && type != 188 && type != 4 && type != 226 && type != 55 && type != 159 && type != 226
        && type != 55 && type != 90 && type != 170 && type != 171 && type != 172 && type != 173
        && type != 174 && type != 175 && type != 176 && type != 177 && type != 178 && type != 179 && type != 180
        && type != 181 && type != 622 && type != 623 && type != 624 && type != 625 && type != 626 && type != 627
        && type != 628 && type != 629 && type != 631 && type != 632)
    {
        EditorCursor.Block.Special = 0;
    }

    // only update slipperiness if it is currently what you would expect.
    if(EditorCursor.Block.Slippy ==
        (EditorCursor.Block.Type == 189 || EditorCursor.Block.Type == 190 || EditorCursor.Block.Type == 191
            || EditorCursor.Block.Type == 270 || EditorCursor.Block.Type == 271 || EditorCursor.Block.Type == 272
            || EditorCursor.Block.Type == 620 || EditorCursor.Block.Type == 621 || EditorCursor.Block.Type == 633
            || EditorCursor.Block.Type == 634 || EditorCursor.Block.Type == 241 || EditorCursor.Block.Type == 242))
    {
        EditorCursor.Block.Slippy = (type == 189 || type == 190 || type == 191 || type == 270 || type == 271 || type == 272 || type == 620 || type == 621 || type == 633 || type == 634 || type == 241 || type == 242);
    }

    EditorCursor.Block.Type = type;
}

void EditorScreen::FocusNPC()
{
    int type;
    if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS)
        type = EditorCursor.Block.Special - 1000;
    else if(NPCIsContainer(EditorCursor.NPC))
        type = EditorCursor.NPC.Special;
    else
        type = EditorCursor.NPC.Type;

    if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS && (type == 10 || type == 9 || type == 90 || type == 14 || type == 264 || type == 34 || type == 169 || type == 170 || type == 226 || type == 287 || type == 33 || type == 185 || type == 187 || type == 183 || type == 188 || type == 277 || type == 95 || type == 31 || type == 227 || type == 88 || type == 184 || type == 186 || type == 182 || type == 153 || type == 138 || type == 249 || type == 134 || type == 241 || type == 240 || type == 152 || type == 250 || type == 254 || type == 251 || type == 252 || type == 253))
        m_NPC_page = -1;
    else if(!EditorCustom::npc_families.empty() && type >= 1 && type <= maxNPCType && EditorCustom::npc_family_by_type[type - 1] != EditorCustom::FAMILY_NONE)
        m_NPC_page = EditorCustom::npc_families[EditorCustom::npc_family_by_type[type - 1]].page;
    else if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS)
        m_NPC_page = -1;
    else
        m_NPC_page = 0;
}

void EditorScreen::FocusBlock()
{
    int type = EditorCursor.Block.Type;
    if(!EditorCustom::block_families.empty() && type >= 1 && type <= maxBlockType && EditorCustom::block_family_by_type[type - 1] != EditorCustom::FAMILY_NONE)
        m_Block_page = EditorCustom::block_families[EditorCustom::block_family_by_type[type - 1]].page;
    else
        m_Block_page = 0;
}

void EditorScreen::FocusBGO()
{
    int type = EditorCursor.Background.Type;
    if(!EditorCustom::bgo_families.empty() && type >= 1 && type <= maxBackgroundType && EditorCustom::bgo_family_by_type[type - 1] != EditorCustom::FAMILY_NONE)
        m_BGO_page = EditorCustom::bgo_families[EditorCustom::bgo_family_by_type[type - 1]].page;
    else
        m_BGO_page = 0;
}

void EditorScreen::FocusTile()
{
    int type = EditorCursor.Tile.Type;
    if(!EditorCustom::tile_families.empty() && type >= 1 && type <= maxTileType && EditorCustom::tile_family_by_type[type - 1] != EditorCustom::FAMILY_NONE)
        m_tile_page = EditorCustom::tile_families[EditorCustom::tile_family_by_type[type - 1]].page;
    else
        m_tile_page = 0;
}

bool EditorScreen::UpdateButton(CallMode mode, int x, int y, StdPicture &im, bool sel,
    int src_x, int src_y, int src_w, int src_h, const char* tooltip)
{
    // the button is 32x32 and outlined by a 36x36 box
    bool coll = false;
    if(e_CursorX >= x && e_CursorX < x + 32
        && e_CursorY >= y && e_CursorY < y + 32)
    {
        coll = true;
    }

    // just do the simple logic if in logic mode
    if(mode == CallMode::Logic)
    {
        bool ret = (MenuMouseRelease && coll);
        if(ret)
            PlaySound(SFX_Saw);
        return ret;
    }

    // otherwise, fully render!
    if(coll && tooltip)
        e_tooltip = tooltip;

    // outline:
    if(sel)
    {
        if(coll && SharedCursor.Primary)
            XRender::renderRect(x - 2, y - 2, 36, 36, XTColorF(0.0_n, 0.5_n, 0.0_n, 1.0_n), true);
        else
            XRender::renderRect(x - 2, y - 2, 36, 36, XTColorF(0.0_n, 1.0_n, 0.0_n, 1.0_n), true);
    }
    else if(coll && SharedCursor.Primary)
        XRender::renderRect(x - 2, y - 2, 36, 36, XTColorF(0.0_n, 0.0_n, 0.0_n, 1.0_n), true);
    else
        XRender::renderRect(x - 2, y - 2, 36, 36, XTColorF(1.0_n, 1.0_n, 1.0_n, 0.5_n), true);

    // background:
    if(SharedCursor.Primary && coll)
        XRender::renderRect(x, y, 32, 32, XTColorF(0.2_n, 0.2_n, 0.2_n), true);
    else
        XRender::renderRect(x, y, 32, 32, XTColorF(0.5_n, 0.5_n, 0.5_n), true);

    // scale and center image
    int dst_x, dst_y, dst_h, dst_w;
    if(src_w > 32 && src_w >= src_h)
    {
        dst_h = (src_h * 32) / src_w;
        dst_w = 32;
    }
    else if(src_h > 32 && src_h > src_w)
    {
        dst_w = (src_w * 32) / src_h;
        dst_h = 32;
    }
    else
    {
        dst_w = src_w;
        dst_h = src_h;
    }
    dst_x = x + 16 - dst_w / 2;
    dst_y = y + 16 - dst_h / 2;

    if(dst_w > src_w)
        D_pLogCriticalNA("Editor upscaling image (should never happen)");


    XRender::renderTextureScaleEx(dst_x, dst_y, dst_w, dst_h, im, src_x, src_y, src_w, src_h);
    return false;
}

bool EditorScreen::UpdateCheckBox(CallMode mode, int x, int y, bool sel, const char* tooltip)
{
    if(sel)
        return this->UpdateButton(mode, x, y, GFX.EIcons, sel, 0, 32*Icon::check, 32, 32, tooltip);
    else
        return this->UpdateButton(mode, x, y, GFX.EIcons, sel, 0, 0, 1, 1, tooltip);
}

bool EditorScreen::UpdateNPCButton(CallMode mode, int x, int y, NPCID type, bool sel)
{
    int draw_width, draw_height;
    if(NPCWidthGFX(type) == 0)
    {
        draw_width = NPCWidth(type);
        draw_height = NPCHeight(type);
    }
    else
    {
        draw_width = NPCWidthGFX(type);
        draw_height = NPCHeightGFX(type);
    }

    return UpdateButton(mode, x, y, GFXNPC[type], sel, 0, 0, draw_width, draw_height);
}

void EditorScreen::UpdateNPC(CallMode mode, int x, int y, NPCID type)
{
    if((type < 1) || (type > maxNPCType))
    {
        pLogWarning("Attempted to render NPC type %d, but the max NPC type is %d!", type, maxNPCType);
        return;
    }
    if(m_special_page != SPECIAL_PAGE_BLOCK_CONTENTS)
    {
        bool sel = (EditorCursor.NPC.Type == type ||
            (EditorCursor.NPC.Special == type && NPCIsContainer(EditorCursor.NPC)));

        if(UpdateNPCButton(mode, x, y, type, sel) && !sel)
            SetEditorNPCType(type);
    }
    else
    {
        bool sel = (EditorCursor.Block.Special == type + 1000);
        if(UpdateNPCButton(mode, x, y, type, sel) && !sel)
            EditorCursor.Block.Special = type + 1000;
    }
}

void EditorScreen::UpdateNPCGrid(CallMode mode, int x, int y, const int* types, int n_npcs, int n_cols)
{
    for(int i = 0; i < n_npcs; i ++)
    {
        int type = types[i];
        if(!type)
            continue;

        int row = i / n_cols;
        int col = i % n_cols;
        UpdateNPC(mode, x + col * 40 + 4, y + row * 40 + 4, NPCID(type));
    }
}

void EditorScreen::UpdateNPCScreen(CallMode mode)
{
    // NPC GUI
    if(mode == CallMode::Render)
    {
        XRender::renderRect(e_ScreenW - 200, 40, 200, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
        XRender::renderRect(0, 40, 40, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
        XRender::renderRect(38, 40, 2, e_ScreenH - 40, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
    }

    if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS && UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
    {
        m_special_page = SPECIAL_PAGE_NONE;
    }

    // Page selector
    int last_category = -1;
    int index = 0;

    for(const EditorCustom::ItemPage_t& page : EditorCustom::npc_pages)
    {
        if(page.category != last_category)
        {
            last_category = page.category;

            if(mode == CallMode::Render && index != 0)
                XRender::renderRect(0, 40 + -2 + (40 * index), 40, 4, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
        }

        index++;

        if(UpdateNPCButton(mode, 4, 4 + (40 * index), NPCID(page.icon), m_NPC_page == index))
            m_NPC_page = index;
    }

    if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS && mode == CallMode::Render)
        XRender::renderRect(0, (40 * index) + 40 + -2, 40, 4, XTColorF(0.25_n, 0.0_n, 0.5_n), true);

    if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS && UpdateNPCButton(mode, 4, 4 + (40 * index) + 40, NPCID_COIN_S3, m_NPC_page == -1))
        m_NPC_page = -1;


    if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS && mode == CallMode::Render)
    {
        FontManager::printTextOptiPx(g_editorStrings.pickBlockContents,
                                     e_ScreenW - 200, 90,
                                     230,
                                     FontManager::fontIdFromSmbxFont(3));
//        SuperPrint(g_editorStrings.pickBlockContents1, 3, e_ScreenW - 200, 90);
//        SuperPrint(g_editorStrings.pickBlockContents2, 3, e_ScreenW - 200, 110);
    }

    if(m_special_page != SPECIAL_PAGE_BLOCK_CONTENTS)
    {
        // Containers
        SuperPrintCenterR(mode, g_editorStrings.npcInContainer, 3, e_ScreenW - 20, 40);
        if(UpdateButton(mode, e_ScreenW - 40 + 4, 60 + 4, GFXNPC[NPCID_ITEM_BURIED], EditorCursor.NPC.Type == NPCID_ITEM_BURIED, 0, 0, NPCWidth(NPCID_ITEM_BURIED), NPCHeight(NPCID_ITEM_BURIED)))
        {
            if(EditorCursor.NPC.Type == NPCID_ITEM_BURIED)
            {
                EditorCursor.NPC.Type = NPCID(EditorCursor.NPC.Special);
                EditorCursor.NPC.Special = 0;
            }
            else if(!NPCIsContainer(EditorCursor.NPC))
            {
                EditorCursor.NPC.Special = EditorCursor.NPC.Type;
                EditorCursor.NPC.Type = NPCID_ITEM_BURIED;
            }
            else
            {
                EditorCursor.NPC.Type = NPCID_ITEM_BURIED;
            }
        }

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 100 + 4, GFXNPC[NPCID_ITEM_POD], EditorCursor.NPC.Type == NPCID_ITEM_POD))
        {
            if(EditorCursor.NPC.Type == NPCID_ITEM_POD)
            {
                EditorCursor.NPC.Type = NPCID(EditorCursor.NPC.Special);
                EditorCursor.NPC.Special = 0;
            }
            else if(!NPCIsContainer(EditorCursor.NPC))
            {
                EditorCursor.NPC.Special = EditorCursor.NPC.Type;
                EditorCursor.NPC.Type = NPCID_ITEM_POD;
            }
            else
            {
                EditorCursor.NPC.Type = NPCID_ITEM_POD;
            }
        }

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 140 + 4, GFXNPC[NPCID_ITEM_THROWER], EditorCursor.NPC.Type == NPCID_ITEM_THROWER, 0, 0, NPCWidthGFX(NPCID_ITEM_THROWER), NPCHeightGFX(NPCID_ITEM_THROWER)))
        {
            if(EditorCursor.NPC.Type == NPCID_ITEM_THROWER)
            {
                EditorCursor.NPC.Type = NPCID(EditorCursor.NPC.Special);
                EditorCursor.NPC.Special = 0;
            }
            else if(!NPCIsContainer(EditorCursor.NPC))
            {
                EditorCursor.NPC.Special = EditorCursor.NPC.Type;
                EditorCursor.NPC.Type = NPCID_ITEM_THROWER;
            }
            else
            {
                EditorCursor.NPC.Type = NPCID_ITEM_THROWER;
            }
        }

        if(FileFormat == FileFormats::LVL_PGEX && UpdateButton(mode, e_ScreenW - 40 + 4, 180 + 4, GFXNPC[NPCID_SPIT_BOSS], (EditorCursor.NPC.Type == NPCID_SPIT_BOSS && EditorCursor.NPC.Special), 0, 0, NPCWidthGFX(NPCID_SPIT_BOSS), NPCHeightGFX(NPCID_SPIT_BOSS)))
        {
            if(EditorCursor.NPC.Type == NPCID_SPIT_BOSS && EditorCursor.NPC.Special)
            {
                EditorCursor.NPC.Type = NPCID(EditorCursor.NPC.Special);
                EditorCursor.NPC.Special = 0;
            }
            else if(!NPCIsContainer(EditorCursor.NPC))
            {
                EditorCursor.NPC.Special = EditorCursor.NPC.Type;
                EditorCursor.NPC.Type = NPCID_SPIT_BOSS;
            }
            else
            {
                EditorCursor.NPC.Type = NPCID_SPIT_BOSS;
            }
        }

        if(AllowBubble())
        {
            if(UpdateButton(mode, e_ScreenW - 40 + 4, ((FileFormat == FileFormats::LVL_PGEX) ? 220 : 180) + 4, GFXNPC[NPCID_ITEM_BUBBLE], EditorCursor.NPC.Type == NPCID_ITEM_BUBBLE, 0, 0, NPCWidthGFX(NPCID_ITEM_BUBBLE), NPCHeightGFX(NPCID_ITEM_BUBBLE)))
            {
                if(EditorCursor.NPC.Type == NPCID_ITEM_BUBBLE)
                {
                    EditorCursor.NPC.Type = NPCID(EditorCursor.NPC.Special);
                    EditorCursor.NPC.Special = 0;
                }
                else if(!NPCIsContainer(EditorCursor.NPC))
                {
                    EditorCursor.NPC.Special = EditorCursor.NPC.Type;
                    EditorCursor.NPC.Type = NPCID_ITEM_BUBBLE;
                }
                else
                {
                    EditorCursor.NPC.Type = NPCID_ITEM_BUBBLE;
                }
            }
        }

        // Various properties that depend on type, get the real one here:
        NPCID type;
        if(NPCIsContainer(EditorCursor.NPC))
        {
            type = (NPCID)EditorCursor.NPC.Special;
        }
        else
        {
            type = EditorCursor.NPC.Type;
        }

        // Direction
        Icon::Icons dir_neg_icon = Icon::left;
        Icon::Icons dir_pos_icon = Icon::right;

        bool show_random = true;
        if(type == NPCID_CONVEYOR || type == NPCID_YEL_PLATFORM || type == NPCID_BLU_PLATFORM || type == NPCID_GRN_PLATFORM || type == NPCID_RED_PLATFORM)
            show_random = false;

        // "direction" means different things for these types
        if(mode == CallMode::Render)
        {
            if(type == NPCID_YEL_PLATFORM || type == NPCID_BLU_PLATFORM || type == NPCID_GRN_PLATFORM || type == NPCID_RED_PLATFORM || type == NPCID_PLATFORM_S3)
            {
                SuperPrintCenter(g_editorStrings.npcPropertyActive, 3, e_ScreenW - 120, 40);
                dir_neg_icon = Icon::x;
                dir_pos_icon = Icon::check;
            }
            else if(type == NPCID_FIRE_DISK || type == NPCID_FIRE_CHAIN)
            {
                SuperPrintCenter(g_editorStrings.npcPropertyAttachSurface, 3, e_ScreenW - 120, 40);
                dir_neg_icon = Icon::bottom;
                dir_pos_icon = Icon::top;
            }
            else
            {
                SuperPrintCenter(g_editorStrings.npcPropertyFacing, 3, e_ScreenW - 120, 40);
                if(type == NPCID_PLATFORM_S1 || (NPCIsAParaTroopa(type) && EditorCursor.NPC.Special == 3))
                {
                    dir_neg_icon = Icon::up;
                    dir_pos_icon = Icon::down;
                }
            }
        }

        // show and apply direction
        if(UpdateButton(mode, e_ScreenW - 180 + 4, 60 + 4, GFX.EIcons, EditorCursor.NPC.Direction == -1, 0, 32 * dir_neg_icon, 32, 32))
            EditorCursor.NPC.Direction = -1;

        if(show_random && UpdateButton(mode, e_ScreenW - 140 + 4, 60 + 4, GFX.EIcons, EditorCursor.NPC.Direction == 0, 0, 32 * Icon::unk, 32, 32))
            EditorCursor.NPC.Direction = 0;

        if(UpdateButton(mode, e_ScreenW - 100 + 4, 60 + 4, GFX.EIcons, EditorCursor.NPC.Direction == 1, 0, 32 * dir_pos_icon, 32, 32))
            EditorCursor.NPC.Direction = 1;

        // Inert ("nice") and Stuck ("stop")
        // The sign (NPC ID 151) is always nice.
        if(type == NPCID_SIGN)
            EditorCursor.NPC.Inert = true;
        else
        {
            SuperPrintRightR(mode, g_editorStrings.npcInertNice, 3, e_ScreenW - 130, 100);
            if(UpdateCheckBox(mode, e_ScreenW - 160 + 4, 120 + 4, EditorCursor.NPC.Inert))
                EditorCursor.NPC.Inert = !EditorCursor.NPC.Inert;
        }

        SuperPrintR(mode, g_editorStrings.npcStuckStop, 3, e_ScreenW - 110, 100);
        if(UpdateCheckBox(mode, e_ScreenW - 120 + 4, 120 + 4, EditorCursor.NPC.Stuck))
            EditorCursor.NPC.Stuck = !EditorCursor.NPC.Stuck;

        // Text
        if(EditorCursor.NPC.Inert)
        {
            MessageText = GetS(EditorCursor.NPC.Text);
            PrepareMessageDims();
            SuperPrintRightR(mode, g_editorStrings.wordText, 3, e_ScreenW - 130, 160);
            if(UpdateButton(mode, e_ScreenW - 160 + 4, 180 + 4, GFX.EIcons, EditorCursor.NPC.Text != STRINGINDEX_NONE, 0, 32*Icon::pencil, 32, 32))
            {
                DisableCursorNew();

                std::string&& prompt = fmt::format_ne(g_editorStrings.phraseTextOf, g_editorStrings.wordNPCGenitive);
                SetS(EditorCursor.NPC.Text, TextEntryScreen::Run(prompt, GetS(EditorCursor.NPC.Text)));

                s_fix_mouse_pos();
            }
        }

        // Wings
        if(FileFormat == FileFormats::LVL_PGEX && !NPCBansWings(EditorCursor.NPC))
        {
            int icon = 32;

            if(EditorCursor.NPC.Wings == WING_JUMP)
                icon = Icon::hop;
            else if(EditorCursor.NPC.Wings == WING_LEFTRIGHT)
                icon = Icon::lr;
            else if(EditorCursor.NPC.Wings == WING_UPDOWN)
                icon = Icon::ud;
            else if(EditorCursor.NPC.Wings == WING_CHASE)
                icon = Icon::target;
            else if(EditorCursor.NPC.Wings == WING_FLEE)
                icon = Icon::hide;

            if(UpdateButton(mode, e_ScreenW - 200 + 4, 180 + 4, GFX.EIcons, EditorCursor.NPC.DefaultWings != WING_NONE, 0, 32 * icon, 32, 32))
            {
                if(EditorCursor.NPC.DefaultWings >= WING_FLEE)
                    EditorCursor.NPC.DefaultWings = WING_NONE;
                else if(EditorCursor.NPC.DefaultWings >= WING_CHASE)
                    EditorCursor.NPC.DefaultWings = WING_FLEE;
                else
                    EditorCursor.NPC.DefaultWings = (WingBehaviors)((int)EditorCursor.NPC.DefaultWings + 1);

                EditorCursor.NPC.Wings = EditorCursor.NPC.DefaultWings;
            }

            if(mode == CallMode::Render)
            {
                int sz = (icon == 32) ? 32 : 16;
                XRender::renderTextureScaleEx(e_ScreenW - 200 + 4, 180 + 4, sz, sz, GFX.YoshiWings, 0, 0, 32, 32);
            }
        }

        // Generator
        SuperPrintR(mode, g_editorStrings.npcAbbrevGen, 3, e_ScreenW - 110, 160);
        if(UpdateButton(mode, e_ScreenW - 120 + 4, 180 + 4, GFX.EIcons, EditorCursor.NPC.Generator, 0, 32*Icon::subscreen, 32, 32))
            m_NPC_page = -2;

        // GFX slot
        if(FileFormat == FileFormats::LVL_PGEX)
        {
            int GFX_type = (EditorCursor.NPC.Type == NPCID_ITEM_BUBBLE) ? EditorCursor.NPC.Special : (int)EditorCursor.NPC.Type;
            int gw = NPCTraits[GFX_type].WidthGFX;
            int gh = NPCTraits[GFX_type].HeightGFX;
            if(gw == 0)
            {
                gw = NPCTraits[GFX_type].TWidth;
                gh = NPCTraits[GFX_type].THeight;
            }

            int avail_slots = GFXNPC[GFX_type].w / gw;

            if(avail_slots > 1 && UpdateButton(mode, e_ScreenW - 80 + 4, 180 + 4, GFXNPC[GFX_type], false, gw * EditorCursor.NPC.GFXSlot, 0, gw, gh))
                EditorCursor.NPC.GFXSlot++;

            if(EditorCursor.NPC.GFXSlot >= avail_slots)
                EditorCursor.NPC.GFXSlot = 0;
        }

        // Behavior
        if(NPCIsAParaTroopa(EditorCursor.NPC))
        {
            // Describe current AI if valid
            if(mode == CallMode::Render)
            {
                std::string ai_invalid;
                const std::string* ai_name = &ai_invalid;

                int index = EditorCursor.NPC.Special;

                if(index >= 0 && index < 4)
                {
                    const std::string* map[] = {
                        &g_editorStrings.npcAiTarget,
                        &g_editorStrings.npcAiJump,
                        &g_editorStrings.npcAiLR,
                        &g_editorStrings.npcAiUD,
                    };
                    ai_name = map[index];
                }

                std::string&& ai_is = fmt::format_ne(g_editorStrings.npcAiIs, *ai_name);

                SuperPrint(ai_is, 3, e_ScreenW - 200, 220);
            }

            if(UpdateButton(mode, e_ScreenW - 200 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 1, 0, 32*Icon::hop, 32, 32))
                EditorCursor.NPC.Special = 1;

            if(UpdateButton(mode, e_ScreenW - 160 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 0, 0, 32*Icon::target, 32, 32))
                EditorCursor.NPC.Special = 0;

            if(UpdateButton(mode, e_ScreenW - 120 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 2, 0, 32*Icon::lr, 32, 32))
                EditorCursor.NPC.Special = 2;

            if(UpdateButton(mode, e_ScreenW - 80 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 3, 0, 32*Icon::ud, 32, 32))
                EditorCursor.NPC.Special = 3;
        }

        if(EditorCursor.NPC->IsFish)
        {
            // Describe current AI if valid
            if(mode == CallMode::Render)
            {
                std::string ai_invalid;
                const std::string* ai_name = &ai_invalid;

                int index = EditorCursor.NPC.Special;

                if(index >= 0 && index < 5)
                {
                    const std::string* map[] =
                    {
                        &g_editorStrings.npcAiSwim,
                        &g_editorStrings.npcAiJump,
                        &g_editorStrings.npcAiLeap,
                        &g_editorStrings.npcAiLR,
                        &g_editorStrings.npcAiUD,
                    };
                    ai_name = map[index];
                }

                std::string&& ai_is = fmt::format_ne(g_editorStrings.npcAiIs, *ai_name);

                SuperPrint(ai_is, 3, e_ScreenW - 200, 220);
            }

            if(UpdateButton(mode, e_ScreenW - 200 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 0, 0, 32*Icon::wave, 32, 32))
                EditorCursor.NPC.Special = 0;

            if(UpdateButton(mode, e_ScreenW - 160 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 1, 0, 32*Icon::hop, 32, 32))
                EditorCursor.NPC.Special = 1;

            if(UpdateButton(mode, e_ScreenW - 120 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 2, 0, 32*Icon::leap, 32, 32))
                EditorCursor.NPC.Special = 2;

            if(UpdateButton(mode, e_ScreenW - 80 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 3, 0, 32*Icon::lr, 32, 32))
                EditorCursor.NPC.Special = 3;

            if(UpdateButton(mode, e_ScreenW - 40 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Special == 4, 0, 32*Icon::ud, 32, 32))
                EditorCursor.NPC.Special = 4;
        }

        if(type == NPCID_MINIBOSS || type == NPCID_SPIT_BOSS || type == NPCID_VILLAIN_S3)
        {
            SuperPrintR(mode, g_editorStrings.npcUse1_0Ai, 3, e_ScreenW - 200, 220);
            if(UpdateButton(mode, e_ScreenW - 200 + 4, 240 + 4, GFX.EIcons, EditorCursor.NPC.Legacy, 0, 32*Icon::_10, 32, 32))
                EditorCursor.NPC.Legacy = true;

            if(UpdateButton(mode, e_ScreenW - 160 + 4, 240 + 4, GFX.EIcons, !EditorCursor.NPC.Legacy, 0, 32*Icon::_1x, 32, 32))
                EditorCursor.NPC.Legacy = false;
        }

        if(EditorCursor.NPC.Type == NPCID_FIRE_CHAIN)
        {
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseRadiusIndex, EditorCursor.NPC.Special), 3, e_ScreenW - 200, 220);

            if(EditorCursor.NPC.Special > 0 && UpdateButton(mode, e_ScreenW - 160 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
                EditorCursor.NPC.Special --;

            if(UpdateButton(mode, e_ScreenW - 120 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
                EditorCursor.NPC.Special ++;
        }

        bool is_magic_door = (EditorCursor.NPC.Type == NPCID_MAGIC_DOOR || EditorCursor.NPC.Type == NPCID_DOOR_MAKER
            || (EditorCursor.NPC.Type == NPCID_ITEM_BURIED && EditorCursor.NPC.Special == NPCID_DOOR_MAKER));

        bool is_multistar = ((type == NPCID_STAR_COLLECT || type == NPCID_STAR_EXIT || type == NPCID_MEDAL) && FileFormat == FileFormats::LVL_PGEX);

        // multistars and magic door destination
        if(is_magic_door || is_multistar)
        {
            if(is_magic_door)
            {
                std::string&& dest_section = fmt::format_ne(g_editorStrings.phraseSectionIndex, EditorCursor.NPC.Variant + 1);
                SuperPrintR(mode, dest_section, 3, e_ScreenW - 200, 220);
            }
            else
            {
                std::string&& star_index = EditorCursor.NPC.Variant ? fmt::format_ne(g_editorStrings.phraseGenericIndex, (int)(EditorCursor.NPC.Variant)) : g_editorStrings.fileFormatLegacy;
                SuperPrintCenterR(mode, star_index, 3, e_ScreenW - 120, 220);
            }

            uint8_t max_index = (type == NPCID_MEDAL) ? 8 : 20;

            if(EditorCursor.NPC.Variant > 0 && UpdateButton(mode, e_ScreenW - 160 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
                EditorCursor.NPC.Variant --;

            if(EditorCursor.NPC.Variant < max_index && UpdateButton(mode, e_ScreenW - 120 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
                EditorCursor.NPC.Variant ++;
        }

        const NPC_Variant_Data_t* data = find_Variant_Data(EditorCursor.NPC.Type);

        // special case for NPCID_VILLAIN_S3 since it also has the Legacy button
        if(EditorCursor.NPC.Type == NPCID_VILLAIN_S3 && FileFormat == FileFormats::LVL_PGEX)
        {
            if(UpdateButton(mode, e_ScreenW - 40 + 4, 240 + 4, GFXBlock[4], EditorCursor.NPC.Variant == 1,
                0, 32 * BlockFrame[4], 32, 32, g_editorStrings.npcTooltipExpandSection.c_str()))
            {
                if(EditorCursor.NPC.Variant == 0)
                    EditorCursor.NPC.Variant = 1;
                else
                    EditorCursor.NPC.Variant = 0;
            }
        }
        else if(data && FileFormat == FileFormats::LVL_PGEX)
        {
            int i;
            bool valid;

            i = data->find_current(EditorCursor.NPC.Variant);
            valid = data->strings[i] != nullptr;

            if(mode == CallMode::Render)
            {
                SuperPrint(g_editorStrings.npcCustomAi, 3, e_ScreenW - 180, 220);
                if(valid)
                    SuperPrint(data->strings[i], 3, e_ScreenW - 160, 242);
                else
                    SuperPrint(std::to_string(EditorCursor.NPC.Variant), 3, e_ScreenW - 160, 242);
            }

            // only show it if it will (i) reset, or (ii) have something to go to.
            // short-circuit evaluation keeps this from accessing outside of the valid range
            bool show_prev_button = (!valid || i != 0);
            bool show_next_button = (!valid || data->strings[i + 1]);
            if(show_prev_button && UpdateButton(mode, e_ScreenW - 200 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            {
                if(!valid)
                    EditorCursor.NPC.Variant = data->values[0];
                else
                    EditorCursor.NPC.Variant = data->values[i-1];
            }

            if(show_next_button && UpdateButton(mode, e_ScreenW - 40 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            {
                if(!valid)
                    EditorCursor.NPC.Variant = data->values[0];
                else
                    EditorCursor.NPC.Variant = data->values[i + 1];
            }
        }

        // Events
        if(mode == CallMode::Render)
        {
            SuperPrintRightAlign(g_editorStrings.eventsHeader, 3, e_ScreenW - 40, 294);
            SuperPrint(g_editorStrings.eventsLetterActivate   + GetE(EditorCursor.NPC.TriggerActivate), 3, e_ScreenW - 200, 320);
            SuperPrint(g_editorStrings.eventsLetterDeath      + GetE(EditorCursor.NPC.TriggerDeath), 3, e_ScreenW - 200, 340);
            SuperPrint(g_editorStrings.eventsLetterTalk       + GetE(EditorCursor.NPC.TriggerTalk), 3, e_ScreenW - 200, 360);
            SuperPrint(g_editorStrings.eventsLetterLayerClear + GetE(EditorCursor.NPC.TriggerLast), 3, e_ScreenW - 200, 380);
        }

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 280 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
            m_special_page = SPECIAL_PAGE_OBJ_TRIGGERS;

        // Layers
        if(mode == CallMode::Render)
        {
            SuperPrintRightAlign(g_editorStrings.labelLayer, 3, e_ScreenW - 40, 414);
            if(EditorCursor.NPC.Layer == LAYER_NONE)
                SuperPrint(g_editorStrings.layersLayerDefault, 3, e_ScreenW - 200, 440);
            else
                SuperPrint(GetL(EditorCursor.NPC.Layer), 3, e_ScreenW - 200, 440);
            if(EditorCursor.NPC.AttLayer != LAYER_NONE && EditorCursor.NPC.AttLayer != LAYER_DEFAULT)
                SuperPrint(g_editorStrings.layersAbbrevAttLayer + GetL(EditorCursor.NPC.AttLayer), 3, e_ScreenW - 200, 460);
        }

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 400 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
            m_special_page = SPECIAL_PAGE_OBJ_LAYER;
    }


    // NPC selector
    if(!EditorCustom::npc_pages.empty() && m_NPC_page > 0 && m_NPC_page <= (int)EditorCustom::npc_pages.size())
    {
        const EditorCustom::ItemPage_t& page = EditorCustom::npc_pages[m_NPC_page - 1];

        for(auto it = page.begin; it != page.end; ++it)
        {
            const EditorCustom::ItemFamily& family = **it;

            if(mode == CallMode::Render)
            {
                int pix_len = SuperTextPixLen(family.name, 3);

                if(40 + family.X * 40 + pix_len > e_ScreenW - 200)
                    SuperPrint(family.name, 3, e_ScreenW - 200 - 4 - pix_len, 40 + family.Y * 20);
                else
                    SuperPrint(family.name, 3, 40 + family.X * 40 + 4, 40 + family.Y * 20);
            }

            UpdateNPCGrid(mode, 40 + family.X * 40, 60 + family.Y * 20, family.layout_pod.types.data(), family.layout_pod.types.size(), family.layout_pod.cols);
        }
    }


    // GENERATOR SETTINGS SCREEN
    if(m_NPC_page == -2 && m_special_page != SPECIAL_PAGE_BLOCK_CONTENTS)
    {
        SuperPrintR(mode, g_editorStrings.npcGenHeader, 3, 50, 44);

        if(UpdateButton(mode, e_ScreenW - 200 - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
            FocusNPC();

        SuperPrintR(mode, g_editorStrings.wordEnabled, 3, 50, 110);

        if(UpdateCheckBox(mode, 280 + 4, 100 + 4, EditorCursor.NPC.Generator))
        {
            EditorCursor.NPC.Generator = true;

            // Set GeneratorDirection and GeneratorEffect both to 1
            if(!EditorCursor.NPC.Special3)
                EditorCursor.NPC.Special3 = 0x0101;

            // GeneratorTimeMax
            if(EditorCursor.NPC.GeneratorTimeMax() < 1)
                EditorCursor.NPC.GeneratorTimeMax() = 1;
        }

        if(UpdateButton(mode, 320 + 4, 100 + 4, GFX.EIcons, !EditorCursor.NPC.Generator, 0, 32*Icon::x, 32, 32))
            EditorCursor.NPC.Generator = false;

        if(EditorCursor.NPC.Generator)
        {
            // direction change
            uint8_t GeneratorDirection = EditorCursor.NPC.GeneratorDirection();
            SuperPrintR(mode, g_editorStrings.npcGenDirection, 3, 50, 150);

            if(UpdateButton(mode, 280 + 4, 140 + 4, GFX.EIcons, GeneratorDirection == 1, 0, 32*Icon::up, 32, 32))
                GeneratorDirection = 1;

            if(UpdateButton(mode, 320 + 4, 140 + 4, GFX.EIcons, GeneratorDirection == 3, 0, 32*Icon::down, 32, 32))
                GeneratorDirection = 3;

            if(UpdateButton(mode, 360 + 4, 140 + 4, GFX.EIcons, GeneratorDirection == 2, 0, 32*Icon::left, 32, 32))
                GeneratorDirection = 2;

            if(UpdateButton(mode, 400 + 4, 140 + 4, GFX.EIcons, GeneratorDirection == 4, 0, 32*Icon::right, 32, 32))
                GeneratorDirection = 4;

            // effect change
            uint8_t GeneratorEffect = EditorCursor.NPC.GeneratorEffect();
            const std::string& effect =
                   (GeneratorEffect == 1) ? g_editorStrings.npcGenEffectWarp
                : ((GeneratorEffect == 2) ? g_editorStrings.npcGenEffectShoot
                : g_mainMenu.caseNone);
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.npcGenEffectIs, effect), 3, 50, 190);

            if(UpdateButton(mode, 280 + 4, 180 + 4, GFX.EIcons, GeneratorEffect == 1, 0, 32*Icon::bottom, 32, 32))
                GeneratorEffect = 1;

            if(UpdateButton(mode, 320 + 4, 180 + 4, GFX.EIcons, GeneratorEffect == 2, 0, 32*Icon::up, 32, 32))
                GeneratorEffect = 2;

            // assign back to updated internal representation in Special3
            EditorCursor.NPC.Special3 = ((uint16_t)GeneratorDirection << 8) + (uint8_t)GeneratorEffect;

            // delay change
            auto& GeneratorTimeMax = EditorCursor.NPC.GeneratorTimeMax();
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseDelayIsMs, GeneratorTimeMax * 100), 3, 50, 230);

            if(GeneratorTimeMax > 1 && UpdateButton(mode, 280 + 4, 220 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
                GeneratorTimeMax --;

            if(UpdateButton(mode, 320 + 4, 220 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
                GeneratorTimeMax ++;
        }
    }

    // COMMON CONTENTS
    if(m_NPC_page == -1 && m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS)
    {
        SuperPrintR(mode, g_editorStrings.wordCoins, 3, 110, 40);

        bool currently_coins = EditorCursor.Block.Special > 0 && EditorCursor.Block.Special < 100;
        if(UpdateButton(mode, 100 + 4, 60 + 4, GFXNPC[NPCID_COIN_S3], currently_coins, 0, 0, 32, 32) && !currently_coins)
        {
            EditorCursor.Block.Special = 1;
            currently_coins = true;
        }

        if(currently_coins)
        {
            SuperPrint("x" + std::to_string(EditorCursor.Block.Special), 3, 140, 74);
            if(EditorCursor.Block.Special > 0 && UpdateButton(mode, 220 + 4, 60 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
                EditorCursor.Block.Special --;
            if(EditorCursor.Block.Special < 99 && UpdateButton(mode, 260 + 4, 60 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
                EditorCursor.Block.Special ++;
        }

        if(FileFormat == FileFormats::LVL_PGEX)
        {
            if(UpdateButton(mode, 60 + 4, 60 + 4, (CommonFrame & 32) ? GFXNPC[NPCID_INVINCIBILITY_POWER] : GFXNPC[NPCID_COIN_S3], EditorCursor.Block.Special == 110, 0, 0, 32, 32))
                EditorCursor.Block.Special = 110;
        }

        SuperPrintR(mode, g_mainMenu.caseNone, 3, 40 + 260, 40);
        if(UpdateButton(mode, 360 + 4, 60 + 4, GFXBlock[2], EditorCursor.Block.Special == 0, 0, 0, 32, 32))
            EditorCursor.Block.Special = 0;

        SuperPrintR(mode, "3", 3, 40 + 10, 140);
        static const int p7_common[] = {NPCID_COIN_S3, NPCID_POWER_S3, NPCID_LIFE_S3, NPCID_FIRE_POWER_S3, NPCID_ICE_POWER_S3, NPCID_LEAF_POWER, NPCID_STATUE_POWER, NPCID_HEAVY_POWER, NPCID_GRN_VINE_TOP_S3, NPCID_RANDOM_POWER};
        UpdateNPCGrid(mode, 40, 160, p7_common, sizeof(p7_common)/sizeof(int), 10);

        SuperPrintR(mode, "4", 3, 40 + 10, 200);
        static const int p7_smw[] = {NPCID_COIN_S4, NPCID_POWER_S4, NPCID_LIFE_S4, NPCID_FIRE_POWER_S4, NPCID_3_LIFE, NPCID_ICE_POWER_S4, NPCID_PET_GREEN, NPCID_KEY, NPCID_GRN_VINE_TOP_S4};
        UpdateNPCGrid(mode, 40, 220, p7_smw, sizeof(p7_smw)/sizeof(int), 10);

        SuperPrintR(mode, "1", 3, 40 + 10, 260);
        static const int p7_smb1[] = {NPCID_COIN_S1, NPCID_POWER_S1, NPCID_LIFE_S1, NPCID_FIRE_POWER_S1, NPCID_POISON};
        UpdateNPCGrid(mode, 40, 280, p7_smb1, sizeof(p7_smb1)/sizeof(int), 5);

        SuperPrintR(mode, "2", 3, 40 + 10, 320);
        static const int p7_smb2[] = {NPCID_COIN_S2, NPCID_POWER_S2, NPCID_BOMB, NPCID_EARTHQUAKE_BLOCK, NPCID_TIMER_S2};
        UpdateNPCGrid(mode, 40, 340, p7_smb2, sizeof(p7_smb2)/sizeof(int), 5);

        SuperPrintR(mode, "X", 3, 40 + 10, 380);
        static const int p7_misc[] = {NPCID_RING, NPCID_POWER_S5, NPCID_FLY_POWER, NPCID_GEM_1, NPCID_GEM_5, NPCID_GEM_20, NPCID_INVINCIBILITY_POWER, NPCID_AQUATIC_POWER, NPCID_POLAR_POWER, NPCID_CYCLONE_POWER, NPCID_SHELL_POWER};
        UpdateNPCGrid(mode, 40, 400, p7_misc, sizeof(p7_misc)/sizeof(int) - (FileFormat != FileFormats::LVL_PGEX) * 5, 10);
    }
}

#if 0
void EditorScreen::UpdateMagicBlockScreen(CallMode mode)
{
    SuperPrintR(mode, "MAGIC BLOCK (DEPRECATED EXTRA SETTINGS)", 3, 160, 50);

    if(UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
        m_special_page = SPECIAL_PAGE_EDITOR_SETTINGS;

    SuperPrintR(mode, "Enable", 3, 90, 94);
    if(UpdateCheckBox(mode, 40 + 4, 80 + 4, MagicBlock::enabled))
        MagicBlock::enabled = !MagicBlock::enabled;

    SuperPrintR(mode, "Overwrite existing items", 3, 90, 134);
    if(UpdateCheckBox(mode, 40 + 4, 120 + 4, MagicBlock::replace_existing))
        MagicBlock::replace_existing = !MagicBlock::replace_existing;


    if(MagicBlock::enabled)
    {
        SuperPrintR(mode, "Check level edges", 3, 90, 174);
        if(UpdateCheckBox(mode, 40 + 4, 160 + 4, MagicBlock::count_level_edges))
            MagicBlock::count_level_edges = !MagicBlock::count_level_edges;


        SuperPrintR(mode, "ADVANCED", 3, 280, 240);


        SuperPrintR(mode, "Allow inner edges", 3, 90, 274);
        if(UpdateCheckBox(mode, 40 + 4, 260 + 4, MagicBlock::advanced_mode))
            MagicBlock::advanced_mode = !MagicBlock::advanced_mode;


        SuperPrintR(mode, "Check", 3, 160, 320);

        SuperPrintR(mode, "All", 3, 90, 354);
        if(UpdateCheckBox(mode, 40 + 4, 340 + 4, MagicBlock::check_level == MagicBlock::LEVEL_ALL))
            MagicBlock::check_level = MagicBlock::LEVEL_ALL;

        SuperPrintR(mode, "Family", 3, 90, 394);
        if(UpdateCheckBox(mode, 40 + 4, 380 + 4, MagicBlock::check_level == MagicBlock::LEVEL_FAMILY))
            MagicBlock::check_level = MagicBlock::LEVEL_FAMILY;

        SuperPrintR(mode, "Subgroup", 3, 90, 434);
        if(UpdateCheckBox(mode, 40 + 4, 420 + 4, MagicBlock::check_level == MagicBlock::LEVEL_GROUP))
            MagicBlock::check_level = MagicBlock::LEVEL_GROUP;

        SuperPrintR(mode, "Change", 3, 460, 320);

        SuperPrintR(mode, "All", 3, 320 + 90, 354);
        if(UpdateCheckBox(mode, 320 + 40 + 4, 340 + 4, MagicBlock::change_level == MagicBlock::LEVEL_ALL))
            MagicBlock::change_level = MagicBlock::LEVEL_ALL;

        SuperPrintR(mode, "Family", 3, 320 + 90, 394);
        if(UpdateCheckBox(mode, 320 + 40 + 4, 380 + 4, MagicBlock::change_level == MagicBlock::LEVEL_FAMILY))
            MagicBlock::change_level = MagicBlock::LEVEL_FAMILY;

        SuperPrintR(mode, "Subgroup", 3, 320 + 90, 434);
        if(UpdateCheckBox(mode, 320 + 40 + 4, 420 + 4, MagicBlock::change_level == MagicBlock::LEVEL_GROUP))
            MagicBlock::change_level = MagicBlock::LEVEL_GROUP;
    }

    return;
}
#endif

void EditorScreen::UpdateEventsScreen(CallMode mode)
{
    if(m_special_page == SPECIAL_PAGE_EVENT_DELETION)
    {
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.eventsDeletingEvent, Events[m_current_event].Name), 3, 60, 40);
        SuperPrintR(mode, g_editorStrings.phraseAreYouSure, 3, 10, 60);
        SuperPrintR(mode, g_editorStrings.eventsDeletionConfirm, 3, 60, 110);

        if(UpdateButton(mode, 20 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            DeleteEvent((eventindex_t)m_current_event);
            m_special_page = SPECIAL_PAGE_EVENTS;
            m_current_event = 0;
        }

        SuperPrintR(mode, g_editorStrings.eventsDeletionCancel, 3, 60, 150);
        if(UpdateButton(mode, 20 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_EVENTS;
            m_current_event = 0;
        }
        return;
    }

    // render general GUI
    SuperPrintR(mode, g_editorStrings.eventsHeader, 3, 60, 40);
    int page_max = numEvents / 10;
    SuperPrintR(mode, fmt::format_ne(g_editorStrings.pageBlankOfBlank, m_events_page + 1, page_max + 1), 3, e_ScreenW - 330, 40);

    if(m_events_page > 0 && UpdateButton(mode, e_ScreenW - 120 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        m_events_page --;

    if(m_events_page < page_max && UpdateButton(mode, e_ScreenW - 80 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        m_events_page ++;

    // render event selector
    for(int i = 0; i < 10; i++)
    {
        int e = m_events_page*10 + i;
        auto &eName = Events[e].Name;
        if(!eName.empty())
        {
            if(eName.length() < 20)
                SuperPrintR(mode, eName, 3, 10, 80 + 40*i + 10);
            else
            {
                SuperPrintR(mode, eName.substr(0,19), 3, 10, 80 + 40*i + 2);
                SuperPrintR(mode, eName.substr(19), 3, 10, 80 + 40*i + 20);
            }

            if(UpdateButton(mode, 360 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::page, 32, 32))
            {
                m_special_page = SPECIAL_PAGE_EVENT_SETTINGS;
                m_current_event = e;
            }

            // rename, shift up, shift down, delete

            if(e <= 2)
                continue;

            // rename
            if(UpdateButton(mode, 400 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
            {
                DisableCursorNew();
                std::string new_name = TextEntryScreen::Run(g_editorStrings.eventsPromptEventName, Events[e].Name);
                if(!new_name.empty())
                    RenameEvent((eventindex_t)e, new_name);
                s_fix_mouse_pos();
            }

            // shift up
            if(e > 3 && UpdateButton(mode, 440 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
                SwapEvents(e-1, e);

            // shift down
            if(e < numEvents - 1 && UpdateButton(mode, 480 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
                SwapEvents(e, e+1);

            // delete
            if(e < numEvents && UpdateButton(mode, 520 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
            {
                m_special_page = SPECIAL_PAGE_EVENT_DELETION;
                m_current_event = e;
                return;
            }
        }
        // create a new event!
        else if(e != 0 && !Events[e - 1].Name.empty())
        {
            SuperPrintR(mode, g_editorStrings.eventsItemNewEvent, 3, 54, 80 + 40*i + 10);
            // rename only
            if(UpdateButton(mode, 400 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
            {
                DisableCursorNew();
                std::string new_name = TextEntryScreen::Run(g_editorStrings.eventsPromptEventName, "");
                s_fix_mouse_pos();
                if(!new_name.empty() && FindEvent(new_name) == EVENT_NONE)
                {
                    InitializeEvent(Events[e]);
                    Events[e].Name = new_name;
                    numEvents ++;
                }
            }
        }
    }
}

void EditorScreen::UpdateEventSettingsScreen(CallMode mode)
{
    if(m_special_page == SPECIAL_PAGE_EVENT_CONTROLS)
    {
        const int titlePosX = 10;
        const int titlePosY = 40;
        PGE_Size titleSize = FontManager_printTextOptiPxR(mode,
                                                          fmt::format_ne(g_editorStrings.eventsControlsForEvent,
                                                                         Events[m_current_event].Name),
                                                          titlePosX, titlePosY,
                                                          590,
                                                          FontManager::fontIdFromSmbxFont(3));

        int elementsListBaseY = 80;
        const int elementsLabelOffset = 10;
        const int elementsRowHeight = 40;
        while(titlePosY + titleSize.h() >= elementsListBaseY)
            elementsListBaseY += elementsRowHeight;

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 8 * 32, 32, 32))
            m_special_page = SPECIAL_PAGE_EVENT_SETTINGS;

        using Controls::PlayerControls::Buttons;

        int yOffset = elementsListBaseY;

        if(UpdateCheckBox(mode, 10 + 4, yOffset + 4, Events[m_current_event].Controls.Up))
            Events[m_current_event].Controls.Up = !Events[m_current_event].Controls.Up;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Up), 3, 54, yOffset + elementsLabelOffset);

        if(UpdateCheckBox(mode, e_ScreenW / 2 + 10 + 4, yOffset + 4, Events[m_current_event].Controls.Down))
            Events[m_current_event].Controls.Down = !Events[m_current_event].Controls.Down;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Down), 3, e_ScreenW / 2 + 54, yOffset + elementsLabelOffset);

        yOffset += elementsRowHeight;

        if(UpdateCheckBox(mode, 10 + 4, yOffset + 4, Events[m_current_event].Controls.Left))
            Events[m_current_event].Controls.Left = !Events[m_current_event].Controls.Left;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Left), 3, 54, yOffset + elementsLabelOffset);

        if(UpdateCheckBox(mode, e_ScreenW / 2 + 10 + 4, yOffset + 4, Events[m_current_event].Controls.Right))
            Events[m_current_event].Controls.Right = !Events[m_current_event].Controls.Right;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Right), 3, e_ScreenW / 2 + 54, yOffset + elementsLabelOffset);

        yOffset += elementsRowHeight;

        if(UpdateCheckBox(mode, 10 + 4, yOffset + 4, Events[m_current_event].Controls.Jump))
            Events[m_current_event].Controls.Jump = !Events[m_current_event].Controls.Jump;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Jump), 3, 54, yOffset + elementsLabelOffset);

        if(UpdateCheckBox(mode, e_ScreenW / 2 + 10 + 4, yOffset + 4, Events[m_current_event].Controls.Run))
            Events[m_current_event].Controls.Run = !Events[m_current_event].Controls.Run;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Run), 3, e_ScreenW / 2 + 54, yOffset + elementsLabelOffset);

        yOffset += elementsRowHeight;

        if(UpdateCheckBox(mode, 10 + 4, yOffset + 4, Events[m_current_event].Controls.AltJump))
            Events[m_current_event].Controls.AltJump = !Events[m_current_event].Controls.AltJump;
        SuperPrintR(mode, GetButtonName_UI(Buttons::AltJump), 3, 54, yOffset + elementsLabelOffset);

        if(UpdateCheckBox(mode, e_ScreenW / 2 + 10 + 4, yOffset + 4, Events[m_current_event].Controls.AltRun))
            Events[m_current_event].Controls.AltRun = !Events[m_current_event].Controls.AltRun;
        SuperPrintR(mode, GetButtonName_UI(Buttons::AltRun), 3, e_ScreenW / 2 + 54, yOffset + elementsLabelOffset);

        yOffset += elementsRowHeight;

        if(UpdateCheckBox(mode, 10 + 4, yOffset + 4, Events[m_current_event].Controls.Start))
            Events[m_current_event].Controls.Start = !Events[m_current_event].Controls.Start;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Start), 3, 54, yOffset + elementsLabelOffset);

        if(UpdateCheckBox(mode, e_ScreenW / 2 + 10 + 4, yOffset + 4, Events[m_current_event].Controls.Drop))
            Events[m_current_event].Controls.Drop = !Events[m_current_event].Controls.Drop;
        SuperPrintR(mode, GetButtonName_UI(Buttons::Drop), 3, e_ScreenW / 2 + 54, yOffset + elementsLabelOffset);

        return;
    }

    // SuperPrintR(mode, g_editorStrings.eventsSettingsForEvent, 3, 60, 40);
    // SuperPrintR(mode, Events[m_current_event].Name, 3, 10, 60);
    FontManager_printTextOptiPxR(mode,
                                 fmt::format_ne(g_editorStrings.eventsSettingsForEvent,
                                                Events[m_current_event].Name),
                                 60, 40,
                                 300,
                                 FontManager::fontIdFromSmbxFont(3));


    // RIGHT PANE: layers
    if(mode == CallMode::Render)
        XRender::renderRect(e_ScreenW - 240, 40, 240, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);

    if(UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
    {
        m_special_page = SPECIAL_PAGE_EVENTS;
        m_current_event = 0;
    }

    // layers
    int layer_line = 1;
    if(!Events[m_current_event].ShowLayer.empty())
    {
        layer_line ++;
        SuperPrintR(mode, g_editorStrings.eventsHeaderShow, 3, e_ScreenW - 200, 40 + (20 * layer_line));
        layer_line ++;
        SuperPrintR(mode, GetL(Events[m_current_event].ShowLayer[0]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        layer_line ++;

        if(Events[m_current_event].ShowLayer.size() >= 2)
        {
            SuperPrintR(mode, GetL(Events[m_current_event].ShowLayer[1]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
            layer_line ++;
        }

        if(Events[m_current_event].ShowLayer.size() == 3)
        {
            SuperPrintR(mode, GetL(Events[m_current_event].ShowLayer[2]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
            layer_line ++;
        }
        else if(Events[m_current_event].ShowLayer.size() > 3)
        {
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseCountMore, Events[m_current_event].ShowLayer.size() - 2), 3, e_ScreenW - 220, 40 + (20 * layer_line));
            layer_line ++;
        }
    }

    if(!Events[m_current_event].HideLayer.empty())
    {
        layer_line ++;
        SuperPrintR(mode, g_editorStrings.eventsHeaderHide, 3, e_ScreenW - 200, 40 + (20 * layer_line));
        layer_line ++;
        SuperPrintR(mode, GetL(Events[m_current_event].HideLayer[0]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        layer_line ++;

        if(Events[m_current_event].HideLayer.size() >= 2)
        {
            SuperPrintR(mode, GetL(Events[m_current_event].HideLayer[1]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
            layer_line ++;
        }

        if(Events[m_current_event].HideLayer.size() == 3)
        {
            SuperPrintR(mode, GetL(Events[m_current_event].HideLayer[2]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
            layer_line ++;
        }
        else if(Events[m_current_event].HideLayer.size() > 3)
        {
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseCountMore, Events[m_current_event].HideLayer.size() - 2), 3, e_ScreenW - 220, 40 + (20 * layer_line));
            layer_line ++;
        }
    }

    if(!Events[m_current_event].ToggleLayer.empty())
    {
        layer_line ++;
        SuperPrintR(mode, g_editorStrings.eventsHeaderToggle, 3, e_ScreenW - 200, 40 + (20 * layer_line));
        layer_line ++;
        SuperPrintR(mode, GetL(Events[m_current_event].ToggleLayer[0]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        layer_line ++;

        if(Events[m_current_event].ToggleLayer.size() >= 2)
        {
            SuperPrintR(mode, GetL(Events[m_current_event].ToggleLayer[1]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
            layer_line ++;
        }

        if(Events[m_current_event].ToggleLayer.size() == 3)
        {
            SuperPrintR(mode, GetL(Events[m_current_event].ToggleLayer[2]), 3, e_ScreenW - 240, 40 + (20 * layer_line));
            layer_line ++;
        }
        else if(Events[m_current_event].ToggleLayer.size() > 3)
        {
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseCountMore, Events[m_current_event].ToggleLayer.size() - 2), 3, e_ScreenW - 220, 40 + (20 * layer_line));
            layer_line ++;
        }
    }

    // MoveLayer is a layerindex_t, not a vector
    if(Events[m_current_event].MoveLayer != LAYER_NONE)
    {
        layer_line ++;
        SuperPrintR(mode, g_editorStrings.eventsHeaderMove, 3, e_ScreenW - 200, 40 + (20 * layer_line));
        layer_line ++;
        SuperPrintR(mode, GetL(Events[m_current_event].MoveLayer), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        layer_line ++;

        // settings for this...
        int sy = num_t::round((num_t)Events[m_current_event].SpeedY * 10);
        int sx = num_t::round((num_t)Events[m_current_event].SpeedX * 10);

        if(sy < 0)
            SuperPrintR(mode, g_editorStrings.letterUp + std::to_string(-sy), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        else if(sy > 0)
            SuperPrintR(mode, g_editorStrings.letterDown + std::to_string(sy), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        else
            SuperPrintR(mode, "-", 3, e_ScreenW - 240, 40 + (20 * layer_line));

        layer_line ++;

        if(sx < 0)
            SuperPrintR(mode, g_editorStrings.letterLeft + std::to_string(-sx), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        else if(sx > 0)
            SuperPrintR(mode, g_editorStrings.letterRight + std::to_string(sx), 3, e_ScreenW - 240, 40 + (20 * layer_line));
        else
            SuperPrintR(mode, "-", 3, e_ScreenW - 240, 40 + (20 * layer_line));

        layer_line --;

        if(UpdateButton(mode, e_ScreenW - 160 + 4, 40 + (20 * layer_line) + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
            Events[m_current_event].SpeedY = s_divide_by_ten(sy + 1);

        if(UpdateButton(mode, e_ScreenW - 120 + 4, 40 + (20 * layer_line) + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
            Events[m_current_event].SpeedY = s_divide_by_ten(sy - 1);

        if(UpdateButton(mode, e_ScreenW - 80 + 4, 40 + (20 * layer_line) + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            Events[m_current_event].SpeedX = s_divide_by_ten(sx - 1);

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 40 + (20 * layer_line) + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            Events[m_current_event].SpeedX = s_divide_by_ten(sx + 1);

        layer_line ++;
    }

    if(layer_line == 1)
    {
        SuperPrintR(mode, g_editorStrings.layersHeader, 3, e_ScreenW - 192, 40);
        SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 40 + (20 * layer_line));

        Events[m_current_event].LayerSmoke = false;
    }
    else
    {
        SuperPrintR(mode, g_editorStrings.layersHeader, 3, e_ScreenW - 192, 50);

        // layer smoke (bottom of layers pane)
        SuperPrintR(mode, g_editorStrings.eventsPropLayerSmoke, 3, e_ScreenW - 192, 40 + (20 * layer_line) + 30);
        if(UpdateCheckBox(mode, e_ScreenW - 240 + 4, 40 + (20 * layer_line) + 24, !Events[m_current_event].LayerSmoke))
            Events[m_current_event].LayerSmoke = !Events[m_current_event].LayerSmoke;
    }

    if(UpdateButton(mode, e_ScreenW - 240 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_EVENT_LAYERS;

    // BOTTOM PANE: sections - background, music, autoscroll
    if(mode == CallMode::Render)
        XRender::renderRect(0, e_ScreenH - 180, e_ScreenW - 240, 180, XTColorF(0.6_n, 0.6_n, 0.8_n), true);

    if(m_special_subpage > 0 && UpdateButton(mode, 40 + 4, e_ScreenH - 180 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        m_special_subpage --;

    if(m_special_subpage < maxSections + 1 && UpdateButton(mode, 320 + 4, e_ScreenH - 180 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        m_special_subpage ++;

    // description of possibilities
    SuperPrintCenterR(mode, g_editorStrings.eventsActionKeep, 3, 170, e_ScreenH - 140);
    SuperPrintCenterR(mode, g_editorStrings.eventsActionReset, 3, 270, e_ScreenH - 140);
    SuperPrintCenterR(mode, g_editorStrings.eventsActionSet, 3, 370, e_ScreenH - 140);

    SuperPrintR(mode, g_editorStrings.eventsCaseMusic, 3, 4, e_ScreenH - 110);
    SuperPrintR(mode, g_editorStrings.eventsCaseBackground, 3, 4, e_ScreenH - 70);
    SuperPrintR(mode, g_editorStrings.eventsCaseBounds, 3, 4, e_ScreenH - 30);

    // subpage - 1 is the internal section ID; subpage 0 is all sections.
    if(m_special_subpage == 0)
    {
        SuperPrintCenterR(mode, g_editorStrings.eventsPhraseAllSections, 3, 190, e_ScreenH - 174);

        // music
        bool all_keep = true;
        bool all_reset = true;
        bool all_set = true;
        int set_same = -1;

        for(int s = 0; s <= maxSections; s++)
        {
            if(Events[m_current_event].section[s].music_id != LESet_Nothing)
                all_keep = false;

            if(Events[m_current_event].section[s].music_id != LESet_ResetDefault)
                all_reset = false;

            if(Events[m_current_event].section[s].music_id < 0)
                all_set = false;
            else if(set_same == -1)
                set_same = Events[m_current_event].section[s].music_id;
            else if(set_same != Events[m_current_event].section[s].music_id)
                all_set = false;
        }

        if(UpdateButton(mode, 150 + 4, e_ScreenH - 120 + 4, GFX.EIcons, all_keep, 0, 0, 1, 1) && !all_keep)
        {
            for(int s = 0; s <= maxSections; s++)
                Events[m_current_event].section[s].music_id = LESet_Nothing;
        }

        if(UpdateButton(mode, 250 + 4, e_ScreenH - 120 + 4, GFX.EIcons, all_reset, 0, 32*Icon::x, 32, 32) && !all_reset)
        {
            for(int s = 0; s <= maxSections; s++)
                Events[m_current_event].section[s].music_id = LESet_ResetDefault;
        }

        if(UpdateButton(mode, 350 + 4, e_ScreenH - 120 + 4, GFX.EIcons, all_set, 0, 32*Icon::subscreen, 32, 32))
            m_special_page = SPECIAL_PAGE_EVENT_MUSIC;

        // background
        all_keep = true;
        all_reset = true;
        all_set = true;
        set_same = -1;

        for(int s = 0; s <= maxSections; s++)
        {
            if(Events[m_current_event].section[s].background_id != LESet_Nothing)
                all_keep = false;
            if(Events[m_current_event].section[s].background_id != LESet_ResetDefault)
                all_reset = false;
            if(Events[m_current_event].section[s].background_id < 0)
                all_set = false;
            else if(set_same == -1)
                set_same = Events[m_current_event].section[s].background_id;
            else if(set_same != Events[m_current_event].section[s].background_id)
                all_set = false;
        }

        if(UpdateButton(mode, 150 + 4, e_ScreenH - 80 + 4, GFX.EIcons, all_keep, 0, 0, 1, 1) && !all_keep)
        {
            for(int s = 0; s <= maxSections; s++)
                Events[m_current_event].section[s].background_id = LESet_Nothing;
        }

        if(UpdateButton(mode, 250 + 4, e_ScreenH - 80 + 4, GFX.EIcons, all_reset, 0, 32*Icon::x, 32, 32) && !all_reset)
        {
            for(int s = 0; s <= maxSections; s++)
                Events[m_current_event].section[s].background_id = LESet_ResetDefault;
        }

        if(UpdateButton(mode, 350 + 4, e_ScreenH - 80 + 4, GFX.EIcons, all_set, 0, 32*Icon::subscreen, 32, 32))
            m_special_page = SPECIAL_PAGE_EVENT_BACKGROUND;

        // bounds
        all_keep = true;
        all_reset = true;
        all_set = true;
        for(int s = 0; s <= maxSections; s++)
        {
            if(Events[m_current_event].section[s].position.X == LESet_Nothing)
            {
                all_reset = false;
                all_set = false;
            }
            else if(Events[m_current_event].section[s].position.X == LESet_ResetDefault)
            {
                all_set = false;
                all_keep = false;
            }
            else
            {
                all_keep = false;
                all_reset = false;
            }
        }

        if(UpdateButton(mode, 150 + 4, e_ScreenH - 40 + 4, GFX.EIcons, all_keep, 0, 0, 1, 1) && !all_keep)
        {
            for(int s = 0; s <= maxSections; s++)
                Events[m_current_event].section[s].position.X = -1;
        }

        if(UpdateButton(mode, 250 + 4, e_ScreenH - 40 + 4, GFX.EIcons, all_reset, 0, 32*Icon::x, 32, 32) && !all_reset)
        {
            for(int s = 0; s <= maxSections; s++)
                Events[m_current_event].section[s].position.X = -2;
        }
    }
    else
    {
        SuperPrintCenterR(mode, fmt::format_ne(g_editorStrings.phraseSectionIndex, m_special_subpage), 3, 190, e_ScreenH - 174);

        auto& es = Events[m_current_event].section[m_special_subpage-1];

        // music
        if(UpdateButton(mode, 150 + 4, e_ScreenH - 120 + 4, GFX.EIcons, es.music_id == LESet_Nothing, 0, 0, 1, 1))
            es.music_id = LESet_Nothing;

        if(UpdateButton(mode, 250 + 4, e_ScreenH - 120 + 4, GFX.EIcons, es.music_id == LESet_ResetDefault, 0, 32*Icon::x, 32, 32))
            es.music_id = LESet_ResetDefault;

        if(UpdateButton(mode, 350 + 4, e_ScreenH - 120 + 4, GFX.EIcons, es.music_id >= 0, 0, 32*Icon::subscreen, 32, 32))
            m_special_page = SPECIAL_PAGE_EVENT_MUSIC;

        // background
        if(UpdateButton(mode, 150 + 4, e_ScreenH - 80 + 4, GFX.EIcons, es.background_id == LESet_Nothing, 0, 0, 1, 1))
            es.background_id = LESet_Nothing;

        if(UpdateButton(mode, 250 + 4, e_ScreenH - 80 + 4, GFX.EIcons, es.background_id == LESet_ResetDefault, 0, 32*Icon::x, 32, 32))
            es.background_id = LESet_ResetDefault;

        if(UpdateButton(mode, 350 + 4, e_ScreenH - 80 + 4, GFX.EIcons, es.background_id >= 0, 0, 32*Icon::subscreen, 32, 32))
            m_special_page = SPECIAL_PAGE_EVENT_BACKGROUND;

        // bounds
        if(UpdateButton(mode, 150 + 4, e_ScreenH - 40 + 4, GFX.EIcons, es.position.X == LESet_Nothing, 0, 0, 1, 1))
            es.position.X = LESet_Nothing;

        if(UpdateButton(mode, 250 + 4, e_ScreenH - 40 + 4, GFX.EIcons, es.position.X == LESet_ResetDefault, 0, 32*Icon::x, 32, 32))
            es.position.X = LESet_ResetDefault;

        if(UpdateButton(mode, 350 + 4, e_ScreenH - 40 + 4, GFX.EIcons, es.position.X != LESet_Nothing && es.position.X != LESet_ResetDefault, 0, 32*Icon::subscreen, 32, 32))
            es.position = LevelREAL[m_special_subpage-1];
    }

    // autostart (top left)
    SuperPrintR(mode, g_editorStrings.eventsPropAutostart, 3, 54, 90);
    if(UpdateCheckBox(mode, 10 + 4, 80 + 4, Events[m_current_event].AutoStart))
        Events[m_current_event].AutoStart = !Events[m_current_event].AutoStart;

    // sound (top right)
    SuperPrintR(mode, g_editorStrings.eventsPropSound, 3, 254, 90);
    if(UpdateButton(mode, 210 + 4, 80 + 4, GFX.EIcons, Events[m_current_event].Sound != 0, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_EVENT_SOUND;

    // end game (mid left)
    SuperPrintR(mode, g_editorStrings.eventsPropEndGame, 3, 54, 130);
    if(UpdateCheckBox(mode, 10 + 4, 120 + 4, Events[m_current_event].EndGame == 1))
        Events[m_current_event].EndGame ^= 1;

    // control lock (mid right)
    bool controls_set = (Events[m_current_event].Controls.AltJump ||
        Events[m_current_event].Controls.AltRun ||
        Events[m_current_event].Controls.Down ||
        Events[m_current_event].Controls.Drop ||
        Events[m_current_event].Controls.Jump ||
        Events[m_current_event].Controls.Left ||
        Events[m_current_event].Controls.Right ||
        Events[m_current_event].Controls.Run ||
        Events[m_current_event].Controls.Start ||
        Events[m_current_event].Controls.Up);
    SuperPrintR(mode, g_editorStrings.eventsPropControls, 3, 254, 130);
    if(UpdateButton(mode, 210 + 4, 120 + 4, GFX.EIcons, controls_set, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_EVENT_CONTROLS;

    // message (bottom left)
    if(!GetS(Events[m_current_event].Text).empty())
    {
        MessageText = GetS(Events[m_current_event].Text);
        PrepareMessageDims();
    }

    SuperPrintR(mode, g_editorStrings.wordText, 3, 54, 170);
    if(UpdateButton(mode, 10 + 4, 160 + 4, GFX.EIcons, !GetS(Events[m_current_event].Text).empty(), 0, 32*Icon::pencil, 32, 32))
    {
        DisableCursorNew();
        SetS(Events[m_current_event].Text, TextEntryScreen::Run(g_editorStrings.eventsPromptEventText, GetS(Events[m_current_event].Text)));
        s_fix_mouse_pos();
    }

    // trigger event (full width, below all)
    SuperPrintR(mode, g_editorStrings.eventsHeaderTriggerEvent, 3, 54, 220);
    if(UpdateButton(mode, 10 + 4, 220 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_EVENT_TRIGGER;

    if(Events[m_current_event].TriggerEvent != EVENT_NONE)
    {
        SuperPrintR(mode, GetE(Events[m_current_event].TriggerEvent).substr(0,19), 3, 54, 240);

        if(Events[m_current_event].TriggerDelay > 0)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseDelayIsMs, 100 * Events[m_current_event].TriggerDelay), 3, 54, 272);
        else
            SuperPrintR(mode, g_editorStrings.wordInstant, 3, 54, 272);

        if(Events[m_current_event].TriggerDelay > 0 && UpdateButton(mode, 10 + 4, 260 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            Events[m_current_event].TriggerDelay --;

        if(UpdateButton(mode, 290 + 4, 260 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            Events[m_current_event].TriggerDelay ++;
    }
    else
        SuperPrintR(mode, g_mainMenu.caseNone, 3, 54, 240);
}

// updates the bounds for Section 0 in level start event according to its autoscroll
void UpdateStartLevelEventBounds()
{
    Events[0].AutoSection = 0;
    Events[0].section[0].position = LevelREAL[0];

    // not sure why 800 is also used for height in the default code, but I will stick with it.
    if(Events[0].AutoX < 0)
        Events[0].section[0].position.X = Events[0].section[0].position.Width - 800;
    else if(Events[0].AutoX > 0)
        Events[0].section[0].position.Width = Events[0].section[0].position.X + 800;

    if(Events[0].AutoY < 0)
        Events[0].section[0].position.Y = Events[0].section[0].position.Height - 800;
    else if(Events[0].AutoY > 0)
        Events[0].section[0].position.Height = Events[0].section[0].position.Y + 800;
}

void EditorScreen::UpdateSectionsScreen(CallMode mode)
{
    // level settings
    if(UpdateButton(mode, 10 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
    {
        DisableCursorNew();
        LevelName = TextEntryScreen::Run(g_editorStrings.levelName, LevelName);
        s_fix_mouse_pos();
    }

    SuperPrintR(mode, g_editorStrings.levelName, 3, 54, 42);
    if(!LevelName.empty())
        SuperPrintR(mode, LevelName, 3, 54, 60);
    else
        SuperPrintR(mode, g_mainMenu.caseNone, 3, 54, 60);

    SuperPrintR(mode, g_editorStrings.levelStartPos, 3, 10, 90);
    if(UpdateButton(mode, 240, 80 + 4, GFXBlock[622], (EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART && EditorCursor.SubMode == 4), 0, 0, 32, 32))
    {
        EditorCursor.Mode = OptCursor_t::LVL_PLAYERSTART;
        EditorCursor.SubMode = 4;
    }

    if(UpdateButton(mode, 280, 80 + 4, GFXBlock[623], (EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART && EditorCursor.SubMode == 5), 0, 0, 32, 32))
    {
        EditorCursor.Mode = OptCursor_t::LVL_PLAYERSTART;
        EditorCursor.SubMode = 5;
    }

    // section settings
    SuperPrintCenterR(mode, fmt::format_ne(g_editorStrings.phraseSectionIndex, curSection + 1), 3, 320, 166);
    if(curSection > 0 && UpdateButton(mode, 160 + 4, 160 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        SetSection(curSection - 1);

    if(curSection < maxSections && UpdateButton(mode, 440 + 4, 160 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        SetSection(curSection + 1);

    // background
    if(UpdateButton(mode, 10 + 4, 200 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_SECTION_BACKGROUND;

    if(mode == CallMode::Render)
    {
        const auto& indices = EditorCustom::bg2_list.indices;
        const auto& names = EditorCustom::bg2_list.names;

        size_t i;
        for(i = 0; i < indices.size(); i++)
        {
            if(indices[i] == Background2[curSection])
                break;
        }

        if(i == indices.size())
            SuperPrintR(mode, g_editorStrings.eventsCaseBackground + ": " + std::to_string(Background2[curSection]), 3, 54, 206);
        else
            SuperPrintR(mode, g_editorStrings.eventsCaseBackground + ": " + names[i], 3, 54, 206);
    }

    // music
    if(UpdateButton(mode, 10 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_SECTION_MUSIC;

    if(mode == CallMode::Render)
    {
        const auto& indices = EditorCustom::music_list.indices;
        const auto& names = EditorCustom::music_list.names;

        size_t i;
        for(i = 0; i < indices.size(); i++)
        {
            if(indices[i] == bgMusic[curSection])
                break;
        }

        if(i == indices.size())
            SuperPrint(g_editorStrings.eventsCaseMusic + ": " + std::to_string(bgMusic[curSection]), 3, 54, 246);
        else
            SuperPrint(g_editorStrings.eventsCaseMusic + ": " + names[i], 3, 54, 246);
    }

    if(bgMusic[curSection] == 24)
    {
        if(CustomMusic[curSection].length() < 15)
        {
            SuperPrintR(mode, CustomMusic[curSection], 3, 374, 252);
        }
        else
        {
            SuperPrintR(mode, CustomMusic[curSection].substr(0,14), 3, 374, 242);
            SuperPrintR(mode, CustomMusic[curSection].substr(14,14), 3, 374, 260);
        }

        if(UpdateButton(mode, 330 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::open, 32, 32))
            StartFileBrowser(&CustomMusic[curSection], FileNamePath, "", c_musicFormats, BROWSER_MODE_OPEN, BROWSER_CALLBACK_CUSTOM_MUSIC);
    }

    // will put section special effects below music

    // vwrap - LevelVWrap
    if(FileFormat == FileFormats::LVL_PGEX)
    {
        if(UpdateCheckBox(mode, e_ScreenW/2 + 10 + 4, 280 + 4, LevelVWrap[curSection]))
            LevelVWrap[curSection] = !LevelVWrap[curSection];
        SuperPrintR(mode, g_editorStrings.sectionVertWrap, 3, e_ScreenW/2 + 54, 286);
    }

    // underwater - UnderWater
    if(UpdateCheckBox(mode, 10 + 4, 320 + 4, UnderWater[curSection]))
        UnderWater[curSection] = !UnderWater[curSection];
    SuperPrintR(mode, g_editorStrings.sectionUnderwater, 3, 54, 326);

    // hwrap - LevelWrap
    if(UpdateCheckBox(mode, e_ScreenW/2 + 10 + 4, 320 + 4, LevelWrap[curSection]))
        LevelWrap[curSection] = !LevelWrap[curSection];
    SuperPrintR(mode, g_editorStrings.sectionHorizWrap, 3, e_ScreenW/2 + 54, 326);

    // no turn back - NoTurnBack
    if(UpdateCheckBox(mode, 10 + 4, 360 + 4, NoTurnBack[curSection]))
        NoTurnBack[curSection] = !NoTurnBack[curSection];
    SuperPrintR(mode, g_editorStrings.sectionNoTurnBack, 3, 54, 366);

    // leave to exit - OffScreenExit
    if(UpdateCheckBox(mode, e_ScreenW/2 + 10 + 4, 360 + 4, OffScreenExit[curSection]))
        OffScreenExit[curSection] = !OffScreenExit[curSection];
    SuperPrintR(mode, g_editorStrings.sectionOffscreenExit, 3, e_ScreenW/2 + 54, 366);

    // moved autoscroll into level settings, and only allow section 0 / event 0 (level start).
    // this is due to an awful bug which couldn't be fixed if people had taken
    // advantage of the ridiculously incorrect original behavior.
    if(curSection == 0)
    {
        SuperPrintR(mode, g_editorStrings.sectionScroll, 3, 10, 430);

        int sy = num_t::round((num_t)Events[0].AutoY * 10);
        if(sy < 0)
            SuperPrintR(mode, g_editorStrings.letterUp    + std::to_string(-sy), 3, 180, 422);
        else if(sy > 0)
            SuperPrintR(mode, g_editorStrings.letterDown  + std::to_string(sy), 3, 180, 422);
        else
            SuperPrintR(mode, "-", 3, 180, 422);

        int sx = num_t::round((num_t)Events[0].AutoX * 10);
        if(sx < 0)
            SuperPrintR(mode, g_editorStrings.letterLeft  + std::to_string(-sx), 3, 180, 440);
        else if(sx > 0)
            SuperPrintR(mode, g_editorStrings.letterRight + std::to_string(sx), 3, 180, 440);
        else
            SuperPrintR(mode, "-", 3, 180, 440);

        if(UpdateButton(mode, 240 + 4, 420 + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
        {
            Events[0].AutoY = s_divide_by_ten(sy - 1);
            UpdateStartLevelEventBounds();
        }

        if(UpdateButton(mode, 280 + 4, 420 + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
        {
            Events[0].AutoY = s_divide_by_ten(sy + 1);
            UpdateStartLevelEventBounds();
        }

        if(UpdateButton(mode, 320 + 4, 420 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        {
            Events[0].AutoX = s_divide_by_ten(sx - 1);
            UpdateStartLevelEventBounds();
        }

        if(UpdateButton(mode, 360 + 4, 420 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        {
            Events[0].AutoX = s_divide_by_ten(sx + 1);
            UpdateStartLevelEventBounds();
        }
    }
}

void EditorScreen::UpdateEditorSettingsScreen(CallMode mode)
{
    // settings screen, now.

#if 0
    // previous magic block settings

    SuperPrintR(mode, g_editorStrings.toggleMagicBlock, 3, 10, 50);


    if(EditorCustom::block_pages.empty() && EditorCustom::bgo_pages.empty() && EditorCustom::tile_pages.empty())
    {
        if(mode == CallMode::Render)
        {
            SuperPrint("Magic Block", 3, 10, 140);
            SuperPrint("needs editor.ini", 3, 10, 160);
            SuperPrint("to work.", 3, 10, 180);
        }
    }
    else
    {
        SuperPrintR(mode, "Normal", 3, 50, 94);
        if(UpdateButton(mode, 4, 80 + 4, GFX.ECursor[2], MagicBlock::enabled && MagicBlock::count_level_edges && !MagicBlock::advanced_mode && MagicBlock::check_level == MagicBlock::LEVEL_FAMILY && MagicBlock::change_level == MagicBlock::LEVEL_FAMILY))
        {
            MagicBlock::enabled = true;
            MagicBlock::count_level_edges = true;
            MagicBlock::advanced_mode = false;
            MagicBlock::check_level = MagicBlock::LEVEL_FAMILY;
            MagicBlock::change_level = MagicBlock::LEVEL_FAMILY;
        }

        SuperPrintR(mode, "Behind", 3, 50, 134);
        if(UpdateButton(mode, 4, 120 + 4, GFX.ECursor[2], MagicBlock::enabled && MagicBlock::count_level_edges && !MagicBlock::advanced_mode && MagicBlock::check_level == MagicBlock::LEVEL_ALL && MagicBlock::change_level == MagicBlock::LEVEL_FAMILY))
        {
            MagicBlock::enabled = true;
            MagicBlock::count_level_edges = true;
            MagicBlock::advanced_mode = false;
            MagicBlock::check_level = MagicBlock::LEVEL_ALL;
            MagicBlock::change_level = MagicBlock::LEVEL_FAMILY;
        }

        SuperPrintR(mode, "Advanced", 3, 50, 174);
        if(UpdateButton(mode, 4, 160 + 4, GFX.EIcons, MagicBlock::enabled && (!MagicBlock::count_level_edges || MagicBlock::advanced_mode || MagicBlock::check_level == MagicBlock::LEVEL_GROUP || MagicBlock::change_level != MagicBlock::LEVEL_FAMILY), 0, 32 * Icon::subscreen, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_MAGICBLOCK;
            return;
        }

        SuperPrintR(mode, "Off", 3, 50, 214);
        if(UpdateButton(mode, 4, 200 + 4, GFX.ECursor[2], !MagicBlock::enabled))
        {
            MagicBlock::enabled = false;
        }

        SuperPrintR(mode, "Overwrite", 3, 50, 294);
        if(UpdateCheckBox(mode, 4, 280 + 4, MagicBlock::replace_existing))
            MagicBlock::replace_existing = !MagicBlock::replace_existing;
    }
#endif

    if(WorldEditor || MagicHand)
        return;

    // level test settings

    if(m_special_subpage < 1)
        m_special_subpage = 1;

    if(m_special_subpage > maxLocalPlayers)
        m_special_subpage = maxLocalPlayers;

    if(this->num_test_players < 1)
        this->num_test_players = 1;

    if(BattleMode /*&& this->num_test_players < 2*/) // currently >2P battle is not supported
        this->num_test_players = 2;

    if(m_special_subpage > this->num_test_players + 1)
        m_special_subpage = this->num_test_players;

    SuperPrintRightR(mode, g_editorStrings.testMagicHand, 3, e_ScreenW - 60, 94);
    if(UpdateCheckBox(mode, e_ScreenW - 50 + 4, 80 + 4, this->test_magic_hand))
        this->test_magic_hand = !this->test_magic_hand;

    if(testStartWarp == 0)
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.warpTo, g_editorStrings.levelStartPos), 3, 46, 94);
    else
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.warpTo, fmt::format_ne(g_editorStrings.phraseWarpIndex, testStartWarp)), 3, 46, 94);

    if(testStartWarp > 0 && UpdateButton(mode, 4, 80 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        testStartWarp--;

    if(testStartWarp < numWarps && UpdateButton(mode, 280 + 4, 80 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        testStartWarp++;

    SuperPrintRightR(mode, Controls::EditorControls::g_button_name_UI[Controls::EditorControls::TestPlay], 3, e_ScreenW - 60, 54);
    if(UpdateButton(mode, e_ScreenW-50 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::play, 32, 32))
    {
        // turn this into a routine...?! (cross-reference editor.cpp handler for EditorControls.TestPlay)
        EditorBackup();
        Backup_FullFileName = FullFileName;
        // how does this interact with cross-level warps?
        FullFileName = FullFileName + "tst";
        SaveLevel(FullFileName, FileFormat);

        if(g_config.EnableInterLevelFade)
            g_levelScreenFader.setupFader(4, 0, 65, ScreenFader::S_FADE);
        else
            g_levelScreenFader.setupFader(65, 0, 65, ScreenFader::S_FADE);

        editorWaitForFade();

        // force reconnect on leveltest start
        Controls::ClearInputMethods();

        HasCursor = false;
        zTestLevel(this->test_magic_hand);
    }

    SuperPrintCenterR(mode, g_mainMenu.wordPlayer + " " + std::to_string(m_special_subpage), 3, 510, 154);
    if(m_special_subpage > 1 && UpdateButton(mode, 400 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        m_special_subpage --;

    if(m_special_subpage < maxLocalPlayers && m_special_subpage <= this->num_test_players && UpdateButton(mode, 580 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        m_special_subpage ++;

    if(m_special_subpage >= this->num_test_players && m_special_subpage != 1 && !(BattleMode && m_special_subpage == 2))
    {
        SuperPrintR(mode, g_editorStrings.wordEnabled, 3, e_ScreenW / 2 + 54, 194);

        if(UpdateCheckBox(mode, e_ScreenW / 2 + 10 + 4, 180 + 4, m_special_subpage == this->num_test_players))
        {
            if(m_special_subpage == this->num_test_players)
                this->num_test_players -= 1;
            else
                this->num_test_players += 1;
        }
    }

    if(m_special_subpage > this->num_test_players)
        return;

    SuperPrintR(mode, g_editorStrings.testChar, 3, e_ScreenW / 2 - 30, 234);

    constexpr int block_for_char[] = {622, 623, 624, 625, 631};
    for(int ch = 1; ch <= 5; ch++)
    {
        bool pPctive = testPlayer[m_special_subpage].Character == ch;
        int block = block_for_char[ch - 1];

        if(UpdateButton(mode, e_ScreenW / 2 + 40 + 4 + 40*ch, 220 + 4, GFXBlock[block], pPctive, 0, 0, 32, 32))
            testPlayer[m_special_subpage].Character = ch;
    }

    SuperPrintR(mode, g_editorStrings.testPower, 3, e_ScreenW / 2 - 30, 274);

    if(testPlayer[m_special_subpage].State == 0)
        testPlayer[m_special_subpage].State = 2;

    constexpr int NPC_for_state[] = {0, NPCID_POWER_S3, NPCID_FIRE_POWER_S3, NPCID_LEAF_POWER, NPCID_STATUE_POWER, NPCID_HEAVY_POWER, NPCID_ICE_POWER_S3, NPCID_AQUATIC_POWER, NPCID_POLAR_POWER, NPCID_CYCLONE_POWER, NPCID_SHELL_POWER};
    int max_state = (g_gameInfo.contentFeatureLevel >= 1030790) ? 11 : 7;
    for(int state = 1; state <= max_state; state++)
    {
        bool pActive = testPlayer[m_special_subpage].State == state;
        int sNPC = NPC_for_state[state - 1];

        bool selected;
        if(!sNPC)
            selected = UpdateButton(mode, e_ScreenW / 2 + 80 + 4 + 40 * ((state - 1) % 6), 260 + 4 + ((state - 1) / 6) * 40, GFX.EIcons, pActive, 0, 0, 1, 1);
        else
            selected = UpdateButton(mode, e_ScreenW / 2 + 80 + 4 + 40 * ((state - 1) % 6), 260 + 4 + ((state - 1) / 6) * 40, GFXNPC[sNPC], pActive, 0, 0, 32, 32);

        if(selected)
            testPlayer[m_special_subpage].State = state;
    }

    SuperPrintR(mode, g_editorStrings.testBoot, 3, e_ScreenW / 2 - 30, 354);

    constexpr int NPC_for_boot[] = {NPCID_GRN_BOOT, NPCID_RED_BOOT, NPCID_BLU_BOOT};
    for(int boot = 1; boot <= 3; boot++)
    {
        bool pActive = testPlayer[m_special_subpage].Mount == 1 && testPlayer[m_special_subpage].MountType == boot;
        int pNPC = NPC_for_boot[boot - 1];

        if(UpdateButton(mode, e_ScreenW / 2 + 40 + 4 + 40*boot, 340 + 4, GFXNPC[pNPC], pActive, 0, 0, 32, 32))
        {
            if(pActive)
            {
                testPlayer[m_special_subpage].Mount = 0;
            }
            else
            {
                testPlayer[m_special_subpage].Mount = 1;
                testPlayer[m_special_subpage].MountType = boot;
            }
        }
    }

    SuperPrintR(mode, g_editorStrings.testPet, 3, e_ScreenW / 2 - 30, 394);

    constexpr int NPC_for_yoshi[] = {NPCID_PET_GREEN, NPCID_PET_BLUE, NPCID_PET_YELLOW, NPCID_PET_RED, NPCID_PET_BLACK, NPCID_PET_PURPLE, NPCID_PET_PINK, NPCID_PET_CYAN};
    for(int yoshi = 1; yoshi <= 8; yoshi++)
    {
        bool pActive = testPlayer[m_special_subpage].Mount == 3 && testPlayer[m_special_subpage].MountType == yoshi;
        int pNPC = NPC_for_yoshi[yoshi - 1];

        if(UpdateButton(mode, e_ScreenW / 2 + 80 + 4 + 40 * ((yoshi - 1) % 6), 380 + 4 + ((yoshi - 1) / 6) * 40, GFXNPC[pNPC], pActive, 0, 0, 72, 56))
        {
            if(pActive)
            {
                testPlayer[m_special_subpage].Mount = 0;
            }
            else
            {
                testPlayer[m_special_subpage].Mount = 3;
                testPlayer[m_special_subpage].MountType = yoshi;
            }
        }
    }
}

void EditorScreen::UpdateWorldSettingsScreen(CallMode mode)
{
    // world name
    if(UpdateButton(mode, 10 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
    {
        DisableCursorNew();
        WorldName = TextEntryScreen::Run(g_editorStrings.worldName, WorldName);
        s_fix_mouse_pos();
    }

    SuperPrintR(mode, g_editorStrings.worldName, 3, 54, 42);
    if(!WorldName.empty())
        SuperPrintR(mode, WorldName, 3, 54, 60);
    else
        SuperPrintR(mode, g_mainMenu.caseNone, 3, 54, 60);

    // auto start level
    if(UpdateButton(mode, 10 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::open, 32, 32))
        StartFileBrowser(&StartLevel, FileNamePath, "", {".lvl", ".lvlx"}, BROWSER_MODE_OPEN);

    SuperPrintR(mode, g_editorStrings.worldIntroLevel, 3, 54, 102);

    if(!StartLevel.empty())
        SuperPrintR(mode, StartLevel, 3, 54, 120);
    else
        SuperPrintR(mode, g_mainMenu.caseNone, 3, 54, 120);

    // no world map - NoMap
    if(UpdateCheckBox(mode, 10 + 4, 160 + 4, NoMap))
        NoMap = !NoMap;

    SuperPrintR(mode, g_editorStrings.worldHubWorld, 3, 54, 170);

    // restart after death - RestartLevel
    if(UpdateCheckBox(mode, e_ScreenW/2 + 10 + 4, 160 + 4, RestartLevel))
        RestartLevel = !RestartLevel;

    SuperPrintR(mode, g_editorStrings.worldRetryOnFail, 3, e_ScreenW/2 + 54, 170);

    // world star count
    if(MaxWorldStars > 0 && UpdateButton(mode, 120 + 4, 220 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        MaxWorldStars --;

    SuperPrintCenterR(mode, g_editorStrings.worldTotalStars + std::to_string(MaxWorldStars), 3, 300, 230);

    if(UpdateButton(mode, 440 + 4, 220 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        MaxWorldStars ++;

    // allow chars
    SuperPrintR(mode, g_editorStrings.worldAllowChars, 3, 10, 290);

    if(UpdateButton(mode, 240 + 4, 280 + 4, GFXBlock[622], !blockCharacter[1], 0, 0, 32, 32))
        blockCharacter[1] = !blockCharacter[1];

    if(UpdateButton(mode, 280 + 4, 280 + 4, GFXBlock[623], !blockCharacter[2], 0, 0, 32, 32))
        blockCharacter[2] = !blockCharacter[2];

    if(UpdateButton(mode, 320 + 4, 280 + 4, GFXBlock[624], !blockCharacter[3], 0, 0, 32, 32))
        blockCharacter[3] = !blockCharacter[3];

    if(UpdateButton(mode, 360 + 4, 280 + 4, GFXBlock[625], !blockCharacter[4], 0, 0, 32, 32))
        blockCharacter[4] = !blockCharacter[4];

    if(UpdateButton(mode, 400 + 4, 280 + 4, GFXBlock[631], !blockCharacter[5], 0, 0, 32, 32))
        blockCharacter[5] = !blockCharacter[5];

    // don't allow all characters to be blocked.
    if(blockCharacter[1] && blockCharacter[2] && blockCharacter[3] && blockCharacter[4] && blockCharacter[5])
        blockCharacter[1] = false;


    // World credits...
    if(m_special_subpage > 0 && UpdateButton(mode, 10 + 4, 340 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        m_special_subpage --;

    if(UpdateButton(mode, 50 + 4, 340 + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
    {
        DisableCursorNew();
        WorldCredits[m_special_subpage + 1] = TextEntryScreen::Run(fmt::format_ne(g_editorStrings.worldCreditIndex, m_special_subpage + 1), WorldCredits[m_special_subpage + 1]);
        s_fix_mouse_pos();
        for(int i = SDL_max(numWorldCredits, m_special_subpage + 1); i > 0; --i) // Find the last non-empty line
        {
            if(!WorldCredits[m_special_subpage + 1].empty())
            {
                numWorldCredits = i;
                break;
            }
        }
    }

    if(m_special_subpage < 4 && UpdateButton(mode, 90 + 4, 340 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        m_special_subpage ++;

    SuperPrintR(mode, fmt::format_ne(g_editorStrings.worldCreditIndex, m_special_subpage + 1), 3, 144, 342);
    SuperPrintR(mode, WorldCredits[m_special_subpage + 1], 3, 144, 360);
}

void EditorScreen::UpdateSelectListScreen(CallMode mode)
{
    if(m_special_page != SPECIAL_PAGE_NONE && UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
    {
        if(m_special_page == SPECIAL_PAGE_EVENT_SOUND || m_special_page == SPECIAL_PAGE_EVENT_MUSIC || m_special_page == SPECIAL_PAGE_EVENT_BACKGROUND)
            m_special_page = SPECIAL_PAGE_EVENT_SETTINGS;
        else if(m_special_page == SPECIAL_PAGE_SECTION_MUSIC || m_special_page == SPECIAL_PAGE_SECTION_BACKGROUND)
            m_special_page = SPECIAL_PAGE_SECTION_SETTINGS;
        else
            m_special_page = SPECIAL_PAGE_NONE;
    }

    vbint_t* target;
    int* current_page;
    PGE_Size titleSize;
    const int titlePosX = 10;
    const int titlePosY = 40;
    const std::vector<std::string>* source;
    const std::vector<int16_t>* source_indices;

    if(m_special_page == SPECIAL_PAGE_EVENT_SOUND)
    {
        titleSize = FontManager_printTextOptiPxR(mode,
                                                 fmt::format_ne(g_editorStrings.selectSoundForEvent,
                                                                Events[m_current_event].Name),
                                                 titlePosX, titlePosY,
                                                 300,
                                                 FontManager::fontIdFromSmbxFont(3));
        target = &Events[m_current_event].Sound;
        current_page = &m_sounds_page;

        source = &EditorCustom::sound_list.names;
        source_indices = &EditorCustom::sound_list.indices;
    }
    else if(m_special_page == SPECIAL_PAGE_EVENT_BACKGROUND)
    {
        if(m_special_subpage > 0)
        {
            titleSize = FontManager_printTextOptiPxR(mode,
                                                     fmt::format_ne(g_editorStrings.selectSectBlankPropBlankForEvent,
                                                                    m_special_subpage,
                                                                    g_editorStrings.eventsCaseBackground,
                                                                    Events[m_current_event].Name),
                                                     titlePosX, titlePosY,
                                                     300,
                                                     FontManager::fontIdFromSmbxFont(3));
            target = &Events[m_current_event].section[m_special_subpage-1].background_id;
        }
        else
        {
            titleSize = FontManager_printTextOptiPxR(mode,
                                                     fmt::format_ne(g_editorStrings.selectAllSectPropBlankForEvent,
                                                                    g_editorStrings.eventsCaseBackground,
                                                                    Events[m_current_event].Name),
                                                     titlePosX, titlePosY,
                                                     300,
                                                     FontManager::fontIdFromSmbxFont(3));
            target = nullptr;
        }

        current_page = &m_background_page;

        source = &EditorCustom::bg2_list.names;
        source_indices = &EditorCustom::bg2_list.indices;
    }
    else if(m_special_page == SPECIAL_PAGE_EVENT_MUSIC)
    {
        if(m_special_subpage > 0)
        {
            titleSize = FontManager_printTextOptiPxR(mode,
                                                     fmt::format_ne(g_editorStrings.selectSectBlankPropBlankForEvent,
                                                                    m_special_subpage,
                                                                    g_editorStrings.eventsCaseMusic,
                                                                    Events[m_current_event].Name),
                                                     titlePosX, titlePosY,
                                                     300,
                                                     FontManager::fontIdFromSmbxFont(3));
            target = &Events[m_current_event].section[m_special_subpage-1].music_id;
        }
        else
        {
            titleSize = FontManager_printTextOptiPxR(mode,
                                                     fmt::format_ne(g_editorStrings.selectAllSectPropBlankForEvent,
                                                                    g_editorStrings.eventsCaseMusic,
                                                                    Events[m_current_event].Name),
                                                     titlePosX, titlePosY,
                                                     300,
                                                     FontManager::fontIdFromSmbxFont(3));
            target = nullptr;
        }

        current_page = &m_music_page;

        source = &EditorCustom::music_list.names;
        source_indices = &EditorCustom::music_list.indices;
    }
    else if(m_special_page == SPECIAL_PAGE_SECTION_BACKGROUND)
    {
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.selectSectionBlankPropBlank, curSection + 1, g_editorStrings.eventsCaseBackground), 3, 10, 50);
        target = &Background2[curSection];
        current_page = &m_background_page;

        source = &EditorCustom::bg2_list.names;
        source_indices = &EditorCustom::bg2_list.indices;
    }
    else if(m_special_page == SPECIAL_PAGE_SECTION_MUSIC)
    {
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.selectSectionBlankPropBlank, curSection + 1, g_editorStrings.eventsCaseMusic), 3, 10, 50);
        target = &bgMusic[curSection];
        current_page = &m_music_page;

        source = &EditorCustom::music_list.names;
        source_indices = &EditorCustom::music_list.indices;
    }
    else if(m_special_page == SPECIAL_PAGE_LEVEL_EXIT)
    {
        using Controls::PlayerControls::Buttons;

        if(m_special_subpage == 1)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.selectPathBlankUnlock, GetButtonName_UI(Buttons::Up)), 3, 10, 50);
        else if(m_special_subpage == 2)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.selectPathBlankUnlock, GetButtonName_UI(Buttons::Left)), 3, 10, 50);
        else if(m_special_subpage == 3)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.selectPathBlankUnlock, GetButtonName_UI(Buttons::Down)), 3, 10, 50);
        else if(m_special_subpage == 4)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.selectPathBlankUnlock, GetButtonName_UI(Buttons::Right)), 3, 10, 50);
        else
            return;

        target = &EditorCursor.WorldLevel.LevelExit[m_special_subpage];
        current_page = nullptr;
        source = &EditorCustom::list_level_exit_names;
        source_indices = nullptr;
    }
    else if(m_special_page == SPECIAL_PAGE_WARP_TRANSITION)
    {
        SuperPrintR(mode, g_editorStrings.selectWarpTransitionEffect, 3, 10, 50);

        target = &EditorCursor.Warp.transitEffect;
        current_page = nullptr;
        source = &g_editorStrings.listWarpTransitNames;
        source_indices = nullptr;
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_MUSIC)
    {
        SuperPrintR(mode, g_editorStrings.selectWorldMusic, 3, 10, 50);
        target = &EditorCursor.WorldMusic.Type;
        current_page = &m_music_page;

        source = &EditorCustom::wmusic_list.names;
        source_indices = &EditorCustom::wmusic_list.indices;
    }
    else
    {
        return;
    }


    int elementsOnPage = 20;
    int elementsOnColumn = elementsOnPage / 2;
    int elementsListBaseY = 80;
    const int elementsRowHeight = 40;

    // Reduce the size of the elements list if title has more lines than expected
    while(titlePosY + titleSize.h() >= elementsListBaseY)
    {
        elementsOnPage -= 2;
        elementsOnColumn -= 1;
        elementsListBaseY += elementsRowHeight;
    }

    SDL_assert(elementsOnPage > 0);
    SDL_assert(elementsOnColumn > 0);

    if(current_page != nullptr)
    {
        int page_max = !source->empty() ? ((static_cast<int>(source->size()) - 1) / elementsOnPage) : 0;

        if(!(page_max == 0 && *current_page == 0))
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.pageBlankOfBlank, *current_page + 1, page_max + 1), 3, e_ScreenW - 320, 50);

        if(*current_page > 0 && UpdateButton(mode, e_ScreenW - 120 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            *current_page = *current_page - 1;

        if(*current_page < page_max && UpdateButton(mode, e_ScreenW - 80 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            *current_page = *current_page + 1;

        if(*current_page < 0)
            *current_page = 0;

        if(*current_page > page_max)
            *current_page = page_max;
    }

    for(int i = 0; i < elementsOnPage; i++)
    {
        int x = 10 + (e_ScreenW / 2) * (i / elementsOnColumn);
        int y = elementsListBaseY + elementsRowHeight * (i % elementsOnColumn);

        int j;

        if(current_page != nullptr)
            j = (*current_page * elementsOnPage) + i;
        else
            j = i;

        if(j >= (int)source->size())
            break;

        int index;
        if(source_indices != nullptr)
        {
            if(source_indices->empty())
                return; // Note: this is an invalid: array must not being empty!
            index = (*source_indices)[j];
        }
        else if(m_special_page == SPECIAL_PAGE_LEVEL_EXIT)
            index = j - 1;
        else
            index = j;

        if(index == -1 && m_special_page != SPECIAL_PAGE_LEVEL_EXIT)
            x += 40;

        SuperPrintR(mode, (*source)[j], 3, x + 44, y + 10);
        if(index != -1 || m_special_page == SPECIAL_PAGE_LEVEL_EXIT)
        {
            bool sel;
            if(target != nullptr)
                sel = *target == index;
            else if(m_special_page == SPECIAL_PAGE_EVENT_BACKGROUND)
            {
                sel = true;
                for(int s = 0; s <= maxSections; s++)
                {
                    if(Events[m_current_event].section[s].background_id != index)
                        sel = false;
                }
            }
            else if(m_special_page == SPECIAL_PAGE_EVENT_MUSIC)
            {
                sel = true;
                for(int s = 0; s <= maxSections; s++)
                {
                    if(Events[m_current_event].section[s].music_id != index)
                        sel = false;
                }
            }
            else // should never happen
            {
                return;
            }

            if(UpdateButton(mode, x + 4, y + 4, GFX.ECursor[2], sel, 0, 0, 32, 32))
            {
                if(!sel)
                {
                    if(target != nullptr)
                        *target = index;
                    else if(m_special_page == SPECIAL_PAGE_EVENT_BACKGROUND)
                    {
                        for(int s = 0; s <= maxSections; s++)
                            Events[m_current_event].section[s].background_id = index;
                    }
                    else if(m_special_page == SPECIAL_PAGE_EVENT_MUSIC)
                    {
                        for(int s = 0; s <= maxSections; s++)
                            Events[m_current_event].section[s].music_id = index;
                    }

                    // and do whatever necessary to preview it.
                    if(m_special_page == SPECIAL_PAGE_EVENT_SOUND && index != 0)
                        PlaySound(index);
                    else if(m_special_page == SPECIAL_PAGE_SECTION_MUSIC)
                        StartMusic(curSection);
                }
                else
                {
                    if(m_special_page == SPECIAL_PAGE_EVENT_SOUND || m_special_page == SPECIAL_PAGE_EVENT_MUSIC || m_special_page == SPECIAL_PAGE_EVENT_BACKGROUND)
                        m_special_page = SPECIAL_PAGE_EVENT_SETTINGS;
                    else if(m_special_page == SPECIAL_PAGE_SECTION_MUSIC || m_special_page == SPECIAL_PAGE_SECTION_BACKGROUND)
                        m_special_page = SPECIAL_PAGE_SECTION_SETTINGS;
                    else
                        m_special_page = SPECIAL_PAGE_NONE;
                }
            }
        }
    }
}

void EditorScreen::UpdateEventsSubScreen(CallMode mode)
{
    // render shared GUI elements on right
    if(mode == CallMode::Render)
        XRender::renderRect(e_ScreenW - 240, 40, 240, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);

    // back button
    if(UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
    {
        if(m_special_page == SPECIAL_PAGE_EVENT_TRIGGER)
            m_special_page = SPECIAL_PAGE_EVENT_SETTINGS;
        else
            m_special_page = SPECIAL_PAGE_NONE;

        m_special_subpage = 0;
        return;
    }

    if(EditorCursor.Mode == OptCursor_t::LVL_NPCS)
    {
        // activate event
        SuperPrintR(mode, g_editorStrings.eventsLabelActivate, 3, e_ScreenW - 200, 200 + 2);

        if(EditorCursor.NPC.TriggerActivate != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.NPC.TriggerActivate), 3, e_ScreenW - 200, 220 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 220 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 200 + 4, GFX.EIcons, m_special_subpage == 1, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 1;

        // death event
        SuperPrintR(mode, g_editorStrings.eventsLabelDeath, 3, e_ScreenW - 200, 240 + 2);

        if(EditorCursor.NPC.TriggerDeath != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.NPC.TriggerDeath), 3, e_ScreenW - 200, 260 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 260 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 240 + 4, GFX.EIcons, m_special_subpage == 2, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 2;

        // talk event
        SuperPrintR(mode, g_editorStrings.eventsLabelTalk, 3, e_ScreenW - 200, 280 + 2);

        if(EditorCursor.NPC.TriggerTalk != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.NPC.TriggerTalk), 3, e_ScreenW - 200, 300 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 300 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 280 + 4, GFX.EIcons, m_special_subpage == 3, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 3;

        // layer clear event
        SuperPrintR(mode, g_editorStrings.eventsLabelLayerClear, 3, e_ScreenW - 200, 320 + 2);

        if(EditorCursor.NPC.TriggerLast != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.NPC.TriggerLast), 3, e_ScreenW - 200, 340 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 340 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 320 + 4, GFX.EIcons, m_special_subpage == 4, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 4;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_BLOCKS)
    {
        // block hit event
        SuperPrintR(mode, g_editorStrings.eventsLabelHit, 3, e_ScreenW - 200, 200 + 2);

        if(EditorCursor.Block.TriggerHit != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.Block.TriggerHit), 3, e_ScreenW - 200, 220 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 220 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 200 + 4, GFX.EIcons, m_special_subpage == 1, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 1;

        // block destroy event
        SuperPrintR(mode, g_editorStrings.eventsLabelDestroy, 3, e_ScreenW - 200, 240 + 2);

        if(EditorCursor.Block.TriggerDeath != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.Block.TriggerDeath), 3, e_ScreenW - 200, 260 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 260 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 240 + 4, GFX.EIcons, m_special_subpage == 2, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 2;

        // layer clear event
        SuperPrintR(mode, g_editorStrings.eventsLabelLayerClear, 3, e_ScreenW - 200, 280 + 2);

        if(EditorCursor.Block.TriggerLast != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.Block.TriggerLast), 3, e_ScreenW - 200, 300 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 300 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 280 + 4, GFX.EIcons, m_special_subpage == 3, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 3;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_WARPS)
    {
        m_special_subpage = 1;

        SuperPrintR(mode, g_editorStrings.eventsLabelEnter, 3, e_ScreenW - 200, 200 + 2);
        if(EditorCursor.Warp.eventEnter != EVENT_NONE)
            SuperPrintR(mode, GetE(EditorCursor.Warp.eventEnter), 3, e_ScreenW - 200, 220 + 2);
        else
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 220 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 200 + 4, GFX.EIcons, m_special_subpage == 1, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 1;
    }
    else if(m_special_page == SPECIAL_PAGE_EVENT_TRIGGER)
    {
        // delay selector, instead of page selector
        if(Events[m_current_event].TriggerDelay > 0)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseDelayIsMs, 100 * Events[m_current_event].TriggerDelay), 3, e_ScreenW - 240 + 4, 272);
        else
            SuperPrintR(mode, g_editorStrings.wordInstant, 3, e_ScreenW - 240 + 4, 272);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 230 + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
            Events[m_current_event].TriggerDelay ++;

        if(Events[m_current_event].TriggerDelay > 0 && UpdateButton(mode, e_ScreenW - 240 + 4, 290 + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
            Events[m_current_event].TriggerDelay --;
    }
    else
        return;

    int page_max = numEvents / 10;
    SuperPrintR(mode, fmt::format_ne(g_editorStrings.pageBlankOfBlank, m_events_page + 1, page_max + 1), 3, e_ScreenW - 228, e_ScreenH - 60);

    if(m_events_page > 0 && UpdateButton(mode, e_ScreenW - 160 + 4, e_ScreenH - 40 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        m_events_page --;

    if(m_events_page < page_max && UpdateButton(mode, e_ScreenW - 120 + 4, e_ScreenH - 40 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        m_events_page ++;

    // prepare selector
    std::string event_name;
    std::string event_desc;
    eventindex_t* event_to_set;

    if(m_special_page == SPECIAL_PAGE_EVENT_TRIGGER)
    {
        event_name = g_editorStrings.eventsLabelNext;
        event_to_set = &Events[m_current_event].TriggerEvent;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_NPCS)
    {
        if(m_special_subpage == 1)
        {
            event_name = g_editorStrings.eventsLabelActivate;
            event_desc = g_editorStrings.eventsDescActivate;
            event_to_set = &EditorCursor.NPC.TriggerActivate;
        }
        else if(m_special_subpage == 2)
        {
            event_name = g_editorStrings.eventsLabelDeath;
            event_desc = g_editorStrings.eventsDescDeath;
            event_to_set = &EditorCursor.NPC.TriggerDeath;
        }
        else if(m_special_subpage == 3)
        {
            event_name = g_editorStrings.eventsLabelTalk;
            event_desc = g_editorStrings.eventsDescTalk;
            event_to_set = &EditorCursor.NPC.TriggerTalk;
        }
        else if(m_special_subpage == 4)
        {
            event_name = g_editorStrings.eventsLabelLayerClear;
            event_desc = g_editorStrings.eventsDescLayerClear;
            event_to_set = &EditorCursor.NPC.TriggerLast;
        }
        else
            return;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_BLOCKS)
    {
        if(m_special_subpage == 1)
        {
            event_name = g_editorStrings.eventsLabelHit;
            event_desc = g_editorStrings.eventsDescHit;
            event_to_set = &EditorCursor.Block.TriggerHit;
        }
        else if(m_special_subpage == 2)
        {
            event_name = g_editorStrings.eventsLabelDestroy;
            event_desc = g_editorStrings.eventsDescDestroy;
            event_to_set = &EditorCursor.Block.TriggerDeath;
        }
        else if(m_special_subpage == 3)
        {
            event_name = g_editorStrings.eventsLabelLayerClear;
            event_desc = g_editorStrings.eventsDescLayerClear;
            event_to_set = &EditorCursor.Block.TriggerLast;
        }
        else
            return;
    }
    else if(EditorCursor.Mode == OptCursor_t::LVL_WARPS)
    {
        if(m_special_subpage == 1)
        {
            event_name = g_editorStrings.eventsLabelEnter;
            event_desc = g_editorStrings.eventsDescEnter;
            event_to_set = &EditorCursor.Warp.eventEnter;
        }
        else
            return;
    }
    else // this should not happen
    {
        return;
    }

    // render description
    if(mode == CallMode::Render)
    {
        // trigger after current event is a special case
        std::string descFormatted = (m_special_page == SPECIAL_PAGE_EVENT_TRIGGER)
            ? fmt::format(g_editorStrings.eventsDescPhraseTriggersAfterTemplate, event_name, Events[m_current_event].TriggerDelay * 100, Events[m_current_event].Name)
            : fmt::format(g_editorStrings.eventsDescPhraseTriggersWhenTemplate, event_name, event_desc);

        FontManager::printTextOptiPx(descFormatted,
                                     e_ScreenW - 236, 80,
                                     230,
                                     FontManager::fontIdFromSmbxFont(3));
    }

    // render current event
    SuperPrintR(mode, fmt::format_ne(g_editorStrings.phraseTypeLabelEvent, event_name), 3, 10, 40);
    if(*event_to_set == EVENT_NONE)
        SuperPrintR(mode, g_mainMenu.caseNone, 3, 10, 56);
    else
        SuperPrintR(mode, Events[*event_to_set].Name, 3, 10, 56);

    // render event selector
    for(int i = 0; i < 10; i++)
    {
        eventindex_t e = m_events_page*10 + i - 1;
        if(e == EVENT_NONE)
        {
            SuperPrintR(mode, g_mainMenu.caseNone, 3, 54, 80 + 40*i + 12);
            if(UpdateButton(mode, 10 + 4, 80 + 40*i + 4, GFX.ECursor[2], *event_to_set == EVENT_NONE, 0, 0, 32, 32))
                *event_to_set = EVENT_NONE;
        }
        else if(!Events[e].Name.empty())
        {
            if(Events[e].Name.length() < 20)
                SuperPrintR(mode, Events[e].Name, 3, 54, 80 + 40*i + 10);
            else
            {
                SuperPrintR(mode, Events[e].Name.substr(0,19), 3, 54, 80 + 40*i + 2);
                SuperPrintR(mode, Events[e].Name.substr(19), 3, 54, 80 + 40*i + 20);
            }

            if(UpdateButton(mode, 10 + 4, 80 + 40*i + 4, GFX.ECursor[2], *event_to_set == e, 0, 0, 32, 32))
                *event_to_set = e;
        }
    }
}

void EditorScreen::UpdateLayersScreen(CallMode mode)
{
    if(m_special_page == SPECIAL_PAGE_LAYER_DELETION)
    {
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.layersDeletionHeader, Layer[m_special_subpage].Name), 3, 60, 40);
        SuperPrintR(mode, g_editorStrings.layersDeletionPreserveLayerContents, 3, 10, 60);

        SuperPrintR(mode, g_editorStrings.layersDeletionConfirmPreserve, 3, 60, 110);

        if(UpdateButton(mode, 20 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            DeleteLayer((layerindex_t)m_special_subpage, false);
            m_special_subpage = 0;
            m_special_page = SPECIAL_PAGE_LAYERS;
            return;
        }


        SuperPrintR(mode, g_editorStrings.layersDeletionConfirmDelete, 3, 60, 150);

        if(UpdateButton(mode, 20 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            DeleteLayer((layerindex_t)m_special_subpage, true);
            m_special_subpage = 0;
            m_special_page = SPECIAL_PAGE_LAYERS;
            return;
        }


        SuperPrintR(mode, g_editorStrings.layersDeletionCancel, 3, 60, 190);

        if(UpdateButton(mode, 20 + 4, 180 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            m_special_subpage = 0;
            m_special_page = SPECIAL_PAGE_LAYERS;
        }

        return;
    }

    // fix just in case wrong subpage is set for obj layer selection
    if(m_special_page == SPECIAL_PAGE_OBJ_LAYER && EditorCursor.Mode != OptCursor_t::LVL_NPCS && m_special_subpage != 0)
        m_special_subpage = 0;

    // render shared GUI elements on right
    if(mode == CallMode::Render && m_special_page != SPECIAL_PAGE_LAYERS && m_special_page != SPECIAL_PAGE_EVENT_LAYERS)
        XRender::renderRect(e_ScreenW - 240, 40, 240, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);

    if(m_special_page != SPECIAL_PAGE_LAYERS && UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
    {
        if(m_special_page == SPECIAL_PAGE_EVENT_LAYERS)
            m_special_page = SPECIAL_PAGE_EVENT_SETTINGS;
        else
            m_special_page = SPECIAL_PAGE_NONE;
        m_special_subpage = 0;
    }

    if(m_special_page == SPECIAL_PAGE_OBJ_LAYER && EditorCursor.Mode == OptCursor_t::LVL_NPCS)
    {
        SuperPrintR(mode, g_editorStrings.labelLayer, 3, e_ScreenW - 200, 200 + 2);
        if(EditorCursor.Layer == LAYER_NONE)
            SuperPrintR(mode, g_editorStrings.layersLayerDefault, 3, e_ScreenW - 200, 220 + 2);
        else
            SuperPrintR(mode, GetL(EditorCursor.Layer), 3, e_ScreenW - 200, 220 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 200 + 4, GFX.EIcons, m_special_subpage == 0, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 0;

        SuperPrintR(mode, g_editorStrings.layersLabelAttached, 3, e_ScreenW - 200, 260 + 2);
        if(EditorCursor.NPC.AttLayer == LAYER_NONE || EditorCursor.NPC.AttLayer == LAYER_DEFAULT)
            SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 200, 280 + 2);
        else
            SuperPrintR(mode, GetL(EditorCursor.NPC.AttLayer), 3, e_ScreenW - 200, 280 + 2);

        if(UpdateButton(mode, e_ScreenW - 240 + 4, 260 + 4, GFX.EIcons, m_special_subpage == 1, 0, 32*Icon::action, 32, 32))
            m_special_subpage = 1;
    }

    int page_max;
    // extra slot for layer creation when not in the object layer selection
    if(m_special_page == SPECIAL_PAGE_OBJ_LAYER)
        page_max = (numLayers - 1) / 10;
    else
        page_max = numLayers / 10;

    // different location for layers and event layers page because they has so many options
    if(m_special_page == SPECIAL_PAGE_LAYERS || m_special_page == SPECIAL_PAGE_EVENT_LAYERS)
    {
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.pageBlankOfBlank, m_layers_page + 1, page_max + 1), 3, e_ScreenW - 330, 40);
        if(m_layers_page > 0 && UpdateButton(mode, e_ScreenW - 120 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            m_layers_page --;

        if(m_layers_page < page_max && UpdateButton(mode, e_ScreenW - 80 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            m_layers_page ++;
    }
    else
    {
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.pageBlankOfBlank, m_layers_page + 1, page_max + 1), 3, e_ScreenW - 228, e_ScreenH - 60);
        if(m_layers_page > 0 && UpdateButton(mode, e_ScreenW - 160 + 4, e_ScreenH - 40 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            m_layers_page --;

        if(m_layers_page < page_max && UpdateButton(mode, e_ScreenW - 120 + 4, e_ScreenH - 40 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            m_layers_page ++;
    }

    // prepare selector
    const std::string* layer_name;
    layerindex_t* layer_to_set;
    if(m_special_page == SPECIAL_PAGE_OBJ_LAYER && m_special_subpage == 1)
    {
        layer_name = &g_editorStrings.layersLabelAttachedLayer;
        layer_to_set = &EditorCursor.NPC.AttLayer;
    }
    else if(m_special_page == SPECIAL_PAGE_EVENT_LAYERS)
    {
        layer_name = &g_editorStrings.layersLabelMoveLayer;
        layer_to_set = &Events[m_current_event].MoveLayer;
    }
    else
    {
        layer_name = &g_editorStrings.labelLayer;
        layer_to_set = &EditorCursor.Layer;
    }

    // render description
    if(mode == CallMode::Render && m_special_page == SPECIAL_PAGE_OBJ_LAYER && m_special_subpage == 1)
    {
        FontManager::printTextOptiPx(g_editorStrings.layersDescAtt,
                                     e_ScreenW - 236, 80,
                                     230,
                                     FontManager::fontIdFromSmbxFont(3));
//        SuperPrintR(mode, g_editorStrings.layersDescAtt, 3, e_ScreenW - 236, 80);
//        SuperPrintR(mode, g_editorStrings.layersDescAtt2, 3, e_ScreenW - 236, 100);
//        SuperPrintR(mode, g_editorStrings.layersDescAtt3, 3, e_ScreenW - 236, 120);
//        SuperPrintR(mode, g_editorStrings.layersDescAtt4, 3, e_ScreenW - 236, 140);
//        SuperPrintR(mode, g_editorStrings.layersDescAtt5, 3, e_ScreenW - 236, 160);
    }

    // render current layer
    SuperPrintR(mode, *layer_name, 3, 10, 40);
    if(*layer_to_set == LAYER_NONE)
    {
        if(m_special_subpage == 1 || m_special_page == SPECIAL_PAGE_EVENT_LAYERS)
            SuperPrintR(mode, g_mainMenu.caseNone, 3, 10, 56);
        else
            SuperPrintR(mode, g_editorStrings.layersLayerDefault, 3, 10, 56);
    }
    else
        SuperPrintR(mode, GetL(*layer_to_set), 3, 10, 56);

    // render layer selector
    for(int i = 0; i < 10; i++)
    {
        int l;
        // separate Default and None for Event layers
        if(m_special_page == SPECIAL_PAGE_EVENT_LAYERS)
            l = m_layers_page*10 + i - 1;
        else
            l = m_layers_page*10 + i;

        if(l > maxLayers)
            continue;

        // separate None for Event layers
        if(l == -1)
        {
            SuperPrintR(mode, g_mainMenu.caseNone, 3, 54, 80 + 40*i + 12);

            if(m_special_page != SPECIAL_PAGE_EVENT_LAYERS && UpdateButton(mode, 10 + 4, 80 + 40*i + 4, GFX.ECursor[2], *layer_to_set == LAYER_NONE, 0, 0, 32, 32))
                *layer_to_set = LAYER_NONE;

            if(m_special_page == SPECIAL_PAGE_EVENT_LAYERS && UpdateButton(mode, 10 + 4, 80 + 40*i + 4, GFX.EIcons, *layer_to_set == LAYER_NONE, 0, 32*Icon::move, 32, 32))
                *layer_to_set = LAYER_NONE;
        }
        // Default and None are the same for objects layers and for the editor cursor -- set to None if "Default".
        else if(l == 0 && (m_special_page == SPECIAL_PAGE_OBJ_LAYER || m_special_page == SPECIAL_PAGE_LAYERS))
        {
            // AttLayer
            if(m_special_page == SPECIAL_PAGE_OBJ_LAYER && m_special_subpage == 1)
                SuperPrintR(mode, g_mainMenu.caseNone, 3, 54, 80 + 40*i + 12);
            else
                SuperPrintR(mode, g_editorStrings.layersLayerDefault, 3, 54, 80 + 40*i + 12);

            if(UpdateButton(mode, 10 + 4, 80 + 40*i + 4, GFX.ECursor[2], *layer_to_set == LAYER_NONE || (*layer_to_set) == l, 0, 0, 32, 32))
                *layer_to_set = LAYER_NONE;
        }
        else if(!Layer[l].Name.empty())
        {
            if(Layer[l].Name.length() < 20)
                SuperPrintR(mode, Layer[l].Name, 3, 54, 80 + 40*i + 10);
            else
            {
                SuperPrintR(mode, Layer[l].Name.substr(0,19), 3, 54, 80 + 40*i + 2);
                SuperPrintR(mode, Layer[l].Name.substr(19), 3, 54, 80 + 40*i + 20);
            }

            if(m_special_page != SPECIAL_PAGE_EVENT_LAYERS && UpdateButton(mode, 10 + 4, 80 + 40*i + 4, GFX.ECursor[2], (*layer_to_set) == l, 0, 0, 32, 32))
                *layer_to_set = l;

            // extra buttons for layers page
            if(m_special_page == SPECIAL_PAGE_LAYERS)
            {
                // rename, hide/show, shift up, shift down, delete
                // hide/show
                if(UpdateButton(mode, 440 + 4, 80 + 40*i + 4, GFX.EIcons, !Layer[l].Hidden, 0, 32*Icon::show, 32, 32))
                {
                    if(Layer[l].Hidden)
                        ShowLayer(l);
                    else
                        HideLayer(l);
                }

                if(l <= 2)
                    continue;

                // rename
                if(UpdateButton(mode, 400 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
                {
                    DisableCursorNew();
                    std::string new_name = TextEntryScreen::Run(g_editorStrings.layersPromptLayerName, Layer[l].Name);
                    if(!new_name.empty())
                        RenameLayer(l, new_name);
                    s_fix_mouse_pos();
                }

                // shift up
                if(l > 3 && UpdateButton(mode, 480 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
                    SwapLayers(l-1, l);

                // shift down
                if(l < numLayers - 1 && UpdateButton(mode, 520 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
                    SwapLayers(l, l+1);

                // delete
                if(l < numLayers && UpdateButton(mode, 560 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
                {
                    m_special_page = SPECIAL_PAGE_LAYER_DELETION;
                    m_special_subpage = l;
                    return;
                }
            }
            // extra buttons for event layers
            else if(m_special_page == SPECIAL_PAGE_EVENT_LAYERS)
            {
                // nothing, hide, show, toggle
                auto hide_it = std::find(Events[m_current_event].HideLayer.begin(), Events[m_current_event].HideLayer.end(), l);
                auto show_it = std::find(Events[m_current_event].ShowLayer.begin(), Events[m_current_event].ShowLayer.end(), l);
                auto togg_it = std::find(Events[m_current_event].ToggleLayer.begin(), Events[m_current_event].ToggleLayer.end(), l);
                bool cur_hide = hide_it != Events[m_current_event].HideLayer.end();
                bool cur_show = show_it != Events[m_current_event].ShowLayer.end();
                bool cur_togg = togg_it != Events[m_current_event].ToggleLayer.end();

                // no change
                if(UpdateButton(mode, 400 + 4, 80 + 40*i + 4, GFX.EIcons, !cur_hide && !cur_show && !cur_togg, 0, 0, 1, 1))
                {
                    if(cur_hide) Events[m_current_event].HideLayer.erase(hide_it);
                    if(cur_show) Events[m_current_event].ShowLayer.erase(show_it);
                    if(cur_togg) Events[m_current_event].ToggleLayer.erase(togg_it);
                }

                // show layer
                if(UpdateButton(mode, 440 + 4, 80 + 40*i + 4, GFX.EIcons, cur_show, 0, 32*Icon::show, 32, 32))
                {
                    if(cur_hide) Events[m_current_event].HideLayer.erase(hide_it);
                    if(!cur_show) Events[m_current_event].ShowLayer.push_back(l);
                    if(cur_togg) Events[m_current_event].ToggleLayer.erase(togg_it);
                }

                // hide layer
                if(UpdateButton(mode, 480 + 4, 80 + 40*i + 4, GFX.EIcons, cur_hide, 0, 32*Icon::hide, 32, 32))
                {
                    if(!cur_hide) Events[m_current_event].HideLayer.push_back(l);
                    if(cur_show) Events[m_current_event].ShowLayer.erase(show_it);
                    if(cur_togg) Events[m_current_event].ToggleLayer.erase(togg_it);
                }

                // togg layer
                if(UpdateButton(mode, 520 + 4, 80 + 40*i + 4, GFX.EIcons, cur_togg, 0, 32*Icon::toggle, 32, 32))
                {
                    if(cur_hide) Events[m_current_event].HideLayer.erase(hide_it);
                    if(cur_show) Events[m_current_event].ShowLayer.erase(show_it);
                    if(!cur_togg) Events[m_current_event].ToggleLayer.push_back(l);
                }

                if(UpdateButton(mode, 10 + 4, 80 + 40*i + 4, GFX.EIcons, (*layer_to_set) == l, 0, 32*Icon::move, 32, 32))
                    *layer_to_set = l;
            }
        }
        // create a new layer!
        else if(m_special_page == SPECIAL_PAGE_LAYERS && l != 0 && !Layer[l - 1].Name.empty())
        {
            SuperPrintR(mode, g_editorStrings.layersItemNewLayer, 3, 54, 80 + 40*i + 10);
            // rename only
            if(UpdateButton(mode, 400 + 4, 80 + 40*i + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
            {
                DisableCursorNew();
                std::string new_name = TextEntryScreen::Run(g_editorStrings.layersPromptLayerName, "");                
                if(!new_name.empty() && FindLayer(new_name) == LAYER_NONE)
                {
                    Layer[l] = Layer_t();
                    Layer[l].Name = new_name;
                    numLayers ++;
                }

                s_fix_mouse_pos();
            }
        }
    }
}

bool EditorScreen::UpdateBlockButton(CallMode mode, int x, int y, int type, bool sel)
{
    int draw_width = 32, draw_height = 32;

    if(!BlockIsSizable[type])
    {
        if(BlockWidth[type] > 0)
            draw_width = BlockWidth[type];

        if(BlockHeight[type] > 0)
            draw_height = BlockHeight[type];
    }

    return UpdateButton(mode, x, y, GFXBlock[type], sel, 0, BlockFrame[type] * 32, draw_width, draw_height) && !sel;
}

void EditorScreen::UpdateBlock(CallMode mode, int x, int y, int type)
{
    if((type < 1) || (type >= maxBlockType))
        return;

    bool sel = EditorCursor.Block.Type == type;

    if(UpdateBlockButton(mode, x, y, type, sel) && !sel)
    {
        // printf("Block %d\n", type);
        SetEditorBlockType(type);
    }
}

void EditorScreen::UpdateBlockGrid(CallMode mode, int x, int y, const int* types, int n_blocks, int n_cols)
{
    for(int i = 0; i < n_blocks; i ++)
    {
        int type = types[i];
        int row = i / n_cols;
        int col = i % n_cols;
        UpdateBlock(mode, x + col * 40 + 4, y + row * 40 + 4, type);
    }
}

void EditorScreen::UpdateBlockScreen(CallMode mode)
{
    // Block GUI
    if(mode == CallMode::Render)
    {
        XRender::renderRect(e_ScreenW - 160, 40, 160, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
        XRender::renderRect(0, 40, 40, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
        XRender::renderRect(38, 40, 2, e_ScreenH - 40, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
    }

    // Page selector
    int last_category = -1;
    int index = 0;

    for(const EditorCustom::ItemPage_t& page : EditorCustom::block_pages)
    {
        if(page.category != last_category)
        {
            last_category = page.category;

            if(mode == CallMode::Render && index != 0)
                XRender::renderRect(0, 40 + -2 + (40 * index), 40, 4, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
        }

        index++;

        if(UpdateBlockButton(mode, 4, 4 + (40 * index), page.icon, m_Block_page == index))
            m_Block_page = index;
    }

    // Magic Block toggle
    if(mode == CallMode::Render)
    {
        FontManager::printTextOptiPx(g_editorStrings.toggleMagicBlock,
                                     e_ScreenW - 120, 42,
                                     120,
                                     FontManager::fontIdFromSmbxFont(3));
    }

    if(UpdateButton(mode, e_ScreenW - 160 + 4, 40 + 4, GFXNPC[NPCID_COIN_SWITCH], MagicBlock::enabled, 0, 0, 32, 32))
        MagicBlock::enabled = !MagicBlock::enabled;

    // Resizing
    if(BlockIsSizable[EditorCursor.Block.Type])
    {
        int H = ((int)EditorCursor.Block.Location.Height) / 32;
        int W = ((int)EditorCursor.Block.Location.Width) / 32;

        SuperPrintR(mode, g_editorStrings.blockLetterWidth  + std::to_string(W), 3, e_ScreenW - 160, 112);

        if(W > 2 && UpdateButton(mode, e_ScreenW - 80 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            EditorCursor.Block.Location.Width = 32 * (W - 1);

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            EditorCursor.Block.Location.Width = 32 * (W + 1);

        SuperPrintR(mode, g_editorStrings.blockLetterHeight + std::to_string(H), 3, e_ScreenW - 160, 152);

        if(H > 2 && UpdateButton(mode, e_ScreenW - 80 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            EditorCursor.Block.Location.Height = 32 * (H - 1);

        if(UpdateButton(mode, e_ScreenW - 40 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            EditorCursor.Block.Location.Height = 32 * (H + 1);
    }

    // Legacy for Spin Block
    if(FileFormat == FileFormats::LVL_PGEX && EditorCursor.Block.Type == 90)
    {
        SuperPrintR(mode, g_editorStrings.blockCanBreak, 3, e_ScreenW - 160, 106);
        if(UpdateButton(mode, e_ScreenW - 40 + 4, 120 + 4, GFXBlock[188], EditorCursor.Block.forceSmashable, 0, 0, 32, 32, g_editorStrings.blockTooltipCanBreak.c_str()))
            EditorCursor.Block.forceSmashable = !EditorCursor.Block.forceSmashable;
    }
    else
    {
        EditorCursor.Block.forceSmashable = 0;
    }

    // Slippy ("SLICK") and Invis
    SuperPrintRightR(mode, g_editorStrings.blockSlick, 3, e_ScreenW - 40, 214);
    if(UpdateCheckBox(mode, e_ScreenW - 40 + 4, 200 + 4, EditorCursor.Block.Slippy))
        EditorCursor.Block.Slippy = !EditorCursor.Block.Slippy;

    SuperPrintRightR(mode, g_editorStrings.blockInvis, 3, e_ScreenW - 40, 254);
    if(UpdateCheckBox(mode, e_ScreenW - 40 + 4, 240 + 4, EditorCursor.Block.Invis))
        EditorCursor.Block.Invis = !EditorCursor.Block.Invis;

    // Contents
    SuperPrintRightR(mode, g_editorStrings.blockInside, 3, e_ScreenW - 40, 294);
    NPCID n_type = NPCID_NULL;
    if(EditorCursor.Block.Special > 0 && EditorCursor.Block.Special <= 100)
    {
        n_type = NPCID_COIN_S3;
        SuperPrintR(mode, "x" + std::to_string(EditorCursor.Block.Special), 3, e_ScreenW-80, 314);
    }
    else if(EditorCursor.Block.Special == 110)
    {
        n_type = (CommonFrame & 32) ? NPCID_INVINCIBILITY_POWER : NPCID_COIN_S3;
    }
    else if(EditorCursor.Block.Special > 1000)
    {
        n_type = NPCID(EditorCursor.Block.Special - 1000);
    }

    if(((n_type >= 1 && n_type <= maxNPCType) && UpdateNPCButton(mode, e_ScreenW - 40 + 4, 280 + 4, n_type, EditorCursor.Block.Special != 0))
        || ((n_type < 1 || n_type > maxNPCType) && UpdateButton(mode, e_ScreenW - 40 + 4, 280 + 4, GFX.EIcons, EditorCursor.Block.Special != 0, 0, 32 * Icon::subscreen, 32, 32)))
    {
        m_special_page = SPECIAL_PAGE_BLOCK_CONTENTS;
        FocusNPC();
    }

    // Events
    SuperPrintRightR(mode, g_editorStrings.eventsHeader, 3, e_ScreenW - 40, 334);
    SuperPrintR(mode, g_editorStrings.eventsLetterHit + GetE(EditorCursor.Block.TriggerHit), 3, e_ScreenW - 160, 360);

    if(EditorCursor.Block.Type != 186 && EditorCursor.Block.Type != 457)
    {
        SuperPrintR(mode, g_editorStrings.eventsLetterDestroy + GetE(EditorCursor.Block.TriggerDeath), 3, e_ScreenW - 160, 380);
        SuperPrintR(mode, g_editorStrings.eventsLetterLayerClear + GetE(EditorCursor.Block.TriggerLast), 3, e_ScreenW - 160, 400);
    }
    else
    {
        EditorCursor.Block.TriggerDeath = EVENT_NONE;
        EditorCursor.Block.TriggerLast = EVENT_NONE;
    }

    if(UpdateButton(mode, e_ScreenW - 40 + 4, 320 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_OBJ_TRIGGERS;

    // Layers
    SuperPrintRightR(mode, g_editorStrings.labelLayer, 3, e_ScreenW - 40, 434);
    if(EditorCursor.Block.Layer == LAYER_NONE)
        SuperPrintR(mode, g_editorStrings.layersLayerDefault, 3, e_ScreenW - 160, 460);
    else
        SuperPrintR(mode, GetL(EditorCursor.Block.Layer), 3, e_ScreenW - 160, 460);

    if(UpdateButton(mode, e_ScreenW - 40 + 4, 420 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_OBJ_LAYER;

    // block selector
    if(m_Block_page > 0 && m_Block_page <= (int)EditorCustom::block_pages.size())
    {
        const EditorCustom::ItemPage_t& page = EditorCustom::block_pages[m_Block_page - 1];

        for(auto it = page.begin; it != page.end; ++it)
        {
            const EditorCustom::ItemFamily& family = **it;

            if(mode == CallMode::Render)
            {
                int pix_len = SuperTextPixLen(family.name, 3);

                if(40 + family.X * 40 + pix_len > e_ScreenW - 160)
                    SuperPrint(family.name, 3, e_ScreenW - 160 - 4 - pix_len, 40 + family.Y * 20);
                else
                    SuperPrint(family.name, 3, 40 + family.X * 40 + 4, 40 + family.Y * 20);
            }

            UpdateBlockGrid(mode, 40 + family.X * 40, 60 + family.Y * 20, family.layout_pod.types.data(), family.layout_pod.types.size(), family.layout_pod.cols);
        }
    }
}

bool EditorScreen::UpdateBGOButton(CallMode mode, int x, int y, int type, bool sel)
{
    return UpdateButton(mode, x, y, GFXBackgroundBMP[type], sel, 0, BackgroundFrame[type] * BackgroundHeight[type], GFXBackground[type].w, BackgroundHeight[type]);
}

void EditorScreen::UpdateBGO(CallMode mode, int x, int y, int type)
{
    if((type < 1) || (type >= maxBackgroundType))
        return;

    bool sel = EditorCursor.Background.Type == type;
    if(UpdateBGOButton(mode, x, y, type, sel) && !sel)
    {
        EditorCursor.Background.Type = type;
        EditorCursor.Background.UpdateSortPriority();
    }
}

void EditorScreen::UpdateBGOGrid(CallMode mode, int x, int y, const int* types, int n_bgos, int n_cols)
{
    for(int i = 0; i < n_bgos; i ++)
    {
        int type = types[i];
        int row = i / n_cols;
        int col = i % n_cols;
        UpdateBGO(mode, x + col * 40 + 4, y + row * 40 + 4, type);
    }
}

void EditorScreen::UpdateBGOScreen(CallMode mode)
{
    // BGO GUI
    if(mode == CallMode::Render)
    {
        XRender::renderRect(e_ScreenW - 160, 40, 160, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
        XRender::renderRect(0, 40, 40, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
        XRender::renderRect(38, 40, 2, e_ScreenH - 40, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
    }


    // Page selector
    int last_category = -1;
    int index = 0;

    for(const EditorCustom::ItemPage_t& page : EditorCustom::bgo_pages)
    {
        if(page.category != last_category)
        {
            last_category = page.category;

            if(mode == CallMode::Render && index != 0)
                XRender::renderRect(0, 40 + -2 + (40 * index), 40, 4, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
        }

        index++;

        if(UpdateBGOButton(mode, 4, 4 + (40 * index), page.icon, m_BGO_page == index))
            m_BGO_page = index;
    }

    // Magic Block toggle
    if(mode == CallMode::Render)
    {
        FontManager::printTextOptiPx(g_editorStrings.toggleMagicBlock,
                                     e_ScreenW - 120, 42,
                                     120,
                                     FontManager::fontIdFromSmbxFont(3));
    }

    if(UpdateButton(mode, e_ScreenW - 160 + 4, 40 + 4, GFXNPC[NPCID_COIN_SWITCH], MagicBlock::enabled, 0, 0, 32, 32))
        MagicBlock::enabled = !MagicBlock::enabled;

    // Z-Layer and Z-Offset
    if(FileFormat == FileFormats::LVL_PGEX)
    {
        int layer = EditorCursor.Background.GetCustomLayer();
        int offset = EditorCursor.Background.GetCustomOffset();

        if(mode == CallMode::Render)
        {
            FontManager::printTextOptiPx(g_editorStrings.labelSortLayer,
                                         e_ScreenW - 120, 102,
                                         120,
                                         FontManager::fontIdFromSmbxFont(3));

            SuperPrint((layer == 0) ? g_editorStrings.layersLayerDefault : std::to_string(layer),
                       3,
                       e_ScreenW - 160, 142);
        }

        if(layer < 2 && UpdateButton(mode, e_ScreenW - 160 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
            EditorCursor.Background.SetSortPriority(layer + 1, offset);

        if(layer > -2 && UpdateButton(mode, e_ScreenW - 160 + 4, 160 + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
            EditorCursor.Background.SetSortPriority(layer - 1, offset);

        if(mode == CallMode::Render)
        {
            FontManager::printTextOptiPx(g_editorStrings.labelSortOffset,
                                         e_ScreenW - 120, 222,
                                         120,
                                         FontManager::fontIdFromSmbxFont(3));

            SuperPrint(std::to_string(offset),
                       3,
                       e_ScreenW - 160, 262);

            // debug: total sort priority
            SuperPrint("=" + std::to_string(EditorCursor.Background.SortPriority),
                       3,
                       e_ScreenW - 140, 322);
        }

        if(offset < 3 && UpdateButton(mode, e_ScreenW - 160 + 4, 220 + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
            EditorCursor.Background.SetSortPriority(layer, offset + 1);

        if(offset > -3 && UpdateButton(mode, e_ScreenW - 160 + 4, 280 + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
            EditorCursor.Background.SetSortPriority(layer, offset - 1);
    }

    // Layers
    SuperPrintRightR(mode, g_editorStrings.labelLayer, 3, e_ScreenW - 40, 434);
    if(EditorCursor.Background.Layer == LAYER_NONE)
        SuperPrintR(mode, g_editorStrings.layersLayerDefault, 3, e_ScreenW - 160, 460);
    else
        SuperPrintR(mode, GetL(EditorCursor.Background.Layer), 3, e_ScreenW - 160, 460);

    if(UpdateButton(mode, e_ScreenW - 40 + 4, 420 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_OBJ_LAYER;

    // BGO selector
    if(m_BGO_page > 0 && m_BGO_page <= (int)EditorCustom::bgo_pages.size())
    {
        const EditorCustom::ItemPage_t& page = EditorCustom::bgo_pages[m_BGO_page - 1];

        for(auto it = page.begin; it != page.end; ++it)
        {
            const EditorCustom::ItemFamily& family = **it;

            if(mode == CallMode::Render)
            {
                int pix_len = SuperTextPixLen(family.name, 3);

                if(40 + family.X * 40 + pix_len > e_ScreenW - 160)
                    SuperPrint(family.name, 3, e_ScreenW - 160 - 4 - pix_len, 40 + family.Y * 20);
                else
                    SuperPrint(family.name, 3, 40 + family.X * 40 + 4, 40 + family.Y * 20);
            }

            UpdateBGOGrid(mode, 40 + family.X * 40, 60 + family.Y * 20, family.layout_pod.types.data(), family.layout_pod.types.size(), family.layout_pod.cols);
        }
    }
}

void EditorScreen::UpdateAreaScreen(CallMode mode)
{
    SuperPrintR(mode, g_editorStrings.tooltipArea, 3, 200, 50);

    int H = EditorCursor.WorldArea.Location.Height / 32;
    int W = EditorCursor.WorldArea.Location.Width / 32;

    // validation
    if(H == 0)
    {
        H = 1;
        EditorCursor.WorldArea.Location.Height = 32;
    }

    if(W == 0)
    {
        W = 1;
        EditorCursor.WorldArea.Location.Width = 32;
    }

    // Width
    SuperPrintRightR(mode, g_editorStrings.wordWidth + " " + std::to_string(W), 3, 330, 90);

    if(W > 1 && UpdateButton(mode, 340 + 4, 80 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        EditorCursor.WorldArea.Location.Width = 32 * (W - 1);

    if(UpdateButton(mode, 380 + 4, 80 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        EditorCursor.WorldArea.Location.Width = 32 * (W + 1);

    // Height
    SuperPrintRightR(mode, g_editorStrings.wordHeight + " " + std::to_string(H), 3, 330, 130);

    if(H > 1 && UpdateButton(mode, 340 + 4, 120 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        EditorCursor.WorldArea.Location.Height = 32 * (H - 1);

    if(UpdateButton(mode, 380 + 4, 120 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        EditorCursor.WorldArea.Location.Height = 32 * (H + 1);
}

void EditorScreen::UpdateWaterScreen(CallMode mode)
{
    SuperPrintR(mode, g_editorStrings.waterTitle, 3, 200, 50);

    int H = ((int)EditorCursor.Water.Location.Height)/32;
    int W = ((int)EditorCursor.Water.Location.Width)/32;

    // validation
    if(H == 0)
    {
        H = 1;
        EditorCursor.Water.Location.Height = 32;
    }

    if(W == 0)
    {
        W = 1;
        EditorCursor.Water.Location.Width = 32;
    }

    // Width
    if(W >= 10)
        SuperPrintRightR(mode, g_editorStrings.wordWidth + " " + std::to_string(W), 3, 330, 90);
    else
        SuperPrintRightR(mode, g_editorStrings.wordWidth + " " + std::to_string(W), 3, 330, 90);

    if(W > 1 && UpdateButton(mode, 340 + 4, 80 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        EditorCursor.Water.Location.Width = 32 * (W - 1);

    if(UpdateButton(mode, 380 + 4, 80 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        EditorCursor.Water.Location.Width = 32 * (W + 1);

    // Height
    if(H >= 10)
        SuperPrintRightR(mode, g_editorStrings.wordHeight + " " + std::to_string(H), 3, 330, 130);
    else
        SuperPrintRightR(mode, g_editorStrings.wordHeight + " " + std::to_string(H), 3, 330, 130);

    if(H > 1 && UpdateButton(mode, 340 + 4, 120 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        EditorCursor.Water.Location.Height = 32 * (H - 1);

    if(UpdateButton(mode, 380 + 4, 120 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        EditorCursor.Water.Location.Height = 32 * (H + 1);

    // mode
    SuperPrintRightR(mode, g_editorStrings.wordMode, 3, 330, 170);

    if(UpdateButton(mode, 340 + 4, 160 + 4, GFXBackgroundBMP[26], EditorCursor.Water.Type == PHYSID_WATER, 0, 0, 32, 32))
        EditorCursor.Water.Type = PHYSID_WATER;

    if(UpdateButton(mode, 380 + 4, 160 + 4, GFXBackgroundBMP[188], EditorCursor.Water.Type == PHYSID_QUICKSAND, 0, 0, 32, 32))
        EditorCursor.Water.Type = PHYSID_QUICKSAND;

    if(FileFormat == FileFormats::LVL_PGEX && UpdateButton(mode, 420 + 4, 160 + 4, GFXBlock[294], EditorCursor.Water.Type == PHYSID_MAZE, 0, 0, 32, 32))
        EditorCursor.Water.Type = PHYSID_MAZE;

    // layers
    SuperPrintRightR(mode, g_editorStrings.labelLayer, 3, 330, 234);
    if(EditorCursor.Layer == LAYER_NONE)
        SuperPrintR(mode, g_editorStrings.layersLayerDefault, 3, 206, 260);
    else
        SuperPrintR(mode, GetL(EditorCursor.Layer), 3, 206, 260);

    if(UpdateButton(mode, 340 + 4, 220 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_OBJ_LAYER;
}

void EditorScreen::UpdateWarpScreen(CallMode mode)
{
    // Warp GUI
    if(mode == CallMode::Render)
        XRender::renderRect(0, 40, e_ScreenW - 240, 140, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
    if(mode == CallMode::Render)
        XRender::renderRect(e_ScreenW - 240, 40, 240, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);

    SuperPrintR(mode, g_editorStrings.warpTitle, 3, 200, 50);

    // prep for placement selection
    if(EditorCursor.Warp.level == STRINGINDEX_NONE && !EditorCursor.Warp.LevelEnt && !EditorCursor.Warp.MapWarp)
    {
        if(EditorCursor.SubMode != 1 && EditorCursor.SubMode != 2)
            EditorCursor.SubMode = 1;
    }
    else if(!EditorCursor.Warp.LevelEnt)
    {
        EditorCursor.Warp.twoWay = false;
        EditorCursor.SubMode = 1;
    }
    else
    {
        EditorCursor.Warp.twoWay = false;
        EditorCursor.SubMode = 2;
    }

    // placement selection and directions
    if(!EditorCursor.Warp.LevelEnt)
    {
        SuperPrintR(mode, g_editorStrings.warpPlacing, 3, 40, 82);

        SuperPrintRightR(mode, g_editorStrings.warpIn, 3, 80, 114);
        if(UpdateButton(mode, 80 + 4, 100 + 4, GFX.EIcons, EditorCursor.SubMode == 1, 0, 32*Icon::action, 32, 32))
            EditorCursor.SubMode = 1;

        SuperPrintRightR(mode, g_editorStrings.warpDir, 3, 220, 114);

        if(UpdateButton(mode, 220 + 4, 100 + 4, GFX.EIcons, EditorCursor.Warp.Direction == 1, 0, 32*Icon::up, 32, 32))
            EditorCursor.Warp.Direction = 1;

        if(UpdateButton(mode, 260 + 4, 100 + 4, GFX.EIcons, EditorCursor.Warp.Direction == 3, 0, 32*Icon::down, 32, 32))
            EditorCursor.Warp.Direction = 3;

        if(UpdateButton(mode, 300 + 4, 100 + 4, GFX.EIcons, EditorCursor.Warp.Direction == 2, 0, 32*Icon::left, 32, 32))
            EditorCursor.Warp.Direction = 2;

        if(UpdateButton(mode, 340 + 4, 100 + 4, GFX.EIcons, EditorCursor.Warp.Direction == 4, 0, 32*Icon::right, 32, 32))
            EditorCursor.Warp.Direction = 4;
    }
    else
    {
        SuperPrintR(mode, g_editorStrings.warpPlacing, 3, 40, 122);
    }

    if(EditorCursor.Warp.level == STRINGINDEX_NONE && !EditorCursor.Warp.MapWarp)
    {
        SuperPrintRightR(mode, g_editorStrings.warpOut, 3, 80, 154);
        if(UpdateButton(mode, 80 + 4, 140 + 4, GFX.EIcons, EditorCursor.SubMode == 2, 0, 32*Icon::action, 32, 32))
            EditorCursor.SubMode = 2;

        SuperPrintRightR(mode, g_editorStrings.warpDir, 3, 220, 154);

        if(UpdateButton(mode, 220 + 4, 140 + 4, GFX.EIcons, EditorCursor.Warp.Direction2 == 1, 0, 32*Icon::down, 32, 32))
            EditorCursor.Warp.Direction2 = 1;

        if(UpdateButton(mode, 260 + 4, 140 + 4, GFX.EIcons, EditorCursor.Warp.Direction2 == 3, 0, 32*Icon::up, 32, 32))
            EditorCursor.Warp.Direction2 = 3;

        if(UpdateButton(mode, 300 + 4, 140 + 4, GFX.EIcons, EditorCursor.Warp.Direction2 == 2, 0, 32*Icon::right, 32, 32))
            EditorCursor.Warp.Direction2 = 2;

        if(UpdateButton(mode, 340 + 4, 140 + 4, GFX.EIcons, EditorCursor.Warp.Direction2 == 4, 0, 32*Icon::left, 32, 32))
            EditorCursor.Warp.Direction2 = 4;
    }

    if(EditorCursor.Warp.level == STRINGINDEX_NONE && !EditorCursor.Warp.LevelEnt && !EditorCursor.Warp.MapWarp)
    {
        SuperPrintR(mode, g_editorStrings.warpTwoWay, 3, e_ScreenW - 240 + 40 + 4, 134);
        if(UpdateCheckBox(mode, e_ScreenW - 240 + 4, 120 + 4, EditorCursor.Warp.twoWay))
            EditorCursor.Warp.twoWay = !EditorCursor.Warp.twoWay;

    }

    // Events
    if(FileFormat == FileFormats::LVL_PGEX)
    {
        if(mode == CallMode::Render)
        {
            SuperPrintRightAlign(g_editorStrings.eventsHeader, 3, e_ScreenW - 80, 334);
            SuperPrint(g_editorStrings.eventsLetterEnter + GetE(EditorCursor.Warp.eventEnter), 3, e_ScreenW - 240, 360);
        }

        if(UpdateButton(mode, e_ScreenW - 80 + 4, 320 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
            m_special_page = SPECIAL_PAGE_OBJ_TRIGGERS;
    }

    // Layers
    if(mode == CallMode::Render)
    {
        SuperPrintRightAlign(g_editorStrings.labelLayer, 3, e_ScreenW - 80, 414);
        if(EditorCursor.Warp.Layer == LAYER_NONE)
            SuperPrint(g_editorStrings.layersLayerDefault, 3, e_ScreenW - 240, 440);
        else
            SuperPrint(GetL(EditorCursor.Warp.Layer), 3, e_ScreenW - 240, 440);
    }

    if(UpdateButton(mode, e_ScreenW - 80 + 4, 400 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        m_special_page = SPECIAL_PAGE_OBJ_LAYER;

    // page selector
    if(UpdateButton(mode, e_ScreenW - 240 + 4, 180 + 4, GFXBlock[294], m_Warp_page == WARP_PAGE_MAIN, 0, 0, 32, 32))
        m_Warp_page = WARP_PAGE_MAIN;

    if(UpdateButton(mode, e_ScreenW - 240 + 4, 220 + 4, GFXNPC[31], m_Warp_page == WARP_PAGE_REQS, 0, 0, 32, 32))
        m_Warp_page = WARP_PAGE_REQS;

    if(UpdateButton(mode, e_ScreenW - 240 + 4, 260 + 4, GFXLevelBMP[2], m_Warp_page == WARP_PAGE_LEVEL, 0, 0, 32, 32))
        m_Warp_page = WARP_PAGE_LEVEL;


    // MAIN WARP PAGE

    if(m_Warp_page == WARP_PAGE_MAIN)
    {
        std::string* style_name;

        // warp effect
        switch(EditorCursor.Warp.Effect)
        {
        default:
            EditorCursor.Warp.Effect = 1;
        //fallthrough
        case 1:
            style_name = &g_editorStrings.warpStylePipe;
            break;
        case 2:
            style_name = &g_editorStrings.warpStyleDoor;
            break;
        case 0:
            style_name = &g_editorStrings.warpStyleBlipInstant;
            break;
        case 3:
            style_name = &g_editorStrings.warpStylePortal;
            break;
        }

        SuperPrintR(mode, g_editorStrings.warpStyle + *style_name, 3, 6, 194);

        if(UpdateButton(mode, 220 + 4, 180 + 4, GFXBlock[294], EditorCursor.Warp.Effect == 1, 0, 0, 32, 32))
            EditorCursor.Warp.Effect = 1;

        if(UpdateButton(mode, 260 + 4, 180 + 4, GFXBackgroundBMP[88], EditorCursor.Warp.Effect == 2, 0, 0, 32, 32))
        {
            EditorCursor.Warp.Effect = 2;
            EditorCursor.Warp.Direction = 1;
            EditorCursor.Warp.Direction2 = 1;
        }

        if(UpdateButton(mode, 300 + 4, 180 + 4, GFXBackgroundBMP[61], EditorCursor.Warp.Effect == 0, 0, 0, 32, 32))
            EditorCursor.Warp.Effect = 0;

        if(FileFormat == FileFormats::LVL_PGEX && UpdateButton(mode, 340 + 4, 180 + 4, GFXNPC[NPCID_HOMING_BALL], EditorCursor.Warp.Effect == 3, 0, 0, 32, 32))
            EditorCursor.Warp.Effect = 3;

        // fade effect
        if(FileFormat == FileFormats::LVL_PGEX)
        {
            if(EditorCursor.Warp.transitEffect < 0 || EditorCursor.Warp.transitEffect >= (int)g_editorStrings.listWarpTransitNames.size())
                EditorCursor.Warp.transitEffect = 0;

            SuperPrintR(mode, g_editorStrings.warpEffect, 3, 6, 234);
            if(mode == CallMode::Render)
                SuperPrintRightAlign(g_editorStrings.listWarpTransitNames[EditorCursor.Warp.transitEffect], 3, 256, 234);

            if(UpdateButton(mode, 260 + 4, 220 + 4, GFX.EIcons, EditorCursor.Warp.transitEffect, 0, 32*Icon::subscreen, 32, 32))
                m_special_page = SPECIAL_PAGE_WARP_TRANSITION;
        }

        // allow / forbid
        SuperPrintR(mode, g_editorStrings.warpAllow, 3, 6, 294);

        SuperPrintRightR(mode, g_editorStrings.warpItem, 3, 220, 294);
        if(UpdateCheckBox(mode, 220 + 4, 280 + 4, EditorCursor.Warp.WarpNPC))
            EditorCursor.Warp.WarpNPC = !EditorCursor.Warp.WarpNPC;

        SuperPrintRightR(mode, g_editorStrings.warpRide, 3, 360, 294);
        if(UpdateCheckBox(mode, 360 + 4, 280 + 4, !EditorCursor.Warp.NoYoshi))
            EditorCursor.Warp.NoYoshi = !EditorCursor.Warp.NoYoshi;

        // cannon exit
        if(FileFormat == FileFormats::LVL_PGEX)
        {
            SuperPrintR(mode, g_editorStrings.warpCannonExit, 3, 6, 354);

            if(UpdateCheckBox(mode, 220 + 4, 340 + 4, EditorCursor.Warp.cannonExit))
            {
                EditorCursor.Warp.cannonExit = !EditorCursor.Warp.cannonExit;
                if(!EditorCursor.Warp.cannonExit)
                    EditorCursor.Warp.cannonExitSpeed = 0;
            }

            if(EditorCursor.Warp.cannonExit)
            {
                SuperPrintR(mode, g_editorStrings.warpSpeed + std::to_string(EditorCursor.Warp.cannonExitSpeed), 3, 26, 394);
                if(EditorCursor.Warp.cannonExitSpeed > 1 && UpdateButton(mode, 180 + 4, 380 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
                    EditorCursor.Warp.cannonExitSpeed --;
                if(EditorCursor.Warp.cannonExitSpeed <= 31 && UpdateButton(mode, 220 + 4, 380 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
                    EditorCursor.Warp.cannonExitSpeed ++;
            }
        }
    }

    if(m_Warp_page == WARP_PAGE_REQS)
    {
        // stars required
        if(mode == CallMode::Render)
        {
            std::string need_star_count = fmt::format_ne(g_editorStrings.warpNeedStarCount, EditorCursor.Warp.Stars,
                LanguageFormatNumber(EditorCursor.Warp.Stars, g_gameInfo.wordStarAccusativeSingular, g_gameInfo.wordStarAccusativeDual_Cnt, g_gameInfo.wordStarAccusativePlural),
                g_gameInfo.wordStarAccusativeDual_Cnt);

            SuperPrintR(mode, need_star_count, 3, 6, 194);
        }

        if(EditorCursor.Warp.Stars > 0 && UpdateButton(mode, 260 + 4, 180 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            EditorCursor.Warp.Stars --;
        if(UpdateButton(mode, 300 + 4, 180 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            EditorCursor.Warp.Stars ++;

        // new: StarsMsg
        if(FileFormat == FileFormats::LVL_PGEX)
        {
            SuperPrintR(mode, g_editorStrings.warpStarLockMessage, 3, 44, 234);
            if(UpdateButton(mode, 300 + 4, 220 + 4, GFX.EIcons, EditorCursor.Warp.StarsMsg != STRINGINDEX_NONE, 0, 32*Icon::pencil, 32, 32))
            {
                DisableCursorNew();
                SetS(EditorCursor.Warp.StarsMsg, TextEntryScreen::Run(g_editorStrings.warpStarLockMessage, GetS(EditorCursor.Warp.StarsMsg)));
                s_fix_mouse_pos();
            }
        }

        SuperPrintR(mode, g_editorStrings.warpNeedKey, 3, 6, 274);
        if(UpdateCheckBox(mode, 220 + 4, 260 + 4, EditorCursor.Warp.Locked))
            EditorCursor.Warp.Locked = !EditorCursor.Warp.Locked;

        // new: must stand to enter
        if(FileFormat == FileFormats::LVL_PGEX)
        {
            SuperPrintR(mode, g_editorStrings.warpNeedFloor, 3, 6, 314);
            if(UpdateCheckBox(mode, 220 + 4, 300 + 4, EditorCursor.Warp.stoodRequired))
                EditorCursor.Warp.stoodRequired = !EditorCursor.Warp.stoodRequired;
        }
    }

    if(m_Warp_page == WARP_PAGE_LEVEL)
    {
        // map/level warps
        SuperPrintR(mode, g_editorStrings.warpToMap, 3, 6, 194);
        if(UpdateCheckBox(mode, 120 + 4, 180 + 4, EditorCursor.Warp.MapWarp))
        {
            EditorCursor.Warp.MapWarp = !EditorCursor.Warp.MapWarp;
            if(EditorCursor.Warp.MapWarp)
            {
                FreeS(EditorCursor.Warp.level);
                EditorCursor.Warp.LevelEnt = false;
            }
        }

        SuperPrintR(mode, g_editorStrings.warpLvlWarp, 3, 6, 234);

        SuperPrintRightR(mode, g_editorStrings.warpIn, 3, 240, 234);
        if(UpdateCheckBox(mode, 240 + 4, 220 + 4, EditorCursor.Warp.level != STRINGINDEX_NONE))
        {
            if(EditorCursor.Warp.level == STRINGINDEX_NONE)
            {
                SetS(EditorCursor.Warp.level, "...");
                EditorCursor.Warp.MapWarp = false;
                EditorCursor.Warp.LevelEnt = false;
            }
            else
                FreeS(EditorCursor.Warp.level);
        }

        SuperPrintRightR(mode, g_editorStrings.warpOut, 3, 360, 234);
        if(UpdateCheckBox(mode, 360 + 4, 220 + 4, EditorCursor.Warp.LevelEnt))
        {
            EditorCursor.Warp.LevelEnt = !EditorCursor.Warp.LevelEnt;
            if(EditorCursor.Warp.LevelEnt)
            {
                FreeS(EditorCursor.Warp.level);
                EditorCursor.Warp.MapWarp = false;
            }
        }

        // special options for lvl warp entrance
        if(EditorCursor.Warp.level != STRINGINDEX_NONE)
        {
            if(GetS(EditorCursor.Warp.level).length() <= 12)
            {
                SuperPrintR(mode, g_editorStrings.warpTarget + GetS(EditorCursor.Warp.level), 3, 6, 314);
            }
            else
            {
                SuperPrintR(mode, g_editorStrings.warpTarget + GetS(EditorCursor.Warp.level).substr(0,12), 3, 6, 302);
                SuperPrintR(mode, GetS(EditorCursor.Warp.level).substr(12), 3, 24, 322);
            }

            if(UpdateButton(mode, 360 + 4, 300 + 4, GFX.EIcons, false, 0, 32*Icon::open, 32, 32))
                StartFileBrowser(PtrS(EditorCursor.Warp.level), FileNamePath, "", {".lvl", ".lvlx"}, BROWSER_MODE_OPEN);

            // display this in a different way if modern options are enabled
            if(EditorCursor.Warp.LevelWarp == 0)
                SuperPrintR(mode, fmt::format_ne(g_editorStrings.warpTo, g_editorStrings.levelStartPos), 3, 46, 354);
            else
                SuperPrintR(mode, fmt::format_ne(g_editorStrings.warpTo, fmt::format_ne(g_editorStrings.phraseWarpIndex, EditorCursor.Warp.LevelWarp)), 3, 46, 354);

            if(EditorCursor.Warp.LevelWarp > 0 && UpdateButton(mode, 4, 340 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
                EditorCursor.Warp.LevelWarp --;

            if(EditorCursor.Warp.LevelWarp < maxWarps && UpdateButton(mode, 280 + 4, 340 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
                EditorCursor.Warp.LevelWarp ++;

            if(FileFormat == FileFormats::LVL_PGEX)
            {
                // display the option to show/hide the level start scene
                SuperPrintRightR(mode, g_editorStrings.warpShowStartScene, 3, 320, 414);
                if(UpdateCheckBox(mode, 320 + 4, 400 + 4, !EditorCursor.Warp.noEntranceScene))
                    EditorCursor.Warp.noEntranceScene = !EditorCursor.Warp.noEntranceScene;
                // display the option to show/hide the level star count
                SuperPrintRightR(mode, g_editorStrings.warpShowStarCount, 3, 320, 454);
                if(UpdateButton(mode, 320 + 4, 440 + 4, GFXNPC[NPCID_STAR_EXIT], !EditorCursor.Warp.noPrintStars, 0, 0, 32, 32))
                    EditorCursor.Warp.noPrintStars = !EditorCursor.Warp.noPrintStars;
            }
        }

        // special options for map warp
        if(EditorCursor.Warp.MapWarp)
        {
            // map warp!
            SuperPrintR(mode, g_editorStrings.mapPos, 3, 44, 302);

            if(EditorCursor.Warp.MapX != -1 || EditorCursor.Warp.MapY != -1)
            {
                SuperPrintR(mode, g_editorStrings.letterCoordX + ": " + std::to_string(EditorCursor.Warp.MapX), 3, 4, 320);
                SuperPrintR(mode, g_editorStrings.letterCoordY + ": " + std::to_string(EditorCursor.Warp.MapY), 3, 4, 340);
            }
            else
            {
                SuperPrintR(mode, g_mainMenu.caseNone, 3, 4, 330);
            }

            if(UpdateButton(mode, 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
            {
                EditorCursor.Warp.MapY = 32*(EditorCursor.Warp.MapY/32 - 1);
                if(EditorCursor.Warp.MapX == -1)
                    EditorCursor.Warp.MapX = 0.;
            }

            if(UpdateButton(mode, 40 + 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
            {
                EditorCursor.Warp.MapY = 32*(EditorCursor.Warp.MapY/32 + 1);
                if(EditorCursor.Warp.MapX == -1)
                    EditorCursor.Warp.MapX = 0.;
            }

            if(UpdateButton(mode, 80 + 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            {
                EditorCursor.Warp.MapX = 32*(EditorCursor.Warp.MapX/32 - 1);
                if(EditorCursor.Warp.MapY == -1)
                    EditorCursor.Warp.MapY = 0.;
            }

            if(UpdateButton(mode, 120 + 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            {
                EditorCursor.Warp.MapX = 32*(EditorCursor.Warp.MapX/32 + 1);
                if(EditorCursor.Warp.MapY == -1)
                    EditorCursor.Warp.MapY = 0.;
            }
        }
    }
}

bool EditorScreen::UpdateTileButton(CallMode mode, int x, int y, int type, bool sel)
{
    return UpdateButton(mode, x, y, GFXTileBMP[type], sel, 0, TileHeight[type] * TileFrame[type], TileWidth[type], TileHeight[type]);
}

void EditorScreen::UpdateTile(CallMode mode, int x, int y, int type)
{
    if((type < 1) || (type >= maxTileType))
        return;

    bool sel = EditorCursor.Tile.Type == type;
    if(UpdateTileButton(mode, x, y, type, sel) && !sel)
    {
        // printf("Tile %d\n", type);
        EditorCursor.Tile.Type = type;
    }
}

void EditorScreen::UpdateTileGrid(CallMode mode, int x, int y, const int* types, int n_tiles, int n_cols)
{
    for(int i = 0; i < n_tiles; i ++)
    {
        int type = types[i];
        int row = i / n_cols;
        int col = i % n_cols;
        UpdateTile(mode, x + col * 40 + 4, y + row * 40 + 4, type);
    }
}

void EditorScreen::UpdateTileScreen(CallMode mode)
{
    // Block GUI
    if(mode == CallMode::Render)
    {
        XRender::renderRect(0, 40, 40, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);
        XRender::renderRect(38, 40, 2, e_ScreenH - 40, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
    }


    // Page selector
    int last_category = -1;
    int index = 0;

    for(const EditorCustom::ItemPage_t& page : EditorCustom::tile_pages)
    {
        if(page.category != last_category)
        {
            last_category = page.category;

            if(mode == CallMode::Render && index != 0)
                XRender::renderRect(0, 40 + -2 + (40 * index), 40, 4, XTColorF(0.25_n, 0.0_n, 0.5_n), true);
        }

        index++;

        if(UpdateTileButton(mode, 4, 4 + (40 * index), page.icon, m_tile_page == index))
            m_tile_page = index;
    }


    // Tile selector
    if(m_tile_page > 0 && m_tile_page <= (int)EditorCustom::tile_pages.size())
    {
        const EditorCustom::ItemPage_t& page = EditorCustom::tile_pages[m_tile_page - 1];

        for(auto it = page.begin; it != page.end; ++it)
        {
            const EditorCustom::ItemFamily& family = **it;

            if(mode == CallMode::Render)
            {
                int pix_len = SuperTextPixLen(family.name, 3);

                if(40 + family.X * 40 + pix_len > e_ScreenW)
                    SuperPrint(family.name, 3, e_ScreenW - 4 - pix_len, 40 + family.Y * 20);
                else
                    SuperPrint(family.name, 3, 40 + family.X * 40 + 4, 40 + family.Y * 20);
            }

            UpdateTileGrid(mode, 40 + family.X * 40, 60 + family.Y * 20, family.layout_pod.types.data(), family.layout_pod.types.size(), family.layout_pod.cols);
        }
    }
}

void EditorScreen::UpdateScene(CallMode mode, int x, int y, int type)
{
    if((type < 1) || (type >= maxSceneType))
        return;
    bool sel = EditorCursor.Scene.Type == type;
    if(UpdateButton(mode, x, y, GFXSceneBMP[type], sel, 0, SceneHeight[type] * SceneFrame[type], SceneWidth[type], SceneHeight[type]) && !sel)
    {
        // printf("%d\n", type);
        EditorCursor.Scene.Type = type;
    }
}

void EditorScreen::UpdateSceneGrid(CallMode mode, int x, int y, const int* types, int n_scenes, int n_cols)
{
    for(int i = 0; i < n_scenes; i ++)
    {
        int type = types[i];
        int row = i / n_cols;
        int col = i % n_cols;
        UpdateScene(mode, x + col * 40 + 4, y + row * 40 + 4, type);
    }
}

void EditorScreen::UpdateSceneScreen(CallMode mode)
{
    // Scene GUI (none)

    // SuperPrintR(mode, "SCENERY", 3, 10, 40);
    static const int scenes[] =
    {
        1,  2, 3, 4, 5, 6, 7, 8, 9, 10,
        11, 12, 13, 14, 15, 16, 17, 18,
        19, 20, 21, 22, 23, 24, 25, 26,
        27, 28, 29, 30, 31, 32, 33, 34,
        35, 36, 37, 38, 39, 40, 41, 48,
        49, 42, 47, 46, 43, 45, 64, 65,
        44, 50, 51, 52, 53, 54, 55, 56,
        57, 58, 59, 60, 61, 62, 63
    };
    UpdateSceneGrid(mode, 0, 60, scenes, sizeof(scenes)/sizeof(int), 10);
}

void EditorScreen::UpdateLevel(CallMode mode, int x, int y, int type)
{
    if((type < 1) || (type >= maxLevelType))
        return;

    bool sel = EditorCursor.WorldLevel.Type == type;
    int draw_height;

    if(GFXLevelBig[type])
        draw_height = GFXLevel[type].h;
    else
        draw_height = 32;

    if(UpdateButton(mode, x, y, GFXLevelBMP[type], sel, 0, 32 * LevelFrame[type], GFXLevel[type].w, draw_height) && !sel)
    {
        // printf("%d\n", type);
        EditorCursor.WorldLevel.Type = type;
    }
}

void EditorScreen::UpdateLevelGrid(CallMode mode, int x, int y, const int* types, int n_levels, int n_cols)
{
    for(int i = 0; i < n_levels; i ++)
    {
        int type = types[i];
        int row = i / n_cols;
        int col = i % n_cols;
        UpdateLevel(mode, x + col * 40 + 4, y + row * 40 + 4, type);
    }
}

void EditorScreen::UpdateLevelScreen(CallMode mode)
{
    // World Level GUI
    if(mode == CallMode::Render)
        XRender::renderRect(e_ScreenW - 240, 40, 240, e_ScreenH - 40, XTColorF(0.7_n, 0.7_n, 0.9_n, 0.75_n), true);

    // SuperPrintR(mode, "LEVEL GRAPHIC", 3, 10, 40);
    static const int levels[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32};
    UpdateLevelGrid(mode, 0, 60, levels, sizeof(levels)/sizeof(int), 8);

    // path bg - Path
    if(UpdateCheckBox(mode, e_ScreenW - 240 + 4, 80+4, EditorCursor.WorldLevel.Path))
    {
        EditorCursor.WorldLevel.Path = !EditorCursor.WorldLevel.Path;
        if(EditorCursor.WorldLevel.Path)
            EditorCursor.WorldLevel.Path2 = false;
    }
    SuperPrintR(mode, g_editorStrings.levelPathBG, 3, e_ScreenW - 240 + 44, 90);

    // big bg - Path2
    if(UpdateCheckBox(mode, e_ScreenW - 240 + 4, 120+4, EditorCursor.WorldLevel.Path2))
    {
        EditorCursor.WorldLevel.Path2 = !EditorCursor.WorldLevel.Path2;
        if(EditorCursor.WorldLevel.Path2)
            EditorCursor.WorldLevel.Path = false;
    }
    SuperPrintR(mode, g_editorStrings.levelBigBG, 3, e_ScreenW - 240 + 44, 130);

    // game start - Start
    if(UpdateCheckBox(mode, e_ScreenW - 240 + 4, 160 + 4, EditorCursor.WorldLevel.Start))
        EditorCursor.WorldLevel.Start = !EditorCursor.WorldLevel.Start;
    SuperPrintR(mode, g_editorStrings.levelGameStart, 3, e_ScreenW - 240 + 44, 170);

    // always visible - Visible
    if(UpdateCheckBox(mode, e_ScreenW - 240 + 4, 200 + 4, EditorCursor.WorldLevel.Visible))
        EditorCursor.WorldLevel.Visible = !EditorCursor.WorldLevel.Visible;
    SuperPrintR(mode, g_editorStrings.levelAlwaysVis, 3, e_ScreenW - 240 + 44, 210);

    // map warp!
    SuperPrintR(mode, g_editorStrings.mapPos, 3, e_ScreenW - 240 + 44, 302);

    if(EditorCursor.WorldLevel.WarpX != -1 || EditorCursor.WorldLevel.WarpY != -1)
    {
        SuperPrintR(mode, g_editorStrings.letterCoordX + ": " + std::to_string(EditorCursor.WorldLevel.WarpX), 3, e_ScreenW - 240 + 4, 320);
        SuperPrintR(mode, g_editorStrings.letterCoordY + ": " + std::to_string(EditorCursor.WorldLevel.WarpY), 3, e_ScreenW - 240 + 4, 340);
        if(UpdateButton(mode, e_ScreenW - 240 + 160 + 4, 320 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
        {
            EditorCursor.WorldLevel.WarpX = -1;
            EditorCursor.WorldLevel.WarpY = -1;
        }
    }
    else
    {
        SuperPrintR(mode, g_mainMenu.caseNone, 3, e_ScreenW - 240 + 4, 330);
    }

    if(UpdateButton(mode, e_ScreenW - 240 + 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::up, 32, 32))
    {
        EditorCursor.WorldLevel.WarpY = 32*(EditorCursor.WorldLevel.WarpY/32 - 1);
        if(EditorCursor.WorldLevel.WarpX == -1)
            EditorCursor.WorldLevel.WarpX = 0.;
    }

    if(UpdateButton(mode, e_ScreenW - 240 + 40 + 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::down, 32, 32))
    {
        EditorCursor.WorldLevel.WarpY = 32*(EditorCursor.WorldLevel.WarpY/32 + 1);
        if(EditorCursor.WorldLevel.WarpX == -1)
            EditorCursor.WorldLevel.WarpX = 0.;
    }

    if(UpdateButton(mode, e_ScreenW - 240 + 80 + 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
    {
        EditorCursor.WorldLevel.WarpX = 32*(EditorCursor.WorldLevel.WarpX/32 - 1);
        if(EditorCursor.WorldLevel.WarpY == -1)
            EditorCursor.WorldLevel.WarpY = 0.;
    }

    if(UpdateButton(mode, e_ScreenW - 240 + 120 + 4, 360 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
    {
        EditorCursor.WorldLevel.WarpX = 32*(EditorCursor.WorldLevel.WarpX/32 + 1);
        if(EditorCursor.WorldLevel.WarpY == -1)
            EditorCursor.WorldLevel.WarpY = 0.;
    }

    // bottom pane: level filename, entrance and exits
    if(mode == CallMode::Render)
        XRender::renderRect(0, e_ScreenH - 240, e_ScreenW - 240, 240, XTColorF(0.6_n, 0.6_n, 0.8_n), true);

    // level name - LevelName
    SuperPrintR(mode, g_editorStrings.levelName, 3, 10 + 44, e_ScreenH - 240 + 2);
    SuperPrintR(mode, EditorCursor.WorldLevel.LevelName.substr(0, 19), 3, 10 + 44, e_ScreenH - 240 + 20);
    if(EditorCursor.WorldLevel.LevelName.length() > 19)
        SuperPrintR(mode, EditorCursor.WorldLevel.LevelName.substr(19), 3, 10 + 44 + 18, e_ScreenH - 240 + 38);

    if(UpdateButton(mode, 10 + 4, e_ScreenH - 240 + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
    {
        DisableCursorNew();
        EditorCursor.WorldLevel.LevelName = TextEntryScreen::Run(g_editorStrings.levelName, EditorCursor.WorldLevel.LevelName);
        s_fix_mouse_pos();
    }

    // level filename - FileName
    SuperPrintR(mode, g_editorStrings.warpTarget, 3, 10 + 44, e_ScreenH - 180 + 2);
    if(!EditorCursor.WorldLevel.FileName.empty())
        SuperPrintR(mode, EditorCursor.WorldLevel.FileName, 3, 10 + 44, e_ScreenH - 180 + 20);
    else
        SuperPrintR(mode, g_mainMenu.caseNone, 3, 10 + 44, e_ScreenH - 180 + 20);

    if(UpdateButton(mode, 10 + 4, e_ScreenH - 180 + 4, GFX.EIcons, false, 0, 32*Icon::open, 32, 32))
        StartFileBrowser(&EditorCursor.WorldLevel.FileName, FileNamePath, "", {".lvl", ".lvlx"}, BROWSER_MODE_OPEN);

    if(!EditorCursor.WorldLevel.FileName.empty())
    {
        // entrance warp - StartWarp
        if(EditorCursor.WorldLevel.StartWarp > 0 && UpdateButton(mode, 10 + 4, e_ScreenH - 180 + 40 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
            EditorCursor.WorldLevel.StartWarp -= 1;
        if(EditorCursor.WorldLevel.StartWarp < maxWarps && UpdateButton(mode, 280 + 4, e_ScreenH - 180 + 40 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
            EditorCursor.WorldLevel.StartWarp += 1;

        if(EditorCursor.WorldLevel.StartWarp == 0)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.warpTo, g_editorStrings.levelStartPos), 3, 10 + 44, e_ScreenH - 180 + 40 + 12);
        else
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.warpTo, fmt::format_ne(g_editorStrings.phraseWarpIndex, EditorCursor.WorldLevel.StartWarp)), 3, 10 + 44, e_ScreenH - 180 + 40 + 12);

        // exits
        SuperPrintR(mode, g_editorStrings.levelPathUnlocks, 3, 10 + 44, e_ScreenH - 180 + 80 + 2);

        using Controls::PlayerControls::Buttons;

        if(UpdateButton(mode, 10 + 4, e_ScreenH - 180 + 100 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_LEVEL_EXIT;
            m_special_subpage = 1;
        }
        SuperPrintR(mode, GetButtonName_UI(Buttons::Up), 3, 10 + 44, e_ScreenH - 180 + 102);
        SuperPrintR(mode, EditorCustom::list_level_exit_names[EditorCursor.WorldLevel.LevelExit[1]+1], 3, 10 + 44, e_ScreenH - 180 + 120);

        if(UpdateButton(mode, (e_ScreenW - 240)/2 + 10 + 4, e_ScreenH - 180 + 100 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_LEVEL_EXIT;
            m_special_subpage = 3;
        }
        SuperPrintR(mode, GetButtonName_UI(Buttons::Down), 3, (e_ScreenW - 240)/2 + 10 + 44, e_ScreenH - 180 + 102);
        SuperPrintR(mode, EditorCustom::list_level_exit_names[EditorCursor.WorldLevel.LevelExit[3]+1], 3, (e_ScreenW - 240)/2 + 10 + 44, e_ScreenH - 180 + 120);

        if(UpdateButton(mode, 10 + 4, e_ScreenH - 180 + 140 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_LEVEL_EXIT;
            m_special_subpage = 2;
        }
        SuperPrintR(mode, GetButtonName_UI(Buttons::Left), 3, 10 + 44, e_ScreenH - 180 + 142);
        SuperPrintR(mode, EditorCustom::list_level_exit_names[EditorCursor.WorldLevel.LevelExit[2]+1], 3, 10 + 44, e_ScreenH - 180 + 160);

        if(UpdateButton(mode, (e_ScreenW - 240)/2 + 10 + 4, e_ScreenH - 180 + 140 + 4, GFX.EIcons, false, 0, 32*Icon::subscreen, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_LEVEL_EXIT;
            m_special_subpage = 4;
        }
        SuperPrintR(mode, GetButtonName_UI(Buttons::Right), 3, (e_ScreenW - 240)/2 + 10 + 44, e_ScreenH - 180 + 142);
        SuperPrintR(mode, EditorCustom::list_level_exit_names[EditorCursor.WorldLevel.LevelExit[4]+1], 3, (e_ScreenW - 240)/2 + 10 + 44, e_ScreenH - 180 + 160);
    }

}

void EditorScreen::UpdatePath(CallMode mode, int x, int y, int type)
{
    if((type < 1) || (type >= maxPathType))
        return;

    bool sel = EditorCursor.WorldPath.Type == type;
    if(UpdateButton(mode, x, y, GFXPathBMP[type], sel, 0, 0, 32, 32) && !sel)
    {
        // printf("%d\n", type);
        EditorCursor.WorldPath.Type = type;
    }
}

void EditorScreen::UpdatePathGrid(CallMode mode, int x, int y, const int* types, int n_paths, int n_cols)
{
    for(int i = 0; i < n_paths; i ++)
    {
        int type = types[i];
        int row = i / n_cols;
        int col = i % n_cols;
        UpdatePath(mode, x + col * 40 + 4, y + row * 40 + 4, type);
    }
}

void EditorScreen::UpdatePathScreen(CallMode mode)
{
    // Path GUI (none)

    // SuperPrintR(mode, "PATH GRAPHIC", 3, 10, 40);
    static const int paths[] =
    {
        2,  1, 18, 19, 31, 22, 32,
        11, 6, 10, 30, 25, 27, 23,
         9, 5,  7, 21,  3, 20, 26,
        13, 8, 12, 29, 24, 28,  4
    };
    UpdatePathGrid(mode, 0, 60, paths, sizeof(paths)/sizeof(int), 7);
}

void EditorScreen::UpdateFileScreen(CallMode mode)
{
    if(m_special_page == SPECIAL_PAGE_FILE_CONFIRM)
    {
        if(m_special_subpage == 0)
        {
            m_special_page = SPECIAL_PAGE_FILE;
            m_special_subpage = 0;
            return;
        }

        bool can_save;
        std::string* action;
        if(m_special_subpage == 1)
        {
            can_save = true;
            action = &g_editorStrings.fileActionClearLevel;
        }
        else if(m_special_subpage == 11)
        {
            can_save = true;
            action = &g_editorStrings.fileActionClearWorld;
        }
        else if(m_special_subpage == 2 || m_special_subpage == 12)
        {
            can_save = true;
            action = &g_editorStrings.fileActionOpen;
        }
        else if(m_special_subpage == 3 || m_special_subpage == 13)
        {
            can_save = false;
            action = &g_editorStrings.fileActionRevert;
        }
        else if(m_special_subpage == 4)
        {
            can_save = true;
            action = &g_editorStrings.fileActionExit;
        }
        else // should never happen
        {
            return;
        }

        if(can_save)
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.fileConfirmationSaveBeforeAction, *action), 3, 10, 50);
        else
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.fileConfirmationConfirmAction, *action), 3, 10, 50);

        bool confirmed = false;
        if(can_save)
        {
            SuperPrintR(mode, fmt::format_ne(g_editorStrings.fileOptionYesSaveThenAction, *action), 3, 60, 110);
            if(UpdateButton(mode, 20 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
            {
                if(!WorldEditor)
                    SaveLevel(FullFileName, FileFormat);
                else
                    SaveWorld(FullFileName, FileFormat);
                confirmed = true;
            }
        }

        SuperPrintR(mode, fmt::format_ne(g_editorStrings.fileOptionActionWithoutSave, *action), 3, 60, 150);
        if(UpdateButton(mode, 20 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            confirmed = true;
        }

        SuperPrintR(mode, fmt::format_ne(g_editorStrings.fileOptionCancelAction, *action), 3, 60, 190);
        if(UpdateButton(mode, 20 + 4, 180 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_FILE;
            m_special_subpage = 0;
            return;
        }

        if(confirmed)
        {
            if(m_special_subpage == 1) // new level
            {
                int cur_FileFormat = FileFormat;
                if((cur_FileFormat < 0) || (cur_FileFormat > 2))
                    cur_FileFormat = FileFormats::LVL_PGEX;

                if(cur_FileFormat == FileFormats::LVL_SMBX64 || cur_FileFormat == FileFormats::LVL_SMBX38A)
                    StartFileBrowser(&FullFileName, "", FileNamePath, {".lvl"}, BROWSER_MODE_SAVE_NEW, BROWSER_CALLBACK_NEW_LEVEL);
                else
                    StartFileBrowser(&FullFileName, "", FileNamePath, {".lvlx"}, BROWSER_MODE_SAVE_NEW, BROWSER_CALLBACK_NEW_LEVEL);
            }
            else if(m_special_subpage == 2) // open level
            {
                StartFileBrowser(&FullFileName, "", FileNamePath, {".lvlx", ".lvl"}, BROWSER_MODE_OPEN, BROWSER_CALLBACK_OPEN_LEVEL);
            }
            else if(m_special_subpage == 3) // revert level
            {
                OpenLevel(FullFileName);
                m_special_page = SPECIAL_PAGE_FILE;
                m_special_subpage = 0;
            }
            else if(m_special_subpage == 11) // new world
            {
                int cur_FileFormat = FileFormat;
                if((cur_FileFormat < 0) || (cur_FileFormat > 2))
                    cur_FileFormat = FileFormats::LVL_PGEX;

                if(cur_FileFormat == FileFormats::LVL_SMBX64 || cur_FileFormat == FileFormats::LVL_SMBX38A)
                    StartFileBrowser(&FullFileName, "", FileNamePath, {".wld"}, BROWSER_MODE_SAVE_NEW, BROWSER_CALLBACK_NEW_WORLD);
                else
                    StartFileBrowser(&FullFileName, "", FileNamePath, {".wldx"}, BROWSER_MODE_SAVE_NEW, BROWSER_CALLBACK_NEW_WORLD);
            }
            else if(m_special_subpage == 12) // open world
            {
                StartFileBrowser(&FullFileName, "", FileNamePath, {".wldx", ".wld"}, BROWSER_MODE_OPEN, BROWSER_CALLBACK_OPEN_WORLD);
            }
            else if(m_special_subpage == 13) // revert world
            {
                OpenWorld(FullFileName);
                m_special_page = SPECIAL_PAGE_FILE;
                m_special_subpage = 0;
            }
            else if(m_special_subpage == 4) // exit
            {
                if(g_config.EnableInterLevelFade)
                {
                    g_levelScreenFader.setupFader(4, 0, 65, ScreenFader::S_FADE);
                    g_worldScreenFader.setupFader(4, 0, 65, ScreenFader::S_FADE);
                }
                else
                {
                    g_levelScreenFader.setupFader(65, 0, 65, ScreenFader::S_FADE);
                    g_worldScreenFader.setupFader(65, 0, 65, ScreenFader::S_FADE);
                }
                editorWaitForFade();

                ClearLevel();
                ClearWorld();
                GameMenu = true;
                MenuMode = 0;
                MenuCursor = 0;
                LevelEditor = false;
                WorldEditor = false;
                TestLevel = false;
                m_special_page = SPECIAL_PAGE_NONE;
                m_special_subpage = 0;
                testStartWarp = 0;
            }
        }
        return;
    }

    if(m_special_page == SPECIAL_PAGE_FILE_CONVERT)
    {
        // TODO: find a way to warn them if this would overwrite something

        const std::string* format = (m_special_subpage == FileFormats::LVL_PGEX) ? &g_editorStrings.fileFormatModern : &g_editorStrings.fileFormatLegacy;

        SuperPrintR(mode, fmt::format_ne(g_editorStrings.fileConfirmationConvertFormatTo, *format), 3, 10, 50);

        if(mode == CallMode::Render)
        {
            FontManager::printTextOptiPx(g_editorStrings.fileConvertDesc,
                                         20, 90,
                                         606,
                                         FontManager::fontIdFromSmbxFont(4));
        }

        SuperPrintR(mode, g_editorStrings.fileOptionProceedWithConversion, 3, 60, 390);
        if(UpdateButton(mode, 20 + 4, 380 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            FileFormat = m_special_subpage;
            if(FileFormat == FileFormats::LVL_SMBX64 || FileFormat == FileFormats::LVL_SMBX38A)
            {
                if(!FileNameFull.empty() && FileNameFull.back() == 'x')
                    FileNameFull.resize(FileNameFull.size() - 1);
                if(!FullFileName.empty() && FullFileName.back() == 'x')
                    FullFileName.resize(FullFileName.size() - 1);
            }
            else
            {
                if(!FileNameFull.empty() && FileNameFull.back() != 'x')
                    FileNameFull += "x";
                if(!FullFileName.empty() && FullFileName.back() != 'x')
                    FullFileName += "x";
            }

            if(WorldEditor)
            {
                // ConvertWorld(m_special_subpage);
                SaveWorld(FullFileName, FileFormat);
                OpenWorld(FullFileName);
            }
            else
            {
                // ConvertLevel(m_special_subpage);
                SaveLevel(FullFileName, FileFormat);
                OpenLevel(FullFileName);
            }

            Integrator::setEditorFile(FileName);

            m_special_page = SPECIAL_PAGE_FILE;
            m_special_subpage = 0;
        }

        SuperPrintR(mode, g_editorStrings.fileOptionCancelConversion, 3, 60, 430);
        if(UpdateButton(mode, 20 + 4, 420 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_FILE;
            m_special_subpage = 0;
        }

        return;
    }

    SuperPrintR(mode, g_editorStrings.fileLabelCurrentFile + FileNameFull, 3, 10, 50);

    if(selWorld == 0)
    {
        SuperPrintR(mode, g_editorStrings.fileLabelFormat, 3, 150, 90);

        if(UpdateButton(mode, 320 + 4, 80 + 4, GFXNPC[NPCID_POWER_S3], FileFormat == FileFormats::LVL_SMBX64, 0, 0, 32, 32, g_editorStrings.fileFormatLegacy.c_str()) && FileFormat != FileFormats::LVL_SMBX64)
        {
            m_special_page = SPECIAL_PAGE_FILE_CONVERT;
            m_special_subpage = FileFormats::LVL_SMBX64;
        }

        if(UpdateButton(mode, 360 + 4, 80 + 4, GFX.EIcons, FileFormat == FileFormats::LVL_PGEX, 0, 32*Icon::thextech, 32, 32, g_editorStrings.fileFormatModern.c_str()) && FileFormat != FileFormats::LVL_PGEX)
        {
            m_special_page = SPECIAL_PAGE_FILE_CONVERT;
            m_special_subpage = FileFormats::LVL_PGEX;
        }
    }

    SuperPrintR(mode, g_editorStrings.fileSectionLevel, 3, 110, 140);

    SuperPrintR(mode, g_editorStrings.fileCommandNew, 3, 54, 170);
    if(UpdateButton(mode, 10 + 4, 160 + 4, GFX.EIcons, false, 0, 32*Icon::newf, 32, 32))
    {
        m_special_page = SPECIAL_PAGE_FILE_CONFIRM;
        m_special_subpage = 1;
    }

    SuperPrintR(mode, g_editorStrings.fileCommandOpen, 3, 54, 210);
    if(UpdateButton(mode, 10 + 4, 200 + 4, GFX.EIcons, false, 0, 32*Icon::open, 32, 32))
    {
        m_special_page = SPECIAL_PAGE_FILE_CONFIRM;
        m_special_subpage = 2;
    }

    if(!WorldEditor)
    {
        SuperPrintR(mode, g_editorStrings.fileCommandSave, 3, 54, 250);
        if(UpdateButton(mode, 10 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::save, 32, 32))
        {
            SaveLevel(FullFileName, FileFormat);
        }

        SuperPrintR(mode, g_editorStrings.fileCommandSaveAs, 3, 54, 290);
        if(UpdateButton(mode, 10 + 4, 280 + 4, GFX.EIcons, false, 0, 32*Icon::save, 32, 32))
        {
            if(FileFormat == 1 || FileFormat == 2)
                StartFileBrowser(&FullFileName, "", FileNamePath, {".lvl"}, BROWSER_MODE_SAVE, BROWSER_CALLBACK_SAVE_LEVEL);
            else
                StartFileBrowser(&FullFileName, "", FileNamePath, {".lvlx"}, BROWSER_MODE_SAVE, BROWSER_CALLBACK_SAVE_LEVEL);
        }

        SuperPrintR(mode, g_editorStrings.fileActionRevert, 3, 54, 330);
        if(UpdateButton(mode, 10 + 4, 320 + 4, GFX.EIcons, false, 0, 32*Icon::hop, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_FILE_CONFIRM;
            m_special_subpage = 3;
        }
    }

    SuperPrintR(mode, g_editorStrings.fileSectionWorld, 3, e_ScreenW/2 + 110, 140);

    SuperPrintR(mode, g_editorStrings.fileCommandNew, 3, e_ScreenW/2 + 54, 170);
    if(UpdateButton(mode, e_ScreenW/2 + 10 + 4, 160 + 4, GFX.EIcons, false, 0, 32*Icon::newf, 32, 32))
    {
        m_special_page = SPECIAL_PAGE_FILE_CONFIRM;
        m_special_subpage = 11;
    }

    SuperPrintR(mode, g_editorStrings.fileCommandOpen, 3, e_ScreenW/2 + 54, 210);
    if(UpdateButton(mode, e_ScreenW/2 + 10 + 4, 200 + 4, GFX.EIcons, false, 0, 32*Icon::open, 32, 32))
    {
        m_special_page = SPECIAL_PAGE_FILE_CONFIRM;
        m_special_subpage = 12;
    }

    if(WorldEditor)
    {
        SuperPrintR(mode, g_editorStrings.fileCommandSave, 3, e_ScreenW/2 + 54, 250);
        if(UpdateButton(mode, e_ScreenW/2 + 10 + 4, 240 + 4, GFX.EIcons, false, 0, 32*Icon::save, 32, 32))
        {
            SaveWorld(FullFileName, FileFormat);
        }

        SuperPrintR(mode, g_editorStrings.fileCommandSaveAs, 3, e_ScreenW/2 + 54, 290);
        if(UpdateButton(mode, e_ScreenW/2 + 10 + 4, 280 + 4, GFX.EIcons, false, 0, 32*Icon::save, 32, 32))
        {
            if(FileFormat == 1 || FileFormat == 2)
                StartFileBrowser(&FullFileName, "", FileNamePath, {".wld"}, BROWSER_MODE_SAVE, BROWSER_CALLBACK_SAVE_WORLD);
            else
                StartFileBrowser(&FullFileName, "", FileNamePath, {".wldx"}, BROWSER_MODE_SAVE, BROWSER_CALLBACK_SAVE_WORLD);
        }

        SuperPrintR(mode, g_editorStrings.fileActionRevert, 3, e_ScreenW/2 + 54, 330);
        if(UpdateButton(mode, e_ScreenW/2 + 10 + 4, 320 + 4, GFX.EIcons, false, 0, 32*Icon::hop, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_FILE_CONFIRM;
            m_special_subpage = 13;
        }
    }

    SuperPrintR(mode, g_editorStrings.fileActionExit, 3, 54, 410);
    if(UpdateButton(mode, 10 + 4, 400 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
    {
        m_special_page = SPECIAL_PAGE_FILE_CONFIRM;
        m_special_subpage = 4;
    }
}

void EditorScreen::StartFileBrowser(std::string* file_target,
                                    const std::string &root_path,
                                    const std::string &current_path,
                                    const std::vector<std::string> &target_exts,
                                    BrowserMode_t browser_mode,
                                    BrowserCallback_t browser_callback)
{
    m_file_target = file_target;
    m_root_path = root_path;
    m_target_exts = target_exts;
    m_browser_mode = browser_mode;
    m_browser_callback = browser_callback;
    m_cur_path = current_path;
    m_path_synced = false;
    m_last_special_page = m_special_page;
    m_special_page = SPECIAL_PAGE_BROWSER;
    m_special_subpage = 0;
}

void EditorScreen::FileBrowserSuccess()
{
    if(m_file_target)
        *m_file_target = m_cur_file;

    if(m_browser_callback == BROWSER_CALLBACK_OPEN_LEVEL)
    {
        EnsureLevel();
        OpenLevel(FullFileName);
        ResetCursor();
        Integrator::setEditorFile(FileName);
    }
    else if(m_browser_callback == BROWSER_CALLBACK_SAVE_LEVEL)
    {
        SaveLevel(FullFileName, FileFormat);
        // this will resync custom assets
        OpenLevel(FullFileName);
        Integrator::setEditorFile(FileName);
    }
    else if(m_browser_callback == BROWSER_CALLBACK_NEW_LEVEL)
    {
        int cur_FileFormat = FileFormat;
        if((cur_FileFormat < 0) || (cur_FileFormat > 2))
            cur_FileFormat = FileFormats::LVL_PGEX;
        EnsureLevel();
        ClearLevel();
        SaveLevel(FullFileName, cur_FileFormat);
        // this will resync custom assets
        OpenLevel(FullFileName);
        ResetCursor();
        Integrator::setEditorFile(FileName);
    }
    else if(m_browser_callback == BROWSER_CALLBACK_OPEN_WORLD)
    {
        EnsureWorld();
        OpenWorld(FullFileName);
        ResetCursor();
        Integrator::setEditorFile(FileName);
    }
    else if(m_browser_callback == BROWSER_CALLBACK_SAVE_WORLD)
    {
        SaveWorld(FullFileName, FileFormat);
        // resync custom assets
        OpenWorld(FullFileName);
        Integrator::setEditorFile(FileName);
    }
    else if(m_browser_callback == BROWSER_CALLBACK_NEW_WORLD)
    {
        int cur_FileFormat = FileFormat;
        if((cur_FileFormat < 0) || (cur_FileFormat > 2))
            cur_FileFormat = FileFormats::LVL_PGEX;
        EnsureWorld();
        ClearWorld();
        SaveWorld(FullFileName, cur_FileFormat);
        // resync custom assets
        OpenWorld(FullFileName);
        ResetCursor();
        Integrator::setEditorFile(FileName);
    }
    else if(m_browser_callback == BROWSER_CALLBACK_CUSTOM_MUSIC)
    {
        StartMusic(curSection);
    }

    FileBrowserCleanup();
}

void EditorScreen::FileBrowserFailure()
{
    // if(m_file_target && m_file_target != &FullFileName) m_file_target->clear();
    FileBrowserCleanup();
}

void EditorScreen::FileBrowserCleanup()
{
    m_cur_file.clear();
    m_file_target = nullptr;
    m_special_page = m_last_special_page;
    m_last_special_page = SPECIAL_PAGE_NONE;
    m_special_subpage = 0;
    m_browser_mode = BROWSER_MODE_NONE;
    m_browser_callback = BROWSER_CALLBACK_NONE;
}

void EditorScreen::SyncPath()
{
    if(m_path_synced) return;
    m_dirman.setPath(m_root_path+m_cur_path);
    m_dirman.getListOfFiles(m_cur_path_files, m_target_exts);
    m_dirman.getListOfFolders(m_cur_path_dirs);
    tinysort(m_cur_path_files.begin(), m_cur_path_files.end());
    tinysort(m_cur_path_dirs.begin(), m_cur_path_dirs.end());
    m_path_synced = true;
}

void EditorScreen::GoToSuper()
{
    if(m_cur_path.empty())
    {
        m_cur_path += "../";
    }
    else
    {
        size_t last_slash = m_cur_path.rfind('/', m_cur_path.length()-2);
        size_t last_chunk_start;
        if(last_slash == std::string::npos)
            last_chunk_start = 0;
        else
            last_chunk_start = last_slash + 1;
        if(m_cur_path.substr(last_chunk_start) == "../")
            m_cur_path += "../";
        else
            m_cur_path = m_cur_path.substr(0, last_chunk_start);
    }
    m_path_synced = false;
}

void EditorScreen::ValidateExt(std::string& cur_file)
{
    if(m_target_exts.empty()) return;

    for(const std::string& ext : m_target_exts)
    {
        if(Files::hasSuffix(cur_file, ext))
            return;
    }

    cur_file += m_target_exts[0];
}

bool EditorScreen::FileExists(const std::string& cur_file)
{
    return (std::find(m_cur_path_files.begin(), m_cur_path_files.end(), cur_file) != m_cur_path_files.end());
}

void EditorScreen::UpdateBrowserScreen(CallMode mode)
{
    constexpr bool IGNORE_DIRS = true;
    // render shared GUI elements on right
    if(UpdateButton(mode, e_ScreenW - 40 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::x, 32, 32))
    {
        FileBrowserFailure();
        return;
    }

    if(m_special_page == SPECIAL_PAGE_BROWSER_CONFIRM)
    {
        SuperPrintR(mode, g_editorStrings.phraseAreYouSure, 3, 60, 40);
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.browserAskOverwriteFile, m_cur_file), 3, 10, 60);

        SuperPrintR(mode, g_mainMenu.wordYes, 3, 60, 110);
        if(UpdateButton(mode, 10 + 4, 100 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            FileBrowserSuccess();
            return;
        }

        SuperPrintR(mode, g_mainMenu.wordNo, 3, 60, 150);
        if(UpdateButton(mode, 10 + 4, 140 + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
        {
            m_special_page = SPECIAL_PAGE_BROWSER;
            m_cur_file.clear();
        }

        return;
    }

    if(!m_path_synced)
        SyncPath();

    int dir_length = m_cur_path_dirs.size() + 1; // ".."
    int file_length = m_cur_path_files.size();

    if(m_browser_mode == BROWSER_MODE_SAVE || m_browser_mode == BROWSER_MODE_SAVE_NEW)
    {
        if(m_browser_mode == BROWSER_MODE_SAVE_NEW)
            SuperPrintR(mode, g_editorStrings.browserNewFile, 3, 60, 40);
        else
            SuperPrintR(mode, g_editorStrings.browserSaveFile, 3, 60, 40);

        dir_length ++; // "new", last folder
        file_length ++; // "new", first file
    }
    else
    {
        SuperPrintR(mode, g_editorStrings.browserOpenFile, 3, 60, 40);
    }

    // ignore directories
    if(IGNORE_DIRS)
        dir_length = 0;

    int page_max = (dir_length + file_length - 1) / 20;
    if(!(page_max == 0 && m_special_subpage == 0))
        SuperPrintR(mode, fmt::format_ne(g_editorStrings.pageBlankOfBlank, m_special_subpage + 1, page_max + 1), 3, e_ScreenW - 320, 40);

    if(m_special_subpage > 0 && UpdateButton(mode, e_ScreenW - 120 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::left, 32, 32))
        m_special_subpage --;

    if(m_special_subpage < page_max && UpdateButton(mode, e_ScreenW - 80 + 4, 40 + 4, GFX.EIcons, false, 0, 32*Icon::right, 32, 32))
        m_special_subpage ++;

    if(!m_cur_path.empty())
    {
        const int avail_chars = (e_ScreenW-140)/18;
        if(m_cur_path.size() > avail_chars)
            SuperPrintR(mode, g_editorStrings.npcInContainer + " ..." + m_cur_path.substr(m_cur_path.size() - avail_chars), 3, 10, 60);
        else
            SuperPrintR(mode, g_editorStrings.npcInContainer + " " + m_cur_path, 3, 10, 60);
    }

    // render file selector
    for(int i = 0; i < 20; i++)
    {
        int x = 10 + (e_ScreenW/2)*(i/10);
        int y = 80 + 40*(i%10);

        int l = m_special_subpage*20 + i;
        if(!IGNORE_DIRS && l == 0)
        {
            SuperPrintR(mode, "..", 3, x + 44, y + 12);
            if(UpdateButton(mode, x + 4, y + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
            {
                GoToSuper();
                m_special_subpage = 0;
            }
        }
        else if((m_browser_mode == BROWSER_MODE_SAVE || m_browser_mode == BROWSER_MODE_SAVE_NEW) && l == dir_length - 1)
        {
            SuperPrintR(mode, g_editorStrings.browserItemNewFolder, 3, x + 44, y + 12);
            if(UpdateButton(mode, x + 4, y + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
            {
                DisableCursorNew();
                std::string folder_name = TextEntryScreen::Run(g_editorStrings.browserItemNewFolder, "");
                s_fix_mouse_pos();

                if(!folder_name.empty() && !m_dirman.exists(folder_name))
                {
                    m_dirman.mkdir(folder_name);
                    m_path_synced = false;
                }
            }
        }
        else if(l < dir_length)
        {
            l -= 1;
            if(m_cur_path_dirs[l].length() < 15)
                SuperPrintR(mode, m_cur_path_dirs[l], 3, x + 44, y + 10);
            else
            {
                SuperPrintR(mode, m_cur_path_dirs[l].substr(0, 14), 3, x + 44, y + 2);
                SuperPrintR(mode, m_cur_path_dirs[l].substr(14, 14), 3, x + 44, y + 20);
            }

            if(UpdateButton(mode, x + 4, y + 4, GFX.EIcons, false, 0, 32*Icon::action, 32, 32))
            {
                m_cur_path += m_cur_path_dirs[l] + "/";
                m_path_synced = false;
                m_special_subpage = 0;
            }
        }
        else if((m_browser_mode == BROWSER_MODE_SAVE || m_browser_mode == BROWSER_MODE_SAVE_NEW) && l == dir_length)
        {
            SuperPrintR(mode, g_editorStrings.browserItemNewFile, 3, x + 44, y + 12);
            if(UpdateButton(mode, x + 4, y + 4, GFX.EIcons, false, 0, 32*Icon::pencil, 32, 32))
            {
                DisableCursorNew();
                std::string file_name = TextEntryScreen::Run(g_editorStrings.fileCommandSaveAs, "");
                s_fix_mouse_pos();

                if(!file_name.empty())
                {
                    // validate: append the file extension if it doesn't already appear.
                    ValidateExt(file_name);
                    m_cur_file = m_cur_path + file_name;

                    if(FileExists(file_name))
                        m_special_page = SPECIAL_PAGE_BROWSER_CONFIRM;
                    else
                    {
                        FileBrowserSuccess();
                        return;
                    }
                }
            }
        }
        else if(l < dir_length + file_length)
        {
            if(m_browser_mode == BROWSER_MODE_SAVE || m_browser_mode == BROWSER_MODE_SAVE_NEW)
                l -= dir_length + 1;
            else
                l -= dir_length;

            if(m_cur_path_files[l].length() < 15)
                SuperPrintR(mode, m_cur_path_files[l], 3, x + 44, y + 10);
            else
            {
                SuperPrintR(mode, m_cur_path_files[l].substr(0, 14), 3, x + 44, y + 2);
                SuperPrintR(mode, m_cur_path_files[l].substr(14, 14), 3, x + 44, y + 20);
            }

            if(UpdateButton(mode, x + 4, y + 4, GFX.ECursor[2], false, 0, 0, 32, 32))
            {
                m_cur_file = m_cur_path + m_cur_path_files[l];
                if(m_browser_mode == BROWSER_MODE_OPEN)
                {
                    FileBrowserSuccess();
                    return;
                }
                else
                {
                    // overwrite confirmation
                    m_special_page = SPECIAL_PAGE_BROWSER_CONFIRM;
                }
            }
        }
    }
}

inline void swap_screens()
{
#ifdef __3DS__
    int win_x, win_y;
    XRender::mapFromScreen((int)SharedCursor.X, (int)SharedCursor.Y, &win_x, &win_y);
#endif

    editorScreen.active = !editorScreen.active;

#ifdef __3DS__
    int m_x, m_y;
    XRender::mapToScreen(win_x, win_y, &m_x, &m_y);
    SharedCursor.X = m_x;
    SharedCursor.Y = m_y;
    MouseMove(m_x, m_y);
#endif

    HasCursor = false;
    MouseRelease = false;
    MenuMouseRelease = false;
    PlaySound(SFX_Pause);
}

void EditorScreen::UpdateSelectorBar(CallMode mode, bool select_bar_only)
{
    // can be drawn either over level screen or at top of editor screen

    // find the selector bar location
    int sx;
    if(select_bar_only)
    {
        e_CursorX = EditorCursor.X;
        e_CursorY = EditorCursor.Y;
        // if(WorldEditor)
        //     e_CursorY += 8;
        sx = (XRender::TargetW - e_ScreenW)/2;
    }
    else
        sx = 0;

    if(mode == CallMode::Render)
    {
        uint8_t alpha = 255;
        if(select_bar_only && MagicHand)
            alpha = XTColor::from_num(0.7_n);

        for(int i = 0; i < 5; i++)
        {
            uint8_t r = 153 + 13 * i;
            uint8_t g = 127 + 19 * i;
            XRender::renderRect(sx+0, 38-2*i, e_ScreenW, 2, {r, g, 204, alpha}, true);
        }

        XRender::renderRect(sx+0, 0, e_ScreenW, 30, {204, 204, 204, alpha}, true);
    }

    bool in_layers = (m_special_page == SPECIAL_PAGE_LAYERS || m_special_page == SPECIAL_PAGE_LAYER_DELETION);
    bool in_events = (m_special_page == SPECIAL_PAGE_EVENTS || m_special_page == SPECIAL_PAGE_EVENT_LAYERS
        || m_special_page == SPECIAL_PAGE_EVENT_TRIGGER || m_special_page == SPECIAL_PAGE_EVENT_SETTINGS
        || m_special_page == SPECIAL_PAGE_EVENT_DELETION
        || m_special_page == SPECIAL_PAGE_EVENT_MUSIC || m_special_page == SPECIAL_PAGE_EVENT_BACKGROUND
        || m_special_page == SPECIAL_PAGE_EVENT_CONTROLS || m_special_page == SPECIAL_PAGE_EVENT_SOUND);
    bool in_file = (m_special_page == SPECIAL_PAGE_FILE || m_special_page == SPECIAL_PAGE_FILE_CONFIRM
        || m_special_page == SPECIAL_PAGE_FILE_CONVERT);
    bool in_section_settings = (m_special_page == SPECIAL_PAGE_SECTION_SETTINGS
        || m_special_page == SPECIAL_PAGE_SECTION_MUSIC
        || m_special_page == SPECIAL_PAGE_SECTION_BACKGROUND);
    bool in_world_settings = (m_special_page == SPECIAL_PAGE_WORLD_SETTINGS);
    bool in_leveltest_settings = (m_special_page == SPECIAL_PAGE_EDITOR_SETTINGS || m_special_page == SPECIAL_PAGE_LEVELTEST_HELDNPC || m_special_page == SPECIAL_PAGE_MAGICBLOCK);
    bool in_excl_special = in_layers || in_events || in_section_settings || in_world_settings || in_leveltest_settings || in_file;
    bool exit_special = false;

    bool currently_in;

    // select
    currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::LVL_SELECT;
    if(UpdateButton(mode, sx+0*40+4, 4, GFX.ECursor[2], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipSelect.c_str()))
    {
        if(editorScreen.active)
            swap_screens();
        EditorCursor.Mode = OptCursor_t::LVL_SELECT;
        if(in_excl_special)
            exit_special = true;
    }

    // erase
    currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::LVL_ERASER;
    if(UpdateButton(mode, sx+1*40+4, 4, GFX.ECursor[3], currently_in && EditorCursor.SubMode != -1, 0, 0, 22, 30, g_editorStrings.tooltipErase.c_str()))
    {
        if(editorScreen.active)
            swap_screens();
        EditorCursor.Mode = OptCursor_t::LVL_ERASER;
        EditorCursor.SubMode = 0;
        if(in_excl_special)
            exit_special = true;
    }

    if(currently_in && UpdateButton(mode, sx+2*40+4, 4, GFXNPC[NPCID_AXE], currently_in && EditorCursor.SubMode == -1, 0, 0, 32, 32, g_editorStrings.tooltipEraseAll.c_str()))
    {
        if(editorScreen.active)
            swap_screens();
        EditorCursor.Mode = OptCursor_t::LVL_ERASER;
        EditorCursor.SubMode = -1;
        if(in_excl_special)
            exit_special = true;
    }

    // level editor tabs
    if(!WorldEditor)
    {
        // blocks
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::LVL_BLOCKS;
        if(UpdateButton(mode, sx+3*40+4, 4, GFXBlock[1], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipBlocks.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_BLOCKS;
            if(in_excl_special)
                exit_special = true;
        }

        // BGOs
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::LVL_BGOS;
        if(UpdateButton(mode, sx+4*40+4, 4, GFXBackgroundBMP[1], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipBGOs.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_BGOS;
            if(in_excl_special)
                exit_special = true;
        }

        // NPCs
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::LVL_NPCS;
        if(UpdateButton(mode, sx+5*40+4, 4, GFXNPC[1], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipNPCs.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_NPCS;
            if(in_excl_special)
                exit_special = true;
        }

        // water
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::LVL_WATER;
        if(!MagicHand && UpdateButton(mode, sx+6*40+4, 4, GFXBackgroundBMP[26], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipWater.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_WATER;
            if(in_excl_special)
                exit_special = true;
        }

        // warps
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::LVL_WARPS;
        if(!MagicHand && UpdateButton(mode, sx+7*40+4, 4, GFXBlock[294], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipWarps.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_WARPS;
            if(in_excl_special)
                exit_special = true;
        }

        // level settings
        currently_in = (in_section_settings || EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART);
        if(!MagicHand && UpdateButton(mode, sx+9*40+4, 4, GFXBlock[60], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipSettings.c_str()))
        {
            if(currently_in || !editorScreen.active)
                swap_screens();

            if(!currently_in)
            {
                EditorCursor.Mode = OptCursor_t::LVL_SELECT;
                m_last_mode = OptCursor_t::LVL_SELECT;
            }

            if(!in_section_settings)
                m_special_page = SPECIAL_PAGE_SECTION_SETTINGS;
        }

        // layers
        if(!MagicHand && UpdateButton(mode, sx+10*40+4, 4, GFXBlock[447], in_layers, 0, 0, 32, 32, g_editorStrings.tooltipLayers.c_str()))
        {
            if(in_layers || !editorScreen.active)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_SELECT;
            m_last_mode = OptCursor_t::LVL_SELECT;
            if(!in_layers)
                m_special_page = SPECIAL_PAGE_LAYERS;
        }

        // events
        if(!MagicHand && UpdateButton(mode, sx+11*40+4, 4, GFXBlock[169], in_events, 0, 0, 32, 32, g_editorStrings.tooltipEvents.c_str()))
        {
            if(in_events || !editorScreen.active)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_SELECT;
            m_last_mode = OptCursor_t::LVL_SELECT;
            if(!in_events)
                m_special_page = SPECIAL_PAGE_EVENTS;
        }
    }

    // world editor tabs
    if(WorldEditor)
    {
        // tiles
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::WLD_TILES;
        if(UpdateButton(mode, sx+3*40+4, 4, GFXTileBMP[1], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipTiles.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::WLD_TILES;
            if(in_excl_special)
                exit_special = true;
        }

        // scenes
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::WLD_SCENES;
        if(UpdateButton(mode, sx+4*40+4, 4, GFXSceneBMP[1], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipScenes.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::WLD_SCENES;
            if(in_excl_special)
                exit_special = true;
        }

        // levels
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::WLD_LEVELS;
        if(UpdateButton(mode, sx+5*40+4, 4, GFXLevelBMP[2], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipLevels.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::WLD_LEVELS;
            if(in_excl_special)
                exit_special = true;
        }

        // paths
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::WLD_PATHS;
        if(UpdateButton(mode, sx+6*40+4, 4, GFXPathBMP[4], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipPaths.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::WLD_PATHS;
            if(in_excl_special)
                exit_special = true;
        }

        // world music
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::WLD_MUSIC;
        if(UpdateButton(mode, sx+7*40+4, 4, GFX.EIcons, currently_in, 0, 32*Icon::music, 32, 32, g_editorStrings.tooltipMusic.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::WLD_MUSIC;
            if(in_excl_special)
                exit_special = true;
        }

        // world area
        currently_in = !in_excl_special && EditorCursor.Mode == OptCursor_t::WLD_AREA;
        if(FileFormat == FileFormats::LVL_PGEX && UpdateButton(mode, sx+8*40+4, 4, GFXBlock[60], currently_in, 0, 0, 32, 32, g_editorStrings.tooltipArea.c_str()))
        {
            if(currently_in)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::WLD_AREA;
            if(in_excl_special)
                exit_special = true;
        }

        // world settings
        if(UpdateButton(mode, sx+9*40+4, 4, GFXLevelBMP[15], in_world_settings, 0, 0, 32, 32, g_editorStrings.tooltipSettings.c_str()))
        {
            if(in_world_settings || !editorScreen.active)
                swap_screens();
            EditorCursor.Mode = OptCursor_t::LVL_SELECT;
            m_last_mode = OptCursor_t::LVL_SELECT;
            if(!in_world_settings)
                m_special_page = SPECIAL_PAGE_WORLD_SETTINGS;
        }
    }

    // file
    if(!MagicHand && UpdateButton(mode, sx+13*40+4, 4, GFX.EIcons, in_file, 0, 32*Icon::page, 32, 32, g_editorStrings.tooltipFile.c_str()))
    {
        if(in_file || !editorScreen.active)
            swap_screens();
        EditorCursor.Mode = OptCursor_t::LVL_SELECT;
        m_last_mode = OptCursor_t::LVL_SELECT;
        if(!in_file)
            m_special_page = SPECIAL_PAGE_FILE;
    }

    // test play settings
    if(!WorldEditor && UpdateButton(mode, sx+14*40 + 4, 4, GFX.EIcons, in_leveltest_settings, 0, 32*Icon::play, 32, 32, g_editorStrings.tooltipSettings.c_str()))
    {
        if(in_leveltest_settings || !editorScreen.active)
            swap_screens();
        EditorCursor.Mode = OptCursor_t::LVL_SELECT;
        m_last_mode = OptCursor_t::LVL_SELECT;
        if(!in_leveltest_settings)
            m_special_page = SPECIAL_PAGE_EDITOR_SETTINGS;
    }

    // swap screens
    int switch_screens_icon = 0;
    const char* switch_screens_tooltip;
    if(select_bar_only)
    {
        switch_screens_icon = Icon::down;
        switch_screens_tooltip = g_editorStrings.tooltipShow.c_str();
    }
    else
    {
        switch_screens_icon = Icon::up;
        switch_screens_tooltip = nullptr;
    }

    if(UpdateButton(mode, sx+15*40 + 4, 4, GFX.EIcons, false, 0, 32*switch_screens_icon, 32, 32, switch_screens_tooltip))
        swap_screens();

    // if mode has been updated for any reason, close any special dialogue boxes
    // and sync everything up
    if(exit_special || EditorCursor.Mode != m_last_mode)
    {
        if(m_browser_mode != BROWSER_MODE_NONE)
            FileBrowserCleanup();
        m_special_page = SPECIAL_PAGE_NONE;
        m_special_subpage = 0;
        m_last_mode = EditorCursor.Mode;
    }

    if(select_bar_only && mode == CallMode::Render && e_CursorY < 40 && e_CursorX >= sx && e_CursorX < sx+e_ScreenW)
    {
        int X = e_CursorX;
        int Y = e_CursorY;
#if 0
        if(g_config.editor_edge_scroll && !MagicHand)
        {
            if(X < 36)
                X = 36;
            if(Y < 36)
                Y = 36;
            if(X >= XRender::TargetW - 36)
                X = XRender::TargetW - 36;
            if(Y >= XRender::TargetH - 36)
                Y = XRender::TargetH - 36;
        }
#endif

#ifdef __3DS__
        if(select_bar_only)
            XRender::renderTextureBasic(X, Y, GFX.ECursor[2]);
#else
        XRender::renderTextureBasic(X, Y, GFX.ECursor[2]);
#endif

        if(e_tooltip)
        {
            if(e_CursorX + 28 < sx + e_ScreenW / 2)
                SuperPrint(e_tooltip, 3, e_CursorX + 28, e_CursorY + 34, XTColorF(1.0_n, 0.7_n, 0.7_n));
            else
                SuperPrintRightAlign(e_tooltip, 3, e_CursorX + 10, e_CursorY + 34, XTColorF(1.0_n, 0.7_n, 0.7_n));
        }
    }
}

void EditorScreen::UpdateEditorScreen(CallMode mode, bool second_screen)
{
    // second screen is like the upper screen of the 3DS or the TV of the Wii U -- any screen without a direct pointing device
    if(second_screen && mode == CallMode::Logic)
        return;

    if(MagicHand && !LevelEditor)
        m_special_page = SPECIAL_PAGE_NONE;

    if(mode == CallMode::Logic)
    {
        if(GamePaused != PauseCode::None)
            return;

        MenuMouseRelease = MouseRelease && !MenuMouseRelease && !SharedCursor.Primary;
    }

    e_tooltip = nullptr;

    bool select_bar_only = ((active && second_screen) || (!active && !second_screen));

    if(select_bar_only)
    {
        XRender::resetViewport();
        UpdateSelectorBar(mode, true);

        if(mode == CallMode::Logic)
            MenuMouseRelease = !SharedCursor.Primary;

        return;
    }

    MessageText.clear();

#ifdef __3DS__
    if(mode == CallMode::Render && active)
        XRender::setTargetSubScreen();
    else if(mode == CallMode::Render)
    {
        XRender::setTargetMainScreen();
        XRender::setViewport(800/2 - e_ScreenW/2, 0, e_ScreenW, e_ScreenH);
    }
#else
    if(mode == CallMode::Render)
        XRender::setViewport(XRender::TargetW/2-e_ScreenW/2, 0, e_ScreenW, e_ScreenH);
#endif

    e_CursorX = EditorCursor.X;
    e_CursorY = EditorCursor.Y;

#ifdef __3DS__
    if(!editorScreen.active)
        e_CursorX -= XRender::TargetW/2-e_ScreenW/2;
#else
    e_CursorX -= XRender::TargetW/2-e_ScreenW/2;
#endif

    // if(WorldEditor)
    //     e_CursorY += 8;

    if(mode == CallMode::Render)
        XRender::renderRect(0, 0, e_ScreenW, e_ScreenH, XTColorF(0.4_n, 0.4_n, 0.8_n, 0.75_n), true);

    UpdateSelectorBar(mode, false);

    if(m_special_page == SPECIAL_PAGE_BROWSER || m_special_page == SPECIAL_PAGE_BROWSER_CONFIRM)
        UpdateBrowserScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_FILE || m_special_page == SPECIAL_PAGE_FILE_CONFIRM
        || m_special_page == SPECIAL_PAGE_FILE_CONVERT)
        UpdateFileScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_LAYERS || m_special_page == SPECIAL_PAGE_LAYER_DELETION
        || m_special_page == SPECIAL_PAGE_OBJ_LAYER || m_special_page == SPECIAL_PAGE_EVENT_LAYERS)
        UpdateLayersScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_EVENTS || m_special_page == SPECIAL_PAGE_EVENT_DELETION)
        UpdateEventsScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_EVENT_SETTINGS || m_special_page == SPECIAL_PAGE_EVENT_CONTROLS)
        UpdateEventSettingsScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_OBJ_TRIGGERS || m_special_page == SPECIAL_PAGE_EVENT_TRIGGER)
        UpdateEventsSubScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_BLOCK_CONTENTS || m_special_page == SPECIAL_PAGE_LEVELTEST_HELDNPC)
        UpdateNPCScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_EDITOR_SETTINGS)
        UpdateEditorSettingsScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_WORLD_SETTINGS)
        UpdateWorldSettingsScreen(mode);
    // else if(m_special_page == SPECIAL_PAGE_MAGICBLOCK)
    //     UpdateMagicBlockScreen(mode);
    else if(m_special_page == SPECIAL_PAGE_EVENT_MUSIC || m_special_page == SPECIAL_PAGE_EVENT_BACKGROUND
        || m_special_page == SPECIAL_PAGE_EVENT_SOUND || m_special_page == SPECIAL_PAGE_SECTION_BACKGROUND
        || m_special_page == SPECIAL_PAGE_SECTION_MUSIC || m_special_page == SPECIAL_PAGE_LEVEL_EXIT
        || EditorCursor.Mode == OptCursor_t::WLD_MUSIC || m_special_page == SPECIAL_PAGE_WARP_TRANSITION)
        UpdateSelectListScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::LVL_BLOCKS)
        UpdateBlockScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::LVL_BGOS)
        UpdateBGOScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::LVL_NPCS)
        UpdateNPCScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::LVL_WATER)
        UpdateWaterScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::LVL_WARPS)
        UpdateWarpScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::LVL_PLAYERSTART || m_special_page == SPECIAL_PAGE_SECTION_SETTINGS)
        UpdateSectionsScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::WLD_TILES)
        UpdateTileScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::WLD_SCENES)
        UpdateSceneScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::WLD_LEVELS)
        UpdateLevelScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::WLD_PATHS)
        UpdatePathScreen(mode);
    else if(EditorCursor.Mode == OptCursor_t::WLD_AREA)
        UpdateAreaScreen(mode);

    if(mode == CallMode::Render && e_CursorX >= 0 && GamePaused == PauseCode::None)
    {
#ifndef __3DS__
        XRender::renderTextureBasic(e_CursorX, e_CursorY, GFX.ECursor[2]);
#endif
        if(e_tooltip)
        {
            if(e_CursorX + 28 < e_ScreenW / 2)
                SuperPrint(e_tooltip, 3, e_CursorX + 28, e_CursorY + 34, XTColorF(1.0_n, 0.7_n, 0.7_n));
            else
                SuperPrintRightAlign(e_tooltip, 3, e_CursorX + 10, e_CursorY + 34, XTColorF(1.0_n, 0.7_n, 0.7_n));
        }
    }

    if(mode == CallMode::Logic)
        MenuMouseRelease = !SharedCursor.Primary;
}

EditorScreen editorScreen;


================================================
FILE: src/editor/new_editor.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef NEW_EDITOR_H
#define NEW_EDITOR_H

#include <string>
#include <vector>

#include <DirManager/dirman.h>

#include "std_picture.h"
#include "global_constants.h"

enum NPCID : vbint_t;

namespace Icon
{
    enum Icons : int
    {
        unk = 0,
        left,
        right,
        up,
        down,
        bottom,
        top,
        check,
        x,
        lr,
        ud,
        hop,
        target,
        wave,
        leap,
        _10,
        _1x,
        pencil,
        show,
        hide,
        toggle,
        play,
        save,
        open,
        newf,
        page,
        music,
        move,
        thextech,
        subscreen,
        select,
        action
    };
}

class EditorScreen
{
public:
    enum class CallMode
    {
        Logic,
        Render
    };

private:
    typedef enum
    {
        SPECIAL_PAGE_NONE,
        SPECIAL_PAGE_MAGICBLOCK,
        SPECIAL_PAGE_BROWSER,
        SPECIAL_PAGE_BROWSER_CONFIRM,
        SPECIAL_PAGE_EVENTS,
        SPECIAL_PAGE_EVENT_SETTINGS,
        SPECIAL_PAGE_EVENT_DELETION,
        SPECIAL_PAGE_EVENT_LAYERS,
        SPECIAL_PAGE_EVENT_TRIGGER,
        SPECIAL_PAGE_EVENT_MUSIC,
        SPECIAL_PAGE_EVENT_BACKGROUND,
        SPECIAL_PAGE_EVENT_CONTROLS,
        SPECIAL_PAGE_EVENT_SOUND,
        SPECIAL_PAGE_SECTION_SETTINGS,
        SPECIAL_PAGE_SECTION_MUSIC,
        SPECIAL_PAGE_SECTION_BACKGROUND,
        SPECIAL_PAGE_LAYERS,
        SPECIAL_PAGE_LAYER_DELETION,
        SPECIAL_PAGE_OBJ_LAYER,
        SPECIAL_PAGE_OBJ_TRIGGERS,
        SPECIAL_PAGE_BLOCK_CONTENTS,
        SPECIAL_PAGE_WARP_TRANSITION,
        SPECIAL_PAGE_LEVEL_EXIT,
        SPECIAL_PAGE_WORLD_SETTINGS,
        SPECIAL_PAGE_EDITOR_SETTINGS,
        SPECIAL_PAGE_LEVELTEST_HELDNPC,
        SPECIAL_PAGE_FILE,
        SPECIAL_PAGE_FILE_CONFIRM,
        SPECIAL_PAGE_FILE_CONVERT,
    } SpecialPage_t;
    typedef enum
    {
        WARP_PAGE_MAIN,
        WARP_PAGE_REQS,
        WARP_PAGE_LEVEL,
    } WarpPage_t;
    typedef enum
    {
        BROWSER_MODE_NONE,
        BROWSER_MODE_SAVE_NEW,
        BROWSER_MODE_SAVE,
        BROWSER_MODE_OPEN,
    } BrowserMode_t;
    typedef enum
    {
        BROWSER_CALLBACK_NONE,
        BROWSER_CALLBACK_NEW_LEVEL,
        BROWSER_CALLBACK_SAVE_LEVEL,
        BROWSER_CALLBACK_OPEN_LEVEL,
        BROWSER_CALLBACK_NEW_WORLD,
        BROWSER_CALLBACK_SAVE_WORLD,
        BROWSER_CALLBACK_OPEN_WORLD,
        BROWSER_CALLBACK_CUSTOM_MUSIC,
    } BrowserCallback_t;

    // current pages
    SpecialPage_t m_special_page = SPECIAL_PAGE_NONE;
    int m_special_subpage = 0;
    int m_last_mode = 0;
    int m_NPC_page = 0;
    int m_Block_page = 0;
    int m_BGO_page = 0;
    WarpPage_t m_Warp_page = WARP_PAGE_MAIN;
    int m_layers_page = 0;
    int m_events_page = 0;
    int m_sounds_page = 0;
    int m_tile_page = 0;
    int m_music_page = 0;
    int m_background_page = 0;
    int m_current_event = 0;

    // saved message string for user (maybe expensive to recalculate each frame)
    std::string m_saved_message;

    // file browser info
    std::string* m_file_target = nullptr;
    std::string m_root_path;
    std::vector<std::string> m_target_exts;
    std::string m_cur_path;
    std::string m_cur_file;
    std::vector<std::string> m_cur_path_dirs;
    std::vector<std::string> m_cur_path_files;
    DirMan m_dirman;
    bool m_path_synced = false;
    BrowserMode_t m_browser_mode = BROWSER_MODE_NONE;
    BrowserCallback_t m_browser_callback = BROWSER_CALLBACK_NONE;
    SpecialPage_t m_last_special_page = SPECIAL_PAGE_NONE;

    void EnsureWorld();
    void EnsureLevel();

    void SyncPath();
    void GoToSuper();
    void ValidateExt(std::string& cur_file);
    bool FileExists(const std::string& cur_file);
    void StartFileBrowser(std::string* file_target,
                          const std::string &root_path,
                          const std::string &current_path,
                          const std::vector<std::string> &target_exts,
                          BrowserMode_t browser_mode = BROWSER_MODE_OPEN,
                          BrowserCallback_t browser_callback = BROWSER_CALLBACK_NONE);
    void FileBrowserSuccess();
    void FileBrowserFailure();
    void FileBrowserCleanup();

    bool UpdateButton(CallMode mode, int x, int y, StdPicture &im, bool sel,
        int src_x = 0, int src_y = 0, int src_w = 32, int src_h = 32, const char* tooltip = nullptr);

    bool UpdateCheckBox(CallMode mode, int x, int y, bool sel, const char* tooltip = nullptr);

    bool UpdateNPCButton(CallMode mode, int x, int y, NPCID type, bool sel);
    void UpdateNPC(CallMode mode, int x, int y, NPCID type);
    void UpdateNPCGrid(CallMode mode, int x, int y, const int* types, int n_npcs, int n_cols);
    void UpdateNPCScreen(CallMode mode);

    bool UpdateBlockButton(CallMode mode, int x, int y, int type, bool sel);
    void UpdateBlock(CallMode mode, int x, int y, int type);
    void UpdateBlockGrid(CallMode mode, int x, int y, const int* types, int n_blocks, int n_cols);
    void UpdateBlockScreen(CallMode mode);

    bool UpdateBGOButton(CallMode mode, int x, int y, int type, bool sel);
    void UpdateBGO(CallMode mode, int x, int y, int type);
    void UpdateBGOGrid(CallMode mode, int x, int y, const int* types, int n_bgos, int n_cols);
    void UpdateBGOScreen(CallMode mode);

    void UpdateAreaScreen(CallMode mode);
    void UpdateWaterScreen(CallMode mode);
    void UpdateWarpScreen(CallMode mode);

    void UpdateSectionsScreen(CallMode mode);

    void UpdateEditorSettingsScreen(CallMode mode);

    void UpdateWorldSettingsScreen(CallMode mode);

    void UpdateLayersScreen(CallMode mode);

    void UpdateEventsScreen(CallMode mode);
    void UpdateEventSettingsScreen(CallMode mode);
    void UpdateEventsSubScreen(CallMode mode);

    bool UpdateTileButton(CallMode mode, int x, int y, int type, bool sel);
    void UpdateTile(CallMode mode, int x, int y, int type);
    void UpdateTileGrid(CallMode mode, int x, int y, const int* types, int n_tiles, int n_cols);
    void UpdateTileScreen(CallMode mode);

    void UpdateScene(CallMode mode, int x, int y, int type);
    void UpdateSceneGrid(CallMode mode, int x, int y, const int* types, int n_scenes, int n_cols);
    void UpdateSceneScreen(CallMode mode);

    void UpdateLevel(CallMode mode, int x, int y, int type);
    void UpdateLevelGrid(CallMode mode, int x, int y, const int* types, int n_levels, int n_cols);
    void UpdateLevelScreen(CallMode mode);

    void UpdatePath(CallMode mode, int x, int y, int type);
    void UpdatePathGrid(CallMode mode, int x, int y, const int* types, int n_paths, int n_cols);
    void UpdatePathScreen(CallMode mode);

    void UpdateSelectListScreen(CallMode mode);

    void UpdateFileScreen(CallMode mode);
    void UpdateBrowserScreen(CallMode mode);

    // void UpdateMagicBlockScreen(CallMode mode);

public:
    bool active = true;
    int num_test_players = 1;
    bool test_magic_hand = false;

    void UpdateEditorScreen(CallMode mode, bool second_screen = false);
    void UpdateSelectorBar(CallMode mode, bool select_bar_only = false);
    void ResetCursor();
    // set m_NPC_page based on the editor cursor
    void FocusNPC();
    // set m_Block_page based on the editor cursor
    void FocusBlock();
    // set m_BGO_page based on the editor cursor
    void FocusBGO();
    // set m_tile_page based on the editor cursor
    void FocusTile();
};

extern EditorScreen editorScreen;

#endif // #ifndef NEW_EDITOR_H


================================================
FILE: src/editor/write_common.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "write_common.h"


void fwritestr(FILE* f, const std::string& s)
{
    char buf[512];
    int dest = 0;
    for (const char& c : s)
    {
        if(dest == 512)
            break;
        if(c == '\t' || c == '\r' || c == '\n' || c == '"')
            continue;
        buf[dest] = c;
        dest ++;
    }
    buf[dest] = '\0';
    fprintf(f, "\"%s\"\r\n", buf);
}

void fwritestr_multiline(FILE* f, const std::string& s)
{
    char buf[512];
    int dest = 0;
    for (const char& c : s)
    {
        if(dest == 512)
            break;
        if(c == '\t' || c == '\r')
            continue;
        if(c == '"')
            buf[dest] = '\'';
        else if(c == '\n')
        {
            if(dest == 511) break;
            buf[dest] = '\r';
            dest ++;
            buf[dest] = '\n';
        }
        else
            buf[dest] = c;
        dest ++;
    }
    buf[dest] = '\0';
    fprintf(f, "\"%s\"\r\n", buf);
}

void fwritenum(FILE* f, int n)
{
    fprintf(f, "%d\r\n", n);
}

void fwritebool(FILE* f, bool b)
{
    if (b)
        fprintf(f, "#TRUE#\r\n");
    else
        fprintf(f, "#FALSE#\r\n");
}

void fwritefloat(FILE* f, float n)
{
    fprintf(f, "%f\r\n", n);
}


================================================
FILE: src/editor/write_common.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef WRITE_COMMON_HHHH
#define WRITE_COMMON_HHHH

#include <cstdio>
#include <string>


void fwritestr(FILE* f, const std::string& s);

void fwritestr_multiline(FILE* f, const std::string& s);

void fwritenum(FILE* f, int n);

void fwritebool(FILE* f, bool b);

void fwritefloat(FILE* f, float n);

#endif // WRITE_COMMON_HHHH


================================================
FILE: src/editor/write_level.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "sorting.h"
#include "layers.h"
#include "write_common.h"
#include "main/game_info.h"
#include "sound.h"
#include "npc.h"
#include "npc_id.h"
#include "npc_traits.h"
#include "npc_special_data.h"
#include <PGE_File_Formats/file_formats.h>
#include <AppPath/app_path.h>
#include "Logger/logger.h"

void SaveLevel(const std::string& FilePath, int format, int version)   // saves the level
{
    LevelData out;
    LevelBlock block;
    LevelBGO bgo;
    LevelSection section;
    LevelNPC npc;
    LevelDoor warp;
    LevelPhysEnv pez;
    LevelLayer layer;
    LevelSMBX64Event evt;
    PlayerPoint player;

    FileFormats::CreateLevelData(out);

    int A = 0;
    int B = 0;
    int C = 0;

    // put NPC types 60, 62, 64, 66, and 78-83 first. (why?)
    for(A = 1; A <= numNPCs; A++)
    {
        if(NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM || NPC[A].Type == NPCID_GRN_PLATFORM || NPC[A].Type == NPCID_RED_PLATFORM || (NPC[A].Type >= NPCID_TANK_TREADS && NPC[A].Type <= NPCID_SLANT_WOOD_M))
        {
            // swap it with the first NPC that isn't one of the special ones
            // this started as B = 1 but C + 1 will work now.
            for(B = C + 1; B < A; B++)
            {
                if (!(NPC[B].Type == NPCID_YEL_PLATFORM || NPC[B].Type == NPCID_BLU_PLATFORM || NPC[B].Type == NPCID_GRN_PLATFORM || NPC[B].Type == NPCID_RED_PLATFORM || (NPC[B].Type >= NPCID_TANK_TREADS && NPC[B].Type <= NPCID_SLANT_WOOD_M)))
                {
                    std::swap(NPC[A], NPC[B]);
                    break;
                }
            }
            C++;
            // we know that the first C slots are all these types
        }
        // C++ was here but that is a logical flaw.
    }

    qSortNPCsY(1, C);
    qSortNPCsY(C + 1, numNPCs);
    qSortBlocks(1, numBlock);
    qSortBackgrounds(1, numBackground);
    // FindSBlocks();

    syncLayersTrees_AllBlocks();
    syncLayers_AllBGOs();
    syncLayers_AllNPCs();

    // NPCyFix
    // Split filepath
    // For A = Len(FilePath) To 1 Step -1
    //     If Mid(FilePath, A, 1) = "/" Or Mid(FilePath, A, 1) = "\\" Then Exit For
    // Next A
    // FileNamePath = Left(FilePath, (A))
    // FileName = Right(FilePath, (Len(FilePath) - A))
    // FullFileName = FilePath
    // If Right(FileNamePath, 2) = "\\" Then
    //     FileNamePath = Left(FileNamePath, Len(FileNamePath) - 1)
    // End If

    // Level-wide settings
    out.LevelName = LevelName;
    out.meta.configPackId = "TheXTech";
    out.meta.engineFeatureLevel = g_gameInfo.contentFeatureLevel;

    // sections
    for(int i = 0; i < numSections; ++i)
    {
        const auto &s = LevelREAL[i];

        section.id = i;
        section.size_left = s.X;
        section.size_top  = s.Y;
        section.size_right = s.Width;
        section.size_bottom  = s.Height;
        section.music_id = bgMusic[i];
        // section.bgcolor = bgColor[i];    // unused since SMBX64, removed
        section.wrap_h = LevelWrap[i];
        section.wrap_v = LevelVWrap[i];
        section.OffScreenEn = OffScreenExit[i];
        section.background = Background2[i];
        section.lock_left_scroll = NoTurnBack[i];
        section.underwater = UnderWater[i];
        section.music_file = CustomMusic[i];

        if(SectionJSONInfo[i] != STRINGINDEX_NONE)
            section.custom_params = GetS(SectionJSONInfo[i]);

        // swapped order of operands because
        // previous code did not make sense
        if(size_t(i) >= out.sections.size())
            out.sections.push_back(section);
        else
            out.sections[i] = section;
    }

    for(int i = 1; i <= 2; ++i)
    {
        const auto &p = PlayerStart[i];

        if(p.isNull())
            continue;

        player.id = i;
        player.x = p.X;
        player.y = p.Y;

        // force to Moondust compatible size
        player.w = 24;
        player.h = (i == 1) ? 54 : 60;

        player.x += PlayerStart[i].Width / 2;
        player.x -= player.w / 2;

        player.y += PlayerStart[i].Height;
        player.y -= player.h;

        player.direction = p.Direction;
        out.players.push_back(player);
    }

    for(int i = 1; i <= numBlock; ++i)
    {
        const auto &b = Block[i];

        block.id = b.Type;
        block.x = (int32_t)b.Location.X;
        block.y = (int32_t)b.Location.Y;
        block.w = (int32_t)b.Location.Width;
        block.h = (int32_t)b.Location.Height;

        if(b.Special >= 1000)
            block.npc_id = b.Special - 1000;
        else if(b.Special > 0)
            block.npc_id = -b.Special;
        else
            block.npc_id = 0;

        block.invisible = b.Invis;
        block.slippery = b.Slippy;
        block.layer = GetL(b.Layer);

        // fix this to update as needed
        if(block.layer.empty())
            block.layer = "Default";

        block.event_destroy = GetE(b.TriggerDeath);
        block.event_hit = GetE(b.TriggerHit);
        block.event_emptylayer = GetE(b.TriggerLast);

        // NEW: legacy behavior for spin block
        if(b.Type == 90)
            block.special_data = (int)b.forceSmashable;

        block.meta.array_id = (out.blocks_array_id++);

        out.blocks.push_back(block);
    }

    for(int i = 1; i <= numBackground; ++i)
    {
        const auto &b = Background[i];

        bgo.id = b.Type;
        bgo.x = (int32_t)b.Location.X;
        bgo.y = (int32_t)b.Location.Y;
        bgo.layer = GetL(b.Layer);

        bgo.z_mode = b.GetCustomLayer();
        bgo.z_offset = b.GetCustomOffset();
        // bgo.smbx64_sp = bgo.z_mode == LevelBGO::ZDefault ? b.SortPriority : -1;

        // fix this to update as needed
        if(bgo.layer.empty())
            bgo.layer = "Default";

        bgo.meta.array_id = out.bgo_array_id++;
        out.bgo.push_back(bgo);
    }

    const auto generator_direct_default = npc.generator_direct;
    const auto generator_period_default = npc.generator_period;
    const auto generator_type_default = npc.generator_type;

    for(int i = 1; i <= numNPCs; ++i)
    {
        const auto &n = NPC[i];

        npc.id = n.Type;
        npc.x = (int32_t)n.Location.X;
        npc.y = (int32_t)n.Location.Y;
        npc.direct = n.Direction;

        npc.contents = 0;
        npc.special_data = 0;

        if(NPCIsContainer(n))
        {
            npc.contents = n.Special;
            npc.special_data = n.Variant;
        }

        // Warp Section pointer
        if(n.Type == NPCID_DOOR_MAKER || n.Type == NPCID_MAGIC_DOOR ||
          (n.Type == NPCID_ITEM_BURIED && n.Special == NPCID_DOOR_MAKER))
        {
            npc.special_data = n.Variant;
        }
        // AI / firebar length
        else if(n.Type == NPCID_FIRE_CHAIN || NPCIsAParaTroopa(n) || n->IsFish)
        {
            npc.special_data = n.Special;
        }
        // Star ID if >0
        else if(n.Type == NPCID_STAR_EXIT || n.Type == NPCID_STAR_COLLECT || n.Type == NPCID_MEDAL)
        {
            npc.special_data = int(n.Variant);
        }
        // Legacy and custom behaviors
        else if(find_Variant_Data(n.Type) != nullptr)
        {
            npc.special_data = n.Variant;
        }

        npc.generator = n.Generator;
        if(npc.generator)
        {
            npc.generator_direct = n.GeneratorDirection();
            npc.generator_period = n.GeneratorTimeMax();
            npc.generator_type = n.GeneratorEffect();
        }
        else
        {
            npc.generator_direct = generator_direct_default;
            npc.generator_period = generator_period_default;
            npc.generator_type = generator_type_default;
        }
        npc.attach_layer = GetL(n.AttLayer);

        npc.msg = GetS(n.Text);
        npc.friendly = n.Inert;
        npc.nomove = n.Stuck;
        npc.is_boss = n.Legacy;
        npc.wings_type = (int)n.DefaultWings;
        npc.gfx_dx = n.GFXSlot;

        npc.layer = GetL(n.Layer);

        npc.event_activate = GetE(n.TriggerActivate);
        npc.event_die = GetE(n.TriggerDeath);
        npc.event_talk = GetE(n.TriggerTalk);
        npc.event_emptylayer = GetE(n.TriggerLast);

        // fix this to update as needed
        if(npc.layer.empty())
            npc.layer = "Default";

        npc.meta.array_id = out.npc_array_id++;
        out.npc.push_back(npc);
    }

    for(int i = 1; i <= numWarps; ++i)
    {
        const auto &w = Warp[i];

        // no case where user would want to save incomplete warp in classic editor
        if(!w.PlacedEnt || !w.PlacedExit)
            continue;

        warp.ix = (int32_t)w.Entrance.X;
        warp.iy = (int32_t)w.Entrance.Y;
        warp.length_i = (int32_t)w.Entrance.Width;
        warp.height_i = (int32_t)w.Entrance.Height;
        warp.ox = (int32_t)w.Exit.X;
        warp.oy = (int32_t)w.Exit.Y;
        warp.length_o = (int32_t)w.Exit.Width;
        warp.height_o = (int32_t)w.Exit.Height;
        warp.isSetIn = w.PlacedEnt;
        warp.isSetOut = w.PlacedExit;
        warp.idirect = w.Direction;
        warp.odirect = w.Direction2;

        warp.type = w.Effect;
        warp.lname = GetS(w.level);

        warp.warpto = w.LevelWarp;
        warp.lvl_i = w.LevelEnt;

        warp.lvl_o = w.MapWarp;
        warp.world_x = w.MapX;
        warp.world_y = w.MapY;

        warp.stars = w.Stars;
        warp.layer = GetL(w.Layer);
        warp.unknown = w.Hidden;

        warp.novehicles = w.NoYoshi;
        warp.allownpc = w.WarpNPC;
        warp.locked = w.Locked;

        // custom fields:
        warp.two_way = w.twoWay;

        warp.cannon_exit = w.cannonExit;
        warp.cannon_exit_speed = w.cannonExitSpeed;
        warp.event_enter = GetE(w.eventEnter);
        warp.event_exit = GetE(w.eventExit);
        warp.stars_msg = GetS(w.StarsMsg);
        warp.star_num_hide = w.noPrintStars;
        warp.hide_entering_scene = w.noEntranceScene;

        warp.stood_state_required = w.stoodRequired;
        warp.transition_effect = w.transitEffect;

        // fix this to update as needed
        if(warp.layer.empty())
            warp.layer = "Default";

        warp.meta.array_id = out.doors_array_id++;
        out.doors.push_back(warp);
    }

    for(int i = 1; i <= numWater; ++i)
    {
        const auto &p = Water[i];

        pez.x = (int32_t)p.Location.X;
        pez.y = (int32_t)p.Location.Y;
        pez.w = (int32_t)p.Location.Width;
        pez.h = (int32_t)p.Location.Height;
        // pez.buoy = p.Buoy;
        pez.env_type = p.Type; // p.Quicksand ? LevelPhysEnv::ENV_QUICKSAND : LevelPhysEnv::ENV_WATER;
        pez.layer = GetL(p.Layer);

        // fix this to update as needed
        if(pez.layer.empty())
            pez.layer = "Default";

        pez.meta.array_id = out.physenv_array_id++;
        out.physez.push_back(pez);
    }

    // clear the layers to prevent duplicates of the built-in layers
    out.layers_array_id = 1;
    out.layers.clear();

    for(int i = 0; i < numLayers; ++i)
    {
        const auto &l = Layer[i];

        layer.name = l.Name;
        layer.hidden = l.Hidden;

        layer.meta.array_id = out.layers_array_id++;
        out.layers.push_back(layer);
    }

    // clear the events to prevent duplicates of the built-in events
    out.events_array_id = 1;
    out.events.clear();

    for(int i = 0; i < numEvents; ++i)
    {
        const auto &e = Events[i];

        evt.name = e.Name;
        evt.msg = GetS(e.Text);
        evt.sound_id = e.Sound;
        evt.end_game = e.EndGame;
        evt.layers_hide.clear();
        for(layerindex_t i : e.HideLayer)
        {
            evt.layers_hide.push_back(GetL(i));
        }
        evt.layers_show.clear();
        for(layerindex_t i : e.ShowLayer)
        {
            evt.layers_show.push_back(GetL(i));
        }
        evt.layers_toggle.clear();
        for(layerindex_t i : e.ToggleLayer)
        {
            evt.layers_toggle.push_back(GetL(i));
        }

        LevelEvent_Sets s;

        for(int j = 0; j < numSections; ++j)
        {
            const auto &ss = e.section[j];

            s.id = j;

            s.music_id = ss.music_id;
            s.background_id = ss.background_id;
            s.music_file = GetS(ss.music_file);

            s.position_left = ss.position.X;
            s.position_top = ss.position.Y;
            s.position_right = ss.position.Width;
            s.position_bottom = ss.position.Height;

            s.autoscrol = ss.autoscroll;
            s.autoscrol_x = (double)ss.autoscroll_x;
            s.autoscrol_y = (double)ss.autoscroll_y;
            s.autoscroll_style = LevelEvent_Sets::AUTOSCROLL_SIMPLE;

            if(j >= (int)evt.sets.size())
                evt.sets.push_back(s);
            else
                evt.sets[j] = s;
        }

        evt.trigger = GetE(e.TriggerEvent);
        evt.trigger_timer = e.TriggerDelay;

        evt.nosmoke = e.LayerSmoke;

        evt.ctrl_altjump = e.Controls.AltJump;
        evt.ctrl_altrun = e.Controls.AltRun;
        evt.ctrl_down   = e.Controls.Down;
        evt.ctrl_drop   = e.Controls.Drop;
        evt.ctrl_jump   = e.Controls.Jump;
        evt.ctrl_left   = e.Controls.Left;
        evt.ctrl_right  = e.Controls.Right;
        evt.ctrl_run    = e.Controls.Run;
        evt.ctrl_start  = e.Controls.Start;
        evt.ctrl_up     = e.Controls.Up;

        evt.autostart = e.AutoStart;
        evt.movelayer = GetL(e.MoveLayer);
        evt.layer_speed_x = (double)e.SpeedX;
        evt.layer_speed_y = (double)e.SpeedY;

        evt.move_camera_x = (double)e.AutoX;
        evt.move_camera_y = (double)e.AutoY;
        evt.scroll_section = e.AutoSection;

        evt.meta.array_id = out.events_array_id++;
        out.events.push_back(evt);
    }

    if(!FileFormats::SaveLevelFile(out, FilePath, (FileFormats::LevelFileFormat)format, version))
    {
        pLogWarning("Error while saving the level file: %s", out.meta.ERROR_info.c_str());
        PlaySound(SFX_Smash);
        return;
    }

    AppPathManager::syncFs();

    // the rest of this stuff is all meant to be appropriately loading data
    // from the chosen folder
    // LoadNPCDefaults
    // If Dir(FileNamePath & Left(FileName, Len(FileName) - 4) & "\*.txt") <> "" Then
    //     FindCustomNPCs FileNamePath & Left(FileName, Len(FileName) - 4)
    // Else
    //     FindCustomNPCs
    // End If

    // UnloadCustomGFX
    // LoadCustomGFX

    // LoadCustomGFX2 FileNamePath & Left(FileName, Len(FileName) - 4)
    PlaySound(SFX_GotItem);
}


================================================
FILE: src/editor/write_level.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef WRITE_LEVEL_HHHH
#define WRITE_LEVEL_HHHH

#include <string>

void SaveLevel(const std::string &FilePath, int format, int version = 64);

#endif // WRITE_LEVEL_HHHH


================================================
FILE: src/editor/write_world.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "sound.h"
#include "write_common.h"
#include "main/game_info.h"
#include <PGE_File_Formats/file_formats.h>
#include <AppPath/app_path.h>
#include "Logger/logger.h"

void SaveWorld(const std::string& FilePath, int format, int version)   // Saves the world!
{
    WorldData out;
    WorldTerrainTile terra;
    WorldScenery scene;
    WorldPathTile path;
    WorldLevelTile level;
    WorldMusicBox musicbox;
    WorldAreaRect area;

    FileFormats::CreateWorldData(out);

    out.meta.configPackId = "TheXTech";
    out.meta.engineFeatureLevel = g_gameInfo.contentFeatureLevel;

    out.EpisodeTitle = WorldName;
    out.IntroLevel_file = StartLevel;
    out.HubStyledWorld = NoMap;
    out.restartlevel = RestartLevel;
    out.stars = MaxWorldStars;
    out.custom_params = WldxCustomParams;

    out.nocharacter.clear();
    for(int i = 1; i <= 5; ++i)
        out.nocharacter.push_back(blockCharacter[i]);
    out.charactersToS64();

    for(int A = 1; A <= numWorldCredits; ++A)
    {
        if(!out.authors.empty())
            out.authors.push_back('\n');
        out.authors.append(WorldCredits[A]);
    }

    // remove all trailing new-lines and spacings
    while(!out.authors.empty() && (out.authors.back() == '\n' || out.authors.back() == ' '))
        out.authors.pop_back();

    for(int i = 1; i <= numTiles; ++i)
    {
        auto &t = Tile[i];
        terra = FileFormats::CreateWldTile();
        terra.x = t.Location.X;
        terra.y = t.Location.Y;
        terra.id = t.Type;
        terra.meta.array_id = out.tile_array_id++;
        out.tiles.push_back(terra);
    }

    for(int i = 1; i <= numScenes; ++i)
    {
        auto &s = Scene[i];
        scene = FileFormats::CreateWldScenery();
        scene.x = s.Location.X;
        scene.y = s.Location.Y;
        scene.id = s.Type;
        scene.meta.array_id = out.scene_array_id++;
        out.scenery.push_back(scene);
    }

    for(int i = 1; i <= numWorldPaths; ++i)
    {
        auto &p = WorldPath[i];
        path = FileFormats::CreateWldPath();
        path.x = p.Location.X;
        path.y = p.Location.Y;
        path.id = p.Type;
        path.meta.array_id = out.path_array_id++;
        out.paths.push_back(path);
    }

    for(int i = 1; i <= numWorldLevels; ++i)
    {
        auto &s = WorldLevel[i];
        level = FileFormats::CreateWldLevel();
        level.x = s.Location.X;
        level.y = s.Location.Y;
        level.id = s.Type;
        level.lvlfile = s.FileName;
        level.title= s.LevelName;
        level.top_exit = s.LevelExit[1];
        level.left_exit = s.LevelExit[2];
        level.bottom_exit = s.LevelExit[3];
        level.right_exit = s.LevelExit[4];
        level.meta.array_id = out.path_array_id++;
        level.entertowarp = s.StartWarp;
        level.alwaysVisible = s.Visible;
        level.gamestart = s.Start;
        level.gotox = s.WarpX;
        level.gotoy = s.WarpY;
        level.pathbg = s.Path;
        level.bigpathbg = s.Path2;

        // new:
        level.starsShowPolicy = s.starsShowPolicy;

        out.levels.push_back(level);
    }

    for(int i = 1; i <= numWorldMusic; i++)
    {
        auto &s = WorldMusic[i];
        musicbox = FileFormats::CreateWldMusicbox();
        musicbox.x = s.Location.X;
        musicbox.y = s.Location.Y;
        musicbox.id = s.Type;

        // new:
        musicbox.music_file = GetS(s.MusicFile);

        musicbox.meta.array_id = out.musicbox_array_id++;
        out.music.push_back(musicbox);
    }

    for(int i = 1; i <= numWorldAreas; i++)
    {
        auto &s = WorldArea[i];

        area = WorldAreaRect();

        area.x = s.Location.X;
        area.y = s.Location.Y;
        area.w = s.Location.Width;
        area.h = s.Location.Height;

        area.flags |= WorldAreaRect::SETUP_SET_VIEWPORT;

        area.meta.array_id = out.arearect_array_id++;
        out.arearects.push_back(area);
    }

    if(!FileFormats::SaveWorldFile(out, FilePath, (FileFormats::WorldFileFormat)format, version))
    {
        pLogWarning("Error while saving the level file: %s", out.meta.ERROR_info.c_str());
        PlaySound(SFX_Smash);
        return;
    }

    AppPathManager::syncFs();

    PlaySound(SFX_GotItem);
}


================================================
FILE: src/editor/write_world.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef WRITE_WORLD_HHHH
#define WRITE_WORLD_HHHH

#include <string>

void SaveWorld(const std::string &FilePath, int format, int version = 64);

#endif // WRITE_WORLD_HHHH


================================================
FILE: src/editor.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef EDITOR_H
#define EDITOR_H

#include <string>

#include "location.h"
#include "global_constants.h"

enum NPCID : vbint_t;

extern std::string Backup_FullFileName;
extern int editor_section_toast;

extern bool HasCursor;
extern bool NoReallyKillIt;
extern int curSection;

extern bool enableAutoAlign;

namespace OptCursor_t
{
    enum Modes {
        LVL_SELECT = 13,
        LVL_ERASER = 6,
        LVL_BLOCKS = 1,
        LVL_BGOS = 3,
        LVL_NPCS = 4,
        LVL_SECTION = 2,
        LVL_PLAYERSTART = 18,
        LVL_WARPS = 5,
        LVL_WATER = 15,
        LVL_EVENTS = 17,
        WLD_PATHS = 10,
        WLD_MUSIC = 11,
        WLD_SCENES = 8,
        WLD_LEVELS = 9,
        WLD_TILES = 7,
        WLD_AREA = 16,
    };
}

// NEW: set / reset the scrolls when changing sections
void ResetSectionScrolls();
void SetSection(int i);

void EditorBackup();
void EditorRestore();

// this sub handles the level editor
// it is still called when the player is testing a level in the editor in windowed mode
extern void UpdateEditor();

#ifdef THEXTECH_INTERPROC_SUPPORTED
extern void UpdateInterprocess();
#endif

// extern int EditorNPCFrame(const NPCID A, vbint_t C, int N = 0);
extern int EditorNPCFrame(const NPCID A, vbint_t& C, int N = 0);

extern void GetEditorControls();

extern void SetCursor();

extern void PositionCursor();

extern void HideCursor();

extern void KillWarp(int A);

extern void zTestLevel(bool magicHand = false, bool interProcess = false);

extern void MouseMove(int X, int Y, bool nCur = false);

extern void ResetNPC(NPCID A);

#endif // EDITOR_H


================================================
FILE: src/eff_id.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef ENUMEFFID_HHH
#define ENUMEFFID_HHH

#include "global_constants.h"

enum EFFID : vbint_t
{
    EFFID_SMOKE_S3_CENTER = -10,
    EFFID_BLOCK_SMASH = 1,
    EFFID_FODDER_S3_SQUISH = 2,
    EFFID_CHAR1_DIE = 3,
    EFFID_FODDER_S3_DIE = 4,
    EFFID_CHAR2_DIE = 5,
    EFFID_RED_FODDER_SQUISH = 6,
    EFFID_RED_FODDER_DIE = 7,
    EFFID_GRN_SHELL_S3_DIE = 8,
    EFFID_RED_SHELL_S3_DIE = 9,
    EFFID_SMOKE_S3 = 10,
    EFFID_COIN_BLOCK_S3 = 11,
    EFFID_BIG_FIREBALL_TAIL = 12,
    EFFID_LAVA_SPLASH = 13,
    EFFID_MINIBOSS_DIE = 14,
    EFFID_BULLET_DIE = 15,
    EFFID_BIG_BULLET_DIE = 16,
    EFFID_RED_GUY_DIE = 17,
    EFFID_BLU_GUY_DIE = 18,
    EFFID_GLASS_SHELL_DIE = 19,
    EFFID_JUMPER_S3_DIE = 20,
    EFFID_BLU_BLOCK_SMASH = 21,
    EFFID_UNDER_FODDER_DIE = 22,
    EFFID_UNDER_FODDER_SQUISH = 23,
    EFFID_RED_FISH_S1_DIE = 24,
    EFFID_HEAVY_THROWER_DIE = 25,
    EFFID_GRN_BOOT_DIE = 26,
    EFFID_SPIKY_S3_DIE = 27,
    EFFID_SPIT_BOSS_BALL_DIE = 28,
    EFFID_SPIT_BOSS_DIE = 29,
    EFFID_SLIDE_BLOCK_SMASH = 30,
    EFFID_SPIKY_BALL_S3_DIE = 31,
    EFFID_SPIKY_THROWER_DIE = 32,
    EFFID_CRAB_DIE = 33,
    EFFID_FLY_DIE = 34,
    EFFID_EXT_TURTLE_SQUISH = 35,
    EFFID_EXT_TURTLE_DIE = 36,
    EFFID_YELSWITCH_FODDER_SQUISH = 37,
    EFFID_YELSWITCH_FODDER_DIE = 38,
    EFFID_BLUSWITCH_FODDER_SQUISH = 39,
    EFFID_BLUSWITCH_FODDER_DIE = 40,
    EFFID_GRNSWITCH_FODDER_SQUISH = 41,
    EFFID_GRNSWITCH_FODDER_DIE = 42,
    EFFID_REDSWITCH_FODDER_SQUISH = 43,
    EFFID_REDSWITCH_FODDER_DIE = 44,
    EFFID_BIG_FODDER_SQUISH = 45,
    EFFID_BIG_FODDER_DIE = 46,
    EFFID_BIG_SHELL_DIE = 47,
    EFFID_POWER_S3_DIE = 48,
    EFFID_JUMPER_S4_DIE = 49,
    EFFID_VILLAIN_S3_DIE = 50,
    EFFID_BLOCK_S1_SMASH = 51,
    EFFID_FODDER_S1_SQUISH = 52,
    EFFID_FODDER_S1_DIE = 53,
    EFFID_DOOR_S2_OPEN = 54,
    EFFID_DOOR_DOUBLE_S3_OPEN = 55,
    EFFID_ITEM_POD_OPEN = 56,
    EFFID_ITEM_POD_BREAK = 57,
    EFFID_PET_BIRTH = 58,
    EFFID_DOOR_SIDE_S3_OPEN = 59,
    EFFID_SHELL_S4_DIE = 60,
    EFFID_HIT_TURTLE_S4_DIE = 61,
    EFFID_HIT_TURTLE_S4_SQUISH = 62,
    EFFID_SMOKE_S5 = 63,
    EFFID_BIRD_DIE = 64,
    EFFID_RED_SPIT_GUY_DIE = 65,
    EFFID_BLU_SPIT_GUY_DIE = 66,
    EFFID_GRY_SPIT_GUY_DIE = 67,
    EFFID_SPIT_GUY_BALL_DIE = 68,
    EFFID_BOMB_S2_EXPLODE = 69,
    EFFID_BOMB_S3_EXPLODE_SEED = 70,
    EFFID_BOMB_S3_EXPLODE = 71,
    EFFID_WALK_BOMB_S3_DIE = 72,
    EFFID_WHIP = 73,
    EFFID_SKID_DUST = 74,
    EFFID_WHACK = 75,
    EFFID_BOOT_STOMP = 76,
    EFFID_PLR_FIREBALL_TRAIL = 77,
    EFFID_COIN_COLLECT = 78,
    EFFID_SCORE = 79,
    EFFID_SPARKLE = 80,
    EFFID_COIN_SWITCH_PRESS = 81,
    EFFID_SPINBLOCK = 82,
    EFFID_CARRY_BUDDY_DIE = 83,
    EFFID_BRUTE_SQUISH = 84,
    EFFID_BRUTE_SQUISHED_DIE = 85,
    EFFID_BRUTE_DIE = 86,
    EFFID_BIG_GUY_DIE = 87,
    EFFID_CARRY_FODDER_DIE = 88,
    EFFID_CHASER_DIE = 89,
    EFFID_STONE_S3_DIE = 90,
    EFFID_BIG_GHOST_DIE = 91,
    EFFID_GHOST_S4_DIE = 92,
    EFFID_GHOST_FAST_DIE = 93,
    EFFID_GHOST_S3_DIE = 94,
    EFFID_GRN_SHELL_S1_DIE = 95,
    EFFID_RED_SHELL_S1_DIE = 96,
    EFFID_SKELETON_DIE = 97,
    EFFID_STONE_S4_DIE = 98,
    EFFID_SAW_DIE = 99,
    EFFID_GRY_BLOCK_SMASH = 100,
    EFFID_RED_BOOT_DIE = 101,
    EFFID_BLU_BOOT_DIE = 102,
    EFFID_BIG_DOOR_OPEN = 103,
    EFFID_LAVA_MONSTER_LOOK = 104,
    EFFID_VILLAIN_S1_DIE = 105,
    EFFID_SICK_BOSS_DIE = 106,
    EFFID_SPACE_BLOCK_SMASH = 107,
    EFFID_BOSS_FRAGILE_EXPLODE = 108,
    EFFID_WALL_TURTLE_DIE = 109,
    EFFID_WALL_SPARK_DIE = 110,
    EFFID_BOSS_CASE_BREAK = 111,
    EFFID_BOSS_FRAGILE_DIE = 112,
    EFFID_AIR_BUBBLE = 113,
    EFFID_WATER_SPLASH = 114,
    EFFID_GRN_FISH_S3_DIE = 115,
    EFFID_RED_FISH_S3_DIE = 116,
    EFFID_SQUID_S3_DIE = 117,
    EFFID_GRN_FISH_S4_DIE = 118,
    EFFID_GRN_FISH_S1_DIE = 119,
    EFFID_BONE_FISH_DIE = 120,
    EFFID_SQUID_S1_DIE = 121,
    EFFID_YEL_FISH_S4_DIE = 122,
    EFFID_TIME_SWITCH_PRESS = 123,
    EFFID_TNT_PRESS = 124,
    EFFID_EARTHQUAKE_BLOCK_HIT = 125,
    EFFID_FODDER_S5_SQUISH = 126,
    EFFID_FODDER_S5_DIE = 127,
    EFFID_STACKER_DIE = 128,
    EFFID_CHAR3_DIE = 129,
    EFFID_CHAR4_DIE = 130,
    EFFID_SMOKE_S4 = 131,
    EFFID_STOMP_INIT = 132,
    EFFID_STOMP_STAR = 133,
    EFFID_CHAR5_DIE = 134,
    EFFID_DIRT_BLOCK_SMASH = 135,
    EFFID_FIRE_DISK_DIE = 136,
    EFFID_WALK_PLANT_DIE = 137,
    EFFID_BOMBER_BOSS_DIE = 138,
    EFFID_PLR_ICEBALL_TRAIL = 139,
    EFFID_MAGIC_BOSS_DIE = 140,
    EFFID_BAT_DIE = 141,
    EFFID_VINE_BUG_DIE = 142,
    EFFID_FIRE_BOSS_DIE = 143,
    EFFID_BUBBLE_POP = 144,
    EFFID_ITEM_THROWER_DIE = 145,
    EFFID_SPIKY_S4_DIE = 146,
    EFFID_SMOKE_S2 = 147,
    EFFID_CHAR3_HEAVY_EXPLODE = 148,
    EFFID_GENERIC_NPC_DIE = 149,
    EFFID_GENERIC_NPC_SQUISH = 150,
};


#endif // ENUMEFFID_HHH


================================================
FILE: src/effect.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "config.h"

#include "effect.h"
#include "npc.h"
#include "npc_id.h"
#include "eff_id.h"
#include "npc_traits.h"
#include "sound.h"
#include "game_main.h"
#include "collision.h"
#include "layers.h"
#include "graphics/gfx_update.h"

#include "main/trees.h"

// should be tuned based on profiling of Effect-heavy cases (consider Col.'s Cathedral in SRW2)
static constexpr int s_kill_stack_size = 16;

// Updates the effects
void UpdateEffects()
{
// please reference the /graphics/effect folder to see what the effects are

//    int A = 0;
    int B = 0;
//    bool DontSpawnExit = false;
//    bool DontResetMusic = false;
    int CoinCount = 0;

    if(FreezeNPCs)
        return;

    vbint_t killed_effects[s_kill_stack_size];
    int num_killed = 0;

    For(A, 1, numEffects)
    {
        auto &e = Effect[A];
        e.Life -= 1;

        // moved code for Life == 0 for EFFID_MINIBOSS_DIE below

        e.Location.X += e.Location.SpeedX;
        e.Location.Y += e.Location.SpeedY;

        if(e.Type == EFFID_FODDER_S3_SQUISH || e.Type == EFFID_FODDER_S5_SQUISH || e.Type == EFFID_RED_FODDER_SQUISH
            || e.Type == EFFID_UNDER_FODDER_SQUISH || e.Type == EFFID_EXT_TURTLE_SQUISH || e.Type == EFFID_YELSWITCH_FODDER_SQUISH
            || e.Type == EFFID_BLUSWITCH_FODDER_SQUISH || e.Type == EFFID_GRNSWITCH_FODDER_SQUISH || e.Type == EFFID_REDSWITCH_FODDER_SQUISH
            || e.Type == EFFID_BIG_FODDER_SQUISH || e.Type == EFFID_FODDER_S1_SQUISH || e.Type == EFFID_HIT_TURTLE_S4_SQUISH
            || e.Type == EFFID_GENERIC_NPC_SQUISH) // Stomped Goombas
        {
            e.Location.SpeedY = 0;
            e.Location.SpeedX = 0;
        }
        else if(e.Type == EFFID_BOSS_FRAGILE_DIE)
        {
            if(e.Life % 5 == 0)
            {
                num_t dx = dRand();
                num_t dy = dRand();
                NewEffect(EFFID_BOSS_FRAGILE_EXPLODE, newLoc(e.Location.X + (dx * (int_ok)e.Location.Width),
                                      e.Location.Y + (dy * (int_ok)e.Location.Height)));
            }
        }
        else if(e.Type == EFFID_BOSS_CASE_BREAK)
        {
            e.Location.SpeedY += 0.5_n;
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 7)
                    e.Frame = 0;
                if(e.Frame >= 14)
                    e.Frame = 7;
            }
        }
        else if(e.Type == EFFID_BOSS_FRAGILE_EXPLODE)
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.FrameCount = 0;
                e.Frame += 1;
            }

            if(e.Frame >= 7)
                e.Life = 0;
        }
        else if(e.Type == EFFID_FIRE_DISK_DIE) // RotoDisk
        {
            if(e.Location.SpeedX != 0 || e.Location.SpeedY != 0)
                e.Location.SpeedY += 0.5_n;
            e.Frame += 1;
            if(e.Frame >= 5)
                e.Frame = 0;
        }
        else if(e.Type == EFFID_BOMB_S2_EXPLODE) // bomb
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 2)
            {
                e.FrameCount = 0;
                if(e.Frame == 0)
                    e.Frame = 1;
                else
                    e.Frame = 0;
            }
        }
        else if(e.Type == EFFID_BLOCK_SMASH || e.Type == EFFID_BLU_BLOCK_SMASH || e.Type == EFFID_SLIDE_BLOCK_SMASH
            || e.Type == EFFID_BLOCK_S1_SMASH || e.Type == EFFID_GRY_BLOCK_SMASH || e.Type == EFFID_DIRT_BLOCK_SMASH
            || e.Type == EFFID_ITEM_POD_BREAK) // Block break
        {
            e.Location.SpeedY += 0.6_n;
            e.Location.SpeedX = e.Location.SpeedX * 0.99_r;
            if(e.Location.SpeedY >= 10)
                e.Location.SpeedY = 10;

            if(e.Type != EFFID_ITEM_POD_BREAK)
            {
                e.FrameCount += 1;
                if(e.FrameCount >= 3)
                {
                    e.FrameCount = 0;
                    e.Frame += 1;
                    if(e.Frame == 4)
                        e.Frame = 0;
                }
            }
        }
        else if(e.Type == EFFID_MAGIC_BOSS_DIE) // larry shell
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.Frame += 1;
                e.FrameCount = 0;
            }

            if(e.Frame > 7)
                e.Frame = 0;

            if(HasSound(SFX_MagicBossShell) && g_config.sfx_modern) // When new sound is presented, do animation a bit differently
            {
                if(e.Life == 75)
                    e.Location.SpeedY = -5;
                else if(e.Life == 65)
                    e.Location.SpeedY = -8;
                else if(e.Life == 60)
                    e.Location.SpeedY = -11;
                else if(e.Life == 52)
                    e.Location.SpeedY = -14;
            }
            else if(e.Life == 100) // Old sound
            {
                e.Location.SpeedY = -8;
                PlaySoundSpatial(SFX_SickBossKilled, e.Location);
            }
        }
        else if(e.Type == EFFID_WATER_SPLASH) // Splash
        {
            e.FrameCount += 1;

            // simplified logic
            if(e.FrameCount < 40)
                e.Frame = e.FrameCount / 8;
            else
                e.Life = 0;

            if(e.FrameCount % 3 == 0)
                e.Frame = 5;
        }
        else if(e.Type == EFFID_AIR_BUBBLE) // Water Bubbles
        {
            if(e.NewNpc == 0)
            {
                bool tempBool = false;
                for(B = 1; B <= numWater; B++)
                {
                    if(CheckCollision(e.Location, Water[B].Location) && !Water[B].Hidden)
                    {
                        tempBool = true;
                        break;
                    }
                }

                if(!tempBool)
                    e.Life = 0;
            }
            e.FrameCount += 1;
            if(e.FrameCount < 4)
                e.Frame = 0;
            else if(e.FrameCount < 6)
                e.Frame = 1;
            else
            {
                e.FrameCount = 0;
                e.Frame = 0;
            }
            e.Location.Y -= 2;
            e.Location.X += dRand() * 2 - 1;
        }
        else if(e.Type == EFFID_CHAR1_DIE || e.Type == EFFID_CHAR2_DIE || e.Type == EFFID_CHAR3_DIE || e.Type == EFFID_CHAR4_DIE || e.Type == EFFID_CHAR5_DIE) // Mario & Luigi death
            e.Location.SpeedY += 0.25_n;
        else if(e.Type == EFFID_ITEM_THROWER_DIE || e.Type == EFFID_WALL_SPARK_DIE || e.Type == EFFID_FODDER_S5_DIE || e.Type == EFFID_FODDER_S3_DIE || e.Type == EFFID_FIRE_BOSS_DIE || e.Type == EFFID_VINE_BUG_DIE || e.Type == EFFID_RED_FODDER_DIE || e.Type == EFFID_UNDER_FODDER_DIE || e.Type == EFFID_SPIKY_BALL_S3_DIE || e.Type == EFFID_CRAB_DIE || e.Type == EFFID_FLY_DIE || e.Type == EFFID_YELSWITCH_FODDER_DIE || e.Type == EFFID_BLUSWITCH_FODDER_DIE || e.Type == EFFID_GRNSWITCH_FODDER_DIE || e.Type == EFFID_REDSWITCH_FODDER_DIE || e.Type == EFFID_BIG_FODDER_DIE || e.Type == EFFID_FODDER_S1_DIE || e.Type == EFFID_SQUID_S3_DIE) // Goomba air ride of dooom
        {
            e.Location.SpeedY += 0.5_n;
            if(e.Location.SpeedY >= 10)
                e.Location.SpeedY = 10;
            e.FrameCount += 1;
            if(e.Type == EFFID_WALL_SPARK_DIE || e.Type == EFFID_FIRE_BOSS_DIE)
                e.FrameCount += 1;
            if(e.FrameCount >= 8)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 2)
                    e.Frame = 0;
            }
        }
        else if(e.Type == EFFID_LAVA_MONSTER_LOOK) // Blaarg eyes
        {
            e.Life += 2;
            if(e.Life <= 30)
                e.Location.SpeedY = -2.8_n;
            else if(e.Life <= 40)
                e.Location.SpeedY = 0.5_n;
            else if(e.Life <= 80)
                e.Location.SpeedY = 0;
            else if(e.Life <= 100)
                e.Location.SpeedY = 2;
            else
                e.Life = 0;
            e.FrameCount += 1;
            if(e.FrameCount >= 16)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 2)
                    e.Frame = 0;
            }
        }
        else if(e.Type == EFFID_HIT_TURTLE_S4_DIE) // Beack Koopa
        {
            e.Location.SpeedY += 0.5_n;
            if(e.Location.SpeedY >= 10)
                e.Location.SpeedY = 10;
            e.FrameCount += 1;
            if(e.FrameCount >= 15)
            {
                e.FrameCount = 0;
                e.Frame -= 1;
            }
            else if(e.FrameCount == 8)
                e.Frame += 1;
        }
        // these are non-animated standard death effects
        else if(e.Type == EFFID_GRN_SHELL_S3_DIE || e.Type == EFFID_RED_SHELL_S3_DIE || e.Type == EFFID_BULLET_DIE
            || e.Type == EFFID_BIG_BULLET_DIE || e.Type == EFFID_GLASS_SHELL_DIE || e.Type == EFFID_SPIKY_S3_DIE
            || e.Type == EFFID_SPIKY_S4_DIE || e.Type == EFFID_SPIT_BOSS_BALL_DIE || e.Type == EFFID_SPIT_BOSS_DIE
            || e.Type == EFFID_SPIKY_THROWER_DIE || e.Type == EFFID_EXT_TURTLE_DIE || e.Type == EFFID_BIG_SHELL_DIE
            || e.Type == EFFID_SHELL_S4_DIE || e.Type == EFFID_GRN_SHELL_S1_DIE || e.Type == EFFID_RED_SHELL_S1_DIE
            || e.Type == EFFID_WALL_TURTLE_DIE || e.Type == EFFID_HEAVY_THROWER_DIE || e.Type == EFFID_POWER_S3_DIE
            || e.Type == EFFID_JUMPER_S4_DIE || e.Type == EFFID_VILLAIN_S3_DIE || e.Type == EFFID_SPIT_GUY_BALL_DIE
            || e.Type == EFFID_WALK_BOMB_S3_DIE || e.Type == EFFID_CHASER_DIE || e.Type == EFFID_STONE_S3_DIE
            || e.Type == EFFID_BIG_GHOST_DIE || e.Type == EFFID_GHOST_S4_DIE || e.Type == EFFID_GHOST_FAST_DIE
            || e.Type == EFFID_GHOST_S3_DIE || e.Type == EFFID_STONE_S4_DIE || e.Type == EFFID_SAW_DIE
            || e.Type == EFFID_VILLAIN_S1_DIE || e.Type == EFFID_BOMBER_BOSS_DIE || e.Type == EFFID_SICK_BOSS_DIE
            || e.Type == EFFID_BAT_DIE || e.Type == EFFID_GENERIC_NPC_DIE) // Flying turtle shell / Bullet bill /hard thing, combined with section with comment "Bullet Bill / Hammer Bro"
        {
            e.Location.SpeedY += 0.5_n;
            if(e.Location.SpeedY >= 10)
                e.Location.SpeedY = 10;
        }
        else if(e.Type == EFFID_GRN_BOOT_DIE || e.Type == EFFID_RED_BOOT_DIE || e.Type == EFFID_BLU_BOOT_DIE) // Goombas shoes
        {
            e.Location.SpeedY += 0.5_n;

            if(e.Location.SpeedY >= 10)
                e.Location.SpeedY = 10;

            if(e.Location.SpeedX > 0)
                e.Frame = 0 + SpecialFrame[1];
            else
                e.Frame = 2 + SpecialFrame[1];
        }
        else if(e.Type == EFFID_SMOKE_S3 || e.Type == EFFID_SMOKE_S4) // SMW / SMB3 Puff of smoke
        {
            // no longer double SpeedX for SMOKE_S3 or SMOKE_S4
            // multiplied SpeedX constants by 2 elsewhere.

            // e.Location.X += e.Location.SpeedX;
            e.FrameCount += 1;
            if(e.FrameCount >= 3)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 4)
                    e.Life = 0;
            }
        }
        else if(e.Type == EFFID_SMOKE_S2) // SMB2 Puff of smoke
        {
            // this did nothing in SMBX 1.3 because SpeedX was always 0
            // e.Location.X += e.Location.SpeedX;

            e.FrameCount += 1;
            if(e.FrameCount >= 6)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 4)
                    e.Life = 0;
            }
        }
        else if(e.Type == EFFID_STOMP_INIT) // stomp stars
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 3)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 2)
                {
                    e.Life = 0;
                    NewEffect(EFFID_STOMP_STAR, e.Location);
                }
            }
        }
        else if(e.Type == EFFID_STOMP_STAR) // stomp stars
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 1)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 4)
                    e.Frame = 0;
            }
        }
        else if(e.Type == EFFID_WHIP) // Tail whack
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 2)
            {
                // If .Frame = 0 Then
                    // .Frame = 2
                // ElseIf .Frame = 2 Then
                    // .Frame = 1
                // ElseIf .Frame = 1 Then
                    // .Frame = 3
                // Else
                e.Frame += 1;
                if(e.Frame > 3)
                {
                    e.Frame = 0;
                    e.Life = 0;
                }
                e.FrameCount = 0;
            }
        }
        else if(e.Type == EFFID_WHACK) // Whack
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.Frame += 1;
                if(e.Frame > 1)
                    e.Life = 0;
                e.FrameCount = 0;
            }
        }
        else if(e.Type == EFFID_BOOT_STOMP)
        {
            // doubled speed in NewEffect
            // e.Location.X += e.Location.SpeedX;
            // e.Location.Y += e.Location.SpeedY;
        }
        else if(e.Type == EFFID_COIN_SWITCH_PRESS || e.Type == EFFID_TIME_SWITCH_PRESS || e.Type == EFFID_TNT_PRESS) // P Switch
        {
            if(e.Life == 1)
                NewEffect(EFFID_SMOKE_S3_CENTER, e.Location);
        }
        else if(e.Type == EFFID_SKID_DUST) // Slide Smoke
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.Frame += 1;
                e.FrameCount = 0;
                if(e.Frame > 2)
                    e.Life = 0;
            }
        }
        else if(e.Type == EFFID_SMOKE_S5) // Zelda Smoke
        {
            // this had no effect because SpeedX/SpeedY was always zero for EFFID_SMOKE_S5 in SMBX 1.3
            // e.Location.X += e.Location.SpeedX;
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 4)
                    e.Life = 0;
            }
        }
        else if(e.Type == EFFID_COIN_BLOCK_S3) // Coin out of block effect
        {
            if(e.Life == 1)
            {
                CoinCount += 1;
                if(CoinCount > 13)
                    CoinCount = 10;
                MoreScore(CoinCount, e.Location);
            }

            // simplified logic
            if(e.Life <= 6)
            {
                // NOTE: 4, 5, 6 are valid frames.
                // This sets Frame to 7 on the frame when Life is 0.
                e.Frame = 4 + (6 - e.Life) / 2;
                // NOTE: The same behavior at VB6 code: just checks the boolean expression and writes 0 or -1
                e.Location.SpeedY = (e.Location.SpeedY == 0) ? 0 : -1;
            }
            else
            {
                e.Location.SpeedY += 0.4_n;
                e.FrameCount += 1;
                if(e.FrameCount >= 3)
                {
                    e.FrameCount = 0;
                    e.Frame += 1;
                    if(e.Frame >= 4)
                        e.Frame = 0;
                }
            }
        }
        else if(e.Type == EFFID_BIG_FIREBALL_TAIL) // Big Fireball Tail
        {
            // .Location.SpeedX = 0
            // .Location.SpeedY = 0
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.FrameCount = 0;
                e.Frame += 1;
            }
        }
        else if(e.Type == EFFID_COIN_COLLECT) // Coin
        {
            e.Location.SpeedX = 0;
            e.Location.SpeedY = 0;
            e.FrameCount += 1;
            if(e.FrameCount >= 5)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 3)
                    e.Life = 0;
            }
        }
        else if(e.Type == EFFID_SPINBLOCK) // Spinning block
        {
            e.Frame = SpecialFrame[3];
            if(e.Life < 10)
            {
                bool tempBool = false;
                for(B = 1; B <= numPlayers; B++)
                {
                    if(!Player[B].Dead && Player[B].TimeToLive == 0)
                    {
                        if(CheckCollision(e.Location, Player[B].Location))
                        {
                            tempBool = true;
                            break;
                        }
                    }
                }
                // tempBool = True
                if(!tempBool)
                {
                    e.Life = 0;
                    e.Frame = 3;
                    Block[e.NewNpc].Hidden = false;
                    invalidateDrawBlocks();
                }
                else
                    e.Life = 10;
            }
        }
        else if(e.Type == EFFID_SPARKLE) // Twinkle
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 8)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 3)
                    e.Life = 0;
            }
        }
        else if(e.Type == EFFID_PLR_FIREBALL_TRAIL || e.Type == EFFID_PLR_ICEBALL_TRAIL) // Small Fireball Tail
        {
            e.Location.X += dRand() * 2 - 1;
            e.Location.Y += dRand() * 2 - 1;
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame == 3 || e.Frame == 6 || e.Frame == 9 || e.Frame == 12 || e.Frame == 15)
                    e.Life = 0;
            }
        }
        else if(e.Type == EFFID_LAVA_SPLASH) // Big Fireball Tail
        {
            e.Location.SpeedX = 0;
            e.Location.SpeedY = 0;
            e.FrameCount += 1;
            if(e.FrameCount >= 6)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                // e.FrameCount = 0;
            }
        }
        else if(e.Type == EFFID_MINIBOSS_DIE) // Dead Big Koopa
        {
            // moved from top
            if(e.Life == 0)
            {
                if(e.NewNpc > 0)
                {
                    numNPCs++;
                    auto &nn = NPC[numNPCs];
                    nn.Type = NPCID(e.NewNpc);

                    nn.Location.Height = nn->THeight;
                    nn.Location.Width = nn->TWidth;
                    nn.Location.X = e.Location.X + (e.Location.Width - NPC[numNPCs].Location.Width) / 2;
                    nn.Location.Y = e.Location.Y - 1;
                    nn.Location.SpeedY = -6;

                    // this would fix the fact that the code was moved from before the effect's speed was applied, but SpeedX / SpeedY is always 0 for EFFID_MINIBOSS_DIE
                    // nn.Location.X -= e.Location.SpeedX;
                    // nn.Location.Y -= e.Location.SpeedY;

                    nn.Active = true;
                    nn.TimeLeft = 100;
                    nn.Frame = 0;
                    syncLayers_NPC(numNPCs);
                    CheckSectionNPC(numNPCs);
                    PlaySoundSpatial(SFX_BossBeat, e.Location);
                }
            }

            e.Location.SpeedX = 0;
            e.Location.SpeedY = 0;
            e.FrameCount += 1;
            if(e.FrameCount >= 2)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                // e.FrameCount = 0;
                if(e.Frame >= 4)
                    e.Frame = 0;
            }
        }
        else if(e.Type == EFFID_BOMB_S3_EXPLODE_SEED) // SMB3 Bomb Part 1
        {
            if(e.FrameCount == 0)
            {
                NewEffect(EFFID_BOMB_S3_EXPLODE, e.Location, e.Frame);
                e.Frame += 1;
                if(e.Frame >= 4)
                    e.Frame = 0;
            }
            else if(e.FrameCount >= 6)
                e.FrameCount = -1;
            e.FrameCount += 1;
        }
        else if(e.Type == EFFID_BOMB_S3_EXPLODE || e.Type == EFFID_CHAR3_HEAVY_EXPLODE) // SMB3 Bomb Part 2
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame >= 4)
                    e.Frame = 0;
            }

            if(e.Type == EFFID_CHAR3_HEAVY_EXPLODE && iRand(10) >= 8)
            {
                NewEffect(EFFID_PLR_FIREBALL_TRAIL, e.Location, 3);
                Effect[numEffects].Location.SpeedX = dRand() * 3 - 1.5_n;
                Effect[numEffects].Location.SpeedY = dRand() * 3 - 1.5_n;
            }
        }
        else if(e.Type == EFFID_EARTHQUAKE_BLOCK_HIT) // POW Block
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.FrameCount = 0;
                e.Frame += 1;
                if(e.Frame >= 4)
                {
                    e.Life = 0;
                    e.Frame = 3;
                }
            }
        }
        else if(e.Type == EFFID_DOOR_S2_OPEN || e.Type == EFFID_DOOR_DOUBLE_S3_OPEN || e.Type == EFFID_DOOR_SIDE_S3_OPEN || e.Type == EFFID_BIG_DOOR_OPEN) // door
        {
            e.FrameCount += 1;
            if(e.FrameCount > 60)
                e.Life = 0;
            else if(e.FrameCount > 55)
                e.Frame = 0;
            else if(e.FrameCount > 50)
                e.Frame = 1;
            else if(e.FrameCount > 45)
                e.Frame = 2;
            else if(e.FrameCount > 40)
                e.Frame = 3;
            else if(e.FrameCount > 20)
                e.Frame = 4;
            else if(e.FrameCount > 15)
                e.Frame = 3;
            else if(e.FrameCount > 10)
                e.Frame = 2;
            else if(e.FrameCount > 5)
                e.Frame = 1;
        }
        else if(e.Type == EFFID_STACKER_DIE)
        {
            e.Location.SpeedY += 0.5_n;
            if(e.Location.SpeedY >= 10)
                e.Location.SpeedY = 10;
            e.FrameCount += 1;
            e.Frame = 5;
            if(e.FrameCount >= 16)
            {
                e.FrameCount = 0;
                //e.Frame = 5; // Already 5!
            }
            else if(e.FrameCount > 8)
                e.Frame = 4;

            // don't combine with below, because it's lopsided: 9 final values (0-8) use Frame 5, and 7 final values (9-15) use Frame 4
        }
        else if(e.Type == EFFID_RED_GUY_DIE || e.Type == EFFID_BLU_GUY_DIE || e.Type == EFFID_JUMPER_S3_DIE
            || e.Type == EFFID_RED_FISH_S1_DIE || (e.Type >= EFFID_BIRD_DIE && e.Type <= EFFID_GRY_SPIT_GUY_DIE)
            || e.Type == EFFID_CARRY_BUDDY_DIE // Shy guy free falling (uses frames 4-7)
            || e.Type == EFFID_BRUTE_SQUISHED_DIE || e.Type == EFFID_BRUTE_DIE || e.Type == EFFID_BIG_GUY_DIE
            || e.Type == EFFID_CARRY_FODDER_DIE || e.Type == EFFID_SKELETON_DIE || e.Type == EFFID_GRN_FISH_S3_DIE
            || e.Type == EFFID_YEL_FISH_S4_DIE || e.Type == EFFID_RED_FISH_S3_DIE || e.Type == EFFID_GRN_FISH_S4_DIE
            || e.Type == EFFID_GRN_FISH_S1_DIE || e.Type == EFFID_BONE_FISH_DIE || e.Type == EFFID_SQUID_S1_DIE
            || e.Type == EFFID_WALK_PLANT_DIE // Rex / mega mole / smw goomba free falling
            )
        {
            e.Location.SpeedY += 0.5_n;
            if(e.Location.SpeedY >= 10)
                e.Location.SpeedY = 10;
            e.FrameCount += 1;
            if(e.FrameCount >= 8)
            {
                e.FrameCount = 0;
                // flip least significant bit to switch frame while keeping same frame set
                e.Frame ^= 1;
            }
        }
        else if(e.Type == EFFID_ITEM_POD_OPEN) // Egg
        {
            if(e.NewNpc == 0 && e.FrameCount < 19)
                e.FrameCount = 19;
            e.FrameCount += 1;
            if(e.FrameCount == 10)
                e.Frame += 1;
            else if(e.FrameCount == 20)
            {
                e.Frame = 2;
                NewEffect(EFFID_ITEM_POD_BREAK, e.Location);
            }
            else if(e.FrameCount == 30)
            {
                e.Life = 0;
                if(!LevelEditor && e.NewNpc != NPCID_ITEM_POD)
                {
                    if(NPCIsYoshi((NPCID)e.NewNpc))
                    {
                        if(NewEffect(EFFID_PET_BIRTH, e.Location, 1))
                            Effect[numEffects].NewNpc = e.NewNpc;
                    }
                    else if(e.NewNpc > 0)
                    {
                        numNPCs++;
                        auto &nn = NPC[numNPCs];
                        nn.Location = e.Location;
                        nn.Active = true;
                        nn.TimeLeft = 100;
                        nn.Direction = 0;
                        nn.Type = NPCID(e.NewNpc);
                        nn.Location.Height = nn->THeight;
                        nn.Location.Width = nn->TWidth;
                        nn.Location.Y += 32 - nn.Location.Height;
                        nn.Location.X += -nn.Location.Width / 2 + 16;

                        if(nn.Type == NPCID_LEAF_POWER)
                            nn.Location.SpeedY = -6;

                        // this is new TheXTech logic
                        if(NPCTraits[e.NewNpc].IsFish || NPCIsAParaTroopa((NPCID)e.NewNpc) || e.NewNpc == NPCID_FIRE_CHAIN)
                        {
                            nn.Special = e.NewNpcSpecial;
                            nn.DefaultSpecial = e.NewNpcSpecial;
                        }

                        // this is new TheXTech logic
                        if(e.NewNpc == NPCID_STAR_EXIT || e.NewNpc == NPCID_STAR_COLLECT || e.NewNpc == NPCID_MEDAL)
                            nn.Variant = e.NewNpcSpecial;

                        syncLayers_NPC(numNPCs);
                        CheckSectionNPC(numNPCs);
                    }
                }
            }
        }
        else if(e.Type == EFFID_SPACE_BLOCK_SMASH)
        {
            e.FrameCount += 1;
            if(e.FrameCount >= 4)
            {
                e.Frame += 1;
                e.FrameCount = 0;
            }

            if(e.Frame >= 3)
                e.Life = 0;
        }
        else if(e.Type == EFFID_PET_BIRTH) // yoshi grow
        {
            e.FrameCount += 1;
            if(e.FrameCount < 10)
                e.Frame = 0;
            else if(e.FrameCount < 20)
                e.Frame = 1;
            else if(e.FrameCount < 30)
                e.Frame = 0;
            else if(e.FrameCount < 40)
                e.Frame = 1;
            else if(e.FrameCount < 50)
                e.Frame = 0;
            else if(e.FrameCount < 60)
                e.Frame = 1;
            else
            {
                e.Frame = 1;
                e.Life = 0;
                numNPCs++;
                auto &nn = NPC[numNPCs];
                nn.Location = e.Location;
                nn.Active = true;
                nn.TimeLeft = 100;
                nn.Direction = 1;
                nn.Type = NPCID(e.NewNpc);
                nn.Location.Height = nn->THeight;
                nn.Location.Width = nn->TWidth;
                syncLayers_NPC(numNPCs);
                CheckSectionNPC(numNPCs);
            }

            if(e.NewNpc == NPCID_PET_BLUE)
                e.Frame += 2;
            else if(e.NewNpc == NPCID_PET_YELLOW)
                e.Frame += 4;
            else if(e.NewNpc == NPCID_PET_RED)
                e.Frame += 6;
            else if(e.NewNpc == NPCID_PET_BLACK)
                e.Frame += 8;
            else if(e.NewNpc == NPCID_PET_PURPLE)
                e.Frame += 10;
            else if(e.NewNpc == NPCID_PET_PINK)
                e.Frame += 12;
            else if(e.NewNpc == NPCID_PET_CYAN)
                e.Frame += 14;
        }
        else if(e.Type == EFFID_SCORE)
            e.Location.SpeedY = e.Location.SpeedY * 0.97_r;

        // check for killed (lets us only do a single loop over effects)
        if(e.Life <= 0)
        {
            if(num_killed < s_kill_stack_size)
                killed_effects[num_killed] = A;

            num_killed++;
        }
    } //for

    if(num_killed > s_kill_stack_size)
    {
        for(int A = numEffects; A >= 1; --A)
        {
            if(Effect[A].Life <= 0)
                KillEffect(A);
        }
    }
    else
    {
        for(int A = num_killed - 1; A >= 0; --A)
            KillEffect(killed_effects[A]);
    }
}

enum NewEffect_PosRoutine
{
    NE_KEEP_POS = 0,
    NE_CENTER_X = 1,
    NE_CENTER_Y = 2,
    NE_FLOOR_Y = 4,
};

bool NewEffect(EFFID A, const Location_t &Location, int Direction, bool Shadow)
{
// this sub creates effects
// please reference the /graphics/effect folder to see what the effects are
// A is the effect type

    int B = 0;

    if(numEffects >= maxEffects - 4)
        return false;

    // cases where more than one Effect is spawned
    if(A == EFFID_BLOCK_SMASH || A == EFFID_BLU_BLOCK_SMASH || A == EFFID_SLIDE_BLOCK_SMASH || A == EFFID_BLOCK_S1_SMASH || A == EFFID_GRY_BLOCK_SMASH || A == EFFID_DIRT_BLOCK_SMASH || A == EFFID_ITEM_POD_BREAK) // Block break effect
    {
        for(B = 1; B <= 4; B++)
        {
            numEffects++;
            auto &ne = Effect[numEffects];
            ne.Shadow = Shadow;
            ne.Location.Width = EffectWidth[A];
            ne.Location.Height = EffectHeight[A];
            ne.Type = A;
            ne.Life = 200;

            ne.Location.X = Location.X;
            ne.Location.Y = Location.Y;
            ne.Location.SpeedX = 3;

            if(B == 1 || B == 2)
                ne.Location.SpeedY = -11;
            else
            {
                ne.Location.SpeedY = -7;
                ne.Location.Y += Location.Height / 2;
            }

            if(A == EFFID_ITEM_POD_BREAK)
            {
                if(B == 1 || B == 2)
                    ne.Location.SpeedX = 2;
                else
                    ne.Location.SpeedX = 1.5_n;

                if(B == 1)
                    ne.Frame = 0;
                else if(B == 2)
                    ne.Frame = 1;
                else if(B == 3)
                    ne.Frame = 3;
                else
                    ne.Frame = 2;
            }

            if(B == 1 || B == 3)
                ne.Location.SpeedX = -ne.Location.SpeedX;
            else
                ne.Location.X += Location.Width / 2;

            auto rand_mul = (A == EFFID_ITEM_POD_BREAK) ? 0.25_rb : 1.0_rb;
            ne.Location.SpeedX += (dRand() * 2 - 1) * rand_mul;
            ne.Location.SpeedY += (dRand() * 4 - 2) * rand_mul;
        }

        return true;
    }
    else if(A == EFFID_BOOT_STOMP || A == EFFID_STOMP_STAR) // "SMW Smashed", combined with "stomp star part 2"
    {
        for(B = 1; B <= 4; B++)
        {
            if(numEffects < maxEffects)
            {
                numEffects++;
                auto &ne = Effect[numEffects];
                ne.Shadow = Shadow;
                ne.Type = A;
                ne.Location.Width = EffectWidth[A];
                ne.Location.Height = EffectHeight[A];
                ne.Location.X = Location.X + (Location.Width - ne.Location.Width) / 2;
                ne.Location.Y = Location.Y + (Location.Height - ne.Location.Height) / 2;

                if(A == EFFID_BOOT_STOMP)
                {
                    ne.Life = 15;
                    ne.Location.SpeedX = 4.8_n; // 3 * 0.8; * 2 because SpeedX got applied twice for EFFID_BOOT_STOMP in SMBX 1.3
                    ne.Location.SpeedY = 2.4_n; // 1.5 * 0.8; * 2 because SpeedY got applied twice for EFFID_BOOT_STOMP in SMBX 1.3
                }
                else
                {
                    ne.Life = 8;
                    ne.Location.SpeedX = 2;
                    ne.Location.SpeedY = 2;
                }

                if(B == 1 || B == 2)
                    ne.Location.SpeedY = -ne.Location.SpeedY;
                if(B == 1 || B == 3)
                    ne.Location.SpeedX = -ne.Location.SpeedX;

                if(A == EFFID_STOMP_STAR)
                {
                    ne.Location.Y += ne.Location.SpeedY * 6;
                    ne.Location.X += ne.Location.SpeedX * 6;
                }

                ne.Frame = 0;
            }
        }

        return true;
    }
    else if(A == EFFID_CHAR3_HEAVY_EXPLODE) // Heart Bomb
    {
        for(B = 1; B <= 6; B++)
        {
            if(numEffects < maxEffects)
            {
                numEffects++;
                auto &ne = Effect[numEffects];
                ne.Shadow = Shadow;

                ne.Location.Width = EffectWidth[A];
                ne.Location.Height = EffectHeight[A];
                ne.Location.X = Location.X + (Location.Width - ne.Location.Width) / 2;
                ne.Location.Y = Location.Y + (Location.Height - ne.Location.Height) / 2;

                if(B == 1 || B == 3 || B == 4 || B == 6)
                {
                    ne.Life = 10;
                    ne.Location.SpeedY = 1.75_n; // 3.5 * 0.5
                    ne.Location.SpeedX = 1; // 2 * 0.5
                }
                else
                {
                    ne.Life = 11;
                    ne.Location.SpeedY = 0;
                    ne.Location.SpeedX = 2; // 4 * 0.5
                }

                if(B <= 3)
                    ne.Location.SpeedX = -ne.Location.SpeedX;
                if(B == 1 || B == 6)
                    ne.Location.SpeedY = -ne.Location.SpeedY;

                // Note: Direction was always the default value of 1 in SMBX 1.3
                // if(int(Direction) % 2 == 0)
                //     std::swap(ne.Location.SpeedX, ne.Location.SpeedY);

                ne.Location.X += ne.Location.SpeedX * 3;
                ne.Location.Y += ne.Location.SpeedY * 3;

                ne.Frame = iRand(4);
                ne.Type = A;
            }
        }

        return true;
    }
    else if(A == EFFID_BOMB_S3_EXPLODE) // SMB3 Bomb Part 2
    {
        for(B = 1; B <= 6; B++)
        {
            if(numEffects < maxEffects)
            {
                numEffects++;
                auto &ne = Effect[numEffects];
                ne.Shadow = Shadow;

                ne.Location.Width = 16;
                ne.Location.Height = 16;
                ne.Location.X = Location.X;
                ne.Location.Y = Location.Y;

                if(B == 1 || B == 3 || B == 4 || B == 6)
                {
                    ne.Location.SpeedY = 4.5_n; // 3 * 1.5
                    ne.Location.SpeedX = 3; // 2 * 1.5
                    ne.Life = 14;
                }
                else
                {
                    ne.Location.SpeedY = 0;
                    ne.Location.SpeedX = 6; // 4 * 1.5
                    ne.Life = 13;
                }

                if(B <= 3)
                    ne.Location.SpeedX = -ne.Location.SpeedX;
                if(B == 1 || B == 6)
                    ne.Location.SpeedY = -ne.Location.SpeedY;

                // Note: Direction was always the default value of 1 in SMBX 1.3
                // if(int(Direction) % 2 == 0)
                //     std::swap(ne.Location.SpeedX, ne.Location.SpeedY);

                // ne.Location.SpeedX = ne.Location.SpeedX * 1.5;
                // ne.Location.SpeedY = ne.Location.SpeedY * 1.5;

                ne.Frame = Direction;
                ne.Type = A;
            }
        }

        return true;
    }
    else if(A == EFFID_COIN_COLLECT) // Coins
    {
        for(B = 1; B <= 4; B++)
        {
            numEffects++;
            auto &ne = Effect[numEffects];
            ne.Shadow = Shadow;
            ne.Location.Width = EffectWidth[A];
            ne.Location.Height = EffectHeight[A];
            ne.Location.X = Location.X + (Location.Width - ne.Location.Width) / 2;
            ne.Location.Y = Location.Y + (Location.Height - ne.Location.Height) / 2;
            ne.Location.SpeedY = 0;
            ne.Location.SpeedX = 0;
            if(B == 1)
                ne.Location.X -= 10;
            if(B == 3)
                ne.Location.X += 10;
            if(B == 2)
                ne.Location.Y += 16;
            if(B == 4)
                ne.Location.Y -= 16;
            ne.Frame = 0 - B;
            ne.Life = 20 * B;
            ne.Type = A;
        }

        return true;
    }

    // how should the position get adjusted based on the size?
    int pos_routine = NE_KEEP_POS;

    // very special case for SMOKE_S3_CENTER
    if(A == EFFID_SMOKE_S3_CENTER)
    {
        A = EFFID_SMOKE_S3;
        pos_routine = NE_CENTER_X | NE_CENTER_Y;
    }

    // this is the most common logic across all effects
    numEffects++;
    auto &ne = Effect[numEffects];
    num_t old_speedY = ne.Location.SpeedY; // for EFFID_BIG_FIREBALL_TAIL (#1101)

    // default initialization
    ne.Shadow = Shadow;
    ne.Type = A;
    ne.NewNpc = 0; // it was never left uninitialized for Effects that use it
    ne.NewNpcSpecial = 0; // it was never left uninitialized for Effects that use it

    ne.Location.X = Location.X;
    ne.Location.Y = Location.Y;
    ne.Location.Width = EffectWidth[A];
    ne.Location.Height = EffectHeight[A];
    ne.Location.SpeedX = 0;
    ne.Location.SpeedY = 0;

    // they were actually reset to these values in the destructors, so we can add debug asserts here
    SDL_assert(ne.Frame == 0);
    SDL_assert(ne.FrameCount == 0);
    ne.Frame = 0;
    ne.FrameCount = 0;

    // begin switch on type
    if(A == EFFID_MAGIC_BOSS_DIE) // larry shell
    {
        ne.Life = 160;
        pos_routine = NE_CENTER_X | NE_FLOOR_Y;
        PlaySoundSpatial(SFX_MagicBossKilled, Location);
    }
    else if(A == EFFID_LAVA_MONSTER_LOOK) // Blaarg eyes
    {
        if(Direction == -1)
            ne.Location.X -= 48;

        pos_routine = NE_CENTER_X;

        ne.Location.Width = 32;
        ne.Location.Height = 32;
        ne.Life = 10;
    }
    else if(A == EFFID_ITEM_POD_OPEN || A == EFFID_PET_BIRTH) // Egg break / Yoshi grow
    {
        // ne.NewNpc = 0; // NewNpc -- now gets set at callsite
        // ne.NewNpcSpecial = 0; // NewNpc -- now gets set at callsite
        // if(ne.NewNpc == NPCID_ITEM_POD) (logic moved to callsite)
        //     ne.NewNpc = 0;

        ne.Location.Width = 32;
        ne.Location.Height = 32;
        ne.Life = 100;

        if(A == EFFID_ITEM_POD_OPEN)
        {
            // moved to callsite
            // if(ne.NewNpc != 0 /*&& ne.NewNpc != NPCID_ITEM_POD*/) // never 96, because of condition above that replaces 96 with zero
            //     PlaySoundSpatial(SFX_PetBirth, Location);
            // else
            //     PlaySoundSpatial(SFX_Smash, Location);
        }
        else if(A == EFFID_PET_BIRTH)
            PlaySoundSpatial(SFX_Pet, Location);
    }
    else if(A == EFFID_FIRE_DISK_DIE) // Roto Disk
    {
        ne.Location.SpeedX = Location.SpeedX;
        ne.Location.SpeedY = Location.SpeedY;
        ne.Location.Width = Location.Width;
        ne.Location.Height = Location.Width; // this is a bug

        ne.Life = 10;
    }
    else if(A == EFFID_EARTHQUAKE_BLOCK_HIT) // pow
    {
        pos_routine = NE_CENTER_X | NE_FLOOR_Y;
        ne.Life = 100;
    }
    else if(A == EFFID_SPACE_BLOCK_SMASH) // Metroid Block
    {
        ne.Location.Width = 32;
        ne.Location.Height = 32;

        ne.Life = 100;
    }
    else if(A == EFFID_FODDER_S3_SQUISH || A == EFFID_RED_FODDER_SQUISH || A == EFFID_UNDER_FODDER_SQUISH
        || A == EFFID_EXT_TURTLE_SQUISH || A == EFFID_YELSWITCH_FODDER_SQUISH || A == EFFID_BLUSWITCH_FODDER_SQUISH
        || A == EFFID_GRNSWITCH_FODDER_SQUISH || A == EFFID_REDSWITCH_FODDER_SQUISH || A == EFFID_BIG_FODDER_SQUISH
        || A == EFFID_FODDER_S1_SQUISH || A == EFFID_HIT_TURTLE_S4_SQUISH || A == EFFID_BRUTE_SQUISH
        || A == EFFID_FODDER_S5_SQUISH || A == EFFID_GENERIC_NPC_SQUISH) // Goomba smash effect
    {
        PlaySoundSpatial(SFX_Stomp, Location); // Stomp sound

        ne.Location.Width = 32;
        ne.Location.Height = 34;

        ne.Life = 20;

        if(A == EFFID_BIG_FODDER_SQUISH)
        {
            ne.Location.Height = 46;
            ne.Location.Width = 48;
        }

        if(A == EFFID_BRUTE_SQUISH)
        {
            if(Direction == 1)
                ne.Frame = 1;
        }
    }
    else if(A == EFFID_COIN_SWITCH_PRESS || A == EFFID_TIME_SWITCH_PRESS || A == EFFID_TNT_PRESS) // P Switch
    {
        pos_routine = NE_CENTER_X | NE_FLOOR_Y;
        ne.Life = 120;
    }
    else if(A == EFFID_AIR_BUBBLE || A == EFFID_WATER_SPLASH) // Water Bubble / Splash
    {
        ne.Location.Height = EffectWidth[A]; // this is a bug

        ne.Life = 300;
        // ne.NewNpc = 0; // NewNpc -- now gets set at callsite

        if(A == EFFID_WATER_SPLASH) // Change height for the background
        {
            bool tempBool = false;
            for(const Background_t& b : treeBackgroundQuery(ne.Location, SORTMODE_ID))
            {
                if(b.Type == 82 || b.Type == 26 || b.Type == 65 || b.Type == 159 || b.Type == 166 || b.Type == 168)
                {
                    // note: NOT a reference
                    auto t = b.Location;
                    if(t.Height > 8 && g_config.fix_submerged_splash_effect)
                        t.Height = 8; // Limit the height
                    if(CheckCollision(ne.Location, t))
                    {
                        if(b.Type == 82 || b.Type == 159)
                            ne.Location.Y = b.Location.Y - ne.Location.Height + 12;
                        if(b.Type == 26)
                            ne.Location.Y = b.Location.Y - ne.Location.Height + 6;
                        if(b.Type == 168)
                            ne.Location.Y = b.Location.Y - ne.Location.Height + 8;
                        if(b.Type == 166)
                            ne.Location.Y = b.Location.Y - ne.Location.Height + 10;
                        if(b.Type == 65)
                            ne.Location.Y = b.Location.Y - ne.Location.Height + 16;
                        tempBool = true;
                        break;
                    }
                }
            }

            if(!tempBool)
                numEffects -= 1;
        }
    }
    else if(A == EFFID_WALL_TURTLE_DIE) // Spike Top
    {
        ne.Location.Width = 32;
        ne.Location.Height = 32;

        ne.Location.SpeedY = -12;
        ne.Location.SpeedX = Location.SpeedX;
        ne.Frame = Direction;
        ne.Life = 120;
    }
    else if(A == EFFID_BOSS_FRAGILE_EXPLODE) // Metroid
    {
        ne.Location.Width = 64;
        ne.Location.Height = 64;
        pos_routine = NE_CENTER_X | NE_CENTER_Y;
        ne.Life = 200;
    }
    else if(A == EFFID_SPINBLOCK) // Block Spin
    {
        // ne.NewNpc = 0; // NewNpc -- now gets set at callsite
        ne.Location.Width = 32;
        ne.Location.Height = 32;
        ne.Life = 300;
    }
    else if(A == EFFID_CHAR1_DIE || A == EFFID_CHAR2_DIE || A == EFFID_CHAR3_DIE || A == EFFID_CHAR4_DIE || A == EFFID_CHAR5_DIE) // Mario & Luigi died effect
    {
        pos_routine = NE_CENTER_X | NE_CENTER_Y;
        ne.Location.SpeedY = -11;

        if(A == EFFID_CHAR5_DIE)
        {
            if(Direction == 1)
                ne.Frame = 1;
        }

        ne.Life = 150;
    }
    else if(A == EFFID_SCORE) // Score
    {
        pos_routine = NE_CENTER_X | NE_CENTER_Y;
        ne.Location.X += dRand() * 32 - 16;
        ne.Location.Y += dRand() * 32 - 16;
        ne.Location.SpeedY = -2;

        ne.Life = 60;
    }
    else if(A == EFFID_BOMB_S3_EXPLODE_SEED) // SMB3 Bomb Part 1
    {
        ne.Location.Width = 16;
        ne.Location.Height = 16;
        pos_routine = NE_CENTER_X | NE_CENTER_Y;
        ne.Location.SpeedY = -0;

        ne.Life = 46;
    }
    else if(A == EFFID_DOOR_S2_OPEN || A == EFFID_DOOR_DOUBLE_S3_OPEN
        || A == EFFID_DOOR_SIDE_S3_OPEN || A == EFFID_BIG_DOOR_OPEN) // Door Effect
    {
        ne.Location.Width = Location.Width;
        ne.Location.Height = Location.Height;

        ne.Life = 150;
    }
    else if(A == EFFID_FODDER_S3_DIE || A == EFFID_RED_FODDER_DIE || A == EFFID_GRN_SHELL_S3_DIE || A == EFFID_RED_SHELL_S3_DIE || A == EFFID_GLASS_SHELL_DIE
        || A == EFFID_UNDER_FODDER_DIE || A == EFFID_GRN_BOOT_DIE || A == EFFID_RED_BOOT_DIE || A == EFFID_BLU_BOOT_DIE
        || A == EFFID_SPIKY_S3_DIE || A == EFFID_SPIKY_S4_DIE || A == EFFID_SPIT_BOSS_BALL_DIE || A == EFFID_SPIT_BOSS_DIE
        || A == EFFID_SPIKY_BALL_S3_DIE || A == EFFID_SPIKY_THROWER_DIE || A == EFFID_ITEM_THROWER_DIE || A == EFFID_CRAB_DIE
        || A == EFFID_FLY_DIE || A == EFFID_EXT_TURTLE_DIE || A == EFFID_YELSWITCH_FODDER_DIE || A == EFFID_BLUSWITCH_FODDER_DIE
        || A == EFFID_GRNSWITCH_FODDER_DIE || A == EFFID_REDSWITCH_FODDER_DIE || A == EFFID_BIG_FODDER_DIE || A == EFFID_BIG_SHELL_DIE
        || A == EFFID_FODDER_S1_DIE || A == EFFID_SHELL_S4_DIE  /* || A == EFFID_RED_FODDER_SQUISH -- mistake, repeated case from above */
        || A == EFFID_GRN_SHELL_S1_DIE || A == EFFID_RED_SHELL_S1_DIE || A == EFFID_WALL_SPARK_DIE || A == EFFID_SQUID_S3_DIE
        || A == EFFID_SQUID_S1_DIE || A == EFFID_FODDER_S5_DIE || A == EFFID_VINE_BUG_DIE || A == EFFID_GENERIC_NPC_DIE) // Flying goomba / turtle shell / hard thing shell /*A == 9 || - duplicated*/
    {
        pos_routine = NE_CENTER_X | NE_FLOOR_Y;

        if(num_t::fEqual_d(Location.SpeedY, 0.123_n))
        {
            ne.Location.SpeedY = 1;
            ne.Location.SpeedX = 0;
        }
        else if(Location.SpeedY != -5.1_n)
        {
            ne.Location.SpeedY = -11;
            ne.Location.SpeedX = Location.SpeedX;
        }
        else
        {
            ne.Location.SpeedY = -5.1_n;
            ne.Location.SpeedX = Location.SpeedX * 0.6_r;
        }

        ne.Life = 150;

        ne.Frame = 0;
        if(ne.Type == EFFID_SPIT_BOSS_DIE && Direction == -1)
            ne.Frame = 1;
        if((ne.Type == EFFID_SPIKY_S3_DIE || ne.Type == EFFID_SPIKY_S4_DIE) && Direction == 1)
            ne.Frame = 2;
        if(ne.Type == EFFID_EXT_TURTLE_DIE && Direction == 1)
            ne.Frame = 1;
    }
    else if(A == EFFID_SMOKE_S3_CENTER || A == EFFID_SMOKE_S3 || A == EFFID_WHIP || A == EFFID_SKID_DUST
        || A == EFFID_WHACK || A == EFFID_SMOKE_S4 || A == EFFID_STOMP_INIT || A == EFFID_SMOKE_S2) // Puff of smoke
    {
        if(A == EFFID_SMOKE_S4)
            pos_routine = NE_CENTER_X | NE_CENTER_Y;

        ne.Life = 12;

        if(ne.Type == EFFID_SMOKE_S2)
            ne.Life = 24;

        if(A == EFFID_STOMP_INIT || A == EFFID_WHIP || A == EFFID_WHACK)
        {
            ne.Location.X += dRand() * 16 - 8;
            ne.Location.Y += dRand() * 16 - 8;
        }
        else if(A == EFFID_SKID_DUST)
        {
            ne.Location.X += dRand() * 4 - 2;
            ne.Location.Y += dRand() * 4 - 2;

            // moved from UpdateEffects
            ne.Location.SpeedY = -0.1_n;
        }
    }
    else if(A == EFFID_BUBBLE_POP) // bubble pop
    {
        pos_routine = NE_CENTER_X | NE_CENTER_Y;
        ne.Life = 6;
    }
    else if(A == EFFID_SMOKE_S5) // Zelda Style Smoke
    {
        ne.Location.Width = 48;
        ne.Location.Height = 48;
        pos_routine = NE_CENTER_X | NE_CENTER_Y;
        ne.Life = 100;
    }
    else if(A == EFFID_COIN_BLOCK_S3) // Coin hit out of block
    {
        ne.Location.Width = 32;
        ne.Location.Height = 32;

        pos_routine = NE_CENTER_X;
        ne.Location.Y = Location.Y - ne.Location.Height; // not floor Y, this effect is above the block

        ne.Location.SpeedY = -8;
        ne.Life = 46;
    }
    else if(A == EFFID_BIG_FIREBALL_TAIL) // Big Fireball Tail
    {
        ne.Location.Width = 8;
        ne.Location.Height = 8;
        ne.Location.X = Location.X + 4 + (dRand() * 12);
        ne.Location.Y = Location.Y + 40;
        // DANGER: this is fully uninitialized (see #1101 on GitHub TheXTech/TheXTech)
        // ' .Location.SpeedY = -8
        ne.Location.SpeedY = old_speedY;

        ne.Life = 12;
    }
    else if(A == EFFID_BOSS_CASE_BREAK) // Glass Shatter
    {
        ne.Location.Width = 16;
        ne.Location.Height = 16;

        ne.Location.SpeedY = -2 - dRand() * 10;
        ne.Location.SpeedX = dRand() * 8 - 4;

        ne.Frame = 0;
        if(iRand(2) == 0)
            ne.Frame = 7;
        ne.Frame += iRand(7);

        ne.Life = 300;
    }
    else if(A == EFFID_BOSS_FRAGILE_DIE) // Mother Brain
    {
        ne.Location.Width = Location.Width;
        ne.Location.Height = Location.Height;

        ne.Frame = 0;
        if(int(Direction) == 1)
            ne.Frame = 1;

        ne.Life = 360;
    }
    else if(A == EFFID_PLR_FIREBALL_TRAIL || A == EFFID_PLR_ICEBALL_TRAIL) // Small Fireball Tail
    {
        pos_routine = NE_CENTER_X | NE_CENTER_Y;

        ne.Location.X += dRand() * 4 - 2;
        ne.Location.Y += dRand() * 4 - 2;

        ne.Frame = 0;

        if(int(Direction) == 2)
            ne.Frame = 3;
        else if(int(Direction) == 3)
            ne.Frame = 6;
        else if(int(Direction) == 4)
            ne.Frame = 9;
        else if(int(Direction) == 5)
            ne.Frame = 12;

        ne.Life = 60;
    }
    else if(A == EFFID_SPARKLE) // Twinkle
    {
        ne.Location.Width = 16;
        ne.Location.Height = 16;
        ne.Location.X = Location.X + Location.Width / 2 - 4 + dRand() * 4 - 2;
        ne.Location.Y = Location.Y + Location.Height / 2 - 4 + dRand() * 4 - 2;

        ne.Life = 60;
    }
    else if(A == EFFID_LAVA_SPLASH) // Lava Splash
    {
        pos_routine = NE_CENTER_X;
        ne.Location.Y = Location.Y + 24;
        ne.Location.SpeedY = -8;

        ne.Life = 100;
    }
    else if(A == EFFID_MINIBOSS_DIE) // Dead Big Koopa
    {
        pos_routine = NE_CENTER_X;
        ne.Location.Y = Location.Y + 22;

        // ne.NewNpc = 0; // NewNpc -- now gets set at callsite

        ne.Life = 120;
    }
    else if(A == EFFID_BULLET_DIE || A == EFFID_SPIT_GUY_BALL_DIE || A == EFFID_BIG_BULLET_DIE) // Dead Bullet Bill
    {
        ne.Location.Width = Location.Width;
        ne.Location.Height = Location.Height;

        ne.Location.SpeedY = Location.SpeedY;
        ne.Location.SpeedX = -Location.SpeedX;

        if(int(Direction) == -1)
            ne.Frame = 0;
        else
            ne.Frame = 1;

        if(A == EFFID_SPIT_GUY_BALL_DIE)
            ne.Frame = 0;
        else if(A == EFFID_BIG_BULLET_DIE)
            ne.Location.SpeedX = Location.SpeedX;

        ne.Life = 120;
    }
    else if(A == EFFID_HIT_TURTLE_S4_DIE) // Flying Beach Koopa
    {
        ne.Location.Width = Location.Width;
        ne.Location.Height = Location.Height;

        ne.Location.SpeedY = -11;
        ne.Location.SpeedX = -Location.SpeedX;
        ne.Life = 120;

        // NOTE: Frame set at callsite
    }
    else if(A == EFFID_POWER_S3_DIE) // Dead toad
    {
        ne.Location.Width = 32;
        ne.Location.Height = 32;
        // ne.Location.X += ne.Location.Width / 2 - 16;
        // ne.Location.Y += ne.Location.Height / 2 - 16;

        pos_routine = NE_CENTER_X | NE_CENTER_Y;

        ne.Location.SpeedX = Location.SpeedX;
        ne.Location.SpeedY = -8;

        ne.Life = 120;
    }
    else if(A == EFFID_BOMB_S2_EXPLODE) // Bomb
    {
        ne.Location.Width = 64;
        ne.Location.Height = 64;
        // ne.Location.X = Location.X + Location.Width / 2 - 32;
        // ne.Location.Y = Location.Y + Location.Height / 2 - 32;

        pos_routine = NE_CENTER_X | NE_CENTER_Y;

        ne.Life = 60;
    }
    else if(A == EFFID_STACKER_DIE) // pokey
    {
        ne.Location.Width = Location.Width;
        ne.Location.Height = Location.Height;

        ne.Location.SpeedY = -11;
        ne.Location.SpeedX = Location.SpeedX;
        ne.Life = 120;

        ne.Frame = 5;
    }
    else if(A == EFFID_RED_GUY_DIE || A == EFFID_BLU_GUY_DIE || A == EFFID_JUMPER_S3_DIE || A == EFFID_RED_FISH_S1_DIE
            || (A >= EFFID_BIRD_DIE && A <= EFFID_GRY_SPIT_GUY_DIE) || A == EFFID_CARRY_BUDDY_DIE || A == EFFID_BRUTE_SQUISHED_DIE
            || A == EFFID_BRUTE_DIE || A == EFFID_BIG_GUY_DIE || A == EFFID_CARRY_FODDER_DIE || A == EFFID_SKELETON_DIE
            || A == EFFID_GRN_FISH_S3_DIE || A == EFFID_YEL_FISH_S4_DIE || A == EFFID_RED_FISH_S3_DIE || A == EFFID_GRN_FISH_S4_DIE
            || A == EFFID_GRN_FISH_S1_DIE || A == EFFID_BONE_FISH_DIE || A == EFFID_WALK_PLANT_DIE) // Shy guy / Star Thing /Red Jumping Fish
    {
        pos_routine = NE_CENTER_X | NE_FLOOR_Y;

        if(A != EFFID_RED_FISH_S1_DIE && A != EFFID_GRN_FISH_S3_DIE && A != EFFID_RED_FISH_S3_DIE)
            ne.Location.SpeedY = -11;
        else
            ne.Location.SpeedY = Location.SpeedY;

        ne.Location.SpeedX = Location.SpeedX;
        if(Location.SpeedY == 0.123_n)
        {
            ne.Location.SpeedY = 1;
            ne.Location.SpeedX = 0;
        }

        if(A == EFFID_BRUTE_SQUISHED_DIE || A == EFFID_BRUTE_DIE || A == EFFID_BIG_GUY_DIE || A == EFFID_CARRY_FODDER_DIE
            || A == EFFID_SKELETON_DIE || A == EFFID_GRN_FISH_S3_DIE || A == EFFID_RED_FISH_S3_DIE || A == EFFID_GRN_FISH_S4_DIE
            || A == EFFID_GRN_FISH_S1_DIE || A == EFFID_BONE_FISH_DIE || A == EFFID_YEL_FISH_S4_DIE || A == EFFID_WALK_PLANT_DIE)
        {
            ne.Frame = 0;
        }
        else
            ne.Frame = 4;

        if(int(Direction) != -1)
            ne.Frame += 2;

        ne.Life = 120;
    }
    else if(A == EFFID_STONE_S3_DIE || A == EFFID_BIG_GHOST_DIE || A == EFFID_GHOST_S4_DIE || A == EFFID_GHOST_FAST_DIE
        || A == EFFID_GHOST_S3_DIE || A == EFFID_STONE_S4_DIE || A == EFFID_SAW_DIE // Case commented "Boo / thwomps"
        || A == EFFID_HEAVY_THROWER_DIE || A == EFFID_JUMPER_S4_DIE || A == EFFID_VILLAIN_S3_DIE || A == EFFID_WALK_BOMB_S3_DIE
        || A == EFFID_CHASER_DIE || A == EFFID_VILLAIN_S1_DIE || A == EFFID_SICK_BOSS_DIE || A == EFFID_BOMBER_BOSS_DIE
        || A == EFFID_BAT_DIE) // Case commented "Hammer Bro"
    {
        ne.Location.Width = Location.Width;
        ne.Location.Height = Location.Height;

        ne.Location.SpeedY = Location.SpeedY;
        ne.Location.SpeedX = -Location.SpeedX;

        if(A == EFFID_BIG_GHOST_DIE)
        {
            ne.Location.set_width_center(EffectWidth[A]);
            ne.Location.set_height_center(EffectHeight[A]);
        }

        if(ne.Location.SpeedX != 0 && ne.Location.SpeedX > -2 && ne.Location.SpeedX < 2)
            ne.Location.SpeedX = 2 * -Direction;

        if(Direction == -1)
            ne.Frame = 0;
        else
            ne.Frame = 2;

        if(A == EFFID_STONE_S3_DIE || A == EFFID_STONE_S4_DIE || A == EFFID_SAW_DIE)
            ne.Frame = 0;
        // combined case previously commented "Hammer Bro"
        else if(A != EFFID_BIG_GHOST_DIE && A != EFFID_GHOST_S4_DIE && A != EFFID_GHOST_FAST_DIE && A != EFFID_GHOST_S3_DIE)
        {
            ne.Location.Width = EffectWidth[A];
            ne.Location.Height = EffectHeight[A];

            if(ne.Frame == 2)
                ne.Frame = 1;
        }

        ne.Life = 120;
    }
    else if(A == EFFID_FIRE_BOSS_DIE) // ludwig dead
    {
        ne.Location.SpeedY = -14;
        ne.Location.SpeedX = 3 * -Direction;
        ne.Life = 200;

        PlaySoundSpatial(SFX_FireBossKilled, Location);
    }

    // apply pos routine if needed
    if(pos_routine & NE_CENTER_X)
        ne.Location.X += (Location.Width - ne.Location.Width) / 2;

    if(pos_routine & NE_CENTER_Y)
        ne.Location.Y += (Location.Height - ne.Location.Height) / 2;

    if(pos_routine & NE_FLOOR_Y)
        ne.Location.Y += (Location.Height - ne.Location.Height);

    return true;
}

void NewEffect_IceSparkle(const NPC_t& n, Location_t& tempLocation)
{
    tempLocation.Height = EffectHeight[EFFID_SPARKLE];
    tempLocation.Width = EffectWidth[EFFID_SPARKLE];
    tempLocation.SpeedX = 0;
    tempLocation.SpeedY = 0;
    tempLocation.X = n.Location.X - tempLocation.Width / 2 + dRand().times(n.Location.Width) - 4;
    tempLocation.Y = n.Location.Y - tempLocation.Height / 2 + dRand().times(n.Location.Height) - 4;
    NewEffect(EFFID_SPARKLE, tempLocation, 1, n.Shadow);
}

bool NewEffect_NpcDeath(EFFID legacy_effect, const NPC_t& n, EFFID generic_effect)
{
    if(n.GFXSlot != 0 && NewEffect(generic_effect, n.Location, n.Direction, n.Shadow))
    {
        auto& ne = Effect[numEffects];
        if(n->WidthGFX)
        {
            ne.Location.Width = n->WidthGFX;
            ne.Location.Height = n->HeightGFX;
            ne.Location.X = n.Location.X + (n->FrameOffsetX * -n.Direction) - n->WidthGFX / 2 + n.Location.Width / 2;
            ne.Location.Y = n.Location.Y + n->FrameOffsetY - n->HeightGFX + n.Location.Height;
        }
        else
        {
            ne.Location.Width = n->TWidth;
            ne.Location.Height = n->THeight;
            ne.Location.X = n.Location.X + n->FrameOffsetX;
            ne.Location.Y = n.Location.Y + n->FrameOffsetY;
        }

        ne.NewNpc = n.Type;
        ne.NewNpcSpecial = n.GFXSlot;
        ne.Frame = n.Frame;
        ne.FrameCount = 0;

        return true;
    }

    return NewEffect(legacy_effect, n.Location, n.Direction, n.Shadow);
}

bool NewEffect_NpcDie(EFFID legacy_effect, const NPC_t& n)
{
    return NewEffect_NpcDeath(legacy_effect, n, EFFID_GENERIC_NPC_DIE);
}

bool NewEffect_NpcSquish(EFFID legacy_effect, const NPC_t& n)
{
    return NewEffect_NpcDeath(legacy_effect, n, EFFID_GENERIC_NPC_SQUISH);
}

// Remove the effect
void KillEffect(int A)
{
    if(numEffects == 0 || A > maxEffects)
        return;

    Effect_t &e = Effect[numEffects];
    Effect[A] = e;
    e.Frame = 0;
    e.FrameCount = 0;
    e.Life = 0;
    e.Type = EFFID(0);
    numEffects -= 1;
}


================================================
FILE: src/effect.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef EFFECT_H
#define EFFECT_H

#include "global_constants.h"
#include "location.h"

// Public Sub UpdateEffects() 'Updates the effects
// Updates the effects
void UpdateEffects();
// Public Sub NewEffect(A As Integer, Location As Location, Optional Direction As Single = 1, Optional NewNpc As Integer = 0, Optional Shadow As Boolean = False)  'Create an effect
// Create an effect
bool NewEffect(EFFID A, const Location_t &Location_t, int Direction, int NewNpc, bool Shadow = false, uint8_t newNpcSpecial = 0) = delete;
bool NewEffect(EFFID A, const Location_t &Location_t, int Direction = 1, bool Shadow = false);
// Public Sub KillEffect(A As Integer) 'Remove the effect
// Remove the effect
void KillEffect(int A);

// new sub deduplicating old logic
void NewEffect_IceSparkle(const NPC_t& n, Location_t& tempLocation);

// new sub deduplicating old logic
bool NewEffect_NpcDeath(EFFID legacy_effect, const NPC_t& n, EFFID generic_effect);

// new sub deduplicating old logic
bool NewEffect_NpcDie(EFFID legacy_effect, const NPC_t& n);
// new sub deduplicating old logic
bool NewEffect_NpcSquish(EFFID legacy_effect, const NPC_t& n);

#endif // EFFECT_H


================================================
FILE: src/fontman/crop_info.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CROP_INFO_H
#define CROP_INFO_H

#include <cstdint>

struct CropInfo
{
    //! width of current text in pixels
    // uint16_t text_width = 0;

    //! width to draw the marquee effect in pixels
    uint16_t draw_width = 0;

    //! draw offset from left in pixels
    uint16_t offset = 0;

    //! fade amount in pixels (left)
    uint8_t fade_left = 0;

    //! fade amount in pixels (right)
    uint8_t fade_right = 0;

    //! use tweaked alpha curve for text outline
    bool for_outline = false;

    //! OUTPUT variable: did the text overrun the crop window?
    bool did_terminate = false;

    /**
     * \brief: calculates alpha multiplier given left and right bounds of letter
     *
     * \param letter_alpha output to store the letter's alpha value
     * \param text_alpha the text's maximum alpha value between zero and one
     * \param left left bound of letter in pixels from the left of the cropped region
     * \param right right bound of letter in pixels from the left of the cropped region
     *
     * \returns false if the right bound has been passed and drawing should be interrupted
     *
     * Side effect: marks the did_terminate flag if returning false
     */
    inline bool letter_alpha(uint8_t& letter_alpha, uint16_t text_alpha, int left, int right)
    {
        if(left < 0)
        {
            letter_alpha = 0;
            return true;
        }

        if((uint16_t)right > draw_width)
        {
            did_terminate = true;
            return false;
        }

        uint16_t fade_zone_right = draw_width - fade_right;

        if((uint16_t)left < fade_left)
        {
            letter_alpha = (text_alpha * left) / fade_left;

            // blend based on proportion in fade zone
            if((uint16_t)right > fade_left)
                letter_alpha = (text_alpha * (right - fade_left) + letter_alpha * (fade_left - left)) / (right - left);
        }
        else if((uint16_t)right > fade_zone_right)
        {
            letter_alpha = (text_alpha * (draw_width - (uint16_t)right)) / fade_right;

            // blend based on proportion in fade zone
            if((uint16_t)left < fade_zone_right)
                letter_alpha = (text_alpha * (fade_zone_right - left) + letter_alpha * (right - fade_zone_right)) / (right - left);
        }
        else
            letter_alpha = text_alpha;

        if(for_outline)
            letter_alpha = letter_alpha * letter_alpha / text_alpha;

        return true;
    }
};

#endif // CROP_INFO_H


================================================
FILE: src/fontman/font_engine_base.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef FONT_ENGINE_BASE_H
#define FONT_ENGINE_BASE_H

#include <Graphics/size.h>
#include <string>

#include "xt_color.h"

#include "fontman/crop_info.h"

class BaseFontEngine
{
public:
    virtual ~BaseFontEngine();

    enum FontType
    {
        FONT_RASTER = 0,
        FONT_TTF,
        FONT_LEGACY
    };

    /*!
     * \brief Get a size of one glyph
     * \param utf8char Pointer to one UTF-8 character
     * \param charNum Character number in the line (required to compute the size of the taboluation)
     * \param fontSize Size of TTF font glyph
     * \return Width and height of one glyph in pixels
     */
    virtual PGE_Size glyphSize(const char *utf8char, uint32_t charNum = 0, uint32_t fontSize = 14) = 0;

    /*!
     * \brief Print the multiline text block on the screen
     * \param text Multi-line text string
     * \param text_size The byte size of the text string to print
     * \param x Hotizontal screen position (at left-top corner of the block)
     * \param y Vertical screen position (at left-top corner of the block)
     * \param Red Red channel colour
     * \param Green Green channel colour
     * \param Blue Blue channel colour
     * \param Alpha Alpha channel level (does not issue render calls if Alpha is 0)
     * \param fontSize The size of the TTF font glyph
     * \param crop_info nullable pointer to info for crop (marquee) logic.
     * \return Width and height of the text block in pixels
     */
    virtual PGE_Size printText(const char *text, size_t text_size,
                               int32_t x, int32_t y,
                               XTColor color = XTColor(),
                               uint32_t fontSize = 14,
                               CropInfo* crop_info = nullptr) = 0;

    /*!
     * \brief Measure the size of the multiline text block in pixels
     * \param text Multi-line text string
     * \param text_size The byte size of the text string to print
     * \param fontSize The size of the TTF font glyph
     * \return Width and height of the text block in pixels
     */
    inline PGE_Size textSize(const char *text, size_t text_size,
                             uint32_t fontSize = 14)
    {
        return printText(text, text_size,
            0, 0,
            XTAlpha(0),
            fontSize,
            nullptr);
    }

    virtual bool isLoaded() const = 0;

    virtual std::string getFontName() const = 0;
    virtual FontType getFontType() const = 0;
};

#endif // FONT_ENGINE_BASE_H


================================================
FILE: src/fontman/font_manager.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_assert.h"
#include "sdl_proxy/sdl_stdinc.h"

#include "font_manager.h"
#include "font_manager_private.h"
#include "raster_font.h"
#include "legacy_font.h"
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
#include "ttf_font.h"
#endif

#include <AppPath/app_path.h>
#include <Graphics/graphics_funcs.h>
#include <IniProcessor/ini_processing.h>
#include <Logger/logger.h>
#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <DirManager/dirman.h>
#include <IniProcessor/ini_processing.h>
#include <sorting/tinysort.h>
#include <fmt_format_ne.h>

#include "global_constants.h"
#include "core/render.h"
#include "global_dirs.h"


#include <vector>
#ifdef LOW_MEM
#   include <map>
#else
#   include <unordered_map>
#endif

BaseFontEngine::~BaseFontEngine()
{}

typedef VPtrList<RasterFont> RasterFontsList;
typedef VPtrList<TtfFont> TtfFontsList;
typedef VPtrList<LegacyFont> LegacyFontsList;

//! Complete array of available raster fonts
static RasterFontsList g_rasterFonts;
static RasterFontsList g_rasterFontsCustomLevel;
static RasterFontsList g_rasterFontsCustom;
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
static TtfFontsList    g_ttfFonts;
static TtfFontsList    g_ttfFontsCustom;
static TtfFontsList    g_ttfFontsCustomLevel;
#define LOADFONTARG(x) x
#else
#   define LOADFONTARG(x) false
#endif
static LegacyFontsList g_legacyFonts;

typedef VPtrList<BaseFontEngine*> PtrFontsList;
static PtrFontsList    g_anyFonts;
//! Backup for the case when any custom fonts are been loaded
static PtrFontsList    g_anyFontsBackup;
static PtrFontsList    g_anyFontsBackupWorld;

//! Default raster font to render text
static BaseFontEngine  *g_defaultRasterFont = nullptr;

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
//! Default TTF font to render text
static BaseFontEngine  *g_defaultTtfFont = nullptr;
#endif

//! IS font manager initialized?
static bool             g_fontManagerIsInit = false;
//! Does font manager uses legacy fonts fallback?
static bool             g_fontManagerIsLegacy = false;

#ifdef LOW_MEM
typedef std::map<std::string, vbint_t> FontsHash;
#else
typedef std::unordered_map<std::string, vbint_t> FontsHash;
#endif
//! Database of available fonts
static FontsHash        g_fontNameToId;
//! Backup of the database of available fonts
static FontsHash        g_fontNameToIdBackup;
static FontsHash        g_fontNameToIdBackupWorld;

static bool             g_double_pixled = false;

#ifdef LOW_MEM
static const vbint_t    c_smbxFontsMapMax = 10;
#else
static const vbint_t    c_smbxFontsMapMax = 20;
#endif

// Current state
static vbint_t s_smbxFontsMap[c_smbxFontsMapMax];
static vbint_t s_smbxFontsSizesMap[c_smbxFontsMapMax];

// The initial default state
static vbint_t s_smbxFontsMapDefault[c_smbxFontsMapMax];
static vbint_t s_smbxFontsSizesMapDefault[c_smbxFontsMapMax];

// The episode-wide preserved state without content of data directory
static vbint_t s_smbxFontsMapWorld[c_smbxFontsMapMax];
static vbint_t s_smbxFontsSizesMapWorld[c_smbxFontsMapMax];

static const uint32_t c_defaultFontSize = 14;

static bool s_fontMapsDefault = true;
static bool s_fontMapsWorld = true;
static std::string s_lastWorldFontsPath;
static std::string s_lastCustomFontsPath;


static void registerFont(BaseFontEngine* font)
{
    g_anyFonts.push_back(font);

    vbint_t newIdx = static_cast<vbint_t>(g_anyFonts.size()) - 1;
    auto ef = g_fontNameToId.find(font->getFontName());

    // If overriding an existing font by name, also replace the SMBX code overrides
    if(ef != g_fontNameToId.end())
    {
        vbint_t oldIdx = ef->second;
        for(int i = 0; i < c_smbxFontsMapMax; ++i)
        {
            if(s_smbxFontsMap[i] == oldIdx)
                s_smbxFontsMap[i] = newIdx;
        }

        ef->second = newIdx;
    }
    else
        g_fontNameToId.insert({font->getFontName(), newIdx});
}

static void backupDefaultFontMaps()
{
    if(!s_fontMapsDefault)
        return; // Don't preserve customized font maps

    SDL_memcpy(s_smbxFontsMapDefault, s_smbxFontsMap, sizeof(s_smbxFontsMap));
    SDL_memcpy(s_smbxFontsSizesMapDefault, s_smbxFontsSizesMap, sizeof(s_smbxFontsSizesMap));
    g_anyFontsBackup = g_anyFonts;
    g_fontNameToIdBackup = g_fontNameToId;
}

static void restoreDefaultFontMaps()
{
    if(s_fontMapsDefault)
        return; // Don't restore if already default

    SDL_memcpy(s_smbxFontsMap, s_smbxFontsMapDefault, sizeof(s_smbxFontsMap));
    SDL_memcpy(s_smbxFontsSizesMap, s_smbxFontsSizesMapDefault, sizeof(s_smbxFontsSizesMap));
    g_anyFonts = g_anyFontsBackup;
    g_fontNameToId = g_fontNameToIdBackup;
    s_fontMapsDefault = true;
    s_fontMapsWorld = true;
}

static void backupWorldFontMaps()
{
    if(!s_fontMapsWorld)
        return; // Don't preserve customized font maps

    SDL_memcpy(s_smbxFontsMapWorld, s_smbxFontsMap, sizeof(s_smbxFontsMap));
    SDL_memcpy(s_smbxFontsSizesMapWorld, s_smbxFontsSizesMap, sizeof(s_smbxFontsSizesMap));
    g_anyFontsBackupWorld = g_anyFonts;
    g_fontNameToIdBackupWorld = g_fontNameToId;
}

static void restoreWorldFontMaps()
{
    if(s_fontMapsWorld)
        return; // Don't restore if already default

    SDL_memcpy(s_smbxFontsMap, s_smbxFontsMapWorld, sizeof(s_smbxFontsMap));
    SDL_memcpy(s_smbxFontsSizesMap, s_smbxFontsSizesMapWorld, sizeof(s_smbxFontsSizesMap));
    g_anyFonts = g_anyFontsBackupWorld;
    g_fontNameToId = g_fontNameToIdBackupWorld;
    s_fontMapsWorld = true;
}

int FontManager::fontIdFromSmbxFont(int font)
{
    if(font >= c_smbxFontsMapMax || font < 0)
        return -1;
    return s_smbxFontsMap[font];
}

uint32_t FontManager::fontSizeFromSmbxFont(int font)
{
    if(font >= c_smbxFontsMapMax || font < 0)
        return c_defaultFontSize;

    int ret = s_smbxFontsSizesMap[font];
    return (ret <= 0) ? c_defaultFontSize : static_cast<uint32_t>(ret);
}


TtfFont* FontManager::getDefaultTtfFont()
{
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    return dynamic_cast<TtfFont*>(g_defaultTtfFont);
#else
    return nullptr;
#endif
}

TtfFont* FontManager::getTtfFontByName(const std::string& fontName)
{
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    if(fontName.empty())
        return FontManager::getDefaultTtfFont();

    FontsHash::iterator i = g_fontNameToId.find(fontName);
    if(i == g_fontNameToId.end())
        return FontManager::getDefaultTtfFont();

    auto *ret = dynamic_cast<TtfFont*>(g_anyFonts[i->second]);

    return ret ? ret : FontManager::getDefaultTtfFont();
#else
    (void)fontName;
    return nullptr;
#endif
}

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
static bool s_loadFontsFromDir(DirListCI &fonts_root,
                               const std::string &subdir,
                               RasterFontsList &outRasterFonts,
                               TtfFontsList &outTtfFonts)
#else
static bool s_loadFontsFromDir(DirListCI &fonts_root,
                               const std::string &subdir,
                               RasterFontsList &outRasterFonts,
                               bool)
#endif
{
    using namespace FontManager;

    /***************Load raster font support****************/
    if(!subdir.empty() && !fonts_root.dirExistsCI(subdir))
        return false; // Fonts manager is unavailable when directory is not exists

    std::vector<std::string> files = fonts_root.getFilesList(subdir, {".font.ini"});
    tinysort(files.begin(), files.end());

    std::string sSubDir = subdir + (subdir.empty() ? "" : "/");

    for(std::string &fonFile : files)
    {
        outRasterFonts.emplace_back();
        RasterFont& rf = outRasterFonts.back();
        std::string fontPath = fonts_root.getCurDir() + sSubDir + fonFile;
        pLogDebug("Loading raster font %s...", fontPath.c_str());
        rf.loadFont(fontPath);

        if(!rf.isLoaded())   //Pop broken font from array
        {
            pLogWarning("Failed to load the font %s", fontPath.c_str());
            outRasterFonts.pop_back();
        }
        else   //Register font name in a table
            registerFont(&rf);
    }

    if(!outRasterFonts.empty())
        g_defaultRasterFont = &outRasterFonts.front();

    /***************Load TTF font support****************/
    IniProcessing overrider = Files::load_ini(fonts_root.getCurDir() + sSubDir + "overrides.ini");

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    if(overrider.beginGroup("ttf-fonts"))
    {
        for(int i = 1; ;++i)
        {
            std::string key = fmt::sprintf_ne("file%d", i);
            std::string keyAntiAlias = fmt::sprintf_ne("file%d-antialias", i);
            std::string keyBitmapSize = fmt::sprintf_ne("file%d-bitmap-size", i);
            std::string keyFontName = fmt::sprintf_ne("file%d-font-name", i);
            std::string keyDoublePixel = fmt::sprintf_ne("file%d-double-pixel", i);
            std::string keyLangsPriority = fmt::sprintf_ne("file%d-lang-priority", i);

            if(!overrider.hasKey(key))
                break; // Stop look up on a first missing key

            std::string fontFile;
            overrider.read(key.c_str(), fontFile, "");

            if(fontFile.empty())
                continue;

            bool antiAlias;
            overrider.read(keyAntiAlias.c_str(), antiAlias, true);

            int bitmapSize;
            overrider.read(keyBitmapSize.c_str(), bitmapSize, 0);

            std::string fontName;
            overrider.read(keyFontName.c_str(), fontName, "");

            bool doublePixel;
            // FIXME: add XRender::RENDER_1X flag, use that instead
#if defined(__WII__) || defined(__3DS__)
            const bool doublePixelDefault = true;
#else
            const bool doublePixelDefault = false;
#endif
            overrider.read(keyDoublePixel.c_str(), doublePixel, doublePixelDefault);

            std::string langsPriority;
            overrider.read(keyLangsPriority.c_str(), langsPriority, std::string());

            std::string fontPath = fonts_root.getCurDir() + sSubDir + fontFile;

            outTtfFonts.emplace_back();
            TtfFont& tf = outTtfFonts.back();

            tf.setAntiAlias(antiAlias);
            tf.setBitmapSize(bitmapSize);
            tf.setDoublePixel(doublePixel);
            tf.setLanguages(langsPriority);

            pLogDebug("Loading TTF font %s...", fontPath.c_str());
            tf.loadFont(fontPath);
            if(!tf.isLoaded())   //Pop broken font from array
            {
                pLogWarning("Failed to load the font %s", fontPath.c_str());
                outTtfFonts.pop_back();
            }
            else   //Register font name in a table
            {
                if(!fontName.empty()) // Set the custom font name
                    tf.setFontName(fontName);

                registerFont(&tf);
                // Set the default TTF font (as a fallback)
                if(!g_defaultTtfFont)
                    g_defaultTtfFont = &tf;
            }
        }
    }

    overrider.endGroup();
#endif

    if(overrider.beginGroup("font-overrides"))
    {
        auto k = overrider.allKeys();
        for(auto &key : k)
        {
            std::string name;

            if(key.find("-size") != std::string::npos)
                continue; // Skip the size key

            overrider.read(key.c_str(), name, "");
            if(name.empty())
                continue;

            int iKey = std::atoi(key.c_str());
            if(iKey >= 0 && iKey < c_smbxFontsMapMax)
                s_smbxFontsMap[iKey] = getFontID(name);

            std::string size_key = fmt::format_ne("{0}-size", iKey);
            if(overrider.hasKey(size_key))
                overrider.read(size_key.c_str(), s_smbxFontsSizesMap[iKey], -1);
        }
    }

    overrider.endGroup();

    return true;
}

static void s_initFontsFallback()
{
    for(int i = 1; i <= 4; ++i)
    {
        g_legacyFonts.emplace_back(i);
        LegacyFont& lf = g_legacyFonts.back();

        if(!lf.isLoaded())   //Pop broken font from array
        {
            pLogWarning("Failed to load the legacy font %d", i);
            g_legacyFonts.pop_back();
        }
        else   //Register font name in a table
        {
            registerFont(&lf);
            s_smbxFontsMap[i] = FontManager::getFontID(lf.getFontName());
        }
    }

    if(!g_legacyFonts.empty())
        g_defaultRasterFont = &g_legacyFonts.front();

    s_fontMapsDefault = true;
    s_fontMapsWorld = true;
    g_fontManagerIsInit = true;
    g_fontManagerIsLegacy = true;
}


void FontManager::initFallback()
{
    if(g_fontManagerIsInit)
        return;

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    g_defaultTtfFont = nullptr;
#endif

    g_double_pixled = false; //ConfigManager::setup_fonts.double_pixled;

    for(int i = 0; i < c_smbxFontsMapMax; ++i)
    {
        s_smbxFontsMap[i] = -1;
        s_smbxFontsSizesMap[i] = -1;
    }

    s_initFontsFallback();

    // use fallback font for everything
    for(int i = 0; i < c_smbxFontsMapMax; ++i)
    {
        s_smbxFontsMap[i] = s_smbxFontsMap[4];
        s_smbxFontsSizesMap[i] = s_smbxFontsSizesMap[4];
    }
}

void FontManager::initFull()
{
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    if(!g_ft)
        initializeFreeType();
    g_defaultTtfFont = nullptr;
#endif

    g_double_pixled = false; //ConfigManager::setup_fonts.double_pixled;

    SDL_memset(s_smbxFontsMap, 0, sizeof(s_smbxFontsMap));
    SDL_memset(s_smbxFontsSizesMap, 0, sizeof(s_smbxFontsSizesMap));

    for(int i = 0; i < c_smbxFontsMapMax; ++i)
    {
        s_smbxFontsMap[i] = -1;
        s_smbxFontsSizesMap[i] = -1;
    }

    const std::string fonts_root = AppPathManager::assetsRoot() + "fonts";
    if(!DirMan::exists(fonts_root))
    {
        pLogWarning("Can't load fonts as directory %s does not exists. Built-in fallback fonts will be loaded.", fonts_root.c_str());
        s_initFontsFallback();
        return;
    }

    DirListCI fontsRootCI(fonts_root);

    if(!s_loadFontsFromDir(fontsRootCI, std::string(), g_rasterFonts, LOADFONTARG(g_ttfFonts)))
    {
        pLogWarning("Can't load any font from the directory %s. Built-in fallback fonts will be loaded.", fonts_root.c_str());
        s_initFontsFallback();
        return;
    }

    if(g_anyFonts.empty())
    {
        pLogWarning("There is no available fonts at the directory %s. Fallback fonts will be loaded.", fonts_root.c_str());
        s_initFontsFallback();
        return;
    }

    s_fontMapsDefault = true;
    s_fontMapsWorld = true;
    g_fontManagerIsInit = true;
    g_fontManagerIsLegacy = false;
}

void FontManager::quit()
{
    clearAllCustomFonts();

    g_fontNameToId.clear();
    g_anyFonts.clear();

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    g_ttfFonts.clear();
    g_defaultTtfFont = nullptr;
#endif

    g_rasterFonts.clear();
    g_defaultRasterFont = nullptr;

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    closeFreeType();
#endif
}

void FontManager::updateDefaultFontByLang(const std::string &lang, const std::string &country)
{
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    g_defaultTtfFont = nullptr;

    if(g_ttfFonts.empty())
        return; // Nothing to choose

    // Just use a first font in the list by default
    g_defaultTtfFont = &g_ttfFonts.front();

    for(auto &f : g_ttfFonts)
    {
        if(!country.empty() && f.hasLanguage(fmt::sprintf_ne("%s-%s", lang.c_str(), country.c_str())))
        {
            g_defaultTtfFont = &f;
            break;
        }

        if(f.hasLanguage(lang))
        {
            g_defaultTtfFont = &f;
            break;
        }
    }
#else
    (void)lang;
    (void)country;
#endif
}

int FontManager::getMetricsValue(UIMetricsCategory category, const std::string &lang)
{
#ifndef THEXTECH_ENABLE_TTF_SUPPORT
    UNUSED(lang);
#endif
    // FIXME: Implement the INI-side table of rules instead of hardcoding that
    // That might work differently if different fonts are used.
    // Hardcoded rules are fine for content that lacks them

    switch(category)
    {
    case Metrics_MenuMinLineHeight:
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
        if(lang == "zh")
            return 26;
        else if(lang == "ko" || lang == "ja")
            return 22;
#endif
        return 18;

    default:
            break;
    }

    return 18;
}

void FontManager::loadCustomFonts()
{
    backupDefaultFontMaps();
    bool doLoadWorld = false;
    bool doLoadCustom = false;

    const std::string& episodeRoot = g_dirEpisode.getCurDir();
    const std::string& dataSubDir = g_dirCustom.getCurDir();

    // Loading fonts from the episode directory
    if(s_lastWorldFontsPath != episodeRoot && episodeRoot != AppPathManager::assetsRoot())
    {
        if(!s_lastWorldFontsPath.empty())
            clearAllCustomFonts();
        doLoadWorld = true;
        pLogDebug("Attempt to load custom fonts at %sfonts", episodeRoot.c_str());
    }
    else
        pLogDebug("Custom fonts at %sfonts already loaded", episodeRoot.c_str());

    if(doLoadWorld && s_loadFontsFromDir(g_dirEpisode,
                                         "fonts",
                                         g_rasterFontsCustom,
                                         LOADFONTARG(g_ttfFontsCustom)))
    {
        s_lastWorldFontsPath = episodeRoot;
        pLogDebug("Loaded custom fonts from the %sfonts", episodeRoot.c_str());
        s_fontMapsDefault = false;
        s_fontMapsWorld = true;
        backupWorldFontMaps();
    }

    // Loading fonts from the data directory
    if(s_lastCustomFontsPath != dataSubDir)
    {
        if(!s_lastCustomFontsPath.empty())
            clearLevelFonts();
        doLoadCustom = true;
        pLogDebug("Attempt to load custom fonts at %sfonts", dataSubDir.c_str());
    }
    else
        pLogDebug("Custom fonts at %sfonts already loaded", dataSubDir.c_str());

    if(doLoadCustom && s_loadFontsFromDir(g_dirCustom,
                                         "fonts",
                                          g_rasterFontsCustomLevel,
                                          LOADFONTARG(g_ttfFontsCustomLevel)))
    {
        s_lastCustomFontsPath = dataSubDir;
        pLogDebug("Loaded custom fonts from the %sfonts", dataSubDir.c_str());
        s_fontMapsDefault = false;
        s_fontMapsWorld = false;
    }
}

void FontManager::clearAllCustomFonts()
{
    g_rasterFontsCustomLevel.clear();
    g_rasterFontsCustom.clear();
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    g_ttfFontsCustomLevel.clear();
    g_ttfFontsCustom.clear();
#endif
    s_lastCustomFontsPath.clear();
    s_lastWorldFontsPath.clear();
    restoreDefaultFontMaps();
}

void FontManager::clearLevelFonts()
{
    g_rasterFontsCustomLevel.clear();
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    g_ttfFontsCustomLevel.clear();
#endif

    s_lastCustomFontsPath.clear();
    restoreWorldFontMaps();
}

bool FontManager::isInitied()
{
    return g_fontManagerIsInit;
}

bool FontManager::isLegacy()
{
    return g_fontManagerIsLegacy;
}


PGE_Size FontManager::textSize(const char* text, size_t text_size, int fontID,
                               uint32_t ttfFontSize)
{
    SDL_assert_release(g_fontManagerIsInit);// Font manager is not initialized!
#ifndef THEXTECH_ENABLE_TTF_SUPPORT
    (void)ttfFontSize;
#endif

    if(!g_fontManagerIsInit)
        return PGE_Size(27 * 20, static_cast<int>(std::count(text, text + text_size, '\n') + 1) * 20);

    if(!text || text_size == 0)
        return PGE_Size(0, 0);

    //Use one of loaded fonts
    if((fontID >= 0) && (static_cast<size_t>(fontID) < g_anyFonts.size()) && g_anyFonts[fontID])
    {
        if(g_anyFonts[fontID]->isLoaded())
            return g_anyFonts[fontID]->textSize(text, text_size, ttfFontSize);
    }

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    if(g_defaultTtfFont && g_defaultTtfFont->isLoaded())
        return g_defaultTtfFont->textSize(text, text_size, ttfFontSize);
#endif

    return PGE_Size(27 * 20, static_cast<int>(std::count(text, text + text_size, '\n') + 1) * 20);
}

PGE_Size FontManager::glyphSize(const char* utf8char, uint32_t charNum, int fontId, uint32_t ttf_fontSize)
{
    SDL_assert_release(g_fontManagerIsInit);// Font manager is not initialized!
#ifndef THEXTECH_ENABLE_TTF_SUPPORT
    (void)ttf_fontSize;
#endif

    //Use one of loaded fonts
    if((fontId >= 0) && (static_cast<size_t>(fontId) < g_anyFonts.size()) && g_anyFonts[fontId])
    {
        if(g_anyFonts[fontId]->isLoaded())
            return g_anyFonts[fontId]->glyphSize(utf8char, charNum, ttf_fontSize);
    }

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
    if(g_defaultTtfFont && g_defaultTtfFont->isLoaded())
        return g_defaultTtfFont->glyphSize(utf8char, charNum, ttf_fontSize);
#endif

    return PGE_Size(27 * 20, 1 * 20);
}

int FontManager::getFontID(std::string fontName)
{
    FontsHash::iterator i = g_fontNameToId.find(fontName);
    if(i == g_fontNameToId.end())
        return DefaultRaster;
    else
        return i->second;
}

PGE_Size FontManager::printText(const char* text, size_t text_size,
                                int x, int y,
                                int font,
                                XTColor color,
                                uint32_t ttf_FontSize, bool outline,
                                XTColor outline_color,
                                CropInfo* crop_info)
{
    if(!g_fontManagerIsInit)
        return PGE_Size(0, 0);

    if(!text || text_size == 0)
        return PGE_Size(0, 0);

    BaseFontEngine* font_engine = nullptr;

    if((font >= 0) && (static_cast<size_t>(font) < g_anyFonts.size()) && g_anyFonts[font])
    {
        if(g_anyFonts[font]->isLoaded())
            font_engine = g_anyFonts[font];
    }

    if(!font_engine)
    {
        switch(font)
        {
        case DefaultRaster:
            if(g_defaultRasterFont && g_defaultRasterFont->isLoaded())
            {
                font_engine = g_defaultRasterFont;
                break;
            } /*fallthrough*/
        case DefaultTTF_Font:
        default:
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
            if(g_defaultTtfFont && g_defaultTtfFont->isLoaded())
            {
                font_engine = g_defaultTtfFont;

                if(ttf_FontSize == 0)
                    ttf_FontSize = 14;
            }
#endif
            break;
        }

        if(!font_engine)
        {
            pLogWarning("Attempt to print text [%s] without any font being loaded", text);
            return PGE_Size(0, 0);
        }
    }

    if(outline)
    {
        // take square of Alpha to match blend of normal text
        uint8_t scaled_a = XTColor::mul(color.a, color.a);
        if(crop_info)
            crop_info->for_outline = true;

        font_engine->printText(text, text_size, x - 2, y, color.with_alpha(scaled_a) * outline_color, ttf_FontSize, crop_info);
        font_engine->printText(text, text_size, x + 2, y, color.with_alpha(scaled_a) * outline_color, ttf_FontSize, crop_info);
        font_engine->printText(text, text_size, x, y - 2, color.with_alpha(scaled_a) * outline_color, ttf_FontSize, crop_info);
        font_engine->printText(text, text_size, x, y + 2, color.with_alpha(scaled_a) * outline_color, ttf_FontSize, crop_info);

        if(crop_info)
            crop_info->for_outline = false;
    }

    return font_engine->printText(text, text_size, x, y, color, ttf_FontSize, crop_info);
}

PGE_Size FontManager::optimizeText(std::string &text, size_t max_columns)
{
    /****************Word wrap*********************/
    size_t  lastspace = 0;
    int     count = 1;
    size_t  maxWidth = 0;

    for(size_t x = 0, i = 0; i < text.size(); i++, x++)
    {
        switch(text[i])
        {
        case '\t':
        case ' ':
            lastspace = i;
            break;

        case '\n':
            lastspace = 0;
            if((maxWidth < x) && (maxWidth < max_columns))
                maxWidth = x;
            x = 0;
            count++;
            break;
        }

        if(x >= max_columns) //If lenght more than allowed
        {
            maxWidth = x;

            if(lastspace > 0)
            {
                text[lastspace] = '\n';
                i = lastspace - 1;
                lastspace = 0;
            }
            else
            {
                text.insert(i, 1, '\n');
                x = 0;
                count++;
            }
        }

        UTF8 uch = static_cast<unsigned char>(text[i]);
        i += static_cast<size_t>(trailingBytesForUTF8[uch]);
    }

    if(count == 1)
        maxWidth = text.length();

    /****************Word wrap*end*****************/

    return PGE_Size(count, static_cast<int>(maxWidth));
}


PGE_Size FontManager::printTextOptiCol(std::string text,
                                   int x, int y,
                                   size_t max_columns,
                                   int font,
                                   XTColor color,
                                   uint32_t ttf_FontSize)
{
    PGE_Size ret = FontManager::optimizeText(text, max_columns);
    FontManager::printText(text.c_str(), text.size(),
                           x, y,
                           font,
                           color,
                           ttf_FontSize);
    return ret;
}

PGE_Size FontManager::printTextOptiPx(std::string text,
                                  int x, int y,
                                  size_t max_pixels_lenght,
                                  int font,
                                  XTColor color,
                                  uint32_t ttf_FontSize)
{
    PGE_Size ret = FontManager::optimizeTextPx(text, max_pixels_lenght, font, ttf_FontSize);
    FontManager::printText(text.c_str(), text.size(),
                           x, y,
                           font,
                           color,
                           ttf_FontSize);
    return ret;
}

PGE_Size FontManager::optimizeTextPx(std::string& text,
                                     size_t max_pixels_lenght,
                                     int fontId,
                                     uint32_t ttf_FontSize)
{
    /****************Word wrap*********************/
    size_t  lastspace = 0;
    // int     count = 1;
    size_t  height = 0;
    size_t  maxWidth = 0;
    size_t  maxWidthAtSpace = 0;
    size_t  pixelWidth = 0;
    size_t  pixelWidthPrev = 0;
    BaseFontEngine *font = nullptr;
    PGE_Size gs;

    int line_h = 0;
    int line_h_at_space = 0;

    if((fontId < 0) || (static_cast<size_t>(fontId) >= g_anyFonts.size()) || !g_anyFonts[fontId])
        return PGE_Size(0, 0); // Invalid font

    font = g_anyFonts[fontId];

    for(size_t x = 0, i = 0; i < text.size(); i++, x++)
    {
        switch(text[i])
        {
        case '\t':
        case ' ':
            lastspace = i;
            maxWidthAtSpace = pixelWidth;
            gs = font->glyphSize(&text[i], x, ttf_FontSize);
            pixelWidthPrev = pixelWidth;
            pixelWidth += gs.w();

            if(line_h < gs.h())
                line_h = gs.h();

            line_h_at_space = line_h;

            break;

        case '\n':
            lastspace = 0;
            maxWidthAtSpace = 0;

            if((maxWidth < pixelWidth) && (maxWidth < max_pixels_lenght))
                maxWidth = pixelWidth;

            x = 0;
            pixelWidth = 0;
            pixelWidthPrev = 0;

            if(line_h < gs.h())
                line_h = gs.h();

            height += line_h;
            line_h = 0;

            // count++;
            break;

        default:
            pixelWidthPrev = pixelWidth;
            gs = font->glyphSize(&text[i], x, ttf_FontSize);
            pixelWidth += gs.w();

            if(line_h < gs.h())
                line_h = gs.h();

            break;
        }

        if(pixelWidth >= max_pixels_lenght) //If lenght more than allowed
        {
            // don't line break if the last character would exactly fill the last line (this is the SMBX 1.3 logic)
            if(pixelWidth == max_pixels_lenght && i + trailingBytesForUTF8[(UTF8)text[i]] + 1 == text.size())
            {
            }
            else if(lastspace > 0)
            {
                if(maxWidth < maxWidthAtSpace)
                    maxWidth = maxWidthAtSpace;
                text[lastspace] = '\n';
                i = lastspace - 1;
                lastspace = 0;
                line_h = line_h_at_space;
            }
            else
            {
                if(maxWidth < pixelWidthPrev)
                    maxWidth = pixelWidthPrev;
                text.insert(i, 1, '\n');
                x = 0;
                pixelWidth = 0;

                height += line_h;
                line_h = 0;
                // count++;
            }
        }

        UTF8 uch = static_cast<unsigned char>(text[i]);
        i += static_cast<size_t>(trailingBytesForUTF8[uch]);
    }

    height += line_h;

    if(maxWidth < pixelWidth)
        maxWidth = pixelWidth;

    /****************Word wrap*end*****************/

    return PGE_Size(maxWidth, height);
}

std::string FontManager::cropText(std::string text, size_t max_symbols)
{
    if(max_symbols == 0)
        return text;

    size_t utf8len = utf8_substrlen(text, max_symbols);
    if(text.size() > utf8len)
    {
        text.erase(utf8len, text.size() - utf8len);
        text.append("...");
    }

    return text;
}

bool FontManager::hasTtfSupport()
{
    return (bool)getDefaultTtfFont();
}


================================================
FILE: src/fontman/font_manager.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef FONT_MANAGER_H
#define FONT_MANAGER_H

#include "std_picture.h"
#include <Graphics/size.h>
#include <Utils/vptrlist.h>

#include <string>

#include "fontman/font_engine_base.h"
#include "fontman/crop_info.h"

namespace FontManager
{
/*
 * UTF-8 helpers
 */
size_t       utf8_strlen(const char *str);
size_t       utf8_strlen(const char *str, size_t len);
size_t       utf8_strlen(const std::string &str);
/**
 * @brief Get byte lenght from character lenght from begin to utf8len
 * @param str input UTF-8 string
 * @param utf8len Desireed character lenght
 * @return Byte-lenght of desired character lenght
 */
size_t       utf8_substrlen(const std::string &str, size_t utf8len);
std::string  utf8_substr(const std::string &str, size_t utf8_begin, size_t utf8_len);
const char*  utf8_skip_begin(const char *str, size_t utf8_begin);
void         utf8_pop_back(std::string &str);
void         utf8_erase_at(std::string &str, size_t begin);
void         utf8_erase_before(std::string &str, size_t end);

//! Fallback initialization of font rendering including only the fallback font
void initFallback();
//! Full initialization of font renderith include external fonts
void initFull();
//! De-Initialize font manager and clear memory
void quit();

/**
 * @brief Once language had been toggled, a different default TTF font may be chosen
 * \param lang Language code
 * \param country Country code (may be empty)
 */
void updateDefaultFontByLang(const std::string &lang, const std::string &country);

/*!
 * \brief List of UI metrics categories
 */
enum UIMetricsCategory
{
    Metrics_MenuMinLineHeight = 0,
    // FIXME: Implement other categories
};

/*!
 * \brief Gets the per language UI metrics value
 * \param category Metrics category index
 * \param lang Current language
 * \return Height in pixels
 */
int getMetricsValue(UIMetricsCategory category, const std::string &lang);

/**
 * @brief Attempts to load custom fonts for the episode and for the level
 */
void loadCustomFonts();

/**
 * @brief Removes all custom fonts completely
 */
void clearAllCustomFonts();

/**
 * @brief Removes all level-wide fonts, but keeps episode-wide fonts being loaded
 */
void clearLevelFonts();

/*!
 * \brief Checks if font manager works
 * \return true when manager actually works
 */
bool isInitied();

/*!
 * \brief Checks if font manager uses legacy fonts fallback
 * \return true when manager uses legacy fonts fallback
 */
bool isLegacy();

int fontIdFromSmbxFont(int font);
uint32_t fontSizeFromSmbxFont(int font);

/**
 * @brief Automatical font choice
 */
enum DefaultFont
{
    //! Using default TTF font
    DefaultTTF_Font = -2,
    //! Using default raster font
    DefaultRaster   = -1
};

/**
 * @brief Get pixel metrics of the text block
 * @param text Text fragment to measure
 * @param text_size The byte size of the text fragment to print
 * @param fontID Font-ID
 * @param ttfFontPixelSize Point size for the TTF fonts
 * @return
 */
PGE_Size textSize(const char *text, size_t text_size,
                  int       fontID,
                  uint32_t  ttfFontSize = 14);


/**
 * @brief Get the size of one glyph
 * @param utf8char The UTF-8 character to measure
 * @param charNum The row number of the character in the line (affects the size of tabulation)
 * @param fontId Font ID
 * @param ttf_fontSize Point size for the TTF fonts
 * @return
 */
PGE_Size glyphSize(const char *utf8char, uint32_t charNum, int fontId, uint32_t ttf_fontSize = 14);

/**
 * @brief Retreive Font-ID from the font name
 * @param fontName Name of the font
 * @return FontID key
 */
int      getFontID(std::string fontName);

/**
 * @brief Print the text fragment to the screen
 * @param text Text fragment to print
 * @param text_size The byte size of the text fragment to print
 * @param x X position on the screen
 * @param y Y position on the screen
 * @param font Font-ID
 * @param Red Red color level from 0.0 to 1.0
 * @param Green Green color level from 0.0 to 1.0
 * @param Blue Blue color level from 0.0 to 1.0
 * @param Alpha Alpha-channel level from 0.0 to 1.0
 * @param ttf_FontSize Point size for the TTF fonts, expected height of line (if non-zero) for raster fonts
 * @param outline Render using added outline
 * @param crop_info nullable pointer to info for crop (marquee) logic.
 * @return The size of text block in pixels
 */
PGE_Size printText(const char* text, size_t text_size,
                   int x, int y,
                   int font = DefaultRaster,
                   XTColor color = XTColor(),
                   uint32_t ttf_FontSize = 0, bool outline = false,
                   XTColor outline_color = {0, 0, 0},
                   CropInfo* crop_info = nullptr);

/**
 * @brief Optimize and print the text fragment to the screen
 * @param text Text fragment to print
 * @param x X position on the screen
 * @param y Y position on the screen
 * @param max_columns The maximum line length in characters (columns)
 * @param font The Font-ID
 * @param Red Red color level from 0.0 to 1.0
 * @param Green Green color level from 0.0 to 1.0
 * @param Blue Blue color level from 0.0 to 1.0
 * @param Alpha Alpha-channel level from 0.0 to 1.0
 * @param ttf_FontSize Point size for the TTF fonts
 * @return The size of text block in columns/rows
 */
PGE_Size printTextOptiCol(std::string text,
                          int x, int y,
                          size_t max_columns,
                          int font = DefaultRaster,
                          XTColor color = XTColor(),
                          uint32_t ttf_FontSize = 14);

/**
 * @brief Optimize and print the text fragment to the screen
 * @param text Text fragment to print
 * @param x X position on the screen
 * @param y Y position on the screen
 * @param max_pixels_lenght The maximum line length in pixels
 * @param font The Font-ID
 * @param Red Red color level from 0.0 to 1.0
 * @param Green Green color level from 0.0 to 1.0
 * @param Blue Blue color level from 0.0 to 1.0
 * @param Alpha Alpha-channel level from 0.0 to 1.0
 * @param ttf_FontSize Point size for the TTF fonts
 * @return The size of text block in pixels
 */
PGE_Size printTextOptiPx(std::string text,
                         int x, int y,
                         size_t max_pixels_lenght,
                         int font = DefaultRaster,
                         XTColor color = XTColor(),
                         uint32_t ttf_FontSize = 14);

/**
 * @brief Optimise the given text fragment to fit it into the given columns count.
 * @param [_inout] text Text to optimize
 * @param [_in]  max_columns The maximum line length in characters (columns)
 * @return Computed size of the printed text in columns and lines
 *
 * Suitable with monospace fonts.
 */
PGE_Size       optimizeText(std::string &text, size_t max_columns);

/**
 * @brief Optimise the given text fragment to fit it into the given pixels width
 * @param [_inout] text Text to optimize (the result will be writtein back to here)
 * @param [_in]  max_pixels_lenght The maximum line length in pixels
 * @param [_in]  fontId font ID
 * @return Computed pixels size of the printed text fragment
 *
 * Can be used with any kind of the font
 */
PGE_Size    optimizeTextPx(std::string &text,
                           size_t max_pixels_lenght,
                           int fontId,
                           uint32_t ttf_FontSize = 14);

/**
 * @brief Strip text outing of max count of symbols
 * @param text input text
 * @param max_symbols Maximal character count limit
 * @return Begin of string which is fit into desired lenght limit
 */
std::string     cropText(std::string text, size_t max_symbols);

/**
 * @brief Checks for TTF font support
 * @return True if any TTF font is loaded
 */
bool            hasTtfSupport();

} //namespace FontManager

#endif // FONT_MANAGER_H


================================================
FILE: src/fontman/font_manager_private.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "font_manager_private.h"

/*
 * Index into the table below with the first byte of a UTF-8 sequence to
 * get the number of trailing bytes that are supposed to follow it.
 * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
 * left as-is for anyone who may want to do such conversion, which was
 * allowed in earlier algorithms.
 */
const char trailingBytesForUTF8[256] =
{
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
};

/*
 * Magic values subtracted from a buffer value during UTF8 conversion.
 * This table contains as many values as there might be trailing bytes
 * in a UTF-8 sequence.
 */
const UTF32 offsetsFromUTF8[6] =
{
    0x00000000UL, 0x00003080UL, 0x000E2080UL,
    0x03C82080UL, 0xFA082080UL, 0x82082080UL
};

char32_t get_utf8_char(const char *str)
{
    const UTF8 *source = reinterpret_cast<const UTF8*>(str);
    UTF32 ch = 0;
    uint16_t extraBytesToRead = static_cast<uint16_t>(trailingBytesForUTF8[*source]);

    switch (extraBytesToRead)
    {
    case 5: ch += *source++; ch <<= 6; /*fallthrough*/ /* remember, illegal UTF-8 */
    case 4: ch += *source++; ch <<= 6; /*fallthrough*/ /* remember, illegal UTF-8 */
    case 3: ch += *source++; ch <<= 6; /*fallthrough*/
    case 2: ch += *source++; ch <<= 6; /*fallthrough*/
    case 1: ch += *source++; ch <<= 6; /*fallthrough*/
    case 0: ch += *source++; /*fallthrough*/
    }
    ch -= offsetsFromUTF8[extraBytesToRead];
    return static_cast<char32_t>(ch);
}

std::u32string std_to_utf32(const std::string &src)
{
    std::u32string dst_tmp;
    dst_tmp.resize(src.size());
    const UTF8* src_begin = reinterpret_cast<const UTF8*>(src.c_str());
    const UTF8* src_end   = src_begin + src.size();
    UTF32*      dst_begin = reinterpret_cast<UTF32*>(&dst_tmp[0]);
    UTF32*      dst_end   = dst_begin + dst_tmp.size();
    PGEFF_ConvertUTF8toUTF32(&src_begin, src_end, &dst_begin, dst_end, strictConversion);
    return std::u32string(reinterpret_cast<char32_t*>(&dst_tmp[0]));
}


================================================
FILE: src/fontman/font_manager_private.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef FONT_MANAGER_PRIVATE_H
#define FONT_MANAGER_PRIVATE_H

#include <PGE_File_Formats/ConvertUTF.h>
#include <stdint.h>
#include <string>

inline uint32_t char2int(const char32_t &ch)
{
    return static_cast<uint32_t>(ch - U'0');
}

/* //Currently unused, uncommend when it needed
static int char2int(const char& ch)
{
    return ch - '0';
}
*/

/*
 * Index into the table below with the first byte of a UTF-8 sequence to
 * get the number of trailing bytes that are supposed to follow it.
 * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
 * left as-is for anyone who may want to do such conversion, which was
 * allowed in earlier algorithms.
 */
extern const char trailingBytesForUTF8[256];

/*
 * Magic values subtracted from a buffer value during UTF8 conversion.
 * This table contains as many values as there might be trailing bytes
 * in a UTF-8 sequence.
 */
extern const UTF32 offsetsFromUTF8[6];

/**
 * @brief Get single UTF32 character from firs character of UTF8 string
 * @param str pointer to position on UTF8 string where need to find a character
 * @return UTF32 character
 */
extern char32_t get_utf8_char(const char *str);

/**
 * @brief Converts UTF8 string into UTF32 string
 * @param src Source string in UTF8
 * @return UTF32 string
 */
extern std::u32string std_to_utf32(const std::string &src);


class BaseFontEngine;
class TtfFont;

namespace FontManager
{
    TtfFont* getDefaultTtfFont();
    TtfFont* getTtfFontByName(const std::string &fontName);
}

#endif // FONT_MANAGER_PRIVATE_H


================================================
FILE: src/fontman/hardcoded_font.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <vector>

#include "fontman/hardcoded_font.h"

#include "core/render.h"

// The monochromic 1-bit texture of the 8x749 size
const std::array<uint8_t, 749> c_hardcoded_font_bytes =
{
    0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x00, 0x00, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x7E, 0x24,
    0x7E, 0x24, 0x00, 0x00, 0x00, 0x38, 0x6C, 0x3B, 0x6E, 0xC6, 0x7B, 0x00, 0x62, 0x66, 0x0C, 0x18, 0x30, 0x66, 0xC6, 0x00,
    0x00, 0x38, 0x6C, 0x3B, 0x6E, 0xC6, 0x7B, 0x00, 0x00, 0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x18, 0x18,
    0x18, 0x18, 0x0C, 0x00, 0x00, 0x18, 0x0C, 0x0C, 0x0C, 0x0C, 0x18, 0x00, 0x00, 0x6C, 0x7C, 0x38, 0x7C, 0x6C, 0x00, 0x00,
    0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x7E,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00, 0x00,
    0x00, 0x3C, 0x66, 0x6E, 0x76, 0x66, 0x3C, 0x00, 0x00, 0x18, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x3C, 0x66, 0x06,
    0x3C, 0x60, 0x7E, 0x00, 0x00, 0x3C, 0x66, 0x0C, 0x06, 0x66, 0x3C, 0x00, 0x00, 0x60, 0x6C, 0x6C, 0x7E, 0x0C, 0x0C, 0x00,
    0x00, 0x7E, 0x40, 0x7C, 0x06, 0x66, 0x3C, 0x00, 0x00, 0x3C, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x7E, 0x0C, 0x0C,
    0x18, 0x18, 0x18, 0x00, 0x00, 0x3C, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x3E, 0x06, 0x3C, 0x00,
    0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x10, 0x00, 0x00, 0x0C, 0x18, 0x30,
    0x18, 0x0C, 0x00, 0x00, 0x00, 0x3E, 0x3E, 0x00, 0x3E, 0x3E, 0x00, 0x00, 0x00, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x00, 0x00,
    0x00, 0x3C, 0x66, 0x06, 0x1C, 0x00, 0x18, 0x00, 0x00, 0x3C, 0x66, 0x6E, 0x6C, 0x60, 0x3E, 0x00, 0x00, 0x3C, 0x66, 0x66,
    0x7E, 0x66, 0x66, 0x00, 0x00, 0x7C, 0x66, 0x7C, 0x66, 0x66, 0x7C, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x60, 0x66, 0x3C, 0x00,
    0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x00, 0x00, 0x7E, 0x60, 0x78, 0x60, 0x60, 0x7E, 0x00, 0x00, 0x7E, 0x60, 0x78,
    0x60, 0x60, 0x60, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x6E, 0x66, 0x3C, 0x00, 0x00, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00,
    0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x3E, 0x0C, 0x0C, 0x0C, 0x6C, 0x38, 0x00, 0x00, 0x66, 0x6C, 0x78,
    0x78, 0x6C, 0x66, 0x00, 0x00, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7C, 0x00, 0x00, 0x63, 0x77, 0x7F, 0x6B, 0x63, 0x63, 0x00,
    0x00, 0x66, 0x76, 0x7E, 0x7E, 0x6E, 0x66, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x7C, 0x66, 0x66,
    0x7C, 0x60, 0x60, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x6C, 0x3A, 0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x00,
    0x00, 0x3C, 0x62, 0x3C, 0x06, 0x66, 0x3C, 0x00, 0x00, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x66, 0x66, 0x66,
    0x66, 0x66, 0x3C, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, 0x00, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00,
    0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x42, 0x00, 0x00, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x00, 0x00, 0x7E, 0x0C, 0x18,
    0x30, 0x60, 0x7E, 0x00, 0x00, 0x1C, 0x18, 0x18, 0x18, 0x18, 0x1C, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0C, 0x04, 0x00, 0x00,
    0x00, 0x1C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1C, 0x00, 0x1C, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x7E, 0x00, 0x00, 0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x66, 0x66, 0x66, 0x3B, 0x00,
    0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x00, 0x06, 0x06, 0x3E, 0x66,
    0x66, 0x66, 0x3E, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x7C, 0x60, 0x3E, 0x00, 0x00, 0x0E, 0x18, 0x3C, 0x18, 0x18, 0x18, 0x00,
    0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x3C, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x00, 0x18, 0x00, 0x18, 0x18,
    0x18, 0x18, 0x18, 0x00, 0x0C, 0x00, 0x0C, 0x0C, 0x0C, 0x0C, 0x6C, 0x38, 0x60, 0x60, 0x66, 0x7C, 0x78, 0x6C, 0x66, 0x00,
    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x1C, 0x00, 0x00, 0x00, 0xEC, 0xD6, 0xD6, 0xD6, 0xD6, 0x00, 0x00, 0x00, 0x7C, 0x66,
    0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60,
    0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x07, 0x06, 0x00, 0x00, 0x6C, 0x76, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x3C, 0x60,
    0x3C, 0x06, 0x7C, 0x00, 0x00, 0x30, 0x7C, 0x30, 0x30, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00,
    0x00, 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x6B, 0x6B, 0x6B, 0x6B, 0x37, 0x00, 0x00, 0x00, 0x66, 0x7E,
    0x3C, 0x7E, 0x66, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x3E, 0x06, 0x3C, 0x00, 0x00, 0x7E, 0x0C, 0x18, 0x30, 0x7E, 0x00,
    0x00, 0x0C, 0x18, 0x70, 0x18, 0x18, 0x0C, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x30, 0x18, 0x0E,
    0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x30, 0x5A, 0x0C
};

#ifdef __16M__

void LoadHardcodedFont(StdPicture& tx)
{
    tx.reset();

    tx.inited = true;
    tx.l.path = "!F";
    tx.l.lazyLoaded = true;

    tx.w = c_hardcoded_font_w * 2;
    tx.h = c_hardcoded_font_h * 2;
    tx.l.flags = 0;
}

#else // __16M__

void LoadHardcodedFont(StdPicture& tx)
{
    tx.reset();

    tx.w = c_hardcoded_font_w * 2;
    tx.h = c_hardcoded_font_h * 2;

    std::vector<uint32_t> image_data(c_hardcoded_font_bytes.size() * 8);

    auto i = c_hardcoded_font_bytes.cbegin();
    uint32_t* o = &image_data[0];

    while(i != c_hardcoded_font_bytes.cend())
    {
        uint8_t row = *(i++);
        *(o++) = (row & 0x80) ? 0xFFFFFFFF : 0;
        *(o++) = (row & 0x40) ? 0xFFFFFFFF : 0;
        *(o++) = (row & 0x20) ? 0xFFFFFFFF : 0;
        *(o++) = (row & 0x10) ? 0xFFFFFFFF : 0;
        *(o++) = (row & 0x08) ? 0xFFFFFFFF : 0;
        *(o++) = (row & 0x04) ? 0xFFFFFFFF : 0;
        *(o++) = (row & 0x02) ? 0xFFFFFFFF : 0;
        *(o++) = (row & 0x01) ? 0xFFFFFFFF : 0;
    }

    XRender::loadTexture(tx, c_hardcoded_font_w, c_hardcoded_font_h, (uint8_t*)image_data.data(), c_hardcoded_font_w * 4);
}

#endif // __16M__


================================================
FILE: src/fontman/hardcoded_font.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef HARDCODED_FONT_H
#define HARDCODED_FONT_H

#include <array>
#include <cstdint>

struct StdPicture;


// each byte is a row of the font, most significant bit is left
extern const std::array<uint8_t, 749> c_hardcoded_font_bytes;

static constexpr int c_hardcoded_font_w = 8;
static constexpr int c_hardcoded_font_h = 749; // 752 including padding
static constexpr int c_hardcoded_font_h_pow2 = 1024;

void LoadHardcodedFont(StdPicture& tx);

#endif // #ifndef HARDCODED_FONT_H


================================================
FILE: src/fontman/legacy_font.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>
#include "sdl_proxy/sdl_stdinc.h"

#include "hardcoded_font.h"

#include "legacy_font.h"
#include "gfx.h"
#include "std_picture.h"
#include "core/render.h"
#include "font_manager_private.h"

#if defined(_MSC_VER) && _MSC_VER <= 1900 // Workaround for MSVC 2015
namespace std
{
    using ::toupper;
}
#endif


LegacyFont::LegacyFont(int legacyFontId)
{
    loadFont(legacyFontId);
}

LegacyFont::~LegacyFont()
{
    m_charMap.clear();
    SDL_memset(m_textures, 0, sizeof(m_textures));
}

void LegacyFont::loadFont(int fontId)
{
    m_charMap.clear();
    SDL_memset(m_textures, 0, sizeof(m_textures));

    switch(fontId)
    {
    default:
    case 1: // Numbers font
        m_glyphWidth = 18;
        m_glyphHeight = 16;

        for(int i = 0; i <= 9; ++i)
        {
            char uchar[5] = {static_cast<char>('0' + i), 0, 0, 0, 0};
            m_textures[i] = &GFX.Font1[i];

            RasChar c;
            c.texId = i;
            c.tX = 0;
            c.tY = 0;
            c.tW = 16;
            c.tH = 14;
            c.width = 18;
            c.valid = true;

            m_charMap.insert({get_utf8_char(uchar), std::move(c)});
        }

        m_isReady = true;
        m_fontName = "numeric";
        break;

    case 2: // World map level title font
        m_glyphWidth = 16;
        m_glyphHeight = 18;

        m_textures[0] = &GFX.Font2[1];
        m_textures[1] = &GFX.Font2S;

        for(char c = 33; c <= 125; ++c)
        {
            char uchar[5] = {c, 0, 0, 0, 0};
            RasChar cc;
            cc.texId = 0;
            cc.tY = 0;
            cc.tW = 15;
            cc.tH = 17;
            cc.width = 16;

            if(c >= 48 && c <= 57)
            {
                cc.tX = (c - 48) * 16;
                cc.texId = 0;
            }
            else if(c >= 65 && c <= 90)
            {
                cc.tX = (c - 55) * 16;
                cc.texId = 0;
            }
            else if(c >= 97 && c <= 122)
            {
                cc.tX = (c - 61) * 16;
                cc.texId = 0;
            }
            else if(c >= 33 && c <= 47)
            {
                cc.tX = (c - 33) * 16;
                cc.texId = 1;
            }
            else if(c >= 58 && c <= 64)
            {
                cc.tX = (c - 58 + 15) * 16;
                cc.texId = 1;
            }
            else if(c >= 91 && c <= 96)
            {
                cc.tX = (c - 91 + 22) * 16;
                cc.texId = 1;
            }
            else if(c >= 123 && c <= 125)
            {
                cc.tX = (c - 123 + 28) * 16;
                cc.texId = 1;
            }

            cc.valid = true;

            m_charMap.insert({get_utf8_char(uchar), std::move(cc)});
        }

        m_isReady = true;
        m_fontName = "font3";
        break;

    case 3: // Menu font
        m_glyphWidth = 16;
        m_glyphHeight = 18;

        m_textures[0] = &GFX.Font2[2];

        for(char c = 33; c <= 126; ++c)
        {
            char ucharH[5] = {c, 0, 0, 0, 0};
            char ucharL[5] = {static_cast<char>(std::tolower(c)), 0, 0, 0, 0};

            RasChar cc;
            cc.texId = 0;
            cc.tX = 2;
            cc.tY = (c - 33) * 32;
            cc.tW = 18;
            cc.tH = 16;
            cc.width = 18;

            if(c == 'M')
                cc.width += 2;

            cc.valid = true;

            m_charMap.insert({get_utf8_char(ucharH), cc});
            m_charMap.insert({get_utf8_char(ucharL), std::move(cc)});
        }

        m_isReady = true;
        m_fontName = "font1";
        break;

    case 4: // Message box font
        m_glyphWidth = 18;
        m_glyphHeight = 18;

        m_textures[0] = &GFX.Font2[3];

        for(char c = 33; c <= 126; ++c)
        {
            char ucharL[5] = {c, 0, 0, 0, 0};

            RasChar cc;
            cc.texId = 0;
            cc.tX = 0;
            cc.tY = (c - 33) * 16;
            cc.tW = 18;
            cc.tH = 16;
            cc.width = 18;

            if(c == 'M')
                cc.width += 2;

            cc.valid = true;

            m_charMap.insert({get_utf8_char(ucharL), cc});
        }

        m_isReady = true;
        m_fontName = "font2";
        break;
    }
}

PGE_Size LegacyFont::glyphSize(const char* utf8char, uint32_t charNum, uint32_t /*fontSize*/)
{
    PGE_Size ret(0, m_glyphHeight);
    const char &cx = utf8char[0];

    switch(cx)
    {
    case '\n':
    case '\r':
        break; // Has no lenght

    case '\t':
    {
        size_t spaceSize = m_glyphWidth;
        if(spaceSize == 0)
            spaceSize = 1; // Don't divide by zero
        size_t tabMult = 4 - ((charNum / spaceSize) % 4);
        ret.setWidth(static_cast<size_t>(m_glyphWidth) * tabMult);
        break;
    }

    case ' ':
    {
        ret.setWidth(m_glyphWidth);
        break;
    }

    default:
    {
        CharMap::iterator rc = m_charMap.find(get_utf8_char(&cx));
        if(rc != m_charMap.end())
        {
            RasChar &rch = rc->second;
            ret.setWidth(rch.valid ? rch.width : m_glyphWidth);
        }
        else
            ret.setWidth(m_glyphWidth);

        break;
    }

    }//Switch

    return ret;
}

PGE_Size LegacyFont::printText(const char* text, size_t text_size, int32_t x, int32_t y,
                               XTColor color,
                               uint32_t /*fontSize*/,
                               CropInfo* crop_info)
{
    if(m_charMap.empty() || !text || text_size == 0)
        return PGE_Size(0, 0);

    // load fallback texture if needed
    if(m_textures[0] == &GFX.Font2[3] && !m_textures[0]->d.hasTexture())
        LoadHardcodedFont(*m_textures[0]);

    int32_t  offsetX = (crop_info) ? -crop_info->offset : 0;
    uint32_t offsetY = 0;

    int32_t  offsetX_max = 0;

    uint8_t letter_alpha = color.a;

    const char *strIt  = text;
    const char *strEnd = strIt + text_size;
    for(; strIt < strEnd; strIt++)
    {
        const char &cx = *strIt;
        const char *fch = "?";
        UTF8 ucx = static_cast<unsigned char>(cx);

        switch(cx)
        {
        case '\n':
            if(offsetX > offsetX_max)
                offsetX_max = offsetX;

            offsetX = (crop_info) ? -crop_info->offset : 0;
            offsetY += m_glyphHeight;
            continue;

        case '\t':
            // Fake tabulation
            offsetX += offsetX + offsetX % m_glyphWidth;
            continue;

        case ' ':
            offsetX += m_glyphWidth;
            continue;
        }

        auto rch_f = m_charMap.find(get_utf8_char(strIt));
        if(rch_f == m_charMap.end())
            rch_f = m_charMap.find(get_utf8_char(fch));

        if(rch_f != m_charMap.end() && rch_f->second.valid)
        {
            const RasChar &rch = rch_f->second;

            if(crop_info)
            {
                if(!crop_info->letter_alpha(letter_alpha, color.a, offsetX, offsetX + rch.width))
                    break;
            }

            if(letter_alpha != 0)
            {
                XRender::renderTextureBasic(x + static_cast<int32_t>(offsetX),
                                       y + static_cast<int32_t>(offsetY),
                                       rch.tW, rch.tH,
                                       *m_textures[rch.texId],
                                       rch.tX, rch.tY,
                                       color.with_alpha(letter_alpha));
            }

            offsetX += rch.width;
        }
        else
            offsetX += m_glyphWidth;

        strIt += static_cast<size_t>(trailingBytesForUTF8[ucx]);
    }

    if(offsetX > offsetX_max)
        offsetX_max = offsetX;

    if(offsetX > 0)
        offsetY += m_glyphHeight;

    return PGE_Size(offsetX_max, offsetY);
}

bool LegacyFont::isLoaded() const
{
    return m_isReady;
}

std::string LegacyFont::getFontName() const
{
    return m_fontName;
}

BaseFontEngine::FontType LegacyFont::getFontType() const
{
    return FONT_LEGACY;
}


================================================
FILE: src/fontman/legacy_font.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LEGACYFONT_H
#define LEGACYFONT_H

#ifdef LOW_MEM
#   include <map>
#else
#   include <unordered_map>
#endif
#include "font_engine_base.h"

struct StdPicture;

/**
 * @brief Implementation of the legacy SMBX font engine as a part of the modern font engine
 */
class LegacyFont final : public BaseFontEngine
{
public:
    explicit LegacyFont(int legacyFontId);
    LegacyFont(const LegacyFont &rf) = delete;
    LegacyFont &operator=(const LegacyFont &tf) = delete;
    LegacyFont(LegacyFont &&tf) = default;

    virtual ~LegacyFont() override;

    void loadFont(int fontId);

    /*!
     * \brief Get a size of one glyph
     * \param utf8char Pointer to one UTF-8 character
     * \param charNum Character number in the line (required to compute the size of the taboluation)
     * \param fontSize Size of TTF font glyph
     * \return Width and height of one glyph in pixels
     */
    PGE_Size glyphSize(const char *utf8char, uint32_t charNum = 0, uint32_t fontSize = 14) override;

    /*!
     * \brief Print the multiline text block on the screen
     * \param text Multi-line text string
     * \param text_size The byte size of the text string to print
     * \param x Hotizontal screen position (at left-top corner of the block)
     * \param y Vertical screen position (at left-top corner of the block)
     * \param Red Red channel colour
     * \param Green Green channel colour
     * \param Blue Blue channel colour
     * \param Alpha Alpha channel level (does not issue render calls if Alpha is 0)
     * \param fontSize The size of the TTF font glyph (unused for raster fonts)
     * \param crop_info nullable pointer to info for crop (marquee) logic
     * \return Width and height of the text block in pixels
     */
    PGE_Size printText(const char* text, size_t text_size,
                       int32_t x, int32_t y,
                       XTColor color = XTColor(),
                       uint32_t fontSize = 0,
                       CropInfo* crop_info = nullptr) override;

    bool isLoaded() const override;

    std::string getFontName() const override;
    FontType getFontType() const override;

private:
    //! font is fine
    bool m_isReady = false;

    //! Handalable name of the font
    std::string m_fontName;

    //! Bank of legacy font textures
    StdPicture *m_textures[10];

    /**
     * @brief Raster font glyph
     */
    struct RasChar
    {
        uint8_t  texId = 0; //!< Texture index in m_textures array
        bool     valid = false; //!< Is a valid glyph
        uint16_t tX = 0; //!< Horizontal pixel offset on texture
        uint16_t tY = 0; //!< Vertical pixel offset on texture
        uint8_t  tW = 0; //!< Pixels width of the texture fragment
        uint8_t  tH = 0; //!< Pixels height of the texture fragment
        uint8_t  width = 0; //!< Width of glyph
    };

    //! Fallback width of glyph
    uint32_t m_glyphWidth = 0;

    //! Height of glyph
    uint32_t m_glyphHeight = 0;

#ifdef LOW_MEM
    typedef std::map<char32_t, RasChar > CharMap;
#else
    typedef std::unordered_map<char32_t, RasChar > CharMap;
#endif

    //! Table of available characters
    CharMap m_charMap;

};

#endif // LEGACYFONT_H


================================================
FILE: src/fontman/raster_font.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <inttypes.h>
#include "raster_font.h"

#include "../core/render.h"

#include "sdl_proxy/sdl_stdinc.h"
#include <fmt_format_ne.h>
#include <Logger/logger.h>
#include <IniProcessor/ini_processing.h>
#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <DirManager/dirman.h>

#ifdef THEXTECH_ENABLE_TTF_SUPPORT
#include "ttf_font.h"
#endif
#include "font_manager_private.h"


RasterFont::RasterFont() : BaseFontEngine()
{
    static uint64_t fontNumberCount = 0;//This number will be used as default font name
    m_letterWidth    = 0;
    m_letterHeight   = 0;
    m_spaceWidth     = 0;
    m_interLetterSpace = 0;
    m_newlineOffset  = 0;
    m_glyphOffsetX   = 0;
    m_glyphOffsetY   = 0;
    m_matrixWidth    = 0;
    m_matrixHeight   = 0;
    m_isReady        = false;
    m_ttfOutlines    = false;
    m_fontName       = fmt::format_ne("font{0}", fontNumberCount++);
}

RasterFont::~RasterFont()
{
    m_texturesBank.clear();
}

void RasterFont::loadFont(const std::string &font_ini)
{
    if(!Files::fileExists(font_ini))
    {
        pLogWarning("Can't load font %s: file not exist", font_ini.c_str());
        return;
    }

    std::string root = DirMan(Files::dirname(font_ini)).absolutePath() + "/";
    IniProcessing font = Files::load_ini(font_ini);

// FIXME: Define it at CMake rather than here
#if defined(__3DS__) || defined(__WII__) || defined(__16M__)
#   define THEXTECH_USE_1X_FONT_MODE
#endif

    uint32_t ttfColourPacked = 0x000000FF;
    uint32_t ttfOutlinesColourPacked = 0x000000FF;

    size_t tables = 0;
    font.beginGroup("font");
    font.read("tables", tables, 0);
    font.read("name", m_fontName, m_fontName);
    font.read("ttf-outlines", m_ttfOutlines, false);
    font.read("ttf-colour", ttfColourPacked, 0xFFFFFFFF);
    font.read("ttf-outlines-colour", ttfOutlinesColourPacked, 0x000000FF);
    font.read("ttf-fallback", m_ttfFallback, std::string());
    font.read("ttf-size", m_ttfSize, -1);
#if defined(THEXTECH_USE_1X_FONT_MODE) // Use special fonts targeted to smaller screen resolutions
    font.read("ttf-fallback-1x", m_ttfFallback, m_ttfFallback);
    font.read("ttf-size-1x", m_ttfSize, m_ttfSize);
#endif
    font.read("space-width", m_spaceWidth, 0);
    font.read("interletter-space", m_interLetterSpace, 0);
    font.read("newline-offset", m_newlineOffset, 0);
    font.read("glyph-offset-x", m_glyphOffsetX, 0);
    font.read("glyph-offset-y", m_glyphOffsetY, 0);
    font.endGroup();

    std::vector<std::string> tables_list;
    tables_list.reserve(tables);

    m_ttfColour.r = (ttfColourPacked >> 24) & 0xFF;
    m_ttfColour.g = (ttfColourPacked >> 16) & 0xFF;
    m_ttfColour.b = (ttfColourPacked >> 8) & 0xFF;
    m_ttfColour.a = (ttfColourPacked >> 0) & 0xFF;

    m_ttfOutlinesColour.r = (ttfOutlinesColourPacked >> 24) & 0xFF;
    m_ttfOutlinesColour.g = (ttfOutlinesColourPacked >> 16) & 0xFF;
    m_ttfOutlinesColour.b = (ttfOutlinesColourPacked >> 8) & 0xFF;
    m_ttfOutlinesColour.a = (ttfOutlinesColourPacked >> 0) & 0xFF;

    font.beginGroup("tables");

    for(size_t i = 1; i <= tables; i++)
    {
        std::string table;
        font.read(fmt::format_ne("table{0}", i).c_str(), table, "");
        if(!table.empty())
            tables_list.push_back(table);
    }

    font.endGroup();

    for(std::string &tbl : tables_list)
        loadFontMap(root + tbl);

    pLogDebug("Loaded raster font with name: [%s]", m_fontName.c_str());
}

void RasterFont::loadFontMap(const std::string& fontmap_ini)
{
    std::string root = DirMan(Files::dirname(fontmap_ini)).absolutePath() + "/";

    if(!Files::fileExists(fontmap_ini))
    {
        pLogWarning("Can't load font map %s: file not exist", fontmap_ini.c_str());
        return;
    }

    IniProcessing font = Files::load_ini(fontmap_ini);
    std::string texFile;
    uint32_t w = m_letterWidth, h = m_letterHeight;
    int texture_scale_factor;
    font.beginGroup("font-map");
    font.read("texture", texFile, "");
    font.read("texture-scale", texture_scale_factor, 1);
    font.read("width", w, 0);
    font.read("height", h, 0);
    m_matrixWidth = w;
    m_matrixHeight = h;

    if((w <= 0) || (h <= 0))
    {
        pLogWarning("Wrong width and height values! %" PRId32 " x %" PRId32 "",  w, h);
        return;
    }

    if(!Files::fileExists(root + texFile))
    {
        pLogWarning("Failed to load font texture! file not exists: %s",
                    (root + texFile).c_str());
        return;
    }

    m_texturesBank.emplace_back();
    StdPicture &fontTexture = m_texturesBank.back();

    XRender::LoadPicture(fontTexture, root + texFile, texture_scale_factor);

    if(!fontTexture.inited)
        pLogWarning("Failed to load font texture! Invalid image!");

    if((m_letterWidth == 0) || (m_letterHeight == 0))
    {
        m_letterWidth    = static_cast<uint32_t>(fontTexture.w) / w;
        m_letterHeight   = static_cast<uint32_t>(fontTexture.h) / h;

        if(m_spaceWidth == 0)
            m_spaceWidth = m_letterWidth;

        if(m_newlineOffset == 0)
            m_newlineOffset = m_letterHeight;
    }

    font.endGroup();
    font.beginGroup("entries");
    std::vector<std::string> entries = font.allKeys();

    for(std::string &x : entries)
    {
        std::string charPosX = "0", charPosY = "0";

        std::string::size_type begPos = 0;
        std::string::size_type endPos = x.find('-', begPos);

        //QStringList tmp = x.split('-');
        if(endPos == std::string::npos)
            endPos = x.size();//Use entire string

        charPosX = x.substr(begPos, endPos);

        if(charPosX.empty())
        {
            pLogDebug("=invalid-X=%s=", x.c_str());
            continue;
        }

        if(m_matrixWidth > 1)
        {
            if(endPos == x.size())
            {
                pLogWarning("=invalid-Y=%s= in the raster font map %s", x.c_str(), fontmap_ini.c_str());
                continue;
            }
            begPos = endPos + 1;//+1 to skip '-' divider
            endPos = x.find('-', begPos);
            if(endPos == std::string::npos)
                endPos = x.size();//Use entire string
            charPosY = x.substr(begPos, endPos);
            if(charPosY.empty())
            {
                pLogWarning("=invalid-Y=%s= in the raster font map %s", x.c_str(), fontmap_ini.c_str());
                continue;
            }
        }

        std::string charX;
        font.read(x.c_str(), charX, "");

        /*Format of entry: X23
         * X - UTF-8 Symbol
         * 2 - padding left [for non-mono fonts]
         * 3 - padding right [for non-mono fonts]
        */
        if(charX.empty())
            continue;

        std::u32string ucharX = std_to_utf32(charX);
        char32_t ch = ucharX[0];
        //qDebug()<<"=char=" << ch << "=id="<<charPosX.toInt()<<charPosY.toInt()<<"=";
        RasChar rch;
        try
        {
            rch.tx              =  &fontTexture;
            rch.x               =  static_cast<int16_t>(std::stoi(charPosY.c_str()) * fontTexture.w / m_matrixWidth);
            rch.padding_left    = (ucharX.size() > 1) ? char2int(ucharX[1]) : 0;
            rch.padding_right   = (ucharX.size() > 2) ? char2int(ucharX[2]) : 0;
            rch.y               =  static_cast<int16_t>(std::stoi(charPosX.c_str()) * fontTexture.h / m_matrixHeight);
            rch.valid = true;
        }
        catch(std::exception &e)
        {
            pLogWarning("Invalid entry of font map: entry: %s, reason: %s, file: %s", x.c_str(), e.what(), fontmap_ini.c_str());
        }

        m_charMap[ch] = rch;
    }

    font.endGroup();

    if(!m_charMap.empty())
        m_isReady = true;
}


PGE_Size RasterFont::glyphSize(const char* utf8char, uint32_t charNum, uint32_t /*fontSize*/)
{
    PGE_Size ret(0, m_newlineOffset);
    const char &cx = utf8char[0];

    switch(cx)
    {
    case '\n':
    case '\r':
        break; // Has no lenght

    case '\t':
    {
        size_t spaceSize = m_spaceWidth;
        if(spaceSize == 0)
            spaceSize = 1; // Don't divide by zero
        size_t tabMult = 4 - ((charNum / spaceSize) % 4);
        ret.setWidth(static_cast<size_t>(spaceSize) * tabMult);
        ret.setHeight(m_newlineOffset);
        break;
    }

    case ' ':
    {
        ret.setWidth(m_spaceWidth);
        ret.setHeight(m_newlineOffset);
        break;
    }

    default:
    {
        CharMap::iterator rc = m_charMap.find(get_utf8_char(&cx));
        bool need_a_ttf = false;
        if(rc != m_charMap.end())
        {
            RasChar &rch = rc->second;
            need_a_ttf = !rch.valid;
            if(rch.valid)
                ret.setWidth(m_letterWidth - rch.padding_left - rch.padding_right + m_interLetterSpace);
        }
        else
            need_a_ttf = true;

        if(need_a_ttf)
        {
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
            TtfFont *font = FontManager::getTtfFontByName(m_ttfFallback);
            if(font)
            {
                uint32_t font_size_use = m_ttfSize > 0 ? m_ttfSize : m_letterWidth;
                // int y_offset = 0; // UNUSED
                bool doublePixel = font->doublePixel();

                if(font->bitmapSize())
                {
                    if(font_size_use > font->bitmapSize() * 1.5)
                        doublePixel = true;

                    font_size_use = font->bitmapSize();
                }
                else if(doublePixel)
                    font_size_use /= 2;

                TtfFont::TheGlyphInfo glyph = font->getGlyphInfo(&cx, font_size_use);
                uint32_t glyph_width = glyph.width > 0 ? uint32_t(glyph.advance_x >> 6) : (font_size_use >> 2);
                uint32_t glyph_height = glyph.height;
                if(doublePixel)
                {
                    glyph_width *= 2;
                    glyph_height *= 2;
                }

                // Raster fonts are monospace fonts. TTF glyphs shoudn't break mono-width until they are wider than a cell
                auto lw = SDL_max(glyph_width, m_letterWidth);
                ret.setWidth(lw + m_interLetterSpace);
                ret.setHeight(glyph_height + 2);
            }
            else
#endif
            {
                ret.setWidth(m_letterWidth + m_interLetterSpace);
                ret.setHeight(m_newlineOffset);
            }
        }

        break;
    }

    }//Switch

    return ret;
}

PGE_Size RasterFont::printText(const char* text, size_t text_size,
                               int32_t x, int32_t y,
                               XTColor color,
                               uint32_t fontSize,
                               CropInfo* crop_info)
{
    if(m_charMap.empty() || !text || text_size == 0)
        return PGE_Size(0, 0);

    int32_t  offsetX = (crop_info) ? -crop_info->offset : 0;
    uint32_t offsetY = 0;
    uint32_t w = m_letterWidth;
    uint32_t h = m_letterHeight;

    uint32_t line_offset = m_newlineOffset;

    int32_t  offsetX_max = 0;

    uint8_t letter_alpha = color.a;

    const char *strIt  = text;
    const char *strEnd = strIt + text_size;
    for(; strIt < strEnd; strIt++)
    {
        const char &cx = *strIt;
        UTF8 ucx = static_cast<unsigned char>(cx);

        switch(cx)
        {
        case '\n':
            if(offsetX > offsetX_max)
                offsetX_max = offsetX;

            offsetX = (crop_info) ? -crop_info->offset : 0;
            offsetY += line_offset;
            line_offset = m_newlineOffset;
            continue;

        case '\t':
            //Fake tabulation
            offsetX += offsetX + offsetX % w;
            continue;

        case ' ':
            offsetX += m_spaceWidth;
            continue;
        }

        const auto rch_f = m_charMap.find(get_utf8_char(strIt));
        if(rch_f != m_charMap.end() && rch_f->second.valid)
        {
            const auto &rch = rch_f->second;

            int drawn_width = w - rch.padding_left - rch.padding_right;

            if(crop_info)
            {
                if(!crop_info->letter_alpha(letter_alpha, color.a, offsetX, offsetX + drawn_width))
                    break;
            }

            if(letter_alpha != 0)
            {
                XRender::renderTextureBasic(x + static_cast<int32_t>(offsetX - rch.padding_left + m_glyphOffsetX),
                                       y + static_cast<int32_t>(offsetY + m_glyphOffsetY),
                                       w, h,
                                       *rch.tx,
                                       rch.x, rch.y,
                                       color.with_alpha(letter_alpha));
            }

            offsetX += drawn_width + m_interLetterSpace;
        }
        else
#ifdef THEXTECH_ENABLE_TTF_SUPPORT
        {
            TtfFont *font = FontManager::getTtfFontByName(m_ttfFallback);
            if(font)
            {
                uint32_t font_size_use = (m_ttfSize > 0) ? m_ttfSize : m_letterWidth;

                int y_offset = 0;
                int baseline = h;
                bool doublePixel = font->doublePixel();

                if(font->bitmapSize())
                {
                    if(font->doublePixel() || font_size_use > font->bitmapSize() * 1.5)
                        doublePixel = true;

                    if(fontSize == 0)
                        y_offset = 0;
                    else if(doublePixel)
                    {
                        y_offset = ((int)fontSize - (font->bitmapSize() * 2)) / 2;
                        baseline += - (h / 2) + font->bitmapSize();
                    }
                    else
                    {
                        y_offset = ((int)fontSize - font->bitmapSize()) / 2;
                        baseline += - (h / 2) + (font->bitmapSize() / 2);
                    }

                    font_size_use = font->bitmapSize();
                }
                else if(doublePixel)
                    font_size_use /= 2;

                TtfFont::TheGlyphInfo glyph = font->getGlyphInfo(&cx, font_size_use);
                uint32_t glyph_width = glyph.width > 0 ? uint32_t(glyph.advance_x >> 6) : (font_size_use >> 2);
                uint32_t glyph_height = glyph.height;

                if(doublePixel)
                {
                    glyph_width *= 2;
                    glyph_height *= 2;
                }

                if(glyph_height + 2 > line_offset)
                    line_offset = glyph_height + 2;

                if(m_ttfOutlines)
                    offsetX += (doublePixel ? 2 : 1);

                int drawn_width = SDL_max(glyph_width, m_letterWidth);

                if(crop_info)
                {
                    if(!crop_info->letter_alpha(letter_alpha, color.a, offsetX, offsetX + drawn_width))
                        break;
                }

                if(letter_alpha != 0)
                {
                    font->drawGlyphB(&cx,
                                    x + static_cast<int32_t>(offsetX + m_glyphOffsetX),
                                    y + baseline + y_offset + static_cast<int32_t>(offsetY),
                                    font_size_use,
                                    (doublePixel ? 2 : 1),
                                    m_ttfOutlines,
                                    (color * m_ttfColour).with_alpha(letter_alpha),
                                    m_ttfOutlinesColour);
                }

                offsetX += drawn_width + m_interLetterSpace;
            }
            else
            {
                offsetX += m_letterWidth + m_interLetterSpace;
            }
        }
#else
        {
            UNUSED(fontSize);
            offsetX += m_interLetterSpace;
        }
#endif
        strIt += static_cast<size_t>(trailingBytesForUTF8[ucx]);
    }

    if(offsetX > offsetX_max)
        offsetX_max = offsetX;

    // remove trailing space
    if(offsetX_max > (int32_t)m_interLetterSpace)
        offsetX_max -= m_interLetterSpace;

    // add current line
    if(offsetX > 0)
        offsetY += m_newlineOffset;

    return PGE_Size(offsetX_max, offsetY);
}

bool RasterFont::isLoaded() const
{
    return m_isReady;
}

std::string RasterFont::getFontName() const
{
    return m_fontName;
}

BaseFontEngine::FontType RasterFont::getFontType() const
{
    return FONT_RASTER;
}


================================================
FILE: src/fontman/raster_font.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef RASTER_FONT_H
#define RASTER_FONT_H

#include <string>
#ifdef LOW_MEM
#   include <map>
#else
#   include <unordered_map>
#endif
#include <Utils/vptrlist.h>
#include "std_picture.h"
#include <Graphics/size.h>

#include "font_engine_base.h"

/**
 * @brief The raster fonts engine
 */
class RasterFont final : public BaseFontEngine
{
public:
    RasterFont();
    RasterFont(const RasterFont &rf) = delete;
    RasterFont &operator=(const RasterFont &tf) = delete;
    RasterFont(RasterFont &&tf) = default;

    virtual ~RasterFont() override;

    void  loadFont(const std::string& font_ini);
    void  loadFontMap(const std::string &fontmap_ini);

    /*!
     * \brief Get a size of one glyph
     * \param utf8char Pointer to one UTF-8 character
     * \param charNum Character number in the line (required to compute the size of the taboluation)
     * \param fontSize Size of TTF font glyph
     * \return Width and height of one glyph in pixels
     */
    PGE_Size glyphSize(const char *utf8char, uint32_t charNum = 0, uint32_t fontSize = 14) override;

    /*!
     * \brief Print the multiline text block on the screen
     * \param text Multi-line text string
     * \param text_size The byte size of the text string to print
     * \param x Hotizontal screen position (at left-top corner of the block)
     * \param y Vertical screen position (at left-top corner of the block)
     * \param Red Red channel colour
     * \param Green Green channel colour
     * \param Blue Blue channel colour
     * \param Alpha Alpha channel level (does not issue render calls if Alpha is 0)
     * \param fontSize The size of the TTF font glyph (used for line height if non-zero for raster fonts)
     * \param crop_info nullable pointer to info for crop (marquee) logic
     * \return Width and height of the text block in pixels
     */
    PGE_Size printText(const char* text, size_t text_size,
                       int32_t x, int32_t y,
                       XTColor color = XTColor(),
                       uint32_t fontSize = 0,
                       CropInfo* crop_info = nullptr) override;

    bool isLoaded() const override;

    std::string getFontName() const override;
    FontType getFontType() const override;

private:
    //! font is fine
    bool m_isReady = false;
    //! The fallback TTF name to prefer to render a missing character [all unknown characters will be rendered as TTF]
    std::string m_ttfFallback;
    //! Colour for backup ttf font render
    XTColor m_ttfColour = {255, 255, 255, 255};
    //! Enable outline borders on backup ttf font render
    bool m_ttfOutlines = false;
    XTColor m_ttfOutlinesColour = {0, 0, 0, 255};
    //! The fallback TTF size of the glyph to request
    int  m_ttfSize = -1;
    //! Width of one letter
    uint32_t m_letterWidth = 0;
    //! Height of one letter
    uint32_t m_letterHeight = 0;
    //! Space between printing letters
    int32_t m_interLetterSpace = 0;
    //! Width of space symbol
    uint32_t m_spaceWidth = 0;
    //! Distance between top of one line and top of next
    uint32_t m_newlineOffset = 0;

    //! Offset all characters by X
    int32_t m_glyphOffsetX = 0;
    //! Offset all characters by Y
    int32_t m_glyphOffsetY = 0;

    //! Width of font matrix
    uint32_t m_matrixWidth = 0;
    //! Width of font matrix
    uint32_t m_matrixHeight = 0;

    //! Handalable name of the font
    std::string m_fontName;

    /**
     * @brief Raster font glyph
     */
    struct RasChar
    {
        bool        valid = false; //!< Is a valid glyph
        StdPicture* tx     = nullptr; //!< Pointer to the texture that contains this glyph
        uint8_t     padding_left    = 0; //!< Crop left
        uint8_t     padding_right   = 0; //!< Crop right
        int16_t     x = 0; //!< X pixel offset
        int16_t     y = 0; //!< Y pixel offset
    };

#ifdef LOW_MEM
    typedef std::map<char32_t, RasChar > CharMap;
#else
    typedef std::unordered_map<char32_t, RasChar > CharMap;
#endif

    //! Table of available characters
    CharMap m_charMap;

    //! Bank of loaded textures
    VPtrList<StdPicture> m_texturesBank;
};

#endif // RASTER_FONT_H


================================================
FILE: src/fontman/ttf_font.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <inttypes.h>
#include <SDL2/SDL_rwops.h>
#include <Utils/files.h>
#include <Utils/strings.h>

#include "ttf_font.h"
#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_assert.h"
#if !defined(PGE_NO_THREADING)
#   ifdef PGE_SDL_MUTEX
#       include <SDL2/SDL_mutex.h>
#   else
#       include <mutex>
#   endif
#endif
#include "core/render.h"
#include <Logger/logger.h>
#include <unordered_set>

#include "font_manager_private.h"

//! FreeType library descriptor
FT_Library  g_ft = nullptr;

//! Loaded TTF fonts set used as fallback for missing glyphs
static std::unordered_set<TtfFont*> g_loadedFaces;

#ifndef PGE_NO_THREADING
#   ifdef PGE_SDL_MUTEX
static SDL_mutex                   *g_loadedFaces_mutex = nullptr;
#   define TTF_MUTEX_LOCK()         SDL_LockMutex(g_loadedFaces_mutex)
#   define TTF_MUTEX_UNLOCK()       SDL_UnlockMutex(g_loadedFaces_mutex)
#   else
static std::mutex                   g_loadedFaces_mutex;
#   define TTF_MUTEX_LOCK()         g_loadedFaces_mutex.lock()
#   define TTF_MUTEX_UNLOCK()       g_loadedFaces_mutex.unlock()
#   endif
#else
#   define TTF_MUTEX_LOCK()         (void)0
#   define TTF_MUTEX_UNLOCK()       (void)0
#endif

static unsigned long s_FT_rwops_io_func(FT_Stream stream, unsigned long offset, unsigned char* buffer, unsigned long count)
{
    if(!stream)
        return !count;

    SDL_RWops* rwops = (SDL_RWops*)stream->descriptor.pointer;

    if(!rwops || SDL_RWseek(rwops, offset, RW_SEEK_SET) < 0)
        return !count;

    if(!count)
        return 0;

    if(!buffer)
        return 0;

    return SDL_RWread(rwops, buffer, 1, count);
}

static void s_FT_rwops_close_func(FT_Stream stream)
{
    if(!stream)
        return;

    SDL_RWops* rwops = (SDL_RWops*)stream->descriptor.pointer;

    if(!rwops)
        return;

    SDL_RWclose(rwops);

    delete stream;
}

static FT_Stream s_FT_make_stream(const std::string& path)
{
    SDL_RWops* rwops = Files::open_file(path, "rb");

    if(!rwops)
        return nullptr;

    FT_Stream stream = new(std::nothrow) FT_StreamRec;
    if(!stream)
    {
        SDL_RWclose(rwops);
        return nullptr;
    }

    stream->base = nullptr;
    stream->descriptor.pointer = (void*)rwops;
    stream->size = SDL_RWsize(rwops);
    stream->read = s_FT_rwops_io_func;
    stream->close = s_FT_rwops_close_func;

    return stream;
}


bool initializeFreeType()
{
    FT_Error error = FT_Init_FreeType(&g_ft);
    SDL_assert_release(error == 0);
#if !defined(PGE_NO_THREADING) && defined(PGE_SDL_MUTEX)
    if(!g_loadedFaces_mutex)
        g_loadedFaces_mutex = SDL_CreateMutex();
#endif
    return true;
}

void closeFreeType()
{
    if(g_ft)
    {
        FT_Done_FreeType(g_ft);
        g_ft = nullptr;
    }

#if !defined(PGE_NO_THREADING) && defined(PGE_SDL_MUTEX)
    if(g_loadedFaces_mutex)
    {
        SDL_DestroyMutex(g_loadedFaces_mutex);
        g_loadedFaces_mutex = nullptr;
    }
#endif
}

// Default dummy glyph
const TtfFont::TheGlyph TtfFont::dummyGlyph = TtfFont::TheGlyph();

TtfFont::TtfFont() : BaseFontEngine()
{
    SDL_assert_release(g_ft);
}

TtfFont::~TtfFont()
{
    TTF_MUTEX_LOCK();
    if(m_face)
    {
        g_loadedFaces.erase(this);
        FT_Done_Face(m_face);
    }
    TTF_MUTEX_UNLOCK();

    m_face = nullptr;
}

bool TtfFont::loadFont(const std::string &path)
{
    SDL_assert_release(g_ft);

    FT_Open_Args args;
    args.flags = FT_OPEN_STREAM;
    args.stream = s_FT_make_stream(path);

    FT_Error error = FT_Err_Cannot_Open_Resource;
    if(args.stream)
        error = FT_Open_Face(g_ft, &args, 0, &m_face);

    if(!args.stream || error)
    {
        pLogWarning("Failed to load the font: %s", FT_Error_String(error));
        return false;
    }

    error = FT_Set_Pixel_Sizes(m_face, 0, m_recentPixelSize);
    if(error)
        pLogWarning("Failed to set the pixel sizes %" PRIu32 " for the font %s: %s", m_recentPixelSize, path.c_str(), FT_Error_String(error));

    error = FT_Select_Charmap(m_face, FT_ENCODING_UNICODE);
    if(error)
    {
        pLogWarning("Failed to select the charmap for the font %s: %s", path.c_str(), FT_Error_String(error));
        FT_Done_Face(m_face);
        m_face = nullptr;
        return false;
    }

    TTF_MUTEX_LOCK();
    g_loadedFaces.insert(this);
    TTF_MUTEX_UNLOCK();

    m_fontName.append(m_face->family_name);
    m_fontName.push_back(' ');
    m_fontName.append(m_face->style_name);
    m_isReady = true;

    pLogDebug("Loaded TTF font with name: [%s]", m_fontName.c_str());

    return true;
}

bool TtfFont::loadFont(const char *mem, size_t size)
{
    SDL_assert_release(g_ft);
    FT_Error error = FT_New_Memory_Face(g_ft, reinterpret_cast<const FT_Byte *>(mem),
                                        static_cast<FT_Long>(size), 0, &m_face);
    SDL_assert(error == 0);
    if(error)
        return false;
    error = FT_Set_Pixel_Sizes(m_face, 0, m_recentPixelSize);
    SDL_assert(error == 0);
    if(error)
        return false;
    error = FT_Select_Charmap(m_face, FT_ENCODING_UNICODE);
    SDL_assert(error == 0);
    if(error)
        return false;

    TTF_MUTEX_LOCK();
    g_loadedFaces.insert(this);
    TTF_MUTEX_UNLOCK();

    m_isReady = true;
    return true;
}

void TtfFont::setAntiAlias(bool enable)
{
    m_enableAntialias = enable;
}

bool TtfFont::antiAlias() const
{
    return m_enableAntialias;
}

void TtfFont::setBitmapSize(int size)
{
    m_bitmapSize = size;
}

int TtfFont::bitmapSize() const
{
    return m_bitmapSize;
}

void TtfFont::setDoublePixel(bool enable)
{
    m_doublePixel = enable;
}

bool TtfFont::doublePixel() const
{
    return m_doublePixel;
}

void TtfFont::setLanguages(const std::string &langs)
{
    m_languages = langs;
}

bool TtfFont::hasLanguage(const std::string &lang) const
{
    std::string::size_type beg = 0;
    std::string::size_type end = 0;

    if(m_languages.empty())
        return false;

    do
    {
        end = m_languages.find(',', beg);

        if(end == std::string::npos)
            end = m_languages.size();

        // trim word
        auto trim_beg = beg;
        while(m_languages[trim_beg] == ' ' && trim_beg < end)
            trim_beg++;

        auto trim_end = end;
        while(trim_end > trim_beg && m_languages[trim_end - 1] == ' ')
            trim_end--;

        if(SDL_strncmp(m_languages.c_str() + trim_beg, lang.c_str(), trim_end - trim_beg) == 0)
            return true;

        beg = end + 1;
    }
    while(end < m_languages.size() - 1);

    return false;
}

PGE_Size TtfFont::glyphSize(const char* utf8char, uint32_t charNum, uint32_t fontSize)
{
    PGE_Size ret(0, static_cast<int32_t>(fontSize * 1.5));

    const char &cx = utf8char[0];

    switch(cx)
    {
    case '\n':
    case '\r':
        break;

    case '\t':
    {
        //Fake tabulation
        size_t space = (4 * fontSize);
        if(space == 0)
            space = 1; // Don't divide by zero
        ret.setWidth(space - ((charNum / space) % 4));
        break;
    }

    default:
    {
        const TheGlyph &glyph = getGlyph(fontSize, get_utf8_char(&cx));
        ret.setWidth(glyph.info.width > 0 ? uint32_t(glyph.info.advance_x >> 6) : (fontSize >> 2));
        break;
    }

    }//Switch

    return ret;
}

PGE_Size TtfFont::printText(const char *text, size_t text_size,
                            int32_t x, int32_t y,
                            XTColor color,
                            uint32_t fontSize,
                            CropInfo* crop_info)
{
    SDL_assert_release(g_ft);
    if(!text || text_size == 0)
        return PGE_Size(0, 0);

    int32_t  offsetX = (crop_info) ? -crop_info->offset : 0;
    uint32_t offsetY = 0;

    int32_t  offsetX_max = 0;

    uint8_t letter_alpha = color.a;

    const char *strIt  = text;
    const char *strEnd = strIt + text_size;
    for(; strIt < strEnd; strIt++)
    {
        const char &cx = *strIt;
        UTF8 ucx = static_cast<unsigned char>(cx);

        switch(cx)
        {
        case '\n':
            if(offsetX > offsetX_max)
                offsetX_max = offsetX;

            offsetX = (crop_info) ? -crop_info->offset : 0;
            offsetY += static_cast<uint32_t>(fontSize * 1.5);
            continue;

        case '\t':
            //Fake tabulation
            offsetX += offsetX + offsetX % uint32_t(fontSize * 1.5);
            continue;
//        case ' ':
//            offsetX += m_spaceWidth + m_interLetterSpace / 2;
//            continue;
        default:
            break;
        }

        const TheGlyph &glyph = getGlyph(m_doublePixel ? (fontSize / 2) : fontSize, get_utf8_char(&cx));
        if(glyph.tx)
        {
            if(crop_info)
            {
                if(!crop_info->letter_alpha(letter_alpha, color.a, offsetX, offsetX + (glyph.info.advance_x >> 6)))
                    break;
            }

            if(letter_alpha != 0)
            {
                int32_t glyph_x = x + static_cast<int32_t>(offsetX);
                int32_t glyph_y = y + static_cast<int32_t>(offsetY + fontSize);
                XRender::renderTextureScale(
                    glyph_x + glyph.info.left,
                    glyph_y - glyph.info.top,
                    (m_doublePixel ? (glyph.info.width * 2) : glyph.info.width),
                    (m_doublePixel ? (glyph.info.height * 2) : glyph.info.height),
                    *glyph.tx,
                    color.with_alpha(letter_alpha)
                );
            }
        }
        offsetX += glyph.tx ? uint32_t(glyph.info.advance_x >> 6) : (fontSize >> 2);

        strIt += static_cast<size_t>(trailingBytesForUTF8[ucx]);
    }

    if(offsetX > offsetX_max)
        offsetX_max = offsetX;

    if(offsetX > 0)
        offsetY += static_cast<uint32_t>(fontSize);

    return PGE_Size(offsetX_max, offsetY);
}

bool TtfFont::isLoaded() const
{
    return m_isReady;
}

void TtfFont::setFontName(const std::string& name)
{
    m_fontName = name;
}

std::string TtfFont::getFontName() const
{
    return m_fontName;
}

BaseFontEngine::FontType TtfFont::getFontType() const
{
    return FONT_TTF;
}

// #define TTF_RENDER_DEBUG

uint32_t TtfFont::drawGlyph(const char *u8char,
                            int32_t x, int32_t y, uint32_t fontSize, int scaleSize,
                            bool drawOutlines,
                            XTColor color,
                            XTColor OL_color)
{
#ifdef TTF_RENDER_DEBUG
    const TheGlyph &glyph = getGlyph(fontSize, get_utf8_char(u8char));

    if(glyph.tx)
        XRender::renderRect(x, y, glyph.info.width * scaleSize, glyph.info.height * scaleSize, XTColor(0, 0, 255, 128), false);
#endif

    return drawGlyphB(u8char, x, y + static_cast<int32_t>(fontSize * scaleSize), fontSize, scaleSize, drawOutlines, color, OL_color);
}

uint32_t TtfFont::drawGlyphB(const char *u8char, int32_t x, int32_t baseline_y, uint32_t fontSize, int scaleSize, bool drawOutlines, XTColor color, XTColor OL_color)
{
    const TheGlyph &glyph = getGlyph(fontSize, get_utf8_char(u8char));

    if(glyph.tx)
    {
        int32_t glyph_x = x + (glyph.info.left * scaleSize);
        int32_t glyph_y = baseline_y - (glyph.info.top * scaleSize);
        int32_t glyph_w = glyph.info.width * scaleSize;
        int32_t glyph_h = glyph.info.height * scaleSize;

        if(drawOutlines)
        {
            const int offsets[4][2] =
            {
                {-scaleSize, 0},
                { scaleSize, 0},
                {0, -scaleSize},
                {0,  scaleSize}
            };

            // take square of Alpha to match blend of normal text
            uint8_t scaled_a = XTColor::mul(color.a, color.a);

            for(size_t i = 0; i < 4; ++i)
            {
                XRender::renderTextureScale(
                    glyph_x + offsets[i][0], glyph_y + offsets[i][1],
                    glyph_w, glyph_h, *glyph.tx,
                    color.with_alpha(scaled_a) * OL_color
                );
            }
        }

        XRender::renderTextureScale(glyph_x, glyph_y, glyph_w, glyph_h, *glyph.tx, color);

#ifdef TTF_RENDER_DEBUG
        XRender::renderRect(x, baseline_y - glyph_h, glyph_w, glyph_h, XTColor(0, 0, 255, 128), false);
        XRender::renderRect(glyph_x, glyph_y, glyph_w, glyph_h, XTColor(255, 0, 0, 128), false);
#endif

        return glyph.info.width;
    }

    return fontSize;
}

TtfFont::TheGlyphInfo TtfFont::getGlyphInfo(const char *u8char, uint32_t fontSize)
{
    TheGlyph glyph = getGlyph(fontSize, get_utf8_char(u8char));
    return glyph.info;
}

const TtfFont::TheGlyph &TtfFont::getGlyph(uint32_t fontSize, char32_t character)
{
    auto fSize = m_charMap.find(fontSize);
    if(fSize != m_charMap.end())
    {
        auto rc = fSize->second.find(character);
        if(rc != fSize->second.end())
        {
            // reload if the renderer has unloaded the glyph
            if(rc->second.tx && !rc->second.tx->d.hasTexture())
                return loadGlyph(*(rc->second.tx), fontSize, character);

            return rc->second;
        }
        return loadGlyph(fontSize, character);
    }

    return loadGlyph(fontSize, character);
}

const TtfFont::TheGlyph &TtfFont::loadGlyph(uint32_t fontSize, char32_t character)
{
    m_texturesBank.emplace_back();
    StdPicture &texture = m_texturesBank.back();

    const TtfFont::TheGlyph &ret = loadGlyph(texture, fontSize, character);

    if(ret.tx != &texture)
        m_texturesBank.pop_back();

    return ret;
}

const TtfFont::TheGlyph &TtfFont::loadGlyph(StdPicture &texture, uint32_t fontSize, char32_t character)
{
    FT_Error     error = 0;
    FT_UInt      t_glyphIndex = 0;
    TheGlyph     t_glyph;
    FT_Face      cur_font = m_face;

    if(m_recentPixelSize != fontSize)
    {
        TTF_MUTEX_LOCK();
        error = FT_Set_Pixel_Sizes(cur_font, 0, fontSize);
        if(error)
            pLogWarning("TheGlyph::loadGlyph (1) Failed to set the pixel sizes %" PRIu32 " for the font %s: %s", fontSize, cur_font->family_name, FT_Error_String(error));
        m_recentPixelSize = fontSize;
        TTF_MUTEX_UNLOCK();
    }

    t_glyphIndex = FT_Get_Char_Index(cur_font, character);

    if(t_glyphIndex == 0)//Attempt to find a fallback
    {
        TTF_MUTEX_LOCK();
        for(TtfFont *fb_font : g_loadedFaces)
        {
            if(fb_font->m_recentPixelSize != fontSize)
            {
                error = FT_Set_Pixel_Sizes(fb_font->m_face, 0, fontSize);
                if(error)
                    pLogWarning("TheGlyph::loadGlyph (2) Failed to set the pixel sizes %" PRIu32 " for the font %s: %s", fontSize, cur_font->family_name, FT_Error_String(error));
                fb_font->m_recentPixelSize = fontSize;
            }

            t_glyphIndex = FT_Get_Char_Index(fb_font->m_face, character);
            if(t_glyphIndex != 0)
            {
                // Fallback has been found!
                cur_font = fb_font->m_face;
                break;
            }
        }
        TTF_MUTEX_UNLOCK();
    }

    FT_Int32 ftLoadFlags = FT_LOAD_RENDER;

    if(FT_HAS_COLOR(cur_font))
        ftLoadFlags |= FT_LOAD_COLOR;
    else if(!m_enableAntialias)
        ftLoadFlags |= FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME;

    error = FT_Load_Glyph(cur_font, t_glyphIndex, ftLoadFlags);
    if(error != 0)
        return dummyGlyph;


    FT_GlyphSlot glyph  = cur_font->glyph;
    FT_Bitmap &bitmap   = glyph->bitmap;
    uint32_t width      = bitmap.width;
    uint32_t height     = bitmap.rows;
    uint32_t pitch      = width * 4;

    if((width == 0) || (height == 0))
        return dummyGlyph;

    SDL_assert_release(bitmap.buffer); // Buffer must NOT be null

    uint8_t *image = nullptr;

    try
    {
        size_t image_size = 4 * width * height;
        image = new uint8_t[image_size];
        SDL_memset(image, 0, image_size);
    }
    catch(const std::bad_alloc &e)
    {
        pLogCritical("TtfFont::TheGlyph: Out of memory: %s", e.what());
        return dummyGlyph;
    }

    switch(bitmap.pixel_mode)
    {
    case FT_PIXEL_MODE_NONE:
        break;

    case FT_PIXEL_MODE_MONO:
    {
        uint32_t bsize = (width + 7) / 8;

        if(bitmap.pitch >= 0)
        {
            for(uint32_t h = 0; h < height; ++h)
            {
                for(uint32_t b = 0; b < bsize; ++b)
                {
                    uint8_t block = bitmap.buffer[(static_cast<uint32_t>(bitmap.pitch) * ((height - 1) - h)) + b];
                    uint32_t* dest = reinterpret_cast<uint32_t*>(&(image[((4 * width) * (height - 1 - h)) + (32 * b)]));
                    for(int x = 0; x < 8 && (b * 8 + x) < width; x++)
                    {
                        if(block & (1 << (7 - x)))
                            dest[x] = 0xFFFFFFFF;
                        else
                            dest[x] = 0;
                    }
                }
            }
        }
        else if(bitmap.pitch < 0)
        {
            for(uint32_t h = 0; h < height; ++h)
            {
                for(uint32_t b = 0; b < bsize; ++b)
                {
                    uint8_t block = *(bitmap.buffer - (static_cast<uint32_t>(bitmap.pitch) * h) + b);
                    uint32_t* dest = reinterpret_cast<uint32_t*>(&(image[((4 * width) * h) + (32 * b)]));
                    for(int x = 0; x < 8 && (b * 8 + x) < width; x++)
                    {
                        if(block & (1 << (7 - x)))
                            dest[x] = 0xFFFFFFFF;
                        else
                            dest[x] = 0;
                    }
                }
            }
        }
        break;
    }
    case FT_PIXEL_MODE_GRAY:
    {
        if(bitmap.pitch >= 0)
        {
            for(uint32_t h = 0; h < height; ++h)
            {
                for(uint32_t w = 0; w < width; ++w)
                {
                    uint8_t color = bitmap.buffer[static_cast<uint32_t>(bitmap.pitch) * ((height - 1) - h) + w];
                    size_t hp = (4 * width) * (height - 1 - h);
                    uint32_t *dst = reinterpret_cast<uint32_t*>(image + hp + (4 * w));
                    *dst = (uint32_t(color) << 0) |
                           (uint32_t(color) << 8) |
                           (uint32_t(color) << 16) |
                           (uint32_t(color) << 24);
                }
            }
        }
        else if(bitmap.pitch < 0)
        {
            for(uint32_t h = 0; h < height; ++h)
            {
                for(uint32_t w = 0; w < width; ++w)
                {
                    uint8_t color = *(bitmap.buffer - (static_cast<uint32_t>(bitmap.pitch) * h) + w);
                    size_t hp = (4 * width) * h;
                    uint32_t *dst = reinterpret_cast<uint32_t*>(image + hp + (4 * w));
                    *dst = (uint32_t(color) << 0) |
                           (uint32_t(color) << 8) |
                           (uint32_t(color) << 16) |
                           (uint32_t(color) << 24);
                }
            }
        }
        break;
    }

    case FT_PIXEL_MODE_BGRA:
    {
        if(bitmap.pitch >= 0)
        {
            for(uint32_t h = 0; h < height; ++h)
            {
                for(uint32_t w = 0; w < width; ++w)
                {
                    uint8_t colour[4];
                    SDL_memcpy(colour, bitmap.buffer + static_cast<uint32_t>(bitmap.pitch) * ((height - 1) - h) + w * 4, 4);
                    size_t hp = (4 * width) * (height - 1 - h);
                    uint32_t *dst = reinterpret_cast<uint32_t*>(image + hp + (4 * w));
                    // Convert pre-multiplied to normal format
                    *dst++ = colour[0] > 0 ? colour[2] / colour[0]: 0;
                    *dst++ = colour[0] > 0 ? colour[1] / colour[0]: 0;
                    *dst++ = colour[0] > 0 ? colour[0] / colour[0]: 0;
                    *dst++ = colour[3];
                }
            }
        }
        else if(bitmap.pitch < 0)
        {
            for(uint32_t h = 0; h < height; ++h)
            {
                for(uint32_t w = 0; w < width; ++w)
                {
                    uint8_t colour[4];
                    SDL_memcpy(colour, (bitmap.buffer - (static_cast<uint32_t>(bitmap.pitch) * h) + w * 4), 4);
                    size_t hp = (4 * width) * h;
                    uint32_t *dst = reinterpret_cast<uint32_t*>(image + hp + (4 * w));
                    // Convert pre-multiplied to normal format
                    *dst++ = colour[0] > 0 ? colour[2] / colour[0]: 0;
                    *dst++ = colour[0] > 0 ? colour[1] / colour[0]: 0;
                    *dst++ = colour[0] > 0 ? colour[0] / colour[0]: 0;
                    *dst++ = colour[3];
                }
            }
        }
        break;
    }

    default:
        pLogWarning("TtfFont::TheGlyph: FIXME: The pixel mode %d is not supported yet!", bitmap.pixel_mode);
        break;
    }

    if(m_doublePixel)
    {
        texture.w = width * 2;
        texture.h = height * 2;
    }
    else
    {
        texture.w = width;
        texture.h = height;
    }

    XRender::loadTexture(texture, width, height, image, pitch);

    t_glyph.tx      = &texture;
    t_glyph.info.width   = width;
    t_glyph.info.height  = height;
    t_glyph.info.left    = glyph->bitmap_left;
    t_glyph.info.top     = glyph->bitmap_top;
    t_glyph.info.advance_x = int32_t(glyph->advance.x);
    t_glyph.info.advance_y = int32_t(glyph->advance.y);
    t_glyph.info.metric_h_bearing_x = int32_t(glyph->metrics.horiBearingX);
    t_glyph.info.metric_h_bearing_y = int32_t(glyph->metrics.horiBearingY);
    t_glyph.info.metric_h_advance = int32_t(glyph->metrics.horiAdvance);
    t_glyph.info.metric_v_bearing_x = int32_t(glyph->metrics.vertBearingX);
    t_glyph.info.metric_v_bearing_y = int32_t(glyph->metrics.vertBearingY);
    t_glyph.info.metric_v_advance = int32_t(glyph->metrics.vertAdvance);
    t_glyph.info.metric_w = int32_t(glyph->metrics.width);
    t_glyph.info.metric_h = int32_t(glyph->metrics.height);
    t_glyph.info.glyph_width = glyph->advance.x;
    t_glyph.info.glyph_height = glyph->advance.y;


#ifdef DEBUG_BUILD
    UTF8 glyph8[6] = {0, 0, 0, 0, 0, 0};
    UTF8 *glyph8_ptr = static_cast<UTF8*>(glyph8);
    const UTF32 glyph32[2] = {character, 0};
    const UTF32 *glyph32_ptr1 = static_cast<const UTF32*>(glyph32);
    PGEFF_ConvertUTF32toUTF8(&glyph32_ptr1, glyph32 + 1, &glyph8_ptr, glyph8 + 5, strictConversion);

    D_pLogDebug("TTF Glyph info %s 0x%08" PRIX32 ": "
        "w=%" PRIu32 ", h=%" PRIu32 ", l=%" PRId32 " t=%" PRId32 ", "
        "ax=%" PRId32 ", ay=%" PRId32 ", "
        "mhbx=%" PRId32 ", mhby=%" PRId32 ", mha=%" PRId32 ", "
        "mvbx=%" PRId32 ", mvby=%" PRId32 ", mva=%" PRId32 ", "
        "mw=%" PRId32 ", mh=%" PRId32 ", "
        "gw=%ld, gh=%ld",
        glyph8,
        static_cast<uint32_t>(character),
        t_glyph.info.width,
        t_glyph.info.height,
        t_glyph.info.left,
        t_glyph.info.top,
        (t_glyph.info.advance_x >> 6),
        (t_glyph.info.advance_y >> 6),
        (t_glyph.info.metric_h_bearing_x >> 6),
        (t_glyph.info.metric_h_bearing_y >> 6),
        (t_glyph.info.metric_h_advance >> 6),
        (t_glyph.info.metric_v_bearing_x >> 6),
        (t_glyph.info.metric_v_bearing_y >> 6),
        (t_glyph.info.metric_v_advance >> 6),
        (t_glyph.info.metric_w >> 6),
        (t_glyph.info.metric_h >> 6),
        (t_glyph.info.glyph_width >> 6),
        (t_glyph.info.glyph_height >> 6)
    );
#endif

    delete [] image;

    auto fSize = m_charMap.find(fontSize);
    if(fSize == m_charMap.end())
    {
        m_charMap.insert({fontSize, CharMap()});
        fSize = m_charMap.find(fontSize);
        SDL_assert_release(fSize != m_charMap.end());
    }

    fSize->second.insert({character, t_glyph});
    auto rc = fSize->second.find(character);
    SDL_assert_release(rc != fSize->second.end());

    return rc->second;
}


================================================
FILE: src/fontman/ttf_font.h
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef TTF_FONT_H
#define TTF_FONT_H


#ifdef LOW_MEM
#   include <map>
#else
#   include <unordered_map>
#endif
#include <Utils/vptrlist.h>
#include "std_picture.h"

#ifdef HAVE_STDINT_H
#undef HAVE_STDINT_H //Avoid a warning about HAVE_STDINT_H's redefinition
#endif
#include <freetype2/ft2build.h>
#include <freetype2/freetype/freetype.h>
#include <freetype2/freetype/ftglyph.h>
#include <freetype2/freetype/ftoutln.h>
#include <freetype2/freetype/fttrigon.h>

#include "font_engine_base.h"

//! FreeType library descriptor
extern FT_Library  g_ft;

extern bool initializeFreeType();
extern void closeFreeType();

/**
 * @brief The FreeType-based font engine
 */
class TtfFont final : public BaseFontEngine
{
public:
    TtfFont();
    TtfFont(const TtfFont &tf) = delete;
    TtfFont &operator=(const TtfFont &tf) = delete;
    TtfFont(TtfFont &&tf) = default;
    virtual ~TtfFont() override;

    bool loadFont(const std::string &path);
    bool loadFont(const char* mem, size_t size);

    void setAntiAlias(bool enable);
    bool antiAlias() const;

    void setBitmapSize(int size);
    int bitmapSize() const;

    void setDoublePixel(bool enable);
    bool doublePixel() const;

    void setLanguages(const std::string &langs);
    bool hasLanguage(const std::string &lang) const;

    /*!
     * \brief Get a size of one glyph
     * \param utf8char Pointer to one UTF-8 character
     * \param charNum Character number in the line (required to compute the size of the taboluation)
     * \param fontSize Size of TTF font glyph
     * \return Width and height of one glyph in pixels
     */
    PGE_Size glyphSize(const char *utf8char, uint32_t charNum = 0, uint32_t fontSize = 14) override;

    /*!
     * \brief Print the multiline text block on the screen
     * \param text Multi-line text string
     * \param text_size The byte size of the text string to print
     * \param x Hotizontal screen position (at left-top corner of the block)
     * \param y Vertical screen position (at left-top corner of the block)
     * \param Red Red channel colour
     * \param Green Green channel colour
     * \param Blue Blue channel colour
     * \param Alpha Alpha channel level (does not issue render calls if Alpha is 0)
     * \param fontSize The size of the TTF font glyph
     * \param crop_info nullable pointer to info for crop (marquee) logic
     * \return Width and height of the text block in pixels
     */
    PGE_Size printText(const char *text, size_t text_size,
                       int32_t x, int32_t y,
                       XTColor color = XTColor(),
                       uint32_t fontSize = 14,
                       CropInfo* crop_info = nullptr) override;

    bool isLoaded() const override;

    void setFontName(const std::string &name);

    std::string getFontName() const override;
    FontType getFontType() const override;

    /**
     * @brief Draw a single glyph by x-y coordinates
     * @param u8char Pointer to UTF8 multi-byte character
     * @param x X position to draw
     * @param y Y position do draw
     * @param fontSize Size of font
     * @param scaleSize Scale rendered texture
     * @param drawOutlines Draw the outline at every glyph
     * @param Red Red color level from 0.0 to 1.0
     * @param Green Green color level from 0.0 to 1.0
     * @param Blue Blue color level from 0.0 to 1.0
     * @param Alpha Transparency level from 0.0 to 1.0
     * @return Width of the glypth
     */
    uint32_t drawGlyph(const char* u8char,
                       int32_t x, int32_t y, uint32_t fontSize, int scaleSize = 1,
                       bool drawOutlines = false,
                       XTColor color = XTColor(),
                       XTColor OL_color = XTColor());

    /**
     * @brief Draw a single glyph relative to baseline offset
     * @param u8char Pointer to UTF8 multi-byte character
     * @param x X position to draw
     * @param baseline_y Y position of the baseline to draw
     * @param fontSize Size of font
     * @param scaleSize Scale rendered texture
     * @param drawOutlines Draw the outline at every glyph
     * @param Red Red color level from 0.0 to 1.0
     * @param Green Green color level from 0.0 to 1.0
     * @param Blue Blue color level from 0.0 to 1.0
     * @param Alpha Transparency level from 0.0 to 1.0
     * @return Width of the glypth
     */
    uint32_t drawGlyphB(const char* u8char,
                       int32_t x, int32_t baseline_y, uint32_t fontSize, int scaleSize = 1,
                       bool drawOutlines = false,
                       XTColor color = XTColor(),
                       XTColor OL_color = XTColor());

    struct TheGlyphInfo
    {
        TheGlyphInfo() = default;
        TheGlyphInfo(const TheGlyphInfo &) = default;
        TheGlyphInfo &operator=(const TheGlyphInfo &) = default;

        uint32_t width  = 0;
        uint32_t height = 0;
        int32_t  left   = 0;
        int32_t  top    = 0;
        int32_t  advance_x = 0;
        int32_t  advance_y = 0;
        int32_t  metric_h_bearing_x = 0;
        int32_t  metric_h_bearing_y = 0;
        int32_t  metric_h_advance = 0;
        int32_t  metric_v_bearing_x = 0;
        int32_t  metric_v_bearing_y = 0;
        int32_t  metric_v_advance = 0;
        int32_t  metric_w = 0;
        int32_t  metric_h = 0;
        FT_Pos   glyph_width = 0;
        FT_Pos   glyph_height = 0;
    };

    TheGlyphInfo getGlyphInfo(const char *u8char, uint32_t fontSize);

private:
    //! font is fine
    bool m_isReady = false;
    //! Handalable name of the font
    std::string m_fontName;

    //! Comma-separated list of languages that should bring this font being loaded first
    std::string m_languages;

    //! Recently used pixel size of the font
    uint32_t     m_recentPixelSize = 10;

    //! Loaded font face
    FT_Face      m_face = nullptr;

    //! Load anti-aliased glyphs
    bool         m_enableAntialias = true;

    //! Make pixelized glyphs: load them with a smaller size, and then, upscale them during a render
    bool         m_doublePixel     = false;

    //! Font face preferred bitmap size, 0 to disable
    int          m_bitmapSize = 0;

    struct TheGlyph
    {
        TheGlyph() = default;
        StdPicture *tx     = nullptr;
        TheGlyphInfo info;
    };

    //! Default dummy glyph
    static const TheGlyph dummyGlyph;

    const TheGlyph &getGlyph(uint32_t fontSize, char32_t character);

    // version allocating a new texture
    const TheGlyph &loadGlyph(uint32_t fontSize, char32_t character);

    // version using an existing texture
    const TheGlyph &loadGlyph(StdPicture &texture, uint32_t fontSize, char32_t character);

#ifdef LOW_MEM
    typedef std::map<char32_t, TheGlyph> CharMap;
    typedef std::map<uint32_t, CharMap>  SizeCharMap;
#else
    typedef std::unordered_map<char32_t, TheGlyph> CharMap;
    typedef std::unordered_map<uint32_t, CharMap>  SizeCharMap;
#endif

    SizeCharMap m_charMap;
    VPtrList<StdPicture > m_texturesBank;
};

#endif // TTF_FONT_H


================================================
FILE: src/fontman/utf8_helpers.cpp
================================================
/*
 * Moondust, a free game engine for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include "font_manager.h"
#include "font_manager_private.h"

size_t FontManager::utf8_strlen(const char *str)
{
    size_t size = 0;

    while(str && *str != 0)
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*str)]);
        size += charLen;
        str  += charLen;
    }

    return size;
}

size_t FontManager::utf8_strlen(const char *str, size_t len)
{
    size_t utf8_pos = 0;

    while(str && len > 0)
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*str)]);
        str  += charLen;
        len  -= charLen;
        utf8_pos++;
    }

    return utf8_pos;
}

size_t FontManager::utf8_strlen(const std::string &str)
{
    return utf8_strlen(str.c_str(), str.size());
}

size_t FontManager::utf8_substrlen(const std::string &str, size_t utf8len)
{
    size_t pos = 0;
    size_t utf8_pos = 0;
    const char *cstr = str.c_str();
    size_t len = str.length();

    while(cstr && len > 0)
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*cstr)]);
        if(utf8_pos == utf8len)
            return pos;
        cstr += charLen;
        pos  += charLen;
        len  -= charLen;
        utf8_pos++;
    }

    return pos;
}

std::string FontManager::utf8_substr(const std::string &str, size_t utf8_begin, size_t utf8_len)
{
    size_t utf8_pos = 0;
    const char *cstr = str.c_str();
    size_t len = str.length();
    std::string out;

    while(cstr && (len > 0) && (utf8_len > 0))
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*cstr)]);
        if(utf8_pos >= utf8_begin)
        {
            out.append(cstr, charLen);
            utf8_len--;
        }

        cstr += charLen;
        len  -= charLen;
        utf8_pos++;
    }

    return out;
}

const char* FontManager::utf8_skip_begin(const char *str, size_t utf8_begin)
{
    size_t utf8_pos = 0;
    const char *cstr = str;
    const char *out = cstr;

    while(cstr && *cstr != 0)
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*cstr)]);
        if(utf8_pos >= utf8_begin)
            out = cstr;
        cstr += charLen;
        utf8_pos++;
    }

    return out;
}

void FontManager::utf8_pop_back(std::string &str)
{
    size_t pos = 0;
    const char*cstr = str.c_str();
    size_t len = str.length();

    while(cstr && len > 0)
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*cstr)]);
        len  -= charLen;
        if(len == 0)
        {
            str.erase(str.begin() + static_cast<std::string::difference_type>(pos), str.end());
            return;
        }

        cstr += charLen;
        pos  += charLen;
    }
}

void FontManager::utf8_erase_at(std::string &str, size_t begin)
{
    size_t pos = 0;
    size_t utf8_pos = 0;
    const char*cstr = str.c_str();
    size_t len = str.length();

    while(cstr && len > 0)
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*cstr)]);
        if(utf8_pos == begin)
        {
            str.erase(str.begin() + static_cast<std::string::difference_type>(pos), str.end());
            return;
        }

        cstr += charLen;
        pos  += charLen;
        len  -= charLen;
        utf8_pos++;
    }
}

void FontManager::utf8_erase_before(std::string &str, size_t end)
{
    size_t pos = 0;
    size_t utf8_pos = 0;
    const char*cstr = str.c_str();
    size_t len = str.length();

    while(cstr && len > 0)
    {
        size_t  charLen = 1 + static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(*cstr)]);
        if(utf8_pos == end)
        {
            str.erase(str.begin(), str.begin() + static_cast<std::string::difference_type>(pos) + 1);
            return;
        }

        cstr += charLen;
        pos  += charLen;
        len  -= charLen;
        utf8_pos++;
    }
}


================================================
FILE: src/frame_timer.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <inttypes.h>
#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_timer.h"

#include <fmt_format_ne.h>
#include <Logger/logger.h>
#include "pge_delay.h"

#include "frame_timer.h"
#include "globals.h"
#include "config.h"
#include "graphics.h"
#include "message.h"
#include "core/render.h"
#include "core/events.h"

#include "npc/npc_queues.h"

// heap info for min console ports
#if defined(__16M__) || defined(__3DS__) // || defined(__WII__)
    #define STATS_SHOW_RAM
    #include <malloc.h>
#endif // #if defined(__16M__) || defined(__3DS__) || defined(__WII__)

// VRAM info for 16M
#ifdef __16M__
    namespace XRender
    {
        extern uint32_t s_loadedVRAM;
    }
#endif

// VRAM info for 3DS
#ifdef __3DS__
    #include <3ds.h>
    extern u32 __ctru_linear_heap_size;
#endif

// heap size for Wii
#if defined(STATS_SHOW_RAM) && defined(__WII__)
    extern u8 __Arena1Lo[], __Arena1Hi[];
    extern u8 __Arena2Lo[], __Arena2Hi[];
    static const uint32_t s_heap_size = (__Arena2Hi - __Arena2Lo) + (__Arena1Hi - __Arena1Lo);
// heap size for other homebrew
#elif defined(STATS_SHOW_RAM)
    extern u8 *fake_heap_start;
    extern u8 *fake_heap_end;
    static const uint32_t s_heap_size = (fake_heap_end - fake_heap_start);
#endif

MicroStats g_microStats;
PerformanceStats_t g_stats;

void MicroStats::reset()
{
    for(uint8_t i = 0; i < TASK_END; i++)
    {
        level_timer[i] = 0;
        view_timer[i] = 0;
        m_cur_timer[i] = 0;
    }

    view_total = 0;

    m_slow_frame_time = 0;
    m_frame_time = 0;

    m_cur_task = TASK_END;
    m_cur_frame = 0;
}

void MicroStats::start_task(Task task)
{
    uint64_t next_time = SDL_GetMicroTicks();

    if(m_cur_task < TASK_END)
    {
        m_cur_timer[m_cur_task] += next_time - m_cur_time;
        level_timer[m_cur_task] += next_time - m_cur_time;
        m_frame_time += next_time - m_cur_time;
    }

    m_cur_time = next_time;
    m_cur_task = task;
}

void MicroStats::start_sleep()
{
    start_task(TASK_END);
}

void MicroStats::end_frame()
{
    start_task(TASK_END);

    m_cur_frame++;
    m_level_frame++;

    if(m_frame_time > m_slow_frame_time)
        m_slow_frame_time = m_frame_time;

    m_frame_time = 0;

    if(m_cur_frame == 66)
    {
        m_cur_frame = 0;
        view_total = 0;

        for(uint8_t i = 0; i < TASK_END; i++)
        {
            view_timer[i] = (m_cur_timer[i] + 500) / 1000;
            view_total += (m_cur_timer[i] + 500) / 1000;
            m_cur_timer[i] = 0;
        }

        view_slow_frame_time = (m_slow_frame_time * 66 + 500) / 1000;
        m_slow_frame_time = 0;
    }
}

void PerformanceStats_t::next_page()
{
    if((XRender::TargetW >= 720 && XRender::TargetH >= 360) || (LevelSelect && !GameMenu))
        page = !page;
    else
        page = (page + 1) % (GameMenu ? 4 : 5);

#ifndef STATS_SHOW_RAM
    if(page == 3)
        page++;
#endif
}

void PerformanceStats_t::reset()
{
   renderedBlocks = 0;
   renderedBGOs = 0;
   renderedNPCs = 0;
   renderedEffects = 0;

   checkedBlocks = 0;
   checkedBGOs = 0;

   renderedTiles = 0;
   renderedScenes = 0;
   renderedPaths = 0;
   renderedLevels = 0;

   checkedTiles = 0;
   checkedScenes = 0;
   checkedPaths = 0;
   checkedLevels = 0;
}

#define YLINE (y + 2 + (row++ * 18))

#ifdef STATS_SHOW_RAM
static void s_print_ram(int x, int y)
{
    int row = 0;

    int items = 1; // RAM

#   ifndef __WII__
    items++; // VRAM
#   endif

    XRender::renderRect(x, y, 340, 12 + (18 * items), XTColorF(0.0_n, 0.0_n, 0.0_n, 0.3_n), true);

    if(x < 200)
        y += 6;

    auto m = mallinfo();

#   ifdef __16M__
    SuperPrint(fmt::sprintf_ne(" RAM: %4zu/%4" PRIu32 " kb", m.uordblks / 1024, s_heap_size / 1024),
               3, x + 4, YLINE);
    SuperPrint(fmt::sprintf_ne("VRAM: %4" PRIu32 "/%4d kb", XRender::s_loadedVRAM / 1024, 512),
               3, x + 4, YLINE, XTColorF(0.5_n, 1.0_n, 0.5_n));
#   else
    SuperPrint(fmt::sprintf_ne(" RAM: %5zu / %5" PRIu32 " kb", m.uordblks / 1024, s_heap_size / 1024),
               3, x + 4, YLINE);
#   endif

#   ifdef __3DS__
    SuperPrint(fmt::sprintf_ne("VRAM: %5" PRIu32 "/%5" PRIu32 " kb", (__ctru_linear_heap_size - linearSpaceFree()) / 1024, __ctru_linear_heap_size / 1024),
               3, x + 4, YLINE, XTColorF(0.5_n, 1.0_n, 0.5_n));
#   endif
}
#else
static void s_print_ram(int, int) {}
#endif // #ifdef STATS_SHOW_RAM

void PerformanceStats_t::print_filenames(int x, int y)
{
    int items = (GameMenu) ? 4 : 3;
    int row = 0;

    XRender::renderRect(x, y, 745, 6 + (18 * items), XTColorF(0.0_n, 0.0_n, 0.0_n, 0.3_n), true);

    SuperPrint(fmt::sprintf_ne("FILE: %s", FileNameFull.empty() ? "<none>" : FileNameFull.c_str()),
               3, x + 4, YLINE, XTColorF(1.0_n, 0.5_n, 1.0_n));
    SuperPrint(fmt::sprintf_ne("MUSK: %s", currentMusic.empty() ? "<none>" : currentMusic.c_str()),
               3, x + 4, YLINE, XTColorF(1.0_n, 0.5_n, 1.0_n));
    SuperPrint(fmt::sprintf_ne("MUSF: %s", currentMusicFile.empty() ? "<none>" : currentMusicFile.c_str()),
               3, x + 4, YLINE, XTColorF(1.0_n, 0.5_n, 1.0_n));

    if(GameMenu)
    {
        SuperPrint(fmt::sprintf_ne("MENU-MODE: %d", MenuMode),
                   3, x + 4, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));
    }
}

void PerformanceStats_t::print_obj_stats(int x, int y)
{
    int items = 5;
    int row = 0;

    XRender::renderRect(x, y, 340, 6 + (18 * items), XTColorF(0.0_n, 0.0_n, 0.0_n, 0.3_n), true);

    SuperPrint(fmt::sprintf_ne("   DRAW/ACTV/TOTAL"),
        3, x + 4, YLINE, XTColorF(1.0_n, 1.0_n, 1.0_n));

    SuperPrint(fmt::sprintf_ne("B: %04d/%04d/%05d", renderedBlocks, checkedBlocks, numBlock),
        3, x + 4, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));
    SuperPrint(fmt::sprintf_ne("G: %04d/%04d/%05d", renderedBGOs, checkedBGOs, numBackground),
        3, x + 4, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));
    SuperPrint(fmt::sprintf_ne("N: %04d/%04d/%05d", renderedNPCs, (int)NPCQueues::Active.no_change.size(), numNPCs),
        3, x + 4, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));
    SuperPrint(fmt::sprintf_ne("E: %04d/%04d", renderedEffects, numEffects),
        3, x + 4, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));
}

void PerformanceStats_t::print_cpu_stats(int x, int y)
{
    int items = 6;

    XRender::renderRect(x, y, 340, 6 + (18 * items), XTColorF(0.0_n, 0.0_n, 0.0_n, 0.3_n), true);

    SuperPrint(fmt::sprintf_ne("CPU: %05dms/s",
                               g_microStats.view_total),
               3, x + 24, y + 2);

    SuperPrint(fmt::sprintf_ne("%s %04d\n%s %04d\n%s %04d\n%s %04d\n%s %04d",
                               g_microStats.task_names[0], g_microStats.view_timer[0],
                               g_microStats.task_names[1], g_microStats.view_timer[1],
                               g_microStats.task_names[2], g_microStats.view_timer[2],
                               g_microStats.task_names[3], g_microStats.view_timer[3],
                               g_microStats.task_names[4], g_microStats.view_timer[4]),
               3, x + 4, y + 2 + 18, XTColorF(1.0_n, 1.0_n, 0.5_n));

    SuperPrint(fmt::sprintf_ne("%s %04d\n%s %04d\n%s %04d\n%s %04d\n%s %04d",
                               g_microStats.task_names[5], g_microStats.view_timer[5],
                               g_microStats.task_names[6], g_microStats.view_timer[6],
                               g_microStats.task_names[7], g_microStats.view_timer[7],
                               g_microStats.task_names[8], g_microStats.view_timer[8],
                               g_microStats.task_names[9], g_microStats.view_timer[9]),
               3, x + 164, y + 2 + 18, XTColorF(1.0_n, 1.0_n, 0.5_n));
}

void PerformanceStats_t::print()
{
    if(page == 0)
        return;

    if(LevelSelect && !GameMenu)
    {
        int items = 5;
        XRender::renderRect(6 + XRender::TargetOverscanX, 6, 745, 6 + (18 * items), XTColorF(0.0_n, 0.0_n, 0.0_n, 0.3_n), true);

        int y = 6;
        int row = 0;

        SuperPrint(fmt::sprintf_ne("FILE: %s", FileNameFull.empty() ? "<none>" : FileNameFull.c_str()),
                   3, 10 + XRender::TargetOverscanX, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));
        SuperPrint(fmt::sprintf_ne("MUSK: %s", currentMusic.empty() ? "<none>" : currentMusic.c_str()),
                   3, 10 + XRender::TargetOverscanX, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));
        SuperPrint(fmt::sprintf_ne("MUSF: %s", currentMusicFile.empty() ? "<none>" : currentMusicFile.c_str()),
                   3, 10 + XRender::TargetOverscanX, YLINE, XTColorF(0.5_n, 1.0_n, 1.0_n));

        SuperPrint(fmt::sprintf_ne("DRAW: T=%03d S=%03d P=%03d L=%03d, SUM=%03d",
                                   renderedTiles, renderedScenes, renderedPaths, renderedLevels,
                                   (renderedTiles + renderedScenes + renderedPaths + renderedLevels)),
                   3, 10 + XRender::TargetOverscanX, YLINE);
        SuperPrint(fmt::sprintf_ne("CHEK: T=%03d S=%03d P=%03d L=%03d, SUM=%03d",
                                   checkedTiles, checkedScenes, checkedPaths, checkedLevels,
                                   (checkedTiles + checkedScenes + checkedPaths + checkedLevels)),
                   3, 10 + XRender::TargetOverscanX, YLINE);

        s_print_ram(10 + XRender::TargetOverscanX, YLINE);
    }
    else if(XRender::TargetW >= 720 && XRender::TargetH >= 360)
    {
        // threshold of 720
        int next_y = 6;
        print_filenames(6 + XRender::TargetOverscanX, next_y);

        next_y += (GameMenu) ? 6 + 18 * 4 : 6 + 18 * 3;

        if(!GameMenu)
        {
            print_cpu_stats(6 + XRender::TargetOverscanX, next_y);
            print_obj_stats(6 + 340 + XRender::TargetOverscanX, next_y);
            s_print_ram(6 + XRender::TargetOverscanX, next_y + 6 + 18 * 6);
        }
        else
        {
            print_obj_stats(6 + XRender::TargetOverscanX, next_y);
            s_print_ram(6 + XRender::TargetOverscanX, next_y + 6 + 18 * 5);
        }
    }
    else if(page == 1)
        print_filenames(6 + XRender::TargetOverscanX, 6);
    else if(page == 3)
        s_print_ram(6 + XRender::TargetOverscanX, 6);
    else if(page == 4 && !GameMenu)
        print_cpu_stats(6 + XRender::TargetOverscanX, 6);
    else
        print_obj_stats(6 + XRender::TargetOverscanX, 6);
}

#undef YLINE

//#if !defined(__EMSCRIPTEN__)
#define USE_NEW_TIMER
#define USE_NEW_FRAMESKIP
//#endif

#ifdef USE_NEW_TIMER
#define COMPUTE_FRAME_TIME_1_REAL computeFrameTime1Real_2
#define COMPUTE_FRAME_TIME_2_REAL computeFrameTime2Real_2
#else
#define COMPUTE_FRAME_TIME_1_REAL computeFrameTime1Real
#define COMPUTE_FRAME_TIME_2_REAL computeFrameTime2Real
#endif


#ifdef USE_NEW_TIMER

#define ONE_MILLIARD 1000000000

typedef int64_t nanotime_t;

static inline nanotime_t getNanoTime()
{
    return static_cast<nanotime_t>(SDL_GetTicks()) * 1000000;
}

static inline nanotime_t getElapsedTime(nanotime_t oldTime)
{
    return getNanoTime() - oldTime;
}

static inline nanotime_t getSleepTime(nanotime_t oldTime, nanotime_t target)
{
    return target - getElapsedTime(oldTime);
}

static inline void xtech_nanosleep(nanotime_t sleepTime)
{
    if(sleepTime <= 0)
        return;
    PGE_Delay((uint32_t)((sleepTime + 999999) / 1000000));
}


struct TimeStore
{
    const size_t size = 4;
    size_t       pos = 0;
    nanotime_t   sum = 0;
    nanotime_t   items[4] = {0, 0, 0, 0};

    void add(nanotime_t item)
    {
        sum -= items[pos];
        sum += item;
        items[pos] = item;
        pos = (pos + 1) % size;
    }

    nanotime_t average()
    {
        return sum / size;
    }
};

static TimeStore         s_overheadTimes;
static const  nanotime_t c_frameRateNano = 1000000000.0 / 64.1025;
static nanotime_t        s_oldTime = 0,
                         s_overhead = 0;
#ifdef USE_NEW_FRAMESKIP
static nanotime_t        s_startProcessing = 0;
static nanotime_t        s_stopProcessing = 0;
static nanotime_t        s_doUpdate = 0;
#endif

#endif
// ----------------------------------------------------

//Public Const frameRate As Double = 15 'for controlling game speed
//const int frameRate = 15;
static const  int64_t c_frameRate = 15;

static int64_t s_overTime = 0;
static int64_t s_goalTime = 0;
static int64_t s_fpsCount = 0;
static int64_t s_fpsTime = 0;
static int    s_cycleCount = 0;
static int64_t s_gameTime = 0;
static int64_t s_currentTicks = 0;


void resetFrameTimer()
{
    s_overTime = 0;
    s_fpsCount = 0;
    s_fpsTime = 0;
    s_cycleCount = 0;
    s_gameTime = 0;
#ifdef USE_NEW_FRAMESKIP
    s_doUpdate = 0;
    s_goalTime = 0;
#else
    s_goalTime = SDL_GetTicks() + 1000;
#endif
    // D_pLogDebugNA("Time counter reset was called");
}

void resetTimeBuffer()
{
    s_currentTicks = 0;
}

#ifdef USE_NEW_FRAMESKIP

bool frameSkipNeeded()
{
    return s_doUpdate > 0;
}

#else

bool frameSkipNeeded() // Old and buggy Redigit's
{
    return SDL_GetTicks() + SDL_floor(1000 * (1 - (s_cycleCount / 63.0))) > s_goalTime;
}

#endif

void frameNextInc()
{
    s_fpsCount += 1;
}

void cycleNextInc()
{
    s_cycleCount++;
}

extern void CheckActive(); // game_main.cpp

static inline bool canProcessFrameCond()
{
    bool ret = s_currentTicks >= s_gameTime + c_frameRate || s_currentTicks < s_gameTime || g_config.unlimited_framerate;
#ifdef USE_NEW_FRAMESKIP
    if(ret && s_doUpdate <= 0)
        s_startProcessing = getNanoTime();
#endif
    return ret;
}

bool canProceedFrame()
{
    s_currentTicks = SDL_GetTicks();
    return canProcessFrameCond();
}

#ifndef USE_NEW_TIMER
static inline void computeFrameTime1Real()
{
    if(s_fpsCount >= 32000)
        s_fpsCount = 0; // Fixes Overflow bug

    if(s_cycleCount >= 32000)
        s_cycleCount = 0; // Fixes Overflow bug

    s_overTime += (s_currentTicks - (s_gameTime + c_frameRate));

    if(s_gameTime == 0.0)
        s_overTime = 0;

    if(s_overTime <= 1)
        s_overTime = 0;
    else if(s_overTime > 1000)
        s_overTime = 1000;

    s_gameTime = s_currentTicks - s_overTime;
    s_overTime -= (s_currentTicks - s_gameTime);
}

static inline void computeFrameTime2Real()
{
    if(SDL_GetTicks() > s_fpsTime)
    {
        if(s_cycleCount >= 65)
        {
            s_overTime = 0;
            s_gameTime = s_currentTicks;
        }
        s_cycleCount = 0;
        s_fpsTime = SDL_GetTicks() + 1000;
        s_goalTime = s_fpsTime;
        //      if(Debugger == true)
        //          frmLevelDebugger.lblFPS = fpsCount;

        // if(g_config.show_fps)
        PrintFPS = s_fpsCount;

        s_fpsCount = 0;
    }
}
#endif


#ifdef USE_NEW_TIMER
static inline void computeFrameTime1Real_2()
{
    if(s_fpsCount >= 32000)
        s_fpsCount = 0; // Fixes Overflow bug

    if(s_cycleCount >= 32000)
        s_cycleCount = 0; // Fixes Overflow bug
}

static inline void computeFrameTime2Real_2()
{
#ifdef USE_NEW_FRAMESKIP
    if(s_doUpdate > 0)
        s_doUpdate -= c_frameRateNano;

    s_startProcessing = 0;
    s_stopProcessing = 0;
#endif

    if(SDL_GetTicks() > s_fpsTime)
    {
        if(s_cycleCount >= 65)
        {
            s_overTime = 0;
            s_gameTime = s_currentTicks;
        }

        s_cycleCount = 0;
        s_fpsTime = SDL_GetTicks() + 1000;
        s_goalTime = s_fpsTime;

        // if(g_config.show_fps)
        PrintFPS = s_fpsCount;

        s_fpsCount = 0;
    }

    if(!g_config.unlimited_framerate)
    {
        nanotime_t start = getNanoTime();
        nanotime_t sleepTime = getSleepTime(s_oldTime, c_frameRateNano);
        s_overhead = s_overheadTimes.average();

        // D_pLogDebug("ST=%lld, OH=%lld", sleepTime, s_overhead);
        if(sleepTime > s_overhead)
        {
            nanotime_t adjustedSleepTime = sleepTime - s_overhead;
            if(adjustedSleepTime > 500000000)
            {
                pLogWarning("frame_timer: Adjusted sleep time got a too big value: %ld", (long)adjustedSleepTime);
                adjustedSleepTime = 500000000;
            }

            xtech_nanosleep(adjustedSleepTime);
            auto e = getElapsedTime(start);
            nanotime_t overslept = e - adjustedSleepTime;
            // SDL_assert(overslept >= 0);
            if(overslept < 0)
                s_overheadTimes.add(0);
            else if(overslept < c_frameRateNano)
                s_overheadTimes.add(overslept);
        }
    }

    s_oldTime = getNanoTime();
}
#endif


void computeFrameTime1()
{
    COMPUTE_FRAME_TIME_1_REAL();
}

void computeFrameTime2()
{
    COMPUTE_FRAME_TIME_2_REAL();
}

void runFrameLoop(LoopCall_t doLoopCallbackPre,
                  LoopCall_t doLoopCallbackPost,
                  std::function<bool(void)> condition,
                  std::function<bool ()> subCondition,
                  std::function<void ()> preTimerExtraPre,
                  std::function<void ()> preTimerExtraPost)
{
    do
    {
        if(preTimerExtraPre)
            preTimerExtraPre();

        if(XMessage::GetStatus() != XMessage::Status::replay)
            XEvents::doEvents();

        s_currentTicks = SDL_GetTicks();

        if(preTimerExtraPost)
            preTimerExtraPost();

        if(canProcessFrameCond())
        {
            CheckActive();
            if(doLoopCallbackPre)
                doLoopCallbackPre();

            COMPUTE_FRAME_TIME_1_REAL();

            if(doLoopCallbackPost)
                doLoopCallbackPost(); // Run the loop callback

            if(XMessage::GetStatus() != XMessage::Status::replay)
                XEvents::doEvents();

            COMPUTE_FRAME_TIME_2_REAL();

            if(subCondition && subCondition())
                break;
        }

        if(!g_config.unlimited_framerate)
            PGE_Delay(1);

        if(!GameIsActive)
            break;// Break on quit
    }
    while(condition());
}

void frameRenderStart()
{
#ifdef USE_NEW_FRAMESKIP
    if(s_doUpdate <= 0)
        s_startProcessing = getNanoTime();
#endif
}

void frameRenderEnd()
{
#ifdef USE_NEW_FRAMESKIP
    if(s_doUpdate <= 0)
    {
        s_stopProcessing = getNanoTime();
        nanotime_t newTime = g_config.enable_frameskip ? (s_stopProcessing - s_startProcessing): 0;
        // D_pLogDebug("newTime/nano=%lld (%lld)", newTime/c_frameRateNano, newTime / 1000000);
        if(newTime > c_frameRateNano * 25) // Limit 25 frames being skipped maximum
        {
            D_pLogDebug("frame_timer: Overloading detected: %lld frames to skip (%lld milliseconds delay)", (long long)newTime / c_frameRateNano, (long long)newTime / 1000000);
            newTime = c_frameRateNano * 25;
        }

        s_doUpdate += newTime * 300 / 166;
        s_goalTime = double(SDL_GetTicks() + (newTime / 1000000));
    }
#endif
}


================================================
FILE: src/frame_timer.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef FRAME_TIMER_H
#define FRAME_TIMER_H

#include <cstdint>
#include <functional>

struct MicroStats
{
public:
    enum Task
    {
        Script,
        Controls,
        Layers,
        NPCs,
        Blocks,
        Effects,
        Player,
        Camera,
        Graphics,
        Events,
        Sound,
        TASK_END
    };

    const char* const task_names[TASK_END] =
    {
        "Sct",
        "Ctl",
        "Lay",
        "NPC",
        "Blk",
        "Eff",
        "Plr",
        "Cam",
        "Gfx",
        "Evt",
        "Snd",
    };

private:
    uint8_t m_cur_task = TASK_END;
    uint8_t m_cur_frame = 0;
    uint64_t m_level_frame = 0;
    uint64_t m_cur_time = 0;
    uint64_t m_cur_timer[TASK_END] = {0};

    uint64_t m_frame_time = 0;
    uint64_t m_slow_frame_time = 0;

public:
    uint64_t level_timer[TASK_END] = {0};
    int view_timer[TASK_END] = {0};
    int view_total = 0;
    int view_slow_frame_time = 0;

    void reset();
    void start_task(Task task);
    void start_sleep();
    void end_frame();

};

struct PerformanceStats_t
{
    // How many objects got drawn in one frame
    int renderedBlocks = 0;
    // int renderedSzBlocks = 0; // combined with normal blocks
    int renderedBGOs = 0;
    int renderedNPCs = 0;
    int renderedEffects = 0;

    // How many objects got scanned to find what to render
    int checkedBlocks = 0;
    // int checkedSzBlocks = 0;
    int checkedBGOs = 0;
    // int checkedNPCs = 0; // use active NPCs
    // int checkedEffects = 0; // use total effects

    int renderedTiles = 0;
    int renderedScenes = 0;
    int renderedPaths = 0;
    int renderedLevels = 0;

    int checkedTiles = 0;
    int checkedScenes = 0;
    int checkedPaths = 0;
    int checkedLevels = 0;

    int page = 0;

    // Displays title of the music OR filename
    std::string currentMusic;
    std::string currentMusicFile;

    void next_page();

    void reset();
    void print_filenames(int x, int y);
    void print_obj_stats(int x, int y);
    void print_cpu_stats(int x, int y);
    // void print_ram_stats();
    void print();
};

extern MicroStats g_microStats;
extern PerformanceStats_t g_stats;

void resetFrameTimer();
void resetTimeBuffer();
bool frameSkipNeeded();

typedef void (*LoopCall_t)(void);

bool canProceedFrame();
void computeFrameTime1();
void computeFrameTime2();
void frameNextInc();
void cycleNextInc();

void frameRenderStart();
void frameRenderEnd();

void runFrameLoop(LoopCall_t doLoopCallbackPre,
                  LoopCall_t doLoopCallbackPost,
                  std::function<bool ()> condition,
                  std::function<bool ()> subCondition = nullptr,
                  std::function<void ()> preTimerExtraPre = nullptr,
                  std::function<void ()> preTimerExtraPost = nullptr);

#endif // FRAME_TIMER_H


================================================
FILE: src/frm_main.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>

#if defined(__WII__) || defined(__3DS__) || !defined(RENDER_CUSTOM)
#   include <Graphics/graphics_funcs.h>
#endif

#include "../version.h"

#include "gfx.h"
#include "config.h"
#ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED
#   include "change_res.h"
#endif

#include "core/render.h"
#include "core/window.h"
#include "core/msgbox.h"
#include "core/events.h"

#ifndef THEXTECH_NO_SDL_CORE
#   include "core/sdl/sdl_core.h"
#endif

#ifdef CORE_EVERYTHING_SDL

#   include "core/sdl/render_sdl.h"
#   include "core/opengl/render_gl.h"

#   define USE_CORE_RENDER_SDL

#   include "core/sdl/window_sdl.h"
typedef WindowSDL WindowUsed;
#   define USE_CORE_WINDOW_SDL

#   ifdef __WIIU__
#       include "core/wiiu/msgbox_wiiu.h"
typedef MsgBoxWiiU MsgBoxUsed;
#       define SDL_CORE_MSGBOX_WIIU
#   else
#       include "core/sdl/msgbox_sdl.h"
typedef MsgBoxSDL MsgBoxUsed;
#       define SDL_CORE_MSGBOX_SDL
#   endif

#   include "core/sdl/events_sdl.h"
typedef EventsSDL EventsUsed;
#   define USE_CORE_EVENTS_SDL
#endif

#include "fontman/font_manager.h"

#include "frm_main.h"

FrmMain g_frmMain;

bool FrmMain::initSystem(const CmdLineSetup_t &setup)
{
    bool res = false;

    LoadLogSettings(setup.interprocess, setup.verboseLogging);
    //Write into log the application start event
    pLogInfo("<Application started>");
    pLogInfo("TheXTech %s (branch %s, commit %s)", V_LATEST_STABLE, V_BUILD_BRANCH, V_BUILD_VER);

#ifndef THEXTECH_NO_SDL_CORE
    res = CoreSDL::init(setup);
    if(!res)
        return false;
#endif

#if defined(__WII__) || defined(__3DS__) || !defined(RENDER_CUSTOM)
    //Initialize FreeImage
    D_pLogDebugNA("FrmMain: Loading FreeImage...");
    GraphicsHelps::initFreeImage();
#endif

    // Build interfaces
#ifndef WINDOW_CUSTOM
    WindowUsed *window = new WindowUsed();
    m_window.reset(window);
    g_window = m_window.get();
#endif

#ifdef USE_CORE_RENDER_SDL


#   ifdef RENDERGL_SUPPORTED
    bool try_gl = false;

    if(    g_config.render_mode == Config_t::RENDER_ACCELERATED_AUTO
        || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL
        || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL_ES
        || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL_LEGACY
        || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL_ES_LEGACY)
    {
        RenderGL *render = new RenderGL();
        m_render.reset(render);
        g_render = m_render.get();
        try_gl = true;
    }
    else
#   endif // #ifdef RENDERGL_SUPPORTED

    {
        RenderSDL *render = new RenderSDL();
        m_render.reset(render);
        g_render = m_render.get();
    }

#endif

#ifndef MSGBOX_CUSTOM
    MsgBoxUsed *msgbox = new MsgBoxUsed();
    m_msgbox.reset(msgbox);
    g_msgBox = m_msgbox.get();
#endif

#ifndef EVENTS_CUSTOM
    EventsUsed *events = new EventsUsed();
    m_events.reset(events);
    g_events = m_events.get();
#endif

    // Initializing window

#ifdef WINDOW_CUSTOM
    D_pLogDebugNA("FrmMain: Loading XWindow...");
    res = XWindow::init();
#elif defined(USE_CORE_WINDOW_SDL)
    res = window->initSDL(g_render->SDL_InitFlags());
#else
#   error "FIXME: Implement supported window initialization here"
#endif

    if(!res)
    {
#ifndef THEXTECH_NO_SDL_CORE
        CoreSDL::quit();
#endif
        return true;
    }


    // Initializing message box

#ifdef MSGBOX_CUSTOM
    D_pLogDebugNA("FrmMain: Loading XMsgBox...");
    res &= XMsgBox::init();
#elif defined(USE_CORE_WINDOW_SDL) && defined(SDL_CORE_MSGBOX_SDL)
    msgbox->init(window->getWindow());
#elif defined(SDL_CORE_MSGBOX_WIIU)
    // Nothing to do for Wii U
#else
#   error "FIXME: Implement supported message boxes initialization here"
#endif



    // Initializing events

#ifdef EVENTS_CUSTOM
    D_pLogDebugNA("FrmMain: Loading XEvents...");
    res &= XEvents::init();
#else
    events->init(this);
#endif


#if defined(_WIN32) && !defined(RENDER_FULLSCREEN_ALWAYS) && defined(RENDER_FULLSCREEN_TYPES_SUPPORTED)
    if(g_config.fullscreen_type == Config_t::FULLSCREEN_TYPE_EXCLUSIVE)
    {
        XWindow::setFullScreenType(g_config.fullscreen_type);
        if(g_config.fullscreen)
        {
            UpdateInternalRes();
            XWindow::setWindowSize(XRender::TargetW, XRender::TargetH);
            XWindow::setFullScreen(g_config.fullscreen);
        }
    }
#endif

    // Initializing render
    pLogDebug("Init renderer settings...");

#ifdef RENDER_CUSTOM
    D_pLogDebugNA("FrmMain: Loading XRender...");
    res &= XRender::init();
#elif defined(USE_CORE_WINDOW_SDL) && defined(USE_CORE_RENDER_SDL)
    res = g_render->initRender(window->getWindow());

#   ifdef RENDERGL_SUPPORTED
    if(try_gl && !res)
    {
        pLogDebug("FrmMain: closing Render GL");
        m_render->clearAllTextures();
        m_render->close();

        msgbox->close();
        window->close();

        m_render.reset();
        g_render = nullptr;

        pLogDebug("FrmMain: retrying with Render SDL layer...");

        RenderSDL *render = new RenderSDL();
        m_render.reset(render);
        g_render = m_render.get();

        // make new window
        res = window->initSDL(g_render->SDL_InitFlags());

        if(res)
        {
            msgbox->init(window->getWindow());
            res = g_render->initRender(window->getWindow());
        }
    }
#   endif // #ifdef RENDERGL_SUPPORTED

#else
#   error "FIXME: Implement supported render initialization here"
#endif

    if(!res)
    {
        D_pLogCriticalNA("FrmMain: Error has occured, exiting...");
        freeSystem();
        return true;
    }

#ifdef RENDER_FULLSCREEN_ALWAYS // Use a full-screen on Android & PS Vita mode by default
    XWindow::setFullScreen(true);
    XWindow::show();
#else
#   ifdef RENDER_FULLSCREEN_TYPES_SUPPORTED
    WindowSDL::setHasFrameBuffer(m_render->hasFrameBuffer());
    XWindow::setFullScreenType(g_config.fullscreen_type);
    XWindow::setFullScreen(g_config.fullscreen);
#   endif
#   ifdef _WIN32
    XWindow::show();
#   endif
#endif

    XEvents::doEvents();

    return !res;
}

void FrmMain::freeSystem()
{
    FontManager::quit();

    GFX.unLoad();

#ifdef RENDER_CUSTOM
    XRender::quit();
#else
    if(m_render)
    {
        m_render->clearAllTextures();
        m_render->close();
    }

    m_render.reset();
    g_render = nullptr;
#endif

#ifdef MSGBOX_CUSTOM
    XMsgBox::quit();
#else
    if(m_msgbox)
        m_msgbox->close();

    m_msgbox.reset();
    g_msgBox = nullptr;
#endif

#ifdef EVENTS_CUSTOM
    XEvents::quit();
#else
    m_events.reset();
    g_events = nullptr;
#endif

#ifdef WINDOW_CUSTOM
    XWindow::quit();
#else
    if(m_window)
        m_window->close();

    m_window.reset();
    g_window = nullptr;
#endif

#if defined(__WII__) || defined(__3DS__) || !defined(RENDER_CUSTOM)
    GraphicsHelps::closeFreeImage();
#endif

    pLogInfo("<Application closed>");
    CloseLog();

#ifndef THEXTECH_NO_SDL_CORE
    CoreSDL::quit();
#endif
}

bool FrmMain::restartRenderer()
{
#ifndef THEXTECH_RESTART_RENDERER_SUPPORTED
    return false;
#else // #ifndef THEXTECH_RESTART_RENDERER_SUPPORTED
    pLogDebug("FrmMain: attempting to restart XRender...");

    bool res;

#    ifdef RENDER_CUSTOM
    // custom renderer
    XRender::quit();

    res = XRender::init();

#    elif defined(RENDERGL_SUPPORTED)

    if(m_render)
    {
        m_render->clearAllTextures();
        m_render->close();
    }

    g_msgBox->close();
    g_window->close();

    m_render.reset();
    g_render = nullptr;

    bool try_gl = false;

    CmdLineSetup_t setup;

    if(g_config.render_mode == Config_t::RENDER_ACCELERATED_AUTO || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL_ES || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL_LEGACY || g_config.render_mode == Config_t::RENDER_ACCELERATED_OPENGL_ES_LEGACY)
    {
        m_render.reset(new RenderGL());
        try_gl = true;
    }
    else
    {
        m_render.reset(new RenderSDL());
    }

    g_render = m_render.get();

    res = reinterpret_cast<WindowUsed*>(g_window)->initSDL(g_render->SDL_InitFlags());

    if(res)
    {
        reinterpret_cast<MsgBoxUsed*>(g_msgBox)->init(reinterpret_cast<WindowUsed*>(g_window)->getWindow());
        res = m_render->initRender(reinterpret_cast<WindowUsed*>(g_window)->getWindow());
    }

    if(try_gl && !res)
    {
        pLogDebug("FrmMain: closing Render GL");
        m_render->clearAllTextures();
        m_render->close();

        g_msgBox->close();
        g_window->close();

        m_render.reset();
        g_render = nullptr;

        pLogDebug("FrmMain: retrying with Render SDL layer...");

        RenderSDL *render = new RenderSDL();
        m_render.reset(render);
        g_render = m_render.get();

        res = reinterpret_cast<WindowUsed*>(g_window)->initSDL(g_render->SDL_InitFlags());

        if(res)
        {
            reinterpret_cast<MsgBoxUsed*>(g_msgBox)->init(reinterpret_cast<WindowUsed*>(g_window)->getWindow());
            res = g_render->initRender(reinterpret_cast<WindowUsed*>(g_window)->getWindow());
        }

        res = false;
    }

#    else
    // SDL, no OpenGL

    if(m_render)
    {
        m_render->clearAllTextures();
        m_render->close();
    }

    m_render.reset();
    g_render = nullptr;

    m_render.reset(new RenderSDL());

    g_render = m_render.get();

    CmdLineSetup_t setup;

    res = m_render->initRender(setup, reinterpret_cast<WindowUsed*>(g_window)->getWindow());
#    endif

    XWindow::show();

    return res;
#endif // #ifndef THEXTECH_RESTART_RENDERER_SUPPORTED
}


================================================
FILE: src/frm_main.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef FRMMAIN_H
#define FRMMAIN_H

#include <memory>
#include <string>

#include "cmd_line_setup.h"

#ifndef RENDER_CUSTOM
#include "core/base/render_base.h"
#endif

#ifndef RENDER_CUSTOM
#include "core/base/window_base.h"
#endif

#ifndef MSGBOX_CUSTOM
#include "core/base/msgbox_base.h"
#endif

#ifndef EVENTS_CUSTOM
#include "core/base/events_base.h"
#endif

class FrmMain
{
#ifndef WINDOW_CUSTOM
    std::unique_ptr<AbstractWindow_t> m_window;
#endif

#ifndef RENDER_CUSTOM
    std::unique_ptr<AbstractRender_t> m_render;
#endif

#ifndef MSGBOX_CUSTOM
    std::unique_ptr<AbstractMsgBox_t> m_msgbox;
#endif

#ifndef EVENTS_CUSTOM
    std::unique_ptr<AbstractEvents_t> m_events;
#endif

public:
    FrmMain() noexcept = default;
    ~FrmMain() = default;

    bool initSystem(const CmdLineSetup_t &setup);
    void freeSystem();

    bool restartRenderer();
};

extern FrmMain g_frmMain;

#endif // FRMMAIN_H


================================================
FILE: src/game_main.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef PGE_NO_THREADING
#include <SDL2/SDL_atomic.h>
#include <SDL2/SDL_thread.h>
#endif

#ifdef __WIIU__
#include <sysapp/launch.h>
#endif

#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
#   include <CrashHandler/crash_handler.h>
#   include <signal.h>
#endif

#include <Logger/logger.h>
#include <Utils/files.h>
#include <Utils/strings.h>
#include <Archives/archives.h>
#include <AppPath/app_path.h>
#include <Integrator/integrator.h>
#include <PGE_File_Formats/file_formats.h>
#ifdef THEXTECH_INTERPROC_SUPPORTED
#   include <InterProcess/intproc.h>
#endif
#include <pge_delay.h>
#include <fmt_format_ne.h>
#include <sorting/tinysort.h>

#ifdef ENABLE_XTECH_LUA
#include "xtech_lua_main.h"
#endif

#ifdef THEXTECH_ENABLE_SDL_NET
#include "main/client_methods.h"
#endif

#include "sdl_proxy/sdl_timer.h"

#include "globals.h"
#include "game_main.h"
#include "gfx.h"

#include "config.h"
#include "message.h"
#include "frame_timer.h"
#include "blocks.h"
#include "change_res.h"
#include "collision.h"
#include "effect.h"
#include "eff_id.h"
#include "graphics.h"
#include "layers.h"
#include "load_gfx.h"
#include "player.h"
#include "sound.h"
#include "editor.h"
#include "editor/new_editor.h"
#include "custom.h"
#include "main/world_globals.h"
#include "main/cheat_code.h"
#include "main/game_globals.h"
#include "main/level_file.h"
#include "main/world_file.h"
#include "main/speedrunner.h"
#include "main/menu_main.h"
#include "main/game_info.h"
#include "main/outro_loop.h"
#include "editor/editor_strings.h"
#include "main/game_strings.h"
#include "main/translate.h"
#include "main/record.h"
#include "main/asset_pack.h"
#include "core/render.h"
#include "core/window.h"
#include "core/events.h"
#include "core/msgbox.h"
#include "core/language.h"
#include "script/luna/luna.h"
#include "fontman/font_manager.h"

#include "pseudo_vb.h"

#include "controls.h"

#include "main/screen_connect.h"
#include "main/screen_quickreconnect.h"
#include "main/screen_asset_pack.h"
#include "main/game_loop_interrupt.h"

#include "main/level_medals.h"

#include "main/trees.h"

bool g_ShortDelay = false;

void CheckActive();
// set up sizable blocks
void SizableBlocks();

// game_main_setupphysics.cpp

static int loadingThread(void *waiter_ptr)
{
#ifndef PGE_NO_THREADING
    auto *waiter = (SDL_atomic_t *)waiter_ptr;
#else
    UNUSED(waiter_ptr);
#endif

    LoaderUpdateDebugString(g_gameStrings.loaderStatusGameInfo);
    initGameInfo();
    cheats_reset();
    ConfigReloadRecentEpisodes();

    LoaderUpdateDebugString(g_gameStrings.loaderStatusTranslations);
    XLanguage::findLanguages(); // find present translations
    ReloadTranslations(); // load translations

    LoaderUpdateDebugString(g_gameStrings.loaderStatusAssetPacks);
    GetAssetPacks();

    SetupPhysics(); // Setup Physics
    SetupGraphics(); // setup graphics
//    Load GFX 'load the graphics form
//    GFX.load(); // load the graphics form // Moved to before sound load
    SizableBlocks();
    LoadGFX(); // load the graphics from file

    Controls::LoadTouchScreenGFX();

    SetupVars(); //Setup Variables

#ifdef THEXTECH_PRELOAD_LEVELS
    LoaderUpdateDebugString("Worlds preload");
    FindWorlds();
    LoaderUpdateDebugString("Levels preload");
    FindLevels();
#endif

    InitSound(); // Setup sound effects

    LoaderUpdateDebugString(g_gameStrings.loaderStatusFinishing, true);
    UpdateLoad();

#ifndef PGE_NO_THREADING
    if(waiter)
        SDL_AtomicSet(waiter, 0);
#endif

    return 0;
}

static std::string getIntrFile()
{
    auto introPath = AppPath + "intro.lvlx";

    if(!Files::fileExists(introPath))
        introPath = AppPath + "intro.lvl";

    if(!Files::fileExists(introPath))
        return std::string();

    pLogDebug("Found root intro level file: %s", introPath.c_str());

    return introPath;
}

/**
 * @brief Choice randomly one of level from the directory
 * @param out The selection path (absolute path)
 * @param dir Directory with levels, must end with /
 * @param rootIntro The fallback absolute path to level if introset not exists or empty
 * @return true if choice was done, otherwise, nothing
 */
static bool choiceFromIntroset(std::string &out, const std::string &dir, const std::string &rootIntro = std::string())
{
    DirMan introSet(dir);
    std::vector<std::string> intros;

    if(!introSet.exists() || !introSet.getListOfFiles(intros, {".lvl", "lvlx"}) || intros.empty())
    {
        if(rootIntro.empty())
            return false;
        else
        {
            out = rootIntro;
            return true;
        }
    }

    tinysort(intros.begin(), intros.end());

    for(auto &i : intros)
    {
        i.insert(0, dir);
        pLogDebug("Found introset intro level: %s", i.c_str());
    }

    // The final choice
    out = intros[iRand2T(intros.size())];

    return true;
}

static std::string findIntroLevel()
{
    std::string choice;

    // Try to find custom intros
    if(!g_recentWorldIntro.empty())
    {
        if(DirMan::exists(g_recentWorldIntro)) // If path is a directory
        {
            if(g_recentWorldIntro.back() != '/')
                g_recentWorldIntro.push_back('/');

            if(choiceFromIntroset(choice, g_recentWorldIntro))
                return choice;
        }
        else if(Files::fileExists(g_recentWorldIntro))
            return g_recentWorldIntro;

        // When found nothing
        Strings::dealloc(g_recentWorldIntro);
    }

    // Find default set
    choiceFromIntroset(choice, AppPath + "introset/", getIntrFile());

    return choice;
}

// mount an archive used in an episode (or level)'s path
static std::string s_prepare_episode_path(const std::string& path)
{
    std::string target_path = path;

    // parse and mount assets if possible
    if(target_path[0] == '@')
    {
        // mount target, then replace path
        auto archive_end = target_path.begin();
        // don't check for path end until after the first slash
        while(archive_end != target_path.end() && *archive_end != '/' && *archive_end != '\\')
            ++archive_end;
        while(archive_end != target_path.end() && *archive_end != ':')
            ++archive_end;

        if(archive_end != target_path.end())
        {
            *archive_end = '\0';

            if(Archives::mount_episode(target_path.c_str() + 1))
            {
                target_path.erase(target_path.begin() + 2, archive_end + 1);
                target_path[0] = ':';
                target_path[1] = 'e';
            }
            else
                *archive_end = ':';
        }
    }

    return target_path;
}

// expand the section vertically if the top 8px of the level are empty
static void s_ExpandSectionForMenu()
{
    SpeedlessLocation_t& menu_section = level[0];

    // check current section top for expandability
    Location_t tempLocation = newLoc(menu_section.X, menu_section.Y, menu_section.Width - menu_section.X, 8);

    for(int A : treeBlockQuery(tempLocation, SORTMODE_NONE))
    {
        if(CheckCollision(Block[A].Location, tempLocation))
            return;
    }

    for(int A : treeBackgroundQuery(tempLocation, SORTMODE_NONE))
    {
        if(CheckCollision(Background[A].Location, tempLocation))
            return;
    }

    // expand level height to a maximum of 2160px
    if(menu_section.Y > menu_section.Height - 2160)
        menu_section.Y = menu_section.Height - 2160;
}

void ReportLoadFailure(const std::string& filename, bool isIPC)
{
#ifdef THEXTECH_ENABLE_SDL_NET
    XMessage::Disconnect();
#endif
#if !defined(THEXTECH_INTERPROC_SUPPORTED)
    UNUSED(isIPC);
#endif

    g_MessageType = MESSAGE_TYPE_SYS_WARNING;

    // temporarily store error code from load process in MessageTitle string
    std::swap(MessageText, MessageTitle);
#if defined(THEXTECH_INTERPROC_SUPPORTED)
    MessageText = isIPC ? g_gameStrings.errorOpenIPCDataFailed : fmt::format_ne(g_gameStrings.errorOpenFileFailed, filename);
#else
    MessageText = fmt::format_ne(g_gameStrings.errorOpenFileFailed, filename);
#endif

    // add error code from load process
    if(!MessageTitle.empty())
    {
        MessageText += '\n';
        MessageText += '\n';
        MessageText += MessageTitle;
        MessageTitle.clear();
    }

    PauseGame(PauseCode::Message);
}

void MainLoadAll()
{
    LoadingInProcess = true;

    if(g_AssetsLoaded)
    {
        StopAllSounds();
        StopMusic();

        UnloadSound();
        UnloadGFX(true);
    }

    if(ScreenAssetPack::g_LoopActive)
        PlayInitSound();

    if(FontManager::isInitied())
        FontManager::quit();

    LoaderInit();

    LoaderUpdateDebugString("Fonts");

    FontManager::initFull();

#ifndef PGE_NO_THREADING
    {
        gfxLoaderThreadingMode = true;

        SDL_Thread*     loadThread;
        SDL_atomic_t    loadWaiter;
        int             loadWaiterState = 1;
        int             threadReturnValue;

        SDL_AtomicSet(&loadWaiter, loadWaiterState);
        loadThread = SDL_CreateThread(loadingThread, "Loader", &loadWaiter);

        if(!loadThread)
        {
            gfxLoaderThreadingMode = false;
            pLogCritical("Failed to create the loading thread! Do running the load directly");
            loadingThread(nullptr);
        }
        else
        {
            do
            {
                UpdateLoadREAL();
                PGE_Delay(15);
                loadWaiterState = SDL_AtomicGet(&loadWaiter);
            } while(loadWaiterState);

            SDL_WaitThread(loadThread, &threadReturnValue);
            pLogDebug("Loading thread was exited with %d code.", threadReturnValue);

            // Draw last frame
            UpdateLoadREAL();
        }
    }
#else
    loadingThread(nullptr);
    UpdateLoad();
#endif

    Integrator::setGameName(g_gameInfo.title, g_gameInfo.statusIconName);
    XWindow::setTitle(g_gameInfo.titleWindow().c_str());
    XWindow::updateWindowIcon();

    LoaderFinish();
    LoadingInProcess = false;

    g_AssetsLoaded = true;
}


#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
static SDL_AssertState ingame_assert_sdl_handler(const SDL_AssertData *data, void *)
{
    CrashHandler::logAssertInfo(data);
    g_MessageType = MESSAGE_TYPE_SYS_FATAL_ASSERT;
    MessageTitle = "Fatal error!";
    MessageText =  fmt::sprintf_ne("Assertion condition has failed:\n"
                                   "\n"
                                   "File: %s(%d)\n"
                                   "Function: %s\n"
                                   "Condition: %s\n"
                                   "\n"
                                   "Game will be closed.\n\n"
                                   "See log for details:\n"
                                   "%s",
                                   data->filename, data->linenum,
                                   data->function,
                                   data->condition,
                                   getLogFilePath().c_str());
    PauseGame(PauseCode::Message);

    return SDL_ASSERTION_ABORT;
}

static void ingame_crash_msg_handler(const std::string &title, const std::string &message)
{
    CloseLog(); // Before this, last log message was written, so, no more logs will be printed
    g_MessageType = MESSAGE_TYPE_SYS_FATAL_ASSERT;
    MessageTitle = "Fatal error!";
    signal(SIGABRT, SIG_DFL);
    MessageText =  fmt::sprintf_ne("%s\n"
                                  "\n"
                                  "%s\n\n"
                                  "Game will be closed.\n\n"
                                  "See log for details:\n"
                                  "%s",
                                  title.c_str(),
                                  message.c_str(),
                                  getLogFilePath().c_str());
    PauseGame(PauseCode::Message);
}
#endif


int GameMain(const CmdLineSetup_t &setup)
{
    Player_t blankPlayer;
//    int A = 0;
//    int B = 0;
//    int C = 0;
    bool tempBool = false;
    int lastWarpEntered = 0;

//    LB = "\n";
//    EoT = "";

    // moved into MainLoadAll
    // cheats_reset();

    // [ !Here was a starting dialog! ]

    //    frmLoader.Show 'show the Splash screen
    //    Do
    //        DoEvents
    //    Loop While StartMenu = False 'wait until the player clicks a button

    // Set global SMBX64 behaviour at PGE-FL
    FileFormats::SetSMBX64LvlFlags(FileFormats::F_SMBX64_KEEP_LEGACY_NPC_IN_BLOCK_CODES);

    // StartMenu = true;
    MenuMode = MENU_INTRO;

    // strings and translation initialization moved into MainLoadAll
#if 0
    initOutroContent();
    initMainMenu();
    initEditorStrings();
    initGameStrings();

    if(!CurrentLanguage.empty())
    {
        XTechTranslate translator;
        if(translator.translate())
        {
            pLogDebug("Loaded translation for language %s-%s",
                      CurrentLanguage.c_str(),
                      CurrentLangDialect.empty() ? "??" : CurrentLangDialect.c_str());
        }
    }
#endif

    initAll();

    UpdateInternalRes();

//    Unload frmLoader
    gfxLoaderTestMode = setup.testLevelMode;

    // find asset pack and load required UI graphics
    bool init_failure = !InitUIAssetsFrom(setup.assetPack);

    if(init_failure)
        FontManager::initFallback();

//    If LevelEditor = False Then
//        frmMain.Show // Show window a bit later
//    XWindow::show();
//        GameMenu = True
    GameMenu = true;
//    Else
//        frmSplash.Show
//        BlocksSorted = True
//    End If

    LoadingInProcess = true;

    XEvents::doEvents();

#ifdef __EMSCRIPTEN__ // Workaround for a recent Chrome's policy to avoid sudden sound without user's interaction
    if(!init_failure)
        FontManager::initFull();

    XWindow::show(); // Don't show window until playing an initial sound

    while(!SharedCursor.Primary)
    {
        XRender::setTargetTexture();
        XRender::clearBuffer();
        SuperPrintScreenCenter("Click to start a game", 5, XRender::TargetH / 2 - 10);
        XRender::repaint();
        XRender::setTargetScreen();
        XEvents::doEvents();
        Controls::Update(false);
        PGE_Delay(10);
    }
#endif

    InitMixerX();

#ifndef PGE_NO_THREADING
    gfxLoaderThreadingMode = true;
#endif
    XWindow::show(); // Don't show window until playing an initial sound

#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
    SDL_SetAssertionHandler(&ingame_assert_sdl_handler, NULL);
    CrashHandler::setCrashMsgBoxHook(&ingame_crash_msg_handler);
#endif

    if(!setup.testLevelMode && !init_failure)
        PlayInitSound();

#ifdef THEXTECH_INTERPROC_SUPPORTED
    if(setup.interprocess)
        IntProc::init();
#endif

    Integrator::initIntegrations();

    // want to go directly to game content
    bool cmdline_content = (!setup.testLevel.empty() || !setup.testReplay.empty() || setup.interprocess);

    // special case: go straight to asset pack menu
    if(g_config.pick_assets_on_start && !cmdline_content && setup.assetPack.empty() && GetAssetPacks().size() > 1)
    {
        FontManager::initFull();
        Controls::LoadTouchScreenGFX();
        GameMenu = false;
        ScreenAssetPack::g_LoopActive = true;
    }
    // normal case: load everything and go to menu
    else if(!init_failure)
        MainLoadAll();

    LevelSelect = true; // world map is to be shown

    LoadingInProcess = false;

    // Clear the screen
    XRender::setTargetTexture();
    XRender::clearBuffer();
    XRender::repaint();
    XEvents::doEvents();

    if(!g_config.background_work && !XWindow::hasWindowInputFocus())
        SoundPauseEngine(1);

    if(init_failure)
    {
        GameMenu = false;
        LevelSelect = false;
        gSMBXHUDSettings.skip = true;
        numPlayers = 1;
        InitScreens();
        Screens_AssignPlayer(1, *l_screen);
        QuickReconnectScreen::g_active = true;

        g_MessageType = MESSAGE_TYPE_SYS_ERROR;
        MessageTitle = "Fatal: assets not found";
        MessageText = "Please extract a game/asset pack to:\n";

        for(auto& i : AppPathManager::assetsSearchPath())
        {
            MessageText += "\n";
            MessageText += i.first;

            if(i.second == AssetsPathType::Legacy)
                MessageText += "assets/<pack-id>/";
            else if(i.second == AssetsPathType::Multiple)
                MessageText += "<pack-id>/";
        }

        if(!setup.assetPack.empty())
        {
            MessageText = "Could not load cmdline-requested assets: ";
            MessageText += setup.assetPack;
        }

        PauseGame(PauseCode::Message);
        GracefulQuit();
        return 0;
    }
    else if(cmdline_content) // Start level testing immediately!
    {
        bool is_world = (Files::hasSuffix(setup.testLevel, ".wld") || Files::hasSuffix(setup.testLevel, ".wldx"));

        GameMenu = false;
        LevelSelect = is_world;

        if(!setup.testReplay.empty())
            Record::LoadReplay(setup.testReplay, setup.testLevel);
        else
            FullFileName = setup.testLevel;

        if(setup.testBattleMode && !is_world)
        {
            numPlayers = 2;
            BattleMode = true;
            BattleIntro = 150;
        }
        else
        {
            numPlayers = setup.testNumPlayers;
            BattleMode = false;
            BattleIntro = 0;
        }

        if(!is_world)
        {
            GodMode = setup.testGodMode;
            GrabAll = setup.testGrabAll;

            if(GodMode || GrabAll)
                Cheater = true;
        }

        editorScreen.ResetCursor();

        if(setup.testReplay.empty() && setup.testEditor)
        {
            editorScreen.active = false;
            MouseRelease = false;
            LevelEditor = true;
            WorldEditor = is_world;
            OpenLevel(FullFileName);
            editorScreen.ResetCursor();
            EditorBackup();
        }
        else if(is_world)
        {
            LoadSingleWorld(setup.testLevel);

            selWorld = 1;

            if(SelectWorld[selWorld].WorldFilePath.empty())
            {
                LevelSelect = false;
                TestLevel = true;
                EndLevel = false;

                ReportLoadFailure(setup.testLevel);
                ErrorQuit = true;
            }
            else
            {
                if(setup.testSave >= 0 && setup.testSave <= maxSaveSlots)
                {
                    selSave = setup.testSave;
                    FindSaves();
                }

                if(numPlayers < 1)
                    numPlayers = 1;

                for(int A = 1; A <= numCharacters; A++)
                    blockCharacter[A] = (g_forceCharacter) ? false : SelectWorld[selWorld].blockChar[A];

                // prepare for StartEpisode(): set player characters
                for(int i = 0; i < numPlayers; i++)
                {
                    if(testPlayer[i + 1].Character != 0)
                        l_screen->charSelect[i] = testPlayer[i + 1].Character;
                    else
                        l_screen->charSelect[i] = i + 1;

                    // replace blocked characters
                    if(blockCharacter[l_screen->charSelect[i]])
                    {
                        for(int new_char = 1; new_char <= numCharacters; new_char++)
                        {
                            // check it's unblocked
                            if(blockCharacter[new_char])
                                continue;

                            // check no other player has the character first
                            int j = 0;
                            for(; j < i; j++)
                            {
                                if(l_screen->charSelect[j] == new_char)
                                    break;
                            }

                            // if loop ended naturally, character is unused
                            if(j == i)
                            {
                                l_screen->charSelect[i] = new_char;
                                break;
                            }
                        }
                    }

                    if(i <= (int)Controls::g_InputMethods.size())
                        Controls::g_InputMethods.push_back(nullptr);
                }

                QuickReconnectScreen::g_active = true;

                StartEpisode();
            }
        }
        else
        {
            zTestLevel(setup.testMagicHand, setup.interprocess);

            if(!LevelName.empty())
                Integrator::setLevelName(LevelName);
            else
                Integrator::setLevelName(FileName);
        }
    }

    while(GameIsActive)
    {
        SyncSysCursorDisplay();

        if(ScreenAssetPack::g_LoopActive)
        {
            // make sure that controllers can connect properly
            numPlayers = maxLocalPlayers;

            // Run the frame-loop
            runFrameLoop(&ScreenAssetPack::Loop,
                         nullptr,
                        []()->bool{ return ScreenAssetPack::g_LoopActive;}, nullptr,
                        nullptr,
                        nullptr);
        }
        else if(LevelEditor) // Load the level editor
        {
            // if(resChanged)
            //     ChangeScreen();
            // BattleMode = false;
            SingleCoop = 0;
            numPlayers = 0;
            // ScreenType = 0; // set in SetupScreens()
            XEvents::doEvents();
            SetupEditorGraphics(); //Set up the editor graphics

            g_VanillaCam = false;

            InitScreens();
            UpdateInternalRes();

            for(int i = 0; i < maxLocalPlayers; i++)
                Screens_AssignPlayer(i + 1, *l_screen);

            SetupScreens();
            MagicHand = false;
            MouseRelease = false;
            ScrollRelease = false;

            // coming back from a level test
            if(!WorldEditor)
                EditorRestore();

            // Run the frame-loop
            runFrameLoop(&EditorLoop,
                         nullptr,
                        []()->bool{ return LevelEditor || WorldEditor;}, nullptr,
                        nullptr,
                        nullptr);

            MenuMode = MENU_INTRO;
            LevelEditor = false;
            WorldEditor = false;

            if(GameIsActive)
            {
                XRender::clearBuffer();
                XRender::repaint();
#ifdef THEXTECH_PRELOAD_LEVELS
                FindWorlds();
#endif
            }
        }

        // TheXTech Credits
        else if(GameOutro)
        {
            ShadowMode = false;
            GodMode = false;
            GrabAll= false;
            CaptainN = false;
            FlameThrower = false;
            FreezeNPCs = false;
            WalkAnywhere = false;
            MultiHop = false;
            SuperSpeed = false;
            FlyForever = false;
            GoToLevelNoGameThing = false;

            g_VanillaCam = false;
            UpdateInternalRes();

            for(int A = 1; A <= maxPlayers; A++)
                Player[A] = blankPlayer;

            GameMenu = false;
            StopMusic();

            std::string outroPath;

            if(!g_recentWorldOutro.empty() && Files::fileExists(g_recentWorldOutro))
                outroPath = g_recentWorldOutro;
            else
            {
                outroPath = AppPath + "outro.lvlx";

                if(!Files::fileExists(outroPath))
                    outroPath = AppPath + "outro.lvl";
            }

            OpenLevel(outroPath);

            numPlayers = g_gameInfo.outroMaxPlayersCount;
#ifdef __16M__
            if(numPlayers > 3)
                numPlayers = 3;
#endif
            if(g_gameInfo.outroDeadMode)
                numPlayers = 1; // Deadman mode

            SetupScreens();
            ClearBuffer = true;

            for(int A = 1; A <= numPlayers; ++A)
            {
                Player_t &p = Player[A];

                if(A <= (int)g_gameInfo.outroStates.size())
                    p.State = g_gameInfo.outroStates[A - 1];
                else if(A == 1)
                    p.State = 4;
                else if(A == 2)
                    p.State = 7;
                else if(A == 3)
                    p.State = 5;
                else if(A == 4)
                    p.State = 3;
                else
                    p.State = 6;

                p.Character = g_gameInfo.outroCharacterNext();

                if(A <= (int)g_gameInfo.outroMounts.size())
                {
                    p.Mount = g_gameInfo.outroMounts[A - 1];
                    switch(p.Mount)
                    {
                    case 1:
                        p.MountType = iRand(3) + 1;
                        break;
                    case 3:
                        p.MountType = iRand(8) + 1;
                        break;
                    default:
                        p.MountType = 0;
                    }
                }
                else if(A == 4)
                {
                    p.Mount = 1;
                    p.MountType = iRand(3) + 1;
                }
                else if(A == 2)
                {
                    p.Mount = 3;
                    p.MountType = iRand(8) + 1;
                }

                p.HeldBonus = NPCID(0);
                p.Section = 0;
                p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
            }

            SetupPlayers();
            GameOutroDoQuit = false;
            SetupCredits();

            // Update graphics before loop begin (to process an initial lazy-unpacking of used sprites)
            GraphicsLazyPreLoad();
            resetFrameTimer();

            for(int A = 1; A <= numPlayers; ++A)
            {
                if(g_gameInfo.outroWalkDirection == 0 && A <= (int)g_gameInfo.outroInitialDirections.size())
                {
                    if(g_gameInfo.outroInitialDirections[A - 1] < 0)
                        Player[A].Direction = -1;
                    else if(g_gameInfo.outroInitialDirections[A - 1] > 0)
                        Player[A].Direction = 1;
                }
            }

            if(g_gameInfo.outroDeadMode)
            {
                CheckSection(1);
                for(int A = 1; A <= numPlayers; ++A)
                    Player[A].Dead = true;
            }

            lunaLoad();

            clearScreenFaders();

            // Run the frame-loop
            runFrameLoop(&OutroLoop,
                         nullptr,
                        []()->bool{ return GameOutro;}, nullptr,
                        nullptr,
                        []()->void
                        {
                            SetupScreens();
                        });

            // Ensure everything is clear
            GraphicsClearScreen();
            XEvents::doEvents();
        }

        // quickly exit if returned to menu from world test
        else if(setup.testLevelMode && GameMenu)
        {
            GracefulQuit();
            return 0;
        }

        // The Game Menu
        else if(GameMenu)
        {
            {
                g_config.playstyle.m_value = Config_t::MODE_MODERN;
                g_config.playstyle.m_set = ConfigSetLevel::ep_config;

                if(g_config.speedrun_mode.m_set != ConfigSetLevel::cmdline)
                {
                    g_config.speedrun_mode.m_value = 0;
                    g_config.playstyle.m_set = ConfigSetLevel::ep_config;
                }
            }

            Integrator::clearEpisodeName();
            Integrator::clearLevelName();
            Integrator::clearEditorFile();
            FontManager::clearAllCustomFonts();

            BattleIntro = 0;
            BattleOutro = 0;
            // AllCharBlock = 0;
            Cheater = false;

            // in a main menu, reset this into initial state
            GoToLevelNoGameThing = false;

            for(int A = 1; A <= maxPlayers; ++A)
            {
                OwedMount[A] = 0;
                OwedMountType[A] = 0;
            }

            MenuMouseRelease = false;
            MenuMouseClick = false;
            MenuCursorCanMove = false;
            BattleMode = false;

            // if(MenuMode != MENU_BATTLE_MODE)
            // {
            //     PlayerCharacter = 0;
            //     PlayerCharacter2 = 0;
            // }

            pLogDebug("Clear check-points at Game Menu start");
            Checkpoint.clear();
            CheckpointsList.clear();
            g_curLevelMedals.reset_checkpoint();
            WorldPlayer[1].Frame = 0;
            cheats_clearBuffer();
            LevelBeatCode = BEATCODE_NONE;
            curWorldLevel = 0;

            lunaReset();
            ResetSoundFX();
            ClearWorld();

            ReturnWarp = 0;
            ReturnWarpSaved = 0;
            ShadowMode = false;
            GodMode = false;
            GrabAll = false;
            CaptainN = false;
            FlameThrower = false;
            FreezeNPCs = false;
            WalkAnywhere = false;
            MultiHop = false;
            SuperSpeed = false;
            FlyForever = false;
            BeatTheGame = false;
            g_ForceBitmaskMerge = false;
#ifdef __3DS__
            g_ForceBitmaskMerge = g_config.inaccurate_gifs;
#endif
            g_ClonedPlayerMode = false;
            g_CheatLogicScreen = false;
            g_CheatEditYourFriends = false;
            CanWallJump = false;
            g_VanillaCam = false;
            SharedPause = false;
            SharedPauseLegacy = false;
            XRender::unloadGifTextures();

            Controls::RemoveNullInputMethods();
            QuickReconnectScreen::Deactivate();

            // reset l_screen to index 0
            Screens[0] = *l_screen;
            l_screen = &Screens[0];

            // reset non-local screens' charSelect
            for(int s = 1; s < maxNetplayClients; s++)
                Screens[s].charSelect = {};

            // reinitialize the screens (resets multiplayer preferences and restores state disrupted by reassigning Screens[0])
            InitScreens();
            UpdateInternalRes();

            for(int i = 0; i < maxLocalPlayers; i++)
                Screens_AssignPlayer(i + 1, *l_screen);

            SetupScreens();

            BattleOutro = 0;
            BattleIntro = 0;

            for(int A = 1; A <= maxPlayers; ++A)
                Player[A] = blankPlayer;

            auto introPath = findIntroLevel();
            if(introPath.empty())
            {
                XMsgBox::errorMsgBox("Fatal error",
                                     "Can't find any intro level file to start the main menu.\n"
                                     "The game will be closed.\n"
                                     "\n"
                                     "Please make sure the intro.lvlx or intro.lvl file is exist\n"
                                     "in the game assets directory, or make sure the \"introset\" directory\n"
                                     "contains any valid level files.");
                return 1;// Fatal error happen
            }

            OpenLevel(introPath);
            Screens[0].vScreen(1).X = -level[0].X;
            Screens[0].canonical_screen().vScreen(1).X = -level[0].X;
            s_ExpandSectionForMenu();

            numPlayers = g_gameInfo.introMaxPlayersCount;
#ifdef __16M__
            if(numPlayers > 3)
                numPlayers = 3;
#endif
            if(g_gameInfo.introDeadMode)
                numPlayers = 1;// one deadman should be

            if(g_config.EnableInterLevelFade)
                g_levelScreenFader.setupFader(3, 65, 0, ScreenFader::S_FADE);
            else
                clearScreenFaders();

            setMusicStartDelay(); // Don't start music until all gfx will be loaded

            StartMusic(0);
            SetupPlayers();

            For(A, 1, numPlayers)
            {
                Player_t &p = Player[A];
                p.State = iRand(6) + 2;
                // p.Character = (iRand() % 5) + 1;

                // if(A >= 1 && A <= 5)
                p.Character = g_gameInfo.introCharacterNext();

                p.HeldBonus = NPCID(0);
                p.Section = 0;
                p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                p.Location.X = level[p.Section].X + ((128 + dRand() * 64) * A);
                p.Location.Y = level[p.Section].Height - p.Location.Height - 65;

                do
                {
                    tempBool = true;
                    for(int B : treeBlockQuery(p.Location, SORTMODE_NONE))
                    {
                        if(CheckCollision(p.Location, Block[B].Location))
                        {
                            p.Location.Y = Block[B].Location.Y - p.Location.Height - 0.1_n;
                            tempBool = false;
                        }
                    }
                } while(!tempBool);
                p.Dead = true;
            }

            // Update graphics before loop begin (to process inital lazy-unpacking of used sprites)
            GraphicsLazyPreLoad();
            resetFrameTimer();
            // Clear the speed-runner timer
            speedRun_resetTotal();

            lunaLoad();

            delayedMusicStart(); // Allow music being started

            ProcEvent(EVENT_LEVEL_START, 0, EventContext::InitSetup);
            For(A, 2, maxEvents)
            {
                if(Events[A].AutoStart)
                    ProcEvent(A, 0, EventContext::InitSetup);
            }

            // Main menu loop
            runFrameLoop(&MenuLoop, nullptr, []()->bool{ return GameMenu;});
            if(!GameIsActive)
            {
                speedRun_saveStats();
                return 0;// Break on quit
            }

            // Ensure everything is clear if the main menu is no longer active
            if(!ScreenAssetPack::g_LoopActive)
            {
                GraphicsClearScreen();
                XEvents::doEvents();
            }
        }

        // World Map
        else if(LevelSelect)
        {
            // only set if loading the WORLD fails
            if(ErrorQuit)
            {
                ErrorQuit = false;
                GameMenu = true;
                MenuMode = MENU_INTRO;
                MenuCursor = 0;
                continue;
            }

            cheats_clearBuffer();

            For(A, 1, numPlayers)
            {
                if(Player[A].Mount == 0 || Player[A].Mount == 2)
                {
                    if(OwedMount[A] > 0)
                    {
                        Player[A].Mount = OwedMount[A];
                        if(OwedMountType[A] > 0)
                            Player[A].MountType = OwedMountType[A];
                        else
                            Player[A].MountType = 1;
                    }
                }

                OwedMount[A] = 0;
                OwedMountType[A] = 0;
            }

            if(!NoMap)
            {
                // Restore the previously preserved world map paths
                FileNameFull = FileNameFullWorld;
                FileName = FileNameWorld;
                FileNamePath = FileNamePathWorld;
                FileFormat = FileFormatWorld;

                // Recalculate the FullFileName
                FullFileName = FileNamePath + FileNameFull;
            }

            LoadCustomConfig();
            FindCustomPlayers();
            LoadCustomGFX();
            LoadCustomSound();
            SetupPlayers();
            FontManager::loadCustomFonts();

            if(!NoMap)
                FindWldStars();

            if((!StartLevel.empty() && NoMap) || !GoToLevel.empty() || !FileRecentSubHubLevel.empty())
            {
                if(NoMap)
                    SaveGame();

                Player[1].Vine = 0;
                Player[2].Vine = 0;

//                if(!GoToLevelNoGameThing)
//                    PlaySound(SFX_LevelSelect);
                SoundPause[SFX_Slide] = 2000;

                LevelSelect = false;

                if(XMessage::GetStatus() != XMessage::Status::replay)
                {
                    XRender::setTargetTexture();
                    XRender::clearBuffer();
                    XRender::repaint();
                }

                lunaReset();
                ResetSoundFX();
                ClearLevel();

                std::string levelPath;
                if(GoToLevel.empty())
                {
                    if(FileRecentSubHubLevel.empty())
                        levelPath = FileNamePathWorld + StartLevel;
                    else
                        levelPath = FileNamePathWorld + FileRecentSubHubLevel;
                }
                else
                {
                    levelPath = FileNamePathWorld + GoToLevel;
                    GoToLevel.clear();
                }

                levelPath = s_prepare_episode_path(levelPath);

                if(!OpenLevel(levelPath))
                {
                    ReportLoadFailure(levelPath);
                    ErrorQuit = true;
                }

                if(!GoToLevelNoGameThing)
                {
                    GameThing(1000 - (g_ShortDelay * 250), 3);
                    g_ShortDelay = false;
                }
                else if(XMessage::GetStatus() != XMessage::Status::replay)
                {
                    XRender::setTargetTexture();
                    XRender::clearBuffer();
                    XRender::repaint();
                }

                GoToLevelNoGameThing = false;
            }
            else
            {
                ResetSoundFX();
                setMusicStartDelay(); // Don't start music until all gfx will be loaded

                worldResetSection();

                if(curWorldMusic > 0)
                    StartMusic(curWorldMusic);

                resetFrameTimer();
                speedRun_resetCurrent();

                // On a world map, reset this into default state
                GoToLevelNoGameThing = false;

                // Clear the recent hub level when entering a world map
                FileRecentSubHubLevel.clear();

                // Update graphics before loop begin (to process inital lazy-unpacking of used sprites)
                UpdateGraphics2(true);
                resetFrameTimer();

                if(g_config.EnableInterLevelFade)
                    g_worldScreenFader.setupFader(4, 65, 0, ScreenFader::S_FADE);
                else
                    g_worldScreenFader.clearFader();

                // WorldLoop will automatically resume the music as needed
                // delayedMusicStart(); // Allow music being started
                worldResetSection();

                // 'level select loop
                runFrameLoop(nullptr, &WorldLoop,
                             []()->bool{return LevelSelect;},
                             nullptr,
                             []()->void{FreezeNPCs = false;});

                if(!GameIsActive)
                {
                    speedRun_saveStats();
                    return 0;// Break on quit
                }
            }
        }

        // MAIN GAME
        else
        {
            cheats_clearBuffer();
            EndLevel = false;

            Record::InitRecording(); // initializes level data recording

            for(int A = 1; A <= numPlayers; ++A)
            {
                if(Player[A].Mount == 2)
                    Player[A].Mount = 0; // take players off the clown car
            }

            setMusicStartDelay(); // Don't start music until all gfx will be loaded

            SetupPlayers(); // Setup Players for the level

            if(LevelRestartRequested && Checkpoint.empty())
                StartWarp = lastWarpEntered; // When restarting a level (after death), don't restore an entered warp on checkpoints

            if(IsHubLevel && StartWarp > 0) // Save the warp where player entered the hub
                ReturnWarpSaved = StartWarp;
            else if(IsHubLevel && ReturnWarp == 0)
                ReturnWarpSaved = 0;

            qScreen = false;
            qScreen_canonical = false;
            LevelRestartRequested = false;

            if(lastWarpEntered != StartWarp)
                lastWarpEntered = StartWarp; // Re-use it when player re-enters a level after death (when option is toggled on)

// for warp entrances
            if((ReturnWarp > 0 && (IsEpisodeIntro || IsHubLevel)/*FileName == StartLevel*/) || (StartWarp > 0))
            {
                for(int numPlayersMax = numPlayers, A = 1; A <= numPlayersMax; ++A)
                {
                    Player_t &p = Player[A];

                    if(StartWarp > 0)
                        p.Warp = StartWarp;
                    else
                        p.Warp = ReturnWarp;

                    if(p.Warp > maxWarps)
                        break;

                    p.WarpBackward = false;
                    auto &warp = Warp[p.Warp];

                    if(warp.Effect == 1)
                    {
                        if(warp.Direction2 == 1) // DOWN
                        {
//                                .Location.X = Warp(.Warp).Exit.X + Warp(.Warp).Exit.Width / 2 - .Location.Width / 2
                            p.Location.X = warp.Exit.X + (warp.Exit.Width - p.Location.Width) / 2;
//                                .Location.Y = Warp(.Warp).Exit.Y - .Location.Height - 8
                            p.Location.Y = warp.Exit.Y - p.Location.Height - 8;
                        }
//                            ElseIf Warp(.Warp).Direction2 = 3 Then
                        if(warp.Direction2 == 3) // UP
                        {
//                                .Location.X = Warp(.Warp).Exit.X + Warp(.Warp).Exit.Width / 2 - .Location.Width / 2
                            p.Location.X = warp.Exit.X + (warp.Exit.Width - p.Location.Width) / 2;
//                                .Location.Y = Warp(.Warp).Exit.Y + Warp(.Warp).Exit.Height + 8
                            p.Location.Y = warp.Exit.Y + warp.Exit.Height + 8;
                        }
//                            ElseIf Warp(.Warp).Direction2 = 2 Then
                        if(warp.Direction2 == 2) // RIGHT
                        {
//                                If .Mount = 3 Then .Duck = True
                            if(p.Mount == 3) p.Duck = true;
//                                .Location.X = Warp(.Warp).Exit.X - .Location.Width - 8
                            p.Location.X = warp.Exit.X - p.Location.Width - 8;
//                                .Location.Y = Warp(.Warp).Exit.Y + Warp(.Warp).Exit.Height - .Location.Height - 2
                            p.Location.Y = warp.Exit.Y + warp.Exit.Height - p.Location.Height - 2;
                        }
//                            ElseIf Warp(.Warp).Direction2 = 4 Then
                        if(warp.Direction2 == 4) // LEFT
                        {
//                                If .Mount = 3 Then .Duck = True
                            if(p.Mount == 3) p.Duck = true;
//                                .Location.X = Warp(.Warp).Exit.X + Warp(.Warp).Exit.Width + 8
                            p.Location.X = warp.Exit.X + warp.Exit.Width + 8;
//                                .Location.Y = Warp(.Warp).Exit.Y + Warp(.Warp).Exit.Height - .Location.Height - 2
                            p.Location.Y = warp.Exit.Y + warp.Exit.Height - p.Location.Height - 2;
//                            End If
                        }

                        PlayerFrame(p);
                        CheckSection_Init(A);
                        SoundPause[SFX_Warp] = 0;
                        p.Effect = PLREFF_WAITING;
                        p.Effect2 = 950;
                    }
                    else if(warp.Effect == 2)
                    {
//                            .Location.X = Warp(.Warp).Exit.X + Warp(.Warp).Exit.Width / 2 - .Location.Width / 2
                        p.Location.X = warp.Exit.X + (warp.Exit.Width - p.Location.Width) / 2;
//                            .Location.Y = Warp(.Warp).Exit.Y + Warp(.Warp).Exit.Height - .Location.Height
                        p.Location.Y = warp.Exit.Y + warp.Exit.Height - p.Location.Height;

                        CheckSection_Init(A);
                        p.Effect = PLREFF_WAITING;
                        p.Effect2 = 2000;
                    }
                    else if(warp.Effect == 3) // Portal warp
                    {
                        p.Location.X = warp.Exit.X + (warp.Exit.Width - p.Location.Width) / 2;
                        p.Location.Y = warp.Exit.Y + warp.Exit.Height - p.Location.Height;
                        CheckSection_Init(A);
                        p.WarpCD = 50;

                        if(warp.eventExit != EVENT_NONE)
                            TriggerEvent(warp.eventExit, A);
                    }
                }

                if(StartWarp > 0)
                {
                    StartWarp = 0;

                    // fix a bug where ReturnWarp (from different level) would be used at hub after death if StartWarp was set for hub
                    if(IsHubLevel && g_config.enable_last_warp_hub_resume)
                        ReturnWarp = 0;
                }
                else
                    ReturnWarp = 0;
            }

            // ---------------------------------------
            //    Verify if level can run or not
            // ---------------------------------------
            bool hasPlayerPoint = false;
            bool hasStartWarp = (Player[1].Warp > 0);
            bool hasCrashStartWarp = (Player[1].Warp > maxWarps);
            bool hasValidStartWarp = (Player[1].Warp > 0 && Player[1].Warp <= numWarps);
            bool startError = false;

            for(int i = 1; i <= numPlayers && i <= 2; ++i)
                hasPlayerPoint |= !PlayerStart[i].isNull();

            if(hasCrashStartWarp || (TestLevel && hasStartWarp && !hasValidStartWarp))
            {
                g_MessageType = MESSAGE_TYPE_SYS_ERROR;
                // this case would have crashed SMBX 1.3.
                MessageText = fmt::format_ne(g_gameStrings.errorInvalidEnterWarp,
                                             FullFileName,
                                             Player[1].Warp,
                                             numWarps);
                startError = true;
                Player[1].Warp = 0;
            }
            else if(!hasPlayerPoint && !hasValidStartWarp)
            {
                g_MessageType = MESSAGE_TYPE_SYS_ERROR;
                MessageText = fmt::format_ne(g_gameStrings.errorNoStartPoint, FullFileName);
                startError = true;
            }
            else if(hasStartWarp && !hasValidStartWarp)
            {
                pLogWarning("Level start: warp %d requested, but only %d warps present.", Player[1].Warp, numWarps);
            }

            if(startError) // Quit the level because of error
            {
                // Mark all players as dead
                for(int A = 1; A <= numPlayers; A++)
                    Player[A].Dead = true;

                PauseGame(PauseCode::Message);

                if(g_config.modern_lives_system)
                    ++g_100s;
                else
                    ++Lives;

                EveryonesDead();
                clearScreenFaders();

                if(BattleMode && !LevelEditor && !setup.testLevelMode)
                {
                    BattleMode = false;
                    GameMenu = true;
                    MenuMode = MENU_BATTLE_MODE;
                    MenuCursor = selWorld - 1;
                }
            }
            else // Run the level normally
            {
                speedRun_resetCurrent();
//'--------------------------------------------

                // Update graphics before loop begin (to process inital lazy-unpacking of used sprites)
                GraphicsLazyPreLoad();
                resetFrameTimer();

                speedRun_triggerEnter();

                clearScreenFaders(); // Reset all faders
                if(g_config.EnableInterLevelFade)
                    g_levelScreenFader.setupFader(2, 65, 0, ScreenFader::S_FADE);

                lunaLoad();

                delayedMusicStart(); // Allow music being started

                // intro events previously processed directly here
                g_gameLoopInterrupt.process_intro_events = true;

                // MAIN GAME LOOP
                runFrameLoop(nullptr, &GameLoop,
                []()->bool{return !LevelSelect && !GameMenu;},
                []()->bool
                {
                    if(!LivingPlayers())
                    {
                        EveryonesDead();
                        return true;
                    }
                    return false;
                });

                // Ensure everything is clear
                GraphicsClearScreen();
                XEvents::doEvents();
            }

            // store to level save info if level won
            if((LevelBeatCode > 0 && LevelBeatCode != BEATCODE_GAME_COMPLETE) || !GoToLevel.empty())
            {
                CommitBeatCode(LevelBeatCode);
                g_curLevelMedals.commit();
            }
            // otherwise, reset the medal count
            else if(LevelBeatCode != BEATCODE_GAME_COMPLETE)
                g_curLevelMedals.on_all_dead();

            Record::EndRecording();

            StopAllSounds();
            UnloadExtSounds();

            if(!GameIsActive)
            {
                speedRun_saveStats();
                return 0;// Break on quit
            }

            // TODO: Utilize this and any TestLevel/MagicHand related code to allow PGE Editor integration
            // (do any code without interaction of no more existnig Editor VB forms, keep IPS with PGE Editor instead)

//            If TestLevel = True Then
            if(TestLevel)
            {
                // provide option to restart (was previously restricted to fails and command-line runs)
                // if(LevelBeatCode == 0 || (setup.testLevelMode && LevelBeatCode >= 0))
                if(LevelBeatCode >= 0)
                {
                    LevelSelect = false;
                    LevelBeatCode = BEATCODE_RESTART; // checked in PauseScreen::Init()
                    PauseGame(PauseCode::PauseScreen);
                }

                // check that we are still restarting (it could have been canceled above)
                if(LevelBeatCode == BEATCODE_NONE || LevelBeatCode == BEATCODE_RESTART)
                {
                    GameThing();
                    zTestLevel(setup.testMagicHand || editorScreen.test_magic_hand, setup.interprocess); // Restart level
                }
                // from editor, return to editor
                else if(!Backup_FullFileName.empty())
                {
                    // printf("returning to editor...\n");

                    TestLevel = false;
                    LevelEditor = true;
                    GameMenu = false;
                    SetupPlayers();

                    // reopen the temporary level (FullFileName)
                    OpenLevel(FullFileName);

                    // reset FullFileName to point to the real level (Backup_FullFileName)
                    Files::deleteFile(FullFileName);
                    FullFileName = Backup_FullFileName;
                    // this is needed because the temporary levels are currently saved as ".lvl(x)tst"
                    if(FileNameFull.size() > 3 && FileNameFull.substr(FileNameFull.size() - 3) == "tst")
                        FileNameFull.resize(FileNameFull.size() - 3);

                    Backup_FullFileName = "";

                    Integrator::setEditorFile(FileName);

                    editorScreen.active = false;
                    MouseRelease = false;

                    if(g_config.EnableInterLevelFade)
                        g_levelScreenFader.setupFader(3, 65, 0, ScreenFader::S_FADE);
                }
                // from command line, close (if player has requested to stop testing)
                else if(setup.testLevelMode)
                {
                    GracefulQuit();
                    return 0;
                }

                LevelBeatCode = BEATCODE_NONE;

//                If nPlay.Online = False Then
//                    OpenLevel FullFileName
//                OpenLevel(FullFileName);
//                Else
//                    If nPlay.Mode = 1 Then
//                        Netplay.sendData "H0" & LB
//                        If Len(FullFileName) > 4 Then
//                            If LCase(Right(FullFileName, 4)) = ".lvl" Then
//                                OpenLevel FullFileName
//                            Else
//                                For A = 1 To 15
//                                    If nPlay.ClientCon(A) = True Then Netplay.InitSync A
//                                Next A
//                            End If
//                        Else
//                            For A = 1 To 15
//                                If nPlay.ClientCon(A) = True Then Netplay.InitSync A
//                            Next A
//                        End If
//                    End If
//                End If

//                LevelSelect = False
                LevelSelect = false;
            }
//            Else
            else if(!LevelRestartRequested)
            {
                lunaReset();
                ResetSoundFX();
                ClearLevel();
//            End If
            } // TestLevel
        }

        Archives::unmount_temp();
    }

    return 0;
}

// game_main_setupvars.cpp

// game_loop.cpp

// menu_loop.cpp

void EditorLoop()
{
    Controls::Update();
    Integrator::sync();
    UpdateEditor();
    UpdateBlocks();
    UpdateEffects();
    if(WorldEditor)
        UpdateGraphics2();
    else if(LevelEditor)
        UpdateGraphics();

    updateScreenFaders();

    // TODO: if there's a second screen, draw editor screen there too

    UpdateSound();
}

void KillIt()
{
#ifdef __WIIU__
    if(!GameIsActive)
        return; // Don't call this twice
#endif

    GameIsActive = false;
    Integrator::quitIntegrations();
#ifndef RENDER_FULLSCREEN_ALWAYS
    XWindow::hide();
    if(g_config.fullscreen)
        SetOrigRes();
#else
    XRender::clearBuffer();
    XRender::repaint();
#endif
    lunaReset();
    QuitMixerX();
    UnloadGFX();
    XWindow::showCursor(1);
}

void GracefulQuit(bool wait)
{
#ifdef __WIIU__
    if(!GameIsActive)
        return; // Don't call this twice
#endif

    StopMusic();

    if(wait)
    {
        const Uint64 waitDst = SDL_GetTicks64() + 500;

        do
        {
            XRender::setTargetTexture();
            XRender::clearBuffer();
            XRender::repaint();
            XEvents::doEvents();
            PGE_Delay(16);
        } while(SDL_GetTicks64() < waitDst);
    }

    StopAllSounds();

    XRender::setTargetTexture();
    XRender::clearBuffer();
    XRender::repaint();
    XEvents::doEvents();

#ifdef __WIIU__
    if(GameIsActive && !g_isHBLauncher)
    {
        SYSLaunchMenu(); // Trigger the SDL_QUIT and the leading quit into Wii U main menu

        while(GameIsActive) // Wait until quit event will happen
        {
            XEvents::doEvents();
            PGE_Delay(10);
        }

        PGE_Delay(100);
    }
#endif

    KillIt();
}

void NextLevel()
{
    int A = 0;

    for(A = 1; A <= numPlayers; A++)
        Player[A].HoldingNPC = 0;

    LevelMacro = LEVELMACRO_OFF;
    LevelMacroCounter = 0;
    LevelMacroWhich = 0;
    StopMusic();
    lunaReset();
    ResetSoundFX();
    ClearLevel();

    if(XMessage::GetStatus() != XMessage::Status::replay)
    {
        XRender::setTargetTexture();
        XRender::clearBuffer();
        XRender::repaint();
        XEvents::doEvents();
    }

    // do an inter-level delay here if there won't be a GameThing later
    if(!TestLevel && GoToLevel.empty() && !NoMap && FileRecentSubHubLevel.empty())
    {
        if(XMessage::GetStatus() != XMessage::Status::local)
        {
            for(int i = 0; i < ((g_ShortDelay) ? 16 : 32); i++)
                Controls::Update(false);
        }
        else if(!g_config.unlimited_framerate)
            PGE_Delay(500 - (g_ShortDelay * 250));

        g_ShortDelay = false;
    }

    if(BattleMode && !LevelEditor && !TestLevel)
    {
        g_ShortDelay = false;
        EndLevel = false;
        GameMenu = true;
        MenuMode = MENU_BATTLE_MODE;
        MenuCursor = selWorld - 1;
        // PlayerCharacter = Player[1].Character;
        // PlayerCharacter2 = Player[2].Character;
    }
    else
    {
        LevelSelect = true;
        EndLevel = false;
        if(TestLevel && BattleMode)
        {
            BattleIntro = 150;

            // if(!LevelEditor && Backup_FullFileName.empty())
            //     GameIsActive = false; // Quit game
        }
    }
}

// macros mainly used for end of level stuffs. takes over the players controls
void UpdateMacro()
{
    int A = 0;
    bool OnScreen = false;

#ifdef THEXTECH_INTERPROC_SUPPORTED
    if(LevelMacro != LEVELMACRO_OFF && LevelMacroCounter == 0 && IntProc::isEnabled())
    {
        for(int i = 0; i < numPlayers; ++i)
        {
            auto &p = Player[i + 1];
            IntProc::sendPlayerSettings(i, p.Character, p.State, p.Mount, p.MountType);
            IntProc::sendPlayerSettings2(i, p.Hearts, p.HeldBonus);
        }
    }
#endif

    if(LevelMacro == LEVELMACRO_CARD_ROULETTE_EXIT) // SMB3 Exit
    {
        for(A = 1; A <= numPlayers; A++)
        {
            auto &p = Player[A];
            auto &c = p.Controls;
            if(p.Location.X < level[p.Section].Width && !p.Dead)
            {
                OnScreen = true;
                c.Down = false;
                c.Drop = false;
                c.Jump = false;
                c.Left = false;
                c.Right = true;
                c.Run = false;
                c.Up = false;
                c.Start = false;
                c.AltJump = false;
                c.AltRun = false;

                if(p.State == PLR_STATE_AQUATIC && !p.Mount && !p.HoldingNPC)
                    c.Run = true;

                if(p.Wet > 0 && p.CanJump)
                {
                    if(p.Location.SpeedY > 1)
                        c.Jump = true;
                }
            }
            else
            {
                p.Location.SpeedY = -Physics.PlayerGravity;
                c.Down = false;
                c.Drop = false;
                c.Jump = false;
                c.Left = false;
                c.Right = true;
                c.Run = false;
                c.Up = false;
                c.Start = false;
                c.AltJump = false;
                c.AltRun = false;
            }
        }

        // !OnScreen requires Player to leave Screen during normal play.
        // is_cheat ensures the ItsVegas Cheat doesn't Softlock the game.
        bool is_cheat = (LevelMacroWhich == -1);

        if(!OnScreen || is_cheat)
        {
            LevelMacroCounter++;

            if(g_config.EnableInterLevelFade &&
                ((LevelMacroCounter == 34 && !is_cheat)
                || (LevelMacroCounter == 250 && is_cheat)))
            {
                g_levelScreenFader.setupFader(1, 0, 65, ScreenFader::S_FADE);
            }

            if((!is_cheat && LevelMacroCounter >= 100) || (is_cheat && LevelMacroCounter >= 316))
            {
                LevelBeatCode = BEATCODE_CARD_ROULETTE;
                LevelMacro = LEVELMACRO_OFF;
                LevelMacroCounter = 0;
                EndLevel = true;
            }
        }
    }
    else if(LevelMacro == LEVELMACRO_QUESTION_SPHERE_EXIT)
    {
        for(A = 1; A <= numPlayers; A++)
        {
            auto &c = Player[A].Controls;
            c.Down = false;
            c.Drop = false;
            c.Jump = false;
            c.Left = false;
            c.Right = false;
            c.Run = false;
            c.Up = false;
            c.Start = false;
            c.AltJump = false;
            c.AltRun = false;
        }

        LevelMacroCounter++;

        if(g_config.EnableInterLevelFade && LevelMacroCounter == 395)
            g_levelScreenFader.setupFader(1, 0, 65, ScreenFader::S_FADE);

        if(LevelMacroCounter >= 460)
        {
            LevelBeatCode = BEATCODE_QUESTION_SPHERE;
            EndLevel = true;
            LevelMacro = LEVELMACRO_OFF;
            LevelMacroCounter = 0;

            if(XMessage::GetStatus() != XMessage::Status::replay)
                XRender::clearBuffer();
        }
    }
    else if(LevelMacro == LEVELMACRO_KEYHOLE_EXIT)
    {
        const int keyholeMax = 192; // Was 300

        // this was previously its own frameloop.
        // items done earlier in the frameloop have been commented out.

        speedRun_tick();
        // Controls::Update(false);
        UpdateGraphics();
        UpdateSound();
        BlockFrames();

        // XEvents::doEvents();
        // computeFrameTime2();

        updateScreenFaders();

        LevelMacroCounter++;

        if(g_config.EnableInterLevelFade && LevelMacroCounter == (keyholeMax - 65))
            g_levelScreenFader.setupFader(1, 0, 65, ScreenFader::S_FADE);

        if(LevelMacroCounter >= keyholeMax) /*300*/
        {
            LevelBeatCode = BEATCODE_KEYHOLE;
            EndLevel = true;
            LevelMacro = LEVELMACRO_OFF;
            LevelMacroWhich = 0;
            LevelMacroCounter = 0;

            if(XMessage::GetStatus() != XMessage::Status::replay)
                XRender::clearBuffer();
        }
    }
    else if(LevelMacro == LEVELMACRO_CRYSTAL_BALL_EXIT)
    {
        for(A = 1; A <= numPlayers; A++)
        {
            auto &c = Player[A].Controls;
            c.Down = false;
            c.Drop = false;
            c.Jump = false;
            c.Left = false;
            c.Right = false;
            c.Run = false;
            c.Up = false;
            c.Start = false;
            c.AltJump = false;
            c.AltRun = false;
        }

        LevelMacroCounter++;

        if(g_config.EnableInterLevelFade && LevelMacroCounter == 235)
            g_levelScreenFader.setupFader(1, 0, 65, ScreenFader::S_FADE);

        if(LevelMacroCounter >= 300)
        {
            LevelBeatCode = BEATCODE_CRYSTAL_BALL;
            EndLevel = true;
            LevelMacro = LEVELMACRO_OFF;
            LevelMacroCounter = 0;

            if(XMessage::GetStatus() != XMessage::Status::replay)
                XRender::clearBuffer();
        }
    }
    else if(LevelMacro == LEVELMACRO_GAME_COMPLETE_EXIT)
    {
        // numNPCs = 0
        for(A = 1; A <= numPlayers; A++)
        {
            auto &c = Player[A].Controls;
            c.Down = false;
            c.Drop = false;
            c.Jump = false;
            c.Left = false;
            c.Right = false;
            c.Run = false;
            c.Up = false;
            c.Start = false;
            c.AltJump = false;
            c.AltRun = false;
        }

        LevelMacroCounter++;

        if(LevelMacroCounter == 250)
            PlaySound(SFX_GameBeat);

        if(g_config.EnableInterLevelFade && LevelMacroCounter == 735)
            g_levelScreenFader.setupFader(1, 0, 65, ScreenFader::S_FADE);

        if(LevelMacroCounter >= 800)
        {
            EndLevel = true;
            LevelMacro = LEVELMACRO_OFF;
            LevelMacroCounter = 0;
            if(!TestLevel)
            {
                BeatTheGame = true;
                // new level beat code 15: beat the game (exclusive to new level save info -- does not open any exits)
                CommitBeatCode(BEATCODE_GAME_COMPLETE);
                g_curLevelMedals.commit();
                SaveGame();
                GameOutro = true;
                MenuMode = MENU_INTRO;
                MenuCursor = 0;
            }

            if(XMessage::GetStatus() != XMessage::Status::replay)
                XRender::clearBuffer();
        }
    }
    else if(LevelMacro == LEVELMACRO_STAR_EXIT) // Star Exit
    {
        for(A = 1; A <= numPlayers; A++)
        {
            auto &c = Player[A].Controls;
            c.Down = false;
            c.Drop = false;
            c.Jump = false;
            c.Left = false;
            c.Right = false;
            c.Run = false;
            c.Up = false;
            c.Start = false;
            c.AltJump = false;
            c.AltRun = false;
        }

        LevelMacroCounter++;

        if(g_config.EnableInterLevelFade && LevelMacroCounter == 235)
            g_levelScreenFader.setupFader(1, 0, 65, ScreenFader::S_FADE);

        if(LevelMacroCounter >= 300)
        {
            LevelBeatCode = BEATCODE_STAR;
            LevelMacro = LEVELMACRO_OFF;
            LevelMacroCounter = 0;
            EndLevel = true;
        }
    }
    else if(LevelMacro == LEVELMACRO_GOAL_TAPE_EXIT || LevelMacro == LEVELMACRO_FLAG_EXIT) // SMW Exit
    {
        for(A = 1; A <= numPlayers; A++)
        {
            auto &p = Player[A];
            auto &c = p.Controls;

            if(p.Location.X < level[p.Section].Width && !p.Dead)
            {
                c.Down = false;
                c.Drop = false;
                c.Jump = false;
                c.Left = false;
                c.Right = true;
                c.Run = false;
                c.Up = (LevelMacro == LEVELMACRO_FLAG_EXIT);
                c.Start = false;
                c.AltJump = false;
                c.AltRun = false;

                if(p.State == PLR_STATE_AQUATIC && !p.Mount && !p.HoldingNPC)
                    c.Run = true;
            }
            else
            {
                p.Location.SpeedY = -Physics.PlayerGravity;
                c.Down = false;
                c.Drop = false;
                c.Jump = false;
                c.Left = false;
                c.Right = true;
                c.Run = false;
                c.Up = false;
                c.Start = false;
                c.AltJump = false;
                c.AltRun = false;
            }
        }

        LevelMacroCounter++;

        if(g_config.EnableInterLevelFade && LevelMacroCounter == 598)
        {
            bool canTrack = (Player[1].Location.X < level[Player[1].Section].Width);
            num_t focusX = (canTrack) ?
                            Player[1].Location.X + Player[1].Location.Width / 2 :
                            level[Player[1].Section].Width;
            num_t focusY = Player[1].Location.Y + Player[1].Location.Height / 2;

            g_levelScreenFader.setupFader(2, 0, 65, ScreenFader::S_CIRCLE, true, (int)focusX, (int)focusY, 1);

            if(canTrack)
                g_levelScreenFader.setTrackedFocus(&Player[1].Location.X,
                                                   &Player[1].Location.Y,
                                                   Player[1].Location.Width / 2,
                                                   Player[1].Location.Height / 2);
        }

        if(LevelMacroCounter >= 630)
        {
            // LEVELMACRO_GOAL_TAPE_EXIT = 7 -> 8
            // LEVELMACRO_FLAG_EXIT = 8 -> 9
            // LEVELMACRO_ALT_FLAG_EXIT = 9 -> 10 (reserved)
            LevelBeatCode = (LevelBeatCode_t)(LevelMacro + 1);
            LevelMacro = LEVELMACRO_OFF;
            LevelMacroCounter = 0;
            EndLevel = true;
        }
    }
}

// main_config.cpp


void CheckActive()
{
    // It's useless on Emscripten as no way to check activity (or just differently)
    // and on Android as it has built-in application pauser
#if !defined(NO_WINDOW_FOCUS_TRACKING)
//    bool MusicPaused = false;
    bool focusLost = false;

    if(g_config.background_work)
        return;

    if(!GameIsActive)
        return;

//    If nPlay.Online = True Then Exit Sub
    // If LevelEditor = False And TestLevel = False Then Exit Sub
    // If LevelEditor = False Then Exit Sub
    while(!XWindow::hasWindowInputFocus())
    {
        if(!focusLost)
        {
            XRender::setTargetTexture();
            XRender::renderRect(0, 0, XRender::TargetW, XRender::TargetH, {0, 0, 0, 127}, true);
            SuperPrintScreenCenter(g_gameStrings.screenPaused.empty() ? "Paused" : g_gameStrings.screenPaused, 3, XRender::TargetH / 2);
            pLogDebug("Window Focus lost");
            focusLost = true;
        }

        XRender::repaint();

        XEvents::waitEvents();
//        If LevelEditor = True Or MagicHand = True Then frmLevelWindow.vScreen(1).MousePointer = 0
        SyncSysCursorDisplay();

        resetFrameTimer();

        resetTimeBuffer();
        //keyDownEnter = false;
        //keyDownAlt = false;

//        if(musicPlaying && !MusicPaused)
//        {
//            MusicPaused = true;
//            SoundPauseEngine(1);
//        }

        if(!GameIsActive)
        {
            speedRun_saveStats();
            break;
        }
    }

    if(focusLost)
        pLogDebug("Window Focus got back");

//    if(MusicPaused)
//        SoundPauseEngine(0);

/* // Useless condition
    if(MusicPaused)
    {
        if(MusicPaused)
        {
            SoundResumeAll();
            if(GameOutro == true)
                SoundResumeAll();
            else if(LevelSelect == true && GameMenu == false && LevelEditor == false)
                SoundResumeAll();
            else if(curMusic > 0)
                SoundResumeAll();
            else if(curMusic < 0)
            {
                SoundResumeAll();
                if(PSwitchStop > 0)
                {
                    // mciSendString "resume stmusic", 0, 0, 0
                    SoundResumeAll();
                }
                else
                {
                    // mciSendString "resume smusic", 0, 0, 0
                    SoundResumeAll();
                }
            }
        }
    }
    */
//    If LevelEditor = True Or MagicHand = True Then frmLevelWindow.vScreen(1).MousePointer = 99
#endif // not def __EMSCRIPTEN__
}


Location_t newLoc(num_t X, num_t Y, num_t Width, num_t Height)
{
    Location_t ret;
    ret.X = X;
    ret.Y = Y;
    ret.Width = Width;
    ret.Height = Height;
    return ret;
}

// Location_t roundLoc(const Location_t &inLoc, double grid)
// {
//     Location_t ret = inLoc;
//     ret.X = Maths::roundTo(ret.X, grid);
//     ret.Y = Maths::roundTo(ret.Y, grid);
//     return ret;
// }

void MoreScore(int addScore, const Location_t &Loc)
{
    uint8_t mult = 0; // dummy
    MoreScore(addScore, Loc, mult);
}

void MoreScore(int addScore, const Location_t &Loc, uint8_t &Multiplier)
{
    //int oldM = 0;
    int A = 0;

    if(GameMenu || GameOutro || BattleMode)
        return;

    A = addScore + Multiplier;

    if(A == 0)
        return;

    Multiplier++;

    if(Multiplier > 9)
        Multiplier = 8;

    if(A < addScore)
        A = addScore;

    if(A > 13)
        A = 13;

    if(Points[A] <= 5)
    {
        if(g_config.modern_lives_system)
            g_100s += Points[A];
        else
            Lives += Points[A];

        PlaySound(SFX_1up, Points[A] - 1);
    }
    else
        Score += Points[A];

    NewEffect(EFFID_SCORE, Loc);
    Effect[numEffects].Frame = A - 1;
}

void Got100Coins()
{
    if(g_config.modern_lives_system)
    {
        if(g_100s < 9999)
        {
            g_100s++;
            PlaySound(SFX_1up);
            Coins -= 100;
        }
        else
            Coins = 99;
    }
    else
    {
        if(Lives < 99)
        {
            Lives += 1;
            PlaySound(SFX_1up);
            Coins -= 100;
        }
        else
            Coins = 99;
    }
}

void SizableBlocks()
{
    BlockIsSizable[568] = true;
    BlockIsSizable[579] = true;
    BlockIsSizable[575] = true;
    BlockIsSizable[25] = true;
    BlockIsSizable[26] = true;
    BlockIsSizable[27] = true;
    BlockIsSizable[28] = true;
    BlockIsSizable[38] = true;
    BlockIsSizable[79] = true;
    BlockIsSizable[108] = true;
    BlockIsSizable[130] = true;
    BlockIsSizable[161] = true;
    BlockIsSizable[240] = true;
    BlockIsSizable[241] = true;
    BlockIsSizable[242] = true;
    BlockIsSizable[243] = true;
    BlockIsSizable[244] = true;
    BlockIsSizable[245] = true;
    BlockIsSizable[259] = true;
    BlockIsSizable[260] = true;
    BlockIsSizable[261] = true;
    BlockIsSizable[287] = true;
    BlockIsSizable[288] = true;
    BlockIsSizable[437] = true;
    BlockIsSizable[441] = true;
    BlockIsSizable[442] = true;
    BlockIsSizable[443] = true;
    BlockIsSizable[444] = true;
    BlockIsSizable[438] = true;
    BlockIsSizable[439] = true;
    BlockIsSizable[440] = true;
    BlockIsSizable[445] = true;
}

static void s_InitPlayersFromCharSelect()
{
    for(int A = 0; A <= maxPlayers; A++)
        Player[A] = Player_t();

    // load players from the screens
    numPlayers = 0;
    InitScreens();

    for(int s = 0; s < maxNetplayClients; s++)
    {
        Screen_t& screen = Screens[s];

        for(int i = 0; i < maxLocalPlayers; i++)
        {
            if(screen.charSelect[i] != 0)
            {
                numPlayers++;
                Screens_AssignPlayer(numPlayers, screen);

                Player_t& p = Player[numPlayers];
                p.State = 1;
                p.Mount = 0;
                p.Character = screen.charSelect[i];
                p.HeldBonus = NPCID(0);
                p.CanFly = false;
                p.CanFly2 = false;
                p.TailCount = 0;
                p.YoshiBlue = false;
                p.YoshiRed = false;
                p.YoshiYellow = false;
                p.Hearts = 0;
            }
        }
    }

    for(int i = (int)Controls::g_InputMethods.size() - 1; i >= l_screen->player_count; i--)
        Controls::DeleteInputMethodSlot(i);
}

void StartEpisode()
{
    XMessage::InitSession();

    For(A, 1, numCharacters)
    {
        SavedChar[A] = Player_t();
        SavedChar[A].Character = A;
        SavedChar[A].State = 1;
    }

    // load players from the screens
    s_InitPlayersFromCharSelect();

    ConnectScreen::SaveChars();

    numStars = 0;
    Coins = 0;
    Score = 0;
    g_100s = 3;
    Lives = 3;
    LevelSelect = true;
    GameMenu = false;
    g_ShortDelay = false;

    // Update local screen size and multiplayer prefs
    UpdateInternalRes();
    XMessage::PushMessage({XMessage::Type::multiplayer_prefs, (uint8_t)g_config.two_screen_mode.m_value, (uint8_t)g_config.four_screen_mode.m_value});

    XRender::setTargetTexture();
    XRender::clearBuffer();
    XRender::repaint();
    StopMusic();
    XEvents::doEvents();

    // Note: this causes the rendered touchscreen controller to freeze with button pressed.
    if(!g_config.unlimited_framerate)
        PGE_Delay(500);

    ClearGame();
    FontManager::clearAllCustomFonts();
    UnloadCustomSound();
    Archives::unmount_episode();

    // New: prevents any buggy processing of leftover effects during a pause on the world map
    ClearLevel();

    std::string wPath = SelectWorld[selWorld].WorldFilePath;
    std::string recentWorldIntroPrev = g_recentWorldIntro;
    bool doSaveConfig = false;

    if((numPlayers == 1 || g_config.compatibility_mode != Config_t::COMPAT_SMBX13) && g_recentWorld1p != wPath)
    {
        g_recentWorld1p = wPath;
        doSaveConfig = true;
    }
    else if((numPlayers >= 2 && g_config.compatibility_mode == Config_t::COMPAT_SMBX13) && g_recentWorld2p != wPath)
    {
        g_recentWorld2p = wPath;
        doSaveConfig = true;
    }

    wPath = s_prepare_episode_path(wPath);

    if(!OpenWorld(wPath))
    {
        if(doSaveConfig)
            SaveConfig();
        ClearLevel();
        LevelSelect = false;
        ReportLoadFailure(wPath);
        LevelSelect = true;
        ErrorQuit = true;
        return;
    }

    if(recentWorldIntroPrev != g_recentWorldIntro)
        doSaveConfig = true;

    if(doSaveConfig)
        SaveConfig();

    if(selSave && SaveSlotInfo[selSave].Progress >= 0)
    {
        if(!NoMap)
            StartLevel.clear();
        LoadGame();
        speedRun_loadStats();
    }

    Integrator::setEpisodeName(WorldName);

#if 0 // unused cheat code from SMBX64
    if(WorldUnlock)
    {
        For(A, 1, numWorldPaths)
        {
            TinyLocation_t tempLocation = WorldPath[A].Location;
            {
                TinyLocation_t &l = tempLocation;
                l.X += 4;
                l.Y += 4;
                l.Width -= 8;
                l.Height -= 8;
            }

            WorldPath[A].Active = true;

            For(B, 1, numScenes)
            {
                if(CheckCollision(tempLocation, Scene[B].Location))
                    Scene[B].Active = false;
            }
        }

        For(A, 1, numWorldLevels)
            WorldLevel[A].Active = true;
    }
#endif

    SetupPlayers();

    if(!StartLevel.empty() || !FileRecentSubHubLevel.empty())
    {
        // TODO: why did Wohlstand disable this?
        PlaySoundMenu(SFX_LevelSelect);
        SoundPause[SFX_Slide] = 200;
        LevelSelect = false;

        ResetSoundFX();
        // todo: update this!
        ClearLevel();

        std::string levelName = (FileRecentSubHubLevel.empty() ? StartLevel : FileRecentSubHubLevel);
        std::string levelPath = FileNamePathWorld + levelName;

        levelPath = s_prepare_episode_path(levelPath);

        if(!OpenLevel(levelPath))
        {
            ReportLoadFailure(levelName);
            LevelSelect = true;

            // return to menu if the hub of a hub world is broken
            if(NoMap)
                ErrorQuit = true;
        }
        else
            GameThing(1000, 3);
    }
}

void StartBattleMode()
{
    XMessage::InitSession();

    int A = 0;
    Player_t blankPlayer;

    for(A = 1; A <= numCharacters; A++)
    {
        SavedChar[A] = blankPlayer;
        SavedChar[A].Character = A;
        SavedChar[A].State = 1;
    }

    s_InitPlayersFromCharSelect();

    for(int i = 1; i <= numPlayers; i++)
    {
        Player[i].State = 2;
        Player[i].Hearts = 2;
    }

    numStars = 0;
    Coins = 0;
    Score = 0;
    g_100s = 0;
    Lives = 99;
    for(int i = 1; i <= numPlayers; i++)
        BattleLives[i] = 3;
    LevelSelect = false;
    GameMenu = false;
    BattleMode = true;
    XRender::setTargetTexture();
    XRender::clearBuffer();
    XRender::repaint();
    StopMusic();
    XEvents::doEvents();

    if(!g_config.unlimited_framerate)
        PGE_Delay(500);

    lunaReset();
    ResetSoundFX();
    ClearLevel();

    if(NumSelectBattle <= 1)
    {
        g_MessageType = MESSAGE_TYPE_SYS_WARNING;
        MessageText = g_mainMenu.errorBattleNoLevels;
        PauseGame(PauseCode::Message);
        ErrorQuit = true;
    }
    else
    {
        if(selWorld == 1)
            selWorld = (iRand(NumSelectBattle - 1)) + 2;
    }

    const std::string& levelPath = SelectBattle[selWorld].WorldFilePath;
    if(!OpenLevel(levelPath))
    {
        ReportLoadFailure(levelPath);
        ErrorQuit = true;
    }
    SetupPlayers();

    BattleIntro = 150;
    BattleWinner = 0;
    BattleOutro = 0;
}


================================================
FILE: src/game_main.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef MAIN_H
#define MAIN_H

#include "globals.h"
#include "cmd_line_setup.h"

enum class PauseCode
{
    None,
    PauseScreen,
    Message,
    DropAdd,
    TextEntry,
    Prompt,
    Options,
};

//Public GamePaused As Boolean 'true if the game is paused
extern PauseCode GamePaused;

void SetupPhysics();

void initAll();

//! Report the failure to load a level, pausing the game with a message box
void ReportLoadFailure(const std::string& filename, bool isIPC = false);

//! NEW: (re)load all file-based assets from the current asset pack directory
void MainLoadAll();

int GameMain(const CmdLineSetup_t &setup);
//! Set up object sizes and frame offsets for blocks/npcs/effects
void SetupVars();
//! The loop for the game
void GameLoop();
//! The loop for the menu
void MenuLoop();
//! The loop for the level editor [DUMMY]
void EditorLoop();
//! Cleans up the buffer before ending the program
void KillIt();
void GracefulQuit(bool wait = false);

// OpenLevel() and ClearLevel() moved into main/level_file.h

void NextLevel();
//! macros mainly used for end of level stuffs. takes over the players controls
void UpdateMacro();

// OpenWorld, FindWldStars, and ClearWorld moved into main/world_file.h

//! Loop for world select
void WorldLoop();

void LevelPath(const WorldLevel_t &Lvl, int Direction, bool Skp = false);

void PlayerPath(WorldPlayer_t &p);

void PathPath(WorldPath_t &Pth, bool Skp = false);

void PathWait();

void FindWorlds();

void LoadSingleWorld(const std::string wPath);

void FindLevels();

void FindSaves();

extern std::string makeGameSavePath(std::string episode, std::string saveFile);

void SaveGame();

void LoadGame();
//! Removes gamesave file and restores initial state of all level objects
void ClearGame(bool punnish = false);
void DeleteSave(int world, int save);
void CopySave(int world, int src, int dst);

void PauseInit(PauseCode code, int plr = 0, void (*callback)() = nullptr);
void PauseLoop();
void PauseGame(PauseCode code, int plr = 0);

// reload recent episodes from config (used when asset pack changes)
void ConfigReloadRecentEpisodes();

void OpenConfig();

void SaveConfig();

// dead since 1.3
// void NPCyFix();

// void CheatCode(char NewKey);// Moved into "main/cheat_code.h"

//! credit loop
void OutroLoop();

void SetupCredits();

// FindStars() moved into main/level_file.h

// for settings up the game's credits
void AddCredit(const std::string& newCredit);
// calcualtes scores based on the multiplyer and how much the NPC is worth
void MoreScore(int addScore, const Location_t &Loc);
void MoreScore(int addScore, const Location_t &Loc, uint8_t &Multiplier);

// NEW: convenience hook for when a player has collected 100 coins
void Got100Coins();

// sets up player frame offsets so they are displayed correctly on the screen
void SetupPlayerFrames();

void StartEpisode();
void StartBattleMode();

// std::string FixComma(std::string newStr); // USELESS

#endif // MAIN_H


================================================
FILE: src/gfx.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_assert.h"

#include "globals.h"
#include "gfx.h"
#include "core/msgbox.h"
#include "core/render.h"
#include "graphics/gfx_frame.h"

#include <IniProcessor/ini_processing.h>
#include <Utils/files_ini.h>
#include <DirManager/dirman.h>
#include <fmt_format_ne.h>
#include <Logger/logger.h>

#if defined(__3DS__) || defined(__SWITCH__) || defined(__WII__) || defined(__WIIU__)
#   include <Utils/files.h>
#   if defined(__SWITCH__)
#       define UI_PLATFORM_EXT "-switch"
#   elif defined(__3DS__)
#       define UI_PLATFORM_EXT "-3ds"
#   elif defined(__WII__)
#       define UI_PLATFORM_EXT "-wii"
#   elif defined(__WIIU__)
#       define UI_PLATFORM_EXT "-wiiu"
#   endif
#endif

#ifdef X_IMG_EXT
#   define  UI_IMG_EXT X_IMG_EXT
#else
#   define  UI_IMG_EXT ".png"
#endif

GFX_t GFX;


void GFX_t::loadImage(StdPicture &img, const std::string &fileName)
{
    std::string path_ext = fileName + UI_IMG_EXT;

    if(!m_uiPathTr.empty() && Files::fileExists(m_uiPathTr + path_ext))
        path_ext = m_uiPathTr + path_ext; // Load localized variant
    else
        path_ext = m_uiPath + path_ext; // Load original

    pLogDebug("Loading texture %s...", path_ext.c_str());
    XRender::LoadPicture(img, path_ext);

#if defined(X_IMG_EXT) && !defined(X_NO_PNG_GIF)
    if(!img.inited)
    {
        path_ext = fileName + ".png";
        if(!m_uiPathTr.empty() && Files::fileExists(m_uiPathTr + path_ext))
            path_ext = m_uiPathTr + path_ext; // Load localized variant
        else
            path_ext = m_uiPath + path_ext; // Load original

        pLogDebug("Could not load, trying %s...", path_ext.c_str());
        XRender::LoadPicture(img, path_ext);
    }
#endif

    if(!img.inited)
    {
        pLogWarning("Failed to load texture: %s...", path_ext.c_str());
        m_loadErrors++;
    }

    m_loadedImages.push_back(&img);
}

void GFX_t::loadBorder(FrameBorder& border, const std::string& fileName)
{
    std::string path_dst;

    if(!m_uiPathTr.empty() && Files::fileExists(m_uiPathTr + fileName + ".ini"))
        path_dst = m_uiPathTr + fileName; // Load localized variant
    else
        path_dst = m_uiPath + fileName; // Load original

    loadImage(border.tex, fileName);

    if(!border.tex.inited)
        return;

    IniProcessing ini = Files::load_ini(path_dst + ".ini");
    loadFrameInfo(ini, border);

    // warn if invalid
    const FrameBorderInfo& i = border;
    if(i.le + i.li + i.ri + i.re > border.tex.w)
        pLogWarning("Invalid border: total internal/external width is %d but [%s] is only %dpx wide.", i.le + i.li + i.ri + i.re, path_dst.c_str(), border.tex.w);
    if(i.te + i.ti + i.bi + i.be > border.tex.h)
        pLogWarning("Invalid border: total internal/external height is %d but [%s] is only %dpx tall.", i.te + i.ti + i.bi + i.be, path_dst.c_str(), border.tex.h);
}

GFX_t::GFX_t() noexcept
{}

bool GFX_t::load()
{
    m_uiPath = AppPath + "graphics/ui/";
    m_uiPathTr.clear();

    if(!CurrentLanguage.empty())
    {
        std::string langDir = CurrentLanguage + "-" + CurrentLangDialect;
        if(!CurrentLangDialect.empty() && DirMan::exists(m_uiPath + "i18n/" + langDir))
            m_uiPathTr = m_uiPath + "i18n/" + langDir + "/";
        else if(DirMan::exists(m_uiPath + "i18n/" + CurrentLanguage))
            m_uiPathTr = m_uiPath + "i18n/" + CurrentLanguage + "/";
    }

    loadImage(BMVs, "BMVs");
    loadImage(BMWin, "BMWin");
    For(i, 1, 3)
        loadImage(Boot[i], fmt::sprintf_ne("Boot%d", i));

    For(i, 1, 5)
        loadImage(CharacterName[i], fmt::sprintf_ne("CharacterName%d", i));

    loadImage(Chat, "Chat");

    For(i, 0, 2)
        loadImage(Container[i], fmt::sprintf_ne("Container%d", i));

    For(i, 1, 3)
        loadImage(ECursor[i], fmt::sprintf_ne("ECursor%d", i));

    For(i, 0, 9)
        loadImage(Font1[i], fmt::sprintf_ne("Font1_%d", i));

    For(i, 1, 3)
        loadImage(Font2[i], fmt::sprintf_ne("Font2_%d", i));

    loadImage(Font2S, "Font2S");

    For(i, 1, 2)
        loadImage(Heart[i], fmt::sprintf_ne("Heart%d", i));

    For(i, 0, 8)
        loadImage(Interface[i], fmt::sprintf_ne("Interface%d", i));

    loadImage(LoadCoin, "LoadCoin");
    loadImage(Loader, "Loader");

    For(i, 0, 3)
        loadImage(MCursor[i], fmt::sprintf_ne("MCursor%d", i));

    For(i, 1, 4)
    {
        if(i == 4 && (XRender::TargetW < 800 || XRender::TargetH < 480))
        {
            const char *n = "MenuGFX4-320p";
#   ifdef X_IMG_EXT
            if(Files::fileExists(m_uiPath + n + UI_IMG_EXT) || Files::fileExists(m_uiPath + n + ".png"))
#   else
            if(Files::fileExists(m_uiPath + n + UI_IMG_EXT))
#   endif
            {
                loadImage(MenuGFX[i], n);
                continue;
            }
        }

#if defined(UI_PLATFORM_EXT)
        auto n = fmt::format_ne("MenuGFX{0}" UI_PLATFORM_EXT, i);
#   ifdef X_IMG_EXT
        if(Files::fileExists(m_uiPath + n + UI_IMG_EXT) || Files::fileExists(m_uiPath + n + ".png"))
#   else
        if(Files::fileExists(m_uiPath + n + UI_IMG_EXT))
#   endif
        {
            loadImage(MenuGFX[i], n);
            continue;
        }

        pLogWarning("File %s%s doesn't exist, trying to load generic one...", n.c_str(), UI_IMG_EXT);
#endif
        loadImage(MenuGFX[i], fmt::sprintf_ne("MenuGFX%d", i));
    }

    loadImage(Mount[2], "Mount");

    For(i, 0, 7)
        loadImage(nCursor[i], fmt::sprintf_ne("nCursor%d", i));

    loadImage(TextBox, "TextBox");

    For(i, 1, 2)
        loadImage(Tongue[i], fmt::sprintf_ne("Tongue%d", i));

    // loadImage(Warp, uiPath + "Warp");

    loadImage(YoshiWings, "YoshiWings");

    // Add new required assets here. Also update load_gfx.cpp:loadCustomUIAssets()

    if(m_loadErrors > 0)
    {
        // std::string msg = fmt::format_ne("Failed to load UI image assets from {0}. Look a log file to get more details:\n{1}"
        //                                  "\n\n"
        //                                  "It's possible that you didn't install the game assets package, or you had installed it at the incorrect directory.",
        //                                  AppPath, getLogFilePath());
        // XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR, "UI image assets loading error", msg);
        m_loadErrors = 0;
        return false;
    }

    loadImage(CycloneAcc, "CycloneAcc");

    loadImage(EIcons, "EditorIcons");

    if(m_loadErrors > 0)
        m_loadErrors = 0;

    loadImage(PCursor, "PCursor");

    if(m_loadErrors > 0)
        m_loadErrors = 0;

    loadImage(Medals, "Medals");

    if(m_loadErrors > 0)
        m_loadErrors = 0;

    loadImage(CharSelIcons, "CharSelIcons");

    loadBorder(CharSelFrame, "CharSelFrame");

    if(m_loadErrors > 0)
        m_loadErrors = 0;

    loadImage(Backdrop, "Backdrop");
    loadBorder(Backdrop_Border, "Backdrop_Border");

    if(m_loadErrors > 0)
    {
        pLogDebug("Missing new backdrop textures.");
        m_loadErrors = 0;
    }

    loadImage(WorldMapFrame_Tile, "WorldMapFrame_Tile");
    loadBorder(WorldMapFrame_Border, "WorldMapFrame_Border");

    if(m_loadErrors > 0)
    {
        pLogDebug("Missing new world map frame tile/border textures.");
        m_loadErrors = 0;
    }

    loadImage(Camera, "Camera");

    if(m_loadErrors > 0)
        m_loadErrors = 0;

    loadImage(Balance, "Balance");

    loadImage(Placeholder, "Placeholder");

    loadImage(SaveIcons, "SaveIcons");

    if(m_loadErrors > 0)
        m_loadErrors = 0;

    // Add new optional assets above this line. Also update load_gfx.cpp: loadCustomUIAssets(), and gfx.h: GFX_t::m_isCustomVolume.

    SDL_assert_release(m_loadedImages.size() <= m_isCustomVolume);
    SDL_memset(m_isCustom, 0, sizeof(m_loadedImages.size() * sizeof(bool)));

    return true;
}

void GFX_t::unLoad()
{
    for(StdPicture *p : m_loadedImages)
        p->reset();

    m_loadedImages.clear();
    SDL_memset(m_isCustom, 0, sizeof(m_loadedImages.size() * sizeof(bool)));
}

bool& GFX_t::isCustom(size_t i)
{
    SDL_assert_release(i < m_isCustomVolume);
    return m_isCustom[i];
}


================================================
FILE: src/gfx.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_H
#define GFX_H

#include <vector>
#include <string>

#include "range_arr.hpp"
#include "std_picture.h"
#include "graphics/gfx_frame.h"

/*!
 * \brief Holder of commonly-used textures such as interface, font, etc.
 */
class GFX_t
{
    //! Holder of loaded textures for easier clean-up
    std::vector<StdPicture*> m_loadedImages;
    //! Capacity of the m_isCustom array (update when new assets are added)
    static constexpr size_t m_isCustomVolume = 79;
    //! Holder of "is custom" flag
    bool m_isCustom[m_isCustomVolume];

    std::string m_uiPathTr;
    std::string m_uiPath;

    /*!
     * \brief Internal function of the texture loading
     * \param img Target texture
     * \param fileName File name of the texture file (excluding extension)
     */
    void loadImage(StdPicture &img, const std::string &fileName);

    /*!
     * \brief Internal function to load a frame border including its texture
     * \param border Target border to load
     * \param fileName File name of the texture file (excluding extension); border info will not include extension either
     */
    void loadBorder(FrameBorder& border, const std::string& fileName);

    //! Counter of loading errors
    int m_loadErrors = 0;
public:
    GFX_t() noexcept;
    bool load();
    void unLoad();

    StdPicture BMVs;
    StdPicture BMWin;
    RangeArr<StdPicture, 1, 3> Boot;
    RangeArr<StdPicture, 1, 5> CharacterName;
    StdPicture Chat;
    RangeArr<StdPicture, 0, 2> Container;
    RangeArr<StdPicture, 1, 3> ECursor;
    RangeArr<StdPicture, 0, 9> Font1;
    RangeArr<StdPicture, 1, 3> Font2;
    StdPicture Font2S;
    RangeArr<StdPicture, 1, 2> Heart;
    RangeArr<StdPicture, 0, 8> Interface; // Interface[4] is 37
    StdPicture LoadCoin;
    StdPicture Loader;
    RangeArr<StdPicture, 0, 3> MCursor;
    RangeArr<StdPicture, 1, 4> MenuGFX;
    RangeArr<StdPicture, 2, 2> Mount;
    RangeArr<StdPicture, 0, 7> nCursor;
    StdPicture TextBox;
    RangeArr<StdPicture, 1, 2> Tongue;
    // StdPicture Warp;
    StdPicture YoshiWings;

    // new graphics for TheXTech
    StdPicture CycloneAcc;
    StdPicture EIcons;
    StdPicture PCursor;
    StdPicture Medals;
    StdPicture CharSelIcons;
    FrameBorder CharSelFrame;
    StdPicture Backdrop; // Backdrop is 71
    FrameBorder Backdrop_Border;
    StdPicture WorldMapFrame_Tile; // WorldMapFrame_Tile is 73
    FrameBorder WorldMapFrame_Border;
    StdPicture Camera;
    StdPicture Balance;
    StdPicture SaveIcons;

    // menu-exclusive graphics, aren't checked in loadCustomUIAssets
    StdPicture Placeholder;

    bool &isCustom(size_t i);
};

//! Container of "hardcoded" (no more) graphics
extern GFX_t GFX;

#endif // GFX_H


================================================
FILE: src/global_constants.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GLOBALCONSTANTS_H
#define GLOBALCONSTANTS_H

#include <stdint.h>

// VB6 Integer type had 16-bit precision, but this is not ideal on modern platforms. Decide based on memory constraint.
#ifdef LOW_MEM
    using vbint_t = int16_t;
#else
    using vbint_t = int;
#endif

// OBSERVE: layer and event references are no longer
//   represented by strings but rather indices in the
//   Layers / Events array.
// Every object that had a Layer or Event reference
//   now has a corresponding *String() inline function
//   which looks up and returns the appropriate string.
typedef uint8_t layerindex_t;
typedef uint8_t eventindex_t;
typedef uint16_t stringindex_t;

// note that the NONE indices rely on the fact that
//   there are at most 254 layers/events,
//   leaving the -1 (255) index unused.
// see layers.h for the respective maximums.
constexpr layerindex_t LAYER_NONE = static_cast<layerindex_t>(-1);
constexpr layerindex_t LAYER_DEFAULT = static_cast<layerindex_t>(0);
constexpr layerindex_t LAYER_DESTROYED_BLOCKS = static_cast<layerindex_t>(1);
constexpr layerindex_t LAYER_SPAWNED_NPCS = static_cast<layerindex_t>(2);

constexpr eventindex_t EVENT_NONE = static_cast<eventindex_t>(-1);
constexpr eventindex_t EVENT_LEVEL_START = static_cast<eventindex_t>(0);
constexpr eventindex_t EVENT_PSWITCH_START = static_cast<eventindex_t>(1);
constexpr eventindex_t EVENT_PSWITCH_END = static_cast<eventindex_t>(2);

constexpr stringindex_t STRINGINDEX_NONE = static_cast<stringindex_t>(-1);

const int MaxLevelStrings = 65535;

//Public Const MaxSavedEvents As Integer = 200
// const int MaxSavedEvents = 200;

//const int maxSelectWorlds = 100;

const int maxCreditsLines = 200;

#ifdef LOW_MEM
const int maxSaveSlots = 3;
#else
// Temporarily limited to 3 while working on UI design...
const int maxSaveSlots = 3;
#endif

const int maxWorldCredits = 100;

const int maxYoshiGfx = 10;

// unused since multistars update
// const int maxStarsNum = 1000;

// maximum number of tracked medals and stars per level
// WARNING: c_max_track_medals must not exceed 8 (number of bits per byte) and c_max_track_stars must not exceed 255 (largest uint8_t)
const int c_max_track_medals = 8;
const int c_max_track_stars = 255;

const int maxLocalPlayers = 4;

// was previously changed to 10000; now only used for certain NPC bounds checking.
// returned to 8000.
const int FLBlocks = 8000;

//Public Const vScreenYOffset As Integer = 0     'Players Y on the screen
const int vScreenYOffset = 0;
//Public Const maxBlocks As Integer = 20000  'Max # of blocks
const int maxBlocks = 20000;
//Public Const maxPlayers As Integer = 200  'Holds the max number of players
// Must not exceed 255 (largest uint8_t)
#ifdef __16M__
const int maxPlayers = 16;
#else
const int maxPlayers = 200;
#endif

//Public Const maxEffects As Integer = 1000    'Max # of effects
const int maxEffects = 1000;
//Public Const maxNPCs As Integer = 5000    'Max # of NPCs
const int maxNPCs = 5000;
//Public Const maxBackgrounds As Integer = 8000    'Max # of background objects
const int maxBackgrounds = 8000;
//Public Const maxBlockType As Integer = 700 'Maximum number of block types
const int maxBlockType = 702;
//Public Const maxBackgroundType As Integer = 200 'Maximum number of background types
const int maxBackgroundType = 200;
//Public Const maxSceneType As Integer = 100 'Maximum number of scenetypes
const int maxSceneType = 100;
//Public Const maxNPCType As Integer = 300 'Maximum number of NPC types
const int maxNPCType = 306;
//Public Const maxEffectType As Integer = 200 'Maximum number of effect types
const int maxEffectType = 200;

//Public Const maxWarps As Integer = 200 'Maximum number of warps
#ifdef LOW_MEM
const int maxWarps = 200; // 200
#else
const int maxWarps = 2000; // 200
#endif

//Public Const numBackground2 As Integer = 100  'Total # of backgrounds
const int numBackground2 = 100;
//Public Const numCharacters As Integer = 5 'Maximum number of player characters
const int numCharacters = 5;
//Public Const numStates As Integer = 7   'Maximum number of player states
const int numStates = 11;
//Public Const maxPlayerFrames As Integer = 750 'Maximum number of player frames
const int maxPlayerFrames = 100 * numStates + 50;
//Public Const maxWater As Integer = 1000
const int maxWater = 1000;
//Public Const maxWorldLevels As Integer = 400   'Maximum number of levels
const int maxWorldLevels = 400;
//Public Const maxWorldPaths As Integer = 2000   'Maximum number of paths
const int maxWorldPaths = 2000;
//Public Const maxWorldMusic As Integer = 1000   'Maximum number of musics
const int maxWorldMusic = 1000;
//! NEW: limit on world map area count
const int maxWorldAreas = 20;
//Public Const numSounds As Integer = 100
const int numSounds = 200;
//Public Const maxSections As Integer = 20
#ifdef LOW_MEM
const int maxSections = 20;
#else
const int maxSections = 200;
#endif
//Public Const maxTileType As Integer = 400
const int maxTileType = 400;
//Public Const maxLevelType As Integer = 100
const int maxLevelType = 100;
//Public Const maxPathType As Integer = 100
const int maxPathType = 100;
//Public Const maxTiles As Integer = 20000
const int maxTiles = 20000;
//Public Const maxScenes As Integer = 5000
const int maxScenes = 5000;

// moved to "screen.h"
//Public Const ScreenW As Integer = 800  'Game Screen Width
// const int ScreenW = 800;
//Public Const ScreenH As Integer = 600  'Game Screen Height
// const int ScreenH = 600;

#endif // GLOBALCONSTANTS_H


================================================
FILE: src/global_dirs.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "global_dirs.h"

DirListCI g_dirEpisode;
DirListCI g_dirCustom;


================================================
FILE: src/global_dirs.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GLOBALDIRS_H
#define GLOBALDIRS_H

#include <Utils/dir_list_ci.h>

// extern DirListCI g_dirAssets;
extern DirListCI g_dirEpisode;
extern DirListCI g_dirCustom;

#endif // #ifndef GLOBALDIRS_H


================================================
FILE: src/global_strings.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "global_strings.h"

#include "sdl_proxy/sdl_assert.h"

#define STRS_UNIQUENESS_TRACKING


// utilities for stringindex_t
const std::string g_emptyString = "";
//! Strings storage
static std::vector<std::string> g_LevelString;
//! Number of world strings
static size_t g_numWorldString = 0;
//! List of free indexes appearing at the moddle of array
static std::vector<int> g_FreeIndexes;

#ifdef STRS_UNIQUENESS_TRACKING
//! Counter of usages per every string
static std::vector<int> g_LevelStringUsages;
//! String-To-Index map
static std::unordered_map<std::string, int> g_uniqueStringsIds;
#endif

#ifdef STRS_UNIQUENESS_TRACKING
static std::vector<std::string> g_LevelString_backup;
static std::vector<int> g_LevelStringUsages_backup;
static std::vector<int> g_FreeIndexes_backup;
static std::unordered_map<std::string, int> g_uniqueStringsIds_backup;
#endif



size_t StringsBankSize()
{
    return g_LevelString.size();
}

size_t StringsUnusedEntries()
{
    return g_FreeIndexes.size();
}

void SaveWorldStrings()
{
#ifdef STRS_UNIQUENESS_TRACKING
    g_LevelString_backup = g_LevelString;
    g_LevelStringUsages_backup = g_LevelStringUsages;
    g_FreeIndexes_backup = g_FreeIndexes;
    g_uniqueStringsIds_backup = g_uniqueStringsIds;
#endif

    g_numWorldString = g_LevelString.size();
}

void RestoreWorldStrings()
{
    EditorCursor.ClearStrings();

#ifdef STRS_UNIQUENESS_TRACKING
    g_LevelString = g_LevelString_backup;
    g_LevelStringUsages = g_LevelStringUsages_backup;
    g_FreeIndexes = g_FreeIndexes_backup;
    g_uniqueStringsIds = g_uniqueStringsIds_backup;
#else
    for(auto i = g_FreeIndexes.begin(); i != g_FreeIndexes.end(); )
    {
        if(*i >= (int)g_numWorldString)
            i = g_FreeIndexes.erase(i);
        else
            ++i;
    }
    g_LevelString.resize(g_numWorldString);
#endif
}

void ClearStringsBank()
{
    EditorCursor.ClearStrings();

    g_LevelString.clear();
    g_numWorldString = 0;

#ifdef STRS_UNIQUENESS_TRACKING
    g_LevelStringUsages.clear();
    g_uniqueStringsIds.clear();
    g_FreeIndexes.clear();
#endif
}

const std::string& GetS(stringindex_t index)
{
    if(index == STRINGINDEX_NONE)
        return g_emptyString;

    SDL_assert_release(index < g_LevelString.size());

    return g_LevelString[index];
}

void SetS(stringindex_t& index, const std::string target)
{
    if(index == STRINGINDEX_NONE && target.empty())
        return;

    SDL_assert_release(index <= STRINGINDEX_NONE);

    bool stringEmpty = index == STRINGINDEX_NONE && g_LevelString.size() < MaxLevelStrings;

    if(!stringEmpty)
    {
#ifdef STRS_UNIQUENESS_TRACKING
        SDL_assert_release(index < g_LevelString.size());
        if(g_LevelString[index] == target)
            return; // Do nothing, there is an attempt to set the same string

        g_LevelStringUsages[index]--;
        if(g_LevelStringUsages[index] == 0)
        {
            g_uniqueStringsIds.erase(g_LevelString[index]);
            g_LevelString[index].clear();
            g_FreeIndexes.push_back(index);
        }
        stringEmpty = true;
#else
        SDL_assert_release(index < g_LevelString.size());
        g_LevelString[index] = target;
#endif
    }

    if(stringEmpty)
    {
#ifdef STRS_UNIQUENESS_TRACKING
        auto f = g_uniqueStringsIds.find(target);
        if(f == g_uniqueStringsIds.end())
        {
            if(g_FreeIndexes.empty())
            {
                index = (stringindex_t)g_LevelString.size();
                g_LevelString.push_back(target);
                g_LevelStringUsages.push_back(1);
            }
            else
            {
                index = g_FreeIndexes.back();
                g_FreeIndexes.pop_back();
                g_LevelString[index] = target;
                g_LevelStringUsages[index] = 1;
            }
            g_uniqueStringsIds[target] = index;
        }
        else
        {
            index = f->second;
            g_LevelStringUsages[index]++;
        }
#else
        if(g_FreeIndexes.empty())
        {
            index = (stringindex_t)g_LevelString.size();
            g_LevelString.push_back(target);
        }
        else
        {
            index = g_FreeIndexes.back();
            g_FreeIndexes.pop_back();
            g_LevelString[index] = target;
        }
#endif
    }
}

stringindex_t AllocS(const std::string& target)
{
    stringindex_t out = STRINGINDEX_NONE;
    SetS(out, target);
    return out;
}

void FreeS(stringindex_t& index)
{
    if(index == STRINGINDEX_NONE)
        return;

    SDL_assert_release(index <= STRINGINDEX_NONE);
    SDL_assert_release(index < g_LevelString.size());

#ifdef STRS_UNIQUENESS_TRACKING
    g_LevelStringUsages[index]--;
    if(g_LevelStringUsages[index] == 0)
    {
        g_uniqueStringsIds.erase(g_LevelString[index]);
        g_LevelString[index].clear();
        g_FreeIndexes.push_back(index);
    }
#else
    g_FreeIndexes.push_back(index);
#endif

    index = STRINGINDEX_NONE;
}

std::string* PtrS(stringindex_t& index)
{
#ifdef STRS_UNIQUENESS_TRACKING
    // deduplicate the string
    std::string target;
    if(index != STRINGINDEX_NONE && g_LevelStringUsages[index] > 1)
    {
        target = GetS(index);
        FreeS(index);
    }
#endif

    if(index == STRINGINDEX_NONE)
    {
        if(g_LevelString.size() >= MaxLevelStrings)
            return nullptr;

        index = (stringindex_t)g_LevelString.size();
        g_LevelString.push_back(std::string());

#ifdef STRS_UNIQUENESS_TRACKING
        g_LevelStringUsages.push_back(1);
        g_LevelString[index] = target;
#endif
    }

    SDL_assert_release(index < g_LevelString.size());

    return &g_LevelString[index];
}


================================================
FILE: src/global_strings.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

// utilities for stringindex_t
// everything here is defined in `globals.cpp`

#pragma once
#ifndef GLOBAL_STRINGS_H
#define GLOBAL_STRINGS_H

#include "global_constants.h"
#include <vector>
#include <string>
#include <unordered_map>

extern const std::string g_emptyString;

extern size_t StringsBankSize();
extern size_t StringsUnusedEntries();

extern void SaveWorldStrings();
extern void RestoreWorldStrings();
extern void ClearStringsBank();

/*!
 * \brief Get string from the bank by index
 * \param index Index of string
 * \return Const referrence to the actual string
 */
extern const std::string& GetS(stringindex_t index);

/*!
 * \brief Set the string to the index
 * \param index destinition string field
 * \param target Target string data to assign
 */
extern void SetS(stringindex_t& index, const std::string target);

/*!
 * \brief Create new string index entry or return exist matching
 * \param target Targete string data to assing
 * \return destinition string field
 */
extern stringindex_t AllocS(const std::string& target);

/*!
 * \brief Clear the string index entry
 * \param index Target index to clear
 */
extern void FreeS(stringindex_t& index);

/*!
 * \brief Get string as pointer from the bank by index
 * \param index Index of string
 * \return Pointer to the actual string
 */
extern std::string* PtrS(stringindex_t& index);

#endif // #ifndef GLOBAL_STRINGS_H


================================================
FILE: src/globals.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#include "core/events.h"
#include "globals.h"
#include "npc_traits.h"
#include <fmt_format_ne.h>
#include <cmath>

bool GameIsActive = false;
std::string AppPath;

// int numSavedEvents = 0;
// RangeArr<std::string, 1, MaxSavedEvents> SavedEvents;
// RangeArrI<bool, 1, 4, false> BlockSwitch;
// RangeArrI<bool, 2, 7, false> PowerUpUnlock;
// long myBackBuffer = 0;
// long myBufferBMP = 0;
// int AllCharBlock = 0;
// bool StartMenu = false;
uint32_t CommonFrame = 0;
uint32_t CommonFrame_NotFrozen = 0;
bool ScrollRelease = false;
bool TakeScreen = false;
bool ShowOnScreenHUD = true;
std::string LB;
std::string EoT;

std::string Checkpoint;
std::vector<Checkpoint_t> CheckpointsList;
std::vector<LevelWarpSaveEntry_t> LevelWarpSaveEntries;
bool MagicHand = false;
RangeArr<Player_t, 1, maxLocalPlayers> testPlayer;
bool ClearBuffer = false;
int numLocked = 0;
// replaced with g_config.fullscreen
// bool resChanged = false;

int16_t testStartWarp = 0;

// moved into game_loop.cpp
// PauseCode GamePaused = PauseCode::None;

std::string MessageTitle;
MessageType g_MessageType = MESSAGE_TYPE_NORMAL;

std::string MessageText;

// int NumSelectWorld  = 0;
// std::vector<SelectWorld_t> SelectWorld;

std::string g_recentAssetPack;
std::string g_recentWorld1p;
std::string g_recentWorld2p;
std::string g_recentWorldEditor;
std::string g_recentWorldIntro;
std::string g_recentWorldOutro;
//bool ShowFPS = false;
int PrintFPS = 0;
bool g_VanillaCam = false;
// moved to "screen.cpp"
// RangeArr<vScreen_t, 0, 2> vScreen;
// int ScreenType = 0;
// int DScreenType = 0;
bool LevelEditor = false;
bool WorldEditor = false;
bool g_forceCharacter = false;
RangeArr<PlayerStart_t, 1, 2> PlayerStart;
RangeArrI<bool, 0, 20, false> blockCharacter;
RangeArrI<vbint_t, 0, maxPlayers, 0> OwedMount;
RangeArrI<vbint_t, 0, maxPlayers, 0> OwedMountType;
bool AutoUseModern = false;
RangeArr<numf_t, 0, maxSections> AutoX;
RangeArr<numf_t, 0, maxSections> AutoY;
int numStars = 0;
RangeArr<Water_t, 0, maxWater> Water;
int numWater = 0;
std::vector<Star_t> Star;
std::string GoToLevel;
bool GoToLevelNoGameThing = false;
std::string StartLevel;
bool NoMap = false;
bool RestartLevel = false;
int WorldStarsShowPolicy = -1;
// float LevelChop[maxSections + 1];
// RangeArr<int, -FLBlocks, FLBlocks> FirstBlock;
// RangeArr<int, -FLBlocks, FLBlocks> LastBlock;
int MidBackground = 1;
int LastBackground = 1;
int iBlocks = 0;
RangeArrI<vbint_t, 0, maxBlocks, 0> iBlock;
int numTiles = 0;
int numScenes = 0;
RangeArr<std::string, 0, maxSections> CustomMusic;
int numSections = 0;
RangeArr<SpeedlessLocation_t, 0, maxSections> level;
RangeArrI<bool, 0, maxSections, false> LevelWrap;
RangeArrI<bool, 0, maxSections, false> LevelVWrap;
RangeArrI<bool, 0, maxSections, false> OffScreenExit;
RangeArrI<vbint_t, 0, maxSections, 0> bgMusic;
RangeArrI<vbint_t, 0, maxSections, 0> bgMusicREAL;
RangeArrI<vbint_t, 0, maxSections, 0> Background2REAL;
RangeArr<IntegerLocation_t, 0, maxSections> LevelREAL;
int curMusic = 0;
// RangeArrI<long, 0, maxSections, 0> bgColor;    // unused since SMBX64, removed
RangeArrI<vbint_t, 0, maxSections, 0> Background2;
RangeArr<WorldPath_t, 1, maxWorldPaths> WorldPath;
int numWorldPaths = 0;
int numWarps = 0;
RangeArr<Warp_t, 1, maxWarps> Warp;
RangeArr<Tile_t, 1, maxTiles> Tile;
RangeArr<Scene_t, 1, maxScenes> Scene;
RangeArr<CreditLine_t, 1, maxCreditsLines> Credit;
int numWorldCredits = 0;
int CreditOffsetY = 0;
int CreditTotalHeight = 0;
int numCredits = 0;
int numBlock = 0;
int numBackground = 0;
int numNPCs = 0;
int numEffects = 0;
int numPlayers = 0;
int numWorldLevels = 0;
RangeArr<WorldMusic_t, 1, maxWorldMusic> WorldMusic;
int numWorldMusic = 0;
RangeArr<WorldArea_t, 1, maxWorldAreas> WorldArea;
int numWorldAreas = 0;
RangeArr<WorldLevel_t, 1, maxWorldLevels> WorldLevel;
RangeArr<Background_t, 1, (maxBackgrounds + maxWarps)> Background;
RangeArr<Effect_t, 1, maxEffects> Effect;

RangeArr<NPC_t, -128, maxNPCs> NPC;
RangeArr<Block_t, 0, maxBlocks> Block;

RangeArr<Player_t, 0, maxPlayers> Player;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> MarioFrameX;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> MarioFrameY;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> LuigiFrameX;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> LuigiFrameY;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> PeachFrameX;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> PeachFrameY;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> ToadFrameX;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> ToadFrameY;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> LinkFrameX;
RangeArrI<int8_t, 0, maxPlayerFrames, 0> LinkFrameY;
RangeArrI<bool, 0, maxBackgroundType, false> BackgroundFence;

RangeArr<NPCTraits_t, 0, maxNPCType> NPCTraits;

#if 0
RangeArrI<int, 0, maxNPCType, 0> NPCFrameOffsetX;
RangeArrI<int, 0, maxNPCType, 0> NPCFrameOffsetY;
RangeArrI<int, 0, maxNPCType, 0> NPCWidth;
RangeArrI<int, 0, maxNPCType, 0> NPCHeight;
RangeArrI<int, 0, maxNPCType, 0> NPCWidthGFX;
RangeArrI<int, 0, maxNPCType, 0> NPCHeightGFX;
RangeArr<float, 0, maxNPCType> NPCSpeedvar;

// RangeArrI<bool, 0, maxNPCType, false> NPCIsAShell;
RangeArrI<bool, 0, maxNPCType, false> NPCIsABlock;
RangeArrI<bool, 0, maxNPCType, false> NPCIsAHit1Block;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsABonus;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsACoin;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsAVine;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsAnExit;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsAParaTroopa;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsCheep;
RangeArrI<bool, 0, maxNPCType, false> NPCJumpHurt;
RangeArrI<bool, 0, maxNPCType, false> NPCNoClipping;
RangeArrI<int, 0, maxNPCType, 0> NPCScore;
RangeArrI<bool, 0, maxNPCType, false> NPCCanWalkOn;
RangeArrI<bool, 0, maxNPCType, false> NPCGrabFromTop;
RangeArrI<bool, 0, maxNPCType, false> NPCTurnsAtCliffs;
RangeArrI<bool, 0, maxNPCType, false> NPCWontHurt;
RangeArrI<bool, 0, maxNPCType, false> NPCMovesPlayer;
RangeArrI<bool, 0, maxNPCType, false> NPCStandsOnPlayer;
RangeArrI<bool, 0, maxNPCType, false> NPCIsGrabbable;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsBoot;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsYoshi;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsToad;
RangeArrI<bool, 0, maxNPCType, false> NPCNoYoshi;
RangeArrI<bool, 0, maxNPCType, false> NPCForeground;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsABot;
// RangeArrI<bool, 0, maxNPCType, false> NPCDefaultMovement;
// RangeArrI<bool, 0, maxNPCType, false> NPCIsVeggie;
RangeArrI<bool, 0, maxNPCType, false> NPCNoFireBall;
RangeArrI<bool, 0, maxNPCType, false> NPCNoIceBall;
RangeArrI<bool, 0, maxNPCType, false> NPCNoGravity;

RangeArrI<int, 0, maxNPCType, 0> NPCFrame;
RangeArrI<int, 0, maxNPCType, 0> NPCFrameSpeed;
RangeArrI<int, 0, maxNPCType, 0> NPCFrameStyle;
#endif

RangeArrI<bool, 0, maxBlockType, false> BlockIsSizable;
RangeArrI<vbint_t, 0, maxBlockType, 0> BlockSlope;
RangeArrI<vbint_t, 0, maxBlockType, 0> BlockSlope2;

// moved into vScreen
// RangeArr<double, 0, maxPlayers> vScreenX;
// RangeArr<double, 0, maxPlayers> vScreenY;

// moved into qScreenLoc
// RangeArr<double, 0, maxPlayers> qScreenX;
// RangeArr<double, 0, maxPlayers> qScreenY;

bool qScreen = false;
bool qScreen_canonical = false;
// RangeArr<vScreen_t, 0, 2> qScreenLoc;

RangeArrI<vbint_t, 0, maxBlockType, 0> BlockWidth;
RangeArrI<vbint_t, 0, maxBlockType, 0> BlockHeight;
// RangeArrI<int, 0, maxBlockType, 0> BonusWidth;
// RangeArrI<int, 0, maxBlockType, 0> BonusHeight;
RangeArrI<vbint_t, 0, maxEffectType, 0> EffectWidth;
RangeArrI<vbint_t, 0, maxEffectType, 0> EffectHeight;

EffectDefaults_t EffectDefaults;
RangeArrI<vbint_t, 1, maxSceneType, 0> SceneWidth;
RangeArrI<vbint_t, 1, maxSceneType, 0> SceneHeight;
RangeArrI<vbint_t, 0, 9, 0> SpecialFrame;
RangeArr<vbint_t, 0, 9> SpecialFrameCount;
RangeArrI<bool, 1, maxBackgroundType, false> BackgroundHasNoMask;
RangeArrI<bool, 0, maxBackgroundType, false> Foreground;
RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundWidth;
RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundHeight;
RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundFrame;
RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundFrameCount;
RangeArrI<vbint_t, 1, maxBlockType, 0> BlockFrame;
RangeArrI<vbint_t, 1, maxBlockType, 0> BlockFrame2;

// deprecated
// RangeArrI<int, 1, 1000, 0> sBlockArray;
// int sBlockNum = 0;

RangeArrI<vbint_t, 1, maxSceneType, 0> SceneFrame;
RangeArrI<vbint_t, 1, maxSceneType, 0> SceneFrame2;
RangeArrI<vbint_t, 1, maxTileType, 0> TileWidth;
RangeArrI<vbint_t, 1, maxTileType, 0> TileHeight;
RangeArrI<vbint_t, 1, maxTileType, 0> TileFrame;
RangeArrI<vbint_t, 1, maxTileType, 0> TileFrame2;
RangeArrI<vbint_t, 1, 100, 0> LevelFrame;
RangeArrI<vbint_t, 1, 100, 0> LevelFrame2;
RangeArrI<bool, 1, maxBlockType, false> BlockHasNoMask;
// RangeArrI<bool, 1, 100, false> LevelHasNoMask;
RangeArrI<bool, 0, maxBlockType, false> BlockOnlyHitspot1;
RangeArrI<bool, 0, maxBlockType, false> BlockKills;
RangeArrI<bool, 0, maxBlockType, false> BlockKills2;
RangeArrI<bool, 0, maxBlockType, false> BlockHurts;
RangeArrI<bool, 0, maxBlockType, false> BlockPSwitch;
RangeArrI<bool, 0, maxBlockType, false> BlockNoClipping;
RangeArrI<vbint_t, 1, 10, 0> CoinFrame;
RangeArrI<vbint_t, 1, 10, 0> CoinFrame2;
EditorCursor_t EditorCursor;
EditorControls_t EditorControls;
SharedControls_t l_SharedControls;

CursorControls_t SharedCursor;
// RangeArr<CursorControls_t, 1, maxLocalPlayers> PlayerCursor;

bool SharedPause;
bool SharedPauseLegacy;
bool SharedPauseForce;

// RangeArrI<int, 1, numSounds, 0> Sound;
RangeArrI<vbint_t, 1, numSounds, 0> SoundPause;
bool ErrorQuit = false;
bool EndLevel = false;
LevelMacro_t LevelMacro = LEVELMACRO_OFF;
int LevelMacroWhich = 0;
int LevelMacroCounter = 0;
bool CanWallJump = false;

// information about the currently loaded file
std::string FileName;
std::string FileNameFull;
std::string FullFileName;
std::string FileNamePath;
std::string FileRecentSubHubLevel;
int FileFormat = 0;

// backup information to restore when returning to world map
std::string FileNameWorld;
std::string FileNameFullWorld;
std::string FileNamePathWorld;
int FileFormatWorld = 0;

bool IsEpisodeIntro = false;
bool IsHubLevel = false;
int Coins = 0;
int Lives = 0;
int g_100s = 0;
// bool EndIntro = false;
// bool ExitMenu = false;
bool LevelSelect = false;
bool LevelRestartRequested = false;
RangeArr<WorldPlayer_t, 0, 1> WorldPlayer;
LevelBeatCode_t LevelBeatCode = BEATCODE_NONE;
int curWorldLevel = 0;
int curWorldMusic = 0;
std::string curWorldMusicFile;
RangeArrI<bool, 0, maxSections, false> NoTurnBack;
RangeArrI<bool, 0, maxSections, false> UnderWater;
RangeArrI<stringindex_t, 0, maxSections, STRINGINDEX_NONE> SectionJSONInfo;
std::string WldxCustomParams;
std::vector<std::string> SubHubLevels;
bool TestLevel = false;
bool GameMenu = false;
std::string WorldName;
int selWorld = 0;
int selSave = 0;
int PSwitchTime = 0;
int PSwitchStop = 0;
int InvincibilityTime = 0;
int PSwitchPlayer = 0;

RangeArr<SaveSlotInfo_t, 1, maxSaveSlots> SaveSlotInfo;

int BeltDirection = 0;
bool BeatTheGame = false;
//int cycleCount = 0;
//double fpsTime = 0.0;
//double fpsCount = 0.0;
//bool FrameSkip = false;
//double GoalTime = 0.0;
//double overTime = 0.0;
// int worldCurs = 0;
// int minShow = 0;
// int maxShow = 0;

int ReturnWarp = 0;
int ReturnWarpSaved = 0;
int StartWarp = 0;
Physics_t Physics;
int MenuCursor = 0;
int MenuMode = 0;
bool MenuCursorCanMove = false;
bool MenuCursorCanMove_Back = false;
// bool NextFrame = false;
int StopHit = 0;
bool MouseRelease = false;
// bool TestFullscreen = false;
//bool keyDownAlt = false;
//bool keyDownEnter = false;
bool BlocksSorted = false;
int SingleCoop = 0;
bool g_ClonedPlayerMode = false;
//std::string CheatString;
bool GameOutro = false;
bool GameOutroDoQuit = false;
int CreditChop = 0;
int EndCredits = 0;
int curStars = 0;
// int maxStars = 0;
bool ShadowMode = false;
bool MultiHop = false;
bool SuperSpeed = false;
bool WalkAnywhere = false;
bool FlyForever = false;
bool FreezeNPCs = false;
bool CaptainN = false;
bool FlameThrower = false;
bool CoinMode = false;
// bool WorldUnlock = false;
//bool MaxFPS = false;
bool GodMode = false;
bool GrabAll = false;
bool Cheater = false;
#ifdef ENABLE_ANTICHEAT_TRAP
bool CheaterMustDie = false;
#endif

RangeArr<std::string, 1, maxWorldCredits> WorldCredits;
int Score = 0;
RangeArrI<int, 1, 13, 0> Points;
int MaxWorldStars = 0;
// bool Debugger = false;
RangeArr<SavedChar_t, 0, 10> SavedChar;

bool LoadingInProcess = false;
int LoadCoins = 0;
unsigned int LoadCoinsT = 0;

// RangeArrI<bool, 1, maxBlockType, false> GFXBlockCustom;
//RangeArrI<long, 1, maxBlockType, 0> GFXBlock;
//RangeArrI<long, 1, maxBlockType, 0> GFXBlockMask;
RangeArr<StdPicture, 1, maxBlockType> GFXBlockBMP;
//RangeArr<StdPicture, 1, maxBlockType> GFXBlockMaskBMP;
// RangeArrI<bool, 1, numBackground2, false> GFXBackground2Custom;
//RangeArrI<long, 1, numBackground2, 0> GFXBackground2;
RangeArr<StdPicture, 1, numBackground2> GFXBackground2BMP;
// RangeArrI<vbint_t, 1, numBackground2, 0> GFXBackground2Height;
// RangeArrI<vbint_t, 1, numBackground2, 0> GFXBackground2Width;
// RangeArrI<bool, 1, maxNPCType, false> GFXNPCCustom;
//RangeArrI<long, 1, maxNPCType, 0> GFXNPC;
//RangeArrI<long, 1, maxNPCType, 0> GFXNPCMask;
RangeArr<StdPicture, 0, maxNPCType> GFXNPCBMP;
//RangeArr<StdPicture, 0, maxNPCType> GFXNPCMaskBMP;
// RangeArrI<int, 1, maxNPCType, 0> GFXNPCHeight;
// RangeArrI<int, 1, maxNPCType, 0> GFXNPCWidth;
RangeArrI<bool, 1, maxEffectType, false> GFXEffectCustom;
//RangeArrI<long, 1, maxEffectType, 0> GFXEffect;
//RangeArrI<long, 1, maxEffectType, 0> GFXEffectMask;
RangeArr<StdPicture, 1, maxEffectType> GFXEffectBMP;
//RangeArr<StdPicture, 1, maxEffectType> GFXEffectMaskBMP;
// RangeArrI<vbint_t, 1, maxEffectType, 0> GFXEffectHeight;
// RangeArrI<vbint_t, 1, maxEffectType, 0> GFXEffectWidth;
// RangeArrI<bool, 1, maxBackgroundType, false> GFXBackgroundCustom;
//RangeArrI<long, 1, maxBackgroundType, 0> GFXBackground;
//RangeArrI<long, 1, maxBackgroundType, 0> GFXBackgroundMask;
RangeArr<StdPicture, 1, maxBackgroundType> GFXBackgroundBMP;
//RangeArr<StdPicture, 1, maxBackgroundType> GFXBackgroundMaskBMP;
// RangeArrI<vbint_t, 1, maxBackgroundType, 0> GFXBackgroundHeight;
// RangeArrI<vbint_t, 1, maxBackgroundType, 0> GFXBackgroundWidth;

const char *GFXPlayerNames[numCharacters] =
{
    "mario", "luigi", "peach", "toad", "link"
};
RangeArr<StdPicture, 1, numStates> *GFXCharacterBMP[numCharacters] =
{
    &GFXMarioBMP, &GFXLuigiBMP, &GFXPeachBMP, &GFXToadBMP, &GFXLinkBMP
};
// RangeArrI<vbint_t, 1, 10, 0> *GFXCharacterWidth[numCharacters] =
// {
//     &GFXMarioWidth, &GFXLuigiWidth, &GFXPeachHeight, &GFXToadWidth, &GFXLinkWidth
// };
// RangeArrI<vbint_t, 1, 10, 0> *GFXCharacterHeight[numCharacters] =
// {
//     &GFXMarioHeight, &GFXLuigiHeight, &GFXPeachHeight, &GFXToadHeight, &GFXLinkHeight
// };
// RangeArrI<bool, 1, 10, false> *GFXCharacterCustom[numCharacters] =
// {
//     &GFXMarioCustom, &GFXLuigiCustom, &GFXPeachCustom, &GFXToadCustom, &GFXLinkCustom
// };

// RangeArrI<bool, 1, 10, false> GFXMarioCustom;
//RangeArrI<long, 1, 10, 0> GFXMario;
//RangeArrI<long, 1, 10, 0> GFXMarioMask;
RangeArr<StdPicture, 1, numStates> GFXMarioBMP;
//RangeArr<StdPicture, 1, 10> GFXMarioMaskBMP;
// RangeArrI<vbint_t, 1, 10, 0> GFXMarioHeight;
// RangeArrI<vbint_t, 1, 10, 0> GFXMarioWidth;
// RangeArrI<bool, 1, 10, false> GFXLuigiCustom;
//RangeArrI<long, 1, 10, 0> GFXLuigi;
//RangeArrI<long, 1, 10, 0> GFXLuigiMask;
RangeArr<StdPicture, 1, numStates> GFXLuigiBMP;
//RangeArr<StdPicture, 1, 10> GFXLuigiMaskBMP;
// RangeArrI<vbint_t, 1, 10, 0> GFXLuigiHeight;
// RangeArrI<vbint_t, 1, 10, 0> GFXLuigiWidth;
// RangeArrI<bool, 1, 10, false> GFXPeachCustom;
//RangeArrI<long, 1, 10, 0> GFXPeach;
//RangeArrI<long, 1, 10, 0> GFXPeachMask;
RangeArr<StdPicture, 1, numStates> GFXPeachBMP;
//RangeArr<StdPicture, 1, 10> GFXPeachMaskBMP;
// RangeArrI<vbint_t, 1, 10, 0> GFXPeachHeight;
// RangeArrI<vbint_t, 1, 10, 0> GFXPeachWidth;
// RangeArrI<bool, 1, 10, false> GFXToadCustom;
//RangeArrI<long, 1, 10, 0> GFXToad;
//RangeArrI<long, 1, 10, 0> GFXToadMask;
RangeArr<StdPicture, 1, numStates> GFXToadBMP;
//RangeArr<StdPicture, 1, 10> GFXToadMaskBMP;
// RangeArrI<vbint_t, 1, 10, 0> GFXToadHeight;
// RangeArrI<vbint_t, 1, 10, 0> GFXToadWidth;

// RangeArrI<bool, 1, 10, false> GFXLinkCustom;
//RangeArrI<long, 1, 10, 0> GFXLink;
//RangeArrI<long, 1, 10, 0> GFXLinkMask;
RangeArr<StdPicture, 1, numStates> GFXLinkBMP;
//RangeArr<StdPicture, 1, 10> GFXLinkMaskBMP;
// RangeArrI<vbint_t, 1, 10, 0> GFXLinkHeight;
// RangeArrI<vbint_t, 1, 10, 0> GFXLinkWidth;

// RangeArrI<bool, 1, maxYoshiGfx, false> GFXYoshiBCustom;
//RangeArrI<long, 1, 10, 0> GFXYoshiB;
//RangeArrI<long, 1, 10, 0> GFXYoshiBMask;
RangeArr<StdPicture, 1, 10> GFXYoshiBBMP;
//RangeArr<StdPicture, 1, 10> GFXYoshiBMaskBMP;
// RangeArrI<bool, 1, 10, false> GFXYoshiTCustom;
//RangeArrI<long, 1, 10, 0> GFXYoshiT;
//RangeArrI<long, 1, 10, 0> GFXYoshiTMask;
RangeArr<StdPicture, 1, 10> GFXYoshiTBMP;
//RangeArr<StdPicture, 1, 10> GFXYoshiTMaskBMP;
// RangeArrI<bool, 1, maxTileType, false> GFXTileCustom;
//RangeArrI<long, 1, maxTileType, 0> GFXTile;
RangeArr<StdPicture, 1, maxTileType> GFXTileBMP;
// RangeArrI<vbint_t, 1, maxTileType, 0> GFXTileHeight;
// RangeArrI<vbint_t, 1, maxTileType, 0> GFXTileWidth;
// RangeArrI<bool, 0, maxLevelType, false> GFXLevelCustom;
//RangeArrI<long, 0, maxLevelType, 0> GFXLevel;
//RangeArrI<long, 0, maxLevelType, 0> GFXLevelMask;
RangeArr<StdPicture, 0, maxLevelType> GFXLevelBMP;
//RangeArr<StdPicture, 0, maxLevelType> GFXLevelMaskBMP;
// RangeArrI<vbint_t, 0, maxLevelType, 0> GFXLevelHeight;
// RangeArrI<vbint_t, 0, maxLevelType, 0> GFXLevelWidth;
RangeArrI<bool, 0, maxLevelType, false> GFXLevelBig;
// RangeArrI<bool, 1, maxSceneType, false> GFXSceneCustom;
//RangeArrI<long, 1, maxSceneType, 0> GFXScene;
//RangeArrI<long, 1, maxSceneType, 0> GFXSceneMask;
RangeArr<StdPicture, 1, maxSceneType> GFXSceneBMP;
//RangeArr<StdPicture, 1, maxSceneType> GFXSceneMaskBMP;
// RangeArrI<vbint_t, 1, maxSceneType, 0> GFXSceneHeight;
// RangeArrI<vbint_t, 1, maxSceneType, 0> GFXSceneWidth;
// RangeArrI<bool, 1, maxPathType, false> GFXPathCustom;
//RangeArrI<long, 1, maxPathType, 0> GFXPath;
//RangeArrI<long, 1, maxPathType, 0> GFXPathMask;
RangeArr<StdPicture, 1, maxPathType> GFXPathBMP;
//RangeArr<StdPicture, 1, maxPathType> GFXPathMaskBMP;
// RangeArrI<vbint_t, 1, maxPathType, 0> GFXPathHeight;
// RangeArrI<vbint_t, 1, maxPathType, 0> GFXPathWidth;

// RangeArrI<bool, 1, numCharacters, false> GFXPlayerCustom;
//RangeArrI<long, 1, numCharacters, 0> GFXPlayer;
//RangeArrI<long, 1, numCharacters, 0> GFXPlayerMask;
RangeArr<StdPicture, 1, numCharacters> GFXPlayerBMP;
//RangeArr<StdPicture, 1, numCharacters> GFXPlayerMaskBMP;
// RangeArrI<vbint_t, 1, numCharacters, 0> GFXPlayerHeight;
// RangeArrI<vbint_t, 1, numCharacters, 0> GFXPlayerWidth;

// int PlayerCharacter = 0;
// int PlayerCharacter2 = 0;
// double MenuMouseX = 0.0;
// double MenuMouseY = 0.0;
// Sint32 MenuWheelDelta = 0;
// bool MenuWheelMoved = false;
// bool MenuMouseDown = false;
// bool MenuMouseBack = false;
bool MenuMouseRelease = false;
// bool MenuMouseMove = false;
bool MenuMouseClick = false;

bool ForcedControls = false;
Controls_t ForcedControl;
// int SyncCount = 0;
// bool noUpdate = false;
//double gameTime = 0.0;

// deprecated by g_config.audio_enable
// bool noSound = false;

//bool neverPause = false;
//double tempTime = 0.0;
bool BattleMode = false;
int BattleWinner = 0;
RangeArrI<int, 1, maxPlayers, 0> BattleLives;
int BattleIntro = 0;
int BattleOutro = 0;
std::string LevelName;
std::string CurrentLanguage;
std::string CurrentLangDialect;

#ifdef __WIIU__
bool g_isHBLauncher = false;
#endif

//void DoEvents()
//{
//    g_events->doEvents();
//}

//Uint8 getKeyState(int key)
//{
//    return XEvents::getKeyState(key);
//}

//Uint8 getKeyStateI(int key)
//{
//    if(key < 0)
//        return 0;
//    return XEvents::getKeyState(key);
//}

// const char *getKeyName(int key)
// {
//     if(key < 0)
//         return " ... ";
//     return g_events->getScanCodeName(key);
// }

void initAll()
{
    // SavedEvents.fill(std::string());
    // BlockSwitch.fill(false);
    // PowerUpUnlock.fill(false);
    vScreen.fill(vScreen_t());
    qScreenLoc.fill(vScreen_t());
    PlayerStart.fill(PlayerStart_t());
    blockCharacter.fill(false);
    OwedMount.fill(0);
    OwedMountType.fill(0);
    AutoX.fill(0);
    AutoY.fill(0);
    Water.fill(Water_t());
    // FirstBlock.fill(0);
    // LastBlock.fill(0);
    iBlock.fill(0);
    CustomMusic.fill(std::string());
    level.fill(SpeedlessLocation_t());
    LevelWrap.fill(false);
    LevelVWrap.fill(false);
    OffScreenExit.fill(false);
    bgMusic.fill(0);
    bgMusicREAL.fill(0);
    Background2REAL.fill(0);
    Background2.fill(0);
    SpecialFrameCount.fill(0);
    // NPCSpeedvar.fill(0.f);

    Block.fill(Block_t());
    Background.fill(Background_t());
    NPC.fill(NPC_t());

    InitScreens();
    for(int i = 0; i < maxLocalPlayers; i++)
        Screens_AssignPlayer(i + 1, *l_screen);
}

XTColor XTColorString(const std::string& s)
{
    const char* s_ = s.c_str();

    if(s_[0] == '0' && s_[1] == 'x')
        s_ += 2;

    if(*s_ == '#')
        s_++;

    uint8_t color[4] = {255, 255, 255, 255};

    // read each byte separately
    for(int i = 0; i < 4; i++)
    {
        if(s_[0] == '\0' || s_[1] == '\0')
            break;

        uint8_t nybble[2] = {0, 0};

        for(int j = 0; j < 2; j++)
        {
            if(*s_ >= '0' && *s_ <= '9')
                nybble[j] = *s_ - '0';
            else if(*s_ >= 'a' && *s_ <= 'f')
                nybble[j] = *s_ - 'a' + 10;
            else if(*s_ >= 'A' && *s_ <= 'F')
                nybble[j] = *s_ - 'A' + 10;

            s_++;
        }

        color[i] = nybble[0] * 16 + nybble[1];
    }

    return XTColor(color[0], color[1], color[2], color[3]);
}


================================================
FILE: src/globals.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GLOBALS_H
#define GLOBALS_H

#include <string>
#include <vector>
#include <cstdlib>

#include "std_picture.h"

#include "numeric_types.h"
#include "location.h"
#include "pinched_info.h"
#include "range_arr.hpp"
#include "ref_type.h"
#include "rand.h"
#include "npc_id.h"
#include "phys_id.h"
#include "eff_id.h"
#include "npc_effect.h"
#include "player/player_effect.h"

#include "global_constants.h"
#include "global_strings.h"

//Option Explicit
//Public Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
//Public Declare Function BitBlt Lib "gdi32" (ByVal hDestDC As Long, ByVal X As Long, ByVal Y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As Long) As Long
//Public Declare Function StretchBlt Lib "gdi32" (ByVal hdc As Long, ByVal X As Long, ByVal Y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nSrcWidth As Long, ByVal nSrcHeight As Long, ByVal dwRop As Long) As Long
//Public Declare Function CreateCompatibleBitmap Lib "gdi32" (ByVal hdc As Long, ByVal nWidth As Long, ByVal nHeight As Long) As Long
//Public Declare Function CreateCompatibleDC Lib "gdi32" (ByVal hdc As Long) As Long
//Public Declare Function GetDC Lib "user32" (ByVal hWnd As Long) As Long
//Public Declare Function SelectObject Lib "gdi32" (ByVal hdc As Long, ByVal hObject As Long) As Long
//Public Declare Function DeleteObject Lib "gdi32" (ByVal hObject As Long) As Long
//Public Declare Function DeleteDC Lib "gdi32" (ByVal hdc As Long) As Long
//Public Declare Function GetKeyState Lib "user32" (ByVal nVirtKey As Long) As Integer
//'Public Declare Function mciSendString Lib "winmm.dll" Alias "mciSendStringA" (ByVal lpstrCommand As String, ByVal lpstrReturnString As String, ByVal uReturnLength As Integer, ByVal hwndCallback As Integer) As Integer
//Public Declare Function SetCursorPos Lib "user32" (ByVal X As Long, ByVal Y As Long) As Long
//Public Declare Function SetWindowPos Lib "user32" (ByVal hWnd As Long, ByVal hWndInsertAfter As Long, ByVal X As Long, ByVal Y As Long, ByVal cx As Long, ByVal cy As Long, ByVal wFlags As Long) As Long
//Private Declare Function GetSystemDirectory Lib "kernel32" Alias "GetSystemDirectoryA" (ByVal lpBuffer As String, ByVal nSize As Long) As Long
//Public Declare Function GetDesktopWindow Lib "user32.dll" () As Long
//Public Declare Function GetWindowDC Lib "user32.dll" (ByVal hWnd As Long) As Long
//Declare Function GetActiveWindow Lib "user32" () As Integer
//Public Declare Function GetTickCount& Lib "kernel32" ()
//Public OnlineDisc As Boolean

#define UNUSED(x) (void)x

#if defined(__GNUC__)
#   define ATTRIB_UNUSED    __attribute__((unused))
#else
#   define ATTRIB_UNUSED
#endif

#define IF_OUTRANGE(x, l, r)  ((x) < (l) || (x) > (r))
#define IF_INRANGE(x, l, r)  ((x) >= (l) && (x) <= (r))


//! Showing that game is works. It gets false when closing a window or exiting a game by menu. To mean that application must be closed.
extern bool GameIsActive;
//! Path to game resources assets (by default it's ~/.PGE_Project/thextech/)
extern std::string AppPath;


// Process internal events (mouse, keyboard, joysticks, window's update, OS communications, etc.)
//extern void DoEvents(); /* Replaced with "XEvents::doEvents()" from `core/events.h` */

//extern Uint8 getKeyState(int key);
//extern Uint8 getKeyStateI(int key);

//Public Const KEY_PRESSED As Integer = &H1000    'For control information
//const int KEY_PRESSED = 1;

/**
 * @brief Get name of key from a keycode
 * @param key Key code
 * @return Human-readable key name
 */
// const char *getKeyName(int key); // no longer used

/**
 * @brief Rounding function that works same as in VB6
 * @param x Floating point value to round
 * @return rounded result
 */
// moved to num_t::vb6round
// extern int vb6Round(double x);


//'Saved Events
//Public numSavedEvents As Integer
// extern int numSavedEvents;
//Public SavedEvents(1 To MaxSavedEvents) As String
// extern RangeArr<std::string, 1, MaxSavedEvents> SavedEvents;
//Public BlockSwitch(1 To 4) As Boolean
// extern RangeArrI<bool, 1, 4, false> BlockSwitch;
//'Public PowerUpUnlock(2 To 7) As Boolean
// extern RangeArrI<bool, 2, 7, false> PowerUpUnlock;

//Public Const SWP_SHOWWINDOW = &H40
//const int SWP_SHOWWINDOW = 0x40;
//Public Const SWP_NOMOVE As Long = 2
//const long SWP_NOMOVE = 2;
//Public Const SWP_NOSIZE As Long = 1
//const long SWP_NOSIZE = 1;
//Public Const FLAGS = SWP_NOMOVE Or SWP_NOSIZE
//const long FLAGS = SWP_NOMOVE | SWP_NOSIZE;
//Public Const HWND_TOPMOST As Long = -1
//const long HWND_TOPMOST = -1;
//Public Const HWND_NOTOPMOST As Long = -2
//const long HWND_NOTOPMOST  = -2;
//Public myBackBuffer As Long 'Backbuffer
// extern long myBackBuffer;
//Public myBufferBMP As Long 'Backbuffer
// extern long myBufferBMP;
//Public AllCharBlock As Integer
// extern int AllCharBlock;
//Public Const KEY_TOGGLED As Integer = &H1   'For control information
//const int KEY_TOGGLED = 0x01;
//Public LocalNick As String  'Online Nickname
//Public LocalCursor As Integer  'Online Cursor color
//Public ClientPassword As String  'Password client is connecting with
//Public ServerPassword As String  'Password game server wants the client to use
//Public ServerClear As Boolean
//Public StartMenu As Boolean
// extern bool StartMenu;

//Public BlockFlash As Integer
// Note: was previously BlockFlash, manually looped by local code to 0-90. Now incremented every frame, should be used with modulus operator.
extern uint32_t CommonFrame;
// This one only increments when FreezeNPCs is not true. Used by shaders.
extern uint32_t CommonFrame_NotFrozen;

//Public ScrollRelease As Boolean
extern bool ScrollRelease;
//Public TakeScreen As Boolean
extern bool TakeScreen;
// EXTRA: Show any on-screen meta (HUD, debug prints, etc.)
extern bool ShowOnScreenHUD;
//Public LB As String  ' Line Break
//extern std::string LB;
//Public EoT As String  ' End of Transmission for WINSOCK
//extern std::string EoT;

// Moved back into "control_types.h"
//     since "controls.h" is changing more rapidly
#include "control_types.h"

//Public Type nPlayer  'online player type
//    Controls As Controls  'online players controls
//    Cursor As Integer
//    IsMe As Boolean  'True if this player is the local player
//    Nick As String
//    Active As Boolean  'True if a player is using this variable
//    ECurserX As Double  'Cursor X position
//    ECurserY As Double   'Cursor Y position
//End Type


//Public Type nPlay  'Netplay data type
//    Allow As Boolean
//    Mode As Integer  'Server or client
//    ServerIP As String 'Server's IP
//    ServerCon As Boolean 'Server is connected
//    ServerStr As String
//    ServerLocked As Boolean
//    ServerLoad1 As Double
//    ServerLoad As Boolean
//    ClientLocked(0 To 15) As Boolean
//    ClientIP(0 To 15) As String
//    ClientCon(0 To 15) As Boolean
//    ClientName(0 To 15) As String
//    ClientStr(0 To 15) As String
//    ClientRelease(0 To 15) As Integer
//    ClientPassword(0 To 15) As Boolean
//    ClientLoad1(0 To 15) As Double
//    Online As Boolean 'online or local
//    MySlot As Integer
//    MyControls As Controls
//    Player(0 To 15) As nPlayer
//    PlayerWaitCount As Integer
//    NPCWaitCount As Single
//End Type

//Public Type Location    'Holds location information for objects
//    X As Double
//    Y As Double
//    Height As Double
//    Width As Double
//    SpeedX As Double
//    SpeedY As Double
//End Type

//Public Type EditorControls      'Controls for the editor
// struct OldEditorControls_t
// {
//    Up As Boolean
//    Down As Boolean
//    Left As Boolean
//    Right As Boolean
//    Mouse1 As Boolean
//End Type
// };


// Structures moved into con_control.h

// Functionality moved into the Controls namespace

// The information of conKeyboard and conJoystick is now found in the InputMethodType Profiles.
// To access it you will need to access the internals of the Controls namespace.
// Avoid doing this.

//Public conKeyboard(1 To 2) As conKeyboard  'player 1 and 2's controls
// extern RangeArr<ConKeyboard_t, 1, maxLocalPlayers> conKeyboard;
//Public conJoystick(1 To 2) As conJoystick
// extern RangeArr<ConJoystick_t, 1, maxLocalPlayers> conJoystick;

// The information of useJoystick and wantedKeyboard is now dynamic you can
// determine by observing the RTTI of the members of Controls::g_InputMethods.
// Avoid doing this.

//Public useJoystick(1 To 2) As Integer
// extern RangeArrI<int, 1, maxLocalPlayers, 0> useJoystick; // no longer
// extern RangeArrI<bool, 1, maxLocalPlayers, false> wantedKeyboard;

struct NPCTraits_t;

enum WingBehaviors : uint8_t
{
    WING_NONE = 0,
    WING_PARA_CHASE = 0,
    WING_JUMP = 1,
    WING_LEFTRIGHT = 2,
    WING_UPDOWN = 3,
    WING_CHASE = 4,
    // reserved 38A values
    WING_HOVER_FORWARD = 5,
    WING_BUTTERFLY_AI = 6,
    // reserved 38A values -- won't happen
    WING_RSV_REMOTE_CONTROL = 7,
    WING_RSV_RAILS = 8,
    // reserved TheXTech values
    WING_FLEE = 9,
    // use normal NPC control for now
    WING_OVERRIDE = 255,
};

//Public Type NPC 'The NPC Type
struct NPC_t
{
    // most important and frequently accessed fields at the top of the struct
//    Type As Integer 'Defines what NPC this is.  1 for goomba, 2 for red goomba, etc.
    NPCID Type = NPCID(0);
//    Killed As Integer 'Flags the NPC to die a specific way.
    vbint_t Killed = 0;
//    Frame As Integer 'The graphic to be shown
    vbint_t Frame = 0;
//    tempBlock As Integer
    // temp block index in the block array
    vbint_t tempBlock = 0;

//    Active As Boolean 'If on screen
    bool Active = false;
//    Hidden As Boolean 'if the layer is hidden or not
    bool Hidden = false;
//    Inert As Boolean 'the friendly toggle. makes the NPC not do anything
    bool Inert = false;

//    Reset(1 To 2) As Boolean 'If it can display the NPC
    // IMPORTANT: in SMBX64 and compat mode, Reset[1] is whether the NPC was NOT on vScreen 1 during the last draw
    //            and Reset[2] is whether it was NOT on vScreen 2 during the last draw.
    //     Because TheXTech plans to support more than 2 vScreens, it uses Reset[1] to mark whether the NPC was on
    //         NO screens during the last draw. Reset[1] is the only externally usable flag, and Reset[2] is used
    //         internally during the NPC screen logic to mark whether Reset[1] was set prior to the screen logic.
    RangeArrI<bool, 1, 2, false> Reset;

//    JustActivated As Integer 'The player that activated the NPC
    uint8_t JustActivated = 0;
//    TimeLeft As Integer 'Time left before reset when not on screen
    vbint_t TimeLeft = 0;

//    Location As Location 'collsion detection information
    Location_t Location;

// NEW: position variables (or double counters) used by AI
    num_t SpecialX = 0_n;
    num_t SpecialY = 0_n;

//'Secial - misc variables used for NPC AI
//    Special As Double
    vbint_t Special = 0;
//    Special2 As Double
    vbint_t Special2 = 0;
//    Special3 As Double
    vbint_t Special3 = 0;
//    Special4 As Double
    vbint_t Special4 = 0;
//    Special5 As Double
    vbint_t Special5 = 0;
//    Special6 As Double
    // vbint_t Special6 = 0;

    // Information about the NPC's current unusual state (reordered for alignment purposes)
//    Effect2 As Double
    // double Effect2 = 0.0; // When Effect 4, Used to store a destination position, must be in double!

    // when Effect == NPCEFF_WARP, this was previously used to hold a destination position.
    // now the destination position is stored in SpecialX/Y, and this is an integer.
    vbint_t Effect2 = 0;
//    Effect As Integer 'For starting / stopping effects
    NPCEffect Effect = NPCEFF_NORMAL;
//    Effect3 As Integer
    // rarely used for warping NPCs (direction) and for NPCs being eaten (countdown timer initialized to 5)
    uint8_t Effect3 = 0;

    // Moderately important counter variables
//    Section As Integer 'what section of the level the NPC is in
    // never set to any non-section values
    uint8_t Section = 0;
//    Wet As Integer ' greater then 0 of the NPC is in water
    // counter for whether NPC is in water, set to 2 when detected, decremented otherwise
    uint8_t Wet = 0;
//    TailCD As Integer 'if greater then 0 the player can't hit with it's tail
    // set to values up to 12 when whipped / kicked, decremented otherwise
    uint8_t TailCD = 0;

//    Direction As Single 'The direction the NPC is walking
    // we have confirmed that this is never assigned a value other than 0, -1, or 1
    vbint_t Direction = 0;

//    Pinched1 As Integer  'getting smashed by a block
    // int Pinched1 = 0;
//    Pinched2 As Integer
    // int Pinched2 = 0;
//    Pinched3 As Integer
    // int Pinched3 = 0;
//    Pinched4 As Integer
    // int Pinched4 = 0;
//    MovingPinched As Integer 'required to be smashed
    // int MovingPinched = 0;

    // NEW: replaces above with bitfield
    PinchedInfo_t Pinched = PinchedInfo_t();

    // indexes to layers / events / text
//    TriggerActivate As String 'for events - triggers when NPC gets activated
    eventindex_t TriggerActivate = EVENT_NONE;
//    TriggerDeath As String 'triggers when NPC dies
    eventindex_t TriggerDeath = EVENT_NONE;
//    TriggerTalk As String 'triggers when you talk to the NPC
    eventindex_t TriggerTalk = EVENT_NONE;
//    TriggerLast As String 'trigger when this is the last NPC in a layer to die
    eventindex_t TriggerLast = EVENT_NONE;
//    Layer As String 'the layer name that the NPC is in
    layerindex_t Layer = LAYER_NONE;
//    AttLayer As String
    layerindex_t AttLayer = LAYER_NONE;
//    Text As String 'the text that is displayed when you talk to the NPC
    stringindex_t Text = STRINGINDEX_NONE;

//    Projectile As Boolean 'If the NPC is a projectile
    bool Projectile = false;
// EXTRA: Variant (previously Special7)
    uint8_t Variant = 0;

    // some misc variables
//    Slope As Integer 'the block that the NPC is on a slope with
    vbint_t Slope = 0;
//    Multiplier As Integer 'for upping the points the player recieves
    uint8_t Multiplier = 0;
//    standingOnPlayer As Integer 'If this NPC is standing on a player in the clown car
    uint8_t vehiclePlr = 0;
//    standingOnPlayerY As Integer
    vbint_t vehicleYOffset = 0;

    // Information about Generator state (Generator and GeneratorActive in bitfield at the bottom of the struct)
//    GeneratorDirection As Integer
    // valid values: 0, 1, 2, 3, 4
    // MOVED: now stored in the upper byte of Special3 for Generators
    // uint8_t GeneratorDirection = 0;
    inline uint8_t GeneratorDirection() const { return (uint8_t)(Special3 >> 8); }
//    GeneratorEffect As Integer
    // valid values: 0, 1, 2
    // MOVED: now stored in the lower byte of Special3 for Generators
    // uint8_t GeneratorEffect = 0;
    inline uint8_t GeneratorEffect() const { return (uint8_t)Special3; }
//    GeneratorTimeMax As Single
    // surprisingly, never stores any floating point variables. expressed in deci-seconds.
    // MOVED: now stored in Special4 for Generators
    // vbint_t GeneratorTimeMax = 0;
    inline vbint_t& GeneratorTimeMax() { return Special4; }
    inline const vbint_t& GeneratorTimeMax() const { return Special4; }
//    GeneratorTime As Single
    // surprisingly, only stores its own limit as a floating point variables. expressed in ticks.
    // MOVED: now stored in Special5 for Generators
    // vbint_t GeneratorTime = 0;
    inline vbint_t& GeneratorTime() { return Special5; }

//    FrameCount As Single 'The counter for incrementing the frames
    // was previously a float but this didn't accomplish anything
    vbint_t FrameCount = 0;

    // Misc floating-point variables
//    RealSpeedX As Single 'the real speed of the NPC
    numf_t RealSpeedX = 0;
//    BeltSpeed As Single 'The speed of the object this NPC is standing on
    numf_t BeltSpeed = 0;
//    oldAddBelt As Single
    numf_t oldAddBelt = 0;
//    Damage As Single
    // never set to a non-integer value, likely used a float for saturation arithemtic
    // (note: for NPCs whose DefaultType is a coin, this now stores the block type of a coin created by a coin switch)
    vbint_t Damage = 0;

    // Player reference variables
//    CantHurtPlayer As Integer
    // almost always set to a valid player index; very rarely set to an invalid index for NPCID_FLIPPED_RAINBOW_SHELL, only used to index the player array by NPCID_SWORDBEAM
    uint8_t CantHurtPlayer = 0;
//    BattleOwner As Integer 'Owner of the projectile
    // not only used in battle mode; almost always set to a valid player index, (see above)
    uint8_t BattleOwner = 0;
//    HoldingPlayer As Integer 'Who is holding it
    // only ever set to 0 or a player index
    uint8_t HoldingPlayer = 0;

    // some more misc counter variables
//    Immune As Integer 'time that the NPC is immune
    // set to values up to 100, decremented each frame
    uint8_t Immune = 0;
//    CantHurt As Integer 'Won't hurt the player
    // timer for how long the NPC will be harmless to a certain player, set to values up to 10000
    vbint_t CantHurt = 0;
//    WallDeath As Integer
    // tracks whether the NPC was activated in a wall (or is not in water, for fish). set to values between 0 and 10, used as a counter bounded at these values, sometimes very briefly 11.
    uint8_t WallDeath = 0;
//  NEW: which GFX expansion slot should the NPC use? Reserved for now
    uint8_t GFXSlot = 0;
//  NEW: what type of wings does the NPC currently have?
    WingBehaviors Wings = WING_NONE;

    // rarely used bools turned into bitfields
//    TurnAround As Boolean 'if the NPC needs to turn around
    bool TurnAround : 1;
//    TurnBackWipe As Boolean
    bool TurnBackWipe : 1;
//    Generator As Boolean 'for spawning new NPCs
    bool Generator : 1;
//    GeneratorActive As Boolean
    bool GeneratorActive : 1;
//    playerTemp As Boolean
    bool playerTemp : 1;
//    Legacy As Boolean 'Legacy Boss
    bool Legacy : 1;
//    Chat As Boolean 'for talking to the NPC
    bool Chat : 1;
    // (only set by NPCHit and used by KillNPC. Killed == 6 is never checked. Could certainly migrate to a KillCode modifier if a bit is needed.)
//    NoLavaSplash As Boolean 'true for no lava splash
    bool NoLavaSplash : 1;
//    Bouce As Boolean
    bool Bouce : 1;
//    DefaultStuck As Boolean
    bool DefaultStuck : 1;
//    RespawnDelay As Integeri
    // Used to respawn an NPC in Battle Mode but no longer a counter.
    // Effect2 is set to 65 * 30 (30s) on deactivation and decremented each frame while this flag is set.
    bool RespawnDelay : 1;
    // EXTRA (private to npc_activation.cpp): stores whether the NPC needs to use an event logic screen for activation
    bool _priv_force_canonical : 1;
    // EXTRA (private to npc_activation.cpp): stores whether the NPC has an activation event to hide self
    bool _priv_self_hide_event : 1;
    // EXTRA: used only for vines spawned by vine head
    bool DefaultLocationHeight_Force32 : 1;
//    EXTRA: does the tempBlock have its own tree entry?
    // To explain further: when an NPC is at the same location as its tempBlock,
    //   its temp block is *not* added to the temp block quadtree
    //   (saves time by only keeping one tree).
    // Whenever the NPC is moved and temp block isn't, they split and the temp block needs to be added to the tree if it has not already been added. (treeNPCSplitTempBlock)
    // Whenever the temp block is moved and the NPC isn't, they split and the temp block needs to be updated even if it is already added. (treeNPCUpdateTempBlock)
    // Whenever the temp block is moved *to* the NPC's position, they re-join, and the temp block is removed if it was added.
    bool tempBlockInTree : 1;
//    Stuck As Boolean 'the 'don't move' toggle. forces the NPC not to move
    bool Stuck : 1;
//    Shadow As Boolean 'if true turn the NPC black and allow it to pass through walls.  only used for a cheat code
    bool Shadow : 1;
//    Quicksand As Integer
    // counter for whether NPC is in quicksand, set to 2 when detected, decremented otherwise
    uint8_t Quicksand : 2;

//  NEW: what type of wing behavior should the NPC normally have?
    WingBehaviors DefaultWings = WING_NONE;
//'the default values are used when De-Activating an NPC when it goes on screen
//    DefaultDirection As Single
    // changed to int8_t, only ever holds values -1, 0, and 1
    int8_t DefaultDirection = 0;
//    DefaultType As Integer
    NPCID DefaultType = NPCID(0);
//    DefaultSpecial As Integer
    vbint_t DefaultSpecial = 0;
//    DefaultLocation As Location
    num_t DefaultLocationX = 0_n;
    num_t DefaultLocationY = 0_n;

    // obsolete and removed fields
//    PinchCount As Integer 'obsolete
    // int PinchCount = 0;    // unused since SMBX64, removed
//    Pinched As Boolean 'obsolete
    // bool Pinched = false;    // unused since SMBX64, removed
//    PinchedDirection As Integer 'obsolete
    // int PinchedDirection = 0;    // unused since SMBX64, removed
//    NetTimeout As Integer 'for online
    // int NetTimeout = 0;    // unused since SMBX64, removed
//    Settings As Integer
    // int Settings = 0;    // unused since SMBX64, removed
    // was previously a persistent variable, but was set to a constant value at the start of UpdateNPCs and never read outside of that routine
//    onWall As Boolean
    // bool onWall : 1;
//    DefaultSpecial2 As Integer
    // was only used by NPCID_MAGIC_DOOR and friends, which now use Variant
    // vbint_t DefaultSpecial2 = 0;

//    Block As Integer 'Used when a P-Switch turns a block into a coint
    // Now stored in Damage which is unused for coins
    inline vbint_t coinSwitchBlockType() const;

//End Type

    // reset location to default
    void ResetLocation();
    const NPCTraits_t* operator->() const;

    NPC_t() : TurnAround(false), TurnBackWipe(false),
        Generator(false), GeneratorActive(false),
        playerTemp(false), Legacy(false), Chat(false), NoLavaSplash(false),
        Bouce(false), DefaultStuck(false), RespawnDelay(false),
        _priv_force_canonical(false),
        _priv_self_hide_event(false),
        DefaultLocationHeight_Force32(false),
        tempBlockInTree(false),
        Stuck(false),
        Shadow(false),
        Quicksand(0) {}

};

//Public Type Player              'The player data type.
struct Player_t
{
//    DoubleJump As Boolean
    bool DoubleJump = false;
//    FlySparks As Boolean
    bool FlySparks = false;
//    Driving As Boolean
    bool Driving = false;
//    Quicksand As Integer
    vbint_t Quicksand = 0;
//    Bombs As Integer
    vbint_t Bombs = 0;
//    Slippy As Boolean
    bool Slippy = false;
//    Fairy As Boolean
    bool Fairy = false;
//    FairyCD As Integer
    vbint_t FairyCD = 0;
//    FairyTime As Integer
    vbint_t FairyTime = 0;
//    HasKey As Boolean
    bool HasKey = false;
//    SwordPoke As Integer
    vbint_t SwordPoke = 0;
//    Hearts As Integer
    vbint_t Hearts = 0;
//    CanFloat As Boolean
    bool CanFloat = false;
//    FloatRelease As Boolean
    bool FloatRelease = false;
//    FloatTime As Integer
    vbint_t FloatTime = 0;
//    FloatSpeed As Single
    numf_t FloatSpeed = 0;
//    FloatDir As Integer
    vbint_t FloatDir = 0;
//    GrabTime As Integer 'how long the player has been trying to grab an npc from above
    vbint_t GrabTime = 0;
//    GrabSpeed As Single
    numf_t GrabSpeed = 0;
//    VineNPC As Double 'the NPC that the player is climbing
    vbint_t VineNPC = 0;
//  EXTRA:  Fence BGO
    vbint_t VineBGO = 0;
//    Wet As Integer 'weather or not the player is under water
    vbint_t Wet = 0;
//    WetFrame As Boolean 'true if the play should be swimming
    bool WetFrame = false;
//    SwimCount As Integer 'cool down between swim strokes
    vbint_t SwimCount = 0;
//    NoGravity As Integer
    vbint_t NoGravity = 0;
//    Slide As Boolean 'true if the player is sliding
    bool Slide = false;
//    SlideKill As Boolean 'true if the player is sliding fast enough to kill an NPC
    bool SlideKill = false;
//    Vine As Integer 'greater then 0 if the player is climbing
    vbint_t Vine = 0;
//    NoShellKick As Integer 'dont kick a shell
    // never set in SMBX 1.3, was originally used to improve shell-surf
    // int NoShellKick = 0;
//    ShellSurf As Boolean 'true if surfing a shell
    bool ShellSurf = false;
    // is currently a rolling shell/ball
    bool Rolling = false;
//    StateNPC As Integer
    NPCID StateNPC = NPCID(0);
//    Slope As Integer 'the block that the player is standing on when on a slope
    vbint_t Slope = 0;
//    Stoned As Boolean 'true of a statue form (tanooki suit)
    bool Stoned = false;
    // is currently swimming with aquatic/polar power
    bool AquaticSwim = false;
//    StonedCD As Integer 'delay before going back in to stone form
    vbint_t StonedCD = 0;
//    StonedTime As Integer 'how long the player can remain as a statue
    vbint_t StonedTime = 0;
//    SpinJump As Boolean 'true if spin jumping
    bool SpinJump = false;
//    SpinFrame As Integer 'frame for spinning
    vbint_t SpinFrame = 0;
//    SpinFireDir As Integer 'for shooting fireballs while spin jumping
    vbint_t SpinFireDir = 0;
//    Multiplier As Integer 'for score increase for multiple hops
    uint8_t Multiplier = 0;
//    SlideCounter As Integer 'for creating the dust effect when sliding
    vbint_t SlideCounter = 0;
//    ShowWarp As Integer
    vbint_t ShowWarp = 0;
//    ForceHold As Integer  'force the player to hold an item for a specific amount of time
    vbint_t ForceHold = 0;

    // pound state converted to bitfield
//    GroundPound As Boolean 'for purple yoshi pound
    bool GroundPound : 1;
//    GroundPound2 As Boolean 'for purple yoshi pound
    bool GroundPound2 : 1;
//    CanPound As Boolean 'for purple yoshi pound
    bool CanPound : 1;
//    NEW: AltRunRelease As Boolean 'has the player not been holding Alt Run?
    bool AltRunRelease : 1;
//    DuckRelease As Boolean
    bool DuckRelease : 1;

    // Can the player NOT currently wall-jump because the wall is slippery?
    bool SlippyWall : 1;
    // Is the player's current jump a wall-jump?
    bool JumpOffWall : 1;

//'yoshi powers
//    YoshiYellow As Boolean
    bool YoshiYellow = false;
//    YoshiBlue As Boolean
    bool YoshiBlue = false;
//    YoshiRed As Boolean
    bool YoshiRed = false;
//    YoshiWingsFrame As Integer
    vbint_t YoshiWingsFrame = 0;
//    YoshiWingsFrameCount As Integer
    vbint_t YoshiWingsFrameCount = 0;
//'yoshi graphic display
//    YoshiTX As Integer
    vbint_t YoshiTX = 0;
//    YoshiTY As Integer
    vbint_t YoshiTY = 0;
//    YoshiTFrame As Integer
    vbint_t YoshiTFrame = 0;
//    YoshiTFrameCount As Integer
    vbint_t YoshiTFrameCount = 0;
//    YoshiBX As Integer
    vbint_t YoshiBX = 0;
//    YoshiBY As Integer
    vbint_t YoshiBY = 0;
//    YoshiBFrame As Integer
    vbint_t YoshiBFrame = 0;
//    YoshiBFrameCount As Integer
    vbint_t YoshiBFrameCount = 0;
//    YoshiTongue As Location
    SpeedlessLocation_t YoshiTongue;
//    YoshiTongueX As Single
    // float YoshiTongueX = 0.0f;
//    YoshiTongueLength As Integer 'length of yoshi's tongue
    vbint_t YoshiTongueLength = 0;
//    YoshiTonugeBool As Boolean
    bool YoshiTonugeBool = false;
//    YoshiNPC As Integer 'the NPC that is in yoshi's mouth
    vbint_t YoshiNPC = 0;
//    YoshiPlayer As Integer 'the player that is in yoshi's mouth
    vbint_t YoshiPlayer = 0;
//    Dismount As Integer 'delay before you can remount
    vbint_t Dismount = 0;
//    NoPlayerCol As Integer
    // vbint_t NoPlayerCol = 0;
//    Location As Location 'collision detection info
    Location_t Location;
//    Character As Integer 'luigi or mario
    vbint_t Character = 0;
//    Controls As Controls 'players controls
    Controls_t Controls;
//    Direction As Integer 'the way the player is facing
    vbint_t Direction = 0;
//    Mount As Integer '1 for boot, 2 for clown car, 3 for yoshi
    vbint_t Mount = 0;
//    MountType As Integer 'for different types of mounts. blue yoshi, red yoshi, etc
    vbint_t MountType = 0;
//    MountSpecial As Integer
    vbint_t MountSpecial = 0;
//    MountOffsetY As Integer
    vbint_t MountOffsetY = 0;
//    MountFrame As Integer 'GFX frame for the player's mount
    vbint_t MountFrame = 0;
//    State As Integer '1 for small mario, 2 for super, 3 for fire, 4 for racoon, 5 for tanooki, 6 for hammer
    vbint_t State = 0;
//    Frame As Integer
    vbint_t Frame = 0;
//    FrameCount As Single
    vbint_t FrameCount = 0;
//    Jump As Integer 'how long the player can jump for
    vbint_t Jump = 0;
//    CanJump As Boolean 'true if the player can jump
    bool CanJump = false;
//    CanAltJump As Boolean 'true if the player can alt jump
    bool CanAltJump = false;
//    Effect As Integer 'for various effects like shrinking/growing/warping
    PlayerEffect Effect = PLREFF_NORMAL;
//    Effect2 As Double 'counter for the effects (was double)
    vbint_t Effect2 = 0;
//    NEW: this previously used the same storage as Effect2
    num_t RespawnY = 0_n;
//    Duck As Boolean 'true if ducking
    bool Duck = false;
//    DropRelease As Boolean
    bool DropRelease = false;
//    StandUp As Boolean 'aid with collision detection after ducking
    bool StandUp = false;
//    StandUp2 As Boolean
    bool StandUp2 = false;
//    Bumped As Boolean 'true if hit by another player
    bool Bumped = false;
//    Bumped2 As Single
    vbint_t Bumped2 = 0;
//    Dead As Boolean 'true if dead
    bool Dead = false;
//    TimeToLive As Integer 'for returning to the other play after dying
    vbint_t TimeToLive = 0;
//    Immune As Integer 'greater then 0 if immune, this is a counter
    vbint_t Immune = 0;
//    Immune2 As Boolean 'makes the player blink
    bool Immune2 = false;
//    ForceHitSpot3 As Boolean 'force hitspot 3 for collision detection
    bool ForceHitSpot3 = false;

//'for getting smashed by a block
//    Pinched1 As Integer
    // int Pinched1 = 0;
//    Pinched2 As Integer
    // int Pinched2 = 0;
//    Pinched3 As Integer
    // int Pinched3 = 0;
//    Pinched4 As Integer
    // int Pinched4 = 0;
//    NPCPinched As Integer 'must be > 0 for the player to get crushed
    // int NPCPinched = 0;

    PinchedInfo_t Pinched = PinchedInfo_t();

//    m2Speed As Single
    // unused since SMBX 1.3
    // float m2Speed = 0.0f;
//    HoldingNPC As Integer 'What NPC is being held
    vbint_t HoldingNPC = 0;
//    CanGrabNPCs As Boolean 'If the player can grab NPCs
    bool CanGrabNPCs = false;
//    HeldBonus As Integer 'the NPC that is in the player's container
    NPCID HeldBonus = NPCID(0);
//    Section As Integer 'What section of the level the player is in
    vbint_t Section = 0;
//    WarpCD As Integer 'delay before allowing the player to warp again
    vbint_t WarpCD = 0;
//    Warp As Integer 'the warp the player is using
    vbint_t Warp = 0;
// EXTRA: Is the backward warp mode
    bool WarpBackward = false;
// EXTRA: True if shooted from the cannon
    bool WarpShooted = false;
//    FireBallCD As Integer 'How long the player has to wait before he can shoot again
    vbint_t FireBallCD = 0;
//    FireBallCD2 As Integer 'How long the player has to wait before he can shoot again
    vbint_t FireBallCD2 = 0;
//    TailCount As Integer 'Used for the tail swipe
    vbint_t TailCount = 0;
//    RunCount As Single 'To find how long the player has ran for
    // was previously incremented 1.0 per running frame and decremented 0.3 per slow frame
    // now is incremented 10 per running frame and decremented 3 per slow frame
    vbint_t RunCount = 0;
//    CanFly As Boolean 'If the player can fly
    bool CanFly = false;
//    CanFly2 As Boolean
    bool CanFly2 = false;
//    FlyCount As Integer 'length of time the player can fly
    vbint_t FlyCount = 0;
//    RunRelease As Boolean 'The player let go of run and pressed again
    bool RunRelease = false;
//    JumpRelease As Boolean 'The player let go of run and pressed again
    bool JumpRelease = false;
//    StandingOnNPC As Integer 'The NPC the player is standing on
    vbint_t StandingOnNPC = 0;
//    StandingOnTempNPC As Integer 'The NPC the player is standing on
    vbint_t StandingOnVehiclePlr = 0;
//    UnStart As Boolean 'Player let go of the start button
    bool UnStart = false;
//    mountBump As Single 'Player hit something while in a mount
    numf_t mountBump = 0.0_nf;
//    SpeedFixY As Single
    // unused since SMBX 1.3
    // float SpeedFixY = 0.0f;
//End Type

    // NEW: currently in a maze zone PhysEnv? (stores physenv index)
    vbint_t CurMazeZone = 0;
    // NEW: status field for maze zone (stores current direction and clearance to leave)
    uint8_t MazeZoneStatus = 0;

    Player_t() : GroundPound(false), GroundPound2(false), CanPound(false), AltRunRelease(false), DuckRelease(false), SlippyWall(false), JumpOffWall(false) {}
};

//Public Type Background  'Background objects
struct Background_t
{
//    Type As Integer
    vbint_t Type = 0;
//    Hidden As Boolean
    bool Hidden = false;
//    Layer As String
    layerindex_t Layer = LAYER_NONE;
//    EXTRA: sort priority for BGO (NOT a draw plane itself, a BGO-only format used for sorting and determining draw plane)
    uint8_t SortPriority = 0;
//    Location As Location
    SpeedlessLocation_t Location;

    //! SortPriority at which PLANE_LVL_BGO_NORM, PLANE_LVL_3D_MAIN, PLANE_LVL_BGO_FG, and PLANE_LVL_BGO_TOP start
    static constexpr uint8_t PRI_NORM_START = 0x30;
    static constexpr uint8_t PRI_BLK_START = 0xA0;
    static constexpr uint8_t PRI_FG_START = 0xC0;
    static constexpr uint8_t PRI_TOP_START = 0xF8;

    // all defined in sorting.cpp:

    //! checks if a custom sorting layer is set; returns -2, -1, +1, or +2 if so, 0 if not
    int GetCustomLayer() const;
    //! returns custom sorting offset (a number between -3 and +3)
    int GetCustomOffset() const;
    //! sets custom sorting layer and offset bits and updates sort priority
    void SetSortPriority(int layer, int offset);
    //! updates SortPriority based on current type, custom layer, and custom offset
    void UpdateSortPriority();

//End Type
};

//Public Type Water
struct Water_t
{
//    Location As Location
    SpeedlessLocation_t Location;
//    Buoy As Single 'not used
    // float Buoy = 0.0f;
//    Quicksand As Boolean
    PHYSID Type = PHYSID_WATER;
//    Layer As String
    layerindex_t Layer = LAYER_NONE;
//    Hidden As Boolean
    bool Hidden = false;
//End Type
};

//Public Type Block   'Blocks
struct Block_t
{
//    Location As Location
    Location_t Location;
//! EXTRA: temporary workaround: is it a smashable block of type 90 (normally not smashable)? (previously Special2)
    bool forceSmashable = false;
//    Slippy As Boolean
    bool Slippy = false;
//    RespawnDelay As Integer
    // Newly re-used to represent which screens can still hit the block (outside of Battle Mode)
    uint16_t RespawnDelay_ScreensLeft = 0;
//    RapidHit As Integer
    vbint_t RapidHit = 0;
//    DefaultType As Integer
    vbint_t DefaultType = 0;
//    DefaultSpecial As Integer
    vbint_t DefaultSpecial = 0;
//'for event triggers
//    TriggerHit As String
    eventindex_t TriggerHit = EVENT_NONE;
//    TriggerDeath As String
    eventindex_t TriggerDeath = EVENT_NONE;
//    TriggerLast As String
    eventindex_t TriggerLast = EVENT_NONE;
//    Layer As String
    layerindex_t Layer = LAYER_NONE;
//    NPC As Integer 'when a coin is turned into a block after the p switch is hit
    NPCID coinSwitchNpcType = NPCID(0);
//    Type As Integer 'the block's type
    vbint_t Type = 0;
//    Special As Integer 'what is in the block?
    vbint_t Special = 0;
//'for the shake effect after hitting ablock
//    ShakeY As Integer
//    ShakeY2 As Integer
//    ShakeY3 As Integer
    uint8_t ShakeCounter = 0;
    int8_t ShakeOffset = 0;
//    Kill As Boolean 'if true the game will destroy the block
    // NEW: can be set to 9 in which case the game will ACTUALLY destroy it
    uint8_t Kill = false;
//    Invis As Boolean 'for invisible blocks
    bool Invis = false;
//    Hidden As Boolean
    bool Hidden = false;
//    IsPlayer As Integer 'for the clown car
    uint8_t tempBlockVehiclePlr = 0;
//    IsNPC As Integer 'the type of NPC the block is
    NPCID tempBlockNpcType = NPCID(0);
//    standingOnPlayerY As Integer 'when standing on a player in the clown car
    vbint_t tempBlockVehicleYOffset = 0;
//    noProjClipping As Boolean
    // bool noProjClipping = false;
//    IsReally As Integer 'the NPC that is this block
    vbint_t tempBlockNpcIdx = 0;

    inline bool tempBlockNoProjClipping() const;

public:

// EXTRA: Indicate the fact that block was resized by a hit
#ifdef LOW_MEM

    inline void setShrinkResized() {}

    inline bool getShrinkResized() const
    {
        // Because the initial block width is stored as an integer, the only way the width could be 31.9 is if it was shrink-resized from 32.
        // The block location width isn't set to a non-integer anywhere else in the game, so this is safe.
        // This is a heuristic and has a small CPU tradeoff, but it saves memory.
        // If it fails in some case, we can switch to the below implementation, or we could use this implementation only when LOW_MEM is set.
        return Location.Width == 31.9_n;
    }

#else

private:
    bool m_wasShrinkResized = false;

public:
    inline void setShrinkResized()
    {
        m_wasShrinkResized = true;
    }

    inline bool getShrinkResized()
    {
        return m_wasShrinkResized;
    }

#endif

//End Type
};

//Public Type Effect  'Special effects
struct Effect_t
{
//    Location As Location
    Location_t Location;
//    Type As Integer
    EFFID Type = EFFID(0);
//    Frame As Integer
    vbint_t Frame = 0;
//    FrameCount As Single
    vbint_t FrameCount = 0;
//    Life As Integer 'timer before the effect disappears
    vbint_t Life = 0;
//    NewNpc As Integer 'when an effect should create and NPC, such as Yoshi (NOTE: occasionally abused, so not turning into an NPCID)
    vbint_t NewNpc = 0;
// EXTRA: New NPC's special value
    uint8_t NewNpcSpecial = 0;
//    Shadow As Boolean 'for a black effect set to true
    bool Shadow = false;
//End Type
};

//Public Type vScreen 'Screen controls
#include "screen.h"

//! NEW: information about available Stars and obtained / available Medals for a level
struct LevelSaveInfo_t
{
    // INTEGERS
    uint8_t  max_stars = 0;
    uint8_t  max_medals = 255; // invalid, maximum is 8

    // BITMASKS, max medals is 8
    uint8_t medals_got = 0;
    uint8_t medals_best = 0;

    // BITMASK
    uint16_t exits_got = 0;

    inline bool inited() const
    {
        return max_medals != 255;
    }
};

//! NEW: stores LevelSaveInfo for levels without WorldLevels
struct LevelWarpSaveEntry_t
{
    std::string levelPath;
    LevelSaveInfo_t save_info;
};

//Public Type WorldLevel 'the type for levels on the world map
struct WorldLevel_t
{
//    Location As Location
    TinyLocation_t Location;

//    FileName As String 'level's file
    std::string FileName;
//    LevelName As String 'The name of the level
    std::string LevelName;

//    LevelExit(1 To 4) As Integer ' For the direction each type of exit opens the path
    RangeArrI<vbint_t, 1, 4, 0> LevelExit;

//    Type As Integer
    vbint_t Type = 0;
//    StartWarp As Integer 'If the level should start with a player exiting a warp
    vbint_t StartWarp = 0;

//    Active As Boolean
    bool Active = false;
//    Path As Boolean 'for drawing a small path background
    bool Path = false;
//    Path2 As Boolean 'big path background
    bool Path2 = false;
//    Start As Boolean 'true if the game starts here
    bool Start = false;

//    Visible As Boolean 'true if it should be shown on the map
    bool Visible = false;

//    WarpX As Double 'for warping to another location on the world map
    int32_t WarpX = 0;
//    WarpY As Double
    int32_t WarpY = 0;

//End Type

    // int64_t Z = 0;

// Display number of stars (if available)
    int8_t starsShowPolicy = -1;
    uint8_t curStars = 0;

    //! NEW: info about collected / available medals / stars (replaces maxStars)
    LevelSaveInfo_t save_info;

    // NEW: returns graphical location extent (based on whether GFXLevelBig is set)
    //   defined in graphics.cpp
    Location_t LocationGFX();

    // NEW: returns location extent, including big background paths, for onscreen checks
    //   defined in graphics.cpp
    Location_t LocationOnscreen();
};

//Public Type Warp 'warps such as pipes and doors
struct Warp_t
{
//    Entrance As Location 'location of warp entrance
    SpeedlessLocation_t Entrance;
//    Exit As Location 'location of warp exit
    SpeedlessLocation_t Exit;
//    Locked As Boolean 'requires a key NPC
    bool Locked = false;
//    WarpNPC As Boolean 'allows NPC through the warp
    bool WarpNPC = false;
//    NoYoshi As Boolean 'don't allow yoshi
    bool NoYoshi = false;
//    Layer As String 'the name of the layer
    layerindex_t Layer = LAYER_NONE;
//    Hidden As Boolean 'if the layer is hidden
    bool Hidden = false;
//    PlacedEnt As Boolean 'for the editor, flags the entranced as placed
    bool PlacedEnt = false;
//    PlacedExit As Boolean
    bool PlacedExit = false;
//    Stars As Integer 'number of stars required to enter
    vbint_t Stars = 0;
//    Effect As Integer 'style of warp. door/
    vbint_t Effect = 0;
//    level As String 'filename of the level it should warp to
    stringindex_t level = STRINGINDEX_NONE;
//    LevelWarp As Integer
    vbint_t LevelWarp = 0;
//    LevelEnt As Boolean 'this warp can't be used if set to true (this is for level entrances)
    bool LevelEnt = false;
//    Direction As Integer 'direction of the entrance for pipe style warps
    int8_t Direction = 0;
//    Direction2 As Integer 'direction of the exit
    int8_t Direction2 = 0;
//    MapWarp As Boolean
    bool MapWarp = false;
//    MapX As Integer
    vbint_t MapX = 0;
//    MapY As Integer
    vbint_t MapY = 0;
//    curStars As Integer
    uint8_t curStars = 0;
//    maxStars As Integer
    //! NEW: index into either LevelWarpSaveEntries (<0x7fff) or WorldLevel (>0x8000)
    uint16_t save_info_idx = 0x8000;
//EXTRA:
    bool twoWay = false;
    bool noPrintStars = false;
    bool noEntranceScene = false;
    bool cannonExit = false;
    vbint_t cannonExitSpeed = 10;
    bool stoodRequired = false; // Require player stood on the ground to enter this warp
    eventindex_t eventEnter = EVENT_NONE;
    eventindex_t eventExit = EVENT_NONE;
    stringindex_t StarsMsg = STRINGINDEX_NONE;
    vbint_t transitEffect = 0;
//End Type

    //! NEW: get the warp's LevelSaveInfo_t (based on save_info_idx)
    inline const LevelSaveInfo_t save_info() const;
};

//Public Type Tile 'Tiles for the World
struct Tile_t
{
//    Location As Location
    TinyLocation_t Location;
//    Type As Integer
    vbint_t Type = 0;
//End Type

    bool Active = true;

    // int64_t Z = 0;
};

//Public Type Scene 'World Scenery
struct Scene_t
{
//    Location As Location
    TinyLocation_t Location;
//    Type As Integer
    vbint_t Type = 0;
//    Active As Boolean 'if false this won't be shown. used for paths that become available on a scene
    bool Active = false;
//End Type

    // int64_t Z = 0;
};

//Public Type WorldPath 'World Paths
struct WorldPath_t
{
//    Location As Location
    TinyLocation_t Location;
//    Active As Boolean
    bool Active = false;
//    Type As Integer
    vbint_t Type = 0;
//End Type

    // int64_t Z = 0;
};

//Public Type WorldMusic 'World Music
struct WorldMusic_t
{
//    Location As Location
    TinyLocation_t Location;
//    Type As Integer
    vbint_t Type = 0;
//    EXTRA: Custom Music
    stringindex_t MusicFile = STRINGINDEX_NONE;
//End Type

    bool Active = true;

    // int64_t Z = 0;
};

//! NEW: a camera zone for the world map
struct WorldArea_t
{
    TinyLocation_t Location;
};

//Public Type EditorCursor 'The editor's cursor
struct EditorCursor_t
{
//    X As Single
    int X = -50;
//    Y As Single
    int Y = -50;
//    SelectedMode As Integer 'cursor mode. eraser/npc/block/background

    // class of object (uses same enum as Mode)
    int InteractMode = 0;
    // NEW: modifiers for type of interaction
    int InteractFlags = 0;
    // index of currently interacted / highlighted object
    int InteractIndex = 0;
    // coordinates where interaction began
    int InteractX = 0;
    int InteractY = 0;

//    Location As Location
    Location_t Location;
//    Layer As String 'current layer
    layerindex_t Layer = LAYER_NONE;
//    Mode As Integer
    int Mode = 0;
//  New, used to represent warp entrance/exit, level settings submodes, and erase mode
//  (erase mode: 0 for unset, positive number for each type of item, negative number for *everything*)
    int SubMode = 0;
//    Block As Block
    Block_t Block;
//    Water As Water
    Water_t Water;
//    Background As Background
    Background_t Background;
//    NPC As NPC
    NPC_t NPC;
//    Warp As Warp
    Warp_t Warp;
//    Tile As Tile
    Tile_t Tile;
//    Scene As Scene
    Scene_t Scene;
//    WorldLevel As WorldLevel
    WorldLevel_t WorldLevel;
//    WorldPath As WorldPath
    WorldPath_t WorldPath;
//    WorldMusic As WorldMusic
    WorldMusic_t WorldMusic;
//End Type

//! NEW
    WorldArea_t WorldArea;

    // clears any strings of objects stored by the world cursor
    void ClearStrings();
};

//Public Type WorldPlayer 'the players variables on the world map
struct WorldPlayer_t
{
//    Location As Location
    TinyLocation_t Location;
//    Type As Integer
    int Type = 0;
//    Frame As Integer
    int Frame = 0;
//    Frame2 As Integer
    int Frame2 = 0;
//    Move As Integer
    int Move = 0;
//    Move2 As Integer
    int Move2 = 0;
//    Move3 As Boolean
    int Move3 = 0;
// EXTRA: last move direction
    int LastMove = 0;
// EXTRA: current world map section
    int Section = 0;
//    LevelName As String
    // std::string LevelName;
    //! NEW: index to player's current WorldLevel, 0 if none. (Replaces LevelName and stars.)
    vbint_t LevelIndex;
//End Type
};

//Public Type Layer
//moved into layers.h

//Public Type CreditLine
struct CreditLine_t
{
//    Location As Location
    IntegerLocation_t Location;
//    Text As String
    stringindex_t Text = STRINGINDEX_NONE;
//End Type
};

//Public ScreenShake As Integer
//extern int ScreenShake; // REPLACED with static variables at the update_gfx.cpp
// TODO: Make it have multiple checkpoints and assign each one with different NPCs,
// last one should resume player at given position
//Public Checkpoint As String 'the filename of the level the player has a checkpoint in
extern std::string Checkpoint;

struct Checkpoint_t
{
    int id = 0;
};
// List of taken checkpoints, spawn player at last of them
extern std::vector<Checkpoint_t> CheckpointsList;

//! List of stars / medal info entries for the levels NOT on the world map
extern std::vector<LevelWarpSaveEntry_t> LevelWarpSaveEntries;

//Public MagicHand As Boolean 'true if playing a level in the editor while not in fullscreen mode
extern bool MagicHand;
//Public testPlayer(1 To 2) As Player 'test level player settings
extern RangeArr<Player_t, 1, maxLocalPlayers> testPlayer;
//Public ClearBuffer As Boolean 'true to black the backbuffer
extern bool ClearBuffer;
//Public numLocked As Integer
extern int numLocked;


// replaced with g_config.fullscreen
//Public resChanged As Boolean 'true if in fullscreen mode
// extern bool resChanged;


// NEW: start warp for a test level
extern int16_t testStartWarp;

// These have been partially moved into the Controls namespace
// and partially moved to g_pollingInput (declared and defined in main/menu_controls.*)

//Public inputKey As Integer 'for setting the players controls
// extern int inputKey;
//Public getNewKeyboard As Boolean 'true if setting keyboard controls
// extern bool getNewKeyboard;
//Public getNewJoystick As Boolean
// extern bool getNewJoystick;
//Public lastJoyButton As Integer
// extern KM_Key lastJoyButton;

// moved into game_main.h / game_loop.cpp
//Public GamePaused As Boolean 'true if the game is paused
// extern PauseCode GamePaused;

extern std::string MessageTitle;
enum MessageType
{
    // Has no title
    MESSAGE_TYPE_NORMAL = 0,
    // Has title, normal colour
    MESSAGE_TYPE_SYS_INFO,
    // Has title, yellow colour
    MESSAGE_TYPE_SYS_WARNING,
    // Has title, red colour
    MESSAGE_TYPE_SYS_ERROR,
    // Has title, red colour, game will quit after closing this
    MESSAGE_TYPE_SYS_FATAL_ASSERT,
};
extern MessageType g_MessageType;

//Public MessageText As String 'when talking to an npc
extern std::string MessageText;

// moved to menu_main.h

//Public NumSelectWorld As Integer
// extern int NumSelectWorld;
//Public SelectWorld(1 To 100) As SelectWorld
// struct SelectWorld_t;
//extern RangeArr<SelectWorld_t, 1, maxSelectWorlds> SelectWorld;
// extern std::vector<SelectWorld_t> SelectWorld;

extern std::string g_recentAssetPack;
extern std::string g_recentWorld1p;
extern std::string g_recentWorld2p;
extern std::string g_recentWorldEditor;

// Absolute path to the level file or directory that contains them. Will be saved at gamesave
extern std::string g_recentWorldIntro;
// Absolute path to the outro level file. Will NOT be saved at gamesave, and will reset on world clear.
extern std::string g_recentWorldOutro;
// replaced with g_config.show_fps
//Public ShowFPS As Boolean
// extern bool ShowFPS;
//Public PrintFPS As Double
extern int PrintFPS;
extern bool g_VanillaCam;

// moved to "screen.h"
//Public vScreen(0 To 2) As vScreen 'Sets up the players screens
// extern RangeArr<vScreen_t, 0, 2> vScreen;
//Public ScreenType As Integer 'The screen/view type
// extern int ScreenType;
//Public DScreenType As Integer 'The dynamic screen setup
// extern int DScreenType;

//Public LevelEditor As Boolean 'if true, load the editor
extern bool LevelEditor;
//Public WorldEditor As Boolean
extern bool WorldEditor;
//Public PlayerStart(1 To 2) As Location
extern RangeArr<PlayerStart_t, 1, 2> PlayerStart;

// NEW: force selected characters to be used (ignore the blockCharacter array)
extern bool g_forceCharacter;

//Public blockCharacter(0 To 20) As Boolean
extern RangeArrI<bool, 0, 20, false> blockCharacter;

struct SelectWorld_t; // moved to main_menu.h

//Public OwedMount(0 To maxPlayers) As Integer 'when a yoshi/boot is taken from the player this returns after going back to the world map
extern RangeArrI<vbint_t, 0, maxPlayers, 0> OwedMount;
//Public OwedMountType(0 To maxPlayers) As Integer
extern RangeArrI<vbint_t, 0, maxPlayers, 0> OwedMountType;
//EXTRA: set this flag once modern autoscroll used, otherwise, legacy will be used
extern bool AutoUseModern;
//Public AutoX(0 To maxSections) As Single 'for autoscroll
extern RangeArr<numf_t, 0, maxSections> AutoX;
//Public AutoY(0 To maxSections) As Single 'for autoscroll
extern RangeArr<numf_t, 0, maxSections> AutoY;
//Public numStars As Integer 'the number of stars the player has
extern int numStars;

//Public Type Star 'keeps track of where there player got the stars from
struct Star_t
{
//    level As String
    std::string level;
//    Section As Integer
    int Section = 0;
//End Type
};

//Public nPlay As nPlay ' for online stuff
//Public Water(0 To maxWater) As Water
extern RangeArr<Water_t, 0, maxWater> Water;
DECLREF_T(Water);
//Public numWater As Integer 'number of water
extern int numWater;
//Public Star(1 To 1000) As Star
extern std::vector<Star_t> Star;
//Public GoToLevel As String
extern std::string GoToLevel;
//! EXTRA: Hide entrance screen
extern bool GoToLevelNoGameThing;
//Public StartLevel As String 'start level for an episode
extern std::string StartLevel;
//Public NoMap As Boolean 'episode has no world map
extern bool NoMap;
//Public RestartLevel As Boolean 'restart the level on death
extern bool RestartLevel;
//! Per-level stars showing policy
extern int WorldStarsShowPolicy;
//Public LevelChop(0 To maxSections) As Single 'for drawing backgrounds when the level has been shrunk
// extern float LevelChop[maxSections + 1];

//'collision detection optimization. creates a table of contents for blocks
// removed in favor of new block quadtree

//Public Const FLBlocks As Long = 8000
// const int64_t FLBlocks = 10000; // moved to global_constants.h and changed back to 8000
//Public FirstBlock(-FLBlocks To FLBlocks) As Integer
// extern RangeArr<int, -FLBlocks, FLBlocks> FirstBlock;
//Public LastBlock(-FLBlocks To FLBlocks) As Integer
// extern RangeArr<int, -FLBlocks, FLBlocks> LastBlock;

//Public MidBackground As Integer 'for drawing backgrounds
extern int MidBackground;
//Public LastBackground As Integer 'last backgrounds to be drawn
extern int LastBackground;
//Public iBlocks As Integer 'blocks that are doing something. this keeps the number of interesting blocks
extern int iBlocks;
//Public iBlock(0 To maxBlocks) As Integer 'references a block #
extern RangeArrI<vbint_t, 0, maxBlocks, 0> iBlock;
//Public numTiles As Integer 'number of map tiles
extern int numTiles;
//Public numScenes As Integer 'number of scense
extern int numScenes;
//Public CustomMusic(0 To maxSections) As String 'section's custom music
extern RangeArr<std::string, 0, maxSections> CustomMusic;
//EXTRA: Max count of used sections
extern int numSections;
//Public level(0 To maxSections) As Location 'sections
extern RangeArr<SpeedlessLocation_t, 0, maxSections> level;
//Public LevelWrap(0 To maxSections) As Boolean 'Wrap around the level
extern RangeArrI<bool, 0, maxSections, false> LevelWrap;
//EXTRA: Wrap vertically around the level
extern RangeArrI<bool, 0, maxSections, false> LevelVWrap;
//Public OffScreenExit(0 To maxSections) As Boolean 'walk offscreen to end the level
extern RangeArrI<bool, 0, maxSections, false> OffScreenExit;
//Public bgMusic(0 To maxSections) As Integer 'music
extern RangeArrI<vbint_t, 0, maxSections, 0> bgMusic;
//Public bgMusicREAL(0 To maxSections) As Integer 'default music
extern RangeArrI<vbint_t, 0, maxSections, 0> bgMusicREAL;
//Public Background2REAL(0 To maxSections) As Integer 'background
extern RangeArrI<vbint_t, 0, maxSections, 0> Background2REAL;
//Public LevelREAL(0 To maxSections) As Location 'default background
extern RangeArr<IntegerLocation_t, 0, maxSections> LevelREAL;
//Public curMusic As Integer 'current music playing
extern int curMusic;
//Public bgColor(0 To maxSections) As Long 'obsolete
// extern RangeArrI<long, 0, maxSections, 0> bgColor;    // unused since SMBX64, removed
//Public Background2(0 To maxSections) As Integer 'level background
extern RangeArrI<vbint_t, 0, maxSections, 0> Background2;
//Public WorldPath(1 To maxWorldPaths) As WorldPath
extern RangeArr<WorldPath_t, 1, maxWorldPaths> WorldPath;
DECLREF_T(WorldPath);
//Public numWorldPaths As Integer
extern int numWorldPaths;
//Public numWarps As Integer 'number of warps in a level
extern int numWarps;
//Public Warp(1 To maxWarps) As Warp 'define the warps
extern RangeArr<Warp_t, 1, maxWarps> Warp;
DECLREF_T(Warp);
//Public Tile(1 To maxTiles) As Tile
extern RangeArr<Tile_t, 1, maxTiles> Tile;
DECLREF_T(Tile);
//Public Scene(1 To maxScenes) As Scene
extern RangeArr<Scene_t, 1, maxScenes> Scene;
DECLREF_T(Scene);
//Public Credit(1 To 200) As CreditLine 'for end game credits
extern RangeArr<CreditLine_t, 1, maxCreditsLines> Credit;
extern int numWorldCredits;
extern int CreditOffsetY;
extern int CreditTotalHeight;
//Public numCredits As Integer 'number of credits
extern int numCredits;
//Public numBlock As Integer 'number of blocks
extern int numBlock;
//Public numBackground As Integer 'number of background objects
extern int numBackground;
//Public numNPCs As Integer
extern int numNPCs;
//Public numEffects As Integer
extern int numEffects;
//Public numPlayers As Integer
extern int numPlayers;
//Public numWorldLevels As Integer
extern int numWorldLevels;
//Public WorldMusic(1 To maxWorldMusic) As WorldMusic
extern RangeArr<WorldMusic_t, 1, maxWorldMusic> WorldMusic;
DECLREF_T(WorldMusic);
//Public numWorldMusic As Integer
extern int numWorldMusic;
//NEW
extern RangeArr<WorldArea_t, 1, maxWorldAreas> WorldArea;
DECLREF_T(WorldArea);
extern int numWorldAreas;
//Public WorldLevel(1 To maxWorldLevels) As WorldLevel
extern RangeArr<WorldLevel_t, 1, maxWorldLevels> WorldLevel;
DECLREF_T(WorldLevel);

inline const LevelSaveInfo_t Warp_t::save_info() const
{
    if(save_info_idx < 0x7FFF && save_info_idx < LevelWarpSaveEntries.size())
        return LevelWarpSaveEntries[save_info_idx].save_info;

    if(save_info_idx > 0x8000 && save_info_idx - 0x8000 <= numWorldLevels)
        return WorldLevel[save_info_idx - 0x8000].save_info;

    return LevelSaveInfo_t();
}

//Public Background(1 To maxBackgrounds) As Background
extern RangeArr<Background_t, 1, (maxBackgrounds + maxWarps)> Background;
DECLREF_T(Background);
//Public Effect(1 To maxEffects) As Effect
extern RangeArr<Effect_t, 1, maxEffects> Effect;

//Public NPC(-128 To maxNPCs) As NPC
extern RangeArr<NPC_t, -128, maxNPCs> NPC;
DECLREF_T(NPC);
//Public Block(0 To maxBlocks) As Block
extern RangeArr<Block_t, 0, maxBlocks> Block;
DECLREF_T(Block);

//Public Player(0 To maxPlayers) As Player
extern RangeArr<Player_t, 0, maxPlayers> Player;
//Public MarioFrameX(0 To maxPlayerFrames) As Integer 'Player frame offset X
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> MarioFrameX;
//Public MarioFrameY(0 To maxPlayerFrames) As Integer 'Player frame offset Y
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> MarioFrameY;
//Public LuigiFrameX(0 To maxPlayerFrames) As Integer 'Player frame offset X
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> LuigiFrameX;
//Public LuigiFrameY(0 To maxPlayerFrames) As Integer 'Player frame offset Y
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> LuigiFrameY;
//Public PeachFrameX(0 To maxPlayerFrames) As Integer 'Player frame offset X
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> PeachFrameX;
//Public PeachFrameY(0 To maxPlayerFrames) As Integer 'Player frame offset Y
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> PeachFrameY;
//Public ToadFrameX(0 To maxPlayerFrames) As Integer 'Player frame offset X
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> ToadFrameX;
//Public ToadFrameY(0 To maxPlayerFrames) As Integer 'Player frame offset Y
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> ToadFrameY;
//Public LinkFrameX(0 To maxPlayerFrames) As Integer 'Player frame offset X
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> LinkFrameX;
//Public LinkFrameY(0 To maxPlayerFrames) As Integer 'Player frame offset Y
extern RangeArrI<int8_t, 0, maxPlayerFrames, 0> LinkFrameY;
//Public BackgroundFence(0 To maxBackgroundType) As Boolean
extern RangeArrI<bool, 0, maxBackgroundType, false> BackgroundFence;

#if 0
// moved to npc_traits.h

//Public NPCFrameOffsetX(0 To maxNPCType) As Integer 'NPC frame offset X
extern RangeArrI<int, 0, maxNPCType, 0> NPCFrameOffsetX;
//Public NPCFrameOffsetY(0 To maxNPCType) As Integer 'NPC frame offset Y
extern RangeArrI<int, 0, maxNPCType, 0> NPCFrameOffsetY;
//Public NPCWidth(0 To maxNPCType) As Integer 'NPC width
extern RangeArrI<int, 0, maxNPCType, 0> NPCWidth;
//Public NPCHeight(0 To maxNPCType) As Integer 'NPC height
extern RangeArrI<int, 0, maxNPCType, 0> NPCHeight;
//Public NPCWidthGFX(0 To maxNPCType) As Integer 'NPC gfx width
extern RangeArrI<int, 0, maxNPCType, 0> NPCWidthGFX;
//Public NPCHeightGFX(0 To maxNPCType) As Integer 'NPC gfx height
extern RangeArrI<int, 0, maxNPCType, 0> NPCHeightGFX;
//Public NPCSpeedvar(0 To maxNPCType) As Single 'NPC Speed Change
extern RangeArr<float, 0, maxNPCType> NPCSpeedvar;

//Public NPCIsAShell(0 To maxNPCType) As Boolean 'Flags the NPC type if it is a shell
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsAShell;
//Public NPCIsABlock(0 To maxNPCType) As Boolean 'Flag NPC as a block
extern RangeArrI<bool, 0, maxNPCType, false> NPCIsABlock;
//Public NPCIsAHit1Block(0 To maxNPCType) As Boolean 'Flag NPC as a hit1 block
extern RangeArrI<bool, 0, maxNPCType, false> NPCIsAHit1Block;
//Public NPCIsABonus(0 To maxNPCType) As Boolean 'Flags the NPC type if it is a bonus
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsABonus;
//Public NPCIsACoin(0 To maxNPCType) As Boolean 'Flags the NPC type if it is a coin
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsACoin;
//Public NPCIsAVine(0 To maxNPCType) As Boolean 'Flags the NPC type if it is a vine
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsAVine;
//Public NPCIsAnExit(0 To maxNPCType) As Boolean 'Flags the NPC type if it is a level exit
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsAnExit;
//Public NPCIsAParaTroopa(0 To maxNPCType) As Boolean 'Flags the NPC type as a para-troopa
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsAParaTroopa;
//Public NPCIsCheep(0 To maxNPCType) As Boolean 'Flags the NPC type as a cheep cheep
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsCheep;
//Public NPCJumpHurt(0 To maxNPCType) As Boolean 'Hurts the player even if it jumps on the NPC
extern RangeArrI<bool, 0, maxNPCType, false> NPCJumpHurt;
//Public NPCNoClipping(0 To maxNPCType) As Boolean 'NPC can go through blocks
extern RangeArrI<bool, 0, maxNPCType, false> NPCNoClipping;
//Public NPCScore(0 To maxNPCType) As Integer 'NPC score value
extern RangeArrI<int, 0, maxNPCType, 0> NPCScore;
//Public NPCCanWalkOn(0 To maxNPCType) As Boolean  'NPC can be walked on
extern RangeArrI<bool, 0, maxNPCType, false> NPCCanWalkOn;
//Public NPCGrabFromTop(0 To maxNPCType) As Boolean  'NPC can be grabbed from the top
extern RangeArrI<bool, 0, maxNPCType, false> NPCGrabFromTop;
//Public NPCTurnsAtCliffs(0 To maxNPCType) As Boolean  'NPC turns around at cliffs
extern RangeArrI<bool, 0, maxNPCType, false> NPCTurnsAtCliffs;
//Public NPCWontHurt(0 To maxNPCType) As Boolean  'NPC wont hurt the player
extern RangeArrI<bool, 0, maxNPCType, false> NPCWontHurt;
//Public NPCMovesPlayer(0 To maxNPCType) As Boolean 'Player can not walk through the NPC
extern RangeArrI<bool, 0, maxNPCType, false> NPCMovesPlayer;
//Public NPCStandsOnPlayer(0 To maxNPCType) As Boolean 'for the clown car
extern RangeArrI<bool, 0, maxNPCType, false> NPCStandsOnPlayer;
//Public NPCIsGrabbable(0 To maxNPCType) As Boolean 'Player can grab the NPC
extern RangeArrI<bool, 0, maxNPCType, false> NPCIsGrabbable;
//Public NPCIsBoot(0 To maxNPCType) As Boolean 'npc is a kurbo's shoe
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsBoot;
//Public NPCIsYoshi(0 To maxNPCType) As Boolean 'npc is a yoshi
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsYoshi;
//Public NPCIsToad(0 To maxNPCType) As Boolean 'npc is a toad
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsToad;
//Public NPCNoYoshi(0 To maxNPCType) As Boolean 'Player can't eat the NPC
extern RangeArrI<bool, 0, maxNPCType, false> NPCNoYoshi;
//Public NPCForeground(0 To maxNPCType) As Boolean 'draw the npc in front
extern RangeArrI<bool, 0, maxNPCType, false> NPCForeground;
//Public NPCIsABot(0 To maxNPCType) As Boolean 'Zelda 2 Bot monster
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsABot;
//Public NPCDefaultMovement(0 To maxNPCType) As Boolean 'default NPC movement
// extern RangeArrI<bool, 0, maxNPCType, false> NPCDefaultMovement;
//Public NPCIsVeggie(0 To maxNPCType) As Boolean 'turnips
// extern RangeArrI<bool, 0, maxNPCType, false> NPCIsVeggie;
//Public NPCNoFireBall(0 To maxNPCType) As Boolean 'not hurt by fireball
extern RangeArrI<bool, 0, maxNPCType, false> NPCNoFireBall;
//Public NPCNoIceBall(0 To maxNPCType) As Boolean 'not hurt by fireball
extern RangeArrI<bool, 0, maxNPCType, false> NPCNoIceBall;
//Public NPCNoGravity(0 To maxNPCType) As Boolean 'not affected by gravity
extern RangeArrI<bool, 0, maxNPCType, false> NPCNoGravity;

//Public NPCFrame(0 To maxNPCType) As Integer
extern RangeArrI<int, 0, maxNPCType, 0> NPCFrame;
//Public NPCFrameSpeed(0 To maxNPCType) As Integer
extern RangeArrI<int, 0, maxNPCType, 0> NPCFrameSpeed;
//Public NPCFrameStyle(0 To maxNPCType) As Integer
extern RangeArrI<int, 0, maxNPCType, 0> NPCFrameStyle;
#endif

//Public Type NPCDefaults 'Default NPC Settings
// Moved into custom.cpp as local-private

//Public BlockIsSizable(0 To maxBlockType) As Boolean 'Flags block if it is sizable
extern RangeArrI<bool, 0, maxBlockType, false> BlockIsSizable;

enum
{
    SLOPE_FLOOR = 0,
    SLOPE_FLOOR_LEFT = -1,
    SLOPE_FLOOR_RIGHT = +1,
    SLOPE_CEILING = 0,
    SLOPE_CEILING_LEFT = -1,
    SLOPE_CEILING_RIGHT = +1,
};
//Public BlockSlope(0 To maxBlockType) As Integer 'block is sloped on top. -1 of block has an upward slope, 1 for downward
extern RangeArrI<vbint_t, 0, maxBlockType, 0> BlockSlope;
//Public BlockSlope2(0 To maxBlockType) As Integer 'block is sloped on the bottom.
extern RangeArrI<vbint_t, 0, maxBlockType, 0> BlockSlope2;

// moved into vScreen

//Public vScreenX(0 To maxPlayers) As Double  'vScreen offset
// extern RangeArr<double, 0, maxPlayers> vScreenX;
//Public vScreenY(0 To maxPlayers) As Double 'vScreen offset
// extern RangeArr<double, 0, maxPlayers> vScreenY;

// moved into qScreenLoc

//Public qScreenX(1 To maxPlayers) As Double  'vScreen offset adjust
// extern RangeArr<double, 0, maxPlayers> qScreenX;
//Public qScreenY(1 To maxPlayers) As Double 'vScreen offset adjust
// extern RangeArr<double, 0, maxPlayers> qScreenY;

//Public qScreen As Boolean 'Weather or not the screen needs adjusting
extern bool qScreen;
//! New: whether any canonical screens are currently in qScreen mode
extern bool qScreen_canonical;

// moved to "screen.h"
// NEW: allows screen position to change during qScreen
// extern RangeArr<vScreen_t, 0, 2> qScreenLoc;

//Public BlockWidth(0 To maxBlockType) As Integer 'Block type width
extern RangeArrI<vbint_t, 0, maxBlockType, 0> BlockWidth;
//Public BlockHeight(0 To maxBlockType) As Integer 'Block type height
extern RangeArrI<vbint_t, 0, maxBlockType, 0> BlockHeight;
//Public BonusWidth(1 To 100) As Integer 'Bonus type width
// extern RangeArrI<vbint_t, 0, maxBlockType, 0> BonusWidth;
//Public BonusHeight(1 To 100) As Integer 'Bonus type height
// extern RangeArrI<vbint_t, 0, maxBlockType, 0> BonusHeight;
//Public EffectWidth(1 To maxEffectType) As Integer 'Effect width
extern RangeArrI<vbint_t, 0, maxEffectType, 0> EffectWidth;
//Public EffectHeight(1 To maxEffectType) As Integer 'Effect height
extern RangeArrI<vbint_t, 0, maxEffectType, 0> EffectHeight;

//Public Type EffectDefaults
struct EffectDefaults_t
{
#ifndef LOW_MEM
//    EffectWidth(1 To maxEffectType) As Integer
    RangeArrI<vbint_t, 1, maxEffectType, 0> EffectWidth;
//    EffectHeight(1 To maxEffectType) As Integer
    RangeArrI<vbint_t, 1, maxEffectType, 0> EffectHeight;
#endif
//EXTRA: count of frames (compute from the GFX height)
    RangeArrI<vbint_t, 1, maxEffectType, 0> EffectFrames;
//End Type
};

//Public EffectDefaults As EffectDefaults
extern EffectDefaults_t EffectDefaults;
//Public SceneWidth(1 To 100) As Integer 'Scene width
extern RangeArrI<vbint_t, 1, maxSceneType, 0> SceneWidth;
//Public SceneHeight(1 To 100) As Integer 'Scene height
extern RangeArrI<vbint_t, 1, maxSceneType, 0> SceneHeight;
//Public BackgroundHasNoMask(1 To maxBackgroundType) As Boolean
extern RangeArrI<bool, 1, maxBackgroundType, false> BackgroundHasNoMask;
//Public Foreground(0 To maxBackgroundType) As Boolean 'flags the background object to be drawn in front of everything else
extern RangeArrI<bool, 0, maxBackgroundType, false> Foreground;
//Public BackgroundWidth(1 To maxBackgroundType) As Integer
extern RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundWidth;
//Public BackgroundHeight(1 To maxBackgroundType) As Integer
extern RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundHeight;
//Public BackgroundFrame(1 To maxBackgroundType) As Integer
extern RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundFrame;
//Public BackgroundFrameCount(1 To maxBackgroundType) As Integer
extern RangeArrI<vbint_t, 1, maxBackgroundType, 0> BackgroundFrameCount;
//Public BlockFrame(1 To maxBlockType) As Integer 'What frame the block is on
extern RangeArrI<vbint_t, 1, maxBlockType, 0> BlockFrame;
//Public BlockFrame2(1 To maxBlockType) As Integer 'Counter to update the blocks frame
extern RangeArrI<vbint_t, 1, maxBlockType, 0> BlockFrame2;

// deprecated
//Public sBlockArray(1 To 1000) As Integer 'sizable block array
// extern RangeArrI<int, 1, 1000, 0> sBlockArray;
//Public sBlockNum As Integer
// extern int sBlockNum;

//Public SceneFrame(1 To maxSceneType) As Integer 'What frame the scene is on
extern RangeArrI<vbint_t, 1, maxSceneType, 0> SceneFrame;
//Public SceneFrame2(1 To maxSceneType) As Integer 'Counter to update the scene frames
extern RangeArrI<vbint_t, 1, maxSceneType, 0> SceneFrame2;
//Public SpecialFrame(100) As Integer 'misc frames for things like coins and the kurbi shoe
extern RangeArrI<vbint_t, 0, 9, 0> SpecialFrame;
//Public SpecialFrameCount(100) As Single
extern RangeArr<vbint_t, 0, 9> SpecialFrameCount;
//Public TileWidth(1 To maxTileType) As Integer
extern RangeArrI<vbint_t, 1, maxTileType, 0> TileWidth;
//Public TileHeight(1 To maxTileType) As Integer
extern RangeArrI<vbint_t, 1, maxTileType, 0> TileHeight;
//Public TileFrame(1 To maxTileType) As Integer
extern RangeArrI<vbint_t, 1, maxTileType, 0> TileFrame;
//Public TileFrame2(1 To maxTileType) As Integer
extern RangeArrI<vbint_t, 1, maxTileType, 0> TileFrame2;
//Public LevelFrame(1 To 100) As Integer 'What frame the scene is on
extern RangeArrI<vbint_t, 1, 100, 0> LevelFrame;
//Public LevelFrame2(1 To 100) As Integer 'Counter to update the scene frames
extern RangeArrI<vbint_t, 1, 100, 0> LevelFrame2;
//Public BlockHasNoMask(1 To maxBlockType) As Boolean
extern RangeArrI<bool, 1, maxBlockType, false> BlockHasNoMask;
//Public LevelHasNoMask(1 To 100) As Boolean
// extern RangeArrI<bool, 1, 100, false> LevelHasNoMask;
//Public BlockOnlyHitspot1(0 To maxBlockType) As Boolean
extern RangeArrI<bool, 0, maxBlockType, false> BlockOnlyHitspot1;
//Public BlockKills(0 To maxBlockType) As Boolean 'block is lava
extern RangeArrI<bool, 0, maxBlockType, false> BlockKills;
//Public BlockKills2(0 To maxBlockType) As Boolean
extern RangeArrI<bool, 0, maxBlockType, false> BlockKills2;
//Public BlockHurts(0 To maxBlockType) As Boolean 'block hurts the player
extern RangeArrI<bool, 0, maxBlockType, false> BlockHurts;
//Public BlockPSwitch(0 To maxBlockType) As Boolean 'block is affected by the p switch
extern RangeArrI<bool, 0, maxBlockType, false> BlockPSwitch;
//Public BlockNoClipping(0 To maxBlockType) As Boolean 'player/npcs can walk throught the block
extern RangeArrI<bool, 0, maxBlockType, false> BlockNoClipping;
//Public CoinFrame(1 To 10) As Integer 'What frame the coin is on
extern RangeArrI<vbint_t, 1, 10, 0> CoinFrame;
//Public CoinFrame2(1 To 10) As Integer 'Counter to update the coin frames
extern RangeArrI<vbint_t, 1, 10, 0> CoinFrame2;
//Public EditorCursor As EditorCursor
extern EditorCursor_t EditorCursor;
//Public EditorControls As EditorControls

extern SharedControls_t l_SharedControls;

extern CursorControls_t SharedCursor;

extern EditorControls_t EditorControls;

extern bool SharedPause;
extern bool SharedPauseLegacy;
extern bool SharedPauseForce;

// extern RangeArr<CursorControls_t, 1, maxLocalPlayers> PlayerCursor;

//Public Sound(1 To numSounds) As Integer
// extern RangeArrI<int, 1, numSounds, 0> Sound;
//Public SoundPause(1 To numSounds) As Integer
extern RangeArrI<vbint_t, 1, numSounds, 0> SoundPause;
//EXTRA: Immediately quit level because of a fatal error
extern bool ErrorQuit;
//Public EndLevel As Boolean 'End the level and move to the next
extern bool EndLevel;

enum LevelMacro_t
{
    LEVELMACRO_OFF = 0,
    LEVELMACRO_CARD_ROULETTE_EXIT = 1,
    LEVELMACRO_QUESTION_SPHERE_EXIT = 2,
    LEVELMACRO_KEYHOLE_EXIT = 3,
    LEVELMACRO_CRYSTAL_BALL_EXIT = 4,
    LEVELMACRO_GAME_COMPLETE_EXIT = 5,
    LEVELMACRO_STAR_EXIT = 6,
    LEVELMACRO_GOAL_TAPE_EXIT = 7,
    LEVELMACRO_FLAG_EXIT = 8,
    LEVELMACRO_ALT_FLAG_EXIT = 9, // reserved
};
//Public LevelMacro As Integer 'Shows a level outro when beat
extern LevelMacro_t LevelMacro;

//Public LevelMacroCounter As Integer
extern int LevelMacroCounter;

//EXTRA: variant for level macro.
// Keyhole exit: which BGO caused the key exit?
// Card roulette exit: negative value indicates triggered by cheat
extern int LevelMacroWhich;

//EXTRA: can the player wall-jump?
extern bool CanWallJump;

//Public numJoysticks As Integer
// extern int numJoysticks;

//Public FileName As String
extern std::string FileName;
//! EXTRA: A full filename (the "FileName" is now has the "base name" sense)
extern std::string FileNameFull;
//Public FullFileName As String
extern std::string FullFileName;
//Public FileNamePath As String
extern std::string FileNamePath;
//! EXTRA: The recent sub-hub level file
extern std::string FileRecentSubHubLevel;
//! EXTRA: The format of the current file
extern int FileFormat;

//! EXTRA: World map preserved filename
extern std::string FileNameWorld;
//! EXTRA: World map preserved full path
extern std::string FileNameFullWorld;
//! EXTRA: World map preserved parent directory
extern std::string FileNamePathWorld;
//! EXTRA: The format of the world file
extern int FileFormatWorld;

//! EXTRA: Identify that episode is an intro level
extern bool IsEpisodeIntro;
//! EXTRA: Identify that level is a hub or sub-hub where player can save the game
extern bool IsHubLevel;
//Public Coins As Integer 'number of coins
extern int Coins;
//Public Lives As Single 'number of lives
extern int Lives;
//NEW: tracker of number of hundreds of coins that have been obtained
extern int g_100s;
//Public EndIntro As Boolean
// extern bool EndIntro;
//Public ExitMenu As Boolean
// extern bool ExitMenu;
//Public LevelSelect As Boolean 'true if game should load the world map
extern bool LevelSelect;


extern bool LevelRestartRequested;
//Public WorldPlayer(1) As WorldPlayer
extern RangeArr<WorldPlayer_t, 0, 1> WorldPlayer;

// unsafe to reorder these -- they are used in the WLD format and also included in the save file
enum LevelBeatCode_t
{
    BEATCODE_SETUP = -3,
    BEATCODE_RESTART = -2,
    BEATCODE_QUIT = -1,
    BEATCODE_NONE = 0,
    BEATCODE_CARD_ROULETTE = 1,
    BEATCODE_QUESTION_SPHERE = 2,
    BEATCODE_OFFSCREEN = 3,
    BEATCODE_KEYHOLE = 4,
    BEATCODE_CRYSTAL_BALL = 5,
    BEATCODE_WARP = 6,
    BEATCODE_STAR = 7,
    BEATCODE_GOAL_TAPE = 8,
    BEATCODE_FLAG = 9,      // new
    BEATCODE_ALT_FLAG = 10, // new, not yet implemented
    BEATCODE_RESERVED_1 = 11,    // new, reserved for scripting
    BEATCODE_RESERVED_2 = 12,    // new, reserved for scripting
    BEATCODE_RESERVED_3 = 13,    // new, reserved for scripting
    BEATCODE_RESERVED_4 = 14,    // new, reserved for scripting
    BEATCODE_GAME_COMPLETE = 15, // new, used to mark the game as completed from this level
};
//Public LevelBeatCode As Integer ' code for the way the plauer beat the level
extern LevelBeatCode_t LevelBeatCode;
//Public curWorldLevel As Integer
extern int curWorldLevel;
//Public curWorldMusic As Integer
extern int curWorldMusic;
//EXTRA: Custom world music
extern std::string curWorldMusicFile;

// EXTRA: convenience functions to check if world music is new or not, and play
// defined in main/world_loop.cpp
bool g_isWorldMusicNotSame(WorldMusic_t &mus);
void g_playWorldMusic(WorldMusic_t &mus);

//Public NoTurnBack(0 To maxSections) As Boolean
extern RangeArrI<bool, 0, maxSections, false> NoTurnBack;
//Public UnderWater(0 To maxSections) As Boolean
extern RangeArrI<bool, 0, maxSections, false> UnderWater;

// EXTRA: track extra JSON info from a loaded level
extern RangeArrI<stringindex_t, 0, maxSections, STRINGINDEX_NONE> SectionJSONInfo;

// world custom data
extern std::string WldxCustomParams;
extern std::vector<std::string> SubHubLevels;

//Public TestLevel As Boolean
extern bool TestLevel;
//Public GameMenu As Boolean
extern bool GameMenu;
//Public WorldName As String
extern std::string WorldName;
//Public selWorld As Integer
extern int selWorld;
//Public selSave As Integer
extern int selSave;
//Public PSwitchTime As Integer
extern int PSwitchTime;
//Public PSwitchStop As Integer
extern int PSwitchStop;
// NEW: tracks period of player's invincibility to all damage except lava, offscreen, and crushing
extern int InvincibilityTime;
//Public PSwitchPlayer As Integer
extern int PSwitchPlayer;

// newly extended

struct SavedChar_t
{
    uint16_t HeldBonus = NPCID(0);
    uint8_t State = 1;
    uint8_t Mount = 0;
    uint8_t MountType = 0;
    uint8_t Hearts = 1;
    uint8_t Character = 1;

    inline SavedChar_t& operator=(const SavedChar_t& ch) = default;
    inline SavedChar_t& operator=(const Player_t& p)
    {
        HeldBonus = p.HeldBonus;
        State = p.State;
        Mount = p.Mount;
        MountType = p.MountType;
        Hearts = p.Hearts;
        Character = p.Character;

        return *this;
    }
    inline operator Player_t() const
    {
        Player_t p;

        p.HeldBonus = NPCID(HeldBonus);
        p.State = State;
        p.Mount = Mount;
        p.MountType = MountType;
        p.Hearts = Hearts;
        p.Character = Character;

        return p;
    }
};

struct SaveSlotInfo_t
{
    int64_t Time = 0;
    bool    FailsEnabled = false;
    int32_t Fails = 0;
    int32_t Score = 0;
    int ConfigDefaults = 0;

    RangeArr<SavedChar_t, 1, 5> SavedChar;

    // Save progress percent, displayed at title. <0 value denotes uninitialized saves
    int Progress = -1;
    int Stars = 0;
    int Lives = 3;
    int Hundreds = 0;
    int Coins = 0;
};

// new: all save info
extern RangeArr<SaveSlotInfo_t, 1, maxSaveSlots> SaveSlotInfo;

// deprecated
//Public SaveSlot(1 To 3) As Integer
// extern RangeArrI<int, 1, maxSaveSlots, 0> SaveSlot;
//Public SaveStars(1 To 3) As Integer
// extern RangeArrI<int, 1, maxSaveSlots, 0> SaveStars;


//Public BeltDirection As Integer 'direction of the converyer belt blocks
extern int BeltDirection;
//Public BeatTheGame As Boolean 'true if the game has been beaten
extern bool BeatTheGame;
// 'for frameskip
//Public cycleCount As Integer
//extern int cycleCount;
//Public fpsTime As Double
//extern double fpsTime;
//Public fpsCount As Double
//extern double fpsCount;
// replaced with g_config.enable_frameskip
//Public FrameSkip As Boolean
// extern bool FrameSkip;
//Public GoalTime As Double
//extern double GoalTime;
//Public overTime As Double
//extern double overTime;
//'------------------
//Public worldCurs As Integer
// extern int worldCurs;
//Public minShow As Integer
// extern int minShow;
//Public maxShow As Integer
// extern int maxShow;

//Public Type Physics
struct Physics_t
{
//    PlayerJumpHeight As Integer
    int PlayerJumpHeight = 0;
//    PlayerBlockJumpHeight As Integer
    int PlayerBlockJumpHeight = 0;
//    PlayerHeadJumpHeight As Integer
    int PlayerHeadJumpHeight = 0;
//    PlayerNPCJumpHeight As Integer
    int PlayerNPCJumpHeight = 0;
//    PlayerSpringJumpHeight As Integer
    int PlayerSpringJumpHeight = 0;
//    PlayerJumpVelocity As Single
    num_t PlayerJumpVelocity = 0_n;
//    PlayerRunSpeed As Single
    int PlayerRunSpeed = 0;
//    PlayerWalkSpeed As Single
    int PlayerWalkSpeed = 0;
//    PlayerTerminalVelocity As Integer
    int PlayerTerminalVelocity = 0;
//    PlayerGravity As Single
    num_t PlayerGravity = 0_n;
//    PlayerHeight(1 To numCharacters, 1 To numStates) As Integer
    RangeArr<RangeArrI<int, 1, numStates, 0>, 1, numCharacters> PlayerHeight;
//    PlayerDuckHeight(1 To numCharacters, 1 To numStates) As Integer
    RangeArr<RangeArrI<int, 1, numStates, 0>, 1, numCharacters> PlayerDuckHeight;
//    PlayerWidth(1 To numCharacters, 1 To numStates) As Integer
    RangeArr<RangeArrI<int, 1, numStates, 0>, 1, numCharacters> PlayerWidth;
//    PlayerGrabSpotX(1 To numCharacters, 1 To numStates) As Integer
    RangeArr<RangeArrI<int, 1, numStates, 0>, 1, numCharacters> PlayerGrabSpotX;
//    PlayerGrabSpotY(1 To numCharacters, 1 To numStates) As Integer
    RangeArr<RangeArrI<int, 1, numStates, 0>, 1, numCharacters> PlayerGrabSpotY;
//    NPCTimeOffScreen As Integer
    int NPCTimeOffScreen = 0;
//    NPCCanHurtWait As Integer
    int NPCCanHurtWait = 0;
//    NPCShellSpeed As Single
    num_t NPCShellSpeed = 0_n;
//    NPCShellSpeedY As Single
    num_t NPCShellSpeedY = 0_n;
//    NPCWalkingSpeed As Single
    num_t NPCWalkingSpeed = 0_n;
//    NPCWalkingOnSpeed As Single
    num_t NPCWalkingOnSpeed = 0_n;
//    NPCMushroomSpeed As Single
    num_t NPCMushroomSpeed = 0_n;
//    NPCGravity As Single
    // Was previously a float, changed to a double for efficient comparisons. All stores must factor through float.
    num_t NPCGravity = 0_n;
//    NPCGravityReal As Single
    numf_t NPCGravityReal = 0_nf;
//    NPCPSwitch As Integer
    int NPCPSwitch = 0;
//End Type
};

//Public Type Events
//moved into "layers.h"

//Public ReturnWarp As Integer 'for when the player returns from a warp
extern int ReturnWarp;
//! EXTRA: Used to be captured into game save
extern int ReturnWarpSaved;
//Public StartWarp As Integer
extern int StartWarp;
//Public Physics As Physics
extern Physics_t Physics;
//Public MenuCursor As Integer
extern int MenuCursor;
//Public MenuMode As Integer
extern int MenuMode;
//Public MenuCursorCanMove As Boolean
extern bool MenuCursorCanMove;
//Public MenuCursorCanMove2 As Boolean 'Joystick
// Now used to check if it's okay to go back (separately from the other actions)
extern bool MenuCursorCanMove_Back;
//Public NextFrame As Boolean
// extern bool NextFrame;
//Public StopHit As Integer
extern int StopHit;
//Public MouseRelease As Boolean
extern bool MouseRelease;
//Public TestFullscreen As Boolean
// extern bool TestFullscreen;
////Public keyDownAlt As Boolean 'for alt/enter fullscreen
//extern bool keyDownAlt;
////Public keyDownEnter As Boolean
//extern bool keyDownEnter;

// no longer needed thanks to block quadtree, BUT used to recreate one buggy behavior
//Public BlocksSorted As Boolean 'if using block optimization it requires the locks to be sorted
extern bool BlocksSorted;

//Public SingleCoop As Integer 'cheat code
extern int SingleCoop;
//NEW: checks whether a superbdemo* cheat code is active
extern bool g_ClonedPlayerMode;
//Public CheatString As String 'logs keys for cheats
//extern std::string CheatString; // Made static at cheat_code.cpp
//Public GameOutro As Boolean 'true if showing credits
extern bool GameOutro;
extern bool GameOutroDoQuit;
//Public CreditChop As Single
extern int CreditChop;
//Public EndCredits As Integer
extern int EndCredits;
//Public curStars As Integer 'number of stars
extern int curStars;
//Public maxStars As Integer 'max number of stars in the game
// extern int maxStars;
//'cheat codes --------------
//Public ShadowMode As Boolean 'cheat code
extern bool ShadowMode;
//Public MultiHop As Boolean
extern bool MultiHop;
//Public SuperSpeed As Boolean
extern bool SuperSpeed;
//Public WalkAnywhere As Boolean
extern bool WalkAnywhere;
//Public FlyForever As Boolean
extern bool FlyForever;
//Public FreezeNPCs As Boolean
extern bool FreezeNPCs;
//Public CaptainN As Boolean
extern bool CaptainN;
//Public FlameThrower As Boolean
extern bool FlameThrower;
//Public CoinMode As Boolean 'cheat code
extern bool CoinMode;
//Public WorldUnlock As Boolean
// extern bool WorldUnlock;
// replaced with g_config.unlimited_framerate
//Public MaxFPS As Boolean
// extern bool MaxFPS;
//Public GodMode As Boolean
extern bool GodMode;
//Public GrabAll As Boolean
extern bool GrabAll;
//Public Cheater As Boolean 'if the player is a cheater
extern bool Cheater;

#ifdef ENABLE_ANTICHEAT_TRAP
//EXTRA: Quit the game like "game over" even with enough lifes
extern bool CheaterMustDie;
#endif

//'--------------------------------
//Public WorldCredits(1 To 5) As String
extern RangeArr<std::string, 1, maxWorldCredits> WorldCredits;
//Public Score As Long 'player's score
extern int Score;
//Public Points(1 To 13) As Integer
extern RangeArrI<int, 1, 13, 0> Points;

// moved into the implementation details of InputMethodProfile_Joystick
//Public oldJumpJoy As Integer
// extern KM_Key oldJumpJoy;

//Public MaxWorldStars As Integer 'maximum number of world stars
extern int MaxWorldStars;
//Public Debugger As Boolean 'if the debugger window is open
// extern bool Debugger;
//Public SavedChar(0 To 10) As Player 'Saves the Player's Status
extern RangeArr<SavedChar_t, 0, 10> SavedChar;

extern bool LoadingInProcess;
//Public LoadCoins As Integer
extern int LoadCoins;
//Public LoadCoinsT As Single
extern unsigned int LoadCoinsT;

//'Game Graphics
//Public GFXBlockCustom(1 To maxBlockType) As Boolean
// extern RangeArrI<bool, 1, maxBlockType, false> GFXBlockCustom;
//Public GFXBlock(1 To maxBlockType) As Long
//extern RangeArrI<long, 1, maxBlockType, 0> GFXBlock;
#define GFXBlock GFXBlockBMP
//Public GFXBlockMask(1 To maxBlockType) As Long
//extern RangeArrI<long, 1, maxBlockType, 0> GFXBlockMask;
//Public GFXBlockBMP(1 To maxBlockType) As StdPicture
extern RangeArr<StdPicture, 1, maxBlockType> GFXBlockBMP;
//Public GFXBlockMaskBMP(1 To maxBlockType) As StdPicture
//extern RangeArr<StdPicture, 1, maxBlockType> GFXBlockMaskBMP;
//Public GFXBackground2Custom(1 To numBackground2) As Boolean
// extern RangeArrI<bool, 1, numBackground2, false> GFXBackground2Custom;
//Public GFXBackground2(1 To numBackground2) As Long
//extern RangeArrI<long, 1, numBackground2, 0> GFXBackground2;
#define GFXBackground2 GFXBackground2BMP
//Public GFXBackground2BMP(1 To numBackground2) As StdPicture
extern RangeArr<StdPicture, 1, numBackground2> GFXBackground2BMP;
//Public GFXBackground2Height(1 To numBackground2) As Integer
// extern RangeArrI<vbint_t, 1, numBackground2, 0> GFXBackground2Height;
//Public GFXBackground2Width(1 To numBackground2) As Integer
// extern RangeArrI<vbint_t, 1, numBackground2, 0> GFXBackground2Width;
//Public GFXNPCCustom(1 To maxNPCType) As Boolean
// extern RangeArrI<bool, 1, maxNPCType, false> GFXNPCCustom;
//Public GFXNPC(1 To maxNPCType) As Long
//extern RangeArrI<long, 1, maxNPCType, 0> GFXNPC;
#define GFXNPC GFXNPCBMP
//Public GFXNPCMask(1 To maxNPCType) As Long
//extern RangeArrI<long, 1, maxNPCType, 0> GFXNPCMask;
//Public GFXNPCBMP(1 To maxNPCType) As StdPicture
extern RangeArr<StdPicture, 0, maxNPCType> GFXNPCBMP;
//Public GFXNPCMaskBMP(1 To maxNPCType) As StdPicture
//extern RangeArr<StdPicture, 0, maxNPCType> GFXNPCMaskBMP;

// removed (GFXNPC[Type].w/w used instead, only used by veggies originally)
//Public GFXNPCHeight(1 To maxNPCType) As Integer
// extern RangeArrI<int, 1, maxNPCType, 0> GFXNPCHeight;
//Public GFXNPCWidth(1 To maxNPCType) As Integer
// extern RangeArrI<int, 1, maxNPCType, 0> GFXNPCWidth;

//Public GFXEffectCustom(1 To maxEffectType) As Boolean
extern RangeArrI<bool, 1, maxEffectType, false> GFXEffectCustom;
//Public GFXEffect(1 To maxEffectType) As Long
//extern RangeArrI<long, 1, maxEffectType, 0> GFXEffect;
#define GFXEffect GFXEffectBMP
//Public GFXEffectMask(1 To maxEffectType) As Long
//extern RangeArrI<long, 1, maxEffectType, 0> GFXEffectMask;
//Public GFXEffectBMP(1 To maxEffectType) As StdPicture
extern RangeArr<StdPicture, 1, maxEffectType> GFXEffectBMP;
//Public GFXEffectMaskBMP(1 To maxEffectType) As StdPicture
//extern RangeArr<StdPicture, 1, maxEffectType> GFXEffectMaskBMP;
//Public GFXEffectHeight(1 To maxEffectType) As Integer
// extern RangeArrI<vbint_t, 1, maxEffectType, 0> GFXEffectHeight;
//Public GFXEffectWidth(1 To maxEffectType) As Integer
// extern RangeArrI<vbint_t, 1, maxEffectType, 0> GFXEffectWidth;
//Public GFXBackgroundCustom(1 To maxBackgroundType) As Boolean
// extern RangeArrI<bool, 1, maxBackgroundType, false> GFXBackgroundCustom;
//Public GFXBackground(1 To maxBackgroundType) As Long
//extern RangeArrI<long, 1, maxBackgroundType, 0> GFXBackground;
#define GFXBackground GFXBackgroundBMP
//Public GFXBackgroundMask(1 To maxBackgroundType) As Long
//extern RangeArrI<long, 1, maxBackgroundType, 0> GFXBackgroundMask;
//Public GFXBackgroundBMP(1 To maxBackgroundType) As StdPicture
extern RangeArr<StdPicture, 1, maxBackgroundType> GFXBackgroundBMP;
//Public GFXBackgroundMaskBMP(1 To maxBackgroundType) As StdPicture
//extern RangeArr<StdPicture, 1, maxBackgroundType> GFXBackgroundMaskBMP;
//Public GFXBackgroundHeight(1 To maxBackgroundType) As Integer
// extern RangeArrI<vbint_t, 1, maxBackgroundType, 0> GFXBackgroundHeight;
//Public GFXBackgroundWidth(1 To maxBackgroundType) As Integer
// extern RangeArrI<vbint_t, 1, maxBackgroundType, 0> GFXBackgroundWidth;

extern const char *GFXPlayerNames[numCharacters];
extern RangeArr<StdPicture, 1, numStates> *GFXCharacterBMP[numCharacters];
extern RangeArrI<vbint_t, 1, numStates, 0> *GFXCharacterWidth[numCharacters];
extern RangeArrI<vbint_t, 1, numStates, 0> *GFXCharacterHeight[numCharacters];
// extern RangeArrI<bool, 1, 10, false> *GFXCharacterCustom[numCharacters];

//Public GFXMarioCustom(1 To 10) As Boolean
// extern RangeArrI<bool, 1, 10, false> GFXMarioCustom;
//Public GFXMario(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXMario;
#define GFXMario GFXMarioBMP
//Public GFXMarioMask(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXMarioMask;
//Public GFXMarioBMP(1 To 10) As StdPicture
extern RangeArr<StdPicture, 1, numStates> GFXMarioBMP;
//Public GFXMarioMaskBMP(1 To 10) As StdPicture
//extern RangeArr<StdPicture, 1, 10> GFXMarioMaskBMP;
//Public GFXMarioHeight(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXMarioHeight;
//Public GFXMarioWidth(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXMarioWidth;
//Public GFXLuigiCustom(1 To 10) As Boolean
// extern RangeArrI<bool, 1, 10, false> GFXLuigiCustom;
//Public GFXLuigi(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXLuigi;
#define GFXLuigi GFXLuigiBMP
//Public GFXLuigiMask(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXLuigiMask;
//Public GFXLuigiBMP(1 To 10) As StdPicture
extern RangeArr<StdPicture, 1, numStates> GFXLuigiBMP;
//Public GFXLuigiMaskBMP(1 To 10) As StdPicture
//extern RangeArr<StdPicture, 1, 10> GFXLuigiMaskBMP;
//Public GFXLuigiHeight(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXLuigiHeight;
//Public GFXLuigiWidth(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXLuigiWidth;
//Public GFXPeachCustom(1 To 10) As Boolean
// extern RangeArrI<bool, 1, 10, false> GFXPeachCustom;
//Public GFXPeach(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXPeach;
#define GFXPeach GFXPeachBMP
//Public GFXPeachMask(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXPeachMask;
//Public GFXPeachBMP(1 To 10) As StdPicture
extern RangeArr<StdPicture, 1, numStates> GFXPeachBMP;
//Public GFXPeachMaskBMP(1 To 10) As StdPicture
//extern RangeArr<StdPicture, 1, 10> GFXPeachMaskBMP;
//Public GFXPeachHeight(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXPeachHeight;
//Public GFXPeachWidth(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXPeachWidth;
//Public GFXToadCustom(1 To 10) As Boolean
// extern RangeArrI<bool, 1, 10, false> GFXToadCustom;
//Public GFXToad(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXToad;
#define GFXToad GFXToadBMP
//Public GFXToadMask(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXToadMask;
//Public GFXToadBMP(1 To 10) As StdPicture
extern RangeArr<StdPicture, 1, numStates> GFXToadBMP;
//Public GFXToadMaskBMP(1 To 10) As StdPicture
//extern RangeArr<StdPicture, 1, 10> GFXToadMaskBMP;
//Public GFXToadHeight(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXToadHeight;
//Public GFXToadWidth(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXToadWidth;

//Public GFXLinkCustom(1 To 10) As Boolean
// extern RangeArrI<bool, 1, 10, false> GFXLinkCustom;
//Public GFXLink(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXLink;
#define GFXLink GFXLinkBMP
//Public GFXLinkMask(1 To 10) As Long
//extern RangeArrI<long, 1, 10, 0> GFXLinkMask;
//Public GFXLinkBMP(1 To 10) As StdPicture
extern RangeArr<StdPicture, 1, numStates> GFXLinkBMP;
//Public GFXLinkMaskBMP(1 To 10) As StdPicture
//extern RangeArr<StdPicture, 1, 10> GFXLinkMaskBMP;
//Public GFXLinkHeight(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXLinkHeight;
//Public GFXLinkWidth(1 To 10) As Integer
// extern RangeArrI<vbint_t, 1, 10, 0> GFXLinkWidth;
//Public GFXYoshiBCustom(1 To 10) As Boolean
// extern RangeArrI<bool, 1, maxYoshiGfx, false> GFXYoshiBCustom;
//Public GFXYoshiB(1 To 10) As Long
//extern RangeArrI<long, 1, maxYoshiGfx, 0> GFXYoshiB;
#define GFXYoshiB GFXYoshiBBMP
//Public GFXYoshiBMask(1 To 10) As Long
//extern RangeArrI<long, 1, maxYoshiGfx, 0> GFXYoshiBMask;
//Public GFXYoshiBBMP(1 To 10) As StdPicture
extern RangeArr<StdPicture, 1, maxYoshiGfx> GFXYoshiBBMP;
//Public GFXYoshiBMaskBMP(1 To 10) As StdPicture
//extern RangeArr<StdPicture, 1, maxYoshiGfx> GFXYoshiBMaskBMP;
//Public GFXYoshiTCustom(1 To 10) As Boolean
// extern RangeArrI<bool, 1, maxYoshiGfx, false> GFXYoshiTCustom;
//Public GFXYoshiT(1 To 10) As Long
//extern RangeArrI<long, 1, maxYoshiGfx, 0> GFXYoshiT;
#define GFXYoshiT GFXYoshiTBMP
//Public GFXYoshiTMask(1 To 10) As Long
//extern RangeArrI<long, 1, maxYoshiGfx, 0> GFXYoshiTMask;
//Public GFXYoshiTBMP(1 To 10) As StdPicture
extern RangeArr<StdPicture, 1, maxYoshiGfx> GFXYoshiTBMP;
//Public GFXYoshiTMaskBMP(1 To 10) As StdPicture
//extern RangeArr<StdPicture, 1, maxYoshiGfx> GFXYoshiTMaskBMP;
//'World Map Graphics
//Public GFXTileCustom(1 To maxTileType) As Long
// extern RangeArrI<bool, 1, maxTileType, false> GFXTileCustom;
//Public GFXTile(1 To maxTileType) As Long
//extern RangeArrI<long, 1, maxTileType, 0> GFXTile;
#define GFXTile GFXTileBMP
//Public GFXTileBMP(1 To maxTileType) As StdPicture
extern RangeArr<StdPicture, 1, maxTileType> GFXTileBMP;
//Public GFXTileHeight(1 To maxTileType) As Integer
// extern RangeArrI<vbint_t, 1, maxTileType, 0> GFXTileHeight;
//Public GFXTileWidth(1 To maxTileType) As Integer
// extern RangeArrI<vbint_t, 1, maxTileType, 0> GFXTileWidth;
//Public GFXLevelCustom(0 To maxLevelType) As Long
// extern RangeArrI<bool, 0, maxLevelType, false> GFXLevelCustom;
//Public GFXLevel(0 To maxLevelType) As Long
//extern RangeArrI<long, 0, maxLevelType, 0> GFXLevel;
#define GFXLevel GFXLevelBMP
//Public GFXLevelMask(0 To maxLevelType) As Long
//extern RangeArrI<long, 0, maxLevelType, 0> GFXLevelMask;
//Public GFXLevelBMP(0 To maxLevelType) As StdPicture
extern RangeArr<StdPicture, 0, maxLevelType> GFXLevelBMP;
//Public GFXLevelMaskBMP(0 To maxLevelType) As StdPicture
//extern RangeArr<StdPicture, 0, maxLevelType> GFXLevelMaskBMP;
//Public GFXLevelHeight(0 To maxLevelType) As Integer
// extern RangeArrI<vbint_t, 0, maxLevelType, 0> GFXLevelHeight;
//Public GFXLevelWidth(0 To maxLevelType) As Integer
// extern RangeArrI<vbint_t, 0, maxLevelType, 0> GFXLevelWidth;
//Public GFXLevelBig(0 To maxLevelType) As Boolean
extern RangeArrI<bool, 0, maxLevelType, false> GFXLevelBig;
//Public GFXSceneCustom(1 To maxSceneType) As Long
// extern RangeArrI<bool, 1, maxSceneType, false> GFXSceneCustom;
//Public GFXScene(1 To maxSceneType) As Long
//extern RangeArrI<long, 1, maxSceneType, 0> GFXScene;
#define GFXScene GFXSceneBMP
//Public GFXSceneMask(1 To maxSceneType) As Long
//extern RangeArrI<long, 1, maxSceneType, 0> GFXSceneMask;
//Public GFXSceneBMP(1 To maxSceneType) As StdPicture
extern RangeArr<StdPicture, 1, maxSceneType> GFXSceneBMP;
//Public GFXSceneMaskBMP(1 To maxSceneType) As StdPicture
//extern RangeArr<StdPicture, 1, maxSceneType> GFXSceneMaskBMP;
//Public GFXSceneHeight(1 To maxSceneType) As Integer
// extern RangeArrI<vbint_t, 1, maxSceneType, 0> GFXSceneHeight;
//Public GFXSceneWidth(1 To maxSceneType) As Integer
// extern RangeArrI<vbint_t, 1, maxSceneType, 0> GFXSceneWidth;
//Public GFXPathCustom(1 To maxPathType) As Long
// extern RangeArrI<bool, 1, maxPathType, false> GFXPathCustom;
//Public GFXPath(1 To maxPathType) As Long
//extern RangeArrI<long, 1, maxPathType, 0> GFXPath;
#define GFXPath GFXPathBMP
//Public GFXPathMask(1 To maxPathType) As Long
//extern RangeArrI<long, 1, maxPathType, 0> GFXPathMask;
//Public GFXPathBMP(1 To maxPathType) As StdPicture
extern RangeArr<StdPicture, 1, maxPathType> GFXPathBMP;
//Public GFXPathMaskBMP(1 To maxPathType) As StdPicture
//extern RangeArr<StdPicture, 1, maxPathType> GFXPathMaskBMP;
//Public GFXPathHeight(1 To maxPathType) As Integer
// extern RangeArrI<vbint_t, 1, maxPathType, 0> GFXPathHeight;
//Public GFXPathWidth(1 To maxPathType) As Integer
// extern RangeArrI<vbint_t, 1, maxPathType, 0> GFXPathWidth;

//Public GFXPlayerCustom(1 To numCharacters) As Long
// extern RangeArrI<bool, 1, numCharacters, false> GFXPlayerCustom;
//Public GFXPlayer(1 To numCharacters) As Long
//extern RangeArrI<long, 1, numCharacters, 0> GFXPlayer;
#define GFXPlayer GFXPlayerBMP
//Public GFXPlayerMask(1 To numCharacters) As Long
//extern RangeArrI<long, 1, numCharacters, 0> GFXPlayerMask;
//Public GFXPlayerBMP(1 To numCharacters) As StdPicture
extern RangeArr<StdPicture, 1, numCharacters> GFXPlayerBMP;
//Public GFXPlayerMaskBMP(1 To numCharacters) As StdPicture
//extern RangeArr<StdPicture, 1, numCharacters> GFXPlayerMaskBMP;
//Public GFXPlayerHeight(1 To numCharacters) As Integer
// extern RangeArrI<vbint_t, 1, numCharacters, 0> GFXPlayerHeight;
//Public GFXPlayerWidth(1 To numCharacters) As Integer
// extern RangeArrI<vbint_t, 1, numCharacters, 0> GFXPlayerWidth;

//Public PlayerCharacter As Integer
// extern int PlayerCharacter;
//Public PlayerCharacter2 As Integer
// extern int PlayerCharacter2;

// replaced with SharedCursor.*

//Public MenuMouseX As Double
// extern double MenuMouseX;
//Public MenuMouseY As Double
// extern double MenuMouseY;
//! mouse wheel delta
// extern Sint32 MenuWheelDelta;
//! mouse wheel event
// extern bool MenuWheelMoved;
//Public MenuMouseDown As Boolean
// extern bool MenuMouseDown;
//Public MenuMouseBack As Boolean
// extern bool MenuMouseBack;
//Public MenuMouseMove As Boolean
// extern bool MenuMouseMove;

// these are preserved because they keep track of the specific frame
//   that the mouse is clicked / released

//Public MenuMouseRelease As Boolean
extern bool MenuMouseRelease;
//Public MenuMouseClick As Boolean
extern bool MenuMouseClick;

//' event stuff
// Moved into "layers.h"

//Public ForcedControls As Boolean
extern bool ForcedControls;
//Public ForcedControl As Controls
extern Controls_t ForcedControl;
//Public SyncCount As Integer
// extern int SyncCount;
//Public noUpdate As Boolean
// extern bool noUpdate;
//Public gameTime As Double
//extern double gameTime;

// deprecated by g_config.audio_enable
//Public noSound As Boolean
//extern bool noSound;

//extern bool neverPause;
//Public tempTime As Double
//extern double tempTime;
//Dim ScrollDelay As Integer [in main.cpp]
//'battlemode stuff
//Public BattleMode As Boolean
extern bool BattleMode;
//Public BattleWinner As Integer
extern int BattleWinner;
//Public BattleLives(1 To maxPlayers) As Integer
extern RangeArrI<int, 1, maxPlayers, 0> BattleLives;
//Public BattleIntro As Integer
extern int BattleIntro;
//Public BattleOutro As Integer
extern int BattleOutro;
//Public LevelName As String
extern std::string LevelName;
//Public Const curRelease As Integer = 64
const int curRelease = 64;

//EXTRA: Language
extern std::string CurrentLanguage;
extern std::string CurrentLangDialect;

#ifdef __WIIU__
extern bool g_isHBLauncher;
#endif

#endif // GLOBALS_H


================================================
FILE: src/graphics/gfx_background.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#include "../globals.h"
#include "../graphics.h"
#include "../collision.h"
#include "../core/render.h"
#include "config.h"

void DrawBackgroundColor(int A, int Z, bool lower = false)
{
    XRender::lazyPreLoad(GFXBackground2[A]);
    if(lower)
    {
        XRender::renderRect(0, 0, vScreen[Z].Width, vScreen[Z].Height,
            GFXBackground2[A].ColorLower);
    }
    else
    {
        XRender::renderRect(0, 0, vScreen[Z].Width, vScreen[Z].Height,
            GFXBackground2[A].ColorUpper);
    }
}

// draws backgrounds _, _, _, _, _
void DrawTopAnchoredBackground(int S, int Z, int A, int offset = 32, int expected_height = 0, int tile_bottom = 0, int h_num = 2)
{
    DrawBackgroundColor(A, Z, true);
    int camX = vScreen[Z].CameraAddX_i();
    int camY = vScreen[Z].CameraAddY_i();

    const auto& sect = LevelREAL[S];
    int levelX = sect.X;

    int camX_levelX = camX + levelX;
    int Left = vScreen[Z].Left;
    int offsetX = (camX_levelX * (4 - h_num) - Left * h_num) / 4;

    int offsetY = sect.Y - offset + camY;
    if(GameMenu && offsetY > 0)
        offsetY = 0;

    for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
    {
        if(offsetX + GFXBackground2[A].w <= 0)
            continue;

        int drawH = GFXBackground2[A].h;
        int offsetY_i = offsetY;

        while(offsetY_i < vScreen[Z].Height)
        {
            XRender::renderTextureBasic(offsetX, offsetY_i,
                GFXBackground2[A].w, drawH, GFXBackground2[A], 0, GFXBackground2[A].h - drawH);

            if(g_config.disable_background2_tiling)
                break;

            if(expected_height != 0 && GFXBackground2[A].h != expected_height)
                break;

            offsetY_i += drawH;

            if(tile_bottom != 0)
            {
                if(GFXBackground2[A].h != expected_height)
                    break;
                drawH = tile_bottom;
            }
        }
    }
}

void DrawCenterAnchoredBackground(int S, int Z, int A, int expected_height = 0, int tile_bottom = 0, int tile_top = 0, bool flip_tile = false, int h_num = 2, bool anim = false)
{
    const auto& sect = LevelREAL[S];
    const Screen_t& screen = Screens[vScreen[Z].screen_ref];
    int camX = vScreen[Z].CameraAddX_i();
    int camY = vScreen[Z].CameraAddY_i();

    int Eff_ScreenH = vScreen[Z].Height;
    int Eff_Top = 0;
    if(screen.Type == ScreenTypes::Dynamic)
    {
        Eff_Top = vScreen[Z].Top;
        Eff_ScreenH = 0;
        for(int i = screen.active_begin(); i < screen.active_end(); i++)
        {
            const auto& s = screen.vScreen(i + 1);
            if(s.Left == vScreen[Z].Left)
                Eff_ScreenH += s.Height;
        }
    }

    bool no_tiling = g_config.disable_background2_tiling;
    if((tile_bottom != 0 || tile_top != 0 || expected_height != 0) && GFXBackground2[A].h != expected_height)
    {
        // HACK: don't cancel the tiling if we have the slightly incorrect original asset
        if(!(A == 42 && GFXBackground2[A].h == expected_height - 1))
            no_tiling = true;
    }

    int frameH = GFXBackground2[A].h;
    // HACK: align non-rounded pictures (there was Redigit's original with the 3455 pixels height,
    // but it must be 3456. There are lot of custom resources that using the 3455 height by mistake)
    // in the original image, the fourth frame is missing its top line.
    if(A == 42 && GFXBackground2[A].h == expected_height - 1 && anim)
    {
        frameH = expected_height / 4;
    }
    else if(anim)
    {
        frameH = GFXBackground2[A].h / 4;
    }

    int CanvasH = frameH;
    int CanvasOffset = 0;

    // ensure that the canvas covers above and below the screen
    if(Eff_ScreenH > CanvasH)
    {
        CanvasOffset = Eff_ScreenH - CanvasH;
        CanvasH += CanvasOffset * 2;
    }

    TinyLocation_t tempLocation;

    int camX_levelX = camX + sect.X;
    int Left = vScreen[Z].Left;

    int offsetX = (camX_levelX * (4 - h_num) - Left * h_num) / 4;

    for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
    {
        if(offsetX + GFXBackground2[A].w <= 0)
            continue;

        tempLocation.Width = GFXBackground2[A].w;
        tempLocation.Height = frameH;

        tempLocation.X = offsetX;
        if(sect.Height - sect.Y > CanvasH)
        {
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - (600 - vScreen(Z).Top)) * (GFXBackground2Height(A) / 4 - (600 - vScreen(Z).Top))
            // .Y = -vScreenY(Z) - .Y
            tempLocation.Y = (-camY - Eff_Top - sect.Y) * (CanvasH - Eff_ScreenH) / (sect.Height - sect.Y - Eff_ScreenH) + Eff_Top;
            tempLocation.Y = -camY - tempLocation.Y;
            tempLocation.Y += CanvasOffset;
        }
        else if(CanvasH > frameH)
        {
            tempLocation.Y = sect.Y + (sect.Height - sect.Y - frameH) / 2;
        }
        else
            tempLocation.Y = sect.Height - frameH;

        int bottom_Y = tempLocation.Y + frameH;
        unsigned int flip = X_FLIP_NONE;
        while(tempLocation.Y + tempLocation.Height > -camY)
        {
            // HACK: place the fourth frame in the correct location if we are missing a single line
            if(A == 42 && GFXBackground2[A].h == expected_height - 1 && anim && SpecialFrame[3] == 3)
            {
                // duplicate the line
                XRender::renderTextureScaleEx(tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, 1,
                    GFXBackground2[A],
                    0, frameH * SpecialFrame[3],
                    GFXBackground2[A].w, 1,
                    0, nullptr, flip);
                // draw the frame
                XRender::renderTextureScaleEx(tempLocation.X, camY + tempLocation.Y + 1,
                    GFXBackground2[A].w, tempLocation.Height - 1,
                    GFXBackground2[A],
                    0, frameH * SpecialFrame[3],
                    GFXBackground2[A].w, tempLocation.Height - 1,
                    0, nullptr, flip);
            }
            else if(anim)
            {
                XRender::renderTextureScaleEx(tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, tempLocation.Height,
                    GFXBackground2[A],
                    0, frameH * SpecialFrame[3],
                    GFXBackground2[A].w, tempLocation.Height,
                    0, nullptr, flip);
            }
            else
            {
                XRender::renderTextureScaleEx(tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, tempLocation.Height,
                    GFXBackground2[A],
                    0, 0,
                    GFXBackground2[A].w, tempLocation.Height,
                    0, nullptr, flip);
            }

            if(no_tiling)
                break;

            if(tile_top != 0)
                tempLocation.Height = tile_top;

            tempLocation.Y -= tempLocation.Height;
            if(flip_tile)
                flip ^= X_FLIP_VERTICAL;
        }

        if(no_tiling)
            continue;

        tempLocation.Y = bottom_Y;
        if(tile_bottom != 0)
            tempLocation.Height = tile_bottom;
        else
            tempLocation.Height = frameH;

        if(flip_tile)
            flip = X_FLIP_VERTICAL;

        while(tempLocation.Y < -camY + vScreen[Z].Height)
        {
            // HACK: use the smaller frame size if we are missing a single line
            if(A == 42 && GFXBackground2[A].h == expected_height - 1 && anim && SpecialFrame[3] == 3)
            {
                XRender::renderTextureScaleEx(tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, tempLocation.Height,
                    GFXBackground2[A],
                    0, frameH * SpecialFrame[3] + (frameH - 1) - tempLocation.Height,
                    GFXBackground2[A].w, tempLocation.Height,
                    0, nullptr, flip);
            }
            else if(anim)
            {
                XRender::renderTextureScaleEx(tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, tempLocation.Height,
                    GFXBackground2[A],
                    0, frameH * SpecialFrame[3] + frameH - tempLocation.Height,
                    GFXBackground2[A].w, tempLocation.Height,
                    0, nullptr, flip);
            }
            else
            {
                XRender::renderTextureScaleEx(tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, tempLocation.Height,
                    GFXBackground2[A],
                    0, frameH - tempLocation.Height,
                    GFXBackground2[A].w, tempLocation.Height,
                    0, nullptr, flip);
            }

            tempLocation.Y += tempLocation.Height;
            if(flip_tile)
                flip ^= X_FLIP_VERTICAL;
        }
    }

    // use the remaining information from the tempLocation (Y and Height, never tiled)
    if(no_tiling)
    {
        int undrawn_above = tempLocation.Y + camY;
        int undrawn_below = tempLocation.Y + camY + tempLocation.Height;
        XRender::renderRect(0, 0, vScreen[Z].Width, undrawn_above,
            GFXBackground2[A].ColorUpper);
        XRender::renderRect(0, undrawn_below, vScreen[Z].Width, vScreen[Z].Height - undrawn_below + 1,
            GFXBackground2[A].ColorLower);
    }
}

void DrawBottomAnchoredBackground(int S, int Z, int A, int offset = 0, int expected_height = 0, int tile_top = 0, int h_parallax_num = 2, bool no_bg = false, bool anim = false)
{
    const auto& sect = LevelREAL[S];
    const Screen_t& screen = Screens[vScreen[Z].screen_ref];
    int camX = vScreen[Z].CameraAddX_i();
    int camY = vScreen[Z].CameraAddY_i();

    if(!no_bg)
        DrawBackgroundColor(A, Z, false);

    int frameH = GFXBackground2[A].h;
    if(anim)
        frameH = GFXBackground2[A].h / 4;

    TinyLocation_t tempLocation;

    int horiz_reps = ((sect.Width - sect.X) * h_parallax_num / 4 + screen.W) / GFXBackground2[A].w + 1;
    for(int B = 0; B <= horiz_reps; B++)
    {
        tempLocation.X = sect.X + ((B * GFXBackground2[A].w) - (camX + vScreen[Z].Left + sect.X) * h_parallax_num / 4);
        tempLocation.Y = sect.Height - frameH - offset;

        tempLocation.Height = frameH;
        tempLocation.Width = GFXBackground2[A].w;

        if(vScreenCollision(Z, tempLocation))
        {
            if(anim)
            {
                XRender::renderTextureBasic(camX + tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, tempLocation.Height,
                    GFXBackground2[A], 0, frameH * SpecialFrame[3]);
            }
            else
            {
                XRender::renderTextureBasic(camX + tempLocation.X, camY + tempLocation.Y,
                    GFXBackground2[A].w, tempLocation.Height,
                    GFXBackground2[A], 0, 0);
            }
        }

        if(g_config.disable_background2_tiling)
            continue;

        if(expected_height != 0 && GFXBackground2[A].h != expected_height)
            continue;

        if(tile_top != 0 && GFXBackground2[A].h != expected_height)
            continue;

        if(tile_top != 0)
            tempLocation.Height = tile_top;

        while(tempLocation.Y > sect.Y || tempLocation.Y > -camY)
        {
            tempLocation.Y -= tempLocation.Height;
            if(vScreenCollision(Z, tempLocation))
            {
                if(anim)
                {
                    XRender::renderTextureBasic(camX + tempLocation.X, camY + tempLocation.Y,
                        GFXBackground2[A].w, tempLocation.Height,
                        GFXBackground2[A], 0, frameH * SpecialFrame[3]);
                }
                else
                {
                    XRender::renderTextureBasic(camX + tempLocation.X, camY + tempLocation.Y,
                        GFXBackground2[A].w, tempLocation.Height,
                        GFXBackground2[A], 0, 0);
                }
            }
        }
    }
}

static void DrawYTiledBackground(int off_x, int off_y, int vscreen_w, int vscreen_h, StdPicture& tx)
{
    off_x %= tx.w;
    off_y %= tx.h;

    if(off_x > 0)
        off_x -= tx.w;
    if(off_y > 0)
        off_y -= tx.h;

    // Fixed an SMBX 1.3 peculiarity -- this was previously -1 rather than force-to-even
    int stride_y = tx.h & ~1;

    for(; off_y < vscreen_h; off_y += stride_y)
    {
        for(int off_x_i = off_x; off_x_i < vscreen_w; off_x_i += tx.w)
            XRender::renderTextureBasic(off_x_i, off_y, tx);
    }
}

void DrawBackground(int S, int Z)
{
    const Screen_t& screen = Screens[vScreen[Z].screen_ref];
    int camX = vScreen[Z].CameraAddX_i();
    int camY = vScreen[Z].CameraAddY_i();

    int Left = vScreen[Z].Left;

    int A = 0;

    const auto& sect = LevelREAL[S];

    int camX_levelX = camX + sect.X;

    int Eff_ScreenH = vScreen[Z].Height;
    int Eff_Top = 0;

    if(screen.Type == ScreenTypes::Dynamic)
    {
        Eff_Top = vScreen[Z].Top;
        Eff_ScreenH = 0;

        for(int i = screen.active_begin(); i < screen.active_end(); i++)
        {
            const auto& s = screen.vScreen(i + 1);
            if(s.Left == vScreen[Z].Left)
                Eff_ScreenH += s.Height;
        }
    }

    if(Background2[S] == 0)
        XRender::renderRect(0, 0, vScreen[Z].Width, vScreen[Z].Height, {0, 0, 0});

    A = 2; // Clouds
    if(Background2[S] == 1 || Background2[S] == 2 || Background2[S] == 22)
    {
        DrawBottomAnchoredBackground(S, Z, A, 500, 0, 0, 3);
    }

    if(Background2[S] == 13)
    {
        DrawCenterAnchoredBackground(S, Z, A, 0, 0, 0, false, 3);
    }

    A = 1; // Blocks
    if(Background2[S] == 1)
    {
        DrawBottomAnchoredBackground(S, Z, A, 0, -1, 0, 2, true);
    }

    A = 3; // Hills
    if(Background2[S] == 2)
    {
        DrawBottomAnchoredBackground(S, Z, A, 0, -1, 0, 2, true);
    }

    A = 4; // Castle
    if(Background2[S] == 3)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 5; // Pipes
    if(Background2[S] == 4)
    {
        int Eff_Top = 0;
        if(screen.Type == ScreenTypes::Dynamic)
            Eff_Top = vScreen[Z].Top;

        int off_y = camY + sect.Y - (camY + Eff_Top + sect.Y) / 2 - 32;
        int off_x = sect.Width - GFXBackground2[A].w;

        if(sect.Width - sect.X > GFXBackground2[A].w)
        {
            off_x = (-camX - sect.X - vScreen[Z].Left) * (GFXBackground2[A].w - 800) / (sect.Width - sect.X - 800) + vScreen[Z].Left;
            off_x = -off_x;
        }

        DrawYTiledBackground(off_x, off_y, vScreen[Z].Width, vScreen[Z].Height, GFXBackground2[A]);
    }

    A = 6; // Trees
    if(Background2[S] == 5)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 7; // Bonus
    if(Background2[S] == 6)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 8; // SMB Underground
    if(Background2[S] == 7)
    {
        DrawTopAnchoredBackground(S, Z, A);
    }

    A = 9; // Night
    if(Background2[S] == 8 || Background2[S] == 9)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1, 0, 0, false, 3);
    }

    A = 10; // Night 2
    if(Background2[S] == 9)
    {
        DrawBottomAnchoredBackground(S, Z, A, 0, -1, 0, 2, true);
    }

    A = 11; // Overworld
    if(Background2[S] == 10)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 12; // SMW Hills
    if(Background2[S] == 11)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 13; // SMW Trees
    if(Background2[S] == 12)
    {
        DrawCenterAnchoredBackground(S, Z, A, 800, 0, 0, true);
    }

    A = 14; // SMB3 Desert
    if(Background2[S] == 14)
    {
        // could possibly tile
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 15; // SMB3 Dungeon
    if(Background2[S] == 15)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 16; // Crateria
    if(Background2[S] == 16)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 17; // smb3 ship
    if(Background2[S] == 17)
    {
        // top segment is 254px tall
        DrawTopAnchoredBackground(S, Z, A, 32, 858, 858-254);
    }

    A = 18; // SMW ghost house
    if(Background2[S] == 18)
    {
        DrawCenterAnchoredBackground(S, Z, A, 0, 0, 0, false, 2, true);
    }

    A = 19; // smw forest
    if(Background2[S] == 19)
    {
        DrawCenterAnchoredBackground(S, Z, A, 1200, 0, 0, true);
    }

    A = 20; // smb3 forest
    if(Background2[S] == 20)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 21; // smb3 battle game
    if(Background2[S] == 21)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 22; // SMB3 Waterfall
    if(Background2[S] == 22)
    {
        DrawBottomAnchoredBackground(S, Z, A, 0, -1, 0, 2, true, true);
    }

    A = 23; // SMB3 Tank
    if(Background2[S] == 23)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 24; // smb3 bowsers castle
    if(Background2[S] == 24)
    {
        DrawTopAnchoredBackground(S, Z, A, 32, 1504, 384);
    }

    A = 25; // SMB2 Underground
    if(Background2[S] == 25)
    {
        int Eff_Top = 0;
        if(screen.Type == ScreenTypes::Dynamic)
            Eff_Top = vScreen[Z].Top;

        int off_y = camY + sect.Y - (camY + Eff_Top + sect.Y) / 2 - 32;
        int off_x = sect.Width - GFXBackground2[A].w;

        if(sect.Width - sect.X > GFXBackground2[A].w)
        {
            int32_t sect_off_x = sect.Width - sect.X - 800;
            off_x = (sect_off_x == 0 ? 0 : (-camX - sect.X - vScreen[Z].Left) * (GFXBackground2[A].w - 800) / sect_off_x) + vScreen[Z].Left;
            off_x = -off_x;
        }

        DrawYTiledBackground(off_x, off_y, vScreen[Z].Width, vScreen[Z].Height, GFXBackground2[A]);
    }

    A = 26; // Toad's House
    if(Background2[S] == 26)
    {
        // top segment is 244px tall
        DrawTopAnchoredBackground(S, Z, A, 32, 1396, 1396-244);
    }

    A = 27; // SMB3 Castle
    if(Background2[S] == 27)
    {
        // can be tiled; top section is 1000px
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 28; // SMW Bonus
    if(Background2[S] == 28)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 29; // SMW Night
    if(Background2[S] == 29)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1, 0, 0, false, 2, true);
    }

    A = 30; // SMW Cave
    if(Background2[S] == 30)
    {
        DrawCenterAnchoredBackground(S, Z, A, 3456, 0, 0, true, 2, true);
    }

    A = 31; // SMW Hills 2
    if(Background2[S] == 31)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 32; // SMW Clouds
    if(Background2[S] == 32)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 33; // SMW Snow
    if(Background2[S] == 33)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 34; // SMW Hills 3
    if(Background2[S] == 34)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 36; // Snow Clouds
    if(Background2[S] == 35 || Background2[S] == 37)
    {
        DrawBottomAnchoredBackground(S, Z, A, 500, 0, 0, 3);
    }

    if(Background2[S] == 36)
    {
        DrawCenterAnchoredBackground(S, Z, A, 0, 0, 0, false, 3);
    }

    A = 35; // SMB 3 Snow Trees
    if(Background2[S] == 35)
    {
        DrawBottomAnchoredBackground(S, Z, A, 0, -1, 0, 2, true);
    }

    A = 37; // SMB 3 Snow Hills
    if(Background2[S] == 37)
    {
        DrawBottomAnchoredBackground(S, Z, A, 0, -1, 0, 2, true);
    }

    A = 38; // SMB3 Cave with Sky
    if(Background2[S] == 38)
    {
        // each of the lower cave segments are 428px
        DrawTopAnchoredBackground(S, Z, A, 20, 1500, 428*2);
    }

    A = 39; // SMB3 Cave no Sky
    if(Background2[S] == 39)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 40; // Mystic Cave Zone
    if(Background2[S] == 40)
    {
        if(g_config.disable_background2_tiling)
        {
            XRender::lazyPreLoad(GFXBackground2[A]);
            XRender::renderRect(0, 0, vScreen[Z].Width, vScreen[Z].Height,
                GFXBackground2[A].ColorUpper);
        }

        int offsetY = 0;

        if(Eff_ScreenH > GFXBackground2[A].h)
        {
            offsetY = Eff_ScreenH - GFXBackground2[A].h + (sect.Height + camY + Eff_Top - Eff_ScreenH) / 2 - Eff_Top;
        }
        else if(sect.Height - sect.Y > GFXBackground2[A].h)
        {
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - (screen.H - vScreen(Z).Top)) * (GFXBackground2Height(A) - (screen.H - vScreen(Z).Top))
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - 600) * (GFXBackground2Height(A) - 600)
            offsetY = (camY + Eff_Top + sect.Y) * (GFXBackground2[A].h - Eff_ScreenH) / (sect.Height - sect.Y - Eff_ScreenH) - Eff_Top;
        }
        else
        {
            offsetY = sect.Height + camY - GFXBackground2[A].h;
        }

        do
        {
            int offsetX = (camX_levelX * 1 - Left * 1) / 2;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 953, GFXBackground2[A].w, 47, GFXBackground2[A], 0, 953);
            }

            offsetX = (camX_levelX * 4 - Left * 6) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 916, GFXBackground2[A].w, 37, GFXBackground2[A], 0, 916);
            }

            offsetX = (camX_levelX * 3 - Left * 7) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 849, GFXBackground2[A].w, 67, GFXBackground2[A], 0, 849);
            }

            offsetX = (camX_levelX * 2 - Left * 8) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 815, GFXBackground2[A].w, 34, GFXBackground2[A], 0, 815);
            }

            offsetX = (camX_levelX * 1 - Left * 9) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 709, GFXBackground2[A].w, 106, GFXBackground2[A], 0, 709);
            }

            offsetX = (camX_levelX * 15 - Left * 85) / 100;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 664, GFXBackground2[A].w, 45, GFXBackground2[A], 0, 664);
            }

            offsetX = (camX_levelX * 2 - Left * 8) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 614, GFXBackground2[A].w, 50, GFXBackground2[A], 0, 614);
            }

            offsetX = (camX_levelX * 25 - Left * 75) / 100;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 540, GFXBackground2[A].w, 74, GFXBackground2[A], 0, 540);
            }

            offsetX = (camX_levelX * 3 - Left * 7) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 408, GFXBackground2[A].w, 132, GFXBackground2[A], 0, 408);
            }

            offsetX = (camX_levelX * 25 - Left * 75) / 100;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 333, GFXBackground2[A].w, 75, GFXBackground2[A], 0, 333);
            }

            offsetX = (camX_levelX * 2 - Left * 8) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 278, GFXBackground2[A].w, 55, GFXBackground2[A], 0, 278);
            }

            offsetX = (camX_levelX * 15 - Left * 85) / 100;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 235, GFXBackground2[A].w, 43, GFXBackground2[A], 0, 235);
            }

            offsetX = (camX_levelX * 1 - Left * 9) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 123, GFXBackground2[A].w, 112, GFXBackground2[A], 0, 123);
            }

            offsetX = (camX_levelX * 2 - Left * 8) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 85, GFXBackground2[A].w, 38, GFXBackground2[A], 0, 85);
            }

            offsetX = (camX_levelX * 3 - Left * 7) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 48, GFXBackground2[A].w, 37, GFXBackground2[A], 0, 48);
            }

            offsetX = (camX_levelX * 4 - Left * 6) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 0, GFXBackground2[A].w, 48, GFXBackground2[A], 0, 0);
            }

            offsetY -= GFXBackground2[A].h;

            if(g_config.disable_background2_tiling)
                break;

        } while(offsetY + GFXBackground2[A].h > 0);
    }

    A = 41; // SMB 1 Castle
    if(Background2[S] == 41)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 42; // SMW Castle
    if(Background2[S] == 42)
    {
        // safe to tile top 546px and bottom 160px of vanilla asset
        DrawCenterAnchoredBackground(S, Z, A, 3456, 160, 546, false, 2, true);
    }

    A = 43; // SMW Castle 2
    if(Background2[S] == 43)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 44; // SMB2 Castle
    if(Background2[S] == 44)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 45; // Brinstar
    if(Background2[S] == 45)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 46; // Transport
    if(Background2[S] == 46)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 47; // Transport
    if(Background2[S] == 47)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 48; // SMB2 Blouds
    if(Background2[S] == 48)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 49; // Desert Night
    if(Background2[S] == 49)
    {
        int CanvasH = GFXBackground2[A].h;
        int CanvasOffset = 0;

        // ensure that the canvas covers above and below the screen
        if(Eff_ScreenH > CanvasH)
        {
            CanvasOffset = Eff_ScreenH - CanvasH;
            CanvasH += CanvasOffset * 2;
        }

        int offsetY = 0;

        if(sect.Height - sect.Y > CanvasH)
        {
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - 600) * (GFXBackground2Height(A) - 600)
            offsetY = (-camY - Eff_Top - sect.Y) * (CanvasH - Eff_ScreenH) / (sect.Height - sect.Y - Eff_ScreenH) + Eff_Top;
            offsetY = -offsetY;
            offsetY += CanvasOffset;
        }
        else if(CanvasH > GFXBackground2[A].h)
        {
            offsetY = camY + sect.Y + (sect.Height - sect.Y - GFXBackground2[A].h) / 2;
        }
        else
            offsetY = camY + sect.Height - GFXBackground2[A].h;

        // use a simple color fill for the sky above and sand below the texture
        XRender::lazyPreLoad(GFXBackground2[A]);
        int undrawn_above = offsetY;
        int undrawn_below = offsetY + GFXBackground2[A].h;
        XRender::renderRect(0, 0, vScreen[Z].Width, std::ceil(undrawn_above),
            GFXBackground2[A].ColorUpper);
        XRender::renderRect(0, undrawn_below, vScreen[Z].Width, vScreen[Z].Height - undrawn_below + 1,
            GFXBackground2[A].ColorLower);

        int offsetX = (camX_levelX * 1 - Left * 1) / 2;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 280, GFXBackground2[A].w, 450, GFXBackground2[A], 0, 280);
        }

        offsetX = (camX_levelX * 1 - Left * 9) / 10;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 268, GFXBackground2[A].w, 12, GFXBackground2[A], 0, 268);
        }

        offsetX = (camX_levelX * 11 - Left * 89) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 244, GFXBackground2[A].w, 24, GFXBackground2[A], 0, 244);
        }

        offsetX = (camX_levelX * 12 - Left * 88) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 228, GFXBackground2[A].w, 16, GFXBackground2[A], 0, 228);
        }

        offsetX = (camX_levelX * 13 - Left * 87) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 196, GFXBackground2[A].w, 32, GFXBackground2[A], 0, 196);
        }

        offsetX = (camX_levelX * 14 - Left * 86) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 164, GFXBackground2[A].w, 32, GFXBackground2[A], 0, 164);
        }

        offsetX = (camX_levelX * 15 - Left * 85) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 116, GFXBackground2[A].w, 48, GFXBackground2[A], 0, 116);
        }

        offsetX = (camX_levelX * 16 - Left * 84) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 58, GFXBackground2[A].w, 58, GFXBackground2[A], 0, 58);
        }

        offsetX = (camX_levelX * 17 - Left * 83) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 0, GFXBackground2[A].w, 58, GFXBackground2[A], 0, 0);
        }
    }

    A = 50; // Shrooms
    if(Background2[S] == 50)
    {
        XRender::lazyPreLoad(GFXBackground2[A]);
        XRender::renderRect(0, 0, vScreen[Z].Width, vScreen[Z].Height,
            GFXBackground2[A].ColorLower);

        int CanvasH = GFXBackground2[A].h;
        int CanvasOffset = 0;

        // ensure that the canvas covers above and below the screen
        if(Eff_ScreenH > CanvasH)
        {
            CanvasOffset = (Eff_ScreenH - CanvasH) * 3 / 2;
            CanvasH += CanvasOffset;
        }

        int offsetY = 0;

        if(sect.Height - sect.Y > CanvasH)
        {
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - 600) * (GFXBackground2Height(A) - 600)
            offsetY = (-camY - Eff_Top - sect.Y) * (CanvasH - Eff_ScreenH) / (sect.Height - sect.Y - Eff_ScreenH) + Eff_Top;
            offsetY = -offsetY;
            offsetY += CanvasOffset;
        }
        else
            offsetY = camY + sect.Height - GFXBackground2[A].h;

        int offsetX = (camX_levelX - Left) / 2;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 378, GFXBackground2[A].w, 378, GFXBackground2[A], 0, 378);
        }

        while(offsetY > -378)
        {
            offsetX = (camX_levelX * 35 - Left * 65) / 100;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY, GFXBackground2[A].w, 220, GFXBackground2[A], 0, 0);
            }

            offsetX = (camX_levelX * 4 - Left * 6) / 10;
            for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
            {
                if(offsetX + GFXBackground2[A].w <= 0)
                    continue;

                XRender::renderTextureBasic(offsetX, offsetY + 220, GFXBackground2[A].w, 158, GFXBackground2[A], 0, 220);
            }

            offsetY -= 378;

            if(g_config.disable_background2_tiling)
                break;
        }
    }

    A = 51; // SMB1 Desert
    if(Background2[S] == 51)
    {
        int CanvasH = GFXBackground2[A].h;
        int CanvasOffset = 0;

        // ensure that the canvas covers above and below the screen
        if(Eff_ScreenH > CanvasH)
        {
            CanvasOffset = 0;
            CanvasH += (Eff_ScreenH - CanvasH);
        }

        int offsetY = 0;

        if(sect.Height - sect.Y > CanvasH)
        {
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - 600) * (GFXBackground2Height(A) - 600)
            offsetY = (-camY - Eff_Top - sect.Y) * (CanvasH - Eff_ScreenH) / (sect.Height - sect.Y - Eff_ScreenH) + Eff_Top;
            offsetY = -offsetY;
            offsetY += CanvasOffset;
        }
        else if(CanvasH > GFXBackground2[A].h)
        {
            offsetY = camY + sect.Y + (sect.Height - sect.Y - GFXBackground2[A].h) / 2;
        }
        else
            offsetY = camY + sect.Height - GFXBackground2[A].h;

        // use a simple color fill for the sky above and sand below the texture
        XRender::lazyPreLoad(GFXBackground2[A]);
        int undrawn_above = offsetY;
        int undrawn_below = offsetY + GFXBackground2[A].h;
        XRender::renderRect(0, 0, vScreen[Z].Width, undrawn_above,
            GFXBackground2[A].ColorUpper);
        XRender::renderRect(0, undrawn_below, vScreen[Z].Width, vScreen[Z].Height - undrawn_below + 1,
            GFXBackground2[A].ColorLower);

        int offsetX = (camX_levelX - Left * 3) / 4;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY, GFXBackground2[A].w, 350, GFXBackground2[A], 0, 0);
        }

        offsetX = (camX_levelX - Left) / 2;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 350, GFXBackground2[A].w, GFXBackground2[A].h - 350, GFXBackground2[A], 0, 350);
        }
    }

    A = 52; // SMB2 Desert Night
    if(Background2[S] == 52)
    {
        int CanvasH = GFXBackground2[A].h;
        int CanvasOffset = 0;

        // ensure that the canvas covers above and below the screen
        if(Eff_ScreenH > CanvasH)
        {
            CanvasOffset = (Eff_ScreenH - CanvasH) * 3 / 2;
            CanvasH += CanvasOffset;
        }

        int offsetY = 0;

        if(sect.Height - sect.Y > CanvasH)
        {
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - 600) * (GFXBackground2Height(A) - 600)
            offsetY = (-camY - Eff_Top - sect.Y) * (CanvasH - Eff_ScreenH) / (sect.Height - sect.Y - Eff_ScreenH) + Eff_Top;
            offsetY = -offsetY;
            offsetY += CanvasOffset;
        }
        else if(CanvasH > GFXBackground2[A].h)
        {
            offsetY = camY + sect.Y + (sect.Height - sect.Y - GFXBackground2[A].h) / 2;
        }
        else
            offsetY = camY + sect.Height - GFXBackground2[A].h;


        // use a simple color fill for the sky above and sand below the texture
        XRender::lazyPreLoad(GFXBackground2[A]);
        int undrawn_above = offsetY;
        int undrawn_below = offsetY + GFXBackground2[A].h;
        XRender::renderRect(0, 0, vScreen[Z].Width, undrawn_above,
            GFXBackground2[A].ColorUpper);
        XRender::renderRect(0, undrawn_below, vScreen[Z].Width, vScreen[Z].Height - undrawn_below + 1,
            GFXBackground2[A].ColorLower);

        int offsetX = (camX_levelX * 1 - Left * 1) / 2;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 280, GFXBackground2[A].w, GFXBackground2[A].h - 280, GFXBackground2[A], 0, 280);
        }

        offsetX = (camX_levelX * 1 - Left * 9) / 10;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 268, GFXBackground2[A].w, 12, GFXBackground2[A], 0, 268);
        }

        offsetX = (camX_levelX * 11 - Left * 89) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 244, GFXBackground2[A].w, 24, GFXBackground2[A], 0, 244);
        }

        offsetX = (camX_levelX * 12 - Left * 88) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 228, GFXBackground2[A].w, 16, GFXBackground2[A], 0, 228);
        }

        offsetX = (camX_levelX * 13 - Left * 87) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 196, GFXBackground2[A].w, 32, GFXBackground2[A], 0, 196);
        }

        offsetX = (camX_levelX * 14 - Left * 86) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 164, GFXBackground2[A].w, 32, GFXBackground2[A], 0, 164);
        }

        offsetX = (camX_levelX * 15 - Left * 85) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 116, GFXBackground2[A].w, 48, GFXBackground2[A], 0, 116);
        }

        offsetX = (camX_levelX * 16 - Left * 84) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 58, GFXBackground2[A].w, 58, GFXBackground2[A], 0, 58);
        }

        offsetX = (camX_levelX * 17 - Left * 83) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 0, GFXBackground2[A].w, 58, GFXBackground2[A], 0, 0);
        }
    }

    A = 53; // Cliffs
    if(Background2[S] == 53)
    {
        DrawCenterAnchoredBackground(S, Z, A, -1);
    }

    A = 54; // Warehouse
    if(Background2[S] == 54)
    {
        DrawCenterAnchoredBackground(S, Z, A);
    }

    A = 55; // SMW Water
    if(Background2[S] == 55)
    {
        DrawCenterAnchoredBackground(S, Z, A, 0, 0, 0, false, 2, true);
    }

    A = 56; // SMB3 Water
    if(Background2[S] == 56)
    {
        int CanvasH = GFXBackground2[A].h;
        int CanvasOffset = 0;

        // ensure that the canvas covers above and below the screen
        if(Eff_ScreenH > CanvasH)
        {
            CanvasOffset = (Eff_ScreenH - CanvasH) * 3 / 2;
            CanvasH += CanvasOffset;
        }

        int offsetY = 0;

        if(sect.Height - sect.Y > CanvasH)
        {
            // .Y = (-vScreenY(Z) - level(S).Y) / (level(S).Height - level(S).Y - 600) * (GFXBackground2Height(A) - 600)
            offsetY = (-camY - Eff_Top - sect.Y) * (CanvasH - Eff_ScreenH) / (sect.Height - sect.Y - Eff_ScreenH) + Eff_Top;
            offsetY = -offsetY;
            offsetY += CanvasOffset;
        }
        else if(CanvasH > GFXBackground2[A].h)
        {
            offsetY = camY + sect.Y + (sect.Height - sect.Y - GFXBackground2[A].h) / 2;
        }
        else
            offsetY = camY + sect.Height - GFXBackground2[A].h;

        // use a simple color fill for the water above and below the texture
        XRender::lazyPreLoad(GFXBackground2[A]);
        int undrawn_above = offsetY;
        int undrawn_below = offsetY + GFXBackground2[A].h;
        XRender::renderRect(0, 0, vScreen[Z].Width, undrawn_above,
            GFXBackground2[A].ColorUpper);
        XRender::renderRect(0, undrawn_below, vScreen[Z].Width, vScreen[Z].Height - undrawn_below + 1,
            GFXBackground2[A].ColorLower);

        int offsetX = (camX_levelX * 35 - Left * 65) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY, GFXBackground2[A].w, 100, GFXBackground2[A], 0, 0);
        }

        offsetX = (camX_levelX * 4 - Left * 6) / 10;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 100, GFXBackground2[A].w, 245, GFXBackground2[A], 0, 100);
        }

        offsetX = (camX_levelX * 45 - Left * 55) / 100;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 345, GFXBackground2[A].w, 110, GFXBackground2[A], 0, 345);
        }

        offsetX = (camX_levelX * 5 - Left * 5) / 10;
        for(; offsetX < vScreen[Z].Width; offsetX += GFXBackground2[A].w)
        {
            if(offsetX + GFXBackground2[A].w <= 0)
                continue;

            XRender::renderTextureBasic(offsetX, offsetY + 455, GFXBackground2[A].w, GFXBackground2[A].h - 455, GFXBackground2[A], 0, 455);
        }
    }

    A = 57; // Warehouse
    if(Background2[S] == 57)
    {
        // looks more like a temple to me.
        // in vanilla asset:
        // top: can loop top 672px
        // bottom: can loop bottom 64px
        DrawCenterAnchoredBackground(S, Z, A, 800, 64, 672);
    }

    A = 58; // SMW Night
    if(Background2[S] == 58)
    {
        // can loop top 600px and bottom 128px of vanilla asset
        DrawCenterAnchoredBackground(S, Z, A, 3584, 128, 600, false, 2, true);
    }
}


================================================
FILE: src/graphics/gfx_camera.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "core/render.h"

#include "globals.h"
#include "game_main.h"
#include "graphics.h"
#include "gfx.h"
#include "screen.h"
#include "config.h"
#include "sound.h"

void ResetCameraPanning()
{
    for(int i = 0; i < 2; ++i)
        vScreen[i].small_screen_features = vScreen_t::SmallScreenFeatures_t();
}

static inline num_t s_small_screen_rate(const Screen_t& screen, const Screen_t& c_screen)
{
    // slowly disable small screen camera features as player cameras approach each other
    num_t rate = 1;
    if(screen.Type == ScreenTypes::Dynamic && (screen.W < c_screen.W || screen.H < c_screen.H))
    {
        num_t dx = num_t::abs(screen.vScreen(1).X - screen.vScreen(2).X);
        num_t dy = num_t::abs(screen.vScreen(1).Y - screen.vScreen(2).Y);
        num_t d = dx + dy;
        const int screen_join = (screen.W + screen.H) / 2;

        rate = (d - screen_join) / screen_join;
        if(rate < 0)
            rate = 0;
        if(rate > 1)
            rate = 1;
    }

    return rate;
}

void ProcessSmallScreenCam(vScreen_t& vscreen)
{
    const Screen_t& screen = Screens[vscreen.screen_ref];
    const Screen_t& c_screen = screen.canonical_screen();
    const Player_t& p = Player[vscreen.player];

    // slowly disable small screen camera features as player cameras approach each other
    num_t rate = s_small_screen_rate(screen, c_screen);

    if(g_config.small_screen_cam && screen.W < c_screen.W && !NoTurnBack[p.Section])
    {
        int16_t max_offsetX = 360;
        if(max_offsetX > vscreen.Width - (int)p.Location.Width * 4)
            max_offsetX = vscreen.Width - (int)p.Location.Width * 4;

        if(max_offsetX > c_screen.W - screen.W)
            max_offsetX = c_screen.W - screen.W;

        int16_t lookX_target = (int)(max_offsetX * p.Location.SpeedX) / 4;
        if(lookX_target > max_offsetX)
            lookX_target = max_offsetX;
        if(lookX_target < -max_offsetX)
            lookX_target = -max_offsetX;
        lookX_target &= ~1;

        if(LevelMacro != LEVELMACRO_OFF || ForcedControls)
            lookX_target = 0;

        int16_t rateX = 1;
        // switching directions
        if((vscreen.small_screen_features.offset_x < 0 && lookX_target > 0)
            || (vscreen.small_screen_features.offset_x > 0 && lookX_target < 0))
        {
            rateX = 3;
        }
        // accelerating
        else if((vscreen.small_screen_features.offset_x > 0) == (lookX_target > vscreen.small_screen_features.offset_x))
        {
            rateX = 2;
        }

        if(GamePaused == PauseCode::None && !qScreen && p.Effect == PLREFF_NORMAL)
        {
            if(vscreen.small_screen_features.offset_x < lookX_target)
                vscreen.small_screen_features.offset_x += rateX;
            else if(vscreen.small_screen_features.offset_x > lookX_target)
                vscreen.small_screen_features.offset_x -= rateX;
        }

        vscreen.X -= (int)(rate * vscreen.small_screen_features.offset_x / 2);
    }

    if(g_config.small_screen_cam && screen.H < c_screen.H)
    {
        int16_t max_offsetY = 200;
        if(max_offsetY > (c_screen.H - screen.H) + 50)
            max_offsetY = (c_screen.H - screen.H) + 50;

        int16_t lookY_target = max_offsetY;

        bool on_ground = p.Pinched.Bottom1 || p.Slope || p.StandingOnNPC || p.Wet || p.Quicksand;
        // bool duck_jump = !on_ground && p.Duck;
        bool prevent_unlock = vscreen.small_screen_features.offset_y_hold != 0 && (p.Vine || !on_ground || p.GrabTime);

        if(p.Controls.Up == p.Controls.Down || prevent_unlock)
            lookY_target = vscreen.small_screen_features.offset_y_hold;
        else if(p.Controls.Down)
            lookY_target *= -1;

        int16_t rateY = 4;
        if((vscreen.small_screen_features.offset_y < 0 && lookY_target > 0)
            || (vscreen.small_screen_features.offset_y > 0 && lookY_target < 0))
        {
            if(vscreen.small_screen_features.offset_y < 50 && vscreen.small_screen_features.offset_y > -50)
                vscreen.small_screen_features.offset_y *= -1;
        }

        if(GamePaused == PauseCode::None && !qScreen && !ForcedControls && LevelMacro == LEVELMACRO_OFF && p.Effect == PLREFF_NORMAL)
        {
            if(vscreen.small_screen_features.offset_y < lookY_target)
            {
                vscreen.small_screen_features.offset_y += rateY;

                if(vscreen.small_screen_features.offset_y > lookY_target)
                    vscreen.small_screen_features.offset_y = lookY_target;
            }
            else if(vscreen.small_screen_features.offset_y > lookY_target)
            {
                vscreen.small_screen_features.offset_y -= rateY;

                if(vscreen.small_screen_features.offset_y < lookY_target)
                    vscreen.small_screen_features.offset_y = lookY_target;
            }

            if(vscreen.small_screen_features.offset_y_hold == 0 && vscreen.small_screen_features.offset_y < -max_offsetY + 40 && (vscreen.small_screen_features.last_buttons_held & 1) == 0 && p.Controls.Down)
            {
                vscreen.small_screen_features.offset_y_hold = -max_offsetY;
                PlaySoundSpatial(SFX_Camera, p.Location);
            }
            else if(vscreen.small_screen_features.offset_y_hold == 0 && vscreen.small_screen_features.offset_y > max_offsetY - 40 && (vscreen.small_screen_features.last_buttons_held & 2) == 0 && p.Controls.Up)
            {
                vscreen.small_screen_features.offset_y_hold = max_offsetY;
                PlaySoundSpatial(SFX_Camera, p.Location);
            }
            else if(vscreen.small_screen_features.offset_y_hold != 0 && vscreen.small_screen_features.offset_y > -60 && vscreen.small_screen_features.offset_y < 60)
            {
                vscreen.small_screen_features.offset_y_hold = 0;
                PlaySoundSpatial(SFX_Camera, p.Location);
            }

            vscreen.small_screen_features.last_buttons_held = (int8_t)p.Controls.Down | (int8_t)p.Controls.Up << 1;
        }

        int16_t lookY = vscreen.small_screen_features.offset_y;

        if(lookY > -50 && lookY < 50)
            lookY = 0;
        else
        {
            if(lookY > 0)
                lookY -= 50;
            if(lookY < 0)
                lookY += 50;
            lookY /= 2;
        }

        // lower the default offset by 32px
        int fix_default_offset = 32;

        // weaken this effect when very close to the original canonical resolution
        if(fix_default_offset > (c_screen.H - screen.H) / 2)
            fix_default_offset = (c_screen.H - screen.H) / 2;

        // fade this out if approaching the canonical screen ounbds
        fix_default_offset *= (c_screen.H - screen.H) - std::abs(lookY) * 2;
        fix_default_offset /= (c_screen.H - screen.H);

        vscreen.Y += (int)(rate * (lookY + fix_default_offset));
    }
}

void DrawSmallScreenCam(vScreen_t& vscreen)
{
    const Screen_t& screen = Screens[vscreen.screen_ref];
    const Screen_t& c_screen = screen.canonical_screen();

    int CamX = vscreen.Width - 54;
    int CamY = vscreen.Height - 42;

    // don't overlap the controls display
    if(screen.Type == ScreenTypes::Dynamic && screen.vScreen(2).Visible && vscreen.Left > 0)
        CamY -= 24;

    // stay in the safe zone
    if(vscreen.ScreenLeft + vscreen.Width >= XRender::TargetW)
        CamX -= XRender::TargetOverscanX;

    // scale the opacity by the current effectiveness of the camera features
    num_t rate = s_small_screen_rate(screen, c_screen);

    int16_t max_offsetY = 200;
    if(max_offsetY > (c_screen.H - screen.H) + 50)
        max_offsetY = (c_screen.H - screen.H) + 50;

    // color for camera
    XTColor color;

    if(vscreen.small_screen_features.offset_y_hold != 0)
    {
        color = XTColorF(1.0_n, 0.2_n, 0.2_n, 1.0_n);

        if(vscreen.small_screen_features.offset_y_hold > 0)
            XRender::renderTextureBasic(CamX + 4, CamY - 18, GFX.MCursor[1], XTAlphaF(rate));
        else
            XRender::renderTextureBasic(CamX + 4, CamY + 18, GFX.MCursor[2], XTAlphaF(rate));
    }
    else if(vscreen.small_screen_features.offset_y < -max_offsetY * 4 / 5 || vscreen.small_screen_features.offset_y > max_offsetY * 4 / 5)
    {
        color = XTColorF(0.5_n, 1.0_n, 0.5_n, 0.7_n);

        if(vscreen.small_screen_features.offset_y > 0)
            XRender::renderTextureBasic(CamX + 4, CamY - 18, GFX.MCursor[1], XTAlphaF(0.7_r * rate));
        else
            XRender::renderTextureBasic(CamX + 4, CamY + 18, GFX.MCursor[2], XTAlphaF(0.7_r * rate));
    }
    else if(vscreen.small_screen_features.offset_y <= -48 || vscreen.small_screen_features.offset_y >= 48)
    {
        color = XTAlphaF(0.5_n);
    }
    else
    {
        color = XTColorF(0.0_n, 0.0_n, 0.0_n, 0.3_n);
    }

    color.a = int(rate * color.a);

    if(GFX.Camera.inited)
        XRender::renderTextureBasic(CamX, CamY, GFX.Camera, color);
    else
        XRender::renderRect(CamX, CamY, 24, 16, color);
}


================================================
FILE: src/graphics/gfx_camera.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_CAMERA_H
#define GFX_CAMERA_H

#include <cstdint>

struct vScreen_t;

void ResetCameraPanning();
void ProcessSmallScreenCam(vScreen_t& vscreen);
void DrawSmallScreenCam(vScreen_t& vscreen);

#endif


================================================
FILE: src/graphics/gfx_credits.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../graphics.h"
#include "main/game_info.h"
#include "core/render.h"


static XTColor s_alphaFromY(int y)
{
    const int h = 32; // An approximate height of one text line
    const int tb = 16;
    int b = static_cast<int>(y + h);
    int t = static_cast<int>(y);

    if(t >= XRender::TargetH) // The line at bottom
    {
        return XTAlpha(0);
    }

    if(b > XRender::TargetH) // The line enters the screen
    {
        return XTAlpha(255 -  255 * (b - XRender::TargetH) / h);
    }

    if(b <= tb) // The line at the top
    {
        return XTAlpha(0);
    }

    if(t < tb) // The line quits the screen
    {
        return XTAlpha(255 * (b - tb) / h);
    }

    return XTAlpha(255);
}

void DrawCredits()
{
    // CreditChop and CreditOffsetY were previously floats, now they are ints measured in tenths
    XRender::renderRect(0, 0, XRender::TargetW, (CreditChop + 5) / 10, {0, 0, 0});
    XRender::renderRect(0, XRender::TargetH - (CreditChop + 5) / 10, XRender::TargetW, (CreditChop + 5) / 10, {0, 0, 0});

    // previously hardcoded to 100
    int shrink = vScreen[1].Top;

    if(CreditChop > shrink * 10)
    {
        int chop = (CreditChop + 5) / 10 - shrink;
        int chop_max = (XRender::TargetH / 2) - shrink;
        uint8_t alpha = 255 * chop / chop_max;
        XRender::renderRect(0, 0, XRender::TargetW, XRender::TargetH, {0, 0, 0, alpha});
    }

    int A;

    // Find the highest
    for(A = 1; A <= numCredits; A++)
    {
        auto &c = Credit[A];
        auto &l = c.Location;
        auto bottom = l.Y + l.Height + CreditOffsetY / 10;
        if(bottom >= 0)
            break; // found!
    }

    // Draw that actually visible
    for(; A <= numCredits; A++)
    {
        auto &c = Credit[A];
        auto &l = c.Location;
        auto y = l.Y + CreditOffsetY / 10;

        if(y > XRender::TargetH)
            break; // Nothing also to draw

        // Printing lines of credits
        SuperPrint(GetS(c.Text),
                   g_gameInfo.creditsFont,
                   l.X,
                   y,
                   s_alphaFromY(y));
    }
}


================================================
FILE: src/graphics/gfx_draw_player.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <array>

#include "globals.h"
#include "graphics.h"
#include "collision.h"
#include "core/render.h"
#include "gfx.h"
#include "frame_timer.h"

#include "npc_id.h"
#include "npc_traits.h"

#include "graphics/gfx_keyhole.h"

static inline int s_round2int(num_t d)
{
    return num_t::floor(d + 0.5_n);
}

//! Get left pixel at the player sprite
int pfrX(const StdPicture& tx, const Player_t& p)
{
    // FIXME: Replace this heuristic logic with a proper texture flags mechanism

    // will use internal flags (tx.flags & PLAYER_MODERN and tx.flags & PLAYER_CUSTOM) in future
    // if tx.flags & PLAYER_CUSTOM, then will use heap-allocated polymorphic CustomData_t* tx.custom_data,
    // which will include all frame bounding boxes and offsets
    if(tx.h != 512)
        return ((p.Frame * p.Direction + 49) / 10) * 100;
    else
    {
        int col_w = (p.Character == 5) ? 64 : 48;
        int n_rows = 4;
        int n_cols = (p.Character == 5) ? 4 : 10;

        int fr = p.Frame;
        int dir = p.Direction;

        if(fr < 0)
        {
            fr = -fr;
            dir = -dir;
        }

        fr = (fr <= 32) ? fr : fr - 7;

        bool is_center_frame = (fr == 0);

        if(p.Character == 5)
            fr -= 1;

        int col = fr / n_rows;

        // load left-facing frame (bottom) - right to left (in order to mirror top half)
        if(!is_center_frame && dir < 0)
            return col_w * (n_cols - col - 1);
        // load right-facing frame (top) - left to right
        else
            return col_w * col;
    }
}

//! Get top pixel at the player sprite
int pfrY(const StdPicture& tx, const Player_t& p)
{
    // FIXME: Replace this heuristic logic with a proper texture flags mechanism
    if(tx.h != 512)
        return ((p.Frame * p.Direction + 49) % 10) * 100;
    else
    {
        int row_h = 64;
        int n_rows = 4;

        int fr = p.Frame;
        int dir = p.Direction;

        if(fr < 0)
        {
            fr = -fr;
            dir = -dir;
        }

        fr = (fr <= 32) ? fr : fr - 7;

        bool is_center_frame = (fr == 0);

        if(p.Character == 5)
            fr -= 1;

        int row = fr % n_rows;

        // load left-facing frame (bottom)
        if(!is_center_frame && dir < 0)
            return row_h * (n_rows + row);
        // load right-facing frame (top)
        else
            return row_h * row;
    }
}

//! Get width at the player sprite
int pfrW(const StdPicture& tx, const Player_t& p)
{
    if(tx.h != 512)
        return 100;
    else if(p.Character == 5)
        return 64;
    else
        return 48;
}

//! Get height at the player sprite
int pfrH(const StdPicture& tx, const Player_t& p)
{
    UNUSED(p);

    if(tx.h != 512)
        return 100;
    else
        return 64;
}

//! Get x offset that should be ADDED to the player position to draw the sprite
int pfrOffX(const StdPicture& tx, const Player_t& p)
{
    UNUSED(tx);

    if((p.Character < 1) || (p.Character > 5))
        return 0;

    using plr_frame_off_arr = RangeArrI<int8_t, 0, maxPlayerFrames, 0>;
    constexpr std::array<plr_frame_off_arr*, 5> char_offsetX = {&MarioFrameX, &LuigiFrameX, &PeachFrameX, &ToadFrameX, &LinkFrameX};
    int offX = (*char_offsetX[p.Character - 1])[(p.State * 100) + (p.Frame * p.Direction)];

    return offX;
}

//! Get y offset that should be ADDED to the player position to draw the sprite
int pfrOffY(const StdPicture& tx, const Player_t& p)
{
    UNUSED(tx);

    if((p.Character < 1) || (p.Character > 5))
        return 0;

    using plr_frame_off_arr = RangeArrI<int8_t, 0, maxPlayerFrames, 0>;
    constexpr std::array<plr_frame_off_arr*, 5> char_offsetY = {&MarioFrameY, &LuigiFrameY, &PeachFrameY, &ToadFrameY, &LinkFrameY};
    int offY = (*char_offsetY[p.Character - 1])[(p.State * 100) + (p.Frame * p.Direction)];

    return offY;
}

void DrawCycloneAccessory(int Z, const Player_t& p, int cX, int tY, XTColor c)
{
    int acc_frame = (CommonFrame / 4) % 4;
    if(acc_frame == 3)
        acc_frame = 1;

    // calculate offset for accessory
    int offsetX = -16;
    int offsetY = -32;

    int extra_offX = 0;
    int extra_offY = 0;

    if(p.Character == 5)
    {
        offsetX += 1;

        if(p.Frame == 1 || p.Frame == 2 || p.Frame == 3)
        {
            extra_offX = -4;
            extra_offY = -6;
        }
        else if(p.Frame == 4)
        {
            extra_offX = -2;
            extra_offY = -4;
        }
        else if(p.Frame == 5)
        {
            extra_offY = -6;
        }
        else if(p.Frame == 6)
        {
            extra_offX = -12;
            extra_offY = -4;
        }
        else if(p.Frame == 7)
        {
            extra_offX = 10;
            extra_offY = -2;
        }
        else if(p.Frame == 8)
        {
            extra_offX = 12;
            extra_offY = -4;
        }
        else if(p.Frame == 9)
        {
            extra_offX = 0;
            extra_offY = 0;
        }
        else if(p.Frame == 10)
        {
            extra_offX = -8;
            extra_offY = -4;
        }
        else if(p.Frame == 11)
        {
            extra_offX = 2;
            extra_offY = 0;
        }
    }
    else if(p.Frame == 30)
    {
        extra_offX = (p.Character == 2) ? -10 : -8;
        int offY = (p.Character == 2) ? -4 : 0;

        extra_offY = p.MountOffsetY + offY;
    }
    else if(p.Frame == 31)
    {
        extra_offX = -4;
        extra_offY = (p.Character == 2) ? -28 : -26;
    }
    else if(p.Frame == 7 || p.Frame == 27)
    {
        if(p.Character == 4)
            extra_offY = 2;
        else if(p.Character == 1)
            extra_offY = -4;
        else if(p.Character == 2)
            extra_offY = -6;
        else
            extra_offY = -2;
    }
    else if(p.Frame == 13)
    {
        if(p.Character == 3)
            extra_offY = 4;
    }
    else if(p.Frame == 15)
    {
        if(p.Character == 3)
            extra_offY = -2;
    }
    else if(p.Frame >= 40)
    {
        if(p.Character == 2)
            extra_offX = -2;
    }
    else if(p.Frame == 24)
    {
        extra_offX = -2;
        extra_offY = 2;
    }
    else if(p.Frame == 25 || p.Frame == 26)
    {
        acc_frame = 3 + (CommonFrame / 8) % 4;
        offsetY = -2;

        if(p.Character == 4)
            offsetY = -6;
        else if(p.Character == 3)
        {
            offsetY = -4;
            offsetX += 4;
        }
    }
    else if(p.Frame == 22 || p.Frame == 23)
    {
        if(p.Frame == 23)
            offsetY += 2;

        extra_offX = -2;

        if(p.Character == 4)
            extra_offY = -12;
        else if(p.Character == 3)
        {
            extra_offY = -22;
            extra_offX = 0;

            if(p.Direction == 1)
                offsetX += 8;
        }
        else
            extra_offY = -18;
    }
    else if(p.Frame == 16 || p.Frame == 17 || p.Frame == 18)
    {
        if(p.Character == 3)
            extra_offY = 2;
        else if(p.Character != 4)
            extra_offY = -2;
    }
    else if(p.Frame <= 10)
    {
        if(p.Character == 1 || p.Character == 2)
        {
            if(p.Frame == 4 || p.Frame == 5)
                extra_offY = -2;

            if(p.Frame == 6)
                extra_offX = 2;
            else if(!p.SpinJump)
                extra_offX = -2;
        }
    }

    if(p.Character == 2 && !(p.Mount == 1 && p.Duck))
        offsetY -= 2;

    offsetX += extra_offX * p.Direction;
    offsetY += extra_offY;

    RenderTexturePlayer(Z, p,
        cX + offsetX,
        tY + offsetY,
        32,
        32,
        GFX.CycloneAcc,
        0,
        32 * acc_frame,
        c);
}

using plr_pic_arr = RangeArr<StdPicture, 1, numStates>;
static constexpr std::array<plr_pic_arr*, 5> s_char_tex = {&GFXMario, &GFXLuigi, &GFXPeach, &GFXToad, &GFXLink};

void DrawPlayerRaw(int X, int Y, int Character, int State, int Frame, int Direction)
{
    Player_t p;
    p.Character = Character;
    p.State = State;
    p.Frame = Frame;
    p.Direction = Direction;

    StdPicture& tx = (*s_char_tex[p.Character - 1])[p.State];

    int offX = pfrOffX(tx, p);
    int offY = pfrOffY(tx, p);

    XRender::renderTextureBasic(X + offX,
                Y + offY,
                pfrW(tx, p),
                pfrH(tx, p),
                tx,
                pfrX(tx, p),
                pfrY(tx, p));
}

void DrawPlayer(const int A, const int Z, XTColor color)
{
    DrawPlayer(Player[A], Z, color);
}

void DrawPlayer(Player_t &p, const int Z, XTColor color)
{
    num_t camX = vScreen[Z].CameraAddX();
    num_t camY = vScreen[Z].CameraAddY();

    int B = 0;
    // double C = 0;
    XTColor s = (ShadowMode ? XTColor(64, 64, 64, color.a) : color);

    // color player during invincibility
    if(InvincibilityTime)
    {
        switch(((unsigned)CommonFrame / 4) % 4)
        {
        case 0:
            s.r = 128;
            break;
        case 1:
            s.g = 128;
            break;
        case 2:
            s.b = 128;
            break;
        case 3:
            break;
        }
    }

    //auto &p = Player[A];

    int sX = num_t::floor(camX + p.Location.X);
    int sY = num_t::floor(camY + p.Location.Y);
    int w = s_round2int(p.Location.Width);
    int h = s_round2int(p.Location.Height);

    if(!p.Immune2) // other draw conditions moved to calling site in UpdateGraphics
    {
        if(vScreenCollision(Z, p.Location))
        {
            // was previously in UpdateGraphicsDraw for pipe-warping players -- think about whether to move these to UpdateGraphicsLogic
            if(p.Character == 5 && p.Effect == PLREFF_WARP_PIPE && p.Frame > 5)
                p.Frame = 1;

            if(p.Mount == 3 && !p.Fairy)
            {
                B = p.MountType;
                // Yoshi's Tongue
                if(p.MountSpecial > 0)
                {
                    int C = 0;
                    if(p.Direction == 1)
                        C = p.YoshiTongueLength;
                    else
                        C = -16;

                    RenderTexturePlayer(Z, p, num_t::floor(camX + p.YoshiTongue.X) - C - 1,
                                          num_t::floor(camY + p.YoshiTongue.Y),
                                          p.YoshiTongueLength + 2,
                                          16,
                                          GFX.Tongue[2],
                                          0, 0,
                                          s);

                    C = 1;
                    if(p.Direction == 1)
                        C = 0;

                    RenderTexturePlayer(Z, p, num_t::floor(camX + p.YoshiTongue.X),
                                          num_t::floor(camY + p.YoshiTongue.Y),
                                          16, 16,
                                          GFX.Tongue[1],
                                          0,
                                          16 * C,
                                          s);
                }

                // Yoshi's Body
                RenderTexturePlayer(Z, p, sX + p.YoshiBX,
                                      sY + p.YoshiBY,
                                      32, 32,
                                      GFXYoshiB[B], 0, 32 * p.YoshiBFrame, s);

                // Yoshi's Head
                RenderTexturePlayer(Z, p, sX + p.YoshiTX,
                                      sY + p.YoshiTY,
                                      32, 32,
                                      GFXYoshiT[B], 0, 32 * p.YoshiTFrame, s);
            }

            if(p.Fairy) // draw a fairy
            {
                p.Frame = 1;

                //if(!p.Immune2) // Always true because of covered condition above
                {
                    RenderTexturePlayer(Z, p, sX - 5,
                                          sY - 2,
                                          32, 32,
                                          GFXNPC[NPCID_FLY_POWER],
                                          0,
                                          (SpecialFrame[9] + (p.Direction > 0 ? 1 : 3)) * 32,
                                          s);
//                    if(p.Direction == 1)
//                    {
//                        RenderTexturePlayer(Z, camX + p.Location.X - 5, camY + p.Location.Y - 2, 32, 32, GFXNPC[254], 0, (SpecialFrame[9] + 1) * 32, s);
//                    }
//                    else
//                    {
//                        RenderTexturePlayer(Z, camX + p.Location.X - 5, camY + p.Location.Y - 2, 32, 32, GFXNPC[254], 0, (SpecialFrame[9] + 3) * 32, s);
//                    }
                }
            }
            else if(p.Character >= 1 && p.Character <= 5) // draw player
            {
                StdPicture& tx = (*s_char_tex[p.Character - 1])[p.State];
                int offX = pfrOffX(tx, p);
                int offY = pfrOffY(tx, p);

                if(p.Mount == 0)
                {
                    RenderTexturePlayer(Z, p,
                                sX + offX,
                                sY + offY,
                                pfrW(tx, p),
                                pfrH(tx, p),
                                tx,
                                pfrX(tx, p),
                                pfrY(tx, p),
                                s);
                }
                else if(p.Mount == 1)
                {
                    if(!p.Duck)
                    {
                        int small_toad_oy_corr
                            = (p.Character == 4 && p.State == 1)
                            ? 6
                            : 0;

                        int peach_h_corr
                            = (p.Character == 3)
                            ? -2
                            : 0;

                        RenderTexturePlayer(Z, p,
                                    sX + offX,
                                    small_toad_oy_corr + sY + offY,
                                    pfrW(tx, p),
                                    h - 26 /*- p.MountOffsetY*/ - offY + peach_h_corr,
                                    tx,
                                    pfrX(tx, p),
                                    pfrY(tx, p),
                                    s);
                    }

                    RenderTexturePlayer(Z, p, sX + w / 2 - 16,
                                          sY + h - 30,
                                          32, 32,
                                          GFX.Boot[p.MountType],
                                          0,
                                          32 * p.MountFrame,
                                          s);
                }
                else if(p.Mount == 3)
                {
                    RenderTexturePlayer(Z, p, sX + offX,
                                          sY + offY + p.MountOffsetY,
                                          pfrW(tx, p),
                                          pfrH(tx, p),
                                          tx,
                                          pfrX(tx, p),
                                          pfrY(tx, p),
                                          s);
                }

                if(p.State == PLR_STATE_CYCLONE)
                    DrawCycloneAccessory(Z, p, sX + w / 2, sY, s);
            }

            // peach/toad held npcs
            // NEW: also, all players' held NPCs during warp
            if((p.Character == 3 || p.Character == 4 || (p.Effect == PLREFF_WARP_PIPE && p.Frame == 15)) && p.HoldingNPC > 0 && p.Effect != PLREFF_WARP_DOOR)
            {
                if(
                    (
                        (
                             (
                                    NPC[p.HoldingNPC].HoldingPlayer > 0
                                    // && Player[NPC[p.HoldingNPC].HoldingPlayer].Effect != PLREFF_WARP_PIPE
                              ) ||
                             (NPC[p.HoldingNPC].Type == NPCID_TOOTHY && NPC[p.HoldingNPC].vehiclePlr == 0) ||
                             (NPC[p.HoldingNPC].Type == NPCID_BULLET && NPC[p.HoldingNPC].CantHurt > 0)
                         ) ||
                      NPC[p.HoldingNPC].Effect == NPCEFF_PET_TONGUE
                    ) &&
                    NPC[p.HoldingNPC].Type != NPCID_ITEM_BURIED &&
                 !Player[NPC[p.HoldingNPC].HoldingPlayer].Dead
                )
                {
                    DrawNPCHeld(Z, camX, camY, p.HoldingNPC);
                }
            }

            if(!p.Fairy)
            {
                if(p.Mount == 3 && p.YoshiBlue)
                {
                    if(p.Direction == 1)
                    {
                        RenderTexturePlayer(Z, p, sX + p.YoshiBX - 12,
                                              sY + p.YoshiBY - 16,
                                              32, 32, GFX.YoshiWings, 0, 0 + 32 * p.YoshiWingsFrame, s);
                    }
                    else
                    {
                        RenderTexturePlayer(Z, p, sX + p.YoshiBX + 12,
                                              sY + p.YoshiBY - 16,
                                              32, 32, GFX.YoshiWings, 0, 0 + 32 * p.YoshiWingsFrame, s);
                    }
                }
                if((p.Mount == 1 && p.MountType == 3) || p.Effect == PLREFF_COOP_WINGS)
                {
                    if(p.Direction == 1)
                    {
                        RenderTexturePlayer(Z, p, sX - 24,
                                              sY + h - 40,
                                              32, 32, GFX.YoshiWings, 0, 0 + 32 * p.YoshiWingsFrame, s);
                    }
                    else
                    {
                        RenderTexturePlayer(Z, p, sX + 16,
                                              sY + h - 40,
                                              32, 32, GFX.YoshiWings, 0, 0 + 32 * p.YoshiWingsFrame, s);
                    }
                }
            }
        }
    }
}

void DrawNPCHeld(int Z, num_t camX, num_t camY, int A)
{
    g_stats.renderedNPCs++;

    XTColor cn = (NPC[A].Shadow) ? XTColor(64, 64, 64) : XTColor();

    if(NPC[A].Type == NPCID_ICE_CUBE)
    {
        DrawFrozenNPC(camX, camY, A);
    }
    else if(!NPCIsYoshi(NPC[A]) && NPC[A].Type > 0)
    {
        int sX = num_t::floor(camX + NPC[A].Location.X);
        int sY = num_t::floor(camY + NPC[A].Location.Y);
        int w = s_round2int(NPC[A].Location.Width);
        int h = s_round2int(NPC[A].Location.Height);

        if(NPC[A]->WidthGFX == 0)
        {
            int src_x = NPC[A].GFXSlot * NPC[A]->TWidth;
            if(src_x >= GFXNPC[NPC[A].Type].w)
                src_x = 0;

            RenderTexturePlayer(Z, Player[NPC[A].HoldingPlayer],
                sX + NPC[A]->FrameOffsetX,
                sY + NPC[A]->FrameOffsetY,
                w,
                h,
                GFXNPC[NPC[A].Type],
                src_x, NPC[A].Frame * h,
                cn);
        }
        else
        {
            int src_x = NPC[A].GFXSlot * NPC[A]->WidthGFX;
            if(src_x >= GFXNPC[NPC[A].Type].w)
                src_x = 0;

            RenderTexturePlayer(Z, Player[NPC[A].HoldingPlayer],
                sX + (NPC[A]->FrameOffsetX * -NPC[A].Direction) - NPC[A]->WidthGFX / 2 + w / 2,
                sY + NPC[A]->FrameOffsetY - NPC[A]->HeightGFX + h,
                NPC[A]->WidthGFX,
                NPC[A]->HeightGFX,
                GFXNPC[NPC[A].Type],
                src_x, NPC[A].Frame * NPC[A]->HeightGFX,
                cn);
        }

        if(NPC[A].Wings)
            DrawNPCWings(NPC[A], sX, sY, cn);
    }
}


================================================
FILE: src/graphics/gfx_editor.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <fmt_format_ne.h>

#include "core/render.h"
#include "globals.h"
#include "graphics.h"
#include "layers.h"
#include "npc.h"
#include "collision.h"
#include "gfx.h"
#include "config.h"
#include "npc_id.h"
#include "npc_traits.h"
#include "player.h"

#include "main/trees.h"

#include "editor.h"
#include "editor/new_editor.h"
#include "editor/editor_strings.h"
#include "editor/magic_block.h"

#ifdef THEXTECH_INTERPROC_SUPPORTED
#   include <InterProcess/intproc.h>
#endif

static inline int s_round2int(num_t d)
{
    return num_t::floor(d + 0.5_n);
}

void s_drawBlockExtra(int Z, num_t camX, num_t camY, const Block_t& b)
{
    if(b.Special > 0 && !b.Hidden)
    {
        if(vScreenCollision(Z, b.Location))
        {
            NPCID C = NPCID_NULL;
            if(b.Special > 1000)
                C = NPCID(b.Special - 1000);
            else if(b.Special == 110 && (CommonFrame & 32))
                C = NPCID_INVINCIBILITY_POWER;
            else
                C = NPCID_COIN_S3;

            int dW, dH;

            if(NPCWidthGFX(C) == 0)
            {
                dH = NPCHeight(C);
                dW = NPCWidth(C);
            }
            else
            {
                dH = NPCHeightGFX(C);
                dW = NPCWidthGFX(C);
            }

            int sX = num_t::floor(camX + b.Location.X + b.Location.Width / 2) - dW / 2;
            int sY = num_t::floor(camY + b.Location.Y + b.Location.Height / 2) - dH / 2;

            vbint_t tempDirection = -1;

            XRender::renderTextureBasic(sX + NPCFrameOffsetX(C),
                sY + NPCFrameOffsetY(C),
                dW, dH,
                GFXNPC[C], 0, EditorNPCFrame(C, tempDirection) * dH);
        }
    }

    // new: indicate that blocks have events
    if(b.TriggerHit != EVENT_NONE || b.TriggerDeath != EVENT_NONE || b.TriggerLast != EVENT_NONE)
    {
        if(vScreenCollision(Z, b.Location))
        {
            int sX = num_t::floor(camX + b.Location.X + b.Location.Width / 2) - GFX.Chat.w / 2;
            int sY = num_t::floor(camY + b.Location.Y) - GFX.Chat.h - 8;

            XRender::renderTextureBasic(sX, sY, GFX.Chat, XTColorF(1.0_n, 0.0_n, 0.0_n, 0.7_n));
        }
    }
}

void s_drawNpcExtra(int Z, num_t camX, num_t camY, const NPC_t& n)
{
    if(!n.Hidden && NPCIsContainer(n) && n.Type != NPCID_ITEM_BUBBLE && (n.Special > 0))
    {
        if(vScreenCollision(Z, n.Location))
        {
            NPCID C = NPCID(n.Special);

            int dW, dH;
            if(NPCWidthGFX(C) == 0)
            {
                dH = NPCHeight(C);
                dW = NPCWidth(C);
            }
            else
            {
                dH = NPCHeightGFX(C);
                dW = NPCWidthGFX(C);
            }

            int sY;
            if(n.Type == NPCID_ITEM_POD)
                sY = num_t::floor(camY + n.Location.Y + n.Location.Height) - dH;
            else
                sY = num_t::floor(camY + n.Location.Y);

            int sX = num_t::floor(camX + n.Location.X + n.Location.Width / 2) - dW / 2;

            vbint_t tempDirection = -1;

            XRender::renderTextureBasic(sX + NPCFrameOffsetX(C),
                sY + NPCFrameOffsetY(C),
                dW, dH,
                GFXNPC[C], 0, EditorNPCFrame(C, tempDirection) * dH);
        }
    }

    // new: indicate that NPCs have events
    if(n.TriggerActivate != EVENT_NONE || n.TriggerTalk != EVENT_NONE || n.TriggerDeath != EVENT_NONE || n.TriggerLast != EVENT_NONE)
    {
        if(vScreenCollision(Z, n.Location))
        {
            int sX = num_t::floor(camX + n.Location.X + n.Location.Width / 2);
            if(n.Text == STRINGINDEX_NONE)
                sX -= GFX.Chat.w / 2;
            else
                sX -= 4 + GFX.Chat.w;

            int sY = num_t::floor(camY + n.Location.Y) - GFX.Chat.h - 8;

            XRender::renderTextureBasic(sX, sY, GFX.Chat, XTColorF(1.0_n, 0.0_n, 0.0_n, 0.7_n));
        }
    }

    // and that they can talk
    if(n.Text != STRINGINDEX_NONE)
    {
        if(vScreenCollision(Z, n.Location))
        {
            int sX = num_t::floor(camX + n.Location.X + n.Location.Width / 2);
            if(!(n.TriggerActivate != EVENT_NONE || n.TriggerTalk != EVENT_NONE || n.TriggerDeath != EVENT_NONE || n.TriggerLast != EVENT_NONE))
                sX -= GFX.Chat.w / 2;
            else
                sX += 4;

            int sY = num_t::floor(camY + n.Location.Y) - GFX.Chat.h - 8;

            XRender::renderTextureBasic(sX, sY, GFX.Chat, XTColorF(1.0_n, 1.0_n, 1.0_n, 0.7_n));
        }
    }
}

void s_drawWaterBox(num_t camX, num_t camY, const Water_t& w)
{
    XRender::renderRect(num_t::floor(camX + w.Location.X), num_t::floor(camY + w.Location.Y), num_t::floor(w.Location.Width), num_t::floor(w.Location.Height),
        (w.Type == PHYSID_QUICKSAND) ? XTColor{255, 255, 0} :
        (w.Type == PHYSID_MAZE) ? XTColor{192, 192, 255} :
        XTColor{0, 255, 255},
        false);
}

void s_drawPlayer(int Z, int A, num_t sceneX, num_t sceneY)
{
    Player_t& p = Player[A];

    p.Character = testPlayer[A].Character;
    p.State = testPlayer[A].State;
    p.Mount = testPlayer[A].Mount;
    p.MountType = testPlayer[A].MountType;

    if(p.Character < 1 || p.Character > numCharacters)
        p.Character = A;
    if(p.State < 1 || p.State > numStates)
        p.State = 2;

    p.Direction = 1;
    p.Location.SpeedY = 0;
    p.Location.SpeedX = 0;
    p.Controls.Left = false;
    p.Controls.Right = false;
    p.SpinJump = false;
    p.Dead = false;
    p.Immune2 = false;
    p.Fairy = false;
    p.TimeToLive = 0;
    p.Effect = PLREFF_NORMAL;
    p.MountSpecial = 0;
    p.HoldingNPC = 0;
    if(p.Duck)
        UnDuck(p);
    PlayerFrame(p);

    if(p.MountType == 3)
    {
        p.YoshiWingsFrameCount += 1;
        p.YoshiWingsFrame = 0;
        if(p.YoshiWingsFrameCount <= 12)
            p.YoshiWingsFrame = 1;
        else if(p.YoshiWingsFrameCount >= 24)
            p.YoshiWingsFrameCount = 0;
        if(p.Direction == 1)
            p.YoshiWingsFrame += 2;
    }

    int C = Physics.PlayerHeight[p.Character][p.State] - Physics.PlayerHeight[A][2];

    p.Location.X = sceneX;
    p.Location.Y = sceneY - C;
    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
    SizeCheck(p);

    DrawPlayer(p, Z);
}

void DrawEditorLevel(int Z)
{
    int A = 0;
    // int B = 0;
    int S = curSection; // Level section to display

    // camera offsets to add to all object positions before drawing
    num_t camX = vScreen[Z].CameraAddX();
    num_t camY = vScreen[Z].CameraAddY();
    int camX_i = num_t::floor(camX);
    int camY_i = num_t::floor(camY);

#ifdef __3DS__
    XRender::setTargetLayer(2);
#endif
    if(LevelEditor)
    {
        if((CommonFrame % 46) <= 30)
        {
            // render NPCs in and events for blocks
            for(A = 1; A <= numBlock; A++)
                s_drawBlockExtra(Z, camX, camY, Block[A]);

            // render NPCs in containers
            for(A = 1; A <= numNPCs; A++)
                s_drawNpcExtra(Z, camX, camY, NPC[A]);
        }

        // render player start points
        for(A = 1; A <= 2; A++)
        {
            if(!(PlayerStart[A].Width > 0)) continue;
            if(vScreenCollision(Z, PlayerStart[A]))
                s_drawPlayer(Z, A, PlayerStart[A].X, PlayerStart[A].Y);
        }

        // render water
        for(int B : treeWaterQuery(-camX, -camY,
            -camX + vScreen[Z].Width, -camY + vScreen[Z].Height,
            SORTMODE_ID))
        {
            if(!Water[B].Hidden && vScreenCollision(Z, Water[B].Location))
                s_drawWaterBox(camX, camY, Water[B]);
        }

        // render warps
        for(A = 1; A <= numWarps; A++)
        {
            if(Warp[A].Direction > 0 && !Warp[A].Hidden)
            {
                bool complete = Warp[A].PlacedEnt && Warp[A].PlacedExit;
                XTColor color = complete ? XTColorF(1.0_n, 0.0_n, 1.0_n) : XTColorF(0.7_n, 0.3_n, 0.0_n);

                const SpeedlessLocation_t* const locs[2] = {&Warp[A].Entrance, &Warp[A].Exit};
                const bool enabled[2] = {Warp[A].PlacedEnt, Warp[A].PlacedExit};
                const int direction[2] = {Warp[A].Direction, Warp[A].Direction2};

                for(int i = 0; i < 2; i++)
                {
                    if(!enabled[i])
                        continue;

                    int l = num_t::floor(camX + locs[i]->X);
                    int t = num_t::floor(camY + locs[i]->Y);
                    int w = num_t::floor(locs[i]->Width);
                    int h = num_t::floor(locs[i]->Height);

                    XRender::renderRect(l, t, w, h, color, false);

                    if(Warp[A].Effect == 1 || Warp[A].Effect == 2)
                    {
                        if(direction[i] == 1 || direction[i] == 3)
                            XRender::renderRect(l + 2, t + 2 + (h - 6) * (direction[i] == 3), w - 4, 2, XTColor(0, 255, 0), true);

                        if(direction[i] == 2 || direction[i] == 4)
                            XRender::renderRect(l + 2 + (w - 6) * (direction[i] == 4), t + 2, 2, h - 4, XTColor(0, 255, 0), true);
                    }

                    SuperPrint(std::to_string(A), 1, l + 2 + (w - 16 - 4) * i,
                        t + 2 + (h - 14 - 4) * i);
                }
            }
        }

        // render event section resizes
        for(int A = 0; A < numEvents; A++)
        {
            const auto& e = Events[A];
            const IntegerLocation_t& sectPos = e.section[curSection].position;
            if(sectPos.X == EventSection_t::LESet_Nothing || sectPos.X == EventSection_t::LESet_ResetDefault)
                continue;

            XTColor ev_color = {uint8_t(64 + 128 * (A & 1)), uint8_t(64 + 64 * (A & 2)), uint8_t(64 + 32 * (A & 4))};
            DrawSimpleFrame(camX_i + sectPos.X, camY_i + sectPos.Y, sectPos.Width - sectPos.X, sectPos.Height - sectPos.Y, {0, 0, 0}, ev_color, {0, 0, 0, 0});
            SuperPrint(g_editorStrings.wordEvent, 3, camX_i + sectPos.X + 8, camY_i + sectPos.Y + 8);
            SuperPrint(e.Name, 3, camX_i + sectPos.X + 8, camY_i + sectPos.Y + 28, ev_color);
            SuperPrint(g_editorStrings.eventsCaseBounds, 3, camX_i + sectPos.X + 8, camY_i + sectPos.Y + 48);
        }
    }

#ifdef __3DS__
    XRender::setTargetLayer(2);
#endif

    // render section boundary
    if(LevelEditor)
    {
        if(camX_i + LevelREAL[S].X > 0)
        {
            XRender::renderRect(0, 0,
                               camX_i + LevelREAL[S].X, XRender::TargetH, {63, 63, 63, 192}, true);
        }

        if(XRender::TargetW > LevelREAL[S].Width + camX_i)
        {
            XRender::renderRect(LevelREAL[S].Width + camX_i, 0,
                               XRender::TargetW - (LevelREAL[S].Width + camX_i), XRender::TargetH, {63, 63, 63, 192}, true);
        }

        if(camY_i + LevelREAL[S].Y > 0)
        {
            XRender::renderRect(camX_i + LevelREAL[S].X, 0,
                               LevelREAL[S].Width - LevelREAL[S].X, camY_i + LevelREAL[S].Y, {63, 63, 63, 192}, true);
        }

        if(XRender::TargetH > LevelREAL[S].Height + camY_i)
        {
            XRender::renderRect(camX_i + LevelREAL[S].X, LevelREAL[S].Height + camY_i,
                               LevelREAL[S].Width - LevelREAL[S].X, XRender::TargetH - (LevelREAL[S].Height + camY_i), {63, 63, 63, 192}, true);
        }
    }

#ifdef __3DS__
    XRender::setTargetLayer(3);
#endif

#ifdef __3DS__
    // In-Editor message box preview (actually only useful on 3DS)
    if(editorScreen.active && !MessageText.empty())
        DrawMessage();
#endif

#ifdef __3DS__
    // disable cursor rendering on main screen when editor screen is active
    if(!editorScreen.active)
#endif
    // Display the cursor
    {
        auto &e = EditorCursor;
        int curX = s_round2int(e.X) - vScreen[Z].TargetX();
        int curY = s_round2int(e.Y) - vScreen[Z].TargetY();

        if((CommonFrame % 46) < 10)
        {
            // don't draw the currently held object
        }
        else if(e.Mode == OptCursor_t::LVL_BLOCKS) // Blocks
        {
            auto &b = e.Block;
            if(BlockIsSizable[b.Type])
            {
                if(vScreenCollision(Z, b.Location))
                    XRender::renderSizableBlock(num_t::floor(camX + b.Location.X), num_t::floor(camY + b.Location.Y), (int)(b.Location.Width), (int)(b.Location.Height), GFXBlockBMP[b.Type]);
            }
            else
            {
                if(vScreenCollision(Z, b.Location))
                {
                    XRender::renderTextureBasic(num_t::floor(camX + b.Location.X),
                                          num_t::floor(camY + b.Location.Y) + b.ShakeOffset,
                                          (int)(b.Location.Width),
                                          (int)(b.Location.Height),
                                          GFXBlock[b.Type], 0, BlockFrame[b.Type] * 32);
                }
            }

            // render NPC inside block
            if((CommonFrame % 46) <= 30)
                s_drawBlockExtra(Z, camX, camY, b);
        }

        else if(e.Mode == OptCursor_t::LVL_PLAYERSTART) // Player start points
        {
            if(e.SubMode == 4 || e.SubMode == 5)
                s_drawPlayer(Z, e.SubMode - 3, e.Location.X, e.Location.Y);
        }

        else if(e.Mode == OptCursor_t::LVL_BGOS) // BGOs
        {
            auto &b = e.Background;
            if(vScreenCollision(Z, b.Location))
            {
                XRender::renderTextureBasic(num_t::floor(camX + b.Location.X),
                                      num_t::floor(camY + b.Location.Y),
                                      BackgroundWidth[b.Type],
                                      BackgroundHeight[b.Type],
                                      GFXBackground[b.Type], 0,
                                      BackgroundHeight[b.Type] * BackgroundFrame[b.Type]);
            }
        }

        else if(e.Mode == OptCursor_t::LVL_NPCS) // NPCs
        {
            e.NPC.Frame = NPC[0].Frame;
            e.NPC.FrameCount = NPC[0].FrameCount;
            NPC[0] = e.NPC;
            NPCFrames(0);
            e.NPC = NPC[0];
            auto &n = e.NPC;

            DrawNPC(camX, camY, 0);

            s_drawNpcExtra(Z, camX, camY, n);
        }
        else if(EditorCursor.Mode == OptCursor_t::LVL_WATER) // Water
            s_drawWaterBox(camX, camY, EditorCursor.Water);
        else if(EditorCursor.Mode == OptCursor_t::LVL_WARPS)
        {
            XRender::renderRect(num_t::floor(camX + EditorCursor.Location.X), num_t::floor(camY + EditorCursor.Location.Y), (int)EditorCursor.Location.Width, (int)EditorCursor.Location.Height,
                XTColorF(1.0_n, 0.0_n, 0.0_n, 1.0_n), false);
        }

        if(EditorCursor.Mode == 0 || EditorCursor.Mode == 6) // Eraser
        {
            if(EditorCursor.SubMode == -1)
            {
                int frame = (CommonFrame % 46) / 20;
                if(frame > 2)
                    frame = 2;
                XRender::renderTextureBasic(curX - 8, curY, 32, 32, GFXNPC[NPCID_AXE], 0, 32 * frame);
            }
            else
                XRender::renderTextureBasic(curX - 2, curY, GFX.ECursor[3]);
        }

        // left-right resize
        else if(EditorCursor.InteractFlags > 1 && !(EditorCursor.InteractFlags & 2) && !(EditorCursor.InteractFlags & 4))
        {
            XRender::renderTextureBasic(curX - 16, curY - 16, 32, 32, GFX.EIcons, 0, 32 * Icon::lr);
        }

        // up-down resize
        else if(EditorCursor.InteractFlags > 1 && !(EditorCursor.InteractFlags & 8) && !(EditorCursor.InteractFlags & 16))
        {
            XRender::renderTextureBasic(curX - 16, curY - 16, 32, 32, GFX.EIcons, 0, 32 * Icon::ud);
        }

        // resize
        else if(EditorCursor.InteractFlags > 1)
        {
            XRender::renderTextureBasic(curX - 16, curY - 16, 32, 32, GFX.EIcons, 0, 32 * Icon::target);
        }

        else if(EditorCursor.Mode == 13 || EditorCursor.Mode == 14) // Selector
        {
            if(MagicBlock::enabled)
                XRender::renderTextureBasic(curX, curY, GFX.ECursor[2], XTColorF(0.7_n, 1.0_n, 0.7_n, 1.0_n));
            else
                XRender::renderTextureBasic(curX, curY, GFX.ECursor[2]);

        }

        // Section Resize
        else if(EditorCursor.Mode == 2 && EditorCursor.SubMode < 4)
        {
            XRender::renderTextureBasic(curX, curY, GFX.ECursor[1]);
        }
        else
        {
            if(MagicBlock::enabled)
                XRender::renderTextureBasic(curX, curY, GFX.ECursor[2], XTColorF(0.7_n, 1.0_n, 0.7_n, 1.0_n));
            else
                XRender::renderTextureBasic(curX, curY, GFX.ECursor[2]);

            if(e.Layer != LAYER_NONE && e.Layer != LAYER_DEFAULT)
            {
                // there might be a tooltip in this case
                if(editorScreen.active || EditorCursor.Y < 40)
                    SuperPrint(GetL(e.Layer), 3, curX + 28 , curY + 34, XTColorF(1.0_n, 1.0_n, 1.0_n, 0.3_n));
                else
                    SuperPrint(GetL(e.Layer), 3, curX + 28 , curY + 34);
            }
        }

//            End With
    }

    if(editor_section_toast > 0)
    {
        SuperPrintCenter("SECTION " + std::to_string(curSection+1), 3, vScreen[Z].Width / 2, vScreen[Z].Height - 100);
        editor_section_toast--;
    }
}

void DrawEditorLevel_UI()
{
#ifdef THEXTECH_INTERPROC_SUPPORTED
    if(!MagicHand || !IntProc::isEnabled())
#endif
    {
        editorScreen.UpdateEditorScreen(EditorScreen::CallMode::Render);
        XRender::resetViewport();
    }

#ifdef __3DS__
    if(!editorScreen.active)
    {
        editorScreen.UpdateEditorScreen(EditorScreen::CallMode::Render, true);
        XRender::resetViewport();
        XRender::setTargetLayer(3);
    }
#endif
}

void DrawEditorWorld()
{
    int Z = 1;

    int camX = vScreen[Z].CameraAddX_i() + XRender::TargetOverscanX;
    int camY = vScreen[Z].CameraAddY_i();

#ifdef __3DS__
    // disable cursor rendering on inactive screen of 3DS
    if(editorScreen.active) {}
    else
#endif

    if((CommonFrame % 46) < 10)
    {
        // don't draw the currently held object
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_TILES)
    {
        XRender::renderTextureBasic(camX + EditorCursor.Tile.Location.X,
            camY + EditorCursor.Tile.Location.Y,
            EditorCursor.Tile.Location.Width,
            EditorCursor.Tile.Location.Height,
            GFXTile[EditorCursor.Tile.Type],
            0,
            TileHeight[EditorCursor.Tile.Type] * TileFrame[EditorCursor.Tile.Type]);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_SCENES)
    {
        XRender::renderTextureBasic(camX + EditorCursor.Scene.Location.X,
            camY + EditorCursor.Scene.Location.Y,
            EditorCursor.Scene.Location.Width,
            EditorCursor.Scene.Location.Height,
            GFXScene[EditorCursor.Scene.Type],
            0,
            SceneHeight[EditorCursor.Scene.Type] * SceneFrame[EditorCursor.Scene.Type]);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_LEVELS)
    {
        if(EditorCursor.WorldLevel.Path)
        {
            XRender::renderTextureBasic(camX + EditorCursor.WorldLevel.Location.X,
                                  camY + EditorCursor.WorldLevel.Location.Y,
                                  EditorCursor.WorldLevel.Location.Width,
                                  EditorCursor.WorldLevel.Location.Height,
                                  GFXLevelBMP[0], 0, 0);
        }

        if(EditorCursor.WorldLevel.Path2)
        {
            XRender::renderTextureBasic(camX + EditorCursor.WorldLevel.Location.X - 16,
                                  camY + 8 + EditorCursor.WorldLevel.Location.Y,
                                  64, 32,
                                  GFXLevelBMP[29], 0, 0);
        }

        if(GFXLevelBig[EditorCursor.WorldLevel.Type])
        {
            XRender::renderTextureBasic(camX + EditorCursor.WorldLevel.Location.X - (GFXLevel[EditorCursor.WorldLevel.Type].w - 32) / 2,
                                  camY + EditorCursor.WorldLevel.Location.Y - GFXLevel[EditorCursor.WorldLevel.Type].h + 32,
                                  GFXLevel[EditorCursor.WorldLevel.Type].w, GFXLevel[EditorCursor.WorldLevel.Type].h,
                                  GFXLevelBMP[EditorCursor.WorldLevel.Type], 0, 32 * LevelFrame[EditorCursor.WorldLevel.Type]);
        }
        else
        {
            XRender::renderTextureBasic(camX + EditorCursor.WorldLevel.Location.X,
                                  camY + EditorCursor.WorldLevel.Location.Y,
                                  EditorCursor.WorldLevel.Location.Width, EditorCursor.WorldLevel.Location.Height,
                                  GFXLevelBMP[EditorCursor.WorldLevel.Type], 0, 32 * LevelFrame[EditorCursor.WorldLevel.Type]);
        }
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_PATHS)
    {
        XRender::renderTextureBasic(camX + EditorCursor.WorldPath.Location.X,
            camY + EditorCursor.WorldPath.Location.Y,
            EditorCursor.WorldPath.Location.Width,
            EditorCursor.WorldPath.Location.Height,
            GFXPath[EditorCursor.WorldPath.Type],
            0, 0);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_MUSIC)
    {
        XRender::renderRect(camX + EditorCursor.WorldMusic.Location.X, camY + EditorCursor.WorldMusic.Location.Y, 32, 32,
            XTColorF(1.0_n, 0.0_n, 1.0_n), false);
        SuperPrint(std::to_string(EditorCursor.WorldMusic.Type), 1, camX + EditorCursor.WorldMusic.Location.X + 2, camY + EditorCursor.WorldMusic.Location.Y + 2);
    }
    else if(EditorCursor.Mode == OptCursor_t::WLD_AREA)
    {
        XRender::renderRect(camX + EditorCursor.WorldArea.Location.X, camY + EditorCursor.WorldArea.Location.Y,
            EditorCursor.WorldArea.Location.Width, EditorCursor.WorldArea.Location.Height,
            XTColorF(1.0_n, 0.8_n, 0.2_n), false);
    }

    int X = (int)EditorCursor.X - vScreen[Z].TargetX();
    int Y = (int)EditorCursor.Y - vScreen[Z].TargetY();

#if 0
    if(g_config.editor_edge_scroll && !editorScreen.active && !MagicHand)
    {
        if(X >= 0 && X < 36)
            X = 36;
        if(Y >= 0 && Y < 36)
            Y = 36;
        if(X >= XRender::TargetW - 36)
            X = XRender::TargetW - 36;
        if(Y >= XRender::TargetH - 36)
            Y = XRender::TargetH - 36;
    }
#endif

#ifdef __3DS__
    // disable cursor rendering on inactive screen of 3DS
    if(editorScreen.active) {}
    else
#endif

    if(EditorCursor.Mode == OptCursor_t::LVL_ERASER)
    {
        if(EditorCursor.SubMode == -1)
        {
            int frame = (CommonFrame % 46) / 20;
            if(frame > 2)
                frame = 2;
            XRender::renderTextureBasic(X - 8, Y, 32, 32, GFXNPC[NPCID_AXE], 0, 32 * frame);
        }
        else
            XRender::renderTextureBasic(X - 2, Y, GFX.ECursor[3]);
    }
    // left-right resize
    else if(EditorCursor.InteractFlags > 1 && !(EditorCursor.InteractFlags & 2) && !(EditorCursor.InteractFlags & 4))
    {
        XRender::renderTextureBasic(X - 16, Y - 16, 32, 32, GFX.EIcons, 0, 32 * Icon::lr);
    }

    // up-down resize
    else if(EditorCursor.InteractFlags > 1 && !(EditorCursor.InteractFlags & 8) && !(EditorCursor.InteractFlags & 16))
    {
        XRender::renderTextureBasic(X - 16, Y - 16, 32, 32, GFX.EIcons, 0, 32 * Icon::ud);
    }

    // resize
    else if(EditorCursor.InteractFlags > 1)
    {
        XRender::renderTextureBasic(X - 16, Y - 16, 32, 32, GFX.EIcons, 0, 32 * Icon::target);
    }
    else
    {
        XRender::renderTextureBasic(X, Y, GFX.ECursor[2]);

        // show coordinates of nearby level for help making warps
        for(WorldLevel_t* t : treeWorldLevelQuery(TinyLocation_t{(int)EditorCursor.Location.X, (int)EditorCursor.Location.Y, 1, 1}, SORTMODE_NONE))
        {
            WorldLevel_t &lvl = *t;
            if(CursorCollision(EditorCursor.Location, lvl.Location))
            {
                int at_X = lvl.Location.X + lvl.Location.Width / 2 + camX;
                int at_Y = lvl.Location.Y + camY - 40;
                XRender::renderRect(at_X - 80, at_Y - 4, 160, 44, {0, 0, 0, 127}, true);
                SuperPrintCenter(fmt::sprintf_ne("%s: %d", g_editorStrings.letterCoordX.c_str(), (int)lvl.Location.X), 3, at_X, at_Y);
                SuperPrintCenter(fmt::sprintf_ne("%s: %d", g_editorStrings.letterCoordY.c_str(), (int)lvl.Location.Y), 3, at_X, at_Y + 20);
            }
        }
    }

    editorScreen.UpdateEditorScreen(EditorScreen::CallMode::Render);
    XRender::resetViewport();

#ifdef __3DS__
    if(!editorScreen.active)
    {
        editorScreen.UpdateEditorScreen(EditorScreen::CallMode::Render, true);
        XRender::resetViewport();
        XRender::setTargetLayer(3);
    }
#endif
}


================================================
FILE: src/graphics/gfx_enter_screen.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_timer.h"

#include "../gfx.h"
#include "../globals.h"
#include "../config.h"
#include "../graphics.h"
#include "../player.h"
#include "../frame_timer.h"
#include "../screen_fader.h"
#include "../core/render.h"
#include "../core/events.h"
#include "../controls.h"
#include "../main/game_strings.h" // For g_gameStrings.loaderLoading strign
#include "pge_delay.h"
#include "npc_id.h"
#include "message.h"

#include "main/hints.h"


static void initPlayers(Player_t tempPlayer[maxLocalPlayers])
{
    for(int A = 0; A < numPlayers && A < maxLocalPlayers; ++A)
    {
        auto &ref = Player[A + 1];
        auto &dst = tempPlayer[A];

        dst.Character = ref.Character;
        dst.State = ref.State;
        dst.Hearts = ref.Hearts;
        dst.Mount = ref.Mount;
        dst.MountType = ref.MountType;

        if(dst.Character == 0)
        {
            dst.Character = 1; // Sets as Mario
            if(numPlayers == 2 && A == 1 /*&& nPlay.Online == false*/) // Sets as Luigi
                dst.Character = 2;
        }

        if(dst.State == 0) // if no state it defaults to small mario
            dst.State = 1;

        if(dst.Character == 3 || dst.Character == 4 || dst.Character == 5) // Peach and Toad
        {
            if(dst.Hearts <= 0)
                dst.Hearts = 1;

            if(dst.Hearts <= 1 && dst.State > 1 && dst.Character != 5)
                dst.Hearts = 2;

            if(dst.HeldBonus > 0)
            {
                dst.Hearts += 1;
                dst.HeldBonus = NPCID(0);
            }

            if(dst.State == 1 && dst.Hearts > 1)
                dst.State = 2;

            if(dst.Hearts > 3)
                dst.Hearts = 3;

            if(dst.Mount == 3)
                dst.Mount = 0;
        }
        else // Mario and Luigi
        {
            if(dst.Hearts == 3 && dst.HeldBonus == 0)
                dst.HeldBonus = NPCID_POWER_S3;
            dst.Hearts = 0;
        }

        if(dst.Character == 5) // Link
            dst.Mount = 0;

        dst.Location.Width = Physics.PlayerWidth[dst.Character][dst.State]; // set height
        dst.Location.Height = Physics.PlayerHeight[dst.Character][dst.State]; // set width
        if(dst.State == 1 && dst.Mount == 1) // if small and in a shoe then set the height to super mario
            dst.Location.Height = Physics.PlayerHeight[1][2];

        // reset all variables
        if(dst.Mount == 2)
            dst.Mount = 0;

        if(dst.Character >= 3 && dst.Mount == 3)
            dst.Mount = 0;

        dst.Frame = 1;

        if(dst.Character == 3)
            dst.CanFloat = true;

        if(dst.Character == 3 || dst.Character == 4)
        {
            if(dst.State == 1)
                dst.Hearts = 1;

            if(dst.State > 1 && dst.Hearts < 2)
                dst.Hearts = 2;
        }

        dst.Section = -1;

        dst.Location.SpeedY = 0;
    }

    if(numPlayers == 1 || g_ClonedPlayerMode)
    {
        tempPlayer[0].Direction = 1;
    }
    else if(numPlayers == 2)
    {
        tempPlayer[0].Direction = -1;
        tempPlayer[1].Direction = 1;
    }
    else
    {
        for(int i = 0; i < numPlayers && i < maxLocalPlayers; i++)
            tempPlayer[i].Direction = 1;
    }

    for(int i = 0; i < numPlayers && i < maxLocalPlayers; i++)
        PlayerFrame(tempPlayer[i]);
}

static void placePlayers(Player_t tempPlayer[maxLocalPlayers])
{
    if(numPlayers == 1 || g_ClonedPlayerMode)
    {
        tempPlayer[0].Location.X = XRender::TargetW / 2 - tempPlayer[0].Location.Width / 2;
        tempPlayer[0].Location.Y = XRender::TargetH / 2 - tempPlayer[0].Location.Height + 24;
    }
    else if(numPlayers == 2)
    {
        tempPlayer[0].Location.X = XRender::TargetW / 2 - tempPlayer[0].Location.Width / 2 - 30;
        tempPlayer[0].Location.Y = XRender::TargetH / 2 - tempPlayer[0].Location.Height + 24;
        tempPlayer[0].Direction = -1;

        tempPlayer[1].Location.X = XRender::TargetW / 2 - tempPlayer[1].Location.Width / 2 + 32;
        tempPlayer[1].Location.Y = XRender::TargetH / 2 - tempPlayer[1].Location.Height + 24;
    }
    else
    {
        int start_x = XRender::TargetW / 2 - (numPlayers - 1) * 32;

        for(int i = 0; i < numPlayers && i < maxLocalPlayers; i++)
        {
            tempPlayer[i].Location.X = start_x + 64 * i - tempPlayer[i].Location.Width / 2;
            tempPlayer[i].Location.Y = XRender::TargetH / 2 - tempPlayer[i].Location.Height + 24;
        }
    }
}


static void drawEnterScreen(Player_t tempPlayer[maxLocalPlayers])
{
    placePlayers(tempPlayer);

    for(int A = 0; A < numPlayers && A < maxLocalPlayers; ++A)
    {
        DrawPlayer(tempPlayer[A], 0);

        if(g_ClonedPlayerMode)
            break;
    }

    if(TestLevel)
        SuperPrintScreenCenter(g_gameStrings.loaderLoading, 3, XRender::TargetH / 2 + 32);
    else
        DrawLives(XRender::TargetW / 2 - 14, XRender::TargetH / 2 + 31, Lives, g_100s);

    XHints::Draw(XRender::TargetH / 2 + 64, 0);
}


void GameThing(int waitms, int fadeSpeed)
{
    Player_t tempPlayer[maxLocalPlayers];
    initPlayers(tempPlayer);

    XHints::Select();

    int wait_frames = (waitms * 10 + 155) / 156;

    if(wait_frames <= 0)
    {
        XRender::setTargetTexture();
        XRender::clearBuffer();
        drawEnterScreen(tempPlayer);
        XRender::repaint();
        XEvents::doEvents();
    }
    else
    {
        ScreenFader fader;

        if(g_config.EnableInterLevelFade && fadeSpeed > 0)
            fader.setupFader(fadeSpeed, 65, 0, ScreenFader::S_FADE);

        while(wait_frames > 0 && GameIsActive)
        {
            XEvents::doEvents();

            if(canProceedFrame())
            {
                computeFrameTime1();

                Controls::Update(false);

                wait_frames--;

                if(XMessage::GetStatus() == XMessage::Status::replay)
                    continue;

                XRender::setTargetTexture();
                XRender::clearBuffer();
                drawEnterScreen(tempPlayer);

                if(fadeSpeed > 0 && fader.m_active)
                {
                    fader.update();
                    fader.draw();
                }

                XRender::repaint();
                XEvents::doEvents();
                computeFrameTime2();
            }

            if(!g_config.unlimited_framerate)
                PGE_Delay(1);
        }
    }
}


================================================
FILE: src/graphics/gfx_frame.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <IniProcessor/ini_processing.h>
#include <Logger/logger.h>

#include "core/render.h"

#include "graphics/gfx_frame.h"

void loadFrameInfo(IniProcessing& ini, FrameBorderInfo& info)
{
	info = FrameBorderInfo();

	ini.beginGroup("border-info");
	ini.read("te", info.te, info.te);
	ini.read("ti", info.ti, info.ti);
	ini.read("be", info.be, info.be);
	ini.read("bi", info.bi, info.bi);
	ini.read("le", info.le, info.le);
	ini.read("li", info.li, info.li);
	ini.read("re", info.re, info.re);
	ini.read("ri", info.ri, info.ri);
	ini.endGroup();
}

void DrawTextureTiled(int dst_x, int dst_y, int dst_w, int dst_h, StdPicture& tx, int src_x, int src_y, int src_w, int src_h, int off_x, int off_y, XTColor color)
{
    if(off_x == -1)
        off_x = dst_x;
    if(off_y == -1)
        off_y = dst_y;
    if(src_w == -1)
        src_w = tx.w;
    if(src_h == -1)
        src_h = tx.h;

    int c_off_x = off_x % src_w;
    // want modulus, not remainder
    if(c_off_x < 0)
    	c_off_x += src_w;

    for(int x = dst_x; x < dst_x + dst_w;)
    {
        int render_w = src_w - c_off_x;
        if(x + render_w > dst_x + dst_w)
            render_w = dst_x + dst_w - x;

        int c_off_y = off_y % src_h;
        // want modulus, not remainder
        if(c_off_y < 0)
        	c_off_y += src_h;

        for(int y = dst_y; y < dst_y + dst_h;)
        {
            int render_h = src_h - c_off_y;
            if(y + render_h > dst_y + dst_h)
                render_h = dst_y + dst_h - y;

            XRender::renderTextureBasic(x, y, render_w, render_h, tx, src_x + c_off_x, src_y + c_off_y, color);

            y += src_h - c_off_y;
            c_off_y = 0;
        }

        x += src_w - c_off_x;
        c_off_x = 0;
    }
}

// renders a new-style frame with the included external and internal locations
void RenderFrameBorder(const IntegerLocation_t& external, const IntegerLocation_t& internal,
	StdPicture& tile, FrameBorder* border)
{
	// first, verify to what extent the external and internal parts are the same
	bool have_l = external.X != internal.X;
	bool have_t = external.Y != internal.Y;
	bool have_r = external.X + external.Width != internal.X + internal.Width;
	bool have_b = external.Y + external.Height != internal.Y + internal.Height;


	// render a modern background: first the tile, then the border (if it exists)

	// top
	if(have_t)
	{
		DrawTextureTiled(external.X,
			external.Y,
			external.Width,
			internal.Y - external.Y,
			tile);
	}
	// left (excl top)
	if(have_l)
	{
		DrawTextureTiled(external.X,
			internal.Y,
			internal.X - external.X,
			external.Y + external.Height - internal.Y,
			tile);
	}
	// right (excl top)
	if(have_r)
	{
		DrawTextureTiled(internal.X + internal.Width,
			internal.Y,
			(external.X + external.Width) - (internal.X + internal.Width),
			external.Y + external.Height - internal.Y,
			tile);
	}
	// bottom (excl left and right)
	if(have_b)
	{
		DrawTextureTiled(internal.X,
			internal.Y + internal.Height,
			internal.Width,
			(external.Y + external.Height) - (internal.Y + internal.Height),
			tile);
	}

	if(!border || !border->tex.inited)
		return;

	FrameBorder& i = *border;

	// zero: check if the `ini` is invalid
	if(i.le + i.li + i.ri + i.re > i.tex.w)
		return;
	if(i.te + i.ti + i.bi + i.be > i.tex.h)
		return;

	int li = have_l ? i.li : 0;
	int ti = have_t ? i.ti : 0;
	int ri = have_r ? i.ri : 0;
	int bi = have_b ? i.bi : 0;

	// top external-left external
	if(have_l && have_t && i.le && i.te)
	{
		XRender::renderTextureBasic(internal.X - i.le, internal.Y - i.te, i.le, i.te,
		    i.tex,
		    0, 0);
	}
	// top external-left internal
	if(have_l && have_t && i.li && i.te)
	{
		XRender::renderTextureBasic(internal.X, internal.Y - i.te, i.li, i.te,
		    i.tex,
		    i.le, 0);
	}
	// top external-center
	if(have_t && i.te && internal.Width - li - ri > 0)
	{
		DrawTextureTiled(internal.X + li, internal.Y - i.te, internal.Width - li - ri, i.te,
		    i.tex,
		    i.le + i.li, 0,
		    i.tex.w - i.le - i.li - i.ri - i.re, i.te,
		    0, 0);
	}
	// top external-right internal
	if(have_t && have_r && i.ri && i.te)
	{
		XRender::renderTextureBasic(internal.X + internal.Width - i.ri, internal.Y - i.te, i.ri, i.te,
		    i.tex,
		    i.tex.w - i.ri - i.re, 0);
	}
	// top external-right external
	if(have_t && have_r && i.re && i.te)
	{
		XRender::renderTextureBasic(internal.X + internal.Width, internal.Y - i.te, i.re, i.te,
		    i.tex,
		    i.tex.w - i.re, 0);
	}
	// top internal-left external
	if(have_t && have_l && i.le && i.ti)
	{
		XRender::renderTextureBasic(internal.X - i.le, internal.Y, i.le, i.ti,
		    i.tex,
		    0, i.te);
	}
	// center-left external
	if(have_l && i.le && internal.Height - ti - bi > 0)
	{
		DrawTextureTiled(internal.X - i.le, internal.Y + ti, i.le, internal.Height - ti - bi,
		    i.tex,
		    0, i.te + i.ti,
		    i.le,
		    i.tex.h - i.te - i.ti - i.bi - i.be,
		    0, 0);
	}
	// bottom internal-left external
	if(have_b && have_l && i.le && i.bi)
	{
		XRender::renderTextureBasic(internal.X - i.le, internal.Y + internal.Height - i.bi, i.le, i.bi,
		    i.tex,
		    0, i.tex.h - i.bi - i.be);
	}
	// bottom external-left external
	if(have_b && have_l && i.le && i.be)
	{
		XRender::renderTextureBasic(internal.X - i.le, internal.Y + internal.Height, i.le, i.be,
		    i.tex,
		    0, i.tex.h - i.be);
	}
	// bottom external-left internal
	if(have_b && have_l && i.li && i.be)
	{
		XRender::renderTextureBasic(internal.X, internal.Y + internal.Height, i.li, i.be,
		    i.tex,
		    i.le, i.tex.h - i.be);
	}
	// bottom external-center
	if(have_b && i.be && internal.Width - li - ri > 0)
	{
		DrawTextureTiled(internal.X + li, internal.Y + internal.Height, internal.Width - li - ri, i.be,
		    i.tex,
		    i.le + i.li, i.tex.h - i.be, i.tex.w - i.le - i.li - i.ri - i.re, i.be,
		    0, 0);
	}
	// bottom external-right internal
	if(have_b && have_r && i.ri && i.be)
	{
		XRender::renderTextureBasic(internal.X + internal.Width - i.ri, internal.Y + internal.Height, i.ri, i.be,
		    i.tex,
		    i.tex.w - i.ri - i.re, i.tex.h - i.be);
	}
	// bottom external-right external
	if(have_b && have_r && i.re && i.be)
	{
		XRender::renderTextureBasic(internal.X + internal.Width, internal.Y + internal.Height, i.re, i.be,
		    i.tex,
		    i.tex.w - i.re, i.tex.h - i.be);
	}
	// top internal-right external
	if(have_t && have_r && i.re && i.ti)
	{
		XRender::renderTextureBasic(internal.X + internal.Width, internal.Y, i.re, i.ti,
		    i.tex,
		    i.tex.w - i.re, i.te);
	}
	// center-right external
	if(have_r && i.re && internal.Height - ti - bi)
	{
		DrawTextureTiled(internal.X + internal.Width, internal.Y + ti, i.re, internal.Height - ti - bi,
		    i.tex,
		    i.tex.w - i.re, i.te + i.ti,
		    i.re, i.tex.h - i.te - i.ti - i.bi - i.be,
		    0, 0);
	}
	// bottom internal-right external
	if(have_b && have_r && i.bi && i.re)
	{
		XRender::renderTextureBasic(internal.X + internal.Width, internal.Y + internal.Height - i.bi, i.re, i.bi,
		    i.tex,
		    i.tex.w - i.re, i.tex.h - i.bi - i.be);
	}
}

// renders a new-style frame as a fill at the included internal location
// the frame fills the internal rect
void RenderFrameFill(const IntegerLocation_t& internal, FrameBorder& frame, XTColor color)
{
	FrameBorder& i = frame;

	// zero: check if the `ini` is invalid
	if(i.le + i.li + i.ri + i.re > i.tex.w)
		return;
	if(i.te + i.ti + i.bi + i.be > i.tex.h)
		return;

	// top internal-left internal
	if(i.li && i.ti)
	{
		XRender::renderTextureBasic(internal.X, internal.Y, i.li, i.ti,
		    i.tex,
		    i.le, i.te,
		    color);
	}
	// top internal-center
	if(i.ti && internal.Width - i.li - i.ri > 0)
	{
		DrawTextureTiled(internal.X + i.li, internal.Y, internal.Width - i.li - i.ri, i.ti,
		    i.tex,
		    i.le + i.li, i.te,
		    i.tex.w - i.le - i.li - i.ri - i.re,
		    i.ti,
		    0, 0,
		    color);
	}
	// top internal-right internal
	if(i.ri && i.ti)
	{
		XRender::renderTextureBasic(internal.X + internal.Width - i.ri, internal.Y, i.ri, i.ti,
		    i.tex,
		    i.tex.w - i.ri - i.re, i.te,
		    color);
	}
	// center-left internal
	if(i.li && internal.Height - i.ti - i.bi > 0)
	{
		DrawTextureTiled(internal.X, internal.Y + i.ti, i.li, internal.Height - i.ti - i.bi,
		    i.tex,
		    i.le, i.te + i.ti,
		    i.li,
		    i.tex.h - i.te - i.ti - i.bi - i.be,
		    0, 0,
		    color);
	}
	// bottom internal-left internal
	if(i.li && i.bi)
	{
		XRender::renderTextureBasic(internal.X, internal.Y + internal.Height - i.bi, i.li, i.bi,
		    i.tex,
		    i.le,
		    i.tex.h - i.bi - i.be,
		    color);
	}
	// bottom internal-center
	if(i.bi && internal.Width - i.li - i.ri > 0)
	{
		DrawTextureTiled(internal.X + i.li, internal.Y + internal.Height - i.bi, internal.Width - i.li - i.ri, i.bi,
		    i.tex,
		    i.le + i.li, i.tex.h - i.be - i.bi, i.tex.w - i.le - i.li - i.ri - i.re, i.bi,
		    0, 0,
		    color);
	}
	// bottom internal-right internal
	if(i.ri && i.bi)
	{
		XRender::renderTextureBasic(internal.X + internal.Width - i.ri, internal.Y + internal.Height - i.bi, i.ri, i.bi,
		    i.tex,
		    i.tex.w - i.ri - i.re, i.tex.h - i.bi - i.be,
		    color);
	}
	// center-right internal
	if(i.ri && internal.Height - i.ti - i.bi)
	{
		DrawTextureTiled(internal.X + internal.Width - i.ri, internal.Y + i.ti, i.ri, internal.Height - i.ti - i.bi,
		    i.tex,
		    i.tex.w - i.re - i.ri, i.te + i.ti,
		    i.ri, i.tex.h - i.te - i.ti - i.bi - i.be,
		    0, 0,
		    color);
	}
	// center
	if(internal.Width - i.li - i.ri > 0 && internal.Height - i.ti - i.bi > 0)
	{
		DrawTextureTiled(internal.X + i.li, internal.Y + i.ti, internal.Width - i.li - i.ri, internal.Height - i.ti - i.bi,
		    i.tex,
		    i.le + i.li, i.te + i.ti,
		    i.tex.w - i.le - i.li - i.ri - i.re, i.tex.h - i.te - i.ti - i.bi - i.be,
		    0, 0,
		    color);
	}
}

// renders a simple colored frame, optimized for an opaque frame
void DrawSimpleFrameOpaque(int x, int y, int w, int h, XTColor border_1, XTColor border_2, XTColor fill)
{
	int bg_l = x;
	int bg_r = x + w;
	int bg_t = y;
	int bg_b = y + h;

	// border 1
	XRender::renderRect(bg_l, bg_t, bg_r - bg_l, bg_b - bg_t, border_1);

	// border 2
	XRender::renderRect(bg_l + 2, bg_t + 2, bg_r - bg_l - 4, bg_b - bg_t - 4, border_2);

	// fill
	XRender::renderRect(bg_l + 4, bg_t + 4, bg_r - bg_l - 8, bg_b - bg_t - 8, fill);
}

// renders a simple colored frame
void DrawSimpleFrame(int x, int y, int w, int h, XTColor border_1, XTColor border_2, XTColor fill)
{
	int bg_l = x;
	int bg_r = x + w;
	int bg_t = y;
	int bg_b = y + h;

	// border 1
	XRender::renderRect(bg_l, bg_t, 2, bg_b - bg_t, border_1);
	XRender::renderRect(bg_r - 2, bg_t, 2, bg_b - bg_t, border_1);
	XRender::renderRect(bg_l + 2, bg_t, bg_r - bg_l - 4, 2, border_1);
	XRender::renderRect(bg_l + 2, bg_b - 2, bg_r - bg_l - 4, 2, border_1);

	// border 2
	XRender::renderRect(bg_l + 2, bg_t + 2, 2, bg_b - bg_t - 4, border_2);
	XRender::renderRect(bg_r - 4, bg_t + 2, 2, bg_b - bg_t - 4, border_2);
	XRender::renderRect(bg_l + 4, bg_t + 2, bg_r - bg_l - 8, 2, border_2);
	XRender::renderRect(bg_l + 4, bg_b - 4, bg_r - bg_l - 8, 2, border_2);

	// fill
	if(fill.a)
		XRender::renderRect(bg_l + 4, bg_t + 4, bg_r - bg_l - 8, bg_b - bg_t - 8, fill);
}


================================================
FILE: src/graphics/gfx_frame.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_FRAME_H
#define GFX_FRAME_H

#include "location.h"
#include "std_picture.h"

struct FrameBorderInfo
{
	// top, left, bottom, and right, external and internal
	int te = 0;
	int ti = 0;
	int le = 0;
	int li = 0;
	int be = 0;
	int bi = 0;
	int re = 0;
	int ri = 0;
};

struct FrameBorder : public FrameBorderInfo
{
	StdPicture tex;
};

class IniProcessing;

void loadFrameInfo(IniProcessing& ini, FrameBorderInfo& borderinfo);

void DrawTextureTiled(int dst_x, int dst_y, int dst_w, int dst_h, StdPicture& tx, int src_x = 0, int src_y = 0, int src_w = -1, int src_h = -1, int off_x = -1, int off_y = -1, XTColor color = XTColor());

// renders a new-style frame as a border with the included external and internal locations
// the frame fills the space between external and internal
// border is nullable
void RenderFrameBorder(const IntegerLocation_t& external, const IntegerLocation_t& internal,
	StdPicture& tile, FrameBorder* border);

// renders a new-style frame as a fill at the included internal location
// the frame fills the internal rect
void RenderFrameFill(const IntegerLocation_t& internal, FrameBorder& frame, XTColor color = XTColor());

// renders a simple colored frame, optimized for an opaque frame
void DrawSimpleFrameOpaque(int x, int y, int w, int h, XTColor border_1, XTColor border_2, XTColor fill);

// renders a simple colored frame
void DrawSimpleFrame(int x, int y, int w, int h, XTColor border_1, XTColor border_2, XTColor fill);

#endif // GFX_FRAME_H


================================================
FILE: src/graphics/gfx_hud.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <fmt_format_ne.h>
#include "sdl_proxy/sdl_stdinc.h"

#include "../globals.h"
#include "../graphics.h"
#include "../core/render.h"
#include "../core/power.h"
#include "../gfx.h"
#include "npc_traits.h"
#include "eff_id.h"

#include "main/speedrunner.h"

#include "config.h"
#include "main/level_medals.h"
#include "main/screen_asset_pack.h"

void DrawInterface(int Z, int numScreens)
{
    int ScreenTop = 0;
    if(vScreen[Z].Height > 600)
        ScreenTop = vScreen[Z].Height / 2 - 300;
    int CenterX = vScreen[Z].Width / 2;

    const Screen_t& screen = Screens[vScreen[Z].screen_ref];

    // note: to_string doesn't belong in per-frame code, replace with faster implementation soon
    std::string scoreStr = std::to_string(Score);
    std::string coinsStr = std::to_string(Coins);
    std::string numStarsStr = std::to_string(numStars);

    bool is_multiplayer = screen.player_count > 1;
    bool shared_screen = (is_multiplayer && numScreens == 1 && screen.Type != 6);

    // number of players to render on this vScreen
    int plr_count = shared_screen ? screen.player_count : 1;

    // do any of the players on this vScreen have a key?
    bool someone_has_key = false;

    // first onscreen player index, affects coin icon and battle mode lives
    int first_plr_idx = 0;

    // bigger player HUD sizes in 1P/2P for compatibility purposes
    int plr_hud_width = plr_count == 1 ? 148 : (114 * plr_count);
    if(plr_count > 2)
        plr_hud_width = 84 * plr_count;

    // left and right sides of hearts / held item box section
    int left_margin = CenterX - plr_hud_width / 2;
    int right_margin = CenterX + plr_hud_width / 2;

    // loop over players and draw them
    for(int i = 0; i < plr_count; i++)
    {
        // look up player index using either screen (shared) or vScreen (non-shared)
        int plr_idx = shared_screen ? screen.players[i] : vScreen[Z].player;
        Player_t& plr = Player[plr_idx];

        if(i == 0)
            first_plr_idx = plr_idx;

        // find center for player HUD info; this is the center of the i'th portion of the HUD (out of plr_count portions)
        int plr_center = left_margin + (plr_hud_width * (i * 2 + 1)) / (plr_count * 2);

        // show hearts
        if(plr.Character == 3 || plr.Character == 4 || plr.Character == 5)
        {
            auto& heart_1_gfx = plr.Hearts > 0 ? GFX.Heart[1] : GFX.Heart[2];
            auto& heart_2_gfx = plr.Hearts > 1 ? GFX.Heart[1] : GFX.Heart[2];
            auto& heart_3_gfx = plr.Hearts > 2 ? GFX.Heart[1] : GFX.Heart[2];

            int heart_offset = (plr_count > 2) ? 24 : 32;

            XRender::renderTextureBasic(plr_center - heart_1_gfx.w / 2 - heart_offset, ScreenTop + 16, heart_1_gfx);
            XRender::renderTextureBasic(plr_center - heart_2_gfx.w / 2               , ScreenTop + 16, heart_2_gfx);
            XRender::renderTextureBasic(plr_center - heart_3_gfx.w / 2 + heart_offset, ScreenTop + 16, heart_3_gfx);
        }
        // show nothing
        else if(g_config.alt_powerdown) {}
        // show held bonus (item box)
        else
        {
            // held bonus offset, bring it towards the screen center in 2P
            if(plr_count == 2)
                plr_center += (i == 0) ? 17 : -17;

            int use_container = plr.Character;

            if(!is_multiplayer || use_container > 2)
                use_container = 0;

            XRender::renderTextureBasic(plr_center - GFX.Container[1].w / 2, ScreenTop + 16, GFX.Container[use_container]);

            if(plr.HeldBonus > 0)
            {
                int x = plr_center - GFX.Container[1].w / 2 + 12;
                int y = ScreenTop + 16 + 12;
                int w = NPCWidth(plr.HeldBonus);
                int h = NPCHeight(plr.HeldBonus);

                if(g_config.fix_visual_bugs)
                {
                    if(NPCWidthGFX(plr.HeldBonus))
                    {
                        w = NPCWidthGFX(plr.HeldBonus);
                        h = NPCHeightGFX(plr.HeldBonus);
                    }
                    x += 16 - w / 2;
                    y += 16 - h / 2;
                }

                XRender::renderTextureBasic(x, y, w, h, GFXNPC[plr.HeldBonus], 0, 0);
            }
        }

        // show bombs
        if(plr.Character == 5 && plr.Bombs > 0)
        {
            // offset for bomb text, just for compatibility
            int off = (plr_count == 2) ? -1 : 0;

            XRender::renderTextureBasic(20 + plr_center - 28 - 34 + off, ScreenTop + 52,
                GFX.Interface[8]);
            XRender::renderTextureBasic(20 + plr_center - 28 - 10 + off, ScreenTop + 53,
                GFX.Interface[1]);
            SuperPrint(std::to_string(plr.Bombs), 1,
                       20 + plr_center - 28 + 12 + off,
                       ScreenTop + 53);
        }

        if(plr.HasKey)
            someone_has_key = true;
    }

    // slightly expand margins for >2P
    if(plr_count > 2)
    {
        left_margin -= 4;
        right_margin += 12;
    }

    // draw non-battle mode info
    if(!BattleMode)
    {
        int coins_x = right_margin + 14;

        // Indicate key
        if(someone_has_key)
            XRender::renderTextureBasic(coins_x - 24, ScreenTop + 16 + 10, GFX.Interface[0]);

        // Print coins on the screen
        auto& coin_icon = (Player[first_plr_idx].Character == 5) ? GFX.Interface[6] : GFX.Interface[2];
        XRender::renderTextureBasic(coins_x, ScreenTop + 16 + 10, coin_icon);

        XRender::renderTextureBasic(coins_x + coin_icon.w + 8, ScreenTop + 16 + 11, GFX.Interface[1]);

        // note: the 36px at end gives 8px of padding between "x" icon and text when there are 2 digits
        int coins_score_text_right = (coins_x + coin_icon.w + 8 + GFX.Interface[1].w + 8 + 36);

        int coins_length = int(coinsStr.size()) * 18;
        SuperPrint(coinsStr, 1,
                   coins_score_text_right - coins_length,
                   ScreenTop + 16 + 11);

        // Print score below coins (match right align)
        int score_length = int(scoreStr.size()) * 18;
        SuperPrint(scoreStr, 1,
                   coins_score_text_right - score_length,
                   ScreenTop + 16 + 31);

        // Print lives on the screen
        int lives_stars_x = left_margin - 60; // excludes life / star icon width
        int lives_stars_text_left = lives_stars_x + 8 + GFX.Interface[1].w + 8;

        DrawLives(lives_stars_x, ScreenTop + 16 + 10, Lives, g_100s);

        // Print stars on the screen
        if(numStars > 0)
        {
            XRender::renderTextureBasic(lives_stars_x - GFX.Interface[5].w, ScreenTop + 16 + 30, GFX.Interface[5]);
            XRender::renderTextureBasic(lives_stars_x + 8, ScreenTop + 16 + 31, GFX.Interface[1]);

            SuperPrint(numStarsStr, 1,
                       lives_stars_text_left,
                       ScreenTop + 16 + 31);
        }

        // draw medals at top-right side of HUD
        int medals_x = SDL_min(static_cast<int>(vScreen[Z].Width), CenterX + 320) - 16;
        int medals_y = ScreenTop + 32;

        if(vScreen[Z].Width > 440 && vScreen[Z].Width < 640)
            medals_x = coins_score_text_right;

        if(vScreen[Z].Width < 640 || plr_count > 2)
            medals_y = ScreenTop + 4;

        DrawMedals(medals_x, medals_y, false, g_curLevelMedals.max, g_curLevelMedals.prev, 0, g_curLevelMedals.got, g_curLevelMedals.life);
    }
    // draw both battle mode lives
    else if(shared_screen)
    {
        // plr 1 lives
        int plr1_lives_x = left_margin - 60; // excludes life icon width
        XRender::renderTextureBasic(plr1_lives_x - GFX.Interface[3].w, ScreenTop + 16 + 10, GFX.Interface[3]);
        XRender::renderTextureBasic(plr1_lives_x + 8, ScreenTop + 16 + 11, GFX.Interface[1]);
        SuperPrint(std::to_string(BattleLives[screen.players[0]]), 1,
                   plr1_lives_x + 8 + GFX.Interface[1].w + 8,
                   ScreenTop + 16 + 11);

        // plr 2 lives
        int plr2_lives_x = right_margin + 30; // excludes life icon width
        XRender::renderTextureBasic(plr2_lives_x - GFX.Interface[7].w, ScreenTop + 16 + 10, GFX.Interface[7]);
        XRender::renderTextureBasic(plr2_lives_x + 8, ScreenTop + 16 + 11, GFX.Interface[1]);
        SuperPrint(std::to_string(BattleLives[screen.players[1]]), 1,
                   plr2_lives_x + 8 + GFX.Interface[1].w + 8,
                   ScreenTop + 16 + 11);
    }
    // draw 1P battle mode lives
    else
    {
        // lives in battle mode
        int lives_x = left_margin - 60; // excludes life icon width
        auto& oneup_twoup = (first_plr_idx == 2 && numPlayers == 2) ? GFX.Interface[7] : GFX.Interface[3];

        XRender::renderTextureBasic(lives_x - oneup_twoup.w,
                              ScreenTop + 16 + 10,
                              oneup_twoup);

        XRender::renderTextureBasic(lives_x + 8,
            ScreenTop + 16 + 11,
            GFX.Interface[1]);

        SuperPrint(std::to_string(BattleLives[first_plr_idx]), 1,
                   lives_x + 8 + GFX.Interface[1].w + 8,
                   ScreenTop + 16 + 11);
    }

    if(BattleIntro > 0)
    {
        if(BattleIntro > 45 || BattleIntro % 2 == 1)
        {
            int nextPlr = 1;

            int nextY = -96 + vScreen[Z].Height / 2 - 24 * (numPlayers / 2 - 1);

            while(numPlayers > nextPlr)
            {
                auto& P1_charname = GFX.CharacterName[Player[nextPlr].Character];
                auto& P2_charname = GFX.CharacterName[Player[nextPlr + 1].Character];

                int w = P1_charname.w + P2_charname.w + GFX.BMVs.w + 16 * 2;
                if(nextPlr > 1)
                    w += GFX.BMVs.w + 16;

                int l = vScreen[Z].Width / 2 - w / 2;

                if(nextPlr > 1)
                {
                    XRender::renderTextureBasic(l, nextY - GFX.BMVs.h / 2, GFX.BMVs);
                    l += GFX.BMVs.w + 16;
                }

                XRender::renderTextureBasic(l, nextY - P1_charname.h / 2, P1_charname);
                l += P1_charname.w + 16;

                XRender::renderTextureBasic(l, nextY - GFX.BMVs.h / 2, GFX.BMVs);
                l += GFX.BMVs.w + 16;

                XRender::renderTextureBasic(l, nextY - P2_charname.h / 2, P2_charname);

                nextY += 48;
                nextPlr += 2;
            }

            // final row if odd number of players
            if(numPlayers == nextPlr)
            {
                auto& last_charname = GFX.CharacterName[Player[nextPlr].Character];

                int w = last_charname.w + GFX.BMVs.w + 16;
                int l = vScreen[Z].Width / 2 - w / 2;

                XRender::renderTextureBasic(l, nextY - GFX.BMVs.h / 2, GFX.BMVs);
                XRender::renderTextureBasic(l + GFX.BMVs.w + 16, nextY - last_charname.h / 2, last_charname);
            }
        }
    }

    if(BattleOutro > 0)
    {
        auto& win_charname = GFX.CharacterName[Player[BattleWinner].Character];

        XRender::renderTextureBasic(10 + (int)vScreen[Z].Width / 2, -96 + (int)vScreen[Z].Height / 2 - GFX.BMWin.h / 2, GFX.BMWin);
        XRender::renderTextureBasic(-10 + (int)vScreen[Z].Width / 2 - win_charname.w, -96 + (int)vScreen[Z].Height / 2 - win_charname.h / 2, win_charname);
    }
}

void DrawLives(int X, int Y, int lives, int hunds, bool force_lives)
{
    bool show_times = true;
    int count = 0;
    int text_X = X + 8 + GFX.Interface[1].w + 8;

    if(g_config.modern_lives_system && !force_lives)
    {
        bool debt = (hunds < 0);
        count = (debt) ? -hunds : hunds;

        if(GFX.Balance.inited)
            XRender::renderTextureBasic(X - GFX.Balance.w / 2, Y, GFX.Balance.w / 2, GFX.Balance.h, GFX.Balance, debt * GFX.Balance.w / 2, 0);
        else
        {
            XRender::renderTextureBasic(X - GFX.Interface[2].w,      Y, GFX.Interface[2], XTColor(0x7F, 0x7F * !debt, 0x7F * !debt));
            XRender::renderTextureBasic(X - GFX.Interface[2].w - 8,  Y, GFX.Interface[2], XTColor(0xBF, 0xBF * !debt, 0xBF * !debt));
            XRender::renderTextureBasic(X - GFX.Interface[2].w - 16, Y, GFX.Interface[2], XTColor(0xFF, 0xFF * !debt, 0xFF * !debt));
        }

        if(count >= 100)
        {
            show_times = false;
            text_X -= 18;
        }

        if(count >= 1000)
            text_X -= 10;
    }
    else
    {
        count = lives;
        XRender::renderTextureBasic(X - GFX.Interface[3].w, Y, GFX.Interface[3]);
    }

    if(show_times)
        XRender::renderTextureBasic(X + 8, Y + 1, GFX.Interface[1]);

    SuperPrint(std::to_string(count), 1,
               text_X,
               Y + 1);
}

enum class MedalDrawLevel
{
    Off = 0, Prev, Got, Shiny
};

//! helper function to draw a single medal at a specific top-left position and acquisition level
static inline void s_DrawMedal(int i, int x, int y, int coin_width, int coin_height, MedalDrawLevel level)
{
    if(GFX.Medals.inited)
    {
        XRender::renderTextureBasic(x, y, coin_width, coin_height, GFX.Medals, coin_width * (int)level, 0);
    }
    else
    {
        if(level == MedalDrawLevel::Shiny || level == MedalDrawLevel::Got)
            XRender::renderTextureBasic(x, y, GFX.Interface[2]);
        else if(level == MedalDrawLevel::Prev)
            XRender::renderTextureBasic(x, y, GFX.Interface[2], XTColorF(0.5_n, 0.5_n, 0.5_n));
        else
            XRender::renderTextureBasic(x, y, GFX.Interface[2], XTColorF(0.5_n, 0.5_n, 0.5_n, 0.5_n));
    }

    // render sparkles for shiny
    if(level == MedalDrawLevel::Shiny && coin_width > 8 && coin_height > 8)
    {
        int sparkle_1_idx = ((CommonFrame + i * 16 * 37) % 1024) / 16; // on frame 3

        for(int i = 0; i < 3; ++i)
        {
            int sparkle_idx = (sparkle_1_idx + i) % 64;

            if(sparkle_idx % 2)
                continue;

            int sparkle_frame = 2 - i;

            int sparkle_X = (9 * sparkle_idx) % (coin_width - 8) + 4;
            int sparkle_Y = (13 * (sparkle_idx % 16) + 29 * (sparkle_idx / 16)) % (coin_height - 8) + 4;

            sparkle_X -= EffectWidth[EFFID_COIN_COLLECT] / 2;
            sparkle_Y -= EffectHeight[EFFID_COIN_COLLECT] / 2;

            sparkle_X &= ~1;
            sparkle_Y &= ~1;

            XRender::renderTextureBasic(x + sparkle_X, y + sparkle_Y, EffectWidth[EFFID_COIN_COLLECT], EffectHeight[EFFID_COIN_COLLECT], GFXEffect[EFFID_COIN_COLLECT], 0, EffectHeight[EFFID_COIN_COLLECT] * sparkle_frame, XTAlphaF(0.8_n));
        }
    }
}

void DrawMedals(int X, int Y, bool warp, uint8_t max, uint8_t prev, uint8_t ckpt, uint8_t got, uint8_t best)
{
    if(!g_config.show_medals_counter)
        return;

    if(g_config.medals_show_policy == Config_t::MEDALS_SHOW_OFF)
        return;

    if(g_config.medals_show_policy == Config_t::MEDALS_SHOW_GOT && got == 0)
        return;

    if(max == 0)
        return;

    int coin_width = GFX.Interface[2].w;
    int coin_height = GFX.Interface[2].h;

    if(GFX.Medals.inited)
    {
        coin_width = GFX.Medals.w / 4;
        coin_height = GFX.Medals.h;
    }

    if(max > static_cast<uint8_t>(c_max_track_medals))
        max = static_cast<uint8_t>(c_max_track_medals);

    // don't spoil the maximum count, make it shiny if all of the discovered medals are shiny
    bool show_max = g_config.medals_show_policy >= Config_t::MEDALS_SHOW_COUNTS;

    // whether to use the shiny effect for medals; for warps, check if best is all 1s (up to bit max); in HUD, always draw shiny medals
    bool show_shiny = (warp && show_max) ? (best == ((1 << max) - 1)) : true;

    // slot-based display
    if(g_config.medals_show_policy == Config_t::MEDALS_SHOW_FULL)
    {
        // position scene
        if(warp)
            X -= ((coin_width * max) / 2) & ~1;
        else
            X -= (coin_width * max);

        // draw coins
        for(uint8_t i = 0; i < max; ++i)
        {
            int bit = (1 << i);
            int X_i = X + coin_width * i;

            if((best & bit) && show_shiny)
                s_DrawMedal(i, X_i, Y, coin_width, coin_height, MedalDrawLevel::Shiny);
            else if(got & bit)
                s_DrawMedal(i, X_i, Y, coin_width, coin_height, MedalDrawLevel::Got);
            else if(ckpt & bit && (CommonFrame % 64) < 32)
                s_DrawMedal(i, X_i, Y, coin_width, coin_height, MedalDrawLevel::Got);
            else if(prev & bit)
                s_DrawMedal(i, X_i, Y, coin_width, coin_height, MedalDrawLevel::Prev);
            else
                s_DrawMedal(i, X_i, Y, coin_width, coin_height, MedalDrawLevel::Off);
        }

        return;
    }

    // text-based display

    // get counts
    int best_count = 0;
    int got_count = 0;
    int prev_count = 0;

    UNUSED(best_count);
    UNUSED(prev_count);

    for(uint8_t i = 0; i < max; ++i)
    {
        int bit = (1 << i);

        if(best & bit)
            best_count++;
        if(got & bit)
            got_count++;
        if(prev & bit)
            prev_count++;
    }

    // make labels and construct / position scene
    std::string label;
    int total_len = 0;

    if(g_config.medals_show_policy == Config_t::MEDALS_SHOW_COUNTS)
        label = fmt::sprintf_ne("%d/%u", got_count, (unsigned)max);
    else
        label = fmt::sprintf_ne("%d", got_count);

    total_len += coin_width + 8 + GFX.Interface[1].w + 4;
    total_len += SuperTextPixLen(label, 3);

    if(warp)
        X -= (total_len / 2) & ~1;
    else
        X -= total_len;

    // draw scene
    s_DrawMedal(0, X, Y, coin_width, coin_height, show_shiny ? MedalDrawLevel::Shiny : MedalDrawLevel::Got);
    X += coin_width + 8;
    XRender::renderTextureBasic(X, Y, GFX.Interface[1]);
    X += GFX.Interface[1].w + 4;
    SuperPrint(label, 3, X, Y);
}

void DrawDeviceBattery()
{
#ifndef RENDER_FULLSCREEN_ALWAYS
    if(!g_config.fullscreen && g_config.show_battery_status == Config_t::BATTERY_STATUS_FULLSCREEN)
        return;
#endif

    if(g_config.show_battery_status == Config_t::BATTERY_STATUS_OFF)
        return;

    XPower::StatusInfo status_info = XPower::devicePowerStatus();

    if(status_info.power_status == XPower::StatusInfo::POWER_DISABLED || status_info.power_status == XPower::StatusInfo::POWER_UNKNOWN || status_info.power_status == XPower::StatusInfo::POWER_WIRED)
        return;

    bool isLow = (status_info.power_level <= 0.35_nf);

    if(g_config.show_battery_status == Config_t::BATTERY_STATUS_LOW && !isLow)
        return;

    int bw = 40;
    int bh = 22;
    int bx = XRender::TargetW - XRender::TargetOverscanX - (bw + 8);
    int by = (GameMenu || ScreenAssetPack::g_LoopActive) ? 24 : 8;

    RenderPowerInfo(-1, bx, by, bw, bh, 255, &status_info);
}


================================================
FILE: src/graphics/gfx_keyhole.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "core/render.h"

#include "graphics/gfx_keyhole.h"

void RenderKeyhole(int Z)
{
    const unsigned keyholeMax = 192; // Was 300
    unsigned keyholeDone = keyholeMax - 65;
    unsigned ratio = 328 * LevelMacroCounter / keyholeDone;
    if(ratio > 327)
        ratio = 327;

    Background_t& keyhole = Background[LevelMacroWhich];

    num_t realKeyholeBottom = keyhole.Location.Y + 24;
    num_t idealKeyholeBottom = 32 * num_t::ceil(realKeyholeBottom / 32);

    // basis of 128
    unsigned keyholeGrowthCoord = ratio;

    if(keyholeGrowthCoord > 128)
        keyholeGrowthCoord = 128;

    // basis of 128
    unsigned keyholeScale = keyholeGrowthCoord * 12;

    if(ratio < 164)
        keyholeScale += (128 - keyholeGrowthCoord);

    num_t keyholeBottom = (realKeyholeBottom * (128 - keyholeGrowthCoord) + idealKeyholeBottom * keyholeGrowthCoord) / 128;

    RenderTexturePlayerScale(Z, Player[0],
        num_t::round(vScreen[Z].X + keyhole.Location.X + keyhole.Location.Width / 2 - keyhole.Location.Width * keyholeScale / 256),
        num_t::round(vScreen[Z].Y + keyholeBottom - 24 * keyholeScale / 128),
        (int)(keyhole.Location.Width) * keyholeScale / 128,
        (int)(keyhole.Location.Height) * keyholeScale / 128,
        GFXBackgroundBMP[keyhole.Type],
        0,
        0,
        (int)(keyhole.Location.Width),
        (int)(keyhole.Location.Height));

    // hide the real keyhole underneath
    if(ratio >= 164)
        keyhole.Hidden = true;
}

// WARP LOGIC: moved from PlayerWarpGFX (graphics.cpp)
static inline bool s_warp_gfx(int Z, const Player_t& p,
                         int& dst_x, int& dst_y, int& dst_w, int& dst_h,
                         int& src_x, int& src_y)
{
    // .Effect = 3      -- Warp Pipe
    // .Effect2 = 0     -- Entering
    // .Effect2 = 1     -- Move to next spot
    // .Effect2 => 100  -- Delay at next spot
    // .Effect2 = 2     -- Exiting
    // .Effect2 = 3     -- Done

    if(p.Effect2 == 1 || p.Effect2 >= 100)
        return true;

    if(p.Effect2 == 0 || p.Effect2 == 2)
    {
        num_t camX = vScreen[Z].CameraAddX();
        num_t camY = vScreen[Z].CameraAddY();

        bool use_exit = (p.WarpBackward) == (p.Effect2 == 0);
        const Warp_t& warp = Warp[p.Warp];
        const SpeedlessLocation_t& warp_loc = (use_exit) ? warp.Exit : warp.Entrance;
        auto warp_dir = (use_exit) ? warp.Direction2 : warp.Direction;

        int warp_l = num_t::floor(warp_loc.X + camX);
        int warp_r = warp_l + num_t::floor(warp_loc.Width);
        int warp_t = num_t::floor(warp_loc.Y + camY);
        int warp_b = warp_t + num_t::floor(warp_loc.Height);

        if(warp_dir == 3) // warp below player
        {
            if(dst_h > warp_b - dst_y)
                dst_h = warp_b - dst_y;
        }
        else if(warp_dir == 1) // warp above player
        {
            if(dst_y < warp_t)
            {
                src_y += (warp_t - dst_y);
                dst_h -= (warp_t - dst_y);
                dst_y = warp_t;
            }
        }
        else if(warp_dir == 4) // warp to right of player
        {
            if(dst_w > warp_r - dst_x)
                dst_w = warp_r - dst_x;
        }
        else if(warp_dir == 2) // warp to left of player
        {
            if(dst_x < warp_l)
            {
                src_x += (warp_l - dst_x);
                dst_w -= (warp_l - dst_x);
                dst_x = warp_l;
            }
        }

        if(dst_w < 0 || dst_h < 0)
            return true;
    }

    return false;
}

void RenderTexturePlayerScale(int Z, const Player_t& p,
                              int dst_x, int dst_y, int dst_w, int dst_h,
                              StdPicture& tex,
                              int src_x, int src_y, int src_w, int src_h,
                              XTColor color)
{
    if(LevelMacro != LEVELMACRO_KEYHOLE_EXIT || LevelMacroWhich == 0)
    {
        if(src_w == -1 || src_h == -1)
        {
            if(p.Effect == PLREFF_WARP_PIPE)
            {
                // apply warp to bounding box and return if sprite should not be drawn
                if(s_warp_gfx(Z, p, dst_x, dst_y, dst_w, dst_h, src_x, src_y))
                    return;
            }

            return XRender::renderTextureBasic(dst_x, dst_y, dst_w, dst_h, tex, src_x, src_y, color);
        }
        else
            return XRender::renderTextureScaleEx(dst_x, dst_y, dst_w, dst_h, tex, src_x, src_y, src_w, src_h, 0, nullptr, X_FLIP_NONE, color);
    }

    if(src_w == -1 || src_h == -1)
    {
        src_w = dst_w;
        src_h = dst_h;
    }

    const unsigned keyholeMax = 192; // Was 300
    unsigned keyholeDone = keyholeMax - 65;
    unsigned ratio = 328 * LevelMacroCounter / keyholeDone;
    if(ratio > 327)
        ratio = 327;

    Background_t& keyhole = Background[LevelMacroWhich];

    // basis of 128
    int scale = (ratio < 199) ? 128 : (327 - ratio);

    num_t cx = vScreen[Z].X + keyhole.Location.X + keyhole.Location.Width / 2;
    num_t cy = vScreen[Z].Y + keyhole.Location.Y + 12;

    return XRender::renderTextureScaleEx(
                (int)(dst_x * scale + cx * (128 - scale)) / 128,
                (int)(dst_y * scale + cy * (128 - scale)) / 128,
                dst_w * scale / 128, dst_h * scale / 128,
                tex,
                src_x,
                src_y,
                src_w, src_h, 0, nullptr, X_FLIP_NONE,
                color);
}

void RenderTexturePlayer(int Z, const Player_t& p,
                         int dst_x, int dst_y, int dst_w, int dst_h,
                         StdPicture& tex,
                         int src_x, int src_y, XTColor color)
{
    RenderTexturePlayerScale(Z, p,
        dst_x, dst_y, dst_w, dst_h,
        tex,
        src_x, src_y, -1, -1,
        color);
}


================================================
FILE: src/graphics/gfx_keyhole.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_KEYHOLE_H
#define GFX_KEYHOLE_H

#include "std_picture.h"

struct Player_t;

void RenderKeyhole(int Z);

void RenderTexturePlayer(int Z, const Player_t& p, int dst_x, int dst_y, int dst_w, int dst_h,
                         StdPicture& tex,
                         int src_x = 0, int src_y = 0,
                         XTColor color = XTColor());

void RenderTexturePlayer(int Z, const Player_t& p, double dst_x, double dst_y, double dst_w, double dst_h,
                         StdPicture& tex,
                         double src_x = 0, double src_y = 0,
                         XTColor color = XTColor()) = delete;

void RenderTexturePlayerScale(int Z, const Player_t& p, int dst_x, int dst_y, int dst_w, int dst_h,
                         StdPicture& tex,
                         int src_x, int src_y, int src_w, int src_h,
                         XTColor color = XTColor());

#endif // GFX_KEYHOLE_H


================================================
FILE: src/graphics/gfx_marquee.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>
#include "sdl_proxy/sdl_stdinc.h"

#include "graphics.h"
#include "graphics/gfx_marquee.h"

#include "fontman/font_manager.h"


// implementation for MarqueeState


void MarqueeState::reset_width(uint16_t text_width)
{
    if(m_text_width != text_width)
    {
        m_text_width = text_width;
        m_cur_frame = 0;
    }
}

void MarqueeState::advance(MarqueeSpec spec)
{
    if(m_text_width < spec.marquee_width)
    {
        m_cur_frame = 0;
        return;
    }

    m_cur_frame++;

    // figure out how many frames there are to decide whether or not to wrap

    // animation requires scrolling through the text
    uint16_t scroll_pixels = m_text_width - spec.marquee_width;

    // animation speed is measured in pixels per 10 frames
    uint16_t anim_frames = (scroll_pixels * 10) / spec.anim_speed;

    // there are also hold frames at start and end
    uint16_t hold_frames = spec.hold_frames * 2;

    uint16_t total_frames = anim_frames + hold_frames;

    if(m_cur_frame >= total_frames)
        m_cur_frame = 0;
}

CropInfo MarqueeState::crop_info(MarqueeSpec spec) const
{
    uint16_t scroll_pixels = m_text_width - spec.marquee_width;

    // need to figure out current pixel in full animation sequence (fade + scroll + fade)
    int cur_pixel = 0;

    if(m_cur_frame < spec.hold_frames)
        cur_pixel = 0;
    else
    {
        int cur_frame = m_cur_frame - spec.hold_frames;
        cur_pixel = (cur_frame * spec.anim_speed) / 10;
    }

    if(cur_pixel > scroll_pixels)
        cur_pixel = scroll_pixels;

    // begin filling in a CropInfo object
    CropInfo crop_info;
    crop_info.draw_width = spec.marquee_width;
    crop_info.offset = cur_pixel;

    // set fade values
    if(cur_pixel < spec.fade_pixels)
        crop_info.fade_left = cur_pixel;
    else
        crop_info.fade_left = spec.fade_pixels;

    if(scroll_pixels - cur_pixel < spec.fade_pixels)
        crop_info.fade_right = (scroll_pixels - cur_pixel);
    else
        crop_info.fade_right = spec.fade_pixels;

    return crop_info;
}


void SuperPrintMarquee(int SuperN, const char* SuperChars, int Font, int X, int Y,
                    MarqueeSpec marquee_spec, MarqueeState& marquee_state,
                    XTColor color)
{
    bool outline = false;

    int dFont = FontManager::fontIdFromSmbxFont(Font);
    if(dFont < 0 && Font == 5)
    {
        Font = 4;
        outline = true;

        dFont = FontManager::fontIdFromSmbxFont(Font);
    }

    if(dFont < 0)
    {
        pLogWarning("SuperPrint: Invalid font %d is specified", Font);
        return; // Invalid font specified
    }

    if(!marquee_state.check_width())
        marquee_state.reset_width(SuperTextPixLen(SuperN, SuperChars, Font));

    if(marquee_state.check_width() < marquee_spec.marquee_width)
    {
        if(marquee_spec.align > 0)
            X += (marquee_spec.marquee_width - marquee_state.check_width());
        else if(marquee_spec.align == 0)
            X += (marquee_spec.marquee_width - marquee_state.check_width()) / 2;

        marquee_spec.marquee_width = marquee_state.check_width();
    }

    CropInfo ci = marquee_state.crop_info(marquee_spec);

    FontManager::printText(SuperChars, SuperN, X, Y, dFont, color, FontManager::fontSizeFromSmbxFont(Font), outline, {0, 0, 0}, &ci);

    // update text width if unexpected result occurred (didn't terminate while text left, terminated when no text left)
    bool text_left = (ci.offset < marquee_state.check_width() - marquee_spec.marquee_width);

    if(ci.did_terminate ^ text_left)
    {
        marquee_state.reset_width(SuperTextPixLen(SuperN, SuperChars, Font));
        pLogDebug("Text width changed, resetting to %d", (int)marquee_state.check_width());
    }
}

void SuperPrintMarquee(const char* SuperChars, int Font, int X, int Y,
                    MarqueeSpec marquee_spec, MarqueeState& marquee_state,
                    XTColor color)
{
    int len = (int)SDL_strlen(SuperChars);

    return SuperPrintMarquee(len, SuperChars, Font, X, Y,
        marquee_spec, marquee_state,
        color);
}

void SuperPrintMarquee(const std::string& SuperWords, int Font, int X, int Y,
                    MarqueeSpec marquee_spec, MarqueeState& marquee_state,
                    XTColor color)
{
    int len = (int)SuperWords.size();

    return SuperPrintMarquee(len, SuperWords.c_str(), Font, X, Y,
        marquee_spec, marquee_state,
        color);
}


================================================
FILE: src/graphics/gfx_marquee.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_MARQUEE_H
#define GFX_MARQUEE_H

#include <cstdint>
#include <string>

#include "xt_color.h"
#include "fontman/crop_info.h"

struct MarqueeSpec
{
    //! width of marquee
    uint16_t marquee_width = 0;

    //! speed of animation in pixels per ten frames
    uint8_t anim_speed = 0;

    //! pixels to fade text on each side
    uint8_t fade_pixels = 0;

    //! frames to hold text on left and right
    uint8_t hold_frames = 0;

    //! how text should be aligned with an unfilled marquee (-1 for left, 0 for center, and 1 for right)
    int8_t align = 0;

    inline constexpr MarqueeSpec(uint16_t marquee_width, uint8_t anim_speed, uint8_t fade_pixels, uint8_t hold_frames, int8_t align)
        : marquee_width(marquee_width), anim_speed(anim_speed), fade_pixels(fade_pixels), hold_frames(hold_frames), align(align) {}
};

class MarqueeState
{
    //! width of currently loaded text in pixels
    uint16_t m_text_width = 0;

    //! current animation frame
    uint16_t m_cur_frame = 0;

public:
    /**
     * \brief: returns marquee's text width
     */
    inline uint16_t check_width() const
    {
        return m_text_width;
    }

    /**
     * \brief: resets the marquee state for a new text width
     */
    void reset_width(uint16_t text_width = 0);

    /**
     * \brief: advance the marquee state by one frame
     */
    void advance(MarqueeSpec spec);

    /**
     * \brief: provides the current crop info for rendering
     */
    CropInfo crop_info(MarqueeSpec spec) const;
};

void SuperPrintMarquee(int SuperN, const char* SuperChars, int Font, int X, int Y, MarqueeSpec spec, MarqueeState& marquee_state, XTColor color = XTColor());
void SuperPrintMarquee(const char* SuperChars, int Font, int X, int Y, MarqueeSpec spec, MarqueeState& marquee_state, XTColor color = XTColor());
void SuperPrintMarquee(const std::string &SuperWords, int Font, int X, int Y, MarqueeSpec spec, MarqueeState& marquee_state, XTColor color = XTColor());

#endif // GFX_MARQUEE_H


================================================
FILE: src/graphics/gfx_message.cpp
================================================
#include "sdl_proxy/sdl_assert.h"

#include "globals.h"
#include "../graphics.h"
#include "core/render.h"
#include "../gfx.h"
#include "../draw_planes.h"
#include "../frame_timer.h"
#include "../config.h"

#include "fontman/font_manager_private.h"
#include "fontman/font_manager.h"

static std::string s_opt_message;
static int s_last_width = 0;
static PGE_Size s_title_dims;
static PGE_Size s_message_dims;


void PrepareMessageDims()
{
    int TextBoxW = GFX.TextBox.w;

    if(!GFX.TextBox.inited || XRender::TargetW < GFX.TextBox.w || (g_MessageType >= MESSAGE_TYPE_SYS_INFO))
        TextBoxW = XRender::TargetW - 50;

    int font = FontManager::fontIdFromSmbxFont(4);

    s_opt_message = MessageText;
    s_message_dims = FontManager::optimizeTextPx(s_opt_message, TextBoxW - 14, font);

    if(!MessageTitle.empty())
        s_title_dims = FontManager::textSize(MessageTitle.c_str(), MessageTitle.size(), font);

    s_last_width = XRender::TargetH;
}

// Now uses the modern systems
void DrawMessage()
{
    if(s_last_width != XRender::TargetH)
        PrepareMessageDims();

    int TextBoxW = GFX.TextBox.w;
    bool UseGFX = true;

    if(!GFX.TextBox.inited || XRender::TargetW < GFX.TextBox.w || (g_MessageType >= MESSAGE_TYPE_SYS_INFO))
    {
        TextBoxW = XRender::TargetW - 50;
        UseGFX = false;
    }

    int BoxY_Start = XRender::TargetH / 2 - 150;

    if(BoxY_Start < 60)
    {
        BoxY_Start = XRender::TargetH / 2 - s_message_dims.h() / 2 - 10;

        if(BoxY_Start > 60)
            BoxY_Start = 60;
    }

    // Draw the background now we know how many lines there are. 10px of padding above and below.
    int totalHeight = s_message_dims.h() + 20;

    XTColor messageColour = {8, 96, 168};
    XTColor titleColour = {255, 255, 255};

    switch(g_MessageType)
    {
    case MESSAGE_TYPE_SYS_INFO:
        messageColour = {0x1D, 0x08, 0x5E};
        titleColour = {0xf5, 0xff, 0x1a};
        break;
    case MESSAGE_TYPE_SYS_WARNING:
        messageColour = {0xBF, 0x63, 0x24};
        titleColour = {0xf5, 0xff, 0x1a};
        break;
    case MESSAGE_TYPE_SYS_ERROR:
    case MESSAGE_TYPE_SYS_FATAL_ASSERT:
        messageColour = {0x61, 0x00, 0x0F};
        titleColour = {0xf5, 0xff, 0x1a};
        break;
    default:
        messageColour = {8, 96, 168};
        break;
    }

    if(g_MessageType >= MESSAGE_TYPE_SYS_INFO && !MessageTitle.empty())
    {
        int titleBoxWidth = TextBoxW > s_title_dims.w() + 12 ? TextBoxW : s_title_dims.w() + 12;
        int titleBoxHeight = s_title_dims.h() + 20;
        int titleBoxX = (XRender::TargetW / 2) - (titleBoxWidth / 2);
        int titleBoxY = BoxY_Start - 40;

        XRender::renderRect(titleBoxX, titleBoxY,
                            titleBoxWidth, titleBoxHeight, {0, 0, 0});
        XRender::renderRect(titleBoxX + 2, titleBoxY + 2,
                            titleBoxWidth - 4, titleBoxHeight - 4, {255, 255, 255});
        XRender::renderRect(titleBoxX + 4, titleBoxY + 4,
                            titleBoxWidth - 8, titleBoxHeight - 8, messageColour);

        SuperPrint(MessageTitle, 4, (XRender::TargetW / 2) - (s_title_dims.w() / 2), titleBoxY + 10, titleColour);
    }

    if(!UseGFX)
    {
        XRender::renderRect(XRender::TargetW / 2 - TextBoxW / 2,
                            BoxY_Start,
                            TextBoxW, totalHeight, {0, 0, 0});
        XRender::renderRect(XRender::TargetW / 2 - TextBoxW / 2 + 2,
                            BoxY_Start + 2,
                            TextBoxW - 4, totalHeight - 4, {255, 255, 255});
        XRender::renderRect(XRender::TargetW / 2 - TextBoxW / 2 + 4,
                            BoxY_Start + 4,
                            TextBoxW - 8, totalHeight - 8, messageColour);
    }

#ifndef BUILT_IN_TEXTBOX
    else
    {
        // amount of space to fill
        int spaceToFill = totalHeight - 20 - 20;

        // amount of middle GFX that gets looped. 20px in SMBX64.
        int gfxMidH = GFX.TextBox.h - 20 - 20;

        // number of reps needed to fill space
        int vertReps = spaceToFill / gfxMidH + 1;

        // want 20px of padding at bottom if possible
        int bottomPaddingHeight = 20;

        // special case where the entire message box is under 40px tall
        if(spaceToFill <= 0)
        {
            vertReps = 0;
            bottomPaddingHeight += spaceToFill;
            spaceToFill = 0;
        }

        // render top 20px of graphics
        XRender::renderTextureBasic(XRender::TargetW / 2 - TextBoxW / 2,
                               BoxY_Start,
                               TextBoxW, 20, GFX.TextBox, 0, 0);

        // loop middle of graphics
        for(int i = 0; i < vertReps; i++)
        {
            if((i + 1) * gfxMidH <= spaceToFill)
                XRender::renderTextureBasic(XRender::TargetW / 2 - TextBoxW / 2,
                                       BoxY_Start + 20 + i * gfxMidH,
                                       TextBoxW, gfxMidH, GFX.TextBox, 0, 20);
            else
                XRender::renderTextureBasic(XRender::TargetW / 2 - TextBoxW / 2,
                                       BoxY_Start + 20 + i * gfxMidH,
                                       TextBoxW, spaceToFill - i * gfxMidH, GFX.TextBox, 0, 20);
        }

        // render bottom of graphics
        XRender::renderTextureBasic(XRender::TargetW / 2 - TextBoxW / 2,
                               BoxY_Start + 20 + spaceToFill,
                               TextBoxW, bottomPaddingHeight, GFX.TextBox, 0, GFX.TextBox.h - bottomPaddingHeight);
    }
#endif

    // PASS TWO: draw the lines
    int font = FontManager::fontIdFromSmbxFont(4);

    int left = XRender::TargetW / 2 - TextBoxW / 2 + 12;

    // single-line centering special case
    if(s_message_dims.h() < 30)
        left += (TextBoxW - 14) / 2 - s_message_dims.w() / 2;

    FontManager::printText(s_opt_message.c_str(), s_opt_message.size(),
                            left, BoxY_Start + totalHeight / 2 - s_message_dims.h() / 2,
                            font);
}

void UpdateGraphicsFatalAssert()
{
    cycleNextInc();

    if(g_config.enable_frameskip && !TakeScreen && frameSkipNeeded())
        return;

    XRender::setTargetTexture();
    XRender::resetViewport();
    XRender::setDrawPlane(PLANE_LVL_META);

    if(PrintFPS > 0 && g_config.show_fps)
        SuperPrint(std::to_string(PrintFPS), 1, XRender::TargetOverscanX + 8, 8, {0, 255, 0});

    DrawMessage();

    XRender::repaint();
}


================================================
FILE: src/graphics/gfx_print.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>
#include "sdl_proxy/sdl_stdinc.h"

#include "core/render.h"

#include "globals.h"
#include "graphics.h"
#include "fontman/font_manager.h"
#include "fontman/font_manager_private.h"


int SuperTextPixLen(int SuperN, const char* SuperChars, int Font)
{
    int dFont = FontManager::fontIdFromSmbxFont(Font);
    if(dFont < 0 && Font == 5)
    {
        Font = 4;
        dFont = FontManager::fontIdFromSmbxFont(Font);
    }

    if(dFont < 0)
    {
        int len = 0;
        pLogWarning("SuperTextPixLen: Invalid font %d is specified", Font);

        for(int i = 0; i < SuperN; ++i)
        {
            len += 18;
            i += static_cast<size_t>(trailingBytesForUTF8[static_cast<UTF8>(SuperChars[i])]);
        }

        return len;
    }

    return FontManager::textSize(SuperChars, SuperN, dFont, FontManager::fontSizeFromSmbxFont(Font)).w();
}

void SuperPrintRightAlign(int SuperN, const char* SuperChars, int Font, int X, int Y, XTColor color)
{
    int RealFont = Font;
    bool outline = false;

    int dFont = FontManager::fontIdFromSmbxFont(Font);
    if(dFont < 0 && Font == 5)
    {
        Font = 4;
        outline = true;

        dFont = FontManager::fontIdFromSmbxFont(Font);
    }

    if(dFont >= 0)
    {
        X -= FontManager::textSize(SuperChars, SuperN, dFont, FontManager::fontSizeFromSmbxFont(Font)).w();
        FontManager::printText(SuperChars, SuperN, X, Y, dFont, color, FontManager::fontSizeFromSmbxFont(Font), outline);
        return;
    }

    X -= SuperTextPixLen(SuperN, SuperChars, RealFont);
    SuperPrint(SuperN, SuperChars, RealFont, X, Y, color);
}

void SuperPrintCenter(int SuperN, const char* SuperChars, int Font, int X, int Y, XTColor color)
{
    int RealFont = Font;
    bool outline = false;

    int dFont = FontManager::fontIdFromSmbxFont(Font);
    if(dFont < 0 && Font == 5)
    {
        Font = 4;
        outline = true;

        dFont = FontManager::fontIdFromSmbxFont(Font);
    }

    if(dFont >= 0)
    {
        X -= FontManager::textSize(SuperChars, SuperN, dFont, FontManager::fontSizeFromSmbxFont(Font)).w() / 2;
        FontManager::printText(SuperChars, SuperN, X, Y, dFont, color, FontManager::fontSizeFromSmbxFont(Font), outline);
        return;
    }

    X -= SuperTextPixLen(SuperN, SuperChars, RealFont) / 2;
    SuperPrint(SuperN, SuperChars, RealFont, X, Y, color);
}

void SuperPrintScreenCenter(int SuperN, const char* SuperChars, int Font, int Y, XTColor color)
{
    int RealFont = Font;
    bool outline = false;

    int dFont = FontManager::fontIdFromSmbxFont(Font);
    if(dFont < 0 && Font == 5)
    {
        Font = 4;
        outline = true;

        dFont = FontManager::fontIdFromSmbxFont(Font);
    }

    if(dFont >= 0)
    {
        int X = (XRender::TargetW / 2) - (FontManager::textSize(SuperChars, SuperN, dFont, FontManager::fontSizeFromSmbxFont(Font)).w() / 2);
        FontManager::printText(SuperChars, SuperN, X, Y, dFont, color, FontManager::fontSizeFromSmbxFont(Font), outline);
        return;
    }

    int X = (XRender::TargetW / 2) - (SuperTextPixLen(SuperN, SuperChars, RealFont) / 2);
    SuperPrint(SuperN, SuperChars, RealFont, X, Y, color);
}

void SuperPrint(int SuperN, const char* SuperChars, int Font, int X, int Y,
                XTColor color)
{
    bool outline = false;

    int dFont = FontManager::fontIdFromSmbxFont(Font);
    if(dFont < 0 && Font == 5)
    {
        Font = 4;
        outline = true;

        dFont = FontManager::fontIdFromSmbxFont(Font);
    }

    if(dFont < 0)
    {
        pLogWarning("SuperPrint: Invalid font %d is specified", Font);
        return; // Invalid font specified
    }

    FontManager::printText(SuperChars, SuperN, X, Y, dFont, color, FontManager::fontSizeFromSmbxFont(Font), outline);
}

// const char* versions

int SuperTextPixLen(const char* SuperChars, int Font)
{
    int len = (int)SDL_strlen(SuperChars);
    return SuperTextPixLen(len, SuperChars, Font);
}

void SuperPrintRightAlign(const char* SuperChars, int Font, int X, int Y, XTColor color)
{
    int len = (int)SDL_strlen(SuperChars);
    SuperPrintRightAlign(len, SuperChars, Font, X, Y, color);
}

void SuperPrintCenter(const char* SuperChars, int Font, int X, int Y, XTColor color)
{
    int len = (int)SDL_strlen(SuperChars);
    SuperPrintCenter(len, SuperChars, Font, X, Y, color);
}

void SuperPrintScreenCenter(const char* SuperChars, int Font, int Y, XTColor color)
{
    int len = (int)SDL_strlen(SuperChars);
    SuperPrintScreenCenter(len, SuperChars, Font, Y, color);
}

void SuperPrint(const char* SuperChars, int Font, int X, int Y, XTColor color)
{
    int len = (int)SDL_strlen(SuperChars);
    SuperPrint(len, SuperChars, Font, X, Y, color);
}


// const std::string& versions

int SuperTextPixLen(const std::string& SuperWords, int Font)
{
    return SuperTextPixLen((int)SuperWords.size(), SuperWords.c_str(), Font);
}

void SuperPrintRightAlign(const std::string& SuperWords, int Font, int X, int Y, XTColor color)
{
    SuperPrintRightAlign((int)SuperWords.size(), SuperWords.c_str(), Font, X, Y, color);
}

void SuperPrintCenter(const std::string& SuperWords, int Font, int X, int Y, XTColor color)
{
    SuperPrintCenter((int)SuperWords.size(), SuperWords.c_str(), Font, X, Y, color);
}

void SuperPrintScreenCenter(const std::string& SuperWords, int Font, int Y, XTColor color)
{
    SuperPrintScreenCenter((int)SuperWords.size(), SuperWords.c_str(), Font, Y, color);
}

void SuperPrint(const std::string& SuperWords, int Font, int X, int Y, XTColor color)
{
    SuperPrint((int)SuperWords.size(), SuperWords.c_str(), Font, X, Y, color);
}


================================================
FILE: src/graphics/gfx_screen.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <sdl_proxy/sdl_stdinc.h>

#include "../globals.h"
#include "../graphics.h"
#include "../player.h"
#include "../sound.h"
#include "../change_res.h"
#include "../load_gfx.h"
#include "../core/window.h"

#include "config.h"
#include "core/render.h"

void SetScreenType(Screen_t& screen)
{
    if(!screen.is_active())
        return;

    auto old_type = screen.Type;

    // moved this code from game_main.cpp, but it occured elsewhere also
    //   it was always called before setup screens, now it is a part of setup screens.
    //   better to have it in one place so it can be updated
    if(screen.player_count == 1)
        screen.Type = ScreenTypes::SinglePlayer; // Follow 1 player
    else if(screen.player_count == 2)
    {
        if(BattleMode)
            screen.Type = ScreenTypes::Dynamic;
        else if(screen.two_screen_pref == MultiplayerPrefs::Split)
            screen.Type = ScreenTypes::LeftRight;
        else if(screen.two_screen_pref == MultiplayerPrefs::Shared)
            screen.Type = ScreenTypes::SharedScreen;
        else if(screen.two_screen_pref == MultiplayerPrefs::TopBottom)
            screen.Type = ScreenTypes::TopBottom;
        else
            screen.Type = ScreenTypes::Dynamic; // Dynamic screen
    }
    else
    {
        if(g_config.fix_npc_camera_logic && (BattleMode || screen.four_screen_pref == MultiplayerPrefs::Split))
            screen.Type = ScreenTypes::Quad;
        else
            screen.Type = ScreenTypes::SharedScreen; // Average, no one leaves the screen
    }

    // special cases
    if(g_ClonedPlayerMode)
        screen.Type = ScreenTypes::Average;
    if(SingleCoop > 0)
        screen.Type = ScreenTypes::SingleCoop;
    if(GameMenu)
        screen.Type = ScreenTypes::Average;
    if(GameOutro)
        screen.Type = ScreenTypes::Credits;
    if(LevelEditor)
        screen.Type = ScreenTypes::SinglePlayer;

#ifndef PGE_MIN_PORT
    if(&screen == l_screen && (old_type == ScreenTypes::Quad) != (screen.Type == ScreenTypes::Quad))
        UpdateInternalRes();
#else
    (void)old_type;
#endif
}

// Sets up the split lines
void SetupScreens(Screen_t& screen, bool reset)
{
    if(!screen.is_active())
        return;

    SetScreenType(screen);

    vScreen_t& vscreen1 = screen.vScreen(1);
    vScreen_t& vscreen2 = screen.vScreen(2);

    switch(screen.Type)
    {
    case 0: // Follows Player 1
        vscreen1.Height = screen.H;
        vscreen1.Width = screen.W;
        vscreen1.Left = 0;
        vscreen1.Top = 0;
        vscreen2.Visible = false;
        break;
    case 1: // Split Screen vertical
        vscreen1.Height = screen.H / 2;
        vscreen1.Width = screen.W;
        vscreen1.Left = 0;
        vscreen1.Top = 0;
        vscreen2.Height = screen.H / 2;
        vscreen2.Width = screen.W;
        vscreen2.Left = 0;
        vscreen2.Top = screen.H / 2;
        break;
    case 2: // Follows all players
        vscreen1.Height = screen.H;
        vscreen1.Width = screen.W;
        vscreen1.Left = 0;
        vscreen1.Top = 0;
        vscreen2.Visible = false;
        break;
    case 3: // Follows all players. Noone leaves the screen
        vscreen1.Height = screen.H;
        vscreen1.Width = screen.W;
        vscreen1.Left = 0;
        vscreen1.Top = 0;
        vscreen2.Visible = false;
        break;
    case 4: // Split Screen horizontal
        vscreen1.Height = screen.H;
        vscreen1.Width = screen.W / 2;
        vscreen1.Left = 0;
        vscreen1.Top = 0;
        vscreen2.Height = screen.H;
        vscreen2.Width = screen.W / 2;
        vscreen2.Left = screen.W / 2;
        vscreen2.Top = 0;
        break;
    case 5: // Dynamic screen detection
        vscreen1.Height = screen.H;
        vscreen1.Width = screen.W;
        vscreen1.Left = 0;
        vscreen1.Top = 0;

        if(reset)
            vscreen2.Visible = false;
        break;
    case 6: // VScreen Coop
        vscreen1.Height = screen.H;
        vscreen1.Width = screen.W;
        vscreen1.Left = 0;
        vscreen1.Top = 0;
        vscreen2.Height = screen.H;
        vscreen2.Width = screen.W;
        vscreen2.Left = 0;
        vscreen2.Top = 0;
        break;
    case 7: // Credits (MODIFIED to include an adjusted chop feature)
        vscreen1.Left = 0;
        vscreen1.Top = (screen.H > 600) ? 100 : (screen.H / 6) & ~1;
        vscreen1.Height = screen.H - 2 * vscreen1.Top;
        vscreen1.Width = screen.W;
        vscreen2.Visible = false;
        break;
    case 8: // netplay
        vscreen1.Left = 0;
        vscreen1.Height = screen.H;
        vscreen1.Top = 0;
        vscreen1.Width = screen.W;
        vscreen2.Visible = false;
        break;
    case ScreenTypes::Quad: // quad
        for(int i = 0; i < 4 && i < maxLocalPlayers; i++)
        {
            vScreen_t& vscreen_i = screen.vScreen(i + 1);

            vscreen_i.Width = screen.W / 2;
            vscreen_i.Height = screen.H / 2;
            vscreen_i.Left = (i & 1) ? screen.W / 2 : 0;
            vscreen_i.Top = (i & 2) ? screen.H / 2 : 0;
        }
        break;
    }

    // clear dynamic screen / section resize offsets when called with reset
    if(reset)
    {
        for(int i = screen.active_begin(); i < screen.active_end(); i++)
        {
            vScreen_t& vscreen_i = screen.vScreen(i + 1);
            vscreen_i.TempDelay = 0;
            vscreen_i.tempX = 0;
            vscreen_i.TempY = 0;
        }
    }
}

void SetupScreens(bool reset)
{
    for(int i = 0; i < c_screenCount; i++)
        SetupScreens(Screens[i], reset);
}

void DynamicScreen(Screen_t& screen, bool mute)
{
    if(!screen.is_active())
        return;

    int A = 0;

    vScreen_t& vscreen1 = screen.vScreen(1);
    vScreen_t& vscreen2 = screen.vScreen(2);

    GetvScreenAverage(vscreen1);

    if(!g_config.multiplayer_pause_controls)
    {
        for(int i = 0; i < 2; i++)
        {
            if(Player[screen.players[i]].Effect == PLREFF_RESPAWN)
                return;
        }
    }

    for(A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Mount == 2)
            Player[A].Location.Height = 0;
    }

    Player_t& p1 = Player[screen.players[0]];
    Player_t& p2 = Player[screen.players[1]];

    num_t p1LocY = (p1.Effect == PLREFF_RESPAWN) ? p1.RespawnY : p1.Location.Y;
    num_t p2LocY = (p2.Effect == PLREFF_RESPAWN) ? p2.RespawnY : p2.Location.Y;

    if(!p1.Dead && !p2.Dead)
    {
        if(p1.Section == p2.Section)
        {
            const SpeedlessLocation_t& section = level[p1.Section];

            // use canonical width for checks in NoTurnBack case
            bool shrink_screen = (NoTurnBack[p1.Section] && g_config.allow_multires);
            const int check_W = shrink_screen ? screen.canonical_screen().W : screen.W;

            // a number of clauses check whether the section is larger than the screen
            bool section_wide = section.Width  - section.X > check_W;
            bool section_tall = section.Height - section.Y > screen.H;

            // observe that in the original code, there is a condition on whether vScreen 2 is visible, and this decides what P1 is compared with
            // (but NOT P2, which is always compared with vScreen 1). This is actually unnecessary and the logic works fine if both players are compared with
            // vScreen 1. It was likely a vestige from before the GetvScreenAverage call above was added. It must be removed if modern_section_change is set,
            // because if qScreen is active for vScreen2 (impossible prior to modern section change), the checks no longer work.
            const vScreen_t& p2_compare_vscreen = vscreen1;
            bool use_vscreen2 = !g_config.modern_section_change && vscreen2.Visible;
            const vScreen_t& p1_compare_vscreen = use_vscreen2 ? vscreen2 : vscreen1;

            // explanation of logic (example of first case, all are similar):
            //     if (1) the section is wider than the screen,
            //    and (2) P2's center is >75% to the right of the screen,
            //    and (3) the players could not both fit within the right 75% of the screen at the right of the section, then split

            // the VB6 code here was extremely complicated; including it below so that simplifications can be verified

            // If level(Player(1).Section).Width - level(Player(1).Section).X > ScreenW And
            //   (((vScreen(2).Visible = False   And Player(2).Location.X + vScreenX(1) >= ScreenW * 0.75 - Player(2).Location.Width / 2) Or
            //       (vScreen(2).Visible = True  And Player(2).Location.X + vScreenX(1) >= ScreenW * 0.75 - Player(2).Location.Width / 2))
            //   And (Player(1).Location.X < level(Player(1).Section).Width - ScreenW * 0.75 - Player(1).Location.Width / 2)) Then

            if(section_wide && (p2.Location.X + p2_compare_vscreen.X >= check_W * 0.75_n - p2.Location.Width / 2) && (p1.Location.X < section.Width - check_W * 0.75_n - p1.Location.Width / 2))
            {
                vscreen2.Height = screen.H;
                vscreen2.Width = screen.W / 2;
                vscreen2.Left = screen.W / 2;
                vscreen2.Top = 0;
                vscreen1.Height = screen.H;
                vscreen1.Width = screen.W / 2;
                vscreen1.Left = 0;
                vscreen1.Top = 0;
                GetvScreenAverage2(vscreen1);
                if(screen.DType != 1 && !mute)
                    PlaySound(SFX_Camera);
                for(A = 1; A <= 2; A++)
                {
                    vScreen_t& vscreena = screen.vScreen(A);
                    Player_t& p = Player[screen.players[A - 1]];
                    num_t pLocY = (A == 1) ? p1LocY : p2LocY;

                    vscreena.TempDelay = 200;
                    vscreena.tempX = 0;
                    vscreena.TempY = -vscreen1.Y + screen.H * 0.5_n - pLocY - vScreenYOffset - p.Location.Height;
                }
                vscreen2.Visible = true;
                screen.DType = 1;
            }

            // ElseIf level(Player(1).Section).Width - level(Player(1).Section).X > ScreenW And
            // (((vScreen(2).Visible = False And Player(1).Location.X + vScreenX(1) >= ScreenW * 0.75 - Player(1).Location.Width / 2) Or
            //   (vScreen(2).Visible = True  And Player(1).Location.X + vScreenX(2) >= ScreenW * 0.75 - Player(1).Location.Width / 2))
            // And (Player(2).Location.X < level(Player(1).Section).Width - ScreenW * 0.75 - Player(2).Location.Width / 2)) Then

            else if(section_wide && (p1.Location.X + p1_compare_vscreen.X >= check_W * 0.75_n - p1.Location.Width / 2) && (p2.Location.X < section.Width - check_W * 0.75_n - p2.Location.Width / 2))
            {
                vscreen1.Height = screen.H;
                vscreen1.Width = screen.W / 2;
                vscreen1.Left = screen.W / 2;
                vscreen1.Top = 0;
                vscreen2.Height = screen.H;
                vscreen2.Width = screen.W / 2;
                vscreen2.Left = 0;
                vscreen2.Top = 0;
                GetvScreenAverage2(vscreen1);
                if(screen.DType != 2 && !mute)
                    PlaySound(SFX_Camera);
                for(A = 1; A <= 2; A++)
                {
                    vScreen_t& vscreena = screen.vScreen(A);
                    Player_t& p = Player[screen.players[A - 1]];
                    num_t pLocY = (A == 1) ? p1LocY : p2LocY;

                    vscreena.TempDelay = 200;
                    vscreena.tempX = 0;
                    vscreena.TempY = -vscreen1.Y + screen.H * 0.5_n - pLocY - vScreenYOffset - p.Location.Height;
                }
                screen.DType = 2;
                vscreen2.Visible = true;
            }

            // ElseIf (level(Player(1).Section).Height - level(Player(1).Section).Y > ScreenH And
            // ((vScreen(2).Visible = False And Player(1).Location.Y + vScreenY(1) >= ScreenH * 0.75 - vScreenYOffset - Player(1).Location.Height) Or
            //  (vScreen(2).Visible = True  And Player(1).Location.Y + vScreenY(2) >= ScreenH * 0.75 - vScreenYOffset - Player(1).Location.Height))
            // And (Player(2).Location.Y < level(Player(1).Section).Height - ScreenH * 0.75 - vScreenYOffset - Player(2).Location.Height)) Then

            else if(section_tall && (p1LocY + p1_compare_vscreen.Y >= screen.H * 0.75_n - vScreenYOffset - p1.Location.Height) && (p2LocY < section.Height - screen.H * 0.75_n - vScreenYOffset - p2.Location.Height))
            {
                vscreen1.Height = screen.H / 2;
                vscreen1.Width = screen.W;
                vscreen1.Left = 0;
                vscreen1.Top = screen.H / 2;
                vscreen2.Height = screen.H / 2;
                vscreen2.Width = screen.W;
                vscreen2.Left = 0;
                vscreen2.Top = 0;
                GetvScreenAverage2(vscreen1);
                if(screen.DType != 3 && !mute)
                    PlaySound(SFX_Camera);
                for(A = 1; A <= 2; A++)
                {
                    vScreen_t& vscreena = screen.vScreen(A);
                    Player_t& p = Player[screen.players[A - 1]];

                    vscreena.TempDelay = 200;
                    vscreena.TempY = 0;
                    vscreena.tempX = -vscreen1.X + check_W * 0.5_n - p.Location.X - p.Location.Width / 2;
                }
                vscreen2.Visible = true;
                screen.DType = 3;
            }

            // ElseIf (level(Player(1).Section).Height - level(Player(1).Section).Y > ScreenH And
            // ((vScreen(2).Visible = False And Player(2).Location.Y + vScreenY(1) >= ScreenH * 0.75 - vScreenYOffset - Player(2).Location.Height) Or
            //  (vScreen(2).Visible = True  And Player(2).Location.Y + vScreenY(1) >= ScreenH * 0.75 - vScreenYOffset - Player(2).Location.Height))
            // And (Player(1).Location.Y < level(Player(1).Section).Height - ScreenH * 0.75 - vScreenYOffset - Player(1).Location.Height)) Then

            else if(section_tall && (p2LocY + p2_compare_vscreen.Y >= screen.H * 0.75_n - vScreenYOffset - p2.Location.Height) && (p1LocY < section.Height - screen.H * 0.75_n - vScreenYOffset - p1.Location.Height))
            {
                vscreen1.Height = screen.H / 2;
                vscreen1.Width = screen.W;
                vscreen1.Left = 0;
                vscreen1.Top = 0;
                vscreen2.Height = screen.H / 2;
                vscreen2.Width = screen.W;
                vscreen2.Left = 0;
                vscreen2.Top = screen.H / 2;
                GetvScreenAverage2(vscreen1);
                if(screen.DType != 4 && !mute)
                    PlaySound(SFX_Camera);
                for(A = 1; A <= 2; A++)
                {
                    vScreen_t& vscreena = screen.vScreen(A);
                    Player_t& p = Player[screen.players[A - 1]];

                    vscreena.TempDelay = 200;
                    vscreena.TempY = 0;
                    vscreena.tempX = -vscreen1.X + check_W * 0.5_n - p.Location.X - p.Location.Width / 2;
                }
                vscreen2.Visible = true;
                screen.DType = 4;
            }
            else
            {
                if(vscreen2.Visible)
                {
                    if(screen.DType != 5 && !mute)
                        PlaySound(SFX_Camera);
                    vscreen2.Visible = false;
                    vscreen1.Height = screen.H;
                    vscreen1.Width = screen.W;
                    vscreen1.Left = 0;
                    vscreen1.Top = 0;
                    vscreen1.tempX = 0;
                    vscreen1.TempY = 0;
                    vscreen2.tempX = 0;
                    vscreen2.TempY = 0;
                }
                screen.DType = 5;
            }
            for(A = 1; A <= 2; A++)
            {
                vScreen_t& vscreena = screen.vScreen(A);

                if(vscreena.TempY > (vscreena.Height * 0.25_n))
                    vscreena.TempY = (vscreena.Height * 0.25_n);
                if(vscreena.TempY < -(vscreena.Height * 0.25_n))
                    vscreena.TempY = -(vscreena.Height * 0.25_n);
                if(vscreena.tempX > (vscreena.Width * 0.25_n))
                    vscreena.tempX = (vscreena.Width * 0.25_n);
                if(vscreena.tempX < -(vscreena.Width * 0.25_n))
                    vscreena.tempX = -(vscreena.Width * 0.25_n);
            }
        }
        else
        {
            vscreen1.Height = screen.H / 2;
            vscreen1.Width = screen.W;
            vscreen1.Left = 0;
            vscreen1.Top = 0;
            vscreen2.Height = screen.H / 2;
            vscreen2.Width = screen.W;
            vscreen2.Left = 0;
            vscreen2.Top = screen.H / 2;
            vscreen1.tempX = 0;
            vscreen1.TempY = 0;
            vscreen2.tempX = 0;
            vscreen2.TempY = 0;
            GetvScreenAverage2(vscreen1);
            if(screen.DType != 6 && !mute)
                PlaySound(SFX_Camera);
            screen.DType = 6;
            vscreen2.Visible = true;
        }
    }
    else
    {
        if(vscreen2.Visible)
        {
            vscreen2.Visible = false;
            // vscreen1.Visible = false; // Useless, because code below sets it as TRUE back
            vscreen1.Height = screen.H;
            vscreen1.Width = screen.W;
            vscreen1.Left = 0;
            vscreen1.Top = 0;
            vscreen1.Visible = true;
            vscreen1.tempX = 0;
            vscreen1.TempY = 0;
            vscreen2.tempX = 0;
            vscreen2.TempY = 0;
        }
    }
    for(A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Mount == 2)
            Player[A].Location.Height = 128;
    }
}

void DynamicScreens()
{
    for(int i = 0; i < c_screenCount; i++)
    {
        Screen_t& screen = Screens[i];
        if(screen.Type == ScreenTypes::Dynamic)
            DynamicScreen(screen, !screen.Visible);
    }
}

// NEW: limit vScreens to playable section area and center them on the real screen
void CenterScreens(Screen_t& screen)
{
    if(!screen.is_active())
        return;

    for(int v = 1; v <= maxLocalPlayers; v++)
    {
        vScreen_t& vscreen = screen.vScreen(v);
        const Player_t& p = Player[screen.players[v - 1]];
        const SpeedlessLocation_t& section = level[p.Section];

        vscreen.ScreenLeft = vscreen.Left;
        vscreen.ScreenTop  = vscreen.Top;

        bool in_map = (LevelSelect && !GameMenu);

        // skip centering in all these places (world map sections handled elsewhere)
        if(LevelEditor || WorldEditor || in_map)
            continue;

        // restrict the vScreen to the level if the level is smaller than the screen
        int MaxWidth = num_t::round(section.Width - section.X);
        int MaxHeight = num_t::round(section.Height - section.Y);

        // on 3DS allow a slight amount of expansion for 3D overdraw, if the vscreen covers (and will cover) the entire screen
        int allow_X = (vscreen.Width == Screens[vscreen.screen_ref].W) ? Screens[vscreen.screen_ref].CameraOverscanX : 0;

        // don't do overscan if the section will be smaller than the screen after overscan (add 1 for floating precision margin)
        if(MaxWidth + XRender::TargetCameraOverscanX * 2 + 1 < vscreen.Width)
            allow_X = 0;

        MaxWidth += allow_X * 2;

        int MinWidth = 0;
        int MinHeight = 0;

        bool no_turn_back = NoTurnBack[p.Section];

        // restrict single vScreens on NoTurnBack sections
        if(g_config.allow_multires && no_turn_back)
        {
            MaxWidth = SDL_min(MaxWidth, screen.canonical_screen().W);

            // limit Visible screens further during DynamicScreen
            if(screen.Visible && screen.Type == 5 && screen.vScreen(2).Visible)
                MaxWidth = SDL_min(MaxWidth, screen.canonical_screen().W / 2);
        }

        // allow the canonical vScreens to approach normal screen size during dynamic screen
        if(g_config.allow_multires && !screen.Visible && !no_turn_back)
        {
            MinWidth = screen.W;
            MinHeight = screen.H;

            // allow to grow up to half the size of the visible screen (in dynamic screen), otherwise full screen
            if(screen.Type == ScreenTypes::Dynamic)
            {
                MinWidth = SDL_min(MinWidth, screen.visible_screen().W / 2);
                MinHeight = SDL_min(MinHeight, screen.visible_screen().H / 2);
            }
            else
            {
                MinWidth = SDL_min(MinWidth, screen.visible_screen().W);
                MinHeight = SDL_min(MinHeight, screen.visible_screen().H);
            }

            // this ensures a gradual transition between canonical screen size / 2 and visible screen size / 2
            // (no need to use it if in different sections or in permanent splitscreen)
            if(screen.Type == ScreenTypes::Dynamic && screen.DType != DScreenTypes::DiffSections)
            {
                // approximate positions of player screens
                num_t cX1, cY1, cX2, cY2;
                GetPlayerScreen(screen.canonical_screen().W, screen.canonical_screen().H, Player[screen.players[0]], cX1, cY1);
                GetPlayerScreen(screen.canonical_screen().W, screen.canonical_screen().H, Player[screen.players[1]], cX2, cY2);

                int screen_X_distance = (int)num_t::abs(cX1 - cX2);
                int screen_Y_distance = (int)num_t::abs(cY1 - cY2);

                MinWidth = SDL_min(MinWidth, screen_X_distance);
                MinHeight = SDL_min(MinHeight, screen_Y_distance);
            }

            // never get larger than section
            MinWidth = SDL_min(MinWidth, MaxWidth);
            MinHeight = SDL_min(MinHeight, MaxHeight);
        }

        if(MinWidth > vscreen.Width || MaxWidth < vscreen.Width)
        {
            int SetWidth = (MaxWidth < vscreen.Width) ? MaxWidth : MinWidth;

            int left_from_center = vscreen.ScreenLeft - (screen.W / 2);
            int right_from_center = (screen.W / 2) - (vscreen.ScreenLeft + vscreen.Width);
            int total_from_center = (left_from_center + right_from_center);
            int size_diff = vscreen.Width - SetWidth;

            // Move towards center of screen. If left is on center, don't need to move left side of screen.
            // If right is on center, need to fully move left so right can stay. Yields following formula:
            if(total_from_center)
                vscreen.ScreenLeft += size_diff * left_from_center / total_from_center;

            vscreen.Width = SetWidth;
        }

        if(MinHeight > vscreen.Height || MaxHeight < vscreen.Height)
        {
            int SetHeight = (MaxHeight < vscreen.Height) ? MaxHeight : MinHeight;

            int top_from_center = vscreen.ScreenTop - (screen.H / 2);
            int bottom_from_center = (screen.H / 2) - (vscreen.ScreenTop + vscreen.Height);
            int total_from_center = (top_from_center + bottom_from_center);
            int size_diff = vscreen.Height - SetHeight;

            // Move towards center of screen. If top is on center, don't need to move top side of screen.
            // If bottom is on center, need to fully move top so bottom can stay. Yields following formula:
            if(total_from_center)
                vscreen.ScreenTop += size_diff * top_from_center / total_from_center;

            vscreen.Height = SetHeight;
        }
    }
}

void CenterScreens()
{
    for(int i = 0; i < c_screenCount; i++)
    {
        Screen_t& screen = Screens[i];
        CenterScreens(screen);
    }
}

// NEW: moves qScreen towards vScreen, now including the screen size
bool Update_qScreen(int Z, num_t camRate, num_t resizeRate)
{
    if(Z == 2 && !g_config.modern_section_change)
        return false;

    bool continue_qScreen = true;

    // take the slower option of 2px per second camera (vanilla)
    //   or 2px per second resize, then scale the speed of the faster one to match
    num_t camRateX = camRate;
    num_t camRateY = camRate;

    int resizeRateX = int(resizeRate);
    int resizeRateY = int(resizeRate);

    num_t camFramesX = num_t::abs(vScreen[Z].X - qScreenLoc[Z].X).divided_by(camRateX);
    num_t camFramesY = num_t::abs(vScreen[Z].Y - qScreenLoc[Z].Y).divided_by(camRateY);

    // qScreenLoc Width and Height values are only valid if modern section change is disabled
    if(g_config.modern_section_change)
    {
        num_t camFramesX_r = num_t::abs(vScreen[Z].X - vScreen[Z].Width - qScreenLoc[Z].X + qScreenLoc[Z].Width).divided_by(camRateX);
        num_t camFramesY_b = num_t::abs(vScreen[Z].Y - vScreen[Z].Height - qScreenLoc[Z].Y + qScreenLoc[Z].Height).divided_by(camRateY);

        camFramesX = SDL_min(camFramesX, camFramesX_r);
        camFramesY = SDL_min(camFramesY, camFramesY_b);
    }

    num_t resizeFramesX = num_t::abs(vScreen[Z].Width - qScreenLoc[Z].Width) / resizeRateX;
    num_t resizeFramesY = num_t::abs(vScreen[Z].Height - qScreenLoc[Z].Height) / resizeRateY;

    if(!g_config.modern_section_change)
    {
        resizeFramesX = 0;
        resizeFramesY = 0;
    }

    num_t qFramesX = SDL_max(camFramesX, resizeFramesX);
    num_t qFramesY = SDL_max(camFramesY, resizeFramesY);

    // don't continue after this frame if it would arrive next frame
    // (this is the intent of the <5 condition in the vanilla game)
    if(qFramesX < 2.5_n && qFramesY < 2.5_n)
        continue_qScreen = false;

    // but, the original condition occurred *after* adding/subtracting 2, so actually
    // the original game would not continue if it would arrive the frame after next, too
    if(!g_config.modern_section_change && qFramesX < 3.5_n && qFramesY < 3.5_n)
        continue_qScreen = false;

    if(qFramesX < 1)
        qFramesX = 1;
    if(qFramesY < 1)
        qFramesY = 1;

    camRateX = num_t::abs(vScreen[Z].X - qScreenLoc[Z].X).divided_by(qFramesX);
    camRateY = num_t::abs(vScreen[Z].Y - qScreenLoc[Z].Y).divided_by(qFramesY);

    resizeRateX = (int)(num_t::abs(vScreen[Z].Width - qScreenLoc[Z].Width).divided_by(qFramesX));
    resizeRateY = (int)(num_t::abs(vScreen[Z].Height - qScreenLoc[Z].Height).divided_by(qFramesY));

    int screenRateX = (int)(num_t::abs(vScreen[Z].ScreenLeft - qScreenLoc[Z].ScreenLeft).divided_by(qFramesX));
    int screenRateY = (int)(num_t::abs(vScreen[Z].ScreenTop - qScreenLoc[Z].ScreenTop).divided_by(qFramesY));

    if(vScreen[Z].X < qScreenLoc[Z].X - camRateX)
        qScreenLoc[Z].X -= camRateX;
    else if(vScreen[Z].X > qScreenLoc[Z].X + camRateX)
        qScreenLoc[Z].X += camRateX;
    else
        qScreenLoc[Z].X = vScreen[Z].X;

    if(vScreen[Z].Y < qScreenLoc[Z].Y - camRateY)
        qScreenLoc[Z].Y -= camRateY;
    else if(vScreen[Z].Y > qScreenLoc[Z].Y + camRateY)
        qScreenLoc[Z].Y += camRateY;
    else
        qScreenLoc[Z].Y = vScreen[Z].Y;

    if(vScreen[Z].ScreenLeft < qScreenLoc[Z].ScreenLeft - screenRateX)
        qScreenLoc[Z].ScreenLeft -= screenRateX;
    else if(vScreen[Z].ScreenLeft > qScreenLoc[Z].ScreenLeft + screenRateX)
        qScreenLoc[Z].ScreenLeft += screenRateX;
    else
        qScreenLoc[Z].ScreenLeft = vScreen[Z].ScreenLeft;

    if(vScreen[Z].ScreenTop < qScreenLoc[Z].ScreenTop - screenRateY)
        qScreenLoc[Z].ScreenTop -= screenRateY;
    else if(vScreen[Z].ScreenTop > qScreenLoc[Z].ScreenTop + screenRateY)
        qScreenLoc[Z].ScreenTop += screenRateY;
    else
        qScreenLoc[Z].ScreenTop = vScreen[Z].ScreenTop;

    if(vScreen[Z].Width < qScreenLoc[Z].Width - resizeRateX)
        qScreenLoc[Z].Width -= resizeRateX;
    else if(vScreen[Z].Width > qScreenLoc[Z].Width + resizeRateX)
        qScreenLoc[Z].Width += resizeRateX;
    else
        qScreenLoc[Z].Width = vScreen[Z].Width;

    if(vScreen[Z].Height < qScreenLoc[Z].Height - resizeRateY)
        qScreenLoc[Z].Height -= resizeRateY;
    else if(vScreen[Z].Height > qScreenLoc[Z].Height + resizeRateY)
        qScreenLoc[Z].Height += resizeRateY;
    else
        qScreenLoc[Z].Height = vScreen[Z].Height;

    vScreen[Z].X = qScreenLoc[Z].X;
    vScreen[Z].Y = qScreenLoc[Z].Y;

    // update vScreen width / height
    if(g_config.modern_section_change)
    {
        vScreen[Z].Width = (qScreenLoc[Z].Width / 2) * 2;
        vScreen[Z].Height = (qScreenLoc[Z].Height / 2) * 2;
        vScreen[Z].ScreenLeft = qScreenLoc[Z].ScreenLeft;
        vScreen[Z].ScreenTop = qScreenLoc[Z].ScreenTop;
    }

    return continue_qScreen;
}


================================================
FILE: src/graphics/gfx_special_frames.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../graphics.h"
#include "blk_id.h"
#include "game_main.h"
#include "npc_traits.h"

static void s_ConveyorBlockConvertedFrames()
{
    // check whether converted conveyors should use custom frames
    const auto& t = NPCTraits[NPCID_CONVEYOR];

    // non-preferred case, custom frames
    for(int dir_right = 0; dir_right < 2; dir_right++)
    {
        int id = (dir_right) ? BLKID_CONVEYOR_R_CONV : BLKID_CONVEYOR_L_CONV;
        auto& Frame = BlockFrame[id];
        auto& FrameCount = BlockFrame2[id];

        FrameCount += 1;

        if(FrameCount > t.FrameSpeed)
        {
            if(t.FrameStyle == 0)
                Frame += (dir_right) ? 1 : -1;
            else
                Frame += 1;

            FrameCount = 0;
        }

        if(t.FrameStyle == 0)
        {
            if(Frame >= t.TFrames)
                Frame = 0;
            else if(Frame < 0)
                Frame = t.TFrames - 1;
        }
        else if(t.FrameStyle == 1 || t.FrameStyle == 2)
        {
            if(!dir_right)
            {
                if(Frame < 0 || Frame >= t.TFrames)
                    Frame = 0;
            }
            else
            {
                if(Frame < t.TFrames || Frame >= t.TFrames * 2)
                    Frame = t.TFrames;
            }
        }
    }
}

/*Private*/
void SpecialFrames()
{
    SpecialFrameCount[1]++;
    if(SpecialFrameCount[1] >= 6)
    {
        SpecialFrameCount[1] = 0;

        SpecialFrame[1]++;
        if(SpecialFrame[1] >= 2)
            SpecialFrame[1] = 0;
    }

    SpecialFrameCount[2]++;
    if(SpecialFrameCount[2] >= 3)
    {
        SpecialFrameCount[2] = 0;

        SpecialFrame[2]++;
        if(SpecialFrame[2] >= 4)
            SpecialFrame[2] = 0;
    }

    SpecialFrameCount[3]++;
    if(SpecialFrameCount[3] >= 8)
    {
        SpecialFrameCount[3] = 0;

        SpecialFrame[3]++;
        if(SpecialFrame[3] >= 4)
            SpecialFrame[3] = 0;
    }

    // SpecialFrameCount[4]++;
    // if(SpecialFrameCount[4] >= 2.475F)

    bool conveyer_block_difficult_frames = (NPCTraits[NPCID_CONVEYOR].TFrames > 0);

    SpecialFrameCount[4] += 1000;
    if(SpecialFrameCount[4] >= 2475)
    {
        // SpecialFrameCount[4] = SpecialFrameCount[4] - 2.475F;
        SpecialFrameCount[4] -= 2475;

        SpecialFrame[4]++;
        if(SpecialFrame[4] >= 4)
            SpecialFrame[4] = 0;

        // Apply NPC conveyor belt frame to block conveyor belts as well
        if(!FreezeNPCs && !LevelSelect && GamePaused == PauseCode::None)
        {
            for(int i = BLKID_CONVEYOR_L_START; i <= BLKID_CONVEYOR_L_END; i++)
            {
                if(i == BLKID_CONVEYOR_L_CONV && conveyer_block_difficult_frames)
                    continue;

                BlockFrame[i] = SpecialFrame[4];
            }

            for(int i = BLKID_CONVEYOR_R_START; i <= BLKID_CONVEYOR_R_END; i++)
            {
                if(i == BLKID_CONVEYOR_R_CONV && conveyer_block_difficult_frames)
                    continue;

                BlockFrame[i] = 3 - SpecialFrame[4];
            }
        }
    }

    // do conveyor block converted frames if needed
    if(conveyer_block_difficult_frames)
        s_ConveyorBlockConvertedFrames();

    SpecialFrameCount[5]++;
    if(SpecialFrameCount[5] < 20)
        SpecialFrame[5] = 1;
    else if(SpecialFrameCount[5] < 25)
        SpecialFrame[5] = 2;
    else if(SpecialFrameCount[5] < 30)
        SpecialFrame[5] = 3;
    else if(SpecialFrameCount[5] < 35)
        SpecialFrame[5] = 4;
    else if(SpecialFrameCount[5] < 40)
        SpecialFrame[5] = 5;
    else if(SpecialFrameCount[5] < 45)
        SpecialFrame[5] = 1;
    else if(SpecialFrameCount[5] < 50)
        SpecialFrame[5] = 0;
    else
        SpecialFrameCount[5] = 0;

    SpecialFrameCount[6]++;
    if(SpecialFrameCount[6] >= 12)
    {
        SpecialFrameCount[6] = 0;

        SpecialFrame[6]++;
        if(SpecialFrame[6] >= 4)
            SpecialFrame[6] = 0;
    }

    SpecialFrameCount[7]++;
    if(SpecialFrameCount[7] < 8)
        SpecialFrame[7] = 0;
    else if(SpecialFrameCount[7] < 16)
        SpecialFrame[7] = 1;
    else if(SpecialFrameCount[7] < 24)
        SpecialFrame[7] = 2;
    else if(SpecialFrameCount[7] < 32)
        SpecialFrame[7] = 3;
    else if(SpecialFrameCount[7] < 40)
        SpecialFrame[7] = 2;
    else if(SpecialFrameCount[7] < 48)
        SpecialFrame[7] = 1;
    else
        SpecialFrameCount[7] = 0;

    SpecialFrameCount[8]++;
    if(SpecialFrameCount[8] >= 8)
    {
        SpecialFrameCount[8] = 0;

        SpecialFrame[8]++;
        if(SpecialFrame[8] >= 3)
            SpecialFrame[8] = 0;
    }

    SpecialFrameCount[9]++; // Fairy frame
    if(SpecialFrameCount[9] >= 8)
    {
        SpecialFrameCount[9] = 0;

        SpecialFrame[9]++;
        if(SpecialFrame[9] >= 2)
            SpecialFrame[9] = 0;
    }
}

void LevelFramesNotFrozen()
{
    BackgroundFrameCount[26]++;
    if(BackgroundFrameCount[26] >= 8)
    {
        BackgroundFrameCount[26] = 0;

        BackgroundFrame[26]++;
        if(BackgroundFrame[26] >= 8)
            BackgroundFrame[26] = 0;
    }

    BackgroundFrameCount[18]++;
    if(BackgroundFrameCount[18] >= 12)
    {
        BackgroundFrameCount[18] = 0;

        BackgroundFrame[18]++;
        if(BackgroundFrame[18] >= 4)
            BackgroundFrame[18] = 0;

        BackgroundFrame[19] = BackgroundFrame[18];
        BackgroundFrame[20] = BackgroundFrame[18];
        BackgroundFrame[161] = BackgroundFrame[18];
    }

    BackgroundFrameCount[36]++;
    if(BackgroundFrameCount[36] >= 2)
    {
        BackgroundFrameCount[36] = 0;

        BackgroundFrame[36]++;
        if(BackgroundFrame[36] >= 4)
            BackgroundFrame[36] = 0;
    }

    BackgroundFrame[68] = BackgroundFrame[36];

    BackgroundFrameCount[65]++;
    if(BackgroundFrameCount[65] >= 8)
    {
        BackgroundFrameCount[65] = 0;

        BackgroundFrame[65]++;
        if(BackgroundFrame[65] >= 4)
            BackgroundFrame[65] = 0;
    }

    BackgroundFrame[66] = BackgroundFrame[65];
    BackgroundFrame[70] = BackgroundFrame[65];
    BackgroundFrame[100] = BackgroundFrame[65];
    BackgroundFrame[134] = BackgroundFrame[65];
    BackgroundFrame[135] = BackgroundFrame[65];
    BackgroundFrame[136] = BackgroundFrame[65];
    BackgroundFrame[137] = BackgroundFrame[65];
    BackgroundFrame[138] = BackgroundFrame[65];

    BackgroundFrameCount[82]++;
    if(BackgroundFrameCount[82] >= 10)
    {
        BackgroundFrameCount[82] = 0;

        BackgroundFrame[82]++;
        if(BackgroundFrame[82] >= 4)
            BackgroundFrame[82] = 0;
    }

    BackgroundFrameCount[170]++;
    if(BackgroundFrameCount[170] >= 8)
    {
        BackgroundFrameCount[170] = 0;

        BackgroundFrame[170]++;
        if(BackgroundFrame[170] >= 4)
            BackgroundFrame[170] = 0;

        BackgroundFrame[171] = BackgroundFrame[170];
    }

    BackgroundFrameCount[125]++;
    if(BackgroundFrameCount[125] >= 4)
    {
        BackgroundFrameCount[125] = 0;

        if(BackgroundFrame[125] == 0)
            BackgroundFrame[125] = 1;
        else
            BackgroundFrame[125] = 0;
    }
}

void LevelFramesAlways()
{
    BackgroundFrame[172] = BackgroundFrame[66];

    BackgroundFrameCount[158]++;
    if(BackgroundFrameCount[158] >= 6)
    {
        BackgroundFrameCount[158] = 0;

        BackgroundFrame[158]++;
        if(BackgroundFrame[158] >= 4)
            BackgroundFrame[158] = 0;

        BackgroundFrame[159]++;
        if(BackgroundFrame[159] >= 8)
            BackgroundFrame[159] = 0;
    }

    BackgroundFrameCount[168]++;
    if(BackgroundFrameCount[168] >= 8)
    {
        BackgroundFrameCount[168] = 0;

        BackgroundFrame[168]++;
        if(BackgroundFrame[168] >= 8)
            BackgroundFrame[168] = 0;
    }

    BackgroundFrameCount[173]++;
    if(BackgroundFrameCount[173] >= 8)
    {
        BackgroundFrameCount[173] = 0;

        if(BackgroundFrame[173] == 0)
            BackgroundFrame[173] = 1;
        else
            BackgroundFrame[173] = 0;
    }

    BackgroundFrameCount[187]++;
    if(BackgroundFrameCount[187] >= 6)
    {
        BackgroundFrameCount[187] = 0;

        BackgroundFrame[187]++;
        if(BackgroundFrame[187] >= 4)
            BackgroundFrame[187] = 0;

        BackgroundFrame[188] = BackgroundFrame[187];
        BackgroundFrame[189] = BackgroundFrame[187];
        BackgroundFrame[190] = BackgroundFrame[187];
    }

    // Update Coin Frames
    CoinFrame2[1] += 1;
    if(CoinFrame2[1] >= 6)
    {
        CoinFrame2[1] = 0;
        CoinFrame[1] += 1;
        if(CoinFrame[1] >= 4)
            CoinFrame[1] = 0;
    }

    CoinFrame2[2] += 1;
    if(CoinFrame2[2] >= 6)
    {
        CoinFrame2[2] = 0;
        CoinFrame[2] += 1;
        if(CoinFrame[2] >= 7)
            CoinFrame[2] = 0;
    }

    CoinFrame2[3] += 1;
    if(CoinFrame2[3] >= 7)
    {
        CoinFrame2[3] = 0;
        CoinFrame[3] += 1;
        if(CoinFrame[3] >= 4)
            CoinFrame[3] = 0;
    }
}

void WorldFrames()
{
    SceneFrame2[1] += 1;
    if(SceneFrame2[1] >= 12)
    {
        SceneFrame2[1] = 0;
        SceneFrame[1] += 1;
        if(SceneFrame[1] >= 4)
            SceneFrame[1] = 0;
        SceneFrame[4] = SceneFrame[1];
        SceneFrame[5] = SceneFrame[1];
        SceneFrame[6] = SceneFrame[1];
        SceneFrame[9] = SceneFrame[1];
        SceneFrame[10] = SceneFrame[1];
        SceneFrame[12] = SceneFrame[1];
        SceneFrame[51] = SceneFrame[1];
        SceneFrame[52] = SceneFrame[1];
        SceneFrame[53] = SceneFrame[1];
        SceneFrame[54] = SceneFrame[1];
        SceneFrame[55] = SceneFrame[1];
    }
    SceneFrame2[27] += 1;
    if(SceneFrame2[27] >= 8)
    {
        SceneFrame2[27] = 0;
        SceneFrame[27] += 1;
        if(SceneFrame[27] >= 12)
            SceneFrame[27] = 0;
        SceneFrame[28] = SceneFrame[27];
        SceneFrame[29] = SceneFrame[27];
        SceneFrame[30] = SceneFrame[27];
    }
    SceneFrame2[33] += 1;
    if(SceneFrame2[33] >= 4)
    {
        SceneFrame2[33] = 0;
        SceneFrame[33] = SceneFrame[27] + 1;
        if(SceneFrame[33] >= 14)
            SceneFrame[33] = 0;
        SceneFrame[34] = SceneFrame[33];
    }
    SceneFrame2[62] += 1;
    if(SceneFrame2[62] >= 8)
    {
        SceneFrame2[62] = 0;
        SceneFrame[62] += 1;
        if(SceneFrame[62] >= 8)
            SceneFrame[62] = 0;
        SceneFrame[63] = SceneFrame[62];
    }
    LevelFrame2[2] += 1;
    if(LevelFrame2[2] >= 6)
    {
        LevelFrame2[2] = 0;
        LevelFrame[2] += 1;
        if(LevelFrame[2] >= 6)
            LevelFrame[2] = 0;
        LevelFrame[9] = LevelFrame[2];
        LevelFrame[13] = LevelFrame[2];
        LevelFrame[14] = LevelFrame[2];
        LevelFrame[15] = LevelFrame[2];
        LevelFrame[31] = LevelFrame[2];
        LevelFrame[32] = LevelFrame[2];
    }
    LevelFrame2[8] += 1;
    if(LevelFrame2[8] >= 12)
    {
        LevelFrame2[8] = 0;
        LevelFrame[8] += 1;
        if(LevelFrame[8] >= 4)
            LevelFrame[8] = 0;
    }
    LevelFrame2[12] += 1;
    if(LevelFrame2[12] >= 8)
    {
        LevelFrame2[12] = 0;
        LevelFrame[12] += 1;
        if(LevelFrame[12] >= 2)
            LevelFrame[12] = 0;
    }
    LevelFrame2[25] += 1;
    if(LevelFrame2[25] >= 8)
    {
        LevelFrame2[25] = 0;
        LevelFrame[25] += 1;
        if(LevelFrame[25] >= 4)
            LevelFrame[25] = 0;
        LevelFrame[26] = LevelFrame[25];
    }
    TileFrame2[14] += 1;
    if(TileFrame2[14] >= 14)
    {
        TileFrame2[14] = 0;
        TileFrame[14] += 1;
        if(TileFrame[14] >= 4)
            TileFrame[14] = 0;
        TileFrame[27] = TileFrame[14];
        TileFrame[241] = TileFrame[14];
    }
}


================================================
FILE: src/graphics/gfx_special_frames.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_SPECIAL_FRAMES_H
#define GFX_SPECIAL_FRAMES_H

#include "globals.h"

// Private Sub SpecialFrames() 'update frames for special things such as coins and kuribo's shoe
// update frames for special things such as coins and kuribo's shoe (pauses during FreezeNPCs)
extern void SpecialFrames();//PRIVATE

// updates CommonFrame and CommonFrame_Unpaused
inline void CommonFrames()
{
    CommonFrame++;

    if(LevelSelect || !FreezeNPCs)
        CommonFrame_NotFrozen++;
}

// NEW: update level frames that keep going during FreezeNPCs and pause
void LevelFramesAlways();

// NEW: update level frames that stop during FreezeNPCs (but continue during pause)
void LevelFramesNotFrozen();

// NEW: update world frames
void WorldFrames();

#endif // #ifndef GFX_SPECIAL_FRAMES_H


================================================
FILE: src/graphics/gfx_update.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "screen.h"
#include "sdl_proxy/sdl_stdinc.h"

#include <sorting/pdqsort.h>
#include <array>
#include <bitset>

#include "../globals.h"
#include "../frame_timer.h"
#include "../graphics.h"
#include "../collision.h"
#include "../editor.h"
#include "../npc.h"
#include "../player.h"
#include "../gfx.h"
#include "../layers.h"
#include "../main/menu_main.h"
#include "../main/speedrunner.h"
#include "../main/trees.h"
#include "../main/screen_pause.h"
#include "../main/screen_connect.h"
#include "../main/screen_options.h"
#include "../main/screen_quickreconnect.h"
#include "../main/screen_textentry.h"
#include "../main/cheat_code.h"
#include "../config.h"
#include "message.h"
#include "../game_main.h"
#include "../main/game_globals.h"
#include "main/world_globals.h"
#include "main/level_medals.h"
#include "../core/render.h"
#include "../script/luna/luna.h"

#include "npc/npc_activation.h"
#include "npc/npc_queues.h"
#include "npc/section_overlap.h"

#include "effect.h"
#include "npc_id.h"
#include "eff_id.h"
#include "npc_traits.h"
#include "draw_planes.h"

#include "graphics/gfx_special_frames.h"
#include "graphics/gfx_camera.h"
#include "graphics/gfx_keyhole.h"

#ifdef THEXTECH_BUILD_GL_MODERN
#    include "core/opengl/gl_program_bank.h"
#endif

#include <fmt_format_ne.h>

struct ScreenShake_t
{
    // these are all multiplied by 0.001 pixels
    int    forceX = 0;
    int    forceY = 0;
    int    forceDecay = 1000;

    // these are in real pixels
    int    offsetX = 0;
    int    offsetY = 0;
    int    type = SHAKE_RANDOM;
    int    duration = 0;
    int    sign = +1;

    bool   active = false;

    void update()
    {
        if(!active || GameMenu)
            return;

        if(duration <= 0)
        {
            if(forceX > 0)
                forceX -= forceDecay;
            if(forceY > 0)
                forceY -= forceDecay;
        }
        else
            duration--;

        if(forceX <= 0 && forceY <= 0)
        {
            forceX = 0;
            forceY = 0;
            active = false;
        }
        // always perform this section to keep the number of random calls consistent w/legacy sources
        {
            switch(type)
            {
            default:
            case SHAKE_RANDOM:
                offsetX = iRand(forceX / 250) - forceX / 500;
                offsetY = iRand(forceY / 250) - forceY / 500;
                break;
            case SHAKE_SEQUENTIAL:
                offsetX = forceX > 0 ? sign * ((forceX + 500) / 1000) : 0;
                offsetY = forceY > 0 ? sign * ((forceY + 500) / 1000) : 0;
                sign *= -1;
                break;
            }
        }
    }

    void apply()
    {
        if(!active || GameMenu || !g_config.show_screen_shake)
        {
            XRender::offsetViewport(0, 0);
            return;
        }

        XRender::offsetViewport(offsetX, offsetY);
        XRender::offsetViewportIgnore(false);
    }

    void setup(int i_forceX, int i_forceY, int i_type, int i_duration, int i_decay)
    {
        if(GameMenu)
            return;

        i_forceX *= 1000;
        i_forceY *= 1000;

        if((forceX <= 0 && forceY <= 0) || (forceDecay < i_decay))
            forceDecay = i_decay;

        // don't override random shake by sequential while random shake is active
        if((forceX <= 0 && forceY <= 0) || (type != SHAKE_RANDOM))
            type = i_type;

        if(forceX < i_forceX)
            forceX = i_forceX;
        if(forceY < i_forceY)
            forceY = i_forceY;
        if(duration < i_duration)
            duration = i_duration;

        active = true;
    }

    void clear()
    {
        forceX = 0;
        forceY = 0;
        duration = 0;
        active = false;
    }
};

static std::array<ScreenShake_t, c_vScreenCount_visible + 1> s_shakeScreen;
static std::array<bool, c_vScreenCount_visible + 1> s_forcedShakeScreen{false};

//static double s_shakeScreenX = 0;
//static double s_shakeScreenY = 0;
//static int s_shakeScreenType = SHAKE_RANDOM;
//static double s_shakeScreenDuration = 0;
//static double s_shakeScreenSign = +1.0;

static inline int s_round2int(num_t d)
{
    return num_t::floor(d + 0.5_n);
}

void doShakeScreen(int force, int type)
{
    for(auto& shake : s_shakeScreen)
        shake.setup(force, force, type, 0, 1000);
}

void doShakeScreen(int forceX, int forceY, int type, int duration, int decay, const Location_t& source)
{
    for(int Z = 0; Z <= c_vScreenCount_visible; Z++)
    {
        if(Z == 0 || vScreenCollision(Z, source))
            s_shakeScreen[Z].setup(forceX, forceY, type, duration, decay);
    }
}

void doShakeScreenClear()
{
    for(auto& shake : s_shakeScreen)
        shake.clear();

    for(bool& forced : s_forcedShakeScreen)
        forced = false;
}

// some "special" logic for pet mounts, used to be in the draw code
static void PetFrameLogic(NPC_t& n)
{
    if(n.Special == 0)
    {
        if(!FreezeNPCs)
            n.FrameCount += 1;

        if(n.FrameCount >= 70)
        {
            if(!FreezeNPCs)
                n.FrameCount = 0;
        }
    }
    else
    {
        if(!FreezeNPCs)
            n.FrameCount += 1;

        if(n.FrameCount > 8)
            n.FrameCount = 0;

        if(!FreezeNPCs)
            n.Special2 += 1;

        if(n.Special2 > 30)
        {
            if(!FreezeNPCs)
                n.Special2 = 0;
        }
    }

}


// this organizes all of the NPC draw conditions into one queue
class NPC_Draw_Queue_t
{
#ifndef LOW_MEM
    static constexpr int maxDrawNPCs = maxNPCs;
#else
    static constexpr int maxDrawNPCs = 512;
#endif
public:
    uint16_t BG[maxDrawNPCs];
    size_t BG_n;
    uint16_t Low[maxDrawNPCs];
    size_t Low_n;
    uint16_t Iced[maxDrawNPCs];
    size_t Iced_n;
    uint16_t Normal[maxDrawNPCs];
    size_t Normal_n;
    uint16_t Chat[20];
    size_t Chat_n;
    uint16_t Held[20];
    size_t Held_n;
    uint16_t FG[maxDrawNPCs];
    size_t FG_n;
    uint16_t Dropped[20];
    size_t Dropped_n;
    uint16_t Warning[32];
    size_t Warning_n;

    // reset the draw queue for the frame
    void reset()
    {
        BG_n = Low_n = Iced_n = Normal_n = Chat_n = Held_n = FG_n = Dropped_n = Warning_n = 0;
    }

    // add NPC with index A to the draw queue, according to its type properties
    void add(uint16_t A)
    {
        if(NPC[A].Chat)
        {
            if(Chat_n != sizeof(Chat) / sizeof(uint16_t))
            {
                Chat[Chat_n] = A;
                Chat_n += 1;
            }
        }

        if(NPC[A].Effect == NPCEFF_DROP_ITEM)
        {
            if(NPC[A].Effect2 % 3 == 0)
                return;
            if(Dropped_n == sizeof(Dropped) / sizeof(uint16_t))
                return;
            Dropped[Dropped_n] = A;
            Dropped_n += 1;
        }
        else if(
                (
                  (
                    (NPC[A].HoldingPlayer > 0 && Player[NPC[A].HoldingPlayer].Effect != PLREFF_WARP_PIPE && Player[NPC[A].HoldingPlayer].CurMazeZone == 0) ||
                    (NPC[A].Type == NPCID_TOOTHY && NPC[A].vehiclePlr == 0) ||
                    (NPC[A].Type == NPCID_BULLET && NPC[A].CantHurt > 0)
                  ) || NPC[A].Effect == NPCEFF_PET_TONGUE
                ) && NPC[A].Type != NPCID_ITEM_BURIED && !Player[NPC[A].HoldingPlayer].Dead
            )
        {
            if(Held_n == sizeof(Held) / sizeof(uint16_t))
                return;
            Held[Held_n] = A;
            Held_n += 1;
        }
        else if(NPC[A].Effect == NPCEFF_NORMAL && NPC[A]->Foreground && NPC[A].HoldingPlayer == 0 && !NPC[A]->IsACoin)
        {
            if(FG_n == sizeof(FG) / sizeof(uint16_t))
                return;
            FG[FG_n] = A;
            FG_n += 1;
        }
        else if(NPC[A].Type == NPCID_ICE_CUBE && NPC[A].Effect == NPCEFF_NORMAL && NPC[A].HoldingPlayer == 0)
        {
            if(Iced_n == sizeof(Iced) / sizeof(uint16_t))
                return;
            Iced[Iced_n] = A;
            Iced_n += 1;
        }
        else if(NPC[A].Effect == NPCEFF_NORMAL && NPC[A].HoldingPlayer == 0 &&
            (NPC[A].vehiclePlr > 0 || NPC[A].Type == NPCID_VEHICLE || NPC[A].Type == NPCID_CANNONITEM ||
                NPC[A].Type == NPCID_TOOTHYPIPE || NPC[A].Type == NPCID_ITEM_BURIED || NPC[A].Type == NPCID_ROCKET_WOOD ||
                NPC[A].Type == NPCID_FIRE_BOSS_FIRE || NPC[A]->IsACoin))
        {
            if(Low_n == sizeof(Low) / sizeof(uint16_t))
                return;
            Low[Low_n] = A;
            Low_n += 1;
        }
        else if(NPC[A].Type == NPCID_SAW || NPC[A].Type == NPCID_JUMP_PLANT ||
            NPC[A].Effect == NPCEFF_MAZE || (NPC[A].HoldingPlayer && Player[NPC[A].HoldingPlayer].CurMazeZone != 0) ||
            ((NPC[A].Effect == NPCEFF_ENCASED || NPC[A]->IsAVine ||
                    NPC[A].Type == NPCID_BOSS_FRAGILE || NPC[A].Type == NPCID_LIFT_SAND || NPC[A].Type == NPCID_FIRE_PLANT ||
                    NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_BIG_PLANT ||
                    NPC[A].Type == NPCID_LONG_PLANT_UP || NPC[A].Type == NPCID_LONG_PLANT_DOWN || NPC[A].Type == NPCID_BOTTOM_PLANT ||
                    NPC[A].Type == NPCID_SIDE_PLANT || NPC[A].Effect == NPCEFF_EMERGE_UP || NPC[A].Effect == NPCEFF_EMERGE_DOWN ||
                    NPC[A].Effect == NPCEFF_WARP || (NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 0))
                && NPC[A].vehiclePlr == 0))
        {
            if(BG_n == sizeof(BG) / sizeof(uint16_t))
                return;
            BG[BG_n] = A;
            BG_n += 1;

            // vine frames (moved from UpdateNPCs)
            if(NPC[A]->IsAVine)
            {
                if(NPC[A].Type == NPCID_GRN_VINE_S3 || NPC[A].Type == NPCID_RED_VINE_S3)
                    NPC[A].Frame = BlockFrame[5];
                else if(NPC[A].Type >= NPCID_GRN_VINE_S2 && NPC[A].Type <= NPCID_BLU_VINE_BASE_S2)
                    NPC[A].Frame = SpecialFrame[7];
            }
        }
        else if(NPC[A].Effect == NPCEFF_NORMAL && NPC[A].HoldingPlayer == 0)
        {
            if(Normal_n == sizeof(Normal) / sizeof(uint16_t))
                return;

            Normal[Normal_n] = A;
            Normal_n += 1;

            // some "special" logic that has been moved into the logic portion
            if(NPCIsYoshi(NPC[A].Type))
                PetFrameLogic(NPC[A]);
        }
    }

    void add_warning(uint16_t A)
    {
        if(Warning_n != sizeof(Warning) / sizeof(uint16_t))
        {
            Warning[Warning_n] = A;
            Warning_n += 1;
        }
    }

    // sort each queue properly
    void sort()
    {
        pdqsort(&BG[0], &BG[BG_n]);
        pdqsort(&Low[0], &Low[Low_n]);
        pdqsort(&Iced[0], &Iced[Iced_n]);
        pdqsort(&Normal[0], &Normal[Normal_n]);
        pdqsort(&Chat[0], &Chat[Chat_n]);
        pdqsort(&Held[0], &Held[Held_n]);
        pdqsort(&FG[0], &FG[FG_n]);
        pdqsort(&Dropped[0], &Dropped[Dropped_n]);
        pdqsort(&Warning[0], &Warning[Warning_n]);
    }
};

NPC_Draw_Queue_t NPC_Draw_Queue[maxLocalPlayers] = {NPC_Draw_Queue_t(), NPC_Draw_Queue_t()};

constexpr int NPC_intro_length = 8;
constexpr uint8_t NPC_shade_opacity = 100;
constexpr size_t NPC_intro_count_MAX = 32;

uint8_t NPC_intro_count = 0;
int16_t NPC_intro[NPC_intro_count_MAX];
// positive values represent just-activated onscreen NPCs; negative values represent conditionally active NPCs
int8_t NPC_intro_frame[NPC_intro_count_MAX];

static inline void s_RemoveIntroNPC(int i)
{
    NPC_intro_count--;
    NPC_intro[i] = NPC_intro[NPC_intro_count];
    NPC_intro_frame[i] = NPC_intro_frame[NPC_intro_count];
}

static inline void ProcessIntroNPCFrames()
{
    for(uint8_t i = 0; i < NPC_intro_count; i++)
    {
        NPC_intro_frame[i]++;

        // two termination conditions, remove the NPC from the intro list either way
        if(NPC_intro_frame[i] == NPC_intro_length || NPC_intro_frame[i] == 0)
        {
            s_RemoveIntroNPC(i);

            // don't advance the iteration counter, since a new NPC is here now
            i--;
        }
    }
}

// tints NPCS
static inline void s_get_NPC_tint(int A, XTColor& cn)
{
    const NPC_t& n = NPC[A];

    if(!LevelEditor)
    {
        if(!n.Active)
        {
            if(!NPC_InactiveRender(n) || g_CheatLogicScreen)
            {
                cn = XTColorF(0.0_n, 0.0_n, 0.0_n, 0.4_n);
                return;
            }
        }
        else for(uint8_t i = 0; i < NPC_intro_count; i++)
        {
            if(NPC_intro[i] == A)
            {
                if(NPC_intro_frame[i] >= 0)
                {
                    uint8_t c = uint8_t(256 * NPC_intro_frame[i] / NPC_intro_length);
                    uint8_t a_add = uint8_t((256 - NPC_shade_opacity) * NPC_intro_frame[i] / NPC_intro_length);
                    cn = XTColor(c, c, c, NPC_shade_opacity + a_add);
                    return;
                }
                break;
            }
        }
    }

    cn = n.Shadow ? XTColor(64, 64, 64) : XTColor();

    if(n.Effect == NPCEFF_DROP_ITEM && n.Effect3 != 0)
    {
        cn = (NPC[A].Special5 <= 66) ? XTAlpha(128 + (66 - NPC[A].Special5) + (int)(32 * num_t::cos((num_t)NPC[A].Special5 / 4))) : XTAlpha(128);
    }
}

// draws a warning icon for offscreen active NPC A on vScreen Z
void DrawWarningNPC(int Z, num_t camX, num_t camY, int A)
{
    g_stats.renderedNPCs++;

    XTColor cn;
    s_get_NPC_tint(A, cn);

    int scr_x = num_t::floor(camX + NPC[A].Location.X) + NPC[A]->FrameOffsetX;
    int scr_y = num_t::floor(camY + NPC[A].Location.Y) + NPC[A]->FrameOffsetY;
    int w = s_round2int(NPC[A].Location.Width);
    int h = s_round2int(NPC[A].Location.Height);
    int frame_h = NPC[A]->THeight;

    int frame_x = 0, frame_y = 0;

    // some special cases: plants that come from below
    if(NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_BIG_PLANT || NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_FIRE_PLANT || NPC[A].Type == NPCID_LONG_PLANT_UP || NPC[A].Type == NPCID_JUMP_PLANT)
    {
        // these are actually normal but don't have WidthGFX set to 0
    }
    // plants from above
    else if(NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_LONG_PLANT_DOWN)
    {
        frame_y = frame_h - h;
    }
    // plants from side
    else if(NPC[A].Type == NPCID_SIDE_PLANT)
    {
        if(NPC[A].Direction != -1)
            frame_x = NPC[A]->TWidth - w;
    }
    else if(NPC[A]->WidthGFX == 0)
    {
        // this is the most normal case
    }
    else
    {
        if(NPC[A].Direction == 1)
            scr_x -= NPC[A]->FrameOffsetX * 2;

        scr_x += (w - NPC[A]->WidthGFX) / 2;
        scr_y += (h - NPC[A]->HeightGFX);

        w = NPC[A]->WidthGFX;
        frame_h = h = NPC[A]->HeightGFX;
    }

    int left_x = -scr_x;
    int right_x = scr_x + w - vScreen[Z].Width;

    int add_x = (left_x > 0 ? left_x : (right_x > 0 ? -right_x : 0));

    int top_y = -scr_y;
    int bottom_y = scr_y + h - vScreen[Z].Height;

    int add_y = (top_y > 0 ? top_y : (bottom_y > 0 ? -bottom_y : 0));

    int total_off = (add_x > 0 ? add_x : -add_x)
        + (add_y > 0 ? add_y : -add_y);

    if(total_off >= 256)
        return;

    int a_scale = (int(cn.a) * (256 - total_off)) / 512;
    if(a_scale > 255)
        a_scale = 255;

    cn.a = uint8_t(a_scale);

    int scale = 128 + (256 - total_off);

    scr_x += w * (512 - scale) / 1024;
    scr_y += h * (512 - scale) / 512;

    int exclam_x = 2;
    int exclam_y = 2;

    // push it onto the screen
    if(scr_x < 0)
    {
        scr_x = 0;
        exclam_x = 1;
    }
    else if(scr_x + w * scale / 512 > vScreen[Z].Width)
    {
        scr_x = vScreen[Z].Width - w * scale / 512;
        exclam_x = 3;
    }

    if(scr_y < 0)
    {
        scr_y = 0;
        exclam_y = 1;
    }
    else if(scr_y + h * scale / 512 > vScreen[Z].Height)
    {
        scr_y = vScreen[Z].Height - h * scale / 512;
        exclam_y = 3;
    }

    XRender::renderTextureScaleEx(scr_x,
        scr_y,
        w * scale / 512, h * scale / 512,
        GFXNPC[NPC[A].Type],
        frame_x, NPC[A].Frame * frame_h + frame_y,
        w, h,
        0, nullptr, X_FLIP_NONE,
        cn);

    XRender::renderTextureBasic(scr_x + (w * scale / 512 - GFX.Chat.w) * exclam_x / 4,
        scr_y + (h * scale / 512 - GFX.Chat.h) * exclam_y / 4,
        GFX.Chat,
        {255, 0, 0, cn.a});
}

// draw wings for an NPC
void DrawNPCWings(const NPC_t& n, int sX, int sY, XTColor cn)
{
    int w = (int)(n->TWidth);
    int h = (int)(n->THeight);
    int h_gfx = (n->HeightGFX) ? n->HeightGFX : h;
    int npcY = (int)(n.Location.Y);

    int draw_frame = ((npcY - CommonFrame_NotFrozen) >> 5) & 1;

    bool one_direction = (w <= 64);

    if(n.Type == NPCID_MINIBOSS || n.Type == NPCID_QUAD_SPITTER)
    {
        one_direction = false;
        sX += 8;
        w -= 16;
    }
    else if(n.Type == NPCID_SPRING && !LevelEditor)
        sY -= 16;

    for(int direction = 0; direction < 2; direction++)
    {
        if(one_direction)
            direction = n.Direction;

        if(direction == 1)
            draw_frame += 2;

        XRender::renderTextureBasic((direction == 1) ? (sX - 20) : (sX + w + 20 - 32),
                              sY + h - h_gfx / 4 - 32,
                              32, 32, GFX.YoshiWings, 0, 0 + 32 * draw_frame, cn);

        if(one_direction)
            break;
    }
}

void DrawNPC(num_t camX, num_t camY, int A)
{
    g_stats.renderedNPCs++;

    XTColor cn;
    s_get_NPC_tint(A, cn);

    int sX = num_t::floor(camX + NPC[A].Location.X);
    int sY = num_t::floor(camY + NPC[A].Location.Y);
    int drawX = sX + NPC[A]->FrameOffsetX;
    int drawY = sY + NPC[A]->FrameOffsetY;
    int w = s_round2int(NPC[A].Location.Width);
    int h = s_round2int(NPC[A].Location.Height);

    int src_x = NPC[A].GFXSlot * ((NPC[A]->WidthGFX != 0) ? NPC[A]->WidthGFX : NPC[A]->TWidth);
    if(src_x >= GFXNPCBMP[NPC[A].Type].w)
        src_x = 0;

    if(NPC[A].Type == NPCID_MEDAL && g_curLevelMedals.gotten(NPC[A].Variant - 1))
        cn.a /= 2;

    if(NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_BIG_PLANT || NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_FIRE_PLANT || NPC[A].Type == NPCID_LONG_PLANT_UP || NPC[A].Type == NPCID_JUMP_PLANT || NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_LONG_PLANT_DOWN || NPC[A].Type == NPCID_SIDE_PLANT)
    {
        int x_off = 0;
        if(NPC[A].Type == NPCID_SIDE_PLANT && NPC[A].Direction != -1)
            x_off = NPC[A]->TWidth - w;

        int y_off = NPC[A].Frame * NPC[A]->THeight;
        if(NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_LONG_PLANT_DOWN)
            y_off += NPC[A]->THeight - h;

        XRender::renderTextureBasic(drawX, drawY, w, h,
            GFXNPC[NPC[A].Type],
            src_x + x_off, y_off,
            cn);
    }
    else if(NPC[A].Type == NPCID_ICE_CUBE)
        DrawFrozenNPC(camX, camY, A);
    else if(NPCIsYoshi(NPC[A]))
    {
        int B = 1;

        if(NPC[A].Type == NPCID_PET_GREEN)
            B = 1;
        else if(NPC[A].Type == NPCID_PET_BLUE)
            B = 2;
        else if(NPC[A].Type == NPCID_PET_YELLOW)
            B = 3;
        else if(NPC[A].Type == NPCID_PET_RED)
            B = 4;
        else if(NPC[A].Type == NPCID_PET_BLACK)
            B = 5;
        else if(NPC[A].Type == NPCID_PET_PURPLE)
            B = 6;
        else if(NPC[A].Type == NPCID_PET_PINK)
            B = 7;
        else if(NPC[A].Type == NPCID_PET_CYAN)
            B = 8;

        int YoshiBX = 0;
        int YoshiBY = 0;
        int YoshiTX = 20;
        int YoshiTY = -32;
        int YoshiTFrame = 0;
        int YoshiBFrame = 0;

        // there was "special" logic affecting FrameCount and Special2, moved to logic side
        if(NPC[A].Special == 0)
        {
            if(NPC[A].FrameCount >= 70)
            {
                // there was a logic assignment here
            }
            else if(NPC[A].FrameCount >= 50)
                YoshiTFrame = 3;

            YoshiBFrame = 6;
            YoshiBY += 10;
            YoshiTY += 10;
        }
        else
        {
            // FrameCount > 8 remapped to FrameCount = 0 in PetFrameLogic
            if(NPC[A].FrameCount > 4 && NPC[A].FrameCount < 6) // previously > 4
            {
                YoshiBFrame = 2;
                YoshiTX -= 2;
                YoshiTY += 4;
                YoshiBY += 2;
            }
            else if(NPC[A].FrameCount > 2) // previously > 6 or > 2
            {
                YoshiBFrame = 1;
                YoshiTX -= 1;
                YoshiTY += 2;
                YoshiBY += 1;
            }

            if(NPC[A].Special2 > 10 && NPC[A].Special2 <= 30)
                YoshiTFrame = 2;
        }

        if(NPC[A].Direction == 1)
        {
            YoshiTFrame += 5;
            YoshiBFrame += 7;
        }
        else
        {
            YoshiBX = -YoshiBX;
            YoshiTX = -YoshiTX;
        }

        // Yoshi's Body
        XRender::renderTextureBasic(sX + YoshiBX, sY + YoshiBY, 32, 32, GFXYoshiB[B], 0, 32 * YoshiBFrame, cn);

        // Yoshi's Head
        XRender::renderTextureBasic(sX + YoshiTX, sY + YoshiTY, 32, 32, GFXYoshiT[B], 0, 32 * YoshiTFrame, cn);
    }
    // fix a graphical SMBX64 bug where the draw width and frame stride were incorrect
    else if(NPC[A].Effect == NPCEFF_EMERGE_UP)
    {
        if(NPC[A]->WidthGFX != 0 && g_config.fix_visual_bugs)
        {
            XRender::renderTextureBasic(sX + (NPC[A]->FrameOffsetX * -NPC[A].Direction) - NPC[A]->WidthGFX / 2 + w / 2, drawY, NPC[A]->WidthGFX, h,
                GFXNPC[NPC[A].Type],
                src_x, NPC[A].Frame * NPC[A]->HeightGFX,
                cn);
        }
        else
        {
            XRender::renderTextureBasic(drawX, drawY, w, h,
                GFXNPC[NPC[A].Type],
                src_x, NPC[A].Frame * NPC[A]->THeight,
                cn);
        }
    }
    else if(NPC[A]->WidthGFX == 0)
    {
        XRender::renderTextureBasic(drawX,
            drawY,
            w,
            h,
            GFXNPC[NPC[A].Type],
            src_x, NPC[A].Frame * h,
            cn);
    }
    else
    {
        if(NPC[A].Type == NPCID_ITEM_BUBBLE && NPC[A].Special > 0)
        {
            int contents_w, contents_h;

            if(NPCWidthGFX(NPC[A].Special) == 0)
            {
                contents_w = NPCWidth(NPC[A].Special);
                contents_h = NPCHeight(NPC[A].Special);
            }
            else
            {
                contents_w = NPCWidthGFX(NPC[A].Special);
                contents_h = NPCHeightGFX(NPC[A].Special);
            }

            int contents_sX = sX + w / 2 - contents_w / 2;
            int contents_sY = sY + h / 2 - contents_h / 2;

            int contents_frame = EditorNPCFrame((NPCID)(NPC[A].Special), NPC[A].Direction);

            // note: using NPC[A]->FrameOffsetX here doesn't really make sense, but it's the SMBX 1.3 logic
            XRender::renderTextureBasic(contents_sX + NPC[A]->FrameOffsetX, contents_sY, contents_w, contents_h,
                GFXNPC[NPC[A].Special],
                NPC[A].GFXSlot * contents_w, contents_frame * contents_h,
                cn);

            if(NPC[A].DefaultWings)
                DrawNPCWings(NPC[A], sX, sY, cn);

            src_x = 0;
        }

        // WARNING: the BG case previously didn't have -NPC[A].Direction here.
        // I've checked and only NPCID_SAW, NPCID_JUMP_PLANT, NPCID_BOSS_FRAGILE, NPCID_LIFT_SAND, and NPCID_SLIDE_BLOCK could possibly be affected.
        // in my episode corpus, none of them set gfxoffsetx to a non-zero value (maybe because it acts differently from normal),
        // but watch for any visual changes that result from this
        XRender::renderTextureBasic(sX + (NPC[A]->FrameOffsetX * -NPC[A].Direction) - NPC[A]->WidthGFX / 2 + w / 2,
            drawY - NPC[A]->HeightGFX + h,
            NPC[A]->WidthGFX,
            NPC[A]->HeightGFX,
            GFXNPC[NPC[A].Type],
            src_x,
            NPC[A].Frame * NPC[A]->HeightGFX,
            cn);
    }

    if(NPC[A].Wings)
        DrawNPCWings(NPC[A], sX, sY, cn);

    // countdown during modern item drop
    if(NPC[A].Effect == NPCEFF_DROP_ITEM && NPC[A].Effect3 != 0 && NPC[A].Special5 <= 66)
    {
        int i = (NPC[A].Special5 - 1) / 22 + 1;
        XRender::renderTextureBasic(sX + w / 2 - GFX.Font1[i].w / 2,
            sY + h / 2 - GFX.Font1[i].h / 2,
            GFX.Font1[i]);
    }
}

// code to facilitate cached values for the onscreen blocks and BGOs
// intentionally only initialize the vectors for the first 2 screens since >2P mode is rare

// query results of last tree query
static std::vector<BlockRef_t> s_drawMainBlocks[maxLocalPlayers] = {std::vector<BlockRef_t>(400), std::vector<BlockRef_t>(400)};
static std::vector<BlockRef_t> s_drawLavaBlocks[maxLocalPlayers] = {std::vector<BlockRef_t>(100), std::vector<BlockRef_t>(100)};
static std::vector<BlockRef_t> s_drawSBlocks[maxLocalPlayers] = {std::vector<BlockRef_t>(40), std::vector<BlockRef_t>(40)};
static std::vector<BaseRef_t> s_drawBGOs[maxLocalPlayers] = {std::vector<BaseRef_t>(400), std::vector<BaseRef_t>(400)};

// query location of last tree query
static Location_t s_drawBlocks_bounds[maxLocalPlayers];
static Location_t s_drawBGOs_bounds[maxLocalPlayers];

// maximum amount of layer movement since last tree query
static num_t s_drawBlocks_invalidate_timer[maxLocalPlayers] = {0, 0};
static num_t s_drawBGOs_invalidate_timer[maxLocalPlayers] = {0, 0};

// global: force-invalidate the cache when the blocks themselves change
std::array<bool, maxLocalPlayers> g_drawBlocks_valid{};
std::array<bool, maxLocalPlayers> g_drawBGOs_valid{};

// global: based on layer movement speed, set in layers.cpp
num_t g_drawBlocks_invalidate_rate = 0;
num_t g_drawBGOs_invalidate_rate = 0;


// Performance-tweakable code. This is the margin away from the vScreen that is filled when onscreen blocks and BGOs are calculated.
//   Larger values result in more offscreen blocks / BGOs being checked.
//   Smaller values result in more frequent block / BGO table queries.
constexpr num_t i_drawBlocks_margin = 64;
constexpr num_t i_drawBGOs_margin = 128;

// updates the lists of blocks and BGOs to draw on i'th vScreen of screen
void s_UpdateDrawItems(Screen_t& screen, int i)
{
    vScreen_t& vscreen = screen.vScreen(i + 1);

    if(i < 0 || i >= maxLocalPlayers)
        return;

    // based on layer movement speed
    s_drawBlocks_invalidate_timer[i] += g_drawBlocks_invalidate_rate;
    s_drawBGOs_invalidate_timer[i] += g_drawBGOs_invalidate_rate;


    // update draw blocks if needed
    if(!g_drawBlocks_valid[i]
        || -vscreen.X                  < s_drawBlocks_bounds[i].X                                 + s_drawBlocks_invalidate_timer[i]
        || -vscreen.X + vscreen.Width  > s_drawBlocks_bounds[i].X + s_drawBlocks_bounds[i].Width  - s_drawBlocks_invalidate_timer[i]
        || -vscreen.Y                  < s_drawBlocks_bounds[i].Y                                 + s_drawBlocks_invalidate_timer[i]
        || -vscreen.Y + vscreen.Height > s_drawBlocks_bounds[i].Y + s_drawBlocks_bounds[i].Height - s_drawBlocks_invalidate_timer[i])
    {
        g_drawBlocks_valid[i] = true;
        s_drawBlocks_invalidate_timer[i] = 0;

        // form query location
        s_drawBlocks_bounds[i] = newLoc(-vscreen.X - i_drawBlocks_margin,
            -vscreen.Y - i_drawBlocks_margin,
            vscreen.Width + i_drawBlocks_margin * 2,
            vscreen.Height + i_drawBlocks_margin * 2);

        // make query (sort by ID as done in vanilla)
        TreeResult_Sentinel<BlockRef_t> areaBlocks = treeFLBlockQuery(s_drawBlocks_bounds[i], SORTMODE_ID);

        // load query results into different sets of blocks
        s_drawSBlocks[i].clear();
        s_drawMainBlocks[i].clear();
        s_drawLavaBlocks[i].clear();

        for(BlockRef_t b : areaBlocks)
        {
            if(b->Hidden)
                continue;
            if(b->Type == 0)
                continue;

            if(BlockIsSizable[b->Type])
                s_drawSBlocks[i].push_back(b);
            else if(BlockKills[b->Type])
                s_drawLavaBlocks[i].push_back(b);
            else
                s_drawMainBlocks[i].push_back(b);
        }

        // sort the Sizable blocks
        // cross-ref the dead code at sorting.cpp:qSortSBlocks
        std::stable_sort(s_drawSBlocks[i].begin(), s_drawSBlocks[i].end(),
            [](BlockRef_t a, BlockRef_t b)
            {
                return a->Location.Y < b->Location.Y;
            });
    }

    // update draw BGOs if needed
    if(!g_drawBGOs_valid[i]
        || -vscreen.X                  < s_drawBGOs_bounds[i].X                               + s_drawBGOs_invalidate_timer[i]
        || -vscreen.X + vscreen.Width  > s_drawBGOs_bounds[i].X + s_drawBGOs_bounds[i].Width  - s_drawBGOs_invalidate_timer[i]
        || -vscreen.Y                  < s_drawBGOs_bounds[i].Y                               + s_drawBGOs_invalidate_timer[i]
        || -vscreen.Y + vscreen.Height > s_drawBGOs_bounds[i].Y + s_drawBGOs_bounds[i].Height - s_drawBGOs_invalidate_timer[i])
    {
        g_drawBGOs_valid[i] = true;
        s_drawBGOs_invalidate_timer[i] = 0;

        // form query location
        s_drawBGOs_bounds[i] = newLoc(-vscreen.X - i_drawBGOs_margin,
            -vscreen.Y - i_drawBGOs_margin,
            vscreen.Width + i_drawBGOs_margin * 2,
            vscreen.Height + i_drawBGOs_margin * 2);

        // make query (sort by ID as done in vanilla)
        s_drawBGOs[i].clear();
        treeBackgroundQuery(s_drawBGOs[i], s_drawBGOs_bounds[i], (LevelEditor) ? SORTMODE_Z : SORTMODE_ID);
    }
}

void GraphicsLazyPreLoad()
{
    // FIXME: update to work for multiple screens
    // TODO: check if this is needed at caller
    SetupScreens(false);

    // TODO: check whether this is even safe
    DynamicScreens();

    int numScreens = Screens[0].active_end();

    if(SingleCoop == 2)
        numScreens = 1; // fine to be 1, since it would just be run for Z = 2 twice otherwise;

    CenterScreens(Screens[0]);

    For(Z, 1, numScreens)
    {
        if(SingleCoop == 2)
            Z = 2;

        // TODO: need to get vScreen?

        int S = Player[Z].Section;
        int bg = Background2[S];

        switch(bg)
        {
        case 1: // Double-row background
            XRender::lazyPreLoad(GFXBackground2[1]);
            XRender::lazyPreLoad(GFXBackground2[2]);
            break;

        case 2: // Single-row clouds background
            XRender::lazyPreLoad(GFXBackground2[2]);
            break;

        case 3: // Double-row background
            XRender::lazyPreLoad(GFXBackground2[3]);
            XRender::lazyPreLoad(GFXBackground2[2]);
            break;
        case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12: case 13:
            // All these backgrounds do use picture with the number less with 1
            XRender::lazyPreLoad(GFXBackground2[bg - 1]);
            break;
        case 22: // Double-row background
            XRender::lazyPreLoad(GFXBackground2[22]);
            XRender::lazyPreLoad(GFXBackground2[2]);
            break;

        default: // Any other normal backgrounds
            if(bg < 1 || bg > maxBackgroundType)
                break; // Don't crash it, stupid!
            XRender::lazyPreLoad(GFXBackground2[bg]);
            break;
        }

        For(A, 1, numPlayers)
        {
            Player_t &p = Player[A];
            int c = p.Character;
            int s = p.State;

            switch(c)
            {
            case 1:
                XRender::lazyPreLoad(GFXMarioBMP[s]);
                break;
            case 2:
                XRender::lazyPreLoad(GFXLuigiBMP[s]);
                break;
            case 3:
                XRender::lazyPreLoad(GFXPeachBMP[s]);
                break;
            case 4:
                XRender::lazyPreLoad(GFXToadBMP[s]);
                break;
            case 5:
                XRender::lazyPreLoad(GFXLinkBMP[s]);
                break;
            default: // Trap
                abort(); // "Please fix me up if you implemented a new playable character, see gfx_update.cpp!"
                return;
            }
        }

        // int64_t fBlock = 0;
        // int64_t lBlock = 0;
        // blockTileGet(-vScreen[Z].X, vScreen[Z].Width, fBlock, lBlock);
        s_UpdateDrawItems(Screens[0], Z - 1);

        for(Block_t& b : s_drawSBlocks[Z - 1])
        {
            if(vScreenCollision(Z, b.Location) && !b.Hidden && IF_INRANGE(b.Type, 1, maxBlockType))
                XRender::lazyPreLoad(GFXBlock[b.Type]);
        }

        for(Block_t& b : s_drawMainBlocks[Z - 1])
        {
            if(vScreenCollision(Z, b.Location) && !b.Hidden && IF_INRANGE(b.Type, 1, maxBlockType))
                XRender::lazyPreLoad(GFXBlock[b.Type]);
        }

        for(Block_t& b : s_drawLavaBlocks[Z - 1])
        {
            if(vScreenCollision(Z, b.Location) && !b.Hidden && IF_INRANGE(b.Type, 1, maxBlockType))
                XRender::lazyPreLoad(GFXBlock[b.Type]);
        }

        for(BackgroundRef_t bgo : s_drawBGOs[Z - 1])
        {
            Background_t& b = bgo;
            if(vScreenCollision(Z, b.Location) && !b.Hidden && IF_INRANGE(b.Type, 1, maxBackgroundType))
                XRender::lazyPreLoad(GFXBackgroundBMP[b.Type]);
        }

        for(int A = 1; A <= numNPCs; A++)
        {
            auto &n = NPC[A];
            if(vScreenCollision(Z, n.Location) && IF_INRANGE(n.Type, 0, maxNPCType))
                XRender::lazyPreLoad(GFXNPC[n.Type]);
        }
    }
}

// swappable buffer for previous frame's NoReset NPCs
static std::vector<NPCRef_t> s_NoReset_NPCs_LastFrame;

// shared between the NPC screen logic functions, always reset to 0 between frames
static std::bitset<maxNPCs> s_NPC_present;

// does the classic ("onscreen") NPC activation / reset logic for vScreen Z, directly based on the many NPC loops of the original game
void ClassicNPCScreenLogic(int Z, int numScreens, bool fill_draw_queue, NPC_Draw_Queue_t& NPC_Draw_Queue_p)
{
    // using bitset here instead of simpler set because I benchmarked it to be faster -- ds-sloth
    std::bitset<maxNPCs>& NPC_present = s_NPC_present;

    // find the onscreen NPCs
    TreeResult_Sentinel<NPCRef_t> _screenNPCs = treeNPCQuery(-vScreen[Z].X, -vScreen[Z].Y,
        -vScreen[Z].X + vScreen[Z].Width, -vScreen[Z].Y + vScreen[Z].Height,
        SORTMODE_NONE);

    // combine the onscreen NPCs with the no-reset NPCs
    std::vector<BaseRef_t>& checkNPCs = *_screenNPCs.i_vec;

    // mark previous ones as checked
    for(int16_t n : checkNPCs)
        NPC_present[n] = true;

    // add the previous frame's no-reset NPCs
    for(int16_t n : s_NoReset_NPCs_LastFrame)
    {
        if(n <= numNPCs && !NPC_present[n])
        {
            checkNPCs.push_back(n);
            NPC_present[n] = true;
        }
    }

    // cleanup the checked NPCs
    for(int16_t n : checkNPCs)
        NPC_present[n] = false;

    // allocate it outside the loop; use it only when needed
    Location_t npcALoc;

    // following logic is somewhat difficult to read but includes the precise conditions
    // from each NPC check in the original UpdateGraphics to determine how to handle each NPC
    for(int A : checkNPCs)
    {
        bool has_ALoc = false;
        bool check_both_reset = false;
        bool check_long_life = false;
        bool activate_conveyer = false;
        bool kill_zero = false;
        bool set_justactivated = true;
        bool can_check = false;
        bool reset_all = true;

        if(((NPC[A].Effect == NPCEFF_ENCASED || NPC[A]->IsAVine ||
             NPC[A].Type == NPCID_BOSS_FRAGILE || NPC[A].Type == NPCID_LIFT_SAND || NPC[A].Type == NPCID_FIRE_PLANT ||
             NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_BIG_PLANT ||
             NPC[A].Type == NPCID_LONG_PLANT_UP || NPC[A].Type == NPCID_LONG_PLANT_DOWN || NPC[A].Type == NPCID_BOTTOM_PLANT ||
             NPC[A].Type == NPCID_SIDE_PLANT || NPC[A].Effect == NPCEFF_EMERGE_UP || NPC[A].Effect == NPCEFF_EMERGE_DOWN ||
             NPC[A].Effect == NPCEFF_WARP || NPC[A].Effect == NPCEFF_MAZE || (NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 0)) &&
             (NPC[A].vehiclePlr == 0 && (!NPC[A].Generator || LevelEditor))) ||
             NPC[A].Type == NPCID_SAW || NPC[A].Type == NPCID_JUMP_PLANT)
        {
            if(NPC[A].Effect != NPCEFF_DROP_ITEM && (!NPC[A].Generator || LevelEditor))
            {
                can_check = true;
            }
        }

        if(NPC[A].Effect == NPCEFF_NORMAL && ((NPC[A].HoldingPlayer == 0 && (NPC[A].vehiclePlr > 0 || NPC[A].Type == NPCID_VEHICLE ||
                                   NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_TOOTHYPIPE || NPC[A].Type == NPCID_ITEM_BURIED || NPC[A].Type == NPCID_ROCKET_WOOD ||
                                   NPC[A].Type == NPCID_FIRE_BOSS_FIRE || NPC[A]->IsACoin) && (!NPC[A].Generator || LevelEditor))))
        {
            npcALoc = newLoc(NPC[A].Location.X - (NPC[A]->WidthGFX - NPC[A].Location.Width) / 2,
                                  NPC[A].Location.Y,
                                  NPC[A]->WidthGFX,
                                  NPC[A]->THeight);
            has_ALoc = true;
            can_check = true;
        }

        if(NPC[A].Type == NPCID_ICE_CUBE && NPC[A].Effect == NPCEFF_NORMAL && NPC[A].HoldingPlayer == 0)
        {
            npcALoc = newLoc(NPC[A].Location.X - (NPC[A]->WidthGFX - NPC[A].Location.Width) / 2,
                                  NPC[A].Location.Y,
                                  NPC[A]->WidthGFX,
                                  NPC[A]->THeight);

            has_ALoc = true;
            can_check = true;
        }


        if(NPC[A].Effect == NPCEFF_NORMAL)
        {
            if(!(NPC[A].HoldingPlayer > 0 || NPC[A]->IsAVine || NPC[A].Type == NPCID_BOSS_FRAGILE || NPC[A].Type == NPCID_FIRE_BOSS_FIRE ||
                 NPC[A].Type == NPCID_JUMP_PLANT || NPC[A].Type == NPCID_ROCKET_WOOD || NPC[A].Type == NPCID_LIFT_SAND || NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_FIRE_PLANT ||
                 NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_SIDE_PLANT || NPC[A].Type == NPCID_BIG_PLANT || NPC[A].Type == NPCID_LONG_PLANT_UP ||
                 NPC[A].Type == NPCID_LONG_PLANT_DOWN || NPC[A].Type == NPCID_VEHICLE || NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_TOOTHYPIPE || NPC[A].Type == NPCID_ITEM_BURIED) &&
               !(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 0) && NPC[A].vehiclePlr == 0 &&
               !NPC[A]->Foreground && (!NPC[A].Generator || LevelEditor) &&
               NPC[A].Type != NPCID_SAW && NPC[A].Type != NPCID_ICE_CUBE)
            {
                if(!NPC[A]->IsACoin)
                {
                    can_check = true;
                    kill_zero = true;
                    activate_conveyer = true;
                    check_both_reset = true;
                    check_long_life = true;
                }
            }
        }


        const Player_t& hp = Player[NPC[A].HoldingPlayer];
        bool hp_door_scroll = (NPC[A].HoldingPlayer > 0 && hp.Effect == PLREFF_WARP_DOOR && hp.Effect2 >= 128);

        if(
            (
              (
                (NPC[A].HoldingPlayer > 0 && hp.Effect != PLREFF_WARP_PIPE && !hp_door_scroll) ||
                (NPC[A].Type == NPCID_TOOTHY && NPC[A].vehiclePlr == 0) ||
                (NPC[A].Type == NPCID_BULLET && NPC[A].CantHurt > 0)
              ) || NPC[A].Effect == NPCEFF_PET_TONGUE
            ) && NPC[A].Type != NPCID_ITEM_BURIED && !Player[NPC[A].HoldingPlayer].Dead
        )
        {
            NPC_Draw_Queue_p.add(A);
        }

        if(NPC[A].Effect == NPCEFF_NORMAL)
        {
            if(NPC[A]->Foreground && NPC[A].HoldingPlayer == 0 && (!NPC[A].Generator || LevelEditor))
            {
                if(!NPC[A]->IsACoin)
                {
                    can_check = true;
                    check_both_reset = true;
                }
            }
        }

        if(NPC[A].Generator)
        {
            if(vScreenCollision(Z, NPC[A].Location) && !NPC[A].Hidden)
                NPC[A].GeneratorActive = true;
        }

        if(NPC[A].Effect == NPCEFF_DROP_ITEM)
        {
            if(NPC[A].Effect2 % 3 != 0)
            {
                can_check = true;
                reset_all = false;
                set_justactivated = false;
            }
        }

        if(!can_check)
            continue;

        if((vScreenCollision(Z, NPC[A].Location) || (has_ALoc && vScreenCollision(Z, npcALoc))) && !NPC[A].Hidden)
        {
            if(kill_zero && NPC[A].Type == 0) // what is this? almost certainly some sort of debugging on Redigit's side
            {
                NPC[A].Killed = 9;

                // KillNPC was called directly in SMBX 1.3. Skipping it is a logic change
                // but I think the situation didn't come up in properly formed content anyway.
                // KillNPC(A, 9);

                NPCQueues::Killed.push_back(A);
                continue;
            }
            else if(NPC[A].Active && fill_draw_queue)
            {
                NPC_Draw_Queue_p.add(A);
            }

            if((NPC[A].Reset[Z] && (!check_both_reset || NPC[A].Reset[3 - Z])) || NPC[A].Active || (activate_conveyer && NPC[A].Type == NPCID_CONVEYOR))
            {
                if(set_justactivated && !NPC[A].Active)
                    NPC[A].JustActivated = static_cast<uint8_t>(Z);

                NPC[A].TimeLeft = Physics.NPCTimeOffScreen;
                // NPCID_PLATFORM_S3 was checked here but not in BlockHit, so it's not included in the global trait
                if(check_long_life && (NPCLongLife(NPC[A].Type) || NPC[A].Type == NPCID_PLATFORM_S3))
                    NPC[A].TimeLeft = Physics.NPCTimeOffScreen * 20;

                if(!NPC[A].Active)
                {
                    NPCQueues::Active.insert(A);
                    NPC[A].Active = true;
                }
            }
            NPC[A].Reset[1] = false;
            NPC[A].Reset[2] = false;

            NPCQueues::NoReset.push_back(A);
        }
        else
        {
            NPC[A].Reset[Z] = true;
            if(reset_all)
            {
                if(numScreens == 1)
                    NPC[A].Reset[2] = true;
                if(SingleCoop == 1)
                    NPC[A].Reset[2] = true;
                else if(SingleCoop == 2)
                    NPC[A].Reset[1] = true;
            }
        }
    }

    if(fill_draw_queue)
        NPC_Draw_Queue_p.sort();
}

// does the modern NPC activation / reset logic for vScreen Z
void ModernNPCScreenLogic(Screen_t& screen, int vscreen_i, bool fill_draw_queue, NPC_Draw_Queue_t& NPC_Draw_Queue_p)
{
    int Z = screen.vScreen_refs[vscreen_i];

    // canonical vScreens
    int c_Z1 = 0;
    int c_Z2 = 0;

    if(!screen.is_canonical())
    {
        Screen_t& c_screen = screen.canonical_screen();

        // canonical screen might have different split than visible screen
        if(c_screen.Type == 5)
        {
            // visible shared, canonical split
            if(screen.DType == 5 && c_screen.DType != 5)
            {
                c_Z1 = c_screen.vScreen_refs[0];
                c_Z2 = c_screen.vScreen_refs[1];
            }
            // visible split, canonical shared
            else if(screen.DType != 5 && c_screen.DType == 5)
            {
                c_Z1 = c_screen.vScreen_refs[0];
            }
            // same mode, use same vScreen index
            else
            {
                c_Z1 = c_screen.vScreen_refs[vscreen_i];
            }
        }
        // same mode, use same vScreen index
        else
        {
            c_Z1 = c_screen.vScreen_refs[vscreen_i];
        }
    }

    // using bitset here instead of simpler set because I benchmarked it to be faster -- ds-sloth
    // the purpose of this logic is to avoid duplicates in the checkNPCs vector
    std::bitset<maxNPCs>& NPC_present = s_NPC_present;

    // find the onscreen NPCs; first, get query bounds that cover all 3 possible screens
    num_t bounds_left = -vScreen[Z].X;
    num_t bounds_top = -vScreen[Z].Y;
    num_t bounds_right = -vScreen[Z].X + vScreen[Z].Width;
    num_t bounds_bottom = -vScreen[Z].Y + vScreen[Z].Height;

    if(c_Z1)
    {
        bounds_left = SDL_min(bounds_left, -vScreen[c_Z1].X);
        bounds_top = SDL_min(bounds_top, -vScreen[c_Z1].Y);
        bounds_right = SDL_max(bounds_right, -vScreen[c_Z1].X + vScreen[c_Z1].Width);
        bounds_bottom = SDL_max(bounds_bottom, -vScreen[c_Z1].Y + vScreen[c_Z1].Height);
    }

    if(c_Z2)
    {
        bounds_left = SDL_min(bounds_left, -vScreen[c_Z2].X);
        bounds_top = SDL_min(bounds_top, -vScreen[c_Z2].Y);
        bounds_right = SDL_max(bounds_right, -vScreen[c_Z2].X + vScreen[c_Z2].Width);
        bounds_bottom = SDL_max(bounds_bottom, -vScreen[c_Z2].Y + vScreen[c_Z2].Height);
    }

    TreeResult_Sentinel<NPCRef_t> _screenNPCs = treeNPCQuery(bounds_left, bounds_top,
        bounds_right, bounds_bottom, SORTMODE_NONE);


    // combine the onscreen NPCs with the no-reset NPCs
    std::vector<BaseRef_t>& checkNPCs = *_screenNPCs.i_vec;

    // mark previous ones as checked
    for(int16_t n : checkNPCs)
        NPC_present[n] = true;

    // add the previous frame's no-reset NPCs (without duplicates)
    for(int16_t n : s_NoReset_NPCs_LastFrame)
    {
        if(n <= numNPCs && !NPC_present[n])
        {
            checkNPCs.push_back(n);
            NPC_present[n] = true;
        }
    }

    // cleanup the checked NPCs
    for(int16_t n : checkNPCs)
        NPC_present[n] = false;

    Location_t loc2;

    for(int A : checkNPCs)
    {
        // there are three related things we will determine:
        // - is the NPC onscreen for rendering?
        // - can we reset the NPC (respawn it to its original location)?
        // - can we activate the NPC?

        // they are normally the same thing -- onscreen -- but we need to separate them to support multiple resolutions.

        bool loc2_exists;
        if(NPC[A].Effect == NPCEFF_NORMAL && NPC[A].HoldingPlayer == 0 && !NPC[A].Generator &&
                (NPC[A].vehiclePlr > 0 || NPC[A].Type == NPCID_VEHICLE || NPC[A].Type == NPCID_CANNONITEM
                    || NPC[A].Type == NPCID_TOOTHYPIPE || NPC[A].Type == NPCID_ITEM_BURIED || NPC[A].Type == NPCID_ROCKET_WOOD
                    || NPC[A].Type == NPCID_FIRE_BOSS_FIRE || NPC[A]->IsACoin || NPC[A].Type == NPCID_ICE_CUBE))
        {
            loc2_exists = true;
            loc2 = newLoc(NPC[A].Location.X - (NPC[A]->WidthGFX - NPC[A].Location.Width) / 2,
                NPC[A].Location.Y,
                NPC[A]->WidthGFX,
                NPC[A]->THeight);
            // not sure why loc2 does not consider NPCHeightGFX...
        }
        else
            loc2_exists = false;

        bool render, cannot_reset, can_activate;

        if(NPC[A].Hidden)
        {
            render = cannot_reset = can_activate = false;
        }
        else
        {
            render = vScreenCollision(Z, NPC[A].Location) || (loc2_exists && vScreenCollision(Z, loc2));

            bool onscreen_canonical = false;

            // check canonical screen
            if(c_Z1)
            {
                onscreen_canonical = (vScreenCollision(c_Z1, NPC[A].Location)
                    || (loc2_exists && vScreenCollision(c_Z1, loc2)));
            }
            // fallback to Z itself if no canonical screen exists
            else
            {
                onscreen_canonical = render;
            }

            // add second canonical screen if needed
            if(c_Z2 && !onscreen_canonical)
            {
                onscreen_canonical = (vScreenCollision(c_Z2, NPC[A].Location)
                    || (loc2_exists && vScreenCollision(c_Z2, loc2)));
            }

            // Possible situations where we need to activate as original:
            if(
                   ForcedControls
                || LevelMacro != LEVELMACRO_OFF
                || qScreen_canonical
                || !g_config.dynamic_camera_logic
                || NPC_MustBeCanonical(A)
            )
                can_activate = onscreen_canonical;
            else
                can_activate = render;

            // normally, don't reset anything that would be capable of activating
            cannot_reset = (can_activate || onscreen_canonical);

            // if it will look different after resetting, don't reset it
            if(!cannot_reset && render &&
                    (!NPC_InactiveRender(NPC[A])
                        || num_t::floor(NPC[A].Location.X) != num_t::floor(NPC[A].DefaultLocationX)
                        || num_t::floor(NPC[A].Location.Y) != num_t::floor(NPC[A].DefaultLocationY)
                        || (!NPC[A].Active && !NPC[A].Reset[2])
                    )
                )
            {
                cannot_reset = true;
            }
        }

        if(NPC[A].Generator)
        {
            NPC[A].GeneratorActive |= can_activate;
            continue;
        }

        if(NPC[A].Type == 0)
            render = false;

        // find the intro frame index for this NPC; will be NPC_intro_count if not found
        uint8_t NPC_intro_index;
        for(NPC_intro_index = 0; NPC_intro_index < NPC_intro_count; NPC_intro_index++)
        {
            if(NPC_intro[NPC_intro_index] == A)
                break;
        }

        // Handle the game's "conditional activation" state where NPC is activated *without* its events being triggered,
        //   with TimeLeft = 0 by the time we get to rendering. In this case, "resetting" means "not activating",
        //   so it's essential that we set cannot_reset to follow can_activate for this frame and the next one
        //   (when Reset[1] and Reset[2] need to become true).

        // Note that this condition, NPC[A].TimeLeft == 0 or 1, is practically never encountered when the NPC is onscreen,
        //   except in the conditional activation code.
        if((NPC[A].TimeLeft == 0 || NPC[A].TimeLeft == 1) && !NPC[A].Reset[2])
        {
            if(render && !can_activate)
            {
                // add it to the set of NPCs in intro/conditional states if not already present
                if(NPC_intro_index == NPC_intro_count && NPC_intro_count < NPC_intro_count_MAX)
                {
                    NPC_intro[NPC_intro_index] = A;
                    NPC_intro_count++;
                }

                // if it was already in the set, or if it was successfully added,
                // set its intro frame to -3 to give it 3 frames of allowing it to reset while onscreen
                //   (was previously 2, but 3 fixes some rare bugs, esp. during level testing)
                if(NPC_intro_index < NPC_intro_count)
                    NPC_intro_frame[NPC_intro_index] = -3;
            }
        }

        // if the NPC is in the "conditional activation" state but didn't activate, then allow it to reset even when onscreen
        if(NPC_intro_index < NPC_intro_count && NPC_intro_frame[NPC_intro_index] < 0)
            cannot_reset = can_activate;

        // if in "poof" mode, render the smoke effect on the first frame of the intro for an active NPC, then cancel the intro
        if(NPC_intro_index < NPC_intro_count && NPC_intro_frame[NPC_intro_index] > 0 && NPC[A].Active && NPC_InactiveSmoke(NPC[A]))
        {
            NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);

            // disable the NPC intro
            s_RemoveIntroNPC(NPC_intro_index);
            NPC_intro_index = NPC_intro_count;
        }

        // this section of the logic handles NPCs that are onscreen but not active yet
        if(!NPC[A].Active && render)
        {
            // Don't show a fish that hasn't jumped yet, a lava bubble that hasn't started coming out yet,
            //   a plant that hasn't emerged yet, etc. Also, don't do poofs for them, since they handle their own intros.
            if(NPC_InactiveIgnore(NPC[A]))
                render = false;
            else if(!NPC_InactiveRender(NPC[A]))
            {
                // add to queue of hidden NPCs
                if(!can_activate)
                {
                    if(NPC_intro_index == NPC_intro_count && NPC_intro_count < NPC_intro_count_MAX)
                    {
                        NPC_intro[NPC_intro_index] = A;
                        NPC_intro_frame[NPC_intro_index] = 0;
                        NPC_intro_count++;
                    }

                    // keep it hidden
                    if(NPC_intro_index < NPC_intro_count && NPC_intro_frame[NPC_intro_index] >= 0)
                        NPC_intro_frame[NPC_intro_index] = 0;
                }

                // if in "poof" mode, cancel render, but still set the intro frames as above so we can spawn the Smoke effect
                if(NPC_InactiveSmoke(NPC[A]) && !g_CheatLogicScreen)
                    render = false;
            }
        }

        // activate the NPC if allowed
        if(can_activate)
        {
            if(NPC[A].Type == 0) // what is this? almost certainly some sort of debugging on Redigit's side
            {
                NPC[A].Killed = 9;

                // KillNPC was called directly in SMBX 1.3. Skipping it is a logic change
                // but I think the situation didn't come up in properly formed content anyway.
                // KillNPC(A, 9);

                NPCQueues::Killed.push_back(A);
                continue;
            }
            else if(!NPC[A].Active && NPC[A].Effect != NPCEFF_DROP_ITEM
                && (NPC[A].Reset[2] || NPC[A].Type == NPCID_CONVEYOR))
            {
                NPC[A].JustActivated = static_cast<uint8_t>(Z);

                if(!NPC[A].Active)
                {
                    NPCQueues::Active.insert(A);
                    NPC[A].Active = true;
                }
            }
        }

        // track the NPC's reset timer
        if(cannot_reset)
        {
            // update TimeLeft (despawn timer) if active and in the no-reset zone
            if(NPC[A].Active)
            {
                // NPCID_PLATFORM_S3 was checked here but not in BlockHit, so it's not included in the global trait
                if(NPCLongLife(NPC[A].Type) || NPC[A].Type == NPCID_PLATFORM_S3)
                    NPC[A].TimeLeft = Physics.NPCTimeOffScreen * 20;
                else
                    NPC[A].TimeLeft = Physics.NPCTimeOffScreen;
            }

            // mark no-reset if it is currently active, or it has never been offscreen since deactivating
            if((NPC[A].Active || !NPC[A].Reset[2]) && NPC[A].Reset[1])
            {
                NPC[A].Reset[1] = false;
                NPCQueues::NoReset.push_back(A);
            }
        }
        else
        {
            // Reset was previously cleared here, but now it is cleared in the main UpdateGraphics function
            // NPC[A].Reset[Z] = true;
            // if(numScreens == 1)
            //     NPC[A].Reset[2] = true;
            // if(SingleCoop == 1)
            //     NPC[A].Reset[2] = true;
            // else if(SingleCoop == 2)
            //     NPC[A].Reset[1] = true;
        }

        const Player_t& hp = Player[NPC[A].HoldingPlayer];
        bool hp_door_scroll = (NPC[A].HoldingPlayer > 0 && hp.Effect == PLREFF_WARP_DOOR && hp.Effect2 >= 128);

        if(hp_door_scroll)
            render = false;

        if(fill_draw_queue && render && (NPC[A].Reset[2] || NPC[A].Active || !cannot_reset))
        {
            NPC_Draw_Queue_p.add(A);

            // just for appearance, do the NPC's frames if it hasn't been activated yet and isn't in a shade / hidden mode
            if(!NPC[A].Active && !FreezeNPCs)
            {
                bool in_hidden_mode = NPC_intro_index < NPC_intro_count && NPC_intro_frame[NPC_intro_index] >= 0;
                if(NPC[A]->InactiveRender != NPCTraits_t::SHOW_STATIC && !in_hidden_mode)
                    NPCFrames(A);
            }
        }
        else if(fill_draw_queue && g_config.small_screen_cam && NPC[A].Active && cannot_reset && NPC[A].JustActivated == 0 && !NPC[A].Inert && NPC[A].Type != NPCID_CONVEYOR)
        {
            if(NPC[A].Location.SpeedX != 0 || NPC[A].Location.SpeedY != 0
                || (!NPC[A]->WontHurt && !NPC[A]->IsACoin && !NPC[A]->IsABonus))
            {
                NPC_Draw_Queue_p.add_warning(A);
            }
        }
    }

    if(fill_draw_queue)
        NPC_Draw_Queue_p.sort();
}

//! all of the logic done by UpdateGraphics
void UpdateGraphicsLogic(bool Do_FrameSkip);

//! parent function for the actual drawing to screen
void UpdateGraphicsDraw(bool skipRepaint);

//! draw graphics for the current Screen_t
void UpdateGraphicsScreen(Screen_t& screen);

//! extra non-gameplay related draws (menus and information display)
void UpdateGraphicsMeta();

void GraphicsClearScreen()
{
    if(!GameIsActive || XMessage::GetStatus() == XMessage::Status::replay)
        return;

    XRender::setTargetTexture();
    XRender::resetViewport();
    XRender::setDrawPlane(PLANE_GAME_BACKDROP);
    XRender::clearBuffer();
    XRender::repaint();
}

// This draws the graphic to the screen when in a level/game menu/outro/level editor
void UpdateGraphics(bool skipRepaint)
{
//    On Error Resume Next

    if(!GameIsActive)
        return;

    // check that we can render, and that we should not frameskip
    bool Do_FrameSkip = false;

#ifdef USE_RENDER_BLOCKING
    if(XRender::renderBlocked())
        Do_FrameSkip = true;
#endif

    // frame skip code
    cycleNextInc();

    if(g_config.enable_frameskip && !TakeScreen && frameSkipNeeded())
        Do_FrameSkip = true;

#ifdef __16M__
    if(!XRender::ready_for_frame())
    {
        if(g_config.unlimited_framerate)
            frameNextInc();
        Do_FrameSkip = true;
    }
#endif

    if(XMessage::GetStatus() == XMessage::Status::replay)
        Do_FrameSkip = true;

    g_microStats.start_task(MicroStats::Camera);

    UpdateGraphicsLogic(Do_FrameSkip);

    // we've now done all the logic that UpdateGraphics can do.
    if(Do_FrameSkip)
        return;

    g_microStats.start_task(MicroStats::Graphics);

    UpdateGraphicsDraw(skipRepaint);
}

void UpdateGraphicsLogic(bool Do_FrameSkip)
{
    // ALL graphics-based logic code has been moved here, separate from rendering.
    // (This code is a combination of the FrameSkip logic from before with the
    //   logic components of the full rendering code.)
    // NPC render queue formation is also here.

    g_stats.reset();

    SetupScreens(false);
    DynamicScreens();
    CenterScreens();

    bool continue_qScreen = false; // will qScreen continue for any visible screen?
    std::array<bool, maxNetplayClients> continue_qScreen_local{false}; // will qScreen continue for a visible screen on this machine? (NetPlay)
    bool continue_qScreen_canonical = false; // will qScreen continue for any canonical screen?

    // prepare to fill this frame's NoReset queue
    std::swap(NPCQueues::NoReset, s_NoReset_NPCs_LastFrame);
    NPCQueues::NoReset.clear();

    // mark the last-frame reset state of NPCs that may have Reset[1] or Reset[2] set to false, and clear their this-frame reset state
    //     Reset[1] could have been set by the last frame's modern NPC logic, or by external code
    //     Reset[2] could only have been set by external code
    if(g_config.fix_npc_camera_logic)
    {
        for(NPC_t& n : s_NoReset_NPCs_LastFrame)
        {
            n.Reset[2] = n.Reset[1] && n.Reset[2];
            n.Reset[1] = true;
        }
    }

    // the graphics screen logic is handled via a big loop over Screens (clients)
    for(int screen_i = 0; screen_i < c_screenCount; screen_i++)
    {
        Screen_t& screen = Screens[screen_i];

        if(!screen.Visible)
            continue;

        if(!screen.player_count && !LevelEditor)
            continue;

        // update screen's canonical vScreens
        if(!screen.is_canonical())
        {
            Screen_t& c_screen = screen.canonical_screen();

            for(int i = c_screen.active_begin() + 1; i <= c_screen.active_end(); i++)
                GetvScreenAuto(c_screen.vScreen(i));

            if(qScreen_canonical)
            {
                for(int i = c_screen.active_begin(); i < c_screen.active_end(); i++)
                {
                    int Z_i = c_screen.vScreen_refs[i];
                    continue_qScreen_canonical |= Update_qScreen(Z_i);

                    // the original code was badly written and made THIS happen (always exactly one frame of qScreen in 2P mode)
                    if(i >= 1 && !g_config.modern_section_change)
                        continue_qScreen_canonical = false;
                }
            }
        }

        int numScreens = screen.active_end();

        for(int vscreen_i = screen.active_begin(); vscreen_i < screen.active_end(); vscreen_i++)
        {
            int Z = screen.vScreen_refs[vscreen_i];
            int plr_Z = screen.players[vscreen_i];

            int S;
            if(LevelEditor)
                S = curSection;
            else
                S = Player[plr_Z].Section;

            // update vScreen location
            if(!LevelEditor)
                GetvScreenAuto(vScreen[Z]);

            // moved to `graphics/gfx_screen.cpp`
            // NOTE: this logic was previously only performed on non-frameskips
            if(qScreen)
            {
                bool continue_this_qScreen = Update_qScreen(Z);
                continue_qScreen |= continue_this_qScreen;
                continue_qScreen_local[screen_i] |= continue_this_qScreen;
            }

            // the original code was badly written and made THIS happen (always exactly one frame of qScreen in 2P mode)
            if(Z == 2 && !g_config.modern_section_change)
                continue_qScreen = false;

            // noturningback
            if(!LevelEditor && NoTurnBack[Player[plr_Z].Section] && g_config.allow_multires)
            {
                // goal: find canonical vScreen currently on this section that is the furthest left
                // only do anything with the last vScreen (of a Visible screen) in the section
                // (ensures all other logic has happened)

                int A = 0;
                int section = Player[plr_Z].Section;
                bool is_last = true;

                for(int screen_j = 0; screen_j < c_screenCount; screen_j++)
                {
                    Screen_t& o_screen = Screens[screen_j];

                    // active_begin() / active_end() are 0-indexed
                    for(int vscreen_j = o_screen.active_begin(); vscreen_j < o_screen.active_end(); vscreen_j++)
                    {
                        int o_p = o_screen.players[vscreen_j];
                        int o_Z = o_screen.vScreen_refs[vscreen_j];

                        if(Player[o_p].Section == section)
                        {
                            // check if this is the last vScreen (of a Visible screen) in the section
                            if(o_screen.Visible && (screen_j > screen_i || (screen_j == screen_i && vscreen_j > vscreen_i)))
                                is_last = false;

                            // only consider canonical screens
                            if(!o_screen.is_canonical())
                                break;

                            // pick screen further to left
                            if(A == 0 || -vScreen[o_Z].X < -vScreen[A].X)
                                A = o_Z;
                        }
                    }
                }

                if(is_last && A != 0 && -vScreen[A].X > level[S].X)
                {
                    // LevelChop[S] += float(-vScreen[A].X - level[S].X); // unused since SMBX64, removed
                    level[S].X = -vScreen[A].X;

                    // mark that section has shrunk
                    UpdateSectionOverlaps(S, true);
                }
            }
            // Legacy noturningback
            else if(!LevelEditor && NoTurnBack[Player[plr_Z].Section])
            {
                vScreen_t& vscreen1 = screen.vScreen(1);
                vScreen_t& vscreen2 = screen.vScreen(2);
                int screen_p1 = screen.players[0];
                int screen_p2 = screen.players[1];

                // goal: find screen currently on this section that is the furthest left
                int A = vscreen_i + 1;
                if(numScreens > 1)
                {
                    if(Player[screen_p1].Section == Player[screen_p2].Section)
                    {
                        if(A == 1)
                            GetvScreen(vscreen2);

                        if(-vscreen1.X < -vscreen2.X)
                            A = 1;
                        else
                            A = 2;
                    }
                }

                if(-screen.vScreen(A).X > level[S].X)
                {
                    // LevelChop[S] += float(-screen.vScreen(A).X - level[S].X); // unused since SMBX64, removed
                    level[S].X = -screen.vScreen(A).X;

                    // mark that section has shrunk
                    UpdateSectionOverlaps(S, true);
                }
            }

            // Keep all players onscreen in clone mode
            if(!GameMenu && !LevelEditor)
            {
                if(g_ClonedPlayerMode)
                {
                    num_t C = 0;
                    int D = 0;

                    For(A, 1, numPlayers)
                    {
                        Player_t &p = Player[A];

                        if(!vScreenCollision(Z, p.Location) && LevelMacro == LEVELMACRO_OFF &&
                            p.Location.Y < level[p.Section].Height &&
                            p.Location.Y + p.Location.Height > level[p.Section].Y &&
                            p.TimeToLive == 0 && !p.Dead)
                        {
                            for(int B = 1; B <= numPlayers; B++)
                            {
                                if(!Player[B].Dead && Player[B].TimeToLive == 0 && Player[B].Section == Player[A].Section && vScreenCollision(Z, Player[B].Location))
                                {
                                    num_t dx = num_t::abs(Player[A].Location.minus_center_x(Player[B].Location));
                                    if(C == 0 || dx < C)
                                    {
                                        C = dx;
                                        D = B;
                                    }
                                }
                            }

                            if(C == 0)
                            {
                                for(int B = 1; B <= numPlayers; B++)
                                {
                                    if(!Player[B].Dead && Player[B].TimeToLive == 0 && Player[B].Section == Player[A].Section)
                                    {
                                        num_t dx = num_t::abs(Player[A].Location.minus_center_x(Player[B].Location));
                                        if(C == 0 || dx < C)
                                        {
                                            C = dx;
                                            D = B;
                                        }
                                    }
                                }
                            }

                            Player[A].Location.X = Player[D].Location.X + (Player[D].Location.Width - Player[A].Location.Width) / 2;
                            Player[A].Location.Y = Player[D].Location.Y + Player[D].Location.Height - Player[A].Location.Height;
                            Player[A].Section = Player[D].Section;
                            Player[A].Location.SpeedX = Player[D].Location.SpeedX;
                            Player[A].Location.SpeedY = Player[D].Location.SpeedY;
                            Player[A].Location.SpeedY = dRand() * 12 - 6;
                            Player[A].CanJump = true;
                        }
                    }
                }
            }

            // It's time to process NPCs. We will update their active state and fill a draw queue.

            // only fill draw queue if drawing will happen and this is the local screen
            bool fill_draw_queue = !Do_FrameSkip && (&screen == l_screen);

            // Make sure we are in range.
            SDL_assert_release(vscreen_i >= 0 && vscreen_i < (int)(sizeof(NPC_Draw_Queue) / sizeof(NPC_Draw_Queue_t)));
            NPC_Draw_Queue_t& NPC_Draw_Queue_p = NPC_Draw_Queue[vscreen_i];

            if(fill_draw_queue)
                NPC_Draw_Queue_p.reset();

            // we'll check the NPCs and do some logic for the game,
            if(!LevelEditor)
            {
                if(g_config.fix_npc_camera_logic)
                    ModernNPCScreenLogic(screen, vscreen_i, fill_draw_queue, NPC_Draw_Queue_p);
                else if(Z <= 2)
                    ClassicNPCScreenLogic(Z, numScreens, fill_draw_queue, NPC_Draw_Queue_p);
            }
            // fill the NPC render queue for the level editor
            else if(fill_draw_queue)
            {
                for(int A = 1; A <= numNPCs; A++)
                {
                    if(NPC[A].Hidden)
                        continue;

                    const Location_t loc2 = newLoc(NPC[A].Location.X - (NPC[A]->WidthGFX - NPC[A].Location.Width) / 2,
                        NPC[A].Location.Y,
                        NPC[A]->WidthGFX, NPC[A]->THeight);

                    if(vScreenCollision(Z, NPC[A].Location) || vScreenCollision(Z, loc2))
                        NPC_Draw_Queue_p.add(A);
                }
            }

            // some "special" logic for warping Char 5 (moved from draw code)
            for(int A = 1; A <= numPlayers; A++)
            {
                Player_t& p = Player[A];

                if(p.Character == 5 && p.Effect == PLREFF_WARP_PIPE && !p.Dead && !p.Immune2 && p.TimeToLive == 0 && p.Frame > 5)
                {
                    if(vScreenCollision(Z, p.Location))
                        p.Frame = 1;
                }
            }

            // moved from render code because it affects the game's random state
            s_shakeScreen[0].update();

            if(g_config.fix_npc_camera_logic)
                s_shakeScreen[Z].update();

        } // loop over vScreens

    } // loop over Screens


    // Background frames (NOTE: frames were only updated on non-frameskip in vanilla)
    if(!FreezeNPCs)
    {
        LevelFramesNotFrozen();
        SpecialFrames();
    }

    CommonFrames();

    LevelFramesAlways();
    ProcessIntroNPCFrames();

    // clear the last-frame reset state of NPCs
    if(g_config.fix_npc_camera_logic)
    {
        for(NPC_t& n : s_NoReset_NPCs_LastFrame)
            n.Reset[2] = true;
    }

    // use screen-shake to indicate if invisible screen is currently causing qScreen
    if(g_config.allow_multires)
    {
        for(int screen_i = 0; screen_i < maxNetplayClients; screen_i++)
        {
            Screen_t& screen = Screens[screen_i];

            if(!screen.Visible)
                continue;

            for(int vscreen_i = screen.active_begin(); vscreen_i < screen.active_end(); vscreen_i++)
            {
                int Z = screen.vScreen_refs[vscreen_i];

                // shake screen to tell player game is currently paused (will take effect next frame)
                if(!continue_qScreen_local[screen_i] && (continue_qScreen || continue_qScreen_canonical) && !s_shakeScreen[Z].active)
                {
                    s_forcedShakeScreen[Z] = true;
                    s_shakeScreen[Z].setup(1, 1, SHAKE_RANDOM, 0, 0);
                }
                // finish forced screenshake
                else if(!(continue_qScreen || continue_qScreen_canonical) && s_forcedShakeScreen[Z])
                {
                    s_forcedShakeScreen[Z] = false;
                    s_shakeScreen[Z].setup(1, 1, SHAKE_RANDOM, 0, 100);
                }
            }
        }
    }

    // update score and lives to their displayable limits
    if(Score > 9999990)
        Score = 9999990;

    if(Lives > 99)
        Lives = 99;

    if(g_100s > 9999)
        g_100s = 9999;

    if(g_100s < -9999)
        g_100s = -9999;

    // NOTE: qScreen was only updated on non-frameskip in vanilla
    qScreen = continue_qScreen;
    qScreen_canonical = continue_qScreen_canonical;
}

static bool s_should_draw_player(const Player_t& p)
{
    bool player_door_scroll = (p.Effect == PLREFF_WARP_DOOR && p.Effect2 >= 128);
    return (!p.Dead && p.TimeToLive == 0 && !(p.Effect == (PLREFF_TURN_TO_STATE + PLR_STATE_LEAF) || p.Effect == PLREFF_WAITING || p.Effect == PLREFF_PET_INSIDE || player_door_scroll));
}

void UpdateGraphicsDraw(bool skipRepaint)
{
    // begin render code
    XRender::setTargetTexture();

    frameNextInc();
    frameRenderStart();
    lunaRenderStart();

    if(ClearBuffer)
    {
        ClearBuffer = false;
        XRender::clearBuffer();
    }

#ifdef __3DS__
    XRender::setTargetLayer(0);
#endif

    XRender::resetViewport();

    XRender::setDrawPlane(PLANE_GAME_BACKDROP);

    UpdateGraphicsScreen(*l_screen);

    UpdateGraphicsMeta();

    if(!skipRepaint)
        XRender::repaint();

    lunaRenderEnd();
    frameRenderEnd();

//    if(XRender::lazyLoadedBytes() > 200000) // Reset timer while loading many pictures at the same time
//        resetFrameTimer();
    XRender::lazyLoadedBytesReset();
}

void UpdateGraphicsScreen(Screen_t& screen)
{
    XTColor plr_shade = ShadowMode ? XTColor(64, 64, 64) : XTColor();

    int numScreens = screen.active_end();

    // even if not clearing buffer, black background is good, to be safe
    XRender::renderRect(0, 0, XRender::TargetW, XRender::TargetH, {0, 0, 0});
    DrawBackdrop(screen);

    // No logic
    // Draw the screens!
    for(int vscreen_i = screen.active_begin(); vscreen_i < screen.active_end(); vscreen_i++)
    {
        int Z = screen.vScreen_refs[vscreen_i];
        int plr_Z = screen.players[vscreen_i];

        int S;
        if(LevelEditor)
            S = curSection;
        else
            S = Player[plr_Z].Section;

        // (Code to get vScreen moved into logic section above.)

#ifdef __3DS__
        if(Z != 1)
            XRender::setTargetLayer(0);
#endif

        XRender::setDrawPlane(PLANE_LVL_BG);

        // Note: this was guarded by an if(!LevelEditor) condition in the past
        if(Background2[S] == 0)
        {
            XRender::renderRect(vScreen[Z].TargetX(), vScreen[Z].TargetY(),
                                vScreen[Z].Width, vScreen[Z].Height, {0, 0, 0}, true);
        }

        // Get a reference to our NPC draw queue.
        // Make sure we are in range.
        SDL_assert_release((vscreen_i >= 0) && (vscreen_i < (int)(sizeof(NPC_Draw_Queue) / sizeof(NPC_Draw_Queue_t))));
        NPC_Draw_Queue_t& NPC_Draw_Queue_p = NPC_Draw_Queue[vscreen_i];

        // always needed now due to cases where vScreen is smaller than physical screen
        XRender::setViewport(vScreen[Z].TargetX(), vScreen[Z].TargetY(), vScreen[Z].Width, vScreen[Z].Height);

        // update viewport from screen shake
        s_shakeScreen[(g_config.fix_npc_camera_logic) ? Z : 0].apply();

        // camera offsets to add to all object positions before drawing
        num_t camX = vScreen[Z].CameraAddX();
        num_t camY = vScreen[Z].CameraAddY();
        int camX_i = num_t::floor(camX);
        int camY_i = num_t::floor(camY);

        DrawBackground(S, Z);

#ifdef THEXTECH_BUILD_GL_MODERN
        if(SectionParticlesBG[S])
            XRender::renderParticleSystem(**SectionParticlesBG[S], camX_i, camY_i);
#endif

        // don't show background outside of the current section!
        if(LevelEditor)
        {
            if(camX_i + LevelREAL[S].X > 0)
            {
                XRender::renderRect(0, 0,
                                    camX_i + LevelREAL[S].X - XRender::TargetOverscanX, screen.H, {63, 63, 63}, true);
            }

            if(screen.W > LevelREAL[S].Width + camX_i)
            {
                XRender::renderRect(LevelREAL[S].Width + camX_i + XRender::TargetOverscanX, 0,
                                    screen.W - (LevelREAL[S].Width + camX_i), screen.H, {63, 63, 63}, true);
            }

            if(camY_i + LevelREAL[S].Y > 0)
            {
                XRender::renderRect(0, 0,
                                    screen.W, camY_i + LevelREAL[S].Y, {63, 63, 63}, true);
            }

            if(screen.H > LevelREAL[S].Height + camY_i)
            {
                XRender::renderRect(0, LevelREAL[S].Height + camY_i,
                                    screen.W, screen.H - (LevelREAL[S].Height + camY_i), {63, 63, 63}, true);
            }
        }


        // moved many-player (superbdemo128) handling code to logic section above

#ifdef __3DS__
        XRender::setTargetLayer(g_config.td_compat_mode ? 2 : 1);
#endif

        // update the vectors of all the onscreen blocks and backgrounds for use at multiple places
        s_UpdateDrawItems(screen, vscreen_i);
        const std::vector<BlockRef_t>& screenMainBlocks = s_drawMainBlocks[vscreen_i];
        const std::vector<BlockRef_t>& screenLavaBlocks = s_drawLavaBlocks[vscreen_i];
        const std::vector<BlockRef_t>& screenSBlocks = s_drawSBlocks[vscreen_i];
        const std::vector<BaseRef_t>& screenBackgrounds = s_drawBGOs[vscreen_i];

        int nextBackground = 0;

        XRender::setDrawPlane(PLANE_LVL_BGO_LOW);

        if(LevelEditor)
        {
            for(; nextBackground < (int)screenBackgrounds.size(); nextBackground++) // First backgrounds
            {
                int A = screenBackgrounds[nextBackground];
                const auto &bgo = Background[A];

                if(A > numBackground)
                    break;

                if(bgo.SortPriority >= Background_t::PRI_NORM_START)
                    break;

                g_stats.checkedBGOs++;
                if(vScreenCollision(Z, bgo.Location) && !bgo.Hidden)
                {
                    g_stats.renderedBGOs++;

                    auto &bgoGfx = GFXBackgroundBMP[bgo.Type];
                    const vbint_t bgoHeight = BackgroundHeight[bgo.Type];
                    const vbint_t bgoFrame = BackgroundFrame[bgo.Type];

                    XRender::renderTextureBasic(num_t::floor(camX + bgo.Location.X),
                                          num_t::floor(camY + bgo.Location.Y),
                                          bgoGfx.w,
                                          bgoHeight,
                                          bgoGfx, 0,
                                          bgoHeight * bgoFrame);
                }
            }
        }
        else
        {
            // For A = 1 To MidBackground - 1 'First backgrounds
            for(; nextBackground < (int)screenBackgrounds.size() && (int)screenBackgrounds[nextBackground] < MidBackground; nextBackground++)  // First backgrounds
            {
                int A = screenBackgrounds[nextBackground];
                const auto &bgo = Background[A];

                g_stats.checkedBGOs++;

                if(bgo.Hidden)
                    continue;

                int sX = num_t::floor(camX + bgo.Location.X);
                if(sX > vScreen[Z].Width)
                    continue;

                int sY = num_t::floor(camY + bgo.Location.Y);
                if(sY > vScreen[Z].Height)
                    continue;

                auto &bgoGfx = GFXBackgroundBMP[bgo.Type];
                const vbint_t bgoHeight = BackgroundHeight[bgo.Type];

                if(sX + bgoGfx.w >= 0 && sY + bgoHeight >= 0 /*&& !bgo.Hidden*/)
                {
                    const vbint_t bgoFrame = BackgroundFrame[bgo.Type];
                    g_stats.renderedBGOs++;
                    XRender::renderTextureBasic(sX,
                                          sY,
                                          bgoGfx.w,
                                          bgoHeight,
                                          bgoGfx,
                                          0,
                                          bgoHeight * bgoFrame);
                }
            }
        }

        XRender::setDrawPlane(PLANE_LVL_SBLOCK);

        for(Block_t& b : screenSBlocks) // Display sizable blocks
        {
            g_stats.checkedBlocks++;
            if(/*BlockIsSizable[b.Type] &&*/ (!b.Invis || LevelEditor))
            {
                int bLeftOnscreen = num_t::floor(camX + b.Location.X);
                if(bLeftOnscreen > vScreen[Z].Width)
                    continue;

                int bTopOnscreen = num_t::floor(camY + b.Location.Y);
                if(bTopOnscreen > vScreen[Z].Height)
                    continue;

                g_stats.renderedBlocks++;

                XRender::renderSizableBlock(bLeftOnscreen, bTopOnscreen, s_round2int(b.Location.Width), s_round2int(b.Location.Height), GFXBlockBMP[b.Type]);
            }
        }

        XRender::setDrawPlane(PLANE_LVL_BGO_NORM);

        if(LevelEditor)
        {
            for(; nextBackground < (int)screenBackgrounds.size(); nextBackground++)  // Second backgrounds
            {
                int A = screenBackgrounds[nextBackground];
                const auto &bgo = Background[A];

                if(A > numBackground)
                    break;

                if(bgo.SortPriority >= Background_t::PRI_FG_START)
                    break;

                g_stats.checkedBGOs++;
                if(vScreenCollision(Z, bgo.Location) && !bgo.Hidden)
                {
                    g_stats.renderedBGOs++;

                    auto &bgoGfx = GFXBackgroundBMP[bgo.Type];
                    const vbint_t bgoHeight = BackgroundHeight[bgo.Type];
                    const vbint_t bgoFrame = BackgroundFrame[bgo.Type];

                    XRender::renderTextureBasic(num_t::floor(camX + bgo.Location.X),
                                          num_t::floor(camY + bgo.Location.Y),
                                          bgoGfx.w,
                                          bgoHeight,
                                          bgoGfx, 0,
                                          bgoHeight * bgoFrame);
                }
            }
        }
        else if(numBackground > 0)
        {
            for(; nextBackground < (int)screenBackgrounds.size() && (int)screenBackgrounds[nextBackground] <= LastBackground; nextBackground++)  // Second backgrounds
            {
                int A = screenBackgrounds[nextBackground];
                const auto &bgo = Background[A];

                g_stats.checkedBGOs++;

                if(bgo.Hidden)
                    continue;

                int sX = num_t::floor(camX + bgo.Location.X);
                if(sX > vScreen[Z].Width)
                    continue;

                int sY = num_t::floor(camY + bgo.Location.Y);
                if(sY > vScreen[Z].Height)
                    continue;

                const vbint_t bgoWidth = BackgroundWidth[bgo.Type];
                const vbint_t bgoHeight = BackgroundHeight[bgo.Type];

                if(sX + bgoWidth >= 0 && sY + bgoHeight >= 0 /*&& !bgo.Hidden*/)
                {
                    auto &bgoGfx = GFXBackgroundBMP[bgo.Type];
                    const vbint_t bgoFrame = BackgroundFrame[bgo.Type];

                    g_stats.renderedBGOs++;
                    XRender::renderTextureBasic(sX,
                                          sY,
                                          bgoWidth,
                                          bgoHeight,
                                          bgoGfx,
                                          0, bgoHeight * bgoFrame);
                }
            }
        }

        for(int oBackground = (int)screenBackgrounds.size() - 1; oBackground > 0 && (int)screenBackgrounds[oBackground] > numBackground; oBackground--)  // Locked doors
        {
            int A = screenBackgrounds[oBackground];
            const auto &bgo = Background[A];

            g_stats.checkedBGOs++;

            if(bgo.Hidden || !(bgo.Type == 98 || bgo.Type == 160))
                continue;

            int sX = num_t::floor(camX + bgo.Location.X);
            if(sX > vScreen[Z].Width)
                continue;

            int sY = num_t::floor(camY + bgo.Location.Y);
            if(sY > vScreen[Z].Height)
                continue;

            const vbint_t bgoWidth = BackgroundWidth[bgo.Type];
            const vbint_t bgoHeight = BackgroundHeight[bgo.Type];

            if(sX + bgoWidth >= 0 && sY + bgoHeight >= 0)
            {
                auto &bgoGfx = GFXBackgroundBMP[bgo.Type];
                const vbint_t bgoFrame = BackgroundFrame[bgo.Type];
                g_stats.renderedBGOs++;
                XRender::renderTextureBasic(sX,
                                      sY,
                                      bgoWidth, bgoHeight,
                                      bgoGfx,
                                      0, bgoHeight * bgoFrame);
            }
        }

#ifdef __3DS__
        XRender::setTargetLayer(2);
#endif

        XRender::setDrawPlane(PLANE_LVL_NPC_BG);

        // 'Display NPCs that should be behind blocks
        for(size_t i = 0; i < NPC_Draw_Queue_p.BG_n; i++)
        {
            int A = NPC_Draw_Queue_p.BG[i];
            DrawNPC(camX, camY, A);
        }


        XRender::setDrawPlane(PLANE_LVL_PLR_WARP);

        // Player warp effects 'Players behind blocks
        for(int A = 1; A <= numPlayers; A++)
        {
            if(Player[A].Dead || Player[A].Immune2 || Player[A].TimeToLive != 0)
                continue;

            if(Player[A].CurMazeZone != 0 || Player[A].Effect == PLREFF_WARP_PIPE)
                DrawPlayer(Player[A], Z);
            // separated player warp draw logic has now been removed!
        }


        XRender::setDrawPlane(PLANE_LVL_BLK_NORM);

        // 'Non-Sizable Blocks
        for(Block_t& block : screenMainBlocks)
        {
            g_stats.checkedBlocks++;

            if(/*!BlockIsSizable[block.Type] &&*/ (!block.Invis || (LevelEditor && (CommonFrame % 46) <= 30)) /*&& block.Type != 0 && !BlockKills[block.Type]*/)
            {
                // Don't show a visual difference of hit-resized block in a comparison to original state
                int sX = (block.getShrinkResized()) ? (num_t::floor(camX + block.Location.X - 0.05_n)) : (num_t::floor(camX + block.Location.X));
                if(sX > vScreen[Z].Width)
                    continue;

                int sY = num_t::floor(camY + block.Location.Y);
                if(sY > vScreen[Z].Height)
                    continue;

                int bw = s_round2int(block.Location.Width);
                int bh = s_round2int(block.Location.Height);

                if(sX + bw >= 0 && sY + bh >= 0 /*&& !block.Hidden*/)
                {
                    g_stats.renderedBlocks++;
                    XTColor cb;

#ifdef THEXTECH_ENABLE_SDL_NET
                    if(block.RespawnDelay_ScreensLeft && !BattleMode)
                    {
                        uint16_t screen_index = (&screen - &Screens[0]);
                        if((block.RespawnDelay_ScreensLeft & (1U << screen_index)) == 0)
                            cb = XTColor(127, 127, 127);
                    }
#endif

                    XRender::renderTextureBasic(sX,
                                          sY + block.ShakeOffset,
                                          bw,
                                          bh,
                                          GFXBlock[block.Type],
                                          0,
                                          BlockFrame[block.Type] * bh,
                                          cb);
                    // BlockFrame * bh was previously BlockFrame * 32
                    // This change is needed for converted conveyor blocks
                    // It may be reverted in the future
                }
            }
        }

        XRender::setDrawPlane(PLANE_LVL_EFF_LOW);

        //'effects in back
        for(int A = 1; A <= numEffects; A++)
        {
            if(Effect[A].Type == EFFID_BOSS_FRAGILE_DIE || Effect[A].Type == EFFID_DOOR_S2_OPEN || Effect[A].Type == EFFID_DOOR_DOUBLE_S3_OPEN ||
               Effect[A].Type == EFFID_DOOR_SIDE_S3_OPEN || Effect[A].Type == EFFID_PLR_FIREBALL_TRAIL || Effect[A].Type == EFFID_COIN_SWITCH_PRESS ||
               Effect[A].Type == EFFID_SPINBLOCK || Effect[A].Type == EFFID_BIG_DOOR_OPEN || Effect[A].Type == EFFID_LAVA_MONSTER_LOOK ||
               Effect[A].Type == EFFID_WATER_SPLASH || Effect[A].Type == EFFID_TIME_SWITCH_PRESS || Effect[A].Type == EFFID_TNT_PRESS)
            {
                int sX = (num_t::floor(camX + Effect[A].Location.X));
                if(sX > vScreen[Z].Width)
                    continue;

                int sY = num_t::floor(camY + Effect[A].Location.Y);
                if(sY > vScreen[Z].Height)
                    continue;

                int w = s_round2int(Effect[A].Location.Width);
                int h = s_round2int(Effect[A].Location.Height);

                if(sX + w >= 0 && sY + h >= 0)
                {
                    g_stats.renderedEffects++;

                    XTColor cn = Effect[A].Shadow ? XTColor(64, 64, 64) : XTColor();
                    XRender::renderTextureBasic(sX, sY, w, h,
                                           GFXEffect[Effect[A].Type], 0,
                                           Effect[A].Frame * EffectHeight[Effect[A].Type], cn);
                }
            }
        }


        XRender::setDrawPlane(PLANE_LVL_NPC_LOW);

        // draw NPCs that should be behind other NPCs
        for(size_t i = 0; i < NPC_Draw_Queue_p.Low_n; i++)
        {
            int A = NPC_Draw_Queue_p.Low[i];
            DrawNPC(camX, camY, A);
        }


        XRender::setDrawPlane(PLANE_LVL_NPC_LOW + 1);

        // ice
        for(size_t i = 0; i < NPC_Draw_Queue_p.Iced_n; i++)
        {
            int A = NPC_Draw_Queue_p.Iced[i];
            DrawFrozenNPC(camX, camY, A);
        }


        XRender::setDrawPlane(PLANE_LVL_NPC_NORM);

        // 'Display NPCs that should be in front of blocks
        for(size_t i = 0; i < NPC_Draw_Queue_p.Normal_n; i++)
        {
            int A = NPC_Draw_Queue_p.Normal[i];
            DrawNPC(camX, camY, A);
        }

        // npc chat bubble
        for(size_t i = 0; i < NPC_Draw_Queue_p.Chat_n; i++)
        {
            int A = NPC_Draw_Queue_p.Chat[i];

            int B = NPC[A]->HeightGFX - s_round2int(NPC[A].Location.Height);
            if(B < 0)
                B = 0;

            XRender::renderTextureBasic((int)num_t::floor(camX + NPC[A].Location.X) + s_round2int(NPC[A].Location.Width) / 2 - GFX.Chat.w / 2,
                (int)num_t::floor(camY + NPC[A].Location.Y) - 30 - B,
                GFX.Chat);
        }


        XRender::setDrawPlane(PLANE_LVL_PLR_NORM);

        For(A, 1, numPlayers) // The clown car
        {
            if(!Player[A].Dead && !Player[A].Immune2 && Player[A].TimeToLive == 0 &&
               !(Player[A].Effect == PLREFF_WARP_PIPE || Player[A].Effect == (PLREFF_TURN_TO_STATE + PLR_STATE_LEAF)) && Player[A].Mount == 2)
            {
                const Player_t& p = Player[A];

                using plr_pic_arr = RangeArr<StdPicture, 1, numStates>;
                constexpr std::array<plr_pic_arr*, 5> char_tex = {&GFXMario, &GFXLuigi, &GFXPeach, &GFXToad, &GFXLink};

                StdPicture& tx = (*char_tex[p.Character - 1])[p.State];

                int Y = 0;

                switch(Player[A].Character)
                {
                default:
                case 1: // Mario
                    if(Player[A].State == 1)
                        Y = 24;
                    else
                        Y = 36;
                    break;

                case 2: // Luigi
                    if(Player[A].State == 1)
                        Y = 24;
                    else
                        Y = 38;
                    break;

                case 3: // Peach
                    if(Player[A].State == 1)
                        Y = 24;
                    else
                        Y = 30;
                    break;

                case 4: // Toad
                    if(Player[A].State == 1)
                        Y = 24;
                    else
                        Y = 30;
                    break;

                case 5: // Link
                    Y = 30;
                    break;
                }

                int sX = num_t::floor(camX + Player[A].Location.X);
                int sY = num_t::floor(camY + Player[A].Location.Y);
                int pW = s_round2int(Player[A].Location.Width);
                int pH = s_round2int(Player[A].Location.Height);

                XRender::renderTextureBasic(
                        sX + pfrOffX(tx, p) - Physics.PlayerWidth[Player[A].Character][Player[A].State] / 2 + 64,
                        sY + pfrOffY(tx, p) + Player[A].MountOffsetY - Y,
                        pfrW(tx, p), // was 99, not 100, but not a big deal
                        pH - 20 - Player[A].MountOffsetY,
                        tx,
                        pfrX(tx, p),
                        pfrY(tx, p),
                        plr_shade);
                XRender::renderTextureBasic(
                        sX + pW / 2 - 64,
                        sY + pH - 128,
                        128,
                        128,
                        GFX.Mount[Player[A].Mount],
                        0,
                        128 * Player[A].MountFrame,
                        plr_shade);

                if(p.State == PLR_STATE_CYCLONE)
                    DrawCycloneAccessory(Z, p, sX + 64, sY + Player[A].MountOffsetY - Y, plr_shade);
            }
        }

        if(LevelMacro == LEVELMACRO_KEYHOLE_EXIT && LevelMacroWhich != 0)
            RenderKeyhole(Z);

        // Put held NPCs on top
        for(size_t i = 0; i < NPC_Draw_Queue_p.Held_n; i++)
        {
            int A = NPC_Draw_Queue_p.Held[i];
            DrawNPCHeld(Z, camX, camY, A);
        }



        //'normal player draw code
        //'Players in front of blocks
        for(int A = numPlayers; A >= 1; A--)
        {
            Player_t& p = Player[A];

            if(p.CurMazeZone == 0 && p.Effect != PLREFF_WARP_PIPE && p.Mount != 2 && s_should_draw_player(p))
                DrawPlayer(p, Z);
        }
        //'normal player end


        // foreground backgrounds
        XRender::setDrawPlane(PLANE_LVL_BGO_FG);

        if(LevelEditor)
        {
            for(; nextBackground < (int)screenBackgrounds.size(); nextBackground++)  // Foreground objects
            {
                int A = screenBackgrounds[nextBackground];
                const auto &bgo = Background[A];

                if(A > numBackground)
                    continue;

                g_stats.checkedBGOs++;
                if(vScreenCollision(Z, bgo.Location) && !bgo.Hidden)
                {
                    auto &bgoGfx = GFXBackgroundBMP[bgo.Type];
                    const vbint_t bgoHeight = BackgroundHeight[bgo.Type];
                    const vbint_t bgoFrame = BackgroundFrame[bgo.Type];
                    g_stats.renderedBGOs++;
                    XRender::renderTextureBasic(num_t::floor(camX + bgo.Location.X),
                                          num_t::floor(camY + bgo.Location.Y),
                                          bgoGfx.w,
                                          bgoHeight,
                                          bgoGfx, 0,
                                          bgoHeight * bgoFrame);
                }
            }
        }
        else
        {
            for(; nextBackground < (int)screenBackgrounds.size() && (int)screenBackgrounds[nextBackground] <= numBackground; nextBackground++)  // Foreground objects
            {
                int A = screenBackgrounds[nextBackground];
                const auto &bgo = Background[A];

                g_stats.checkedBGOs++;

                if(bgo.Hidden)
                    continue;

                int sX = num_t::floor(camX + bgo.Location.X);
                if(sX > vScreen[Z].Width)
                    continue;

                int sY = num_t::floor(camY + bgo.Location.Y);
                if(sY > vScreen[Z].Height)
                    continue;

                auto &bgoGfx = GFXBackgroundBMP[bgo.Type];
                const vbint_t bgoHeight = BackgroundHeight[bgo.Type];

                if(sX + bgoGfx.w >= 0 && sY + bgoHeight >= 0 /*&& !bgo.Hidden*/)
                {
                    g_stats.renderedBGOs++;
                    const vbint_t bgoFrame = BackgroundFrame[bgo.Type];
                    XRender::renderTextureBasic(sX, sY,
                                                bgoGfx.w,
                                                bgoHeight,
                                                bgoGfx, 0,
                                                bgoHeight * bgoFrame);
                }
            }
        }

        XRender::setDrawPlane(PLANE_LVL_NPC_FG);

        // foreground NPCs
        for(size_t i = 0; i < NPC_Draw_Queue_p.FG_n; i++)
        {
            int A = NPC_Draw_Queue_p.FG[i];
            DrawNPC(camX, camY, A);
        }

        XRender::setDrawPlane(PLANE_LVL_BLK_HURTS);

        // Blocks in Front
        for(Block_t& block : screenLavaBlocks)
        {
            g_stats.checkedBlocks++;

            // screenLavaBlocks only contains deadly blocks
            // if(!BlockKills[block.Type]) continue;

            // if(vScreenCollision(Z, block.Location) /*&& !block.Hidden*/)

            // Don't show a visual difference of hit-resized block in a comparison to original state
            int sX = (block.getShrinkResized()) ? (num_t::floor(camX + block.Location.X - 0.05_n)) : (num_t::floor(camX + block.Location.X));
            if(sX > vScreen[Z].Width)
                continue;

            int sY = num_t::floor(camY + block.Location.Y);
            if(sY > vScreen[Z].Height)
                continue;

            int bw = s_round2int(block.Location.Width);
            int bh = s_round2int(block.Location.Height);

            if(sX + bw >= 0 && sY + bh >= 0 /*&& !block.Hidden*/)
            {
                g_stats.renderedBlocks++;
                XRender::renderTextureBasic(sX,
                                      sY + block.ShakeOffset,
                                      bw,
                                      bh,
                                      GFXBlock[block.Type],
                                      0,
                                      BlockFrame[block.Type] * 32);
            }
        }

        XRender::setDrawPlane(PLANE_LVL_EFF_NORM);

        // effects on top
        For(A, 1, numEffects)
        {
            const auto &e = Effect[A];

            if(e.Type != EFFID_BOSS_FRAGILE_DIE && e.Type != EFFID_DOOR_S2_OPEN && e.Type != EFFID_DOOR_DOUBLE_S3_OPEN && e.Type != EFFID_DOOR_SIDE_S3_OPEN &&
               e.Type != EFFID_PLR_FIREBALL_TRAIL && e.Type != EFFID_COIN_SWITCH_PRESS && e.Type != EFFID_SPINBLOCK && e.Type != EFFID_BIG_DOOR_OPEN &&
               e.Type != EFFID_LAVA_MONSTER_LOOK && e.Type != EFFID_WATER_SPLASH && e.Type != EFFID_TIME_SWITCH_PRESS && e.Type != EFFID_TNT_PRESS)
            {
                int sX = (num_t::floor(camX + Effect[A].Location.X));
                if(sX > vScreen[Z].Width)
                    continue;

                int sY = num_t::floor(camY + Effect[A].Location.Y);
                if(sY > vScreen[Z].Height)
                    continue;

                int w = s_round2int(Effect[A].Location.Width);
                int h = s_round2int(Effect[A].Location.Height);

                if(sX + w >= 0 && sY + h >= 0)
                {
                    g_stats.renderedEffects++;

                    XTColor cn = e.Shadow ? XTColor(64, 64, 64) : XTColor();

                    if(e.Type == EFFID_GENERIC_NPC_DIE || e.Type == EFFID_GENERIC_NPC_SQUISH)
                    {
                        auto flip = X_FLIP_NONE;
                        auto draw_h = h;

                        if(e.Type == EFFID_GENERIC_NPC_SQUISH)
                            draw_h /= 2;
                        else
                            flip = X_FLIP_VERTICAL;

                        XRender::renderTextureScaleEx(sX, sY + h - draw_h, w, draw_h,
                            GFXNPCBMP[e.NewNpc],
                            e.NewNpcSpecial * w, e.Frame * h, w, h,
                            0, nullptr, flip, cn);

                        continue;
                    }

                    XRender::renderTextureBasic(sX, sY, w, h,
                        GFXEffectBMP[e.Type], 0, e.Frame * EffectHeight[e.Type], cn);
                }
            }
        }

        XRender::setDrawPlane(PLANE_LVL_INFO);

        // NPCs warnings
        for(size_t i = 0; i < NPC_Draw_Queue_p.Warning_n; i++)
        {
            int A = NPC_Draw_Queue_p.Warning[i];
            DrawWarningNPC(Z, camX, camY, A);
        }

        if(!LevelEditor) // Graphics for the main game.
        {
            // moved vScreen divider below

            // Redigit NetPlay player names were also dropped

            lunaRender(Z);

            // debug code to show logical screens
            if(g_CheatLogicScreen && !screen.is_canonical())
            {
                Screen_t& c_screen = screen.canonical_screen();

                for(int c_vscreen_Z = c_screen.active_begin() + 1; c_vscreen_Z <= c_screen.active_end(); c_vscreen_Z++)
                {
                    vScreen_t& c_vscreen = c_screen.vScreen(c_vscreen_Z);

                    int c_vscreen_X = num_t::floor(camX - c_vscreen.X);
                    int c_vscreen_Y = num_t::floor(camY - c_vscreen.Y);

                    XRender::renderRect(c_vscreen_X, c_vscreen_Y, c_vscreen.Width, c_vscreen.Height,
                        {  0,   0,   0}, false);
                    XRender::renderRect(c_vscreen_X + 1, c_vscreen_Y + 1, c_vscreen.Width - 2, c_vscreen.Height - 2,
                        {  0,   0,   0}, false);
                    XRender::renderRect(c_vscreen_X + 2, c_vscreen_Y + 2, c_vscreen.Width - 4, c_vscreen.Height - 4,
                        {255, 255, 255}, false);
                    XRender::renderRect(c_vscreen_X + 3, c_vscreen_Y + 3, c_vscreen.Width - 6, c_vscreen.Height - 6,
                        {255, 255, 255}, false);
                    SuperPrint(std::to_string(c_vscreen_Z), 1, c_vscreen_X + 4, c_vscreen_Y + 4);
                }
            }

            // 'Interface

            // moved condition past the splitFrame() call (always draw section effects)
            // if(!GameMenu && !GameOutro)

            // figure out whether to show names over players
            bool char_rep = false;
            if(numPlayers > 5)
                char_rep = true;
            else
            {
                for(int A = 1; A < numPlayers; A++)
                {
                    for(int B = A + 1; B <= numPlayers; B++)
                        char_rep |= (Player[A].Character == Player[B].Character);
                }
            }

            if(g_ClonedPlayerMode || GameMenu)
                char_rep = false;

            For(A, 1, numPlayers)
            {
                int p_center_x = num_t::floor(camX + Player[A].Location.X) + s_round2int(Player[A].Location.Width) / 2;
                int info_y = num_t::floor(camY + Player[A].Location.Y) + s_round2int(Player[A].Location.Height) - 96;

                if(char_rep && s_should_draw_player(Player[A]))
                {
                    char pname[2] = {'P', '0'};
                    pname[1] = '0' + A;
                    SuperPrintCenter(2, pname, 3, p_center_x, info_y + 12);
                    info_y -= 16;
                }

                if(Player[A].Effect == PLREFF_COOP_WINGS)
                    DrawPlayer(Player[A], Z, XTColor(192, 192, 192, 192));
                else if(Player[A].ShowWarp > 0 && Player[A].Mount != 2)
                {
                    const auto &w = Warp[Player[A].ShowWarp];

                    if(!w.noPrintStars && w.save_info().inited() && w.save_info().max_stars > 0)
                    {
                        std::string tempString = fmt::format_ne("{0}/{1}", w.curStars, w.save_info().max_stars);
                        int font_half_width = (tempString.length() * 9) & ~1;
                        XRender::renderTextureBasic(p_center_x - font_half_width - 20, info_y,     GFX.Interface[5]);
                        XRender::renderTextureBasic(p_center_x - font_half_width,      info_y + 1, GFX.Interface[1]);
                        SuperPrint(tempString, 3,
                                   p_center_x - font_half_width + 18,
                                   info_y);

                        info_y -= 20;
                    }

                    if(w.save_info().inited() && w.save_info().max_medals > 0)
                    {
                        // IsHubLevel is functionally an optimization here, not a critical piece of logic
                        uint8_t ckpt = (IsHubLevel && Checkpoint == FileNamePath + GetS(w.level)) ? g_curLevelMedals.checkpoint : 0;

                        DrawMedals(p_center_x, info_y, true, w.save_info().max_medals, 0, ckpt, w.save_info().medals_got, w.save_info().medals_best);
                    }
                }
            }
        }

        XRender::setDrawPlane(PLANE_LVL_SECTION_FG);

#ifdef THEXTECH_BUILD_GL_MODERN
        if(SectionParticlesFG[S])
            XRender::renderParticleSystem(**SectionParticlesFG[S], camX_i, camY_i);

        XRender::setupLighting(SectionLighting[S]);

        if(SectionEffect[S])
            XRender::renderTextureScale(0, 0, vScreen[Z].Width, vScreen[Z].Height, **SectionEffect[S]);
        else if(SectionLighting[S])
            XRender::renderLighting();
#endif

        XRender::splitFrame();
        XRender::offsetViewportIgnore(true);

        // vScreen fader (for within-level warps). Always draw for single-player and forced shared screen
        // And don't draw when many players at the same screen (might be leaving / joining the dynamic shared screen)
        if(screen.player_count == 1 || numScreens != 1 || screen.Type == ScreenTypes::SharedScreen)
        {
            if(g_levelVScreenFader[Z].isVisible())
            {
                XRender::setDrawPlane(PLANE_LVL_HUD - 1);
                g_levelVScreenFader[Z].draw(false);
                XRender::splitFrame();
            }
        }

#ifdef __3DS__
        if(GamePaused != PauseCode::Options && !(GameMenu && MenuMode == MENU_NEW_OPTIONS))
            XRender::setTargetLayer(3);
#endif

        // HUD and dropped NPCs
        if(!GameMenu && !GameOutro && !LevelEditor)
        {
            XRender::setDrawPlane(PLANE_LVL_HUD);

            // draw HUD only if player has not disabled it
            if(ShowOnScreenHUD)
            {
#ifdef THEXTECH_ENABLE_LUNA_AUTOCODE
                lunaRenderHud(Z);
#endif

                // this is LunaScript's way of disabling the original SMBX HUD, so it shouldn't affect the Luna HUD
                if(!gSMBXHUDSettings.skip)
                   DrawInterface(Z, numScreens);
            }

            XRender::setDrawPlane(PLANE_LVL_HUD + 1);

            // Display NPCs that got dropped from the container
            for(size_t i = 0; i < NPC_Draw_Queue_p.Dropped_n; i++)
            {
                int A = NPC_Draw_Queue_p.Dropped[i];
                DrawNPC(camX, camY, A);
            }
        }

        XRender::setDrawPlane(PLANE_LVL_META);

        if((LevelEditor || MagicHand))
        {
            // editor code now located in `gfx_editor.cpp`
            XRender::setDrawPlane(PLANE_LVL_INFO);
            DrawEditorLevel(Z);
        }

        XRender::setDrawPlane(PLANE_LVL_META);

        // Screen shake logic was here; moved into the logic section of the file because it affects the random state of the game

        // draw onscreen controls display

        if(screen.Type == 5 && numScreens == 1)
        {
            speedRun_renderControls(0, Z, SPEEDRUN_ALIGN_LEFT);
            speedRun_renderControls(1, Z, SPEEDRUN_ALIGN_RIGHT);
        }
        else if(numScreens >= 2)
        {
            speedRun_renderControls(vscreen_i, Z, SPEEDRUN_ALIGN_AUTO);
        }

        // indicate any small-screen camera features
        if(g_config.small_screen_cam && screen.H < 600
            && screen.Type != 2 && screen.Type != 3 && screen.Type != 7 && (screen.Type != 5 || screen.vScreen(2).Visible))
        {
            DrawSmallScreenCam(vScreen[Z]);
        }
    } // For(Z, 2, numScreens)


    // graphics shared by all vScreens, but still on the Screen
    XRender::setViewport(screen.TargetX(), screen.TargetY(), screen.W, screen.H);
    XRender::offsetViewportIgnore(true);

    // splitscreen dividers
    if(numScreens > 1 && !SingleCoop)
    {
        XRender::setDrawPlane(PLANE_LVL_META);

        bool horiz_split = (screen.Type == ScreenTypes::TopBottom) || (screen.Type == ScreenTypes::Quad);
        horiz_split |= screen.Type == ScreenTypes::Dynamic && (screen.DType == 3 || screen.DType == 4 || screen.DType == 6);

        if(horiz_split)
            XRender::renderRect(0, (screen.H / 2) - 2, screen.W, 4, {0, 0, 0});

        bool vert_split = (screen.Type == ScreenTypes::LeftRight) || (screen.Type == ScreenTypes::Quad);
        vert_split |= screen.Type == ScreenTypes::Dynamic && (screen.DType == 1 || screen.DType == 2);

        if(vert_split)
            XRender::renderRect((screen.W / 2) - 2, 0, 4, screen.H, {0, 0, 0});
    }

    XRender::resetViewport();

    XRender::setDrawPlane(PLANE_GAME_META);

    // 1P / shared screen controls indicator
    bool show_controls_one_vscreen = (screen.Type != 5 && numScreens == 1);

    // fix missing controls info when the vScreen didn't get rendered at all
    bool show_controls_no_vscreen = (screen.Type == 5 && numScreens == 1 && screen.vScreen(1).Width == 0);

    if(show_controls_one_vscreen || show_controls_no_vscreen)
    {
        for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
            speedRun_renderControls(plr_i, -1, SPEEDRUN_ALIGN_AUTO);
    }
}

void UpdateGraphicsMeta()
{
    XRender::resetViewport();

    XRender::setDrawPlane(PLANE_GAME_META);

    if(GameMenu && !GameOutro)
    {
        mainMenuDraw();

#ifdef __3DS__
        // draw everything else below new options screen on 3DS
        if(MenuMode == MENU_NEW_OPTIONS)
            XRender::setTargetLayer(2);
#endif
    }

    if(GameOutro)
        DrawCredits();

    DrawDeviceBattery();

    speedRun_renderTimer();

    if(PrintFPS > 0 && g_config.show_fps)
        SuperPrint(std::to_string(PrintFPS), 1, XRender::TargetOverscanX + 8, 8, {0, 255, 0});

    if(g_VanillaCam && (XRender::TargetW > 800 || XRender::TargetH > 600) && GFX.Camera.inited)
        XRender::renderTextureBasic(XRender::TargetW - XRender::TargetOverscanX - GFX.Camera.w - 4, XRender::TargetH - GFX.Camera.h - 4, GFX.Camera);

    g_stats.print();

    if(!BattleMode && !GameMenu && !GameOutro && !LevelEditor && g_config.show_episode_title)
    {
        // big screen, display at top
        if(XRender::TargetH >= 640 && g_config.show_episode_title == Config_t::EPISODE_TITLE_TOP)
        {
            int y = 20;
            SuperPrintScreenCenter(WorldName, 3, y);
        }
        // display at bottom
        else if(g_config.show_episode_title == Config_t::EPISODE_TITLE_BOTTOM)
        {
            int y = XRender::TargetH - 60;
            SuperPrintScreenCenter(WorldName, 3, y, XTAlphaF(0.75_n));
        }
    }

    XRender::setDrawPlane(PLANE_GAME_MENUS);

    if(LevelEditor || MagicHand)
        DrawEditorLevel_UI();

    // render special screens
    if(GamePaused == PauseCode::PauseScreen)
        PauseScreen::Render();

    if(GamePaused == PauseCode::Message)
        DrawMessage();

    if(GamePaused == PauseCode::DropAdd)
    {
        ConnectScreen::Render();
        XRender::renderTextureBasic(int(SharedCursor.X), int(SharedCursor.Y), GFX.ECursor[2]);
    }

    if(GamePaused == PauseCode::Options)
    {
#ifdef __3DS__
        XRender::setTargetLayer(3);
#endif

        OptionsScreen::Render();
        XRender::renderTextureBasic(int(SharedCursor.X), int(SharedCursor.Y), GFX.ECursor[2]);
    }

    if(GamePaused == PauseCode::TextEntry)
        TextEntryScreen::Render();

    // Draw screen fader below level menu when game is paused
    // This makes sure that the level test menu is drawn above the screen fader during level tests
    if(GamePaused != PauseCode::None)
        XRender::setDrawPlane(PLANE_GAME_MENUS - 1);
    else
        XRender::setDrawPlane(PLANE_GAME_FADER);

    if(LevelSelect && !GameMenu && !GameOutro)
        g_worldScreenFader.draw();
    else
        g_levelScreenFader.draw();
}


================================================
FILE: src/graphics/gfx_update.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_UPDATE_H
#define GFX_UPDATE_H

#include <array>
#include "global_constants.h"

extern std::array<bool, maxLocalPlayers> g_drawBlocks_valid;
extern std::array<bool, maxLocalPlayers> g_drawBGOs_valid;

// should equal the largest X or Y move rate of any layer containing blocks / BGOs
extern num_t g_drawBlocks_invalidate_rate;
extern num_t g_drawBGOs_invalidate_rate;

// call when a block is added, moved, or its Hidden attribute is changed
inline void invalidateDrawBlocks()
{
    for(bool& v : g_drawBlocks_valid)
        v = false;
}

// call when a BGO is added, moved, or its Hidden attribute is changed
inline void invalidateDrawBGOs()
{
    for(bool& v : g_drawBGOs_valid)
        v = false;
}

//! UpdateGraphics function that ONLY draws to the screen (no logic!)
void UpdateGraphicsDraw(bool skipRepaint = false);

#endif // #ifdef GFX_UPDATE_H


================================================
FILE: src/graphics/gfx_update2.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <sdl_proxy/sdl_stdinc.h>

#include <fontman/font_manager.h>

#include "../globals.h"
#include "../gfx.h"
#include "../frame_timer.h"
#include "../graphics.h"
#include "../collision.h"
#include "../player.h"
#include "../config.h"
#include "../sound.h"
#include "../main/speedrunner.h"
#include "../main/trees.h"
#include "../main/screen_pause.h"
#include "../main/screen_connect.h"
#include "../main/screen_options.h"
#include "../main/screen_quickreconnect.h"
#include "../main/screen_textentry.h"
#include "../game_main.h"
#include "../main/world_globals.h"
#include "main/level_medals.h"
#include "../core/render.h"
#include "../screen_fader.h"
#include "message.h"

#include "graphics/gfx_frame.h"
#include "graphics/gfx_marquee.h"
#include "graphics/gfx_world.h"

#include "gfx_special_frames.h"

#include "draw_planes.h"

#include <fmt_format_ne.h>


//! extra non-gameplay related draws (menus and information display), defined in gfx_update.cpp
void UpdateGraphicsMeta();

static inline int computeStarsShowingPolicy(int ll, int cur)
{
    // Disable if not allowed globally
    if(!g_config.world_map_stars_show)
        return Config_t::MAP_STARS_HIDE;

    // Level individual
    if(ll > Config_t::MAP_STARS_UNSPECIFIED)
    {
        if(ll == Config_t::MAP_STARS_COLLECTED && cur <= 0)
            return Config_t::MAP_STARS_HIDE;
        return ll;
    }

    // World map-wide
    // (IMPORTANT NOTE: "hide" is now ignored as a map-wide setting, since the user has responsibility for setting this)
    if(WorldStarsShowPolicy > Config_t::MAP_STARS_HIDE)
    {
        if(WorldStarsShowPolicy == Config_t::MAP_STARS_COLLECTED && cur <= 0)
            return Config_t::MAP_STARS_HIDE;
        return WorldStarsShowPolicy;
    }

    // Default behavior if not disabled is collected only
    if(cur <= 0)
        return Config_t::MAP_STARS_HIDE;

    return Config_t::MAP_STARS_COLLECTED;
}


static inline int s_round2int(num_t d)
{
    return num_t::floor(d + 0.5_n);
}

// draws GFX to screen when on the world map/world map editor
void UpdateGraphics2(bool skipRepaint)
{
    if(!GameIsActive)
        return;

#ifdef USE_RENDER_BLOCKING
    if(XRender::renderBlocked())
        return;
#endif

    cycleNextInc();

    if(g_config.enable_frameskip && frameSkipNeeded())
        return;

#ifdef __16M__
    if(!XRender::ready_for_frame())
    {
        if(g_config.unlimited_framerate)
            frameNextInc();
        return;
    }
#endif

    if(XMessage::GetStatus() == XMessage::Status::replay)
        return;

    XRender::setTargetTexture();

    frameNextInc();
    frameRenderStart();

    g_stats.reset();

    // int A = 0;
    // int B = 0;
    const int Z = l_screen->vScreen_refs[0];
    int WPHeight = 0;
//    Location_t tempLocation;
    //Z = 1;

    if(WorldEditor)
    {
        vScreen[Z].Left = 0;
        vScreen[Z].ScreenLeft = 0;
        vScreen[Z].Top = 0;
        vScreen[Z].ScreenTop = 0;
        vScreen[Z].Width = l_screen->W;
        vScreen[Z].Height = l_screen->H;
    }
    else
    {
        SetupScreens(false);
        GetvScreenWorld(vScreen[Z]);

        if(qScreen)
        {
            qScreen = Update_qScreen(Z, g_worldCamSpeed, g_worldCamSpeed);

            if(qScreen && g_worldPlayCamSound)
                PlaySound(SFX_Camera);

            // reset cam sound
            g_worldPlayCamSound = false;
        }
        // reset cam speed
        else
        {
            g_worldCamSpeed = 1.5_n;
        }
    }

    SpecialFrames();
    CommonFrames();
    WorldFrames();

//    if(WorldEditor == true)
//    {
//        XRender::renderTexture(0, 0, ScreenW, ScreenH, 0, 0, 0);
//    }
//    else
//    {
//        XRender::renderTexture(0, 0, ScreenW, ScreenH, 0, 0, 0);
//    }

#ifdef __3DS__
    XRender::setTargetLayer(0);
#endif

    XRender::setDrawPlane(PLANE_GAME_BACKDROP);

    XRender::clearBuffer();
    XRender::resetViewport();
    DrawBackdrop(*l_screen);

//    if(TakeScreen == true)
//    {
//        if(LevelEditor == true || MagicHand == true)
//            frmLevelWindow::vScreen[Z].AutoRedraw = true;
//        else
//            frmMain.AutoRedraw = true;
//    }

//    If LevelEditor = True Then
//        For A = 1 To numTiles
//            With Tile(A)
//                If vScreenCollision(1, .Location) = True Then
//                    BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXTile(.Type), 0, TileHeight(.Type) * TileFrame(.Type), vbSrcCopy
//                End If
//            End With
//        Next A
//        For A = 1 To numScenes
//            With Scene(A)
//                If vScreenCollision(1, .Location) = True Then
//                    BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXSceneMask(.Type), 0, SceneHeight(.Type) * SceneFrame(.Type), vbSrcAnd
//                    BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXScene(.Type), 0, SceneHeight(.Type) * SceneFrame(.Type), vbSrcPaint
//                End If
//            End With
//        Next A
//        For A = 1 To numWorldPaths
//            With WorldPath(A)
//                If vScreenCollision(1, .Location) = True Then
//                    BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXPathMask(.Type), 0, 0, vbSrcAnd
//                    BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXPath(.Type), 0, 0, vbSrcPaint
//                End If
//            End With
//        Next A
//        For A = 1 To numWorldLevels
//            With WorldLevel(A)
//                If vScreenCollision(1, .Location) = True Then
//                    If .Path = True Then
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXLevelMask(0), 0, 0, vbSrcAnd
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXLevel(0), 0, 0, vbSrcPaint
//                    End If
//                    If .Path2 = True Then
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X - 16, vScreenY(Z) + 8 + .Location.Y, 64, 32, GFXLevelMask(29), 0, 0, vbSrcAnd
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X - 16, vScreenY(Z) + 8 + .Location.Y, 64, 32, GFXLevel(29), 0, 0, vbSrcPaint
//                    End If
//                    If GFXLevelBig(.Type) = True Then
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X - (GFXLevelWidth(.Type) - 32) / 2, vScreenY(Z) + .Location.Y - GFXLevelHeight(.Type) + 32, GFXLevelWidth(.Type), GFXLevelHeight(.Type), GFXLevelMask(.Type), 0, 32 * LevelFrame(.Type), vbSrcAnd
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X - (GFXLevelWidth(.Type) - 32) / 2, vScreenY(Z) + .Location.Y - GFXLevelHeight(.Type) + 32, GFXLevelWidth(.Type), GFXLevelHeight(.Type), GFXLevel(.Type), 0, 32 * LevelFrame(.Type), vbSrcPaint
//                    Else
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXLevelMask(.Type), 0, 32 * LevelFrame(.Type), vbSrcAnd
//                        BitBlt myBackBuffer, vScreenX(Z) + .Location.X, vScreenY(Z) + .Location.Y, .Location.Width, .Location.Height, GFXLevel(.Type), 0, 32 * LevelFrame(.Type), vbSrcPaint
//                    End If
//                End If
//            End With
//        Next A
//    Else

#ifdef __3DS__
    XRender::setTargetLayer(1);
#endif

    XRender::setViewport(vScreen[Z].TargetX() - XRender::TargetOverscanX, vScreen[Z].TargetY(), vScreen[Z].Width + 2 * XRender::TargetOverscanX, vScreen[Z].Height);

    int camX = vScreen[Z].CameraAddX_i() + XRender::TargetOverscanX;
    int camY = vScreen[Z].CameraAddY_i();

    int sLeft = -camX - 2 * XRender::TargetOverscanX;
    int sTop = -camY;
    int sRight = -camX + vScreen[Z].Width + 2 * XRender::TargetOverscanX;
    int sBottom = -camY + vScreen[Z].Height;

    {
        Location_t sView;
        sView.X = sLeft;
        sView.Y = sTop;
        sView.Width = sRight - sLeft;
        sView.Height = sBottom - sTop;

        XRender::setDrawPlane(PLANE_WLD_TIL);

        //for(A = 1; A <= numTiles; A++)
        for(Tile_t* t : treeWorldTileQuery(sLeft, sTop, sRight, sBottom, true))
        {
            Tile_t &tile = *t;
            SDL_assert(IF_INRANGE(tile.Type, 1, maxTileType));

            g_stats.checkedTiles++;
            if(CheckCollision(sView, tile.Location))
            {
                g_stats.renderedTiles++;
//                XRender::renderTexture(camX + Tile[A].Location.X, camY + Tile[A].Location.Y, Tile[A].Location.Width, Tile[A].Location.Height, GFXTile[Tile[A].Type], 0, TileHeight[Tile[A].Type] * TileFrame[Tile[A].Type]);
                XRender::renderTextureBasic(camX + tile.Location.X,
                                      camY + tile.Location.Y,
                                      tile.Location.Width,
                                      tile.Location.Height,
                                      GFXTileBMP[tile.Type], 0, TileHeight[tile.Type] * TileFrame[tile.Type]);
            }
        }

        XRender::setDrawPlane(PLANE_WLD_SCN);

        //for(A = 1; A <= numScenes; A++)
        for(Scene_t* t : treeWorldSceneQuery(sLeft, sTop, sRight, sBottom, true))
        {
            Scene_t &scene = *t;
            SDL_assert(IF_INRANGE(scene.Type, 1, maxSceneType));

            g_stats.checkedScenes++;
            if(CheckCollision(sView, scene.Location) && (WorldEditor || scene.Active))
            {
                g_stats.renderedScenes++;
//                XRender::renderTexture(camX + scene.Location.X, camY + scene.Location.Y, scene.Location.Width, scene.Location.Height, GFXSceneMask[scene.Type], 0, SceneHeight[scene.Type] * SceneFrame[scene.Type]);
//                XRender::renderTexture(camX + scene.Location.X, camY + scene.Location.Y, scene.Location.Width, scene.Location.Height, GFXScene[scene.Type], 0, SceneHeight[scene.Type] * SceneFrame[scene.Type]);
                XRender::renderTextureBasic(camX + scene.Location.X,
                                      camY + scene.Location.Y,
                                      scene.Location.Width, scene.Location.Height,
                                      GFXSceneBMP[scene.Type], 0, SceneHeight[scene.Type] * SceneFrame[scene.Type]);
            }
        }

        XRender::setDrawPlane(PLANE_WLD_PTH);

        //for(A = 1; A <= numWorldPaths; A++)
        for(WorldPath_t* t : treeWorldPathQuery(sLeft, sTop, sRight, sBottom, true))
        {
            WorldPath_t &path = *t;
            SDL_assert(IF_INRANGE(path.Type, 1, maxPathType));

            g_stats.checkedPaths++;
            if(CheckCollision(sView, path.Location) && (WorldEditor || path.Active))
            {
                g_stats.renderedPaths++;
//                XRender::renderTexture(camX + path.Location.X, camY + path.Location.Y, path.Location.Width, path.Location.Height, GFXPathMask[path.Type], 0, 0);
//                XRender::renderTexture(camX + path.Location.X, camY + path.Location.Y, path.Location.Width, path.Location.Height, GFXPath[path.Type], 0, 0);
                XRender::renderTextureBasic(camX + path.Location.X,
                                      camY + path.Location.Y,
                                      path.Location.Width, path.Location.Height,
                                      GFXPathBMP[path.Type], 0, 0);
            }
        }

        XRender::setDrawPlane(PLANE_WLD_LVL);

        //for(A = 1; A <= numWorldLevels; A++)
        for(WorldLevel_t* t : treeWorldLevelQuery(sLeft, sTop, sRight, sBottom, true))
        {
            WorldLevel_t &lvlP = *t;
            SDL_assert(IF_INRANGE(lvlP.Type, 0, maxLevelType));

            g_stats.checkedLevels++;

            // using this for the onscreen collision fixes bugs where levels with large graphics or Big Path backgrounds would not be drawn when partially offscreen
            //   could use a compat check here to choose between LocationOnscreen and Location if desired
            Location_t locOnscreen = lvlP.LocationOnscreen();

            if(CheckCollision(sView, locOnscreen) && (WorldEditor || lvlP.Active))
            {
                Location_t locGFX = lvlP.LocationGFX();

                g_stats.renderedLevels++;

                if(lvlP.Path)
                {
                    XRender::renderTextureBasic(camX + lvlP.Location.X,
                                          camY + lvlP.Location.Y,
                                          lvlP.Location.Width,
                                          lvlP.Location.Height,
                                          GFXLevelBMP[0], 0, 0);
                }

                if(lvlP.Path2)
                {
                    XRender::renderTextureBasic(camX + lvlP.Location.X - 16,
                                          camY + 8 + lvlP.Location.Y,
                                          64, 32,
                                          GFXLevelBMP[29], 0, 0);
                }

                XRender::renderTextureBasic(camX + s_round2int(locGFX.X),
                                      camY + s_round2int(locGFX.Y),
                                      (int)locGFX.Width, (int)locGFX.Height,
                                      GFXLevelBMP[lvlP.Type], 0, 32 * LevelFrame[lvlP.Type]);
            }
        }
    }

    if(WorldEditor)
    {
        XRender::setDrawPlane(PLANE_WLD_EFF);

        for(int A = 1; A <= numEffects; A++)
        {
            if(vScreenCollision(Z, Effect[A].Location))
            {
                XRender::renderTextureBasic(camX + s_round2int(Effect[A].Location.X),
                    camY + s_round2int(Effect[A].Location.Y),
                    (int)Effect[A].Location.Width, (int)Effect[A].Location.Height,
                    GFXEffect[Effect[A].Type], 0, Effect[A].Frame * EffectHeight[Effect[A].Type]);
            }
        }

        XRender::setDrawPlane(PLANE_WLD_INFO);

        for(WorldMusic_t* t : treeWorldMusicQuery(sLeft, sTop, sRight, sBottom, true))
        {
            WorldMusic_t &music = *t;
            if(vScreenCollision(Z, music.Location))
            {
                XRender::renderRect(camX + music.Location.X, camY + music.Location.Y, 32, 32,
                    {255, 0, 255}, false);
                SuperPrint(std::to_string(music.Type), 1, camX + music.Location.X + 2, camY + music.Location.Y + 2);
            }
        }

        for(int A = 1; A <= numWorldAreas; A++)
        {
            WorldArea_t &area = WorldArea[A];
            if(vScreenCollision(Z, static_cast<Location_t>(area.Location)))
            {
                // single color for now
                XTColor color = XTColorF(1.0_n, 0.8_n, 0.2_n);

                // draw rect with outline
                XRender::renderRect(camX + area.Location.X, camY + area.Location.Y,
                    area.Location.Width, area.Location.Height,
                    {0, 0, 0}, false);
                XRender::renderRect(camX + area.Location.X + 1, camY + area.Location.Y + 1,
                    area.Location.Width - 2, area.Location.Height - 2,
                    {0, 0, 0}, false);
                XRender::renderRect(camX + area.Location.X + 2, camY + area.Location.Y + 2,
                    area.Location.Width - 4, area.Location.Height - 4,
                    color, false);
                XRender::renderRect(camX + area.Location.X + 3, camY + area.Location.Y + 3,
                    area.Location.Width - 6, area.Location.Height - 6,
                    color, false);

                // highlight selectable area
                XRender::renderRect(camX + area.Location.X + 4, camY + area.Location.Y + 4,
                    28, 28,
                    XTColorF(1.0_n, 1.0_n, 0.0_n, 0.5_n), true);

                // label with index
                SuperPrint(std::to_string(A), 1, camX + area.Location.X + 4, camY + area.Location.Y + 4);
            }
        }

#ifdef __3DS__
        XRender::setTargetLayer(3);
#endif

        DrawEditorWorld();
    }
    else
    { // NOT AN EDITOR!!!
        XRender::setDrawPlane(PLANE_WLD_PLR);

        if(WorldPlayer[1].Type == 0)
            WorldPlayer[1].Type = 1;

        WorldPlayer[1].Type = Player[1].Character;

        switch(WorldPlayer[1].Type)
        {
        case 3:
            WPHeight = 44;
            break;
        case 4:
            WPHeight = 40;
            break;
        default:
            WPHeight = 32;
            break;
        }

//        XRender::renderTexture(camX + WorldPlayer[1].Location.X, camY + WorldPlayer[1].Location.Y - 10 + WorldPlayer[1].Location.Height - WPHeight, WorldPlayer[1].Location.Width, WPHeight, GFXPlayerMask[WorldPlayer[1].Type], 0, WPHeight * WorldPlayer[1].Frame);
//        XRender::renderTexture(camX + WorldPlayer[1].Location.X, camY + WorldPlayer[1].Location.Y - 10 + WorldPlayer[1].Location.Height - WPHeight, WorldPlayer[1].Location.Width, WPHeight, GFXPlayer[WorldPlayer[1].Type], 0, WPHeight * WorldPlayer[1].Frame);
        XRender::renderTextureBasic(camX + s_round2int(WorldPlayer[1].Location.X),
                              camY + s_round2int(WorldPlayer[1].Location.Y + WorldPlayer[1].Location.Height) - 10 - WPHeight,
                              (int)WorldPlayer[1].Location.Width, WPHeight,
                              GFXPlayerBMP[WorldPlayer[1].Type], 0, WPHeight * WorldPlayer[1].Frame);

        if(WorldPlayer[1].LevelIndex)
        {
            XRender::setDrawPlane(PLANE_WLD_INFO);

            auto &l = WorldLevel[WorldPlayer[1].LevelIndex];

            auto policy = computeStarsShowingPolicy(l.starsShowPolicy, l.curStars);

            int p_center_x = camX + s_round2int(WorldPlayer[1].Location.X + (WorldPlayer[1].Location.Width / 2));
            int info_y = camY + s_round2int(WorldPlayer[1].Location.Y) - 32;

            if(l.save_info.inited() && l.save_info.max_stars > 0 && policy > Config_t::MAP_STARS_HIDE)
            {
                std::string label;

                if(policy >= Config_t::MAP_STARS_SHOW)
                    label = fmt::format_ne("{0}/{1}", l.curStars, l.save_info.max_stars);
                else
                    label = fmt::format_ne("{0}", l.curStars);

                int len = SuperTextPixLen(label, 3);
                int totalLen = len + GFX.Interface[1].w + GFX.Interface[5].w + 8 + 4;
                int x = p_center_x - (totalLen / 2);

                XRender::renderTextureBasic(x, info_y, GFX.Interface[5]);
                XRender::renderTextureBasic(x + GFX.Interface[5].w + 8, info_y, GFX.Interface[1]);
                SuperPrint(label, 3, x + GFX.Interface[1].w + GFX.Interface[5].w + 8 + 4, info_y);
                info_y -= 20;
            }

            if(l.save_info.inited() && l.save_info.max_medals > 0 && true)
            {
                uint8_t ckpt = (Checkpoint == FileNamePathWorld + l.FileName) ? g_curLevelMedals.checkpoint : 0;

                DrawMedals(p_center_x, info_y, true, l.save_info.max_medals, 0, ckpt, l.save_info.medals_got, l.save_info.medals_best);
            }
        }

        XRender::setViewport(l_screen->TargetX(), l_screen->TargetY(), l_screen->W, l_screen->H);

#ifdef __3DS__
        XRender::setTargetLayer(2);
#endif

        XRender::setDrawPlane(PLANE_WLD_FRAME);

//        XRender::renderTexture(0, 0, 800, 130, GFX.Interface[4], 0, 0);
        DrawWorldMapFrame(vScreen[Z]);


        int pX = vScreen[Z].ScreenLeft + 32 - 64 + 48;
        int pY = vScreen[Z].ScreenTop - 6;


        XRender::setDrawPlane(PLANE_WLD_HUD);

        // prepare for player draw
        vScreen[0].X = 0;
        vScreen[0].Y = 0;

        // do this part for l_screen->players
        for(int A = 1; A <= numPlayers; A++)
        {
            DrawPlayerWorld(Player[A], pX, pY);
            pX += 48;
        }

        // Print lives on the screen
        DrawLives(pX + 32, vScreen[Z].ScreenTop - 20, Lives, g_100s);

        // Print coins on the screen
        auto& coin_icon = (Player[1].Character == 5) ? GFX.Interface[6] : GFX.Interface[2];

        XRender::renderTextureBasic(pX + 16, vScreen[Z].ScreenTop - 42, coin_icon);
        XRender::renderTextureBasic(pX + 40, vScreen[Z].ScreenTop - 40, GFX.Interface[1]);
        SuperPrint(std::to_string(Coins), 1, pX + 62, vScreen[Z].ScreenTop - 40);

        // Print stars on the screen
        if(numStars > 0)
        {
            XRender::renderTextureBasic(pX + 16, vScreen[Z].ScreenTop - 64, GFX.Interface[5]);
            XRender::renderTextureBasic(pX + 40, vScreen[Z].ScreenTop - 62, GFX.Interface[1]);
            SuperPrint(std::to_string(numStars), 1, pX + 62, vScreen[Z].ScreenTop - 62);
        }

        // Print the level's name
        if(WorldPlayer[1].LevelIndex)
        {
            int lnlx = pX + 116;
            int lnrx = vScreen[Z].ScreenLeft + vScreen[Z].Width;

            MarqueeSpec marquee_spec(lnrx - lnlx, 10, 64, 32, -1);
            static MarqueeState marquee_state;

            // could make these arrays if multiple world players ever supported
            static vbint_t cache_LevelIndex;
            static int cache_vScreen_W = 0;

            static std::string cache_LevelName_Split;
            static int cache_LevelName_H = 0;

            int font = FontManager::fontIdFromSmbxFont(2);

            if(cache_LevelIndex != WorldPlayer[1].LevelIndex || cache_vScreen_W != vScreen[Z].Width)
            {
                cache_LevelIndex = WorldPlayer[1].LevelIndex;
                cache_vScreen_W = vScreen[Z].Width;

                marquee_state.reset_width();

                int max_width = lnrx - lnlx;

                cache_LevelName_Split = WorldLevel[WorldPlayer[1].LevelIndex].LevelName;
                // mutates cache_LevelName_Split
                cache_LevelName_H = FontManager::optimizeTextPx(cache_LevelName_Split, max_width, font).h();
            }

            if(g_config.world_map_lvlname_marquee || cache_LevelName_H > vScreen[Z].ScreenTop - 2 - 8)
            {
                SuperPrintMarquee(WorldLevel[WorldPlayer[1].LevelIndex].LevelName, 2, lnlx, vScreen[Z].ScreenTop - 21, marquee_spec, marquee_state);
                marquee_state.advance(marquee_spec);
            }
            else
            {
                FontManager::printText(cache_LevelName_Split.c_str(), cache_LevelName_Split.size(),
                                        lnlx, vScreen[Z].ScreenTop - 2 - cache_LevelName_H,
                                        font);
            }
        }

#ifdef __3DS__
        if(GamePaused != PauseCode::Options)
            XRender::setTargetLayer(3);
#endif

        XRender::resetViewport();

        for(int plr_i = 0; plr_i < l_screen->player_count; plr_i++)
            speedRun_renderControls(plr_i, -1, SPEEDRUN_ALIGN_AUTO);
    }

    // draw on-screen menus and meta-information
    UpdateGraphicsMeta();

    if(!skipRepaint)
        XRender::repaint();

    frameRenderEnd();

//    if(XRender::lazyLoadedBytes() > 200000) // Reset timer while loading many pictures at the same time
//        resetFrameTimer();
    XRender::lazyLoadedBytesReset();
}


================================================
FILE: src/graphics/gfx_world.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "core/render.h"

#include "globals.h"
#include "player.h"
#include "gfx.h"
#include "graphics.h"

bool worldHasFrameAssets()
{
    return GFX.WorldMapFrame_Tile.inited && (!GFX.Interface[4].inited || !GFX.isCustom(37) || GFX.isCustom(73));
}

static bool s_border_valid()
{
    return GFX.WorldMapFrame_Border.tex.inited && (!GFX.isCustom(73) || GFX.isCustom(74));
}

static void s_getMargins(const Screen_t& screen, int& margin, int& marginTop, int& marginBottom)
{
    margin = 66;
    marginTop = 130;
    marginBottom = 66;

    if(screen.H < 400)
    {
        marginBottom = 24;
        marginTop = 72;
    }
    else if(screen.H < 500)
    {
        marginBottom = 32;
        marginTop = 96;
    }

    if(screen.W < 400)
        margin = 24;
    else if(screen.W < 600)
        margin = 32;
    else if(screen.W < 800)
        margin = 48;

    // make sure world map frame stays visible
    if(s_border_valid())
    {
        if(margin < GFX.WorldMapFrame_Border.le)
            margin = GFX.WorldMapFrame_Border.le;

        if(margin < GFX.WorldMapFrame_Border.re)
            margin = GFX.WorldMapFrame_Border.re;

        if(marginTop < GFX.WorldMapFrame_Border.te)
            marginTop = GFX.WorldMapFrame_Border.te;

        if(marginBottom < GFX.WorldMapFrame_Border.be)
            marginBottom = GFX.WorldMapFrame_Border.be;
    }
}

void GetvScreenWorld(vScreen_t& vscreen)
{
    const Screen_t& screen = Screens[vscreen.screen_ref];
    const WorldPlayer_t& wp = WorldPlayer[1];
    const TinyLocation_t& wpLoc = wp.Location;

    int margin, marginTop, marginBottom;
    s_getMargins(screen, margin, marginTop, marginBottom);

    vscreen.Top = marginTop;
    vscreen.Height = screen.H - marginBottom - marginTop;
    vscreen.Left = margin;
    vscreen.Width = screen.W - (margin * 2);

    // limit the vScreen to its 800x600 size (668x404) if the new world map frame assets are missing
    const bool haveFrameAssets = worldHasFrameAssets();
    if(!haveFrameAssets)
    {
        if(vscreen.Width > 668)
        {
            vscreen.Left += (vscreen.Width - 668) / 2;
            vscreen.Width = 668;
        }

        if(vscreen.Height > 404)
        {
            vscreen.Top += (vscreen.Height - 404) / 2;
            vscreen.Height = 404;
        }
    }

    int fX = wpLoc.X + wpLoc.Width / 2;
    int fY = wpLoc.Y + wpLoc.Height / 2;

    // apply a temporary vScreen focus
    if(vscreen.TempDelay)
    {
        // this is safe; tempX/Y are set to integral values
        fX = (int)(vscreen.tempX);
        fY = (int)(vscreen.TempY);
    }

    vscreen.X = -fX + vscreen.Width / 2;
    vscreen.Y = -fY + vscreen.Height / 2;

    // begin bounds logic

    // default bounds are the canonical vScreen
    const Screen_t& c_screen = screen.canonical_screen();
    int c_margin, c_marginTop, c_marginBottom;
    s_getMargins(c_screen, c_margin, c_marginTop, c_marginBottom);

    int c_width = c_screen.W - c_margin * 2;
    int c_height = c_screen.H - c_marginTop - c_marginBottom;

    const TinyLocation_t defaultBounds = TinyLocation_t{fX - c_width / 2, fY - c_height / 2, (int16_t)c_width, (int16_t)c_height};

    // get the bounds from the player's section if possible, otherwise the defaults
    const TinyLocation_t& bounds = (wp.Section != 0)
        ? WorldArea[wp.Section].Location
        : defaultBounds;

    if(bounds.Width < vscreen.Width)
    {
        vscreen.Left += (vscreen.Width - bounds.Width) / 2;
        vscreen.Width = bounds.Width;
        vscreen.X = -bounds.X;
    }
    else if(-vscreen.X < bounds.X)
        vscreen.X = -bounds.X;
    else if(-vscreen.X > bounds.X + bounds.Width - vscreen.Width)
        vscreen.X = -(bounds.X + bounds.Width - vscreen.Width);

    if(bounds.Height < vscreen.Height)
    {
        vscreen.Top += (vscreen.Height - bounds.Height) / 2;
        vscreen.Height = bounds.Height;
        vscreen.Y = -bounds.Y;
    }
    else if(-vscreen.Y < bounds.Y)
        vscreen.Y = -bounds.Y;
    else if(-vscreen.Y > bounds.Y + bounds.Height - vscreen.Height)
        vscreen.Y = -(bounds.Y + bounds.Height - vscreen.Height);

    vscreen.ScreenTop = vscreen.Top;
    vscreen.ScreenLeft = vscreen.Left;
}

void DrawPlayerWorld(Player_t& p, int X, int Y)
{
    p.Direction = -1;
    p.Location.SpeedY = 0;
    p.Location.SpeedX = -1;
    p.Controls.Left = false;
    p.Controls.Right = false;
    p.SpinJump = false;
    p.Dead = false;
    p.Immune2 = false;
    p.Fairy = false;
    p.TimeToLive = 0;
    p.Effect = PLREFF_NORMAL;
    p.MountSpecial = 0;
    p.HoldingNPC = 0;
    if(p.Duck)
        UnDuck(p);
    PlayerFrame(p);

    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
    SizeCheck(p);
    p.Location.X = X;
    p.Location.Y = Y - p.Location.Height;

    if(p.MountType == 3)
    {
        p.YoshiWingsFrameCount += 1;
        p.YoshiWingsFrame = 0;
        if(p.YoshiWingsFrameCount <= 12)
            p.YoshiWingsFrame = 1;
        else if(p.YoshiWingsFrameCount >= 24)
            p.YoshiWingsFrameCount = 0;
        if(p.Direction == 1)
            p.YoshiWingsFrame += 2;
    }

    DrawPlayer(p, 0);
}

void DrawWorldMapFrame(const vScreen_t& vscreen)
{
    const Screen_t& screen = Screens[vscreen.screen_ref];

    if(worldHasFrameAssets())
    {
        RenderFrameBorder({0, 0, screen.W, screen.H}, {(int)vscreen.ScreenLeft, (int)vscreen.ScreenTop, (int)vscreen.Width, (int)vscreen.Height},
            GFX.WorldMapFrame_Tile, s_border_valid() ? &GFX.WorldMapFrame_Border : nullptr);
    }
    else
    {
        // render a legacy background, in MANY careful segments...
        constexpr bool do_stretch = true;

        int ScreenLeft = vscreen.ScreenLeft;
        int ScreenTop = vscreen.ScreenTop;
        int ScreenWidth = vscreen.Width;
        int ScreenHeight = vscreen.Height;

        // top-left
        XRender::renderTextureBasic(ScreenLeft - 66, ScreenTop - 130, 66, 130, GFX.Interface[4], 0, 0);

        // top
        int orig_width = GFX.Interface[4].w - 66 - 66;
        if(do_stretch)
        {
            XRender::renderTextureScaleEx(vscreen.ScreenLeft, vscreen.ScreenTop - 130,
                vscreen.Width, 130,
                GFX.Interface[4], 66, 0, orig_width, 130);
        }
        else
        {
            for(int offset = 0; offset < ScreenWidth; offset += orig_width)
            {
                XRender::renderTextureBasic(ScreenLeft + offset, ScreenTop - 130,
                    SDL_min(ScreenWidth - offset, orig_width), 130,
                    GFX.Interface[4], 66, 0);
            }
        }

        // top-right
        XRender::renderTextureBasic(ScreenLeft + ScreenWidth, ScreenTop - 130, 66, 130 + 20, GFX.Interface[4], GFX.Interface[4].w - 66, 0);

        // left
        int orig_height = GFX.Interface[4].h - 130 - 66;
        if(do_stretch)
        {
            XRender::renderTextureScaleEx(vscreen.ScreenLeft - 66, vscreen.ScreenTop,
                66, vscreen.Height,
                GFX.Interface[4], 0, 130, 66, orig_height);
        }
        else
        {
            for(int offset = 0; offset < ScreenHeight; offset += orig_height)
            {
                XRender::renderTextureBasic(ScreenLeft - 66, ScreenTop + offset,
                    66, SDL_min(ScreenHeight - offset, orig_height),
                    GFX.Interface[4], 0, 130);
            }
        }

        // right
        orig_height = GFX.Interface[4].h - (130 + 20) - 66;
        if(do_stretch)
        {
            XRender::renderTextureScaleEx(vscreen.ScreenLeft + vscreen.Width, vscreen.ScreenTop + 20,
                66, vscreen.Height - 20,
                GFX.Interface[4], GFX.Interface[4].w - 66, 130 + 20, 66, orig_height);
        }
        else
        {
            for(int offset = 20; offset < ScreenHeight; offset += orig_height)
            {
                XRender::renderTextureBasic(ScreenLeft + ScreenWidth, ScreenTop + offset,
                    66, SDL_min((int)ScreenHeight - offset, orig_height),
                    GFX.Interface[4], GFX.Interface[4].w - 66, 130 + 20);
            }
        }

        // bottom-left
        XRender::renderTextureBasic(ScreenLeft - 66, ScreenTop + ScreenHeight, 66 + 34, 66, GFX.Interface[4], 0, GFX.Interface[4].h - 66);

        // bottom
        orig_width = GFX.Interface[4].w - (66 + 34) - 66;
        if(do_stretch)
        {
            XRender::renderTextureScaleEx(vscreen.ScreenLeft + 34, vscreen.ScreenTop + vscreen.Height,
                vscreen.Width - 34, 66,
                GFX.Interface[4], 100, GFX.Interface[4].h - 66, orig_width, 66);
        }
        else
        {
            for(int offset = 34; offset < ScreenWidth; offset += orig_width)
            {
                XRender::renderTextureBasic(ScreenLeft + offset, ScreenTop + ScreenHeight,
                    SDL_min(ScreenWidth - offset, orig_width), 66,
                    GFX.Interface[4], 100, GFX.Interface[4].h - 66);
            }
        }

        // bottom-right
        XRender::renderTextureBasic(ScreenLeft + ScreenWidth, ScreenTop + ScreenHeight, 66, 66, GFX.Interface[4], GFX.Interface[4].w - 66, GFX.Interface[4].h - 66);
    }
}


================================================
FILE: src/graphics/gfx_world.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GFX_WORLD_H
#define GFX_WORLD_H

struct vScreen_t;
struct Player_t;

//! Checks whether the world map frame assets exist and are valid
bool worldHasFrameAssets();

//! Get the vscreen for a world player, with world section bounds checking
void GetvScreenWorld(vScreen_t& vscreen);

//! Draws world map frame around vscreen in its screen
void DrawWorldMapFrame(const vScreen_t& vscreen);

//! Draws a player for the world map HUD, at coordinates X (left) and Y (bottom)
void DrawPlayerWorld(Player_t& p, int X, int Y);

#endif // GFX_WORLD_H


================================================
FILE: src/graphics.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "graphics.h"
#include "collision.h"
#include "player.h"
#include "game_main.h"
#include "sound.h"
#include "change_res.h"
#include "main/game_info.h"
#include "core/render.h"
#include "core/events.h"

#include "graphics/gfx_frame.h"
#include "graphics/gfx_camera.h"
#include "graphics/gfx_world.h"

#include "pseudo_vb.h"
#include "gfx.h"
#include "config.h"
#include "npc_traits.h"


//  Get the screen position
void GetvScreen(vScreen_t& vscreen)
{
    auto &p = Player[vscreen.player];
    auto &pLoc = p.Location;

    if(p.Mount == 2)
        pLoc.Height = 0;

    // this check is new because players can now respawn in 1P mode through DropAdd
    num_t pLocY = (p.Effect == PLREFF_RESPAWN) ? p.RespawnY : pLoc.Y;

    vscreen.X = -pLoc.X + (vscreen.Width - pLoc.Width) / 2;
    vscreen.Y = -pLocY + (vscreen.Height * 0.5_n) - vScreenYOffset - pLoc.Height;

    ProcessSmallScreenCam(vscreen);

    vscreen.X += -vscreen.tempX;
    vscreen.Y += -vscreen.TempY;

    // allow some overscan (needed for 3DS)
    int allow_X = (vscreen.Width == Screens[vscreen.screen_ref].W) ? Screens[vscreen.screen_ref].CameraOverscanX : 0;

    // shift the level so that it is onscreen
    if(-vscreen.X < level[p.Section].X - allow_X)
        vscreen.X = -(level[p.Section].X - allow_X);
    if(-vscreen.X + vscreen.Width > level[p.Section].Width + allow_X)
        vscreen.X = -(level[p.Section].Width - vscreen.Width + allow_X);
    if(-vscreen.Y < level[p.Section].Y)
        vscreen.Y = -level[p.Section].Y;
    if(-vscreen.Y + vscreen.Height > level[p.Section].Height)
        vscreen.Y = -(level[p.Section].Height - vscreen.Height);

    if(vscreen.TempDelay > 0)
        vscreen.TempDelay -= 1;
    else
    {
        if(vscreen.tempX > 0)
            vscreen.tempX -= 1;
        if(vscreen.tempX < 0)
            vscreen.tempX += 1;
        if(vscreen.TempY > 0)
            vscreen.TempY -= 1;
        if(vscreen.TempY < 0)
            vscreen.TempY += 1;
    }

    if(p.Mount == 2)
        pLoc.Height = 128;
}

// Get the average screen position for all players
void GetvScreenAverage(vScreen_t& vscreen)
{
    // int A = 0;
    int B = 0;
    num_t OldX = 0;
    num_t OldY = 0;

    OldX = vscreen.X;
    OldY = vscreen.Y;

    vscreen.X = 0;
    vscreen.Y = 0;

    const Screen_t& screen = Screens[vscreen.screen_ref];

    int plr_count = (GameMenu) ? numPlayers : screen.player_count;

    for(int i = 0; i < plr_count; i++)
    {
        const Player_t& plr = Player[(GameMenu) ? i + 1 : screen.players[i]];

        if(!plr.Dead && (plr.Effect != PLREFF_RESPAWN || g_config.multiplayer_pause_controls))
        {
            vscreen.X += -plr.Location.X - plr.Location.Width / 2;

            num_t pLocY = (plr.Effect == PLREFF_RESPAWN) ? plr.RespawnY : plr.Location.Y;

            if(plr.Mount == 2)
                vscreen.Y += -pLocY;
            else
                vscreen.Y += -pLocY - plr.Location.Height;

            B += 1;
        }
    }

    // A = 1;
    if(B == 0)
    {
        if(GameMenu)
        {
            vscreen.X = -level[0].X;
            B = 1;
        }
        else
        {
            vscreen.X = OldX;
            vscreen.Y = OldY;
            return;
        }
    }

    // used ScreenW / ScreenH in VB6 code
    const SpeedlessLocation_t& section = level[Player[screen.players[0]].Section];

    // remember that the screen will be limited to the section's size in all cases
    num_t use_width  = SDL_min(static_cast<num_t>(screen.W), section.Width  - section.X);
    num_t use_height = SDL_min(static_cast<num_t>(screen.H), section.Height - section.Y);

    vscreen.X = (vscreen.X / B) + (use_width / 2);
    vscreen.Y = (vscreen.Y / B) + (use_height / 2) - vScreenYOffset;

    // allow some overscan (needed for 3DS)
    int allow_X = (vscreen.Width == Screens[vscreen.screen_ref].W) ? Screens[vscreen.screen_ref].CameraOverscanX : 0;

    if(-vscreen.X < section.X - allow_X)
        vscreen.X = -(section.X - allow_X);
    if(-vscreen.X + use_width > section.Width + allow_X)
        vscreen.X = -(section.Width - use_width + allow_X);
    if(-vscreen.Y < section.Y)
        vscreen.Y = -section.Y;
    if(-vscreen.Y + use_height > section.Height)
        vscreen.Y = -(section.Height - use_height);

    if(GameMenu)
    {
        if(vscreen.X > OldX)
        {
            if(-vscreen.X <= level[0].X)
                vscreen.X = OldX + 20;
            else
                vscreen.X = OldX;
        }
        else if(vscreen.X < OldX - 10)
            vscreen.X = OldX - 10;

        // on menu, bottom of screen always tracks bottom of level
        vscreen.Y = -(level[Player[1].Section].Height - vscreen.Height);
    }
}

// Get the average screen position for all players with no level edge detection
void GetvScreenAverage2(vScreen_t& vscreen)
{
    // int A = 0;
    int B = 0;

    vscreen.X = 0;
    vscreen.Y = 0;

    const Screen_t& screen = Screens[vscreen.screen_ref];

    for(int i = 0; i < screen.player_count; i++)
    {
        const Player_t& plr = Player[screen.players[i]];

        if(!plr.Dead)
        {
            vscreen.X += -plr.Location.X - plr.Location.Width / 2;
            if(plr.Mount == 2)
                vscreen.Y += -plr.Location.Y;
            else
                vscreen.Y += -plr.Location.Y - plr.Location.Height;
            B += 1;
        }
    }

    //A = 1; // Stored value gets never read

    if(B == 0)
        return;

    const SpeedlessLocation_t& section = level[Player[screen.players[0]].Section];

    num_t use_width  = SDL_min(static_cast<num_t>(screen.W), section.Width  - section.X);
    num_t use_height = SDL_min(static_cast<num_t>(screen.H), section.Height - section.Y);

    vscreen.X = (vscreen.X / B) + (use_width / 2);
    vscreen.Y = (vscreen.Y / B) + (use_height / 2) - vScreenYOffset;
}

// Get the average screen position for all players for ScreenType 3
// Uses only the furthest left and right players for the X position
// Doubles the weight of the top player for the Y position
void GetvScreenAverage3(vScreen_t& vscreen)
{
    int plr_count = 0;
    num_t OldX = 0;
    num_t OldY = 0;

    OldX = vscreen.X;
    OldY = vscreen.Y;

    // calculate average Y position
    vscreen.Y = 0;
    num_t Y_not_warping = 0;
    int not_warping_count = 0;

    // find furthest left, right, top, and bottom players
    num_t l, r, t, b;

    const Screen_t& screen = Screens[vscreen.screen_ref];

    int section_idx = Player[screen.players[0]].Section;

    for(int i = 0; i < screen.player_count; i++)
    {
        const Player_t& plr = Player[screen.players[i]];

        if(plr.Dead)
            continue;

        num_t pl = plr.Location.X;
        num_t pr = pl + plr.Location.Width;

        // DANGER: consider case where players are free-fall and a player respawns
        num_t pLocY = (plr.Effect == PLREFF_RESPAWN) ? plr.RespawnY : plr.Location.Y;

        num_t by = pLocY + plr.Location.Height;

        if(plr_count == 0 || by < t)
            t = by;
        if(plr_count == 0 || b < by)
            b = by;
        if(plr_count == 0 || pl < l)
            l = pl;
        if(plr_count == 0 || r < pr)
            r = pr;

        vscreen.Y -= by;
        plr_count += 1;

        if(!PlayerWaitingInWarp(plr))
        {
            Y_not_warping -= by;
            not_warping_count += 1;
        }
    }

    if(plr_count == 0)
    {
        vscreen.X = OldX;
        vscreen.Y = OldY;
        return;
    }

    // 2x the contribution of the top player to the result
    vscreen.Y -= t;
    plr_count += 1;

    // take the average, but if the players waiting to exit a warp are keeping the screen too high, don't let them control the screen
    num_t mean_Y = vscreen.Y / plr_count;
    if(not_warping_count != 0)
    {
        num_t mean_Y_not_warping = Y_not_warping / not_warping_count;
        // if the warping players are pulling the screen up by more than 100px, ignore them
        num_t allowed_height = 100;
        if(mean_Y > mean_Y_not_warping + allowed_height)
            mean_Y = mean_Y_not_warping + allowed_height;
    }

    const SpeedlessLocation_t& section = level[section_idx];

    num_t use_width  = screen.W;
    num_t use_height = screen.H;

    // allow canonical screen to expand to reach size of main screen, if there are players near the side of the screen
    if(g_config.allow_multires && !screen.Visible)
    {
        // vScreen boundaries that would have been present in SMBX 1.3 splitscreen
        num_t want_l = l - screen.W / 4;
        num_t want_r = r + screen.W / 4;
        num_t want_t = t - screen.H / 4;
        num_t want_b = b + screen.H / 4;

        if(want_t > -mean_Y - screen.H / 2)
            want_t = -mean_Y - screen.H / 2;

        if(want_b < -mean_Y + screen.H / 2)
            want_b = -mean_Y + screen.H / 2;

        if(want_l < section.X)
            want_l = section.X;
        if(want_r > section.Width)
            want_r = section.Width;
        if(want_t < section.Y)
            want_t = section.Y;
        if(want_b > section.Height)
            want_b = section.Height;

        if(want_r - want_l > use_width)
            use_width = want_r - want_l;

        if(want_b - want_t > use_height)
            use_height = want_b - want_t;

        use_width  = SDL_min(use_width,  static_cast<num_t>(screen.visible_screen().W));
        // don't limit by visible screen: needed to handle unusual shared screen cases found by Sapphire Bullet Bill
        // use_height = SDL_min(use_height, static_cast<num_t>(screen.visible_screen().H));

        vscreen.Width = (int)use_width;
        vscreen.Height = (int)use_height;

        if(use_height > screen.H)
            mean_Y = -(want_t + want_b) / 2;
    }

    // if a NoTurnBack section, make sure that the limited width is tracked
    if(g_config.allow_multires && NoTurnBack[section_idx])
        use_width = SDL_min(use_width, static_cast<num_t>(screen.canonical_screen().W));

    use_width  = SDL_min(use_width,  section.Width  - section.X);
    use_height = SDL_min(use_height, section.Height - section.Y);

    vscreen.X = (use_width - (l + r)) / 2;
    vscreen.Y = mean_Y + (use_height / 2) - vScreenYOffset;

    // allow some overscan (needed for 3DS)
    int allow_X = (vscreen.Width == Screens[vscreen.screen_ref].W) ? Screens[vscreen.screen_ref].CameraOverscanX : 0;

    for(int i = 0; i < 2; i++)
    {
        if(-vscreen.X < section.X - allow_X)
            vscreen.X = -(section.X - allow_X);
        if(-vscreen.X + use_width > section.Width + allow_X)
            vscreen.X = -(section.Width - use_width + allow_X);
        if(-vscreen.Y < section.Y)
            vscreen.Y = -section.Y;
        if(-vscreen.Y + use_height > section.Height)
            vscreen.Y = -(section.Height - use_height);

        if(i == 1)
            break;

        if(vscreen.tempX == 0 && vscreen.TempY == 0 && vscreen.TempDelay == 0)
            break;

        // apply vScreen temp
        vscreen.X += -vscreen.tempX;
        vscreen.Y += -vscreen.TempY;

        if(vscreen.TempDelay > 0)
        {
            vscreen.TempDelay--;
            continue;
        }

        if(vscreen.tempX >= 2)
            vscreen.tempX -= 2;
        else if(vscreen.tempX <= -2)
            vscreen.tempX += 2;
        else
            vscreen.tempX = 0;

        if(vscreen.TempY >= 2)
            vscreen.TempY -= 2;
        else if(vscreen.TempY <= -2)
            vscreen.TempY += 2;
        else
            vscreen.TempY = 0;
    }
}

// NEW: update a vScreen with the correct procedure based on its screen's Type and DType
void GetvScreenAuto(vScreen_t& vscreen)
{
    const Screen_t& screen = Screens[vscreen.screen_ref];

    if(screen.Type == 3)
        GetvScreenAverage3(vscreen);
    else if(screen.Type == 2 || (screen.Type == 5 && !screen.vScreen(2).Visible))
        GetvScreenAverage(vscreen);
    else if(screen.Type == 7)
        GetvScreenCredits(vscreen);
    else
        GetvScreen(vscreen);
}

void SharedScreenAvoidJump_Pre(Screen_t& screen)
{
    if(screen.Type != ScreenTypes::SharedScreen)
        return;

    auto& vscreen = screen.vScreen(1);

    GetvScreenAverage3(vscreen);

    if(!screen.is_canonical())
        SharedScreenAvoidJump_Pre(screen.canonical_screen());
}

void SharedScreenAvoidJump_Post(Screen_t& screen, int Delay)
{
    if(screen.Type != ScreenTypes::SharedScreen)
        return;

    auto& vscreen = screen.vScreen(1);

    num_t curX = vscreen.X;
    num_t curY = vscreen.Y;

    vscreen.tempX = 0;
    vscreen.TempY = 0;

    GetvScreenAverage3(vscreen);

    vscreen.tempX = vscreen.X - curX;
    vscreen.TempY = vscreen.Y - curY;

    vscreen.X = curX;
    vscreen.Y = curY;

    vscreen.TempDelay = Delay;

    if(!screen.is_canonical())
        SharedScreenAvoidJump_Post(screen.canonical_screen(), Delay);
}

void SharedScreenResetTemp(Screen_t& screen)
{
    if(screen.Type != ScreenTypes::SharedScreen)
        return;

    auto& vscreen = screen.vScreen(1);

    vscreen.tempX = 0;
    vscreen.TempY = 0;
    vscreen.TempDelay = 0;

    if(!screen.is_canonical())
        SharedScreenResetTemp(screen.canonical_screen());
}

// NEW: get the fixed-resolution vScreen position for a player, and write the top-left coordinate to (left, top)
void GetPlayerScreen(num_t W, num_t H, const Player_t& p, num_t& left, num_t& top)
{
    auto &pLoc = p.Location;

    num_t pHeight = (p.Mount != 2) ? pLoc.Height : 0;

    left = -pLoc.X + (W - pLoc.Width) / 2;
    top = -pLoc.Y + (H / 2) - vScreenYOffset - pHeight;

    // limit to level bounds
    if(-left < level[p.Section].X)
        left = -level[p.Section].X;
    else if(-left + W > level[p.Section].Width)
        left = -(level[p.Section].Width - W);

    if(-top < level[p.Section].Y)
        top = -level[p.Section].Y;
    else if(-top + H > level[p.Section].Height)
        top = -(level[p.Section].Height - H);
}

void SetupGraphics()
{
    //DUMMY AND USELESS

    // Creates the back buffer for the main game
    // myBackBuffer = CreateCompatibleDC(GetDC(0))
    // myBufferBMP = CreateCompatibleBitmap(GetDC(0), screenw, screenh)
//    myBackBuffer = CreateCompatibleDC(frmMain::hdc);
//    myBufferBMP = CreateCompatibleBitmap(frmMain::hdc, ScreenW, ScreenH);
//    SelectObject myBackBuffer, myBufferBMP;
//    GFX.Split(2).Width = ScreenW;
//    GFX.Split(2).Height = ScreenH;
    // GFX.BackgroundColor(1).Width = Screen.Width
    // GFX.BackgroundColor(1).Height = Screen.Height
    // GFX.BackgroundColor(2).Width = Screen.Width
    // GFX.BackgroundColor(2).Height = Screen.Height
}

void SetupEditorGraphics()
{
    //DUMMY AND USELESS

//    GFX.Split(1).Width = frmLevelWindow.vScreen(1).Width
//    GFX.Split(1).Height = frmLevelWindow.vScreen(1).Height
//    GFX.Split(2).Width = frmLevelWindow.vScreen(1).Width
//    GFX.Split(2).Height = frmLevelWindow.vScreen(1).Height
//    vScreen(1).Height = frmLevelWindow.vScreen(1).ScaleHeight
//    vScreen(1).Width = frmLevelWindow.vScreen(1).ScaleWidth
//    vScreen(1).Left = 0
//    vScreen(1).Top = 0
//    vScreen(2).Visible = False
//    'Creates the back buffer for the level editor
//    'myBackBuffer = CreateCompatibleDC(GetDC(0))
//    'myBufferBMP = CreateCompatibleBitmap(GetDC(0), screenw, screenh)
//    'SelectObject myBackBuffer, myBufferBMP
//    GFX.BackgroundColor(1).Width = frmLevelWindow.vScreen(1).Width
//    GFX.BackgroundColor(1).Height = frmLevelWindow.vScreen(1).Height
//    GFX.BackgroundColor(2).Width = frmLevelWindow.vScreen(1).Width
//    GFX.BackgroundColor(2).Height = frmLevelWindow.vScreen(1).Height
}

static inline int s_round2int(num_t d)
{
    return num_t::floor(d + 0.5_n);
}

// change from fullscreen to windowed mode
void ChangeScreen()
{
#ifndef RENDER_FULLSCREEN_ALWAYS
    // shouldn't be possible
    if(g_config.fullscreen.m_set > ConfigSetLevel::user_config)
    {
        PlaySoundMenu(SFX_BlockHit);
        return;
    }

    g_config_game_user.fullscreen = !g_config.fullscreen;
    UpdateConfig();
    SaveConfig();
#endif
}

void GetvScreenCredits(vScreen_t& vscreen)
{
    int A = 0;
    int B = 0;

    vscreen.X = 0;
    vscreen.Y = 0;

    for(A = 1; A <= numPlayers; A++)
    {
        if((!Player[A].Dead || g_gameInfo.outroDeadMode) && Player[A].Effect != PLREFF_RESPAWN)
        {
            vscreen.X += -Player[A].Location.X - Player[A].Location.Width / 2;

            if(Player[A].Mount == 2)
                vscreen.Y += -Player[A].Location.Y;
            else
                vscreen.Y += -Player[A].Location.Y - Player[A].Location.Height;

            B++;
        }
    }

    A = 1;
    if(B == 0)
        return;

    // used ScreenW / ScreenH in VB6 code, using vScreen.Width / Height here

    const SpeedlessLocation_t& section = level[Player[1].Section];

    // remember that the screen will be limited to the section's size in all cases
    num_t use_width  = SDL_min((num_t)vscreen.Width,  section.Width  - section.X);
    num_t use_height = SDL_min((num_t)vscreen.Height, section.Height - section.Y);

    vscreen.X = (vscreen.X / B) + (use_width / 2);
    vscreen.Y = (vscreen.Y / B) + (use_height / 2) - vScreenYOffset;

    if(-vscreen.X < section.X)
        vscreen.X = -section.X;
    if(-vscreen.X + use_width > section.Width)
        vscreen.X = -(section.Width - use_width);
    if(-vscreen.Y < section.Y)
        vscreen.Y = -section.Y;
    if(-vscreen.Y + use_height > section.Height)
        vscreen.Y = -(section.Height - use_height);
}

#if 0
// old, 100x100-based functions
// now defined at gfx_draw_player.cpp

int pfrXo(int plrFrame)
{
#if 1
    return pfrX(plrFrame - 100);
#else
    // Old Redigit's code, does the same as a small one-line formula
    int A;
    A = plrFrame;
    A -= 50;
    while(A > 100)
        A -= 100;
    if(A > 90)
        A = 9;
    else if(A > 90)
        A = 9;
    else if(A > 80)
        A = 8;
    else if(A > 70)
        A = 7;
    else if(A > 60)
        A = 6;
    else if(A > 50)
        A = 5;
    else if(A > 40)
        A = 4;
    else if(A > 30)
        A = 3;
    else if(A > 20)
        A = 2;
    else if(A > 10)
        A = 1;
    else
        A = 0;
    return A * 100;
#endif
}

int pfrYo(int plrFrame)
{
#if 1
    return pfrX(plrFrame - 100);
#else
    // Old Redigit's code, does the same as a small one-line formula
    int A;
    A = plrFrame;
    A -= 50;
    while(A > 100)
        A -= 100;
    A -= 1;
    while(A > 9)
        A -= 10;
    return A * 100;
#endif
}

int pfrX(int plrFrame)
{
    return ((plrFrame + 49) / 10) * 100;
}

int pfrY(int plrFrame)
{
    return ((plrFrame + 49) % 10) * 100;
}
#endif

void ScreenShot()
{
#ifdef USE_SCREENSHOTS_AND_RECS
    XRender::setTargetTexture();
    XRender::makeShot();
    XRender::setTargetScreen();
    PlaySoundMenu(SFX_GotItem);
#endif
    TakeScreen = false;
}

void DrawFrozenNPC(num_t camX, num_t camY, int A)
{
    auto &n = NPC[A];

    int sX = num_t::floor(camX + NPC[A].Location.X);
    int sY = num_t::floor(camY + NPC[A].Location.Y);
    int w = s_round2int(NPC[A].Location.Width);
    int h = s_round2int(NPC[A].Location.Height);

    // collision already checked elsewhere
    // if((vScreenCollision(Z, n.Location) ||
    //     vScreenCollision(Z, newLoc(n.Location.X - (n->WidthGFX - n.Location.Width) / 2,
    //                         n.Location.Y, CDbl(n->WidthGFX), CDbl(n->THeight)))) && !n.Hidden)
    if(true)
    {
// draw npc
        XTColor c = n.Shadow ? XTColor(0, 0, 0) : XTColor();
        int content = n.Special;
        int contentFrame = n.Special2;

        // SDL_assert_release(content >= 0 && content <= maxNPCType);

        // Draw frozen NPC body in only condition the content value is valid
        if(content > 0 && content <= maxNPCType)
        {
            int frame_h = NPCHeight(content);
            int srcX_off = NPC[A].GFXSlot * NPCWidth(content);
            if(srcX_off >= GFXNPCBMP[content].w)
                srcX_off = 0;

            int srcY_off = 0;

            // Fix vanilla bug where these NPCs would be rendered incorrectly
            if(NPCWidthGFX(content) != 0 && g_config.fix_visual_bugs)
            {
                frame_h = NPCHeightGFX(content);

                // computations as though the NPC were rendered normally
                int contents_sX = sX + w / 2 - NPCWidthGFX(content) / 2 + (NPCTraits[content].FrameOffsetX * -NPC[A].Direction);
                int contents_sY = sY + h - NPCHeightGFX(content) + NPCTraits[content].FrameOffsetY;

                // get offsets
                srcX_off = sX - contents_sX;
                srcY_off = sY - contents_sY;

                srcX_off += NPC[A].GFXSlot * NPCWidthGFX(content);
            }

            XRender::renderTextureBasic(sX + 2,
                                    sY + 2,
                                    w - 4,
                                    h - 4,
                                    GFXNPCBMP[content],
                                    2 + srcX_off, 2 + srcY_off + contentFrame * frame_h,
                                    c);
        }

        // draw ice
         XRender::renderTextureBasic(sX + n->FrameOffsetX,
                                sY + n->FrameOffsetY,
                                w - 6, h - 6,
                                GFXNPCBMP[n.Type], 0, 0, c);
         XRender::renderTextureBasic(sX + n->FrameOffsetX + w - 6,
                                sY + n->FrameOffsetY,
                                6, h - 6,
                                GFXNPCBMP[n.Type], 128 - 6, 0, c);
         XRender::renderTextureBasic(sX + n->FrameOffsetX,
                                sY + n->FrameOffsetY + h - 6,
                                w - 6, 6,
                                GFXNPCBMP[n.Type], 0, 128 - 6, c);
         XRender::renderTextureBasic(sX + n->FrameOffsetX + w - 6,
                                sY + n->FrameOffsetY + h - 6,
                                6, 6, GFXNPCBMP[n.Type],
                                128 - 6, 128 - 6, c);
    }
}

Location_t WorldLevel_t::LocationGFX()
{
    Location_t ret = static_cast<Location_t>(Location);

    if(Type >= 1 && Type <= maxLevelType && GFXLevelBig[Type])
    {
        ret.X -= (GFXLevel[Type].w - ret.Width) / 2;
        ret.Y -= (GFXLevel[Type].h - ret.Height);
        ret.Width = GFXLevel[Type].w;
        ret.Height = GFXLevel[Type].h;
    }

    return ret;
}

Location_t WorldLevel_t::LocationOnscreen()
{
    Location_t ret = LocationGFX();

    if(Path2)
    {
        if(ret.Height < 40)
            ret.Height = 40;

        if(ret.Width < 64)
        {
            ret.X += (ret.Width - 64) / 2;
            ret.Width = 64;
        }
    }

    return ret;
}

void DrawBackdrop(const Screen_t& screen)
{
    if(GFX.Backdrop.inited)
    {
        bool border_valid = GFX.Backdrop_Border.tex.inited && (!GFX.isCustom(71) || GFX.isCustom(72));

        // special case for world map
        if(LevelSelect && !GameMenu && !GameOutro && !LevelEditor)
        {
            IntegerLocation_t full{0, 0, XRender::TargetW, XRender::TargetH};
            IntegerLocation_t inner{screen.TargetX(), screen.TargetY(), screen.W, screen.H};

            // if world map frame assets missing, use the 800x600 area isntead
            if(!worldHasFrameAssets())
            {
                inner.X = screen.vScreen(1).TargetX() - 66;
                inner.Y = screen.vScreen(1).TargetY() - 130;
                inner.Width = 800;
                inner.Height = 600;
            }

            RenderFrameBorder(full, inner, GFX.Backdrop, border_valid ? &GFX.Backdrop_Border : nullptr);

            return;
        }

        for(int i = screen.active_begin(); i < screen.active_end(); i++)
        {
            const auto& s = screen.vScreen(i + 1);

            IntegerLocation_t full{0, 0, XRender::TargetW, XRender::TargetH};
            IntegerLocation_t inner{s.TargetX(), s.TargetY(), (int)s.Width, (int)s.Height};

            // horizontal
            if(screen.Type == 4 || (screen.Type == 5 && (screen.DType == 1 || screen.DType == 2)) || (screen.Type == 9 && (i != 2 || screen.active_end() != 3)))
            {
                full.Width = XRender::TargetW / 2;
                // our screen on right
                if(((screen.Type == 4 || (screen.Type == 5 && screen.DType == 1)) && i == 1) || (screen.DType == 2 && i == 0) || (screen.Type == 9 && (i == 1 || i == 3)))
                    full.X = XRender::TargetW / 2;
            }

            // vertical
            if(screen.Type == 1 || (screen.Type == 5 && (screen.DType == 3 || screen.DType == 4 || screen.DType == 6)) || screen.Type == 9)
            {
                full.Height = XRender::TargetH / 2;
                // our screen on bottom
                if(((screen.Type == 1 || (screen.Type == 5 && (screen.DType == 3 || screen.DType == 6))) && i == 1) || (screen.DType == 4 && i == 0) || (screen.Type == 9 && (i == 2 || i == 3)))
                    full.Y = XRender::TargetH / 2;
            }

            RenderFrameBorder(full, inner, GFX.Backdrop, border_valid ? &GFX.Backdrop_Border : nullptr);
        }
    }
}


================================================
FILE: src/graphics.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GRAPHICS_H
#define GRAPHICS_H

#include <string>
#include "location.h"
#include "globals.h"

enum
{
    SHAKE_RANDOM = 0,
    SHAKE_SEQUENTIAL
};

void doShakeScreen(int force, int type);
// decay is in units of 0.001 pixels/frame (ie, 1000 is 1px decay per frame)
void doShakeScreen(int forceX, int forceY, int type, int duration, int decay, const Location_t& source);
void doShakeScreenClear();

// Public Sub UpdateGraphics2() 'draws GFX to screen when on the world map/world map editor
// draws GFX to screen when on the world map/world map editor
void UpdateGraphics2(bool skipRepaint = false);
// Unpack all visible lazily-loaded graphics
void GraphicsLazyPreLoad();
// Draws the black screen (A final screen clean-up before quitting, even frame-skip is enabled)
void GraphicsClearScreen();
// Public Sub UpdateGraphics() 'This draws the graphic to the screen when in a level/game menu/outro/level editor
// This draws the graphic to the screen when in a level/game menu/outro/level editor
void UpdateGraphics(bool skipRepaint = false);
// Public Sub GetvScreen(A As Integer) ' Get the screen position
//  Get the screen position
void GetvScreen(vScreen_t& vscreen);

// Public Sub GetvScreenAverage() ' Get the average screen position for all players
//  Get the average screen position for all players
void GetvScreenAverage(vScreen_t& vscreen);

// Public Sub GetvScreenAverage2() ' Get the average screen position for all players with no level edge detection
//  Get the average screen position for all players with no level edge detection
void GetvScreenAverage2(vScreen_t& vscreen);
//  EXTRA: Get the average screen position for all players in shared screen mode.
//   The main difference is that it uses the average of the further players to each side, instead of the true average
void GetvScreenAverage3(vScreen_t& vscreen);

// NEW: update a vScreen with the correct procedure based on its screen's Type and DType
void GetvScreenAuto(vScreen_t& vscreen);

//  Prepares shared screen to avoid a jump
void SharedScreenAvoidJump_Pre(Screen_t& screen);

//  Sets TempX and TempY to avoid a jump for a Screen's shared vScreen, and TempDelay as requested.
void SharedScreenAvoidJump_Post(Screen_t& screen, int TempDelay);

//  Resets variables set by above
void SharedScreenResetTemp(Screen_t& screen);

// NEW: get the fixed-res vScreen position for a player, and write the top-left coordinate to (left, top)
void GetPlayerScreen(num_t W, num_t H, const Player_t& p, num_t& left, num_t& top);


// Public Sub SetupGraphics()
//! DUMMY AND USELESS
void SetupGraphics();
// Public Sub SetupEditorGraphics()
//! DUMMY AND USELESS
void SetupEditorGraphics();

// Public Sub SetupScreens()
// Sets the screen type and vScreen locations for a single screen
void SetupScreens(Screen_t& screen, bool reset = true);

// Sets the screen type and vScreen locations for all screens
void SetupScreens(bool reset = true);

// Public Sub DynamicScreen() 'for the split screen stuff
// Decides how to split the vScreens in Dynamic mode
void DynamicScreen(Screen_t& screen, bool mute = false);

// NEW: calls DynamicScreen for all screens with ScreenTypes::Dynamic. Mutes any that are not visible.
void DynamicScreens();

// NEW: limit vScreens to playable section area and center them on the real screen
void CenterScreens(Screen_t& screen);

// NEW: limits vScreens to playable section area and centers them on the real screen, for all screens.
void CenterScreens();

// NEW: moves qScreen towards vScreen, now including the screen size
bool Update_qScreen(int Z, num_t camRate = 2, num_t resizeRate = 2);

// Public Sub SuperPrint(SuperWords As String, Font As Integer, X As Single, Y As Single) 'prints text to the screen
// prints text to the screen
int SuperTextPixLen(int SuperN, const char* SuperChars, int Font);
void SuperPrint(int SuperN, const char* SuperChars, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintRightAlign(int SuperN, const char* SuperChars, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintCenter(int SuperN, const char* SuperChars, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintScreenCenter(int SuperN, const char* SuperChars, int Font, int Y, XTColor color = XTColor());

int SuperTextPixLen(const char* SuperChars, int Font);
void SuperPrint(const char* SuperChars, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintRightAlign(const char* SuperChars, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintCenter(const char* SuperChars, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintScreenCenter(const char* SuperChars, int Font, int Y, XTColor color = XTColor());

int SuperTextPixLen(const std::string &SuperWords, int Font);
void SuperPrint(const std::string &SuperWords, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintRightAlign(const std::string &SuperWords, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintCenter(const std::string &SuperWords, int Font, int X, int Y, XTColor color = XTColor());
void SuperPrintScreenCenter(const std::string &SuperWords, int Font, int Y, XTColor color = XTColor());

/*!
 * \brief Prepares dimensions for drawing a message with the message box
 */
void PrepareMessageDims();

/*!
 * \brief Print the message box with a multi-line text inside using a plain string itself
 */
void DrawMessage();

/*!
 * \brief This is a very special function that runs only last state of the texture
 */
void UpdateGraphicsFatalAssert();

// Public Sub SetRes()
// void SetRes(); //deprecated
// Public Function CheckKey(newStrizzle As String) As String
//std::string CheckKey(std::string newStrizzle); // USELESS

// moved to gfx_special_frames.h
// Private Sub SpecialFrames() 'update frames for special things such as coins and kuribo's shoe
// extern void SpecialFrames();//PRIVATE
// update frames for special things such as coins and kuribo's shoe

// Public Sub DrawBackground(S As Integer, Z As Integer) 'draws the background to the screen
// draws the background to the screen
void DrawBackground(int S, int Z);

// these were removed, and their logic is now incorporated into RenderTexturePlayer.

// Public Sub PlayerWarpGFX(A As Integer, tempLocation As Location, X2 As Single, Y2 As Single)
// void PlayerWarpGFX(int A, IntegerLocation_t &tempLocation, int &X2, int &Y2);
// Public Sub NPCWarpGFX(A As Integer, tempLocation As Location, X2 As Single, Y2 As Single)
// void NPCWarpGFX(int A, IntegerLocation_t &tempLocation, int &X2, int &Y2);

// Public Sub ChangeScreen() 'change from fullscreen to windowed mode
// change from fullscreen to windowed mode
void ChangeScreen();
// Public Sub GetvScreenCredits() ' Get the average screen position for all players for the games outro
//  Get the average screen position for all players for the games outro
void GetvScreenCredits(vScreen_t& vscreen);
// Public Sub DoCredits() 'print credits
// print credits
void DoCredits();
void DrawCredits();
// Public Sub DrawInterface(Z As Integer, numScreens) 'draws the games interface
// draws the games interface
void DrawInterface(int Z, int numScreens);

/*!
 * \brief NEW: draws the lives / 100s count
 * \param X      the *right* side of the 1UP / 100 icon
 * \param Y      top Y coordinate
 * \param lives  lives count to draw
 * \param hunds  100s count to draw
 * \param force_lives force draw of the lives count
 */
void DrawLives(int X, int Y, int lives, int hunds, bool force_lives = false);

/*!
 * \brief NEW: draws a set of medals onscreen
 * \param X      right/center X coordinate
 * \param Y      top Y coordinate
 * \param warp   whether this is a medals preview for a warp/level; will be centered on X if true, otherwise right-justified
 * \param max    integer for the maximum number of medals (limited to 8)
 * \param prev   bitmask for previously received medals (used in level)
 * \param ckpt   bitmask for medals gotten before checkpoint (used in world / hub)
 * \param got    bitmask for acquired medals (acquired in current session, when inside level)
 * \param best   bitmask for best set of medals acquired during a single life (acquired during current life, when inside level)
 */
void DrawMedals(int X, int Y, bool warp, uint8_t max, uint8_t prev, uint8_t ckpt, uint8_t got, uint8_t best);

// NEW: draws the level editor interface on vScreen Z
void DrawEditorLevel(int Z);
// NEW: draws the level editor UI
void DrawEditorLevel_UI();
// NEW: draws the world editor interface
void DrawEditorWorld();

#if 0
// old, 100x100-based functions

// Public Function pfrX(plrFrame As Integer) As Integer
//! Get X offset at the player sprite (old call, required to add 100 into source value)
int pfrXo(int plrFrame);
// Public Function pfrY(plrFrame As Integer) As Integer
//! Get Y offset at the player sprite (old call, required to add 100 into source value)
int pfrYo(int plrFrame);
//! Get X offset at the player sprite
int pfrX(int plrFrame);
//! Get Y offset at the player sprite
int pfrY(int plrFrame);
#endif

// NEW: defined in gfx_draw_player.cpp

//! Get left pixel at the player sprite
int pfrX(const StdPicture& tx, const Player_t& p);
//! Get top pixel at the player sprite
int pfrY(const StdPicture& tx, const Player_t& p);
//! Get width at the player sprite
int pfrW(const StdPicture& tx, const Player_t& p);
//! Get height at the player sprite
int pfrH(const StdPicture& tx, const Player_t& p);
//! Get x offset that should be ADDED to the player position to draw the sprite
int pfrOffX(const StdPicture& tx, const Player_t& p);
//! Get y offset that should be ADDED to the player position to draw the sprite
int pfrOffY(const StdPicture& tx, const Player_t& p);

// Public Sub GameThing()
/*!
 * \brief Draw the level enter scene
 * \param noSetup Avoid player settings re-setup
 */
void GameThing(int waitms = 0, int fadeSpeed = 0);
// Draw a player frame onscreen
void DrawPlayerRaw(int X, int Y, int Character, int State, int Frame, int Direction);
// Public Sub DrawPlayer(A As Integer, Z As Integer)
void DrawPlayer(const int A, const int Z, XTColor color = XTColor());
void DrawPlayer(Player_t &p, const int Z, XTColor color = XTColor());

// NEW: cX and tY are in screen coordinates
void DrawCycloneAccessory(int Z, const Player_t& p, int cX, int tY, XTColor c);

// Public Sub ScreenShot()
void ScreenShot();
// Public Sub DrawFrozenNPC(Z As Integer, A As Integer)
void DrawFrozenNPC(num_t camX, num_t camY, int A);
// NEW: draw wings for an NPC at a particular location
void DrawNPCWings(const NPC_t& n, int sX, int sY, XTColor cn);
// NEW: draw NPC held by player
void DrawNPCHeld(int Z, num_t camX, num_t camY, int A);
// NEW: draw NPC (generic routine)
void DrawNPC(num_t camX, num_t camY, int A);

// NEW: draw the backdrop texture behind the vScreens
void DrawBackdrop(const Screen_t& screen);
// NEW: draws device battery status in top-right corner of screen
void DrawDeviceBattery();


#endif // GRAPHICS_H


================================================
FILE: src/layers.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <set>

#include "sdl_proxy/sdl_stdinc.h"
#include "globals.h"
#include "layers.h"
#include "saved_layers.h"
#include "effect.h"
#include "collision.h"
#include "npc.h"
#include "npc_id.h"
#include "eff_id.h"
#include "blk_id.h"
#include "npc_traits.h"
#include "sound.h"
#include "graphics.h"
#include "game_main.h"
#include "config.h"
#include "frame_timer.h"
#include "main/speedrunner.h"
#include "editor.h"
#include "player.h"
#include "blocks.h"
#include "main/trees.h"
#include "main/block_table.h"
#include "script/msg_preprocessor.h"

#include "npc/npc_activation.h"
#include "npc/npc_queues.h"
#include "npc/section_overlap.h"
#include "graphics/gfx_update.h"
#include "main/game_loop_interrupt.h"

int numLayers = 0;
RangeArr<Layer_t, 0, maxLayers> Layer;

int numEvents = 0;
RangeArr<Events_t, 0, maxEvents> Events;

RangeArrI<eventindex_t, 1, maxEvents, EVENT_NONE> NewEvent;
RangeArrI<vbint_t, 1, maxEvents, 0> newEventDelay;
RangeArrI<uint8_t, 1, maxEvents, 0> newEventPlayer;
int newEventNum = 0;

layerindex_t LAYER_USED_P_SWITCH = LAYER_NONE;
static std::set<eventindex_t> recentlyTriggeredEvents;

static SDL_INLINE bool equalCase(const std::string &x, const std::string &y)
{
    return (SDL_strcasecmp(x.c_str(), y.c_str()) == 0);
}

static SDL_INLINE ATTRIB_UNUSED bool equalCase(const char *x, const char *y)
{
    return (SDL_strcasecmp(x, y) == 0);
}

static void sorted_insert(std::vector<vbint_t>& vec, vbint_t val)
{
    auto it = std::lower_bound(vec.begin(), vec.end(), val);
    bool val_exists = (it != vec.end() && *it == val);

    // don't duplicate value
    if(val_exists)
        return;

    vec.insert(it, val);
}

static void sorted_erase(std::vector<vbint_t>& vec, vbint_t val)
{
    auto it = std::lower_bound(vec.begin(), vec.end(), val);
    bool val_exists = (it != vec.end() && *it == val);

    // don't remove nonexistent value
    if(!val_exists)
        return;

    vec.erase(it);
}



// utilities for layerindex_t and eventindex_t

layerindex_t FindLayer(const std::string& LayerName)
{
    if(LayerName.empty())
        return LAYER_NONE;

    for(layerindex_t A = 0; A <= maxLayers; A++)
    {
        if(equalCase(Layer[A].Name, LayerName))
            return A;
    }

    return LAYER_NONE;
}

eventindex_t FindEvent(const std::string& EventName)
{
    if(EventName.empty())
        return EVENT_NONE;

    for(eventindex_t A = 0; A <= maxEvents; A++)
    {
        if(equalCase(Events[A].Name, EventName))
            return A;
    }

    return EVENT_NONE;
}


// Functions for layers


// New functions:


bool SwapLayers(layerindex_t index_1, layerindex_t index_2)
{
    if(index_1 == LAYER_NONE || index_2 == LAYER_NONE)
        return false;

    std::swap(Layer[index_1], Layer[index_2]);

    // repoint all of the new Layer 1's objects to index 1
    for(int A : Layer[index_1].NPCs)
        NPC[A].Layer = index_1;

    for(int A : Layer[index_1].blocks)
        Block[A].Layer = index_1;

    for(int A : Layer[index_1].BGOs)
        Background[A].Layer = index_1;

    for(int A : Layer[index_1].warps)
        Warp[A].Layer = index_1;

    for(int A : Layer[index_1].waters)
        Water[A].Layer = index_1;

    // repoint all of the new Layer 2's objects to index 2
    for(int A : Layer[index_2].NPCs)
        NPC[A].Layer = index_2;

    for(int A : Layer[index_2].blocks)
        Block[A].Layer = index_2;

    for(int A : Layer[index_2].BGOs)
        Background[A].Layer = index_2;

    for(int A : Layer[index_2].warps)
        Warp[A].Layer = index_2;

    for(int A : Layer[index_2].waters)
        Water[A].Layer = index_2;

    // swap AttLayers
    for(int A = 1; A <= numNPCs; A++)
    {
        if(NPC[A].AttLayer == index_1)
            NPC[A].AttLayer = index_2;
        else if(NPC[A].AttLayer == index_2)
            NPC[A].AttLayer = index_1;
    }

    // swap event layer refs
    for(int A = 0; A < numEvents; A++)
    {
        for(layerindex_t& l : Events[A].HideLayer)
        {
            if(l == index_1)
                l = index_2;
            else if(l == index_2)
                l = index_1;
        }

        for(layerindex_t& l : Events[A].ShowLayer)
        {
            if(l == index_1)
                l = index_2;
            else if(l == index_2)
                l = index_1;
        }

        for(layerindex_t& l : Events[A].ToggleLayer)
        {
            if(l == index_1)
                l = index_2;
            else if(l == index_2)
                l = index_1;
        }

        if(Events[A].MoveLayer == index_1)
            Events[A].MoveLayer = index_2;
        else if(Events[A].MoveLayer == index_2)
            Events[A].MoveLayer = index_1;
    }

    // swap EditorCursor layer
    if(EditorCursor.Layer == index_1)
        EditorCursor.Layer = index_2;
    else if(EditorCursor.Layer == index_2)
        EditorCursor.Layer = index_1;

    LAYER_USED_P_SWITCH = FindLayer(LAYER_USED_P_SWITCH_TITLE);

    return true;
}

bool RenameLayer(layerindex_t L, const std::string& NewName)
{
    if(L == LAYER_NONE)
        return false;
    if(NewName.empty())
        return false;

    int A = 0;

    for(A = 0; A <= maxLayers; A++)
    {
        if(equalCase(Layer[A].Name, NewName))
            return false;
    }

    Layer[L].Name = NewName;

    LAYER_USED_P_SWITCH = FindLayer(LAYER_USED_P_SWITCH_TITLE);

    return true;
}

bool DeleteLayer(layerindex_t L, bool killall)
{
    if(L == LAYER_NONE)
        return false;

    int A = 0;

    // order is important here, thus the unoptimized loops
    for(A = numNPCs; A >= 1; A--)
    {
        if(NPC[A].AttLayer == L)
            NPC[A].AttLayer = LAYER_NONE;
        if(NPC[A].Layer == L)
        {
            if(killall)
                KillNPC(A, 9);
            else
            {
                NPC[A].Layer = LAYER_DEFAULT;
                syncLayers_NPC(A);
            }
        }
    }

    for(A = numBlock; A >= 1; A--)
    {
        if(Block[A].Layer == L)
        {
            if(killall)
                KillBlock(A, false);
            else
            {
                Block[A].Layer = LAYER_DEFAULT;
                syncLayersTrees_Block(A);
            }
        }
    }

    for(A = numWarps; A >= 1; A--)
    {
        if(Warp[A].Layer == L)
        {
            if(killall)
                KillWarp(A);
            else
            {
                Warp[A].Layer = LAYER_DEFAULT;
                syncLayers_Warp(A);
            }
        }
    }

    for(A = numBackground; A >= 1; A--)
    {
        if(Background[A].Layer == L)
        {
            if(killall)
            {
                Background[A] = Background[numBackground];
                numBackground --;
                syncLayers_BGO(A);
                syncLayers_BGO(numWater+1);
            }
            else
            {
                Background[A].Layer = LAYER_DEFAULT;
                syncLayers_BGO(A);
            }
        }
    }

    for(A = numWater; A >= 1; A--)
    {
        if(Water[A].Layer == L)
        {
            if(killall)
            {
                Water[A] = Water[numWater];
                numWater --;
                syncLayers_Water(A);
                syncLayers_Water(numWater+1);
            }
            else
            {
                Water[A].Layer = LAYER_DEFAULT;
                syncLayers_Water(A);
            }
        }
    }

    for(A = 0; A < numEvents; A++)
    {
        for(auto it = Events[A].HideLayer.end(); it != Events[A].HideLayer.begin();)
        {
            it--;
            if(*it == L)
                it = Events[A].HideLayer.erase(it);
        }

        for(auto it = Events[A].ShowLayer.end(); it != Events[A].ShowLayer.begin();)
        {
            it--;
            if(*it == L)
                it = Events[A].ShowLayer.erase(it);
        }

        for(auto it = Events[A].ToggleLayer.end(); it != Events[A].ToggleLayer.begin();)
        {
            it--;
            if(*it == L)
                it = Events[A].ToggleLayer.erase(it);
        }

        if(Events[A].MoveLayer == L)
            Events[A].MoveLayer = LAYER_NONE;
    }

    for(int B = L; B < numLayers - 1; B++)
        SwapLayers(B, B+1);

    numLayers --;
    Layer[numLayers] = Layer_t();

    if(EditorCursor.Layer == L)
        EditorCursor.Layer = LAYER_DEFAULT;

    LAYER_USED_P_SWITCH = FindLayer(LAYER_USED_P_SWITCH_TITLE);

    return true;
}

void SetLayerSpeed(layerindex_t L, num_t SpeedX, num_t SpeedY, bool EffectStop, bool Defective)
{
    if(L == LAYER_NONE)
        return;

    if(g_config.fix_attlayer_reset)
        Defective = false;

    // relatively simple code to set the layer's speed
    if(SpeedX != 0 || SpeedY != 0 || Defective)
    {
        Layer[L].SpeedX = (numf_t)SpeedX;
        Layer[L].SpeedY = (numf_t)SpeedY;

        if(!Defective)
            Layer[L].EffectStop = EffectStop;

        return;
    }


    // relatively more complex code to stop the layer -- first check that it's necessary (note: this check prevents an infinite recursion)
    if(Layer[L].SpeedX == 0 && Layer[L].SpeedY == 0)
        return;


    // EffectStop is set arbitrarily in the SMBX 1.3 code (and not used while speed is 0), but fortunately always to the opposite of what it is actually meant to be
    Layer[L].EffectStop = !EffectStop;
    Layer[L].SpeedX = 0;
    Layer[L].SpeedY = 0;
    Layer[L].ApplySpeedX = 0;
    Layer[L].ApplySpeedY = 0;

    for(int C : Layer[L].blocks)
    {
        Block[C].Location.SpeedX = 0;
        Block[C].Location.SpeedY = 0;

        if(Block[C].Type >= BLKID_CONVEYOR_L_START && Block[C].Type <= BLKID_CONVEYOR_L_END)
            Block[C].Location.SpeedX = -0.8_n;
        else if(Block[C].Type >= BLKID_CONVEYOR_R_START && Block[C].Type <= BLKID_CONVEYOR_R_END)
            Block[C].Location.SpeedX = 0.8_n;
    }

    for(int C : Layer[L].NPCs)
    {
        if(NPC[C]->IsAVine || NPC[C].Type == NPCID_ITEM_BURIED)
        {
            NPC[C].Location.SpeedX = 0;
            NPC[C].Location.SpeedY = 0;
        }

        if(g_config.fix_attlayer_reset && !NPC[C].Active)
        {
            // this does not cause an infinite recursion due to the early return code above
            if(NPC[C].AttLayer != LAYER_NONE && NPC[C].AttLayer != LAYER_DEFAULT)
                SetLayerSpeed(NPC[C].AttLayer, 0, 0);
        }
    }
}


// Old functions:

void ShowLayer(layerindex_t L, bool NoEffect)
{
    if(L == LAYER_NONE)
        return;

    int A = 0;
    int B = 0;

    if(Layer[L].SavedLayer)
        SavedLayers[Layer[L].SavedLayer - 1].Visible = true;

    Layer[L].Hidden = false;
    if(L == LAYER_DESTROYED_BLOCKS)
        Layer[L].Hidden = true;

    if(L == LAYER_SPAWNED_NPCS)
        Layer[L].Hidden = false;

    for(int A : Layer[L].NPCs)
    {
        if(NPC[A].Hidden)
        {
            if(!NoEffect && !NPC[A].Generator)
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);

            if(!LevelEditor)
            {
                if(!NPC[A]->WontHurt && !NPC[A]->IsABonus && NPC[A].Active)
                {
                    for(B = 1; B <= numPlayers; B++)
                    {
                        if(CheckCollision(Player[B].Location, NPC[A].Location))
                            Player[B].Immune = 120;
                    }
                }
            }
        }
        NPC[A].Hidden = false;
        NPC[A].GeneratorActive = true;
        NPC[A].Reset[1] = true;
        NPC[A].Reset[2] = true;

        if(!NPC[A].Generator)
        {
            bool do_activate = true;

            // new logic: if an NPC must follow canonical screen logic, only activate it if on a canonical vScreen
            // Fixes bug at star exit on SRW2:YA - Searing Skull Stepping
            if(g_config.fix_npc_camera_logic && !NPC[A].Active && NPC_MustBeCanonical(A))
            {
                bool hit = false;

                // see if it's close to a canonical screen (within 8px), and disallow it from activating if not
                // (fixes mostly vanilla bug which occurs because visible NPCs move following Deactivate but hidden NPCs don't)
                Location_t tempLocation = NPC[A].Location;
                tempLocation.X -= 8;
                tempLocation.Y -= 8;
                tempLocation.Width += 16;
                tempLocation.Height += 16;

                for(int screen_i = 0; !hit && screen_i < c_screenCount; screen_i++)
                {
                    const Screen_t& screen = Screens[screen_i];

                    if(!screen.is_active())
                        continue;

                    if(!screen.is_canonical())
                        continue;

                    for(int vscreen_i = screen.active_begin(); !hit && vscreen_i < screen.active_end(); vscreen_i++)
                    {
                        int vscreen_Z = screen.vScreen_refs[vscreen_i];

                        if(vScreenCollision(vscreen_Z, tempLocation))
                            hit = true;
                    }
                }

                if(!hit)
                    do_activate = false;
            }

            if(do_activate)
            {
                NPC[A].Active = true;
                NPC[A].TimeLeft = 1;

                NPCQueues::Active.insert(A);
            }
        }

        CheckSectionNPC(A);
    }

    if(!Layer[L].blocks.empty())
        invalidateDrawBlocks();

    for(int A : Layer[L].blocks)
    {
        // If Not (Block(A).DefaultType = 0 And Block(A).Layer = "Destroyed Blocks") Then
        if(Block[A].Hidden)
        {
            if(!NoEffect && !Block[A].Invis)
                NewEffect(EFFID_SMOKE_S3_CENTER, Block[A].Location);
        }
        Block[A].Hidden = false;

        // moved code to restore all hit blocks below
    }

    if(!Layer[L].BGOs.empty())
        invalidateDrawBGOs();

    for(int A : Layer[L].BGOs)
    {
        if(Background[A].Hidden)
        {
            if(!NoEffect)
                NewEffect(EFFID_SMOKE_S3_CENTER, static_cast<Location_t>(Background[A].Location));
        }
        Background[A].Hidden = false;
    }

    for(int A : Layer[L].warps)
        Warp[A].Hidden = false;

    for(int A : Layer[L].waters)
        Water[A].Hidden = false;

    if(L == LAYER_DESTROYED_BLOCKS)
    {
        // restore all hit blocks, even non-destroyed
        for(A = 1; A <= numBlock; A++)
        {
            if(Block[A].DefaultType > 0)
            {
                // could be nice to have an "orig_layer" variable,
                //  would eliminate certain vanilla peculiarities,
                //  especially if done cleverly with the block's
                //  layer offset
                if(Block[A].Layer == L)
                    Block[A].Layer = LAYER_DEFAULT;
                Block[A].Special = Block[A].DefaultSpecial;
                Block[A].Type = Block[A].DefaultType;
                syncLayersTrees_Block(A);
            }
        }
    }
}

void HideLayer(layerindex_t L, bool NoEffect)
{
    if(L == LAYER_NONE)
        return;

    if(Layer[L].SavedLayer)
        SavedLayers[Layer[L].SavedLayer - 1].Visible = false;

    Layer[L].Hidden = true;

    for(int A : Layer[L].NPCs)
    {
        if(!NPC[A].Hidden)
        {
            if(!NoEffect && !NPC[A].Generator)
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
        }

        NPC[A].Hidden = true;

        if(!LevelEditor && !NPC[A].Generator)
            Deactivate(A);
    }

    if(!Layer[L].blocks.empty())
        invalidateDrawBlocks();

    for(int A : Layer[L].blocks)
    {
        if(!Block[A].Hidden)
        {
            if(!NoEffect && !Block[A].Invis)
                NewEffect(EFFID_SMOKE_S3_CENTER, Block[A].Location);
        }
        Block[A].Hidden = true;
    }

    if(!Layer[L].BGOs.empty())
        invalidateDrawBGOs();

    for(int A : Layer[L].BGOs)
    {
        if(!Background[A].Hidden)
        {
            if(!NoEffect)
                NewEffect(EFFID_SMOKE_S3_CENTER, static_cast<Location_t>(Background[A].Location));
        }
        Background[A].Hidden = true;
    }

    for(int A : Layer[L].warps)
        Warp[A].Hidden = true;

    for(int A : Layer[L].waters)
        Water[A].Hidden = true;
}

void SetLayer(layerindex_t /*LayerName*/)
{
    // Unused
}



// Functions for events


// New functions:

void InitializeEvent(Events_t& event)
{
    event.reinit();

    for(int i = 0; i <= maxSections; i++)
        event.section[i].position.X = EventSection_t::LESet_Nothing;
}

bool SwapEvents(eventindex_t index_1, eventindex_t index_2)
{
    if(index_1 == EVENT_NONE || index_2 == EVENT_NONE)
        return false;

    std::swap(Events[index_1], Events[index_2]);

    int A = 0;

    // swap EVERYTHING
    for(A = 1; A <= numNPCs; A++)
    {
        if(NPC[A].TriggerTalk == index_1)
            NPC[A].TriggerTalk = index_2;
        else if(NPC[A].TriggerTalk == index_2)
            NPC[A].TriggerTalk = index_1;

        if(NPC[A].TriggerDeath == index_1)
            NPC[A].TriggerDeath = index_2;
        else if(NPC[A].TriggerDeath == index_2)
            NPC[A].TriggerDeath = index_1;

        if(NPC[A].TriggerLast == index_1)
            NPC[A].TriggerLast = index_2;
        else if(NPC[A].TriggerLast == index_2)
            NPC[A].TriggerLast = index_1;

        if(NPC[A].TriggerActivate == index_1)
            NPC[A].TriggerActivate = index_2;
        else if(NPC[A].TriggerActivate == index_2)
            NPC[A].TriggerActivate = index_1;
    }

    for(A = 1; A <= numBlock; A++)
    {
        if(Block[A].TriggerHit == index_1)
            Block[A].TriggerHit = index_2;
        else if(Block[A].TriggerHit == index_2)
            Block[A].TriggerHit = index_1;

        if(Block[A].TriggerDeath == index_1)
            Block[A].TriggerDeath = index_2;
        else if(Block[A].TriggerDeath == index_2)
            Block[A].TriggerDeath = index_1;

        if(Block[A].TriggerLast == index_1)
            Block[A].TriggerLast = index_2;
        else if(Block[A].TriggerLast == index_2)
            Block[A].TriggerLast = index_1;
    }

    for(A = 1; A <= numWarps; A++)
    {
        if(Warp[A].eventEnter == index_1)
            Warp[A].eventEnter = index_2;
        else if(Warp[A].eventEnter == index_2)
            Warp[A].eventEnter = index_1;

        if(Warp[A].eventExit == index_1)
            Warp[A].eventExit= index_2;
        else if(Warp[A].eventExit == index_2)
            Warp[A].eventExit = index_1;
    }

    for(A = 0; A < numEvents; A++)
    {
        if(Events[A].TriggerEvent == index_1)
            Events[A].TriggerEvent = index_2;
        else if(Events[A].TriggerEvent == index_2)
            Events[A].TriggerEvent = index_1;
    }

    return true;
}

bool RenameEvent(eventindex_t index, const std::string& NewName)
{
    if(index == EVENT_NONE || NewName.empty())
        return false;

    Events[index].Name = NewName;

    return true;
}

bool DeleteEvent(eventindex_t index)
{
    if(index == EVENT_NONE)
        return false;

    int A = 0;

    for(A = 1; A <= numNPCs; A++)
    {
        if(NPC[A].TriggerTalk == index)
            NPC[A].TriggerTalk = EVENT_NONE;

        if(NPC[A].TriggerDeath == index)
            NPC[A].TriggerDeath = EVENT_NONE;

        if(NPC[A].TriggerLast == index)
            NPC[A].TriggerLast = EVENT_NONE;

        if(NPC[A].TriggerActivate == index)
            NPC[A].TriggerActivate = EVENT_NONE;
    }

    for(A = 1; A <= numBlock; A++)
    {
        if(Block[A].TriggerHit == index)
            Block[A].TriggerHit = EVENT_NONE;

        if(Block[A].TriggerDeath == index)
            Block[A].TriggerDeath = EVENT_NONE;

        if(Block[A].TriggerLast == index)
            Block[A].TriggerLast = EVENT_NONE;
    }

    for(A = 1; A <= numWarps; A++)
    {
        if(Warp[A].eventEnter == index)
            Warp[A].eventEnter = EVENT_NONE;

        if(Warp[A].eventExit == index)
            Warp[A].eventExit = EVENT_NONE;
    }

    for(A = 0; A < numEvents; A++)
    {
        if(Events[A].TriggerEvent == index)
            Events[A].TriggerEvent = EVENT_NONE;
    }

    for(int B = index; B < numEvents - 1; B++)
        SwapEvents(B, B+1);

    numEvents--;
    Events[numEvents].reinit();

    return true;
}


// Helper functions for ProcEvent

// tests which players are in a resized section, and warps other onscreen players to the section if do_warp is enabled
static inline void s_testPlayersInSection(const Screen_t& screen, int B, bool do_warp, int& onscreen_plr, int& warped_plr)
{
    // warp EVERYONE in cloned player mode, otherwise just warp players of this screen
    int i_start = g_ClonedPlayerMode ? 1 : 0;
    int i_end   = g_ClonedPlayerMode ? numPlayers + 1 : screen.player_count;
    for(int i = i_start; i < i_end; i++)
    {
        int C = g_ClonedPlayerMode ? i : screen.players[i];

        // If .Section = B Then
        // Should set this only if the warp is successful!
        if(do_warp && !g_config.modern_section_change)
            Player[C].Section = B;

        bool tempBool = false;
        if(Player[C].Location.X + Player[C].Location.Width >= level[B].X)
        {
            if(Player[C].Location.X <= level[B].Width)
            {
                if(Player[C].Location.Y + Player[C].Location.Height >= level[B].Y)
                {
                    if(Player[C].Location.Y <= level[B].Height)
                    {
                        tempBool = true; // Check to see if player is still in section after resizing
                        onscreen_plr = C;

                        if(do_warp)
                            Player[C].Section = B;
                    }
                }
            }
        }

        // don't warp on reset
        if(!do_warp)
            continue;

        if(!tempBool)
        {
            for(int D = 1; D <= numPlayers; D++)
            {
                if(D != C && Player[D].Section == B)
                {
                    if(Player[D].Location.X + Player[D].Location.Width >= level[B].X)
                    {
                        if(Player[D].Location.X <= level[B].Width)
                        {
                            if(Player[D].Location.Y + Player[D].Location.Height >= level[B].Y)
                            {
                                if(Player[D].Location.Y <= level[B].Height) // Move to another player who is still in the section
                                {
                                    warped_plr = C;

                                    Player[C].Section = B;
                                    Player[C].Location.X = Player[D].Location.X + (Player[D].Location.Width - Player[C].Location.Width) / 2;
                                    Player[C].Location.Y = Player[D].Location.Y + Player[D].Location.Height - Player[C].Location.Height;
                                    Player[C].Effect = PLREFF_NO_COLLIDE;
                                    Player[C].Effect2 = D;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
        // End If
    }
}

// initializes modern qScreen for section B, and returns true if any of the screen's vScreens got qScreen enabled
static inline bool s_initModernQScreen(Screen_t& screen, const int B, const SpeedlessLocation_t& tempLevel, const SpeedlessLocation_t& newLevel, const int onscreen_plr, const int warped_plr, const bool is_reset)
{
    bool set_qScreen = false;

    // check that the onscreen player is here
    if(onscreen_plr == 0 && warped_plr == 0)
    {
        // no qScreen because there were no onscreen players, but do an update in case another Screen called qScreen
        for(int i = screen.active_begin(); i < screen.active_end(); i++)
        {
            int Z_i = screen.vScreen_refs[i];
            GetvScreenAuto(vScreen[Z_i]);
            qScreenLoc[Z_i] = vScreen[Z_i];
        }
    }
    // 2P dynamic screen handling
    else if(screen.Type == ScreenTypes::Dynamic)
    {
        int Z1 = screen.vScreen_refs[0];
        int Z2 = screen.vScreen_refs[1];

        int p1 = screen.players[0];
        int p2 = screen.players[1];

        set_qScreen = true;

        bool screen2_was_visible = vScreen[Z2].Visible;

        int32_t tX = 0;
        int32_t tY = 0;

        if(warped_plr == p1 || warped_plr == p2)
        {
            int warped_Z = (warped_plr == p1) ? Z1 : Z2;
            int onscreen_Z = (onscreen_plr == p1) ? Z1 : Z2;
            tX = (int)vScreen[warped_Z].X - (int)vScreen[onscreen_Z].X;
            tY = (int)vScreen[warped_Z].Y - (int)vScreen[onscreen_Z].Y;
        }

        SoundPause[SFX_Camera] = 10;

        // need two cycles to fully update the dynamic screens in the new level
        SetupScreens(screen, false);
        DynamicScreen(screen);
        CenterScreens(screen);

        if(vScreen[Z2].Visible)
        {
            for(int Z = 1; Z <= 2; Z++)
                GetvScreen(screen.vScreen(Z));
        }
        else
            GetvScreenAverage(vScreen[Z1]);

        // set up the dynamic screens in the new level
        SetupScreens(screen, false);
        DynamicScreen(screen);

        // set the positions (including screen positions) in the old level, but with the NEW dynamic splits
        level[B] = tempLevel;
        CenterScreens(screen);

        if(vScreen[Z2].Visible)
        {
            for(int Z = 1; Z <= 2; Z++)
                GetvScreen(screen.vScreen(Z));
        }
        else
        {
            GetvScreenAverage(vScreen[Z1]);
        }

        // set the qScreen!
        qScreenLoc[Z1] = vScreen[Z1];

        // set the second qScreen if possible
        if(vScreen[Z2].Visible)
            qScreenLoc[Z2] = vScreen[Z2];

        // special code to indicate the direction the other player was warped from
        if((tX || tY) && (screen2_was_visible && !vScreen[Z2].Visible))
        {
            // total distance of warp
            int xSq = tX * tX;
            int ySq = tY * tY;
            int dSquare = xSq + ySq;

            // project onto the circle: proportion of distance from each axis
            if(tX < 0)
                xSq *= -1;

            if(tY < 0)
                ySq *= -1;

            // maximum total shift of 1/4 of the vScreen's size; also limit by 200x150 (SMBX64 amount)
            int maxShiftX = vScreen[Z1].Width / 4;
            int maxShiftY = vScreen[Z1].Height / 4;

            if(maxShiftX > 200)
                maxShiftX = 200;

            if(maxShiftY > 150)
                maxShiftY = 150;

            // apply the shift
            qScreenLoc[Z1].X += maxShiftX * xSq / dSquare;
            qScreenLoc[Z1].Y += maxShiftY * ySq / dSquare;

            // restrict to old level bounds
            if(-qScreenLoc[Z1].X < level[B].X)
                qScreenLoc[Z1].X = -level[B].X;

            if(-qScreenLoc[Z1].X + vScreen[Z1].Width > level[B].Width)
                qScreenLoc[Z1].X = -(level[B].Width - vScreen[Z1].Width);

            if(-qScreenLoc[Z1].Y < level[B].Y)
                qScreenLoc[Z1].Y = -level[B].Y;

            if(-qScreenLoc[Z1].Y + vScreen[Z1].Height > level[B].Height)
                qScreenLoc[Z1].Y = -(level[B].Height - vScreen[Z1].Height);
        }

        // restore the new level
        level[B] = newLevel;
    }
    // single-screen or forced split-screen code
    else
    {
        // first, quickly store the old vScreens into qScreen
        for(int i = screen.active_begin(); i < screen.active_end(); i++)
        {
            int Z_i = screen.vScreen_refs[i];

            // update qScreenLoc only if qScreen was not already set (avoids jumps)
            if(screen.Visible && !qScreen)
                qScreenLoc[Z_i] = vScreen[Z_i];

            if(!screen.Visible && screen.is_canonical() && !qScreen_canonical)
                qScreenLoc[Z_i] = vScreen[Z_i];
        }

        // now, update the screen positions here before proceeding
        SetupScreens(screen, false);
        CenterScreens(screen);

        for(int i = screen.active_begin(); i < screen.active_end(); i++)
        {
            int Z_i = screen.vScreen_refs[i];
            Player_t& plr = Player[vScreen[Z_i].player];

            // update vScreen position
            GetvScreenAuto(vScreen[Z_i]);

            // the next code is designed to avoid needing a qScreen if it wouldn't have occurred in the original game
            bool use_new_resize = true;

            int old_w = qScreenLoc[Z_i].Width;
            int old_h = qScreenLoc[Z_i].Height;
            num_t old_x = qScreenLoc[Z_i].X;
            num_t old_y = qScreenLoc[Z_i].Y;

            // (0) player should not have warped
            if(plr.Effect == PLREFF_NO_COLLIDE)
                use_new_resize = false;

            // (1) old bounds shouldn't be outside of the new level
            if(-old_x < level[B].X
                || -old_x + old_w > level[B].Width
                || -old_y < level[B].Y
                || -old_y + old_h > level[B].Height)
            {
                use_new_resize = false;
            }

            // (2) new screen size should equal old (get new vScreen here)
            if(vScreen[Z_i].Width != old_w || vScreen[Z_i].Height != old_h)
                use_new_resize = false;

            // (3) qScreen should not have occurred in old game
            if(use_new_resize && !is_reset)
            {
                num_t cx, cy, old_cx, old_cy;

                GetPlayerScreen(800, 600, plr, cx, cy);

                level[B] = tempLevel;
                GetPlayerScreen(800, 600, plr, old_cx, old_cy);
                level[B] = newLevel;

                if(num_t::abs(cx - old_cx) > 32 || num_t::abs(cy - old_cy) > 32)
                    use_new_resize = false;
            }

            // do it!
            if(use_new_resize)
            {
                qScreenLoc[Z_i] = vScreen[Z_i];
                vScreen[Z_i].tempX = vScreen[Z_i].X - old_x;
                vScreen[Z_i].TempY = vScreen[Z_i].Y - old_y;
            }
            else
            {
                // limit qScreen duration if player was warped
                if(plr.Effect == PLREFF_NO_COLLIDE)
                {
                    Location_t old_section_loc = newLoc(tempLevel.X, tempLevel.Y, tempLevel.Width - tempLevel.X, tempLevel.Height - tempLevel.Y);
                    Location_t qScreen_loc = newLoc(-qScreenLoc[Z_i].X, -qScreenLoc[Z_i].Y, qScreenLoc[Z_i].Width, qScreenLoc[Z_i].Height);

                    // disable qScreen if cross-section
                    if(!CheckCollision(old_section_loc, qScreen_loc))
                    {
                        qScreenLoc[Z_i] = vScreen[Z_i];
                    }
                    // otherwise, limit distance
                    else
                    {
                        num_t distance = num_t::dist(vScreen[Z_i].X - qScreenLoc[Z_i].X, vScreen[Z_i].Y - qScreenLoc[Z_i].Y);

                        if(distance > 400)
                        {
                            qScreenLoc[Z_i].X = ((qScreenLoc[Z_i].X - vScreen[Z_i].X) * 400).divided_by(distance) + vScreen[Z_i].X;
                            qScreenLoc[Z_i].Y = ((qScreenLoc[Z_i].Y - vScreen[Z_i].Y) * 400).divided_by(distance) + vScreen[Z_i].Y;
                        }
                    }
                }

                set_qScreen = true;
            }
        }
    }

    return set_qScreen;
}

// initializes legacy qScreen for section B, and returns true in all cases
static inline bool s_initLegacyQScreen(Screen_t& screen, const int B, const SpeedlessLocation_t& tempLevel, const SpeedlessLocation_t& newLevel, const int onscreen_plr)
{
    int Z1 = screen.vScreen_refs[0];
    int Z2 = screen.vScreen_refs[1];

    int p1 = screen.players[0];
    int p2 = screen.players[1];

    if(screen.player_count == 2 && screen.DType != 5)
    {
        level[B] = tempLevel;

        // faithful to original code which used vScreen[C], where C could be 0
        vScreen_t screenLoc = vScreen[0];
        if(p2 == onscreen_plr)
            screenLoc = vScreen[Z2];
        else if(p1 == onscreen_plr)
            screenLoc = vScreen[Z1];

        SoundPause[SFX_Camera] = 10;

        DynamicScreen(screen);

        // calculate the vScreen at non-splitscreen resolution (as the original game does)
        GetvScreenAverage(vScreen[Z1]);
        qScreenLoc[Z1] = vScreen[Z1];

        // pan to indicate warped player, in the direction the screen was previously split
        //   (used hardcoded 400 / 200 / 300 / 150 in VB6 code)
        if(int(screenLoc.Width) == screen.W / 2)
        {
            if(qScreenLoc[Z1].X < screenLoc.X + screenLoc.Left)
                qScreenLoc[Z1].X += screen.W / 4;
            else
                qScreenLoc[Z1].X -= screen.W / 4;
        }

        if(int(screenLoc.Height) == screen.H / 2)
        {
            if(qScreenLoc[Z1].Y < screenLoc.Y + screenLoc.Top)
                qScreenLoc[Z1].Y += screen.H / 4;
            else
                qScreenLoc[Z1].Y -= screen.H / 4;
        }

        // used ScreenW / H and FrmMain.ScaleWidth / Height in VB6 code
        num_t use_width  = SDL_min(static_cast<num_t>(screen.W), level[B].Width  - level[B].X);
        num_t use_height = SDL_min(static_cast<num_t>(screen.H), level[B].Height - level[B].Y);

        // restrict to old level bounds
        if(-qScreenLoc[Z1].X < level[B].X)
            qScreenLoc[Z1].X = -level[B].X;

        if(-qScreenLoc[Z1].X + use_width /*FrmMain.ScaleWidth*/ > level[B].Width)
            qScreenLoc[Z1].X = -(level[B].Width - use_width);

        if(-qScreenLoc[Z1].Y < level[B].Y)
            qScreenLoc[Z1].Y = -level[B].Y;

        if(-qScreenLoc[Z1].Y + use_height /*FrmMain.ScaleHeight*/ > level[B].Height)
            qScreenLoc[Z1].Y = -(level[B].Height - use_height);

        // restore the new level
        level[B] = newLevel;
    }
    else
    {
        qScreenLoc[Z1] = vScreen[Z1];
    }

    return true;
}

// Old functions:

eventindex_t ProcEvent_Safe(bool is_resume, eventindex_t index, int whichPlayer, EventContext context)
{
    if(index == EVENT_NONE || LevelEditor)
        return EVENT_NONE;

    // this is for events that have just been triggered
    int B = 0;
    // int C = 0;
    // int D = 0;
    // bool tempBool = false;
    SpeedlessLocation_t tempLevel;
    SpeedlessLocation_t newLevel;

    // Ignore vanilla autoscroll if newer way has been used
    bool autoScrollerChanged = false;

    auto &evt = Events[index];

    if(is_resume)
        goto event_resume;

    recentlyTriggeredEvents.insert(index);

    if(g_config.speedrun_stop_timer_by == Config_t::SPEEDRUN_STOP_EVENT && equalCase(evt.Name.c_str(), g_config.speedrun_stop_timer_at))
        speedRun_bossDeadEvent();

    for(B = 0; B < numSections; B++)
    {
        /* Music change */
        auto &s = evt.section[B];

        bool musicChanged = false;
        if(s.music_id == EventSection_t::LESet_ResetDefault)
        {
            bgMusic[B] = bgMusicREAL[B];
            musicChanged = true;
        }
        else if(s.music_id != EventSection_t::LESet_Nothing)
        {
            bgMusic[B] = s.music_id;
            musicChanged = true;
        }

        if(musicChanged)
            StartMusicIfOnscreen(B);

        /* Background change */
        if(s.background_id == EventSection_t::LESet_ResetDefault)
            Background2[B] = Background2REAL[B];
        else if(s.background_id != EventSection_t::LESet_Nothing)
            Background2[B] = s.background_id;

        /* Per-Section autoscroll setup */
        if(s.autoscroll)
        {
            if(!AutoUseModern) // First attemt to use modern autoscrolling will block futher use of the legacy autoscrolling
                AutoUseModern = true;
            autoScrollerChanged = true;
            AutoX[B] = s.autoscroll_x;
            AutoY[B] = s.autoscroll_y;
        }

        bool is_reset = (s.position.X == EventSection_t::LESet_ResetDefault);

        /* Resize the section boundaries */
        if(is_reset && !g_config.modern_section_change)
        {
            level[B] = static_cast<SpeedlessLocation_t>(LevelREAL[B]);
            UpdateSectionOverlaps(B);
        }
        else if(s.position.X != EventSection_t::LESet_Nothing)
        {
            tempLevel = level[B];
            newLevel = static_cast<SpeedlessLocation_t>((is_reset) ? LevelREAL[B] : s.position);
            level[B] = newLevel;
            UpdateSectionOverlaps(B);

            // track these across all screens
            bool set_qScreen = false;
            bool set_qScreen_canonical = false;

            for(int screen_i = 0; screen_i < c_screenCount; screen_i++)
            {
                Screen_t& screen = Screens[screen_i];

                if(!screen.is_active())
                    continue;

                // which player on this screen is already in the new section? (used for 2P dynamic)
                int onscreen_plr = 0;
                // which player on this screen was moved to the new section? (used for 2P dynamic)
                int warped_plr = 0;

                // warp other players to resized section, if not a reset or level start
                bool do_warp = !is_reset && (index != EVENT_LEVEL_START);
                // modern/classic logic: don't warp if it's the auto-run event loop
                if(g_config.modern_section_change)
                    do_warp &= (context != EventContext::InitSetup);
                // vanilla logic: don't warp on any Autostart event (even if it isn't the first frame of the level)
                else
                    do_warp &= !evt.AutoStart;

                s_testPlayersInSection(screen, B, do_warp, onscreen_plr, warped_plr);

                bool set_qScreen_i = false;

                // modern/classic: don't start any qScreen during initial setup frame
                if(g_config.modern_section_change && context == EventContext::InitSetup)
                {
                    // do nothing
                }
                // don't start any qScreen for "Level - Start" event, on any frame (vanilla logic)
                else if(index == EVENT_LEVEL_START)
                {
                    // do nothing
                }
                // start the modern qScreen animation
                else if(g_config.modern_section_change)
                    set_qScreen_i = s_initModernQScreen(screen, B, tempLevel, newLevel, onscreen_plr, warped_plr, is_reset);
                // legacy qScreen animation
                else
                    set_qScreen_i = s_initLegacyQScreen(screen, B, tempLevel, newLevel, onscreen_plr);

                if(set_qScreen_i)
                {
                    set_qScreen |= screen.Visible;
                    set_qScreen_canonical |= !screen.Visible && screen.is_canonical();
                }
            }

            // enable qScreen (now after all logic to prevent messing up GetvScreen calls)
            qScreen |= set_qScreen;
            qScreen_canonical |= set_qScreen_canonical;

            resetFrameTimer();
        }
    }

    for(auto &l : evt.HideLayer)
        HideLayer(l, (context != EventContext::Normal) ? (true) : evt.LayerSmoke);

    for(auto &l : evt.ShowLayer)
        ShowLayer(l, (context != EventContext::Normal) ? (true) : evt.LayerSmoke);

    for(auto &l : evt.ToggleLayer)
    {
        if(Layer[l].Hidden)
            ShowLayer(l, evt.LayerSmoke);
        else
            HideLayer(l, evt.LayerSmoke);
    }

    if(evt.MoveLayer != LAYER_NONE)
    {
        B = evt.MoveLayer;

        SetLayerSpeed(B, (num_t)evt.SpeedX, (num_t)evt.SpeedY, true);

        if(Layer[B].SpeedX == 0 && Layer[B].SpeedY == 0)
        {
            // join the layer back to the main spatial lookup tables if it doesn't start moving again for 255 frames (this can be tuned, 255 is the maximum possible for this uint8_t variable)
            Layer[B].join_timer = 255;
        }
        else
        {
            // these thresholds can be tweaked, but they balance the expense of querying more tables with the expense of updating locations in the main table
            if(Layer[B].blocks.size() > 2)
                treeBlockSplitLayer(B);

            if(Layer[B].BGOs.size() > 2)
                treeBackgroundSplitLayer(B);

            if(Layer[B].waters.size() > 2)
                treeWaterSplitLayer(B);
        }
    }

    if(!AutoUseModern) // Use legacy auto-scrolling when modern autoscrolling was never used here
    {
        if(g_config.fix_autoscroll_speed)
        {
            if(!autoScrollerChanged)
            {
                // Do set the autoscrool when non-zero values only, don't zero by other autoruns
                if((evt.AutoX != 0 || evt.AutoY != 0) && IF_INRANGE(evt.AutoSection, 0, maxSections))
                {
                    AutoX[evt.AutoSection] = evt.AutoX;
                    AutoY[evt.AutoSection] = evt.AutoY;
                }
            }
        }
        else if(IF_INRANGE(evt.AutoSection, 0, SDL_min(maxSections, maxEvents)))
        {
            // Buggy behavior, see https://github.com/Wohlstand/TheXTech/issues/44
            AutoX[evt.AutoSection] = Events[evt.AutoSection].AutoX;
            AutoY[evt.AutoSection] = Events[evt.AutoSection].AutoY;
        }
    }

    if(evt.Text != STRINGINDEX_NONE)
    {
        MessageText = GetS(evt.Text);

        bool player_valid = whichPlayer >= 1 && whichPlayer <= numPlayers;
        int base_player = (numPlayers > 1) ? -1 : 1;
        preProcessMessage(MessageText, player_valid ? whichPlayer : base_player);

        bool use_player_pause = (player_valid && g_config.multiplayer_pause_controls);
        PauseInit(PauseCode::Message, use_player_pause ? whichPlayer : 0);

        // request resuming at the current index
        return index;
    }

event_resume:

    if(evt.Sound > 0)
    {
        if(SoundPause[evt.Sound] > 4)
            SoundPause[evt.Sound] = 0;
        PlaySound(evt.Sound);
    }

    if(evt.EndGame == 1)
    {
        for(B = 0; B < numSections; B++)
            bgMusic[B] = 0;
        StopMusic();
        speedRun_bossDeadEvent();
        LevelMacroCounter = 0;
        LevelMacro = LEVELMACRO_GAME_COMPLETE_EXIT;
    }

    ForcedControls = (evt.Controls.AltJump ||
                      evt.Controls.AltRun ||
                      evt.Controls.Down ||
                      evt.Controls.Drop ||
                      evt.Controls.Jump ||
                      evt.Controls.Left ||
                      evt.Controls.Right ||
                      evt.Controls.Run ||
                      evt.Controls.Start ||
                      evt.Controls.Up);

    ForcedControl = evt.Controls;

    // tempBool = false;
    if(evt.TriggerEvent != EVENT_NONE)
    {
        if(evt.TriggerDelay == 0)
        {
            // for(B = 0; B <= maxEvents; B++)
            // {
            //     if(Events[B].Name == evt.TriggerEvent)
            //     {
            //         if(Events[B].TriggerEvent == evt.Name)
            //             tempBool = true;
            //         break;
            //     }
            // }

            // here tempBool prevented any order-2 circles from occurring
            // if(!tempBool)
            if(Events[evt.TriggerEvent].TriggerEvent != index)
            {
                // this should receive tail-call optimization
                // possibly request resuming at the child index (or its child, etc)
                return ProcEvent_Safe(false, evt.TriggerEvent, whichPlayer, context);
            }
        }
        else if(newEventNum < maxEvents)
        {
            newEventNum++;
            NewEvent[newEventNum] = evt.TriggerEvent;
            // note: this should be rounded towards even, this is non-trivial to implement as integer logic even though all variables involved are integers
            // FIXME: simplify this -- add a new vb6round_div2 call
            newEventDelay[newEventNum] = num_t::vb6round(evt.TriggerDelay * 6.5_n);
            newEventPlayer[newEventNum] = static_cast<uint8_t>(whichPlayer);
        }
        else
        {
            // SMBX64 would have crashed here... eventually we should do a message box and crash to menu in vanilla mode.
            // probably best to make a single function handling this.
        }
    }

    return EVENT_NONE;
}

void ProcEvent(eventindex_t index, int whichPlayer, EventContext context)
{
    eventindex_t resume_event = ProcEvent_Safe(false, index, whichPlayer, context);

    while(resume_event != EVENT_NONE)
    {
        PauseGame(PauseCode::None, 0);
        resume_event = ProcEvent_Safe(true, resume_event, whichPlayer, context);
    }
}

void TriggerEvent(eventindex_t index, int whichPlayer)
{
    if(newEventNum >= maxEvents)
        return;

    newEventNum++;
    NewEvent[newEventNum] = index;
    newEventDelay[newEventNum] = -1;
    newEventPlayer[newEventNum] = static_cast<uint8_t>(whichPlayer);
}

bool UpdateEvents()
{
    // this is for events that have a delay to call other events
    // this sub also updates the screen position for autoscroll levels
    bool events_active = true;

    switch(g_gameLoopInterrupt.site)
    {
    case GameLoopInterrupt::UpdateEvents:
        goto resume;
    default:
        break;
    }

    if(FreezeNPCs)
        events_active = false;

    if(!GameMenu)
    {
        // possibly undesirable: doesn't advance event timer at all if any players are (for example) in doors or in holding pattern
        if(!AllPlayersNormal())
            events_active = false;
    }

    if(newEventNum > 0)
    {
        int newEventNum_old;
        newEventNum_old = newEventNum;

        int A;
        for(A = 1; A <= newEventNum_old; A++)
        {
            bool event_triggered;
            event_triggered = newEventDelay[A] < 0;

            // count down the event if the events are active
            if(newEventDelay[A] > 0 && events_active)
                newEventDelay[A]--;
            // trigger event if it's ready, or if the event was directly Triggered
            else if(events_active || event_triggered)
            {
                int prevEventNum;
                prevEventNum = newEventNum;
                eventindex_t resume_index;
                resume_index = ProcEvent_Safe(false, NewEvent[A], newEventPlayer[A]);
                while(resume_index != EVENT_NONE)
                {
                    g_gameLoopInterrupt.A = A;
                    g_gameLoopInterrupt.B = newEventNum_old;
                    g_gameLoopInterrupt.C = resume_index;
                    g_gameLoopInterrupt.D = prevEventNum;
                    g_gameLoopInterrupt.bool1 = events_active;

                    g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateEvents;
                    return true;

resume:
                    A = g_gameLoopInterrupt.A;
                    newEventNum_old = g_gameLoopInterrupt.B;
                    resume_index = g_gameLoopInterrupt.C;
                    prevEventNum = g_gameLoopInterrupt.D;
                    events_active = g_gameLoopInterrupt.bool1;

                    g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                    resume_index = ProcEvent_Safe(true, resume_index, newEventPlayer[A]);
                }

                event_triggered = newEventDelay[A] < 0;
                newEventDelay[A] = newEventDelay[newEventNum];
                newEventPlayer[A] = newEventPlayer[newEventNum];
                NewEvent[A] = NewEvent[newEventNum];
                newEventNum--;

                // if the event was triggered, countdown its successor event
                if(event_triggered && newEventNum == prevEventNum)
                    A--;
                else if(g_config.fix_event_swap_bug)
                {
                    // if A was not replaced by a new event, then we should check the event A was replaced by (instead of duplicating it!)
                    if(newEventNum < newEventNum_old)
                    {
                        if(newEventDelay[A] <= 0)
                            A--;
                        newEventNum_old--;
                    }
                }
            }
        }
    }

    if(!events_active)
        return false;

    for(int A = 0; A < numSections; A++)
    {
        if(AutoX[A] != 0 || AutoY[A] != 0)
        {
            level[A].X += (num_t)AutoX[A];
            level[A].Width += (num_t)AutoX[A];
            level[A].Y += (num_t)AutoY[A];
            level[A].Height += (num_t)AutoY[A];

            int cam_w = num_t::round(level[A].Width - level[A].X);
            int cam_h = num_t::round(level[A].Height - level[A].Y);

            // SMBX 1.3 forces 800x800 camera at end of autoscroll (vanilla bug)
            if(!AutoUseModern)
            {
                cam_w = 800;
                cam_h = 800;
            }

            if(level[A].Width > LevelREAL[A].Width)
            {
                level[A].Width = LevelREAL[A].Width;
                level[A].X = LevelREAL[A].Width - cam_w;
            }

            if(level[A].X < LevelREAL[A].X)
            {
                level[A].Width = LevelREAL[A].X + cam_w;
                level[A].X = LevelREAL[A].X;
            }

            if(level[A].Height > LevelREAL[A].Height)
            {
                level[A].Height = LevelREAL[A].Height;
                level[A].Y = LevelREAL[A].Height - cam_h;
            }

            if(level[A].Y < LevelREAL[A].Y)
            {
                level[A].Height = LevelREAL[A].Y + cam_h;
                level[A].Y = LevelREAL[A].Y;
            }

            UpdateSectionOverlaps(A);
        }
    }

    return false;
}

void CancelNewEvent(eventindex_t index)
{
    if(newEventNum <= 0)
        return; // Nothing to do

    for(int A = 1; A <= newEventNum; ++A)
    {
        if(index == NewEvent[A])
        {
            newEventDelay[A] = newEventDelay[newEventNum];
            NewEvent[A] = NewEvent[newEventNum];
            newEventPlayer[A] = newEventPlayer[newEventNum];
            newEventNum--;
            --A;
        }
    }
}

bool EventWasTriggered(eventindex_t index)
{
    return !recentlyTriggeredEvents.empty() &&
            recentlyTriggeredEvents.find(index) != recentlyTriggeredEvents.end();
}

void ClearTriggeredEvents()
{
    if(!recentlyTriggeredEvents.empty())
        recentlyTriggeredEvents.clear();
}

void UpdateLayers()
{
    // this is mainly for moving layers
    int A = 0;
    // int C = 0;

    bool FreezeLayers = false;

    if(!GameMenu)
    {
        // possibly undesirable: doesn't advance layer movement at all if any players are (for example) in doors or in holding pattern
        if(!AllPlayersNormal())
        {
            // moved this code into the loop over layers instead of repeating it per player
            // it has also been combined with the FreezeNPCs code since they did the same thing
            // in the original game

            // for(A = 0; A <= maxLayers; A++)
            // {
            //     if(Layer[A].Name != "" && (Layer[A].SpeedX != 0.f || Layer[A].SpeedY != 0.f) && Layer[A].EffectStop)
            //     {
            //         for(C = 1; C <= numBlock; C++)
            //         {
            //             if(Block[C].Layer == Layer[A].Name)
            //             {
            //                 Block[C].Location.SpeedX = 0;
            //                 Block[C].Location.SpeedY = 0;
            //             }
            //         }
            //     }
            // }
            FreezeLayers = true;
        }
    }

    // set invalidate rate
    g_drawBlocks_invalidate_rate = 0;
    g_drawBGOs_invalidate_rate = 0;

    for(A = 0; A < numLayers; A++)
    {
        Layer[A].ApplySpeedX = 0;
        Layer[A].ApplySpeedY = 0;

        // only consider non-empty, moving layers
        if(Layer[A].Name.empty() || (Layer[A].SpeedX == 0 && Layer[A].SpeedY == 0))
        {
            // join timer check for layers that were moving until recently
            if(Layer[A].join_timer && !FreezeNPCs && !FreezeLayers)
            {
                Layer[A].join_timer--;
                if(Layer[A].join_timer == 0)
                {
                    treeBlockJoinLayer(A);
                    treeBackgroundJoinLayer(A);
                    treeWaterJoinLayer(A);
                }
            }

            continue;
        }

        // the layer does not move
        if(FreezeNPCs || (FreezeLayers && Layer[A].EffectStop))
        {
            {
                // Block-stopping code from earlier. Now together with the compat BGO layer move code.
                for(int B : Layer[A].blocks)
                {
                    Block[B].Location.SpeedX = 0;
                    Block[B].Location.SpeedY = 0;

                    if(Block[B].Type >= BLKID_CONVEYOR_L_START && Block[B].Type <= BLKID_CONVEYOR_L_END)
                        Block[B].Location.SpeedX = -0.8_n;
                    else if(Block[B].Type >= BLKID_CONVEYOR_R_START && Block[B].Type <= BLKID_CONVEYOR_R_END)
                        Block[B].Location.SpeedX = 0.8_n;
                }

                if(g_config.enable_climb_bgo_layer_move)
                {
                    for(int B : Layer[A].NPCs)
                    {
                        if(NPC[B].Type == NPCID_ITEM_BURIED || NPC[B].Type == NPCID_HOMING_BALL_GEN || NPC[B]->IsAVine)
                        {
                            NPC[B].Location.SpeedX = 0;
                            NPC[B].Location.SpeedY = 0;
                        }
                    }
                }
            }
        }
        // the layer moves!
        else
        {
            // if(!(FreezeLayers && Layer[A].EffectStop))
            {
                // widen to full precision
                num_t SpeedX = (num_t)Layer[A].SpeedX;
                num_t SpeedY = (num_t)Layer[A].SpeedY;

                Layer[A].OffsetX += SpeedX;
                Layer[A].OffsetY += SpeedY;

                Layer[A].ApplySpeedX = Layer[A].SpeedX;
                Layer[A].ApplySpeedY = Layer[A].SpeedY;

                // no longer needed thanks to block quadtree, but used to reproduce some buggy behaviors
                // move the sort invalidation out of the loop over blocks
                if(!Layer[A].blocks.empty() && Layer[A].SpeedX != 0 && g_config.emulate_classic_block_order)
                {
                    if(BlocksSorted)
                        BlocksSorted = false;
                }

                if(!Layer[A].blocks.empty())
                {
                    if(num_t::abs(SpeedX) > g_drawBlocks_invalidate_rate)
                        g_drawBlocks_invalidate_rate = num_t::abs(SpeedX);
                    if(num_t::abs(SpeedY) > g_drawBlocks_invalidate_rate)
                        g_drawBlocks_invalidate_rate = num_t::abs(SpeedY);
                }

                if(!Layer[A].BGOs.empty())
                {
                    if(num_t::abs(SpeedX) > g_drawBGOs_invalidate_rate)
                        g_drawBGOs_invalidate_rate = num_t::abs(SpeedX);
                    if(num_t::abs(SpeedY) > g_drawBGOs_invalidate_rate)
                        g_drawBGOs_invalidate_rate = num_t::abs(SpeedY);
                }

                // is the layer currently included in the main block quadtree?
                bool inactive = !treeBlockLayerActive(A);

                for(int B : Layer[A].blocks)
                {
                    // if(Block[B].Layer == Layer[A].Name)
                    //{
                    Block[B].Location.X += SpeedX;
                    Block[B].Location.Y += SpeedY;
                    Block[B].Location.SpeedX = SpeedX;
                    Block[B].Location.SpeedY = SpeedY;

                    if(Block[B].Type >= BLKID_CONVEYOR_L_START && Block[B].Type <= BLKID_CONVEYOR_L_END)
                        Block[B].Location.SpeedX += -0.8_n;
                    else if(Block[B].Type >= BLKID_CONVEYOR_R_START && Block[B].Type <= BLKID_CONVEYOR_R_END)
                        Block[B].Location.SpeedX += 0.8_n;

                    if(inactive)
                        treeBlockUpdateLayer(A, B);
                    //}
                }

                // is the layer currently included in the main BGO quadtree?
                inactive = !treeBackgroundLayerActive(A);

                // int allBGOs = numBackground + numLocked;
                for(int B : Layer[A].BGOs)
                {
                    // if(Background[B].Layer == Layer[A].Name)
                    //{
                    Background[B].Location.X += SpeedX;
                    Background[B].Location.Y += SpeedY;

                    if(inactive)
                        treeBackgroundUpdateLayer(A, B);
                    //}
                }

                // is the layer currently included in the main water quadtree?
                inactive = !treeWaterLayerActive(A);

                for(int B : Layer[A].waters)
                {
                    // if(Water[B].Layer == Layer[A].Name)
                    //{
                    Water[B].Location.X += SpeedX;
                    Water[B].Location.Y += SpeedY;

                    if(inactive)
                        treeWaterUpdateLayer(A, B);
                    //}
                }

                for(int B : Layer[A].NPCs)
                {
                    // if(NPC[B].Layer == Layer[A].Name)
                    {
                        NPC[B].DefaultLocationX += SpeedX;
                        NPC[B].DefaultLocationY += SpeedY;

                        if(!NPC[B].Active || NPC[B].Generator || NPC[B].Effect != NPCEFF_NORMAL ||
                           NPC[B]->IsACoin || NPC[B].Type == NPCID_PLANT_S3 || NPC[B].Type == NPCID_STONE_S3 ||
                           NPC[B].Type == NPCID_BOTTOM_PLANT || NPC[B].Type == NPCID_SIDE_PLANT || NPC[B].Type == NPCID_FALL_BLOCK_RED ||
                           NPC[B].Type == NPCID_PLANT_S1 || NPC[B].Type == NPCID_BIG_PLANT || NPC[B]->IsAVine ||
                           NPC[B].Type == NPCID_CHECKPOINT || NPC[B].Type == NPCID_GOALTAPE || NPC[B].Type == NPCID_ITEM_BURIED ||
                           NPC[B].Type == NPCID_HOMING_BALL_GEN || NPC[B].Type == NPCID_LONG_PLANT_UP || NPC[B].Type == NPCID_LONG_PLANT_DOWN ||
                           NPC[B].Type == NPCID_FIRE_PLANT)
                        {
                            if(NPC[B].Type == NPCID_ITEM_BURIED || NPC[B].Type == NPCID_HOMING_BALL_GEN)
                            {
                                NPC[B].Location.SpeedX = SpeedX;
                                NPC[B].Location.SpeedY = SpeedY;
                            }
                            else if(NPC[B]->IsAVine)
                            {
                                NPC[B].Location.SpeedX = SpeedX;
                                NPC[B].Location.SpeedY = SpeedY;
                            }

                            if(!NPC[B].Active)
                            {
                                NPC[B].Location.X = NPC[B].DefaultLocationX;
                                NPC[B].Location.Y = NPC[B].DefaultLocationY;

                                // In SMBX 1.3, these assignments undone during the next call to UpdateNPCs.
                                // Add to NPCQueues::Unchecked to ensure that will happen still.
                                if(NPC[B].Type == NPCID_PLANT_S3 || NPC[B].Type == NPCID_BIG_PLANT || NPC[B].Type == NPCID_PLANT_S1 ||
                                   NPC[B].Type == NPCID_LONG_PLANT_UP || NPC[B].Type == NPCID_FIRE_PLANT)
                                {
                                    NPC[B].Location.Y += NPC[B]->THeight;
                                    NPCQueues::Unchecked.push_back(B);
                                }
                                else if(NPC[B].Type == NPCID_SIDE_PLANT && NPC[B].Direction == -1)
                                {
                                    NPC[B].Location.X += NPC[B]->TWidth;
                                    NPCQueues::Unchecked.push_back(B);
                                }
                            }
                            else
                            {
                                NPC[B].Location.X += SpeedX;
                                NPC[B].Location.Y += SpeedY;
                            }

                            if(NPC[B].Effect == NPCEFF_WARP)
                            {
                                // specialY/X store the NPC's destination position
                                // this previously changed Effect2
                                if(NPC[B].Effect3 == 1 || NPC[B].Effect3 == 3)
                                    NPC[B].SpecialY += SpeedY;
                                else
                                    NPC[B].SpecialX += SpeedX;
                            }

                            if(!NPC[B].Active)
                            {
                                // note: this is the "defective" version of SetLayerSpeed, which (in classic mode) only sets the speed, and does nothing else
                                if(NPC[B].AttLayer != LAYER_NONE && NPC[B].AttLayer != LAYER_DEFAULT)
                                    SetLayerSpeed(NPC[B].AttLayer, SpeedX, SpeedY, Layer[A].EffectStop, true);

                                // NOTE: this was the source of at least two bugs: (1) won't get reset later; (2) an undefined value of EffectStop will be used by NPC[B].AttLayer
                                // (1) should be fixed in SetLayerSpeed by checking for inactive NPCs with AttLayers and resetting their speeds
                                // (2) is fixed in modern mode, where SetLayerSpeed correctly updates EffectStop to match Layer[A]'s
                            }

                            treeNPCUpdate(B);
                        }
                    }
                }

                for(int B : Layer[A].warps)
                {
                    Warp[B].Entrance.X += SpeedX;
                    Warp[B].Entrance.Y += SpeedY;
                    Warp[B].Exit.X += SpeedX;
                    Warp[B].Exit.Y += SpeedY;
                }
            }
        }
    }
}



// the code for synchronizing the layers of objects

void syncLayersTrees_AllBlocks()
{
    // would be nice to use a non-deallocating version here
    treeLevelCleanBlockLayers();
    invalidateDrawBlocks();

    for(int layer = 0; layer < numLayers; layer++)
        Layer[layer].blocks.clear();

    for(int block = 1; block <= numBlock; block++)
    {
        int layer = Block[block].Layer;

        treeBlockAddLayer(layer, block);
        if(layer != LAYER_NONE)
            sorted_insert(Layer[layer].blocks, block);
    }
}

void syncLayersTrees_Block(int block)
{
    invalidateDrawBlocks();

    for(int layer = 0; layer < numLayers; layer++)
    {
        if(layer != Block[block].Layer)
        {
            sorted_erase(Layer[layer].blocks, block);
            treeBlockRemoveLayer(layer, block);
        }
    }

    int layer = Block[block].Layer;
    if(block <= numBlock)
    {
        treeBlockUpdateLayer(layer, block);
        if(layer != LAYER_NONE)
            sorted_insert(Layer[layer].blocks, block);
    }
    else
    {
        treeBlockRemoveLayer(layer, block);
        if(layer != LAYER_NONE)
        {
            sorted_erase(Layer[layer].blocks, block);
        }
    }
}

void syncLayersTrees_Block_SetHidden(int block) // set block hidden based on layer
{
    syncLayersTrees_Block(block);
    if(Block[block].Layer != LAYER_NONE)
        Block[block].Hidden = Layer[Block[block].Layer].Hidden;
}

void syncLayers_AllNPCs()
{
    NPCQueues::clear();

    for(int npc = 1; npc <= numNPCs; npc++)
        syncLayers_NPC(npc);
}

void syncLayers_NPC(int npc)
{
    for(int layer = 0; layer < numLayers; layer++)
    {
        if(npc <= numNPCs && NPC[npc].Layer == layer)
            Layer[layer].NPCs.insert(npc);
        else
            Layer[layer].NPCs.erase(npc);
    }

    NPCQueues::update(npc);

    SDL_assert_release(npc > 0);

    if(npc <= numNPCs)
        treeNPCUpdate(npc);
    else
        treeNPCRemove(npc);
}

void syncLayers_AllBGOs()
{
    treeLevelCleanBackgroundLayers();
    invalidateDrawBGOs();

    for(int layer = 0; layer < numLayers; layer++)
        Layer[layer].BGOs.clear();

    for(int bgo = 1; bgo <= numBackground + numLocked; bgo++)
    {
        int layer = Background[bgo].Layer;
        treeBackgroundAddLayer(layer, bgo);
        if(layer != LAYER_NONE)
            sorted_insert(Layer[layer].BGOs, bgo);
    }
}

void syncLayers_BGO(int bgo)
{
    invalidateDrawBGOs();

    for(int layer = 0; layer < numLayers; layer++)
    {
        if(layer != Background[bgo].Layer)
        {
            treeBackgroundRemoveLayer(layer, bgo);
            sorted_erase(Layer[layer].BGOs, bgo);
        }
    }

    int layer = Background[bgo].Layer;
    if(bgo <= numBackground + numLocked)
    {
        treeBackgroundUpdateLayer(layer, bgo);
        if(layer != LAYER_NONE)
            sorted_insert(Layer[layer].BGOs, bgo);
    }
    else
    {
        treeBackgroundRemoveLayer(layer, bgo);
        if(layer != LAYER_NONE)
            sorted_erase(Layer[layer].BGOs, bgo);
    }
}

void syncLayers_Warp(int warp)
{
    for(int layer = 0; layer < numLayers; layer++)
    {
        if(warp <= numWarps && Warp[warp].Layer == layer)
            sorted_insert(Layer[layer].warps, warp);
        else
            sorted_erase(Layer[layer].warps, warp);
    }
}

void syncLayers_Water(int water)
{
    for(int layer = 0; layer < numLayers; layer++)
    {
        if(layer != Water[water].Layer)
        {
            treeWaterRemoveLayer(layer, water);
            sorted_erase(Layer[layer].waters, water);
        }
    }

    int layer = Water[water].Layer;
    if(water <= numWater)
    {
        treeWaterUpdateLayer(layer, water);
        if(layer != LAYER_NONE)
            sorted_insert(Layer[layer].waters, water);
    }
    else
    {
        treeWaterRemoveLayer(layer, water);
        if(layer != LAYER_NONE)
            sorted_erase(Layer[layer].waters, water);
    }
}


================================================
FILE: src/layers.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LAYERS_H
#define LAYERS_H

#include <string>
#include <vector>
#include <set>
#include <cstdint>

#include "range_arr.hpp"
#include "location.h"
#include "global_constants.h"
#include "control_types.h"

// also defined in "globals.h"
extern const std::string g_emptyString;

enum class EventContext
{
    // proceed as usual
    Normal = 0,
    // don't show layer smoke
    NoEffect,
    CoinSwitch = NoEffect,
    // NoEffect, plus don't trigger player warp or screen pan (Modern/Classic mode)
    InitSetup,
};

//Public Type Layer
struct Layer_t
{
//    EffectStop As Boolean
    bool EffectStop = false;
//    Hidden As Boolean
    bool Hidden = false;
    // Index into SavedLayers array, plus 1. (Normally 0, indicating a non-saved layer.)
    uint8_t SavedLayer = 0;
    // NEW: time until layer rejoins the main table
    uint8_t join_timer = 0;
//    Name As String
    std::string Name;
//    SpeedX As Single
    numf_t SpeedX = 0;
//    SpeedY As Single
    numf_t SpeedY = 0;

// NEW: track the actual applied SpeedX and SpeedY during the last frame. Used for vines.
    numf_t ApplySpeedX = 0;
    numf_t ApplySpeedY = 0;

//End Type
// NEW: track the objects belonging to the layer
    std::vector<vbint_t> blocks;
    std::vector<vbint_t> BGOs;
    std::set<int> NPCs;
    std::vector<vbint_t> warps;
    std::vector<vbint_t> waters;
// NEW: track the layer offset so we don't need to update the block/BGO trees
    num_t OffsetX = 0;
    num_t OffsetY = 0;
};

struct EventSection_t
{
    enum SetActions
    {
        LESet_Nothing = -1,
        LESet_ResetDefault = -2,
    };

    //! Change section borders if not (-1 - do nothing, -2 set default, any other values - set X position of left section boundary)
    IntegerLocation_t position;

    //! Set new Background ID in this section (-1 - do nothing, -2 - reset to defaint, >=0 - set background ID)
    vbint_t background_id = LESet_Nothing;

    //! Set new Music ID in this section (-1 - do nothing, -2 - reset to defaint, >=0 - set music ID)
    vbint_t music_id = LESet_Nothing;
    //! Set new Custom Music File path
    stringindex_t music_file = STRINGINDEX_NONE;

    //! Do override current autoscroll
    bool  autoscroll = false;
    //! X speed of autoscrool
    numf_t autoscroll_x = 0;
    //! Y speed of autoscrool
    numf_t autoscroll_y = 0;
};


//Public Type Events
struct Events_t
{
    // never implemented by Redigit; we can add back in later
//    addSavedEvent As String
    // std::string addSavedEvent;
//    RemoveSavedEvent As String
    // std::string RemoveSavedEvent;
//    LayerSmoke As Boolean
    bool LayerSmoke = false;
//    Sound As Integer
    vbint_t Sound = 0;
//    Name As String
    std::string Name;
//    Text As String
    stringindex_t Text = STRINGINDEX_NONE;
//    HideLayer(0 To 20) As String
    std::vector<layerindex_t> HideLayer;
//    ShowLayer(0 To 20) As String
    std::vector<layerindex_t> ShowLayer;
//    ToggleLayer(0 To 20) As String
    std::vector<layerindex_t> ToggleLayer;
//    Music(0 To maxSections) As Integer
//    RangeArrI<int, 0, maxSections, 0> Music;
//    Background(0 To maxSections) As Integer
//    RangeArrI<int, 0, maxSections, 0> Background;
//    level(0 To maxSections) As Location
//    RangeArr<Location_t, 0, maxSections> level;
// EXTRA: Override per-section settings
    RangeArr<EventSection_t, 0, maxSections> section;
//    EndGame As Integer
    int EndGame = 0;
//    TriggerEvent As String
    eventindex_t TriggerEvent = EVENT_NONE;
//    TriggerDelay As Double
    vbint_t TriggerDelay = 0;
//    Controls As Controls
    Controls_t Controls;
//    MoveLayer As String
    layerindex_t MoveLayer = LAYER_NONE;
//    SpeedX As Single
    numf_t SpeedX = 0;
//    SpeedY As Single
    numf_t SpeedY = 0;
//    AutoX As Single
    numf_t AutoX = 0;
//    AutoY As Single
    numf_t AutoY = 0;
//    AutoSection As Integer
    int AutoSection = 0;
//    AutoStart As Boolean
    bool AutoStart = false;
//End Type

    // reinitialize in place
    void reinit()
    {
        this->~Events_t();
        new(this)Events_t();
    }
};

//Public Layer(0 To 100) As Layer
#ifdef LOW_MEM
const int maxLayers = 100; // 100
#else
const int maxLayers = 254; // 100
#endif

extern int numLayers;
extern RangeArr<Layer_t, 0, maxLayers> Layer;

//Public Events(0 To 100) As Events
#ifdef LOW_MEM
const int maxEvents = 100; // 100
#else
const int maxEvents = 254; // 100
#endif

extern int numEvents;
extern RangeArr<Events_t, 0, maxEvents> Events;

//Public NewEvent(1 To 100) As String
extern RangeArrI<eventindex_t, 1, maxEvents, EVENT_NONE> NewEvent;
//Public newEventDelay(1 To 100) As Integer
extern RangeArrI<vbint_t, 1, maxEvents, 0> newEventDelay;
//! NEW: which player originally triggered each queued event
extern RangeArrI<uint8_t, 1, maxEvents, 0> newEventPlayer;
//Public newEventNum As Integer
extern int newEventNum;


// utilities for layerindex_t and eventindex_t

#define LAYER_USED_P_SWITCH_TITLE "Used P Switch"

extern layerindex_t LAYER_USED_P_SWITCH;

inline const std::string& GetL(layerindex_t index)
{
    if(index == LAYER_NONE)
    {
        return g_emptyString;
    }
    return Layer[index].Name;
}
inline const std::string& GetE(eventindex_t index)
{
    if(index == EVENT_NONE)
    {
        return g_emptyString;
    }
    return Events[index].Name;
}

// right now these are only used by the editor,
// so they are done using a linear search.
// they should be updated to use a hash map if
// they will be heavily used by autocode
layerindex_t FindLayer(const std::string& LayerName);
eventindex_t FindEvent(const std::string& EventName);


// Functions for layers

// New functions:

// swaps two layers and updates all references to them
bool SwapLayers(layerindex_t index_1, layerindex_t index_2);
// renames a layer
bool RenameLayer(layerindex_t index, const std::string& NewName);
// deletes a layer (and, optionally, everything in it)
bool DeleteLayer(layerindex_t index, bool killall);

// sets the speed of a layer
// EffectStop controls whether the layer will stop when a player has abnormal status
// Defective means that SMBX 1.3 was initially missing all code other than setting the speed
void SetLayerSpeed(layerindex_t index, num_t SpeedX, num_t SpeedY, bool EffectStop = true, bool Defective = false);

// Old functions:

// Public Sub ShowLayer(LayerName As String, Optional NoEffect As Boolean = False) 'shows a layer
// shows a layer
void ShowLayer(layerindex_t index, bool NoEffect = false);
// Public Sub HideLayer(LayerName As String, Optional NoEffect As Boolean = False) 'hides a layer
// hides a layer
void HideLayer(layerindex_t index, bool NoEffect = false);
// Public Sub SetLayer(LayerName As String)
// (unused)
void SetLayer(layerindex_t index);
// Public Sub UpdateLayers()
void UpdateLayers();


// Functions for events

// New functions:

// initializes an event
void InitializeEvent(Events_t& event);
// swaps two events and updates all references to them
bool SwapEvents(eventindex_t index_1, eventindex_t index_2);
// renames an event
bool RenameEvent(eventindex_t index, const std::string& NewName);
// deletes an event
bool DeleteEvent(eventindex_t index);

// EXTRA: Cancel awaiting event trigger
void CancelNewEvent(eventindex_t index);
// EXTRA: Check was any event got triggered?
bool EventWasTriggered(eventindex_t index);
// EXTRA: Clear up the tracklist
void ClearTriggeredEvents();

// Old functions:

// Public Sub ProcEvent(EventName As String, Optional NoEffect As Boolean = False)
void ProcEvent(eventindex_t, bool) = delete; // old signature
void ProcEvent(eventindex_t, EventContext) = delete; // old signature
// NEW: added WhichPlayer, 0 by default, to indicate which player triggered the event
void ProcEvent(eventindex_t index, int WhichPlayer, EventContext context = EventContext::Normal);

// If this returns an eventindex other than EVENT_NONE, then a pause has been initiated for a message
// As soon as the pause ends, the call must be re-made with the same arguments, but with resume set to true and index set to the returned eventindex
// The caller must also support an interrupt and restore routine.
eventindex_t ProcEvent_Safe(bool resume, eventindex_t index, int WhichPlayer, EventContext context = EventContext::Normal);

// NEW: safe call that adds event to the end of the events queue for the current frame
void TriggerEvent(eventindex_t index, int WhichPlayer);

// Public Sub UpdateEvents()
bool UpdateEvents();


// functions to synchronize the layers of objects
// call these any time the layer of an object changes
void syncLayersTrees_AllBlocks();
void syncLayersTrees_Block(int block);
void syncLayersTrees_Block_SetHidden(int block); // set block hidden based on layer

void syncLayers_AllNPCs();
void syncLayers_NPC(int npc);

void syncLayers_AllBGOs();
void syncLayers_BGO(int bgo);

void syncLayers_Warp(int warp);

void syncLayers_Water(int water);

#endif // LAYERS_H


================================================
FILE: src/load_gfx.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_timer.h"
#include "sdl_proxy/sdl_assert.h"
#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_types.h"

#ifndef PGE_NO_THREADING
#include <SDL2/SDL_mutex.h>
#endif

#include "globals.h"
#include "global_dirs.h"

#include "blk_id.h"
#include "eff_id.h"

#include "gfx.h"
#include "load_gfx.h"
#include "graphics.h" // SuperPrint
#include "graphics/gfx_frame.h" // FrameBorderInfo, loadFrameInfo
#include "core/render.h"
#include "core/events.h"
#include "main/asset_pack.h"
#include "main/screen_asset_pack.h"
#include "main/game_strings.h"

#include <IniProcessor/ini_processing.h>
#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <Utils/dir_list_ci.h>
#include <Utils/strings.h>
#include <DirManager/dirman.h>
#ifdef THEXTECH_INTERPROC_SUPPORTED
#   include <InterProcess/intproc.h>
#endif
#include <fmt_format_ne.h>
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif

#if defined(PGE_MIN_PORT) || defined(THEXTECH_CLI_BUILD)
#   include <PGE_File_Formats/file_formats.h>
#endif

#include <set>

bool gfxLoaderTestMode = false;
bool gfxLoaderThreadingMode = false;
#ifndef PGE_NO_THREADING
static SDL_mutex *gfxLoaderDebugMutex = nullptr;
#endif
static std::string gfxLoaderDebugString;
static bool        gfxLoaderDebugStringUpdated = false;
static Sint64 gfxLoaderDebugStart = -1;
static const Sint64 c_gfxLoaderShowInterval = 500;

//// Private Sub cBlockGFX(A As Integer)
//void cBlockGFX(int A);
//// Private Sub cNPCGFX(A As Integer)
//void cNPCGFX(int A);
//// Private Sub cBackgroundGFX(A As Integer)
//void cBackgroundGFX(int A);
//// Private Sub cTileGFX(A As Integer)
//void cTileGFX(int A);
//// Private Sub cSceneGFX(A As Integer)
//void cSceneGFX(int A);
//// Private Sub cLevelGFX(A As Integer)
//void cLevelGFX(int A);
//// Private Sub cPathGFX(A As Integer)
//void cPathGFX(int A);

struct GFXBackup_t
{
    vbint_t *remote_width = nullptr;
    vbint_t *remote_height = nullptr;
    bool *remote_isCustom = nullptr;
    StdPicture *remote_texture = nullptr;
    vbint_t width = 0;
    vbint_t height = 0;
    bool isCustom = false;
    StdPicture_Sub texture_backup;
};

static std::vector<GFXBackup_t> g_defaultLevelGfxBackup;
static std::vector<GFXBackup_t> g_defaultWorldGfxBackup;

// track which backups are previews of player graphics
static size_t s_previewPlayersBegin = 0;
static size_t s_previewPlayersEnd = 0;

struct FrameBorderInfoBackup_t
{
    FrameBorderInfo *remote_info = nullptr;
    FrameBorderInfo info_backup;
};

static std::vector<FrameBorderInfoBackup_t> g_defaultBorderInfoBackup;

static DirListCI s_dirFallback;

static std::string getGfxDir()
{
    return AppPath + "graphics/";
}

static bool s_useLangDir = false;
static std::string s_langSubDir;
static bool s_useLangDirEp = false;
static std::string s_langSubDirEp;

static void cgfx_initLangDir()
{
    std::string langDir;
    s_useLangDir = false;
    s_langSubDir.clear();
    s_useLangDirEp = false;
    s_langSubDirEp.clear();

    if(!CurrentLanguage.empty())
    {
        if(!CurrentLangDialect.empty())
        {
            langDir = CurrentLanguage + "-" + CurrentLangDialect;
            // Data directory
            if(DirMan::exists(g_dirCustom.getCurDir() + "i18n/" + langDir))
                s_langSubDir = "i18n/" + langDir + "/";
            else if(DirMan::exists(g_dirCustom.getCurDir() + "i18n/" + CurrentLanguage))
                s_langSubDir = "i18n/" + CurrentLanguage + "/";

            // Episode directory
            if(DirMan::exists(g_dirEpisode.getCurDir() + "i18n/" + langDir))
                s_langSubDirEp = "i18n/" + langDir + "/";
            else if(DirMan::exists(g_dirEpisode.getCurDir() + "i18n/" + CurrentLanguage))
                s_langSubDirEp = "i18n/" + CurrentLanguage + "/";
        }
        else
        {
            // Data directory
            if(DirMan::exists(g_dirCustom.getCurDir() + "i18n/" + CurrentLanguage))
                s_langSubDir = "i18n/" + CurrentLanguage + "/";

            // Episode directory
            if(DirMan::exists(g_dirEpisode.getCurDir() + "i18n/" + CurrentLanguage))
                s_langSubDirEp = "i18n/" + CurrentLanguage + "/";
        }

        s_useLangDir = !s_langSubDir.empty();
        s_useLangDirEp = !s_langSubDirEp.empty();
    }
}

SDL_FORCE_INLINE bool s_resolveFile(const char **extList,
                                    const char *extGif,
                                    const std::string &fName,
                                    std::string &imgToUse,
                                    bool &isGif)
{
    const char **ext_p;
    const char *ext;

    if(s_useLangDir)
    {
        ext_p = extList;
        while((ext = *ext_p++) != nullptr)
        {
            imgToUse = g_dirCustom.resolveFileCaseExistsAbs(s_langSubDir + fName + ext);
            isGif = (ext == extGif);
            if(!imgToUse.empty())
                return true; // Found that we looked for
        }
    }

    ext_p = extList;
    while((ext = *ext_p++) != nullptr)
    {
        imgToUse = g_dirCustom.resolveFileCaseExistsAbs(fName + ext);
        isGif = (ext == extGif);
        if(!imgToUse.empty())
            return true; // Found that we looked for
    }

    if(s_useLangDirEp)
    {
        ext_p = extList;
        while((ext = *ext_p++) != nullptr)
        {
            imgToUse = g_dirEpisode.resolveFileCaseExistsAbs(s_langSubDirEp + fName + ext);
            isGif = (ext == extGif);
            if(!imgToUse.empty())
                return true; // Found that we looked for
        }
    }

    ext_p = extList;
    while((ext = *ext_p++) != nullptr)
    {
        imgToUse = g_dirEpisode.resolveFileCaseExistsAbs(fName + ext);
        isGif = (ext == extGif);
        if(!imgToUse.empty())
            return true; // Found that we looked for
    }

    return false; // Nothing was found
}

/*!
 * \brief Load the custom GFX sprite
 * \param subfolder Subfolder of graphics folder used
 * \param stem Filename stem for graphics
 * \param index Filename index for graphics -- if < 0, then filename won't include index
 * \param fName file name for custommization target
 * \param width Reference to width field (optional)
 * \param height Reference to height field (optional)
 * \param isCustom Reference to the "is custom" boolean
 * \param texture Target texture to load
 * \param world Is a world map
 * \param skipMask Don't even try to load a masked GIF sprite
 */
static void loadCGFX(const char* subfolder,
                     const char* stem,
                     int index,
                     vbint_t *width, vbint_t *height, bool* isCustom, StdPicture &texture,
                     bool world = false,
                     bool skipMask = false)
{
    std::string fName = (index < 0) ? stem : fmt::sprintf_ne("%s%d", stem, index);
    std::string origPath = fmt::sprintf_ne("%sgraphics/%s/%s.png", AppPath.c_str(), subfolder, fName.c_str());

    std::string loadedPath;
    bool success = false;
    StdPicture_Sub newTexture;

    GFXBackup_t backup;
    backup.remote_width = width;
    backup.remote_height = height;
    backup.remote_isCustom = isCustom;
    backup.remote_texture = &texture;
    if(width)
        backup.width = *width;
    if(height)
        backup.height = *height;
    if(isCustom)
        backup.isCustom = *isCustom;

    bool isGif = false;

#if defined(X_IMG_EXT) && !defined(X_NO_PNG_GIF)
    // look for the image file: ext in custom, png in custom, gif in custom, ext in episode, png in episode, gif in episode
    const char *extsList[] = {X_IMG_EXT, ".png", ".gif", nullptr};
    const char *extGif = extsList[2];
#elif defined(X_IMG_EXT)
    // look for the image file: ext in custom, ext in episode
    const char *extsList[] = {X_IMG_EXT, nullptr};
    const char *extGif = nullptr;
#else
    // look for the image file: png in custom, gif in custom, png in episode, gif in episode
    const char *extsList[] = {".png", ".gif", nullptr};
    const char *extGif = extsList[1];
#endif

    std::string imgToUse;

    if(!s_resolveFile(extsList, extGif, fName, imgToUse, isGif))
        return; // Nothing to do

    if(isGif && !skipMask)
    {
        // look for the mask file: custom, episode, fallback
        std::string maskToUse;

        if(s_useLangDir)
            maskToUse = g_dirCustom.resolveFileCaseExistsAbs(s_langSubDir + fName + "m.gif");

        if(maskToUse.empty())
            maskToUse = g_dirCustom.resolveFileCaseExistsAbs(fName + "m.gif");

        if(s_useLangDirEp && maskToUse.empty())
            maskToUse = g_dirEpisode.resolveFileCaseExistsAbs(s_langSubDirEp + fName + "m.gif");

        if(maskToUse.empty())
            maskToUse = g_dirEpisode.resolveFileCaseExistsAbs(fName + "m.gif");

        if(maskToUse.empty())
            maskToUse = s_dirFallback.resolveFileCaseExistsAbs(fName + "m.gif");

#ifdef DEBUG_BUILD
        pLogDebug("Trying to load custom GFX: %s with mask %s", imgToUse.c_str(), maskToUse.c_str());
#endif
        XRender::lazyLoadPicture(newTexture, imgToUse, maskToUse, origPath);
        success = newTexture.inited;
        loadedPath = imgToUse;
    }
    else
    {
#ifdef DEBUG_BUILD
        pLogDebug("Trying to load custom GFX: %s", imgToUse.c_str());
#endif
        XRender::lazyLoadPicture(newTexture, imgToUse);
        success = newTexture.inited;
        loadedPath = imgToUse;
    }

    if(success)
    {
        // don't keep state from old texture
        XRender::unloadTexture(texture);

        pLogDebug("Loaded custom GFX: %s", loadedPath.c_str());
        if(isCustom)
            *isCustom = true;

        backup.texture_backup = std::move(static_cast<StdPicture_Sub&>(texture));
        static_cast<StdPicture_Sub&>(texture) = std::move(newTexture);

        if(width)
            *width = newTexture.w;
        if(height)
            *height = newTexture.h;

        if(world)
            g_defaultWorldGfxBackup.push_back(std::move(backup));
        else
            g_defaultLevelGfxBackup.push_back(std::move(backup));
    }
}

/* load a single custom border */
static void loadCBorder(const char* stem,
    bool* isCustom,
    FrameBorder &border)
{
    loadCGFX("ui", stem, -1, nullptr, nullptr, isCustom, border.tex, false, true);

    std::string fName = fmt::sprintf_ne("%s.ini", stem);

    // find the frame border info
    std::string res;

    res = g_dirCustom.resolveFileCaseExistsAbs(fName);

    if(res.empty())
        res = g_dirEpisode.resolveFileCaseExistsAbs(fName);

    // attempt to load frame border info
    if(!res.empty())
    {
        // backup the frame border info
        FrameBorderInfoBackup_t bak;
        bak.remote_info = &border;
        bak.info_backup =  border;
        g_defaultBorderInfoBackup.push_back(bak);

        // load the frame border info
        IniProcessing ini = Files::load_ini(res);
        loadFrameInfo(ini, border);
    }

    // warn if invalid
    const FrameBorderInfo& i = border;
    if(i.le + i.li + i.ri + i.re > border.tex.w)
        pLogWarning("Invalid border: total internal/external width is %d but texture [%s.png] is only %dpx wide.", i.le + i.li + i.ri + i.re, stem, border.tex.w);
    if(i.te + i.ti + i.bi + i.be > border.tex.h)
        pLogWarning("Invalid border: total internal/external height is %d but texture [%s.png] is only %dpx tall.", i.te + i.ti + i.bi + i.be, stem, border.tex.h);
}

#if defined(PGE_MIN_PORT) || defined(THEXTECH_CLI_BUILD)
/*!
 * \brief Load the custom GFX from a load list
 * \param f The load list
 * \param dir The directory to which paths are relative
 * \param texture Target texture to modify
 * \param width Reference to width field (optional)
 * \param height Reference to height field (optional)
 * \param is_custom_ref Reference to the "is custom" boolean
 * \param world Is a world map
 * \param this_is_custom Is custom in the current load context
 */
static void loadImageFromList(PGE_FileFormats_misc::TextInput& t, std::string& line_buf, const std::string& dir,
                    StdPicture &texture,
                    vbint_t *width, vbint_t *height, bool *is_custom_loc,
                    bool world = false, bool this_is_custom = false)
{
    StdPicture_Sub newTexture;
    XRender::lazyLoadPictureFromList(newTexture, t, line_buf, dir);

    if(!newTexture.inited)
        return;

    if(this_is_custom)
    {
        GFXBackup_t backup;
        backup.remote_width = width;
        backup.remote_height = height;
        backup.remote_isCustom = is_custom_loc;
        backup.remote_texture = &texture;
        XRender::unloadTexture(texture);
        if(width)
            backup.width = *width;
        if(height)
            backup.height = *height;
        if(is_custom_loc)
            backup.isCustom = *is_custom_loc;
        backup.texture_backup = static_cast<StdPicture_Sub&>(texture);

        if(world)
            g_defaultWorldGfxBackup.push_back(backup);
        else
            g_defaultLevelGfxBackup.push_back(backup);
    }

    if(this_is_custom && is_custom_loc)
    {
        // pLogDebug("Loaded custom GFX: %s", newTexture.l.path.c_str());
        *is_custom_loc = true;
    }

    static_cast<StdPicture_Sub&>(texture) = newTexture;
    if(width)
        *width = newTexture.w;
    if(height)
        *height = newTexture.h;
}

bool LoadGFXFromList(std::string source_dir, bool custom, bool skip_world)
{
    std::string path = source_dir + "graphics.list";

    SDL_RWops* f = Files::open_file(path, "rb");

    if(!f)
        return false;

    PGE_FileFormats_misc::RWopsTextInput in(f, path);
    std::string line_buf;

    char type_buf[12];
    int A;

    bool failed = false;

    while(true)
    {
        // advance the file to the next entry
        if(failed)
        {
            do
            {
                in.readLine(line_buf);
            } while(!line_buf.empty());

            if(in.eof())
            {
                pLogWarning("No more entries after failure");
                break;
            }
        }

        in.readLine(line_buf);
        if(line_buf.empty() && !in.eof())
            continue;

        failed = true;

        // read the entry!
        SDL_memset(type_buf, 0, sizeof(type_buf));
        int pos;
        if(sscanf(line_buf.c_str(), "%11s %d%n", type_buf, &A, &pos) != 2 || pos != (int)line_buf.size())
        {
            if(in.eof())
                break;
            else
            {
                pLogDebug("Failed to read entry header of the load list");
                continue;
            }
        }


        // load the entry
        if(type_buf[10] == '2')
        {
            if(A > numBackground2)
            {
                pLogWarning("Received load request for invalid bg2 %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXBackground2BMP[A], nullptr, nullptr, nullptr,
                false, custom);
        }
        else if(type_buf[9] == 'd')
        {
            if(A > maxBackgroundType)
            {
                pLogWarning("Received load request for invalid background %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXBackgroundBMP[A], nullptr, nullptr, nullptr,
                false, custom);

            if(!custom)
            {
                BackgroundWidth[A] = GFXBackground[A].w;
                BackgroundHeight[A] = GFXBackground[A].h;
            }
        }
        else if(type_buf[0] == 'b')
        {
            if(A > maxBlockType || A == BLKID_CONVEYOR_L_CONV || A == BLKID_CONVEYOR_R_CONV)
            {
                pLogWarning("Received load request for invalid block %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXBlockBMP[A], nullptr, nullptr, nullptr,
                false, custom);
        }
        else if(type_buf[0] == 'n')
        {
            if(A > maxNPCType)
            {
                pLogWarning("Received load request for invalid NPC %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXNPCBMP[A], nullptr, nullptr, nullptr,
                false, custom);

            // load converted conveyer block graphics from conveyer NPC graphics
            if(A == NPCID_CONVEYOR)
            {
                if(custom)
                {
                    for(int i = BLKID_CONVEYOR_L_CONV; i <= BLKID_CONVEYOR_R_CONV; i += BLKID_CONVEYOR_R_CONV - BLKID_CONVEYOR_L_CONV)
                    {
                        GFXBackup_t backup;
                        backup.remote_texture = &GFXBlockBMP[i];
                        XRender::unloadTexture(GFXBlockBMP[i]);
                        backup.texture_backup = static_cast<StdPicture_Sub&>(GFXBlockBMP[i]);
                        g_defaultLevelGfxBackup.push_back(backup);
                    }
                }

                (StdPicture_Sub&)GFXBlockBMP[BLKID_CONVEYOR_L_CONV] = (const StdPicture_Sub&)GFXNPCBMP[NPCID_CONVEYOR];
                (StdPicture_Sub&)GFXBlockBMP[BLKID_CONVEYOR_R_CONV] = (const StdPicture_Sub&)GFXNPCBMP[NPCID_CONVEYOR];
            }
        }
        else if(type_buf[0] == 'e')
        {
            if(A > maxEffectType)
            {
                pLogWarning("Received load request for invalid effect %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXEffectBMP[A], &EffectWidth[A], &EffectHeight[A], &GFXEffectCustom[A],
                false, custom);

            // update calculation (but still rely on backup made above)
            if(GFXEffectCustom[A])
                EffectHeight[A] = GFXEffectBMP[A].h / EffectDefaults.EffectFrames[A];
        }
        else if(type_buf[0] == 'y' && type_buf[5] == 't')
        {
            if(A > maxYoshiGfx)
            {
                pLogWarning("Received load request for invalid yoshitop %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXYoshiTBMP[A], nullptr, nullptr, nullptr,
                false, custom);
        }
        else if(type_buf[0] == 'y')
        {
            if(A > maxYoshiGfx)
            {
                pLogWarning("Received load request for invalid yoshib %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXYoshiBBMP[A], nullptr, nullptr, nullptr,
                false, custom);
        }
        else if(type_buf[0] == 'l' && type_buf[1] == 'e')
        {
            if(skip_world)
                continue;

            if(A > maxLevelType)
            {
                pLogWarning("Received load request for invalid level %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXLevelBMP[A], nullptr, nullptr, nullptr,
                true, custom);
        }
        else if(type_buf[0] == 't' && type_buf[1] == 'i')
        {
            if(skip_world)
                continue;

            if(A > maxTileType)
            {
                pLogWarning("Received load request for invalid tile %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXTileBMP[A], nullptr, nullptr, nullptr,
                true, custom);
        }
        else if(type_buf[0] == 's')
        {
            if(skip_world)
                continue;

            if(A > maxSceneType)
            {
                pLogWarning("Received load request for invalid scene %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXSceneBMP[A], nullptr, nullptr, nullptr,
                true, custom);
        }
        else if(type_buf[0] == 'p' && type_buf[1] == 'l')
        {
            if(skip_world)
                continue;

            if(A > numCharacters)
            {
                pLogWarning("Received load request for invalid worldplayer %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXPlayerBMP[A], nullptr, nullptr, nullptr,
                true, custom);
        }
        else if(type_buf[0] == 'p' && type_buf[1] == 'a')
        {
            if(skip_world)
                continue;

            if(A > maxPathType)
            {
                pLogWarning("Received load request for invalid path %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                GFXPathBMP[A], nullptr, nullptr, nullptr,
                true, custom);
        }
        // character graphics
        else
        {
            int c;
            if(type_buf[0] == 'l' && type_buf[4] == '\0')
                c = 4;
            else if(type_buf[0] == 'l')
                c = 1;
            else if(type_buf[0] == 't')
                c = 3;
            else if(type_buf[0] == 'm')
                c = 0;
            else if(type_buf[0] == 'p')
                c = 2;
            else
            {
                pLogWarning("Received unrecognized load request category %s", type_buf);
                continue;
            }

            if(A > numStates)
            {
                pLogWarning("Received load request for invalid player state %s %d", type_buf, A);
                continue;
            }

            loadImageFromList(in, line_buf, source_dir,
                (*GFXCharacterBMP[c])[A], nullptr, nullptr, nullptr,
                false, custom);
        }

        failed = false;
    }

    return true;
}

#endif // #if defined(PGE_MIN_PORT) || defined(THEXTECH_CLI_BUILD)

static void s_UnloadPreviewPlayers()
{
    if(s_previewPlayersEnd == 0 || s_previewPlayersEnd == s_previewPlayersBegin)
    {
        s_previewPlayersBegin = 0;
        s_previewPlayersEnd = 0;
        return;
    }

    // check that no textures have been loaded since player preview
    SDL_assert_release(s_previewPlayersEnd == g_defaultLevelGfxBackup.size());

    for(auto it = g_defaultLevelGfxBackup.begin() + s_previewPlayersEnd;
        it > g_defaultLevelGfxBackup.begin() + s_previewPlayersBegin;
        )
    {
        --it;

        auto &t = *it;

        if(t.remote_width)
            *t.remote_width = t.width;
        if(t.remote_height)
            *t.remote_height = t.height;
        if(t.remote_isCustom)
            *t.remote_isCustom = t.isCustom;
        SDL_assert_release(t.remote_texture);
        XRender::unloadTexture(*t.remote_texture);
        *static_cast<StdPicture_Sub*>(t.remote_texture) = std::move(t.texture_backup);
    }

    g_defaultLevelGfxBackup.resize(s_previewPlayersBegin);

    s_previewPlayersBegin = 0;
    s_previewPlayersEnd = 0;

#ifndef LOW_MEM
    // Restore default sizes of custom player effects (should no longer be required, now that backups are made directly)
    for(int A = 1; A < maxEffectType; ++A)
    {
        if(GFXEffectCustom[A])
        {
            SDL_assert_release(EffectWidth[A] == GFXEffectBMP[A].w);
            SDL_assert_release(EffectHeight[A] == GFXEffectBMP[A].h / EffectDefaults.EffectFrames[A]);
        }
        else
        {
            SDL_assert_release(EffectWidth[A] == EffectDefaults.EffectWidth[A]);
            SDL_assert_release(EffectHeight[A] == EffectDefaults.EffectHeight[A]);
        }
    }
#endif // #ifndef LOW_MEM
}

static void restoreLevelBackupTextures()
{
    for(auto it = g_defaultLevelGfxBackup.rbegin(); it != g_defaultLevelGfxBackup.rend(); ++it)
    {
        auto &t = *it;

        if(t.remote_width)
            *t.remote_width = t.width;
        if(t.remote_height)
            *t.remote_height = t.height;
        if(t.remote_isCustom)
            *t.remote_isCustom = t.isCustom;
        SDL_assert_release(t.remote_texture);
        XRender::unloadTexture(*t.remote_texture);
        *static_cast<StdPicture_Sub*>(t.remote_texture) = std::move(t.texture_backup);
    }
    g_defaultLevelGfxBackup.clear();
    s_previewPlayersBegin = 0;
    s_previewPlayersEnd = 0;
}

static void restoreWorldBackupTextures()
{
    for(auto it = g_defaultWorldGfxBackup.rbegin(); it != g_defaultWorldGfxBackup.rend(); ++it)
    {
        auto &t = *it;

        if(t.remote_width)
            *t.remote_width = t.width;
        if(t.remote_height)
            *t.remote_height = t.height;
        if(t.remote_isCustom)
            *t.remote_isCustom = t.isCustom;
        SDL_assert_release(t.remote_texture);
        XRender::unloadTexture(*t.remote_texture);
        *static_cast<StdPicture_Sub*>(t.remote_texture) = std::move(t.texture_backup);
    }
    g_defaultWorldGfxBackup.clear();
}


static inline void s_find_image(std::string& dest, DirListCI& CurDir, std::string baseName)
{
#if defined(X_IMG_EXT) && !defined(X_NO_PNG_GIF)
    int s = baseName.size();
    baseName += X_IMG_EXT;
    dest = CurDir.resolveFileCaseExistsAbs(baseName);
    if(dest.empty())
    {
        baseName.resize(s);
        baseName += ".png";
        dest = CurDir.resolveFileCaseExistsAbs(baseName);
    }
#elif defined(X_IMG_EXT)
    baseName += X_IMG_EXT;
    dest = CurDir.resolveFileCaseExistsAbs(baseName);
#else
    baseName += ".png";
    dest = CurDir.resolveFileCaseExistsAbs(baseName);
#endif
}

void LoadGFX()
{
#if defined(PGE_MIN_PORT) || defined(THEXTECH_CLI_BUILD)
    if(LoadGFXFromList(getGfxDir(), false, false))
        return;
#endif

    std::string p;
    DirListCI CurDir;

    pLogDebug("Loading character textures");
    LoaderUpdateDebugString("Characters");
    for(int c = 0; c < numCharacters; ++c)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Character %d", c));
        CurDir.setCurDir(getGfxDir() + GFXPlayerNames[c]);
        For(A, 1, numStates)
        {
            s_find_image(p, CurDir, fmt::sprintf_ne("%s-%d", GFXPlayerNames[c], A));
            if(!p.empty())
                XRender::lazyLoadPicture((*GFXCharacterBMP[c])[A], p);
        }
        UpdateLoad();
    }

    pLogDebug("Loading block textures");
    LoaderUpdateDebugString("Blocks");
    CurDir.setCurDir(getGfxDir() + "block/");
    for(int A = 1; A <= maxBlockType; ++A)
    {
        if(A == BLKID_CONVEYOR_L_CONV || A == BLKID_CONVEYOR_R_CONV)
            continue;

        LoaderUpdateDebugString(fmt::sprintf_ne("Block %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("block-%d", A));

        if(!p.empty())
            XRender::lazyLoadPicture(GFXBlockBMP[A], p);
        else
            break;

        if(A % 20 == 0)
            UpdateLoad();
    }
    UpdateLoad();

    pLogDebug("Loading BG2 textures");
    LoaderUpdateDebugString("Backgrounds");
    CurDir.setCurDir(getGfxDir() + "background2/");
    for(int A = 1; A <= numBackground2; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Background %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("background2-%d", A));

        if(!p.empty())
            XRender::lazyLoadPicture(GFXBackground2BMP[A], p);
        else
            break;

        if(A % 10 == 0)
            UpdateLoad();
    }
    UpdateLoad();

    pLogDebug("Loading NPC textures");
    LoaderUpdateDebugString("NPC");
    CurDir.setCurDir(getGfxDir() + "npc/");
    for(int A = 1; A <= maxNPCType; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("NPC %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("npc-%d", A));

        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXNPCBMP[A], p);

            // load converted conveyer block graphics from conveyer NPC graphics
            if(A == NPCID_CONVEYOR)
            {
                XRender::lazyLoadPicture(GFXBlockBMP[BLKID_CONVEYOR_L_CONV], p);
                XRender::lazyLoadPicture(GFXBlockBMP[BLKID_CONVEYOR_R_CONV], p);
            }

            // GFXNPCWidth(A) = GFXNPCBMP[A].w;
            // GFXNPCHeight(A) = GFXNPCBMP[A].h;
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            // GFXNPCWidth(A) = 0;
            // GFXNPCHeight(A) = 0;
            break;
        }
    }
    UpdateLoad();

    pLogDebug("Loading effect textures");
    LoaderUpdateDebugString("Effects");
    CurDir.setCurDir(getGfxDir() + "effect/");
    for(int A = 1; A <= maxEffectType; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Effect %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("effect-%d", A));

        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXEffectBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
            break;
    }
    UpdateLoad();

    pLogDebug("Loading mount textures");
    LoaderUpdateDebugString("Mounts");
    CurDir.setCurDir(getGfxDir() + "yoshi/");
    for(int A = 1; A <= maxYoshiGfx; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Mount B %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("yoshib-%d", A));

        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXYoshiBBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            break;
        }
    }
    UpdateLoad();

    for(int A = 1; A <= maxYoshiGfx; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Mount T %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("yoshit-%d", A));

        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXYoshiTBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            break;
        }
    }
    UpdateLoad();

    pLogDebug("Loading background textures");
    LoaderUpdateDebugString("BGO");
    CurDir.setCurDir(getGfxDir() + "background/");
    for(int A = 1; A <= maxBackgroundType; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("BGO %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("background-%d", A));

        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXBackgroundBMP[A], p);
            BackgroundWidth[A] = GFXBackgroundBMP[A].w;
            BackgroundHeight[A] = GFXBackgroundBMP[A].h;
        }
        else
        {
            break;
        }

        if(A % 20 == 0)
            UpdateLoad();
    }
    UpdateLoad();


// 'world map
    pLogDebug("Loading tile textures");
    LoaderUpdateDebugString("Terrain");
    CurDir.setCurDir(getGfxDir() + "tile/");
    for(int A = 1; A <= maxTileType; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Terrain %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("tile-%d", A));
        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXTileBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            break;
        }
    }
    UpdateLoad();

    pLogDebug("Loading level textures");
    LoaderUpdateDebugString("Level entries");
    CurDir.setCurDir(getGfxDir() + "level/");
    for(int A = 0; A <= maxLevelType; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Level %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("level-%d", A));
        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXLevelBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            break;
        }
    }
    UpdateLoad();

    pLogDebug("Loading scene textures");
    LoaderUpdateDebugString("Scenery");
    CurDir.setCurDir(getGfxDir() + "scene/");
    for(int A = 1; A <= maxSceneType; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Scenery %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("scene-%d", A));
        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXSceneBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            break;
        }
    }
    UpdateLoad();

    pLogDebug("Loading world player textures");
    LoaderUpdateDebugString("World characters");
    CurDir.setCurDir(getGfxDir() + "player/");
    for(int A = 1; A <= numCharacters; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("World character %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("player-%d", A));
        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXPlayerBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            break;
        }
    }
    UpdateLoad();

    pLogDebug("Loading path textures");
    LoaderUpdateDebugString("Path cells");
    CurDir.setCurDir(getGfxDir() + "path/");
    for(int A = 1; A <= maxPathType; ++A)
    {
        LoaderUpdateDebugString(fmt::sprintf_ne("Path cell %d", A));
        s_find_image(p, CurDir, fmt::sprintf_ne("path-%d", A));
        if(!p.empty())
        {
            XRender::lazyLoadPicture(GFXPathBMP[A], p);
            if(A % 20 == 0)
                UpdateLoad();
        }
        else
        {
            break;
        }
    }
    UpdateLoad();
}

void UnloadGFX(bool reload)
{
    if(!reload)
    {
        // Do nothing at game exit
        return;
    }

    UnloadCustomGFX();
    UnloadWorldCustomGFX();

    for(int c = 0; c < numCharacters; ++c)
    {
        For(A, 1, 10)
        {
            (*GFXCharacterBMP[c])[A].reset();
        }
    }

    for(int A = 1; A <= maxBlockType; ++A)
        GFXBlockBMP[A].reset();

    for(int A = 1; A <= numBackground2; ++A)
        GFXBackground2BMP[A].reset();

    for(int A = 1; A <= maxNPCType; ++A)
        GFXNPCBMP[A].reset();

    for(int A = 1; A <= maxEffectType; ++A)
        GFXEffectBMP[A].reset();

    for(int A = 1; A <= maxYoshiGfx; ++A)
    {
        GFXYoshiBBMP[A].reset();
        GFXYoshiTBMP[A].reset();
    }

    for(int A = 1; A <= maxBackgroundType; ++A)
        GFXBackgroundBMP[A].reset();

// 'world map
    for(int A = 1; A <= maxTileType; ++A)
        GFXTileBMP[A].reset();

    for(int A = 1; A <= maxLevelType; ++A)
        GFXLevelBMP[A].reset();

    for(int A = 1; A <= maxSceneType; ++A)
        GFXSceneBMP[A].reset();

    for(int A = 1; A <= numCharacters; ++A)
        GFXPlayerBMP[A].reset();

    for(int A = 1; A <= maxPathType; ++A)
        GFXPathBMP[A].reset();
}

static void loadCustomUIAssets()
{
    size_t ci = 0;

     // these should all have been set previously, but will do no harm
    g_dirEpisode.setCurDir(FileNamePath);
    g_dirCustom.setCurDir(FileNamePath + FileName);
    s_dirFallback.setCurDir(getGfxDir() + "fallback");

    loadCGFX("ui", "BMVs", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.BMVs, false, true);

    loadCGFX("ui", "BMWin", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.BMWin, false, true);

    For(i, 1, 3)
        loadCGFX("ui", "Boot", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.Boot[i], false, true);

    For(i, 1, 5)
        loadCGFX("ui", "CharacterName", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.CharacterName[i], false, true);

    loadCGFX("ui", "Chat", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Chat, false, true);

    For(i, 0, 2)
        loadCGFX("ui", "Container", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.Container[i], false, true);

    For(i, 1, 3)
        loadCGFX("ui", "ECursor", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.ECursor[i], false, true);

    For(i, 0, 9)
        loadCGFX("ui", "Font1_", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.Font1[i], false, true);

    For(i, 1, 3)
        loadCGFX("ui", "Font2_", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.Font2[i], false, true);

    loadCGFX("ui", "Font2S", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Font2S, false, true);

    For(i, 1, 2)
        loadCGFX("ui", "Heart", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.Heart[i], false, true);

    For(i, 0, 8)
        loadCGFX("ui", "Interface", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.Interface[i], false, true);

    loadCGFX("ui", "LoadCoin", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.LoadCoin, false, true);

    loadCGFX("ui", "Loader", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Loader, false, true);

    For(i, 0, 3)
        loadCGFX("ui", "MCursor", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.MCursor[i], false, true);

    For(i, 1, 4)
        loadCGFX("ui", "MenuGFX", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.MenuGFX[i], false, true);

    loadCGFX("ui", "Mount", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Mount[2], false, true);

    For(i, 0, 7)
        loadCGFX("ui", "nCursor", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.nCursor[i], false, true);

    loadCGFX("ui", "TextBox", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.TextBox, false, true);

    For(i, 1, 2)
        loadCGFX("ui", "Tongue", i,
                 nullptr, nullptr, &GFX.isCustom(ci++), GFX.Tongue[i], false, true);

    // loadCGFX("ui", "Warp", i,
    //          nullptr, nullptr, &GFX.isCustom(ci++), GFX.Warp, false, true);

    loadCGFX("ui", "YoshiWings", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.YoshiWings, false, true);

    loadCGFX("ui", "CycloneAcc", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.CycloneAcc, false, true);

    loadCGFX("ui", "EditorIcons", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.EIcons, false, true);

    loadCGFX("ui", "PCursor", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.PCursor, false, true);

    loadCGFX("ui", "Medals", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Medals, false, true);

    loadCGFX("ui", "CharSelIcons", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.CharSelIcons, false, true);

    loadCBorder("CharSelFrame",
             &GFX.isCustom(ci++), GFX.CharSelFrame);

    loadCGFX("ui", "Backdrop", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Backdrop, false, true);

    loadCBorder("Backdrop_Border",
             &GFX.isCustom(ci++), GFX.Backdrop_Border);

    loadCGFX("ui", "WorldMapFrame_Tile", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.WorldMapFrame_Tile, false, true);

    loadCBorder("WorldMapFrame_Border",
             &GFX.isCustom(ci++), GFX.WorldMapFrame_Border);

    loadCGFX("ui", "Camera", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Camera, false, true);

    loadCGFX("ui", "Balance", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.Balance, false, true);

    loadCGFX("ui", "SaveIcons", -1,
             nullptr, nullptr, &GFX.isCustom(ci++), GFX.SaveIcons, false, true);

    // Add new optional assets above this line. Also update gfx.cpp: GFX_t::load(), and gfx.h: GFX_t::m_isCustomVolume.
}

void LoadCustomGFX(bool include_world, const char* preview_players_from)
{
    // this should have been set previously, but will do no harm
    s_dirFallback.setCurDir(getGfxDir() + "fallback");

    // unload any previously loaded player previews
    s_UnloadPreviewPlayers();

    if(!preview_players_from)
    {
        // these should all have been set previously, but will do no harm
        g_dirEpisode.setCurDir(FileNamePath);
        g_dirCustom.setCurDir(FileNamePath + FileName);

        cgfx_initLangDir();

        loadCustomUIAssets();

#if defined(PGE_MIN_PORT) || defined(THEXTECH_CLI_BUILD)
        bool success = LoadGFXFromList(g_dirEpisode.getCurDir(), true, !include_world);

        if(s_useLangDirEp)
            success |= LoadGFXFromList(g_dirEpisode.getCurDir() + s_langSubDirEp, true, !include_world);

        success |= LoadGFXFromList(g_dirCustom.getCurDir(), true, !include_world);

        if(s_useLangDir)
            success |= LoadGFXFromList(g_dirCustom.getCurDir() + s_langSubDir, true, !include_world);

        if(success)
            return;
#endif
    }
    else
    {
        s_previewPlayersBegin = g_defaultLevelGfxBackup.size();

        g_dirEpisode.setCurDir(preview_players_from);
        g_dirCustom.setCurDir("");

        loadCGFX("ui", "Interface5", -1,
                 nullptr, nullptr, &GFX.isCustom(38), GFX.Interface[5], false, true);
    }


    for(int A = 1; A <= maxYoshiGfx; ++A)
    {
        loadCGFX("yoshi", "yoshib-", A,
                 nullptr, nullptr, nullptr, GFXYoshiBBMP[A]);
    }

    for(int A = 1; A <= maxYoshiGfx; ++A)
    {
        loadCGFX("yoshi", "yoshit-", A,
                 nullptr, nullptr, nullptr, GFXYoshiTBMP[A]);
    }

    for(int c = 0; c < numCharacters; ++c)
    {
        std::string pstem = fmt::sprintf_ne("%s-", GFXPlayerNames[c]);

        for(int A = 1; A <= numStates; ++A)
        {
            loadCGFX(GFXPlayerNames[c], pstem.c_str(), A,
                     nullptr, nullptr,
                     nullptr, (*GFXCharacterBMP[c])[A]);
        }
    }

    for(int A = 1; A <= maxEffectType; ++A)
    {
        if(preview_players_from && A != EFFID_CHAR1_DIE && A != EFFID_CHAR2_DIE && A != EFFID_CHAR3_DIE && A != EFFID_CHAR4_DIE && A != EFFID_CHAR5_DIE)
            continue;

        loadCGFX("effect", "effect-", A,
                 &EffectWidth[A], &EffectHeight[A], &GFXEffectCustom[A], GFXEffectBMP[A]);

        // update calculation (but still rely on backup made above)
        if(GFXEffectCustom[A])
            EffectHeight[A] = GFXEffectBMP[A].h / EffectDefaults.EffectFrames[A];
    }


    if(preview_players_from)
    {
        s_previewPlayersEnd = g_defaultLevelGfxBackup.size();
        return;
    }


    for(int A = 1; A <= maxBlockType; ++A)
    {
        if(A == BLKID_CONVEYOR_L_CONV || A == BLKID_CONVEYOR_R_CONV)
            continue;

        loadCGFX("block", "block-", A,
                 nullptr, nullptr, nullptr, GFXBlockBMP[A],
                 false, BlockHasNoMask[A]);
    }

    for(int A = 1; A <= numBackground2; ++A)
    {
        loadCGFX("background2", "background2-", A,
                 nullptr, nullptr, nullptr, GFXBackground2BMP[A],
                 false, true);
    }

    for(int A = 1; A <= maxNPCType; ++A)
    {
        loadCGFX("npc", "npc-", A,
                 nullptr, nullptr, nullptr, GFXNPCBMP[A]);

        // load converted conveyer block graphics from conveyer NPC graphics
        if(A == NPCID_CONVEYOR)
        {
            loadCGFX("npc", "npc-", A,
                     nullptr, nullptr, nullptr, GFXBlockBMP[BLKID_CONVEYOR_L_CONV]);

            loadCGFX("npc", "npc-", A,
                     nullptr, nullptr, nullptr, GFXBlockBMP[BLKID_CONVEYOR_R_CONV]);
        }
    }

    for(int A = 1; A <= maxBackgroundType; ++A)
    {
        loadCGFX("background", "background-", A,
                 nullptr, nullptr, nullptr, GFXBackgroundBMP[A],
                 false, BackgroundHasNoMask[A]);
    }


    if(!include_world)
        return;


    for(int A = 1; A <= maxTileType; ++A)
    {
        loadCGFX("tile", "tile-", A,
                 nullptr, nullptr, nullptr, GFXTileBMP[A], true);
    }

    for(int A = 0; A <= maxLevelType; ++A)
    {
        loadCGFX("level", "level-", A,
                 nullptr, nullptr, nullptr, GFXLevelBMP[A], true);
    }

    for(int A = 1; A <= maxSceneType; ++A)
    {
        loadCGFX("scene", "scene-", A,
                 nullptr, nullptr, nullptr, GFXSceneBMP[A], true);
    }

    for(int A = 1; A <= numCharacters; ++A)
    {
        loadCGFX("player", "player-", A,
                 nullptr, nullptr, nullptr, GFXPlayerBMP[A], true);
    }

    for(int A = 1; A <= maxPathType; ++A)
    {
        loadCGFX("path", "path-", A,
                 nullptr, nullptr, nullptr, GFXPathBMP[A], true);
    }
}


void UnloadCustomGFX()
{
#ifndef RENDER_CUSTOM
    // reset bitmask warning flag on SDL platforms
    XRender::g_BitmaskTexturePresent = false;
#endif

    // unload custom frame border info
    for(auto it = g_defaultBorderInfoBackup.rbegin(); it != g_defaultBorderInfoBackup.rend(); ++it)
    {
        auto &t = *it;

        if(t.remote_info)
            *t.remote_info = t.info_backup;
    }
    g_defaultBorderInfoBackup.clear();

    restoreLevelBackupTextures();

#ifndef LOW_MEM
    // Restore default sizes of custom effects (should no longer be required, now that backups are made directly)
    for(int A = 1; A < maxEffectType; ++A)
    {
        SDL_assert_release(EffectWidth[A] == EffectDefaults.EffectWidth[A]);
        SDL_assert_release(EffectHeight[A] == EffectDefaults.EffectHeight[A]);
    }
#endif // #ifndef LOW_MEM
}

void UnloadPlayerPreviewGFX()
{
    s_UnloadPreviewPlayers();
}


void UnloadWorldCustomGFX()
{
    restoreWorldBackupTextures();
}

void LoaderInit()
{
    gfxLoaderDebugStart = SDL_GetTicks();
    Strings::dealloc(gfxLoaderDebugString);
    gfxLoaderDebugStringUpdated = true;
    gfxLoaderDebugString.reserve(1024);

#ifndef PGE_NO_THREADING
    if(!gfxLoaderDebugMutex)
        gfxLoaderDebugMutex = SDL_CreateMutex();
#endif
}

void LoaderFinish()
{
    gfxLoaderDebugStart = -1;
    Strings::dealloc(gfxLoaderDebugString);
    gfxLoaderDebugStringUpdated = true;

#ifndef PGE_NO_THREADING
    if(gfxLoaderDebugMutex)
        SDL_DestroyMutex(gfxLoaderDebugMutex);
    gfxLoaderDebugMutex = nullptr;
#endif
}

void LoaderUpdateDebugString(const std::string &strig, bool forceUpdate)
{
    if(gfxLoaderDebugStart == -1)
        return;

#ifndef PGE_NO_THREADING
    SDL_LockMutex(gfxLoaderDebugMutex);
#endif
    gfxLoaderDebugString = fmt::format_ne(g_gameStrings.loaderStatusLoadFile, strig);
    if(forceUpdate)
        gfxLoaderDebugStringUpdated = true;
#ifndef PGE_NO_THREADING
    SDL_UnlockMutex(gfxLoaderDebugMutex);
#endif

    if(!gfxLoaderThreadingMode)
        UpdateLoadREAL();
}


void UpdateLoadREAL()
{
    std::string state;
    bool draw = false;

#ifdef THEXTECH_INTERPROC_SUPPORTED
    if(IntProc::isEnabled())
    {
        state = IntProc::getState();
        draw = true;
    }
#endif // THEXTECH_INTERPROC_SUPPORTED

    bool assets_reload = (ScreenAssetPack::g_LoopActive && g_AssetsLoaded);

    static uint8_t alphaFader = 255;

    if(assets_reload)
        alphaFader = 0;

    if(gfxLoaderDebugStringUpdated)
    {
        gfxLoaderDebugStringUpdated = false;
        draw = true;
    }

    if(LoadCoinsT <= SDL_GetTicks())
    {
        LoadCoinsT = SDL_GetTicks() + 100;
        LoadCoins += 1;
        if(LoadCoins > 3)
            LoadCoins = 0;
        draw = true;
    }

    if(gfxLoaderThreadingMode && alphaFader >= 10)
    {
        alphaFader -= 10;
        draw = true;
    }
    else if(gfxLoaderThreadingMode && alphaFader != 0)
    {
        alphaFader = 0;
        draw = true;
    }

#ifdef USE_RENDER_BLOCKING
    if(XRender::renderBlocked())
        return;
#endif

    if(draw)
    {
        XRender::setTargetTexture();
        XRender::clearBuffer();

        int sh_w = XRender::TargetW / 2;
        int gh_w = GFX.MenuGFX[4].w / 2;
        int sh_h = XRender::TargetH / 2;
        int gh_h = GFX.MenuGFX[4].h / 2;

        // use default coordinates during reload
        if(assets_reload)
        {
            gh_w = 400;
            gh_h = 300;
        }

        int Left    = sh_w - gh_w;
        int Top     = sh_h - gh_h;
        int Right   = sh_w + gh_w;
        int Bottom  = sh_h + gh_h;

        if(Left < 0)
            Left = 0;

        if(Top < 0)
            Top = 0;

        if(Right > XRender::TargetW)
            Right = XRender::TargetW;

        if(Bottom > XRender::TargetH)
            Bottom = XRender::TargetH;

        Left += XRender::TargetOverscanX;
        Right -= XRender::TargetOverscanX;

        if(assets_reload)
        {
            ScreenAssetPack::DrawBackground(64);
            DrawDeviceBattery();
        }
        else if(!gfxLoaderTestMode)
        {
            XRender::renderTextureBasic(sh_w - gh_w, sh_h - gh_h, GFX.MenuGFX[4]);
        }
        else
        {
            // Display the IPC status
            if(!state.empty())
                SuperPrint(state, 3, 10, 10);
            else
                SuperPrint(g_gameStrings.loaderStatusLoadData, 3, 10, 10);
        }

        if(gh_w < 400)
        {
            Left = 0;
            Right = XRender::TargetW;
        }

        if(gh_h < 240)
        {
            // Top = 0;
            Bottom = XRender::TargetH;
        }

        XRender::renderTextureBasic(Right - (GFX.Loader.w + 50), Bottom - (GFX.Loader.h + 8), GFX.Loader);
        XRender::renderTextureBasic(Right - 40, Bottom - 40, GFX.LoadCoin.w, GFX.LoadCoin.h / 4, GFX.LoadCoin, 0, 32 * LoadCoins);

        if(gfxLoaderThreadingMode && alphaFader > 0)
            XRender::renderRect(0, 0, XRender::TargetW, XRender::TargetH, {0, 0, 0, alphaFader});

#ifndef PGE_NO_THREADING
        SDL_LockMutex(gfxLoaderDebugMutex);
#endif

        if(!gfxLoaderDebugString.empty() && gfxLoaderDebugStart + c_gfxLoaderShowInterval < SDL_GetTicks())
        {
            SuperPrint(gfxLoaderDebugString.c_str(), 3,
                       Left + 10, Bottom - 24,
                       {255, 255, 0, 127});
        }

#ifndef PGE_NO_THREADING
        SDL_UnlockMutex(gfxLoaderDebugMutex);
#endif

        XRender::repaint();
        XRender::setTargetScreen();

        XEvents::doEvents();
#ifdef __EMSCRIPTEN__
        emscripten_sleep(1); // To repaint screenn, it's required to send a sleep signal
#endif
    }
}

void UpdateLoad()
{
    if(LoadingInProcess && !gfxLoaderThreadingMode)
        UpdateLoadREAL();
}


================================================
FILE: src/load_gfx.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LOAD_GFX_H
#define LOAD_GFX_H

#include <string>

extern bool gfxLoaderTestMode;
extern bool gfxLoaderThreadingMode;

// Public Sub LoadGFX()
void LoadGFX();
// Public Sub UnloadGFX()
void UnloadGFX(bool reload = false);
// Public Sub LoadCustomGFX()
void LoadCustomGFX(bool include_world = false, const char* preview_players_from = nullptr);
// Public Sub UnloadCustomGFX()
void UnloadCustomGFX();
// Public Sub LoadCustomGFX2(GFXFilePath As String)
//void LoadCustomGFX2(std::string GFXFilePath);

void UnloadPlayerPreviewGFX();

// now a subfunction of LoadCustomGFX
// Public Sub LoadWorldCustomGFX()
// void LoadWorldCustomGFX();
// Public Sub UnloadWorldCustomGFX()
void UnloadWorldCustomGFX();

// Private Sub cBlockGFX(A As Integer)
// Private Sub cNPCGFX(A As Integer)
// Private Sub cBackgroundGFX(A As Integer)
// Private Sub cTileGFX(A As Integer)
// Private Sub cSceneGFX(A As Integer)
// Private Sub cLevelGFX(A As Integer)
// Private Sub cPathGFX(A As Integer)

void LoaderInit();
void LoaderFinish();
void LoaderUpdateDebugString(const std::string &strig, bool forceUpdate = false);

// Public Sub UpdateLoad()
void UpdateLoadREAL();
void UpdateLoad();


#endif // LOAD_GFX_H


================================================
FILE: src/location.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LOCATION_H
#define LOCATION_H

#include <cstdint>

#include "numeric_types.h"

//Public Type Location    'Holds location information for objects
struct Location_t
{
//    X As Double
    num_t X = 0.0_n;
//    Y As Double
    num_t Y = 0.0_n;
//    Height As Double
    num_t Height = 0.0_n;
//    Width As Double
    num_t Width = 0.0_n;
//    SpeedX As Double
    num_t SpeedX = 0.0_n;
//    SpeedY As Double
    num_t SpeedY = 0.0_n;
//End Type

    // checks if the center is strictly to the right of the other location's center
    inline bool to_right_of(const Location_t& o) const
    {
        return X - o.X + (Width - o.Width) / 2 > 0;
    }

    // sets the width, maintaining location center
    inline void set_width_center(num_t new_width)
    {
        X += (Width - new_width) / 2;
        Width = new_width;
    }

    // sets the height, maintaining location center
    inline void set_height_center(num_t new_height)
    {
        Y += (Height - new_height) / 2;
        Height = new_height;
    }

    // sets the height, maintaining location floor
    inline void set_height_floor(num_t new_height)
    {
        Y += Height - new_height;
        Height = new_height;
    }

    // sees how far this location's center is to the right of the other location
    inline num_t minus_center_x(const Location_t& o) const
    {
        return X - o.X + (Width - o.Width) / 2;
    }

    // sees how far this location's center is below the other location
    inline num_t minus_center_y(const Location_t& o) const
    {
        return Y - o.Y + (Height - o.Height) / 2;
    }
};

//NEW: 'Holds location information for an object without speed at integer coordinates, with width / height values below 32767
struct TinyLocation_t
{
    int32_t X = 0;
    int32_t Y = 0;
    int16_t Height = 0;
    int16_t Width = 0;

    inline TinyLocation_t() = default;
    inline TinyLocation_t(int32_t X, int32_t Y, int16_t Width, int16_t Height) : X(X), Y(Y), Height(Height), Width(Width) {}
    inline explicit TinyLocation_t(const Location_t& loc) : X(loc.X), Y(loc.Y), Height(loc.Height), Width(loc.Width) {}

    inline explicit operator Location_t() const
    {
        Location_t ret;
        ret.X = X;
        ret.Y = Y;
        ret.Height = Height;
        ret.Width = Width;

        return ret;
    }
};

//NEW: 'Holds location information for an object without speed at integer coordinates (like most objects that have not moved since saving)
struct IntegerLocation_t
{
    int32_t X = 0;
    int32_t Y = 0;
    int32_t Height = 0;
    int32_t Width = 0;

    inline IntegerLocation_t() = default;
    inline IntegerLocation_t(int32_t X, int32_t Y, int32_t Width, int32_t Height) : X(X), Y(Y), Height(Height), Width(Width) {}

    inline explicit operator Location_t() const
    {
        Location_t ret;
        ret.X = X;
        ret.Y = Y;
        ret.Height = Height;
        ret.Width = Width;

        return ret;
    }
};

//NEW: 'Holds location information for an object without speed
struct SpeedlessLocation_t
{
//    X As Double
    num_t X = 0_n;
//    Y As Double
    num_t Y = 0_n;
//    Height As Double
    num_t Height = 0_n;
//    Width As Double
    num_t Width = 0_n;

    inline SpeedlessLocation_t() = default;
    inline explicit SpeedlessLocation_t(const Location_t& loc) : X(loc.X), Y(loc.Y), Height(loc.Height), Width(loc.Width) {}
    inline explicit SpeedlessLocation_t(const IntegerLocation_t& loc) : X(loc.X), Y(loc.Y), Height(loc.Height), Width(loc.Width) {}

    inline explicit operator Location_t() const
    {
        Location_t ret;
        ret.X = X;
        ret.Y = Y;
        ret.Height = Height;
        ret.Width = Width;

        return ret;
    }
};

//NEW: 'Holds location information for player start location, including Direction
struct PlayerStart_t
{
//    X As Double
    int32_t X = 0;
//    Y As Double
    int32_t Y = 0;
//    Height As Double
    int32_t Height = 0;
//    Width As Double
    int32_t Width = 0;
//! Initial direction [New-added]
    int Direction = 1;
//End Type

    inline PlayerStart_t() = default;
    inline PlayerStart_t(const Location_t& loc) : X((int32_t)loc.X), Y((int32_t)loc.Y), Height((int32_t)loc.Height), Width((int32_t)loc.Width) {}

    inline bool isNull() const
    {
        return X == 0 &&
               Y == 0 &&
               Width == 0 &&
               Height == 0;
    }

    inline operator Location_t() const
    {
        Location_t ret;
        ret.X = X;
        ret.Y = Y;
        ret.Height = Height;
        ret.Width = Width;

        return ret;
    }
};

// creates a temp Location
Location_t newLoc(num_t X, num_t Y, num_t Width = 0, num_t Height = 0);
// creates a copy of location with a grid rounding
// Location_t roundLoc(const Location_t &inLoc, num_t grid);

#endif // LOCATION_H


================================================
FILE: src/logic/object_graph.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include <Logger/logger.h>

#include "logic/object_graph.h"

#include "npc_id.h"
#include "npc.h"
#include "globals.h"

namespace ObjectGraph
{

template<class LocType>
Loc get_center(const LocType& loc)
{
    return {(int)(loc.X + loc.Width / 2), (int)(loc.Y + loc.Height / 2)};
}

static unsigned int s_get_distance(const Loc& loc_1, const Loc& loc_2)
{
    int dx = loc_1.x - loc_2.x;
    int dy = loc_1.y - loc_2.y;
    return SDL_abs(dx) + SDL_abs(dy);
}

void Graph::expand(SearchPriorityQueue& queue, DistMap& dist_map, const Object* node, unsigned int distance, bool warps_reverse) const
{
    if(dist_map.find(node) != dist_map.end())
        return;

    dist_map.emplace(node, distance);

    // expand warps (only)
    if(node->type == Object::Warp)
    {
        // add paths from warp to all nodes to queue
        Loc source_loc = warps_reverse ? node->loc : node->dest;

        for(const Object* next : this->all_nodes)
        {
            Loc dest_loc = (warps_reverse && next->type == Object::Warp) ? next->dest : next->loc;
            queue.emplace(distance + s_get_distance(source_loc, dest_loc), next);
        }
    }
}

void Graph::search(DistMap& dist_map, const Object* origin, bool warps_reverse) const
{
    SearchPriorityQueue queue;
    dist_map.clear();

    // add paths from origin to all nodes to queue
    Loc origin_loc = (!warps_reverse && origin->type == Object::Warp) ? origin->dest : origin->loc;

    for(const Object* next : this->all_nodes)
    {
        Loc next_loc = (warps_reverse && next->type == Object::Warp) ? next->dest : next->loc;
        queue.emplace(s_get_distance(origin_loc, next_loc), next);
    }

    while(!queue.empty())
    {
        QueueEntry entry = queue.top();
        queue.pop();

        unsigned int distance = entry.first;
        const Object* node = entry.second;

        expand(queue, dist_map, node, distance, warps_reverse);
    }
}

void Graph::update()
{
    // refresh the set of nodes
    this->all_nodes.clear();
    for(const Object& node : this->level.warps)
        this->all_nodes.insert(&node);
    // don't process exits for now, because only medals are tracked for now
    // for(const Object& node : this->level.exits)
    //     this->all_nodes.insert(&node);
    for(const Object& node : this->level.items)
        this->all_nodes.insert(&node);

    // create the map of distances from start
    search(start_dist_map, &this->level.player_start, false);

    // check the furthest distance
    this->furthest_dist = 0;
    for(const Object* node : this->all_nodes)
    {
        unsigned int node_dist = this->start_dist_map[node];
        if(node_dist > this->furthest_dist)
            this->furthest_dist = node_dist;
    }
}

unsigned int Graph::distance_from_start(Loc loc)
{
    unsigned int best_distance = s_get_distance(loc, this->level.player_start.loc);

    for(const Object* node : this->all_nodes)
    {
        unsigned int start_to_node = start_dist_map[node];
        if(start_to_node == 0 || start_to_node >= best_distance)
            continue;

        const Loc& node_loc = (node->type == Object::Warp) ? node->dest : node->loc;

        unsigned int node_to_loc = s_get_distance(loc, node_loc);

        if(start_to_node + node_to_loc < best_distance)
            best_distance = start_to_node + node_to_loc;
    }

    return best_distance;
}

void FillGraph(Graph& graph)
{
    // start by filling the level struct
    graph.level = ObjectGraph::Level();

    graph.level.player_start = o(ObjectGraph::Object::PlayerStart,
        get_center(PlayerStart[1]));

    for(int i = 1; i <= numWarps; i++)
    {
        if(Warp[i].LevelEnt)
        {
            // eventually mark it as a possible level start
            continue;
        }

        if(Warp[i].MapWarp || Warp[i].LevelWarp)
        {
            graph.level.exits.push_back(o(ObjectGraph::Object::Exit,
                get_center(Warp[i].Entrance),
                ObjectGraph::Object::G_Warp, i));
        }
        else
        {
            graph.level.warps.push_back(o(ObjectGraph::Object::Warp,
                get_center(Warp[i].Entrance),
                ObjectGraph::Object::G_Warp, i,
                get_center(Warp[i].Exit)));

            if(Warp[i].twoWay)
            {
                graph.level.warps.push_back(o(ObjectGraph::Object::Warp,
                    get_center(Warp[i].Exit),
                    ObjectGraph::Object::G_Warp, i,
                    get_center(Warp[i].Entrance)));
            }
        }
    }

    // add magic doors as warps
    for(int i = 1; i <= numNPCs; ++i)
    {
        NPC_t& n = NPC[i];

        bool is_container = NPCIsContainer(n);

        bool contains_door = is_container && (n.Special == NPCID_DOOR_MAKER || n.Special == NPCID_MAGIC_DOOR);
        bool is_door = (n.Type == NPCID_DOOR_MAKER || n.Type == NPCID_MAGIC_DOOR);

        bool has_target_section = n.Variant <= maxSections;

        // allow doors only
        if(!is_door && !contains_door)
            continue;

        // only count it if it has a target section
        if(!has_target_section)
            continue;

        // add a warp from the NPC's position to the corresponding position in the target section

        // check current section (backing up whatever value was already there)
        uint8_t old_section = n.Section;
        CheckSectionNPC(i);

        int cur_section = n.Section;
        n.Section = old_section;

        Loc npc_center = get_center(n.Location);

        int targetX = npc_center.x - LevelREAL[cur_section].X + LevelREAL[n.Variant].X;
        int targetY = npc_center.y - LevelREAL[cur_section].Y + LevelREAL[n.Variant].Y;

        graph.level.warps.push_back(o(ObjectGraph::Object::Warp,
            npc_center,
            ObjectGraph::Object::G_NPC, i,
            {targetX, targetY}));
    }

    for(int i = 1; i <= numNPCs; i++)
    {
        if(NPC[i].Type == NPCID_GOALTAPE || NPC[i].Type == NPCID_STAR_EXIT || NPC[i].Type == NPCID_FLAG_EXIT
            || NPC[i].Type == NPCID_ITEMGOAL || NPC[i].Type == NPCID_GOALORB_S3 || NPC[i].Type == NPCID_GOALORB_S2)
        {
            graph.level.exits.push_back(o(ObjectGraph::Object::Exit,
                get_center(NPC[i].Location),
                ObjectGraph::Object::G_NPC, i));
        }

        // only track medals for now -- they're all that's used for the time being
        if(NPC[i].Type == NPCID_MEDAL) // || NPC[i].Type == NPCID_STAR_COLLECT || NPC[i].Type == NPCID_KEY)
        {
            graph.level.items.push_back(o(ObjectGraph::Object::Item,
                get_center(NPC[i].Location),
                ObjectGraph::Object::G_NPC, i));
        }
    }

    for(int i = 1; i <= numBackground; i++)
    {
        // keyhole
        if(Background[i].Type == 35)
        {
            graph.level.exits.push_back(o(ObjectGraph::Object::Exit,
                get_center(Background[i].Location),
                ObjectGraph::Object::G_BGO, i));
        }
    }

    // now update the graph (gets all objects' distances from start)
    graph.update();
}

} //namespace ObjectGraph


================================================
FILE: src/logic/object_graph.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef OBJECT_GRAPH_H
#define OBJECT_GRAPH_H

#include <unordered_map>
#include <vector>
#include <set>
#include <queue>

//! a set of features designed to support warp-aware (but not block-aware) distance checks between objects
namespace ObjectGraph
{

struct Loc
{
    int x;
    int y;
};

//! represents a single game object (does not attempt to track a single NPC if its ID changes)
struct Object
{
    enum Object_Type
    {
        PlayerStart,
        Warp,
        Item,
        Exit
    };
    enum Game_Object_Type
    {
        G_None,
        G_Warp,
        G_Block,
        G_NPC,
        G_BGO
    };

    Object_Type type;
    Loc loc;
    Game_Object_Type g_type = G_None;
    int game_index = -1;
    Loc dest;
};

inline Object o(Object::Object_Type type, Loc loc)
{
    Object o;
    o.type = type;
    o.loc = loc;
    return o;
}

inline Object o(Object::Object_Type type, Loc loc, Object::Game_Object_Type g_type, int game_index)
{
    Object o;
    o.type = type;
    o.loc = loc;
    o.g_type = g_type;
    o.game_index = game_index;
    return o;
}

inline Object o(Object::Object_Type type, Loc loc, Object::Game_Object_Type g_type, int game_index, Loc dest)
{
    Object o;
    o.type = type;
    o.loc = loc;
    o.g_type = g_type;
    o.game_index = game_index;
    o.dest = dest;
    return o;
}

struct Level
{
    Object player_start;
    std::vector<Object> exits;
    std::vector<Object> warps;
    std::vector<Object> items;
};

class Graph
{
public:
    // map of distances to/from objects
    using DistMap = std::unordered_map<const Object*, unsigned int>;

    Level level;

    // set of all objects in the graph
    std::set<const Object*> all_nodes;

    // map of distances from P1 start TO each object
    DistMap start_dist_map;

    //! furthest distance of anything from player start
    unsigned int furthest_dist = 0;

    //! update the object graph's nodes and start_dist_map based on its level substruct
    void update();

    //! get the distance (using warps if needed) from P1 start to loc
    unsigned int distance_from_start(Loc loc);

private:
    // search algorithm support functions
    using QueueEntry = std::pair<unsigned int, const Object*>;
    using SearchPriorityQueue = std::priority_queue<QueueEntry, std::vector<QueueEntry>, std::greater<QueueEntry>>;

    // Expand a single object in the queue, updating the dist_map and adding new queue entries to additional objects.
    void expand(SearchPriorityQueue& queue, DistMap& dist_map, const Object* node, unsigned int distance, bool warps_reverse) const;

    // Fill dist_map with distances from origin. If warps_reverse is true, then find paths from objects to origin.
    void search(DistMap& dist_map, const Object* origin, bool warps_reverse) const;
};

//! create an object graph based on the currently loaded level
void FillGraph(Graph& graph);

} //namespace ObjectGraph

#endif // #ifndef OBJECT_GRAPH_H


================================================
FILE: src/main/asset_pack.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>

#include <AppPath/app_path.h>

#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <Archives/archives.h>
#include <DirManager/dirman.h>
#include <Logger/logger.h>
#include <IniProcessor/ini_processing.h>

#include "global_dirs.h"
#include "main/asset_pack.h"
#include "main/translate.h"
#include "core/render.h"
#include "core/msgbox.h"
#include "core/language.h"
#include "fontman/font_manager.h"

#include "sound.h"
#include "gfx.h"
#include "load_gfx.h"
#include "game_main.h"

static std::vector<AssetPack_t> s_asset_packs;
static bool s_found_asset_packs = false;

std::string g_AssetPackID;
bool g_AssetsLoaded = false;

static void appendSlash(std::string &path)
{
#if defined(__EMSCRIPTEN__)
    // fix emscripten bug of duplicated worlds
    if(path.empty() || path.back() != '/')
        path.push_back('/');
#else
    if(!path.empty() && path.back() != '/')
        path.push_back('/');
#endif
}

static inline void s_load_image(StdPicture& dest, std::string nameWithPng)
{
    dest.reset();

#if defined(X_IMG_EXT)
    if(nameWithPng.size() > 4)
    {
        std::string orig_ext;
        size_t base_size = nameWithPng.find_last_of('.');

        if(base_size == std::string::npos)
            base_size = nameWithPng.size();
        else
        {
            orig_ext = nameWithPng.substr(base_size);
            nameWithPng.resize(base_size);
        }

        nameWithPng += X_IMG_EXT;

        if(Files::fileExists(nameWithPng))
        {
            XRender::lazyLoadPicture(dest, nameWithPng);

            if(dest.inited)
                return; // Success
        }

#   if !defined(X_NO_PNG_GIF)
        nameWithPng.resize(base_size);

        if(!orig_ext.empty())
            nameWithPng += orig_ext;
#   endif // !defined(X_NO_PNG_GIF)
    }
#endif // defined(X_IMG_EXT)

#if !defined(X_NO_PNG_GIF)
    if(!dest.inited && Files::fileExists(nameWithPng))
        XRender::lazyLoadPicture(dest, nameWithPng);
#endif
}

static AssetPack_t s_scan_asset_pack(const std::string& path, bool skip_graphics = false)
{
    AssetPack_t ret;
    ret.path = path;
    ret.gfx.reset(new AssetPack_t::Gfx());

    appendSlash(ret.path);

    // based on Launcher.java:updateOverlook()
    const char* assets_icon = "graphics/ui/icon/thextech_128.png";
    const char* logo_image_path_default = "graphics/ui/MenuGFX2.png";
    const char* bg_image_path_default = "graphics/background2/background2-2.png";

    std::string logo_image_path;
    std::string bg_image_path;

    ret.gfx->bg_frames = 1;
    ret.gfx->bg_frame_ticks = 125;

    std::string meta_path = ret.path + "_meta.ini";
    std::string gi_path = ret.path + "gameinfo.ini";

    IniProcessing ini;
    int ini_exists = 0;

    if(Archives::has_prefix(path) && Files::fileExists(meta_path))
    {
        Files::Data data = Files::load_file(meta_path);
        ini.openMem(data.c_str(), data.size());
        ini_exists = 1;

        ini.beginGroup("content");

        // confirm engine support
        std::string engine;
        ini.read("engine", engine, engine);
        if(engine != "TheXTech")
        {
            pLogInfo("Asset pack [%s] not loaded; for incompatible engine [%s]", path.c_str(), engine.c_str());
            return ret;
        }

        // confirm platform support
        std::string platform;
        ini.read("platform", platform, platform);

        bool platform_okay = false;

#ifndef __16M__
        if(platform == "main")
            platform_okay = true;
#endif

#ifdef __3DS__
        if(platform == "3ds")
            platform_okay = true;
#endif

#ifdef __WII__
        if(platform == "wii")
            platform_okay = true;
#endif

#ifdef __16M__
        if(platform == "dsi")
            platform_okay = true;
#endif

        if(!platform_okay)
        {
            pLogInfo("Asset pack [%s] not loaded; for incompatible platform [%s]", path.c_str(), platform.c_str());
            return ret;
        }

        ini.read("pack-id", ret.id, ret.id);
    }
    else if(Files::fileExists(gi_path))
    {
        Files::Data data = Files::load_file(gi_path);
        ini.openMem(data.c_str(), data.size());
        ini_exists = -1;

        ini.beginGroup("game");
        ini.read("id", ret.id, ret.id);
    }

    if(ini_exists)
    {
        // finish reading main group
        ini.read("version", ret.version, ret.version);
        ini.read("show-id", ret.show_id, ret.show_id);
        ini.endGroup();

        // read graphics group (properties for _meta.ini, android for gameinfo.ini)
        ini.beginGroup((ini_exists > 0) ? "properties" : "android");
        ini.read("show-id", ret.show_id, ret.show_id);
        ini.read("logo", logo_image_path, logo_image_path_default);
        ini.read("background", bg_image_path, bg_image_path_default);
        ini.read("background-frames", ret.gfx->bg_frames, ret.gfx->bg_frames);
        ini.read("background-delay", ret.gfx->bg_frame_ticks, ret.gfx->bg_frame_ticks);
        ini.endGroup();
    }

    if(logo_image_path != logo_image_path_default)
        ret.logo_override = true;

    // don't allow any dirsep characters in asset pack ID
    for(char& c : ret.id)
    {
        if(c == '/' || c == '\\')
            c = '_';
    }

    // ms to frames (approximately)
    ret.gfx->bg_frame_ticks /= 15;

    // load graphics
    if(!skip_graphics)
    {
        s_load_image(ret.gfx->icon, ret.path + assets_icon);
        s_load_image(ret.gfx->logo, ret.path + logo_image_path);
        s_load_image(ret.gfx->background, ret.path + bg_image_path);

        if(!ret.gfx->logo.inited && logo_image_path != logo_image_path_default)
            s_load_image(ret.gfx->logo, ret.path + logo_image_path_default);

        if(!ret.gfx->background.inited && bg_image_path != bg_image_path_default)
            s_load_image(ret.gfx->background, ret.path + bg_image_path_default);
    }

    return ret;
}

static void s_strip_id(AssetPack_t& pack)
{
    if(!pack.id.empty() && !pack.version.empty())
        pack.version = pack.id + '-' + pack.version;
    else if(!pack.id.empty())
        pack.version = pack.id;

    pack.id.clear();
}

static void s_find_asset_packs()
{
    pLogDebug("Searching for asset packs in...");

    DirMan assets;
    std::vector<std::string> subdirList;
    std::vector<std::string> archiveList;
    std::string subdir;

    for(const auto& root_ : AppPathManager::assetsSearchPath())
    {
        std::string root = root_.first;
        AssetsPathType type = root_.second;

        // check for a root passed via `-c`
        bool is_modern_root = (type == AssetsPathType::Single);
        bool is_multiple_root = (type == AssetsPathType::Multiple);

        // Normally, root is a legacy asset pack, and <root>/assets/ contains modern asset packs.
        // If passed via -c, root must be a modern asset pack also.

        // check for legacy debug assets
        if(!is_multiple_root)
            pLogDebug("- %s%s", root.c_str(), (is_modern_root) ? "" : " (legacy)");

        if(!is_multiple_root && DirMan::exists(root + "graphics/ui/"))
        {
            AssetPack_t pack = s_scan_asset_pack(root);

            // strip the ID from a legacy asset pack
            if(!is_modern_root)
                s_strip_id(pack);

            if(!pack.gfx || !pack.gfx->logo.inited)
                pLogWarning("  Could not load UI assets from %s asset pack [%s], ignoring", (is_modern_root) ? "user-specified" : "possible legacy", pack.path.c_str());
            else if(is_modern_root && pack.id.empty())
                pLogWarning("  Could not read ID of modern asset pack [%s], ignoring", pack.path.c_str());
            else
                s_asset_packs.push_back(std::move(pack));
        }

        if(type == AssetsPathType::Legacy)
            root += "assets/";

        if(!is_modern_root)
            pLogDebug("- %s*", root.c_str());

        if(!is_modern_root && DirMan::exists(root))
        {
            assets.setPath(root);
            assets.getListOfFolders(subdirList);
            assets.getListOfFiles(archiveList);

            size_t num_dirs = subdirList.size();

            for(std::string& a : archiveList)
                subdirList.push_back(std::move(a));

            size_t i = 0;

            for(const std::string& sub : subdirList)
            {
                i++;

                // archive
                if(i > num_dirs)
                {
                    subdir = "@" + root + sub + ":/";

                    if(!Files::fileExists(subdir + "_meta.ini"))
                        continue;
                }
                // subdir
                else
                {
                    subdir = root + sub;

                    if(!DirMan::exists(subdir + "/graphics/ui/"))
                        continue;
                }

                D_pLogDebug("  Checking %s", subdir.c_str());

                AssetPack_t pack = s_scan_asset_pack(subdir);

                if(!pack.gfx || !pack.gfx->logo.inited)
                    pLogWarning("  Could not load UI assets from possible asset pack [%s], ignoring", pack.path.c_str());
                else if(pack.id.empty())
                    pLogWarning("  Could not read ID of possible asset pack [%s], ignoring", pack.path.c_str());
                else
                    s_asset_packs.push_back(std::move(pack));
            }
        }
    }

    if(!s_asset_packs.empty())
    {
        pLogDebug("Found asset packs:");

        for(const AssetPack_t& pack : s_asset_packs)
            pLogDebug("- %s (%s)", pack.full_id().c_str(), pack.path.c_str());
    }
    else
        pLogCritical("Could not find any asset packs.");

    // check for duplicates
    for(size_t i = 0; i < s_asset_packs.size(); i++)
    {
        for(size_t j = i + 1; j < s_asset_packs.size();)
        {
            if(s_asset_packs[i].id == s_asset_packs[j].id)
            {
                if(s_asset_packs[i].version == s_asset_packs[j].version)
                {
                    // erase a case with same ID and version
                    s_asset_packs.erase(s_asset_packs.begin() + j);
                    continue;
                }

                // if version is the distinguishing factor, display it
                s_asset_packs[i].show_version = true;
                s_asset_packs[j].show_version = true;
            }

            j++;
        }
    }

    s_found_asset_packs = true;
}

static std::string s_prepare_assets_path(const std::string& path)
{
    Archives::unmount_assets();

    std::string target_path = path;

    // parse and mount assets if possible
    if(target_path[0] == '@')
    {
        // mount target, then replace path
        auto archive_end = target_path.begin();
        // don't check for path end until after the first slash
        while(archive_end != target_path.end() && *archive_end != '/' && *archive_end != '\\')
            ++archive_end;
        while(archive_end != target_path.end() && *archive_end != ':')
            ++archive_end;

        if(archive_end != target_path.end())
        {
            *archive_end = '\0';

            if(Archives::mount_assets(target_path.c_str() + 1))
            {
                target_path.erase(target_path.begin() + 2, archive_end + 1);
                target_path[0] = ':';
                target_path[1] = 'a';
            }
            else
                *archive_end = ':';
        }
    }

    return target_path;
}

static bool s_try_load_gfx(const AssetPack_t& pack, bool skip_gfx)
{
    pLogDebug("= Trying to load asset pack \"%s/%s\" from [%s]", pack.id.c_str(), pack.version.c_str(), pack.path.c_str());

    std::string target_path = s_prepare_assets_path(pack.path);

    AppPathManager::setCurrentAssetPack(pack.id, target_path);
    AppPath = AppPathManager::assetsRoot();
    g_AssetPackID = pack.full_id();

    XLanguage::findLanguages(); // find present translations
    ReloadTranslations(); // load translations

    if(!skip_gfx && !GFX.load())
    {
        GFX.unLoad();
        pLogWarning("Failed to load GFX from %s", AppPath.c_str());
        return false;
    }

    FontManager::initFull();

    return true;
}


bool ReloadAssetsFrom(const AssetPack_t& pack)
{
    const AssetPack_t* fallback_pack = nullptr;
    for(const AssetPack_t& pack : s_asset_packs)
    {
        if(pack.path == AppPath && pack.full_id() == g_AssetPackID)
        {
            fallback_pack = &pack;
            break;
        }
    }

    UnloadCustomGFX();
    UnloadWorldCustomGFX();

    GFX.unLoad();
    StopAllSounds();
    StopMusic();
    UnloadSound();
    FontManager::quit();

    if(!s_try_load_gfx(pack, false))
    {
        pLogWarning("Failed to load UI assets");

        // restore original GFX
        if(!fallback_pack || !s_try_load_gfx(*fallback_pack, false))
            pLogCritical("Could not reload graphics from previous path.");
        else
        {
            FontManager::initFull();
            InitSound(); // Restore sound effects
        }

        // also, remove from list of valid asset packs
        for(auto it = s_asset_packs.begin(); it != s_asset_packs.end(); ++it)
        {
            // find the requested pack exactly (by identity, not contents)
            if(&*it != &pack)
                continue;

            pLogInfo("Removed %s from asset pack list because it is missing UI assets", pack.path.c_str());
            s_asset_packs.erase(it);
            break;
        }

        return false;
    }

    g_dirEpisode.invalidate();
    g_dirCustom.invalidate();

    pLogDebug("Successfully loaded UI assets; now loading all other assets from [%s]", AppPath.c_str());

    MainLoadAll();
    return true;
}


bool InitUIAssetsFrom(const std::string& cmdline_id, bool skip_gfx)
{
    if(!s_found_asset_packs)
        s_find_asset_packs();

    // figure out exactly what is requested.
    std::string full_id = cmdline_id;
    std::string id_as_path = cmdline_id;
    if(full_id.empty())
    {
        full_id = g_recentAssetPack;
        pLogDebug("Trying to load most recent asset pack [ID: %s]", full_id.c_str());
    }
    else
    {
        appendSlash(id_as_path);
        pLogDebug("Trying to load CLI-specified asset pack [%s]", full_id.c_str());
    }

    // split full ID into ID and version
    std::string id = full_id;
    std::string version;

    auto slash_pos = id.find('/');

    if(slash_pos != std::string::npos)
    {
        version = id.substr(slash_pos + 1);
        id.resize(slash_pos);
    }

    // path-match, full-match, id-match, any
    for(int round = 0; round < 4; round++)
    {
        for(auto it = s_asset_packs.begin(); it != s_asset_packs.end(); /* ++it at bottom of loop */)
        {
            bool matched = false;
            if(round == 0)
                matched = (!cmdline_id.empty() && it->path == id_as_path);
            else if(round == 1)
                matched = (it->id == id && it->version == version);
            else if(round == 2 && (cmdline_id.empty() || slash_pos == std::string::npos))
                matched = (it->id == id);
            else
                matched = cmdline_id.empty();

            if(matched)
            {
                if(s_try_load_gfx(*it, skip_gfx))
                    return true;

                // failed to load, erase the failed asset pack and move on to next loop
                it = s_asset_packs.erase(it);
                continue;
            }

            ++it;
        }
    }

    if(!skip_gfx && !GFX.load())
        return false;

    return true;
}


const std::vector<AssetPack_t>& GetAssetPacks()
{
    if(!s_found_asset_packs)
        s_find_asset_packs();

    return s_asset_packs;
}


================================================
FILE: src/main/asset_pack.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef ASSET_PACK_H
#define ASSET_PACK_H

#include <string>
#include <vector>
#include <memory>

#include "std_picture.h"

// string ID of the current asset pack
extern std::string g_AssetPackID;

// true if any asset pack has been loaded yet
extern bool g_AssetsLoaded;

struct AssetPack_t
{
    struct Gfx
    {
        StdPicture logo;
        StdPicture icon;
        StdPicture background;

        int bg_frames = 1;
        int bg_frame_ticks = 8;
    };

    std::string id;
    std::string version;

    std::string path;

    std::unique_ptr<Gfx> gfx;

    bool show_id = false;
    bool show_version = false;
    bool logo_override = false;

    std::string full_id() const
    {
        if(id.empty() && version.empty())
            return "";
        else if(version.empty())
            return id;

        return id + "/" + version;
    }
};

//! reports currently discovered asset pack IDs
const std::vector<AssetPack_t>& GetAssetPacks();

//! changes the AppPath and reloads assets from a desired asset pack
bool ReloadAssetsFrom(const AssetPack_t& pack);

//! initalizes the AppPath and loads GFX from a desired asset pack
bool InitUIAssetsFrom(const std::string& id, bool skip_gfx = false);

#endif // #ifndef ASSET_PACK_H


================================================
FILE: src/main/block_table.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>
#include <sorting/pdqsort.h>

#include "layers.h"
#include "config.h"

#include "main/block_table.h"
#include "main/block_table.hpp"
#include "main/trees.h"

// all shared utility code for all item types
template<class ItemRef_t>
struct TableInterface
{
    table_t<ItemRef_t> common_table;
    table_t<ItemRef_t> layer_table[maxLayers+1];

    bool layer_table_active[maxLayers+1] = {false};
    int16_t active_tables[maxLayers+1] = {0};
    int num_active_tables = 0;

    // clears all tables and rejoins all layers
    void clear()
    {
        common_table.clear();

        for(int i = 0; i < maxLayers + 1; i++)
        {
            layer_table[i].clear();
            layer_table_active[i] = false;
        }

        num_active_tables = 0;
    }

    const std::vector<vbint_t>& layer_items(int layer);

    // checks if a layer is currently split from the main table
    bool active(int layer)
    {
        return layer_table_active[layer];
    }

    // splits a layer from the main table
    void split(int layer)
    {
        if(layer < 0 || layer == LAYER_NONE || layer_table_active[layer])
            return;

        layer_table_active[layer] = true;
        active_tables[num_active_tables] = layer;
        num_active_tables++;

        for(int i : layer_items(layer))
        {
            common_table.erase(i);
            layer_table[layer].insert_layer(i);
        }
    }

    // joins a layer to the main table
    void join(int layer)
    {
        if(layer < 0 || layer == LAYER_NONE || !layer_table_active[layer])
            return;

        layer_table_active[layer] = false;

        // remove from queue of active tables
        num_active_tables--;
        for(int i = 0; i < num_active_tables; i++)
        {
            if(active_tables[i] == layer)
            {
                active_tables[i] = active_tables[num_active_tables];
                break;
            }
        }

        for(int i : layer_items(layer))
        {
            common_table.insert(i);
        }

        layer_table[layer].clear();
    }

    void add(int layer, ItemRef_t item)
    {
        if(layer < 0 || layer == LAYER_NONE || !layer_table_active[layer])
            common_table.insert(item);
        else
            layer_table[layer].insert_layer(item);
    }

    void update(int layer, ItemRef_t item)
    {
        if(layer < 0 || layer == LAYER_NONE || !layer_table_active[layer])
            common_table.update(item);
        else
            layer_table[layer].update_layer(item);
    }

    void erase(int layer, ItemRef_t item)
    {
        if(layer < 0 || layer == LAYER_NONE || !layer_table_active[layer])
            common_table.erase(item);
        else
            layer_table[layer].erase(item);
    }

    inline void query(std::vector<BaseRef_t>& out, const Location_t& _loc, int sort_mode)
    {
        // ignore improper rects
        if(_loc.Width < 0 || _loc.Height < 0)
            return;

        rect_external loc;

        // NOTE: there are extremely rare cases when these margins are not sufficient for full compatibility
        //   (such as, when an item is trapped inside a wall during !BlocksSorted)
        // This should be fixed for players now.
        // Conversely, there may be cases where this is too much when BlocksSorted is true and an FLBlock query was made.
        if(g_config.emulate_classic_block_order)
            loc.query_from_loc_paranoid(_loc);
        else
        {
            int32_t l_int = num_t::floor(_loc.X);
            int32_t r_int = num_t::ceil(_loc.X + _loc.Width);
            int32_t t_int = num_t::floor(_loc.Y);
            int32_t b_int = num_t::ceil(_loc.Y + _loc.Height);

            // workaround to handle common block push behavior of NPCs -- if NPCs eventually use updatable queries, then we can simply use query_from_loc_standard as in other callsites
            if(r_int < l_int + 32)
                r_int = l_int + 32;

            // find which 64x64 tiles contain the query with a 2px margin in each direction
            loc.l = s_floor_div_64(l_int - 2);
            loc.r = s_floor_div_64(r_int + 2 + 63);
            loc.t = s_floor_div_64(t_int - 2);
            loc.b = s_floor_div_64(b_int + 2 + 63);
        }

        common_table.query(out, loc);

        // bigger offset for r/b because of layer offset rounding issues
        if(num_active_tables > 0)
        {
            loc.r += 1;
            loc.b += 1;

            for(int i = 0; i < num_active_tables; i++)
            {
                int layer = active_tables[i];

                int16_t offX = s_floor_div_64(num_t::floor(-Layer[layer].OffsetX));
                int16_t offY = s_floor_div_64(num_t::floor(-Layer[layer].OffsetY));

                rect_external layer_loc{(int16_t)(loc.l + offX), (int16_t)(loc.r + offX), (int16_t)(loc.t + offY), (int16_t)(loc.b + offY)};

                layer_table[layer].query(out, layer_loc);
            }
        }

        if(sort_mode == SORTMODE_COMPAT)
        {
            if(g_config.emulate_classic_block_order)
                sort_mode = SORTMODE_ID;
            else
                sort_mode = SORTMODE_LOC;
        }

        if(sort_mode == SORTMODE_LOC)
            pdqsort(out.begin(), out.end(), Comparisons::Loc<ItemRef_t>);
        else if(sort_mode == SORTMODE_ID)
            trees_sort_by_index(out);
        else if(sort_mode == SORTMODE_Z)
            pdqsort(out.begin(), out.end(), Comparisons::Z<ItemRef_t>);
    }

    void query(std::vector<BaseRef_t>& out, num_t Left, num_t Top, num_t Right, num_t Bottom,
               int sort_mode, num_t margin)
    {
        auto loc = newLoc(Left - margin,
                          Top - margin,
                          (Right - Left) + margin * 2,
                          (Bottom - Top) + margin * 2);

        query(out, loc, sort_mode);
    }

    TreeResult_Sentinel<ItemRef_t> query(Location_t loc,
                             int sort_mode)
    {
        TreeResult_Sentinel<ItemRef_t> result;

        query(*result.i_vec, loc, sort_mode);

        return result;
    }

    TreeResult_Sentinel<ItemRef_t> query(num_t Left, num_t Top, num_t Right, num_t Bottom,
                             int sort_mode, num_t margin)
    {
        auto loc = newLoc(Left - margin,
                          Top - margin,
                          (Right - Left) + margin * 2,
                          (Bottom - Top) + margin * 2);

        return query(loc, sort_mode);
    }
};

table_t<BlockRef_t> s_temp_block_table;
table_t<NPCRef_t> s_npc_table;
bool s_temp_blocks_enabled = false;


/* ================= Level blocks ================= */

template<>
const std::vector<vbint_t>& TableInterface<BlockRef_t>::layer_items(int layer)
{
    return Layer[layer].blocks;
}

TableInterface<BlockRef_t> s_block_tables;

void treeLevelCleanBlockLayers()
{
    s_block_tables.clear();
    s_temp_block_table.clear();
}

// checks if a layer is split from the main block table
bool treeBlockLayerActive(int layer)
{
    return s_block_tables.active(layer);
}

// splits a layer from the main block table
void treeBlockSplitLayer(int layer)
{
    s_block_tables.split(layer);
}

// joins a layer to the main block table
void treeBlockJoinLayer(int layer)
{
    s_block_tables.join(layer);
}

void treeBlockAddLayer(int layer, BlockRef_t block)
{
    s_block_tables.add(layer, block);
}

void treeBlockUpdateLayer(int layer, BlockRef_t block)
{
    s_block_tables.update(layer, block);
}

void treeBlockRemoveLayer(int layer, BlockRef_t block)
{
    s_block_tables.erase(layer, block);
}

TreeResult_Sentinel<BlockRef_t> treeFLBlockQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                         int sort_mode,
                         num_t margin)
{
    return s_block_tables.query(Left, Top, Right, Bottom, sort_mode, margin);
}

void treeFLBlockQuery(std::vector<BaseRef_t>& out, const Location_t &loc, int sort_mode)
{
    s_block_tables.query(out, loc, sort_mode);
}

TreeResult_Sentinel<BlockRef_t> treeFLBlockQuery(const Location_t &loc,
                         int sort_mode)
{
    return s_block_tables.query(loc, sort_mode);
}

/* ================= Temp blocks ================= */

static void s_NPCsToTempBlocks(std::vector<BaseRef_t>& out, size_t begin)
{
    for(size_t i = begin; i != out.size();)
    {
        // some NPCs' tempBlocks are at a different place than their location,
        // and those tempBlocks get added to the dedicated tree.

        const NPC_t& n = (NPCRef_t) out[i];
        if(!n.tempBlockInTree && n.tempBlock != 0 && n.tempBlock <= numBlock)
        {
            out[i] = n.tempBlock;
            ++i;
        }
        else
        {
            out[i] = out[out.size() - 1];
            out.resize(out.size() - 1);
        }
    }
}

static void s_NPCsToTempBlocks(std::vector<BaseRef_t>& out)
{
    s_NPCsToTempBlocks(out, 0);
}


void treeTempBlockEnable()
{
    s_temp_blocks_enabled = true;
}

void treeTempBlockFullClear()
{
    s_temp_block_table.clear();
    s_temp_blocks_enabled = false;
}

void treeTempBlockClear()
{
    s_temp_block_table.clear_light();
    s_temp_blocks_enabled = false;
}

void treeTempBlockAdd(BlockRef_t obj)
{
    if(!s_temp_blocks_enabled)
        return;

    s_temp_block_table.insert(obj);
}

void treeTempBlockUpdate(BlockRef_t obj)
{
    if(!s_temp_blocks_enabled)
        return;

    s_temp_block_table.update(obj);
}

void treeTempBlockRemove(BlockRef_t obj)
{
    if(!s_temp_blocks_enabled)
        return;

    s_temp_block_table.erase(obj);
}

void treeTempBlockQuery(std::vector<BaseRef_t>& out,
                        const Location_t &_loc,
                        int sort_mode)
{
    if(!s_temp_blocks_enabled)
        return;

    // ignore improper rects
    if(_loc.Width < 0 || _loc.Height < 0)
        return;

    rect_external loc;

    // NOTE: there are extremely rare cases when these margins are not sufficient for full compatibility
    //   (such as, when an item is trapped inside a wall during !BlocksSorted)
    if(g_config.emulate_classic_block_order)
        loc.query_from_loc_paranoid(_loc);
    else
        loc.query_from_loc_standard(_loc);


    s_npc_table.query(out, loc);

    s_NPCsToTempBlocks(out);

    // this table is empty unless an NPC crossed a boundary during this frame
    if(s_temp_block_table.member_rects.size() != 0)
        s_temp_block_table.query(out, loc);


    if(sort_mode == SORTMODE_COMPAT)
    {
        if(g_config.emulate_classic_block_order)
            sort_mode = SORTMODE_ID;
        else
            sort_mode = SORTMODE_LOC;
    }

    if(sort_mode == SORTMODE_LOC)
        pdqsort(out.begin(), out.end(), Comparisons::Loc<BlockRef_t>);
    else if(sort_mode == SORTMODE_ID)
        trees_sort_by_index(out);
    else if(sort_mode == SORTMODE_Z)
        pdqsort(out.begin(), out.end(), Comparisons::Z<BlockRef_t>);
}

TreeResult_Sentinel<BlockRef_t> treeTempBlockQuery(const Location_t &_loc,
                        int sort_mode)
{
    TreeResult_Sentinel<BlockRef_t> result;

    treeTempBlockQuery(*result.i_vec, _loc, sort_mode);

    return result;
}

TreeResult_Sentinel<BlockRef_t> treeTempBlockQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                         int sort_mode,
                         num_t margin)
{
    auto loc = newLoc(Left - margin,
                      Top - margin,
                      (Right - Left) + margin * 2,
                      (Bottom - Top) + margin * 2);

    return treeTempBlockQuery(loc, sort_mode);
}

/* ================= Combined Block Query ============== */

TreeResult_Sentinel<BlockRef_t> treeBlockQuery(const Location_t &_loc,
                         int sort_mode)
{
    TreeResult_Sentinel<BlockRef_t> result;

    // ignore improper rects
    if(_loc.Width < 0 || _loc.Height < 0)
        return result;

    Location_t loc = _loc;

    // NOTE: there are extremely rare cases when these margins are not sufficient for full compatibility
    //   (such as, when an item is trapped inside a wall during !BlocksSorted)
    if(g_config.emulate_classic_block_order)
    {
        loc.X -= 32;
        loc.Y -= 32;
        loc.Width += 64;
        loc.Height += 64;
    }
    else
    {
        loc.X -= 2;
        loc.Y -= 2;
        loc.Width += 4;
        loc.Height += 4;
    }


    s_block_tables.common_table.query(*result.i_vec, loc);

    num_t oX = loc.X;
    num_t oY = loc.Y;

    for(int i = 0; i < s_block_tables.num_active_tables; i++)
    {
        int layer = s_block_tables.active_tables[i];

        loc.X -= Layer[layer].OffsetX;
        loc.Y -= Layer[layer].OffsetY;

        s_block_tables.layer_table[layer].query(*result.i_vec, loc);

        loc.X = oX;
        loc.Y = oY;
    }


    // this is where this function differs from the standard TableInterface::query
    if(s_temp_blocks_enabled)
    {
        auto pre_temp_size = result.i_vec->size();

        s_npc_table.query(*result.i_vec, loc);

        s_NPCsToTempBlocks(*result.i_vec, pre_temp_size);

        s_temp_block_table.query(*result.i_vec, loc);
    }


    if(sort_mode == SORTMODE_COMPAT)
    {
        if(g_config.emulate_classic_block_order)
            sort_mode = SORTMODE_ID;
        else
            sort_mode = SORTMODE_LOC;
    }

    if(sort_mode == SORTMODE_LOC)
        pdqsort(result.i_vec->begin(), result.i_vec->end(), Comparisons::Loc<BlockRef_t>);
    else if(sort_mode == SORTMODE_ID)
        trees_sort_by_index(*result.i_vec);
    else if(sort_mode == SORTMODE_Z)
        pdqsort(result.i_vec->begin(), result.i_vec->end(), Comparisons::Z<BlockRef_t>);

    return result;
}

/* ================= Level Backgrounds ================= */

template<>
const std::vector<vbint_t>& TableInterface<BackgroundRef_t>::layer_items(int layer)
{
    return Layer[layer].BGOs;
}

TableInterface<BackgroundRef_t> s_background_tables;

void treeLevelCleanBackgroundLayers()
{
    s_background_tables.clear();
}

// checks if a layer is split from the main background table
bool treeBackgroundLayerActive(int layer)
{
    return s_background_tables.active(layer);
}

// splits a layer from the main Background table
void treeBackgroundSplitLayer(int layer)
{
    s_background_tables.split(layer);
}

// joins a layer to the main Background table
void treeBackgroundJoinLayer(int layer)
{
    s_background_tables.join(layer);
}

void treeBackgroundAddLayer(int layer, BackgroundRef_t obj)
{
    s_background_tables.add(layer, obj);
}

void treeBackgroundUpdateLayer(int layer, BackgroundRef_t obj)
{
    s_background_tables.update(layer, obj);
}

void treeBackgroundRemoveLayer(int layer, BackgroundRef_t obj)
{
    s_background_tables.erase(layer, obj);
}

TreeResult_Sentinel<BackgroundRef_t> treeBackgroundQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                         int sort_mode,
                         num_t margin)
{
    return s_background_tables.query(Left, Top, Right, Bottom, sort_mode, margin);
}

void treeBackgroundQuery(std::vector<BaseRef_t>& out, const Location_t &loc, int sort_mode)
{
    s_background_tables.query(out, loc, sort_mode);
}

TreeResult_Sentinel<BackgroundRef_t> treeBackgroundQuery(const Location_t &loc, int sort_mode)
{
    return s_background_tables.query(loc, sort_mode);
}


/* ================= Level NPCs ================= */

void treeNPCClear()
{
    s_npc_table.clear();
}

void treeNPCAdd(NPCRef_t obj)
{
    s_npc_table.insert(obj);
}

bool treeNPCUpdate(NPCRef_t obj)
{
    SDL_assert_release((int)obj > 0);

    return s_npc_table.update(obj);
}

void treeNPCSplitTempBlock(NPCRef_t obj)
{
    if(!obj->tempBlockInTree)
    {
        obj->tempBlockInTree = true;
        treeTempBlockAdd(obj->tempBlock);
    }
}

void treeNPCUpdateTempBlock(NPCRef_t obj)
{
    if(!obj->tempBlockInTree)
    {
        obj->tempBlockInTree = true;
        treeTempBlockAdd(obj->tempBlock);
    }
    else
    {
        treeTempBlockUpdate(obj->tempBlock);
    }
}

void treeNPCRemove(NPCRef_t obj)
{
    s_npc_table.erase(obj);
}

void treeNPCQuery(std::vector<BaseRef_t>& out, const Location_t &_loc, int sort_mode)
{
    // ignore improper rects
    if(_loc.Width < 0 || _loc.Height < 0)
        return;

    rect_external loc;

    // NOTE: there are extremely rare cases when these margins are not sufficient for full compatibility
    //   (such as, when an item is trapped inside a wall during !BlocksSorted)
    if(g_config.emulate_classic_block_order)
        loc.query_from_loc_paranoid(_loc);
    else
        loc.query_from_loc_standard(_loc);

    s_npc_table.query(out, loc);

    if(sort_mode == SORTMODE_COMPAT)
        sort_mode = SORTMODE_ID;

    if(sort_mode == SORTMODE_LOC)
        pdqsort(out.begin(), out.end(), Comparisons::Loc<NPCRef_t>);
    else if(sort_mode == SORTMODE_ID)
        trees_sort_by_index(out);
    else if(sort_mode == SORTMODE_Z)
        pdqsort(out.begin(), out.end(), Comparisons::Z<NPCRef_t>);
}

TreeResult_Sentinel<NPCRef_t> treeNPCQuery(const Location_t &_loc,
                         int sort_mode)
{
    TreeResult_Sentinel<NPCRef_t> result;

    treeNPCQuery(*result.i_vec, _loc, sort_mode);

    return result;
}

TreeResult_Sentinel<NPCRef_t> treeNPCQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                         int sort_mode,
                         num_t margin)
{
    auto loc = newLoc(Left - margin,
                      Top - margin,
                      (Right - Left) + margin * 2,
                      (Bottom - Top) + margin * 2);

    return treeNPCQuery(loc, sort_mode);
}


/* ================= Level PEZs ================= */

template<>
const std::vector<vbint_t>& TableInterface<WaterRef_t>::layer_items(int layer)
{
    return Layer[layer].waters;
}

TableInterface<WaterRef_t> s_water_tables;

void treeLevelCleanWaterLayers()
{
    s_water_tables.clear();
}

// checks if a layer is split from the main Water table
bool treeWaterLayerActive(int layer)
{
    return s_water_tables.active(layer);
}

// splits a layer from the main Water table
void treeWaterSplitLayer(int layer)
{
    s_water_tables.split(layer);
}

// joins a layer to the main Water table
void treeWaterJoinLayer(int layer)
{
    s_water_tables.join(layer);
}

void treeWaterAddLayer(int layer, WaterRef_t obj)
{
    s_water_tables.add(layer, obj);
}

void treeWaterUpdateLayer(int layer, WaterRef_t obj)
{
    s_water_tables.update(layer, obj);
}

void treeWaterRemoveLayer(int layer, WaterRef_t obj)
{
    s_water_tables.erase(layer, obj);
}

TreeResult_Sentinel<WaterRef_t> treeWaterQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                         int sort_mode,
                         num_t margin)
{
    if(numWater == 0)
    {
        TreeResult_Sentinel<WaterRef_t> empty;
        return empty;
    }

    return s_water_tables.query(Left, Top, Right, Bottom, sort_mode, margin);
}

TreeResult_Sentinel<WaterRef_t> treeWaterQuery(const Location_t &loc,
                         int sort_mode)
{
    if(numWater == 0)
    {
        TreeResult_Sentinel<WaterRef_t> empty;
        return empty;
    }

    return s_water_tables.query(loc, sort_mode);
}


================================================
FILE: src/main/block_table.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef BLOCK_TABLE_H
#define BLOCK_TABLE_H

#include "globals.h"

void treeBlockUpdateLayer(int layer, BlockRef_t block);
bool treeBlockLayerActive(int layer);
void treeBlockJoinLayer(int layer);
void treeBlockSplitLayer(int layer);

void treeBackgroundUpdateLayer(int layer, BackgroundRef_t block);
bool treeBackgroundLayerActive(int layer);
void treeBackgroundJoinLayer(int layer);
void treeBackgroundSplitLayer(int layer);

void treeWaterUpdateLayer(int layer, WaterRef_t block);
bool treeWaterLayerActive(int layer);
void treeWaterJoinLayer(int layer);
void treeWaterSplitLayer(int layer);

#endif // #ifndef BLOCK_TABLE_H


================================================
FILE: src/main/block_table.hpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef BLOCK_TABLE_IMPL_HPP
#define BLOCK_TABLE_IMPL_HPP

#include <iterator>
#include <array>
#include <set>
#include <unordered_map>

#include "globals.h"
#include "layers.h"
#include "npc_traits.h"

#include "sdl_proxy/sdl_stdinc.h"

static inline int32_t s_floor_div_32(int32_t x)
{
    static_assert(((-1) >> 5) == -1 && (31 >> 5) == 0 && (-3232 >> 5) == -101, "block_table.hpp requires signed right shift to have floor semantics");
    return (int16_t)(x >> 5);
}

static inline int32_t s_floor_div_64(int32_t x)
{
    static_assert(((-1) >> 6) == -1 && (63 >> 6) == 0 && (-6464 >> 6) == -101, "block_table.hpp requires signed right shift to have floor semantics");
    return (int16_t)(x >> 6);
}

enum ContinuedRect
{
    CONT_NONE = 0,
    CONT_X = 1,
    CONT_Y = 2,
    CONT_XY = CONT_X | CONT_Y,
};

struct AugBaseRef_t
{
    BaseRef_t ref;
    uint8_t cont_axes;
};

struct node_t
{
    // not safe to change this
    static constexpr int node_size = 4;

    node_t* next = nullptr;
    int16_t refs[node_size];
    uint8_t filled = 0;
    uint8_t cont_axes = 0;

    inline node_t()
    {
        next = nullptr;
        filled = 0;
        cont_axes = 0;
    }

    inline ~node_t()
    {
        if(next)
            delete next;
    }

    struct iterator
    {
        node_t* parent;
        uint16_t i;

        constexpr inline iterator(std::nullptr_t parent) : parent(parent), i(0) {}

        inline void check_linkage()
        {
            while(this->parent && this->i == this->parent->filled)
            {
                this->parent = this->parent->next;
                this->i = 0;
            }
        }

        inline iterator(node_t* parent, size_t i): parent(parent), i((uint16_t)i)
        {
            this->check_linkage();
        }

        inline iterator operator++()
        {
            if(this->parent)
            {
                this->i++;
                if(this->i == this->parent->filled)
                {
                    this->parent = this->parent->next;
                    this->i = 0;
                    this->check_linkage();
                }
            }
            return *this;
        }

        inline bool operator!=(const iterator& other) const
        {
            return this->parent != other.parent || this->i != other.i;
        }

        inline AugBaseRef_t operator*() const
        {
            return {this->parent->refs[this->i], (uint8_t)((this->parent->cont_axes >> (this->i * 2)) & 3)};
        }
    };

    inline iterator begin()
    {
        return iterator(this, 0);
    }

    static constexpr inline iterator end()
    {
        return iterator(nullptr);
    }

    inline void insert(AugBaseRef_t b)
    {
        if(this->filled < node_size)
        {
            this->refs[this->filled] = b.ref;
            this->cont_axes |= (b.cont_axes & 3) << (this->filled * 2);
            this->filled++;
        }
        else
        {
            if(!this->next)
                this->next = new node_t;
            this->next->insert(b);
        }
    }

    inline void erase(iterator& it)
    {
        it.parent->filled--;
        it.parent->refs[it.i] = it.parent->refs[it.parent->filled];
        it.parent->cont_axes &= ~(3 << (it.i * 2));
        it.parent->cont_axes |= ((it.parent->cont_axes >> (it.parent->filled * 2)) & 3) << (it.i * 2);
        it.parent->cont_axes &= ~(3 << (it.parent->filled * 2));
    }

    inline void erase(BaseRef_t o)
    {
        iterator it = this->begin();

        while(it != this->end())
        {
            if((*it).ref == o)
                break;
            ++it;
        }

        if(it != this->end())
            this->erase(it);
    }
};

struct AugLoc_t
{
    int16_t x, y;
    uint8_t cont_axes;
};

struct rect_internal
{
    int16_t t, l, b, r;
    uint8_t cont_axes;

    class iterator
    {
        friend struct rect_internal;
    private:
        const rect_internal& parent;
        AugLoc_t cur_loc;

    public:
        inline iterator(const rect_internal& parent, AugLoc_t cur_loc): parent(parent), cur_loc(cur_loc)
        {}

        inline iterator operator++()
        {
            this->cur_loc.y++;
            this->cur_loc.cont_axes |= CONT_Y;

            if(this->cur_loc.y == this->parent.b)
            {
                this->cur_loc.x++;

                if(this->cur_loc.x != this->parent.r)
                {
                    // CONT_X for certain, CONT_Y if it's set by the parent
                    this->cur_loc.cont_axes = CONT_X | this->parent.cont_axes;
                    this->cur_loc.y = this->parent.t;
                }
            }

            return *this;
        }

        inline bool operator!=(const iterator& end) const
        {
            // only check for inequality on X axis; that signals iteration is over
            return this->cur_loc.x != end.cur_loc.x;
        }

        inline const AugLoc_t& operator*() const
        {
            return cur_loc;
        }
    };

    inline iterator begin() const
    {
        iterator ret(*this, {l, t, cont_axes});

        // if range is empty, return end instead
        if(t == b)
            ret.cur_loc.x = r;

        return ret;
    }

    inline iterator end() const
    {
        return iterator(*this, {r, b, CONT_XY});
    }
};

struct rect_external
{
    int16_t l, r, t, b;

    rect_external() {}

    rect_external(int16_t l, int16_t r, int16_t t, int16_t b) : l(l), r(r), t(t), b(b) {}

    rect_external(const Location_t& loc)
    {
        // find which 64x64 tiles contain the object
        l = s_floor_div_64((int32_t)num_t::floor(loc.X));
        r = s_floor_div_64((int32_t)num_t::ceil(loc.X + loc.Width) + 63);
        t = s_floor_div_64((int32_t)num_t::floor(loc.Y));
        b = s_floor_div_64((int32_t)num_t::ceil(loc.Y + loc.Height) + 63);
    }

    void query_from_loc_paranoid(const Location_t& loc)
    {
        // find which 64x64 tiles contain the query with a 32px margin in each direction
        l = s_floor_div_64((int32_t)num_t::floor(loc.X) - 32);
        r = s_floor_div_64((int32_t)num_t::ceil(loc.X + loc.Width) + 32 + 63);
        t = s_floor_div_64((int32_t)num_t::floor(loc.Y) - 32);
        b = s_floor_div_64((int32_t)num_t::ceil(loc.Y + loc.Height) + 32 + 63);
    }

    void query_from_loc_standard(const Location_t& loc)
    {
        // find which 64x64 tiles contain the query with a 2px margin in each direction
        l = s_floor_div_64((int32_t)num_t::floor(loc.X) - 2);
        r = s_floor_div_64((int32_t)num_t::ceil(loc.X + loc.Width) + 2 + 63);
        t = s_floor_div_64((int32_t)num_t::floor(loc.Y) - 2);
        b = s_floor_div_64((int32_t)num_t::ceil(loc.Y + loc.Height) + 2 + 63);
    }
};

// a screen is 2048x2048.
// it's made up of node_t's, which are 64x64 each.
struct screen_t
{
    std::array<node_t, 1024> nodes;

    screen_t()
    {}

    void query(std::vector<BaseRef_t>& out, const rect_internal& rect)
    {
        for(const AugLoc_t& loc : rect)
        {
            for(AugBaseRef_t obj : nodes[loc.x * 32 + loc.y])
            {
                // only want objs that are new on all continued axes
                if((obj.cont_axes & loc.cont_axes) == CONT_NONE)
                    out.push_back(obj.ref);
            }
        }
    }

    void insert(BaseRef_t obj, const rect_internal& rect)
    {
        for(const AugLoc_t& loc : rect)
            nodes[loc.x * 32 + loc.y].insert({obj, loc.cont_axes});
    }

    void erase(BaseRef_t obj, const rect_internal& rect)
    {
        for(const AugLoc_t& loc : rect)
            nodes[loc.x * 32 + loc.y].erase(obj);
    }
};

template<class MyRef_t>
inline Location_t extract_loc(MyRef_t obj)
{
    return static_cast<Location_t>(obj->Location);
}

template<>
inline Location_t extract_loc(WorldLevelRef_t obj)
{
    return obj->LocationOnscreen();
}

template<>
inline Location_t extract_loc(NPCRef_t obj)
{
    Location_t ret = obj->Location;

    if(ret.Height < NPCHeight(obj->Type))
        ret.Height = NPCHeight(obj->Type);
    else if(ret.Height <= 0)
        ret.Height = 1;

    if(ret.Width < NPCWidthGFX(obj->Type))
    {
        ret.X -= (NPCWidthGFX(obj->Type) - ret.Width) / 2;
        ret.Width = NPCWidthGFX(obj->Type);
    }
    else if(ret.Width <= 0)
        ret.Width = 1;

    // for tempBlock queries
    if(obj->Type == NPCID_SPRING)
    {
        ret.Y -= 16;
        ret.Height += 16;
    }

    return ret;
}

template<class MyRef_t>
inline Location_t extract_loc_layer(MyRef_t obj)
{
    Location_t loc = static_cast<Location_t>(obj->Location);

    if(obj->Layer != LAYER_NONE)
    {
        loc.X -= Layer[obj->Layer].OffsetX;
        loc.Y -= Layer[obj->Layer].OffsetY;
    }

    return loc;
}

// it's a bunch of stacks of screens, which are 2048x2048.
// will be reallocated as needed
struct base_table_t
{
    typedef std::vector<screen_t*> screen_ptr_arr_t;
    std::vector<screen_ptr_arr_t> columns;
    std::vector<int> col_first_row_index;
    std::unordered_map<BaseRef_t, rect_external> member_rects;
    int first_col_index;

    ~base_table_t()
    {
        clear();
    }

protected:
    void insert(BaseRef_t b, const rect_external& rect)
    {
        int lcol = s_floor_div_32(rect.l); // each column contains 32 cells
        int rcol = s_floor_div_32(rect.r + 31); // ceiling, this column won't get checked

        int trow = s_floor_div_32(rect.t);
        int brow = s_floor_div_32(rect.b + 31);

        if(columns.size() == 0)
        {
            columns.emplace_back(screen_ptr_arr_t());
            col_first_row_index.resize(1);
            first_col_index = lcol;
        }

        if(lcol < first_col_index)
        {
            int to_add = first_col_index - lcol;
            for(int i = 0; i < to_add; i++)
                columns.emplace_back(screen_ptr_arr_t());

            std::rotate(columns.rbegin(), columns.rbegin() + to_add, columns.rend());

            col_first_row_index.resize(columns.size() + to_add);
            std::rotate(col_first_row_index.rbegin(), col_first_row_index.rbegin() + to_add, col_first_row_index.rend());

            first_col_index = lcol;
        }

        if(rcol > first_col_index + (int)columns.size())
        {
            for(int i = first_col_index + (int)columns.size(); i < rcol; i++)
                columns.emplace_back(screen_ptr_arr_t());

            col_first_row_index.resize(rcol - first_col_index);
        }

        rect_internal inner_rect;

        inner_rect.l = rect.l - lcol * 32;
        inner_rect.r = 32;
        inner_rect.cont_axes = CONT_NONE;

        for(int col = lcol; col < rcol; col++)
        {
            int internal_col = col - first_col_index;

            if(col == rcol - 1)
                inner_rect.r = rect.r - (rcol - 1) * 32;

            if(columns[internal_col].size() == 0)
            {
                columns[internal_col].push_back(new screen_t);
                col_first_row_index[internal_col] = trow;
            }

            if(trow < col_first_row_index[internal_col])
            {
                int to_add = col_first_row_index[internal_col] - trow;
                for(int i = 0; i < to_add; i++)
                    columns[internal_col].push_back(new screen_t);
                std::rotate(columns[internal_col].rbegin(), columns[internal_col].rbegin() + to_add, columns[internal_col].rend());
                col_first_row_index[internal_col] = trow;
            }

            if(brow > col_first_row_index[internal_col] + (int)columns[internal_col].size())
            {
                for(int i = col_first_row_index[internal_col] + (int)columns[internal_col].size(); i < brow; i++)
                    columns[internal_col].push_back(new screen_t);
            }

            inner_rect.t = rect.t - trow * 32;
            inner_rect.b = 32;

            for(int row = trow; row < brow; row++)
            {
                int internal_row = row - col_first_row_index[internal_col];

                if(row == brow - 1)
                    inner_rect.b = rect.b - (brow - 1) * 32;

                columns[internal_col][internal_row]->insert(b, inner_rect);

                inner_rect.t = 0;
                inner_rect.cont_axes |= CONT_Y;
            }

            inner_rect.l = 0;
            inner_rect.cont_axes = CONT_X;
        }
    }

    void erase(BaseRef_t b, const rect_external& rect)
    {
        int lcol = s_floor_div_32(rect.l); // each column contains 32 cells
        int rcol = s_floor_div_32(rect.r + 31); // ceiling, this column won't get checked

        int trow = s_floor_div_32(rect.t);
        int brow = s_floor_div_32(rect.b + 31);

        int lcol_check = SDL_max(lcol, first_col_index);
        int rcol_check = SDL_min(rcol, first_col_index + (int)columns.size());

        rect_internal inner_rect;

        // initialize l/r bounds of inner query rect
        inner_rect.l = rect.l - lcol * 32;
        inner_rect.r = 32;
        inner_rect.cont_axes = CONT_NONE;

        if(lcol_check != lcol)
        {
            inner_rect.l = 0;
            inner_rect.cont_axes = CONT_X;
        }

        for(int col = lcol_check; col < rcol_check; col++)
        {
            int internal_col = col - first_col_index;

            // it's 32 until this point
            if(col == rcol - 1)
                inner_rect.r = rect.r - (rcol - 1) * 32;

            // initialize t/b bounds of inner query rect
            inner_rect.t = rect.t - trow * 32;
            inner_rect.b = 32;

            int trow_check = SDL_max(trow, col_first_row_index[internal_col]);
            int brow_check = SDL_min(brow, col_first_row_index[internal_col] + (int)columns[internal_col].size());
            if(trow_check != trow)
            {
                inner_rect.t = 0;
                inner_rect.cont_axes |= CONT_Y;
            }

            for(int row = trow_check; row < brow_check; row++)
            {
                int internal_row = row - col_first_row_index[internal_col];

                if(row == brow - 1)
                    inner_rect.b = rect.b - (brow - 1) * 32;

                columns[internal_col][internal_row]->erase(b, inner_rect);

                inner_rect.t = 0;
                inner_rect.cont_axes |= CONT_Y;
            }

            inner_rect.l = 0;
            inner_rect.cont_axes = CONT_X;
        }
    }

public:
    void query(std::vector<BaseRef_t>& out, const rect_external& rect)
    {
        if(columns.size() == 0 || member_rects.size() == 0)
            return;

        int lcol = s_floor_div_32(rect.l); // each column contains 32 cells
        int rcol = s_floor_div_32(rect.r + 31); // ceiling, this column won't get checked

        int trow = s_floor_div_32(rect.t);
        int brow = s_floor_div_32(rect.b + 31);

        int lcol_check = SDL_max(lcol, first_col_index);
        int rcol_check = SDL_min(rcol, first_col_index + (int)columns.size());

        rect_internal inner_rect;

        // initialize l/r bounds of inner query rect
        inner_rect.l = rect.l - lcol * 32;
        inner_rect.r = 32;
        inner_rect.cont_axes = CONT_NONE;

        if(lcol_check != lcol)
        {
            inner_rect.l = 0;
            inner_rect.cont_axes = CONT_X;
        }

        for(int col = lcol_check; col < rcol_check; col++)
        {
            int internal_col = col - first_col_index;

            if(columns[internal_col].size() == 0)
            {
                inner_rect.l = 0;
                inner_rect.cont_axes = CONT_X;
                continue;
            }

            // it's 32 until this point
            if(col == rcol - 1)
                inner_rect.r = rect.r - (rcol - 1) * 32;

            // initialize t/b bounds of inner query rect
            inner_rect.t = rect.t - trow * 32;
            inner_rect.b = 32;

            int trow_check = SDL_max(trow, col_first_row_index[internal_col]);
            int brow_check = SDL_min(brow, col_first_row_index[internal_col] + (int)columns[internal_col].size());
            if(trow_check != trow)
            {
                inner_rect.t = 0;
                inner_rect.cont_axes |= CONT_Y;
            }

            for(int row = trow_check; row < brow_check; row++)
            {
                int internal_row = row - col_first_row_index[internal_col];

                if(row == brow - 1)
                    inner_rect.b = rect.b - (brow - 1) * 32;

                columns[internal_col][internal_row]->query(out, inner_rect);

                inner_rect.t = 0;
                inner_rect.cont_axes |= CONT_Y;
            }

            inner_rect.l = 0;
            inner_rect.cont_axes = CONT_X;
        }
    }

    void clear()
    {
        // can optimize later
        for(auto col : columns)
        {
            for(screen_t* screen : col)
                delete screen;
        }

        columns.clear();
        col_first_row_index.clear();
        member_rects.clear();
    }

    void clear_light()
    {
        for(const auto& p : member_rects)
            base_table_t::erase(p.first, p.second);

        member_rects.clear();
    }
};

template<class MyRef_t>
struct table_t : public base_table_t
{
    void insert(MyRef_t b)
    {
        Location_t loc = extract_loc<MyRef_t>(b);

        // ignore improper rects
        if(loc.Width < 0 || loc.Height < 0)
            return;

        rect_external rect(loc);
        member_rects[b] = rect;
        base_table_t::insert(b, rect);
    }

    void insert_layer(MyRef_t b)
    {
        Location_t loc = extract_loc_layer<MyRef_t>(b);

        // ignore improper rects
        if(loc.Width < 0 || loc.Height < 0)
            return;

        rect_external rect(loc);
        member_rects[b] = rect;
        base_table_t::insert(b, rect);
    }

    void erase(MyRef_t b)
    {
        auto it = member_rects.find(b);
        if(it == member_rects.end())
            return;

        base_table_t::erase(b, it->second);
        member_rects.erase(it);
    }

    bool update(MyRef_t b)
    {
        Location_t loc = extract_loc<MyRef_t>(b);

        rect_external rect(loc);

        auto it = member_rects.find(b);
        if(it != member_rects.end())
        {
            // no-change optimization
            if(it->second.l == rect.l
                && it->second.r == rect.r
                && it->second.t == rect.t
                && it->second.b == rect.b)
            {
                return false;
            }

            base_table_t::erase(b, it->second);
        }

        // ignore improper rects
        if(loc.Width < 0 || loc.Height < 0)
            return true;

        member_rects[b] = rect;
        base_table_t::insert(b, rect);

        return true;
    }

    void update_layer(MyRef_t b)
    {
        auto it = member_rects.find(b);
        if(it != member_rects.end())
            base_table_t::erase(b, it->second);

        insert_layer(b);
    }
};

inline void trees_sort_by_index(std::vector<BaseRef_t>& i_vec)
{
    pdqsort(i_vec.begin(), i_vec.end(),
        [](BaseRef_t a, BaseRef_t b) {
            return a < b;
        });
}

#endif // #ifndef BLOCK_TABLE_IMPL_HPP


================================================
FILE: src/main/cheat_code.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <vector>

#ifdef ENABLE_ANTICHEAT_TRAP
#include "core/msgbox.h"
#include "core/render.h"
#include "core/events.h"
#endif

#include "sdl_proxy/sdl_stdinc.h"

#include <Logger/logger.h>
#ifdef ENABLE_ANTICHEAT_TRAP
#include <pge_delay.h>
#endif

#include "globals.h"
#include "sound.h"
#include "graphics.h"
#include "collision.h"
#include "effect.h"
#include "player.h"
#include "npc.h"
#include "layers.h"
#include "controls.h"
#include "game_main.h"
#include "change_res.h"
#include "config.h"
#ifdef ENABLE_ANTICHEAT_TRAP
#include "editor.h" // For the `Backup_FullFileName` only
#endif
#include "frm_main.h"

#include "core/render.h"

#include "npc/npc_queues.h"

#include "main/game_info.h"
#include "main/screen_quickreconnect.h"
#include "main/screen_textentry.h"

#include "main/trees.h"

#include "main/cheat_code.h"

#include "npc_id.h"
#include "npc_traits.h"
#include "eff_id.h"

bool g_ForceBitmaskMerge = false;
bool g_CheatLogicScreen = false;
int g_CheatEditYourFriends = 0;

static void redigitIsCool()
{
    PlaySound(SFX_SMCry);
    Cheater = false;
}


#ifdef ENABLE_ANTICHEAT_TRAP
static void dieCheater()
{
    if(LevelEditor || WorldEditor || BattleMode || TestLevel || !Backup_FullFileName.empty())
    {
        // Don't perform the punish when running a level test or the editor
        redigitIsCool();
        return;
    }

    pLogCritical("redigitiscool code was been used, player got a punish!");
    PlaySound(SFX_SMExplosion);
    Score = 0; // Being very evil here, mu-ha-ha-ha-ha! >:D
    Lives = 0;
    g_100s = 0;
    Coins = 0;
    GodMode = false;
    ClearGame(true); // As a penalty, remove the saved game
    Cheater = true;
    CheaterMustDie = true;
    cheats_clearBuffer();

    if(!LevelSelect)
    {
        MessageText = "       Die, cheater!       "
                      "Now play the game all over "
                      "    from the beginning!    "
                      "                           "
                      "     Time to be evil!      "
                      "      Mu-ha-ha-ha-ha!      ";
        PauseGame(PauseCode::Message);
        MessageText.clear();
    }
    else
    {
        XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR,
                              "Die, cheater!",
                              "       Die, cheater!       \n"
                              "Now play the game all over \n"
                              "    from the beginning!    \n"
                              "                           \n"
                              "     Time to be evil!      \n"
                              "      Mu-ha-ha-ha-ha!      ");
    }

    for(int A = 1; A <= numPlayers; ++A)
    {
        Player[A].State = 0;
        Player[A].Hearts = 1;
        if(!LevelSelect)
            PlayerHurt(A);
        else
            KillPlayer(A);
    }

    if(LevelSelect)
    {
        LevelSelect = false;
        GameMenu = true;
        MenuMode = 0;
        MenuCursor = 0;
        XRender::clearBuffer();
        XRender::repaint();
        StopMusic();
        XEvents::doEvents();

        if(!g_config.unlimited_framerate)
            PGE_Delay(500);
    }
}
#endif



/* -----------------------------------*
 *      World map only cheats         *
 *------------------------------------*/

/*!
 * \brief Open all paths
 */
static void moonWalk()
{
    TinyLocation_t tempLocation;

    for(int B = 1; B <= numWorldPaths; B++)
    {
        tempLocation = WorldPath[B].Location;
        tempLocation.X += 4;
        tempLocation.Y += 4;
        tempLocation.Width -= 8;
        tempLocation.Height -= 8;
        WorldPath[B].Active = true;

        for(int C = 1; C <= numScenes; C++)
        {
            if(CheckCollision(tempLocation, Scene[C].Location))
                Scene[C].Active = false;
        }
    }

    for(int B = 1; B <= numWorldLevels; B++)
        WorldLevel[B].Active = true;

    PlaySound(SFX_NewPath);
}

/*!
 * \brief Opens all exits for current world level
 */
static void openSesame()
{
    bool found = false;

    for(WorldLevel_t &lev : treeWorldLevelQuery(WorldPlayer[1].Location, SORTMODE_ID))
    {
        if(CheckCollision(WorldPlayer[1].Location, lev.Location))
        {
            found = true;

            for(int A = 1; A <= 4; A++)
                LevelPath(lev, A);
        }
    }

    if(!found)
        PlaySound(SFX_BlockHit);
}

/*!
 * \brief Allow player walk everywhere
 */
static void illParkWhereIWant()
{
    if(WalkAnywhere)
    {
        WalkAnywhere = false;
        PlaySound(SFX_PlayerShrink);
    }
    else
    {
        WalkAnywhere = true;
        PlaySound(SFX_PlayerGrow);
    }
}


/* -----------------------------------*
 *        Level only cheats           *
 *------------------------------------*/


static void fairyMagic()
{
    if(Player[1].Fairy)
    {
        for(int B = 1; B <= numPlayers; B++)
        {
            PlaySound(SFX_HeroFairy);
            Player[B].Immune = 10;
            Player[B].Effect = PLREFF_WAITING;
            Player[B].Effect2 = 4;
            Player[B].Fairy = false;
            Player[B].FairyTime = 0;
            SizeCheck(Player[B]);
            NewEffect(EFFID_SMOKE_S5, Player[B].Location);
        }
    }
    else
    {
        for(int B = 1; B <= numPlayers; B++)
        {
            PlaySound(SFX_HeroFairy);
            Player[B].Immune = 10;
            Player[B].Effect = PLREFF_WAITING;
            Player[B].Effect2 = 4;
            Player[B].Fairy = true;
            Player[B].FairyTime = -1;
            SizeCheck(Player[B]);
            NewEffect(EFFID_SMOKE_S5, Player[B].Location);
        }
    }
}

static void iceAge()
{
    for(int C : NPCQueues::Active.may_insert_erase)
    {
        if(NPC[C].Active)
        {
            if(!NPC[C]->NoIceBall && NPC[C].Type != NPCID_ICE_CUBE && !NPC[C]->IsABonus)
            {
                NPC[0].Type = NPCID_PLR_ICEBALL;
                NPCHit(C, 3, 0);
            }
        }
    }

    PlaySound(SFX_Transform);
}

static void iStillPlayWithLegos()
{
    ShowLayer(LAYER_DESTROYED_BLOCKS);
    PlaySound(SFX_Transform);
}

static void itsRainingMen()
{
    for(int C = 1; C <= numPlayers; C++)
    {
        for(int B = -100; B <= 900; B += 34)
        {
            numNPCs++;
            NPC[numNPCs].Type = NPCID_LIFE_S3;
            NPC[numNPCs].Location.Y = Player[C].Location.Y - 600;
            NPC[numNPCs].Location.X = Player[C].Location.X - 400 + B;
            NPC[numNPCs].Location.Height = 32;
            NPC[numNPCs].Location.Width = 32;
            NPC[numNPCs].Stuck = true;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].TimeLeft = 200;
            NPC[numNPCs].Section = Player[C].Section;
            syncLayers_NPC(numNPCs);
        }
    }

    PlaySound(SFX_Transform);
}

static void dontTypeThis()
{
    for(int C = 1; C <= numPlayers; C++)
    {
        for(int B = -100; B <= 900; B += 34)
        {
            numNPCs++;
            NPC[numNPCs].Type = NPCID_BOMB;
            NPC[numNPCs].Location.Y = Player[C].Location.Y - 600;
            NPC[numNPCs].Location.X = Player[C].Location.X - 400 + B;
            NPC[numNPCs].Location.Height = 32;
            NPC[numNPCs].Location.Width = 32;
            NPC[numNPCs].Stuck = true;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].TimeLeft = 200;
            NPC[numNPCs].Section = Player[C].Section;
            syncLayers_NPC(numNPCs);
        }
    }

    PlaySound(SFX_Transform);
}

static void wetWater()
{
    for(int B = 1; B <= numEffects; B++)
    {
        if(Effect[B].Type == EFFID_AIR_BUBBLE)
            Effect[B].Life = 0;
    }

    for(int B = 0; B < numSections; B++)
    {
        if(UnderWater[B])
        {
            UnderWater[B] = false;

            if(Background2REAL[B] == 55)
                Background2[B] = 30;
            else if(Background2REAL[B] == 56)
                Background2[B] = 39;
            else
                Background2[B] = Background2REAL[B];

            if(bgMusicREAL[B] == 46)
            {
                Background2[B] = 8;
                bgMusic[B] = 7;
            }
            else if(bgMusicREAL[B] == 47)
            {
                Background2[B] = 39;
                bgMusic[B] = 4;
            }
            else if(bgMusicREAL[B] == 48)
            {
                Background2[B] = 30;
                bgMusic[B] = 29;
            }
            else if(bgMusicREAL[B] == 49)
            {
                Background2[B] = 30;
                bgMusic[B] = 50;
            }
            else
                bgMusic[B] = bgMusicREAL[B];
        }
        else
        {
            UnderWater[B] = true;

            if(Background2REAL[B] != 55 && Background2REAL[B] != 56)
            {
                if(Background2REAL[B] == 12 || Background2REAL[B] == 13 || Background2REAL[B] == 19 || Background2REAL[B] == 29 ||
                   Background2REAL[B] == 30 || Background2REAL[B] == 31 || Background2REAL[B] == 32 || Background2REAL[B] == 33 ||
                   Background2REAL[B] == 34 || Background2REAL[B] == 42 || Background2REAL[B] == 43)
                    Background2[B] = 55;
                else
                    Background2[B] = 56;
            }
            else
                Background2[B] = Background2REAL[B];

            if(bgMusicREAL[B] < 46 || bgMusicREAL[B] > 49)
            {
                if(bgMusic[B] == 7 || bgMusic[B] == 9 || bgMusic[B] == 42)
                    bgMusic[B] = 46;
                else if(bgMusic[B] == 1 || bgMusic[B] == 2 || bgMusic[B] == 3 || bgMusic[B] == 4 || bgMusic[B] == 6 || bgMusic[B] == 54)
                    bgMusic[B] = 47;
                else if(bgMusic[B] == 10 || bgMusic[B] == 17 || bgMusic[B] == 28 || bgMusic[B] == 29 || bgMusic[B] == 41 || bgMusic[B] == 51)
                    bgMusic[B] = 48;
                else if(bgMusic[B] == 14 || bgMusic[B] == 26 || bgMusic[B] == 27 || bgMusic[B] == 35 || bgMusic[B] == 36 || bgMusic[B] == 50)
                    bgMusic[B] = 49;
                else
                    bgMusic[B] = 18;
            }
            else
                bgMusic[B] = bgMusicREAL[B];
        }
    }

    PlaySound(SFX_Transform);

    for(int i = 0; i < l_screen->player_count; i++)
    {
        int B = l_screen->players[i];

        if(!Player[B].Dead && Player[B].TimeToLive == 0)
        {
            StopMusic();
            StartMusic(Player[B].Section);
            break;
        }
    }
}

static void grantPowerup(NPCID npcid, PlayerState state)
{
    PlaySound(SFX_GotItem);

    for(int B = 1; B <= numPlayers; B++)
    {
        Player[B].HeldBonus = npcid;

        if((Player[B].Character >= 3 || g_config.alt_powerdown) && Player[B].State != state)
        {
            PlaySound(SFX_Transform);
            Player[B].Immune = 30;
            Player[B].Effect = PLREFF_WAITING;
            Player[B].Effect2 = 4;
            Player[B].State = state;
            SizeCheck(Player[B]);
            NewEffect(EFFID_SMOKE_S3_CENTER, Player[B].Location);
        }

        if(Player[B].Character >= 3 && Player[B].Hearts < 3)
            Player[B].Hearts += 1;
    }
}

static void needATanookiSuit()
{
    grantPowerup(NPCID_STATUE_POWER, PLR_STATE_STATUE);
}

static void needAHammerSuit()
{
    grantPowerup(NPCID_HEAVY_POWER, PLR_STATE_HEAVY);
}

static void needAMushroom()
{
    PlaySound(SFX_GotItem);

    for(int B = 1; B <= numPlayers; B++)
    {
        Player[B].HeldBonus = NPCID_POWER_S3;

        if(Player[B].Character >= 3 && Player[B].State == 1)
        {
            PlaySound(SFX_Transform);
            Player[B].Immune = 30;
            Player[B].Effect = PLREFF_WAITING;
            Player[B].Effect2 = 4;
            Player[B].State = 2;
            SizeCheck(Player[B]);
            NewEffect(EFFID_SMOKE_S3_CENTER, Player[B].Location);
        }

        if(Player[B].Character >= 3 && Player[B].Hearts < 3)
            Player[B].Hearts += 1;
    }
}

static void needAFlower()
{
    grantPowerup(NPCID_FIRE_POWER_S3, PLR_STATE_FIRE);
}

static void needAnIceFlower()
{
    grantPowerup(NPCID_ICE_POWER_S3, PLR_STATE_ICE);
}

static void needALeaf()
{
    grantPowerup(NPCID_LEAF_POWER, PLR_STATE_LEAF);
}

static void needACyclone()
{
    grantPowerup(NPCID_CYCLONE_POWER, PLR_STATE_CYCLONE);
}

static void goodTimesRoll()
{
    grantPowerup(NPCID_SHELL_POWER, PLR_STATE_SHELL);
}

static void wayPastCool()
{
    grantPowerup(NPCID_POLAR_POWER, PLR_STATE_POLAR);
}

static void sushiTime()
{
    grantPowerup(NPCID_AQUATIC_POWER, PLR_STATE_AQUATIC);
}

static void grantItemBox(NPCID npcid)
{
    PlaySound(SFX_GotItem);
    for(int B = 1; B <= numPlayers; B++)
        Player[B].HeldBonus = npcid;
}

static void needAShell()
{
    grantItemBox(NPCID_GRN_SHELL_S4);
}

static void needARedShell()
{
    grantItemBox(NPCID_RED_SHELL_S4);
}

static void needABlueShell()
{
    grantItemBox(NPCID_BLU_SHELL_S4);
}

static void needAYellowShell()
{
    grantItemBox(NPCID_YEL_SHELL_S4);
}

static void needATurnip()
{
    grantItemBox(NPCID_VEGGIE_1);
}

static void needA1Up()
{
    grantItemBox(NPCID_LIFE_S3);
}

static void needANegg()
{
    grantItemBox(NPCID_ITEM_POD);
}

static void needAPlant()
{
    grantItemBox(NPCID_TOOTHYPIPE);
}

static void needAGun()
{
    grantItemBox(NPCID_CANNONITEM);
}

static void needASwitch()
{
    grantItemBox(NPCID_COIN_SWITCH);
}

static void needAClock()
{
    grantItemBox(NPCID_TIMER_S3);
}

static void needABomb()
{
    grantItemBox(NPCID_WALK_BOMB_S2);
}

static void needAShoe()
{
    grantItemBox(NPCID_GRN_BOOT);
}

static void redShoe()
{
    grantItemBox(NPCID_RED_BOOT);
}

static void blueShoe()
{
    grantItemBox(NPCID_BLU_BOOT);
}

static void shadowStar()
{
    PlaySound(SFX_Transform);

    for(int B = 1; B <= numPlayers; B++)
    {
        Player[B].Immune = 50;
        NewEffect(EFFID_SMOKE_S3_CENTER, Player[B].Location);
    }

    ShadowMode = !ShadowMode;

    //if(ShadowMode)
    //    ShadowMode = false;
    //else
    //    ShadowMode = true;
}

static void s_heightFix(Player_t& p)
{
    if(p.Mount <= 1)
    {
        int new_height = Physics.PlayerHeight[p.Character][p.State];
        if(p.Mount == 1 && p.State == 1)
            new_height = Physics.PlayerHeight[1][2];

        p.Location.set_height_floor(new_height);
        p.StandUp = true;
    }
}

static void changeCharCheat(int new_char)
{
    PlaySound(SFX_Transform);

    for(int B = 1; B <= numPlayers; B++)
    {
        Player[B].Character = new_char;
        Player[B].Immune = 50;

        s_heightFix(Player[B]);

        NewEffect(EFFID_SMOKE_S3_CENTER, Player[B].Location);
    }

    UpdateYoshiMusic();
}

static void becomeAsPeach()
{
    changeCharCheat(3);
}

static void becomeAsToad()
{
    changeCharCheat(4);
}

static void becomeAsLink()
{
    changeCharCheat(5);
}

static void becomeAsMario()
{
    changeCharCheat(1);
}

static void becomeAsLuigi()
{
    changeCharCheat(2);
}

static int findLivingForCheat()
{
    if(!g_ClonedPlayerMode && numPlayers != Screens[0].player_count)
    {
        PlaySound(SFX_BlockHit);
        return false;
    }

    return CheckLiving();
}

static void setScreenPlayers(int count)
{
    Screens[0].player_count = count;
    Screens[0].players = {1, 2, 3, 4};
    UpdateScreenPlayers();
}

static void superbDemo200()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 200;
        g_ClonedPlayerMode = true;
        setScreenPlayers(1);

        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;
        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void superbDemo128()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 128;
        g_ClonedPlayerMode = true;
        setScreenPlayers(1);

        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;
        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void superbDemo64()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 64;
        g_ClonedPlayerMode = true;
        setScreenPlayers(1);

        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;
        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void superbDemo32()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 32;
        g_ClonedPlayerMode = true;
        setScreenPlayers(1);

        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;

        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void superbDemo16()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 16;
        g_ClonedPlayerMode = true;
        setScreenPlayers(1);

        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;

        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void superbDemo8()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 8;
        g_ClonedPlayerMode = true;
        setScreenPlayers(1);

        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;

        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void superbDemo4()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 4;
        g_ClonedPlayerMode = true;
        setScreenPlayers(1);

        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;

        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void superbDemo2()
{
    int B = findLivingForCheat();

    if(B > 0)
    {
        g_ClonedPlayerMode = false;
        numPlayers = 2;
        SingleCoop = 1;
        setScreenPlayers(2);

        SetupScreens();
        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;
        Player[B].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * 24 - 12;
            }

            if(C == 1)
            {
                Player[C].Character = 1;
                s_heightFix(Player[C]);
            }
            else
            {
                Player[C].Character = 2;
                s_heightFix(Player[C]);
            }
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void onePlayer()
{
    int B = findLivingForCheat();

    if(B > 0)
    {
        for(int C = 1; C <= numPlayers; C++)
            Player[C].Immune = 1;

        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Bomb(Player[C].Location, iRand(2) + 2);
            }
        }

        // set the living player to get the controls if not P1
        if(!g_ClonedPlayerMode && !SingleCoop && B - 1 < (int)Controls::g_InputMethods.size() && Controls::g_InputMethods[B-1])
            std::swap(Controls::g_InputMethods[0], Controls::g_InputMethods[B-1]);

        // delete other control methods
        while(Controls::g_InputMethods.size() > 1)
            Controls::DeleteInputMethodSlot(1);

        numPlayers = 1;
        SingleCoop = 1;
        g_ClonedPlayerMode = false;

        setScreenPlayers(1);
        SetupScreens();
        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;

        // move the living player into slot 1
        int C = 1;
        Player[C] = Player[B];
        Player[C].Character = 1;
        s_heightFix(Player[C]);

        Player[C].Immune = 1;
        Player[C].Immune2 = true;
    }
}

static void twoPlayer()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 2;

        // setup so there are exactly two controller slots,
        // activate quick-reconnect if needed
        while(Controls::g_InputMethods.size() > 2)
        {
            Controls::DeleteInputMethodSlot(2);
        }
        if(Controls::g_InputMethods.size() == 1)
        {
            Controls::g_InputMethods.push_back(nullptr);
            QuickReconnectScreen::g_active = true;
        }

        SingleCoop = 0;
        g_ClonedPlayerMode = false;
        setScreenPlayers(2);
        SetupScreens();

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;

        Player[B].Immune = 1;
        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * -12;
            }

            Player[C].Character = C;
            s_heightFix(Player[C]);
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void fourPlayer()
{
    int B = findLivingForCheat();
    if(B > 0)
    {
        numPlayers = 4;

        // setup so there are exactly two controller slots,
        // activate quick-reconnect if needed
        while(Controls::g_InputMethods.size() > 4)
        {
            Controls::DeleteInputMethodSlot(4);
        }
        while(Controls::g_InputMethods.size() < 4)
        {
            Controls::g_InputMethods.push_back(nullptr);
            QuickReconnectScreen::g_active = true;
        }

        SingleCoop = 0;
        g_ClonedPlayerMode = false;
        setScreenPlayers(4);

        if(Player[B].Effect == PLREFF_NO_COLLIDE)
            Player[B].Effect = PLREFF_NORMAL;

        Player[B].Immune = 1;
        for(int C = 1; C <= numPlayers; C++)
        {
            if(C != B)
            {
                Player[C] = Player[B];
                Player[C].Location.SpeedY = dRand() * -12;
            }

            Player[C].Character = C;

            if(Player[C].Character > 2 && Player[C].Mount == 3)
            {
                Player[C].Mount = 1;
                Player[C].MountType = 1;
            }

            s_heightFix(Player[C]);
        }

        Bomb(Player[B].Location, iRand(2) + 2);
    }
}

static void fourShared()
{
    fourPlayer();

    {
        ConfigChangeSentinel sent(ConfigSetLevel::cheat);
        g_config.four_screen_mode = MultiplayerPrefs::Shared;
    }
}

static void fourSplit()
{
    fourPlayer();

    {
        ConfigChangeSentinel sent(ConfigSetLevel::cheat);
        g_config.four_screen_mode = MultiplayerPrefs::Split;
    }
}

static void warioTime()
{
    for(int B : NPCQueues::Active.no_change)
    {
        if(NPC[B].Active)
        {
            if(!NPC[B]->WontHurt &&
               !NPC[B]->IsABlock &&
               !NPC[B]->IsABonus &&
               !NPC[B]->IsACoin &&
               !NPCIsAnExit(NPC[B]) &&
                NPC[B].Type != NPCID_ITEM_BURIED && !NPC[B].Generator &&
               !NPC[B].Inert
            )
            {
                PlaySound(SFX_Transform);
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[B].Location);
                NPC[B].Type = NPCID_COIN_S3;
                NPC[B].Location.set_width_center(NPC[B]->TWidth);
                NPC[B].Location.set_height_center(NPC[B]->THeight);
                NPC[B].Location.SpeedX = 0;
                NPC[B].Location.SpeedY = 0;

                treeNPCUpdate(B);
                NPCQueues::Unchecked.push_back(B);
            }
        }
    }
}

static void grantItemHeld(NPCID npcid, NPCEffect eff = NPCEFF_NORMAL, int special = 0)
{
    for(int B = 1; B <= numPlayers; B++)
    {
        if(Player[B].Mount == 0 && !Player[B].Dead && Player[B].TimeToLive == 0 && Player[B].Effect == PLREFF_NORMAL)
        {
            numNPCs++;
            NPC[numNPCs].Type = npcid;
            NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
            NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
            NPC[numNPCs].Location.X = Player[B].Location.X;
            NPC[numNPCs].Location.Y = Player[B].Location.Y;
            NPC[numNPCs].Location.SpeedX = 0;
            NPC[numNPCs].Location.SpeedY = 0;
            NPC[numNPCs].Effect = eff;
            NPC[numNPCs].Special = special;

            // for the pods
            if(special)
                NPCFrames(numNPCs);

            NPC[numNPCs].Active = true;
            NPC[numNPCs].TimeLeft = 200;
            NPC[numNPCs].HoldingPlayer = B;

            syncLayers_NPC(numNPCs);
            CheckSectionNPC(numNPCs);

            Player[B].HoldingNPC = numNPCs;
            Player[B].ForceHold = 60;
            PlaySound(SFX_Grab);
        }
    }
}

static void carKeys()
{
    grantItemHeld(NPCID_KEY);
}

static void boingyBoing()
{
    grantItemHeld(NPCID_SPRING);
}

static void bombsAway()
{
    grantItemHeld(NPCID_BOMB);
}

static void fireMissiles()
{
    grantItemHeld(NPCID_BULLET);
}

static void hellFire()
{
    grantItemHeld(NPCID_FLY_CANNON);
}

static void upAndOut()
{
    grantItemHeld(NPCID_FLY_BLOCK);
}

static void powHammer()
{
    grantItemHeld(NPCID_EARTHQUAKE_BLOCK);
}

static void hammerInMyPants()
{
    grantItemHeld(NPCID_HEAVY_THROWER);
}

static void rainbowRider()
{
    grantItemHeld(NPCID_FLIPPED_RAINBOW_SHELL, NPCEFF_DROP_ITEM);
}

static void cantTouchThis()
{
    grantItemHeld(NPCID_INVINCIBILITY_POWER);
}

static void greenEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_GREEN);
}

static void blueEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_BLUE);
}

static void yellowEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_YELLOW);
}

static void redEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_RED);
}

static void blackEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_BLACK);
}

static void purpleEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_PURPLE);
}

static void pinkEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_PINK);
}

static void coldEgg()
{
    grantItemHeld(NPCID_ITEM_POD, NPCEFF_DROP_ITEM, NPCID_PET_CYAN);
}

static void stopHittingMe()
{
    bool ret = GodMode;
    GodMode = false;

    for(int B = 1; B <= numPlayers; B++)
        PlayerHurt(B);

    GodMode = ret;
}

static void stickyFingers()
{
    GrabAll = !GrabAll;
    PlaySound(GrabAll ? SFX_PlayerGrow : SFX_PlayerShrink);

    for(int B = 1; B <= maxPlayers; B++)
        Player[B].CanGrabNPCs = GrabAll;
}

static void capitanN()
{
    CaptainN = !CaptainN;
    PlaySound(CaptainN ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void flameThrower()
{
    FlameThrower = !FlameThrower;
    PlaySound(FlameThrower ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void moneyTree()
{
    CoinMode = !CoinMode;
    PlaySound(CoinMode ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void godMode()
{
    GodMode = !GodMode;
    PlaySound(GodMode ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void wingMan()
{
    FlyForever = !FlyForever;
    PlaySound(FlyForever ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void tooSlow()
{
    SuperSpeed = !SuperSpeed;
    PlaySound(SuperSpeed ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void ahippinAndAHopping()
{
    MultiHop = !MultiHop;
    PlaySound(MultiHop ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void frameRate()
{
    ConfigChangeSentinel sent(ConfigSetLevel::cheat);

    g_config.show_fps = !g_config.show_fps;
    PlaySound(g_config.show_fps ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void speedDemon()
{
    ConfigChangeSentinel sent(ConfigSetLevel::cheat);

    g_config.unlimited_framerate = !g_config.unlimited_framerate;
    PlaySound(g_config.unlimited_framerate ? SFX_PlayerGrow : SFX_PlayerShrink);

    if(g_config.compatibility_mode != Config_t::COMPAT_OFF && g_config.compatibility_mode != Config_t::COMPAT_MODERN)
    {
        pLogDebug("Marking Cheater by unlimited framerate cheat code");
        Cheater = true;
    }
}

static void gifs2png()
{
    PlaySound(SFX_Transform);

#ifdef __3DS__
    ConfigChangeSentinel sent(ConfigSetLevel::cheat);
    g_config.inaccurate_gifs = !g_config.inaccurate_gifs;
#else
    g_ForceBitmaskMerge = !g_ForceBitmaskMerge;
    XRender::unloadGifTextures();
#endif
}

static void logicScreen()
{
    PlaySound(SFX_PSwitch);
    g_CheatLogicScreen = !g_CheatLogicScreen;
}

static void editYourFriends()
{
    g_CheatEditYourFriends = 2;
    PauseGame(PauseCode::Options);
}

static void bornToClimb()
{
    CanWallJump = !CanWallJump;
    PlaySound(CanWallJump ? SFX_PlayerGrow : SFX_PlayerShrink);
}

static void newLeaf()
{
    if(g_config.show_fps.m_set == ConfigSetLevel::cheat || g_config.unlimited_framerate.m_set == ConfigSetLevel::cheat)
    {
        g_config.show_fps.unset();
        g_config.unlimited_framerate.unset();
        UpdateConfig();
    }

    GodMode = false;
    MultiHop = false;
    SuperSpeed = false;
    FlyForever = false;
    CoinMode = false;
    FlameThrower = false;
    CaptainN = false;
    GrabAll = false;
    ShadowMode = false;
    CanWallJump = false;
    PlaySound(SFX_VillainKilled);
}

static void getMeOuttaHere()
{
    // in non-cheat variant, LevelMacroCounter is stuck at 0 if player never leaves section
    bool possible_softlock = (LevelMacro == LEVELMACRO_CARD_ROULETTE_EXIT && LevelMacroCounter == 0);

    if(LevelMacro != LEVELMACRO_OFF && !possible_softlock)
        return;

    LevelBeatCode = BEATCODE_NONE;
    LevelMacro = LEVELMACRO_OFF;
    LevelMacroCounter = 0;
    EndLevel = true;
}

static void holyTrinity()
{
    PlaySound(SFX_Transform);

    for(int B = 1; B <= numPlayers; B++)
    {
        Player[B].Immune = 50;
        NewEffect(EFFID_SMOKE_S3_CENTER, Player[B].Location);
    }

    if(ShadowMode && GodMode && MultiHop)
    {
        ShadowMode = false;
        GodMode = false;
        MultiHop = false;
    }
    else
    {
        ShadowMode = true;
        GodMode = true;
        MultiHop = true;
    }
}

static void essentials()
{
    PlaySound(SFX_Transform);

    for(int B = 1; B <= numPlayers; B++)
    {
        Player[B].Immune = 50;
        NewEffect(EFFID_SMOKE_S3_CENTER, Player[B].Location);
    }

    if(ShadowMode && GodMode && MultiHop && SuperSpeed)
    {
        SuperSpeed = false;
        ShadowMode = false;
        GodMode = false;
        MultiHop = false;
    }
    else
    {
        SuperSpeed = true;
        ShadowMode = true;
        GodMode = true;
        MultiHop = true;
    }
}

static void foundMyCarKey()
{
    if(LevelMacro != LEVELMACRO_OFF)
        return;

    PlaySound(SFX_Key);
    StopMusic();
    LevelMacro = LEVELMACRO_KEYHOLE_EXIT;

    int player = CheckLiving();
    if(player && numBackground + numLocked < maxBackgrounds)
    {
        const Location_t& pLoc = Player[player].Location;

        // can't properly add a background because they need to be sorted, but can at least trigger the animation.
        Background_t& bgo = Background[numBackground + numLocked + 1];
        bgo = Background_t();

        bgo.Type = 35;

        bgo.Location.Width = BackgroundWidth[35];
        bgo.Location.Height = BackgroundHeight[35];
        bgo.Location.X = pLoc.X + (pLoc.Width - bgo.Location.Width) / 2;
        bgo.Location.Y = pLoc.Y + pLoc.Height - bgo.Location.Height;

        LevelMacroWhich = numBackground + numLocked + 1;
    }
}

static void lifeGoals()
{
    if(LevelMacro != LEVELMACRO_OFF)
        return;

    LevelMacro = LEVELMACRO_GOAL_TAPE_EXIT;
    StopMusic();
    PlaySound(SFX_TapeExit);
}

static void mysteryBall()
{
    if(LevelMacro != LEVELMACRO_OFF)
        return;

    LevelMacro = LEVELMACRO_QUESTION_SPHERE_EXIT;
    StopMusic();
    PlaySound(SFX_DungeonClear);
}

static void itsVegas()
{
    // in non-cheat variant, LevelMacroCounter is stuck at 0 if player never leaves section
    bool possible_softlock = (LevelMacro == LEVELMACRO_CARD_ROULETTE_EXIT && LevelMacroCounter == 0);

    if(LevelMacro != LEVELMACRO_OFF && !possible_softlock)
        return;

    LevelMacro = LEVELMACRO_CARD_ROULETTE_EXIT;
    // mark as cheat variant to prevent softlocks
    LevelMacroWhich = -1;
    StopMusic();
    PlaySound(SFX_CardRouletteClear);
}

static void setRes(int w, int h)
{
    ConfigChangeSentinel sent(ConfigSetLevel::cheat);

    g_config.internal_res = {w, h};
}

static void setResGb()
{
    setRes(320, 288);
}

static void setResGba()
{
    setRes(480, 320);
}

static void setResNds()
{
    setRes(512, 384);
}

static void setResSnes()
{
    setRes(512, 448);
}

static void setResVga()
{
    setRes(640, 480);
}

static void setResHello()
{
    setRes(768, 432);
}

static void setRes3ds()
{
    setRes(800, 480);
}

static void setResClassic()
{
    setRes(800, 600);
}

static void setResHD()
{
    setRes(1280, 720);
}

static void setResDyn()
{
    setRes(0, 0);
}

static void setResCustom()
{
    int w, h;

    std::string s = TextEntryScreen::Run("Game width:");
    if(s.empty())
        return;

    w = 0; // just to suppress an unneeded warning

    while(s != "dyn" && (w = atol(s.c_str())) <= 0)
    {
        s = TextEntryScreen::Run("Invalid input. Game width:");
        if(s.empty())
            return;
    }

    if(s == "dyn")
        w = 0;

    s = TextEntryScreen::Run("Game height:");
    if(s.empty())
        return;

    while((h = atol(s.c_str())) <= 0)
    {
        s = TextEntryScreen::Run("Invalid input. Game height:");
        if(s.empty())
            return;
    }

    setRes(w, h);
}




struct CheatCodeDefault_t
{
    const char*key;
    void (*call)();
    bool isCheat;
};

struct CheatCode_t
{
    char key[25];
    size_t keyLen;
    void (*call)();
    bool isCheat;
};

static const CheatCodeDefault_t s_cheatsListGlobalDefault[] =
{
#ifdef ENABLE_ANTICHEAT_TRAP
    {"redigitiscool", dieCheater, false},
#else
    {"redigitiscool", redigitIsCool, false},
#endif
    {"\x77\x6f\x68\x6c\x73\x74\x61\x6e\x64\x69\x73\x74\x73\x65\x68\x72\x67\x75\x74", redigitIsCool, false},

    {"gifs2png", gifs2png, false},

    // cheat to show the logical screens
    {"logicscreen", logicScreen, false},

    // cheat to allow editing any setting
    {"edityourfriends", editYourFriends, false},

    // resolution cheats
    {"gameboyview", setResGb, false},
    {"tinyview", setResGba, false},
    {"gbaview", setResGba, false},
    {"superbdemoadvance", setResGba, false},
    {"ndsview", setResNds, false},
    {"snesview", setResSnes, false},
    {"vgaview", setResVga, false},
    {"helloview", setResHello, false},
    {"3dsview", setRes3ds, false},
    {"smbxview", setResClassic, false},
    {"aodview", setResClassic, false},
    {"classicview", setResClassic, false},
    {"hdview", setResHD, false},
    {"dynview", setResDyn, false},
    {"debugview", setResCustom, false},
    {"customview", setResCustom, false},

    {nullptr, nullptr, false}
};


static const CheatCodeDefault_t s_cheatsListWorldDefault[] =
{
    {"imtiredofallthiswalking", moonWalk, true}, {"moonwalk", moonWalk, true}, {"skywalk", moonWalk, true},
    {"illparkwhereiwant", illParkWhereIWant, true}, {"parkinglot", illParkWhereIWant, true},
    {"4shared", fourShared, true},
    {"4split", fourSplit, true},
    {"opensesame", openSesame, true},
    {nullptr, nullptr, false}
};

static const CheatCodeDefault_t s_cheatsListLevelDefault[] =
{
    {"needashell", needAShell, true},
    {"fairymagic", fairyMagic, true},
    {"iceage", iceAge, true},
    {"istillplaywithlegos", iStillPlayWithLegos, true},
    {"itsrainingmen", itsRainingMen, true},
    {"donttypethis", dontTypeThis, true},
    {"wetwater", wetWater, true},
    {"needaredshell", needARedShell, true},
    {"needablueshell", needABlueShell, true},
    {"needayellowshell", needAYellowShell, true},
    {"needaturnip", needATurnip, true},
    {"needa1up", needA1Up, true},
    {"needatanookisuit", needATanookiSuit, true},
    {"needahammersuit", needAHammerSuit, true}, {"hammertime", needAHammerSuit, true},
    {"needamushroom", needAMushroom, true},
    {"needaflower", needAFlower, true},
    {"niceflower", needAnIceFlower, true},
    {"needaleaf", needALeaf, true},
    {"needanegg", needANegg, true},
    {"needaplant", needAPlant, true},
    {"needagun", needAGun, true},
    {"needaswitch", needASwitch, true},
    {"needaclock", needAClock, true},
    {"needabomb", needABomb, true},
    {"needashoe", needAShoe, true},
    {"redshoe", redShoe, true},
    {"blueshoe", blueShoe, true},
    {"shadowstar", shadowStar, true},

    {"ibakedacakeforyou", becomeAsPeach, true}, {"itsamepeach", becomeAsPeach, true},
    {"anothercastle", becomeAsToad, true}, {"itsametoad", becomeAsToad, true},
    {"iamerror", becomeAsLink, true}, {"itsamelink", becomeAsLink, true},
    {"itsamemario", becomeAsMario, true}, {"plumberboy", becomeAsMario, true}, {"moustacheman", becomeAsMario, true},
    {"itsameluigi", becomeAsLuigi, true}, {"greenmario", becomeAsLuigi, true},

    {"supermario200", superbDemo200, true},
    {"supermario128", superbDemo128, true},
    {"supermario64", superbDemo64, true},
    {"supermario32", superbDemo32, true},
    {"supermario16", superbDemo16, true},
    {"supermario8", superbDemo8, true},
    {"supermario4", superbDemo4, true},
    {"supermario2", superbDemo2, true},
    {"1player", onePlayer, true},
    {"2player", twoPlayer, true},
    {"4shared", fourShared, true},
    {"4split", fourSplit, true},

    {"wariotime", warioTime, true},
    {"carkeys", carKeys, true},
    {"boingyboing", boingyBoing, true},
    {"bombsaway", bombsAway, true},
    {"firemissiles", fireMissiles, true},
    {"burnthehousedown", hellFire, true}, {"hellfire", hellFire, true},
    {"upandout", upAndOut, true},
    {"powhammer", powHammer, true},
    {"hammerinmypants", hammerInMyPants, true},
    {"rainbowrider", rainbowRider, true},

    {"greenegg", greenEgg, true},
    {"blueegg", blueEgg, true},
    {"yellowegg", yellowEgg, true},
    {"redegg", redEgg, true},
    {"blackegg", blackEgg, true},
    {"purpleegg", purpleEgg, true},
    {"pinkegg", pinkEgg, true},
    {"coldegg", coldEgg, true},
    {"stophittingme", stopHittingMe, true}, {"uncle", stopHittingMe, true},
    {"stickyfingers", stickyFingers, true},
    {"captainn", capitanN, true},
    {"flamethrower", flameThrower, true},
    {"moneytree", moneyTree, true},
    {"donthurtme", godMode, true}, {"godmode", godMode, true},
    {"wingman", wingMan, true},
    {"tooslow", tooSlow, true},
    {"ahippinandahoppin", ahippinAndAHopping, true}, {"jumpman", ahippinAndAHopping, true},
    {"framerate", frameRate, false},
    {"speeddemon", speedDemon, false},

    {"getmeouttahere", getMeOuttaHere, true},
    {"newleaf", newLeaf, true},
    {"borntoclimb", bornToClimb, true},
    {"needacyclone", needACyclone, true},
    {"goodtimesroll", goodTimesRoll, true},
    {"canttouchthis", cantTouchThis, true},
    {"waypastcool", wayPastCool, true},
    {"sushitime", sushiTime, true},

    {"holytrinity", holyTrinity, true}, {"passerby", holyTrinity, true},
    {"essentials", essentials, true}, {"holyfour", essentials, true},

    {"foundmycarkey", foundMyCarKey, true},
    {"lifegoals", lifeGoals, true},
    {"mysteryball", mysteryBall, true},
    {"itsvegas", itsVegas, true},

    {nullptr, nullptr, false}
};


//! Current list of global cheats
static std::vector<CheatCode_t> s_cheatsListGlobal;
//! Current list of world map specific cheats
static std::vector<CheatCode_t> s_cheatsListWorld;
//! Current list of level specific cheats
static std::vector<CheatCode_t> s_cheatsListLevel;


/*!
 * \brief hasQWERTZ
 * \param s Checks does string is suitable for conversion into QWERTZ
 * \return true if string can be converted into QWERTZ
 */
SDL_FORCE_INLINE bool hasQWERTZ(const std::string &s)
{
    for(const char &c : s)
    {
        switch(c)
        {
        case 'y':
        case 'z':
            return true;
        default:
            continue;
        }
    }

    return false;
}

/*!
 * \brief convert string into QWERTZ
 * \param s Source string in QWERTY
 * \return QWERTZ string
 */
SDL_FORCE_INLINE std::string toQWERTZ(std::string s)
{
    for(char &c : s)
    {
        switch(c)
        {
        case 'y':
            c = 'z';
            break;
        case 'z':
            c = 'y';
            break;
        default:
            continue;
        }
    }

    return s;
}

/*!
 * \brief hasAZERTY
 * \param s Checks does string is suitable for conversion into AZERTY
 * \return true if string can be converted into AZERTY
 */
SDL_FORCE_INLINE bool hasAZERTY(const std::string &s)
{
    for(const char &c : s)
    {
        switch(c)
        {
        case 'q':
        case 'w':
        case 'a':
        case ';':
        case 'z':
        case 'm':
            return true;
        default:
            continue;
        }
    }

    return false;
}

/*!
 * \brief convert string into AZERTY
 * \param s Source string in AZERTY
 * \return AZERTY string
 */
SDL_FORCE_INLINE std::string toAZERTY(std::string s)
{
    for(char &c : s)
    {
        switch(c)
        {
        case 'q':
            c = 'a';
            break;
        case 'w':
            c = 'z';
            break;
        case 'a':
            c = 'q';
            break;
        case 'z':
            c = 'w';
            break;
        case 'm':
            c = ';';
            break;
        default:
            continue;
        }
    }

    return s;
}

SDL_FORCE_INLINE void convertArray(std::vector<CheatCode_t> &dst, const CheatCodeDefault_t *src)
{
    dst.clear();

    while(src->key && src->call)
    {
        CheatCode_t cd = {};
        SDL_memset(cd.key, 0, sizeof(cd.key));
        SDL_strlcpy(cd.key, src->key, sizeof(cd.key));
        cd.keyLen = SDL_strlen(cd.key);
        cd.call = src->call;
        cd.isCheat = src->isCheat;
        dst.push_back(cd);

        if(hasQWERTZ(src->key)) // Automatically add QWERTZ alias
        {
            std::string z = toQWERTZ(src->key);
            SDL_memset(cd.key, 0, sizeof(cd.key));
            SDL_strlcpy(cd.key, z.c_str(), SDL_min(sizeof(cd.key), z.size() + 1));
            cd.keyLen = SDL_strlen(cd.key);
            dst.push_back(cd);
        }

        if(hasAZERTY(src->key)) // Automatically add AZERTY alias
        {
            std::string z = toAZERTY(src->key);
            SDL_memset(cd.key, 0, sizeof(cd.key));
            SDL_strlcpy(cd.key, z.c_str(), SDL_min(sizeof(cd.key), z.size() + 1));
            cd.keyLen = SDL_strlen(cd.key);
            dst.push_back(cd);
        }

        ++src;
    }
}

SDL_FORCE_INLINE void addAliasCheats(CheatsScope scope, std::vector<GameInfo::CheatAlias> &list)
{
    for(const auto &c : list)
    {
        cheats_addAlias(scope, c.first, c.second);
        if(hasQWERTZ(c.second)) // Add QWERTZ version for new string
            cheats_addAlias(scope, c.first, toQWERTZ(c.second));
        if(hasAZERTY(c.second)) // Add AZERTY version for new string
            cheats_addAlias(scope, c.first, toAZERTY(c.second));
    }
}

SDL_FORCE_INLINE void addRenameCheats(CheatsScope scope, std::vector<GameInfo::CheatAlias> &list)
{
    for(const auto &c : list)
    {
        cheats_rename(scope, c.first, c.second);

        if(hasQWERTZ(c.first)) // Remove no longer relevant QWERTZ version of string
            cheats_erase(scope, toQWERTZ(c.first));
        if(hasAZERTY(c.first)) // Remove no longer relevant AZERTY version of string
            cheats_erase(scope, toAZERTY(c.first));

        if(hasQWERTZ(c.second)) // Add QWERTZ version for new string if needed
            cheats_addAlias(scope, c.second, toQWERTZ(c.second));
        if(hasAZERTY(c.second)) // Add AZERTY version for new string if needed
            cheats_addAlias(scope, c.second, toAZERTY(c.second));
    }
}

void cheats_reset()
{
    convertArray(s_cheatsListGlobal, s_cheatsListGlobalDefault);
    convertArray(s_cheatsListWorld, s_cheatsListWorldDefault);
    convertArray(s_cheatsListLevel, s_cheatsListLevelDefault);

    addAliasCheats(CHEAT_SCOPE_GLOBAL,  g_gameInfo.cheatsGlobalAliases);
    addRenameCheats(CHEAT_SCOPE_GLOBAL, g_gameInfo.cheatsGlobalRenames);

    addAliasCheats(CHEAT_SCOPE_WORLD,  g_gameInfo.cheatsWorldAliases);
    addRenameCheats(CHEAT_SCOPE_WORLD, g_gameInfo.cheatsWorldRenames);

    addAliasCheats(CHEAT_SCOPE_LEVEL,  g_gameInfo.cheatsLevelAliases);
    addRenameCheats(CHEAT_SCOPE_LEVEL, g_gameInfo.cheatsLevelRenames);
}

void cheats_addAlias(CheatsScope scope, const std::string &source, const std::string &alias)
{
    std::vector<CheatCode_t> *dst = nullptr;

    switch(scope)
    {
    case CHEAT_SCOPE_GLOBAL:
        dst = &s_cheatsListGlobal;
        break;
    case CHEAT_SCOPE_WORLD:
        dst = &s_cheatsListWorld;
        break;
    case CHEAT_SCOPE_LEVEL:
        dst = &s_cheatsListLevel;
        break;
    }

    SDL_assert(dst);

    for(auto &c : *dst)
    {
        if(source == c.key)
        {
            auto cc = c;
            SDL_memset(cc.key, 0, sizeof(cc.key));
            SDL_strlcpy(cc.key, alias.c_str(), SDL_min(sizeof(cc.key), alias.size() + 1));
            cc.keyLen = SDL_strlen(cc.key);
            dst->push_back(cc);
            break;
        }
    }
}

void cheats_rename(CheatsScope scope, const std::string &source, const std::string &alias)
{
    std::vector<CheatCode_t> *dst = nullptr;

    switch(scope)
    {
    case CHEAT_SCOPE_GLOBAL:
        dst = &s_cheatsListGlobal;
        break;
    case CHEAT_SCOPE_WORLD:
        dst = &s_cheatsListWorld;
        break;
    case CHEAT_SCOPE_LEVEL:
        dst = &s_cheatsListLevel;
        break;
    }

    SDL_assert(dst);

    for(auto &c : *dst)
    {
        if(source == c.key)
        {
            SDL_memset(c.key, 0, sizeof(c.key));
            SDL_strlcpy(c.key, alias.c_str(), SDL_min(sizeof(c.key), alias.size() + 1));
            c.keyLen = SDL_strlen(c.key);
            break;
        }
    }

}

void cheats_erase(CheatsScope scope, const std::string &source)
{
    std::vector<CheatCode_t> *dst = nullptr;

    switch(scope)
    {
    case CHEAT_SCOPE_GLOBAL:
        dst = &s_cheatsListGlobal;
        break;
    case CHEAT_SCOPE_WORLD:
        dst = &s_cheatsListWorld;
        break;
    case CHEAT_SCOPE_LEVEL:
        dst = &s_cheatsListLevel;
        break;
    }

    SDL_assert(dst);

    for(auto it = dst->begin(); it != dst->end(); ++it)
    {
        if(source == it->key)
        {
            dst->erase(it);
            break;
        }
    }
}


struct CheatBuffer_t
{
    static const size_t maxLen = 25;
    char buffer[2][maxLen + 1] = {};
    size_t t = 0;
    size_t bufLen = 0;

    void clear()
    {
        buffer[0][0] = 0;
        buffer[1][0] = 0;
        bufLen = 0;
    }

    void setBuffer(const std::string &line)
    {
        bufLen = SDL_min(maxLen, line.size());
        SDL_memcpy(buffer[t], line.c_str(), bufLen);
        buffer[t][bufLen] = 0;
    }

    void addSym(char c)
    {
        if(bufLen < maxLen)
        {
            buffer[t][bufLen++] = c;
            buffer[t][bufLen] = 0;
        }
        else
        {
            size_t ts = t,
                   td = !t;
            SDL_memcpy(buffer[td], buffer[ts] + 1, bufLen - 1);
            t = td;
            buffer[t][bufLen - 1] = c;
            buffer[t][bufLen] = 0;
        }
    }

    const char *getString()
    {
        if(bufLen == 0)
            return "";
        return buffer[t];
    }

    size_t getBufLen() const
    {
        return bufLen;
    }
};

static CheatBuffer_t s_buffer;


SDL_FORCE_INLINE bool cheatCompare(size_t bufLen, const char *buf,
                                   size_t keyLen, const char *key)
{
    if(bufLen < keyLen)
        return false;

    return SDL_memcmp(buf + (bufLen - keyLen), key, keyLen) == 0;
}

void run_cheat(XMessage::Message message)
{
    int set = message.player;

    const auto& cheat_list = (set == 0) ? s_cheatsListGlobal
                            : (set == 1) ? s_cheatsListLevel
                            : s_cheatsListWorld;

    if(set == 1 && LevelSelect)
        return;
    else if(set == 2 && !LevelSelect)
        return;

    if(message.message >= cheat_list.size())
        return;

    const auto& c = cheat_list[message.message];

    c.call();

    if(c.isCheat)
    {
        pLogDebug("Cheating detected!!! [%s]\n", c.key);
        Cheater = true;
    }
}

static void processCheats(bool instant)
{
    const char *buf = s_buffer.getString();
    auto bufLen = s_buffer.getBufLen();

    for(uint8_t set = 0; set < 3; set++)
    {
        const auto& cheat_list = (set == 0) ? s_cheatsListGlobal
                                : (set == 1) ? s_cheatsListLevel
                                : s_cheatsListWorld;

        for(size_t i = 0; i < cheat_list.size(); i++)
        {
            const auto& c = cheat_list[i];

            if(!cheatCompare(bufLen, buf, c.keyLen, c.key))
                continue;

            XMessage::Message cheat_message{XMessage::Type::enter_code, set, (uint8_t)i};

            if(instant)
                run_cheat(cheat_message);
            else
                XMessage::PushMessage(cheat_message);

            s_buffer.clear();
            break;
        }
    }
}

void cheats_setBuffer(const std::string &line, bool instant)
{
    s_buffer.setBuffer(line);
    processCheats(instant);
}

void cheats_clearBuffer()
{
    s_buffer.clear();
}

/*!
 * \brief Process the cheat buffer
 * \param sym New key symbol
 */
void CheatCode(char sym)
{
    if(LevelEditor || GameMenu || /*nPlay.Online ||*/ BattleMode)
    {
        s_buffer.clear();
        return;
    }

    s_buffer.addSym(sym);

    processCheats(false);
}

bool cheats_contains(const std::string &needle)
{
    const char *buf = s_buffer.getString();
    auto bufLen = s_buffer.getBufLen();
    return cheatCompare(bufLen, buf, needle.size(), needle.c_str());
}

bool cheats_contains(const char *needle)
{
    const char *buf = s_buffer.getString();
    auto bufLen = s_buffer.getBufLen();
    return cheatCompare(bufLen, buf, SDL_strlen(needle), needle);
}


================================================
FILE: src/main/cheat_code.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CHEAT_CODE_H
#define CHEAT_CODE_H

#include <string>
#include "message.h"

//! if true, bitmask merge is forced to occur even when logic ops are supported and merge loses information
extern bool g_ForceBitmaskMerge;

//! if true, the boundaries of logical screens are shown over the visible screen
extern bool g_CheatLogicScreen;

//! if 1, the player may edit compat settings (but they won't get saved). if 2, the player goes directly to compat on the next Options Screen start.
extern int g_CheatEditYourFriends;

/*!
 * \brief Reset all customized cheats state into default
 */
extern void cheats_reset();


enum CheatsScope
{
    CHEAT_SCOPE_GLOBAL = 0,
    CHEAT_SCOPE_WORLD,
    CHEAT_SCOPE_LEVEL
};

/*!
 * \brief Add alias to the existing cheat code
 * \param scope Cheats scope
 * \param source Source name of the cheat
 * \param alias New alias name
 */
extern void cheats_addAlias(CheatsScope scope,
                            const std::string &source,
                            const std::string &alias);

/*!
 * \brief Rename existing cheat into something other
 * \param scope Cheats scope
 * \param source Original name of cheat to rename
 * \param alias New name for the cheat
 */
extern void cheats_rename(CheatsScope scope,
                          const std::string &source,
                          const std::string &alias);

/*!
 * \brief Erase cheat code by name
 * \param scope Cheats scope
 * \param source Cheat to erase
 */
extern void cheats_erase(CheatsScope scope, const std::string &source);


/*!
 * \brief Runs cheat based on saved message
 */
extern void run_cheat(XMessage::Message message);

/*!
 * \brief Sets cheat buffer to string and processes cheats
 * \param line - cheat string to set
 * \param instant - for use by scripts: trigger cheat immediately. otherwise, push onto XMessage queue
 */
extern void cheats_setBuffer(const std::string &line, bool instant);

extern bool cheats_contains(const std::string &needle);
extern bool cheats_contains(const char *needle);

extern void cheats_clearBuffer();

/*!
 * \brief Adds one charracter into the cheat buffer and executes cheat if buffer has enough
 * \param sym ASCII character to add into the cheat buffer
 */
extern void CheatCode(char sym);

#endif // CHEAT_CODE_H


================================================
FILE: src/main/client.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <array>
#include <vector>

#include <Logger/logger.h>
#include <SDL_net.h>

#include "message.h"
#include "main/client.h"

static constexpr bool max_debug = false;

static XMessage::Message msg_from_frame_no(XMessage::Type type, uint32_t frame_no)
{
    XMessage::Message ret;
    ret.type = type;
    ret.screen = (uint8_t)(frame_no >> 16);
    ret.player = (uint8_t)(frame_no >> 8);
    ret.message = (uint8_t)(frame_no >> 0);

    return ret;
}

static int frame_no_from_message(XMessage::Message message)
{
    return (int)(message.screen << 16) | (int)(message.player << 8) | (int)(message.message << 0);
}


namespace XMessage
{

static int s_client_thread(void* _client)
{
    if(!_client)
        return 1;

    NetworkClient& client = *static_cast<NetworkClient*>(_client);

    while(!client.shutdown)
    {
        client.client_loop();
        // eventually, some way of sleeping
    }

    return 0;
}

bool TCPWrapper::FillBuffer(bool nb)
{
    if(!socket)
        return false;

    if(nb)
    {
        if(!SDLNet_SocketReady(socket))
            return false;
    }

    if(network_client_buffer_size <= buffer_used)
        return false;

    int got = SDLNet_TCP_Recv(socket, &buffer[buffer_used], network_client_buffer_size - buffer_used);

    if(got <= 0)
    {
        err = true;
        return false;
    }

    buffer_used += got;
    return true;
}

bool TCPWrapper::FillBufferTo(size_t fill)
{
    while(buffer_used < fill)
    {
        if(!socket || err)
            return false;

        FillBuffer();
    }

    return true;
}

bool TCPWrapper::FillBufferTo_NB(size_t fill)
{
    while(buffer_used < fill)
    {
        if(!socket || err)
            return false;

        if(!FillBuffer(true))
            return false;
    }

    return true;
}

void TCPWrapper::ShiftBuffer(size_t shift)
{
    size_t to_move = buffer_used - shift;
    SDL_memmove(&buffer[0], &buffer[shift], to_move);
    buffer_used = to_move;
}

XMessage::Message NetworkClient::ParseMessage(const uint8_t* message)
{
    XMessage::Message got;
    got.type = (XMessage::Type)message[0];
    got.screen = message[1];
    got.player = message[2];
    got.message = message[3];

    return got;
}

void NetworkClient::Shutdown()
{
    if(thread)
    {
        shutdown = true;
        SDL_WaitThread(thread, nullptr);
        thread = nullptr;
    }

    Disconnect(true);

    if(client_wakeup)
    {
        SDL_DestroySemaphore(client_wakeup);
        client_wakeup = nullptr;
    }

    if(game_wakeup)
    {
        SDL_DestroySemaphore(game_wakeup);
        game_wakeup = nullptr;
    }

    if(sdlnet_inited)
    {
        SDLNet_FreeSocketSet(socket_set);
        socket_set = nullptr;

        SDLNet_Quit();
        sdlnet_inited = false;
    }
}

void NetworkClient::EnsureThread()
{
    if(!sdlnet_inited)
    {
        SDLNet_Init();
        sdlnet_inited = true;
        socket_set = SDLNet_AllocSocketSet(3);
    }

    if(!thread)
    {
        SDL_AtomicSet(&status_req_state, REQUEST_IDLE);
        SDL_AtomicSet(&message_buffer_state, REQUEST_IDLE);
        thread = SDL_CreateThread(s_client_thread, "network thread", this);
        shutdown = false;
    }

    if(!client_wakeup)
        client_wakeup = SDL_CreateSemaphore(0);

    if(!game_wakeup)
        game_wakeup = SDL_CreateSemaphore(0);
}

void NetworkClient::Connect(const char* host, int port)
{
    Disconnect();

    IPaddress addr;
    if(SDLNet_ResolveHost(&addr, host, port) != 0)
        return;

    tcp_control.socket = SDLNet_TCP_OpenClient(&addr);
    if(!tcp_control.socket)
        return;

    SDLNet_TCP_AddSocket(socket_set, tcp_control.socket);

    tcp_data.socket = SDLNet_TCP_OpenClient(&addr);
    if(!tcp_data.socket)
    {
        Disconnect();
        return;
    }

    SDLNet_TCP_AddSocket(socket_set, tcp_data.socket);

    udp_socket = SDLNet_UDP_Open(0);
    if(!udp_socket || SDLNet_UDP_Bind(udp_socket, 0, &addr) != 0)
    {
        Disconnect();
        return;
    }

    // SDLNet_UDP_SetPacketLoss(udp_socket, 99);
    SDLNet_UDP_AddSocket(socket_set, udp_socket);

    udp_packet = SDLNet_AllocPacket(256);
    if(!udp_packet)
    {
        Disconnect();
        return;
    }

    udp_packet->channel = 0;
    udp_packet->address = addr;

    status = ClientStatus();
    status.client_state = CLIENT_LOBBY;
    status.server_address = host;
    status.server_port = port;

    tick = 0;
}

void NetworkClient::Disconnect(bool shutdown)
{
    if(tcp_control.socket)
    {
        SDLNet_TCP_DelSocket(socket_set, tcp_control.socket);
        SDLNet_TCP_Close(tcp_control.socket);
        tcp_control.socket = nullptr;
    }

    if(tcp_data.socket)
    {
        SDLNet_TCP_DelSocket(socket_set, tcp_data.socket);
        SDLNet_TCP_Close(tcp_data.socket);
        tcp_data.socket = nullptr;
    }

    if(udp_socket)
    {
        SDLNet_UDP_DelSocket(socket_set, udp_socket);
        SDLNet_UDP_Close(udp_socket);
        udp_socket = nullptr;
    }

    if(udp_packet)
    {
        SDLNet_FreePacket(udp_packet);
        udp_packet = nullptr;
    }

    tcp_control.buffer_used = 0;
    tcp_control.err = false;

    tcp_data.buffer_used = 0;
    tcp_data.err = false;

    session_key = 0;

    // FIXME: think carefully about how to update status field
    // given that the primary status struct is owned by the game thread at this point

    if(shutdown)
        return;

    // UpdateConfig();
    // UpdateInternalRes();
}

void NetworkClient::LeaveRoom()
{
    if(!tcp_control.socket || status.client_state == CLIENT_LOBBY)
        return;

    uint8_t to_send[4] = {0,0,0,0};

    SDLNet_TCP_Send(tcp_control.socket, to_send, 4);
}

void NetworkClient::SendAll()
{
    if(!tcp_data.socket)
        return;

    send_buffer.current_frame = tick;

    if(!message_buffer.empty())
    {
        send_buffer.messages.push_back(msg_from_frame_no(Type::frame_begin, tick));

        for(Message msg : message_buffer)
            send_buffer.messages.push_back(msg);

        message_buffer.clear();

        if(!ping_send_frame)
        {
            if(udp_packet_recd > 0 || tick - acked_frame > 60)
            {
                ping_send_frame = tick;
                ping_send_ms = SDL_GetTicks();
            }
        }
    }

    bool fast_forward = (receive_buffer.available_frame > tick + 10);
    if(!send_buffer.messages.empty() || !fast_forward)
        SendData();

    SDL_AtomicSet(&message_buffer_state, REQUEST_PENDING);
}

void NetworkClient::SendData()
{
    if(send_buffer.current_frame < 0)
        return;

    // remove any ACKed messages from send buffer
    while(!send_buffer.messages.empty())
    {
        Message front = send_buffer.messages.front();
        if(front.type == Type::frame_begin && frame_no_from_message(front) > acked_frame)
            break;

        send_buffer.messages.pop_front();
    }

    // FIXME: something about having received things
    bool has_udp = (udp_socket != nullptr && udp_packet_recd != 0);

    // 1ms timer goes here
    // if there's nothing that hasn't been ACKed, put a 15ms timer here
    if(!has_udp && send_buffer.messages.empty())
        return;

    // serialize messages
    std::vector<uint8_t> to_send;
    to_send.reserve(4096);

    // temporary marker to let server know how far the client has ACKed
    send_buffer.messages.push_back(msg_from_frame_no(Type::frame_end, send_buffer.current_frame));

    for(XMessage::Message m : send_buffer.messages)
    {
        to_send.push_back((uint8_t)m.type);
        to_send.push_back(m.screen);
        to_send.push_back(m.player);
        to_send.push_back(m.message);
    }

    // remove temporary marker
    send_buffer.messages.pop_back();

    size_t MTU_size = 250;

    // ideally, send with UDP
    if(has_udp && to_send.size() <= MTU_size)
    {
        udp_packet->len = to_send.size();
        SDL_memcpy(udp_packet->data, to_send.data(), to_send.size());
        udp_packet_sent++;
        SDLNet_UDP_Send(udp_socket, 0, udp_packet);
    }
    // fallback to TCP if UDP is unavailable or unfeasible
    else
    {
        // send_buffer.udp_transmission.clear();
        send_buffer.messages.clear();
        for(uint8_t c : to_send)
            send_buffer.tcp_transmit_in_progress.push_back(c);
    }

    // FIXME: the above should only get called once, and then the below should get called multiple times (with UDP retransmission moved below)

    // update any TCP transmission in progress
    if(!send_buffer.tcp_transmit_in_progress.empty())
    {
        send_buffer.tcp_transmit_pos += SDLNet_TCP_Send(tcp_data.socket,
            send_buffer.tcp_transmit_in_progress.data() + send_buffer.tcp_transmit_pos,
            send_buffer.tcp_transmit_in_progress.size() - send_buffer.tcp_transmit_pos);

        if(send_buffer.tcp_transmit_pos >= send_buffer.tcp_transmit_in_progress.size())
        {
            send_buffer.tcp_transmit_in_progress.clear();
            send_buffer.tcp_transmit_pos = 0;
        }
    }
}

void NetworkClient::ReceiveData()
{
    while(tcp_data.FillBufferTo_NB(4))
    {
        Message got = ParseMessage(&tcp_data.buffer[0]);
        tcp_data.ShiftBuffer(4);

        switch(got.type)
        {
        case(XMessage::Type::frame_begin):
        case(XMessage::Type::frame_end):
            int frame_no;
            frame_no = frame_no_from_message(got);

            // previous TCP frame is finished!
            if(receive_buffer.tcp_frame_index > receive_buffer.available_frame)
            {
                receive_buffer.available_frame = receive_buffer.tcp_frame_index;

                for(Message msg : receive_buffer.tcp_frame_in_progress)
                {
                    receive_buffer.messages.push_back(msg);
                    if(max_debug)
                        pLogDebug("TCP message get: %d %d %d %d", (int)msg.type, msg.screen, msg.player, msg.message);
                }

                receive_buffer.tcp_frame_in_progress.clear();
            }

            if(got.type == XMessage::Type::frame_begin)
            {
                receive_buffer.tcp_frame_index = frame_no;
                receive_buffer.tcp_frame_in_progress.push_back(got);
            }
            else if(got.type == XMessage::Type::frame_end)
            {
                if(frame_no > receive_buffer.available_frame)
                    receive_buffer.available_frame = frame_no;

                receive_buffer.tcp_frame_index = -1;
            }

            break;

        default:
            if(receive_buffer.tcp_frame_index > receive_buffer.available_frame)
                receive_buffer.tcp_frame_in_progress.push_back(got);
        }
    }

    // receive UDP data
    while(SDLNet_UDP_Recv(udp_socket, udp_packet))
    {
        udp_packet_recd++;

        if(max_debug)
        {
            std::string got;
            for(int i = 0; i < udp_packet->len; i++)
            {
                got += std::to_string(udp_packet->data[i]);
                got += ' ';
            }

            pLogDebug("UDP packet get: %s", got.c_str());
        }

        int udp_frame_index = -1;

        for(int i = 0; i + 4 <= udp_packet->len; i += 4)
        {
            Message got = ParseMessage(&udp_packet->data[i]);

            switch(got.type)
            {
            // can recognize acks here soon
            case(XMessage::Type::transmit_start):
                acked_frame = frame_no_from_message(got);
                if(acked_frame > tick)
                {
                    // prematurely received packet
                    goto skip_packet;
                }

                if(acked_frame >= ping_send_frame && ping_send_frame != 0)
                {
                    latency_ms = SDL_GetTicks() - ping_send_ms;
                    latency_frames = tick - ping_send_frame;
                    ping_send_frame = 0;
                    pLogDebug("UDP latency: %u ms, %d ticks", latency_ms, latency_frames);
                }
                break;
            case(XMessage::Type::frame_end):
                udp_frame_index = frame_no_from_message(got);
                if(udp_frame_index > receive_buffer.available_frame)
                    receive_buffer.available_frame = udp_frame_index;
                break;
            case(XMessage::Type::frame_begin):
                udp_frame_index = frame_no_from_message(got);
            // fallthrough
            default:
                if(udp_frame_index > receive_buffer.available_frame)
                {
                    receive_buffer.messages.push_back(got);

                    if(max_debug)
                        pLogDebug("UDP message get: %d %d %d %d", (int)got.type, got.screen, got.player, got.message);
                }
                else
                {
                    // pLogDebug("UDP stale message get: %d %d %d %d [%d %d]", got.type, got.screen, got.player, got.message, udp_frame_index, receive_buffer.available_frame);
                }
                break;
            }
        }
skip_packet:
        // skip to next loop step
        (void)0;
    }
}

bool NetworkClient::WaitAndFill()
{
    // use the receive buffer to fill a frame if possible
    if(receive_buffer.available_frame >= tick)
    {
        if(!receive_buffer.messages.empty())
        {
            Message front = receive_buffer.messages.front();
            if(front.type == Type::frame_begin && frame_no_from_message(front) == tick)
            {
                receive_buffer.messages.pop_front();

                while(!receive_buffer.messages.empty() && receive_buffer.messages.front().type != Type::frame_begin)
                {
                    if(max_debug)
                        pLogDebug("Message push: %d %d %d %d %d", tick, (int)receive_buffer.messages.front().type, receive_buffer.messages.front().screen, receive_buffer.messages.front().player, receive_buffer.messages.front().message);

                    message_buffer.push_back(receive_buffer.messages.front());
                    receive_buffer.messages.pop_front();
                }
            }
        }

        // pLogDebug("UDP packets sent %d recv %d", udp_packet_sent, udp_packet_recd);

        tick++;
        return true;
    }

    return false;
}

void NetworkClient::client_loop()
{
    // bool fast_forward = (status.client_state > CLIENT_LOBBY) && (receive_buffer.available_frame > tick + 8);
    if(!tcp_control.socket || !SDLNet_CheckSockets(socket_set, 0))
    {
        // currently, sleep 2ms here (waiting on messages from the main thread), then check again
        // if(!fast_forward)
        SDL_SemWaitTimeout(client_wakeup, 2);

        if(tcp_control.socket)
            SDLNet_CheckSockets(socket_set, 0);
    }

    // hang up on error
    if(tcp_control.err || tcp_data.err)
    {
        Disconnect();
        if(SDL_AtomicGet(&status_req_state) > REQUEST_IDLE)
        {
            status = ClientStatus();
            SDL_AtomicSet(&status_req_state, REQUEST_COMPLETED);
        }

        if(SDL_AtomicGet(&message_buffer_state) == REQUEST_PENDING)
            SDL_AtomicSet(&message_buffer_state, REQUEST_COMPLETED);
    }

    // section to handle connection status updates
    if(SDL_AtomicGet(&status_req_state) == REQUEST_SUBMIT)
    {
        // if we shouldn't be connected, disconnect!
        if(status_req.client_state == CLIENT_OFF)
        {
            Disconnect();
        }
        // otherwise, we should be connected.
        else if(status_req.server_address != status.server_address || !tcp_control.socket)
        {
            // this will update status if it succeeds
            Connect(status_req.server_address.c_str(), status_req.server_port);
        }

        // if not currently connected, ensure status is cleared and return early
        if(!tcp_control.socket)
        {
            status = ClientStatus();
            SDL_AtomicSet(&status_req_state, REQUEST_COMPLETED);
            return;
        }

        if(status_req.client_state != status.client_state)
        {
            // always shift through lobby (in the future...)
            if(status.client_state != CLIENT_LOBBY && status.client_state != CLIENT_SESSION_CONFIG)
            {
                // request leave room, mark as pending
                return;
            }

            if(status.client_state == CLIENT_SESSION_CONFIG)
            {
                if(status_req.client_state == CLIENT_GUEST)
                {
                    std::array<uint8_t, 1> to_send =
                    {
                        HEADER_GET_SESSION,
                    };

                    SDLNet_TCP_Send(tcp_control.socket, to_send.data(), to_send.size());
                }
                else if(status_req.client_state == CLIENT_HOST)
                {
                    // encode session here
                    std::array<uint8_t, 9> to_send =
                    {
                        HEADER_PUT_SESSION,
                        0, 0, 0, 4,
                        uint8_t(g_session.random_seed  >> 24), uint8_t(g_session.random_seed  >> 16), uint8_t(g_session.random_seed  >> 8), uint8_t(g_session.random_seed  >> 0),
                    };

                    SDLNet_TCP_Send(tcp_control.socket, to_send.data(), to_send.size());
                }

                SDL_AtomicSet(&status_req_state, REQUEST_PENDING);
                return;
            }
            else if(status_req.client_state == CLIENT_GUEST)
            {
                auto room_key = status_req.room_info.room_key;
                std::array<uint8_t, 5> to_send =
                {
                    HEADER_JOIN_ROOM,
                    uint8_t(room_key >> 24), uint8_t(room_key >> 16), uint8_t(room_key >> 8), uint8_t(room_key >> 0),
                };

                SDLNet_TCP_Send(tcp_control.socket, to_send.data(), to_send.size());
            }
            else if(status_req.client_state == CLIENT_HOST)
            {
                const auto& room_info = status_req.room_info;

                std::array<uint8_t, 13> to_send =
                {
                    HEADER_CREATE_ROOM,
                    uint8_t(room_info.engine_hash  >> 24), uint8_t(room_info.engine_hash  >> 16), uint8_t(room_info.engine_hash  >> 8), uint8_t(room_info.engine_hash  >> 0),
                    uint8_t(room_info.asset_hash   >> 24), uint8_t(room_info.asset_hash   >> 16), uint8_t(room_info.asset_hash   >> 8), uint8_t(room_info.asset_hash   >> 0),
                    uint8_t(room_info.content_hash >> 24), uint8_t(room_info.content_hash >> 16), uint8_t(room_info.content_hash >> 8), uint8_t(room_info.content_hash >> 0),
                };

                SDLNet_TCP_Send(tcp_control.socket, to_send.data(), to_send.size());
            }

            SDL_AtomicSet(&status_req_state, REQUEST_PENDING);
            return;
        }

        if(status_req.room_info.room_key != status.room_info.room_key)
        {
            if(status_req.client_state == CLIENT_LOBBY)
            {
                // send room info request
                auto room_key = status_req.room_info.room_key;
                std::array<uint8_t, 5> to_send =
                {
                    HEADER_ROOM_INFO,
                    uint8_t(room_key >> 24), uint8_t(room_key >> 16), uint8_t(room_key >> 8), uint8_t(room_key >> 0),
                };

                SDLNet_TCP_Send(tcp_control.socket, to_send.data(), to_send.size());

                SDL_AtomicSet(&status_req_state, REQUEST_PENDING);
                return;
            }
        }

        // all done with the request
        SDL_AtomicSet(&status_req_state, REQUEST_COMPLETED);
        return;

        // // if currently in a room, try to leave it
        // if(status.client_state != CLIENT_LOBBY)
        // {
        //     // ...
        //     SDL_AtomicSet(&status_req_state, REQUEST_PENDING);
        //     return;
        // }

        // // try to join a room as a guest
        // if(status_req.client_state == CLIENT_GUEST)
        // {
        //     // try to leave the room
        //     // ...
        //     SDL_AtomicSet(&status_req_state, REQUEST_PENDING);
        // }
    }

    // section to send pending messages
    if(SDL_AtomicGet(&message_buffer_state) == REQUEST_SUBMIT)
        SendAll();

    // section to handle incoming TCP control messages
    if(tcp_control.FillBufferTo_NB(1))
    {
        if(tcp_control.buffer[0] == HEADER_ROOM_INFO)
        {
            if(!tcp_control.FillBufferTo_NB(17))
                return;

            const auto& buffer = tcp_control.buffer;

            uint32_t got_room_key = ((uint32_t)buffer[1] << 24) | ((uint32_t)buffer[2] << 16) | ((uint32_t)buffer[3] << 8) | ((uint32_t)buffer[4] << 0);
            uint32_t engine_hash = ((uint32_t)buffer[5] << 24) | ((uint32_t)buffer[6] << 16) | ((uint32_t)buffer[7] << 8) | ((uint32_t)buffer[8] << 0);
            uint32_t asset_hash = ((uint32_t)buffer[9] << 24) | ((uint32_t)buffer[10] << 16) | ((uint32_t)buffer[11] << 8) | ((uint32_t)buffer[12] << 0);
            uint32_t content_hash = ((uint32_t)buffer[13] << 24) | ((uint32_t)buffer[14] << 16) | ((uint32_t)buffer[15] << 8) | ((uint32_t)buffer[16] << 0);

            tcp_control.ShiftBuffer(17);

            // ignore unexpected (stale?) rooom key responses
            if(SDL_AtomicGet(&status_req_state) == REQUEST_PENDING && got_room_key == status_req.room_info.room_key)
            {
                status.room_info.room_key = got_room_key;
                status.room_info.engine_hash = engine_hash;
                status.room_info.asset_hash = asset_hash;
                status.room_info.content_hash = content_hash;

                SDL_AtomicSet(&status_req_state, REQUEST_COMPLETED);
            }
        }
        else if(tcp_control.buffer[0] == HEADER_ROOM_KEY)
        {
            if(!tcp_control.FillBufferTo_NB(13))
                return;

            const auto& buffer = tcp_control.buffer;

            status.room_info.room_key = ((uint32_t)buffer[1] << 24) | ((uint32_t)buffer[2] << 16) | ((uint32_t)buffer[3] << 8) | ((uint32_t)buffer[4] << 0);

            status.client_index = buffer[5];

            fast_forward_to = ((int)buffer[6] << 16) | ((int)buffer[7] << 8) | ((int)buffer[8] << 0);

            session_key = ((uint32_t)buffer[9] << 24) | ((uint32_t)buffer[10] << 16) | ((uint32_t)buffer[11] << 8) | ((uint32_t)buffer[12] << 0);

            tcp_control.ShiftBuffer(13);

            if(status_req.room_info.room_key && status.room_info.room_key != status_req.room_info.room_key)
            {
                pLogWarning("Server placed client in unexpected room");
                Disconnect();
            }

            // register data TCP channel (would actually be ideal to CONNECT it here)
            {
                std::array<uint8_t, 5> to_send =
                {
                    HEADER_DATA_CHANNEL,
                    uint8_t(session_key >> 24), uint8_t(session_key >> 16), uint8_t(session_key >> 8), uint8_t(session_key >> 0),
                };

                SDLNet_TCP_Send(tcp_data.socket, to_send.data(), to_send.size());
            }

            // register data UDP channel
            {
                udp_packet->data[0] = uint8_t(session_key >> 24);
                udp_packet->data[1] = uint8_t(session_key >> 16);
                udp_packet->data[2] = uint8_t(session_key >> 8);
                udp_packet->data[3] = uint8_t(session_key >> 0);

                udp_packet->len = 4;

                for(int i = 0; i < 4; i++)
                {
                    SDLNet_UDP_Send(udp_socket, 0, udp_packet);
                    SDL_Delay(1);
                }
            }

            udp_packet_sent = 0;
            udp_packet_recd = 0;

            // reset send and receive buffers
            receive_buffer = RecvBuffer();
            send_buffer = SendBuffer();

            pLogInfo("NetPlay: joining room %s", DisplayRoom(status.room_info.room_key).room_name);

            status.client_state = CLIENT_SESSION_CONFIG;

            if(SDL_AtomicGet(&status_req_state) == REQUEST_PENDING)
                SDL_AtomicSet(&status_req_state, REQUEST_SUBMIT);
        }
        else if(tcp_control.buffer[0] == HEADER_GET_SESSION)
        {
            if(!tcp_control.FillBufferTo_NB(1))
                return;

            tcp_control.ShiftBuffer(1);

            if(SDL_AtomicGet(&status_req_state) == REQUEST_PENDING && status.client_state == CLIENT_SESSION_CONFIG)
            {
                status.client_state = CLIENT_HOST;
                pLogDebug("The random seed is %d", (int)g_session.random_seed);
                SDL_AtomicSet(&status_req_state, REQUEST_COMPLETED);
            }
            else
                Disconnect();
        }
        else if(tcp_control.buffer[0] == HEADER_PUT_SESSION)
        {
            if(!tcp_control.FillBufferTo_NB(5))
                return;

            uint32_t session_size = ((uint32_t)tcp_control.buffer[1] << 24) | ((uint32_t)tcp_control.buffer[2] << 16) | ((uint32_t)tcp_control.buffer[3] << 8) | ((uint32_t)tcp_control.buffer[4] << 0);

            tcp_control.ShiftBuffer(5);

            // decode session here

            // handle this later, once we know exactly what we're filling
            if(session_size > network_client_buffer_size)
                Disconnect();

            // note: not NB
            if(!tcp_control.FillBufferTo(session_size))
                Disconnect();

            tcp_control.ShiftBuffer(session_size);

            if(SDL_AtomicGet(&status_req_state) == REQUEST_PENDING && status.client_state == CLIENT_SESSION_CONFIG)
            {
                g_session.random_seed = ((uint32_t)tcp_control.buffer[0] << 24) | ((uint32_t)tcp_control.buffer[1] << 16) | ((uint32_t)tcp_control.buffer[2] << 8) | ((uint32_t)tcp_control.buffer[3] << 0);
                status.client_state = CLIENT_GUEST;
                pLogDebug("The random seed is %d", (int)g_session.random_seed);
                SDL_AtomicSet(&status_req_state, REQUEST_COMPLETED);
            }
            else
                Disconnect();
        }
        else if(tcp_control.buffer[0] == HEADER_ACK)
        {
            if(!tcp_control.FillBufferTo_NB(4))
                return;

            acked_frame = ((int)tcp_control.buffer[1] << 16) | ((int)tcp_control.buffer[2] << 8) | ((int)tcp_control.buffer[3] << 0);

            if(acked_frame >= ping_send_frame && ping_send_frame != 0)
            {
                latency_ms = SDL_GetTicks() - ping_send_ms;
                latency_frames = tick - ping_send_frame;
                ping_send_frame = 0;
                pLogDebug("TCP latency: %u ms, %d ticks", latency_ms, latency_frames);
            }

            tcp_control.ShiftBuffer(4);
        }
        // notice of current frame (for fast-forward)
        else if(tcp_control.buffer[0] == HEADER_FRAME_COMPLETE)
        {
            if(!tcp_control.FillBufferTo_NB(4))
                return;

            // fixme: consider how to handle
            fast_forward_to = ((int)tcp_control.buffer[1] << 16) | ((int)tcp_control.buffer[2] << 8) | ((int)tcp_control.buffer[3] << 0);

            tcp_control.ShiftBuffer(4);
        }
    }

    // handle incoming data messages from TCP data channel
    if(status.client_state > CLIENT_LOBBY)
    {
        // if(!fast_forward)
        //     SendData();

        ReceiveData();

        if(SDL_AtomicGet(&message_buffer_state) == REQUEST_PENDING && WaitAndFill())
        {
            SDL_AtomicSet(&message_buffer_state, REQUEST_COMPLETED);
            SDL_SemPost(game_wakeup);
        }
    }
}

} // namespace XMessage


================================================
FILE: src/main/client.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef THEXTECH_ENABLE_SDL_NET
#error "client.h cannot be included in a build without SDL_net support"
#endif

#ifndef XCLIENT_H
#define XCLIENT_H

#include <cstdint>
#include <cstddef>
#include <climits>
#include <deque>

#include <SDL_net.h>
#include <SDL2/SDL_atomic.h>
#include <SDL2/SDL_thread.h>

#include "message.h"
#include "client_methods.h"

namespace XMessage
{

static constexpr size_t network_client_buffer_size = 2048;

enum NetworkHeader
{
    // HEADER_CLIENT_JOIN = 1,
    // HEADER_CLIENT_LOSS = 2,
    // HEADER_TEXT_EVENT = 3,
    HEADER_FRAME_COMPLETE = 4,
    // HEADER_YOU_ARE = 5,
    // HEADER_RAND_SEED = 6,
    // HEADER_TIME_IS = 7,
    HEADER_LEFT_ROOM = 8,

    HEADER_ROOM_KEY = 9,
    HEADER_ROOM_INFO = 10,

    HEADER_CREATE_ROOM = 11,
    HEADER_JOIN_ROOM = 12,

    HEADER_DATA_CHANNEL = 13,
    HEADER_ACK = 14,

    HEADER_PUT_SESSION = 15,
    HEADER_GET_SESSION = 16,
};

// enum BufferState
// {
//     OWNER_GAME = 0,
//     OWNER_CLIENT = 1,
//     OWNER_CLIENT_RECV = 2,
// };

enum RequestState
{
    // game is owner of request fields
    REQUEST_COMPLETED = -1,
    REQUEST_IDLE = 0,
    // client thread is owner of request fields
    REQUEST_SUBMIT = 1,
    REQUEST_PENDING = 2,
};

struct TCPWrapper
{
    TCPsocket socket = nullptr;
    uint8_t buffer[network_client_buffer_size];
    size_t buffer_used = 0;
    bool err = false;

    // returns true if something has been read from the socket
    bool FillBuffer(bool nb = false);

    // returns true if something has been read from the socket, false if connection is broken
    bool FillBufferTo(size_t fill);

    // returns true if the TCP buffer has been filled to this point, false if not ready yet
    bool FillBufferTo_NB(size_t fill);

    // shift the buffer after reading n bytes
    void ShiftBuffer(size_t shift);
};

struct RecvBuffer
{
    std::deque<Message> messages;
    std::vector<Message> tcp_frame_in_progress;
    int tcp_frame_index = -1;

    int available_frame = -1;
};

struct SendBuffer
{
    std::deque<Message> messages;
    int current_frame = -1;

    std::vector<uint8_t> tcp_transmit_in_progress;
    size_t tcp_transmit_pos = 0;
};

struct NetworkClient
{
    SDL_Thread* thread = nullptr;
    SDL_sem* client_wakeup = nullptr;
    SDL_sem* game_wakeup = nullptr;
    bool shutdown = false;

    TCPWrapper tcp_control;
    TCPWrapper tcp_data;
    UDPsocket  udp_socket = nullptr;
    UDPpacket* udp_packet = nullptr;

    int udp_packet_sent = 0;
    int udp_packet_recd = 0;

    SDLNet_SocketSet socket_set = nullptr;
    int tick = 0;
    uint32_t session_key = 0;

    int fast_forward_to = INT_MAX;

    SDL_atomic_t status_req_state;
    ClientStatus status_req;
    ClientStatus status;

    RecvBuffer receive_buffer;
    SendBuffer send_buffer;

    SDL_atomic_t message_buffer_state;
    std::deque<Message> message_buffer;

    // ping info
    int ping_send_frame = -1;
    uint32_t ping_send_ms = 0;
    int acked_frame = 0;

    uint32_t latency_ms = 0;
    int latency_frames = 0;

    bool sdlnet_inited = false;

    void EnsureThread();

    void Connect(const char* host, int port);
    void Disconnect(bool shutdown = false);

    void Shutdown();

    XMessage::Message ParseMessage(const uint8_t* message);

    // misc in-game calls
    void LeaveRoom();

    // load messages into send buffer
    void SendAll();

    // transmit messages
    void SendData();

    // receive messages
    void ReceiveData();

    bool WaitAndFill();

    // misc lobby calls
    void JoinNewRoom(const RoomInfo& room_info);

    // this is the primary loop for the client thread
    void client_loop();
};

} // namespace XMessage

#endif // #ifndef XCLIENT_H


================================================
FILE: src/main/client_methods.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <deque>

#include "controls.h"
#include "message.h"
#include "globals.h"
#include "sound.h"
#include "change_res.h"

#include "core/events.h"

#include "main/client.h"
#include "main/client_methods.h"
#include "main/screen_progress.h"

std::string g_netplayServer = "thextech.link";
std::string g_netplayNickname;

namespace XMessage
{

static NetworkClient s_network_client;

bool in_fast_forward = false;
uint32_t fast_forward_begin_ms = 0;
uint32_t fast_forward_begin_frame = 0;

void Connect(const char* host)
{
    s_network_client.EnsureThread();

    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE)
        return;

    s_network_client.status_req = ClientStatus();
    s_network_client.status_req.client_state = CLIENT_LOBBY;
    s_network_client.status_req.server_address = (host) ? host : g_netplayServer;

    SDL_AtomicSet(&s_network_client.status_req_state, REQUEST_SUBMIT);
}

void Disconnect()
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE)
        return;

    s_network_client.status_req = ClientStatus();

    SDL_AtomicSet(&s_network_client.status_req_state, REQUEST_SUBMIT);

    if(!s_network_client.thread)
        SDL_AtomicSet(&s_network_client.status_req_state, REQUEST_COMPLETED);
}

void Shutdown()
{
    s_network_client.Shutdown();
}

const ClientStatus* GetClientStatus()
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE)
        return nullptr;

    return &s_network_client.status;
}

bool CompleteRequest()
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) == REQUEST_COMPLETED)
    {
        SDL_AtomicSet(&s_network_client.status_req_state, REQUEST_IDLE);
        return true;
    }

    return false;
}

Status GetStatus()
{
    if(CurrentRoom())
    {
        if(in_fast_forward)
            return Status::replay;
        else
            return Status::connected;
    }
    else
        return Status::local;
}

void ClientFrameSync(std::deque<Message>& buffer)
{
    bool start_fast_forward = (s_network_client.tick < s_network_client.fast_forward_to - 8);
    bool end_fast_forward = (s_network_client.tick >= s_network_client.fast_forward_to);
    if(!in_fast_forward && start_fast_forward)
    {
        in_fast_forward = true;
        fast_forward_begin_ms = SDL_GetTicks();
        fast_forward_begin_frame = s_network_client.tick;
    }
    else if(in_fast_forward)
    {
        IndicateProgress(fast_forward_begin_ms, num_t(s_network_client.tick - fast_forward_begin_frame) / (s_network_client.fast_forward_to - fast_forward_begin_frame), "Loading game history...");

        if(end_fast_forward)
        {
            in_fast_forward = false;
            // start playing music when no longer fast forwarding
            UpdateMusicVolume();
            // update current resolution (may need to resync screen size)
            UpdateInternalRes();
        }
    }

    SDL_assert_release(SDL_AtomicGet(&s_network_client.message_buffer_state) == REQUEST_IDLE);

    std::swap(s_network_client.message_buffer, buffer);

    SDL_AtomicSet(&s_network_client.message_buffer_state, REQUEST_SUBMIT);
    SDL_SemPost(s_network_client.client_wakeup);

    while(SDL_AtomicGet(&s_network_client.message_buffer_state) != REQUEST_COMPLETED)
    {
        // wait for a wakeup call from the network thread, refreshing events every 5ms
        if(SDL_SemWaitTimeout(s_network_client.game_wakeup, 5) < 0)
        {
            XEvents::doEvents();
        }
    }

    std::swap(s_network_client.message_buffer, buffer);

    SDL_AtomicSet(&s_network_client.message_buffer_state, REQUEST_IDLE);
}

bool RequestFillRoomInfo(uint32_t room_key)
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE || s_network_client.status_req.client_state != CLIENT_LOBBY)
        return false;

    s_network_client.status_req.room_info.room_key = room_key;

    SDL_AtomicSet(&s_network_client.status_req_state, REQUEST_SUBMIT);
    return true;
}

const RoomInfo* GetRoomInfo()
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE)
        return nullptr;

    return &s_network_client.status.room_info;
}


void JoinNewRoom(const RoomInfo& room_info)
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE || s_network_client.status.client_state != CLIENT_LOBBY)
        return;

    s_network_client.status_req.client_state = CLIENT_HOST;
    s_network_client.status_req.room_info = room_info;

    XMessage::g_session.random_seed = iRand(2147483647);

    SDL_AtomicSet(&s_network_client.status_req_state, REQUEST_SUBMIT);
}

void JoinRoom(uint32_t room_key)
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE || s_network_client.status.client_state != CLIENT_LOBBY)
        return;

    s_network_client.status_req.client_state = CLIENT_GUEST;
    s_network_client.status_req.room_info.room_key = room_key;

    SDL_AtomicSet(&s_network_client.status_req_state, REQUEST_SUBMIT);
}

uint32_t CurrentRoom()
{
    if(SDL_AtomicGet(&s_network_client.status_req_state) > REQUEST_IDLE || s_network_client.status.client_state == CLIENT_LOBBY)
        return 0;

    return s_network_client.status.room_info.room_key;
}

void LeaveRoom()
{
    s_network_client.LeaveRoom();
}

uint32_t RoomFromString(const std::string& room)
{
    if(room.size() != 6 && !(room.size() == 7 && room[3] == '-'))
        return 0;

    uint32_t sum = 0;
    uint32_t shift = 30;
    for(size_t i = 0; i < room.size(); i++)
    {
        if(i == 3 && room.size() == 7)
            continue;

        shift -= 5;

        char c = room[i];
        if(c < 48 || (c > 57 && c < 65) || (c > 90 && c < 97) || c > 122)
            return 0;

        if(c >= 97)
            c -= 32;

        const uint8_t digit_codes[10] = {14, 8, 25, 26, 27, 18, 28, 29, 30, 31};

        if(c >= 65)
            sum += (uint32_t)(c - 65) << shift;
        else
            sum += (uint32_t)digit_codes[c - 48] << shift;
    }

    return sum;
}

RoomName DisplayRoom(uint32_t room_key)
{
    RoomName ret;
    ret.room_name[0] = '\0';

    if(room_key == 0 || room_key & (3 << 30))
        return ret;

    const char letters[33] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ346789";

    ret.room_name[3] = '-';
    ret.room_name[7] = '\0';
    uint32_t shift = 30;
    for(int i = 0; i < 6; i++)
    {
        shift -= 5;
        int index = (i >= 3) ? i + 1 : i;
        ret.room_name[index] = letters[(room_key >> shift) & 31];
    }

    return ret;
}

} // namespace XMessage


================================================
FILE: src/main/client_methods.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef THEXTECH_ENABLE_SDL_NET
#error "client_methods.h cannot be included in a build without SDL_net support"
#endif

#ifndef XCLIENT_METHODS_H
#define XCLIENT_METHODS_H

#include <deque>
#include <cstdint>
#include <string>

#include "message.h"

extern std::string g_netplayServer;
extern std::string g_netplayNickname;


namespace XMessage
{

struct RoomInfo
{
    uint32_t room_key = 0;
    uint32_t engine_hash = 0;
    uint32_t asset_hash = 0;
    uint32_t content_hash = 0;
};


struct RoomName
{
    char room_name[8];
};

enum ClientState
{
    CLIENT_OFF = 0,
    CLIENT_SESSION_CONFIG, // joined room but haven't yet sent/received session
    CLIENT_LOBBY,
    CLIENT_HOST_IDLE,
    CLIENT_HOST_SPECTATED,
    CLIENT_HOST,
    CLIENT_GUEST,
    CLIENT_SPECTATOR,
};

struct ClientStatus
{
    ClientState client_state = CLIENT_OFF;
    std::string server_address;
    int server_port = 4305;
    RoomInfo room_info;
    int client_index = 0;
};

void Connect(const char* host = nullptr);
void Disconnect();
void Shutdown();
const ClientStatus* GetClientStatus();
bool CompleteRequest();

void ClientFrameSync(std::deque<Message>& buffer);

bool RequestFillRoomInfo(uint32_t room_key);
const RoomInfo* GetRoomInfo();

void JoinNewRoom(const RoomInfo& room_info);
void JoinRoom(uint32_t room_key);
uint32_t CurrentRoom();
void LeaveRoom();

uint32_t RoomFromString(const std::string& room);
RoomName DisplayRoom(uint32_t room_key);

} // namespace XMessage

#endif // #ifndef XCLIENT_METHODS_H


================================================
FILE: src/main/game_globals.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GAME_GLOBALS_H
#define GAME_GLOBALS_H

#include "screen.h"
#include "../screen_fader.h"
#include "../range_arr.hpp"

extern ScreenFader g_levelScreenFader;
extern RangeArr<ScreenFader, 0, c_vScreenCount> g_levelVScreenFader;

// delay following current level should be shortened by 16 frames / 250 milliseconds,
// because current level ended with the fade out from an offscreen exit
extern bool g_ShortDelay;

extern void clearScreenFaders();
extern void updateScreenFaders();
extern void levelWaitForFade(int waitTicks); // wait waitTicks frames for the fader (or no-fader) to finish
extern void editorWaitForFade();

#endif // GAME_GLOBALS_H


================================================
FILE: src/main/game_info.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <fmt_format_ne.h>
#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <Utils/strings.h>
#include <Archives/archives.h>
#include <IniProcessor/ini_processing.h>
#include <PGE_File_Formats/pge_file_lib_globs.h>

#include "game_info.h"
#include "script/luna/luna.h"

#include "globals.h"

#include "../version.h"


GameInfo g_gameInfo;

static void readCheats(IniProcessing &conf, std::vector<GameInfo::CheatAlias> &dst, const std::string &group)
{
    dst.clear();
    conf.beginGroup(group);
    {
        auto ak = conf.allKeys();
        for(const auto &k : ak)
        {
            GameInfo::CheatAlias ca;
            ca.first = k;
            conf.read(k.c_str(), ca.second, std::string());
            if(ca.second.empty())
                continue; // Skip empty aliases
            dst.push_back(ca);
        }
    }
    conf.endGroup();
}

const std::string GameInfo::titleWindow() const
{
#if defined(ENABLE_OLD_CREDITS) && !defined(CUSTOM_GAME_NAME_TITLE)
    return "Super Mario Bros. X - Version 1.3 - www.SuperMarioBrothers.org";
#else
    const char* ver_string = "TheXTech v" V_LATEST_STABLE ", #" V_BUILD_VER;
    return fmt::sprintf_ne("%s - (%s)", this->title.c_str(), ver_string);
#endif
}

void GameInfo::InitGameInfo()
{
#ifdef CUSTOM_GAME_NAME_TITLE
    title = CUSTOM_GAME_NAME_TITLE;
#else
#   ifdef ENABLE_OLD_CREDITS
    title = "Super Mario Bros. X";
#   else
    title = "TheXTech Engine";
#   endif
#endif /* CUSTOM_GAME_NAME_TITLE */

    statusIconName.clear();

    characterName[1] = "Mario";
    characterName[2] = "Luigi";
    characterName[3] = "Peach";
    characterName[4] = "Toad";
    characterName[5] = "Link";

    fails_counter_title = "FAILS";

    wordStarAccusativeSingular = "star";
    wordStarAccusativeDual_Cnt = "";
    wordStarAccusativePlural = "stars";

    creditsFont = 5;

#ifdef CUSTOM_CREDITS_URL
    creditsHomePage = CUSTOM_CREDITS_URL;
#else
#   ifdef ENABLE_OLD_CREDITS
    creditsHomePage = "www.SuperMarioBrothers.org";
#   else
    creditsHomePage = "wohlsoft.ru";
#   endif
#endif

    disableTwoPlayer = false;
    disableBattleMode = false;

    activity_settings_in_compat = false;
    contentFeatureLevel = 0;

    ResetIntroActivitySettings();
    ResetOutroActivitySettings();
}

void GameInfo::ResetIntroActivitySettings()
{
    introEnableActivity = true;
    introMaxPlayersCount = 6;
    introCharacters = {1, 2, 3, 4, 5};
    introCharacterCurrent = 0;
    introDeadMode = false;
}

void GameInfo::ResetOutroActivitySettings()
{
    outroEnableActivity = true;
    outroMaxPlayersCount = 5;
    outroCharacters = {1, 2, 3, 4, 5};
    outroStates = {4, 7, 5, 3, 6};
    outroMounts = {0, 3, 0, 1, 0};
    outroCharacterCurrent = 0;
    outroInitialDirections = {0, 0, 0, 0, 0};
    outroWalkDirection = -1;
    outroAutoJump = true;
    outroDeadMode = false;
}

void GameInfo::LoadGameInfo()
{
    InitGameInfo();

    std::string gameInfoPath = AppPath + "gameinfo.ini";
    if(Files::fileExists(gameInfoPath))
    {
        IniProcessing config = Files::load_ini(gameInfoPath);

        config.beginGroup("game");
        {
            if(config.hasKey("title"))
                config.read("title", title, title);
            config.read("disable-two-player", disableTwoPlayer, false);
            config.read("disable-battle-mode", disableBattleMode, false);
            config.read("status-icon-name", statusIconName, std::string());
            config.read("feature-level-supported", contentFeatureLevel, 0);

            constexpr unsigned int engineFeatureLevel = V_FEATURE_LEVEL;
            if(contentFeatureLevel > engineFeatureLevel)
            {
                pLogDebug("Limiting asset pack to feature level %u (supports %u)", engineFeatureLevel, contentFeatureLevel);
                contentFeatureLevel = engineFeatureLevel;
            }
        }
        config.endGroup();

        // legacy options
        if(!config.beginGroup("fails-counter"))
        {
            config.beginGroup("death-counter"); // Backup fallback
        }
        {
            config.read("title", fails_counter_title, fails_counter_title);
        }
        config.endGroup();

        config.beginGroup("objects");
        {
            config.read("star", wordStarAccusativeSingular, "star");
            config.read("star-singular", wordStarAccusativeSingular, g_gameInfo.wordStarAccusativeSingular);
            config.read("star-plural", wordStarAccusativePlural, g_gameInfo.wordStarAccusativeSingular + "s");
        }
        config.endGroup();

        config.beginGroup("characters");
        {
            for(int i = 1; i <= numCharacters; ++i)
            {
                std::string name = fmt::sprintf_ne("name%d", i);
                config.read(name.c_str(),
                            characterName[i],
                            characterName[i]);
            }
        }
        config.endGroup();

        if(!Archives::has_prefix(AppPath))
        {
            config.beginGroup("intro");
            LoadIntroActivitySettings(config);
            config.endGroup();

            config.beginGroup("outro");
            LoadOutroActivitySettings(config);
            config.endGroup();
        }

        config.beginGroup("credits");
        {
            config.read("font", creditsFont, 5);
            config.read("homepage", creditsHomePage, creditsHomePage);

            std::string value;
            Strings::dealloc(creditsGame);

            std::string credits_file;
            config.read("game-credits-file", credits_file, "");

            if(!credits_file.empty())
            {
                PGE_FileFormats_misc::RWopsTextInput input(Files::open_file(AppPath + credits_file, "r"));
                while(!input.eof())
                {
                    input.readLine(value);
                    if(!value.empty() || !input.eof())
                        creditsGame.push_back(value);
                }
            }

            if(creditsGame.empty())
            {
                // Old format
                for(int cr = 1; ; cr++)
                {
                    std::string key = fmt::sprintf_ne("game-credit-%d", cr);
                    if(!config.hasKey(key))
                        break;
                    config.read(key.c_str(), value, value);
                    creditsGame.push_back(value);
                }
            }
        }
        config.endGroup();

        readCheats(config, cheatsGlobalAliases, "cheats-global-aliases");
        readCheats(config, cheatsGlobalRenames, "cheats-global-renames");
        readCheats(config, cheatsWorldAliases, "cheats-world-aliases");
        readCheats(config, cheatsWorldRenames, "cheats-world-renames");
        readCheats(config, cheatsLevelAliases, "cheats-level-aliases");
        readCheats(config, cheatsLevelRenames, "cheats-level-renames");
    }
}

void GameInfo::LoadIntroActivitySettings(IniProcessing& config)
{
    config.read("enable-activity", introEnableActivity, introEnableActivity);
    config.read("max-players-count", introMaxPlayersCount, introMaxPlayersCount);
    config.read("characters", introCharacters, introCharacters);
    introDeadMode = !introEnableActivity || introMaxPlayersCount < 1;
}

void GameInfo::LoadOutroActivitySettings(IniProcessing& config)
{
    config.read("enable-activity", outroEnableActivity, outroEnableActivity);
    config.read("max-players-count", outroMaxPlayersCount, outroMaxPlayersCount);
    config.read("characters", outroCharacters, outroCharacters);
    config.read("states", outroStates, outroStates);
    config.read("mounts", outroMounts, outroMounts);
    config.read("auto-jump", outroAutoJump, outroAutoJump);
    IniProcessing::StrEnumMap dirs
    {
        {"left", -1},
        {"idle", 0},
        {"right", +1}
    };
    config.readEnum("walk-direction", outroWalkDirection, outroWalkDirection, dirs);
    config.read("initial-directions", outroInitialDirections, outroInitialDirections);
    outroDeadMode = !outroEnableActivity || outroMaxPlayersCount < 1;
}

int GameInfo::introCharacterNext()
{
    if(introCharacters.empty())
        return 1;
    if(g_gameInfo.introCharacterCurrent >= introCharacters.size())
        g_gameInfo.introCharacterCurrent = 0;
    int ret = g_gameInfo.introCharacters[g_gameInfo.introCharacterCurrent++];

    if(ret > 5) // anti-idiot protection
        ret = 5;
    else if(ret < 1)
        ret = 1;

    return ret;
}

int GameInfo::outroCharacterNext()
{
    if(outroCharacters.empty())
        return 1;
    if(g_gameInfo.outroCharacterCurrent >= outroCharacters.size())
        g_gameInfo.outroCharacterCurrent = 0;
    int ret = g_gameInfo.outroCharacters[g_gameInfo.outroCharacterCurrent++];

    if(ret > 5) // anti-idiot protection
        ret = 5;
    else if(ret < 1)
        ret = 1;

    return ret;
}

void initGameInfo()
{
    g_gameInfo.InitGameInfo();
    g_gameInfo.LoadGameInfo();
}


================================================
FILE: src/main/game_info.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GAME_INFO_H
#define GAME_INFO_H

#include <string>
#include <vector>
#include "global_constants.h"
#include "range_arr.hpp"

class IniProcessing;

struct GameInfo
{
    void InitGameInfo();
    void LoadGameInfo();

    void LoadIntroActivitySettings(IniProcessing& ini);
    void LoadOutroActivitySettings(IniProcessing& ini);

    void ResetIntroActivitySettings();
    void ResetOutroActivitySettings();

    std::string title;
    // std::string titleCredits;
    RangeArr<std::string, 1, numCharacters> characterName;

    std::string fails_counter_title;

    std::string statusIconName;

    std::string wordStarAccusativeSingular;
    std::string wordStarAccusativeDual_Cnt;
    std::string wordStarAccusativePlural;

    bool disableBattleMode = true;
    bool disableTwoPlayer = true;

    int creditsFont = 4;
    std::string creditsHomePage;
    std::vector<std::string> creditsGame;

    bool activity_settings_in_compat = false;

    bool introEnableActivity = true;
    int  introMaxPlayersCount = 6;
    std::vector<int> introCharacters;

    bool introDeadMode = true;

    bool outroEnableActivity = true;
    int  outroMaxPlayersCount = 5;
    bool outroAutoJump = true;
    std::vector<int> outroCharacters;
    std::vector<int> outroStates;
    std::vector<int> outroMounts;
    std::vector<int> outroInitialDirections;
    int  outroWalkDirection = -1;

    bool outroDeadMode = true;

    unsigned int contentFeatureLevel = 0;

    typedef std::pair<std::string, std::string> CheatAlias;

    std::vector<CheatAlias> cheatsGlobalAliases;
    std::vector<CheatAlias> cheatsGlobalRenames;

    std::vector<CheatAlias> cheatsWorldAliases;
    std::vector<CheatAlias> cheatsWorldRenames;

    std::vector<CheatAlias> cheatsLevelAliases;
    std::vector<CheatAlias> cheatsLevelRenames;

    // Carousel
    int introCharacterNext();
    size_t introCharacterCurrent = 0;

    int outroCharacterNext();
    size_t outroCharacterCurrent = 0;

    const std::string titleWindow() const;
};

extern GameInfo g_gameInfo;

extern void initGameInfo();

#endif // GAME_INFO_H


================================================
FILE: src/main/game_loop.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <Logger/logger.h>
#include <Integrator/integrator.h>
#include <pge_delay.h>

#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
#   ifdef __WIIU__
#       include <sysapp/launch.h>
#   endif
#   include "frm_main.h"
#endif

#if defined(__16M__) && !defined(__CALICO__)
#include "core/16m/sound_stream_16m.h"
#endif

#include "../globals.h"
#include "../config.h"
#include "../frame_timer.h"
#include "../game_main.h"
#include "../sound.h"
#include "../controls.h"
#include "../effect.h"
#include "../graphics.h"
#include "../blocks.h"
#include "../npc.h"
#include "../layers.h"
#include "../player.h"
#include "../editor.h"
#include "../core/render.h"
#include "../core/events.h"
#include "../core/window.h"
#include "graphics/gfx_update.h"
#include "game_globals.h"
#include "world_globals.h"
#include "speedrunner.h"
#include "main/record.h"
#include "menu_main.h"
#include "change_res.h"
#include "message.h"
#include "screen_pause.h"
#include "screen_connect.h"
#include "screen_options.h"
#include "screen_quickreconnect.h"
#include "screen_textentry.h"
#include "screen_prompt.h"
#include "main/level_medals.h"
#include "main/game_loop_interrupt.h"
#include "script/luna/luna.h"
#include "game_strings.h"

#include "../pseudo_vb.h"

PauseCode GamePaused = PauseCode::None;

//! Holds the screen overlay for the level
ScreenFader g_levelScreenFader;
RangeArr<ScreenFader, 0, c_vScreenCount> g_levelVScreenFader;

void clearScreenFaders()
{
    g_levelScreenFader.clearFader();
    for(int s = 0; s <= c_vScreenCount; ++s)
        g_levelVScreenFader[s].clearFader();
}

void updateScreenFaders()
{
    g_levelScreenFader.update();

    for(int s = 0; s <= c_vScreenCount; ++s)
        g_levelVScreenFader[s].update();
}

void levelWaitForFade(int waitTicks)
{
    while(waitTicks >= 0 && GameIsActive)
    {
        XEvents::doEvents();

        if(canProceedFrame())
        {
            computeFrameTime1();
            Controls::Update(false);
            if(XMessage::GetStatus() != XMessage::Status::replay)
                UpdateGraphicsDraw();
            UpdateSound();
            XEvents::doEvents();
            computeFrameTime2();
            updateScreenFaders();
            waitTicks--;
        }

        if(!g_config.unlimited_framerate)
            PGE_Delay(1);
    }

    // Ensure everything is clear
    if(GameIsActive)
    {
        XEvents::doEvents();
        GraphicsClearScreen();
    }
}

void editorWaitForFade()
{
    while(!g_levelScreenFader.isComplete() && GameIsActive)
    {
        XEvents::doEvents();

        if(canProceedFrame())
        {
            computeFrameTime1();
            if(GamePaused == PauseCode::Prompt)
                PromptScreen::Render();
            else if(WorldEditor)
                UpdateGraphics2();
            else
                UpdateGraphics();
            UpdateSound();
            XEvents::doEvents();
            computeFrameTime2();
            updateScreenFaders();
        }

        if(!g_config.unlimited_framerate)
            PGE_Delay(1);
    }
}


void CheckActive();//in game_main.cpp

GameLoopInterrupt g_gameLoopInterrupt;

void GameLoop()
{
    if(GamePaused != PauseCode::None)
    {
        PauseLoop();

        // resume code (if needed)
        if(GamePaused == PauseCode::None)
        {
            switch(g_gameLoopInterrupt.site)
            {
            case GameLoopInterrupt::UpdatePlayer_MessageNPC:
            case GameLoopInterrupt::UpdatePlayer_TriggerTalk:
            case GameLoopInterrupt::UpdatePlayer_SuperWarp:
                goto resume_UpdatePlayer;
            case GameLoopInterrupt::UpdateNPCs_Activation_Generator:
            case GameLoopInterrupt::UpdateNPCs_Activation_Self:
            case GameLoopInterrupt::UpdateNPCs_Activation_Chain:
            case GameLoopInterrupt::UpdateNPCs_KillNPC:
                goto resume_UpdateNPCs;
            case GameLoopInterrupt::UpdateEvents:
                goto resume_UpdateEvents;
            case GameLoopInterrupt::UpdateBlocks_KillBlock:
            case GameLoopInterrupt::UpdateBlocks_TriggerHit:
            case GameLoopInterrupt::UpdateBlocks_SwitchOn:
            case GameLoopInterrupt::UpdateBlocks_SwitchOff:
            case GameLoopInterrupt::UpdateBlocks_SwitchOff_KillBlock:
                goto resume_UpdateBlocks;
            case GameLoopInterrupt::IntroEvents:
                goto resume_IntroEvents;
            default:
                break;
            }
        }

        return;
    }

    if(g_gameLoopInterrupt.process_intro_events)
    {
        int A;

        for(A = 0; A <= maxEvents; ++A)
        {
            // excluded in SMBX 1.3
            if(A == 1)
                continue;

            if(A == EVENT_LEVEL_START || Events[A].AutoStart)
            {
                eventindex_t resume_index;
                resume_index = ProcEvent_Safe(false, A, 0, EventContext::InitSetup);
                while(resume_index != EVENT_NONE)
                {
                    g_gameLoopInterrupt.A = A;
                    g_gameLoopInterrupt.C = resume_index;
                    g_gameLoopInterrupt.site = GameLoopInterrupt::IntroEvents;
                    return;

resume_IntroEvents:
                    A = g_gameLoopInterrupt.A;
                    resume_index = g_gameLoopInterrupt.C;
                    g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                    resume_index = ProcEvent_Safe(true, resume_index, 0, EventContext::InitSetup);
                }
            }
        }

        g_gameLoopInterrupt.process_intro_events = false;
    }

    g_microStats.start_task(MicroStats::Script);
    lunaLoop();

    g_microStats.start_task(MicroStats::Controls);

    if(!Controls::Update())
    {
        QuickReconnectScreen::g_active = true;

        if(g_config.allow_drop_add && !TestLevel && XMessage::GetStatus() == XMessage::Status::local)
            PauseGame(PauseCode::DropAdd, 0);
    }

    if(QuickReconnectScreen::g_active)
        QuickReconnectScreen::Logic();

    Integrator::sync();

    g_microStats.start_task(MicroStats::Layers);

    if(LevelMacro > LEVELMACRO_OFF)
    {
        UpdateMacro();

        // was previously a nested frameloop, now that logic is still done in UpdateMacro,
        // but per-frame -> we need to skip the rest of the frame if it didn't finish
        if(LevelMacro == LEVELMACRO_KEYHOLE_EXIT)
            return;
    }

    if(BattleMode)
    {
        if(BattleOutro > 0)
        {
            BattleOutro++;

            if(g_config.EnableInterLevelFade && BattleOutro == 195)
                g_levelScreenFader.setupFader(1, 0, 65, ScreenFader::S_FADE);

            if(BattleOutro == 260)
                EndLevel = true;
        }
    }

    if(ErrorQuit)
    {
        EndLevel = true;
        ErrorQuit = false;
        LevelBeatCode = BEATCODE_QUIT;
        pLogWarning("Quit level because of an error");
        XRender::clearBuffer();
    }

    if(EndLevel)
    {
        if(LevelBeatCode > 0)
        {
            if(Checkpoint == FullFileName)
            {
                pLogDebug("Clear check-points at GameLoop()");
                Checkpoint.clear();
                CheckpointsList.clear();
                g_curLevelMedals.reset_checkpoint();
            }

            // Quit to world map when finishing the sub-hub
            if(!NoMap && IsHubLevel && !FileRecentSubHubLevel.empty() && GoToLevel.empty())
            {
                FileRecentSubHubLevel.clear();
                ReturnWarp = 0;
                ReturnWarpSaved = 0;
            }
        }

        if(SwapCharAllowed())
        {
            pLogDebug("Save drop/add characters configuration at EndLevel");
            ConnectScreen::SaveChars();
        }

        speedRun_triggerLeave();
        NextLevel();

        Controls::Update(false);
    }
    else if(qScreen || (g_config.allow_multires && qScreen_canonical))
    {
        g_microStats.start_task(MicroStats::Effects);
        UpdateEffects();
        if(!g_config.modern_section_change)
            speedRun_tick();
        UpdateGraphics();
        updateScreenFaders();

#if defined(__16M__) && !defined(__CALICO__)
        // make sure that streamed audio is still updated on non-threading 16M build
        Sound_StreamUpdate();
#endif
    }
    else if(BattleIntro > 0)
    {
        UpdateGraphics();
        BlockFrames();
        g_microStats.start_task(MicroStats::Sound);
        UpdateSound();
        g_microStats.start_task(MicroStats::NPCs);
        For(A, 1, numNPCs)
            NPCFrames(A);
        BattleIntro--;
        if(BattleIntro == 1)
            PlaySound(SFX_Checkpoint);
        updateScreenFaders();
    }
    else
    {
        if(MagicHand)
            UpdateEditor();

        ClearTriggeredEvents();
        UpdateLayers(); // layers before/after npcs

resume_UpdateNPCs:
        g_microStats.start_task(MicroStats::NPCs);
        if(UpdateNPCs())
            return;

        if(LevelMacro == LEVELMACRO_KEYHOLE_EXIT)
            return; // stop on key exit

resume_UpdateBlocks:
        g_microStats.start_task(MicroStats::Blocks);
        if(UpdateBlocks())
            return;

        g_microStats.start_task(MicroStats::Effects);
        UpdateEffects();

resume_UpdatePlayer:
        g_microStats.start_task(MicroStats::Player);
        if(UpdatePlayer())
            return;

        speedRun_tick();
        // UpdateGraphics() now calls start_task internally
        if(LivingPlayers() || BattleMode)
            UpdateGraphics();
        g_microStats.start_task(MicroStats::Sound);
        UpdateSound();

resume_UpdateEvents:
        g_microStats.start_task(MicroStats::Events);
        if(UpdateEvents())
            return;
//        If MagicHand = True Then UpdateEditor

        updateScreenFaders();

        // Pause game and CaptainN logic
        if((LevelMacro == LEVELMACRO_OFF && CheckLiving() > 0) || SharedPauseForce)
        {
            // this is always able to pause the game even when CaptainN is enabled.
            if(SharedPause)
                PauseInit(PauseCode::PauseScreen, 0);
            // don't let double-pause or double-toggle happen
            else
            {
                for(int p = 1; p <= numPlayers && p <= maxLocalPlayers; p++)
                {
                    // only consider new start presses
                    if(!Player[p].UnStart || !Player[p].Controls.Start)
                        continue;

                    // use limited, buggy code for non-player 1 in compat case
                    if(p != 1 && !g_config.multiplayer_pause_controls)
                    {
                        if(CaptainN || FreezeNPCs)
                        {
                            Player[p].UnStart = false;
                            FreezeNPCs = !FreezeNPCs;
                            PlaySound(SFX_Pause);
                        }

                        // don't let double-pause or double-toggle happen
                        break;
                    }

                    // the special NPC freeze toggling functionality from CaptainN
                    if((CaptainN || FreezeNPCs) && PSwitchStop == 0)
                    {
                        Player[p].UnStart = false;
                        if(FreezeNPCs)
                        {
                            FreezeNPCs = false;
                            if(PSwitchTime > 0)
                                ResumeMusic();
                        }
                        else
                        {
                            FreezeNPCs = true;
                            if(PSwitchTime > 0)
                                PauseMusic();
                        }
                        PlaySound(SFX_Pause);
                    }
                    // normally pause the game
                    else
                        PauseInit(PauseCode::PauseScreen, 0);

                    // don't let double-pause or double-toggle happen
                    break;
                }
            }
        }
    }

    g_microStats.end_frame();
}

void MessageScreen_Init()
{
    switch(g_MessageType)
    {
    case MESSAGE_TYPE_SYS_ERROR:
        SoundPause[SFX_SMGlass] = 0;
        PlaySoundMenu(SFX_SMGlass);
        break;
#ifdef THEXTECH_ASSERTS_INGAME_MESSAGE
    case MESSAGE_TYPE_SYS_FATAL_ASSERT:
        StopMusic();
        SoundPause[SFX_SMGlass] = 0;
        PlayErrorSound(SFX_SMGlass);
        break;
#endif
    default:
        SoundPause[SFX_Message] = 0;
        PlaySound(SFX_Message);
        break;
    }

    if(g_MessageType >= MESSAGE_TYPE_SYS_INFO && MessageTitle.empty())
    {
        switch(g_MessageType)
        {
        case MESSAGE_TYPE_SYS_INFO:
            MessageTitle = g_gameStrings.msgBoxTitleInfo;
            break;
        case MESSAGE_TYPE_SYS_WARNING:
            MessageTitle = g_gameStrings.msgBoxTitleWarning;
            break;
        case MESSAGE_TYPE_SYS_ERROR:
        case MESSAGE_TYPE_SYS_FATAL_ASSERT:
            MessageTitle = g_gameStrings.msgBoxTitleError;
            break;
        default:
            break;
        }
    }

    MenuCursorCanMove = false;
    MenuCursorCanMove_Back = false;
    PrepareMessageDims();
}

bool MessageScreen_Logic(int plr)
{
    // can't check other local shared controls because this is global logic
    bool menuDoPress = SharedPause;
    bool menuBackPress = false;

    if(GameMenu)
    {
        bool clicked = (SharedCursor.Primary || SharedCursor.Secondary);
        menuDoPress |= clicked;
        MenuMouseRelease = !clicked;
    }

    // there was previously code to copy all players' controls from the main player, but this is no longer necessary (and actively harmful in the SingleCoop case)

    if(!g_config.multiplayer_pause_controls && plr == 0)
        plr = 1;

    for(int i = 1; i <= numPlayers; i++)
    {
        // in exclusive mode, skip other players
        if(plr != 0 && i != plr)
            continue;

        const Controls_t& c = Player[i].Controls;

        menuDoPress |= (c.Start || c.Jump);
        menuBackPress |= c.Run;

        // NEW: allow AltJump (Do in alt menu layout) to advance messages
        if(g_config.multiplayer_pause_controls && c.AltJump)
            menuDoPress = true;
    }

    if(!MenuCursorCanMove_Back)
    {
        if(!menuBackPress && MenuCursorCanMove)
            MenuCursorCanMove_Back = true;

        menuBackPress = false;
    }
    else if(menuBackPress)
        MenuCursorCanMove_Back = false;

    if(!MenuCursorCanMove)
    {
        if(!menuDoPress && !menuBackPress)
            MenuCursorCanMove = true;

        return false;
    }

    if(MenuCursorCanMove && (menuDoPress || menuBackPress))
    {
#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
        // When it's a fatal error, just quit everything immediately
        if(g_MessageType == MESSAGE_TYPE_SYS_FATAL_ASSERT)
        {
            GracefulQuit(false);

#ifdef __WIIU__
            if(g_isHBLauncher)
                SYSRelaunchTitle(0, NULL);
#endif

            Controls::Quit();
            QuitMixerX();
            g_frmMain.freeSystem();
#   if defined(__WII__) || defined(__WIIU__)
            exit(0);
#   else
            abort();
#   endif
        }
#endif

        MessageTitle.clear();
        MessageText.clear();
        g_MessageType = MESSAGE_TYPE_NORMAL;
        return true;
    }

    return false;
}

static constexpr int s_max_pause_stack_depth = 4;

struct PauseLoopState
{
    int pause_player = 0;
    PauseCode pause_stack[s_max_pause_stack_depth + 1];
    typedef void (*callback_t)();
    callback_t pause_stack_callback[s_max_pause_stack_depth + 1];
    int pause_stack_depth = 0;
};

static PauseLoopState s_pauseLoopState;

// initializes a certain pause screen (but does not reset the game loop)
void PauseInit(PauseCode code, int plr, void (*callback)())
{
    // initialize pause from main game
    if(GamePaused == PauseCode::None)
    {
        s_pauseLoopState = PauseLoopState();
        s_pauseLoopState.pause_player = plr;

        if(!GameMenu && !LevelEditor)
        {
            for(int A = numPlayers; A >= 1; A--)
                SavedChar[Player[A].Character] = Player[A];
        }

        if(PSwitchTime > 0)
            PauseMusic();
    }
    // push pause code stack
    else if(s_pauseLoopState.pause_stack_depth < s_max_pause_stack_depth)
        s_pauseLoopState.pause_stack_depth++;

    // set pause code
    GamePaused = code;

    // store pause code and pause callback for this pause
    s_pauseLoopState.pause_stack[s_pauseLoopState.pause_stack_depth] = GamePaused;
    s_pauseLoopState.pause_stack_callback[s_pauseLoopState.pause_stack_depth] = callback;

    // init correct pause screen type
    if(code == PauseCode::Message)
        MessageScreen_Init();
    else if(code == PauseCode::PauseScreen)
        PauseScreen::Init(s_pauseLoopState.pause_player, SharedPauseLegacy);
    else if(code == PauseCode::DropAdd)
        ConnectScreen::DropAdd_Start();
    else if(code == PauseCode::Prompt)
        PromptScreen::Init();
    else if(code == PauseCode::Options)
        OptionsScreen::Init();
    else if(code == PauseCode::TextEntry)
    {
        // assume TextEntryScreen has already been inited through its Run function.
    }

    // sync system cursor
    SyncSysCursorDisplay();

    // resetFrameTimer();
}

// finishes the current pause and pops it from the pause stack
static void s_PauseFinish(int stack_level);

// a main loop for cases where the game is paused
void PauseLoop()
{
    int cur_stack_level = s_pauseLoopState.pause_stack_depth;

    g_microStats.start_task(MicroStats::Graphics);

#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
    const bool is_fatal_message = (g_MessageType == MESSAGE_TYPE_SYS_FATAL_ASSERT);
#else
    constexpr bool is_fatal_message = false;
#endif

    if(!is_fatal_message)
        speedRun_tick();

    if(is_fatal_message)
        UpdateGraphicsFatalAssert();
    else if(GamePaused == PauseCode::Prompt)
        PromptScreen::Render();
    else if((LevelSelect && !GameMenu) || WorldEditor)
        UpdateGraphics2();
    else
        UpdateGraphics();

    g_microStats.start_task(MicroStats::Controls);

    if(!Controls::Update())
        QuickReconnectScreen::g_active = true;

    if(QuickReconnectScreen::g_active)
        QuickReconnectScreen::Logic();

    g_microStats.start_task(MicroStats::Sound);

    UpdateSound();
    BlockFrames();

    g_microStats.start_task(MicroStats::Effects);

    UpdateEffects();

    if(LevelSelect)
        g_worldScreenFader.update();
    else
        updateScreenFaders();

    // reset the active player if it is no longer present
    if(s_pauseLoopState.pause_player > numPlayers)
        s_pauseLoopState.pause_player = 0;

    g_microStats.start_task(MicroStats::Script);

    bool pause_done = false;

    // run the appropriate pause logic
    if(qScreen)
    {
        // prevent any logic or unpause from taking place

        // qScreen takes place in WorldLoop, not world graphics
        if(LevelSelect)
            qScreen = Update_qScreen(1);
    }
    else if(GamePaused == PauseCode::Message)
    {
        if(MessageScreen_Logic(s_pauseLoopState.pause_player))
            pause_done = true;
    }
    else if(GamePaused == PauseCode::Prompt)
    {
        if(PromptScreen::Logic())
            pause_done = true;
    }
    else
    {
        // Check messages from the main pause screen first, then everything else. Important for catching delayed messages.
        if(PauseScreen::Logic())
        {
            s_pauseLoopState.pause_stack_depth = 0;
            pause_done = true;
        }
        else if(GamePaused == PauseCode::DropAdd)
        {
            if(ConnectScreen::Logic())
                pause_done = true;
        }
        else if(GamePaused == PauseCode::Options)
        {
            if(OptionsScreen::Logic())
                pause_done = true;
        }
        else if(GamePaused == PauseCode::TextEntry)
        {
            if(TextEntryScreen::Logic())
                pause_done = true;
        }
    }

    g_microStats.end_frame();

    if(pause_done)
        s_PauseFinish(cur_stack_level);
}

static void s_PauseFinish(int stack_level)
{
    // perform callback
    if(s_pauseLoopState.pause_stack_callback[stack_level])
        s_pauseLoopState.pause_stack_callback[stack_level]();

    // special case: remove dropped frame from middle of pause stack
    if(s_pauseLoopState.pause_stack_depth > stack_level)
    {
        for(int i = stack_level; i < s_pauseLoopState.pause_stack_depth; i++)
        {
            s_pauseLoopState.pause_stack[i] = s_pauseLoopState.pause_stack[i + 1];
            s_pauseLoopState.pause_stack_callback[i] = s_pauseLoopState.pause_stack_callback[i + 1];
        }

        s_pauseLoopState.pause_stack_depth--;

        return;
    }

    // pop pause stack
    if(s_pauseLoopState.pause_stack_depth > 0)
    {
        s_pauseLoopState.pause_stack_depth--;
        GamePaused = s_pauseLoopState.pause_stack[s_pauseLoopState.pause_stack_depth];
    }
    // resume main game
    else
    {
        GamePaused = PauseCode::None;

        if(PSwitchTime > 0)
            ResumeMusic();

        // prevent unexpected button presses
        for(int i = 1; i <= numPlayers; i++)
        {
            Player[i].UnStart = false;
            Player[i].CanJump = false;

            // NEW: disable AltJump (used by alt menu controls and optionally used in standard menu controls)
            if(g_config.multiplayer_pause_controls)
                Player[i].CanAltJump = false;
        }
    }

    MenuCursorCanMove = false;

    // sync system cursor
    SyncSysCursorDisplay();

    // resetFrameTimer();
}

void PauseGame(PauseCode code, int plr)
{
//    double fpsTime = 0;
//    int fpsCount = 0;

    // allow waiting for the current pause frame to terminate by triggering PauseGame with PauseCode::None
    if(code != PauseCode::None)
        PauseInit(code, plr);

    int cur_pause_stack_depth = s_pauseLoopState.pause_stack_depth;

    do
    {
        if(canProceedFrame())
        {
            computeFrameTime1();
            computeFrameTime2();

            g_microStats.start_task(MicroStats::Controls);

            XEvents::doEvents();
            CheckActive();

            PauseLoop();
        }

        if(!g_config.unlimited_framerate)
            PGE_Delay(1);

        if(!GameIsActive)
            break;
    } while(GamePaused != PauseCode::None && s_pauseLoopState.pause_stack_depth >= cur_pause_stack_depth);
}


================================================
FILE: src/main/game_loop_interrupt.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GAME_LOOP_INTERRUPT_H
#define GAME_LOOP_INTERRUPT_H

struct GameLoopInterrupt
{
    enum Site
    {
        None = 0,
        IntroEvents,
        UpdatePlayer_MessageNPC,
        UpdatePlayer_TriggerTalk,
        UpdatePlayer_SuperWarp,
        UpdateNPCs_Activation_Generator,
        UpdateNPCs_Activation_Self,
        UpdateNPCs_Activation_Chain,
        UpdateNPCs_KillNPC,
        UpdateEvents,
        UpdateBlocks_KillBlock,
        UpdateBlocks_TriggerHit,
        UpdateBlocks_SwitchOn,
        UpdateBlocks_SwitchOff,
        UpdateBlocks_SwitchOff_KillBlock,
    };

    // variables to help with resume
    Site site = None;
    int A, B, C, D, E, F, G;
    bool bool1, bool2, bool3, bool4;
    bool process_intro_events = false;
};

extern GameLoopInterrupt g_gameLoopInterrupt;

#endif // #ifndef GAME_LOOP_INTERRUPT_H


================================================
FILE: src/main/game_save.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../game_main.h"
#include "config.h"

#include "speedrunner.h"
#ifdef THEXTECH_ENABLE_LUNA_AUTOCODE
#include "../script/luna/lunavarbank.h"
#endif

#include <Utils/files.h>
#include <DirManager/dirman.h>
#include <AppPath/app_path.h>
#include <PGE_File_Formats/file_formats.h>
#include <fmt_format_ne.h>
#include <IniProcessor/ini_processing.h>
#include <script/luna/lunacounter.h>
#include <Logger/logger.h>

#include "main/level_save_info.h"
#include "menu_main.h"
#include "saved_layers.h"

std::string makeGameSavePath(std::string epPath, std::string saveFile)
{
    std::string gameSaveDir = AppPathManager::gameSaveRootDir() + Files::basename(Files::dirname(epPath));
    if(gameSaveDir.back() == ':')
        gameSaveDir.pop_back();

    if(!DirMan::exists(gameSaveDir))
    {
        pLogDebug("Creating directory [%s]", gameSaveDir.c_str());
        DirMan::mkAbsPath(gameSaveDir);
    }

    std::string ret = gameSaveDir + "/" + Files::basename(epPath) + "-" + saveFile;

    pLogDebug("Save data path for ep [%s], file [%s] -> [%s]", epPath.c_str(), saveFile.c_str(), ret.c_str());

    return ret;
}

static void s_LoadCharacter(SavedChar_t& dest, const saveCharState& s)
{
    dest = SavedChar_t();

    if((s.state < 1) || (s.state > numStates))
        dest.State = 1;
    else
        dest.State = int(s.state);

    dest.HeldBonus = int(s.itemID);

    switch(s.mountID)
    {
    default:
    case 0:
        dest.Mount = 0;
        dest.MountType = 0;
        break;
    case 1: case 2: case 3:
        dest.Mount = int(s.mountID);
    }

    dest.MountType = int(s.mountType);
    switch(s.mountID)
    {
    case 1:
        if((s.mountType < 1) || (s.mountType > 3))
            dest.MountType = 1;
        break;
    default:
        break;
    case 3:
        if((s.mountType < 1) || (s.mountType > 8))
            dest.MountType = 1;
        break;
    }

    dest.Hearts = int(s.health);
    dest.Character = int(s.id);
}

static std::string s_legacy_save_path(const SelectWorld_t& w, int save_idx)
{
    const std::string episode = Files::dirname(w.WorldFilePath);
    return fmt::sprintf_ne("%ssave%d.sav", episode.c_str(), save_idx);
}


void FindSaves()
{
//    std::string newInput;
    const auto &w = SelectWorld[selWorld];
    GamesaveData f;

    for(auto A = 1; A <= maxSaveSlots; A++)
    {
        auto& info = SaveSlotInfo[A];

        info = SaveSlotInfo_t();
        info.ConfigDefaults = 0;

        // Modern gamesave file
        std::string saveFile = makeGameSavePath(w.WorldFilePath,
                                                fmt::format_ne("save{0}.savx", A));
        // Old gamesave location at episode's read-only directory
        std::string saveFileOld = s_legacy_save_path(w, A);
        // Gamesave locker to make an illusion of absence of the gamesave
        std::string saveFileOldLocker = makeGameSavePath(w.WorldFilePath,
                                                         fmt::format_ne("save{0}.nosave", A));

        if((Files::fileExists(saveFile) && FileFormats::ReadExtendedSaveFileF(saveFile, f)) ||
           (!Files::fileExists(saveFileOldLocker) && Files::fileExists(saveFileOld) && FileFormats::ReadSMBX64SavFileF(saveFileOld, f)))
        {
            int curActive = 0;
            int maxActive = 0;

            // "game beat flag"
            maxActive++;
            if(f.gameCompleted)
                curActive++;

            // how many items
            if(f.lvl_path_count)
                maxActive += (int)f.lvl_path_count;
            else
            {
                maxActive += (int)f.visiblePaths.size();
                maxActive += (int)f.visibleLevels.size();
            }

            // How much paths open
            for(auto &p : f.visiblePaths)
            {
                if(p.second)
                    curActive++;
            }

            // How much levels opened
            for(auto &p : f.visibleLevels)
            {
                if(p.second)
                    curActive++;
            }

            // How many stars collected
            maxActive += (int(f.totalStars) * 4);
            info.Stars = int(f.gottenStars.size());

            curActive += (info.Stars * 4);

            // calculate progress
            if(maxActive > 0)
                info.Progress = curActive * 100 / maxActive;
            else
                info.Progress = 100;

            // load normal stats
            info.Lives = f.lives;
            info.Hundreds = (f.hundreds == 0) ? f.lives : ((f.hundreds > 0) ? f.hundreds - 1 : f.hundreds);
            info.Coins = f.coins;
            info.Score = f.points;

            // load saved chars
            for(int i = 1; i <= 5; i++)
            {
                info.SavedChar[i] = SavedChar_t();
                info.SavedChar[i].Character = i;
            }

            for(auto &s : f.characterStates)
            {
                if((s.id < 1) || (s.id > 5))
                    continue;
                int i = int(s.id);
                s_LoadCharacter(info.SavedChar[i], s);
            }

            // load settings from save file here
            for(auto &s : f.userData.store)
            {
                if(s.name == "_xt_ep_conf" && s.location == saveUserData::DATA_GLOBAL)
                {
                    for(const saveUserData::DataEntry& e : s.data)
                    {
                        if(e.key == "speedrun-mode" && e.value != "0")
                        {
                            info.ConfigDefaults = -atoi(e.value.c_str());
                            break;
                        }
                        // TODO: remove this legacy clause
                        else if(e.key == "enable-bugfixes")
                        {
                            info.ConfigDefaults = (e.value == "none") ? Config_t::MODE_VANILLA : ((e.value == "critical") ? Config_t::MODE_CLASSIC : Config_t::MODE_MODERN);
                            info.ConfigDefaults += 1;
                        }
                        else if(e.key == "playstyle")
                        {
                            info.ConfigDefaults = (e.value == "vanilla") ? Config_t::MODE_VANILLA : ((e.value == "classic") ? Config_t::MODE_CLASSIC : Config_t::MODE_MODERN);
                            info.ConfigDefaults += 1;
                        }
                    }
                    break;
                }
            }

            // default config if not present
            if(info.ConfigDefaults == 0)
            {
                if(f.meta.smbx64strict)
                    info.ConfigDefaults = Config_t::MODE_VANILLA + 1;
                else if(w.bugfixes_on_by_default)
                    info.ConfigDefaults = Config_t::MODE_MODERN + 1;
                else
                    info.ConfigDefaults = Config_t::MODE_CLASSIC + 1;
            }

            // load timer info for existing save
            std::string savePath = makeGameSavePath(w.WorldFilePath,
                                                     fmt::format_ne("timers{0}.ini", A));

            if(Files::fileExists(savePath))
            {
                IniProcessing timer(savePath);
                timer.beginGroup("timers");
                timer.read("total", info.Time, 0);
                timer.endGroup();
            }

            // load fails for existing save
            savePath = makeGameSavePath(w.WorldFilePath,
                                        fmt::format_ne("fails-{0}.rip", A));

            if(Files::fileExists(savePath))
            {
                gDeathCounter.counterFile = savePath;
                gDeathCounter.TryLoadStats();
                gDeathCounter.Recount();
                info.FailsEnabled = true;
                info.Fails = gDeathCounter.mCurTotalDeaths;
                gDeathCounter.quit();
            }
        }
    }
}


void SaveGame()
{
    int A = 0;

    if(Cheater || !selSave)
        return;

    for(A = numPlayers; A >= 1; A--)
        SavedChar[Player[A].Character] = Player[A];

    // Clean-up from invalid entries
    for(auto it = Star.begin(); it != Star.end(); )
    {
        if(it->level.empty())
            it = Star.erase(it);
        else
            ++it;
    }

    numStars = (int)Star.size();

    const auto &w = SelectWorld[selWorld];

    GamesaveData sav;
//    std::string savePath = SelectWorld[selWorld].WorldPath + fmt::format_ne("save{0}.savx", selSave);
    std::string savePath = makeGameSavePath(w.WorldFilePath,
                                            fmt::format_ne("save{0}.savx", selSave));
    std::string legacyGamesaveLocker = makeGameSavePath(w.WorldFilePath,
                                                        fmt::format_ne("save{0}.nosave", selSave));

//    Open SelectWorld[selWorld].WorldPath + "save" + selSave + ".sav" For Output As #1;
    sav.lives = Lives;
    sav.hundreds = (g_100s >= 0) ? g_100s + 1 : g_100s;
    sav.coins = uint32_t(Coins);
    sav.points = uint32_t(Score);
    sav.worldPosX = (int)WorldPlayer[1].Location.X;
    sav.worldPosY = (int)WorldPlayer[1].Location.Y;

    for(A = 1; A <= 5; A++)
    {
        saveCharState c;
        c.id = static_cast<unsigned long>(A);
        c.state = uint32_t(SavedChar[A].State);
        c.itemID = uint32_t(SavedChar[A].HeldBonus);
        c.mountID = uint32_t(SavedChar[A].Mount);
        c.mountType = uint32_t(SavedChar[A].MountType);
        c.health = uint32_t(SavedChar[A].Hearts);
        sav.characterStates.push_back(c);
    }
    sav.musicID = uint32_t(curWorldMusic);
    sav.musicFile = curWorldMusicFile;
    sav.last_hub_warp = static_cast<unsigned long>(ReturnWarpSaved);
    sav.last_hub_level_file = FileRecentSubHubLevel;

    // ABOVE GETS SKIPPED BY FINDSAVES
    sav.gameCompleted = BeatTheGame; // Can only get 99% until you finish the game;

    sav.lvl_path_count = numWorldLevels + numWorldPaths;

    for(A = 1; A <= numWorldLevels; A++)
    {
        if(WorldLevel[A].Active)
            sav.visibleLevels.emplace_back(A, WorldLevel[A].Active);
    }

    for(A = 1; A <= numWorldPaths; A++)
    {
        if(WorldPath[A].Active)
            sav.visiblePaths.emplace_back(A, WorldPath[A].Active);
    }

    for(A = 1; A <= numScenes; A++)
    {
        if(!Scene[A].Active)
            sav.visibleScenery.emplace_back(A, Scene[A].Active);
    }

    for(const auto& star : Star)
        sav.gottenStars.emplace_back(star.level, star.Section);

    savedLayerSaveEntry savedLayer;
    for(A = 0; ExportSavedLayer(nullptr, savedLayer, A); A++)
        sav.savedLayers.push_back(savedLayer);

    sav.totalStars = uint32_t(MaxWorldStars);

#ifdef THEXTECH_ENABLE_LUNA_AUTOCODE
    gSavedVarBank.WriteBank();
    if(gLunaVarBank.name == "LunaDLL" && !gLunaVarBank.data.empty())
        sav.userData.store.push_back(gLunaVarBank);
#endif

    // save extra settings here
    g_config.SaveEpisodeConfig(sav.userData);

    ExportLevelSaveInfo(sav);

    FileFormats::WriteExtendedSaveFileF(savePath, sav);

    if(Files::fileExists(legacyGamesaveLocker))
        Files::deleteFile(legacyGamesaveLocker); // Remove the gamesave locker of legacy file

    // Also, save the speed-running states
    speedRun_saveStats();

    AppPathManager::syncFs();
}

void LoadGame()
{
    int A = 0;
    size_t i = 0;
    const auto &w = SelectWorld[selWorld];
//    std::string newInput;

    GamesaveData sav;
    std::string savePath = makeGameSavePath(w.WorldFilePath,
                                            fmt::format_ne("save{0}.savx", selSave));
    std::string savePathOld = s_legacy_save_path(w, selSave);
    std::string legacySaveLocker = makeGameSavePath(w.WorldFilePath,
                                                    fmt::format_ne("save{0}.nosave", selSave));

    if(Files::fileExists(savePath))
        FileFormats::ReadExtendedSaveFileF(savePath, sav);
    else if(!Files::fileExists(legacySaveLocker) && Files::fileExists(savePathOld))
        FileFormats::ReadSMBX64SavFileF(savePathOld, sav);
    else
    {
        pLogDebug("Game save file not found: %s", savePath.c_str());
        return;
    }

    if(!sav.meta.ReadFileValid)
    {
        pLogWarning("Invalid game save file: %s [%s]; ", sav.meta.filename.c_str(), sav.meta.ERROR_info.c_str());
        return;
    }

    // load settings from save file here
    g_config.LoadEpisodeConfig(sav.userData);

    Lives = sav.lives;
    g_100s = (sav.hundreds == 0) ? sav.lives : ((sav.hundreds > 0) ? sav.hundreds - 1 : sav.hundreds);
    Coins = int(sav.coins);
    Score = int(sav.points);
    BeatTheGame = sav.gameCompleted;
    WorldPlayer[1].Location.X = sav.worldPosX;
    WorldPlayer[1].Location.Y = sav.worldPosY;

    if(Lives > 99)
        Lives = 99;
    if(Coins > 99)
        Coins = 0;
    if(Score > 9999990)
        Score = 9999990;

    if(g_100s > 9999)
        g_100s = 9999;
    else if(g_100s < -9999)
        g_100s = -9999;

    // reset score on load in Vanilla Mode (like SMBX 1.3)
    if(g_config.playstyle == Config_t::MODE_VANILLA)
        Score = 0;

    curWorldMusic = int(sav.musicID);
    curWorldMusicFile = sav.musicFile;

    if(g_config.enable_last_warp_hub_resume)
    {
        ReturnWarp = int(sav.last_hub_warp);
        FileRecentSubHubLevel = sav.last_hub_level_file;
        if(ReturnWarp > maxWarps)
            ReturnWarp = 0; // Invalid value
    }
    else
    {
        // Keep the vanilla behavior, and let players feel the pain!, MuhahahahA! >:-D
        ReturnWarp = 0;
        FileRecentSubHubLevel.clear();
    }

    ReturnWarpSaved = ReturnWarp;

    for(A = 1, i = 0; A <= 5; A++, i++)
    {
        SavedChar[A] = SavedChar_t();
        SavedChar[A].Character = A;
    }

    for(auto &s : sav.characterStates)
    {
        if((s.id < 1) || (s.id > 5))
            continue;
        A = int(s.id);

        s_LoadCharacter(SavedChar[A], s);
    }


    for(auto &p : sav.visiblePaths)
    {
        A = static_cast<int>(p.first);
        if(A > 0 && A <= maxWorldPaths)
            WorldPath[A].Active = p.second;
    }

    for(auto &p : sav.visibleLevels)
    {
        A = static_cast<int>(p.first);
        if(A > 0 && A <= maxWorldLevels)
            WorldLevel[A].Active = p.second;
    }

    for(auto &p : sav.visibleScenery)
    {
        A = static_cast<int>(p.first);
        if(A > 0 && A <= maxScenes)
            Scene[A].Active = p.second;
    }

    if(Star.capacity() < sav.gottenStars.size())
        Star.reserve(sav.gottenStars.size());

    for(auto &p : sav.gottenStars)
    {
        Star_t star;
        star.level = p.first;
        star.Section = p.second;
        Star.push_back(std::move(star));
    }

    for(auto& p : sav.savedLayers)
        LoadSavedLayer(nullptr, p);

    numStars = int(sav.gottenStars.size());

    for(A = 1; A <= numPlayers; A++)
        Player[A] = SavedChar[Player[A].Character];

#ifdef THEXTECH_ENABLE_LUNA_AUTOCODE
    gLunaVarBank = saveUserData::DataSection();
    for(auto &s : sav.userData.store)
    {
        if(s.name == "LunaDLL" && s.location == saveUserData::DATA_GLOBAL)
        {
            gLunaVarBank = s;
            break;
        }
    }

    gSavedVarBank.TryLoadWorldVars();
#endif

    ImportLevelSaveInfo(sav);
}

void ClearGame(bool punnish)
{
    curWorldMusic = 0;
    curWorldMusicFile.clear();

    ReturnWarp = 0;
    ReturnWarpSaved = ReturnWarp;

    IsHubLevel = false;
    FileRecentSubHubLevel.clear();

    WorldPlayer[1].Location.X = -1;
    WorldPlayer[1].Location.Y = -1;

    for(int A = 1, i = 0; A <= 5; A++, i++)
    {
        SavedChar[A].State = 1;
        SavedChar[A].HeldBonus = NPCID(0);
        SavedChar[A].Mount = 0;
        SavedChar[A].MountType = 0;
        SavedChar[A].Hearts = 1;
        SavedChar[A].Character = A;
    }

    for(int A = 1; A <= maxWorldPaths; ++A)
        WorldPath[A].Active = false;

    for(int A = 1; A <= maxWorldLevels; ++A)
    {
        WorldLevel[A].Active = false;
        WorldLevel[A].save_info = LevelSaveInfo_t();
    }

    for(int A = 1; A <= maxScenes; ++A)
        Scene[A].Active = true;

    // maxStars = 0;
    Star.clear();
    numStars = 0;

    LevelWarpSaveEntries.clear();

#ifdef THEXTECH_ENABLE_LUNA_AUTOCODE
    gLunaVarBank = saveUserData::DataSection();
    gSavedVarBank.ClearBank();
#endif

    if(punnish && selSave) // Remove gamesave of user who was used a trap cheat
        DeleteSave(selWorld, selSave);
}


void DeleteSave(int world, int save)
{
    const auto &w = SelectWorld[world];
    std::vector<std::string> deleteList;

#define AddFile(f) \
    deleteList.push_back(makeGameSavePath(w.WorldFilePath,\
                                          fmt::format_ne(f, save)));

    AddFile("save{0}.savx");
    AddFile("timers{0}.ini");
    AddFile("deaths-{0}.rip");
    AddFile("fails-{0}.rip");
    AddFile("demos-{0}.dmo");

    // Clear all files in list
    for(auto &s : deleteList)
    {
        if(Files::fileExists(s))
            Files::deleteFile(s);
    }

    std::string legacySave = s_legacy_save_path(w, save);
    std::string legacySaveLocker = makeGameSavePath(w.WorldFilePath,
                                                    fmt::format_ne("save{0}.nosave", save));

    // If legacy gamesave file exists, make the locker file to make illusion that old file got been removed
    if(Files::fileExists(legacySave))
    {
        auto *f = Files::open_file(legacySaveLocker, "wb");
        if(f)
        {
            const char s[] = "If this file exists, the Vanilla \"save*.sav\" inside the episode folder is ignored.";
            SDL_RWwrite(f, s, 1, sizeof(s) - 1);
            SDL_RWclose(f);
        }
    }

#undef AddFile

#ifdef __EMSCRIPTEN__
    AppPathManager::syncFs();
#endif
}


static void copySaveFile(const SelectWorld_t& w, const char*file_mask, int src, int dst)
{
    std::string filePathSrc = makeGameSavePath(w.WorldFilePath,
                                               fmt::format_ne(file_mask, src));
    std::string filePathDst = makeGameSavePath(w.WorldFilePath,
                                               fmt::format_ne(file_mask, dst));
    Files::copyFile(filePathDst, filePathSrc, true);
}

void CopySave(int world, int src, int dst)
{
    const auto &w = SelectWorld[world];

    std::string savePathSrc = makeGameSavePath(w.WorldFilePath,
                                               fmt::format_ne("save{0}.savx", src));
    std::string savePathDst = makeGameSavePath(w.WorldFilePath,
                                               fmt::format_ne("save{0}.savx", dst));
    std::string legacySaveLocker = makeGameSavePath(w.WorldFilePath,
                                                    fmt::format_ne("save{0}.nosave", dst));

    if(!Files::fileExists(savePathSrc))
    {
        // Attempt to import an old game-save from the episode directory
        std::string savePathOld = s_legacy_save_path(w, src);

        GamesaveData sav;
        bool succ = false;

        if(Files::fileExists(savePathOld))
            succ = FileFormats::ReadSMBX64SavFileF(savePathOld, sav);

        if(succ)
            FileFormats::WriteExtendedSaveFileF(savePathSrc, sav);

        if(Files::fileExists(legacySaveLocker))
            Files::deleteFile(legacySaveLocker);
    }

    Files::copyFile(savePathDst, savePathSrc, true);

    copySaveFile(w, "timers{0}.ini", src, dst);
    copySaveFile(w, "fails-{0}.rip", src, dst);
    copySaveFile(w, "deaths-{0}.rip", src, dst);
    copySaveFile(w, "demos-{0}.dmo", src, dst);

#ifdef __EMSCRIPTEN__
    AppPathManager::syncFs();
#endif
}


================================================
FILE: src/main/game_strings.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "main/game_strings.h"

GameContent g_gameStrings;

void initGameStrings()
{
    g_gameStrings.msgBoxTitleInfo = "Info";
    g_gameStrings.msgBoxTitleWarning = "Warning!";
    g_gameStrings.msgBoxTitleError = "Error!";

    g_gameStrings.loaderLoading = "Loading...";
    g_gameStrings.loaderStatusLoadData = "Loading data...";
    g_gameStrings.loaderStatusLoadFile = "Load: {0}";
    g_gameStrings.loaderStatusGameInfo = "Game info";
    g_gameStrings.loaderStatusTranslations = "Translations";
    g_gameStrings.loaderStatusAssetPacks = "Asset packs";
    g_gameStrings.loaderStatusFinishing = "Finishing...";

    g_gameStrings.errorOpenFileFailed = "Can't open \"{0}\": file doesn't exist or corrupted.";
#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    g_gameStrings.errorOpenIPCDataFailed = "Can't proceed received file data because of corruption or other errors.";
#endif
    g_gameStrings.errorTooOldEngine = "Content requires a newer engine feature level ({0}) than the current version ({1}). Please update TheXTech.";
    g_gameStrings.errorTooOldGameAssets = "Content requires a newer asset pack feature level ({0}) than the current asset pack ({1}). Please upgrade your game asset pack.";

    g_gameStrings.errorInvalidEnterWarp = "Can't start the level "
                                          "because of an invalid "
                                          "entrance warp {1} was "
                                          "specified.\n"
                                          "Total warp entries: {2}\n"
                                          "\n"
                                          "File: {0}";
    g_gameStrings.errorNoStartPoint = "Can't start the level "
                                      "because of no available "
                                      "start points placed or "
                                      "entrance warp specified.\n"
                                      "\n"
                                      "File: {0}";

#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    g_gameStrings.errorIPCTimeOut = "No responce from the connected Editor. Game will be closed.";
#endif

    g_gameStrings.messageScanningLevels = "Scanning levels...";
    g_gameStrings.formatMinutesSeconds = "{0}m{1}s";

#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    g_gameStrings.ipcStatusWaitingInput = "Waiting for input data...";
    g_gameStrings.ipcStatusDataTransferStarted = "Started data tansfer...";
    g_gameStrings.ipcStatusDataAccepted = "Data accepted, the parsing started...";
    g_gameStrings.ipcStatusDataValid = "Accepted data is valid";
    g_gameStrings.ipcStatusErrorTimeout = "ERROR: Wait time out.";
    g_gameStrings.ipcStatusLoadingDone = "Done. Starting game...";
#endif

#if !defined(NO_WINDOW_FOCUS_TRACKING) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    g_gameStrings.screenPaused = "Paused";
#endif

    g_gameStrings.warpNeedStarCount = "You need {0} {1} to enter.";

    g_gameStrings.pauseItemContinue = "Continue";
    g_gameStrings.pauseItemRestartLevel = "Restart Level";
    g_gameStrings.pauseItemResetCheckpoints = "Reset Checkpoints";
    g_gameStrings.pauseItemQuitTesting = "Quit Testing";
    g_gameStrings.pauseItemReturnToEditor = "Return to Editor";
    g_gameStrings.pauseItemPlayerSetup = "Player Setup";
    g_gameStrings.pauseItemEnterCode = "Enter Code";
    g_gameStrings.pauseItemSaveAndContinue = "Save and Continue";
    g_gameStrings.pauseItemSaveAndQuit = "Save and Quit";
    g_gameStrings.pauseItemQuit = "Quit";


    g_gameStrings.connectReconnectTitle = "Reconnect";
    g_gameStrings.connectPressAButton = "Press A Button";
    g_gameStrings.connectTestProfile = "Test Profile";
    g_gameStrings.connectDisconnect = "Disconnect";
    g_gameStrings.connectHoldStart = "Hold Start";

    g_gameStrings.connectDropMe = "Drop Me";

    g_gameStrings.connectDropPX = "Drop P{0}";
    g_gameStrings.connectForceResume = "Force Resume";

    g_gameStrings.connectWaitingForInputDevice = "Waiting for input device...";
    g_gameStrings.connectPressSelectForControlsOptions_P1 = "Press Select for";
    g_gameStrings.connectPressSelectForControlsOptions_P2 = "Controls Options";

}


================================================
FILE: src/main/game_strings.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GAME_STRINGS_H
#define GAME_STRINGS_H

#include <string>

struct GameContent
{
    std::string msgBoxTitleInfo;
    std::string msgBoxTitleWarning;
    std::string msgBoxTitleError;

    std::string loaderLoading;
    std::string loaderStatusLoadData;
    std::string loaderStatusLoadFile;
    std::string loaderStatusGameInfo;
    std::string loaderStatusTranslations;
    std::string loaderStatusAssetPacks;
    std::string loaderStatusFinishing;

    std::string errorOpenFileFailed;
#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    std::string errorOpenIPCDataFailed;
#endif
    std::string errorTooOldEngine;
    std::string errorTooOldGameAssets;
    std::string errorInvalidEnterWarp;
    std::string errorNoStartPoint;
#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    std::string errorIPCTimeOut;
#endif
    std::string messageScanningLevels;
    std::string formatMinutesSeconds;

#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    std::string ipcStatusWaitingInput;
    std::string ipcStatusDataTransferStarted;
    std::string ipcStatusDataAccepted;
    std::string ipcStatusDataValid;
    std::string ipcStatusErrorTimeout;
    std::string ipcStatusLoadingDone;
#endif

#if !defined(NO_WINDOW_FOCUS_TRACKING) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    std::string screenPaused;
#endif

    std::string warpNeedStarCount;

    std::string pauseItemContinue;
    std::string pauseItemRestartLevel;
    std::string pauseItemResetCheckpoints;
    std::string pauseItemQuitTesting;
    std::string pauseItemReturnToEditor;
    std::string pauseItemPlayerSetup;
    std::string pauseItemEnterCode;
    std::string pauseItemSaveAndContinue;
    std::string pauseItemSaveAndQuit;
    std::string pauseItemQuit;


    // ConnectScreen

    std::string connectReconnectTitle;

    std::string connectPressAButton;

    std::string connectTestProfile;
    std::string connectHoldStart;
    std::string connectDisconnect;

    std::string connectDropMe;

    std::string connectForceResume;
    std::string connectDropPX;

    std::string connectWaitingForInputDevice;
    std::string connectPressSelectForControlsOptions_P1;
    std::string connectPressSelectForControlsOptions_P2;
};

extern GameContent g_gameStrings;

void initGameStrings();

#endif // GAME_STRINGS_H


================================================
FILE: src/main/gameplay_timer.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <fmt_format_ne.h>
#include <IniProcessor/ini_processing.h>

#include "sdl_proxy/sdl_stdinc.h"

#include "core/render.h"

#include "gameplay_timer.h"
#include "graphics.h"
#include "game_main.h"
#include "globals.h"
#include "config.h"

#include "menu_main.h"

std::string GameplayTimer::formatTime(int64_t t)
{
    std::string displayTime;

    int64_t realMiliseconds = (t * 156) / 10;
    int miliseconds = realMiliseconds % 1000;
    int64_t realSeconds = realMiliseconds / 1000;
    int seconds = realSeconds % 60;
    int64_t realMinutes = realSeconds / 60;
    int minutes = realMinutes % 60;
    int64_t realHours = realMinutes / 60;
    int hours = realHours % 24;
    int days = realHours / 24;

    if(days >= 1)
        displayTime = fmt::sprintf_ne("%02d:%02d:%02d:%02d.%03d", days, hours, minutes, seconds, miliseconds);
    else if(realHours >= 1)
        displayTime = fmt::sprintf_ne("%02d:%02d:%02d.%03d", hours, minutes, seconds, miliseconds);
    else if(realHours < 1)
        displayTime = fmt::sprintf_ne("%02d:%02d.%03d", minutes, seconds, miliseconds);

    return displayTime;
}

void GameplayTimer::updateColorSpin(int delta)
{
    const int in_s = 178;
    const int in_v = 255;

    // note: changed from 360 degrees to 384 (64 * 6) degrees
    m_colorSpinHue += delta;
    if(m_colorSpinHue >= 384)
        m_colorSpinHue -= 384;
    else if(m_colorSpinHue < 0)
        m_colorSpinHue += 384;

    if(in_s <= 0) // < is bogus, just shuts up warnings
    {
        m_colorSpin = XTColor(in_v, in_v, in_v);
        return;
    }

    int ff = m_colorSpinHue % 64;
    int p = in_v * (256 - in_s) / 256;
    int q = in_v * (256 - (in_s * ff) / 64) / 256;
    int t = in_v * (256 - (in_s * (64 - ff)) / 64) / 256;

    int i = m_colorSpinHue / 64;
    switch(i)
    {
    case 0:
        m_colorSpin = XTColor(in_v, t, p);
        break;
    case 1:
        m_colorSpin = XTColor(q, in_v, p);
        break;
    case 2:
        m_colorSpin = XTColor(p, in_v, t);
        break;
    case 3:
        m_colorSpin = XTColor(p, q, in_v);
        break;
    case 4:
        m_colorSpin = XTColor(t, p, in_v);
        break;
    case 5:
    default:
        m_colorSpin = XTColor(in_v, p, q);
        break;
    }
}

GameplayTimer::GameplayTimer() = default;


void GameplayTimer::reset()
{
    m_invalidContinue = false;
    m_cyclesInt = false;
    m_cyclesAtWin = 0;
    m_cyclesAtWinDisplay = 0;
    m_cyclesCurrent = 0;
    m_cyclesTotal = 0;
    m_levelBlinkActive = false;
    m_worldBlinkActive = false;
    m_blinkingFactor = 0;
}

void GameplayTimer::resetCurrent()
{
    m_cyclesCurrent = 0;
    m_levelBlinkActive = false;
    m_worldBlinkActive = false;
    m_blinkingFactor = 0;
}

void GameplayTimer::load()
{
    if(TestLevel || selSave == 0)
    {
        reset();
        return;
    }

    IniProcessing o;
    std::string savePath = makeGameSavePath(SelectWorld[selWorld].WorldFilePath,
                                            fmt::format_ne("timers{0}.ini", selSave));
    o.open(savePath);

    o.beginGroup("timers");
    o.read("int", m_cyclesInt, false);
    o.read("total", m_cyclesTotal, 0);

    // no longer permanently stop the timer following credits roll, but do store the cycles at first win for future display
    bool legacy_fin = false;
    o.read("fin", legacy_fin, false);
    int64_t cyclesAtWin_default = (legacy_fin) ? m_cyclesTotal : 0;

    o.read("win", m_cyclesAtWin, cyclesAtWin_default);
    m_cyclesCurrent = 0; // Reset the counter
    m_cyclesAtWinDisplay = 0;
    o.endGroup();

    if(!m_cyclesInt)
        m_invalidContinue = true;
}

void GameplayTimer::save()
{
    // should Cheater also be a condition here?
    if(TestLevel || !selSave || m_invalidContinue)
        return;

    IniProcessing o;
    std::string savePath = makeGameSavePath(SelectWorld[selWorld].WorldFilePath,
                                            fmt::format_ne("timers{0}.ini", selSave));
    o.open(savePath);

    o.beginGroup("timers");
    o.setValue("int", m_cyclesInt);
    o.setValue("total", m_cyclesTotal);
    o.setValue("win", m_cyclesAtWin);
    o.endGroup();

    o.writeIniFile();
}

void GameplayTimer::tick()
{
    // initialize timer
    if(!m_cyclesInt)
    {
        m_cyclesInt = true;
        m_cyclesCurrent = 0;
        m_cyclesTotal = 0;
        m_cyclesAtWin = 0;
        m_cyclesAtWinDisplay = 0;
        m_levelBlinkActive = false;
        m_worldBlinkActive = false;
        m_blinkingFactor = 0;
    }

    bool in_leveltest_restart_screen = (GamePaused == PauseCode::PauseScreen && LevelBeatCode < 0);
    bool in_normal_level_play = (!LevelSelect && LevelMacro == 0);

    if(!in_leveltest_restart_screen && (LevelSelect || in_normal_level_play))
        m_cyclesCurrent += 1;
    else if(!in_leveltest_restart_screen && g_config.show_playtime_counter == Config_t::PLAYTIME_COUNTER_ANIMATED)
        m_levelBlinkActive = true;

    m_cyclesTotal += 1;

    if(m_levelBlinkActive)
        updateColorSpin(5);

    if(m_worldBlinkActive)
    {
        m_blinkingFactor += m_blinkingDir * 5;
        if(m_blinkingFactor >= 75 || m_blinkingFactor <= -75)
            m_blinkingDir *= -1;
    }
}

void GameplayTimer::onBossDead()
{
    m_cyclesAtWinDisplay = m_cyclesTotal;

    if(m_cyclesAtWin == 0)
        m_cyclesAtWin = m_cyclesTotal;

    if(g_config.show_playtime_counter == Config_t::PLAYTIME_COUNTER_ANIMATED)
        m_worldBlinkActive = true;
}

void GameplayTimer::render()
{
    uint8_t a = (g_config.show_playtime_counter == Config_t::PLAYTIME_COUNTER_SUBTLE) ? 127 : 255;
    // int x = (XRender::TargetW / 2) - (144 / 2);
    int y = XRender::TargetH;

    XTColor lc = m_levelBlinkActive ? m_colorSpin : XTColor(154, 154, 154);
    uint8_t wc = m_worldBlinkActive ? (128 + m_blinkingFactor) : 255;

    SuperPrintScreenCenter(formatTime(m_cyclesCurrent), 3, y - 34, lc.with_alpha(a));

    if(m_invalidContinue)
        SuperPrintScreenCenter(g_mainMenu.caseNone,         3, y - 18, XTColor(127, 127, 127, a));
    else if(!TestLevel)
    {
        int64_t use_total = m_cyclesTotal;
        if(m_cyclesAtWinDisplay)
            use_total = m_cyclesAtWinDisplay;

        SuperPrintScreenCenter(formatTime(use_total),       3, y - 18, XTColor(wc, 255, wc, a));
    }
}


================================================
FILE: src/main/gameplay_timer.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef GAMEPLAYTIMER_H
#define GAMEPLAYTIMER_H

#include <string>

#include "xt_color.h"

class GameplayTimer
{
    bool    m_invalidContinue = false;
    bool    m_cyclesInt = false;
    // bool    m_cyclesFin = false;
    int64_t m_cyclesAtWin = 0;
    int64_t m_cyclesAtWinDisplay = 0;
    int64_t m_cyclesCurrent = 0;
    int64_t m_cyclesTotal = 0;

    bool    m_levelBlinkActive = false;
    bool    m_worldBlinkActive = false;
    int     m_blinkingFactor = 0;
    int     m_blinkingDir = 1;
    XTColor m_colorSpin;
    int     m_colorSpinHue = 0;
    void    updateColorSpin(int delta);

public:
    static std::string formatTime(int64_t t);

    GameplayTimer();

    void reset();
    void resetCurrent();

    void load();
    void save();

    void tick();

    void onBossDead();

    void render();
};

#endif // GAMEPLAYTIMER_H


================================================
FILE: src/main/hints.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <cstdint>
#include <string>

#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_stdinc.h"

#include "fontman/font_manager.h"

#include "core/render.h"

#include "main/hints.h"
#include "main/speedrunner.h"
#include "main/translate.h"
#include "main/trees.h"
#include "game_main.h"

#include "std_picture.h"
#include "screen.h"
#include "globals.h"
#include "player.h"
#include "npc_id.h"
#include "npc_traits.h"
#include "npc/npc_queues.h"
#include "config.h"
#include "controls.h"
#include "graphics.h"
#include "gfx.h"
#include "eff_id.h"


namespace XHints
{

struct Hint
{
    const char* text_en;
    const char* tr_id;
    uint8_t (&check_priority)();
    void (&draw_icon)(int, int);

    Hint(const char* text_en, const char* tr_id, uint8_t (&check_priority)(), void (&draw_icon)(int, int))
        : text_en(text_en), tr_id(tr_id), check_priority(check_priority), draw_icon(draw_icon) {}
};


// default hints defined here

static void s_draw_purple_pet(const Controls_t& c, int x, int y)
{
    RenderControls(c, x + 96 / 2 - 76 / 2, y + 96 - 34, 76, 30, false, 255);

    StdPicture& tex = GFXNPC[NPCID_PET_PURPLE];
    XRender::renderTextureBasic(x + 96 / 3 - tex.w / 3, y + 96 - 34 - 4 - tex.h / 2, tex.w, tex.h / 2, tex, 0, tex.h / 2);
}

static void s_draw_purple_pet_down(int x, int y)
{
    Controls_t c;
    c.Down = true;

    s_draw_purple_pet(c, x, y);
}

static void s_draw_purple_pet_altrun(int x, int y)
{
    Controls_t c;
    c.AltRun = true;

    s_draw_purple_pet(c, x, y);
}

static void s_draw_no_lives_new(int x, int y)
{
    StdPicture &tex = GFXEffect[EFFID_CHAR1_DIE];

    XRender::renderTextureBasic(x + 48 - tex.w / 2, y + 54 - tex.h, tex);

    if(GFX.Balance.inited)
        XRender::renderTextureBasic(x + 48 - GFX.Balance.w / 2, y + 64, GFX.Balance);
}

static void s_draw_no_lives_old(int x, int y)
{
    StdPicture &tex = GFXNPC[NPCID_POISON];

    int frame_h = NPCTraits[NPCID_POISON].HeightGFX;
    if(frame_h == 0)
        frame_h = NPCTraits[NPCID_POISON].THeight;

    XRender::renderTextureBasic(x + 48 - tex.w / 2, y + 48 - frame_h / 2,
        tex.w, frame_h, tex, 0, 0);
}

static void s_draw_rainbow_surf(int x, int y)
{
    Controls_t c;
    c.Down = true;

    if(Player[1].Direction < 0)
        c.Left = true;
    else
        c.Right = true;

    if(GamePaused == PauseCode::None || CommonFrame % 128 < 64)
        c.Run = true;

    RenderControls(c, x + 96 / 2 - 76 / 2, y + 96 - 34, 76, 30, false, 255);

    StdPicture& tex = GFXNPC[NPCID_FLIPPED_RAINBOW_SHELL];

    int frame_h = NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].HeightGFX;
    if(frame_h == 0)
        frame_h = NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].THeight;
    int frame_idx = ((CommonFrame % 64) / 4);

    XRender::renderTextureBasic(x + 96 / 2 - tex.w / 2, y + 96 - 34 - 4 - frame_h, tex.w, frame_h, tex, 0, frame_h * frame_idx);
}

static void s_draw_char5_bombs(int x, int y)
{
    DrawPlayerRaw(x + 10, y + 96 - 56, 5, 2, 8, 1);

    StdPicture& tex = GFXNPC[NPCID_BOMB];
    XRender::renderTextureBasic(x + 96 + 4 - NPCTraits[NPCID_BOMB].WidthGFX, y + 96 - 8 - NPCTraits[NPCID_BOMB].HeightGFX, NPCTraits[NPCID_BOMB].WidthGFX, NPCTraits[NPCID_BOMB].HeightGFX, tex, 0, 0);
}

static void s_draw_shoe_block(int x, int y)
{
    StdPicture& plant = GFXNPC[NPCID_FIRE_PLANT];
    XRender::renderTextureBasic(x + 96 - 4 - 32, y + 96 - 8 - NPCTraits[NPCID_FIRE_PLANT].THeight, 32, NPCTraits[NPCID_FIRE_PLANT].THeight, plant, 0, 0);

    StdPicture& fire = GFXNPC[NPCID_PLANT_FIREBALL];
    XRender::renderTextureBasic(x + 96 - 56, y + 96 - 56, 32, NPCTraits[NPCID_PLANT_FIREBALL].THeight, fire, 0, 0);

    DrawPlayerRaw(x + 8 + 4, y + 96 - 8 - 32 - 22, 3, 1, 1, 1);

    StdPicture& boot = GFXNPC[NPCID_RED_BOOT];
    XRender::renderTextureBasic(x + 8, y + 96 - 8 - 32, 32, 32, boot, 0, 64);
}

static void s_draw_heavy_duck(int x, int y)
{
    StdPicture& plant = GFXNPC[NPCID_FIRE_PLANT];
    XRender::renderTextureBasic(x + 96 - 4 - 32, y + 96 - 8 - NPCTraits[NPCID_FIRE_PLANT].THeight, 32, NPCTraits[NPCID_FIRE_PLANT].THeight, plant, 0, 0);

    StdPicture& fire = GFXNPC[NPCID_PLANT_FIREBALL];
    XRender::renderTextureBasic(x + 96 - 56, y + 96 - 56, 32, NPCTraits[NPCID_PLANT_FIREBALL].THeight, fire, 0, 0);

    DrawPlayerRaw(x + 8, y + 96 - 56, 1, 6, 7, 1);
}

static void s_draw_gray_bricks(int x, int y)
{
    StdPicture& brick = GFXBlock[457];
    XRender::renderTextureBasic(x + 24 + 4, y + 96 - 8 - 32, 32, 32, brick, 0, 0);

    StdPicture& st = GFXNPC[NPCID_STATUE_POWER];
    XRender::renderTextureBasic(x + 4, y + 4, 32, 32, st, 0, 0);

    StdPicture& heavy = GFXNPC[NPCID_HEAVY_POWER];
    XRender::renderTextureBasic(x + 96 - 4 - 32, y + 96 - 16 - 64, 32, 32, heavy, 0, 0);
}

static bool s_purple_pet_present()
{
    for(int A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Mount == 3 && Player[A].MountType == 6)
            return true;
    }

    return false;
}

static uint8_t s_altrun_pound_applies()
{
    if(!g_config.pound_by_alt_run)
        return 0;

    if(!s_purple_pet_present())
        return 0;

    return 108;
}

static uint8_t s_down_pound_applies()
{
    if(g_config.pound_by_alt_run)
        return 0;

    if(!s_purple_pet_present())
        return 0;

    return 108;
}

static uint8_t s_no_lives_new_applies()
{
    if(!g_config.modern_lives_system)
        return 0;

    if(g_100s == 0)
        return 100;

    return 0;
}

static uint8_t s_no_lives_old_applies()
{
    if(g_config.modern_lives_system)
        return 0;

    if(Lives == 0)
        return 100;

    return 0;
}

static uint8_t s_rainbow_surf_applies()
{
    if(LevelSelect)
        return 0;

    for(NPCRef_t n : NPCQueues::Active.no_change)
    {
        if(n->Type == NPCID_FLIPPED_RAINBOW_SHELL && n->TimeLeft > 2)
            return 107;
    }

    return 0;
}

static uint8_t s_char5_bombs_applies()
{
    if(LevelSelect)
        return 0;

    bool has_char5 = false;

    for(int A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Character == 5)
        {
            if(Player[A].Bombs > 0)
                return 102;
            else
            {
                has_char5 = true;
                break;
            }
        }
    }

    if(!has_char5)
        return 0;

    for(NPCRef_t n : NPCQueues::Active.no_change)
    {
        if(n->Type == NPCID_BOMB && n->TimeLeft > 2)
            return 102;
    }

    return 0;
}

static uint8_t s_shoe_block_applies()
{
    if(LevelSelect)
        return 0;

    for(int A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Mount == 1 && Player[A].MountType == 2)
            return 104;
    }

    return 0;
}

static uint8_t s_heavy_duck_applies()
{
    if(LevelSelect)
        return 0;

    for(int A = 1; A <= numPlayers; A++)
    {
        if(Player[A].State == 6 && Player[A].Character != 5)
            return 101;
    }

    return 0;
}

static uint8_t s_gray_bricks_applies()
{
    if(LevelSelect)
        return 0;

    int found = 0;
    for(int A = 1; A <= numPlayers; A++)
    {
        if(Player[A].State == 5 || Player[A].State == 6)
        {
            found = A;
            break;
        }
    }

    if(!found)
        return 0;

#ifndef LOW_MEM
    const vScreen_t& vscreen = vScreenByPlayer(found);
    for(const Block_t& b : treeBlockQuery(newLoc(-vscreen.X, -vscreen.Y, vscreen.Width, vscreen.Height), SORTMODE_NONE))
    {
        if(b.Type == 457 && !b.Hidden && !b.Invis)
            return 106;
    }
#endif

    return 30;
}

static const Hint s_hints[] = {
    {"Press Alt Run to pound downwards!",                       "pound-altrun", s_altrun_pound_applies, s_draw_purple_pet_altrun},
    {"Press Down to pound downwards!",                          "pound-down",   s_down_pound_applies,   s_draw_purple_pet_down},
    {"No coins left? Take a loan! Just watch your score...",    "no-lives-new", s_no_lives_new_applies, s_draw_no_lives_new},
    {"Be careful - Game Over is imminent!",                     "no-lives-old", s_no_lives_old_applies, s_draw_no_lives_old},
    {"Grab, run, hold down, and let go to surf.",               "rainbow-surf", s_rainbow_surf_applies, s_draw_rainbow_surf},
    {"Press Run to collect and Alt Run to throw.",              "char5-bombs",  s_char5_bombs_applies,  s_draw_char5_bombs},
    {"Duck to block most - but not all - flames!",              "heavy-duck",   s_heavy_duck_applies,   s_draw_heavy_duck},
    {"Wearing this blocks most - but not all - flames!",        "shoe-block",   s_shoe_block_applies,   s_draw_shoe_block},
    {"Some blocks are vulnerable to special powers.",           "gray-bricks",  s_gray_bricks_applies,  s_draw_gray_bricks},
};

static constexpr size_t s_hint_count = sizeof(s_hints) / sizeof(Hint);


// library state defined here

//! translatable strings for hints
static std::vector<std::string> s_translated_hint_text;

//! index into s_translated_hint_text for each hint (for case of duplicated keys)
static std::array<int, s_hint_count> s_hint_text_index;

//! currently loaded hint
static int s_select_hint = -1;
static uint8_t s_select_hint_priority = 0;


// main library functions here

/**
 * \brief idempotent; prepares hint strings for translation and use
 **/
static void Init()
{
    if(!s_translated_hint_text.empty())
        return;

    for(size_t i = 0; i < s_hint_count; i++)
    {
        // check if a duplicate
        size_t use_idx = 0;
        for(; use_idx < i; use_idx++)
        {
            if(SDL_strcmp(s_hints[i].tr_id, s_hints[use_idx].tr_id) == 0)
                break;
        }

        // if not duplicate, add unique string
        if(use_idx == i)
        {
            s_hint_text_index[i] = s_translated_hint_text.size();
            s_translated_hint_text.push_back(s_hints[i].text_en);
        }
        // otherwise, refer to existing string
        else
            s_hint_text_index[i] = s_hint_text_index[use_idx];
    }
}

void ResetStrings()
{
    Init();

    for(size_t i = s_hint_count; i != 0;)
    {
        --i;

        if(s_hint_text_index[i] >= (int)s_translated_hint_text.size())
            continue;

        s_translated_hint_text[s_hint_text_index[i]] = s_hints[i].text_en;
    }
}

void InitTranslations(XTechTranslate& translate)
{
    Init();

    int top_index = -1;

    for(size_t i = 0; i < s_hint_count; i++)
    {
        if(s_hint_text_index[i] <= top_index)
            continue;

        SDL_assert(s_hint_text_index[i] == top_index + 1); // no hints should be skipped

        top_index = s_hint_text_index[i];

        XTechTranslate::insert(translate.m_engineMap, fmt::format_ne("game.hint.{0}", s_hints[i].tr_id), &(s_translated_hint_text[top_index]));
    }
}

void Select()
{
    Init();

    s_select_hint = -1;
    s_select_hint_priority = 0;

    for(size_t hint_i = 0; hint_i < s_hint_count; hint_i++)
    {
        const Hint& hint = s_hints[hint_i];

        uint8_t hint_priority = hint.check_priority();

        if(hint_priority <= s_select_hint_priority)
            continue;

        s_select_hint = (int)hint_i;
        s_select_hint_priority = hint_priority;
    }
}

void Draw(int top, int min_priority, int width)
{
    if(BattleMode || s_select_hint == -1 || s_hint_text_index[s_select_hint] >= (int)s_translated_hint_text.size())
        return;

    const Hint& hint = s_hints[s_select_hint];
    const std::string& tr_hint = s_translated_hint_text[s_hint_text_index[s_select_hint]];

    if(s_select_hint_priority < min_priority)
        return;

    constexpr int hint_box_height = 96;
    const int hint_box_width = width;
    constexpr int text_start = 110;

    int hint_box_left = XRender::TargetW / 2 - hint_box_width / 2;

    XRender::renderRect(hint_box_left -  4, top    , hint_box_width + 8, hint_box_height + 8, {  0,   0,   0});
    XRender::renderRect(hint_box_left -  2, top + 2, hint_box_width + 4, hint_box_height + 4, {255, 255, 255});
    XRender::renderRect(hint_box_left     , top + 4, hint_box_width    , hint_box_height    , {  0,   0,   0});
    XRender::renderRect(hint_box_left + 96, top + 4,                  2, hint_box_height    , {255, 255, 255});

    // draw icon
    hint.draw_icon(hint_box_left, top + 4);

    // draw text
    std::string text = tr_hint;
    PGE_Size text_size = FontManager::optimizeTextPx(text, hint_box_width - 2 - text_start, FontManager::fontIdFromSmbxFont(4));

    FontManager::printText(text.c_str(), text.size(),
                           hint_box_left + text_start,
                           top + hint_box_height / 2 - text_size.h() / 2 + 4,
                           FontManager::fontIdFromSmbxFont(4));
}

} // namespace XHints


================================================
FILE: src/main/hints.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#pragma once
#ifndef THEXTECH_HINTS_H
#define THEXTECH_HINTS_H

#include <string>

class XTechTranslate;

namespace XHints
{

/**
 * \brief resets hint strings to their English values
 **/
void ResetStrings();

/**
 * \brief registers hint strings for translation
 **/
void InitTranslations(XTechTranslate& translate);

/**
 * \brief select a hint based on the currently loaded level
 **/
void Select();

/**
 * \brief draws a hint chosen with SelectHint() on the screen
 *
 * \param top top y coordinate for hint box
 * \param min_priority required priority for the hint to get drawn
 * \param width width of hint box
 **/
void Draw(int top, int min_priority, int width = 460);

} // namespace XHints

#endif // #ifndef THEXTECH_HINTS_H


================================================
FILE: src/main/level_file.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_timer.h"

#include <json/json_rwops_input.hpp>
#include <json/json.hpp>
#include <fmt_format_ne.h>
#include <algorithm>

#ifdef __16M__
// used to clear loaded textures on level/world load
#include "core/render.h"
#endif

#include "../globals.h"
#include "../game_main.h" // SetupPhysics()
#include "../frame_timer.h"
#include "../npc.h"
#include "../load_gfx.h"
#include "../custom.h"
#include "../sound.h"
#include "../sorting.h"
#include "../layers.h"
#include "saved_layers.h"
#include "config.h"
#include "../graphics.h"
#include "../editor.h"
#include "../npc_id.h"
#include "blk_id.h"
#include "level_file.h"
#include "main/level_save_info.h"
#include "main/level_medals.h"
#include "main/game_strings.h"
#include "main/screen_progress.h"
#include "main/game_strings.h"
#include "main/game_info.h"
#include "trees.h"
#include "npc_traits.h"
#include "npc_special_data.h"
#include "graphics/gfx_camera.h"
#include "graphics/gfx_update.h"
#include "npc/npc_activation.h"
#include "npc/npc_queues.h"
#include "translate_episode.h"
#include "fontman/font_manager.h"

#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <Utils/strings.h>
#include <Utils/dir_list_ci.h>
#include <Logger/logger.h>
#include <PGE_File_Formats/file_formats.h>

#include "global_dirs.h"
#include "screen_fader.h"

#include "editor/editor_custom.h"
#include "editor/editor_strings.h"

#include "npc/section_overlap.h"

#include "../version.h"

#ifdef THEXTECH_BUILD_GL_MODERN
#    include "core/opengl/gl_program_bank.h"
#endif

#ifdef THEXTECH_ENABLE_LUAU
#    include "script/luau/test.h"
#endif


// warning for improper rects
static const char* s_improper_rect_warning = "Attempted to set %s %d %s to %d, setting to 0";

// used to signal a total failure in a callback
#ifdef PGEFL_CALLBACK_API
using callback_error = PGE_FileFormats_misc::callback_error;
#else
using callback_error = std::runtime_error;
#endif

[[ noreturn ]] void priv_FeatureLevelError(const std::string& errMsg, int reqFeatureLevel, int curFeatureLevel)
{
    // use MessageText as a temporary store -- the error gets processed before returning to game code control
    MessageText = fmt::format_ne(errMsg, reqFeatureLevel, curFeatureLevel);
    throw callback_error(MessageText.c_str());
}

void addMissingLvlSuffix(std::string &fileName)
{
    if(!fileName.empty() && !Files::hasSuffix(fileName, ".lvl") && !Files::hasSuffix(fileName, ".lvlx") && !Files::hasSuffix(fileName, "tst"))
    {
        bool isAbsolute = Files::isAbsolute(fileName);
        bool lvlxExists;

        if(isAbsolute)
            lvlxExists = Files::fileExists(fileName + ".lvlx");
        else
            lvlxExists = !g_dirEpisode.resolveFileCaseExists(fileName + ".lvlx").empty();

        if(lvlxExists)
            fileName += ".lvlx";
        else
            fileName += ".lvl";
    }
}

void validateLevelName(std::string &out, const std::string &raw)
{
    if(raw.empty())
    {
        out.clear();
        return;
    }

    if(!Strings::endsWith(raw, ".lvl") && !Strings::endsWith(raw, ".lvlx"))
    {
        std::string lx = g_dirEpisode.resolveFileCaseExists(raw + ".lvlx"),
                    lo = g_dirEpisode.resolveFileCaseExists(raw + ".lvl");

        if(!lx.empty())
            out = lx;
        else if(!lo.empty())
            out = lo;
        else
            out = g_dirEpisode.resolveFileCase(raw);
    }
    else
        out = g_dirEpisode.resolveFileCase(raw);
}

bool OpenLevel(std::string FilePath)
{
    addMissingLvlSuffix(FilePath);

    PGE_FileFormats_misc::RWopsTextInput in(Files::open_file(FilePath, "r"), FilePath);

    if(in.eof())
    {
        pLogWarning("File [%s] missing!", FilePath.c_str());
        MessageText = "File does not exist";
        return false;
    }

    if(!OpenLevelData(in, FilePath))
        return false;

    OpenLevelDataPost();

    return true;
}

struct LevelLoad
{
    std::vector<std::string> current_layers;
    std::vector<std::string> current_events;

    std::vector<layerindex_t> final_layer_index;
    std::vector<eventindex_t> final_event_index;

    SaveInfoInit si;

    int numPlayerStart = 0;

    layerindex_t layers_finalized = 0;
    eventindex_t events_finalized = 0;

    void AddCurrentLayer(const std::string& layer_name)
    {
        current_layers.push_back(layer_name);
        final_layer_index.push_back(LAYER_NONE);
    }

    layerindex_t FindLayer(const std::string& layer_name)
    {
        if(layer_name.empty())
            return LAYER_NONE;

        const char* s = layer_name.c_str();
        if(s[0] == 'D' && s[1] == 'e' && s[2] == 'f' && s[3] == 'a' && s[4] == 'u' && s[5] == 'l' && s[6] == 't' && s[7] == '\0')
            return LAYER_DEFAULT;

        for(layerindex_t A = 0; A < current_layers.size(); A++)
        {
            if(SDL_strcasecmp(current_layers[A].c_str(), layer_name.c_str()) == 0)
                return A;
        }

        if(current_layers.size() == LAYER_NONE)
            return LAYER_NONE;

        layerindex_t old_size = (layerindex_t)current_layers.size();
        AddCurrentLayer(layer_name);

        return old_size;
    }

    layerindex_t FinalizeLayer(layerindex_t current_index)
    {
        if(current_index == LAYER_NONE)
            return LAYER_NONE;

        if(final_layer_index[current_index] == LAYER_NONE)
        {
            // note: both 0 and maxLayers are valid layer indexes
            if(layers_finalized > maxLayers)
                return LAYER_NONE;

            final_layer_index[current_index] = layers_finalized;
            layers_finalized++;
        }

        return final_layer_index[current_index];
    }

    void AddCurrentEvent(const std::string& event_name)
    {
        current_events.push_back(event_name);
        final_event_index.push_back(EVENT_NONE);
    }

    eventindex_t FindEvent(const std::string& event_name)
    {
        if(event_name.empty())
            return EVENT_NONE;

        for(eventindex_t A = 0; A < current_events.size(); A++)
        {
            if(SDL_strcasecmp(current_events[A].c_str(), event_name.c_str()) == 0)
                return A;
        }

        if(current_events.size() == EVENT_NONE)
            return EVENT_NONE;

        eventindex_t old_size = (eventindex_t)current_events.size();
        AddCurrentEvent(event_name);

        return old_size;
    }

    eventindex_t FinalizeEvent(eventindex_t current_index)
    {
        if(current_index == EVENT_NONE)
            return EVENT_NONE;

        if(final_event_index[current_index] == EVENT_NONE)
        {
            // note: both 0 and maxEvents are valid event indexes
            if(events_finalized > maxEvents)
                return EVENT_NONE;

            final_event_index[current_index] = events_finalized;
            events_finalized++;
        }

        return final_event_index[current_index];
    }
};

#ifdef PGEFL_CALLBACK_API
LevelLoadCallbacks OpenLevel_SetupCallbacks(LevelLoad& load);
#else
bool OpenLevel_Unpack(LevelLoad& load, LevelData& lvl);
#endif

void OpenLevel_FixLayersEvents(const LevelLoad& load);

bool OpenLevelData(PGE_FileFormats_misc::TextInput& input, const std::string FilePath)
{
    if(FilePath == ".lvl" || FilePath == ".lvlx")
        return false;

    LevelLoad load;

    qScreen = false;
    qScreen_canonical = false;
    ClearLevel();
    BlockSound();
    FreezeNPCs = false;
    CoinMode = false;

    numBlock = 0;
    numBackground = 0;
    numLocked = 0;
    numNPCs = 0;
    numWarps = 0;
    numSections = 0;

    // initialize basic layers and events left by ClearLevel()
    // they'll get updated, but this is necessary to handle PGE-X files without them included
    load.AddCurrentLayer("Default");

    for(int l = 0; l < 3; l++)
        load.FinalizeLayer(load.FindLayer(Layer[l].Name));

    for(int e = 0; e < 3; e++)
        load.FinalizeEvent(load.FindEvent(Events[e].Name));


    // set the file path and load custom configuration
    const std::string& path = (FilePath.empty()) ? input.getFilePath() : FilePath;

    FileNamePath = Files::dirname(path) + "/";
    g_dirEpisode.setCurDir(FileNamePath);

    FileName = g_dirEpisode.resolveDirCase(Files::basenameNoSuffix(path));
    g_dirCustom.setCurDir(FileNamePath + FileName);

    FileNameFull = Files::basename(path);
    FullFileName = path;


// Load Custom Stuff
    LoadCustomConfig();
    FindCustomPlayers();
    FindCustomNPCs();
    LoadCustomGFX();
    LoadCustomSound();
    FontManager::loadCustomFonts();


    load.si.begin(g_curLevelMedals.should_initialize());

#ifdef PGEFL_CALLBACK_API
    LevelLoadCallbacks callbacks = OpenLevel_SetupCallbacks(load);
    if(!FileFormats::OpenLevelFileT(input, callbacks))
    {
        pLogDebug("Failed to load [%s]", FilePath.c_str());
        load.si.on_error();
        return false;
    }
#else
    LevelData lvl;
    if(!FileFormats::OpenLevelFileT(input, lvl))
    {
        pLogWarning("Error of level \"%s\" file loading: %s (line %ld).",
                    FilePath.c_str(),
                    lvl.meta.ERROR_info.c_str(),
                    lvl.meta.ERROR_linenum);
        load.si.on_error();
        return false;
    }

    if(!OpenLevel_Unpack(load, lvl))
        return false;
#endif

    OpenLevel_FixLayersEvents(load);

    return true;
}

#ifdef PGEFL_CALLBACK_API
void OpenLevel_Error(void*, FileFormatsError& e)
{
    pLogWarning("Error of level file loading: %s (line %ld).",
                e.ERROR_info.c_str(),
                e.ERROR_linenum);

    MessageText = std::move(e.ERROR_info);
}
#endif

#ifdef PGEFL_CALLBACK_API
bool OpenLevel_Head(void* userdata, LevelHead& head)
#else
bool OpenLevel_Head(void* userdata, LevelData& head)
#endif
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    // Level-wide settings
    // maxStars = head.stars;
    LevelName = head.LevelName;

    constexpr unsigned int engineFeatureLevel = V_FEATURE_LEVEL;

#ifdef PGEFL_CALLBACK_API
    FileFormat = head.RecentFormat;
    unsigned int reqFeatureLevel = head.engineFeatureLevel;
#else
    FileFormat = head.meta.RecentFormat;
    unsigned int reqFeatureLevel = head.meta.engineFeatureLevel;
#endif

    if(reqFeatureLevel > engineFeatureLevel)
        priv_FeatureLevelError(g_gameStrings.errorTooOldEngine, reqFeatureLevel, engineFeatureLevel);
    else if(reqFeatureLevel > g_gameInfo.contentFeatureLevel)
        priv_FeatureLevelError(g_gameStrings.errorTooOldGameAssets, reqFeatureLevel, g_gameInfo.contentFeatureLevel);

    // Level-wide extra settings
    if(!head.custom_params.empty())
    {
        // none supported yet
    }

    load.si.check_head(head);

    return true;
}

bool OpenLevel_Section(void*, LevelSection& s)
{
    // preserving indent
    {
        // load failure, invalid section ID
        if(s.id > maxSections || s.id < 0)
            throw callback_error("Invalid section id");

        if(s.id + 1 > numSections)
            numSections = s.id + 1;

        int B = s.id;

        LevelREAL[B].X = s.size_left;
        LevelREAL[B].Y = s.size_top;
        LevelREAL[B].Height = s.size_bottom;
        LevelREAL[B].Width = s.size_right;
        level[B] = static_cast<SpeedlessLocation_t>(LevelREAL[B]);
        bgMusic[B] = int(s.music_id);
        bgMusicREAL[B] = bgMusic[B];
        // bgColor[B] = s.bgcolor;    // unused since SMBX64, removed
        LevelWrap[B] = s.wrap_h;
        LevelVWrap[B] = s.wrap_v; // EXTRA
        OffScreenExit[B] = s.OffScreenEn;
        Background2[B] = int(s.background);
        Background2REAL[B] = Background2[B];
        NoTurnBack[B] = s.lock_left_scroll;
        UnderWater[B] = s.underwater;
        if(s.music_file.empty())
            CustomMusic[B].clear();
        else
            CustomMusic[B] = g_dirEpisode.resolveFileCase(s.music_file);

        // NOTE: maybe this will get stored and used as a Lua table (instead of as a string) on platforms supporting Lua
        if(LevelEditor && !s.custom_params.empty())
            SetS(SectionJSONInfo[B], s.custom_params);

#if defined(THEXTECH_BUILD_GL_MODERN)
        if(!s.custom_params.empty())
        {
            try
            {
                const nlohmann::json section_data = nlohmann::json::parse(s.custom_params);

                if(section_data.contains("effects"))
                {
                    std::string screen_effect = section_data["effects"].value("screenEffect", "");
                    if(screen_effect.empty())
                    {
                        const char* x2_screen_effects[] = {"", "wavy", "lava", "caustics", "underwater", "mist", "sepia", "grayscale", "inverted", "gameboy", "gameboy-dither"};

                        int x2_effect_idx = section_data["effects"].value("screenEffects", 0);
                        if(x2_effect_idx > 0 && x2_effect_idx < int(sizeof(x2_screen_effects) / sizeof(const char*)))
                        {
                            screen_effect += "x2-";
                            screen_effect += x2_screen_effects[x2_effect_idx];
                        }
                    }

                    if(!screen_effect.empty())
                        SectionEffect[B] = ResolveGLProgram("screen-" + screen_effect);

                    std::string particles_fg = section_data["effects"].value("fgParticles", "");
                    if(particles_fg.empty())
                    {
                        const char* x2_weather_effects[] = {"", "rain", "snow", "fog", "sandstorm", "cinders", "wisps"};

                        int x2_weather_idx = section_data["effects"].value("weather", 0);
                        if(x2_weather_idx > 0 && x2_weather_idx < int(sizeof(x2_weather_effects) / sizeof(const char*)))
                        {
                            particles_fg += "x2-";
                            particles_fg += x2_weather_effects[x2_weather_idx];
                        }
                    }

                    if(!particles_fg.empty())
                        SectionParticlesFG[B] = ResolveGLParticleSystem("particles-" + particles_fg);

                    std::string particles_bg = section_data["effects"].value("bgParticles", "");
                    if(!particles_bg.empty())
                        SectionParticlesBG[B] = ResolveGLParticleSystem("particles-" + particles_bg);
                }

                SectionLighting[B] = GLLightSystem();
                if(section_data.contains("darkness") && section_data["darkness"].value("enableDarkness", false))
                {
                    double shadow_strength = section_data["darkness"].value("shadowStrength", 0.5);
                    SectionLighting[B].shadow_strength = (float)shadow_strength;

                    int shadow_type = section_data["darkness"].value("shadowType", -1);
                    if(shadow_type == -1)
                    {
                        int x2_shadows = section_data["darkness"].value("shadows", 0);

                        if(x2_shadows == 1)
                            SectionLighting[B].system_type = GLLightSystemType::shadow_rays;
                        else if(x2_shadows == 2)
                        {
                            SectionLighting[B].system_type = GLLightSystemType::shadow_rays;
                            SectionLighting[B].shadow_strength = 1.0f;
                        }
                        else
                            SectionLighting[B].system_type = GLLightSystemType::shadow_none;
                    }

                    if(shadow_type == 1)
                        SectionLighting[B].system_type = GLLightSystemType::shadow_rays;
                    else if(shadow_type == 2)
                        SectionLighting[B].system_type = GLLightSystemType::shadow_drop;
                    else
                        SectionLighting[B].system_type = GLLightSystemType::shadow_none;

                    std::string ambient = section_data["darkness"].value("ambient", "#181828ff");

                    SectionLighting[B].ambient = XTColorString(ambient);
                }
            }
            catch(const std::exception &e)
            {
                pLogWarning("Failed to load Section %d JSON data: %s", B, e.what());

                SectionEffect[B] = LoadedGLProgramRef_t();
                SectionParticlesBG[B] = LoadedGLProgramRef_t();
                SectionParticlesFG[B] = LoadedGLProgramRef_t();
                SectionLighting[B] = GLLightSystem();
            }
        }
#endif
    }
    return true;
}


bool OpenLevel_PlayerStart(void* userdata, PlayerPoint& p)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    if(load.numPlayerStart == 2)
        return false;

    {
        // TODO: should try to use the startpoint's ID field if possible
        load.numPlayerStart++;
        int A = load.numPlayerStart;

        PlayerStart[A].X = p.x;
        PlayerStart[A].Y = p.y;
        PlayerStart[A].Width = p.w;
        PlayerStart[A].Height = p.h;

        // don't allow improper rects
        if(PlayerStart[A].Width < 0)
        {
            pLogWarning(s_improper_rect_warning, "PlayerStart", A, "Width", (int)p.w);
            PlayerStart[A].Width = 0;
        }

        if(PlayerStart[A].Height < 0)
        {
            pLogWarning(s_improper_rect_warning, "PlayerStart", A, "Height", (int)p.h);
            PlayerStart[A].Height = 0;
        }

        // Width and height are zero in LVLX files
        // This indicates SMBX-based values for height, not the values of the actual asset pack
        if(PlayerStart[A].Width == 0)
            PlayerStart[A].Width = 24;

        if(PlayerStart[A].Height == 0)
        {
            if(A == 1)
                PlayerStart[A].Height = 54;
            else if(A == 2)
                PlayerStart[A].Height = 60;
            else
                PlayerStart[A].Height = 32;
        }

        // turn into size compatible with in-game editor UI
        if(LevelEditor)
        {
            PlayerStart[A].X += PlayerStart[A].Width / 2;
            PlayerStart[A].Y += PlayerStart[A].Height;

            PlayerStart[A].Width = Physics.PlayerWidth[A][2];
            PlayerStart[A].Height = Physics.PlayerHeight[A][2];

            PlayerStart[A].X -= PlayerStart[A].Width / 2;
            PlayerStart[A].Y -= PlayerStart[A].Height;
        }

        PlayerStart[A].Direction = p.direction;

        if(load.numPlayerStart == 2)
            return false;
    }

    return true;
}

bool OpenLevel_Layer(void* userdata, LevelLayer& l)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    {
        int A = load.FinalizeLayer(load.FindLayer(l.name));

        // too many layers
        if(A == LAYER_NONE)
            throw callback_error("Too many layers");

        // update layer count
        if(A + 1 > numLayers)
            numLayers = A + 1;

        auto &layer = Layer[A];

        layer = Layer_t();

        layer.Name = l.name;
        layer.Hidden = l.hidden;
        // hide layers after everything is done
    }

    return true;
}

bool OpenLevel_Event(void* userdata, LevelSMBX64Event& e)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    {
        int A = load.FinalizeEvent(load.FindEvent(e.name));

        // too many events
        if(A == EVENT_NONE)
            throw callback_error("Too many events");

        // update events count
        if(A + 1 > numEvents)
            numEvents = A + 1;

        auto &event = Events[A];

        event.reinit();

        event.Name = e.name;
        if(!e.msg.empty())
            SetS(event.Text, e.msg);
        event.Sound = int(e.sound_id);
        event.EndGame = int(e.end_game);

        event.HideLayer.clear();
        for(std::string& l : e.layers_hide)
        {
            layerindex_t found = load.FindLayer(l);
            if(found != LAYER_NONE)
                event.HideLayer.push_back(found);
        }
        event.ShowLayer.clear();
        for(std::string& l : e.layers_show)
        {
            layerindex_t found = load.FindLayer(l);
            if(found != LAYER_NONE)
                event.ShowLayer.push_back(found);
        }
        event.ToggleLayer.clear();
        for(std::string& l : e.layers_toggle)
        {
            layerindex_t found = load.FindLayer(l);
            if(found != LAYER_NONE)
                event.ToggleLayer.push_back(found);
        }

        // this was done in ClearLevel, but may be necessary here to refresh matters
        for(int B = 0; B <= maxSections; B++)
        {
            auto &s = event.section[B];
            s.music_id = LevelEvent_Sets::LESet_Nothing;
            s.background_id = LevelEvent_Sets::LESet_Nothing;
            s.music_file = STRINGINDEX_NONE;
            s.position.X = LevelEvent_Sets::LESet_Nothing;
            s.position.Y = 0;
            s.position.Height = 0;
            s.position.Width = 0;
        }

        // unpack section settings
        for(auto &s : e.sets)
        {
            // this has a different meaning (padding) when we are not actually using callbacks
            if(s.id == -1)
                continue;
            // invalid section ID
            else if(s.id > maxSections || s.id < 0)
                throw callback_error("Invalid section id");

            // relies on the fact that this is an ARRAY at TheXTech's side
            auto &ss = event.section[s.id];

            ss.music_id = int(s.music_id);
            ss.background_id = int(s.background_id);
            if(!s.music_file.empty())
            {
                SetS(ss.music_file, s.music_file);
            }

            auto &l = ss.position;
            l.X = s.position_left;
            l.Y = s.position_top;
            l.Height = s.position_bottom;
            l.Width = s.position_right;

            ss.autoscroll = s.autoscrol;
            // Simple style is only supported yet
            if(s.autoscroll_style == LevelEvent_Sets::AUTOSCROLL_SIMPLE)
            {
                ss.autoscroll_x = (numf_t)num_t::from_double((float)s.autoscrol_x);
                ss.autoscroll_y = (numf_t)num_t::from_double((float)s.autoscrol_y);
            }
        }

        event.TriggerEvent = load.FindEvent(e.trigger);

        event.TriggerDelay = e.trigger_timer;

        event.LayerSmoke = e.nosmoke;

        event.Controls.AltJump = e.ctrl_altjump;
        event.Controls.AltRun = e.ctrl_altrun;
        event.Controls.Down = e.ctrl_down;
        event.Controls.Drop = e.ctrl_drop;
        event.Controls.Jump = e.ctrl_jump;
        event.Controls.Left = e.ctrl_left;
        event.Controls.Right = e.ctrl_right;
        event.Controls.Run = e.ctrl_run;
        event.Controls.Start = e.ctrl_start;
        event.Controls.Up = e.ctrl_up;

        event.AutoStart = e.autostart;
        event.MoveLayer = load.FindLayer(e.movelayer);
        event.SpeedX = (numf_t)num_t::from_double((float)e.layer_speed_x);
        event.SpeedY = (numf_t)num_t::from_double((float)e.layer_speed_y);

        event.AutoX = (numf_t)num_t::from_double((float)e.move_camera_x);
        event.AutoY = (numf_t)num_t::from_double((float)e.move_camera_y);
        event.AutoSection = int(e.scroll_section);
    }

    return true;
}

bool OpenLevel_Block(void* userdata, LevelBlock& b)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    {
        numBlock++;
        if(numBlock > maxBlocks)
        {
            numBlock = maxBlocks;
            return false;
        }

        auto &block = Block[numBlock];

        block = Block_t();

        block.Location.X = b.x;
        block.Location.Y = b.y;
        block.Location.Height = b.h;
        block.Location.Width = b.w;

        // don't allow improper rects
        if(block.Location.Width < 0)
        {
            pLogWarning(s_improper_rect_warning, "Block", numBlock, "Width", (int)b.w);
            block.Location.Width = 0;
        }

        if(block.Location.Height < 0)
        {
            pLogWarning(s_improper_rect_warning, "Block", numBlock, "Height", (int)b.h);
            block.Location.Height = 0;
        }

        block.Type = int(b.id);
        block.DefaultType = block.Type;

        if(b.npc_id > maxNPCType)
        {
            pLogWarning("Block contents %d is out of range (max NPC type %d), reset to 1 coin", (int)b.npc_id, maxNPCType);
            b.npc_id = -1;
        }

        block.Special = int(b.npc_id > 0 ? b.npc_id + 1000 : -1 * b.npc_id);

        switch(block.Special) // Replace some legacy NPC codes with new
        {
        case 100: block.Special = 1000 + NPCID_POWER_S3; break;
        case 102: block.Special = 1000 + NPCID_FIRE_POWER_S3; break;
        case 103: block.Special = 1000 + NPCID_LEAF_POWER; break;
        case 105: block.Special = 1000 + NPCID_PET_GREEN; break;
        default: break;
        }

        block.DefaultSpecial = block.Special;

        block.forceSmashable = false;
        if(b.id == 90)
        {
            // if(lvl.meta.RecentFormat == LevelData::SMBX64 && lvl.meta.RecentFormatVersion < 20)
            //     block.forceSmashable = true; // Restore bricks algorithm for turn blocks for SMBX19 and lower
            // else
            block.forceSmashable = (bool)b.special_data; // load it if set in the modern format
        }

        block.Invis = b.invisible;
        block.Slippy = b.slippery;
        block.Layer = load.FindLayer(b.layer);
        block.TriggerDeath = load.FindEvent(b.event_destroy);
        block.TriggerHit = load.FindEvent(b.event_hit);
        block.TriggerLast = load.FindEvent(b.event_emptylayer);

        if((block.Type == 186 || block.Type == 457) && (block.TriggerDeath != EVENT_NONE || block.TriggerLast != EVENT_NONE))
        {
            const char* error_string = "Block 186 or 457 has a destroy event. TheXTech does not match SMBX 1.3 logic in this case. This content cannot be played in Vanilla mode.";

            pLogWarningS(error_string);

            if(g_config.playstyle == Config_t::MODE_VANILLA)
                throw callback_error(error_string);
        }

        if(IF_OUTRANGE(block.Type, 0, maxBlockType) || block.Type == BLKID_CONVEYOR_L_CONV || block.Type == BLKID_CONVEYOR_R_CONV) // Drop ID to 1 for blocks of out of range IDs
        {
            pLogWarning("Block-%d ID is out of range (max types %d), reset to Block-1", block.Type, maxBlockType);
            block.Type = 1;
        }
    }

    return true;
}

bool OpenLevel_Background(void* userdata, LevelBGO& b)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    {
        numBackground++;
        if(numBackground > maxBackgrounds)
        {
            numBackground = maxBackgrounds;
            return false;
        }

        auto &bgo = Background[numBackground];

        bgo = Background_t();

        bgo.Location.X = b.x;
        bgo.Location.Y = b.y;
        bgo.Type = int(b.id);

        if(IF_OUTRANGE(bgo.Type, 1, maxBackgroundType)) // Drop ID to 1 for BGOs of out of range IDs
        {
            pLogWarning("BGO-%d ID is out of range (max types %d), reset to BGO-1", bgo.Type, maxBackgroundType);
            bgo.Type = 1;
        }

        bgo.Layer = load.FindLayer(b.layer);
        bgo.Location.Width = GFXBackground[bgo.Type].w;
        bgo.Location.Height = BackgroundHeight[bgo.Type];

        bgo.SetSortPriority(b.z_mode, std::round(b.z_offset));
    }

    return true;
}

bool OpenLevel_NPC(void* userdata, LevelNPC& n)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    {
        bool variantHandled = false;

        numNPCs++;
        if(numNPCs > maxNPCs)
        {
            numNPCs = maxNPCs;
            return false;
        }

        auto &npc = NPC[numNPCs];

        npc.Location.X = n.x;
        npc.Location.Y = n.y;
        if(!LevelEditor)
            npc.Location.Y -= 0.01_n;
        npc.Direction = n.direct;

        if(n.id > maxNPCType) // Drop ID to 1 for NPCs of out of range IDs
        {
            pLogWarning("NPC-%d ID is out of range (max types %d), reset to NPC-1", (int)n.id, maxNPCType);
            n.id = 1;
        }

        if(n.contents > maxNPCType) // Drop contents to 0 for NPCs of out of range contents
        {
            pLogWarning("NPC contents %d is out of range (max types %d), reset to 0", (int)n.contents, maxNPCType);
            n.contents = 0;
        }

        npc.Type = NPCID(n.id);

        bool force_variant = false;

        if(npc.Type == NPCID_ITEM_BURIED || npc.Type == NPCID_ITEM_POD ||
           npc.Type == NPCID_ITEM_BUBBLE || npc.Type == NPCID_ITEM_THROWER ||
           (NPCNewContainerType(npc.Type) && FileFormat == FileFormats::LVL_PGEX))
        {
            npc.Special = (vbint_t)n.contents;
            npc.DefaultSpecial = npc.Special;
            npc.Variant = n.special_data;
            variantHandled = true;

            // this use of special_data was enabled in SMBX64
            if(npc.Type == NPCID_ITEM_BURIED && npc.Special == NPCID_DOOR_MAKER)
                force_variant = true;
        }
        else if(npc.Type == NPCID_DOOR_MAKER || npc.Type == NPCID_MAGIC_DOOR)
        {
            if(n.special_data < 0)
                npc.Variant = 255;
            else
                npc.Variant = n.special_data;

            // this use of special_data was enabled in SMBX64
            force_variant = true;
            variantHandled = true;
        }

        if(NPCIsAParaTroopa(npc))
        {
            npc.Special = (vbint_t)n.special_data;
            npc.DefaultSpecial = npc.Special;
        }

        if(npc->IsFish)
        {
            npc.Special = (vbint_t)n.special_data;
            npc.DefaultSpecial = npc.Special;
        }

        if(npc.Type == NPCID_FIRE_CHAIN)
        {
            npc.Special = (vbint_t)n.special_data;
            npc.DefaultSpecial = npc.Special;
        }

        if(npc.Type == NPCID_STAR_EXIT || npc.Type == NPCID_STAR_COLLECT || npc.Type == NPCID_MEDAL)
        {
            npc.Variant = n.special_data;
            variantHandled = true;
        }

        // don't load anything for SMBX64 files
        if(FileFormat == FileFormats::LVL_SMBX64 && !force_variant)
        {
            npc.Variant = 0;
        }
        // only load Variant for NPCs that support it
        else if(find_Variant_Data(npc.Type))
        {
            if((n.special_data < 0) || (n.special_data >= 256))
                pLogWarning("Attempted to load npc Type %d with out-of-range variant index %ld", (int)npc.Type, n.special_data);
            else
                npc.Variant = (uint8_t)n.special_data;
        }
        else
        {
            if(!variantHandled)
                npc.Variant = 0;
        }

        // NEW: GFX expansion
        npc.GFXSlot = (uint8_t)n.gfx_dx;

        npc.Generator = n.generator;
        if(npc.Generator)
        {
            npc.Special3 = ((uint16_t)(uint8_t)n.generator_direct << 8) + (uint8_t)n.generator_type;
            npc.GeneratorTime() = 0;
            npc.GeneratorTimeMax() = n.generator_period;

            // npc.GeneratorDirection = n.generator_direct;
            // npc.GeneratorEffect = n.generator_type;
            // npc.GeneratorTimeMax = n.generator_period;
        }

        if(!n.msg.empty())
            SetS(npc.Text, n.msg);

        npc.Inert = n.friendly;
        if(npc.Type == NPCID_SIGN)
            npc.Inert = true;
        npc.Stuck = n.nomove;
        npc.DefaultStuck = npc.Stuck;

        if(n.wings_type && !NPCBansWings(npc))
        {
            npc.DefaultWings = (WingBehaviors)n.wings_type;
            npc.Wings = npc.DefaultWings;
        }

        npc.Legacy = n.is_boss;

        npc.Layer = load.FindLayer(n.layer);
        npc.TriggerActivate = load.FindEvent(n.event_activate);
        npc.TriggerDeath = load.FindEvent(n.event_die);
        npc.TriggerTalk = load.FindEvent(n.event_talk);
        npc.TriggerLast = load.FindEvent(n.event_emptylayer);
        npc.AttLayer = load.FindLayer(n.attach_layer);

        npc.DefaultType = npc.Type;
        npc.Location.Width = npc->TWidth;
        npc.Location.Height = npc->THeight;
        npc.DefaultLocationX = npc.Location.X;
        npc.DefaultLocationY = npc.Location.Y;
        npc.DefaultDirection = npc.Direction;

        // allow every NPC to be active for one frame to initialize its internal state
        npc.TimeLeft = 1;
        npc.Active = true;
        npc.JustActivated = 1;
    }

    // update the level's save info based on the NPC
    load.si.check_npc(n);

    return true;
}

bool OpenLevel_Warp(void* userdata, LevelDoor& w)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    w.isSetIn = (!w.lvl_i);
    w.isSetOut = (!w.lvl_o || (w.lvl_i));

    if(!w.isSetIn && w.isSetOut)
    {
        w.ix = w.ox;
        w.iy = w.oy;
        w.length_i = w.length_o;
        w.height_i = w.height_o;
    }

    if(!w.isSetOut && w.isSetIn)
    {
        w.ox = w.ix;
        w.oy = w.iy;
        w.length_o = w.length_i;
        w.height_o = w.height_i;
    }

    {
        numWarps++;
        if(numWarps > maxWarps)
        {
            numWarps = maxWarps;
            return false;
        }

        auto &warp = Warp[numWarps];

        warp = Warp_t();

        warp.PlacedEnt = true;
        warp.PlacedExit = true;
        warp.Entrance.X = w.ix;
        warp.Entrance.Y = w.iy;
        warp.Exit.X = w.ox;
        warp.Exit.Y = w.oy;
        warp.Direction = w.idirect;
        warp.Direction2 = w.odirect;
        warp.Effect = w.type;

        // Work around filenames with no extension suffix and case missmatch
        if(!w.lname.empty())
        {
            std::string level_name;
            validateLevelName(level_name, w.lname);
            SetS(warp.level, level_name);
        }

        warp.LevelWarp = int(w.warpto);
        warp.LevelEnt = w.lvl_i;

        warp.MapWarp = w.lvl_o;
        warp.MapX = int(w.world_x);
        warp.MapY = int(w.world_y);

        warp.Stars = w.stars;
        warp.Layer = load.FindLayer(w.layer);
        warp.Hidden = w.unknown;

        warp.NoYoshi = w.novehicles;
        warp.WarpNPC = w.allownpc;
        warp.Locked = w.locked;

        // custom fields:
        warp.twoWay = w.two_way;

        warp.cannonExit = w.cannon_exit;
        warp.cannonExitSpeed = w.cannon_exit_speed;
        warp.eventEnter = load.FindEvent(w.event_enter);
        warp.eventExit = load.FindEvent(w.event_exit);
        if(!w.stars_msg.empty())
            SetS(warp.StarsMsg, w.stars_msg);
        warp.noPrintStars = w.star_num_hide;
        warp.noEntranceScene = w.hide_entering_scene;

        warp.stoodRequired = w.stood_state_required;
        warp.transitEffect = w.transition_effect;

        warp.Entrance.Height = w.height_i;
        warp.Entrance.Width = w.length_i;
        warp.Exit.Height = w.height_o;
        warp.Exit.Width = w.length_o;

        // FIXME: allow warp object to specify a transit effect name as a string
        if(warp.transitEffect >= ScreenFader::S_CUSTOM)
            warp.transitEffect = ScreenFader::loadTransitEffect(std::to_string(warp.transitEffect));
    }

    return true;
}

bool OpenLevel_Water(void* userdata, LevelPhysEnv& w)
{
    LevelLoad& load = *static_cast<LevelLoad*>(userdata);

    {
        numWater++;
        if(numWater > maxWater)
        {
            numWater = maxWater;
            return false;
        }

        auto &water = Water[numWater];

        water = Water_t();

        water.Location.X = w.x;
        water.Location.Y = w.y;
        water.Location.Width = w.w;
        water.Location.Height = w.h;

        // don't allow improper rects
        if(water.Location.Width < 0)
        {
            pLogWarning(s_improper_rect_warning, "Water", numWater, "Width", (int)w.w);
            water.Location.Width = 0;
        }

        if(water.Location.Height < 0)
        {
            pLogWarning(s_improper_rect_warning, "Water", numWater, "Height", (int)w.h);
            water.Location.Height = 0;
        }

        // water.Buoy = w.buoy;
        water.Type = (PHYSID)w.env_type;
        water.Layer = load.FindLayer(w.layer);
    }

    return true;
}

void OpenLevel_FixLayersEvents(const LevelLoad& load)
{
    // Everything is loaded.
    // Now we fix the layers and events that got temporary indexes.
    // We also do some NPC logic that depends on the section boundaries.
    for(int A = 1; A <= numBlock; A++)
    {
        if(Block[A].Layer != LAYER_NONE)
            Block[A].Layer = load.final_layer_index[Block[A].Layer];

        if(Block[A].TriggerDeath != EVENT_NONE)
            Block[A].TriggerDeath = load.final_event_index[Block[A].TriggerDeath];

        if(Block[A].TriggerHit != EVENT_NONE)
            Block[A].TriggerHit = load.final_event_index[Block[A].TriggerHit];

        if(Block[A].TriggerLast != EVENT_NONE)
            Block[A].TriggerLast = load.final_event_index[Block[A].TriggerLast];
    }

    for(int A = 1; A <= numBackground; A++)
    {
        if(Background[A].Layer != LAYER_NONE)
            Background[A].Layer = load.final_layer_index[Background[A].Layer];
    }

    // Prepare for NPC logic
    CalculateSectionOverlaps();
    int checkPointId = 0;

    for(int A = 1; A <= numNPCs; A++)
    {
        if(NPC[A].Layer != LAYER_NONE)
            NPC[A].Layer = load.final_layer_index[NPC[A].Layer];

        if(NPC[A].AttLayer != LAYER_NONE)
            NPC[A].AttLayer = load.final_layer_index[NPC[A].AttLayer];

        if(NPC[A].TriggerActivate != EVENT_NONE)
            NPC[A].TriggerActivate = load.final_event_index[NPC[A].TriggerActivate];

        if(NPC[A].TriggerDeath != EVENT_NONE)
            NPC[A].TriggerDeath = load.final_event_index[NPC[A].TriggerDeath];

        if(NPC[A].TriggerTalk != EVENT_NONE)
            NPC[A].TriggerTalk = load.final_event_index[NPC[A].TriggerTalk];

        if(NPC[A].TriggerLast != EVENT_NONE)
            NPC[A].TriggerLast = load.final_event_index[NPC[A].TriggerLast];

        // section check logic is stubbed in the game menu, so don't use a strict check
        if(!GameMenu)
            NPC[A].Section = maxSections + 1;

        CheckSectionNPC(A);

        // if not fully in any section, use canonical camera for this (fixes final boss of Valtteri's Island - Revisited)
        if(NPC[A].Section == maxSections + 1)
        {
            NPC[A].Section = 0;
            NPC[A]._priv_force_canonical = true;
        }


        // Extra NPC load logic
        NPC_t& npc = NPC[A];

        if(npc.Type == NPCID_CHECKPOINT) // Is a checkpoint
        {
            checkPointId++;
            if(g_config.fix_vanilla_checkpoints)
            {
                npc.Special = checkPointId;
                npc.DefaultSpecial = int(npc.Special);
            }
        }
        else if(npc.Type == NPCID_STAR_EXIT || npc.Type == NPCID_STAR_COLLECT) // Is a star
        {
            bool starFound = false;
            for(const auto& star : Star)
            {
                bool bySection = npc.Variant == 0 && (star.Section == npc.Section || star.Section == -1);
                bool byId = npc.Variant > 0 && -(star.Section + 100) == (int)npc.Variant;
                if(star.level == FileNameFull && (bySection || byId))
                    starFound = true;
            }

            if(starFound)
            {
                npc.Special = 1;
                npc.DefaultSpecial = 1;
                if(npc.Type == NPCID_STAR_COLLECT)
                    npc.Killed = 9;
            }
        }
        else if(NPCIsContainer(npc) &&
                (NPCID(npc.Special) == NPCID_STAR_EXIT || NPCID(npc.Special) == NPCID_STAR_COLLECT)) // Is a container that has a star inside
        {
            bool starFound = false;
            for(const auto& star : Star)
            {
                bool byId = npc.Variant > 0 && -(star.Section + 100) == (int)npc.Variant;
                if(star.level == FileNameFull && byId)
                    starFound = true;
            }

            if(starFound)
            {
                if(NPCID(npc.Special) == NPCID_STAR_COLLECT)
                    npc.Killed = 9;
            }
        }
    }

    for(int A = 1; A <= numWarps; A++)
    {
        if(Warp[A].Layer != LAYER_NONE)
            Warp[A].Layer = load.final_layer_index[Warp[A].Layer];

        if(Warp[A].eventEnter != EVENT_NONE)
            Warp[A].eventEnter = load.final_event_index[Warp[A].eventEnter];

        if(Warp[A].eventExit != EVENT_NONE)
            Warp[A].eventExit = load.final_event_index[Warp[A].eventExit];

        syncLayers_Warp(A);
    }

    for(int A = 1; A <= numWater; A++)
    {
        if(Water[A].Layer != LAYER_NONE)
            Water[A].Layer = load.final_layer_index[Water[A].Layer];

        syncLayers_Water(A);
    }

    for(int A = 0; A < numEvents; A++)
    {
        if(Events[A].MoveLayer != LAYER_NONE)
            Events[A].MoveLayer = load.final_layer_index[Events[A].MoveLayer];

        if(Events[A].TriggerEvent != EVENT_NONE)
            Events[A].TriggerEvent = load.final_event_index[Events[A].TriggerEvent];

        // fix all layer indices
        for(int i = 0; i < 3; i++)
        {
            auto& arr = (i == 0) ? Events[A].ShowLayer
                : (i == 1) ? Events[A].HideLayer
                : Events[A].ToggleLayer;

            auto out_it = arr.begin();
            for(auto in_it = out_it; in_it != arr.end(); ++in_it)
            {
                layerindex_t l = *in_it;

                if(l != LAYER_NONE)
                    l = load.final_layer_index[l];

                if(l != LAYER_NONE)
                    *(out_it++) = l;
            }

            arr.resize(out_it - arr.begin());
        }
    }

    LAYER_USED_P_SWITCH = FindLayer(LAYER_USED_P_SWITCH_TITLE);
}

#ifdef PGEFL_CALLBACK_API

LevelLoadCallbacks OpenLevel_SetupCallbacks(LevelLoad& load)
{
    LevelLoadCallbacks callbacks;

    callbacks.on_error = OpenLevel_Error;
    callbacks.load_head = OpenLevel_Head;
    callbacks.load_section = OpenLevel_Section;
    callbacks.load_startpoint = OpenLevel_PlayerStart;
    callbacks.load_block = OpenLevel_Block;
    callbacks.load_bgo = OpenLevel_Background;
    callbacks.load_npc = OpenLevel_NPC;
    callbacks.load_warp = OpenLevel_Warp;
    callbacks.load_phys = OpenLevel_Water;
    callbacks.load_layer = OpenLevel_Layer;
    callbacks.load_event = OpenLevel_Event;

    callbacks.userdata = &load;

    return callbacks;
}

#else // #ifdef PGEFL_CALLBACK_API

bool OpenLevel_Unpack(LevelLoad& load, LevelData& lvl)
{
    try
    {
        OpenLevel_Head(&load, lvl);

        for(auto &s : lvl.sections)
        {
            if(!OpenLevel_Section(&load, s))
                break;
        }
        for(auto &p : lvl.players)
        {
            if(!OpenLevel_PlayerStart(&load, p))
                break;
        }
        for(auto &b : lvl.blocks)
        {
            if(!OpenLevel_Block(&load, b))
                break;
        }
        for(auto &b : lvl.bgo)
        {
            if(!OpenLevel_Background(&load, b))
                break;
        }
        for(auto &n : lvl.npc)
        {
            if(!OpenLevel_NPC(&load, n))
                break;
        }
        for(auto &w : lvl.doors)
        {
            if(!OpenLevel_Warp(&load, w))
                break;
        }
        for(auto &w : lvl.physez)
        {
            if(!OpenLevel_Water(&load, w))
                break;
        }
        for(auto &l : lvl.layers)
        {
            if(!OpenLevel_Layer(&load, l))
                break;
        }
        for(auto &e : lvl.events)
        {
            if(!OpenLevel_Event(&load, e))
                break;
        }
    }
    catch(const callback_error& e)
    {
        pLogWarning("Error of level \"%s\" file loading: %s.",
                    lvl.meta.filename.c_str(),
                    e.what());

        MessageText = e.what();

        return false;
    }

    return true;
}
#endif // #else // #ifdef PGEFL_CALLBACK_API

void OpenLevelDataPost()
{
    TranslateEpisode tr;

    if(!GameMenu && !LevelEditor)
        tr.loadLevelTranslation(FileNameFull);

#ifdef THEXTECH_ENABLE_LUAU
    load_test_script();
#endif

    IsEpisodeIntro = (StartLevel == FileNameFull);

    if(IsEpisodeIntro)
    {
        IsHubLevel = NoMap;
        FileRecentSubHubLevel.clear();
    }

    if(!IsHubLevel)
    {
        IsHubLevel = std::find(SubHubLevels.begin(), SubHubLevels.end(), FileNameFull) != SubHubLevels.end();

        if(IsHubLevel)
            FileRecentSubHubLevel = FileNameFull;
    }

    // turn NPC conveyor belts into new conveyor belts in modern mode
    bool used_new_belts = false;

    if(g_config.new_conveyor_belts && !LevelEditor)
    {
        const NPCTraits_t& t = NPCTraits[NPCID_CONVEYOR];

        // check all of these conditions first
        if(t.FrameOffsetX == 0 && t.FrameOffsetY == 0
            && (t.WidthGFX == 0 || t.WidthGFX == t.TWidth)
            && (t.HeightGFX == 0 || t.HeightGFX == t.THeight)
            && t.IsABlock && t.CanWalkOn && t.MovesPlayer && !t.JumpHurt
            && t.WontHurt && t.NoYoshi && t.Speedvar == 1)
        {
            int numNPCs_new = 0;

            for(int A = 1; A <= numNPCs; A++)
            {
                const NPC_t& n_in = NPC[A];

                if(n_in.Type == NPCID_CONVEYOR &&
                   !n_in.Generator &&
                   !n_in.Inert &&
                   numBlock < maxBlocks &&
                   n_in.AttLayer == LAYER_NONE)
                {
                    used_new_belts = true;

                    numBlock++;

                    auto &block = Block[numBlock];

                    block = Block_t();

                    block.Location = n_in.Location;

                    block.Type = (n_in.Direction > 0) ? BLKID_CONVEYOR_R_CONV : BLKID_CONVEYOR_L_CONV;
                    block.Location.SpeedX = (n_in.Direction > 0) ? 0.8_n : -0.8_n;

                    block.DefaultType = block.Type;
                    block.Layer = n_in.Layer;

                    continue;
                }

                numNPCs_new++;
                if(A != numNPCs_new)
                    NPC[numNPCs_new] = NPC[A];
            }

            // clear the deleted NPCs (prevents NPC index shenanigans)
            for(int A = numNPCs_new + 1; A <= numNPCs; A++)
                NPC[A] = NPC_t();

            numNPCs = numNPCs_new;
        }

        // (note: it might be possible to handle the case where MovesPlayer and IsABlock are both false but CanWalkOn and IsAHit1Block are true)
        // (note: it might be possible to handle the case where SpeedVar is not 1 -- still risky if SpeedVar is greater than 10)
    }

    // TODO: disable this if the file indicates that it is already sorted
    if(g_config.emulate_classic_block_order && (FileFormat == FileFormats::LVL_PGEX || used_new_belts))
    {
        qSortBlocks(1, numBlock);
        qSortBackgrounds(1, numBackground);
    }
    else
        qSortBackgrounds(1, numBackground, false);

    // FindBlocks();
    UpdateBackgrounds();
    // FindSBlocks();
    syncLayersTrees_AllBlocks();
    syncLayers_AllBGOs();
    syncLayers_AllNPCs();

    NPC_ConstructCanonicalSet();

    // moved the old event/layer loading code to the top
    // since it is needed before loading objects now

    for(int A = 0; A < numLayers; A++)
    {
        // check if layer is a saved layer
        for(int i = 0; i < numSavedLayers; i++)
        {
            if(SDL_strcasecmp(Layer[A].Name.c_str(), SavedLayers[i].Name.data()) == 0)
            {
                Layer[A].SavedLayer = i + 1;
                if(!LevelEditor)
                    Layer[A].Hidden = !SavedLayers[i].Visible;
                break;
            }
        }

        // hide layer if needed
        if(Layer[A].Hidden)
            HideLayer(A, true);
    }


    if(LevelEditor)
    {
        if(numSections < 21)
            numSections = 21;

        ResetSectionScrolls();
        SetSection(curSection);
    }
    else
    {
        FindStars();
        LevelMacro = LEVELMACRO_OFF;
        for(int A = 0; A < numSections; A++) // Automatically correct 608 section height to 600
        {
//            if(int(level[A].Height - level[A].Y) == 608)
//                level[A].Y += 8;
            int height = int(level[A].Height - level[A].Y);
            if(height > 600 && height < 610)
                level[A].Y = level[A].Height - 600; // Better and cleaner logic
        }

        int B = numBackground;
        for(int A = 1; A <= numWarps; A++)
        {
            auto &w = Warp[A];
            if(w.Effect == 2 && w.Stars > numStars)
            {
                B++;
                numLocked++;
                auto &bgo = Background[B];
                bgo = Background_t();
                bgo.Layer = w.Layer;
                bgo.Hidden = w.Hidden;
                bgo.Location.Width = 24;
                bgo.Location.Height = 24;
                bgo.Location.Y = w.Entrance.Y - bgo.Location.Height;
                bgo.Location.X = w.Entrance.X + (w.Entrance.Width - bgo.Location.Width) / 2;
                bgo.Type = 160;
                syncLayers_BGO(B);

                if(w.twoWay)
                {
                    B++;
                    numLocked++;
                    auto &bgo2 = Background[B];
                    bgo2 = bgo;
                    bgo2.Location = bgo.Location;
                    bgo2.Location.Y = w.Exit.Y - bgo2.Location.Height;
                    bgo2.Location.X = w.Exit.X + (w.Exit.Width - bgo2.Location.Width) / 2;
                    syncLayers_BGO(B);
                }
            }
            else if(w.Effect == 2 && w.Locked) // For locks
            {
                B++;
                numLocked++;
                auto &bgo = Background[B];
                bgo = Background_t();
                bgo.Layer = w.Layer;
                bgo.Hidden = w.Hidden;
                bgo.Location = w.Entrance;
                bgo.Type = 98;
                bgo.Location.Width = 16;
                syncLayers_BGO(B);

                if(w.twoWay)
                {
                    B++;
                    numLocked++;
                    auto &bgo2 = Background[B];
                    bgo2 = bgo;
                    bgo2.Location = w.Exit;
                    bgo2.Location.Width = 16;
                    syncLayers_BGO(B);
                }
            }
        }
    }

    if(!LevelEditor)
    {
        g_curLevelMedals.prepare_lvl();
        OrderMedals();
    }

    // If too much locks
    SDL_assert_release(numBackground + numLocked <= (maxBackgrounds + maxWarps));

    SoundPause[SFX_Camera] = 100;
    resetFrameTimer();
}

void ClearLevel()
{
    int A = 0;
    const NPC_t blankNPC = NPC_t();
    const Water_t blankwater = Water_t();
    const Warp_t blankWarp = Warp_t();
    const Block_t blankBlock = Block_t();
    const Background_t BlankBackground = Background_t();
    const Location_t BlankLocation = Location_t();
    const SpeedlessLocation_t BlankSpeedless;
    const Effect_t blankEffect = Effect_t();
    NPCTraits[NPCID_MEDAL].Score = 6;
    RestoreWorldStrings();
    LevelName.clear();
    IsHubLevel = false;
    // default file format if level header is missing
    FileFormat = FileFormats::LVL_PGEX;
    // removed because the same logic is called inside of LoadCustomConfig()
    // ResetCustomConfig();
    SetupPhysics();
    LoadNPCDefaults();
    LoadPlayerDefaults();
    // noUpdate = true;
    BlocksSorted = true;
    qScreen = false;
    qScreen_canonical = false;

#ifdef __16M__
    XRender::clearAllTextures();
#endif

    SectionJSONInfo.fill(STRINGINDEX_NONE);

#ifdef THEXTECH_BUILD_GL_MODERN
    SectionEffect.fill(LoadedGLProgramRef_t());
    SectionParticlesBG.fill(LoadedGLProgramRef_t());
    SectionParticlesFG.fill(LoadedGLProgramRef_t());
    SectionLighting.fill(GLLightSystem());
#endif

    UnloadCustomGFX();
    doShakeScreenClear();
    ResetCameraPanning();
    treeLevelCleanAll();
    FontManager::clearLevelFonts();

    invalidateDrawBlocks();
    invalidateDrawBGOs();
    NPCQueues::clear();

    AutoUseModern = false;

    numSections = 0;

    for(A = 1; A <= newEventNum; A++)
    {
        NewEvent[A] = EVENT_NONE;
        newEventDelay[A] = 0;
    }

    for(A = 0; A <= maxSections; A++)
    {
        AutoX[A] = 0;
        AutoY[A] = 0;
    }

    numEvents = 3;
    newEventNum = 0;
    for(A = 0; A <= maxEvents; A++)
        InitializeEvent(Events[A]);

    for(A = 0; A <= maxWater; A++)
        Water[A] = blankwater;

    numWater = 0;
    Events[0].Name = "Level - Start";
    Events[1].Name = "P Switch - Start";
    Events[2].Name = "P Switch - End";
    curMusic = 0;
    curStars = 0;
    // maxStars = 0;
    g_curLevelMedals.reset_lvl();

    InvincibilityTime = 0;
    PSwitchTime = 0;
    PSwitchStop = 0;
    BeltDirection = 1;
    StopMusic();
    Layer[0] = Layer_t();
    Layer[0].Name = "Default";
    Layer[0].Hidden = false;
    Layer[1] = Layer_t();
    Layer[1].Name = "Destroyed Blocks";
    Layer[1].Hidden = true;
    Layer[2] = Layer_t();
    Layer[2].Name = "Spawned NPCs";
    Layer[2].Hidden = false;

    LAYER_USED_P_SWITCH = LAYER_NONE;

    numLayers = 3;
    for(A = 3; A <= maxLayers; A++)
    {
        Layer[A] = Layer_t();
        // all of these are cleared by reinitializing the layer
        // if(A > 2)
        // {
        //     Layer[A].Name = "";
        //     Layer[A].Hidden = false;
        // }
        // Layer[A].SpeedX = 0;
        // Layer[A].SpeedY = 0;
    }

//    If LevelEditor = True Or MagicHand = True Then
    if(LevelEditor || MagicHand)
    {
//        MessageText = ""
        MessageText.clear();
//        frmNPCs.chkMessage.Value = 0
//        frmBlocks.chkFill.Value = 0
//        frmEvents.txtEvent.Text = ""
//        noUpdate = True
        // noUpdate = true;
//        frmEvents.RefreshEvents
//        frmLayers.lstLayer.Clear
//        frmLayers.lstLayer.AddItem "Default"
//        frmLayers.lstLayer.AddItem "Destroyed Blocks"
//        frmLayers.lstLayer.AddItem "Spawned NPCs"
//        frmLayers.lstLayer.Selected(1) = False
//        frmLayers.lstLayer.Selected(2) = True
//        frmLayers.lstLayer.Selected(0) = True
//        frmLayers.cmdDelete.Enabled = False
//        frmLayers.txtLayer.Enabled = False
//        frmLevelEditor.optCursor(13).Value = True
//    End If
    }

    for(A = -128; A <= maxNPCs; A++)
        NPC[A] = blankNPC;
    numNPCs = 0;

    for(A = 1; A <= maxBlocks; A++)
        Block[A] = blankBlock;
    numBlock = 0;

    for(A = 1; A <= maxBackgrounds; A++)
        Background[A] = BlankBackground;

    for(A = 0; A <= maxSections; A++)
    {
        Background2[A] = 0;
        // bgColor[A] = 0xF89868;    // unused since SMBX64, removed
        bgMusic[A] = 0;
        level[A] = BlankSpeedless;
        LevelREAL[A] = IntegerLocation_t();
        LevelWrap[A] = false;
        LevelVWrap[A] = false;
        // LevelChop[A] = 0; // unused since SMBX64, removed
        NoTurnBack[A] = false;
        UnderWater[A] = false;
        OffScreenExit[A] = false;
        CustomMusic[A] = "";
    }

    for(A = 1; A <= numWarps; A++)
        Warp[A] = blankWarp;
    numWarps = 0;

    for(A = 1; A <= numEffects; A++)
        Effect[A] = blankEffect;
    numEffects = 0;
    numBackground = 0;
    numLocked = 0;
    MidBackground = 1;
    LastBackground = 0;
    PlayerStart[1] = BlankLocation;
    PlayerStart[2] = BlankLocation;

    // noUpdate = false;
}

void FindStars()
{
//    int A = 0;
//    int B = 0;
//    std::string newInput;
    LevelData tempData;

    uint32_t start_time = SDL_GetTicks();

    for(int A = 1; A <= numWarps; A++)
    {
        IndicateProgress(start_time, num_t(A) / numWarps, g_gameStrings.messageScanningLevels);

        auto &warp = Warp[A];

        if(warp.level != STRINGINDEX_NONE)
        {
            std::string lFile = GetS(warp.level);

            warp.curStars = 0;

            for(const auto& star : Star)
            {
                if(SDL_strcasecmp(star.level.c_str(), Files::basename(lFile).c_str()) == 0)
                    warp.curStars++;
            }

            if(warp.save_info().inited())
                continue;

            // set the warp's save info index

            // check world levels
            for(uint16_t idx = 1; idx != 0x7FFF && idx <= numWorldLevels; ++idx)
            {
                const auto& l = WorldLevel[idx];

                if(l.FileName == lFile)
                {
                    warp.save_info_idx = 0x8000 + idx;
                    break;
                }
            }

            if(warp.save_info().inited())
                continue;

            // check existing level warp save entries
            for(uint16_t idx = 0; idx != 0x7FFF && idx < LevelWarpSaveEntries.size(); ++idx)
            {
                const auto& e = LevelWarpSaveEntries[idx];

                if(e.levelPath == lFile)
                {
                    warp.save_info_idx = idx;
                    break;
                }
            }

            if(warp.save_info().inited())
                continue;

            // don't overflow the LevelWarpSaveEntries array
            if(LevelWarpSaveEntries.size() >= 0x7FFF)
                continue;

            // add a new save entry if the file exists
            std::string fullPath = g_dirEpisode.resolveFileCaseExistsAbs(lFile);

            if(!fullPath.empty())
            {
                LevelSaveInfo_t info = InitLevelSaveInfo(fullPath, tempData);

                if(info.inited())
                {
                    warp.save_info_idx = LevelWarpSaveEntries.size();
                    LevelWarpSaveEntries.push_back({lFile, info});
                }
            }
        }
    }
}

#if 0
// Is there any unsupported content for this format in the level?
bool CanConvertLevel(int format, std::string* reasons)
{
    if(format == FileFormats::LVL_PGEX)
        return true;

    if(format == FileFormats::LVL_SMBX38A)
    {
        if(reasons)
        {
            *reasons = g_editorStrings.fileConvert38aUnsupported;
            *reasons += '\n';
        }
        return false;
    }

    if(format != FileFormats::LVL_SMBX64)
    {
        if(reasons)
        {
            *reasons = g_editorStrings.fileConvertFormatUnknown;
            *reasons += '\n';
        }
        return false;
    }

    bool can_convert = true;
    if(reasons)
        reasons->clear();

    bool seen_transit = false;
    bool seen_stood = false;
    bool seen_cannon = false;
    bool seen_warp_event = false;
    bool seen_stars_msg = false;
    bool seen_no_print_stars = false;
    bool seen_no_entrance_scene = false;
    bool seen_portal_warp = false;
    for(int i = 1; i <= numWarps; i++)
    {
        Warp_t& w = Warp[i];

        if(!seen_transit && w.transitEffect != LevelDoor::TRANSIT_NONE)
        {
            can_convert = false;
            seen_transit = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpTransit;
                *reasons += '\n';
            }
        }

        if(!seen_stood && w.stoodRequired)
        {
            can_convert = false;
            seen_stood = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpNeedsStand;
                *reasons += '\n';
            }
        }

        if(!seen_cannon && w.cannonExit)
        {
            can_convert = false;
            seen_cannon = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpCannonExit;
                *reasons += '\n';
            }
        }

        if(!seen_warp_event && w.eventEnter != EVENT_NONE)
        {
            can_convert = false;
            seen_warp_event = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpEnterEvent;
                *reasons += '\n';
            }
        }

        if(!seen_stars_msg && !GetS(w.StarsMsg).empty())
        {
            can_convert = false;
            seen_stars_msg = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpCustomStarsMsg;
                *reasons += '\n';
            }
        }

        if(!seen_no_print_stars && w.noPrintStars)
        {
            can_convert = false;
            seen_no_print_stars = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpNoPrintStars;
                *reasons += '\n';
            }
        }

        if(!seen_no_entrance_scene && w.noEntranceScene)
        {
            can_convert = false;
            seen_no_entrance_scene = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpNoStartScene;
                *reasons += '\n';
            }
        }

        if(!seen_portal_warp && w.Effect == 3)
        {
            can_convert = false;
            seen_portal_warp = true;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureWarpPortal;
                *reasons += '\n';
            }
         }
    }

    bool seen_event_custom_music = false;
    bool seen_modern_autoscroll = false;
    for(int i = 0; i < numEvents; ++i)
    {
        Events_t& e = Events[i];

        for(int j = 0; j < numSections; ++j)
        {
            auto &ss = e.section[j];

            if(!seen_event_custom_music && !GetS(ss.music_file).empty())
            {
                can_convert = false;
                seen_event_custom_music = true;
                if(reasons)
                {
                    *reasons += g_editorStrings.fileConvertFeatureEventCustomMusic;
                    *reasons += '\n';
                }
            }

            if(!seen_modern_autoscroll && ss.autoscroll)
            {
                can_convert = false;
                seen_modern_autoscroll = true;
                if(reasons)
                {
                    *reasons += g_editorStrings.fileConvertFeatureEventAutoscroll;
                    *reasons += '\n';
                }
            }
        }
    }

    for(int i = 1; i <= numNPCs; i++)
    {
        if(NPC[i].Variant != 0)
        {
            can_convert = false;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureNPCVariant;
                *reasons += '\n';
            }
            break;
        }
    }

    for(int i = 1; i <= numBlock; i++)
    {
        if(Block[i].Type == 90 && Block[i].forceSmashable)
        {
            can_convert = false;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureBlockForceSmashable;
                *reasons += '\n';
            }
            break;
        }
    }

    for(int i = 1; i <= numBackground; i++)
    {
        if(Background[i].GetCustomLayer() || Background[i].GetCustomOffset())
        {
            can_convert = false;
            if(reasons)
            {
                *reasons += g_editorStrings.fileConvertFeatureBgoOrder;
                *reasons += '\n';
            }
            break;
        }
    }

    return can_convert;
}

// Strips all unsupported content from the level.
void ConvertLevel(int format)
{
    FileFormat = format;

    if(format == FileFormats::LVL_SMBX64 || format == FileFormats::LVL_SMBX38A)
    {
        if(!FileNameFull.empty() && FileNameFull.back() == 'x')
            FileNameFull.resize(FileNameFull.size() - 1);

        if(!FullFileName.empty() && FullFileName.back() == 'x')
            FullFileName.resize(FullFileName.size() - 1);
    }
    else
    {
        if(!FileNameFull.empty() && FileNameFull.back() != 'x')
            FileNameFull += "x";

        if(!FullFileName.empty() && FullFileName.back() != 'x')
            FullFileName += "x";
    }

    if(format != FileFormats::LVL_SMBX64)
        return;

    for(int i = 1; i <= numWarps; i++)
    {
        Warp_t& w = Warp[i];

        w.transitEffect = LevelDoor::TRANSIT_NONE;
        w.stoodRequired = false;
        w.cannonExit = false;
        w.eventEnter = EVENT_NONE;
        SetS(w.StarsMsg, "");
        w.noPrintStars = false;
        w.noEntranceScene = false;

        if(w.Effect == 3)
            w.Effect = 0;
    }

    for(int i = 0; i < numEvents; ++i)
    {
        Events_t& e = Events[i];

        for(int j = 0; j < numSections; ++j)
        {
            auto &ss = e.section[j];
            SetS(ss.music_file, "");
            ss.autoscroll = false;
        }
    }

    for(int i = 1; i <= numBackground; i++)
        Background[i].SetSortPriority(0, 0);

    for(int i = 1; i <= numNPCs; i++)
        NPC[i].Variant = 0;


    for(int i = 1; i <= numBlock; i++)
        Block[i].forceSmashable = 0;
}
#endif


================================================
FILE: src/main/level_file.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#pragma once
#ifndef LEVEL_FILE_H
#define LEVEL_FILE_H

#include <string>
#include <PGE_File_Formats/lvl_filedata.h>

extern void addMissingLvlSuffix(std::string &fileName);
extern void validateLevelName(std::string &out, const std::string &raw);

//! loads the level
bool OpenLevel(std::string FilePath);
bool OpenLevelData(PGE_FileFormats_misc::TextInput& input, const std::string FilePath = std::string());
void OpenLevelDataPost();
//! Reset everything to zero
void ClearLevel();

//! checks for stars in warps the lead to another level
void FindStars();

//! NEW: routines to check if it is possible to convert to legacy file formats and to remove all non-legacy content
// Removed, let PGE-FL handle conversion on its own.
// bool CanConvertLevel(int format, std::string* reasons);
// void ConvertLevel(int format);

#endif // LEVEL_FILE_H



================================================
FILE: src/main/level_medals.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <bitset>
#include <array>
#include <algorithm>

#include <sorting/tinysort.h>
#include <PGE_File_Formats/file_formats.h>

#include <Logger/logger.h>

#include "npc_id.h"
#include "npc.h"

#include "main/level_medals.h"
#include "main/level_save_info.h"

#include "logic/object_graph.h"

CurLevelMedals_t g_curLevelMedals;

// find the LevelSaveInfo for the current level
static inline LevelSaveInfo_t* s_findSaveInfo()
{
    for(int i = 1; i <= numWorldLevels; ++i)
    {
        if(WorldLevel[i].FileName == FileNameFull)
            return &WorldLevel[i].save_info;
    }

    for(auto& e : LevelWarpSaveEntries)
    {
        if(e.levelPath == FileNameFull)
            return &e.save_info;
    }

    return nullptr;
}

// find the next matching LevelSaveInfo for the current level, used to make sure all WorldLevels pointing to the same file are updated
static inline LevelSaveInfo_t* s_nextSaveInfo(LevelSaveInfo_t* prev)
{
    for(int i = 1; i <= numWorldLevels; ++i)
    {
        if(WorldLevel[i].FileName == FileNameFull)
        {
            LevelSaveInfo_t* info = &WorldLevel[i].save_info;

            if(info > prev)
                return info;
        }
    }

    return nullptr;
}

void CurLevelMedals_t::get(uint8_t idx)
{
    if(idx < c_max_track_medals && idx < max)
    {
        got |= (1 << idx);
        life |= (1 << idx);
    }
}

bool CurLevelMedals_t::gotten(uint8_t idx) const
{
    if(idx < c_max_track_medals && idx < max)
        return got & (1 << idx);

    return false;
}

void CurLevelMedals_t::on_any_death()
{
    life = 0;
}

void CurLevelMedals_t::on_all_dead()
{
    life = 0;

    if(Checkpoint == FullFileName)
        got = checkpoint;
    else
        got = 0;
}

void CurLevelMedals_t::on_checkpoint()
{
    checkpoint = got;
}

void CurLevelMedals_t::reset_checkpoint()
{
    checkpoint = 0;
}

void CurLevelMedals_t::resume_from_checkpoint()
{
    got = checkpoint;
}

void CurLevelMedals_t::reset_lvl()
{
    max = 0;
    prev = 0;
}

LevelSaveInfo_t* CurLevelMedals_t::should_initialize() const
{
    // find the level save info
    LevelSaveInfo_t* info = s_findSaveInfo();

    // if it can't be found in the world map / previously warped locations, initialize it and add to LevelWarpSaveEntries
    if(!info && LevelWarpSaveEntries.size() != 0xFFFF)
    {
        LevelWarpSaveEntries.push_back({FileNameFull, LevelSaveInfo_t()});
        info = &LevelWarpSaveEntries[LevelWarpSaveEntries.size() - 1].save_info;
    }

    // if allocation failed, just reset level info
    if(!info)
        return nullptr;

    // if allocated and inited, do nothing
    if(info->inited())
        return nullptr;

    // we are ready!
    return info;
}

void CurLevelMedals_t::prepare_lvl()
{
    // reset got / life
    got = 0;
    life = 0;

    // find the level save info
    LevelSaveInfo_t* info = s_findSaveInfo();

    // if save info isn't ready, just reset level info
    if(!info || !info->inited())
    {
        reset_lvl();
        return;
    }

    // load max / prev from the level info
    max = info->max_medals;
    prev = info->medals_got;
}

void CurLevelMedals_t::commit()
{
    LevelSaveInfo_t* info = s_findSaveInfo();

    if(!info)
        return;

    info->medals_got |= got;

    int old_best_count = 0;
    int new_best_count = 0;

    for(int i = 0; i < c_max_track_medals && i < info->max_medals; ++i)
    {
        if(info->medals_best & (1 << i))
            old_best_count++;

        if(life & (1 << i))
            new_best_count++;
    }

    if(new_best_count > old_best_count)
        info->medals_best = life;

    // copy this to any other world levels with the same filename
    while(LevelSaveInfo_t* next = s_nextSaveInfo(info))
    {
        *next = *info;
        info = next;
    }
}

void CommitBeatCode(int beat_code)
{
    if(beat_code <= 0 || beat_code > 16)
        return;

    LevelSaveInfo_t* info = s_findSaveInfo();
    if(!info)
        return;

    uint16_t bit = (1 << (beat_code - 1));
    info->exits_got |= bit;

    // copy this to any other world levels with the same filename
    while(LevelSaveInfo_t* next = s_nextSaveInfo(info))
    {
        *next = *info;
        info = next;
    }
}

void OrderMedals()
{
    using dist_and_hit_index = std::pair<uint16_t, int16_t>;

    // used to track medals without creator-specified indexes; first short is distance from start, second short is NPC array index
    std::array<dist_and_hit_index, c_max_track_medals> auto_medals;
    int auto_medal_count = 0;

    // used to track medals with creator indexes
    std::bitset<c_max_track_medals> used_indexes;

    // look for medals
    for(int i = 1; i <= numNPCs; ++i)
    {
        NPC_t& n = NPC[i];

        bool is_container = NPCIsContainer(n);

        bool contains_medal = is_container && n.Special == NPCID_MEDAL;

        // allow medals only
        if(n.Type != NPCID_MEDAL && !contains_medal)
            continue;

        // don't count friendly medals (except, thrown medals can be collected)
        if(n.Inert && n.Type != NPCID_ITEM_THROWER)
            continue;

        // medal won't be counted (at all) if out-of-range
        if(n.Variant > c_max_track_medals)
            continue;

        // record that the medal index has been used
        if(n.Variant > 0)
        {
            used_indexes[n.Variant - 1] = true;
            continue;
        }

        // if not specified, then try to fill into the array to auto-assign an index
        if(auto_medal_count < c_max_track_medals)
        {
            auto_medals[auto_medal_count] = {0, static_cast<int16_t>(i)};
            auto_medal_count++;
        }

        // otherwise, Variant will be left as 0 and medal won't be counted
    }

    // find the distance of unspecified medals from level start, and sort
    if(auto_medal_count > 1)
    {
        // need to order the auto_hits; get an idea of the layout of the level
        ObjectGraph::Graph graph;
        ObjectGraph::FillGraph(graph);

        for(int auto_i = 0; auto_i < auto_medal_count; ++auto_i)
        {
            const NPC_t& n = NPC[auto_medals[auto_i].second];

            unsigned int coord = graph.distance_from_start({(int)n.Location.X, (int)n.Location.Y});

            D_pLogDebug("Medal with NPC ID %d at %d from level start, %d to level end", auto_medals[auto_i].second, coord, graph.furthest_dist);

            // furthest_dist is the furthest item (including medals), and it's never negative
            uint64_t scaled_coord = (uint64_t)coord * 0x10000 / (2 * graph.furthest_dist);
            if(scaled_coord >= 0x10000)
                scaled_coord = 0xFFFF;

            auto_medals[auto_i].first = static_cast<uint16_t>(scaled_coord);
        }

        // sort by distance
        tinysort(auto_medals.begin(), auto_medals.begin() + auto_medal_count);
    }

    // auto-assign indexes to unspecified medals
    for(int auto_i = 0; auto_i < auto_medal_count; ++auto_i)
    {
        NPC_t& n = NPC[auto_medals[auto_i].second];

        // try to find an index
        for(int i = 0; i < c_max_track_medals; ++i)
        {
            if(!used_indexes[i])
            {
                D_pLogDebug("Medal with NPC ID %d gets index %d", auto_medals[auto_i].second, i + 1);

                n.Variant = i + 1;
                used_indexes[i] = true;
                break;
            }
        }

        // if failed, Variant will be left as 0 and medal won't be counted
    }
}


================================================
FILE: src/main/level_medals.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef LEVEL_MEDALS_H
#define LEVEL_MEDALS_H

#include <string>

struct LevelData;
struct LevelSaveInfo_t;

namespace PGE_FileFormats_misc
{
    class TextInput;
}

struct CurLevelMedals_t
{
protected:
    friend bool OpenLevelData(PGE_FileFormats_misc::TextInput &lvl, const std::string FilePath);
    friend void OpenLevelDataPost();

    /**
     * \brief checks if the current level's save data must be initialized
     * Must be called during OpenLevelData after FileNameFull is set
     *
     * The resulting pointer may be used by a SaveInfoInit object during level load,
     * and remains valid until the next time LevelWarpSaveEntries is modified
     * by this method or by FindStars()
     *
     * \param loadedLevel the loaded LevelData object, used to initialize level save info if needed
     */
    LevelSaveInfo_t* should_initialize() const;

    /**
     * \brief loads maximums from the current level and resets gotten counts
     * Must be called after the level is fully loaded and the save data has been initialized
     */
    void prepare_lvl();

public:
    //! INTEGER for number of medals available (can't exceed 8)
    uint8_t max = 0;

    //! bitfield of medals previously acquired in level (imported as "got" from save data)
    uint8_t prev = 0;
    //! bitfield of medals acquired during current play session (on win, combined with "got" in save data)
    uint8_t got = 0;
    //! bitfield of medals acquired since most recent lost life (on win, compared with and possibly replaces "best" in save data)
    uint8_t life = 0;
    //! bitfield of medals acquired at most recent checkpoint
    uint8_t checkpoint = 0;

    /**
     * \brief sets specific coin as obtained
     * \param idx coin index
     */
    void get(uint8_t idx);

    /**
     * \brief checks whether specific coin has been obtained
     * \param idx coin index
     */
    bool gotten(uint8_t idx) const;

    /**
     * \brief resets this-life medals
     */
    void on_any_death();

    /**
     * \brief loads currently got medals from checkpoint (if appropriate), resets this-life medals
     */
    void on_all_dead();

    /**
     * \brief saves currently got medals to checkpoint
     */
    void on_checkpoint();

    /**
     * \brief resets saved medals in checkpoint
     */
    void reset_checkpoint();

    /**
     * \brief restores saved medals from checkpoint
     */
    void resume_from_checkpoint();

    /**
     * \brief resets level attributes (keeps checkpoint and gotten counts)
     */
    void reset_lvl();

    /**
     * \brief commits run to current level's save info
     */
    void commit();
};

/**
 * \brief sets the Variant attribute of medals in the current level
 */
void OrderMedals();

/**
 * \brief Save an obtained level beat code to the current level's LevelSaveInfo entries
 */
void CommitBeatCode(int beat_code);

extern CurLevelMedals_t g_curLevelMedals;

#endif // #ifndef LEVEL_MEDALS_H


================================================
FILE: src/main/level_save_info.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <cstdio>
#include <string>
#include <bitset>
#include <PGE_File_Formats/file_formats.h>
#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "Utils/files.h"

#include "sdl_proxy/sdl_stdinc.h"

#include "npc_id.h"
#include "npc.h"

#include "globals.h"

#include "level_save_info.h"

static bool s_exportSingleSaveInfo(saveLevelInfo& s, const LevelSaveInfo_t& info)
{
    if(!info.inited())
        return false;

    s.max_stars = info.max_stars;
    s.max_medals = info.max_medals;
    s.exits_got = info.exits_got;

    int size = SDL_min(static_cast<int>(info.max_medals), c_max_track_medals);

    s.medals_got.resize(size);
    s.medals_best.resize(size);

    for(int i = 0; i < size; ++i)
    {
        s.medals_got[i]  = (info.medals_got  & (1 << i));
        s.medals_best[i] = (info.medals_best & (1 << i));
    }

    return true;
}

static bool s_importSingleSaveInfo(LevelSaveInfo_t& info, const saveLevelInfo& s)
{
    info = LevelSaveInfo_t();

    unsigned max_stars = s.max_stars;
    unsigned max_medals = s.max_medals;
    unsigned exits_got = s.exits_got;

    // validate limits
    static_assert(c_max_track_stars <= 255, "c_max_track_stars used to limit values of uint8_t");
    if(max_stars > c_max_track_stars)
        max_stars = c_max_track_stars;

    static_assert(c_max_track_medals <= 8, "c_max_track_medals used to limit bit indexes into uint8_t");
    if(max_medals > c_max_track_medals)
        max_medals = c_max_track_medals;

    exits_got &= 0xFFFF;

    // load maximums
    info.max_stars = max_stars;
    info.max_medals = max_medals;
    info.exits_got = exits_got;

    // load medals
    for(unsigned i = 0; i < max_medals; ++i)
    {
        if(i < s.medals_got.size() && s.medals_got[i])
            info.medals_got |= (1 << i);

        if(i < s.medals_got.size() && s.medals_best[i])
            info.medals_best |= (1 << i);
    }

    return true;
}

void ImportLevelSaveInfo(const GamesaveData& s)
{
    // reset all world levels' save info
    for(int A = 1; A <= numWorldLevels; A++)
    {
        if(WorldLevel[A].FileName.empty())
            continue;

        WorldLevel[A].save_info = LevelSaveInfo_t();
    }

    LevelWarpSaveEntries.clear();

    for(const saveLevelInfo& e : s.levelInfo)
    {
        LevelSaveInfo_t info;

        if(!s_importSingleSaveInfo(info, e))
            continue;

        D_pLogDebug("Loaded save info (stars %d, medals %d - got %x, best %x) for level [%s]", (int)info.max_stars, (int)info.max_medals, (int)info.medals_got, (int)info.medals_best, e.level_filename.c_str());

        // see if it applies to a world level
        bool worldLevelHit = false;

        for(int A = 1; A <= numWorldLevels; A++)
        {
            WorldLevel_t& l = WorldLevel[A];

            // can skip the string comparison if the level has already been initialized and we are no longer checking whether this save info has any level
            if(l.save_info.inited() && worldLevelHit)
                continue;

            if(l.FileName == e.level_filename)
            {
                // update level save info if not yet initialized
                if(!l.save_info.inited())
                    l.save_info = info;

                // mark save info as paired with a level
                worldLevelHit = true;

                // don't break, in case another level has the same filename
            }
        }

        // otherwise, add a new level warp save entry
        if(!worldLevelHit)
            LevelWarpSaveEntries.push_back(LevelWarpSaveEntry_t{e.level_filename, info});
    }
}

void ExportLevelSaveInfo(GamesaveData& s)
{
    saveLevelInfo tempInfo;

    for(int A = 1; A <= numWorldLevels; A++)
    {
        if(s_exportSingleSaveInfo(tempInfo, WorldLevel[A].save_info))
        {
            tempInfo.level_filename = WorldLevel[A].FileName;
            s.levelInfo.push_back(tempInfo);
        }
    }

    for(const auto& e : LevelWarpSaveEntries)
    {
        if(s_exportSingleSaveInfo(tempInfo, e.save_info))
        {
            tempInfo.level_filename = e.levelPath;
            s.levelInfo.push_back(tempInfo);
        }
    }
}

// level save info initialization code
void SaveInfoInit::begin(LevelSaveInfo_t* _target)
{
    target = _target;
    if(!target)
        return;

    target->max_stars = 0;
    target->max_medals = 0;
    target->medals_got = 0;
    target->medals_best = 0;

    // keep track of the user-specified ones because two medals with the same user index are only counted once
    used_indexes.reset();
}

void SaveInfoInit::on_error()
{
    if(target)
        *target = LevelSaveInfo_t();
}

#ifdef PGEFL_CALLBACK_API
void SaveInfoInit::check_head(const LevelHead& head)
#else
void SaveInfoInit::check_head(const LevelData& head)
#endif
{
    if(!target)
        return;

    target->max_stars = head.stars;
}

void SaveInfoInit::check_npc(const LevelNPC& npc)
{
    if(!target)
        return;

    bool is_container = (npc.id == NPCID_ITEM_BURIED || npc.id == NPCID_ITEM_POD ||
                         npc.id == NPCID_ITEM_BUBBLE || npc.id == NPCID_ITEM_THROWER ||
                         NPCNewContainerType(npc.id));

    bool contains_medal = is_container && npc.contents == NPCID_MEDAL;

    // allow medals only
    if(npc.id != NPCID_MEDAL && !contains_medal)
        return;

    // don't count friendly medals (except, thrown medals can be collected)
    if(npc.friendly && npc.id != NPCID_ITEM_THROWER)
        return;

    uint8_t Variant = static_cast<uint8_t>(npc.special_data);

    // medal won't be counted (at all) if out-of-range
    if(Variant > c_max_track_medals)
        return;

    // if no index, add to medal count
    if(Variant == 0)
    {
        if(target->max_medals < c_max_track_medals)
            target->max_medals++;

        return;
    }

    // if index specified, check that the index hasn't already been used
    if(!used_indexes[Variant - 1])
    {
        if(target->max_medals < c_max_track_medals)
            target->max_medals++;

        used_indexes[Variant - 1] = true;
    }
}

#ifdef PGEFL_CALLBACK_API

static void InitLevelSaveInfo_on_error(void* userdata, FileFormatsError& e)
{
    SaveInfoInit& si = *static_cast<SaveInfoInit*>(userdata);
    si.on_error();

    pLogWarning("During save info init: %s (line %ld).",
                e.ERROR_info.c_str(),
                e.ERROR_linenum);
}

static bool InitLevelSaveInfo_load_head(void* userdata, LevelHead& head)
{
    SaveInfoInit& si = *static_cast<SaveInfoInit*>(userdata);
    si.check_head(head);
    return true;
}

static bool InitLevelSaveInfo_load_npc(void* userdata, LevelNPC& npc)
{
    SaveInfoInit& si = *static_cast<SaveInfoInit*>(userdata);
    si.check_npc(npc);
    return true;
}

LevelSaveInfo_t InitLevelSaveInfo(const std::string& fullPath, LevelData&)
{
    LevelSaveInfo_t ret;

    SaveInfoInit si;
    si.begin(&ret);

    LevelLoadCallbacks cb;
    cb.on_error = InitLevelSaveInfo_on_error;
    cb.load_head = InitLevelSaveInfo_load_head;
    cb.load_npc = InitLevelSaveInfo_load_npc;
    cb.userdata = &si;

    PGE_FileFormats_misc::RWopsTextInput in(Files::open_file(fullPath, "r"), fullPath);

    if(FileFormats::OpenLevelFileT(in, cb))
        pLogDebug("Initing level save data at [%s] with %d stars and %d medals", fullPath.c_str(), (int)ret.max_stars, (int)ret.max_medals);
    else
    {
        si.on_error();
        pLogWarning("During save info init: failed to load [%s]", fullPath.c_str());
    }

    return ret;
}

#else // #ifdef PGEFL_CALLBACK_API
LevelSaveInfo_t InitLevelSaveInfo(const LevelData& loadedLevel)
{
    LevelSaveInfo_t ret;

    SaveInfoInit si;
    si.begin(&ret);

    si.check_head(loadedLevel);

    for(const auto& n : loadedLevel.npc)
        si.check_npc(n);

    return ret;
}

LevelSaveInfo_t InitLevelSaveInfo(const std::string& fullPath, LevelData& tempData)
{
    if(!FileFormats::OpenLevelFile(fullPath, tempData))
    {
        pLogWarning("During save info init: failed to load [%s]", fullPath.c_str());
        return LevelSaveInfo_t();
    }

    auto ret = InitLevelSaveInfo(tempData);

    pLogDebug("Initing level save data at [%s] with %d stars and %d medals", fullPath.c_str(), (int)ret.max_stars, (int)ret.max_medals);

    return ret;
}
#endif // #else // #ifdef PGEFL_CALLBACK_API


================================================
FILE: src/main/level_save_info.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef LEVEL_SAVE_INFO_H
#define LEVEL_SAVE_INFO_H

#include <string>
#include <bitset>

#include <PGE_File_Formats/file_formats.h>

#include "globals.h"

struct SaveInfoInit
{
    LevelSaveInfo_t* target = nullptr;
    std::bitset<c_max_track_medals> used_indexes;

    // resets target's fields to begin initialization
    void begin(LevelSaveInfo_t* target);

    // marks target as invalid on load error
    void on_error();

#ifdef PGEFL_CALLBACK_API
    // updates star count from header
    void check_head(const LevelHead& head);
#else
    // updates star count from header
    void check_head(const LevelData& head);
#endif

    // updates medal count from NPC
    void check_npc(const LevelNPC& head);
};

/**
 * \brief convenience function: initialize level save info from fullPath, loading the level into tempData
 *
 * \param fullPath a full path to the level file whose save info will be initialized
 * \param tempData an unloaded LevelData object used to prevent repeated heap allocations while loading multiple levels
 *
 * \return loaded save info
 */
LevelSaveInfo_t InitLevelSaveInfo(const std::string& fullPath, LevelData& tempData);

/**
 * \brief import all level save info into WorldLevel and LevelWarpSaveEntries from a GamesaveData object
 * \param s a PGE-FL GamesaveData object from which level save info will be loaded to global arrays
 */
void ImportLevelSaveInfo(const GamesaveData& s);

/**
 * \brief export all level save info from WorldLevel and LevelWarpSaveEntries to a GamesaveData object
 * \param s a mutable PGE-FL GamesaveData object to which level save info will be stored from global arrays
 */
void ExportLevelSaveInfo(GamesaveData& s);

#endif // #ifndef LEVEL_SAVE_INFO_H


================================================
FILE: src/main/main_config.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../game_main.h"
#include "../graphics.h"
#include "../sound.h"
#include "../config.h"
#include "../controls.h"

#ifdef THEXTECH_ENABLE_SDL_NET
#include "main/client_methods.h"
#endif

#include "core/render.h"

#include "speedrunner.h"
#include "record.h"
#include "main/asset_pack.h"

#include <Utils/files.h>
#include <Utils/strings.h>
#include <IniProcessor/ini_processing.h>
#include <fmt_format_ne.h>
#include <AppPath/app_path.h>
#include <Logger/logger.h>


void ConfigReloadRecentEpisodes()
{
    // reload recently used episodes for the new asset pack
    std::string configPath = AppPathManager::settingsFileSTD();

    if(Files::fileExists(configPath))
    {
        IniProcessing config(configPath);

        std::string asset_pack_prefix = g_AssetPackID;
        if(!asset_pack_prefix.empty())
            asset_pack_prefix += '-';

        config.beginGroup("recent");
        config.read((asset_pack_prefix + "episode-1p").c_str(), g_recentWorld1p, std::string());
        config.read((asset_pack_prefix + "episode-2p").c_str(), g_recentWorld2p, std::string());
        config.read((asset_pack_prefix + "episode-editor").c_str(), g_recentWorldEditor, std::string());
        config.read((asset_pack_prefix + "episode-custom-intro").c_str(), g_recentWorldIntro, std::string());
        config.endGroup();

        pLogDebug("Loaded recent episodes for asset pack [id: %s] from [%s]", g_AssetPackID.c_str(), configPath.c_str());
    }
}


void OpenConfig()
{
    g_pLogGlobalSetup.logPathDefault = AppPathManager::logsDir();
    g_pLogGlobalSetup.logPathFallBack = AppPathManager::userAppDirSTD();

    int FileRelease = 0;

    std::string configPath = AppPathManager::settingsFileSTD();

    if(Files::fileExists(configPath))
    {
        IniProcessing config(configPath);

        config.beginGroup("main");
        config.read("release", FileRelease, curRelease);
        config.endGroup();

        std::string asset_pack_prefix = g_AssetPackID;
        if(!asset_pack_prefix.empty())
            asset_pack_prefix += '-';

        config.beginGroup("recent");
        config.read("asset-pack", g_recentAssetPack, std::string());
#ifdef THEXTECH_ENABLE_SDL_NET
        config.read("server", g_netplayServer, g_netplayServer);
        config.read("nickname", g_netplayNickname, std::string());
#endif
        config.read((asset_pack_prefix + "episode-1p").c_str(), g_recentWorld1p, std::string());
        config.read((asset_pack_prefix + "episode-2p").c_str(), g_recentWorld2p, std::string());
        config.read((asset_pack_prefix + "episode-editor").c_str(), g_recentWorldEditor, std::string());
        config.read((asset_pack_prefix + "episode-custom-intro").c_str(), g_recentWorldIntro, std::string());
        config.endGroup();

        config.beginGroup("logging");
        config.read("log-path", g_pLogGlobalSetup.logPathCustom, std::string());
        config.read("max-log-count", g_pLogGlobalSetup.maxFilesCount, 10);
        config.endGroup();

        g_config_game_user.Clear();
        g_config_game_user.UpdateFromIni(&config);

        g_config.log_level.set_from_default(ConfigSetLevel::set);

        g_pLogGlobalSetup.level = (PGE_LogLevel::Level)(int)(g_config_game_user.log_level.is_set() ? g_config_game_user.log_level : g_config.log_level);

        pLogDebug("Loaded config: %s", configPath.c_str());
    }
    else
    {
        pLogDebug("Writing new config on first run.");
        SaveConfig(); // Create the config file on first run
    }

}

void SaveConfig()
{
    std::string configPath = AppPathManager::settingsFileSTD();

    IniProcessing config(configPath);
    config.beginGroup("main");
    config.setValue("release", curRelease);
    config.endGroup();

    config.beginGroup("logging");
    {
        if(!g_pLogGlobalSetup.logPathCustom.empty())
            config.setValue("log-path", g_pLogGlobalSetup.logPathCustom);
        config.setValue("max-log-count", g_pLogGlobalSetup.maxFilesCount);
    }
    config.endGroup();

    std::string asset_pack_prefix = g_AssetPackID;
    if(!asset_pack_prefix.empty())
        asset_pack_prefix += '-';

    config.beginGroup("recent");
    config.setValue("asset-pack", g_AssetPackID);
#ifdef THEXTECH_ENABLE_SDL_NET
    config.setValue("server", g_netplayServer);
    config.setValue("nickname", g_netplayNickname);
#endif
    config.setValue((asset_pack_prefix + "episode-1p").c_str(), g_recentWorld1p);
    config.setValue((asset_pack_prefix + "episode-2p").c_str(), g_recentWorld2p);
    config.setValue((asset_pack_prefix + "episode-editor").c_str(), g_recentWorldEditor);
    config.setValue((asset_pack_prefix + "episode-custom-intro").c_str(), g_recentWorldIntro);
    config.endGroup();

    g_config_game_user.SaveToIni(&config);

    config.writeIniFile();
    AppPathManager::syncFs();

    pLogDebug("Saved config: %s", configPath.c_str());
}


================================================
FILE: src/main/menu_controls.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <array>

#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_stdinc.h"
#include "../global_constants.h"
#include "../controls.h"
#include "../sound.h"
#include "../globals.h"
#include "../graphics.h"
#include "control/controls_methods.h" // to cancel keyboard's double-click fullscreen

#include "../gfx.h"
#include "../core/render.h"

#include "fontman/font_manager.h"

#include "graphics/gfx_frame.h"
#include "graphics/gfx_marquee.h"

#include "main/screen_textentry.h"

#include "main/speedrunner.h"
#include "main/menu_main.h"
#include "main/game_strings.h"

bool g_pollingInput = false;

static int s_curType = -1;
static int s_curProfile = -1;

static bool s_secondaryInput = false;

static bool s_canDelete = false;

static bool s_deleteProfileSel = false;

static Controls::ControlsClass s_profileTab = Controls::ControlsClass::None;

static std::array<MarqueeState, maxLocalPlayers> s_controller_type_marquee;
static std::array<MarqueeState, maxLocalPlayers> s_controller_profile_marquee;

static inline void s_cancelDoubleClick()
{
#ifdef KEYBOARD_H
    Controls::g_cancelDoubleClick = true;
#endif
}

// only partially refactored from the mouse and standard menu logic functions
//   (which currently duplicate part of their logic)
int menuControls_Do()
{
    if(s_curType == -1)
    {
    }
    else if(s_curProfile == -1)
    {
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        (void)type;
    }
    else if(s_profileTab == Controls::ControlsClass::None)
    {
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        Controls::InputMethodProfile* profile = type->GetProfiles()[s_curProfile];

        if(MenuCursor == 0) // Rename Profile
        {
            PlaySoundMenu(SFX_Do);
            MenuCursorCanMove = false;
            profile->Name = TextEntryScreen::Run(g_mainMenu.controlsRenameProfile, profile->Name);
            MenuCursorCanMove = false;
            return 0;
        }
        else if(MenuCursor == 1) // Delete Profile
        {
            PlaySoundMenu(SFX_PlayerDied2);
            s_deleteProfileSel = true;
            MenuCursor = 0;
            MenuCursorCanMove = false;
            return 0;
        }
        else // submenu
        {
            PlaySoundMenu(SFX_Do);
            if(MenuCursor == 2)
                s_profileTab = Controls::ControlsClass::Player;
            else if(MenuCursor == 3)
                s_profileTab = Controls::ControlsClass::Cursor;
            else if(MenuCursor == 4)
                s_profileTab = Controls::ControlsClass::Editor;
            else if(MenuCursor == 5)
                s_profileTab = Controls::ControlsClass::Hotkey;
            MenuCursor = 0;
            MenuCursorCanMove = false;
            return 0;
        }
    }
    return 0;
}

int menuControls_Mouse_Render(bool mouse, bool render)
{
    if(mouse && !SharedCursor.Move && !render && !SharedCursor.Primary)
        return 0;

    const int n_types = (int)Controls::g_InputMethodTypes.size();

    // want 680px width. if not possible, use double-line mode on settable option screens
    int width;
    if(XRender::TargetW < 640)
        width = XRender::TargetW - 16 - XRender::TargetOverscanX * 2;
    else if(XRender::TargetW < 720)
        width = XRender::TargetW - 40 - XRender::TargetOverscanX * 2;
    else
        width = 680;

    // want up to 15 lines of text
    int line = (XRender::TargetH - 60) / 15;
    line -= line & 1;
    if(line > 30)
        line = 30;

    // check for Chinese and Korean languages
    int min_line_size = FontManager::getMetricsValue(FontManager::Metrics_MenuMinLineHeight, CurrentLanguage); // 18;

    // (okay if we don't get 15 lines)
    int max_line = 15;
    if(line < min_line_size)
    {
        line = min_line_size;
        max_line = (int)XRender::TargetH / line;

        // fix some strange offscreen issues
        if(min_line_size > 18)
            max_line--;
    }

    // horizontal start of the menu
    int sX = XRender::TargetW/2 - width/2;
    sX -= sX & 1;
    // vertical start of the menu
    int sY = XRender::TargetH/2 - (line*max_line)/2;
    sY -= sY & 1;

    // render the background
    if(render)
        DrawSimpleFrame(sX, sY - (line - 18) - 4, width, line * max_line + (line - 18) + 8, {0, 0, 0, 127}, {255, 255, 255, 127}, {0, 0, 0, 127});

    // rendering of profile deletion screen
    if(s_deleteProfileSel)
    {
        if(render)
        {
            SuperPrintScreenCenter(g_mainMenu.controlsReallyDeleteProfile, 3, sY);
        }

        if(s_curType < 0 || s_curType >= n_types)
        {
            return 0;
        }
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_profiles = (int)type->GetProfiles().size();

        if(s_curProfile < 0 || s_curProfile >= n_profiles)
        {
            return 0;
        }

        Controls::InputMethodProfile* profile = type->GetProfiles()[s_curProfile];

        if(profile && render)
            SuperPrintScreenCenter(profile->Name, 3, sY+line);

        if(render)
        {
            SuperPrint(g_mainMenu.wordNo, 3, sX+width/4, sY+line*3);
            if(MenuCursor == 0)
                XRender::renderTextureBasic(sX+width/4-24, sY+line*3, GFX.MCursor[0]);
            SuperPrint(g_mainMenu.wordYes, 3, sX+width/4, sY+line*4);
            if(MenuCursor == 1)
                XRender::renderTextureBasic(sX+width/4-24, sY+line*4, GFX.MCursor[0]);
        }

        if(mouse)
        {
            // collision and click handling for "NO"
            int menuLen = (int)g_mainMenu.wordNo.size() * 18;
            if(SharedCursor.X >= sX+width/4 && SharedCursor.X <= sX+width/4 + menuLen
                && SharedCursor.Y >= sY+line*3 && SharedCursor.Y <= sY+line*3 + 16)
            {
                if(MenuCursor != 0)
                {
                    PlaySoundMenu(SFX_Slide);
                    MenuCursor = 0;
                }

                if(MenuMouseRelease && SharedCursor.Primary)
                {
                    s_cancelDoubleClick();
                    PlaySoundMenu(SFX_Slide);
                    s_deleteProfileSel = false;
                    MenuCursor = 1; // Delete Profile
                    MenuMouseRelease = false;
                }
            }

            // collision and click handling for "YES"
            menuLen = (int)g_mainMenu.wordYes.size() * 18;
            if(SharedCursor.X >= sX+width/4 && SharedCursor.X <= sX+width/4 + menuLen
                && SharedCursor.Y >= sY+line*4 && SharedCursor.Y <= sY+line*4 + 16)
            {
                if(MenuCursor != 1)
                {
                    PlaySoundMenu(SFX_Slide);
                    MenuCursor = 1;
                }

                if(MenuMouseRelease && SharedCursor.Primary)
                {
                    s_cancelDoubleClick();
                    if(profile && type->DeleteProfile(profile, Controls::g_InputMethods))
                    {
                        PlaySoundMenu(SFX_VillainKilled);
                        s_deleteProfileSel = false;
                        MenuCursor = s_curProfile;
                        s_curProfile = -1;
                    }
                    else
                    {
                        PlaySoundMenu(SFX_BlockHit);
                    }
                    MenuMouseRelease = false;
                }
            }
        }

        return 0;
    }

    // rendering / mouse for the main controls screen
    if(s_curType == -1)
    {
        if(render)
            SuperPrintScreenCenter(g_mainMenu.controlsTitle, 3, sY);

        // render the types at the top of the screen and the currently connected devices at the bottom
        if(render)
            SuperPrint(g_mainMenu.controlsDeviceTypes, 3, sX+16, sY+2*line);

        int scroll_start = 0;
        int scroll_end = n_types;

        if(max_line - 9 < n_types)
        {
            int scroll_n = max_line - 10;
            scroll_start = MenuCursor - scroll_n/2;
            scroll_end = scroll_start + scroll_n;
            if(scroll_start < 0)
            {
                scroll_start = 0;
                scroll_end = scroll_start + scroll_n;
            }
            if(scroll_end > n_types)
            {
                scroll_end = n_types;
                scroll_start = scroll_end - scroll_n;
            }
        }

        // render the scroll indicators
        if(render)
        {
            if(scroll_start > 0)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[1].w / 2, sY + 3*line - GFX.MCursor[1].h, GFX.MCursor[1]);

            if(scroll_end < n_types)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[2].w / 2, sY + (3+scroll_end-scroll_start)*line - line + 18, GFX.MCursor[2]);
        }

        // render the menu items
        for(int i = 0; i < scroll_end - scroll_start; i++)
        {
            if(render)
            {
                bool in_use = false;

                for(Controls::InputMethod* method : Controls::g_InputMethods)
                {
                    if(!method)
                        continue;
                    if(method->Type == Controls::g_InputMethodTypes[scroll_start + i])
                    {
                        in_use = true;
                        break;
                    }
                }

                if(in_use)
                    SuperPrint(Controls::g_InputMethodTypes[scroll_start + i]->LocalName() + " " + g_mainMenu.controlsInUse, 5, sX+48, sY+(3+i)*line);
                else
                    SuperPrint(Controls::g_InputMethodTypes[scroll_start + i]->LocalName(), 5, sX+48, sY+(3+i)*line);
                if(MenuCursor == scroll_start + i)
                    XRender::renderTextureBasic(sX + 24, sY+(3+i)*line, GFX.MCursor[0]);
            }
            int item_width = (int)Controls::g_InputMethodTypes[scroll_start + i]->LocalName().size() * 18;
            if(mouse && SharedCursor.X >= sX+48 && SharedCursor.X <= sX+48 + item_width
                && SharedCursor.Y >= sY+(3+i)*line && SharedCursor.Y <= sY+(3+i)*line + 16)
            {
                if(MenuCursor != scroll_start + i)
                {
                    PlaySoundMenu(SFX_Slide);
                    MenuCursor = scroll_start + i;
                }

                if(MenuMouseRelease && SharedCursor.Primary)
                {
                    s_cancelDoubleClick();
                    PlaySoundMenu(SFX_Do);
                    s_curType = MenuCursor;
                    MenuCursor = 0;
                    MenuMouseRelease = false;
                }
            }
        }

        // render the players
        if(render && s_curType == -1 && Controls::g_InputMethods.size() > 0)
        {
            SuperPrintScreenCenter(g_mainMenu.controlsConnected, 3, sY+(max_line-5)*line);

            int p_width = (width - 8) / Controls::g_InputMethods.size();

            for(size_t p = 0; p < Controls::g_InputMethods.size() && p < maxLocalPlayers; p++)
            {
                if(!Controls::g_InputMethods[p])
                    continue;

                int lX = sX + 4 + (p_width * (int)p);
                int cX = lX + p_width / 2;

                MarqueeSpec print_spec = MarqueeSpec(p_width - 8, 10, 16, 32, 0);

                s_controller_type_marquee[p].advance(print_spec);
                SuperPrintMarquee(Controls::g_InputMethods[p]->Name, 5, lX, sY+(max_line-4)*line, print_spec, s_controller_type_marquee[p]);

                RenderControls(p, cX - 76 / 2, sY + (max_line - 3) * line - (line - 18) / 2 + 2, 76, 30, false, 255, true);

                // should never be null
                if(Controls::g_InputMethods[p]->Profile != nullptr)
                {
                    s_controller_profile_marquee[p].advance(print_spec);
                    SuperPrintMarquee(Controls::g_InputMethods[p]->Profile->Name, 5, lX, sY+(max_line-3)*line + 34, print_spec, s_controller_profile_marquee[p]);
                }
            }
        }
    }
    // rendering / mouse for the input method type screens
    else if(s_curProfile == -1)
    {
        bool double_line = false;
        if(width < 500)
            double_line = true;

        // should never happen
        if(s_curType < 0 || s_curType >= n_types)
        {
            SDL_assert_release(false); // invalid state in controls settings
            PlaySoundMenu(SFX_BlockHit);
            s_curType = -1;
            MenuCursorCanMove = false;
            return 0;
        }
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_options = (int)type->GetOptionCount();
        std::vector<Controls::InputMethodProfile*> profiles = type->GetProfiles();
        const int n_profiles = (int)profiles.size();

        if(render)
        {
            SuperPrintScreenCenter(type->Name, 3, sY);

            bool in_use = false;

            for(Controls::InputMethod* method : Controls::g_InputMethods)
            {
                if(!method)
                    continue;
                if(method->Type == type)
                {
                    in_use = true;
                    break;
                }
            }

            if(in_use)
                SuperPrintScreenCenter(g_mainMenu.controlsInUse, 3, sY+16);
            else
                SuperPrintScreenCenter(g_mainMenu.controlsNotInUse, 3, sY+16);
        }

        // first come the profiles, and then the type options.
        // the scrolling is determined here

        int avail_lines = max_line - 2;

        int total_lines;
        if(double_line)
            total_lines = 1 + (n_profiles+1) + 2 + n_options*2;
        else
            total_lines = 1 + (n_profiles+1) + 2 + n_options;

        int cur_line;
        if(MenuCursor <= n_profiles)
            cur_line = 1 + MenuCursor;
        else if(double_line)
            cur_line = 1 + (n_profiles+1) + 2 + (MenuCursor-(n_profiles+1))*2;
        else
            cur_line = 1 + (n_profiles+1) + 2 + (MenuCursor-(n_profiles+1));

        // handle scrolling
        int scroll_start = 0;
        int scroll_end = total_lines;

        if(avail_lines < total_lines)
        {
            avail_lines --; // for scroll indicator

            scroll_start = cur_line - avail_lines/2;
            scroll_end = scroll_start + avail_lines;
            if(scroll_start < 0)
            {
                scroll_start = 0;
                scroll_end = scroll_start + avail_lines;
            }
            if(scroll_end > total_lines)
            {
                scroll_end = total_lines;
                scroll_start = scroll_end - avail_lines;
            }
        }

        // overall title and "PROFILES" come before the profiles
        int start_y = sY + 2*line;

        // render the scroll indicators
        if(render)
        {
            if(scroll_start > 0)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[1].w / 2, start_y - GFX.MCursor[1].h, GFX.MCursor[1]);

            if(scroll_end < total_lines)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[2].w / 2, start_y + (avail_lines)*line - line + 18, GFX.MCursor[2]);
        }

        if(render && 0 >= scroll_start && 0 < scroll_end)
            SuperPrint(g_mainMenu.wordProfiles, 3, sX+16, start_y + (0-scroll_start)*line);

        for(int i = 0; i <= n_profiles; i++)
        {
            if(i + 1 >= scroll_start && i + 1 < scroll_end)
            {
                if(render)
                {
                    bool in_use = false;

                    for(Controls::InputMethod* method : Controls::g_InputMethods)
                    {
                        if(!method || i == n_profiles)
                            continue;
                        if(method->Profile == profiles[i])
                        {
                            in_use = true;
                            break;
                        }
                    }

                    if(i == n_profiles)
                        SuperPrint(g_mainMenu.controlsNewProfile, 5, sX+48, start_y + (i + 1-scroll_start)*line);
                    else if(in_use)
                        SuperPrint(profiles[i]->Name + " " + g_mainMenu.controlsInUse, 5, sX+48, start_y + (i + 1-scroll_start)*line);
                    else
                        SuperPrint(profiles[i]->Name, 5, sX+48, start_y + (i + 1-scroll_start)*line);
                    if(MenuCursor == i)
                        XRender::renderTextureBasic(sX + 24, start_y + (i + 1-scroll_start)*line, GFX.MCursor[0]);
                }
                if(mouse)
                {
                    int item_width;
                    if(i == n_profiles)
                        item_width = (int)g_mainMenu.controlsNewProfile.size() * 18;
                    else
                        item_width = (int)profiles[i]->Name.size() * 18;

                    if(SharedCursor.X >= sX + 48 && SharedCursor.X <= sX + 48 + item_width
                        && SharedCursor.Y >= start_y + (i + 1 - scroll_start)*line && SharedCursor.Y <= start_y + (i + 1 - scroll_start) * line + 16)
                    {
                        if(MenuCursor != i)
                        {
                            PlaySoundMenu(SFX_Slide);
                            MenuCursor = i;
                        }

                        if(MenuMouseRelease && SharedCursor.Primary)
                        {
                            s_cancelDoubleClick();
                            if(MenuCursor != n_profiles)
                            {
                                PlaySoundMenu(SFX_Do);
                                s_curProfile = MenuCursor;
                                MenuCursor = 0;
                            }
                            else
                            {
                                PlaySoundMenu(SFX_DropItem);
                                type->AddProfile();
                            }
                            MenuMouseRelease = false;
                        }
                    }
                }
            }
        }

        // "PROFILE", the profiles, "NEW PROFILE", a blank line, and "OPTIONS" come before the options
        int o_base = (1+n_profiles+1+2);

        if(n_options && render && o_base - 1 >= scroll_start && o_base - 1 < scroll_end)
        {
            SuperPrint(g_mainMenu.mainOptions, 3, sX+16, start_y + (o_base - 1 - scroll_start)*line);
        }

        for(int i = 0; i < n_options; i++)
        {
            const char* name = type->GetOptionName(i);
            const char* value = type->GetOptionValue(i);
            if(double_line)
            {
                if(render)
                {
                    if(o_base + 2*i >= scroll_start && o_base + 2*i + 1 < scroll_end)
                    {
                        if(name)
                            SuperPrint(name, 5, sX+24, start_y + (o_base + 2*i - scroll_start)*line);
                        if(value)
                            SuperPrint(value, 3, sX+48, start_y + (o_base + 2*i + 1 - scroll_start)*line);
                        if(MenuCursor - n_profiles - 1 == i)
                            XRender::renderTextureBasic(sX + 24, start_y + (o_base + 2*i + 1 - scroll_start)*line, GFX.MCursor[0]);
                    }
                }
                if(mouse && value)
                {
                    int item_width = SuperTextPixLen(value, 3);

                    if(SharedCursor.X >= sX+48 && SharedCursor.X <= sX+48 + item_width
                        && SharedCursor.Y >= start_y + (o_base + 2*i + 1 - scroll_start)*line && SharedCursor.Y <= start_y + (o_base + 2*i + 1 - scroll_start)*line + 16)
                    {
                        if(MenuCursor != i + n_profiles + 1)
                        {
                            PlaySoundMenu(SFX_Slide);
                            MenuCursor = i + n_profiles + 1;
                        }

                        if(MenuMouseRelease && SharedCursor.Primary)
                        {
                            s_cancelDoubleClick();
                            if(type->OptionChange(i))
                                PlaySoundMenu(SFX_Do);
                            else
                                PlaySoundMenu(SFX_BlockHit);
                            MenuMouseRelease = false;
                        }
                    }
                }
            }
            else
            {
                if(render)
                {
                    if(o_base + i >= scroll_start && o_base + i < scroll_end)
                    {
                        if(name)
                            SuperPrint(name, 5, sX+48, start_y + (o_base + i - scroll_start)*line);
                        if(value)
                            SuperPrintRightAlign(value, 3, sX+width-32, start_y + (o_base + i - scroll_start)*line);
                        if(MenuCursor - n_profiles - 1 == i)
                            XRender::renderTextureBasic(sX + 24, start_y + (o_base + i - scroll_start)*line, GFX.MCursor[0]);
                    }
                }
                if(mouse)
                {
                    if(SharedCursor.X >= sX+48 && SharedCursor.X <= sX+width-32
                        && SharedCursor.Y >= start_y + (o_base + i - scroll_start)*line && SharedCursor.Y <= start_y + (o_base + i - scroll_start)*line + 16)
                    {
                        if(MenuCursor != i + n_profiles + 1)
                        {
                            PlaySoundMenu(SFX_Slide);
                            MenuCursor = i + n_profiles + 1;
                        }

                        if(MenuMouseRelease && SharedCursor.Primary)
                        {
                            s_cancelDoubleClick();
                            if(type->OptionChange(i))
                                PlaySoundMenu(SFX_Do);
                            else
                                PlaySoundMenu(SFX_BlockHit);
                            MenuMouseRelease = false;
                        }
                    }
                }
            }
        }

    }
    // rendering / mouse for the input method profile main screen
    else if(s_profileTab == Controls::ControlsClass::None)
    {
        bool double_line = false;
        if(width < 680)
        {
            double_line = true;
            if(line > min_line_size + 2)
            {
                max_line = max_line * line / (min_line_size + 2);
                line = (min_line_size + 2);
            }
        }
        // should never happen
        if(s_curType < 0 || s_curType >= n_types)
        {
            return 0;
        }
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_profiles = (int)type->GetProfiles().size();

        if(s_curProfile < 0 || s_curProfile >= n_profiles)
        {
            return 0;
        }

        Controls::InputMethodProfile* profile = type->GetProfiles()[s_curProfile];
        const int n_options = (int)profile->GetOptionCount();
        const int n_stock = 6;

        if(render)
        {
            SuperPrintScreenCenter(profile->Name, 3, sY);

            bool in_use = false;

            for(Controls::InputMethod* method : Controls::g_InputMethods)
            {
                if(!method)
                    continue;
                if(method->Profile == profile)
                    in_use = true;
            }

            if(in_use)
                SuperPrintScreenCenter(g_mainMenu.controlsInUse, 3, sY+16);
            else
                SuperPrintScreenCenter(g_mainMenu.controlsNotInUse, 3, sY+16);
        }

        // first come the stock options, then the profile options.
        // the scrolling is determined here

        int avail_lines = max_line - 2;

        int total_lines;
        if(double_line)
            total_lines = n_stock + 1 + n_options*2;
        else
            total_lines = n_stock + 1 + n_options;
        if(n_options)
            total_lines += 2;

        int cur_line;
        if(double_line && MenuCursor > n_stock)
            cur_line = n_stock + (MenuCursor-n_stock)*2;
        else
            cur_line = MenuCursor;
        if(MenuCursor >= 3)
            cur_line += 1;
        if(MenuCursor >= n_stock)
            cur_line += 1;

        // handle scrolling
        int scroll_start = 0;
        int scroll_end = total_lines;

        if(avail_lines < total_lines)
        {
            avail_lines --; // for scroll indicator

            scroll_start = cur_line - avail_lines/2;
            scroll_end = scroll_start + avail_lines;
            if(scroll_start < 0)
            {
                scroll_start = 0;
                scroll_end = scroll_start + avail_lines;
            }
            if(scroll_end > total_lines)
            {
                scroll_end = total_lines;
                scroll_start = scroll_end - avail_lines;
            }
        }

        // overall title comes before the stock options
        int start_y = sY + 1*line;

        // render the scroll indicators
        if(render)
        {
            if(scroll_start > 0)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[1].w / 2, start_y - GFX.MCursor[1].h, GFX.MCursor[1]);

            if(scroll_end < total_lines)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[2].w / 2, start_y + (avail_lines)*line - line + 18, GFX.MCursor[2]);
        }

        for(int i = 0; i < n_stock; i++)
        {
            const char* name;
            if(i == 0) // Rename profile
                name = g_mainMenu.controlsRenameProfile.c_str();
            else if(i == 1) // Delete profile
                name = g_mainMenu.controlsDeleteProfile.c_str();
            else if(i == 2) // Player
                name = g_mainMenu.controlsPlayerControls.c_str();
            else if(i == 3) // Cursor
                name = g_mainMenu.controlsCursorControls.c_str();
            else if(i == 4) // Editor
                name = g_mainMenu.controlsEditorControls.c_str();
            else if(i == 5) // Hotkeys
                name = g_mainMenu.controlsHotkeys.c_str();
            else
                name = "";

            int s; // shift
            if(i >= 2)
                s = 2;
            else
                s = 1;

            if(render && i == 2 && i+s-2 >= scroll_start && i+s-2 < scroll_end)
                SuperPrint(g_mainMenu.controlsTitle, 3, sX+16, start_y+(i+s - 1 - scroll_start)*line);

            if(i+s-1 < scroll_start || i+s-1 >= scroll_end)
                continue;

            if(render)
            {
                SuperPrint(name, 5, sX+48, start_y+(i+s - scroll_start)*line);
                if(MenuCursor == i)
                    XRender::renderTextureBasic(sX + 24, start_y + (i+s - scroll_start)*line, GFX.MCursor[0]);
            }
            if(mouse)
            {
                int item_width = SuperTextPixLen(name, 3);

                if(SharedCursor.X >= sX+48 && SharedCursor.X <= sX+48 + item_width
                    && SharedCursor.Y >= start_y + (i+s-scroll_start)*line && SharedCursor.Y <= start_y + (i+s-scroll_start)*line + 16)
                {
                    if(MenuCursor != i)
                    {
                        PlaySoundMenu(SFX_Slide);
                        MenuCursor = i;
                    }

                    if(MenuMouseRelease && SharedCursor.Primary)
                    {
                        s_cancelDoubleClick();
                        MenuMouseRelease = false;

                        menuControls_Do();
                    }
                }
            }
        }

        // overall title, stock options, and "OPTIONS" come before the options
        int o_base = n_stock+3;

        if(n_options && render && o_base - 1 >= scroll_start && o_base - 1 < scroll_end)
        {
            SuperPrint(g_mainMenu.mainOptions, 3, sX+16, start_y + (o_base - 1 - scroll_start)*line);
        }

        for(int i = 0; i < n_options; i++)
        {
            const char* name = profile->GetOptionName(i);
            const char* value = profile->GetOptionValue(i);
            if(double_line)
            {
                if(render)
                {
                    if(o_base + 2*i >= scroll_start && o_base + 2*i < scroll_end && name)
                        SuperPrint(name, 5, sX+24, start_y + (o_base + 2*i - scroll_start)*line, {160, 160, 255});
                    if(o_base + 2*i + 1 >= scroll_start && o_base + 2*i + 1 < scroll_end)
                    {
                        if(value)
                            SuperPrint(value, 3, sX+48, start_y + (o_base + 2*i + 1 - scroll_start)*line);
                        if(MenuCursor - n_stock == i)
                            XRender::renderTextureBasic(sX + 24, start_y + (o_base + 2*i + 1 - scroll_start)*line, GFX.MCursor[0]);
                    }
                }

                if(mouse && value)
                {
                    int item_width = SuperTextPixLen(value, 3);

                    if(SharedCursor.X >= sX+48 && SharedCursor.X <= sX+48 + item_width
                        && SharedCursor.Y >= start_y + (o_base + 2*i + 1 - scroll_start)*line && SharedCursor.Y <= start_y + (o_base + 2*i + 1 - scroll_start)*line + 16)
                    {
                        if(MenuCursor != i + n_stock)
                        {
                            PlaySoundMenu(SFX_Slide);
                            MenuCursor = i + n_stock;
                        }

                        if(MenuMouseRelease && SharedCursor.Primary)
                        {
                            s_cancelDoubleClick();
                            if(type->OptionChange(i))
                                PlaySoundMenu(SFX_Do);
                            else
                                PlaySoundMenu(SFX_BlockHit);
                            MenuMouseRelease = false;
                        }
                    }
                }
            }
            else
            {
                if(render)
                {
                    if(o_base + i >= scroll_start && o_base + i < scroll_end)
                    {
                        if(name)
                            SuperPrint(name, 5, sX+48, start_y + (o_base + i - scroll_start)*line);
                        if(value)
                            SuperPrintRightAlign(value, 3, sX+width-32, start_y + (o_base + i - scroll_start)*line);
                        if(MenuCursor - n_stock == i)
                            XRender::renderTextureBasic(sX + 24, start_y + (o_base + i - scroll_start)*line, GFX.MCursor[0]);
                    }
                }

                if(mouse)
                {
                    if(SharedCursor.X >= sX+48 && SharedCursor.X <= sX+width-32
                        && SharedCursor.Y >= start_y + (o_base + i - scroll_start)*line && SharedCursor.Y <= start_y + (o_base + i - scroll_start)*line + 16)
                    {
                        if(MenuCursor != i + n_stock)
                        {
                            PlaySoundMenu(SFX_Slide);
                            MenuCursor = i + n_stock;
                        }

                        if(MenuMouseRelease && SharedCursor.Primary)
                        {
                            s_cancelDoubleClick();
                            if(profile->OptionChange(i))
                                PlaySoundMenu(SFX_Do);
                            else
                                PlaySoundMenu(SFX_BlockHit);
                            MenuMouseRelease = false;
                        }
                    }
                }
            }
        }
    }
    // rendering / mouse for the input method profile sub screens
    else
    {
        bool double_line = false;
        if(width < 680)
        {
            double_line = true;
            if(line > min_line_size + 2)
            {
                max_line = max_line * line / (min_line_size + 2);
                line = (min_line_size + 2);
            }
        }
        // should never happen
        if(s_curType < 0 || s_curType >= n_types)
        {
            return 0;
        }
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_profiles = (int)type->GetProfiles().size();

        if(s_curProfile < 0 || s_curProfile >= n_profiles)
        {
            return 0;
        }

        Controls::InputMethodProfile* profile = type->GetProfiles()[s_curProfile];

        int n_buttons;
        if(s_profileTab == Controls::ControlsClass::Player)
            n_buttons = Controls::PlayerControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Cursor)
            n_buttons = Controls::CursorControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Editor)
            n_buttons = Controls::EditorControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Hotkey)
            n_buttons = Controls::Hotkeys::n_buttons;
        else
        {
            // shouldn't happen
            s_profileTab = Controls::ControlsClass::None;
            return 0;
        }

        if(render)
        {
            SuperPrintScreenCenter(profile->Name, 3, sY);

            bool in_use = false;

            for(Controls::InputMethod* method : Controls::g_InputMethods)
            {
                if(!method)
                    continue;
                if(method->Profile == profile)
                    in_use = true;
            }

            if(in_use)
                SuperPrintScreenCenter(g_mainMenu.controlsInUse, 3, sY+16);
            else
                SuperPrintScreenCenter(g_mainMenu.controlsNotInUse, 3, sY+16);
        }

        // the buttons are the only thing now.
        // work out scrolling here

        int avail_lines = max_line - 3;

        int total_lines;
        if(double_line)
            total_lines = 1 + n_buttons*2;
        else
            total_lines = 1 + n_buttons;

        int cur_line;
        if(double_line)
            cur_line = MenuCursor*2;
        else
            cur_line = MenuCursor;

        // handle scrolling
        int scroll_start = 0;
        int scroll_end = total_lines;

        if(avail_lines < total_lines)
        {
            avail_lines --; // for scroll indicator

            scroll_start = cur_line - avail_lines/2;
            scroll_end = scroll_start + avail_lines;
            if(scroll_start < 0)
            {
                scroll_start = 0;
                scroll_end = scroll_start + avail_lines;
            }
            if(scroll_end > total_lines)
            {
                scroll_end = total_lines;
                scroll_start = scroll_end - avail_lines;
            }
        }

        // overall title and "BUTTONS" come before the buttons
        int start_y = sY + 2*line;
        int b_base = 1;

        // render the scroll indicators
        if(render)
        {
            if(scroll_start > 0)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[1].w / 2, start_y - GFX.MCursor[1].h, GFX.MCursor[1]);

            if(scroll_end < total_lines)
                XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[2].w / 2, start_y + (avail_lines)*line - line + 18, GFX.MCursor[2]);
        }

        // render the word "BUTTONS"
        if(render && scroll_start == 0)
        {
            SuperPrint(g_mainMenu.wordButtons, 3, sX+16, start_y);
            SuperPrintRightAlign(g_mainMenu.controlsDeleteKey, 3, sX+width-16, start_y);
        }

        for(int i = 0; i < n_buttons; i++)
        {
            int label_row, value_row, label_x, left_value_x, right_value_x;
            XTColor label_color;

            if(double_line)
            {
                label_color = {160, 160, 255};

                label_row = b_base + (2 * i) - scroll_start;
                value_row = label_row + 1;

                label_x = sX + 24;
                left_value_x = sX + 48;
                right_value_x = sX + 48 + ((width - 48) / 2);
            }
            else
            {
                label_row = b_base + i - scroll_start;
                value_row = label_row;

                label_x = sX + 48;
                left_value_x = sX + width - 420;
                right_value_x = sX + width - 210;
            }

            if(render && label_row >= 0 && label_row < avail_lines)
            {
                const char* name = nullptr;
                if(s_profileTab == Controls::ControlsClass::Player)
                    name = Controls::PlayerControls::GetButtonName_UI(i);
                else if(s_profileTab == Controls::ControlsClass::Cursor)
                    name = Controls::CursorControls::GetButtonName_UI(i);
                else if(s_profileTab == Controls::ControlsClass::Editor)
                    name = Controls::EditorControls::GetButtonName_UI(i);
                else if(s_profileTab == Controls::ControlsClass::Hotkey)
                    name = Controls::Hotkeys::GetButtonName_UI(i);

                SuperPrint(name, 5, label_x, start_y + label_row * line, label_color);

                if(MenuCursor == i && !s_secondaryInput && g_pollingInput)
                    SuperPrint("...", 3, left_value_x, start_y + value_row * line);
                else
                    SuperPrint(profile->NamePrimaryButton(s_profileTab, i), 3, left_value_x, start_y + value_row * line);

                if(MenuCursor == i && s_secondaryInput && g_pollingInput)
                    SuperPrint("...", 3, right_value_x, start_y + value_row * line);
                else
                    SuperPrint(profile->NameSecondaryButton(s_profileTab, i), 3, right_value_x, start_y + value_row * line);

                if(MenuCursor == i)
                {
                    if(!s_secondaryInput)
                        XRender::renderTextureBasic(left_value_x - 24, start_y + value_row * line, GFX.MCursor[0]);
                    else
                        XRender::renderTextureBasic(right_value_x - 24, start_y + value_row * line, GFX.MCursor[0]);
                }
            }

            if(mouse && !g_pollingInput && SharedCursor.Y >= start_y + value_row * line && SharedCursor.Y <= start_y + value_row * line + 16)
            {
                int primary_width = SuperTextPixLen(profile->NamePrimaryButton(s_profileTab, i), 3);
                int secondary_width = SuperTextPixLen(profile->NameSecondaryButton(s_profileTab, i), 3);

                if(primary_width < 72)
                    primary_width = 72;
                if(secondary_width < 72)
                    secondary_width = 72;

                if(SharedCursor.X >= left_value_x && SharedCursor.X <= left_value_x + primary_width)
                {
                    if(MenuCursor != i || s_secondaryInput)
                    {
                        PlaySoundMenu(SFX_Slide);
                        MenuCursor = i;
                        s_secondaryInput = false;
                    }

                    if(MenuMouseRelease && SharedCursor.Primary)
                    {
                        s_cancelDoubleClick();
                        PlaySoundMenu(SFX_PSwitch);
                        g_pollingInput = true;
                        MenuCursorCanMove = false;
                        MenuMouseRelease = false;
                        return 0;
                    }
                }

                if(SharedCursor.X >= right_value_x && SharedCursor.X <= right_value_x + secondary_width)
                {
                    if(MenuCursor != i || !s_secondaryInput)
                    {
                        PlaySoundMenu(SFX_Slide);
                        MenuCursor = i;
                        s_secondaryInput = true;
                    }

                    if(MenuMouseRelease && SharedCursor.Primary)
                    {
                        s_cancelDoubleClick();
                        PlaySoundMenu(SFX_PSwitch);
                        g_pollingInput = true;
                        MenuCursorCanMove = false;
                        MenuMouseRelease = false;
                        return 0;
                    }
                }
            }
        }
    }

    if(mouse && (SharedCursor.Primary || SharedCursor.Secondary))
        MenuMouseRelease = false;

    return 0;
}

int menuControls_MouseLogic()
{
    return menuControls_Mouse_Render(true, false);
}

int menuControls_Logic()
{
    // allow input methods to join so long as not currently changing a profile
    if(!g_pollingInput && GameMenu)
        Controls::PollInputMethod();

    const int n_types = (int)Controls::g_InputMethodTypes.size();

    MenuControls_t menuControls = Controls::GetMenuControls();

    if(g_pollingInput)
    {
        // should never happen
        if(s_curType < 0 || s_curType >= n_types)
        {
            g_pollingInput = false;
            return 0;
        }

        const int n_profiles = (int)Controls::g_InputMethodTypes[s_curType]->GetProfiles().size();

        if(s_curProfile < 0 || s_curProfile >= n_profiles)
        {
            g_pollingInput = false;
            return 0;
        }

        Controls::InputMethodProfile* profile = Controls::g_InputMethodTypes[s_curType]->GetProfiles()[s_curProfile];

        int n_buttons;
        if(s_profileTab == Controls::ControlsClass::Player)
            n_buttons = Controls::PlayerControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Cursor)
            n_buttons = Controls::CursorControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Editor)
            n_buttons = Controls::EditorControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Hotkey)
            n_buttons = Controls::Hotkeys::n_buttons;
        else
            n_buttons = 0;

        if(MenuCursor < 0 || MenuCursor >= n_buttons)
        {
            g_pollingInput = false;
            return 0;
        }

        if((!s_secondaryInput && profile->PollPrimaryButton(s_profileTab, MenuCursor))
            || (s_secondaryInput && profile->PollSecondaryButton(s_profileTab, MenuCursor)))
        {
            g_pollingInput = false;
            MenuCursorCanMove = false;
            s_canDelete = false;
            Controls::g_disallowHotkeys = true;
            PlaySoundMenu(SFX_PSwitch);
            return 0;
        }

        if(MenuCursorCanMove && menuControls.Back)
        {
            g_pollingInput = false;
            MenuCursorCanMove = false;
            s_canDelete = false;
            PlaySoundMenu(SFX_Slide);
            return 0;
        }

        return 0;
    }

    menuControls.Back |= (SharedCursor.Secondary && MenuMouseRelease);

    if(menuControls.Back && menuControls.Do)
        menuControls.Do = false;

    if(menuControls.Erase && s_canDelete)
        s_canDelete = false;
    else if(menuControls.Erase)
        menuControls.Erase = false;
    else
        s_canDelete = true;

    // logic for the profile deletion screen
    if(s_deleteProfileSel)
    {
        // keep things in range
        while(MenuCursor < 0)
            MenuCursor += 2;
        while(MenuCursor >= 2)
            MenuCursor -= 2;

        if(!MenuCursorCanMove)
            return 0;

        if(s_curType < 0 || s_curType >= n_types)
        {
            s_deleteProfileSel = false;
            return 0;
        }
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_profiles = (int)type->GetProfiles().size();

        if(s_curProfile < 0 || s_curProfile >= n_profiles)
        {
            s_deleteProfileSel = false;
            return 0;
        }

        Controls::InputMethodProfile* profile = type->GetProfiles()[s_curProfile];

        if(menuControls.Back || (menuControls.Do && MenuCursor == 0))
        {
            PlaySoundMenu(SFX_Slide);
            s_deleteProfileSel = false;
            MenuCursor = 1; // Delete Profile
            MenuCursorCanMove = false;
        }
        else if(menuControls.Do && MenuCursor == 1)
        {
            if(type->DeleteProfile(profile, Controls::g_InputMethods))
            {
                PlaySoundMenu(SFX_VillainKilled);
                s_deleteProfileSel = false;
                MenuCursor = s_curProfile - 1;
                if(MenuCursor < 0)
                    MenuCursor = 0;
                s_curProfile = -1;
            }
            else
                PlaySoundMenu(SFX_BlockHit);
            MenuCursorCanMove = false;
        }
    }
    // logic for the main controls screen
    else if(s_curType == -1)
    {
        // keep things in range
        while(MenuCursor < 0)
            MenuCursor += n_types;
        while(MenuCursor >= n_types)
            MenuCursor -= n_types;

        if(!MenuCursorCanMove)
            return 0;

        // back and forward nav
        if(menuControls.Back)
        {
            PlaySoundMenu(SFX_Slide);
            MenuCursorCanMove = false;
            return -1;
        }
        if(menuControls.Do && MenuCursor >= 0 && MenuCursor < n_types)
        {
            s_curType = MenuCursor;
            MenuCursor = 0;
            PlaySoundMenu(SFX_Do);
            MenuCursorCanMove = false;
            return 0;
        }
    }
    // logic for the input method type screens
    else if(s_curProfile == -1)
    {
        // should never happen
        if(s_curType < 0 || s_curType >= n_types)
        {
            SDL_assert_release(false); // invalid state in controls settings
            PlaySoundMenu(SFX_BlockHit);
            s_curType = -1;
            MenuCursorCanMove = false;
            return 0;
        }
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_options = (int)type->GetOptionCount();
        const int n_profiles = (int)type->GetProfiles().size();

        // keep things in range
        while(MenuCursor < 0)
            MenuCursor += n_profiles + 1 + n_options;
        while(MenuCursor >= n_profiles + 1 + n_options)
            MenuCursor -= n_profiles + 1 + n_options;

        if(!MenuCursorCanMove)
            return 0;

        // backward navigation
        if(menuControls.Back)
        {
            PlaySoundMenu(SFX_Slide);
            MenuCursor = s_curType;
            s_curType = -1;
            MenuCursorCanMove = false;
            return 0;
        }

        // first come the profiles, then the type options.

        // forward navigation
        if(menuControls.Do && MenuCursor >= 0 && MenuCursor < n_profiles)
        {
            PlaySoundMenu(SFX_Do);
            s_curProfile = MenuCursor;
            s_profileTab = Controls::ControlsClass::None;
            s_secondaryInput = false;
            MenuCursor = 0;
            MenuCursorCanMove = false;
            return 0;
        }

        // creation
        if(menuControls.Do && MenuCursor == n_profiles)
        {
            PlaySoundMenu(SFX_DropItem);
            type->AddProfile();
            MenuCursorCanMove = false;
            return 0;
        }

        // options logic
        if(MenuCursor >= n_profiles + 1 && MenuCursor < n_profiles + 1 + n_options)
        {
            if(menuControls.Do)
            {
                if(type->OptionChange(MenuCursor - n_profiles - 1))
                    PlaySoundMenu(SFX_Slide);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
            else if(menuControls.Left)
            {
                if(type->OptionRotateLeft(MenuCursor - n_profiles - 1))
                    PlaySoundMenu(SFX_Slide);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
            else if(menuControls.Right)
            {
                if(type->OptionRotateRight(MenuCursor - n_profiles - 1))
                    PlaySoundMenu(SFX_Slide);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
        }
    }
    // logic for the input method profile screens
    else if(s_profileTab == Controls::ControlsClass::None)
    {
        // should never happen
        if(s_curType < 0 || s_curType >= n_types)
        {
            SDL_assert_release(false); // invalid state in controls settings
            PlaySoundMenu(SFX_BlockHit);
            s_curType = -1;
            s_curProfile = -1;
            MenuCursorCanMove = false;
            return 0;
        }
        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_profiles = (int)type->GetProfiles().size();

        if(s_curProfile < 0 || s_curProfile >= n_profiles)
        {
            SDL_assert_release(false); // invalid state in controls settings
            PlaySoundMenu(SFX_BlockHit);
            s_curProfile = -1;
            MenuCursorCanMove = false;
            return 0;
        }

        Controls::InputMethodProfile* profile = type->GetProfiles()[s_curProfile];
        const int n_stock = 6;
        const int n_options = (int)profile->GetOptionCount();

        // first come the stock options, then the profile options.

        // keep things in range
        while(MenuCursor < 0)
            MenuCursor += n_options + n_stock;
        while(MenuCursor >= n_options + n_stock)
            MenuCursor -= n_options + n_stock;

        if(!MenuCursorCanMove)
            return 0;

        // backward navigation
        if(menuControls.Back)
        {
            PlaySoundMenu(SFX_Slide);
            MenuCursor = s_curProfile;
            s_curProfile = -1;
            MenuCursorCanMove = false;
            return 0;
        }

        // stock options
        if(MenuCursor >= 0 && MenuCursor < n_stock && menuControls.Do)
        {
            return menuControls_Do();
        }

        // options logic
        if(MenuCursor >= n_stock && MenuCursor < n_stock + n_options)
        {
            if(menuControls.Do)
            {
                if(profile->OptionChange(MenuCursor - n_stock))
                    PlaySoundMenu(SFX_Slide);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
            else if(menuControls.Left)
            {
                if(profile->OptionRotateLeft(MenuCursor - n_stock))
                    PlaySoundMenu(SFX_Slide);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
            else if(menuControls.Right)
            {
                if(profile->OptionRotateRight(MenuCursor - n_stock))
                    PlaySoundMenu(SFX_Slide);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
        }
    }
    // logic for the controls submenus of the input method profile screens
    else
    {
        // should never happen
        if(s_curType < 0 || s_curType >= n_types)
        {
            SDL_assert_release(false); // invalid state in controls settings
            PlaySoundMenu(SFX_BlockHit);
            s_curType = -1;
            s_curProfile = -1;
            MenuCursorCanMove = false;
            return 0;
        }

        Controls::InputMethodType* type = Controls::g_InputMethodTypes[s_curType];
        const int n_profiles = (int)type->GetProfiles().size();

        if(s_curProfile < 0 || s_curProfile >= n_profiles)
        {
            SDL_assert_release(false); // invalid state in controls settings
            PlaySoundMenu(SFX_BlockHit);
            s_curProfile = -1;
            MenuCursorCanMove = false;
            return 0;
        }

        Controls::InputMethodProfile* profile = type->GetProfiles()[s_curProfile];

        int n_buttons;
        if(s_profileTab == Controls::ControlsClass::Player)
            n_buttons = Controls::PlayerControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Cursor)
            n_buttons = Controls::CursorControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Editor)
            n_buttons = Controls::EditorControls::n_buttons;
        else if(s_profileTab == Controls::ControlsClass::Hotkey)
            n_buttons = Controls::Hotkeys::n_buttons;
        else
        {
            // shouldn't happen
            SDL_assert_release(false);
            s_profileTab = Controls::ControlsClass::None;
            return 0;
        }

        // keep things in range
        // why didn't I write MenuCursor %= n_buttons?
        while(MenuCursor < 0)
            MenuCursor += n_buttons;

        while(MenuCursor >= n_buttons)
            MenuCursor -= n_buttons;

        if(!MenuCursorCanMove)
            return 0;

        // backward navigation
        if(menuControls.Back)
        {
            PlaySoundMenu(SFX_Slide);

            if(s_profileTab == Controls::ControlsClass::Player)
                MenuCursor = 2;
            else if(s_profileTab == Controls::ControlsClass::Cursor)
                MenuCursor = 3;
            else if(s_profileTab == Controls::ControlsClass::Editor)
                MenuCursor = 4;
            else if(s_profileTab == Controls::ControlsClass::Hotkey)
                MenuCursor = 5;

            s_profileTab = Controls::ControlsClass::None;
            s_secondaryInput = false;
            MenuCursorCanMove = false;

            return 0;
        }

        // key logic
        if(MenuCursor >= 0 && MenuCursor < n_buttons)
        {
            if(menuControls.Do)
            {
                PlaySoundMenu(SFX_PSwitch);
                g_pollingInput = true;
                MenuCursorCanMove = false;
                return 0;
            }
            else if(menuControls.Left || menuControls.Right)
            {
                PlaySoundMenu(SFX_Slide);
                s_secondaryInput = !s_secondaryInput;
                MenuCursorCanMove = false;
            }
            else if(menuControls.Erase && s_secondaryInput)
            {
                if(profile->DeleteSecondaryButton(s_profileTab, MenuCursor))
                    PlaySoundMenu(SFX_PlayerDied2);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
            else if(menuControls.Erase)
            {
                if(profile->DeletePrimaryButton(s_profileTab, MenuCursor))
                    PlaySoundMenu(SFX_PlayerDied2);
                else
                    PlaySoundMenu(SFX_BlockHit);

                MenuCursorCanMove = false;
            }
        }
    }

    return menuControls_MouseLogic();
}

void menuControls_Render()
{
    menuControls_Mouse_Render(false, true);
}


================================================
FILE: src/main/menu_controls.h
================================================
#ifndef MENU_CONTROLS_H

#define MENU_CONTROLS_H

extern bool g_pollingInput;

void menuControls_Render();
// return values:
// -1 back
// 0 continue
int menuControls_Logic();

#endif // MENU_CONTROLS_H

================================================
FILE: src/main/menu_loop.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <AppPath/app_path.h>
#include <Utils/files.h>
#include <Integrator/integrator.h>
#include <PGE_File_Formats/file_formats.h>
#include <fmt_format_ne.h>

#include "../globals.h"
#include "../game_main.h"
#include "../sound.h"
#include "../effect.h"
#include "../graphics.h"
#include "../blocks.h"
#include "../npc.h"
#include "../eff_id.h"
#include "../layers.h"
#include "../player.h"
#include "../collision.h"
#include "../controls.h"
#include "menu_main.h"
#include "game_info.h"
#include "game_globals.h"
#include "menu_controls.h"

#include "npc_traits.h"

#include "control/controls_methods.h" // to cancel keyboard's double-click fullscreen
#include "main/trees.h"
#include "script/luna/luna.h"

#include "npc/npc_queues.h"


static void updateIntroLevelActivity()
{
    Location_t tempLocation;
    bool tempBool;

    SingleCoop = 0;

    // only restore the level on the first frame that all players are dead
    static bool restore_done = false;

    bool any_living = CheckLiving();
    if(!any_living && !restore_done)
    {
        ShowLayer(LAYER_DESTROYED_BLOCKS);

        For(A, 1, numNPCs)
        {
            if(NPC[A].DefaultType == 0)
            {
                if(NPC[A].TimeLeft > 10) NPC[A].TimeLeft = 10;
            }
        }

        restore_done = true;
    }
    else if(any_living)
    {
        restore_done = false;
    }

    For(A, 1, numPlayers)
    {
        Player_t &p = Player[A];
        if(p.TimeToLive > 0)
        {
            p.TimeToLive = 0;
            p.Dead = true;
        }

        p.Controls.Down = false;
        p.Controls.Drop = false;
        p.Controls.Right = true;
        p.Controls.Left = false;
        p.Controls.Run = true;
        p.Controls.Up = false;
        p.Controls.AltRun = false;
        p.Controls.AltJump = false;

        if(p.Jump == 0 || p.Location.Y < level[0].Y + 200)
            p.Controls.Jump = false;

        if(p.Location.SpeedX < 0.5_n)
        {
            p.Controls.Jump = true;
            if(p.Slope > 0 || p.StandingOnNPC > 0 || p.Location.SpeedY == 0)
                p.CanJump = true;
        }

        if(p.HoldingNPC == 0)
        {
            if((p.State == 3 || p.State == 6 || p.State == 7) && iRand(100) >= 90)
            {
                if(p.FireBallCD == 0 && !p.RunRelease)
                    p.Controls.Run = false;
            }

            if((p.State == 4 || p.State == 5) && p.TailCount == 0 && !p.RunRelease)
            {
                tempLocation.Width = 24;
                tempLocation.Height = 20;
                tempLocation.Y = p.Location.Y + p.Location.Height - 22;
                tempLocation.X = p.Location.X + p.Location.Width;

                for(int B : treeNPCQuery(tempLocation, SORTMODE_NONE))
                {
                    if(NPC[B].Active && !NPC[B]->IsABonus &&
                       !NPC[B]->WontHurt && NPC[B].HoldingPlayer == 0)
                    {
                        if(CheckCollision(tempLocation, NPC[B].Location))
                        {
                            p.Controls.Run = false;
                            break;
                        }
                    }
                }
            }

            if(p.StandingOnNPC > 0)
            {
                if(NPC[p.StandingOnNPC]->GrabFromTop)
                {
                    p.Controls.Down = true;
                    p.Controls.Run = true;
                    p.RunRelease = true;
                }
            }
        }

        if(p.Character == 5)
        {
            if(p.FireBallCD == 0 && !p.RunRelease)
            {
                tempLocation.Width = 38 + p.Location.SpeedX / 2;
                tempLocation.Height = p.Location.Height - 8;
                tempLocation.Y = p.Location.Y + 4;
                tempLocation.X = p.Location.X + p.Location.Width;

                for(int B : treeNPCQuery(tempLocation, SORTMODE_NONE))
                {
                    if(NPC[B].Active && !NPC[B]->IsABonus &&
                      !NPC[B]->WontHurt && NPC[B].HoldingPlayer == 0)
                    {
                        if(CheckCollision(tempLocation, NPC[B].Location))
                        {
                            p.RunRelease = true;
                            if(NPC[B].Location.Y > p.Location.Y + p.Location.Height / 2)
                                p.Controls.Down = true;
                            break;
                        }
                    }
                }
            }

            if(p.Slope == 0 && p.StandingOnNPC == 0)
            {
                if(p.Location.SpeedY < 0)
                {
                    tempLocation.Width = 200;
                    tempLocation.Height = p.Location.Y - level[0].Y + p.Location.Height;
                    tempLocation.Y = level[0].Y;
                    tempLocation.X = p.Location.X;

                    for(int B : treeNPCQuery(tempLocation, SORTMODE_NONE))
                    {
                        if(NPC[B].Active && !NPC[B]->IsABonus &&
                           !NPC[B]->WontHurt && NPC[B].HoldingPlayer == 0)
                        {
                            if(CheckCollision(tempLocation, NPC[B].Location))
                            {
                                p.Controls.Up = true;
                                break;
                            }
                        }
                    }

                }
                else if(p.Location.SpeedY > 0)
                {
                    tempLocation.Width = 200;
                    tempLocation.Height = level[0].Height - p.Location.Y;
                    tempLocation.Y = p.Location.Y;
                    tempLocation.X = p.Location.X;

                    for(int B : treeNPCQuery(tempLocation, SORTMODE_NONE))
                    {
                        if(NPC[B].Active && !NPC[B]->IsABonus &&
                           !NPC[B]->WontHurt && NPC[B].HoldingPlayer == 0)
                        {
                            if(CheckCollision(tempLocation, NPC[B].Location))
                            {
                                p.Controls.Down = true;
                                break;
                            }
                        }
                    }
                }
            }
        }

        if(p.Location.X < -vScreen[1].X - p.Location.Width && -vScreen[1].X > level[0].X)
            p.Dead = true;

        if(p.Location.X > -vScreen[1].X + vScreen[1].Width + 200)
            p.Dead = true;

        if(p.Location.X > -vScreen[1].X + vScreen[1].Width * 0.75_n && -vScreen[1].X + vScreen[1].Width + 50 < level[0].Width)
            p.Controls.Run = false;

        if(-vScreen[1].X <= level[0].X && (p.Dead || p.TimeToLive > 0) && g_gameInfo.introMaxPlayersCount > 0)
        {
            p.ForceHold = 65;
            p.State = iRand(6) + 2;
            p.CanFly = false;
            p.CanFly2 = false;
            p.TailCount = 0;
            p.Dead = false;
            p.TimeToLive = 0;
            iRand(1); // advance the random state by one
//            p.Character = (iRand() % 5) + 1;

//            if(A >= 1 && A <= 5)
            p.Character = g_gameInfo.introCharacterNext();

            p.HeldBonus = NPCID(0);
            p.Section = 0;
            p.Mount = 0;
            p.MountType = 0;
            p.YoshiBlue = false;
            p.YoshiRed = false;
            p.YoshiYellow = false;
            p.YoshiNPC = 0;
            p.Wet = 0;
            p.WetFrame = false;
            p.YoshiPlayer = 0;
            p.Bumped = false;
            p.Bumped2 = 0;
            p.Direction = 1;
            p.Dismount = 0;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.FireBallCD = 0;
            p.ForceHold = 0;
            p.Warp = 0;
            p.WarpBackward = false;
            p.WarpCD = 0;
            p.GroundPound = false;
            p.Immune = 0;
            p.Frame = 0;
            p.Slope = 0;
            p.Slide = false;
            p.SpinJump = false;
            p.FrameCount = 0;
            p.TailCount = 0;
            p.Duck = false;
            p.GroundPound = false;
            p.Hearts = 3;

            PlayerFrame(p);

            p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
            p.Location.X = level[p.Section].X - A * 48;
            p.Location.SpeedX = Physics.PlayerRunSpeed;
            p.Location.Y = level[p.Section].Height - p.Location.Height - 33;

            do
            {
                tempBool = true;
                for(int B : treeBlockQuery(p.Location, SORTMODE_NONE))
                {
                    if(CheckCollision(p.Location, Block[B].Location))
                    {
                        p.Location.Y = Block[B].Location.Y - p.Location.Height - 0.1_n;
                        tempBool = false;
                        break;
                    }
                }
            } while(!tempBool);

            if(!UnderWater[p.Section])
            {
                if(iRand(25) == 0)
                {
                    p.Mount = 1;
                    p.MountType = iRand(3) + 1;
                    if(p.State == 1)
                    {
                        p.Location.Height = Physics.PlayerHeight[1][2];
                        p.Location.Y += -Physics.PlayerHeight[1][2] + Physics.PlayerHeight[p.Character][1];
                    }
                }
            }

            if(p.Mount == 0 && p.Character <= 2)
            {
                if(iRand(15) == 0)
                {
                    p.Mount = 3;
                    p.MountType = iRand(7) + 1;
                    p.Location.set_height_floor(Physics.PlayerHeight[2][2]);
                    p.Location.Y -= 0.01_n;
                }
            }

            p.CanFly = false;
            p.CanFly2 = false;
            p.RunCount = 0;

            if(p.Mount == 0 && p.Character != 5)
            {
                numNPCs++;
                p.HoldingNPC = numNPCs;
                p.ForceHold = 120;

                {
                    NPC_t &n = NPC[numNPCs];
                    do
                    {
                        do
                        {
                            n.Type = NPCID(iRand(286) + 1);
                        } while(n.Type == 11 || n.Type == 16 || n.Type == 18 || n.Type == 15 ||
                                n.Type == 21 || n.Type == 12 || n.Type == 13 || n.Type == 30 ||
                                n.Type == 17 || n.Type == 31 || n.Type == 32 ||
                                (n.Type >= 37 && n.Type <= 44) || n.Type == 46 || n.Type == 47 ||
                                n.Type == 50 || (n.Type >= 56 && n.Type <= 70) || n.Type == 8 ||
                                n.Type == 74 || n.Type == 51 || n.Type == 52 || n.Type == 75 ||
                                n.Type == 34 || NPCIsToad(n) || NPCIsAnExit(n) ||
                                NPCIsYoshi(n) || (n.Type >= 78 && n.Type <= 87) ||
                                n.Type == 91 || n.Type == 93 || (n.Type >= 104 && n.Type <= 108) ||
                                n.Type == 125 || n.Type == 133 || (n.Type >= 148 && n.Type <= 151) ||
                                n.Type == 159 || n.Type == 160 || n.Type == 164 || n.Type == 168 ||
                                // n.Type == 159 || n.Type == 160 || n.Type == 164 || // Duplicated segment [PVS Studio]
                                (n.Type >= 154 && n.Type <= 157) ||
                                n.Type == 165 || n.Type == 171 || n.Type == 178 ||
                                n.Type == 197 || n.Type == 180 || n.Type == 181 || n.Type == 190 ||
                                n.Type == 192 || n.Type == 196 ||
                                // Duplicated segment, .....! [PVS Studio]
                                // n.Type == 197 ||
                                (UnderWater[0] && NPCIsBoot(n)) ||
                                (n.Type >= 198 && n.Type <= 228) || n.Type == 234);

                    } while(n.Type == 235 || n.Type == 231 || n.Type == 179 || n.Type == 49 ||
                            n.Type == 237 || n.Type == 238 || n.Type == 239 || n.Type == 240 ||
                            n.Type == 245 || n.Type == 246 || n.Type == 248 || n.Type == 254 ||
                            n.Type == 255 || n.Type == 256 || n.Type == 257 || n.Type == 259 ||
                            n.Type == 260 || n.Type == 262 || n.Type == 263 || n.Type == 265 ||
                            n.Type == 266 || (n.Type >= 267 && n.Type <= 272) ||
                            n.Type == 275 || n.Type == 276 ||
                            (n.Type >= 280 && n.Type <= 284) || n.Type == 241);

                    n.Active = true;
                    n.HoldingPlayer = A;
                    n.Location.Height = n->THeight;
                    n.Location.Width = n->TWidth;
                    n.Location.Y = Player[A].Location.Y;  // level[n.Section].Height + 1000
                    n.Location.X = Player[A].Location.X; // level[n.Section].X + 1000
                    n.TimeLeft = 100;
                    n.Section = Player[A].Section;
                    syncLayers_NPC(numNPCs);
                }
            }

        }
        else if(p.Location.X > level[p.Section].Width + 64)
        {
            p.Dead = true;
        }

        if(p.WetFrame)
        {
            if(p.Location.SpeedY == 0 || p.Slope > 0)
                p.CanJump = true;
            if(iRand(100) >= 98 || p.Location.SpeedY == 0 || p.Slope > 0)
                p.Controls.Jump = true;
        }

        if(iRand(20) == 0 && Player[A].HoldingNPC == 0 && !Player[A].Slide && Player[A].CanAltJump && Player[A].Mount == 0)
            Player[A].Controls.AltJump = true;

        if(iRand(1000) == 0 && !Player[A].CanFly2)
            Player[A].Controls.Run = false;

        if(Player[A].Mount == 3 && iRand(50) == 0 && !Player[A].RunRelease)
            Player[A].Controls.Run = false;

        if(NPC[Player[A].HoldingNPC].Type == 22 || NPC[Player[A].HoldingNPC].Type == 49)
            Player[A].Controls.Run = true;

        if(Player[A].Slide && Player[A].CanJump)
        {
            if(Player[A].Location.SpeedX > -2 && Player[A].Location.SpeedX < 2)
                Player[A].Controls.Jump = true;
        }

        if(!Player[A].CanFly && !Player[A].CanFly2 && (Player[A].State == 4 || Player[A].State == 5) && !Player[A].Slide)
            Player[A].Controls.Jump = true;

        if(Player[A].Quicksand > 0)
        {
            Player[A].CanJump = true;
            Player[A].Controls.Jump = true;
        }

        if(Player[A].FloatTime > 0 || (Player[A].CanFloat && Player[A].FloatRelease && Player[A].Jump == 0 && Player[A].Location.SpeedY > 0 && iRand(20) == 0))
            Player[A].Controls.Jump = true;

        if(NPC[Player[A].HoldingNPC].Type == 13 && iRand(20) == 0)
        {
            Player[A].Controls.Run = false;
            if(iRand(2) == 0)
                Player[A].Controls.Up = true;
            if(iRand(2) == 0)
                Player[A].Controls.Right = false;
        }

        if(!Player[A].Slide && (Player[A].Slope > 0 || Player[A].StandingOnNPC > 0 || Player[A].Location.SpeedY == 0))
        {
            tempLocation = Player[A].Location;
            tempLocation.Width = 95;
            tempLocation.Height -= 1;

            for(int B : treeBlockQuery(tempLocation, SORTMODE_NONE))
            {
                if(BlockSlope[Block[B].Type] == 0 && !BlockIsSizable[Block[B].Type] &&
                   !BlockOnlyHitspot1[Block[B].Type] && !Block[B].Hidden)
                {
                    if(CheckCollision(Block[B].Location, tempLocation))
                    {
                        Player[A].CanJump = true;
                        Player[A].SpinJump = false;
                        Player[A].Controls.Jump = true;
                        break;
                    }
                }
            }
        }

        if(Player[A].Slope == 0 && !Player[A].Slide && Player[A].StandingOnNPC == 0 && (Player[A].Slope > 0 || Player[A].Location.SpeedY == 0))
        {
            tempBool = false;
            tempLocation = Player[A].Location;
            tempLocation.Width = 16;
            tempLocation.Height = 16;
            tempLocation.X = Player[A].Location.X + Player[A].Location.Width;
            tempLocation.Y = Player[A].Location.Y + Player[A].Location.Height;

            for(int B : treeBlockQuery(tempLocation, SORTMODE_NONE))
            {
                if((!BlockIsSizable[Block[B].Type] || Block[B].Location.Y > Player[A].Location.Y + Player[A].Location.Height - 1) &&
                   !BlockOnlyHitspot1[Block[B].Type] && !Block[B].Hidden)
                {
                    if(CheckCollision(Block[B].Location, tempLocation))
                    {
                        tempBool = true;
                        break;
                    }
                }
            }

            if(!tempBool)
            {
                Player[A].CanJump = true;
                Player[A].SpinJump = false;
                Player[A].Controls.Jump = true;
            }
        }

        if(Player[A].Character == 5 && Player[A].Controls.Jump)
        {
            Player[A].Controls.AltJump = true;
            // .Controls.Jump = False
        }
    }

    if(LevelMacro > LEVELMACRO_OFF)
        UpdateMacro();

    ClearTriggeredEvents();
    UpdateLayers();
    UpdateNPCs();
    UpdateBlocks();
    UpdateEffects();
    UpdatePlayer();
    UpdateGraphics();
    UpdateSound();
    UpdateEvents();
    updateScreenFaders();
}

void MenuLoop()
{
    lunaLoop();

    // ConnectScreen and ControlsSettings screens handles its own input method polling
    if(MenuMode != MENU_CHARACTER_SELECT_NEW && MenuMode != MENU_INPUT_SETTINGS && !g_pollingInput)
        Controls::PollInputMethod();
    Controls::Update();
    if(!SharedCursor.Primary && !SharedCursor.Secondary)
        MenuMouseRelease = true;
    // replicates legacy behavior allowing clicks to be detected
    if(SharedCursor.Primary || SharedCursor.Secondary || SharedCursor.Tertiary)
        SharedCursor.Move = true;

    if(mainMenuUpdate())
        return;

    Integrator::sync();

    if(!g_gameInfo.introDeadMode)
        updateIntroLevelActivity();
    else
    {
        ClearTriggeredEvents();
        UpdateLayers();
        UpdateNPCs();
        UpdateBlocks();
        UpdateEffects();
//        UpdatePlayer();
        UpdateGraphics();
        UpdateSound();
        UpdateEvents();
        updateScreenFaders();
    }

    if(SharedCursor.Primary)
    {
        const Location_t cursorLoc = newLoc(SharedCursor.X - vScreen[1].X - vScreen[1].TargetX(), SharedCursor.Y - vScreen[1].Y - vScreen[1].TargetY());
        if(iRand(5) >= 2)
        {
            NewEffect(EFFID_SPARKLE, cursorLoc);
            Effect[numEffects].Location.SpeedX = dRand() * 4 - 2;
            Effect[numEffects].Location.SpeedY = dRand() * 4 - 2;
        }

        for(int A : treeNPCQuery(cursorLoc, SORTMODE_NONE))
        {
            if(NPC[A].Active)
            {
                if(CheckCollision(cursorLoc, NPC[A].Location))
                {
                    if(!NPC[A]->IsACoin)
                    {
                        NPC[0] = NPC[A];
                        NPC[0].Location.X = SharedCursor.X - vScreen[1].X - vScreen[1].ScreenLeft;
                        NPC[0].Location.Y = SharedCursor.Y - vScreen[1].Y - vScreen[1].ScreenTop;
                        NPCHit(A, 3, 0);
                    }
                    else
                    {
                        NewEffect(EFFID_COIN_COLLECT, NPC[A].Location);
                        NPC[A].Killed = 9;
                        NPCQueues::Killed.push_back(A);
                    }
                }
            }
        }

        for(int A : treeBlockQuery(cursorLoc, SORTMODE_COMPAT))
        {
            if(!Block[A].Hidden)
            {
                if(CheckCollision(cursorLoc, Block[A].Location))
                {
                    BlockHit(A);
                    BlockHitHard(A);
                }
            }
        }
    }

    if(SharedCursor.Primary || SharedCursor.Secondary)
        MenuMouseRelease = false;

#ifdef KEYBOARD_H
    if(MenuMouseClick)
        Controls::g_cancelDoubleClick = true;
#endif

    MenuMouseClick = false;
}


================================================
FILE: src/main/menu_main.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_timer.h"
#include "sdl_proxy/sdl_atomic.h"

#ifndef PGE_NO_THREADING
#include <SDL2/SDL_thread.h>
#endif

#ifdef THEXTECH_ENABLE_SDL_NET
#include <md5/md5tools.hpp>
#include "main/client_methods.h"
#endif

#include <fmt_format_ne.h>
#include <array>
#include <sorting/tinysort.h>

#include <AppPath/app_path.h>
#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <Archives/archives.h>
#include <PGE_File_Formats/file_formats.h>
#include <Integrator/integrator.h>

#include "menu_main.h"
#include "game_info.h"
#include "../version.h"
#include "../gfx.h"
#include "main/screen_connect.h"
#include "main/screen_options.h"
#include "main/menu_controls.h"
#include "main/translate_episode.h"

#include "speedrunner.h"
#include "main/gameplay_timer.h"
#include "../game_main.h"
#include "../sound.h"
#include "../player.h"
#include "../collision.h"
#include "../graphics.h"
#include "../core/render.h"
#include "../core/window.h"
#include "../core/events.h"
#include "../controls.h"
#include "../config.h"
#include "level_file.h"
#include "world_file.h"
#include "pge_delay.h"
#include "change_res.h"
#include "game_globals.h"
#include "core/language.h"
#include "main/translate.h"
#include "change_res.h"
#include "game_globals.h"
#include "npc_id.h"
#include "fontman/font_manager.h"
#include "custom.h"

#include "editor.h"
#include "frm_main.h"
#include "load_gfx.h"

#include "screen_textentry.h"
#include "main/asset_pack.h"
#include "main/screen_asset_pack.h"
#include "main/screen_content.h"
#include "editor/new_editor.h"
#include "editor/write_level.h"
#include "editor/write_world.h"
#include "editor/editor_custom.h"
#include "script/luna/luna.h"

MainMenuContent g_mainMenu;

#ifndef PGE_NO_THREADING
static bool                 s_atomicsInited = false;
static SDL_atomic_t         loading = {};
static SDL_atomic_t         loadingProgrss = {};
static SDL_atomic_t         loadingProgrssMax = {};

static SDL_Thread*          loadingThread = nullptr;
#endif

static constexpr int c_menuSavesLength = maxSaveSlots + 2;
static constexpr int c_menuSavesFooterHint = (c_menuSavesLength * 30) - 30;
static constexpr int c_menuItemSavesEndList = maxSaveSlots - 1;
static constexpr int c_menuItemSavesCopy = maxSaveSlots;
static constexpr int c_menuItemSavesDelete = maxSaveSlots + 1;
static constexpr int c_menuSavesOffsetY = (maxSaveSlots - 3) * 30;

static uint8_t s_episode_playstyle = 0;
static uint8_t s_episode_speedrun_mode = 0;

int NumSelectWorld = 0;
int NumSelectBattle = 0;
std::vector<SelectWorld_t> SelectWorld;
std::vector<SelectWorld_t> SelectBattle;


void initMainMenu()
{
#ifndef PGE_NO_THREADING
    if(!s_atomicsInited)
    {
        SDL_AtomicSet(&loading, 0);
        SDL_AtomicSet(&loadingProgrss, 0);
        SDL_AtomicSet(&loadingProgrssMax, 0);
        s_atomicsInited = true;
    }
#endif

    g_mainMenu.introPressStart = "Press Start";

    g_mainMenu.mainPlayEpisode = "Play Episode";
    g_mainMenu.main1PlayerGame = "1 Player Game";
    g_mainMenu.mainMultiplayerGame = "2 Player Game";
    g_mainMenu.mainBattleGame = "Battle Game";
    g_mainMenu.mainEditor = "Editor";
    g_mainMenu.mainOptions = "Options";
    g_mainMenu.mainExit = "Exit";

    g_mainMenu.loading = "Loading...";

    g_mainMenu.languageName = "English";
    g_mainMenu.pluralRules = "one-is-singular";

    g_mainMenu.selectCharacter = "{0} game";

    g_mainMenu.editorBattles = "<Battle Levels>";
    g_mainMenu.editorNewWorld = "<New World>";
    g_mainMenu.editorMakeFor = "Make for:";
    g_mainMenu.editorErrorMissingResources = "Sorry! You are missing {0}, required for the in-game editor.";
    g_mainMenu.editorPromptNewWorldName = "New world name";

    g_mainMenu.gameNoEpisodesToPlay = "<No episodes to play>";
    g_mainMenu.gameNoBattleLevels = "<No battle levels>";
    g_mainMenu.gameBattleRandom = "Random Level";

    g_mainMenu.warnEpCompat = "This episode was made for a different branch of SMBX and may not work properly.";

    g_mainMenu.gameSlotContinue = "SLOT {0} ... {1}%";
    g_mainMenu.gameSlotNew = "SLOT {0} ... NEW GAME";
    g_mainMenu.gameCopySave = "Copy save";
    g_mainMenu.gameEraseSave = "Erase save";
    g_mainMenu.gameSourceSlot = "Select the source slot";
    g_mainMenu.gameTargetSlot = "Now select the target";
    g_mainMenu.gameEraseSlot = "Select the slot to erase";

    g_mainMenu.phraseScore = "Score: {0}";
    g_mainMenu.phraseTime = "Time: {0}";

    g_mainMenu.errorBattleNoLevels = "Can't start battle because of no levels available";

    g_mainMenu.optionsRestartEngine = "Restart engine for changes to take effect.";

    g_mainMenu.wordPlayer = "Player";
    g_mainMenu.wordProfile = "Profile";
    g_mainMenu.wordBack = "Back";
    g_mainMenu.wordResume = "Resume";
    g_mainMenu.wordWaiting = "Waiting";

    g_mainMenu.controlsTitle = "Controls";
    g_mainMenu.controlsConnected = "Connected:";
    g_mainMenu.controlsDeleteKey = "(Alt Run to Delete)";
    g_mainMenu.controlsDeviceTypes = "Device Types";
    g_mainMenu.controlsInUse = "(In Use)";
    g_mainMenu.controlsNotInUse = "(Not In Use)";

    g_mainMenu.controlsActivateProfile = "Activate profile";
    g_mainMenu.controlsRenameProfile = "Rename profile";
    g_mainMenu.controlsDeleteProfile = "Delete profile";
    g_mainMenu.controlsPlayerControls = "Player controls";
    g_mainMenu.controlsCursorControls = "Cursor controls";
    g_mainMenu.controlsEditorControls = "Editor controls";
    g_mainMenu.controlsHotkeys = "Hotkeys";

    g_mainMenu.controlsOptionRumble = "Rumble";
    // g_mainMenu.controlsOptionGroundPoundButton = "Ground Pound Button";
    g_mainMenu.controlsOptionBatteryStatus = "Battery Status";
    g_mainMenu.controlsOptionAltMenuControls = "Alt Menu Controls";

    g_mainMenu.wordProfiles = "Profiles";
    g_mainMenu.wordButtons  = "Buttons";

    g_mainMenu.controlsReallyDeleteProfile = "Really delete profile?";
    g_mainMenu.controlsNewProfile = "<New Profile>";

    g_mainMenu.wordNo   = "No";
    g_mainMenu.wordYes  = "Yes";
    g_mainMenu.wordOkay = "Okay";
    g_mainMenu.caseNone = "<None>";
    g_mainMenu.wordOn   = "On";
    g_mainMenu.wordOff  = "Off";
    g_mainMenu.wordShow = "Show";
    g_mainMenu.wordHide = "Hide";
    g_mainMenu.abbrevMilliseconds = "MS";

#ifdef THEXTECH_ENABLE_SDL_NET
    // NetPlay
    g_mainMenu.mainNetplay = "NetPlay";
    g_mainMenu.netplayRoomKey = "Room key:";
    g_mainMenu.netplayJoinRoom = "Join Room";
    g_mainMenu.netplayCreateRoom = "Create Room";
    g_mainMenu.netplayLeaveRoom = "Leave Room";
    g_mainMenu.netplayServer = "Server:";
    g_mainMenu.netplayNickname = "Nickname:";
#endif

    // g_mainMenu.promptDeprecatedSetting = "This file uses a deprecated compatibility flag that will be removed in version 1.3.7.\n\nOld flag: \"{0}\"\nNew flag: \"{1}\"\n\n\nReplace it with the updated flag for version 1.3.6 and newer?";
    // g_mainMenu.promptDeprecatedSettingUnwritable = "An unwritable file ({0}) uses a deprecated compatibility flag that will be removed in version 1.3.7.\n\nSection: [{1}]\nOld flag: \"{2}\"\nNew flag: \"{3}\"\n\n\nPlease update it manually and copy to your device.";
}


static int menuPlayersNum = 0;
static int menuBattleMode = false;

static int menuCopySaveSrc = 0;
static int menuCopySaveDst = 0;

static int s_startAssetPackTimer = 0;

static const int TinyScreenH = 400;
static const int SmallScreenH = 500;
static const int TinyScreenW = 600;

static bool s_prefer_modern_char_sel()
{
    return (g_config.compatibility_mode != Config_t::COMPAT_SMBX13) && (s_episode_speedrun_mode != 3);
}

static bool s_show_separate_2P()
{
    return g_config.compatibility_mode == Config_t::COMPAT_SMBX13 && !g_gameInfo.disableTwoPlayer;
}

#ifdef THEXTECH_ENABLE_SDL_NET
static bool s_show_online()
{
    return !g_gameInfo.disableTwoPlayer;
}

static void s_StartEpisodeOnline()
{
    if(!XMessage::GetClientStatus())
        return;

    const auto& status = *XMessage::GetClientStatus();

    l_screen = &Screens[status.client_index];
    seedRandom(XMessage::g_session.random_seed);

    selSave = 0;

    if((int)Controls::g_InputMethods.size() > 1)
        Controls::ClearInputMethods();

    for(int A = 1; A <= numCharacters; A++)
        blockCharacter[A] = (g_forceCharacter) ? false : SelectWorld[selWorld].blockChar[A];

    for(int p = 0; p < maxLocalPlayers; p++)
        l_screen->charSelect[p] = 0;

    // find character for P1 (player on episode start)
    Screens[0].charSelect[0] = 1;

    for(int A = 1; A <= numCharacters; A++)
    {
        if(blockCharacter[A])
            continue;

        Screens[0].charSelect[0] = A;
        break;
    }

    StartEpisode();
}

uint32_t s_assetPackHash()
{
    return 0;
}

uint32_t s_engineHash()
{
    return md5::string_to_u32(V_BUILD_VER);
}
#endif

// export it, let's hope for some nice LTO here
int mainMenuPlaystyle()
{
    return s_episode_playstyle;
}

static void s_change_save_item()
{
    if(MenuCursor < 0 || MenuCursor >= maxSaveSlots)
        return;

    int save_configs = SaveSlotInfo[MenuCursor + 1].ConfigDefaults;

    if(save_configs > 0)
    {
        s_episode_playstyle = save_configs - 1;
        s_episode_speedrun_mode = 0;
    }
    else if(save_configs < 0)
    {
        s_episode_speedrun_mode = -save_configs;
        s_episode_playstyle = s_episode_speedrun_mode - 1;
    }
    else
    {
        s_episode_playstyle = SelectWorld[selWorld].bugfixes_on_by_default ? Config_t::MODE_MODERN : Config_t::MODE_CLASSIC;
        s_episode_speedrun_mode = g_config.speedrun_mode.m_value;
    }
}

void menu_draw_infobox_switch_arrows(int infobox_x, int infobox_y)
{
    // XRender::renderRect(infobox_x, infobox_y, 480, 68, {0, 0, 0, 192});

    if(CommonFrame % 90 < 45)
        return;

    if(GFX.CharSelIcons.inited)
    {
        XRender::renderTextureFL(infobox_x + 8, infobox_y + 34 - 24 / 2, 24, 24, GFX.CharSelIcons, 72, 0, 0, nullptr, X_FLIP_HORIZONTAL);
        XRender::renderTextureBasic(infobox_x + 480 - 8 - 24, infobox_y + 34 - 24 / 2, 24, 24, GFX.CharSelIcons, 72, 0);
    }
    else
    {
        XRender::renderTextureFL(infobox_x + 8, infobox_y + 34 - GFX.MCursor[1].w / 2, GFX.MCursor[1].w, GFX.MCursor[1].h, GFX.MCursor[1], 0, 0, -90);
        XRender::renderTextureFL(infobox_x + 480 - 8 - GFX.MCursor[1].h, infobox_y + 34 - GFX.MCursor[2].w / 2, GFX.MCursor[2].w, GFX.MCursor[2].h, GFX.MCursor[2], 0, 0, -90);
    }
}

void GetMenuPos(int* MenuX, int* MenuY)
{
    if(MenuX)
        *MenuX = XRender::TargetW / 2 - 100;

    if(MenuY)
        *MenuY = XRender::TargetH - 250;

    // tweaks for MenuX
    if(MenuX && XRender::TargetW < TinyScreenW)
    {
        *MenuX = XRender::TargetW / 2 - 240;
        if(*MenuX < 24 + XRender::TargetOverscanX)
            *MenuX = 24 + XRender::TargetOverscanX;
    }

    // the rest is tweaks for MenuY
    if(!MenuY)
        return;

    if(XRender::TargetH < TinyScreenH)
        *MenuY = 100;
    else if(XRender::TargetH < SmallScreenH)
        *MenuY = XRender::TargetH - 220;

    if(MenuMode >= MENU_SELECT_SLOT_BASE && MenuMode < MENU_SELECT_SLOT_END)
        *MenuY -= c_menuSavesOffsetY;
}

#if !defined(PGE_NO_THREADING)
static int FindWorldsThread(void *)
{
    FindWorlds();
    return 0;
}
#endif

#if (defined(__APPLE__) && defined(USE_BUNDLED_ASSETS)) || defined(FIXED_ASSETS_PATH) || defined(__EMSCRIPTEN__)
#   define CAN_WRITE_APPPATH_WORLDS false
#else
#   define CAN_WRITE_APPPATH_WORLDS true
#endif

struct WorldRoot_t
{
    std::string path;
    bool editable;
};

// helper functions used by FindWorlds() and LoadSingleWorld()
static void s_LoadSingleWorld(const std::string& epDir, const std::string& fName, WorldData& head, TranslateEpisode& tr, bool editable);
static void s_LoadWorldArchive(const std::string& archive);
static void s_FinishFindWorlds();

void FindWorlds()
{
    TranslateEpisode tr;
    WorldData head;
    NumSelectWorld = 0;

    std::vector<WorldRoot_t> worldRoots =
    {
        {AppPath + "worlds/", CAN_WRITE_APPPATH_WORLDS}
    };

    if(AppPathManager::userDirIsAvailable())
    {
        // assume that assets are not writable
        worldRoots.push_back({AppPathManager::userWorldsRootDir(), true});
        worldRoots[0].editable = false;
    }

#ifdef APP_PATH_HAS_EXTRA_WORLDS
    // add worlds from additional romfs packages
    for(const std::string& root : AppPathManager::worldRootDirs())
        worldRoots.push_back({root, false});
#endif

    SelectWorld.clear();
    SelectWorld.emplace_back(SelectWorld_t()); // Dummy entry

#ifndef PGE_NO_THREADING
    if(SDL_AtomicGet(&loading))
    {
        SDL_AtomicSet(&loadingProgrss, 0);
        SDL_AtomicSet(&loadingProgrssMax, 0);

        for(const auto &worldsRoot : worldRoots)
        {
            std::vector<std::string> dirs;
            DirMan episodes(worldsRoot.path);
            episodes.getListOfFolders(dirs);
            SDL_AtomicAdd(&loadingProgrssMax, (int)dirs.size());
            if(!Archives::has_prefix(worldsRoot.path))
            {
                episodes.getListOfFiles(dirs);
                SDL_AtomicAdd(&loadingProgrssMax, (int)dirs.size());
            }
        }
    }
#endif

    for(const auto &worldsRoot : worldRoots)
    {
        DirMan episodes(worldsRoot.path);

        std::vector<std::string> dirs;
        std::vector<std::string> files;
        episodes.getListOfFolders(dirs);

        for(const auto &dir : dirs)
        {
            std::string epDir = worldsRoot.path + dir + "/";
            DirMan episode(epDir);
            episode.getListOfFiles(files, {".wld", ".wldx"});

            for(std::string &fName : files)
                s_LoadSingleWorld(epDir, fName, head, tr, worldsRoot.editable);

#ifdef THEXTECH_PRELOAD_LEVELS
            if(LoadingInProcess)
                UpdateLoad();
#endif

#ifndef PGE_NO_THREADING
            SDL_AtomicAdd(&loadingProgrss, 1);
#endif
        }

        if(!Archives::has_prefix(worldsRoot.path))
        {
            episodes.getListOfFiles(dirs);

            for(const auto &dir : dirs)
            {
                s_LoadWorldArchive(worldsRoot.path + dir);

#ifdef THEXTECH_PRELOAD_LEVELS
                if(LoadingInProcess)
                    UpdateLoad();
#endif

#ifndef PGE_NO_THREADING
                SDL_AtomicAdd(&loadingProgrss, 1);
#endif
            }
        }
    }

    s_FinishFindWorlds();
}

static void s_LoadSingleWorld(const std::string& epDir, const std::string& fName, WorldData& head, TranslateEpisode& tr, bool editable)
{
    SelectWorld_t w;
    w.WorldFilePath = epDir + fName;

    PGE_FileFormats_misc::RWopsTextInput in(Files::open_file(w.WorldFilePath, "r"), w.WorldFilePath);

    if(FileFormats::OpenWorldFileHeaderT(in, head))
    {
        w.WorldName = head.EpisodeTitle;
        head.charactersToS64();
        if(w.WorldName.empty())
            w.WorldName = fName;

        bool is_wldx = (head.meta.RecentFormat == WorldData::PGEX);
        bool is_wld38a = (head.meta.RecentFormat == WorldData::SMBX38A);
        if(is_wldx && (head.meta.configPackId == "SMBX2" || head.meta.engineFeatureLevel > g_gameInfo.contentFeatureLevel))
            w.probably_incompatible = true;
        else if(is_wld38a)
            w.probably_incompatible = true;
        else
            w.bugfixes_on_by_default = is_wldx;

        w.blockChar[1] = head.nocharacter1;
        w.blockChar[2] = head.nocharacter2;
        w.blockChar[3] = head.nocharacter3;
        w.blockChar[4] = head.nocharacter4;
        w.blockChar[5] = head.nocharacter5;

        w.editable = editable;

        if(tr.tryTranslateTitle(epDir, fName, w.WorldName))
            pLogDebug("Translated world title: %s", w.WorldName.c_str());

#ifdef THEXTECH_ENABLE_SDL_NET
        if(w.WorldFilePath.size() > 2 && w.WorldFilePath[0] == ':' && w.WorldFilePath[1] == 'a')
            w.lz4_content_hash = md5::string_to_u32(w.WorldFilePath);
#endif

        SelectWorld.push_back(std::move(w));
    }
}

static void s_LoadWorldArchive(const std::string& archive)
{
    SelectWorld_t w;
    w.WorldFilePath = "@";
    w.WorldFilePath += archive;
    w.WorldFilePath += ":/";

    IniProcessing ini = Files::load_ini(w.WorldFilePath + "_meta.ini");

    ini.beginGroup("content");

    // confirm filename exists
    ini.read("filename", w.WorldName, w.WorldName);
    if(w.WorldName.empty())
    {
        pLogInfo("Episode [%s] not loaded; could not parse _meta.ini", archive.c_str());
        return;
    }
    w.WorldFilePath += w.WorldName;

    // confirm engine support
    std::string engine;
    ini.read("engine", engine, engine);
    if(engine != "TheXTech")
    {
        pLogInfo("Episode [%s] not loaded; for incompatible engine [%s]", archive.c_str(), engine.c_str());
        return;
    }

    // confirm platform support
    std::string platform;
    ini.read("platform", platform, platform);

    bool platform_okay = false;

#ifndef __16M__
    if(platform == "main")
        platform_okay = true;
#endif

#ifdef __3DS__
    if(platform == "3ds")
        platform_okay = true;
#endif

#ifdef __WII__
    if(platform == "wii")
        platform_okay = true;
#endif

#ifdef __16M__
    if(platform == "dsi")
        platform_okay = true;
#endif

    if(!platform_okay)
    {
        pLogInfo("Episode [%s] not loaded; for incompatible platform [%s]", archive.c_str(), platform.c_str());
        return;
    }

#ifdef THEXTECH_ENABLE_SDL_NET
    ini.read("source-hash", w.lz4_content_hash, 0);
#endif

    ini.endGroup();

    // load properties
    ini.beginGroup("properties");

    // playstyle classic
    bool is_classic;
    ini.read("is-classic", is_classic, false);
    w.bugfixes_on_by_default = !is_classic;

    // character block
    std::string char_block;
    ini.read("char-block", char_block, char_block);
    char_block.resize(numCharacters, '0');

    for(int i = 1; i <= numCharacters; i++)
        w.blockChar[i] = (char_block[i - 1] == '1');

    // title
    ini.read("title", w.WorldName, w.WorldName);

    std::string title_key = "title-";
    title_key += CurrentLanguage;
    ini.read(title_key.c_str(), w.WorldName, w.WorldName);

    title_key += '-';
    title_key += CurrentLangDialect;
    ini.read(title_key.c_str(), w.WorldName, w.WorldName);

    ini.endGroup();

    // last details
    w.editable = false;

#ifdef THEXTECH_ENABLE_SDL_NET
    if(!w.lz4_content_hash)
    {
        SDL_RWops* rw = Files::open_file(archive, "rb");
        if(rw)
        {
            SDL_RWseek(rw, -4, RW_SEEK_END);
            uint8_t hash[4];
            if(SDL_RWread(rw, hash, 1, 4) == 4)
            {
                w.lz4_content_hash = (hash[0])
                    | ((uint32_t)(hash[1]) <<  8)
                    | ((uint32_t)(hash[2]) << 16)
                    | ((uint32_t)(hash[3]) << 24);
            }
            SDL_RWclose(rw);
        }
    }
#endif

    // store it!
    SelectWorld.push_back(std::move(w));
}

static void s_FinishFindWorlds()
{
    if(SelectWorld.size() <= 1) // No available worlds in the list
    {
        SelectWorld.clear();
        SelectWorld.emplace_back(SelectWorld_t()); // Dummy entry
        SelectWorld.emplace_back(SelectWorld_t()); // "no episodes to play" entry
        SelectWorld[1].WorldName = g_mainMenu.gameNoEpisodesToPlay;
        SelectWorld[1].disabled = true;
    }

    // Sort all worlds by alphabetical order
    tinysort(SelectWorld.begin(), SelectWorld.end(),
              [](const SelectWorld_t& a, const SelectWorld_t& b)
    {
        return a.WorldName < b.WorldName;
    });

    NumSelectWorld = (int)(SelectWorld.size() - 1);

    SelectWorld_t battles = SelectWorld_t();
    battles.WorldName = g_mainMenu.editorBattles;
    battles.WorldFilePath = "battle";
    battles.editable = true;
    SelectWorld.push_back(std::move(battles));

    SelectWorld_t createWorld = SelectWorld_t();
    createWorld.WorldName = g_mainMenu.editorNewWorld;
    createWorld.editable = true;
    SelectWorld.push_back(std::move(createWorld));

    ContentSelectScreen::Prepare();

#ifndef PGE_NO_THREADING
    SDL_AtomicSet(&loading, 0);
#endif
}

void LoadSingleWorld(const std::string wPath)
{
    TranslateEpisode tr;
    WorldData head;
    NumSelectWorld = 0;

    SelectWorld.clear();
    SelectWorld.emplace_back(SelectWorld_t()); // Dummy entry

    std::string fName = Files::basename(wPath);
    std::string epDir = wPath.substr(0, wPath.size() - fName.size());

    if(epDir.empty())
        epDir = "./";

    epDir = DirMan(epDir).absolutePath() + "/";

    s_LoadSingleWorld(epDir, fName, head, tr, true);

    s_FinishFindWorlds();
}

#if !defined(THEXTECH_PRELOAD_LEVELS) && !defined(PGE_NO_THREADING)
static int FindLevelsThread(void *)
{
    FindLevels();
    return 0;
}
#endif

void FindLevels()
{
    std::vector<WorldRoot_t> battleRoots =
    {
        {AppPath + "battle/", CAN_WRITE_APPPATH_WORLDS}
    };

    if(AppPathManager::userDirIsAvailable())
    {
        // assume that assets are not writable
        battleRoots.push_back({AppPathManager::userBattleRootDir(), true});
        battleRoots[0].editable = false;
    }

    SelectBattle.clear();
    SelectBattle.emplace_back(SelectWorld_t()); // Dummy entry

    NumSelectBattle = 1;
    SelectBattle.emplace_back(SelectWorld_t()); // "random level" entry
    SelectBattle[1].WorldName = g_mainMenu.gameBattleRandom;
    LevelData head;

#ifndef PGE_NO_THREADING
    if(SDL_AtomicGet(&loading))
    {
        SDL_AtomicSet(&loadingProgrss, 0);
        SDL_AtomicSet(&loadingProgrssMax, 0);

        for(const auto &battleRoot : battleRoots)
        {
            std::vector<std::string> files;
            DirMan battleLvls(battleRoot.path);
            battleLvls.getListOfFiles(files, {".lvl", ".lvlx"});
            SDL_AtomicAdd(&loadingProgrssMax, (int)files.size());
        }
    }
#endif

    for(const auto &battleRoot : battleRoots)
    {
        std::vector<std::string> files;
        DirMan battleLvls(battleRoot.path);
        battleLvls.getListOfFiles(files, {".lvl", ".lvlx"});
        for(std::string &fName : files)
        {
            std::string wPath = battleRoot.path + fName;

            PGE_FileFormats_misc::RWopsTextInput in(Files::open_file(wPath, "r"), wPath);
            if(FileFormats::OpenLevelFileHeaderT(in, head))
            {
                SelectWorld_t w;
                w.WorldFilePath = battleRoot.path;
                w.WorldFilePath += '/';
                w.WorldFilePath += fName;
                w.WorldName = head.LevelName;
                if(w.WorldName.empty())
                    w.WorldName = fName;
                w.editable = battleRoot.editable;
                SelectBattle.push_back(std::move(w));

#ifdef THEXTECH_PRELOAD_LEVELS
                if(LoadingInProcess)
                    UpdateLoad();
#endif
            }
#ifndef PGE_NO_THREADING
            SDL_AtomicAdd(&loadingProgrss, 1);
#endif
        }
    }

    NumSelectBattle = ((int)SelectBattle.size() - 1);

    if(SelectBattle.size() <= 2) // No available levels in the list
    {
        SelectBattle.clear();
        SelectBattle.emplace_back(SelectWorld_t()); // Dummy entry

        NumSelectBattle = 1;
        SelectBattle.emplace_back(SelectWorld_t()); // "no battle levels" entry
        SelectBattle[1].WorldName = g_mainMenu.gameNoBattleLevels;
        SelectBattle[1].disabled = true;
    }

    ContentSelectScreen::Prepare();

#ifndef PGE_NO_THREADING
    SDL_AtomicSet(&loading, 0);
#endif
}

static void s_PrepareContentSelect()
{
#ifdef THEXTECH_PRELOAD_LEVELS
    ContentSelectScreen::Prepare();
#elif defined(PGE_NO_THREADING)
    if(MenuMode == MENU_BATTLE_MODE)
        FindLevels();
    else
        FindWorlds();
#else
    SDL_AtomicSet(&loading, 1);
    if(MenuMode == MENU_BATTLE_MODE)
        loadingThread = SDL_CreateThread(FindLevelsThread, "FindLevels", nullptr);
    else
        loadingThread = SDL_CreateThread(FindWorldsThread, "FindWorlds", nullptr);
    SDL_DetachThread(loadingThread);
#endif
}


static void s_handleMouseMove(int items, int x, int y, int maxWidth, int itemHeight)
{
    For(A, 0, items)
    {
        if(SharedCursor.Y >= y + A * itemHeight && SharedCursor.Y <= y + 16 + A * itemHeight)
        {
            if(SharedCursor.X >= x && SharedCursor.X <= x + maxWidth)
            {
                if(MenuMouseRelease && SharedCursor.Primary)
                    MenuMouseClick = true;
                if(MenuCursor != A)
                {
                    PlaySoundMenu(SFX_Slide);
                    MenuCursor = A;
                    break;
                }
            }
        }
    }
}

static int s_quitKeyPos()
{
    int quitKeyPos = 2;

    if(s_show_separate_2P())
        quitKeyPos++;

    if(!g_gameInfo.disableBattleMode)
        quitKeyPos++;

#ifdef THEXTECH_ENABLE_SDL_NET
    if(s_show_online())
        quitKeyPos++;
#endif

    if(g_config.enable_editor)
        quitKeyPos++;

    return quitKeyPos;
}


static bool s_can_enter_ap_screen()
{
    return MenuMode == MENU_INTRO || (XRender::TargetH >= TinyScreenH && MenuMode == MENU_MAIN);
}



bool mainMenuUpdate()
{
    int MenuX, MenuY;
    GetMenuPos(&MenuX, &MenuY);

    // Location_t tempLocation;
    int menuLen;
    // Player_t blankPlayer;

    MenuControls_t menuControls = Controls::GetMenuControls();

    menuControls.Back |= (SharedCursor.Secondary && MenuMouseRelease);

    if(menuControls.Back && menuControls.Do)
        menuControls.Do = false;

    bool should_enter_ap_screen = menuControls.Home && s_can_enter_ap_screen() && MenuCursorCanMove;

    if(should_enter_ap_screen && GetAssetPacks().size() <= 1)
    {
        PlaySoundMenu(SFX_BlockHit);
        MenuCursorCanMove = false;
    }

    if(should_enter_ap_screen && GetAssetPacks().size() > 1)
    {
        s_startAssetPackTimer++;
        if(s_startAssetPackTimer == 64)
        {
            PlaySoundMenu(SFX_Do);
            FadeOutMusic(500);
            ScreenAssetPack::g_LoopActive = true;
            GameMenu = false;
            return true;
        }
    }
    else if(s_can_enter_ap_screen() && s_startAssetPackTimer > 0)
        s_startAssetPackTimer -= 2;
    else
        s_startAssetPackTimer = 0;

    {
        {
            bool k = false;
            k |= menuControls.Back;
            k |= menuControls.Do;
            k |= menuControls.Up;
            k |= menuControls.Down;
            k |= menuControls.Left;
            k |= menuControls.Right;
            k |= menuControls.Home;
            k |= menuControls.Erase;

            if(!k)
                MenuCursorCanMove = true;
        }

        bool in_content_select = (MenuMode == MENU_1PLAYER_GAME || MenuMode == MENU_2PLAYER_GAME || MenuMode == MENU_BATTLE_MODE || MenuMode == MENU_EDITOR);
#ifdef THEXTECH_ENABLE_SDL_NET
        if(MenuMode == MENU_NETPLAY_WORLD_SELECT)
            in_content_select = true;
#endif

        if(!g_pollingInput && (MenuMode != MENU_CHARACTER_SELECT_NEW && MenuMode != MENU_CHARACTER_SELECT_NEW_BM && MenuMode != MENU_NEW_OPTIONS && MenuMode != MENU_INTRO && !in_content_select))
        {
            int cursorDelta = 0;

            if(menuControls.Up)
            {
                if(MenuCursorCanMove)
                {
                    MenuCursor -= 1;
                    cursorDelta = -1;
                }

                MenuCursorCanMove = false;
            }
            else if(menuControls.Down)
            {
                if(MenuCursorCanMove)
                {
                    MenuCursor += 1;
                    cursorDelta = +1;
                }

                MenuCursorCanMove = false;
            }

            if(cursorDelta != 0)
            {
                if(MenuMode >= MENU_SELECT_SLOT_BASE && MenuMode < MENU_SELECT_SLOT_END)
                    s_change_save_item();

                PlaySoundMenu(SFX_Slide);
            }

        } // No keyboard/Joystick grabbing active

        if(MenuMode == MENU_INTRO && XRender::TargetH >= TinyScreenH)
            MenuMode = MENU_MAIN;

        if(false
#ifndef PGE_NO_THREADING
            || SDL_AtomicGet(&loading)
#endif
#ifdef THEXTECH_ENABLE_SDL_NET
            || XMessage::GetClientStatus() == nullptr
#endif
        )
        {
            if((menuControls.Do && MenuCursorCanMove) || MenuMouseClick)
                PlaySoundMenu(SFX_BlockHit);

            if(MenuCursor != 0)
                MenuCursor = 0;
        }
#ifdef THEXTECH_ENABLE_SDL_NET
        else if(XMessage::CompleteRequest())
        {
            auto* status = XMessage::GetClientStatus();
            if(status && (status->client_state == XMessage::CLIENT_GUEST || status->client_state == XMessage::CLIENT_HOST))
            {
                s_StartEpisodeOnline();
                return true;
            }
            else if(status && status->client_state == XMessage::CLIENT_LOBBY && XMessage::GetRoomInfo() && XMessage::GetRoomInfo()->room_key)
            {
                const XMessage::RoomInfo& room_info = *XMessage::GetRoomInfo();

                selWorld = -1;

                for(size_t i = 0; i < SelectWorld.size(); i++)
                {
                    if(SelectWorld[i].lz4_content_hash == room_info.content_hash)
                    {
                        selWorld = i;
                        break;
                    }
                }

                if(room_info.room_key == 0 || room_info.engine_hash != s_engineHash() || room_info.asset_hash != s_assetPackHash() || room_info.content_hash == 0 || selWorld == -1)
                    PlaySoundMenu(SFX_BlockHit);
                else
                {
                    PlaySoundMenu(SFX_Do);
                    XMessage::JoinRoom(room_info.room_key);
                }
            }
            // ... some sort of switch for responses to queries
        }
#endif // #ifdef THEXTECH_ENABLE_SDL_NET
        // Menu Intro
        else if(MenuMode == MENU_INTRO)
        {
            if(MenuMouseRelease && SharedCursor.Primary)
                MenuMouseClick = true;

            if(menuControls.Back && MenuCursorCanMove)
            {
                int quitKeyPos = s_quitKeyPos();

                MenuMode = MENU_MAIN;
                MenuCursor = quitKeyPos;
                MenuCursorCanMove = false;
                PlaySoundMenu(SFX_Slide);
            }

            if((menuControls.Do && MenuCursorCanMove) || MenuMouseClick)
            {
                MenuCursorCanMove = false;
                MenuMode = MENU_MAIN;
                MenuCursor = 0;
                PlaySoundMenu(SFX_Do);
            }
        }
        // Main Menu
        else if(MenuMode == MENU_MAIN)
        {
            if(SharedCursor.Move)
            {
                For(A, 0, 10)
                {
                    if(SharedCursor.Y >= MenuY + A * 30 && SharedCursor.Y <= MenuY + A * 30 + 16)
                    {
                        int i = 0;
                        if(A == i++)
                            menuLen = 18 * (s_show_separate_2P() ? (int)g_mainMenu.main1PlayerGame.size() : (int)g_mainMenu.mainPlayEpisode.size()) - 2;
                        else if(s_show_separate_2P() && A == i++)
                            menuLen = 18 * (int)g_mainMenu.mainMultiplayerGame.size() - 2;
                        else if(!g_gameInfo.disableBattleMode && A == i++)
                            menuLen = 18 * (int)g_mainMenu.mainBattleGame.size();
#ifdef THEXTECH_ENABLE_SDL_NET
                        else if(s_show_online() && A == i++)
                            menuLen = 18 * (int)g_mainMenu.mainNetplay.size();
#endif
                        else if(g_config.enable_editor && A == i++)
                            menuLen = 18 * (int)g_mainMenu.mainEditor.size();
                        else if(A == i++)
                            menuLen = 18 * (int)g_mainMenu.mainOptions.size();
                        else if(A == i++)
                            menuLen = 18 * (int)g_mainMenu.mainExit.size();
                        else
                            break;

                        if(SharedCursor.X >= MenuX && SharedCursor.X <= MenuX + menuLen)
                        {
                            if(MenuMouseRelease && SharedCursor.Primary)
                                MenuMouseClick = true;

                            if(MenuCursor != A)
                            {
                                PlaySoundMenu(SFX_Slide);
                                MenuCursor = A;
                            }
                        }
                    }
                }
            }

            if(menuControls.Back && MenuCursorCanMove)
            {
                int quitKeyPos = s_quitKeyPos();

                if(XRender::TargetH < TinyScreenH)
                {
                    MenuCursorCanMove = false;
                    MenuMode = MENU_INTRO;
                    PlaySoundMenu(SFX_Slide);
                }
                else if(MenuCursor != quitKeyPos)
                {
                    MenuCursor = quitKeyPos;
                    MenuCursorCanMove = false;
                    PlaySoundMenu(SFX_Slide);
                }
            }
            else if((menuControls.Do && MenuCursorCanMove) || MenuMouseClick)
            {
                MenuCursorCanMove = false;
                // PlayerCharacter = 0;
                // PlayerCharacter2 = 0;

                int i = 0;
                if(MenuCursor == i++)
                {
                    PlaySoundMenu(SFX_Do);
                    MenuMode = MENU_1PLAYER_GAME;
                    menuPlayersNum = 1;
                    menuBattleMode = false;
                    MenuCursor = 0;
                    s_PrepareContentSelect();
                }
                else if(s_show_separate_2P() && MenuCursor == i++)
                {
                    PlaySoundMenu(SFX_Do);
                    MenuMode = MENU_2PLAYER_GAME;
                    menuPlayersNum = 2;
                    menuBattleMode = false;
                    MenuCursor = 0;

                    s_PrepareContentSelect();
                }
                else if(!g_gameInfo.disableBattleMode && MenuCursor == i++)
                {
                    PlaySoundMenu(SFX_Do);
                    MenuMode = MENU_BATTLE_MODE;
                    menuPlayersNum = 2;
                    menuBattleMode = true;
                    MenuCursor = 0;

                    s_PrepareContentSelect();
                }
#ifdef THEXTECH_ENABLE_SDL_NET
                else if(s_show_online() && MenuCursor == i++)
                {
                    PlaySoundMenu(SFX_Do);
                    MenuMode = MENU_NETPLAY;
                    MenuCursor = 0;

                    s_PrepareContentSelect();

                    XMessage::Connect();
                }
#endif
                else if(g_config.enable_editor && MenuCursor == i++)
                {
                    if(!GFX.EIcons.inited)
                    {
                        PlaySoundMenu(SFX_BlockHit);
                        g_MessageType = MESSAGE_TYPE_SYS_WARNING;
                        MessageText = fmt::format_ne(g_mainMenu.editorErrorMissingResources, "EditorIcons.png");
                        PauseGame(PauseCode::Message);
                    }
                    else if(!EditorCustom::loaded)
                    {
                        PlaySoundMenu(SFX_BlockHit);
                        g_MessageType = MESSAGE_TYPE_SYS_WARNING;
                        MessageText = fmt::format_ne(g_mainMenu.editorErrorMissingResources, "editor.ini");
                        PauseGame(PauseCode::Message);
                    }
                    else
                    {
                        PlaySoundMenu(SFX_Do);
                        MenuMode = MENU_EDITOR;
                        MenuCursor = 0;

                        s_PrepareContentSelect();
                    }
                }
                else if(MenuCursor == i++)
                {
                    PlaySoundMenu(SFX_Do);
                    MenuMode = MENU_NEW_OPTIONS;
                    OptionsScreen::Init();
                }
                else if(MenuCursor == i++)
                {
                    PlaySoundMenu(SFX_Do);
                    GracefulQuit(true);
                    return true;
                }

            }


            if(MenuMode == MENU_MAIN)
            {
                int quitKeyPos = s_quitKeyPos();

                if(MenuCursor > quitKeyPos)
                    MenuCursor = 0;

                if(MenuCursor < 0)
                    MenuCursor = quitKeyPos;
            }
        } // Main Menu

        // Character Select
        else if(MenuMode == MENU_CHARACTER_SELECT_NEW ||
                MenuMode == MENU_CHARACTER_SELECT_NEW_BM)
        {
            int ret = ConnectScreen::Logic();
            if(ret == -1)
            {
                // disconnect input methods for convenience
                Controls::ClearInputMethods();

                if(MenuMode == MENU_CHARACTER_SELECT_NEW_BM)
                {
                    MenuCursor = selWorld - 1;
                    MenuMode = MENU_BATTLE_MODE;
                }
                else
                {
                    MenuCursor = selSave - 1;
                    if(menuPlayersNum == 1)
                        MenuMode = MENU_SELECT_SLOT_1P;
                    else
                        MenuMode = MENU_SELECT_SLOT_2P;
                }

                MenuCursorCanMove = false;
            }
            else if(ret == 1)
            {
                if(MenuMode == MENU_CHARACTER_SELECT_NEW)
                {
                    // writing to m_value to avoid extra UpdateConfig hook
                    g_config.playstyle.m_value = s_episode_playstyle;
                    g_config.playstyle.m_set = ConfigSetLevel::ep_config;

                    if(g_config.speedrun_mode.m_set != ConfigSetLevel::cmdline)
                    {
                        g_config.speedrun_mode.m_value = s_episode_speedrun_mode;
                        g_config.speedrun_mode.m_set = ConfigSetLevel::ep_config;
                    }

                    MenuCursor = 0;
                    StartEpisode();
                    return true;
                }
                else if(MenuMode == MENU_CHARACTER_SELECT_NEW_BM)
                {
                    MenuCursor = 0;
                    StartBattleMode();
                    return true;
                }
            }
        }
#ifdef THEXTECH_ENABLE_SDL_NET
        else if(MenuMode == MENU_NETPLAY)
        {
            if(SharedCursor.Move)
            {
                For(A, 0, 10)
                {
                    if(SharedCursor.Y >= MenuY + A * 30 && SharedCursor.Y <= MenuY + A * 30 + 16)
                    {
                        int i = 0;
                        if(A == i++)
                            menuLen = 18 * (int)g_mainMenu.netplayJoinRoom.size();
                        else if(A == i++)
                            menuLen = 18 * (int)g_mainMenu.netplayCreateRoom.size();
                        else if(A == i++)
                            menuLen = 18 * (int)g_mainMenu.netplayServer.size();
                        else if(A == i++)
                            menuLen = 18 * (int)g_mainMenu.netplayNickname.size();
                        else
                            break;

                        if(SharedCursor.X >= MenuX && SharedCursor.X <= MenuX + menuLen)
                        {
                            if(MenuMouseRelease && SharedCursor.Primary)
                                MenuMouseClick = true;

                            if(MenuCursor != A)
                            {
                                PlaySoundMenu(SFX_Slide);
                                MenuCursor = A;
                            }
                        }
                    }
                }
            }

            if(menuControls.Back && MenuCursorCanMove)
            {
                int netplayPos = 1;
                if(s_show_separate_2P())
                    netplayPos++;
                if(!g_gameInfo.disableBattleMode)
                    netplayPos++;

                XMessage::Disconnect();

                MenuMode = MENU_MAIN;
                MenuCursor = netplayPos;
                MenuCursorCanMove = false;
                PlaySoundMenu(SFX_Slide);
            }
            else if((menuControls.Do && MenuCursorCanMove) || MenuMouseClick)
            {
                MenuCursorCanMove = false;

                if((MenuCursor == 0 || MenuCursor == 1) && (!XMessage::GetClientStatus() || XMessage::GetClientStatus()->client_state != XMessage::CLIENT_LOBBY))
                    PlaySoundMenu(SFX_BlockHit);
                else if(MenuCursor == 0)
                {
                    PlaySoundMenu(SFX_Do);

                    uint32_t room_key = XMessage::RoomFromString(TextEntryScreen::Run(g_mainMenu.netplayRoomKey));

                    if(room_key && XMessage::RequestFillRoomInfo(room_key))
                    {
                    }
                    else
                        PlaySoundMenu(SFX_BlockHit);
                }
                else if(MenuCursor == 1)
                {
                    PlaySoundMenu(SFX_Do);
                    MenuMode = MENU_NETPLAY_WORLD_SELECT;
                    menuPlayersNum = 1;
                    menuBattleMode = false;
                    MenuCursor = 0;
                }
                else if(MenuCursor == 2)
                {
                    PlaySoundMenu(SFX_Do);
                    g_netplayServer = TextEntryScreen::Run(g_mainMenu.netplayServer);
                    XMessage::Connect();
                }
                else if(MenuCursor == 3)
                {
                    PlaySoundMenu(SFX_Do);
                    g_netplayNickname = TextEntryScreen::Run(g_mainMenu.netplayNickname);
                }
            }

            if(MenuMode == MENU_NETPLAY)
            {
                if(MenuCursor > 3)
                    MenuCursor = 0;
                else if(MenuCursor < 0)
                    MenuCursor = 3;
            }
        }
#endif

        // World Select
        else if(MenuMode == MENU_1PLAYER_GAME || MenuMode == MENU_2PLAYER_GAME
#ifdef THEXTECH_ENABLE_SDL_NET
            || MenuMode == MENU_NETPLAY_WORLD_SELECT
#endif
            || MenuMode == MENU_BATTLE_MODE || MenuMode == MENU_EDITOR)
        {
            int ret = ContentSelectScreen::Logic();

            if(ret == -1)
            {
                MenuCursor = MenuMode - 1;

                if(MenuMode == MENU_BATTLE_MODE)
                {
                    MenuCursor = !s_show_separate_2P() ? 1 : 2;
                }
                else if(MenuMode == MENU_EDITOR)
                {
                    MenuCursor = 3;
                    if(!s_show_separate_2P())
                        MenuCursor--;
                    if(g_gameInfo.disableBattleMode)
                        MenuCursor--;
#ifdef THEXTECH_ENABLE_SDL_NET
                    if(s_show_online())
                        MenuCursor++;
#endif
                }

#ifdef THEXTECH_ENABLE_SDL_NET
                if(MenuMode == MENU_NETPLAY_WORLD_SELECT)
                {
                    MenuMode = MENU_NETPLAY;
                    MenuCursor = 1;
                }
                else
#endif
                {
                    MenuMode = MENU_MAIN;
                }
//'world select back
            }
            else if(ret == 1)
            {
                if(MenuMode == MENU_EDITOR)
                {
                    if(selWorld == (int)SelectWorld.size() - 1)
                    {
                        ClearWorld(true);
                        WorldName = TextEntryScreen::Run(g_mainMenu.editorPromptNewWorldName);
                        if(!WorldName.empty())
                        {
                            std::string fn = WorldName;
                            // eliminate bad characters
                            std::replace(fn.begin(), fn.end(), '/', '_');
                            std::replace(fn.begin(), fn.end(), '\\', '_');
                            std::replace(fn.begin(), fn.end(), '.', '_');
                            std::replace(fn.begin(), fn.end(), ':', '_');
                            std::replace(fn.begin(), fn.end(), '<', '_');
                            std::replace(fn.begin(), fn.end(), '>', '_');
                            std::replace(fn.begin(), fn.end(), '"', '_');
                            std::replace(fn.begin(), fn.end(), '|', '_');
                            std::replace(fn.begin(), fn.end(), '?', '_');
                            std::replace(fn.begin(), fn.end(), '*', '_');
                            // ensure uniqueness (but still case-sensitive for now)
                            while(DirMan::exists(AppPathManager::userWorldsRootDir() + fn))
                                fn += "2";
                            DirMan::mkAbsPath(AppPathManager::userWorldsRootDir() + fn);

                            std::string wPath = AppPathManager::userWorldsRootDir() + fn + "/world.wld";
                            if(ContentSelectScreen::editor_target_thextech)
                                wPath += "x";
                            g_recentWorldEditor = wPath;

                            SaveWorld(wPath, (ContentSelectScreen::editor_target_thextech) ? FileFormats::WLD_PGEX : FileFormats::WLD_SMBX64);

#ifdef PGE_NO_THREADING
                            FindWorlds();
#else
                            SDL_AtomicSet(&loading, 1);
                            loadingThread = SDL_CreateThread(FindWorldsThread, "FindWorlds", NULL);
                            SDL_DetachThread(loadingThread);
#endif
                        }
                    }
                    else if(!g_gameInfo.disableBattleMode && selWorld == (int)SelectWorld.size() - 2)
                    {
                        ClearWorld(true);
                        GameMenu = false;
                        LevelSelect = false;
                        BattleMode = true;
                        LevelEditor = true;
                        WorldEditor = false;
                        ClearLevel();
                        ClearGame();
                        SetupPlayers();

                        std::string lPath = AppPathManager::userBattleRootDir();
                        {
                            // find a single battle level to open first
                            std::vector<std::string> files;
                            DirMan battleLvls(lPath);
                            battleLvls.getListOfFiles(files, {(ContentSelectScreen::editor_target_thextech) ? ".lvlx" : ".lvl"});
                            if(files.empty())
                                lPath += "newbattle.lvl";
                            else
                                lPath += files[0];
                        }

                        if(!Files::fileExists(lPath))
                        {
                            if(ContentSelectScreen::editor_target_thextech)
                                lPath += "x";

                            SaveLevel(lPath, (ContentSelectScreen::editor_target_thextech) ? FileFormats::LVL_PGEX : FileFormats::LVL_SMBX64);
                        }

                        OpenLevel(lPath);
                        EditorBackup(); // EditorRestore() gets called when not in world editor

                        // todo: de-dupe with below
                        const std::string& wPath = SelectWorld[selWorld].WorldFilePath;
                        if(g_recentWorldEditor != wPath)
                        {
                            g_recentWorldEditor = wPath;
                            SaveConfig();
                        }

                        Integrator::setEditorFile(FileName);
                        editorScreen.ResetCursor();
                        editorScreen.active = false;
                        MouseRelease = false;
                        return true;
                    }
                    else
                    {
                        GameMenu = false;
                        LevelSelect = false;
                        BattleMode = false;
                        LevelEditor = true;
                        WorldEditor = true;
                        ClearLevel();
                        ClearGame();
                        SetupPlayers();
                        const std::string& wPath = SelectWorld[selWorld].WorldFilePath;
                        OpenWorld(wPath);
                        if(g_recentWorldEditor != wPath)
                        {
                            g_recentWorldEditor = wPath;
                            SaveConfig();
                        }
                        Integrator::setEditorFile(FileName);
                        editorScreen.ResetCursor();
                        editorScreen.active = false;
                        MouseRelease = false;
                        return true;
                    }
                }
                // battle mode
                else if(MenuMode == MENU_BATTLE_MODE)
                {
                    MenuMode = MENU_CHARACTER_SELECT_NEW_BM;
                    ConnectScreen::MainMenu_Start(2);
                }
#ifdef THEXTECH_ENABLE_SDL_NET
                // new room
                else if(MenuMode == MENU_NETPLAY_WORLD_SELECT)
                {
                    XMessage::RoomInfo room_info = XMessage::RoomInfo();
                    room_info.engine_hash = s_engineHash();
                    room_info.asset_hash = s_assetPackHash();
                    room_info.content_hash = SelectWorld[selWorld].lz4_content_hash;
                    XMessage::JoinNewRoom(room_info);
                }
#endif
                // enter save select
                else
                {
                    LoadCustomPlayerPreviews(Files::dirname(SelectWorld[selWorld].WorldFilePath).c_str());

                    FindSaves();
                    MenuMode *= MENU_SELECT_SLOT_BASE;
                    MenuCursor = 0;

                    s_change_save_item();
                }

                MenuCursorCanMove = false;
            }
        } // World select

        // Save Select
        else if(MenuMode == MENU_SELECT_SLOT_1P || MenuMode == MENU_SELECT_SLOT_2P)
        {
            if(SharedCursor.Move)
            {
                int old_item = MenuCursor;
                s_handleMouseMove(c_menuItemSavesDelete, MenuX, MenuY, 300, 30);

                if(MenuCursor != old_item)
                    s_change_save_item();
            }

            // new mode selection logic
            if(MenuCursor >= 0 && MenuCursor < maxSaveSlots && SaveSlotInfo[MenuCursor + 1].ConfigDefaults == 0)
            {
                // switch mode
                if(MenuCursorCanMove && (menuControls.Left || menuControls.Right) && s_episode_speedrun_mode == 0)
                {
                    if(s_episode_playstyle == Config_t::MODE_MODERN)
                        s_episode_playstyle = Config_t::MODE_CLASSIC;
                    else
                        s_episode_playstyle = Config_t::MODE_MODERN;

                    PlaySoundMenu(SFX_Climbing);
                    MenuCursorCanMove = false;
                }

                // only enter the menu if allowed by the global speedrun mode
                if(MenuCursorCanMove && menuControls.Home && g_config.speedrun_mode.m_set == ConfigSetLevel::cmdline)
                {
                    PlaySoundMenu(SFX_BlockHit);
                }
                // enter vanilla mode if an existing save slot
                else if(MenuCursorCanMove && menuControls.Home && SaveSlotInfo[MenuCursor + 1].Progress >= 0)
                {
                    int target_bugfixes = (SelectWorld[selWorld].bugfixes_on_by_default) ? Config_t::MODE_MODERN : Config_t::MODE_CLASSIC;

                    if(s_episode_playstyle == Config_t::MODE_VANILLA)
                        s_episode_playstyle = target_bugfixes;
                    else
                        s_episode_playstyle = Config_t::MODE_VANILLA;

                    PlaySoundMenu(SFX_Climbing);
                    MenuCursorCanMove = false;
                }
                // go to speedrun menu otherwise
                else if(MenuCursorCanMove && menuControls.Home)
                {
                    PlaySoundMenu(SFX_PlayerGrow);
                    selSave = MenuCursor + 1;

                    if(s_episode_speedrun_mode == 0)
                        MenuCursor = s_episode_playstyle;
                    else
                        MenuCursor = s_episode_speedrun_mode + 2;

                    MenuMode += MENU_SELECT_SLOT_ADVMODE_ADD;
                    MenuCursorCanMove = false;
                    MenuMouseClick = false;
                }
            }
            else if(MenuCursor >= 0 && MenuCursor < maxSaveSlots)
            {
                int save_configs = SaveSlotInfo[MenuCursor + 1].ConfigDefaults;

                if(save_configs > 0)
                {
                    s_episode_playstyle = save_configs - 1;
                    s_episode_speedrun_mode = 0;
                }
                else if(save_configs < 0)
                {
                    s_episode_speedrun_mode = -save_configs;
                    s_episode_playstyle = s_episode_speedrun_mode - 1;
                }
            }

            if(MenuCursorCanMove || MenuMouseClick)
            {
                if(menuControls.Back)
                {
//'save select back
                    UnloadCustomPlayerPreviews();

                    MenuMode /= MENU_SELECT_SLOT_BASE;

                    MenuCursorCanMove = false;
                    PlaySoundMenu(SFX_Slide);
                }
                else if(menuControls.Do || MenuMouseClick)
                {
                    if(MenuCursor == c_menuItemSavesCopy) // Copy the gamesave
                    {
                        PlaySoundMenu(SFX_Do);
                        MenuCursor = 0;
                        MenuMode += MENU_SELECT_SLOT_COPY_S1_ADD;
                        MenuCursorCanMove = false;
                    }
                    else if(MenuCursor == c_menuItemSavesDelete) // Delete the gamesave
                    {
                        PlaySoundMenu(SFX_Do);
                        MenuCursor = 0;
                        MenuMode += MENU_SELECT_SLOT_DELETE_ADD;
                        MenuCursorCanMove = false;
                    }
                    // block invalid speedrun continuation
                    else if(MenuCursor >= 0 && MenuCursor <= c_menuItemSavesEndList
                        && (int)g_config.speedrun_mode != 0 && g_config.speedrun_mode != -SaveSlotInfo[MenuCursor + 1].ConfigDefaults
                        && (SaveSlotInfo[MenuCursor + 1].ConfigDefaults != 0 || SaveSlotInfo[MenuCursor + 1].Progress >= 0))
                    {
                        PlaySoundMenu(SFX_BlockHit);
                        MenuCursorCanMove = false;
                    }
                    else if(MenuCursor >= 0 && MenuCursor <= c_menuItemSavesEndList) // Select the save slot, but still need to select players
                    {
                        selSave = MenuCursor + 1;

                        // warn the user of incompatibility if present
                        if(SaveSlotInfo[selSave].Progress < 0 && SelectWorld[selWorld].probably_incompatible)
                        {
                            PlaySoundMenu(SFX_Message);

                            g_MessageType = MESSAGE_TYPE_SYS_WARNING;
                            MessageText = g_mainMenu.warnEpCompat;
                            PauseGame(PauseCode::Message);
                        }

                        PlaySoundMenu(SFX_Do);

                        if(MenuMode == MENU_SELECT_SLOT_2P)
                            ConnectScreen::MainMenu_Start(2);
                        else if(s_prefer_modern_char_sel())
                            ConnectScreen::MainMenu_Start(1);
                        else
                            ConnectScreen::LegacyMenu_Start();

                        MenuMode = MENU_CHARACTER_SELECT_NEW;
                        MenuCursorCanMove = false;
                    }
                }
            }

            if(MenuMode == MENU_SELECT_SLOT_1P || MenuMode == MENU_SELECT_SLOT_2P)
            {
                if(MenuCursor > c_menuItemSavesDelete) MenuCursor = 0;
                if(MenuCursor < 0) MenuCursor = c_menuItemSavesDelete;
            }
        } // Save Slot Select

        // Save Select
        else if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S1 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S1 ||
                MenuMode == MENU_SELECT_SLOT_1P_COPY_S2 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S2)
        {
            if(SharedCursor.Move)
                s_handleMouseMove(c_menuItemSavesEndList, MenuX, MenuY, 300, 30);

            if(MenuCursorCanMove || MenuMouseClick)
            {
                if(menuControls.Back)
                {
//'save select back
                    if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S2 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S2)
                    {
                        MenuMode -= MENU_SELECT_SLOT_COPY_S1_ADD;
                    }
                    else
                    {
                        MenuMode -= MENU_SELECT_SLOT_COPY_S1_ADD;
                        MenuCursor = c_menuItemSavesCopy;
                    }

                    MenuCursorCanMove = false;
                    PlaySoundMenu(SFX_Do);
                }
                else if(menuControls.Do || MenuMouseClick)
                {
                    SDL_assert_release(IF_INRANGE(MenuCursor, 0, maxSaveSlots - 1));
                    int slot = MenuCursor + 1;

                    if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S1 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S1)
                    {
                        if(SaveSlotInfo[slot].Progress < 0)
                            PlaySoundMenu(SFX_BlockHit);
                        else
                        {
                            PlaySoundMenu(SFX_Do);
                            menuCopySaveSrc = slot;
                            MenuMode += MENU_SELECT_SLOT_COPY_S1_ADD;
                        }

                        MenuCursorCanMove = false;
                    }
                    else if(menuCopySaveSrc == slot)
                    {
                        PlaySoundMenu(SFX_BlockHit);
                        MenuCursorCanMove = false;
                    }
                    else
                    {
                        PlaySoundMenu(SFX_Transform);
                        menuCopySaveDst = slot;
                        CopySave(selWorld, menuCopySaveSrc, menuCopySaveDst);
                        FindSaves();
                        MenuMode -= MENU_SELECT_SLOT_COPY_S2_ADD;
                        MenuCursor = c_menuItemSavesCopy;
                        MenuCursorCanMove = false;
                    }
                }
            }

            if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S1 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S1 ||
               MenuMode == MENU_SELECT_SLOT_1P_COPY_S2 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S2)
            {
                if(MenuCursor > c_menuItemSavesEndList) MenuCursor = 0;
                if(MenuCursor < 0) MenuCursor = c_menuItemSavesEndList;
            }
        }

        // Delete gamesave
        else if(MenuMode == MENU_SELECT_SLOT_1P_DELETE || MenuMode == MENU_SELECT_SLOT_2P_DELETE)
        {
            if(SharedCursor.Move)
                s_handleMouseMove(c_menuItemSavesEndList, MenuX, MenuY, 300, 30);

            if(MenuCursorCanMove || MenuMouseClick)
            {
                if(menuControls.Back)
                {
//'save select back
                    MenuMode -= MENU_SELECT_SLOT_DELETE_ADD;
                    MenuCursor = c_menuItemSavesDelete;
                    PlaySoundMenu(SFX_Do);
                    MenuCursorCanMove = false;
                }
                else if(menuControls.Do || MenuMouseClick)
                {
                    MenuMode -= MENU_SELECT_SLOT_DELETE_ADD;
                    DeleteSave(selWorld, (MenuCursor + 1));
                    FindSaves();
                    MenuCursor = c_menuItemSavesDelete;
                    PlaySoundMenu(SFX_LavaMonster);
                    MenuCursorCanMove = false;
                }
            }

            if(MenuMode == MENU_SELECT_SLOT_1P_DELETE || MenuMode == MENU_SELECT_SLOT_2P_DELETE)
            {
                if(MenuCursor > c_menuItemSavesEndList) MenuCursor = 0;
                if(MenuCursor < 0) MenuCursor = c_menuItemSavesEndList;
            }
        }

        // Advanced mode selection
        else if(MenuMode == MENU_SELECT_SLOT_1P_ADVMODE || MenuMode == MENU_SELECT_SLOT_2P_ADVMODE)
        {
            if(SharedCursor.Move)
                s_handleMouseMove(5, MenuX, MenuY, MenuX, 30);

            if(MenuCursorCanMove || MenuMouseClick)
            {
                if(menuControls.Back)
                {
//'save select back
                    MenuMode -= MENU_SELECT_SLOT_ADVMODE_ADD;
                    MenuCursor = selSave - 1;
                    selSave = 0;
                    PlaySoundMenu(SFX_Slide);
                    MenuCursorCanMove = false;
                }
                else if(menuControls.Do || MenuMouseClick)
                {
                    if(MenuCursor < 3)
                    {
                        s_episode_playstyle = MenuCursor;
                        s_episode_speedrun_mode = 0;
                    }
                    else
                    {
                        s_episode_speedrun_mode = MenuCursor - 2;
                        s_episode_playstyle = s_episode_speedrun_mode - 1;
                    }

                    PlaySoundMenu(SFX_Do);
                    MenuMode -= MENU_SELECT_SLOT_ADVMODE_ADD;
                    MenuCursor = selSave - 1;
                    selSave = 0;
                    MenuCursorCanMove = false;
                }
            }

            if(MenuMode == MENU_SELECT_SLOT_1P_ADVMODE || MenuMode == MENU_SELECT_SLOT_2P_ADVMODE)
            {
                if(MenuCursor > 5) MenuCursor = 0;
                if(MenuCursor < 0) MenuCursor = 5;
            }
        }

        // Input Settings
        else if(MenuMode == MENU_INPUT_SETTINGS)
        {
            int ret = menuControls_Logic();
            if(ret == -1)
            {
                Controls::SaveConfig();
                MenuMode = MENU_NEW_OPTIONS;
                MenuCursorCanMove = false;
            }
        }

        // New Settings
        else if(MenuMode == MENU_NEW_OPTIONS)
        {
            if(OptionsScreen::Logic())
            {
                int optionsIndex = 1;
                if(s_show_separate_2P())
                    optionsIndex++;
                if(!g_gameInfo.disableBattleMode)
                    optionsIndex++;
#ifdef THEXTECH_ENABLE_SDL_NET
                if(s_show_online())
                    optionsIndex++;
#endif
                if(g_config.enable_editor)
                    optionsIndex++;
                MenuMode = MENU_MAIN;
                MenuCursor = optionsIndex;
                MenuCursorCanMove = false;
                PlaySoundMenu(SFX_Slide);
            }
        }
    }

    return false;
}

static constexpr int find_in_string(const char* haystack, const char* haystack_start, char needle)
{
    return (*haystack == '\0') ? -1 :
        ((*haystack == needle) ? haystack - haystack_start : find_in_string(haystack + 1, haystack_start, needle));
}

static constexpr bool in_string(const char* haystack, char needle)
{
    return find_in_string(haystack, haystack, needle) != -1;
}

static constexpr bool str_prefix(const char* string, const char* prefix)
{
    return (*prefix == '\0' || (*string == *prefix && str_prefix(string + 1, prefix + 1)));
}

static constexpr int find_in_string(const char* haystack, char needle)
{
    return find_in_string(haystack, haystack, needle);
}

void drawGameVersion(bool disable_git, bool git_only)
{
    constexpr bool is_release = !in_string(V_LATEST_STABLE, '-');
    constexpr bool is_main = str_prefix(V_BUILD_BRANCH, "main");
    constexpr bool is_stable = str_prefix(V_BUILD_BRANCH, "stable");
    constexpr bool is_head = str_prefix(V_BUILD_BRANCH, "HEAD");
    constexpr bool is_wip = str_prefix(V_BUILD_BRANCH, "wip-");

    constexpr bool is_dirty = in_string(V_BUILD_VER, '-');

    constexpr bool show_branch = (!is_main && !(is_release && is_stable) && !is_head);
    constexpr bool show_commit = (!is_release || (!is_main && !is_stable && !is_head));

    // show version
    if(!git_only)
        SuperPrintRightAlign("v" V_LATEST_STABLE, 5, XRender::TargetW - XRender::TargetOverscanX - 2, 2);

    // show branch
    if(show_branch && !disable_git)
    {
        int y = show_commit ? XRender::TargetH - 36 : XRender::TargetH - 18;

        if(is_wip)
        {
            // strip the "wip-"
            SuperPrintRightAlign(&V_BUILD_BRANCH[find_in_string(V_BUILD_BRANCH, '-') + 1], 5, XRender::TargetW - XRender::TargetOverscanX - 2, y);
        }
        else
            SuperPrintRightAlign(V_BUILD_BRANCH, 5, XRender::TargetW - XRender::TargetOverscanX - 2, y);
    }

    // show git commit
    if(show_commit && !disable_git)
    {
        if(is_dirty)
        {
            // only show -d, not -dirty
            SuperPrintRightAlign(find_in_string(V_BUILD_VER, '-') + 2 + 1, "#" V_BUILD_VER, 5, XRender::TargetW - XRender::TargetOverscanX - 2, XRender::TargetH - 18);
        }
        else
            SuperPrintRightAlign("#" V_BUILD_VER, 5, XRender::TargetW - XRender::TargetOverscanX - 2, XRender::TargetH - 18);
    }
}

static void s_drawGameTypeTitle(int x, int y)
{
    if(MenuMode == MENU_EDITOR)
        SuperPrint(g_mainMenu.mainEditor, 3, x, y, XTColorF(0.8_n, 0.8_n, 0.3_n));
    else if(menuBattleMode)
        SuperPrint(g_mainMenu.mainBattleGame, 3, x, y, XTColorF(0.3_n, 0.3_n, 1.0_n));
    else
    {
        // show "Play Episode" when at the save slot selecting and adjusting settings (not when the game was started in compat / speedrun mode)
        if(!s_show_separate_2P())
            SuperPrint(g_mainMenu.mainPlayEpisode, 3, x, y, XTColorF(1.0_n, 0.3_n, 0.3_n));
        else if(menuPlayersNum == 1)
            SuperPrint(g_mainMenu.main1PlayerGame, 3, x, y, XTColorF(1.0_n, 0.3_n, 0.3_n));
        else
            SuperPrint(g_mainMenu.mainMultiplayerGame, 3, x, y, XTColorF(0.3_n, 1.0_n, 0.3_n));
    }
}

static void s_drawGameSaves(int MenuX, int MenuY)
{
    int A;

    for(A = 1; A <= maxSaveSlots; A++)
    {
        int posY = MenuY - 30 + (A * 30);
        const auto& info = SaveSlotInfo[A];

        if(info.Progress >= 0)
        {
            // "SLOT {0} ... {1}%"
            std::string p = fmt::format_ne(g_mainMenu.gameSlotContinue, A, SaveSlotInfo[A].Progress);
            int len = SuperTextPixLen(p, 3);

            SuperPrint(p, 3, MenuX, posY);

            if(info.Stars > 0)
            {
                len += 4;
                XRender::renderTextureBasic(MenuX + len, posY + 1, GFX.Interface[5]);

                len += GFX.Interface[5].w + 4;
                XRender::renderTextureBasic(MenuX + len, posY + 2, GFX.Interface[1]);

                len += GFX.Interface[1].w + 4;
                SuperPrint(fmt::format_ne("{0}", info.Stars), 3, MenuX + len, posY);
            }
        }
        else
        {
            // "SLOT {0} ... NEW GAME"
            SuperPrint(fmt::format_ne(g_mainMenu.gameSlotNew, A), 3, MenuX, posY);
        }

        int mode_icon_X = MenuX + 340;
        int mode_icon_Y = MenuY - 34 + (A * 30);

        int save_configs = info.ConfigDefaults;
        if(save_configs == 0 && A == MenuCursor + 1 && (MenuMode == MENU_SELECT_SLOT_1P || MenuMode == MENU_SELECT_SLOT_2P))
        {
            save_configs = s_episode_playstyle + 1;
            if((int)s_episode_speedrun_mode != 0)
                save_configs = -s_episode_speedrun_mode;
            if((int)g_config.speedrun_mode != 0)
                save_configs = -g_config.speedrun_mode;
        }

        if(save_configs != 0)
        {
            uint16_t rot = 0;
            uint8_t op = 255;
            if(A == MenuCursor + 1)
            {
                rot = SDL_abs((int)(CommonFrame % 64) - 32);
                rot = rot - 16;
            }

            if(info.ConfigDefaults == 0)
                op = SDL_abs((int)(CommonFrame % 32) - 16) * 3 + 128;

            if(save_configs == Config_t::MODE_CLASSIC + 1)
            {
                XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFXNPC[NPCID_POWER_S3], 0, 0, 32, 32, rot, nullptr, X_FLIP_NONE, XTAlpha(op));
            }
            else if(save_configs == Config_t::MODE_VANILLA + 1)
            {
                XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFXNPC[NPCID_FODDER_S3], 0, 0, 32, 32, rot, nullptr, X_FLIP_NONE, XTAlpha(op));
            }
            else if(save_configs < 0)
            {
                XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFXNPC[NPCID_TIMER_S2], 0, 0, 32, 32, rot, nullptr, X_FLIP_NONE, XTAlpha(op));
                if(save_configs > -10)
                    XRender::renderTextureBasic(mode_icon_X + 12, mode_icon_Y + 12, GFX.Font1[-save_configs]);
            }
            else
            {
                if(GFX.EIcons.inited)
                    XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFX.EIcons, 0, 32*Icon::thextech, 32, 32, rot, nullptr, X_FLIP_NONE, XTAlpha(op));
                else
                    XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFXNPC[NPCID_ICE_POWER_S3], 0, 0, 32, 32, rot, nullptr, X_FLIP_NONE, XTAlpha(op));
            }
        }
    }

    if(MenuMode == MENU_SELECT_SLOT_1P || MenuMode == MENU_SELECT_SLOT_2P)
    {
        SuperPrint(g_mainMenu.gameCopySave, 3, MenuX, MenuY - 30 + (A * 30));
        A++;
        SuperPrint(g_mainMenu.gameEraseSave, 3, MenuX, MenuY - 30 + (A * 30));
    }


    if(MenuCursor < 0 || MenuCursor >= maxSaveSlots || (MenuMode != MENU_SELECT_SLOT_1P && MenuMode != MENU_SELECT_SLOT_2P))
        return;

    const auto& info = SaveSlotInfo[MenuCursor + 1];

    int infobox_x = XRender::TargetW / 2 - 240;
    int infobox_y = MenuY + 145 + c_menuSavesOffsetY;

    // forbid incompatible speedrun
    if((int)g_config.speedrun_mode != 0 && g_config.speedrun_mode != -info.ConfigDefaults
        && (info.ConfigDefaults != 0 || info.Progress >= 0))
    {
        XRender::renderRect(XRender::TargetW / 2 - 240, infobox_y, 480, 68, XTColorF(0, 0, 0, 1.0_n));
        SuperPrintScreenCenter("SAVE INCOMPATIBLE", 3, infobox_y + 4, XTColorF(1.0_n, 0.0_n, 0.0_n, 1.0_n));
        SuperPrintScreenCenter(fmt::format_ne("WITH SPEEDRUN MODE {0}", (int)g_config.speedrun_mode), 3, infobox_y + 24, XTColorF(1.0_n, 0.0_n, 0.0_n, 1.0_n));
        SuperPrintScreenCenter("(COMMAND LINE FLAG)", 3, infobox_y + 44, XTColorF(0.8_n, 0.8_n, 0.8_n, 1.0_n));
    }
    // initialize config
    else if(info.ConfigDefaults == 0)
    {
        XRender::renderRect(infobox_x, infobox_y, 480, 68, {0, 0, 0, 192});

        XTColor color;

        if(s_episode_playstyle == Config_t::MODE_MODERN)
            color = XTColorF(0.5_n, 0.8_n, 1.0_n);
        else if(s_episode_playstyle == Config_t::MODE_CLASSIC)
            color = XTColorF(1.0_n, 0.5_n, 0.5_n);
        else
            color = XTColorF(0.8_n, 0.5_n, 0.2_n);

        if(s_episode_speedrun_mode != 0)
        {
            SuperPrintScreenCenter("SPEEDRUN MODE " + std::to_string(s_episode_speedrun_mode), 3, infobox_y + 14, color);
        }
        else
        {
            // int target_bugfixes = (SelectWorld[selWorld].bugfixes_on_by_default) ? Config_t::MODE_MODERN : Config_t::MODE_CLASSIC;

            std::string playstyle_string;
            playstyle_string += g_options.playstyle.m_display_name;
            playstyle_string += ": ";

            if(s_episode_playstyle == Config_t::MODE_MODERN)
                playstyle_string += g_options.playstyle.m_enum_values[0].m_display_name;
            else if(s_episode_playstyle == Config_t::MODE_CLASSIC)
                playstyle_string += g_options.playstyle.m_enum_values[1].m_display_name;
            else
                playstyle_string += g_options.playstyle.m_enum_values[2].m_display_name;

            // if(target_bugfixes == g_config.playstyle)
            //     playstyle_string += " (Recommended)";

            SuperPrintScreenCenter(playstyle_string, 3, infobox_y + 14, color);

            // switch arrows
            menu_draw_infobox_switch_arrows(infobox_x, infobox_y);
        }

        const std::string& playstyle_description
            = (s_episode_playstyle == Config_t::MODE_MODERN) ?
                g_options.playstyle.m_enum_values[0].m_display_tooltip
            : (s_episode_playstyle == Config_t::MODE_CLASSIC) ?
                g_options.playstyle.m_enum_values[1].m_display_tooltip
            :
                g_options.playstyle.m_enum_values[2].m_display_tooltip;

        SuperPrintScreenCenter(playstyle_description, 5, infobox_y + 34, color);
    }
    // display fun save slot info
    else if(info.Progress >= 0)
    {
        int row_1 = infobox_y + 10;
        int row_2 = infobox_y + 42;
        int row_c = infobox_y + 26;

        bool hasFails = (g_config.enable_fails_tracking || info.FailsEnabled);
        bool show_timer = info.Time > 0 && (g_config.enable_playtime_tracking || info.ConfigDefaults < 0);
        bool show_score = (s_episode_playstyle != Config_t::MODE_VANILLA);

        // recenter if single row
        if(!show_timer && !hasFails)
            row_1 = infobox_y + 26;

        XRender::renderRect(infobox_x, infobox_y, 480, 68, {0, 0, 0, 127});

        // Temp string
        std::string t;

        // Score
        if(show_score)
        {
            int row_score = show_timer ? row_1 : row_c;
            SuperPrint(t = fmt::format_ne(g_mainMenu.phraseScore, info.Score), 3, infobox_x + 10, row_score);
        }

        // Gameplay Timer
        if(show_timer)
        {
            std::string t = GameplayTimer::formatTime(info.Time);

            if(t.size() > 9)
                t = t.substr(0, t.size() - 4);

            SuperPrint(fmt::format_ne(g_mainMenu.phraseTime, t), 3, infobox_x + 10, row_2);
        }

        // If demos off, put (l)ives and (c)oins on center
        int row_lc = (hasFails) ? row_1 : row_c;

        // Print lives on the screen (from gfx_update2.cpp)
        DrawLives(infobox_x + 272 + 32, row_lc, info.Lives, info.Hundreds, s_episode_playstyle == Config_t::MODE_VANILLA);

        // Print coins on the screen (from gfx_update2.cpp)
        int coins_x = infobox_x + 480 - 10 - 36 - 62;
        XRender::renderTextureBasic(coins_x + 16, row_lc, GFX.Interface[2]);
        XRender::renderTextureBasic(coins_x + 40, row_lc + 2, GFX.Interface[1]);
        SuperPrintRightAlign(t = std::to_string(info.Coins), 1, coins_x + 62 + 36, row_lc + 2);

        // Fails Counter
        if(hasFails)
            SuperPrintRightAlign(fmt::format_ne("{0}: {1}", g_gameInfo.fails_counter_title, info.Fails), 3, infobox_x + 480 - 10, row_2);
    }
}

void mainMenuDraw()
{
    int MenuX, MenuY;
    GetMenuPos(&MenuX, &MenuY);

#ifdef __3DS__
    XRender::setTargetLayer(2);
#endif

    // Render the permanent menu graphics (curtain, URL, logo)

    // URL
    if(XRender::TargetH >= SmallScreenH)
        XRender::renderTextureBasic(XRender::TargetW / 2 - GFX.MenuGFX[3].w / 2, XRender::TargetH - 24, GFX.MenuGFX[3]);

    bool at_main_title = (MenuMode == MENU_MAIN || MenuMode == MENU_INTRO);
    bool draw_in_asset_pack = at_main_title && s_startAssetPackTimer >= 2;

    if(!draw_in_asset_pack)
    {
        // Curtain
        // correction to loop the original asset properly
        int curtain_draw_w = GFX.MenuGFX[1].w;
        if(curtain_draw_w == 800)
            curtain_draw_w = 768;
        int curtain_horiz_reps = XRender::TargetW / curtain_draw_w + 2;

        for(int i = 0; i < curtain_horiz_reps; i++)
            XRender::renderTextureBasic(curtain_draw_w * i, 0, curtain_draw_w, GFX.MenuGFX[1].h, GFX.MenuGFX[1], 0, 0);

#ifdef __3DS__
        if(at_main_title)
            XRender::setTargetLayer(3);
#endif

        // game logo
        int LogoMode = 0;
        if(XRender::TargetH >= TinyScreenH || MenuMode == MENU_INTRO)
            LogoMode = 1;
        else if(MenuMode == MENU_MAIN)
            LogoMode = 2;

        if(LogoMode == 1)
        {
            // show at half opacity if not at main menu on a small screen
            XTColor logo_tint = (XRender::TargetH < SmallScreenH && MenuMode != MENU_INTRO && MenuMode != MENU_MAIN) ? XTAlpha(127) : XTColor();

            int logo_y = XRender::TargetH / 2 - 230;

            // place manually on small screens
            if(XRender::TargetH < TinyScreenH)
                logo_y = 16 + (XRender::TargetH - 320) / 2;
            else if(XRender::TargetH < SmallScreenH)
                logo_y = 16;
            else if(XRender::TargetH <= 600)
                logo_y = 40;

            XRender::renderTextureBasic(XRender::TargetW / 2 - GFX.MenuGFX[2].w / 2, logo_y, GFX.MenuGFX[2], logo_tint);
        }
        else if(LogoMode == 2)
        {
            SuperPrint(g_gameInfo.title, 3, XRender::TargetW / 2 - g_gameInfo.title.length()*9, 30);
        }
    }

#ifdef __3DS__
    if(MenuMode != MENU_NEW_OPTIONS)
        XRender::setTargetLayer(3);
#endif

    drawGameVersion(false, draw_in_asset_pack);


    // Menu Intro
    if(MenuMode == MENU_INTRO)
    {
        if((CommonFrame % 90) < 45)
            SuperPrintScreenCenter(g_mainMenu.introPressStart, 3, XRender::TargetH - 48 - (XRender::TargetH - 320) / 4);
    }

#ifndef PGE_NO_THREADING
    // loading (can't safely render)
    if(SDL_AtomicGet(&loading))
    {
        if(SDL_AtomicGet(&loadingProgrssMax) <= 0)
            SuperPrint(g_mainMenu.loading, 3, MenuX, MenuY);
        else
        {
            int progress = (SDL_AtomicGet(&loadingProgrss) * 100) / SDL_AtomicGet(&loadingProgrssMax);
            SuperPrint(fmt::format_ne("{0} {1}%", g_mainMenu.loading, progress), 3, MenuX, MenuY);
        }
    }
    // DO NOT DETACH THE BELOW ELSE STATEMENT FROM THE FOLLOWING SERIES OF IF CLAUSES
    else
#endif // #ifndef PGE_NO_THREADING
#ifdef THEXTECH_ENABLE_SDL_NET
    // loading (can't safely render)
    if(XMessage::GetClientStatus() == nullptr)
    {
        SuperPrint(g_mainMenu.loading, 3, MenuX, MenuY);
    }
    // DO NOT DETACH THE BELOW ELSE STATEMENT FROM THE FOLLOWING SERIES OF IF CLAUSES
    else
#endif // #ifdef THEXTECH_ENABLE_SDL_NET
    // Main menu
        if(MenuMode == MENU_MAIN)
    {
        int i = 0;
        SuperPrint(s_show_separate_2P() ? g_mainMenu.main1PlayerGame : g_mainMenu.mainPlayEpisode, 3, MenuX, MenuY+30*(i++));
        if(s_show_separate_2P())
            SuperPrint(g_mainMenu.mainMultiplayerGame, 3, MenuX, MenuY+30*(i++));
        if(!g_gameInfo.disableBattleMode)
            SuperPrint(g_mainMenu.mainBattleGame, 3, MenuX, MenuY+30*(i++));
#ifdef THEXTECH_ENABLE_SDL_NET
        if(s_show_online())
            SuperPrint(g_mainMenu.mainNetplay, 3, MenuX, MenuY+30*(i++));
#endif
        if(g_config.enable_editor)
            SuperPrint(g_mainMenu.mainEditor, 3, MenuX, MenuY+30*(i++));
        SuperPrint(g_mainMenu.mainOptions, 3, MenuX, MenuY+30*(i++));
        SuperPrint(g_mainMenu.mainExit, 3, MenuX, MenuY+30*(i++));
        XRender::renderTextureBasic(MenuX - 20, MenuY + (MenuCursor * 30), GFX.MCursor[0]);
    }
    // Character select
    else if(MenuMode == MENU_CHARACTER_SELECT_NEW ||
            MenuMode == MENU_CHARACTER_SELECT_NEW_BM)
    {
        s_drawGameTypeTitle(MenuX, MenuY - 70);
        const auto& world_list = (MenuMode == MENU_CHARACTER_SELECT_NEW) ? SelectWorld : SelectBattle;
        SuperPrint(world_list[selWorld].WorldName, 3, MenuX, MenuY - 40, XTColorF(0.6_n, 1.0_n, 1.0_n));

        ConnectScreen::Render();
    }
#ifdef THEXTECH_ENABLE_SDL_NET
    // NetPlay main menu
    else if(MenuMode == MENU_NETPLAY)
    {
        int i = 0;
        XTColor c;
        XTColor s;

        if(XMessage::GetClientStatus() && XMessage::GetClientStatus()->client_state == XMessage::CLIENT_LOBBY)
            s = {200, 255, 200};
        else
        {
            s = {255, 200, 200};
            c = {127, 127, 127};
        }

        SuperPrint(g_mainMenu.netplayJoinRoom, 3, MenuX, MenuY+30*(i++), c);
        SuperPrint(g_mainMenu.netplayCreateRoom, 3, MenuX, MenuY+30*(i++), c);
        SuperPrint(g_mainMenu.netplayServer + ' ' + g_netplayServer, 3, MenuX, MenuY+30*(i++), s);
        SuperPrint(g_mainMenu.netplayNickname + ' ' + g_netplayNickname, 3, MenuX, MenuY+30*(i++));
        XRender::renderTextureBasic(MenuX - 20, MenuY + (MenuCursor * 30), GFX.MCursor[0]);
    }
#endif

    // Episode / Level selection
    else if(MenuMode == MENU_1PLAYER_GAME || MenuMode == MENU_2PLAYER_GAME
#ifdef THEXTECH_ENABLE_SDL_NET
        || MenuMode == MENU_NETPLAY_WORLD_SELECT
#endif
        || MenuMode == MENU_BATTLE_MODE || MenuMode == MENU_EDITOR)
    {
        s_drawGameTypeTitle(MenuX, MenuY - 70);
        ContentSelectScreen::Render();
    }

    else if(MenuMode == MENU_SELECT_SLOT_1P || MenuMode == MENU_SELECT_SLOT_2P) // Save Select
    {
        s_drawGameTypeTitle(MenuX, MenuY - 70);
        SuperPrint(SelectWorld[selWorld].WorldName, 3, MenuX, MenuY - 40, XTColorF(0.6_n, 1.0_n, 1.0_n));
        s_drawGameSaves(MenuX, MenuY);
        XRender::renderTextureBasic(MenuX - 20, MenuY + (MenuCursor * 30), GFX.MCursor[0]);
    }

    else if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S1 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S1 ||
            MenuMode == MENU_SELECT_SLOT_1P_COPY_S2 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S2) // Copy save
    {
        s_drawGameTypeTitle(MenuX, MenuY - 70);
        SuperPrint(SelectWorld[selWorld].WorldName, 3, MenuX, MenuY - 40, XTColorF(0.6_n, 1.0_n, 1.0_n));
        s_drawGameSaves(MenuX, MenuY);

        if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S1 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S1)
            SuperPrint(g_mainMenu.gameSourceSlot, 3, MenuX, MenuY + c_menuSavesFooterHint, XTColorF(0.7_n, 0.7_n, 1.0_n));
        else if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S2 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S2)
            SuperPrint(g_mainMenu.gameTargetSlot, 3, MenuX, MenuY + c_menuSavesFooterHint, XTColorF(0.7_n, 1.0_n, 0.7_n));

        if(MenuMode == MENU_SELECT_SLOT_1P_COPY_S2 || MenuMode == MENU_SELECT_SLOT_2P_COPY_S2)
        {
            XRender::renderTextureBasic(MenuX - 20, MenuY + ((menuCopySaveSrc - 1) * 30), GFX.MCursor[0]);
            XRender::renderTextureBasic(MenuX - 20, MenuY + (MenuCursor * 30), GFX.MCursor[3]);
        }
        else
            XRender::renderTextureBasic(MenuX - 20, MenuY + (MenuCursor * 30), GFX.MCursor[0]);
    }

    else if(MenuMode == MENU_SELECT_SLOT_1P_DELETE || MenuMode == MENU_SELECT_SLOT_2P_DELETE) // Delete save
    {
        s_drawGameTypeTitle(MenuX, MenuY - 70);
        SuperPrint(SelectWorld[selWorld].WorldName, 3, MenuX, MenuY - 40, XTColorF(0.6_n, 1.0_n, 1.0_n));
        s_drawGameSaves(MenuX, MenuY);

        SuperPrint(g_mainMenu.gameEraseSlot, 3, MenuX, MenuY + c_menuSavesFooterHint, XTColorF(1.0_n, 0.7_n, 0.7_n));

        XRender::renderTextureBasic(MenuX - 20, MenuY + (MenuCursor * 30), GFX.MCursor[0]);
    }

    else if(MenuMode == MENU_SELECT_SLOT_1P_ADVMODE || MenuMode == MENU_SELECT_SLOT_2P_ADVMODE) // Advanced mode select
    {
        s_drawGameTypeTitle(MenuX, MenuY - 70);
        SuperPrint(SelectWorld[selWorld].WorldName, 3, MenuX, MenuY - 40, XTColorF(0.6_n, 1.0_n, 1.0_n));

        int A = 0;

        SuperPrint("Modern Game", 3, MenuX, MenuY + (A++ * 30), XTColorF(0.5_n, 0.7_n, 1.0_n));
        SuperPrint("Classic Game", 3, MenuX, MenuY + (A++ * 30), XTColorF(1.0_n, 0.7_n, 0.7_n));
        SuperPrint("Vanilla Game", 3, MenuX, MenuY + (A++ * 30), XTColorF(0.8_n, 0.5_n, 0.2_n));
        SuperPrint("Speedrun Mode 1", 3, MenuX, MenuY + (A++ * 30), XTColorF(0.5_n, 0.7_n, 1.0_n));
        SuperPrint("Speedrun Mode 2", 3, MenuX, MenuY + (A++ * 30), XTColorF(1.0_n, 0.7_n, 0.7_n));
        SuperPrint("Speedrun Mode 3", 3, MenuX, MenuY + (A++ * 30), XTColorF(0.8_n, 0.5_n, 0.2_n));

        XRender::renderTextureBasic(MenuX - 20, MenuY + (MenuCursor * 30), GFX.MCursor[0]);
    }

    // Player controls setup
    else if(MenuMode == MENU_INPUT_SETTINGS)
    {
        menuControls_Render();
    }

    // New options screen
    else if(MenuMode == MENU_NEW_OPTIONS)
    {
#ifdef __3DS__
        // draw options screen (only) in top draw plane
        XRender::setTargetLayer(3);
#endif

        OptionsScreen::Render();
    }

    // fade to / from asset pack screen
    if(s_can_enter_ap_screen() && s_startAssetPackTimer > 0)
    {
        ScreenAssetPack::DrawBackground(s_startAssetPackTimer);
        g_levelScreenFader.clearFader();
    }

    // Mouse cursor
    XRender::renderTextureBasic(int(SharedCursor.X), int(SharedCursor.Y), GFX.ECursor[2]);
}


================================================
FILE: src/main/menu_main.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef MENU_MAIN_H
#define MENU_MAIN_H

#include <string>
#include <memory>
#include <stdint.h>

#include "global_constants.h"
#include "std_picture.h"
#include "range_arr.hpp"

//Public Type SelectWorld
struct SelectWorld_t
{
//    WorldName As String
    std::string WorldName;
//    WorldPath As String
    // std::string WorldPath;
//    WorldFile As String (NEW: Full filepath, or <URL for remote assets)
    std::string WorldFilePath;

    // NEW: repo annotations
    std::string CreatorName;
    std::string Description;
    std::unique_ptr<StdPicture> screenshot;
    uint32_t ReleaseDate = 0; // reserved for now

//    blockChar(1 To numCharacters) As Boolean
    RangeArrI<bool, 1, numCharacters, false> blockChar;
// EXTRA:
    bool bugfixes_on_by_default = false;
    bool editable = false;
    bool disabled = false;
    bool probably_incompatible = false;

#ifdef THEXTECH_ENABLE_SDL_NET
    // content hash of packed episode
    uint32_t lz4_content_hash = 0;
#endif
//End Type
};

extern int NumSelectWorld;
extern int NumSelectWorldEditable; // NEW
extern int NumSelectBattle; // NEW
extern std::vector<SelectWorld_t> SelectWorld;
extern std::vector<SelectWorld_t> SelectBattle; // NEW

// Menu modes
enum
{
    // Main intro
    MENU_INTRO = -1,
    // Main menu
    MENU_MAIN = 0,
    // One player game episode select
    MENU_1PLAYER_GAME = 1,
    // Two player game episode select
    MENU_2PLAYER_GAME = 2,
    // Battle mode level select
    MENU_BATTLE_MODE = 4,
#ifdef THEXTECH_ENABLE_SDL_NET
    // NetPlay welcome menu
    MENU_NETPLAY = 5,
    // NetPlay episode select
    MENU_NETPLAY_WORLD_SELECT = 6,
#endif
    // Options menu
    // MENU_OPTIONS = 3, // FULLY UNUSED
    // New options menu
    MENU_NEW_OPTIONS = 8,
    // Editor mode episode select
    MENU_EDITOR = 9,

#if 0
    // Character select for single player game
    MENU_CHARACTER_SELECT_1P    = 100,
    // Character select for two player game, step 1
    MENU_CHARACTER_SELECT_2P_S1 = 200,
    // Character select for two player game, step 2
    MENU_CHARACTER_SELECT_2P_S2 = 300,
    // Character select for battle game, step 1
    MENU_CHARACTER_SELECT_BM_S1 = 400,
    // Character select for battle game, step 2
    MENU_CHARACTER_SELECT_BM_S2 = 500,

    MENU_CHARACTER_SELECT_BASE  = MENU_CHARACTER_SELECT_1P,
    MENU_CHARACTER_SELECT_BASE_END = MENU_CHARACTER_SELECT_BM_S2,
#endif

    // New character select for main game
    MENU_CHARACTER_SELECT_NEW    = 1000,
    MENU_CHARACTER_SELECT_NEW_BM = 1001,

    MENU_INPUT_SETTINGS = 30,

    MENU_SELECT_SLOT_BASE = 10,
    // Select game slot for single-player game
    MENU_SELECT_SLOT_1P = 10,
    // Select game slot for two player game
    MENU_SELECT_SLOT_2P = 20,

    MENU_SELECT_SLOT_1P_COPY_S1 = 11,
    MENU_SELECT_SLOT_2P_COPY_S1 = 21,
    MENU_SELECT_SLOT_COPY_S1_ADD = 1,
    MENU_SELECT_SLOT_1P_COPY_S2 = 12,
    MENU_SELECT_SLOT_2P_COPY_S2 = 22,
    MENU_SELECT_SLOT_COPY_S2_ADD = 2,

    MENU_SELECT_SLOT_1P_DELETE = 13,
    MENU_SELECT_SLOT_2P_DELETE = 23,
    MENU_SELECT_SLOT_DELETE_ADD = 3,

    MENU_SELECT_SLOT_1P_ADVMODE = 14,
    MENU_SELECT_SLOT_2P_ADVMODE = 24,
    MENU_SELECT_SLOT_ADVMODE_ADD = 4,

    MENU_SELECT_SLOT_END = 30,
};

struct MainMenuContent
{
    std::string introPressStart;

    std::string mainPlayEpisode;
    std::string main1PlayerGame;
    std::string mainMultiplayerGame;
    std::string mainBattleGame;
    std::string mainEditor;
    std::string mainOptions;
    std::string mainExit;

    std::string loading;

    std::string languageName;
    std::string pluralRules;

    std::string editorBattles;
    std::string editorNewWorld;
    std::string editorMakeFor;
    std::string editorErrorMissingResources;
    std::string editorPromptNewWorldName;

    std::string gameNoEpisodesToPlay;
    std::string gameNoBattleLevels;
    std::string gameBattleRandom;

    std::string warnEpCompat;

    std::string gameSlotContinue;
    std::string gameSlotNew;

    std::string gameCopySave;
    std::string gameEraseSave;

    std::string gameSourceSlot;
    std::string gameTargetSlot;
    std::string gameEraseSlot;

    std::string phraseScore;
    std::string phraseTime;

    // Battle
    std::string errorBattleNoLevels;

    // Options
    std::string optionsRestartEngine;

    // ConnectScreen
    std::string selectCharacter;

    // Controls menus
    std::string controlsTitle;
    std::string controlsConnected;
    std::string controlsDeleteKey;
    std::string controlsDeviceTypes;
    std::string controlsInUse;
    std::string controlsNotInUse;

    std::string controlsActivateProfile;
    std::string controlsRenameProfile;
    std::string controlsDeleteProfile;
    std::string controlsPlayerControls;
    std::string controlsCursorControls;
    std::string controlsEditorControls;
    std::string controlsHotkeys;

    std::string controlsOptionRumble;
    std::string controlsOptionBatteryStatus;
    std::string controlsOptionAltMenuControls;

    std::string wordProfiles;
    std::string wordButtons;
    std::string controlsReallyDeleteProfile;
    std::string controlsNewProfile;

    // General purpose
    std::string wordYes;
    std::string wordNo;
    std::string wordOkay;
    std::string caseNone;
    std::string wordOn;
    std::string wordOff;
    std::string wordShow;
    std::string wordHide;
    std::string wordPlayer;
    std::string wordProfile;
    std::string wordBack;
    std::string wordResume;
    std::string wordWaiting;
    std::string abbrevMilliseconds;

#ifdef THEXTECH_ENABLE_SDL_NET
    // NetPlay
    std::string mainNetplay;
    std::string netplayRoomKey;
    std::string netplayJoinRoom;
    std::string netplayCreateRoom;
    std::string netplayLeaveRoom;
    std::string netplayServer;
    std::string netplayNickname;
#endif
};

extern MainMenuContent g_mainMenu;

extern void initMainMenu();

extern bool mainMenuUpdate();
extern void mainMenuDraw();

extern int mainMenuPlaystyle();

void GetMenuPos(int* MenuX, int* MenuY);

#endif // MENU_MAIN_H


================================================
FILE: src/main/outro_loop.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include <Logger/logger.h>
#include <Integrator/integrator.h>

#include "../globals.h"
#include "../game_main.h"
#include "../core/render.h"
#include "../controls.h"
#include "../npc.h"
#include "../blocks.h"
#include "../collision.h"
#include "../effect.h"
#include "../player.h"
#include "../graphics.h"
#include "../sound.h"
#include "../main/trees.h"
#include "../script/luna/luna.h"
#include "layers.h"
#include "game_info.h"
#include "outro_loop.h"

OutroContent g_outroScreen;

void initOutroContent()
{
    g_outroScreen.gameCredits = "Game credits:";
    g_outroScreen.engineCredits = "Engine credits:";

    g_outroScreen.originalBy = "Original VB6 code By:";
    g_outroScreen.nameAndrewSpinks = "Andrew Spinks";

    g_outroScreen.cppPortDevelopers = "C++ port developers:";
    g_outroScreen.nameVitalyNovichkov = "Vitaly Novichkov";

    g_outroScreen.qualityControl = "Quality Control:";

    g_outroScreen.psVitaPortBy = "PS Vita Port By:";

    g_outroScreen.levelDesign = "Level Design:";

    g_outroScreen.customSprites = "Custom Sprites:";

    g_outroScreen.specialThanks = "Special Thanks:";
}


void DoCredits(bool quit)
{
    // CreditChop and CreditOffsetY were previously floats, now they are ints measured in tenths

    if(GameMenu)
        return;

    int TargetH_half = XRender::TargetH / 2;

    int shrink = vScreen[1].Top;

    CreditOffsetY -= 8;
//    if(CreditOffsetY > ScreenH || CreditOffsetY + CreditTotalHeight < 0)
//    {}

    // Closing screen
    if((CreditOffsetY + CreditTotalHeight * 10) < -shrink * 10)
    {
        if(musicPlaying)
        {
            FadeOutMusic(11000);
            musicPlaying = false;
        }

        // CreditChop += 0.4f;
        CreditChop += 4;
        if(CreditChop >= TargetH_half * 10)
        {
            CreditChop = TargetH_half * 10;
            EndCredits++;
            if(EndCredits == TargetH_half)
            {
                SetupCredits();
                GameOutroDoQuit = true;
                GameMenu = true;
            }
        }
        else
            EndCredits = 0;
    }

        // Opening screen
    else if(CreditChop > shrink * 10 && CreditOffsetY + CreditTotalHeight * 10 > 0)
    {
        // CreditChop -= 2.0f;
        CreditChop -= 20;
        if(CreditChop < shrink * 10)
            CreditChop = shrink * 10;

        if(CreditChop < TargetH_half * 10 - 500 && !musicPlaying)
        {
            if(bgMusic[0] <= 0) // Play default music if no music set in outro level
            {
                musicName = "tmusic";
                PlayMusic("tmusic", 2000);
                musicPlaying = true;
            }
            else // Otherwise, play the music that set by level
                StartMusic(0, 2000);
        }
    }

    if(CreditChop <= shrink * 10 || EndCredits > 0)
    {
//        for(A = 1; A <= 2; A++) // Useless loop
//        {
        if(quit)
        {
            CreditChop = TargetH_half * 10;
            EndCredits = 0;
            XRender::clearBuffer();
            SetupCredits();
            GameMenu = true;
            GameOutroDoQuit = true;
        }
//        }
    }
}

void OutroLoop()
{
    lunaLoop();
    Controls::Update(false);
    Integrator::sync();
    bool quit = l_SharedControls.QuitCredits;

    for(int i = 0; i < l_screen->player_count; i++)
        quit |= Controls::g_RawControls[i].Start;

    if(g_gameInfo.outroDeadMode)
    {
        ClearTriggeredEvents();
        UpdateLayers();
        UpdateNPCs();
        UpdateBlocks();
        UpdateEffects();
        // UpdatePlayer();
        DoCredits(quit);
        UpdateGraphics();
        UpdateSound();
        UpdateEvents();

        if(GameOutroDoQuit) // Don't unset the GameOutro before GFX update, otherwise a glitch will happen
        {
            GameOutro = false;
            GameOutroDoQuit = false;
        }
        return;
    }

    for(int A = 1; A <= numPlayers; A++)
    {
        auto &pp = Player[A];
        pp.Controls = Controls_t();

        if(g_gameInfo.outroWalkDirection < 0)
            pp.Controls.Left = true;
        else if(g_gameInfo.outroWalkDirection > 0)
            pp.Controls.Right = true;

        if(pp.Controls.Left)
            pp.Direction = -1;
        if(pp.Controls.Right)
            pp.Direction = 1;

        Location_t tempLocation = pp.Location;
        // tempLocation = pp.Location; // Why here was the duplicated location assignment?
        tempLocation.SpeedX = 0;
        tempLocation.SpeedY = 0;
        num_t pp_bottom = pp.Location.Y + pp.Location.Height;
        tempLocation.Y = pp_bottom - 8;
        tempLocation.Height = pp.Mount == 1 ? 50 : 25;
        tempLocation.Width = 16;

        if(pp.Location.SpeedX > 0)
            tempLocation.X = (pp.Location.X + pp.Location.Width) + 20;
        else
            tempLocation.X = pp.Location.X - (tempLocation.Width + 20);

        if(g_gameInfo.outroAutoJump)
        {
            // int64_t fBlock = 0;
            // int64_t lBlock = 0;
            // fBlock = FirstBlock[long(tempLocation.X / 32) - 1];
            // lBlock = LastBlock[long((tempLocation.X + tempLocation.Width) / 32.0) + 1];
            // blockTileGet(tempLocation, fBlock, lBlock);
            // if(!BlocksSorted)
            // {
            //     fBlock = 1;
            //     lBlock = numBlock;
            // }

            bool doJump = true;

            for(const Block_t& bb : treeFLBlockQuery(tempLocation, SORTMODE_NONE))
            {
//                if(tempLocation.X + tempLocation.Width >= Block[B].Location.X &&
//                   tempLocation.X <= Block[B].Location.X + Block[B].Location.Width &&
//                   tempLocation.Y + tempLocation.Height >= Block[B].Location.Y &&
//                   tempLocation.Y <= Block[B].Location.Y + Block[B].Location.Height)
                if(CheckCollision(tempLocation, bb.Location))
                {
                    if(!BlockNoClipping[bb.Type] &&
                       !bb.Invis && !bb.Hidden &&
                       !(BlockIsSizable[bb.Type] && bb.Location.Y < pp_bottom - 3))
                    {
                        doJump = false;
                        break;
                    }
                }
            }

            // D_pLogDebug("Player %d jumped: doJump %d, ppJump: %d", A, doJump ? 1 : 0, pp.Jump);
            if(doJump || pp.Jump > 0)
                pp.Controls.Jump = true;
        }
    }

    ClearTriggeredEvents();
    UpdateLayers();
    UpdateNPCs();
    UpdateBlocks();
    UpdateEffects();
    UpdatePlayer();
    DoCredits(quit);
    UpdateGraphics();
    UpdateSound();
    UpdateEvents();

    if(GameOutroDoQuit) // Don't unset the GameOutro before GFX update, otherwise a glitch will happen
    {
        GameOutro = false;
        GameOutroDoQuit = false;
    }
}

void AddCredit(const std::string &newCredit)
{
    numCredits += 1;
    if(numCredits > maxCreditsLines)
    {
        numCredits = maxCreditsLines;
        pLogWarning("Can't add more credits lines: max limit has been excited (%d linex maximum)", maxCreditsLines);
        return;
    }

    auto &c = Credit[numCredits];
    c.Text = STRINGINDEX_NONE;

    SetS(c.Text, newCredit);
}

void SetupCredits()
{
    int A = 0;
    numCredits = 0;

    AddCredit(g_gameInfo.title);

    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
#ifdef ENABLE_OLD_CREDITS
    AddCredit("Created By:");
#else
    if(!g_gameInfo.creditsGame.empty())
    {
        AddCredit(g_outroScreen.gameCredits);
        for(auto &s : g_gameInfo.creditsGame)
            AddCredit(s);
        AddCredit("");
        AddCredit("");
        AddCredit(g_outroScreen.engineCredits);
        AddCredit("");
    }

    AddCredit(g_outroScreen.originalBy);
#endif
    AddCredit("");
    AddCredit(g_outroScreen.nameAndrewSpinks);
    AddCredit("'Redigit'"); // Author of original VB6 Engine (2009-2011)
    AddCredit("");
    AddCredit("");
#ifndef ENABLE_OLD_CREDITS
    AddCredit(g_outroScreen.cppPortDevelopers);
    AddCredit("");
    AddCredit(g_outroScreen.nameVitalyNovichkov);
    AddCredit("'Wohlstand'");
    AddCredit("");
    AddCredit("ds-sloth"); // For the major contribution to the code and becoming a co-developer
    AddCredit("");
    AddCredit("");
    AddCredit(g_outroScreen.qualityControl);
    AddCredit("");
    AddCredit("0lhi"); // Significant contribution to TheXTech development, testing, improvement process (2021-2024)
    AddCredit("");
    AddCredit("");
#endif
#ifdef VITA
    AddCredit(g_outroScreen.psVitaPortBy);
    AddCredit("");
    AddCredit("Axiom");
    AddCredit("");
    AddCredit("");
#endif

    if(numWorldCredits > 0)
    {
        AddCredit(g_outroScreen.levelDesign);
        AddCredit("");
        for(A = 1; A <= numWorldCredits; A++)
            AddCredit(WorldCredits[A]);
        AddCredit("");
        AddCredit("");
        AddCredit("");
    }

    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit(g_outroScreen.customSprites);
    AddCredit("");
    AddCredit("Blue");
    AddCredit("Iceman404");
    AddCredit("LuigiFan");
    AddCredit("NameUser");
    AddCredit("Redigit");
    AddCredit("Valtteri");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit(g_outroScreen.specialThanks);
#ifndef ENABLE_OLD_CREDITS
    AddCredit("");
    AddCredit("Kevsoft");
    AddCredit("Rednaxela");
    AddCredit("Aero");
    AddCredit("Kley");
    AddCredit("ShadowYoshi (Joey)");
    AddCredit("ZeZeinzer"); // Android testing, touchscreen controller button pictures
    AddCredit("LucyZocker"); // Android testing
    AddCredit("DavFar"); // Spanish translation of the ReadMe
    AddCredit("Yingchun Soul"); // Idea for individual iceball shooting SFX and contribution with the "frozen NPC breaking" SFX
    AddCredit("MrDoubleA"); // Contribution with the "NPC got frozen" SFX
    AddCredit("Slash-18"); // Contribution with the better iceball shooting SFX
    AddCredit("sl4cer");   // For reporting several issues while livestreaming (2021) (also known as draena)
    AddCredit("Eclipsed"); // For the help to verify and polish the speed-run mode (2021)
    AddCredit("RunninPigeon"); // For Nintendo Switch alpha testing on hardware (Formerly "ThatRoadRunnerfan727 (Matthew)")
    AddCredit("RMN Community"); // For Quality Episodes that allowed us to refine the Engine
    AddCredit("Savby"); // For important design work on the character select screen (ConnectScreen)
    AddCredit("Otabo"); /* For the "Sarasaland Adventure" projects (both 1 and 2) that was being widely used in
                           tests and debugs: and also, they introduced the SMBX to me (Vitaliy), in 2013
                           and inspired me to all my future projects (Moondust Project and TheXTech). */
    AddCredit("Krissy Silvermoon"); // For testing and design feedback since 2021 until at least 2025
    AddCredit("Sapphire Bullet Bill"); // For testing and gameplay feedback since 2022 until at least 2025
    AddCredit("Bubble"); // For bugtesting in 2021-2022
    AddCredit("Trickii"); // For extensive bugtesting in 2024
    AddCredit("AntonioGZZ96"); // For careful bugtesting in 2024
    AddCredit("ddrsoul"); // For sharing the engine with the PortMaster community (2024)
    AddCredit("ChaikaWiFika"); // For the help with the testing/debugging on Intel Iris Xe GPU in 2025
    AddCredit("Bloxen"); // For help testing and improving the 38A powerups (2025)
    AddCredit("Liebning"); // For careful bugtesting in 2025
    AddCredit("55jedat555"); // For long-term research support regarding SMBX 1.3 bugs, from ~2023 until at least 2025
    // --- P.S. Put all next lines above THIS comment line. ---
#endif
    AddCredit("");
    AddCredit("4matsy");
    AddCredit("AndyDark");
    AddCredit("Bikcmp");
    AddCredit("Blue");
    AddCredit("Captain Obvious");
    AddCredit("CaptainTrek");
    AddCredit("Chase");
    AddCredit("Coldwin");
    AddCredit("CrystalMike");
    AddCredit("DarkMatt");
    AddCredit("FallingSnow");
    AddCredit("Garro");
    AddCredit("Knuckles96");
    AddCredit("Kuribo");
    AddCredit("Kyasarin");
    AddCredit("Luminous");
    AddCredit("m4sterbr0s");
    AddCredit("NameUser");
    AddCredit("Namyrr");
    AddCredit("Qig");
    AddCredit("Quill");
    AddCredit("Red_Yoshi");
    AddCredit("Spitfire");
    AddCredit("Valtteri");
    AddCredit("Vandarx");
    AddCredit("Zephyr");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
#ifndef ENABLE_OLD_CREDITS
    AddCredit("'It just works!'");
    AddCredit("");
    AddCredit("Todd Howard");
#else
    AddCredit("'He has delivered us from the power");
    AddCredit("of darkness and conveyed us into");
    AddCredit("the kingdom of the Son of His love.'");
    AddCredit("");
    AddCredit("Colossians 1:13");
#endif
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit("");
    AddCredit(g_gameInfo.creditsHomePage);

    // CreditChop and CreditOffsetY were previously floats, now they are ints measured in tenths
    CreditChop = (XRender::TargetH / 2) * 10; // 100
    EndCredits = 0;
    CreditOffsetY = (XRender::TargetH + 40) * 10;
    CreditTotalHeight = 32;

    for(A = 1; A <= numCredits; A++)
    {
        auto &cr = Credit[A];
        cr.Location.Width = SuperTextPixLen(GetS(cr.Text), g_gameInfo.creditsFont);
        cr.Location.Height = 16;
        cr.Location.X = (XRender::TargetW / 2) - (cr.Location.Width / 2);
        cr.Location.Y = 32 * A;
        CreditTotalHeight += 32;
    }
}


================================================
FILE: src/main/outro_loop.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef OUTRO_LOOP_H
#define OUTRO_LOOP_H

#include <string>

struct OutroContent
{
    std::string gameCredits;
    std::string engineCredits;

    std::string originalBy;
    std::string nameAndrewSpinks;

    std::string cppPortDevelopers;
    std::string nameVitalyNovichkov;

    std::string qualityControl;

    std::string psVitaPortBy;

    std::string levelDesign;

    std::string customSprites;

    std::string specialThanks;
};

extern OutroContent g_outroScreen;

void initOutroContent();

#endif // OUTRO_LOOP_H


================================================
FILE: src/main/player_frames.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../game_main.h"


void SetupPlayerFrames()
{
    For(A, 1, maxPlayerFrames)
    {
        MarioFrameX[A] = 0;
        MarioFrameY[A] = 0;
        LuigiFrameX[A] = 0;
        LuigiFrameY[A] = 0;
        PeachFrameX[A] = 0;
        PeachFrameY[A] = 0;
        ToadFrameX[A] = 0;
        ToadFrameY[A] = 0;
    }

    LinkFrameY[101] = -8;
    LinkFrameY[102] = -8;
    LinkFrameY[103] = -8;
    LinkFrameY[104] = -6;
    LinkFrameY[105] = -8;
    LinkFrameY[106] = -8;
    LinkFrameY[107] = -4;
    LinkFrameY[108] = -6;
    LinkFrameY[109] = -4;
    LinkFrameY[110] = -16;
    LinkFrameY[111] = -2;
    LinkFrameY[99] = -8;
    LinkFrameY[98] = -8;
    LinkFrameY[97] = -8;
    LinkFrameY[96] = -6;
    LinkFrameY[95] = -8;
    LinkFrameY[94] = -8;
    LinkFrameY[93] = -4;
    LinkFrameY[92] = -6;
    LinkFrameY[91] = -4;
    LinkFrameY[90] = -16;
    LinkFrameY[89] = -2;
    For(A, 51, 149)
    {
        LinkFrameX[A] = -4;
    }
    LinkFrameX[106] = -18;
    LinkFrameX[93] = -36;
    LinkFrameX[92] = -36;

    For(A, 51, maxPlayerFrames - 101) // 649
    {
        LinkFrameX[A + 100] = LinkFrameX[A];
        LinkFrameY[A + 100] = LinkFrameY[A];
    }

        LinkFrameX[512] = -4;
        LinkFrameY[512] = -8;
        LinkFrameX[488] = -4;
        LinkFrameY[488] = -8;

    For(A, 51, 149)
    {
        ToadFrameY[A] = -6;
        ToadFrameX[A] = -2;
    }
    ToadFrameY[107] = -2;
    ToadFrameY[127] = -2;

    ToadFrameX[127] = -4;
    ToadFrameX[73] = -4;

    ToadFrameX[115] = -4;
    ToadFrameX[85] = -4;
    ToadFrameY[93] = -2;
    ToadFrameY[73] = -2;
    ToadFrameY[122] = -20;
    ToadFrameY[123] = -12;

    ToadFrameY[78] = -20;
    ToadFrameY[77] = -12;

    For(A, 151, 349)
    {
        ToadFrameY[A] = 2;
        ToadFrameX[A] = -4;
    }

    For(A, 151, 349)
    {
        ToadFrameY[A] -= 4;
    }

    ToadFrameY[227] = 0;
    ToadFrameY[207] = 0;
    ToadFrameY[173] = 0;
    ToadFrameY[193] = 0;
    ToadFrameY[327] = 0;
    ToadFrameY[307] = 0;
    ToadFrameY[273] = 0;
    ToadFrameY[293] = 0;
    ToadFrameY[322] = -22;
    ToadFrameY[278] = -22;
    ToadFrameY[222] = -22;
    ToadFrameY[178] = -22;
    ToadFrameY[323] = -16;
    ToadFrameY[277] = -16;
    ToadFrameY[223] = -16;
    ToadFrameY[177] = -16;

    ToadFrameX[294] = -4;
    ToadFrameX[194] = -4;
    ToadFrameX[306] = -6;
    ToadFrameX[206] = -6;
    ToadFrameX[106] = -4;

    PeachFrameY[101] = -4;
    PeachFrameY[102] = -4;
    PeachFrameY[103] = -4;
    PeachFrameY[104] = -4;
    PeachFrameY[108] = -4;
    PeachFrameY[109] = -4;
    PeachFrameY[110] = -4;
    PeachFrameY[127] = -2;
    PeachFrameY[122] = -16;
    PeachFrameY[78] = -16;
    PeachFrameY[99] = -4;
    PeachFrameY[98] = -4;
    PeachFrameY[97] = -4;
    PeachFrameY[96] = -4;
    PeachFrameY[92] = -4;
    PeachFrameY[91] = -4;
    PeachFrameY[90] = -4;
    PeachFrameY[73] = -2;
    PeachFrameX[101] = -2;
    PeachFrameX[102] = -2;
    PeachFrameX[103] = -2;
    PeachFrameX[104] = -2;
    PeachFrameX[108] = -2;
    PeachFrameX[109] = -2;
    PeachFrameX[110] = -2;
    PeachFrameX[107] = -2;
    PeachFrameX[93] = -2;
    PeachFrameX[127] = -4;
    PeachFrameX[99] = 0;
    PeachFrameX[98] = 0;
    PeachFrameX[97] = 0;
    PeachFrameX[96] = 0;
    PeachFrameX[92] = 0;
    PeachFrameX[91] = 0;
    PeachFrameX[90] = 0;
    PeachFrameX[73] = -4;

    PeachFrameY[201] = -2;
    PeachFrameY[202] = -2;
    PeachFrameY[203] = -2;
    PeachFrameY[204] = -2;
    PeachFrameY[208] = -2;
    PeachFrameY[209] = -2;
    PeachFrameY[210] = -2;
    PeachFrameY[215] = -2;
    PeachFrameY[185] = -2;
    PeachFrameY[222] = -30;
    PeachFrameY[178] = -30;
    PeachFrameY[199] = -2;
    PeachFrameY[198] = -2;
    PeachFrameY[197] = -2;
    PeachFrameY[196] = -2;
    PeachFrameY[192] = -2;
    PeachFrameY[191] = -2;
    PeachFrameY[190] = -2;
    PeachFrameX[201] = -4;
    PeachFrameX[202] = -4;
    PeachFrameX[203] = -4;
    PeachFrameX[204] = -4;
    PeachFrameX[207] = -4;
    PeachFrameX[208] = -4;
    PeachFrameX[209] = -4;
    PeachFrameX[210] = -4;
    PeachFrameX[215] = -4;
    PeachFrameX[185] = -4;
    PeachFrameX[227] = -4;
    PeachFrameX[199] = -4;
    PeachFrameX[198] = -4;
    PeachFrameX[197] = -4;
    PeachFrameX[196] = -4;
    PeachFrameX[193] = -4;
    PeachFrameX[192] = -4;
    PeachFrameX[191] = -4;
    PeachFrameX[190] = -4;
    PeachFrameX[173] = -4;
    PeachFrameY[223] = -30;
    PeachFrameY[177] = -30;
    PeachFrameY[206] = -2;
    PeachFrameY[194] = -2;
    PeachFrameX[195] = PeachFrameX[196];
    PeachFrameY[195] = PeachFrameY[196];
    PeachFrameX[205] = PeachFrameX[204];
    PeachFrameY[205] = PeachFrameY[204];
    PeachFrameX[206] = -8;
    PeachFrameX[194] = 0;
    PeachFrameX[213] = -4;
    PeachFrameX[187] = -4;
    PeachFrameY[213] = -2;
    PeachFrameY[187] = -2;
    PeachFrameY[123] = -16;
    PeachFrameY[77] = -16;
    PeachFrameY[122] = -2;
    PeachFrameY[78] = -22;
    PeachFrameY[106] = -4;
    PeachFrameY[94] = -4;
    PeachFrameX[95] = PeachFrameX[96];
    PeachFrameY[95] = PeachFrameY[96];
    PeachFrameX[105] = PeachFrameX[104];
    PeachFrameY[105] = PeachFrameY[104];
    PeachFrameX[106] = -4;
    PeachFrameX[94] = 0;
    PeachFrameX[113] = -2;
    PeachFrameX[115] = -2;
    PeachFrameX[85] = -2;
    PeachFrameY[115] = -4;
    PeachFrameY[85] = -4;
    PeachFrameX[87] = -2;
    PeachFrameY[113] = -4;
    PeachFrameY[87] = -4;
    PeachFrameY[75] = -2;
    PeachFrameY[74] = -2;
    PeachFrameY[125] = -2;
    PeachFrameY[126] = -2;
    PeachFrameY[123] = -16;
    PeachFrameY[122] = -22;
    For(A, 151, 249)
    {
        PeachFrameX[A + 100] = PeachFrameX[A];
        PeachFrameY[A + 100] = PeachFrameY[A];
    }
    PeachFrameX[312] = PeachFrameX[310];
    PeachFrameX[311] = PeachFrameX[310];
    PeachFrameX[288] = PeachFrameX[290];
    PeachFrameX[289] = PeachFrameX[290];
    PeachFrameY[312] = PeachFrameY[310];
    PeachFrameY[311] = PeachFrameY[310];
    PeachFrameY[288] = PeachFrameY[290];
    PeachFrameY[289] = PeachFrameY[290];




    MarioFrameY[96] = 0;
    MarioFrameX[97] = -4;
    MarioFrameX[98] = -2;
    MarioFrameY[98] = 0;
    MarioFrameY[99] = 2;
    MarioFrameY[101] = 2;
    MarioFrameX[102] = -4;
    MarioFrameY[102] = 0;
    MarioFrameX[103] = -4;
    MarioFrameY[104] = 0;
    MarioFrameX[105] = -2;
    MarioFrameX[106] = -4;
    MarioFrameY[190] = 2;
    MarioFrameY[191] = 2;
    MarioFrameY[192] = 2;
    MarioFrameY[193] = -4;
    MarioFrameX[194] = -2;
    MarioFrameY[194] = 0;
    MarioFrameX[195] = -2;
    MarioFrameX[196] = -2;
    MarioFrameX[197] = -2;
    MarioFrameY[197] = 2;
    MarioFrameX[198] = -2;
    MarioFrameY[198] = 2;
    MarioFrameY[199] = 2;
    MarioFrameY[201] = 2;
    MarioFrameY[202] = 2;
    MarioFrameX[202] = -2;
    MarioFrameY[203] = 2;
    MarioFrameX[203] = -2;
    MarioFrameX[204] = -2;
    MarioFrameX[205] = -2;
    MarioFrameX[206] = -2;
    MarioFrameY[206] = 0;
    MarioFrameY[207] = -4;
    MarioFrameY[208] = 2;
    MarioFrameY[209] = 2;
    MarioFrameY[210] = 2;
    MarioFrameX[209] = -2;
    MarioFrameX[210] = -4;
    MarioFrameY[288] = 2;
    MarioFrameY[289] = 2;
    MarioFrameY[290] = 2;
    MarioFrameY[291] = 2;
    MarioFrameY[292] = 2;
    MarioFrameY[293] = -4;
    MarioFrameX[294] = -2;
    MarioFrameY[294] = 0;
    MarioFrameX[295] = -2;
    MarioFrameX[296] = -2;
    MarioFrameX[297] = -2;
    MarioFrameY[297] = 2;
    MarioFrameX[298] = -2;
    MarioFrameY[298] = 2;
    MarioFrameY[299] = 2;
    MarioFrameY[301] = 2;
    MarioFrameY[302] = 2;
    MarioFrameX[302] = -2;
    MarioFrameY[303] = 2;
    MarioFrameX[303] = -2;
    MarioFrameX[304] = -2;
    MarioFrameX[305] = -2;
    MarioFrameX[306] = -2;
    MarioFrameY[306] = 0;
    MarioFrameY[307] = -4;
    MarioFrameY[308] = 2;
    MarioFrameY[309] = 2;
    MarioFrameY[310] = 2;
    MarioFrameX[309] = -2;
    MarioFrameX[310] = -4;
    MarioFrameY[311] = 2;
    MarioFrameY[312] = 2;
    MarioFrameX[382] = -4;
    MarioFrameX[383] = -4;
    MarioFrameX[384] = -4;
    MarioFrameY[385] = -2;
    MarioFrameX[386] = -14;
    MarioFrameX[389] = -2;
    MarioFrameY[393] = -4;
    MarioFrameX[394] = -2;
    MarioFrameY[394] = -4;
    MarioFrameX[395] = -2;
    MarioFrameX[396] = -2;
    MarioFrameX[397] = -2;
    MarioFrameX[398] = -2;
    MarioFrameX[401] = -14;
    MarioFrameX[402] = -14;
    MarioFrameX[403] = -16;
    MarioFrameX[404] = -16;
    MarioFrameX[405] = -16;
    MarioFrameY[406] = -4;
    MarioFrameX[407] = -14;
    MarioFrameY[407] = -4;
    MarioFrameX[408] = -14;
    MarioFrameX[409] = -16;
    MarioFrameX[410] = -18;
    MarioFrameX[411] = -14;
    MarioFrameX[412] = -18;
    MarioFrameX[413] = -4;
    MarioFrameX[414] = -4;
    MarioFrameX[415] = -4;
    MarioFrameY[415] = -2;
    MarioFrameX[416] = -16;
    MarioFrameX[417] = -16;
    MarioFrameX[418] = -16;
    MarioFrameX[419] = -16;
    MarioFrameX[420] = -16;
    MarioFrameX[421] = -16;
    LuigiFrameY[96] = 0;
    LuigiFrameX[97] = -4;
    LuigiFrameX[98] = -2;
    LuigiFrameY[98] = 0;
    LuigiFrameY[99] = 2;
    LuigiFrameY[101] = 2;
    LuigiFrameX[102] = -4;
    LuigiFrameY[102] = 0;
    LuigiFrameX[103] = -4;
    LuigiFrameY[104] = 0;
    LuigiFrameX[105] = -2;
    LuigiFrameX[106] = -4;
    LuigiFrameY[190] = 2;
    LuigiFrameY[191] = 2;
    LuigiFrameY[192] = 2;
    LuigiFrameY[193] = -6;
    LuigiFrameX[194] = -2;
    LuigiFrameY[194] = 0;
    LuigiFrameX[195] = -2;
    LuigiFrameX[196] = -2;
    LuigiFrameX[197] = -2;
    LuigiFrameY[197] = 2;
    LuigiFrameX[198] = -2;
    LuigiFrameY[198] = 2;
    LuigiFrameY[199] = 2;
    LuigiFrameY[201] = 2;
    LuigiFrameY[202] = 2;
    LuigiFrameX[202] = -2;
    LuigiFrameY[203] = 2;
    LuigiFrameX[203] = -2;
    LuigiFrameX[204] = -2;
    LuigiFrameX[205] = -2;
    LuigiFrameX[206] = -2;
    LuigiFrameY[206] = 0;
    LuigiFrameY[207] = -6;
    LuigiFrameY[208] = 2;
    LuigiFrameY[209] = 2;
    LuigiFrameY[210] = 2;
    LuigiFrameX[209] = -2;
    LuigiFrameX[210] = -4;
    LuigiFrameY[288] = 2;
    LuigiFrameY[289] = 2;
    LuigiFrameY[290] = 2;
    LuigiFrameY[291] = 2;
    LuigiFrameY[292] = 2;
    LuigiFrameY[293] = -6;
    LuigiFrameX[294] = -2;
    LuigiFrameY[294] = 0;
    LuigiFrameX[295] = -2;
    LuigiFrameX[296] = -2;
    LuigiFrameX[297] = -2;
    LuigiFrameY[297] = 2;
    LuigiFrameX[298] = -2;
    LuigiFrameY[298] = 2;
    LuigiFrameY[299] = 2;
    LuigiFrameY[301] = 2;
    LuigiFrameY[302] = 2;
    LuigiFrameX[302] = -2;
    LuigiFrameY[303] = 2;
    LuigiFrameX[303] = -2;
    LuigiFrameX[304] = -2;
    LuigiFrameX[305] = -2;
    LuigiFrameX[306] = -2;
    LuigiFrameY[306] = 0;
    LuigiFrameY[307] = -6;
    LuigiFrameY[308] = 2;
    LuigiFrameY[309] = 2;
    LuigiFrameY[310] = 2;
    LuigiFrameX[309] = -2;
    LuigiFrameX[310] = -4;
    LuigiFrameY[311] = 2;
    LuigiFrameY[312] = 2;
    LuigiFrameX[382] = -4;
    LuigiFrameX[383] = -4;
    LuigiFrameX[384] = -2;
    LuigiFrameX[386] = -14;
    LuigiFrameX[389] = -2;
    LuigiFrameY[393] = -4;
    LuigiFrameX[394] = -2;
    LuigiFrameY[394] = 0;
    LuigiFrameX[395] = -2;
    LuigiFrameX[396] = -2;
    LuigiFrameX[397] = -2;
    LuigiFrameX[398] = -2;
    LuigiFrameX[401] = -14;
    LuigiFrameX[402] = -14;
    LuigiFrameX[403] = -16;
    LuigiFrameX[404] = -16;
    LuigiFrameX[405] = -16;
    LuigiFrameY[406] = 0;
    LuigiFrameX[407] = -14;
    LuigiFrameY[407] = -4;
    LuigiFrameX[408] = -14;
    LuigiFrameX[409] = -16;
    LuigiFrameX[410] = -18;
    LuigiFrameX[411] = -14;
    LuigiFrameX[412] = -18;
    LuigiFrameX[413] = -4;
    LuigiFrameX[414] = -4;
    LuigiFrameX[415] = -4;
    LuigiFrameX[416] = -16;
    LuigiFrameX[417] = -16;
    LuigiFrameX[418] = -16;
    LuigiFrameX[419] = -16;
    LuigiFrameX[420] = -18;
    LuigiFrameX[421] = -16;
    For(A, 150, maxPlayerFrames) // Adjust the players frames to their new sizes
    {
        MarioFrameX[A] -= 2;
        LuigiFrameX[A] -= 2;
        LuigiFrameY[A] -= 2;
    }
    LuigiFrameY[101] -= 2;
    LuigiFrameY[102] -= 2;
    LuigiFrameY[105] -= 2;
    LuigiFrameY[106] -= 2;
    LuigiFrameY[99] -= 2;
    LuigiFrameY[98] -= 2;
    LuigiFrameY[95] -= 2;
    LuigiFrameY[94] -= 2;
// Yoshi Frames
    MarioFrameX[130] = -2 - 4;
    MarioFrameX[70] = 6 - 4;
    MarioFrameY[130] = 18;
    MarioFrameY[70] = 18;
    MarioFrameX[230] = -4 - 4;
    MarioFrameX[170] = 4 - 4;
    MarioFrameX[330] = -4 - 4;
    MarioFrameX[270] = 4 - 4;
    MarioFrameX[430] = -20 - 4;
    MarioFrameX[370] = 4 - 4;
    MarioFrameY[430] = -2;
    MarioFrameY[370] = -2;
    LuigiFrameX[130] = -2 - 4;
    LuigiFrameX[70] = 6 - 4;
    LuigiFrameY[130] = 16;
    LuigiFrameY[70] = 16;
    LuigiFrameY[230] = -4;
    LuigiFrameY[170] = -4;
    LuigiFrameY[330] = -4;
    LuigiFrameY[270] = -4;
    LuigiFrameY[430] = -6;
    LuigiFrameY[370] = -6;
    LuigiFrameX[230] = -6 - 4;
    LuigiFrameX[170] = 4 - 4;
    LuigiFrameX[330] = -6 - 4;
    LuigiFrameX[270] = 4 - 4;
    LuigiFrameX[430] = -20 - 4;
    LuigiFrameX[370] = 4 - 4;
    MarioFrameX[131] = -2 - 2;
    MarioFrameX[69] = 6 - 4;
    MarioFrameY[131] = 22;
    MarioFrameY[69] = 22;
    MarioFrameX[231] = -4 - 3;
    MarioFrameX[169] = 4 - 6;
    MarioFrameY[231] = 8;
    MarioFrameY[169] = 8;
    MarioFrameX[331] = -4 - 2;
    MarioFrameX[269] = 4 - 6;
    MarioFrameY[331] = 8;
    MarioFrameY[269] = 8;
    MarioFrameX[431] = -20;
    MarioFrameX[369] = 4 - 6;
    MarioFrameY[431] = 6;
    MarioFrameY[369] = 6;
    LuigiFrameX[131] = -2 - 2;
    LuigiFrameX[69] = 6 - 4;
    LuigiFrameY[131] = 22;
    LuigiFrameY[69] = 22;
    LuigiFrameX[231] = -6;
    LuigiFrameX[169] = 4 - 6;
    LuigiFrameY[231] = 4;
    LuigiFrameY[169] = 4;
    LuigiFrameX[331] = -6;
    LuigiFrameX[269] = 4 - 6;
    LuigiFrameY[331] = 4;
    LuigiFrameY[269] = 4;
    LuigiFrameX[431] = -20;
    LuigiFrameX[369] = 4 - 6;
    LuigiFrameY[431] = 2;
    LuigiFrameY[369] = 2;
// Facing Frames
    MarioFrameX[113] = -2;
    MarioFrameY[113] = 2;
    MarioFrameX[115] = -2;
    MarioFrameY[115] = 2;
    MarioFrameX[87] = MarioFrameX[113];
    MarioFrameY[87] = MarioFrameY[113];
    MarioFrameX[85] = MarioFrameX[115];
    MarioFrameY[85] = MarioFrameY[115];
    MarioFrameX[213] = -4;
    MarioFrameY[213] = 2;
    MarioFrameX[215] = -4;
    MarioFrameY[215] = 2;
    MarioFrameX[187] = MarioFrameX[213];
    MarioFrameY[187] = MarioFrameY[213];
    MarioFrameX[185] = MarioFrameX[215];
    MarioFrameY[185] = MarioFrameY[215];
    MarioFrameX[313] = -4;
    MarioFrameY[313] = 2;
    MarioFrameX[315] = -4;
    MarioFrameY[315] = 2;
    MarioFrameX[287] = MarioFrameX[313];
    MarioFrameY[287] = MarioFrameY[313];
    MarioFrameX[285] = MarioFrameX[315];
    MarioFrameY[285] = MarioFrameY[315];
    MarioFrameX[413] = -4;
    MarioFrameY[413] = 0;
    MarioFrameX[415] = -4;
    MarioFrameY[415] = -2;
    MarioFrameX[387] = MarioFrameX[413];
    MarioFrameY[387] = MarioFrameY[413];
    MarioFrameX[385] = MarioFrameX[415];
    MarioFrameY[385] = MarioFrameY[415];
    LuigiFrameX[113] = -2;
    LuigiFrameY[113] = 2;
    LuigiFrameX[115] = -2;
    LuigiFrameY[115] = 2;
    LuigiFrameX[87] = LuigiFrameX[113];
    LuigiFrameY[87] = LuigiFrameY[113];
    LuigiFrameX[85] = LuigiFrameX[115];
    LuigiFrameY[85] = LuigiFrameY[115];
    LuigiFrameX[213] = -4;
    LuigiFrameY[213] = 2;
    LuigiFrameX[215] = -4;
    LuigiFrameY[215] = 2;
    LuigiFrameX[187] = LuigiFrameX[213];
    LuigiFrameY[187] = LuigiFrameY[213];
    LuigiFrameX[185] = LuigiFrameX[215];
    LuigiFrameY[185] = LuigiFrameY[215];
    LuigiFrameX[313] = -4;
    LuigiFrameY[313] = 2;
    LuigiFrameX[315] = -4;
    LuigiFrameY[315] = 2;
    LuigiFrameX[287] = LuigiFrameX[313];
    LuigiFrameY[287] = LuigiFrameY[313];
    LuigiFrameX[285] = LuigiFrameX[315];
    LuigiFrameY[285] = LuigiFrameY[315];
    LuigiFrameX[413] = -4;
    LuigiFrameY[413] = 0;
    LuigiFrameX[415] = -4;
    LuigiFrameY[415] = -2;
    LuigiFrameX[387] = LuigiFrameX[413];
    LuigiFrameY[387] = LuigiFrameY[413];
    LuigiFrameX[385] = LuigiFrameX[415];
    LuigiFrameY[385] = LuigiFrameY[415];
    LuigiFrameX[113] = 0; // -2
    LuigiFrameY[113] = 0;
    LuigiFrameX[115] = 0; // -2
    LuigiFrameY[115] = 0;
    LuigiFrameX[87] = LuigiFrameX[113];
    LuigiFrameY[87] = LuigiFrameY[113];
    LuigiFrameX[85] = LuigiFrameX[115];
    LuigiFrameY[85] = LuigiFrameY[115];
    LuigiFrameX[213] = -4;
    LuigiFrameY[213] = 0;
    LuigiFrameX[215] = -4;
    LuigiFrameY[215] = 0;
    LuigiFrameX[187] = LuigiFrameX[213];
    LuigiFrameY[187] = LuigiFrameY[213];
    LuigiFrameX[185] = LuigiFrameX[215];
    LuigiFrameY[185] = LuigiFrameY[215];
    LuigiFrameX[313] = -4;
    LuigiFrameY[313] = 0;
    LuigiFrameX[315] = -4;
    LuigiFrameY[315] = 0;
    LuigiFrameX[287] = LuigiFrameX[313];
    LuigiFrameY[287] = LuigiFrameY[313];
    LuigiFrameX[285] = LuigiFrameX[315];
    LuigiFrameY[285] = LuigiFrameY[315];
    LuigiFrameX[413] = -4;
    LuigiFrameY[413] = -2;
    LuigiFrameX[415] = -4;
    LuigiFrameY[415] = -2;
    LuigiFrameX[387] = LuigiFrameX[413];
    LuigiFrameY[387] = LuigiFrameY[413];
    LuigiFrameX[385] = LuigiFrameX[415];
    LuigiFrameY[385] = LuigiFrameY[415];
    For(A, 450, 550)
    {
        MarioFrameX[A] = MarioFrameX[A - 100];
        MarioFrameY[A] = MarioFrameY[A - 100];
        LuigiFrameX[A] = LuigiFrameX[A - 100];
        LuigiFrameY[A] = LuigiFrameY[A - 100];
        MarioFrameX[A + 100] = MarioFrameX[A - 200];
        MarioFrameY[A + 100] = MarioFrameY[A - 200];
        LuigiFrameX[A + 100] = LuigiFrameX[A - 200];
        LuigiFrameY[A + 100] = LuigiFrameY[A - 200];
    }
    MarioFrameY[508] -= 2;
    MarioFrameY[509] -= 2;
    MarioFrameY[510] -= 2;
    MarioFrameY[492] -= 2;
    MarioFrameY[491] -= 2;
    MarioFrameY[490] -= 2;
    MarioFrameY[501] = -2;
    MarioFrameY[499] = -2;
    MarioFrameY[502] = -2;
    MarioFrameY[498] = -2;
    MarioFrameY[503] = 0;
    MarioFrameY[497] = 0;
    MarioFrameY[512] = -2;
    MarioFrameY[513] = -2;
    MarioFrameY[514] = -2;
    MarioFrameY[515] = 0;
    MarioFrameY[488] = -2;
    MarioFrameY[487] = -2;
    MarioFrameY[486] = -2;
    MarioFrameY[485] = 0;
    MarioFrameX[513] = -6;
    MarioFrameX[514] = -6;
    MarioFrameX[515] = -6;
    MarioFrameX[485] = -2;
    MarioFrameX[487] = -2;
    MarioFrameX[518] = -16;
    MarioFrameX[517] = -16;
    MarioFrameX[516] = -16;
    MarioFrameY[530] -= 2;
    MarioFrameY[531] -= 2;
    MarioFrameY[470] -= 2;
    MarioFrameY[569] = MarioFrameY[469] - 2;
    MarioFrameY[500] = -2;
    MarioFrameX[500] = -4;
    LuigiFrameY[500] = 4;
    LuigiFrameX[500] = -4;
    MarioFrameX[513] = -4;
    MarioFrameX[487] = -4;
    MarioFrameX[601] = -6;
    MarioFrameY[601] = 0;
    MarioFrameY[599] = 0;
    MarioFrameY[602] = 0;
    MarioFrameY[603] = 0;
    MarioFrameY[598] = 0;
    MarioFrameY[597] = 0;
    MarioFrameY[604] = -2;
    MarioFrameY[605] = -2;
    MarioFrameY[596] = -2;
    MarioFrameY[595] = -2;
    MarioFrameY[613] = -2;
    MarioFrameY[587] = -2;
    MarioFrameY[615] = 0;
    MarioFrameY[585] = 0;
    MarioFrameX[608] = -6;
    MarioFrameY[608] = 0;
    MarioFrameY[592] = 0;
    MarioFrameX[609] = -6;
    MarioFrameY[609] = 0;
    MarioFrameY[591] = 0;
    MarioFrameY[610] = 0;
    MarioFrameY[590] = 0;
    MarioFrameY[611] = 0;
    MarioFrameX[611] = -6;
    MarioFrameY[589] = 0;
    MarioFrameY[612] = 0;
    MarioFrameX[612] = -6;
    MarioFrameY[588] = 0;
    MarioFrameY[613] = 0;
    MarioFrameY[587] = 0;
    MarioFrameY[630] = -2;
    MarioFrameY[570] = -2;
    MarioFrameY[631] = 6;
    MarioFrameY[569] = 6;
    MarioFrameY[469] = 4;
    MarioFrameY[607] = 0;
    MarioFrameY[593] = 0;
    MarioFrameX[593] = -6;
    LuigiFrameX[601] = -6;
    LuigiFrameX[608] = -6;
    LuigiFrameX[609] = -6;
    LuigiFrameX[611] = -6;
    LuigiFrameX[612] = -6;
    LuigiFrameX[630] = -12;
    LuigiFrameY[607] = 0;
    LuigiFrameY[593] = 0;

    MarioFrameX[225] = -4;
    MarioFrameX[226] = -4;
    MarioFrameX[175] = -4;
    MarioFrameX[174] = -4;
    MarioFrameX[325] = -4;
    MarioFrameX[326] = -4;
    MarioFrameX[275] = -4;
    MarioFrameX[274] = -4;
    MarioFrameX[425] = -4;
    MarioFrameX[426] = -4;
    MarioFrameX[375] = -4;
    MarioFrameX[374] = -4;
    MarioFrameX[525] = -4;
    MarioFrameX[526] = -4;
    MarioFrameX[475] = -4;
    MarioFrameX[474] = -4;
    MarioFrameX[625] = -4;
    MarioFrameX[626] = -4;
    MarioFrameX[575] = -4;
    MarioFrameX[574] = -4;
    MarioFrameX[125] = -2;
    MarioFrameX[126] = -2;
    MarioFrameX[75] = -2;
    MarioFrameX[74] = -2;
    LuigiFrameX[225] = -4;
    LuigiFrameX[226] = -4;
    LuigiFrameX[175] = -4;
    LuigiFrameX[174] = -4;
    LuigiFrameX[325] = -4;
    LuigiFrameX[326] = -4;
    LuigiFrameX[275] = -4;
    LuigiFrameX[274] = -4;
    LuigiFrameX[425] = -4;
    LuigiFrameX[426] = -4;
    LuigiFrameX[375] = -4;
    LuigiFrameX[374] = -4;
    LuigiFrameX[525] = -4;
    LuigiFrameX[526] = -4;
    LuigiFrameX[475] = -4;
    LuigiFrameX[474] = -4;
    LuigiFrameX[625] = -4;
    LuigiFrameX[626] = -4;
    LuigiFrameX[575] = -4;
    LuigiFrameX[574] = -4;

    LuigiFrameX[124] = -4;
    LuigiFrameX[76] = -4;
    LuigiFrameX[224] = -4;
    LuigiFrameX[176] = -4;
    LuigiFrameX[324] = -4;
    LuigiFrameX[276] = -4;
    LuigiFrameX[424] = -4;
    LuigiFrameX[376] = -4;
    LuigiFrameX[524] = -4;
    LuigiFrameX[476] = -4;
    LuigiFrameX[624] = -4;
    LuigiFrameX[576] = -4;

    LuigiFrameY[224] = 2;
    LuigiFrameY[176] = 2;
    LuigiFrameY[324] = 2;
    LuigiFrameY[276] = 2;
    LuigiFrameY[424] = 0;
    LuigiFrameY[376] = 0;
    LuigiFrameY[524] = 0;
    LuigiFrameY[476] = 0;
    LuigiFrameY[624] = 2;
    LuigiFrameY[576] = 2;


    MarioFrameX[124] = -4;
    MarioFrameX[76] = -2;
    MarioFrameX[224] = -4;
    MarioFrameX[176] = -4;
    MarioFrameX[324] = -4;
    MarioFrameX[276] = -4;
    MarioFrameX[424] = -4;
    MarioFrameX[376] = -4;
    MarioFrameX[524] = -4;
    MarioFrameX[476] = -4;
    MarioFrameX[624] = -4;
    MarioFrameX[576] = -4;
    MarioFrameY[224] = 4;
    MarioFrameY[176] = 4;
    MarioFrameY[324] = 4;
    MarioFrameY[276] = 4;
    MarioFrameY[424] = 2;
    MarioFrameY[376] = 2;
    MarioFrameY[524] = 2;
    MarioFrameY[476] = 2;
    MarioFrameY[624] = 2;
    MarioFrameY[576] = 2;



    MarioFrameX[140] = -4;
    MarioFrameY[140] = 2;
    MarioFrameX[141] = -4;
    MarioFrameY[141] = 2;
    MarioFrameX[142] = -4;
    MarioFrameY[142] = 2;
    MarioFrameX[143] = -4;
    MarioFrameY[143] = 2;
    MarioFrameX[60] = -4;
    MarioFrameY[60] = 2;
    MarioFrameX[59] = -4;
    MarioFrameY[59] = 2;
    MarioFrameX[58] = 0;
    MarioFrameY[58] = 2;
    MarioFrameX[57] = 0;
    MarioFrameY[57] = 2;
    MarioFrameX[240] = -8;
    MarioFrameY[240] = 2;
    MarioFrameX[241] = -8;
    MarioFrameY[241] = 2;
    MarioFrameX[242] = -8;
    MarioFrameY[242] = 2;
    MarioFrameX[243] = -8;
    MarioFrameY[243] = 2;
    MarioFrameX[244] = -8;
    MarioFrameY[244] = 2;
    MarioFrameX[160] = -6;
    MarioFrameY[160] = 2;
    MarioFrameX[159] = -6;
    MarioFrameY[159] = 2;
    MarioFrameX[158] = -6;
    MarioFrameY[158] = 2;
    MarioFrameX[157] = -4;
    MarioFrameY[157] = 2;
    MarioFrameX[156] = -6;
    MarioFrameY[156] = 2;
    MarioFrameX[340] = -8;
    MarioFrameY[340] = 2;
    MarioFrameX[341] = -8;
    MarioFrameY[341] = 2;
    MarioFrameX[342] = -8;
    MarioFrameY[342] = 2;
    MarioFrameX[343] = -8;
    MarioFrameY[343] = 2;
    MarioFrameX[344] = -8;
    MarioFrameY[344] = 2;
    MarioFrameX[260] = -6;
    MarioFrameY[260] = 2;
    MarioFrameX[259] = -6;
    MarioFrameY[259] = 2;
    MarioFrameX[258] = -6;
    MarioFrameY[258] = 2;
    MarioFrameX[257] = -4;
    MarioFrameY[257] = 2;
    MarioFrameX[256] = -6;
    MarioFrameY[256] = 2;
    MarioFrameX[540] = -18;
    MarioFrameY[540] = 0;
    MarioFrameX[541] = -18;
    MarioFrameY[541] = 0;
    MarioFrameX[542] = -18;
    MarioFrameY[542] = 0;
    MarioFrameX[543] = -18;
    MarioFrameY[543] = 0;
    MarioFrameX[544] = -18;
    MarioFrameY[544] = 0;
    MarioFrameX[460] = -6;
    MarioFrameY[460] = 0;
    MarioFrameX[459] = -6;
    MarioFrameY[459] = 0;
    MarioFrameX[458] = -6;
    MarioFrameY[458] = 0;
    MarioFrameX[457] = -4;
    MarioFrameY[457] = 0;
    MarioFrameX[456] = -6;
    MarioFrameY[456] = 0;
    MarioFrameX[440] = -18;
    MarioFrameY[440] = 0;
    MarioFrameX[441] = -18;
    MarioFrameY[441] = 0;
    MarioFrameX[442] = -18;
    MarioFrameY[442] = 0;
    MarioFrameX[443] = -18;
    MarioFrameY[443] = 0;
    MarioFrameX[444] = -18;
    MarioFrameY[444] = 0;
    MarioFrameX[360] = -6;
    MarioFrameY[360] = 0;
    MarioFrameX[359] = -6;
    MarioFrameY[359] = 0;
    MarioFrameX[358] = -6;
    MarioFrameY[358] = 0;
    MarioFrameX[357] = -4;
    MarioFrameY[357] = 0;
    MarioFrameX[356] = -6;
    MarioFrameY[356] = 0;
    MarioFrameX[640] = -8;
    MarioFrameY[640] = 0;
    MarioFrameX[641] = -8;
    MarioFrameY[641] = 0;
    MarioFrameX[642] = -8;
    MarioFrameY[642] = 0;
    MarioFrameX[643] = -8;
    MarioFrameY[643] = 0;
    MarioFrameX[644] = -8;
    MarioFrameY[644] = 0;
    MarioFrameX[560] = -6;
    MarioFrameY[560] = 0;
    MarioFrameX[559] = -6;
    MarioFrameY[559] = 0;
    MarioFrameX[558] = -6;
    MarioFrameY[558] = 0;
    MarioFrameX[557] = -4;
    MarioFrameY[557] = 0;
    MarioFrameX[556] = -6;
    MarioFrameY[556] = 0;


    MarioFrameX[515] = -4;
    MarioFrameX[485] = -4;


    LuigiFrameX[640] = -10;
    LuigiFrameY[640] = 0;
    LuigiFrameX[641] = -10;
    LuigiFrameY[641] = 0;
    LuigiFrameX[642] = -10;
    LuigiFrameY[642] = 0;
    LuigiFrameX[643] = -10;
    LuigiFrameY[643] = 0;
    LuigiFrameX[644] = -10;
    LuigiFrameY[644] = 0;

    LuigiFrameX[560] = -4;
    LuigiFrameY[560] = 0;
    LuigiFrameX[559] = -4;
    LuigiFrameY[559] = 0;
    LuigiFrameX[558] = -4;
    LuigiFrameY[558] = 0;
    LuigiFrameX[557] = -2;
    LuigiFrameY[557] = 0;
    LuigiFrameX[556] = -2;
    LuigiFrameY[556] = 0;


    LuigiFrameX[540] = -20;
    LuigiFrameY[540] = -2;
    LuigiFrameX[541] = -20;
    LuigiFrameY[541] = -2;
    LuigiFrameX[542] = -20;
    LuigiFrameY[542] = -2;
    LuigiFrameX[543] = -20;
    LuigiFrameY[543] = -2;
    LuigiFrameX[544] = -20;
    LuigiFrameY[544] = -2;
    LuigiFrameX[460] = -4;
    LuigiFrameY[460] = -2;
    LuigiFrameX[459] = -4;
    LuigiFrameY[459] = -2;
    LuigiFrameX[458] = -4;
    LuigiFrameY[458] = -2;
    LuigiFrameX[457] = -2;
    LuigiFrameY[457] = -2;
    LuigiFrameX[456] = -2;
    LuigiFrameY[456] = -2;



    LuigiFrameX[140] = -4;
    LuigiFrameY[140] = 0;
    LuigiFrameX[141] = -4;
    LuigiFrameY[141] = 0;
    LuigiFrameX[142] = -4;
    LuigiFrameY[142] = 0;
    LuigiFrameX[143] = -4;
    LuigiFrameY[143] = 0;
    LuigiFrameX[60] = -6;
    LuigiFrameY[60] = 0;
    LuigiFrameX[59] = -6;
    LuigiFrameY[59] = 0;
    LuigiFrameX[58] = 0;
    LuigiFrameY[58] = 0;
    LuigiFrameX[57] = 0;
    LuigiFrameY[57] = 0;

    LuigiFrameX[240] = -10;
    LuigiFrameY[240] = 0;
    LuigiFrameX[241] = -10;
    LuigiFrameY[241] = 0;
    LuigiFrameX[242] = -10;
    LuigiFrameY[242] = 0;
    LuigiFrameX[243] = -10;
    LuigiFrameY[243] = 0;
    LuigiFrameX[244] = -10;
    LuigiFrameY[244] = 0;
    LuigiFrameX[160] = -4;
    LuigiFrameY[160] = 0;
    LuigiFrameX[159] = -4;
    LuigiFrameY[159] = 0;
    LuigiFrameX[158] = -4;
    LuigiFrameY[158] = 0;
    LuigiFrameX[157] = -2;
    LuigiFrameY[157] = 0;
    LuigiFrameX[156] = -2;
    LuigiFrameY[156] = 0;

    LuigiFrameX[340] = -10;
    LuigiFrameY[340] = 0;
    LuigiFrameX[341] = -10;
    LuigiFrameY[341] = 0;
    LuigiFrameX[342] = -10;
    LuigiFrameY[342] = 0;
    LuigiFrameX[343] = -10;
    LuigiFrameY[343] = 0;
    LuigiFrameX[344] = -10;
    LuigiFrameY[344] = 0;
    LuigiFrameX[260] = -4;
    LuigiFrameY[260] = 0;
    LuigiFrameX[259] = -4;
    LuigiFrameY[259] = 0;
    LuigiFrameX[258] = -4;
    LuigiFrameY[258] = 0;
    LuigiFrameX[257] = -2;
    LuigiFrameY[257] = 0;
    LuigiFrameX[256] = -2;
    LuigiFrameY[256] = 0;


    LuigiFrameX[440] = -20;
    LuigiFrameY[440] = -2;
    LuigiFrameX[441] = -20;
    LuigiFrameY[441] = -2;
    LuigiFrameX[442] = -20;
    LuigiFrameY[442] = -2;
    LuigiFrameX[443] = -20;
    LuigiFrameY[443] = -2;
    LuigiFrameX[444] = -20;
    LuigiFrameY[444] = -2;
    LuigiFrameX[360] = -4;
    LuigiFrameY[360] = -2;
    LuigiFrameX[359] = -4;
    LuigiFrameY[359] = -2;
    LuigiFrameX[358] = -4;
    LuigiFrameY[358] = -2;
    LuigiFrameX[357] = -2;
    LuigiFrameY[357] = -2;
    LuigiFrameX[356] = -2;
    LuigiFrameY[356] = -2;

    MarioFrameY[122] = -8;
    MarioFrameY[123] = -6;
    MarioFrameY[78] = -8;
    MarioFrameX[78] = -4;
    MarioFrameY[77] = -6;

    MarioFrameY[222] = -24;
    MarioFrameX[222] = -4;
    MarioFrameY[223] = -6 - 24;
    MarioFrameX[223] = -4;
    MarioFrameY[178] = -24;
    MarioFrameX[178] = -4;
    MarioFrameY[177] = -6 - 24;
    MarioFrameX[177] = -4;
    MarioFrameY[322] = -24;
    MarioFrameX[322] = -4;
    MarioFrameY[323] = -6 - 24;
    MarioFrameX[323] = -4;
    MarioFrameY[278] = -24;
    MarioFrameX[278] = -4;
    MarioFrameY[277] = -6 - 24;
    MarioFrameX[277] = -4;
    MarioFrameY[422] = -24 - 2;
    MarioFrameX[422] = -4;
    MarioFrameY[423] = -6 - 24;
    MarioFrameX[423] = -4;
    MarioFrameY[378] = -24 - 2;
    MarioFrameX[378] = -4;
    MarioFrameY[377] = -6 - 24;
    MarioFrameX[377] = -4;

    MarioFrameY[522] = -24 - 2;
    MarioFrameX[522] = -4;
    MarioFrameY[523] = -6 - 24;
    MarioFrameX[523] = -4;
    MarioFrameY[478] = -24 - 2;
    MarioFrameX[478] = -4;
    MarioFrameY[477] = -6 - 24;
    MarioFrameX[477] = -4;

    MarioFrameY[622] = -24 - 2;
    MarioFrameX[622] = -4;
    MarioFrameY[623] = -6 - 24;
    MarioFrameX[623] = -4;
    MarioFrameY[578] = -24 - 2;
    MarioFrameX[578] = -4;
    MarioFrameY[577] = -6 - 24;
    MarioFrameX[577] = -4;
    LuigiFrameY[122] = -8;
    LuigiFrameY[123] = -6;
    LuigiFrameX[123] = -2;
    LuigiFrameY[78] = -8;
    LuigiFrameX[78] = -4;
    LuigiFrameY[77] = -6;
    LuigiFrameY[222] = -24 - 4;
    LuigiFrameX[222] = -4;
    LuigiFrameY[223] = -8 - 24;
    LuigiFrameX[223] = -4;
    LuigiFrameY[178] = -24 - 4;
    LuigiFrameX[178] = -4;
    LuigiFrameY[177] = -8 - 24;
    LuigiFrameX[177] = -4;

    LuigiFrameY[322] = -24 - 4;
    LuigiFrameX[322] = -4;
    LuigiFrameY[323] = -8 - 24;
    LuigiFrameX[323] = -4;
    LuigiFrameY[278] = -24 - 4;
    LuigiFrameX[278] = -4;
    LuigiFrameY[277] = -8 - 24;
    LuigiFrameX[277] = -4;

    LuigiFrameY[422] = -24 - 4;
    LuigiFrameX[422] = -4;
    LuigiFrameY[423] = -8 - 24;
    LuigiFrameX[423] = -4;
    LuigiFrameY[378] = -24 - 4;
    LuigiFrameX[378] = -4;
    LuigiFrameY[377] = -8 - 24;
    LuigiFrameX[377] = -4;

    LuigiFrameY[522] = -24 - 4;
    LuigiFrameX[522] = -4;
    LuigiFrameY[523] = -8 - 24;
    LuigiFrameX[523] = -4;
    LuigiFrameY[478] = -24 - 4;
    LuigiFrameX[478] = -4;
    LuigiFrameY[477] = -8 - 24;
    LuigiFrameX[477] = -4;

    LuigiFrameY[622] = -24 - 4;
    LuigiFrameX[622] = -4;
    LuigiFrameY[623] = -8 - 24;
    LuigiFrameX[623] = -4;
    LuigiFrameY[578] = -24 - 4;
    LuigiFrameX[578] = -4;
    LuigiFrameY[577] = -8 - 24;
    LuigiFrameX[577] = -4;

    LuigiFrameY[207] = -6;
    LuigiFrameY[193] = -6;
    LuigiFrameY[307] = -6;
    LuigiFrameY[293] = -6;

    For(A, 650, 749)
    {
        MarioFrameX[A] = MarioFrameX[A - 400];
        MarioFrameY[A] = MarioFrameY[A - 400];
        LuigiFrameX[A] = LuigiFrameX[A - 400];
        LuigiFrameY[A] = LuigiFrameY[A - 400];
        PeachFrameX[A] = PeachFrameX[A - 400];
        PeachFrameY[A] = PeachFrameY[A - 400];
        ToadFrameX[A] = ToadFrameX[A - 400];
        ToadFrameY[A] = ToadFrameY[A - 400];
        LinkFrameX[A] = LinkFrameX[A - 400];
        LinkFrameY[A] = LinkFrameY[A - 400];
    }

    PeachFrameX[401] = -16;
    PeachFrameY[401] = -2;
    PeachFrameX[399] = -4;
    PeachFrameY[399] = -2;
    PeachFrameX[402] = -16;
    PeachFrameY[402] = -2;
    PeachFrameX[398] = -4;
    PeachFrameY[398] = -2;
    PeachFrameX[403] = -16;
    PeachFrameY[403] = -2;
    PeachFrameX[397] = -4;
    PeachFrameY[397] = -2;
    PeachFrameX[404] = -14;
    PeachFrameY[404] = -2;
    PeachFrameX[396] = -4;
    PeachFrameY[396] = -2;
    PeachFrameX[405] = -14;
    PeachFrameY[405] = -2;
    PeachFrameX[395] = -4;
    PeachFrameY[395] = -2;
    PeachFrameX[406] = -8;
    PeachFrameY[406] = -2;
    PeachFrameX[394] = -14;
    PeachFrameY[394] = -2;
    PeachFrameX[407] = -4;
    PeachFrameY[407] = -2;
    PeachFrameX[393] = -4;
    PeachFrameY[393] = -2;
    PeachFrameX[408] = -14;
    PeachFrameY[408] = -2;
    PeachFrameX[392] = -4;
    PeachFrameY[392] = -2;
    PeachFrameX[409] = -14;
    PeachFrameY[409] = -2;
    PeachFrameX[391] = -4;
    PeachFrameY[391] = -2;
    PeachFrameX[410] = -16;
    PeachFrameY[410] = -2;
    PeachFrameX[390] = -4;
    PeachFrameY[390] = -2;
    PeachFrameX[412] = -16;
    PeachFrameY[412] = -2;
    PeachFrameX[388] = -4;
    PeachFrameY[388] = -2;
    PeachFrameX[413] = -4;
    PeachFrameY[413] = -4;
    PeachFrameX[387] = -4;
    PeachFrameY[387] = -4;
    PeachFrameX[414] = -4;
    PeachFrameY[414] = -2;
    PeachFrameX[386] = -16;
    PeachFrameY[386] = -2;
    PeachFrameX[415] = -4;
    PeachFrameY[415] = -4;
    PeachFrameX[385] = -4;
    PeachFrameY[385] = -4;
    PeachFrameX[419] = -13;
    PeachFrameY[419] = 0;
    PeachFrameX[381] = -11;
    PeachFrameY[381] = 0;
    PeachFrameX[420] = -13;
    PeachFrameY[420] = 0;
    PeachFrameX[380] = -11;
    PeachFrameY[380] = 0;
    PeachFrameX[421] = -13;
    PeachFrameY[421] = 0;
    PeachFrameX[379] = -11;
    PeachFrameY[379] = 0;
    PeachFrameX[422] = 0;
    PeachFrameY[422] = -30;
    PeachFrameX[378] = 0;
    PeachFrameY[378] = -30;
    PeachFrameX[423] = 0;
    PeachFrameY[423] = -30;
    PeachFrameX[377] = 0;
    PeachFrameY[377] = -30;
    PeachFrameX[425] = 0;
    PeachFrameY[425] = -2;
    PeachFrameX[375] = 0;
    PeachFrameY[375] = -2;
    PeachFrameX[426] = 0;
    PeachFrameY[426] = -2;
    PeachFrameX[374] = 0;
    PeachFrameY[374] = -2;
    PeachFrameX[427] = -4;
    PeachFrameY[427] = -2;
    PeachFrameX[373] = -4;
    PeachFrameY[373] = -2;
    PeachFrameX[501] = -16;
    PeachFrameY[501] = -6;
    PeachFrameX[499] = -4;
    PeachFrameY[499] = -6;
    PeachFrameX[502] = -18;
    PeachFrameY[502] = -6;
    PeachFrameX[498] = -4;
    PeachFrameY[498] = -6;
    PeachFrameX[503] = -16;
    PeachFrameY[503] = -6;
    PeachFrameX[497] = -4;
    PeachFrameY[497] = -6;
    PeachFrameX[504] = -14;
    PeachFrameY[504] = -6;
    PeachFrameX[496] = -4;
    PeachFrameY[496] = -6;
    PeachFrameX[505] = -14;
    PeachFrameY[505] = -6;
    PeachFrameX[495] = -4;
    PeachFrameY[495] = -6;
    PeachFrameX[506] = -8;
    PeachFrameY[506] = -6;
    PeachFrameX[494] = -12;
    PeachFrameY[494] = -6;
    PeachFrameX[507] = -4;
    PeachFrameY[507] = -6;
    PeachFrameX[493] = -4;
    PeachFrameY[493] = -6;
    PeachFrameX[508] = -16;
    PeachFrameY[508] = -6;
    PeachFrameX[492] = -4;
    PeachFrameY[492] = -6;
    PeachFrameX[509] = -18;
    PeachFrameY[509] = -6;
    PeachFrameX[491] = -4;
    PeachFrameY[491] = -6;
    PeachFrameX[510] = -18;
    PeachFrameY[510] = -6;
    PeachFrameX[490] = -4;
    PeachFrameY[490] = -6;
    PeachFrameX[512] = -16;
    PeachFrameY[512] = -6;
    PeachFrameX[488] = -4;
    PeachFrameY[488] = -6;
    PeachFrameX[513] = -4;
    PeachFrameY[513] = -2;
    PeachFrameX[487] = -4;
    PeachFrameY[487] = -2;
    PeachFrameX[514] = -4;
    PeachFrameY[514] = -6;
    PeachFrameX[486] = -16;
    PeachFrameY[486] = -6;
    PeachFrameX[515] = -4;
    PeachFrameY[515] = -6;
    PeachFrameX[485] = -4;
    PeachFrameY[485] = -6;
    PeachFrameX[519] = -13;
    PeachFrameY[519] = -4;
    PeachFrameX[481] = -9;
    PeachFrameY[481] = -4;
    PeachFrameX[520] = -13;
    PeachFrameY[520] = -4;
    PeachFrameX[480] = -9;
    PeachFrameY[480] = -4;
    PeachFrameX[521] = -13;
    PeachFrameY[521] = -4;
    PeachFrameX[479] = -9;
    PeachFrameY[479] = -4;
    PeachFrameX[522] = 0;
    PeachFrameY[522] = -34;
    PeachFrameX[478] = 0;
    PeachFrameY[478] = -34;
    PeachFrameX[523] = 0;
    PeachFrameY[523] = -34;
    PeachFrameX[477] = 0;
    PeachFrameY[477] = -34;
    PeachFrameX[525] = 0;
    PeachFrameY[525] = 0;
    PeachFrameX[475] = 0;
    PeachFrameY[475] = 0;
    PeachFrameX[526] = 0;
    PeachFrameY[526] = 0;
    PeachFrameX[474] = 0;
    PeachFrameY[474] = 0;
    PeachFrameX[527] = -6;
    PeachFrameY[527] = -6;
    PeachFrameX[473] = -6;
    PeachFrameY[473] = -6;
    PeachFrameX[500] = -5;
    PeachFrameY[500] = -6;

    PeachFrameX[601] = -10;
    PeachFrameY[601] = -2;
    PeachFrameX[599] = -4;
    PeachFrameY[599] = -2;
    PeachFrameX[602] = -10;
    PeachFrameY[602] = -2;
    PeachFrameX[598] = -4;
    PeachFrameY[598] = -2;
    PeachFrameX[603] = -8;
    PeachFrameY[603] = -2;
    PeachFrameX[597] = -4;
    PeachFrameY[597] = -2;
    PeachFrameX[604] = -8;
    PeachFrameY[604] = -2;
    PeachFrameX[596] = -4;
    PeachFrameY[596] = -2;
    PeachFrameX[605] = -8;
    PeachFrameY[605] = -2;
    PeachFrameX[595] = -4;
    PeachFrameY[595] = -2;
    PeachFrameX[606] = -6;
    PeachFrameY[606] = -2;
    PeachFrameX[594] = -6;
    PeachFrameY[594] = -2;
    PeachFrameX[607] = -4;
    PeachFrameY[607] = -4;
    PeachFrameX[593] = -4;
    PeachFrameY[593] = -4;
    PeachFrameX[608] = -6;
    PeachFrameY[608] = -2;
    PeachFrameX[592] = -4;
    PeachFrameY[592] = -2;
    PeachFrameX[609] = -6;
    PeachFrameY[609] = -2;
    PeachFrameX[591] = -4;
    PeachFrameY[591] = -2;
    PeachFrameX[610] = -8;
    PeachFrameY[610] = -2;
    PeachFrameX[590] = -4;
    PeachFrameY[590] = -2;
    PeachFrameX[611] = -6;
    PeachFrameY[611] = -2;
    PeachFrameX[589] = -4;
    PeachFrameY[589] = -2;
    PeachFrameX[612] = -6;
    PeachFrameY[612] = -2;
    PeachFrameX[588] = -4;
    PeachFrameY[588] = -2;
    PeachFrameX[613] = -4;
    PeachFrameY[613] = 2;
    PeachFrameX[587] = -4;
    PeachFrameY[587] = 2;
    PeachFrameX[615] = -4;
    PeachFrameY[615] = -4;
    PeachFrameX[585] = -4;
    PeachFrameY[585] = -4;
    PeachFrameX[622] = 0;
    PeachFrameY[622] = -34;
    PeachFrameX[578] = 0;
    PeachFrameY[578] = -34;
    PeachFrameX[623] = 0;
    PeachFrameY[623] = -32;
    PeachFrameX[577] = 0;
    PeachFrameY[577] = -32;
    PeachFrameX[625] = 0;
    PeachFrameY[625] = 2;
    PeachFrameX[575] = 0;
    PeachFrameY[575] = 2;
    PeachFrameX[626] = 0;
    PeachFrameY[626] = 2;
    PeachFrameX[574] = 0;
    PeachFrameY[574] = 2;
    PeachFrameX[627] = -4;
    PeachFrameY[627] = -4;
    PeachFrameX[573] = -4;
    PeachFrameY[573] = -4;

    ToadFrameX[401] = -14;
    ToadFrameY[401] = -2;
    ToadFrameX[399] = -4;
    ToadFrameY[399] = -2;
    ToadFrameX[402] = -12;
    ToadFrameY[402] = -2;
    ToadFrameX[398] = -4;
    ToadFrameY[398] = -2;
    ToadFrameX[403] = -18;
    ToadFrameY[403] = -2;
    ToadFrameX[397] = -4;
    ToadFrameY[397] = -2;
    ToadFrameX[404] = -18;
    ToadFrameY[404] = -2;
    ToadFrameX[396] = -4;
    ToadFrameY[396] = -2;
    ToadFrameX[405] = -18;
    ToadFrameY[405] = -2;
    ToadFrameX[395] = -4;
    ToadFrameY[395] = -2;
    ToadFrameX[406] = -6;
    ToadFrameY[406] = -2;
    ToadFrameX[394] = -4;
    ToadFrameY[394] = -2;
    ToadFrameX[407] = -4;
    ToadFrameY[407] = 0;
    ToadFrameX[393] = -4;
    ToadFrameY[393] = 0;
    ToadFrameX[408] = -16;
    ToadFrameY[408] = -2;
    ToadFrameX[392] = -4;
    ToadFrameY[392] = -2;
    ToadFrameX[409] = -14;
    ToadFrameY[409] = -2;
    ToadFrameX[391] = -4;
    ToadFrameY[391] = -2;
    ToadFrameX[410] = -18;
    ToadFrameY[410] = -2;
    ToadFrameX[390] = -4;
    ToadFrameY[390] = -2;
    ToadFrameX[411] = -14;
    ToadFrameY[411] = -2;
    ToadFrameX[389] = -4;
    ToadFrameY[389] = -2;
    ToadFrameX[412] = -16;
    ToadFrameY[412] = -2;
    ToadFrameX[388] = -4;
    ToadFrameY[388] = -2;
    ToadFrameX[413] = -4;
    ToadFrameY[413] = -4;
    ToadFrameX[387] = -4;
    ToadFrameY[387] = -4;
    ToadFrameX[414] = -4;
    ToadFrameY[414] = -2;
    ToadFrameX[386] = -14;
    ToadFrameY[386] = -2;
    ToadFrameX[415] = -4;
    ToadFrameY[415] = -2;
    ToadFrameX[385] = -4;
    ToadFrameY[385] = -2;
    ToadFrameX[416] = -18;
    ToadFrameY[416] = -2;
    ToadFrameX[384] = -8;
    ToadFrameY[384] = -2;
    ToadFrameX[417] = -18;
    ToadFrameY[417] = -2;
    ToadFrameX[383] = -8;
    ToadFrameY[383] = -2;
    ToadFrameX[418] = -18;
    ToadFrameY[418] = -2;
    ToadFrameX[382] = -8;
    ToadFrameY[382] = -2;
    ToadFrameX[419] = -12;
    ToadFrameY[419] = -2;
    ToadFrameX[381] = -8;
    ToadFrameY[381] = -2;
    ToadFrameX[420] = -18;
    ToadFrameY[420] = -2;
    ToadFrameX[380] = -8;
    ToadFrameY[380] = -2;
    ToadFrameX[421] = -14;
    ToadFrameY[421] = -2;
    ToadFrameX[379] = -8;
    ToadFrameY[379] = -2;
    ToadFrameX[422] = -4;
    ToadFrameY[422] = -22;
    ToadFrameX[378] = -4;
    ToadFrameY[378] = -22;
    ToadFrameX[423] = -4;
    ToadFrameY[423] = -16;
    ToadFrameX[377] = -4;
    ToadFrameY[377] = -16;
    ToadFrameX[424] = -8;
    ToadFrameY[424] = 6;
    ToadFrameX[376] = -4;
    ToadFrameY[376] = 6;
    ToadFrameX[425] = -4;
    ToadFrameY[425] = -4;
    ToadFrameX[375] = -4;
    ToadFrameY[375] = -4;
    ToadFrameX[426] = -4;
    ToadFrameY[426] = -4;
    ToadFrameX[374] = -4;
    ToadFrameY[374] = -4;
    ToadFrameX[427] = -4;
    ToadFrameY[427] = 0;
    ToadFrameX[373] = -4;
    ToadFrameY[373] = 0;




    ToadFrameX[501] = -12;
    ToadFrameY[501] = -2;
    ToadFrameX[499] = -4;
    ToadFrameY[499] = -2;
    ToadFrameX[502] = -12;
    ToadFrameY[502] = -2;
    ToadFrameX[498] = -4;
    ToadFrameY[498] = -2;
    ToadFrameX[503] = -18;
    ToadFrameY[503] = -2;
    ToadFrameX[497] = -4;
    ToadFrameY[497] = -2;
    ToadFrameX[504] = -18;
    ToadFrameY[504] = -2;
    ToadFrameX[496] = -4;
    ToadFrameY[496] = -2;
    ToadFrameX[505] = -18;
    ToadFrameY[505] = -2;
    ToadFrameX[495] = -4;
    ToadFrameY[495] = -2;
    ToadFrameX[506] = -6;
    ToadFrameY[506] = -2;
    ToadFrameX[494] = -4;
    ToadFrameY[494] = -2;
    ToadFrameX[507] = -4;
    ToadFrameY[507] = 0;
    ToadFrameX[493] = -4;
    ToadFrameY[493] = 0;
    ToadFrameX[508] = -12;
    ToadFrameY[508] = -2;
    ToadFrameX[492] = -4;
    ToadFrameY[492] = -2;
    ToadFrameX[509] = -12;
    ToadFrameY[509] = -2;
    ToadFrameX[491] = -4;
    ToadFrameY[491] = -2;
    ToadFrameX[510] = -18;
    ToadFrameY[510] = -2;
    ToadFrameX[490] = -4;
    ToadFrameY[490] = -2;
    ToadFrameX[511] = -14;
    ToadFrameY[511] = -2;
    ToadFrameX[489] = -4;
    ToadFrameY[489] = -2;
    ToadFrameX[512] = -14;
    ToadFrameY[512] = -2;
    ToadFrameX[488] = -4;
    ToadFrameY[488] = -2;
    ToadFrameX[513] = -4;
    ToadFrameY[513] = -4;
    ToadFrameX[487] = -4;
    ToadFrameY[487] = -4;
    ToadFrameX[514] = -4;
    ToadFrameY[514] = -2;
    ToadFrameX[486] = -12;
    ToadFrameY[486] = -2;
    ToadFrameX[515] = -4;
    ToadFrameY[515] = -2;
    ToadFrameX[485] = -4;
    ToadFrameY[485] = -2;
    ToadFrameX[516] = -12;
    ToadFrameY[516] = -2;
    ToadFrameX[484] = -8;
    ToadFrameY[484] = -2;
    ToadFrameX[517] = -12;
    ToadFrameY[517] = -2;
    ToadFrameX[483] = -8;
    ToadFrameY[483] = -2;
    ToadFrameX[518] = -18;
    ToadFrameY[518] = -2;
    ToadFrameX[482] = -8;
    ToadFrameY[482] = -2;
    ToadFrameX[519] = -12;
    ToadFrameY[519] = -2;
    ToadFrameX[481] = -8;
    ToadFrameY[481] = -2;
    ToadFrameX[520] = -12;
    ToadFrameY[520] = -2;
    ToadFrameX[480] = -8;
    ToadFrameY[480] = -2;
    ToadFrameX[521] = -14;
    ToadFrameY[521] = -2;
    ToadFrameX[479] = -8;
    ToadFrameY[479] = -2;
    ToadFrameX[522] = -4;
    ToadFrameY[522] = -22;
    ToadFrameX[478] = -4;
    ToadFrameY[478] = -22;
    ToadFrameX[523] = -4;
    ToadFrameY[523] = -16;
    ToadFrameX[477] = -4;
    ToadFrameY[477] = -16;
    ToadFrameX[524] = -12;
    ToadFrameY[524] = 6;
    ToadFrameX[476] = -4;
    ToadFrameY[476] = 6;
    ToadFrameX[525] = -4;
    ToadFrameY[525] = -4;
    ToadFrameX[475] = -4;
    ToadFrameY[475] = -4;
    ToadFrameX[526] = -4;
    ToadFrameY[526] = -4;
    ToadFrameX[474] = -4;
    ToadFrameY[474] = -4;
    ToadFrameX[527] = -4;
    ToadFrameY[527] = -2;
    ToadFrameX[473] = -4;
    ToadFrameY[473] = -2;


    ToadFrameX[601] = -6;
    ToadFrameY[601] = -2;
    ToadFrameX[599] = -4;
    ToadFrameY[599] = -2;

    ToadFrameX[602] = -6;
    ToadFrameY[602] = -2;
    ToadFrameX[598] = -4;
    ToadFrameY[598] = -2;

    ToadFrameX[603] = -6;
    ToadFrameY[603] = -2;
    ToadFrameX[597] = -4;
    ToadFrameY[597] = -2;

    ToadFrameX[604] = -6;
    ToadFrameY[604] = -2;
    ToadFrameX[596] = -4;
    ToadFrameY[596] = -2;

    ToadFrameX[605] = -6;
    ToadFrameY[605] = -2;
    ToadFrameX[595] = -4;
    ToadFrameY[595] = -2;

    ToadFrameX[606] = -6;
    ToadFrameY[606] = -2;
    ToadFrameX[594] = -4;
    ToadFrameY[594] = -2;

    ToadFrameX[607] = -6;
    ToadFrameY[607] = 0;
    ToadFrameX[593] = -6;
    ToadFrameY[593] = 0;

    ToadFrameX[608] = -6;
    ToadFrameY[608] = -2;
    ToadFrameX[592] = -4;
    ToadFrameY[592] = -2;

    ToadFrameX[609] = -6;
    ToadFrameY[609] = -2;
    ToadFrameX[591] = -4;
    ToadFrameY[591] = -2;

    ToadFrameX[610] = -6;
    ToadFrameY[610] = -2;
    ToadFrameX[590] = -4;
    ToadFrameY[590] = -2;

    ToadFrameX[611] = -6;
    ToadFrameY[611] = -2;
    ToadFrameX[589] = -4;
    ToadFrameY[589] = -2;

    ToadFrameX[612] = -6;
    ToadFrameY[612] = -2;
    ToadFrameX[588] = -4;
    ToadFrameY[588] = -2;

    ToadFrameX[613] = -4;
    ToadFrameY[613] = -2;
    ToadFrameX[587] = -4;
    ToadFrameY[587] = -2;

    ToadFrameX[615] = -6;
    ToadFrameY[615] = -2;
    ToadFrameX[585] = -6;
    ToadFrameY[585] = -2;

    ToadFrameX[622] = -4;
    ToadFrameY[622] = -22;
    ToadFrameX[578] = -4;
    ToadFrameY[578] = -22;

    ToadFrameX[623] = -4;
    ToadFrameY[623] = -16;
    ToadFrameX[577] = -4;
    ToadFrameY[577] = -16;

    ToadFrameX[625] = -4;
    ToadFrameY[625] = -2;
    ToadFrameX[575] = -4;
    ToadFrameY[575] = -2;

    ToadFrameX[626] = -4;
    ToadFrameY[626] = -2;
    ToadFrameX[574] = -4;
    ToadFrameY[574] = -2;

    ToadFrameX[627] = -4;
    ToadFrameY[627] = 0;
    ToadFrameX[573] = -4;
    ToadFrameY[573] = 0;


    ToadFrameX[500] = -6;
    ToadFrameY[500] = -6;

    int base = 150;
    int offset_x = -8;
    int offset_y = -2;
    int char1_offset_y = -8;
    for(int A = 750; A <= 1150; A++) // this just fills 750 and above with frames matching big power
    {
        // special case: cyclone power has big sprites
        if(A == 950)
        {
            base = 150;
            offset_x = -2;
            offset_y = -2;
            char1_offset_y = -4;
        }
        else if(A == 1050)
        {
            base = 150;
            offset_x = -6;
            offset_y = 0;
            char1_offset_y = 0;
        }
        else if(A == 850)
        {
            // polar power uses fire sprites as base
            offset_x = -4;
            offset_y = -4;
            char1_offset_y = -6;
        }

        MarioFrameX[A] = MarioFrameX[base] + offset_x;
        MarioFrameY[A] = MarioFrameY[base] + char1_offset_y;
        LuigiFrameX[A] = LuigiFrameX[base] + offset_x;
        LuigiFrameY[A] = LuigiFrameY[base] + offset_y;
        PeachFrameX[A] = PeachFrameX[base] + offset_x;
        PeachFrameY[A] = PeachFrameY[base];
        ToadFrameX[A] = ToadFrameX[base] + offset_x;
        ToadFrameY[A] = ToadFrameY[base];
        LinkFrameX[A] = LinkFrameX[base];
        LinkFrameY[A] = LinkFrameY[base];

        base++;
    }

    // special power corrections
    for(int D = -1; D <= 1; D += 2)
    {
        // cyclone power
        LuigiFrameY[1000 + D * 3] -= 2;
        LuigiFrameY[1000 + D * 4] -= 2;
        LuigiFrameY[1000 + D * 5] -= 2;
        LuigiFrameY[1000 + D * 7] -= 2;
        LuigiFrameY[1000 + D * 10] -= 2;
        LuigiFrameY[1000 + D * 24] -= 2;
        LuigiFrameY[1000 + D * 30] -= 2;
        LuigiFrameY[1000 + D * 31] -= 2;
        LuigiFrameY[1000 + D * 41] -= 2;
        LuigiFrameY[1000 + D * 44] -= 2;

        LuigiFrameY[1000 + D * 6] += 2;
        LuigiFrameY[1000 + D * 23] += 2;

        PeachFrameY[1000 + D * 7] -= 4;
        PeachFrameY[1000 + D * 27] -= 4;

        MarioFrameY[1000 + D * 23] += 2;

        MarioFrameX[1000 + D * 16] = -12;
        MarioFrameX[1000 + D * 17] = -12;
        MarioFrameX[1000 + D * 18] = -12;

        LuigiFrameX[1000 + D * 16] = -12;
        LuigiFrameX[1000 + D * 17] = -12;
        LuigiFrameX[1000 + D * 18] = -12;

        PeachFrameX[1000 + D * 16] = -12;
        PeachFrameX[1000 + D * 17] = -12;
        PeachFrameX[1000 + D * 18] = -12;

        ToadFrameX[1000 + D * 16] = -12;
        ToadFrameX[1000 + D * 17] = -12;
        ToadFrameX[1000 + D * 18] = -12;

        // rolling power
        LinkFrameY[1100 + D * 12] = -12;
        LinkFrameY[1100 + D * 13] = -12;
        LinkFrameY[1100 + D * 14] = -12;
        LinkFrameY[1100 + D * 15] = -12;

        // aquatic frame corrections
        MarioFrameY[800 + D * 4] += 6;
        MarioFrameY[800 + D * 5] += 6;
        MarioFrameY[800 + D * 7] -= 2;
        MarioFrameY[800 + D * 23] += 6;

        LuigiFrameY[800 + D * 4] += 8;
        LuigiFrameY[800 + D * 5] += 8;
        LuigiFrameY[800 + D * 7] -= 8;
        LuigiFrameY[800 + D * 23] += 2;

        PeachFrameY[800 + D * 5] += 4;
        PeachFrameY[800 + D * 7] -= 14;
        PeachFrameY[800 + D * 27] -= 14;

        ToadFrameY[800 + D * 7] -= 12;
        ToadFrameY[800 + D * 8] -= 4;
        ToadFrameY[800 + D * 9] -= 4;
        ToadFrameY[800 + D * 10] -= 4;
        ToadFrameY[800 + D * 27] -= 12;

        // polar frame corrections
        MarioFrameY[900 + D * 23] += 4;
        LuigiFrameY[900 + D * 23] += 4;
        LuigiFrameY[900 + D * 6] += 2;

        // polar slide
        PeachFrameX[900 + D * 14] = ToadFrameX[900 + D * 14] = LuigiFrameX[900 + D * 14] = MarioFrameX[900 + D * 14] = -12 - 8 * D;
        PeachFrameY[900 + D * 14] = ToadFrameY[900 + D * 14] = LuigiFrameY[900 + D * 14] = MarioFrameY[900 + D * 14] = -10;

        // aquatic swim
        for(int C = 800; C <= 900; C += 100)
        {
            PeachFrameX[C + D * 16] = ToadFrameX[C + D * 16] = LuigiFrameX[C + D * 16] = MarioFrameX[C + D * 16] = -12 - 8 * D;
            PeachFrameX[C + D * 17] = ToadFrameX[C + D * 17] = LuigiFrameX[C + D * 17] = MarioFrameX[C + D * 17] = -12 - 8 * D;
            PeachFrameX[C + D * 18] = ToadFrameX[C + D * 18] = LuigiFrameX[C + D * 18] = MarioFrameX[C + D * 18] = -12 - 8 * D;
            PeachFrameY[C + D * 16] = ToadFrameY[C + D * 16] = LuigiFrameY[C + D * 16] = MarioFrameY[C + D * 16] = -10;
            PeachFrameY[C + D * 17] = ToadFrameY[C + D * 17] = LuigiFrameY[C + D * 17] = MarioFrameY[C + D * 17] = -10;
            PeachFrameY[C + D * 18] = ToadFrameY[C + D * 18] = LuigiFrameY[C + D * 18] = MarioFrameY[C + D * 18] = -10;

            PeachFrameX[C + D * 19] = ToadFrameX[C + D * 19] = LuigiFrameX[C + D * 19] = MarioFrameX[C + D * 19] = -4;
            PeachFrameX[C + D * 20] = ToadFrameX[C + D * 20] = LuigiFrameX[C + D * 20] = MarioFrameX[C + D * 20] = -4;
            PeachFrameX[C + D * 21] = ToadFrameX[C + D * 21] = LuigiFrameX[C + D * 21] = MarioFrameX[C + D * 21] = -4;
            PeachFrameY[C + D * 19] = ToadFrameY[C + D * 19] = LuigiFrameY[C + D * 19] = MarioFrameY[C + D * 19] = -24;
            PeachFrameY[C + D * 20] = ToadFrameY[C + D * 20] = LuigiFrameY[C + D * 20] = MarioFrameY[C + D * 20] = -24;
            PeachFrameY[C + D * 21] = ToadFrameY[C + D * 21] = LuigiFrameY[C + D * 21] = MarioFrameY[C + D * 21] = -24;

            PeachFrameX[C + D * 40] = ToadFrameX[C + D * 40] = LuigiFrameX[C + D * 40] = MarioFrameX[C + D * 40] = -4;
            PeachFrameX[C + D * 41] = ToadFrameX[C + D * 41] = LuigiFrameX[C + D * 41] = MarioFrameX[C + D * 41] = -4;
            PeachFrameX[C + D * 42] = ToadFrameX[C + D * 42] = LuigiFrameX[C + D * 42] = MarioFrameX[C + D * 42] = -4;
            PeachFrameY[C + D * 40] = ToadFrameY[C + D * 40] = LuigiFrameY[C + D * 40] = MarioFrameY[C + D * 40] = -8;
            PeachFrameY[C + D * 41] = ToadFrameY[C + D * 41] = LuigiFrameY[C + D * 41] = MarioFrameY[C + D * 41] = -8;
            PeachFrameY[C + D * 42] = ToadFrameY[C + D * 42] = LuigiFrameY[C + D * 42] = MarioFrameY[C + D * 42] = -8;
        }
    }
}


================================================
FILE: src/main/record.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

// needed because there are a lot of writes / scans whose failure is detected at the end of the function
// updated versions of glibc don't even seem to trigger this warning in this context
#if !defined(__clang__) && (defined(__GNUC__) || defined(__MINGW32__))
#   pragma GCC diagnostic ignored "-Wunused-result"
#   define XTECH_GCC_UNUSED_RESULT_IGNORED
#endif


// this module handles particular the control recording and playback functions
// and the gameplay stats recording functions

#include "../version.h"

#define LONG_VERSION "TheXTech branch " V_BUILD_BRANCH " commit " V_BUILD_VER
#define SHORT_VERSION V_BUILD_VER

#include "../globals.h"
#include "../rand.h"
#include "../frame_timer.h"
#include "../config.h"
#include "record.h"
#include "message.h"

#include "sdl_proxy/sdl_timer.h"
#include "sdl_proxy/sdl_stdinc.h"

#include <chrono>
#include <fmt_time_ne.h>
#include <fmt_format_ne.h>

#include <cstdint>
#include <cinttypes>
#include <Utils/files.h>
#include <DirManager/dirman.h>
#include <AppPath/app_path.h>
#include <Logger/logger.h>
#include <md5tools.hpp>


#ifndef PRId64 /*Workaround*/
#   ifndef __PRI64_PREFIX
#       if THEXTECH_WORDSIZE == 64
#           ifdef _WIN32
#               define __PRI64_PREFIX   "I64"
#               define __PRIPTR_PREFIX  "I64"
#               ifdef __MINGW32__
#                   pragma GCC diagnostic push
#                   pragma GCC diagnostic ignored "-Wformat="
#                   define X_GCC_NO_WARNING_FORMAT
#               endif
#           else
#               define __PRI64_PREFIX   "l"
#               define __PRIPTR_PREFIX  "l"
#           endif
#       else
#           define __PRI64_PREFIX   "ll"
#           define __PRIPTR_PREFIX
#       endif
#   endif
#   define PRId64   __PRI64_PREFIX "d"
#endif

#ifdef LOW_MEM
#   define PRIvb PRId16
#else
#   define PRIvb "d"
#endif

static std::string makeRecordPrefix()
{
    auto now = std::chrono::system_clock::now();
    std::time_t in_time_t = std::chrono::system_clock::to_time_t(now);
    std::tm t = fmt::localtime_ne(in_time_t);

    return fmt::sprintf_ne("%s%s_%s_%04d-%02d-%02d_%02d-%02d-%02d.rec",
                           AppPathManager::gameplayRecordsRootDir().c_str(), FileName.c_str(), SHORT_VERSION,
                           (1900 + t.tm_year), (1 + t.tm_mon), t.tm_mday,
                           t.tm_hour, t.tm_min, t.tm_sec);
}

static void clipNewLine(char *buffer, size_t maxSize)
{
    for(size_t i = 0; i < maxSize; i++)
    {
        if(buffer[i] == '\r' || buffer[i] == '\n')
        {
            buffer[i] = '\0';
            break;
        }
    }
}


namespace Record
{

// public
FILE* record_file = nullptr;
FILE* replay_file = nullptr;

//! Externally providen level file path for the replay
static std::string replayLevelFilePath;

static const int c_recordVersion = 3;

// private

static bool         in_level = false;
static bool         diverged_major = false;
static bool         diverged_minor = false;
static int64_t      frame_no = 0;
static int64_t      next_record_frame = 0;
static uint32_t     last_status_tick = 0;
static Controls_t   last_controls[maxPlayers];


static void write_header()
{
    // write all necessary state variables!
    fprintf(record_file, "Header\r\n");
    fprintf(record_file, "RecordVersion %d\r\n", c_recordVersion); // Version of record file
    fprintf(record_file, "Version %s\r\n", LONG_VERSION); // game version / commit
    fprintf(record_file, "CompatLevel %d\r\n", (int)g_config.compatibility_mode); // compatibility mode
    if(FullFileName.compare(0, AppPath.size(), AppPath) == 0)
        fprintf(record_file, "%s\r\n", FullFileName.c_str()+AppPath.size()); // level that was played
    else
        fprintf(record_file, "%s\r\n", FullFileName.c_str()); // level that was played

    std::string md5sum = md5::file_to_hashGC(FullFileName);
    fprintf(record_file, "SumMD5 %s\r\n", md5sum.c_str()); // level that was played
    fprintf(record_file, "Seed %d\r\n", readSeed());
    fprintf(record_file, "Checkpoint %d\r\n", (Checkpoint == FullFileName) ? 1 : 0);

    if(g_config.fix_vanilla_checkpoints && Checkpoint == FullFileName)
    {
        fprintf(record_file, "Multipoints %d: ", (int)CheckpointsList.size());

        for(const Checkpoint_t& cp : CheckpointsList)
            fprintf(record_file, "%d,", cp.id);

        fprintf(record_file, "\r\n");
    }

    fprintf(record_file, "StartWarp %d\r\n", StartWarp);
    fprintf(record_file, "ReturnWarp %d\r\n", ReturnWarp);
    fprintf(record_file, "Lives %d\r\n", (int)Lives);
    fprintf(record_file, "Coins %d\r\n", Coins);
    fprintf(record_file, "Score %d\r\n", Score);
    fprintf(record_file, "Stars %d\r\n", numStars);

    for(const auto& star : Star)
    {
        fprintf(record_file, "Star\r\n");
        fprintf(record_file, "%s\r\n", star.level.c_str());
        fprintf(record_file, "Section %d\r\n", star.Section);
    }

    fprintf(record_file, "Players %d\r\n", numPlayers);

    for(int A = 1; A <= numPlayers; A++)
    {
        fprintf(record_file,
                "Player\r\n"
                "Char %d\r\n"
                "State %d\r\n"
                "Mount %d\r\n"
                "MountType %d\r\n"
                "HeldBonus %d\r\n",
                (int)Player[A].Character, (int)Player[A].State, (int)Player[A].Mount, (int)Player[A].MountType, (int)Player[A].HeldBonus);
    }
}

// FIXME: Implement the error returning and on-failure abortation with leading abortation of record replaying startup

static void read_header()
{
    rewind(replay_file); // fseek(replay_file, 0, SEEK_SET);

    // buffer is a 1024-character buffer used for reading strings, shared with the record_init() function.
    char buffer[1024];
    char md5hash[1024];
    std::string thisHash;

    // n is an integer for some implicit conversions
    int n;
    // Version of record file
    int recordVersion = 0;

    // read all necessary state variables!
    fgets(buffer, 1024, replay_file); // "Header"
    fscanf(replay_file, "RecordVersion %d\r\n", &recordVersion);

    pLogDebug("Loading recording version %d", recordVersion);

    if(recordVersion < 2)
        pLogCritical("Record file is invalid! (version below than minimally supported: %d)", recordVersion);

    fgets(buffer, 1024, replay_file); // game version / commit

    pLogDebug("Recording made with %s", buffer);

    fscanf(replay_file, "CompatLevel %d\r\n", &n); // compatibility mode

    pLogDebug("  at compat level %d", n);

    if(n != Config_t::COMPAT_SMBX13)
        pLogWarning("compatibility mode is not a long-term support version. Do not expect identical results.");

    g_config.compatibility_mode = n;
    UpdateConfig();

    fgets(buffer, 1024, replay_file); // level that was played

    clipNewLine(buffer, 1024); // clip the newline :(

    // now SET the filename
    FullFileName = replayLevelFilePath.empty() ? buffer : replayLevelFilePath;
    // if(SDL_strcasecmp(buffer, FilefNameFull.c_str()))
    //     pLogWarning("FileName does not match.");

    pLogDebug("Attempt to load level file %s for the replay", FullFileName.c_str());

    thisHash = md5::file_to_hashGC(FullFileName);

    if(thisHash.empty())
    {
        FullFileName = AppPath + FullFileName;
        pLogDebug("Not found; attempt to load level file %s for the replay", FullFileName.c_str());
        thisHash = md5::file_to_hashGC(FullFileName);
    }

    if(thisHash.empty())
        pLogCritical("Failed to retrieve the MD5 hash for %s file (probably, it doesn't exist)", FullFileName.c_str());

    SDL_memset(md5hash, 0, sizeof(md5hash));
    fscanf(replay_file, "SumMD5 %s\r\n", md5hash); // File's hash
    pLogDebug("Replay file (loaded %s, expected %s)", thisHash.c_str(), md5hash);
    int hashCmp = thisHash.compare(md5hash);
    if(hashCmp != 0)
        pLogCritical("Loaded level file is not matched to expected (check sum missmatch %d)", hashCmp);

    fscanf(replay_file, "Seed %d\r\n", &n); // random seed
    seedRandom(n);

    fscanf(replay_file, "Checkpoint %d\r\n", &n); // is there a checkpoint?

    Checkpoint = n ? FullFileName : std::string();

    if(g_config.fix_vanilla_checkpoints && Checkpoint == FullFileName)
    {
        CheckpointsList.clear();
        fscanf(replay_file, "Multipoints %d: ", &n);
        CheckpointsList.resize(n);

        for(int i = 0; i < n; i++)
            fscanf(replay_file, "%d,", &CheckpointsList[i].id);

        fscanf(replay_file, "\r\n");
    }

    fscanf(replay_file, "StartWarp %d\r\n", &StartWarp);
    fscanf(replay_file, "ReturnWarp %d\r\n", &ReturnWarp);
    fscanf(replay_file, "Lives %d\r\n", &n);
    Lives = n;
    fscanf(replay_file, "Coins %d\r\n", &Coins);
    fscanf(replay_file, "Score %d\r\n", &Score);
    fscanf(replay_file, "Stars %d\r\n", &numStars);
    
    if(Star.capacity() < (size_t)numStars)
        Star.reserve(numStars);

    for(int A = 1; A <= numStars; A++)
    {
        Star_t star;
        fgets(buffer, 1024, replay_file); // "Star"
        fgets(buffer, 1024, replay_file); // level

        for(int i = 0; i < 1024; i++)
            if(buffer[i] == '\r') buffer[i] = '\0'; // clip the newline :(

        star.level = buffer;
        fscanf(replay_file, "Section %d\r\n", &star.Section);
        Star.push_back(std::move(star));
    }

    fscanf(replay_file, "Players %d\r\n", &numPlayers);

    for(int A = 1; A <= numPlayers; A++)
    {
        vbint_t HeldBonus = NPCID(0);

        if(recordVersion < 3)
            fscanf(replay_file,
                   "Player\r\n"
                   "Char %" PRIvb "\r\n"
                   "State %" PRIvb "\r\n"
                   "MountType %" PRIvb "\r\n"
                   "HeldBonus %" PRIvb "\r\n",
                &Player[A].Character, &Player[A].State, &Player[A].MountType, &HeldBonus);
        else
            fscanf(replay_file,
                   "Player\r\n"
                   "Char %" PRIvb "\r\n"
                   "State %" PRIvb "\r\n"
                   "Mount %" PRIvb "\r\n"
                   "MountType %" PRIvb "\r\n"
                   "HeldBonus %" PRIvb "\r\n",
                &Player[A].Character, &Player[A].State, &Player[A].Mount, &Player[A].MountType, &HeldBonus);

        Player[A].HeldBonus = NPCID(HeldBonus);
    }

    Cheater = true; // important to avoid losing player save data in replay mode.
    TestLevel = false;
    g_config.unlimited_framerate = true;
    g_config.show_fps = true;
    g_config.enable_frameskip = false;
}

static void write_end()
{
    fprintf(record_file, " %" PRId64 " \r\nEnd\r\nLevelBeatCode %d\r\n", frame_no+1, (int)LevelBeatCode);
}

static void read_end()
{
    int b;

    if(fscanf(replay_file, "End\r\nLevelBeatCode %d\r\n", &b) != 1)
    {
        pLogWarning("old gameplay file diverged (invalid end header).");
        diverged_major = true;
    }

    if(next_record_frame-1 != frame_no)
    {
        pLogWarning("final frame_no diverged (old: %" PRId64 ", new: %" PRId64 ").", next_record_frame-1, frame_no);
        diverged_major = true;
    }

    if(b != LevelBeatCode && !(b == -1 && LevelBeatCode == 0))
    {
        pLogWarning("LevelBeatCode diverged (old: %d, new: %d).", b, LevelBeatCode);
        diverged_major = true;
    }
}

static void write_control()
{
    for(int i = 0; i < numPlayers; i++)
    {
        const Controls_t& keys = Player[i+1].Controls;

        if(!last_controls[i].Up && keys.Up)
            fprintf(record_file, " %" PRId64 "\r\nC+%dU\r\n", frame_no, i+1);
        else if(last_controls[i].Up && !keys.Up)
            fprintf(record_file, " %" PRId64 "\r\nC-%dU\r\n", frame_no, i+1);

        if(!last_controls[i].Down && keys.Down)
            fprintf(record_file, " %" PRId64 "\r\nC+%dD\r\n", frame_no, i+1);
        else if(last_controls[i].Down && !keys.Down)
            fprintf(record_file, " %" PRId64 "\r\nC-%dD\r\n", frame_no, i+1);

        if(!last_controls[i].Left && keys.Left)
            fprintf(record_file, " %" PRId64 "\r\nC+%dL\r\n", frame_no, i+1);
        else if(last_controls[i].Left && !keys.Left)
            fprintf(record_file, " %" PRId64 "\r\nC-%dL\r\n", frame_no, i+1);

        if(!last_controls[i].Right && keys.Right)
            fprintf(record_file, " %" PRId64 "\r\nC+%dR\r\n", frame_no, i+1);
        else if(last_controls[i].Right && !keys.Right)
            fprintf(record_file, " %" PRId64 "\r\nC-%dR\r\n", frame_no, i+1);

        if(!last_controls[i].Start && keys.Start)
            fprintf(record_file, " %" PRId64 "\r\nC+%dS\r\n", frame_no, i+1);
        else if(last_controls[i].Start && !keys.Start)
            fprintf(record_file, " %" PRId64 "\r\nC-%dS\r\n", frame_no, i+1);

        if(!last_controls[i].Drop && keys.Drop)
            fprintf(record_file, " %" PRId64 "\r\nC+%dI\r\n", frame_no, i+1);
        else if(last_controls[i].Drop && !keys.Drop)
            fprintf(record_file, " %" PRId64 "\r\nC-%dI\r\n", frame_no, i+1);

        if(!last_controls[i].Jump && keys.Jump)
            fprintf(record_file, " %" PRId64 "\r\nC+%dA\r\n", frame_no, i+1);
        else if(last_controls[i].Jump && !keys.Jump)
            fprintf(record_file, " %" PRId64 "\r\nC-%dA\r\n", frame_no, i+1);

        if(!last_controls[i].Run && keys.Run)
            fprintf(record_file, " %" PRId64 "\r\nC+%dB\r\n", frame_no, i+1);
        else if(last_controls[i].Run && !keys.Run)
            fprintf(record_file, " %" PRId64 "\r\nC-%dB\r\n", frame_no, i+1);

        if(!last_controls[i].AltJump && keys.AltJump)
            fprintf(record_file, " %" PRId64 "\r\nC+%dX\r\n", frame_no, i+1);
        else if(last_controls[i].AltJump && !keys.AltJump)
            fprintf(record_file, " %" PRId64 "\r\nC-%dX\r\n", frame_no, i+1);

        if(!last_controls[i].AltRun && keys.AltRun)
            fprintf(record_file, " %" PRId64 "\r\nC+%dY\r\n", frame_no, i+1);
        else if(last_controls[i].AltRun && !keys.AltRun)
            fprintf(record_file, " %" PRId64 "\r\nC-%dY\r\n", frame_no, i+1);

        last_controls[i] = keys;
    }

    fflush(record_file);
}

static void read_control()
{
    int p;
    char mode, key;

    if(fscanf(replay_file, "C%c%d%c\r\n", &mode, &p, &key) != 3)
        return;

    bool set = (mode != '-');

    if(key == 'U')
        last_controls[p-1].Up = set;
    else if(key == 'D')
        last_controls[p-1].Down = set;
    else if(key == 'L')
        last_controls[p-1].Left = set;
    else if(key == 'R')
        last_controls[p-1].Right = set;
    else if(key == 'S')
        last_controls[p-1].Start = set;
    else if(key == 'I')
        last_controls[p-1].Drop = set;
    else if(key == 'A')
        last_controls[p-1].Jump = set;
    else if(key == 'B')
        last_controls[p-1].Run = set;
    else if(key == 'X')
        last_controls[p-1].AltJump = set;
    else if(key == 'Y')
        last_controls[p-1].AltRun = set;

    // replicate the controls changes in the new recording
    if(record_file)
    {
        fprintf(record_file, " %" PRId64 "\r\nC%c%d%c\r\n", frame_no, mode, p, key);
    }
}

static void write_status()
{
    if(frame_no == 0)
    {
        g_stats.renderedNPCs = 0;
        g_stats.renderedBlocks = 0;
        g_stats.renderedBGOs = 0;
    }

    fprintf(record_file, " %" PRId64 " \r\nStatus\r\n", frame_no);
    uint32_t status_tick = SDL_GetTicks();
    fprintf(record_file, "Ticks %lu\r\n", (long unsigned)(SDL_GetTicks() - last_status_tick));
    last_status_tick = status_tick;
    fprintf(record_file, "randCalls %ld\r\n", random_ncalls());
    fprintf(record_file, "Score %d\r\n", Score);
    fprintf(record_file, "numNPCs %d\r\n", numNPCs);

    int numActiveNPCs = 0;
    if(frame_no != 0)
    {
        for(int i = 1; i <= numNPCs; i++)
        {
            if(NPC[i].Active)
                numActiveNPCs ++;
        }
    }

    fprintf(record_file, "numActiveNPCs %d\r\n", numActiveNPCs);
    fprintf(record_file, "numRenderNPCs %d\r\nnumRenderBlocks %d\r\nnumRenderBGOs %d\r\n",
        g_stats.renderedNPCs, g_stats.renderedBlocks, g_stats.renderedBGOs);

    for(int i = 1; i <= numPlayers; i++)
    {
        fprintf(record_file, "p%dx %lf\r\np%dy %lf\r\n",
            i, (double)Player[i].Location.X, i, (double)Player[i].Location.Y);
    }

    fflush(record_file);
}

static void read_status()
{
    if(frame_no == 0)
    {
        g_stats.renderedNPCs = 0;
        g_stats.renderedBlocks = 0;
        g_stats.renderedBGOs = 0;
    }

    int o_ticks, o_Score, o_numNPCs, o_numActiveNPCs, o_renderedNPCs, o_renderedBlocks, o_renderedBGOs;
    long o_randCalls;

    int success = 0;

    fscanf(replay_file, "Status\r\n%n", &success);

    if(!success)
    {
        pLogWarning("old gameplay file diverged (invalid status header) at frame %" PRId64 ".", frame_no);
        diverged_major = true;
        return;
    }

    if(fscanf(replay_file,
              "Ticks %d\r\n"
              "randCalls %ld\r\n"
              "Score %d\r\n"
              "numNPCs %d\r\n"
              "numActiveNPCs %d\r\n"
              "numRenderNPCs %d\r\n"
              "numRenderBlocks %d\r\n"
              "numRenderBGOs %d\r\n",
        &o_ticks, &o_randCalls, &o_Score, &o_numNPCs, &o_numActiveNPCs, &o_renderedNPCs, &o_renderedBlocks, &o_renderedBGOs) != 8)
    {
        pLogWarning("old gameplay file diverged (invalid status info) at frame %" PRId64 ".", frame_no);
        diverged_major = true;
        return;
    }

    if(o_randCalls != random_ncalls())
    {
        pLogWarning("randCalls diverged (old: %ld, new: %ld) at frame %" PRId64 ".", o_randCalls, random_ncalls(), frame_no);
        diverged_minor = true;
#ifdef DEBUG_RANDOM_CALLS
        for(int i = 0; i < g_random_calls.size(); i++)
            printf("%p\n", g_random_calls[i]);
#endif
        pLogWarning("  Resetting random engine to match.");
        random_set_ncalls(o_randCalls);
    }
#ifdef DEBUG_RANDOM_CALLS
    g_random_calls.clear();
#endif

    if(o_Score != Score)
    {
        pLogWarning("score diverged (old: %d, new: %d) at frame %" PRId64 ".", o_Score, Score, frame_no);
        diverged_major = true;
    }

    if(o_numNPCs != numNPCs)
    {
        pLogWarning("numNPCs diverged (old: %d, new: %d) at frame %" PRId64 ".", o_numNPCs, numNPCs, frame_no);
        diverged_major = true;
    }

    int numActiveNPCs = 0;
    if(frame_no != 0)
    {
        for(int i = 1; i <= numNPCs; i++)
        {
            if(NPC[i].Active)
                numActiveNPCs ++;
        }
    }

    if(o_numActiveNPCs != numActiveNPCs)
    {
        pLogWarning("numActiveNPCs diverged (old: %d, new: %d) at frame %" PRId64 ".", o_numActiveNPCs, numActiveNPCs, frame_no);
        diverged_minor = true;
    }

    if(o_renderedNPCs != g_stats.renderedNPCs)
    {
        pLogWarning("renderedNPCs diverged (old: %d, new: %d) at frame %" PRId64 ".", o_renderedNPCs, g_stats.renderedNPCs, frame_no);
        diverged_minor = true;
    }

    if(o_renderedBlocks != g_stats.renderedBlocks)
    {
        pLogWarning("renderedBlocks diverged (old: %d, new: %d) at frame %" PRId64 ".", o_renderedBlocks, g_stats.renderedBlocks, frame_no);
        diverged_minor = true;
    }

    if(o_renderedBGOs != g_stats.renderedBGOs)
    {
        pLogWarning("renderedBGOs diverged (old: %d, new: %d) at frame %" PRId64 ".", o_renderedBGOs, g_stats.renderedBGOs, frame_no);
        diverged_minor = true;
    }

    for(int i = 1; i <= numPlayers; i++)
    {
        double px, py;

        if(fscanf(replay_file, "p%dx %lf\r\np%dy %lf\r\n", &success, &px, &success, &py) != 4)
        {
            pLogWarning("old gameplay file diverged (invalid player %d info) at frame %" PRId64 ".", i, frame_no);
            diverged_major = true;
            break;
        }

        num_t dx = num_t::abs(num_t::from_double(px) - Player[i].Location.X);
        num_t dy = num_t::abs(num_t::from_double(py) - Player[i].Location.Y);

        // quite non-strict because in a true divergence situation, it will get continually worse
        if(dx > 0.01_n || dy > 0.01_n)
        {
            pLogWarning("player %d position diverged (old x=%f new x=%f, old y=%f new y=%f) at frame %" PRId64 ".",
                        i,
                        px, (double)Player[i].Location.X,
                        py, (double)Player[i].Location.Y, frame_no);
            diverged_minor = true;
            if(dx > 1 || dy > 1)
            {
                pLogWarning("  this is a major divergence.");
                diverged_major = true;
            }
        }
    }
}

static void write_NPCs()
{
    fprintf(record_file, " %" PRId64 " \r\nNPCs\r\nnumNPCs %d\r\n", frame_no, numNPCs);
    for(int i = 1; i <= numNPCs; i++)
    {
        const NPC_t& n = NPC[i];
        fprintf(record_file, "NPC %d\r\n", i);
        fprintf(record_file, "Type %d\r\n", n.Type);
        fprintf(record_file, "Active %d\r\n", n.Active);
        fprintf(record_file, "Dir %lf\r\n", (double)n.Direction);
        fprintf(record_file, "XYWH %lf %lf %lf %lf\r\n", (double)n.Location.X, (double)n.Location.Y, (double)n.Location.Width, (double)n.Location.Height);
        fprintf(record_file, "S %lf %lf %lf %lf %lf %lf %lf\r\n", (double)n.Special, (double)n.Special2, (double)n.Special3, (double)n.Special4, (double)n.Special5, (double)n.SpecialX, (double)n.SpecialY);
    }
}

static void read_NPCs()
{
    int success = 0;

    fscanf(replay_file, "NPCs\r\n%n", &success);

    // will only possibly be used in the cases where it is initialized by fscanf
    int o_numNPCs = 0;

    if(!success || fscanf(replay_file, "numNPCs %d\r\n", &o_numNPCs) != 1)
        success = 0;
    else if(o_numNPCs != numNPCs)
    {
        pLogWarning("numNPCs diverged (old %d, new %d) at frame %" PRId64 ".", o_numNPCs, numNPCs, frame_no);
        diverged_major = true;
    }

    if(success)
    {
        for(int i = 1; i <= o_numNPCs; i++)
        {
            int N, T, A;
            double D, X, Y, W, H, S1, S2, S3, S4, S5, S6, S7;
            bool invalid = false;

            invalid |= (fscanf(replay_file,
                               "NPC %d\r\n"
                               "Type %d\r\n"
                               "Active %d\r\n",
                               &N, &T, &A) != 3);
            invalid |= fscanf(replay_file,
                              "Dir %lf\r\n"
                              "XYWH %lf %lf %lf %lf\r\n"
                              "S %lf %lf %lf %lf %lf %lf",
                              &D, &X, &Y, &W, &H, &S1, &S2, &S3, &S4, &S5, &S6) != 11;

            if(invalid)
            {
                pLogWarning("old gameplay file diverged (invalid NPC %d data) at frame %" PRId64 ".", i, frame_no);
                diverged_major = true;
                return;
            }

            // either '\r' (no S7) or ' ' (S7)
            if(fgetc(replay_file) == ' ')
            {
                fscanf(replay_file, "%lf\r\n", &S7);
            }
            else
            {
                S7 = 0;
                fgetc(replay_file); // '\n'
            }

            if(N != i)
            {
                pLogWarning("old gameplay file diverged (NPC %d index listed as %d) at frame %" PRId64 ".", i, N, frame_no);
                diverged_major = true;
                continue;
            }

            if(i > numNPCs)
                continue;

            const NPC_t& n = NPC[i];

            if(T != n.Type)
            {
                pLogWarning("NPC[%d].Type diverged (old %d, new %d) at frame %" PRId64 ".", i, T, n.Type, frame_no);
                diverged_major = true;
            }

            if((bool)A != n.Active)
            {
                pLogWarning("NPC[%d].Active diverged (old %d, new %d; type %d) at frame %" PRId64 ".", i, A, n.Active, n.Type, frame_no);
                diverged_minor = true;
            }

            if(D != n.Direction)
            {
                pLogWarning("NPC[%d].Direction diverged (old %f, new %d; type %d) at frame %" PRId64 ".", i, D, n.Direction, n.Type, frame_no);
                diverged_minor = true;
            }

            if(num_t::abs(num_t::from_double(X) - n.Location.X) > 0.01_n ||
               num_t::abs(num_t::from_double(Y) - n.Location.Y) > 0.01_n ||
               num_t::abs(num_t::from_double(W) - n.Location.Width) > 0.01_n ||
               num_t::abs(num_t::from_double(H) - n.Location.Height) > 0.01_n)
            {
                pLogWarning("NPC[%d].Location diverged (old %lf %lf %lf %lf, new %lf %lf %lf %lf; type %d) at frame %" PRId64 ".", i,
                    X, Y, W, H, (double)n.Location.X, (double)n.Location.Y, (double)n.Location.Width, (double)n.Location.Height, n.Type, frame_no);
                diverged_minor = true;
            }

            num_t sOld[] = {num_t::from_double(S1), num_t::from_double(S2), num_t::from_double(S3), num_t::from_double(S4), num_t::from_double(S5), num_t::from_double(S6), num_t::from_double(S7)};
            num_t sNew[] = {n.Special, n.Special2, n.Special3, n.Special4, n.Special5, n.SpecialX, n.SpecialY};

            for(int s = 0; s < 7; ++s)
            {
                if(!num_t::fEqual_d(sOld[s], sNew[s]))
                {
                    pLogWarning("NPC[%d].Special%d diverged (old %f => new %f; type %d) at frame %" PRId64 ".",
                                i, s + 1, (double)sOld[s], (double)sNew[s], n.Type, frame_no);
                    diverged_minor = true;
                }
            }

//            if(S1 != n.Special || S2 != n.Special2 || S3 != n.Special3 || S4 != n.Special4 || S5 != n.Special5 || S6 != n.Special6 || S7 != n.Special7)
//            {
//                pLogWarning("NPC[%d].Special* diverged (old %f %f %f %f %f %f %f, new %f %f %f %f %f %f %f; type %d) at frame %" PRId64 ".", i,
//                    S1, S2, S3, S4, S5, S6, S7, n.Special, n.Special2, n.Special3, n.Special4, n.Special5, n.Special6, n.Special7, n.Type, frame_no);
//                diverged_minor = true;
//            }
        }
    }

    if(!success)
    {
        pLogWarning("old gameplay file diverged (invalid NPC header) at frame %" PRId64 ".", frame_no);
        diverged_major = true;
        return;
    }
}

void InitRecording()
{
    if(LevelEditor || GameMenu || GameOutro || XMessage::Status() != XMessage::Status::local)
        return;

    if(!g_config.record_gameplay_data && !replay_file)
        return;

    in_level = true;
    diverged_major = false;
    diverged_minor = false;
    frame_no = 0;
    next_record_frame = -1;
    last_status_tick = SDL_GetTicks();
    g_stats.renderedNPCs = 0;
    g_stats.renderedBlocks = 0;
    g_stats.renderedBGOs = 0;

    std::string filename = makeRecordPrefix();

    if(!record_file)
        record_file = Files::utf8_fopen(filename.c_str(), "wb");

    // start of gameplay data
    seedRandom(iRand(32767));

    if(replay_file)
    {
        read_header();
        if(!fscanf(replay_file, "%" PRId64 "\r\n", &next_record_frame))
        {
            pLogWarning("Replayed recording file has prematurely ended.");
            diverged_major = true;
            EndRecording();
        }
    }

    if(record_file)
        write_header();

    for(int i = 0; i < numPlayers; i++)
        last_controls[i] = Controls_t();
}

// need to preload level info from the replay to load with proper compat
void LoadReplay(const std::string &recording_path, const std::string &level_path)
{
    if(LevelEditor || GameMenu || GameOutro)
        return;

    replayLevelFilePath = level_path;

    // figure out how many runs have already happened
    if(!replay_file)
    {
        replay_file = Files::utf8_fopen(recording_path.c_str(), "rb");
        if(replay_file)
            read_header();
    }
}

void EndRecording()
{
    if(!record_file && !replay_file)
        return;

    in_level = false;

    if(record_file)
        write_end();

    if(replay_file)
    {
        read_end();

        if(!diverged_minor && !diverged_major)
        {
            pLogDebug("CONGRATULATIONS! Your build's run did not diverge from the old run.");
            printf("CONGRATULATIONS! Your build's run did not diverge from the old run.\n");

            if(record_file)
                fprintf(record_file, "DID NOT diverge from old run.\r\n");
        }
        else if(!diverged_major)
        {
            pLogDebug("Your build's run only had MINOR divergence from the old run.");
            printf("Your build's run only had MINOR divergence from the old run.\n");

            if(record_file)
                fprintf(record_file, "MINOR divergence from old run.\r\n");
        }
        else
        {
            pLogWarning("I'm sorry, but your build's run DIVERGED from the old run.");
            printf("I'm sorry, but your build's run DIVERGED from the old run.\n");
            if(record_file)
                fprintf(record_file, "DIVERGED from old run.\r\n");
        }

        fclose(replay_file);
        replay_file = nullptr;

        GameIsActive = false;
    }

    if(record_file)
    {
        fclose(record_file);
        record_file = nullptr;
    }
}

void Sync()
{
    if(!record_file && !replay_file)
        return; // Do nothing

    if(replay_file)
    {
        while(next_record_frame == frame_no && replay_file)
        {
            int type = fgetc(replay_file);
            fseek(replay_file, -1, SEEK_CUR);

            if(type == 'S')
                read_status();
            else if(type == 'E')
                read_end();
            else if(type == 'N')
                read_NPCs();
            else if(type == 'C')
                read_control();
            else if(!feof(replay_file))
            {
                pLogWarning("Invalid record type %c in replayed recording file.", type);
                diverged_major = true;
                EndRecording();
                return;
            }

            if(feof(replay_file) || fscanf(replay_file, "%" PRId64 "\r\n", &next_record_frame) != 1)
            {
                pLogWarning("Replayed recording file has prematurely ended.");
                diverged_major = true;
                EndRecording();
                return;
            }
        }

        for(int i = 0; i < numPlayers; i++)
            Player[i+1].Controls = last_controls[i];
    }

    if(record_file)
    {
        write_control();

        if(!(frame_no % 60))
            write_status();

        if(!(frame_no % 900))
            write_NPCs();
    }

    frame_no++;
}

} // namespace Record

#if defined(X_GCC_NO_WARNING_FORMAT) || defined(XTECH_GCC_UNUSED_RESULT_IGNORED)
#   pragma GCC diagnostic pop
#endif


================================================
FILE: src/main/record.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

// this module handles the control recording and playback functions
// and the gameplay stats recording functions

#pragma once
#ifndef RECORD_H
#define RECORD_H

#include <string>

namespace Record
{

// public to allow other systems to spy on status of the Record system
extern FILE* record_file;
extern FILE* replay_file;

void LoadReplay(const std::string &recording_path, const std::string &level_path);

void InitRecording();

void Sync();

void EndRecording();

} // namespace Record

#endif // #ifndef RECORD_H


================================================
FILE: src/main/screen_asset_pack.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>
#include <fmt_format_ne.h>
#include <Integrator/integrator.h>

#include "Archives/archives.h"
#include "sdl_proxy/sdl_stdinc.h"

#include "main/screen_asset_pack.h"
#include "main/asset_pack.h"

#include "core/render.h"

#include "sound.h"
#include "controls.h"
#include "draw_planes.h"
#include "graphics.h"
#include "gfx.h"
#include "game_main.h"

void drawGameVersion(bool disable_git, bool git_only);

namespace ScreenAssetPack
{

bool g_LoopActive = false;
bool s_AnimatingBack = false;

// the player's target asset pack index
static int s_target_idx = -1;

// the current asset pack index
static int s_cur_idx = -1;

// how far to scroll the logos. ranges from -1 (halfway through a right rotation) to +1 (halfway through a left rotation)
static num_t s_switch_coord = 0.0_n;

static bool s_ensure_idx_valid()
{
    const auto& asset_packs = GetAssetPacks();

    if(s_cur_idx >= 0 && s_cur_idx < (int)asset_packs.size())
        return true;

    s_cur_idx = 0;

    std::string real_app_path;

    // restore real path from loaded assets
    if(AppPath[0] == ':' && AppPath[1] == 'a')
    {
        real_app_path.push_back('@');
        real_app_path.append(Archives::assets_archive_path());
        real_app_path.push_back(':');
        real_app_path.append(AppPath.c_str() + 2, AppPath.size() - 2);
    }
    else
        real_app_path = AppPath;

    for(const auto& pack : asset_packs)
    {
        if(pack.path == real_app_path && pack.full_id() == g_AssetPackID)
        {
            if(s_target_idx == -1)
                s_target_idx = s_cur_idx;

            return true;
        }

        s_cur_idx++;
    }

    return false;
}

static void s_renderBackground(AssetPack_t::Gfx& gfx, XTColor bg_color)
{
    if(gfx.background.inited)
    {
        int background_height = gfx.background.h / gfx.bg_frames;
        int background_frame = (CommonFrame / gfx.bg_frame_ticks) % gfx.bg_frames;

        int show_width = SDL_min(background_height * XRender::TargetW / XRender::TargetH, gfx.background.w);
        int show_height = SDL_min(gfx.background.w * XRender::TargetH / XRender::TargetW, background_height);

        XRender::renderTextureScaleEx(0, 0, XRender::TargetW, XRender::TargetH,
                                      gfx.background,
                                      (gfx.background.w - show_width) / 2, background_height * background_frame + (background_height - show_height) / 2,
                                      show_width, show_height,
                                      0, nullptr, X_FLIP_NONE,
                                      bg_color);
    }
    else
    {
        XRender::renderRect(0, 0, XRender::TargetW, XRender::TargetH, XTColor(0, 0, 0) * bg_color);
    }
}

// this method is public so that it is possible to fade in the asset pack screen from the main menu
void DrawBackground(int fade)
{
    if(!s_ensure_idx_valid())
        return;

    // used for things that are scaled in special ways during switch
    XTColor color_no_switch = XTAlpha(fade * 4 - 1);

    // used for things linked to the central pack
    XTColor color = XTAlphaF(fade * (1.0_n - num_t::abs(s_switch_coord)) / 64);

    const AssetPack_t& pack = GetAssetPacks()[s_cur_idx];

    if(!pack.gfx)
        return;

    int menu_logo_y = XRender::TargetH / 2 - 230;

    // place manually on small screens
    if(XRender::TargetH < 400)
        menu_logo_y = 16 + (XRender::TargetH - 320) / 2;
    else if(XRender::TargetH < 500)
        menu_logo_y = 16;
    else if(XRender::TargetH <= 600)
        menu_logo_y = 40;

    // logic for the menu curtain draw
    int curtain_draw_w = GFX.MenuGFX[1].w;
    if(curtain_draw_w == 800)
        curtain_draw_w = 768;
    int curtain_horiz_reps = XRender::TargetW / curtain_draw_w + 2;

    // draw background curtain fade
    if(s_AnimatingBack)
    {
        for(int i = 0; i < curtain_horiz_reps; i++)
            XRender::renderTextureBasic(curtain_draw_w * i, -(GFX.MenuGFX[1].h * fade / 64), curtain_draw_w, GFX.MenuGFX[1].h, GFX.MenuGFX[1], 0, 0);
    }

    // draw background logo
    if(s_AnimatingBack || pack.logo_override)
        XRender::renderTextureBasic(XRender::TargetW / 2 - GFX.MenuGFX[2].w / 2, menu_logo_y, GFX.MenuGFX[2]);

    AssetPack_t::Gfx& gfx = *pack.gfx;

#ifdef __3DS__
    XRender::setTargetLayer(2);
#endif

    // draw background
    s_renderBackground(gfx, color_no_switch);

    // draw curtain during transition
    if(!g_LoopActive && !s_AnimatingBack)
    {
        for(int i = 0; i < curtain_horiz_reps; i++)
            XRender::renderTextureBasic(curtain_draw_w * i, -(GFX.MenuGFX[1].h * fade / 64), curtain_draw_w, GFX.MenuGFX[1].h, GFX.MenuGFX[1], 0, 0);
    }

    // show previous / next packs
    int prev_index = s_cur_idx - 1;
    int next_index = s_cur_idx + 1;

    if(prev_index < 0)
        prev_index = GetAssetPacks().size() - 1;
    if(next_index >= (int)GetAssetPacks().size())
        next_index = 0;

    const AssetPack_t& prev_pack = GetAssetPacks()[prev_index];
    const AssetPack_t& next_pack = GetAssetPacks()[next_index];

    // cross-fade background
    if(s_switch_coord > 0 && prev_pack.gfx)
    {
        XTColor bg_color = color_no_switch * XTAlphaF(s_switch_coord / 2);
        s_renderBackground(*prev_pack.gfx, bg_color);
    }
    else if(s_switch_coord < 0 && next_pack.gfx)
    {
        XTColor bg_color = color_no_switch * XTAlphaF(-s_switch_coord / 2);
        s_renderBackground(*next_pack.gfx, bg_color);
    }

#ifdef __3DS__
    XRender::setTargetLayer(3);

    // fade the existing display
    if(!g_LoopActive && XRender::TargetH <= 480)
        XRender::targetFade(256 - fade * 4);
#endif

    // calculate how much the pack logos should be shifted
    int logo_shift = (XRender::TargetW / 2) - 100;

    if(prev_pack.gfx && prev_pack.gfx->logo.inited)
    {
        num_t cX = 100 + logo_shift * s_switch_coord / 2;
        XTColor pack_color = (s_switch_coord == 0) ? color * XTAlpha(127) : color_no_switch * XTAlphaF(0.25_n + (s_switch_coord + 1.0_n) / 4);
        XRender::renderTextureBasic((int)(cX + prev_pack.gfx->logo.w * (s_switch_coord / 4 - 1)),
            XRender::TargetH / 2 - prev_pack.gfx->logo.h / 2,
            prev_pack.gfx->logo,
            pack_color);
    }

    if(next_pack.gfx && next_pack.gfx->logo.inited)
    {
        num_t cX = (XRender::TargetW - 100) + logo_shift * s_switch_coord / 2;
        XTColor pack_color = (s_switch_coord == 0) ? color * XTAlpha(127) : color_no_switch * XTAlphaF(0.25_n + (1.0_n - s_switch_coord) / 4);
        XRender::renderTextureBasic((int)(cX + prev_pack.gfx->logo.w * (s_switch_coord / 4)),
            XRender::TargetH / 2 - next_pack.gfx->logo.h / 2,
            next_pack.gfx->logo,
            pack_color);
    }

    // draw current logo in all cases (needed for cases where title card is not in GFX.MenuGFX[2])
    if(!gfx.logo.inited)
    {
        SuperPrintScreenCenter(pack.full_id(), 3, XRender::TargetH / 2 - 20, color);
        SuperPrintScreenCenter(pack.path, 3, XRender::TargetH / 2 + 2, color);
    }
    else if(g_LoopActive || s_AnimatingBack || pack.logo_override)
    {
        num_t cX = (XRender::TargetW / 2) + logo_shift * s_switch_coord / 2;
        XTColor main_color = color_no_switch * XTAlphaF(0.75_n + (1.0_n - num_t::abs(s_switch_coord)) / 4);
        XRender::renderTextureBasic((int)(cX + gfx.logo.w * (s_switch_coord / 4 - 0.5_n)), XRender::TargetH / 2 - gfx.logo.h / 2, gfx.logo, main_color);
    }
    else
    {
        num_t cX = (XRender::TargetW / 2) + logo_shift * s_switch_coord * fade / (64 * 2);

        int center_Y = XRender::TargetH / 2 - gfx.logo.h / 2;
        int place_Y = (center_Y * fade / 64) + (menu_logo_y * (64 - fade) / 64);

        XRender::renderTextureBasic((int)(cX + gfx.logo.w * (s_switch_coord * fade / (64 * 4) - 0.5_n)),
            place_Y,
            gfx.logo);
    }

    // show version if appropriate
    bool show_version = pack.show_version && !pack.version.empty();
    if(pack.show_id || show_version || pack.id.empty())
    {
        num_t cX = (XRender::TargetW / 2) + logo_shift * s_switch_coord / 2;
        int text_Y = XRender::TargetH / 2 + gfx.logo.h / 2 + 8;

        const std::string& display = (pack.show_id) ? pack.full_id() : ((show_version) ? pack.version : "<legacy>");
        SuperPrintCenter(display, 3, (int)cX, text_Y, color);
    }

    // show scroll indicators
    if(g_LoopActive && CommonFrame % 90 >= 45 && s_cur_idx == s_target_idx && s_switch_coord == 0)
    {
        int offset = SDL_min(XRender::TargetW / 2 - 8, 250);
        if(GFX.CharSelIcons.inited)
        {
            XRender::renderTextureFL(XRender::TargetW / 2 - offset, XRender::TargetH / 2 - 24 / 2, 24, 24, GFX.CharSelIcons, 72, 0, 0, nullptr, X_FLIP_HORIZONTAL);
            XRender::renderTextureBasic(XRender::TargetW / 2 + offset - 24, XRender::TargetH / 2, 24, 24, GFX.CharSelIcons, 72, 0);
        }
        else
        {
            XRender::renderTextureFL(XRender::TargetW / 2 - offset, XRender::TargetH / 2 - GFX.MCursor[1].w / 2, GFX.MCursor[1].w, GFX.MCursor[1].h, GFX.MCursor[1], 0, 0, -90);
            XRender::renderTextureFL(XRender::TargetW / 2 + offset - GFX.MCursor[1].h, XRender::TargetH / 2 - GFX.MCursor[2].w / 2, GFX.MCursor[2].w, GFX.MCursor[2].h, GFX.MCursor[2], 0, 0, -90);
        }
    }

    drawGameVersion(true, false);

    // reset all variables when alpha is low enough during exit
    if(fade < 3)
    {
        s_AnimatingBack = false;
        s_cur_idx = -1;
        s_target_idx = -1;
        s_switch_coord = 0;
    }

    if(g_LoopActive)
        s_AnimatingBack = false;
}

void Render(bool now_loading = false)
{
    XRender::setTargetTexture();
    XRender::resetViewport();
    XRender::clearBuffer();

    XRender::setDrawPlane(PLANE_GAME_MENUS);

    CommonFrame++;

    DrawBackground(64);

    // Mouse cursor
    XRender::renderTextureBasic(int(SharedCursor.X), int(SharedCursor.Y), GFX.ECursor[2]);

    DrawDeviceBattery();

    if(now_loading)
    {
        int R = XRender::TargetW / 2 + 400;
        int B = XRender::TargetH / 2 + 300;

        if(R > XRender::TargetW)
            R = XRender::TargetW;

        if(B > XRender::TargetH)
            B = XRender::TargetH;

        R -= (GFX.Loader.w + 50);
        B -= (GFX.Loader.h + 8);

        XRender::renderTextureBasic(R, B, GFX.Loader);
    }

    XRender::repaint();

    if(TakeScreen)
        ScreenShot();
}

bool Logic()
{
    // escape if the current asset pack no longer exists
    if(!s_ensure_idx_valid())
    {
        g_LoopActive = false;
        GameMenu = true;
        return true;
    }

    if(!SharedCursor.Primary && !SharedCursor.Secondary)
        MenuMouseRelease = true;
    // replicates legacy behavior allowing clicks to be detected
    if(SharedCursor.Primary || SharedCursor.Secondary || SharedCursor.Tertiary)
        SharedCursor.Move = true;

    MenuControls_t menuControls = Controls::GetMenuControls();

    menuControls.Left |= SharedCursor.ScrollUp;
    menuControls.Right |= SharedCursor.ScrollDown;

    menuControls.Back |= (SharedCursor.Secondary && MenuMouseRelease);

    if(menuControls.Back && menuControls.Do)
        menuControls.Do = false;

    if(!MenuCursorCanMove)
    {
        bool k = false;
        k |= menuControls.Back;
        k |= menuControls.Do;
        k |= menuControls.Left;
        k |= menuControls.Right;

        if(!k)
            MenuCursorCanMove = true;
    }
    else if(menuControls.Do)
    {
        MenuCursorCanMove = false;
        MenuMouseRelease = false;

        // check if we are still on the same asset pack
        int cur_idx = s_cur_idx;
        s_cur_idx = -1;
        s_ensure_idx_valid();

        // if not still on the same asset pack, reload assets!!
        if(cur_idx != s_cur_idx || !g_AssetsLoaded)
        {
            s_cur_idx = cur_idx;

            if(!g_AssetsLoaded)
            {
                XRender::setTargetTexture();
                XRender::clearBuffer();
                XRender::repaint();
            }
            else
                Render(true);

            CommonFrame = 0; // don't show indicators
            if(!ReloadAssetsFrom(GetAssetPacks()[cur_idx]))
            {
                s_cur_idx = -1;
                s_target_idx = -1;

                // stay in the asset pack screen
                return false;
            }
            else
            {
                // update recent asset pack
                SaveConfig();
            }
        }
        else
            PlaySoundMenu(SFX_Do);

        // proceed to game menu
        g_LoopActive = false;
        GameMenu = true;
        MenuCursor = 0;
        return true;
    }
    else if(menuControls.Back && g_AssetsLoaded)
    {
        PlaySoundMenu(SFX_Slide);

        // check if we are still on the same asset pack
        int cur_idx = s_cur_idx;
        s_cur_idx = -1;
        s_ensure_idx_valid();

        // if not still on the same asset pack, animate the back
        if(cur_idx != s_cur_idx)
            s_AnimatingBack = true;

        s_cur_idx = cur_idx;

        // return to game menu
        g_LoopActive = false;
        GameMenu = true;
        MenuCursorCanMove = false;
        MenuMouseRelease = false;
        return true;
    }
    else if(menuControls.Left)
    {
        MenuCursorCanMove = false;

        PlaySoundMenu(SFX_Climbing);
        s_target_idx--;
    }
    else if(menuControls.Right)
    {
        MenuCursorCanMove = false;

        PlaySoundMenu(SFX_Climbing);
        s_target_idx++;
    }

    if(SharedCursor.Primary || SharedCursor.Secondary)
        MenuMouseRelease = false;

    MenuMouseClick = false;

    // 16 frames to switch
    constexpr num_t move_rate = 0.125_n;

    // make s_switch_coord approach the target
    if(s_target_idx != s_cur_idx)
        s_switch_coord -= move_rate * (s_target_idx - s_cur_idx);
    else if(s_switch_coord < -move_rate)
        s_switch_coord += move_rate;
    else if(s_switch_coord > move_rate)
        s_switch_coord -= move_rate;
    else
        s_switch_coord = 0.0_n;

    // actually switch the index when switch coord grows enough
    if(s_switch_coord >= 1.0_n)
    {
        s_cur_idx--;
        if(s_cur_idx < 0)
        {
            if(s_target_idx < 0)
                s_target_idx += (int)GetAssetPacks().size();

            s_cur_idx = (int)GetAssetPacks().size() - 1;
        }

        s_switch_coord -= 2.0_n;
    }
    else if(s_switch_coord <= -1.0_n)
    {
        s_cur_idx++;
        if(s_cur_idx >= (int)GetAssetPacks().size())
        {
            if(s_target_idx >= (int)GetAssetPacks().size())
                s_target_idx -= (int)GetAssetPacks().size();

            s_cur_idx = 0;
        }

        s_switch_coord += 2.0_n;
    }

    return false;
}

void Loop()
{
    Controls::PollInputMethod();
    Controls::Update(false);

    if(Logic())
        return;

    UpdateSound();

    Integrator::sync();

    Render();
}

} // namespace ScreenAssetPack


================================================
FILE: src/main/screen_asset_pack.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef SCREEN_ASSET_PACK_H
#define SCREEN_ASSET_PACK_H

#include "xt_color.h"

// The asset pack screen is special, because after exiting from it with a success, EVERYTHING gets reloaded. So, it gets its own main loop.

namespace ScreenAssetPack
{

extern bool g_LoopActive;

// this method is public so that it is possible to fade in the asset pack screen from the main menu
// fade goes from 0 to 64
void DrawBackground(int fade);

void Loop();

} // namespace ScreenAssetPack

#endif // #ifndef SCREEN_ASSET_PACK_H


================================================
FILE: src/main/screen_connect.cpp
================================================
#include <fmt_format_ne.h>

#include "core/render.h"

#include "global_constants.h"
#include "message.h"
#include "controls.h"
#include "sound.h"
#include "globals.h"
#include "gfx.h"
#include "graphics.h"
#include "player.h"
#include "config.h"
#include "npc_id.h"
#include "npc/npc_queues.h"

#include "graphics/gfx_marquee.h"

#include "main/game_info.h"

#include "main/screen_connect.h"
#include "main/screen_quickreconnect.h"
#include "main/menu_main.h"
#include "main/game_strings.h"
#include "main/speedrunner.h"

#include "control/controls_methods.h" // to cancel keyboard's double-click fullscreen

static inline void s_cancelDoubleClick()
{
#ifdef KEYBOARD_H
    Controls::g_cancelDoubleClick = true;
#endif
}

namespace ConnectScreen
{

enum class PlayerState
{
    Disconnected,   // missing controller for player
    SelectChar,     // left side of main screen
    ControlsMenu,   // right side of main screen
    Reconnecting,   // player requested to reconnect controller
    SelectProfile,  // selecting controls profile
    ConfirmProfile, // checking that player understands controls profile
    ForceDrop,      // player wants to force disconnected other players to drop (to leave drop/add screen)
};

enum class Context
{
    MainMenu,
    LegacyMenu,
    DropAdd,
};

static Context s_context;
static std::array<uint8_t, maxLocalPlayers> s_recent_char{};

struct CharInfo
{
private:
    bool char_present[numCharacters];

public:
    int dead_count = 0;
    int max_players = 0;

    bool accept(int c, int p, uint8_t current_add)
    {
        if(c < 1 || c > numCharacters)
            return false;

        // don't accept a blocked char, unless it has been present before
        if(blockCharacter[c] && !(s_context == Context::DropAdd && this->char_present[c - 1]))
            return false;

        // allow everything if char swap is allowed
        if(SwapCharAllowed())
            return true;

        // automatically recognize novel adds
        if(p >= this->max_players)
            current_add = 2;

        // if not a current add, don't allow changing character
        if(!current_add)
            return false;

        bool novel_add = (current_add >= 2);

        // require the character to have been selected previously if the player is not a novel add
        if(!novel_add && !this->char_present[c - 1])
            return false;

        return true;
    }

    void reset()
    {
        for(int c = 0; c < numCharacters; c++)
            char_present[c] = false;

        max_players = l_screen->player_count;
        dead_count = 0;
    }

    void mark_present()
    {
        for(int p = 0; p < l_screen->player_count; p++)
        {
            s_recent_char[p] = Player[l_screen->players[p]].Character;
            int c = Player[l_screen->players[p]].Character - 1;

            if(0 <= c && c < numCharacters)
                char_present[c] = true;
        }

        if(max_players < l_screen->player_count)
            max_players = l_screen->player_count;
    }

    // checks if the active players' characters have been changed by gameplay logic (not drop/add)
    bool chars_changed()
    {
        for(int p = 0; p < l_screen->player_count; p++)
        {
            int c = Player[l_screen->players[p]].Character - 1;

            if(0 <= c && c < numCharacters)
            {
                if(!char_present[c])
                    return true;
            }
        }

        return false;
    }

    // checks if a character has been present
    bool char_was_present(int c)
    {
        if(c < 1 || c > numCharacters)
            return false;

        return this->char_present[c - 1];
    }

    // marks a single character as present
    void mark_char_present(int c)
    {
        if(c < 1 || c > numCharacters)
            return;

        this->char_present[c - 1] = true;
    }
};

struct PlayerBox
{
    PlayerState m_state = PlayerState::Disconnected;
    bool m_input_ready = false;

    // set if the player was added during this invocation of the Drop/Add screen; set to 2 if a novel add (the number of players is greater than it had been previously)
    uint8_t m_current_add = 0;

private:
    // just added a player in multiplayer menu char select: play DropItem if appropriate, and block the start and back keys for non-P1 players
    bool m_just_added = false;

    // progress towards entering the Konami cheat to set g_forceCharacter
    uint8_t m_konami_bits = false;

    //! multiuse tracker for current menu item / action confirm progress
    int m_menu_item = 0;

    // state of hint text marquee
    MarqueeState m_marquee_state;

    Controls::InputMethodProfile* m_last_profile = nullptr;

    // calculates the player index using pointer arithmetic
    int CalcIndex() const;

    // checks if a character is validly available for this player
    bool CharAvailable(int c, bool ghost_mode = false);

    // adds player if not present, and updates player's character
    void UpdatePlayer();

    // makes sure that l_screen->charSelect[p] is valid
    void ValidateChar(bool ghost_mode = false);

    // does logic for an item the mouse is currently over
    bool MouseItem(int i);

    // do all mouse logic and rendering for an item at a certain location
    bool MenuItem_Mouse_Render(int i, const std::string& label, int X, int Y, bool mouse, bool render, int end_X = 0);

    // draws the selected character at a location
    bool DrawChar(int x, int w, int y, int h, bool show_name);

    // do rendering and mouse logic for SinglePlayer char select
    // returns -1 if player is ready to return, +1 if player is ready to proceed
    int Mouse_Render_1P(bool render);

public:
    // initialize the state for the current context
    void Init();

    // do rendering and mouse logic
    // returns -1 if player is ready to return, +1 if player is ready to proceed
    int Mouse_Render(bool render, int x, int y, int w, int h);

    // returns -1 if player is ready to return, +1 if player is ready to proceed
    int Logic();

    // check if it is possible to rotate char
    bool CanChangeChar();

    // rotate character
    void PrevChar();
    void NextChar();

    // registers the appropriate cursor input
    void Left();
    void Right();

    void Up();
    void Down();

    // returns true if this player is ready to return to previous menu
    bool Back();

    // returns true if this player is ready to proceed
    bool Do();

    // returns true if this player is ready to proceed
    bool Ready() const;
};

static bool s_controls_dirty = false;
static int s_minPlayers = 1;

static std::array<PlayerBox, maxLocalPlayers> s_players;

static CharInfo s_char_info;

static void s_logRecentChars()
{
    // reset recent chars to 0
    s_recent_char = {};

    // update recent characters
    for(size_t i = 0; i < maxLocalPlayers; i++)
    {
        if(s_players[i].m_state != PlayerState::Disconnected)
            s_recent_char[i] = l_screen->charSelect[i];
    }

    // mark input methods as used
    for(Controls::InputMethod* method : Controls::g_InputMethods)
    {
        if(method)
            method->used_for_player = true;
    }

    // if controls dirty, save them
    if(s_controls_dirty)
    {
        Controls::SaveConfig();
        s_controls_dirty = false;
    }
}

static inline void Render_PCursor(int x, int y)
{
    if(GFX.PCursor.inited)
        XRender::renderTextureBasic(x, y, GFX.PCursor);
    else
        XRender::renderTextureFL(x, y, GFX.MCursor[1].w, GFX.MCursor[1].h, GFX.MCursor[1], 0, 0, 90, nullptr, X_FLIP_NONE);
}

static inline void Render_PCursorDownwards(int x, int y, XTColor color = XTColor())
{
    if(GFX.PCursor.inited)
        XRender::renderTextureFL(x - GFX.PCursor.h / 2, y - GFX.PCursor.w, GFX.PCursor.w, GFX.PCursor.h, GFX.PCursor, 0, 0, 90, nullptr, X_FLIP_NONE, color);
    else
        XRender::renderTextureBasic(x - GFX.MCursor[2].w / 2, y - GFX.MCursor[2].h, GFX.MCursor[2], color);
}

static inline bool Is1P()
{
    return s_context == Context::LegacyMenu;
}

static inline bool IsMenu()
{
    return (s_context == Context::MainMenu || s_context == Context::LegacyMenu);
}

// check if PlayerBox p (zero-indexed) can drop self
static inline bool ControlsMenu_ShowDrop(int p)
{
    // don't allow dropping below required player count
    if(s_context == Context::DropAdd && l_screen->player_count <= s_minPlayers)
        return false;

    // never show drop icon at main menu
    if(s_context == Context::MainMenu)
        return false;

    int plr_A = l_screen->players[p];

    // check that there is a different living player
    for(int B = 1; B <= numPlayers; B++)
    {
        if(B == plr_A)
            continue;

        if(!Player[B].Dead && Player[B].TimeToLive == 0)
            return true;
    }

    return false;
}

static inline int BoxCount(bool strict = false)
{
    int n = (int)Controls::g_InputMethods.size();

    if(!BattleMode)
        n += 1;

    if(n < s_minPlayers)
        n = s_minPlayers;

    if(s_context == Context::MainMenu && n < 2)
        n = 2;

    // disable entering >2P in vanilla mode (in-game)
    if(n > 2 && !g_config.multiplayer_pause_controls)
        n = 2;

    // disable entering >2P in vanilla mode (main menu)
    if(n > 2 && s_context == Context::MainMenu && mainMenuPlaystyle() == Config_t::MODE_VANILLA)
        n = 2;

    // disable entering >1P from legacy menu
    if(s_context == Context::LegacyMenu)
        n = 1;

    // disable entering >1P when 2P is disabled
    if(g_gameInfo.disableTwoPlayer && !g_forceCharacter)
        n = 1;

    // but do show all players once they are already present
    if(!strict && n < (int)Controls::g_InputMethods.size())
        n = (int)Controls::g_InputMethods.size();

    // limit to maxLocalPlayers to prevent out-of-bounds access
    if(n > maxLocalPlayers)
        n = maxLocalPlayers;

    return n;
}

static void s_InitBlockCharacter()
{
    g_forceCharacter = false;
    For(A, 1, numCharacters)
    {
        if(MenuMode == MENU_CHARACTER_SELECT_NEW_BM)
            blockCharacter[A] = false;
        else
            blockCharacter[A] = SelectWorld[selWorld].blockChar[A];
    }
}

void MainMenu_Start(int minPlayers)
{
    s_minPlayers = minPlayers;
    s_context = Context::MainMenu;

    // clear input methods if invalid
    if((int)Controls::g_InputMethods.size() > BoxCount(true))
        Controls::ClearInputMethods();
    // confirm that input methods are associated with players
    else if(Controls::g_InputMethods.size() > 1)
    {
        for(size_t i = 0; i < Controls::g_InputMethods.size(); )
        {
            if(Controls::g_InputMethods[i] && Controls::g_InputMethods[i]->used_for_player)
                i++;
            else
                Controls::DeleteInputMethodSlot(i);
        }
    }
    else if(Controls::g_InputMethods.size() > 0 && Controls::g_InputMethods[0])
        Controls::g_InputMethods[0]->used_for_player = true;

    for(int i = 0; i < maxLocalPlayers; i++)
        l_screen->charSelect[i] = 0;

    if(!(g_forceCharacter && SelectWorld[selWorld].blockChar[s_recent_char[0]]))
        s_InitBlockCharacter();

    for(int i = 0; i < maxLocalPlayers; i++)
    {
        s_players[i] = PlayerBox();
        s_players[i].Init();
    }

    MenuMouseRelease = false;
    MenuCursorCanMove = false;

    s_char_info.reset();

    // prepare for first frame
    Logic();
}

void LegacyMenu_Start()
{
    s_minPlayers = 1;
    s_context = Context::LegacyMenu;

    // clear input methods if invalid
    if((int)Controls::g_InputMethods.size() > BoxCount(true))
        Controls::ClearInputMethods();
    else if(Controls::g_InputMethods.size() > 0 && Controls::g_InputMethods[0])
        Controls::g_InputMethods[0]->used_for_player = true;

    for(int i = 0; i < maxLocalPlayers; i++)
        l_screen->charSelect[i] = 0;

    s_InitBlockCharacter();

    for(int i = 0; i < maxLocalPlayers; i++)
    {
        s_players[i] = PlayerBox();
        s_players[i].Init();
    }

    // create an empty input slot
    if(Controls::g_InputMethods.size() == 0)
        Controls::g_InputMethods.push_back(nullptr);

    s_players[0].m_state = PlayerState::SelectChar;

    MenuMouseRelease = false;
    MenuCursorCanMove = false;

    s_char_info.reset();

    // prepare for first frame
    Logic();
}

void DropAdd_Start()
{
    if(BattleMode)
        s_minPlayers = l_screen->player_count;
    else
        s_minPlayers = 1;

    s_context = Context::DropAdd;

    for(int i = 0; i < maxLocalPlayers; i++)
    {
        s_players[i] = PlayerBox();
        s_players[i].Init();
    }

    MenuMouseRelease = false;
    MenuCursorCanMove = false;

    // update the present characters, IF they got changed by level logic
    if(s_char_info.chars_changed())
        SaveChars();

    // prepare for first frame
    Logic();
}

int PlayerBox::CalcIndex() const
{
    if(this >= &s_players[0] && this <= &s_players[maxLocalPlayers - 1])
    {
        return this - &s_players[0];
    }

    return 0;
}

bool PlayerBox::Ready() const
{
    switch(m_state)
    {
    case PlayerState::Disconnected:
    case PlayerState::Reconnecting:
    case PlayerState::SelectProfile:
    case PlayerState::ConfirmProfile:
        return false;

    default:
        return true;
    }
}

void PlayerBox::Init()
{
    int p = CalcIndex();

    if(p < (int)Controls::g_InputMethods.size() && Controls::g_InputMethods[p]
            && (s_context != Context::DropAdd || p < l_screen->player_count))
    {
        m_state = PlayerState::SelectChar;
    }
    else
        m_state = PlayerState::Disconnected;

    if(s_context == Context::DropAdd && p < l_screen->player_count)
    {
        l_screen->charSelect[p] = Player[l_screen->players[p]].Character;
    }
    else
    {
        l_screen->charSelect[p] = s_recent_char[p];
        if(l_screen->charSelect[p] == 0)
            l_screen->charSelect[p] = p + 1;
        ValidateChar(true);
    }
}

bool PlayerBox::CharAvailable(int c, bool ghost_mode)
{
    // check if invalid
    if(c < 1 || c > numCharacters)
        return false;

    int p = CalcIndex();

    // check if blocked for use in the level (blocked in episode, or a different character was previously dropped in the level)
    if(!s_char_info.accept(c, p, ghost_mode ? 1 : m_current_add))
        return false;

    int max_check = ghost_mode ? BoxCount() : (int)Controls::g_InputMethods.size();

    if(max_check < s_minPlayers)
        max_check = s_minPlayers;

    // check if a different player has selected or is currently selecting the character
    for(int i = 0; i < maxLocalPlayers && i < max_check; i++)
    {
        // fine if self
        if(i == p)
            continue;

        if(l_screen->charSelect[i] == c && !(s_context == Context::MainMenu && MenuMode == MENU_CHARACTER_SELECT_NEW_BM) && !g_forceCharacter)
            return false;
    }

    return true;
}

static bool CheckDone()
{
    // What is the first player that is not done?
    int n = (int)Controls::g_InputMethods.size();
    if(n < s_minPlayers)
        n = s_minPlayers;
    if(n > maxLocalPlayers)
        n = maxLocalPlayers;

    // What is the first player that is not done?
    int notDone;
    for(notDone = 0; notDone < n; notDone++)
    {
        if(notDone == (int)Controls::g_InputMethods.size() || !Controls::g_InputMethods[notDone])
            break;

        if(!s_players[notDone].Ready())
            break;
    }

    // not enough players / controllers -> not done
    if(notDone < s_minPlayers || (int)Controls::g_InputMethods.size() < s_minPlayers)
        return false;

    // need all connected players to be done
    if(notDone == (int)Controls::g_InputMethods.size() || notDone == maxLocalPlayers)
        return true;

    return false;
}


// helper function when trying to force exit the drop/add screen
// returns zero-indexed player that can be dropped (is currently disconnected), -3 if the player set is already complete, -2 if exiting the menu is blocked, and -1 if dropping a player will not make the player set complete
static int CheckCanDrop()
{
    // What is the first player that is not done?
    int n = (int)Controls::g_InputMethods.size();
    if(n < s_minPlayers)
        n = s_minPlayers;
    if(n > maxLocalPlayers)
        n = maxLocalPlayers;

    int are_present = 0;
    int can_drop = -3;

    // What is the first player that is not done?
    for(int notDone = 0; notDone < n; notDone++)
    {
        if(s_players[notDone].Ready())
            are_present++;
        else if(s_players[notDone].m_state == PlayerState::Disconnected || s_players[notDone].m_state == PlayerState::Reconnecting)
            can_drop = notDone;
        else if(s_players[notDone].m_state == PlayerState::ConfirmProfile)
            return -2;
    }

    // not enough players / controllers -> can't drop to exit
    if(are_present < s_minPlayers)
        return -1;

    return can_drop;
}

static void Player_Remove(int p)
{
    // if it was a novel add, mark their character as allowed
    if(s_players[p].m_current_add == 2)
        s_char_info.mark_char_present(l_screen->charSelect[p]);

    Controls::DeleteInputMethodSlot(p);

    // move all player boxes back, and reset final box
    for(int p2 = p; p2 + 1 < maxLocalPlayers; p2++)
    {
        s_players[p2] = s_players[p2 + 1];
        s_players[p2].m_input_ready = false;
        l_screen->charSelect[p2] = l_screen->charSelect[p2 + 1];
    }

    s_players[maxLocalPlayers - 1] = PlayerBox();

    // in drop-add, remove the Player officially in main game engine
    if(p < l_screen->player_count && s_context == Context::DropAdd)
    {
        if((Player[l_screen->players[p]].Dead || Player[l_screen->players[p]].TimeToLive > 0) && Player[l_screen->players[p]].Effect != PLREFF_COOP_WINGS)
            s_char_info.dead_count++;

        XMessage::PushMessage({XMessage::Type::drop_player, (uint8_t)p, 0});
    }
}

static void Player_Swap(int p1, int p2)
{
    if(p1 == p2)
        return;

    if(p1 >= (int)Controls::g_InputMethods.size() || p2 >= (int)Controls::g_InputMethods.size())
        return;

    std::swap(s_players[p1], s_players[p2]);

    std::swap(l_screen->charSelect[p1], l_screen->charSelect[p2]);

    s_players[p1].m_input_ready = false;
    s_players[p2].m_input_ready = false;
}

// transform players and items based on character
static void DoTransform(int p, int ch)
{
    for(int A = 1; A <= numPlayers; A++)
    {
        if(A % (p + 1) == 0)
        {
            if(Player[A].Character != ch)
            {
                Player[A].Character = ch;
                SizeCheck(Player[A]);
            }
        }
    }

    for(int A : NPCQueues::Active.no_change)
    {
        if(A % (p + 1) == 0 && NPC[A].Type == NPCID_PLR_FIREBALL)
            NPC[A].Special = ch;
    }
}

void PlayerBox::UpdatePlayer()
{
    int p = CalcIndex();

    // if initialized, then update character
    if(p < l_screen->player_count)
    {
        if(l_screen->charSelect[p] != Player[l_screen->players[p]].Character)
            XMessage::PushMessage({XMessage::Type::char_swap, (uint8_t)p, (uint8_t)l_screen->charSelect[p]});
    }
    // otherwise, add new player!
    else
    {
        // swap p with the first non-existent player slot
        Player_Swap(l_screen->player_count, p);

        // check the desired character
        uint8_t chara = l_screen->charSelect[l_screen->player_count];

        // add as dead if dead player was dropped in this level
        if(s_char_info.dead_count > 0)
        {
            s_char_info.dead_count--;
            PlaySound(SFX_ShellHit);
            XMessage::PushMessage({XMessage::Type::add_player_dead, 0, chara});
        }
        else
        {
            PlaySound(SFX_DropItem);
            XMessage::PushMessage({XMessage::Type::add_player, 0, chara});
        }
    }
}

void PlayerBox::ValidateChar(bool ghost_mode)
{
    int p = CalcIndex();

    uint8_t& sel = l_screen->charSelect[p];

    // ensure that character selection is still valid

    // bounds check
    if(sel < 1 || sel > numCharacters)
        sel = 1;

    // i is a dummy variable so that if invalid, end up where we started
    for(int i = 0; i < numCharacters; i++)
    {
        if(CharAvailable(sel, ghost_mode))
            return;

        sel ++;
        if(sel > numCharacters)
            sel = 1;
    }

    // if we failed (total block), first try to find an unblocked char
    for(int i = 1; i <= numCharacters; i++)
    {
        if(s_char_info.accept(i, p, m_current_add))
        {
            sel = i;
            return;
        }
    }

    // failed again? just do char 1
    sel = 1;
}

struct PlayDoSentinel
{
    bool active = true;
    ~PlayDoSentinel()
    {
        if(active)
            PlaySoundMenu(SFX_Do);
    }
};

// returns true to signal exit from menu
bool PlayerBox::Back()
{
    // int p = CalcIndex();

    m_input_ready = false;

    // first screen of main menu
    if(m_state == PlayerState::Disconnected && IsMenu())
    {
        PlaySoundMenu(SFX_Slide);
        return true;
    }
    // primary menu areas
    else if(m_state == PlayerState::SelectChar || m_state == PlayerState::ControlsMenu)
    {
        // adding player at main menu
        if(IsMenu())
        {
            // just go back!
            PlaySoundMenu(SFX_Slide);
            return true;
        }
        // escape the drop/add menu
        else
        {
            if(CheckDone())
            {
                PlaySoundMenu(SFX_Slide);
                return true;
            }
            else if(CheckCanDrop() >= -1)
            {
                m_state = PlayerState::ForceDrop;
                m_menu_item = 0;
                m_input_ready = true;
                m_marquee_state.reset_width();
                return false;
            }
            else
            {
                // m_back_requested = true;
                PlaySoundMenu(SFX_BlockHit);
                return false;
            }
        }
    }

    PlaySoundMenu(SFX_Slide);

    if(Is1P() && m_state == PlayerState::SelectProfile)
    {
        m_state = PlayerState::SelectChar;
        m_menu_item = 0;
    }
    else if(m_state == PlayerState::SelectProfile)
    {
        m_state = PlayerState::ControlsMenu;
        m_menu_item = 1;
        m_marquee_state.reset_width();
    }

    return false;
}

bool PlayerBox::Do()
{
    int p = CalcIndex();

    m_input_ready = false;

    // plays SFX_Do at end of scope unless inactivated
    PlayDoSentinel do_sentinel;

    // controls menu
    if(m_state == PlayerState::ControlsMenu && p < (int)Controls::g_InputMethods.size())
    {
        // drop me
        if(ControlsMenu_ShowDrop(p) && m_menu_item == -1)
        {
            do_sentinel.active = false;

            Player_Remove(p);

            // quit if there aren't any other players
            if(s_context == Context::MainMenu && Controls::g_InputMethods.empty())
            {
                PlaySoundMenu(SFX_Slide);
                return true;
            }

            PlaySoundMenu(SFX_PlayerDied2);
            return false;
        }
        // reconnect controller
        else if(m_menu_item == 0)
        {
            // does set Controls::g_InputMethods[p] to null
            Controls::DeleteInputMethod(Controls::g_InputMethods[p]);

            m_state = PlayerState::Reconnecting;
            m_marquee_state.reset_width();

            do_sentinel.active = false;

            PlaySoundMenu(SFX_PetHurt);

            return false;
        }
        // select a profile
        else if(m_menu_item == 1)
        {
            // only enter the profile select screen if safe to do so.
            if(Controls::g_InputMethods[p])
            {
                m_state = PlayerState::SelectProfile;
                m_marquee_state.reset_width();

                // set the current menu item to the current profile.
                std::vector<Controls::InputMethodProfile*> profiles = Controls::g_InputMethods[p]->Type->GetProfiles();
                std::vector<Controls::InputMethodProfile*>::iterator p_profile
                    = std::find(profiles.begin(), profiles.end(), Controls::g_InputMethods[p]->Profile);

                if(profiles.size() > 1 && p_profile != profiles.end())
                    m_menu_item = p_profile - profiles.begin();
                else
                    m_menu_item = 0;
            }
        }
        return false;
    }

    // select char
    if(m_state == PlayerState::SelectChar)
    {
        do_sentinel.active = false;

        if(IsMenu())
        {
            if(CheckDone())
            {
                // clean up charSelect fields
                for(int p = (int)Controls::g_InputMethods.size(); p < maxLocalPlayers; p++)
                    l_screen->charSelect[p] = 0;

                do_sentinel.active = true;
                return true;
            }
            else
                PlaySoundMenu(SFX_BlockHit);
        }
    }
    // select profile
    else if(m_state == PlayerState::SelectProfile)
    {
        m_marquee_state.reset_width();

        if(p < (int)Controls::g_InputMethods.size() && Controls::g_InputMethods[p])
        {
            const std::vector<Controls::InputMethodProfile*> profiles = Controls::g_InputMethods[p]->Type->GetProfiles();
            // store profile
            m_last_profile = Controls::g_InputMethods[p]->Profile;

            int back_index = (int)profiles.size();
            // if not possible, just go back
            if(m_menu_item < 0 || m_menu_item >= back_index)
            {
                Back();
                do_sentinel.active = false;
            }
            // don't do confirmation screen if just setting current profile
            else if(m_last_profile == profiles[m_menu_item])
            {
                Back();
                do_sentinel.active = false;
            }
            // advance to the confirmation screen if successful
            else if(Controls::SetInputMethodProfile(p, profiles[m_menu_item]))
            {
                m_state = PlayerState::ConfirmProfile;
                m_menu_item = 66 * 3;
            }
            // indicate that profile couldn't be bound
            else
            {
                PlaySoundMenu(SFX_BlockHit);
                do_sentinel.active = false;
            }
        }
    }

    return false;
}

bool PlayerBox::CanChangeChar()
{
    // if(!SwapCharAllowed() && !m_current_add)
    //     return false;

    int p = CalcIndex();

    // see if any other character is totally free for self
    for(int ch = 1; ch <= numCharacters; ch++)
    {
        if(ch == l_screen->charSelect[p])
            continue;

        if(CharAvailable(ch))
            return true;
    }

    // if own character is okay, then it'll be kept. return false here.
    if(CharAvailable(l_screen->charSelect[p]))
        return false;

    // if even own character not totally free, see if any character is allowed by the s_char_info state
    for(int ch = 1; ch <= numCharacters; ch++)
    {
        if(ch == l_screen->charSelect[p])
            continue;

        if(s_char_info.accept(l_screen->charSelect[p], p, m_current_add))
            return true;
    }

    return false;
}

void PlayerBox::PrevChar()
{
    // if(!SwapCharAllowed() && !m_current_add)
    // {
    //     PlaySoundMenu(SFX_BlockHit);
    //     return;
    // }

    int p = CalcIndex();
    int old_ch = l_screen->charSelect[p];

    int i = 0;
    for(i = 0; i < numCharacters; i++)
    {
        l_screen->charSelect[p] --;

        if(l_screen->charSelect[p] < 1)
            l_screen->charSelect[p] = numCharacters;

        if(CharAvailable(l_screen->charSelect[p]))
            break;
    }

    // if can't traverse normally, allow duplicates
    if(i == numCharacters)
    {
        for(i = 0; i < numCharacters; i++)
        {
            l_screen->charSelect[p] --;

            if(l_screen->charSelect[p] < 1)
                l_screen->charSelect[p] = numCharacters;

            if(s_char_info.accept(l_screen->charSelect[p], p, m_current_add))
                break;
        }
    }

    // eventually changed character, update the player
    if(l_screen->charSelect[p] != old_ch)
    {
        PlaySoundMenu(SFX_Slide);
        UpdatePlayer();
    }
    else
        PlaySoundMenu(SFX_BlockHit);
}

void PlayerBox::NextChar()
{
    // if(!SwapCharAllowed() && !m_current_add)
    // {
    //     PlaySoundMenu(SFX_BlockHit);
    //     return;
    // }

    int p = CalcIndex();
    int old_ch = l_screen->charSelect[p];

    int i;
    for(i = 0; i < numCharacters; i++)
    {
        l_screen->charSelect[p] ++;

        if(l_screen->charSelect[p] > numCharacters)
            l_screen->charSelect[p] = 1;

        if(CharAvailable(l_screen->charSelect[p]))
            break;
    }

    // if can't traverse normally, allow duplicates
    if(i == numCharacters)
    {
        for(i = 0; i < numCharacters; i++)
        {
            l_screen->charSelect[p] ++;

            if(l_screen->charSelect[p] > numCharacters)
                l_screen->charSelect[p] = 1;

            if(s_char_info.accept(l_screen->charSelect[p], p, m_current_add))
                break;
        }
    }

    // eventually changed character, update the player
    if(l_screen->charSelect[p] != old_ch)
    {
        PlaySoundMenu(SFX_Slide);
        UpdatePlayer();
    }
    else
        PlaySoundMenu(SFX_BlockHit);
}

void PlayerBox::Up()
{
    int p = CalcIndex();

    m_input_ready = false;

    if(m_state == PlayerState::SelectProfile)
    {
        PlaySoundMenu(SFX_Slide);

        if(m_menu_item == 0)
        {
            if(p < (int)Controls::g_InputMethods.size() && Controls::g_InputMethods[p])
            {
                std::vector<Controls::InputMethodProfile*> profiles = Controls::g_InputMethods[p]->Type->GetProfiles();
                int back_index = (int)profiles.size();
                m_menu_item = back_index;
            }
        }
        else
            m_menu_item --;

        m_marquee_state.reset_width();
    }

    if(m_state == PlayerState::ControlsMenu)
    {
        PlaySoundMenu(SFX_Slide);
        m_state = PlayerState::SelectChar;
        m_marquee_state.reset_width();
    }

    // rotate char backwards in 1P menu
    if(m_state == PlayerState::SelectChar && Is1P())
        PrevChar();
}

void PlayerBox::Down()
{
    int p = CalcIndex();

    m_input_ready = false;

    if(m_state == PlayerState::SelectProfile)
    {
        PlaySoundMenu(SFX_Slide);

        if(p < (int)Controls::g_InputMethods.size() && Controls::g_InputMethods[p])
        {
            std::vector<Controls::InputMethodProfile*> profiles = Controls::g_InputMethods[p]->Type->GetProfiles();
            int back_index = (int)profiles.size();
            if(m_menu_item == back_index)
                m_menu_item = -1;
        }

        m_menu_item ++;

        m_marquee_state.reset_width();
    }

    // go to controls menu in non-1P
    if(m_state == PlayerState::SelectChar && !Is1P())
    {
        PlaySoundMenu(SFX_Slide);
        m_state = PlayerState::ControlsMenu;

        if(ControlsMenu_ShowDrop(p))
            m_menu_item = -1;
        else
            m_menu_item = 0;

        m_marquee_state.reset_width();
    }

    // rotate char forwards in 1P menu
    if(m_state == PlayerState::SelectChar && Is1P())
        NextChar();
}

void PlayerBox::Left()
{
    m_input_ready = false;

    // rotate char backwards in non-1P
    if(m_state == PlayerState::SelectChar && !Is1P())
        PrevChar();

    if(m_state == PlayerState::ControlsMenu)
    {
        int p = CalcIndex();

        // don't auto-rotate for clarity
        if(m_menu_item > 0 || (ControlsMenu_ShowDrop(p) && m_menu_item == 0))
        {
            PlaySoundMenu(SFX_Slide);
            m_menu_item --;
            m_marquee_state.reset_width();
        }
    }
}

void PlayerBox::Right()
{
    m_input_ready = false;

    // rotate char forwards in non-1P
    if(m_state == PlayerState::SelectChar && !Is1P())
        NextChar();

    if(m_state == PlayerState::ControlsMenu)
    {
        if(m_menu_item < 1)
        {
            PlaySoundMenu(SFX_Slide);
            m_menu_item ++;
            m_marquee_state.reset_width();
        }
    }
}

bool PlayerBox::MouseItem(int i)
{
    if(!Is1P() && m_state == PlayerState::SelectChar)
    {
        m_state = PlayerState::ControlsMenu;
        PlaySoundMenu(SFX_Slide);
    }

    int sel = (m_state == PlayerState::SelectChar) ? l_screen->charSelect[0] : m_menu_item;

    if(sel != i)
    {
        PlaySoundMenu(SFX_Slide);

        if(m_state == PlayerState::SelectChar)
            l_screen->charSelect[0] = i;
        else
            m_menu_item = i;

        m_marquee_state.reset_width();
    }

    if(MenuMouseRelease && SharedCursor.Primary)
    {
        s_cancelDoubleClick();
        MenuMouseRelease = false;
        return Do();
    }

    return false;
}

bool PlayerBox::MenuItem_Mouse_Render(int i, const std::string& label, int X, int Y, bool mouse, bool render, int end_X)
{
    if(mouse)
    {
        int menuLen = (int)label.size() * 18;
        if(SharedCursor.X >= X && SharedCursor.X <= X + menuLen
            && SharedCursor.Y >= Y && SharedCursor.Y <= Y + 16)
        {
            return MouseItem(i);
        }
    }

    if(render)
    {
        if(m_state != PlayerState::SelectProfile)
        {
            if(GFX.CharSelIcons.inited && label.size() == 1)
            {
                if(label[0] == 'X')
                {
                    XRender::renderTextureBasic(X, Y, 24, 24, GFX.CharSelIcons, 0, 0);
                    return false;
                }
                else if(label[0] == 'O')
                {
                    XRender::renderTextureBasic(X, Y, 24, 24, GFX.CharSelIcons, 24, 0);
                    return false;
                }
                else if(label[0] == '?')
                {
                    XRender::renderTextureBasic(X, Y, 24, 24, GFX.CharSelIcons, 48, 0);
                    return false;
                }
            }
            else if(label.size() == 1)
                X += 4;
        }

        if(end_X != 0)
        {
            bool cur_item = (m_menu_item == i);

            MarqueeState null_marquee;
            MarqueeSpec item_spec(end_X - X, 10, 32, 32, -1);

            if(m_menu_item == i)
                m_marquee_state.advance(item_spec);

            SuperPrintMarquee(label, 5, X, Y, item_spec, (cur_item) ? m_marquee_state : null_marquee);
        }
        else
            SuperPrint(label, 3, X, Y);
    }

    return false;
}

// render the selected character for player P
bool PlayerBox::DrawChar(int x, int w, int y, int h, bool show_name)
{
    // don't render character box in certain states
    if(m_state == PlayerState::SelectProfile || m_state == PlayerState::ConfirmProfile)
        return false;

    int p = CalcIndex();

    // player hasn't been added yet
    bool inactive = m_state == PlayerState::Disconnected && (IsMenu() || p >= l_screen->player_count);
    bool show_inactive = inactive && p >= s_minPlayers;

    // alpha for most uses
    uint8_t alpha = (show_inactive) ? 127 : 255;

    // verify that character is valid
    int ch = l_screen->charSelect[p];
    if(ch < 1 || ch > numCharacters)
        return false;

    // do the fun player transformation thing!
    if(s_context == Context::MainMenu)
        DoTransform(p, ch);

    // draw frame
    if(GFX.CharSelFrame.tex.inited)
        RenderFrameFill(IntegerLocation_t{x, y, w, h}, GFX.CharSelFrame, XTAlpha(alpha));
    else
    {
        uint8_t alpha_border = (show_inactive) ?  64 : 255;

        XRender::renderRect(x, y, w, h, {0, 0, 0, alpha_border});
        XRender::renderRect(x + 2, y + 2, w - 4, h - 4, {255, 255, 255, alpha});
    }

    // draw arrows
    if(m_state == PlayerState::SelectChar || (s_context == Context::MainMenu && inactive))
    {
        XTColor arrow_color;

        // show grayed out scroll indicator if can't change char
        if(!CanChangeChar())
            arrow_color.a = 127;
        // otherwise, hide half of the time
        else if(CommonFrame % 90 >= 45)
            arrow_color.a = 0;
        // never show full opacity when inactive
        else if(show_inactive)
            arrow_color.a = 127;

        if(arrow_color.a == 0)
        {
            // don't render
        }
        else if(GFX.CharSelIcons.inited)
        {
            XRender::renderTextureFL(x - 24 - 4, y + h / 2 - 24 / 2, 24, 24, GFX.CharSelIcons, 72, 0, 0, nullptr, X_FLIP_HORIZONTAL, arrow_color);
            XRender::renderTextureBasic(x + w + 4, y + h / 2 - 24 / 2, 24, 24, GFX.CharSelIcons, 72, 0, arrow_color);
        }
        else
        {
            XRender::renderTextureFL(x - GFX.MCursor[1].h - 4, y + h / 2 - GFX.MCursor[1].w / 2, GFX.MCursor[1].w, GFX.MCursor[1].h, GFX.MCursor[1], 0, 0, -90, nullptr, X_FLIP_NONE, arrow_color);
            XRender::renderTextureFL(x + w + 4, y + h / 2 - GFX.MCursor[2].w / 2, GFX.MCursor[2].w, GFX.MCursor[2].h, GFX.MCursor[2], 0, 0, -90, nullptr, X_FLIP_NONE, arrow_color);
        }
    }

    // flash if player is currently disconnected
    bool player_flash = (!inactive && m_state == PlayerState::Disconnected);

    if(!player_flash || (CommonFrame % 60) < 30)
    {
        // always walk in Drop / Add, walk only after finalizing selection at main menu
        bool player_walk = (s_context == Context::DropAdd || !inactive);

        // find a spare player to edit
        int scratch_index = maxPlayers - maxLocalPlayers + 1 + p;
        Player_t& scratch_player = Player[scratch_index];

        // back up some info to the stack
        int PrevCh = scratch_player.Character;
        int Frame = scratch_player.Frame;
        int FrameCount = scratch_player.FrameCount;
        int YoshiTFrameCount = scratch_player.YoshiTFrameCount;
        int YoshiBFrameCount = scratch_player.YoshiBFrameCount;
        int YoshiWingsFrameCount = scratch_player.YoshiWingsFrameCount;

        // initialize player based on saved data (unless in Battle Mode)
        if(s_context == Context::MainMenu && MenuMode == MENU_CHARACTER_SELECT_NEW_BM)
        {
            scratch_player = Player_t();
            scratch_player.Character = ch;
            scratch_player.State = 2;
            scratch_player.Hearts = 2;
        }
        // empty save
        else if(s_context == Context::MainMenu && SaveSlotInfo[selSave].Progress < 0)
        {
            scratch_player = Player_t();
            scratch_player.Character = ch;
            scratch_player.State = 1;
            scratch_player.Hearts = 1;
        }
        else if(s_context == Context::MainMenu)
            scratch_player = SaveSlotInfo[selSave].SavedChar[ch];
        else if(BattleMode)
        {
            scratch_player = Player_t();
            scratch_player.Character = ch;
            scratch_player.State = 2;
            scratch_player.Hearts = 2;
        }
        else
            scratch_player = SavedChar[ch];

        if(scratch_player.Character < 1 || scratch_player.Character > numCharacters)
            scratch_player.Character = ch;

        if(scratch_player.State < 1 || scratch_player.State > numStates)
            scratch_player.State = 1;

        // restore data
        if(scratch_player.Character == PrevCh)
        {
            scratch_player.Frame = Frame;
            scratch_player.FrameCount = FrameCount;
            scratch_player.YoshiTFrameCount = YoshiTFrameCount;
            scratch_player.YoshiBFrameCount = YoshiBFrameCount;
            scratch_player.YoshiWingsFrameCount = YoshiWingsFrameCount;
        }
        else
            scratch_player.Frame = 1;

        // process height and frames
        scratch_player.Location.Height = Physics.PlayerHeight[scratch_player.Character][scratch_player.State];
        YoshiHeight(scratch_index);

        scratch_player.Direction = 1;
        scratch_player.Location.SpeedY = 0;
        if(player_walk)
            scratch_player.Location.SpeedX = 1;

        PlayerFrame(scratch_player);

        // set up location and place player
        scratch_player.Location.Width = Physics.PlayerWidth[scratch_player.Character][scratch_player.State];
        scratch_player.Location.Height = Physics.PlayerHeight[scratch_player.Character][scratch_player.State];
        SizeCheck(scratch_player);
        scratch_player.Location.X = x + w / 2 - scratch_player.Location.Width / 2 - vScreen[0].X;
        scratch_player.Location.Y = y + h / 2 + Physics.PlayerHeight[5][2] / 4 - scratch_player.Location.Height * 3 / 4 + 4 - vScreen[0].Y;

        if(scratch_player.Mount == 3)
            scratch_player.Location.Y += 6;

        // animate winged boot
        if(scratch_player.Mount == 1 && scratch_player.MountType == 3)
        {
            scratch_player.YoshiWingsFrameCount += 1;
            scratch_player.YoshiWingsFrame = 0;

            if(scratch_player.YoshiWingsFrameCount <= 12)
                scratch_player.YoshiWingsFrame = 1;
            else if(scratch_player.YoshiWingsFrameCount >= 24)
                scratch_player.YoshiWingsFrameCount = 0;

            if(scratch_player.Direction == 1)
                scratch_player.YoshiWingsFrame += 2;
        }

        DrawPlayer(scratch_player, 0, XTAlpha(alpha));
    }

#if 0
    // finish with character name
    if(show_name)
        SuperPrintCenter(g_gameInfo.characterName[l_screen->charSelect[p]], 3, x + w / 2, y + h + 12, XTAlpha(alpha));
#else
    UNUSED(show_name);
#endif

    return true;
}

// special the mouse logic and rendering 1P char select
int PlayerBox::Mouse_Render_1P(bool render)
{
    int p = CalcIndex();
    bool mouse = !render;

    if(p < 0 || p >= maxLocalPlayers)
    {
        // `p` should not be bigger than `maxLocalPlaeyrs`, otherwise the out of range at `s_playerState`
        SDL_assert(p >=0 && p < maxLocalPlayers);
        return false;
    }

    if(mouse && !render && !SharedCursor.Move && !SharedCursor.Primary && !SharedCursor.Secondary && !SharedCursor.ScrollUp && !SharedCursor.ScrollDown)
        return 0;

    if(mouse && SharedCursor.Secondary && MenuMouseRelease)
    {
        MenuMouseRelease = false;

        if(Back())
            return -1;
    }

    int MenuX, MenuY;
    GetMenuPos(&MenuX, &MenuY);

    int y_pos = MenuY;

    for(int i = 1; i <= numCharacters; i++)
    {
        if(!blockCharacter[i])
        {
            if(MenuItem_Mouse_Render(i, fmt::format_ne(g_mainMenu.selectCharacter, g_gameInfo.characterName[i]), MenuX, y_pos, mouse, render))
                return 1;

            if(render && l_screen->charSelect[p] == i)
                XRender::renderTextureBasic(MenuX - 20, y_pos, GFX.MCursor[0]);

            y_pos += 30;
        }
    }

    // show controls info
    if(render)
    {
        int infobox_y = MenuY + 145;

        XRender::renderRect(XRender::TargetW / 2 - 240, infobox_y, 480, 68, XTColorF(0, 0, 0, 0.5_n));

        // disconnection hint
        if(p >= (int)Controls::g_InputMethods.size() || !Controls::g_InputMethods[p])
        {
            SuperPrintScreenCenter(g_gameStrings.connectWaitingForInputDevice, 3, infobox_y + 4, XTColorF(0.8_n, 0.8_n, 0.8_n, 0.8_n));
        }
        else
        {
            // global information about controller
            // Profile should never be null
            if(Controls::g_InputMethods[p]->Profile != nullptr)
                SuperPrintScreenCenter(Controls::g_InputMethods[p]->Name + " - " + Controls::g_InputMethods[p]->Profile->Name, 3, infobox_y + 4);
            else
                SuperPrintScreenCenter(Controls::g_InputMethods[p]->Name, 3, infobox_y + 4);
        }

        SuperPrintScreenCenter(g_gameStrings.connectPressSelectForControlsOptions_P1, 3, infobox_y + 24, XTColorF(0.8_n, 0.8_n, 0.8_n, 0.8_n));
        SuperPrintScreenCenter(g_gameStrings.connectPressSelectForControlsOptions_P2, 3, infobox_y + 44, XTColorF(0.8_n, 0.8_n, 0.8_n, 0.8_n));
    }

    // do char transform thing!
    if(render && l_screen->charSelect[p] >= 1 && l_screen->charSelect[p] <= numCharacters)
        DoTransform(p, l_screen->charSelect[p]);

    return 0;
}

// do the mouse logic and rendering for each player
int PlayerBox::Mouse_Render(bool render, int x, int y, int w, int h)
{
    if(Is1P() && (m_state == PlayerState::SelectChar))
        return Mouse_Render_1P(render);

    int p = CalcIndex();
    bool mouse = !render;
    const auto* input_method = (p < (int)Controls::g_InputMethods.size()) ? Controls::g_InputMethods[p] : nullptr;


    // calculate positions
    int cx = x + w / 2;

    // controls / info pane
    const int info_height = 80;
    int info_y = y + h - info_height;

    // icons column
    const int icons_height = 22;
    int icons_x = x + 8 + 76 + 8;
    int icons_y = info_y + (GFX.PCursor.inited ? GFX.PCursor.w : GFX.MCursor[2].h) + 8;
    int infotext_y = icons_y + icons_height + 8;

    // main char select pane
    int main_x = x + 4;
    int main_y = y + 6;
    int main_width = w - 8;
    int main_height = h - info_height - 6;
    int total_height = h - 12;

    // not-yet-added player
    bool inactive = m_state == PlayerState::Disconnected && (s_context == Context::MainMenu || p >= l_screen->player_count);
    bool show_inactive = inactive && p >= s_minPlayers;

    if(inactive)
    {
        if(show_inactive)
            l_screen->charSelect[p] = s_recent_char[p];
        ValidateChar(true);
    }

    // check currently selected character
    int ch = l_screen->charSelect[p];

    // verify that character is valid
    if(ch < 1 || ch > numCharacters)
        ch = 0;

    // calculate box color
    XTColor color = XTColorF(0.4_n, 0.4_n, 0.4_n);

    switch(ch)
    {
    case 1:
        color = XTColorF(1.0_n, 0.0_n, 0.0_n);
        break;
    case 2:
        color = XTColorF(0.0_n, 1.0_n, 0.0_n);
        break;
    case 3:
        color = XTColorF(1.0_n, 0.4_n, 0.5_n);
        break;
    case 4:
        color = XTColorF(0.0_n, 0.4_n, 1.0_n);
        break;
    case 5:
        color = {255, 204, 0};
        break;
    }

    if(show_inactive)
    {
        color.r = color.r / 4 + 127;
        color.g = color.g / 4 + 127;
        color.b = color.b / 4 + 127;
    }

    // render background
    if(render)
    {
        // background
        XRender::renderRect(x + 0, y + 0, w - 0, h - 0, {0, 0, 0});
        XRender::renderRect(x + 2, y + 2, w - 4, h - 4, color * 0.95_n);
        XRender::renderRect(x + 4, y + 4, w - 8, h - 8, color * 0.75_n);

        if(m_state != PlayerState::SelectProfile)
        {
            // middle dividing line (bg)
            XRender::renderRect(x + 2, info_y - 2, w - 4, 6, color * 0.95_n);

            // middle dividing line (fg)
            XRender::renderRect(x, info_y, w, 2, {0, 0, 0});
        }

        // confirmation progress
        if(m_state == PlayerState::ConfirmProfile || m_state == PlayerState::ForceDrop)
        {
            int menu_progress = m_menu_item;
            int menu_max = 66 * 2;

            // special asymmetric setup for confirming controls profile
            if(m_state == PlayerState::ConfirmProfile)
            {
                menu_progress = SDL_min(m_menu_item, 66 * 3) * 2 + SDL_max(m_menu_item - 66 * 3, 0) * 3;
                menu_max = 66 * 12;
            }

            XTColor shade = color * XTColor::from_num(0.95_n);
            XRender::renderRect(x + 4, info_y + 4, (w - 8) * menu_progress / menu_max, info_height - 8, shade);

            // move infotext y up a bit, since controls will be drawn in main box (if at all)
            infotext_y = info_y + info_height / 2 - 8;
        }
    }

    // render the player box (if appropriate)
    // bool show_name = (main_height > 88 + 16 + 32);
    constexpr bool show_name = false;
    const int label_h = show_name ? 32 : 16;
    const int pbox_h = SDL_max(64, SDL_min(88, main_height - 16 - label_h));
    const int pbox_w = pbox_h;
    const int pbox_h_full = pbox_h + 16 + label_h;
    int pbox_x = main_x + main_width / 2 - pbox_w / 2;
    int pbox_y = main_y + main_height / 2 - pbox_h_full / 2 + 16;

    // draw character box
    if(render)
        DrawChar(pbox_x, pbox_w, pbox_y, pbox_h, show_name);

    // allow mouse to select char
    if(mouse && (m_state == PlayerState::ControlsMenu || m_state == PlayerState::SelectChar))
    {
        if(SharedCursor.X >= pbox_x && SharedCursor.X <= pbox_x + pbox_w
            && SharedCursor.Y >= pbox_y && SharedCursor.Y <= pbox_y + pbox_h)
        {
            if(m_state != PlayerState::SelectChar)
            {
                m_state = PlayerState::SelectChar;
                PlaySoundMenu(SFX_Slide);
            }

            if(m_input_ready && SharedCursor.ScrollUp)
                Left();

            if(m_input_ready && SharedCursor.ScrollDown)
                Right();

            if(MenuMouseRelease && SharedCursor.Primary)
            {
                s_cancelDoubleClick();
                MenuMouseRelease = false;
                return Do();
            }
        }
    }

    // draw cursor above char box
    if(render)
    {
        if(m_state == PlayerState::SelectChar || (inactive && p < s_minPlayers))
            Render_PCursorDownwards(pbox_x + pbox_w / 2, pbox_y - 2);
        else if(inactive && s_context == Context::MainMenu)
            Render_PCursorDownwards(pbox_x + pbox_w / 2, pbox_y - 2, XTAlpha(127));
    }

    // now render / process the player's menu as appropriate to its case

    // render the profile selection menu
    if(m_state == PlayerState::SelectProfile)
    {
        if(!input_method)
        {
            Back();
            return 0;
        }

        // set the current menu item to the current profile.
        std::vector<Controls::InputMethodProfile*> profiles = input_method->Type->GetProfiles();

        if(profiles.empty())
        {
            Back();
            return 0;
        }

        if(render)
            SuperPrintCenter(g_mainMenu.wordProfiles, 3, cx, main_y);

        int line = 20;

        int start_y = main_y + 16 + 1 * line;
        int end_y = main_y + total_height - 8;

        // calculate scroll (top rendered index) here
        int total_lines = (int)profiles.size() + 1;
        int avail_lines = (end_y - start_y) / line;

        int scroll_start = 0;
        int scroll_end = total_lines;

        if(avail_lines < total_lines)
        {
            if(m_menu_item >= 0)
                scroll_start = m_menu_item - avail_lines/2;
            if(scroll_start < 0)
                scroll_start = 0;

            scroll_end = scroll_start + avail_lines;
            if(scroll_end > total_lines)
            {
                scroll_end = total_lines;
                scroll_start = scroll_end - avail_lines;
            }
        }

        // render the scroll indicators
        if(render)
        {
            if(scroll_start > 0)
                XRender::renderTextureBasic(cx - GFX.MCursor[1].w / 2, start_y - GFX.MCursor[1].h, GFX.MCursor[1]);

            if(scroll_end < total_lines)
                XRender::renderTextureBasic(cx - GFX.MCursor[2].w / 2, start_y + (avail_lines)*line - line + 18, GFX.MCursor[2]);
        }

        // show the menu cursor for the player
        if(render && m_menu_item >= 0)
            Render_PCursor(x + 6, start_y + (m_menu_item-scroll_start)*line);

        // render the profile names and "Back"
        for(int i = scroll_start; i < scroll_end; i++)
        {
            std::string* name = &g_mainMenu.wordBack;

            if(i != (int)profiles.size())
                name = &(profiles[i]->Name);

            MenuItem_Mouse_Render(i, *name,
                x + 6 + 16 + 2, start_y + (i-scroll_start)*line, mouse, render, x + w - 6);
        }
    }

    // render the profile confirmation screen
    if(render && m_state == PlayerState::ConfirmProfile)
    {
        SuperPrintCenter(g_gameStrings.connectTestProfile, 3, cx, main_y);

        if(input_method && input_method->Profile != nullptr)
        {
            MarqueeSpec profile_spec(w - 12, 10, 64, 32, 0);
            m_marquee_state.advance(profile_spec);
            SuperPrintMarquee(input_method->Profile->Name, 5, x + 6, main_y + 20, profile_spec, m_marquee_state);
        }
    }

    // draw the controls box in the appropriate place
    if(render)
    {
        int controls_x = 0;
        int controls_y = 0;

        if(m_state == PlayerState::SelectProfile || m_state == PlayerState::ForceDrop)
        {
            // don't draw at all
        }
        else if(m_state == PlayerState::ConfirmProfile)
        {
            controls_x = main_x + main_width / 2 - 76 / 2;
            controls_y = main_y + main_height / 2 - 16;
        }
        else if(m_state == PlayerState::Disconnected || m_state == PlayerState::Reconnecting)
        {
            controls_x = main_x + main_width / 2 - 76 / 2;
            controls_y = icons_y - 6;
        }
        else
        {
            controls_x = icons_x - 84;
            controls_y = icons_y - 6;
        }

        if(controls_x != 0)
        {
            if(inactive)
                speedRun_syncControlKeys(p, Controls_t());

            RenderControls(p, controls_x, controls_y, 76, 30, !input_method, 255, true);
        }
    }

    // render the controls menu main icons
    if(m_state == PlayerState::SelectChar || m_state == PlayerState::ControlsMenu)
    {
        int col_spacer = (x + w - 4 - icons_x) / 3;
        int base_col = icons_x + col_spacer;

        // show the cursor for the player
        if(render && m_state == PlayerState::ControlsMenu)
            Render_PCursorDownwards(base_col + 12 + m_menu_item * col_spacer, icons_y);

        // drop me
        if(ControlsMenu_ShowDrop(p))
        {
            // this one returns true when no players are left
            if(MenuItem_Mouse_Render(-1, "X",
                base_col - col_spacer, icons_y, mouse, render))
            {
                return -1;
            }
        }

        // reconnect controller
        MenuItem_Mouse_Render(0, "O",
            base_col, icons_y, mouse, render);

        // switch profile
        MenuItem_Mouse_Render(1, "?",
            base_col + col_spacer, icons_y, mouse, render);
    }

    // hint string
    if(render)
    {
        const std::string* message = nullptr;
        std::string temporary;
        XTColor message_color;

        if(m_state == PlayerState::SelectChar)
        {
            if(input_method && input_method->Profile != nullptr)
            {
                message = &input_method->Profile->Name;
                message_color = XTAlphaF(0.75_n);
            }
        }
        else if(m_state == PlayerState::ControlsMenu)
        {
            if(m_menu_item == -1)
                message = &g_gameStrings.connectDropMe;
            else if(m_menu_item == 0)
                message = &g_gameStrings.connectReconnectTitle;
            else if(m_menu_item == 1)
                message = &g_mainMenu.wordProfiles;
        }
        else if(m_state == PlayerState::ConfirmProfile)
        {
            // using marquee for profile name
            SuperPrintCenter(g_gameStrings.connectHoldStart, 5, cx, infotext_y, message_color);
        }
        else if(m_state == PlayerState::ForceDrop)
        {
            int index = CheckCanDrop() + 1;

            if(index > 0)
                message = &(temporary = fmt::format_ne(g_gameStrings.connectDropPX, index));
            else
                message = &g_gameStrings.connectForceResume;
        }
        else if(m_state == PlayerState::Reconnecting)
            message = &g_gameStrings.connectReconnectTitle;
        else if(m_state == PlayerState::Disconnected)
            message = &g_gameStrings.connectPressAButton;

        if(message)
        {
            MarqueeSpec print_spec = MarqueeSpec(main_width - 8, 10, 16, 32, 0);

            m_marquee_state.advance(print_spec);
            SuperPrintMarquee(*message, 5, main_x + 4, infotext_y, print_spec, m_marquee_state, message_color);
        }
    }

    if(MenuMouseRelease && SharedCursor.Secondary
        && SharedCursor.X >= x && SharedCursor.X <= x + w
        && SharedCursor.Y >= y && SharedCursor.Y <= y + h)
    {
        MenuMouseRelease = false;
        if(Back())
            return -1;
    }

    return 0;
}

int Mouse_Render(bool mouse, bool render)
{
    int MenuX, MenuY;
    GetMenuPos(&MenuX, &MenuY);

    if(mouse && !SharedCursor.Move && !render && !SharedCursor.Primary && !SharedCursor.Secondary && !SharedCursor.ScrollUp && !SharedCursor.ScrollDown)
        return 0;

    int n = BoxCount();

    /*--------------------*\
    || Arrange screen     ||
    \*--------------------*/

    const int header_height = (s_context == Context::DropAdd) ? 32 : 0;
    int box_width = 220;
    int box_height = 240;
    if(IsMenu() && box_height > XRender::TargetH - MenuY - 8)
        box_height = XRender::TargetH - MenuY - 8;
    int padding = 16;

    // number of columns per row
    int n_cols[2] = {n, 0};

    // do drop/add in 2 rows when >2P
    if(n > 2 && s_context != Context::MainMenu)
    {
        n_cols[1] = n / 2;
        n_cols[0] = n - n_cols[1];
    }

    // shrink boxes when they would not fit on screen
    if(n_cols[0] * box_width + (n_cols[0] - 1) * padding > XRender::TargetW)
    {
        box_width = 168;
        padding = 8;

        int max_width = (XRender::TargetW - (n_cols[0] - 1) * padding) / n_cols[0];
        max_width &= ~1;
        if(box_width > max_width)
            box_width = max_width;
    }

    int full_height = header_height + box_height + padding;
    int full_width = padding + (box_width + padding) * n_cols[0];

    if(n_cols[1])
        full_height += padding + box_height;

    // vertical / horizontal start of the menu
    int start_x = XRender::TargetW / 2 - full_width / 2;
    int draw_y = XRender::TargetH / 2 - full_height / 2;

    if(IsMenu())
        GetMenuPos(nullptr, &draw_y);

    // make sure they are even
    start_x &= ~1;
    draw_y &= ~1;

    /*-----------------------*\
    || Background and header ||
    \*-----------------------*/

    if(s_context == Context::DropAdd)
    {
        if(render)
        {
            if(full_width < 440)
                XRender::renderRect((XRender::TargetW / 2 - 440 / 2) & ~1, draw_y, 440, full_height, XTColorF(0.0_n, 0.0_n, 0.0_n, 0.5_n));
            else
                XRender::renderRect(start_x, draw_y, full_width, full_height, XTColorF(0.0_n, 0.0_n, 0.0_n, 0.5_n));

            SuperPrintScreenCenter(g_gameStrings.pauseItemPlayerSetup, 3, draw_y + 8);
        }

        draw_y += header_height;
    }

    int ret = 0;

    // start drawing player boxes
    int draw_x = start_x + padding;

    for(int p = 0; p < n; p++)
    {
        // start new row if needed
        if(p == n_cols[0])
        {
            draw_x = start_x + padding;
            draw_y += box_height + padding;
        }

        int p_ret = s_players[p].Mouse_Render(render, draw_x, draw_y, box_width, box_height);

        if(p_ret != 0)
            ret = p_ret;

        draw_x += box_width + padding;
    }

    return ret;
}

int MouseLogic()
{
    // check mouse release if not in main menu
    if(s_context == Context::DropAdd)
    {
        if(!SharedCursor.Primary && !SharedCursor.Secondary)
            MenuMouseRelease = true;
    }

    int ret = Mouse_Render(true, false);

    // and set it to false if needed
    if(SharedCursor.Primary || SharedCursor.Secondary)
        MenuMouseRelease = false;

    return ret;
}

int PlayerBox::Logic()
{
    int p = CalcIndex();
    auto* input_method = (p < (int)Controls::g_InputMethods.size()) ? Controls::g_InputMethods[p] : nullptr;


    // hide "Drop Me", if it is no longer allowed
    if(m_state == PlayerState::ControlsMenu
        && m_menu_item == -1 && !ControlsMenu_ShowDrop(p))
    {
        m_menu_item = 0;
        m_marquee_state.reset_width();
    }

    // if player's input was lost, mark disconnected and return (unless in 1P menu)
    if(!Is1P() && !input_method)
    {
        m_input_ready = false;

        if(m_state != PlayerState::Reconnecting && m_state != PlayerState::Disconnected)
        {
            m_state = PlayerState::Disconnected;
            m_marquee_state.reset_width();
        }

        return 0;
    }

    // if the player has a controller and was previously disconnected, mark them as connected
    if(m_state == PlayerState::Disconnected || m_state == PlayerState::Reconnecting)
    {
        m_marquee_state.reset_width();
        m_input_ready = false;

        if(IsMenu())
        {
            if(m_state == PlayerState::Reconnecting) // requested reconnect
            {
                m_state = PlayerState::SelectChar;
                m_menu_item = 0;
                PlaySoundMenu(SFX_Pet);
            }
            else
            {
                m_input_ready = true;
                m_just_added = true;

                m_menu_item = 0;
                if(p >= s_minPlayers)
                    l_screen->charSelect[p] = s_recent_char[p];
                m_state = PlayerState::SelectChar;
                ValidateChar();
            }
        }
        else if(s_context == Context::DropAdd)
        {
            // this is an Add situation
            if(p >= l_screen->player_count)
            {
                m_menu_item = 0;
                l_screen->charSelect[p] = s_recent_char[p];
                m_state = PlayerState::SelectChar;

                // check whether a novel add
                if(p >= s_char_info.max_players)
                {
                    m_current_add = 2;
                    s_char_info.max_players = p + 1;
                }
                else
                {
                    m_current_add = 1;
                }

                // validate character
                ValidateChar();

                // add the player immediately
                UpdatePlayer();
            }
            else // was disconnected
            {
                m_state = PlayerState::SelectChar;
                m_menu_item = 0;
                PlaySoundMenu(SFX_Pet);
            }
        }

        // wait in case controls are not yet updated
        return 0;
    }

    const Controls_t& c = Controls::g_RawControls[p];

    bool c_Do, c_Back, c_AltDo, c_AltBack;

    if(p < (int)Controls::g_InputMethods.size() && Controls::g_InputMethods[p] && Controls::g_InputMethods[p]->Profile && Controls::g_InputMethods[p]->Profile->m_altMenuControls)
    {
        c_Do = c.AltJump;
        c_Back = c.Jump || c.Run;
        c_AltDo = c.AltRun;
        c_AltBack = c.Run;
    }
    else
    {
        c_Do = c.Jump;
        c_Back = c.Run || c.AltJump;
        c_AltDo = c.AltJump;
        c_AltBack = c.AltRun;
    }

    if(m_just_added)
    {
        // play drop item noise?
        bool play_noise = (s_context != Context::LegacyMenu);

        // block back if a new-added player
        if((int)Controls::g_InputMethods.size() > s_minPlayers && (c_Back || l_SharedControls.MenuBack))
            m_input_ready = false;
        // if pressing back, don't play drop item noise
        else if(c_Back || l_SharedControls.MenuBack)
            play_noise = false;

        // if about to move cursor, don't play drop item noise
        if(m_input_ready && (c.Down || c.Up || c.Left || c.Right))
            play_noise = false;

        // don't allow going forwards at main menu
        if(s_context == Context::MainMenu && m_input_ready && (c_Do || c.Start))
            m_input_ready = false;

        if(play_noise)
            PlaySoundMenu(SFX_DropItem);

        m_just_added = false;
    }

    // don't do any logic until all buttons have been released
    if(!m_input_ready)
    {
        if(!l_SharedControls.MenuDo && !l_SharedControls.MenuBack && !l_SharedControls.MenuDown
            && !l_SharedControls.MenuUp && !l_SharedControls.MenuLeft && !l_SharedControls.MenuRight
            && !c.Jump && !c.Start && !c.Run && !c.Down && !c.Up && !c.Left && !c.Right && !c.Drop && !c.AltRun && !c.AltJump)
        {
            m_input_ready = true;
        }

        return 0;
    }

    if(IsMenu() && !g_forceCharacter)
    {
        if((m_konami_bits == 0 && c.Up)
            || (m_konami_bits == 1 && c.Up)
            || (m_konami_bits == 2 && c.Down)
            || (m_konami_bits == 3 && c.Down)
            || (m_konami_bits == 4 && c.Left)
            || (m_konami_bits == 5 && c.Right)
            || (m_konami_bits == 6 && c.Left)
            || (m_konami_bits == 7 && c.Right)
            || (m_konami_bits == 8 && c_AltBack)
            || (m_konami_bits == 9 && c_AltDo))
        {
            m_konami_bits++;

            if(m_konami_bits == 10)
            {
                for(int A = 1; A <= numCharacters; A++)
                    blockCharacter[A] = false;

                g_forceCharacter = true;

                PlaySoundMenu(SFX_MedalGet);
                m_input_ready = false;
                return 0;
            }
            else if(m_konami_bits >= 9)
            {
                m_input_ready = false;
                return 0;
            }
        }
        else if(c.Jump || c.Start || c.Run || c.Down || c.Up || c.Left || c.Right || c.Drop || c.AltRun || c.AltJump)
            m_konami_bits = 0;
    }

    if(m_state == PlayerState::ConfirmProfile)
    {
        bool no_buttons = !c.Run && !c.Jump && !c.AltRun && !c.AltJump && !c.Start && !c.Drop && !c.Down && !c.Up && !c.Left && !c.Right;

        if(!no_buttons && m_menu_item < 66 * 3)
            m_menu_item = (4 * m_menu_item + 66 * 3) / 5;

        if(c.Start)
            m_menu_item += 2;
        else if(m_menu_item > 66 * 3 || no_buttons)
            m_menu_item--;

        if(m_menu_item < 0)
        {
            // Go back to profile select screen, if possible
            if(input_method)
            {
                m_state = PlayerState::SelectProfile;

                // set the current menu item to the profile that the player tried to activate.
                std::vector<Controls::InputMethodProfile*> profiles = input_method->Type->GetProfiles();
                std::vector<Controls::InputMethodProfile*>::iterator p_profile
                    = std::find(profiles.begin(), profiles.end(), input_method->Profile);

                if(profiles.size() > 1 && p_profile != profiles.end())
                    m_menu_item = p_profile - profiles.begin();
                else
                    m_menu_item = 0;

                Controls::SetInputMethodProfile(input_method, m_last_profile);
            }
            else
            {
                s_controls_dirty = true;
                m_state = PlayerState::ControlsMenu;
                m_menu_item = 1;
            }

            m_last_profile = nullptr;
            m_input_ready = false;
            m_marquee_state.reset_width();
            PlaySoundMenu(SFX_Slide);
        }
        else if(m_menu_item > 66 * 5)
        {
            PlaySoundMenu(SFX_Do);

            if(Is1P())
            {
                m_menu_item = 0;
                m_state = PlayerState::SelectChar;
            }
            else
            {
                m_menu_item = 1;
                m_state = PlayerState::ControlsMenu;
            }

            m_last_profile = nullptr;
            m_input_ready = false;
            m_marquee_state.reset_width();
        }

        return 0;
    }

    if(m_state == PlayerState::ForceDrop)
    {
        int to_drop = CheckCanDrop();

        if(to_drop <= -2)
        {
            PlaySoundMenu(SFX_BlockHit);
            m_state = PlayerState::SelectChar;
            m_menu_item = 0;
            m_marquee_state.reset_width();
            m_input_ready = false;
        }
        else if(c_Back)
            m_menu_item += 1;
        else if(m_menu_item >= 0)
            m_menu_item -= 2;

        if(m_menu_item > 66 * 2)
        {
            if(to_drop >= 0)
                Player_Remove(to_drop);
            else
                QuickReconnectScreen::g_active = true;

            if(to_drop == -1 || CheckDone())
            {
                PlaySoundMenu(SFX_Slide);
                return -1;
            }
            else
                PlaySoundMenu(SFX_PlayerDied2);

            m_menu_item = 0;
        }
        else if(m_menu_item < 0)
        {
            m_state = PlayerState::ControlsMenu;
            m_menu_item = 0;
            m_marquee_state.reset_width();
            m_input_ready = false;
        }

        return 0;
    }
    else if(c_Back || (Is1P() && l_SharedControls.MenuBack))
    {
        if(Back())
            return -1;
    }
    else if(c_Do || c.Start || (Is1P() && l_SharedControls.MenuDo))
    {
        if(Do())
        {
            if(Controls::g_InputMethods.empty())
                return -1;

            return 1;
        }
    }
    else if(c.Down || (Is1P() && l_SharedControls.MenuDown))
    {
        Down();
    }
    else if(c.Up || (Is1P() && l_SharedControls.MenuUp))
    {
        Up();
    }
    else if(c.Left || (Is1P() && l_SharedControls.MenuLeft))
    {
        Left();
    }
    else if(c.Right || (Is1P() && l_SharedControls.MenuRight))
    {
        Right();
    }
    else if(Is1P() && m_state == PlayerState::SelectChar && c.Drop)
    {
        // force Select Profile mode
        m_state = PlayerState::ControlsMenu;
        m_menu_item = 1;
        Do();
    }

    return 0;
}

int Logic()
{
    /*-----------------------*\
    ||    Shared back key    ||
    \*-----------------------*/
    if(CheckDone() || (s_context == Context::MainMenu && Controls::g_InputMethods.size() == 0))
    {
        if(!l_SharedControls.MenuBack)
            MenuCursorCanMove = true;

        if((l_SharedControls.MenuBack && MenuCursorCanMove) || (SharedCursor.Secondary && MenuMouseRelease))
        {
            PlaySoundMenu(SFX_Slide);
            MenuCursorCanMove = false;
            return -1;
        }
    }

    /*-----------------------*\
    ||   per-player logic    ||
    \*-----------------------*/

    for(int p = 0; p < maxLocalPlayers; p++)
    {
        int p_ret = s_players[p].Logic();
        if(p_ret)
        {
            s_char_info.mark_present();
            if(p_ret == 1 || s_context == Context::DropAdd)
                s_logRecentChars();
            return p_ret;
        }
    }

    int ret = MouseLogic();
    if(ret)
    {
        s_char_info.mark_present();
        if(ret == 1 || s_context == Context::DropAdd)
            s_logRecentChars();
        return ret;
    }

    /*-----------------------*\
    || polling input methods ||
    \*-----------------------*/
    bool block_poll = false;

    // only allow the correct number of players to connect
    int first_not_connected = std::find(Controls::g_InputMethods.begin(), Controls::g_InputMethods.end(), nullptr) - Controls::g_InputMethods.begin();
    if(first_not_connected >= BoxCount())
        block_poll = true;

    // block polling if a player might need to restore their previous profile
    for(int p = 0; p < maxLocalPlayers; p++)
    {
        if(s_players[p].m_state == PlayerState::ConfirmProfile)
            block_poll = true;
    }

    if(!block_poll)
    {
        auto found = Controls::PollInputMethod();
        if(found)
            found->used_for_player = true;
    }

    return 0;
}

void Render()
{
    Mouse_Render(false, true);
}

// reset allowed char tracking
void SaveChars()
{
    s_char_info.reset();
    s_char_info.mark_present();
}

} // namespace ConnectScreen


================================================
FILE: src/main/screen_connect.h
================================================
#ifndef SCREEN_CONNECT_H

#define SCREEN_CONNECT_H

// for maxLocalPlayers
#include "../global_constants.h"

namespace ConnectScreen
{

void MainMenu_Start(int minPlayers);
void DropAdd_Start();
void LegacyMenu_Start();

void Render();

// return values:
// -1 back
// 0 continue
// 1 next
int Logic();

// used to track which characters
//   were present in last case with
//   SwapCharAllowed() true.
void SaveChars();

} // namespace ConnectScreen

#endif // SCREEN_CONNECT_H


================================================
FILE: src/main/screen_content.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <memory>
#include <vector>

#include "core/render.h"

#include "graphics.h"
#include "graphics/gfx_marquee.h"
#include "gfx.h"

#include "main/menu_main.h"
#include "main/game_info.h"
#include "editor/new_editor.h"

#include "globals.h"
#include "controls.h"
#include "sound.h"
#include "config.h"

void menu_draw_infobox_switch_arrows(int infobox_x, int infobox_y);

namespace ContentSelectScreen
{

struct Item
{
    int m_index = -1;
    MarqueeState m_title_marquee_state;
    MarqueeState m_author_marquee_state;

    const SelectWorld_t* operator->() const;
};

static std::vector<Item> s_items;
static int s_current_item = 0;
static int s_recent_item = -1;

static int ScrollDelay = 0;
static int minShow = 0;
static int maxShow = 0;

static int worldCurs = 0;

bool editor_target_thextech = true;


// Implementation for Item
const SelectWorld_t* Item::operator->() const
{
    const std::vector<SelectWorld_t>& SelectorList
        = (MenuMode == MENU_BATTLE_MODE) ? SelectBattle :
            SelectWorld;

    if(m_index > 0 && m_index < (int)SelectorList.size())
        return &SelectorList[m_index];
    else if(SelectorList.size() > 0)
        return &SelectorList[0];
    else
        return nullptr;
}


// Implementation for global routines

void Prepare()
{
    s_items.clear();

    const std::vector<SelectWorld_t>& SelectorList
        = (MenuMode == MENU_BATTLE_MODE) ? SelectBattle :
            SelectWorld;

    size_t editor_entries_start = SelectorList.size() - 2;
    size_t editor_battle_levels = editor_entries_start;
    // size_t editor_new_world = SelectorList.size() - 1;

    for(size_t i = 1; i < SelectorList.size(); i++)
    {
        // filtering condition can go here
        if(MenuMode == MENU_EDITOR)
        {
            if(!SelectorList[i].editable)
                continue;

            if(g_gameInfo.disableBattleMode && i == editor_battle_levels)
                continue;
        }
        // skip the special editor worlds if not in editor
        else if(MenuMode != MENU_BATTLE_MODE && i >= editor_entries_start)
            continue;

        s_items.emplace_back();
        s_items.back().m_index = i;

        // load thumbnail here
    }

    // find recent item
    s_recent_item = -1;

    for(size_t i = 0; i < s_items.size(); ++i)
    {
        auto &w = SelectorList[s_items[i].m_index];
        const std::string& wPath = w.WorldFilePath;

        if((MenuMode == MENU_1PLAYER_GAME && wPath == g_recentWorld1p) ||
           (MenuMode == MENU_2PLAYER_GAME && wPath == g_recentWorld2p) ||
           (MenuMode == MENU_EDITOR && wPath == g_recentWorldEditor))
        {
            s_recent_item = (int)i;
        }
    }

    if(s_recent_item >= 0)
    {
        s_current_item = s_recent_item;
        worldCurs = s_recent_item - 2;
    }
    else
    {
        s_current_item = 0;
        worldCurs = 0;
    }
}

int Logic()
{
    MenuControls_t menuControls = Controls::GetMenuControls();

    menuControls.Back |= (SharedCursor.Secondary && MenuMouseRelease);

    if(menuControls.Back && menuControls.Do)
        menuControls.Do = false;

    int MenuX, MenuY;
    GetMenuPos(&MenuX, &MenuY);

    if(ScrollDelay > 0)
    {
        SharedCursor.Move = true;
        ScrollDelay -= 1;
    }

    if(SharedCursor.Move)
    {
        int B = 0;

        for(int A = minShow; A < maxShow; A++)
        {
            if(SharedCursor.Y >= MenuY + B * 30 && SharedCursor.Y <= MenuY + B * 30 + 16)
            {
                int menuLen = 19 * static_cast<int>(s_items[A]->WorldName.size());

                if(SharedCursor.X >= MenuX && SharedCursor.X <= MenuX + menuLen)
                {
                    if(MenuMouseRelease && SharedCursor.Primary)
                        MenuMouseClick = true;

                    if(s_current_item != A && ScrollDelay == 0)
                    {
                        ScrollDelay = 10;
                        PlaySoundMenu(SFX_Slide);
                        s_current_item = A;
                    }
                }
            }

            B += 1;
        }
    }

    if(MenuCursorCanMove || MenuMouseClick)
    {
        if(menuControls.Back)
        {
            PlaySoundMenu(SFX_Slide);
            MenuCursorCanMove = false;
            return -1;
        }
        else if(menuControls.Do || MenuMouseClick)
        {
            bool disabled = false;
            // Save menu state
            // listMenuLastScroll = worldCurs;
            // listMenuLastCursor = s_current_item;

            selWorld = s_items[s_current_item].m_index;

            MenuCursorCanMove = false;

            if(s_items[s_current_item]->disabled)
                disabled = true;

            if(!disabled)
                PlaySoundMenu(SFX_Do);

            if(disabled)
            {
                PlaySoundMenu(SFX_BlockHit);
                // Do nothing. stay at menu
            }
            // advance to next menu
            else
                return 1;
        }
    }

    // New world select scroll options!
    // Based on Wohlstand's but somewhat simpler and less keyboard-specific.
    // Left and right are -/+ 3 (repeatable, so they also provide a quick-first/quick-last function).
    // DropItem / Tertiary cursor button is return to last episode.
    bool dontWrap = false;

    if(SharedCursor.ScrollUp || SharedCursor.ScrollDown)
    {
        PlaySoundMenu(SFX_Saw);
        dontWrap = true;

        if(SharedCursor.ScrollUp)
            s_current_item -= 1;
        else
            s_current_item += 1;
    }
    else if(menuControls.Left || menuControls.Right || menuControls.Up || menuControls.Down)
    {
        if(MenuCursorCanMove || ScrollDelay == 0)
        {
            if(menuControls.Left || menuControls.Right)
            {
                int first_new_content = (g_gameInfo.disableBattleMode) ? s_items.size() - 1 : s_items.size() - 2;

                if(MenuMode == MENU_EDITOR && s_current_item >= first_new_content)
                {
                    if(MenuCursorCanMove)
                    {
                        editor_target_thextech = !editor_target_thextech;
                        PlaySoundMenu(SFX_Climbing);
                        ScrollDelay = -1;
                    }
                }
                else
                {
                    PlaySoundMenu(SFX_Saw);
                    ScrollDelay = 15;
                    dontWrap = true;

                    if(menuControls.Left)
                        s_current_item -= 3;
                    else
                        s_current_item += 3;
                }
            }
            else
            {
                PlaySoundMenu(SFX_Slide);
                ScrollDelay = -1;

                if(menuControls.Up)
                    s_current_item -= 1;
                else
                    s_current_item += 1;
            }

            MenuCursorCanMove = false;
        }
    }

    if(menuControls.Home && MenuCursorCanMove && s_recent_item >= 0)
    {
        PlaySoundMenu(SFX_Camera);
        s_current_item = s_recent_item;
        MenuCursorCanMove = false;
        dontWrap = true;
    }

    if(dontWrap)
    {
        if(s_current_item >= (int)s_items.size())
            s_current_item = (int)s_items.size() - 1;
        if(s_current_item < 0)
            s_current_item = 0;
    }
    else
    {
        if(s_current_item >= (int)s_items.size())
            s_current_item = 0;
        if(s_current_item < 0)
            s_current_item = (int)s_items.size() - 1;
    }

    return 0;
}

void Render()
{
    int MenuX, MenuY;
    GetMenuPos(&MenuX, &MenuY);

    // std::string tempStr;

    minShow = 0;
    maxShow = s_items.size();

    int original_maxShow = maxShow;
    if(maxShow > 5)
    {
        minShow = worldCurs;
        maxShow = minShow + 5;

        if(s_current_item <= minShow)
            worldCurs -= 1;

        if(s_current_item >= maxShow - 1)
            worldCurs += 1;

        if(worldCurs < 0)
            worldCurs = 0;

        if(worldCurs > original_maxShow - 5)
            worldCurs = original_maxShow - 5;

        minShow = worldCurs;
        maxShow = minShow + 5;
    }

    for(auto A = minShow; A < maxShow; A++)
    {
        const Item& w = s_items[A];

        XTColor color;
        color.r = (A == s_recent_item) ? 0 : 255;

        if(w->disabled)
            color = {127, 127, 127};

        if(w->probably_incompatible)
            color = {255, 127, 127};

        int B = A - minShow + 1;

        SuperPrint(w->WorldName, 3, MenuX, MenuY - 30 + (B * 30), color);
    }

    // preview type of content being created
    int first_new_content = (g_gameInfo.disableBattleMode) ? s_items.size() - 1 : s_items.size() - 2;
    if(MenuMode == MENU_EDITOR && s_current_item >= first_new_content)
    {
        int B = s_current_item - minShow + 1;

        // draw mode icon
        int mode_icon_X = MenuX + 340;
        int mode_icon_Y = MenuY - 34 + (B * 30);

        uint16_t rot = SDL_abs((int)(CommonFrame % 64) - 32);
        rot = rot - 16;

        if(!editor_target_thextech)
            XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFXNPC[NPCID_POWER_S3], 0, 0, 32, 32, rot, nullptr, X_FLIP_NONE);
        else if(GFX.EIcons.inited)
            XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFX.EIcons, 0, 32*Icon::thextech, 32, 32, rot, nullptr, X_FLIP_NONE);
        else
            XRender::renderTextureScaleEx(mode_icon_X, mode_icon_Y, 24, 24, GFXNPC[NPCID_ICE_POWER_S3], 0, 0, 32, 32, rot, nullptr, X_FLIP_NONE);

        // draw infobox
        int infobox_x = XRender::TargetW / 2 - 240;
        int infobox_y = MenuY + 145;

        XRender::renderRect(infobox_x, infobox_y, 480, 68, {0, 0, 0, 192});

        XTColor color;

        if(editor_target_thextech)
            color = XTColorF(0.5_n, 0.8_n, 1.0_n);
        else
            color = XTColorF(1.0_n, 0.5_n, 0.5_n);

        SuperPrintScreenCenter(g_mainMenu.editorMakeFor, 3, infobox_y + 14, color);

        if(editor_target_thextech)
            SuperPrintScreenCenter("TheXTech", 3, infobox_y + 34, color);
        else
            SuperPrintScreenCenter("SMBX 1.3", 3, infobox_y + 34, color);

        menu_draw_infobox_switch_arrows(infobox_x, infobox_y);
    }

    // render the scroll indicators
    if(minShow > 0)
        XRender::renderTextureBasic(XRender::TargetW/2 - 8, MenuY - 20, GFX.MCursor[1]);

    if(maxShow < original_maxShow)
        XRender::renderTextureBasic(XRender::TargetW/2 - 8, MenuY + 140, GFX.MCursor[2]);

    int B = s_current_item - minShow;

    if(B >= 0 && B < 5)
        XRender::renderTextureBasic(MenuX - 20, MenuY + (B * 30), GFX.MCursor[0]);
}


} // namespace ContentSelectScreen


================================================
FILE: src/main/screen_content.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef SCREEN_CONTENT_H
#define SCREEN_CONTENT_H

namespace ContentSelectScreen
{

extern bool editor_target_thextech;

void Prepare();

void Render();

// return values:
// -1 back
// 0 continue
// 1 next
int Logic();

} // namespace ContentSelectScreen

#endif // SCREEN_CONTENT_H


================================================
FILE: src/main/screen_options.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>

#include <IniProcessor/ini_processing.h>
#include <AppPath/app_path.h>
#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "core/render.h"

#include "global_constants.h"
#include "global_dirs.h"
#include "sound.h"
#include "globals.h"
#include "gfx.h"
#include "graphics.h"
#include "config.h"

#include "cheat_code.h"
#include "game_main.h"
#include "main/game_info.h"
#include "main/menu_main.h"
#include "main/screen_options.h"
#include "graphics/gfx_frame.h"
#include "graphics/gfx_marquee.h"
#include "fontman/font_manager.h"
#include "main/menu_controls.h"
#include "controls.h"
#include "control/controls_methods.h" // to cancel keyboard's double-click fullscreen

namespace OptionsScreen
{

constexpr size_t SECTION_NONE = -1;
size_t section_index = SECTION_NONE;
std::vector<size_t> section_header_indexes;
size_t next_section_index = 0;

std::vector<size_t> visible_items;


size_t cur_item = 0;
size_t cur_scroll = 0;

int8_t mouse_scroll_cooldown = -1;
bool controls_ready = false;
bool cur_item_changed = false;

bool global_dirty = false;

MarqueeState name_marquee;
MarqueeState value_marquee;
MarqueeState name_tooltip_marquee;
MarqueeState value_tooltip_marquee;

static std::string s_temp_string;

// Config_t* const config_levels[] = {nullptr, nullptr, &g_gameInfo, &g_config_game_user, &g_config_episode_creator, &g_config_episode_user,
//     &g_config_file_creator, nullptr, &g_config_cmdline, nullptr};

inline bool s_deferred_changes()
{
#if (defined(CUSTOM_AUDIO) || defined(__16M__)) && defined(RENDER_CUSTOM)
    return false;
#else
    return section_index != SECTION_NONE && g_config.m_options[section_index] == &g_config.advanced;
#endif
}

inline void s_set_dirty()
{
    global_dirty = true;
}

inline void s_switch_item()
{
    cur_item_changed = false;
    name_marquee.reset_width();
    value_marquee.reset_width();
    name_tooltip_marquee.reset_width();
    value_tooltip_marquee.reset_width();
}

inline void s_change_item()
{
    cur_item_changed = true;
    value_marquee.reset_width();
    value_tooltip_marquee.reset_width();
    s_set_dirty();

    if(!s_deferred_changes())
        UpdateConfig();
}

inline size_t get_num_items()
{
    return visible_items.size();
}

inline bool is_subsection(size_t item)
{
    if(section_index == SECTION_NONE || item >= get_num_items())
        return false;

    if(g_config.m_options[visible_items[item]] == &g_config.reset_all)
        return false;

    return dynamic_cast<ConfigSubSection_t<true>*>(g_config.m_options[visible_items[item]]) != nullptr;
}

inline void s_reset_friends()
{
    bool any_compat_set = false;

    for(size_t index : visible_items)
    {
        if(index < g_config.m_options.size() && g_config.m_options[index] && g_config.m_options[index]->m_set == ConfigSetLevel::cheat)
        {
            g_config.m_options[index]->unset();
            any_compat_set = true;
        }
    }

    if(any_compat_set)
    {
        UpdateConfig();
        PlaySoundMenu(SFX_LavaMonster);
    }
    else
        PlaySoundMenu(SFX_BlockHit);
}

inline void s_check_friends_edited()
{
    bool any_compat_set = false;

    for(size_t index : visible_items)
    {
        if(index < g_config.m_options.size() && g_config.m_options[index] && g_config.m_options[index]->m_set == ConfigSetLevel::cheat)
        {
            any_compat_set = true;
            break;
        }
    }

    g_CheatEditYourFriends = any_compat_set;
}

void RefreshVisibleItems();

void ResetStrings()
{
    name_marquee.reset_width();
    value_marquee.reset_width();
    name_tooltip_marquee.reset_width();
    value_tooltip_marquee.reset_width();
}

void Init()
{
    section_header_indexes.clear();
    size_t i = 0;
    for(BaseConfigOption_t<false>* opt : g_options.m_options)
    {
        if(dynamic_cast<ConfigSection_t<false>*>(opt))
            section_header_indexes.push_back(i);
        i++;
    }

    section_index = SECTION_NONE;

    if(g_CheatEditYourFriends == 2)
    {
        // set to compat
        for(size_t i : section_header_indexes)
        {
            if(g_options.m_options[i] == &g_options.compat)
            {
                section_index = i;
                break;
            }
        }
    }

    RefreshVisibleItems();

    cur_item = 0;
    s_switch_item();
    cur_scroll = 0;

    controls_ready = false;

    global_dirty = false;
}

void RefreshVisibleItems()
{
    visible_items.clear();

    auto current_scope = Config_t::Scope::UserVisible;

    if(section_index == SECTION_NONE)
    {
        for(size_t i : section_header_indexes)
        {
            if(g_options.m_options[i] == &g_options.view_credits && !GameMenu)
                continue;

            // previously banned access to advanced menu during gameplay
            // if(g_options.m_options[i] == &g_options.advanced && !GameMenu)
            //     continue;

            if(g_options.m_options[i] == &g_options.episode_options && (GameMenu || BattleMode))
                continue;

            if(g_options.m_options[i] == &g_options.compat && !g_CheatEditYourFriends)
                continue;

            if(g_options.m_options[i]->m_scope & current_scope)
                visible_items.push_back(i);
        }
    }
    else
    {
        bool last_was_subsection = false;

        auto it = std::find(section_header_indexes.begin(), section_header_indexes.end(), section_index);
        if(it == section_header_indexes.end() || it + 1 == section_header_indexes.end())
            next_section_index = g_config.m_options.size();
        else
            next_section_index = *(it + 1);

        for(size_t i = section_index + 1; i < next_section_index; i++)
        {
            if(g_options.m_options[i] == &g_options.enable_last_warp_hub_resume && !NoMap)
                continue;

            if(g_CheatEditYourFriends || g_options.m_options[i]->m_scope & current_scope)
            {
                bool this_is_subsection = g_options.m_options[i] != &g_options.reset_all && dynamic_cast<ConfigSubSection_t<false>*>(g_options.m_options[i]);

                if(last_was_subsection && this_is_subsection)
                    visible_items.resize(visible_items.size() - 1);

                visible_items.push_back(i);

                last_was_subsection = this_is_subsection;
            }
        }

        if(last_was_subsection)
            visible_items.resize(visible_items.size() - 1);
    }
}

// checks to see whether it is possible for a Left/Right/Do to be performed given the current cursor and resolve which exact option should be modified
inline BaseConfigOption_t<true>* PrepareAction(bool to_delete = false)
{
    if(cur_item >= visible_items.size())
        return nullptr;

    size_t i = visible_items[cur_item];
    if(i >= next_section_index)
        return nullptr;

    // ban changing speedrun mode
    if(g_config.m_options[i] == &g_config.speedrun_mode)
        return nullptr;

    // is it one of the other unique episode config options?
    bool is_ep_config = (g_config.m_options[i] == &g_config.creator_compat) || (g_config.m_options[i] == &g_config.playstyle) || (g_config.m_options[i] == &g_config.enable_last_warp_hub_resume);

    // check some info about the option
    ConfigSetLevel prev_level = g_config.m_options[i]->m_set;
    bool use_cheat = g_CheatEditYourFriends && ((g_options.m_options[i]->m_scope & g_config_game_user.m_scope) == 0 || prev_level > ConfigSetLevel::user_config);
    bool was_debug = (!use_cheat && prev_level == ConfigSetLevel::cheat) || (prev_level == ConfigSetLevel::debug);

    // level that will be set
    ConfigSetLevel target_level = (is_ep_config) ? ConfigSetLevel::ep_config
        : ((use_cheat) ? ConfigSetLevel::cheat
            : ConfigSetLevel::user_config);

    if(prev_level > target_level && !was_debug)
        return nullptr;

    if(!(is_ep_config || use_cheat) && (g_options.m_options[i]->m_scope & g_config_game_user.m_scope) == 0)
        return nullptr;

    BaseConfigOption_t<true>* opt = (is_ep_config || use_cheat) ? g_config.m_options[i] : g_config_game_user.m_options[i];

    // if not currently active, set from previous level
    if(!opt->is_set() || (was_debug && !to_delete))
    {
        opt->m_set = ConfigSetLevel::unset;

        if(g_config.m_options[i]->is_set() && !(s_deferred_changes() && to_delete))
            opt->update_from(*g_config.m_options[i], ConfigSetLevel::set);
        else
            opt->set_from_default(ConfigSetLevel::set);

        opt->m_set = ConfigSetLevel::unset;
    }

    if(was_debug)
    {
        pLogDebug("Unsetting debug / cheat option [%s]", g_options.m_options[i]->m_internal_name);

        g_config.m_options[i]->unset();
        s_change_item();

        // consider this the deleted option
        if(to_delete)
        {
            PlaySoundMenu(SFX_PlayerShrink);
            return nullptr;
        }
    }

    if(is_ep_config || use_cheat)
        opt->m_set = target_level;

    return opt;
}

void Do()
{
    if(cur_item >= visible_items.size())
        return;

    size_t real_item = visible_items[cur_item];

    if(real_item >= g_config.m_options.size())
        return;

    if(g_config.m_options[real_item] == &g_config.reset_all)
    {
        s_reset_friends();
    }
    else if(dynamic_cast<ConfigSection_t<true>*>(g_config.m_options[real_item]))
    {
        if(g_config.m_options[real_item] == &g_config.controls)
        {
            PlaySoundMenu(SFX_Do);

            global_dirty = true;
            MenuMode = MENU_INPUT_SETTINGS;
            MenuCursor = 0;
            MenuCursorCanMove = false;
            controls_ready = false;
            return;
        }
        else if(g_config.m_options[real_item] == &g_config.view_credits && GameMenu)
        {
            controls_ready = false;

            PlaySoundMenu(SFX_Do);
            GameMenu = false;
            GameOutro = true;

            // these is here only to prevent the screen from looking strange
            SetupCredits();
            return;
        }

        section_index = real_item;

        RefreshVisibleItems();

        if(visible_items.size() == 0)
        {
            PlaySoundMenu(SFX_BlockHit);
            section_index = SECTION_NONE;
            RefreshVisibleItems();
        }
        else
        {
            cur_item = 0;
            s_switch_item();
            while(is_subsection(cur_item) && cur_item + 1 < visible_items.size())
                cur_item++;

            cur_scroll = 0;

            PlaySoundMenu(SFX_Do);
        }
    }
    else
    {
        BaseConfigOption_t<true>* opt = PrepareAction();

        if(opt && opt->change())
        {
            s_change_item();
            PlaySoundMenu(SFX_Do);
        }
        else
        {
            PlaySoundMenu(SFX_BlockHit);
        }
    }
}

void RotateLeft()
{
    if(section_index == SECTION_NONE)
        return;

    BaseConfigOption_t<true>* opt = PrepareAction();

    if(opt && opt->rotate_left())
    {
        s_change_item();
        PlaySoundMenu(SFX_Do);
    }
    else
    {
        PlaySoundMenu(SFX_BlockHit);
    }
}

void RotateRight()
{
    if(section_index == SECTION_NONE)
        return;

    BaseConfigOption_t<true>* opt = PrepareAction();

    if(opt && opt->rotate_right())
    {
        s_change_item();
        PlaySoundMenu(SFX_Do);
    }
    else
    {
        PlaySoundMenu(SFX_BlockHit);
    }
}

void Delete()
{
    if(section_index == SECTION_NONE)
        return;

    BaseConfigOption_t<true>* opt = PrepareAction(true);

    if(opt && opt->is_set() && opt != &g_config.playstyle && opt != &g_config.creator_compat)
    {
        // restore to default internally -- this helps when directly displaying g_config_game_user items
        opt->set_from_default(ConfigSetLevel::set);
        opt->unset();
        s_change_item();
        PlaySoundMenu(SFX_PlayerShrink);
    }
    else
    {
        PlaySoundMenu(SFX_BlockHit);
    }
}

bool Back();

void Select()
{
    if(s_deferred_changes())
    {
        UpdateConfig();
        PlaySoundMenu(SFX_PSwitch);
    }
}

bool Back()
{
    PlaySoundMenu(SFX_Slide);

    if(g_CheatEditYourFriends == 2)
    {
        // return to game directly from first trip to edit your friends screen
        g_CheatEditYourFriends = 1;
        s_check_friends_edited();
        global_dirty = false;
        return true;
    }
    else if(section_index == SECTION_NONE)
    {
        pLogDebug("Saving config on options screen exit (config path [%s], dirty %d)",
            AppPathManager::settingsFileSTD().c_str(), (int)global_dirty);

        // save any dirty configs
        if(global_dirty)
            SaveConfig();

        return true;
    }
    else
    {
        if(s_deferred_changes())
            UpdateConfig();

        if(section_index < g_config.m_options.size() && g_config.m_options[section_index] == &g_config.compat)
            s_check_friends_edited();

        s_switch_item();

        int last_section = section_index;

        section_index = SECTION_NONE;
        cur_scroll = 0;
        RefreshVisibleItems();

        auto it = std::find(visible_items.begin(), visible_items.end(), last_section);

        // go to last item if couldn't find
        if(it == visible_items.end() && it != visible_items.begin())
            cur_item = (int)((visible_items.end() - 1) - visible_items.begin());
        else
            cur_item = (int)(it - visible_items.begin());
    }

    return false;
}

static inline void Render_Cursor(int x, int y, int p)
{
    XRender::renderTextureBasic(x, y, GFX.MCursor[0]);

    UNUSED(p);
}

bool Mouse_Render(bool mouse, bool render)
{
    if(mouse && !render && !SharedCursor.Move && !SharedCursor.Primary && !SharedCursor.Secondary && !SharedCursor.ScrollUp && !SharedCursor.ScrollDown)
    {
        if(!GameMenu)
            MenuMouseRelease = true;

        // subtract from the mouse scroll cooldown
        if(mouse_scroll_cooldown > 0)
            mouse_scroll_cooldown--;
    }

    // want 680px width.
    int width;
    if(XRender::TargetW < 640)
        width = XRender::TargetW - 16 - XRender::TargetOverscanX * 2;
    else if(XRender::TargetW < 720)
        width = XRender::TargetW - 40 - XRender::TargetOverscanX * 2;
    else
        width = 680;

    const bool tight_mode = width < 640 || XRender::TargetH < 480;

    // calculate line height: want 15 lines of text
    int line = (XRender::TargetH - 60) / 15;
    line -= line & 1;
    // max line height 30
    if(line > 30)
        line = 30;

    // check for Chinese and Korean languages
    int min_line_size = FontManager::getMetricsValue(FontManager::Metrics_MenuMinLineHeight, CurrentLanguage);

    // (it's okay if we don't get 15 lines, but we need at least 18px per line.)
    int max_line = 15;
    if(line < min_line_size)
    {
        line = min_line_size;
        max_line = (int)XRender::TargetH / line;

        // fix some strange offscreen issues
        if(min_line_size > 18)
            max_line--;
    }

    // two header rows, two footer rows
    const int first_display_row = 2;
    const int display_rows = max_line - 4;

    // calculate main column and value column width
    const int total_width = tight_mode ? width - 32 : width - 64;
    const int main_width  = total_width * 3 / 4 - 16;
    const int value_width = total_width * 1 / 4;

    // horizontal start of the menu
    int sX = XRender::TargetW / 2 - width / 2;
    sX -= sX & 1;
    // vertical start of the menu
    int sY = XRender::TargetH / 2 - (line * max_line) / 2;
    sY -= sY & 1;

    int cursor_x = tight_mode ? sX + 8 : sX + 24;

    size_t num_items = get_num_items();

    // mouse logic
    if(mouse)
    {
        if(SharedCursor.ScrollUp)
        {
            if(cur_scroll > 0)
            {
                PlaySoundMenu(SFX_Saw);
                cur_scroll--;
                if(cur_item >= display_rows + cur_scroll - 1)
                {
                    cur_item--;
                    s_switch_item();
                }
            }
        }
        else if(SharedCursor.ScrollDown)
        {
            if(cur_scroll + display_rows < num_items)
            {
                PlaySoundMenu(SFX_Saw);
                cur_scroll++;

                if(cur_item < cur_scroll + 1)
                {
                    cur_item++;
                    s_switch_item();
                }
            }
        }

        if(SharedCursor.X < sX || SharedCursor.X >= sX + width / 2)
            return false;

        int cur_mouse_line = ((int)SharedCursor.Y - sY) / line;
        int cur_mouse_item = cur_scroll + cur_mouse_line - first_display_row;

        if(SharedCursor.Primary && cur_mouse_item == (int)cur_item && MenuMouseRelease)
        {
#ifdef KEYBOARD_H
            Controls::g_cancelDoubleClick = true;
#endif
            MenuMouseRelease = false;
            Do();
        }
        else if(SharedCursor.Secondary && MenuMouseRelease)
        {
            MenuMouseRelease = false;
            return Back();
        }
        else if(cur_mouse_item != (int)cur_item
            && cur_mouse_line >= first_display_row
            && cur_mouse_line < first_display_row + display_rows
            && cur_mouse_item >= 0
            && cur_mouse_item < (int)num_items)
        {
            if(cur_mouse_line == first_display_row || cur_mouse_line == first_display_row + display_rows - 1)
            {
                if(mouse_scroll_cooldown > 0 || (mouse_scroll_cooldown == -1 && !SharedCursor.Move))
                    return false;
                else
                    mouse_scroll_cooldown = 11;
            }
            else if(!SharedCursor.Move)
                return false;

            if(is_subsection(cur_mouse_item))
            {
                if(cur_mouse_line == first_display_row && cur_scroll > 0)
                {
                    PlaySoundMenu(SFX_Saw);
                    cur_scroll--;
                    if(cur_item >= display_rows + cur_scroll - 1)
                    {
                        cur_item--;
                        s_switch_item();
                    }
                }
                else if(cur_mouse_line == first_display_row + display_rows - 1 && cur_scroll + display_rows < num_items)
                {
                    PlaySoundMenu(SFX_Saw);
                    cur_scroll++;

                    if(cur_item < cur_scroll + 1)
                    {
                        cur_item++;
                        s_switch_item();
                    }
                }
                else
                {
                    return false;
                }
            }

            cur_item = (size_t)cur_mouse_item;
            s_switch_item();
            if(!SharedCursor.ScrollUp && !SharedCursor.ScrollDown)
                PlaySoundMenu(SFX_Slide);
        }

        if(SharedCursor.Primary)
            MenuMouseRelease = false;

        return false;
    }

    // render logic

    // render the background
    DrawSimpleFrame(sX, sY - (line - 18) - 4, width, line * max_line + (line - 18) + 8, {0, 0, 0, 127}, {255, 255, 255, 127}, {0, 0, 0, 127});

    // render the title
    if(section_index != SECTION_NONE && section_index < g_config.m_options.size())
        g_config.m_options[section_index]->get_display_name(s_temp_string);
    else
        s_temp_string = g_mainMenu.mainOptions;

    SuperPrintScreenCenter(s_temp_string, 3, sY);

    // locate the cursor
    int cur_item_row = cur_item - cur_scroll;

    // handle forced scrolling
    if(cur_item_row < 1 && cur_scroll > 0)
    {
        cur_scroll--;
        cur_item_row++;
    }
    else if(cur_item_row >= display_rows - 1 && cur_scroll + display_rows < num_items)
    {
        cur_scroll++;
        cur_item_row--;
    }

    // render the cursor
    if(cur_item_row >= 0 && cur_item_row < display_rows)
        Render_Cursor(cursor_x, sY + (cur_item_row + first_display_row) * line, 0);

    // render the scroll indicators
    if(cur_scroll > 0)
        XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[1].w / 2, sY + first_display_row * line - GFX.MCursor[1].h, GFX.MCursor[1]);

    if(cur_scroll + display_rows < num_items)
        XRender::renderTextureBasic(sX + width / 2 - GFX.MCursor[2].w / 2, sY + (first_display_row + display_rows) * line - line + 18, GFX.MCursor[2]);

    MarqueeSpec name_marquee_spec = MarqueeSpec(0, 10, 64, 32, -1);
    MarqueeSpec value_marquee_spec = MarqueeSpec(value_width, 10, 64, 32, 1);

    // render the options
    for(size_t i = cur_scroll; i < cur_scroll + display_rows && i < num_items; i++)
    {
        BaseConfigOption_t<true>* opt = g_config.m_options[visible_items[i]];

        if(s_deferred_changes())
        {
            BaseConfigOption_t<true>* user_opt = g_config_game_user.m_options[visible_items[i]];
            if(user_opt->m_set != ConfigSetLevel::unset || opt->m_set == ConfigSetLevel::user_config)
                opt = user_opt;
        }

        bool is_header = is_subsection(i);

        // for subsection headers, indent to left and allow to fill screen
        int lX = is_header ? cursor_x : cursor_x + 24;
        XTColor name_color = is_header ? XTColorF(0.7_n, 0.7_n, 0.7_n) : XTColor();
        int name_font = is_header ? 3 : 5;

        name_marquee_spec.marquee_width = is_header ? total_width : main_width;

        if(tight_mode && i != cur_item)
            name_color = name_color * XTColor::from_num(0.6_n);

        if(opt == &g_config.compat || opt == &g_config.reset_all)
            name_color.g = 0;

        // display name
        opt->get_display_name(s_temp_string);

        MarqueeState null_marquee;

        SuperPrintMarquee(s_temp_string, name_font,
            lX, sY + (i - cur_scroll + first_display_row) * line,
            name_marquee_spec, (i == cur_item) ? name_marquee : null_marquee,
            name_color);

        if(i == cur_item)
            name_marquee.advance(name_marquee_spec);

        if(is_header)
            continue;

        // display value
        null_marquee = MarqueeState();

        opt->get_display_value(s_temp_string);

        // pick the appropriate tint based on the setting level
        XTColor vcolor;
        switch(opt->m_set)
        {
        case(ConfigSetLevel::debug):
        case(ConfigSetLevel::script):
        case(ConfigSetLevel::cheat):
            vcolor = XTColorF(1.0_n, 0.0_n, 1.0_n, 1.0_n);
            break;
        case(ConfigSetLevel::compat):
        case(ConfigSetLevel::speedrun):
            vcolor = XTColorF(0.7_n, 0.5_n, 0.2_n, 1.0_n);
            break;
        case(ConfigSetLevel::cmdline):
            vcolor = XTColorF(0.0_n, 0.5_n, 1.0_n, 1.0_n);
            break;
        case(ConfigSetLevel::file_compat):
        case(ConfigSetLevel::ep_compat):
            vcolor = XTColorF(1.0_n, 1.0_n, 0.0_n, 1.0_n);
            break;
        default:
        case(ConfigSetLevel::user_config):
            if(s_temp_string == "✓" || s_temp_string == "+")
                vcolor = XTColorF(0.5_n, 1.0_n, 0.5_n, 1.0_n);
            else if(s_temp_string == "×" || s_temp_string == "-")
                vcolor = XTColorF(1.0_n, 0.5_n, 0.5_n, 1.0_n);
            else
                vcolor = XTColorF(1.0_n, 1.0_n, 1.0_n, 1.0_n);
            break;
        case(ConfigSetLevel::game_info):
        case(ConfigSetLevel::game_defaults):
        case(ConfigSetLevel::bugfix_defaults):
            if(s_temp_string == "✓" || s_temp_string == "+")
                vcolor = XTColorF(0.25_n, 0.5_n, 0.25_n, 1.0_n);
            else if(s_temp_string == "×" || s_temp_string == "-")
                vcolor = XTColorF(0.5_n, 0.25_n, 0.25_n, 1.0_n);
            else
                vcolor = XTColorF(0.5_n, 0.5_n, 0.5_n, 1.0_n);
            break;
        }

        if(s_deferred_changes())
        {
            const BaseConfigOption_t<true>* main_opt = g_config.m_options[visible_items[i]];
            if(!(*opt == *main_opt))
                vcolor = XTColor(240, 255, 32);
            else
            {
                auto* opt_impl = dynamic_cast<ConfigSetupEnum_t<true>*>(opt);
                const auto* main_opt_impl = dynamic_cast<const ConfigSetupEnum_t<true>*>(main_opt);

                // provide value for "Auto" from main option
                if(opt_impl && main_opt_impl && opt_impl != main_opt_impl)
                {
                    if(main_opt_impl->m_value == 0)
                        opt_impl->obtained = main_opt_impl->obtained;
                    else
                        opt_impl->obtained = 0;
                }

                if(main_opt_impl && main_opt_impl->m_value != 0 && main_opt_impl->m_value != main_opt_impl->obtained)
                    vcolor = XTColor(192, 96, 96);
            }
        }

        if(tight_mode && i != cur_item)
            vcolor = vcolor * XTColor::from_num(0.6_n);

        const int rX = tight_mode ? sX + width - 8 : sX + width - 16;
        // SuperPrintRightAlign(s_temp_string, 3, rX, sY + (i - cur_scroll + first_display_row) * line, vr, vg, vb, va * name_opacity);

        SuperPrintMarquee(s_temp_string, name_font,
            rX - value_width, sY + (i - cur_scroll + first_display_row) * line,
            value_marquee_spec, (i == cur_item) ? value_marquee : null_marquee,
            vcolor);

        if(i == cur_item)
            value_marquee.advance(value_marquee_spec);
    }

    // render the tooltips
    if(cur_item < visible_items.size())
    {
        MarqueeSpec tooltip_marquee_spec = MarqueeSpec(total_width, 10, 64, 32, 0);
        int tooltip_left = sX + (width - total_width) / 2;

        BaseConfigOption_t<true>* opt = g_config.m_options[visible_items[cur_item]];

        if(cur_item_changed && !opt->get_value_tooltip(s_temp_string).empty())
        {
            value_tooltip_marquee.advance(tooltip_marquee_spec);
            SuperPrintMarquee(s_temp_string, 5, tooltip_left, sY + (first_display_row + display_rows + 1) * line, tooltip_marquee_spec, value_tooltip_marquee);
        }
        else if(!opt->get_tooltip(s_temp_string).empty())
        {
            name_tooltip_marquee.advance(tooltip_marquee_spec);
            SuperPrintMarquee(s_temp_string, 5, tooltip_left, sY + (first_display_row + display_rows + 1) * line, tooltip_marquee_spec, name_tooltip_marquee);
        }
    }

    return false;
}

void Render()
{
    // only relevant when launched from game
    if(MenuMode == MENU_INPUT_SETTINGS)
        return menuControls_Render();

    Mouse_Render(false, true);
}

bool Logic()
{
    size_t num_items = get_num_items();

    MenuControls_t menuControls = Controls::GetMenuControls();

    // IMPORTANT: delegate to MENU_INPUT_SETTINGS. Only relevant when launched from game.
    if(MenuMode == MENU_INPUT_SETTINGS)
    {
        if(!menuControls.Up && !menuControls.Down && !menuControls.Left && !menuControls.Right && !menuControls.Do && !menuControls.Back && !menuControls.Erase && !menuControls.Home)
            MenuCursorCanMove = true;

        if(MenuCursorCanMove && menuControls.Up)
        {
            PlaySoundMenu(SFX_Slide);
            MenuCursor--;
            MenuCursorCanMove = false;
        }

        if(MenuCursorCanMove && menuControls.Down)
        {
            PlaySoundMenu(SFX_Slide);
            MenuCursor++;
            MenuCursorCanMove = false;
        }

        if(!SharedCursor.Primary && !SharedCursor.Secondary)
            MenuMouseRelease = true;

        if(menuControls_Logic() == -1)
        {
            Controls::SaveConfig();
            MenuMode = MENU_NEW_OPTIONS;
            MenuMouseRelease = false;
            controls_ready = false;
        }
        return false;
    }


    if(!menuControls.Up && !menuControls.Down && !menuControls.Left && !menuControls.Right && !menuControls.Do && !menuControls.Back && !menuControls.Erase && !menuControls.Home)
        controls_ready = true;
    else
        mouse_scroll_cooldown = -1;

    if(controls_ready && menuControls.Back)
    {
        controls_ready = false;

        if(Back())
        {
            MenuCursorCanMove = false;
            MenuMouseRelease = false;
            return true;
        }
    }

    if(controls_ready && menuControls.Do)
    {
        controls_ready = false;
        Do();
    }

    if(controls_ready && menuControls.Left)
    {
        controls_ready = false;
        RotateLeft();
    }

    if(controls_ready && menuControls.Right)
    {
        controls_ready = false;
        RotateRight();
    }

    if(controls_ready && menuControls.Erase)
    {
        controls_ready = false;
        Delete();
    }

    if(controls_ready && menuControls.Home)
    {
        controls_ready = false;
        Select();
    }

    if(controls_ready && menuControls.Up)
    {
        controls_ready = false;
        if(cur_item == 0)
            cur_item = num_items;
        cur_item--;

        if(is_subsection(cur_item))
        {
            if(cur_item == 0)
                cur_item = num_items;
            cur_item--;
        }

        s_switch_item();
        PlaySoundMenu(SFX_Slide);
    }

    if(controls_ready && menuControls.Down)
    {
        controls_ready = false;
        cur_item++;
        if(cur_item == num_items)
            cur_item = 0;

        if(is_subsection(cur_item))
        {
            cur_item++;
            if(cur_item == num_items)
                cur_item = 0;
        }

        s_switch_item();
        PlaySoundMenu(SFX_Slide);
    }

    return Mouse_Render(true, false);
}

} // namespace OptionsScreen


================================================
FILE: src/main/screen_options.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef SCREEN_OPTIONS_H

#define SCREEN_OPTIONS_H

namespace OptionsScreen
{

void Init();

void Render();

// if returns true, user has exited the screen
bool Logic();

void ResetStrings();

} // namespace OptionsScreen

#endif // SCREEN_OPTIONS_H


================================================
FILE: src/main/screen_pause.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <vector>
#include <string>

#ifdef THEXTECH_INTERPROC_SUPPORTED
#include <InterProcess/intproc.h>
#endif // #ifdef THEXTECH_INTERPROC_SUPPORTED

#ifdef THEXTECH_ENABLE_SDL_NET
#include "main/client_methods.h"
#endif

#include <Logger/logger.h>

#include "../globals.h"

#include "../player.h"
#include "../sound.h"
#include "../gfx.h"
#include "../graphics.h"
#include "../frm_main.h"
#include "../config.h"
#include "../core/render.h"
#include "../core/events.h"

#include "../game_main.h"
#include "menu_main.h"
#include "main/screen_pause.h"
#include "main/screen_textentry.h"
#include "main/screen_connect.h"
#include "speedrunner.h"
#include "cheat_code.h"
#include "message.h"

#include "main/game_strings.h"
#include "main/level_medals.h"
#include "main/hints.h"

#include "controls.h"

#include "editor.h"

namespace PauseScreen
{

struct MenuItem
{
    std::string name;
    bool (*callback)();
    bool is_private;
    MenuItem(const std::string &n, bool(*cb)(), bool p = false) : name(n), callback(cb), is_private(p) {}
};

enum class PauseType
{
    Modern,
    Testing,
    Legacy,
};

static PauseType s_pause_type = PauseType::Modern;
static int s_pause_plr = 0;
static int s_longest_width = 0;
static std::vector<MenuItem> s_items;
static int s_cheat_menu_bits = 0;
static uint32_t s_cheat_menu_frame = 0;
static std::array<bool, maxLocalPlayers> s_leftright_release;

uint8_t g_pending_action = 255;
static bool s_force_exit = false;

static void s_push_unpause()
{
    XMessage::Message unpause;
    unpause.type = XMessage::Type::menu_action;
    unpause.message = 0;
    XMessage::PushMessage(unpause);
}

static bool s_Continue()
{
    PlaySound(SFX_Pause);
    return true;
}

static bool s_RestartLevel()
{
    MenuMode = MENU_INTRO;
    MenuCursor = 0;
    XRender::setTargetTexture();
    XRender::clearBuffer();
    XRender::repaint();
    EndLevel = true;
    LevelBeatCode = BEATCODE_RESTART;
    StopMusic();
    XEvents::doEvents();
    return true;
}

static bool s_ResetCheckpoints()
{
    pLogDebug("Clear check-points from a menu");
    Checkpoint.clear();
    CheckpointsList.clear();
    g_curLevelMedals.reset_checkpoint();
    numStars = 0;
    Star.clear();
#ifdef THEXTECH_INTERPROC_SUPPORTED
    IntProc::sendStarsNumber(numStars);
#endif
    // numSavedEvents = 0;
    // BlockSwitch.fill(false);
    PlaySound(SFX_Bullet);
    return true;
}

static bool s_DropAddScreen()
{
    // don't allow Drop / Add screen in clone mode
    if(g_ClonedPlayerMode || SingleCoop)
    {
        PlaySoundMenu(SFX_BlockHit);
        return false;
    }

    PlaySound(SFX_Do);

    PauseInit(PauseCode::DropAdd, 0);

    return false;
}


static void s_OptionsScreen_Resume();

static bool s_OptionsScreen()
{
    PlaySound(SFX_Do);

    PauseInit(PauseCode::Options, 0, s_OptionsScreen_Resume);

    return false;
}

static void s_OptionsScreen_Resume()
{
    // re-initialize / re-translate pause menu
    SoundPause[SFX_Pause] = 1;
    Init(s_pause_plr, s_pause_type == PauseType::Legacy);

    // set MenuCursor correctly
    for(size_t i = 0; i < s_items.size(); i++)
    {
        if(s_items[i].callback == s_OptionsScreen)
        {
            MenuCursor = i;
            break;
        }
    }
}

static void s_CheatScreen_callback()
{
    cheats_setBuffer(TextEntryScreen::Text, false);

    // comment this if you want to return to the pause menu
    s_push_unpause();
}

static bool s_CheatScreen()
{
    TextEntryScreen::Init(g_gameStrings.pauseItemEnterCode, s_CheatScreen_callback);

    return true;
}

static bool s_QuitTesting()
{
    MenuMode = MENU_INTRO;
    MenuCursor = 0;
    XRender::setTargetTexture();
    XRender::clearBuffer();
    XRender::repaint();
    EndLevel = true;
    LevelBeatCode = BEATCODE_QUIT;
    StopMusic();
    XEvents::doEvents();

    if(Backup_FullFileName.empty())
    {
        GameIsActive = false; // Quit the game entirely
    }

    return true;
}

static bool s_SaveAndContinue()
{
    bool CanSave = (LevelSelect || IsHubLevel) && !Cheater;

    if(CanSave)
    {
        SaveGame();
        PlaySound(SFX_Checkpoint);
    }
    else
    {
        // player tried to cheat, scare them
        PlaySound(SFX_VillainKilled);
    }

    return true;
}

static bool s_Quit()
{
#ifdef THEXTECH_ENABLE_SDL_NET
    XMessage::Disconnect();
    s_force_exit = true;
#endif

    bool CanSave = (LevelSelect || IsHubLevel) && !Cheater;

    if(CanSave)
        SaveGame(); // "Save & Quit"
    else
        speedRun_saveStats();

    ConnectScreen::SaveChars();

    s_cheat_menu_bits = 0;
    GameMenu = true;

    MenuMode = MENU_INTRO;
    MenuCursor = 0;

    if(!LevelSelect)
    {
        LevelSelect = true;
        EndLevel = true;
    }
    else
        LevelSelect = false;

    XRender::setTargetTexture();
    XRender::clearBuffer();
    XRender::repaint();
    StopMusic();
    XEvents::doEvents();

    return true;
}

void UnlockCheats()
{
    s_cheat_menu_bits = 15;
    s_cheat_menu_frame = CommonFrame;

    if(GamePaused == PauseCode::PauseScreen)
        TextEntryScreen::Init(g_gameStrings.pauseItemEnterCode, s_CheatScreen_callback);
}

void Init(int plr, bool LegacyPause)
{
    XHints::Select();

    PlaySound(SFX_Pause);
    MenuCursor = 0;
    MenuCursorCanMove = false;
    MenuCursorCanMove_Back = false;
    g_pending_action = 255;
    s_force_exit = false;

    if(LegacyPause)
        s_pause_type = PauseType::Legacy;
    else if(TestLevel)
        s_pause_type = PauseType::Testing;
    else
        s_pause_type = PauseType::Modern;

    s_pause_plr = plr;
    if(s_cheat_menu_bits < 14)
        s_cheat_menu_bits = 0;

    s_leftright_release.fill(false);

    // do a context-aware initialization of s_items
    s_items.clear();

    bool CanSave = (LevelSelect || IsHubLevel) && !Cheater && !TestLevel;

    // add pause menu items

    // level test
    if(s_pause_type == PauseType::Testing)
    {
        bool inter_screen = (LevelBeatCode <= BEATCODE_RESTART);
        bool start_screen = (LevelBeatCode == BEATCODE_SETUP);
        bool editor_test = !Backup_FullFileName.empty();

        if(!inter_screen)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemContinue, s_Continue});

        s_items.push_back(MenuItem{start_screen ? g_gameStrings.pauseItemContinue : g_gameStrings.pauseItemRestartLevel, s_RestartLevel});

        if(!start_screen && !BattleMode)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemResetCheckpoints, s_ResetCheckpoints});

        if(g_config.allow_drop_add)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemPlayerSetup, s_DropAddScreen, true});

        if(!inter_screen && s_cheat_menu_bits >= 14 && !BattleMode)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemEnterCode, s_CheatScreen, true});

        s_items.push_back(MenuItem{g_mainMenu.mainOptions, s_OptionsScreen, true});

        s_items.push_back(MenuItem{editor_test ? g_gameStrings.pauseItemReturnToEditor : g_gameStrings.pauseItemQuitTesting, s_QuitTesting});
    }
#ifdef THEXTECH_ENABLE_SDL_NET
    // NetPlay pause
    else if(XMessage::GetStatus() != XMessage::Status::local)
    {
        s_items.push_back(MenuItem{g_gameStrings.pauseItemContinue, s_Continue});

        if(g_config.allow_drop_add && s_pause_type != PauseType::Legacy)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemPlayerSetup, s_DropAddScreen, true});

        if(s_cheat_menu_bits >= 14 && s_pause_type != PauseType::Legacy && !BattleMode)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemEnterCode, s_CheatScreen, true});

        if(s_pause_type != PauseType::Legacy)
            s_items.push_back(MenuItem{g_mainMenu.mainOptions, s_OptionsScreen, true});

        s_items.push_back(MenuItem{g_mainMenu.netplayLeaveRoom, s_Quit, true});
    }
#endif
    // main game pause
    else
    {
        s_items.push_back(MenuItem{g_gameStrings.pauseItemContinue, s_Continue});

        if(g_config.allow_drop_add && s_pause_type != PauseType::Legacy)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemPlayerSetup, s_DropAddScreen, true});

        if(s_cheat_menu_bits >= 14 && s_pause_type != PauseType::Legacy && !BattleMode)
            s_items.push_back(MenuItem{g_gameStrings.pauseItemEnterCode, s_CheatScreen, true});

        if(s_pause_type != PauseType::Legacy)
            s_items.push_back(MenuItem{g_mainMenu.mainOptions, s_OptionsScreen, true});

        if(CanSave)
        {
            s_items.push_back(MenuItem{g_gameStrings.pauseItemSaveAndContinue, s_SaveAndContinue});
            s_items.push_back(MenuItem{g_gameStrings.pauseItemSaveAndQuit, s_Quit});
        }
        else
        {
            s_items.push_back(MenuItem{g_gameStrings.pauseItemQuit, TestLevel ? s_QuitTesting : s_Quit});
        }
    }

    const int font = (s_pause_type == PauseType::Legacy) ? 3 : 4;

    // set the longest width
    s_longest_width = 0;

    for(size_t i = 0; i < s_items.size(); i++)
    {
        int item_width = SuperTextPixLen(s_items[i].name, font);
        if(item_width > s_longest_width)
            s_longest_width = item_width;
    }

    int total_menu_height = (int)s_items.size() * 36 - 18;
    int total_menu_width = s_longest_width + 40;

    // GBA bounds
    if(total_menu_height > 320 || total_menu_width > 480)
        pLogWarning("Menu doesn't fit within bounds (actual size %dx%d, bounds 480x320)", total_menu_width, total_menu_height);

    // force cheat entry if needed
    if(s_cheat_menu_bits == 15)
    {
        s_cheat_menu_bits = 14;
        if(CommonFrame - s_cheat_menu_frame < 60)
            TextEntryScreen::Init(g_gameStrings.pauseItemEnterCode, s_CheatScreen_callback);
    }
}

void Render()
{
    // height includes intermediate padding but no top/bottom padding
    // width includes cursor on left and 20px padding on right for symmetry
    int total_menu_height = (int)s_items.size() * 36 - 18;
    int total_menu_width = s_longest_width + 40;

    // enforce GBA bounds (480x320)
    if(total_menu_height > 320)
        total_menu_height = 320;

    if(total_menu_width > 480)
        total_menu_width = 480;

    int menu_box_height = 200;
    int menu_box_width = 380;

    if(menu_box_height - total_menu_height < 18)
        menu_box_height = total_menu_height + 18;

    if(menu_box_width - total_menu_width < 32)
        menu_box_width = total_menu_width + 32;

    int menu_left_X = XRender::TargetW / 2 - total_menu_width / 2 + 20;
    int menu_top_Y = XRender::TargetH / 2 - total_menu_height / 2;

    // display room info above the pause menu
#ifdef THEXTECH_ENABLE_SDL_NET
    if(XMessage::GetStatus() == XMessage::Status::connected)
    {
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2 - 4, XRender::TargetH / 2 - menu_box_height / 2 - 40 - 4, menu_box_width + 8, 28 + 8, {0, 0, 0});
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2 - 2, XRender::TargetH / 2 - menu_box_height / 2 - 40 - 2, menu_box_width + 4, 28 + 4, {255, 255, 255});
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2, XRender::TargetH / 2 - menu_box_height / 2 - 40, menu_box_width, 28, {8, 96, 168});

        SuperPrintScreenCenter(g_mainMenu.netplayRoomKey + ' ' + XMessage::DisplayRoom(XMessage::CurrentRoom()).room_name, 5, XRender::TargetH / 2 - menu_box_height / 2 - 36);
    }
#endif // #ifdef THEXTECH_ENABLE_SDL_NET

    switch(s_pause_type)
    {
    case(PauseType::Legacy):
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2, XRender::TargetH / 2 - menu_box_height / 2, menu_box_width, menu_box_height, {0, 0, 0});
        break;
    case(PauseType::Modern):
    default:
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2 - 4, XRender::TargetH / 2 - menu_box_height / 2 - 4, menu_box_width + 8, menu_box_height + 8, {0, 0, 0});
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2 - 2, XRender::TargetH / 2 - menu_box_height / 2 - 2, menu_box_width + 4, menu_box_height + 4, {255, 255, 255});
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2, XRender::TargetH / 2 - menu_box_height / 2, menu_box_width, menu_box_height, {0, 0, 0});
        break;
    case(PauseType::Testing):
        XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2, XRender::TargetH / 2 - menu_box_height / 2, menu_box_width, menu_box_height, {0, 0, 0, 127});
        break;
    }

    if(s_pause_type == PauseType::Testing)
    {
        for(size_t i = 0; i < s_items.size(); i++)
        {
            XTColor color = ((int)i == MenuCursor) ? XTColor() : XTColor(127, 127, 127);

            SuperPrintScreenCenter(s_items[i].name, 5, menu_top_Y + (i * 36), color);
        }
    }
    else
    {
        const int font = (s_pause_type == PauseType::Legacy) ? 3 : 4;

        for(size_t i = 0; i < s_items.size(); i++)
            SuperPrint(s_items[i].name, font, menu_left_X, menu_top_Y + (i * 36));

        if(GFX.PCursor.inited)
        {
            if(s_pause_plr == 2 && s_pause_type != PauseType::Legacy)
                XRender::renderTextureBasic(menu_left_X - 20, menu_top_Y + (MenuCursor * 36), GFX.PCursor, {0, 255, 0});
            else if(s_pause_plr != 1 && s_pause_type != PauseType::Legacy)
                XRender::renderTextureBasic(menu_left_X - 20, menu_top_Y + (MenuCursor * 36), GFX.PCursor);
            else
                XRender::renderTextureBasic(menu_left_X - 20, menu_top_Y + (MenuCursor * 36), GFX.PCursor, {255, 0, 0});
        }
        else if(s_pause_plr == 2 && s_pause_type != PauseType::Legacy)
            XRender::renderTextureBasic(menu_left_X - 20, menu_top_Y + (MenuCursor * 36), 16, 16, GFX.MCursor[3], 0, 0);
        else
            XRender::renderTextureBasic(menu_left_X - 20, menu_top_Y + (MenuCursor * 36), 16, 16, GFX.MCursor[0], 0, 0);
    }

    if(XRender::TargetH > XRender::TargetH / 2 + menu_box_height / 2 + 16 + 96 + 8)
        XHints::Draw(XRender::TargetH / 2 + menu_box_height / 2 + 16, 100, menu_box_width);
}

void ControlsLogic()
{
    int plr = s_pause_plr;
    if(plr > numPlayers)
        plr = 0;

    if(!g_config.multiplayer_pause_controls && plr == 0)
        plr = 1;

    // there was previously code to copy all players' controls from the main player, but this is no longer necessary (and actively harmful in the SingleCoop case)

    MenuControls_t menuControls = Controls::GetMenuControls(plr);

    if(!MenuCursorCanMove_Back)
    {
        if(!menuControls.Back && MenuCursorCanMove)
            MenuCursorCanMove_Back = true;

        menuControls.Back = false;
    }
    else if(menuControls.Back)
        MenuCursorCanMove_Back = false;

    if(menuControls.Back && menuControls.Do)
        menuControls.Do = false;

    if(!MenuCursorCanMove)
    {
        if(!menuControls.Do && !menuControls.Back && !menuControls.Up && !menuControls.Down && (s_pause_type == PauseType::Legacy || (!menuControls.Left && !menuControls.Right)))
            MenuCursorCanMove = true;

        return;
    }

    if((s_pause_type == PauseType::Legacy || BattleMode) && s_cheat_menu_bits < 14)
        s_cheat_menu_bits = 0;

    int max_item = (int)s_items.size() - 1;

    if(menuControls.Back)
    {
        if(MenuCursor != max_item)
            PlaySound(SFX_Slide);

        MenuCursor = max_item;

        if(s_cheat_menu_bits < 14)
            s_cheat_menu_bits = 0;

        // fixes TheXTech 1.3.7-beta bug where hitting escape (bound to both Shared Back and P1 Do) would immediately exit
        MenuCursorCanMove = false;
    }
    else if(menuControls.Up)
    {
        PlaySound(SFX_Slide);
        MenuCursor = MenuCursor - 1;
        MenuCursorCanMove = false;

        if(s_cheat_menu_bits < 14)
            s_cheat_menu_bits = 0;
    }
    else if(menuControls.Down)
    {
        PlaySound(SFX_Slide);
        MenuCursor = MenuCursor + 1;
        MenuCursorCanMove = false;

        if(s_cheat_menu_bits < 14)
            s_cheat_menu_bits = 0;
    }
    else if(menuControls.Left && s_pause_type != PauseType::Legacy)
    {
        if(s_cheat_menu_bits == 0 || s_cheat_menu_bits == 2 || s_cheat_menu_bits == 5 || s_cheat_menu_bits == 9)
        {
            s_cheat_menu_bits++;
            MenuCursorCanMove = false;

            // don't swap char
            if(s_cheat_menu_bits >= 5)
            {
                PlaySound(SFX_Do);
                return;
            }
        }
        else if(s_cheat_menu_bits < 14)
            s_cheat_menu_bits = 1;
    }
    else if(menuControls.Right && s_pause_type != PauseType::Legacy)
    {
        if(s_cheat_menu_bits != 0 && s_cheat_menu_bits != 2 && s_cheat_menu_bits != 5 && s_cheat_menu_bits != 9 && s_cheat_menu_bits < 14)
        {
            s_cheat_menu_bits++;
            MenuCursorCanMove = false;

            // do cheat screen
            if(s_cheat_menu_bits == 14)
            {
                PlaySound(SFX_MedalGet);
                s_CheatScreen();
                return;
            }

            // don't swap char
            if(s_cheat_menu_bits >= 5)
            {
                PlaySound(SFX_Do);
                return;
            }
        }
        else if(s_cheat_menu_bits < 14)
            s_cheat_menu_bits = 0;
    }
    else if(menuControls.Do && s_cheat_menu_bits < 14)
        s_cheat_menu_bits = 0;

    if(MenuCursor < 0)
        MenuCursor = max_item;
    else if(MenuCursor > max_item)
        MenuCursor = 0;

    // special char change code
    if(SwapCharAllowed())
    {
        for(int plr_i = 0; plr_i < l_screen->player_count; plr_i++)
        {
            int A = l_screen->players[plr_i];

            if(!s_leftright_release[plr_i])
            {
                if(!Controls::g_RawControls[plr_i].Left && !Controls::g_RawControls[plr_i].Right)
                    s_leftright_release[plr_i] = true;
            }
            else if(Controls::g_RawControls[plr_i].Left || Controls::g_RawControls[plr_i].Right)
            {
                s_leftright_release[plr_i] = false;
                auto snd = SFX_BlockHit;

                if(!g_ClonedPlayerMode && Player[A].Effect == PLREFF_NORMAL)
                {
                    // replaced old character swap code with this new code,
                    // supporting arbitrary multiplayer and in-level swap.
                    int target = Player[A].Character;

                    // do the full wrap-around to find an acceptable target
                    for(int i = 0; i < 5; i++)
                    {
                        // move the target in the direction requested by the player
                        if(Controls::g_RawControls[plr_i].Left)
                        {
                            target --;

                            if(target <= 0)
                                target = 5;
                        }
                        else
                        {
                            target ++;

                            if(target > 5)
                                target = 1;
                        }

                        // immediately skip the target if it's blocked
                        if(blockCharacter[target])
                            continue;

                        // also skip the target if it's another player's character
                        bool already_used = false;

                        for(int B = 1; B <= numPlayers; B++)
                        {
                            if(B == A)
                                continue;

                            if(target == Player[B].Character)
                            {
                                already_used = true;
                                break;
                            }
                        }

                        if(already_used)
                            continue;

                        // otherwise we are good and can keep the target
                        break;
                    }

                    // if a suitable target found, swap character
                    if(target != Player[A].Character)
                    {
                        snd = SFX_Slide;
                        XMessage::PushMessage({XMessage::Type::char_swap, (uint8_t)plr_i, (uint8_t)target});
                    }
                }

                PlaySound(snd);
            }
        }
    }

    if(menuControls.Do && MenuCursor >= 0 && MenuCursor < (int)s_items.size())
    {
        if(s_items[MenuCursor].is_private)
            s_items[MenuCursor].callback();
        else
        {
            XMessage::Message menu_action;
            menu_action.type = XMessage::Type::menu_action;
            menu_action.message = MenuCursor;
            XMessage::PushMessage(menu_action);
        }
    }
}

bool Logic()
{
    if(s_force_exit)
    {
        s_force_exit = false;
        return true;
    }

    bool stopPause = false;

    if(g_pending_action < s_items.size() && !s_items[g_pending_action].is_private)
        stopPause = s_items[g_pending_action].callback();

    g_pending_action = 255;

    return stopPause;
}

} // namespace PauseScreen


================================================
FILE: src/main/screen_pause.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SCREEN_PAUSE_H
#define SCREEN_PAUSE_H

namespace PauseScreen
{

extern uint8_t g_pending_action;

void UnlockCheats();

void Init(int plr, bool LegacyPause);

void ControlsLogic();
bool Logic();
void Render();

} // namespace PauseScreen

#endif // #ifndef SCREEN_PAUSE_H


================================================
FILE: src/main/screen_progress.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif

#include <cstdint>
#include <string>

#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_timer.h"

#include "gfx.h"
#include "graphics.h" // SuperPrint

#include "core/render.h"
#include "core/events.h"

#include "main/game_strings.h"

static const uint32_t c_progress_screen_min_elapsed = 1000;
static const uint32_t c_progress_screen_tick_duration = 250;

void IndicateProgress(uint32_t start_time, num_t progress, const std::string& message)
{
#ifdef USE_RENDER_BLOCKING
    if(XRender::renderBlocked())
        return;
#endif

    bool progress_valid = (uint16_t(1024 * progress) > 0);

    if(progress > 1)
        progress = 1;

    uint32_t cur_time = SDL_GetTicks();
    uint32_t elapsed = cur_time - start_time;
    uint32_t total = progress_valid ? uint32_t(1024 * elapsed / uint16_t(1024 * progress)) : 0;

    if(elapsed < c_progress_screen_min_elapsed && total < c_progress_screen_min_elapsed)
        return;

    int load_coins_new = (elapsed / c_progress_screen_tick_duration) % 4;

    if(load_coins_new == LoadCoins)
        return;

    LoadCoins = load_coins_new;

    XRender::setTargetTexture();
    XRender::clearBuffer();

    SuperPrintScreenCenter(message.c_str(), 4,
               XRender::TargetH / 2 - 40,
               {255, 255, 0, 127});

    int time_y = XRender::TargetH / 2 - 20;

    // outline
    XRender::renderRect(XRender::TargetW / 4, time_y + 4, XRender::TargetW / 2, 32, {255, 255, 255});
    // empty progress
    XRender::renderRect(XRender::TargetW / 4 + 2, time_y + 6, XRender::TargetW / 2 - 4, 28, {0, 0, 0});
    // progress fill
    if(progress > 0)
        XRender::renderRect(XRender::TargetW / 4 + 2, time_y + 6, (int)((XRender::TargetW / 2 - 4) * progress), 28, {127, 255, 127});
    // push text down
    time_y += 60;

    std::string time_message = fmt::format_ne(g_gameStrings.formatMinutesSeconds, elapsed / 60000, (elapsed / 1000) % 60);
    if(progress_valid)
    {
        time_message += " / ";
        time_message += fmt::format_ne(g_gameStrings.formatMinutesSeconds, total / 60000, (total / 1000) % 60);
    }

    SuperPrintScreenCenter(time_message.c_str(), 4,
               time_y,
               {255, 255, 255, 127});

    XRender::renderTextureBasic(XRender::TargetW / 2 - GFX.LoadCoin.w / 2, time_y + 40, GFX.LoadCoin.w, GFX.LoadCoin.h / 4, GFX.LoadCoin, 0, 32 * LoadCoins);

    XRender::repaint();
    XRender::setTargetScreen();
    XEvents::doEvents();

#ifdef __EMSCRIPTEN__
    emscripten_sleep(1); // To repaint screenn, it's required to send a sleep signal
#endif
}


================================================
FILE: src/main/screen_progress.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef SCREEN_PROGRESS_H
#define SCREEN_PROGRESS_H

#include <cstdint>
#include <string>

#include "numeric_types.h"

/**
 * \brief Updates a progress screen for a long main thread operation
 *
 * \param start_time: start time of the operation based on SDL_GetTicks() (required)
 * \param progress: estimated progress ratio between 0 and 1 (set to negative value if no estimate possible)
 * \param message:
 *
 * Will perform an events update and other actions required during main loop
 **/
void IndicateProgress(uint32_t start_time, num_t progress, const std::string& message);

#endif // SCREEN_PROGRESS_H


================================================
FILE: src/main/screen_prompt.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "config.h"
#include "gfx.h"
#include "sound.h"
#include "graphics.h"
#include "npc_id.h"
#include "controls.h"
#include "screen_fader.h"
#include "game_main.h"

#include "main/game_globals.h"

#include <Logger/logger.h>

#include "core/render.h"
#include "main/screen_prompt.h"
#include "main/screen_quickreconnect.h"
#include "main/speedrunner.h"

namespace PromptScreen
{

static int8_t s_cur_item = 0;
static std::vector<std::string> s_options;
static int s_longest_width = 0;

int Run(const std::string& prompt, std::vector<std::string>&& options)
{
    // initialize text prompt
    MessageText = prompt;
    PrepareMessageDims();

    // initialize options
    s_options = options;

    // perform the pause loop
    PauseGame(PauseCode::Prompt, 0);
    MenuCursorCanMove = false;
    MenuMouseRelease = false;
    MouseRelease = false;
    ScrollRelease = false;

    for(int i = 1; i <= numPlayers; i++)
    {
        Player[i].UnStart = false;
        Player[i].CanJump = false;
        Player[i].CanAltJump = false;
    }

    return s_cur_item;
}

void Init()
{
    PlayMusic("wmusic12", 0);
    PlaySoundMenu(SFX_Message);
    s_cur_item = 0;
    MenuCursorCanMove = false;

    // set the longest width
    s_longest_width = 0;

    for(const std::string& label : s_options)
    {
        int item_width = SuperTextPixLen(label, 3);
        if(item_width > s_longest_width)
            s_longest_width = item_width;
    }

    int total_menu_height = (int)s_options.size() * 36 - 18;
    int total_menu_width = s_longest_width + 40;

    // GBA bounds
    if(total_menu_height > 200 || total_menu_width > 480)
        pLogDebug("Prompt options don't fit within bounds (actual size %dx%d, bounds 480x200)", total_menu_width, total_menu_height);

    // setup fader
    if(g_config.EnableInterLevelFade)
        g_levelScreenFader.setupFader(3, 65, 0, ScreenFader::S_CIRCLE, false, XRender::TargetW / 2, XRender::TargetH / 2, 0);
}

void Render()
{
    XRender::setTargetTexture();

    // reset screen
    XRender::clearBuffer();

    // display background
    vScreen[1].X = 0;
    vScreen[1].Y = 0;
    vScreen[1].Left = 0; vScreen[1].Top = 0; vScreen[1].Width = XRender::TargetW; vScreen[1].Height = XRender::TargetH;
    LevelREAL[1] = IntegerLocation_t(0, 0, XRender::TargetW, XRender::TargetH);
    level[1] = static_cast<SpeedlessLocation_t>(LevelREAL[1]);
    Background2[1] = 1;
    DrawBackground(1, 1);

    // draw message box
    DrawMessage();

    // (from screen_pause.cpp)
    // draw menu box

    // height includes intermediate padding but no top/bottom padding
    // width includes cursor on left and 20px padding on right for symmetry
    int total_menu_height = (int)s_options.size() * 36 - 18;
    int total_menu_width = s_longest_width + 40;

    // enforce GBA bounds (480x320)
    if(total_menu_height > 320)
        total_menu_height = 320;

    if(total_menu_width > 480)
        total_menu_width = 480;

    int menu_box_height = total_menu_height + 32;

    int menu_box_width = 160;
    if(menu_box_width - total_menu_width < 32)
        menu_box_width = total_menu_width + 32;

    int menu_box_Y = XRender::TargetH - 24 - menu_box_height;

    int menu_left_X = XRender::TargetW / 2 - total_menu_width / 2 + 20;
    int menu_top_Y = menu_box_Y + menu_box_height / 2 - total_menu_height / 2;

    XRender::renderRect(XRender::TargetW / 2 - menu_box_width / 2, menu_box_Y, menu_box_width, menu_box_height, XTColorF(0.0_n, 0.0_n, 0.0_n, 0.8_n));

    for(size_t i = 0; i < s_options.size(); i++)
        SuperPrint(s_options[i], 3, menu_left_X, menu_top_Y + (i * 36));

    if(GFX.PCursor.inited)
        XRender::renderTextureBasic(menu_left_X - 20, menu_top_Y + (s_cur_item * 36), GFX.PCursor);
    else
        XRender::renderTextureFL(menu_left_X - 20, menu_top_Y + (s_cur_item * 36), GFX.MCursor[1].w, GFX.MCursor[1].h, GFX.MCursor[1], 0, 0, 90, nullptr, X_FLIP_NONE);

    for(int plr_i = 0; plr_i < l_screen->player_count; plr_i++)
        speedRun_renderControls(plr_i, -1);

    // draw screen fader and repaint

    g_levelScreenFader.draw();

    DrawDeviceBattery();

    XRender::repaint();

    if(TakeScreen)
        ScreenShot();
}

bool Logic()
{
    MenuControls_t menuControls = Controls::GetMenuControls();

    if(!menuControls.Up && !menuControls.Down && !menuControls.Do)
        MenuCursorCanMove = true;

    if(!MenuCursorCanMove)
        return false;

    if(menuControls.Up)
    {
        PlaySoundMenu(SFX_Slide);
        s_cur_item--;
        if(s_cur_item < 0)
            s_cur_item = (int8_t)s_options.size() - 1;
        MenuCursorCanMove = false;
        return false;
    }

    if(menuControls.Down)
    {
        PlaySoundMenu(SFX_Slide);
        s_cur_item++;
        if(s_cur_item >= (int)s_options.size())
            s_cur_item = 0;
        MenuCursorCanMove = false;
        return false;
    }

    if(menuControls.Do && s_cur_item >= 0 && s_cur_item <= 3)
    {
        PlaySoundMenu(SFX_Do);

        if(g_config.EnableInterLevelFade)
            g_levelScreenFader.setupFader(3, 0, 65, ScreenFader::S_CIRCLE, false, XRender::TargetW / 2, XRender::TargetH / 2, 0);
        else
            g_levelScreenFader.setupFader(65, 0, 65, ScreenFader::S_CIRCLE, false, XRender::TargetW / 2, XRender::TargetH / 2, 0);

        editorWaitForFade();
        return true;
    }

    g_levelScreenFader.update();

    return false;
}

} // namespace PromptScreen


================================================
FILE: src/main/screen_prompt.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef SCREEN_PROMPT_H

#define SCREEN_PROMPT_H

#include <string>
#include <vector>

namespace PromptScreen
{

int Run(const std::string& prompt, std::vector<std::string>&& options);

void Init();

void Render();

// if returns true, user has exited the screen
bool Logic();

} // namespace PromptScreen

#endif // SCREEN_PROMPT_H


================================================
FILE: src/main/screen_quickreconnect.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_stdinc.h"

#include "controls.h"
#include "globals.h"
#include "graphics.h"
#include "game_main.h"
#include "message.h"

#include "main/menu_main.h"
#include "main/game_strings.h"

#include "main/screen_quickreconnect.h"

namespace QuickReconnectScreen
{

bool g_active;
int g_toast_duration[maxLocalPlayers] = {0};

void Deactivate()
{
    g_active = false;

    for(int i = 0; i < maxLocalPlayers; ++i)
        g_toast_duration[i] = 0;
}

void Logic()
{
    if(GameMenu || LevelEditor || GameOutro)
    {
        Deactivate();
        return;
    }

    if(XMessage::GetStatus() == XMessage::Status::replay)
        return;

    bool has_missing = false;
    bool has_toast = false;
    bool was_missing[maxLocalPlayers] = {false};

    for(int i = 0; i < maxLocalPlayers; i++)
    {
        if(i >= l_screen->player_count)
            continue;

        if(i >= (int)Controls::g_InputMethods.size() || !Controls::g_InputMethods[i])
        {
            has_missing = true;
            was_missing[i] = true;
        }
        else if(g_toast_duration[i])
        {
            g_toast_duration[i] --;
            has_toast = true;
        }
    }

    if(has_missing && GamePaused != PauseCode::DropAdd)
    {
        auto found = Controls::PollInputMethod();
        if(found)
            found->used_for_player = true;

        // add toasts for new players
        for(int i = 0; i < maxLocalPlayers; i++)
        {
            if(was_missing[i] && i < (int)Controls::g_InputMethods.size() && Controls::g_InputMethods[i])
                g_toast_duration[i] = MAX_TOAST_DURATION;
        }
    }

    if(!has_missing && !has_toast)
        g_active = false;
}

} // namespace QuickReconnectScreen


================================================
FILE: src/main/screen_quickreconnect.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SCREEN_QUICKRECONNECT_H
#define SCREEN_QUICKRECONNECT_H

#include "global_constants.h"

namespace QuickReconnectScreen
{

constexpr int MAX_TOAST_DURATION = 66 * 3; // 3 seconds

extern bool g_active;
extern int g_toast_duration[maxLocalPlayers];

void Deactivate();
void Logic();

} // namespace QuickReconnectScreen

#endif // #ifndef SCREEN_QUICKRECONNECT_H


================================================
FILE: src/main/screen_textentry.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include "../globals.h"
#include "../graphics.h"
#include "../config.h"
#include "core/render.h"
#include "../game_main.h"
#include "controls.h"
#include "gfx.h"

#include "fontman/font_manager_private.h"
#include "fontman/font_manager.h"

#ifdef __ANDROID__

#   include <SDL2/SDL_system.h>
#   include <jni.h>

static void s_textEntry_callDialog()
{
    JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
    jobject activity = (jobject)SDL_AndroidGetActivity();
    jclass clazz = env->GetObjectClass(activity);
    jmethodID method = env->GetMethodID(clazz, "requestText", "()V");
    env->CallVoidMethod(activity, method);
    env->DeleteLocalRef(activity);
    env->DeleteLocalRef(clazz);
}

#endif // #ifdef __ANDROID__

#ifdef __3DS__

#include <3ds.h>

#include "sound.h"

// to check if on second screen
#include "editor/new_editor.h"

namespace XRender
{
    extern bool g_in_frame;
};

static const std::string s_GetTextInput(const std::string& prompt, const std::string& init = "")
{
    static SwkbdState keystate;
    static char input_buffer[240];

    if(XRender::g_in_frame)
        C3D_FrameEnd(0);
    SoundPauseAll();

    swkbdInit(&keystate, SWKBD_TYPE_QWERTY, 1, 120);
    swkbdSetHintText(&keystate, prompt.c_str());
    swkbdSetInitialText(&keystate, init.c_str());
    swkbdSetFeatures(&keystate, SWKBD_DARKEN_TOP_SCREEN);

    swkbdInputText(&keystate, input_buffer, sizeof(input_buffer));

    if(XRender::g_in_frame)
        C3D_FrameBegin(0);
    SoundResumeAll();

    return std::string(input_buffer);
}

#endif // #ifdef __3DS__

namespace TextEntryScreen
{

std::string Text;
static std::vector<int16_t> s_Prompt_UTF_offsets;
static std::vector<int16_t> s_Text_UTF_offsets;

enum class MouseState : uint8_t
{
    down = 0,
    just_released = 1,
    up = 2,
    canceled = 3,
    canceled_2 = 4, // sometimes takes 2 frames for residual touchscreen press to become active
};

static std::string s_Prompt;
static int s_cursor = 0;
static int s_timer = 0;
static bool s_committed = false;
static MouseState s_mouse_state = MouseState::canceled;

// KEYMAP!
// we are assumed to be operating on a Nx5x12 (levels, rows, columns) grid.
// special characters: \b is backspace, \x0e and \x0f are shift up and shift down (a grid level)
// \n is a newline (actually, accept), and \x1d and \x1c are left and right.
// special control character meanings: \x11 is "last button wider" and \x12 is "empty"

static const char* s_keymap_EN = "1234567890-\b"
    "qwertyuiop[]"
    "asdfghjkl;'="
    "`zxcvbnm,./\\"
    "\x0e\x11\x11 \x11\x11\x11\x11\x1d\x1c\n\x11"
    "!@#$%^&*()_\b"
    "QWERTYUIOP{}"
    "ASDFGHJKL:\"+"
    "~ZXCVBNM<>?|"
    "\x0f\x11\x11 \x11\x11\x11\x11\x1d\x1c\n\x11";

#if 0 // FIXME: Decide, what to do with these maps?
static const char* s_keymap_RU = "1234567890-\b"
    "йцукенгшщзхъ"
    "фывапролджэ:"
    "ячсмитьбюё,."
    "\x0e\x11\x11 \x11\x11\x11\x11\x1d\x1c\n\x11"
    "!\"№;%:?*()_\b"
    "ЙЦУКЕНГШЩЗХЪ"
    "ФЫВАПРОЛДЖЭ+"
    "ЯЧСМИТЬБЮЁ«»"
    "\x0f\x11\x11 \x11\x11\x11\x11\x1d\x1c\n\x11";

static const char* s_keymap_JP =
    "あかさたなはまやらわ\b"
    "いきしちにひみ　りゃん"
    "うくすつぬふむゆるょ！"
    "えけせてねへめ　れゅ？"
    "おこそとのほもよろを。"
    "\x0e\x11\x11　\x11\x11\x11\x1d\x1c\n\x11"
    "\x12がざだ\x12ばぱ１６「\b"
    "\x12ぎじぢ\x12びぴ２７」～"
    "\x12ぐずづ\x12ぶぷ３８’、"
    "\x12げぜで\x12べぺ４９”・"
    "\x12ごぞど\x12ぼぽ５０＋ー"
    "\x0e\x11\x11　\x11\x11\x11\x1d\x1c\n\x11"
    "アカサタナハマヤラワ\b"
    "イキシチニヒミ　リャン"
    "ウクスツヌフムユルョ！"
    "エケセテネヘメ　レュ？"
    "オコソトノホモヨロウ。"
    "\x0e\x11\x11　\x11\x11\x11\x1d\x1c\n\x11"
    "\x12ガザダ\x12バパ１６「\b"
    "\x12ギジヂ\x12ビピ２７」～"
    "\x12グズヅ\x12ブプ３８’、"
    "\x12ゲゼデ\x12ベペ４９”・"
    "\x12ゴゾド\x12ボポ５０＋ー"
    "\x0e\x11\x11　\x11\x11\x11\x1d\x1c\n\x11";
#endif

// used to support UTF-8 characters
static std::vector<int16_t> s_current_keymap_UTF_offsets;

static const char* s_current_keymap = s_keymap_EN;
// static const char* s_current_keymap = s_keymap_RU;
static int s_current_keymap_rows = 5;
static int s_current_keymap_cols = 12;
static int s_current_keymap_levels = 3;

// static const char* s_current_keymap = s_keymap_JP;
// static int s_current_keymap_rows = 6;
// static int s_current_keymap_cols = 11;
// static int s_current_keymap_levels = 4;

// selected button location
static int s_cur_level = 0;
static int s_cur_row = 0;
static int s_cur_col = 0;
static bool s_render_sel = false;

inline void find_utf_offsets(const char* str, std::vector<int16_t>& out)
{
    out.clear();

    int16_t offset;

    for(offset = 0; str[offset] != '\0' && offset >= 0; offset++)
    {
        out.push_back(offset);
        UTF8 ucx = static_cast<unsigned char>(str[offset]);
        offset += static_cast<size_t>(trailingBytesForUTF8[ucx]);
    }

    out.push_back(offset);
}

inline const char* get_char(int cLevel, int row, int col)
{
    return s_current_keymap + s_current_keymap_UTF_offsets[(cLevel * s_current_keymap_rows * s_current_keymap_cols) + (row * s_current_keymap_cols) + col];
}

inline const char* get_char()
{
    return get_char(s_cur_level, s_cur_row, s_cur_col);
}

bool UpdateButton(int x, int y, int size, const char* c, bool sel, bool render)
{
    if(*c == '\x12' || *c == '\x11') // empty space or someone else's continuation
        return false;

    const char* next_char = c+1;
    char print_char[6];

    if(*c == '\b')
    {
        print_char[0] = 'B'; print_char[1] = 'S'; print_char[2] = '\0';
    }
    else if(*c == '\x0e' || *c == '\x0f')
    {
        print_char[0] = 's'; print_char[1] = 'h'; print_char[2] = 'i'; print_char[3] = 'f'; print_char[4] = 't'; print_char[5] = '\0';
    }
    else if(*c == '\n')
    {
        print_char[0] = 'o'; print_char[1] = 'k'; print_char[2] = 'a'; print_char[3] = 'y'; print_char[4] = '\0';
    }
    else if(*c == ' ')
    {
        print_char[0] = 's'; print_char[1] = 'p'; print_char[2] = 'a'; print_char[3] = 'c'; print_char[4] = 'e'; print_char[5] = '\0';
    }
    else if(*c == '\x1d')
    {
        print_char[0] = '<'; print_char[1] = '-'; print_char[2] = '\0';
    }
    else if(*c == '\x1c')
    {
        print_char[0] = '-'; print_char[1] = '>'; print_char[2] = '\0';
    }
    else if(c[0] & 1<<7)
    {
        print_char[0] = c[0];
        print_char[1] = c[1];
        next_char ++;
        if(c[0] & 1<<5)
        {
            print_char[2] = c[2];
            next_char ++;
            if(c[0] & 1<<4)
            {
                print_char[3] = c[3];
                print_char[4] = '\0';
                next_char ++;
            }
            else
                print_char[3] = '\0';
        }
        else
            print_char[2] = '\0';
    }
    else
    {
        print_char[0] = c[0];
        print_char[1] = '\0';
    }

    int width = size;

    while(*next_char == '\x11') // wider
    {
        width += size;
        next_char ++;
    }

    // the button is 36x36 and outlined by a 2 pixel box
    bool coll = false;
    if(SharedCursor.X >= x + 2 && SharedCursor.X < x + width - 2
        && SharedCursor.Y >= y + 2 && SharedCursor.Y < y + size - 2)
        coll = true;

    // outline:
    if(render)
    {
        if(sel)
        {
            if(coll && s_mouse_state == MouseState::down)
                XRender::renderRect(x, y, width, size, XTColorF(0.0_n, 0.5_n, 0.5_n, 1.0_n), true);
            else
                XRender::renderRect(x, y, width, size, XTColorF(0.0_n, 1.0_n, 1.0_n, 1.0_n), true);
        }
        else if(coll && s_mouse_state == MouseState::down)
            XRender::renderRect(x, y, width, size, XTColorF(0.0_n, 0.0_n, 0.0_n, 1.0_n), true);

        // background:
        if(s_mouse_state == MouseState::down && coll)
            XRender::renderRect(x+2, y+2, width-4, size-4, XTColorF(0.2_n, 0.2_n, 0.2_n, 1.0_n), true);
        else
            XRender::renderRect(x+2, y+2, width-4, size-4, XTColorF(0.5_n, 0.5_n, 0.6_n, 1.0_n), true);

        SuperPrintCenter(print_char, 4, x+width/2, y+size/2-10);
    }

    return (s_mouse_state == MouseState::just_released && coll);
}

void GoLeft()
{
    int break_col = s_cur_col;
    if(s_cur_col == 0)
        s_cur_col = s_current_keymap_cols - 1;
    else
        s_cur_col --;

    while(*get_char() == '\x11' || *get_char() == '\x12')
    {
        if(s_cur_col == 0)
            s_cur_col = s_current_keymap_cols - 1;
        else
            s_cur_col --;
        if(s_cur_col == break_col)
            break;
    }
}

void GoRight()
{
    int break_col = s_cur_col;

    if(s_cur_col == s_current_keymap_cols - 1)
        s_cur_col = 0;
    else
        s_cur_col ++;

    while(*get_char() == '\x11' || *get_char() == '\x12')
    {
        if(s_cur_col == s_current_keymap_cols - 1)
            s_cur_col = 0;
        else
            s_cur_col ++;
        if(s_cur_col == break_col)
            break;
    }
}

void GoDown()
{
    int break_row = s_cur_row;

    if(s_cur_row == s_current_keymap_rows - 1)
        s_cur_row = 0;
    else
        s_cur_row ++;

    while(*get_char() == '\x12')
    {
        if(s_cur_row == s_current_keymap_rows - 1)
            s_cur_row = 0;
        else
            s_cur_row ++;
        if(s_cur_row == break_row)
            break;
    }

    while(*get_char() == '\x11')
        s_cur_col --;
}

void GoUp()
{
    int break_row = s_cur_row;

    if(s_cur_row == 0)
        s_cur_row = s_current_keymap_rows - 1;
    else
        s_cur_row --;

    while(*get_char() == '\x12')
    {
        if(s_cur_row == 0)
            s_cur_row = s_current_keymap_rows - 1;
        else
            s_cur_row --;
        if(s_cur_row == break_row)
            break;
    }

    while(*get_char() == '\x11')
        s_cur_col --;
}

void Insert(const char* c, int size)
{
    Text.insert(s_Text_UTF_offsets[s_cursor], c, size);

    int16_t new_pos = s_Text_UTF_offsets[s_cursor] + size;

    find_utf_offsets(Text.c_str(), s_Text_UTF_offsets);

    while(s_cursor + 1 < (int16_t)s_Text_UTF_offsets.size() && s_Text_UTF_offsets[s_cursor] < new_pos)
        s_cursor ++;
}

void Insert(const char* c)
{
    // don't allow keyboard insertions until event loop has properly started
    // (this is the input repetition timer, which is initialized first time
    // no input is pressed.)
    if(s_timer < 0)
        return;

    Insert(c, (int)SDL_strlen(c));
}

inline void InsertUnicodeChar(const char* c)
{
    UTF8 ucx = static_cast<unsigned char>(*c);
    Insert(c, 1 + trailingBytesForUTF8[ucx]);
}

void CursorLeft()
{
    if(s_cursor > 0)
        s_cursor --;
}

void CursorRight()
{
    if(s_cursor + 1 < (int)s_Text_UTF_offsets.size())
        s_cursor ++;
}

void Backspace()
{
    int old_cursor = s_cursor;

    CursorLeft();

    Text.erase(Text.begin() + s_Text_UTF_offsets[s_cursor], Text.begin() + s_Text_UTF_offsets[old_cursor]);

    find_utf_offsets(Text.c_str(), s_Text_UTF_offsets);
}

void Commit()
{
    s_committed = true;
}

// returns true if the string is complete
bool DoAction()
{
    const char* c = get_char(s_cur_level, s_cur_row, s_cur_col);

    switch(*c)
    {
    // invalid chars
    case '\x11':
    case '\x12':
        break;
    // accept input
    case '\n':
        return true;
    // left
    case '\x1d':
        CursorLeft();
        break;
    // right
    case '\x1c':
        CursorRight();
        break;
    // shift up
    case '\x0e':
        s_cur_level ++;
        if(s_cur_level == s_current_keymap_levels)
            s_cur_level = 0;
        break;
    // shift down
    case '\x0f':
        if(s_cur_level == 0)
            s_cur_level = s_current_keymap_levels;
        s_cur_level --;
        break;
    // backspace
    case '\b':
        Backspace();
        break;
    // proper text entry
    default:
        InsertUnicodeChar(c);
    }
    return false;
}

bool KeyboardMouseRender(bool mouse, bool render)
{
#ifdef __3DS__
    int cur_ScreenW = (LevelEditor && editorScreen.active) ? 640 : XRender::TargetW;
    int cur_ScreenH = (LevelEditor && editorScreen.active) ? 480 : XRender::TargetH;
#else
    const int cur_ScreenW = XRender::TargetW;
    const int cur_ScreenH = XRender::TargetH;
#endif

#if defined(__WII__) || defined(__3DS__) || defined(__16M__)
    constexpr bool c_always_fill_screen = true;
#else
    constexpr bool c_always_fill_screen = false;
#endif

    int key_size = 40;
    // make OSK fill screen on certain platforms / when touchscreen is in use
    if(c_always_fill_screen || Controls::g_renderTouchscreen)
    {
        key_size = (cur_ScreenW - 40) / s_current_keymap_cols;
        // force even
        key_size &= ~1;
    }

    int kb_height = s_current_keymap_rows*key_size;
    int kb_width = s_current_keymap_cols*key_size;

    int win_width = kb_width + 20;
    int win_height = kb_height + 20;

    int n_text_chars = (s_current_keymap_cols * key_size - 20) / 18 - 1;
    int n_prompt_chars = n_text_chars + 2;

    int n_prompt_lines = (((int)s_Prompt_UTF_offsets.size() - 1 + n_prompt_chars - 1) / n_prompt_chars);
    int n_text_lines = (((int)s_Text_UTF_offsets.size() - 1 + n_text_chars - 1) / n_text_chars);
    if(n_text_lines == 0)
        n_text_lines = 1;

    win_height += n_prompt_lines * 20;
    win_height += n_text_lines * 20;

    int win_x = cur_ScreenW / 2 - win_width / 2;
    int kb_x = win_x + 10;

    // bias towards bottom of screen
    int win_y = (cur_ScreenH - win_height) * 4 / 5;
    // force even
    win_y &= ~1;
    int kb_y = win_y + 10 + n_prompt_lines * 20 + n_text_lines * 20;

    if(render)
    {
        XRender::renderRect(win_x, win_y, win_width, win_height, XTColorF(0.6_n, 0.6_n, 1.0_n, 0.8_n));
        for(int i = 0; i < n_prompt_lines; i ++)
        {
            if(n_prompt_chars * (i + 1) < (int)s_Prompt_UTF_offsets.size())
                SuperPrint(s_Prompt_UTF_offsets[n_prompt_chars * (i + 1)] - s_Prompt_UTF_offsets[n_prompt_chars * i], s_Prompt.c_str() + s_Prompt_UTF_offsets[n_prompt_chars * i], 4, win_x + 10, win_y + 6 + 20*i);
            else
                SuperPrint(s_Prompt.c_str() + s_Prompt_UTF_offsets[n_prompt_chars * i], 4, win_x + 10, win_y + 6 + 20*i);
        }

        XRender::renderRect(win_x + 20, win_y + n_prompt_lines * 20 + 4, win_width - 40, n_text_lines * 20, XTColorF(0.06_n, 0.06_n, 0.1_n, 1.0_n));
        for(int i = 0; i < n_text_lines; i ++)
        {
            if(n_text_chars * (i + 1) < (int)s_Text_UTF_offsets.size())
                SuperPrint(s_Text_UTF_offsets[n_text_chars * (i + 1)] - s_Text_UTF_offsets[n_text_chars * i], Text.c_str() + s_Text_UTF_offsets[n_text_chars * i], 4, win_x + 10 + 16, win_y + 6 + 20 * (n_prompt_lines + i));
            else
                SuperPrint(Text.c_str() + s_Text_UTF_offsets[n_text_chars * i], 4, win_x + 10 + 16, win_y + 6 + 20 * (n_prompt_lines + i));

            // render cursor if it is on this line
            if(CommonFrame % 64 < 32 && ((s_cursor >= i * n_text_chars && s_cursor < (i + 1) * n_text_chars) || (s_cursor == (i + 1) * n_text_chars && s_cursor == (int)s_Text_UTF_offsets.size() - 1)))
            {
                int cursor_offset = SuperTextPixLen(s_Text_UTF_offsets[s_cursor] - s_Text_UTF_offsets[n_text_chars * i], Text.c_str() + s_Text_UTF_offsets[n_text_chars * i], 4);
                XRender::renderRect(win_x + 10 + 16 + cursor_offset - 2, win_y + 4 + 20 * (n_prompt_lines + i), 2, 20, XTColorF(0.7_n, 0.7_n, 0.7_n, 1.0_n));
            }
        }

        XRender::renderRect(kb_x, kb_y, kb_width, kb_height, XTColorF(0.45_n, 0.45_n, 0.75_n, 1.0_n));
    }

    for(int row = 0; row < s_current_keymap_rows; row ++)
    {
        for(int col = 0; col < s_current_keymap_cols; col ++)
        {
            bool sel = false;
            if(s_render_sel && s_cur_row == row && s_cur_col == col)
                sel = true;

            if(UpdateButton(key_size*col + kb_x, key_size*row + kb_y, key_size, get_char(s_cur_level, row, col), sel, render) && mouse)
            {
                s_render_sel = false;
                s_cur_row = row;
                s_cur_col = col;
                if(DoAction())
                    return true;
            }
        }
    }

    if(render && !Controls::g_renderTouchscreen)
        XRender::renderTextureBasic((int)SharedCursor.X, (int)SharedCursor.Y, GFX.ECursor[2]);

    return false;
}

bool Init(const std::string& Prompt, void (*callback)(), const std::string Value)
{
#ifdef __ANDROID__
    if(g_config.use_native_osk)
    {
        s_textEntry_callDialog();

        if(callback)
            callback();

        return false;
    }
#endif

#ifdef __3DS__
    if(g_config.use_native_osk)
    {
        Text = s_GetTextInput(Prompt, Value);

        if(callback)
            callback();

        return false;
    }
#endif

    find_utf_offsets(s_current_keymap, s_current_keymap_UTF_offsets);

    s_Prompt = Prompt;
    Text = Value;
    find_utf_offsets(Text.c_str(), s_Text_UTF_offsets);
    find_utf_offsets(s_Prompt.c_str(), s_Prompt_UTF_offsets);
    s_cursor = (int)s_Text_UTF_offsets.size() - 1;
    s_mouse_state = MouseState::canceled;
    s_cur_level = 0;
    s_cur_row = 0;
    s_cur_col = 0;
    MenuCursorCanMove = false;
    s_render_sel = false;
    s_timer = -1;
    s_committed = false;
    PauseInit(PauseCode::TextEntry, 0, callback);

    return true;
}

const std::string& Run(const std::string& Prompt, const std::string Value)
{
    bool using_pause_loop = Init(Prompt, nullptr, Value);

    // wait for pause loop to finish
    if(using_pause_loop)
        PauseGame(PauseCode::None);

    return Text;
}

void Render()
{
    KeyboardMouseRender(false, true);
}

static void s_finalize()
{
    MenuCursorCanMove = false;
    MenuMouseRelease = false;
    MouseRelease = false;
    ScrollRelease = false;

    for(int i = 1; i <= numPlayers; i++)
    {
        Player[i].UnStart = false;
        Player[i].CanJump = false;
        Player[i].CanAltJump = false;
    }
}

bool Logic()
{
    if(s_mouse_state == MouseState::canceled)
    {
        if(!SharedCursor.Primary)
            s_mouse_state = MouseState::canceled_2;
    }
    else if(s_mouse_state == MouseState::canceled_2)
    {
        if(!SharedCursor.Primary)
            s_mouse_state = MouseState::up;
    }
    else if(SharedCursor.Primary)
        s_mouse_state = MouseState::down;
    else if(s_mouse_state == MouseState::down)
        s_mouse_state = MouseState::just_released;
    else
        s_mouse_state = MouseState::up;

    if(KeyboardMouseRender(true, false))
    {
        s_finalize();
        return true;
    }

    MenuControls_t menuControls = Controls::GetMenuControls();

    bool startPressed = false;

    for(int i = 0; i < l_screen->player_count; i++)
    {
        const Controls_t &c = Controls::g_RawControls[i];

        startPressed |= c.Start;
    }

    if(MenuCursorCanMove)
    {
        if(menuControls.Up)
            GoUp();

        if(menuControls.Down)
            GoDown();

        if(menuControls.Left)
            GoLeft();

        if(menuControls.Right)
            GoRight();

        if(menuControls.Back)
            Backspace();

        if(startPressed || (menuControls.Do && DoAction()))
        {
            s_finalize();
            return true;
        }
    }


    if(!menuControls.Up && !menuControls.Down && !menuControls.Left && !menuControls.Right && !menuControls.Do && !menuControls.Back && !startPressed)
    {
        MenuCursorCanMove = true;
    }
    else
    {
        if(MenuCursorCanMove)
            s_render_sel = true;
        MenuCursorCanMove = false;
        s_timer --;
        if(s_timer == 0)
            MenuCursorCanMove = true;
    }

    if(MenuCursorCanMove)
        s_timer = 10;

    if(s_committed)
        s_finalize();

    return s_committed;
}

} // namespace TextEntryScreen

#ifdef __ANDROID__

extern "C" JNIEXPORT void JNICALL
Java_ru_wohlsoft_thextech_thextechActivity_textentry_1setBuffer(JNIEnv *env, jclass clazz, jstring line_j)
{
    const char *line;
    (void)clazz;
    line = env->GetStringUTFChars(line_j, nullptr);
    TextEntryScreen::Text = (std::string)line;
    env->ReleaseStringUTFChars(line_j, line);
}

#endif // #ifdef __ANDROID__


================================================
FILE: src/main/screen_textentry.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SCREEN_TEXTENTRY_H
#define SCREEN_TEXTENTRY_H

#include <string>

namespace TextEntryScreen
{

extern std::string Text;

// Initialize TextEntryScreen. [Temporarily returns whether a PauseGame(PauseCode::None) should be triggered.]
bool Init(const std::string& Prompt, void (*callback)(), const std::string Value = std::string());

// Initialize and run TextEntryScreen, waiting for the pause loop to complete, and returning the entered text. Deprecated.
const std::string& Run(const std::string& Prompt, const std::string Value = std::string());

void Render();
bool Logic();

void CursorLeft();
void CursorRight();
void Insert(const char* text);
void Backspace();
void Commit();

} // namespace TextEntryScreen

#endif // #ifndef SCREEN_TEXTENTRY_H


================================================
FILE: src/main/setup_physics.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../game_main.h"

void SetupPhysics()
{
    Physics.PlayerJumpVelocity = -(num_t)5.7_nf; // Jump velocity
    Physics.PlayerJumpHeight = 20;          // Jump height
    Physics.PlayerBlockJumpHeight = 25;     // Jump height off bouncy blocks
    Physics.PlayerHeadJumpHeight = 22;      // Jump height off another players head
    Physics.PlayerNPCJumpHeight = 22;       // Jump height off a NPC
    Physics.PlayerSpringJumpHeight = 55;    // Jump height off a Spring
    Physics.PlayerRunSpeed = 6;             // Max run speed
    Physics.PlayerWalkSpeed = 3;            // Max walk speed
    Physics.PlayerGravity = (num_t)0.4_nf;  // Player's gravity
    Physics.PlayerTerminalVelocity = 12;    // Max falling speed
    Physics.PlayerHeight[1][1] = 30;        // Little Mario
    Physics.PlayerWidth[1][1] = 24;         // ------------
    Physics.PlayerGrabSpotX[1][1] = 18;     // ---------
    Physics.PlayerGrabSpotY[1][1] = -2;     // ---------

    for(int i = 2; i <= numStates; i++)
    {
        Physics.PlayerHeight[1][i] = 54;        // Big Char1
        Physics.PlayerWidth[1][i] = 24;         // ---------
        Physics.PlayerDuckHeight[1][i] = 30;    // ---------
        Physics.PlayerGrabSpotX[1][i] = 18;     // ---------
        Physics.PlayerGrabSpotY[1][i] = 16;     // ---------
    }

    Physics.PlayerHeight[2][1] = 30;        // Little Luigi
    Physics.PlayerWidth[2][1] = 24;         // ------------
    Physics.PlayerGrabSpotX[2][1] = 16;     // ---------
    Physics.PlayerGrabSpotY[2][1] = -4;     // ---------

    for(int i = 2; i <= numStates; i++)
    {
        Physics.PlayerHeight[2][i] = 60;        // Big Char2
        Physics.PlayerWidth[2][i] = 24;         // ---------
        Physics.PlayerDuckHeight[2][i] = 30;    // ---------
        Physics.PlayerGrabSpotX[2][i] = 18;     // ---------
        Physics.PlayerGrabSpotY[2][i] = 16;     // ---------
    }

    Physics.PlayerHeight[3][1] = 38;        // Little Peach
    Physics.PlayerDuckHeight[3][1] = 26;    // ---------
    Physics.PlayerWidth[3][1] = 24;         // ------------
    Physics.PlayerGrabSpotX[3][1] = 0;      // ---------
    Physics.PlayerGrabSpotY[3][1] = 0;      // ---------
    Physics.PlayerHeight[3][2] = 60;        // Big Peach
    Physics.PlayerWidth[3][2] = 24;         // ---------
    Physics.PlayerDuckHeight[3][2] = 30;    // ---------
    Physics.PlayerGrabSpotX[3][2] = 0;     // ---------
    Physics.PlayerGrabSpotY[3][2] = 0;     // ---------

    for(int i = 3; i <= numStates; i++)
    {
        Physics.PlayerHeight[3][i] = 60;        // Power Char3
        Physics.PlayerWidth[3][i] = 24;         // ---------
        Physics.PlayerDuckHeight[3][i] = 30;    // ---------
        Physics.PlayerGrabSpotX[3][i] = 18;
        Physics.PlayerGrabSpotY[3][i] = 16;
    }

    Physics.PlayerHeight[4][1] = 30;        // Little Toad
    Physics.PlayerWidth[4][1] = 24;         // ------------
    Physics.PlayerDuckHeight[4][1] = 26;    // ---------
    Physics.PlayerGrabSpotX[4][1] = 18;     // ---------
    Physics.PlayerGrabSpotY[4][1] = -2;     // ---------

    for(int i = 2; i <= numStates; i++)
    {
        Physics.PlayerHeight[4][i] = 50;        // Big Char3
        Physics.PlayerWidth[4][i] = 24;         // ---------
        Physics.PlayerDuckHeight[4][i] = 30;    // ---------
        Physics.PlayerGrabSpotX[4][i] = 18;     // ---------
        Physics.PlayerGrabSpotY[4][i] = 16;     // ---------
    }

    for(int i = 1; i <= numStates; i++)
    {
        Physics.PlayerHeight[5][i] = 54;        // Char5
        Physics.PlayerWidth[5][i] = 22;         // ---------
        Physics.PlayerDuckHeight[5][i] = 44;    // ---------
        Physics.PlayerGrabSpotX[5][i] = 18;     // ---------
        Physics.PlayerGrabSpotY[5][i] = 16;     // ---------
    }

    Physics.NPCTimeOffScreen = 180;                     // How long NPCs are active offscreen before being reset
    Physics.NPCShellSpeed = (num_t)7.1_nf;              // Speed of kicked shells
    Physics.NPCShellSpeedY = 11;                        // Vertical Speed of kicked shells
    Physics.NPCCanHurtWait = 30;                        // How long to wait before NPCs can hurt players
    Physics.NPCGravityReal = 0.26_nf;                   // NPC Gravity
    Physics.NPCGravity = (num_t)Physics.NPCGravityReal; // NPC Gravity
    Physics.NPCWalkingSpeed = (num_t)1.2_nf;            // NPC Walking Speed
    Physics.NPCWalkingOnSpeed = 1;                      // NPC that can be walked on walking speed
    Physics.NPCMushroomSpeed = (num_t)1.8_nf;           // Mushroom X Speed
    Physics.NPCPSwitch = 777;                           // P Switch time
}


================================================
FILE: src/main/setup_vars.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../game_main.h"
#include "../custom.h"
#include "npc_traits.h"
#include "npc_id.h"

void SetupVars()
{
    //int A;
    SetupPlayerFrames();
    for(int A = 1; A <= maxEffectType; A++)
    {
        EffectWidth[A] = 32;
        EffectHeight[A] = 32;
    }
    // now part of the default NPCTraits_t initializer'
    // for(int A = 1; A <= maxNPCType; ++A)
    //     NPCTraits[A].Speedvar = 1;
    for(int A = 174; A <= 186; ++A)
        BackgroundFence[A] = true;

    GFXLevelBig[21] = true;
    GFXLevelBig[22] = true;
    GFXLevelBig[23] = true;
    GFXLevelBig[24] = true;
    GFXLevelBig[28] = true;

    EffectWidth[145] = 32;
    EffectHeight[145] = 60;

    EffectWidth[71] = 16;
    EffectHeight[71] = 16;
    EffectWidth[148] = 16;
    EffectHeight[148] = 16;


    EffectWidth[111] = 16;
    EffectHeight[111] = 16;
    EffectHeight[121] = 48;

    EffectWidth[144] = 54;
    EffectHeight[144] = 42;


    EffectWidth[143] = 64;
    EffectHeight[143] = 64;

    EffectWidth[120] = 48;
    EffectHeight[121] = 48;


    EffectWidth[138] = 48;
    EffectHeight[138] = 64;


    EffectWidth[125] = 80;
    EffectHeight[125] = 34;

    EffectWidth[134] = 32;
    EffectHeight[134] = 58;

    EffectWidth[130] = 30;
    EffectHeight[130] = 34;

    EffectWidth[132] = 32;
    EffectHeight[132] = 32;
    EffectWidth[133] = 10;
    EffectHeight[133] = 8;


    EffectWidth[1] = 16;
    EffectHeight[1] = 16;

    EffectWidth[135] = 16;
    EffectHeight[135] = 16;

    EffectWidth[104] = 32;
    EffectHeight[104] = 32;
    EffectWidth[105] = 64;
    EffectHeight[105] = 72;

    EffectWidth[129] = 30;
    EffectHeight[129] = 42;

    EffectWidth[106] = 80;
    EffectHeight[106] = 94;

    EffectWidth[108] = 64;
    EffectHeight[108] = 64;

    EffectWidth[112] = 96;
    EffectHeight[112] = 106;

    EffectWidth[4] = 32;
    EffectHeight[4] = 32;
    EffectWidth[8] = 32;
    EffectHeight[8] = 32;
    EffectWidth[9] = 32;
    EffectHeight[9] = 32;
    EffectWidth[10] = 32;
    EffectHeight[10] = 32;
    EffectWidth[11] = 32;
    EffectHeight[11] = 32;
    EffectWidth[12] = 8;
    EffectHeight[12] = 8;
    EffectWidth[13] = 84;
    EffectHeight[13] = 26;
    EffectWidth[14] = 62;
    EffectHeight[14] = 32;
    EffectWidth[15] = 32;
    EffectHeight[15] = 28;
    EffectWidth[16] = 128;
    EffectHeight[16] = 128;
    EffectWidth[17] = 32;
    EffectHeight[17] = 32;
    EffectWidth[18] = 32;
    EffectHeight[18] = 32;
    EffectWidth[19] = 32;
    EffectHeight[19] = 32;
    EffectWidth[20] = 32;
    EffectHeight[20] = 32;
    EffectWidth[21] = 16;
    EffectHeight[21] = 16;
    EffectWidth[22] = 32;
    EffectHeight[22] = 32;
    EffectWidth[23] = 32;
    EffectHeight[23] = 32;
    EffectWidth[24] = 32;
    EffectHeight[24] = 32;
    EffectWidth[25] = 32;
    EffectHeight[25] = 48;
    EffectWidth[26] = 32;
    EffectHeight[26] = 32;
    EffectWidth[29] = 40;
    EffectHeight[29] = 64;
    EffectWidth[30] = 16;
    EffectHeight[30] = 16;
    EffectWidth[31] = 32;
    EffectHeight[31] = 32;
    EffectWidth[32] = 32;
    EffectHeight[32] = 62;
    EffectWidth[33] = 32;
    EffectHeight[33] = 32;
    EffectWidth[34] = 32;
    EffectHeight[34] = 32;
    EffectWidth[35] = 32;
    EffectHeight[35] = 32;
    EffectWidth[36] = 32;
    EffectHeight[36] = 32;
    EffectWidth[37] = 32;
    EffectHeight[37] = 32;
    EffectWidth[38] = 32;
    EffectHeight[38] = 32;
    EffectWidth[45] = 48;
    EffectHeight[45] = 46;
    EffectWidth[46] = 48;
    EffectHeight[46] = 46;
    EffectWidth[47] = 44;
    EffectHeight[47] = 44;
    EffectWidth[48] = 32;
    EffectHeight[48] = 32;
    EffectWidth[50] = 64;
    EffectHeight[50] = 80;
    EffectWidth[51] = 16;
    EffectHeight[51] = 16;
    EffectWidth[54] = 32;
    EffectHeight[54] = 64;
    EffectWidth[55] = 32;
    EffectHeight[55] = 64;
    EffectWidth[56] = 32;
    EffectHeight[56] = 32;
    EffectWidth[57] = 16;
    EffectHeight[57] = 16;
    EffectWidth[58] = 32;
    EffectHeight[58] = 32;
    EffectWidth[59] = 32;
    EffectHeight[59] = 64;
    EffectWidth[60] = 32;
    EffectHeight[60] = 32;
    EffectWidth[61] = 32;
    EffectHeight[61] = 32;
    EffectWidth[62] = 32;
    EffectHeight[62] = 32;
    EffectWidth[63] = 48;
    EffectHeight[63] = 48;
    EffectWidth[64] = 32;
    EffectHeight[64] = 32;
    EffectWidth[65] = 32;
    EffectHeight[65] = 32;
    EffectWidth[66] = 32;
    EffectHeight[66] = 32;
    EffectWidth[67] = 32;
    EffectHeight[67] = 32;
    EffectWidth[68] = 16;
    EffectHeight[68] = 16;
    EffectWidth[69] = 64;
    EffectHeight[69] = 64;
    EffectWidth[70] = 16;
    EffectHeight[70] = 16;
    EffectWidth[71] = 16;
    EffectHeight[71] = 16;
    EffectWidth[72] = 32;
    EffectHeight[72] = 28;
    EffectWidth[73] = 32;
    EffectHeight[73] = 32;
    EffectWidth[74] = 8;
    EffectHeight[74] = 10;
    EffectWidth[75] = 32;
    EffectHeight[75] = 32;
    EffectWidth[76] = 14;
    EffectHeight[76] = 14;
    EffectWidth[77] = 8;
    EffectHeight[77] = 8;
    EffectWidth[139] = 8;
    EffectHeight[139] = 8;
    EffectWidth[78] = 10;
    EffectHeight[78] = 10;
    EffectWidth[79] = 50;
    EffectHeight[79] = 24;
    EffectWidth[80] = 16;
    EffectHeight[80] = 16;
    EffectWidth[81] = 32;
    EffectHeight[81] = 32;
    EffectWidth[82] = 32;
    EffectHeight[82] = 32;
    EffectWidth[83] = 32;
    EffectHeight[83] = 42;
    EffectWidth[84] = 32;
    EffectHeight[84] = 32;
    EffectWidth[85] = 32;
    EffectHeight[85] = 32;
    EffectWidth[86] = 40;
    EffectHeight[86] = 64;
    EffectWidth[87] = 64;
    EffectHeight[87] = 64;
    EffectWidth[88] = 32;
    EffectHeight[88] = 32;
    EffectWidth[89] = 26;
    EffectHeight[89] = 46;
    EffectWidth[90] = 48;
    EffectHeight[90] = 96;
    EffectWidth[91] = 140;
    EffectHeight[91] = 128;
    EffectWidth[92] = 32;
    EffectHeight[92] = 32;
    EffectWidth[93] = 32;
    EffectHeight[93] = 32;
    EffectWidth[94] = 32;
    EffectHeight[94] = 32;
    EffectWidth[97] = 48;
    EffectHeight[97] = 64;
    EffectWidth[98] = 64;
    EffectHeight[98] = 64;
    EffectWidth[99] = 48;
    EffectHeight[99] = 64;
    EffectWidth[100] = 16;
    EffectHeight[100] = 16;

    EffectWidth[113] = 8;
    EffectHeight[113] = 8;

    EffectWidth[140] = 32;
    EffectHeight[140] = 40;


    EffectWidth[114] = 32;
    EffectHeight[114] = 32;

    EffectWidth[103] = 120;
    EffectHeight[103] = 96;

    EffectWidth[123] = 32;
    EffectHeight[123] = 32;
    EffectWidth[124] = 32;
    EffectHeight[124] = 32;
    EffectHeight[95] = 28;
    EffectHeight[96] = 28;

    EffectHeight[46] = 46;
    EffectWidth[46] = 48;
    EffectHeight[47] = 44;
    EffectWidth[47] = 44;

    // NEW: reset all variables to their original values (it will be nice to convert all NPC traits to a single struct)
    NPCTraits.fill(NPCTraits_t());

    // clear fields that were incorrectly initialized for NPCTraits[0] between v1.3.7 and v1.3.7.3 (caused a bug where popping an empty bubble could harm the player)
    NPCTraits[NPCID_NULL].Speedvar = 0;
    NPCTraits[NPCID_NULL].TWidth = 0;
    NPCTraits[NPCID_NULL].THeight = 0;
    NPCTraits[NPCID_NULL].Score = 0;

    // SMBX64 logic:
    // now included as part of default NPCTraits_t initializer
    // for(int A = 1; A <= maxNPCType; ++A)
    // {
    //     NPCTraits[A].Score = 2;
    //     NPCTraits[A].TWidth = 32;
    //     NPCTraits[A].THeight = 32;
    // }

    NPCTraits[NPCID_CHAR3_HEAVY].TWidth = 22;
    NPCTraits[NPCID_CHAR3_HEAVY].THeight = 18;
    NPCTraits[NPCID_CHAR3_HEAVY].WidthGFX = 42;
    NPCTraits[NPCID_CHAR3_HEAVY].HeightGFX = 34;
    NPCTraits[NPCID_CHAR3_HEAVY].WontHurt = true;
    NPCTraits[NPCID_CHAR3_HEAVY].JumpHurt = true;
    NPCTraits[NPCID_CHAR3_HEAVY].NoYoshi = true;



    NPCTraits[NPCID_LONG_PLANT_UP].NoYoshi = true;
    NPCTraits[NPCID_LONG_PLANT_DOWN].NoYoshi = true;
    NPCTraits[NPCID_TNT].NoYoshi = true;


    NPCTraits[NPCID_BOSS_CASE].Score = 0;
    NPCTraits[NPCID_MINIBOSS].Score = 7;
    NPCTraits[NPCID_SPIT_BOSS].Score = 7;
    NPCTraits[NPCID_VILLAIN_S3].Score = 9;
    NPCTraits[NPCID_VILLAIN_S1].Score = 9;
    NPCTraits[NPCID_SICK_BOSS].Score = 9;
    NPCTraits[NPCID_BOSS_FRAGILE].Score = 9;
    NPCTraits[NPCID_HEAVY_THROWER].Score = 5;
    NPCTraits[NPCID_SPIKY_THROWER].Score = 6;
    NPCTraits[NPCID_ITEM_THROWER].Score = 6;
    NPCTraits[NPCID_LONG_PLANT_UP].Score = 5;
    NPCTraits[NPCID_LONG_PLANT_DOWN].Score = 5;
    NPCTraits[NPCID_BOMBER_BOSS].Score = 8;
    NPCTraits[NPCID_MAGIC_BOSS].Score = 8;
    NPCTraits[NPCID_MAGIC_BOSS_SHELL].Score = 8;
    NPCTraits[NPCID_FIRE_BOSS].Score = 8;
    NPCTraits[NPCID_FIRE_BOSS_SHELL].Score = 8;
    NPCTraits[NPCID_GEM_1].FrameOffsetY = 2;
    NPCTraits[NPCID_GEM_5].FrameOffsetY = 2;
    NPCTraits[NPCID_GEM_20].FrameOffsetY = 2;
    NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].FrameOffsetY = 2;
    NPCTraits[NPCID_JUMPER_S4].FrameOffsetY = 2;

    NPCTraits[NPCID_DOOR_MAKER].WontHurt = true;
    NPCTraits[NPCID_DOOR_MAKER].JumpHurt = true;

    NPCTraits[NPCID_RANDOM_POWER].WontHurt = true;
    NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].WontHurt = true;
    NPCTraits[NPCID_HOMING_BALL].Foreground = true;
    NPCTraits[NPCID_RED_FISH_S3].Foreground = true;

    NPCTraits[NPCID_RED_FISH_S1].IsFish = true;
    NPCTraits[NPCID_GRN_FISH_S3].IsFish = true;
    NPCTraits[NPCID_RED_FISH_S3].IsFish = true;
    NPCTraits[NPCID_GRN_FISH_S4].IsFish = true;
    NPCTraits[NPCID_GRN_FISH_S1].IsFish = true;
    NPCTraits[NPCID_BONE_FISH].IsFish = true;
    NPCTraits[NPCID_YEL_FISH_S4].IsFish = true;


    NPCTraits[NPCID_MAGIC_DOOR].NoClipping = true;
    NPCTraits[NPCID_MAGIC_DOOR].WontHurt = true;
    NPCTraits[NPCID_MAGIC_DOOR].JumpHurt = true;
    NPCTraits[NPCID_MAGIC_DOOR].TWidth = 32;
    NPCTraits[NPCID_MAGIC_DOOR].THeight = 32;
    NPCTraits[NPCID_MAGIC_DOOR].WidthGFX = 32;
    NPCTraits[NPCID_MAGIC_DOOR].HeightGFX = 64;


    NPCTraits[NPCID_ITEM_BUBBLE].TWidth = 48;
    NPCTraits[NPCID_ITEM_BUBBLE].THeight = 48;
    NPCTraits[NPCID_ITEM_BUBBLE].WidthGFX = 64;
    NPCTraits[NPCID_ITEM_BUBBLE].HeightGFX = 64;
    NPCTraits[NPCID_ITEM_BUBBLE].FrameOffsetY = 8;
    NPCTraits[NPCID_ITEM_BUBBLE].WontHurt = true;
    NPCTraits[NPCID_ITEM_BUBBLE].JumpHurt = true;

    NPCTraits[NPCID_COCKPIT].WidthGFX = 32;
    NPCTraits[NPCID_COCKPIT].HeightGFX = 64;
    NPCTraits[NPCID_COCKPIT].Foreground = true;
    NPCTraits[NPCID_COCKPIT].CanWalkOn = true;
    NPCTraits[NPCID_COCKPIT].IsABlock = true;
    NPCTraits[NPCID_COCKPIT].WontHurt = true;
    NPCTraits[NPCID_COCKPIT].NoClipping = true;


    NPCTraits[NPCID_ICE_CUBE].CanWalkOn = true;
    NPCTraits[NPCID_ICE_CUBE].WontHurt = true;
    NPCTraits[NPCID_ICE_CUBE].MovesPlayer = true;
    NPCTraits[NPCID_ICE_CUBE].IsGrabbable = true;
    NPCTraits[NPCID_ICE_CUBE].GrabFromTop = true;
    NPCTraits[NPCID_ICE_CUBE].IsABlock = true;

    NPCTraits[NPCID_BOMBER_BOSS].CanWalkOn = true;
    NPCTraits[NPCID_BOMBER_BOSS].TWidth = 40;
    NPCTraits[NPCID_BOMBER_BOSS].THeight = 56;
    NPCTraits[NPCID_BOMBER_BOSS].WidthGFX = 48;
    NPCTraits[NPCID_BOMBER_BOSS].HeightGFX = 64;



    NPCTraits[NPCID_FLY_POWER].IsABonus = true;
    NPCTraits[NPCID_ICE_BLOCK].IsAShell = true;
    NPCTraits[NPCID_ICE_BLOCK].WontHurt = true;
    NPCTraits[NPCID_ICE_BLOCK].CanWalkOn = true;
    NPCTraits[NPCID_PLR_FIREBALL].JumpHurt = true;
    NPCTraits[NPCID_VILLAIN_S3].JumpHurt = true;
    NPCTraits[NPCID_FIRE_CHAIN].JumpHurt = true;



    NPCTraits[NPCID_ICE_CUBE].NoYoshi = true;
    NPCTraits[NPCID_PLR_ICEBALL].NoYoshi = true;
    NPCTraits[NPCID_FIRE_CHAIN].NoYoshi = true;
    NPCTraits[NPCID_LOCK_DOOR].NoYoshi = true;

    NPCTraits[NPCID_JUMP_PLANT].NoClipping = true;

    NPCTraits[NPCID_PLANT_FIREBALL].JumpHurt = true;
    NPCTraits[NPCID_PLANT_FIREBALL].NoClipping = true;
    NPCTraits[NPCID_PLANT_FIREBALL].NoYoshi = true;
    NPCTraits[NPCID_PLANT_FIREBALL].TWidth = 16;
    NPCTraits[NPCID_PLANT_FIREBALL].THeight = 16;

    NPCTraits[NPCID_GEM_1].TWidth = 18; // TLOZ Rupee
    NPCTraits[NPCID_GEM_1].THeight = 32;
    NPCTraits[NPCID_GEM_1].IsABonus = true;
    NPCTraits[NPCID_GEM_1].IsACoin = true;

    NPCTraits[NPCID_GEM_5].TWidth = 18; // TLOZ Rupee
    NPCTraits[NPCID_GEM_5].THeight = 32;
    NPCTraits[NPCID_GEM_5].IsABonus = true;
    NPCTraits[NPCID_GEM_5].IsACoin = true;

    NPCTraits[NPCID_GEM_20].TWidth = 18; // TLOZ Rupee
    NPCTraits[NPCID_GEM_20].THeight = 32;
    NPCTraits[NPCID_GEM_20].IsABonus = true;
    NPCTraits[NPCID_GEM_20].IsACoin = true;

    NPCTraits[NPCID_POWER_S5].TWidth = 32; // TLOZ Heart
    NPCTraits[NPCID_POWER_S5].THeight = 32;
    NPCTraits[NPCID_POWER_S5].IsABonus = true;

    // vines
    for(int A = NPCID_GRN_VINE_S3; A <= NPCID_GRN_VINE_S4; ++A)
    {
        NPCTraits[A].IsAVine = true;
        NPCTraits[A].WontHurt = true;
        NPCTraits[A].NoClipping = true;
        NPCTraits[A].JumpHurt = true;
        NPCTraits[A].NoYoshi = true;
        NPCTraits[A].TWidth = 16;
        NPCTraits[A].WidthGFX = 32;
        NPCTraits[A].HeightGFX = 32;
    }
    NPCTraits[NPCID_GRN_VINE_TOP_S1].THeight = 24;
    NPCTraits[NPCID_GRN_VINE_TOP_S1].HeightGFX = 24;
    NPCTraits[NPCID_SQUID_S3].JumpHurt = true;
    NPCTraits[NPCID_RED_VINE_TOP_S3].WontHurt = true;
    NPCTraits[NPCID_RED_VINE_TOP_S3].JumpHurt = true;
    NPCTraits[NPCID_RED_VINE_TOP_S3].NoYoshi = true;
    NPCTraits[NPCID_GRN_VINE_TOP_S3].WontHurt = true;
    NPCTraits[NPCID_GRN_VINE_TOP_S3].JumpHurt = true;
    NPCTraits[NPCID_GRN_VINE_TOP_S3].NoYoshi = true;
    NPCTraits[NPCID_GRN_VINE_TOP_S4].WontHurt = true;
    NPCTraits[NPCID_GRN_VINE_TOP_S4].JumpHurt = true;
    NPCTraits[NPCID_GRN_VINE_TOP_S4].NoYoshi = true;

    NPCTraits[NPCID_HOMING_BALL_GEN].NoYoshi = true;

    NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].IsGrabbable = true;
    NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].GrabFromTop = true;

    NPCTraits[NPCID_TIMER_S2].TWidth = 32;
    NPCTraits[NPCID_TIMER_S2].THeight = 32;
    NPCTraits[NPCID_TIMER_S2].IsABonus = true;//32;

    NPCTraits[NPCID_TIMER_S3].TWidth = 32;
    NPCTraits[NPCID_TIMER_S3].THeight = 32;
    NPCTraits[NPCID_TIMER_S3].IsABonus = true;//32;

    NPCTraits[NPCID_VILLAIN_S1].TWidth = 64;
    NPCTraits[NPCID_VILLAIN_S1].THeight = 72;
    NPCTraits[NPCID_VILLAIN_S1].FrameOffsetY = 2;
    NPCTraits[NPCID_VILLAIN_S1].JumpHurt = true;
    NPCTraits[NPCID_HOMING_BALL].JumpHurt = true;
    NPCTraits[NPCID_FIRE_DISK].NoClipping = true;
    NPCTraits[NPCID_FIRE_DISK].NoYoshi = true;
    NPCTraits[NPCID_FIRE_DISK].JumpHurt = true;
    NPCTraits[NPCID_FIRE_CHAIN].TWidth = 16;
    NPCTraits[NPCID_FIRE_CHAIN].THeight = 16;
    NPCTraits[NPCID_FIRE_CHAIN].NoClipping = true;

    NPCTraits[NPCID_POISON].TWidth = 32; // Poison Mushroom
    NPCTraits[NPCID_POISON].THeight = 32;
    NPCTraits[NPCID_POISON].FrameOffsetY = 2;

    NPCTraits[NPCID_FODDER_S5].TWidth = 32; // SML2 Goomba
    NPCTraits[NPCID_FODDER_S5].THeight = 32;
    NPCTraits[NPCID_FODDER_S5].FrameOffsetY = 2;
    // NPCDefaultMovement(NPCID_FODDER_S5) = true;

    NPCTraits[NPCID_FLY_FODDER_S5].TWidth = 32; // SML2 Flying Goomba
    NPCTraits[NPCID_FLY_FODDER_S5].THeight = 32;
    NPCTraits[NPCID_FLY_FODDER_S5].FrameOffsetY = 2;
    NPCTraits[NPCID_FLY_FODDER_S5].WidthGFX = 56;
    NPCTraits[NPCID_FLY_FODDER_S5].HeightGFX = 36;

    NPCTraits[NPCID_FLY_FODDER_S3].TWidth = 32; // SMB3 Flying Goomba
    NPCTraits[NPCID_FLY_FODDER_S3].THeight = 32;
    NPCTraits[NPCID_FLY_FODDER_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_FLY_FODDER_S3].WidthGFX = 40;
    NPCTraits[NPCID_FLY_FODDER_S3].HeightGFX = 48;

    NPCTraits[NPCID_LOCK_DOOR].TWidth = 20;
    NPCTraits[NPCID_LOCK_DOOR].THeight = 96;
    NPCTraits[NPCID_LOCK_DOOR].WontHurt = true;
    NPCTraits[NPCID_LOCK_DOOR].IsABlock = true;
    NPCTraits[NPCID_LOCK_DOOR].CanWalkOn = true;
    NPCTraits[NPCID_LOCK_DOOR].MovesPlayer = true;

    // NPCIsAParaTroopa(NPCID_FLY_FODDER_S3) = true;
    // NPCIsAParaTroopa(NPCID_FLY_FODDER_S5) = true;

    NPCTraits[NPCID_FODDER_S3].TWidth = 32; // Goomba
    NPCTraits[NPCID_FODDER_S3].THeight = 32;
    NPCTraits[NPCID_FODDER_S3].FrameOffsetY = 2;

    NPCTraits[NPCID_FODDER_S3].TWidth = 32; // Goomba
    NPCTraits[NPCID_FODDER_S3].THeight = 32;
    NPCTraits[NPCID_FODDER_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_FODDER].TWidth = 32; // Red goomba
    NPCTraits[NPCID_RED_FODDER].THeight = 32;
    NPCTraits[NPCID_RED_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_FLY_FODDER].TWidth = 32; // Flying goomba
    NPCTraits[NPCID_RED_FLY_FODDER].THeight = 32;
    NPCTraits[NPCID_RED_FLY_FODDER].WidthGFX = 40;
    NPCTraits[NPCID_RED_FLY_FODDER].HeightGFX = 48;
    NPCTraits[NPCID_RED_FLY_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_GRN_TURTLE_S3].TWidth = 32; // Green koopa
    NPCTraits[NPCID_GRN_TURTLE_S3].THeight = 32;
    NPCTraits[NPCID_GRN_TURTLE_S3].WidthGFX = 32;
    NPCTraits[NPCID_GRN_TURTLE_S3].HeightGFX = 54;
    NPCTraits[NPCID_GRN_TURTLE_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_GRN_SHELL_S3].TWidth = 32; // Green shell
    NPCTraits[NPCID_GRN_SHELL_S3].THeight = 32;
    NPCTraits[NPCID_GRN_SHELL_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_TURTLE_S3].TWidth = 32; // Red koopa
    NPCTraits[NPCID_RED_TURTLE_S3].THeight = 32;
    NPCTraits[NPCID_RED_TURTLE_S3].WidthGFX = 32;
    NPCTraits[NPCID_RED_TURTLE_S3].HeightGFX = 54;
    NPCTraits[NPCID_RED_TURTLE_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_SHELL_S3].TWidth = 32; // Red shell
    NPCTraits[NPCID_RED_SHELL_S3].THeight = 32;
    NPCTraits[NPCID_RED_SHELL_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_PLANT_S3].TWidth = 32; // Plant
    NPCTraits[NPCID_PLANT_S3].THeight = 48;
    NPCTraits[NPCID_PLANT_S3].WidthGFX = 32;
    NPCTraits[NPCID_PLANT_S3].HeightGFX = 48;
    NPCTraits[NPCID_FIRE_PLANT].TWidth = 32; // SMB 3 Fire Plant
    NPCTraits[NPCID_FIRE_PLANT].THeight = 64;
    NPCTraits[NPCID_FIRE_PLANT].WidthGFX = 32;
    NPCTraits[NPCID_FIRE_PLANT].HeightGFX = 64;
    NPCTraits[NPCID_PLANT_S3].FrameOffsetY = 1;
    NPCTraits[NPCID_POWER_S3].TWidth = 32; // Mushroom
    NPCTraits[NPCID_POWER_S3].THeight = 32;
    NPCTraits[NPCID_POWER_S3].FrameOffsetY =2;

    // Reversed incompatible powerup score customizability implementation at v1.3.6.1.
    // These scores are now found in loadNpcSetupFixes();

    NPCTraits[NPCID_SWAP_POWER].TWidth = 32; // ? Mushroom
    NPCTraits[NPCID_SWAP_POWER].THeight = 32;
    NPCTraits[NPCID_SWAP_POWER].FrameOffsetY = 2;

    NPCTraits[NPCID_POWER_S2].TWidth = 32; // SMB2 Mushroom
    NPCTraits[NPCID_POWER_S2].THeight = 32;
    NPCTraits[NPCID_POWER_S2].IsABonus = true;

    NPCTraits[NPCID_MEDAL].TWidth = 32; // dragon coin
    NPCTraits[NPCID_MEDAL].THeight = 50;
    NPCTraits[NPCID_MEDAL].IsABonus = true;
    NPCTraits[NPCID_MEDAL].IsACoin = true;
    NPCTraits[NPCID_MEDAL].Score = 6;

    NPCTraits[NPCID_COIN_S3].TWidth = 28; // SMB3 Coin
    NPCTraits[NPCID_COIN_S3].THeight = 32;
    NPCTraits[NPCID_ITEMGOAL].TWidth = 32; // SMB3 Level exit
    NPCTraits[NPCID_ITEMGOAL].THeight = 32;
    NPCTraits[NPCID_LAVABUBBLE].TWidth = 28; // Big Fireball
    NPCTraits[NPCID_LAVABUBBLE].THeight = 32;
    NPCTraits[NPCID_PLR_FIREBALL].TWidth = 16; // Small Fireball
    NPCTraits[NPCID_PLR_FIREBALL].THeight = 16;
    NPCTraits[NPCID_PLR_ICEBALL].TWidth = 16; // Ice Bolt
    NPCTraits[NPCID_PLR_ICEBALL].THeight = 16;
    NPCTraits[NPCID_PLR_ICEBALL].NoIceBall = true;
    NPCTraits[NPCID_PLR_FIREBALL].NoYoshi = true;
    NPCTraits[NPCID_FIRE_POWER_S3].TWidth = 32; // Fire Flower
    NPCTraits[NPCID_FIRE_POWER_S3].THeight = 32;
    NPCTraits[NPCID_FIRE_POWER_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_ICE_POWER_S3].TWidth = 32; // Ice Flower
    NPCTraits[NPCID_ICE_POWER_S3].THeight = 32;
    NPCTraits[NPCID_ICE_POWER_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_ICE_POWER_S4].TWidth = 32; // Ice Flower
    NPCTraits[NPCID_ICE_POWER_S4].THeight = 32;
    NPCTraits[NPCID_ICE_POWER_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_MINIBOSS].TWidth = 60; // Big Koopa
    NPCTraits[NPCID_MINIBOSS].THeight = 54;
    NPCTraits[NPCID_MINIBOSS].WidthGFX = 68;
    NPCTraits[NPCID_MINIBOSS].HeightGFX = 54;
    NPCTraits[NPCID_MINIBOSS].FrameOffsetY = 2;
    NPCTraits[NPCID_MINIBOSS].NoYoshi = true;
    NPCTraits[NPCID_GOALORB_S3].TWidth = 32; // Boss Exit
    NPCTraits[NPCID_GOALORB_S3].THeight = 32;
    NPCTraits[NPCID_BULLET].TWidth = 32; // Bullet Bill
    NPCTraits[NPCID_BULLET].THeight = 28;
    NPCTraits[NPCID_BIG_BULLET].TWidth = 128; // Giant Bullet Bill
    NPCTraits[NPCID_BIG_BULLET].THeight = 128;
    NPCTraits[NPCID_BIG_BULLET].NoYoshi = true;
    NPCTraits[NPCID_BLU_GUY].TWidth = 32; // Red Shy guy
    NPCTraits[NPCID_BLU_GUY].THeight = 32;
    NPCTraits[NPCID_RED_GUY].TWidth = 32; // Blue Shy guy
    NPCTraits[NPCID_RED_GUY].THeight = 32;
    NPCTraits[NPCID_STACKER].TWidth = 32; // Cactus Thing
    NPCTraits[NPCID_STACKER].THeight = 32;
    NPCTraits[NPCID_CANNONENEMY].TWidth = 32; // Bullet Bill Shooter
    NPCTraits[NPCID_CANNONENEMY].THeight = 32;
    NPCTraits[NPCID_CANNONENEMY].NoYoshi = true;
    NPCTraits[NPCID_CANNONITEM].TWidth = 32; // Bullet Bill Gun
    NPCTraits[NPCID_CANNONITEM].THeight = 32;
    NPCTraits[NPCID_CANNONITEM].FrameOffsetY = 2;
    NPCTraits[NPCID_GLASS_TURTLE].TWidth = 32; // Hard thing
    NPCTraits[NPCID_GLASS_TURTLE].THeight = 32;
    NPCTraits[NPCID_GLASS_TURTLE].FrameOffsetY = 2;
    NPCTraits[NPCID_GLASS_SHELL].TWidth = 32; // Hard Thing shell
    NPCTraits[NPCID_GLASS_SHELL].THeight = 32;
    NPCTraits[NPCID_GLASS_SHELL].FrameOffsetY = 2;
    NPCTraits[NPCID_JUMPER_S3].TWidth = 32; // Bouncy Start Thing
    NPCTraits[NPCID_JUMPER_S3].THeight = 32;
    NPCTraits[NPCID_SPRING].TWidth = 32; // Spring
    NPCTraits[NPCID_SPRING].THeight = 32;
    NPCTraits[NPCID_SPRING].WidthGFX = 32;
    NPCTraits[NPCID_SPRING].HeightGFX = 32;
    NPCTraits[NPCID_SPRING].FrameOffsetY = 2;
    NPCTraits[NPCID_UNDER_FODDER].TWidth = 32; // Grey goomba
    NPCTraits[NPCID_UNDER_FODDER].THeight = 32;
    NPCTraits[NPCID_RED_FISH_S1].TWidth = 32; // Red Jumping Fish
    NPCTraits[NPCID_RED_FISH_S1].THeight = 32;
    NPCTraits[NPCID_HEAVY_THROWER].TWidth = 32; // Hammer Bro
    NPCTraits[NPCID_HEAVY_THROWER].THeight = 48;
    NPCTraits[NPCID_HEAVY_THROWER].FrameOffsetY = 2;
    NPCTraits[NPCID_HEAVY_THROWN].TWidth = 32; // Hammer
    NPCTraits[NPCID_HEAVY_THROWN].THeight = 32;
    NPCTraits[NPCID_HEAVY_THROWN].NoYoshi = true;
    NPCTraits[NPCID_KEY].TWidth = 32; // Key
    NPCTraits[NPCID_KEY].THeight = 32;
    NPCTraits[NPCID_KEY].FrameOffsetY = 1;
    NPCTraits[NPCID_COIN_SWITCH].TWidth = 32; // P Switch
    NPCTraits[NPCID_COIN_SWITCH].THeight = 32;
    NPCTraits[NPCID_COIN_SWITCH].FrameOffsetY = 2;
    NPCTraits[NPCID_TIME_SWITCH].TWidth = 32; // P Switch Time
    NPCTraits[NPCID_TIME_SWITCH].THeight = 32;
    NPCTraits[NPCID_TIME_SWITCH].FrameOffsetY = 2;
    NPCTraits[NPCID_TNT].TWidth = 32; // Push down thing
    NPCTraits[NPCID_TNT].THeight = 32;
    NPCTraits[NPCID_TNT].FrameOffsetY = 2;
    NPCTraits[NPCID_COIN_S4].TWidth = 24; // SMW Coin
    NPCTraits[NPCID_COIN_S4].THeight = 32;
    NPCTraits[NPCID_COIN_5].TWidth = 24; // SMW Blue Coin
    NPCTraits[NPCID_COIN_5].THeight = 32;
    NPCTraits[NPCID_LEAF_POWER].TWidth = 32; // Leaf
    NPCTraits[NPCID_LEAF_POWER].THeight = 32;
    NPCTraits[NPCID_GRN_BOOT].TWidth = 32; // Goombas Shoe
    NPCTraits[NPCID_GRN_BOOT].THeight = 32;
    NPCTraits[NPCID_GRN_BOOT].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_BOOT].FrameOffsetY = 2;
    NPCTraits[NPCID_BLU_BOOT].FrameOffsetY = 2;

    NPCTraits[NPCID_SPIKY_S4].TWidth = 32; // Spiney
    NPCTraits[NPCID_SPIKY_S4].THeight = 32;
    NPCTraits[NPCID_SPIKY_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_SPIKY_BALL_S4].TWidth = 32; // Falling Spiney
    NPCTraits[NPCID_SPIKY_BALL_S4].THeight = 32;
    NPCTraits[NPCID_SPIKY_BALL_S4].FrameOffsetY = 2;

    NPCTraits[NPCID_SPIKY_S3].TWidth = 32; // Spiney
    NPCTraits[NPCID_SPIKY_S3].THeight = 32;
    NPCTraits[NPCID_SPIKY_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_STONE_S3].TWidth = 48; // Thwomp
    NPCTraits[NPCID_STONE_S3].THeight = 64;
    NPCTraits[NPCID_STONE_S3].NoYoshi = true;
    NPCTraits[NPCID_GHOST_S3].TWidth = 32; // Boo
    NPCTraits[NPCID_GHOST_S3].THeight = 32;
    NPCTraits[NPCID_GHOST_S3].NoYoshi = true;
    NPCTraits[NPCID_SPIT_BOSS].TWidth = 32; // Birdo
    NPCTraits[NPCID_SPIT_BOSS].THeight = 60;
    NPCTraits[NPCID_SPIT_BOSS].WidthGFX = 40;
    NPCTraits[NPCID_SPIT_BOSS].HeightGFX = 72;
    NPCTraits[NPCID_SPIT_BOSS].FrameOffsetY = 2;
    NPCTraits[NPCID_SPIT_BOSS].FrameOffsetX = 3;
    NPCTraits[NPCID_SPIT_BOSS].NoYoshi = true;
    NPCTraits[NPCID_SPIT_BOSS_BALL].TWidth = 32; // egg
    NPCTraits[NPCID_SPIT_BOSS_BALL].THeight = 24;
    NPCTraits[NPCID_GOALORB_S2].TWidth = 32; // smb2 exit(birdo)
    NPCTraits[NPCID_GOALORB_S2].THeight = 32;
    NPCTraits[NPCID_GHOST_FAST].TWidth = 32; // ghost 1
    NPCTraits[NPCID_GHOST_FAST].THeight = 32;
    NPCTraits[NPCID_GHOST_FAST].NoYoshi = true;
    NPCTraits[NPCID_GHOST_S4].TWidth = 32; // ghost 2
    NPCTraits[NPCID_GHOST_S4].THeight = 32;
    NPCTraits[NPCID_GHOST_S4].NoYoshi = true;
    NPCTraits[NPCID_BIG_GHOST].TWidth = 128; // big ghost
    NPCTraits[NPCID_BIG_GHOST].THeight = 120;
    NPCTraits[NPCID_BIG_GHOST].WidthGFX = 140;
    NPCTraits[NPCID_BIG_GHOST].HeightGFX = 128;
    NPCTraits[NPCID_BIG_GHOST].NoYoshi = true;
    NPCTraits[NPCID_SLIDE_BLOCK].TWidth = 32; // ice block
    NPCTraits[NPCID_SLIDE_BLOCK].THeight = 32;
    NPCTraits[NPCID_FALL_BLOCK_RED].TWidth = 32; // falling block
    NPCTraits[NPCID_FALL_BLOCK_RED].THeight = 32;
    NPCTraits[NPCID_FALL_BLOCK_RED].NoYoshi = true;
    NPCTraits[NPCID_FALL_BLOCK_BROWN].NoYoshi = true;
    NPCTraits[NPCID_SPIKY_THROWER].TWidth = 32; // lakitu
    NPCTraits[NPCID_SPIKY_THROWER].THeight = 48;
    NPCTraits[NPCID_SPIKY_THROWER].WidthGFX = 32;
    NPCTraits[NPCID_SPIKY_THROWER].HeightGFX = 64;
    NPCTraits[NPCID_ITEM_THROWER].TWidth = 40; // smw lakitu
    NPCTraits[NPCID_ITEM_THROWER].THeight = 48;
    NPCTraits[NPCID_ITEM_THROWER].FrameOffsetY = 6;
    NPCTraits[NPCID_ITEM_THROWER].WidthGFX = 56;
    NPCTraits[NPCID_ITEM_THROWER].HeightGFX = 72;

    NPCTraits[NPCID_SPIKY_BALL_S3].TWidth = 32; // unripe spiney
    NPCTraits[NPCID_SPIKY_BALL_S3].THeight = 32;
    NPCTraits[NPCID_TOOTHYPIPE].TWidth = 32; // killer pipe
    NPCTraits[NPCID_TOOTHYPIPE].THeight = 32;
    NPCTraits[NPCID_TOOTHYPIPE].FrameOffsetY = 2;
    NPCTraits[NPCID_TOOTHY].TWidth = 48; // killer plant
    NPCTraits[NPCID_TOOTHY].THeight = 32;
    NPCTraits[NPCID_TOOTHY].FrameOffsetY = 2;
    NPCTraits[NPCID_TOOTHY].NoYoshi = true;
    NPCTraits[NPCID_BOTTOM_PLANT].TWidth = 32; // down piranha plant
    NPCTraits[NPCID_BOTTOM_PLANT].THeight = 64;
    NPCTraits[NPCID_SIDE_PLANT].TWidth = 48; // left.right piranha plant
    NPCTraits[NPCID_SIDE_PLANT].THeight = 32;
    NPCTraits[NPCID_CRAB].TWidth = 32; // mr crabs
    NPCTraits[NPCID_CRAB].THeight = 32;
    NPCTraits[NPCID_CRAB].FrameOffsetY = 2;
    NPCTraits[NPCID_FLY].TWidth = 32; // bee thing
    NPCTraits[NPCID_FLY].THeight = 32;
    NPCTraits[NPCID_FLY].FrameOffsetY = 2;
    NPCTraits[NPCID_EXT_TURTLE].TWidth = 32; // nekkid koopa
    NPCTraits[NPCID_EXT_TURTLE].THeight = 32;
    NPCTraits[NPCID_EXT_TURTLE].FrameOffsetY = 2;
    NPCTraits[NPCID_VEHICLE].TWidth = 128; // koopa clown car
    NPCTraits[NPCID_VEHICLE].THeight = 128;
    NPCTraits[NPCID_VEHICLE].NoYoshi = true;
    NPCTraits[NPCID_CONVEYOR].TWidth = 32; // smb3 conveyer belt
    NPCTraits[NPCID_CONVEYOR].THeight = 32;
    NPCTraits[NPCID_CONVEYOR].NoYoshi = true;
    NPCTraits[NPCID_METALBARREL].TWidth = 32; // smb3 barrel
    NPCTraits[NPCID_METALBARREL].THeight = 32;
    NPCTraits[NPCID_METALBARREL].NoYoshi = true;
    NPCTraits[NPCID_YELSWITCH_FODDER].TWidth = 32; // purple goomba
    NPCTraits[NPCID_YELSWITCH_FODDER].THeight = 32;
    NPCTraits[NPCID_YELSWITCH_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_YEL_PLATFORM].TWidth = 96; // purple platform
    NPCTraits[NPCID_YEL_PLATFORM].THeight = 32;
    NPCTraits[NPCID_YEL_PLATFORM].NoYoshi = true;
    NPCTraits[NPCID_BLUSWITCH_FODDER].TWidth = 32; // blue goomba
    NPCTraits[NPCID_BLUSWITCH_FODDER].THeight = 32;
    NPCTraits[NPCID_BLUSWITCH_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_BLU_PLATFORM].TWidth = 96; // blue platform
    NPCTraits[NPCID_BLU_PLATFORM].THeight = 32;
    NPCTraits[NPCID_BLU_PLATFORM].NoYoshi = true;
    NPCTraits[NPCID_GRNSWITCH_FODDER].TWidth = 32; // green goomba
    NPCTraits[NPCID_GRNSWITCH_FODDER].THeight = 32;
    NPCTraits[NPCID_GRNSWITCH_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_GRN_PLATFORM].TWidth = 96; // green platform
    NPCTraits[NPCID_GRN_PLATFORM].THeight = 32;
    NPCTraits[NPCID_GRN_PLATFORM].NoYoshi = true;
    NPCTraits[NPCID_REDSWITCH_FODDER].TWidth = 32; // red goomba
    NPCTraits[NPCID_REDSWITCH_FODDER].THeight = 32;
    NPCTraits[NPCID_REDSWITCH_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_PLATFORM].TWidth = 96; // red platform
    NPCTraits[NPCID_RED_PLATFORM].THeight = 32;
    NPCTraits[NPCID_RED_PLATFORM].NoYoshi = true;
    NPCTraits[NPCID_HPIPE_SHORT].TWidth = 128; // grey pipe x
    NPCTraits[NPCID_HPIPE_SHORT].THeight = 32;
    NPCTraits[NPCID_HPIPE_SHORT].NoYoshi = true;
    NPCTraits[NPCID_HPIPE_LONG].TWidth = 256; // big grey pipe x
    NPCTraits[NPCID_HPIPE_LONG].THeight = 32;
    NPCTraits[NPCID_HPIPE_LONG].NoYoshi = true;
    NPCTraits[NPCID_VPIPE_SHORT].TWidth = 32; // grey pipe y
    NPCTraits[NPCID_VPIPE_SHORT].THeight = 128; // NOTE: was set to 127 until v1.3.7.2, due to different semantics for the implicit cast of 127.9 to int between VB6 and C++
    NPCTraits[NPCID_VPIPE_SHORT].NoYoshi = true;
    NPCTraits[NPCID_VPIPE_LONG].TWidth = 32; // big grey pipe y
    NPCTraits[NPCID_VPIPE_LONG].THeight = 256; // NOTE: was set to 255 until v1.3.7.2, due to different semantics for the implicit cast of 127.9 to int between VB6 and C++
    NPCTraits[NPCID_VPIPE_LONG].NoYoshi = true;
    NPCTraits[NPCID_BIG_FODDER].TWidth = 48; // giant goomba
    NPCTraits[NPCID_BIG_FODDER].THeight = 46;
    NPCTraits[NPCID_BIG_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_BIG_TURTLE].TWidth = 48; // giant green koopa
    NPCTraits[NPCID_BIG_TURTLE].THeight = 48;
    NPCTraits[NPCID_BIG_TURTLE].FrameOffsetY = 2;
    NPCTraits[NPCID_BIG_TURTLE].WidthGFX = 48;
    NPCTraits[NPCID_BIG_TURTLE].HeightGFX = 62;
    NPCTraits[NPCID_BIG_SHELL].TWidth = 44; // giant green shell
    NPCTraits[NPCID_BIG_SHELL].THeight = 44;
    NPCTraits[NPCID_BIG_SHELL].FrameOffsetY = 2;
    NPCTraits[NPCID_BIG_PLANT].TWidth = 48; // giant pirhana plant
    NPCTraits[NPCID_BIG_PLANT].THeight = 64;
    NPCTraits[NPCID_BIG_PLANT].FrameOffsetY = 2;

    NPCTraits[NPCID_LONG_PLANT_UP].TWidth = 48; // gianter pirhana plant
    NPCTraits[NPCID_LONG_PLANT_UP].THeight = 128;
    NPCTraits[NPCID_LONG_PLANT_UP].FrameOffsetY = 2;

    NPCTraits[NPCID_LONG_PLANT_DOWN].TWidth = 48; // gianter pirhana plant
    NPCTraits[NPCID_LONG_PLANT_DOWN].THeight = 128;

    NPCTraits[NPCID_CIVILIAN_SCARED].TWidth = 38; // toad
    NPCTraits[NPCID_CIVILIAN_SCARED].THeight = 54;
    NPCTraits[NPCID_CIVILIAN_SCARED].FrameOffsetY = 2;
    NPCTraits[NPCID_CIVILIAN_SCARED].WidthGFX = 38;
    NPCTraits[NPCID_CIVILIAN_SCARED].HeightGFX = 58;
    // NPCIsToad(NPCID_CIVILIAN_SCARED) = true;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S3].TWidth = 32; // flying green koopa
    NPCTraits[NPCID_GRN_FLY_TURTLE_S3].THeight = 32;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S3].WidthGFX = 32;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S3].HeightGFX = 56;
    // NPCIsAParaTroopa(NPCID_GRN_FLY_TURTLE_S3) = true;
    NPCTraits[NPCID_RED_FLY_TURTLE_S3].TWidth = 32; // flying red koopa
    NPCTraits[NPCID_RED_FLY_TURTLE_S3].THeight = 32;
    NPCTraits[NPCID_RED_FLY_TURTLE_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_FLY_TURTLE_S3].WidthGFX = 32;
    NPCTraits[NPCID_RED_FLY_TURTLE_S3].HeightGFX = 56;
    // NPCIsAParaTroopa(NPCID_RED_FLY_TURTLE_S3) = true;
    NPCTraits[NPCID_JUMPER_S4].TWidth = 32; // black ninja
    NPCTraits[NPCID_JUMPER_S4].THeight = 32;
    NPCTraits[NPCID_BIG_SHELL].FrameOffsetY = 2;
    NPCTraits[NPCID_TANK_TREADS].TWidth = 128; // tank treads
    NPCTraits[NPCID_TANK_TREADS].THeight = 32;
    NPCTraits[NPCID_TANK_TREADS].NoYoshi = true;
    NPCTraits[NPCID_SHORT_WOOD].TWidth = 64; // tank parts
    NPCTraits[NPCID_SHORT_WOOD].THeight = 32;
    NPCTraits[NPCID_SHORT_WOOD].NoYoshi = true;
    NPCTraits[NPCID_LONG_WOOD].TWidth = 128; // tank parts
    NPCTraits[NPCID_LONG_WOOD].THeight = 32;
    NPCTraits[NPCID_LONG_WOOD].NoYoshi = true;
    NPCTraits[NPCID_SLANT_WOOD_L].TWidth = 128; // tank parts
    NPCTraits[NPCID_SLANT_WOOD_L].THeight = 32;
    NPCTraits[NPCID_SLANT_WOOD_L].NoYoshi = true;
    NPCTraits[NPCID_SLANT_WOOD_R].TWidth = 128; // tank parts
    NPCTraits[NPCID_SLANT_WOOD_R].THeight = 32;
    NPCTraits[NPCID_SLANT_WOOD_R].NoYoshi = true;
    NPCTraits[NPCID_SLANT_WOOD_M].TWidth = 256; // tank parts
    NPCTraits[NPCID_SLANT_WOOD_M].THeight = 32;
    NPCTraits[NPCID_SLANT_WOOD_M].NoYoshi = true;
    NPCTraits[NPCID_STATUE_S3].TWidth = 32; // bowser statue
    NPCTraits[NPCID_STATUE_S3].THeight = 64;
    NPCTraits[NPCID_STATUE_S3].NoYoshi = true;
    NPCTraits[NPCID_STATUE_FIRE].TWidth = 32; // statue fireball
    NPCTraits[NPCID_STATUE_FIRE].THeight = 16;
    NPCTraits[NPCID_STATUE_FIRE].NoYoshi = true;
    NPCTraits[NPCID_VILLAIN_S3].TWidth = 62; // smb3 bowser
    NPCTraits[NPCID_VILLAIN_S3].THeight = 80;
    NPCTraits[NPCID_VILLAIN_S3].WidthGFX = 64;
    NPCTraits[NPCID_VILLAIN_S3].HeightGFX = 80;
    NPCTraits[NPCID_VILLAIN_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_VILLAIN_S3].NoYoshi = true;
    NPCTraits[NPCID_VILLAIN_FIRE].TWidth = 48; // smb3 bowser fireball
    NPCTraits[NPCID_VILLAIN_FIRE].THeight = 32;
    NPCTraits[NPCID_VILLAIN_FIRE].NoYoshi = true;
    NPCTraits[NPCID_COIN_S1].TWidth = 20; // smb1 coin
    NPCTraits[NPCID_COIN_S1].THeight = 32;
    NPCTraits[NPCID_FODDER_S1].TWidth = 32; // smb1 brown goomba
    NPCTraits[NPCID_FODDER_S1].THeight = 32;
    NPCTraits[NPCID_FODDER_S1].FrameOffsetY = 2;
    NPCTraits[NPCID_LIFE_S3].TWidth = 32; // 1 up
    NPCTraits[NPCID_LIFE_S3].THeight = 32;
    NPCTraits[NPCID_LIFE_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_LIFE_S3].IsAHit1Block = true;
    NPCTraits[NPCID_ITEM_BURIED].TWidth = 32; // grab grass
    NPCTraits[NPCID_ITEM_BURIED].THeight = 16;
    NPCTraits[NPCID_ITEM_BURIED].FrameOffsetY = -16;
    NPCTraits[NPCID_VEGGIE_1].TWidth = 32; // turnip
    NPCTraits[NPCID_VEGGIE_1].THeight = 32;
    // NPCIsVeggie(NPCID_VEGGIE_1) = true;
    NPCTraits[NPCID_PLANT_S1].TWidth = 32; // SMB1 Plant
    NPCTraits[NPCID_PLANT_S1].THeight = 48;
    NPCTraits[NPCID_CIVILIAN].TWidth = 32; // Inert Toad
    NPCTraits[NPCID_CIVILIAN].THeight = 54;

    NPCTraits[NPCID_CHAR3].TWidth = 32; // Peach
    NPCTraits[NPCID_CHAR3].THeight = 64;
    NPCTraits[NPCID_CHAR3].FrameOffsetY = 2;
    NPCTraits[NPCID_CIVILIAN].FrameOffsetY = 2;
    // NPCIsToad(NPCID_CIVILIAN) = true;
    // NPCIsToad(NPCID_CHAR3) = true;
    NPCTraits[NPCID_PET_GREEN].TWidth = 32; // Green Yoshi
    NPCTraits[NPCID_PET_GREEN].THeight = 32;
    NPCTraits[NPCID_PET_GREEN].WidthGFX = 74;
    NPCTraits[NPCID_PET_GREEN].HeightGFX = 56;
    NPCTraits[NPCID_PET_GREEN].FrameOffsetY = 2;
    NPCTraits[NPCID_PET_GREEN].NoYoshi = true;
    NPCTraits[NPCID_ITEM_POD].TWidth = 32; // Yoshi Egg
    NPCTraits[NPCID_ITEM_POD].THeight = 32;
    NPCTraits[NPCID_STAR_EXIT].TWidth = 32; // SMB3 Star
    NPCTraits[NPCID_STAR_EXIT].THeight = 32;
    NPCTraits[NPCID_PET_BLUE].TWidth = 32; // Blue Yoshi
    NPCTraits[NPCID_PET_BLUE].THeight = 32;
    NPCTraits[NPCID_PET_BLUE].WidthGFX = 74;
    NPCTraits[NPCID_PET_BLUE].HeightGFX = 56;
    NPCTraits[NPCID_PET_BLUE].FrameOffsetY = 2;
    NPCTraits[NPCID_PET_YELLOW].TWidth = 32; // Yellow Yoshi
    NPCTraits[NPCID_PET_YELLOW].THeight = 32;
    NPCTraits[NPCID_PET_YELLOW].WidthGFX = 74;
    NPCTraits[NPCID_PET_YELLOW].HeightGFX = 56;
    NPCTraits[NPCID_PET_YELLOW].FrameOffsetY = 2;
    NPCTraits[NPCID_PET_RED].TWidth = 32; // Red Yoshi
    NPCTraits[NPCID_PET_RED].THeight = 32;
    NPCTraits[NPCID_PET_RED].WidthGFX = 74;
    NPCTraits[NPCID_PET_RED].HeightGFX = 56;
    NPCTraits[NPCID_PET_RED].FrameOffsetY = 2;
    NPCTraits[NPCID_CHAR2].TWidth = 28; // Luigi
    NPCTraits[NPCID_CHAR2].THeight = 62;
    NPCTraits[NPCID_CHAR2].FrameOffsetY = 2;
    // NPCIsToad(NPCID_CHAR2) = true;
    NPCTraits[NPCID_CHAR5].TWidth = 32; // Link
    NPCTraits[NPCID_CHAR5].THeight = 64;
    NPCTraits[NPCID_CHAR5].FrameOffsetY = 2;
    // NPCIsToad(NPCID_CHAR5) = true;
    NPCTraits[NPCID_RED_COIN].TWidth = 28; // SMB3 Red Coin
    NPCTraits[NPCID_RED_COIN].THeight = 32;
    NPCTraits[NPCID_PLATFORM_S3].TWidth = 96; // SMB3 Platform
    NPCTraits[NPCID_PLATFORM_S3].THeight = 32;
    NPCTraits[NPCID_PLATFORM_S3].NoYoshi = true;
    NPCTraits[NPCID_CHECKER_PLATFORM].TWidth = 128; // SMW Falling Platform
    NPCTraits[NPCID_CHECKER_PLATFORM].THeight = 22;
    NPCTraits[NPCID_CHECKER_PLATFORM].NoYoshi = true;
    NPCTraits[NPCID_PLATFORM_S1].TWidth = 128; // SMB Platform
    NPCTraits[NPCID_PLATFORM_S1].THeight = 16;
    NPCTraits[NPCID_PLATFORM_S1].NoYoshi = true;
    NPCTraits[NPCID_PINK_CIVILIAN].TWidth = 24; // Bob-omb buddy
    NPCTraits[NPCID_PINK_CIVILIAN].THeight = 38;
    NPCTraits[NPCID_PINK_CIVILIAN].WidthGFX = 48;
    NPCTraits[NPCID_PINK_CIVILIAN].HeightGFX = 38;
    NPCTraits[NPCID_PINK_CIVILIAN].FrameOffsetY = 2;
    // NPCIsToad(NPCID_PINK_CIVILIAN) = true;
    NPCTraits[NPCID_PET_FIRE].TWidth = 32; // Yoshi Fireball
    NPCTraits[NPCID_PET_FIRE].THeight = 32;
    NPCTraits[NPCID_PET_FIRE].NoYoshi = true;
    NPCTraits[NPCID_GRN_TURTLE_S4].TWidth = 32; // SMW Green Koopa
    NPCTraits[NPCID_GRN_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_GRN_TURTLE_S4].WidthGFX = 32;
    NPCTraits[NPCID_GRN_TURTLE_S4].HeightGFX = 54;
    NPCTraits[NPCID_GRN_TURTLE_S4].FrameOffsetY = 2;
    // NPCDefaultMovement(NPCID_GRN_TURTLE_S4) = true;
    NPCTraits[NPCID_RED_TURTLE_S4].TWidth = 32; // SMW Red Koopa
    NPCTraits[NPCID_RED_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_RED_TURTLE_S4].WidthGFX = 32;
    NPCTraits[NPCID_RED_TURTLE_S4].HeightGFX = 54;
    NPCTraits[NPCID_RED_TURTLE_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_TURTLE_S4].TurnsAtCliffs = true;
    // NPCDefaultMovement(NPCID_RED_TURTLE_S4) = true;
    NPCTraits[NPCID_BLU_TURTLE_S4].TWidth = 32; // SMW Blue Koopa
    NPCTraits[NPCID_BLU_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_BLU_TURTLE_S4].WidthGFX = 32;
    NPCTraits[NPCID_BLU_TURTLE_S4].HeightGFX = 54;
    NPCTraits[NPCID_BLU_TURTLE_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_BLU_TURTLE_S4].TurnsAtCliffs = true;
    // NPCDefaultMovement(NPCID_BLU_TURTLE_S4) = true;
    NPCTraits[NPCID_YEL_TURTLE_S4].TWidth = 32; // SMW Yellow Koopa
    NPCTraits[NPCID_YEL_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_YEL_TURTLE_S4].WidthGFX = 32;
    NPCTraits[NPCID_YEL_TURTLE_S4].HeightGFX = 54;
    NPCTraits[NPCID_YEL_TURTLE_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_YEL_TURTLE_S4].TurnsAtCliffs = true;
    // NPCDefaultMovement(NPCID_YEL_TURTLE_S4) = true;
    NPCTraits[NPCID_GRN_SHELL_S4].TWidth = 32; // SMW Green Shell
    NPCTraits[NPCID_GRN_SHELL_S4].THeight = 32;
    NPCTraits[NPCID_GRN_SHELL_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_GRN_SHELL_S4].IsAShell = true;
    NPCTraits[NPCID_RED_SHELL_S4].TWidth = 32; // SMW Red Shell
    NPCTraits[NPCID_RED_SHELL_S4].THeight = 32;
    NPCTraits[NPCID_RED_SHELL_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_SHELL_S4].IsAShell = true;
    NPCTraits[NPCID_BLU_SHELL_S4].TWidth = 32; // SMW Blue Shell
    NPCTraits[NPCID_BLU_SHELL_S4].THeight = 32;
    NPCTraits[NPCID_BLU_SHELL_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_BLU_SHELL_S4].IsAShell = true;
    NPCTraits[NPCID_YEL_SHELL_S4].TWidth = 32; // SMW Yellow Shell
    NPCTraits[NPCID_YEL_SHELL_S4].THeight = 32;
    NPCTraits[NPCID_YEL_SHELL_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_YEL_SHELL_S4].IsAShell = true;
    NPCTraits[NPCID_GRN_HIT_TURTLE_S4].TWidth = 32; // SMW Green Beach Koopa
    NPCTraits[NPCID_GRN_HIT_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_GRN_HIT_TURTLE_S4].FrameOffsetY = 2;
    // NPCDefaultMovement(NPCID_GRN_HIT_TURTLE_S4) = true;
    NPCTraits[NPCID_RED_HIT_TURTLE_S4].TWidth = 32; // SMW Red Beach Koopa
    NPCTraits[NPCID_RED_HIT_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_RED_HIT_TURTLE_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_RED_HIT_TURTLE_S4].TurnsAtCliffs = true;
    // NPCDefaultMovement(NPCID_RED_HIT_TURTLE_S4) = true;
    NPCTraits[NPCID_BLU_HIT_TURTLE_S4].TWidth = 32; // SMW Blue Beach Koopa
    NPCTraits[NPCID_BLU_HIT_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_BLU_HIT_TURTLE_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_BLU_HIT_TURTLE_S4].TurnsAtCliffs = true;
    // NPCDefaultMovement(NPCID_BLU_HIT_TURTLE_S4) = true;
    NPCTraits[NPCID_YEL_HIT_TURTLE_S4].TWidth = 32; // SMW Yellow Beach Koopa
    NPCTraits[NPCID_YEL_HIT_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_YEL_HIT_TURTLE_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_YEL_HIT_TURTLE_S4].TurnsAtCliffs = true;
    // NPCDefaultMovement(NPCID_YEL_HIT_TURTLE_S4) = true;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S4].TWidth = 32; // SMW Green Para-Koopa
    NPCTraits[NPCID_GRN_FLY_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S4].WidthGFX = 56;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S4].HeightGFX = 56;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S4].FrameOffsetY = 2;
    // NPCIsAParaTroopa(NPCID_GRN_FLY_TURTLE_S4) = true;
    NPCTraits[NPCID_RED_FLY_TURTLE_S4].TWidth = 32; // SMW Red Para-Koopa
    NPCTraits[NPCID_RED_FLY_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_RED_FLY_TURTLE_S4].WidthGFX = 56;
    NPCTraits[NPCID_RED_FLY_TURTLE_S4].HeightGFX = 56;
    NPCTraits[NPCID_RED_FLY_TURTLE_S4].FrameOffsetY = 2;
    // NPCIsAParaTroopa(NPCID_RED_FLY_TURTLE_S4) = true;
    NPCTraits[NPCID_BLU_FLY_TURTLE_S4].TWidth = 32; // SMW Blue Para-Koopa
    NPCTraits[NPCID_BLU_FLY_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_BLU_FLY_TURTLE_S4].WidthGFX = 56;
    NPCTraits[NPCID_BLU_FLY_TURTLE_S4].HeightGFX = 56;
    NPCTraits[NPCID_BLU_FLY_TURTLE_S4].FrameOffsetY = 2;
    // NPCIsAParaTroopa(NPCID_BLU_FLY_TURTLE_S4) = true;
    NPCTraits[NPCID_YEL_FLY_TURTLE_S4].TWidth = 32; // SMW Yellow Para-Koopa
    NPCTraits[NPCID_YEL_FLY_TURTLE_S4].THeight = 32;
    NPCTraits[NPCID_YEL_FLY_TURTLE_S4].WidthGFX = 56;
    NPCTraits[NPCID_YEL_FLY_TURTLE_S4].HeightGFX = 56;
    NPCTraits[NPCID_YEL_FLY_TURTLE_S4].FrameOffsetY = 2;
    // NPCIsAParaTroopa(NPCID_YEL_FLY_TURTLE_S4) = true;
    NPCTraits[NPCID_KNIGHT].TWidth = 36; // Rat Head
    NPCTraits[NPCID_KNIGHT].THeight = 56;
    NPCTraits[NPCID_KNIGHT].WidthGFX = 36;
    NPCTraits[NPCID_KNIGHT].HeightGFX = 66;
    NPCTraits[NPCID_KNIGHT].FrameOffsetY = 2;
    NPCTraits[NPCID_WALK_PLANT].JumpHurt = true;
    NPCTraits[NPCID_WALK_PLANT].NoFireBall = true;
    NPCTraits[NPCID_BULLET].NoFireBall = true;
    // NPCDefaultMovement(NPCID_KNIGHT) = true;
    NPCTraits[NPCID_KNIGHT].NoYoshi = true;
    NPCTraits[NPCID_BLU_SLIME].TWidth = 32; // Blue Bot
    NPCTraits[NPCID_BLU_SLIME].THeight = 34;
    NPCTraits[NPCID_BLU_SLIME].WidthGFX = 32;
    NPCTraits[NPCID_BLU_SLIME].HeightGFX = 26;
    // NPCIsABot(NPCID_BLU_SLIME) = true;
    NPCTraits[NPCID_CYAN_SLIME].TWidth = 32; // Cyan Bot
    NPCTraits[NPCID_CYAN_SLIME].THeight = 34;
    NPCTraits[NPCID_CYAN_SLIME].WidthGFX = 32;
    NPCTraits[NPCID_CYAN_SLIME].HeightGFX = 26;
    // NPCIsABot(NPCID_CYAN_SLIME) = true;
    NPCTraits[NPCID_RED_SLIME].TWidth = 32; // Red Bot
    NPCTraits[NPCID_RED_SLIME].THeight = 34;
    NPCTraits[NPCID_RED_SLIME].WidthGFX = 32;
    NPCTraits[NPCID_RED_SLIME].HeightGFX = 26;
    NPCTraits[NPCID_BIRD].TWidth = 32; // SMB2 Jumpy guy
    NPCTraits[NPCID_BIRD].THeight = 32;
    NPCTraits[NPCID_BIRD].CanWalkOn = true;
    NPCTraits[NPCID_BIRD].GrabFromTop = true;
    // NPCDefaultMovement(NPCID_BIRD) = true;
    NPCTraits[NPCID_RED_SPIT_GUY].TWidth = 32; // Red Sniffit
    NPCTraits[NPCID_RED_SPIT_GUY].THeight = 32;
    NPCTraits[NPCID_RED_SPIT_GUY].CanWalkOn = true;
    NPCTraits[NPCID_RED_SPIT_GUY].GrabFromTop = true;
    // NPCDefaultMovement(NPCID_RED_SPIT_GUY) = true;
    NPCTraits[NPCID_BLU_SPIT_GUY].TWidth = 32; // Blue Sniffit
    NPCTraits[NPCID_BLU_SPIT_GUY].THeight = 32;
    NPCTraits[NPCID_BLU_SPIT_GUY].CanWalkOn = true;
    NPCTraits[NPCID_BLU_SPIT_GUY].GrabFromTop = true;
    // NPCDefaultMovement(NPCID_BLU_SPIT_GUY) = true;
    NPCTraits[NPCID_BLU_SPIT_GUY].TurnsAtCliffs = true;
    NPCTraits[NPCID_GRY_SPIT_GUY].TWidth = 32; // Grey Sniffit
    NPCTraits[NPCID_GRY_SPIT_GUY].THeight = 32;
    NPCTraits[NPCID_GRY_SPIT_GUY].CanWalkOn = true;
    NPCTraits[NPCID_GRY_SPIT_GUY].GrabFromTop = true;
    // NPCDefaultMovement(NPCID_GRY_SPIT_GUY) = true;
    NPCTraits[NPCID_SPIT_GUY_BALL].TWidth = 16; // Bullet
    NPCTraits[NPCID_SPIT_GUY_BALL].THeight = 16;
    NPCTraits[NPCID_SPIT_GUY_BALL].NoYoshi = true;
    NPCTraits[NPCID_SPIT_GUY_BALL].JumpHurt = true;
    NPCTraits[NPCID_BOMB].TWidth = 24; // SMB2 Bomb
    NPCTraits[NPCID_BOMB].THeight = 24;
    NPCTraits[NPCID_BOMB].WidthGFX = 40;
    NPCTraits[NPCID_BOMB].HeightGFX = 40;
    NPCTraits[NPCID_BOMB].WontHurt = true;
    NPCTraits[NPCID_BOMB].IsGrabbable = true;
    NPCTraits[NPCID_BOMB].GrabFromTop = true;
    NPCTraits[NPCID_BOMB].CanWalkOn = true;
    NPCTraits[NPCID_WALK_BOMB_S2].TWidth = 32; // SMB2 Bob-om
    NPCTraits[NPCID_WALK_BOMB_S2].THeight = 32;
    NPCTraits[NPCID_WALK_BOMB_S2].GrabFromTop = true;
    NPCTraits[NPCID_WALK_BOMB_S2].CanWalkOn = true;
    // NPCDefaultMovement(NPCID_WALK_BOMB_S2) = true;
    NPCTraits[NPCID_WALK_BOMB_S3].TWidth = 32; // SMB3 Bob-om
    NPCTraits[NPCID_WALK_BOMB_S3].THeight = 32;
    NPCTraits[NPCID_WALK_BOMB_S3].FrameOffsetY = 2;
    // NPCDefaultMovement(NPCID_WALK_BOMB_S3) = true;
    NPCTraits[NPCID_WALK_BOMB_S3].TurnsAtCliffs = true;
    NPCTraits[NPCID_LIT_BOMB_S3].TWidth = 32; // SMB3 Bomb
    NPCTraits[NPCID_LIT_BOMB_S3].THeight = 28;
    NPCTraits[NPCID_LIT_BOMB_S3].FrameOffsetY = 2;
    NPCTraits[NPCID_LIT_BOMB_S3].IsGrabbable = true;
    NPCTraits[NPCID_COIN_S2].TWidth = 28; // SMB 2 Coin
    NPCTraits[NPCID_COIN_S2].THeight = 32;
    NPCTraits[NPCID_COIN_S2].IsABonus = true;
    NPCTraits[NPCID_COIN_S2].IsACoin = true;
    NPCTraits[NPCID_RING].TWidth = 32; // Sonic Ring
    NPCTraits[NPCID_RING].THeight = 32;
    NPCTraits[NPCID_RING].IsABonus = true;
    NPCTraits[NPCID_RING].IsACoin = true;
    For(A, NPCID_VEGGIE_2, NPCID_VEGGIE_RANDOM) // Veggies
    {
        NPCTraits[A].TWidth = GFXNPC[A].w;
        NPCTraits[A].THeight = GFXNPC[A].h;
        NPCTraits[A].CanWalkOn = true;
        NPCTraits[A].GrabFromTop = true;
        NPCTraits[A].WontHurt = true;
        NPCTraits[A].IsGrabbable = true;
        // NPCIsVeggie(A) = true;
    }
    NPCTraits[NPCID_PET_BLACK].TWidth = 32; // Black Yoshi
    NPCTraits[NPCID_PET_BLACK].THeight = 32;
    NPCTraits[NPCID_PET_BLACK].WidthGFX = 74;
    NPCTraits[NPCID_PET_BLACK].HeightGFX = 56;
    NPCTraits[NPCID_PET_BLACK].FrameOffsetY = 2;
    NPCTraits[NPCID_PET_BLACK].NoYoshi = true;
    NPCTraits[NPCID_PET_PURPLE].TWidth = 32; // Purple Yoshi
    NPCTraits[NPCID_PET_PURPLE].THeight = 32;
    NPCTraits[NPCID_PET_PURPLE].WidthGFX = 74;
    NPCTraits[NPCID_PET_PURPLE].HeightGFX = 56;
    NPCTraits[NPCID_PET_PURPLE].FrameOffsetY = 2;
    NPCTraits[NPCID_PET_PURPLE].NoYoshi = true;
    NPCTraits[NPCID_PET_PINK].TWidth = 32; // Pink Yoshi
    NPCTraits[NPCID_PET_PINK].THeight = 32;
    NPCTraits[NPCID_PET_PINK].WidthGFX = 74;
    NPCTraits[NPCID_PET_PINK].HeightGFX = 56;
    NPCTraits[NPCID_PET_PINK].FrameOffsetY = 2;
    NPCTraits[NPCID_PET_CYAN].TWidth = 32; // Ice Yoshi
    NPCTraits[NPCID_PET_CYAN].THeight = 32;
    NPCTraits[NPCID_PET_CYAN].WidthGFX = 74;
    NPCTraits[NPCID_PET_CYAN].HeightGFX = 56;
    NPCTraits[NPCID_PET_CYAN].FrameOffsetY = 2;
    NPCTraits[NPCID_SIGN].TWidth = 48; // SMW Sign
    NPCTraits[NPCID_SIGN].THeight = 48;
    NPCTraits[NPCID_SIGN].NoYoshi = true;
    NPCTraits[NPCID_SIGN].WontHurt = true;
    NPCTraits[NPCID_SIGN].NoClipping = true;
    NPCTraits[NPCID_CARRY_BLOCK_A].TWidth = 32; // SMB2 Mushroom Block
    NPCTraits[NPCID_CARRY_BLOCK_A].THeight = 32;
    NPCTraits[NPCID_CARRY_BLOCK_B].TWidth = 32; // SMB2 Mushroom Block
    NPCTraits[NPCID_CARRY_BLOCK_B].THeight = 32;
    NPCTraits[NPCID_CARRY_BLOCK_C].TWidth = 32; // SMB2 Mushroom Block
    NPCTraits[NPCID_CARRY_BLOCK_C].THeight = 32;
    NPCTraits[NPCID_CARRY_BLOCK_D].TWidth = 32; // SMB2 Mushroom Block
    NPCTraits[NPCID_CARRY_BLOCK_D].THeight = 32;
    NPCTraits[NPCID_CARRY_BUDDY].TWidth = 32; // Mr Saturn
    NPCTraits[NPCID_CARRY_BUDDY].THeight = 42;
    NPCTraits[NPCID_CARRY_BUDDY].FrameOffsetY = 2;
    NPCTraits[NPCID_CARRY_BUDDY].JumpHurt = true;
    NPCTraits[NPCID_LIFT_SAND].TWidth = 32; // Diggable Dirt
    NPCTraits[NPCID_LIFT_SAND].THeight = 32;
    NPCTraits[NPCID_ROCKET_WOOD].TWidth = 128; // Airship Rocket
    NPCTraits[NPCID_ROCKET_WOOD].THeight = 32;
    NPCTraits[NPCID_ROCKET_WOOD].WidthGFX = 316;
    NPCTraits[NPCID_ROCKET_WOOD].HeightGFX = 32;
    NPCTraits[NPCID_ROCKET_WOOD].NoYoshi = true;
    NPCTraits[NPCID_CARRY_BLOCK_A].TWidth = 32; // SMB2 Mushroom Block
    NPCTraits[NPCID_CARRY_BLOCK_A].THeight = 32;
    NPCTraits[NPCID_BRUTE].TWidth = 32; // SMW Rex
    NPCTraits[NPCID_BRUTE].THeight = 60;
    NPCTraits[NPCID_BRUTE].WidthGFX = 40;
    NPCTraits[NPCID_BRUTE].HeightGFX = 64;
    NPCTraits[NPCID_BRUTE].FrameOffsetY = 2;
    NPCTraits[NPCID_BRUTE_SQUISHED].TWidth = 32; // SMW Rex Smashed
    NPCTraits[NPCID_BRUTE_SQUISHED].THeight = 32;
    NPCTraits[NPCID_BRUTE_SQUISHED].WidthGFX = 32;
    NPCTraits[NPCID_BRUTE_SQUISHED].HeightGFX = 32;
    NPCTraits[NPCID_BRUTE_SQUISHED].FrameOffsetY = 2;
    NPCTraits[NPCID_BIG_GUY].TWidth = 58; // SMW Mega Mole
    NPCTraits[NPCID_BIG_GUY].THeight = 58;
    NPCTraits[NPCID_BIG_GUY].WidthGFX = 64;
    NPCTraits[NPCID_BIG_GUY].HeightGFX = 64;
    NPCTraits[NPCID_BIG_GUY].FrameOffsetY = 2;
    NPCTraits[NPCID_CARRY_FODDER].TWidth = 32; // SMW Goomba
    NPCTraits[NPCID_CARRY_FODDER].THeight = 32;
    NPCTraits[NPCID_CARRY_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_HIT_CARRY_FODDER].TWidth = 32; // SMW Stomped Goomba Goomba
    NPCTraits[NPCID_HIT_CARRY_FODDER].THeight = 32;
    NPCTraits[NPCID_HIT_CARRY_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_FLY_CARRY_FODDER].TWidth = 32; // SMW Para-Goomba
    NPCTraits[NPCID_FLY_CARRY_FODDER].THeight = 32;
    NPCTraits[NPCID_FLY_CARRY_FODDER].WidthGFX = 66;
    NPCTraits[NPCID_FLY_CARRY_FODDER].HeightGFX = 50;
    NPCTraits[NPCID_FLY_CARRY_FODDER].FrameOffsetY = 2;
    NPCTraits[NPCID_CHASER].TWidth = 26; // Bully
    NPCTraits[NPCID_CHASER].THeight = 30;
    NPCTraits[NPCID_CHASER].WidthGFX = 26;
    NPCTraits[NPCID_CHASER].HeightGFX = 46;
    NPCTraits[NPCID_CHASER].FrameOffsetY = 2;
    NPCTraits[NPCID_STATUE_POWER].TWidth = 32; // Tanooki Suit
    NPCTraits[NPCID_STATUE_POWER].THeight = 32;
    NPCTraits[NPCID_STATUE_POWER].FrameOffsetY = 2;
    NPCTraits[NPCID_STATUE_POWER].IsABonus = true;
    NPCTraits[NPCID_HEAVY_POWER].TWidth = 32; // Hammer Suit
    NPCTraits[NPCID_HEAVY_POWER].THeight = 32;
    NPCTraits[NPCID_HEAVY_POWER].FrameOffsetY = 2;
    NPCTraits[NPCID_HEAVY_POWER].IsABonus = true;

    NPCTraits[NPCID_CHAR4_HEAVY].WontHurt = true; // Boomerang
    NPCTraits[NPCID_CHAR4_HEAVY].JumpHurt = true;
    NPCTraits[NPCID_CHAR4_HEAVY].NoClipping = true;
    NPCTraits[NPCID_CHAR4_HEAVY].NoYoshi = true;
    NPCTraits[NPCID_CHAR4_HEAVY].Foreground = true;
    NPCTraits[NPCID_CHAR4_HEAVY].NoIceBall = true;

    NPCTraits[NPCID_STACKER].NoIceBall = true;

    NPCTraits[NPCID_PLR_HEAVY].TWidth = 16; // Hammer Suit Hammer
    NPCTraits[NPCID_PLR_HEAVY].THeight = 28;
    NPCTraits[NPCID_PLR_HEAVY].WontHurt = true;
    NPCTraits[NPCID_PLR_HEAVY].NoClipping = true;
    NPCTraits[NPCID_PLR_HEAVY].NoYoshi = true;

    NPCTraits[NPCID_GRN_SHELL_S1].THeight = 28; //  Green SMB1 Shell
    NPCTraits[NPCID_GRN_SHELL_S1].IsAShell = true;
    NPCTraits[NPCID_RED_SHELL_S1].THeight = 28; //  Red SMB1 Shell
    NPCTraits[NPCID_RED_SHELL_S1].IsAShell = true;
    NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].IsAShell = true;

    NPCTraits[NPCID_SAW].JumpHurt = true; // Razor Blade
    NPCTraits[NPCID_SAW].WidthGFX = 64;
    NPCTraits[NPCID_SAW].HeightGFX = 64;
    NPCTraits[NPCID_SAW].TWidth = 48;
    NPCTraits[NPCID_SAW].THeight = 48;
    NPCTraits[NPCID_SAW].FrameOffsetY = 8;
    NPCTraits[NPCID_STONE_S4].JumpHurt = true; // SMW Thwomp
    NPCTraits[NPCID_STONE_S4].TWidth = 48;
    NPCTraits[NPCID_STONE_S4].THeight = 64;
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].TWidth = 32; // POW
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].THeight = 32; // POW
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].CanWalkOn = true;
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].MovesPlayer = true;
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].WontHurt = true;
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].IsABlock = true;
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].GrabFromTop = true;
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].IsGrabbable = true;

    NPCTraits[NPCID_STATUE_S4].WontHurt = true; // SMW Bowser Statue
    NPCTraits[NPCID_STATUE_S4].IsABlock = true;
    NPCTraits[NPCID_STATUE_S4].CanWalkOn = true;
    NPCTraits[NPCID_STATUE_S4].MovesPlayer = true;
    NPCTraits[NPCID_STATUE_S4].TWidth = 48;
    NPCTraits[NPCID_STATUE_S4].THeight = 46;
    NPCTraits[NPCID_STATUE_S4].FrameOffsetY = 2;
    NPCTraits[NPCID_GOALTAPE].TWidth = 48;
    NPCTraits[NPCID_GOALTAPE].THeight = 16;
    NPCTraits[NPCID_GOALTAPE].IsABonus = true;
    NPCTraits[NPCID_FIRE_POWER_S1].IsABonus = true; // SMB1 Flower
    NPCTraits[NPCID_FIRE_POWER_S4].IsABonus = true; // SMW Flower
    NPCTraits[NPCID_POWER_S1].IsABonus = true; // SMB1 Mushroom
    NPCTraits[NPCID_POWER_S4].IsABonus = true; // SMW Mushroom
    NPCTraits[NPCID_LIFE_S1].IsABonus = true; // SMB1 1-up
    NPCTraits[NPCID_LIFE_S4].IsABonus = true; // SMW 1-up
    NPCTraits[NPCID_3_LIFE].IsABonus = true; // SMW 3 up
    NPCTraits[NPCID_3_LIFE].TWidth = 30;
    NPCTraits[NPCID_SKELETON].TWidth = 32;

    NPCTraits[NPCID_SICK_BOSS].NoYoshi = true;
    NPCTraits[NPCID_SICK_BOSS_BALL].NoYoshi = true;
    NPCTraits[NPCID_SICK_BOSS_BALL].JumpHurt = true;
    NPCTraits[NPCID_SICK_BOSS].TWidth = 80;
    NPCTraits[NPCID_SICK_BOSS].THeight = 94;

    NPCTraits[NPCID_LAVA_MONSTER].TWidth = 56;
    NPCTraits[NPCID_LAVA_MONSTER].THeight = 60;
    NPCTraits[NPCID_LAVA_MONSTER].WidthGFX = 130;
    NPCTraits[NPCID_LAVA_MONSTER].HeightGFX = 64;
    NPCTraits[NPCID_LAVA_MONSTER].JumpHurt = true;
    NPCTraits[NPCID_LAVA_MONSTER].NoClipping = true;
    NPCTraits[NPCID_FLIER].NoYoshi = true;
    NPCTraits[NPCID_ROCKET_FLIER].NoYoshi = true;
    NPCTraits[NPCID_WALL_BUG].NoYoshi = true;
    NPCTraits[NPCID_WALL_SPARK].NoYoshi = true;

    NPCTraits[NPCID_FLIER].TWidth = 46;
    NPCTraits[NPCID_FLIER].THeight = 26;
    NPCTraits[NPCID_FLIER].NoYoshi = true;
    NPCTraits[NPCID_FLIER].CanWalkOn = true;
    NPCTraits[NPCID_ROCKET_FLIER].NoYoshi = true;
    NPCTraits[NPCID_ROCKET_FLIER].CanWalkOn = true;
    NPCTraits[NPCID_SICK_BOSS].JumpHurt = true;

    NPCTraits[NPCID_BOSS_CASE].NoYoshi = true;
    NPCTraits[NPCID_BOSS_FRAGILE].NoYoshi = true;
    NPCTraits[NPCID_BOSS_FRAGILE].CanWalkOn = true;
    NPCTraits[NPCID_BOSS_FRAGILE].MovesPlayer = true;
    NPCTraits[NPCID_BOSS_FRAGILE].IsABlock = true;
    NPCTraits[NPCID_BOSS_FRAGILE].NoClipping = true;
    NPCTraits[NPCID_BOSS_FRAGILE].TWidth = 96;
    NPCTraits[NPCID_BOSS_FRAGILE].THeight = 106;

    NPCTraits[NPCID_SICK_BOSS_BALL].NoYoshi = true;
    NPCTraits[NPCID_SICK_BOSS].NoYoshi = true;
    NPCTraits[NPCID_VILLAIN_S1].NoYoshi = true;

    NPCTraits[NPCID_SKELETON].WidthGFX = 48;
    NPCTraits[NPCID_SKELETON].HeightGFX = 64;
    NPCTraits[NPCID_SKELETON].THeight = 64;
    NPCTraits[NPCID_SKELETON].TurnsAtCliffs = true;
    NPCTraits[NPCID_SKELETON].FrameOffsetY = 2;
    // NPCDefaultMovement(189) = true;
    NPCTraits[NPCID_RED_TURTLE_S1].WidthGFX = 32;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S1].WidthGFX = 32;
    NPCTraits[NPCID_RED_FLY_TURTLE_S1].WidthGFX = 32;
    NPCTraits[NPCID_GRN_TURTLE_S1].WidthGFX = 32;
    NPCTraits[NPCID_RED_TURTLE_S1].HeightGFX = 48;
    NPCTraits[NPCID_GRN_FLY_TURTLE_S1].HeightGFX = 48;
    NPCTraits[NPCID_RED_FLY_TURTLE_S1].HeightGFX = 48;
    NPCTraits[NPCID_GRN_TURTLE_S1].HeightGFX = 48;

    NPCTraits[NPCID_RAFT].WidthGFX = 32;
    NPCTraits[NPCID_RAFT].HeightGFX = 32;

    NPCTraits[NPCID_BONE_FISH].TWidth = 48;

    NPCTraits[NPCID_SQUID_S1].HeightGFX = 48;
    NPCTraits[NPCID_SQUID_S1].WidthGFX = 32;
    NPCTraits[NPCID_SQUID_S1].FrameOffsetY = 16;

    NPCTraits[NPCID_SQUID_S1].JumpHurt = true;
    NPCTraits[NPCID_BONE_FISH].JumpHurt = true;

    NPCTraits[NPCID_RAFT].THeight = 20;
    NPCTraits[NPCID_RAFT].FrameOffsetY = 12;
    NPCTraits[NPCID_RAINBOW_SHELL].FrameOffsetY = 2;

    NPCTraits[NPCID_RAFT].MovesPlayer = true;

    NPCTraits[NPCID_RED_TURTLE_S1].TurnsAtCliffs = true;

    NPCTraits[NPCID_AXE].NoYoshi = true;
    NPCTraits[NPCID_SAW].NoYoshi = true;
    NPCTraits[NPCID_STONE_S4].NoYoshi = true;
    NPCTraits[NPCID_STATUE_S4].NoYoshi = true;
    NPCTraits[NPCID_SKELETON].NoYoshi = true;

    NPCTraits[NPCID_RAFT].NoYoshi = true;
    NPCTraits[NPCID_CHECKPOINT].NoYoshi = true;
    NPCTraits[NPCID_CHECKPOINT].IsABonus = true;



    // NPCIsAParaTroopa(NPCID_GRN_FLY_TURTLE_S1) = true;
    // NPCIsAParaTroopa(NPCID_RED_FLY_TURTLE_S1) = true;
    NPCTraits[NPCID_AXE].IsABonus = true;
    // NPCDefaultMovement(NPCID_GRN_TURTLE_S1) = true;
    // NPCDefaultMovement(NPCID_RED_TURTLE_S1) = true;
    // NPCDefaultMovement(NPCID_BRUTE) = true;
    // 'NPCDefaultMovement(NPCID_BRUTE_SQUISHED) = true;
    // 'NPCDefaultMovement(NPCID_BIG_GUY) = true;
    // NPCDefaultMovement(NPCID_CARRY_FODDER) = true;
    // NPCDefaultMovement(NPCID_FLY_CARRY_FODDER) = true;
    NPCTraits[NPCID_BIG_GUY].CanWalkOn = true;
    NPCTraits[NPCID_BIG_GUY].IsAHit1Block = true;
    NPCTraits[NPCID_ROCKET_WOOD].WontHurt = true;
    NPCTraits[NPCID_HIT_CARRY_FODDER].WontHurt = true;
    NPCTraits[NPCID_ROCKET_WOOD].CanWalkOn = true;
    NPCTraits[NPCID_ROCKET_WOOD].MovesPlayer = true;
    NPCTraits[NPCID_ROCKET_WOOD].IsABlock = true;
    // NPCDefaultMovement(NPCID_ROCKET_WOOD) = true;
    NPCTraits[NPCID_LIFT_SAND].WontHurt = true;
    NPCTraits[NPCID_LIFT_SAND].CanWalkOn = true;
    NPCTraits[NPCID_LIFT_SAND].IsAHit1Block = true;
    NPCTraits[NPCID_LIFT_SAND].GrabFromTop = true;
    NPCTraits[NPCID_CARRY_BLOCK_A].WontHurt = true;
    NPCTraits[NPCID_CARRY_BLOCK_A].CanWalkOn = true;
    NPCTraits[NPCID_CARRY_BLOCK_A].IsABlock = true;
    NPCTraits[NPCID_CARRY_BLOCK_A].MovesPlayer = true;
    NPCTraits[NPCID_CARRY_BLOCK_B].WontHurt = true;
    NPCTraits[NPCID_CARRY_BLOCK_B].CanWalkOn = true;
    NPCTraits[NPCID_CARRY_BLOCK_B].IsABlock = true;
    NPCTraits[NPCID_CARRY_BLOCK_B].MovesPlayer = true;
    NPCTraits[NPCID_CARRY_BLOCK_C].WontHurt = true;
    NPCTraits[NPCID_CARRY_BLOCK_C].CanWalkOn = true;
    NPCTraits[NPCID_CARRY_BLOCK_C].IsABlock = true;
    NPCTraits[NPCID_CARRY_BLOCK_C].MovesPlayer = true;
    NPCTraits[NPCID_CARRY_BLOCK_D].WontHurt = true;
    NPCTraits[NPCID_CARRY_BLOCK_D].CanWalkOn = true;
    NPCTraits[NPCID_CARRY_BLOCK_D].IsABlock = true;
    NPCTraits[NPCID_CARRY_BLOCK_D].MovesPlayer = true;
    NPCTraits[NPCID_LIFT_SAND].NoYoshi = true;


    NPCTraits[NPCID_GOALTAPE].WontHurt = true;
    NPCTraits[NPCID_GOALTAPE].NoYoshi = true;


    NPCTraits[NPCID_CARRY_BLOCK_A].IsGrabbable = true;
    NPCTraits[NPCID_HIT_CARRY_FODDER].IsGrabbable = true;
    NPCTraits[NPCID_CARRY_BLOCK_A].GrabFromTop = true;
    NPCTraits[NPCID_CARRY_BLOCK_B].IsGrabbable = true;
    NPCTraits[NPCID_CARRY_BLOCK_B].GrabFromTop = true;
    NPCTraits[NPCID_CARRY_BLOCK_C].IsGrabbable = true;
    NPCTraits[NPCID_CARRY_BLOCK_C].GrabFromTop = true;
    NPCTraits[NPCID_CARRY_BLOCK_D].IsGrabbable = true;
    NPCTraits[NPCID_CARRY_BLOCK_D].GrabFromTop = true;
    // NPCIsABot(NPCID_RED_SLIME) = true;
    // NPCIsYoshi(NPCID_PET_GREEN) = true;
    // NPCIsYoshi(NPCID_PET_BLUE) = true;
    // NPCIsYoshi(NPCID_PET_YELLOW) = true;
    // NPCIsYoshi(NPCID_PET_RED) = true;
    // NPCIsYoshi(NPCID_PET_BLACK) = true;
    // NPCIsYoshi(NPCID_PET_PURPLE) = true;
    // NPCIsYoshi(NPCID_PET_PINK) = true;
    // NPCIsYoshi(NPCID_PET_CYAN) = true;
    // NPCIsBoot(NPCID_GRN_BOOT) = true;
    // NPCIsBoot(NPCID_RED_BOOT) = true;
    // NPCIsBoot(NPCID_BLU_BOOT) = true;
    NPCTraits[NPCID_GRN_SHELL_S3].IsAShell = true;
    NPCTraits[NPCID_RED_SHELL_S3].IsAShell = true;
    NPCTraits[NPCID_GLASS_SHELL].IsAShell = true;
    NPCTraits[NPCID_BIG_SHELL].IsAShell = true;
    NPCTraits[NPCID_POWER_S3].IsABonus = true;
    NPCTraits[NPCID_SWAP_POWER].IsABonus = true;
    NPCTraits[NPCID_COIN_S3].IsABonus = true;
    NPCTraits[NPCID_ITEMGOAL].IsABonus = true;
    NPCTraits[NPCID_FLAG_EXIT].IsABonus = true;
    NPCTraits[NPCID_FLAG_EXIT].TFrames = 3;
    NPCTraits[NPCID_FLAG_EXIT].FrameSpeed = 8;
    NPCTraits[NPCID_FIRE_POWER_S3].IsABonus = true;
    NPCTraits[NPCID_ICE_POWER_S3].IsABonus = true;
    NPCTraits[NPCID_ICE_POWER_S4].IsABonus = true;
    NPCTraits[NPCID_GOALORB_S3].IsABonus = true;
    NPCTraits[NPCID_COIN_S4].IsABonus = true;
    NPCTraits[NPCID_COIN_5].IsABonus = true;
    NPCTraits[NPCID_LEAF_POWER].IsABonus = true;
    NPCTraits[NPCID_GOALORB_S2].IsABonus = true;
    NPCTraits[NPCID_CIVILIAN_SCARED].IsABonus = true;
    NPCTraits[NPCID_COIN_S1].IsABonus = true;
    NPCTraits[NPCID_LIFE_S3].IsABonus = true;
    NPCTraits[NPCID_CIVILIAN].IsABonus = true;
    NPCTraits[NPCID_CHAR3].IsABonus = true;
    NPCTraits[NPCID_STAR_EXIT].IsABonus = true;
    NPCTraits[NPCID_CHAR2].IsABonus = true;
    NPCTraits[NPCID_CHAR5].IsABonus = true;
    NPCTraits[NPCID_RED_COIN].IsABonus = true;
    NPCTraits[NPCID_PINK_CIVILIAN].IsABonus = true;
    NPCTraits[NPCID_POISON].IsABonus = true;
    NPCTraits[NPCID_STAR_COLLECT].IsABonus = true;
    NPCTraits[NPCID_INVINCIBILITY_POWER].IsABonus = true;
    NPCTraits[NPCID_INVINCIBILITY_POWER].TFrames = 4;
    NPCTraits[NPCID_INVINCIBILITY_POWER].FrameSpeed = 4;
    NPCTraits[NPCID_AQUATIC_POWER].IsABonus = true;
    NPCTraits[NPCID_POLAR_POWER].IsABonus = true;
    NPCTraits[NPCID_CYCLONE_POWER].IsABonus = true;
    NPCTraits[NPCID_CYCLONE_POWER].TFrames = 4;
    NPCTraits[NPCID_CYCLONE_POWER].FrameSpeed = 6;
    NPCTraits[NPCID_CYCLONE_POWER].WidthGFX = 32;
    NPCTraits[NPCID_CYCLONE_POWER].HeightGFX = 42;
    NPCTraits[NPCID_CYCLONE_POWER].NoGravity = true;
    NPCTraits[NPCID_CYCLONE_POWER].NoClipping = true;
    NPCTraits[NPCID_SHELL_POWER].IsABonus = true;
    NPCTraits[NPCID_COIN_S3].IsACoin = true;
    NPCTraits[NPCID_COIN_S4].IsACoin = true;
    NPCTraits[NPCID_COIN_5].IsACoin = true;
    NPCTraits[NPCID_COIN_S1].IsACoin = true;
    NPCTraits[NPCID_RED_COIN].IsACoin = true;
    // NPCIsAnExit(NPCID_ITEMGOAL) = true;
    // NPCIsAnExit(NPCID_GOALORB_S3) = true;
    // NPCIsAnExit(NPCID_GOALORB_S2) = true;
    // NPCIsAnExit(NPCID_STAR_EXIT) = true;
    // NPCIsAnExit(NPCID_STAR_COLLECT) = true;
    NPCTraits[NPCID_PLANT_S3].JumpHurt = true;
    NPCTraits[NPCID_FIRE_PLANT].JumpHurt = true;
    NPCTraits[NPCID_LAVABUBBLE].JumpHurt = true;
    NPCTraits[NPCID_HEAVY_THROWN].JumpHurt = true;
    NPCTraits[NPCID_SPIKY_S3].JumpHurt = true;
    NPCTraits[NPCID_SPIKY_S4].JumpHurt = true;
    NPCTraits[NPCID_SPIKY_BALL_S4].JumpHurt = true;
    NPCTraits[NPCID_STONE_S3].JumpHurt = true;
    NPCTraits[NPCID_GHOST_S3].JumpHurt = true;
    NPCTraits[NPCID_GHOST_FAST].JumpHurt = true;
    NPCTraits[NPCID_GHOST_S4].JumpHurt = true;
    NPCTraits[NPCID_BIG_GHOST].JumpHurt = true;
    NPCTraits[NPCID_SPIKY_BALL_S3].JumpHurt = true;
    NPCTraits[NPCID_BOTTOM_PLANT].JumpHurt = true;
    NPCTraits[NPCID_SIDE_PLANT].JumpHurt = true;
    NPCTraits[NPCID_CRAB].JumpHurt = true;
    NPCTraits[NPCID_FLY].JumpHurt = true;
    NPCTraits[NPCID_BIG_PLANT].JumpHurt = true;
    NPCTraits[NPCID_LONG_PLANT_UP].JumpHurt = true;
    NPCTraits[NPCID_LONG_PLANT_DOWN].JumpHurt = true;
    NPCTraits[NPCID_STATUE_FIRE].JumpHurt = true;
    NPCTraits[NPCID_VILLAIN_FIRE].JumpHurt = true;
    NPCTraits[NPCID_PLANT_S1].JumpHurt = true;
    NPCTraits[NPCID_BLU_GUY].CanWalkOn = true;
    NPCTraits[NPCID_RED_GUY].CanWalkOn = true;
    NPCTraits[NPCID_STACKER].CanWalkOn = true;
    NPCTraits[NPCID_CANNONENEMY].CanWalkOn = true;
    NPCTraits[NPCID_JUMPER_S3].CanWalkOn = true;
    // NPCTraits[NPCID_RED_FISH_S1].CanWalkOn = true;
    NPCTraits[NPCID_KEY].CanWalkOn = true;
    NPCTraits[NPCID_SPIT_BOSS].CanWalkOn = true;
    NPCTraits[NPCID_SPIT_BOSS_BALL].CanWalkOn = true;
    NPCTraits[NPCID_SLIDE_BLOCK].CanWalkOn = true;
    NPCTraits[NPCID_FALL_BLOCK_RED].CanWalkOn = true;
    NPCTraits[NPCID_FALL_BLOCK_BROWN].CanWalkOn = true;
    NPCTraits[NPCID_VEHICLE].CanWalkOn = true;
    NPCTraits[NPCID_CONVEYOR].CanWalkOn = true;
    NPCTraits[NPCID_METALBARREL].CanWalkOn = true;
    NPCTraits[NPCID_YEL_PLATFORM].CanWalkOn = true;
    NPCTraits[NPCID_BLU_PLATFORM].CanWalkOn = true;
    NPCTraits[NPCID_GRN_PLATFORM].CanWalkOn = true;
    NPCTraits[NPCID_RED_PLATFORM].CanWalkOn = true;
    NPCTraits[NPCID_HPIPE_SHORT].CanWalkOn = true;
    NPCTraits[NPCID_HPIPE_LONG].CanWalkOn = true;
    NPCTraits[NPCID_VPIPE_SHORT].CanWalkOn = true;
    NPCTraits[NPCID_VPIPE_LONG].CanWalkOn = true;
    NPCTraits[NPCID_TANK_TREADS].CanWalkOn = true;
    NPCTraits[NPCID_SHORT_WOOD].CanWalkOn = true;
    NPCTraits[NPCID_LONG_WOOD].CanWalkOn = true;
    NPCTraits[NPCID_SLANT_WOOD_L].CanWalkOn = true;
    NPCTraits[NPCID_SLANT_WOOD_R].CanWalkOn = true;
    NPCTraits[NPCID_SLANT_WOOD_M].CanWalkOn = true;
    NPCTraits[NPCID_STATUE_S3].CanWalkOn = true;
    NPCTraits[NPCID_ITEM_BURIED].CanWalkOn = true;
    NPCTraits[NPCID_VEGGIE_1].CanWalkOn = true;
    NPCTraits[NPCID_PLATFORM_S3].CanWalkOn = true;
    NPCTraits[NPCID_CHECKER_PLATFORM].CanWalkOn = true;
    NPCTraits[NPCID_PLATFORM_S1].CanWalkOn = true;
    NPCTraits[NPCID_BLU_GUY].GrabFromTop = true;
    NPCTraits[NPCID_RED_GUY].GrabFromTop = true;
    NPCTraits[NPCID_STACKER].GrabFromTop = true;
    NPCTraits[NPCID_JUMPER_S3].GrabFromTop = true;
    // NPCTraits[NPCID_RED_FISH_S1].GrabFromTop = true;
    NPCTraits[NPCID_KEY].GrabFromTop = true;
    NPCTraits[NPCID_SPIT_BOSS_BALL].GrabFromTop = true;
    NPCTraits[NPCID_SLIDE_BLOCK].GrabFromTop = true;
    NPCTraits[NPCID_ITEM_BURIED].GrabFromTop = true;
    NPCTraits[NPCID_VEGGIE_1].GrabFromTop = true;
    NPCTraits[NPCID_PLANT_S3].NoClipping = true;
    NPCTraits[NPCID_FIRE_PLANT].NoClipping = true;
    // NPCTraits[NPCID_COIN_S3].NoClipping = true;
    NPCTraits[NPCID_LAVABUBBLE].NoClipping = true;
    NPCTraits[NPCID_BULLET].NoClipping = true;
    NPCTraits[NPCID_BIG_BULLET].NoClipping = true;
    NPCTraits[NPCID_HEAVY_THROWN].NoClipping = true;
    NPCTraits[NPCID_LEAF_POWER].NoClipping = true;
    NPCTraits[NPCID_GHOST_S3].NoClipping = true;
    NPCTraits[NPCID_GHOST_FAST].NoClipping = true;
    NPCTraits[NPCID_GHOST_S4].NoClipping = true;
    NPCTraits[NPCID_BIG_GHOST].NoClipping = true;
    NPCTraits[NPCID_FALL_BLOCK_RED].NoClipping = true;
    NPCTraits[NPCID_FALL_BLOCK_BROWN].NoClipping = true;
    NPCTraits[NPCID_SPIKY_THROWER].NoClipping = true;
    NPCTraits[NPCID_ITEM_THROWER].NoClipping = true;
    NPCTraits[NPCID_TOOTHY].NoClipping = true;
    NPCTraits[NPCID_BOTTOM_PLANT].NoClipping = true;
    NPCTraits[NPCID_SIDE_PLANT].NoClipping = true;
    // NPCTraits[NPCID_VEHICLE].NoClipping = true;
    NPCTraits[NPCID_CONVEYOR].NoClipping = true;
    NPCTraits[NPCID_YEL_PLATFORM].NoClipping = true;
    NPCTraits[NPCID_BLU_PLATFORM].NoClipping = true;
    NPCTraits[NPCID_GRN_PLATFORM].NoClipping = true;
    NPCTraits[NPCID_RED_PLATFORM].NoClipping = true;
    NPCTraits[NPCID_BIG_PLANT].NoClipping = true;
    NPCTraits[NPCID_LONG_PLANT_UP].NoClipping = true;
    NPCTraits[NPCID_LONG_PLANT_DOWN].NoClipping = true;
    NPCTraits[NPCID_STATUE_FIRE].NoClipping = true;
    NPCTraits[NPCID_VILLAIN_FIRE].NoClipping = true;
    NPCTraits[NPCID_ITEM_BURIED].NoClipping = true;
    NPCTraits[NPCID_PLANT_S1].NoClipping = true;
    NPCTraits[NPCID_PLATFORM_S3].NoClipping = true;
    NPCTraits[NPCID_CHECKER_PLATFORM].NoClipping = true;
    NPCTraits[NPCID_PLATFORM_S1].NoClipping = true;
    NPCTraits[NPCID_PET_FIRE].NoClipping = true;
    NPCTraits[NPCID_RED_TURTLE_S3].TurnsAtCliffs = true;
    NPCTraits[NPCID_RED_GUY].TurnsAtCliffs = true;
    NPCTraits[NPCID_STACKER].TurnsAtCliffs = true;
    NPCTraits[NPCID_EXT_TURTLE].TurnsAtCliffs = true;
    NPCTraits[NPCID_YELSWITCH_FODDER].TurnsAtCliffs = true;
    NPCTraits[NPCID_BLUSWITCH_FODDER].TurnsAtCliffs = true;
    NPCTraits[NPCID_GRNSWITCH_FODDER].TurnsAtCliffs = true;
    NPCTraits[NPCID_REDSWITCH_FODDER].TurnsAtCliffs = true;
    NPCTraits[NPCID_PINK_CIVILIAN].TurnsAtCliffs = true;
    NPCTraits[NPCID_CARRY_BUDDY].TurnsAtCliffs = true;
    NPCTraits[NPCID_CANNONENEMY].MovesPlayer = true;
    NPCTraits[NPCID_KEY].MovesPlayer = true;
    NPCTraits[NPCID_COIN_SWITCH].MovesPlayer = true;
    NPCTraits[NPCID_TIME_SWITCH].MovesPlayer = true;
    NPCTraits[NPCID_TNT].MovesPlayer = true;
    NPCTraits[NPCID_SLIDE_BLOCK].MovesPlayer = true;
    NPCTraits[NPCID_FALL_BLOCK_RED].MovesPlayer = true;
    NPCTraits[NPCID_FALL_BLOCK_BROWN].MovesPlayer = true;
    NPCTraits[NPCID_CONVEYOR].MovesPlayer = true;
    NPCTraits[NPCID_METALBARREL].MovesPlayer = true;
    NPCTraits[NPCID_HPIPE_SHORT].MovesPlayer = true;
    NPCTraits[NPCID_HPIPE_LONG].MovesPlayer = true;
    NPCTraits[NPCID_VPIPE_SHORT].MovesPlayer = true;
    NPCTraits[NPCID_VPIPE_LONG].MovesPlayer = true;
    NPCTraits[NPCID_TANK_TREADS].MovesPlayer = true;
    NPCTraits[NPCID_SHORT_WOOD].MovesPlayer = true;
    NPCTraits[NPCID_LONG_WOOD].MovesPlayer = true;
    NPCTraits[NPCID_SLANT_WOOD_L].MovesPlayer = true;
    NPCTraits[NPCID_SLANT_WOOD_R].MovesPlayer = true;
    NPCTraits[NPCID_SLANT_WOOD_M].MovesPlayer = true;
    NPCTraits[NPCID_STATUE_S3].MovesPlayer = true;
    NPCTraits[NPCID_CANNONENEMY].WontHurt = true;
    NPCTraits[NPCID_CANNONITEM].WontHurt = true;
    NPCTraits[NPCID_SPRING].WontHurt = true;
    NPCTraits[NPCID_KEY].WontHurt = true;
    NPCTraits[NPCID_COIN_SWITCH].WontHurt = true;
    NPCTraits[NPCID_TIME_SWITCH].WontHurt = true;
    NPCTraits[NPCID_TNT].WontHurt = true;
    NPCTraits[NPCID_GRN_BOOT].WontHurt = true;
    NPCTraits[NPCID_RED_BOOT].WontHurt = true;
    NPCTraits[NPCID_BLU_BOOT].WontHurt = true;
    NPCTraits[NPCID_SLIDE_BLOCK].WontHurt = true;
    NPCTraits[NPCID_FALL_BLOCK_RED].WontHurt = true;
    NPCTraits[NPCID_FALL_BLOCK_BROWN].WontHurt = true;
    NPCTraits[NPCID_TOOTHYPIPE].WontHurt = true;
    NPCTraits[NPCID_TOOTHY].WontHurt = true;
    NPCTraits[NPCID_VEHICLE].WontHurt = true;
    NPCTraits[NPCID_CONVEYOR].WontHurt = true;
    NPCTraits[NPCID_METALBARREL].WontHurt = true;
    NPCTraits[NPCID_YEL_PLATFORM].WontHurt = true;
    NPCTraits[NPCID_BLU_PLATFORM].WontHurt = true;
    NPCTraits[NPCID_GRN_PLATFORM].WontHurt = true;
    NPCTraits[NPCID_RED_PLATFORM].WontHurt = true;
    NPCTraits[NPCID_HPIPE_SHORT].WontHurt = true;
    NPCTraits[NPCID_HPIPE_LONG].WontHurt = true;
    NPCTraits[NPCID_VPIPE_SHORT].WontHurt = true;
    NPCTraits[NPCID_VPIPE_LONG].WontHurt = true;
    NPCTraits[NPCID_TANK_TREADS].WontHurt = true;
    NPCTraits[NPCID_SHORT_WOOD].WontHurt = true;
    NPCTraits[NPCID_LONG_WOOD].WontHurt = true;
    NPCTraits[NPCID_SLANT_WOOD_L].WontHurt = true;
    NPCTraits[NPCID_SLANT_WOOD_R].WontHurt = true;
    NPCTraits[NPCID_SLANT_WOOD_M].WontHurt = true;
    NPCTraits[NPCID_STATUE_S3].WontHurt = true;
    NPCTraits[NPCID_ITEM_BURIED].WontHurt = true;
    NPCTraits[NPCID_VEGGIE_1].WontHurt = true;
    NPCTraits[NPCID_PET_GREEN].WontHurt = true;
    NPCTraits[NPCID_ITEM_POD].WontHurt = true;
    NPCTraits[NPCID_PET_BLUE].WontHurt = true;
    NPCTraits[NPCID_PET_YELLOW].WontHurt = true;
    NPCTraits[NPCID_PET_RED].WontHurt = true;
    NPCTraits[NPCID_PLATFORM_S3].WontHurt = true;
    NPCTraits[NPCID_CHECKER_PLATFORM].WontHurt = true;
    NPCTraits[NPCID_PLATFORM_S1].WontHurt = true;
    NPCTraits[NPCID_PINK_CIVILIAN].WontHurt = true;
    NPCTraits[NPCID_PET_FIRE].WontHurt = true;
    NPCTraits[NPCID_PET_BLACK].WontHurt = true;
    NPCTraits[NPCID_PET_PURPLE].WontHurt = true;
    NPCTraits[NPCID_PET_PINK].WontHurt = true;
    NPCTraits[NPCID_PET_CYAN].WontHurt = true;
    NPCTraits[NPCID_CARRY_BUDDY].WontHurt = true;
    NPCTraits[NPCID_CANNONITEM].IsGrabbable = true;
    NPCTraits[NPCID_SPRING].IsGrabbable = true;
    NPCTraits[NPCID_KEY].IsGrabbable = true;
    NPCTraits[NPCID_COIN_SWITCH].IsGrabbable = true;
    NPCTraits[NPCID_TIME_SWITCH].IsGrabbable = true;
    NPCTraits[NPCID_GRN_BOOT].IsGrabbable = true;
    NPCTraits[NPCID_RED_BOOT].IsGrabbable = true;
    NPCTraits[NPCID_BLU_BOOT].IsGrabbable = true;
    NPCTraits[NPCID_SLIDE_BLOCK].IsGrabbable = true;
    NPCTraits[NPCID_TOOTHYPIPE].IsGrabbable = true;
    NPCTraits[NPCID_VEGGIE_1].IsGrabbable = true;
    NPCTraits[NPCID_ITEM_POD].IsGrabbable = true;
    NPCTraits[NPCID_CARRY_BUDDY].IsGrabbable = true;
    NPCTraits[NPCID_CANNONENEMY].IsABlock = true;
    NPCTraits[NPCID_KEY].IsABlock = true;
    NPCTraits[NPCID_COIN_SWITCH].IsABlock = true;
    NPCTraits[NPCID_TIME_SWITCH].IsABlock = true;
    NPCTraits[NPCID_TNT].IsABlock = true;
    NPCTraits[NPCID_SLIDE_BLOCK].IsABlock = true;
    NPCTraits[NPCID_FALL_BLOCK_RED].IsABlock = true;
    NPCTraits[NPCID_FALL_BLOCK_BROWN].IsABlock = true;
    NPCTraits[NPCID_VEHICLE].IsABlock = true;
    NPCTraits[NPCID_CONVEYOR].IsABlock = true;
    NPCTraits[NPCID_METALBARREL].IsABlock = true;
    NPCTraits[NPCID_HPIPE_SHORT].IsABlock = true;
    NPCTraits[NPCID_HPIPE_LONG].IsABlock = true;
    NPCTraits[NPCID_VPIPE_SHORT].IsABlock = true;
    NPCTraits[NPCID_VPIPE_LONG].IsABlock = true;
    NPCTraits[NPCID_TANK_TREADS].IsABlock = true;
    NPCTraits[NPCID_SHORT_WOOD].IsABlock = true;
    NPCTraits[NPCID_LONG_WOOD].IsABlock = true;
    NPCTraits[NPCID_SLANT_WOOD_L].IsABlock = true;
    NPCTraits[NPCID_SLANT_WOOD_R].IsABlock = true;
    NPCTraits[NPCID_SLANT_WOOD_M].IsABlock = true;
    NPCTraits[NPCID_STATUE_S3].IsABlock = true;
    NPCTraits[NPCID_RAFT].IsABlock = true;
    NPCTraits[NPCID_GRN_BOOT].IsAHit1Block = true;
    NPCTraits[NPCID_RED_BOOT].IsAHit1Block = true;
    NPCTraits[NPCID_BLU_BOOT].IsAHit1Block = true;
    NPCTraits[NPCID_CANNONITEM].IsAHit1Block = true;
    NPCTraits[NPCID_TOOTHYPIPE].IsAHit1Block = true;
    NPCTraits[NPCID_SPRING].IsAHit1Block = true;
    NPCTraits[NPCID_YEL_PLATFORM].IsAHit1Block = true;
    NPCTraits[NPCID_BLU_PLATFORM].IsAHit1Block = true;
    NPCTraits[NPCID_GRN_PLATFORM].IsAHit1Block = true;
    NPCTraits[NPCID_RED_PLATFORM].IsAHit1Block = true;
    NPCTraits[NPCID_PLATFORM_S3].IsAHit1Block = true;
    NPCTraits[NPCID_CHECKER_PLATFORM].IsAHit1Block = true;
    NPCTraits[NPCID_PLATFORM_S1].IsAHit1Block = true;
    NPCTraits[NPCID_RAFT].WontHurt = true;
    NPCTraits[NPCID_RAFT].CanWalkOn = true;
    NPCTraits[NPCID_CANNONITEM].StandsOnPlayer = true;
    NPCTraits[NPCID_SPRING].StandsOnPlayer = true;
    NPCTraits[NPCID_KEY].StandsOnPlayer = true;
    NPCTraits[NPCID_COIN_SWITCH].StandsOnPlayer = true;
    NPCTraits[NPCID_TIME_SWITCH].StandsOnPlayer = true;
    NPCTraits[NPCID_TNT].StandsOnPlayer = true;
    NPCTraits[NPCID_GRN_BOOT].StandsOnPlayer = true;
    NPCTraits[NPCID_RED_BOOT].StandsOnPlayer = true;
    NPCTraits[NPCID_BLU_BOOT].StandsOnPlayer = true;
    NPCTraits[NPCID_TOOTHYPIPE].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_GREEN].StandsOnPlayer = true;
    NPCTraits[NPCID_ITEM_POD].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_BLUE].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_YELLOW].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_RED].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_BLACK].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_PURPLE].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_PINK].StandsOnPlayer = true;
    NPCTraits[NPCID_PET_CYAN].StandsOnPlayer = true;


    NPCTraits[NPCID_VINE_BUG].CanWalkOn = true;
    NPCTraits[NPCID_VINE_BUG].GrabFromTop = true;
    NPCTraits[NPCID_VINE_BUG].NoFireBall = true;
    NPCTraits[NPCID_VINE_BUG].NoClipping = true;
    NPCTraits[NPCID_VINE_BUG].TWidth = 32;
    NPCTraits[NPCID_VINE_BUG].THeight = 32;

    NPCTraits[NPCID_BOSS_CASE].CanWalkOn = true;
    NPCTraits[NPCID_BOSS_CASE].WontHurt = true;
    NPCTraits[NPCID_BOSS_CASE].MovesPlayer = true;
    NPCTraits[NPCID_BOSS_CASE].TWidth = 128;
    NPCTraits[NPCID_BOSS_CASE].THeight = 128;
    NPCTraits[NPCID_BOSS_CASE].IsABlock = true;

    NPCTraits[NPCID_BOSS_CASE].Foreground = true;
    NPCTraits[NPCID_WALL_TURTLE].JumpHurt = true;
    NPCTraits[NPCID_WALL_SPARK].JumpHurt = true;
    NPCTraits[NPCID_WALL_BUG].JumpHurt = true;

    NPCTraits[NPCID_ROCKET_FLIER].TWidth = 48;
    NPCTraits[NPCID_ROCKET_FLIER].THeight = 28;
    NPCTraits[NPCID_ROCKET_FLIER].WidthGFX = 112;
    NPCTraits[NPCID_ROCKET_FLIER].HeightGFX = 28;

    NPCTraits[NPCID_WALL_BUG].WidthGFX = 44;
    NPCTraits[NPCID_WALL_BUG].HeightGFX = 44;
    NPCTraits[NPCID_WALL_BUG].FrameOffsetY = 6;


    NPCTraits[NPCID_JUMP_PLANT].TWidth = 32;
    NPCTraits[NPCID_JUMP_PLANT].THeight = 42;
    NPCTraits[NPCID_JUMP_PLANT].JumpHurt = true;
    NPCTraits[NPCID_JUMP_PLANT].NoClipping = true;

    NPCTraits[NPCID_BAT].TWidth = 32;
    NPCTraits[NPCID_BAT].THeight = 32;
    NPCTraits[NPCID_BAT].NoClipping = true;


    NPCTraits[NPCID_HOMING_BALL].TWidth = 28;
    NPCTraits[NPCID_HOMING_BALL].NoClipping = true;
    NPCTraits[NPCID_HOMING_BALL_GEN].IsABlock = true;
    NPCTraits[NPCID_HOMING_BALL_GEN].NoClipping = true;
    NPCTraits[NPCID_HOMING_BALL_GEN].MovesPlayer = true;
    NPCTraits[NPCID_HOMING_BALL_GEN].CanWalkOn = true;
    NPCTraits[NPCID_HOMING_BALL_GEN].WontHurt = true;





    NPCTraits[NPCID_LAVABUBBLE].Foreground = true;
    NPCTraits[NPCID_BULLET].Foreground = true;
    NPCTraits[NPCID_BIG_BULLET].Foreground = true;
    NPCTraits[NPCID_RED_FISH_S1].Foreground = true;
    NPCTraits[NPCID_HEAVY_THROWN].Foreground = true;
    NPCTraits[NPCID_LEAF_POWER].Foreground = true;
    NPCTraits[NPCID_GHOST_S3].Foreground = true;
    NPCTraits[NPCID_GHOST_FAST].Foreground = true;
    NPCTraits[NPCID_GHOST_S4].Foreground = true;
    NPCTraits[NPCID_BIG_GHOST].Foreground = true;
    NPCTraits[NPCID_SPIKY_THROWER].Foreground = true;
    NPCTraits[NPCID_STATUE_FIRE].Foreground = true;
    NPCTraits[NPCID_VILLAIN_S3].Foreground = true;
    NPCTraits[NPCID_VILLAIN_FIRE].Foreground = true;
    NPCTraits[NPCID_PET_FIRE].Foreground = true;
    NPCTraits[NPCID_PLR_HEAVY].Foreground = true;
    // NPCDefaultMovement(NPCID_FODDER_S3) = true;
    // NPCDefaultMovement(NPCID_RED_FODDER) = true;
    // NPCDefaultMovement(NPCID_RED_FLY_FODDER) = true;
    // NPCDefaultMovement(NPCID_GRN_TURTLE_S3) = true;
    // NPCDefaultMovement(NPCID_RED_TURTLE_S3) = true;
    // NPCDefaultMovement(NPCID_BLU_GUY) = true;
    // NPCDefaultMovement(NPCID_RED_GUY) = true;
    // NPCDefaultMovement(NPCID_STACKER) = true;
    // NPCDefaultMovement(NPCID_GLASS_TURTLE) = true;
    // NPCDefaultMovement(NPCID_UNDER_FODDER) = true;
    // NPCDefaultMovement(NPCID_SPIKY_S3) = true;
    // NPCDefaultMovement(NPCID_SPIKY_S4) = true;
    // NPCDefaultMovement(NPCID_TOOTHY) = true;
    // NPCDefaultMovement(NPCID_CRAB) = true;
    // NPCDefaultMovement(NPCID_EXT_TURTLE) = true;
    // NPCDefaultMovement(NPCID_YELSWITCH_FODDER) = true;
    // NPCDefaultMovement(NPCID_BLUSWITCH_FODDER) = true;
    // NPCDefaultMovement(NPCID_GRNSWITCH_FODDER) = true;
    // NPCDefaultMovement(NPCID_REDSWITCH_FODDER) = true;
    // NPCDefaultMovement(NPCID_BIG_FODDER) = true;
    // NPCDefaultMovement(NPCID_BIG_TURTLE) = true;
    // NPCDefaultMovement(NPCID_JUMPER_S4) = true;
    // NPCDefaultMovement(NPCID_TANK_TREADS) = true;
    // NPCDefaultMovement(NPCID_FODDER_S1) = true;
    // NPCDefaultMovement(NPCID_ITEM_BURIED) = true;
    // NPCDefaultMovement(NPCID_PINK_CIVILIAN) = true;

    NPCTraits[NPCID_BLU_GUY].NoFireBall = true;
    NPCTraits[NPCID_RED_GUY].NoFireBall = true;
    NPCTraits[NPCID_GLASS_TURTLE].NoFireBall = true;
    NPCTraits[NPCID_GLASS_SHELL].NoFireBall = true;
    NPCTraits[NPCID_LIT_BOMB_S3].NoFireBall = true;
    NPCTraits[NPCID_WALK_BOMB_S3].NoFireBall = true;
    NPCTraits[NPCID_BIRD].NoFireBall = true;
    NPCTraits[NPCID_RED_SPIT_GUY].NoFireBall = true;
    NPCTraits[NPCID_BLU_SPIT_GUY].NoFireBall = true;
    NPCTraits[NPCID_GRY_SPIT_GUY].NoFireBall = true;
    NPCTraits[NPCID_LAVABUBBLE].NoFireBall = true;
    NPCTraits[NPCID_JUMPER_S3].NoFireBall = true;


    // link sword beam
    NPCTraits[NPCID_SWORDBEAM].TWidth = 16;
    NPCTraits[NPCID_SWORDBEAM].THeight = 8;
    NPCTraits[NPCID_SWORDBEAM].WontHurt = true;
    NPCTraits[NPCID_SWORDBEAM].JumpHurt = true;
    NPCTraits[NPCID_SWORDBEAM].NoGravity = true;

    NPCTraits[NPCID_MAGIC_BOSS].NoYoshi = true;
    NPCTraits[NPCID_MAGIC_BOSS_SHELL].NoYoshi = true;
    NPCTraits[NPCID_MAGIC_BOSS_BALL].NoYoshi = true;
    NPCTraits[NPCID_FIRE_BOSS].NoYoshi = true;
    NPCTraits[NPCID_FIRE_BOSS_SHELL].NoYoshi = true;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].NoYoshi = true;


    NPCTraits[NPCID_QUAD_BALL].NoClipping = true;
    NPCTraits[NPCID_QUAD_BALL].TWidth = 16;
    NPCTraits[NPCID_QUAD_BALL].THeight = 16;
    NPCTraits[NPCID_QUAD_BALL].NoYoshi = true;
    NPCTraits[NPCID_QUAD_BALL].JumpHurt = true;

    NPCTraits[NPCID_QUAD_SPITTER].TWidth = 60;
    NPCTraits[NPCID_QUAD_SPITTER].THeight = 24;
    NPCTraits[NPCID_QUAD_SPITTER].WidthGFX = 64;
    NPCTraits[NPCID_QUAD_SPITTER].HeightGFX = 32;
    NPCTraits[NPCID_QUAD_SPITTER].NoFireBall = true;
    NPCTraits[NPCID_QUAD_SPITTER].JumpHurt = true;

    NPCTraits[NPCID_FLY_BLOCK].TWidth = 32;
    NPCTraits[NPCID_FLY_BLOCK].THeight = 44;
    NPCTraits[NPCID_FLY_BLOCK].WontHurt = true;
    NPCTraits[NPCID_FLY_BLOCK].JumpHurt = true;
    NPCTraits[NPCID_FLY_BLOCK].IsGrabbable = true;

    NPCTraits[NPCID_FLY_CANNON].TWidth = 32;
    NPCTraits[NPCID_FLY_CANNON].THeight = 44;
    NPCTraits[NPCID_FLY_CANNON].WidthGFX = 96;
    NPCTraits[NPCID_FLY_CANNON].HeightGFX = 44;
    NPCTraits[NPCID_FLY_CANNON].WontHurt = true;
    NPCTraits[NPCID_FLY_CANNON].JumpHurt = true;
    NPCTraits[NPCID_FLY_CANNON].IsGrabbable = true;


// set ice
    NPCTraits[NPCID_GOALTAPE].NoIceBall = true;
    NPCTraits[NPCID_CHECKPOINT].NoIceBall = true;

    NPCTraits[NPCID_MAGIC_BOSS].NoIceBall = true;
    NPCTraits[NPCID_MAGIC_BOSS_SHELL].NoIceBall = true;
    NPCTraits[NPCID_MAGIC_BOSS_BALL].NoIceBall = true;
    NPCTraits[NPCID_QUAD_SPITTER].NoIceBall = true;
    NPCTraits[NPCID_FIRE_BOSS].NoIceBall = true;
    NPCTraits[NPCID_FIRE_BOSS_SHELL].NoIceBall = true;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].NoIceBall = true;
    NPCTraits[NPCID_MINIBOSS].NoIceBall = true;
    NPCTraits[NPCID_BIG_BULLET].NoIceBall = true;
    NPCTraits[NPCID_SPRING].NoIceBall = true;
    NPCTraits[NPCID_HEAVY_THROWN].NoIceBall = true;
    NPCTraits[NPCID_KEY].NoIceBall = true;
    NPCTraits[NPCID_COIN_SWITCH].NoIceBall = true;
    NPCTraits[NPCID_GRN_BOOT].NoIceBall = true;
    NPCTraits[NPCID_STONE_S3].NoIceBall = true;
    NPCTraits[NPCID_GHOST_S3].NoIceBall = true;
    NPCTraits[NPCID_SPIT_BOSS].NoIceBall = true;
    NPCTraits[NPCID_SPIT_BOSS_BALL].NoIceBall = true;
    NPCTraits[NPCID_GHOST_FAST].NoIceBall = true;
    NPCTraits[NPCID_GHOST_S4].NoIceBall = true;
    NPCTraits[NPCID_BIG_GHOST].NoIceBall = true;
    NPCTraits[NPCID_SLIDE_BLOCK].NoIceBall = true;
    NPCTraits[NPCID_FALL_BLOCK_RED].NoIceBall = true;
    NPCTraits[NPCID_VEHICLE].NoIceBall = true;
    For(A, NPCID_CONVEYOR, NPCID_VPIPE_LONG)
    {
        NPCTraits[A].NoIceBall = true;
    }
    NPCTraits[NPCID_CIVILIAN_SCARED].NoIceBall = true;
    For(A, NPCID_TANK_TREADS, NPCID_COIN_S1)
    {
        NPCTraits[A].NoIceBall = true;
    }
    NPCTraits[NPCID_ITEM_BURIED].NoIceBall = true;
    NPCTraits[NPCID_VEGGIE_1].NoIceBall = true;
    NPCTraits[NPCID_CIVILIAN].NoIceBall = true;
    For(A, NPCID_PET_GREEN, NPCID_PET_FIRE)
    {
        NPCTraits[A].NoIceBall = true;
    }
    NPCTraits[NPCID_SPIT_GUY_BALL].NoIceBall = true;
    NPCTraits[NPCID_BOMB].NoIceBall = true;
    For(A, NPCID_COIN_S2, NPCID_ROCKET_WOOD)
    {
        NPCTraits[A].NoIceBall = true;
    }
    NPCTraits[NPCID_PLR_HEAVY].NoIceBall = true;
    NPCTraits[NPCID_AXE].NoIceBall = true;
    NPCTraits[NPCID_SAW].NoIceBall = true;
    NPCTraits[NPCID_STONE_S4].NoIceBall = true;
    NPCTraits[NPCID_STATUE_S4].NoIceBall = true;
    NPCTraits[NPCID_RAFT].NoIceBall = true;
    NPCTraits[NPCID_RED_BOOT].NoIceBall = true;
    NPCTraits[NPCID_CHECKPOINT].NoIceBall = true;
    NPCTraits[NPCID_BLU_BOOT].NoIceBall = true;
    NPCTraits[NPCID_FLIPPED_RAINBOW_SHELL].NoIceBall = true;
    NPCTraits[NPCID_LAVA_MONSTER].NoIceBall = true;
    NPCTraits[NPCID_VILLAIN_S1].NoIceBall = true;
    NPCTraits[NPCID_SICK_BOSS].NoIceBall = true;
    NPCTraits[NPCID_BOSS_CASE].NoIceBall = true;
    NPCTraits[NPCID_BOSS_FRAGILE].NoIceBall = true;
    NPCTraits[NPCID_HOMING_BALL].NoIceBall = true;
    For(A, NPCID_HOMING_BALL_GEN, NPCID_PET_CYAN)
    {
        NPCTraits[A].NoIceBall = true;
    }
    NPCTraits[NPCID_ICE_BLOCK].NoIceBall = true;
    NPCTraits[NPCID_TIME_SWITCH].NoIceBall = true;
    NPCTraits[NPCID_TNT].NoIceBall = true;
    NPCTraits[NPCID_EARTHQUAKE_BLOCK].NoIceBall = true;
    NPCTraits[NPCID_PLANT_FIREBALL].NoIceBall = true;
    NPCTraits[NPCID_FLY_POWER].NoIceBall = true;
    NPCTraits[NPCID_LOCK_DOOR].NoIceBall = true;
    NPCTraits[NPCID_LONG_PLANT_UP].NoIceBall = true;
    NPCTraits[NPCID_LONG_PLANT_DOWN].NoIceBall = true;
    NPCTraits[NPCID_FIRE_DISK].NoIceBall = true;
    NPCTraits[NPCID_FIRE_CHAIN].NoIceBall = true;
    NPCTraits[NPCID_BOMBER_BOSS].NoIceBall = true;
    NPCTraits[NPCID_GEM_1].NoIceBall = true;
    NPCTraits[NPCID_GEM_5].NoIceBall = true;
    NPCTraits[NPCID_GEM_20].NoIceBall = true;
    NPCTraits[NPCID_COIN_5].NoIceBall = true;
    NPCTraits[NPCID_COIN_S4].NoIceBall = true;
    NPCTraits[NPCID_MEDAL].NoIceBall = true;
    NPCTraits[NPCID_FLY_BLOCK].NoIceBall = true;
    NPCTraits[NPCID_FLY_CANNON].NoIceBall = true;

    for(int A = NPCID_FIRE_BOSS_FIRE; A <= NPCID_CHAR4_HEAVY; ++A)
    {
        if(A != NPCID_SPIKY_S4 && A != NPCID_SPIKY_BALL_S4)
            NPCTraits[A].NoIceBall = true;
    }


    NPCTraits[NPCID_STACKER].THeight = 30;
    NPCTraits[NPCID_STACKER].HeightGFX = 32;
    NPCTraits[NPCID_STACKER].WidthGFX = 32;


    // NPCDefaultMovement(NPCID_CARRY_BUDDY) = true;


    NPCTraits[NPCID_MAGIC_BOSS].WidthGFX = 84;
    NPCTraits[NPCID_MAGIC_BOSS].HeightGFX = 62;
    NPCTraits[NPCID_MAGIC_BOSS].TWidth = 44;
    NPCTraits[NPCID_MAGIC_BOSS].THeight = 50;

    NPCTraits[NPCID_MAGIC_BOSS_SHELL].WidthGFX = 44;
    NPCTraits[NPCID_MAGIC_BOSS_SHELL].HeightGFX = 32;
    NPCTraits[NPCID_MAGIC_BOSS_SHELL].TWidth = 32;
    NPCTraits[NPCID_MAGIC_BOSS_SHELL].THeight = 28;

    NPCTraits[NPCID_MAGIC_BOSS_BALL].WidthGFX = 16;
    NPCTraits[NPCID_MAGIC_BOSS_BALL].HeightGFX = 32;
    NPCTraits[NPCID_MAGIC_BOSS_BALL].TWidth = 16;
    NPCTraits[NPCID_MAGIC_BOSS_BALL].THeight = 32;
    NPCTraits[NPCID_MAGIC_BOSS_BALL].NoClipping = true;
    NPCTraits[NPCID_MAGIC_BOSS_BALL].JumpHurt = true;

    NPCTraits[NPCID_FIRE_BOSS].WidthGFX = 64;
    NPCTraits[NPCID_FIRE_BOSS].HeightGFX = 64;
    NPCTraits[NPCID_FIRE_BOSS].TWidth = 48;
    NPCTraits[NPCID_FIRE_BOSS].THeight = 48;

    NPCTraits[NPCID_FIRE_BOSS_SHELL].WidthGFX = 40;
    NPCTraits[NPCID_FIRE_BOSS_SHELL].HeightGFX = 36;
    NPCTraits[NPCID_FIRE_BOSS_SHELL].TWidth = 36;
    NPCTraits[NPCID_FIRE_BOSS_SHELL].THeight = 32;

    NPCTraits[NPCID_FIRE_BOSS_FIRE].WidthGFX = 64;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].HeightGFX = 32;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].TWidth = 64;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].THeight = 26;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].FrameOffsetY = 4;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].NoClipping = true;
    NPCTraits[NPCID_FIRE_BOSS_FIRE].JumpHurt = true;

    // Default NPCs that must use the canonical camera
    NPCTraits[NPCID_STONE_S3].UseDefaultCam = true;
    NPCTraits[NPCID_STONE_S4].UseDefaultCam = true;
    NPCTraits[NPCID_METALBARREL].UseDefaultCam = true;
    NPCTraits[NPCID_CANNONENEMY].UseDefaultCam = true;
    NPCTraits[NPCID_BULLET].UseDefaultCam = true;
    NPCTraits[NPCID_BIG_BULLET].UseDefaultCam = true;
    NPCTraits[NPCID_GHOST_FAST].UseDefaultCam = true;
    NPCTraits[NPCID_STATUE_S3].UseDefaultCam = true;
    NPCTraits[NPCID_STATUE_S4].UseDefaultCam = true;
    NPCTraits[NPCID_HOMING_BALL_GEN].UseDefaultCam = true;
    NPCTraits[NPCID_LAVA_MONSTER].UseDefaultCam = true;
    NPCTraits[NPCID_SPIKY_THROWER].UseDefaultCam = true;
    NPCTraits[NPCID_ITEM_THROWER].UseDefaultCam = true;
    // NPCTraits[NPCID_SAW].UseDefaultCam = true; // held back for 1.3.7
    // NPCTraits[NPCID_BOMB].UseDefaultCam = true; // held back for 1.3.7

    // Default NPCs that render differently when inactive
    for(int A = 1; A <= maxNPCType; A++)
    {
        if(NPCTraits[A].IsABlock || NPCTraits[A].IsAHit1Block || NPCTraits[A].IsACoin || NPCTraits[A].IsAVine || NPCTraits[A].IsABonus)
            NPCTraits[A].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    }

    NPCTraits[NPCID_CHECKPOINT].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_ITEM_BURIED].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_CONVEYOR].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_STONE_S3].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_STONE_S4].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_HOMING_BALL_GEN].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_ITEMGOAL].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_FLAG_EXIT].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_CANNONENEMY].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_STATUE_S3].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_STATUE_S4].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_ITEM_POD].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_SPRING].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_CANNONITEM].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_KEY].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_TIME_SWITCH].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_COIN_SWITCH].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_ICE_BLOCK].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_VEHICLE].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_AXE].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_WALK_PLANT].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_FLY_BLOCK].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_FLY_CANNON].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_MAGIC_DOOR].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    NPCTraits[NPCID_DOOR_MAKER].InactiveRender = NPCTraits_t::SHOW_ALWAYS;
    // NPCTraits[NPCID_SAW].InactiveRender = NPCTraits_t::SHOW_STATIC;
    // NPCTraits[NPCID_BOMB].InactiveRender = NPCTraits_t::SHOW_STATIC;

    NPCTraits[NPCID_LAVABUBBLE].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_PLANT_S3].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_BOTTOM_PLANT].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_SIDE_PLANT].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_BIG_PLANT].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_PLANT_S1].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_FIRE_PLANT].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_LONG_PLANT_UP].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_LONG_PLANT_DOWN].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_JUMP_PLANT].InactiveRender = NPCTraits_t::SKIP;
    NPCTraits[NPCID_LAVA_MONSTER].InactiveRender = NPCTraits_t::SKIP;

    NPCTraits[NPCID_BULLET].InactiveRender = NPCTraits_t::SMOKE;
    NPCTraits[NPCID_BIG_BULLET].InactiveRender = NPCTraits_t::SMOKE;
    NPCTraits[NPCID_GHOST_FAST].InactiveRender = NPCTraits_t::SMOKE;


    For(A, 1, maxBlockType)
    {
        BlockWidth[A] = 32;
        BlockHeight[A] = 32;
    }

    BlockWidth[571] = 64;
    BlockWidth[572] = 64;
    BlockWidth[615] = 64;

    BlockWidth[634] = 64;
    BlockHeight[634] = 64;

    BlockHeight[595] = 64;
    BlockHeight[596] = 64;
    BlockHeight[597] = 64;

    BlockHeight[569] = 64;
    BlockHeight[570] = 64;
    BlockHeight[571] = 64;
    BlockHeight[572] = 64;
    BlockHeight[575] = 64;

    BlockOnlyHitspot1[572] = true;
    BlockWidth[21] = 64;
    BlockWidth[22] = 64;
    BlockHeight[23] = 64;
    BlockHeight[24] = 64;
    BlockWidth[34] = 64;
    BlockWidth[35] = 64;
    BlockWidth[36] = 64;
    BlockWidth[37] = 64;
    BlockWidth[61] = 128;
    BlockHeight[61] = 128;
    BlockWidth[78] = 64;
    BlockWidth[91] = 64;
    BlockHeight[91] = 64;
    BlockWidth[92] = 128;
    BlockHeight[92] = 128;
    BlockWidth[93] = 128;
    BlockHeight[93] = 128;
    BlockWidth[103] = 64;
    BlockWidth[104] = 64;
    BlockWidth[113] = 64;
    BlockWidth[114] = 64;
    BlockWidth[125] = 64;
    BlockHeight[125] = 64;
    BlockWidth[182] = 96;
    BlockHeight[182] = 96;
    BlockWidth[184] = 64;
    BlockHeight[184] = 64;
    BlockWidth[185] = 128;
    BlockHeight[187] = 128;
    BlockWidth[187] = 128;
    BlockWidth[194] = 64;
    BlockWidth[195] = 64;
    BlockWidth[196] = 64;
    BlockWidth[197] = 64;
    BlockWidth[206] = 64;
    BlockHeight[206] = 64;
    BlockHeight[211] = 64;
    BlockHeight[212] = 64;
    BlockWidth[224] = 64;
    BlockHeight[224] = 64;
    BlockWidth[225] = 64;
    BlockHeight[225] = 64;
    BlockWidth[226] = 64;
    BlockHeight[226] = 64;
    BlockWidth[262] = 128;
    BlockHeight[262] = 128;

    BlockWidth[616] = 64;
    BlockWidth[617] = 64;
    BlockSlope[616] = -1;
    BlockSlope[617] = 1;

    BlockSlope[635] = -1;
    BlockSlope[636] = -1;
    BlockWidth[636] = 64;
    BlockSlope[637] = 1;
    BlockSlope[638] = 1;
    BlockWidth[638] = 64;


    For(A, 137, 146)
    {
        BlockWidth[A] = 64;
    }

    For(A, 147, 158)
    {
        BlockHeight[A] = 64;
    }
    BlockWidth[301] = 128;
    BlockWidth[302] = 128;
    BlockWidth[303] = 128;
    BlockWidth[304] = 128;
    BlockWidth[306] = 64;
    BlockWidth[308] = 64;
    BlockWidth[312] = 64;
    BlockWidth[314] = 64;
    BlockWidth[319] = 128;
    BlockWidth[320] = 128;
    BlockWidth[321] = 128;
    BlockWidth[322] = 128;
    BlockWidth[325] = 64;
    BlockWidth[324] = 64;
    BlockWidth[325] = 64;
    BlockWidth[324] = 64;
    BlockWidth[336] = 64;
    BlockWidth[338] = 64;
    BlockWidth[340] = 64;
    BlockWidth[342] = 64;
    BlockWidth[357] = 64;
    BlockWidth[360] = 64;
    BlockWidth[361] = 64;
    BlockWidth[364] = 64;
    BlockWidth[365] = 64;
    BlockWidth[366] = 64;
    BlockWidth[367] = 64;
    BlockWidth[368] = 64;
    BlockHeight[376] = 64;
    BlockHeight[377] = 64;
    BlockWidth[378] = 64;
    BlockHeight[378] = 64;
    BlockWidth[472] = 64;
    BlockHeight[472] = 32;
    BlockWidth[474] = 64;
    BlockHeight[474] = 32;
    BlockWidth[476] = 64;
    BlockHeight[476] = 32;
    BlockWidth[479] = 64;
    BlockHeight[479] = 32;
    BlockWidth[505] = 64;
    BlockHeight[505] = 32;
    BlockWidth[506] = 64;
    BlockHeight[506] = 64;

    BlockWidth[613] = 64;

    BlockWidth[507] = 64;
    BlockHeight[507] = 32;

    BlockWidth[599] = 64;
    BlockHeight[599] = 64;


    BlockWidth[508] = 64;
    BlockHeight[508] = 32;

    BlockWidth[529] = 32;
    BlockHeight[529] = 64;

    BlockWidth[527] = 64;
    BlockHeight[527] = 96;




    BlockWidth[534] = 48;
    BlockHeight[534] = 128;
    BlockWidth[535] = 48;
    BlockHeight[535] = 128;
    BlockWidth[536] = 128;
    BlockHeight[536] = 48;
    BlockWidth[537] = 128;
    BlockHeight[537] = 48;
    BlockWidth[540] = 64;




    BlockSlope[472] = -1;
    BlockSlope[474] = 1;
    BlockSlope2[476] = 1;
    BlockSlope2[479] = -1;


    BlockSlope2[77] = 1;
    BlockSlope2[78] = 1;
    BlockSlope2[613] = -1;
    BlockSlope2[614] = -1;


    BlockSlope[480] = -1;
    BlockSlope[482] = 1;
    BlockSlope2[486] = 1;
    BlockSlope2[485] = -1;


    BlockOnlyHitspot1[372] = true;
    BlockOnlyHitspot1[373] = true;
    BlockOnlyHitspot1[374] = true;
    BlockOnlyHitspot1[375] = true;
    BlockOnlyHitspot1[379] = true;
    BlockOnlyHitspot1[380] = true;
    BlockOnlyHitspot1[381] = true;
    BlockOnlyHitspot1[382] = true;
    BlockOnlyHitspot1[389] = true;
    BlockOnlyHitspot1[391] = true;
    BlockOnlyHitspot1[392] = true;

    BlockOnlyHitspot1[506] = true;
    BlockOnlyHitspot1[507] = true;
    BlockOnlyHitspot1[508] = true;

    BlockKills[371] = true;
    BlockKills[404] = true;
    BlockKills[406] = true;
    BlockKills[405] = true;
    BlockKills[420] = true;
    BlockHasNoMask[336] = true;
    BlockHasNoMask[337] = true;
    BlockHasNoMask[338] = true;
    BlockHasNoMask[339] = true;
    BlockHasNoMask[303] = true;
    BlockHasNoMask[304] = true;
    BlockHasNoMask[348] = true;
    BlockHasNoMask[353] = true;
    BlockHasNoMask[354] = true;
    BlockHasNoMask[355] = true;
    BlockHasNoMask[356] = true;
    BlockHasNoMask[3] = true;
    BlockHasNoMask[4] = true;
    BlockHasNoMask[13] = true;
    BlockHasNoMask[15] = true;
    BlockHasNoMask[16] = true;
    BlockHasNoMask[17] = true;
    BlockHasNoMask[19] = true;
    BlockHasNoMask[21] = true;
    BlockHasNoMask[34] = true;
    BlockHasNoMask[36] = true;
    BlockHasNoMask[23] = true;
    BlockHasNoMask[29] = true;
    BlockHasNoMask[40] = true;
    BlockHasNoMask[43] = true;
    BlockHasNoMask[46] = true;
    BlockHasNoMask[47] = true;
    BlockHasNoMask[48] = true;
    BlockHasNoMask[49] = true;
    BlockHasNoMask[50] = true;
    BlockHasNoMask[51] = true;
    BlockHasNoMask[52] = true;
    BlockHasNoMask[53] = true;
    BlockHasNoMask[54] = true;
    BlockHasNoMask[59] = true;
    BlockHasNoMask[60] = true;
    BlockHasNoMask[61] = true;
    BlockHasNoMask[63] = true;
    BlockHasNoMask[65] = true;
    BlockHasNoMask[67] = true;
    BlockHasNoMask[70] = true;
    BlockHasNoMask[71] = true;
    BlockHasNoMask[72] = true;
    BlockHasNoMask[73] = true;
    BlockHasNoMask[74] = true;
    BlockHasNoMask[75] = true;
    BlockHasNoMask[76] = true;
    BlockHasNoMask[81] = true;
    BlockHasNoMask[83] = true;
    BlockHasNoMask[84] = true;
    BlockHasNoMask[85] = true;
    BlockHasNoMask[86] = true;
    BlockHasNoMask[87] = true;
    BlockHasNoMask[91] = true;
    BlockHasNoMask[93] = true;
    BlockHasNoMask[94] = true;
    BlockHasNoMask[95] = true;
    BlockHasNoMask[96] = true;
    BlockHasNoMask[97] = true;
    BlockHasNoMask[98] = true;
    BlockHasNoMask[99] = true;
    BlockHasNoMask[100] = true;
    BlockHasNoMask[101] = true;
    BlockHasNoMask[102] = true;
    BlockHasNoMask[103] = true;
    BlockHasNoMask[111] = true;
    BlockHasNoMask[118] = true;
    BlockHasNoMask[119] = true;
    BlockHasNoMask[120] = true;
    BlockHasNoMask[121] = true;
    BlockHasNoMask[122] = true;
    BlockHasNoMask[123] = true;
    BlockHasNoMask[124] = true;
    BlockHasNoMask[125] = true;
    BlockHasNoMask[126] = true;
    BlockHasNoMask[127] = true;
    BlockHasNoMask[131] = true;
    BlockHasNoMask[134] = true;
    BlockHasNoMask[136] = true;
    BlockHasNoMask[159] = true;
    BlockHasNoMask[160] = true;
    BlockHasNoMask[166] = true;
    BlockHasNoMask[183] = true;
    BlockHasNoMask[184] = true;
    BlockHasNoMask[186] = true;
    BlockHasNoMask[187] = true;
    BlockHasNoMask[188] = true;
    BlockHasNoMask[190] = true;
    BlockHasNoMask[198] = true;
    BlockHasNoMask[199] = true;
    BlockHasNoMask[200] = true;
    BlockHasNoMask[201] = true;
    BlockHasNoMask[202] = true;
    BlockHasNoMask[203] = true;
    BlockHasNoMask[204] = true;
    BlockHasNoMask[205] = true;
    BlockHasNoMask[206] = true;
    BlockHasNoMask[216] = true;
    BlockHasNoMask[217] = true;
    BlockHasNoMask[218] = true;
    BlockHasNoMask[223] = true;
    BlockHasNoMask[226] = true;
    BlockHasNoMask[227] = true;
    BlockHasNoMask[228] = true;
    BlockHasNoMask[229] = true;
    BlockHasNoMask[230] = true;
    BlockHasNoMask[231] = true;
    BlockHasNoMask[232] = true;
    BlockHasNoMask[233] = true;
    BlockHasNoMask[234] = true;
    BlockHasNoMask[235] = true;
    BlockHasNoMask[236] = true;
    BlockHasNoMask[237] = true;
    BlockHasNoMask[238] = true;
    BlockHasNoMask[239] = true;
    BlockHasNoMask[250] = true;
    BlockHasNoMask[251] = true;
    BlockHasNoMask[252] = true;
    BlockHasNoMask[253] = true;
    BlockHasNoMask[254] = true;
    BlockHasNoMask[255] = true;
    BlockHasNoMask[256] = true;
    BlockHasNoMask[257] = true;
    BlockHasNoMask[258] = true;
    // BlockHasNoMask[261] = true; // invalid, Block 261 is sizable and this flag is never read for sizable blocks in SMBX 1.3
    BlockHasNoMask[262] = true;
    BlockHasNoMask[264] = true;
    BlockHasNoMask[263] = true;
    BlockHasNoMask[273] = true;
    BlockHasNoMask[272] = true;
    BlockHasNoMask[276] = true;
    BlockHasNoMask[281] = true;
    BlockHasNoMask[282] = true;
    BlockHasNoMask[283] = true;
    BlockHasNoMask[291] = true;
    BlockHasNoMask[292] = true;
    BlockHasNoMask[320] = true;
    BlockHasNoMask[322] = true;
    BlockHasNoMask[323] = true;
    BlockHasNoMask[330] = true;
    BlockHasNoMask[331] = true;
    BlockHasNoMask[369] = true;
    BlockHasNoMask[370] = true;
    BlockOnlyHitspot1[8] = true;
    BlockOnlyHitspot1[121] = true;
    BlockOnlyHitspot1[122] = true;
    BlockOnlyHitspot1[123] = true;
    BlockOnlyHitspot1[168] = true;
    BlockOnlyHitspot1[289] = true;
    BlockOnlyHitspot1[290] = true;
    BlockOnlyHitspot1[370] = true;

    BlockKills[30] = true;
    BlockHurts[109] = true;
    BlockHurts[598] = true;
    BlockHurts[110] = true;
    BlockHurts[267] = true;
    BlockHurts[268] = true;
    BlockHurts[269] = true;
    BlockHurts[511] = true;
    BlockPSwitch[4] = true;
    BlockPSwitch[60] = true;
    BlockPSwitch[89] = true;
    BlockPSwitch[188] = true;
    BlockPSwitch[280] = true;
    BlockPSwitch[293] = true;
    BlockNoClipping[172] = true;
    BlockNoClipping[175] = true;
    BlockNoClipping[178] = true;
    BlockNoClipping[181] = true;
    BlockSlope[299] = -1;
    BlockSlope[300] = 1;
    BlockSlope[301] = 1;
    BlockSlope[302] = -1;
    BlockSlope[305] = -1;
    BlockSlope[306] = -1;
    BlockSlope[307] = 1;
    BlockSlope[308] = 1;
    BlockSlope[324] = -1;
    BlockSlope[325] = 1;

    BlockSlope2[528] = 1;
    BlockSlope2[523] = -1;

    BlockSlope2[309] = 1;
    BlockSlope2[310] = -1;
    BlockSlope2[311] = 1;
    BlockSlope2[312] = 1;
    BlockSlope2[313] = -1;
    BlockSlope2[314] = -1;
    BlockSlope[315] = 1;
    BlockSlope[316] = -1;
    BlockSlope2[317] = 1;
    BlockSlope2[318] = -1;
    BlockSlope[319] = 1;
    BlockSlope[321] = -1;
    BlockSlope[326] = -1;
    BlockSlope[327] = 1;
    BlockSlope2[328] = -1;
    BlockSlope2[329] = 1;
    BlockSlope[332] = -1;
    BlockSlope[333] = 1;
    BlockSlope2[334] = -1;
    BlockSlope2[335] = 1;
    BlockSlope[340] = -1;
    BlockSlope[341] = -1;
    BlockSlope[342] = 1;
    BlockSlope[343] = 1;
    BlockSlope[357] = -1;
    BlockSlope[358] = -1;
    BlockSlope[359] = 1;
    BlockSlope[360] = 1;
    BlockSlope2[361] = 1;
    BlockSlope2[362] = 1;
    BlockSlope2[363] = -1;
    BlockSlope2[364] = -1;
    BlockSlope[365] = -1;
    BlockSlope[366] = 1;
    BlockSlope2[367] = -1;
    BlockSlope2[368] = 1;

    BlockKills[459] = true;

    BlockKills[460] = true;
    BlockKills[461] = true;
    BlockKills[462] = true;
    BlockKills[463] = true;
    BlockKills[464] = true;
    BlockKills[465] = true;
    BlockKills[466] = true;
    BlockKills[467] = true;
    BlockKills[468] = true;
    BlockKills[469] = true;
    BlockKills[470] = true;
    BlockKills[471] = true;

    BlockKills2[460] = true;
    BlockKills2[461] = true;
    BlockKills2[462] = true;
    BlockKills2[463] = true;
    BlockKills2[464] = true;
    BlockKills2[465] = true;
    BlockKills2[466] = true;
    BlockKills2[467] = true;
    BlockKills[472] = true;
    BlockKills[473] = true;
    BlockKills[474] = true;
    BlockKills[475] = true;
    BlockKills[476] = true;
    BlockKills[478] = true;
    BlockKills[479] = true;
    BlockKills2[472] = true;
    BlockKills2[474] = true;
    BlockKills2[476] = true;
    BlockKills2[479] = true;

    BlockKills[480] = true;
    BlockKills[481] = true;
    BlockKills[482] = true;
    BlockKills[483] = true;
    BlockKills[484] = true;
    BlockKills[485] = true;
    BlockKills[486] = true;
    BlockKills[487] = true;
    BlockKills2[480] = true;
    BlockKills2[482] = true;
    BlockKills2[485] = true;
    BlockKills2[486] = true;



    BlockHurts[407] = true;
    BlockHurts[408] = true;
    BlockHurts[428] = true;
    BlockHurts[429] = true;
    BlockHurts[430] = true;
    BlockHurts[431] = true;
    BlockHurts[511] = true;
    BlockOnlyHitspot1[447] = true;
    BlockOnlyHitspot1[446] = true;
    BlockOnlyHitspot1[448] = true;




    BlockWidth[604] = 64;
    BlockWidth[605] = 64;

    BlockSlope[600] = -1;
    BlockSlope[604] = -1;
    BlockSlope[601] = 1;
    BlockSlope[605] = 1;


    BlockSlope[451] = 1;
    BlockSlope[452] = -1;
    For(A, 459, 487)
    {
        BlockKills[A] = true;
    }
    BackgroundHasNoMask[187] = true;
    BackgroundHasNoMask[188] = true;
    BackgroundHasNoMask[189] = true;
    BackgroundHasNoMask[190] = true;

    BackgroundHasNoMask[172] = true;
    BackgroundHasNoMask[167] = true;
    BackgroundHasNoMask[164] = true;
    BackgroundHasNoMask[165] = true;
    BackgroundHasNoMask[158] = true;
    BackgroundHasNoMask[146] = true;
    BackgroundHasNoMask[12] = true;
    BackgroundHasNoMask[14] = true;
    BackgroundHasNoMask[15] = true;
    BackgroundHasNoMask[22] = true;
    BackgroundHasNoMask[30] = true;
    BackgroundHasNoMask[39] = true;
    BackgroundHasNoMask[40] = true;
    BackgroundHasNoMask[41] = true;
    BackgroundHasNoMask[42] = true;
    BackgroundHasNoMask[43] = true;
    BackgroundHasNoMask[44] = true;
    BackgroundHasNoMask[47] = true;
    BackgroundHasNoMask[52] = true;
    BackgroundHasNoMask[53] = true;
    BackgroundHasNoMask[55] = true;
    BackgroundHasNoMask[56] = true;
    BackgroundHasNoMask[60] = true;
    BackgroundHasNoMask[61] = true;
    BackgroundHasNoMask[64] = true;
    BackgroundHasNoMask[75] = true;
    BackgroundHasNoMask[76] = true;
    BackgroundHasNoMask[77] = true;
    BackgroundHasNoMask[78] = true;
    BackgroundHasNoMask[79] = true;
    BackgroundHasNoMask[83] = true;
    BackgroundHasNoMask[87] = true;
    BackgroundHasNoMask[88] = true;
    BackgroundHasNoMask[91] = true;
    BackgroundHasNoMask[98] = true;
    BackgroundHasNoMask[99] = true;
    BackgroundHasNoMask[107] = true;
    BackgroundHasNoMask[115] = true;
    BackgroundHasNoMask[116] = true;
    BackgroundHasNoMask[117] = true;
    BackgroundHasNoMask[118] = true;
    BackgroundHasNoMask[119] = true;
    BackgroundHasNoMask[122] = true;
    BackgroundHasNoMask[123] = true;
    BackgroundHasNoMask[124] = true;

    BackgroundHasNoMask[139] = true;
    BackgroundHasNoMask[140] = true;
    BackgroundHasNoMask[141] = true;
    BackgroundHasNoMask[144] = true;
    BackgroundHasNoMask[145] = true;
    BlockOnlyHitspot1[69] = true;


    Foreground[187] = true;
    Foreground[188] = true;
    Foreground[143] = true;
    // Foreground[165] = true;
    Foreground[145] = true;
    Foreground[23] = true;
    Foreground[24] = true;
    Foreground[25] = true;
    Foreground[45] = true;
    Foreground[46] = true;
    Foreground[49] = true;
    Foreground[50] = true;
    Foreground[51] = true;
    // Foreground[65] = true;
    Foreground[68] = true;
    Foreground[69] = true;
    Foreground[106] = true;
    Foreground[137] = true;
    Foreground[138] = true;

    Foreground[154] = true;
    Foreground[155] = true;
    Foreground[156] = true;
    Foreground[157] = true;

    BackgroundHeight[158] = 32;
    BackgroundHeight[159] = 32;

    BackgroundHeight[187] = 32;
    BackgroundHeight[188] = 32;
    BackgroundHeight[189] = 32;
    BackgroundHeight[190] = 32;



    BackgroundHeight[170] = 32;
    BackgroundHeight[171] = 32;

    BackgroundHeight[26] = 64;
    BackgroundHeight[18] = 32;
    BackgroundHeight[19] = 32;
    BackgroundHeight[20] = 32;
    BackgroundHeight[36] = 96;
    BackgroundHeight[65] = 96;

    BackgroundHeight[66] = 32;

    BackgroundHeight[68] = 64;
    BackgroundHeight[70] = 32;
    BackgroundHeight[172] = 32;
    BackgroundHeight[82] = 32;
    BackgroundHeight[100] = 32;
    BackgroundHeight[125] = 64;
    BackgroundHeight[134] = 32;
    BackgroundHeight[135] = 32;
    BackgroundHeight[136] = 32;
    BackgroundHeight[137] = 32;
    BackgroundHeight[138] = 32;
    BackgroundWidth[163] = 64;

    BackgroundWidth[173] = 112;
    BackgroundHeight[173] = 120;


    BackgroundWidth[160] = 24;
    BackgroundHeight[160] = 24;

    BackgroundWidth[161] = 64;
    BackgroundHeight[161] = 48;

    BackgroundHeight[168] = 32;
    BackgroundWidth[168] = 64;

    BackgroundHeight[169] = 64;
    BackgroundWidth[169] = 64;
    BackgroundHasNoMask[169] = true;



    For(A, 1, maxSceneType)
    {
        SceneWidth[A] = 32;
        SceneHeight[A] = 32;
        if((A >= 15 && A <= 18) || (A == 21) || (A == 24) || (A == 58) || (A == 59) || (A == 63))
        {
            SceneWidth[A] = 16;
            SceneHeight[A] = 16;
        }
    }
    SceneWidth[20] = 64;
    SceneHeight[20] = 64;
    SceneWidth[27] = 48;
    SceneHeight[27] = 16;
    SceneWidth[28] = 48;
    SceneHeight[28] = 16;
    SceneWidth[29] = 64;
    SceneHeight[29] = 16;
    SceneWidth[30] = 64;
    SceneHeight[30] = 16;
    SceneWidth[33] = 14;
    SceneHeight[33] = 14;
    SceneWidth[34] = 14;
    SceneHeight[34] = 14;
    SceneWidth[44] = 64;
    SceneHeight[50] = 48;
    SceneWidth[50] = 64;
    SceneWidth[54] = 30;
    SceneHeight[54] = 24;
    SceneWidth[55] = 30;
    SceneHeight[55] = 24;
    SceneWidth[57] = 64;
    SceneHeight[57] = 64;
    SceneWidth[60] = 48;
    SceneHeight[60] = 48;
    SceneWidth[61] = 64;
    SceneHeight[61] = 76;

    For(A, 1, maxTileType)
    {
        TileWidth[A] = 32;
        TileHeight[A] = 32;
    }
    TileWidth[8] = 64;
    TileHeight[8] = 64;
    TileWidth[9] = 96;
    TileHeight[9] = 96;
    TileWidth[12] = 64;
    TileHeight[12] = 64;
    TileWidth[13] = 96;
    TileHeight[13] = 96;
    TileWidth[27] = 128;
    TileHeight[27] = 128;
    TileWidth[325] = 64;
    TileHeight[325] = 64;
    Points[1] = 10;
    Points[2] = 100;
    Points[3] = 200;
    Points[4] = 400;
    Points[5] = 800;
    Points[6] = 1000;
    Points[7] = 2000;
    Points[8] = 4000;
    Points[9] = 8000;
    Points[10] = 1;
    Points[11] = 2;
    Points[12] = 3;
    Points[13] = 5;
    For(A, 1, maxNPCType)
    {
        if(NPCTraits[A].IsFish)
            NPCTraits[A].Foreground = true;
    }
    For(A, 1, maxEffectType)
    {
#ifndef LOW_MEM
        // kept only for debugging that it's safe to remove them
        EffectDefaults.EffectHeight[A] = EffectHeight[A];
        EffectDefaults.EffectWidth[A] = EffectWidth[A];
#endif // #ifndef LOW_MEM

        if(EffectHeight[A] > 0)
        {
            // EffectDefaults.EffectFrames[A] = vb6Round(double(GFXEffectBMP[A].h) / EffectHeight[A]);
            EffectDefaults.EffectFrames[A] = (GFXEffectBMP[A].h * 2 + EffectHeight[A]) / (EffectHeight[A] * 2);
            if(EffectDefaults.EffectFrames[A] <= 0)
                EffectDefaults.EffectFrames[A] = 1;
        }
        else
            EffectDefaults.EffectFrames[A] = 1;
    }
    SaveNPCDefaults();
    SavePlayerDefaults();
}


================================================
FILE: src/main/speedrunner.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include <fmt_format_ne.h>
#include "speedrunner.h"
#include "globals.h"
#include "graphics.h"
#include "core/render.h"
#include "config.h"
#include "../controls.h"

#include "main/screen_quickreconnect.h"
#include "main/menu_main.h"

#include "gameplay_timer.h"

static      GameplayTimer s_gamePlayTimer;

void speedRun_loadStats()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    s_gamePlayTimer.load();
}

void speedRun_saveStats()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    if(GameMenu || GameOutro || BattleMode)
        return; // Do nothing when out of the game

    s_gamePlayTimer.save();
}

void speedRun_resetCurrent()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    s_gamePlayTimer.resetCurrent();
}

void speedRun_resetTotal()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    s_gamePlayTimer.reset();
}

static constexpr XTColor s_green  = XTColorF(0.0_n, 1.0_n, 0.0_n);
static constexpr XTColor s_blue   = XTColorF(0.0_n, 0.0_n, 1.0_n);
static constexpr XTColor s_red    = XTColorF(1.0_n, 0.0_n, 0.0_n);
static constexpr XTColor s_yellow = XTColorF(0.9_n, 0.9_n, 0.0_n);
static constexpr XTColor s_gray   = XTColorF(0.9_n, 0.9_n, 0.9_n);
static constexpr XTColor s_legacy = XTColorF(0.7_n, 0.7_n, 0.7_n);

static constexpr inline XTColor bool2(XTColor color, bool btn, uint8_t alpha)
{
    return btn ? color.with_alpha(alpha) : XTColor(32, 32, 32, alpha);
}

static Controls_t s_displayControls[maxLocalPlayers] = {Controls_t()};


void speedRun_renderTimer()
{
    if((g_config.speedrun_mode == SPEEDRUN_MODE_OFF && g_config.show_playtime_counter == Config_t::PLAYTIME_COUNTER_OFF) || !g_config.enable_playtime_tracking)
        return; // Do nothing

    if(g_config.speedrun_mode != SPEEDRUN_MODE_OFF)
    {
        // place speedrun mode below game version display on main menu
        int topY = (GameMenu) ? 22 : 2;

        SuperPrintRightAlign(fmt::format_ne(Cheater ? "CMode {0}" : "Mode {0}", g_config.speedrun_mode), 3, XRender::TargetW - XRender::TargetOverscanX - 2, topY, XTColorF(1.0_n, 0.3_n, 0.3_n, 0.5_n));

        if(g_config.allow_multires)
            SuperPrintRightAlign(fmt::format_ne("{0}x{1}", l_screen->W, l_screen->H), 3, XRender::TargetW - XRender::TargetOverscanX - 2, topY + 20, XTColorF(1.0_n, 0.3_n, 0.3_n, 0.5_n));
    }

    if(GameMenu || GameOutro || BattleMode || LevelEditor)
        return; // Don't draw things at Menu and Outro

    s_gamePlayTimer.render();
}

static void GetControllerColor(int l_player_i, XTColor& color, bool* drawLabel = nullptr)
{
    color = XTColorF(0.4_n, 0.4_n, 0.4_n);
    if(drawLabel)
        *drawLabel = false;

    if(GameMenu)
        return;

    if(l_player_i < 0 || l_player_i >= l_screen->player_count)
        return;

    int player = l_screen->players[l_player_i];

    if(player < 1 || player > numPlayers)
        return;

    if(numPlayers > 1 && !g_ClonedPlayerMode)
    {
        auto &p = Player[player];

        switch(p.Character) // TODO: Add changing of these colors by gameinfo.ini
        {
        case 1:
            color = XTColorF(0.7_n, 0.3_n, 0.3_n);
            break;
        case 2:
            color = XTColorF(0.3_n, 0.7_n, 0.3_n);
            break;
        case 3:
            color = XTColorF(1.0_n, 0.6_n, 0.7_n);
            break;
        case 4:
            color = XTColorF(0.04_n, 0.43_n, 1.0_n);
            break;
        case 5:
            color = {192, 168, 72};
            break;
        }

        if(drawLabel)
            *drawLabel = true;
    }
}

void RenderControls_priv(int player, const Controls_t* controls, int x, int y, int w, int h, bool missing, uint8_t alpha, bool connect_screen)
{
    if(!controls && (player < 0 || player >= maxLocalPlayers))
        return;

    uint8_t alphaBtn = missing ? alpha / 2 : alpha;
    uint8_t alphaText = alpha / 2;

    XTColor color;
    bool drawLabel = false;

    if(!connect_screen)
        GetControllerColor(player, color, &drawLabel);
    else if(player == -1)
        color = XTColorF(0.4_n, 0.4_n, 0.4_n);

    XRender::renderRect(x, y, w, h, {0, 0, 0, alpha}, true);//Edge
    XRender::renderRect(x + 2, y + 2, w - 4, h - 4, {color, alpha}, true);//Box

    if(missing)
    {
        num_t tick = 2 * num_t::PI() * (CommonFrame % 128) / 128;
        num_t coord = (num_t::sin(tick) + 1) / 2 + 0.25_n;
        alphaBtn = (uint8_t)(coord * alphaBtn);
        alphaText = (uint8_t)(coord * alphaText);
    }

    const Controls_t& c = (controls) ? *controls : s_displayControls[player];

    XRender::renderRect(x + 10, y + 12, 6, 6, {32, 32, 32, alphaBtn}, true);//Cender of D-Pad

    XRender::renderRect(x + 10, y + 6, 6, 6, bool2(s_gray, c.Up, alphaBtn), true);
    XRender::renderRect(x + 10, y + 18, 6, 6, bool2(s_gray, c.Down, alphaBtn), true);
    XRender::renderRect(x + 4, y + 12, 6, 6, bool2(s_gray, c.Left, alphaBtn), true);
    XRender::renderRect(x + 16, y + 12, 6, 6, bool2(s_gray, c.Right, alphaBtn), true);

    // This was suggested before, but perhaps don't do it: AltJump is still used for dismounting.
    // auto altjump_color = (g_config.disable_spin_jump) ? s_green : s_red;

    XRender::renderRect(x + 64, y + 18, 6, 6, bool2(s_green, c.Jump, alphaBtn), true);
    XRender::renderRect(x + 66, y + 8, 6, 6, bool2(s_red, c.AltJump, alphaBtn), true);
    XRender::renderRect(x + 54, y + 16, 6, 6, bool2(s_blue, c.Run, alphaBtn), true);
    XRender::renderRect(x + 56, y + 6, 6, 6, bool2(s_yellow, c.AltRun, alphaBtn), true);

    XRender::renderRect(x + 26, y + 22, 10, 4, bool2(s_gray, c.Drop, alphaBtn), true);
    if(SharedPauseLegacy)
        XRender::renderRect(x + 40, y + 22, 10, 4, bool2(s_legacy, c.Start, alphaBtn), true);
    else
        XRender::renderRect(x + 40, y + 22, 10, 4, bool2(s_gray, c.Start, alphaBtn), true);

    if(!connect_screen && (drawLabel || missing))
    {
        const char* label_fmt = (missing ? "P{0}?" : "P{0}");
        SuperPrintCenter(fmt::format_ne(label_fmt, player + 1), 3, x + w / 2, y + 2, XTAlpha(alphaText));
    }
    else if(missing)
    {
        SuperPrintCenter("?", 3, x + w / 2, y + 4, XTAlpha(alphaText));
    }
}

void RenderControls(int player, int x, int y, int w, int h, bool missing, uint8_t alpha, bool connect_screen)
{
    return RenderControls_priv(player, nullptr, x, y, w, h, missing, alpha, connect_screen);
}

void RenderControls(const Controls_t& controls, int x, int y, int w, int h, bool missing, uint8_t alpha)
{
    return RenderControls_priv(-1, &controls, x, y, w, h, missing, alpha, true);
}



void RenderPowerInfo(int player, int bx, int by, int bw, int bh, uint8_t alpha, const XPower::StatusInfo* status)
{
    // force to 2x
    bx &= ~1;
    by &= ~1;
    bw &= ~1;
    bh &= ~1;

    uint8_t alphaBox = alpha;
    uint8_t alphaBtn = alpha;

    XTColor color;
    GetControllerColor(player, color);
    if(color.r >= 128 || color.g >= 128 || color.b >= 128)
    {
        // make it darker so it can be distinguished from segments
        color.r /= 2;
        color.g /= 2;
        color.b /= 2;
    }

    XPower::StatusInfo status_info;

    if(status)
        status_info = *status;
    else if(player >= 0 && player < maxLocalPlayers)
        status_info = Controls::GetStatus(player);
    else
        status_info = XPower::devicePowerStatus();

    // don't draw segments for states without battery info
    if(status_info.power_status == XPower::StatusInfo::POWER_WIRED || status_info.power_status == XPower::StatusInfo::POWER_UNKNOWN)
        status_info.power_level = 0;

    if(status_info.power_status != XPower::StatusInfo::POWER_DISABLED)
    {
        XRender::renderRect(bx, by, bw - 4, bh, {0, 0, 0, alphaBox}, true);//Edge
        XRender::renderRect(bx + 2, by + 2, bw - 8, bh - 4, {color, alphaBox}, true);//Box
        XRender::renderRect(bx + 36, by + 6, 4, 10, {0, 0, 0, alphaBox}, true);//Edge
        XRender::renderRect(bx + 34, by + 8, 4, 6, {color, alphaBox}, true);//Box

        // segment count
        int segments;

        if(status_info.power_level > 0.90_nf)
            segments = 4;
        else if(status_info.power_level > 0.60_nf)
            segments = 3;
        else if(status_info.power_level > 0.30_nf)
            segments = 2;
        else
            segments = 1;

        // new color for the inner segments
        color = XTColor(0, 0, 0);

        if(status_info.power_level <= 0.5_nf)
            color.r = (255 - uint8_t(status_info.power_level * 510));

        if(status_info.power_status == XPower::StatusInfo::POWER_CHARGING)
        {
            color.g = 255;
            color.g -= color.r;
        }

        if(status_info.power_status == XPower::StatusInfo::POWER_CHARGED)
        {
            color.b = XTColor::from_num(0.8_n);
            color.g = XTColor::from_num(0.4_n);
        }

        // size for segment
        int s;

        switch(segments)
        {
        case 4:
            // 2 is the width of the segment, 10 lets us scale to the last 0.1_nf
            s = (int32_t)((status_info.power_level - 0.9_nf) * (2 * 10));
            if(s > 2) s = 2;
            // if(flash && status_info.power_status == XPower::StatusInfo::POWER_CHARGING)
            //     s = 2;
            XRender::renderRect(bx + 34, by + 10, s, 2, {color, alphaBtn}, true); // fallthrough
        case 3:
            // 4 is the width of the segment, 10 / 3 lets us scale to the 0.6-0.9 segment
            s = (int32_t)((status_info.power_level - 0.6_nf) * (4 * 10) / 3);
            if(s > 4) s = 4;
            // if(flash && status_info.power_status == XPower::StatusInfo::POWER_CHARGING)
            //     s = 4;
            XRender::renderRect(bx + 24, by + 4, s*2, 14, {color, alphaBtn}, true); // fallthrough
        case 2:
            // 4 is the width of the segment, 10 / 3 lets us scale to the 0.3-0.6 segment
            s = (int32_t)((status_info.power_level - 0.3_nf) * (4 * 10) / 3);
            if(s > 4) s = 4;
            // if(flash && status_info.power_status == XPower::StatusInfo::POWER_CHARGING)
            //     s = 4;
            XRender::renderRect(bx + 14, by + 4, s*2, 14, {color, alphaBtn}, true); // fallthrough
        case 1:
            // 4 is the width of the segment, 10 / 3 lets us scale to the 0.0-0.3 segment
            s = (int32_t)(status_info.power_level * (4 * 10) / 3);
            if(s > 4) s = 4;
            // if(flash && status_info.power_status == XPower::StatusInfo::POWER_CHARGING)
            //     s = 4;
            XRender::renderRect(bx + 4, by + 4, s*2, 14, {color, alphaBtn}, true);
            break;
        }

        if(status_info.power_status == XPower::StatusInfo::POWER_UNKNOWN)
            SuperPrintCenter("?", 3, (bx + bw / 2) & ~1, (by + bh / 2 - 8) & ~1, XTAlpha(alpha));

        if(status_info.power_status == XPower::StatusInfo::POWER_WIRED)
            SuperPrintCenter("W", 3, (bx + bw / 2) & ~1, (by + bh / 2 - 8) & ~1, XTAlpha(alpha));

        if(status_info.power_status == XPower::StatusInfo::POWER_CHARGING)
            SuperPrintCenter("+", 3, (bx + bw / 2) & ~1, (by + bh / 2 - 7) & ~1, XTAlpha(alpha));
    }

    if(status_info.info_string)
        SuperPrintCenter(status_info.info_string, 3, bx + bw / 2, by - 30, XTAlpha(alpha));
}

void speedRun_renderControls(int player, int screenZ, int align)
{
    if(GameOutro || LevelEditor)
        return; // Don't draw things at Editor and Outro

    if(GameMenu && (!g_config.show_controllers || MenuMode == MENU_CHARACTER_SELECT_NEW || MenuMode == MENU_CHARACTER_SELECT_NEW_BM))
        return;

    // player is an index into the local screen's player array, not a global player index
    if(player < 0 || player >= maxLocalPlayers)
        return;

    if(SingleCoop)
        player = 0;

    const bool player_missing = (player >= (int)Controls::g_InputMethods.size() || !Controls::g_InputMethods[player]);
    const bool player_newly_connected = !player_missing && QuickReconnectScreen::g_active && QuickReconnectScreen::g_toast_duration[player];
    XPower::StatusInfo status_info = Controls::GetStatus(player);

    // Controller
    int x, y;
    int w = 76;
    int h = 30;

    // Battery status
    int bx, by;
    int bw = 40;
    int bh = 22;

    int num_players = 1;

    if(screenZ >= 0)
    {
        auto &scr = vScreen[screenZ];
        y = (int)scr.Height - 34;
        by = y + 4;

        if(align == SPEEDRUN_ALIGN_AUTO)
            align = scr.Left > 0 ? SPEEDRUN_ALIGN_RIGHT : SPEEDRUN_ALIGN_LEFT;

        // this keeps the locations fixed even when the vScreens expand/contract
        if(align == SPEEDRUN_ALIGN_LEFT)
        {
            x = 4;
            bx = x + w + 4;
        }
        else
        {
            x = (int)scr.Width - (w + 4);
            bx = x - (bw + 4);
        }
    }
    else
    {
        const Screen_t& plr_screen = *l_screen;
        num_players = plr_screen.player_count;

        int plr_i = player;

        if(GameMenu)
        {
            num_players = SDL_min(num_players, (int)Controls::g_InputMethods.size());

            if(plr_i >= num_players)
                return;
        }

        if(align == SPEEDRUN_ALIGN_AUTO && !GameMenu)
        {
            if(plr_i == 0 || num_players <= 1)
                align = SPEEDRUN_ALIGN_LEFT;
            else if(plr_i >= num_players - 1)
                align = SPEEDRUN_ALIGN_RIGHT;
        }

        if(align == SPEEDRUN_ALIGN_LEFT)
        {
            x = XRender::TargetOverscanX + 4;
            bx = x + w + 4;
        }
        else if(align == SPEEDRUN_ALIGN_RIGHT)
        {
            x = (XRender::TargetW - XRender::TargetOverscanX - (w + 4));
            bx = x - (bw + 4);
        }
        else if(GameMenu)
        {
            x = XRender::TargetOverscanX + 4 + (w + 4) * plr_i;
            bx = x + w + 4;
        }
        else
        {
            int display_w = (status_info.power_status != XPower::StatusInfo::POWER_DISABLED) ? (w + 4 + bw + 4) : (w + 4);

            x = (XRender::TargetW - display_w) * plr_i / (num_players - 1);
            bx = x + (w + 4);
        }

        y = XRender::TargetH - 34;
        by = y + 4;
    }

    bool show_always = g_config.show_controllers;
    bool show_controls = false;

    // render controls if enabled or quick-reconnect logic is active
    if(show_always || player_missing || player_newly_connected)
    {
        show_controls = true;
    }
    else
    {
        // reposition battery correctly
        if(x < bx)
            bx = x;
        else
            bx = x + w - bw;
    }

    uint8_t controls_alpha = 255;
    uint8_t battery_alpha = 255;

    if(player_newly_connected)
    {
        const Controls::InputMethod* input_method = Controls::g_InputMethods[player];

        const std::string& profile_name = (input_method->Profile ? input_method->Profile->Name : "");

        uint8_t alpha = 255;
        int toast_duration = QuickReconnectScreen::g_toast_duration[player];
        int time_from_edge = SDL_min(toast_duration, QuickReconnectScreen::MAX_TOAST_DURATION - toast_duration);

        if(time_from_edge < 33)
        {
            num_t linear_coord = num_t::PI() * (33 - time_from_edge) / 33;
            XTColor alpha = XTAlphaF(num_t::cos(linear_coord) / 2 + 0.5_n);

            if(!show_always && toast_duration < 33)
                controls_alpha = alpha.a;

            // battery just appeared
            if(toast_duration > 33)
                battery_alpha = alpha.a;
        }

        // code for lower-resolution case
        if(XRender::TargetW < 600 || (XRender::TargetW < 800 && status_info.power_status != XPower::StatusInfo::POWER_DISABLED) || num_players > 2)
        {
            if(align == SPEEDRUN_ALIGN_RIGHT)
                SuperPrintRightAlign(profile_name, 3, x + w, y - 20, XTAlpha(alpha));
            else if(align == SPEEDRUN_ALIGN_LEFT)
                SuperPrint(profile_name, 3, x, y - 20, XTAlpha(alpha));
            else
                SuperPrintCenter(profile_name, 3, x + w / 2, y - 20, XTAlpha(alpha));
        }
        // code for higher resolution case, including battery
        else if(status_info.power_status != XPower::StatusInfo::POWER_DISABLED)
        {
            if(align == SPEEDRUN_ALIGN_RIGHT)
                SuperPrintRightAlign(profile_name, 3, bx - 4, by + 2, XTAlpha(alpha));
            else if(align == SPEEDRUN_ALIGN_LEFT)
                SuperPrint(profile_name, 3, bx + bw + 4, by + 2, XTAlpha(alpha));
            else
                SuperPrintCenter(profile_name, 3, x + w, y - 20, XTAlpha(alpha));
        }
        // code for normal case
        else
        {
            if(align == SPEEDRUN_ALIGN_RIGHT)
                SuperPrintRightAlign(profile_name, 3, x - 4, by + 2, XTAlpha(alpha));
            else if(align == SPEEDRUN_ALIGN_LEFT)
                SuperPrint(profile_name, 3, x + w + 4, by + 2, XTAlpha(alpha));
            else
                SuperPrintCenter(profile_name, 3, x + w / 2, y - 20, XTAlpha(alpha));
        }
    }

    if(!GameMenu)
        RenderPowerInfo(player, bx, by, bw, bh, battery_alpha, &status_info);

    if(show_controls)
        RenderControls(player, x, y, w, h, player_missing, controls_alpha);
}

void speedRun_tick()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    s_gamePlayTimer.tick();
}

void speedRun_triggerEnter()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    if(g_config.speedrun_stop_timer_by != Config_t::SPEEDRUN_STOP_ENTER_LEVEL)
        return;

    if(SDL_strcasecmp(FileName.c_str(), static_cast<const std::string&>(g_config.speedrun_stop_timer_at).c_str()) == 0)
        speedRun_bossDeadEvent();
}

void speedRun_triggerLeave()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    if(g_config.speedrun_stop_timer_by != Config_t::SPEEDRUN_STOP_LEAVE_LEVEL)
        return;

    if(SDL_strcasecmp(FileName.c_str(), static_cast<const std::string&>(g_config.speedrun_stop_timer_at).c_str()) == 0)
        speedRun_bossDeadEvent();
}


void speedRun_bossDeadEvent()
{
    if(!g_config.enable_playtime_tracking)
        return; // Do nothing

    if(GameMenu || GameOutro || BattleMode)
        return; // Don't draw things at Menu and Outro

    s_gamePlayTimer.onBossDead();
}

void speedRun_syncControlKeys(int plr, const Controls_t &keys)
{
    // there are still reasons to sync control keys (eg control tests)
    // if(g_speedRunnerMode == SPEEDRUN_MODE_OFF && !g_drawController)
    //     return; // Do nothing

    SDL_assert(plr >= 0 && plr < maxLocalPlayers);
    SDL_memcpy(&s_displayControls[plr], &keys, sizeof(Controls_t));
}


================================================
FILE: src/main/speedrunner.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SPEEDRUNNER_H
#define SPEEDRUNNER_H

#include "control_types.h"

namespace XPower { struct StatusInfo; }

enum
{
    SPEEDRUN_MODE_OFF = 0,
    SPEEDRUN_MODE_1,
    SPEEDRUN_MODE_2,
    SPEEDRUN_MODE_3
};

void speedRun_tick();

void speedRun_syncControlKeys(int l_player_i, const Controls_t &keys);

void speedRun_loadStats();
void speedRun_saveStats();

void speedRun_resetCurrent();
void speedRun_resetTotal();

void speedRun_triggerEnter();
void speedRun_triggerLeave();

void speedRun_bossDeadEvent();

void RenderPowerInfo(int l_player_i, int bx, int by, int bw, int bh, uint8_t alpha, const XPower::StatusInfo* status);

// l_player_i is an index into the local screen's player array, not a global player index anymore.
void RenderControls(int l_player_i, int x, int y, int w, int h, bool missing, uint8_t alpha, bool connect_screen = false);
void RenderControls(const Controls_t& controls, int x, int y, int w, int h, bool missing, uint8_t alpha);

enum
{
    SPEEDRUN_ALIGN_LEFT = -1,
    SPEEDRUN_ALIGN_AUTO,
    SPEEDRUN_ALIGN_RIGHT,
};

// player is an index into the local screen's player array, not a global player index
void speedRun_renderControls(int l_player_i, int screenZ = -1, int align = SPEEDRUN_ALIGN_AUTO);
void speedRun_renderTimer();

#endif // SPEEDRUNNER_H


================================================
FILE: src/main/translate/tr_level.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XTECH_TRANSLATE_EPISODE
#include <unordered_map>
#include <vector>
#include <json/json.hpp>
#include <Logger/logger.h>
#include <Utils/strings.h>
#include "globals.h"
#include "layers.h"
#endif /* XTECH_TRANSLATE_EPISODE */

class TrLevelParser : public nlohmann::json_sax<nlohmann::json>
{
public:
    TrLevelParser()
    {
        // Build the map of tr-id objects
        for(int i = 1; i <= numNPCs; ++i)
        {
            auto &it = m_trIdMap[GetS(NPC[i].Text)];
            it.push_back(&NPC[i].Text);
        }

        for(int i = 0; i < numEvents; ++i)
        {
            auto &it = m_trIdMap[GetS(Events[i].Text)];
            it.push_back(&Events[i].Text);
        }
    }

    TrLevelParser(const TrLevelParser&) = default;
    ~TrLevelParser() = default;

    std::unordered_map<std::string, std::vector<stringindex_t*> > m_trIdMap;

    std::string m_wantedKey;
    std::string m_curKey;

    int m_outKey = -1;
    std::string m_outTrId;
    std::string m_outValue;

    enum Where
    {
        W_SKIP = 0,
        W_ROOT,
        W_LEVEL,
        W_NPC,    W_NPC_OBJ,
        W_EVENT,  W_EVENT_OBJ
    } m_where = W_SKIP;

    void flushData()
    {
        if((m_outKey < 0 && m_outTrId.empty()) || m_outValue.empty())
            return;

        if(!m_outTrId.empty()) // By TrId
        {
            D_pLogDebug("JSON: Written %s into %s", m_outTrId.c_str(), m_outValue.c_str());
            auto it = m_trIdMap.find(m_outTrId);
            if(it != m_trIdMap.end())
            {
                for(auto *k : it->second)
                    SetS(*k, m_outValue);
            }
        }
        else // By object Index
        {
            D_pLogDebug("JSON: Written %d into %s", m_outKey, m_outValue.c_str());

            if(m_where == W_NPC_OBJ && m_outKey < numNPCs)
                SetS(NPC[m_outKey + 1].Text, m_outValue);
            else if(m_where == W_EVENT_OBJ && m_outKey < numEvents)
                SetS(Events[m_outKey].Text, m_outValue);
        }

        m_outKey = -1;
        m_outTrId.clear();
        m_outValue.clear();
    }


    // called when null is parsed
    bool null()
    {
        return true;
    }

    // called when a boolean is parsed; value is passed
    bool boolean(bool)
    {
        return true;
    }

    bool number_integer(number_integer_t val)
    {
        if((m_where == W_NPC_OBJ || m_where == W_EVENT_OBJ) && m_curKey == "i")
            m_outKey = val;
        return true;
    }

    bool number_unsigned(number_unsigned_t val)
    {
        if((m_where == W_NPC_OBJ || m_where == W_EVENT_OBJ) && m_curKey == "i")
            m_outKey = (int)val;
        return true;
    }

    bool number_float(number_float_t, const string_t&)
    {
        return true;
    }

    bool string(string_t& val)
    {
        if((m_where == W_NPC_OBJ || m_where == W_EVENT_OBJ) && m_curKey == "tr-id")
            m_outTrId = val;
        else if(m_where == W_NPC_OBJ && m_curKey == "talk")
            m_outValue = val;
        else if(m_where == W_EVENT_OBJ && m_curKey == "msg")
            m_outValue = val;
        else if(m_where == W_LEVEL && m_curKey == "title")
            LevelName = m_outValue;

        return true;
    }

    bool binary(binary_t&)
    {
        return true;
    }

    // called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
    bool start_object(std::size_t)
    {
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_ROOT)
            m_where = W_LEVEL;
        else if(m_where == W_NPC)
            m_where = W_NPC_OBJ;
        else if(m_where == W_EVENT)
            m_where = W_EVENT_OBJ;

        D_pLogDebug("JSON: Start Object (where=%d)", m_where);

        return true;
    }

    bool end_object()
    {
        if(m_where == W_SKIP)
            return true;

        D_pLogDebug("JSON: End Object (where=%d)", m_where);

        if(m_where == W_NPC_OBJ)
        {
            flushData();
            m_where = W_NPC;
        }
        else if(m_where == W_EVENT_OBJ)
        {
            flushData();
            m_where = W_EVENT;
        }
        else if(m_where == W_NPC)
            m_where = W_LEVEL;
        else if(m_where == W_EVENT)
            m_where = W_LEVEL;
        else if(m_where == W_LEVEL)
            return false; // All enough data has been taken

        return true;
    }

    bool start_array(std::size_t)
    {
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_ROOT)
            m_where = W_LEVEL;
        else if(m_where == W_LEVEL)
        {
            if(m_curKey == "npc")
                m_where = W_NPC;
            else if(m_curKey == "events")
                m_where = W_EVENT;
        }

        D_pLogDebug("JSON: Start Array (where=%d)", m_where);

        return true;
    }

    bool end_array()
    {
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_NPC || m_where == W_EVENT)
        {
            flushData();
            m_where = W_LEVEL;
            return true; // All enough data has been taken
        }

        return true;
    }

    // called when an object key is parsed; value is passed and can be safely moved away
    bool key(string_t& val)
    {
        m_curKey = val;

        if(m_where == W_SKIP)
        {
            if(Strings::endsWith(m_wantedKey, ".lvlx"))
                m_wantedKey.erase(m_wantedKey.end() - 1);

            if(Strings::endsWith(m_curKey, ".lvlx"))
                m_curKey.erase(m_curKey.end() - 1);

            if(m_curKey == m_wantedKey)
            {
                m_where = W_ROOT;
                D_pLogDebug("JSON: FOUND A KEY %s", val.c_str());
            }
            return true;
        }

        D_pLogDebug("JSON: Key=%s", val.c_str());

        return true;
    }

    bool parse_error(std::size_t position, const std::string& last_token, const nlohmann::detail::exception& ex)
    {
        pLogWarning("JSON parsing error: pos: %zu, last token: %s, exception: %s",
                     position, last_token.c_str(), ex.what());
        return false;
    }
};


================================================
FILE: src/main/translate/tr_script.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XTECH_TRANSLATE_EPISODE
#include <unordered_map>
#include <vector>
#include <json/json.hpp>
#include <Logger/logger.h>
#endif /* XTECH_TRANSLATE_EPISODE */

class TrScriptParser : public nlohmann::json_sax<nlohmann::json>
{
public:
    TrScriptParser() = default;
    TrScriptParser(const TrScriptParser&) = default;
    ~TrScriptParser() = default;

    std::unordered_map<int, std::string> *m_outputLines;
    std::unordered_map<std::string, std::string> *m_outputTrIdLines;
    std::string m_wantedKey;
    std::string m_curKey;

    int m_outKey = -1;
    std::string m_outTrId;
    std::string m_outValue;

    enum Where
    {
        W_SKIP = 0,
        W_ROOT,
        W_DLLTXT,
        W_LINES,
        W_LINES_OBJ
    } m_where = W_SKIP;

    void flushData()
    {
        if((m_outKey < 0 && m_outTrId.empty()) || m_outValue.empty())
            return;

        if(!m_outTrId.empty()) // By TrId
        {
            D_pLogDebug("JSON: Written %s into %s", m_outTrId.c_str(), m_outValue.c_str());
            m_outputTrIdLines->insert({m_outTrId, m_outValue});
        }
        else
        {
            D_pLogDebug("JSON: Written %d into %s", m_outKey, m_outValue.c_str());
            m_outputLines->insert({m_outKey, m_outValue});
        }

        m_outKey = -1;
        m_outTrId.clear();
        m_outValue.clear();
    }


    // called when null is parsed
    bool null()
    {
        return true;
    }

    // called when a boolean is parsed; value is passed
    bool boolean(bool)
    {
        return true;
    }

    bool number_integer(number_integer_t val)
    {
        if(m_where == W_LINES_OBJ && m_curKey == "i")
            m_outKey = val;
        return true;
    }

    bool number_unsigned(number_unsigned_t val)
    {
        if(m_where == W_LINES_OBJ && m_curKey == "i")
            m_outKey = (int)val;
        return true;
    }

    bool number_float(number_float_t, const string_t&)
    {
        return true;
    }

    bool string(string_t& val)
    {
        if(m_where == W_LINES_OBJ && m_curKey == "tr-id")
            m_outTrId = val;
        else if(m_where == W_LINES_OBJ && m_curKey == "tr")
            m_outValue = val;
        return true;
    }

    bool binary(binary_t&)
    {
        return true;
    }

    // called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
    bool start_object(std::size_t)
    {
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_ROOT)
            m_where = W_DLLTXT;
        else if(m_where == W_LINES)
            m_where = W_LINES_OBJ;

        D_pLogDebug("JSON: Start Object (where=%d)", m_where);

        return true;
    }

    bool end_object()
    {
        if(m_where == W_SKIP)
            return true;

        D_pLogDebug("JSON: End Object (where=%d)", m_where);

        if(m_where == W_LINES_OBJ)
        {
            flushData();
            m_where = W_LINES;
        }
        else if(m_where == W_LINES)
            m_where = W_DLLTXT;
        else if(m_where == W_DLLTXT)
            return false; // All enough data has been taken

        return true;
    }

    bool start_array(std::size_t)
    {
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_ROOT)
            m_where = W_DLLTXT;
        else if(m_where == W_DLLTXT && m_curKey == "lines")
            m_where = W_LINES;

        D_pLogDebug("JSON: Start Array (where=%d)", m_where);

        return true;
    }

    bool end_array()
    {
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_LINES)
        {
            flushData();
            m_where = W_DLLTXT;
            return true; // All enough data has been taken
        }

        return true;
    }

    // called when an object key is parsed; value is passed and can be safely moved away
    bool key(string_t& val)
    {
        m_curKey = val;

        if(m_where == W_SKIP)
        {
            if(m_curKey == m_wantedKey)
            {
                m_where = W_ROOT;
                D_pLogDebug("JSON: FOUND A KEY %s", val.c_str());
            }
            return true;
        }

        D_pLogDebug("JSON: Key=%s", val.c_str());

        return true;
    }

    bool parse_error(std::size_t position, const std::string& last_token, const nlohmann::detail::exception& ex)
    {
        pLogWarning("JSON parsing error: pos: %zu, last token: %s, exception: %s",
                     position, last_token.c_str(), ex.what());
        return false;
    }
};


================================================
FILE: src/main/translate/tr_title.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XTECH_TRANSLATE_EPISODE
#include <json/json.hpp>
#include <Logger/logger.h>
#endif /* XTECH_TRANSLATE_EPISODE */

class TrTitleParser : public nlohmann::json_sax<nlohmann::json>
{
public:
    TrTitleParser() = default;
    TrTitleParser(const TrTitleParser&) = default;
    ~TrTitleParser() = default;

    const std::string m_wantedKeyTitle = " episode_title";
    const std::string m_wantedKeyWorld = " episode_world";
    std::string m_wantedWorld;
    std::string m_curKey;
    std::string m_curWorld;
    int depth = 0;

    std::string *m_toWrite = nullptr;
    std::string m_outValue;
    bool m_hasValue = false;
    bool m_hasWorldTitle = false;

    // called when null is parsed
    bool null()
    {
        return true;
    }

    // called when a boolean is parsed; value is passed
    bool boolean(bool)
    {
        return true;
    }

    bool number_integer(number_integer_t)
    {
        return true;
    }

    bool number_unsigned(number_unsigned_t)
    {
        return true;
    }

    bool number_float(number_float_t, const string_t&)
    {
        return true;
    }

    bool string(string_t& val)
    {
        if(m_curKey == m_wantedKeyTitle && !val.empty())
        {
            m_outValue = val;
            m_hasValue = true;
        }

        else if(m_curKey == m_wantedKeyWorld && !val.empty())
        {
            m_curWorld = val;
            m_hasWorldTitle = true;
        }

        if(m_hasWorldTitle && m_hasValue)
        {
            if(m_curWorld == m_wantedWorld)
                *m_toWrite = m_outValue;
            return false; // We found that we looked for
        }

        return true;
    }

    bool binary(binary_t&)
    {
        return true;
    }

    // called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
    bool start_object(std::size_t)
    {
        ++depth;
        D_pLogDebug("JSON: Start Object, depth=%d", depth);
        if(depth > 1)
            return false;
        return true;
    }

    bool end_object()
    {
        --depth;
        D_pLogDebug("JSON: End Object, depth=%d", depth);
        return true;
    }

    bool start_array(std::size_t)
    {
        ++depth;
        return true;
    }

    bool end_array()
    {
        --depth;
        return true;
    }

    // called when an object key is parsed; value is passed and can be safely moved away
    bool key(string_t& val)
    {
        m_curKey = val;
        D_pLogDebug("JSON: Key=%s", val.c_str());

        return true;
    }

    bool parse_error(std::size_t position, const std::string& last_token, const nlohmann::detail::exception& ex)
    {
        pLogWarning("JSON parsing error: pos: %zu, last token: %s, exception: %s",
                     position, last_token.c_str(), ex.what());
        return false;
    }
};


================================================
FILE: src/main/translate/tr_world.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XTECH_TRANSLATE_EPISODE
#include <unordered_map>
#include <vector>
#include <json/json.hpp>
#include <Logger/logger.h>
#include <Utils/strings.h>
#include "globals.h"
#endif /* XTECH_TRANSLATE_EPISODE */

class TrWorldParser : public nlohmann::json_sax<nlohmann::json>
{
public:
    TrWorldParser()
    {
        // Build the map of tr-id objects
        for(int i = 1; i <= numWorldLevels; ++i)
        {
            auto &it = m_trIdMapLevel[WorldLevel[i].LevelName];
            it.push_back(i);
        }
    }

    TrWorldParser(const TrWorldParser&) = default;
    ~TrWorldParser() = default;

    std::string m_wantedKey;
    std::string m_curKey;

    int m_outKey = -1;
    std::string m_outTrId;
    std::string m_outValue;

    enum Where
    {
        W_SKIP = 0,
        W_ROOT,
        W_WORLD,
        W_LEVELS,  W_LEVEL_OBJ
    } m_where = W_SKIP;
    int m_depth = 0;

    std::unordered_map<std::string, std::vector<int /*WorldLevel index*/> > m_trIdMapLevel;

    void flushData()
    {
        if((m_outKey < 0 && m_outTrId.empty()) || m_outValue.empty())
            return;

        if(!m_outTrId.empty()) // By TrId
        {
            D_pLogDebug("JSON: Written %s into %s", m_outTrId.c_str(), m_outValue.c_str());
            auto it = m_trIdMapLevel.find(m_outTrId);
            if(it != m_trIdMapLevel.end())
            {
                for(auto &k : it->second)
                    WorldLevel[k].LevelName = m_outValue;
            }
        }
        else
        {
            D_pLogDebug("JSON: Written %d into %s", m_outKey, m_outValue.c_str());

            if(m_where == W_LEVEL_OBJ && m_outKey < numWorldLevels)
                WorldLevel[m_outKey + 1].LevelName = m_outValue;
        }

        m_outKey = -1;
        m_outTrId.clear();
        m_outValue.clear();
    }


    // called when null is parsed
    bool null()
    {
        return true;
    }

    // called when a boolean is parsed; value is passed
    bool boolean(bool)
    {
        return true;
    }

    bool number_integer(number_integer_t val)
    {
        if(m_where == W_LEVEL_OBJ && m_curKey == "i")
            m_outKey = val;
        return true;
    }

    bool number_unsigned(number_unsigned_t val)
    {
        if(m_where == W_LEVEL_OBJ && m_curKey == "i")
            m_outKey = (int)val;
        return true;
    }

    bool number_float(number_float_t, const string_t&)
    {
        return true;
    }

    bool string(string_t& val)
    {
        if(m_where == W_LEVEL_OBJ && m_curKey == "tr-id")
            m_outTrId = val;
        else if(m_where == W_LEVEL_OBJ && m_curKey == "tit")
            m_outValue = val;
        else if(m_where == W_WORLD && m_curKey == "title")
            WorldName = val;
        else if(m_where == W_WORLD && m_curKey == "credits")
        {
            std::string credits(val);
            int B = 0;
            std::vector<std::string> authorsList;

            if(!credits.empty())
            {
                numWorldCredits = 0;
                for(int i = 1; i <= maxWorldCredits; i++)
                    WorldCredits[i].clear();

                Strings::split(authorsList, credits, "\n");
                for(auto &c : authorsList)
                {
                    ++B;
                    if(B > maxWorldCredits)
                        break;
                    WorldCredits[B] = c;
                    numWorldCredits = B;
                }
            }
        }

        return true;
    }

    bool binary(binary_t&)
    {
        return true;
    }

    // called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
    bool start_object(std::size_t)
    {
        ++m_depth;
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_ROOT)
            m_where = W_WORLD;
        else if(m_where == W_LEVELS)
            m_where = W_LEVEL_OBJ;

        D_pLogDebug("JSON: Start Object (where=%d)", m_where);

        return true;
    }

    bool end_object()
    {
        --m_depth;
        if(m_where == W_SKIP)
            return true;

        D_pLogDebug("JSON: End Object (where=%d)", m_where);

        if(m_where == W_LEVEL_OBJ)
        {
            flushData();
            m_where = W_LEVELS;
        }
        else if(m_where == W_LEVELS)
            m_where = W_WORLD;
        else if(m_where == W_WORLD)
            return false; // All enough data has been taken

        return true;
    }

    bool start_array(std::size_t)
    {
        ++m_depth;
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_ROOT)
            m_where = W_WORLD;
        else if(m_where == W_WORLD)
        {
            if(m_curKey == "levels")
                m_where = W_LEVELS;
        }

        D_pLogDebug("JSON: Start Array (where=%d, depth=%d)", m_where, m_depth);

        return true;
    }

    bool end_array()
    {
        --m_depth;
        if(m_where == W_SKIP)
            return true;

        if(m_where == W_LEVELS)
        {
            flushData();
            m_where = W_WORLD;
            return true; // All enough data has been taken
        }

        return true;
    }

    // called when an object key is parsed; value is passed and can be safely moved away
    bool key(string_t& val)
    {
        m_curKey = val;

        if(m_where == W_SKIP)
        {
            if(Strings::endsWith(m_wantedKey, ".wldx"))
                m_wantedKey.erase(m_wantedKey.end() - 1);

            if(Strings::endsWith(m_curKey, ".wldx"))
                m_curKey.erase(m_curKey.end() - 1);

            if(m_curKey == m_wantedKey)
            {
                m_where = W_ROOT;
                D_pLogDebug("JSON: FOUND A KEY %s", val.c_str());
            }
            return true;
        }

        D_pLogDebug("JSON: Key=%s", val.c_str());

        return true;
    }

    bool parse_error(std::size_t position, const std::string& last_token, const nlohmann::detail::exception& ex)
    {
        pLogWarning("JSON parsing error: pos: %zu, last token: %s, exception: %s",
                     position, last_token.c_str(), ex.what());
        return false;
    }
};


================================================
FILE: src/main/translate.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>
#include <DirManager/dirman.h>
#include <AppPath/app_path.h>
#include <Utils/files.h>
#include <Utils/strings.h>
#include <json/json_rwops_input.hpp>
#include <json/json.hpp>
#include <fmt_format_ne.h>

#ifndef SDL_SDL_STDINC_H
#include "sdl_proxy/sdl_stdinc.h"
#endif

#ifndef GLOBALS_H
#include "globals.h"
#endif

#include "fontman/font_manager.h"
#include "core/language.h"

#include "translate.h"
#include "main/menu_main.h"
#include "main/game_info.h"
#include "main/outro_loop.h"
#include "main/game_strings.h"
#include "main/hints.h"

#include "controls.h"
#include "config.h"
#include "control/controls_strings.h"

#include "editor/editor_strings.h"
#include "editor/editor_custom.h"

#include "script/luna/luna.h"

#if TR_MAP_TYPE == 1 && !defined(THEXTECH_DISABLE_LANG_TOOLS)
#   include <sorting/tinysort.h>
#endif


enum class PluralRules
{
    SingularOnly,
    OneIsSingular,
    Slavic,
};

static PluralRules s_CurrentPluralRules = PluralRules::OneIsSingular;

const std::string& LanguageFormatSlavic(int number, const std::string& singular, const std::string& dual, const std::string& plural)
{
    if(((number % 100) != 11) && ((number % 10) == 1))
        return singular;
    else if((number % 10) >= 2 && (number % 10) <= 4 && (number % 100 < 10 || number % 100 > 20))
        return dual;
    else
        return plural;
}

const std::string& LanguageFormatNumber(int number, const std::string& singular, const std::string& dual, const std::string& plural)
{
    // Ensure it's always positive number
    number = SDL_abs(number);

    if(s_CurrentPluralRules == PluralRules::OneIsSingular)
        return (number == 1) ? singular : plural;
    else if(s_CurrentPluralRules == PluralRules::Slavic)
        return LanguageFormatSlavic(number, singular, dual, plural);
    else // if(s_CurrentPluralRules == PluralRules::SingularOnly)
        return singular;
}

#ifndef THEXTECH_DISABLE_LANG_TOOLS
static void setJsonValue(nlohmann::ordered_json &j, const std::string &key, const std::string &value)
{
    auto dot = key.find(".");
    if(dot == std::string::npos)
    {
        j[key] = value;
        return;
    }

    std::string subKey = key.substr(0, dot);
    setJsonValue(j[subKey], key.substr(dot + 1), value);
}

static bool setJsonValueIfNotExist(nlohmann::ordered_json &j, const std::string &key, const std::string &value, bool noBlank)
{
    auto dot = key.find(".");
    if(dot == std::string::npos)
    {
        if(!j.contains(key) || j.is_null())
        {
            std::printf("-- ++ Added new string: %s = %s\n", key.c_str(), value.c_str());
            std::fflush(stdout);
            if(!noBlank || !value.empty())
                j[key] = value;
            else if(j.contains(key))
                j.erase(key);
            return true;
        }
        return false; // Nothing changed
    }

    std::string subKey = key.substr(0, dot);
    bool ret = setJsonValueIfNotExist(j[subKey], key.substr(dot + 1), value, noBlank);

    if(noBlank && (j[subKey].is_null() || j[subKey].empty()))
        j.erase(subKey);

    return ret;
}
#endif

static std::string getJsonValue(nlohmann::ordered_json &j, const std::string &key, const std::string &defVal)
{
    auto dot = key.find(".");
    if(dot == std::string::npos)
    {
        if(!j.contains(key) || j[key].is_null())
            return defVal;

        auto out = j.value(key, defVal);

        if(out.empty()) // For empty lines, return default value
            return defVal;

        return out;
    }

    std::string subKey = key.substr(0, dot);
    return getJsonValue(j[subKey], key.substr(dot + 1), defVal);
}

#ifndef THEXTECH_DISABLE_LANG_TOOLS
static bool saveFile(const std::string &inPath, const std::string &inData)
{
    bool ret = true;
    SDL_RWops *in = Files::open_file(inPath, "w");
    if(!in)
        return false;

    SDL_RWwrite(in, inData.c_str(), 1, inData.size());
    SDL_RWwrite(in, "\n", 1, 1);

    SDL_RWclose(in);

    return ret;
}
#endif


void XTechTranslate::insert(TrList &list, const char *key, std::string *value)
{
#if defined(DEBUG_BUILD) && TR_MAP_TYPE == 1
    for(auto &k : list)
    {
        if(k.first.compare(key) == 0)
            SDL_assert_release(false && "Duplicated translation line detected!");
    }
#endif
    list.TR_MAP_INSERT({key, value});
}

void XTechTranslate::insert(TrList &list, std::string &&key, std::string *value)
{
#if defined(DEBUG_BUILD) && TR_MAP_TYPE == 1
    for(auto &k : list)
    {
        if(k.first.compare(key) == 0)
            SDL_assert_release(false && "Duplicated translation line detected!");
    }
#endif
    list.TR_MAP_INSERT({key, value});
}

XTechTranslate::XTechTranslate()
{
    // List of all translatable strings of the engine
    m_engineMap.clear();

    insert(m_engineMap, "menu.main.mainPlayEpisode",            &g_mainMenu.mainPlayEpisode);
    insert(m_engineMap, "menu.main.main1PlayerGame",            &g_mainMenu.main1PlayerGame);
    insert(m_engineMap, "menu.main.mainMultiplayerGame",        &g_mainMenu.mainMultiplayerGame);
    insert(m_engineMap, "menu.main.mainBattleGame",             &g_mainMenu.mainBattleGame);
    insert(m_engineMap, "menu.main.mainEditor",                 &g_mainMenu.mainEditor);
    insert(m_engineMap, "menu.main.mainOptions",                &g_mainMenu.mainOptions);
    insert(m_engineMap, "menu.main.mainExit",                   &g_mainMenu.mainExit);

    insert(m_engineMap, "menu.loading",                         &g_mainMenu.loading);

    insert(m_engineMap, "languageName",                         &g_mainMenu.languageName);
    insert(m_engineMap, "pluralRules",                          &g_mainMenu.pluralRules);

    insert(m_engineMap, "menu.editor.battles",                  &g_mainMenu.editorBattles);
    insert(m_engineMap, "menu.editor.newWorld",                 &g_mainMenu.editorNewWorld);
    insert(m_engineMap, "menu.editor.makeFor",                  &g_mainMenu.editorMakeFor);
    insert(m_engineMap, "menu.editor.errorMissingResources",    &g_mainMenu.editorErrorMissingResources);
    insert(m_engineMap, "menu.editor.promptNewWorldName",       &g_mainMenu.editorPromptNewWorldName);

    insert(m_engineMap, "menu.game.gameNoEpisodesToPlay",       &g_mainMenu.gameNoEpisodesToPlay);
    insert(m_engineMap, "menu.game.gameNoBattleLevels",         &g_mainMenu.gameNoBattleLevels);
    insert(m_engineMap, "menu.game.gameBattleRandom",           &g_mainMenu.gameBattleRandom);

    insert(m_engineMap, "menu.game.warnEpCompat",               &g_mainMenu.warnEpCompat);

    insert(m_engineMap, "menu.game.gameSlotContinue",           &g_mainMenu.gameSlotContinue);
    insert(m_engineMap, "menu.game.gameSlotNew",                &g_mainMenu.gameSlotNew);

    insert(m_engineMap, "menu.game.gameCopySave",               &g_mainMenu.gameCopySave);
    insert(m_engineMap, "menu.game.gameEraseSave",              &g_mainMenu.gameEraseSave);

    insert(m_engineMap, "menu.game.gameSourceSlot",             &g_mainMenu.gameSourceSlot);
    insert(m_engineMap, "menu.game.gameTargetSlot",             &g_mainMenu.gameTargetSlot);
    insert(m_engineMap, "menu.game.gameEraseSlot",              &g_mainMenu.gameEraseSlot);

    insert(m_engineMap, "menu.game.phraseScore",                &g_mainMenu.phraseScore);
    insert(m_engineMap, "menu.game.phraseTime",                 &g_mainMenu.phraseTime);

    insert(m_engineMap, "menu.battle.errorNoLevels",            &g_mainMenu.errorBattleNoLevels);

    insert(m_engineMap, "menu.options.restartEngine",           &g_mainMenu.optionsRestartEngine);

    insert(m_engineMap, "menu.character.selectCharacter",       &g_mainMenu.selectCharacter);


    insert(m_engineMap, "menu.controls.controlsTitle",          &g_mainMenu.controlsTitle);
    insert(m_engineMap, "menu.controls.controlsConnected",      &g_mainMenu.controlsConnected);
    insert(m_engineMap, "menu.controls.controlsDeleteKey2",     &g_mainMenu.controlsDeleteKey);
    insert(m_engineMap, "menu.controls.controlsDeviceTypes",    &g_mainMenu.controlsDeviceTypes);
    insert(m_engineMap, "menu.controls.controlsInUse",          &g_mainMenu.controlsInUse);
    insert(m_engineMap, "menu.controls.controlsNotInUse",       &g_mainMenu.controlsNotInUse);

    insert(m_engineMap, "menu.controls.wordProfiles",           &g_mainMenu.wordProfiles);
    insert(m_engineMap, "menu.controls.wordButtons",            &g_mainMenu.wordButtons);

    insert(m_engineMap, "menu.controls.controlsReallyDeleteProfile", &g_mainMenu.controlsReallyDeleteProfile);
    insert(m_engineMap, "menu.controls.controlsNewProfile",     &g_mainMenu.controlsNewProfile);
    insert(m_engineMap, "menu.controls.caseInvalid",            &g_controlsStrings.sharedCaseInvalid);

    insert(m_engineMap, "menu.controls.profile.renameProfile",  &g_mainMenu.controlsRenameProfile);
    insert(m_engineMap, "menu.controls.profile.deleteProfile",  &g_mainMenu.controlsDeleteProfile);
    insert(m_engineMap, "menu.controls.profile.playerControls", &g_mainMenu.controlsPlayerControls);
    insert(m_engineMap, "menu.controls.profile.cursorControls", &g_mainMenu.controlsCursorControls);
    insert(m_engineMap, "menu.controls.profile.editorControls", &g_mainMenu.controlsEditorControls);
    insert(m_engineMap, "menu.controls.profile.hotkeys",        &g_mainMenu.controlsHotkeys);

    insert(m_engineMap, "menu.controls.options.rumble",         &g_mainMenu.controlsOptionRumble);
    insert(m_engineMap, "menu.controls.options.batteryStatus",  &g_mainMenu.controlsOptionBatteryStatus);
    insert(m_engineMap, "menu.controls.options.altMenuControls",  &g_mainMenu.controlsOptionAltMenuControls);
    insert(m_engineMap, "menu.controls.options.maxPlayers",     &g_controlsStrings.sharedOptionMaxPlayers);

    insert(m_engineMap, "menu.controls.buttons.up",      &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Up]);
    insert(m_engineMap, "menu.controls.buttons.down",    &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Down]);
    insert(m_engineMap, "menu.controls.buttons.left",    &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Left]);
    insert(m_engineMap, "menu.controls.buttons.right",   &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Right]);
    insert(m_engineMap, "menu.controls.buttons.jump",    &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Jump]);
    insert(m_engineMap, "menu.controls.buttons.run",     &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Run]);
    insert(m_engineMap, "menu.controls.buttons.altJump", &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::AltJump]);
    insert(m_engineMap, "menu.controls.buttons.altRun",  &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::AltRun]);
    insert(m_engineMap, "menu.controls.buttons.start",   &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Start]);
    insert(m_engineMap, "menu.controls.buttons.drop",    &Controls::PlayerControls::g_button_name_UI[Controls::PlayerControls::Drop]);

    insert(m_engineMap, "menu.controls.cursor.up",        &Controls::CursorControls::g_button_name_UI[Controls::CursorControls::CursorUp]);
    insert(m_engineMap, "menu.controls.cursor.down",      &Controls::CursorControls::g_button_name_UI[Controls::CursorControls::CursorDown]);
    insert(m_engineMap, "menu.controls.cursor.left",      &Controls::CursorControls::g_button_name_UI[Controls::CursorControls::CursorLeft]);
    insert(m_engineMap, "menu.controls.cursor.right",     &Controls::CursorControls::g_button_name_UI[Controls::CursorControls::CursorRight]);
    insert(m_engineMap, "menu.controls.cursor.primary",   &Controls::CursorControls::g_button_name_UI[Controls::CursorControls::Primary]);
    insert(m_engineMap, "menu.controls.cursor.secondary", &Controls::CursorControls::g_button_name_UI[Controls::CursorControls::Secondary]);
    insert(m_engineMap, "menu.controls.cursor.tertiary",  &Controls::CursorControls::g_button_name_UI[Controls::CursorControls::Tertiary]);

    insert(m_engineMap, "menu.controls.editor.scrollUp",      &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::ScrollUp]);
    insert(m_engineMap, "menu.controls.editor.scrollDown",    &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::ScrollDown]);
    insert(m_engineMap, "menu.controls.editor.scrollLeft",    &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::ScrollLeft]);
    insert(m_engineMap, "menu.controls.editor.scrollRight",   &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::ScrollRight]);
    insert(m_engineMap, "menu.controls.editor.fastScroll",    &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::FastScroll]);
    insert(m_engineMap, "menu.controls.editor.modeSelect",    &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::ModeSelect]);
    insert(m_engineMap, "menu.controls.editor.modeErase",     &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::ModeErase]);
    insert(m_engineMap, "menu.controls.editor.prevSection",   &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::PrevSection]);
    insert(m_engineMap, "menu.controls.editor.nextSection",   &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::NextSection]);
    insert(m_engineMap, "menu.controls.editor.switchScreens", &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::SwitchScreens]);
    insert(m_engineMap, "menu.controls.editor.testPlay",      &Controls::EditorControls::g_button_name_UI[Controls::EditorControls::TestPlay]);

#ifndef RENDER_FULLSCREEN_ALWAYS
    insert(m_engineMap, "menu.controls.hotkeys.fullscreen",  &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::Fullscreen]);
#endif
#ifdef USE_SCREENSHOTS_AND_RECS
    insert(m_engineMap, "menu.controls.hotkeys.screenshot",  &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::Screenshot]);
#endif
#ifdef PGE_ENABLE_VIDEO_REC
    insert(m_engineMap, "menu.controls.hotkeys.recordGif",   &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::RecordGif]);
#endif
    insert(m_engineMap, "menu.controls.hotkeys.debugInfo",   &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::DebugInfo]);
    insert(m_engineMap, "menu.controls.hotkeys.vanillaCam",  &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::VanillaCam]);
    insert(m_engineMap, "menu.controls.hotkeys.enterCheats", &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::EnterCheats]);
    insert(m_engineMap, "menu.controls.hotkeys.toggleHUD",   &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::ToggleHUD]);
    insert(m_engineMap, "menu.controls.hotkeys.legacyPause", &Controls::Hotkeys::g_button_name_UI[Controls::Hotkeys::LegacyPause]);

#ifdef CONTROLS_KEYBOARD_STRINGS
    insert(m_engineMap, "menu.controls.types.keyboard",    &g_controlsStrings.nameKeyboard);
    insert(m_engineMap, "menu.controls.options.textEntryStyle",    &g_controlsStrings.keyboardOptionTextEntryStyle);
    insert(m_engineMap, "menu.controls.caseMouse",         &g_controlsStrings.caseMouse);
#endif

#if defined(CONTROLS_KEYBOARD_STRINGS) || defined(CONTROLS_JOYSTICK_STRINGS)
    insert(m_engineMap, "menu.controls.types.gamepad",     &g_controlsStrings.nameGamepad);
#endif

#if defined(CONTROLS_JOYSTICK_STRINGS)
    insert(m_engineMap, "menu.controls.phraseNewProfOldJoy",&g_controlsStrings.phraseNewProfOldJoy);
    insert(m_engineMap, "menu.controls.types.oldJoystick", &g_controlsStrings.nameOldJoy);
#endif

#if defined(CONTROLS_JOYSTICK_STRINGS) || defined(CONTROLS_WII_STRINGS)
    insert(m_engineMap, "menu.controls.joystickSimpleEditor",&g_controlsStrings.joystickSimpleEditor);
#endif

#if defined(CONTROLS_TOUCHSCREEN_STRINGS)
    insert(m_engineMap, "menu.controls.types.touchscreen", &g_controlsStrings.nameTouchscreen);

    insert(m_engineMap, "menu.controls.caseTouch",         &g_controlsStrings.caseTouch);

    insert(m_engineMap, "menu.controls.touchscreen.option.layoutStyle",    &g_controlsStrings.touchscreenOptionLayoutStyle);
    insert(m_engineMap, "menu.controls.touchscreen.option.scaleFactor",    &g_controlsStrings.touchscreenOptionScaleFactor);
    insert(m_engineMap, "menu.controls.touchscreen.option.scaleDPad",      &g_controlsStrings.touchscreenOptionScaleDPad);
    insert(m_engineMap, "menu.controls.touchscreen.option.scaleButtons",   &g_controlsStrings.touchscreenOptionScaleButtons);
    insert(m_engineMap, "menu.controls.touchscreen.option.sStartSpacing",  &g_controlsStrings.touchscreenOptionSStartSpacing);
    insert(m_engineMap, "menu.controls.touchscreen.option.resetLayout",    &g_controlsStrings.touchscreenOptionResetLayout);
    insert(m_engineMap, "menu.controls.touchscreen.option.interfaceStyle", &g_controlsStrings.touchscreenOptionInterfaceStyle);
    insert(m_engineMap, "menu.controls.touchscreen.option.feedbackStrength", &g_controlsStrings.touchscreenOptionFeedbackStrength);
    insert(m_engineMap, "menu.controls.touchscreen.option.feedbackLength", &g_controlsStrings.touchscreenOptionFeedbackLength);
    insert(m_engineMap, "menu.controls.touchscreen.option.holdRun",        &g_controlsStrings.touchscreenOptionHoldRun);
    insert(m_engineMap, "menu.controls.touchscreen.option.showCodeButton", &g_controlsStrings.touchscreenOptionShowCodeButton);


    insert(m_engineMap, "menu.controls.touchscreen.layout.tight",          &g_controlsStrings.touchscreenLayoutTight);
    insert(m_engineMap, "menu.controls.touchscreen.layout.tinyOld",        &g_controlsStrings.touchscreenLayoutTinyOld);
    insert(m_engineMap, "menu.controls.touchscreen.layout.phoneOld",       &g_controlsStrings.touchscreenLayoutPhoneOld);
    insert(m_engineMap, "menu.controls.touchscreen.layout.longOld",        &g_controlsStrings.touchscreenLayoutLongOld);
    insert(m_engineMap, "menu.controls.touchscreen.layout.phabletOld",     &g_controlsStrings.touchscreenLayoutPhabletOld);
    insert(m_engineMap, "menu.controls.touchscreen.layout.tabletOld",      &g_controlsStrings.touchscreenLayoutTabletOld);
    insert(m_engineMap, "menu.controls.touchscreen.layout.standard",       &g_controlsStrings.touchscreenLayoutStandard);

    insert(m_engineMap, "menu.controls.touchscreen.style.actions",         &g_controlsStrings.touchscreenStyleActions);
    insert(m_engineMap, "menu.controls.touchscreen.style.ABXY",            &g_controlsStrings.touchscreenStyleABXY);
    insert(m_engineMap, "menu.controls.touchscreen.style.XODA",            &g_controlsStrings.touchscreenStyleXODA);
#endif // #if defined(CONTROLS_TOUCHSCREEN_STRINGS)

#if defined(CONTROLS_16M_STRINGS)
    insert(m_engineMap, "menu.controls.tDS.buttonA",      &g_controlsStrings.tdsButtonA);
    insert(m_engineMap, "menu.controls.tDS.buttonB",      &g_controlsStrings.tdsButtonB);
    insert(m_engineMap, "menu.controls.tDS.buttonX",      &g_controlsStrings.tdsButtonX);
    insert(m_engineMap, "menu.controls.tDS.buttonY",      &g_controlsStrings.tdsButtonY);
    insert(m_engineMap, "menu.controls.tDS.buttonL",      &g_controlsStrings.tdsButtonL);
    insert(m_engineMap, "menu.controls.tDS.buttonR",      &g_controlsStrings.tdsButtonR);
    insert(m_engineMap, "menu.controls.tDS.buttonSelect", &g_controlsStrings.tdsButtonSelect);
    insert(m_engineMap, "menu.controls.tDS.buttonStart",  &g_controlsStrings.tdsButtonStart);

    insert(m_engineMap, "menu.controls.tDS.casePen",      &g_controlsStrings.tdsCasePen);
#endif // #ifdef CONTROLS_16M_STRINGS

#if defined(CONTROLS_3DS_STRINGS)
    insert(m_engineMap, "menu.controls.tDS.buttonZL",     &g_controlsStrings.tdsButtonZL);
    insert(m_engineMap, "menu.controls.tDS.buttonZR",     &g_controlsStrings.tdsButtonZR);
    insert(m_engineMap, "menu.controls.tDS.dPad",         &g_controlsStrings.tdsDpad);
    insert(m_engineMap, "menu.controls.tDS.tStick",       &g_controlsStrings.tdsTstick);
    insert(m_engineMap, "menu.controls.tDS.cStick",       &g_controlsStrings.tdsCstick);
#endif // #ifdef CONTROLS_3DS_STRINGS

#if defined(CONTROLS_WII_STRINGS)
    insert(m_engineMap, "menu.controls.wii.typeWiimote",         &g_controlsStrings.wiiTypeWiimote);
    insert(m_engineMap, "menu.controls.wii.typeNunchuck",        &g_controlsStrings.wiiTypeNunchuck);
    insert(m_engineMap, "menu.controls.wii.typeClassic",         &g_controlsStrings.wiiTypeClassic);
    insert(m_engineMap, "menu.controls.wii.typeGamecube",        &g_controlsStrings.wiiTypeGamecube);
    insert(m_engineMap, "menu.controls.wii.phraseNewNunchuck",   &g_controlsStrings.wiiPhraseNewNunchuck);
    insert(m_engineMap, "menu.controls.wii.phraseNewClassic",    &g_controlsStrings.wiiPhraseNewClassic);

    insert(m_engineMap, "menu.controls.wii.wiimote.dPad",        &g_controlsStrings.wiiDpad);
    insert(m_engineMap, "menu.controls.wii.wiimote.buttonA",     &g_controlsStrings.wiiButtonA);
    insert(m_engineMap, "menu.controls.wii.wiimote.buttonB",     &g_controlsStrings.wiiButtonB);
    insert(m_engineMap, "menu.controls.wii.wiimote.buttonMinus", &g_controlsStrings.wiiButtonMinus);
    insert(m_engineMap, "menu.controls.wii.wiimote.buttonPlus",  &g_controlsStrings.wiiButtonPlus);
    insert(m_engineMap, "menu.controls.wii.wiimote.buttonHome",  &g_controlsStrings.wiiButtonHome);
    insert(m_engineMap, "menu.controls.wii.wiimote.button2",     &g_controlsStrings.wiiButton2);
    insert(m_engineMap, "menu.controls.wii.wiimote.button1",     &g_controlsStrings.wiiButton1);
    insert(m_engineMap, "menu.controls.wii.wiimote.shake",       &g_controlsStrings.wiiShake);
    insert(m_engineMap, "menu.controls.wii.wiimote.caseIR",      &g_controlsStrings.wiiCaseIR);

    insert(m_engineMap, "menu.controls.wii.nunchuck.prefixN",    &g_controlsStrings.wiiPrefixNunchuck);
    insert(m_engineMap, "menu.controls.wii.nunchuck.buttonZ",    &g_controlsStrings.wiiButtonZ);
    insert(m_engineMap, "menu.controls.wii.nunchuck.buttonC",    &g_controlsStrings.wiiButtonC);

    insert(m_engineMap, "menu.controls.wii.classic.lStick",      &g_controlsStrings.wiiLStick);
    insert(m_engineMap, "menu.controls.wii.classic.rStick",      &g_controlsStrings.wiiRStick);
    insert(m_engineMap, "menu.controls.wii.classic.buttonZL",    &g_controlsStrings.wiiButtonZL);
    insert(m_engineMap, "menu.controls.wii.classic.buttonZR",    &g_controlsStrings.wiiButtonZR);
    insert(m_engineMap, "menu.controls.wii.classic.buttonLT",    &g_controlsStrings.wiiButtonLT);
    insert(m_engineMap, "menu.controls.wii.classic.buttonRT",    &g_controlsStrings.wiiButtonRT);
    insert(m_engineMap, "menu.controls.wii.classic.buttonX",     &g_controlsStrings.wiiButtonX);
    insert(m_engineMap, "menu.controls.wii.classic.buttonY",     &g_controlsStrings.wiiButtonY);
#endif // #ifdef CONTROLS_WII_STRINGS

    insert(m_engineMap, "menu.wordNo",         &g_mainMenu.wordNo);
    insert(m_engineMap, "menu.wordYes",        &g_mainMenu.wordYes);
    insert(m_engineMap, "menu.caseNone",       &g_mainMenu.caseNone);
    insert(m_engineMap, "menu.wordOn",         &g_mainMenu.wordOn);
    insert(m_engineMap, "menu.wordOff",        &g_mainMenu.wordOff);
    insert(m_engineMap, "menu.wordShow",       &g_mainMenu.wordShow);
    insert(m_engineMap, "menu.wordHide",       &g_mainMenu.wordHide);
    insert(m_engineMap, "menu.wordPlayer",     &g_mainMenu.wordPlayer);
    insert(m_engineMap, "menu.wordProfile",    &g_mainMenu.wordProfile);
    insert(m_engineMap, "menu.wordBack",       &g_mainMenu.wordBack);
    insert(m_engineMap, "menu.wordResume",     &g_mainMenu.wordResume);
    insert(m_engineMap, "menu.wordWaiting",    &g_mainMenu.wordWaiting);

    insert(m_engineMap, "menu.abbrevMilliseconds", &g_mainMenu.abbrevMilliseconds);


    insert(m_engineMap, "outro.gameCredits",           &g_outroScreen.gameCredits);
    insert(m_engineMap, "outro.engineCredits",         &g_outroScreen.engineCredits);
    insert(m_engineMap, "outro.originalBy",            &g_outroScreen.originalBy);
    insert(m_engineMap, "outro.nameAndrewSpinks",      &g_outroScreen.nameAndrewSpinks);
    insert(m_engineMap, "outro.cppPortDevelopers",     &g_outroScreen.cppPortDevelopers);
    insert(m_engineMap, "outro.nameVitalyNovichkov",   &g_outroScreen.nameVitalyNovichkov);
    insert(m_engineMap, "outro.qualityControl",        &g_outroScreen.qualityControl);
    insert(m_engineMap, "outro.psVitaPortBy",          &g_outroScreen.psVitaPortBy);
    insert(m_engineMap, "outro.levelDesign",           &g_outroScreen.levelDesign);
    insert(m_engineMap, "outro.customSprites",         &g_outroScreen.customSprites);
    insert(m_engineMap, "outro.specialThanks",         &g_outroScreen.specialThanks);


    insert(m_engineMap, "game.msgbox.sysInfoTitle",                &g_gameStrings.msgBoxTitleInfo);
    insert(m_engineMap, "game.msgbox.sysInfoWarning",              &g_gameStrings.msgBoxTitleWarning);
    insert(m_engineMap, "game.msgbox.sysInfoError",                &g_gameStrings.msgBoxTitleError);

    insert(m_engineMap, "game.loader.loading",                     &g_gameStrings.loaderLoading);
    insert(m_engineMap, "game.loader.statusLoadData",              &g_gameStrings.loaderStatusLoadData);
    insert(m_engineMap, "game.loader.statusLoadFile",              &g_gameStrings.loaderStatusLoadFile);
    insert(m_engineMap, "game.loader.statusGameInfo",              &g_gameStrings.loaderStatusGameInfo);
    insert(m_engineMap, "game.loader.statusTranslations",          &g_gameStrings.loaderStatusTranslations);
    insert(m_engineMap, "game.loader.statusAssetPacks",            &g_gameStrings.loaderStatusAssetPacks);
    insert(m_engineMap, "game.loader.statusFinishing",             &g_gameStrings.loaderStatusFinishing);

    insert(m_engineMap, "game.error.openFileFailed",               &g_gameStrings.errorOpenFileFailed);
#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    insert(m_engineMap, "game.error.openIPCDataFailed",            &g_gameStrings.errorOpenIPCDataFailed);
#endif
    insert(m_engineMap, "game.error.errorTooOldEngine",            &g_gameStrings.errorTooOldEngine);
    insert(m_engineMap, "game.error.errorTooOldGameAssets",        &g_gameStrings.errorTooOldGameAssets);
    insert(m_engineMap, "game.error.errorInvalidEnterWarp",        &g_gameStrings.errorInvalidEnterWarp);
    insert(m_engineMap, "game.error.errorNoStartPoint",            &g_gameStrings.errorNoStartPoint);
#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    insert(m_engineMap, "game.error.IPCTimeOut",                   &g_gameStrings.errorIPCTimeOut);
#endif

    insert(m_engineMap, "game.error.warpNeedStarCount",            &g_gameStrings.warpNeedStarCount);

    insert(m_engineMap, "game.message.scanningLevels",             &g_gameStrings.messageScanningLevels);
    insert(m_engineMap, "game.format.minutesSeconds",              &g_gameStrings.formatMinutesSeconds);

#if defined(THEXTECH_INTERPROC_SUPPORTED) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    insert(m_engineMap, "game.ipcStatus.waitingInput",             &g_gameStrings.ipcStatusWaitingInput);
    insert(m_engineMap, "game.ipcStatus.dataTransferStarted",      &g_gameStrings.ipcStatusDataTransferStarted);
    insert(m_engineMap, "game.ipcStatus.dataAccepted",             &g_gameStrings.ipcStatusDataAccepted);
    insert(m_engineMap, "game.ipcStatus.dataValid",                &g_gameStrings.ipcStatusDataValid);
    insert(m_engineMap, "game.ipcStatus.errorTimeout",             &g_gameStrings.ipcStatusErrorTimeout);
    insert(m_engineMap, "game.ipcStatus.loadingdone",              &g_gameStrings.ipcStatusLoadingDone);
#endif

#if !defined(NO_WINDOW_FOCUS_TRACKING) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    insert(m_engineMap, "game.screenPaused",               &g_gameStrings.screenPaused);
#endif

    insert(m_engineMap, "game.pause.continue",             &g_gameStrings.pauseItemContinue);
    insert(m_engineMap, "game.pause.restartLevel",         &g_gameStrings.pauseItemRestartLevel);
    insert(m_engineMap, "game.pause.resetCheckpoints",     &g_gameStrings.pauseItemResetCheckpoints);
    insert(m_engineMap, "game.pause.quitTesting",          &g_gameStrings.pauseItemQuitTesting);
    insert(m_engineMap, "game.pause.returnToEditor",       &g_gameStrings.pauseItemReturnToEditor);
    insert(m_engineMap, "game.pause.playerSetup",          &g_gameStrings.pauseItemPlayerSetup);
    insert(m_engineMap, "game.pause.enterCode",            &g_gameStrings.pauseItemEnterCode);
    insert(m_engineMap, "game.pause.saveAndContinue",      &g_gameStrings.pauseItemSaveAndContinue);
    insert(m_engineMap, "game.pause.saveAndQuit",          &g_gameStrings.pauseItemSaveAndQuit);
    insert(m_engineMap, "game.pause.quit",                 &g_gameStrings.pauseItemQuit);

    insert(m_engineMap, "game.connect.reconnectTitle",            &g_gameStrings.connectReconnectTitle);

    insert(m_engineMap, "game.connect.phrasePressAButton",        &g_gameStrings.connectPressAButton);

    insert(m_engineMap, "game.connect.phraseTestProfile",        &g_gameStrings.connectTestProfile);
    insert(m_engineMap, "game.connect.phraseHoldStart",           &g_gameStrings.connectHoldStart);
    insert(m_engineMap, "game.connect.wordDisconnect",            &g_gameStrings.connectDisconnect);

    insert(m_engineMap, "game.connect.phraseForceResume",         &g_gameStrings.connectForceResume);
    insert(m_engineMap, "game.connect.phraseDropPX",              &g_gameStrings.connectDropPX);

    insert(m_engineMap, "game.connect.phraseWaitingForInput",     &g_gameStrings.connectWaitingForInputDevice);
    insert(m_engineMap, "game.connect.splitPressSelect_1",        &g_gameStrings.connectPressSelectForControlsOptions_P1);
    insert(m_engineMap, "game.connect.splitPressSelect_2",        &g_gameStrings.connectPressSelectForControlsOptions_P2);

    insert(m_engineMap, "game.connect.phraseDropMe",              &g_gameStrings.connectDropMe);

#if defined(THEXTECH_ENABLE_EDITOR) || !defined(THEXTECH_DISABLE_LANG_TOOLS)
    insert(m_engineMap, "editor.block.pickContents",       &g_editorStrings.pickBlockContents);

    insert(m_engineMap, "editor.block.letterWidth",        &g_editorStrings.blockLetterWidth);
    insert(m_engineMap, "editor.block.letterHeight",       &g_editorStrings.blockLetterHeight);
    insert(m_engineMap, "editor.block.canBreak",           &g_editorStrings.blockCanBreak);
    insert(m_engineMap, "editor.block.canBreakTooltip",    &g_editorStrings.blockTooltipCanBreak);
    insert(m_engineMap, "editor.block.slick",              &g_editorStrings.blockSlick);
    insert(m_engineMap, "editor.block.invis",              &g_editorStrings.blockInvis);
    insert(m_engineMap, "editor.block.inside",             &g_editorStrings.blockInside);

    insert(m_engineMap, "editor.warp.title",               &g_editorStrings.warpTitle);
    insert(m_engineMap, "editor.warp.placing",             &g_editorStrings.warpPlacing);
    insert(m_engineMap, "editor.warp.in",                  &g_editorStrings.warpIn);
    insert(m_engineMap, "editor.warp.out",                 &g_editorStrings.warpOut);
    insert(m_engineMap, "editor.warp.dir",                 &g_editorStrings.warpDir);
    insert(m_engineMap, "editor.warp.twoWay",              &g_editorStrings.warpTwoWay);
    insert(m_engineMap, "editor.warp.style.style",         &g_editorStrings.warpStyle);
    insert(m_engineMap, "editor.warp.style.pipe",          &g_editorStrings.warpStylePipe);
    insert(m_engineMap, "editor.warp.style.door",          &g_editorStrings.warpStyleDoor);
    insert(m_engineMap, "editor.warp.style.blipInstant",   &g_editorStrings.warpStyleBlipInstant);
    insert(m_engineMap, "editor.warp.style.portal",        &g_editorStrings.warpStylePortal);
    insert(m_engineMap, "editor.warp.effect",              &g_editorStrings.warpEffect);
    insert(m_engineMap, "editor.warp.allow",               &g_editorStrings.warpAllow);
    insert(m_engineMap, "editor.warp.item",                &g_editorStrings.warpItem);
    insert(m_engineMap, "editor.warp.ride",                &g_editorStrings.warpRide);
    insert(m_engineMap, "editor.warp.cannonExit",          &g_editorStrings.warpCannonExit);
    insert(m_engineMap, "editor.warp.speed",               &g_editorStrings.warpSpeed);
    insert(m_engineMap, "editor.warp.needStarCount",       &g_editorStrings.warpNeedStarCount);
    insert(m_engineMap, "editor.warp.needKey",             &g_editorStrings.warpNeedKey);
    insert(m_engineMap, "editor.warp.needFloor",           &g_editorStrings.warpNeedFloor);
    insert(m_engineMap, "editor.warp.starLockMessage",     &g_editorStrings.warpStarLockMessage);
    insert(m_engineMap, "editor.warp.toMap",               &g_editorStrings.warpToMap);
    insert(m_engineMap, "editor.warp.lvlWarp",             &g_editorStrings.warpLvlWarp);
    insert(m_engineMap, "editor.warp.target",              &g_editorStrings.warpTarget);
    insert(m_engineMap, "editor.warp.to",                  &g_editorStrings.warpTo);
    insert(m_engineMap, "editor.warp.showStartScene",      &g_editorStrings.warpShowStartScene);
    insert(m_engineMap, "editor.warp.showStarCount",       &g_editorStrings.warpShowStarCount);

    insert(m_engineMap, "editor.water.title",              &g_editorStrings.waterTitle);

    insert(m_engineMap, "editor.npc.inContainer",          &g_editorStrings.npcInContainer);
    insert(m_engineMap, "editor.npc.inertNice",            &g_editorStrings.npcInertNice);
    insert(m_engineMap, "editor.npc.stuckStop",            &g_editorStrings.npcStuckStop);
    insert(m_engineMap, "editor.npc.props.active",         &g_editorStrings.npcPropertyActive);
    insert(m_engineMap, "editor.npc.props.attachSurface",  &g_editorStrings.npcPropertyAttachSurface);
    insert(m_engineMap, "editor.npc.props.facing",         &g_editorStrings.npcPropertyFacing);
    insert(m_engineMap, "editor.npc.abbrevGen",            &g_editorStrings.npcAbbrevGen);

    insert(m_engineMap, "editor.npc.ai.aiIs",              &g_editorStrings.npcAiIs);
    insert(m_engineMap, "editor.npc.ai.target",            &g_editorStrings.npcAiTarget);
    insert(m_engineMap, "editor.npc.ai.jump",              &g_editorStrings.npcAiJump);
    insert(m_engineMap, "editor.npc.ai.leap",              &g_editorStrings.npcAiLeap);
    insert(m_engineMap, "editor.npc.ai.swim",              &g_editorStrings.npcAiSwim);
    insert(m_engineMap, "editor.npc.ai.LR",                &g_editorStrings.npcAiLR);
    insert(m_engineMap, "editor.npc.ai.UD",                &g_editorStrings.npcAiUD);

    insert(m_engineMap, "editor.npc.ai.headerCustomAi",    &g_editorStrings.npcCustomAi);

    insert(m_engineMap, "editor.npc.ai.use1_0Ai",          &g_editorStrings.npcUse1_0Ai);
    insert(m_engineMap, "editor.npc.tooltipExpandSection", &g_editorStrings.npcTooltipExpandSection);

    insert(m_engineMap, "editor.npc.gen.header",           &g_editorStrings.npcGenHeader);
    insert(m_engineMap, "editor.npc.gen.direction",        &g_editorStrings.npcGenDirection);
    insert(m_engineMap, "editor.npc.gen.effectIs",         &g_editorStrings.npcGenEffectIs);
    insert(m_engineMap, "editor.npc.gen.effectWarp",       &g_editorStrings.npcGenEffectWarp);
    insert(m_engineMap, "editor.npc.gen.effectShoot",      &g_editorStrings.npcGenEffectShoot);

    insert(m_engineMap, "editor.wordNPC.nominative",       &g_editorStrings.wordNPC);
    insert(m_engineMap, "editor.wordNPC.genitive",         &g_editorStrings.wordNPCGenitive);

    insert(m_engineMap, "editor.wordEvent.nominative",     &g_editorStrings.wordEvent);
    insert(m_engineMap, "editor.wordEvent.genitive",       &g_editorStrings.wordEventGenitive);
    insert(m_engineMap, "editor.wordEvent.typeLabel",      &g_editorStrings.phraseTypeLabelEvent);

    insert(m_engineMap, "editor.wordCoins",                &g_editorStrings.wordCoins);

    insert(m_engineMap, "editor.wordEnabled",              &g_editorStrings.wordEnabled);
    insert(m_engineMap, "editor.wordText",                 &g_editorStrings.wordText);
    insert(m_engineMap, "editor.wordInstant",              &g_editorStrings.wordInstant);
    insert(m_engineMap, "editor.wordMode",                 &g_editorStrings.wordMode);
    insert(m_engineMap, "editor.wordHeight",               &g_editorStrings.wordHeight);
    insert(m_engineMap, "editor.wordWidth",                &g_editorStrings.wordWidth);

    insert(m_engineMap, "editor.labelSortLayer",           &g_editorStrings.labelSortLayer);
    insert(m_engineMap, "editor.labelSortOffset",          &g_editorStrings.labelSortOffset);

    insert(m_engineMap, "editor.phraseTextOf",             &g_editorStrings.phraseTextOf);
    insert(m_engineMap, "editor.phraseSectionIndex",       &g_editorStrings.phraseSectionIndex);
    insert(m_engineMap, "editor.phraseRadiusIndex",        &g_editorStrings.phraseRadiusIndex);
    insert(m_engineMap, "editor.phraseWarpIndex",          &g_editorStrings.phraseWarpIndex);
    insert(m_engineMap, "editor.phraseGenericIndex",       &g_editorStrings.phraseGenericIndex);
    insert(m_engineMap, "editor.phraseDelayIsMs",          &g_editorStrings.phraseDelayIsMs);
    insert(m_engineMap, "editor.phraseCountMore",          &g_editorStrings.phraseCountMore);
    insert(m_engineMap, "editor.mapPos",                   &g_editorStrings.mapPos);
    insert(m_engineMap, "editor.phraseAreYouSure",         &g_editorStrings.phraseAreYouSure);
    insert(m_engineMap, "editor.pageBlankOfBlank",         &g_editorStrings.pageBlankOfBlank);

    insert(m_engineMap, "editor.letterUp",                 &g_editorStrings.letterUp);
    insert(m_engineMap, "editor.letterDown",               &g_editorStrings.letterDown);
    insert(m_engineMap, "editor.letterLeft",               &g_editorStrings.letterLeft);
    insert(m_engineMap, "editor.letterRight",              &g_editorStrings.letterRight);
    insert(m_engineMap, "editor.letterCoordX",             &g_editorStrings.letterCoordX);
    insert(m_engineMap, "editor.letterCoordY",             &g_editorStrings.letterCoordY);

    insert(m_engineMap, "editor.toggleMagicBlock",         &g_editorStrings.toggleMagicBlock);

    insert(m_engineMap, "editor.testPlay.magicHand",       &g_editorStrings.testMagicHand);
    insert(m_engineMap, "editor.testPlay.char",            &g_editorStrings.testChar);
    insert(m_engineMap, "editor.testPlay.power",           &g_editorStrings.testPower);
    insert(m_engineMap, "editor.testPlay.boot",            &g_editorStrings.testBoot);
    insert(m_engineMap, "editor.testPlay.pet",             &g_editorStrings.testPet);

    insert(m_engineMap, "editor.events.header",            &g_editorStrings.eventsHeader);

    insert(m_engineMap, "editor.events.letter.activate",    &g_editorStrings.eventsLetterActivate);
    insert(m_engineMap, "editor.events.letter.death",       &g_editorStrings.eventsLetterDeath);
    insert(m_engineMap, "editor.events.letter.talk",        &g_editorStrings.eventsLetterTalk);
    insert(m_engineMap, "editor.events.letter.layerClear",  &g_editorStrings.eventsLetterLayerClear);
    insert(m_engineMap, "editor.events.letter.hit",         &g_editorStrings.eventsLetterHit);
    insert(m_engineMap, "editor.events.letter.destroy",     &g_editorStrings.eventsLetterDestroy);
    insert(m_engineMap, "editor.events.letter.enter",       &g_editorStrings.eventsLetterEnter);

    insert(m_engineMap, "editor.events.label.next",        &g_editorStrings.eventsLabelNext);
    insert(m_engineMap, "editor.events.label.activate",    &g_editorStrings.eventsLabelActivate);
    insert(m_engineMap, "editor.events.label.death",       &g_editorStrings.eventsLabelDeath);
    insert(m_engineMap, "editor.events.label.talk",        &g_editorStrings.eventsLabelTalk);
    insert(m_engineMap, "editor.events.label.layerClear",  &g_editorStrings.eventsLabelLayerClear);
    insert(m_engineMap, "editor.events.label.hit",         &g_editorStrings.eventsLabelHit);
    insert(m_engineMap, "editor.events.label.destroy",     &g_editorStrings.eventsLabelDestroy);
    insert(m_engineMap, "editor.events.label.enter",       &g_editorStrings.eventsLabelEnter);

    insert(m_engineMap, "editor.events.desc.activate",     &g_editorStrings.eventsDescActivate);
    insert(m_engineMap, "editor.events.desc.death",        &g_editorStrings.eventsDescDeath);
    insert(m_engineMap, "editor.events.desc.talk",         &g_editorStrings.eventsDescTalk);
    insert(m_engineMap, "editor.events.desc.layerClear",   &g_editorStrings.eventsDescLayerClear);
    insert(m_engineMap, "editor.events.desc.hit",          &g_editorStrings.eventsDescHit);
    insert(m_engineMap, "editor.events.desc.destroy",      &g_editorStrings.eventsDescDestroy);
    insert(m_engineMap, "editor.events.desc.enter",        &g_editorStrings.eventsDescEnter);

    insert(m_engineMap, "editor.events.desc.phraseTriggersWhenTemplate",   &g_editorStrings.eventsDescPhraseTriggersWhenTemplate);
    insert(m_engineMap, "editor.events.desc.phraseTriggersAfterTemplate",   &g_editorStrings.eventsDescPhraseTriggersAfterTemplate);

    insert(m_engineMap, "editor.events.deletion.deletingEvent",    &g_editorStrings.eventsDeletingEvent);
    insert(m_engineMap, "editor.events.deletion.confirm",          &g_editorStrings.eventsDeletionConfirm);
    insert(m_engineMap, "editor.events.deletion.cancel",           &g_editorStrings.eventsDeletionCancel);

    insert(m_engineMap, "editor.events.promptEventText",  &g_editorStrings.eventsPromptEventText);
    insert(m_engineMap, "editor.events.promptEventName",  &g_editorStrings.eventsPromptEventName);
    insert(m_engineMap, "editor.events.itemNewEvent",     &g_editorStrings.eventsItemNewEvent);

    insert(m_engineMap, "editor.events.controlsForEventN",      &g_editorStrings.eventsControlsForEvent);
    insert(m_engineMap, "editor.events.settingsForEvent",       &g_editorStrings.eventsSettingsForEvent);

    insert(m_engineMap, "editor.events.layers.headerShow",      &g_editorStrings.eventsHeaderShow);
    insert(m_engineMap, "editor.events.layers.headerHide",      &g_editorStrings.eventsHeaderHide);
    insert(m_engineMap, "editor.events.layers.headerToggle",    &g_editorStrings.eventsHeaderToggle);
    insert(m_engineMap, "editor.events.layers.headerMove",      &g_editorStrings.eventsHeaderMove);

    insert(m_engineMap, "editor.events.sections.actionKeep",    &g_editorStrings.eventsActionKeep);
    insert(m_engineMap, "editor.events.sections.actionReset",   &g_editorStrings.eventsActionReset);
    insert(m_engineMap, "editor.events.sections.actionSet",     &g_editorStrings.eventsActionSet);

    insert(m_engineMap, "editor.events.sections.propMusic",     &g_editorStrings.eventsCaseMusic);
    insert(m_engineMap, "editor.events.sections.propBackground", &g_editorStrings.eventsCaseBackground);
    insert(m_engineMap, "editor.events.sections.propBounds",    &g_editorStrings.eventsCaseBounds);

    insert(m_engineMap, "editor.events.sections.phraseAllSections",     &g_editorStrings.eventsPhraseAllSections);

    insert(m_engineMap, "editor.events.props.autostart",     &g_editorStrings.eventsPropAutostart);
    insert(m_engineMap, "editor.events.props.sound",         &g_editorStrings.eventsPropSound);
    insert(m_engineMap, "editor.events.props.endGame",       &g_editorStrings.eventsPropEndGame);
    insert(m_engineMap, "editor.events.props.controls",      &g_editorStrings.eventsPropControls);
    insert(m_engineMap, "editor.events.props.layerSmoke",    &g_editorStrings.eventsPropLayerSmoke);

    insert(m_engineMap, "editor.events.headerTriggerEvent",  &g_editorStrings.eventsHeaderTriggerEvent);

    insert(m_engineMap, "editor.level.levelName",            &g_editorStrings.levelName);
    insert(m_engineMap, "editor.level.startPos",             &g_editorStrings.levelStartPos);
    insert(m_engineMap, "editor.level.pathBG",               &g_editorStrings.levelPathBG);
    insert(m_engineMap, "editor.level.bigBG",                &g_editorStrings.levelBigBG);
    insert(m_engineMap, "editor.level.gameStart",            &g_editorStrings.levelGameStart);
    insert(m_engineMap, "editor.level.alwaysVis",            &g_editorStrings.levelAlwaysVis);
    insert(m_engineMap, "editor.level.pathUnlocks",          &g_editorStrings.levelPathUnlocks);

    insert(m_engineMap, "editor.section.scroll",             &g_editorStrings.sectionScroll);
    insert(m_engineMap, "editor.section.horizWrap",          &g_editorStrings.sectionHorizWrap);
    insert(m_engineMap, "editor.section.vertWrap",           &g_editorStrings.sectionVertWrap);
    insert(m_engineMap, "editor.section.underwater",         &g_editorStrings.sectionUnderwater);
    insert(m_engineMap, "editor.section.noTurnBack",         &g_editorStrings.sectionNoTurnBack);
    insert(m_engineMap, "editor.section.offscreenExit",      &g_editorStrings.sectionOffscreenExit);

    insert(m_engineMap, "editor.world.name",                 &g_editorStrings.worldName);
    insert(m_engineMap, "editor.world.introLevel",           &g_editorStrings.worldIntroLevel);
    insert(m_engineMap, "editor.world.hubWorld",             &g_editorStrings.worldHubWorld);
    insert(m_engineMap, "editor.world.retryOnFail",          &g_editorStrings.worldRetryOnFail);
    insert(m_engineMap, "editor.world.totalStars",           &g_editorStrings.worldTotalStars);
    insert(m_engineMap, "editor.world.allowChars",           &g_editorStrings.worldAllowChars);
    insert(m_engineMap, "editor.world.phraseCreditIndex",    &g_editorStrings.worldCreditIndex);

    insert(m_engineMap, "editor.select.soundForEventN",              &g_editorStrings.selectSoundForEvent);
    insert(m_engineMap, "editor.select.sectBlankPropBlankForEventN", &g_editorStrings.selectSectBlankPropBlankForEvent);
    insert(m_engineMap, "editor.select.allSectPropBlankForEventN",   &g_editorStrings.selectAllSectPropBlankForEvent);
    insert(m_engineMap, "editor.select.sectionBlankPropBlank",     &g_editorStrings.selectSectionBlankPropBlank);
    insert(m_engineMap, "editor.select.pathBlankUnlock",           &g_editorStrings.selectPathBlankUnlock);
    insert(m_engineMap, "editor.select.warpTransitEffect",         &g_editorStrings.selectWarpTransitionEffect);
    insert(m_engineMap, "editor.select.worldMusic",                &g_editorStrings.selectWorldMusic);

    insert(m_engineMap, "editor.layers.header",              &g_editorStrings.layersHeader);

    insert(m_engineMap, "editor.layers.label",               &g_editorStrings.labelLayer);
    insert(m_engineMap, "editor.layers.labelAttached",       &g_editorStrings.layersLabelAttached);
    insert(m_engineMap, "editor.layers.abbrevAttLayer",      &g_editorStrings.layersAbbrevAttLayer);
    insert(m_engineMap, "editor.layers.default",             &g_editorStrings.layersLayerDefault);

    insert(m_engineMap, "editor.layers.labelAttachedLayer",  &g_editorStrings.layersLabelAttachedLayer);
    insert(m_engineMap, "editor.layers.labelMoveLayer",      &g_editorStrings.layersLabelMoveLayer);

    insert(m_engineMap, "editor.layers.deletion.header",                   &g_editorStrings.layersDeletionHeader);
    insert(m_engineMap, "editor.layers.deletion.preserveLayerContents",    &g_editorStrings.layersDeletionPreserveLayerContents);
    insert(m_engineMap, "editor.layers.deletion.confirmPreserve",          &g_editorStrings.layersDeletionConfirmPreserve);
    insert(m_engineMap, "editor.layers.deletion.confirmDelete",            &g_editorStrings.layersDeletionConfirmDelete);
    insert(m_engineMap, "editor.layers.deletion.cancel",                   &g_editorStrings.layersDeletionCancel);

    insert(m_engineMap, "editor.layers.desc.att", &g_editorStrings.layersDescAtt);

    insert(m_engineMap, "editor.layers.promptLayerName", &g_editorStrings.layersPromptLayerName);
    insert(m_engineMap, "editor.layers.itemNewLayer",    &g_editorStrings.layersItemNewLayer);

    insert(m_engineMap, "editor.file.actionClearLevel",            &g_editorStrings.fileActionClearLevel);
    insert(m_engineMap, "editor.file.actionClearWorld",            &g_editorStrings.fileActionClearWorld);
    insert(m_engineMap, "editor.file.actionOpen",                  &g_editorStrings.fileActionOpen);
    insert(m_engineMap, "editor.file.actionRevert",                &g_editorStrings.fileActionRevert);
    insert(m_engineMap, "editor.file.actionExit",                  &g_editorStrings.fileActionExit);
    insert(m_engineMap, "editor.file.confirmSaveBeforeAction",     &g_editorStrings.fileConfirmationSaveBeforeAction);
    insert(m_engineMap, "editor.file.confirmConfirmAction",        &g_editorStrings.fileConfirmationConfirmAction);
    insert(m_engineMap, "editor.file.confirmConvertFormatTo",      &g_editorStrings.fileConfirmationConvertFormatTo);
    insert(m_engineMap, "editor.file.optionYesSaveThenAction",     &g_editorStrings.fileOptionYesSaveThenAction);
    insert(m_engineMap, "editor.file.optionActionWithoutSave",     &g_editorStrings.fileOptionActionWithoutSave);
    insert(m_engineMap, "editor.file.optionCancelAction",          &g_editorStrings.fileOptionCancelAction);
    insert(m_engineMap, "editor.file.optionProceedWithConversion", &g_editorStrings.fileOptionProceedWithConversion);
    insert(m_engineMap, "editor.file.optionCancelConversion",      &g_editorStrings.fileOptionCancelConversion);

    insert(m_engineMap, "editor.file.labelCurrentFile",    &g_editorStrings.fileLabelCurrentFile);
    insert(m_engineMap, "editor.file.labelFormat",         &g_editorStrings.fileLabelFormat);

    insert(m_engineMap, "editor.file.formatModern",        &g_editorStrings.fileFormatModern);
    insert(m_engineMap, "editor.file.formatLegacy",        &g_editorStrings.fileFormatLegacy);

    insert(m_engineMap, "editor.file.sectionLevel",        &g_editorStrings.fileSectionLevel);
    insert(m_engineMap, "editor.file.sectionWorld",        &g_editorStrings.fileSectionWorld);
    insert(m_engineMap, "editor.file.commandNew",          &g_editorStrings.fileCommandNew);
    insert(m_engineMap, "editor.file.commandOpen",         &g_editorStrings.fileCommandOpen);
    insert(m_engineMap, "editor.file.commandSave",         &g_editorStrings.fileCommandSave);
    insert(m_engineMap, "editor.file.commandSaveAs",       &g_editorStrings.fileCommandSaveAs);

    insert(m_engineMap, "editor.file.convert.descNew",             &g_editorStrings.fileConvertDesc);

#if 0
    insert(m_engineMap, "editor.file.convert._38aUnsupported",     &g_editorStrings.fileConvert38aUnsupported);
    insert(m_engineMap, "editor.file.convert.formatUnknown",       &g_editorStrings.fileConvertFormatUnknown);

    insert(m_engineMap, "editor.file.convert.featureWarpTransit",      &g_editorStrings.fileConvertFeatureWarpTransit);
    insert(m_engineMap, "editor.file.convert.featureWarpNeedsStand",   &g_editorStrings.fileConvertFeatureWarpNeedsStand);
    insert(m_engineMap, "editor.file.convert.featureWarpCannonExit",   &g_editorStrings.fileConvertFeatureWarpCannonExit);
    insert(m_engineMap, "editor.file.convert.featureWarpEnterEvent",   &g_editorStrings.fileConvertFeatureWarpEnterEvent);
    insert(m_engineMap, "editor.file.convert.featureWarpCustomStarsMsg", &g_editorStrings.fileConvertFeatureWarpCustomStarsMsg);
    insert(m_engineMap, "editor.file.convert.featureWarpNoPrintStars", &g_editorStrings.fileConvertFeatureWarpNoPrintStars);
    insert(m_engineMap, "editor.file.convert.featureWarpNoStartScene", &g_editorStrings.fileConvertFeatureWarpNoStartScene);
    insert(m_engineMap, "editor.file.convert.featureWarpPortal",       &g_editorStrings.fileConvertFeatureWarpPortal);

    insert(m_engineMap, "editor.file.convert.featureEventCustomMusic", &g_editorStrings.fileConvertFeatureEventCustomMusic);
    insert(m_engineMap, "editor.file.convert.featureEventAutoscroll",  &g_editorStrings.fileConvertFeatureEventAutoscroll);

    insert(m_engineMap, "editor.file.convert.featureNPCVariant",       &g_editorStrings.fileConvertFeatureNPCVariant);
    insert(m_engineMap, "editor.file.convert.featureBlockForceSmashable", &g_editorStrings.fileConvertFeatureBlockForceSmashable);
    insert(m_engineMap, "editor.file.convert.featureBgoOrder",         &g_editorStrings.fileConvertFeatureBgoOrder);

    insert(m_engineMap, "editor.file.convert.featureCustomWorldMusic", &g_editorStrings.fileConvertFeatureCustomWorldMusic);
    insert(m_engineMap, "editor.file.convert.featureWorldStarDisplay", &g_editorStrings.fileConvertFeatureWorldStarDisplay);
    insert(m_engineMap, "editor.file.convert.featureLevelStarDisplay", &g_editorStrings.fileConvertFeatureLevelStarDisplay);
    insert(m_engineMap, "editor.file.convert.featureWorldMapSections", &g_editorStrings.fileConvertFeatureWorldMapSections);
#endif

    insert(m_engineMap, "editor.browser.newFile",          &g_editorStrings.browserNewFile);
    insert(m_engineMap, "editor.browser.saveFile",         &g_editorStrings.browserSaveFile);
    insert(m_engineMap, "editor.browser.openFile",         &g_editorStrings.browserOpenFile);

    insert(m_engineMap, "editor.browser.itemNewFile",      &g_editorStrings.browserItemNewFile);
    insert(m_engineMap, "editor.browser.itemNewFolder",    &g_editorStrings.browserItemNewFolder);

    insert(m_engineMap, "editor.browser.askOverwriteFile", &g_editorStrings.browserAskOverwriteFile);

    insert(m_engineMap, "editor.tooltip.select",   &g_editorStrings.tooltipSelect);
    insert(m_engineMap, "editor.tooltip.erase",    &g_editorStrings.tooltipErase);
    insert(m_engineMap, "editor.tooltip.eraseAll", &g_editorStrings.tooltipEraseAll);
    insert(m_engineMap, "editor.tooltip.blocks",   &g_editorStrings.tooltipBlocks);
    insert(m_engineMap, "editor.tooltip.BGOs",     &g_editorStrings.tooltipBGOs);
    insert(m_engineMap, "editor.tooltip.NPCs",     &g_editorStrings.tooltipNPCs);
    insert(m_engineMap, "editor.tooltip.warps",    &g_editorStrings.tooltipWarps);
    insert(m_engineMap, "editor.tooltip.water",    &g_editorStrings.tooltipWater);
    insert(m_engineMap, "editor.tooltip.settings", &g_editorStrings.tooltipSettings);
    insert(m_engineMap, "editor.tooltip.layers",   &g_editorStrings.tooltipLayers);
    insert(m_engineMap, "editor.tooltip.events",   &g_editorStrings.tooltipEvents);
    insert(m_engineMap, "editor.tooltip.tiles",    &g_editorStrings.tooltipTiles);
    insert(m_engineMap, "editor.tooltip.scenes",   &g_editorStrings.tooltipScenes);
    insert(m_engineMap, "editor.tooltip.levels",   &g_editorStrings.tooltipLevels);
    insert(m_engineMap, "editor.tooltip.paths",    &g_editorStrings.tooltipPaths);
    insert(m_engineMap, "editor.tooltip.music",    &g_editorStrings.tooltipMusic);
    insert(m_engineMap, "editor.tooltip.area",     &g_editorStrings.tooltipArea);
    insert(m_engineMap, "editor.tooltip.file",     &g_editorStrings.tooltipFile);
    insert(m_engineMap, "editor.tooltip.show",     &g_editorStrings.tooltipShow);

#endif // THEXTECH_ENABLE_EDITOR
    // };

#ifdef THEXTECH_ENABLE_EDITOR
    for(int i = 0; i < 6; ++i)
    {
        insert(m_engineMap, fmt::format_ne("editor.warp.transit.name{0}", i), &g_editorStrings.listWarpTransitNames[i]);
    }
#endif


    m_assetsMap =
    {
        {"languageName", &g_mainMenu.languageName},

        {"objects.wordStarAccusativeSingular",      &g_gameInfo.wordStarAccusativeSingular},
        {"objects.wordStarAccusativeDualOrCounter", &g_gameInfo.wordStarAccusativeDual_Cnt},
        {"objects.wordStarAccusativePlural",        &g_gameInfo.wordStarAccusativePlural},

        {"objects.wordFails", &g_gameInfo.fails_counter_title}
    };

    for(int i = 1; i <= numCharacters; ++i)
        insert(m_assetsMap, fmt::format_ne("character.name{0}", i), &g_gameInfo.characterName[i]);

    // reset all strings for options to hardcoded defaults
    g_options.reset_options();

    // add config fields to engine map
    g_options.make_translation(*this);

#ifdef THEXTECH_ENABLE_EDITOR
    // adds dynamic fields to the asset map
    EditorCustom::Load(this);
#endif

    XHints::InitTranslations(*this);

#if TR_MAP_TYPE == 1 && !defined(THEXTECH_DISABLE_LANG_TOOLS)
    tinysort(m_engineMap.begin(), m_engineMap.end(),
        [](const TrEntry &a, const TrEntry &b)->bool
        {
            return a.first.compare(b.first) < 0;
        });

    tinysort(m_assetsMap.begin(), m_assetsMap.end(),
        [](const TrEntry &a, const TrEntry &b)->bool
        {
            return a.first.compare(b.first) < 0;
        });
#endif
}

void XTechTranslate::reset()
{
    initOutroContent();
    initMainMenu();
    initGameStrings();

#ifdef THEXTECH_ENABLE_EDITOR
    initEditorStrings();

    // don't need to reset EditorCustom because we reloaded it in the initializer
    // it would be dangerous to reload it here because it would invalidate a lot of references
#endif

    // likewise, unsafe to reset g_options here because it would invalidate pointers to data inside vectors
    // g_options.reset_options();

    Controls::InitStrings();
    g_controlsStrings = ControlsStrings_t();

    XHints::ResetStrings();

    s_CurrentPluralRules = PluralRules::OneIsSingular;
}

void XTechTranslate::exportTemplate()
{
#ifndef THEXTECH_DISABLE_LANG_TOOLS
    reset();

    try
    {
        nlohmann::ordered_json langFile;

        for(auto &k : m_engineMap)
        {
#ifdef DEBUG_BUILD
            std::printf("-- writing %s -> %s\n", k.first.c_str(), k.second->c_str());
#endif
            setJsonValue(langFile, k.first, *k.second);
        }

        std::printf("Lang file data (Engine): \n\n%s\n\n", langFile.dump(4, ' ', false).c_str());
        std::fflush(stdout);

        langFile.clear();

        for(auto &k : m_assetsMap)
        {
#ifdef DEBUG_BUILD
            std::printf("-- writing %s -> %s\n", k.first.c_str(), k.second->c_str());
#endif
            setJsonValue(langFile, k.first, *k.second);
        }

        std::printf("Lang file data (Assets): \n\n%s\n\n", langFile.dump(4, ' ', false).c_str());
        std::fflush(stdout);
    }
    catch(const std::exception &e)
    {
        std::printf("JSON: Caught an exception: %s", e.what());
        std::fflush(stdout);
    }
#endif
}

void XTechTranslate::updateLanguages(const std::string &outPath, bool noBlank)
{
#ifndef THEXTECH_DISABLE_LANG_TOOLS
    std::vector<std::string> list;
    DirMan langs(outPath.empty() ? AppPathManager::languagesDir() : outPath);

    if(!langs.exists())
    {
        std::printf("Can't open the languages directory: %s", langs.absolutePath().c_str());
        std::fflush(stdout);
        return;
    }

    if(!langs.getListOfFiles(list, {".json"}))
    {
        std::printf("Can't show the content of the languages directory: %s", langs.absolutePath().c_str());
        std::fflush(stdout);
        return;
    }

    reset();

    for(auto &f : list)
    {
        bool isEnglish = Strings::endsWith(f, "_en.json");
        std::printf("-- Processing file %s...\n", f.c_str());
        std::string fullFilePath = langs.absolutePath() + "/" + f;
        bool changed = false;

        TrList &trList = Strings::startsWith(f, "thextech_") ? m_engineMap : m_assetsMap;

        try
        {
            Files::Data data = Files::load_file(fullFilePath);

            if(!data.valid())
            {
                std::printf("Warning: Failed to load the translation file %s: can't open file\n", fullFilePath.c_str());
                continue;
            }

            nlohmann::ordered_json langFile = nlohmann::ordered_json::parse(data.begin(), data.end());

            for(const auto &k : trList)
            {
                const std::string &res = *k.second;
                changed |= setJsonValueIfNotExist(langFile, k.first, isEnglish ? res : std::string(), noBlank);
            }

            if(!changed)
            {
                std::printf("Lang file remain unchanged!\n");
                std::fflush(stdout);
                continue;
            }

            if(saveFile(fullFilePath, langFile.dump(4, ' ', false)))
            {
                std::printf("Lang file has been updated!\n");
                std::fflush(stdout);
            }
            else
            {
                std::printf("Error: Failed to write out the file %s!\n", fullFilePath.c_str());
                std::fflush(stdout);
            }
        }
        catch(const std::exception &e)
        {
            std::printf("Warning: Failed to process the translation file %s: %s\n", fullFilePath.c_str(), e.what());
        }
    }

    std::fflush(stdout);
#else
    UNUSED(outPath);
    UNUSED(noBlank);
#endif
}



bool XTechTranslate::translate()
{
    if(!FontManager::isInitied() || FontManager::isLegacy())
    {
        pLogWarning("Translations aren't supported without new font engine loaded (the 'fonts' directory is required)");
        return false;
    }

    s_CurrentPluralRules = PluralRules::OneIsSingular;

    const std::string &langEngineFile = XLanguage::getEngineFile();
    const std::string &langAssetsFile = XLanguage::getAssetsFile();

    if(!langEngineFile.empty() && Files::fileExists(langEngineFile))
    {
        // Engine translations
        if(!translateFile(langEngineFile, m_engineMap, "engine"))
            pLogWarning("Failed to apply the engine translation file %s", langEngineFile.c_str());
    }

    if(!langAssetsFile.empty() && Files::fileExists(langAssetsFile))
    {
        // assets translations
        if(!translateFile(langAssetsFile, m_assetsMap, "assets"))
            pLogWarning("Failed to apply the assets translation file %s", langAssetsFile.c_str());
    }

    if(langEngineFile.empty() && langAssetsFile.empty())
        return false; // No language was found at all

    if(!Files::fileExists(langEngineFile) && !Files::fileExists(langAssetsFile))
        return false; // Files are not exists, do nothing

    if(g_mainMenu.pluralRules == "one-is-singular")
        s_CurrentPluralRules = PluralRules::OneIsSingular;
    else if(g_mainMenu.pluralRules == "singular-only")
        s_CurrentPluralRules = PluralRules::SingularOnly;
    else if(g_mainMenu.pluralRules == "slavic")
        s_CurrentPluralRules = PluralRules::Slavic;

    return true;
}

bool XTechTranslate::translateFile(const std::string& file, TrList& list, const char *trTypeName)
{
    try
    {
        // Engine translations
        Files::Data data = Files::load_file(file);

        if(!data.valid())
        {
            pLogWarning("Failed to load the %s translation file %s: can't open file", trTypeName, file.c_str());
            return false;
        }

        nlohmann::ordered_json langFile = nlohmann::ordered_json::parse(data.begin(), data.end());

        for(auto &k : list)
        {
            std::string &res = *k.second;
            res = getJsonValue(langFile, k.first, *k.second);
        }
    }
    catch(const std::exception &e)
    {
        reset();
        pLogWarning("Failed to load the %s translation file %s: %s", trTypeName, file.c_str(), e.what());
        return false;
    }

    return true;
}

void ReloadTranslations()
{
    XLanguage::resolveLanguage(g_config.language);

    FontManager::updateDefaultFontByLang(CurrentLanguage, CurrentLangDialect);

    XTechTranslate translator;
    translator.reset();
    if(translator.translate())
    {
        pLogDebug("Reloaded translation for language %s-%s",
                  CurrentLanguage.c_str(),
                  CurrentLangDialect.empty() ? "??" : CurrentLangDialect.c_str());
    }
}



================================================
FILE: src/main/translate.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef TRANSLATE_H
#define TRANSLATE_H

#include <map>
#include <string>

#include "editor/editor_custom.h"
#include "main/hints.h"

const std::string& LanguageFormatNumber(int number, const std::string& singular, const std::string& dual, const std::string& plural);

template<bool writable>
class _Config_t;

template<bool writable>
class BaseConfigOption_t;

template<bool writable>
class ConfigSection_t;

template<bool writable, class value_t>
class ConfigEnumOption_t;

class XTechTranslate
{
#ifdef THEXTECH_DISABLE_LANG_TOOLS
    typedef std::pair<std::string, std::string*> TrEntry;
    typedef std::vector<TrEntry> TrList;
#   define TR_MAP_TYPE 1
#   define TR_MAP_INSERT push_back
#else
    typedef std::map<std::string, std::string*> TrList;
#   define TR_MAP_TYPE 0
#   define TR_MAP_INSERT insert
#endif
    //! Map of the engine specific translation key and the actual string container, used to simplify the maintenance
    TrList m_engineMap;

    //! Map of the assets specific translation key and the actual string container, used to simplify the maintenance
    TrList m_assetsMap;

    /**
     * @brief Inserts a new translation line
     * @param list Translation list to insert
     * @param key Key of the translation line
     * @param value Pointer to the contained string that should be translated
     */
    static void insert(TrList &list, const char *key, std::string *value);

    /**
     * @brief Inserts a new translation line
     * @param list Translation list to insert
     * @param key Key of the translation line
     * @param value Pointer to the contained string that should be translated
     */
    static void insert(TrList &list, std::string &&key, std::string *value);

public:
    XTechTranslate();

    /*!
     * \brief Load default built-in translation
     */
    void reset();

    /*!
     * \brief Print the content of default translation file to the terminal
     */
    void exportTemplate();

    /*!
     * \brief Fetch all translation files and update their content (add any missing entries)
     */
    void updateLanguages(const std::string& outPath, bool noBlank);

    /*!
     * \brief Switch the language of the engine
     * \return True if language was been successfully loaded
     */
    bool translate();

#ifdef THEXTECH_ENABLE_EDITOR
    friend void EditorCustom::Load(XTechTranslate* translate);
    friend struct EditorCustom::ItemList_t;
#endif

    friend void XHints::InitTranslations(XTechTranslate& translate);

    friend class _Config_t<false>;
    friend class BaseConfigOption_t<false>;
    friend class ConfigSection_t<false>;

    template<bool writable, class value_t>
    friend class ConfigEnumOption_t;

private:
    bool translateFile(const std::string &file, TrList &list, const char* trTypeName);
};

// safe to call at any time; reloads all engine-level string translations (no level / episode translations)
void ReloadTranslations();

#endif // TRANSLATE_H


================================================
FILE: src/main/translate_episode.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <json/json_rwops_input.hpp>
#include <json/json.hpp>
#include <Logger/logger.h>
#include <Utils/files.h>
#include <Utils/strings.h>
#include <fmt_format_ne.h>
#include <fstream>
#include <unordered_map>
#include <vector>

#include "globals.h"
#ifndef LAYERS_H // Workaround for Clazy
#include "layers.h"
#endif

#include "fontman/font_manager.h"
#include "translate_episode.h"
#define XTECH_TRANSLATE_EPISODE
#include "translate/tr_title.h"
#include "translate/tr_level.h"
#include "translate/tr_world.h"
#include "translate/tr_script.h"


static std::string getTrFileLang(const std::string &lang, const std::string &dialect, const std::string &subDir, const std::string &episodePath = std::string())
{
    std::string langFile;

    const auto &p = episodePath.empty() ?
                        FileNamePath :
                        episodePath;

    // Trying to find the dialect-specific translation
    if(!dialect.empty())
    {
        if(!subDir.empty())
        {
            // Try to find the translation at the i18n at data sub-directory
            langFile = p + fmt::format_ne("{0}/i18n/translation_{1}-{2}.json", subDir, lang.c_str(), dialect.c_str());
            if(!Files::fileExists(langFile))
                langFile.clear();
        }

        // Now try at the i18n at episode root
        if(langFile.empty())
        {
            langFile = p + fmt::format_ne("i18n/translation_{0}-{1}.json", lang.c_str(), dialect.c_str());
            if(!Files::fileExists(langFile))
                langFile.clear();
        }
    }

    // Trying the general translation
    if(langFile.empty())
    {
        // Try to find the translation at the data sub-directory
        if(!subDir.empty())
        {
            // Try to find the translation at the i18n at data sub-directory
            langFile = p + fmt::format_ne("{0}/i18n/translation_{1}.json", subDir, lang.c_str());
            if(!Files::fileExists(langFile))
                langFile.clear();
        }

        // Now try at the i18n at episode root
        if(langFile.empty())
        {
            langFile = p + fmt::format_ne("i18n/translation_{0}.json", lang.c_str());
            if(!Files::fileExists(langFile))
                langFile.clear();
        }
    }

    return langFile;
}


static std::string getTrFile(const std::string &subDir, const std::string &episodePath = std::string())
{
    std::string langFile = getTrFileLang(CurrentLanguage, CurrentLangDialect, subDir, episodePath);

    if(langFile.empty()) // If no language detected or invalid language set, fallback to English
        langFile = getTrFileLang("en", "gb", subDir, episodePath);

    return langFile;
}


TranslateEpisode::TranslateEpisode()
{}

void TranslateEpisode::loadLevelTranslation(const std::string& key)
{
    if(!FontManager::isInitied() || FontManager::isLegacy())
    {
        pLogWarning("TranslateEpisode: Translations aren't supported without new font engine loaded (the 'fonts' directory is required)");
        return;
    }

    std::string langFile = getTrFile(FileName);

    if(langFile.empty())
        return; // No translation found

    TrLevelParser parser;
    parser.m_wantedKey = key;

    SDL_RWops *f_in = Files::open_file(langFile, "rb");
    if(!f_in)
        return;

    if(nlohmann::json::sax_parse(f_in, &parser))
        pLogDebug("JSON SaX returned TRUE");
    else
        pLogDebug("JSON SaX returned FALSE");

    SDL_RWclose(f_in);
}

void TranslateEpisode::loadWorldTranslation(const std::string& key)
{
    if(!FontManager::isInitied() || FontManager::isLegacy())
    {
        pLogWarning("TranslateEpisode: Translations aren't supported without new font engine loaded (the 'fonts' directory is required)");
        return;
    }

    std::string langFile = getTrFile(FileNameWorld);

    if(langFile.empty())
        return; // No translation found

    TrWorldParser parser;
    parser.m_wantedKey = key;

    SDL_RWops *f_in = Files::open_file(langFile, "rb");
    if(!f_in)
        return;

    if(nlohmann::json::sax_parse(f_in, &parser))
        pLogDebug("JSON SaX returned TRUE");
    else
        pLogDebug("JSON SaX returned FALSE");

    SDL_RWclose(f_in);
}

void TranslateEpisode::loadLunaScript(const std::string& key)
{
    m_scriptLines.clear();
    m_scriptTrId.clear();

    if(!FontManager::isInitied() || FontManager::isLegacy())
    {
        pLogWarning("TranslateEpisode: Translations aren't supported without new font engine loaded (the 'fonts' directory is required)");
        return;
    }

    std::string langFile = getTrFile(FileName);

    if(langFile.empty())
        return; // No translation found

    TrScriptParser parser;
    parser.m_wantedKey = key;
    parser.m_outputLines = &m_scriptLines;
    parser.m_outputTrIdLines = &m_scriptTrId;

    SDL_RWops *f_in = Files::open_file(langFile, "rb");
    if(!f_in)
        return;

    if(nlohmann::json::sax_parse(f_in, &parser))
        pLogDebug("JSON SaX returned TRUE");
    else
        pLogDebug("JSON SaX returned FALSE");

    SDL_RWclose(f_in);
}

bool TranslateEpisode::tryTranslateTitle(const std::string& episodePath,
                                         const std::string& worldFile,
                                         std::string& output)
{
    if(!FontManager::isInitied() || FontManager::isLegacy())
    {
        pLogWarning("TranslateEpisode: Translations aren't supported without new font engine loaded (the 'fonts' directory is required)");
        return false;
    }

    std::string langFile = getTrFile(std::string(), episodePath);

    if(langFile.empty())
        return false; // No translation found

    TrTitleParser parser;
    parser.m_toWrite = &output;
    parser.m_wantedWorld = worldFile;

    SDL_RWops *f_in = Files::open_file(langFile, "rb");
    if(!f_in)
        return false;

    if(nlohmann::json::sax_parse(f_in, &parser))
        pLogDebug("JSON SaX returned TRUE");
    else
        pLogDebug("JSON SaX returned FALSE");

    SDL_RWclose(f_in);

    return true;
}

void TranslateEpisode::trScriptLine(std::string& data, int line)
{
    if(!FontManager::isInitied() || FontManager::isLegacy())
    {
        pLogWarning("TranslateEpisode: Translations aren't supported without new font engine loaded (the 'fonts' directory is required)");
        return;
    }

    if(m_scriptLines.empty() && m_scriptTrId.empty())
        return;

    if(!m_scriptTrId.empty())
    {
        auto f = m_scriptTrId.find(data);
        if(f != m_scriptTrId.end())
        {
            data = f->second;
            return; // translated by TrId
        }
    }

    auto f = m_scriptLines.find(line);
    if(f != m_scriptLines.end())
        data = f->second; // translated by line number
}


================================================
FILE: src/main/translate_episode.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef TRANSLATEEPISODE_H
#define TRANSLATEEPISODE_H

#include <unordered_map>
#include <string>


class TranslateEpisode
{
    std::unordered_map<int, std::string> m_scriptLines;
    std::unordered_map<std::string, std::string> m_scriptTrId;

public:
    TranslateEpisode();

    /*!
     * \brief Translate the level file data by key
     * \param lvl Level data
     * \param key Translation key
     */
    void loadLevelTranslation(const std::string &key);

    /*!
     * \brief Translate the world map file data by key
     * \param wld World map data
     * \param key Translation key
     */
    void loadWorldTranslation(const std::string &key);

    /*!
     * \brief Load the script translation data by key
     * \param key Translation key
     */
    void loadLunaScript(const std::string &key);

    /*!
     * \brief Attempt to find the translated episode title
     * \param episodePath Path to the episode directory to prove
     * \return true if translation has been found
     */
    bool tryTranslateTitle(const std::string &episodePath, const std::string &worldFile, std::string &output);

    /*!
     * \brief Translate script line by number
     * \param data Line data to translate
     * \param line line number where the line appears
     */
    void trScriptLine(std::string &data, int line);
};

#endif // TRANSLATEEPISODE_H


================================================
FILE: src/main/trees.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <memory>
#include <sorting/pdqsort.h>

#include "layers.h"
#include "config.h"

#include "main/trees.h"
#include "main/block_table.h"
#include "main/block_table.hpp"


std::vector<BaseRef_t> treeresult_vec[MAX_TREEQUERY_DEPTH] = {std::vector<BaseRef_t>(400), std::vector<BaseRef_t>(400), std::vector<BaseRef_t>(50), std::vector<BaseRef_t>(50)};
ptrdiff_t cur_treeresult_vec = 0;

static std::unique_ptr<table_t<TileRef_t>> s_worldTilesTree;
static std::unique_ptr<table_t<SceneRef_t>> s_worldSceneTree;
static std::unique_ptr<table_t<WorldPathRef_t>> s_worldPathTree;
static std::unique_ptr<table_t<WorldLevelRef_t>> s_worldLevelTree;
static std::unique_ptr<table_t<WorldMusicRef_t>> s_worldMusicTree;

template<class Q>
void clearTree(Q &tree)
{
    if(tree.get())
    {
        tree->clear();
        tree.reset();
    }
}

void treeWorldCleanAll()
{
    clearTree(s_worldTilesTree);
    clearTree(s_worldSceneTree);
    clearTree(s_worldPathTree);
    clearTree(s_worldLevelTree);
    clearTree(s_worldMusicTree);
}

void treeLevelCleanAll()
{
    treeLevelCleanBlockLayers();
    treeLevelCleanBackgroundLayers();
    treeLevelCleanWaterLayers();
    treeTempBlockFullClear();
    treeNPCClear();
}

template<class ItemRef_t, class Arr>
void treeInsert(Arr &p, ItemRef_t obj)
{
    if(!p.get())
        p.reset(new table_t<ItemRef_t>());
    p->insert(obj);
}

template<class ItemRef_t, class Arr>
void treeUpdate(Arr &p, ItemRef_t obj)
{
    if(p.get())
        p->update(obj);
}

template<class ItemRef_t, class Arr>
void treeRemove(Arr &p, ItemRef_t obj)
{
    if(p.get())
        p->erase(obj);
}

template<class ItemRef_t>
TreeResult_Sentinel<ItemRef_t> treeWorldQuery(std::unique_ptr<table_t<ItemRef_t>> &p,
    int Left, int Top, int Right, int Bottom, int sort_mode)
{
    TreeResult_Sentinel<ItemRef_t> result;

    if(!p.get())
        return result;

    p->query(*result.i_vec, rect_external(s_floor_div_64(Left),
                                  s_floor_div_64(Right + 63),
                                  s_floor_div_64(Top),
                                  s_floor_div_64(Bottom + 63)));

    if(sort_mode == SORTMODE_ID || sort_mode == SORTMODE_Z)
        trees_sort_by_index(*result.i_vec);
    else if(sort_mode == SORTMODE_LOC)
    {
        pdqsort(result.i_vec->begin(), result.i_vec->end(),
            [](BaseRef_t a, BaseRef_t b) {
                return (((ItemRef_t)a)->Location.X < ((ItemRef_t)b)->Location.X
                    || (((ItemRef_t)a)->Location.X == ((ItemRef_t)b)->Location.X
                        && ((ItemRef_t)a)->Location.Y < ((ItemRef_t)b)->Location.Y));
            });
    }

    return result;
}


/* ================= Terrain Tile ================= */

void treeWorldTileAdd(TileRef_t obj)
{
    treeInsert(s_worldTilesTree, obj);
}

void treeWorldTileUpdate(TileRef_t obj)
{
    treeUpdate(s_worldTilesTree, obj);
}

void treeWorldTileRemove(TileRef_t obj)
{
    treeRemove(s_worldTilesTree, obj);
}

TreeResult_Sentinel<TileRef_t> treeWorldTileQuery(int Left, int Top, int Right, int Bottom, int sort_mode, int margin)
{
    return treeWorldQuery(s_worldTilesTree,
                   Left - margin,
                   Top - margin,
                   Right + margin,
                   Bottom + margin,
                   sort_mode);
}

TreeResult_Sentinel<TileRef_t> treeWorldTileQuery(const TinyLocation_t &loc, int sort_mode, int margin)
{
    return treeWorldQuery(s_worldTilesTree,
                   loc.X - margin,
                   loc.Y - margin,
                   loc.X + loc.Width + margin,
                   loc.Y + loc.Height + margin,
                   sort_mode);
}


/* ================= Scenery ================= */

void treeWorldSceneAdd(SceneRef_t obj)
{
    treeInsert(s_worldSceneTree, obj);
}

void treeWorldSceneUpdate(SceneRef_t obj)
{
    treeUpdate(s_worldSceneTree, obj);
}

void treeWorldSceneRemove(SceneRef_t obj)
{
    treeRemove(s_worldSceneTree, obj);
}

TreeResult_Sentinel<SceneRef_t> treeWorldSceneQuery(int Left, int Top, int Right, int Bottom, int sort_mode, int margin)
{
    return treeWorldQuery(s_worldSceneTree,
                   Left - margin,
                   Top - margin,
                   Right + margin,
                   Bottom + margin,
                   sort_mode);
}

TreeResult_Sentinel<SceneRef_t> treeWorldSceneQuery(const TinyLocation_t &loc, int sort_mode, int margin)
{
    return treeWorldQuery(s_worldSceneTree,
                   loc.X - margin,
                   loc.Y - margin,
                   loc.X + loc.Width + margin,
                   loc.Y + loc.Height + margin,
                   sort_mode);
}


/* ================= Paths ================= */

void treeWorldPathAdd(WorldPathRef_t obj)
{
    treeInsert(s_worldPathTree, obj);
}

void treeWorldPathUpdate(WorldPathRef_t obj)
{
    treeUpdate(s_worldPathTree, obj);
}

void treeWorldPathRemove(WorldPathRef_t obj)
{
    treeRemove(s_worldPathTree, obj);
}

TreeResult_Sentinel<WorldPathRef_t> treeWorldPathQuery(int Left, int Top, int Right, int Bottom,
                        int sort_mode, int margin)
{
    return treeWorldQuery(s_worldPathTree,
                   Left - margin,
                   Top - margin,
                   Right + margin,
                   Bottom + margin,
                   sort_mode);
}

TreeResult_Sentinel<WorldPathRef_t> treeWorldPathQuery(const TinyLocation_t &loc, int sort_mode, int margin)
{
    return treeWorldQuery(s_worldPathTree,
                   loc.X - margin,
                   loc.Y - margin,
                   loc.X + loc.Width + margin,
                   loc.Y + loc.Height + margin,
                   sort_mode);
}

/* ================= Levels ================= */

void treeWorldLevelAdd(WorldLevelRef_t obj)
{
    treeInsert(s_worldLevelTree, obj);
}

void treeWorldLevelUpdate(WorldLevelRef_t obj)
{
    treeUpdate(s_worldLevelTree, obj);
}

void treeWorldLevelRemove(WorldLevelRef_t obj)
{
    treeRemove(s_worldLevelTree, obj);
}

TreeResult_Sentinel<WorldLevelRef_t> treeWorldLevelQuery(int Left, int Top, int Right, int Bottom,
                         int sort_mode, int margin)
{
    return treeWorldQuery(s_worldLevelTree,
                   Left - margin,
                   Top - margin,
                   Right + margin,
                   Bottom + margin,
                   sort_mode);
}

TreeResult_Sentinel<WorldLevelRef_t> treeWorldLevelQuery(const TinyLocation_t &loc, int sort_mode, int margin)
{
    return treeWorldQuery(s_worldLevelTree,
                   loc.X - margin,
                   loc.Y - margin,
                   loc.X + loc.Width + margin,
                   loc.Y + loc.Height + margin,
                   sort_mode);
}


/* ================= Music ================= */

void treeWorldMusicAdd(WorldMusicRef_t obj)
{
    treeInsert(s_worldMusicTree, obj);
}

void treeWorldMusicUpdate(WorldMusicRef_t obj)
{
    treeUpdate(s_worldMusicTree, obj);
}

void treeWorldMusicRemove(WorldMusicRef_t obj)
{
    treeRemove(s_worldMusicTree, obj);
}

TreeResult_Sentinel<WorldMusicRef_t> treeWorldMusicQuery(int Left, int Top, int Right, int Bottom,
                         int sort_mode,
                         int margin)
{
    return treeWorldQuery(s_worldMusicTree,
                   Left - margin,
                   Top - margin,
                   Right + margin,
                   Bottom + margin,
                   sort_mode);
}

TreeResult_Sentinel<WorldMusicRef_t> treeWorldMusicQuery(const TinyLocation_t &loc,
                         int sort_mode,
                         int margin)
{
    return treeWorldQuery(s_worldMusicTree,
                   loc.X - margin,
                   loc.Y - margin,
                   loc.X + loc.Width + margin,
                   loc.Y + loc.Height + margin,
                   sort_mode);
}

/* ================= Tile block search ================= */
// removed in favor of block quadtree

#if 0
void blockTileGet(const Location_t &loc, int64_t &fBlock, int64_t &lBlock)
{
    int f = vb6Round(loc.X / 32) - 1;
    int l = vb6Round((loc.X + loc.Width) / 32.0) + 1;
    fBlock = FirstBlock[f < -FLBlocks ? -FLBlocks : f];
    lBlock = LastBlock[l > FLBlocks ? FLBlocks : l];
}

void blockTileGet(double x, double w, int64_t &fBlock, int64_t &lBlock)
{
    int f = vb6Round(x / 32) - 1;
    int l = vb6Round((x + w) / 32.0) + 1;
    fBlock = FirstBlock[f < -FLBlocks ? -FLBlocks : f];
    lBlock = LastBlock[l > FLBlocks ? FLBlocks : l];
}
#endif

template<>
void UpdatableQuery<BlockRef_t>::update(const Location_t& loc, const UpdatableQuery<BlockRef_t>::it& current_step)
{
    SDL_assert(sort_mode != SORTMODE_NONE); // impossible to update unsorted query

    bool use_fl_block = (block_query_mode == QUERY_FLBLOCK && BlocksSorted);

    // check if this query is a subset of the previous query
    if((loc.Y >= bounds.Y && loc.Y + loc.Height <= bounds.Y + bounds.Height)
        && (use_fl_block || (loc.X >= bounds.X && loc.X + loc.Width <= bounds.X + bounds.Width)))
    {
        return;
    }

    // update bounds, and expand by 6px on each side
    bounds.Y = loc.Y - 6;
    bounds.Height = loc.Height + 6;

    // in compat mode, use a special formula for the FLBlock bounds
    if(use_fl_block && g_config.emulate_classic_block_order)
    {
        bounds.X = num_t::vb6round(loc.X / 32 - 1) * 32;
        bounds.Width = num_t::vb6round((loc.X + loc.Width) / 32 + 1) * 32 - bounds.X;
    }
    else
    {
        bounds.X = loc.X - 6;
        bounds.Width = loc.Width + 6;
    }

    // set up comparison functions
    int sort_mode_use = sort_mode;

    if(sort_mode_use == SORTMODE_COMPAT)
    {
        if(block_query_mode == QUERY_FLBLOCK && g_config.emulate_classic_block_order)
            sort_mode_use = SORTMODE_ID;
        else
            sort_mode_use = SORTMODE_LOC;
    }

    auto compare_func = (sort_mode_use == SORTMODE_Z) ? Comparisons::Z<BlockRef_t>
        : (sort_mode_use == SORTMODE_LOC) ? Comparisons::Loc<BlockRef_t>
        : Comparisons::ID<BlockRef_t>;

    // helps track range to sort following update
    bool current_step_valid = (current_step != end());
    ptrdiff_t start_sort = current_step_valid ? current_step.index + 1 : end().index;
    BlockRef_t lower_bound = current_step_valid ? *current_step : BlockRef_t();

    size_t start_new = sent.i_vec->size();

    // add the normal blocks
    if(block_query_mode != QUERY_TEMPBLOCK)
        treeFLBlockQuery(*sent.i_vec, bounds, SORTMODE_NONE);

    // add the temp blocks
    if(block_query_mode != QUERY_FLBLOCK)
        treeTempBlockQuery(*sent.i_vec, bounds, SORTMODE_NONE);

    // filter out the invalid blocks
    if(current_step_valid)
    {
        for(size_t i = start_new; i < sent.i_vec->size();)
        {
            // need lower_bound to be strictly before the new item
            if(compare_func(lower_bound, (*sent.i_vec)[i]))
            {
                i++;
                continue;
            }

            // must remove the item!
            (*sent.i_vec)[i] = (*sent.i_vec)[sent.i_vec->size() - 1];
            sent.i_vec->resize(sent.i_vec->size() - 1);
        }
    }

    // sort all of the blocks after the current step (manually separating cases to maximize chances of successful inlining)
    if(sort_mode_use == SORTMODE_Z)
        pdqsort(sent.i_vec->begin() + start_sort, sent.i_vec->end(), Comparisons::Z<BlockRef_t>);
    else if(sort_mode_use == SORTMODE_LOC)
        pdqsort(sent.i_vec->begin() + start_sort, sent.i_vec->end(), Comparisons::Loc<BlockRef_t>);
    else
        trees_sort_by_index(*sent.i_vec);
}


================================================
FILE: src/main/trees.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef TREES_HHHH
#define TREES_HHHH

#include "sdl_proxy/sdl_assert.h"

#include "globals.h"

#define MAX_TREEQUERY_DEPTH 4
extern std::vector<BaseRef_t> treeresult_vec[MAX_TREEQUERY_DEPTH];
extern ptrdiff_t cur_treeresult_vec;

enum SortMode
{
    SORTMODE_NONE = 0,
    SORTMODE_ID = 1,
    SORTMODE_LOC = 2,
    SORTMODE_Z = 3,
    SORTMODE_COMPAT = 4, // sort according to ID (location at last sort) in compat mode, and according to current location normally
};

enum QueryMode
{
    QUERY_NORMAL = 0,
    QUERY_FLBLOCK = 1,
    QUERY_TEMPBLOCK = 2,
};

namespace Comparisons
{
    // sort by location
    template<class ItemRef_t>
    inline bool Loc(BaseRef_t a, BaseRef_t b)
    {
        return (((ItemRef_t)a)->Location.X <= ((ItemRef_t)b)->Location.X
            && (((ItemRef_t)a)->Location.X < ((ItemRef_t)b)->Location.X
                || ((ItemRef_t)a)->Location.Y < ((ItemRef_t)b)->Location.Y));
    }

    // sort by index
    template<class ItemRef_t>
    inline bool ID(BaseRef_t a, BaseRef_t b)
    {
        return a < b;
    }

    // sort by index when unimplemented
    template<class ItemRef_t>
    inline bool Z(BaseRef_t a, BaseRef_t b)
    {
        return a < b;
    }

    // sort blocks by Y, then index
    template<>
    inline bool Z<BlockRef_t>(BaseRef_t a, BaseRef_t b)
    {
        return (((BlockRef_t)a)->Location.Y < ((BlockRef_t)b)->Location.Y) ||
            (((BlockRef_t)a)->Location.Y == ((BlockRef_t)b)->Location.Y && a < b);
    }

    // sort BGOs by SortPriority
    template<>
    inline bool Z<BackgroundRef_t>(BaseRef_t a, BaseRef_t b)
    {
        return (((BackgroundRef_t)a)->SortPriority < ((BackgroundRef_t)b)->SortPriority)
            || (((BackgroundRef_t)a)->SortPriority == ((BackgroundRef_t)b)->SortPriority
                && ((BackgroundRef_t)a)->Location.X < ((BackgroundRef_t)b)->Location.X);
    }
}

template<class ItemRef_t>
class TreeResult_Sentinel
{
public:
    struct it
    {
        using iterator_category = std::input_iterator_tag;
        using difference_type   = std::ptrdiff_t;
        using value_type        = typename ItemRef_t::value_type;
        using pointer           = ItemRef_t*;
        using reference         = ItemRef_t;

        reference operator*() const { return (reference)*it_internal; }
        pointer operator->() { return &((reference)*it_internal); }

        // Prefix increment
        it& operator++() { it_internal++; return *this; }

        // Postfix increment
        it operator++(int) { it tmp = *this; ++(*this); return tmp; }

        // Prefix decrement
        it& operator--() { it_internal--; return *this; }

        // Postfix decrement
        it operator--(int) { it tmp = *this; --(*this); return tmp; }

        friend bool operator== (const it& a, const it& b) { return a.it_internal == b.it_internal; }
        friend bool operator!= (const it& a, const it& b) { return a.it_internal != b.it_internal; }
        friend bool operator<= (const it& a, const it& b) { return a.it_internal <= b.it_internal; }
        friend bool operator>= (const it& a, const it& b) { return a.it_internal >= b.it_internal; }
        friend bool operator< (const it& a, const it& b) { return a.it_internal < b.it_internal; }
        friend bool operator> (const it& a, const it& b) { return a.it_internal > b.it_internal; }

        std::vector<BaseRef_t>::iterator it_internal;
    };

    std::vector<BaseRef_t>* i_vec = nullptr;

    TreeResult_Sentinel()
    {
        SDL_assert(cur_treeresult_vec >= 0); // invalid state
        SDL_assert_release(cur_treeresult_vec < MAX_TREEQUERY_DEPTH); // insufficient sentinels: move recursive calls out of sentinel scope
        i_vec = &treeresult_vec[cur_treeresult_vec];
        i_vec->clear();
        cur_treeresult_vec ++;
    }

    TreeResult_Sentinel(const TreeResult_Sentinel& other) = delete;
    const TreeResult_Sentinel& operator=(const TreeResult_Sentinel& other) = delete;

    TreeResult_Sentinel(TreeResult_Sentinel&& other)
    {
        i_vec = other.i_vec;
        other.i_vec = nullptr;
    }

    const TreeResult_Sentinel& operator=(const TreeResult_Sentinel&& other) = delete;

    it begin() const
    {
        SDL_assert(i_vec); // invalid use of discarded sentinel
        it ret;
        ret.it_internal = i_vec->begin();
        return ret;
    }

    it end() const
    {
        SDL_assert(i_vec); // invalid use of discarded sentinel
        it ret;
        ret.it_internal = i_vec->end();
        return ret;
    }

    ~TreeResult_Sentinel()
    {
        if(!i_vec)
            return;
        cur_treeresult_vec --;
        SDL_assert(cur_treeresult_vec == i_vec - &treeresult_vec[0]); // scopes have been switched
    }
};

extern void treeWorldCleanAll();
extern void treeLevelCleanAll();

extern void treeWorldTileAdd(TileRef_t obj);
extern void treeWorldTileUpdate(TileRef_t obj);
extern void treeWorldTileRemove(TileRef_t obj);
extern TreeResult_Sentinel<TileRef_t> treeWorldTileQuery(int Left, int Top, int Right, int Bottom,
                               int sort_mode, int margin = 0);
extern TreeResult_Sentinel<TileRef_t> treeWorldTileQuery(const TinyLocation_t &loc, int sort_mode, int margin = 0);


extern void treeWorldSceneAdd(SceneRef_t obj);
extern void treeWorldSceneUpdate(SceneRef_t obj);
extern void treeWorldSceneRemove(SceneRef_t obj);
extern TreeResult_Sentinel<SceneRef_t> treeWorldSceneQuery(int Left, int Top, int Right, int Bottom,
                               int sort_mode, int margin = 16);
extern TreeResult_Sentinel<SceneRef_t> treeWorldSceneQuery(const TinyLocation_t &loc, int sort_mode, int margin = 16);


extern void treeWorldPathAdd(WorldPathRef_t obj);
extern void treeWorldPathUpdate(WorldPathRef_t obj);
extern void treeWorldPathRemove(WorldPathRef_t obj);
extern TreeResult_Sentinel<WorldPathRef_t> treeWorldPathQuery(int Left, int Top, int Right, int Bottom,
                               int sort_mode, int margin = 16);
extern TreeResult_Sentinel<WorldPathRef_t> treeWorldPathQuery(const TinyLocation_t &loc, int sort_mode, int margin = 16);


extern void treeWorldLevelAdd(WorldLevelRef_t obj);
extern void treeWorldLevelUpdate(WorldLevelRef_t obj);
extern void treeWorldLevelRemove(WorldLevelRef_t obj);
extern TreeResult_Sentinel<WorldLevelRef_t> treeWorldLevelQuery(int Left, int Top, int Right, int Bottom,
                               int sort_mode, int margin = 16);
extern TreeResult_Sentinel<WorldLevelRef_t> treeWorldLevelQuery(const TinyLocation_t &loc, int sort_mode, int margin = 16);

extern void treeWorldMusicAdd(WorldMusicRef_t obj);
extern void treeWorldMusicUpdate(WorldMusicRef_t obj);
extern void treeWorldMusicRemove(WorldMusicRef_t obj);
extern TreeResult_Sentinel<WorldMusicRef_t> treeWorldMusicQuery(int Left, int Top, int Right, int Bottom,
                               int sort_mode, int margin = 16);
extern TreeResult_Sentinel<WorldMusicRef_t> treeWorldMusicQuery(const TinyLocation_t &loc, int sort_mode, int margin = 16);


// declared in block_table.cpp

extern void treeLevelCleanBlockLayers();
extern void treeBlockAddLayer(int layer, BlockRef_t obj);
extern void treeBlockRemoveLayer(int layer, BlockRef_t obj);
extern void treeBlockUpdateLayer(int layer, BlockRef_t obj);

/**
 * \brief queries the block table, and excludes tempBlocks from the results if called while tempBlocks are active
 *
 * use this to replace VB6 iterations over block columns (that previously used FLBlock), or code that specifically wants to exclude tempBlocks
 **/
extern TreeResult_Sentinel<BlockRef_t> treeFLBlockQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                               int sort_mode, num_t margin = 2);
extern void treeFLBlockQuery(std::vector<BaseRef_t>& out, const Location_t &loc, int sort_mode);
extern TreeResult_Sentinel<BlockRef_t> treeFLBlockQuery(const Location_t &loc, int sort_mode);

/**
 * \brief queries the block table, and includes tempBlocks in the results if called while tempBlocks are active
 *
 * use this in new code, and to replace VB6 iterations over the full block array
 **/
extern TreeResult_Sentinel<BlockRef_t> treeBlockQuery(const Location_t &loc, int sort_mode);

extern void treeTempBlockFullClear();
extern void treeTempBlockEnable();
extern void treeTempBlockClear();
extern void treeTempBlockAdd(BlockRef_t obj);
extern void treeTempBlockUpdate(BlockRef_t obj);
extern void treeTempBlockRemove(BlockRef_t obj);
extern TreeResult_Sentinel<BlockRef_t> treeTempBlockQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                               int sort_mode, num_t margin = 2);
extern void treeTempBlockQuery(std::vector<BaseRef_t>& out, const Location_t &loc, int sort_mode);
extern TreeResult_Sentinel<BlockRef_t> treeTempBlockQuery(const Location_t &loc, int sort_mode);

extern void treeLevelCleanBackgroundLayers();
extern void treeBackgroundAddLayer(int layer, BackgroundRef_t obj);
extern void treeBackgroundRemoveLayer(int layer, BackgroundRef_t obj);
extern void treeBackgroundUpdateLayer(int layer, BackgroundRef_t obj);
extern TreeResult_Sentinel<BackgroundRef_t> treeBackgroundQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                               int sort_mode, num_t margin = 2);
extern void treeBackgroundQuery(std::vector<BaseRef_t>& out, const Location_t &loc, int sort_mode);
extern TreeResult_Sentinel<BackgroundRef_t> treeBackgroundQuery(const Location_t &loc, int sort_mode);

extern void treeNPCClear();
extern void treeNPCAdd(NPCRef_t obj);
extern void treeNPCRemove(NPCRef_t obj);
extern bool treeNPCUpdate(NPCRef_t obj);
extern void treeNPCSplitTempBlock(NPCRef_t obj);
extern void treeNPCUpdateTempBlock(NPCRef_t obj);
extern TreeResult_Sentinel<NPCRef_t> treeNPCQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                               int sort_mode, num_t margin = 2);
extern void treeNPCQuery(std::vector<BaseRef_t>& out, const Location_t &loc, int sort_mode);
extern TreeResult_Sentinel<NPCRef_t> treeNPCQuery(const Location_t &loc, int sort_mode);

extern void treeLevelCleanWaterLayers();
extern void treeWaterAddLayer(int layer, WaterRef_t obj);
extern void treeWaterRemoveLayer(int layer, WaterRef_t obj);
extern void treeWaterUpdateLayer(int layer, WaterRef_t obj);
extern TreeResult_Sentinel<WaterRef_t> treeWaterQuery(num_t Left, num_t Top, num_t Right, num_t Bottom,
                               int sort_mode, num_t margin = 2);
extern TreeResult_Sentinel<WaterRef_t> treeWaterQuery(const Location_t &loc, int sort_mode);

// removed in favor of block quadtree

// extern void blockTileGet(const Location_t &loc, int64_t &fBlock, int64_t &lBlock);
// extern void blockTileGet(double x, double w, int64_t &fBlock, int64_t &lBlock);

// special class used to handle situation where query may need to be significantly updated after location changes
template<class ItemRef_t>
class UpdatableQuery
{
    TreeResult_Sentinel<ItemRef_t> sent;
    Location_t bounds; // bounds that were used for the previous query, including margin
    const SortMode sort_mode;
    const QueryMode block_query_mode;

public:
    struct it
    {
        using iterator_category = std::input_iterator_tag;
        using difference_type   = std::ptrdiff_t;
        using value_type        = typename ItemRef_t::value_type;
        using pointer           = ItemRef_t*;
        using reference         = ItemRef_t;

        it(const TreeResult_Sentinel<ItemRef_t>& sent, ptrdiff_t index)
            : parent(*sent.i_vec), index(index) {}

        reference operator*() const { return (reference)(parent[index]); }
        pointer operator->() { return &*this; }

        // Prefix increment
        it& operator++() { index++; return *this; }

        // Postfix increment
        it operator++(int) { it tmp = *this; ++(*this); return tmp; }

        // Prefix decrement
        it& operator--() { index--; return *this; }

        // Postfix decrement
        it operator--(int) { it tmp = *this; --(*this); return tmp; }

        friend bool operator== (const it& a, const it& b) { return a.index == b.index; }
        friend bool operator!= (const it& a, const it& b) { return a.index != b.index; }
        friend bool operator<= (const it& a, const it& b) { return a.index <= b.index; }
        friend bool operator>= (const it& a, const it& b) { return a.index >= b.index; }
        friend bool operator< (const it& a, const it& b) { return a.index < b.index; }
        friend bool operator> (const it& a, const it& b) { return a.index > b.index; }

        const std::vector<BaseRef_t>& parent;
        ptrdiff_t index;
    };

    UpdatableQuery(const Location_t& target, SortMode sort_mode, QueryMode block_query_mode = QUERY_NORMAL)
        : sort_mode(sort_mode), block_query_mode(block_query_mode)
    {
        update(target, end());
    }

    it begin() const
    {
        SDL_assert(sent.i_vec); // invalid use of discarded sentinel
        it ret(sent, 0);
        return ret;
    }

    it end() const
    {
        SDL_assert(sent.i_vec); // invalid use of discarded sentinel
        it ret(sent, sent.i_vec->size());
        return ret;
    }

    void update(const Location_t& loc, const it& current_step);
};

#endif // TREES_HHHH


================================================
FILE: src/main/world_file.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_timer.h"

#include <json/json_rwops_input.hpp>
#include <json/json.hpp>
#include <fmt_format_ne.h>

#include "core/render.h"

#include "../globals.h"
#include "../frame_timer.h"
#include "../game_main.h"
#include "../load_gfx.h"
#include "../sound.h"
#include "../custom.h"
#include "config.h"
#include "../main/trees.h"
#include "level_file.h"
#include "world_file.h"
#include "saved_layers.h"
#include "main/game_info.h"
#include "main/level_save_info.h"
#include "main/screen_progress.h"
#include "main/game_strings.h"
#include "translate_episode.h"
#include "fontman/font_manager.h"
#include "../version.h"

#include <Utils/strings.h>
#include <Utils/files.h>
#include <Utils/dir_list_ci.h>
#include <Archives/archives.h>
#include <Logger/logger.h>
#include <PGE_File_Formats/file_formats.h>

#include "global_dirs.h"

#include "editor/editor_custom.h"
#include "editor/editor_strings.h"

struct WorldLoad
{
    int FileRelease = 64;
};

#ifdef PGEFL_CALLBACK_API
WorldLoadCallbacks OpenWorld_SetupCallbacks(WorldLoad& load);
using callback_error = PGE_FileFormats_misc::callback_error;
#else
bool OpenWorld_Unpack(WorldLoad& load, WorldData& wld);
using callback_error = std::runtime_error;
#endif

bool OpenWorld_Post(const WorldLoad& load);

// defined in level_file.cpp
[[ noreturn ]] void priv_FeatureLevelError(const std::string& errMsg, int reqFeatureLevel, int curFeatureLevel);

bool OpenWorld(std::string FilePath)
{
    // USE PGE-FL here
    // std::string newInput = "";
    WorldLoad load;
    // long long zCounter = 0;

    ClearWorld();

//    for(A = FilePath.length(); A >= 1; A--)
//    {
//        if(FilePath.substr(A - 1, 1) == "/" || FilePath.substr(A - 1, 1) == "\\")
//            break;
//    }

    // set the file path and load custom configuration
    FileNamePath = Files::dirname(FilePath) + "/";
    g_dirEpisode.setCurDir(FileNamePath);

    FileName = g_dirEpisode.resolveDirCase(Files::basenameNoSuffix(FilePath));
    g_dirCustom.setCurDir(FileNamePath + FileName);

    FileNameFull = Files::basename(FilePath);
    FullFileName = FilePath;

    // Preserve these values for quick restoring when going to the world map
    FileNameFullWorld = FileNameFull;
    FileNameWorld = FileName;
    FileNamePathWorld = FileNamePath;
    FileFormatWorld = FileFormat;

    FontManager::loadCustomFonts();

    LoadCustomConfig();
    FindCustomPlayers();
    LoadCustomGFX(true);
    if(!LoadDefaultSavedLayers())
    {
        MessageText = "savedlayers.ini invalid";
        return false;
    }

    // bool compatModern = (g_config.compatibility_mode == Config_t::COMPAT_OFF);

    numTiles = 0;
    numScenes = 0;
    numWorldLevels = 0;
    numWorldPaths = 0;
    numWorldMusic = 0;
    numWorldAreas = 0;

    // FileFormats::OpenWorldFile(FilePath, wld);
    PGE_FileFormats_misc::RWopsTextInput in(Files::open_file(FilePath, "r"), FilePath);

    if(in.eof())
    {
        pLogWarning("File [%s] missing!", FilePath.c_str());
        MessageText = "File does not exist";
        return false;
    }

#ifdef PGEFL_CALLBACK_API
    WorldLoadCallbacks callbacks = OpenWorld_SetupCallbacks(load);
    if(!FileFormats::OpenWorldFileT(in, callbacks))
    {
        pLogDebug("Failed to load [%s]", FilePath.c_str());
        return false;
    }
#else // #ifdef PGEFL_CALLBACK_API
    {
        WorldData wld;

        if(!FileFormats::OpenWorldFileT(in, wld))
        {
            pLogWarning("Error of world \"%s\" file loading: %s (line %ld).",
                        FilePath.c_str(),
                        wld.meta.ERROR_info.c_str(),
                        wld.meta.ERROR_linenum);
            MessageText = std::move(wld.meta.ERROR_info);
            return false;
        }

        if(!OpenWorld_Unpack(load, wld))
            return false;
    }
#endif // #ifdef PGEFL_CALLBACK_API

    return OpenWorld_Post(load);
}

#ifdef PGEFL_CALLBACK_API
void OpenWorld_Error(void*, FileFormatsError& e)
{
    pLogWarning("Error of world file loading: %s (line %ld).",
                e.ERROR_info.c_str(),
                e.ERROR_linenum);

    MessageText = std::move(e.ERROR_info);
}
#endif

#ifdef PGEFL_CALLBACK_API
bool OpenWorld_Head(void* userdata, WorldHead& wld)
#else
bool OpenWorld_Head(void* userdata, WorldData& wld)
#endif
{
    WorldLoad& load = *static_cast<WorldLoad*>(userdata);

    constexpr unsigned int engineFeatureLevel = V_FEATURE_LEVEL;

#ifdef PGEFL_CALLBACK_API
    FileFormat = wld.RecentFormat;
    unsigned int reqFeatureLevel = wld.engineFeatureLevel;
    if(wld.RecentFormat == LevelData::SMBX64)
        load.FileRelease = int(wld.RecentFormatVersion);
#else
    FileFormat = wld.meta.RecentFormat;
    unsigned int reqFeatureLevel = wld.meta.engineFeatureLevel;
    if(wld.meta.RecentFormat == LevelData::SMBX64)
        load.FileRelease = int(wld.meta.RecentFormatVersion);
#endif

    if(reqFeatureLevel > engineFeatureLevel)
        priv_FeatureLevelError(g_gameStrings.errorTooOldEngine, reqFeatureLevel, engineFeatureLevel);
    else if(reqFeatureLevel > g_gameInfo.contentFeatureLevel)
        priv_FeatureLevelError(g_gameStrings.errorTooOldGameAssets, reqFeatureLevel, g_gameInfo.contentFeatureLevel);

    WorldName = wld.EpisodeTitle;

    // cancel block if cheat is active
    if(g_forceCharacter && !LevelEditor && !WorldEditor)
    {
        for(int A = 1; A <= numCharacters; A++)
            blockCharacter[A] = false;
    }
    // load character block
    else
    {
        for(size_t A = 1; A <= numCharacters && A - 1 < wld.nocharacter.size(); A++)
            blockCharacter[A] = wld.nocharacter[A - 1];
    }

    StartLevel = wld.IntroLevel_file;
    addMissingLvlSuffix(StartLevel);
    StartLevel = g_dirEpisode.resolveFileCase(StartLevel);

    NoMap = wld.HubStyledWorld;
    RestartLevel = wld.restartlevel;

    // new:
    WorldStarsShowPolicy = wld.starsShowPolicy;

    MaxWorldStars = int(wld.stars);

    // world extra settings:
    WldxCustomParams.clear();
    SubHubLevels.clear();

    Strings::dealloc(g_recentWorldIntro);
    Strings::dealloc(g_recentWorldOutro);

    if(!wld.custom_params.empty())
    {
        WldxCustomParams = wld.custom_params;

        try
        {
            const nlohmann::json world_data = nlohmann::json::parse(wld.custom_params);

            if(world_data.contains("sub_hubs_list"))
            {
                for(const nlohmann::json& sub_hub : world_data["sub_hubs_list"])
                    SubHubLevels.push_back(sub_hub.get<std::string>());
            }

            if(world_data.contains("custom_intro"))
            {
                auto p = world_data["custom_intro"];
                if(p.contains("intro_path"))
                {
                    std::string pp = p.value("intro_path", std::string());
                    if(!pp.empty())
                    {
                        if(FileNamePath[0] == ':' && FileNamePath[1] == 'e')
                            g_recentWorldIntro = "@" + Archives::episode_archive_path() + ":/" + pp;
                        else
                            g_recentWorldIntro = FileNamePath + pp;
                    }
                }
            }

            if(world_data.contains("custom_outro"))
            {
                auto p = world_data["custom_outro"];
                if(p.contains("outro_path"))
                {
                    std::string pp = p.value("outro_path", std::string());
                    g_recentWorldOutro = FileNamePath + pp;
                }
            }
        }
        catch(const std::exception &e)
        {
            pLogWarning("Failed to load World %s JSON data: %s", FileNameFull.c_str(), e.what());
        }
    }

    // world credits
    numWorldCredits = 0;
    for(int i = 1; i <= maxWorldCredits; i++)
        WorldCredits[i].clear();

    int B = 0;
    std::vector<std::string> authorsList;
    if(!wld.authors.empty())
    {
        Strings::split(authorsList, wld.authors, "\n");
        for(auto &c : authorsList)
        {
            ++B;
            if(B > maxWorldCredits)
                break;
            WorldCredits[B] = c;
            numWorldCredits = B;
        }
    }

    return true;
}

bool OpenWorld_Tile(void*, WorldTerrainTile& t)
{
    {
        numTiles++;
        if(numTiles > maxTiles)
        {
            numTiles = maxTiles;
            return false;
        }

        auto &terra = Tile[numTiles];

        terra = Tile_t();

        terra.Location.X = t.x;
        terra.Location.Y = t.y;
        terra.Type = int(t.id);
        terra.Location.Width = TileWidth[terra.Type];
        terra.Location.Height = TileHeight[terra.Type];
        // terra.Z = zCounter++;
        treeWorldTileAdd(&terra);

        if(IF_OUTRANGE(terra.Type, 1, maxTileType)) // Drop ID to 1 for Tiles of out of range IDs
        {
            pLogWarning("TILE-%d ID is out of range (max types %d), reset to TILE-1", terra.Type, maxTileType);
            terra.Type = 1;
        }
    }

    return true;
}

bool OpenWorld_Scene(void*, WorldScenery& s)
{
    {
        numScenes++;
        if(numScenes > maxScenes)
        {
            numScenes = maxScenes;
            return false;
        }

        auto &scene = Scene[numScenes];

        scene = Scene_t();

        scene.Type = int(s.id);
        scene.Location.X = s.x;
        scene.Location.Y = s.y;
        scene.Location.Width = SceneWidth[scene.Type];
        scene.Location.Height = SceneHeight[scene.Type];
        scene.Active = true;
        // scene.Z = zCounter++;
        treeWorldSceneAdd(&scene);

        if(IF_OUTRANGE(scene.Type, 1, maxSceneType)) // Drop ID to 1 for Scenery of out of range IDs
        {
            pLogWarning("TILE-%d ID is out of range (max types %d), reset to TILE-1", scene.Type, maxSceneType);
            scene.Type = 1;
        }
    }

    return true;
}

bool OpenWorld_Path(void*, WorldPathTile& p)
{
    {
        numWorldPaths++;
        if(numWorldPaths > maxWorldPaths)
        {
            numWorldPaths = maxWorldPaths;
            return false;
        }

        auto &pp = WorldPath[numWorldPaths];

        pp = WorldPath_t();

        pp.Location.X = p.x;
        pp.Location.Y = p.y;
        pp.Type = int(p.id);
        pp.Location.Width = 32;
        pp.Location.Height = 32;
        pp.Active = false;
        // pp.Z = zCounter++;
        treeWorldPathAdd(&pp);
//        if(LevelEditor == true)
//            pp.Active = true;

        if(IF_OUTRANGE(pp.Type, 1, maxPathType)) // Drop ID to 1 for Path of out of range IDs
        {
            pLogWarning("PATH-%d ID is out of range (max types %d), reset to PATH-1", pp.Type, maxPathType);
            pp.Type = 1;
        }
    }

    return true;
}

bool OpenWorld_Level(void*, WorldLevelTile& l)
{
    {
        numWorldLevels++;
        if(numWorldLevels > maxWorldLevels)
        {
            numWorldLevels = maxWorldLevels;
            return false;
        }

        auto &ll = WorldLevel[numWorldLevels];

        ll = WorldLevel_t();

        ll.Location.X = l.x;
        ll.Location.Y = l.y;
        ll.Type = int(l.id);
        validateLevelName(ll.FileName, l.lvlfile);
        ll.LevelName = l.title;
        ll.LevelExit[1] = l.top_exit;
        ll.LevelExit[2] = l.left_exit;
        ll.LevelExit[3] = l.bottom_exit;
        ll.LevelExit[4] = l.right_exit;
        ll.Location.Width = 32;
        ll.Location.Height = 32;
        ll.StartWarp = int(l.entertowarp);
        ll.Visible = l.alwaysVisible;
        ll.Active = ll.Visible;
        ll.Path = l.pathbg;
        ll.Start = l.gamestart;
        ll.WarpX = l.gotox;
        ll.WarpY = l.gotoy;
        ll.Path2 = l.bigpathbg;

        // new:
        ll.starsShowPolicy = l.starsShowPolicy;

        // ll.Z = zCounter++;
        treeWorldLevelAdd(&ll);

        if(IF_OUTRANGE(ll.Type, 0, maxLevelType)) // Drop ID to 1 for Levels of out of range IDs
        {
            pLogWarning("PATH-%d ID is out of range (max types %d), reset to PATH-1", ll.Type, maxLevelType);
            ll.Type = 1;
        }
    }

    return true;
}

bool OpenWorld_Music(void*, WorldMusicBox& m)
{
    {
        numWorldMusic++;
        if(numWorldMusic > maxWorldMusic)
        {
            numWorldMusic = maxWorldMusic;
            return false;
        }

        auto &box = WorldMusic[numWorldMusic];

        box = WorldMusic_t();

        box.Location.X = m.x;
        box.Location.Y = m.y;
        box.Type = int(m.id);

        // new:
        std::string music_file = g_dirEpisode.resolveFileCase(m.music_file);
        if(!music_file.empty())
        {
            SetS(box.MusicFile, music_file); // adds to LevelString
        }

        // In game they are smaller (30x30), in world they are 32x32
        if(!LevelEditor)
        {
            box.Location.Width = 30;
            box.Location.Height = 30;
            box.Location.Y += 1;
            box.Location.X += 1;
        }
        else
        {
            box.Location.Width = 32;
            box.Location.Height = 32;
        }

        // box.Z = zCounter++;
        treeWorldMusicAdd(&box);
    }

    return true;
}

bool OpenWorld_AreaRect(void*, WorldAreaRect& m)
{
    {
        if(!(m.flags & WorldAreaRect::SETUP_SET_VIEWPORT))
            return true;

        numWorldAreas++;
        if(numWorldAreas > maxWorldAreas)
        {
            numWorldAreas = maxWorldAreas;
            return false;
        }

        auto &area = WorldArea[numWorldAreas];

        area = WorldArea_t();

        area.Location.X = m.x;
        area.Location.Y = m.y;
        area.Location.Width = m.w;
        area.Location.Height = m.h;
    }

    return true;
}

#ifdef PGEFL_CALLBACK_API

WorldLoadCallbacks OpenWorld_SetupCallbacks(WorldLoad& load)
{
    WorldLoadCallbacks callbacks;

    callbacks.on_error = OpenWorld_Error;
    callbacks.load_head = OpenWorld_Head;
    callbacks.load_level = OpenWorld_Level;
    callbacks.load_path = OpenWorld_Path;
    callbacks.load_scene = OpenWorld_Scene;
    callbacks.load_tile = OpenWorld_Tile;
    callbacks.load_music = OpenWorld_Music;
    callbacks.load_arearect = OpenWorld_AreaRect;

    callbacks.userdata = &load;

    return callbacks;
}

#else // #ifdef PGEFL_CALLBACK_API

bool OpenWorld_Unpack(WorldLoad& load, WorldData& wld)
{
    try
    {
        OpenWorld_Head(&load, wld);
    }
    catch(const callback_error& e)
    {
        pLogWarning("Error of level \"%s\" file loading: %s.",
                    wld.meta.filename.c_str(),
                    e.what());

        MessageText = e.what();

        return false;
    }

    for(auto &t : wld.tiles)
    {
        if(!OpenWorld_Tile(&load, t))
            break;
    }
    for(auto &s : wld.scenery)
    {
        if(!OpenWorld_Scene(&load, s))
            break;
    }
    for(auto &p : wld.paths)
    {
        if(!OpenWorld_Path(&load, p))
            break;
    }
    for(auto &l : wld.levels)
    {
        if(!OpenWorld_Level(&load, l))
            break;
    }
    for(auto &m : wld.music)
    {
        if(!OpenWorld_Music(&load, m))
            break;
    }
    for(auto &a : wld.arearects)
    {
        if(!OpenWorld_AreaRect(&load, a))
            break;
    }

    return true;
}

#endif // #ifdef PGEFL_CALLBACK_API

bool OpenWorld_Post(const WorldLoad& load)
{
    TranslateEpisode tr;

    if(!LevelEditor)
        tr.loadWorldTranslation(FileNameFull);

    LoadCustomSound();

    // the version targeting below is from SMBX 1.3
    const int FileRelease = load.FileRelease;

    if(!LevelEditor)
    {
        for(int A = 1; A <= numWorldLevels; A++)
        {
            auto &ll = WorldLevel[A];
            if((FileRelease <= 20 && ll.Type == 1) || (FileRelease > 20 && ll.Start))
            {
                WorldPlayer[1].Type = 1;
                WorldPlayer[1].Location = WorldLevel[A].Location;
                break;
            }
        }

        for(int A = 1; A <= numWorldLevels; A++)
        {
            auto &ll = WorldLevel[A];
            if((FileRelease <= 20 && ll.Type == 1) || (FileRelease > 20 && ll.Start))
            {
                ll.Active = true;
                LevelPath(WorldLevel[A], 5, true);
            }
        }
    }
    else
    {
        for(int A = 1; A <= numWorldLevels; A++)
        {
            auto &ll = WorldLevel[A];
            if(FileRelease <= 20 && ll.Type == 1)
                ll.Start = true;
        }

        vScreen[1].X = (XRender::TargetW / 2) - (800 / 2);
        vScreen[1].Y = (XRender::TargetH / 2) - (600 / 2);
    }

    SaveWorldStrings();
    resetFrameTimer();

    return true;
}

void ClearWorld(bool quick)
{
    int A = 0;

    for(A = 1; A <= numCharacters; A++)
    {
        blockCharacter[A] = false;
//        if(LevelEditor == true)
//            frmWorld::chkChar(A).Value = 0;
    }

    treeWorldCleanAll();

    for(A = 1; A <= numTiles; A++)
        Tile[A] = Tile_t();
    for(A = 1; A <= numWorldPaths; A++)
        WorldPath[A] = WorldPath_t();
    for(A = 1; A <= numScenes; A++)
        Scene[A] = Scene_t();
    for(A = 1; A <= numWorldLevels; A++)
        WorldLevel[A] = WorldLevel_t();
    for(A = 1; A <= numWorldMusic; A++)
        WorldMusic[A] = WorldMusic_t();

    WorldPlayer[1] = WorldPlayer_t();

    if(!quick)
    {
#ifdef __16M__
        XRender::clearAllTextures();
#endif

        ClearStringsBank();
        UnloadCustomGFX();
        UnloadWorldCustomGFX();
        UnloadCustomSound();
        LoadPlayerDefaults();
    }

    ClearSavedLayers();

    MaxWorldStars = 0;
    numTiles = 0;
    numWorldPaths = 0;
    numScenes = 0;
    numWorldLevels = 0;
    numWorldPaths = 0;
    numWorldMusic = 0;
    numWorldAreas = 0;
    RestartLevel = false;
    WorldStarsShowPolicy = WorldData::STARS_UNSPECIFIED;
    NoMap = false;
    IsEpisodeIntro = false;
    WldxCustomParams.clear();
    SubHubLevels.clear();
    StartLevel.clear();
    BeatTheGame = false;
    numWorldCredits = 0;
    // Clear custom outro if that was presented
    g_recentWorldOutro.clear();
    // default file format if world header is missing
    FileFormat = FileFormats::LVL_PGEX;

    for(int i = 1; i <= maxWorldCredits; i++)
        WorldCredits[i].clear();

    if(LevelEditor)
    {
        vScreen[1].X = 0;
        vScreen[1].Y = 0;
    }
//    if(LevelEditor == true)
//    {
//        frmLevelEditor::optCursor(14).Value = true;
//        frmWorld.txtWorldName = "";
//        frmWorld.txtStartLevel = "";
//        frmWorld::chkNoMap.Value = false;
//        frmWorld.chkRestartLevel = false;
//        vScreen[1].X = 0;
//        vScreen[1].Y = 0;
//        for(A = 1; A <= 5; A++)
//            frmWorld::txtCredits(A).Text = "";
//        frmWorld.txtStars = "";
//        MaxWorldStars = 0;
//    }
}

void FindWldStars()
{
    LevelData tempData;
    uint32_t start_time = SDL_GetTicks();

    bool world_must_show_stars = (WorldStarsShowPolicy == Config_t::MAP_STARS_SHOW);

    for(int A = 1; A <= numWorldLevels; A++)
    {
        IndicateProgress(start_time, num_t(A) / numWorldLevels, g_gameStrings.messageScanningLevels);

        auto &l = WorldLevel[A];

        if(!l.FileName.empty())
        {
            l.curStars = 0;

            for(const auto& star : Star)
            {
                if(SDL_strcasecmp(star.level.c_str(), Files::basename(l.FileName).c_str()) == 0)
                    l.curStars++;
            }

            bool level_must_show_stars = (l.starsShowPolicy == Config_t::MAP_STARS_SHOW);
            bool level_can_show_stars = (world_must_show_stars && l.starsShowPolicy == Config_t::MAP_STARS_UNSPECIFIED);

            // skip check for max stars and medals if it's already been inited, OR if the star count isn't needed
            if(l.save_info.inited() || !(level_must_show_stars || level_can_show_stars))
                continue;

            std::string lFile = l.FileName;
            addMissingLvlSuffix(lFile);

            std::string fullPath = g_dirEpisode.resolveFileCaseExistsAbs(lFile);

            if(!fullPath.empty())
                l.save_info = InitLevelSaveInfo(fullPath, tempData);
        }
    }
}

#if 0
// Is there any unsupported content for this format in the world?
bool CanConvertWorld(int format, std::string* reasons)
{
    if(format == FileFormats::WLD_PGEX)
        return true;

    if(format == FileFormats::WLD_SMBX38A)
    {
        if(reasons)
        {
            *reasons = g_editorStrings.fileConvert38aUnsupported;
            *reasons += '\n';
        }
        return false;
    }

    if(format != FileFormats::WLD_SMBX64)
    {
        if(reasons)
        {
            *reasons = g_editorStrings.fileConvertFormatUnknown;
            *reasons += '\n';
        }
        return false;
    }

    bool can_convert = true;
    if(reasons)
        reasons->clear();

    for(int i = 1; i <= numWorldMusic; i++)
    {
        if(!GetS(WorldMusic[i].MusicFile).empty())
        {
            can_convert = false;
            if(reasons)
            {
                *reasons = g_editorStrings.fileConvertFeatureCustomWorldMusic;
                *reasons += '\n';
            }
            break;
        }
    }

    if(WorldStarsShowPolicy != WorldData::STARS_UNSPECIFIED)
    {
        can_convert = false;
        if(reasons)
        {
            *reasons = g_editorStrings.fileConvertFeatureWorldStarDisplay;
            *reasons += '\n';
        }
    }

    for(int i = 1; i <= numWorldLevels; i++)
    {
        if(WorldLevel[i].starsShowPolicy != WorldData::STARS_UNSPECIFIED)
        {
            can_convert = false;
            if(reasons)
            {
                *reasons = g_editorStrings.fileConvertFeatureLevelStarDisplay;
                *reasons += '\n';
            }
        }
    }

    if(numWorldAreas > 0)
    {
        can_convert = false;
        if(reasons)
        {
            *reasons = g_editorStrings.fileConvertFeatureLevelStarDisplay;
            *reasons += '\n';
        }
    }

    return can_convert;
}

// Strips all unsupported content from the world.
void ConvertWorld(int format)
{
    FileFormat = format;
    if(format == FileFormats::LVL_SMBX64 || format == FileFormats::LVL_SMBX38A)
    {
        if(!FileNameFull.empty() && FileNameFull.back() == 'x')
            FileNameFull.resize(FileNameFull.size() - 1);
        if(!FullFileName.empty() && FullFileName.back() == 'x')
            FullFileName.resize(FullFileName.size() - 1);
    }
    else
    {
        if(!FileNameFull.empty() && FileNameFull.back() != 'x')
            FileNameFull += "x";
        if(!FullFileName.empty() && FullFileName.back() != 'x')
            FullFileName += "x";
    }

    if(format != FileFormats::WLD_SMBX64)
        return;

    for(int i = 1; i <= numWorldMusic; i++)
        SetS(WorldMusic[i].MusicFile, "");

    WorldStarsShowPolicy = WorldData::STARS_UNSPECIFIED;

    for(int i = 1; i <= numWorldLevels; i++)
        WorldLevel[i].starsShowPolicy = WorldData::STARS_UNSPECIFIED;

    numWorldAreas = 0;
}
#endif


================================================
FILE: src/main/world_file.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#pragma once
#ifndef WORLD_FILE_H
#define WORLD_FILE_H

#include <string>

//! loads the world
bool OpenWorld(std::string FilePath);
void FindWldStars();
//! clears the world.
//  when "quick" is true, does not unload custom assets. this is used only for creating new worlds at menu.
void ClearWorld(bool quick = false);

//! NEW: routines to check if it is possible to convert to legacy file formats and to remove all non-legacy content
// Removed, let PGE-FL handle conversion on its own.
// bool CanConvertWorld(int format, std::string* reasons);
// void ConvertWorld(int format);

#endif // WORLD_FILE_H


================================================
FILE: src/main/world_globals.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef WORLD_GLOBALS_H
#define WORLD_GLOBALS_H

#include "../screen_fader.h"

//! Holds the screen overlay for the world map
extern ScreenFader g_worldScreenFader;

//! Multiplier for world map qScreen
extern num_t g_worldCamSpeed;

//! Play sound if world map qScreen stays active next frame
extern bool g_worldPlayCamSound;

//! NEW: set the world player's section variable based on its position
extern void worldCheckSection(WorldPlayer_t& wp);

//! NEW: reset the world players' section variables without invoking qScreen
extern void worldResetSection();

extern void worldWaitForFade(int waitTicks = -1);

extern bool worldHasFrameAssets();

#endif // WORLD_GLOBALS_H


================================================
FILE: src/main/world_loop.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Utils/files.h>
#include <Integrator/integrator.h>
#include <pge_delay.h>
#include <fmt_format_ne.h>
#include <sdl_proxy/sdl_stdinc.h>

#include "../globals.h"
#include "../frame_timer.h"
#include "../game_main.h"
#include "../sound.h"
#include "../controls.h"
#include "../graphics.h"
#include "../collision.h"
#include "../player.h"
#include "../main/trees.h"
#include "../core/events.h"
#include "../config.h"
#include "gfx.h"
#include "message.h"
#include "main/world_globals.h"
#include "main/level_file.h"
#include "main/speedrunner.h"
#include "main/screen_quickreconnect.h"
#include "main/screen_connect.h"
#include "main/game_strings.h"
#include "graphics/gfx_world.h"

#include "global_dirs.h"

//! Holds the screen overlay for the world map
ScreenFader g_worldScreenFader;

//! Multiplier for world map qScreen
num_t g_worldCamSpeed = 1.5_n;

//! Play sound if world map qScreen stays active next frame
bool g_worldPlayCamSound = false;

void worldWaitForFade(int waitTicks)
{
    bool ticks = waitTicks > 0;
    while(((!ticks && !g_worldScreenFader.isComplete()) || (ticks && waitTicks >= 0)) && GameIsActive)
    {
        XEvents::doEvents();

        if(canProceedFrame())
        {
            computeFrameTime1();
            Controls::Update(false);
            // FIXME: strip logic out of UpdateGraphics2
            UpdateGraphics2();
            UpdateSound();
            XEvents::doEvents();
            computeFrameTime2();
            g_worldScreenFader.update();
            if(waitTicks >= 0)
                waitTicks--;
        }

        if(!g_config.unlimited_framerate)
            PGE_Delay(1);
    }

    // Ensure everything is clear
    if(GameIsActive)
    {
        XEvents::doEvents();
        GraphicsClearScreen();
    }
}


bool g_isWorldMusicNotSame(WorldMusic_t &mus)
{
    bool ret = false;
    ret |= (curWorldMusic != mus.Type);
    ret |= (mus.Type == CustomWorldMusicId() && curWorldMusicFile != GetS(mus.MusicFile));
    return ret;
}

void g_playWorldMusic(WorldMusic_t &mus)
{
    curWorldMusicFile = GetS(mus.MusicFile);
    StartMusic(mus.Type);
}

// returns size of largest box centered around loc contained in s
static inline int s_worldSectionArea(WorldAreaRef_t s, const TinyLocation_t& loc)
{
    int fX = loc.X + loc.Width / 2;
    int fY = loc.Y + loc.Height / 2;

    int side_x = SDL_min(fX - s->Location.X, s->Location.X + s->Location.Width - fX);
    int side_y = SDL_min(fY - s->Location.Y, s->Location.Y + s->Location.Height - fY);

    return side_x * side_y;
}

static inline bool s_worldUpdateMusic(const TinyLocation_t &loc)
{
    bool ret = false;

    for(auto t : treeWorldMusicQuery(loc, false))
    {
        WorldMusic_t &mus = *t;
        if(CheckCollision(loc, mus.Location))
        {
            if(g_isWorldMusicNotSame(mus))
            {
                g_playWorldMusic(mus);
                ret = true;
            }
        }
    }

    return ret;
}

static void s_worldCheckSection(WorldPlayer_t& wp, const TinyLocation_t& loc)
{
    int best_section = 0;
    int best_section_area = 0;
    int best_wasted_area = 0;

    for(int A = 1; A <= numWorldAreas; A++)
    {
        WorldArea_t &area = WorldArea[A];
        if(CheckCollision(loc, area.Location))
        {
            int section_area = s_worldSectionArea(A, loc);
            int wasted_area = area.Location.Width * area.Location.Height - section_area;

            if(section_area >= best_section_area && (section_area > best_section_area || wasted_area < best_wasted_area))
            {
                best_section = A;
                best_section_area = section_area;
                best_wasted_area = wasted_area;
            }
        }
    }

    if(best_section != wp.Section)
    {
        wp.Section = best_section;

        // enable a qScreen to the new section
        if(!qScreen)
        {
            const int Z = l_screen->vScreen_refs[0];

            qScreen = true;
            g_worldPlayCamSound = true;
            qScreenLoc[Z] = vScreen[Z];

            // move camera quickly for transitions!
            if(g_worldCamSpeed < 4)
                g_worldCamSpeed = 4;
        }
    }
}

void worldCheckSection(WorldPlayer_t& wp)
{
    s_worldCheckSection(wp, wp.Location);
}

static inline int getWPHeight()
{
    switch(WorldPlayer[1].Type)
    {
    case 3:
        return 44;
        break;
    case 4:
        return 40;
        break;
    default:
        return 32;
        break;
    }
}

void worldResetSection()
{
    worldCheckSection(WorldPlayer[1]);
    qScreen = false;
    GetvScreenWorld(l_screen->vScreen(1));
}

//static inline double getWorldPlayerX()
//{
//    return WorldPlayer[1].Location.X;
//}

//static inline double getWorldPlayerY()
//{
//    return WorldPlayer[1].Location.Y - 10 + WorldPlayer[1].Location.Height - getWPHeight();
//}

static inline int getWorldPlayerCenterX()
{
    return (int)(WorldPlayer[1].Location.X + WorldPlayer[1].Location.Width / 2);
}

static inline int getWorldPlayerCenterY()
{
    return (int)(WorldPlayer[1].Location.Y + WorldPlayer[1].Location.Height) - 10 - getWPHeight() / 2;
}

void WorldLoop()
{
    bool musicReset = false;
    const int Z = l_screen->vScreen_refs[0];

    if(GamePaused != PauseCode::None)
    {
        PauseLoop();

        if(GamePaused != PauseCode::None)
            return;
        else
            goto resume_from_pause;
    }

    // Location_t tempLocation;
    // int A = 0;
    // int B = 0;

    if(SingleCoop > 0)
        SingleCoop = 1;

    // remove any temporary path focus
    vScreen[Z].TempDelay = 0;
    vScreen[Z].tempX = 0;
    vScreen[Z].TempY = 0;

    // disable cloned player mode
    if(g_ClonedPlayerMode)
    {
        numPlayers = (int)Controls::g_InputMethods.size();
        g_ClonedPlayerMode = false;
    }

    if(numPlayers < 1)
        numPlayers = 1;

    if(numPlayers > maxLocalPlayers)
        numPlayers = maxLocalPlayers;

    for(int B = 1; B <= numPlayers; B++)
    {
        if(Player[B].Mount == 2)
            Player[B].Mount = 0;
    }

    speedRun_tick();
    Integrator::sync();
    UpdateGraphics2();

    if(!Controls::Update())
    {
        QuickReconnectScreen::g_active = true;

        if(g_config.allow_drop_add && XMessage::GetStatus() == XMessage::Status::local)
            PauseGame(PauseCode::DropAdd, 0);
    }

    if(QuickReconnectScreen::g_active)
        QuickReconnectScreen::Logic();

    UpdateSound();

    g_worldScreenFader.update();

    if(curWorldLevel > 0)
    {
        if(LevelBeatCode > 0)
        {
            s_worldUpdateMusic(WorldPlayer[1].Location);
            worldResetSection();

            for(int A = 1; A <= 4; A++)
            {
                if(WorldLevel[curWorldLevel].LevelExit[A] == LevelBeatCode || WorldLevel[curWorldLevel].LevelExit[A] == -1)
                {
                    WorldPlayer[1].LevelIndex = curWorldLevel;
                    LevelPath(WorldLevel[curWorldLevel], A);
                }
            }

            SaveGame();
            LevelBeatCode = BEATCODE_NONE;
        }
        // case where the player manually quit or there was an error
        // (these should probably be split up -- the error logic is from SMBX 1.3 and should be preserved)
        else if(LevelBeatCode == BEATCODE_QUIT)
        {
            s_worldUpdateMusic(WorldPlayer[1].Location);
            worldResetSection();

            //for(A = 1; A <= numWorldLevels; A++)
            for(WorldLevelRef_t t : treeWorldLevelQuery(WorldPlayer[1].Location, SORTMODE_NONE))
            {
                WorldLevel_t &l = *t;
                if(CheckCollision(WorldPlayer[1].Location, l.Location))
                {
                    WorldPlayer[1].LevelIndex = t;
                    break;
                }
            }

            if(curWorldLevel > 0)
                LevelPath(WorldLevel[curWorldLevel], 5);

            SaveGame();
            LevelBeatCode = BEATCODE_NONE;
        }
    }
    else
        LevelBeatCode = BEATCODE_NONE;

    for(int A = 1; A <= numPlayers; A++)
    {
        Player[A].Bumped = false;
        Player[A].Bumped2 = 0;
        Player[A].CanFly = false;
        Player[A].CanFly2 = false;
        Player[A].Effect = PLREFF_NORMAL;
        Player[A].Effect2 = 0;
        Player[A].FlyCount = 0;
        Player[A].TailCount = 0;
        Player[A].Stoned = false;
    }

    if(WorldPlayer[1].Move > 0)
    {
        WorldPlayer[1].Frame2 += 1;

        if(WorldPlayer[1].Frame2 >= 8)
        {
            WorldPlayer[1].Frame2 = 0;
            WorldPlayer[1].Frame += 1;
        }

        if(WorldPlayer[1].Move == 1)
        {
            if(WorldPlayer[1].Frame < 6)
                WorldPlayer[1].Frame = 7;
            if(WorldPlayer[1].Frame > 7)
                WorldPlayer[1].Frame = 6;
        }

        if(WorldPlayer[1].Move == 4)
        {
            if(WorldPlayer[1].Frame < 2)
                WorldPlayer[1].Frame = 3;
            if(WorldPlayer[1].Frame > 3)
                WorldPlayer[1].Frame = 2;
        }

        if(WorldPlayer[1].Move == 3)
        {
            if(WorldPlayer[1].Frame < 0)
                WorldPlayer[1].Frame = 1;
            if(WorldPlayer[1].Frame > 1)
                WorldPlayer[1].Frame = 0;
        }

        if(WorldPlayer[1].Move == 2)
        {
            if(WorldPlayer[1].Frame < 4)
                WorldPlayer[1].Frame = 5;
            if(WorldPlayer[1].Frame > 5)
                WorldPlayer[1].Frame = 4;
        }
    }


    if(WorldPlayer[1].Move == 0)
    {
        if(SharedPause)
        {
            PauseInit(PauseCode::PauseScreen, 0);
            return;
        }

        for(int i = 1; i <= numPlayers; i++)
        {
            if(Player[i].Controls.Start && Player[i].UnStart)
            {
                PauseInit(PauseCode::PauseScreen, 0);
                return;
            }

            // only allow P1 to pause if multiplayer pause controls disabled
            if(!g_config.multiplayer_pause_controls)
                break;
        }

resume_from_pause:

        // find player's current level
        TinyLocation_t tempLocation = WorldPlayer[1].Location;
        tempLocation.Width -= 8;
        tempLocation.Height -= 8;
        tempLocation.X += 4;
        tempLocation.Y += 4;

        WorldPlayer[1].LevelIndex = 0;

        //for(A = 1; A <= numWorldLevels; A++)
        for(auto t : treeWorldLevelQuery(tempLocation, SORTMODE_Z))
        {
            WorldLevel_t &l = *t;
            if(CheckCollision(tempLocation, l.Location))
            {
                WorldPlayer[1].LevelIndex = t;
                break;
            }
        }

        // NEW: allow CanAltJump to start levels (for starting levels using AltJump)
        if(g_config.multiplayer_pause_controls)
        {
            if(Player[1].Controls.AltJump)
            {
                if(Player[1].CanAltJump)
                    Player[1].Controls.Jump = true;

                Player[1].CanAltJump = false;
            }
            else
                Player[1].CanAltJump = true;
        }

        // geneeral controls / movement logic
        if(Player[1].Controls.Up)
        {
            tempLocation.Y -= 32;

            //for(A = 1; A <= numWorldPaths; A++)
            for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_ID))
            {
                WorldPath_t &path = *t;
                if(CheckCollision(tempLocation, path.Location) && path.Active)
                {
                    WorldPlayer[1].Move = 1;
                    break;
                }
            }

            //for(A = 1; A <= numWorldLevels; A++)
            for(auto t : treeWorldLevelQuery(tempLocation, SORTMODE_ID))
            {
                WorldLevel_t &lvl = *t;
                if(WorldPlayer[1].Move == 0)
                {
                    if(CheckCollision(tempLocation, lvl.Location) && lvl.Active)
                    {
                        WorldPlayer[1].Move = 1;
                        break;
                    }
                }
            }

            if(WalkAnywhere)
                WorldPlayer[1].Move = 1;

            if(WorldPlayer[1].Move == 0)
            {
                WorldPlayer[1].Move3 = false;
                PlaySound(SFX_BlockHit);
                SoundPause[SFX_BlockHit] = 2;
            }
        }
        else if(Player[1].Controls.Left)
        {
            tempLocation.X -= 32;

            //for(A = 1; A <= numWorldPaths; A++)
            for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_ID))
            {
                WorldPath_t &path = *t;
                if(CheckCollision(tempLocation, path.Location) && path.Active)
                {
                    WorldPlayer[1].Move = 2;
                    break;
                }
            }

            //for(A = 1; A <= numWorldLevels; A++)
            for(auto t : treeWorldLevelQuery(tempLocation, SORTMODE_ID))
            {
                WorldLevel_t &lvl = *t;
                if(WorldPlayer[1].Move == 0)
                {
                    if(CheckCollision(tempLocation, lvl.Location) && lvl.Active)
                    {
                        WorldPlayer[1].Move = 2;
                        break;
                    }
                }
            }

            if(WalkAnywhere)
                WorldPlayer[1].Move = 2;
            if(WorldPlayer[1].Move == 0)
            {
                WorldPlayer[1].Move3 = false;
                PlaySound(SFX_BlockHit);
                SoundPause[SFX_BlockHit] = 2;
            }
        }
        else if(Player[1].Controls.Down)
        {
            tempLocation.Y += 32;

            //for(A = 1; A <= numWorldPaths; A++)
            for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_ID))
            {
                WorldPath_t &path = *t;
                if(CheckCollision(tempLocation, path.Location) && path.Active)
                {
                    WorldPlayer[1].Move = 3;
                    break;
                }
            }

            //for(A = 1; A <= numWorldLevels; A++)
            for(auto t : treeWorldLevelQuery(tempLocation, SORTMODE_ID))
            {
                WorldLevel_t &lvl = *t;
                if(WorldPlayer[1].Move == 0)
                {
                    if(CheckCollision(tempLocation, lvl.Location) && lvl.Active)
                    {
                        WorldPlayer[1].Move = 3;
                        break;
                    }
                }
            }

            if(WalkAnywhere)
                WorldPlayer[1].Move = 3;
            if(WorldPlayer[1].Move == 0)
            {
                WorldPlayer[1].Move3 = false;
                PlaySound(SFX_BlockHit);
                SoundPause[SFX_BlockHit] = 2;
            }
        }
        else if(Player[1].Controls.Right)
        {
            tempLocation.X += 32;

            //for(A = 1; A <= numWorldPaths; A++)
            for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_ID))
            {
                WorldPath_t &path = *t;
                if(CheckCollision(tempLocation, path.Location) && path.Active)
                {
                    WorldPlayer[1].Move = 4;
                    break;
                }
            }

            //for(A = 1; A <= numWorldLevels; A++)
            for(auto t : treeWorldLevelQuery(tempLocation, SORTMODE_ID))
            {
                WorldLevel_t &lvl = *t;
                if(WorldPlayer[1].Move == 0)
                {
                    if(CheckCollision(tempLocation, lvl.Location) && lvl.Active)
                    {
                        WorldPlayer[1].Move = 4;
                        break;
                    }
                }
            }

            if(WalkAnywhere)
                WorldPlayer[1].Move = 4;
            if(WorldPlayer[1].Move == 0)
            {
                WorldPlayer[1].Move3 = false;
                PlaySound(SFX_BlockHit);
                SoundPause[SFX_BlockHit] = 2;
            }
        }
        else if(Player[1].Controls.Jump && Player[1].UnStart)
        {
            //for(A = 1; A <= numWorldLevels; A++)
            for(WorldLevelRef_t t : treeWorldLevelQuery(tempLocation, SORTMODE_ID))
            {
                WorldLevel_t &lvl = *t;
                if(CheckCollision(tempLocation, lvl.Location))
                {
#if 0 // Moved into the handler of level ending
                    if(int(lvl.WarpX) != -1)
                        WorldPlayer[1].Location.X = lvl.WarpX;

                    if(int(lvl.WarpY) != -1)
                        WorldPlayer[1].Location.Y = lvl.WarpY;

                    if(int(lvl.WarpY) != -1 || int(lvl.WarpX) != -1)
                    {
                        LevelBeatCode = 6;
                        //for(B = 1; B <= numWorldLevels; B++)
                        for(auto t2 : treeWorldLevelQuery(WorldPlayer[1].Location, SORTMODE_ID))
                        {
                            WorldLevel_t &level2 = *t2;
                            if(CheckCollision(WorldPlayer[1].Location, level2.Location))
                            {
                                level2.Active = true;
                                curWorldLevel = t2;
                            }
                        }
                    }
#endif

                    if(!lvl.FileName.empty() && lvl.FileName != ".lvl" && lvl.FileName != ".lvlx")
                    {
                        addMissingLvlSuffix(lvl.FileName);
                        std::string levelPath = g_dirEpisode.resolveFileCaseExistsAbs(lvl.FileName);

                        if(!levelPath.empty())
                        {
                            // save which characters were present at level start
                            if(SwapCharAllowed())
                            {
                                pLogDebug("Save drop/add characters configuration at WorldLoop()");
                                ConnectScreen::SaveChars();
                            }

                            StartWarp = lvl.StartWarp;
                            StopMusic();
                            PlaySound(SFX_LevelSelect);

                            // NOTE: this is TheXTech's timing. For TAS Mode 3: SMBX 1.3's timing waits 33 fewer frames (33 * 15.6 fewer ms).
                            int GameThingTicks = 1000;

                            if(g_config.EnableInterLevelFade)
                            {
                                g_worldScreenFader.setupFader(2, 0, 65, ScreenFader::S_RECT,
                                                              true,
                                                              getWorldPlayerCenterX(), getWorldPlayerCenterY(), l_screen->vScreen_refs[0]);
                                worldWaitForFade();
                            }
                            else
                                GameThingTicks += (33 * 156 / 10);

                            SoundPause[SFX_Slide] = 200;
                            curWorldLevel = t;
                            LevelSelect = false;

                            delayedMusicReset(); // Reset delayed music to prevent unexpected behaviour at loaded level

                            ClearLevel();

                            if(!OpenLevel(levelPath))
                            {
                                delayedMusicStart(); // Allow music being started
                                ReportLoadFailure(lvl.FileName);
                                ErrorQuit = true;
                            }

                            GameThing(GameThingTicks, 3);

                            break;
                        }
                        else
                        {
                            pLogWarning("Level file name \"%s\" at %d x %d (id=%d) was not found (directory %s)",
                                        lvl.FileName.c_str(),
                                        (int)lvl.Location.X,
                                        (int)lvl.Location.Y,
                                        lvl.Type,
                                        g_dirEpisode.getCurDir().c_str()
                            );
                        }
                    }
                    else if(lvl.WarpX != -1 || lvl.WarpY != -1)
                    {
                        musicReset = true;
                        StopMusic();
                        PlaySound(SFX_Warp);
//                        frmMain.setTargetTexture();
//                        frmMain.clearBuffer();
//                        frmMain.repaint();
//                        DoEvents();
//                        PGE_Delay(1000);
                        if(g_config.EnableInterLevelFade)
                        {
                            g_worldScreenFader.setupFader(3, 0, 65, ScreenFader::S_RECT,
                                                          true,
                                                          getWorldPlayerCenterX(), getWorldPlayerCenterY(), l_screen->vScreen_refs[0]);
                            worldWaitForFade(65);
                        }
                        else
                            worldWaitForFade(65);

                        // Moved from above
                        if(lvl.WarpX != -1)
                            WorldPlayer[1].Location.X = lvl.WarpX;
                        if(lvl.WarpY != -1)
                            WorldPlayer[1].Location.Y = lvl.WarpY;

                        worldResetSection();

                        LevelBeatCode = BEATCODE_WARP;

                        //for(B = 1; B <= numWorldLevels; B++)
                        for(WorldLevelRef_t t2 : treeWorldLevelQuery(WorldPlayer[1].Location, SORTMODE_ID))
                        {
                            WorldLevel_t &level2 = *t2;
                            if(CheckCollision(WorldPlayer[1].Location, level2.Location))
                            {
                                level2.Active = true;
                                curWorldLevel = t2;
                            }
                        }
                        // -----------------------

                        if(g_config.EnableInterLevelFade)
                        {
                            g_worldScreenFader.setupFader(3, 65, 0, ScreenFader::S_RECT,
                                                          true,
                                                          getWorldPlayerCenterX(), getWorldPlayerCenterY(), l_screen->vScreen_refs[0]);
                        }
//                        resetFrameTimer();
                    }
                }
            }
        }
        // else

        if(WorldPlayer[1].Move3 && WorldPlayer[1].Move == 0)
        {
            if(g_config.world_map_fast_move)
                PlayerPath(WorldPlayer[1]);

            if(WorldPlayer[1].Move == 0)
            {
                WorldPlayer[1].Move3 = false;
                PlaySound(SFX_Slide);
            }
        }

        if(WorldPlayer[1].Move == 0)
        {
            if(WorldPlayer[1].Frame == 5)
                WorldPlayer[1].Frame = 4;
            if(WorldPlayer[1].Frame == 3)
                WorldPlayer[1].Frame = 2;
        }

//        if(WorldPlayer[1].Move3 && WorldPlayer[1].Move == 0)
//        {
//            WorldPlayer[1].Move3 = false;
//            PlaySound(SFX_Slide);
//        }
        WorldPlayer[1].LastMove = 0;

        worldCheckSection(WorldPlayer[1]);

        if(s_worldUpdateMusic(WorldPlayer[1].Location))
            musicReset = false;

        if(musicReset) // Resume the last playing music after teleportation
        {
            StartMusic(curWorldMusic);
            // musicReset = false;
        }

        if(delayMusicIsSet())
            delayedMusicStart();
    }
    else if(WorldPlayer[1].Move == 1)
    {
        WorldPlayer[1].Move2 += 2;
        WorldPlayer[1].Location.Y -= 2;

        if(WalkAnywhere || g_config.world_map_fast_move)
        {
            WorldPlayer[1].Move2 += 2;
            WorldPlayer[1].Location.Y -= 2;
        }

        if(WorldPlayer[1].Move2 >= 32)
        {
            WorldPlayer[1].LastMove = WorldPlayer[1].Move;
            WorldPlayer[1].Move2 = 0;
            WorldPlayer[1].Move = 0;
            WorldPlayer[1].Move3 = true;
        }
    }
    else if(WorldPlayer[1].Move == 2)
    {
        WorldPlayer[1].Move2 += 2;
        WorldPlayer[1].Location.X -= 2;

        if(WalkAnywhere || g_config.world_map_fast_move)
        {
            WorldPlayer[1].Move2 += 2;
            WorldPlayer[1].Location.X -= 2;
        }

        if(WorldPlayer[1].Move2 >= 32)
        {
            WorldPlayer[1].LastMove = WorldPlayer[1].Move;
            WorldPlayer[1].Move2 = 0;
            WorldPlayer[1].Move = 0;
            WorldPlayer[1].Move3 = true;
        }
    }
    else if(WorldPlayer[1].Move == 3)
    {
        WorldPlayer[1].Move2 += 2;
        WorldPlayer[1].Location.Y += 2;

        if(WalkAnywhere || g_config.world_map_fast_move)
        {
            WorldPlayer[1].Move2 += 2;
            WorldPlayer[1].Location.Y += 2;
        }

        if(WorldPlayer[1].Move2 >= 32)
        {
            WorldPlayer[1].LastMove = WorldPlayer[1].Move;
            WorldPlayer[1].Move2 = 0;
            WorldPlayer[1].Move = 0;
            WorldPlayer[1].Move3 = true;
        }
    }
    else if(WorldPlayer[1].Move == 4)
    {
        WorldPlayer[1].Move2 += 2;
        WorldPlayer[1].Location.X += 2;

        if(WalkAnywhere || g_config.world_map_fast_move)
        {
            WorldPlayer[1].Move2 += 2;
            WorldPlayer[1].Location.X += 2;
        }

        if(WorldPlayer[1].Move2 >= 32)
        {
            WorldPlayer[1].LastMove = WorldPlayer[1].Move;
            WorldPlayer[1].Move2 = 0;
            WorldPlayer[1].Move = 0;
            WorldPlayer[1].Move3 = true;
        }
    }
}

void LevelPath(const WorldLevel_t &Lvl, int Direction, bool Skp)
{
    TinyLocation_t tempLocation;
//    int A = 0;

    bool hit = false;

    // Up
    if(Direction == 1 || Direction == 5)
    {
        tempLocation = Lvl.Location;
        tempLocation.X +=  4;
        tempLocation.Y +=  4;
        tempLocation.Width -= 8;
        tempLocation.Height -=  8;
        tempLocation.Y -= 32;

        //for(A = 1; A <= numWorldPaths; A++)
        for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_NONE))
        {
            WorldPath_t &path = *t;
            if(!path.Active)
            {
                if(CheckCollision(tempLocation, path.Location))
                {
                    PathPath(path, Skp);
                    hit = true;
                    // move camera quickly for path branch switch
                    if(g_worldCamSpeed < 4 && !Skp)
                        g_worldCamSpeed = 4;
                }
            }
        }
    }

    // Left
    if(Direction == 2 || Direction == 5)
    {
        tempLocation = Lvl.Location;
        tempLocation.X += 4;
        tempLocation.Y += 4;
        tempLocation.Width -= 8;
        tempLocation.Height -= 8;
        tempLocation.X -= 32;

        //for(A = 1; A <= numWorldPaths; A++)
        for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_NONE))
        {
            WorldPath_t &path = *t;
            if(!path.Active)
            {
                if(CheckCollision(tempLocation, path.Location))
                {
                    PathPath(path, Skp);
                    hit = true;
                    // move camera quickly for path branch switch
                    if(g_worldCamSpeed < 4 && !Skp)
                        g_worldCamSpeed = 4;
                }
            }
        }
    }

    // Down
    if(Direction == 3 || Direction == 5)
    {
        tempLocation = Lvl.Location;
        tempLocation.X += 4;
        tempLocation.Y += 4;
        tempLocation.Width -= 8;
        tempLocation.Height -= 8;
        tempLocation.Y += 32;

        //for(A = 1; A <= numWorldPaths; A++)
        for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_NONE))
        {
            WorldPath_t &path = *t;
            if(!path.Active)
            {
                if(CheckCollision(tempLocation, path.Location))
                {
                    PathPath(path, Skp);
                    hit = true;
                    // move camera quickly for path branch switch
                    if(g_worldCamSpeed < 4 && !Skp)
                        g_worldCamSpeed = 4;
                }
            }
        }
    }

    // Right
    if(Direction == 4 || Direction == 5)
    {
        tempLocation = Lvl.Location;
        tempLocation.X += 4;
        tempLocation.Y += 4;
        tempLocation.Width -= 8;
        tempLocation.Height -= 8;
        tempLocation.X += 32;

        //for(A = 1; A <= numWorldPaths; A++)
        for(auto t : treeWorldPathQuery(tempLocation, SORTMODE_NONE))
        {
            WorldPath_t &path = *t;
            if(!path.Active)
            {
                if(CheckCollision(tempLocation, path.Location))
                {
                    PathPath(path, Skp);
                    hit = true;
                    // move camera quickly for path branch switch
                    if(g_worldCamSpeed < 4 && !Skp)
                        g_worldCamSpeed = 4;
                }
            }
        }
    }

    // quickly return to player
    if(g_config.EnableInterLevelFade && hit && !Skp)
    {
        qScreen = true;

        const int Z = l_screen->vScreen_refs[0];
        qScreenLoc[Z] = vScreen[Z];

        if(g_worldCamSpeed < 8)
            g_worldCamSpeed = 8;
    }
}

void PlayerPath(WorldPlayer_t &p)
{
    if(p.LevelIndex)
        return;

    TinyLocation_t tempLocation = p.Location;

    tempLocation.X += 4;
    tempLocation.Y += 4;
    tempLocation.Width -= 8;
    tempLocation.Height -= 8;

    // stop at level
    for(auto t : treeWorldLevelQuery(tempLocation, false))
    {
        WorldLevel_t& lvl = *t;
        if(CheckCollision(tempLocation, lvl.Location) && lvl.Active)
        {
            p.Move = 0;
            return;
        }
    }

    // stop at branch point
    int n_moves = 0;
    for(int B = 1; B <= 4; B++)
    {
        if(B == 1)
            tempLocation.Y -= 32; // Up
        else if(B == 2)
        {
            tempLocation.Y += 32; // Down
            tempLocation.X -= 32; // Left
        }
        else if(B == 3)
        {
            tempLocation.X += 32; // Right
            tempLocation.Y += 32; // Down
        }
        else if(B == 4)
        {
            tempLocation.Y -= 32; // Up
            tempLocation.X += 32; // Right
        }

        // don't consider the backwards path
        if(B != p.LastMove && B % 2 == p.LastMove % 2)
            continue;

        for(auto t : treeWorldPathQuery(tempLocation, false))
        {
            WorldPath_t& path = *t;
            if(CheckCollision(tempLocation, path.Location) && path.Active)
            {
                p.Move = B;
                n_moves ++;
                break;
            }
        }

        if(p.Move == B)
            continue;

        for(auto t : treeWorldLevelQuery(tempLocation, false))
        {
            WorldLevel_t& lvl = *t;
            if(CheckCollision(tempLocation, lvl.Location) && lvl.Active)
            {
                p.Move = B;
                n_moves ++;
                break;
            }
        }
    }

    if(n_moves > 1)
        p.Move = 0;
}

void PathPath(WorldPath_t &Pth, bool Skp)
{
    const int Z = l_screen->vScreen_refs[0];

    //int A = 0;
    int B = 0;

    TinyLocation_t tempLocation;
    tempLocation = Pth.Location;
    tempLocation.X += 4;
    tempLocation.Y += 4;
    tempLocation.Width -= 8;
    tempLocation.Height -= 8;

    //for(A = 1; A <= numScenes; A++)
    for(auto t : treeWorldSceneQuery(tempLocation, SORTMODE_ID))
    {
        Scene_t &scene = *t;
        if(scene.Active)
        {
            if(CheckCollision(tempLocation, scene.Location))
                scene.Active = false;
        }
    }

    if(!Pth.Active && !Skp)
    {
        Pth.Active = true;

        // set a temporary vScreen focus
        vScreen[Z].tempX = Pth.Location.X + Pth.Location.Width / 2;
        vScreen[Z].TempY = Pth.Location.Y + Pth.Location.Height / 2;
        vScreen[Z].TempDelay = 1;

        // update section (no cam sound)
        s_worldCheckSection(WorldPlayer[1], Pth.Location);
        g_worldPlayCamSound = false;

        // force qScreen in modern mode
        if(g_config.EnableInterLevelFade)
        {
            qScreen = true;
            qScreenLoc[Z] = vScreen[Z];
        }
        // fully disable otherwise
        else
        {
            qScreen = false;
        }

        PlaySound(SFX_NewPath);
        PathWait();
    }

    Pth.Active = true;

    for(B = 1; B <= 4; B++)
    {
        if(B == 1)
            tempLocation.Y -= 32; // Up
        else if(B == 2)
        {
            tempLocation.Y += 32; // Down
            tempLocation.X -= 32; // Left
        }
        else if(B == 3)
        {
            tempLocation.X += 32; // Right
            tempLocation.Y += 32; // Down
        }
        else if(B == 4)
        {
            tempLocation.Y -= 32; // Up
            tempLocation.X += 32; // Right
        }

        //for(A = 1; A <= numWorldPaths; A++)
        WorldPath_t* found = nullptr;
        for(WorldPath_t *path : treeWorldPathQuery(tempLocation, SORTMODE_ID))
        {
            D_pLogDebug("Found path activity: %d", (int)path->Active);
            if(!path->Active)
            {
                D_pLogDebugNA("Collision with path...");
                if(CheckCollision(tempLocation, path->Location))
                {
                    D_pLogDebugNA("Collision with path FOUND...");
                    found = path;
                    break;
                }
            }
        }

        if(found)
            PathPath(*found, Skp);


        //for(A = 1; A <= numWorldLevels; A++)
        for(auto t : treeWorldLevelQuery(tempLocation, SORTMODE_ID))
        {
            WorldLevel_t &lev = *t;
            D_pLogDebug("Found level activity: %d", (int)lev.Active);
            if(!lev.Active)
            {
                D_pLogDebugNA("Collision with level...");
                if(CheckCollision(tempLocation, lev.Location))
                {
                    D_pLogDebugNA("Collision with level FOUND...");
                    lev.Active = true;
                    if(!Skp)
                    {
                        // set a temporary vScreen focus
                        vScreen[Z].tempX = lev.Location.X + lev.Location.Width / 2;
                        vScreen[Z].TempY = lev.Location.Y + lev.Location.Height / 2;
                        vScreen[Z].TempDelay = 1;

                        // update world map section (no cam sound)
                        s_worldCheckSection(WorldPlayer[1], lev.Location);
                        g_worldPlayCamSound = false;

                        // force qScreen in modern mode
                        if(g_config.EnableInterLevelFade)
                        {
                            qScreen = true;
                            qScreenLoc[Z] = vScreen[Z];
                        }
                        // fully disable it otherwise
                        else
                        {
                            qScreen = false;
                        }

                        PlaySound(SFX_NewPath);
                        PathWait();
                    }
                }
            }
        }
    }
}

void PathWait()
{
    int C = 0;

    resetFrameTimer();

    do
    {
        XEvents::doEvents();
        if(canProceedFrame())
        {
            Controls::Update(false);
            speedRun_tick();
            UpdateGraphics2();
            UpdateSound();
            g_worldScreenFader.update();

            if(delayMusicIsSet())
                delayedMusicStart();

            C++;
            computeFrameTime1();
            XEvents::doEvents();
            computeFrameTime2();
        }

        if(!g_config.unlimited_framerate)
            PGE_Delay(1);
    } while(C < 24);

    resetFrameTimer();
}


================================================
FILE: src/main.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <ctime>
#include "sdl_proxy/sdl_head.h"

#include "../version.h"

#include "game_main.h"
#include "frm_main.h"
#include "gfx.h"
#include "rand.h"
#include "sound.h"
#include "main/game_info.h"
#include "main/speedrunner.h"
#include "main/game_info.h"
#include "main/asset_pack.h"
#include "main/translate.h"
#include "core/language.h"
#include "config.h"
#include "controls.h"
#include <AppPath/app_path.h>

#ifdef THEXTECH_INTERPROC_SUPPORTED
#   include "capabilities.h"
#endif

#ifdef THEXTECH_ENABLE_SDL_NET
#   include "main/client_methods.h"
#endif

#ifndef THEXTECH_NO_ARGV_HANDLING
#   include <tclap/CmdLine.h>
#endif

#include <Integrator/integrator.h>
#include <Utils/strings.h>
#include <Utils/files.h>
#include <Archives/archives.h>

#ifdef THEXTECH_CRASHHANDLER_SUPPORTED
#   include <CrashHandler/crash_handler.h>
#endif

#if defined(_WIN32) || defined(_WIN64)
#include <SDL2/SDL_main.h>
#endif

#ifdef VITA
#include "core/vita/vita_memory.h"
#endif

#ifdef __16M__
#include <nds.h>
#endif

#ifdef __CALICO__
#define main _entry_point
#endif

#ifdef __WII__
#include <gccore.h>
#endif

#ifdef __WIIU__
#include <coreinit/title.h>
#include <coreinit/systeminfo.h>
#include <sysapp/launch.h>
#   define HBL_TITLE_ID             (0x0005000013374842)
#   define MII_MAKER_JPN_TITLE_ID   (0x000500101004A000)
#   define MII_MAKER_USA_TITLE_ID   (0x000500101004A100)
#   define MII_MAKER_EUR_TITLE_ID   (0x000500101004A200)
#endif

#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif

#ifdef ENABLE_XTECH_LUA
#include "xtech_lua_main.h"
#endif

#ifdef __APPLE__
#include <SDL2/SDL.h>
#include <SDL2/SDL_events.h>
#include <Utils/files.h>
#include <Logger/logger.h>

static std::string g_fileToOpen;
/**
 * @brief Receive an opened file from the Finder (Must be created at least one window!)
 */
static void macosReceiveOpenFile()
{
    if(g_fileToOpen.empty())
    {
        pLogDebug("Attempt to take Finder args...");
        SDL_EventState(SDL_DROPFILE, SDL_ENABLE);
        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
            if(event.type == SDL_DROPFILE)
            {
                std::string file(event.drop.file);
                if(Files::fileExists(file))
                {
                    g_fileToOpen = file;
                    pLogDebug("Got file path: [%s]", file.c_str());
                }
                else
                    pLogWarning("Invalid file path, sent by Mac OS X Finder event: [%s]", file.c_str());
            }
        }
        SDL_EventState(SDL_DROPFILE, SDL_DISABLE);
    }
}
#endif

#ifdef __3DS__
#include <3ds.h>
#include <malloc.h>
int n3ds_clocked = 0; // eventually move elsewhere

void InitClockSpeed()
{
    bool isN3DS;

    APT_CheckNew3DS(&isN3DS);

    if(!isN3DS)
        n3ds_clocked = -1;

    // I've made this configurable.
    // if(isN3DS) // make this configurable...
    // {
    //     SwapClockSpeed();
    //     printf("N3DS clock enabled\n");
    // }
}

void SwapClockSpeed()
{
    if(n3ds_clocked == -1)
        return;

    n3ds_clocked = !n3ds_clocked;
    osSetSpeedupEnable(n3ds_clocked);
}

#endif

#ifndef THEXTECH_NO_ARGV_HANDLING
static void strToPlayerSetup(int player, const std::string &setupString)
{
    if(setupString.empty())
        return; // Do nothing

    std::vector<std::string> keys;

    auto &p = testPlayer[player];
    bool hasHealth = false;

    Strings::split(keys, setupString, ";");
    for(auto &k : keys)
    {
        if(k.empty())
            continue;
        if(k[0] == 'c') // Character
            p.Character = int(SDL_strtol(k.substr(1).c_str(), nullptr, 10));
        else if(k[0] == 's') // State
            p.State = int(SDL_strtol(k.substr(1).c_str(), nullptr, 10));
        else if(k[0] == 'm') // Mounts
            p.Mount = int(SDL_strtol(k.substr(1).c_str(), nullptr, 10));
        else if(k[0] == 't') // Mount types
            p.MountType = int(SDL_strtol(k.substr(1).c_str(), nullptr, 10));
        else if(k[0] == 'h') // Health level
        {
            p.Hearts = int(SDL_strtol(k.substr(1).c_str(), nullptr, 10));
            hasHealth = true;
        }
        else if(k[0] == 'r') // Reserved NPC-ID
            p.HeldBonus = NPCID(SDL_strtol(k.substr(1).c_str(), nullptr, 10));
    }

    if(p.Character < 1)
        p.Character = 1;
    else if(p.Character > numCharacters)
        p.Character = numCharacters;

    if(p.State < 1)
        p.State = 1;
    else if(p.State >= numStates)
        p.State = numStates;

    if(p.HeldBonus > maxNPCType)
        p.HeldBonus = NPCID_NULL;

    if(hasHealth)
    {
        if(p.Hearts <= 1 && p.State == 2)
            p.Hearts = 2;

        if(p.Hearts > 3)
            p.Hearts = 3;
    }
    else if(p.Character >= 3 && p.State > 2)
        p.Hearts = 3; // Ensure the health is 3 when any state is bigger than 2 is assigned
    else
        p.Hearts = 0;


    switch(p.Mount)
    {
    default:
    case 0:
        p.Mount = 0;
        p.MountType = 0;
        break; // Rejected aliens
    case 1: case 2: case 3:
        break; // Allowed
    }

    switch(p.Mount)
    {
    case 1:
        if((p.MountType < 1) || (p.MountType > 3)) // Socks
            p.MountType = 1;
        break;
    default:
        break;
    case 3:
        if((p.MountType < 1) || (p.MountType > 8)) // Cat Llamas
            p.MountType = 1;
        break;
    }
}
#endif

#if defined(SDL_MAIN_NEEDED) || defined(__16M__)
extern "C"
#endif
int main(int argc, char**argv)
{
#ifdef __16M__
    // install the default exception handler
    defaultExceptionHandler();

    videoSetModeSub(MODE_0_2D);
    vramSetBankH(VRAM_H_SUB_BG);
    vramSetBankI(VRAM_I_SUB_BG_0x06208000);

#ifdef __BLOCKS__
    // give ourselves an extra 32kb of stack space -- thanks @AntonioND!
    reduceHeapSize(0x8000);

    const int DEFAULT_CONSOLE_MAP_BASE = 22;
    const int DEFAULT_CONSOLE_GFX_BASE = 3;
    const int DEFAULT_CONSOLE_BG_LAYER = 0;
    consoleInit(nullptr, DEFAULT_CONSOLE_BG_LAYER, BgType_Text4bpp, BgSize_T_256x256, DEFAULT_CONSOLE_MAP_BASE, DEFAULT_CONSOLE_GFX_BASE, false, true);
#else
    const PrintConsole* defaultConsole = consoleGetDefault();
    consoleInit(nullptr, defaultConsole->bgLayer, BgType_Text4bpp, BgSize_T_256x256, defaultConsole->mapBase, defaultConsole->gfxBase, false, true);
#endif

    printf("Hello, 16MB world!\n");
#endif

#ifdef __WII__
    VIDEO_Init();
    VIDEO_SetBlack(TRUE);
#endif

#ifdef __WIIU__
    g_isHBLauncher = false;
    uint64_t titleID = OSGetTitleID();

    if(titleID == HBL_TITLE_ID ||
       titleID == MII_MAKER_JPN_TITLE_ID ||
       titleID == MII_MAKER_USA_TITLE_ID ||
       titleID == MII_MAKER_EUR_TITLE_ID)
    {
        // Important: OSEnableHomeButtonMenu must be called before ProcUIInitEx.
        OSEnableHomeButtonMenu(FALSE);
        g_isHBLauncher = true;
    }
#endif

    CmdLineSetup_t setup;

#if defined(__APPLE__) && defined(USE_APPLE_X11)
    char *x11_display_env = getenv("DISPLAY");
    if(!x11_display_env || x11_display_env[0] == '\0')
        setenv("DISPLAY", ":0", 1); // Automatically set the display to :0 if not defined
#endif

#ifdef THEXTECH_CRASHHANDLER_SUPPORTED
    CrashHandler::initSigs();
#endif

#ifdef __3DS__
    InitClockSpeed();
    SwapClockSpeed();

#   ifdef THEXTECH_ENABLE_SDL_NET
    // spend 256kb on a buffer
    uint32_t* socket_buffer = (uint32_t*)memalign(0x1000, 0x40000);
    socInit(socket_buffer, 0x40000);
#   endif
#endif

    seedRandom(std::time(NULL));

    testPlayer.fill(Player_t());
    for(int i = 1; i <= maxLocalPlayers; i++)
    {
        testPlayer[i].Character = i;
    }

#ifndef THEXTECH_NO_ARGV_HANDLING
    try
    {
        // Define the command line object.
        TCLAP::CmdLine  cmd("TheXTech Engine\n"
                            "Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>\n\n"
                            "This program is distributed under the GPLv3 license\n\n", ' ', V_LATEST_STABLE " [" V_BUILD_BRANCH ", #" V_BUILD_VER "]");

        TCLAP::ValueArg<std::string> customAssetsPath("c", "asset-pack", "Specify the different assets pack name or directory to play",
                                                      false, "",
                                                      "string or directory path",
                                                      cmd);

        TCLAP::ValueArg<std::string> customUserDirectory("u", "user-directory", "Specify the different writable user directory to store settings, gamesaves, logs, screenshots, etc.",
                                                         false, "",
                                                         "directory path",
                                                         cmd);

        TCLAP::ValueArg<std::string> customGameDirName(std::string(), "game-dirname",
                                                       "Specify the game directory name for default locations (ignored if user-directory is specified)",
                                                       false, "",
                                                       "directory name",
                                                       cmd);


        TCLAP::SwitchArg switchFrameSkip("f", "frameskip", "Enable frame skipping mode", false);
        TCLAP::SwitchArg switchDisableFrameSkip(std::string(), "no-frameskip", "Disable frame skipping mode", false);
        TCLAP::SwitchArg switchNoSound("s", "no-sound", "Disable sound", false);
        TCLAP::SwitchArg switchNoPause("p", "never-pause", "Never pause game when window losts a focus", false);
        TCLAP::SwitchArg switchBgInput(std::string(), "bg-input", "Allow background input for joysticks", false);
        TCLAP::SwitchArg switchVSync(std::string(), "vsync", "Limit the framerate to the screen refresh rate", false);
        TCLAP::ValueArg<std::string> renderType("r", "render", "Sets the graphics mode:\n"
                                                "  sw - software SDL2 render (fallback)\n"
                                                "  hw - generic hardware accelerated render (currently SDL2) [Default]\n"
                                                "  vsync - generic hardware accelerated render with vSync [deprecated]\n"
                                                "  sdl - hardware accelerated SDL2 render\n"
#   ifdef THEXTECH_BUILD_GL_DESKTOP_MODERN
                                                "  opengl - hardware accelerated OpenGL 2.1+ render\n"
#   endif
#   ifdef THEXTECH_BUILD_GL_ES_MODERN
                                                "  opengles - hardware accelerated OpenGL ES (mobile) 2.0+ render\n"
#   endif
#   ifdef THEXTECH_BUILD_GL_DESKTOP_LEGACY
                                                "  opengl11 - hardware accelerated OpenGL 1.1-2.0 render (legacy)\n"
#   endif
#   ifdef THEXTECH_BUILD_GL_ES_LEGACY
                                                "  opengles11 - hardware accelerated OpenGL ES 1.1 render (legacy)"
#   endif
                                                ,
                                                false, "",
                                                "render type",
                                                cmd);

        TCLAP::ValueArg<std::string> testLevel("l", "leveltest", "Start a level test of a given level file.\n"
                                                "[OBSOLETE OPTION]: now you able to specify the file path without -l or --leveltest argument.",
                                                false, "",
                                                "file path",
                                                cmd);

        TCLAP::ValueArg<unsigned int> numPlayers("n", "num-players", "Count of players",
                                                    false, 1u,
                                                   "number 1 or 2",
                                                   cmd);

        TCLAP::ValueArg<unsigned int> startWarp("w", "start-warp", "Warp index to start level test at",
                                                    false, 0u,
                                                   "start warp index",
                                                   cmd);

        TCLAP::SwitchArg switchBattleMode("b", "battle", "Test level in battle mode", false);

        TCLAP::ValueArg<std::string> playerCharacter1("1",
                                                      "player1",
                                                      "Setup of playable character for player 1:\n"
                                                      "  Semicolon separated key-argument values:\n"
                                                      "  c - character, s - state, m - mount, t - mount type, h - health, r - reserved NPC-ID.\n\n"
                                                      "Example:\n"
                                                      "  c1;s2;m3;t0;r10;h2 - Character as 1, State as 2, Mount as 3, M.Type as 0",
                                                      false, "",
                                                      "c1;s2;m0;t0;r10;h2",
                                                      cmd);

        TCLAP::ValueArg<std::string> playerCharacter2("2",
                                                      "player2",
                                                      "Setup of playable character for player 2:\n"
                                                      "  Semicolon separated key-argument values:\n"
                                                      "  c - character, s - state, m - mount, t - mount type.\n\n"
                                                      "Example:\n"
                                                      "  c1;s2;m3;t0;r10;h2 - Character as 1, State as 2, Mount as 3, M.Type as 0",
                                                      false, "",
                                                      "c1;s2;m0;t0;r10;h2",
                                                      cmd);

        TCLAP::SwitchArg switchTestGodMode("g", "god-mode", "Enable god mode in level testing", false);
        TCLAP::SwitchArg switchTestGrabAll("a", "grab-all", "Enable ability to grab everything while level testing", false);
        TCLAP::SwitchArg switchTestShowFPS("m", "show-fps", "Show FPS counter on the screen", false);
        TCLAP::SwitchArg switchTestMaxFPS("x", "max-fps", "Run FPS as fast as possible", false);
        TCLAP::SwitchArg switchTestMagicHand("k", "magic-hand", "Enable magic hand functionality while level test running", false);
        TCLAP::SwitchArg switchTestEditor("e", "editor", "Open level in the editor", false);
#ifdef THEXTECH_INTERPROC_SUPPORTED
        TCLAP::SwitchArg switchTestInterprocess("i", "interprocessing", "Enable an interprocessing mode with Editor", false);
        TCLAP::SwitchArg switchPrintCapabilities(std::string(), "capabilities", "Print the JSON string of this build's capabilities", false);
#endif

        TCLAP::ValueArg<std::string> compatLevel(std::string(), "compat-level",
                                                   "Enforce the specific gameplay compatibility level. Supported values:\n"
                                                   "  modern - TheXTech native, all features and fixes enabled [Default]\n"
                                                   "  classic - Disables all features and bugfixes except of crticial updates\n"
                                                   "  vanilla - Enforces the full compatibility with the SMBX 1.3 behaviour\n"
                                                   "\n"
                                                   "  Deprecated: acts as an alias for speed-run mode. Will be overridden if speed-run mode is set.",
                                                    false, "modern",
                                                   "modern, classic, vanilla",
                                                   cmd);
        TCLAP::ValueArg<unsigned int> speedRunMode(std::string(), "speed-run-mode",
                                                   "Enable the speed-runer mode: the playthrough timer will be shown, "
                                                   "and some gameplay limitations will be enabled. Supported values:\n"
                                                   "  0 - Disabled [Default]\n"
                                                   "  1 - TheXTech native\n"
                                                   "  2 - Disable time-winning updates (Classic mode)\n"
                                                   "  3 - Strict vanilla SMBX 1.3, enable all bugs",
                                                    false, 0u,
                                                   "0, 1, 2, or 3",
                                                   cmd);
        TCLAP::SwitchArg switchSpeedRunSemiTransparent(std::string(), "speed-run-semitransparent",
                                                       "Make the speed-runner mode timer be drawn transparently", false);
        TCLAP::ValueArg<std::string> speedRunBlinkMode(std::string(), "speed-run-blink-mode",
                                                   "Choose the speed-run timer blinking effect for a level/episode completion\n"
                                                   "Supported values:\n"
                                                   "  opaque - Blink effect works when semi-transparent mode is not enabled\n"
                                                   "  always - Blink effect will work always\n"
                                                   "  never - Disable blink effect completely",
                                                    false, "undefined",
                                                   "opaque, always, never",
                                                    cmd);
        TCLAP::SwitchArg switchDisplayControls(std::string(), "show-controls", "Display current controller state while the game process", false);
        TCLAP::ValueArg<unsigned int> showBatteryStatus(std::string(), "show-battery-status",
                                                   "Display the battery status indicator (if available):\n"
                                                   "  0 - Never show [Default]\n"
                                                   "  1 - Show on fullscreen only when battery low\n"
                                                   "  2 - Show when battery low\n"
                                                   "  3 - Show always on fullscreen only\n"
                                                   "  4 - Always show",
                                                    false, 0u,
                                                   "0, 1, 2, 3, or 4",
                                                   cmd);
        TCLAP::ValueArg<int> saveSlot(std::string(), "save-slot", "Save slot to use for world play", false, 0, std::string("number from 1 to ") + std::to_string(maxSaveSlots), cmd);

#ifndef THEXTECH_DISABLE_LANG_TOOLS
        TCLAP::SwitchArg switchMakeLangTemplate(std::string(), "export-lang", "Exports the default language template", false);
        TCLAP::SwitchArg switchLangUpdate(std::string(), "lang-update", "Updated all language of assets package: missing lines will be added", false);
        TCLAP::SwitchArg switchLangNoBlank(std::string(), "lang-no-blank", "Don't put blank lines into translation files", false);
        TCLAP::ValueArg<std::string> langOutputPath(std::string(), "lang-output",
                                                    "Path to the languages directory that needs to be updated (by default, the in-assets directory is used)",
                                                    false, std::string(),
                                                    "path to directory");
#endif
        TCLAP::ValueArg<std::string> lang(std::string(), "lang", "Set the engine's language by code", false, "", "en, ru, zh-cn, etc.");

        TCLAP::SwitchArg switchVerboseLog(std::string(), "verbose", "Enable log output into the terminal", false);

        TCLAP::UnlabeledMultiArg<std::string> inputFileNames("levelpath", "Path to level file or replay data to run the test", false, std::string(), "path to file");

#ifdef THEXTECH_ENABLE_SDL_NET
        TCLAP::ValueArg<std::string> server(std::string(), "server", "Server address", false, "", "");
        cmd.add(&server);

        TCLAP::ValueArg<std::string> room_key(std::string(), "room-key", "Room key", false, "", "");
        cmd.add(&room_key);
#endif

        cmd.add(&switchFrameSkip);
        cmd.add(&switchDisableFrameSkip);
        cmd.add(&switchNoSound);
        cmd.add(&switchNoPause);
        cmd.add(&switchBgInput);
        cmd.add(&switchVSync);
        cmd.add(&switchBattleMode);

        cmd.add(&switchTestGodMode);
        cmd.add(&switchTestGrabAll);
        cmd.add(&switchTestShowFPS);
        cmd.add(&switchTestMaxFPS);
        cmd.add(&switchTestMagicHand);
        cmd.add(&switchTestEditor);
#ifdef THEXTECH_INTERPROC_SUPPORTED
        cmd.add(&switchTestInterprocess);
        cmd.add(&switchPrintCapabilities);
#endif
        cmd.add(&switchVerboseLog);
        cmd.add(&switchSpeedRunSemiTransparent);
        cmd.add(&switchDisplayControls);
#ifndef THEXTECH_DISABLE_LANG_TOOLS
        cmd.add(&switchMakeLangTemplate);
        cmd.add(&switchLangUpdate);
        cmd.add(&switchLangNoBlank);
        cmd.add(&langOutputPath);
#endif
        cmd.add(&lang);
        cmd.add(&inputFileNames);

        cmd.parse(argc, argv);

        // Initialize the assets and user paths
        {
            setup.assetPack = customAssetsPath.getValue();
            std::string customUserDir = customUserDirectory.getValue();
            std::string customGameDir = customGameDirName.getValue();

            if(!setup.assetPack.empty())
                AppPathManager::addAssetsRoot(setup.assetPack);

            if(!customUserDir.empty())
                AppPathManager::setUserDirectory(customUserDir);

            if(!customGameDir.empty())
                AppPathManager::setGameDirName(customGameDir);

            AppPathManager::initAppPath();
        }

#ifdef THEXTECH_INTERPROC_SUPPORTED
        if(switchPrintCapabilities.isSet() && switchPrintCapabilities.getValue())
        {
            std::fprintf(stdout, "%s\n", g_capabilities);
            std::fflush(stdout);
            return 0;
        }
#endif

        OpenConfig();


#ifndef THEXTECH_DISABLE_LANG_TOOLS
        // Print the language template to the screen
        if(switchMakeLangTemplate.isSet() && switchMakeLangTemplate.getValue())
        {
            // Locate asset pack. The `true` here indicates to skip actually loading UI GFX.
            if(!InitUIAssetsFrom(setup.assetPack, true))
                return 1;

            printf("== Language template for [%s] ==\n", AppPath.c_str());

            initGameInfo();

            XTechTranslate translate;
            translate.reset();
            translate.exportTemplate();
            return 0;
        }

        // Update all translation files at current assets pack
        if(switchLangUpdate.isSet() && switchLangUpdate.getValue())
        {
            // Locate asset pack. The `true` here indicates to skip actually loading UI GFX.
            if(!InitUIAssetsFrom(setup.assetPack, true))
                return 1;

            printf("== Updating language files at [%s] ==\n", AppPath.c_str());

            initGameInfo();

            XTechTranslate translate;
            translate.reset();
            translate.updateLanguages(langOutputPath.getValue(), switchLangNoBlank.isSet());
            return 0;
        }
#endif

        // Store all of the command-line config options
        ConfigChangeSentinel sent(ConfigSetLevel::cmdline);

        if(compatLevel.isSet() && !speedRunMode.isSet())
        {
            std::string compatModeVal = compatLevel.getValue();
            if(compatModeVal == "classic" || compatModeVal == "smbx2")
                g_config.speedrun_mode = 2;
            else if(compatModeVal == "smbx13" || compatModeVal == "vanilla")
                g_config.speedrun_mode = 3;
            else if(compatModeVal == "modern")
                g_config.speedrun_mode = 1;
            else
            {
                std::cerr << "Error: Invalid value for the --compat-level argument: " << compatModeVal << std::endl;
                std::cerr.flush();
                return 2;
            }
        }

        if(speedRunMode.isSet())
            g_config.speedrun_mode = speedRunMode.getValue();

        if(speedRunBlinkMode.isSet())
        {
            bool is_transparent = false;
            if(switchSpeedRunSemiTransparent.isSet())
                is_transparent = switchSpeedRunSemiTransparent.getValue();

            std::string mode = speedRunBlinkMode.getValue();
            if(mode == "always")
                g_config.show_playtime_counter = Config_t::PLAYTIME_COUNTER_ANIMATED;
            else if(is_transparent)
                g_config.show_playtime_counter = Config_t::PLAYTIME_COUNTER_SUBTLE;
            else if(mode == "opaque")
                g_config.show_playtime_counter = Config_t::PLAYTIME_COUNTER_ANIMATED;
            else if(mode == "never")
                g_config.show_playtime_counter = Config_t::PLAYTIME_COUNTER_OPAQUE;
            else
            {
                std::cerr << "Error: Invalid value for the --speed-run-blink argument: " << mode << std::endl;
                std::cerr.flush();
                return 2;
            }
        }
        else if(switchSpeedRunSemiTransparent.isSet())
        {
            if(switchSpeedRunSemiTransparent.getValue())
                g_config.show_playtime_counter = Config_t::PLAYTIME_COUNTER_SUBTLE;
            else
                g_config.show_playtime_counter = Config_t::PLAYTIME_COUNTER_ANIMATED;
        }

        if(switchTestShowFPS.isSet())
            g_config.show_fps = switchTestShowFPS.getValue();

        if(switchTestMaxFPS.isSet())
            g_config.unlimited_framerate = switchTestMaxFPS.getValue();

        if(switchDisplayControls.isSet())
            g_config.show_controllers = switchDisplayControls.getValue();

        if(showBatteryStatus.isSet() && IF_INRANGE(showBatteryStatus.getValue(), 1, 4))
            g_config.show_battery_status = showBatteryStatus.getValue();

        if(switchDisableFrameSkip.isSet())
            g_config.enable_frameskip = false;
        else if(switchFrameSkip.isSet())
            g_config.enable_frameskip = true;

#ifndef THEXTECH_NO_SDL_BUILD
        if(switchNoSound.isSet())
            g_config.audio_enable    = !switchNoSound.getValue();
#endif

        if(switchVSync.isSet())
            g_config.render_vsync    = switchVSync.getValue();

#ifndef NO_WINDOW_FOCUS_TRACKING
        if(switchNoPause.isSet())
            g_config.background_work = switchNoPause.getValue();

        if(switchBgInput.isSet())
            g_config.background_work = switchBgInput.getValue();
#endif // NO_WINDOW_FOCUS_TRACKING

#ifndef RENDER_CUSTOM
        if(renderType.isSet())
        {
            std::string rt = renderType.getValue();
            if(rt == "sw")
                g_config.render_mode = Config_t::RENDER_SOFTWARE;
            else if(rt == "vsync")
            {
                g_config.render_mode = Config_t::RENDER_ACCELERATED_AUTO;
                g_config.render_vsync = true;
            }
            else if(rt == "hw")
                g_config.render_mode = Config_t::RENDER_ACCELERATED_AUTO;
            else if(rt == "sdl")
                g_config.render_mode = Config_t::RENDER_ACCELERATED_SDL;
            else if(rt == "opengl")
                g_config.render_mode = Config_t::RENDER_ACCELERATED_OPENGL;
            else if(rt == "opengl11")
                g_config.render_mode = Config_t::RENDER_ACCELERATED_OPENGL_LEGACY;
            else if(rt == "opengles")
                g_config.render_mode = Config_t::RENDER_ACCELERATED_OPENGL_ES;
            else if(rt == "opengles11")
                g_config.render_mode = Config_t::RENDER_ACCELERATED_OPENGL_ES_LEGACY;
            else
            {
                std::cerr << "Error: Invalid value for the --render argument: " << rt << std::endl;
                std::cerr.flush();
                return 2;
            }
#   ifdef DEBUG_BUILD
            std::cerr << "Manually selected renderer: " << rt << " - " << g_config.render_mode << std::endl;
            std::cerr.flush();
#   endif
        }
#endif

        // store the game setup options

        setup.testLevel = testLevel.getValue();

        if(inputFileNames.isSet())
        {
            for(const auto &fpath : inputFileNames.getValue())
            {
                if(Files::hasSuffix(fpath, ".lvl") || Files::hasSuffix(fpath, ".lvlx"))
                    setup.testLevel = fpath;
                else if(Files::hasSuffix(fpath, ".wld") || Files::hasSuffix(fpath, ".wldx"))
                    setup.testLevel = fpath;
                else if(Files::hasSuffix(fpath, ".rec"))
                    setup.testReplay = fpath;

//                //TODO: Implement a world map running and testing
//                else if(Files::hasSuffix(fpath, ".wld") || Files::hasSuffix(fpath, ".wldx"))
//                {

//                }
            }
        }

        setup.verboseLogging = switchVerboseLog.getValue();
#ifdef THEXTECH_INTERPROC_SUPPORTED
        setup.interprocess = switchTestInterprocess.getValue();
#endif
        setup.testLevelMode = !setup.testLevel.empty() || setup.interprocess;
        setup.testNumPlayers = int(numPlayers.getValue());
        if(setup.testNumPlayers > 2)
            setup.testNumPlayers = 2;
        setup.testBattleMode = switchBattleMode.getValue();
        if(setup.testLevelMode)
        {
            strToPlayerSetup(1, playerCharacter1.getValue());
            strToPlayerSetup(2, playerCharacter2.getValue());
        }

        setup.testGodMode = switchTestGodMode.getValue();
        setup.testGrabAll = switchTestGrabAll.getValue();
        setup.testMagicHand = switchTestMagicHand.getValue();
        setup.testEditor = switchTestEditor.getValue();
        setup.testSave = saveSlot.getValue();

        if(startWarp.isSet() && startWarp.getValue() > 0 && startWarp.getValue() < maxWarps)
            testStartWarp = startWarp.getValue();

        if(lang.isSet())
            g_config.language = lang;

#ifdef THEXTECH_ENABLE_SDL_NET
        if(!setup.testLevel.empty() && server.isSet())
        {
            XMessage::Connect(server.getValue().c_str());

            uint32_t room_key_int = XMessage::RoomFromString(room_key.getValue());
            if(!room_key_int)
                XMessage::JoinNewRoom(XMessage::RoomInfo{});
            else
                XMessage::JoinRoom(room_key_int);
        }
#endif
    }
    catch(TCLAP::ArgException &e)   // catch any exceptions
    {
        std::cerr << "Error: " << e.error() << " for arg " << e.argId() << std::endl;
        std::cerr.flush();
        return 2;
    }
#else
    UNUSED(argc);
    UNUSED(argv);

    printf("Launching AppPath...\n");
    AppPathManager::initAppPath();

    OpenConfig();

    setup.verboseLogging = true;
#endif

#if defined(__EMSCRIPTEN__) && defined(THEXTECH_DEBUG_INFO)
    setup.verboseLogging = true;
#endif

#ifdef __16M__
    // setup.testMaxFPS = true;
    setCpuClock(true);
#endif

    UpdateConfig();

    // set this flag before SDL initialization to allow game be quit when closing a window before a loading process will be completed
    GameIsActive = true;

    if(g_frmMain.initSystem(setup))
    {
        g_frmMain.freeSystem();
        return 1;
    }

#ifdef __APPLE__
    macosReceiveOpenFile();
    if(!g_fileToOpen.empty())
    {
        setup.testLevel = g_fileToOpen;
        setup.testLevelMode = !setup.testLevel.empty();
        setup.testNumPlayers = 1;
        setup.testGodMode = false;
        setup.testGrabAll = false;
    }
#endif

#ifdef ENABLE_XTECH_LUA
    if(!xtech_lua_init())
        return 1;
#endif

    Controls::Init();
    Controls::LoadConfig();

    int ret = GameMain(setup);

#ifdef THEXTECH_ENABLE_SDL_NET
    XMessage::Shutdown();
#endif

    Integrator::quitIntegrations();

#ifdef ENABLE_XTECH_LUA
    if(!xtech_lua_quit())
        ret = 1;
#endif

#ifdef __WIIU__
    if(g_isHBLauncher)
        SYSRelaunchTitle(0, NULL);
#endif

    Controls::Quit();
    QuitMixerX();

    g_frmMain.freeSystem();

    Archives::unmount_assets();
    Archives::unmount_episode();
    Archives::unmount_temp();

#ifdef __EMSCRIPTEN__
    AppPathManager::syncFs();
    EM_ASM(
        setTimeout(() => {
            console.log("Attempting to close window following game exit...");
            document.getElementById("canvas").style.display = 'none';
            document.getElementById("exit-msg").style.display = null;
            window.close();
        }, 250);
    );
#endif

    return ret;
}


================================================
FILE: src/message.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <deque>

#include "controls.h"
#include "message.h"
#include "globals.h"

#include "graphics.h"
#include "player.h"
#include "main/cheat_code.h"
#include "main/screen_pause.h"

#ifdef THEXTECH_ENABLE_SDL_NET
#   include "main/client_methods.h"
#endif

namespace XMessage
{

static std::deque<Message> s_message_vector;
Session g_session;

static Controls_t s_last_controls[maxNetplayPlayers + 1];

void Handle(const Message& m)
{
#ifdef THEXTECH_ENABLE_SDL_NET
    // server control messages
    if(m.screen == 255)
    {
        if(m.type == Type::add_client)
        {
            Screen_t& screen = Screens[m.message];

            // add player if there isn't any
            if(screen.player_count == 0)
                AddPlayer((m.message % 5) + 1, screen);

            SetupScreens();
        }
        else if(m.type == Type::drop_client)
        {
            Screen_t& screen = Screens[m.message];

            // reset screen parameters
            screen.W = 800;
            screen.H = 600;
            screen.CameraOverscanX = 0;
            screen.two_screen_pref = MultiplayerPrefs::Dynamic;
            screen.four_screen_pref = MultiplayerPrefs::Shared;
            screen.canonical_screen().two_screen_pref = screen.two_screen_pref;
            screen.canonical_screen().four_screen_pref = screen.four_screen_pref;

            // drop players other than the last player
            for(int p = screen.player_count - 1; p >= 0; p--)
            {
                // reassign last player to Screen 0
                if(numPlayers == 1)
                {
                    Screens_DropPlayer(1);
                    Screens_AssignPlayer(1, Screens[0]);
                }
                else
                    DropPlayer(screen.players[p]);
            }
        }

    }
#endif // #ifdef THEXTECH_ENABLE_SDL_NET

    if(m.screen >= maxNetplayClients)
        return;

    Screen_t& screen = Screens[m.screen];

    if(m.type == Type::press || m.type == Type::release)
    {
        if(m.player >= maxLocalPlayers || m.message >= Controls::PlayerControls::n_buttons)
            return;

        auto& controls = s_last_controls[screen.players[m.player]];
        bool& button = Controls::PlayerControls::GetButton(controls, m.message);
        bool is_press = (m.type == Type::press);

        button = is_press;
    }
    else if(m.type == Type::char_swap)
    {
        if(m.player >= screen.player_count || m.message < 1 || m.message > numCharacters || !SwapCharAllowed())
            return;

        SwapCharacter(screen.players[m.player], m.message);

        if(LevelSelect && !GameMenu)
            SetupPlayers();
    }
    else if(m.type == Type::add_player || m.type == Type::add_player_dead)
    {
        if(screen.player_count >= maxLocalPlayers || m.message < 1 || m.message > numCharacters)
            return;

        // after AddPlayer, numPlayers is always the new player
        AddPlayer(m.message, screen);

        // set the player to be dead if needed
        if(m.type == Type::add_player_dead)
        {
            Player[numPlayers].Dead = true;

            // initialize ghost logic for player
            int living = CheckNearestLiving(numPlayers);
            if(living)
            {
                Player[numPlayers].Effect2 = -living;
                Player[numPlayers].Location.X = Player[living].Location.X;
                Player[numPlayers].Location.Y = Player[living].Location.Y;
                Player[numPlayers].Section    = Player[living].Section;
            }
            else
                Player[numPlayers].Effect2 = 0;
        }
    }
    else if(m.type == Type::drop_player)
    {
        if(m.player >= screen.player_count)
            return;

        DropPlayer(screen.players[m.player]);
    }
    else if(m.type == Type::menu_action)
    {
        PauseScreen::g_pending_action = m.message;
    }
    else if(m.type == Type::shared_controls)
    {
        if(m.message == 0)
            SharedPause = true;
        else if(m.message == 1)
            SharedPauseLegacy = true;
        else if(m.message == 2)
            SharedPauseForce = true;
    }
    else if(m.type == Type::enter_code)
        run_cheat(m);
    else if(m.type == Type::screen_w)
    {
        screen.W = m.player * 256 + m.message;
    }
    else if(m.type == Type::screen_h)
    {
        screen.H = m.player * 256 + m.message;
    }
    else if(m.type == Type::camera_overscan_x)
    {
        screen.CameraOverscanX = m.message;
    }
    else if(m.type == Type::multiplayer_prefs)
    {
        int two_screen_pref = m.player;
        int four_screen_pref = m.message;

        if(two_screen_pref > MultiplayerPrefs::Max_2P)
            two_screen_pref = 0;

        if(four_screen_pref > MultiplayerPrefs::Max_4P)
            four_screen_pref = 0;

        screen.two_screen_pref = two_screen_pref;
        screen.four_screen_pref = four_screen_pref;

        screen.canonical_screen().two_screen_pref = two_screen_pref;
        screen.canonical_screen().four_screen_pref = four_screen_pref;

        SetupScreens();
        PlayersEnsureNearby(screen);
    }
}

void InitSession()
{
    for(int A = 0; A <= maxNetplayPlayers; A++)
        s_last_controls[A] = Controls_t();
}

void Tick()
{
#ifdef THEXTECH_ENABLE_SDL_NET
    // sync state with other clients here
    if(CurrentRoom())
        ClientFrameSync(s_message_vector);
#endif

    // update player controls based on message queue
    Message m;
    while((m = PopMessage()))
        Handle(m);

    int numPlayers_p = numPlayers;

    // fix a bug affecting main menu dead mode
    if(GameMenu || GameOutro)
        numPlayers_p = maxLocalPlayers;

    for(int A = 1; A <= numPlayers_p && A <= maxNetplayPlayers; A++)
        Player[A].Controls = s_last_controls[A];
}

void PushMessage_Direct(Message message)
{
    s_message_vector.push_back(message);
}

void PushMessage(Message message)
{
    message.screen = l_screen - &Screens[0];
    PushMessage_Direct(message);
}

Message PopMessage()
{
    Message ret;
    if(s_message_vector.empty())
        return ret;

    ret = s_message_vector.front();
    s_message_vector.pop_front();
    return ret;
}

void PushControls(int l_player_i, const Controls_t& controls)
{
    Controls_t& last_controls = Controls::g_RawControls[l_player_i];

    Message m;
    m.screen = l_screen - &Screens[0];
    m.player = l_player_i;

    for(uint8_t i = 0; i < Controls::PlayerControls::n_buttons; i++)
    {
        bool new_pressed = Controls::PlayerControls::GetButton(controls, i);
        bool old_pressed = Controls::PlayerControls::GetButton(last_controls, i);

        if(new_pressed && !old_pressed)
        {
            m.type = Type::press;
            m.message = i;
            PushMessage_Direct(m);
        }
        else if(old_pressed && !new_pressed)
        {
            m.type = Type::release;
            m.message = i;
            PushMessage_Direct(m);
        }
    }

    last_controls = controls;
}

} // namespace XMessage


================================================
FILE: src/message.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef XMESSAGE_H
#define XMESSAGE_H

#include <cstdint>

struct Controls_t;


// The purpose of these methods is to track the set of player-initiated events that may affect gameplay
namespace XMessage
{

enum class Status : uint8_t
{
    local,
    replay,
    connected,
};

struct Session
{
    uint32_t random_seed = 0;
};

enum class Type : uint8_t
{
    empty,
    press,
    release,
    menu_action,
    char_swap,
    add_player,
    add_player_dead,
    drop_player,
    shared_controls,
    enter_code,
    screen_w,
    screen_h,
    multiplayer_prefs,
    camera_overscan_x,
    frame_begin = 32, // meta-message: the following messages belong to the named frame
#ifdef THEXTECH_ENABLE_SDL_NET
    // special server control messages
    add_client = 33,
    drop_client = 34,
    frame_end = 35, // meta-message: closes the previously named frame (only used by TCP)
    transmit_start = 36, // meta-message: acknowledges client messages up to named frame (only used by UDP)
#endif // #ifdef THEXTECH_ENABLE_SDL_NET
};

struct Message
{
    Type type = Type::empty;
    uint8_t screen;
    uint8_t player;
    uint8_t message;

    inline Message() : screen(0), player(0) {}
    inline Message(Type type, uint8_t player, uint8_t message) : type(type), screen(0), player(player), message(message) {}
    operator bool() const
    {
        return type != Type::empty;
    }
};

extern Session g_session;

void InitSession();
void Tick();

void PushMessage_Direct(Message message);
void PushMessage(Message message);
Message PopMessage();

void PushControls(int l_player_i, const Controls_t& controls);

#ifdef THEXTECH_ENABLE_SDL_NET

// defined in client_methods.cpp
Status GetStatus();

#else // #ifdef THEXTECH_ENABLE_SDL_NET

static inline Status GetStatus()
{
    return Status::local;
}

#endif // #ifdef THEXTECH_ENABLE_SDL_NET

} // namespace XMessage

#endif // #ifndef XMESSAGE_H


================================================
FILE: src/npc/npc_activation.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <bitset>
#include "sdl_proxy/sdl_stdinc.h"

#include "globals.h"
#include "layers.h"
#include "config.h"
#include "collision.h"

#include "npc_id.h"
#include "npc_traits.h"
#include "npc_queues.h"

#include "main/trees.h"

inline static bool s_Event_SoundOnly(const Events_t& evt, int test_section)
{
    if(!(evt.Text == STRINGINDEX_NONE
        && evt.HideLayer.empty()
        && evt.ShowLayer.empty()
        && evt.ToggleLayer.empty()
        && evt.MoveLayer == LAYER_NONE
        && evt.TriggerEvent == EVENT_NONE
        && evt.EndGame == 0))
    {
        return false;
    }

    bool autoscroll_okay = !AutoUseModern || evt.AutoSection != test_section
        || (g_config.fix_autoscroll_speed
            ? (!(evt.AutoX != 0 || evt.AutoY != 0)
                || (AutoX[evt.AutoSection] == evt.AutoX && AutoY[evt.AutoSection] == evt.AutoY))
            : (!IF_INRANGE(evt.AutoSection, 0, SDL_min(maxSections, maxEvents))
                || (AutoX[evt.AutoSection] == Events[evt.AutoSection].AutoX
                    && AutoY[evt.AutoSection] == Events[evt.AutoSection].AutoY)));

    if(!autoscroll_okay)
        return false;

    const EventSection_t& s = const_cast<Events_t&>(evt).section[test_section];
    bool section_okay = s.music_id == EventSection_t::LESet_Nothing
        && s.background_id == EventSection_t::LESet_Nothing
        && s.position.X == EventSection_t::LESet_Nothing
        && s.autoscroll == false;

    return section_okay;
}

// from section of UpdateNPCs called "process chain activations"
static bool s_NPC_CanActivate(const NPC_t& n)
{
    return n.Type != NPCID_CONVEYOR && n.Type != NPCID_FALL_BLOCK_RED &&
        n.Type != NPCID_FALL_BLOCK_BROWN && !n->IsACoin;
}

static bool s_NPC_MustBeCanonical_internal(const NPC_t& n)
{
    if(!s_NPC_CanActivate(n))
        return n.Generator;

    return n.Generator
        || n->UseDefaultCam
        || (n->IsFish && n.Special == 2)
        || n.AttLayer != LAYER_NONE
        || (n.Legacy && (n.Type == NPCID_MINIBOSS || n.Type == NPCID_SPIT_BOSS || n.Type == NPCID_VILLAIN_S3))
        || (n.TriggerActivate != EVENT_NONE && !s_Event_SoundOnly(Events[n.TriggerActivate], n.Section));
}

bool NPC_MustBeCanonical(NPCRef_t n)
{
    return n->_priv_force_canonical;
}

bool NPC_InactiveIgnore(const NPC_t& n)
{
    return (n->IsFish && n.Special == 2)
        || n->InactiveRender == NPCTraits_t::SKIP
        || n._priv_self_hide_event;
}

bool NPC_InactiveRender(const NPC_t& n)
{
    if(n->InactiveRender == NPCTraits_t::SMOKE)
        return false;

    if(n.DefaultType == 0)
        return false;

    return n.Inert
        || n.Stuck
        || n->InactiveRender == NPCTraits_t::SHOW_ALWAYS
        || n->InactiveRender == NPCTraits_t::SHOW_STATIC;
}

bool NPC_InactiveSmoke(const NPC_t& n)
{
    return n->InactiveRender == NPCTraits_t::SMOKE;
}

void NPC_ConstructCanonicalSet()
{
    std::vector<int16_t> to_check;
    to_check.reserve(64);

    for(int16_t n = 1; n <= numNPCs; n++)
    {
        if(s_NPC_MustBeCanonical_internal(NPC[n]) || NPC[n]._priv_force_canonical)
        {
            NPC[n]._priv_force_canonical = true;
            to_check.push_back(n);
        }

        // check if NPC has a hide self event
        if(NPC[n].TriggerActivate != EVENT_NONE && NPC[n].Layer != LAYER_NONE && NPC[n].Layer != LAYER_DEFAULT)
        {
            const Events_t& e = Events[NPC[n].TriggerActivate];

            for(layerindex_t l : e.HideLayer)
            {
                if(l == NPC[n].Layer)
                {
                    NPC[n]._priv_self_hide_event = true;
                    break;
                }
            }
        }
    }

    // find all NPCs that could cause the above NPCs to activate via chain activation
    for(size_t i = 0; i < to_check.size(); i++)
    {
        int16_t n = to_check[i];

        Location_t tempLocation = NPC[n].Location;
        tempLocation.Y -= 32;
        tempLocation.X -= 32;
        tempLocation.Width += 64;
        tempLocation.Height += 64;

        bool n_is_generator = NPC[n].Generator;

        for(int16_t B : treeNPCQuery(tempLocation, SORTMODE_NONE))
        {
            if(B != n && CheckCollision(tempLocation, NPC[B].Location))
            {
                // check that B is capable of chain-activation (or that n is a generator, in which case B would block it)
                if(!n_is_generator && !s_NPC_CanActivate(NPC[B]))
                    continue;

                if(!NPC[B]._priv_force_canonical)
                {
                    NPC[B]._priv_force_canonical = true;
                    to_check.push_back(B);
                }
            }
        }
    }
}

void NPCActivationLogic(int A)
{
    if(NPC[A].Active)
    {
        if((NPC[A]->IsFish && NPC[A].Special == 2) || NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_BIG_BULLET || NPC[A].Type == NPCID_GHOST_FAST) // Special Start for Jumping Fish and Bullet Bills
        {
            if(NPC[A].TimeLeft <= 1)
            {
                NPC[A].Active = false;
                NPC[A].TimeLeft = 0;
            }
            else if(NPC[A].Direction == -1 && NPC[A].Location.X < Player[NPC[A].JustActivated].Location.X)
            {
                NPC[A].Active = false;
                NPC[A].TimeLeft = 0;
            }
            else if(NPC[A].Direction == 1 && NPC[A].Location.X > Player[NPC[A].JustActivated].Location.X)
            {
                NPC[A].Active = false;
                NPC[A].TimeLeft = 0;
            }
            else if(NPC[A]->IsFish && NPC[A].Special == 2)
            {
                NPC[A].Location.Y = level[Player[NPC[A].JustActivated].Section].Height - 0.1_n;
                NPC[A].Location.SpeedX = (1 + (NPC[A].Location.Y - NPC[A].DefaultLocationY) / 200) * NPC[A].Direction;
                NPC[A].Special5 = 1;
                treeNPCUpdate(A);
                if(NPC[A].tempBlock > 0)
                    treeNPCSplitTempBlock(A);
            }
            else if(NPC[A].Type != NPCID_GHOST_FAST && !FreezeNPCs)
                PlaySoundSpatial(SFX_Bullet, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_GOALTAPE)
        {
            Location_t tempLocation = NPC[A].Location;
            tempLocation.Height = 8000;
            int C = 0;
            for(int B : treeBlockQuery(tempLocation, SORTMODE_COMPAT))
            {
                if(CheckCollision(tempLocation, Block[B].Location))
                {
                    if(C == 0)
                        C = B;
                    else
                    {
                        if(Block[B].Location.Y < Block[C].Location.Y)
                            C = B;
                    }
                }
            }

            if(C > 0)
            {
                // save location of ground below goal tape (was previously Special2)
                NPC[A].SpecialY = Block[C].Location.Y + 4;
                NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height;
                NPC[A].Special = 1;

                treeNPCUpdate(A);
                if(NPC[A].tempBlock > 0)
                    treeNPCSplitTempBlock(A);
            }
        }
        else if(NPC[A].Type == NPCID_LAVA_MONSTER) // blaarg
        {
            NPC[A].Location.Y = NPC[A].DefaultLocationY + NPC[A].Location.Height + 36;
            treeNPCUpdate(A);
            if(NPC[A].tempBlock > 0)
                treeNPCSplitTempBlock(A);
        }
        else if(NPC[A].Type == NPCID_CANNONENEMY)
            NPC[A].Special = 100;
    }

    // NOTE: these were not guarded by the Active check above in SMBX 1.3
    // they can't be safely moved into it because the iRand call has side effects
    if(NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_CANNONITEM)
        NPC[A].Projectile = false;
    else if(NPC[A].Type == NPCID_STATUE_S3 || NPC[A].Type == NPCID_STATUE_S4)
        NPC[A].Special = iRand(200);
    // new, clip wings from buried items
    else if(NPC[A].Type == NPCID_ITEM_BURIED)
        NPC[A].Wings = WING_NONE;

    NPC[A].JustActivated = 0;
    NPC[A].CantHurt = 0;
    NPC[A].CantHurtPlayer = 0;

    // in addition to removing cancelled NPCs from the Active list,
    // this also allows us to exclude Vines from the set of active NPCs
    // (without checking their status every frame if they do need to be active)
    if(!NPCQueues::check_active(NPC[A]))
        NPCQueues::Active.erase(A);
}


================================================
FILE: src/npc/npc_activation.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef NPC_ACTIVATION_H
#define NPC_ACTIVATION_H

#include "globals.h"

bool NPC_MustBeCanonical(NPCRef_t n);

// four possible render outcomes for an NPC: ignore (hide with no effect), render normally, hide with smoke effect, or shade (the default)
bool NPC_InactiveIgnore(const NPC_t& n);

bool NPC_InactiveRender(const NPC_t& n);

bool NPC_InactiveSmoke(const NPC_t& n);

void NPC_ConstructCanonicalSet();

#endif // #ifndef NPC_ACTIVATION_H


================================================
FILE: src/npc/npc_bonus.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../npc.h"
#include "../npc_id.h"
#include "../eff_id.h"
#include "../sound.h"
#include "../collision.h"
#include "../effect.h"
#include "../graphics.h"
#include "../player.h"
#include "../game_main.h"
#include "../core/events.h"
#include "main/game_globals.h"
#include "../config.h"
#include "../layers.h"

#include "npc_traits.h"

#include "main/level_medals.h"

#include "npc/npc_queues.h"

#include "../controls.h"

#include <Logger/logger.h>
#ifdef THEXTECH_INTERPROC_SUPPORTED
#   include <InterProcess/intproc.h>
#endif


static void s_PowerupScore(NPCRef_t n)
{
    if(g_config.custom_powerup_collect_score)
        MoreScore((*n)->Score, n->Location);
    else
        MoreScore(6, n->Location);
}


inline void RumbleForPowerup(int A)
{
    Controls::Rumble(A, 200, 0.25);
}

void DropBonus(int A)
{
    const Player_t& plr = Player[A];

    // does player not have a bonus?
    if(plr.HeldBonus <= 0)
        return;

    // is player a clone?
    if(g_ClonedPlayerMode && A != 1)
    {
        Player[A].HeldBonus = NPCID(0);
        return;
    }

    // is player not meant to have a bonus?
    if(Player[A].Character == 3 || Player[A].Character == 4)
    {
        Player[A].HeldBonus = NPCID(0);
        return;
    }

    if(g_config.alt_powerdown)
        return;

    // drop the bonus!
    PlaySoundSpatial(SFX_DropItem, plr.Location);
    numNPCs++;
    NPC[numNPCs].Type = Player[A].HeldBonus;
    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
    NPC[numNPCs].Location.Height = 32;

    // need to find a position to place the bonus -- look for ths HUD
    const Screen_t& screen = ScreenByPlayer(A);
    bool is_shared = (screen.player_count > 1) && (screen.Type != 6) && (screen.active_end() == screen.active_begin() + 1);

    // HUD offset for player
    int hud_offset = 0;

    if(is_shared && screen.player_count > 2)
    {
        int hud_width = 84 * screen.player_count;
        for(int i = 0; i < screen.player_count; i++)
        {
            if(A == screen.players[i])
            {
                // find center for player item box; this is the center of the i'th portion of the HUD (out of plr_count portions)
                hud_offset = (hud_width * (i * 2 + 1)) / (screen.player_count * 2) - hud_width / 2;
                break;
            }
        }
    }
    else if(is_shared)
    {
        if(A == screen.players[0])
            hud_offset = -40;
        if(A == screen.players[1])
            hud_offset = 40;
    }

    // update the vScreen for the player
    vScreen_t& vscreen = vScreenByPlayer(A);
    GetvScreenAuto(vscreen);

    // also update canonical vScreen if needed
    if(!screen.is_canonical())
        GetvScreenAuto(vScreenByPlayer_canonical(A));

    // find the HUD
    num_t ScreenTop = -vscreen.Y;

    if(vscreen.Height > 600)
        ScreenTop += vscreen.Height / 2 - 300;

    num_t CenterX = -vscreen.X + vscreen.Width / 2;

    // place NPC at HUD
    NPC[numNPCs].Location.X = CenterX + hud_offset - NPC[numNPCs].Location.Width / 2;
    NPC[numNPCs].Location.Y = ScreenTop + 16 + 12;

    // finish initializing the NPC
    NPC[numNPCs].Location.SpeedX = 0;
    NPC[numNPCs].Location.SpeedY = 0;
    NPC[numNPCs].Effect = NPCEFF_DROP_ITEM;
    NPC[numNPCs].Effect2 = 1;
    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = 200;
    syncLayers_NPC(numNPCs);
    CheckSectionNPC(numNPCs);

    // enable modern NPC spawn code
    bool small_screen_cam = (g_config.small_screen_cam && screen.W < screen.canonical_screen().W);
    bool always_shared = (is_shared && screen.Type == ScreenTypes::SharedScreen);
    bool multi_screen = (numPlayers > screen.player_count) && !g_ClonedPlayerMode;
    if(!ForcedControls && (always_shared || small_screen_cam || multi_screen))
    {
        NPC[numNPCs].Special5 = 120;
        NPC[numNPCs].Effect3 = A;
        NPC[numNPCs].Effect2 = 1;
    }

    // erase bonus
    Player[A].HeldBonus = NPCID(0);
}

void CheckAfterStarTake(bool many)
{
    int allBGOs = numBackground + numLocked;
    for(int c = 1; c <= numWarps; c++)
    {
        auto &w = Warp[c];
        if((!many && (w.Stars == numStars)) || (many && (w.Stars <= numStars)))
        {
            for(int d = numBackground + 1; d <= allBGOs; d++)
            {
                auto &b = Background[d];
                if(b.Type == 160 &&
                    (CheckCollision(w.Entrance, b.Location) ||
                     (w.twoWay && CheckCollision(w.Exit, b.Location)))
                )
                {
                    // this makes the background permanently disappear
                    b.Layer = LAYER_NONE;
                    b.Hidden = true;
                    syncLayers_BGO(d);
                }
            }
        }
    }
}

static void s_MovePlayersToExit(int got_exit_A)
{
    const auto& p_A = Player[got_exit_A];

    for(int C = 1; C <= numPlayers; C++)
    {
        if(got_exit_A == C) // And DScreenType <> 5 Then
            continue;

        auto& p_C = Player[C];

        p_C.Section = p_A.Section;
        p_C.Location.Y = p_A.Location.Y + p_A.Location.Height - p_C.Location.Height;
        p_C.Location.X = p_A.Location.X + (p_A.Location.Width - p_C.Location.Width) / 2;
        p_C.Location.SpeedX = 0;
        p_C.Location.SpeedY = 0;
        p_C.Effect = PLREFF_WAITING;
        p_C.Effect2 = -got_exit_A;
    }

    clearScreenFaders();
}

void CollectMedal(const NPC_t& medal)
{
    PlaySoundSpatial(SFX_MedalGet, medal.Location);

    auto& medal_score = NPCTraits[medal.Type].Score;
    MoreScore(medal_score, medal.Location);

    medal_score += 1;
    if(medal_score > 14)
        medal_score = 14;

    if(!GameMenu && !GameOutro)
        g_curLevelMedals.get(medal.Variant - 1);
}

void TouchBonus(int A, int B)
{
    // INCORRECT NOTE: the only way to reach this code in SMBX 1.3 when Player[A].Effect is not PLREFF_NORMAL is if NPC[B]->IsACoin is true and NPC[B] is on Char4's boomerang
    // NOTE: this is not true. It can also be reached if two bonuses are touched in the same frame.

    // ban collecting dropped item during first stage of modern item drop process
    if(NPC[B].Effect == NPCEFF_DROP_ITEM && NPC[B].Effect3 != 0)
        return;

    // don't get just-thrown items, except coins
    if(NPC[B].CantHurtPlayer == A && !(NPC[B]->IsACoin && Player[A].HoldingNPC != B && NPC[B].Killed == 0))
        return;

    int sfx_extra_item     = (Player[A].Character == 5) ? SFX_HeroHeart : SFX_GotItem;
    int sfx_grow_item      = (Player[A].Character == 5) ? SFX_HeroItem  : SFX_PlayerGrow;
    int sfx_transform_item = (Player[A].Character == 5) ? SFX_HeroItem  : SFX_Transform;

    // moved up here so that the hearts logic works
    NPCID civilian_type = NPCID(0);

    if(NPCIsToad(NPC[B]))
    {
        civilian_type = NPC[B].Type;
        NPC[B].Type = NPCID_POWER_S3;
    }

    // give hearts to heart chars
    if(Player[A].Character == 3 || Player[A].Character == 4 || Player[A].Character == 5)
    {
        // only the first three types were checked in SMBX 1.3, the others were moved here for simplicity
        if(NPC[B].Type == NPCID_LEAF_POWER || NPC[B].Type == NPCID_STATUE_POWER || NPC[B].Type == NPCID_HEAVY_POWER
            || NPC[B].Type == NPCID_POWER_S3 || NPC[B].Type == NPCID_POWER_S1 || NPC[B].Type == NPCID_POWER_S4 || NPC[B].Type == NPCID_POWER_S2 || NPC[B].Type == NPCID_POWER_S5
            || NPC[B].Type == NPCID_FIRE_POWER_S3 || NPC[B].Type == NPCID_FIRE_POWER_S1 || NPC[B].Type == NPCID_FIRE_POWER_S4
            || NPC[B].Type == NPCID_ICE_POWER_S3 || NPC[B].Type == NPCID_ICE_POWER_S4
            || NPC[B].Type == NPCID_AQUATIC_POWER || NPC[B].Type == NPCID_POLAR_POWER
            || NPC[B].Type == NPCID_CYCLONE_POWER || NPC[B].Type == NPCID_SHELL_POWER)
        {
            Player[A].Hearts += 1;

            if(Player[A].Hearts > 3)
                Player[A].Hearts = 3;
        }
    }

    // If .Character = 3 Or .Character = 4 Then  'for chars 3/4 turn leaf and suits into a mushroom
    // If NPC(B).Type = 34 Or NPC(B).Type = 169 Or NPC(B).Type = 170 Then NPC(B).Type = 9
    // End If

    if(NPC[B].Type == NPCID_SWAP_POWER) // ? mushroom
    {
        int touched_power_i = A;
        int target_i = CheckNearestLiving(A);

        // NOTE: this previously used hardcoded 1 and 2; now it targets the living player nearest A, prioritizing local players
        if(g_ClonedPlayerMode)
        {
            touched_power_i = 1;
            target_i = 2;
        }

        Player_t& p_touched = Player[touched_power_i];
        Player_t& p_target = Player[target_i];

        if(target_i != 0
            && !p_touched.Dead && p_touched.TimeToLive == 0 && p_touched.Immune == 0
            && !p_target.Dead && p_target.TimeToLive == 0 && p_target.Immune == 0)
        {
            // tempLocation = p_touched.Location;

            // swap location
            num_t touched_X = p_touched.Location.X;
            num_t touched_Y = p_touched.Location.Y;
            p_touched.Location.X = p_target.Location.X + (p_target.Location.Width  - p_touched.Location.Width) / 2;
            p_touched.Location.Y = p_target.Location.Y + p_target.Location.Height  - p_touched.Location.Height;
            p_target.Location.X  = touched_X           + (p_touched.Location.Width - p_target.Location.Width) / 2;
            p_target.Location.Y  = touched_Y           + p_touched.Location.Height - p_target.Location.Height;

            // swap some variables
            std::swap(p_touched.Direction, p_target.Direction);
            std::swap(p_touched.Slope, p_target.Slope);
            std::swap(p_touched.StandingOnNPC, p_target.StandingOnNPC);

            // FIXME: verify whether warps should also be swapped...

            // BUGFIX: swap sections; fixes vanilla bug where both players could be killed / trapped
            if(g_config.fix_multiplayer_targeting)
            {
                CheckSection(touched_power_i);
                CheckSection(target_i);
            }

            // NEW: swap status for maze zones
            std::swap(p_touched.CurMazeZone, p_target.CurMazeZone);
            std::swap(p_touched.MazeZoneStatus, p_target.MazeZoneStatus);

            // make players immune
            if(p_touched.Immune < 10)
                p_touched.Immune = 10;
            if(p_target.Immune < 10)
                p_target.Immune = 10;

            // play sound in both locations (so both players will hear if remote)
            int old_pause = SoundPause[SFX_BossBeat];
            PlaySoundSpatial(SFX_BossBeat, p_touched.Location);
            SoundPause[SFX_BossBeat] = old_pause;
            PlaySoundSpatial(SFX_BossBeat, p_target.Location);
        }
    }
    else if(NPC[B].Type == NPCID_FLY_POWER) // Player is a fairy
    {
        // don't kill the powerup if it can't be used!
        if(Player[A].Mount == 2)
            return;

        if(!Player[A].Fairy)
        {
            Player[A].Immune = 30;
            Player[A].Effect = PLREFF_WAITING;
            Player[A].Effect2 = 4;
            Player[A].Fairy = true;
            SizeCheck(Player[A]);
            NewEffect(EFFID_SMOKE_S5, Player[A].Location);
        }

        PlaySoundSpatial(SFX_HeroFairy, NPC[B].Location);
        Player[A].FairyTime = -1;
    }
    else if(NPC[B].Type == NPCID_LIFE_S3 || NPC[B].Type == NPCID_LIFE_S4 || NPC[B].Type == NPCID_LIFE_S1) // player touched a 1up mushroom
    {
        MoreScore(10, NPC[B].Location);
    }
    else if(NPC[B].Type == NPCID_TIMER_S3 && NPC[B].Effect != NPCEFF_DROP_ITEM && (Player[A].Character == 1 || Player[A].Character == 2)) // send the clock to the item container
    {
        Player[A].HeldBonus = NPCID_TIMER_S3;
        PlaySoundSpatial(SFX_GotItem, NPC[B].Location);
    }
    else if(NPC[B].Type == NPCID_TIMER_S2 || NPC[B].Type == NPCID_TIMER_S3) // player touched the clock
    {
        PSwitchStop = Physics.NPCPSwitch;
        FreezeNPCs = true;
        PSwitchPlayer = A;
    }
    else if(NPC[B].Type == NPCID_CHECKPOINT) // player touched the chekpoint
    {
        RumbleForPowerup(A);

        if(Player[A].State == 1)
            Player[A].State = 2;
        if(Player[A].Hearts == 1)
            Player[A].Hearts = 2;
        SizeCheck(Player[A]);

        PlaySoundSpatial(SFX_Checkpoint, NPC[B].Location);

        Checkpoint = FullFileName;
        Checkpoint_t cp;
        cp.id = NPC[B].Special;
        CheckpointsList.push_back(cp);
        g_curLevelMedals.on_checkpoint();
        pLogDebug("Added checkpoint ID %d", cp.id);
    }
    else if(NPC[B].Type == NPCID_3_LIFE) // player touched the 3up moon
    {
        MoreScore(12, NPC[B].Location);
    }
    else if(NPC[B].Type == NPCID_AXE)
    {
        // go straight to code to kill NPC
    }
    else if(NPC[B].Type == NPCID_FLAG_EXIT)
    {
        // do nothing, we just want the other traits of bonus
        return;
    }
    else if(NPC[B].Type == NPCID_POISON) // Bonus is a POISON mushroom
    {
        PlayerHurt(A);
    }
    else if(NPC[B].Type == NPCID_INVINCIBILITY_POWER)
    {
        PSwitchPlayer = A;
        InvincibilityTime = Physics.NPCPSwitch;
    }
    else if(NPC[B].Type == NPCID_POWER_S3 || NPC[B].Type == NPCID_POWER_S1 || NPC[B].Type == NPCID_POWER_S4 || NPC[B].Type == NPCID_POWER_S2 || NPC[B].Type == NPCID_POWER_S5) // Bonus is a mushroom
    {
        if(Player[A].Character == 5 && Player[A].State == 1)
            Player[A].State = 2;

        UpdatePlayerBonus(A, NPC[B].Type);

        if(Player[A].State == 1 && Player[A].Character != 5)
        {
            RumbleForPowerup(A);

            // UnDuck checks Duck internally, so let's call it directly
            // if(Player[A].Duck)
            //     UnDuck(Player[A]);

            int BackupGrabTime = Player[A].GrabTime;

            // force UnDuck to work, fixes a vanilla downwards clip while ducking
            if(g_config.fix_player_grab_clip && Player[A].Character >= 3)
                Player[A].GrabTime = 0;

            UnDuck(Player[A]);

            Player[A].GrabTime = BackupGrabTime;

            Player[A].StateNPC = NPC[B].Type;
            Player[A].Frame = 1;
            Player[A].Effect = PLREFF_TURN_BIG;

            // Duck already unset above
            // if(Player[A].Mount > 0)
            //     UnDuck(Player[A]);

            PlaySoundSpatial(SFX_PlayerGrow, NPC[B].Location);
        }
        else if(NPC[B].Type == NPCID_POWER_S5)
            PlaySoundSpatial(SFX_HeroHeart, NPC[B].Location);
        else
            PlaySoundSpatial(SFX_GotItem, NPC[B].Location);

        if(NPC[B].Effect != NPCEFF_DROP_ITEM)
            s_PowerupScore(B);
    }
    // logic combined across all powerup NPCs
    else if(NPC[B].Type == NPCID_FIRE_POWER_S3 || NPC[B].Type == NPCID_FIRE_POWER_S1 || NPC[B].Type == NPCID_FIRE_POWER_S4
        || NPC[B].Type == NPCID_ICE_POWER_S3 || NPC[B].Type == NPCID_ICE_POWER_S4
        || NPC[B].Type == NPCID_LEAF_POWER || NPC[B].Type == NPCID_STATUE_POWER || NPC[B].Type == NPCID_HEAVY_POWER
        || NPC[B].Type == NPCID_AQUATIC_POWER || NPC[B].Type == NPCID_POLAR_POWER
        || NPC[B].Type == NPCID_CYCLONE_POWER || NPC[B].Type == NPCID_SHELL_POWER)
    {
        int target_state = PLR_STATE_BIG;
        PlayerEffect target_effect = PLREFF_TURN_TO_STATE;
        bool reset_effect2 = true;
        int use_sfx = sfx_transform_item;

        if(NPC[B].Type == NPCID_FIRE_POWER_S3 || NPC[B].Type == NPCID_FIRE_POWER_S1 || NPC[B].Type == NPCID_FIRE_POWER_S4)
        {
            target_state = PLR_STATE_FIRE;
            target_effect = PLREFF_GROW_TO_STATE;
            reset_effect2 = false;
            use_sfx = sfx_grow_item;
        }
        else if(NPC[B].Type == NPCID_ICE_POWER_S3 || NPC[B].Type == NPCID_ICE_POWER_S4)
        {
            target_state = PLR_STATE_ICE;
            target_effect = PLREFF_GROW_TO_STATE;
            reset_effect2 = false;
            use_sfx = sfx_grow_item;
        }
        else if(NPC[B].Type == NPCID_CYCLONE_POWER)
        {
            target_state = PLR_STATE_CYCLONE;
            target_effect = PLREFF_GROW_TO_STATE;
            reset_effect2 = false;
            use_sfx = sfx_grow_item;

            // award a double-jump!
            if(Player[A].State != PLR_STATE_CYCLONE)
                Player[A].DoubleJump = true;
        }
        else if(NPC[B].Type == NPCID_LEAF_POWER)
            target_state = PLR_STATE_LEAF;
        else if(NPC[B].Type == NPCID_STATUE_POWER)
            target_state = PLR_STATE_STATUE;
        else if(NPC[B].Type == NPCID_HEAVY_POWER)
            target_state = PLR_STATE_HEAVY;
        else if(NPC[B].Type == NPCID_AQUATIC_POWER)
            target_state = PLR_STATE_AQUATIC;
        else if(NPC[B].Type == NPCID_POLAR_POWER)
            target_state = PLR_STATE_POLAR;
        else if(NPC[B].Type == NPCID_SHELL_POWER)
            target_state = PLR_STATE_SHELL;

        UpdatePlayerBonus(A, NPC[B].Type);
        Player[A].StateNPC = NPC[B].Type;

        if(Player[A].State != target_state)
        {
            RumbleForPowerup(A);

            // fixes a vanilla downwards clip that happens even if the player is just ducking (not even digging)
            if(g_config.fix_player_grab_clip && Player[A].State == 1 && Player[A].Character >= 3 && reset_effect2)
            {
                int BackupGrabTime = Player[A].GrabTime;
                Player[A].GrabTime = 0;
                UnDuck(Player[A]);
                Player[A].GrabTime = BackupGrabTime;
            }

            if(!Player[A].AquaticSwim && !Player[A].Rolling)
                Player[A].Frame = 1;

            Player[A].Effect = (PlayerEffect)(target_effect + target_state);

            if(reset_effect2)
                Player[A].Effect2 = 0;

            if(Player[A].Mount > 0 || (Player[A].AquaticSwim && target_state != PLR_STATE_AQUATIC && target_state != PLR_STATE_POLAR) || (Player[A].Rolling && target_state != PLR_STATE_SHELL && target_state != PLR_STATE_POLAR))
            {
                Player[A].AquaticSwim = false;
                Player[A].Rolling = false;

                UnDuck(Player[A]);

                if(Player[A].Mount == 0)
                    PlayerFrame(A);
            }

            PlaySoundSpatial(use_sfx, NPC[B].Location);
        }
        else
            PlaySoundSpatial(sfx_extra_item, NPC[B].Location);

        if(NPC[B].Effect != NPCEFF_DROP_ITEM)
            s_PowerupScore(B);
    }
#if 0
    else if(NPC[B].Type == NPCID_FIRE_POWER_S3 || NPC[B].Type == NPCID_FIRE_POWER_S1 || NPC[B].Type == NPCID_FIRE_POWER_S4) // Bonus is a fire flower
    {
        UpdatePlayerBonus(A, NPC[B].Type);
        Player[A].StateNPC = NPC[B].Type;

        if(Player[A].State != 3)
        {
            RumbleForPowerup(A);
            Player[A].Frame = 1;
            Player[A].Effect = PLREFF_TURN_FIRE;
            if(Player[A].Mount > 0)
                UnDuck(Player[A]);

            PlaySoundSpatial(sfx_grow_item, NPC[B].Location);
        }
        else
            PlaySoundSpatial(sfx_extra_item, NPC[B].Location);

        if(NPC[B].Effect != NPCEFF_DROP_ITEM)
            s_PowerupScore(B);
    }
    else if(NPC[B].Type == NPCID_ICE_POWER_S3 || NPC[B].Type == NPCID_ICE_POWER_S4) // Bonus is an ice flower
    {
        UpdatePlayerBonus(A, NPC[B].Type);
        Player[A].StateNPC = NPC[B].Type;

        if(Player[A].State != 7)
        {
            RumbleForPowerup(A);
            Player[A].Frame = 1;
            Player[A].Effect = PLREFF_TURN_ICE;
            if(Player[A].Mount > 0)
                UnDuck(Player[A]);

            PlaySoundSpatial(sfx_grow_item, NPC[B].Location);
        }
        else
            PlaySoundSpatial(sfx_extra_item, NPC[B].Location);

        if(NPC[B].Effect != NPCEFF_DROP_ITEM)
            s_PowerupScore(B);
    }
    else if(NPC[B].Type == NPCID_LEAF_POWER) // Bonus is a leaf
    {
        UpdatePlayerBonus(A, NPC[B].Type);
        Player[A].StateNPC = NPC[B].Type;

        if(Player[A].State != 4)
        {
            RumbleForPowerup(A);
            Player[A].Frame = 1;
            Player[A].Effect = PLREFF_TURN_LEAF;
            Player[A].Effect2 = 0;
            if(Player[A].Mount > 0)
                UnDuck(Player[A]);

            PlaySoundSpatial(sfx_transform_item, NPC[B].Location);
        }
        else
            PlaySoundSpatial(sfx_extra_item, NPC[B].Location);

        if(NPC[B].Effect != NPCEFF_DROP_ITEM)
            s_PowerupScore(B);
    }
    else if(NPC[B].Type == NPCID_STATUE_POWER) // Bonus is a Tanooki Suit
    {
        UpdatePlayerBonus(A, NPC[B].Type);
        Player[A].StateNPC = NPC[B].Type;

        if(Player[A].State != 5)
        {
            RumbleForPowerup(A);
            Player[A].Frame = 1;
            Player[A].Effect = PLREFF_TURN_STATUE;
            Player[A].Effect2 = 0;
            if(Player[A].Mount > 0)
                UnDuck(Player[A]);

            PlaySoundSpatial(sfx_transform_item, NPC[B].Location);
        }
        else
            PlaySoundSpatial(sfx_extra_item, NPC[B].Location);

        if(NPC[B].Effect != NPCEFF_DROP_ITEM)
            s_PowerupScore(B);
    }
    else if(NPC[B].Type == NPCID_HEAVY_POWER) // Bonus is a Hammer Suit
    {
        UpdatePlayerBonus(A, NPC[B].Type);
        Player[A].StateNPC = NPC[B].Type;

        if(Player[A].State != 6)
        {
            RumbleForPowerup(A);
            Player[A].Frame = 1;
            Player[A].Effect = PLREFF_TURN_HEAVY;
            Player[A].Effect2 = 0;
            if(Player[A].Mount > 0)
                UnDuck(Player[A]);

            PlaySoundSpatial(sfx_transform_item, NPC[B].Location);
        }
        else
            PlaySoundSpatial(sfx_extra_item, NPC[B].Location);

        if(NPC[B].Effect != NPCEFF_DROP_ITEM)
            s_PowerupScore(B);
    }
#endif
    else if(NPC[B]->IsACoin) // Bonus is a coin
    {
        if(NPC[B].Type == NPCID_RING)
            PlaySoundSpatial(SFX_RingGet, NPC[B].Location);
        else if(NPC[B].Type == NPCID_GEM_1 || NPC[B].Type == NPCID_GEM_5 || NPC[B].Type == NPCID_GEM_20)
            PlaySoundSpatial(SFX_HeroRupee, NPC[B].Location);
        else if(NPC[B].Type != NPCID_MEDAL)
            PlaySoundSpatial(SFX_Coin, NPC[B].Location);

        if(NPC[B].Type == NPCID_GEM_5 || NPC[B].Type == NPCID_COIN_5)
            Coins += 5;
        else if(NPC[B].Type == NPCID_GEM_20)
            Coins += 20;
        else
            Coins += 1;

        if(Coins >= 100)
            Got100Coins();

        if(NPC[B].Type == NPCID_MEDAL)
            CollectMedal(NPC[B]);
        else
            MoreScore(1, NPC[B].Location);

        NewEffect(EFFID_COIN_COLLECT, NPC[B].Location);
    }
    else if(NPCIsAnExit(NPC[B]) && LevelMacro == LEVELMACRO_OFF) // Level exit
    {
        if(NPC[B].Type != NPCID_STAR_COLLECT)
        {
            TurnNPCsIntoCoins();
            FreezeNPCs = false;
            if(g_ClonedPlayerMode)
                Player[1] = Player[A];
        }

        if(NPC[B].Type == NPCID_ITEMGOAL)
        {
            if(NPC[B].Frame == 0)
                MoreScore(10, Player[A].Location);
            if(NPC[B].Frame == 1)
                MoreScore(6, Player[A].Location);
            if(NPC[B].Frame == 2)
                MoreScore(8, Player[A].Location);

            LevelMacro = LEVELMACRO_CARD_ROULETTE_EXIT;

            s_MovePlayersToExit(A);

            StopMusic();
            // XEvents::doEvents();
            PlaySound(SFX_CardRouletteClear);
        }
        else if(NPC[B].Type == NPCID_GOALORB_S3)
        {
            LevelMacro = LEVELMACRO_QUESTION_SPHERE_EXIT;

            s_MovePlayersToExit(A);

            StopMusic();
            PlaySound(SFX_DungeonClear);
        }
        else if(NPC[B].Type == NPCID_GOALORB_S2)
        {
            LevelMacro = LEVELMACRO_CRYSTAL_BALL_EXIT;

            s_MovePlayersToExit(A);

            StopMusic();
            PlaySound(SFX_CrystalBallExit);
        }
        else if(NPC[B].Type == NPCID_STAR_EXIT || NPC[B].Type == NPCID_STAR_COLLECT)
        {
            bool star_gotten = false;

            for(const auto& star : Star)
            {
                bool bySection = NPC[B].Variant == 0 && (star.Section == NPC[B].Section || star.Section == -1);
                bool byId = NPC[B].Variant > 0 && -(star.Section + 100) == int(NPC[B].Variant);

                if(star.level == FileNameFull && (bySection || byId))
                    star_gotten = true;
            }

            if(!star_gotten)
            {
                Star_t star;
                star.level = FileNameFull;
                // Positive - section number, Negative - UID of each star per level
                int special = (int)NPC[B].Variant;
                star.Section = special <= 0 ? NPC[B].Section : -special - 100;
                if(special > 0)
                    pLogDebug("Got a star with UID=%d", special);
                Star.push_back(std::move(star));
                numStars = (int)Star.size();
#ifdef THEXTECH_INTERPROC_SUPPORTED
                IntProc::sendStarsNumber(numStars);
#endif
                CheckAfterStarTake(false);
            }

            if(NPC[B].Type == NPCID_STAR_EXIT)
            {
                LevelMacro = LEVELMACRO_STAR_EXIT;

                s_MovePlayersToExit(A);

                StopMusic();
                PlaySound(SFX_GotStar);
            }
            else
                PlaySoundSpatial(SFX_MedalGet, NPC[B].Location);
        }
    }

    if(civilian_type > 0)
        NPC[B].Type = civilian_type;

    NPC[B].Killed = 9;
    NPCQueues::Killed.push_back(B);
}


================================================
FILE: src/npc/npc_cockpit_bits.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef NPC_COCKPIT_BITS_H
#define NPC_COCKPIT_BITS_H

enum NPC_CockpitBits
{
    NPC_COCKPIT_DRIVING = (1 << 0),
    NPC_COCKPIT_LEFT = (1 << 1),
    NPC_COCKPIT_RIGHT = (1 << 2),
    NPC_COCKPIT_UP = (1 << 3),
    NPC_COCKPIT_DOWN = (1 << 4),
};

#endif // #ifndef NPC_COCKPIT_BITS_H


================================================
FILE: src/npc/npc_frames.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "npc.h"
#include "sound.h"
#include "collision.h"
#include "effect.h"
#include "npc_id.h"
#include "eff_id.h"
#include "npc_traits.h"

#include "main/trees.h"

static void s_makeHeavySparkle(const NPC_t& n, int offY)
{
    NewEffect(EFFID_SPARKLE, newLoc(n.Location.X + n.Location.Width / 2 - 4, n.Location.Y + n.Location.Height / 2 - offY), 1, n.Shadow);
    Effect[numEffects].Location.SpeedX = dRand() - 0.5_n;
    Effect[numEffects].Location.SpeedY = dRand() - 0.5_n;
}


void NPCFrames(int A)
{
    if(NPC[A]->TFrames > 0) // custom frames
    {
        NPC[A].FrameCount += 1;
        if(NPC[A]->FrameStyle == 2 && (NPC[A].Projectile || NPC[A].HoldingPlayer > 0))
            NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= NPC[A]->FrameSpeed)
        {
            if(NPC[A]->FrameStyle == 0)
                NPC[A].Frame += 1 * NPC[A].Direction;
            else
                NPC[A].Frame += 1;
            NPC[A].FrameCount = 0;
        }
        if(NPC[A]->FrameStyle == 0)
        {
            if(NPC[A].Frame >= NPC[A]->TFrames)
                NPC[A].Frame = 0;
            if(NPC[A].Frame < 0)
                NPC[A].Frame = NPC[A]->TFrames - 1;
        }
        else if(NPC[A]->FrameStyle == 1)
        {
            if(NPC[A].Direction == -1)
            {
                if(NPC[A].Frame >= NPC[A]->TFrames)
                    NPC[A].Frame = 0;
                if(NPC[A].Frame < 0)
                    NPC[A].Frame = NPC[A]->TFrames;
            }
            else
            {
                if(NPC[A].Frame >= NPC[A]->TFrames * 2)
                    NPC[A].Frame = NPC[A]->TFrames;
                if(NPC[A].Frame < NPC[A]->TFrames)
                    NPC[A].Frame = NPC[A]->TFrames;
            }
        }
        else if(NPC[A]->FrameStyle == 2)
        {
            if(NPC[A].HoldingPlayer == 0 && !NPC[A].Projectile)
            {
                if(NPC[A].Direction == -1)
                {
                    if(NPC[A].Frame >= NPC[A]->TFrames)
                        NPC[A].Frame = 0;
                    if(NPC[A].Frame < 0)
                        NPC[A].Frame = NPC[A]->TFrames - 1;
                }
                else
                {
                    if(NPC[A].Frame >= NPC[A]->TFrames * 2)
                        NPC[A].Frame = NPC[A]->TFrames;
                    if(NPC[A].Frame < NPC[A]->TFrames)
                        NPC[A].Frame = NPC[A]->TFrames * 2 - 1;
                }
            }
            else
            {
                if(NPC[A].Direction == -1)
                {
                    if(NPC[A].Frame >= NPC[A]->TFrames * 3)
                        NPC[A].Frame = NPC[A]->TFrames * 2;
                    if(NPC[A].Frame < NPC[A]->TFrames * 2)
                        NPC[A].Frame = NPC[A]->TFrames * 3 - 1;
                }
                else
                {
                    if(NPC[A].Frame >= NPC[A]->TFrames * 4)
                        NPC[A].Frame = NPC[A]->TFrames * 3;
                    if(NPC[A].Frame < NPC[A]->TFrames * 3)
                        NPC[A].Frame = NPC[A]->TFrames * 4 - 1;
                }
            }
        }
    }
    // massive conditional over NPC's Type
    else if(NPC[A].Type == NPCID_VILLAIN_S3 || NPC[A].Type == NPCID_ITEM_THROWER || NPC[A].Type == NPCID_SPIKY_THROWER)
    {
        // do nothing
    }
    else if(NPC[A].Type == NPCID_SQUID_S3 || NPC[A].Type == NPCID_SQUID_S1 || NPC[A].Type == NPCID_SPIT_BOSS_BALL ||
            NPC[A].Type == NPCID_FALL_BLOCK_RED || NPC[A].Type == NPCID_FALL_BLOCK_BROWN ||
            NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT ||
            NPC[A].Type == NPCID_VPIPE_LONG || NPC[A].Type == NPCID_BIG_SHELL || NPCIsVeggie(NPC[A].Type) || NPC[A].Type == NPCID_SHORT_WOOD ||
            NPC[A].Type == NPCID_LONG_WOOD || NPC[A].Type == NPCID_SLANT_WOOD_R || NPC[A].Type == NPCID_SLANT_WOOD_M || NPC[A].Type == NPCID_PLATFORM_S3 ||
            NPC[A].Type == NPCID_CHECKER_PLATFORM || NPC[A].Type == NPCID_PLATFORM_S1 || NPC[A].Type == NPCID_SPIT_GUY_BALL || NPC[A].Type == NPCID_SIGN ||
            (NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D) || NPC[A].Type == NPCID_LIFT_SAND || NPC[A].Type == NPCID_CHECKPOINT ||
            NPC[A].Type == NPCID_GOALTAPE || NPC[A].Type == NPCID_ICE_BLOCK || NPC[A].Type == NPCID_TNT ||
            NPC[A].Type == NPCID_TIMER_S2 || NPC[A].Type == NPCID_POWER_S5 || NPC[A].Type == NPCID_MAGIC_DOOR || NPC[A].Type == NPCID_COCKPIT ||
            NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_COIN_SWITCH) // no frames
    {
        if(A == 0) // Reset Frame to 0
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_STATUE_POWER || NPC[A].Type == NPCID_HEAVY_POWER)
    {
        int new_frame = 0;

        num_t min_dist = 0;
        for(int B = 1; B <= numPlayers; B++)
        {
            if(!Player[B].Dead && Player[B].Section == NPC[A].Section && Player[B].TimeToLive == 0)
            {
                auto L1_dist = num_t::abs(NPC[A].Location.minus_center_x(Player[B].Location)) + num_t::abs(NPC[A].Location.minus_center_y(Player[B].Location));
                if(min_dist == 0 || L1_dist < min_dist)
                {
                    min_dist = L1_dist;

                    if(Player[B].Character == 5)
                        new_frame = 1;
                    else
                        new_frame = 0;
                }
            }
        }

        if(new_frame != NPC[A].Frame)
        {
            if(NPC[A].FrameCount > 0)
                NewEffect(EFFID_SMOKE_S4, NPC[A].Location);

            NPC[A].Frame = new_frame;
        }

        NPC[A].FrameCount = 1;
    }
    else if(NPC[A].Type == NPCID_FLY_BLOCK || NPC[A].Type == NPCID_FLY_CANNON) // fly block
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].HoldingPlayer > 0)
            NPC[A].FrameCount += 1;
        if(NPC[A].Location.SpeedY != 0)
            NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount <= 6)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount <= 12)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount <= 18)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 24)
            NPC[A].Frame = 3;
        else if(NPC[A].FrameCount <= 30)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 36)
            NPC[A].Frame = 1;
        else
        {
            NPC[A].Frame = 0;
            NPC[A].FrameCount = 0;
        }
        if(NPC[A].Type == NPCID_FLY_CANNON && NPC[A].Direction == 1)
            NPC[A].Frame += 4;
    }
    else if(NPC[A].Type == NPCID_QUAD_SPITTER) // fire plant thing
    {
        if(NPC[A].Special == 0)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 0;
            else if(NPC[A].FrameCount < 16)
                NPC[A].Frame = 2;
            else
            {
                NPC[A].Frame = 0;
                NPC[A].FrameCount = 0;
            }
        }
        else if(NPC[A].Special == 1)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 0;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 1;
            else
            {
                NPC[A].Frame = 0;
                NPC[A].FrameCount = 0;
            }
        }
        else
            NPC[A].Frame = 3;
    }
    else if(NPC[A].Type == NPCID_DOOR_MAKER) // potion
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].Frame += 1;
            NPC[A].FrameCount = 0;
        }
        if(NPC[A].Frame >= 4)
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_ITEM_BUBBLE) // bubble
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount < 6)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 12)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount < 18)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 24)
            NPC[A].Frame = 2;
        else
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_VINE_BUG) // spider
    {
        if(NPC[A].Projectile || NPC[A].Location.SpeedY >= 0 || NPC[A].HoldingPlayer > 0)
            NPC[A].Frame = 0;
        else
            NPC[A].Frame = 2;
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount > 15)
            NPC[A].FrameCount = 0;
        else if(NPC[A].FrameCount >= 8)
            NPC[A].Frame += 1;
    }
    else if(NPC[A].Type == NPCID_BAT) // bat thing
    {
        if(NPC[A].Special == 0)
            NPC[A].Frame = 0;
        else
        {
            NPC[A].Frame = 1;
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount > 15)
                NPC[A].FrameCount = 0;
            else if(NPC[A].FrameCount >= 8)
                NPC[A].Frame = 2;
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 3;


    }
    else if(NPC[A].Type == NPCID_JUMP_PLANT) // jumping plant
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].Frame += 1;
            NPC[A].FrameCount = 0;
        }
        if(NPC[A].Frame >= 4)
            NPC[A].Frame = 0;

    }
    else if(NPC[A].Type == NPCID_FIRE_BOSS) // ludwig koopa
    {
        if(NPC[A].Location.SpeedY != 0 && !NPC[A].Wings)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 10;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 11;
            else
            {
                NPC[A].Frame = 10;
                NPC[A].FrameCount = 0;
            }
        }
        else
        {
            if(NPC[A].Special == 0)
            {
                NPC[A].FrameCount += 1;
                if(NPC[A].Location.SpeedX == 0)
                    NPC[A].FrameCount = 10;
                if(NPC[A].FrameCount < 4)
                    NPC[A].Frame = 0;
                else if(NPC[A].FrameCount < 8)
                    NPC[A].Frame = 1;
                else if(NPC[A].FrameCount < 12)
                    NPC[A].Frame = 2;
                else
                {
                    NPC[A].Frame = 0;
                    NPC[A].FrameCount = 0;
                }
            }
            else if(NPC[A].Special == 1)
                NPC[A].Frame = 3;
            else if(NPC[A].Special == 2)
                NPC[A].Frame = 4;
            if(NPC[A].Direction == 1)
                NPC[A].Frame += 5;
        }



    }
    else if(NPC[A].Type == NPCID_FIRE_BOSS_SHELL) // ludwig shell
    {
        if(NPC[A].Location.SpeedX == 0)
        {
            if(NPC[A].Frame > 2)
                NPC[A].Frame = 0;
        }
        else
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 4)
            {
                NPC[A].Frame += NPC[A].Direction;
                NPC[A].FrameCount = 0;
            }
            if(NPC[A].Frame < 0)
                NPC[A].Frame = 2;
            if(NPC[A].Frame > 2)
                NPC[A].Frame = 0;
        }

    }
    else if(NPC[A].Type == NPCID_FIRE_BOSS_FIRE) // ludwig fire
    {
        NPC[A].FrameCount += 1;
        NPC[A].Frame = 0;
        if(NPC[A].FrameCount > 8)
            NPC[A].FrameCount = 0;
        else if(NPC[A].FrameCount >= 4)
            NPC[A].Frame = 1;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 2;

    }
    else if(NPC[A].Type == NPCID_MAGIC_BOSS_BALL) // larry magic
    {
        if(NPC[A].Special == 0)
            NPC[A].Frame = 2;
        else if(NPC[A].Special == 1)
            NPC[A].Frame = 1;
        else
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_MAGIC_BOSS_SHELL) // larry shell
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].Frame += NPC[A].Direction;
            NPC[A].FrameCount = 0;
        }
        if(NPC[A].Frame < 0)
            NPC[A].Frame = 5;
        if(NPC[A].Frame > 5)
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_MAGIC_BOSS) // larry koopa
    {

        NPC[A].Frame = 0;
        if(NPC[A].Special == 0)
        {
            if(NPC[A].Location.SpeedY == 0)
            {
                if(NPC[A].Location.SpeedX == 0)
                    NPC[A].Frame = 0;
                else
                {
                    NPC[A].FrameCount += 1;
                    if(NPC[A].FrameCount < 8)
                        NPC[A].Frame = 0;
                    else if(NPC[A].FrameCount < 16)
                        NPC[A].Frame = 1;
                    else
                    {
                        NPC[A].Frame = 0;
                        NPC[A].FrameCount = 0;
                    }
                }
            }
            else
                NPC[A].Frame = 1;
        }
        else if(NPC[A].Special == 1)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 2)
                NPC[A].Frame = 2;
            else if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 3;
            else if(NPC[A].FrameCount < 6)
                NPC[A].Frame = 4;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 5;
            else
            {
                NPC[A].Frame = 2;
                NPC[A].FrameCount = 0;
            }
        }
        else if(NPC[A].Special == 2)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 2)
                NPC[A].Frame = 6;
            else if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 7;
            else if(NPC[A].FrameCount < 6)
                NPC[A].Frame = 8;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 9;
            else
            {
                NPC[A].Frame = 6;
                NPC[A].FrameCount = 0;
            }
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 10;


    }
    else if(NPC[A].Type == NPCID_SWORDBEAM) // sword beam
    {
        NPC[A].Frame = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 4;
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount < 2)
        {
        }
        else if(NPC[A].FrameCount < 4)
            NPC[A].Frame += 1;
        else if(NPC[A].FrameCount < 6)
            NPC[A].Frame += 2;
        else if(NPC[A].FrameCount < 8)
            NPC[A].Frame += 3;
        else
            NPC[A].FrameCount = 0;


    }
    else if(NPC[A].Type == NPCID_BOMBER_BOSS) // mouser
    {
        if(NPC[A].Immune > 0)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 3;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 4;
            else if(NPC[A].FrameCount < 12)
                NPC[A].Frame = 5;
            else if(NPC[A].FrameCount < 15)
                NPC[A].Frame = 6;
            else
            {
                NPC[A].Frame = 6;
                NPC[A].FrameCount = 0;
            }
            if(NPC[A].Direction == 1)
                NPC[A].Frame += 7;
        }
        else if(NPC[A].Special <= 0)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 1;
            else if(NPC[A].FrameCount < 15)
                NPC[A].Frame = 2;
            else
            {
                NPC[A].Frame = 2;
                NPC[A].FrameCount = 0;
            }
            if(NPC[A].Direction == 1)
                NPC[A].Frame += 7;
        }
        else
        {
            NPC[A].Frame = 0;
            if(NPC[A].Direction == 1)
                NPC[A].Frame += 7;
        }

    }
    else if(NPC[A].Type == NPCID_WALK_PLANT)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount < 8)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 15)
            NPC[A].Frame = 1;
        else
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 1;
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 4;
        if(NPC[A].Special > 0 && NPC[A].Location.SpeedY <= 0)
            NPC[A].Frame += 2;

    }
    else if(NPC[A].Type == NPCID_FIRE_CHAIN)
    {
        if(NPC[A].Direction == 1)
            NPC[A].Frame = SpecialFrame[2];
        else
            NPC[A].Frame = 3 - SpecialFrame[2];
    }
    else if(NPC[A].Type == NPCID_LOCK_DOOR)
    {
        // NPC has no frames so do nothing
    }
    else if(NPC[A].Type == NPCID_FIRE_DISK)
    {
        NPC[A].Frame += 1;
        if(NPC[A].Frame >= 5)
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_GEM_1 || NPC[A].Type == NPCID_GEM_5 || NPC[A].Type == NPCID_GEM_20)
        NPC[A].Frame = SpecialFrame[8];
    else if(NPC[A].Type == NPCID_TIME_SWITCH)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += 1;
        }
        if(NPC[A].Frame >= 3)
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_STACKER)
    {
        // Special less than zero - body, zero - head
        if(NPC[A].Special < 0 && NPC[A].Location.SpeedY == 0)
            NPC[A].Special += 1;
        if(NPC[A].Projectile || NPC[A].HoldingPlayer > 0)
            NPC[A].Frame = 4;
        else
        {
            if(NPC[A].Special < 0)
                NPC[A].Frame = 1;
            else
                NPC[A].Frame = 0;
        }
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 16)
            NPC[A].FrameCount = 0;
        else if(NPC[A].FrameCount > 8)
        {
            if(NPC[A].Projectile || NPC[A].HoldingPlayer > 0)
                NPC[A].Frame += 1;
            else
                NPC[A].Frame += 2;
        }
    }
    else if(NPC[A].Type == NPCID_FIRE_PLANT)
    {
        NPC[A].Frame = 0;
        if(Player[NPC[A].Special4].Location.to_right_of(NPC[A].Location))
            NPC[A].Frame = 2;
        if(Player[NPC[A].Special4].Location.Y + Player[NPC[A].Special4].Location.Height / 2 < NPC[A].Location.Y + 16)
            NPC[A].Frame += 1;
    }
    else if(NPC[A].Type == NPCID_FLY_FODDER_S5)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += 1;
            if(NPC[A].Frame >= 2)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_EARTHQUAKE_BLOCK) // POW block
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += 1;
            if(NPC[A].Frame >= 7)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_SLANT_WOOD_L) // 1 frame left or right
    {
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 1;
        else
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_HOMING_BALL_GEN)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount <= 6)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount <= 12)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount <= 18)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 24)
            NPC[A].Frame = 3;
        else if(NPC[A].FrameCount <= 30)
            NPC[A].Frame = 4;
        else if(NPC[A].FrameCount <= 36)
            NPC[A].Frame = 5;
        else if(NPC[A].FrameCount <= 42)
            NPC[A].Frame = 4;
        else if(NPC[A].FrameCount <= 48)
            NPC[A].Frame = 3;
        else if(NPC[A].FrameCount <= 54)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 60)
            NPC[A].Frame = 1;
        else
            NPC[A].FrameCount = 0;
    }
    else if(NPC[A].Type == NPCID_HOMING_BALL)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount <= 8)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount <= 16)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount <= 24)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 32)
            NPC[A].Frame = 3;
        else if(NPC[A].FrameCount <= 38)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 46)
            NPC[A].Frame = 1;
        else
            NPC[A].FrameCount = 0;
    }
    else if(NPC[A].Type == NPCID_BOSS_FRAGILE)
    {
        NPC[A].Frame = 0;
        if(NPC[A].Special > 0 && NPC[A].Special < 15)
            NPC[A].Frame = 1;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 2;
    }
    else if(NPC[A].Type == NPCID_BOSS_CASE)
    {
        if(NPC[A].Damage < 3)
            NPC[A].Frame = 0;
        else if(NPC[A].Damage < 6)
            NPC[A].Frame = 1;
        else if(NPC[A].Damage < 9)
            NPC[A].Frame = 2;
        else if(NPC[A].Damage < 12)
            NPC[A].Frame = 3;
        else
            NPC[A].Frame = 4;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 5;
    }
    else if(NPC[A].Type == NPCID_WALL_TURTLE)
    {
        NPC[A].FrameCount += 1;
        NPC[A].Frame = 0;
        if(NPC[A].FrameCount >= 16)
            NPC[A].FrameCount = 0;
        else if(NPC[A].FrameCount > 8)
            NPC[A].Frame = 1;
        if(NPC[A].Special == 4)
            NPC[A].Frame += 4;
        else if(NPC[A].Special == 3)
            NPC[A].Frame += 8;
        else if(NPC[A].Special == 2)
            NPC[A].Frame += 12;
        if(NPC[A].Special2 == 1)
            NPC[A].Frame += 2;


    }
    else if(NPC[A].Type == NPCID_WALL_BUG)
    {
        NPC[A].FrameCount += 1;
        NPC[A].Frame = 0;
        if(NPC[A].FrameCount <= 6)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount <= 12)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount <= 18)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 24)
            NPC[A].Frame = 3;
        else if(NPC[A].FrameCount <= 30)
            NPC[A].Frame = 4;
        else
            NPC[A].FrameCount = 0;
        if(NPC[A].Special == 4)
            NPC[A].Frame += 5;
        else if(NPC[A].Special == 3)
            NPC[A].Frame += 10;
        else if(NPC[A].Special == 2)
            NPC[A].Frame += 15;


    }
    else if(NPC[A].Type == NPCID_FLIER || NPC[A].Type == NPCID_ROCKET_FLIER)
    {
        NPC[A].FrameCount += 1;
        NPC[A].Frame = 0;
        if(NPC[A].FrameCount <= 6)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount <= 12)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount <= 18)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount <= 24)
            NPC[A].Frame = 1;
        else
            NPC[A].FrameCount = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 4;
    }
    else if(NPC[A].Type == NPCID_SICK_BOSS)
    {
        NPC[A].Frame = 0;
        if(NPC[A].Special == 0)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 0;
            else if(NPC[A].FrameCount < 16)
                NPC[A].Frame = 1;
            else
                NPC[A].FrameCount = 0;
        }
        else if(NPC[A].Special == 1)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 2;

        }
        else if(NPC[A].Special == 2)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 3;
            else if(NPC[A].FrameCount < 16)
                NPC[A].Frame = 4;
            else
            {
                NPC[A].Frame = 3;
                NPC[A].FrameCount = 0;
            }
        }

        if(NPC[A].Special == 3 || NPC[A].Special == 2)
        {
            NPC[A].Frame = 0;
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 5;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 6;
            else if(NPC[A].FrameCount < 12)
                NPC[A].Frame = 7;
            else
            {
                NPC[A].Frame = 7;
                NPC[A].FrameCount = 0;
            }
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 8;
    }
    else if(NPC[A].Type == NPCID_VILLAIN_S1) // King Koopa
    {
        NPC[A].Frame = 0;
        if(NPC[A].Special == 0)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount <= 8)
                NPC[A].Frame = 1;
            else if(NPC[A].FrameCount <= 16)
                NPC[A].Frame = 0;
            else if(NPC[A].FrameCount <= 24)
                NPC[A].Frame = 2;
            else if(NPC[A].FrameCount <= 32)
                NPC[A].Frame = 0;
            else
                NPC[A].FrameCount = 0;
        }
        else if(NPC[A].Special == 1)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 3;
        }
        else if(NPC[A].Special == 2)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 4;
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 5;
    }
    else if(NPC[A].Type == NPCID_STAR_COLLECT)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += 1;
            if(NPC[A].Frame >= 2)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_STONE_S4)
    {
        NPC[A].Frame = 0;

        if(NPC[A].Special == 1)
            NPC[A].Frame = 2;

        for(int B = 1; B <= numPlayers; ++B)
        {
            if(!CanComeOut(NPC[A].Location, Player[B].Location) && Player[B].Location.Y >= NPC[A].Location.Y)
            {
                NPC[A].Frame = 2;
                break;
            }
        }

        if(NPC[A].Frame == 0)
        {
            Location_t tempLocation = NPC[A].Location;
            tempLocation.Width = NPC[A].Location.Width * 2;
            tempLocation.X = NPC[A].Location.X - NPC[A].Location.Width / 2;

            for(int B = 1; B <= numPlayers; ++B)
            {
                if(!CanComeOut(tempLocation, Player[B].Location) && Player[B].Location.Y >= NPC[A].Location.Y)
                {
                    NPC[A].Frame = 1;
                    break;
                }
            }
        }
    }
    else if(NPC[A].Type == NPCID_CHAR4_HEAVY) // toad boomerang
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 6)
        {
            NPC[A].FrameCount = 0;

            if(NPC[A].Location.SpeedX > 0)
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame == 1)
                    NPC[A].Location.X += 4;
                else if(NPC[A].Frame == 3)
                    NPC[A].Location.X -= 4;
                else if(NPC[A].Frame == 2)
                    NPC[A].Location.Y += 4;
                else
                    NPC[A].Location.Y -= 4;
            }
            else
            {
                NPC[A].Frame -= 1;
                if(NPC[A].Frame == 0)
                    NPC[A].Location.X -= 4;
                else if(NPC[A].Frame == 1)
                    NPC[A].Location.Y -= 4;
                else if(NPC[A].Frame == 2)
                    NPC[A].Location.X += 4;
                else
                    NPC[A].Location.Y += 4;
            }

            if(NPC[A].Frame > 3)
                NPC[A].Frame = 0;
            else if(NPC[A].Frame < 0)
                NPC[A].Frame = 3;

            treeNPCUpdate(A);
            if(NPC[A].tempBlock > 0)
                treeNPCSplitTempBlock(A);
        }

        if(iRand(4) == 0)
            s_makeHeavySparkle(NPC[A], 4);
    }
    else if(NPC[A].Type == NPCID_PLR_HEAVY) // Mario Hammer
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 0;

            if(NPC[A].Location.SpeedX > 0)
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame == 1)
                    NPC[A].Location.X += 8;
                else if(NPC[A].Frame == 3)
                    NPC[A].Location.X -= 8;
                else if(NPC[A].Frame == 2)
                    NPC[A].Location.Y += 12;
                else
                    NPC[A].Location.Y -= 12;
            }
            else
            {
                NPC[A].Frame -= 1;
                if(NPC[A].Frame == 0)
                    NPC[A].Location.X -= 8;
                else if(NPC[A].Frame == 1)
                    NPC[A].Location.Y -= 12;
                else if(NPC[A].Frame == 2)
                    NPC[A].Location.X += 8;
                else
                    NPC[A].Location.Y += 12;
            }

            if(NPC[A].Frame > 3)
                NPC[A].Frame = 0;
            else if(NPC[A].Frame < 0)
                NPC[A].Frame = 3;

            treeNPCUpdate(A);
            if(NPC[A].tempBlock > 0)
                treeNPCSplitTempBlock(A);

            s_makeHeavySparkle(NPC[A], 8);
        }
    }
    else if(NPC[A].Type == NPCID_FLY_CARRY_FODDER) // smw paragoomba
    {
        NPC[A].FrameCount += 1;

        if(NPC[A].Direction == 1)
            NPC[A].Frame = 4;
        else
            NPC[A].Frame = 0;

        if(NPC[A].FrameCount >= 16)
            NPC[A].FrameCount = 0;
        else if(NPC[A].FrameCount >= 8)
            NPC[A].Frame += 1;

        if(NPC[A].Effect == NPCEFF_NORMAL)
        {
            if(NPC[A].Special == 0)
                NPC[A].Special2 += 2;
            else if(NPC[A].Special <= 60)
                NPC[A].Special2 = 0;
            else if(NPC[A].Special < 65)
                NPC[A].Special2 += 1;
            else
                NPC[A].Special2 += 2;

            if(NPC[A].Special2 >= 16)
                NPC[A].Special2 = 0;
            else if(NPC[A].Special2 >= 8)
                NPC[A].Frame += 2;
        }
    }
    else if(NPC[A].Type == NPCID_RED_FLY_FODDER || NPC[A].Type == NPCID_FLY_FODDER_S3) // Flying Goomba
    {
        if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 8)
            {
                NPC[A].FrameCount = 0;
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 2)
                    NPC[A].Frame = 0;
            }
        }
        else
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 4)
            {
                NPC[A].FrameCount = 0;
                if(NPC[A].Frame == 0)
                    NPC[A].Frame = 2;
                else if(NPC[A].Frame == 1)
                    NPC[A].Frame = 3;
                else if(NPC[A].Frame == 2)
                    NPC[A].Frame = 1;
                else if(NPC[A].Frame == 3)
                    NPC[A].Frame = 0;
            }
        }
    }
    else if(NPC[A].Type == NPCID_BOMB) // bomb
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount < 4)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 8)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount < 11)
            NPC[A].Frame = 2;
        else
            NPC[A].FrameCount = 0;
        if(NPC[A].Special2 == 1)
        {
            NPC[A].Special3 += 1;
            if(NPC[A].Special3 < 4)
            {
            }
            else if(NPC[A].Special3 < 8)
                NPC[A].Frame += 9;
            else if(NPC[A].Special3 < 12)
                NPC[A].Frame += 3;
            else if(NPC[A].Special3 < 15)
                NPC[A].Frame += 6;
            else
                NPC[A].Special3 = 0;
        }
    }
    else if(NPC[A].Type == NPCID_CHAR3_HEAVY) // heart bomb
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount < 4)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 8)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount < 11)
            NPC[A].Frame = 2;
        else
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 0;
        }

        NPC[A].Special3 += 1;
        if(NPC[A].Special3 < 4)
        {}
        else if(NPC[A].Special3 < 8)
            NPC[A].Frame += 3;
        else if(NPC[A].Special3 < 12)
            NPC[A].Frame += 6;
        else // If .Special3 >= 16 Then
            NPC[A].Special3 = 0;

        if(iRand(100) >= 92)
            s_makeHeavySparkle(NPC[A], 6);
    }
    else if(NPC[A].Type == NPCID_ITEM_BURIED)
        NPC[A].Frame = SpecialFrame[5];
    else if(NPC[A].Type == NPCID_ITEM_POD)
    {
        NPC[A].Frame = 0;
        if(NPC[A].Special == 98)
            NPC[A].Frame = 1;
        else if(NPC[A].Special == 99)
            NPC[A].Frame = 2;
        else if(NPC[A].Special == 100)
            NPC[A].Frame = 3;
        else if(NPC[A].Special == 148)
            NPC[A].Frame = 4;
        else if(NPC[A].Special == 149)
            NPC[A].Frame = 5;
        else if(NPC[A].Special == 150)
            NPC[A].Frame = 6;
        else if(NPC[A].Special == 228)
            NPC[A].Frame = 7;
    }
    else if(NPC[A].Type == NPCID_RAINBOW_SHELL || NPC[A].Type == NPCID_FLIPPED_RAINBOW_SHELL) // Glowy Shell
    {
        NPC[A].Special5 += 1;
        if(NPC[A].Special5 >= 16)
            NPC[A].Special5 = 0;
        if(NPC[A].Location.SpeedX > 0)
        {
            if(NPC[A].Type == NPCID_RAINBOW_SHELL)
                NPC[A].FrameCount += 1;
            else
                NPC[A].FrameCount -= 1;
        }
        else if(NPC[A].Location.SpeedX < 0)
        {
            if(NPC[A].Type == NPCID_RAINBOW_SHELL)
                NPC[A].FrameCount -= 1;
            else
                NPC[A].FrameCount += 1;
        }
        else
        {
            if(NPC[A].Type == NPCID_RAINBOW_SHELL)
                NPC[A].FrameCount = 0;
            else
                NPC[A].FrameCount = 12;
        }
        if(NPC[A].FrameCount < 0)
            NPC[A].FrameCount = 15;
        if(NPC[A].FrameCount >= 16)
            NPC[A].FrameCount = 0;
        if(NPC[A].FrameCount < 4)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 8)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount < 12)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount < 16)
            NPC[A].Frame = 3;
        if(NPC[A].Special5 < 4)
        {
        }
        else if(NPC[A].Special5 < 8)
            NPC[A].Frame += 4;
        else if(NPC[A].Special5 < 12)
            NPC[A].Frame += 8;
        else if(NPC[A].Special5 < 16)
            NPC[A].Frame += 12;
    }
    else if(NPC[A].Type == NPCID_JUMPER_S4) // black ninja
    {
        if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
        {
            NPC[A].Frame = 0;
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 12)
                NPC[A].FrameCount = 0;
            else if(NPC[A].FrameCount >= 6)
                NPC[A].Frame = 1;
        }
        else if(NPC[A].Location.SpeedY < 0)
        {
            NPC[A].Frame = 0;
            NPC[A].FrameCount = 6;
        }
        else
        {
            NPC[A].Frame = 1;
            NPC[A].FrameCount = 0;
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 2;
    }
    else if(NPC[A].Type == NPCID_CONVEYOR) // smb3 belt
    {
        if(NPC[A].Direction == -1)
            NPC[A].Frame = SpecialFrame[4];
        else
            NPC[A].Frame = 3 - SpecialFrame[4];
    }
    else if(NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM || NPC[A].Type == NPCID_GRN_PLATFORM || NPC[A].Type == NPCID_RED_PLATFORM)
    {
        NPC[A].Frame = 1;
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_CHASER) // Bully
    {
        NPC[A].Frame = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 3;

        if(NPC[A].Projectile || NPC[A].Special2 != 0)
        {
            NPC[A].Frame += 2;
            NPC[A].FrameCount = 0;
        }
        else
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 16)
                NPC[A].FrameCount = 0;
            else if(NPC[A].FrameCount >= 8)
                NPC[A].Frame += 1;
        }


    }
    else if(NPC[A].Type == NPCID_TANK_TREADS) // tank treads
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount >= 4)
            NPC[A].Frame = 1;
        else
            NPC[A].Frame = 0;
        if(NPC[A].FrameCount > 12)
            NPC[A].FrameCount = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 3;
    }
    else if(NPC[A].Type == NPCID_EXT_TURTLE) // nekkid koopa
    {
        if(NPC[A].Special == 0)
        {
            NPC[A].Frame = 0;
            if(NPC[A].Direction == 1)
                NPC[A].Frame = 3;
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 15)
                NPC[A].FrameCount = 0;
            else if(NPC[A].FrameCount >= 8)
                NPC[A].Frame += 1;
        }
        else
        {
            if(NPC[A].Direction == -1)
                NPC[A].Frame = 2;
            else
                NPC[A].Frame = 5;
        }
    }
    else if(NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4) // beach koopa
    {
        if(NPC[A].Projectile)
        {
            if(NPC[A].Location.SpeedX < -0.5_n || NPC[A].Location.SpeedX > 0.5_n)
                NPC[A].Frame = 3;
            else
            {
                NPC[A].Frame = 3;
                NPC[A].FrameCount += 1;
                if(NPC[A].FrameCount >= 15)
                    NPC[A].FrameCount = 0;
                else if(NPC[A].FrameCount >= 8)
                    NPC[A].Frame = 4;
            }
        }
        else
        {
            if(NPC[A].Special == 0)
            {
                NPC[A].Frame = 0;
                NPC[A].FrameCount += 1;
                if(NPC[A].FrameCount >= 15)
                    NPC[A].FrameCount = 0;
                else if(NPC[A].FrameCount >= 8)
                    NPC[A].Frame = 1;
            }
            else
                NPC[A].Frame = 2;
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 5;
    }
    else if(NPC[A].Type == NPCID_FLY) // bouncy bee
    {
        if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 0;
        }
        else
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 3)
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 2)
                    NPC[A].Frame = 0;
                NPC[A].FrameCount = 0;
            }
        }
    }
    else if(NPC[A].Type == NPCID_VEHICLE)
    {
        NPC[A].Frame = SpecialFrame[2];
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 4;
    }
    else if(NPC[A].Type == NPCID_SLIDE_BLOCK) // ice block
    {
        if(NPC[A].Special == 0)
            NPC[A].Frame = BlockFrame[4];
        else
        {
            if(NPC[A].Frame < 4)
                NPC[A].Frame = 4;
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 4)
            {
                NPC[A].FrameCount = 0;
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 6)
                    NPC[A].Frame = 4;
            }
        }
        // bowser fireball
    }
    else if(NPC[A].Type == NPCID_VILLAIN_FIRE)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 20)
            NPC[A].FrameCount = 0;
        // NPC[A].Frame = static_cast<int>(floor(static_cast<double>(NPC[A].FrameCount / 5)));
        // integer division now
        NPC[A].Frame = NPC[A].FrameCount / 5;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 4;
        // statue fireball
    }
    else if(NPC[A].Type == NPCID_STATUE_FIRE)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
            NPC[A].FrameCount = 0;
        // NPC[A].Frame = static_cast<int>(floor(static_cast<double>(NPC[A].FrameCount / 2)));
        // integer division now
        NPC[A].Frame = NPC[A].FrameCount / 2;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 4;
        // winged koopa
    }
    else if(NPC[A].Type == NPCID_GRN_FLY_TURTLE_S3 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S3)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].Direction == -1 && NPC[A].Frame >= 4)
            NPC[A].Frame = 0;
        else if(NPC[A].Direction == 1 && NPC[A].Frame < 4)
            NPC[A].Frame = 4;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 0;
            if(NPC[A].Direction == -1)
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 4)
                    NPC[A].Frame = 0;
            }
            else
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 8)
                    NPC[A].Frame = 4;
            }
        }
    }
    else if(NPC[A].Type == NPCID_LIT_BOMB_S3) // SMB3 Bomb
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount < 8)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 15)
            NPC[A].Frame = 1;
        else
        {
            NPC[A].Frame = 1;
            NPC[A].FrameCount = 0;
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 6;
        if(NPC[A].Special2 == 1)
        {
            NPC[A].Special3 += 1;
            if(NPC[A].Special3 < 4)
            {
            }
            else if(NPC[A].Special3 < 8)
                NPC[A].Frame += 2;
            else if(NPC[A].Special3 < 11)
                NPC[A].Frame += 4;
            else
            {
                NPC[A].Frame += 4;
                NPC[A].Special3 = 0;
            }
        }
    }
    else if(NPC[A].Type == NPCID_ROCKET_WOOD) // Airship Jet
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].Direction == -1 && NPC[A].Frame >= 4)
            NPC[A].Frame = 0;
        else if(NPC[A].Direction == 1 && NPC[A].Frame < 4)
            NPC[A].Frame = 8;
        if(NPC[A].FrameCount >= 2)
        {
            NPC[A].FrameCount = 0;
            if(NPC[A].Direction == -1)
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 4)
                    NPC[A].Frame = 0;
            }
            else
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 8)
                    NPC[A].Frame = 4;
            }
        }
    }
    else if(NPC[A].Type == NPCID_AXE)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += 1;
            if(NPC[A].Frame >= 3)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_GRN_TURTLE_S3 || NPC[A].Type == NPCID_RED_TURTLE_S3 || NPC[A].Type == NPCID_GLASS_TURTLE || NPC[A].Type == NPCID_SPIKY_S3 || NPC[A].Type == NPCID_SPIKY_S4 || NPC[A].Type == NPCID_GHOST_FAST || NPC[A].Type == NPCID_SIDE_PLANT || NPC[A].Type == NPCID_BIG_TURTLE || (NPC[A].Type >= NPCID_GRN_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_TURTLE_S4) || (NPC[A].Type >= NPCID_GRN_FLY_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_FLY_TURTLE_S4) || NPC[A].Type == NPCID_WALK_BOMB_S3 || NPC[A].Type == NPCID_LIFT_SAND || NPC[A].Type == NPCID_BRUTE || NPC[A].Type == NPCID_BRUTE_SQUISHED || NPC[A].Type == NPCID_BIG_GUY || NPC[A].Type == NPCID_CARRY_FODDER || NPC[A].Type == NPCID_HIT_CARRY_FODDER || NPC[A].Type == NPCID_GRN_TURTLE_S1 || NPC[A].Type == NPCID_RED_TURTLE_S1 || NPC[A].Type == NPCID_GRN_FLY_TURTLE_S1 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S1 || NPC[A].Type == NPCID_LAVA_MONSTER || NPC[A].Type == NPCID_GRN_FISH_S3 || NPC[A].Type == NPCID_YEL_FISH_S4 || NPC[A].Type == NPCID_RED_FISH_S3 || NPC[A].Type == NPCID_GRN_FISH_S4 || NPC[A].Type == NPCID_GRN_FISH_S1) // Walking koopa troopa / hard thing / spiney
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].Type == NPCID_HIT_CARRY_FODDER && NPC[A].Special > 360)
            NPC[A].FrameCount += 1;
        if(NPC[A].Direction == -1 && NPC[A].Frame >= 2)
            NPC[A].Frame = 0;
        else if(NPC[A].Direction == 1 && NPC[A].Frame < 2)
            NPC[A].Frame = 2;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].FrameCount = 0;
            if(NPC[A].Direction == -1)
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 2)
                    NPC[A].Frame = 0;
            }
            else
            {
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 4)
                    NPC[A].Frame = 2;
            }
        }

    }
    else if(NPC[A].Type == NPCID_BONE_FISH)
    {
        NPC[A].FrameCount += 1;
        NPC[A].Frame = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 3;

        if(NPC[A].FrameCount > 8)
            NPC[A].Frame += 1;

        if(NPC[A].FrameCount > 16)
            NPC[A].Frame += 1;
        if(NPC[A].FrameCount > 24)
            NPC[A].Frame -= 1;
        if(NPC[A].FrameCount > 32)
            NPC[A].FrameCount = 0;

    }
    else if(NPC[A].Type == NPCID_SKELETON) // dry bones
    {
        if(NPC[A].Special == 0)
        {
            NPC[A].FrameCount += 1;
            // was not commented in VB6, but it's obviously impossible
            // if(NPC[A].Type == NPCID_HIT_CARRY_FODDER && NPC[A].Special > 360)
            //     NPC[A].FrameCount += 1;
            if(NPC[A].Direction == -1 && NPC[A].Frame >= 2)
                NPC[A].Frame = 0;
            else if(NPC[A].Direction == 1 && NPC[A].Frame < 2)
                NPC[A].Frame = 2;
            if(NPC[A].FrameCount >= 8)
            {
                NPC[A].FrameCount = 0;
                if(NPC[A].Direction == -1)
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 2)
                        NPC[A].Frame = 0;
                }
                else
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 4)
                        NPC[A].Frame = 2;
                }
            }
        }
        else
        {
            if(NPC[A].Special2 < 10 || NPC[A].Special2 > 400 - 10)
                NPC[A].Frame = 4;
            else
                NPC[A].Frame = 5;
            if(NPC[A].Direction == 1)
                NPC[A].Frame += 2;
        }
    }
    else if(NPC[A].Type == NPCID_MEDAL) // dragon coin
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount < 6)
            NPC[A].Frame = 0;
        else if(NPC[A].FrameCount < 12)
            NPC[A].Frame = 1;
        else if(NPC[A].FrameCount < 18)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount < 24)
            NPC[A].Frame = 3;
        else if(NPC[A].FrameCount < 30)
            NPC[A].Frame = 2;
        else if(NPC[A].FrameCount < 36)
            NPC[A].Frame = 1;
        else
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_ITEMGOAL) // Frame finder for Star/Flower/Mushroom Exit
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += 1;
            if(NPC[A].Frame == 3)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_TOOTHY) // killer plant
    {
        // .vehiclePlr = A
        NPC[A].Frame = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 2;
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
            NPC[A].Frame += 1;
        if(NPC[A].FrameCount >= 16)
            NPC[A].FrameCount = 0;
    }
    else if(NPC[A].Type == NPCID_TOOTHYPIPE) // killer pipe
    {
        if(NPC[A].HoldingPlayer == 0 && !Player[NPC[A].vehiclePlr].Controls.Run && !NPC[A].Projectile)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 4)
            {
                NPC[A].Frame += 1;
                NPC[A].FrameCount = 0;
            }
            if(NPC[A].Frame >= 5)
                NPC[A].Frame = 0;
        }
        else
        {
            if(NPC[A].Direction == -1)
            {
                NPC[A].FrameCount += 1;
                if(NPC[A].FrameCount >= 4)
                {
                    NPC[A].Frame += 1;
                    NPC[A].FrameCount = 0;
                }
                if(NPC[A].Frame >= 10 || NPC[A].Frame < 5)
                    NPC[A].Frame = 5;
            }
            else
            {
                NPC[A].FrameCount += 1;
                if(NPC[A].FrameCount >= 4)
                {
                    NPC[A].Frame += 1;
                    NPC[A].FrameCount = 0;
                }
                if(NPC[A].Frame >= 15 || NPC[A].Frame < 10)
                    NPC[A].Frame = 10;
            }
        }
    }
    else if(NPC[A].Type == NPCID_LAVABUBBLE) // Frame finder for big fireball
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += 1;
            if(NPC[A].Location.SpeedY < 0)
            {
                if(NPC[A].Frame >= 2)
                    NPC[A].Frame = 0;
            }
            else
            {
                if(NPC[A].Frame >= 4)
                    NPC[A].Frame = 2;
            }
        }
    }
    else if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_HEAVY_THROWN || NPC[A].Type == NPCID_PLANT_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL) // Frame finder for Fireball / Hammer
    {
        if((NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL) && NPC[A].Quicksand == 0)
        {
            Location_t tempLocation;
            bool make_trail = true;

            if(NPC[A].Wet > 0)
            {
                if(iRand(20) == 0)
                {
                    tempLocation = newLoc(NPC[A].Location.X + 4, NPC[A].Location.Y + 4, 8, 8);
                    if(!UnderWater[NPC[A].Section])
                    {
                        // set NewNpc to 0 -- pop when no longer in water
                        NewEffect(EFFID_AIR_BUBBLE, tempLocation, 1, NPC[A].Shadow);
                    }
                    else
                    {
                        // set NewNpc to 1 -- keep forever
                        if(NewEffect(EFFID_AIR_BUBBLE, tempLocation, 1, NPC[A].Shadow))
                            Effect[numEffects].NewNpc = 1;
                    }
                }

                if(iRand(100) >= 85)
                    make_trail = true;
                else
                    make_trail = false;
            }

            if(make_trail)
            {
                if(NPC[A].Type == NPCID_PLR_ICEBALL)
                {
                    if(NPC[A].Special == 5)
                    {
                        NewEffect(EFFID_PLR_ICEBALL_TRAIL, NPC[A].Location, 1, NPC[A].Shadow);
                        if(iRand(5) == 0)
                        {
                            tempLocation.Height = EffectHeight[EFFID_SPARKLE];
                            tempLocation.Width = EffectWidth[EFFID_SPARKLE];
                            tempLocation.SpeedX = 0;
                            tempLocation.SpeedY = 0;
                            tempLocation.X = NPC[A].Location.X + dRand() * 16 - EffectWidth[EFFID_SPARKLE] * 0.5_n - 4 - NPC[A].Location.SpeedX * 3;
                            tempLocation.Y = NPC[A].Location.Y + dRand() * 16 - EffectHeight[EFFID_SPARKLE] * 0.5_n - 4;
                            NewEffect(EFFID_SPARKLE, tempLocation);
                            Effect[numEffects].Location.SpeedX = NPC[A].Location.SpeedX / 2;
                            Effect[numEffects].Location.SpeedY = NPC[A].Location.SpeedY / 2;
                            Effect[numEffects].Frame = iRand(3);
                        }
                    }
                    else if(iRand(5) >= 3)
                    {
                        NewEffect_IceSparkle(NPC[A], tempLocation);
                        Effect[numEffects].Location.SpeedX = NPC[A].Location.SpeedX / 4;
                        Effect[numEffects].Location.SpeedY = NPC[A].Location.SpeedY / 4;
                        Effect[numEffects].Frame = iRand(3);
                    }
                }
                else
                    NewEffect(EFFID_PLR_FIREBALL_TRAIL, NPC[A].Location, NPC[A].Special, NPC[A].Shadow);
            }
        }

        NPC[A].FrameCount += 1;

        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 0;
            NPC[A].Frame += -NPC[A].Direction;
        }

        if(NPC[A].Special < 2 || (NPC[A].Type == NPCID_PLR_ICEBALL && NPC[A].Special != 5))
        {
            if(NPC[A].Frame >= 4)
                NPC[A].Frame = 0;
            if(NPC[A].Frame < 0)
                NPC[A].Frame = 3;
        }
        else if(NPC[A].Special == 2 || (NPC[A].Type == NPCID_PLR_ICEBALL && NPC[A].Special == 5))
        {
            if(NPC[A].Frame >= 7)
                NPC[A].Frame = 4;
            if(NPC[A].Frame < 4)
                NPC[A].Frame = 6;
        }
        else if(NPC[A].Special == 3)
        {
            if(NPC[A].Frame >= 11)
                NPC[A].Frame = 8;
            if(NPC[A].Frame < 8)
                NPC[A].Frame = 10;
        }
        else if(NPC[A].Special == 4)
        {
            if(NPC[A].Frame >= 15)
                NPC[A].Frame = 12;
            if(NPC[A].Frame < 12)
                NPC[A].Frame = 14;
        }
        else if(NPC[A].Special == 5)
        {
            if(NPC[A].Frame >= 19)
                NPC[A].Frame = 16;
            if(NPC[A].Frame < 16)
                NPC[A].Frame = 18;
        }
    }
    else if(NPC[A].Type == NPCID_MINIBOSS) // Frame finder for Big Koopa
    {
        if(NPC[A].Special == 0)
        {
            if(NPC[A].Location.SpeedY != 0)
                NPC[A].Frame = 0;
            else
            {
                if(NPC[A].FrameCount >= 0)
                    NPC[A].FrameCount += 1;
                else
                    NPC[A].FrameCount -= 1;
                if(NPC[A].FrameCount >= 5 || NPC[A].FrameCount <= -5)
                {
                    if(NPC[A].FrameCount >= 0)
                    {
                        NPC[A].Frame += 1;
                        NPC[A].FrameCount = 1;
                    }
                    else
                    {
                        NPC[A].Frame -= 1;
                        NPC[A].FrameCount = -1;
                    }
                    if(NPC[A].Frame >= 5)
                    {
                        NPC[A].Frame = 3;
                        NPC[A].FrameCount = -1;
                    }
                    else if(NPC[A].Frame <= 0)
                    {
                        NPC[A].Frame = 2;
                        NPC[A].FrameCount = 1;
                    }
                }
            }
        }
        else if(NPC[A].Special == 1)
            NPC[A].Frame = 6;
        else if(NPC[A].Special == 4)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].Frame < 7)
                NPC[A].Frame = 7;
            if(NPC[A].FrameCount >= 8)
            {
                NPC[A].FrameCount = 0;
                if(NPC[A].Frame == 7)
                    NPC[A].Frame = 8;
                else
                    NPC[A].Frame = 7;
            }
        }
        else
            NPC[A].Frame = 5;
    }
    else if(NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_STONE_S4) // Thwomp
    {
        // Bullet Bills / Key / ONLY DIRECTION FRAMES
    }
    else if(NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_BIG_BULLET || NPC[A].Type == NPCID_KEY || NPC[A].Type == NPCID_STATUE_S3 || NPC[A].Type == NPCID_CIVILIAN || NPC[A].Type == NPCID_CHAR3 || NPCIsYoshi(NPC[A].Type) || NPC[A].Type == NPCID_CHAR2 || NPC[A].Type == NPCID_CHAR5 || NPC[A].Type == NPCID_STATUE_S4)
    {
        if(NPC[A].Direction == -1)
            NPC[A].Frame = 0;
        else
            NPC[A].Frame = 1;
        // Leaf
    }
    else if(NPC[A].Type == NPCID_LEAF_POWER)
    {
        if(NPC[A].Direction == -1)
            NPC[A].Frame = 1;
        else
            NPC[A].Frame = 0;
    }
    else if(NPC[A].Type == NPCID_BLU_GUY || NPC[A].Type == NPCID_RED_GUY || NPC[A].Type == NPCID_RED_FISH_S1 || (NPC[A].Type >= NPCID_BIRD && NPC[A].Type <= NPCID_GRY_SPIT_GUY) || NPC[A].Type == NPCID_WALK_BOMB_S2 || NPC[A].Type == NPCID_CARRY_BUDDY) // Shy guys / Jumping Fish
    {
        if(NPC[A].Type == NPCID_WALK_BOMB_S2 && NPC[A].Special2 == 1)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 8;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 9;
            else if(NPC[A].FrameCount < 11)
                NPC[A].Frame = 10;
            else
            {
                NPC[A].Frame = 10;
                NPC[A].FrameCount = 0;
            }
            if(NPC[A].HoldingPlayer > 0 || NPC[A].Projectile)
                NPC[A].Frame += 6;
            if(NPC[A].Direction == 1)
                NPC[A].Frame += 3;
        }
        else if(NPC[A].HoldingPlayer == 0 && !NPC[A].Projectile)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].Direction == -1 && NPC[A].Frame >= 2)
                NPC[A].Frame = 0;
            else if(NPC[A].Direction == 1 && NPC[A].Frame < 2)
                NPC[A].Frame = 2;
            if(NPC[A].FrameCount >= 8)
            {
                NPC[A].FrameCount = 0;
                if(NPC[A].Direction == -1)
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 2)
                        NPC[A].Frame = 0;
                }
                else
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 4)
                        NPC[A].Frame = 2;
                }
            }
        }
        else
        {
            if(NPC[A].Frame < 4)
                NPC[A].Frame = 4;
            NPC[A].FrameCount += 1;
            if(NPC[A].Direction == -1 && NPC[A].Frame >= 6)
                NPC[A].Frame = 4;
            else if(NPC[A].Direction == 1 && NPC[A].Frame < 6)
                NPC[A].Frame = 6;
            if(NPC[A].FrameCount >= 4)
            {
                NPC[A].FrameCount = 0;
                if(NPC[A].Direction == -1)
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 6)
                        NPC[A].Frame = 4;
                }
                else
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 8)
                        NPC[A].Frame = 6;
                }
            }
        }
    }
    else if(NPC[A].Type == NPCID_JUMPER_S3) // Bouncy Star things
    {
        if(NPC[A].HoldingPlayer == 0 && !NPC[A].Projectile)
        {
            if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
            {
                if(NPC[A].Direction == -1)
                    NPC[A].Frame = 0;
                else if(NPC[A].Direction == 1)
                    NPC[A].Frame = 2;
            }
            else
            {
                if(NPC[A].Direction == -1)
                    NPC[A].Frame = 1;
                else if(NPC[A].Direction == 1)
                    NPC[A].Frame = 3;
            }
        }
        else
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].Direction == -1 && NPC[A].Frame >= 6)
                NPC[A].Frame = 4;
            else if(NPC[A].Direction == 1 && NPC[A].Frame < 6)
                NPC[A].Frame = 6;
            if(NPC[A].FrameCount >= 4)
            {
                NPC[A].FrameCount = 0;
                if(NPC[A].Direction == -1)
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 6)
                        NPC[A].Frame = 4;
                }
                else
                {
                    NPC[A].Frame += 1;
                    if(NPC[A].Frame >= 8)
                        NPC[A].Frame = 6;
                }
            }
        }
    }
    else if(NPC[A].Type == NPCID_CANNONITEM) // Bullet bill Gun
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 1;
            NPC[A].Frame += 1;
            if(NPC[A].Frame == 5)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_PINK_CIVILIAN)
    {
        if(NPC[A].Location.SpeedX == 0)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 0;
            else if(NPC[A].FrameCount < 7)
                NPC[A].Frame = 1;
            else
            {
                NPC[A].Frame = 1;
                NPC[A].FrameCount = 0;
            }
        }
        else
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount < 4)
                NPC[A].Frame = 0;
            else if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 1;
            else if(NPC[A].FrameCount < 12)
                NPC[A].Frame = 2;
            else if(NPC[A].FrameCount < 15)
                NPC[A].Frame = 3;
            else
            {
                NPC[A].Frame = 3;
                NPC[A].FrameCount = 0;
            }
        }
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 4;
    }
    else if(NPC[A].Type == NPCID_SPRING) // Spring thing
    {
        if(!LevelEditor)
        {
            if(NPC[A].Location.Height == 32)
            {
                NPC[A].Location.Height = 16;
                NPC[A].Location.Y += 16;
            }
            if(NPC[A].HoldingPlayer > 0)
                NPC[A].Frame = 0;
            else
            {
                int C = 0;
                Location_t tempLocation = NPC[A].Location;
                tempLocation.Height = 24;
                tempLocation.Y -= 8;
                for(int B = 1; B <= numPlayers; ++B)
                {
                    if(CheckCollision(tempLocation, Player[B].Location) && Player[B].Mount != 2 && (Player[B].Location.SpeedY > 0 || Player[B].Location.SpeedY < Physics.PlayerJumpVelocity))
                    {
                        C = 2;
                        break;
                    }
                }
                if(C == 0)
                {
                    tempLocation = NPC[A].Location;
                    tempLocation.Height = 32;
                    tempLocation.Y -= 16;
                    for(int B = 1; B <= numPlayers; ++B)
                    {
                        if(CheckCollision(tempLocation, Player[B].Location) && Player[B].Mount != 2 && (Player[B].Location.SpeedY > 0 || Player[B].Location.SpeedY < Physics.PlayerJumpVelocity))
                        {
                            C = 1;
                            break;
                        }
                    }
                }
                NPC[A].Frame = C;
            }
        }
    }
    else if(NPC[A].Type == NPCID_SPIT_BOSS) // birdo
    {
        NPC[A].Frame = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 5;

        // changed from Special when it became a container
        if(NPC[A].Special5 == 0)
        {
            if(NPC[A].Location.SpeedX != 0)
            {
                NPC[A].FrameCount += 1;
                if(NPC[A].FrameCount > 12)
                    NPC[A].FrameCount = 0;
                else if(NPC[A].FrameCount >= 6)
                    NPC[A].Frame += 1;
            }
        }
        else if(NPC[A].Special5 < 0)
        {
            NPC[A].Frame += 3;
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount > 8)
                NPC[A].FrameCount = 0;
            else if(NPC[A].FrameCount >= 4)
                NPC[A].Frame += 1;
        }
        else
            NPC[A].Frame += 2;
    }
    else if(NPC[A].Type == NPCID_KNIGHT) // Rat Head
    {
        NPC[A].Frame = NPC[A].FrameCount;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 2;
    }
    else if(NPC[A].Type == NPCID_HEAVY_THROWER) // SMB Hammer Bro
    {
        // the throw counter was previously Special3, and it has been moved to SpecialX
        if(NPC[A].SpecialX >= 0)
        {
            if((NPC[A].Location.SpeedY < 1 && NPC[A].Location.SpeedY >= 0) || NPC[A].Slope > 0 || NPC[A].HoldingPlayer > 0)
            {
                NPC[A].FrameCount += 1;
                if(NPC[A].Direction == -1 && NPC[A].Frame >= 2)
                    NPC[A].Frame = 0;
                else if(NPC[A].Direction == 1 && NPC[A].Frame < 3)
                    NPC[A].Frame = 3;
                if(NPC[A].FrameCount >= 8)
                {
                    NPC[A].FrameCount = 0;
                    if(NPC[A].Direction == -1)
                    {
                        NPC[A].Frame += 1;
                        if(NPC[A].Frame >= 2)
                            NPC[A].Frame = 0;
                    }
                    else
                    {
                        NPC[A].Frame += 1;
                        if(NPC[A].Frame >= 5)
                            NPC[A].Frame = 3;
                    }
                }
            }
            else
            {
                if(NPC[A].Direction == -1)
                    NPC[A].Frame = 0;
                else
                    NPC[A].Frame = 3;
            }
        }
        else
        {
            if(NPC[A].Direction == -1)
                NPC[A].Frame = 2;
            else
                NPC[A].Frame = 5;
        }
    }
    else if(NPC[A].Type == NPCID_PET_FIRE) // Yoshi Fireball
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].Frame = 1;
            NPC[A].FrameCount = 0;
        }
        else if(NPC[A].FrameCount > 4)
            NPC[A].Frame = 1;
        else
            NPC[A].Frame = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame += 2;
    }
    else if(NPC[A].Type == NPCID_GRN_BOOT || NPC[A].Type == NPCID_RED_BOOT || NPC[A].Type == NPCID_BLU_BOOT) // Goombas Shoe
    {
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 2 + SpecialFrame[1];
        else
            NPC[A].Frame = 0 + SpecialFrame[1];
    }
    else if(NPC[A].Type == NPCID_GHOST_S3 || NPC[A].Type == NPCID_GHOST_S4 || NPC[A].Type == NPCID_BIG_GHOST) // Boo
    {
        NPC[A].Frame = 0;
        if(NPC[A].Direction == 1)
            NPC[A].Frame = 2;
        if(NPC[A].Special == 1 || NPC[A].HoldingPlayer > 0)
            NPC[A].Frame += 1;
    }
    else if(NPC[A].Type == NPCID_GOALORB_S2) // smb2 birdo exit
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].FrameCount = 1;
            NPC[A].Frame += 1;
            if(NPC[A].Frame == 8)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_STAR_EXIT) // SMB3 Star
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].Special == 0)
        {
            if(NPC[A].FrameCount < 8)
                NPC[A].Frame = 0;
            else if(NPC[A].FrameCount < 12)
                NPC[A].Frame = 1;
            else if(NPC[A].FrameCount < 16)
                NPC[A].Frame = 2;
            else if(NPC[A].FrameCount < 20)
                NPC[A].Frame = 1;
            else
                NPC[A].FrameCount = 0;
        }
        else
        {
            if(NPC[A].FrameCount < 60)
                NPC[A].Frame = 2;
            // ElseIf .FrameCount < 64 Then
            // .Frame = 1
            else
                NPC[A].FrameCount = 0;
        }
    }
    else if(NPC[A].Type == NPCID_FIRE_POWER_S4 || NPC[A].Type == NPCID_ICE_POWER_S4)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 12)
        {
            NPC[A].FrameCount = 1;
            NPC[A].Frame += 1;
            if(NPC[A].Frame == 2)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_FIRE_POWER_S1)
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 4)
        {
            NPC[A].FrameCount = 1;
            NPC[A].Frame += 1;
            if(NPC[A].Frame == 4)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_SPIKY_BALL_S3 || NPC[A].Type == NPCID_WALL_SPARK)
    {
        NPC[A].FrameCount += 2;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].FrameCount = 1;
            NPC[A].Frame += 1;
            if(NPC[A].Frame == 2)
                NPC[A].Frame = 0;
        }
    }
    else if(NPC[A].Type == NPCID_COIN_S2)
    {
        NPC[A].Frame = CoinFrame[2];
    }
    else if(NPC[A].Type == NPCID_RING)
    {
        NPC[A].Frame = CoinFrame[3];
    }
    // non-type based logic
    else if(NPC[A]->IsACoin) // Coin
    {
        NPC[A].Frame = CoinFrame[3];
    }
    else if(NPC[A]->IsAVine || NPC[A]->IsABonus) // no frames for these
    {
        if(A == 0)
            NPC[A].Frame = 0;
    }
    else if(NPC[A]->IsAShell) // Turtle shell
    {
        if(NPC[A].Location.SpeedX == 0)
            NPC[A].Frame = 0;
        else
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount >= 4)
            {
                NPC[A].FrameCount = 0;
                NPC[A].Frame += 1;
                if(NPC[A].Frame >= 4)
                    NPC[A].Frame = 0;
            }
        }
    }
    else // Frame finder for everything else
    {
        NPC[A].FrameCount += 1;
        if(NPC[A].FrameCount >= 8)
        {
            NPC[A].FrameCount = 1;
            NPC[A].Frame += 1;
            if(NPC[A].Frame == 2)
                NPC[A].Frame = 0;
        }
    }
}


================================================
FILE: src/npc/npc_hit.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#include "../globals.h"
#include "../npc.h"
#include "../sound.h"
#include "../collision.h"
#include "../effect.h"
#include "../editor.h"
#include "../game_main.h"
#include "../blocks.h"
#include "../graphics.h"
#include "../npc_id.h"
#include "../eff_id.h"
#include "../layers.h"

#include "npc_traits.h"

#include "npc/npc_queues.h"
#include "main/trees.h"

#include <Logger/logger.h>

void NPCHit(int A, int B, int C)
{
    // NPC_t tempNPC;
    // Location_t tempLocation;

    // if(B == 1 && C != 0)
    //     Controls::Rumble(C, 50, .25);

    // ------+  HIT CODES  +-------
    // B = 1      Jumped on by a player (or kicked)
    // B = 2      Hit by a shaking block
    // B = 3      Hit by projectile
    // B = 4      Hit something as a projectile
    // B = 5      Hit something while being held
    // B = 6      Touched a lava block
    // B = 7      Hit by a tail
    // B = 8      Stomped by Boot
    // B = 9      Fell of a cliff
    // B = 10     Link stab
    // Frost Bolt check
    if(B == 3 && NPC[A].Type != NPCID_ICE_CUBE && NPC[A].Type != NPCID_PLR_ICEBALL)
    {
        if(NPC[C].Type == NPCID_PLR_ICEBALL && NPC[A].Location.Width > 8 && NPC[A].Location.Height > 8)
        {
            if(NPC[A].Type == NPCID_ITEM_BUBBLE)
            {
                if(NPC[3].Type == NPCID_PLR_ICEBALL)
                {
                    // FIXME: warn user that game would have crashed

                    if(NPC[0].Type == NPCID_PLR_ICEBALL)
                        NPC[0].Type = NPCID_PLR_FIREBALL;

                    NPCHit(A, 3, 0);
                }
                else
                {
                    // B is always 3, this caused a crash if NPC[3].Type was NPCID_PLR_ICEBALL
                    NPCHit(A, 3, B);
                }
            }

            if(NPC[A]->NoIceBall || NPC[A].Location.Width > 128 || NPC[A].Location.Height > 128)
                return;

            bool reset_frame = true;

            if(NPC[A].Type == NPCID_RED_FLY_FODDER)
                NPC[A].Type = NPCID_RED_FODDER;
            else if(NPC[A].Type == NPCID_GRN_TURTLE_S3)
                NPC[A].Type = NPCID_GRN_SHELL_S3;
            else if(NPC[A].Type == NPCID_RED_TURTLE_S3 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S3)
                NPC[A].Type = NPCID_RED_SHELL_S3;
            else if(NPC[A].Type == NPCID_BIG_TURTLE)
                NPC[A].Type = NPCID_BIG_SHELL;
            else if(NPC[A].Type == NPCID_GRN_FLY_TURTLE_S3)
                NPC[A].Type = NPCID_GRN_SHELL_S3;
            else if(NPC[A].Type == NPCID_GRN_TURTLE_S4 || NPC[A].Type == NPCID_GRN_FLY_TURTLE_S4)
                NPC[A].Type = NPCID_GRN_SHELL_S4;
            else if(NPC[A].Type == NPCID_RED_TURTLE_S4 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S4)
                NPC[A].Type = NPCID_RED_SHELL_S4;
            else if(NPC[A].Type == NPCID_BLU_TURTLE_S4 || NPC[A].Type == NPCID_BLU_FLY_TURTLE_S4)
                NPC[A].Type = NPCID_BLU_SHELL_S4;
            else if(NPC[A].Type == NPCID_YEL_TURTLE_S4 || NPC[A].Type == NPCID_YEL_FLY_TURTLE_S4)
                NPC[A].Type = NPCID_YEL_SHELL_S4;
            else if(NPC[A].Type == NPCID_RED_TURTLE_S1 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S1)
                NPC[A].Type = NPCID_RED_SHELL_S1;
            else if(NPC[A].Type == NPCID_GRN_TURTLE_S1 || NPC[A].Type == NPCID_GRN_FLY_TURTLE_S1)
                NPC[A].Type = NPCID_GRN_SHELL_S1;
            else if(NPC[A].Type == NPCID_FLY_FODDER_S5)
                NPC[A].Type = NPCID_FODDER_S5;
            else if(NPC[A].Type == NPCID_FLY_FODDER_S3)
                NPC[A].Type = NPCID_FODDER_S3;
            else
                reset_frame = false;

            if(reset_frame)
                NPC[A].Frame = EditorNPCFrame(NPC[A].Type, NPC[A].Direction);

            NPC[A].Wings = WING_NONE;

            NPC[A].Special = NPC[A].Type;
            NPC[A].Special2 = NPC[A].Frame;
            // If .Type = 52 Or .Type = 51 Then
            // End If

            if(NPC[A].Type == NPCID_SIDE_PLANT)
            {
                if(NPC[A].Direction == -1)
                    NPC[A].Location.Width = num_t::floor(NPC[A].Location.Width) - 0.01_n;
                else
                    NPC[A].Location.X = num_t::floor(NPC[A].Location.X) + 0.01_n;

                NPCQueues::Unchecked.push_back(A);
            }

            NPC[A].Location.Height = num_t::floor(NPC[A].Location.Height);
            NPC[A].Type = NPCID_ICE_CUBE;
            NPC[A].BeltSpeed = 0;
            NPC[A].RealSpeedX = 0;
            NPC[A].Projectile = false;

            if(NPC[A].Effect == NPCEFF_MAZE)
            {
                // disable no-gravity for an item frozen within a maze
                NPC[A].Special3 = 0;
                NPC[A].Projectile = true;

                if(NPC[A].Effect3 != NPC[C].Effect3)
                    NPC[A].TurnAround = true;
            }
            else
            {
                // this freezes the item in mid-air until it's grabbed
                NPC[A].Special3 = 1;
                NPC[A].Location.SpeedY = 0;
                NPC[A].Location.SpeedX = 0;
            }

            NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            Location_t tempLocation;
            for(C = 1; C <= 20; C++)
            {
                NewEffect_IceSparkle(NPC[A], tempLocation);
                Effect[numEffects].Location.SpeedX = dRand() * 2 - 1;
                Effect[numEffects].Location.SpeedY = dRand() * 2 - 1;
                Effect[numEffects].Frame = iRand(3);
            }

            PlaySoundSpatial(SFX_Freeze, NPC[A].Location);
            // NPCHit C, 3, C

            treeNPCUpdate(A);
            if(NPC[A].tempBlock > 0)
                treeNPCSplitTempBlock(A);
            return;
        }
    }

    // Online code
    //    if(nPlay.Online == true)
    //    {
    //        if(B == 1 || B == 7 || B == 8)
    //        {
    //            if(C == nPlay.MySlot + 1 || nPlay.Allow == true || C <= 0)
    //            {
    //                if(C == nPlay.MySlot + 1)
    //                    Netplay::sendData "2d" + std::to_string(A) + "|" + std::to_string(B) + "|" + std::to_string(C) + "|" + NPC[A].Type + LB;
    //            }
    //            else
    //                return;
    //        }
    //    }

    if(!NPC[A].Active)
        return;


    // Safety
    StopHit += 1;
    if(NPC[A].Killed > 0)
        return;
    if(B == 3 || B == 4)
    {
        if(NPC[C].Generator)
            return;
    }
    if((NPC[A].Type == NPCID_SQUID_S1 || NPC[A].Type == NPCID_SQUID_S3 || NPC[A]->IsFish) && B == 1)
    {
        if(Player[C].Wet > 0)
            return;
    }
    if(NPC[A].Inert || StopHit > 2 || NPC[A].Immune > 0 || NPC[A].Effect == NPCEFF_ENCASED || NPC[A].Generator)
        return;
    if(B == 3 || B == 4 || B == 5) // Things immune to fire
    {
        if(NPC[C].Type == NPCID_PLR_FIREBALL)
        {
            if(NPC[A]->NoFireBall)
                return;
        }
    }


    if(B == 1 && NPC[A]->JumpHurt && NPC[A].Type != NPCID_ITEM_BUBBLE) // Things that don't die from jumping
        return;

    if(B == 10 && NPC[A].Type == NPCID_KEY)
    {
        if(Player[C].Character == 5 && !Player[C].HasKey)
        {
            NPC[A].Killed = 9;
            NPCQueues::Killed.push_back(A);
            Player[C].HasKey = true;
            PlaySoundSpatial(SFX_HeroKey, NPC[A].Location);
            return;
        }
    }

    // NEWLY used to check when NPC's tree location needs to be updated
    NPC_t oldNPC = NPC[A];

    // BEGIN NORMAL LOGIC: giant switch over NPC's type

    // Yoshi Ice
    if(NPC[A].Type == NPCID_ICE_BLOCK)
    {
        if(B != 1 && B != 7 && B != 8 && B != 4)
            NPC[A].Killed = B;
    }
    // Frozen NPC
    else if(NPC[A].Type == NPCID_ICE_CUBE)
    {
        if(B == 3 && NPC[C].Type == NPCID_PLR_FIREBALL)
        {
            NPC[A].Type = NPCID(NPC[A].Special);

            if(NPC[A].Location.SpeedX > 0)
                NPC[A].Direction = 1;
            else if(NPC[A].Location.SpeedX < 0)
                NPC[A].Direction = -1;
            else
                NPC[A].Direction = NPC[A].DefaultDirection;

            NPC[A].Frame = EditorNPCFrame(NPC[A].Type, NPC[A].Direction);
            NPC[A].Special = NPC[A].DefaultSpecial;
            NPC[A].Special2 = 0;
            NPC[A].Special3 = 0;
            NPC[A].Special4 = 0;
            NPC[A].Special5 = 0;
            // NPC[A].Special6 = 0;
            NPC[A].SpecialX = 0;
            NPC[A].SpecialY = 0;

            if(NPC[A].Effect == NPCEFF_MAZE)
                NPC[A].Projectile = false;
        }
        else if(B == 3 || B == 5)
        {
            if(A == C || B == 6 || B == 5)
                NPC[A].Killed = B;

            if(B == 3 && NPC[C].Type == NPC[A].Type)
                NPC[A].Killed = B;
        }
        else if(B == 10 || B == 2)
            NPC[A].Killed = B;
    }
    // Things that link can move with his sword
    else if(B == 10 && NPC[A].Type == NPCID_BOMB && NPC[A].CantHurt == 0 && !NPC[A].Projectile) // link picks up bombs
    {
        if(Player[C].Bombs < 9)
            Player[C].Bombs += 1;
        // .Location.X += .Location.Width / 2 - EffectWidth(10) / 2
        // .Location.Y += .Location.Height / 2 - EffectHeight(10) / 2
        // NewEffect 10, .Location
        NPC[A].Killed = 9;
        PlaySoundSpatial(SFX_HeroHeart, NPC[A].Location);
    }
    else if(B == 10 && ((NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D) || NPC[A].Type == NPCID_SPRING || NPC[A].Type == NPCID_COIN_SWITCH || NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_EARTHQUAKE_BLOCK || NPC[A].Type == NPCID_ITEM_POD || NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_BOMB))
    {
        PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
        NPC[A].Bouce = true;
        if((NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D) || NPC[A].Type == NPCID_CANNONITEM)
        {
            NPC[A].Location.SpeedX = 3 * Player[C].Direction;
            NPC[A].Location.SpeedY = -5;
        }
        else
        {
            NPC[A].Location.SpeedX = 4 * Player[C].Direction;
            NPC[A].Location.SpeedY = -4;
        }
        NPC[A].Projectile = true;
        NPC[A].CantHurt = 30;
        NPC[A].CantHurtPlayer = C;
        NPC[A].BattleOwner = C;
        if(NPC[A].Type == NPCID_CANNONITEM)
            NPC[A].Direction = Player[C].Direction;
    }
    // SMB2 Grass
    else if(B == 10 && (NPC[A].Type == NPCID_ITEM_BURIED || NPCIsVeggie(NPC[A].Type)))
    {
        // Unbury code (v2)
        if(NPC[A].Type == NPCID_ITEM_BURIED)
        {
            NPC[A].Location.Y += -NPC[A].Location.Height;
            NPC[A].Type = NPCID(NPC[A].Special);
            NPC[A].Wings = NPC[A].DefaultWings;
        }

        PlaySoundSpatial(SFX_HeroGrass, NPC[A].Location);
        NewEffect(EFFID_SMOKE_S5, NPC[A].Location);

        if(NPC[A].Type == NPCID_BULLET)
        {
            PlaySoundSpatial(SFX_Bullet, NPC[A].Location);
            NPC[A].Location.SpeedX = 5 * Player[C].Direction;
            NPC[A].Location.Y += NPC[A].Location.Height;
        }

        NPC[A].Direction = Player[C].Direction;

        NPCUnbury(A, 2);

        NPC[A].Location.Y += -NPC[A].Location.Height;
        NPC[A].Location.SpeedX = (3 + dRand()) * Player[C].Direction;
        if(NPC[A].Type == NPCID_BULLET)
            NPC[A].Location.SpeedX = 5 * Player[C].Direction;
        NPC[A].Location.SpeedY = -4;
        NPC[A].CantHurtPlayer = C;
        NPC[A].CantHurt = 30;
        if(NPCIsVeggie(NPC[A].Type) || NPC[A].Type == NPCID_HEAVY_THROWER || NPC[A].Type == NPCID_GEM_1 || NPC[A].Type == NPCID_GEM_5)
        {
            if(NPC[A].Type != NPCID_GEM_5)
                NPC[A].Type = NPCID_GEM_1;
            NPC[A].Location.SpeedX = (1 + dRand() / 2) * Player[C].Direction;
            NPC[A].Location.SpeedY = -5;
            if(iRand(20) < 3)
                NPC[A].Type = NPCID_GEM_5;
            if(iRand(40) < 3)
                NPC[A].Type = NPCID_GEM_20;
            NPC[A].Location.set_width_center(NPC[A]->TWidth);
            NPC[A].Location.set_height_floor(NPC[A]->THeight);
        }
        if(NPC[A]->IsAShell)
            NPC[A].Location.SpeedX = Physics.NPCShellSpeed * Player[C].Direction;

        NPCQueues::Unchecked.push_back(A);

        NPCFrames(A);

        if(!NPC[A]->IsACoin)
            NPC[A].Projectile = true;
        else
            NPC[A].Special = 1;

        NPC[A].Immune = 10;

        if(NPC[A].Type == NPCID_BOMB)
        {
            // .Location.SpeedX = 5 * Player(C).Direction + Player(C).Location.SpeedX
            // .Location.SpeedY = -5
            NPC[A].Projectile = false;
        }

        if(Player[C].StandingOnNPC == A)
            Player[C].StandingOnNPC = 0;
    }

    // bubble
    else if(NPC[A].Type == NPCID_ITEM_BUBBLE)
        NPC[A].Special3 = 1;

    // Larry Koopa
    else if(NPC[A].Type == NPCID_MAGIC_BOSS || NPC[A].Type == NPCID_FIRE_BOSS)
    {
        if(B != 7)
            NPC[A].Immune = 10;
        if(B == 1 || B == 2 || B == 8)
        {
            NPC[A].Damage += 5;
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Special = 5;
            if(NPC[A].Type == NPCID_MAGIC_BOSS && NPC[A].Damage < 15)
                PlaySoundSpatial(SFX_MagicBossShell, NPC[A].Location);
        }
        else if(B == 3 || B == 4 || B == 5)
        {
            if(NPC[C].Type == NPCID_PLR_FIREBALL || NPC[C].Type == NPCID_PET_FIRE)
            {
                NPC[A].Damage += 1;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            }
            else
            {
                NPCHit(C, 3, B);
                NPC[A].Special = 5;
                NPC[A].Damage += 5;
                PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                if(NPC[A].Type == NPCID_MAGIC_BOSS && NPC[A].Damage < 15)
                    PlaySoundSpatial(SFX_MagicBossShell, NPC[A].Location);
            }
        }
        else if(B == 10)
        {
            NPC[A].Damage += 2;
            PlaySoundSpatial(SFX_HeroHit, NPC[A].Location);
        }
        else if(B == 6)
            NPC[A].Killed = B;
        if(NPC[A].Damage >= 15)
            NPC[A].Killed = B;
        else if(NPC[A].Special == 5 && !(NPC[A].Type == NPCID_MAGIC_BOSS_SHELL || NPC[A].Type == NPCID_FIRE_BOSS_SHELL))
        {
            NPC[A].Special = 0;
            NPC[A].Special2 = 0;
            NPC[A].Special3 = 0;
            NPC[A].Special4 = 0;
            NPC[A].Special5 = 0;
            // NPC[A].Special6 = 0;
            NPC[A].SpecialX = 0;
            NPC[A].SpecialY = 0;
            if(NPC[A].Type == NPCID_MAGIC_BOSS)
                NPC[A].Type = NPCID_MAGIC_BOSS_SHELL;
            else
                NPC[A].Type = NPCID_FIRE_BOSS_SHELL;
            NPC[A].Location.set_width_center(NPC[A]->TWidth);
            NPC[A].Location.set_height_floor(NPC[A]->THeight);
            NPC[A].Location.SpeedX = 0;
            NPC[A].Location.SpeedY = 0;

            // update now because oldNPC (which we use to check for deferred update later) has been updated
            NPCQueues::Unchecked.push_back(A);
            treeNPCUpdate(A);
            if(NPC[A].tempBlock > 0)
                treeNPCSplitTempBlock(A);

            oldNPC = NPC[A];
        }

    }
    // Larry Koop Shell
    else if(NPC[A].Type == NPCID_MAGIC_BOSS_SHELL || NPC[A].Type == NPCID_FIRE_BOSS_SHELL)
    {
        if(B != 7 && B != 1 && B != 2 && B != 8)
            NPC[A].Immune = 10;
        if(B == 1 || B == 2 || B == 8)
        {
            if(B == 1 || B == 8)
            {

                if(NPC[A].Location.to_right_of(Player[C].Location))
                    Player[C].Location.SpeedX -= 3;
                else
                    Player[C].Location.SpeedX += 3;

            }
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
        }
        else if(B == 3 || B == 4 || B == 5)
        {
            if(NPC[C].Type == NPCID_PLR_FIREBALL || NPC[C].Type == NPCID_PET_FIRE)
            {
                NPC[A].Damage += 1;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            }
            else
            {
                NPCHit(C, 3, B);
                NPC[A].Special = 5;
                NPC[A].Damage += 5;
                PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
            }
        }
        else if(B == 10)
        {
            NPC[A].Damage += 2;
            PlaySoundSpatial(SFX_HeroHit, NPC[A].Location);
        }
        else if(B == 6)
            NPC[A].Killed = B;
        if(NPC[A].Damage >= 15)
            NPC[A].Killed = B;
    }
    // Zelda 2 Locked Door
    else if(NPC[A].Type == NPCID_LOCK_DOOR)
    {
        if(B == 10)
        {
            if(Player[C].HasKey)
            {
                Player[C].HasKey = false;
                NPC[A].Killed = 3;
            }
        }
    }
    // Goomba / Nekkid Koopa
    else if(NPC[A].Type == NPCID_FODDER_S3 || NPC[A].Type == NPCID_RED_FODDER || NPC[A].Type == NPCID_FODDER_S5 || NPC[A].Type == NPCID_UNDER_FODDER ||
            NPC[A].Type == NPCID_EXT_TURTLE || NPC[A].Type == NPCID_YELSWITCH_FODDER || NPC[A].Type == NPCID_BLUSWITCH_FODDER || NPC[A].Type == NPCID_GRNSWITCH_FODDER ||
            NPC[A].Type == NPCID_REDSWITCH_FODDER || NPC[A].Type == NPCID_BIG_FODDER || NPC[A].Type == NPCID_JUMPER_S4 || NPC[A].Type == NPCID_BAT ||
            NPC[A].Type == NPCID_FODDER_S1 || (NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4) || NPC[A].Type == NPCID_BRUTE ||
            NPC[A].Type == NPCID_BRUTE_SQUISHED || NPC[A].Type == NPCID_GRN_FISH_S3 || NPC[A].Type == NPCID_YEL_FISH_S4 || NPC[A].Type == NPCID_RED_FISH_S3 ||
            NPC[A].Type == NPCID_GRN_FISH_S4 || NPC[A].Type == NPCID_GRN_FISH_S1 || NPC[A].Type == NPCID_BONE_FISH)
    {
        if(B == 1)
        {
            if(NPC[A].Type == NPCID_BRUTE && !NPC[A].Wings)
            {
                NPC[A].Location.set_height_floor(32);
                NPC[A].Type = NPCID_BRUTE_SQUISHED;
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            }
            else if(NPC[A].Type != NPCID_BONE_FISH)
                NPC[A].Killed = B;
        }
        else if(NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4)
        {
            if(B == 3 && NPC[A].CantHurt > 0)
            {
            }
            else
                NPC[A].Killed = B;
        }
        else
        {
            if(NPC[A].Type == NPCID_BONE_FISH && B == 3)
            {
                if(NPC[C].Type != NPCID_PLR_FIREBALL && NPC[C].Type != NPCID_PET_FIRE)
                    NPC[A].Killed = B;
            }
            else
                NPC[A].Killed = B;
        }
    }
    // Mother Brain
    else if(NPC[A].Type == NPCID_BOSS_FRAGILE)
    {
        // int D = 0;
        bool tempBool;
        tempBool = false;

        for(int D : treeNPCQuery(NPC[A].Location, SORTMODE_NONE))
        {
            if(NPC[D].Type == NPCID_BOSS_CASE)
            {
                if(NPC[D].Active)
                {
                    if(NPC[D].Section == NPC[A].Section)
                    {
                        if(CheckCollision(NPC[A].Location, NPC[D].Location))
                        {
                            tempBool = true;
                            NPC[A].Immune = 65;
                            break;
                        }
                    }
                }
            }
        }

        if(!tempBool)
        {
            if(B == 3 || B == 10)
            {
                if(NPC[C].Type == NPCID_PLR_FIREBALL)
                {
                }
                else
                {
                    if(NPC[C].Type == NPCID_PLR_HEAVY)
                        NPC[A].Immune = 60;
                    else
                        NPC[A].Immune = 20;
                    NPC[A].Special = 1;
                    PlaySoundSpatial(SFX_SMBossHit, NPC[A].Location);
                    NPC[A].Damage += 1;
                    if(NPC[A].Damage >= 10)
                        NPC[A].Killed = 3;
                }
            }
        }
    }
    // Metroid Cherrio
    else if(NPC[A].Type == NPCID_HOMING_BALL)
    {
        if(B == 3 || B == 4 || B == 5 || B == 7 || B == 9 || B == 10)
            NPC[A].Killed = B;
    }
    // Metroid Glass
    else if(NPC[A].Type == NPCID_BOSS_CASE)
    {
        if(B == 3)
        {
            PlaySoundSpatial(SFX_SMBlockHit, NPC[A].Location);
            if(NPC[C].Type == NPCID_PLR_FIREBALL)
            {
            }
            else
            {
                if(NPC[C].Type == NPCID_PLR_HEAVY)
                    NPC[A].Immune = 60;
                else
                    NPC[A].Immune = 20;
                NPC[A].Damage += 3;
            }
        }
        else if(B == 10)
        {
            NPC[A].Damage += 3;
            NPC[A].Immune = 10;
        }
        if(NPC[A].Damage >= 15)
            NPC[A].Killed = B;
    }
    // Metroid Floating Things
    else if(NPC[A].Type == NPCID_FLIER || NPC[A].Type == NPCID_ROCKET_FLIER)
    {
        if(B == 3)
        {
            if(NPC[C].Type != NPCID_PLR_FIREBALL && NPC[C].Type != NPCID_PET_FIRE)
                NPC[A].Killed = B;
        }
        else if(B == 2 || B == 4 || B == 5 || B == 6 || B == 9 || B == 10)
            NPC[A].Killed = B;
    }
    // Spike Top
    else if(NPC[A].Type == NPCID_WALL_TURTLE)
    {
        if(B == 3)
        {
            if(NPC[C].Type != NPCID_PLR_FIREBALL && NPC[C].Type != NPCID_PET_FIRE)
                NPC[A].Killed = B;
        }
        else if(B != 1)
            NPC[A].Killed = B;
    }
    // Metroid Crawler
    else if(NPC[A].Type == NPCID_WALL_BUG)
    {
        if(B == 3)
        {
            if(NPC[C].Type == NPCID_PLR_FIREBALL)
                NPC[A].Damage += 1;
            else
                NPC[A].Damage += 3;
            if(NPC[A].Damage >= 3)
                NPC[A].Killed = B;
            else
                PlaySoundSpatial(SFX_SMHurt, NPC[A].Location);
        }
        else if(B == 8)
        {
            NPC[A].Damage += 1;
            if(NPC[A].Damage >= 3)
                NPC[A].Killed = B;
            else
                PlaySoundSpatial(SFX_SMHurt, NPC[A].Location);
        }
        else if(B == 10)
            NPC[A].Killed = B;
        else if(B == 4 || B == 2 || B == 9 || B == 6)
            NPC[A].Killed = B;
    }
    // mouser
    else if(NPC[A].Type == NPCID_BOMBER_BOSS)
    {
        if(B == 1)
        {
        }
        else if(B == 3)
        {
            if(NPC[C].Type != NPCID_PLR_FIREBALL)
            {
                NPC[A].Damage += 5;
                NPC[A].Immune = 60;
            }
            else
                NPC[A].Damage += 1;
        }
        else if(B == 6)
        {
            NPC[A].Killed = B;
            PlaySoundSpatial(SFX_SickBossKilled, NPC[A].Location);
        }
        else if(B == 10)
        {
            NPC[A].Damage += 2;
            NPC[A].Immune = 20;
        }
        if(NPC[A].Damage >= 20)
        {
            NPC[A].Killed = 3;
            PlaySoundSpatial(SFX_SpitBossBeat, NPC[A].Location);
        }
        else if(B == 3)
        {
            if(NPC[C].Type == NPCID_PLR_FIREBALL)
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            else
                PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
        }
        else if(B == 10)
            PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
    }
    // Wart
    else if(NPC[A].Type == NPCID_SICK_BOSS)
    {
        if(B == 1)
        {
        }
        else if(B == 3)
        {
            if(NPCIsVeggie(NPC[C].Type))
            {
                if(NPC[A].Special == 1)
                {
                    PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                    NPC[A].Damage += 5;
                    NPC[A].Immune = 20;
                    NPC[C].Killed = 9;
                    NPCQueues::Killed.push_back(C);
                }
            }
            else
            {
                if(NPC[C].Type != NPCID_PLR_FIREBALL)
                {
                    PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                    NPC[A].Damage += 5;
                    NPC[A].Immune = 20;
                }
                else
                {
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    NPC[A].Damage += 1;
                }
            }
        }
        else if(B == 6)
        {
            NPC[A].Killed = B;
            PlaySoundSpatial(SFX_SickBossKilled, NPC[A].Location);
        }
        else if(B == 10)
        {
            PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
            NPC[A].Damage += 5;
            NPC[A].Immune = 20;
        }
    }
    // King Koopa
    else if(NPC[A].Type == NPCID_VILLAIN_S1)
    {
        if(B == 1)
        {
        }
        else if(B == 3)
        {
            NPC[A].Immune = 20;
            if(NPC[C].Type != NPCID_PLR_FIREBALL)
            {
                PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                NPC[A].Damage += 3;
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NPC[A].Damage += 1;
            }
        }
        else if(B == 10)
        {
            PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
            NPC[A].Immune = 20;
            NPC[A].Damage += 1;
        }
        else if(B == 6)
            NPC[A].Killed = B;
        if(NPC[A].Damage >= 12)
            NPC[A].Killed = B;
        // SMW Dry Bones
    }
    else if(NPC[A].Type == NPCID_SKELETON)
    {
        if(B == 1 || B == 8 || B == 10)
        {
            PlaySoundSpatial(SFX_Skeleton, NPC[A].Location);
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Special = 1;
            NPC[A].Special2 = 0;
            NPC[A].Inert = true;
            NPC[A].Stuck = true;
        }
        else if(B == 3)
        {
            if(NPC[C].Type == NPCID_PLR_FIREBALL || NPC[C].Type == NPCID_PET_FIRE)
            {
            }
            else
                NPC[A].Killed = B;
        }
        else
            NPC[A].Killed = B;

        // Big Boo
    }
    else if(NPC[A].Type == NPCID_BIG_GHOST)
    {
        if((B == 3 && NPC[C].Type != NPCID_PLR_FIREBALL) || B == 4)
        {
            if(B == 3 && NPC[C].Type == NPCID_SLIDE_BLOCK)
                NPCHit(C, 3, C);
            NPC[A].Damage += 1;
            NPC[A].Immune = 30;
            if(NPC[A].Damage >= 3)
                NPC[A].Killed = B;
            else
                PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
        }
        else if(B == 6)
            NPC[A].Killed = B;

        // Projectile Only Death (Ghosts, Thwomps, Etc.)
    }
    else if(NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_GHOST_S3 || NPC[A].Type == NPCID_GHOST_FAST || NPC[A].Type == NPCID_GHOST_S4 || NPC[A].Type == NPCID_STONE_S4 || NPC[A].Type == NPCID_SAW || NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_FIRE_DISK)
    {
        if((B == 3 && NPC[C].Type != NPCID_PLR_FIREBALL) || B == 4)
        {
            if(NPC[A].Type != NPCID_FIRE_DISK && NPC[C].Type != NPCID_METALBARREL) // roto disks don't die form falling blocks
            {
                if(NPC[A].Type != NPCID_SAW)
                    NPC[A].Killed = B;
                if(B == 3 && (NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_STONE_S4 || NPC[A].Type == NPCID_FIRE_DISK))
                {
                    if(NPC[C].Location.SpeedX > 0)
                    {
                        NPC[A].Direction = 1;
                        NPC[A].Location.SpeedX = 2;
                    }
                    else
                    {
                        NPC[A].Direction = -1;
                        NPC[A].Location.SpeedX = -2;
                    }
                }
            }
        }
        else if(B == 6)
            NPC[A].Killed = B;
        else if(NPC[A].Type == NPCID_WALL_SPARK && B == 10)
            NPC[A].Killed = B;
    }
    // Mega Mole
    else if(NPC[A].Type == NPCID_BIG_GUY)
    {
        if(B == 6 || B == 7 || B == 9 || B == 2 || B == 10)
            NPC[A].Killed = B;
        else if(B == 3)
        {
            if(NPC[C].Type != NPCID_PLR_FIREBALL)
                NPC[A].Killed = B;
        }
    }
    // SMW Goombas
    else if(NPC[A].Type == NPCID_CARRY_FODDER || NPC[A].Type == NPCID_HIT_CARRY_FODDER ||
            NPC[A].Type == NPCID_FLY_CARRY_FODDER || NPC[A].Type == NPCID_CHASER)
    {
        if(B == 1)
        {
            if(NPC[A].Type == NPCID_FLY_CARRY_FODDER)
            {
                NPC[A].Type = NPCID_CARRY_FODDER;
                if(!NPC[A].Projectile)
                {
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    NPC[A].Projectile = true;
                }
            }
            else if(NPC[A].Type == NPCID_CHASER)
            {
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                if(NPC[A].Special2 == 0)
                {
                    NPC[A].Special2 = 1;
                    NPC[A].Location.SpeedX = 4 * Player[C].Direction;
                    NPC[A].Location.SpeedY = -2;
                }
            }
            else if(NPC[A].Type == NPCID_CARRY_FODDER)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NPC[A].Projectile = true;
                NPC[A].Type = NPCID_HIT_CARRY_FODDER;
            }
            else if(NPC[A].Type == NPCID_HIT_CARRY_FODDER)
            {
                if(NPC[A].CantHurt == 0)
                {
                    NPC[A].CantHurtPlayer = C;
                    NPC[A].CantHurt = 10;
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    NPC[A].Projectile = true;
                    if(Player[C].Location.to_right_of(NPC[A].Location))
                        NPC[A].Direction = -1;
                    else
                        NPC[A].Direction = 1;
                    NPC[A].Location.SpeedX = 5 * NPC[A].Direction;
                    NPC[A].Location.SpeedY = -2.5_n;
                }
            }
            NPC[A].Special = 0;
        }
        else if(B == 2)
        {
            if(NPC[A].Type != NPCID_CHASER)
                NPC[A].Type = NPCID_HIT_CARRY_FODDER;
            NPC[A].Special = 0;
            if(NPC[A].Location.SpeedY > -4)
            {
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                if(NPC[A].Type == NPCID_CHASER)
                    NPC[A].Special2 = 1;
                else
                    NPC[A].Projectile = true;
                NPC[A].Location.SpeedY = -5;
                NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
            }
        }
        else if(B == 7)
        {
            if(NPC[A].Type != NPCID_CHASER)
                NPC[A].Type = NPCID_HIT_CARRY_FODDER;
            NPC[A].Special = 0;
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Location.SpeedY = -5;
            NPC[A].Location.SpeedX = 3 * Player[C].Direction;
            if(NPC[A].Type == NPCID_CHASER)
                NPC[A].Special2 = 1;
            else
                NPC[A].Projectile = true;
        }
        else
        {
            if(NPC[A].Type == NPCID_CHASER && (B == 3 || B == 4 || B == 8))
            {
                if(B == 3 && NPC[C].Type != NPCID_PLR_FIREBALL && NPC[C].Type != NPCID_PET_FIRE)
                {
                    NPC[A].Location.SpeedY = -7;
                    NPC[A].Killed = B;
                }
            }
            else
                NPC[A].Killed = B;
        }
    }
    // SMB2 Bomb
    else if(NPC[A].Type == NPCID_BOMB)
    {
        if(B == 9)
            NPC[A].Killed = B;
        else if(B != 8 && B != 7)
            NPC[A].Special = 10000;
    }
    // Heart bomb
    else if(NPC[A].Type == NPCID_CHAR3_HEAVY)
    {
        if(B == 9)
            NPC[A].Killed = B;
        else if(B != 1 && B != 8 && B != 7 && B != 10)
        {
            if(NPC[A].HoldingPlayer > 0)
            {
                Player[NPC[A].HoldingPlayer].HoldingNPC = 0;
                NPC[A].HoldingPlayer = 0;
            }
            NPC[A].Special4 = 1;
        }
    }
    // SMB2 Bob-omb
    else if(NPC[A].Type == NPCID_WALK_BOMB_S2)
    {
        if(B == 9)
            NPC[A].Killed = B;
        else if(B == 7)
        {
            NPC[A].Projectile = true;
            NPC[A].Location.SpeedX = 3 * Player[C].Direction;
            NPC[A].Location.SpeedY = -5;
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            if(NPC[A].Special < 520)
                NPC[A].Special = 520;
        }
        else if(B != 8)
            NPC[A].Special = 10000;
    }
    // Thwomps
    else if(NPC[A].Type == NPCID_STATUE_S3 || NPC[A].Type == NPCID_STATUE_S4 || NPC[A].Type == NPCID_STONE_S4)
    {
        if(B == 6)
            NPC[A].Killed = B;
    }
    // Zelda NPCs
    else if(NPC[A].Type == NPCID_KNIGHT)
        NPC[A].Killed = B;
    // Zelda Bots
    else if(NPCIsABot(NPC[A]))
        NPC[A].Killed = B;
    // Switch Platforms
    else if(NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM || NPC[A].Type == NPCID_GRN_PLATFORM || NPC[A].Type == NPCID_RED_PLATFORM)
    {
        if(B == 9)
            NPC[A].Killed = B;
    }
    // Veggies
    else if(NPCIsVeggie(NPC[A].Type))
    {
        if(B == 5)
        {
            Player[NPC[A].HoldingPlayer].HoldingNPC = 0;
            NPC[A].CantHurtPlayer = NPC[A].HoldingPlayer;
            NPC[A].HoldingPlayer = 0;
            NPC[A].CantHurt = 1000;
            NPC[A].Location.SpeedX = 3 * -NPC[A].Direction;
            NPC[A].Location.SpeedY = -3;
            NPC[A].Projectile = true;
        }
        // Because C++, second part of this condition never gets checked
        // in VB6, it does check and causes a crash, because C is an index of block when B is 4
        else if(B == 4 && (NPC[C].Type != NPC[A].Type || A == C))
        {
            if(NPC[C].Type != NPCID_SICK_BOSS_BALL && NPC[C].Type != NPCID_SICK_BOSS)
            {
                if(NPC[A].Location.SpeedY > -4)
                    NPC[A].Location.SpeedY = -4;
                if(NPC[A].Location.SpeedX == 0)
                {
                    if(iRand(2) == 0)
                        NPC[A].Location.SpeedX = 2;
                    else
                        NPC[A].Location.SpeedX = -2;
                }
            }
        }
        else if(B == 6)
            NPC[A].Killed = B;
    }
    // SMB3 Bomb
    else if(NPC[A].Type == NPCID_LIT_BOMB_S3)
    {
        if(B == 1)
        {
            if(NPC[A].CantHurt == 0)
            {
                NPC[A].CantHurt = 10;
                NPC[A].CantHurtPlayer = C;
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                NPC[A].Projectile = true;
                if(Player[C].Location.to_right_of(NPC[A].Location))
                    NPC[A].Direction = -1;
                else
                    NPC[A].Direction = 1;
                NPC[A].Location.SpeedX = 5 * NPC[A].Direction;
                NPC[A].Location.SpeedY = -2;
            }
        }
        else if(B == 2)
        {
            if(NPC[A].Location.SpeedY > -4)
            {
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                NPC[A].Projectile = true;
                NPC[A].Location.SpeedY = -5;
                NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
            }
        }
        else if(B == 7 || B == 10)
        {
            NPC[A].Type = NPCID_LIT_BOMB_S3;
            NPC[A].Special = 0;
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Location.SpeedY = -5;
            NPC[A].Location.SpeedX = 3 * Player[C].Direction;
            NPC[A].Projectile = true;
        }
        else
        {
            if(B == 3)
            {
                if(NPC[C].Type != NPCID_PLR_FIREBALL && NPC[C].Type != NPCID_PET_FIRE)
                    NPC[A].Killed = B;
            }
            else if(B != 8)
                NPC[A].Killed = B;
        }
    }
    // SMB3 Bob-om
    else if(NPC[A].Type == NPCID_WALK_BOMB_S3)
    {
        if(B == 1)
        {
            NPC[A].CantHurt = 11;
            NPC[A].Type = NPCID_LIT_BOMB_S3;
            NPC[A].Special = 0;
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Projectile = true;
        }
        else if(B == 2)
        {
            if(NPC[A].Location.SpeedY > -4)
            {
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                NPC[A].Location.SpeedY = -5;
                NPC[A].Projectile = true;
                NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
            }
            NPC[A].Type = NPCID_LIT_BOMB_S3;
            NPC[A].Special = 0;
        }
        else if(B == 7 || B == 10)
        {
            NPC[A].Type = NPCID_LIT_BOMB_S3;
            NPC[A].Special = 0;
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Location.SpeedY = -5;
            NPC[A].Location.SpeedX = 3 * Player[C].Direction;
            NPC[A].Projectile = true;
        }
        else
        {
            if(B == 3 || B == 5)
            {
                if(NPC[C].Type != NPCID_PLR_FIREBALL && NPC[C].Type != NPCID_PET_FIRE)
                    NPC[A].Killed = B;
            }
            else if(B != 8)
                NPC[A].Killed = B;
        }
        if(NPC[A].Type == NPCID_LIT_BOMB_S3)
            NPC[A].Location.Height = 28;
    }
    // Friendly NPCs (Toad, Peach, Link, Luigi, Etc.)
    else if(NPCIsToad(NPC[A].Type))
    {
        if(B == 2 && NPC[A].Location.SpeedY > -4)
        {
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Location.SpeedY = -5;
            NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
        }
        else if(B == 3 || B == 4 || B == 5 || B == 6 || B == 9)
        {
            NPC[A].Killed = B;
            if(B == 3)
                NPC[A].Location.SpeedX = 2 * NPC[B].Direction;
        }
    }
    // SMB3 Red Paragoomba
    else if(NPC[A].Type == NPCID_RED_FLY_FODDER)
    {
        if(B == 1)
        {
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            if(NPC[A].Location.SpeedY < 0)
                NPC[A].Location.SpeedY = 0;
            NPC[A].Type = NPCID_RED_FODDER;
            NPC[A].Frame = 0;
        }
        else
            NPC[A].Killed = B;
    }
    // SML2 Paragoomba
    else if(NPC[A].Type == NPCID_FLY_FODDER_S5)
    {
        if(B == 1)
        {
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            if(NPC[A].Location.SpeedY < 0)
                NPC[A].Location.SpeedY = 0;
            NPC[A].Type = NPCID_FODDER_S5;
            NPC[A].Frame = 0;
        }
        else
            NPC[A].Killed = B;
    }
    // SMB3 Brown Paragoomba
    else if(NPC[A].Type == NPCID_FLY_FODDER_S3)
    {
        if(B == 1)
        {
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            if(NPC[A].Location.SpeedY < 0)
                NPC[A].Location.SpeedY = 0;
            NPC[A].Type = NPCID_FODDER_S3;
            NPC[A].Frame = 0;
        }
        else
            NPC[A].Killed = B;
    }
    // SMB3 Ice Block
    else if(NPC[A].Type == NPCID_SLIDE_BLOCK)
    {
        if(B == 1 || (B == 10 && !NPC[A].Projectile))
        {
            NPC[A].Special = 1;
            PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            NPC[A].Location.SpeedX = Physics.NPCShellSpeed * Player[C].Direction;
            NPC[A].CantHurt = Physics.NPCCanHurtWait;
            NPC[A].CantHurtPlayer = C;
        }
        else if(B == 6 || B == 2 || B == 5 || B == 4 || (B == 3 && NPC[A].Special == 1) || B == 9 || (B == 10 && NPC[A].Projectile))
        {
            if(B == 10)
                B = 3;
            if(B == 4)
            {
                if(C == A)
                {
                    NPC[A].Killed = B;
                    NewEffect(EFFID_WHACK, NPC[A].Location);
                    Effect[numEffects].Location.X += NPC[A].Location.SpeedX;
                    Effect[numEffects].Location.Y += NPC[A].Location.SpeedY;
                }
            }
            else if(B == 3)
            {
                if(NPC[C].Type != NPCID_PLR_FIREBALL)
                    NPC[A].Killed = B;
                if(NPC[C].Killed == 0)
                    NPCHit(C, 3, A);
            }
            else
                NPC[A].Killed = B;
        }
    }
    // Bower Statues
    else if(NPC[A].Type == NPCID_STATUE_S3 || NPC[A].Type == NPCID_STATUE_S4)
    {
        if(B == 2)
        {
            NPC[A].Location.Y -= 1;
            NPC[A].Location.SpeedY = -1;
        }
    }
    // Things With Shells (Koopa Troopa, Buzzy Beetle, Etc.)
    else if(NPC[A].Type == NPCID_GRN_TURTLE_S3 || NPC[A].Type == NPCID_RED_TURTLE_S3 || NPC[A].Type == NPCID_GLASS_TURTLE || NPC[A].Type == NPCID_BIG_TURTLE || NPCIsAParaTroopa(NPC[A].Type)
        || (NPC[A].Type >= NPCID_GRN_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_TURTLE_S4)
        || NPC[A].Type == NPCID_GRN_TURTLE_S1 || NPC[A].Type == NPCID_RED_TURTLE_S1
        /* || NPC[A].Type == NPCID_GRN_FLY_TURTLE_S1 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S1 */ // implied by NPCIsAParaTroopa
    )
    {
        if((B == 1 && !NPC[A].Wings) || B == 2 || B == 7)
        {
            PlaySoundSpatial((B == 1) ? SFX_Stomp : SFX_ShellHit, NPC[A].Location);

            if(B != 1)
                NPC[A].Projectile = true;

            NPC[A].Location.Y += NPC[A].Location.Height;
            NPC[A].Location.X += NPC[A].Location.Width / 2;
            if(NPC[A].Type == NPCID_GRN_TURTLE_S3)
                NPC[A].Type = NPCID_GRN_SHELL_S3;
            else if(NPC[A].Type == NPCID_RED_TURTLE_S3)
                NPC[A].Type = NPCID_RED_SHELL_S3;
            else if(NPC[A].Type == NPCID_BIG_TURTLE)
                NPC[A].Type = NPCID_BIG_SHELL;
            else if(NPC[A].Type == NPCID_GRN_FLY_TURTLE_S3) // winged green koopa
                NPC[A].Type = (B == 1) ? NPCID_GRN_TURTLE_S3 : NPCID_GRN_SHELL_S3;
            else if(NPC[A].Type == NPCID_RED_FLY_TURTLE_S3) // winged red koopa
                NPC[A].Type = (B == 1) ? NPCID_RED_TURTLE_S3 : NPCID_RED_SHELL_S3;
            else if(NPC[A].Type == NPCID_GRN_FLY_TURTLE_S1 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S1) // smb1 winged koopa
            {
                NPC[A].Type = (NPC[A].Type == NPCID_GRN_FLY_TURTLE_S1) ? NPCID_GRN_TURTLE_S1 : NPCID_RED_TURTLE_S1;
                if(B != 1)
                {
                    NPC[A].Type = NPCID(NPC[A].Type - 1); // to shell
                    // NPC[A].Location.Height = 28; // reset below
                }
            }
            else if(NPC[A].Type == NPCID_GRN_TURTLE_S1 || NPC[A].Type == NPCID_RED_TURTLE_S1) // smb1 koopa
            {
                NPC[A].Type = NPCID(NPC[A].Type - 1); // to shell
                // NPC[A].Location.Height = 28; // reset below
            }
            else if(NPC[A].Type == NPCID_GLASS_TURTLE)
                NPC[A].Type = NPCID_GLASS_SHELL;
            else if(NPC[A].Type >= NPCID_GRN_FLY_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_FLY_TURTLE_S4)
            {
                NPC[A].Type = NPCID(NPC[A].Type - 12);
                // NPC[A].Special = 0; // also set below
            }
            else if(B != 2) // turn S4 turtles into shells and release inner turtles
            {
                // release inner (hit) turtle
                numNPCs++;
                NPC[numNPCs].Location = NPC[A].Location;
                NPC[numNPCs].Location.Y -= 32;
                NPC[numNPCs].Type = NPCID(NPC[A].Type + 8); // to hit turtle
                NPC[numNPCs].Projectile = true;
                NPC[numNPCs].Direction = Player[C].Direction;
                NPC[numNPCs].Location.SpeedY = 0;
                NPC[numNPCs].Location.SpeedX = Physics.NPCShellSpeed * NPC[numNPCs].Direction;
                // logic to prevent double-hitting is different in stomp and whip cases
                NPC[numNPCs].Location.X += -16 + (B == 1 ? NPC[numNPCs].Location.SpeedX : (32 * NPC[numNPCs].Direction));
                NPC[numNPCs].CantHurtPlayer = C;
                NPC[numNPCs].CantHurt = 6;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].TimeLeft = 100;
                CheckSectionNPC(numNPCs);
                syncLayers_NPC(numNPCs);

                NPC[A].Type = NPCID(NPC[A].Type + 4); // to shell
            }
            else // turn S4 turtles into shells without inner turtles if hit from below
                NPC[A].Type = NPCID(NPC[A].Type + 4);

            NPC[A].Special = 0;
            NPC[A].Frame = 0;

            NPC[A].Location.Height = NPC[A]->THeight;
            NPC[A].Location.Width = NPC[A]->TWidth;
            NPC[A].Location.Y -= NPC[A].Location.Height;
            NPC[A].Location.X += -(NPC[A].Location.Width / 2) - NPC[A].Direction * 2;
            NPC[A].Location.SpeedX = 0;

            if(B == 1)
            {
                NPC[A].Location.SpeedY = 0;
                NPC[A].RealSpeedX = 0;

                D_pLogDebug("Shell stomp, X distance: [%g], Y=[%g]", (double)num_t::abs(NPC[numNPCs].Location.X - NPC[A].Location.X), (double)NPC[numNPCs].Location.Y);

                if(NPC[A].Type >= NPCID_GRN_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4)
                    NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            }
            else
            {
                NPC[A].Location.SpeedY = -5;
                if(B == 2)
                    NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
            }

            NPCQueues::Unchecked.push_back(A);
        }
        else
        {
            if(B == 3)
            {
                if(!(NPC[A].Type == NPCID_GLASS_TURTLE && (NPC[C].Type == NPCID_PLR_FIREBALL || NPC[C].Type == NPCID_PET_FIRE)))
                    NPC[A].Killed = B;
            }
            else
                NPC[A].Killed = B;
        }

        if(NPC[A]->IsAShell)
            NPC[A].Stuck = false;
    }
    // SMB3 Bowser
    else if(NPC[A].Type == NPCID_VILLAIN_S3)
    {
        if(B == 9)
        {
            NPC[A].Killed = 6;
            if(NPC[A].Legacy)
            {
                bgMusic[NPC[A].Section] = 0;
                StopMusic();
            }
        }
        if(B == 1)
        {
            // PlaySound 2
        }
        else if(B == 3)
        {
            if(NPC[C].Type != NPCID_VILLAIN_S3)
            {
                NPC[A].Immune = 10;
                if(NPC[C].Type == NPCID_BULLET)
                {
                    NPC[C].Location.SpeedX = -NPC[C].Location.SpeedX;
                    NPCHit(C, 4, C);
                }
                else
                    NPCHit(C, 3, A);
                if(NPC[C].Type != NPCID_PLR_FIREBALL)
                {
                    PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                    NPC[A].Damage += 10;
                }
                else
                {
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    NPC[A].Damage += 1;
                }
            }
        }
        else if(B == 6)
            NPC[A].Killed = B;
        else if(B == 10)
        {
            NPC[A].Immune = 10;
            PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
            NPC[A].Damage += 10;
        }
        if(NPC[A].Damage >= 200)
        {
            NPC[A].Location.SpeedY = -13;
            NPC[A].Location.SpeedX = 4 * NPC[C].Direction;
            NPC[A].Killed = B;

            if(NPC[A].Legacy)
            {
                bgMusic[NPC[A].Section] = 0;
                StopMusic();
            }

            // cancel MoreScore for invincibility-triggered kill
            if(B == 3 && C > numNPCs)
                C = A;
        }
    }
    // SMW Rainbow Shell
    else if(NPC[A].Type == NPCID_RAINBOW_SHELL)
    {
        if(B == 1)
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
        else if(B == 2 || B == 7)
        {
            PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            NPC[A].Location.SpeedY = -5;
            if(B == 7)
            {
                NPC[A].Type = NPCID_FLIPPED_RAINBOW_SHELL;
                NPC[A].Location.SpeedX = 0;
                MoreScore(6, NPC[A].Location, Player[C].Multiplier);
            }
        }
        else if(B == 6)
        {
            Location_t tempLocation;
            tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - 2;
            tempLocation.X = NPC[A].Location.X - 4 + dRand().times(NPC[A].Location.Width + 8) - 4;
            NewEffect(EFFID_SKID_DUST, tempLocation);
        }
        else if(B == 8)
        {
            NPC[A].Killed = 8;
            PlaySoundSpatial(SFX_Smash, NPC[A].Location);
        }
    }
    // Shells
    else if(NPC[A].Type == NPCID_GRN_SHELL_S3 || NPC[A].Type == NPCID_RED_SHELL_S3 || NPC[A].Type == NPCID_GLASS_SHELL || NPC[A].Type == NPCID_BIG_SHELL || (NPC[A].Type >= NPCID_GRN_SHELL_S4 && NPC[A].Type <= NPCID_YEL_SHELL_S4) || NPC[A].Type == NPCID_RED_SHELL_S1 || NPC[A].Type == NPCID_GRN_SHELL_S1 || NPC[A].Type == NPCID_FLIPPED_RAINBOW_SHELL)
    {
        if(B == 1)
        {
            if(NPC[A].Effect == NPCEFF_DROP_ITEM)
                NPC[A].Effect = NPCEFF_NORMAL;

            if(Player[C].Dismount <= 0 && Player[C].Mount != 2)
            {
                if(NPC[A].Location.SpeedX == 0 && NPC[A].CantHurtPlayer != C)
                {
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    NPC[A].Location.SpeedX = Physics.NPCShellSpeed * Player[C].Direction;
                    NPC[A].CantHurt = Physics.NPCCanHurtWait;
                    NPC[A].CantHurtPlayer = C;
                    NPC[A].Projectile = true;
                    NPC[A].Location.SpeedY = 0;
                }
                else if(NPC[A].CantHurtPlayer != C || (NPC[A].Slope == 0 && Player[C].Vine == 0))
                {
                    PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                    NPC[A].Location.SpeedX = 0;
                    NPC[A].Location.SpeedY = 0;
                    if(NPC[A].Wet > 0)
                    {
                        NPC[A].RealSpeedX = 0;
                        NPC[A].Projectile = false;
                    }
                }
            }
        }
        else if(B == 2 || B == 7)
        {
            PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            NPC[A].Projectile = true;
            NPC[A].Location.SpeedY = -5;
            NPC[A].Location.SpeedX = 0;
        }
        else if(B == 6)
        {
            if(NPC[A].Type == NPCID_FLIPPED_RAINBOW_SHELL)
            {
                Location_t tempLocation;
                tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - 2;
                tempLocation.X = NPC[A].Location.X - 4 + dRand().times(NPC[A].Location.Width + 8) - 4;
                NewEffect(EFFID_SKID_DUST, tempLocation);
            }
            else
                NPC[A].Killed = B;
        }
        else if(B != 4)
        {
            if(B == 3)
            {
                if(!(NPC[A].Type == NPCID_GLASS_SHELL && (NPC[C].Type == NPCID_PLR_FIREBALL || NPC[C].Type == NPCID_PET_FIRE)))
                    NPC[A].Killed = B;
            }
            else
                NPC[A].Killed = B;
        }
        else if(B == 4)
        {
            if(NPC[C].Projectile && !(NPC[C].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[C].Type <= NPCID_YEL_HIT_TURTLE_S4))
            {
                // FIXME: Why the condition is here if it always assigns B? [PVS Studio]
#if 0
                if(!(NPC[A].Type == NPCID_GLASS_SHELL && NPC[C].Type == NPCID_PLR_FIREBALL))
                    NPC[A].Killed = B;
                else
                    NPC[A].Killed = B;
#endif
                NPC[A].Killed = B;
            }
        }

        if(NPC[A].Type == NPCID_FLIPPED_RAINBOW_SHELL)
        {
            NPC[A].Killed = 0;
            if(B == 5)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NPC[A].Location.SpeedX = Physics.NPCShellSpeed * -NPC[A].Direction;
                NPC[A].Location.X += NPC[A].Location.SpeedX;
                NPC[A].CantHurt = Physics.NPCCanHurtWait;
                NPC[A].CantHurtPlayer = C;

                // NEW code: does not alter behavior, but keeps the value in uint8_t range
                if(C > maxPlayers)
                    NPC[A].CantHurtPlayer = maxPlayers + 1;

                NPC[A].Projectile = true;
                NPC[A].Location.SpeedY = 0;
                Player[NPC[A].HoldingPlayer].HoldingNPC = 0;
                NPC[A].HoldingPlayer = 0;
            }
        }
    }
    // Big Piranha Plant
    else if(NPC[A].Type == NPCID_LONG_PLANT_UP || NPC[A].Type == NPCID_LONG_PLANT_DOWN)
    {
        if(!(B == 1 || B == 2 || B == 6))
        {
            if(NPC[A].Special3 == 0)
            {
                if(B == 3)
                {
                    if(NPC[C].Type == NPCID_PLR_FIREBALL)
                    {
                        PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                        NPC[A].Damage += 1;
                        NPC[A].Special3 = 10;
                        if(NPC[A].Special2 == 2)
                            NPC[A].Special = 50;
                    }
                    else
                    {
                        NPC[A].Damage += 3;
                        PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                        NPC[A].Special3 = 30;
                        if(NPC[A].Special2 == 2)
                            NPC[A].Special = 50;
                    }
                }
                else if(B == 10)
                {
                    NPC[A].Damage += 2;
                    PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                    NPC[A].Special3 = 10;
                    if(NPC[A].Special2 == 2)
                        NPC[A].Special = 50;
                }
            }
            if(NPC[A].Damage >= 6)
                NPC[A].Killed = B;
        }
    }

    // Piranha Plants
    else if(NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_QUAD_SPITTER || NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_SIDE_PLANT || NPC[A].Type == NPCID_BIG_PLANT || NPC[A].Type == NPCID_FIRE_PLANT || NPC[A].Type == NPCID_JUMP_PLANT)
    {
        if(!(B == 1 || B == 2 || B == 6))
        {
            if(B != 8 && B != 10 && !(B == 9 && g_config.fix_visual_bugs))
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);

            NPC[A].Killed = B;
        }
    }
    // Podoboo
    else if(NPC[A].Type == NPCID_LAVABUBBLE)
    {
        if(B == 9)
        {
        }
        else if(B == 8)
            NPC[A].Killed = B;
        else if(B == 3 || B == 5 || B == 7)
        {
            PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            NPC[A].Killed = B;
        }
        else if(B == 4 && C > 0)
        {
            if(NPC[C].Projectile)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NPC[A].Killed = 3;
            }
        }
    }
    // Player Fireball
    else if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL)
    {
        if(B != 7 && B != 9 && B != 2)
        {
            if(B == 3 || B == 4)
            {
                if(NPC[C].Type != NPCID_PLR_HEAVY)
                {
                    // if(B != 6) // Always true
                    if(NPC[A].Special == 5 && HasSound(SFX_HeroFireRod))
                        PlaySoundSpatial(SFX_HeroFire, NPC[A].Location);
                    else
                        PlaySoundSpatial(SFX_BlockHit, NPC[A].Location);
                    NPC[A].Killed = B;
                }
            }
            else
            {
                if(B != 6)
                {
                    if(NPC[A].Special == 5 && HasSound(SFX_HeroFireRod))
                        PlaySoundSpatial(SFX_HeroFire, NPC[A].Location);
                    else
                        PlaySoundSpatial(SFX_BlockHit, NPC[A].Location);
                }
                NPC[A].Killed = B;
            }
        }
    }
    // Yoshi Fireball
    else if(NPC[A].Type == NPCID_PET_FIRE)
    {
        if(B == 3 || B == 5)
        {
            PlaySoundSpatial(SFX_BlockHit, NPC[A].Location);
            NPC[A].Killed = B;
        }
    }
    // Hammer Bros.
    else if(NPC[A].Type == NPCID_HEAVY_THROWER)
        NPC[A].Killed = B;
    // Hammer Bros. Hammer
    else if(NPC[A].Type == NPCID_HEAVY_THROWN)
    {
        if(B == 3)
            NPC[A].Killed = B;
    }
    // Boom Boom
    else if(NPC[A].Type == NPCID_MINIBOSS)
    {
        if(NPC[A].Special != 4)
        {
            if((B == 1 || B == 10) && NPC[A].Special == 0)
            {
                NPC[A].Damage += 3;
                if(B == 1)
                    PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                else
                    PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                NPC[A].Special = 4;
                // (was previously Special2)
                NPC[A].SpecialY = 0;
                NPC[A].Location.SpeedX = 0;
                NPC[A].Location.SpeedY = 0;
            }
            else if(B == 3)
            {
                NPC[A].Immune = 20;
                if(C > 0)
                    NPCHit(C, 3, A);
                NPC[A].Damage++;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            }
            else if(B == 6)
            {
                NPC[A].Killed = B;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            }
            else if(B == 10)
            {
#if XTECH_ENABLE_WEIRD_GFX_UPDATES
                UpdateGraphics(true);
#endif
                NPC[A].Immune = 10;
                NPC[A].Damage++;
                PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
            }
        }

        if(NPC[A].Damage >= 9)
            NPC[A].Killed = B;
    }
    // Bullet Bills
    else if(NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_BIG_BULLET)
    {
        if(B == 1 || B == 3 || B == 4 || B == 5 || B == 7 || B == 8 || B == 10)
        {
            if(!((B == 3 || B == 4) && (NPC[C].Type == NPCID_PLR_FIREBALL || NPC[C].Type == NPCID_LAVABUBBLE)))
            {
                if(!(B == 7 && NPC[A].Projectile))
                {
                    if(!(B == 3 && NPC[A].CantHurt > 0) && !(B == 3 && NPC[C].Type == NPCID_PET_FIRE))
                    {
                        if(!(NPC[A].Type == NPCID_BIG_BULLET && B == 4))
                        {
                            if(!(B == 10 && NPC[A].Projectile)) // Link can't stab friendly bullets
                            {
                                NPC[A].Killed = B;
                                if(A != C && B != 8 && B != 10)
                                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                            }
                        }
                    }
                }
            }
        }
    }
    // Birdo
    else if(NPC[A].Type == NPCID_SPIT_BOSS)
    {
        // changed from Special when it became a container
        if(NPC[A].Special5 >= 0)
        {
            if(B == 3)
            {
                if(NPC[C].Type == NPC[A].Special && NPC[C].Immune)
                {
                    // new logic: don't get hurt by a just-shot item
                }
                else if(NPC[C].Type != NPCID_PLR_FIREBALL)
                {
                    NPC[A].Special5 = -30;
                    NPC[A].Damage += 1;
                    NPC[A].Direction = -NPC[A].Direction;
                    PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
                }
            }
            else if(B == 4)
                NPC[A].Damage = 3;
            else if(B == 10)
            {
                NPC[A].Special5 = -30;
                NPC[A].Damage += 1;
                NPC[A].Direction = -NPC[A].Direction;
                PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
            }

            if(NPC[A].Damage >= 3)
                NPC[A].Killed = B;
        }

        if(B == 6)
        {
            NPC[A].Killed = B;
            PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
        }
    }
    // Eggs
    else if(NPC[A].Type == NPCID_SPIT_BOSS_BALL)
    {
        if(B == 3)
        {
            if(NPC[C].Type == NPCID_PLR_FIREBALL)
                B = 0;
        }

        if(B == 3 || B == 4 || B == 5 || B == 7 || B == 10)
        {
            if(C == A)
                NPC[A].Special = 1;
            else
            {
                NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.6_r;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            }

            NPC[A].Killed = B;
        }
    }
    // Indestructable Objects
    else if(NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_SPRING || NPC[A].Type == NPCID_KEY || NPC[A].Type == NPCID_COIN_SWITCH || NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_TNT || NPC[A].Type == NPCID_GRN_BOOT || NPC[A].Type == NPCID_RED_BOOT || NPC[A].Type == NPCID_BLU_BOOT || NPC[A].Type == NPCID_TOOTHYPIPE || NPCIsYoshi(NPC[A].Type) || NPC[A].Type == NPCID_ITEM_POD || (NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D) || NPC[A].Type == NPCID_TIMER_S2 || NPC[A].Type == NPCID_EARTHQUAKE_BLOCK || NPC[A].Type == NPCID_FLY_BLOCK || NPC[A].Type == NPCID_FLY_CANNON)
    {
        if(NPC[A].Type == NPCID_EARTHQUAKE_BLOCK && (B == 4 || B == 5 || B == 10))
        {
            NPC[A].Killed = 4;
            PowBlock();
        }

        if(NPC[A].Type == NPCID_ITEM_POD && (B == 4 || B == 5))
        {
            if(NPC[C].Type != NPC[A].Type)
                NPC[A].Killed = B;
        }
        else if(NPC[A].Type == NPCID_ITEM_POD && B == 10)
        {
            PlaySoundSpatial(SFX_HeroKill, NPC[A].Location);
            NPC[A].Special2 = 1;
        }
        else
        {
            if(B == 1 && NPC[A].Type == NPCID_SPRING)
            {
                PlaySoundSpatial(SFX_Spring, NPC[A].Location);

                // prevent wing loss
                if(NPC[A].Wings)
                    NPC[A].Damage = 1;
            }

            if(B == 1 && (NPC[A].Type == NPCID_COIN_SWITCH || NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_TNT))
            {
                NPC[A].Killed = 1;
                NPC[A].Wings = WING_NONE;
                if(NPC[A].Type == NPCID_COIN_SWITCH)
                {
                    PSwitchTime = Physics.NPCPSwitch;
                    PSwitchPlayer = C;
                }
                else if(NPC[A].Type == NPCID_TIME_SWITCH)
                {
                    PSwitchStop = Physics.NPCPSwitch;
                    FreezeNPCs = true;
                    PSwitchPlayer = C;
                }
            }

            if(B == 2 && NPC[A].Location.SpeedY > -4 && NPC[A].CantHurt == 0)
            {
                NPC[A].CantHurt = 10;
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                NPC[A].Location.SpeedY = -5;
                // If .Type = 96 Then .Location.SpeedY = -4
                NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
            }
            else if(B == 6)
            {
                if(NPC[A].Type == NPCID_RED_BOOT)
                {
                    Location_t tempLocation;
                    tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - 2;
                    // tempLocation.X = .Location.X + .Location.Width / 2 - 4 '+ 4 * .Direction
                    tempLocation.X = NPC[A].Location.X - 4 + dRand().times(NPC[A].Location.Width + 8) - 4;
                    NewEffect(EFFID_SKID_DUST, tempLocation);
                }
                else
                {
                    if(NPC[A].Type == NPCID_SPRING)
                        NPC[A].Location.Y -= 16;
                    NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                    if(!NPC[A].NoLavaSplash)
                        NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
                    PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                    NPC[A].ResetLocation();

                    if(NPC[A].Active)
                    {
                        NPC[A].Active = false;
                        NPCQueues::update(A);
                    }
                    else
                    {
                        NPCQueues::Unchecked.push_back(A);
                    }

                    // TODO: any other hooks for inactive?

                    NPC[A].TimeLeft = 0;
                    NPC[A].Projectile = false;
                    NPC[A].Direction = NPC[A].DefaultDirection;
                    NPC[A].CantHurt = 0;
                    NPC[A].CantHurtPlayer = 0;
                    NPC[A].Reset[1] = false;
                    NPC[A].Reset[2] = false;
                    NPCQueues::NoReset.push_back(A);
                }
            }
        }
    }
    // Misc. Things With No Jump Death (SMB2 Shy Guys, SMB2 Ninji, SMB2 Pokey)
    else if(NPC[A].Type == NPCID_BLU_GUY || NPC[A].Type == NPCID_RED_GUY || NPC[A].Type == NPCID_STACKER || NPC[A].Type == NPCID_JUMPER_S3 || NPC[A].Type == NPCID_RED_FISH_S1 || NPC[A].Type == NPCID_SPIKY_S3 || NPC[A].Type == NPCID_SPIKY_S4 || NPC[A].Type == NPCID_SPIKY_BALL_S4 || NPC[A].Type == NPCID_SPIKY_THROWER || NPC[A].Type == NPCID_ITEM_THROWER || NPC[A].Type == NPCID_SPIKY_BALL_S3 || NPC[A].Type == NPCID_CRAB || NPC[A].Type == NPCID_FLY || (NPC[A].Type >= NPCID_BIRD && NPC[A].Type <= NPCID_GRY_SPIT_GUY) || NPC[A].Type == NPCID_CARRY_BUDDY || NPC[A].Type == NPCID_SQUID_S3 || NPC[A].Type == NPCID_SQUID_S1 || NPC[A].Type == NPCID_WALK_PLANT || NPC[A].Type == NPCID_VINE_BUG)
    {
        if(B == 10 && NPC[A].Type != NPCID_CARRY_BUDDY)
            NPC[A].Killed = B;
        else if(B != 1)
        {
            if(B == 6)
                NPC[A].Killed = B;
            else if(B == 2 && NPC[A].Type == NPCID_CARRY_BUDDY)
            {
                if(NPC[A].CantHurt == 0)
                {
                    NPC[A].CantHurt = 10;
                    PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                    NPC[A].Location.SpeedY = -5;
                    NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
                    NPC[A].Projectile = true;
                    NPC[A].Location.SpeedX /= 2;
                }
            }
            else if(NPC[A].Type == NPCID_CARRY_BUDDY && B == 5)
            {
                Player[NPC[A].HoldingPlayer].HoldingNPC = 0;
                NPC[A].Projectile = true;
                NPC[A].Location.SpeedX = 3 * -Player[NPC[A].HoldingPlayer].Direction;
                NPC[A].Location.SpeedY = -4;
                NPC[A].WallDeath = 0;
                NPC[A].HoldingPlayer = 0;
            }
            else if(NPC[A].Type == NPCID_CARRY_BUDDY && B == 3)
            {
                if(NPC[C].HoldingPlayer == 0 && NPC[C].Type != NPC[A].Type)
                {
                    NPC[A].Immune = 30;
                    NPC[A].Projectile = true;
                    NPC[A].Location.SpeedY = -5;
                    NPC[A].Location.SpeedX = (NPC[C].Location.SpeedX + NPC[A].Location.SpeedX) / 2;
                    if(NPC[A].Location.SpeedX < 1.2_n && NPC[A].Location.SpeedX > -1.2_n)
                    {
                        if(NPC[C].Direction == -1)
                            NPC[A].Location.SpeedX = 3;
                        else
                            NPC[A].Location.SpeedX = -3;
                    }
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                }
            }
            else if(NPC[A].Type == NPCID_CARRY_BUDDY && B == 10)
            {
                NPC[A].Immune = 30;
                NPC[A].Projectile = true;
                NPC[A].Location.SpeedY = -5;
                NPC[A].Location.SpeedX = Player[C].Location.SpeedX + 4 * Player[C].Direction;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            }
            else if(!(NPC[A].Type == NPCID_CARRY_BUDDY && (B == 4 || B == 8 || (B == 3 && NPC[C].Type == NPCID_PLR_FIREBALL))))
            {
                if(NPC[A].Type == NPCID_CARRY_BUDDY && B == 7)
                {
                    NPC[A].Direction = Player[C].Direction;
                    NPC[A].Location.SpeedX = num_t::abs(NPC[A].Location.SpeedX) * NPC[A].Direction;
                    NPC[A].TurnAround = false;
                    NPC[A].Location.SpeedY = -6;
                    NPC[A].Projectile = true;
                    PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                }
                else
                    NPC[A].Killed = B;
            }
        }
        else if(B == 1 && NPC[A].Type == NPCID_RED_FISH_S1)
        {
            NPC[A].Killed = B;
            NPC[A].Location.SpeedY = 0;
            NPC[A].Location.SpeedX = 0;
        }
        else if(B == 1 && !NPC[A]->CanWalkOn /*&& !NPC[A]->JumpHurt*/) // JumpHurt checked at the top
        {
            NPC[A].Killed = B;
            NPC[A].Location.SpeedY = 0.123_n;
            NPC[A].Location.SpeedX = 0;
        }

        if(B == 1 && NPC[A].Type == NPCID_CARRY_BUDDY)
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
        if((B == 1 || B == 8) && (NPC[A].Type == NPCID_SPIKY_THROWER || NPC[A].Type == NPCID_ITEM_THROWER))
            NPC[A].Killed = B;
    }
    // Exits
    else if(NPCIsAnExit(NPC[A].Type))
    {
        if(B == 6)
        {
            NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            PlaySoundSpatial(SFX_Lava, NPC[A].Location);
            NPC[A].ResetLocation();
            NPCQueues::Unchecked.push_back(A);
        }
    }
    // non type-based logic
    // Coins
    else if(NPC[A]->IsACoin)
    {
        if(LevelEditor)
            PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);

        if(B == 2)
        {
            if(NPC[A].Type == NPCID_GEM_1 || NPC[A].Type == NPCID_GEM_5 || NPC[A].Type == NPCID_GEM_20)
            {
                PlaySoundSpatial(SFX_HeroRupee, NPC[A].Location);
                NewEffect(EFFID_COIN_COLLECT, NPC[A].Location);
                MoreScore(1, NPC[A].Location);
            }
            else if(NPC[A].Type == NPCID_COIN_5 || NPC[A].Type == NPCID_RED_COIN)
            {
                PlaySoundSpatial(SFX_Coin, NPC[A].Location);
                NewEffect(EFFID_COIN_COLLECT, NPC[A].Location);
                MoreScore(1, NPC[A].Location);
            }
            else if(g_config.fix_medal_kill && NPC[A].Type == NPCID_MEDAL)
            {
                NewEffect(EFFID_COIN_COLLECT, NPC[A].Location);
                CollectMedal(NPC[A]);
            }
            else
            {
                // useless self-assignment code [PVS-Studio]
                //NPC[A].Location.X = NPC[A].Location.X; // - (32 - .Location.Width) / 2
                NPC[A].Location.set_height_floor(0);
                PlaySoundSpatial(SFX_Coin, NPC[A].Location);
                NewEffect(EFFID_COIN_BLOCK_S3, NPC[A].Location);
            }

            NPC[A].Killed = 9;

            if(NPC[A].Type == NPCID_GEM_5 || NPC[A].Type == NPCID_COIN_5)
                Coins += 5;
            else if(NPC[A].Type == NPCID_GEM_20)
                Coins += 20;
            else
                Coins += 1;

            if(Coins >= 100)
                Got100Coins();
        }
        else if(B == 5 || B == 3 || B == 4 || B == 6)
            NPC[A].Killed = B;
        else if(B == 10)
        {
            if(C > 0)
                TouchBonus(C, A);
        }
    }
    // Bonus Items
    else if(NPC[A]->IsABonus)
    {
        if(B == 2 && NPC[A].Location.SpeedY > -4)
        {
            PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            NPC[A].Location.SpeedY = -5;
            NPC[A].Location.Y = Block[C].Location.Y - NPC[A].Location.Height - 0.01_n;
        }
        // B == 6 - touched a lava block, C is a block, not NPC!!!
        else if(B == 6 && g_config.fix_powerup_lava_bug)
        {
            NPC[A].Killed = B;
        }
        else if(B == 6 && C > maxNPCs)
        {
            pLogWarning("SMBX64 engine would have crashed on illegal index to NPC %d (maximum legal index %d)", C, maxNPCs);
            NPC[A].Killed = B;
        }
        // B == 6 - old behavior, access index C as an NPC
        else if(B == 6 || B == 5 || B == 4)
        {
            if(!(NPC[C].Type == NPCID_PLR_FIREBALL || NPC[C].Type == NPCID_PET_FIRE || NPC[C].Type == NPCID_PLR_HEAVY || NPCIsVeggie(NPC[C].Type)))
                NPC[A].Killed = B;
        }
        else if(B == 7)
        {
            if(NPC[A].Type == NPCID_POWER_S3 || NPC[A].Type == NPCID_SWAP_POWER || NPC[A].Type == NPCID_FIRE_POWER_S3 ||
               NPC[A].Type == NPCID_LIFE_S3 || NPC[A].Type == NPCID_POISON || NPC[A].Type == NPCID_STATUE_POWER ||
               (NPC[A].Type >= NPCID_FIRE_POWER_S1 && NPC[A].Type <= NPCID_3_LIFE) || NPC[A].Type == NPCID_HEAVY_POWER
               || NPC[A].Type == NPCID_AQUATIC_POWER || NPC[A].Type == NPCID_POLAR_POWER || NPC[A].Type == NPCID_SHELL_POWER)
            {
                NPC[A].Direction = Player[C].Direction;
                NPC[A].Location.SpeedX = num_t::abs(NPC[A].Location.SpeedX) * NPC[A].Direction;
                NPC[A].TurnAround = false;
                NPC[A].Location.SpeedY = -6;
                PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
            }
        }
        else if(B == 10 && NPC[A].Type != NPCID_POISON)
        {
            if(C > 0 && NPC[A].Effect == NPCEFF_NORMAL)
                TouchBonus(C, A);
        }
    }

    if(NPC[A].Killed == 10)
        NPC[A].Direction = Player[C].Direction;

    bool tempBool = false;
    if(NPC[A].Killed == 3)
    {
        if(NPC[C].Type == NPCID_PLR_FIREBALL && NPC[C].Special == 5 && NPC[A].Type != NPCID_PLR_FIREBALL)
        {
            NPC[A].Direction = NPC[C].Direction;
            NPC[A].Killed = 10;
            tempBool = true;
        }
    }

    if(NPC[A].Killed == 10)
    {
        if(tempBool)
            MoreScore(NPC[A]->Score, NPC[A].Location, NPC[C].Multiplier);
        else
            MoreScore(NPC[A]->Score, NPC[A].Location, Player[C].Multiplier);
    }
    // Calculate Score
    Player[0].Multiplier = 0;
    if((B == 1 || B == 8) && C <= numPlayers && !NPC[A]->IsABonus)
    {
        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_COIN_SWITCH || NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_TNT)
        {
        }
        else if(oldNPC.Type == NPCID_LIT_BOMB_S3 || NPC[A].Type == NPCID_SLIDE_BLOCK || oldNPC.Type == NPCID_HIT_CARRY_FODDER || NPC[A].Type == NPCID_CHASER || (oldNPC->IsAShell && B != 8))
        {
            if(B != 8) // (.Type = 45 And B = 8) Then
            {
                if(NPC[A].Type != NPCID_FLIPPED_RAINBOW_SHELL)
                {
                    // MoreScore 1, .Location
                    if(Player[C].Multiplier > NPC[A].Multiplier)
                        NPC[A].Multiplier = Player[C].Multiplier;
                }
            }
        }
        else if(NPC[A].Location.SpeedX != oldNPC.Location.SpeedX || NPC[A].Location.SpeedY != oldNPC.Location.SpeedY ||
                /*NPC[A].Projectile != NPC[A].Projectile ||*/ // FIXME: Wrong condition, always false [PVS Studio]
                NPC[A].Killed != oldNPC.Killed ||
                NPC[A].Type != oldNPC.Type || NPC[A].Inert != oldNPC.Inert)
        {
            if(NPC[A].Type == NPCID_MINIBOSS && NPC[A].Killed == 0)
            {
                MoreScore(2, NPC[A].Location, Player[C].Multiplier);
                if(Player[C].Multiplier > NPC[A].Multiplier)
                    NPC[A].Multiplier = Player[C].Multiplier;
            }
            else
            {
                MoreScore(NPC[A]->Score, NPC[A].Location, Player[C].Multiplier);
                if(Player[C].Multiplier > NPC[A].Multiplier)
                    NPC[A].Multiplier = Player[C].Multiplier;
            }
        }
    }

    if((B == 2 || B == 7) && !NPC[A]->IsABonus && oldNPC.Type != NPCID_RAINBOW_SHELL && NPC[A].Type != NPCID_EARTHQUAKE_BLOCK)
    {
        if(NPC[A].Killed != 0 || NPC[A].Type != oldNPC.Type)
        {
            MoreScore(NPC[A]->Score, NPC[A].Location);
            if(B == 2)
                NewEffect(EFFID_WHACK, newLoc(NPC[A].Location.X, NPC[A].Location.Y + NPC[A].Location.Height - 16));
        }
        else if(NPC[A].Location.SpeedX != oldNPC.Location.SpeedX ||
                NPC[A].Location.SpeedY != oldNPC.Location.SpeedY /*||
                NPC[A].Projectile != NPC[A].Projectile*/) // FIXME: Wrong condition, always false [PVS Studio]
        {
            // MoreScore 1, .Location
            if(B == 2)
                NewEffect(EFFID_WHACK, newLoc(NPC[A].Location.X, NPC[A].Location.Y + NPC[A].Location.Height - 16));
        }
    }

    if(B == 4 && NPC[A].Killed == 4 && !NPC[A]->IsACoin && C != A && NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PLR_ICEBALL && NPC[A].Type != NPCID_PET_FIRE && NPC[A].Type != NPCID_EARTHQUAKE_BLOCK)
    {
        if(NPC[C].Type != NPCID_BOSS_CASE)
        {
            if(!(NPC[A].Type == NPCID_BULLET && NPC[A].CantHurt > 0))
            {
                if(NPC[C].Multiplier < NPC[A].Multiplier)
                    NPC[C].Multiplier = NPC[A].Multiplier;
                MoreScore(NPC[A]->Score, NPC[A].Location, NPC[C].Multiplier);
            }
        }
    }

    if(B == 5 && NPC[A].Killed == 5)
    {
        if(NPC[A].Multiplier < NPC[C].Multiplier)
            NPC[A].Multiplier = NPC[C].Multiplier;
        MoreScore(NPC[A]->Score, NPC[A].Location, NPC[A].Multiplier);
    }

    if(B == 6 && NPC[A].Killed == 6 && (NPC[A].Type == NPCID_BOSS_FRAGILE || NPC[A].Type == NPCID_VILLAIN_S1 || NPC[A].Type == NPCID_SICK_BOSS || NPC[A].Type == NPCID_MINIBOSS || NPC[A].Type == NPCID_SPIT_BOSS || NPC[A].Type == NPCID_VILLAIN_S3))
    {
        if(!NPC[A]->WontHurt && !NPC[A]->IsABonus && NPC[A].Type != NPCID_PLR_FIREBALL)
            MoreScore(NPC[A]->Score, NPC[A].Location);
    }

    if(!NPC[A]->IsACoin && B == 3 && C != A &&
       (NPC[A].Killed == B || NPC[A].Damage != oldNPC.Damage) &&
        NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PET_FIRE && NPC[A].Type != NPCID_SLIDE_BLOCK &&
        NPC[A].Type != NPCID_HOMING_BALL && NPC[A].Type != NPCID_EARTHQUAKE_BLOCK)
    {
        if(NPC[A].Killed == B)
        {
            if(NPC[C].Multiplier < NPC[A].Multiplier)
                NPC[C].Multiplier = NPC[A].Multiplier;
            MoreScore(NPC[A]->Score, NPC[A].Location, NPC[C].Multiplier);
        }
        if(NPC[A].Type != NPCID_BOSS_CASE && NPC[A].Type != NPCID_BOSS_FRAGILE)
        {
            Location_t tempLocation = NPC[C].Location;

            if(NPC[A].Location.Width >= 64 || NPC[A].Location.Height >= 64)
            {
                tempLocation.X = NPC[C].Location.X + NPC[C].Location.Width / 2 - 16 + NPC[C].Location.SpeedX;
                tempLocation.Y = NPC[C].Location.Y + NPC[C].Location.Height / 2 - 16 + NPC[C].Location.SpeedY;
            }
            else
            {
                tempLocation.Y = (NPC[C].Location.Y + tempLocation.Y + (NPC[C].Location.Height + tempLocation.Height) / 2) / 2 - 16;
                tempLocation.X = (NPC[C].Location.X + tempLocation.X + (NPC[C].Location.Width + tempLocation.Width) / 2) / 2 - 16;
            }

            NewEffect(EFFID_WHACK, tempLocation);
        }
    }

    if(NPC[A].Killed == 6)
    {
        if(BlockKills2[Block[C].Type])
            NPC[A].NoLavaSplash = true;
    }

    // lose wings and get an extra hit if not a boss
    if(NPC[A].Wings && NPC[A].Damage == 0 && (B == 1 || B == 2 || B == 7))
    {
        if(B == 1 && NPC[A].Location.SpeedY < 0)
            NPC[A].Location.SpeedY = 0;

        PlaySoundSpatial((B == 1) ? SFX_Stomp : SFX_ShellHit, NPC[A].Location);

        NPC[A].Killed = 0;
        if(!NPC[A].Immune)
            NPC[A].Immune = 4;
        NPC[A].Wings = WING_NONE;
    }

    if(NPC[A].Killed == 0 && NPC[A].Location.SpeedX == 0 && oldNPC.Location.SpeedX != 0)
        NPC[A].RealSpeedX = 0;

    if(NPC[A].Killed != 0 && oldNPC.Killed == 0)
        NPCQueues::Killed.push_back(A);

    if(NPC[A].Type != oldNPC.Type)
    {
        NPC[A].Location.set_height_floor(NPC[A]->THeight);
        NPC[A].Location.set_width_center(NPC[A]->TWidth);
    }

    if(NPC[A].Location.Width != oldNPC.Location.Width
        || NPC[A].Location.Height != oldNPC.Location.Height
        || NPC[A].Location.X != oldNPC.Location.X
        || NPC[A].Location.Y != oldNPC.Location.Y)
    {
        if(NPC[A].Location.Width != oldNPC.Location.Width)
            NPCQueues::Unchecked.push_back(A);

        bool changed = treeNPCUpdate(A);
        if(changed && NPC[A].tempBlock > 0)
            treeNPCSplitTempBlock(A);

    }

    StopHit = 0;
}


================================================
FILE: src/npc/npc_kill.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../globals.h"
#include "../npc.h"
#include "../npc_id.h"
#include "../eff_id.h"
#include "../sound.h"
#include "../effect.h"
#include "../layers.h"
#include "../game_main.h"
#include "../main/speedrunner.h"
#include "config.h"
#include "../controls.h"
#include "../layers.h"

#include "npc_traits.h"

#include "sdl_proxy/sdl_stdinc.h"

#include "npc/npc_queues.h"

#include "main/game_loop_interrupt.h"

static void s_makeSparkles(const NPC_t& npc, int speed_random, int speed_mult)
{
    NewEffect(EFFID_SMOKE_S3, npc.Location);

    Location_t tempLocation;
    tempLocation.Height = EffectHeight[EFFID_SPARKLE];
    tempLocation.Width = EffectWidth[EFFID_SPARKLE];
    tempLocation.SpeedX = 0;
    tempLocation.SpeedY = 0;

    num_t tempLocX_base = npc.Location.X - EffectWidth[EFFID_SPARKLE] / 2;
    num_t tempLocY_base = npc.Location.Y - EffectHeight[EFFID_SPARKLE] / 2;

    for(int C = 1; C <= 50; C++)
    {
        tempLocation.X = tempLocX_base + dRand().times(npc.Location.Width);
        tempLocation.Y = tempLocY_base + dRand().times(npc.Location.Height);
        NewEffect(EFFID_SPARKLE, tempLocation);

        Effect[numEffects].Location.SpeedX = (dRand() - 0.5_n) * speed_random - npc.Location.SpeedX * speed_mult / 10;
        Effect[numEffects].Location.SpeedY = (dRand() - 0.5_n) * speed_random + npc.Location.SpeedY * speed_mult / 10;
        Effect[numEffects].Frame = iRand(3);
    }
}

bool KillNPC(int A, int B)
{
    // ------+  KILL CODES  +-------
    // B = 1      Jumped on by a player (or kicked)
    // B = 2      Hit by a shaking block
    // B = 3      Hit by projectile
    // B = 4      Hit something as a projectile
    // B = 5      Hit something while being held
    // B = 6      Touched a lava block
    // B = 8      Stomped by boot
    // B = 9      Time to DIE
    // B = 10     Zelda Stab
    // bool DontSpawnExit = false;
    // bool DontResetMusic = false;
    // bool tempBool = false;
    // NPC_t blankNPC;
    int C = 0;
    Location_t tempLocation;

    switch(g_gameLoopInterrupt.site)
    {
    case GameLoopInterrupt::UpdateNPCs_KillNPC:
        if(g_gameLoopInterrupt.bool1)
            goto resume_TriggerLast;
        else
            goto resume_TriggerDeath;
    default:
        break;
    }

    // don't need to worry about updating NPC A's tree because that will certainly happen in either the syncLayersNPC or the Deactivate call at the end of the procedure

    if(NPC[A].Type == NPCID_ICE_CUBE && NPC[A].Special > 0 && NPC[A].Killed != 9)
    {
        s_makeSparkles(NPC[A], 4, 2);
        PlaySoundSpatial(SFX_Icebreak, NPC[A].Location);
        NPC[A].Type = NPCID(NPC[A].Special);

        NPCQueues::update(A);

        if(B != 10)
        {
            MoreScore(NPC[A]->Score, NPC[A].Location, NPC[A].Multiplier);
        }

        NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.4_r;
        if(NPC[A].Location.SpeedX < 2 && NPC[A].Location.SpeedX > -2)
            NPC[A].Location.SpeedX = 2 * NPC[A].Direction;
    }

    if(NPC[A].Killed == 8 && NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_KNIGHT && !NPCIsABot(NPC[A]) && NPC[A].Type != NPCID_FLIER && NPC[A].Type != NPCID_ROCKET_FLIER && NPC[A].Type != NPCID_WALL_BUG && NPC[A].Type != NPCID_HOMING_BALL)
        NewEffect(EFFID_BOOT_STOMP, NPC[A].Location);

    if(NPC[A].Type == NPCID_YELSWITCH_FODDER || NPC[A].Type == NPCID_BLUSWITCH_FODDER || NPC[A].Type == NPCID_GRNSWITCH_FODDER || NPC[A].Type == NPCID_REDSWITCH_FODDER
        || NPC[A].DefaultType == NPCID_YELSWITCH_FODDER || NPC[A].DefaultType == NPCID_BLUSWITCH_FODDER || NPC[A].DefaultType == NPCID_GRNSWITCH_FODDER || NPC[A].DefaultType == NPCID_REDSWITCH_FODDER)
    {
        bool tempBool = false;

        for(C = 1; C <= numNPCs; C++)
        {
            // WARNING: this does not check DefaultType
            if(NPC[C].Type == NPC[A].Type && NPC[C].Section == NPC[A].Section && C != A)
            {
                tempBool = true;
                break;
            }
        }

        if(LevelEditor)
            tempBool = true;

        if(!tempBool)
        {
            if(NPC[A].Type == NPCID_YELSWITCH_FODDER || NPC[A].DefaultType == NPCID_YELSWITCH_FODDER)
            {
                PlaySoundSpatial(SFX_PSwitch, NPC[A].Location);
                for(C = 1; C <= numBlock; C++)
                {
                    if(Block[C].Type == 171)
                        Block[C].Type = 172;
                    else if(Block[C].Type == 172)
                        Block[C].Type = 171;
                }
                for(C = 1; C <= numNPCs; C++)
                {
                    if(NPC[C].Type == NPCID_YEL_PLATFORM)
                        NPC[C].Direction = -NPC[C].Direction;
                }
            }
            else if(NPC[A].Type == NPCID_BLUSWITCH_FODDER || NPC[A].DefaultType == NPCID_BLUSWITCH_FODDER)
            {
                PlaySoundSpatial(SFX_PSwitch, NPC[A].Location);
                for(C = 1; C <= numBlock; C++)
                {
                    if(Block[C].Type == 174)
                        Block[C].Type = 175;
                    else if(Block[C].Type == 175)
                        Block[C].Type = 174;
                }
                for(C = 1; C <= numNPCs; C++)
                {
                    if(NPC[C].Type == NPCID_BLU_PLATFORM)
                        NPC[C].Direction = -NPC[C].Direction;
                }
            }
            else if(NPC[A].Type == NPCID_GRNSWITCH_FODDER || NPC[A].DefaultType == NPCID_GRNSWITCH_FODDER)
            {
                PlaySoundSpatial(SFX_PSwitch, NPC[A].Location);
                for(C = 1; C <= numBlock; C++)
                {
                    if(Block[C].Type == 177)
                        Block[C].Type = 178;
                    else if(Block[C].Type == 178)
                        Block[C].Type = 177;
                }
                for(C = 1; C <= numNPCs; C++)
                {
                    if(NPC[C].Type == NPCID_GRN_PLATFORM)
                        NPC[C].Direction = -NPC[C].Direction;
                }
            }
            else if(NPC[A].Type == NPCID_REDSWITCH_FODDER || NPC[A].DefaultType == NPCID_REDSWITCH_FODDER)
            {
                PlaySoundSpatial(SFX_PSwitch, NPC[A].Location);
                for(C = 1; C <= numBlock; C++)
                {
                    if(Block[C].Type == 180)
                        Block[C].Type = 181;
                    else if(Block[C].Type == 181)
                        Block[C].Type = 180;
                }
                for(C = 1; C <= numNPCs; C++)
                {
                    if(NPC[C].Type == NPCID_RED_PLATFORM)
                        NPC[C].Direction = -NPC[C].Direction;
                }
            }
        }
    }

    if(NPC[A].TriggerDeath != EVENT_NONE && !LevelEditor)
    {
        eventindex_t resume_index;
        resume_index = ProcEvent_Safe(false, NPC[A].TriggerDeath, 0);
        while(resume_index != EVENT_NONE)
        {
            g_gameLoopInterrupt.C = resume_index;
            g_gameLoopInterrupt.bool1 = false; // marks as TriggerDeath
            return true;

resume_TriggerDeath:
            resume_index = g_gameLoopInterrupt.C;
            g_gameLoopInterrupt.site = GameLoopInterrupt::None;

            resume_index = ProcEvent_Safe(true, resume_index, 0);
        }
    }

    if(NPC[A].TriggerLast != EVENT_NONE)
    {
        bool last_in_layer;

        {
            last_in_layer = true;

            int lr = NPC[A].Layer;
            if(lr != LAYER_NONE)
            {
                for(int other_npc : Layer[lr].NPCs)
                {
                    if(other_npc != A && !NPC[other_npc].Generator)
                    {
                        last_in_layer = false;
                        break;
                    }
                }

                if(!Layer[lr].blocks.empty())
                    last_in_layer = false;
            }
        }

        if(last_in_layer)
        {
            eventindex_t resume_index;
            resume_index = ProcEvent_Safe(false, NPC[A].TriggerLast, 0);
            while(resume_index != EVENT_NONE)
            {
                g_gameLoopInterrupt.C = resume_index;
                g_gameLoopInterrupt.bool1 = true; // marks as TriggerLast
                return true;

resume_TriggerLast:
                resume_index = g_gameLoopInterrupt.C;
                g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                resume_index = ProcEvent_Safe(true, resume_index, 0);
            }
        }
    }

    num_t NPC_CenterX = NPC[A].Location.X + NPC[A].Location.Width / 2;
    num_t NPC_CenterY = NPC[A].Location.Y + NPC[A].Location.Height / 2;
    num_t NPC_BottomY = NPC[A].Location.Y + NPC[A].Location.Height;

    if(NPC[A].HoldingPlayer > 0)
    {
        if(!NPCIsAnExit(NPC[A])) // Tell the player the NPC he was holding is dead
            Player[NPC[A].HoldingPlayer].HoldingNPC = 0;
    }

    if(NPC[A].Killed == 10) // Things that die by Link's sword
    {
        if(!(NPC[A].Type == NPCID_MINIBOSS || NPC[A].Type == NPCID_SPIT_BOSS || NPC[A].Type == NPCID_VILLAIN_S3 || NPC[A].Type == NPCID_BOSS_FRAGILE || NPC[A].Type == NPCID_VILLAIN_S1 || NPC[A].Type == NPCID_SICK_BOSS || NPC[A].Type == NPCID_FLIER || NPC[A].Type == NPCID_ROCKET_FLIER || NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_HOMING_BALL || NPC[A].Type == NPCID_BOSS_CASE))
        {
            PlaySoundSpatial(SFX_HeroKill, NPC[A].Location);
            NewEffect(EFFID_SMOKE_S5, NPC[A].Location);
            B = 9;
            if(iRand(10) < 3)
            {
                numNPCs++;
                NPC[numNPCs].Type = NPCID_GEM_1;
                if(iRand(5) == 0)
                    NPC[numNPCs].Type = NPCID_GEM_5;
                if(iRand(40) < 3)
                    NPC[numNPCs].Type = NPCID_GEM_20;
                NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                NPC[numNPCs].Location.X = NPC_CenterX - NPC[numNPCs].Location.Width / 2;
                NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                if(NPC[A].Location.Height >= 32)
                    NPC[numNPCs].Location.Y = NPC_CenterY - NPC[numNPCs].Location.Height / 2;
                else if(NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_LONG_PLANT_DOWN) // Stops the rupees from spawning in blocks
                    NPC[numNPCs].Location.Y = NPC[A].Location.Y + 1;
                else // Stops the rupees from spawning in blocks
                    NPC[numNPCs].Location.Y = NPC_BottomY - NPC[numNPCs].Location.Height - 1;
                NPC[numNPCs].Section = NPC[A].Section;
                NPC[numNPCs].TimeLeft = Physics.NPCTimeOffScreen;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].TailCD = 10;
                NPC[numNPCs].Special = 1;
                NPC[numNPCs].Location.SpeedY = -5;
                NPC[numNPCs].Location.SpeedX = (1 + dRand() / 2) * NPC[A].Direction;
                syncLayers_NPC(numNPCs);
                CheckSectionNPC(numNPCs);
            }
        }
    }

    if(B != 9)
    {
        NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
        if(NPC[A].Type == NPCID_SQUID_S1 || NPC[A].Type == NPCID_SQUID_S3 || NPC[A].Type == NPCID_FODDER_S3 || NPC[A].Type == NPCID_FODDER_S5 || NPC[A].Type == NPCID_FLY_FODDER_S5 || NPC[A].Type == NPCID_FLY_FODDER_S3 || NPC[A].Type == NPCID_BRUTE || NPC[A].Type == NPCID_BRUTE_SQUISHED || NPC[A].Type == NPCID_BIG_GUY || NPC[A].Type == NPCID_CARRY_FODDER || NPC[A].Type == NPCID_HIT_CARRY_FODDER || NPC[A].Type == NPCID_FLY_CARRY_FODDER || NPC[A].Type == NPCID_GRN_FISH_S3 || NPC[A].Type == NPCID_YEL_FISH_S4 || NPC[A].Type == NPCID_RED_FISH_S3 || NPC[A].Type == NPCID_GRN_FISH_S4 || NPC[A].Type == NPCID_GRN_FISH_S1 || NPC[A].Type == NPCID_BONE_FISH || NPC[A].Type == NPCID_ICE_BLOCK || NPC[A].Type == NPCID_ICE_CUBE) // Goomba / Rex
        {
            if(B == 1 && NPC[A].Type != NPCID_GRN_FISH_S3 && NPC[A].Type != NPCID_YEL_FISH_S4 && NPC[A].Type != NPCID_RED_FISH_S3 && NPC[A].Type != NPCID_GRN_FISH_S4 && NPC[A].Type != NPCID_GRN_FISH_S1 && NPC[A].Type != NPCID_BONE_FISH)
            {
                if(NPC[A].Type == NPCID_FODDER_S3)
                    NewEffect_NpcSquish(EFFID_FODDER_S3_SQUISH, NPC[A]);
                else if(NPC[A].Type == NPCID_FODDER_S5)
                    NewEffect_NpcSquish(EFFID_FODDER_S5_SQUISH, NPC[A]);
                else if(NPC[A].Type == NPCID_SQUID_S1 && g_config.fix_squid_stomp_effect)
                {
                    NPC[A].Location.SpeedY = 0.123_n;
                    NewEffect_NpcDie(EFFID_SQUID_S1_DIE, NPC[A]);
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                }
                else if(NPC[A].Type == NPCID_SQUID_S3 && g_config.fix_squid_stomp_effect)
                {
                    NPC[A].Location.SpeedY = 0.123_n;
                    NewEffect_NpcDie(EFFID_SQUID_S3_DIE, NPC[A]);
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                }
                else
                    NewEffect_NpcSquish(EFFID_BRUTE_SQUISH, NPC[A]);
            }
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NPC[A].Location.X = NPC_CenterX - 16;
                NPC[A].Location.Width = 32;
                NPC[A].Location.Y = NPC_BottomY - 32;
                NPC[A].Location.Height = 32;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                if(NPC[A].Type == NPCID_ICE_BLOCK) // Yoshi's ice break
                    PlaySoundSpatial(SFX_Icebreak, NPC[A].Location);
                else
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound

                if(NPC[A].Type == NPCID_FODDER_S3 || NPC[A].Type == NPCID_FLY_FODDER_S3)
                    NewEffect_NpcDie(EFFID_FODDER_S3_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_FODDER_S5 || NPC[A].Type == NPCID_FLY_FODDER_S5)
                    NewEffect_NpcDie(EFFID_FODDER_S5_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_SQUID_S3)
                    NewEffect_NpcDie(EFFID_SQUID_S3_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_SQUID_S1)
                    NewEffect_NpcDie(EFFID_SQUID_S1_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_BRUTE)
                    NewEffect_NpcDie(EFFID_BRUTE_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_BIG_GUY)
                    NewEffect_NpcDie(EFFID_BIG_GUY_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_BRUTE_SQUISHED)
                    NewEffect_NpcDie(EFFID_BRUTE_SQUISHED_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_GRN_FISH_S3)
                {
                    NPC[A].Location.SpeedY = -11;
                    if(B == 1)
                        NPC[A].Location.SpeedY = -2;
                    NewEffect_NpcDie(EFFID_GRN_FISH_S3_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_YEL_FISH_S4)
                {
                    NPC[A].Location.SpeedY = -11;
                    if(B == 1)
                        NPC[A].Location.SpeedY = -2;
                    NewEffect_NpcDie(EFFID_YEL_FISH_S4_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_RED_FISH_S3)
                {
                    NPC[A].Location.SpeedY = -11;
                    if(B == 1)
                        NPC[A].Location.SpeedY = -2;
                    NewEffect_NpcDie(EFFID_RED_FISH_S3_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_GRN_FISH_S4)
                {
                    NPC[A].Location.SpeedY = -11;
                    if(B == 1)
                        NPC[A].Location.SpeedY = -2;
                    NewEffect_NpcDie(EFFID_GRN_FISH_S4_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_GRN_FISH_S1)
                {
                    NPC[A].Location.SpeedY = -11;
                    if(B == 1)
                        NPC[A].Location.SpeedY = -2;
                    NewEffect_NpcDie(EFFID_GRN_FISH_S1_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_BONE_FISH)
                {
                    NPC[A].Location.SpeedY = -11;
                    if(B == 1)
                        NPC[A].Location.SpeedY = -2;
                    NewEffect_NpcDie(EFFID_BONE_FISH_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_ICE_BLOCK || NPC[A].Type == NPCID_ICE_CUBE)
                {
                    s_makeSparkles(NPC[A], 2, 3);
                }
                else
                    NewEffect_NpcDie(EFFID_CARRY_FODDER_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_FLIER || NPC[A].Type == NPCID_ROCKET_FLIER || NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_HOMING_BALL)
        {
            PlaySoundSpatial(SFX_SMKilled, NPC[A].Location);
            NewEffect(EFFID_BOSS_FRAGILE_EXPLODE, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_BOSS_CASE)
        {
            PlaySoundSpatial(SFX_SMGlass, NPC[A].Location);
            for(C = 1; C <= 100; C++)
            {
                num_t dx = dRand();
                num_t dy = dRand();
                NewEffect(EFFID_BOSS_CASE_BREAK, newLoc(NPC[A].Location.X + dx.times(NPC[A].Location.Width) - 16, NPC[A].Location.Y + dy.times(NPC[A].Location.Height) - 16));
            }
        }
        else if(NPC[A].Type == NPCID_BOSS_FRAGILE)
        {
            PlaySoundSpatial(SFX_SMCry, NPC[A].Location);
            PlaySoundSpatial(SFX_SMExplosion, NPC[A].Location);
            NewEffect(EFFID_BOSS_FRAGILE_DIE, NPC[A].Location, NPC[A].Direction);
        }
        else if(NPC[A].Type == NPCID_GHOST_S3 || NPC[A].Type == NPCID_GHOST_FAST || NPC[A].Type == NPCID_GHOST_S4 || NPC[A].Type == NPCID_BIG_GHOST || NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_FIRE_DISK)
        {
            PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
            NPC[A].Location.SpeedY = -10;
            if(NPC[A].Type == NPCID_GHOST_S3)
                NewEffect_NpcDie(EFFID_GHOST_S3_DIE, NPC[A]);
            else if(NPC[A].Type == NPCID_GHOST_FAST)
                NewEffect_NpcDie(EFFID_GHOST_FAST_DIE, NPC[A]);
            else if(NPC[A].Type == NPCID_GHOST_S4)
                NewEffect_NpcDie(EFFID_GHOST_S4_DIE, NPC[A]);
            else if(NPC[A].Type == NPCID_WALL_SPARK)
                NewEffect_NpcDie(EFFID_WALL_SPARK_DIE, NPC[A]);
            else if(NPC[A].Type == NPCID_FIRE_DISK)
            {
                NewEffect_NpcDie(EFFID_FIRE_DISK_DIE, NPC[A]);
                Effect[numEffects].Frame = NPC[A].Frame;
                Effect[numEffects].Life = 100;
            }
            else
                NewEffect_NpcDie(EFFID_BIG_GHOST_DIE, NPC[A]);
        }
        else if(NPC[A].Type == NPCID_CHASER) // bully
        {
            NPC[A].Location.SpeedY = -8;
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_BottomY - EffectHeight[EFFID_SMOKE_S3];
                NPC[A].Location.Width = 32;
                NPC[A].Location.Height = 32;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect_NpcDie(EFFID_CHASER_DIE, NPC[A]);
            }

        }
        // turnips
        else if(NPCIsVeggie(NPC[A]))
        {
            NPC[A].Location.Y = NPC_BottomY - 32;
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
            NPC[A].Location.Y += NPC[A].Location.Height / 2 - EffectHeight[EFFID_SMOKE_S3] / 2;
            NPC[A].Location.Height = 32;
            NPC[A].Location.Width = 32;
            if(NPC[A].Killed == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
        }
        else if(NPC[A].Type == NPCID_COIN_SWITCH) // P Switch
        {
            if(B == 1)
            {
                NPC[A].Location.Y += 2;
                NewEffect(EFFID_COIN_SWITCH_PRESS, NPC[A].Location);
            }
            else if(B == 2)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            }
        }
        else if(NPC[A].Type == NPCID_TIME_SWITCH) // P Switch Time
        {
            if(B == 1)
            {
                NPC[A].Location.Y += 2;
                NewEffect(EFFID_TIME_SWITCH_PRESS, NPC[A].Location);
            }
            else if(B == 2)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            }
        }
        else if(NPC[A].Type == NPCID_TNT) // Red Switch
        {
            if(B == 1)
            {
                NPC[A].Location.Y += 2;
                NewEffect(EFFID_TNT_PRESS, NPC[A].Location);
            }
            else if(B == 2)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            }
        }
        else if((NPC[A].Type == NPCID_STATUE_S3 || NPC[A].Type == NPCID_STATUE_S4) && B == 6) // lava only
        {
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
            NPC[A].Location.Y = NPC_BottomY - 32;
            NPC[A].Location.Height = 32;
            NPC[A].Location.Width = 32;
            PlaySoundSpatial(SFX_Lava, NPC[A].Location);
            NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            if(!NPC[A].NoLavaSplash)
                NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_SAW || NPC[A].Type == NPCID_STONE_S4) // thwomp
        {
            if(B == 6)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_BottomY - 32;
                NPC[A].Location.Height = 32;
                NPC[A].Location.Width = 32;
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(NPC[A].Type == NPCID_SAW)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NPC[A].Location.SpeedY = -10;
                NPC[A].Location.Width = 64;
                NPC[A].Location.Height = 64;
                NPC[A].Location.X -= 8;
                NPC[A].Location.Y -= 8;
                NewEffect_NpcDie(EFFID_SAW_DIE, NPC[A]);
            }
            else if(B == 3 || B == 4 || B == 2)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NPC[A].Location.SpeedY = -10;
                if(NPC[A].Type == NPCID_STONE_S3)
                    NewEffect_NpcDie(EFFID_STONE_S3_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_STONE_S4)
                    NewEffect_NpcDie(EFFID_STONE_S4_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_WALK_BOMB_S3 || NPC[A].Type == NPCID_LIT_BOMB_S3)
        {
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NPC[A].Location.SpeedY = -11;
                NewEffect_NpcDie(EFFID_WALK_BOMB_S3_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_FODDER_S1) // SMB1 Goomba
        {
            if(B == 1)
                NewEffect_NpcSquish(EFFID_FODDER_S1_SQUISH, NPC[A]);
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_FODDER_S1_DIE, NPC[A]);
            }
        // Zelda NPCs
        }
        else if(NPC[A].Type == NPCID_KNIGHT || NPCIsABot(NPC[A]) || NPC[A].Type == NPCID_LOCK_DOOR)
        {
            PlaySoundSpatial(SFX_HeroKill, NPC[A].Location);
            NewEffect(EFFID_SMOKE_S5, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_SPIT_GUY_BALL)
        {
            NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX * 0.3_r;
            NewEffect(EFFID_SPIT_GUY_BALL_DIE, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_YELSWITCH_FODDER || NPC[A].Type == NPCID_BLUSWITCH_FODDER || NPC[A].Type == NPCID_GRNSWITCH_FODDER || NPC[A].Type == NPCID_REDSWITCH_FODDER) // switch goombas
        {
            if(B == 1)
            {
                NewEffect_NpcSquish((EFFID)((NPC[A].Type - NPCID_YELSWITCH_FODDER) + EFFID_YELSWITCH_FODDER_SQUISH), NPC[A]);
            }
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie((EFFID)((NPC[A].Type - NPCID_YELSWITCH_FODDER) + EFFID_YELSWITCH_FODDER_DIE), NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_MAGIC_BOSS || NPC[A].Type == NPCID_MAGIC_BOSS_SHELL || NPC[A].Type == NPCID_FIRE_BOSS || NPC[A].Type == NPCID_FIRE_BOSS_SHELL) // larry koopa
        {
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(NPC[A].Type == NPCID_FIRE_BOSS || NPC[A].Type == NPCID_FIRE_BOSS_SHELL)
                NewEffect(EFFID_FIRE_BOSS_DIE, NPC[A].Location);
            else
                NewEffect(EFFID_MAGIC_BOSS_DIE, NPC[A].Location);

        }
        else if(NPC[A].Type == NPCID_SICK_BOSS || NPC[A].Type == NPCID_BOMBER_BOSS) // wart, smb2 bosses
        {
            if(NPC[A].Type == NPCID_BOMBER_BOSS && NPC[A].Killed != 3 && NPC[A].Killed != 6 && NPC[A].Killed != 10)
                PlaySoundSpatial(SFX_SpitBossBeat, NPC[A].Location);

            // If B <> 6 Then MoreScore NPCScore(.Type), .Location
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y += 24;
                NPC[A].Location.Width = 32;
                NPC[A].Location.Height = 32;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else
            {
                NPC[A].Location.SpeedY = -7;
                if(NPC[A].Type == NPCID_BOMBER_BOSS)
                {
                    NewEffect_NpcDie(EFFID_BOMBER_BOSS_DIE, NPC[A]);
                    Effect[numEffects].Location.SpeedX = 0;
                    Effect[numEffects].Location.SpeedY = -8;
                }
                else
                    NewEffect(EFFID_SICK_BOSS_DIE, NPC[A].Location, NPC[A].Direction);
            }
        }
        else if(NPC[A].Type == NPCID_VILLAIN_S1) // king koopa
        {
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y += 24;
                NPC[A].Location.Width = 32;
                NPC[A].Location.Height = 32;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else
            {
                // .Location.Width += 2
                // .Location.X += -1
                NewEffect_NpcDie(EFFID_VILLAIN_S1_DIE, NPC[A]);
            }
            PlaySoundSpatial(SFX_VillainKilled, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_VILLAIN_S3) // bowser
        {
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y += 24;
                NPC[A].Location.Width = 32;
                NPC[A].Location.Height = 32;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else
            {
                NPC[A].Location.Width += 2;
                NPC[A].Location.X -= 1;
                NewEffect_NpcDie(EFFID_VILLAIN_S3_DIE, NPC[A]);
            }
            PlaySoundSpatial(SFX_VillainKilled, NPC[A].Location);

            if(NPC[A].Legacy)
            {
                bool tempBool = false;
                for(B = 1; B <= numNPCs; B++)
                {
                    if(B != A && NPC[B].Type == NPCID_VILLAIN_S3)
                    {
                        tempBool = true;
                        break;
                    }
                }

                if(!tempBool)
                {
                    speedRun_bossDeadEvent();
                    LevelMacroCounter = 0;
                    LevelMacro = LEVELMACRO_GAME_COMPLETE_EXIT;
                }
            }
        }
        else if(NPC[A].Type == NPCID_RED_FODDER || NPC[A].Type == NPCID_RED_FLY_FODDER) // Red goomba
        {
            if(B == 1)
                NewEffect_NpcSquish(EFFID_RED_FODDER_SQUISH, NPC[A]);
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_RED_FODDER_DIE, NPC[A]);
            }
        }
        else if(NPCIsToad(NPC[A])) // toad
        {
            if(B != 2)
            {
                if(B == 6)
                {
                    NPC[A].Location.Y += (NPC[A].Location.Height - 32);
                    PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                    NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                    if(!NPC[A].NoLavaSplash)
                        NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
                }
                else
                {
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                    NewEffect(EFFID_POWER_S3_DIE, NPC[A].Location, NPC[A].Direction);
                }
            }
        }
        else if(NPC[A].Type == NPCID_ITEM_POD) // yoshi egg
        {
            C = NPC[A].Special;
            CharStuff(A, true);
            if(NPC[A].Special == NPCID_RANDOM_POWER)
                NPC[A].Special = RandomBonus();

            if(NewEffect(EFFID_ITEM_POD_OPEN, NPC[A].Location, 1, false))
            {
                if(NPC[A].Special != NPCID_ITEM_POD)
                    Effect[numEffects].NewNpc = NPC[A].Special;
                Effect[numEffects].NewNpcSpecial = NPC[A].Variant;

                // moved from NewEffect
                PlaySoundSpatial((Effect[numEffects].NewNpc != 0) ? SFX_PetBirth : SFX_Smash, NPC[A].Location);
            }

            if(C == 98)
                Effect[numEffects].Frame += 3;
            else if(C == 99)
                Effect[numEffects].Frame += 5;
            else if(C == 100)
                Effect[numEffects].Frame += 7;
            else if(C == 148)
                Effect[numEffects].Frame += 9;
            else if(C == 149)
                Effect[numEffects].Frame += 11;
            else if(C == 150)
                Effect[numEffects].Frame += 13;
            else if(C == 228)
                Effect[numEffects].Frame += 15;
        }
        else if(NPC[A].Type == NPCID_BIG_FODDER) // giagnormous goomba
        {
            if(B == 1)
                NewEffect_NpcSquish(EFFID_BIG_FODDER_SQUISH, NPC[A]);
            else if(B == 6)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_BottomY - 32;
                NPC[A].Location.Height = 32;
                NPC[A].Location.Width = 32;
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_BIG_FODDER_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_UNDER_FODDER) // Grey goomba
        {
            if(B == 1)
                NewEffect_NpcSquish(EFFID_UNDER_FODDER_SQUISH, NPC[A]);
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                if(B != 5)
                    NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                NewEffect_NpcDie(EFFID_UNDER_FODDER_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_EXT_TURTLE) // nekkid koopa
        {
            if(B == 1)
                NewEffect_NpcSquish(EFFID_EXT_TURTLE_SQUISH, NPC[A]);
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                if(B != 5)
                    NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                NewEffect_NpcDie(EFFID_EXT_TURTLE_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_SKELETON) // Dry Bones
        {
            if(B == 6)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_BottomY - 32;
                NPC[A].Location.Height = 32;
                NPC[A].Location.Width = 32;
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else
            {
                NPC[A].Location.Width = 48;
                NPC[A].Location.X -= 8;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect_NpcDie(EFFID_SKELETON_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4) // SMW Beach Koopas
        {
            if(B == 1)
            {
                NewEffect_NpcSquish(EFFID_HIT_TURTLE_S4_SQUISH, NPC[A]);
                Effect[numEffects].Frame = NPC[A].Type - NPCID_GRN_HIT_TURTLE_S4;
            }
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                if(B != 5)
                    NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                NewEffect_NpcDie(EFFID_HIT_TURTLE_S4_DIE, NPC[A]);
                Effect[numEffects].Frame = (NPC[A].Type - NPCID_GRN_HIT_TURTLE_S4) * 4;
                if(NPC[A].Direction == 1)
                    Effect[numEffects].Frame += 2;
            }
        }
        else if(NPC[A].Type == NPCID_GRN_TURTLE_S3 || NPC[A].Type == NPCID_GRN_SHELL_S3 || NPC[A].Type == NPCID_GRN_FLY_TURTLE_S3) // Green Koopa
        {
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
            NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_GRN_SHELL_S3_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_WALL_TURTLE) // spike top
        {
            if(B == 6)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect(EFFID_WALL_TURTLE_DIE, NPC[A].Location, NPC[A].Frame);
            }
        }
        else if(NPC[A].Type == NPCID_GRN_SHELL_S1 || NPC[A].Type == NPCID_GRN_TURTLE_S1 || NPC[A].Type == NPCID_GRN_FLY_TURTLE_S1) // smb1 Green Koopa
        {
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
            NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_GRN_SHELL_S1_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_RED_SHELL_S1 || NPC[A].Type == NPCID_RED_TURTLE_S1 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S1) // smb1 red Koopa
        {
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
            NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_RED_SHELL_S1_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_EARTHQUAKE_BLOCK)
        {
            Controls::RumbleAllPlayers(200, 1.0);

            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else
                NewEffect(EFFID_EARTHQUAKE_BLOCK_HIT, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_BIG_TURTLE || NPC[A].Type == NPCID_BIG_SHELL) // giant Green Koopa
        {
            if(B == 6)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_BottomY - 32;
                NPC[A].Location.Height = 32;
                NPC[A].Location.Width = 32;
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_GRN_SHELL_S3_DIE] * 0.5_n;
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_BIG_SHELL_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_SPIT_BOSS) // Birdo
        {
            PlaySoundSpatial(SFX_SpitBossHit, NPC[A].Location);
            if(NPC[A].Legacy && !LevelEditor)
            {
                bool DontSpawnExit = false;

                for(C = 1; C <= numNPCs; C++)
                {
                    if(NPC[C].Type == NPCID_SPIT_BOSS && C != A)
                    {
                        DontSpawnExit = true;
                        break;
                    }
                }

                if(!DontSpawnExit)
                {
                    numNPCs++;
                    NPC[numNPCs].Type = NPCID_GOALORB_S2;
                    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                    NPC[numNPCs].Location.X = NPC[A].Location.X;
                    NPC[numNPCs].Location.Y = NPC[A].Location.Y;
                    NPC[numNPCs].Location.SpeedY = -6;
                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].TimeLeft = 100;
                    NPC[numNPCs].Frame = 0;
                    syncLayers_NPC(numNPCs);
                    CheckSectionNPC(numNPCs);
                    PlaySoundSpatial(SFX_SpitBossBeat, NPC[A].Location);
                }
                else
                {
                    bool DontResetMusic = false;

                    for(int nc : NPCQueues::Active.no_change)
                    {
                        if(NPC[nc].Type == NPCID_SPIT_BOSS && NPC[nc].Active && nc != A)
                        {
                            DontResetMusic = true;
                            break;
                        }
                    }

                    if(!DontResetMusic)
                    {
                        bgMusic[NPC[A].Section] = bgMusicREAL[NPC[A].Section];
                        StartMusicIfOnscreen(NPC[A].Section);
                    }
                }
            }

            NPC[A].Location.Y += -NPC[A].Location.Height / 2 + 32;
            NPC[A].Location.X += -NPC[A].Location.Width / 2 + 20;
            NewEffect_NpcDie(EFFID_SPIT_BOSS_DIE, NPC[A]);
        }
        else if(NPC[A].Type == NPCID_SPIT_BOSS_BALL) // Egg
        {
            if(NPC[A].Special == 1)
                NPC[A].Location.SpeedY = -5.1_n;
            NewEffect_NpcDie(EFFID_SPIT_BOSS_BALL_DIE, NPC[A]);
        }
        else if(NPC[A].Type == NPCID_RED_TURTLE_S3 || NPC[A].Type == NPCID_RED_SHELL_S3 || NPC[A].Type == NPCID_RED_FLY_TURTLE_S3) // Red Koopa
        {
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_RED_SHELL_S3_DIE] * 0.5_n;
            NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_RED_SHELL_S3_DIE] * 0.5_n;
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                NewEffect_NpcDie(EFFID_RED_SHELL_S3_DIE, NPC[A]);
            }

        }
        else if((NPC[A].Type >= NPCID_GRN_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_SHELL_S4) || (NPC[A].Type >= NPCID_GRN_FLY_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_FLY_TURTLE_S4)) // SMW Koopas
        {
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect(EFFID_SHELL_S4_DIE, NPC[A].Location);
                if(NPC[A].Type <= NPCID_YEL_TURTLE_S4)
                    Effect[numEffects].Frame = NPC[A].Type - NPCID_GRN_TURTLE_S4;
                else if(NPC[A].Type <= NPCID_YEL_SHELL_S4)
                    Effect[numEffects].Frame = NPC[A].Type - NPCID_GRN_SHELL_S4;
                else
                    Effect[numEffects].Frame = NPC[A].Type - NPCID_GRN_FLY_TURTLE_S4;
            }
        }
        else if(NPC[A].Type == NPCID_GLASS_TURTLE || NPC[A].Type == NPCID_GLASS_SHELL || NPC[A].Type == NPCID_SPIKY_S3 || NPC[A].Type == NPCID_CRAB || NPC[A].Type == NPCID_FLY || NPC[A].Type == NPCID_SPIKY_S4 || NPC[A].Type == NPCID_SPIKY_BALL_S4) // Hard thing / Spiney
        {
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_RED_SHELL_S3_DIE] * 0.5_n;
            NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_RED_SHELL_S3_DIE] * 0.5_n;
            if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_SMOKE_S3] / 2;
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
                if(NPC[A].Type == NPCID_SPIKY_S3)
                    NewEffect_NpcDie(EFFID_SPIKY_S3_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_SPIKY_S4 || NPC[A].Type == NPCID_SPIKY_BALL_S4)
                    NewEffect_NpcDie(EFFID_SPIKY_S4_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_CRAB)
                    NewEffect_NpcDie(EFFID_CRAB_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_FLY)
                    NewEffect_NpcDie(EFFID_FLY_DIE, NPC[A]);
                else
                    NewEffect_NpcDie(EFFID_GLASS_SHELL_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_HEAVY_THROWN) // Hammer
        {
            if(B == 3)
            {
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
            }
        }
        else if(NPC[A].Type == NPCID_LONG_PLANT_UP || NPC[A].Type == NPCID_LONG_PLANT_DOWN)
        {
            NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_SMOKE_S3] / 2;
            tempLocation = NPC[A].Location;
            if(NPC[A].Type == NPCID_LONG_PLANT_DOWN)
            {
                int npcH = (int)NPC[A].Location.Height;
                for(C = 0; C <= npcH; C += 32)
                {
                    if(NPC[A].Location.Height - C > 16)
                    {
                        tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - 32 - C;
                        NewEffect(EFFID_SMOKE_S3, tempLocation);
                    }
                }
            }
            else
            {
                int npcH = (int)NPC[A].Location.Height;
                for(C = 0; C <= npcH; C += 32)
                {
                    if(NPC[A].Location.Height - C > 16)
                    {
                        tempLocation.Y = NPC[A].Location.Y + C;
                        NewEffect(EFFID_SMOKE_S3, tempLocation);
                    }
                }
            }
            PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
        }
        else if(NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_QUAD_SPITTER || NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_LAVABUBBLE || NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_SIDE_PLANT || NPC[A].Type == NPCID_BIG_PLANT || NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_GHOST_S3 || NPC[A].Type == NPCID_GHOST_FAST || NPC[A].Type == NPCID_GHOST_S4 || NPC[A].Type == NPCID_BIG_GHOST || NPC[A].Type == NPCID_FIRE_PLANT || NPC[A].Type == NPCID_JUMP_PLANT) // Piranha Plant / Fireball
        {
            NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
            if(B == 8)
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            else
                PlaySoundSpatial(SFX_ShellHit, NPC[A].Location); // Shell hit sound
        }
        else if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PET_FIRE || NPC[A].Type == NPCID_PLR_ICEBALL) // Small Fireball / Yoshi Fireball
        {
            if(B == 6)
            {
                NPC[A].Location.X = NPC_CenterX - EffectWidth[EFFID_RED_SHELL_S3_DIE] * 0.5_n;
                NPC[A].Location.Y = NPC_CenterY - EffectHeight[EFFID_RED_SHELL_S3_DIE] * 0.5_n;
                NPC[A].Location.Width = 32;
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location, 1, NPC[A].Shadow);
                NPC[A].Location.X += 2;
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else
            {
                for(C = 1; C <= 10; C++)
                {
                    if(NPC[A].Type == NPCID_PLR_ICEBALL)
                        NewEffect(EFFID_PLR_ICEBALL_TRAIL, NPC[A].Location, NPC[A].Special, NPC[A].Shadow);
                    else
                        NewEffect(EFFID_PLR_FIREBALL_TRAIL, NPC[A].Location, NPC[A].Special, NPC[A].Shadow);

                    Effect[numEffects].Location.SpeedX = dRand() * 3 - 1.5_n + NPC[A].Location.SpeedX / 10;
                    Effect[numEffects].Location.SpeedY = dRand() * 3 - 1.5_n - NPC[A].Location.SpeedY / 10;
                }
                if((NPC[A].Type == NPCID_PLR_FIREBALL && NPC[A].Special == 5) || NPC[A].Type == NPCID_PET_FIRE)
                    NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location, 1, NPC[A].Shadow);
                else
                    NewEffect(EFFID_SMOKE_S4, NPC[A].Location, 1, NPC[A].Shadow);
            }
        }
        else if(NPC[A].Type == NPCID_MINIBOSS) // Big Koopa
        {
            NPC[A].Location.Y += -(NPC[A]->THeight - NPC[A].Location.Height);
            NPC[A].Location.Height = NPC[A]->THeight;
            if(NPC[A].Legacy)
            {
                bool DontSpawnExit = false;

                for(B = 1; B <= numNPCs; B++)
                {
                    if(NPC[B].Type == NPCID_MINIBOSS && NPC[B].Killed == 0 && B != A)
                    {
                        DontSpawnExit = true;
                        break;
                    }
                }

                if(LevelEditor)
                    DontSpawnExit = true;

                if(!DontSpawnExit)
                {
                    if(NewEffect(EFFID_MINIBOSS_DIE, NPC[A].Location, 1))
                        Effect[numEffects].NewNpc = NPCID_GOALORB_S3;
                }
                else
                {
                    bool DontResetMusic = false;

                    NewEffect(EFFID_MINIBOSS_DIE, NPC[A].Location);

                    for(int nc : NPCQueues::Active.no_change)
                    {
                        if(NPC[nc].Type == NPCID_MINIBOSS && NPC[nc].Active && nc != A && NPC[nc].Killed == 0)
                        {
                            DontResetMusic = true;
                            break;
                        }
                    }

                    if(!DontResetMusic)
                    {
                        bgMusic[NPC[A].Section] = bgMusicREAL[NPC[A].Section];
                        StartMusicIfOnscreen(NPC[A].Section);
                    }
                }
            }
            else
                NewEffect(EFFID_MINIBOSS_DIE, NPC[A].Location);
        }
        else if(NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_BIG_BULLET) // Bullet Bills
        {
            NPC[A].Location.SpeedX = NPC[A].Location.SpeedX / 2;
            if(B == 1)
                NPC[A].Location.SpeedX = 0.0001_n * NPC[A].Direction;
            else if(B == 5)
                NPC[A].Location.SpeedX = 3 * NPC[A].Direction;
            else
                NPC[A].Location.SpeedX = NPC[A].Location.SpeedX / 2;

            if(B != 1)
                NPC[A].Location.SpeedY = -9;

            if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                if(B == 3 || B == 2)
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                if(NPC[A].Type == NPCID_BULLET)
                    NewEffect_NpcDie(EFFID_BULLET_DIE, NPC[A]);
                else
                    NewEffect_NpcDie(EFFID_BIG_BULLET_DIE, NPC[A]);
            }
        }
        else if(NPC[A].Type == NPCID_STACKER || NPC[A].Type == NPCID_BLU_GUY || NPC[A].Type == NPCID_RED_GUY || NPC[A].Type == NPCID_JUMPER_S3 || NPC[A].Type == NPCID_RED_FISH_S1 || NPC[A].Type == NPCID_HEAVY_THROWER || NPC[A].Type == NPCID_SPIKY_THROWER || NPC[A].Type == NPCID_ITEM_THROWER || NPC[A].Type == NPCID_SPIKY_BALL_S3 || NPC[A].Type == NPCID_JUMPER_S4 || NPC[A].Type == NPCID_BAT || (NPC[A].Type >= NPCID_BIRD && NPC[A].Type <= NPCID_GRY_SPIT_GUY) || NPC[A].Type == NPCID_CARRY_BUDDY || NPC[A].Type == NPCID_WALK_PLANT || NPC[A].Type == NPCID_VINE_BUG) // Misc Things
        {
            if(B == 6)
            {
                NPC[A].Location.Y += (NPC[A].Location.Height - 32);
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
            else if(B == 8)
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
            else
            {
                if(NPC[A].Type >= NPCID_BIRD && NPC[A].Type <= NPCID_GRY_SPIT_GUY)
                    NewEffect((EFFID)((NPC[A].Type - NPCID_BIRD) + EFFID_BIRD_DIE), NPC[A].Location, NPC[A].Direction);
                else if(NPC[A].Type == NPCID_BLU_GUY)
                    NewEffect_NpcDie(EFFID_RED_GUY_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_RED_GUY)
                    NewEffect_NpcDie(EFFID_BLU_GUY_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_WALK_PLANT)
                    NewEffect_NpcDie(EFFID_WALK_PLANT_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_JUMPER_S3)
                    NewEffect_NpcDie(EFFID_JUMPER_S3_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_RED_FISH_S1)
                {
                    NPC[A].Location.SpeedY = -11;
                    if(NPC[A].Killed == 1)
                        NPC[A].Location.SpeedY = 0;
                    NewEffect_NpcDie(EFFID_RED_FISH_S1_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_CARRY_BUDDY)
                    NewEffect_NpcDie(EFFID_CARRY_BUDDY_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_STACKER)
                    NewEffect_NpcDie(EFFID_STACKER_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_VINE_BUG)
                    NewEffect_NpcDie(EFFID_VINE_BUG_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_JUMPER_S4)
                {
                    if(B == 1)
                    {
                        NPC[A].Location.SpeedY = 0;
                        NPC[A].Location.SpeedX = 0;
                        PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                    }
                    else
                    {
                        NPC[A].Location.SpeedY = -11;
                        PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    }

                    NewEffect_NpcDie(EFFID_JUMPER_S4_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_BAT)
                {
                    if(B == 1)
                    {
                        NPC[A].Location.SpeedY = 0;
                        NPC[A].Location.SpeedX = 0;
                    }
                    else
                    {
                        NPC[A].Location.SpeedY = -11;
                        PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    }

                    NewEffect_NpcDie(EFFID_BAT_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_HEAVY_THROWER)
                {
                    if(B == 1)
                    {
                        NPC[A].Location.SpeedY = 0;
                        NPC[A].Location.SpeedX = 0;
                        PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                    }
                    else
                    {
                        NPC[A].Location.SpeedY = -11;
                        PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    }

                    NewEffect_NpcDie(EFFID_HEAVY_THROWER_DIE, NPC[A]);
                }
                else if(NPC[A].Type == NPCID_SPIKY_BALL_S3)
                    NewEffect_NpcDie(EFFID_SPIKY_BALL_S3_DIE, NPC[A]);
                else if(NPC[A].Type == NPCID_SPIKY_THROWER || NPC[A].Type == NPCID_ITEM_THROWER)
                {
                    if(NPC[A].Location.SpeedX > 4)
                        NPC[A].Location.SpeedX = 4;
                    if(NPC[A].Location.SpeedX < -4)
                        NPC[A].Location.SpeedX = -4;

                    if(B == 1)
                    {
                        NPC[A].Location.SpeedY = 0;
                        NPC[A].Location.SpeedX = 0;
                        PlaySoundSpatial(SFX_Stomp, NPC[A].Location);
                    }
                    else
                    {
                        NPC[A].Location.SpeedY = -11;
                        PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                    }

                    if(NPC[A].Type == NPCID_ITEM_THROWER)
                        NewEffect_NpcDie(EFFID_ITEM_THROWER_DIE, NPC[A]);
                    else
                    {
                        NPC[A].Location.Y -= 14;
                        NewEffect_NpcDie(EFFID_SPIKY_THROWER_DIE, NPC[A]);
                    }
                }

                if(NPC[A].Type != NPCID_HEAVY_THROWER && NPC[A].Type != NPCID_SPIKY_THROWER && NPC[A].Type != NPCID_JUMPER_S4)
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
            }
        }
        else if(NPC[A].Type == NPCID_SLIDE_BLOCK) // ice block
        {
            if(B == 6)
            {
                NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
            }
            else
            {
                NewEffect(EFFID_SLIDE_BLOCK_SMASH, NPC[A].Location);
                PlaySoundSpatial(SFX_BlockSmashed, NPC[A].Location);
            }
        }
        else if(NPC[A]->IsABonus) // NPC is a bonus
        {
            if(B == 3 || B == 4 || B == 5)
            {
                if(!NPC[A]->IsACoin || LevelEditor || TestLevel) // Shell hit sound
                    PlaySoundSpatial(SFX_ShellHit, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
            }
            else if(B == 6)
            {
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                if(!NPC[A].NoLavaSplash)
                    NewEffect(EFFID_LAVA_SPLASH, NPC[A].Location);
            }
        }
        else if(LevelEditor || MagicHand)
        {
            if(!(NPC[A].Type == NPCID_COIN_SWITCH && B == 1))
            {
                NewEffect(EFFID_SMOKE_S3_CENTER, NPC[A].Location);
                PlaySoundSpatial(SFX_Smash, NPC[A].Location);
            }
        }
    }

    if(BattleMode)
        NPC[A].RespawnDelay = true;

    // note: this is the "defective" version of SetLayerSpeed, which (in classic mode) only sets the speed to 0, and does nothing else
    if(NPC[A].AttLayer != LAYER_NONE && NPC[A].AttLayer != LAYER_DEFAULT)
        SetLayerSpeed(NPC[A].AttLayer, 0, 0, false, true);

    if((!GameMenu && !BattleMode) || NPC[A].DefaultType == 0)
    {
        for(B = 1; B <= numPlayers; B++) // Tell the player to stop standing on me because im dead kthnx
        {
            if(Player[B].StandingOnNPC == A)
            {
                Player[B].StandingOnNPC = 0;
                if(NPC[A].Type != NPCID_VEHICLE)
                    Player[B].Location.SpeedY = NPC[A].Location.SpeedY;
            }
            else if(Player[B].StandingOnNPC == numNPCs)
                Player[B].StandingOnNPC = A;

            if(Player[B].YoshiNPC == numNPCs)
                Player[B].YoshiNPC = A;
            if(Player[B].VineNPC == numNPCs)
                Player[B].VineNPC = A;
        }

        SDL_assert_release(A > 0);
        NPC[A] = NPC[numNPCs];
        NPC[numNPCs] = NPC_t();
        numNPCs--;
        syncLayers_NPC(A);
        syncLayers_NPC(numNPCs + 1);

        if(NPC[A].HoldingPlayer > 0)
        {
            Player[NPC[A].HoldingPlayer].HoldingNPC = A;
//            if(nPlay.Online == true && nPlay.Mode == 1)
//                Netplay::sendData "K" + std::to_string(C) + "|" + NPC[A].Type + "|" + NPC[A].Location.X + "|" + NPC[A].Location.Y + "|" + std::to_string(NPC[A].Location.Width) + "|" + std::to_string(NPC[A].Location.Height) + "|" + NPC[A].Location.SpeedX + "|" + NPC[A].Location.SpeedY + "|" + NPC[A].Section + "|" + NPC[A].TimeLeft + "|" + NPC[A].Direction + "|" + std::to_string(static_cast<int>(floor(static_cast<double>(NPC[A].Projectile)))) + "|" + NPC[A].Special + "|" + NPC[A].Special2 + "|" + NPC[A].Special3 + "|" + NPC[A].Special4 + "|" + NPC[A].Special5 + "|" + NPC[A].Effect + LB + "1n" + NPC[A].HoldingPlayer + "|" + std::to_string(A) + "|" + NPC[A].Type + LB;
        }

        if(NPC[A].Effect == NPCEFF_PET_TONGUE || NPC[A].Effect == NPCEFF_PET_INSIDE)
            Player[NPC[A].Effect2].YoshiNPC = A;

        if(NPC[A].Type == NPCID_TOOTHYPIPE && NPC[A].Special == 1)
        {
            for(int C : NPCQueues::Active.no_change)
            {
                if(NPC[C].Type == NPCID_TOOTHY && NPC[C].Special2 == numNPCs + 1)
                    NPC[C].Special2 = A;
            }
        }
        else if(NPC[A].Type == NPCID_TOOTHYPIPE && NPC[A].Special2 > 0)
            NPC[NPC[A].Special2].Special2 = A;
        else if(NPC[A].Type == NPCID_TOOTHY && NPC[A].Special2 > 0)
            NPC[NPC[A].Special2].Special2 = A;
    }
    else
    {
        Deactivate(A);
    }

    return false;
}


================================================
FILE: src/npc/npc_queues.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <sorting/pdqsort.h>

#include <vector>
#include <set>

#include "globals.h"

#include "npc/npc_queues.h"

namespace NPCQueues
{

std::vector<NPCRef_t> NoReset;

std::vector<NPCRef_t> Killed;
std::vector<NPCRef_t> Unchecked;

std::vector<NPCRef_t> PlayerTemp;

SafeSet<NPCRef_t> Active;

std::set<NPCRef_t> RespawnDelay;

void clear()
{
    NoReset.clear();

    Killed.clear();
    Unchecked.clear();

    PlayerTemp.clear();

    Active.clear();

    RespawnDelay.clear();
}

void update(NPCRef_t npc)
{
    if((int)npc > numNPCs)
    {
        Active.erase(npc);
        RespawnDelay.erase(npc);

        return;
    }

    // cheaper to do this than to check if it's already there
    NoReset.push_back(npc);
    Unchecked.push_back(npc);

    if(npc->playerTemp)
        PlayerTemp.push_back(npc);

    if(check_active(npc))
        Active.insert(npc);
    else
        Active.erase(npc);

    if(npc->RespawnDelay)
        RespawnDelay.insert(npc);
    else
        RespawnDelay.erase(npc);

    if(npc->Killed)
        Killed.push_back(npc);
}

void reverse_sort(int16_t* start, int16_t* end)
{
    pdqsort(start, end,
        [](int16_t a, int16_t b)
        {
            return a > b;
        }
    );
}

} // namespace NPCQueues


================================================
FILE: src/npc/npc_queues.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#pragma once

#ifndef NPC_QUEUES_H
#define NPC_QUEUES_H

/*
 * The goal of this file is to maintain certain queues to track which NPCs
 * need to be accessed at which times. Ultimately, the intention is to
 * eliminate all loops over the entire NPC array.
 *
 *
 * All queues except paired write/read vector queues share a common interface:
 *   - C++11 iteration over `NPCRef_t`s
 *   - clear()
 *   - insert(NPCRef_t)
 *   - erase(NPCRef_t)
 *   - size_t size()
 *
 *
 * Each type of queue must be chosen for the optimal use case:
 *
 * - Some queues are write-once/read-once per-frame, like the set of NPCs that
 *   currently have one of the Reset flags disabled. They can be simple
 *   vectors, or pairs of vectors if they are simultaneously read and written.
 *
 * - Other queues are read and written frequently, but persist across frames,
 *   like the set of NPCs that are Active or have TimeLeft > 0.
 *   They should carefully be tuned as sets, well-constructed linked lists,
 *   or indexed sorted vectors, depending on use case.
 *
 * - Some queues need to be sorted, and others don't.
 *
 *
 * When implementing a new queue, it is best to start with the set-backed
 * queue because this one has the simplest implementation. Then if profiling
 * reveals a need, we can change the queue.
 *
 * -- ds-sloth
 */

#include <vector>
#include <set>
#include "npc/safe_set.hpp"
#include "npc_traits.h"

#include "globals.h"

namespace NPCQueues
{

// NPC[A].Reset[X] = false -> NPCQueues::NoReset.push_back(A);
extern std::vector<NPCRef_t> NoReset;

// NPC[A].Killed = X -> NPCQueues::Killed.push_back(A);
extern std::vector<NPCRef_t> Killed;

// NPC[A].playerTemp = true -> NPCQueues::PlayerTemp.push_back(A);
extern std::vector<NPCRef_t> PlayerTemp;

// NPC[A].Location.Width modified or NPC A deactivated -> NPCQueues::Unchecked.push_back(A);
//   Also add if certain fields (RealSpeedX and various counters) are unexpectedly modified while NPC inactive
extern std::vector<NPCRef_t> Unchecked;

// Contained in any of the following cases:
// - NPC[A].Active true
// - NPC[A].Generator true
// - NPC[A].JustActivated true
// - check_active_type(NPC[A]) true -- check when changing NPC[A].Type
// - NPC[A].AttLayer not LAYER_NONE or LAYER_DEFAULT
extern SafeSet<NPCRef_t> Active;

// NPC[A].RespawnDelay modified -> NPCQueues::RespawnDelay.insert(A) / erase(A);
extern std::set<NPCRef_t> RespawnDelay;

inline bool check_active_type(NPCRef_t n)
{
    return n->Type == NPCID_CONVEYOR || n->Type == NPCID_YEL_PLATFORM || n->Type == NPCID_BLU_PLATFORM || n->Type == NPCID_GRN_PLATFORM || n->Type == NPCID_RED_PLATFORM;
}

inline bool check_exclude_vine(NPCRef_t n)
{
    return (*n)->IsAVine && !((*n)->IsABlock || (*n)->IsAHit1Block || (*n)->CanWalkOn);
}

inline bool check_active(NPCRef_t n)
{
    return (n->Active && !check_exclude_vine(n)) || n->Generator || n->JustActivated || check_active_type(n) || (n->AttLayer != LAYER_NONE && n->AttLayer != LAYER_DEFAULT);
}

void clear();

void update(NPCRef_t npc);

/* utility function to help with multiple NPC-related routines */
void reverse_sort(int16_t* start, int16_t* end);

template<class T>
void reverse_sort(std::vector<T>& vec)
{
    static_assert(sizeof(*vec.data()) == sizeof(int16_t), "reverse_sort can only be called on BaseRef_t and its children");
    reverse_sort(reinterpret_cast<int16_t*>(vec.data()), reinterpret_cast<int16_t*>(vec.data() + vec.size()));
}

} // namespace NPCQueues

#endif // #ifndef NPC_QUEUES_H


================================================
FILE: src/npc/npc_update/npc_block_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "blocks.h"
#include "npc.h"
#include "npc_traits.h"
#include "npc/npc_queues.h"
#include "config.h"
#include "collision.h"
#include "layers.h"
#include "effect.h"
#include "eff_id.h"
#include "blk_id.h"

#include "main/trees.h"

void NPCBlockLogic(int A, num_t& tempHit, int& tempHitBlock, tempf_t& tempSpeedA, const int numTempBlock, const tempf_t speedVar)
{
    bool resetBeltSpeed = false;
    bool beltClear = false; // "stops belt movement when on a wall" (Redigit)
    bool onWall = false; // temporary variable, moved from NPC_t struct
    tempf_t beltCount = 0;
    tempf_t addBelt = 0;

    bool SlopeTurn = false;

    // int tempBlockHit[3] = {0}; // keeps track of up to two blocks hit from below
    int tempBlockHit1 = 0;
    int tempBlockHit2 = 0;
    int tempHitIsSlope = 0;

    int oldSlope = NPC[A].Slope; // previous sloped block the npc was on
    tempf_t oldBeltSpeed = (tempf_t)NPC[A].BeltSpeed;

    NPC[A].Slope = 0;
    // now, use tempf_t to do all BeltSpeed computations (accumulation, etc) in full precision in fixed-point builds
    // NPC[A].BeltSpeed = 0;
    tempf_t beltSpeed = 0;

    bool is_winged = (NPCIsAParaTroopa(NPC[A]) || (NPC[A].Wings && NPC[A].Wings != WING_JUMP));

    if((!NPC[A]->NoClipping || NPC[A].Projectile || NPC[A].Wings) &&
       !(NPC[A].Type == NPCID_SPIT_BOSS_BALL && NPC[A].Projectile) && NPC[A].Type != NPCID_TOOTHY &&
        NPC[A].vehiclePlr == 0 && !(NPCIsVeggie(NPC[A]) && NPC[A].Projectile) &&
       NPC[A].Type != NPCID_HEAVY_THROWN && NPC[A].Type != NPCID_BIG_BULLET && NPC[A].Type != NPCID_PET_FIRE &&
       !(NPC[A]->IsFish && NPC[A].Special == 2) && NPC[A].Type != NPCID_VINE_BUG)
    {
        for(int bCheck = 1; bCheck <= 2; bCheck++)
        {
            // if(bCheck == 1)
            // {
            //     // fBlock = FirstBlock[(int)SDL_floor(NPC[A].Location.X / 32) - 1];
            //     // lBlock = LastBlock[(int)SDL_floor((NPC[A].Location.X + NPC[A].Location.Width) / 32.0) + 1];
            //     blockTileGet(NPC[A].Location, fBlock, lBlock);
            // }
            // else
            // {
            //     fBlock = numBlock + 1 - numTempBlock;
            //     lBlock = numBlock;
            // }
            auto collBlockSentinel = (bCheck == 1)
                ? treeFLBlockQuery(NPC[A].Location, SORTMODE_COMPAT)
                : treeTempBlockQuery(NPC[A].Location, SORTMODE_LOC);

            for(BlockRef_t block : collBlockSentinel)
            {
                int B = block;
                // If Not .Block = B And Not .tempBlock = B And Not (.Projectile = True And Block(B).noProjClipping = True) And BlockNoClipping(Block(B).Type) = False And Block(B).Hidden = False And Block(B).Hidden = False Then




                if(NPC[A].Location.X + NPC[A].Location.Width >= Block[B].Location.X)
                {
                    if(NPC[A].Location.X <= Block[B].Location.X + Block[B].Location.Width)
                    {
                        if(NPC[A].Location.Y + NPC[A].Location.Height >= Block[B].Location.Y)
                        {
                            if(NPC[A].Location.Y <= Block[B].Location.Y + Block[B].Location.Height)
                            {

                                // If CheckCollision(.Location, Block(B).Location) = True Then



                                // the coinSwitchBlockType != B check is an SMBX 1.3 bug, probably because the field was called "Block"
                                if(NPC[A].coinSwitchBlockType() != B && NPC[A].tempBlock != B &&
                                   !(NPC[A].Projectile && Block[B].tempBlockNoProjClipping()) &&
                                   !BlockNoClipping[Block[B].Type] && !Block[B].Hidden)
                                {
                                    if(Block[B].tempBlockNpcType == NPCID_TANK_TREADS && !NPC[A]->NoClipping && NPC[A].Type != NPCID_BULLET)
                                        NPCHit(A, 8);

                                    // traits of the block's NPC (if it is actually an NPC)
                                    const NPCTraits_t& blk_npc_tr = NPCTraits[Block[B].tempBlockNpcType];

                                    bool block_is_not_conveyor = (Block[B].tempBlockNpcType != NPCID_CONVEYOR) && !(Block[B].Type >= BLKID_CONVEYOR_L_START && Block[B].Type <= BLKID_CONVEYOR_R_END);

                                    int HitSpot;
                                    if(block_is_not_conveyor && (blk_npc_tr.IsABlock || blk_npc_tr.IsAHit1Block || blk_npc_tr.CanWalkOn))
                                        HitSpot = NPCFindCollision(NPC[A].Location, Block[B].Location);
                                    else
                                        HitSpot = FindCollisionBelt(NPC[A].Location, Block[B].Location, oldBeltSpeed);

                                    // block-based cancellation logic (plus some type-based cancellation logic that was placed between these in SMBX 1.3)
                                    if(Block[B].tempBlockVehiclePlr > 0 && ((!NPC[A]->StandsOnPlayer && NPC[A].Type != NPCID_PLR_FIREBALL) || NPC[A].Inert))
                                        HitSpot = 0;

                                    if(Block[B].Invis)
                                    {
                                        if(HitSpot != 3)
                                            HitSpot = 0;
                                    }

                                    if(HitSpot == 5)
                                    {
                                        if(CheckHitSpot1(NPC[A].Location, Block[B].Location))
                                            HitSpot = 1;
                                        else if(Block[B].tempBlockNpcType == NPCID_CONVEYOR) // && HitSpot == 5
                                        {
                                            if(Block[B].Location.to_right_of(NPC[A].Location))
                                                HitSpot = 4;
                                            else
                                                HitSpot = 2;
                                        }
                                        // after CheckHitSpot1 and NPCID_CONVEYOR check, before sizable check
                                        else if(NPC[A].Type == NPCID_MINIBOSS) // && HitSpot == 5
                                        {
                                            if(NPC[A].WallDeath >= 5)
                                            {
                                                NPC[A].Killed = 3;
                                                NPCQueues::Killed.push_back(A);
                                            }
                                            else
                                                HitSpot = 3;
                                        }
                                    }

                                    // after CheckHitSpot1, before sizable check
                                    if(NPC[A].Type == NPCID_VILLAIN_S3)
                                    {
                                        if(HitSpot != 1 && NPC[A].Special > 0)
                                        {
                                            if(Block[B].Location.X < level[NPC[A].Section].X + 48 || Block[B].Location.X > level[NPC[A].Section].Width - 80)
                                                NPC[A].Special = 0;
                                            else
                                            {
                                                HitSpot = 0;
                                                resetBeltSpeed = true;
                                            }
                                        }
                                        else if(HitSpot == 3)
                                        {
                                            if(NPC[A].Special4 == 3)
                                            {
                                                NPC[A].Frame = 10;
                                                NPC[A].Special3 = 21;
                                                NPC[A].Special = 1;
                                                NPC[A].Location.SpeedX = 0;
                                            }
                                        }
                                    }

                                    if(BlockIsSizable[Block[B].Type] || BlockOnlyHitspot1[Block[B].Type])
                                    {
                                        if(HitSpot != 1 || (NPCIsAParaTroopa(NPC[A]) && NPC[A].Special != WING_JUMP) || (NPC[A].Wings && NPC[A].Wings != WING_JUMP))
                                            HitSpot = 0;
                                    }

                                    // Unified type-based cancellation / collision logic -- prior to slope and lava checks. Deprecate this and don't allow users to define.
                                    if(NPC[A]->IsFish)
                                    {
                                        // fish ignore block collisions while out of water (eg, jumping)
                                        if(NPC[A].Wet == 0)
                                        {
                                            if(NPC[A].WallDeath >= 9)
                                                HitSpot = 0;
                                        }

                                        // leaping fish always ignore non-ceiling collisions
                                        if(NPC[A].Special == 2 && HitSpot != 3)
                                            HitSpot = 0;
                                    }
                                    else if(NPC[A].Type == NPCID_PLR_HEAVY || NPC[A].Type == NPCID_SWORDBEAM || NPC[A].Type == NPCID_CHAR4_HEAVY)
                                    {
                                        if(Block[B].Type == 457)
                                            SafelyKillBlock(B);

                                        HitSpot = 0;
                                    }
                                    else if(NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG)
                                    {
                                        if(Block[B].tempBlockVehiclePlr > 0 || Block[B].tempBlockNpcType == NPCID_VEHICLE)
                                        {
                                            HitSpot = 0;
                                            NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                        }
                                    }
                                    else if(NPC[A].Type >= NPCID_TANK_TREADS && NPC[A].Type <= NPCID_SLANT_WOOD_M)
                                    {
                                        if(HitSpot != 1)
                                            HitSpot = 0;
                                    }
                                    else if(NPC[A].Type == NPCID_SPIKY_BALL_S3)
                                    {
                                        if(Block[B].tempBlockNpcType == NPCID_CANNONITEM || Block[B].tempBlockNpcType == NPCID_TOOTHYPIPE) // spiney eggs don't walk on special items
                                            HitSpot = 0;
                                    }
                                    else if(NPC[A].Type == NPCID_RAFT) // Skull raft
                                    {
                                        if(Block[B].tempBlockNpcType > 0)
                                            HitSpot = 0;

                                        if(g_config.fix_skull_raft) // reached a solid wall
                                        {
                                            auto bt = Block[B].Type;
                                            if(Block[B].tempBlockNpcType <= 0 && NPC[A].Special == 1 &&
                                              (HitSpot == COLLISION_LEFT || HitSpot == COLLISION_RIGHT) &&
                                               BlockSlope[bt] == SLOPE_FLOOR && BlockSlope2[bt] == SLOPE_CEILING)
                                            {
                                                if(npcHasFloor(NPC[A]) || NPC[A].Special2 > 0)
                                                {
                                                    SkullRide(A, false, &Block[B].Location);
                                                    NPC[A].Special = 3; // 3 - watcher, 2 - waiter
                                                }
                                            }
                                        }
                                    }
                                    else if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL || NPC[A].Type == NPCID_PET_FIRE)
                                    {
                                        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL)
                                        {
                                            // NEW: bugfix to make ice balls properly respect char blocks
                                            int special = (g_config.fix_char_pass_balls) ? NPC[A].Variant : NPC[A].Special;

                                            if(Block[B].Type == 626 && special == 1)
                                                HitSpot = 0;
                                            if(Block[B].Type == 627 && special == 2)
                                                HitSpot = 0;
                                            if(Block[B].Type == 628 && special == 3)
                                                HitSpot = 0;
                                            if(Block[B].Type == 629 && special == 4)
                                                HitSpot = 0;
                                            if(Block[B].Type == 632 && special == 5 && g_config.fix_char_pass_balls) // NEW
                                                HitSpot = 0;

                                            if(NPCTraits[Block[B].tempBlockNpcType].IsABonus)
                                                HitSpot = 0;

                                            if(NPC[A].Type == NPCID_PLR_FIREBALL && Block[B].tempBlockNpcType == NPCID_ICE_CUBE)
                                                HitSpot = 0;
                                        }

                                        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PET_FIRE)
                                        {
                                            if(Block[B].Type == 621 || Block[B].Type == 620)
                                            {
                                                NPCHit(A, 3, A);
                                                if(Block[B].Type == 621)
                                                    Block[B].Type = 109;
                                                else
                                                {
                                                    Block[B].Layer = LAYER_DESTROYED_BLOCKS;
                                                    Block[B].Hidden = true;
                                                    syncLayersTrees_Block(B);
                                                    numNPCs++;
                                                    NPC[numNPCs].Location.Width = 28;
                                                    NPC[numNPCs].Location.Height = 32;
                                                    NPC[numNPCs].Type = NPCID_COIN_S3;
                                                    NPC[numNPCs].Location.Y = Block[B].Location.Y;
                                                    NPC[numNPCs].Location.X = Block[B].Location.X + 2;
                                                    NPC[numNPCs].Active = true;
                                                    NPC[numNPCs].DefaultType = NPC[numNPCs].Type;
                                                    NPC[numNPCs].DefaultLocationX = NPC[numNPCs].Location.X;
                                                    NPC[numNPCs].DefaultLocationY = NPC[numNPCs].Location.Y;
                                                    NPC[numNPCs].TimeLeft = 100;
                                                    syncLayers_NPC(numNPCs);
                                                    CheckSectionNPC(numNPCs);
                                                }
                                            }
                                        }
                                    }
                                    else if(NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_STONE_S4)
                                    {
                                        if(HitSpot != 1)
                                            HitSpot = 0;
                                    }
                                    else if(NPC[A].Type == NPCID_SPIT_GUY_BALL)
                                    {
                                        if(HitSpot > 0)
                                        {
                                            NPC[A].Killed = 4;
                                            NPCQueues::Killed.push_back(A);
                                        }
                                    }
                                    else if(NPC[A].Type == NPCID_BOMB)
                                    {
                                        if(NPC[A].Projectile && HitSpot != 0)
                                            NPC[A].Special = 1000;
                                    }
                                    // vine makers
                                    else if(NPC[A].Type == NPCID_RED_VINE_TOP_S3 || NPC[A].Type == NPCID_GRN_VINE_TOP_S3 || NPC[A].Type == NPCID_GRN_VINE_TOP_S4)
                                    {
                                        if(HitSpot == 3)
                                            NPC[A].Special = 1;
                                    }
                                    else if(NPC[A].Type == NPCID_GOALTAPE)
                                    {
                                        if(Block[B].tempBlockNpcType > 0)
                                            HitSpot = 0;
                                    }
                                    else if(NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_WALL_TURTLE)
                                    {
                                        // tells the NPC that it's supported
                                        NPC[A].Special5 = 0;

                                        if(HitSpot == 1)
                                        {
                                            if(NPC[A].Special == 4 && NPC[A].Location.X + 0.99_n == Block[B].Location.X + Block[B].Location.Width)
                                                HitSpot = 0;

                                            if(NPC[A].Special == 2 && NPC[A].Location.X + NPC[A].Location.Width - 0.99_n == Block[B].Location.X)
                                                HitSpot = 0;
                                        }

                                        if(BlockIsSizable[Block[B].Type] || BlockOnlyHitspot1[Block[B].Type])
                                            HitSpot = 0;

                                        if(BlockSlope2[Block[B].Type] != 0 && HitSpot == 3)
                                        {
                                            if(NPC[A].Special == 4 && NPC[A].Special2 == -1)
                                            {
                                                if(NPC[A].Location.X - 0.01_n == Block[B].Location.X)
                                                {
                                                    NPC[A].Special = 3;
                                                    NPC[A].Special2 = 1;
                                                    NPC[A].Location.SpeedX = -NPC[A].Location.SpeedY;
                                                }
                                            }
                                        }

                                        if(BlockSlope2[Block[B].Type] != 0 && HitSpot == 1)
                                        {
                                            if(NPC[A].Special == 4)
                                                HitSpot = 2;
                                            if(NPC[A].Special == 2)
                                                HitSpot = 4;
                                        }

                                        if(NPC[A].Special == 3)
                                        {
                                            // if(BlockSlope2[Block[B].Type] != 0)
                                            // {
                                            //     if(HitSpot == 2 || HitSpot == 4)
                                            //         HitSpot = 0;
                                            // }
                                            // else
                                            if(HitSpot == 2 || HitSpot == 4)
                                                HitSpot = 0;
                                        }

                                        if(Block[B].tempBlockNpcType > 0)
                                            HitSpot = 0;

                                        // hit a wall, cancel wings and switch routines
                                        if(HitSpot)
                                            NPC[A].Wings = WING_NONE;
                                    }
                                    else if(NPC[A].Type == NPCID_SAW)
                                    {
                                        if(Block[B].tempBlockNpcType > 0)
                                            HitSpot = 0;
                                    }

                                    // shadow mode cancellation
                                    if(NPC[A].Shadow && HitSpot != 1 && !(Block[B].Special > 0 && NPC[A].Projectile))
                                        HitSpot = 0;

                                    if(BlockSlope2[Block[B].Type] != 0 && HitSpot > 0 && ((NPC[A].Location.Y > Block[B].Location.Y) || ((NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_WALL_TURTLE) && NPC[A].Special == 3)))
                                    {
                                        // the modifications to Special and Special2 here are invalid and could affect any NPC. They were meant to affect wall climbers.
                                        num_t NPC_A_Special = NPC[A].Special;
                                        num_t NPC_A_Special2 = NPC[A].Special2;

                                        char Special_from = 0;
                                        char Special2_from = 0;

                                        if(NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM || NPC[A].Type == NPCID_GRN_PLATFORM || NPC[A].Type == NPCID_RED_PLATFORM || NPC[A].Type == NPCID_PLATFORM_S3 || NPC[A].Type == NPCID_SAW)
                                        {
                                            Special_from = 'Y';
                                            Special2_from = 'X';
                                            NPC_A_Special = NPC[A].SpecialY;
                                            NPC_A_Special2 = NPC[A].SpecialX;
                                        }
                                        else if(NPC[A].Type == NPCID_HOMING_BALL_GEN)
                                        {
                                            Special_from = 'Y';
                                            NPC_A_Special = NPC[A].SpecialY;
                                        }
                                        else if(NPC[A].Type == NPCID_VILLAIN_S3 || NPC[A].Type == NPCID_MINIBOSS || NPC[A].Type == NPCID_GOALTAPE || NPC[A].Type == NPCID_BAT)
                                        {
                                            Special2_from = 'Y';
                                            NPC_A_Special2 = NPC[A].SpecialY;
                                        }
                                        else if(NPC[A].Type == NPCID_SPIT_BOSS)
                                        {
                                            Special_from = '5';
                                            NPC_A_Special = NPC[A].Special5;
                                        }

                                        // previously going down a wall? now turn around this outer corner
                                        if(HitSpot == 5 && (NPC_A_Special == 2 || NPC_A_Special == 4) && NPC_A_Special2 == 1)
                                        {
                                            // left side -> move right on ceiling slope
                                            if(NPC_A_Special == 2)
                                                NPC_A_Special2 = 1;
                                             // right side -> move left on ceiling slope
                                            else
                                                NPC_A_Special2 = -1;

                                            NPC_A_Special = 3;
                                        }

                                        HitSpot = 0;
                                        num_t PlrMid;
                                        if(BlockSlope2[Block[B].Type] == 1)
                                            PlrMid = NPC[A].Location.X + NPC[A].Location.Width;
                                        else
                                            PlrMid = NPC[A].Location.X;

                                        num_t Slope = (PlrMid - Block[B].Location.X) / (int_ok)Block[B].Location.Width;
                                        if(BlockSlope2[Block[B].Type] > 0)
                                            Slope = 1 - Slope;
                                        if(Slope < 0)
                                            Slope = 0;
                                        if(Slope > 1)
                                            Slope = 1;

                                        if(NPC[A].Location.Y < Block[B].Location.Y + Block[B].Location.Height - ((int_ok)Block[B].Location.Height * Slope) - 0.1_n)
                                        {
                                            if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_PLR_ICEBALL)
                                                NPCHit(A, 3, A);

                                            if(NPC[A].Type == NPCID_ICE_CUBE)
                                            {
                                                if(NPC[A].Location.SpeedY < -2)
                                                    NPCHit(A, 3, A);
                                            }

                                            if(num_t::fEqual_d(NPC[A].Location.SpeedY, Physics.NPCGravity) || NPC[A].Slope > 0 || oldSlope > 0)
                                            {
                                                // previously going up a wall? now turn within this inner corner
                                                if((NPC_A_Special == 2 || NPC_A_Special == 4) && NPC_A_Special2 == -1)
                                                {
                                                    // right side -> move right on ceiling slope
                                                    if(NPC_A_Special == 4)
                                                        NPC_A_Special2 = 1;
                                                    // left side -> move left on ceiling slope
                                                    else
                                                        NPC_A_Special2 = -1;

                                                    NPC_A_Special = 3;
                                                }

                                                PlrMid = NPC[A].Location.Y;
                                                Slope = (PlrMid - Block[B].Location.Y) / (int_ok)Block[B].Location.Height;
                                                if(Slope < 0)
                                                    Slope = 0;
                                                if(Slope > 1)
                                                    Slope = 1;
                                                if(BlockSlope2[Block[B].Type] < 0)
                                                    NPC[A].Location.X = Block[B].Location.X + Block[B].Location.Width - ((int_ok)Block[B].Location.Width * Slope);
                                                else
                                                    NPC[A].Location.X = Block[B].Location.X + ((int_ok)Block[B].Location.Width * Slope) - NPC[A].Location.Width;
                                                SlopeTurn = true;
                                                if(NPC[A].Location.SpeedX < 0)
                                                    HitSpot = 2;
                                                else
                                                    HitSpot = 4;
                                            }
                                            else
                                            {
                                                NPC[A].Location.Y = Block[B].Location.Y + Block[B].Location.Height - ((int_ok)Block[B].Location.Height * Slope);
                                                if(NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_WALL_TURTLE)
                                                {
                                                    NPC[A].Location.Y += 1;
                                                    tempBlockHit1 = 0;
                                                    tempBlockHit2 = 0;
                                                }

                                                if(NPC[A].Location.SpeedY < -0.01_n)
                                                    NPC[A].Location.SpeedY = -0.01_n + Block[B].Location.SpeedY;

                                                if(is_winged)
                                                    NPC[A].Location.SpeedY += 2;
                                            }
                                        }

                                        // could make compat flag here and refuse to clobber these values for cases other than wall climbers
                                        if(Special2_from == 'X')
                                            NPC[A].SpecialX = NPC_A_Special2;
                                        else if(Special2_from == 'Y')
                                            NPC[A].SpecialY = NPC_A_Special2;
                                        else
                                            NPC[A].Special2 = (vbint_t)NPC_A_Special2;

                                        if(Special_from == 'X')
                                            NPC[A].SpecialX = NPC_A_Special;
                                        else if(Special_from == 'Y')
                                            NPC[A].SpecialY = NPC_A_Special;
                                        else if(Special_from == '5')
                                            NPC[A].Special5 = (vbint_t)NPC_A_Special;
                                        else
                                            NPC[A].Special = (vbint_t)NPC_A_Special;
                                    }


                                    if(BlockSlope[Block[B].Type] != 0 && HitSpot > 0)
                                    {
                                        HitSpot = 0;
                                        if(NPC[A].Location.Y + NPC[A].Location.Height <= Block[B].Location.Y + Block[B].Location.Height + NPC[A].Location.SpeedY + 4)
                                        {
                                            if(NPC[A].Location.X < Block[B].Location.X + Block[B].Location.Width && NPC[A].Location.X + NPC[A].Location.Width > Block[B].Location.X)
                                            {
                                                num_t PlrMid;
                                                if(BlockSlope[Block[B].Type] == 1)
                                                    PlrMid = NPC[A].Location.X;
                                                else
                                                    PlrMid = NPC[A].Location.X + NPC[A].Location.Width;

                                                num_t Slope = (PlrMid - Block[B].Location.X) / (int_ok)Block[B].Location.Width;

                                                if(BlockSlope[Block[B].Type] < 0)
                                                    Slope = 1 - Slope;
                                                if(Slope < 0)
                                                    Slope = 0;
                                                if(Slope > 100)
                                                    Slope = 100;

                                                if(tempHitBlock > 0) // VERIFY ME
                                                {
                                                    if(!BlockIsSizable[Block[tempHitBlock].Type])
                                                    {
                                                        if(Block[tempHitBlock].Location.Y != Block[B].Location.Y)
                                                        {
                                                            tempHitBlock = 0;
                                                            tempHit = 0;
                                                        }
                                                    }
                                                }

                                                if(NPC[A].Location.Y >= Block[B].Location.Y + ((int_ok)Block[B].Location.Height * Slope) - NPC[A].Location.Height - 0.1_n)
                                                {
                                                    if(NPC[A].Type == NPCID_EARTHQUAKE_BLOCK && NPC[A].Location.SpeedY > 2)
                                                        NPCHit(A, 4, A);

                                                    if((NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_WALL_TURTLE) && NPC[A].Special == 3)
                                                    {
                                                        NPC[A].Special = 1;
                                                        NPC[A].Special2 = -NPC[A].Special2;
                                                    }

                                                    if(NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_SPIT_BOSS_BALL) // Bullet bills crash on slopes
                                                    {
                                                        NPC[A].Slope = 1;
                                                        if(NPC[A].Location.SpeedX < 0)
                                                            HitSpot = 2;
                                                        else
                                                            HitSpot = 4;
                                                    }
                                                    else
                                                    {
                                                        NPC[A].Location.Y = Block[B].Location.Y + ((int_ok)Block[B].Location.Height * Slope) - NPC[A].Location.Height - 0.1_n;

                                                        if(NPC[A]->IsFish)
                                                            NPC[A].TurnAround = true;

                                                        NPC[A].Slope = B;
                                                        HitSpot = 1;

                                                        // Fireballs dont go up steep slopes
                                                        if(Block[B].Location.Height >= Block[B].Location.Width && ((BlockSlope[Block[B].Type] == -1 && NPC[A].Location.SpeedX > 0) || (BlockSlope[Block[B].Type] == 1 && NPC[A].Location.SpeedX < 0)))
                                                        {
                                                            if((NPC[A].Type == NPCID_PLR_FIREBALL && NPC[A].Special != 2 && NPC[A].Special != 3) || (NPC[A].Type == NPCID_PLR_ICEBALL && NPC[A].Special == 5))
                                                            {
                                                                if(NPC[A].Location.SpeedX < 0)
                                                                    HitSpot = 2;
                                                                else
                                                                    HitSpot = 4;
                                                            }
                                                        }

                                                        if(NPC[A]->IsAShell || (NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1) || NPC[A].Type == NPCID_ICE_CUBE)
                                                        {
                                                            if(NPC[A].Location.SpeedY > NPC[A].Location.SpeedX * (int_ok)Block[B].Location.Height / (int_ok)Block[B].Location.Width * BlockSlope[Block[B].Type])
                                                            {
                                                                NPC[A].Location.SpeedY = NPC[A].Location.SpeedX * (int_ok)Block[B].Location.Height / (int_ok)Block[B].Location.Width * BlockSlope[Block[B].Type];
                                                                HitSpot = 0;
                                                                if(NPC[A].Location.SpeedY > 0)
                                                                    NPC[A].Location.SpeedY = 0;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    if(BlockKills[Block[B].Type] && (HitSpot > 0 || NPC[A].Slope == B))
                                        NPCHit(A, 6, B);

                                    if(HitSpot == 5)
                                    {
                                        if(NPC[A].Slope > 0 && Block[B].Location.Y + Block[B].Location.Height < NPC[A].Location.Y + 4)
                                        {
                                            if(Block[B].Location.X + Block[B].Location.Width < NPC[A].Location.X + 4 || Block[B].Location.X > NPC[A].Location.X + NPC[A].Location.Width - 4)
                                                HitSpot = 0;
                                        }
                                    }

                                    if(Block[B].tempBlockNpcType == NPCID_BOSS_CASE || Block[B].tempBlockNpcType == NPCID_BOSS_FRAGILE)
                                    {
                                        if(NPC[A].Projectile)
                                        {
                                            NPCHit(Block[B].tempBlockNpcIdx, 3, A);
                                            NPCHit(A, 4, Block[B].tempBlockNpcIdx);
                                        }
                                    }

                                    // At this point, the hit is confirmed and the HitSpot will not change.

                                    // Unified type-based logic on confirmed hit -- post slope and lava checks. Probably do allow users to define this for non-floor collisions
                                    if(NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_WALL_TURTLE)
                                    {
                                        if(NPC[A].Special == 3 && (HitSpot == 2 || HitSpot == 4))
                                        {
                                            if(Block[B].Location.Y + Block[B].Location.Height <= NPC[A].Location.Y + 1)
                                                HitSpot = 3;
                                        }
                                    }
                                    // beech koopa kicking an ice block
                                    else if(NPC[A].Type == NPCID_EXT_TURTLE || NPC[A].Type == NPCID_BLU_HIT_TURTLE_S4)
                                    {
                                        if(Block[B].tempBlockNpcType == NPCID_SLIDE_BLOCK
                                            && (g_config.fix_npc55_kick_ice_blocks || NPC[A].Type == NPCID_BLU_HIT_TURTLE_S4)
                                            && (HitSpot == 2 || HitSpot == 4))
                                        {
                                            if(NPC[A].Location.SpeedY == Physics.NPCGravity ||
                                               NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0 ||
                                               (oldSlope > 0 && !NPC[Block[B].tempBlockNpcIdx].Projectile))
                                            {
                                                NPC[Block[B].tempBlockNpcIdx].Special = 1;
                                                NPC[A].Special = 10;
                                                Player[numPlayers + 1].Direction = NPC[A].Direction;
                                                NPC[A].Location.X += -NPC[A].Direction;
                                                NPCHit(Block[B].tempBlockNpcIdx, 1, numPlayers + 1);
                                                HitSpot = 0;
                                            }
                                        }
                                    }
                                    // slightly rearranged -- note that these types ignore HitCode 4 and that ICE_CUBE is Killed by HitCode 3, so this is safe
                                    else if(NPC[A].Type == NPCID_ICE_BLOCK || NPC[A].Type == NPCID_ICE_CUBE)
                                    {
                                        if(HitSpot == 2 || HitSpot == 4 || HitSpot == 5)
                                        {
                                            if(Block[B].tempBlockNpcType == NPCID_ICE_CUBE)
                                            {
                                                NPCHit(Block[B].tempBlockNpcIdx, 3, Block[B].tempBlockNpcIdx);
                                                NPC[Block[B].tempBlockNpcIdx].Location.SpeedX = -NPC[A].Location.SpeedX;
                                                NPC[A].Multiplier += 1;
                                            }

                                            NPCHit(A, 3, A);
                                        }
                                        else if(NPC[A].Type == NPCID_ICE_CUBE && (HitSpot == 1 || HitSpot == 3 /* || HitSpot == 5*/))
                                        {
                                            if(NPC[A].Location.SpeedX > -Physics.NPCShellSpeed * 0.8_r && NPC[A].Location.SpeedX < Physics.NPCShellSpeed * 0.8_r)
                                            {
                                                if(NPC[A].Location.SpeedY > 5 || NPC[A].Location.SpeedY < -2)
                                                    NPCHit(A, 3, A);
                                            }
                                        }
                                    }
                                    // quite rearranged. these came after the below pinch logic before.
                                    // I confirmed that each of their NPCHit calls commute with being hit by NPC 0 with HitCode 3. -- ds-sloth
                                    else if(NPC[A].Type == NPCID_PLR_ICEBALL)
                                    {
                                        if(HitSpot > 1 || (NPC[A].Special == 5 && HitSpot > 0))
                                            NPCHit(A, 3, A);
                                    }
                                    else if(NPC[A].Type == NPCID_ITEM_BUBBLE)
                                    {
                                        if(!BlockIsSizable[Block[B].Type])
                                            NPCHit(A, 3, A);
                                    }
                                    else if(NPC[A].Type == NPCID_CHAR3_HEAVY)
                                    {
                                        if(HitSpot > 0)
                                            NPCHit(A, 3, A);
                                    }
                                    else if(NPC[A].Type == NPCID_PLR_FIREBALL)
                                    {
                                        if(NPC[A].Special == 5 && HitSpot > 0)
                                            NPCHit(A, 3, A);
                                    }

                                    // dead code: this procedure isn't called for coins with NPC[A].Special == 0
                                    // if(NPC[A]->IsACoin && NPC[A].Special == 0 && HitSpot > 0)
                                    //     NPCHit(A, 3, A);

                                    // NPC pinch logic
                                    if(Block[B].Location.SpeedX != 0 && (HitSpot == 2 || HitSpot == 4))
                                        NPC[A].Pinched.Moving = 2;

                                    if(Block[B].Location.SpeedY != 0 && (HitSpot == 1 || HitSpot == 3))
                                        NPC[A].Pinched.Moving = 2;

                                    if(NPC[A].TimeLeft > 1)
                                    {
                                        if(HitSpot == 1)
                                            NPC[A].Pinched.Bottom1 = 2;
                                        else if(HitSpot == 2)
                                            NPC[A].Pinched.Left2 = 2;
                                        else if(HitSpot == 3)
                                            NPC[A].Pinched.Top3 = 2;
                                        else if(HitSpot == 4)
                                            NPC[A].Pinched.Right4 = 2;
                                        else if(HitSpot == 5)
                                        {
                                            num_t dx = Block[B].Location.minus_center_x(NPC[A].Location);
                                            num_t dy = Block[B].Location.minus_center_y(NPC[A].Location);

                                            int D = 0;

                                            if(dx > 0)
                                                D = 2;
                                            else
                                            {
                                                dx = -dx;
                                                D = 4;
                                            }

                                            if(dy > 0)
                                            {
                                                if(dx < dy)
                                                    D = 1;
                                            }
                                            else
                                            {
                                                if(dx < -dy)
                                                    D = 3;
                                            }

                                            if(D == 1)
                                                NPC[A].Pinched.Bottom1 = 2;
                                            if(D == 2)
                                                NPC[A].Pinched.Left2 = 2;
                                            if(D == 3)
                                                NPC[A].Pinched.Top3 = 2;
                                            if(D == 4)
                                                NPC[A].Pinched.Right4 = 2;

                                            if(Block[B].Location.SpeedX != 0 && (D == 2 || D == 4))
                                                NPC[A].Pinched.Moving = 2;
                                            if(Block[B].Location.SpeedY != 0 && (D == 1 || D == 3))
                                                NPC[A].Pinched.Moving = 2;

                                            // If Not (.Location.Y + .Location.Height - .Location.SpeedY <= Block(B).Location.Y - Block(B).Location.SpeedY) Then .Pinched1 = 2
                                            // If Not (.Location.Y - .Location.SpeedY >= Block(B).Location.Y + Block(B).Location.Height - Block(B).Location.SpeedY) Then .Pinched3 = 2
                                            // If Not (.Location.X + .Location.Width - .Location.SpeedX <= Block(B).Location.X - Block(B).Location.SpeedX) Then .Pinched2 = 2
                                            // If Not (.Location.X - .Location.SpeedX >= Block(B).Location.X + Block(B).Location.Width - Block(B).Location.SpeedX) Then .Pinched4 = 2
                                        }

                                        if(NPC[A].Pinched.Moving > 0)
                                        {
                                            if((NPC[A].Pinched.Bottom1 > 0 && NPC[A].Pinched.Top3 > 0) || (NPC[A].Pinched.Left2 > 0 && NPC[A].Pinched.Right4 > 0))
                                            {
                                                if(HitSpot > 1)
                                                    HitSpot = 0;

                                                // for coins, Damage was overloaded to store coinSwitchBlockType. don't clobber it here!
                                                if(!NPCTraits[NPC[A].DefaultType].IsACoin)
                                                {
                                                    NPC[A].Damage += 10000;

                                                    // NEW bounds check
                                                    // this reduces the risk of a signed integer overflow, and SMBX 1.3 includes no comparisons to values above 20000
                                                    // SMBX 1.3 uses a float for Damage, which effectively saturates at such high values
                                                    if(NPC[A].Damage > 16000)
                                                        NPC[A].Damage = 16000;
                                                }

                                                NPC[A].Immune = 0;
                                                NPC[0].Multiplier = 0;
                                                NPCHit(A, 3, 0);
                                            }
                                        }
                                    }

                                    // safe to leave uninitialized, they're only read if g_config.fix_npc_downward_clip is set
                                    num_t tempHitOld;
                                    int tempHitOldBlock;

                                    if(g_config.fix_npc_downward_clip)
                                    {
                                        tempHitOld = tempHit;
                                        tempHitOldBlock = tempHitBlock;
                                    }

                                    // hitspot 1
                                    if(HitSpot == 1) // Hitspot 1
                                    {
                                        tempSpeedA = (tempf_t)Block[B].Location.SpeedY;
                                        if(tempSpeedA < 0)
                                            tempSpeedA = 0;

                                        if(Block[B].tempBlockNpcIdx > 0 && NPC[Block[B].tempBlockNpcIdx].Type != NPCID_CONVEYOR
                                            && NPC[Block[B].tempBlockNpcIdx].Type != NPCID_YEL_PLATFORM && NPC[Block[B].tempBlockNpcIdx].Type != NPCID_BLU_PLATFORM && NPC[Block[B].tempBlockNpcIdx].Type != NPCID_GRN_PLATFORM && NPC[Block[B].tempBlockNpcIdx].Type != NPCID_RED_PLATFORM)
                                        {
                                            if(NPC[Block[B].tempBlockNpcIdx].TimeLeft < NPC[A].TimeLeft - 1)
                                                NPC[Block[B].tempBlockNpcIdx].TimeLeft = NPC[A].TimeLeft - 1;
                                            else if(NPC[Block[B].tempBlockNpcIdx].TimeLeft - 1 > NPC[A].TimeLeft)
                                                NPC[A].TimeLeft = NPC[Block[B].tempBlockNpcIdx].TimeLeft - 1;
                                        }

                                        // type-based logic for floor collisions
                                        if(NPC[A].Type == NPCID_STACKER)
                                        {
                                            // If a Pokey head stands on a top of another Pokey segment
                                            // FIXME: need a compat guard for second condition
                                            if(Block[B].tempBlockNpcType == NPCID_STACKER
                                                && NPC[Block[B].tempBlockNpcIdx].Type == NPCID_STACKER) // Make sure Pokey didn't transformed into ice cube or anything also
                                            {
                                                NPC[Block[B].tempBlockNpcIdx].Special = -3;
                                                NPC[A].Special2 = 0;
                                            }
                                        }
                                        // item pod hatching (moved from above)
                                        else if(NPC[A].Type == NPCID_ITEM_POD /* && HitSpot == 1 */)
                                        {
                                            if(NPC[A].Location.SpeedY > 2) /* && HitSpot == 1) || (NPC[A].Location.SpeedY < -2 && HitSpot == 3) || (NPC[A].Location.SpeedX > 2 && HitSpot == 4) || (NPC[A].Location.SpeedX < -2 && HitSpot == 2)) */
                                                NPC[A].Special2 = 1;
                                        }
                                        else if(NPC[A].Type == NPCID_SPIKY_BALL_S4 || NPC[A].Type == NPCID_GOALTAPE || NPC[A].Type == NPCID_FLAG_EXIT)
                                            NPC[A].Special = 1;
                                        else if(NPC[A].Type == NPCID_SQUID_S3 || NPC[A].Type == NPCID_SQUID_S1)
                                            NPC[A].Special4 = 1;
                                        else if(NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_STONE_S4)
                                            NPC[A].Special = 2;
                                        else if(NPC[A].Type == NPCID_DOOR_MAKER)
                                        {
                                            NPC[A].Special3 = 1;
                                            NPC[A].Projectile = false;
                                        }
                                        else if(NPC[A].Type == NPCID_EARTHQUAKE_BLOCK)
                                        {
                                            if(NPC[A].Location.SpeedY > 2)
                                                NPCHit(A, 4, A);
                                        }
                                        else if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL)
                                        {
                                            if(NPC[A].Location.SpeedX == 0)
                                                NPCHit(A, 4, A);
                                        }
                                        else if(NPC[A].Type == NPCID_SLIDE_BLOCK)
                                        {
                                            if(NPC[A].Special == 1 && NPC[A].Location.SpeedX == 0 && NPC[A].Location.SpeedY > 7.95_n)
                                                NPCHit(A, 4, A);
                                        }
                                        else if(NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG)
                                        {
                                            if(NPC[A].Location.SpeedY > Physics.NPCGravity * 20)
                                                PlaySoundSpatial(SFX_Stone, NPC[A].Location);
                                        }
                                        else if(NPC[A].Type == NPCID_TANK_TREADS)
                                        {
                                            if(NPC[A].Location.SpeedY > Physics.NPCGravity * 10)
                                                PlaySoundSpatial(SFX_Stone, NPC[A].Location);
                                        }

                                        if(WalkingCollision3(NPC[A].Location, Block[B].Location, oldBeltSpeed) || NPC[A].Location.Width > 32)
                                        {
                                            resetBeltSpeed = true;

                                            if(Block[B].tempBlockNpcType != 0)
                                            {
                                                if(Block[B].Location.SpeedY > 0 && Block[B].tempBlockNpcType >= NPCID_YEL_PLATFORM && Block[B].tempBlockNpcType <= NPCID_RED_PLATFORM)
                                                    tempHit = Block[B].Location.Y - NPC[A].Location.Height - 0.01_n + Block[B].Location.SpeedY;
                                                else
                                                    tempHit = Block[B].Location.Y - NPC[A].Location.Height - 0.01_n;

                                                tempHitBlock = B;
                                            }
                                            else
                                            {
                                                tempHitBlock = B;
                                                tempHit = Block[B].Location.Y - NPC[A].Location.Height - 0.01_n;
                                            }

                                            if(Block[B].tempBlockNpcType >= NPCID_YEL_PLATFORM && Block[B].tempBlockNpcType <= NPCID_RED_PLATFORM)
                                            {
                                                beltSpeed = 0;
                                                beltCount = 0;
                                            }

                                            num_t C = 0;

                                            if(NPC[A].Location.X > Block[B].Location.X)
                                                C = NPC[A].Location.X - 0.01_n;
                                            else
                                                C = Block[B].Location.X - 0.01_n;

                                            if(NPC[A].Location.X + NPC[A].Location.Width < Block[B].Location.X + Block[B].Location.Width)
                                                C = (NPC[A].Location.X + NPC[A].Location.Width - C + 0.01_n);
                                            else
                                                C = (Block[B].Location.X + Block[B].Location.Width - C + 0.01_n);

                                            if(Block[B].tempBlockVehiclePlr == 0)
                                            {
                                                if(Block[B].tempBlockNpcType > 0)
                                                    beltSpeed = (tempf_t)((num_t)beltSpeed + Block[B].Location.SpeedX.times(C).times((num_t)blk_npc_tr.Speedvar));
                                                else
                                                    beltSpeed = (tempf_t)((num_t)beltSpeed + Block[B].Location.SpeedX.times(C));

                                                beltCount += tempf_t(C);
                                            }
                                        }

                                        if(tempHitBlock == B)
                                        {
                                            if(NPC[A].Type == NPCID_SPIKY_BALL_S3)
                                            {
                                                if(NPC[A].Location.SpeedY > 2)
                                                {
                                                    NPC[A].Location.SpeedY = -NPC[A].Location.SpeedY * 0.7_r + Block[B].Location.SpeedY;

                                                    if(NPC[A].Slope == 0)
                                                        NPC[A].Location.Y = Block[B].Location.Y - NPC[A].Location.Height - 0.01_n;

                                                    tempHit = 0;
                                                    tempHitBlock = 0;
                                                }
                                            }

                                            if(((NPC[A]->StandsOnPlayer && !NPC[A].Projectile) || (NPC[A]->IsAShell && NPC[A].Location.SpeedX == 0)) && Block[B].tempBlockVehiclePlr > 0)
                                            {
                                                // IMPORTANT: this case was truncation until v1.3.7.1-dev. Confirm that changing to VB6 rounding does not cause any issues.
                                                NPC[A].vehicleYOffset = Block[B].tempBlockVehicleYOffset + num_t::vb6round(NPC[A].Location.Height);
                                                NPC[A].vehiclePlr = Block[B].tempBlockVehiclePlr;
                                                if(NPC[A].vehiclePlr == 0 && Block[B].tempBlockNpcType == NPCID_VEHICLE)
                                                    NPC[A].TimeLeft = 100;
                                            }

                                            if(NPC[A].Projectile)
                                            {
                                                if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL)
                                                {
                                                    if(NPC[A].Type == NPCID_PLR_ICEBALL)
                                                        NPC[A].Location.SpeedY = -7 + Block[B].Location.SpeedY;
                                                    else if(NPC[A].Special == 4)
                                                        NPC[A].Location.SpeedY = -3 + Block[B].Location.SpeedY;
                                                    else
                                                        NPC[A].Location.SpeedY = -5 + Block[B].Location.SpeedY;

                                                    if(NPC[A].Slope == 0)
                                                        NPC[A].Location.Y = Block[B].Location.Y - NPC[A].Location.Height - 0.01_n;

                                                    tempHit = 0;
                                                    tempHitOld = 0;

                                                    if(NPC[A].Type == NPCID_PLR_ICEBALL)
                                                    {
                                                        if(!Block[B].Slippy)
                                                            NPC[A].Special5 += 1;

                                                        if(NPC[A].Special5 >= 3)
                                                            NPCHit(A, 3, A);
                                                    }
                                                }
                                                else if(NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4)
                                                {
                                                    // Yes, you aren't mistook, it's just a blank block, hehehe (made by Redigit originally)


                                                }
                                                else if(NPC[A].Bouce || NPC[A].Location.SpeedY > 5.8_n || ((NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_TOOTHYPIPE) && (NPC[A].Location.SpeedY > 2 || (NPC[A].Location.SpeedX > 1 || NPC[A].Location.SpeedX < -1))))
                                                {
                                                    NPC[A].Bouce = false;
                                                    if(NPC[A]->IsAShell || (NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1) || NPC[A].Type == NPCID_ICE_CUBE)
                                                    {
                                                        if(NPC[A].Slope == 0)
                                                            NPC[A].Location.SpeedY = -NPC[A].Location.SpeedY / 2;
                                                        for(int C = 1; C <= numPlayers; C++)
                                                        {
                                                            if(Player[C].StandingOnNPC == A)
                                                            {
                                                                NPC[A].Location.SpeedY = 0;
                                                                break;
                                                            }
                                                        }

                                                    }
                                                    else if(NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG || (NPC[A].Type >= NPCID_TANK_TREADS && NPC[A].Type <= NPCID_SLANT_WOOD_M))
                                                        NPC[A].Location.SpeedY = 0;
                                                    else if(NPC[A].Type == NPCID_VILLAIN_S3 || NPC[A].Type == NPCID_ITEM_POD)
                                                    {
                                                        NPC[A].Projectile = false;
                                                        NPC[A].Location.SpeedY = 0;
                                                    }
                                                    else
                                                        NPC[A].Location.SpeedY = -NPC[A].Location.SpeedY * 0.6_r;
                                                    if(NPC[A].Slope == 0)
                                                        NPC[A].Location.Y = Block[B].Location.Y - NPC[A].Location.Height - 0.01_n;
                                                    tempHit = 0;
                                                    tempHitOld = 0;
                                                }
                                                else if(NPC[A].Type != NPCID_TANK_TREADS && NPC[A].Type != NPCID_BULLET /* && NPC[A].Type != NPCID_PLR_FIREBALL*/) // FIREBALL checked above
                                                {
                                                    if(NPC[A]->MovesPlayer)
                                                    {
                                                        if(NPC[A].Location.SpeedX == 0)
                                                        {
                                                            bool tempBool = false;
                                                            for(int C = 1; C <= numPlayers; C++)
                                                            {
                                                                if(CheckCollision(NPC[A].Location, Player[C].Location))
                                                                {
                                                                    tempBool = true;
                                                                    break;
                                                                }
                                                            }

                                                            if(!tempBool)
                                                                NPC[A].Projectile = false;
                                                        }
                                                    }
                                                    else if(NPC[A].Type == NPCID_CHASER)
                                                    {
                                                        if(NPC[A].Location.SpeedX > -0.1_n && NPC[A].Location.SpeedX < 0.1_n)
                                                            NPC[A].Projectile = false;
                                                    }
                                                    else if(!(NPC[A]->IsAShell || (NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1) || NPC[A].Type == NPCID_SPIKY_BALL_S3))
                                                        NPC[A].Projectile = false;
                                                    else if(NPC[A].Location.SpeedX == 0)
                                                        NPC[A].Projectile = false;
                                                }
                                            }
                                        }
                                    }
                                    else if(HitSpot == 2 || HitSpot == 4) // Horizontal collisions
                                    {
                                        if(HitSpot == 2 && BlockSlope[Block[oldSlope].Type] == 1 && Block[oldSlope].Location.Y == Block[B].Location.Y)
                                        {
                                        }
                                        else
                                        {
                                            beltClear = true;
                                            if(NPC[A].Type == NPCID_VILLAIN_S3 && !NPC[A].Wings)
                                                NPC[A].Location.SpeedX = 0;

                                            resetBeltSpeed = true;
                                            if(NPC[A].Type == NPCID_PLR_FIREBALL && NPC[A].Special == 3)
                                            {
                                                if(NPC[A].Special2 == 0)
                                                {
                                                    NPC[A].Special2 = 1;
                                                    NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                                }
                                                else
                                                    NPCHit(A, 4, A);
                                            }
                                            else if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_SPIT_BOSS_BALL)
                                                NPCHit(A, 4, A);
                                            if(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1)
                                                NPCHit(A, 4, A);

                                            addBelt = (tempf_t)NPC[A].Location.X;

                                            if(NPC[A].Slope == 0 && !SlopeTurn)
                                            {
                                                if(HitSpot == 2)
                                                    NPC[A].Location.X = Block[B].Location.X + Block[B].Location.Width + 0.01_n;
                                                else
                                                    NPC[A].Location.X = Block[B].Location.X - NPC[A].Location.Width - 0.01_n;
                                            }

                                            addBelt = (tempf_t)(NPC[A].Location.X - (num_t)addBelt);

                                            // the only read-site in the entire SMBX 1.3 codebase checks for these types and ignores them
                                            // if(!(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_TANK_TREADS || NPC[A].Type == NPCID_BULLET))
                                            NPC[A].TurnAround = true;

                                            if(is_winged)
                                                NPC[A].Location.SpeedX += -Block[B].Location.SpeedX * 1.2_r;
                                            else if(NPC[A]->IsAShell && !NPC[A].Wings)
                                                NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                        }
                                    }
                                    else if(HitSpot == 3) // Hitspot 3
                                    {
                                        // ignore the hit if it is an NPC that a Winged Block NPC will be supporting
                                        if(NPC[A].Wings && NPC[A].tempBlock && Block[B].tempBlockNpcIdx && !blk_npc_tr.NoGravity)
                                            continue;

                                        if(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1)
                                            NPCHit(A, 4, A);

                                        if(NPC[A].Type == NPCID_MINIBOSS)
                                            NPC[A].Special3 = 0;

                                        if(tempBlockHit1 == 0)
                                            tempBlockHit1 = B;
                                        else
                                            tempBlockHit2 = B;

                                        if(is_winged)
                                        {
                                            NPC[A].Location.SpeedY = 2 + Block[B].Location.SpeedY;
                                            NPC[A].Location.Y = Block[B].Location.Y + Block[B].Location.Height + 0.1_n;
                                        }
                                    }
                                    else if(HitSpot == 5) // Hitspot 5
                                    {
                                        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_SPIT_BOSS_BALL)
                                            NPCHit(A, 4, A);

                                        beltClear = true;

                                        if(NPC[A].Type == NPCID_VILLAIN_S3)
                                            NPC[A].Location.SpeedX = 0;

                                        onWall = true;

                                        // item was thrown into a wall this frame (or is a fish that just re-entered water)
                                        if(NPC[A].WallDeath >= 5 && !NPC[A]->IsABonus && NPC[A].Type != NPCID_FLY_BLOCK &&
                                           NPC[A].Type != NPCID_FLY_CANNON && NPC[A].Type != NPCID_RED_BOOT && NPC[A].Type != NPCID_CANNONENEMY && NPC[A].Type != NPCID_CANNONITEM &&
                                           NPC[A].Type != NPCID_SPRING && NPC[A].Type != NPCID_HEAVY_THROWER && NPC[A].Type != NPCID_KEY && NPC[A].Type != NPCID_COIN_SWITCH &&
                                           NPC[A].Type != NPCID_GRN_BOOT &&
                                           // Duplicated segment [PVS Studio]
                                           // NPC[A].Type != NPCID_RED_BOOT &&
                                           NPC[A].Type != NPCID_BLU_BOOT && NPC[A].Type != NPCID_TOOTHYPIPE &&
                                           NPC[A].Type != NPCID_BOMB && NPC[A].Type != NPCID_CARRY_BUDDY && NPC[A].Type != NPCID_FLIPPED_RAINBOW_SHELL && NPC[A].Type != NPCID_EARTHQUAKE_BLOCK &&
                                           !((NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D))) // walldeath stuff
                                        {
                                            NPC[A].Location.SpeedX = Physics.NPCShellSpeed / 2 * NPC[A].Direction;
                                            if(NPCIsVeggie(NPC[A]))
                                                NPC[A].Projectile = true;
                                            else if(NPC[A].Type == NPCID_WALK_BOMB_S2)
                                                NPCHit(A, 4, A);
                                            else if(NPC[A].Type == NPCID_CHAR3_HEAVY)
                                                NPCHit(A, 3, A);
                                            else
                                            {
                                                NewEffect(EFFID_WHACK, NPC[A].Location);
                                                NPC[A].Killed = 3;
                                                NPCQueues::Killed.push_back(A);
                                            }
                                        }
                                        else if(NPC[A].Type != NPCID_SPIKY_BALL_S3 && !(NPC[A]->IsABlock && Block[B].tempBlockNpcType > 0) && block_is_not_conveyor)
                                        {
                                            addBelt = (tempf_t)NPC[A].Location.X;

                                            if(NPC[A].Location.X + NPC[A].Location.Width / 2 < Block[B].Location.X + Block[B].Location.Width / 2)
                                                NPC[A].Location.X = Block[B].Location.X - NPC[A].Location.Width - 0.01_n;
                                            else
                                                NPC[A].Location.X = Block[B].Location.X + Block[B].Location.Width + 0.01_n;

                                            addBelt = (tempf_t)(NPC[A].Location.X - (num_t)addBelt);

                                            if(NPC[A].Type == NPCID_MINIBOSS)
                                            {
                                                NPC[A].Location.SpeedY = 0;
                                                NPC[A].Location.Y = Block[B].Location.Y - NPC[A].Location.Height - 0.01_n;
                                            }

                                            // the only read-site in the entire SMBX 1.3 codebase checks for fireball and tank_treads and ignores them,
                                            //   and kills iceball (which must have already been killed if this code was reached)
                                            // if(NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_TANK_TREADS && NPC[A].Type != NPCID_PLR_ICEBALL)
                                            NPC[A].TurnAround = true;

                                            if(NPC[A]->IsAShell)
                                            {
                                                if(NPC[A].Location.X < Block[B].Location.X && NPC[A].Location.SpeedX > 0)
                                                    NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                                else if(NPC[A].Location.X + NPC[A].Location.Width > Block[B].Location.X + Block[B].Location.Width && NPC[A].Location.SpeedX < 0)
                                                    NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                            }
                                        }
                                    }

                                    // Find best block here
                                    if(g_config.fix_npc_downward_clip && (tempHitBlock != tempHitOldBlock))
                                    {
                                        CompareNpcWalkBlock(tempHitBlock, tempHitOldBlock,
                                                            tempHit, tempHitOld,
                                                            tempHitIsSlope, &NPC[A]);
                                    }

                                    if(NPC[A].Projectile && NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PLR_ICEBALL && NPC[A].Type != NPCID_METALBARREL && !(NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG)) // Hit the block if the NPC is a projectile
                                    {
                                        if(HitSpot == 2 || HitSpot == 4 || HitSpot == 5)
                                        {
                                            BlockHit(B);
                                            PlaySoundSpatial(SFX_BlockHit, NPC[A].Location);
                                            if(NPC[A].Type == NPCID_BULLET) // Bullet Bills
                                            {
                                                NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                                NPCHit(A, 4, A);
                                                BlockHitHard(B);
                                                break;
                                            }

                                            if(NPC[A]->IsAShell || (NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1) || NPC[A].Type == NPCID_ICE_CUBE)
                                            {
                                                BlockHitHard(B);
                                                if(Block[B].Type == 4 || Block[B].Type == 188 || Block[B].Type == 60 || Block[B].Type == 90)
                                                    NPC[A].TimeLeft = Physics.NPCTimeOffScreen;
                                            }
                                        }
                                    }
                                }
                                // End If
                            }
                        }
                    }
                }
                else
                {
                    if((bCheck == 2 || BlocksSorted) && PSwitchTime == 0)
                        break;
                }
            }

            if(numTempBlock == 0)
                break;
        }
    } // do block collisions

    // ceiling logic (safe to move into above braces if desired; it's impossible for tempBlockHit to be set unless that clause executed)
    if(tempBlockHit1 > 0) // find out which block was hit from below
    {
        int winningBlock = 0;

        if(tempBlockHit2 == 0)
            winningBlock = tempBlockHit1;
        else
        {
            num_t C = num_t::abs(Block[tempBlockHit1].Location.minus_center_x(NPC[A].Location));
            num_t D = num_t::abs(Block[tempBlockHit2].Location.minus_center_x(NPC[A].Location));

            if(C < D)
                winningBlock = tempBlockHit1;
            else
                winningBlock = tempBlockHit2;
        }

        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL) // Kill the fireball
            NPCHit(A, 4);
        else if(NPC[A].Projectile || Block[winningBlock].Invis) // Hit the block hard if the NPC is a projectile
        {
            if(!(NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG || NPC[A].Type == NPCID_CANNONENEMY))
            {
                if(NPC[A].Location.SpeedY < -0.05_n)
                {
                    BlockHit(winningBlock);
                    PlaySoundSpatial(SFX_BlockHit, NPC[A].Location);
                    if(NPC[A]->IsAShell || NPC[A].Type == NPCID_ICE_CUBE)
                        BlockHitHard(winningBlock);
                }
                else
                    NPC[A].Projectile = false;
            }
        }

        if(!is_winged)
        {
            NPC[A].Location.Y = Block[winningBlock].Location.Y + Block[winningBlock].Location.Height + 0.01_n;

            if(g_config.fix_npc_ceiling_speed)
                NPC[A].Location.SpeedY = 0.01_n + Block[winningBlock].Location.SpeedY;
            else
            {
                // This is the original extremely buggy line, using an arbitrary B from the end of the old fBlock/lBlock or tempBlock query.
                // NPC[A].Location.SpeedY = 0.01 + Block[B].Location.SpeedY;

                // Unfortunately, we need to emulate it. We're lucky that NPCs don't frequently hit ceilings.

                // our old... friends?
                int fBlock, lBlock;

                // if no temp blocks, then no second pass occurred in the check loops above where B was set
                if(numTempBlock != 0)
                {
                    fBlock = numBlock + 1 - numTempBlock;
                    lBlock = numBlock;
                }
                else
                {
                    fBlock = 1;
                    lBlock = numBlock - numTempBlock;
                }

                int B = -1;

                // The first line contains the original condition that guarded the "break" in our loop above B.
                // Note that this means the bug would be different during PSwitch or after a horiz layer has moved.
                // The second line lets us find the Block that is accessed upon overflow of the original FLBlock column.
                if((PSwitchTime == 0 && (BlocksSorted || numTempBlock != 0))
                    || (BlocksSorted && numTempBlock == 0))
                {
                    // We could use a quadtree here, but this is a rare case. Just do it.

                    // Normally, need to find the first Block (in sorted order) which is to the right of the NPC.
                    num_t right_border = NPC[A].Location.X + NPC[A].Location.Width;

                    int first_after_block = -1;
                    num_t first_after_x = 0, first_after_y = 0;

                    // IF PSwitchTime != 0 but the blocks are sorted,
                    // then we would have iterated over the NPC's entire FLBlock column without breaking,
                    // and ended with B set to the first block after it.
                    // To emulate, move the right_border to the end of its FLBlock column.
                    // vb6 rounds its array indexes from doubles to integers
                    if(PSwitchTime != 0)
                        right_border = num_t::vb6round(right_border / 32 + 1) * 32;

                    // If the loop never invoked break and was not over a single column,
                    // then the game would have accessed numBlock + 1 here, but we won't.
                    // We'll assume it was properly deallocated and has SpeedY = 0.

                    for(int block = fBlock; block <= lBlock; block++)
                    {
                        // Old code checked coordinates first, then properties without affecting the loop.
                        // This means we don't need to touch any properties here.

                        const Block_t& b = Block[block];

                        num_t bx = b.Location.X;
                        num_t by = b.Location.Y;

                        // sort as they were in the original array
                        if(b.Layer != LAYER_NONE)
                        {
                            bx -= Layer[b.Layer].OffsetX;
                            by -= Layer[b.Layer].OffsetY;
                        }

                        if(b.Location.X > right_border)
                        {
                            if(first_after_block == -1 || bx < first_after_x || (bx == first_after_x && by < first_after_y))
                            {
                                first_after_block = block;
                                first_after_x = bx;
                                first_after_y = by;

                                // want the first one in the SMBX sorted order, which might not be accurate
                                if(g_config.emulate_classic_block_order && numTempBlock == 0)
                                    break;
                            }
                        }
                    }

                    B = first_after_block;
                }
                else
                {
                    // The game went through the full loop and B = numBlock + 1 in vanilla.
                    // We'll assume it was properly deallocated and has SpeedY = 0.
                }

                if(B != -1)
                {
                    NPC[A].Location.SpeedY = 0.01_n + Block[B].Location.SpeedY;
                    // pLogDebug("NPC %d hits ceiling, set SpeedY using block %d with speed %f\n", A, B, Block[B].Location.SpeedY);
                }
                else
                {
                    NPC[A].Location.SpeedY = 0.01_n;
                    // pLogDebug("NPC %d hits ceiling, set SpeedY using OOB block with speed 0\n", A);
                }
            }
        }
    }

    // beltspeed code
    if(!resetBeltSpeed)
    {
        if(NPC[A].Type == NPCID_VILLAIN_S3 && NPC[A].Special == 1)
            NPC[A].Special = 0;

        if(oldBeltSpeed >= 1 || oldBeltSpeed <= -1)
        {
            beltSpeed = oldBeltSpeed - (tempf_t)NPC[A].oldAddBelt;
            beltCount = 1;
            if(beltSpeed >= (tempf_t)2.1_n)
                beltSpeed -= (tempf_t)0.1_n;
            else if(beltSpeed <= -(tempf_t)2.1_n)
                beltSpeed += (tempf_t)0.1_n;
        }
    }

    if(beltSpeed != 0)
    {
        Location_t preBeltLoc = NPC[A].Location;
        beltSpeed = beltSpeed.divided_by(beltCount).times(speedVar);
        NPC[A].Location.X += num_t(beltSpeed);
//                            D = NPC[A].BeltSpeed; // Idk why this is needed as this value gets been overriden and never re-used
        Location_t tempLocation = NPC[A].Location;
        tempLocation.Y += 1;
        tempLocation.Height -= 2;
        tempLocation.Width = tempLocation.Width / 2;

        if(beltSpeed > 0)
            tempLocation.X += tempLocation.Width;

        if(!(NPC[A].Type >= NPCID_SHORT_WOOD && NPC[A].Type <= NPCID_SLANT_WOOD_M) && !NPC[A].Inert)
        {
            for(int C : treeNPCQuery(tempLocation, SORTMODE_NONE))
            {
                if(A != C && NPC[C].Active && !NPC[C].Projectile)
                {
                    if(NPC[C].Killed == 0 && NPC[C].vehiclePlr == 0 && NPC[C].HoldingPlayer == 0 &&
                       !NPC[C]->NoClipping && NPC[C].Effect == NPCEFF_NORMAL && !NPC[C].Inert) // And Not NPCIsABlock(NPC(C).Type) Then
                    {
                        Location_t tempLocation2 = preBeltLoc;
                        tempLocation2.Width -= 4;
                        tempLocation2.X += 2;
                        if(CheckCollision(tempLocation, NPC[C].Location))
                        {
                            if(!CheckCollision(tempLocation2, NPC[C].Location))
                            {
                                if(NPC[A].TimeLeft - 1 > NPC[C].TimeLeft)
                                    NPC[C].TimeLeft = NPC[A].TimeLeft - 1;
                                else if(NPC[A].TimeLeft < NPC[C].TimeLeft - 1)
                                    NPC[A].TimeLeft = NPC[C].TimeLeft - 1;
                                onWall = true;
                                if((NPC[A].Location.SpeedX > 0 && NPC[C].Location.X > NPC[A].Location.X) || (NPC[A].Location.SpeedX < 0 && NPC[C].Location.X < NPC[A].Location.X))
                                    NPC[A].TurnAround = true;
                                if((NPC[C].Location.SpeedX > 0 && NPC[A].Location.X > NPC[C].Location.X) || (NPC[C].Location.SpeedX < 0 && NPC[A].Location.X < NPC[C].Location.X))
                                    NPC[C].TurnAround = true;
                                NPC[A].Location = preBeltLoc;
                            }
                        }
                    }
                }
            }
        }

        if(NPC[A].Location.X == preBeltLoc.X)
        {
            beltSpeed = 0;
            addBelt = 0;
            if(NPC[A].tempBlock > 0)
                Block[NPC[A].tempBlock].Location.SpeedX = 0;
        }
    }

    if(!onWall)
        beltSpeed += addBelt;

    NPC[A].oldAddBelt = (numf_t)addBelt;

    if(beltClear || NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_STONE_S4)
        NPC[A].BeltSpeed = 0;
    else
        NPC[A].BeltSpeed = (numf_t)beltSpeed;
}


================================================
FILE: src/npc/npc_update/npc_collide.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "npc.h"
#include "npc_traits.h"
#include "npc/npc_queues.h"
#include "config.h"
#include "collision.h"
#include "layers.h"
#include "effect.h"
#include "eff_id.h"
#include "editor.h"

#include "main/trees.h"

void NPCCollide(int A)
{
    // first exclusion condition
    // if(!(!NPC[A].Inert && NPC[A].Type != NPCID_LIFT_SAND && NPC[A].Type != NPCID_CANNONITEM && NPC[A].Type != NPCID_SPRING &&
    //         !(NPC[A].Type == NPCID_HEAVY_THROWN && !NPC[A].Projectile) && NPC[A].Type != NPCID_COIN_SWITCH && NPC[A].Type != NPCID_GRN_BOOT &&
    //         !(NPC[A].Type == NPCID_SPIT_BOSS_BALL && !NPC[A].Projectile) &&
    //         !((NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM || NPC[A].Type == NPCID_GRN_PLATFORM ||
    //    NPC[A].Type == NPCID_RED_PLATFORM || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT ||
    //    NPC[A].Type == NPCID_VPIPE_LONG || NPC[A].Type == NPCID_CANNONENEMY) && !NPC[A].Projectile) &&
    //         !(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 0) && !(NPC[A].Type == NPCID_SPIKY_BALL_S3 && !NPC[A].Projectile) &&
    //    NPC[A].Type != NPCID_TOOTHYPIPE && NPC[A].Type != NPCID_FALL_BLOCK_RED && NPC[A].Type != NPCID_VEHICLE && NPC[A].Type != NPCID_CONVEYOR &&
    //         !NPCIsYoshi(NPC[A]) && !(NPC[A].Type >= NPCID_TANK_TREADS && NPC[A].Type <= NPCID_SLANT_WOOD_M) &&
    //         !(NPC[A].Type == NPCID_ITEM_POD && !NPC[A].Projectile) && !(NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 &&
    //    NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4 && NPC[A].Projectile && NPC[A].CantHurt > 0) &&
    //         !(NPC[A]->IsAShell && !NPC[A].Projectile) &&
    //         !(NPC[A].Projectile && NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4) &&
    //    NPC[A].Type != NPCID_SPIT_GUY_BALL && !(!NPCIsToad(NPC[A]) && !NPC[A].Projectile &&
    //    NPC[A].Location.SpeedX == 0 && (NPC[A].Location.SpeedY == 0 || NPC[A].Location.SpeedY == Physics.NPCGravity))))
    // {
    //     return;
    // }

    // second exclusion condition
    // if(!(!NPC[A]->IsACoin && NPC[A].Type != NPCID_TIMER_S2 && NPC[A].Type != NPCID_FALL_BLOCK_BROWN &&
    //     NPC[A].Type != NPCID_WALL_BUG && NPC[A].Type != NPCID_WALL_SPARK && NPC[A].Type != NPCID_WALL_TURTLE && NPC[A].Type != NPCID_RED_BOOT &&
    //     NPC[A].Type != NPCID_BLU_BOOT && !(NPC[A]->IsFish && NPC[A].Special == 2) &&
    //    !NPC[A].Generator && NPC[A].Type != NPCID_PLANT_FIREBALL && NPC[A].Type != NPCID_FIRE_CHAIN &&
    //     NPC[A].Type != NPCID_QUAD_BALL && NPC[A].Type != NPCID_FLY_BLOCK && NPC[A].Type != NPCID_FLY_CANNON &&
    //     NPC[A].Type != NPCID_FIRE_BOSS_FIRE && NPC[A].Type != NPCID_DOOR_MAKER && NPC[A].Type != NPCID_MAGIC_DOOR))
    // {
    //     return;
    // }

    // These NPC types prevent all physics updates and make it so that NPCCollide can never be called. They are removed now.
    // NPC[A].Type == NPCID_LIFT_SAND || NPC[A].Type == NPCID_PLANT_FIREBALL || NPC[A].Type == NPCID_FIRE_CHAIN

    // NPC properties that block collision query
    if(NPC[A].Inert || NPC[A].Generator)
        return;

    // NPC traits that prevent collision query
    if(NPC[A]->IsACoin || NPCIsYoshi(NPC[A]))
        return;

    // NPC types that prevent collision query
    if(NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_SPRING || NPC[A].Type == NPCID_COIN_SWITCH || NPC[A].Type == NPCID_GRN_BOOT
        || NPC[A].Type == NPCID_TOOTHYPIPE || NPC[A].Type == NPCID_FALL_BLOCK_RED || NPC[A].Type == NPCID_VEHICLE || NPC[A].Type == NPCID_CONVEYOR
        || (NPC[A].Type >= NPCID_TANK_TREADS && NPC[A].Type <= NPCID_SLANT_WOOD_M) || NPC[A].Type == NPCID_SPIT_GUY_BALL
        || NPC[A].Type == NPCID_TIMER_S2 || NPC[A].Type == NPCID_FALL_BLOCK_BROWN
        || NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_WALL_TURTLE
        || NPC[A].Type == NPCID_RED_BOOT || NPC[A].Type == NPCID_BLU_BOOT || NPC[A].Type == NPCID_QUAD_BALL
        || NPC[A].Type == NPCID_FLY_BLOCK || NPC[A].Type == NPCID_FLY_CANNON || NPC[A].Type == NPCID_FIRE_BOSS_FIRE
        || NPC[A].Type == NPCID_DOOR_MAKER || NPC[A].Type == NPCID_MAGIC_DOOR)
    {
        return;
    }

    // NPC types that can only query collisions as projectiles
    if(!NPC[A].Projectile && (NPC[A].Type == NPCID_HEAVY_THROWN || NPC[A].Type == NPCID_SPIT_BOSS_BALL || NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM || NPC[A].Type == NPCID_GRN_PLATFORM ||
       NPC[A].Type == NPCID_RED_PLATFORM || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT ||
       NPC[A].Type == NPCID_VPIPE_LONG || NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_SPIKY_BALL_S3 || NPC[A].Type == NPCID_ITEM_POD || NPC[A]->IsAShell))
    {
        return;
    }

    // most NPCs cannot query collisions if static and not projectile
    if(!NPCIsToad(NPC[A]) && !NPC[A].Projectile && NPC[A].Location.SpeedX == 0 && (NPC[A].Location.SpeedY == 0 || NPC[A].Location.SpeedY == Physics.NPCGravity))
        return;

    // slide blocks only query collisions after activation
    if(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 0)
        return;

    // newly spawned hit turtles do not query collisions
    if(NPC[A].Projectile && NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4)
        return;

    // duplicate condition
    // if(NPC[A].Projectile && NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4 && NPC[A].CantHurt > 0)
    //     return;

    if(NPC[A]->IsFish && NPC[A].Special == 2)
        return;

    for(int B : treeNPCQuery(NPC[A].Location, SORTMODE_ID))
    {
        if(B == A || !NPC[B].Active || NPC[B]->IsACoin)
            continue;

        if(!CheckCollision(NPC[A].Location, NPC[B].Location))
            continue;

        // first exclusion condition
        // if(!(!(NPC[B].Type == NPCID_MINIBOSS && NPC[B].Special == 4) && !(NPCIsToad(NPC[B])) &&
        //    !(NPC[B].Type >= NPCID_PLATFORM_S3 && NPC[B].Type <= NPCID_PLATFORM_S1) && !(NPC[B].Type >= NPCID_CARRY_BLOCK_A && NPC[B].Type <= NPCID_CARRY_BLOCK_D) &&
        //    NPC[B].Type != NPCID_LIFT_SAND && NPC[B].Type != NPCID_SICK_BOSS_BALL && !NPC[B]->IsAVine &&
        //    NPC[B].Type != NPCID_PLR_ICEBALL && NPC[B].Type != NPCID_FIRE_CHAIN && NPC[B].Type != NPCID_CHAR3_HEAVY))
        // {
        //     continue;
        // }

        // second exclusion condition
        // If Not (NPC(B).Type = 133) And NPC(B).HoldingPlayer = 0 And .Killed = 0 And NPC(B).JustActivated = 0 And NPC(B).Inert = False And NPC(B).Killed = 0 Then
        // if(!(NPC[B].Type != NPCID_SPIT_GUY_BALL && !(NPCIsVeggie(NPC[B]) && NPCIsVeggie(NPC[A])) &&
        //    NPC[B].HoldingPlayer == 0 && NPC[A].Killed == 0 &&
        //    NPC[B].JustActivated == 0 && !NPC[B].Inert && NPC[B].Killed == 0))
        // {
        //     continue;
        // }

        // third exclusion condition
        // if(!(NPC[B].Type != NPCID_CANNONITEM && NPC[B].Type != NPCID_SWORDBEAM && NPC[B].Type != NPCID_TOOTHYPIPE && NPC[B].Type != NPCID_SPRING &&
        //    NPC[B].Type != NPCID_HEAVY_THROWN && NPC[B].Type != NPCID_KEY && NPC[B].Type != NPCID_COIN_SWITCH && NPC[B].Type != NPCID_GRN_BOOT &&
        //    NPC[B].Type != NPCID_VEHICLE && NPC[B].Type != NPCID_TOOTHY && NPC[B].Type != NPCID_CONVEYOR && NPC[B].Type != NPCID_METALBARREL &&
        //    NPC[B].Type != NPCID_RED_BOOT && NPC[B].Type != NPCID_BLU_BOOT && !NPC[B].Generator &&
        //    !((NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL) && NPC[B].Type == NPCID_FLIPPED_RAINBOW_SHELL) &&
        //    NPC[B].Type != NPCID_TIMER_S2 && NPC[B].Type != NPCID_FLY_BLOCK && NPC[B].Type != NPCID_FLY_CANNON && NPC[B].Type != NPCID_DOOR_MAKER &&
        //    NPC[B].Type != NPCID_MAGIC_DOOR && NPC[B].Type != NPCID_CHAR3_HEAVY && NPC[B].Type != NPCID_PLR_HEAVY && NPC[B].Type != NPCID_CHAR4_HEAVY))
        // {
        //     continue;
        // }

        // fourth exclusion condition
        // if(!(!(NPC[B].Type == NPCID_HPIPE_SHORT || NPC[B].Type == NPCID_YEL_PLATFORM || NPC[B].Type == NPCID_BLU_PLATFORM ||
        //    NPC[B].Type == NPCID_GRN_PLATFORM || NPC[B].Type == NPCID_RED_PLATFORM || NPC[B].Type == NPCID_HPIPE_LONG ||
        //    NPC[B].Type == NPCID_VPIPE_SHORT || NPC[B].Type == NPCID_VPIPE_LONG) && !(!NPC[A].Projectile &&
        //    NPC[B].Type == NPCID_SPIKY_BALL_S3) && !NPCIsYoshi(NPC[B]) && NPC[B].Type != NPCID_FALL_BLOCK_RED &&
        //    NPC[B].Type != NPCID_FALL_BLOCK_BROWN && !(NPC[B].Type == NPCID_SLIDE_BLOCK && NPC[B].Special == 0) &&
        //    NPC[B].Type != NPCID_CONVEYOR && !(NPC[B].Type >= NPCID_TANK_TREADS && NPC[B].Type <= NPCID_SLANT_WOOD_M) &&
        //    NPC[B].Type != NPCID_STATUE_S3 && NPC[B].Type != NPCID_STATUE_FIRE && !(NPC[B].Type == NPCID_BULLET &&
        //    NPC[B].CantHurt > 0) && NPC[B].Type != NPCID_ITEM_BURIED && !(NPC[A].CantHurtPlayer == NPC[B].CantHurtPlayer &&
        //    NPC[A].CantHurtPlayer > 0) && !(NPC[B].Type == NPCID_ITEM_POD && !NPC[B].Projectile) &&
        //    NPC[B].Type != NPCID_PET_FIRE && NPC[B].Type != NPCID_PLANT_FIREBALL && NPC[B].Type != NPCID_QUAD_BALL &&
        //    NPC[B].Type != NPCID_FIRE_BOSS_FIRE && NPC[B].Type != NPCID_RED_VINE_TOP_S3 && NPC[B].Type != NPCID_GRN_VINE_TOP_S3 && NPC[B].Type != NPCID_GRN_VINE_TOP_S4))
        // {
        //     continue;
        // }

        // don't allow vines to be collision targets
        if(NPC[B]->IsAVine)
            continue;

        // don't allow killed NPCs to collide, and don't allow held, just-activated, or friendly NPCs to be collision targets
        if(NPC[A].Killed != 0 || NPC[B].Killed != 0 || NPC[B].HoldingPlayer != 0 || NPC[B].JustActivated != 0 || NPC[B].Inert)
            continue;

        // don't allow generators to be collision targets
        if(NPC[B].Generator)
            continue;

        // don't allow friendly fire
        if(NPC[A].CantHurtPlayer == NPC[B].CantHurtPlayer && NPC[A].CantHurtPlayer > 0)
            continue;

        // these types can't be collision targets
        if((NPC[B].Type >= NPCID_PLATFORM_S3 && NPC[B].Type <= NPCID_PLATFORM_S1) || (NPC[B].Type >= NPCID_CARRY_BLOCK_A && NPC[B].Type <= NPCID_CARRY_BLOCK_D) ||
            NPC[B].Type == NPCID_LIFT_SAND || NPC[B].Type == NPCID_SICK_BOSS_BALL || NPC[B].Type == NPCID_PLR_ICEBALL || NPC[B].Type == NPCID_FIRE_CHAIN || NPC[B].Type == NPCID_CHAR3_HEAVY ||
            NPC[B].Type == NPCID_FALL_BLOCK_RED || NPC[B].Type == NPCID_FALL_BLOCK_BROWN ||
            NPC[B].Type == NPCID_SPIT_GUY_BALL || NPC[B].Type == NPCID_CANNONITEM || NPC[B].Type == NPCID_SWORDBEAM || NPC[B].Type == NPCID_TOOTHYPIPE || NPC[B].Type == NPCID_SPRING ||
            NPC[B].Type == NPCID_HEAVY_THROWN || NPC[B].Type == NPCID_KEY || NPC[B].Type == NPCID_COIN_SWITCH || NPC[B].Type == NPCID_GRN_BOOT ||
            NPC[B].Type == NPCID_VEHICLE || NPC[B].Type == NPCID_TOOTHY || NPC[B].Type == NPCID_CONVEYOR || NPC[B].Type == NPCID_METALBARREL ||
            NPC[B].Type == NPCID_RED_BOOT || NPC[B].Type == NPCID_BLU_BOOT ||
            NPC[B].Type == NPCID_TIMER_S2 || NPC[B].Type == NPCID_FLY_BLOCK || NPC[B].Type == NPCID_FLY_CANNON || NPC[B].Type == NPCID_DOOR_MAKER ||
            NPC[B].Type == NPCID_MAGIC_DOOR || NPC[B].Type == NPCID_CHAR3_HEAVY || NPC[B].Type == NPCID_PLR_HEAVY || NPC[B].Type == NPCID_CHAR4_HEAVY ||
            NPC[B].Type == NPCID_HPIPE_SHORT || NPC[B].Type == NPCID_YEL_PLATFORM || NPC[B].Type == NPCID_BLU_PLATFORM ||
            NPC[B].Type == NPCID_GRN_PLATFORM || NPC[B].Type == NPCID_RED_PLATFORM || NPC[B].Type == NPCID_HPIPE_LONG ||
            NPC[B].Type == NPCID_VPIPE_SHORT || NPC[B].Type == NPCID_VPIPE_LONG || NPC[B].Type == NPCID_CONVEYOR || (NPC[B].Type >= NPCID_TANK_TREADS && NPC[B].Type <= NPCID_SLANT_WOOD_M) ||
            NPC[B].Type == NPCID_STATUE_S3 || NPC[B].Type == NPCID_STATUE_FIRE || NPC[B].Type == NPCID_ITEM_BURIED || NPC[B].Type == NPCID_PET_FIRE || NPC[B].Type == NPCID_PLANT_FIREBALL || NPC[B].Type == NPCID_QUAD_BALL ||
            NPC[B].Type == NPCID_FIRE_BOSS_FIRE || NPC[B].Type == NPCID_RED_VINE_TOP_S3 || NPC[B].Type == NPCID_GRN_VINE_TOP_S3 || NPC[B].Type == NPCID_GRN_VINE_TOP_S4 || NPCIsYoshi(NPC[B].Type) || NPCIsToad(NPC[B].Type))
        {
            continue;
        }
        // miniboss can't be collision target if in guard state
        else if(NPC[B].Type == NPCID_MINIBOSS)
        {
            if(NPC[B].Special == 4)
                continue;
        }
        // bullet can't be collision target if just player-shot
        else if(NPC[B].Type == NPCID_BULLET)
        {
            if(NPC[B].CantHurt > 0)
                continue;
        }
        // item pod can't be collision target until thrown
        else if(NPC[B].Type == NPCID_ITEM_POD)
        {
            if(!NPC[B].Projectile)
                continue;
        }
        // slide block can't be collision target until activation
        else if(NPC[B].Type == NPCID_SLIDE_BLOCK)
        {
            if(NPC[B].Special == 0)
                continue;
        }
        // spiky balls can't be collision target unless hit by thrown item
        else if(NPC[B].Type == NPCID_SPIKY_BALL_S3)
        {
            if(!NPC[A].Projectile)
                continue;
        }
        // flipped rainbow shells can't be collision target of fireball / iceball
        else if(NPC[B].Type == NPCID_FLIPPED_RAINBOW_SHELL)
        {
            if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL)
                continue;
        }
        // veggies can't be collision target of other veggies
        else if(NPCIsVeggie(NPC[B].Type))
        {
            if(NPCIsVeggie(NPC[A].Type))
                continue;
        }

        // NPC-NPC collisions must be handled a function pointer defined by NPC A, but also shouldn't be hardcoded based on NPC B's type
        //   this logic will be quite difficult (but necessary) to convert

        // NOTE: There are a number of assignments to HitSpot here, but they are never read from (in the entire UpdateNPCs routine).
        // All reads are preceded by other writes.
        // I am commenting out these assignments.

        // if(NPC[A].Type == NPCID_MAGIC_BOSS_BALL || NPC[B].Type == NPCID_MAGIC_BOSS_BALL || NPC[A].Type == NPCID_FIRE_BOSS_FIRE || NPC[B].Type == NPCID_FIRE_BOSS_FIRE)
        //     HitSpot = 0;

        if(NPC[A].Type == NPCID_ITEM_BUBBLE)
        {
            NPCHit(A, 3, B);
            // HitSpot = 0;
        }
        else if(NPC[B].Type == NPCID_ITEM_BUBBLE)
            NPCHit(B, 3, A);


        if(NPC[A].Type == NPCID_SWORDBEAM)
        {
            if(!NPC[B]->IsABonus)
                NPCHit(B, 10, NPC[A].CantHurtPlayer);
            // HitSpot = 0;
        }

        // toad code
        if(NPCIsToad(NPC[A]))
        {
            if(!(NPC[B]->WontHurt && !NPC[B].Projectile) && !NPC[B]->IsABonus &&
               NPC[B].Type != NPCID_PLR_FIREBALL && /* NPC[B].Type != NPCID_PLR_ICEBALL && !(NPC[B].Type == NPCID_BULLET && NPC[B].CantHurt > 0) &&
               NPC[B].Type != NPCID_TOOTHY && NPC[B].Type != NPCID_PLR_HEAVY && NPC[B].Type != NPCID_CHAR4_HEAVY && */ NPC[B].Type != NPCID_FLIPPED_RAINBOW_SHELL)
            {
                NPCHit(A, 3, B);
                // HitSpot = 0;
            }
        }

        // turtle enters a shell
        if((NPC[A].Type == NPCID_GRN_HIT_TURTLE_S4 || NPC[A].Type == NPCID_RED_HIT_TURTLE_S4 || NPC[A].Type == NPCID_YEL_HIT_TURTLE_S4) && /* !NPC[A].Projectile && */
           (!NPC[B].Projectile && NPC[B].Type >= NPCID_GRN_SHELL_S4 && NPC[B].Type <= NPCID_YEL_SHELL_S4))
        {
            Location_t tempLocation = NPC[A].Location;
            Location_t tempLocation2 = NPC[B].Location;
            tempLocation.Width = 8;
            tempLocation.X += 12;
            tempLocation2.Width = 8;
            tempLocation2.X += 12;

            if(CheckCollision(tempLocation, tempLocation2))
            {
                NPC[B].Type = NPCID(NPC[B].Type - 4);
                if(NPC[B].Type == NPCID_YEL_TURTLE_S4)
                    NPC[B].Type = NPCID_RAINBOW_SHELL;
                NPC[A].Killed = 9;
                NPCQueues::Killed.push_back(A);
                NPC[B].Direction = NPC[A].Direction;
                NPC[B].Frame = EditorNPCFrame(NPC[B].Type, NPC[B].Direction);
            }
        }
        // NPC is a projectile
        else if(NPC[A].Projectile && /*!(NPC[B].Type == NPCID_SLIDE_BLOCK && NPC[B].Special == 0.0) &&*/ NPC[A].Type != NPCID_SWORDBEAM)
        {
            if(!(NPC[A].Projectile && NPC[B].Projectile && NPC[A].Type == NPCID_BULLET && NPC[B].Type == NPCID_BULLET && NPC[A].CantHurtPlayer != NPC[B].CantHurtPlayer))
            {
                if(!((NPC[A].Type == NPCID_PLR_FIREBALL && NPC[B]->IsABonus) || NPC[B].Type == NPCID_PLR_FIREBALL || NPC[B].Type == NPCID_VILLAIN_FIRE))
                {
                    // allow turtle (B) to kick shell (A) if it is facing the shell
                    if(NPC[A]->IsAShell &&
                            (NPC[B].Type == NPCID_EXT_TURTLE || NPC[B].Type == NPCID_BLU_HIT_TURTLE_S4) &&
                            (NPC[A].Direction != NPC[B].Direction || NPC[A].Special > 0) && !NPC[B].Projectile)
                    {
                        if(NPC[A].Direction == -1)
                        {
                            NPC[B].Frame = 3;
                            if(NPC[B].Type == NPCID_BLU_HIT_TURTLE_S4)
                                NPC[B].Frame = 5;
                            NPC[B].FrameCount = 0;
                        }
                        else
                        {
                            NPC[B].Frame = 0;
                            NPC[B].FrameCount = 0;
                        }

                        if(NPC[A].CantHurt < 25)
                            NPC[A].Special = 1;
                        if(NPC[A].Location.to_right_of(NPC[B].Location))
                        {
                            NPC[B].Location.X = NPC[A].Location.X - NPC[B].Location.Width - 1;
                            NPC[B].Direction = 1;
                        }
                        else
                        {
                            NPC[B].Location.X = NPC[A].Location.X + NPC[A].Location.Width + 1;
                            NPC[B].Direction = -1;
                        }

                        if(NPC[A].Location.SpeedY < NPC[B].Location.SpeedY)
                            NPC[A].Location.SpeedY = NPC[B].Location.SpeedY;
                        NPC[A].Frame = 0;
                        NPC[A].FrameCount = 0;
                        if(NPC[A].CantHurt < 25)
                            NPC[A].Special = 2;
                        NPC[B].Special = 0;
                        Location_t tempLocation = NPC[B].Location;
                        tempLocation.Y += 1;
                        tempLocation.Height -= 2;

                        for(int bCheck2 = 1; bCheck2 <= 2; bCheck2++)
                        {
                            // if(bCheck2 == 1)
                            // {
                            //     // fBlock2 = FirstBlock[(NPC[B].Location.X / 32) - 1];
                            //     // lBlock2 = LastBlock[((NPC[B].Location.X + NPC[B].Location.Width) / 32.0) + 1];
                            //     blockTileGet(NPC[B].Location, fBlock2, lBlock2);
                            // }
                            // else
                            // {
                                   // ds-sloth comment: this was a "bug",
                                   // but it never affected the result so wasn't fixed
                                   // should be numBlock - numTempBlock + 1,
                                   // this will double-count numBlock - numTempBlock.
                                   // not a problem because it is the last of the non-temp blocks
                                   // and the first of the temp blocks in the original check,
                                   // so order is the same if we exclusively count it is a non-temp block,
                                   // which is what the new code does
                            //     fBlock2 = numBlock - numTempBlock;
                            //     lBlock2 = numBlock;
                            // }

                            auto collBlockSentinel2 = (bCheck2 == 1)
                                ? treeFLBlockQuery(NPC[B].Location, SORTMODE_COMPAT)
                                : treeTempBlockQuery(NPC[B].Location, SORTMODE_LOC);

                            for(BlockRef_t block2 : collBlockSentinel2)
                            {
                                int C = block2;

                                if(!BlockIsSizable[Block[C].Type] && !BlockOnlyHitspot1[Block[C].Type] && !Block[C].Hidden && BlockSlope[Block[C].Type] == 0)
                                {
                                    if(CheckCollision(tempLocation, Block[C].Location))
                                    {
                                        if(int(NPC[A].Direction) == -1)
                                        {
                                            NPC[B].Location.X = Block[C].Location.X + Block[C].Location.Width + 0.1_n;
                                            NPC[A].Location.X = NPC[B].Location.X + NPC[B].Location.Width + 0.1_n;
                                        }
                                        else
                                        {
                                            NPC[B].Location.X = Block[C].Location.X - NPC[B].Location.Width - 0.1_n;
                                            NPC[A].Location.X = NPC[B].Location.X - NPC[A].Location.Width - 0.1_n;
                                        }
                                    }
                                }
                            }
                        }

                        treeNPCUpdate(B);
                        if(NPC[B].tempBlock > 0)
                            treeNPCSplitTempBlock(B);
                    }
                    else if(NPC[A].Type == NPCID_TANK_TREADS)
                        NPCHit(B, 8, A);
                    else
                    {
                        if(!NPC[B]->IsABonus)
                        {
                            if(NPC[A].Type == NPCID_CANNONENEMY && NPC[B].Type == NPCID_BULLET)
                                NPC[B].Projectile = true;
                            else
                            {
                                bool tempBool = false; // This whole cluster stops friendly projectiles form killing riddin shells

                                if(NPC[A]->IsAShell)
                                {
                                    for(auto C = 1; C <= numPlayers; C++)
                                    {
                                        if(Player[C].StandingOnNPC == A && NPC[B].CantHurtPlayer == C)
                                        {
                                            tempBool = true;
                                            break;
                                        }
                                    }
                                }

                                if(NPC[B]->IsAShell)
                                {
                                    for(auto C = 1; C <= numPlayers; C++)
                                    {
                                        if(Player[C].StandingOnNPC == B && NPC[A].CantHurtPlayer == C)
                                        {
                                            tempBool = true;
                                            break;
                                        }
                                    }
                                }

                                if(!(NPC[A].Type == NPCID_BULLET && NPC[A].Projectile))
                                {
                                    if(NPC[B]->IsAShell && NPC[B].Projectile)
                                    {
                                        if(!tempBool)
                                            NPCHit(A, 3, B);
                                    }
                                    else
                                    {
                                        if(!tempBool)
                                            NPCHit(A, 4, B);
                                    }
                                }

                                if(!tempBool) // end cluster
                                    NPCHit(B, 3, A);

                                if(NPC[A].Type == NPCID_BULLET)
                                {
                                    if(NPC[B].Type == NPCID_MINIBOSS)
                                    {
                                        NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                        NPCHit(A, 4, B);
                                    }
                                    else if(NPC[B].Type == NPCID_CANNONENEMY)
                                    {
                                        NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                                        PlaySoundSpatial(SFX_BlockHit, NPC[A].Location);
                                        NPCHit(A, 4, A);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        else if(!(NPC[B].Type == NPCID_SPIT_BOSS_BALL && !NPC[B].Projectile))
        {
            int HitSpot = FindCollision(NPC[A].Location, NPC[B].Location);

            if(NPCIsToad(NPC[A]) && NPC[A].Killed > 0)
                HitSpot = 0;

            if((NPCIsAParaTroopa(NPC[A]) || NPC[A].Wings) && (NPCIsAParaTroopa(NPC[B]) || NPC[B].Wings))
            {
                // don't do these special movement routines for winged NPCs if one of the NPCs is a block
                if(!NPC[A].Wings || !(NPC[A]->IsABlock || (HitSpot == 3 && (NPC[A]->IsAHit1Block || NPC[A]->CanWalkOn)) || NPC[B]->IsABlock || (HitSpot == 1 && (NPC[B]->IsAHit1Block || NPC[B]->CanWalkOn))))
                {
                    if(NPC[A].Location.to_right_of(NPC[B].Location))
                        NPC[A].Location.SpeedX += 0.05_n;
                    else
                        NPC[A].Location.SpeedX -= 0.05_n;

                    if(NPC[A].Location.Y + NPC[A].Location.Height / 2 > NPC[B].Location.Y + NPC[B].Location.Height / 2)
                        NPC[A].Location.SpeedY += 0.05_n;
                    else
                        NPC[A].Location.SpeedY -= 0.05_n;
                }

                HitSpot = 0;
            }

            if(!NPC[B].Projectile && !NPC[A]->NoClipping && !NPC[B]->NoClipping)
            {
                // NPC A can't be a shell in this condition, because A is not a projectile, and shells only query collisions as projectiles
                if(((NPC[A].Type == NPCID_EXT_TURTLE || NPC[A].Type == NPCID_BLU_HIT_TURTLE_S4) && NPC[B]->IsAShell) /* || ((NPC[B].Type == NPCID_EXT_TURTLE || NPC[B].Type == NPCID_BLU_HIT_TURTLE_S4) && NPC[A]->IsAShell)*/) // Nekkid koopa kicking a shell
                {
                    // if(NPC[A].Type == NPCID_EXT_TURTLE || NPC[A].Type == NPCID_BLU_HIT_TURTLE_S4)
                    if(NPC[A].Location.SpeedY == Physics.NPCGravity || NPC[A].Slope > 0)
                    {
                        // If .Direction = 1 And .Location.X + .Location.Width < NPC(B).Location.X + 3 Or (.Direction = -1 And .Location.X > NPC(B).Location.X + NPC(B).Location.Width - 3) Then
                        if((NPC[A].Direction == 1  && NPC[A].Location.X + NPC[A].Location.Width < NPC[B].Location.X + 4) ||
                           (NPC[A].Direction == -1 && NPC[A].Location.X > NPC[B].Location.X + NPC[B].Location.Width - 4))
                        {
                            if(NPC[B].Location.SpeedX == 0 && NPC[B].Effect == NPCEFF_NORMAL)
                            {
                                NPC[A].Special = 10;
                                Player[numPlayers + 1].Direction = NPC[A].Direction;
                                NPC[A].Location.X += -NPC[A].Direction;
                                NPCHit(B, 1, numPlayers + 1);
                            }
                        }
                    }
                }
                else if(NPC[A].Effect == NPCEFF_MAZE && NPC[B].Effect == NPCEFF_MAZE && HitSpot != 5)
                {
                    if(!NPC[B].TurnAround)
                        NPC[A].TurnAround = true;

                    if(NPC[A].Effect3 != NPC[B].Effect3)
                        NPC[B].TurnAround = true;
                }
                else if((HitSpot == 2 || HitSpot == 4) && NPC[A].Type != NPCID_SAW && NPC[B].Type != NPCID_SAW)
                {
                    // set in SMBX 1.3 but reset to false before it got read
                    // NPC[A].onWall = true;

                    if(NPC[A].Direction == NPC[B].Direction)
                    {
                        if(NPC[A].Location.SpeedX * NPC[A].Direction > NPC[B].Location.SpeedX * NPC[B].Direction)
                        {
                            if(NPC[A].Type != NPCID_BULLET && NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PLR_ICEBALL)
                                NPC[A].TurnAround = true;
                        }
                        else if(NPC[A].Location.SpeedX * NPC[A].Direction < NPC[B].Location.SpeedX * NPC[B].Direction)
                            NPC[B].TurnAround = true;
                        else
                        {
                            NPC[A].TurnAround = true;
                            NPC[B].TurnAround = true;
                        }
                    }
                    else
                    {
                        if(NPC[A].Type != NPCID_BULLET && NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PLR_ICEBALL)
                            NPC[A].TurnAround = true;
                        NPC[B].TurnAround = true;
                    }
                }
            }
        }
    }
}

void NPCCollideHeld(int A)
{
    // these types can't collide while held
    if(NPC[A].Type == NPCID_FLIPPED_RAINBOW_SHELL || NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_SPRING || NPC[A].Type == NPCID_COIN_SWITCH ||
         NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_TNT || NPC[A].Type == NPCID_BLU_BOOT || NPC[A].Type == NPCID_GRN_BOOT || NPC[A].Type == NPCID_RED_BOOT ||
         NPC[A].Type == NPCID_TOOTHYPIPE || NPC[A].Type == NPCID_BOMB || (NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D) ||
         NPC[A].Type == NPCID_KEY || NPC[A].Type == NPCID_TIMER_S2 || NPC[A].Type == NPCID_FLY_BLOCK || NPC[A].Type == NPCID_FLY_CANNON || NPC[A].Type == NPCID_CHAR4_HEAVY)
    {
        return;
    }

    for(int B : treeNPCQuery(NPC[A].Location, SORTMODE_ID))
    {
        // original exclusion condition
        // if(!(B != A && NPC[B].Active &&
        //    (NPC[B].HoldingPlayer == 0 || (BattleMode && NPC[B].HoldingPlayer != NPC[A].HoldingPlayer)) &&
        //    !NPC[B]->IsABonus &&
        //    (NPC[B].Type != NPCID_PLR_FIREBALL  || (BattleMode && NPC[B].CantHurtPlayer != NPC[A].HoldingPlayer)) &&
        //    (NPC[B].Type != NPCID_PLR_ICEBALL || (BattleMode && NPC[B].CantHurtPlayer != NPC[A].HoldingPlayer)) &&
        //     NPC[B].Type != NPCID_CANNONENEMY && NPC[B].Type != NPCID_CANNONITEM &&  NPC[B].Type != NPCID_SPRING && NPC[B].Type != NPCID_KEY &&
        //     NPC[B].Type != NPCID_COIN_SWITCH && NPC[B].Type != NPCID_TIME_SWITCH && NPC[B].Type != NPCID_TNT && NPC[B].Type != NPCID_RED_BOOT &&
        //     NPC[B].Type != NPCID_GRN_BOOT && !(NPC[B].Type == NPCID_BLU_BOOT && NPC[A].Type == NPCID_BLU_BOOT) &&
        //     NPC[B].Type != NPCID_STONE_S3 && NPC[B].Type != NPCID_STONE_S4 && NPC[B].Type != NPCID_GHOST_S3 &&
        //     NPC[B].Type != NPCID_SPIT_BOSS && !(NPC[B].Type == NPCID_SLIDE_BLOCK && NPC[B].Special == 0.0) &&
        //     NPC[B].Type != NPCID_ITEM_BURIED && NPC[B].Type != NPCID_LIFT_SAND && NPC[B].Type != NPCID_FLIPPED_RAINBOW_SHELL &&
        //    !(NPC[B].Type == NPCID_HEAVY_THROWN && NPC[B].Projectile) && NPC[B].Type != NPCID_EARTHQUAKE_BLOCK && NPC[B].Type != NPCID_ICE_CUBE && NPC[B].Type != NPCID_CHAR3_HEAVY))
        // {
        //     continue;
        // }

        if(B == A || !NPC[B].Active)
            continue;

        // don't kill dead or friendly NPC
        if(NPC[B].Killed != 0 || NPC[B].Inert)
            continue;

        // don't kill powerups
        if(NPC[B]->IsABonus)
            continue;

        // don't kill other players' NPCs except in Battle Mode
        if(NPC[B].HoldingPlayer != 0 && (!BattleMode || NPC[B].HoldingPlayer == NPC[A].HoldingPlayer))
            continue;

        // no friendly fire
        if(NPC[A].CantHurtPlayer == NPC[B].CantHurtPlayer)
            continue;

        // don't kill NPC player is standing on
        if(Player[NPC[A].HoldingPlayer].StandingOnNPC == B)
            continue;

        // these types can't be collision targets
        if(NPC[B].Type == NPCID_CANNONENEMY || NPC[B].Type == NPCID_CANNONITEM || NPC[B].Type == NPCID_SPRING || NPC[B].Type == NPCID_KEY ||
            NPC[B].Type == NPCID_COIN_SWITCH || NPC[B].Type == NPCID_TIME_SWITCH || NPC[B].Type == NPCID_TNT || NPC[B].Type == NPCID_RED_BOOT ||
            NPC[B].Type == NPCID_GRN_BOOT || NPC[B].Type == NPCID_STONE_S3 || NPC[B].Type == NPCID_STONE_S4 || NPC[B].Type == NPCID_GHOST_S3 ||
            NPC[B].Type == NPCID_SPIT_BOSS || NPC[B].Type == NPCID_ITEM_BURIED || NPC[B].Type == NPCID_LIFT_SAND || NPC[B].Type == NPCID_FLIPPED_RAINBOW_SHELL ||
            NPC[B].Type == NPCID_EARTHQUAKE_BLOCK || NPC[B].Type == NPCID_ICE_CUBE || NPC[B].Type == NPCID_CHAR3_HEAVY)
        {
            continue;
        }
        // slide block can't be collision target until activation
        else if(NPC[B].Type == NPCID_SLIDE_BLOCK)
        {
            if(NPC[B].Special == 0)
                continue;
        }
        else if(NPC[B].Type == NPCID_HEAVY_THROWN)
        {
            if(NPC[B].Projectile)
                continue;
        }
        // probably redundant check (see above friendly fire note), but need to confirm when CantHurtPlayer and HoldingPlayer may be out of sync
        else if(NPC[B].Type == NPCID_PLR_FIREBALL || NPC[B].Type == NPCID_PLR_ICEBALL)
        {
            if(!BattleMode || NPC[B].CantHurtPlayer == NPC[A].HoldingPlayer)
                continue;
        }

#if 0
        // impossible
        if(NPC[B].Type == NPCID_BLU_BOOT && NPC[A].Type == NPCID_BLU_BOOT)
            continue;
#endif

        if(!CheckCollision(NPC[A].Location, NPC[B].Location))
            continue;

        NPCHit(B, 3, A);

        if(NPC[B].Killed > 0)
        {
            NPC[B].Location.SpeedX = Physics.NPCShellSpeed / 2 * -Player[NPC[A].HoldingPlayer].Direction;
            NPCHit(A, 5, B);
        }

        if(NPC[A].Killed > 0)
            NPC[A].Location.SpeedX = Physics.NPCShellSpeed / 2 * Player[NPC[A].HoldingPlayer].Direction;

        if(!g_config.fix_held_item_cancel || NPC[A].Killed || NPC[B].Killed)
            break;
    }
}


================================================
FILE: src/npc/npc_update/npc_effects.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#include "globals.h"
#include "npc.h"
#include "npc_traits.h"
#include "npc/npc_queues.h"
#include "config.h"
#include "collision.h"
#include "layers.h"
#include "editor.h"
#include "player.h"
#include "npc_update_priv.h"
#include "phys_env.h"

#include "main/trees.h"

static inline void NPCEffectLogic_EmergeUp(int A)
{
    if(NPC[A].Direction == 0) // Move toward the closest player
    {
        int target_plr = NPCTargetPlayer(NPC[A]);

        if(target_plr)
            NPC[A].Direction = -Player[target_plr].Direction;
    }

    NPC[A].Frame = EditorNPCFrame(NPC[A].Type, NPC[A].Direction, A);
    NPC[A].Effect2 += 1;
    NPC[A].Location.Y -= 1; // .01
    NPC[A].Location.Height += 1;

    if(NPC[A]->HeightGFX > 0)
    {
        if(NPC[A].Effect2 >= NPC[A]->HeightGFX)
        {
            NPC[A].Effect = NPCEFF_NORMAL;
            NPC[A].Effect2 = 0;
            NPC[A].Location.set_height_floor(NPC[A]->THeight);
        }
    }
    else
    {
        if(NPC[A].Effect2 >= NPC[A]->THeight)
        {
            NPC[A].Effect = NPCEFF_NORMAL;
            NPC[A].Effect2 = 0;
            NPC[A].Location.Height = NPC[A]->THeight;
        }
    }
}

static inline void NPCEffectLogic_EmergeDown(int A)
{
    if(NPC[A].Type == NPCID_LEAF_POWER)
        NPC[A].Direction = 1;
    else if(NPC[A].Direction == 0) // Move toward the closest player
    {
        int target_plr = NPCTargetPlayer(NPC[A]);

        if(target_plr)
            NPC[A].Direction = -Player[target_plr].Direction;
    }

    NPC[A].Effect2 += 1;
    NPC[A].Location.Y += 1;

    if(NPC[A].Effect2 == 32)
    {
        NPC[A].Effect = NPCEFF_NORMAL;
        NPC[A].Effect2 = 0;

        NPC[A].Location.Height = (g_config.fix_npc_emerge_size) ? NPC[A]->THeight : 32;

        for(int bCheck = 1; bCheck <= 2; bCheck++)
        {
            // if(bCheck == 1)
            // {
            //     // fBlock = FirstBlock[(NPC[A].Location.X / 32) - 1];
            //     // lBlock = LastBlock[((NPC[A].Location.X + NPC[A].Location.Width) / 32.0) + 1];
            //     blockTileGet(NPC[A].Location, fBlock, lBlock);
            // }
            // else
            // {
                   // buggy, mentioned above, should be numBlock - numTempBlock + 1 -- ds-sloth
                   // it's not a problem here because the NPC is moved out of the way of the block
                   // during the first loop, so can't collide during the second loop.
            //     fBlock = numBlock - numTempBlock;
            //     lBlock = numBlock;
            // }

            auto collBlockSentinel = (bCheck == 1)
                ? treeFLBlockQuery(NPC[A].Location, SORTMODE_COMPAT)
                : treeTempBlockQuery(NPC[A].Location, SORTMODE_LOC);

            for(BlockRef_t block : collBlockSentinel)
            {
                int B = block;

                if(!Block[B].Invis && !(BlockIsSizable[Block[B].Type] && NPC[A].Location.Y > Block[B].Location.Y) && !Block[B].Hidden)
                {
                    if(CheckCollision(NPC[A].Location, Block[B].Location))
                    {
                        NPC[A].Location.Y = Block[B].Location.Y - NPC[A].Location.Height - 0.1_n;
                        break;
                    }
                }
            }
        }
    }
}

static inline void NPCEffectLogic_Encased(int A)
{
    bool still_encased = false;

    // Note: since SMBX64, this logic doesn't check for Hidden or Active, so an encased NPC will not escape encased mode properly in Battle Mode (where killed NPCs just become inactive)
    // Note 2: NPCID_BOSS_FRAGILE does not use the encased logic, it has its own specific logic to check for nearby NPCID_BOSS_CASE
    for(int B : treeNPCQuery(NPC[A].Location, SORTMODE_NONE))
    {
        if(NPC[B].Type == NPCID_BOSS_CASE)
        {
            if(CheckCollision(NPC[A].Location, NPC[B].Location))
            {
                still_encased = true;
                break;
            }
        }
    }

    if(!still_encased)
        NPC[A].Effect = NPCEFF_NORMAL;
}

static inline void NPCEffectLogic_DropItem(int A)
{
    // modern item drop
    if(NPC[A].Effect3 != 0)
    {
        const Player_t& p = Player[NPC[A].Effect3];
        const Location_t& pLoc = p.Location;
        Location_t& nLoc = NPC[A].Location;

        // Y logic
        vScreen_t& vscreen = vScreenByPlayer(NPC[A].Effect3);

        // put above player
        num_t target_X = pLoc.X + (pLoc.Width - nLoc.Width) / 2;
        num_t target_Y = pLoc.Y + pLoc.Height - 192;

        // anticipate player movement
        if(PlayerNormal(p))
        {
            target_X += pLoc.SpeedX;
            target_Y += pLoc.SpeedY;
        }

        // never allow item to go fully offscreen
        if(target_Y < -vscreen.Y - 8)
            target_Y = -vscreen.Y - 8;

        // perform movement
        num_t delta_X = target_X - nLoc.X;
        num_t delta_Y = target_Y - nLoc.Y;

        num_t move_X = delta_X / 8;
        num_t move_Y = delta_Y / 8;

        num_t dist = num_t::dist(move_X, move_Y);

        // this magic number is 8 * sqrt(2)
        if(dist > 0 && dist < 11.31371_n)
        {
            move_X = (move_X * 11.31371_r).divided_by(dist);
            move_Y = (move_Y * 11.31371_r).divided_by(dist);
        }

        if(num_t::abs(delta_Y) < num_t::abs(move_Y) || NPC[A].Special5 <= 66)
            nLoc.Y = target_Y;
        else
            nLoc.Y += move_Y;

        if(num_t::abs(delta_X) < num_t::abs(move_X) || NPC[A].Special5 <= 66)
            nLoc.X = target_X;
        else
            nLoc.X += move_X;

        // timer logic
        if(NPC[A].Special5 <= 66)
            NPC[A].Special5 -= 1;
        else if(nLoc.X == target_X && nLoc.Y == target_Y)
            NPC[A].Special5 = 66;

        // enter SMBX mode on timer expiration
        if(NPC[A].Special5 <= 0)
        {
            NPC[A].Effect3 = 0;
            NPC[A].Special5 = 0;
        }
    }
    else
    {
        NPC[A].Location.Y += 2.2_n;

        NPC[A].Effect2 += 1;
        if(NPC[A].Effect2 == 5)
            NPC[A].Effect2 = 1;
    }
}

static inline void NPCEffectLogic_Warp(int A)
{
    // NOTE: this code previously used Effect2 to store destination position, and now it uses SpecialX/Y
    if(NPC[A].Effect3 == 1)
    {
        NPC[A].Location.Y -= 1;
        if(NPC[A].Type == NPCID_PLATFORM_S1)
            NPC[A].Location.Y -= 1;

        if(NPC[A].Location.Y + NPC[A].Location.Height <= NPC[A].SpecialY)
        {
            NPC[A].Effect = NPCEFF_NORMAL;
            NPC[A].SpecialY = 0;
            NPC[A].Effect3 = 0;
        }
    }
    else if(NPC[A].Effect3 == 3)
    {
        NPC[A].Location.Y += 1;

        if(NPC[A].Type == NPCID_PLATFORM_S1)
            NPC[A].Location.Y += 1;

        if(NPC[A].Location.Y >= NPC[A].SpecialY)
        {
            NPC[A].Effect = NPCEFF_NORMAL;
            NPC[A].SpecialY = 0;
            NPC[A].Effect3 = 0;
        }
    }
    else if(NPC[A].Effect3 == 2)
    {
        if(NPC[A].Type == NPCID_POWER_S3 || NPC[A].Type == NPCID_LIFE_S3 || NPC[A].Type == NPCID_POISON || NPC[A].Type == NPCID_POWER_S1 || NPC[A].Type == NPCID_POWER_S4 || NPC[A].Type == NPCID_LIFE_S1 || NPC[A].Type == NPCID_LIFE_S4 || NPC[A].Type == NPCID_BRUTE_SQUISHED || NPC[A].Type == NPCID_BIG_GUY)
            NPC[A].Location.X -= Physics.NPCMushroomSpeed;
        else if(NPC[A]->CanWalkOn)
            NPC[A].Location.X -= 1;
        else
            NPC[A].Location.X -= Physics.NPCWalkingSpeed;

        if(NPC[A].Location.X + NPC[A].Location.Width <= NPC[A].SpecialX)
        {
            NPC[A].Effect = NPCEFF_NORMAL;
            NPC[A].SpecialX = 0;
            NPC[A].Effect3 = 0;
        }
    }
    else if(NPC[A].Effect3 == 4)
    {
        if(NPC[A].Type == NPCID_POWER_S3 || NPC[A].Type == NPCID_LIFE_S3 || NPC[A].Type == NPCID_POISON || NPC[A].Type == NPCID_POWER_S1 || NPC[A].Type == NPCID_POWER_S4 || NPC[A].Type == NPCID_LIFE_S1 || NPC[A].Type == NPCID_LIFE_S4 || NPC[A].Type == NPCID_BRUTE_SQUISHED || NPC[A].Type == NPCID_BIG_GUY)
            NPC[A].Location.X += Physics.NPCMushroomSpeed;
        else if(NPC[A]->CanWalkOn)
            NPC[A].Location.X += 1;
        else
            NPC[A].Location.X += Physics.NPCWalkingSpeed;

        if(NPC[A].Location.X >= NPC[A].SpecialX)
        {
            NPC[A].Effect = NPCEFF_NORMAL;
            NPC[A].SpecialX = 0;
            NPC[A].Effect3 = 0;
        }
    }

    NPCFrames(A);

    if(NPC[A].Effect == NPCEFF_NORMAL && NPC[A].Type != NPCID_ITEM_BURIED)
    {
        NPC[A].Layer = LAYER_SPAWNED_NPCS;
        syncLayers_NPC(A);
    }
}

static inline void NPCEffectLogic_PetTongue(int A)
{
    NPC[A].TimeLeft = 100;
    NPC[A].Effect3 -= 1;
    if(NPC[A].Effect3 <= 0)
    {
        NPC[A].Effect = NPCEFF_NORMAL;
        NPC[A].Effect2 = 0;
        NPC[A].Effect3 = 0;
    }
}

static inline void NPCEffectLogic_PetInside(int A)
{
    NPC[A].TimeLeft = 100;
    if(Player[NPC[A].Effect2].YoshiNPC != A)
    {
        NPC[A].Effect = NPCEFF_NORMAL;
        NPC[A].Effect2 = 0;
        NPC[A].Effect3 = 0;
    }
}

static inline void NPCEffectLogic_Waiting(int A)
{
    NPC[A].Effect2 -= 1;
    if(NPC[A].Effect2 <= 0)
    {
        NPC[A].Effect = NPCEFF_NORMAL;
        NPC[A].Effect2 = 0;
        NPC[A].Effect3 = 0;
    }
}

static inline void NPCEffectLogic_Maze(int A)
{
    NPC_t& npc = NPC[A];

    NPCFrames(A);
    NPCSectionWrap(npc);
    NPCCollide(A);

    if(npc.TurnAround)
    {
        npc.Effect3 = (npc.Effect3 & 3) ^ MAZE_DIR_FLIP_BIT;
        npc.TurnAround = false;
    }

    // make balls go very slightly faster, and give them speed when they leave so they don't bounce forever
    bool is_ball = (npc.Type == NPCID_PLR_FIREBALL || npc.Type == NPCID_PLR_ICEBALL);
    bool is_bullet = (npc.Type == NPCID_BULLET && npc.CantHurt);
    bool is_player_thrown = is_ball || (npc.Type == NPCID_CHAR3_HEAVY || npc.Type == NPCID_BOMB);

    PhysEnv_Maze(npc.Location, npc.Effect2, npc.Effect3, A, 0, npc.Quicksand ? 1 : (npc.Wet ? 2 : 4) + is_player_thrown + 4 * is_bullet, {false, false, false, false});

    if(npc.Effect3 == MAZE_DIR_LEFT)
        npc.Direction = -1;
    else if(npc.Effect3 == MAZE_DIR_RIGHT)
        npc.Direction = 1;

    if(!npc.Effect2)
    {
        npc.Effect = NPCEFF_NORMAL;

        bool is_vert = (npc.Effect3 % 4 == MAZE_DIR_UP || npc.Effect3 % 4 == MAZE_DIR_DOWN);
        npc.Effect3 = 0;

        if(is_bullet)
            npc.Location.SpeedX = (npc.CantHurt ? 8 : 4) * npc.Direction;
        else if(is_vert)
        {
            if(!npc.Projectile && !npc.Wet)
            {
                npc.Projectile = true;
                npc.Effect3 = 128;
            }

            if(is_ball && npc.Special != 5)
            {
                int is_left = iRand(2);
                npc.Location.SpeedX = 1 - 4 * is_left + 2 * dRand();
            }
        }
    }
}


void NPCEffects(int A)
{
    if(NPC[A].Effect == NPCEFF_EMERGE_UP) // Bonus coming out of a block effect
        NPCEffectLogic_EmergeUp(A);
    else if(NPC[A].Effect == NPCEFF_ENCASED)
        NPCEffectLogic_Encased(A);
    else if(NPC[A].Effect == NPCEFF_DROP_ITEM) // Bonus item is falling from the players container effect
        NPCEffectLogic_DropItem(A);
    else if(NPC[A].Effect == NPCEFF_EMERGE_DOWN) // Bonus falling out of a block
        NPCEffectLogic_EmergeDown(A);
    else if(NPC[A].Effect == NPCEFF_WARP) // Warp Generator
        NPCEffectLogic_Warp(A);
    else if(NPC[A].Effect == NPCEFF_PET_TONGUE) // Grabbed by Yoshi
        NPCEffectLogic_PetTongue(A);
    else if(NPC[A].Effect == NPCEFF_PET_INSIDE) // Held by Yoshi
        NPCEffectLogic_PetInside(A);
    else if(NPC[A].Effect == NPCEFF_WAITING) // Holding Pattern
        NPCEffectLogic_Waiting(A);
    else if(NPC[A].Effect == NPCEFF_MAZE) // In a maze zone
        NPCEffectLogic_Maze(A);
}


================================================
FILE: src/npc/npc_update/npc_generator.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "npc.h"
#include "effect.h"
#include "sound.h"
#include "collision.h"
#include "layers.h"
#include "editor.h"
#include "main/trees.h"
#include "npc_id.h"
#include "eff_id.h"
#include "npc_traits.h"

#include "npc/npc_queues.h"
#include "npc/npc_update/npc_update_priv.h"

// returns true if an NPC should be generated
bool NPCGeneratorLogic(int A)
{
    bool should_make_new = false;

    NPC[A].TimeLeft = 0;

    // Old timer logic
    // this did not achieve anything other than keeping the value from growing large, but was likely the reason Redigit thought floats were necessary
#if 0
    NPC[A].GeneratorTime() += 1;

    if(NPC[A].GeneratorTime() >= NPC[A].GeneratorTimeMax() * 6.5f)
        NPC[A].GeneratorTime() = NPC[A].GeneratorTimeMax() * 6.5f;
#endif

    // increase activation timer if not ready yet
    // (Note: the + 1 tests whether the NPC would have exceeded the limit *after* adding 1, matching the original logic. It's immaterial whether the final += 1 ever occurs.)
    if((NPC[A].GeneratorTime() + 1) * 10 < NPC[A].GeneratorTimeMax() * 65)
        NPC[A].GeneratorTime() += 1;
    // if ready and onscreen, try to activate!
    else if(NPC[A].GeneratorActive)
    {
        bool blocked = false;

        if(numNPCs == maxNPCs - 100)
            blocked = true;

        // check if blocked by players
        if(NPC[A].Type != NPCID_ITEM_BURIED && !blocked)
        {
            for(int B = 1; B <= numPlayers; B++)
            {
                if(!Player[B].Dead && Player[B].TimeToLive == 0)
                {
                    if(CheckCollision(NPC[A].Location, Player[B].Location))
                    {
                        blocked = true;
                        break;
                    }
                }
            }
        }

        // check if blocked by blocks
        if(NPC[A].Type != NPCID_ITEM_BURIED && !blocked)
        {
            for(int B : treeBlockQuery(NPC[A].Location, SORTMODE_NONE))
            {
                if(!Block[B].Hidden && !BlockIsSizable[Block[B].Type])
                {
                    if(CheckCollision(NPC[A].Location,
                                      newLoc(Block[B].Location.X + 0.1_n, Block[B].Location.Y + 0.1_n,
                                             Block[B].Location.Width - 0.2_n, Block[B].Location.Height - 0.2_n)))
                    {
                        blocked = true;
                        break;
                    }
                }
            }
        }

        // check if blocked by NPCs
        if(!blocked)
        {
            for(int B : treeNPCQuery(NPC[A].Location, SORTMODE_NONE))
            {
                if(B != A && NPC[B].Active && NPC[B].Type != NPCID_CONVEYOR)
                {
                    if(CheckCollision(NPC[A].Location, NPC[B].Location))
                    {
                        blocked = true;
                        break;
                    }
                }
            }
        }

        // if blocked, reset GeneratorTime (measured in ticks) to GeneratorTimeMax (measured in deciseconds)
        // the effect is that we will wait for (6.5 - 1) / 6.5 = 11/13 of the normal generator time before checking again
        if(blocked)
            NPC[A].GeneratorTime() = NPC[A].GeneratorTimeMax();
        // generate a new NPC!
        else
        {
            NPC[A].GeneratorTime() = 0;
            should_make_new = true;
        }
    }

    NPC[A].GeneratorActive = false;

    return should_make_new;
}

// does NOT call the activation event (because that requires safe ProcEvent handling)
void NPCGeneratorMakeNew(int A)
{
    numNPCs++;
    NPC[numNPCs] = NPC[A];

    if(NPC[A].GeneratorEffect() == 1) // Warp NPC
    {
        // NOTE: this code previously used Effect2 to store the destination position, and now it uses SpecialX/Y
        NPC[numNPCs].Layer = NPC[A].Layer;
        NPC[numNPCs].Effect3 = NPC[A].GeneratorDirection();
        NPC[numNPCs].Effect2 = 0;
        NPC[numNPCs].Effect = NPCEFF_WARP;
        NPC[numNPCs].Location.SpeedX = 0;
        NPC[numNPCs].TimeLeft = 100;
        if(NPC[A].GeneratorDirection() == 1)
        {
            if(NPC[A]->HeightGFX > NPC[A].Location.Height)
            {
                NPC[numNPCs].Location.Y = NPC[A].Location.Y + NPC[A]->HeightGFX;
                NPC[numNPCs].SpecialY = NPC[numNPCs].Location.Y - (NPC[A]->HeightGFX - NPC[A].Location.Height);
            }
            else
            {
                NPC[numNPCs].Location.Y = NPC[A].Location.Y + NPC[A].Location.Height;
                NPC[numNPCs].SpecialY = NPC[numNPCs].Location.Y;
            }
        }
        else if(NPC[A].GeneratorDirection() == 3)
        {
            if(NPC[A]->HeightGFX > NPC[A].Location.Height)
            {
                NPC[numNPCs].Location.Y = NPC[A].Location.Y - NPC[A].Location.Height;
                NPC[numNPCs].SpecialY = NPC[numNPCs].Location.Y + NPC[A].Location.Height + (NPC[A]->HeightGFX - NPC[A].Location.Height);
            }
            else
            {
                NPC[numNPCs].Location.Y = NPC[A].Location.Y - NPC[A].Location.Height;
                NPC[numNPCs].SpecialY = NPC[numNPCs].Location.Y + NPC[A].Location.Height;
            }
        }
        else if(NPC[A].GeneratorDirection() == 2)
        {
            NPC[numNPCs].Location.Y -= 4;
            NPC[numNPCs].Location.X = NPC[A].Location.X + NPC[A].Location.Width;
            NPC[numNPCs].SpecialX = NPC[numNPCs].Location.X;
        }
        else if(NPC[A].GeneratorDirection() == 4)
        {
            NPC[numNPCs].Location.Y -= 4;
            NPC[numNPCs].Location.X = NPC[A].Location.X - NPC[A].Location.Width;
            NPC[numNPCs].SpecialX = NPC[numNPCs].Location.X + NPC[A].Location.Width;
        }
    }
    else if(NPC[A].GeneratorEffect() == 2) // projectile
    {
        NPC[numNPCs].Layer = LAYER_SPAWNED_NPCS;
        PlaySoundSpatial(SFX_Bullet, NPC[A].Location);
        NPC[numNPCs].Projectile = true;
        if(NPC[numNPCs].Type == NPCID_BULLET) // Normal Bullet Bills
            NPC[numNPCs].Projectile = false;

        if(NPC[numNPCs].Type == NPCID_SLIDE_BLOCK)
            NPC[numNPCs].Special = 1;

        if(NPC[A].GeneratorDirection() == 1)
        {
            NPC[numNPCs].Location.SpeedY = -10;
            NPC[numNPCs].Location.SpeedX = 0;
            NewEffect(EFFID_SMOKE_S3, newLoc(NPC[A].Location.X, NPC[A].Location.Y + 16, 32, 32));
            if(NPCIsVeggie(NPC[numNPCs]))
                NPC[numNPCs].Location.SpeedX = dRand() * 2 - 1;
            // NPC(numNPCs).Location.SpeedY = -1
        }
        else if(NPC[A].GeneratorDirection() == 2)
        {
            NPC[numNPCs].Location.SpeedX = -Physics.NPCShellSpeed;
            NewEffect(EFFID_SMOKE_S3, newLoc(NPC[A].Location.X + 16, NPC[A].Location.Y, 32, 32));
        }
        else if(NPC[A].GeneratorDirection() == 3)
        {
            NPC[numNPCs].Location.SpeedY = 8;
            NPC[numNPCs].Location.SpeedX = 0;
            NewEffect(EFFID_SMOKE_S3, newLoc(NPC[A].Location.X, NPC[A].Location.Y - 16, 32, 32));
        }
        else
        {
            NPC[numNPCs].Location.SpeedX = Physics.NPCShellSpeed;
            SoundPause[SFX_BlockHit] = 1;
            NewEffect(EFFID_SMOKE_S3, newLoc(NPC[A].Location.X - 16, NPC[A].Location.Y, 32, 32));
        }
    }

    NPC[numNPCs].Direction = NPC[numNPCs].DefaultDirection;
    NPC[numNPCs].Frame = EditorNPCFrame(NPC[numNPCs].Type, NPC[numNPCs].Direction);
    NPC[numNPCs].DefaultDirection = NPC[numNPCs].Direction;
    NPC[numNPCs].DefaultType = NPCID_NULL;
    NPC[numNPCs].Generator = false;
    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = 100;
    NPC[numNPCs].TriggerActivate = NPC[A].TriggerActivate;
    NPC[numNPCs].TriggerDeath = NPC[A].TriggerDeath;
    NPC[numNPCs].TriggerLast = NPC[A].TriggerLast;
    NPC[numNPCs].TriggerTalk = NPC[A].TriggerTalk;
    // new because generator variables now share memory with Special3/4/5
    NPC[numNPCs].Special3 = 0;
    NPC[numNPCs].GeneratorTime() = 0;
    NPC[numNPCs].GeneratorTimeMax() = 0;
    CheckSectionNPC(numNPCs);
    syncLayers_NPC(numNPCs);
}


================================================
FILE: src/npc/npc_update/npc_movement_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "npc.h"
#include "npc_traits.h"
#include "config.h"
#include "collision.h"

#include "npc/npc_update/npc_update_priv.h"

#include "main/trees.h"

void NPCMovementLogic(int A, tempf_t& speedVar)
{
    num_t Wings_SpeedX = NPC[A].Location.SpeedX;
    num_t Wings_SpeedY = NPC[A].Location.SpeedY;

    // POSSIBLE SUBROUTINE: setSpeed

    // this condition was duplicated in two places in SMBX 1.3
    bool use_default_movement = (NPCDefaultMovement(NPC[A].Type) || (NPC[A]->IsFish && NPC[A].Special != 2)) && !((NPC[A].Type == NPCID_EXT_TURTLE || NPC[A].Type == NPCID_BLU_HIT_TURTLE_S4) && NPC[A].Special > 0);

    // Default Movement Code
    if(use_default_movement && NPC[A].Type != NPCID_ITEM_BURIED)
    {
        if(NPC[A].Direction == 0)
        {
            if(iRand(2) == 0)
                NPC[A].Direction = -1;
            else
                NPC[A].Direction = 1;
        }

        if(NPC[A]->CanWalkOn)
        {
            if(NPC[A].Location.SpeedX < Physics.NPCWalkingOnSpeed && NPC[A].Location.SpeedX > -Physics.NPCWalkingOnSpeed)
            {
                if(!NPC[A].Projectile)
                    NPC[A].Location.SpeedX = Physics.NPCWalkingOnSpeed * NPC[A].Direction;
            }

            if(NPC[A].Location.SpeedX > Physics.NPCWalkingOnSpeed)
            {
                NPC[A].Location.SpeedX -= 0.05_n;
                if(!NPC[A].Projectile)
                    NPC[A].Location.SpeedX -= 0.1_n;
            }
            else if(NPC[A].Location.SpeedX < -Physics.NPCWalkingOnSpeed)
            {
                NPC[A].Location.SpeedX += 0.05_n;
                if(!NPC[A].Projectile)
                    NPC[A].Location.SpeedX += 0.1_n;
            }
        }
        else if(NPC[A].Type == NPCID_KNIGHT)
        {
            if(NPC[A].Location.SpeedX < 2 && NPC[A].Location.SpeedX > -2)
            {
                if(!NPC[A].Projectile)
                    NPC[A].Location.SpeedX = 2 * NPC[A].Direction;
            }

            if(NPC[A].Location.SpeedX > 2)
                NPC[A].Location.SpeedX -= 0.05_n;
            else if(NPC[A].Location.SpeedX < -2)
                NPC[A].Location.SpeedX += 0.05_n;
        }
        else if(!(NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4 && NPC[A].Projectile))
        {
            if(NPC[A].Location.SpeedX < Physics.NPCWalkingSpeed && NPC[A].Location.SpeedX > -Physics.NPCWalkingSpeed)
            {
                if(!NPC[A].Projectile)
                    NPC[A].Location.SpeedX = Physics.NPCWalkingSpeed * NPC[A].Direction;
            }

            if(NPC[A].Location.SpeedX > Physics.NPCWalkingSpeed)
                NPC[A].Location.SpeedX -= 0.05_n;
            else if(NPC[A].Location.SpeedX < -Physics.NPCWalkingSpeed)
                NPC[A].Location.SpeedX += 0.05_n;
        }
    }
    else if(NPC[A].Type == NPCID_FLIER)
    {
        if(NPC[A].Location.SpeedX > -2 && NPC[A].Location.SpeedX < 2)
            NPC[A].Location.SpeedX = 2 * NPC[A].Direction;
    }
    else if(NPC[A].Type == NPCID_ROCKET_FLIER)
    {
        if(NPC[A].Location.SpeedX > -2.5_n && NPC[A].Location.SpeedX < 2.5_n)
            NPC[A].Location.SpeedX = 2.5_n * NPC[A].Direction;
    }
    // Slow things down that shouldnt move
    else if(NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_CANNONITEM || NPC[A].Type == NPCID_JUMPER_S3 || NPC[A].Type == NPCID_SPRING ||
            NPC[A].Type == NPCID_KEY || NPC[A].Type == NPCID_COIN_SWITCH || NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_TNT ||
            NPC[A].Type == NPCID_GRN_BOOT || NPC[A].Type == NPCID_RED_BOOT || NPC[A].Type == NPCID_BLU_BOOT ||
            (NPC[A].Type == NPCID_SPIT_BOSS_BALL && NPC[A].Projectile) || NPC[A].Type == NPCID_TOOTHYPIPE || NPC[A].Type == NPCID_METALBARREL ||
            NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG ||
            (NPCIsVeggie(NPC[A].Type) && !NPC[A].Projectile) ||
            (NPC[A].Type == NPCID_HEAVY_THROWER && NPC[A].Projectile) ||
            /*(NPC[A].Projectile && (NPC[A].Type == NPCID_FLY && NPC[A].Type == NPCID_MINIBOSS)) ||*/ // FIXME: This segment is always false (type equal both 54 and 15, impossible!) [PVS Studio]
            NPC[A].Type == NPCID_CIVILIAN_SCARED || NPC[A].Type == NPCID_STATUE_S3 || NPC[A].Type == NPCID_STATUE_S4 || NPC[A].Type == NPCID_CIVILIAN ||
            NPC[A].Type == NPCID_CHAR3 || NPC[A].Type == NPCID_ITEM_POD || NPC[A].Type == NPCID_BOMB || NPC[A].Type == NPCID_LIT_BOMB_S3 ||
            NPC[A].Type == NPCID_CHAR2 || NPC[A].Type == NPCID_CHAR5 || (NPCIsYoshi(NPC[A].Type) && NPC[A].Special == 0) ||
            (NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D) || NPC[A].Type == NPCID_HIT_CARRY_FODDER || (NPC[A].Type == NPCID_SPIT_BOSS && NPC[A].Projectile) ||
            NPC[A].Type == NPCID_HEAVY_POWER || NPC[A].Type == NPCID_STATUE_POWER || NPC[A].Type == NPCID_FIRE_POWER_S4 || NPC[A].Type == NPCID_3_LIFE ||
            NPC[A].Type == NPCID_STAR_EXIT || NPC[A].Type == NPCID_STAR_COLLECT || NPC[A].Type == NPCID_FIRE_POWER_S1 || NPC[A].Type == NPCID_TIMER_S2 ||
            NPC[A].Type == NPCID_EARTHQUAKE_BLOCK || NPC[A].Type == NPCID_POWER_S2 || NPC[A].Type == NPCID_POWER_S5 || NPC[A].Type == NPCID_FLY_POWER ||
            NPC[A].Type == NPCID_LOCK_DOOR || NPC[A].Type == NPCID_FLY_BLOCK || NPC[A].Type == NPCID_FLY_CANNON || NPC[A].Type == NPCID_ICE_POWER_S4 ||
            NPC[A].Type == NPCID_ICE_POWER_S3 || NPC[A].Type == NPCID_DOOR_MAKER || NPC[A].Type == NPCID_QUAD_SPITTER || NPC[A].Type == NPCID_AQUATIC_POWER ||
            NPC[A].Type == NPCID_POLAR_POWER || NPC[A].Type == NPCID_SHELL_POWER)
    {
        if(NPC[A].Location.SpeedX > 0)
            NPC[A].Location.SpeedX -= 0.05_n;
        else if(NPC[A].Location.SpeedX < 0)
            NPC[A].Location.SpeedX += 0.05_n;

        if(NPC[A].Location.SpeedX >= -0.05_n && NPC[A].Location.SpeedX <= 0.05_n)
            NPC[A].Location.SpeedX = 0;

        if(NPC[A].Location.SpeedY >= -Physics.NPCGravity && NPC[A].Location.SpeedY <= Physics.NPCGravity)
        {
            if(NPC[A].Location.SpeedX > 0)
                NPC[A].Location.SpeedX -= 0.3_n;
            else if(NPC[A].Location.SpeedX < 0)
                NPC[A].Location.SpeedX += 0.3_n;

            if(NPC[A].Location.SpeedX >= -0.3_n && NPC[A].Location.SpeedX <= 0.3_n)
                NPC[A].Location.SpeedX = 0;
        }
    }
#if 0
    // dead code because NPCDefaultMovement(NPCID_TANK_TREADS) is true
    else if(NPC[A].Type == NPCID_TANK_TREADS)
    {
        NPC[A].Projectile = true;
        NPC[A].Direction = NPC[A].DefaultDirection;
        NPC[A].Location.SpeedX = 1 * NPC[A].DefaultDirection;

        // the conditions here are outdated
        for(int B = 1; B <= numPlayers; B++)
        {
            if(!(Player[B].Effect == PLREFF_NORMAL || Player[B].Effect == PLREFF_WARP_PIPE))
            {
                NPC[A].Location.SpeedX = 0;
                NPC[A].Location.SpeedY = 0;
            }
        }
    }
#endif
    // Mushroom Movement Code
    else if(NPC[A].Type == NPCID_POWER_S3 || NPC[A].Type == NPCID_SWAP_POWER || NPC[A].Type == NPCID_LIFE_S3 ||
            NPC[A].Type == NPCID_POISON || NPC[A].Type == NPCID_POWER_S1 || NPC[A].Type == NPCID_POWER_S4 ||
            NPC[A].Type == NPCID_LIFE_S1 || NPC[A].Type == NPCID_LIFE_S4 || NPC[A].Type == NPCID_BRUTE_SQUISHED ||
            NPC[A].Type == NPCID_BIG_GUY || NPC[A].Type == NPCID_INVINCIBILITY_POWER || NPC[A].Type == NPCID_CYCLONE_POWER)
    {
        if(NPC[A].Direction == 0) // Move toward the closest player
        {
            int target_plr = NPCTargetPlayer(NPC[A]);

            if(target_plr)
                NPC[A].Direction = -Player[target_plr].Direction;
        }

        if(NPC[A].Location.SpeedX < Physics.NPCMushroomSpeed && NPC[A].Location.SpeedX > -Physics.NPCMushroomSpeed)
        {
            if(!NPC[A].Projectile)
                NPC[A].Location.SpeedX = Physics.NPCMushroomSpeed * NPC[A].Direction;
        }

        if(NPC[A].Location.SpeedX > Physics.NPCMushroomSpeed)
            NPC[A].Location.SpeedX -= 0.05_n;
        else if(NPC[A].Location.SpeedX < -Physics.NPCMushroomSpeed)
            NPC[A].Location.SpeedX += 0.05_n;
    }
    else if(NPC[A].Type == NPCID_RAINBOW_SHELL)
    {
        NPC[A].Projectile = true;

        NPCFaceNearestPlayer(NPC[A]);

        NPC[A].Location.SpeedX += 0.1_n * NPC[A].Direction;

        if(NPC[A].Location.SpeedX < -4)
            NPC[A].Location.SpeedX = -4;

        if(NPC[A].Location.SpeedX > 4)
            NPC[A].Location.SpeedX = 4;
    }
    // Yoshi Fireball
    else if(NPC[A].Type == NPCID_PET_FIRE)
    {
        NPC[A].Projectile = true;
        if(NPC[A].Location.SpeedX == 0)
            NPC[A].Location.SpeedX = 5 * NPC[A].Direction;
    }
    // bully
    else if(NPC[A].Type == NPCID_CHASER)
    {
        if(!NPC[A].Projectile && NPC[A].Special2 == 0)
        {
            NPCFaceNearestPlayer(NPC[A]);

            NPC[A].Location.SpeedX += 0.05_n * NPC[A].Direction;

            if(NPC[A].Location.SpeedX >= 3)
                NPC[A].Location.SpeedX = 3;

            if(NPC[A].Location.SpeedX <= -3)
                NPC[A].Location.SpeedX = -3;
        }
        else
        {
            if(NPC[A].Location.SpeedX > 0.1_n)
                NPC[A].Location.SpeedX -= 0.075_n;
            else if(NPC[A].Location.SpeedX < -0.1_n)
                NPC[A].Location.SpeedX += 0.075_n;

            if(NPC[A].Location.SpeedX >= -0.1_n && NPC[A].Location.SpeedX <= 0.1_n)
                NPC[A].Special2 = 0;
        }
    }
    else if(NPC[A].Type == NPCID_RAFT)
    {
        if(NPC[A].Special == 1)
            NPC[A].Location.SpeedX = 2 * NPC[A].Direction;
    }
    // Big Koopa Movement Code
    else if(NPC[A].Type == NPCID_MINIBOSS)
    {
        if(NPC[A].Location.SpeedX < 0)
            NPC[A].Direction = -1;
        else
            NPC[A].Direction = 1;

        if(NPC[A].Special == 0 || NPC[A].Special == 3)
        {
            if(NPC[A].Location.SpeedX < 3.5_n && NPC[A].Location.SpeedX > -3.5_n)
                NPC[A].Location.SpeedX += (0.1_n * NPC[A].Direction);

            if(NPC[A].Location.SpeedX > 3.5_n)
                NPC[A].Location.SpeedX -= 0.05_n;
            else if(NPC[A].Location.SpeedX < -3.5_n)
                NPC[A].Location.SpeedX += 0.05_n;

            if(NPC[A].Special == 3)
                NPC[A].Location.SpeedY = -6;
        }
        else if(NPC[A].Special == 2)
            NPC[A].Location.SpeedX += (0.2_n * NPC[A].Direction);
        else if(NPC[A].Special == 3)
            NPC[A].Location.SpeedY = -6;
        else
        {
            if(NPC[A].Location.SpeedX > 0)
                NPC[A].Location.SpeedX -= 0.05_n;
            else if(NPC[A].Location.SpeedX < 0)
                NPC[A].Location.SpeedX += 0.05_n;

            if(NPC[A].Location.SpeedX > -0.5_n && NPC[A].Location.SpeedX < 0.5_n)
                NPC[A].Location.SpeedX = 0.0001_n * NPC[A].Direction;
        }
    }
    // spiney eggs
    else if(NPC[A].Type == NPCID_SPIKY_BALL_S3)
    {
        if(NPC[A].CantHurt > 0)
        {
            NPC[A].Projectile = true;
            NPC[A].CantHurt = 100;
        }
        else
        {
            NPCFaceNearestPlayer(NPC[A]);

            if(NPC[A].Direction == 1 && NPC[A].Location.SpeedX < 4)
                NPC[A].Location.SpeedX += 0.04_n;
            if(NPC[A].Direction == -1 && NPC[A].Location.SpeedX > -4)
                NPC[A].Location.SpeedX -= 0.04_n;
        }
    }
    else if(NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_BIG_BULLET)
    {
        if(NPC[A].CantHurt < 1000)
            NPC[A].Location.SpeedX = 4 * NPC[A].Direction;
    }
    else if(NPC[A].Type == NPCID_GHOST_FAST)
        NPC[A].Location.SpeedX = 2 * NPC[A].Direction;

    // yoshi
    if(NPCIsYoshi(NPC[A].Type))
    {
        if(NPC[A].Special == 0)
        {
            if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
            {
                if(NPC[A].Wet == 0)
                    NPC[A].Location.SpeedY = -2.1_n;
                else
                    NPC[A].Location.SpeedY = -1.1_n;
            }
        }
        else
        {
            if(NPC[A].Location.SpeedX < 3 && NPC[A].Location.SpeedX > -3)
            {
                if(!NPC[A].Projectile)
                    NPC[A].Location.SpeedX = 3 * NPC[A].Direction;
            }
        }
    }

    if(NPC[A].Type != NPCID_SPIT_BOSS && NPC[A].Type != NPCID_FALL_BLOCK_RED && NPC[A].Type != NPCID_FALL_BLOCK_BROWN && NPC[A].Type != NPCID_VEHICLE &&
       NPC[A].Type != NPCID_CONVEYOR && NPC[A].Type != NPCID_YEL_PLATFORM && NPC[A].Type != NPCID_BLU_PLATFORM && NPC[A].Type != NPCID_GRN_PLATFORM &&
       NPC[A].Type != NPCID_RED_PLATFORM && NPC[A].Type != NPCID_STATUE_S3 && NPC[A].Type != NPCID_STATUE_S4 && NPC[A].Type != NPCID_STATUE_FIRE &&
       NPC[A].Type != NPCID_CANNONITEM && NPC[A].Type != NPCID_TOOTHYPIPE && NPC[A].Type != NPCID_TOOTHY && !(NPC[A].Type >= NPCID_PLATFORM_S3 &&
       NPC[A].Type <= NPCID_PLATFORM_S1))
    {
        if(NPC[A].Location.SpeedX < 0) // Find the NPCs direction
            NPC[A].Direction = -1;
        else if(NPC[A].Location.SpeedX > 0)
            NPC[A].Direction = 1;
    }

    // Reset Speed when no longer a projectile
    // If Not (NPCIsAShell(.Type) Or .Type = 8 Or .Type = 93 Or .Type = 74 Or .Type = 51 Or .Type = 52 Or .Type = 12 Or .Type = 14 Or .Type = 13 Or .Type = 15 Or NPCIsABonus(.Type) Or .Type = 17 Or .Type = 18 Or .Type = 21 Or .Type = 22 Or .Type = 25 Or .Type = 26 Or .Type = 29 Or .Type = 30 Or .Type = 31 Or .Type = 32 Or .Type = 35 Or .Type = 37 Or .Type = 38 Or .Type = 39 Or .Type = 40 Or .Type = 42 Or .Type = 43 Or .Type = 44 Or .Type = 45 Or .Type = 46 Or .Type = 47 Or .Type = 48 Or .Type = 76 Or .Type = 49 Or .Type = 54 Or .Type = 56 Or .Type = 57 Or .Type = 58 Or .Type = 60 Or .Type = 62 Or .Type = 64 Or .Type = 66 Or .Type = 67 Or .Type = 68 Or .Type = 69 Or .Type = 70 Or .Type = 78 Or .Type = 84 Or .Type = 85 Or .Type = 87 Or (.Type = 55 And .Special > 0) Or (.Type >= 79 And .Type <= 83) Or .Type = 86 Or .Type = 92 Or .Type = 94 Or NPCIsYoshi(.Type) Or .Type = 96 Or .Type = 101 Or .Type = 102) And .Projectile = False Then
    if(use_default_movement && !NPC[A].Projectile)
    {
        if(!NPC[A]->CanWalkOn)
        {
            if(NPC[A]->CanWalkOn)
                NPC[A].Location.SpeedX = Physics.NPCWalkingOnSpeed * NPC[A].Direction;
            else if(NPC[A].Type == NPCID_KNIGHT)
                NPC[A].Location.SpeedX = 2 * NPC[A].Direction;
            else
                NPC[A].Location.SpeedX = Physics.NPCWalkingSpeed * NPC[A].Direction;


            if((NPC[A]->IsFish && NPC[A].Special != 1) && !NPC[A].Projectile)
            {
                // NOTE: SpeedX was previously stored in Special3. That value was only read here (fish with Special == 1 use Special3 in a different way).
                if(NPC[A].Wet == 0)
                {
                    if(NPC[A].Special5 >= 0)
                        NPC[A].Special2 -= 1;
                }
                else
                {
                    NPC[A].Special2 = 6;
                    NPC[A].SpecialX = NPC[A].Location.SpeedX;
                }

                if(NPC[A].Special2 <= 0)
                {
                    NPC[A].SpecialX = NPC[A].SpecialX * 0.99_r;
                    if(NPC[A].SpecialX > -0.1_n && NPC[A].SpecialX < 0.1_n)
                        NPC[A].SpecialX = 0;
                    NPC[A].Location.SpeedX = NPC[A].SpecialX;
                }
            }

            if(NPC[A]->IsFish && NPC[A].Special == 1 && !NPC[A].Projectile)
                NPC[A].Location.SpeedX = Physics.NPCWalkingOnSpeed * 2 * NPC[A].Direction;
        }

        // moved into here from immediately below, use_def_mov is certainly true for NPCID_WALK_BOMB_S2 (cross-ref NPCDefaultMovement)
        if(NPC[A].Type == NPCID_WALK_BOMB_S2 /* && !NPC[A].Projectile */ && NPC[A].Special2 == 1)
            NPC[A].Location.SpeedX = 0;
    }


    // NPC Gravity
    if(!NPC[A]->NoGravity)
    {
        // POSSIBLE SUBROUTINE: calcGravity

        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL)
        {
            NPC[A].CantHurt = 100;
            if(NPC[A].Special < 2)
                NPC[A].Location.SpeedY += Physics.NPCGravity * 1.5_rb;
            else if(NPC[A].Special == 3)
            {
                // peach fireball changes
                NPC[A].Location.SpeedY += Physics.NPCGravity * 0.9_r;
                if(NPC[A].Location.SpeedX > 3)
                    NPC[A].Location.SpeedX -= 0.04_n;
                else if(NPC[A].Location.SpeedX < -3)
                    NPC[A].Location.SpeedX += 0.04_n;
            }
            else if(NPC[A].Special == 4)
            {

                // toad fireball changes
                NPC[A].Location.SpeedY += Physics.NPCGravity * 1.3_r;
                if(NPC[A].Location.SpeedX < 8 && NPC[A].Location.SpeedX > 0)
                    NPC[A].Location.SpeedX += 0.03_n;
                else if(NPC[A].Location.SpeedX > -8 && NPC[A].Location.SpeedX < 0)
                    NPC[A].Location.SpeedX -= 0.03_n;
            }
            else if(NPC[A].Special == 5) // link fireballs float
            {
            }
            else
                NPC[A].Location.SpeedY += Physics.NPCGravity * 1.3_r;

        }
        else if(NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_BIG_BULLET)
            NPC[A].Location.SpeedY = 0;

        else if((NPC[A]->IsFish && NPC[A].Special == 2) && !NPC[A].Projectile)
        {
            if(NPC[A].Special5 == 1)
            {
                if(NPC[A].Location.Y > NPC[A].DefaultLocationY)
                    NPC[A].Location.SpeedY = -4 - (NPC[A].Location.Y - NPC[A].DefaultLocationY) / 50;
                else
                    NPC[A].Special5 = 0;
            }
            else
            {
                // If .Location.SpeedY < 2 + (.Location.Y - .DefaultLocationY) * 0.02 Then
                NPC[A].Location.SpeedY += Physics.NPCGravity * 0.4_r;
                // End If
            }
        }
        else if(NPC[A].Type != NPCID_RED_VINE_TOP_S3 && NPC[A].Type != NPCID_GRN_VINE_TOP_S3 && NPC[A].Type != NPCID_GRN_VINE_TOP_S4 &&
                !(NPC[A]->IsFish && NPC[A].Special == 2) && NPC[A].Type != NPCID_HOMING_BALL &&
                NPC[A].Type != NPCID_HOMING_BALL_GEN && NPC[A].Type != NPCID_SPIT_GUY_BALL && NPC[A].Type != NPCID_STAR_EXIT && NPC[A].Type != NPCID_STAR_COLLECT &&
                NPC[A].Type != NPCID_VILLAIN_FIRE && NPC[A].Type != NPCID_PLANT_S3 && NPC[A].Type != NPCID_FIRE_PLANT && NPC[A].Type != NPCID_PLANT_FIREBALL &&
                NPC[A].Type != NPCID_PLANT_S1 && NPC[A].Type != NPCID_BIG_PLANT && NPC[A].Type != NPCID_LONG_PLANT_UP && NPC[A].Type != NPCID_LONG_PLANT_DOWN &&
                !NPCIsAParaTroopa(NPC[A].Type) && NPC[A].Type != NPCID_BOTTOM_PLANT && NPC[A].Type != NPCID_SIDE_PLANT &&
                NPC[A].Type != NPCID_LEAF_POWER && NPC[A].Type != NPCID_STONE_S3 && NPC[A].Type != NPCID_STONE_S4 && NPC[A].Type != NPCID_GHOST_S3 &&
                NPC[A].Type != NPCID_GHOST_FAST && NPC[A].Type != NPCID_GHOST_S4 && NPC[A].Type != NPCID_BIG_GHOST && NPC[A].Type != NPCID_SPIKY_THROWER &&
                NPC[A].Type != NPCID_VEHICLE && NPC[A].Type != NPCID_CONVEYOR && NPC[A].Type != NPCID_YEL_PLATFORM &&
                NPC[A].Type != NPCID_BLU_PLATFORM && NPC[A].Type != NPCID_GRN_PLATFORM && NPC[A].Type != NPCID_RED_PLATFORM &&
                NPC[A].Type != NPCID_STATUE_FIRE && !(NPC[A]->IsACoin && NPC[A].Special == 0) &&
                NPC[A].Type != NPCID_CHECKER_PLATFORM && NPC[A].Type != NPCID_PLATFORM_S1 && NPC[A].Type != NPCID_PET_FIRE &&
                NPC[A].Type != NPCID_GOALTAPE && NPC[A].Type != NPCID_LAVA_MONSTER && NPC[A].Type != NPCID_FLIER &&
                NPC[A].Type != NPCID_ROCKET_FLIER &&
                ((NPC[A].Type != NPCID_WALL_BUG && NPC[A].Type != NPCID_WALL_SPARK && NPC[A].Type != NPCID_WALL_TURTLE)) &&
                NPC[A].Type != NPCID_BOSS_FRAGILE && NPC[A].Type != NPCID_ITEM_BURIED &&
                NPC[A].Type != NPCID_MAGIC_BOSS_BALL && NPC[A].Type != NPCID_JUMP_PLANT && NPC[A].Type != NPCID_LOCK_DOOR)
        {
            if(NPC[A].Type != NPCID_BAT && NPC[A].Type != NPCID_VINE_BUG && NPC[A].Type != NPCID_QUAD_BALL && NPC[A].Type != NPCID_FIRE_BOSS_FIRE && NPC[A].Type != NPCID_ITEM_BUBBLE && NPC[A].Type != NPCID_ITEM_THROWER && NPC[A].Type != NPCID_MAGIC_DOOR && NPC[A].Type != NPCID_COCKPIT && NPC[A].Type != NPCID_CHAR3_HEAVY && NPC[A].Type != NPCID_CHAR4_HEAVY) // no gravity
            {
                if(NPC[A]->IsFish && NPC[A].Special == 4 && !NPC[A].Projectile)
                    NPC[A].Location.SpeedX = 0;
                if(NPC[A].Wet == 2 && (NPC[A].Type == NPCID_RAFT))
                    NPC[A].Location.SpeedY += -Physics.NPCGravity / 2;
                else if(NPC[A].Wet == 2 && NPC[A]->IsFish && NPC[A].Special != 2 && !NPC[A].Projectile) // Fish cheep
                {
                    if((NPC[A].Location.X < NPC[A].DefaultLocationX - 100 && NPC[A].Direction == -1) || (NPC[A].Location.X > NPC[A].DefaultLocationX + 100 && NPC[A].Direction == 1))
                    {
                        if(NPC[A].Special == 3)
                            NPC[A].TurnAround = true;
                    }

                    if(NPC[A].Special == 4)
                    {


                        if(NPC[A].Location.SpeedY == 0)
                            NPC[A].Special4 = 1;
                        if(NPC[A].Location.SpeedY == 0.01_n)
                            NPC[A].Special4 = 0;

                        NPC[A].Location.SpeedX = 0;
                        if(NPC[A].Location.SpeedY > 2)
                            NPC[A].Location.SpeedY = 2;
                        if(NPC[A].Location.SpeedY < -2)
                            NPC[A].Location.SpeedY = -2;
                        if(NPC[A].Location.Y > NPC[A].DefaultLocationY + 25)
                            NPC[A].Special4 = 1;
                        else if(NPC[A].Location.Y < NPC[A].DefaultLocationY - 25)
                            NPC[A].Special4 = 0;
                        if(NPC[A].Special4 == 0)
                            NPC[A].Location.SpeedY += 0.05_n;
                        else
                            NPC[A].Location.SpeedY -= 0.05_n;
                    }
                    else
                    {
                        if(NPC[A].Special4 == 0)
                        {
                            NPC[A].Location.SpeedY -= 0.025_n;
                            if(NPC[A].Location.SpeedY <= -1)
                                NPC[A].Special4 = 1;
                            if(NPC[A].Special == 3 && NPC[A].Location.SpeedY <= -0.5_n)
                                NPC[A].Special4 = 1;
                        }
                        else
                        {
                            NPC[A].Location.SpeedY += 0.025_n;
                            if(NPC[A].Location.SpeedY >= 1)
                                NPC[A].Special4 = 0;
                            if(NPC[A].Special == 3 && NPC[A].Location.SpeedY >= 0.5_n)
                                NPC[A].Special4 = 0;
                        }
                    }
                }
                else if(NPC[A]->IsFish && NPC[A].Special == 1 && NPC[A].Special5 == 1)
                    NPC[A].Location.SpeedY += Physics.NPCGravity * 0.6_r;
                else if(NPC[A].Type == NPCID_FLY_BLOCK || (g_config.fix_flamethrower_gravity && NPC[A].Type == NPCID_FLY_CANNON))
                {
                    NPC[A].Location.SpeedY += Physics.NPCGravity * 0.75_rb;
                    if(NPC[A].Location.SpeedY > Physics.NPCGravity * 15)
                        NPC[A].Location.SpeedY = Physics.NPCGravity * 15;
                }
                else if(NPC[A].Type != NPCID_FIRE_DISK && NPC[A].Type != NPCID_FIRE_CHAIN)
                    NPC[A].Location.SpeedY += Physics.NPCGravity;
            }
        }


        if(NPC[A].Type == NPCID_CHAR3_HEAVY)
        {
            NPC[A].Location.SpeedY += Physics.NPCGravity * 0.8_r;
            // If .Location.SpeedY >= 5 Then .Location.SpeedY = 5
            if(NPC[A].Location.SpeedX < -0.005_n)
                NPC[A].Location.SpeedX += 0.02_n;
            else if(NPC[A].Location.SpeedX > 0.005_n)
                NPC[A].Location.SpeedX -= 0.02_n;
            else
                NPC[A].Location.SpeedX = 0;
        }
    }
    else if(NPC[A].Projectile)
    {
        NPC[A].Location.SpeedY = NPC[A].Location.SpeedY * 0.95_r;
        if(NPC[A].Location.SpeedY > -0.1_n && NPC[A].Location.SpeedY < 0.1_n)
        {
            NPC[A].Projectile = false;
            NPC[A].Location.SpeedY = 0;
        }
    }

    if(NPC[A].Location.SpeedY >= 8 && NPC[A].Type != NPCID_FIRE_DISK && NPC[A].Type != NPCID_FIRE_CHAIN)
        NPC[A].Location.SpeedY = 8;

    // POSSIBLE SUBROUTINE: preMovement

    NPCSpecial(A);

    // there was lots of speed cancel code (and some TheXTech logic for the Raft NPC) here; moved into NPCSpecial

    if(NPC[A].Type == NPCID_STACKER && !NPC[A].Projectile)
    {
        speedVar = speedVar * 7 / 10;
        if(NPC[A].Special2 < 2)
        {
            speedVar = speedVar * 7 / 10;
            NPC[A].Special2 += 1;
        }
    }

    // POSSIBLE SUBROUTINE: applyMovement

    // Dont move
    if(NPC[A].Stuck && !NPC[A].Projectile && NPC[A].Type != NPCID_LEAF_POWER) // face closest player
    {
        NPC[A].Location.SpeedX = 0;
        if(!(NPC[A].Type == NPCID_SKELETON && NPC[A].Special > 0))
            NPCFaceNearestPlayer(NPC[A]);
    }

    // Actual Movement (SpeedX / SpeedY application code)
    if(NPC[A].Wings)
    {
        // don't do anything here, the movement will be applied after SpecialNPC
    }
    else if(/*(!NPCIsAnExit(NPC[A]) || NPC[A].Type == NPCID_STAR_EXIT || NPC[A].Type == NPCID_STAR_COLLECT) */
        NPC[A].Type != NPCID_ITEMGOAL && NPC[A].Type != NPCID_GOALORB_S3 && NPC[A].Type != NPCID_GOALORB_S2 && NPC[A].Type != NPCID_FLAG_EXIT &&
        NPC[A].Type != NPCID_FIRE_POWER_S3 && NPC[A].Type != NPCID_CONVEYOR)
    {
        // ParaTroopa speed application happens in SpecialNPC, buried item can't move at all
        if(!NPCIsAParaTroopa(NPC[A].Type) && NPC[A].Type != NPCID_ITEM_BURIED)
        {
            NPC[A].Location.X += NPC[A].Location.SpeedX.times((num_t)speedVar);
            NPC[A].Location.Y += NPC[A].Location.SpeedY;
        }
    }
    else
    {
        if(!(NPC[A].Location.X == NPC[A].DefaultLocationX && NPC[A].Location.Y == NPC[A].DefaultLocationY) || NPC[A].Type == NPCID_FIRE_POWER_S3)
        {
            NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.99_r;
            NPC[A].Location.X += NPC[A].Location.SpeedX;
            NPC[A].Location.Y += NPC[A].Location.SpeedY;
            if(!NPC[A].Projectile)
                NPC[A].Location.SpeedX = 0;
        }
    }
    // End If 'end of freezenpcs


    // POSSIBLE SUBROUTINE: postMovement

    // projectile checks moved into SpecialNPC

    // Special NPCs code
    SpecialNPC(A);

    // Wings movement code
    if(NPC[A].Wings)
    {
        // reset speed to its old value
        if(NPC[A].Wings != WING_OVERRIDE)
        {
            NPC[A].Location.SpeedX = Wings_SpeedX;
            NPC[A].Location.SpeedY = Wings_SpeedY;
        }

        // do wings movement!
        NPCMovementLogic_Wings(A, (num_t)speedVar);
    }
}

void NPCSectionWrap(NPC_t& npc)
{
    if((LevelWrap[npc.Section] || LevelVWrap[npc.Section]) && npc.Type != NPCID_HEAVY_THROWN && npc.Type != NPCID_PET_FIRE) // Level wraparound
    {
        if(LevelWrap[npc.Section])
        {
            if(npc.Location.X + npc.Location.Width < level[npc.Section].X)
                npc.Location.X = level[npc.Section].Width - 1;
            else if(npc.Location.X > level[npc.Section].Width)
                npc.Location.X = level[npc.Section].X - npc.Location.Width + 1;
        }

        if(LevelVWrap[npc.Section])
        {
            if(npc.Location.Y + npc.Location.Height < level[npc.Section].Y)
                npc.Location.Y = level[npc.Section].Height - 1;
            else if(npc.Location.Y > level[npc.Section].Height)
                npc.Location.Y = level[npc.Section].Y - npc.Location.Height + 1;
        }
    }
}

void NPCMovementLogic_Wings(int A, const num_t speedVar)
{
    WingBehaviors behavior = (NPC[A].Wings) ? NPC[A].Wings : (WingBehaviors)NPC[A].Special;

    if(NPC[A].Wings && NPC[A].Projectile && !NPC[A]->IsAShell)
    {
        NPC[A].Location.SpeedY += Physics.NPCGravity;

        if(num_t::abs(NPC[A].Location.SpeedY) < 0.5_n)
            NPC[A].Projectile = false;
    }
    else if(behavior == WING_CHASE || behavior == WING_PARA_CHASE || behavior == WING_FLEE) // chase
    {
        if(NPC[A].CantHurt > 0)
            NPC[A].CantHurt = 100;

        NPC[A].Projectile = false;

        int target_plr = 0;
        num_t min_dist = 0;
        for(int B = 1; B <= numPlayers; B++)
        {
            if(!Player[B].Dead && Player[B].Section == NPC[A].Section && Player[B].TimeToLive == 0 && NPC[A].CantHurtPlayer != B)
            {
                num_t dist = NPCPlayerTargetDist(NPC[A], Player[B]);
                if(min_dist == 0 || dist < min_dist)
                {
                    min_dist = dist;
                    target_plr = B;
                }
            }
        }

        if(NPC[A].Wings && target_plr == 0 && NPC[A].CantHurtPlayer)
            target_plr = NPC[A].CantHurtPlayer;

        if(target_plr > 0)
        {
            int D;
            if(NPC[A].Location.to_right_of(Player[target_plr].Location))
                D = -1;
            else
                D = 1;

            NPC[A].Direction = D;
            int E = 0; // X
            int F_div = -1; // Y

            if(NPC[A].Location.Y > Player[target_plr].Location.Y)
                F_div = -1;
            else if(NPC[A].Location.Y < Player[target_plr].Location.Y - 128)
                F_div = 1;

            if(NPC[A].Location.X > Player[target_plr].Location.X + Player[target_plr].Location.Width + 64)
                E = -1;
            else if(NPC[A].Location.X + NPC[A].Location.Width + 64 < Player[target_plr].Location.X)
                E = 1;

            if(NPC[A].Location.X + NPC[A].Location.Width + 150 > Player[target_plr].Location.X && NPC[A].Location.X - 150 < Player[target_plr].Location.X + Player[target_plr].Location.Width)
            {
                if(NPC[A].Location.Y > Player[target_plr].Location.Y + Player[target_plr].Location.Height)
                {

                    // If Player(C).Location.SpeedX + NPC(Player(C).StandingOnNPC).Location.SpeedX > 0 And .Location.X + .Location.Width / 2 > Player(C).Location.X + Player(C).Location.Width / 2 Then
                        // E = -D
                    // ElseIf Player(C).Location.SpeedX + NPC(Player(C).StandingOnNPC).Location.SpeedX <= 0 And .Location.X + .Location.Width / 2 < Player(C).Location.X + Player(C).Location.Width / 2 Then
                        E = -D;
                    // End If
                    if(NPC[A].Location.Y < Player[target_plr].Location.Y + Player[target_plr].Location.Height + 160)
                    {
                        if(NPC[A].Location.X + NPC[A].Location.Width + 100 > Player[target_plr].Location.X && NPC[A].Location.X - 100 < Player[target_plr].Location.X + Player[target_plr].Location.Width)
                            F_div = 5;
                    }
                }
                else
                {
                    E = D;
                    F_div = 1;
                }
            }

            num_t factor = (NPC[A].Wet == 2) ? 0.025_n : 0.05_n;
            if(behavior == WING_FLEE && min_dist < (g_config.fix_multiplayer_targeting ? 122500_n : 350_n))
                factor = -factor;

            NPC[A].Location.SpeedX += factor * E;
            NPC[A].Location.SpeedY += factor / F_div;

            if(NPC[A].Location.SpeedX > 4)
                NPC[A].Location.SpeedX = 4;
            else if(NPC[A].Location.SpeedX < -4)
                NPC[A].Location.SpeedX = -4;

            if(NPC[A].Location.SpeedY > 3)
                NPC[A].Location.SpeedY = 3;
            else if(NPC[A].Location.SpeedY < -3)
                NPC[A].Location.SpeedY = -3;
        }
    }
    else if(behavior == WING_JUMP)
    {
        NPC[A].Location.SpeedY += Physics.NPCGravity;

        if(NPC[A].Wings && NPC[A].Location.SpeedX)
        {
            if(NPC[A].Location.SpeedX < 0)
                NPC[A].Location.SpeedX = -Physics.NPCWalkingSpeed;
            else
                NPC[A].Location.SpeedX = Physics.NPCWalkingSpeed;
        }
        else
            NPC[A].Location.SpeedX = Physics.NPCWalkingSpeed * NPC[A].Direction;
    }
    else if(behavior == WING_LEFTRIGHT)
    {
        if(NPC[A].Wings)
        {
            if(NPC[A].Location.Y == NPC[A].DefaultLocationY && NPC[A].Location.SpeedY == 0)
                NPC[A].Location.SpeedY = 1;

            if(NPC[A].Location.Y > NPC[A].DefaultLocationY)
                NPC[A].Location.SpeedY -= 0.02_n;
            else if(NPC[A].Location.Y < NPC[A].DefaultLocationY)
                NPC[A].Location.SpeedY += 0.02_n;

            if(NPC[A].Location.SpeedY < -2)
                NPC[A].Location.SpeedY += Physics.NPCGravity;
            else if(num_t::abs(NPC[A].Location.SpeedY) >= 1)
                NPC[A].Location.SpeedY *= 0.9921875_rb;
        }
        else
        {
            if(NPC[A].Special3 == 0)
            {
                NPC[A].Location.SpeedY += 0.05_n;
                if(NPC[A].Location.SpeedY > 1)
                    NPC[A].Special3 = 1;
            }
            else
            {
                NPC[A].Location.SpeedY -= 0.05_n;
                if(NPC[A].Location.SpeedY < -1)
                    NPC[A].Special3 = 0;
            }
        }

        if(NPC[A].Location.X == NPC[A].DefaultLocationX && NPC[A].Location.SpeedX == 0)
            NPC[A].Location.SpeedX = 2 * NPC[A].Direction;
        if(NPC[A].Location.X < NPC[A].DefaultLocationX - 64)
            NPC[A].Location.SpeedX += 0.02_n;
        else if(NPC[A].Location.X > NPC[A].DefaultLocationX + 64)
            NPC[A].Location.SpeedX -= 0.02_n;
        else if(NPC[A].Direction == -1)
            NPC[A].Location.SpeedX -= 0.02_n;
        else if(NPC[A].Direction == 1)
            NPC[A].Location.SpeedX += 0.02_n;

        if(NPC[A].Location.SpeedX > 2)
            NPC[A].Location.SpeedX = 2;
        if(NPC[A].Location.SpeedX < -2)
            NPC[A].Location.SpeedX = -2;
    }
    else if(behavior == WING_UPDOWN)
    {
        NPC[A].Location.SpeedX = 0;

        if(NPC[A].Location.Y == NPC[A].DefaultLocationY && NPC[A].Location.SpeedY == 0)
            NPC[A].Location.SpeedY = 2 * NPC[A].Direction;
        if(NPC[A].Location.Y < NPC[A].DefaultLocationY - 64)
            NPC[A].Location.SpeedY += 0.02_n;
        else if(NPC[A].Location.Y > NPC[A].DefaultLocationY + 64)
            NPC[A].Location.SpeedY -= 0.02_n;
        else if(NPC[A].Location.SpeedY < 0)
            NPC[A].Location.SpeedY -= 0.02_n;
        else
            NPC[A].Location.SpeedY += 0.02_n;

        if(NPC[A].Location.SpeedY > 2)
            NPC[A].Location.SpeedY = 2;
        if(NPC[A].Location.SpeedY < -2)
            NPC[A].Location.SpeedY = -2;

        NPCFaceNearestPlayer(NPC[A], true);
    }

    if(NPC[A].Stuck && !NPC[A].Projectile)
        NPC[A].Location.SpeedX = 0;

    // slightly slower terminal falling velocity than normal (normal is 8)
    if(NPC[A].Location.SpeedY >= 6)
        NPC[A].Location.SpeedY = 6;

    // apply speed
    NPC[A].Location.X += NPC[A].Location.SpeedX.times(speedVar);
    NPC[A].Location.Y += NPC[A].Location.SpeedY;
    // deferring tree update to end of the NPC physics update
}


================================================
FILE: src/npc/npc_update/npc_special_maybe_held.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "npc.h"
#include "npc_traits.h"
#include "npc/npc_queues.h"
#include "npc/section_overlap.h"
#include "sound.h"
#include "effect.h"
#include "eff_id.h"
#include "config.h"
#include "collision.h"
#include "player.h"
#include "layers.h"
#include "blocks.h"
#include "graphics.h"
#include "player/player_update_priv.h"

#include "main/trees.h"

void NPCSpecialMaybeHeld(int A)
{
    // Special Code for things that work while held
    // perfectly factored by NPC Type
    if(NPC[A].Type == NPCID_BOMB) // SMB2 Bomb
    {
        // If .Location.SpeedX < -2 Or .Location.SpeedX > 2 Or .Location.SpeedY < -2 Or .Location.SpeedY > 5 Then .Projectile = True
        NPC[A].Special += 1;
        if(NPC[A].Special > 250)
            NPC[A].Special2 = 1;

        if(NPC[A].Special >= 350 || NPC[A].Special < 0)
        {
            Bomb(NPC[A].Location, 2);
            NPC[A].Killed = 9;
            NPCQueues::Killed.push_back(A);
        }
    }
    else if(NPC[A].Type == NPCID_WALK_BOMB_S2) // SMB2 Bob-om
    {
        NPC[A].Special += 1;
        if(NPC[A].Special > 450)
            NPC[A].Special2 = 1;
        if(NPC[A].Special >= 550 || NPC[A].Special < 0)
        {
            Bomb(NPC[A].Location, 2);
            NPC[A].Killed = 9;
            NPCQueues::Killed.push_back(A);
        }
    }
    else if(NPC[A].Type == NPCID_LIT_BOMB_S3) // SMB3 Bomb
    {
        if(!NPC[A].Inert)
            NPC[A].Special += 1;
        if(NPC[A].Special > 250)
            NPC[A].Special2 = 1;
        if(NPC[A].Special >= 350 || NPC[A].Special < 0)
            Bomb(NPC[A].Location, 3);
    }
    else if(NPC[A].Type == NPCID_SKELETON)
    {
        if(NPC[A].Special > 0)
        {
            NPC[A].Special2 += 1;
            if(NPC[A].Special2 >= 400 && NPC[A].Special3 == 0)
            {
                NPC[A].Special = 0;
                NPC[A].Special2 = 0;
                NPC[A].Inert = false;
                NPC[A].Stuck = false;
                NPC[A].Wings = NPC[A].DefaultWings;
            }
            else if(NPC[A].Special2 >= 300)
            {
                if(NPC[A].Special3 == 0)
                {
                    NPC[A].Location.X += 2;
                    NPC[A].Special3 = 1;
                }
                else
                {
                    NPC[A].Location.X -= 2;
                    NPC[A].Special3 = 0;
                }
            }
        }
    }
    else if(NPC[A].Type == NPCID_VILLAIN_S3) // smb3 bowser
    {
        // special5 - the player
        // special4 - what bowser is doing
        // special3 - counter for what bowser is doing
        // specialY - counter for what bowser needs to do (was Special2)
        if(NPC[A].Legacy)
        {
            if(NPC[A].TimeLeft > 1)
            {
                NPC[A].TimeLeft = 100;
                if(bgMusic[NPC[A].Section] != 21)
                {
                    bgMusic[NPC[A].Section] = 21;
                    StartMusicIfOnscreen(NPC[A].Section);
                }
            }
        }

        if(NPC[A].Special4 == 0)
        {
            NPC[A].Wings = NPC[A].DefaultWings;
            NPC[A].Special3 = 0; // reset counter when done
            if(NPC[A].Direction < 0)
                NPC[A].Frame = 0;
            else
                NPC[A].Frame = 5;
        }

        if(NPC[A].Special5 == 0) // find player
        {
            bool tempBool = false;
            for(int B = 1; B <= numPlayers; B++)
            {
                if(!Player[B].Dead && Player[B].TimeToLive == 0)
                    tempBool = true;
            }

            if(!tempBool)
            {
                NPC[A].Special5 = 0;
                NPC[A].Special4 = 2;
            }
            else
            {
                int B;
                do
                    B = iRand(numPlayers) + 1;
                while(Player[B].Dead || Player[B].TimeToLive > 0);
                NPC[A].Special5 = B;
            }
        }

        // see if facing the player
        // new: don't wait to face player if using wings movement
        bool tempBool = NPC[A].Wings;
        if(NPC[A].Special5 > 0)
        {
            if(NPC[A].Location.to_right_of(Player[NPC[A].Special5].Location))
            {
                if(NPC[A].Direction < 0)
                    tempBool = true;
            }
            else
            {
                if(NPC[A].Direction > 0)
                    tempBool = true;
            }
        }

        NPC[A].SpecialY += dRand();

        if(NPC[A].Special4 == 0 && tempBool)
        {
            num_t r1 = dRand();
            num_t r2 = dRand();
            if(NPC[A].SpecialY >= 200 + r1 * 400 - r2 * 200) // hop on player
            {
                if(NPC[A].SpecialY >= 200 + dRand() * 600)
                    NPC[A].SpecialY = 0;
                NPC[A].Special4 = 3;
            }
            // Even though this looks risky, it imposes strict sequencing semantics on the dRand() calls,
            // matching TheXTech's lifelong logic, and smbx-experiments' logic since 2021
            else if((NPC[A].SpecialY >= 80 && NPC[A].SpecialY <= 130) || (NPC[A].SpecialY >= 160 + dRand() * 300 && NPC[A].SpecialY <= 180 + dRand() * 800)) // shoot fireball
                NPC[A].Special4 = 4;
        }

        if(NPC[A].Inert)
        {
            if(NPC[A].Special4 == 4 || NPC[A].Special4 == 3)
                NPC[A].Special4 = 0;
        }

        if(NPC[A].Special4 == 0) // when not doing anything turn to player
        {
            if(!tempBool)
            {
                if(NPC[A].Direction > 0)
                    NPC[A].Special4 = -1;
                if(NPC[A].Direction < 0)
                    NPC[A].Special4 = 1;
            }
        }

        if(NPC[A].Special4 == 0) // hop
            NPC[A].Special4 = 2;

        if(NPC[A].HoldingPlayer > 0)
        {
            if(NPC[A].Direction == -1)
                NPC[A].Frame = 0;
            else
                NPC[A].Frame = 5;
            NPC[A].Special4 = 9000;
        }
        else if(NPC[A].Special4 == 9000)
        {
            NPC[A].Special5 = NPC[A].CantHurtPlayer;
            NPC[A].Special4 = 0;
            NPC[A].Location.SpeedX = 0;
            NPC[A].Location.SpeedY = 0;
        }

        if(NPC[A].Special4 == -1) // turn left
        {
            NPC[A].Special3 -= 1;
            if(NPC[A].Special3 > -5)
                NPC[A].Frame = 9;
            else if(NPC[A].Special3 > -10)
                NPC[A].Frame = 8;
            else if(NPC[A].Special3 > -15)
                NPC[A].Frame = 12;
            else if(NPC[A].Special3 > -20)
                NPC[A].Frame = 3;
            else if(NPC[A].Special3 > -25)
                NPC[A].Frame = 4;
            else
            {
                NPC[A].Special4 = 0;
                NPC[A].Direction = -1;
            }
        }
        else if(NPC[A].Special4 == 1) // turn right
        {
            NPC[A].Special3 += 1;
            if(NPC[A].Special3 < 5)
                NPC[A].Frame = 4;
            else if(NPC[A].Special3 < 10)
                NPC[A].Frame = 3;
            else if(NPC[A].Special3 < 15)
                NPC[A].Frame = 12;
            else if(NPC[A].Special3 < 20)
                NPC[A].Frame = 8;
            else if(NPC[A].Special3 < 25)
                NPC[A].Frame = 9;
            else
            {
                NPC[A].Special4 = 0;
                NPC[A].Direction = 1;
            }
        }
        else if(NPC[A].Special4 == -10) // look left
        {
            NPC[A].Special3 -= 1;
            if(NPC[A].Special3 > -5)
                NPC[A].Frame = 3;
            else if(NPC[A].Special3 > -10)
                NPC[A].Frame = 4;
            else
            {
                NPC[A].Special4 = 0;
                NPC[A].Direction = -1;
            }
        }
        else if(NPC[A].Special4 == 10) // look right
        {
            NPC[A].Special3 += 1;
            if(NPC[A].Special3 < 5)
                NPC[A].Frame = 8;
            else if(NPC[A].Special3 < 10)
                NPC[A].Frame = 9;
            else
            {
                NPC[A].Special4 = 0;
                NPC[A].Direction = 1;
            }
        }
        else if(NPC[A].Special4 == 2) // hops
        {
            if(NPC[A].Wings)
            {
                NPC[A].Special3 += 1;
                if(NPC[A].Special3 >= 10)
                    NPC[A].Special4 = 0;
            }
            else if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
            {
                if(NPC[A].Special3 < 5)
                {
                    NPC[A].Special3 += 1;
                    if(NPC[A].Direction < 0)
                        NPC[A].Frame = 1;
                    else
                        NPC[A].Frame = 6;
                }
                else if(NPC[A].Special3 == 5)
                {
                    NPC[A].Special3 += 1;
                    NPC[A].Location.SpeedY = -3;
                    NPC[A].Location.Y -= 0.1_n;
                    if(NPC[A].Direction < 0)
                        NPC[A].Frame = 0;
                    else
                        NPC[A].Frame = 5;
                }
                else if(NPC[A].Special3 < 10)
                {
                    NPC[A].Special3 += 1;
                    if(NPC[A].Direction < 0)
                        NPC[A].Frame = 1;
                    else
                        NPC[A].Frame = 6;
                }
                else
                    NPC[A].Special4 = 0;
            }
        }
        else if(NPC[A].Special4 == 3) // jump on player
        {
            if(NPC[A].Wings)
            {
                // -9 is jump speed, this means that the NPC is currently in its walking routine
                if(NPC[A].Wings != WING_JUMP || NPC[A].Location.SpeedY == -9)
                    NPC[A].Wings = WING_NONE;
            }
            else if(NPC[A].Special3 < -1)
            {
                if(NPC[A].Special > 1)
                    NPC[A].Special -= 1;
                NPC[A].Special3 += 1;
                if(NPC[A].Special3 == -1)
                    NPC[A].Special3 = 6;
            }
            else if(NPC[A].Special3 < 5)
            {
                NPC[A].Special3 += 1;
                if(NPC[A].Direction < 0)
                    NPC[A].Frame = 1;
                else
                    NPC[A].Frame = 6;
            }
            else if(NPC[A].Special3 == 5)
            {
                auto &sx = NPC[A].Location.SpeedX;
                auto &pl = Player[NPC[A].Special5].Location;
                NPC[A].Special3 += 1;
                NPC[A].Location.SpeedY = -12;
                NPC[A].BeltSpeed = 0;
                NPC[A].Location.Y -= 0.1_n;
                // This formula got been compacted: If something will glitch, feel free to restore back this crap
                // NPC[A].Location.SpeedX = (static_cast<int>(std::floor(static_cast<num_t>(((Player[NPC[A].Special5].Location.X + Player[NPC[A].Special5].Location.Width / 2 - 16) + 1) / 32))) * 32 + 1 - NPC[A].Location.X) / 50;
                num_t pCenter = pl.X + pl.Width / 2;
                sx = num_t::floor((pCenter - 15) / 32) * 32 + 1;
                sx -= NPC[A].Location.X;
                sx /= 50;
                if(sx > 15)
                    sx = 15;
                else if(sx < -15)
                    sx = -15;
                NPC[A].Special3 = -50;
                NPC[A].Special = 10;

                // reset direction if NPC normally has wings
                if(NPC[A].DefaultWings != WING_NONE)
                    NPC[A].Direction = (sx > 0) ? 1 : -1;

                if(NPC[A].Direction < 0)
                    NPC[A].Frame = 0;
                else
                    NPC[A].Frame = 5;
            }
            else if(NPC[A].Special3 == 6)
            {
                if(NPC[A].Location.SpeedY > 0)
                {
                    NPC[A].Frame = 10;
                    NPC[A].Location.SpeedX = 0;
                    NPC[A].Location.SpeedY = 0;
                    NPC[A].Special3 = 10;
                    NPC[A].Projectile = true;
                }
            }
            else if(NPC[A].Special3 < 13)
            {
                NPC[A].Location.SpeedY = -2;
                NPC[A].Special3 += 1;
            }
            else if(NPC[A].Special3 < 16)
            {
                NPC[A].Location.SpeedY = 2;
                NPC[A].Special3 += 1;
            }
            else if(NPC[A].Special3 < 19)
            {
                NPC[A].Location.SpeedY = -2;
                NPC[A].Special3 += 1;
            }
            else if(NPC[A].Special3 < 21)
            {
                NPC[A].Location.SpeedY = 2;
                NPC[A].Special3 += 1;
            }
            else if(NPC[A].Special3 == 21)
            {
                if(NPC[A].Location.SpeedY != 0)
                    NPC[A].Location.SpeedY = 10;
                else
                {
                    bool legacy = /*NPC[A].Legacy &&*/ (NPC[A].Variant == 1);
                    PlaySoundSpatial(SFX_Stone, NPC[A].Location);
                    NPC[A].Special3 = 30;
                    NPC[A].Frame = 11;
                    NPC[A].Projectile = false;
                    Location_t tempLocation = NPC[A].Location;

                    // Useless self-assignment code [PVS Studio]
                    //tempLocation.X = tempLocation.X; // + 16
                    //tempLocation.Width = tempLocation.Width; // - 32

                    tempLocation.Y += tempLocation.Height - 8;
                    tempLocation.Height = 16;
                    // fBlock = FirstBlock[long(NPC[A].Location.X / 32) - 1];
                    // lBlock = LastBlock[long((NPC[A].Location.X + NPC[A].Location.Width) / 32.0) + 1];
                    // blockTileGet(NPC[A].Location, fBlock, lBlock);

                    for(BlockRef_t block : treeFLBlockQuery(tempLocation, false))
                    {
                        int B = block;
                        if(Block[B].Type == 186 && CheckCollision(tempLocation, Block[B].Location) && !Block[B].Hidden)
                            SafelyKillBlock(B);
                    }

                    if(!legacy && g_config.extra_screen_shake)
                        doShakeScreen(0, 4, SHAKE_SEQUENTIAL, 7, 150, NPC[A].Location);

                    if(legacy) // Classic SMBX 1.0's behavior when Bowser stomps a floor
                    {
                        // fBlock = FirstBlock[long(level[NPC[A].Section].X / 32) - 1];
                        // lBlock = LastBlock[long((level[NPC[A].Section].Width) / 32.0) + 2];
                        // {
                        //     auto &sec = level[NPC[A].Section];
                        //     Location_t toShake;
                        //     toShake.X = sec.X;
                        //     toShake.Width = (sec.Width - sec.X);
                        //     blockTileGet(toShake, fBlock, lBlock);
                        // }

                        // Shake all blocks up
                        // for(int B = (int)fBlock; B <= lBlock; B++)
                        //     BlockShakeUp(B);
                        {
                            const auto &sec = level[NPC[A].Section];
                            Location_t toShake;
                            toShake.X = sec.X;
                            toShake.Width = (sec.Width - sec.X);
                            toShake.Y = sec.Y;
                            toShake.Height = (sec.Height - sec.Y);
                            for(BlockRef_t block : treeFLBlockQuery(toShake, false))
                            {
                                int B = block;
                                BlockShakeUp(B);
                            }
                        }

                        // expand down a section at the bottom of destroyed blocks
                        for(int B = 0; B < numSections; B++)
                        {
                            auto &n = NPC[A];
                            auto &s = level[B];

                            if(n.Location.X >= s.X &&
                               n.Location.X + n.Location.Width <= s.Width &&
                               n.Location.Y + n.Location.Height + 48 >= s.Y &&
                               n.Location.Y + n.Location.Height + 48 <= s.Height &&
                               B != n.Section)
                            {
                                n.SpecialY = 0;
                                n.Special3 = 0;
                                n.Special4 = 2;

                                auto &ns = level[n.Section];
                                if(s.X < ns.X)
                                    ns.X = s.X;
                                if(s.Y < ns.Y)
                                    ns.Y = s.Y;
                                if(s.Width > ns.Width)
                                    ns.Width = s.Width;
                                if(s.Height > ns.Height)
                                    ns.Height = s.Height;

                                s.X = 0;
                                s.Y = 0;
                                s.Width = 0;
                                s.Height = 0;

                                UpdateSectionOverlaps(B);
                                UpdateSectionOverlaps(n.Section);

                                for(int C = 1; C <= numNPCs; C++)
                                {
                                    auto &nc = NPC[C];
                                    if(nc.Section == B)
                                        nc.Section = n.Section;
                                }
                            }
                        } // for
                        SoundPause[SFX_Stomp] = 12;
                    }
                }
            }
            else if(NPC[A].Special3 < 35)
            {
                NPC[A].Frame = 11;
                NPC[A].Special3 += 1;
            }
            else if(NPC[A].Special3 < 40)
            {
                NPC[A].Frame = 12;
                NPC[A].Special3 += 1;
                NPC[A].Special5 = 0;
            }
            else
            {
                if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
                {
                    NPC[A].Special3 = 0;
                    if(NPC[A].Location.to_right_of(Player[NPC[A].Special5].Location))
                        NPC[A].Special4 = -10;
                    else
                        NPC[A].Special4 = 10;
                }
            }
        }
        else if(NPC[A].Special4 == 4) // shoot a fireball
        {
            NPC[A].Special3 += 1;
            if(NPC[A].Special3 < 15)
            {
                if(NPC[A].Direction < 0)
                    NPC[A].Frame = 13;
                else
                    NPC[A].Frame = 14;
            }
            else if(NPC[A].Special3 < 30)
            {
                if(NPC[A].Direction < 0)
                    NPC[A].Frame = 2;
                else
                    NPC[A].Frame = 7;

                if(NPC[A].Special3 == 29)
                {
                    numNPCs++;
                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].TimeLeft = 100;
                    NPC[numNPCs].Direction = NPC[A].Direction;
                    NPC[numNPCs].Section = NPC[A].Section;
                    NPC[numNPCs].Type = NPCID_VILLAIN_FIRE;
                    if(NPC[numNPCs].Direction > 0)
                        NPC[numNPCs].Frame = 4;
                    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                    if(NPC[numNPCs].Direction < 0)
                        NPC[numNPCs].Location.X = NPC[A].Location.X - 40;
                    else
                        NPC[numNPCs].Location.X = NPC[A].Location.X + 54;
                    NPC[numNPCs].Location.Y = NPC[A].Location.Y + 19;

                    NPCSetSpeedTarget_FixedX(NPC[numNPCs], Player[NPC[A].Special5].Location, 4, 1);

                    syncLayers_NPC(numNPCs);
                    PlaySoundSpatial(SFX_BigFireball, NPC[A].Location);
                }
            }
            else if(NPC[A].Special3 < 45)
            {
                if(NPC[A].Direction == -1)
                    NPC[A].Frame = 0;
                else
                    NPC[A].Frame = 5;
            }
            else
                NPC[A].Special4 = 0;
        }
    }
    else if(NPC[A].Type == NPCID_HEAVY_THROWER)
    {
        if(NPC[A].HoldingPlayer > 0)
        {
            // the throw counter was previously Special3, but it uses a double in the non-held logic, so it has been moved to SpecialX
            if(Player[NPC[A].HoldingPlayer].Effect == PLREFF_NORMAL)
                NPC[A].SpecialX += 1;

            if(NPC[A].SpecialX >= 20)
            {
                PlaySoundSpatial(SFX_HeavyToss, NPC[A].Location);
                NPC[A].SpecialX = 0; // -15
                numNPCs++;
                NPC[numNPCs].Location.Height = 32;
                NPC[numNPCs].Location.Width = 32;
                NPC[numNPCs].Location.X = NPC[A].Location.X;
                NPC[numNPCs].Location.Y = NPC[A].Location.Y;
                NPC[numNPCs].Direction = NPC[A].Direction;
                NPC[numNPCs].Type = NPCID_HEAVY_THROWN;
                NPC[numNPCs].Shadow = NPC[A].Shadow;
                NPC[numNPCs].CantHurt = 200;
                NPC[numNPCs].CantHurtPlayer = NPC[A].HoldingPlayer;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].Projectile = true;
                NPC[numNPCs].TimeLeft = 50;
                NPC[numNPCs].Location.SpeedY = -8;
                NPC[numNPCs].Location.SpeedX = 3 * Player[NPC[A].HoldingPlayer].Direction + Player[NPC[A].HoldingPlayer].Location.SpeedX * 0.8_r;
                syncLayers_NPC(numNPCs);
            }
        }
    }
    else if(NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_CANNONITEM) // Bullet Bill Shooter
    {
        if(NPC[A].Type == NPCID_CANNONENEMY)
        {
            NPC[A].Special += 1;
            if(NPC[A].HoldingPlayer > 0)
            {
                if(Player[NPC[A].HoldingPlayer].Effect == PLREFF_NORMAL)
                    NPC[A].Special += 6;
            }
        }
        else
        {
            int shootStep = 10;
            int shootStepSpin = 20;
            int shootStepCar = 5;
            bool keepProjectile = false;

            int shootBehavior = NPC[A].Variant;

            switch(shootBehavior)
            {
            default:
            case 0:
                // SMBX 1.2.1 and newer (shoot fast, don't shoot while projectile)
                break;
            case 1:
                // SMBX 1.2 (shoot fast, keep shoot while projectile)
                keepProjectile = true;
                break;
            case 2:
                // SMBX older than 1.2 (shoot slow, keep shoot while projectile)
                keepProjectile = true;
                shootStep = 5;
                shootStepSpin = 10;
                break;
            }

            if(NPC[A].HoldingPlayer > 0)
            {
                if(Player[NPC[A].HoldingPlayer].SpinJump)
                {
                    if(NPC[A].Direction != Player[NPC[A].HoldingPlayer].SpinFireDir)
                    {
                        if(Player[NPC[A].HoldingPlayer].Effect == PLREFF_NORMAL)
                            NPC[A].Special += shootStepSpin;
                    }
                }
                else
                {
                    if(Player[NPC[A].HoldingPlayer].Effect == PLREFF_NORMAL)
                        NPC[A].Special += shootStep;
                }
            }
            else if(NPC[A].vehiclePlr > 0)
                NPC[A].Special += shootStepCar;
            else if(NPC[A].Projectile && keepProjectile)
                NPC[A].Special += shootStep;
        }

        if(NPC[A].Special >= 200)
        {
            bool can_come_out = true;

            if(NPC[A].HoldingPlayer > 0)
            {
                if(Player[NPC[A].HoldingPlayer].SpinJump)
                    Player[NPC[A].HoldingPlayer].SpinFireDir = int(NPC[A].Direction);
            }

            if(NPC[A].HoldingPlayer == 0 && NPC[A].vehiclePlr == 0 && NPC[A].Type == NPCID_CANNONENEMY)
            {
                num_t C = 0;
                for(int B = 1; B <= numPlayers; B++)
                {
                    if(!Player[B].Dead && Player[B].Section == NPC[A].Section)
                    {
                        num_t dist = NPCPlayerTargetDist(NPC[A], Player[B]);
                        if(C == 0 || dist < C)
                        {
                            C = dist;
                            if(NPC[A].Location.to_right_of(Player[B].Location))
                                NPC[A].Direction = -1;
                            else
                                NPC[A].Direction = 1;

                            if(!CanComeOut(NPC[A].Location, Player[B].Location))
                                can_come_out = false;
                        }
                    }
                }
            }

            if(numNPCs < maxNPCs)
            {
                if(!can_come_out)
                    NPC[A].Special = 0;
                else if(Player[NPC[A].vehiclePlr].Controls.Run || NPC[A].vehiclePlr == 0)
                {
                    NPC[A].Special = 0;
                    numNPCs++;
                    NPC[numNPCs].Inert = NPC[A].Inert;
                    bool tempBool = false;
                    NPC[numNPCs].Direction = NPC[A].Direction;
                    NPC[numNPCs].DefaultDirection = NPC[A].Direction;
                    if(NPC[A].HoldingPlayer > 0 || NPC[A].vehiclePlr > 0 || (NPC[A].Type == NPCID_CANNONITEM && NPC[A].Projectile))
                    {
                        NPC[numNPCs].Projectile = true;
                        NPC[numNPCs].CantHurt = 10000;
                        NPC[numNPCs].CantHurtPlayer = NPC[A].HoldingPlayer;
                        NPC[numNPCs].Location.SpeedX = 8 * NPC[numNPCs].Direction;
                    }
                    else if(NPC[A].CantHurtPlayer > 0)
                    {
                        NPC[numNPCs].Projectile = true;
                        NPC[numNPCs].CantHurt = 1000;
                        NPC[numNPCs].CantHurtPlayer = NPC[A].CantHurtPlayer;
                    }
                    else if(NPC[A].Type == NPCID_CANNONITEM)
                    {
                        tempBool = true;
                        numNPCs--;
                    }

                    if(!tempBool)
                    {
                        NPC[numNPCs].Shadow = NPC[A].Shadow;
                        NPC[numNPCs].Active = true;
                        NPC[numNPCs].TimeLeft = 100;
                        NPC[numNPCs].JustActivated = 0;
                        NPC[numNPCs].Section = NPC[A].Section;
                        NPC[numNPCs].Type = NPCID_BULLET;
                        NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                        NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;

                        if(NPC[numNPCs].Direction > 0)
                            NPC[numNPCs].Location.X = NPC[A].Location.X + NPC[A].Location.Width / 2;
                        else
                            NPC[numNPCs].Location.X = NPC[A].Location.X + NPC[A].Location.Width / 2 - NPC[numNPCs].Location.Width;

                        if(NPC[numNPCs].Direction > 0)
                            NPC[numNPCs].Frame = 1;
                        else
                            NPC[numNPCs].Frame = 0;
                        NPC[numNPCs].Location.Y = NPC[A].Location.Y + (NPC[A].Location.Height - NPC[numNPCs].Location.Height) / 2;

                        if(NPC[A].HoldingPlayer)
                            PlayerThrownNpcMazeCheck(Player[NPC[A].HoldingPlayer], NPC[numNPCs]);

                        syncLayers_NPC(numNPCs);

                        Location_t tempLocation;
                        tempLocation.X = NPC[numNPCs].Location.X + (NPC[numNPCs].Location.Width / 2) * NPC[numNPCs].Direction;
                        tempLocation.Y = NPC[numNPCs].Location.Y + NPC[numNPCs].Location.Height / 2 - EffectHeight[EFFID_SMOKE_S3] / 2;
                        NewEffect(EFFID_SMOKE_S3, tempLocation);

                        PlaySoundSpatial(SFX_Bullet, NPC[A].Location);
                    }
                }
            }
        }
    }
    else if(NPC[A].Type == NPCID_TOOTHY)
    {
        int B = 0;
        if(NPC[A].Special > 0)
        {
            if(Player[NPC[A].Special].HoldingNPC > 0)
            {
                if(NPC[Player[NPC[A].Special].HoldingNPC].Type == 49)
                    B = 1;
            }
        }
        else if(NPC[NPC[A].Special2].Projectile && NPC[NPC[A].Special2].Active)
        {
            B = 1;
            NPC[A].Projectile = true;
            NPC[A].Direction = NPC[NPC[A].Special2].Direction;
            if(NPC[A].Direction > 0)
                NPC[A].Location.X = NPC[NPC[A].Special2].Location.X + 32;
            else
                NPC[A].Location.X = NPC[NPC[A].Special2].Location.X - NPC[A].Location.Width;
            NPC[A].Location.Y = NPC[NPC[A].Special2].Location.Y;
        }

        if(Player[NPC[A].vehiclePlr].Controls.Run)
            B = 1;

        if(NPC[A].Special2 > 0 && NPC[NPC[A].Special2].Special2 != A)
            B = 0;

        if(NPC[A].Special > 0)
        {
            if(Player[NPC[A].Special].Effect != PLREFF_NORMAL)
                B = 0;
        }

        if(B == 0)
        {
            NPC[A].Killed = 9;
            NPCQueues::Killed.push_back(A);
        }
    }
    else if(NPC[A].Type == NPCID_TOOTHYPIPE)
    {
        if(NPC[A].HoldingPlayer == 0 && NPC[A].vehiclePlr == 0)
            NPC[A].Special = 0;

        if(NPC[A].HoldingPlayer > 0 && NPC[A].Special2 > 0)
            NPC[NPC[A].Special2].Direction = NPC[A].Direction;

        if(Player[NPC[A].HoldingPlayer].Effect != PLREFF_NORMAL)
            NPC[A].Special = 0;
#if 0
        // Important: this also makes a thrown handheld plant harm NPCs, so it is a major balance change.
        // Since it was disabled in SMBX code, better not to change it. -- ds-sloth
        // In original game, this is a dead code because of "And 0" condition at end.
        // In this sample, the "& false" was been commented
        // This code makes Toothy shown off the pipe when the pipe is a projectile, shooted by generator
        if(NPC[A].Projectile && NPC[A].Special2 == 0 && NPC[A].Special == 0 /*&& false*/)
        {
            numNPCs++;
            NPC[A].Special2 = numNPCs;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].Section = NPC[A].Section;
            NPC[numNPCs].TimeLeft = 100;
            NPC[numNPCs].Type = NPCID_TOOTHY;
            NPC[numNPCs].Location.Height = 32;
            NPC[numNPCs].Location.Width = 48;
            NPC[numNPCs].Special = 0;
            NPC[numNPCs].Special2 = A;
            NPC[numNPCs].Projectile = true;
            NPC[numNPCs].Direction = NPC[A].Direction;
            if(NPC[numNPCs].Direction > 0)
            {
                NPC[numNPCs].Location.X = NPC[A].Location.X + 32;
                NPC[numNPCs].Frame = 2;
            }
            else
                NPC[numNPCs].Location.X = NPC[A].Location.X - NPC[numNPCs].Location.Width;
            NPC[numNPCs].Location.Y = NPC[A].Location.Y;
            syncLayers_NPC(numNPCs);
        }
#endif

        if(NPC[NPC[A].Special2].Type == NPCID_TOOTHY && NPC[NPC[A].Special2].Special2 == A)
        {
            NPC[NPC[A].Special2].Projectile = true;
            NPC[NPC[A].Special2].Direction = NPC[A].Direction;
            if(NPC[A].Direction > 0)
                NPC[NPC[A].Special2].Location.X = NPC[A].Location.X + 32;
            else
                NPC[NPC[A].Special2].Location.X = NPC[A].Location.X - NPC[NPC[A].Special2].Location.Width;
            NPC[NPC[A].Special2].Location.Y = NPC[A].Location.Y;

            treeNPCUpdate(NPC[A].Special2);
            if(NPC[NPC[A].Special2].tempBlock != 0)
                treeNPCSplitTempBlock(NPC[A].Special2);
        }

        if(NPC[A].vehiclePlr > 0 && !Player[NPC[A].vehiclePlr].Controls.Run)
            NPC[A].Special = 0;
    }
    else if(NPC[A].Type == NPCID_KEY)
    {
        if(NPC[A].HoldingPlayer > 0)
            KeyholeCheck(NPC[A].HoldingPlayer, NPC[A].Location);
    }
    else if(NPCIsABot(NPC[A]))
    {
        if(NPC[A].Projectile || NPC[A].HoldingPlayer > 0)
        {
            NPC[A].Special = -1;
            NPC[A].Special2 = 0;
            NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.98_r;
        }
        else
        {
            if(NPC[A].Special == 0)
            {
                int target_plr = NPCTargetPlayer(NPC[A]);

                if(target_plr == 0)
                    target_plr = 1;

                if(Player[target_plr].Location.X + Player[target_plr].Location.Width / 2 > NPC[A].Location.X + 16)
                    NPC[A].Direction = 1;
                else
                    NPC[A].Direction = -1;
            }

            if(NPC[A].Location.SpeedY == 0 || NPC[A].Slope > 0)
            {
                NPC[A].Location.SpeedX = 0;

                if(NPC[A].Special == 0)
                    NPC[A].Special = iRand(3) + 1;

                if(NPC[A].Special == 1)
                {
                    NPC[A].FrameCount += 1;
                    NPC[A].Special2 += 1;
                    NPC[A].Location.SpeedX = 0;
                    if(NPC[A].Special2 >= 90)
                    {
                        NPC[A].Special2 = 0;
                        NPC[A].Special = -1;
                        NPC[A].Location.SpeedY = -7;
                        NPC[A].Location.SpeedX = 2 * NPC[A].Direction;
                    }
                }
                else if(NPC[A].Special == 3)
                {
                    NPC[A].FrameCount += 1;
                    NPC[A].Special2 += 30;
                    NPC[A].Location.SpeedX = 0;
                    if(NPC[A].Special2 >= 30)
                    {
                        NPC[A].Special2 = 0;
                        NPC[A].Special = -1;
                        NPC[A].Location.SpeedY = -3;
                        NPC[A].Location.SpeedX = 2.5_n * NPC[A].Direction;
                    }
                }
                else if(NPC[A].Special == 2)
                {
                    NPC[A].Location.SpeedX = 0.5_n * NPC[A].Direction;
                    NPC[A].Special2 += 1;
                    if(NPC[A].Special2 == 120)
                    {
                        NPC[A].Special2 = 0;
                        NPC[A].Special = -2;
                    }
                }
                else
                {
                    NPC[A].Special2 += 1;
                    if(NPC[A].Special2 == 30)
                    {
                        NPC[A].Special2 = 0;
                        NPC[A].Special = 0;
                    }
                }
            }
        }
    }
}


================================================
FILE: src/npc/npc_update/npc_update_priv.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef NPC_UPDATE_PRIV_H
#define NPC_UPDATE_PRIV_H

#include "numeric_types.h"

struct NPC_t;

// most of these routines were originally part of UpdateNPCs
void NPCMovementLogic(int A, tempf_t& speedVar);

void NPCMovementLogic_Wings(int A, const num_t speedVar);

void NPCSectionWrap(NPC_t& npc);

void NPCBlockLogic(int A, num_t& tempHit, int& tempHitBlock, tempf_t& tempSpeedA, const int numTempBlock, const tempf_t speedVar);

void NPCCollide(int A);

void NPCCollideHeld(int A);

void NPCWalkingLogic(int A, const num_t tempHit, const int tempHitBlock, tempf_t tempSpeedA);

void NPCEffects(int A);

void NPCSpecialMaybeHeld(int A);

void NPCActivationLogic(int A);

// returns true if an NPC should be generated
bool NPCGeneratorLogic(int A);
// does NOT call the activation event (because that requires safe ProcEvent handling)
void NPCGeneratorMakeNew(int A);

#endif // NPC_UPDATE_PRIV_H


================================================
FILE: src/npc/npc_update/npc_walking_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "npc.h"
#include "npc_traits.h"
#include "config.h"
#include "collision.h"

#include "main/trees.h"

void NPCWalkingLogic(int A, const num_t tempHit, const int tempHitBlock, tempf_t tempSpeedA)
{
    // tempSpeedA does not check for walking collisions in vanilla
    if(g_config.fix_npc_downward_clip)
    {
        tempSpeedA = (tempf_t)Block[tempHitBlock].Location.SpeedY;
        if(tempSpeedA < 0)
            tempSpeedA = 0;
    }

    if(NPC[A].Wings)
    {
        if(NPC[A].Wings == WING_JUMP)
            NPC[A].Location.SpeedY = -9;
        else
        {
            if(NPC[A].Location.SpeedY > 0)
                NPC[A].Location.SpeedY = -NPC[A].Location.SpeedY;
        }
    }
    else if(NPC[A].Type == NPCID_RED_FLY_FODDER) // Walking code for Flying Goomba
    {
        if(NPC[A].Special <= 30)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = 0;

            if(NPC[A].Slope > 0)
            {
                NPC[A].Location.SpeedY = NPC[A].Location.SpeedX * (int_ok)Block[NPC[A].Slope].Location.Height / (int_ok)Block[NPC[A].Slope].Location.Width * BlockSlope[Block[NPC[A].Slope].Type];
                if(NPC[A].Location.SpeedY < 0)
                    NPC[A].Location.SpeedY = 0;
            }

            if(tempSpeedA != 0)
                NPC[A].Location.SpeedY = (num_t)tempSpeedA;
        }
        else if(NPC[A].Special == 31)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -4;
        }
        else if(NPC[A].Special == 32)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -4;
        }
        else if(NPC[A].Special == 33)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -4;
        }
        else if(NPC[A].Special == 34)
        {
            NPC[A].Special = 0;
            NPC[A].Location.SpeedY = -7;
        }
    }
    else if(NPC[A].Type == NPCID_FLY_CARRY_FODDER) // Walking code for SMW Flying Goomba
    {
        if(NPC[A].Special <= 60)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = 0;

            if(NPC[A].Slope > 0)
            {
                NPC[A].Location.SpeedY = NPC[A].Location.SpeedX * (int_ok)Block[NPC[A].Slope].Location.Height / (int_ok)Block[NPC[A].Slope].Location.Width * BlockSlope[Block[NPC[A].Slope].Type];
                if(NPC[A].Location.SpeedY < 0)
                    NPC[A].Location.SpeedY = 0;
            }

            if(tempSpeedA != 0)
                NPC[A].Location.SpeedY = (num_t)tempSpeedA;
        }
        else if(NPC[A].Special == 61)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -3;
        }
        else if(NPC[A].Special == 62)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -3;
        }
        else if(NPC[A].Special == 63)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -3;
        }
        else if(NPC[A].Special == 64)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -3;
        }
        else if(NPC[A].Special == 65)
        {
            NPC[A].Special = 0;
            NPC[A].Location.SpeedY = -7;
        }
    }
    else if(NPC[A]->TurnsAtCliffs && !NPC[A].Projectile) // Walking code NPCs that turn
    {
        bool tempTurn = true; // used for turning the npc around
        Location_t tempLocation = NPC[A].Location;
        tempLocation.SpeedX = 0;
        tempLocation.SpeedY = 0;
        tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - 8;
        tempLocation.Height = 16;
        if(NPC[A].Slope > 0)
            tempLocation.Height = 32;
        tempLocation.Width = 16;

        bool isPokeyHead = (NPC[A].Type == NPCID_STACKER && NPC[A].Special2 == 0);

        // If .Location.SpeedX > 0 Then
        if(NPC[A].Direction > 0)
        {
            tempLocation.X += NPC[A].Location.Width - 20;
            if(isPokeyHead)
                tempLocation.X += 16;
            // If .Type = 189 Then tempLocation.X += -10
        }
        else
        {
            tempLocation.X += -tempLocation.Width + 20;
            if(isPokeyHead)
                tempLocation.X -= 16;
            // If .Type = 189 Then tempLocation.X += 10
        }

        for(int bCheck2 = 1; bCheck2 <= 2; bCheck2++)
        {
            // if(bCheck2 == 1)
            // {
            //     // fBlock2 = FirstBlock[(tempLocation.X / 32) - 1];
            //     // lBlock2 = LastBlock[((tempLocation.X + tempLocation.Width) / 32.0) + 1];
            //     blockTileGet(tempLocation, fBlock2, lBlock2);
            // }
            // else
            // {
            //     fBlock2 = numBlock - numTempBlock;
            //     lBlock2 = numBlock;
            // }
            auto collBlockSentinel2 = (bCheck2 == 1)
                ? treeFLBlockQuery(tempLocation, SORTMODE_NONE)
                : treeTempBlockQuery(tempLocation, SORTMODE_NONE);

            for(BlockRef_t block : collBlockSentinel2)
            {
                int B = block;
                //If BlockNoClipping(Block(B).Type) = False And Block(B).Invis = False And Block(B).Hidden = False And Not (BlockIsSizable(Block(B).Type) And Block(B).Location.Y < .Location.Y + .Location.Height - 3) Then

                // Don't collapse Pokey during walking on slopes and other touching surfaces
                if(g_config.fix_npc247_collapse && isPokeyHead && Block[B].tempBlockNpcType != NPCID_STACKER)
                    continue;

                if((tempLocation.X + tempLocation.Width >= Block[B].Location.X) &&
                   (tempLocation.X <= Block[B].Location.X + Block[B].Location.Width) &&
                   (tempLocation.Y + tempLocation.Height >= Block[B].Location.Y) &&
                   (tempLocation.Y <= Block[B].Location.Y + Block[B].Location.Height) &&
                   (!BlockNoClipping[Block[B].Type] && !Block[B].Invis && !Block[B].Hidden && !(BlockIsSizable[Block[B].Type] && Block[B].Location.Y < NPC[A].Location.Y + NPC[A].Location.Height - 3)))
                {
                    // If CheckCollision(tempLocation, Block(B).Location) = True Then
                    tempTurn = false;
                    break;
                    // End If
                }
                else
                {
                    // not working
                }

                // End If
            }

            if(!tempTurn)
                break;
        }

        if(tempTurn)
            NPC[A].TurnAround = true;

        NPC[A].Location.SpeedY = 0;
        if(NPC[A].Slope > 0)
        {
            NPC[A].Location.SpeedY = NPC[A].Location.SpeedX * (int_ok)Block[NPC[A].Slope].Location.Height / (int_ok)Block[NPC[A].Slope].Location.Width * BlockSlope[Block[NPC[A].Slope].Type];
            if(NPC[A].Location.SpeedY < 0)
                NPC[A].Location.SpeedY = 0;
        }

        if(tempSpeedA != 0)
            NPC[A].Location.SpeedY = (num_t)tempSpeedA;
    }
    else if(NPC[A].Type == NPCID_JUMPER_S4) // ninja code
    {
        bool tempTurn = true; // used for turning the npc around

        Location_t tempLocation = NPC[A].Location;
        tempLocation.SpeedX = 0;
        tempLocation.SpeedY = 0;
        tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - 8;
        tempLocation.Height = 16;

        if(NPC[A].Slope > 0)
            tempLocation.Height = 32;

        tempLocation.Width = 16;

        if(NPC[A].Location.SpeedX > 0)
            tempLocation.X = NPC[A].Location.X + NPC[A].Location.Width - 16;
        else
            tempLocation.X = NPC[A].Location.X - tempLocation.Width + 16;

        for(int bCheck2 = 1; bCheck2 <= 2; bCheck2++)
        {
            // if(bCheck2 == 1)
            // {
            //     // fBlock2 = FirstBlock[(tempLocation.X / 32) - 1];
            //     // lBlock2 = LastBlock[((tempLocation.X + tempLocation.Width) / 32.0) + 1];
            //     blockTileGet(tempLocation, fBlock2, lBlock2);
            // }
            // else
            // {
            //     fBlock2 = numBlock - numTempBlock;
            //     lBlock2 = numBlock;
            // }
            auto collBlockSentinel2 = (bCheck2 == 1)
                ? treeFLBlockQuery(tempLocation, SORTMODE_NONE)
                : treeTempBlockQuery(tempLocation, SORTMODE_NONE);

            for(BlockRef_t block : collBlockSentinel2)
            {
                int B = block;
                if(!BlockNoClipping[Block[B].Type] && !Block[B].Invis && !Block[B].Hidden && !(BlockIsSizable[Block[B].Type] && Block[B].Location.Y < NPC[A].Location.Y + NPC[A].Location.Height - 3))
                {
                    if(CheckCollision(tempLocation, Block[B].Location))
                    {
                        tempTurn = false;
                        break;
                    }
                }

                if(!tempTurn)
                    break;
            }
        }

        tempLocation = NPC[A].Location;
        tempLocation.SpeedX = 0;
        tempLocation.SpeedY = 0;
        tempLocation.Y = NPC[A].Location.Y + 8;
        tempLocation.Height -= 16;
        tempLocation.Width = 32;
        if(NPC[A].Location.SpeedX > 0)
            tempLocation.X = NPC[A].Location.X + NPC[A].Location.Width;
        else
            tempLocation.X = NPC[A].Location.X - tempLocation.Width;

        // we are able to wrap this whole thing in the inner-loop check that (NPC[A].Slope <= 0)
        // commenting for now to avoid inadvertently introducing any bugs
        // if(NPC[A].Slope <= 0)
        for(int bCheck2 = 1; bCheck2 <= 2; bCheck2++)
        {
            // if(bCheck2 == 1)
            // {
            //     // fBlock2 = FirstBlock[(tempLocation.X / 32) - 1];
            //     // lBlock2 = LastBlock[((tempLocation.X + tempLocation.Width) / 32.0) + 1];
            //     blockTileGet(tempLocation, fBlock2, lBlock2);
            // }
            // else
            // {
            //     fBlock2 = numBlock - numTempBlock;
            //     lBlock2 = numBlock;
            // }
            auto collBlockSentinel2 = (bCheck2 == 1)
                ? treeFLBlockQuery(tempLocation, SORTMODE_NONE)
                : treeTempBlockQuery(tempLocation, SORTMODE_NONE);

            for(BlockRef_t block : collBlockSentinel2)
            {
                int B = block;
                if(!BlockNoClipping[Block[B].Type] && !Block[B].Invis && !Block[B].Hidden && !(BlockIsSizable[Block[B].Type] && Block[B].Location.Y < NPC[A].Location.Y + NPC[A].Location.Height - 1))
                {
                    if(CheckCollision(tempLocation, Block[B].Location))
                    {
                        if(NPC[A].Slope > 0)
                        {

                        }
                        else if(BlockSlope[Block[B].Type] == 0)
                            tempTurn = true;
                        break;
                    }
                }

                if(tempTurn)
                    break;
            }
        }

        if(tempTurn)
        {
            NPC[A].Location.Y -= 0.1_n;
            NPC[A].Location.SpeedY = -6.55_n;
        }
        else
        {
            NPC[A].Location.SpeedY = 0;
            if(NPC[A].Slope > 0)
            {
                NPC[A].Location.SpeedY = NPC[A].Location.SpeedX * (int_ok)Block[NPC[A].Slope].Location.Height / (int_ok)Block[NPC[A].Slope].Location.Width * BlockSlope[Block[NPC[A].Slope].Type];
                if(NPC[A].Location.SpeedY < 0)
                    NPC[A].Location.SpeedY = 0;
            }
        }

        if(tempSpeedA != 0)
            NPC[A].Location.SpeedY += (num_t)tempSpeedA;
    }
    else // Walking code for everything else
    {
        if(NPCIsAParaTroopa(NPC[A]))
        {
            if(NPC[A].Special == WING_JUMP)
                NPC[A].Location.SpeedY = -9;
            else
            {
                if(NPC[A].Location.SpeedY > 0)
                    NPC[A].Location.SpeedY = -NPC[A].Location.SpeedY;
            }
        }
        else
        {
            NPC[A].Location.SpeedY = 0;
            if(NPC[A].Slope > 0 && !NPC[A]->IsAShell && NPC[A].Type != NPCID_SLIDE_BLOCK)
            {
                NPC[A].Location.SpeedY = NPC[A].Location.SpeedX * (int_ok)Block[NPC[A].Slope].Location.Height / (int_ok)Block[NPC[A].Slope].Location.Width * BlockSlope[Block[NPC[A].Slope].Type];
                if(NPC[A].Location.SpeedY < 0)
                    NPC[A].Location.SpeedY = 0;
            }
        }

        if(NPC[A].Type == NPCID_BIRD)
        {
            NPC[A].Special += 1;
            if(NPC[A].Special <= 3)
                NPC[A].Location.SpeedY = -3.5_n;
            else
            {
                NPC[A].Location.SpeedY = -5.5_n;
                NPC[A].Special = 0;
            }
        }

        if(NPC[A].Type == NPCID_KNIGHT)
        {
            NPC[A].FrameCount += 1;
            if(NPC[A].FrameCount > 1)
                NPC[A].FrameCount = 0;
            NPC[A].Location.SpeedY = -3;
        }

        if(NPC[A].Type == NPCID_INVINCIBILITY_POWER)
            NPC[A].Location.SpeedY = -6_n;

        if(tempSpeedA != 0)
            NPC[A].Location.SpeedY = (num_t)tempSpeedA;

        // assigned to Special in SMBX 1.3
        if(NPC[A].Type == NPCID_SAW)
            NPC[A].SpecialY = NPC[A].Location.SpeedY;
    }

    if(NPC[A].Slope == 0)
        NPC[A].Location.Y = tempHit;

#if 0
    tempHit = 0;
    tempHitBlock = 0;

    // impossible
    if(Block[tempHitBlock].tempBlockNpcType > 0 && NPC[Block[tempHitBlock].tempBlockNpcIdx].Slope > 0)
    {
        // .Location.SpeedY = 0
        NPC[A].Slope = NPC[Block[tempHitBlock].tempBlockNpcIdx].Slope;
        // Stop
    }
#endif
}


================================================
FILE: src/npc/npc_update.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>
#include <array>

#include <Logger/logger.h>

#include "sdl_proxy/sdl_stdinc.h"

#include "../globals.h"
#include "../npc.h"
#include "player.h"
#include "../sound.h"
#include "../graphics.h"
#include "../collision.h"
#include "../effect.h"
#include "../layers.h"
#include "../editor.h"
#include "../blocks.h"
#include "../sorting.h"
#include "../config.h"
#include "../main/trees.h"
#include "../npc_id.h"
#include "../eff_id.h"
#include "../layers.h"

#include "main/game_loop_interrupt.h"

#include "game_main.h"
#include "npc_traits.h"
#include "phys_env.h"

#include "npc/npc_queues.h"
#include "npc/section_overlap.h"
#include "npc/npc_update/npc_update_priv.h"

// moved into the function, as a static array
// static RangeArr<int, 0, maxNPCs> newAct;
// Why this array is here? to don't reallocate it every call of UpdateNPCs()

void CheckNPCWidth(NPC_t& n)
{
    if(num_t::fEqual_d(n.Location.Width, 32))
    {
        if(n.Type != NPCID_CONVEYOR && n.Type != NPCID_STATUE_S3)
        {
            // If .Type = 58 Or .Type = 21 Then
            if(!(NPCIsAnExit(n) || n.Type == NPCID_PLANT_S3 || n.Type == NPCID_BOTTOM_PLANT ||
                 n.Type == NPCID_SIDE_PLANT || n.Type == NPCID_BIG_PLANT || n.Type == NPCID_LONG_PLANT_UP ||
                 n.Type == NPCID_LONG_PLANT_DOWN || n.Type == NPCID_PLANT_S1 || n.Type == NPCID_FIRE_PLANT))
            {
                n.Location.X += 0.015_n;
            }

            n.Location.Width -= 0.03_n;
        }
    }
    else if(num_t::fEqual_d(n.Location.Width, 256))
        n.Location.Width = 255.9_n;
    else if(num_t::fEqual_d(n.Location.Width, 128))
        n.Location.Width = 127.9_n;

    // unset a bunch of variables that would normally decay for inactive NPCs
    if(!n.Active)
    {
        n.tempBlock = 0;

        n.TailCD = 0;
        n.Immune = 0;

        // Failing to update Location.SpeedX causes inaccurate initial movement speed of some NPCs, including squids
        //   (cross-ref UpdateNPCs condition RealSpeedX != 0 for Active NPCs.)
        // Technically, the final values should depend on the value of speedVar,
        //   which invalidly exchanged information between loop iterations,
        //   but in the valid case this is the outcome.
        //   (cross-ref UpdateNPCs clause updating RealSpeedX for Active, formerly all, NPCs)
        if(n.RealSpeedX != 0)
        {
            n.Location.SpeedX = (num_t)n.RealSpeedX;
            n.RealSpeedX = 0;
        }

        if(!n.Projectile || n.Type == NPCID_TOOTHY || n.Type == NPCID_TANK_TREADS)
            n.Multiplier = 0;
    }
}

bool UpdateNPCs()
{
    // this is 1 of the 2 clusterfuck subs in the code, be weary

    // misc variables used mainly for arrays
    // int A = 0;
    // int B = 0;
//    float C = 0;
//    float D = 0;
//    double E = 0;
//    float F = 0;

//    std::string tempStr;
    // int oldSlope = 0; // previous sloped block the npc was on
//    NPC_t tempNPC;
    // int HitSpot = 0; // used for collision detection
    // double tempHit = 0;
    // double tempHitOld = 0;
    // Block_t tmpBlock;
    // int tempHitBlock = 0;
    // int tempHitOldBlock = 0;
    // int tempHitIsSlope = 0;
    // float tempSpeedA = 0;
//    float tempSpeedB = 0;
    // bool tempTurn = false; // used for turning the npc around
    // Location_t tempLocation;
    // Location_t tempLocation2;
    // Location_t preBeltLoc;
    // float beltCount = 0;
    // int tempBlockHit[3] = {0}; // Hit block from below code
    // int winningBlock = 0; // More code for hitting the block from below
    int numTempBlock = 0;
    // float speedVar = 0; // percent of the NPC it should actually moved. this helps when underwater

    // bool tempBool = false;
//    bool tempBool2 = false;
//    bool tempBool3 = false;
    // float newY = 0; // fully unused
//    bool straightLine = false;
    const Block_t blankBlock;
//    bool noBelt = false;
    // float oldBeltSpeed = 0;
//    float beltFixX = 0;
    // int oldDirection = 0;

    // used for collision detection
    // int64_t fBlock = 0;
    // int64_t lBlock = 0;
    // int64_t fBlock2 = 0;
    // int64_t lBlock2 = 0;
    // int bCheck2 = 0;
    // int bCheck = 0;
    // float addBelt = 0;
    // int numAct = 0;
    // bool beltClear = false; // stops belt movement when on a wall
    // bool resetBeltSpeed = false;
    // double PlrMid = 0;
    // double Slope = 0;
    // bool SlopeTurn = false;
//    std::string timeStr;

    num_t lyrX = 0; // for attaching to layers
    num_t lyrY = 0; // for attaching to layers

    auto activation_it = NPCQueues::Active.may_insert_erase.begin();

    switch(g_gameLoopInterrupt.site)
    {
    case GameLoopInterrupt::UpdateNPCs_Activation_Generator:
    case GameLoopInterrupt::UpdateNPCs_Activation_Self:
    case GameLoopInterrupt::UpdateNPCs_Activation_Chain:
        goto resume_Activation;
    case GameLoopInterrupt::UpdateNPCs_KillNPC:
        goto resume_KillNPC;
    default:
        break;
    }

    // newAct.fill(0);

    NPC[0].Location.SpeedX = 0;
    NPC[0].Location.SpeedY = 0;

    if(LevelMacro > LEVELMACRO_OFF)
    {
        if(PSwitchTime > 0)
            PSwitchTime = 100;
        if(PSwitchStop > 0)
            PSwitchStop = 100;
    }

    // used for the p switches
    if(PSwitchStop > 0) // time stop
    {
        if(PSwitchStop == Physics.NPCPSwitch)
        {
            StopMusic();
            StartMusic(-1);
            PlaySound(SFX_PSwitch);
        }

        if(PSwitchTime > 2)
            PSwitchTime = 2;

        PSwitchStop -= 1;

        if(PSwitchStop <= 0)
        {
            FreezeNPCs = false;
            SwitchEndResumeMusic();
        }
    }

    if(FreezeNPCs) // When time is paused
    {
        StopHit = 0;

        // handle active NPCs
        for(; activation_it != NPCQueues::Active.may_insert_erase.end(); ++activation_it)
        {
            int A = *activation_it;
            if(NPCIsBoot(NPC[A]) || NPCIsYoshi(NPC[A]))
            {
                if(NPC[A].CantHurt > 0)
                {
                    NPC[A].CantHurt -= 1;
                    if(NPC[A].CantHurt == 0)
                        NPC[A].CantHurtPlayer = 0;
                }
            }

            if(NPC[A].TimeLeft > 0)
                NPC[A].TimeLeft -= 1;

            if(NPC[A].Immune > 0)
                NPC[A].Immune -= 1;

            NPC[A].Chat = false;

            if(NPC[A].TimeLeft == 0)
            {
                Deactivate(A);

                if(g_config.fix_timestop_respawn)
                {
                    // NPCMovementLogic gets called here to reset the NPC's position -- important for plants
                    if(!NPC[A].Generator)
                    {
                        tempf_t speedVar = 1;
                        NPCMovementLogic(A, speedVar);
                    }

                    // don't keep deactivating the NPC every frame
                    NPC[A].TimeLeft = -1;
                }
            }

            if(NPC[A].JustActivated)
            {
                // update the NPC's position -- important for bullets and jumping fish
                if(g_config.fix_timestop_respawn && !NPC[A].Generator)
                {
                    NPCActivationLogic(A);

                    if(NPC[A].TriggerActivate != EVENT_NONE)
                        TriggerEvent(NPC[A].TriggerActivate, 0);
                }

                NPC[A].JustActivated = 0;
                NPCQueues::update(A);
            }
        }

        // keep inactive NPCs from respawning during FreezeNPCs (SMBX 1.3 behavior)
        for(int A : NPCQueues::Unchecked)
        {
            if(A <= numNPCs && NPC[A].TimeLeft == 0)
            {
                NPC[A].Reset[1] = false;
                NPC[A].Reset[2] = false;
                NPCQueues::NoReset.push_back(A);
            }
        }

        goto kill_NPCs_and_CharStuff;
    }


    if(CoinMode) // this is a cheat code
    {
        if(!g_config.modern_lives_system && Lives >= 99 && Coins >= 99)
            CoinMode = false;
        else
        {
            PlaySound(SFX_Coin);
            Coins += 1;
            if(Coins >= 100)
            {
                if(g_config.modern_lives_system)
                    CoinMode = false;

                Got100Coins();
            }
        }
    }



    // need this complex loop syntax because RespawnDelay can be modified within it
    for(auto it = NPCQueues::RespawnDelay.begin(); it != NPCQueues::RespawnDelay.end();)
    {
        int A = *(it++);

        if(NPC[A].RespawnDelay && !NPC[A].Active && NPC[A].Effect2 > 0)
        {
            NPC[A].Reset[1] = false;
            NPC[A].Reset[2] = false;
            NPC[A].Effect2 -= 1;

            NPCQueues::NoReset.push_back(A);
        }
        else
        {
            // don't reset Effect2 in case the NPC is somehow using it now
            NPC[A].RespawnDelay = false;
            NPCQueues::RespawnDelay.erase(A);
        }
    }

    for(int A = maxNPCs - 100 + 1; A <= numNPCs; A++)
    {
        // if(A > maxNPCs - 100)
        NPC[A].Killed = 9;
        NPCQueues::Killed.push_back(A);
    }

    for(int A : NPCQueues::Unchecked)
        CheckNPCWidth(NPC[A]);

    // gets restored by resumption here
    int numNPCsMax;
    numNPCsMax = numNPCs;

    // need this complex loop syntax because Active can be modified within it
    for(; activation_it != NPCQueues::Active.may_insert_erase.end(); ++activation_it)
    {
        int A;
        if(true)
        {
            A = *activation_it;
        }
        else
        {
resume_Activation:
            A = g_gameLoopInterrupt.A;
            numNPCsMax = g_gameLoopInterrupt.B;
            activation_it.last_val = A;
            NPCQueues::Active.invalidate();

            switch(g_gameLoopInterrupt.site)
            {
            case GameLoopInterrupt::UpdateNPCs_Activation_Generator:
                goto resume_Activation_Generator;
            case GameLoopInterrupt::UpdateNPCs_Activation_Self:
                goto resume_Activation_Self;
            case GameLoopInterrupt::UpdateNPCs_Activation_Chain:
                goto resume_Activation_Chain;
            default:
                break;
            }
        }

        if(A > numNPCsMax)
            break;

        if(NPC[A].Hidden)
        {
            Deactivate(A);
            CheckNPCWidth(NPC[A]);
        }
        else if(NPC[A].TailCD > 0)
            NPC[A].TailCD -= 1;

        // generator code
        if(NPC[A].Generator)
        {
            NPC[A].Active = false;

            if(!NPC[A].Hidden)
            {
                if(NPCGeneratorLogic(A))
                {
                    NPCGeneratorMakeNew(A);

                    if(NPC[numNPCs].TriggerActivate != EVENT_NONE)
                    {
                        eventindex_t resume_index;
                        resume_index = ProcEvent_Safe(false, NPC[numNPCs].TriggerActivate, 0);
                        while(resume_index != EVENT_NONE)
                        {
                            g_gameLoopInterrupt.C = resume_index;
                            g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateNPCs_Activation_Generator;
                            goto interrupt_Activation;

resume_Activation_Generator:
                            resume_index = g_gameLoopInterrupt.C;
                            g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                            resume_index = ProcEvent_Safe(true, resume_index, 0);
                        }
                    }

                    if(NPC[numNPCs].Type == NPCID_RANDOM_POWER)
                        NPC[numNPCs].Type = RandomBonus();
                }
            }

            // skip the rest of this logic unless NPC is a force-active type (in which case the result will be buggy)
            if(!NPCQueues::check_active_type(NPC[A]))
                continue;
        }

        // Force-active NPCs, part 1
        if(NPC[A].Type == NPCID_CONVEYOR && !NPC[A].Hidden)
        {
            CheckSectionNPC(A);
            bool sameSection = false;
            for(int B = 1; B <= numPlayers; B++)
            {
                if(Player[B].Section == NPC[A].Section)
                    sameSection = true;
            }

            if(sameSection)
            {
                NPC[A].TimeLeft = 100;
                NPC[A].Active = true;
                NPC[A].JustActivated = 0;
            }
        }
        else if(NPC[A].Type == NPCID_STATUE_POWER || NPC[A].Type == NPCID_HEAVY_POWER)
        {
            if(NPC[A].TimeLeft == 1 || NPC[A].JustActivated != 0)
                NPC[A].Frame = EditorNPCFrame(NPC[A].Type, NPC[A].Direction, A);
        }
        // platforms returned to their SMBX 1.3 position below chain activation logic to prevent mistaken chain-activations

        // process chain activations
        if(NPC[A].JustActivated != 0)
        {
            static std::array<vbint_t, maxNPCs> newAct;
            int numAct;
            numAct = 0;

            if(NPC[A].Active && NPC[A].TimeLeft > 1 &&
               NPC[A].Type != NPCID_CONVEYOR && NPC[A].Type != NPCID_FALL_BLOCK_RED &&
               NPC[A].Type != NPCID_FALL_BLOCK_BROWN && !NPC[A]->IsACoin) // And .Type <> NPCID_SPIKY_THROWER
            {
                // if activated by a shared screen, don't make the event player-specific
                int activ_player;
                {
                    const vScreen_t& activ_vscreen = vScreen[NPC[A].JustActivated];
                    const Screen_t& activ_screen = Screens[activ_vscreen.screen_ref];
                    bool shared_screen = (activ_screen.player_count > 1) && (activ_screen.active_end() - activ_screen.active_begin() == 1);

                    activ_player = (shared_screen) ? 0 : activ_vscreen.player;
                }

                if(NPC[A].TriggerActivate != EVENT_NONE)
                {
                    eventindex_t resume_index;
                    resume_index = ProcEvent_Safe(false, NPC[A].TriggerActivate, activ_player);
                    while(resume_index != EVENT_NONE)
                    {
                        g_gameLoopInterrupt.C = resume_index;
                        g_gameLoopInterrupt.D = activ_player;
                        g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateNPCs_Activation_Self;
                        goto interrupt_Activation;

resume_Activation_Self:
                        resume_index = g_gameLoopInterrupt.C;
                        activ_player = g_gameLoopInterrupt.D;
                        numAct = 0;
                        g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                        resume_index = ProcEvent_Safe(true, resume_index, activ_player);
                    }
                }

                newAct[numAct] = A;
                numAct++;

                // chain activation
                int C;
                for(C = 0; C < numAct; C++)
                {
                    if(NPC[newAct[C]].Type != NPCID_CONVEYOR && NPC[newAct[C]].Type != NPCID_FALL_BLOCK_RED &&
                       NPC[newAct[C]].Type != NPCID_FALL_BLOCK_BROWN && (C == 0 || NPC[newAct[C]].Type != NPCID_SPIKY_THROWER) &&
                       !NPC[newAct[C]]->IsACoin)
                    {
                        // start of NPCs to check for events (not preserved by resume)
                        int activated_by_C_begin;
                        activated_by_C_begin = numAct;

                        {
                            Location_t tempLocation2 = NPC[newAct[C]].Location;
                            tempLocation2.Y -= 32;
                            tempLocation2.X -= 32;
                            tempLocation2.Width += 64;
                            tempLocation2.Height += 64;

                            for(int B : treeNPCQuery(tempLocation2, SORTMODE_ID))
                            {
                                // In SMBX 1.3, Deactivate was called every frame for every Hidden NPC (in this loop over A). That set Reset to false. Now we need to emulate it.
                                bool reset_should_be_false = (B < A && NPC[B].Hidden);

                                if(!NPC[B].Active && B != A
                                    && !reset_should_be_false
                                    && (C == 0 || !NPC[B].Hidden || !g_config.fix_npc_activation_event_loop_bug)
                                    && NPC[B].Reset[1] && NPC[B].Reset[2])
                                {
                                    if(CheckCollision(tempLocation2, NPC[B].Location))
                                    {
                                        SDL_assert_release(numAct < maxNPCs);
                                        newAct[numAct] = B;
                                        numAct++;

                                        NPC[B].Active = true;
                                        NPC[B].TimeLeft = NPC[newAct[C]].TimeLeft;
                                        NPC[B].Section = NPC[newAct[C]].Section;

                                        if(g_config.fix_npc_camera_logic)
                                            NPC[B].JustActivated = NPC[A].JustActivated;
                                        else
                                            NPC[B].JustActivated = 1;

                                        NPCQueues::Active.insert(B);

                                        // event for B was previously triggered here
                                        // this should not be a logic change from SMBX 1.3:
                                        // - ShowLayer turns Hidden NPCs (which can't be activated) into already-active NPCs
                                        // - HideLayer calls Deactivate on NPCs, so their Reset flags will be false
                                    }
                                }
                                else if(C == 0 && B != A && NPC[B].Active && NPC[B].TimeLeft < NPC[A].TimeLeft - 1)
                                {
                                    if(CheckCollision(tempLocation2, NPC[B].Location))
                                        NPC[B].TimeLeft = NPC[A].TimeLeft - 1;
                                }
                            }
                        }

                        // trigger events for all NPCs activated by C (outside of the query loop above)

                        // restored by resume
                        int i;
                        for(i = activated_by_C_begin; i < numAct; i++)
                        {
                            // not used by resume
                            int B;
                            B = newAct[i];

                            if(B < A)
                            {
                                if(NPC[B].TriggerActivate != EVENT_NONE)
                                {
                                    eventindex_t resume_index;
                                    resume_index = ProcEvent_Safe(false, NPC[B].TriggerActivate, activ_player);
                                    while(resume_index != EVENT_NONE)
                                    {
                                        g_gameLoopInterrupt.C = resume_index;
                                        g_gameLoopInterrupt.D = activ_player;
                                        g_gameLoopInterrupt.E = numAct;
                                        g_gameLoopInterrupt.F = C;
                                        g_gameLoopInterrupt.G = i;

                                        g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateNPCs_Activation_Chain;
                                        goto interrupt_Activation;

resume_Activation_Chain:
                                        resume_index = g_gameLoopInterrupt.C;
                                        activ_player = g_gameLoopInterrupt.D;
                                        numAct = g_gameLoopInterrupt.E;
                                        C = g_gameLoopInterrupt.F;
                                        i = g_gameLoopInterrupt.G;

                                        g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                                        resume_index = ProcEvent_Safe(true, resume_index, activ_player);
                                    }
                                }
                            }
                        }
                    }
                }
            } // NPC[A].Active ...

            if(NPC[A].Type == NPCID_BOSS_CASE)
            {
                for(int B : NPCQueues::Active.no_change)
                {
                    if(NPC[B].Type != NPCID_BOSS_CASE && NPC[B].Effect == NPCEFF_NORMAL && NPC[B].Active)
                    {
                        if(!NPC[B]->NoClipping)
                        {
                            // TRIES to check if A contains B, but actually checks the Y axis only
                            // cross-reference the NPC Effect 208 code, which fixes this but wastes a frame
                            if(NPC[A].Location.Y < NPC[B].Location.Y)
                            {
                                if(NPC[A].Location.Y + NPC[A].Location.Height > NPC[B].Location.Y + NPC[B].Location.Height)
                                {
                                    if(NPC[A].Location.Y < NPC[B].Location.Y)
                                    {
                                        if(NPC[A].Location.Y + NPC[A].Location.Height > NPC[B].Location.Y + NPC[B].Location.Height)
                                        {
                                            NPC[B].Frame = EditorNPCFrame(NPC[B].Type, NPC[B].Direction);
                                            NPC[B].Effect = NPCEFF_ENCASED;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            } // NPCID_BOSS_CASE
        } // .JustActivated != 0

        // force-activate platforms (but don't mistakenly chain-activate -- doing this logic above caused a bug from v1.3.6.1 until v1.3.7.1)
        if(NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM || NPC[A].Type == NPCID_GRN_PLATFORM || NPC[A].Type == NPCID_RED_PLATFORM)
        {
            NPC[A].Active = true;
            NPC[A].TimeLeft = 100;
        }

#if 0
        // this code became the function CheckNPCWidth above
        if(fEqual(NPC[A].Location.Width, 32.0))
        {
            if(NPC[A].Type != NPCID_CONVEYOR && NPC[A].Type != NPCID_STATUE_S3)
            {
                // If .Type = 58 Or .Type = 21 Then
                if(!(NPCIsAnExit(NPC[A]) || NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_BOTTOM_PLANT ||
                     NPC[A].Type == NPCID_SIDE_PLANT || NPC[A].Type == NPCID_BIG_PLANT || NPC[A].Type == NPCID_LONG_PLANT_UP ||
                     NPC[A].Type == NPCID_LONG_PLANT_DOWN || NPC[A].Type == NPCID_PLANT_S1 || NPC[A].Type == NPCID_FIRE_PLANT))
                {
                    NPC[A].Location.X += 0.015;
                }

                NPC[A].Location.Width -= 0.03;
            }
        }
        else if(fEqual(NPC[A].Location.Width, 256.0))
        {
            NPC[A].Location.Width = 255.9;
        }
        else if(fEqual(NPC[A].Location.Width, 128.0))
        {
            NPC[A].Location.Width = 127.9;
        }
#endif

        // construct tempBlock tree
        NPC[A].tempBlock = 0;
        NPC[A].tempBlockInTree = false;

        if(NPC[A].Active && NPC[A].TimeLeft > 1)
        {
            if(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1)
            {
                if(NPC[A].Projectile)
                    NPC[A].Special2 = 0;
                else
                {
                    NPC[A].Special2 += 1;
                    if(NPC[A].Special2 >= 450)
                    {
                        NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                        NPC[A].Killed = 9;
                        NPCQueues::Killed.push_back(A);
                    }
                }
            }

            else if(NPC[A]->IsABlock || NPC[A]->IsAHit1Block || (NPC[A]->CanWalkOn && !(NPC[A]->IsFish && NPC[A].Special == 2)))
            {
                if(
                    (
                        !NPC[A].Projectile && NPC[A].HoldingPlayer == 0 &&
                        NPC[A].Effect == NPCEFF_NORMAL && /* !(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1) && */
                       !((NPC[A].Type == NPCID_FALL_BLOCK_RED || NPC[A].Type == NPCID_FALL_BLOCK_BROWN) && NPC[A].Special == 1)
                    ) || NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG ||
                    NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG
                )
                {
                    numBlock++;

                    Block[numBlock] = blankBlock;
                    Block[numBlock].Type = 0;
                    Block[numBlock].Location = NPC[A].Location;
                    Block[numBlock].Location.Y = num_t::floor(Block[numBlock].Location.Y + 0.02_n);
                    Block[numBlock].tempBlockVehiclePlr = NPC[A].vehiclePlr;
                    Block[numBlock].tempBlockVehicleYOffset = NPC[A].vehicleYOffset;
                    Block[numBlock].tempBlockNpcIdx = A;

                    if(NPC[A].Type == NPCID_VEHICLE)
                        Block[numBlock].Type = 25;

                    if(NPC[A]->IsAHit1Block || (NPC[A]->CanWalkOn && !NPC[A]->IsABlock))
                        Block[numBlock].Type = 26;

                    // moved to Block_t::tempBlockNoProjClipping(), defined in npc_traits.h
                    // if(NPC[A]->CanWalkOn && !NPC[A]->IsAHit1Block && !NPC[A]->IsABlock)
                    //     Block[numBlock].noProjClipping = true;

                    if(NPC[A].Type == NPCID_SPRING && Block[numBlock].Location.Height != 32)
                    {
                        Block[numBlock].Location.Y -= 16;
                        Block[numBlock].Location.Height += 16;
                    }

                    Block[numBlock].Location.SpeedX += (num_t)NPC[A].BeltSpeed;
                    Block[numBlock].tempBlockNpcType = NPC[A].Type;
                    // not syncing the block layer here because we'll sync all of them together later
                    numTempBlock++;
                    NPC[A].tempBlock = numBlock;
                }
            }
        }

        if(false)
        {
interrupt_Activation:
            g_gameLoopInterrupt.A = A;
            g_gameLoopInterrupt.B = numNPCsMax;
            return true;
        }
    }

    // only need to add NPC temp blocks to the quadtree when they are at a diff loc than the NPC
    treeTempBlockEnable();

    for(int A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Mount == 2)
        {
            numBlock++;
            Block[numBlock] = blankBlock;
            Block[numBlock].Type = 25;
            Block[numBlock].Location = Player[A].Location;
            Block[numBlock].Location.X = num_t::floor(Block[numBlock].Location.X) + 1;
            Block[numBlock].Location.Y = num_t::floor(Block[numBlock].Location.Y) + 1;
            Block[numBlock].Location.Width = num_t::floor(Block[numBlock].Location.Width) + 1;
            Block[numBlock].tempBlockVehiclePlr = A;

            // delay add to below if it will be sorted
            if(!g_config.emulate_classic_block_order)
                treeTempBlockAdd(numBlock);

            numTempBlock++;
        }
    }

    // need to sort the temp blocks in strict compatibility mode, to fully emulate the specific way that switched block clipping works in X64 (#739)
    if(g_config.emulate_classic_block_order)
    {
        if(numTempBlock > 1)
            qSortBlocksX(numBlock + 1 - numTempBlock, numBlock);

        // restore tempBlock tracking
        for(int A = numBlock + 1 - numTempBlock; A <= numBlock; A++)
        {
            if(Block[A].tempBlockNpcIdx > 0)
                NPC[Block[A].tempBlockNpcIdx].tempBlock = A;
            else if(Block[A].tempBlockVehiclePlr > 0)
                treeTempBlockAdd(A);
        }
    }

    for(int A : NPCQueues::Unchecked)
    {
        if(NPC[A].Active)
            continue;

        CheckNPCWidth(NPC[A]);

        if(NPCQueues::check_active(NPC[A]))
            continue;

        // check for inactive NPCs that are falling off
        if(NPC[A].JustActivated == 0 && !(NPC[A]->IsFish && NPC[A].Special == 2) && NPC[A].Type != NPCID_LAVABUBBLE)
        {
            if(!GameMenu && NPC[A].Location.Y > level[NPC[A].Section].Height + 16)
            {
                StopHit = 0;
                NPCHit(A, 9);
            }
        }

        // check for inactive NPCs that got the wrong location
        if(NPC[A].Hidden)
        {
            // essential part of Deactivate(A);
            NPC[A].Location.X = NPC[A].DefaultLocationX;
            NPC[A].Location.Y = NPC[A].DefaultLocationY;
            NPC[A].Location.SpeedX = 0;
            NPC[A].Location.SpeedY = 0;
        }
    }

    NPCQueues::Unchecked.clear();


    // need this complex loop syntax because Active can be modified within it
    for(int A : NPCQueues::Active.may_insert_erase)
    {
        if(NPC[A].AttLayer != LAYER_NONE)
        {
            lyrX = NPC[A].Location.X;
            lyrY = NPC[A].Location.Y;
        }

        // all of these are moved into the Active section
#if 0
        Physics.NPCGravity = Physics.NPCGravityReal;

        lyrX = NPC[A].Location.X;
        lyrY = NPC[A].Location.Y;

        if(NPC[A].RealSpeedX != 0)
        {
            NPC[A].Location.SpeedX = NPC[A].RealSpeedX;
            NPC[A].RealSpeedX = 0;
        }


        StopHit = 0;
        if(!NPC[A].Projectile || NPC[A].Type == NPCID_TOOTHY || NPC[A].Type == NPCID_TANK_TREADS)
            NPC[A].Multiplier = 0;
        if(NPC[A].Immune > 0)
            NPC[A].Immune -= 1;
        if(NPC[A].Type == NPCID_VEHICLE && NPC[A].TimeLeft > 1)
            NPC[A].TimeLeft = 100;
#endif

        // Activation collisions
        if(NPC[A].JustActivated != 0)
            NPCActivationLogic(A);
        // check for active NPCs that are falling off
        else if(NPC[A].Location.Y > level[NPC[A].Section].Height && NPC[A].Location.Y > level[NPC[A].Section].Height + 16)
        {
            if(!GameMenu && !(NPC[A]->IsFish && NPC[A].Special == 2) && NPC[A].Type != NPCID_LAVABUBBLE)
                NPCHit(A, 9);
        }



        // Normal operations start here


        if(NPC[A]->IsACoin && NPC[A].Special == 0 && NPC[A].HoldingPlayer == 0 && !NPC[A].Inert && !NPC[A].Wings && NPC[A].Effect == NPCEFF_NORMAL && g_config.optimize_coins)
        {
            if(NPC[A].Active && NPC[A].Killed == 0 && !NPC[A].Generator)
            {
                if(NPC[A].TimeLeft > 10)
                {
                    if(NoTurnBack[NPC[A].Section])
                       NPC[A].TurnBackWipe = true;
                    else if(NPC[A].DefaultType)
                        NPC[A].TimeLeft = 10;
                }

                if(NPC[A].TimeLeft < 1)
                    Deactivate(A);

                NPC[A].TimeLeft -= 1;

                NPCFrames(A);
            }
        }
        else if(NPC[A]->IsAVine)
        {
            // .Location.SpeedX = 0
            // .Location.SpeedY = 0

            // moved into UpdateGraphicsLogic, now only applies to visible vines
            // if(NPC[A].Type == NPCID_GRN_VINE_S3 || NPC[A].Type == NPCID_RED_VINE_S3)
            //     NPC[A].Frame = BlockFrame[5];
            // else if(NPC[A].Type >= NPCID_GRN_VINE_S2 && NPC[A].Type <= NPCID_BLU_VINE_BASE_S2)
            //     NPC[A].Frame = SpecialFrame[7];
        }
/////////////// BEGIN ACTIVE CODE /////////////////////////////////////////////////////////////
        else if(NPC[A].Active && NPC[A].Killed == 0 && !NPC[A].Generator)
        {
            // don't worry about updating A's tree within this block -- it is done at the end if needed.
            num_t prevX = NPC[A].Location.X;
            num_t prevY = NPC[A].Location.Y;
            num_t prevW = NPC[A].Location.Width;
            num_t prevH = NPC[A].Location.Height;

            // all this cleanup code was moved here from the top of the loop
            Physics.NPCGravity = (num_t)Physics.NPCGravityReal;

            StopHit = 0;

            if(NPC[A].RealSpeedX != 0)
            {
                NPC[A].Location.SpeedX = (num_t)NPC[A].RealSpeedX;
                NPC[A].RealSpeedX = 0;
            }

            if(!NPC[A].Projectile || NPC[A].Type == NPCID_TOOTHY || NPC[A].Type == NPCID_TANK_TREADS)
                NPC[A].Multiplier = 0;
            if(NPC[A].Immune > 0)
                NPC[A].Immune -= 1;
            if(NPC[A].Type == NPCID_VEHICLE && NPC[A].TimeLeft > 1)
                NPC[A].TimeLeft = 100;

            tempf_t speedVar = 1; // percent of the NPC it should actually moved. this helps when underwater

            // dead code in VB6
#if 0
            if(NPC[A].Slope > 0 && !(NPC[A]->IsAShell || (NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 1)))
            {
                if((NPC[A].Location.SpeedX > 0 && BlockSlope[Block[NPC[A].Slope].Type] == -1) ||
                   (NPC[A].Location.SpeedX < 0 && BlockSlope[Block[NPC[A].Slope].Type] == 1))
                {
                    if(!NPC[A]->CanWalkOn || NPC[A]->IsABlock || NPC[A].Type == NPCID_TANK_TREADS)
                        speedVar = (float)(1 - Block[NPC[A].Slope].Location.Height / Block[NPC[A].Slope].Location.Width * 0.4);
                }
            }
            speedVar = 1;
#endif

            if(!NPC[A].Projectile)
                speedVar = (tempf_t)NPC[A]->Speedvar;

            // water check

            // Things immune to water's effects
            if(NPC[A].Type == NPCID_LAVABUBBLE || NPC[A].Type == NPCID_BIG_BULLET || NPC[A].Type == NPCID_HEAVY_THROWN || NPC[A].Type == NPCID_CYCLONE_POWER
                || NPC[A].Type == NPCID_GHOST_S3 || NPC[A].Type == NPCID_GHOST_FAST || NPC[A].Type == NPCID_GHOST_S4 || NPC[A].Type == NPCID_BIG_GHOST
                || NPC[A].Type == NPCID_STATUE_FIRE || NPC[A].Type == NPCID_VILLAIN_FIRE || NPC[A].Type == NPCID_PET_FIRE || NPC[A].Type == NPCID_PLR_HEAVY
                || NPC[A].Type == NPCID_CHAR4_HEAVY || NPC[A].Type == NPCID_GOALTAPE || NPC[A].Type == NPCID_SICK_BOSS_BALL || NPC[A].Type == NPCID_HOMING_BALL
                || NPC[A].Type == NPCID_RED_VINE_TOP_S3 || NPC[A].Type == NPCID_GRN_VINE_TOP_S3 || NPC[A].Type == NPCID_GRN_VINE_TOP_S4 || NPC[A].Type == NPCID_SPIKY_THROWER
                || NPC[A].Type == NPCID_ITEM_THROWER || NPC[A].Type == NPCID_SAW || NPC[A].Type == NPCID_JUMP_PLANT || NPC[A].Type == NPCID_MAGIC_BOSS_BALL
                || (NPC[A]->IsACoin && NPC[A].Special == 0) || NPC[A].Type == NPCID_SWORDBEAM || NPC[A].Type == NPCID_FIRE_DISK || NPC[A].Type == NPCID_FIRE_CHAIN
                || NPC[A].Type == NPCID_FLAG_EXIT)
            {
                NPC[A].Wet = 0;
                NPC[A].Quicksand = 0;
            }
            else
            {
                if(NPC[A].Wet > 0)
                    NPC[A].Wet -= 1;

                if(NPC[A].Quicksand > 0)
                    NPC[A].Quicksand -= 1;

                if(UnderWater[NPC[A].Section] && NPC[A].Type != NPCID_BULLET)
                    NPC[A].Wet = 2;

                bool already_in_maze = (NPC[A].Effect == NPCEFF_MAZE);

                for(int B : treeWaterQuery(NPC[A].Location, SORTMODE_NONE))
                {
                    if(!Water[B].Hidden)
                    {
                        if(Water[B].Type == PHYSID_MAZE)
                        {
                            if(NPC[A]->TWidth > 64 || NPC[A]->THeight > 64)
                                continue;

                            if(NPC[A].Effect != NPCEFF_NORMAL && NPC[A].Effect != NPCEFF_MAZE)
                                continue;

                            if(NPC[A].Effect == NPCEFF_MAZE && (already_in_maze || NPC[A].Effect2 < B))
                                continue;

                            if(NPCIsYoshi(NPC[A]) || NPCIsBoot(NPC[A]) || (NPC[A].Type == NPCID_WALL_SPARK || NPC[A].Type == NPCID_WALL_BUG || NPC[A].Type == NPCID_WALL_TURTLE))
                                continue;

                            if((NPCIsVeggie(NPC[A]) && NPC[A].Projectile) || (NPC[A]->NoClipping && !NPC[A].Projectile) || NPC[A].WallDeath || NPC[A].HoldingPlayer)
                                continue;
                        }
                        else if(NPC[A].Type == NPCID_BULLET)
                            continue;

                        if(CheckCollision(NPC[A].Location, Water[B].Location))
                        {
                            if(Water[B].Type == PHYSID_MAZE)
                            {
                                NPC[A].Effect = NPCEFF_MAZE;
                                NPC[A].Effect2 = B;

                                if(NPC[A].Effect3 == 128)
                                    NPC[A].Projectile = false;

                                PhysEnv_Maze_PickDirection(NPC[A].Location, B, NPC[A].Effect3);

                                // cancel if not currently moving down
                                if(NPC[A].Effect3 == MAZE_DIR_DOWN)
                                {
                                    num_t rel_speed = NPC[A].Location.SpeedY - (num_t)Layer[Water[B].Layer].SpeedY;
                                    if(rel_speed < 0 || (NPC[A]->IsABlock && rel_speed <= 4))
                                        NPC[A].Effect = NPCEFF_NORMAL;
                                }

                                continue;
                            }

                            if(NPC[A].Wet == 0 && !NPC[A]->IsACoin)
                            {
                                if(NPC[A].Location.SpeedY >= 1 && (!g_config.fix_submerged_splash_effect || !CheckCollisionIntersect(NPC[A].Location, static_cast<Location_t>(Water[B].Location))))
                                {
                                    Location_t tempLocation;
                                    tempLocation.Width = 32;
                                    tempLocation.Height = 32;
                                    tempLocation.X = NPC[A].Location.X + (NPC[A].Location.Width - tempLocation.Width) / 2;
                                    tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - tempLocation.Height;
                                    NewEffect(EFFID_WATER_SPLASH, tempLocation);
                                }

                                if(!(NPC[A]->IsFish && NPC[A].Special == 1) && NPC[A].Type != NPCID_LEAF_POWER && NPC[A].Type != NPCID_PLR_FIREBALL)
                                {
                                    if(NPC[A].Location.SpeedY > 0.5_n)
                                        NPC[A].Location.SpeedY = 0.5_n;
                                    if(NPC[A].Location.SpeedY < -0.5_n)
                                        NPC[A].Location.SpeedY = -0.5_n;
                                }
                                else
                                {
                                    if(NPC[A].Location.SpeedY > 2)
                                        NPC[A].Location.SpeedY = 2;
                                    if(NPC[A].Location.SpeedY < -2)
                                        NPC[A].Location.SpeedY = -2;
                                }

                                // assigned to Special in SMBX 1.3
                                if(NPC[A].Type == NPCID_PLATFORM_S3)
                                    NPC[A].SpecialY = NPC[A].Location.SpeedY;
                            }

                            if(Water[B].Type == PHYSID_QUICKSAND)
                                NPC[A].Quicksand = 2;

                            NPC[A].Wet = 2;
                        }
                    }
                }
            }

            if(NPC[A].Wet == 1 && NPC[A].Location.SpeedY < -1)
            {
                Location_t tempLocation;
                tempLocation.Width = 32;
                tempLocation.Height = 32;
                tempLocation.X = NPC[A].Location.X + (NPC[A].Location.Width - tempLocation.Width) / 2;
                tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - tempLocation.Height;
                NewEffect(EFFID_WATER_SPLASH, tempLocation);
            }


            if(NPC[A].Wet > 0)
            {
                if(NPC[A].Type == NPCID_ICE_CUBE)
                {
                    NPC[A].Projectile = true;
                    Physics.NPCGravity = num_t(-(tempf_t)Physics.NPCGravityReal / 5);
                }
                else
                    Physics.NPCGravity = num_t((tempf_t)Physics.NPCGravityReal / 5);

                if(NPC[A].Type == NPCID_FLIPPED_RAINBOW_SHELL && NPC[A].Special4 == 1)
                    NPC[A].Special5 = 0;
                else if(!NPC[A]->IsFish && NPC[A].Type != NPCID_RAFT && NPC[A].Type != NPCID_WALL_BUG && NPC[A].Type != NPCID_WALL_SPARK && NPC[A].Type != NPCID_WALL_TURTLE)
                    speedVar /= 2;
                else if(NPC[A]->IsFish && NPC[A].Special == 2 && NPC[A].Location.SpeedY > 0)
                    speedVar /= 2;

                // new logic for iceballs fired upwards by a Polar Swim player
                if(NPC[A].Type == NPCID_PLR_ICEBALL && NPC[A].Special4)
                    Physics.NPCGravity /= 4;
                // SMBX 1.3 logic: Terminal Velocity in water
                else if(NPC[A].Location.SpeedY >= 3)
                    NPC[A].Location.SpeedY = 3;
                else if(NPC[A].Location.SpeedY < -3)
                    NPC[A].Location.SpeedY = -3;

                if(NPC[A].Type == NPCID_RAFT)
                    NPC[A].Special2 = 10; // Set a counter of being dry while floating on water top
            }
            // as far as I'm aware it would make absolutely no difference if this did not happen for NPCID_RAFT
            else if(NPC[A].Type == NPCID_RAFT || NPC[A]->IsFish)
            {
                if(NPC[A].Type == NPCID_RAFT && NPC[A].Special2 > 0)
                    --NPC[A].Special2; // Once it's dry, count down

                // detect if fish is out of water for an extended period so that it can clip through walls
                NPC[A].WallDeath += 2;

                if(NPC[A].WallDeath >= 10)
                    NPC[A].WallDeath = 10;
            }

            if(NPC[A].Quicksand > 0 && !NPC[A]->NoClipping)
            {
                NPC[A].Location.SpeedY += 1;

                if(NPC[A].Location.SpeedY < -1)
                    NPC[A].Location.SpeedY = -1;
                else if(NPC[A].Location.SpeedY > 0.5_n)
                    NPC[A].Location.SpeedY = 0.5_n;

                speedVar = speedVar * 3 / 10;
            }

            if(NPC[A].Type == NPCID_VEGGIE_RANDOM)
            {
                int B = iRand(9);
                NPC[A].Type = NPCID(NPCID_VEGGIE_2 + B);
                if(NPC[A].Type == NPCID_VEGGIE_RANDOM)
                    NPC[A].Type = NPCID_VEGGIE_1;
                NPC[A].Location.set_width_center(NPC[A]->TWidth);
                NPC[A].Location.set_height_center(NPC[A]->THeight);
                NPCQueues::Unchecked.push_back(A);
            }

            if(NPC[A].Text != STRINGINDEX_NONE)
            {
                NPC[A].Chat = false;
                Location_t tempLocation = NPC[A].Location;
                tempLocation.Y -= 25;
                tempLocation.Height += 50;
                tempLocation.X -= 25;
                tempLocation.Width += 50;
                for(int B = 1; B <= numPlayers; B++)
                {
                    if(CheckCollision(tempLocation, Player[B].Location))
                        NPC[A].Chat = true;
                }
            }

            // oldDirection = NPC[A].Direction;

            if(NPC[A].Type == NPCID_BULLET || NPC[A].Type == NPCID_BIG_BULLET)
            {
                if(NPC[A].CantHurt > 0)
                {
                    NPC[A].CantHurt = 10000;
                    if(NPC[A].Type == NPCID_BIG_BULLET)
                        NPC[A].Location.SpeedX = 4 * NPC[A].Direction;
                }

                if(NPC[A].TimeLeft > 3 && !BattleMode)
                    NPC[A].TimeLeft = 3;
            }

            if(NPC[A].Type == NPCID_MAGIC_BOSS || NPC[A].Type == NPCID_MAGIC_BOSS_SHELL || NPC[A].Type == NPCID_FIRE_BOSS || NPC[A].Type == NPCID_FIRE_BOSS_SHELL) // koopalings
            {
                if(NPC[A].TimeLeft > 1)
                    NPC[A].TimeLeft = Physics.NPCTimeOffScreen;
            }

            CheckSectionNPC(A);

            if((NPC[A].Type == NPCID_VILLAIN_S3 || NPC[A].Type == NPCID_FIRE_DISK || NPC[A].Type == NPCID_FIRE_CHAIN) && NPC[A].TimeLeft > 1)
                NPC[A].TimeLeft = 100;

            if(!(NPC[A].Type == NPCID_PLR_FIREBALL || (NPC[A]->IsFish && NPC[A].Special == 2) ||
                 NPC[A].Type == NPCID_TOOTHY || NPC[A].Type == NPCID_VEHICLE || NPC[A].Type == NPCID_YEL_PLATFORM || NPC[A].Type == NPCID_BLU_PLATFORM ||
                 NPC[A].Type == NPCID_GRN_PLATFORM || NPC[A].Type == NPCID_RED_PLATFORM || NPC[A].Type == NPCID_VILLAIN_S3 || NPCIsYoshi(NPC[A])) &&
                 NPC[A].HoldingPlayer == 0)
            {
                int C = 0;
                for(int B = 1; B <= numPlayers; B++)
                {
                    if(Player[B].Section == NPC[A].Section)
                        C = 1;
                }

                if(C == 0 && NPC[A].TimeLeft > 1)
                    NPC[A].TimeLeft = 0;
            }

            if((NPC[A].Type == NPCID_RED_VINE_TOP_S3 || NPC[A].Type == NPCID_GRN_VINE_TOP_S3 || NPC[A].Type == NPCID_GRN_VINE_TOP_S4) && NPC[A].TimeLeft > 10)
                NPC[A].TimeLeft = 100;

            if(NPC[A].TimeLeft > 10 && NoTurnBack[NPC[A].Section])
                NPC[A].TurnBackWipe = true;

            if(NPC[A].TimeLeft < 1)
                Deactivate(A);

            NPC[A].TimeLeft -= 1;

            if(NPC[A].Effect == NPCEFF_NORMAL)
            {
                // this code is for NPCs that are being held by a player

                if(NPC[A].HoldingPlayer > 0) // NPC is held
                {
                    NPC[A].vehiclePlr = 0;
                    if(NPC[A].Type == NPCID_VEHICLE)
                    {
                        Player[NPC[A].HoldingPlayer].HoldingNPC = 0;
                        NPC[A].HoldingPlayer = 0;
                    }

                    if(Player[NPC[A].HoldingPlayer].HoldingNPC == A && Player[NPC[A].HoldingPlayer].TimeToLive == 0 && !Player[NPC[A].HoldingPlayer].Dead) // Player and NPC are on the same page
                    {
                        NPC[A].Multiplier = 0;

                        if(NPC[A].Type == NPCID_LIFT_SAND)
                        {
                            Player[NPC[A].HoldingPlayer].HoldingNPC = 0;
                            NPC[A].HoldingPlayer = 0;
                            NPC[A].Killed = 9;
                            NPCQueues::Killed.push_back(A);
                            NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                        }

                        if(NPCIsYoshi(NPC[A]))
                        {
                            NPC[A].Special = NPC[A].Type;
                            NPC[A].Type = NPCID_ITEM_POD;
                        }

                        // Unbury code (v1)
                        if(NPC[A].Type == NPCID_ITEM_BURIED)
                        {
                            if(NPC[A].Special == 0)
                                NPC[A].Special = NPCID_VEGGIE_RANDOM;

                            NPCUnbury(A, 1);
                            NPCQueues::Unchecked.push_back(A);
                        }

                        if(NPC[A].Type == NPCID_SLIDE_BLOCK)
                        {
                            NPC[A].Special = 1;
                            NPC[A].Wings = WING_NONE;
                        }

                        if(NPC[A].Type == NPCID_SPIT_GUY_BALL)
                        {
                            NPC[A].Type = NPCID_COIN_S2;
                            NPC[A].Location.set_height_center(NPC[A]->THeight);
                            NPC[A].Location.set_width_center(NPC[A]->TWidth);

                            NPCQueues::Unchecked.push_back(A);
                        }

                        NPC[A].TimeLeft = 100;
                        NPC[A].BeltSpeed = 0;

                        // dead code, impossible condition in SMBX 1.3 source (IsFish did not apply for NPC Type 1)
                        // if(NPC[A].Type == (NPC[A]->IsFish && NPC[A].Special == 2))
                        //     NPC[A].Special5 = 0;

                        NPC[A].Direction = Player[NPC[A].HoldingPlayer].Direction; // Face the player
                        NPC[A].Location.SpeedY = Player[NPC[A].HoldingPlayer].Location.SpeedY;
                        NPC[A].Location.SpeedX = 0;

                        NPCCollideHeld(A);

                        if(NPC[A].Type == NPCID_ICE_BLOCK || NPC[A].Type == NPCID_ICE_CUBE) // Yoshi Ice
                        {
                            if(iRand(100) >= 93)
                            {
                                Location_t tempLocation;
                                NewEffect_IceSparkle(NPC[A], tempLocation);
                            }
                        }
                    }
                    else // Player and NPC are not on the same page
                    {
                        Player[NPC[A].HoldingPlayer].HoldingNPC = 0;

                        if(NPC[A].Type == NPCID_VINE_BUG)
                            NPC[A].Projectile = true;

                        NPC[A].Location.SpeedX = 0;
                        NPC[A].Location.SpeedY = 0;

                        if(NPC[A].Type == NPCID_HEAVY_THROWER)
                        {
                            NPC[A].Killed = 3;
                            NPCQueues::Killed.push_back(A);
                            NPC[A].Direction = -NPC[A].Direction;
                        }

                        if(NPC[A].Type == NPCID_BULLET)
                        {
                            PlaySoundSpatial(SFX_Bullet, NPC[A].Location);
                            NPC[A].Location.SpeedX = 5 * NPC[A].Direction;
                            NPC[A].Projectile = true;
                            NPC[A].CantHurt = 1000;
                            NPC[A].CantHurtPlayer = NPC[A].HoldingPlayer;
                        }

                        NPC[A].HoldingPlayer = 0;
                    }
                }
                else // NPC is not held
                {
                    if(NPC[A].CantHurt <= 0)
                        NPC[A].CantHurtPlayer = 0;
                    // tempHit = 0;
                    // tempHitBlock = 0;
                    // tempBlockHit[1] = 0;
                    // tempBlockHit[2] = 0;
                    // winningBlock = 0;

                    NPCSectionWrap(NPC[A]);

                    if(NoTurnBack[NPC[A].Section] && NPC[A].Location.X < level[NPC[A].Section].X - NPC[A].Location.Width - 32)
                        NPCHit(A, 9);

                    if(NPC[A].CantHurt > 0)
                    {
                        if(NPC[A].Type != NPCID_CANNONENEMY)
                            NPC[A].CantHurt -= 1;
                    }
                    else
                        NPC[A].CantHurtPlayer = 0;

                    if(NPC[A].Projectile)
                    {
                        if(NPC[A].CantHurtPlayer != 0)
                            NPC[A].BattleOwner = NPC[A].CantHurtPlayer;
                    }
                    else
                        NPC[A].BattleOwner = 0;

                    if(NPC[A]->IsAShell)
                    {
                        NPC[A].Special4 -= 1;
                        if(NPC[A].Special4 < 0)
                            NPC[A].Special4 = 0;
                    }

                    if(NPC[A].TurnAround)
                    {
                        if((NPC[A].Type == NPCID_MAGIC_BOSS || NPC[A].Type == NPCID_FIRE_BOSS) && NPC[A].Special == 0) // larry koopa
                        {
                            if(NPC[A].Location.to_right_of(Player[NPC[A].Special5].Location))
                            {
                                if(NPC[A].Special2 < 0)
                                    NPC[A].Special3 += 30;
                                NPC[A].Special2 = -1;
                            }
                            else
                            {
                                if(NPC[A].Special2 > 0)
                                    NPC[A].Special3 += 30;
                                NPC[A].Special2 = 1;
                            }

                        }

                        if(NPC[A].Type == NPCID_PLR_ICEBALL)
                            NPCHit(A, 3, A);

                        if(NPC[A]->IsAShell && NPC[A].Location.SpeedX != 0 && NPC[A].Special4 == 0)
                        {
                            NPC[A].Special4 = 5;
                            Location_t tempLocation;
                            tempLocation.Height = 0;
                            tempLocation.Width = 0;
                            tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height / 2 - 16;
                            tempLocation.X = NPC[A].Location.X - 16;
                            if(NPC[A].Direction == 1)
                                tempLocation.X = NPC[A].Location.X + NPC[A].Location.Width - 16;
                            NewEffect(EFFID_STOMP_INIT, tempLocation);
                        }

                        // was Special2
                        if(NPC[A].Type == NPCID_SAW)
                            NPC[A].SpecialX = -NPC[A].SpecialX;

                        // Don't turn around if a shell or a fireball
                        bool can_turn_around = !NPC[A]->IsAShell && NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_TANK_TREADS &&
                           NPC[A].Type != NPCID_BULLET && NPC[A].Type != NPCID_VILLAIN_S3 && !NPCIsABot(NPC[A]) &&
                           NPC[A].Type != NPCID_SPIT_BOSS_BALL && NPC[A].Type != NPCID_SPIT_GUY_BALL && !NPCIsVeggie(NPC[A]) &&
                           NPC[A].Type != NPCID_ROCKET_WOOD && NPC[A].Type != NPCID_WALL_SPARK && NPC[A].Type != NPCID_WALL_BUG &&
                           NPC[A].Type != NPCID_WALL_TURTLE && NPC[A].Type != NPCID_PLR_ICEBALL && NPC[A].Type != NPCID_SWORDBEAM;

                        // wings override their parents' behavior
                        if(NPC[A].Wings)
                            can_turn_around = true;

                        if(can_turn_around)
                        {
                            NPC[A].Location.SpeedX = -NPC[A].Location.SpeedX;
                            if(NPC[A].tempBlock > 0)
                                Block[NPC[A].tempBlock].Location.SpeedX = -Block[NPC[A].tempBlock].Location.SpeedX;
                        }

                        NPC[A].TurnAround = false;
                    }

                    // NPC Movement Code

                    // Probably make a single function pointer for this whole block (until RESUME UNIFIED CODE),
                    //   but create subroutines for the most commonly repeated code

                    NPCMovementLogic(A, speedVar);

                    // RESUME UNIFIED CODE

                    // Block Collision

                    if(NPC[A].Pinched.Bottom1 > 0)
                        NPC[A].Pinched.Bottom1 -= 1;
                    if(NPC[A].Pinched.Left2 > 0)
                        NPC[A].Pinched.Left2 -= 1;
                    if(NPC[A].Pinched.Top3 > 0)
                        NPC[A].Pinched.Top3 -= 1;
                    if(NPC[A].Pinched.Right4 > 0)
                        NPC[A].Pinched.Right4 -= 1;
                    if(NPC[A].Pinched.Moving > 0)
                        NPC[A].Pinched.Moving -= 1;

                    // removed, only ever read in NPCBlockLogic
                    // NPC[A].onWall = false;
                    if(NPC[A].Location.X < -(FLBlocks - 1) * 32)
                        NPC[A].Location.X = -(FLBlocks - 1) * 32;
                    if(NPC[A].Location.X + NPC[A].Location.Width > (FLBlocks + 1) * 32)
                        NPC[A].Location.X = (FLBlocks + 1) * 32 - NPC[A].Location.Width;

                    bool can_do_blocks = !(NPC[A]->IsACoin && NPC[A].Special == 0) && !(NPC[A].Type == NPCID_SLIDE_BLOCK && NPC[A].Special == 0) &&
                       NPC[A].Type != NPCID_CONVEYOR && NPC[A].Type != NPCID_STATUE_FIRE && NPC[A].Type != NPCID_ITEM_BURIED && NPC[A].Type != NPCID_STAR_EXIT &&
                       NPC[A].Type != NPCID_STAR_COLLECT && !(NPC[A].Type >= NPCID_PLATFORM_S3 && NPC[A].Type <= NPCID_PLATFORM_S1) &&
                       NPC[A].Type != NPCID_LIFT_SAND && NPC[A].Type != NPCID_CHECKPOINT && NPC[A].Type != NPCID_SICK_BOSS_BALL &&
                       !(NPC[A].Type == NPCID_PLANT_FIREBALL || NPC[A].Type == NPCID_LOCK_DOOR || NPC[A].Type == NPCID_FIRE_DISK || NPC[A].Type == NPCID_FIRE_CHAIN) &&
                       !(NPCIsAnExit(NPC[A]) && ((NPC[A].DefaultLocationX == NPC[A].Location.X && NPC[A].DefaultLocationY == NPC[A].Location.Y) || NPC[A].Inert));

                    // wings override their parents' behavior
                    if(NPC[A].Wings)
                        can_do_blocks = true;

                    if(can_do_blocks)
                    {
                        // only the top half of the saw collides with blocks (gets restored after block collisions)
                        if(NPC[A].Type == NPCID_SAW)
                        {
                            PlaySoundSpatial(SFX_Saw, NPC[A].Location);
                            NPC[A].Location.Height = 24;
                        }

                        num_t tempHit = 0; // height of block NPC is walking on
                        int tempHitBlock = 0; // index of block NPC is walking on
                        tempf_t tempSpeedA = 0; // speed of ground the NPC is possibly standing on

                        NPCBlockLogic(A, tempHit, tempHitBlock, tempSpeedA, numTempBlock, speedVar);


                        // End Block Collision
                        // possible usually-nulled function pointer for logic between block and NPC collisions

                        if(NPC[A]->IsAShell)
                        {
                            if(NPC[A].Special > 0)
                            {
                                NPC[A].Location.SpeedX *= 0.9_r;
                                NPC[A].Frame = 0;
                                NPC[A].FrameCount = 0;
                                if(NPC[A].Location.SpeedX > -0.3_n && NPC[A].Location.SpeedX < 0.3_n)
                                {
                                    NPC[A].Location.SpeedX = 0;
                                    NPC[A].Special = 0;
                                    NPC[A].Projectile = false;
                                }
                            }
                        }

                        if(NPC[A].Type == NPCID_TANK_TREADS && NPC[A].Location.SpeedX != 0)
                            NPC[A].Location.SpeedX = 1 * NPC[A].DefaultDirection;

                        // If .Type = 12 Then .Projectile = True 'Stop the big fireballs from getting killed from tha lava
                        if(NPC[A].Type == NPCID_RAINBOW_SHELL)
                            NPC[A].Projectile = true;

                        // restore saw height after block collision and belt logic
                        if(NPC[A].Type == NPCID_SAW)
                        {
                            NPC[A].Location.Height = NPC[A]->THeight;
                            NPC[A].Projectile = true;
                        }


                        // NPC Collision
                        NPCCollide(A);

                        // reset WallDeath variable for thrown items and decay it for fish re-entering water
                        if(NPC[A].WallDeath > 0)
                        {
                            if(NPC[A]->IsFish)
                                NPC[A].WallDeath -= 1;
                            else
                                NPC[A].WallDeath = 0;
                        }

                        if(tempHit != 0) // Walking   // VERIFY ME
                            NPCWalkingLogic(A, tempHit, tempHitBlock, tempSpeedA);
                    }
                    else
                    {
                        NPC[A].BeltSpeed = 0;
                        NPC[A].Slope = 0;
                    }
                }

                if(NPC[A].tempBlock > 0 && (NPC[A].Type < NPCID_YEL_PLATFORM || NPC[A].Type > NPCID_RED_PLATFORM) && NPC[A].Type != NPCID_CONVEYOR)
                {
                    if((NPC[A].Type < NPCID_TANK_TREADS || NPC[A].Type > NPCID_SLANT_WOOD_M) && NPC[A].Type != NPCID_SPRING)
                    {
                        Block[NPC[A].tempBlock].Location = NPC[A].Location;
                        if(NPC[A].Type == NPCID_SPRING)
                        {
                            // the NPC tree accounts for this; no need to split tempBlock
                            Block[NPC[A].tempBlock].Location.Y -= 16;
                            Block[NPC[A].tempBlock].Location.Height += 16;
                        }

                        // tempBlock comes back in sync with NPC
                        if(NPC[A].Location.X != prevX
                            || NPC[A].Location.Y != prevY
                            || NPC[A].Location.Width != prevW
                            || NPC[A].Location.Height != prevH)
                        {
                            prevX = NPC[A].Location.X;
                            prevY = NPC[A].Location.Y;
                            prevW = NPC[A].Location.Width;
                            prevH = NPC[A].Location.Height;

                            treeNPCUpdate(A);

                            if(NPC[A].tempBlockInTree)
                            {
                                NPC[A].tempBlockInTree = false;
                                treeTempBlockRemove(NPC[A].tempBlock);
                            }
                        }

                        // no longer needed; maintaining the sort
#if 0
                        while(Block[NPC[A].tempBlock].Location.X < Block[NPC[A].tempBlock - 1].Location.X && NPC[A].tempBlock > numBlock + 1 - numTempBlock)
                        {

                            tmpBlock = Block[NPC[A].tempBlock - 1];
                            Block[NPC[A].tempBlock - 1] = Block[NPC[A].tempBlock];
                            Block[NPC[A].tempBlock] = tmpBlock;

                            NPC[Block[NPC[A].tempBlock].tempBlockNpcIdx].tempBlock = NPC[A].tempBlock;
                            NPC[A].tempBlock -= 1;

                        }
                        while(Block[NPC[A].tempBlock].Location.X > Block[NPC[A].tempBlock + 1].Location.X && NPC[A].tempBlock < numBlock)
                        {


                            tmpBlock = Block[NPC[A].tempBlock + 1];
                            Block[NPC[A].tempBlock + 1] = Block[NPC[A].tempBlock];
                            Block[NPC[A].tempBlock] = tmpBlock;

                            NPC[Block[NPC[A].tempBlock].tempBlockNpcIdx].tempBlock = NPC[A].tempBlock;
                            NPC[A].tempBlock += 1;




                            // NPC(Block(.tempBlock).tempBlockNpcIdx).tempBlock = .tempBlock
                            // NPC(Block(.tempBlock + 1).tempBlockNpcIdx).tempBlock = .tempBlock + 1


                        }
#endif
                    }
                    Block[NPC[A].tempBlock].Location.SpeedX = NPC[A].Location.SpeedX + (num_t)NPC[A].BeltSpeed;
                }

                if(NPC[A].Projectile)
                {
                    if(NPC[A].Type == NPCID_SAW || NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_HPIPE_SHORT || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG || (NPC[A].Type >= NPCID_TANK_TREADS && NPC[A].Type <= NPCID_SLANT_WOOD_M))
                        NPC[A].Projectile = false;
                }

                // obsolete code commented out in SMBX64

                // Pinched code
                // If .Direction <> oldDirection Then
                // .PinchCount += 10
                // Else
                // If .PinchCount > 0 Then
                // .PinchCount += -1
                // If .Pinched = False Then .PinchCount += -1
                // End If
                // End If
                // If .PinchCount >= 14 And .Pinched = False Then
                // .Pinched = True
                // .PinchedDirection = .Direction
                // ElseIf .PinchCount >= 15 Then
                // .PinchCount = 15
                // ElseIf .PinchCount = 0 Then
                // .Pinched = False
                // End If

                // NPC[A].Pinched = false;    // never set to true since SMBX64, removed

                // Special Code for things that work while held
                NPCSpecialMaybeHeld(A);


                // If FreezeNPCs = True Then
                // .Direction = .DefaultDirection
                // .Special = .DefaultSpecial
                // .Special2 = 0
                // .Special3 = 0
                // .Special4 = 0
                // .Special5 = 0
                // End If


                NPCFrames(A);
            }
            // Effects
            else
                NPCEffects(A);

            // Originally applied for all NPCs, even if inactive.
            // Moved here because speedVar is only validly set here.
            if(!num_t::fEqual_f(speedVar, 1) && !num_t::fEqual_f(speedVar, 0))
            {
                NPC[A].RealSpeedX = numf_t(NPC[A].Location.SpeedX);
                NPC[A].Location.SpeedX = NPC[A].Location.SpeedX.times(num_t(speedVar));
            }

            // finally update NPC's tree status if needed, and split the tempBlock (since it has not been updated)
            if(NPC[A].Location.X != prevX
                || NPC[A].Location.Y != prevY
                || NPC[A].Location.Width != prevW
                || NPC[A].Location.Height != prevH)
            {
                bool changed = treeNPCUpdate(A);

                if(changed && NPC[A].tempBlock > 0)
                    treeNPCSplitTempBlock(A);
            }
        }

        if(NPC[A].AttLayer != LAYER_NONE && NPC[A].AttLayer != LAYER_DEFAULT && NPC[A].HoldingPlayer == 0)
            SetLayerSpeed(NPC[A].AttLayer, NPC[A].Location.X - lyrX, NPC[A].Location.Y - lyrY, false);
    }

    numBlock -= numTempBlock; // clean up the temp npc blocks

    treeTempBlockClear();

kill_NPCs_and_CharStuff:

    // kill the NPCs, from last to first
    NPCQueues::reverse_sort(NPCQueues::Killed);

    // all of these are preserved by the interrupt / resume routine
    int last_NPC;
    size_t KilledQueue_check;
    size_t KilledQueue_known;
    size_t i;
    last_NPC = maxNPCs + 1;
    KilledQueue_check = NPCQueues::Killed.size();
    KilledQueue_known = NPCQueues::Killed.size();

    for(i = 0; i < KilledQueue_check; i++) // KILL THE NPCS <><><><><><><><><><><><><><><><><><><><><><><><><><><><><><
    {
        // preserved by the interrupt / resume routine
        int A;
        A = NPCQueues::Killed[i];

        // in rare cases, the game may accidentally kill an NPC outside of the NPC array (storage glitch example)
        if(A > numNPCs)
            continue;

        // duplicated entry, no problem
        if(A == last_NPC)
            continue;

        SDL_assert(A < last_NPC); // something's wrong in the sort order

        if(NPC[A].Killed > 0)
        {
            if(NPC[A].Location.SpeedX == 0)
            {
                NPC[A].Location.SpeedX = dRand() * 2 - 1;
                if(NPC[A].Location.SpeedX < 0)
                    NPC[A].Location.SpeedX -= 0.5_n;
                else
                    NPC[A].Location.SpeedX += 0.5_n;
            }

            // preserved by the interrupt / resume routine
            int KillCode;
            KillCode = NPC[A].Killed;

            while(KillNPC(A, NPC[A].Killed))
            {
                g_gameLoopInterrupt.site = GameLoopInterrupt::UpdateNPCs_KillNPC;
                g_gameLoopInterrupt.A = i; // NOT A
                g_gameLoopInterrupt.B = KillCode;
                // C is reserved as the event index
                g_gameLoopInterrupt.D = last_NPC;
                g_gameLoopInterrupt.E = KilledQueue_check;
                g_gameLoopInterrupt.F = KilledQueue_known;
                return true;

resume_KillNPC:
                i = g_gameLoopInterrupt.A;
                A = NPCQueues::Killed[i];
                KillCode = g_gameLoopInterrupt.B;

                last_NPC = g_gameLoopInterrupt.D;
                KilledQueue_check = g_gameLoopInterrupt.E;
                KilledQueue_known = g_gameLoopInterrupt.F;
            }

            // KillNPC sometimes adds duplicate / unnecessary members to NPCQueues::Killed
            bool real_new_killed = false;
            if(NPCQueues::Killed.size() > KilledQueue_known)
            {
                for(size_t j = NPCQueues::Killed.size() - 1; j >= KilledQueue_known; j--)
                {
                    int K = NPCQueues::Killed[j];
                    if(K != A && K >= 1 && K <= numNPCs)
                    {
                        real_new_killed = true;
                        break;
                    }
                }

                // ignore if no real new NPCs added
                if(!real_new_killed)
                    NPCQueues::Killed.resize(KilledQueue_known);
                else
                {
                    pLogDebug("During KillNPC(%d), %d actual new killed NPC indexes added.", A, (int)(NPCQueues::Killed.size() - KilledQueue_known));
                    KilledQueue_known = NPCQueues::Killed.size();
                }
            }

            // rare cases exist where a real new NPC is killed (mostly events that hide layers)
            // sort and check the ones smaller than A
            if(real_new_killed)
            {
                size_t old_check = KilledQueue_check;

                // partition to check all the ones < A this frame
                auto first_bigger_it = std::partition(NPCQueues::Killed.begin() + KilledQueue_check, NPCQueues::Killed.end(),
                [A](NPCRef_t a)
                {
                    return (int)a < A;
                });

                KilledQueue_check = first_bigger_it - NPCQueues::Killed.begin();

                if(old_check != KilledQueue_check)
                {
                    pLogDebug("Found %d indexes lower than %d. Sorting to check this frame.", (int)(first_bigger_it - NPCQueues::Killed.begin()) - (int)old_check, A);

                    // re-sort the range to check this frame
                    NPCQueues::reverse_sort(
                        reinterpret_cast<int16_t*>(NPCQueues::Killed.data() + i + 1),
                        reinterpret_cast<int16_t*>(NPCQueues::Killed.data() + KilledQueue_check)
                    );
                }
            }
        }
    }

    if(NPCQueues::Killed.size() > KilledQueue_check)
    {
        NPCQueues::Killed.erase(NPCQueues::Killed.begin(), NPCQueues::Killed.begin() + KilledQueue_check);
        pLogDebug("Checking %d newly killed NPC indexes next frame.", (int)NPCQueues::Killed.size());
    }
    else
        NPCQueues::Killed.clear();

    //    if(nPlay.Online == true)
    //    {
    //        if(nPlay.Mode == 1)
    //        {
    //            nPlay.NPCWaitCount += 10;
    //            if(nPlay.NPCWaitCount >= 5)
    //            {
    //                tempStr = "L" + LB;
    //                for(int A = 1; A <= numNPCs; A++)
    //                {
    //                    if(NPC[A].Active == true && NPC[A].TimeLeft > 1)
    //                    {
    //                        if(NPC[A].HoldingPlayer <= 1)
    //                        {
    //                            tempStr += "K" + std::to_string(A) + "|" + NPC[A].Type + "|" + NPC[A].Location.X + "|" + NPC[A].Location.Y + "|" + std::to_string(NPC[A].Location.Width) + "|" + std::to_string(NPC[A].Location.Height) + "|" + NPC[A].Location.SpeedX + "|" + NPC[A].Location.SpeedY + "|" + NPC[A].Section + "|" + NPC[A].TimeLeft + "|" + NPC[A].Direction + "|" + std::to_string(static_cast<int>(floor(static_cast<double>(NPC[A].Projectile)))) + "|" + NPC[A].Special + "|" + NPC[A].Special2 + "|" + NPC[A].Special3 + "|" + NPC[A].Special4 + "|" + NPC[A].Special5 + "|" + NPC[A].Effect + LB;
    //                            if(NPC[A].Effect != NPCEFF_NORMAL)
    //                                tempStr += "2c" + std::to_string(A) + "|" + NPC[A].Effect2 + "|" + NPC[A].Effect3 + LB;
    //                        }
    //                    }
    //                }
    //                Netplay::sendData tempStr + "O" + std::to_string(numPlayers) + LB;
    //                nPlay.NPCWaitCount = 0;
    //            }
    //        }
    //    }
    CharStuff();

    return false;
}


================================================
FILE: src/npc/safe_set.hpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#pragma once

#ifndef SAFE_SET_HPP
#define SAFE_SET_HPP

#include <set>

template<class T>
class SafeSet
{
    using PlainSet = std::set<T>;
    using PlainIt = typename std::set<T>::iterator;

    bool invalid = false;
    PlainSet m_set;

public:
    struct InsertEraseSafeIteration
    {
        SafeSet& parent;

        InsertEraseSafeIteration(SafeSet& parent) : parent(parent) {}

        struct iterator
        {
            SafeSet* m_parent;
            PlainIt it;
            int prev_invalid;

            T last_val;

            inline iterator(SafeSet& parent) : m_parent(&parent), it(parent.m_set.begin()), prev_invalid(parent.invalid)
            {
                if(it != parent.m_set.end())
                    last_val = *it;
                m_parent->invalid = false;
            }

            inline iterator(SafeSet& parent, std::nullptr_t ptr) : m_parent(ptr), it(parent.m_set.end()), prev_invalid(-1) {}

            inline ~iterator()
            {
                if(m_parent && prev_invalid > 0)
                    m_parent->invalid = true;

                m_parent = nullptr;
            }

            inline bool operator!=(const iterator& o)
            {
                return it != o.it;
            }

            inline bool operator!=(const PlainIt oit)
            {
                return it != oit;
            }

            inline T operator*()
            {
                return last_val;
            }

            inline const iterator& operator++()
            {
                if(m_parent->invalid)
                    it = m_parent->m_set.upper_bound(last_val);
                else
                    ++it;

                if(it != m_parent->m_set.end())
                    last_val = *it;

                return *this;
            }
        };

        iterator begin()
        {
            return iterator(parent);
        }

        iterator end()
        {
            return iterator(parent, nullptr);
        }
    };

    InsertEraseSafeIteration safe{*this};

    std::set<T>& no_change = m_set;
    std::set<T>& may_insert = m_set;
    InsertEraseSafeIteration& may_erase = safe;
    InsertEraseSafeIteration& may_insert_erase = safe;

    inline void clear()
    {
        invalid = true;
        m_set.clear();
    }

    inline void insert(const T& t)
    {
        m_set.insert(t);
    }

    inline void erase(const T& t)
    {
        invalid = true;
        m_set.erase(t);
    }

    inline void invalidate()
    {
        invalid = true;
    }
};

#endif // #ifndef SAFE_SET_HPP


================================================
FILE: src/npc/section_overlap.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>

#include "globals.h"

#include "npc/section_overlap.h"

std::array<uint8_t, maxSections + 1> g_SectionFirstOverlap;

//! Check if two section bounds collide
static bool s_SectionCollide(const SpeedlessLocation_t& bounds, const SpeedlessLocation_t& other_bounds)
{
    // remember that section bounds are stored "incorrectly" with "Width" / "Height" referring to the Right / Bottom
    return (bounds.Width >= other_bounds.X
        && bounds.X <= other_bounds.Width
        && bounds.Height >= other_bounds.Y
        && bounds.Y <= other_bounds.Height);
}

//! Find the first section (from start) that overlaps with S, and store it into g_SectionFirstOverlap[S]
static void s_FindFirstOverlap(int S, int start)
{
    g_SectionFirstOverlap[S] = S;

    for(int O = start; O < S; O++)
    {
        if(s_SectionCollide(level[S], level[O]))
        {
            g_SectionFirstOverlap[S] = O;
            D_pLogDebug("Note: section %d is the first section overlapping section %d", O, S);
            break;
        }
    }
}

//! Find the first section that overlaps with each section
void CalculateSectionOverlaps()
{
    for(int S = 0; S < numSections; S++)
        s_FindFirstOverlap(S, 0);
}

void UpdateSectionOverlaps(int S, bool shrink)
{
    // if not a shrink, find first section overlapping S
    if(!shrink)
        s_FindFirstOverlap(S, 0);
    // if a shrink, only check sections starting from current first overlap
    else if(g_SectionFirstOverlap[S] != S)
        s_FindFirstOverlap(S, g_SectionFirstOverlap[S]);

    // update all sections after S (for which S might be first overlap)
    for(int O = S + 1; O < numSections; O++)
    {
        // if S is the current overlap, check that it still applies
        if(g_SectionFirstOverlap[O] == S)
        {
            if(!s_SectionCollide(level[S], level[O]))
                s_FindFirstOverlap(O, S + 1);
        }
        // if S is earlier than the current overlap (and not a shrink), check if S is the new first overlap
        else if(!shrink && g_SectionFirstOverlap[O] > S)
        {
            if(s_SectionCollide(level[S], level[O]))
                g_SectionFirstOverlap[O] = S;
        }
    }
}


================================================
FILE: src/npc/section_overlap.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SECTION_OVERLAP_H
#define SECTION_OVERLAP_H

#include <array>
#include <cstdint>

#include "global_constants.h"

extern std::array<uint8_t, maxSections + 1> g_SectionFirstOverlap;

//! calculate all section overlaps, called on level load
void CalculateSectionOverlaps();

//! Update section overlaps after section S's bounds are changed.
//  Set shrink if section S's new bounds are contained in its old bounds.
void UpdateSectionOverlaps(int S, bool shrink = false);


#endif


================================================
FILE: src/npc.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include "globals.h"
#include "npc.h"
#include "sound.h"
#include "graphics.h"
#include "effect.h"
#include "game_main.h"
#include "player.h"
#include "collision.h"
#include "editor.h"
#include "blocks.h"
#include "controls.h"
#include "config.h"
#include "main/trees.h"
#include "core/events.h"
#include "npc_id.h"
#include "eff_id.h"
#include "npc_traits.h"
#include "layers.h"

#include "npc/npc_queues.h"
#include "npc/npc_activation.h"
#include "npc/section_overlap.h"
#include "npc/npc_cockpit_bits.h"
#include "npc/npc_update/npc_update_priv.h"

void NPC_t::ResetLocation()
{
    Location.X = DefaultLocationX;
    Location.Y = DefaultLocationY;
    Location.Width = (*this)->TWidth;
    Location.Height = (*this)->THeight;
    Location.SpeedX = 0;
    Location.SpeedY = 0;

    if(DefaultLocationHeight_Force32)
        Location.Height = 32;
}

// UpdateNPCs at npc/npc_update.cpp

// NpcHit at npc/npc_hit.cpp

num_t NPCPlayerTargetDist(const NPC_t& npc, const Player_t& player)
{
    num_t dx = npc.Location.minus_center_x(player.Location);

    if(g_config.fix_multiplayer_targeting)
    {
        num_t dy = npc.Location.minus_center_y(player.Location);
        return num_t::dist2(dx, dy);
    }
    else
        return num_t::abs(dx);
}

int NPCTargetPlayer(const NPC_t& npc)
{
    int target_plr = 0;
    num_t min_dist = 0;

    for(int B = 1; B <= numPlayers; B++)
    {
        if(!Player[B].Dead && Player[B].Section == npc.Section)
        {
            if(numPlayers == 1)
                return 1;

            num_t dist = NPCPlayerTargetDist(npc, Player[B]);
            if(min_dist == 0 || dist < min_dist)
            {
                min_dist = dist;
                target_plr = B;
            }
        }
    }

    return target_plr;
}

int NPCFaceNearestPlayer(NPC_t& npc, bool old_version)
{
    int target = NPCTargetPlayer(npc);

    num_t target_center = Player[target].Location.X + Player[target].Location.Width / 2;

    // broken version of logic that appears in a few places
    if(old_version)
    {
        if(target_center > npc.Location.X + 16)
            npc.Direction = 1;
        else
            npc.Direction = -1;
    }
    else
    {
        if(target != 0)
        {
            if(npc.Location.X + npc.Location.Width / 2 > target_center)
                npc.Direction = -1;
            else
                npc.Direction = 1;
        }
    }

    return target;
}

static void s_NPCSetSpeedTarget_FixedX_dist(NPC_t& npc, num_t dist_x, num_t dist_y, int speed_x, int speed_y_cap)
{
    // originally only applied to plant, but good to apply in all cases (and was UB in VB6)
    if(dist_x == 0)
        dist_x = -0.00001_n;

    npc.Location.SpeedX = speed_x * npc.Direction;
    npc.Location.SpeedY = speed_x * npc.Direction * dist_y.divided_by(dist_x);

    if(NPC[numNPCs].Location.SpeedY > speed_y_cap)
        NPC[numNPCs].Location.SpeedY = speed_y_cap;
    else if(NPC[numNPCs].Location.SpeedY < -speed_y_cap)
        NPC[numNPCs].Location.SpeedY = -speed_y_cap;
}

void NPCSetSpeedTarget_FixedX(NPC_t& npc, const Location_t& target, int speed_x, int speed_y_cap)
{
    num_t dist_x = target.minus_center_x(npc.Location);
    num_t dist_y = target.minus_center_y(npc.Location);

    s_NPCSetSpeedTarget_FixedX_dist(npc, dist_x, dist_y, speed_x, speed_y_cap);
}

void NPCSetSpeedTarget_FixedX(NPC_t& npc, num_t target_x, num_t target_y, int speed_x, int speed_y_cap)
{
    num_t dist_x = target_x - (npc.Location.X + npc.Location.Width / 2);
    num_t dist_y = target_y - (npc.Location.Y + npc.Location.Height / 2);

    s_NPCSetSpeedTarget_FixedX_dist(npc, dist_x, dist_y, speed_x, speed_y_cap);
}

void NPCSetSpeedTarget_FixedSpeed(NPC_t& npc, const Location_t& target, int speed)
{
    num_t dist_x = target.minus_center_x(npc.Location);
    num_t dist_y = target.minus_center_y(npc.Location);

    num_t dist = num_t::dist(dist_x, dist_y);

    npc.Location.SpeedX = speed * dist_x.divided_by(dist);
    npc.Location.SpeedY = speed * dist_y.divided_by(dist);
}

void CheckSectionNPC(int A)
{
    if(GameMenu)
        return;

    if(NPC[A].HoldingPlayer > 0)
    {
        if(NPC[A].TimeLeft < 10)
            NPC[A].TimeLeft = 10;
        NPC[A].Section = Player[NPC[A].HoldingPlayer].Section;
    }

    // disabled in 1.3.6.1 because of bugs when overlapping sections change
    // Previously, it optimized for section 0. Now, it optimizes for NPC's current section.
    int B = NPC[A].Section;
    if(B <= maxSections && g_SectionFirstOverlap[B] == B && NPC[A].Location.X >= level[B].X)
    {
        if(NPC[A].Location.X + NPC[A].Location.Width <= level[B].Width)
        {
            if(NPC[A].Location.Y >= level[B].Y)
            {
                if(NPC[A].Location.Y + NPC[A].Location.Height <= level[B].Height)
                {
                    return;
                }
            }
        }
    }

    for(int B = 0; B < numSections; B++)
    {
        if(NPC[A].Location.X >= level[B].X)
        {
            if(NPC[A].Location.X + NPC[A].Location.Width <= level[B].Width)
            {
                if(NPC[A].Location.Y >= level[B].Y)
                {
                    if(NPC[A].Location.Y + NPC[A].Location.Height <= level[B].Height)
                    {
                        NPC[A].Section = B;
                        return;
                    }
                }
            }
        }
    }
}

void Deactivate(int A)
{
    if(NPC[A].DefaultType > 0)
    {
        if(NPC[A].TurnBackWipe && NoTurnBack[NPC[A].Section])
        {
            NPC[A].Killed = 9;
            NPCQueues::Killed.push_back(A);
        }
        else
        {
            if(NPC[A].Type == NPCID_SKELETON && NPC[A].Special > 0)
            {
                NPC[A].Inert = false;
                NPC[A].Stuck = false;
            }

            // reset variables back to default
            NPC[A].Quicksand = 0;
            NPC[A].NoLavaSplash = false;
            NPC[A].Active = false;

            // prevent instantly respawning, unless the animation will be totally seamless
            if(!g_config.fix_npc_camera_logic
                || !NPC_InactiveRender(NPC[A])
                || num_t::floor(NPC[A].Location.X) != num_t::floor(NPC[A].DefaultLocationX)
                || num_t::floor(NPC[A].Location.Y) != num_t::floor(NPC[A].DefaultLocationY))
            {
                NPC[A].Reset[1] = false;
                NPC[A].Reset[2] = false;
            }

            // reset variables
            NPC[A].Type = NPC[A].DefaultType;
            NPC[A].ResetLocation();
            NPC[A].Direction = NPC[A].DefaultDirection;
            NPC[A].Stuck = NPC[A].DefaultStuck;

            // NEW: reset wings (unless the NPC is a container that bans wings)
            NPC[A].Wings = NPC[A].DefaultWings;
            if(NPC[A].Type == NPCID_ITEM_BURIED || NPC[A].Type == NPCID_ITEM_BUBBLE)
                NPC[A].Wings = WING_NONE;

            NPC[A].TimeLeft = 0;
            NPC[A].Projectile = false;
            NPC[A].Effect = NPCEFF_NORMAL;

            // counter to respawn
            if(NPC[A].RespawnDelay)
                NPC[A].Effect2 = 65 * 30;
            else
                NPC[A].Effect2 = 0;

            NPC[A].Effect3 = 0;
            NPC[A].BeltSpeed = 0;
            NPC[A].vehiclePlr = 0;
            NPC[A].vehicleYOffset = 0;
            NPC[A].Frame = 0;
            NPC[A].Killed = 0;
            NPC[A].Shadow = false;
            NPC[A].oldAddBelt = 0;

            // DefaultSpecial
            NPC[A].Special = NPC[A].DefaultSpecial;
            NPC[A].Special2 = 0; // NPC[A].DefaultSpecial2; // moved to Variant for the one type (NPCID_MAGIC_DOOR) that used it

            // for generators, these store critical variables
            if(!NPC[A].Generator)
            {
                NPC[A].Special3 = 0;
                NPC[A].Special4 = 0;
                NPC[A].Special5 = 0;
            }

            // NPC[A].Special6 = 0;
            NPC[A].SpecialX = 0;
            NPC[A].SpecialY = 0;
            if(!NPC[A]->IsACoin)
                NPC[A].Damage = 0;
            NPC[A].HoldingPlayer = 0;

            // NPC[A].Pinched1 = 0;
            // NPC[A].Pinched2 = 0;
            // NPC[A].Pinched3 = 0;
            // NPC[A].Pinched4 = 0;
            // NPC[A].Pinched = 0;
            // NPC[A].MovingPinched = 0;

            NPC[A].Pinched = PinchedInfo_t();

            // new-added logic: if CURRENTLY offscreen for all vScreens, allow it to reset
            if(g_config.fix_frame_perfect_despawn && (g_config.fix_timestop_respawn || !FreezeNPCs))
            {
                bool hit = false;

                for(int screen_i = 0; !hit && screen_i < c_screenCount; screen_i++)
                {
                    const Screen_t& screen = Screens[screen_i];

                    for(int vscreen_i = screen.active_begin(); !hit && vscreen_i < screen.active_end(); vscreen_i++)
                    {
                        int vscreen_Z = screen.vScreen_refs[vscreen_i];

                        if(vScreenCollision(vscreen_Z, NPC[A].Location))
                            hit = true;
                    }
                }

                if(!hit)
                {
                    NPC[A].Reset[1] = true;
                    NPC[A].Reset[2] = true;
                }
            }

            // NEW now that we have the new NPC Queues
            NPCQueues::update(A);
            bool changed = treeNPCUpdate(A);
            if(changed && NPC[A].tempBlock > 0)
                treeNPCSplitTempBlock(A);
        }
    }
    else if(NPCIsAnExit(NPC[A]))
        NPC[A].TimeLeft = 100;
    else
    {
        NPC[A].Killed = 9;
        NPCQueues::Killed.push_back(A);
    }
}

void Bomb(Location_t Location, int Game, int ImmunePlayer)
{
    num_t Radius = 0;
    // int i = 0;
    num_t X = 0;
    num_t Y = 0;
    num_t A = 0;
    num_t B = 0;
    num_t C = 0;

    NPC[0].Multiplier = 0;
    if(Game == 0)
    {
        NewEffect(EFFID_CHAR3_HEAVY_EXPLODE, Location);
        PlaySoundSpatial(SFX_Bullet, Location);
        Radius = 32;
    }
    if(Game == 2)
    {
        Controls::RumbleAllPlayers(150, 1.0);
        NewEffect(EFFID_BOMB_S2_EXPLODE, Location);
        PlaySoundSpatial(SFX_Fireworks, Location);
        Radius = 52;
    }
    if(Game == 3)
    {
        Controls::RumbleAllPlayers(200, 1.0);
        NewEffect(EFFID_BOMB_S3_EXPLODE_SEED, Location);
        PlaySoundSpatial(SFX_Fireworks, Location);
        Radius = 64;
    }

    X = Location.X + Location.Width / 2;
    Y = Location.Y + Location.Height / 2;

    for(int i : treeNPCQuery(newLoc(X - Radius, Y - Radius, Radius * 2, Radius * 2), SORTMODE_ID))
    {
        if(!NPC[i].Hidden && NPC[i].Active && !NPC[i].Inert && !NPC[i].Generator && !NPC[i]->IsABonus)
        {
            if(NPC[i].Type != NPCID_PLR_FIREBALL && NPC[i].Type != NPCID_CHAR3_HEAVY)
            {
                A = NPC[i].Location.X + NPC[i].Location.Width / 2 - X;
                B = NPC[i].Location.Y + NPC[i].Location.Height / 2 - Y;
                C = num_t::dist(A, B);

                if(C <= Radius + NPC[i].Location.Width / 4 + NPC[i].Location.Height / 4)
                {
                    NPC[0].Location = NPC[i].Location;
                    NPCHit(i, 3, 0);
                    if(NPCIsVeggie(NPC[i]))
                    {
                        NPC[i].Projectile = true;
                        NPC[i].Location.SpeedY = -5;
                        NPC[i].Location.SpeedX = dRand() * 4 - 2;
                    }
                }
            }
        }
    }

    for(int i : treeBlockQuery(newLoc(X - Radius, Y - Radius, Radius * 2, Radius * 2), SORTMODE_COMPAT))
    {
        if(!Block[i].Hidden && !BlockNoClipping[Block[i].Type])
        {
            A = Block[i].Location.X + Block[i].Location.Width / 2 - X;
            B = Block[i].Location.Y + Block[i].Location.Height / 2 - Y;
            C = num_t::dist(A, B);

            if(C <= Radius + Block[i].Location.Width / 4 + Block[i].Location.Height / 4)
            {
                BlockHit(i);
                BlockHitHard(i);
                if(Game == 0 && Block[i].Type == 457)
                    SafelyKillBlock(i);
            }
        }
    }

    if(Game != 0 || BattleMode)
    {
        for(int i = 1; i <= numPlayers; i++)
        {
            if(Game != 0 || i != ImmunePlayer)
            {
                A = Player[i].Location.X + Player[i].Location.Width / 2 - X;
                B = Player[i].Location.Y + Player[i].Location.Height / 2 - Y;
                C = num_t::dist(A, B);

                if(C <= Radius + Player[i].Location.Width / 4 + Player[i].Location.Height / 4)
                    PlayerHurt(i);
            }
        }
    }
}

#if 0
// dead code, removed

void DropNPC(int A, int NPCType)
{
    int B = 0;
    if(A == 1 || numPlayers == 2)
    {
        PlaySound(SFX_DropItem);
        numNPCs++;
        NPC[numNPCs].Type = NPCType;
        NPC[numNPCs].Location.Width = NPCWidth(NPCType);
        NPC[numNPCs].Location.Height = NPCHeight(NPCType);
        if(ScreenType == 5 && !vScreen[2].Visible)
        {
            if(A == 1)
                B = -40;
            if(A == 2)
                B = 40;
            NPC[numNPCs].Location.X = -vScreen[1].X + vScreen[1].Width / 2 - NPC[numNPCs].Location.Width / 2 + B;
            NPC[numNPCs].Location.Y = -vScreen[1].Y + 16 + 12;
        }
        else
        {
            NPC[numNPCs].Location.X = -vScreen[A].X + vScreen[A].Width / 2 - NPC[numNPCs].Location.Width / 2;
            NPC[numNPCs].Location.Y = -vScreen[A].Y + 16 + 12;
        }
        NPC[numNPCs].Location.SpeedX = 0;
        NPC[numNPCs].Location.SpeedY = 0;
        NPC[numNPCs].Effect = NPCEFF_DROP_ITEM;
        NPC[numNPCs].Active = true;
        NPC[numNPCs].TimeLeft = 200;
        syncLayers_NPC(numNPCs);
    }
}
#endif

void TurnNPCsIntoCoins()
{
    // need this complex loop syntax because Active can be modified within it
    for(int A : NPCQueues::Active.may_erase)
    {
        if(NPC[A].Active && !NPC[A].Generator)
        {
            if(!NPC[A].Hidden && NPC[A].Killed == 0 && !NPCIsAnExit(NPC[A]) && !NPC[A].Inert)
            {
                if(!NPCIsYoshi(NPC[A]) && !NPCIsBoot(NPC[A]) &&
                   !NPC[A]->IsABonus && NPC[A].Type != NPCID_PLR_ICEBALL && NPC[A].Type != NPCID_PLR_FIREBALL &&
                   NPC[A].Type != NPCID_PET_FIRE && NPC[A].Type != NPCID_SPRING && !NPCIsVeggie(NPC[A]) &&
                   NPC[A].Type != NPCID_ITEM_BURIED && NPC[A].Type != NPCID_PLR_HEAVY && !NPC[A]->IsAVine &&
                   NPC[A].Type != NPCID_VEHICLE && NPC[A].Type != NPCID_YEL_PLATFORM && NPC[A].Type != NPCID_BLU_PLATFORM &&
                   NPC[A].Type != NPCID_GRN_PLATFORM && NPC[A].Type != NPCID_RED_PLATFORM && NPC[A].Type != NPCID_PLATFORM_S3 &&
                   !(NPC[A].Projectile && NPC[A].Type == NPCID_HEAVY_THROWN) &&
                   !(NPC[A].Projectile && NPC[A].Type == NPCID_BULLET) &&
                   NPC[A].Type != NPCID_CHAR3_HEAVY && NPC[A].Type != NPCID_CHAR4_HEAVY && NPC[A].Type != NPCID_SWORDBEAM &&
                   NPC[A].Type != NPCID_CONVEYOR && NPC[A].Type != NPCID_METALBARREL &&
                   !(NPC[A].Type >= NPCID_TANK_TREADS && NPC[A].Type <= NPCID_SLANT_WOOD_M) &&
                   NPC[A].Type != NPCID_ITEM_BURIED && NPC[A].Type != NPCID_FIRE_CHAIN && NPC[A].Type != NPCID_FIRE_DISK)
                {
                    NPC[A].Location.Y += 32;
                    NewEffect(EFFID_COIN_BLOCK_S3, NPC[A].Location);
                    PlaySoundSpatial(SFX_Coin, NPC[A].Location);
                    Coins += 1;
                    if(Coins >= 100)
                        Got100Coins();

                    NPC[A].Killed = 9;
                    NPC[A].Location.Height = 0;

                    NPCQueues::Killed.push_back(A);

                    if(NPC[A].Active)
                        NPCQueues::Active.erase(A);

                    NPC[A].Active = false;

                    treeNPCUpdate(A);
                    if(NPC[A].tempBlock != 0)
                        treeNPCSplitTempBlock(A);
                }
                else if(NPC[A].Type == NPCID_GOALTAPE || NPC[A].Type == NPCID_FIRE_CHAIN || NPC[A].Type == NPCID_FIRE_DISK)
                {
                    NPC[A].Active = false;
                    NPCQueues::update(A);
                }
            }
        }
        else if(NPC[A].Generator)
        {
            NPC[A].Killed = 9;
            NPC[A].Hidden = true;

            NPCQueues::Killed.push_back(A);
        }
    }
}

#if 0
// previous recursive version of the function

void SkullRide(int A, bool reEnable)
{
    Location_t loc = NPC[A].Location;
    loc.Width += 16;
    loc.X -= 8;
    if(g_config.fix_skull_raft) // Detect by height in condition skull ruft cells were on slopes
    {
        loc.Height += 30;
        loc.Y -= 15;
    }

    int spec = reEnable ? 2 : 0;

    for(int B = 1; B <= numNPCs; B++) // Recursively activate all neihbour skull-ride segments
    {
        auto &npc = NPC[B];
        if(npc.Type == NPCID_RAFT)
        {
            if(npc.Active)
            {
                if(npc.Special == spec)
                {
                    if(CheckCollision(loc, npc.Location))
                    {
                        npc.Special = 1;
                        SkullRide(B, reEnable);
                    }
                }
            }
        }
    }
}
#endif

static void s_alignRuftCell(NPC_t &me, const Location_t &alignAt)
{
    num_t w = me.Location.Width;
    me.Location.SpeedX = 0;
    me.RealSpeedX = 0;

    if(me.Direction > 0)
    {
        auto p = alignAt.X;
        do
        {
            p -= w;
        } while(num_t::abs(p - me.Location.X) >= w / 2 && p > me.Location.X);
        me.Location.X = p;
    }
    else
    {
        auto p = alignAt.X + alignAt.Width;
        while(num_t::abs(p - me.Location.X) >= w / 2 && p < me.Location.X + me.Location.Width)
        {
            p += w;
        }
        me.Location.X = p;
    }

    me.SpecialX = me.Location.X;
    treeNPCUpdate(&me);
    if(me.tempBlock != 0)
        treeNPCSplitTempBlock(&me);
}

#if 0
// previous recursive version of the function

void SkullRideDone(int A, const Location_t &alignAt)
{
    auto &me = NPC[A];

    Location_t loc = me.Location;
    loc.Width += 16;
    loc.X -= 8;
    loc.Height += 30;
    loc.Y -= 15;

    for(int B = 1; B <= numNPCs; B++) // Recursively DE-activate all neighbour skull-ride segments
    {
        auto &npc = NPC[B];
        if(npc.Type == NPCID_RAFT)
        {
            if(npc.Active)
            {
                if(npc.Special == 1.0)
                {
                    if(CheckCollision(loc , npc.Location))
                    {
                        npc.Special = 2;
                        npc.Location.SpeedX = 0.0;
                        s_alignRuftCell(npc, alignAt);
                        SkullRideDone(B, alignAt);
                    }
                }
            }
        }
    }
}
#endif


// this mimics the above functions and should match it in all cases
void SkullRide(int A, bool reEnable, const Location_t *alignAt)
{
    int spec = (alignAt) ? 1 : (reEnable ? 2 : 0);

    // allocates and guards a vector of BaseRef_t in its i_vec.
    TreeResult_Sentinel<NPCRef_t> frontier;

    // LIFO stack of NPCs to trigger, imitates recursion from old SkullRide
    std::vector<BaseRef_t>& vec = *frontier.i_vec;

    vec.push_back(A);

    while(!vec.empty())
    {
        // pop from top of stack
        const NPC_t& me = static_cast<NPCRef_t>(vec.back());
        vec.pop_back();

        // construct location query (head of original SkullRide)
        Location_t loc = me.Location;
        loc.Width += 16;
        loc.X -= 8;

        if(g_config.fix_skull_raft) // Detect by height in condition skull ruft cells were on slopes
        {
            loc.Height += 30;
            loc.Y -= 15;
        }

        // add all queried NPCs to the frontier's internal vector (but check them, and remove them if invalid)
        size_t current_frontier_size = vec.size();

        treeNPCQuery(vec, loc, SORTMODE_NONE);

        size_t unchecked = current_frontier_size;
        while(unchecked < vec.size())
        {
            NPC_t& npc = static_cast<NPCRef_t>(vec[unchecked]);

            // conditions from inside of loop in original SkullRide
            if(npc.Type == NPCID_RAFT && npc.Active && npc.Special == spec && CheckCollision(loc, npc.Location))
            {
                if(alignAt)
                {
                    npc.Special = 2;
                    npc.Location.SpeedX = 0;
                    s_alignRuftCell(npc, *alignAt);
                }
                else
                {
                    // set active flag
                    npc.Special = 1;
                }

                // previously, used recursion
                // SkullRide(B, reEnable);

                // this will preserve the NPC in the stack
                unchecked++;
                continue;
            }

            // remove the NPC from the stack if conditions fail
            vec[unchecked] = vec[vec.size() - 1];
            vec.pop_back();
        }

        // reverse sort the frontier of the stack because this is a depth-first approach
        NPCQueues::reverse_sort(
            reinterpret_cast<int16_t*>(vec.data() + current_frontier_size),
            reinterpret_cast<int16_t*>(vec.data() + vec.size())
        );
    }
}

static void s_NPCSpawnCustomThrown(NPC_t& thrower, NPC_t& new_npc)
{
    new_npc.Location.Width = new_npc->TWidth;
    new_npc.Location.Height = new_npc->THeight;
    new_npc.Variant = thrower.Variant;

    num_t floor_y = thrower.Location.Y + thrower.Location.Height - new_npc.Location.Height;
    if(new_npc.Location.Y > floor_y)
        new_npc.Location.Y = floor_y;

    new_npc.Immune = 12;

    if(new_npc->IsACoin || new_npc.Type == NPCID_SLIDE_BLOCK)
    {
        if(NPC[numNPCs]->IsACoin)
            NPC[numNPCs].Location.SpeedX /= 2;

        new_npc.Special = 1;
    }
    else if(new_npc.Type == NPCID_HOMING_BALL)
        new_npc.Special2 = 95;

    if(new_npc->IsABlock)
    {
        if(new_npc.Direction > 0)
            new_npc.Location.X = thrower.Location.X + thrower.Location.Width;
        else
            new_npc.Location.X = thrower.Location.X - new_npc.Location.Width;
    }

    if(new_npc.Type != NPCID_BULLET && new_npc.Type != NPCID_BOMB && new_npc.Type != NPCID_HOMING_BALL
        && new_npc.Type != NPCID_HOMING_BALL_GEN && new_npc.Type != NPCID_STACKER && new_npc.Type != NPCID_WALK_PLANT
        && new_npc.Type != NPCID_VINE_BUG && new_npc.Type != NPCID_BOSS_CASE && new_npc.Type != NPCID_FLY
        && !new_npc->IsACoin)
    {
        new_npc.Projectile = true;
    }

    if(thrower.Inert && !(new_npc->IsACoin || new_npc->IsABonus || new_npc->WontHurt))
        new_npc.Inert = true;
}

void NPCSpecial(int A)
{
    // double C = 0;
    // double D = 0;
    // double E = 0;
    // double F = 0;
    // int64_t fBlock = 0;
    // int64_t lBlock = 0;
    // bool straightLine = false; // SET BUT NOT USED
    bool tempBool = false;
    // bool tempBool2 = false;
    // Location_t tempLocation;
    // NPC_t tempNPC;
    auto &npc = NPC[A];

    if(npc.Type == NPCID_BOSS_CASE) // previously included many other bosses, now moved into their logic
    {
        // dont despawn
        if(npc.TimeLeft > 1)
            npc.TimeLeft = 100;
    }
    else if(npc.Type == NPCID_RED_VINE_TOP_S3 || npc.Type == NPCID_GRN_VINE_TOP_S3 || npc.Type == NPCID_GRN_VINE_TOP_S4) // Vine Maker
    {
        npc.Location.SpeedY = -2;
        Location_t tempLocation;
        tempLocation.Height = 28;
        tempLocation.Width = 30;
        tempLocation.Y = npc.Location.Y + (npc.Location.Height - tempLocation.Height) / 2;
        tempLocation.X = npc.Location.X + (npc.Location.Width - tempLocation.Width) / 2;
        tempBool = false;

        for(int i : treeNPCQuery(tempLocation, SORTMODE_NONE))
        {
            auto &n = NPC[i];
            if(n->IsAVine && !n.Hidden && CheckCollision(tempLocation, n.Location))
            {
                tempBool = true;
                break;
            }
        }

        // this block had no effect because the inner `tempBool = True` was commented in the original VB6 code
#if 0
        if(!tempBool)
        {
            // fBlock = FirstBlock[static_cast<int>(floor(static_cast<double>(tempLocation.X / 32))) - 1];
            // lBlock = LastBlock[floor((tempLocation.X + tempLocation.Width) / 32.0) + 1];

            for(Block_t* block : treeFLBlockQuery(tempLocation, false))
            {
                auto &b = *block;
                if(!b.Hidden && !BlockNoClipping[b.Type] && !BlockIsSizable[b.Type] && !BlockOnlyHitspot1[b.Type])
                {
                    if(CheckCollision(tempLocation, b.Location) && BlockSlope[b.Type] == 0)
                    {
                        // tempBool = True
                    }
                }
            }
        }
#endif
        // ============================================================

        if(!tempBool || npc.Special == 1)
        {
            numNPCs++;
            if(npc.Type == NPCID_RED_VINE_TOP_S3)
                NPC[numNPCs].Type = NPCID_RED_VINE_S3;
            else if(npc.Type == NPCID_GRN_VINE_TOP_S3)
                NPC[numNPCs].Type = NPCID_GRN_VINE_S3;
            else if(npc.Type == NPCID_GRN_VINE_TOP_S4)
                NPC[numNPCs].Type = NPCID_GRN_VINE_S4;
            NPC[numNPCs].Location.Y = num_t::vb6round(npc.Location.Y / 32) * 32;
            NPC[numNPCs].Location.Height = 32;
            NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
            NPC[numNPCs].Location.X = npc.Location.X + (npc.Location.Width - NPC[numNPCs].Location.Width) / 2;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].TimeLeft = 100;
            NPC[numNPCs].Section = npc.Section;
            NPC[numNPCs].DefaultLocationX = NPC[numNPCs].Location.X;
            NPC[numNPCs].DefaultLocationY = NPC[numNPCs].Location.Y;
            NPC[numNPCs].DefaultLocationHeight_Force32 = true;
            NPC[numNPCs].DefaultType = NPC[numNPCs].Type;
            NPC[numNPCs].Layer = npc.Layer;
            NPC[numNPCs].Shadow = npc.Shadow;
            syncLayers_NPC(numNPCs);
        }

        if(npc.Special == 1)
        {
            npc.Killed = 9;
            NPCQueues::Killed.push_back(A);
        }

        // driving block
    }
    else if(npc.Type == NPCID_COCKPIT)
    {
        // Previously, used Special4 (1 if being driven), Special5 (-1 for left, 1 for right), and Special6 (-1 for up, 1 for down)
        // Now, uses a bitfield in Special4

        // if(npc.Special4 > 0)
        //     npc.Special4 = 0;
        // else
        // {
        //     npc.Special5 = 0;
        //     npc.Special6 = 0;
        // }

        // if(npc.Special5 > 0)
        if(npc.Special4 & NPC_COCKPIT_RIGHT)
        {
            if(npc.Location.SpeedX < 0)
                npc.Location.SpeedX = npc.Location.SpeedX * 0.95_r;
            npc.Location.SpeedX += 0.1_n;
        }
        // else if(npc.Special5 < 0)
        else if(npc.Special4 & NPC_COCKPIT_LEFT)
        {
            if(npc.Location.SpeedX > 0)
                npc.Location.SpeedX = npc.Location.SpeedX * 0.95_r;
            npc.Location.SpeedX -= 0.1_n;
        }
        else
        {
            npc.Location.SpeedX = npc.Location.SpeedX * 0.95_r;
            if(npc.Location.SpeedX > -0.1_n && npc.Location.SpeedX < 0.1_n)
                npc.Location.SpeedX = 0;
        }

        // if(npc.Special6 > 0)
        if(npc.Special4 & NPC_COCKPIT_DOWN)
        {
            if(npc.Location.SpeedY < 0)
                npc.Location.SpeedY = npc.Location.SpeedY * 0.95_r;
            npc.Location.SpeedY += 0.1_n;
        }
        // else if(npc.Special6 < 0)
        else if(npc.Special4 & NPC_COCKPIT_UP)
        {
            if(npc.Location.SpeedY > 0)
                npc.Location.SpeedY = npc.Location.SpeedY * 0.95_r;
            npc.Location.SpeedY -= 0.1_n;
        }
        else
        {
            npc.Location.SpeedY = npc.Location.SpeedY * 0.95_r;
            if(npc.Location.SpeedY > -0.1_n && npc.Location.SpeedY < 0.1_n)
                npc.Location.SpeedY = 0;
        }

        // reset after reading
        npc.Special4 = 0;

        if(npc.Location.SpeedY > 4)
            npc.Location.SpeedY = 4;

        if(npc.Location.SpeedY < -4)
            npc.Location.SpeedY = -4;

        if(npc.Location.SpeedX > 6)
            npc.Location.SpeedX = 6;

        if(npc.Location.SpeedX < -6)
            npc.Location.SpeedX = -6;

    }
    else if(npc.Type == NPCID_CHAR3_HEAVY) // heart bomb
    {
        if(npc.Special4 != 0)
        {
            npc.Killed = 9;
            NPCQueues::Killed.push_back(A);

            int C = npc.BattleOwner;

            if(npc.CantHurtPlayer > 0)
                C = npc.CantHurtPlayer;

            Bomb(npc.Location, 0, C);

            for(int i = 1; i <= 5; i++)
            {
                NewEffect(EFFID_SPARKLE, newLoc(npc.Location.X + npc.Location.Width / 2 - 4, npc.Location.Y + npc.Location.Height / 2 - 6), 1, npc.Shadow);
                Effect[numEffects].Location.SpeedX = dRand() * 6 - 3;
                Effect[numEffects].Location.SpeedY = dRand() * 6 - 3;
                Effect[numEffects].Frame = iRand(3);
            }
        }
    }
    else if(npc.Type == NPCID_VINE_BUG)
    {
        if(!npc.Projectile)
        {
            npc.Location.SpeedX = 0;
            if(npc.Location.SpeedY < 0)
                npc.Special = -1;
            else
                npc.Special = 1;

            Location_t tempLocation = npc.Location;

            if(npc.Special == -1)
                tempLocation.Y -= 1;
            else
                tempLocation.Y += tempLocation.Height + 1;

            tempLocation.Height = 1;
            tempBool = false;

            for(int i : treeNPCQuery(tempLocation, SORTMODE_NONE))
            {
                auto &n = NPC[i];
                if(n.Active && !n.Hidden && n->IsAVine && CheckCollision(tempLocation, n.Location))
                {
                    tempBool = true;
                    break;
                }
            }

            if(!tempBool)
            {
                for(BackgroundRef_t i : treeBackgroundQuery(tempLocation, SORTMODE_NONE))
                {
                    if((int)i > numBackground)
                        continue;

                    Background_t &b = i;
                    if(!b.Hidden && ((b.Type >= 174 && b.Type <= 186) || b.Type == 63) && CheckCollision(tempLocation, b.Location))
                    {
                        tempBool = true;
                        break;
                    }
                }
            }

            if(tempBool)
            {
                if(npc.Special == 1)
                    npc.Location.SpeedY = 2;
                else
                    npc.Location.SpeedY = -1;
            }
            else
            {
                if(npc.Special == -1)
                {
                    npc.Location.SpeedY = 2;
                    npc.Special = 2;
                }
                else
                {
                    npc.Location.SpeedY = -1;
                    npc.Special = -1;
                }
            }
        }
        else
        {
            npc.Location.SpeedY += Physics.NPCGravity;
            npc.Location.SpeedX *= 0.987_r;

            if(npc.Location.SpeedX > -0.1_n && npc.Location.SpeedX < 0.1_n)
                npc.Location.SpeedX = 0;
        }
    }
    else if(npc.Type == NPCID_RANDOM_POWER)
        npc.Type = RandomBonus();
    else if(npc.Type == NPCID_SPIKY_BALL_S4) // falling spiney
    {
        if(npc.Special != 0)
        {
            npc.Type = NPCID_SPIKY_S4;
            npc.Special = 0;

            num_t min_dist = 0;

            for(int i = 1; i <= numPlayers; i++)
            {
                auto &p = Player[i];
                if(!p.Dead && p.Section == npc.Section && p.TimeToLive == 0)
                {
                    num_t horiz_dist = NPCPlayerTargetDist(npc, p);
                    if(min_dist == 0 || horiz_dist < min_dist)
                    {
                        min_dist = horiz_dist;
                        if(npc.Location.to_right_of(p.Location))
                            npc.Direction = -1;
                        else
                            npc.Direction = 1;
                    }
                }
            }

            npc.Location.SpeedX = Physics.NPCWalkingOnSpeed * npc.Direction;
        }
    }
    else if(npc.Type == NPCID_ITEM_BUBBLE) // bubble
    {
        npc.Wings = WING_NONE;

        if(npc.Special == NPCID_RANDOM_POWER)
        {
            npc.Special = RandomBonus();
            npc.DefaultSpecial = npc.Special;
        }

        npc.Location.SpeedX = 0.75_n * npc.DefaultDirection;
        if(npc.Special2 == 0)
            npc.Special2 = -1;

        npc.Location.SpeedY += 0.05_n * npc.Special2;
        if(npc.Location.SpeedY > 1)
        {
            npc.Location.SpeedY = 1;
            npc.Special2 = -1;
        }
        else if(npc.Location.SpeedY < -1)
        {
            npc.Location.SpeedY = -1;
            npc.Special2 = 1;
        }

        if(npc.Special3 > 0)
        {
            NewEffect(EFFID_BUBBLE_POP, npc.Location);
            PlaySoundSpatial(SFX_Bubble, npc.Location);
            npc.Type = NPCID(npc.Special);
            npc.Special3 = 0;
            npc.Special2 = 0;
            npc.Special = 0;
            npc.Frame = EditorNPCFrame(npc.Type, npc.Direction);
            npc.FrameCount = 0;
            npc.Location.set_width_center(npc->TWidth);
            npc.Location.set_height_center(npc->THeight);
            npc.Location.SpeedX = 0;
            npc.Location.SpeedY = 0;
            npc.Direction = npc.DefaultDirection;
            npc.Wings = npc.DefaultWings;

            NPCQueues::update(A);

            // deferring tree update to end of the NPC physics update

            if(npc->IsACoin)
            {
                npc.Special = 1;
                npc.Location.SpeedX = dRand() - 0.5_n;
            }

            if(npc.Direction == 0)
            {
                if(iRand(2) == 0)
                    npc.Direction = 1;
                else
                    npc.Direction = -1;
            }

            npc.TurnAround = false;
            if(npc.Type == NPCID_BOMB)
                npc.Projectile = true;
        }

    }
    else if(npc.Type == NPCID_QUAD_SPITTER) // fire plant thing
    {
        if(npc.Special == 0)
        {
            npc.Special2 += 1;
            if(npc.Special2 >= 170)
            {
                npc.Special2 = 0;
                npc.Special = 1;
            }
        }
        else if(npc.Special == 1)
        {
            npc.Special2 += 1;
            if(npc.Special2 >= 70)
            {
                npc.Special2 = 0;
                npc.Special = 2;
            }
        }
        else if(npc.Special == 2)
        {
            if(npc.Special2 == 0) // spit fireballs
            {
                for(int i = 1; i <= 4; i++)
                {
                    numNPCs++;
                    NPC[numNPCs].Type = NPCID_QUAD_BALL;
                    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                    NPC[numNPCs].Section = npc.Section;
                    NPC[numNPCs].TimeLeft = npc.TimeLeft;
                    NPC[numNPCs].Location.X = npc.Location.X + (npc.Location.Width - NPC[numNPCs].Location.Width) / 2;
                    NPC[numNPCs].Location.Y = npc.Location.Y - NPC[numNPCs].Location.Height;
                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].Layer = npc.Layer;

                    if(i == 1 || i == 4)
                    {
                        NPC[numNPCs].Location.SpeedX = -4.0_n; // -2.5 * 1.6
                        NPC[numNPCs].Location.SpeedY = -2.4_n; // -1.5 * 1.6
                    }
                    else
                    {
                        NPC[numNPCs].Location.SpeedX = -1.6_n; // -1.0 * 1.6
                        NPC[numNPCs].Location.SpeedY = -3.2_n; // -2 * 1.6
                    }

                    if(i == 3 || i == 4)
                        NPC[numNPCs].Location.SpeedX = -NPC[numNPCs].Location.SpeedX;

                    // NPC[numNPCs].Location.SpeedX = NPC[numNPCs].Location.SpeedX * 1.6;
                    // NPC[numNPCs].Location.SpeedY = NPC[numNPCs].Location.SpeedY * 1.6;

                    syncLayers_NPC(numNPCs);
                }
            }

            npc.Special2 += 1;
            if(npc.Special2 >= 50)
            {
                npc.Special2 = 0;
                npc.Special = 0;
            }
        }
    }
    else if(npc.Type == NPCID_QUAD_BALL) // plant fireballs
    {
        if(npc.Special == 0)
        {
            npc.Location.SpeedY *= 0.98_r;
            npc.Location.SpeedX *= 0.98_r;
            if(npc.Location.SpeedY > -0.5_n)
            {
                npc.Location.SpeedX = 0;
                npc.Location.SpeedY = 0;
                npc.Special2 = 0;
                npc.Special = 1;
            }
        }
        else
        {
            npc.Location.SpeedY += 0.02_n;
            if(npc.Location.SpeedY > 2)
                npc.Location.SpeedY = 2;

            if(npc.Location.SpeedY > 0.25_n)
            {
                npc.Special2 += 1;
                if(npc.Special2 < 7)
                    npc.Location.SpeedX = -0.8_n;
                else if(npc.Special2 < 13)
                    npc.Location.SpeedX = 0.8_n;
                else
                {
                    npc.Special2 = 0;
                    npc.Location.SpeedX = 0;
                }
            }

        }
    }
    else if(npc.Type == NPCID_BAT) // bat thing
    {
        // Special is an activation flag
        // SpecialY (previously Special2) is the target Y coordinate
        if(npc.Special == 0)
        {
            if(!g_config.fix_bat_start_while_inactive || npc.Active)
            {
                for(int i = 1; i <= numPlayers; i++)
                {
                    auto &p = Player[i];
                    if(p.Section == npc.Section && !p.Dead && p.TimeToLive == 0)
                    {
                        Location_t tempLocation = npc.Location;
                        tempLocation.Width = 400;
                        tempLocation.Height = 800;
                        tempLocation.X -= tempLocation.Width / 2;
                        tempLocation.Y -= tempLocation.Height / 2;

                        if(CheckCollision(tempLocation, p.Location))
                        {
                            npc.Special = 1;
                            if(p.Location.X < npc.Location.X)
                                npc.Direction = -1;
                            else
                                npc.Direction = 1;
                            npc.Location.SpeedX = 0.01_n * npc.Direction;

                            if(p.Location.Y > npc.Location.Y)
                            {
                                npc.Location.SpeedY = 2.5_n;
                                npc.SpecialY = p.Location.Y - 130;
                            }
                            else
                            {
                                npc.Location.SpeedY = -2.5_n;
                                npc.SpecialY = p.Location.Y + 130;
                            }

                            if(npc.Active)
                                PlaySoundSpatial(SFX_BatFlap, npc.Location);
                        }
                    }
                }
            }
        }
        else
        {
            npc.Location.SpeedX = (3 - num_t::abs(npc.Location.SpeedY)) * npc.Direction;
            if((npc.Location.SpeedY > 0 && npc.Location.Y > npc.SpecialY) || (npc.Location.SpeedY < 0 && npc.Location.Y < npc.SpecialY))
            {
                npc.Location.SpeedY = npc.Location.SpeedY * 0.98_r;
                if(npc.Location.SpeedY > -0.1_n && npc.Location.SpeedY < 0.1_n)
                    npc.Location.SpeedY = 0;
            }
        }
    }
    else if(npc.Type == NPCID_MAGIC_BOSS_BALL) // larry magic
    {
        if(npc.Special < 2)
        {
            npc.Special2 += 1;
            if(npc.Special2 >= 30 && npc.Special != 2)
            {
                npc.Location.X += npc.Location.Width;
                npc.Location.Width = 16;
                npc.Location.set_height_floor(32);
                npc.Special = 2;
                npc.Location.X += -npc.Location.Width;
                npc.Special2 = 21;

                NPCQueues::Unchecked.push_back(A);
                // deferring tree update to end of the NPC physics update
            }
            else if(npc.Special2 >= 15 && npc.Special != 1)
            {
                npc.Location.X += npc.Location.Width;
                npc.Location.Width = 10;
                npc.Location.set_height_floor(20);
                npc.Special = 1;
                npc.Location.X += -npc.Location.Width;

                NPCQueues::Unchecked.push_back(A);
                // deferring tree update to end of the NPC physics update
            }
        }
    }
    else if(npc.Type == NPCID_MAGIC_BOSS_SHELL || npc.Type == NPCID_FIRE_BOSS_SHELL) // larry/ludwig shell
    {
        // temporarily remove any wings if present
        npc.Wings = WING_NONE;

        if(npc.Special5 == 0) // Target a Random Player
        {
            int C = 0;
            do
            {
                // COMPAT BUGFIX. Should be iRand(numPlayers) + 1
                int i = (g_config.fix_multiplayer_targeting) ? (iRand(numPlayers) + 1) : (iRand(1) * numPlayers + 1); // always 1
                if(!Player[i].Dead && Player[i].Section == npc.Section && Player[i].TimeToLive == 0)
                    npc.Special5 = i;
                C += 1;
                if(C >= 20)
                    npc.Special5 = 1;
            }
            while(npc.Special5 <= 0);
        }

        if(npc.Location.to_right_of(Player[npc.Special5].Location))
            npc.Direction = -1;
        else
            npc.Direction = 1;
        if(npc.Special == 0)
        {
            npc.Special2 += 1;
            if(npc.Special2 >= 60)
            {
                npc.Special = 1;
                npc.Special2 = 0;
            }
        }
        else if(npc.Special == 1)
        {
            if(npc.Type == NPCID_FIRE_BOSS_SHELL && num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
                npc.Location.SpeedX += 0.1_n * npc.Direction;
            else
                npc.Location.SpeedX += 0.2_n * npc.Direction;
            if(npc.Type == NPCID_FIRE_BOSS_SHELL && npc.Damage >= 5)
            {
                if(npc.Location.SpeedX > 5.5_n)
                    npc.Location.SpeedX = 5.5_n;
                else if(npc.Location.SpeedX < -5.5_n)
                    npc.Location.SpeedX = -5.5_n;
            }
            else if(npc.Type == NPCID_FIRE_BOSS_SHELL && npc.Damage >= 10)
            {
                if(npc.Location.SpeedX > 6)
                    npc.Location.SpeedX = 6;
                else if(npc.Location.SpeedX < -6)
                    npc.Location.SpeedX = -6;
            }
            else
            {
                if(npc.Location.SpeedX > 5)
                    npc.Location.SpeedX = 5;
                else if(npc.Location.SpeedX < -5)
                    npc.Location.SpeedX = -5;
            }

            if(npc.Type == NPCID_FIRE_BOSS_SHELL && num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
            {
                npc.Special3 += 1;
                if((npc.Location.SpeedX < -2 && npc.Direction < 0) || (npc.Location.SpeedX > 2 && npc.Direction > 0))
                {
                    if(npc.Special3 >= 20 - npc.Damage * 2)
                    {
                        npc.Special3 = 0;
                        npc.Location.SpeedY = -3 - dRand() * 2;
                    }
                }
            }

            npc.Special2 += 1;

            if(npc.Special2 >= 300 && num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
            {
                npc.Special = 2;
                npc.Special2 = 0;
            }
        }
        else if(npc.Special == 2)
        {
            npc.Location.SpeedY = -5 - dRand() * 3;
            if(npc.Type == NPCID_FIRE_BOSS_SHELL)
                npc.Location.SpeedY -= 2;
            npc.Special = 3;
        }
        else if(npc.Special == 3)
        {
            if(npc.Location.SpeedX > 2.5_n)
                npc.Location.SpeedX -= 0.2_n;
            else if(npc.Location.SpeedX < -2.5_n)
                npc.Location.SpeedX += 0.2_n;
            npc.Special2 += 1;

            if(npc.Type == NPCID_FIRE_BOSS_SHELL)
            {
                npc.Special2 = 20;
                PlaySoundSpatial(SFX_Spring, npc.Location);
            }

            if(npc.Special2 == 20)
            {
                npc.Special = 0;
                npc.Special2 = npc.Direction;
                npc.Special3 = 0;
                npc.Special4 = 0;
                npc.Special5 = 0;
                // npc.Special6 = 0;
                npc.Type = NPCID(npc.Type - 1);
                npc.Location.set_width_center(npc->TWidth);
                npc.Location.set_height_floor(npc->THeight);

                // restore wings if lost
                npc.Wings = npc.DefaultWings;

                NPCQueues::Unchecked.push_back(A);
                // deferring tree update to end of the NPC physics update
            }
        }
        else
            npc.Special = 0;

    }
    else if(npc.Type == NPCID_MAGIC_BOSS) // larry koopa
    {
        // special is phase
        // special5 is targetted player
        // special3 is jump counter
        // special2 is direction

        // special4 is attack timer
        // special3 is attack count
        if(npc.Inert)
        {
            npc.Special4 = 0;
            npc.Special3 = 0;
        }

        if(npc.Special5 == 0) // Target a Random Player
        {
            int C = 0;
            do
            {
                // COMPAT BUGFIX. Should be iRand(numPlayers) + 1
                int i = (g_config.fix_multiplayer_targeting) ? (iRand(numPlayers) + 1) : (iRand(1) * numPlayers + 1); // always 1
                // should be int i = iRand(numPlayers) + 1;
                if(!Player[i].Dead && Player[i].Section == npc.Section && Player[i].TimeToLive == 0)
                    npc.Special5 = i;
                C += 1;
                if(C >= 20)
                    npc.Special5 = 1;
            }
            while(npc.Special5 <= 0);
        }

        if(npc.Location.to_right_of(Player[npc.Special5].Location))
            npc.Direction = -1;
        else
            npc.Direction = 1;

        if(npc.Special2 == 0)
            npc.Special2 = npc.Direction;

        if(npc.Special == 0)
        {
            if(npc.Special2 == -1)
                npc.Location.SpeedX = -2.5_n;
            else
                npc.Location.SpeedX = 2.5_n;

            // movement
            if(npc.Location.X < Player[npc.Special5].Location.X - 400)
                npc.Special2 = 1;
            else if(npc.Location.X > Player[npc.Special5].Location.X + 400)
                npc.Special2 = -1;

            // jumping
            if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
            {
                npc.Special3 += 1;
                if(npc.Special3 > 30 + iRand(100))
                {
                    npc.Special3 = 0;
                    npc.Location.SpeedY = -5 - dRand() * 4;
                }
            }
            else
                npc.Special3 = 0;

            // attack timer
            npc.Special4 += 1;
            if(npc.Special4 > 100 + iRand(100) && (num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity) || npc.Wings))
            {
                npc.Special = 1;
                npc.Special5 = 0;
                npc.Special3 = 0;
                npc.Special4 = 0;
            }
        }
        else if(npc.Special == 1)
        {
            if(npc.Location.to_right_of(Player[npc.Special5].Location))
                npc.Direction = -1;
            else
                npc.Direction = 1;

            npc.Special2 = npc.Direction;
            npc.Location.SpeedX = 0;
            npc.Special3 += 1;

            if(npc.Special3 >= 10)
            {
                npc.Special3 = 0;
                npc.Special = 2;
            }
        }
        else if(npc.Special == 2)
        {
            npc.Location.SpeedX = 0;
            if(npc.Special3 == 0 || npc.Special3 == 6 || npc.Special3 == 12) // shoot
            {

                if(npc.Special3 == 0)
                {
                    npc.SpecialX = Player[npc.Special5].Location.X + Player[npc.Special5].Location.Width / 2;
                    npc.SpecialY = Player[npc.Special5].Location.Y + Player[npc.Special5].Location.Height / 2 + 16;
                }

                if(npc.Special3 == 0)
                    PlaySoundSpatial(SFX_Transform, npc.Location);

                numNPCs++;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].TimeLeft = 100;
                NPC[numNPCs].Direction = npc.Direction;
                NPC[numNPCs].Section = npc.Section;
                NPC[numNPCs].Type = NPCID_MAGIC_BOSS_BALL;
                NPC[numNPCs].Location.Width = 10;
                NPC[numNPCs].Location.Height = 8;
                NPC[numNPCs].Frame = 3;
                NPC[numNPCs].Special2 = npc.Special3;

                if(NPC[numNPCs].Direction == -1)
                    NPC[numNPCs].Location.X = npc.Location.X - 20;
                else
                    NPC[numNPCs].Location.X = npc.Location.X + npc.Location.Width - NPC[numNPCs].Location.Width + 20;

                NPC[numNPCs].Location.Y = npc.Location.Y + 47;

                NPCSetSpeedTarget_FixedX(NPC[numNPCs], npc.SpecialX, npc.SpecialY, 3, 3);

                syncLayers_NPC(numNPCs);
            }

            npc.Special3 += 1;
            if(npc.Special3 >= 30)
            {
                npc.Special = 0;
                npc.Special4 = 0;
                npc.Special5 = 0;
                // npc.Special6 = 0;
                npc.SpecialX = 0;
                npc.SpecialY = 0;
            }
        }

        // ludwig koopa
    }
    else if(npc.Type == NPCID_FIRE_BOSS)
    {
        // special is phase
        // special5 is targetted player
        // special3 is jump counter
        // special2 is direction

        // special4 is attack timer
        // special3 is attack count

        // SpecialX (Special6 in SMBX 1.3) appears to be an additional attack timer

        if(npc.Inert)
        {
            npc.Special4 = 0;
            npc.Special3 = 0;
            npc.SpecialX = 0;
        }

        if(npc.Special5 == 0) // Target a Random Player
        {
            int C = 0;
            do
            {
                // COMPAT BUGFIX. Should be iRand(numPlayers) + 1
                int i = (g_config.fix_multiplayer_targeting) ? (iRand(numPlayers) + 1) : (iRand(1) * numPlayers + 1); // always 1
                if(!Player[i].Dead && Player[i].Section == npc.Section && Player[i].TimeToLive == 0)
                    npc.Special5 = i;
                C += 1;
                if(C >= 20)
                    npc.Special5 = 1;
            }
            while(npc.Special5 <= 0); // TESTME: !(npc.Special5 > 0)
        }

        if(npc.Location.to_right_of(Player[npc.Special5].Location))
            npc.Direction = -1;
        else
            npc.Direction = 1;

        if(npc.Special2 == 0)
            npc.Special2 = npc.Direction;

        if(npc.Special == 0)
        {
            if((npc.Damage < 5 && npc.SpecialX > 60) || (npc.Damage < 10 && npc.SpecialX > 80) || npc.Inert)
            {
                if(npc.Special2 == -1)
                    npc.Location.SpeedX = -1.5_n;
                else
                    npc.Location.SpeedX = 1.5_n;

                // movement
                if(npc.Location.X < Player[npc.Special5].Location.X - 400)
                    npc.Special2 = 1;
                else if(npc.Location.X > Player[npc.Special5].Location.X + 400)
                    npc.Special2 = -1;
            }
            else
            {
                npc.Location.SpeedX = npc.Location.SpeedX * 0.98_r;
                if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
                    npc.Location.SpeedX = 0;

            }

            // attack timer
            bool can_advance = (num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity) || npc.Wings);
            if(can_advance)
                npc.SpecialX += 1;

            if(npc.SpecialX == 20 || npc.SpecialX == 40 || npc.SpecialX == 60 || (npc.Damage >= 5 && npc.SpecialX == 80) || (npc.Damage >= 10 && npc.SpecialX == 100))
            {
                npc.Special = 1;
                npc.Special5 = 0;
                npc.Special3 = 0;
                npc.Special4 = 0;
            }

            if(npc.Damage >= 10 && npc.Special == 0 && npc.SpecialX >= 100)
                npc.SpecialX = 200;

            if(npc.SpecialX >= 160 && can_advance)
            {
                npc.SpecialX = 0;
                npc.Special = 3;
                PlaySoundSpatial(SFX_Spring, npc.Location);
                npc.Location.SpeedY = -7 - dRand() * 2;
                // clip wings if present
                npc.Wings = WING_NONE;
            }
        }
        else if(npc.Special == 3)
        {
            if(npc.Location.SpeedY > 0) // turn into shell
            {
                npc.Special = 1;
                npc.Special2 = 0;
                npc.Special3 = 0;
                npc.Special4 = 0;
                npc.Special5 = 0;
                // npc.Special6 = 0;
                npc.SpecialX = 0;
                npc.Type = NPCID_FIRE_BOSS_SHELL;
                npc.Location.set_width_center(npc->TWidth);
                npc.Location.set_height_floor(npc->THeight);

                NPCQueues::Unchecked.push_back(A);
                // deferring tree update to end of the NPC physics update
            }
            else
            {
                npc.Location.SpeedX += 0.2_n * npc.Special2;
                if(npc.Location.SpeedX > 5)
                    npc.Location.SpeedX = 5;
                else if(npc.Location.SpeedX < -5)
                    npc.Location.SpeedX = -5;
            }
        }
        else if(npc.Special == 1 || npc.Special == 2)
        {
            if(npc.Location.to_right_of(Player[npc.Special5].Location))
                npc.Direction = -1;
            else
                npc.Direction = 1;

            npc.Special2 = npc.Direction;
            npc.Location.SpeedX = 0;

            if(npc.Special3 == 20) // shoot
            {
                PlaySoundSpatial(SFX_BigFireball, npc.Location);
                numNPCs++;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].TimeLeft = 100;
                NPC[numNPCs].Direction = npc.Direction;
                NPC[numNPCs].Section = npc.Section;
                NPC[numNPCs].Type = NPCID_FIRE_BOSS_FIRE;
                NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                NPC[numNPCs].Frame = 0;

                if(NPC[numNPCs].Direction == -1)
                    NPC[numNPCs].Location.X = npc.Location.X - 24;
                else
                    NPC[numNPCs].Location.X = npc.Location.X + npc.Location.Width - NPC[numNPCs].Location.Width + 24;
                NPC[numNPCs].Location.Y = npc.Location.Y + 4;

                NPCSetSpeedTarget_FixedX(NPC[numNPCs], Player[npc.Special5].Location, 4, 2);

                syncLayers_NPC(numNPCs);
            }

            npc.Special3 += 1;
            if(npc.Special3 < 20)
                npc.Special = 1;
            else
                npc.Special = 2;

            if(npc.Special3 >= 40)
            {
                npc.Special = 0;
                npc.Special5 = 0;
                npc.Special3 = 0;
                npc.Special4 = 0;
            }
        }
    }
    else if(npc.Type == NPCID_SWORDBEAM) // link sword beam
    {
        npc.Special += 1;
        if(npc.Special == 40)
        {
            npc.Killed = 9;
            NPCQueues::Killed.push_back(A);
        }

        // unified sparkle code (previously there was a 1-4 loop above, and the iRand(2) code was below)
        for(int i = 1; i <= 5; i++)
        {
            if((i < 5 && npc.Special == 40)
                || (i == 5 && iRand(2) == 0))
            {
                Location_t tempLocation;
                tempLocation.Height = EffectHeight[EFFID_SPARKLE];
                tempLocation.Width = EffectWidth[EFFID_SPARKLE];
                tempLocation.SpeedX = 0;
                tempLocation.SpeedY = 0;
                tempLocation.X = npc.Location.X + dRand() * 16 - (num_t)EffectWidth[EFFID_SPARKLE] / 2 - 4; // + .Location.SpeedX
                tempLocation.Y = npc.Location.Y + dRand() * 4 - (num_t)EffectHeight[EFFID_SPARKLE] / 2 - 2;
                NewEffect(EFFID_SPARKLE, tempLocation);

                if(i < 5)
                {
                    Effect[numEffects].Location.SpeedX = npc.Location.SpeedX * 0.3_r + dRand() * 2 - 1;
                    Effect[numEffects].Location.SpeedY = dRand() * 1 - 0.5_n;
                    Effect[numEffects].Frame = iRand(3);
                }
                else
                {
                    Effect[numEffects].Location.SpeedX = npc.Location.SpeedX * 0.15_r;
                    Effect[numEffects].Location.SpeedY = npc.Location.SpeedY; // + Rnd * 2 - 1
                    Effect[numEffects].Frame = iRand(2) + 1;
                }
            }
        }
    }
    else if(npc.Type == NPCID_BOMBER_BOSS) // mouser
    {
        // don't despawn -- moved here from the top of the routine
        if(npc.TimeLeft > 1)
            npc.TimeLeft = 100;

        if(npc.Immune == 0)
            NPCFaceNearestPlayer(npc);
        else
        {
            if(iRand(10) == 0)
                npc.Direction = -npc.Direction;
            npc.Special3 = 0;
            npc.Special4 = 0;
        }

        if(npc.Immune != 0)
            npc.Location.SpeedX = 0;
        else if(npc.Special == 0)
        {
            if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity) || npc.Wings)
            {
                if(npc.Special2 == 0)
                    npc.Special2 = npc.Direction;

                npc.Location.SpeedX = 2 * npc.Special2;

                if(npc.Location.X < npc.DefaultLocationX - 64)
                    npc.Special2 = 1;
                else if(npc.Location.X > npc.DefaultLocationX + 64)
                    npc.Special2 = -1;

                npc.Special3 += 1;
                npc.Special4 += 1;

                if(npc.Special3 > 100 + iRand(200))
                {
                    npc.Special3 = 0;
                    npc.Location.SpeedX = 0;
                    npc.Location.SpeedY = -5;
                }
                else if(npc.Special4 > 20 + iRand(200))
                {
                    npc.Special4 = 0;
                    npc.Special = -10;
                }
            }
            else
                npc.Location.SpeedX = 0;
        }
        else
        {
            if(npc.Special == -1)
            {
                npc.Special = 20;
                numNPCs++;
                NPC[numNPCs].Layer = LAYER_SPAWNED_NPCS;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].Direction = npc.Direction;
                NPC[numNPCs].Type = NPCID_BOMB;
                NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                NPC[numNPCs].Location.Y = npc.Location.Y + npc.Location.Height - 48;
                NPC[numNPCs].Location.X = npc.Location.X + (npc.Location.Width - NPC[numNPCs].Location.Width) / 2 - 12 * NPC[numNPCs].Direction;
                NPC[numNPCs].TimeLeft = 100;
                NPC[numNPCs].Section = npc.Section;
                NPC[numNPCs].Location.SpeedX = (5 + dRand() * 3) * NPC[numNPCs].Direction;
                NPC[numNPCs].Location.SpeedY = -5 - (dRand() * 3);

                syncLayers_NPC(numNPCs);
            }

            npc.Location.SpeedX = 0;

            if(npc.Special < 0)
                npc.Special += 1;
            else
                npc.Special -= 1;
        }
    }
    else if(npc.Type == NPCID_WALK_PLANT) // muncher thing
    {
        if(npc.Special == 0)
        {
            for(int i = 1; i <= numPlayers; i++)
            {
                auto &p = Player[i];
                if(!p.Dead && p.TimeToLive == 0 && p.Section == npc.Section)
                {
                    Location_t tempLocation = npc.Location;
                    tempLocation.Height = 256;
                    tempLocation.Y -= tempLocation.Height;

                    if(CheckCollision(tempLocation, p.Location))
                    {
                        npc.Special = 1;
                        npc.Location.SpeedY = -7;
                        npc.Location.SpeedX = 0;
                    }
                }
            }
        }
        else if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
            npc.Special = 0;

        if(!npc.Stuck && npc.Special == 0)
        {
            if(npc.Special2 == 0)
            {
                if(npc.Location.X < npc.DefaultLocationX - 128 && npc.Direction == -1)
                    npc.Special2 = 60;
                else if(npc.Location.X > npc.DefaultLocationX + 128 && npc.Direction == 1)
                    npc.Special2 = 60;

                npc.Location.SpeedX = 1.4_n * npc.Direction;

                if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
                    npc.Location.SpeedY = -1.5_n;
            }
            else
            {
                npc.Special2 -= 1;

                if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
                    npc.Location.SpeedX = 0;

                if(npc.Special2 == 0)
                {
                    if(npc.Location.X < npc.DefaultLocationX)
                        npc.Direction = 1;
                    else
                        npc.Direction = -1;
                }
            }
        }
    }
    // newly combined (note that Special was previously the stage counter for FIRE_DISK; now Special2 is the counter for both)
    else if(npc.Type == NPCID_FIRE_CHAIN || npc.Type == NPCID_FIRE_DISK)
    {
        num_t C;
        num_t B;
        num_t thresh;

        if(npc.Type == NPCID_FIRE_DISK)
        {
            npc.Special4 += 1;

            if(npc.Special4 == 4)
            {
                NewEffect(EFFID_FIRE_DISK_DIE, npc.Location);
                Effect[numEffects].Frame = npc.Frame;
                Effect[numEffects].Location.SpeedX = 0;
                Effect[numEffects].Location.SpeedY = 0;
                npc.Special4 = 0;
            }

            C = 0.2_n;
            B = 6.05_n;
            thresh = 0_n;
        }
        else
        {
            C = 0.03_n * npc.DefaultSpecial;
            B = 0.98_n * npc.DefaultSpecial;
            thresh = 0.001_n;
        }

        if(npc.Special2 == 0)
        {
            npc.Location.SpeedX += C;
            npc.Location.SpeedY += C * npc.DefaultDirection;

            if(npc.Special5 == 0)
            {
                npc.Special5 = 1;
                npc.Location.SpeedX = -B;
                npc.Location.SpeedY = 0;
            }

            if(npc.Location.SpeedX >= -thresh)
            {
                if(npc.DefaultDirection > 0)
                    npc.Special2 = 1;
                else if(npc.DefaultDirection < 0 || npc.Type == NPCID_FIRE_CHAIN)
                    npc.Special2 = 3;

                npc.Special5 = 0;
            }
        }
        else if(npc.Special2 == 1)
        {
            npc.Location.SpeedX += C * npc.DefaultDirection;
            npc.Location.SpeedY -= C;

            if(npc.Special5 == 0)
            {
                npc.Special5 = 1;
                npc.Location.SpeedY = B;
                npc.Location.SpeedX = 0;
            }

            if(npc.Location.SpeedY <= thresh)
            {
                npc.Special2 += npc.DefaultDirection;
                npc.Special5 = 0;
            }
        }
        else if(npc.Special2 == 2)
        {
            npc.Location.SpeedX -= C;
            npc.Location.SpeedY -= C * npc.DefaultDirection;

            if(npc.Special5 == 0)
            {
                npc.Special5 = 1;
                npc.Location.SpeedX = B;
                npc.Location.SpeedY = 0;
            }

            if(npc.Location.SpeedX <= thresh)
            {
                npc.Special2 += npc.DefaultDirection;
                npc.Special5 = 0;
            }
        }
        else if(npc.Special2 == 3)
        {
            npc.Location.SpeedX -= C * npc.DefaultDirection;
            npc.Location.SpeedY += C;

            if(npc.Special5 == 0)
            {
                npc.Special5 = 1;
                npc.Location.SpeedY = -B;
                npc.Location.SpeedX = 0;
            }

            if(npc.Location.SpeedY >= -thresh)
            {
                if(npc.DefaultDirection > 0)
                    npc.Special2 = 0;
                else
                    npc.Special2 += npc.DefaultDirection;

                npc.Special5 = 0;
            }
        }
    }
    else if(npc.Type == NPCID_LOCK_DOOR)
    {
        for(int i : treeNPCQuery(npc.Location, SORTMODE_NONE))
        {
            auto &n = NPC[i];
            if(n.Type == NPCID_KEY && n.Active && n.HoldingPlayer != 0 && CheckCollision(npc.Location, n.Location))
            {
                n.Killed = 9;
                NewEffect(EFFID_SMOKE_S3, n.Location);
                npc.Killed = 3;
                NPCQueues::Killed.push_back(A);
                NPCQueues::Killed.push_back(i);
            }
        }
    }
    else if(npc.Type == NPCID_BOSS_FRAGILE) // Mother Brain
    {
        // don't despawn -- moved here from the top of the routine
        if(npc.TimeLeft > 1)
            npc.TimeLeft = 100;

        if(npc.Special >= 1)
        {
            // double B = 1 - (npc.Special / 45.0);
            // double C = B * 0.5;
            // B *= 15;
            // C *= 15;
            // npc.Location.X = npc.DefaultLocationX + dRand() * B - dRand() * C;
            // npc.Location.Y = npc.DefaultLocationY + dRand() * B - dRand() * C;

            int time_left = 45 - npc.Special;

            num_t dx1 = dRand();
            num_t dx2 = dRand();
            num_t dy1 = dRand();
            num_t dy2 = dRand();
            npc.Location.X = npc.DefaultLocationX + (dx1 * 2 - dx2) * time_left / 6;
            npc.Location.Y = npc.DefaultLocationY + (dy1 * 2 - dy2) * time_left / 6;

            npc.Special += 1;
            if(npc.Special >= 45)
                npc.Special = 0;

            // deferring tree update to end of the NPC physics update
        }
        else
        {
            npc.ResetLocation();
            NPCQueues::Unchecked.push_back(A);
            // deferring tree update to end of the NPC physics update
        }
    }
    else if(npc.Type == NPCID_HOMING_BALL) // O thing
    {
        if(npc.Special == 0)
        {
            npc.Special2 += 1;

            if(npc.Special2 > 80 + iRand(20))
            {
                npc.Special = 1;

                int ip = NPCTargetPlayer(npc);
                NPCSetSpeedTarget_FixedSpeed(npc, Player[ip].Location, 3);
            }
        }
    }
    else if(npc.Type == NPCID_HOMING_BALL_GEN) // Metroid O shooter thing
    {
        // moved from pre-NPCSpecial code
        npc.Location.SpeedX = 0;
        npc.Location.SpeedY = 0;

        // was Special in SMBX 1.3
        npc.SpecialY += 1 + dRand();
        if(npc.SpecialY >= 200 + dRand() * 200)
        {
            npc.SpecialY = 0;
            numNPCs++;
            NPC[numNPCs].Inert = npc.Inert;
            NPC[numNPCs].Location.Height = 32;
            NPC[numNPCs].Location.Width = 28;
            NPC[numNPCs].Location.X = npc.Location.X + 2;
            NPC[numNPCs].Location.Y = npc.Location.Y;
            NPC[numNPCs].Section = npc.Section;
            NPC[numNPCs].Layer = LAYER_SPAWNED_NPCS;
            NPC[numNPCs].Type = NPCID_HOMING_BALL;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].TimeLeft = 50;

            syncLayers_NPC(numNPCs);
        }
    }
    else if(npc.Type == NPCID_WALL_SPARK || npc.Type == NPCID_WALL_BUG || npc.Type == NPCID_WALL_TURTLE) // sparky
    {
        // was F
        int speed_mult = (npc.Type == NPCID_WALL_SPARK) ? 2 : 1;

        // special stores wall attachment side, special2 stores current direction (1 is right, -1 is left)

        if(npc.Special == 0)
        {
            if(npc.Direction == 0)
            {
                if(iRand(2) == 1)
                    npc.Direction = 1;
                else
                    npc.Direction = -1;
            }

            npc.Special = 1;
            npc.Special2 = npc.Direction;
        }

        // handle floor slopes
        if(npc.Slope > 0 && (npc.Special == 2 || npc.Special == 4))
        {
            // "right side of a wall" -> moving left
            if(npc.Special == 2)
                npc.Special2 = 1;
            // "left side of a wall" -> moving left
            else if(npc.Special == 4)
                npc.Special2 = -1;

            // you're on a floor!
            npc.Special = 1;
        }

        // timer for being unsupported while on floor
        npc.Special5 += 1;
        if(npc.Special5 >= 8 && npc.Special == 1)
        {
            npc.Special5 = 8;
            npc.Special = 0;
            npc.Location.SpeedY += Physics.NPCGravity;
            if(npc.Location.SpeedY > 8)
                npc.Location.SpeedY = 8;
        }

        // the following code was previously separated into conditions 1/2/3/4
        if(npc.Special < 1 || npc.Special > 4)
            return;

        // set speed: push NPC into wall it is currently climbing
        // FIXME: is Special2 ever anything other than -1 or 1 at this point? Would be nice to remove the abs calls.
        if(npc.Special == 1)
        {
            npc.Location.SpeedY = speed_mult * std::abs(npc.Special2);
            npc.Location.SpeedX = speed_mult * npc.Special2;
        }
        else if(npc.Special == 2)
        {
            npc.Location.SpeedY = speed_mult * npc.Special2;
            npc.Location.SpeedX = std::abs(npc.Special2);
        }
        else if(npc.Special == 3)
        {
            npc.Location.SpeedY = -std::abs(npc.Special2);
            npc.Location.SpeedX = speed_mult * npc.Special2;
        }
        else if(npc.Special == 4)
        {
            npc.Location.SpeedY = speed_mult * npc.Special2;
            npc.Location.SpeedX = -std::abs(npc.Special2);
        }

        // check whether the NPC is about to turn an inner corner (eg, hit a wall when on ground)
        bool inner_corner = false;
        Location_t tempLocation;
        tempLocation.Width = 2;
        tempLocation.Height = 2;
        tempLocation.X = npc.Location.X + npc.Location.Width / 2 - 1;
        tempLocation.Y = npc.Location.Y + npc.Location.Height / 2 - 1;

        // check the point 18px to the left/right of the NPC's center (horizontal climbing)
        if(npc.Special == 1 || npc.Special == 3)
            tempLocation.X += 18 * npc.Special2;
        // check the point 18px to the top/bottom of the NPC's center (vertical climbing)
        else if(npc.Special == 2 || npc.Special == 4)
            tempLocation.Y += 18 * npc.Special2;

        for(Block_t& block : treeFLBlockQuery(tempLocation, SORTMODE_NONE))
        {
            if(!block.Hidden && !BlockNoClipping[block.Type] && !BlockIsSizable[block.Type] && !BlockOnlyHitspot1[block.Type])
            {
                if(npc.Special == 1 && BlockSlope[block.Type])
                    continue;

                if((npc.Special == 3 || npc.Special == 4) && BlockSlope2[block.Type])
                    continue;

                if(CheckCollision(tempLocation, block.Location))
                {
                    inner_corner = true;
                    break;
                }
            }
        }

        // routine for turning an inner corner
        if(inner_corner)
        {
            int old_side = npc.Special;

            // on a ceiling / floor?
            if(npc.Special == 1 || npc.Special == 3)
            {
                // going right -> hit left side of wall
                if(npc.Special2 == 1)
                    npc.Special = 2;
                // hit right side of wall
                else
                    npc.Special = 4;

                // was on floor -> now you're going up
                if(old_side == 1)
                {
                    npc.Location.SpeedY = 0;
                    npc.Special2 = -1;
                }
                // now you're going down
                else
                    npc.Special2 = 1;
            }
            // on a wall?
            else if(npc.Special == 2 || npc.Special == 4)
            {
                // going down -> hit a floor
                if(npc.Special2 == 1)
                    npc.Special = 1;
                // hit a ceiling
                else
                    npc.Special = 3;

                // was on left side of wall -> now you're going left
                if(old_side == 2)
                    npc.Special2 = -1;
                // now you're going right
                else
                    npc.Special2 = 1;
            }

            return;
        }

        // check whether the wall the NPC is pressing into is gone -> it's on an outer corner
        bool outer_corner = true;

        // check the 8px below (case 1) / above (case 3) the NPC
        if(npc.Special == 1 || npc.Special == 3)
        {
            tempLocation.Width = npc.Location.Width + ((npc.Special == 1) ? 2 : 0);
            tempLocation.Height = 8;
            tempLocation.X = npc.Location.X;
            tempLocation.Y = npc.Location.Y + ((npc.Special == 1) ? npc.Location.Height : -8);
        }
        // check the 8px to the right (case 2) / left (case 4) of the NPC
        else if(npc.Special == 2 || npc.Special == 4)
        {
            tempLocation.Width = 8;
            tempLocation.Height = npc.Location.Height;
            tempLocation.Y = npc.Location.Y;
            tempLocation.X = npc.Location.X + ((npc.Special == 2) ? npc.Location.Width : -8);
        }

        for(BlockRef_t block_p : treeFLBlockQuery(tempLocation, SORTMODE_COMPAT))
        {
            Block_t& block = *block_p;

            if(!block.Hidden && !BlockNoClipping[block.Type] && !BlockIsSizable[block.Type] && !BlockOnlyHitspot1[block.Type])
            {
                if(CheckCollision(tempLocation, block.Location))
                {
                    // this saves the last Block that the NPC was on top of
                    if(npc.Special == 1)
                        npc.Special3 = (vbint_t)block_p;
                    // this makes the climbing work when on a ceiling slope, without slamming into ceilings otherwise
                    else if(npc.Special == 3)
                    {
                        if(BlockSlope2[block.Type] != 0)
                            npc.Location.SpeedY *= speed_mult;
                    }

                    outer_corner = false;
                    break;
                }
            }
        }

        // outer corner turning logic
        if(outer_corner)
        {
            int old_side = npc.Special;

            // moving on floor / ceiling
            if(npc.Special == 1 || npc.Special == 3)
            {
                // was moving right -> now you're on right side of floor/ceiling block
                if(npc.Special2 == 1)
                {
                    // VB6 logic: turn right off of floor extra beautifully (but note that this could potentially cause the NPC to return to a location from long ago)
                    if(npc.Special == 1 && npc.Special3 > 0)
                    {
                        npc.Location.X = Block[npc.Special3].Location.X + Block[npc.Special3].Location.Width + 2;
                        npc.Location.Y += 2;
                    }

                    npc.Special = 4;
                }
                // now you're on left side of floor/ceiling block
                else
                    npc.Special = 2;

                // on floor -> moving down
                if(old_side == 1)
                    npc.Special2 = 1;
                // on ceiling -> moving up
                else
                    npc.Special2 = -1;
            }
            // moving on wall
            else if(npc.Special == 2 || npc.Special == 4)
            {
                // was moving down -> now you're on bottom of wall block
                if(npc.Special2 == 1)
                    npc.Special = 3;
                // now you're on top of wall block
                else
                    npc.Special = 1;

                // on left side of wall -> moving right
                if(old_side == 2)
                    npc.Special2 = 1;
                // on right side of wall -> moving left
                else
                    npc.Special2 = -1;
            }
        }
    }
    else if(npc.Type == NPCID_SICK_BOSS) // Wart
    {
        // don't despawn -- moved from top of this routine
        if(npc.TimeLeft > 1)
            npc.TimeLeft = 100;

        if(!npc.Wings)
            npc.Direction = npc.DefaultDirection;

        if(npc.Immune > 0 && npc.Special != 3)
            npc.Special = 2;

        if(npc.Damage >= 30)
        {
            if(npc.Special != 3)
                PlaySoundSpatial(SFX_SickBossKilled, npc.Location);
            npc.Special = 3;
        }

        if(npc.Special == 0)
        {
            npc.Special3 += 1;

            if(npc.Special3 > 160 + iRand(140))
            {
                npc.Special = 1;
                npc.Special3 = 0;
            }

            if(npc.Special2 == 1)
            {
                npc.Location.SpeedX = 1;
                if(npc.Location.X > npc.DefaultLocationX + npc.Location.Width * 1)
                    npc.Special2 = -1;
            }
            else if(npc.Special2 == -1)
            {
                npc.Location.SpeedX = -1;
                if(npc.Location.X < npc.DefaultLocationX - npc.Location.Width * 1)
                    npc.Special2 = 1;
            }
            else
                npc.Special2 = npc.Direction;
        }
        else if(npc.Special == 1)
        {
            npc.Location.SpeedX = 0;
            if(npc.Special3 == 0)
                PlaySoundSpatial(SFX_SickBossSpit, npc.Location);

            npc.Special3 += 1;
            if((npc.Special3 % 10) == 0)
            {
                numNPCs++;
                NPC[numNPCs].Inert = npc.Inert;
                NPC[numNPCs].Location.Height = 32;
                NPC[numNPCs].Location.Width = 32;
                NPC[numNPCs].Location.X = npc.Location.X + npc.Location.Width / 2 - 16 + (32 * npc.Direction);
                NPC[numNPCs].Location.Y = npc.Location.Y + 18;
                NPC[numNPCs].Direction = npc.Direction;
                NPC[numNPCs].Type = NPCID_SICK_BOSS_BALL;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].TimeLeft = 50;
                NPC[numNPCs].Location.SpeedY = -7;
                NPC[numNPCs].Location.SpeedY += dRand() * 6 - 3;
                NPC[numNPCs].Location.SpeedX = 7 * NPC[numNPCs].Direction;
                NPC[numNPCs].Location.SpeedX *= (140 - npc.Special3);
                NPC[numNPCs].Location.SpeedX /= 140;

                syncLayers_NPC(numNPCs);
            }

            if(npc.Special3 > 120 + iRand(40))
            {
                npc.Special = 0;
                npc.Special3 = 0;
            }
        }
        else if(npc.Special == 2)
        {
            npc.Location.SpeedX = 0;
            npc.Special4 += 1;
            if(npc.Special4 >= 120)
            {
                npc.Special4 = 0;
                npc.Special = 0;
            }
        }
        else if(npc.Special == 3)
        {
            npc.Location.SpeedX = 0;
            npc.Special4 += 1;
            if(npc.Special4 >= 120)
            {
                npc.Killed = 3;
                NPCQueues::Killed.push_back(A);
            }
        }

    }
    // Platform movement
    else if(npc.Type == NPCID_YEL_PLATFORM || npc.Type == NPCID_BLU_PLATFORM || npc.Type == NPCID_GRN_PLATFORM ||
            npc.Type == NPCID_RED_PLATFORM || npc.Type == NPCID_PLATFORM_S3 || npc.Type == NPCID_SAW)
    {
        // SpecialX (prev Special2) stores the previous X speed (ignoring platform pause)
        // SpecialY (prev Special) stores the previous Y speed (ignoring platform pause)

        // straightLine = false; // SET BUT NOT USED
        // UNUSED(straightLine);
        tempBool = false;

        for(int B = 1; B <= numPlayers; B++)
        {
            if(Player[B].Section == npc.Section)
                tempBool = true;
        }

        int railAlgo = int(npc.Variant);

        if(npc.Type == NPCID_SAW && railAlgo != 2) // Grinder
        {
            npc.Location.X -= 24;
            npc.Location.Width = 96;
            npc.Location.Y += 8;
            npc.Location.Height = 32;

            NPCQueues::Unchecked.push_back(A);
            // deferring tree update to end of the NPC physics update
        }

        const num_t speed = 2; // The Speed

        if((npc.Direction == 1 && tempBool) || npc.Type == NPCID_SAW) // Player in same section, enabled, or, grinder
        {
            bool pausePlatforms = !AllPlayersNormal();

            // this code ran unconditionally in SMBX 1.3
            if(!g_config.fix_platforms_acceleration || !pausePlatforms) // Keep zeroed speed when player required the pause of the move effect
            {
                npc.Location.SpeedY = npc.SpecialY;
                npc.Location.SpeedX = npc.SpecialX;
            }

            tempBool = false;
            // tempBool2 = false; // "value set, but never unused"
            bool centered = false;

            Location_t tempLocation = npc.Location;

            switch(railAlgo) // The hot spot (the rail attachment point)
            {
            case 0:
            case 1: // Fixed 15x47 hot spot
                tempLocation.Y = npc.Location.Y + 15;
                if(railAlgo == 1)
                    tempLocation.Y -= 1; // Exclusive workaround for The Invasion 1 to fix the stuck at the "Clown Car Parking" level
                tempLocation.Height = 2;
                tempLocation.X = npc.Location.X + 47;
                tempLocation.Width = 2;
                break;

            case 2: // Centered hot spot
                centered = true;
                tempLocation.Y = npc.Location.Y + (npc.Location.Height / 2);
                tempLocation.Height = 2;
                tempLocation.X = npc.Location.X + (npc.Location.Width / 2) - 1;
                tempLocation.Width = 2;
                break;
            }

            num_t speed_y = 0; // D = 0;
            num_t speed_x = 0; // E = 0;
            vbint_t bgo_type = 0; // F = 0;
            // tempNPC = npc;
            Location_t oldLoc = npc.Location;

            for(int i : treeBackgroundQuery(tempLocation, SORTMODE_ID))
            {
                if(i > numBackground)
                    break;

                // Any nearest BGO touched? (rails and reverse buffers)
                if((Background[i].Type >= 70 && Background[i].Type <= 74) || Background[i].Type == 100)
                {
                    // Not hidden
                    if(!Background[i].Hidden)
                    {
                        if(CheckCollision(tempLocation, Background[i].Location))
                        {
                            if(bgo_type > 0)
                            {
                                if(Background[i].Type == npc.Special5 || Background[i].Type == 70 || Background[i].Type == 100)
                                {
                                    bgo_type = 0;
                                    speed_x = 0;
                                    speed_y = 0;
                                    // npc = tempNPC;
                                    npc.Location = oldLoc;
                                }
                            }

                            if(bgo_type == 0)
                            {
                                // Vertical rail
                                if(Background[i].Type == 72)
                                {
                                    if(npc.Location.SpeedY <= 0)
                                        npc.Location.SpeedY = -speed;
                                    else
                                        npc.Location.SpeedY = speed;

                                    npc.Location.SpeedX = 0;

                                    if(centered)
                                        speed_x = -(npc.Location.X + (npc.Location.Width / 2)) + (Background[i].Location.X + (Background[i].Location.Width / 2));
                                    else
                                        speed_x = -npc.Location.X + Background[i].Location.X - 32;
                                }
                                // Horizontal rail
                                else if(Background[i].Type == 71)
                                {
                                    if(npc.Location.SpeedX >= 0)
                                        npc.Location.SpeedX = speed;
                                    else
                                        npc.Location.SpeedX = -speed;

                                    npc.Location.SpeedY = 0;

                                    if(centered)
                                        speed_y = -(npc.Location.Y + (npc.Location.Height / 2)) + (Background[i].Location.Y + (Background[i].Location.Height / 2));
                                    else
                                        speed_y = -npc.Location.Y + Background[i].Location.Y;
                                }
                                // Diagonal rail left-bottom, right-top
                                else if(Background[i].Type == 73)
                                {
                                    if(npc.Location.SpeedY < 0)
                                        npc.Location.SpeedX = speed;
                                    else if(npc.Location.SpeedY > 0)
                                        npc.Location.SpeedX = -speed;

                                    if(npc.Location.SpeedX > 0)
                                        npc.Location.SpeedY = -speed;
                                    else if(npc.Location.SpeedX < 0)
                                        npc.Location.SpeedY = speed;
                                }
                                // Diagonal rail left-top, right-bottom
                                else if(Background[i].Type == 74)
                                {
                                    if(npc.Location.SpeedY < 0)
                                        npc.Location.SpeedX = -speed;
                                    else if(npc.Location.SpeedY > 0)
                                        npc.Location.SpeedX = speed;

                                    if(npc.Location.SpeedX > 0)
                                        npc.Location.SpeedY = speed;
                                    else if(npc.Location.SpeedX < 0)
                                        npc.Location.SpeedY = -speed;
                                }
                                // Reverse buffer
                                else if(Background[i].Type == 70 || Background[i].Type == 100)
                                {
                                    npc.Location.SpeedX = -npc.Location.SpeedX;
                                    npc.Location.SpeedY = -npc.Location.SpeedY;
                                    tempBool = true;
                                    break;
                                }

                                tempBool = true;
                                bgo_type = Background[i].Type;
                            }
                        }
                    }//Not hidden
                } // any important BGO?
            } // for BGOs

            // store current rail type in Special5
            npc.Special5 = bgo_type;

            if(!tempBool)
            {
                if(npc.Type == NPCID_PLATFORM_S3 && npc.Wet == 2)
                    npc.Location.SpeedY -= Physics.NPCGravity / 4;
                else
                    npc.Location.SpeedY += Physics.NPCGravity;
            }
            else
            {
                npc.Location.SpeedX += speed_x;
                npc.Location.SpeedY += speed_y;
            }

            // this code ran unconditionally in SMBX 1.3
            // it does not run in modern mode so that the SpecialY / SpecialX keep the speed from before the pause
            if(!g_config.fix_platforms_acceleration || !pausePlatforms)
            {
                npc.SpecialY = npc.Location.SpeedY;
                npc.SpecialX = npc.Location.SpeedX;
            }

            // NEW: add a terminal velocity for the platforms in modern mode
            if(npc.SpecialY > 40)
            {
                if(g_config.fix_platforms_acceleration)
                    npc.SpecialY = 40;

                // in either mode, try to "cancel" the NPC once it has fallen below everything
                // fixes some serious memory exhaustion bugs
                int below_section = (int)(npc.Location.Y - level[npc.Section].Height);

                // kill 4096 below section in Vanilla, and 1024 below section in Classic / Modern
                int kill_threshold = (!g_config.fix_platforms_acceleration) ? 4096 : 1024;

                if(below_section >= kill_threshold)
                {
                    bool below_all = true;

                    for(int B = 0; B < numSections; B++)
                    {
                        if(npc.Location.Y < level[B].Height)
                        {
                            if(npc.Location.X >= level[B].X && npc.Location.X + npc.Location.Width <= level[B].Width)
                            {
                                below_all = false;
                                break;
                            }
                        }
                    }

                    if(below_all)
                    {
                        npc.Effect = NPCEFF_WAITING;
                        npc.Effect2 = npc.TimeLeft + 1;
                    }
                }
            }

            // SMBX 1.3 logic: zero the actual speed of the platforms
            if(pausePlatforms) // Or zero the speed and don't change special values
            {
                npc.Location.SpeedX = 0;
                npc.Location.SpeedY = 0;
            }
        }
        else
        {
            npc.Location.SpeedX = 0;
            npc.Location.SpeedY = 0;
        }

        Block[npc.tempBlock].Location = npc.Location;
        Block[npc.tempBlock].Location.X += npc.Location.SpeedX;

        if(npc.Location.SpeedY < 0)
            Block[npc.tempBlock].Location.Y += npc.Location.SpeedY;

        // The tempBlock has been moved, above, and the NPC hasn't.
        // So, the tempBlock goes out of sync with the NPC and joins the tree.
        if(npc.tempBlock > 0 && (npc.Location.SpeedX != 0 || npc.Location.SpeedY < 0))
            treeNPCUpdateTempBlock(&npc);

        if(npc.Type == NPCID_SAW)
        {
            if(railAlgo != 2)
            {
                npc.Location.X += 24;
                npc.Location.Width = 48;
                npc.Location.Y -= 8;
                npc.Location.Height = 48;

                NPCQueues::Unchecked.push_back(A);
                // deferring tree update to end of the NPC physics update
            }

            if(npc.Location.SpeedX == 0 && num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity))
            {
                npc.Location.SpeedX = speed * npc.Direction;
                npc.SpecialX = npc.Location.SpeedX;
            }
        }
    }
    else if(npc.Type == NPCID_VILLAIN_S1) // King Koopa
    {
        // don't despawn -- moved from top of this routine
        if(npc.TimeLeft > 1)
            npc.TimeLeft = 100;

        int target_plr = NPCFaceNearestPlayer(npc, true); // was D

        npc.Special5 = target_plr;

        if(iRand(300) >= 297 && npc.Special == 0)
            npc.Special = 1;

        npc.Special4 += 1;

        if(npc.Inert)
            npc.Special4 = 150;

        if(npc.Special4 <= 80 + iRand(40))
        {
            if((iRand(100) >= 40) && npc.Special4 % 16 == 0)
            {
                PlaySoundSpatial(SFX_HeavyToss, npc.Location);
                numNPCs++;
                NPC[numNPCs].Inert = npc.Inert;
                NPC[numNPCs].Location.Height = 32;
                NPC[numNPCs].Location.Width = 32;
                NPC[numNPCs].Location.X = npc.Location.X + npc.Location.Width / 2 - 16;
                NPC[numNPCs].Location.Y = npc.Location.Y - 32;
                NPC[numNPCs].Direction = npc.Direction;
                NPC[numNPCs].Type = NPCID_HEAVY_THROWN;
                NPC[numNPCs].Active = true;
                NPC[numNPCs].TimeLeft = 50;
                NPC[numNPCs].Layer = LAYER_SPAWNED_NPCS;
                NPC[numNPCs].Location.SpeedY = -8;
                NPC[numNPCs].Location.SpeedX = 3 * NPC[numNPCs].Direction;

                syncLayers_NPC(numNPCs);
            }
        }
        else if(npc.Special4 > 300 + iRand(50))
            npc.Special4 = 0;

        if(npc.Inert)
            npc.Special = 0;

        if(npc.Special > 0)
        {
            npc.Special3 += 1;
            if(npc.Special3 < 40)
                npc.Special = 1;
            else if(npc.Special3 < 70)
            {
                if(npc.Special3 == 40)
                {
                    numNPCs++;
                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].TimeLeft = 100;
                    NPC[numNPCs].Direction = npc.Direction;
                    NPC[numNPCs].Section = npc.Section;
                    NPC[numNPCs].Layer = LAYER_SPAWNED_NPCS;
                    NPC[numNPCs].Type = NPCID_VILLAIN_FIRE;
                    if(NPC[numNPCs].Direction == 1)
                        NPC[numNPCs].Frame = 4;
                    NPC[numNPCs].Location.Height = 32;
                    NPC[numNPCs].Location.Width = 48;
                    if(NPC[numNPCs].Direction == -1)
                        NPC[numNPCs].Location.X = npc.Location.X - 40;
                    else
                        NPC[numNPCs].Location.X = npc.Location.X + 54;
                    NPC[numNPCs].Location.Y = npc.Location.Y + 19;

                    NPCSetSpeedTarget_FixedX(NPC[numNPCs], Player[npc.Special5].Location, 4, 1);

                    PlaySoundSpatial(SFX_BigFireball, npc.Location);

                    syncLayers_NPC(numNPCs);
                }
                npc.Special = 2;
            }
            else
            {
                npc.Special = 0;
                npc.Special3 = 0;
            }
        }
        else if(npc.Special == 0)
        {
            if(npc.Special2 == 0)
            {
                npc.Location.SpeedX = -0.5_n;
                if(npc.Location.X < npc.DefaultLocationX - npc.Location.Width * 1.5_rb)
                    npc.Special2 = 1;
            }
            else
            {
                npc.Location.SpeedX = 0.5_n;
                if(npc.Location.X > npc.DefaultLocationX + npc.Location.Width * 1.5_rb)
                    npc.Special2 = 0;
            }

            if(num_t::fEqual_d(npc.Location.SpeedY, Physics.NPCGravity) || npc.Slope > 0)
            {
                if(iRand(100) == 0)
                    npc.Location.SpeedY = -8;
            }
        }
    }
    else if(npc.Type == NPCID_GOALTAPE || npc.Type == NPCID_FLAG_EXIT) // SMW Exit
    {
        // Special is whether the tape is going up or down
        // SpecialY is the Y coordinate of the ground below the tape (was previously Special2)

        if(npc.Type == NPCID_FLAG_EXIT)
        {
            if(LevelMacro == LEVELMACRO_FLAG_EXIT)
            {
                if(npc.Special)
                    npc.Location.SpeedY = 0;
                else
                    npc.Location.SpeedY = 2;

                return;
            }
        }
        else if(npc.Special == 0)
            npc.Location.SpeedY = 2;
        else
            npc.Location.SpeedY = -2;

        if(npc.Location.Y <= npc.DefaultLocationY)
            npc.Special = 0;

        if(npc.SpecialY == 0)
        {
            Location_t tempLocation = npc.Location;
            tempLocation.Height = 8000;
            int C = 0;
            for(int i : treeBlockQuery(tempLocation, SORTMODE_COMPAT))
            {
                if(CheckCollision(tempLocation, Block[i].Location))
                {
                    if(C == 0)
                        C = i;
                    else
                    {
                        if(Block[i].Location.Y < Block[C].Location.Y)
                            C = i;
                    }
                }
            }
            if(C > 0)
                npc.SpecialY = Block[C].Location.Y + 4;
        }

        num_t left_boundary = npc.Location.X;
        if(npc.Type == NPCID_GOALTAPE)
            left_boundary += npc.Location.Width - 8;

        for(int i = 1; i <= numPlayers; i++)
        {
            auto &p = Player[i];

            if(p.Section == npc.Section)
            {
                if(p.Location.Y + npc.Location.Height <= npc.SpecialY)
                {
                    if(p.Location.X + p.Location.Width >= left_boundary)
                    {
                        if(p.Location.X <= npc.Location.X + 80)
                        {
                            if(npc.Type == NPCID_FLAG_EXIT)
                            {
                                // have some stricter checks for this exit
                                if(p.Dead || p.TimeToLive || p.Effect != PLREFF_NORMAL || p.CurMazeZone)
                                    continue;

                                // give tapes for flag exit
                                int score = 10;

                                int gap = num_t::floor(p.Location.Y) - num_t::floor(npc.Location.Y);
                                if(gap > 0)
                                    score -= (gap + 31) / 32;

                                if(score < 1)
                                    score = 1;

                                MoreScore(score, npc.Location);
                            }
                            // give points for goal tape if touched
                            else if(CheckCollision(p.Location, npc.Location))
                            {
                                MoreScore(num_t::vb6round((1 - (npc.Location.Y - npc.DefaultLocationY).divided_by(npc.SpecialY - npc.DefaultLocationY)) * 10) + 1, npc.Location);
                                npc.Killed = 9;
                                NPCQueues::Killed.push_back(A);
                                PlaySoundSpatial(SFX_Stone, npc.Location);
                            }

                            FreezeNPCs = false;
                            TurnNPCsIntoCoins();

                            if(g_ClonedPlayerMode)
                                Player[1] = Player[A];

                            for(int j = 1; j <= numPlayers; j++)
                            {
                                if(i == j) // And DScreenType <> 5 Then
                                    continue;
                                Player[j].Section = p.Section;
                                // yes, it's a VB6 bug
                                Player[j].Location.Y = p.Location.Y /* + p.Location.Height - p.Location.Height*/;
                                Player[j].Location.X = p.Location.X /* + (p.Location.Width - p.Location.Width) / 2*/;
                                Player[j].Location.SpeedX = 0;
                                Player[j].Location.SpeedY = 0;
                                Player[j].Effect = PLREFF_WAITING;
                                Player[j].Effect2 = -i;
                            }

                            StopMusic();

                            if(npc.Type == NPCID_FLAG_EXIT)
                            {
                                LevelMacro = LEVELMACRO_FLAG_EXIT;
                                // go towards the ground
                                npc.Location.Y += 2;
                                // wait for player to reach ground
                                LevelMacroWhich = -16;
                                PlaySound(SFX_FlagExit);
                            }
                            else
                            {
                                LevelMacro = LEVELMACRO_GOAL_TAPE_EXIT;
                                PlaySound(SFX_TapeExit);
                            }

                            // XEvents::doEvents();
                            break;
                        }
                    }
                }
            }
        }

    }
    else if(npc.Type == NPCID_CHECKER_PLATFORM)
    {
        if(npc.Special == 1)
        {
            npc.Location.SpeedY += Physics.NPCGravity / 4;
            npc.Special = 0;
        }
        else
            npc.Location.SpeedY = 0;
    }
    else if(npc.Type == NPCID_PLATFORM_S1)
        npc.Location.SpeedY = npc.Direction * 2;

    else if(npc.Type == NPCID_LAVA_MONSTER)
    {
        if(npc.Special == 0)
        {
            Location_t tempLocation = npc.Location;
            tempLocation.Height = 400;
            tempLocation.Y -= tempLocation.Height;
            tempLocation.set_width_center(600);

            for(int i = 1; i <= numPlayers; i++)
            {
                if(CheckCollision(tempLocation, Player[i].Location))
                {
                    if(npc.Location.to_right_of(Player[i].Location))
                        npc.Direction = -1;
                    else
                        npc.Direction = 1;

                    npc.Special = 1;
                    NewEffect(EFFID_LAVA_MONSTER_LOOK, npc.Location, npc.Direction);
                    break;
                }
            }
        }
        else if(npc.Special == 1)
        {
            npc.Special2 += 1;
            if(npc.Special2 == 90)
            {
                npc.Location.SpeedX = 1 * npc.Direction;
                npc.Location.SpeedY = -4.2_n;
                npc.Special = 2;
                PlaySoundSpatial(SFX_LavaMonster, npc.Location);
            }
        }
        else if(npc.Special == 2)
        {
            npc.Location.SpeedY += Physics.NPCGravity * 0.4_r;
            if(npc.Location.Y > npc.DefaultLocationY + npc.Location.Height + 48)
                Deactivate(A);
        }


        // End If
        // Sniffits
    }
    else if(npc.Type >= NPCID_RED_SPIT_GUY && npc.Type <= NPCID_GRY_SPIT_GUY)
    {
        if(npc.Projectile)
        {
            npc.Special = 0;
            npc.Special2 = 0;
        }

        tempBool = false;

        if(npc.Type < NPCID_GRY_SPIT_GUY)
        {
            npc.Special += 1;
            if(npc.Special > 120)
            {
                npc.FrameCount -= 1;

                if(npc.Special2 == 0)
                {
                    npc.Special2 = 1;
                    npc.Location.X -= 2;
                }
                else
                {
                    npc.Special2 = 0;
                    npc.Location.X += 2;
                }

                npc.Location.SpeedX = 0;

                if(npc.Special >= 150)
                {
                    tempBool = true;
                    npc.Special = 0;
                }
            }
        }
        else
        {
            npc.Special += 1;

            if(npc.Special > 160)
            {
                tempBool = true;

                if(npc.Special3 != 2)
                {
                    npc.Special3 -= 1;
                    npc.Special = 0;
                }
                else
                {
                    npc.Special = 140;
                    npc.Special3 -= 1;
                    if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity) || npc.Slope > 0)
                        npc.Special2 = 90;
                }

                if(npc.Special3 < 0)
                    npc.Special3 = 2;
            }

            if(num_t::fEqual_f(npc.Location.SpeedY, Physics.NPCGravity) || npc.Slope > 0)
            {
                npc.Special2 += 1;
                if(npc.Special2 >= 100)
                {
                    npc.Special2 = 0;
                    npc.Location.SpeedY = -3.9_n;
                    npc.Location.Y -= Physics.NPCGravity;
                    // deferring tree update to end of the NPC physics update
                }
            }
            else
                npc.FrameCount -= 1;
        }

        if(tempBool)
        {
            numNPCs++;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].Section = npc.Section;
            NPC[numNPCs].TimeLeft = 100;
            NPC[numNPCs].Type = NPCID_SPIT_GUY_BALL;
            NPC[numNPCs].Layer = npc.Layer;
            NPC[numNPCs].Inert = npc.Inert;
            NPC[numNPCs].Direction = npc.Direction;
            NPC[numNPCs].Location.SpeedX = 4 * NPC[numNPCs].Direction;
            NPC[numNPCs].Location.Width = 16;
            NPC[numNPCs].Location.Height = 16;
            NPC[numNPCs].Location.X = npc.Location.X + 8 + 16 * NPC[numNPCs].Direction;
            NPC[numNPCs].Location.Y = npc.Location.Y + 13;
            syncLayers_NPC(numNPCs);
        }
    }
    // code moved from pre-NPCSpecial call
    else if(npc.Type == NPCID_SPIT_BOSS_BALL)
    {
        if(!npc.Projectile)
        {
            npc.Location.SpeedY = 0; // egg code
            if(npc.Location.SpeedX == 0)
                npc.Projectile = true;
        }
    }
    else if(npc.Type == NPCID_SLIDE_BLOCK || npc.Type == NPCID_FALL_BLOCK_RED || npc.Type == NPCID_FALL_BLOCK_BROWN)
    {
        if(npc.Special == 0)
            npc.Location.SpeedY = 0;
    }
    else if(npc.Type == NPCID_TOOTHY)
    {
        npc.Location.SpeedX = 0;
        npc.Location.SpeedY = 0;
    }
    // code moved from post-NPCSpecial call
    else if(npc.Type == NPCID_TANK_TREADS)
    {
        if(!AllPlayersNormal())
            npc.Location.SpeedX = 0;
    }
    else if(npc.Type == NPCID_ICE_CUBE)
    {
        if(npc.Projectile || npc.Wet > 0 || npc.HoldingPlayer > 0)
            npc.Special3 = 0;
        else if(npc.Special3 == 1)
        {
            npc.Location.SpeedX = 0;
            npc.Location.SpeedY = 0;
        }

        // this part was from SpecialNPC
        if(npc.Special == 3)
            npc.BeltSpeed = 0;
    }
    else if(npc.Type == NPCID_ITEM_POD)
    {
        if(npc.Special2 == 1)
        {
            // this part was from the below section
            npc.Location.SpeedX = 0;
            npc.Location.SpeedY = 0;

            // this part was from SpecialNPC
            npc.Killed = 1;
            NPCQueues::Killed.push_back(A);
        }
    }
    else if(npc.Type == NPCID_SIGN || npc.Type == NPCID_LIFT_SAND)
    {
        npc.Location.SpeedX = 0;
        npc.Location.SpeedY = 0;
    }
    else if(npc.Type == NPCID_ROCKET_WOOD || npc.Type == NPCID_3_LIFE)
        npc.Location.SpeedY = 0;
    else if(npc.Type == NPCID_CHECKPOINT)
    {
        npc.Projectile = false;
        npc.Location.SpeedX = 0;
        npc.Location.SpeedY = 0;
    }
    else if(npc.Type == NPCID_CYCLONE_POWER)
    {
        npc.Special += 1;

        if(npc.Special == 96 || npc.Special >= 256)
            npc.Special = 128;

        npc.Location.SpeedX /= 2;

        if(npc.Stuck)
        {
            // do nothing!
        }
        // accelerate upwards for 80 frames
        else if(npc.Special < 80)
        {
            if(npc.Special < 32)
                npc.Special2 += (32 - npc.Special);
            else if(npc.Special >= 62)
                npc.Special2 -= (84 - npc.Special) * 2;

            npc.Location.SpeedY = -0.004_n * npc.Special2;
            npc.Location.SpeedX = 0.003_n * (npc.Special2 * npc.Direction);
        }
        // pause for a few frames
        else if(npc.Special < 88)
        {
            npc.Location.SpeedX = 0;

            if(npc.Location.SpeedY < 0_n)
                npc.Location.SpeedY += 0.05_n;
        }
        // ease into movement
        else if(npc.Special < 96)
        {
            npc.Location.SpeedX = Physics.NPCMushroomSpeed * npc.Direction * (npc.Special - 80) / 32;
            npc.Location.SpeedY += 0.05_n;
        }
        // bob movement pattern
        else if(npc.Special < 192)
        {
            if(npc.Location.SpeedY < 1.5_n)
                npc.Location.SpeedY += 0.1_n;
        }
        else
        {
            if(npc.Location.SpeedY > -1.5_n)
                npc.Location.SpeedY -= 0.1_n;
        }
    }
    else if(npc.Type == NPCID_RAFT) // Skull raft
    {
        if(!AllPlayersNormal())
        {
            npc.Location.SpeedX = 0;
            npc.Location.SpeedY = 0;
        }

        // the following is all new code!

        if((npc.Special == 2 || npc.Special == 3) && (npc.SpecialX != 0))
        {
            npc.Location.X = npc.SpecialX; // Finish alignment
            npc.SpecialX = 0;
        }

        if(npc.Special == 3) // Watch for wall collisions. If one got dissappear (hidden layer, toggled switch), resume a ride
        {
            auto loc = npc.Location;
            loc.X += 1 * npc.Direction;
            loc.SpeedX += 2 * npc.Direction;

            // int64_t fBlock;// = FirstBlock[static_cast<int>(floor(static_cast<double>(loc.X / 32))) - 1];
            // int64_t lBlock;// = LastBlock[floor((loc.X + loc.Width) / 32.0) + 1];
            // blockTileGet(loc, fBlock, lBlock);
            bool stillCollide = false;

            for(BlockRef_t block : treeBlockQuery(loc, SORTMODE_NONE))
            {
                int B = block;
                if(!CheckCollision(loc, Block[B].Location))
                    continue;

                if(npc.tempBlock == B || Block[B].tempBlockNoProjClipping() ||
                   BlockOnlyHitspot1[Block[B].Type] || BlockIsSizable[Block[B].Type] ||
                   BlockNoClipping[Block[B].Type] || Block[B].Hidden)
                {
                    continue;
                }

                int hs = NPCFindCollision(loc, Block[B].Location);
                if(Block[B].tempBlockNpcType > 0)
                    hs = 0;
                if(hs == 2 || hs == 4)
                    stillCollide = true;
            }

            if((!npcHasFloor(npc) && NPC[A].Special2 == 0) || !stillCollide)
            {
                npc.Special = 2;
                SkullRide(A, true);
            }
        }
    }
}

void SpecialNPC(int A)
{
    // int B = 0;
    // float C = 0;
    // float D = 0;
    // float E = 0;
    // float F = 0;
    // bool tempTurn = false;
    // Location_t tempLocation;
    // Location_t tempLocation2;
    // NPC_t tempNPC;

    if(NPC[A].Type == NPCID_VILLAIN_FIRE || NPC[A].Type == NPCID_QUAD_BALL || NPC[A].Type == NPCID_STATUE_FIRE ||
       NPC[A].Type == NPCID_SPIT_GUY_BALL || NPC[A].Type == NPCID_PLANT_FIREBALL || NPC[A].Type == NPCID_HEAVY_THROWN ||
       NPC[A].Type == NPCID_SICK_BOSS_BALL || NPC[A].Type == NPCID_HOMING_BALL ||
       NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_HEAVY || NPC[A].Type == NPCID_PLR_ICEBALL) // Link shield block
    {
        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_HEAVY || NPC[A].Type == NPCID_PLR_ICEBALL)
        {
            // Projectile check, previously set immediately before calling SpecialNPC
            NPC[A].Projectile = true;

            if(!BattleMode)
                return;
        }

        for(int B = 1; B <= numPlayers; B++)
        {
            if(Player[B].Character == 5 && !Player[B].Dead && Player[B].TimeToLive == 0 &&
               Player[B].Effect == PLREFF_NORMAL && Player[B].SwordPoke == 0 && !Player[B].Fairy &&
               !(NPC[A].Type == NPCID_PLR_FIREBALL && NPC[A].CantHurtPlayer == B) &&
               !(NPC[A].Type == NPCID_PLR_HEAVY && NPC[A].CantHurtPlayer == B))
            {
                Location_t tempLocation;
                if(!Player[B].Duck)
                    tempLocation.Y = Player[B].Location.Y + Player[B].Location.Height - 52;
                else
                    tempLocation.Y = Player[B].Location.Y + Player[B].Location.Height - 28;
                tempLocation.Height = 24;
                tempLocation.Width = 6;
                if(Player[B].Direction == 1)
                    tempLocation.X = Player[B].Location.X + Player[B].Location.Width - 2;
                else
                    tempLocation.X = Player[B].Location.X - tempLocation.Width + 4;
                if(CheckCollision(NPC[A].Location, tempLocation))
                {
#if XTECH_ENABLE_WEIRD_GFX_UPDATES
                    UpdateGraphics(true);
#endif
                    PlaySoundSpatial(SFX_HeroShield, NPC[A].Location);
                    if(NPC[A].Type == NPCID_SPIT_GUY_BALL)
                    {
                        NPC[A].Killed = 3;
                        NPCQueues::Killed.push_back(A);
                    }
                    else
                    {
                        NPC[A].Killed = 9;
                        NPCQueues::Killed.push_back(A);

                        if(NPC[A].Type == NPCID_PLR_FIREBALL || NPC[A].Type == NPCID_PLR_ICEBALL)
                            NPC[A].Killed = 3;

                        if(NPC[A].Type != NPCID_HEAVY_THROWN && NPC[A].Type != NPCID_SICK_BOSS_BALL && NPC[A].Type != NPCID_HOMING_BALL &&
                           NPC[A].Type != NPCID_PLR_HEAVY && NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PLR_ICEBALL)
                        {
                            for(int Ci = 1; Ci <= 10; Ci++)
                            {
                                NewEffect(EFFID_PLR_FIREBALL_TRAIL, NPC[A].Location, NPC[A].Special);
                                Effect[numEffects].Location.SpeedX = dRand() * 3 - 1.5_n + NPC[A].Location.SpeedX / 10;
                                Effect[numEffects].Location.SpeedY = dRand() * 3 - 1.5_n - NPC[A].Location.SpeedY / 10;

                                if(Effect[numEffects].Frame == 0)
                                    Effect[numEffects].Frame = -iRand(3);
                                else
                                    Effect[numEffects].Frame = 5 + iRand(3);
                            }
                        }

                        if(NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PLR_ICEBALL)
                        {
                            NPC[A].Location.X += (NPC[A].Location.Width - EffectWidth[EFFID_SMOKE_S3]) / 2;
                            NPC[A].Location.Y += (NPC[A].Location.Height - EffectHeight[EFFID_SMOKE_S3]) / 2;
                            NewEffect(EFFID_SMOKE_S3, NPC[A].Location);
                            // deferring tree update to end of the NPC physics update
                        }
                    }
                }
            }
        }
    }
    else if(NPC[A].Type == NPCID_CHAR4_HEAVY) // Toad Boomerang
    {
        // Projectile check, previously set immediately before calling SpecialNPC
        NPC[A].Projectile = true;

        // Special5 is player that threw NPC
        // Special4 is the direction that the player was facing when throwing (Special6 in SMBX 1.3)

        num_t npcHCenter = NPC[A].Location.X + NPC[A].Location.Width / 2;
        num_t npcVCenter = NPC[A].Location.Y + NPC[A].Location.Height / 2;
        num_t playerHCenter = Player[NPC[A].Special5].Location.X + Player[NPC[A].Special5].Location.Width / 2;
        num_t playerVCenter = Player[NPC[A].Special5].Location.Y + Player[NPC[A].Special5].Location.Height / 2;

        if(NPC[A].CantHurt > 0)
            NPC[A].CantHurt = 100;
        if(NPC[A].Location.SpeedY > 8)
            NPC[A].Location.SpeedY = 8;
        if(NPC[A].Location.SpeedY < -8)
            NPC[A].Location.SpeedY = -8;
        if(NPC[A].Location.SpeedX > 12 + Player[NPC[A].Special5].Location.SpeedX)
            NPC[A].Location.SpeedX = 12 + Player[NPC[A].Special5].Location.SpeedX;
        if(NPC[A].Location.SpeedX < -12 + Player[NPC[A].Special5].Location.SpeedX)
            NPC[A].Location.SpeedX = -12 + Player[NPC[A].Special5].Location.SpeedX;

        if(npcHCenter > playerHCenter)
        {
            NPC[A].Location.SpeedX -= 0.2_n;
            if(NPC[A].Location.SpeedX > -4 && NPC[A].Location.SpeedX < 4)
                NPC[A].Location.SpeedX -= 0.5_n;

        }
        else if(npcHCenter < playerHCenter)
        {
            NPC[A].Location.SpeedX += 0.2_n;
            if(NPC[A].Location.SpeedX > -4 && NPC[A].Location.SpeedX < 4)
                NPC[A].Location.SpeedX += 0.5_n;
        }

        NPC[A].Location.SpeedX += (playerHCenter - npcHCenter) / 2000;

        if(NPC[A].Location.Y + NPC[A].Location.Height / 2 > playerVCenter)
        {
            NPC[A].Location.SpeedY -= 0.2_n;
            if(NPC[A].Location.SpeedY > 0 && NPC[A].Direction != NPC[A].Special4)
                NPC[A].Location.SpeedY += -num_t::abs(NPC[A].Location.SpeedY) / 25;
        }
        else if(NPC[A].Location.Y + NPC[A].Location.Height / 2 < playerVCenter)
        {
            NPC[A].Location.SpeedY += 0.2_n;
            if(NPC[A].Location.SpeedY < 0 && NPC[A].Direction != NPC[A].Special4)
                NPC[A].Location.SpeedY += num_t::abs(NPC[A].Location.SpeedY) / 25;
        }
        NPC[A].Location.SpeedY += (playerVCenter - NPC[A].Location.Y + NPC[A].Location.Height / 2) / 250;


        bool picked_up = false;
        bool atCenter = (npcHCenter > playerHCenter && NPC[A].Special4 == 1) ||
                        (npcHCenter < playerHCenter && NPC[A].Special4 == -1);
        if(!atCenter)
        {
            NPC[A].Special2 = 1;
            if(CheckCollision(NPC[A].Location, Player[NPC[A].Special5].Location))
            {
                NPC[A].Killed = 9;
                NPCQueues::Killed.push_back(A);
                Player[NPC[A].Special5].FrameCount = 115;
                PlaySoundSpatial(SFX_Grab2, NPC[A].Location);
                picked_up = true;
            }
        }

        // look for coins, and pick them up if needed
        for(int B : treeNPCQuery(NPC[A].Location, (picked_up) ? SORTMODE_ID : SORTMODE_NONE))
        {
            if(NPC[B].Active)
            {
                if(NPC[B]->IsACoin)
                {
                    if(CheckCollision(NPC[A].Location, NPC[B].Location))
                    {
                        NPC[B].Special = 0;
                        NPC[B].Projectile = false;

                        if(picked_up)
                        {
                            NPC[B].Location.X = playerHCenter - NPC[B].Location.Width / 2;
                            NPC[B].Location.Y = playerVCenter - NPC[B].Location.Height / 2;
                            TouchBonus(NPC[A].Special5, B);
                        }
                        else
                        {
                            NPC[B].Location.X = npcHCenter - NPC[B].Location.Width / 2;
                            NPC[B].Location.Y = npcVCenter - NPC[B].Location.Height / 2;
                        }

                        // must update now because B won't be checked later
                        treeNPCUpdate(B);
                        if(NPC[B].tempBlock > 0)
                            treeNPCSplitTempBlock(B);
                    }
                }
            }
        }

        if(NPC[A].Special2 == 1)
        {
            if(NPC[A].Location.X + NPC[A].Location.Width / 2 > playerHCenter)
            {
                if(NPC[A].Location.SpeedX > 0)
                    NPC[A].Location.SpeedX -= 0.1_n;
            }
            else if(NPC[A].Location.X + NPC[A].Location.Width / 2 < playerHCenter)
            {
                if(NPC[A].Location.SpeedX < 0)
                    NPC[A].Location.SpeedX += 0.1_n;
            }

            if(NPC[A].Location.Y + NPC[A].Location.Height / 2 > playerVCenter)
            {
                if(NPC[A].Location.SpeedY > 0)
                    NPC[A].Location.SpeedY -= 0.3_n;
            }
            else if(NPC[A].Location.Y + NPC[A].Location.Height / 2 < playerVCenter)
            {
                if(NPC[A].Location.SpeedY < 0)
                    NPC[A].Location.SpeedY += 0.1_n;
            }
        }
    }
    else if(NPC[A].Type == NPCID_ITEM_POD) // yoshi egg
    {
        if(NPC[A].Location.SpeedY > 2)
            NPC[A].Projectile = true;

        // moved to NPCSpecial
        // if(NPC[A].Special2 == 1)
        // {
        //     NPC[A].Killed = 1;
        //     NPCQueues::Killed.push_back(A);
        // }
    }
    else if(NPC[A].Type == NPCID_GEM_1 || NPC[A].Type == NPCID_GEM_5 || NPC[A].Type == NPCID_GEM_20) // Rupee
    {
        if(NPC[A].Location.SpeedX < -0.02_n)
            NPC[A].Location.SpeedX += 0.02_n;
        else if(NPC[A].Location.SpeedX > 0.02_n)
            NPC[A].Location.SpeedX -= 0.02_n;
        else
            NPC[A].Location.SpeedX = 0;
    }
    else if(NPC[A].Type == NPCID_ICE_BLOCK || NPC[A].Type == NPCID_ICE_CUBE || NPC[A].Type == NPCID_INVINCIBILITY_POWER) // Yoshi Ice
    {
        // moved to NPCSpecial
        // if(NPC[A].Type == NPCID_ICE_CUBE && NPC[A].Special == 3)
        //     NPC[A].BeltSpeed = 0;

        Location_t tempLocation;

        // two chances to make a sparkle: 7 frames out of 100 when stationary, and 1 frame out of 5 when thrown
        if(iRand(100) >= 93)
            NewEffect_IceSparkle(NPC[A], tempLocation);

        if(NPC[A].Projectile && iRand(5) == 0)
            NewEffect_IceSparkle(NPC[A], tempLocation);
    }
    else if(NPC[A].Type == NPCID_SQUID_S3 || NPC[A].Type == NPCID_SQUID_S1) // Blooper
    {
        if(NPC[A].Wet == 2 && NPC[A].Quicksand == 0)
        {
            if(NPC[A].Special == 0)
            {
                int target_plr = NPCTargetPlayer(NPC[A]);

                if(target_plr == 0)
                    target_plr = 1;

                NPC[A].Special = target_plr;
            }

            if(NPC[A].Special2 == 0 || NPC[A].Special4 == 1)
            {
                if(NPC[A].Location.Y + NPC[A].Location.Height >= Player[NPC[A].Special].Location.Y - 24 || NPC[A].Special4 == 1)
                {
                    NPC[A].Special2 = 60;
                    if(Player[NPC[A].Special].Location.to_right_of(NPC[A].Location))
                        NPC[A].Location.SpeedX = 4;
                    else
                        NPC[A].Location.SpeedX = -4;
                    if(NPC[A].Special4 == 1)
                    {
                        NPC[A].Special4 = 0;
                        NPC[A].Location.Y -= 0.1_n;
                    }
                }
            }

            if(NPC[A].Special2 > 0)
            {
                NPC[A].Special2 -= 1;
                NPC[A].Location.SpeedY = -1.75_n;
                NPC[A].Frame = 0;
            }
            else
            {
                NPC[A].Location.SpeedY = 1;
                NPC[A].Frame = 1;
            }

            if(NPC[A].Special2 == 0)
                NPC[A].Special2 = -20;

            if(NPC[A].Special2 < 0)
                NPC[A].Special2 += 1;

            if(NPC[A].Location.SpeedY >= 0)
                NPC[A].Location.SpeedX = 0;
        }
        else
        {
            NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.7_r;
            if(NPC[A].Location.SpeedY < -1)
                NPC[A].Location.SpeedY = -1;
            NPC[A].Special2 = -60;
        }

        if(Player[NPC[A].Special].Dead || Player[NPC[A].Special].Section != NPC[A].Section)
            NPC[A].Special = 0;
    }
    else if(NPC[A].Type == NPCID_DOOR_MAKER)
    {
        if(NPC[A].Special3 == 1)
        {
            Location_t tempLocation = NPC[A].Location;
            tempLocation.Y -= 32;
            NewEffect(EFFID_SMOKE_S2, NPC[A].Location);
            NewEffect(EFFID_SMOKE_S2, tempLocation);
            NPC[A].Frame = 0;
            NPC[A].Location.SpeedX = 0;
            NPC[A].Location.SpeedY = 0;
            NPC[A].Special3 = 0;
            NPC[A].Effect = NPCEFF_WAITING;
            NPC[A].Effect2 = 16;
            NPC[A].Projectile = false;
            NPC[A].Type = NPCID_MAGIC_DOOR;
            NPC[A].Wings = WING_NONE;
            PlaySoundSpatial(SFX_SpitBossBeat, NPC[A].Location);
        }
    }
    // jumping plant
    else if(NPC[A].Type == NPCID_JUMP_PLANT)
    {
        if(NPC[A].Projectile)
        {
            NPC[A].Location.SpeedY += Physics.NPCGravity;
            NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.98_r;
        }
        else
        {
            if(NPC[A].Special == 0) // hiding
            {
                NPC[A].Location.Y = NPC[A].DefaultLocationY + NPC[A]->THeight + 1.5_n;
                NPC[A].Location.Height = 0;
                NPC[A].Special2 -= 1;

                if(NPC[A].Special2 <= -30)
                {
                    bool tempTurn = true;

                    if(!NPC[A].Inert)
                    {
                        for(int B = 1; B <= numPlayers; B++)
                        {
                            if(!Player[B].Dead && Player[B].TimeToLive == 0)
                            {
                                if(!CanComeOut(NPC[A].Location, Player[B].Location))
                                {
                                    tempTurn = false;
                                    break;
                                }
                            }
                        }
                    }

                    if(tempTurn)
                    {
                        NPC[A].Special = 1;
                        NPC[A].Special2 = 0;
                    }
                    else
                        NPC[A].Special2 = 1000;
                }
            }
            else if(NPC[A].Special == 1) // jumping
            {
                NPC[A].Location.Height = NPC[A]->THeight;

                if(NPC[A].Special2 == 0)
                    NPC[A].Location.SpeedY = -6;
                else if(NPC[A].Location.SpeedY < -4)
                    NPC[A].Location.SpeedY += 0.2_n;
                else if(NPC[A].Location.SpeedY < -3)
                    NPC[A].Location.SpeedY += 0.15_n;
                else if(NPC[A].Location.SpeedY < -2)
                    NPC[A].Location.SpeedY += 0.1_n;
                else if(NPC[A].Location.SpeedY < -1)
                    NPC[A].Location.SpeedY += 0.05_n;
                else
                    NPC[A].Location.SpeedY += 0.02_n;

                NPC[A].Special2 += 1;

                if(NPC[A].Location.SpeedY >= 0)
                {
                    NPC[A].Special = 2;
                    NPC[A].Special2 = 0;
                }

            }
            else if(NPC[A].Special == 2) // falling
            {
                NPC[A].Location.Height = NPC[A]->THeight;

                NPC[A].Location.SpeedY += 0.01_n;
                if(NPC[A].Location.SpeedY >= 0.75_n)
                    NPC[A].Location.SpeedY = 0.75_n;

                if(NPC[A].Location.Y + NPC[A]->THeight >= NPC[A].DefaultLocationY + NPC[A]->THeight)
                {
                    NPC[A].Location.Height = (NPC[A].DefaultLocationY + NPC[A]->THeight) - (NPC[A].Location.Y);
                    if(NPC[A].Location.Y >= NPC[A].DefaultLocationY + NPC[A]->THeight)
                    {
                        NPC[A].Location.Height = 0;
                        NPC[A].Location.Y = NPC[A].DefaultLocationY + NPC[A]->THeight;
                        NPC[A].Special = 0;
                        NPC[A].Special2 = 60;
                    }
                }
            }

            if(NPC[A].Location.Height < 0)
                NPC[A].Location.Height = 0;
            // deferring tree update to end of the NPC physics update

            if(NPC[A].Location.Height == 0)
                NPC[A].Immune = 100;
            else
                NPC[A].Immune = 0;
        }
    }
    // Piranha Plant code
    else if(NPC[A].Type == NPCID_PLANT_S3 || NPC[A].Type == NPCID_BIG_PLANT || NPC[A].Type == NPCID_PLANT_S1
        || NPC[A].Type == NPCID_LONG_PLANT_UP || NPC[A].Type == NPCID_FIRE_PLANT)
    {
        if(NPC[A].Special3 > 0)
            NPC[A].Special3 -= 1;

        if(NPC[A].Type == NPCID_FIRE_PLANT)
        {
            int target_plr = NPCFaceNearestPlayer(NPC[A]);

            if(target_plr != 0)
                NPC[A].Special4 = target_plr;
        }

        if(NPC[A].Location.X != NPC[A].DefaultLocationX)
        {
            NPC[A].Killed = 2;
            NPCQueues::Killed.push_back(A);

            NPC[A].Location.Y += -NPC[A].Location.SpeedY;
            // deferring tree update to end of the NPC physics update
        }
        else
        {
            if(NPC[A].Special2 == 0 && !NPC[A].Inert)
            {
                NPC[A].Location.Y += NPC[A]->THeight + 1.5_n;
                NPC[A].Special2 = 4;
                NPC[A].Special = 70;
            }

            if(NPC[A].Special2 == 1)
            {
                NPC[A].Special += 1;
                NPC[A].Location.Y -= 1.5_n;

                // NPC[A].Special >= NPC[A]->THeight * 0.65 + 1
                if(NPC[A].Special * 100 >= NPC[A]->THeight * 65 + 100)
                {
                    if(g_config.fix_plant_wobble)
                    {
                        NPC[A].Location.Y = num_t::round(NPC[A].Location.Y);
                        NPC[A].Location.Height = NPC[A]->THeight;
                    }

                    NPC[A].Special2 = 2;
                    NPC[A].Special = 0;
                }
            }
            else if(NPC[A].Special2 == 2)
            {
                if(NPC[A].Type != NPCID_LONG_PLANT_UP)
                    NPC[A].Special += 1;

                vbint_t pause_length = (NPC[A].Type == NPCID_FIRE_PLANT) ? 100 : 50;
                if(NPC[A].Special >= pause_length)
                {
                    NPC[A].Special2 = 3;
                    NPC[A].Special = 0;
                }
                // fire plant shoots fire at middle of pause
                else if(NPC[A].Type == NPCID_FIRE_PLANT && NPC[A].Special == 50)
                {
                    numNPCs++;
                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].TimeLeft = 100;
                    NPC[numNPCs].Direction = NPC[A].Direction;
                    NPC[numNPCs].Section = NPC[A].Section;
                    NPC[numNPCs].Type = NPCID_PLANT_FIREBALL;
                    NPC[numNPCs].Frame = 1;
                    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;

                    if(NPC[numNPCs]->TWidth == 16)
                    {
                        NPC[numNPCs].Location.X = NPC[A].Location.X + 8;
                        NPC[numNPCs].Location.Y = NPC[A].Location.Y + 8;
                    }
                    else // modified fireball
                    {
                        NPC[numNPCs].Location.X = NPC[A].Location.X;
                        NPC[numNPCs].Location.Y = NPC[A].Location.Y;
                    }

                    NPCSetSpeedTarget_FixedX(NPC[numNPCs], Player[NPC[A].Special4].Location, 3, 2);

                    NPC[numNPCs].Location.X += NPC[numNPCs].Location.SpeedX * 4;
                    NPC[numNPCs].Location.Y += NPC[numNPCs].Location.SpeedY * 4;

                    syncLayers_NPC(numNPCs);
                }
            }
            else if(NPC[A].Special2 == 3)
            {
                NPC[A].Special += 1;
                NPC[A].Location.Y += 1.5_n;

                // NPC[A].Special >= NPC[A]->THeight * 0.65 + 1
                if(NPC[A].Special * 100 >= NPC[A]->THeight * 65 + 100)
                {
                    NPC[A].Special2 = 4;
                    if(NPC[A].Type == NPCID_LONG_PLANT_UP)
                        NPC[A].Special = 0;
                }
            }
            else if(NPC[A].Special2 == 4)
            {
                NPC[A].Special += 1;

                vbint_t hidden_length = (NPC[A].Type == NPCID_FIRE_PLANT) ? 150 : 75;
                if(NPC[A].Special >= hidden_length)
                {
                    bool tempTurn = true;
                    if(!NPC[A].Inert)
                    {
                        for(int B = 1; B <= numPlayers; B++)
                        {
                            if(!Player[B].Dead && Player[B].TimeToLive == 0)
                            {
                                if(!CanComeOut(NPC[A].Location, Player[B].Location))
                                {
                                    tempTurn = false;
                                    break;
                                }
                            }
                        }
                    }

                    if(tempTurn)
                    {
                        NPC[A].Special2 = 1;
                        NPC[A].Special = 0;
                    }
                    else
                        NPC[A].Special = 140;
                }
            }

            NPC[A].Location.Height = NPC[A]->THeight - (NPC[A].Location.Y - NPC[A].DefaultLocationY);

            if(NPC[A].Location.Height < 0)
                NPC[A].Location.Height = 0;
            // deferring tree update to end of the NPC physics update

            if(NPC[A].Location.Height == 0)
                NPC[A].Immune = 100;
            else
                NPC[A].Immune = 0;
        }
    }
    // down piranha plant
    else if(NPC[A].Type == NPCID_BOTTOM_PLANT || NPC[A].Type == NPCID_LONG_PLANT_DOWN)
    {
        if(NPC[A].Special3 > 0)
            NPC[A].Special3 -= 1;

        if(NPC[A].Location.X != NPC[A].DefaultLocationX)
        {
            NPC[A].Killed = 2;
            NPCQueues::Killed.push_back(A);

            NPC[A].Location.Y -= NPC[A].Location.SpeedY;
            // deferring tree update to end of the NPC physics update
        }
        else
        {
            if(NPC[A].Special2 == 0 && !NPC[A].Inert)
            {
                // .Location.Y += -NPCHeight(.Type) - 1.5
                NPC[A].Location.Height = 0;
                NPC[A].Special2 = 1;
                NPC[A].Special = 0;
            }
            else if(NPC[A].Special2 == 1)
            {
                NPC[A].Special += 1;
                // .Location.Y += 1.5
                NPC[A].Location.Height += 1.5_n;

                // NPC[A].Special >= NPC[A]->THeight * 0.65 + 1
                if(NPC[A].Special * 100 >= NPC[A]->THeight * 65 + 100)
                {
                    if(g_config.fix_plant_wobble)
                        NPC[A].Location.Height = NPC[A]->THeight;

                    NPC[A].Special2 = 2;
                    NPC[A].Special = 0;
                }
            }
            else if(NPC[A].Special2 == 2)
            {
                if(NPC[A].Type != NPCID_LONG_PLANT_DOWN)
                    NPC[A].Special += 1;

                if(NPC[A].Special >= 50)
                {
                    NPC[A].Special2 = 3;
                    NPC[A].Special = 0;
                }
            }
            else if(NPC[A].Special2 == 3)
            {
                NPC[A].Special += 1;
                // .Location.Y += -1.5
                NPC[A].Location.Height -= 1.5_n;

                // NPC[A].Special >= NPC[A]->THeight * 0.65 + 1
                if(NPC[A].Special * 100 >= NPC[A]->THeight * 65 + 100)
                {
                    if(g_config.fix_plant_wobble)
                        NPC[A].Location.Height = 0;

                    NPC[A].Special2 = 4;
                }
            }
            else if(NPC[A].Special2 == 4)
            {
                NPC[A].Special += 1;
                if(NPC[A].Special >= 110)
                {
                    NPC[A].Special2 = 1;
                    NPC[A].Special = 0;
                }
            }
            // deferring tree update to end of the NPC physics update

            if(NPC[A].Location.Height == 0)
                NPC[A].Immune = 100;
            else
                NPC[A].Immune = 0;
        }
    // left/right piranha plant
    }
    else if(NPC[A].Type == NPCID_SIDE_PLANT)
    {
        NPC[A].Direction = NPC[A].DefaultDirection;
        if(NPC[A].Location.Y != NPC[A].DefaultLocationY)
        {
            NPC[A].Location.Y += -NPC[A].Location.SpeedY;
            NPCHit(A, 4);
            // deferring tree update to end of the NPC physics update
        }
        else
        {
            if(NPC[A].Special2 == 0 && !NPC[A].Inert)
            {
                if(NPC[A].Direction == 1)
                {
                    // .Location.x += -NPCWidth(.Type) - 1.5
                    NPC[A].Location.Width += -NPC[A]->TWidth - 1.5_n;
                }
                else
                    NPC[A].Location.X += NPC[A]->TWidth + 1.5_n;
                NPC[A].Special2 = 1;
                NPC[A].Special = 0;
            }
            else if(NPC[A].Special2 == 1)
            {
                NPC[A].Special += 1;

                if(NPC[A].Direction == -1)
                    NPC[A].Location.X += 1.5_n * NPC[A].Direction;
                else
                    NPC[A].Location.Width += 1.5_n * NPC[A].Direction;

                // NPC[A].Special >= NPC[A]->TWidth * 0.65 + 1
                if(NPC[A].Special * 100 >= NPC[A]->TWidth * 65 + 100)
                {
                    if(g_config.fix_plant_wobble)
                    {
                        NPC[A].Location.Width = NPC[A]->TWidth;
                        NPCQueues::Unchecked.push_back(A);
                    }

                    NPC[A].Special2 = 2;
                    NPC[A].Special = 0;
                }
            }
            else if(NPC[A].Special2 == 2)
            {
                NPC[A].Special += 1;

                if(NPC[A].Special >= 50)
                {
                    NPC[A].Special2 = 3;
                    NPC[A].Special = 0;
                }
            }
            else if(NPC[A].Special2 == 3)
            {
                NPC[A].Special += 1;

                if(NPC[A].Direction == -1)
                    NPC[A].Location.X -= 1.5_n * NPC[A].Direction;
                else
                    NPC[A].Location.Width -= 1.5_n * NPC[A].Direction;

                // NPC[A].Special >= NPC[A]->TWidth * 0.65 + 1
                if(NPC[A].Special * 100 >= NPC[A]->TWidth * 65 + 100)
                {
                    NPC[A].Special2 = 4;

                    if(g_config.fix_plant_wobble)
                    {
                        NPC[A].Location.Width = 0;
                        NPCQueues::Unchecked.push_back(A);
                    }
                }
            }
            else if(NPC[A].Special2 == 4)
            {
                NPC[A].Special += 1;
                if(NPC[A].Special >= 110)
                {
                    NPC[A].Special2 = 1;
                    NPC[A].Special = 0;
                }
            }

            if(NPC[A].Direction == -1)
            {
                NPC[A].Location.Width = NPC[A]->TWidth - (NPC[A].Location.X - NPC[A].DefaultLocationX);
                if(NPC[A].Location.Width < 0)
                    NPC[A].Location.Width = 0;

                NPCQueues::Unchecked.push_back(A);
            }

            // deferring tree update to end of the NPC physics update

            if(NPC[A].Location.Width == 0)
                NPC[A].Immune = 100;
            else
                NPC[A].Immune = 0;

        }
    }
    // smb3 belt code
    else if(NPC[A].Type == NPCID_CONVEYOR)
    {
        NPC[A].Location.SpeedX = 0.8_n * NPC[A].DefaultDirection * BeltDirection;
        NPC[A].Location.X = NPC[A].DefaultLocationX;
        NPC[A].Location.Y = NPC[A].DefaultLocationY;
        NPC[A].Direction = NPC[A].DefaultDirection * BeltDirection;
        // deferring tree update to end of the NPC physics update
    }
    else if(NPC[A].Type == NPCID_CIVILIAN_SCARED)
    {
        if(NPC[A].Location.SpeedY == Physics.NPCGravity)
        {
            NPC[A].Special += 1;
            NPC[A].Frame = 0;
            if(NPC[A].Special >= 100)
                NPC[A].Special = 1;
            else if(NPC[A].Special >= 10)
            {
                NPC[A].Special = 0;
                NPC[A].Frame = 1;
                NPC[A].Location.Y -= 1;
                NPC[A].Location.SpeedY = -4.6_n;
                // deferring tree update to end of the NPC physics update
            }
        }
        else
        {
            if(NPC[A].Special <= 8)
            {
                NPC[A].Special += 1;
                NPC[A].Frame = 1;
            }
            else
            {
                NPC[A].Frame = 2;
                NPC[A].Special = 100;
            }

        }

        if(NPC[A].Direction == 1)
            NPC[A].Frame += 3;
    }
    // Fireball code (Podoboo)
    else if(NPC[A].Type == NPCID_LAVABUBBLE)
    {
        Location_t tempLocation;

        if(NPC[A].Location.Y > NPC[A].DefaultLocationY + NPC[A].Location.Height + 16)
            NPC[A].Location.Y = NPC[A].DefaultLocationY + NPC[A]->THeight + 16;

        NPC[A].Projectile = true;

        // If .Location.X <> .DefaultLocationX Then .Killed = 2
        if(NPC[A].Special2 == 0)
        {
            NPC[A].Location.Y = NPC[A].DefaultLocationY + NPC[A].Location.Height + 1.5_n;
            NPC[A].Special2 = 1;
            NPC[A].Special = 0;
            PlaySoundSpatial(SFX_Lava, NPC[A].Location);
            tempLocation = NPC[A].Location;
            tempLocation.Y -= 32;
            NewEffect(EFFID_LAVA_SPLASH, tempLocation);
        }
        else if(NPC[A].Special2 == 1)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedY = -6;

            if(NPC[A].Location.Y < NPC[A].DefaultLocationY - 10)
            {
                if(NPC[A].Special % 5 == 0) {
                    NewEffect(EFFID_BIG_FIREBALL_TAIL, NPC[A].Location);
                }
            }

            if(NPC[A].Special >= 30)
            {
                NPC[A].Special2 = 2;
                NPC[A].Special = 0;
            }
        }
        else if(NPC[A].Special2 == 2)
        {
            NPC[A].Special += 1;

            if(NPC[A].Special == 61)
            {
                tempLocation = NPC[A].Location;
                tempLocation.Y += 2;
                NewEffect(EFFID_LAVA_SPLASH, tempLocation);
                PlaySoundSpatial(SFX_Lava, NPC[A].Location);
            }

            if(NPC[A].Special >= 150)
            {
                NPC[A].Special2 = 0;
                NPC[A].Special = 0;
            }
        }

        if(NPC[A].Location.Y > level[NPC[A].Section].Height + 1)
            NPC[A].Location.Y = level[NPC[A].Section].Height;
        // deferring tree update to end of the NPC physics update

        // Stop the big fireballs from getting killed from tha lava
        NPC[A].Projectile = false;
    }
    else if(NPC[A].Type == NPCID_FALL_BLOCK_RED || NPC[A].Type == NPCID_FALL_BLOCK_BROWN)
    {
        if(LevelMacro == LEVELMACRO_OFF && NPC[A].Special == 0)
        {
            if(NPC[A].Special2 == 1)
            {
                NPC[A].Special3 += 1;
                NPC[A].Special2 = 0;

                // new shake logic because wings allow this object to move horizontally
                if(NPC[A].Wings)
                {
                    NPC[A].Special4 = (NPC[A].Special4 + 1) & 3;
                    NPC[A].Location.X += (NPC[A].Special4 >= 2) ? 2 : -2;
                }
                else
                {
                    NPC[A].Location.X += NPC[A].Direction * 2;
                    if(NPC[A].Location.X >= NPC[A].DefaultLocationX + 2)
                        NPC[A].Direction = -1;
                    if(NPC[A].Location.X <= NPC[A].DefaultLocationX - 2)
                        NPC[A].Direction = 1;
                }
            }
            else
            {
                if(NPC[A].Special3 > 0)
                    NPC[A].Special3 -= 1;

                // new shake logic because wings allow this object to move horizontally
                if(NPC[A].Wings)
                    NPC[A].Special4 = 0;
                else
                    NPC[A].Location.X = NPC[A].DefaultLocationX;
            }

            if((NPC[A].Special3 >= 5 && NPC[A].Type == NPCID_FALL_BLOCK_RED) || (NPC[A].Special3 >= 30 && NPC[A].Type == NPCID_FALL_BLOCK_BROWN))
            {
                NPC[A].Special = 1;

                if(NPC[A].Wings)
                    NPC[A].Wings = WING_NONE;
                else
                    NPC[A].Location.X = NPC[A].DefaultLocationX;
            }
            // deferring tree update to end of the NPC physics update
        }
    // Big Koopa Code
    }
    else if(NPC[A].Type == NPCID_MINIBOSS)
    {
        // Special is the current state
        // SpecialY is the main counter (was previously Special2)
        if(NPC[A].Legacy)
        {
            if(NPC[A].TimeLeft > 1)
                NPC[A].TimeLeft = 100;
            if(bgMusic[NPC[A].Section] != 6 && bgMusic[NPC[A].Section] != 15 && bgMusic[NPC[A].Section] != 21 && NPC[A].TimeLeft > 1)
            {
                bgMusic[NPC[A].Section] = 6;
                StartMusicIfOnscreen(NPC[A].Section);
            }
        }

        // temporarily remove any wings if not in normal state
        if(NPC[A].Special != 0)
            NPC[A].Wings = WING_NONE;

        if(NPC[A].Special == 0)
        {
            if(NPC[A].Location.Height != 54)
            {
                NPC[A].Location.Y += NPC[A].Location.Height - 54;
                NPC[A].Location.Height = 54;

                // restore wings if lost
                NPC[A].Wings = NPC[A].DefaultWings;
            }

            NPC[A].SpecialY += dRand() * 2;
            if(NPC[A].SpecialY >= 250 + iRand(250))
            {
                NPC[A].Special = 2;
                NPC[A].SpecialY = 0;
            }
        }
        else if(NPC[A].Special == 2)
        {
            NPC[A].SpecialY += 1;
            if(NPC[A].SpecialY >= 10)
            {
                NPC[A].Special = 1;
                NPC[A].SpecialY = 0;
            }
        }
        else if(NPC[A].Special == 1)
        {
            if(NPC[A].Location.Height != 40)
            {
                NPC[A].Location.Y += NPC[A].Location.Height - 40;
                NPC[A].Location.Height = 40;
            }

            NPC[A].SpecialY += dRand() * 2;
            if(NPC[A].SpecialY >= 100 + iRand(100))
            {
                NPC[A].Special = 3;
                NPC[A].SpecialY = 0;
            }
        }
        else if(NPC[A].Special == 3)
        {
            NPC[A].SpecialY += 1;
            if(NPC[A].SpecialY >= 10)
            {
                NPC[A].Special = 0;
                NPC[A].SpecialY = 0;
            }
        }
        else if(NPC[A].Special == 4)
        {
            if(NPC[A].Location.Height != 34)
            {
                NPC[A].Location.Y += NPC[A].Location.Height - 34;
                NPC[A].Location.Height = 34;
            }

            NPC[A].SpecialY += 1;
            if(NPC[A].SpecialY >= 100)
            {
                NPC[A].Special = 1;
                NPC[A].SpecialY = 0;
            }
        }
        // deferring tree update to end of the NPC physics update
    }
    else if(NPCIsAParaTroopa(NPC[A].Type)) // para-troopas
    {
        // do wings logic if it won't be handled elsewhere
        if(!NPC[A].Wings)
            NPCMovementLogic_Wings(A, 1);
    }
    // Jumpy bee thing
    else if(NPC[A].Type == NPCID_FLY)
    {
        if(NPC[A].Location.SpeedY == Physics.NPCGravity || NPC[A].Slope > 0)
        {
            NPC[A].Location.SpeedX = 0;
            NPC[A].Special += 1;
            if(NPC[A].Special == 30)
            {
                NPC[A].Special = 0;
                NPC[A].Location.Y -= 1;
                NPC[A].Location.SpeedY = -6;
                NPC[A].Location.SpeedX = 1.4_n * NPC[A].Direction;
                // deferring tree update to end of the NPC physics update
            }
        }
    }
    // Bouncy Star thing code
    else if(NPC[A].Type == NPCID_JUMPER_S3)
    {
        NPCFaceNearestPlayer(NPC[A]);

        if(NPC[A].Location.SpeedY == Physics.NPCGravity || NPC[A].Slope > 0)
        {
            NPC[A].Special += 1;
            if(NPC[A].Special == 8)
            {
                NPC[A].Location.SpeedY = -7;
                NPC[A].Location.Y -= 1;
                NPC[A].Special = 0;
                // deferring tree update to end of the NPC physics update
            }
        }
        else
            NPC[A].Special = 0;
    }
    // bowser statue
    else if(NPC[A].Type == NPCID_STATUE_S3 || NPC[A].Type == NPCID_STATUE_S4)
    {
        NPC[A].Special += 1;
        if(NPC[A].Special > 200 + iRand(200))
        {
            NPC[A].Special = 0;
            numNPCs++;
            NPC[numNPCs].Inert = NPC[A].Inert;
            NPC[numNPCs].Type = NPCID_STATUE_FIRE;
            NPC[numNPCs].Direction = NPC[A].Direction;
            NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
            NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
            NPC[numNPCs].TimeLeft = 100;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].Section = NPC[A].Section;
            NPC[numNPCs].Location.Y = NPC[A].Location.Y + 16;
            NPC[numNPCs].Location.X = NPC[A].Location.X + 24 * NPC[numNPCs].Direction;
            if(NPC[A].Type == NPCID_STATUE_S4)
            {
                NPC[numNPCs].Location.Y -= 5;
                NPC[numNPCs].Location.X = NPC[A].Location.X + 6 + 30 * NPC[numNPCs].Direction;
            }
            NPC[numNPCs].Location.SpeedX = 4 * NPC[numNPCs].Direction;
            if(NPC[numNPCs].Direction == 1)
                NPC[numNPCs].Frame = 4;
            NPC[numNPCs].FrameCount = iRand(8);
            PlaySoundSpatial(SFX_BigFireball, NPC[A].Location);

            syncLayers_NPC(numNPCs);
        }
    }
    // Hammer Bro
    else if(NPC[A].Type == NPCID_HEAVY_THROWER)
    {
        if(NPC[A].Projectile)
            return;

        NPCFaceNearestPlayer(NPC[A]);

        if(NPC[A].Special > 0)
        {
            NPC[A].Special += 1;
            NPC[A].Location.SpeedX = 0.6_n;
            if(NPC[A].Special >= 100 && NPC[A].Location.SpeedY == Physics.NPCGravity)
                NPC[A].Special = -1;
        }
        else
        {
            NPC[A].Special -= 1;
            NPC[A].Location.SpeedX = -0.6_n;
            if(NPC[A].Special <= -100 && NPC[A].Location.SpeedY == Physics.NPCGravity)
                NPC[A].Special = 1;
        }

        if(NPC[A].Location.SpeedY == Physics.NPCGravity)
        {
            NPC[A].Special2 += 1;
            if(NPC[A].Special2 >= 250)
            {
                NPC[A].Location.SpeedY = -7;
                NPC[A].Location.Y -= 1;
                NPC[A].Special2 = 0;
                // deferring tree update to end of the NPC physics update
            }
        }

        // the throw counter was previously Special3
        NPC[A].SpecialX += dRand() * 2;
        if(NPC[A].SpecialX >= 50 + dRand() * 1000)
        {
            if(NPC[A].Location.SpeedY == Physics.NPCGravity)
            {
                NPC[A].Location.SpeedY = -3;
                NPC[A].Location.Y -= 1;
                // deferring tree update to end of the NPC physics update
            }

            PlaySoundSpatial(SFX_HeavyToss, NPC[A].Location);
            NPC[A].SpecialX = -15;
            numNPCs++;
            NPC[numNPCs].Inert = NPC[A].Inert;
            NPC[numNPCs].Location.Height = 32;
            NPC[numNPCs].Location.Width = 32;
            NPC[numNPCs].Location.X = NPC[A].Location.X;
            NPC[numNPCs].Location.Y = NPC[A].Location.Y;
            NPC[numNPCs].Direction = NPC[A].Direction;
            NPC[numNPCs].Type = NPCID_HEAVY_THROWN;
            NPC[numNPCs].Section = NPC[A].Section;
            NPC[numNPCs].Active = true;
            NPC[numNPCs].TimeLeft = 50;
            NPC[numNPCs].Location.SpeedY = -8;
            NPC[numNPCs].Location.SpeedX = 3 * NPC[numNPCs].Direction;

            syncLayers_NPC(numNPCs);
        }
    }
    // leaf
    else if(NPC[A].Type == NPCID_LEAF_POWER) // Leaf
    {
        if(NPC[A].Stuck && !NPC[A].Projectile)
            NPC[A].Location.SpeedX = 0;
        else if(NPC[A].Stuck)
        {
            NPC[A].Location.SpeedY += Physics.NPCGravity;
            if(NPC[A].Location.SpeedY >= 8)
                NPC[A].Location.SpeedY = 8;
        }
        else if(NPC[A].Special == 0)
        {
            NPC[A].Location.SpeedY += Physics.NPCGravity;
            if(NPC[A].Projectile)
            {
                if(NPC[A].Location.SpeedY >= 2)
                {
                    NPC[A].Location.SpeedX = 1.2_n;
                    NPC[A].Special = 1;
                    NPC[A].Projectile = false;
                }

            }
            else if(NPC[A].Location.SpeedY >= 0)
                NPC[A].Special = 6;
        }
        else
        {
            if(NPC[A].Special == 1)
            {
                NPC[A].Location.SpeedY -= 0.25_n;
                NPC[A].Location.SpeedX += 0.3_n;
                if(NPC[A].Location.SpeedY <= 0)
                    NPC[A].Special = 2;
            }
            else if(NPC[A].Special == 2)
            {
                NPC[A].Location.SpeedX -= 0.3_n;
                NPC[A].Location.SpeedY -= 0.02_n;
                if(NPC[A].Location.SpeedX <= 0)
                {
                    NPC[A].Special = 3;
                    NPC[A].Location.SpeedX = 0;
                }
            }
            else if(NPC[A].Special == 3)
            {
                NPC[A].Location.SpeedY += 0.4_n;
                NPC[A].Location.SpeedX -= 0.1_n;
                if(NPC[A].Location.SpeedY >= 3)
                    NPC[A].Special = 4;
            }
            else if(NPC[A].Special == 4)
            {
                NPC[A].Location.SpeedY -= 0.25_n;
                NPC[A].Location.SpeedX -= 0.3_n;
                if(NPC[A].Location.SpeedY <= 0)
                    NPC[A].Special = 5;
            }
            else if(NPC[A].Special == 5)
            {
                NPC[A].Location.SpeedX += 0.3_n;
                NPC[A].Location.SpeedY -= 0.02_n;
                if(NPC[A].Location.SpeedX >= 0)
                {
                    NPC[A].Special = 6;
                    NPC[A].Location.SpeedX = 0;
                }
            }
            else if(NPC[A].Special == 6)
            {
                NPC[A].Location.SpeedY += 0.4_n;
                NPC[A].Location.SpeedX += 0.1_n;
                if(NPC[A].Location.SpeedY >= 3)
                    NPC[A].Special = 1;
            }
        }
    }
    else if(NPC[A].Type == NPCID_SPIKY_THROWER || NPC[A].Type == NPCID_ITEM_THROWER) // combined code for spiky and item throwers
    {
        if(NPC[A].Type == NPCID_ITEM_THROWER && NPC[A].Special == 0)
            NPC[A].Special = NPC[A].Type;

        NPC[A].Projectile = false;
        if(NPC[A].TimeLeft > 1)
            NPC[A].TimeLeft = 100;
        if(NPC[A].CantHurt > 0)
            NPC[A].CantHurt = 100;

        num_t min_dist = 0;
        int target_plr = 0;
        for(int B = 1; B <= numPlayers; B++)
        {
            if(NPC[A].Type == NPCID_ITEM_THROWER && Player[B].TimeToLive != 0)
                continue;

            if(!Player[B].Dead && Player[B].Section == NPC[A].Section && B != NPC[A].CantHurtPlayer)
            {
                num_t dist = NPCPlayerTargetDist(NPC[A], Player[B]);
                if(min_dist == 0 || dist < min_dist)
                {
                    min_dist = dist;
                    target_plr = B;
                }
            }
        }

        const auto& p = Player[target_plr];

        if(target_plr > 0)
        {
            // this direction indicator used Special (for spiky throwers) and Special6 (for item throwers) in SMBX 1.3
            // now it uses SpecialX (as a simple boolean flag)

            // speed control code: check distance to player
            num_t dx = NPC[A].Location.minus_center_x(p.Location);
            num_t speed_bound = num_t::abs(dx) / 100 + num_t::abs(p.Location.SpeedX) / 2 + 5;

            // adjust expected distance by player's speed
            dx -= p.Location.SpeedX * 15;

            // movement left
            if(NPC[A].SpecialX == 0)
            {
                if(NPC[A].Location.SpeedX >= -speed_bound)
                    NPC[A].Location.SpeedX -= 0.2_n;
                // if we are more than 50px to the left of the player's expected location
                if(dx < -50)
                    NPC[A].SpecialX = 1;
            }
            // movement right
            else
            {
                if(NPC[A].Location.SpeedX <= speed_bound)
                    NPC[A].Location.SpeedX += 0.2_n;
                // if we are more than 50px to the right of the player's expected location
                if(dx > 50)
                    NPC[A].SpecialX = 0;
            }

            // target_plr is the targeted player
            // D is the targeted vScreen

            int D;
            if(g_config.fix_npc_camera_logic)
                D = vScreenIdxByPlayer_canonical(target_plr);
            else
            {
                const Screen_t& plr_screen = ScreenByPlayer(target_plr);

                int vscreen_idx = 0;

                if(plr_screen.player_count == 2)
                {
                    if(plr_screen.Type == 5)
                    {
                        if(plr_screen.DType != 5)
                            vscreen_idx = 1;
                    }
                }

                D = plr_screen.vScreen_refs[vscreen_idx];
            }

            if(NPC[A].Location.Y + NPC[A].Location.Height > p.Location.Y - 248)
                NPC[A].Special2 = 1;
            if(NPC[A].Location.Y + NPC[A].Location.Height < p.Location.Y - 256 || NPC[A].Location.Y < -vScreen[D].Y)
                NPC[A].Special2 = 0;
            if(NPC[A].Location.Y > -vScreen[D].Y + 64)
                NPC[A].Special2 = 1;
            if(NPC[A].Location.Y < -vScreen[D].Y + 72)
                NPC[A].Special2 = 0;

            if(NPC[A].Special2 == 0)
            {
                NPC[A].Location.SpeedY += 0.05_n;
                if(NPC[A].Location.SpeedY > 2)
                    NPC[A].Location.SpeedY = 2;
            }
            else
            {
                NPC[A].Location.SpeedY -= 0.05_n;
                if(NPC[A].Location.SpeedY < -2)
                    NPC[A].Location.SpeedY = -2;
            }

            if(NPC[A].Inert)
            {
                if(NPC[A].Special3 > 1)
                    NPC[A].Special3 = 0;
            }

            // frame timing code for spiky thrower
            if(NPC[A].Type != NPCID_ITEM_THROWER)
            {
                if(NPC[A].Special3 == 0)
                {
                    NPC[A].FrameCount += 1;
                    if(NPC[A].FrameCount >= 10)
                    {
                        NPC[A].FrameCount = 0;
                        NPC[A].Frame += 1;
                        if(NPC[A].Frame >= 2)
                            NPC[A].Special3 = 1;
                    }
                }
                else if(NPC[A].Special3 == 1)
                {
                    NPC[A].FrameCount += 1;
                    if(NPC[A].FrameCount >= 10)
                    {
                        NPC[A].FrameCount = 0;
                        NPC[A].Frame -= 1;
                        if(NPC[A].Frame <= 0)
                            NPC[A].Special3 = 0;
                    }
                }
                else if(NPC[A].Special3 == 2)
                {
                    NPC[A].FrameCount += 1;
                    if(NPC[A].FrameCount >= 16)
                    {
                        NPC[A].FrameCount = 10;
                        if(NPC[A].Frame < 5)
                            NPC[A].Frame += 1;
                        if(NPC[A].Frame <= 5)
                            NPC[A].Special5 += 1;
                    }
                }
                else if(NPC[A].Special3 == 3)
                {
                    NPC[A].FrameCount += 1;
                    if(NPC[A].FrameCount >= 2)
                    {
                        NPC[A].FrameCount = 0;
                        NPC[A].Frame -= 1;
                        if(NPC[A].Frame <= 0)
                        {
                            NPC[A].Special3 = 0;
                            NPC[A].Frame = 0;
                        }
                    }
                }
            }

            // yes, it's a VB6 bug, p.Location.Width / 2 should be subtracted, not added
            if(num_t::abs(NPC[A].Location.X - p.Location.X + (NPC[A].Location.Width + p.Location.Width) / 2) < 100)
            {
                if(NPC[A].Special4 == 0)
                {
                    NPC[A].Special3 = 2;
                    NPC[A].Special4 = 100;
                }
            }
        }

        if(NPC[A].Special4 > 0)
            NPC[A].Special4 -= 1;

        // frame timing code for item thrower
        if(NPC[A].Type == NPCID_ITEM_THROWER)
        {
            NPC[A].Frame = 0;
            if(NPC[A].FrameCount < 100)
            {
                NPC[A].FrameCount += 1;
                if(NPC[A].FrameCount < 8)
                    NPC[A].Frame = 0;
                else if(NPC[A].FrameCount < 16)
                    NPC[A].Frame = 1;
                else if(NPC[A].FrameCount < 24)
                    NPC[A].Frame = 2;
                else if(NPC[A].FrameCount < 32)
                    NPC[A].Frame = 1;
                else
                {
                    NPC[A].Frame = 0;
                    NPC[A].FrameCount = 0;
                }
            }
            else
            {
                NPC[A].FrameCount += 1;
                if(NPC[A].FrameCount < 108)
                    NPC[A].Frame = 6;
                else if(NPC[A].FrameCount < 116)
                    NPC[A].Frame = 7;
                else if(NPC[A].FrameCount < 124)
                    NPC[A].Frame = 8;
                else if(NPC[A].FrameCount < 132)
                    NPC[A].Frame = 7;
                else
                {
                    NPC[A].Frame = 0;
                    NPC[A].FrameCount = 0;
                }
            }

            if(NPC[A].Direction == 1)
                NPC[A].Frame += 3;

            NPC[A].Special5 += 1;
        }

        int timer = (NPC[A].Type == NPCID_ITEM_THROWER) ? 150 : 20;

        if(NPC[A].Special5 >= timer)
        {
            NPC[A].Special5 = timer;
            Location_t tempLocation = NPC[A].Location;
            tempLocation.X -= 16;
            tempLocation.Y -= 16;
            tempLocation.Width += 32;
            tempLocation.Height += 32;

            bool do_not_throw = false;

            if(NPC[A].Location.Y + NPC[A].Location.Height > p.Location.Y)
                do_not_throw = true;
            else
            {
                for(int Ei : treeBlockQuery(tempLocation, SORTMODE_NONE))
                {
                    if(NPC[A].Type != NPCID_ITEM_THROWER)
                    {
                        if(BlockIsSizable[Block[Ei].Type] ||
                           BlockOnlyHitspot1[Block[Ei].Type])
                        {
                            continue;
                        }
                    }

                    if(CheckCollision(tempLocation, Block[Ei].Location) && !BlockNoClipping[Block[Ei].Type])
                    {
                        do_not_throw = true;
                        break;
                    }
                }
            }

            if(!do_not_throw)
            {
                if(NPC[A].Type == NPCID_ITEM_THROWER)
                    NPC[A].FrameCount = 100;
                else
                    NPC[A].FrameCount = 0;

                NPC[A].Special3 = 3;
                NPC[A].Special5 = 0;

                numNPCs++;

                if(NPC[A].Location.to_right_of(p.Location))
                    NPC[numNPCs].Direction = -1;
                else
                    NPC[numNPCs].Direction = 1;

                if(NPC[A].CantHurt > 0)
                {
                    NPC[numNPCs].CantHurt = 100;
                    NPC[numNPCs].CantHurtPlayer = NPC[A].CantHurtPlayer;
                }

                NPC[numNPCs].Active = true;
                NPC[numNPCs].Section = NPC[A].Section;
                NPC[numNPCs].TimeLeft = 100;

                if(NPC[A].Type == NPCID_ITEM_THROWER)
                {
                    NPC[numNPCs].Type = NPCID(NPC[A].Special);

                    if(NPC[numNPCs].Type == NPCID_RANDOM_POWER)
                        NPC[numNPCs].Type = RandomBonus();

                    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                    NPC[numNPCs].Location.X = NPC[A].Location.X + (NPC[A].Location.Width - NPC[numNPCs].Location.Width) / 2;
                    NPC[numNPCs].Location.Y = NPC[A].Location.Y + 8;

                    NPC[numNPCs].Location.SpeedX = (1 + dRand() * 2) * NPC[numNPCs].Direction;
                    NPC[numNPCs].Location.SpeedY = -7;

                    NPC[numNPCs].Variant = NPC[A].Variant;

                    if(NPC[numNPCs]->IsACoin)
                    {
                        NPC[numNPCs].Special = 1;
                        NPC[numNPCs].Location.SpeedX /= 2;
                    }

                    // commented out in SMBX 1.3
                    // tempNPC = NPC(A)
                    // NPC(A) = NPC(numNPCs)
                    // NPC(numNPCs) = tempNPC
                }
                else
                {
                    NPC[numNPCs].Type = NPCID_SPIKY_BALL_S3;

                    NPC[numNPCs].Location.X = NPC[A].Location.X;
                    NPC[numNPCs].Location.Y = NPC[A].Location.Y + 8;
                    NPC[numNPCs].Location.Height = 32;
                    NPC[numNPCs].Location.Width = 32;

                    NPC[numNPCs].Location.SpeedX = (1.5_n + num_t::abs(p.Location.SpeedX) * 0.75_rb) * NPC[numNPCs].Direction;
                    NPC[numNPCs].Location.SpeedY = -8;

                    // tempNPC = NPC[A];
                    NPC_t tempNPC = NPC[A];
                    NPC[A] = NPC[numNPCs];
                    NPC[numNPCs] = tempNPC;
                    PlaySoundSpatial(SFX_HeavyToss, NPC[A].Location);

                    syncLayers_NPC(A);
                }

                syncLayers_NPC(numNPCs);
            }
        }
    }
    else if(NPC[A].Type == NPCID_HIT_CARRY_FODDER) // smw goomba
    {
        NPC[A].Special += 1;
        if(NPC[A].Special >= 400)
        {
            if(NPC[A].Slope > 0 || NPC[A].Location.SpeedY == Physics.NPCGravity || NPC[A].Location.SpeedY == 0)
            {
                NPC[A].Location.SpeedY = -5;
                NPC[A].Type = NPCID_CARRY_FODDER;
                NPC[A].Special = 0;
                NPC[A].Location.Y -= 1;
                // deferring tree update to end of the NPC physics update
            }
        }
    }
    else if(NPC[A].Type == NPCID_STONE_S3 || NPC[A].Type == NPCID_STONE_S4) // thwomp
    {
            if(NPC[A].Special == 0)
            {
                NPC[A].Location.SpeedY = 0;
                if(!NPC[A].Wings)
                    NPC[A].Location.Y = NPC[A].DefaultLocationY;
                for(int B = 1; B <= numPlayers; B++)
                {
                    bool playerLower = Player[B].Location.Y >= NPC[A].Location.Y;
                    // When mode 1, simulate older behavior and do always fall
                    playerLower |= (NPC[A].Variant == 1);
                    if(!CanComeOut(NPC[A].Location, Player[B].Location) && playerLower)
                    {
                        NPC[A].Special = 1;
                        break;
                    }
                }
            }
            else if(NPC[A].Special == 1)
            {
                NPC[A].Location.SpeedY = 6;

                if(NPC[A].Wings)
                {
                    // remember current Y coordinate when rising back up
                    NPC[A].SpecialY = NPC[A].Location.Y;
                    NPC[A].Location.SpeedX = 0;
                    NPC[A].Wings = WING_NONE;
                }
            }
            else if(NPC[A].Special == 2)
            {
                if(NPC[A].Special2 == 0 && !NPC[A].Wings)
                {
                    PlaySoundSpatial(SFX_Stone, NPC[A].Location);
                    if(g_config.extra_screen_shake)
                        doShakeScreen(0, 4, SHAKE_SEQUENTIAL, 5, 200, NPC[A].Location);
                    Location_t tempLocation;
                    tempLocation.Width = 32;
                    tempLocation.Height = 32;
                    tempLocation.Y = NPC[A].Location.Y + NPC[A].Location.Height - 16;

//                    tempLocation.X = NPC[A].Location.X;
                    tempLocation.X = (NPC[A].Location.X + NPC[A].Location.Width / 8);
                    NewEffect(EFFID_SMOKE_S3, tempLocation);
                    // in SMBX 1.3, this was 1.5_n and SpeedX was doubled for EFFID_SMOKE_S3.
                    Effect[numEffects].Location.SpeedX = -3;

//                    tempLocation.X += tempLocation.Width - EffectWidth[EFFID_SMOKE_S3];
                    tempLocation.X = (NPC[A].Location.X + NPC[A].Location.Width - EffectWidth[EFFID_SMOKE_S3]) - (NPC[A].Location.Width / 8);
                    NewEffect(EFFID_SMOKE_S3, tempLocation);
                    // in SMBX 1.3, this was 1.5_n and SpeedX was doubled for EFFID_SMOKE_S3.
                    Effect[numEffects].Location.SpeedX = 3;
                }
                NPC[A].Location.SpeedY = 0;
                if(NPC[A].Slope > 0)
                    NPC[A].Location.Y -= 0.1_n;
                NPC[A].Special2 += 1;
                if(NPC[A].Special2 >= 100)
                {
                    NPC[A].Location.Y -= 1;
                    NPC[A].Special = 3;
                    NPC[A].Special2 = 0;
                }
            }
            else if(NPC[A].Special == 3)
            {
                NPC[A].Location.SpeedY = -2;

                num_t target_y = (NPC[A].DefaultWings) ? NPC[A].SpecialY : NPC[A].DefaultLocationY;
                if(NPC[A].Location.Y <= target_y + 1)
                {
                    if(!NPC[A].Wings)
                        NPC[A].Location.Y = target_y;

                    NPC[A].Location.SpeedY = 0;
                    NPC[A].Special = 0;
                    NPC[A].Special2 = 0;
                    NPC[A].Wings = NPC[A].DefaultWings;
                }
            }
        // End If
        // deferring tree update to end of the NPC physics update
    }
    else if(NPC[A].Type == NPCID_GHOST_S3 || NPC[A].Type == NPCID_GHOST_S4 || NPC[A].Type == NPCID_BIG_GHOST) // boo
    {
        if(BattleMode && NPC[A].CantHurt > 0)
            NPC[A].CantHurt = 100;

        if(NPC[A].Projectile)
        {
            if(NPC[A].CantHurtPlayer > 0)
                NPC[A].BattleOwner = NPC[A].CantHurtPlayer;

            NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.95_r;
            NPC[A].Location.SpeedY = NPC[A].Location.SpeedY * 0.95_r;

            if(NPC[A].Location.SpeedX > -2 && NPC[A].Location.SpeedX < 2)
            {
                if(NPC[A].Location.SpeedY > -2 && NPC[A].Location.SpeedY < 2)
                    NPC[A].Projectile = false;
            }
        }

        num_t min_dist = 0;
        int target_plr = 0;
        for(int B = 1; B <= numPlayers; B++)
        {
            if(!Player[B].Dead && Player[B].Section == NPC[A].Section && B != NPC[A].CantHurtPlayer)
            {
                num_t dist = NPCPlayerTargetDist(NPC[A], Player[B]);
                if(min_dist == 0 || dist < min_dist)
                {
                    min_dist = dist;
                    target_plr = B;
                }
            }
        }

        const auto& p = Player[target_plr];

        if(target_plr > 0)
        {
            num_t D = NPC[A].Location.X + NPC[A].Location.Width / 2;
            num_t E = p.Location.X + p.Location.Width / 2;

            // hide
            if((D <= E && p.Direction == -1) || (D >= E && p.Direction == 1) || p.SpinJump)
            {
                // set wings to override to use normal ghost speed logic
                if(NPC[A].Wings)
                    NPC[A].Wings = WING_OVERRIDE;

                NPC[A].Special = 0;

                if(NPC[A].Type == NPCID_GHOST_S3)
                {
                    NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.9_r;
                    NPC[A].Location.SpeedY = NPC[A].Location.SpeedY * 0.9_r;
                }
                else if(NPC[A].Type == NPCID_GHOST_S4)
                {
                    NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.85_r;
                    NPC[A].Location.SpeedY = NPC[A].Location.SpeedY * 0.85_r;
                }
                else if(NPC[A].Type == NPCID_BIG_GHOST)
                {
                    NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.8_r;
                    NPC[A].Location.SpeedY = NPC[A].Location.SpeedY * 0.8_r;
                }

                if(NPC[A].Location.SpeedX < 0.1_n && NPC[A].Location.SpeedX > -0.1_n)
                    NPC[A].Location.SpeedX = 0;

                if(NPC[A].Location.SpeedY < 0.1_n && NPC[A].Location.SpeedY > -0.1_n)
                    NPC[A].Location.SpeedY = 0;
            }
            // chase
            else
            {
                // restore wings to their default value
                NPC[A].Wings = NPC[A].DefaultWings;

                NPC[A].Special = 1;
                NPC[A].Direction = p.Direction;

                num_t F = 0;
                if(NPC[A].Type == NPCID_GHOST_S3)
                    F = 0.03_n;
                else if(NPC[A].Type == NPCID_GHOST_S4)
                    F = 0.025_n;
                else if(NPC[A].Type == NPCID_BIG_GHOST)
                    F = 0.02_n;

                if(D <= E && NPC[A].Location.SpeedX < 1.5_n)
                    NPC[A].Location.SpeedX += F;
                else if(NPC[A].Location.SpeedX > -1.5_n)
                    NPC[A].Location.SpeedX += -F;

                D = NPC[A].Location.Y + NPC[A].Location.Height / 2;
                E = p.Location.Y + p.Location.Height / 2;

                if(D <= E && NPC[A].Location.SpeedY < 1.5_n)
                    NPC[A].Location.SpeedY += F;
                else if(NPC[A].Location.SpeedY > -1.5_n)
                    NPC[A].Location.SpeedY += -F;
            }
        }
        else
        {
            NPC[A].Special = 0;
            NPC[A].Location.SpeedX = 0;
            NPC[A].Location.SpeedY = 0;
        }
    }
    else if(NPC[A].Type == NPCID_STAR_EXIT || NPC[A].Type == NPCID_STAR_COLLECT)
    {
        if(NPC[A].Projectile)
        {
            NPC[A].Location.SpeedX = NPC[A].Location.SpeedX * 0.95_r;
            NPC[A].Location.SpeedY = NPC[A].Location.SpeedY * 0.95_r;
            if(NPC[A].Location.SpeedY < 1 && NPC[A].Location.SpeedY > -1)
            {
                if(NPC[A].Location.SpeedX < 1 && NPC[A].Location.SpeedX > -1)
                    NPC[A].Projectile = false;
            }
        }

        // unified sparkle timer
        NPC[A].Special4 += 1;
        if(NPC[A].Special4 >= ((NPC[A].Special == 0) ? 5 : 10))
        {
            NPC[A].Special4 = 0;
            num_t dx = dRand();
            num_t dy = dRand();
            NewEffect(EFFID_SPARKLE, newLoc(NPC[A].Location.X + dx.times(NPC[A].Location.Width) - 2, NPC[A].Location.Y + dy.times(NPC[A].Location.Height)));
            Effect[numEffects].Location.SpeedX = dRand() - 0.5_n;
            Effect[numEffects].Location.SpeedY = dRand() - 0.5_n;

            if(NPC[A].Special != 0)
                Effect[numEffects].Frame = 1;
        }

        if(NPC[A].Special2 == 0)
        {
            NPC[A].Location.SpeedY -= 0.04_n;
            if(NPC[A].Location.SpeedY <= -1.4_n)
                NPC[A].Special2 = 1;
        }
        else
        {
            NPC[A].Location.SpeedY += 0.04_n;
            if(NPC[A].Location.SpeedY >= 1.4_n)
                NPC[A].Special2 = 0;
        }

        if(NPC[A].Special3 == 0)
        {
            NPC[A].Location.SpeedX -= 0.03_n;
            if(NPC[A].Location.SpeedX <= -0.6_n)
                NPC[A].Special3 = 1;
        }
        else
        {
            NPC[A].Location.SpeedX += 0.03_n;
            if(NPC[A].Location.SpeedX >= 0.6_n)
                NPC[A].Special3 = 0;
        }
    }
    else if(NPC[A].Type == NPCID_SPIT_BOSS) // birdo
    {
        if(NPC[A].Projectile)
            return;

        if(NPC[A].Legacy)
        {
            if(NPC[A].TimeLeft > 1)
                NPC[A].TimeLeft = 100;
            if(bgMusic[NPC[A].Section] != 6 && bgMusic[NPC[A].Section] != 15 && bgMusic[NPC[A].Section] != 21 && NPC[A].TimeLeft > 1)
            {
                bgMusic[NPC[A].Section] = 15;
                StartMusicIfOnscreen(NPC[A].Section);
            }
        }

        // previously Special, changed to Special5 when it became a container
        if(NPC[A].Special5 >= 0)
        {
            NPCFaceNearestPlayer(NPC[A]);

            NPC[A].Special2 += 1;
            if(NPC[A].Special2 == 125)
            {
                NPC[A].Location.Y -= 1;
                NPC[A].Location.SpeedY = -5;
                // previously never shot anything, now it shoots if contents are configured
                if(NPC[A].Inert && !NPC[A].Special)
                    NPC[A].Special2 = 0;
                // deferring tree update to end of the NPC physics update
            }
            else if(NPC[A].Special2 >= 240)
            {
                if(NPC[A].Special2 == 260)
                {
                    numNPCs++;
                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].Direction = NPC[A].Direction;
                    NPC[numNPCs].Type = (NPC[A].Special) ? (NPCID)NPC[A].Special : NPCID_SPIT_BOSS_BALL;

                    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                    NPC[numNPCs].Location.Y = NPC[A].Location.Y + 14 - NPC[numNPCs].Location.Height / 2;

                    if(NPC[numNPCs].Direction == 1)
                        NPC[numNPCs].Location.X = NPC[A].Location.X + NPC[A].Location.Width / 2;
                    else
                        NPC[numNPCs].Location.X = NPC[A].Location.X + NPC[A].Location.Width / 2 - NPC[numNPCs].Location.Width;

                    NPC[numNPCs].TimeLeft = 100;
                    NPC[numNPCs].Section = NPC[A].Section;
                    NPC[numNPCs].Location.SpeedX = 4 * NPC[numNPCs].Direction;

                    if(NPC[A].Special)
                    {
                        s_NPCSpawnCustomThrown(NPC[A], NPC[numNPCs]);

                        if(NPC[numNPCs].Type == NPCID_SLIDE_BLOCK || NPC[numNPCs]->IsAShell)
                            NPC[numNPCs].Location.SpeedX = Physics.NPCShellSpeed * NPC[numNPCs].Direction;
                    }

                    PlaySoundSpatial(SFX_SpitBossSpit, NPC[A].Location);
                    syncLayers_NPC(numNPCs);
                }
                NPC[A].Special5 = 1;
                if(NPC[A].Special2 > 280)
                {
                    NPC[A].Special2 = 0;
                    NPC[A].Special5 = 0;
                }
            }
            if(NPC[A].Special5 == 0 && NPC[A].Location.SpeedY == Physics.NPCGravity)
            {
                NPC[A].Special3 += 1;
                if(NPC[A].Special3 <= 200)
                    NPC[A].Location.SpeedX = -1;
                else if(NPC[A].Special3 > 500)
                    NPC[A].Special3 = 0;
                else if(NPC[A].Special3 > 250 && NPC[A].Special3 <= 450)
                    NPC[A].Location.SpeedX = 1;
                else
                    NPC[A].Location.SpeedX = 0;
            }
            else
                NPC[A].Location.SpeedX = 0;
        }
        else
        {
            NPC[A].Special5 += 1;
            NPC[A].Location.SpeedX = 0;
        }

        if(NPC[A].Stuck)
            NPC[A].Location.SpeedX = 0;
    }
    else if(NPC[A].Type == NPCID_EXT_TURTLE)
    {
        if(NPC[A].Special > 0)
        {
            NPC[A].Special -= 1;
            NPC[A].Location.SpeedX = 0;
        }
    // beach koopa
    }
    else if(NPC[A].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[A].Type <= NPCID_YEL_HIT_TURTLE_S4)
    {
        if(NPC[A].Type == NPCID_BLU_HIT_TURTLE_S4 && NPC[A].Special > 0)
        {
            NPC[A].Special -= 1;
            NPC[A].Location.SpeedX = 0;
        }

        if(NPC[A].Projectile)
        {
            NPC[A].Location.SpeedX *= 0.96_r;
            if(NPC[A].Location.SpeedX > -0.003_n && NPC[A].Location.SpeedX < 0.003_n)
            {
                NPC[A].Projectile = false;
                NPC[A].Location.Y -= Physics.NPCGravity;
                NPC[A].Location.SpeedY = -5;
                NPC[A].Direction = -NPC[A].Direction;
                // deferring tree update to end of the NPC physics update
            }
        }
        else
        {
            if(NPC[A].Type != NPCID_BLU_HIT_TURTLE_S4)
            {
                if(num_t::fEqual_f(NPC[A].Location.SpeedY, Physics.NPCGravity))
                {
                    Location_t tempLocation = NPC[A].Location;
                    tempLocation.Width += 32;
                    tempLocation.X -= 16;

                    for(int B : treeNPCQuery(tempLocation, SORTMODE_NONE))
                    {
                        if(NPC[B].Active && NPC[B].Section == NPC[A].Section && !NPC[B].Hidden && NPC[B].HoldingPlayer == 0)
                        {
                            if(NPC[B].Type >= NPCID_GRN_SHELL_S4 && NPC[B].Type <= NPCID_YEL_SHELL_S4)
                            {
                                if(CheckCollision(tempLocation, NPC[B].Location))
                                {
                                    NPC[A].Location.Y -= Physics.NPCGravity;
                                    NPC[A].Location.SpeedY = -4;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    else if(NPC[A].Type == NPCID_TOOTHY) // killer plant destroys blocks
    {
        for(int B : treeBlockQuery(NPC[A].Location, SORTMODE_COMPAT))
        {
            if(CheckCollision(NPC[A].Location, Block[B].Location))
            {
                BlockHitHard(B);
            }
        }
    }
    // Projectile code
    else if(NPC[A].Type == NPCID_SLIDE_BLOCK)
    {
        if(NPC[A].Special == 1 && NPC[A].Location.SpeedX != 0)
            NPC[A].Projectile = true;
    }
    else if(NPC[A].Type == NPCID_BULLET)
    {
        if(NPC[A].CantHurt > 0)
            NPC[A].Projectile = true;
    }
    // Projectile check, previously set immediately before calling SpecialNPC
    else if(NPC[A].Type == NPCID_PET_FIRE || NPC[A].Type == NPCID_SWORDBEAM || NPC[A].Type == NPCID_TANK_TREADS)
        NPC[A].Projectile = true;
    else if(NPC[A].Type == NPCID_METALBARREL || NPC[A].Type == NPCID_CANNONENEMY || NPC[A].Type == NPCID_HPIPE_SHORT
        || NPC[A].Type == NPCID_HPIPE_LONG || NPC[A].Type == NPCID_VPIPE_SHORT || NPC[A].Type == NPCID_VPIPE_LONG
        || (NPC[A].Type >= NPCID_SHORT_WOOD && NPC[A].Type <= NPCID_SLANT_WOOD_M))
    {
        if(NPC[A].Location.SpeedY > Physics.NPCGravity * 20)
            NPC[A].Projectile = true;
        else
            NPC[A].Projectile = false;
    }
    else if(NPC[A].Type == NPCID_EARTHQUAKE_BLOCK)
    {
        if(NPC[A].Location.SpeedY > 2 || NPC[A].Location.SpeedY < -2)
            NPC[A].Projectile = true;
    }
    // NPCs selected by trait (instead of type)
    else
    {
        if(NPC[A]->IsAShell)
        {
            if(NPC[A].Location.SpeedX != 0)
                NPC[A].Projectile = true;
        }
        // moved from above
        else if(NPC[A]->IsFish)
        {
            if(NPC[A].Special == 1 && !NPC[A].Projectile)
            {
                if(NPC[A].Wet == 2)
                    NPC[A].Special5 = 0;

                int B = NPCTargetPlayer(NPC[A]);
                if(B == 0)
                    B = 1;

                if(!Player[B].WetFrame && Player[B].Location.Y + Player[B].Location.Height < NPC[A].Location.Y)
                {
                    if((NPC[A].Direction == 1 && Player[B].Location.X > NPC[A].Location.X) ||
                       (NPC[A].Direction == -1 && Player[B].Location.X < NPC[A].Location.X))
                    {
                        if(NPC[A].Location.X > Player[B].Location.X - 200 && NPC[A].Location.X + NPC[A].Location.Width < Player[B].Location.X + Player[B].Location.Width + 200)
                        {
                            if(NPC[A].Wet == 2)
                            {
                                if(NPC[A].Location.SpeedY > -3)
                                    NPC[A].Location.SpeedY -= 0.1_n;
                                NPC[A].Special3 = 1;
                            }
                        }
                        else
                            NPC[A].Special3 = 0;
                    }
                    else
                        NPC[A].Special3 = 0;

                    if(NPC[A].Special3 == 1 && NPC[A].Wet == 0)
                    {
                        NPC[A].Location.SpeedY = -(NPC[A].Location.Y - Player[B].Location.Y + Player[B].Location.Height / 2) / 20 + dRand() * 4 - 2;
                        if(NPC[A].Location.SpeedY < -9)
                            NPC[A].Location.SpeedY = -9;
                        NPC[A].Special3 = 0;
                        NPC[A].Special5 = 1;

                        // this allows the fish to go through walls after leaping
                        NPC[A].WallDeath = 10;
                    }
                }
            }
        }
    }
}

void CharStuff(int WhatNPC, bool CheckEggs)
{
    bool SMBX = false;
    bool SMB2 = false;
    bool TLOZ = false;
    int A = 0;
    int NPCStart = 0;
    int NPCStop = 0;
    if(GameMenu)
        return;

    for(A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Character == 1 || Player[A].Character == 2)
            SMBX = true;
        if(Player[A].Character == 3 || Player[A].Character == 4)
            SMB2 = true;
        if(Player[A].Character == 5)
            TLOZ = true;
    }

    if(WhatNPC == 0)
    {
        NPCStart = 1;
        NPCStop = numNPCs;
    }
    else
    {
        NPCStart = WhatNPC;
        NPCStop = WhatNPC;
    }

    if(!SMBX && SMB2 && CheckEggs) // Turn SMBX stuff into SMB2 stuff
    {
        for(A = NPCStart; A <= NPCStop; A++)
        {
            if(NPC[A].Type == NPCID_ITEM_POD && NPC[A].Special > 0 /* && CheckEggs*/) // Check Eggs
            {
                if(NPCIsYoshi((NPCID)NPC[A].Special)) // Yoshi into mushroom (Egg)
                {
                    // NPC(A).Special = 249
                    NPC[A].Special = NPCID_GRN_BOOT; // Yoshi into boot
                }
            }
        }
    }

    if(!SMBX && !SMB2 && TLOZ) // Turn SMBX stuff into Zelda stuff
    {
        for(int A : NPCQueues::Active.no_change)
        {
            if(WhatNPC != 0)
                A = WhatNPC;

            if(NPC[A].Active && !NPC[A].Generator && !NPC[A].Inert)
            {
                if(NPC[A].Type == NPCID_POWER_S3 || NPC[A].Type == NPCID_POWER_S1 || NPC[A].Type == NPCID_POWER_S4 || NPCIsBoot(NPC[A])) // turn mushrooms into hearts
                {
                    NPC[A].Frame = 0;
                    NPC[A].Type = NPCID_POWER_S5;
                    NPC[A].Location.SpeedX = 0;
                    NPC[A].Location.Y += NPC[A].Location.Height - NPC[A]->THeight - 1;
                    NPC[A].Location.X += (NPC[A].Location.Width - NPC[A]->TWidth) / 2;
                    NPC[A].Location.Width = 32;
                    NPC[A].Location.Height = 32;

                    NPCQueues::Unchecked.push_back(A);
                    treeNPCUpdate(A);
                }
                else if(NPC[A].Type == NPCID_COIN_S3 || NPC[A].Type == NPCID_COIN_S4 || NPC[A].Type == NPCID_COIN_S1 || NPC[A].Type == NPCID_COIN_S2 || NPC[A].Type == NPCID_COIN_5) // turn coins into rupees
                {
                    if(NPC[A].Type == NPCID_COIN_5)
                        NPC[A].Type = NPCID_GEM_5;
                    else
                        NPC[A].Type = NPCID_GEM_1;
                    NPC[A].Location.Y += NPC[A].Location.Height - NPC[A]->THeight;
                    NPC[A].Location.X += (NPC[A].Location.Width - NPC[A]->TWidth) / 2;
                    NPC[A].Location.Width = NPC[A]->TWidth;
                    NPC[A].Location.Height = NPC[A]->THeight;
                    NPC[A].Frame = 0;

                    NPCQueues::Unchecked.push_back(A);
                    treeNPCUpdate(A);
                }
            }

            if(WhatNPC != 0)
                break;
        }
    }

    if(!SMBX && !SMB2 && TLOZ && CheckEggs) // Turn SMBX stuff into Zelda stuff
    {
        for(A = NPCStart; A <= NPCStop; A++)
        {
            if(NPC[A].Type == NPCID_ITEM_POD && NPC[A].Special > 0 /* && CheckEggs*/) // Check Eggs
            {
                if(NPCIsYoshi((NPCID)NPC[A].Special) || NPCIsBoot((NPCID)NPC[A].Special)) // Yoshi / boot into mushroom (Egg)
                    NPC[A].Special = NPCID_POWER_S5;
                if(NPC[A].Special == NPCID_POWER_S3 || NPC[A].Special == NPCID_POWER_S1 || NPC[A].Special == NPCID_POWER_S4) // mushrooms into hearts (eggs)
                    NPC[A].Special = NPCID_POWER_S5;
                if(NPC[A].Special == NPCID_COIN_S3 || NPC[A].Special == NPCID_COIN_S4 || NPC[A].Special == NPCID_COIN_S1 || (!SMB2 && NPC[A].Special == NPCID_COIN_S2)) // coins into rupees (eggs)
                    NPC[A].Special = NPCID_GEM_1;
            }
        }
    }
}

NPCID RandomBonus()
{
    int B = iRand(6);

    switch(B)
    {
    default:
    case 0:
        return NPCID_POWER_S3;
    case 1:
        return NPCID_FIRE_POWER_S3;
    case 2:
        return NPCID_LEAF_POWER;
    case 3:
        return NPCID_STATUE_POWER;
    case 4:
        return NPCID_HEAVY_POWER;
    case 5:
        return NPCID_ICE_POWER_S3;
    }
}

bool npcHasFloor(const struct NPC_t &npc)
{
    bool hasFloor = false;

    if(npc.Type < 1 || npc.Type > maxNPCType)
        return false; // invalid NPC type

    if(npc->NoClipping)
        return false; // No collision with blocks

    const auto &l = npc.Location;

    auto checkLoc = l;
    checkLoc.Y = l.Y + l.Height;
    checkLoc.Height = 4;
    checkLoc.Width = l.Width / 2;
    checkLoc.X = l.X + (l.Width / 2) - (checkLoc.Width / 2);

    // Ensure that there is a floor under feet
    for(BlockRef_t sb : treeBlockQuery(checkLoc, SORTMODE_NONE))
    {
        int idx = sb;

        if(npc.tempBlock == idx)
            continue; // Skip collision check to self

        if(BlockNoClipping[sb->Type] || sb->Hidden || sb->Invis || (npc.Projectile && sb->tempBlockNoProjClipping()))
            continue;

        if(CheckCollision(checkLoc, sb->Location))
        {
            hasFloor = true;
            break;
        }
    }

    return hasFloor;
}

bool NPCNewContainerType(int Type)
{
    return Type == NPCID_SPIT_BOSS;
}

bool NPCIsContainer(const NPC_t& npc)
{
    return npc.Type == NPCID_ITEM_BURIED || npc.Type == NPCID_ITEM_POD
        || npc.Type == NPCID_ITEM_BUBBLE || npc.Type == NPCID_ITEM_THROWER
        || (NPCNewContainerType(npc.Type) && npc.Special != 0);
}

void NPCUnbury(int A, int Callsite)
{
    if(NPC[A].Generator)
    {
        NPC[A].Generator = false;
        NPCQueues::update(A);
    }

    NPC[A].Frame = 0;

    if(Callsite != 1)
        NPC[A].Frame = EditorNPCFrame(NPC[A].Type, NPC[A].Direction);

    if(Callsite != 2)
    {
        NPC[A].Type = NPCID(NPC[A].Special);
        NPC[A].Wings = NPC[A].DefaultWings;
    }

    if(Callsite != 1 && Callsite != 2 && NPC[A].Type == NPCID_RANDOM_POWER)
    {
        NPC[A].Type = RandomBonus();
        NPC[A].DefaultSpecial = NPC[A].Type;
    }

    if(Callsite != 1)
        CharStuff(A);

    NPC[A].Special = 0;

    if(NPCIsYoshi(NPC[A]))
    {
        NPC[A].Special = NPC[A].Type;
        NPC[A].Type = NPCID_ITEM_POD;
    }

    if(Callsite != 2 && Callsite != 3 && (NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_TNT))
    {
        // those types were in the below sequence of checks at Callsite 1
    }
    else if(!(NPC[A].Type == NPCID_CANNONENEMY
        || NPC[A].Type == NPCID_CANNONITEM
        || NPC[A].Type == NPCID_SPRING
        || NPC[A].Type == NPCID_KEY
        || NPC[A].Type == NPCID_COIN_SWITCH
        // || NPC[A].Type == NPCID_TIME_SWITCH
        // || NPC[A].Type == NPCID_TNT
        || NPC[A].Type == NPCID_GRN_BOOT
        || NPC[A].Type == NPCID_RED_BOOT
        || NPC[A].Type == NPCID_BLU_BOOT
        || NPC[A].Type == NPCID_TOOTHYPIPE
        || NPCIsAnExit(NPC[A])))
    {
        if(Callsite == 1 || !BattleMode)
            NPC[A].DefaultType = NPCID_NULL;
    }

    NPC[A].Location.Height = NPC[A]->THeight;
    NPC[A].Location.Width = NPC[A]->TWidth;

    if(Callsite != 2 && NPC[A].Type == NPCID_VEGGIE_RANDOM)
    {
        int B = iRand(9);
        NPC[A].Type = NPCID(NPCID_VEGGIE_2 + B);

        if(NPC[A].Type == NPCID_VEGGIE_RANDOM)
            NPC[A].Type = NPCID_VEGGIE_1;

        NPC[A].Location.set_width_center(NPC[A]->TWidth);
        NPC[A].Location.set_height_center(NPC[A]->THeight);
    }
}

static bool s_TypeBansWings(NPCID Type)
{
    const auto& tr = NPCTraits[Type];
    if(tr.IsAVine)
        return true;

    switch(Type)
    {
    // ban plants
    case NPCID_JUMP_PLANT:
    case NPCID_FIRE_PLANT:
    case NPCID_PLANT_S3:
    case NPCID_BIG_PLANT:
    case NPCID_PLANT_S1:
    case NPCID_LONG_PLANT_UP:
    case NPCID_BOTTOM_PLANT:
    case NPCID_LONG_PLANT_DOWN:
    case NPCID_SIDE_PLANT:
    // ban these types which set location to default location
    case NPCID_LAVA_MONSTER:
    case NPCID_LAVABUBBLE:
    case NPCID_CONVEYOR:
    case NPCID_BOSS_CASE:
    case NPCID_BOSS_FRAGILE:
        return true;
    default:
        return false;
    }
}

bool NPCBansWings(const NPC_t& npc)
{
    if(s_TypeBansWings(npc.Type))
        return true;

    if(npc.Type == NPCID_ITEM_BUBBLE || npc.Type == NPCID_ITEM_BURIED)
    {
        if(s_TypeBansWings((NPCID)npc.Special))
            return true;
    }

    return false;
}


================================================
FILE: src/npc.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef NPC_H
#define NPC_H

#include "location.h"
#include "global_constants.h"

enum NPCID : vbint_t;
struct NPC_t;
struct Player_t;

// Returns true if the game has been paused
bool UpdateNPCs();
// Public Sub DropBonus(A As Integer) 'Drops a bonus item that was held by the player
// Drops a bonus item that was held by the player
void DropBonus(int A);

// EXTRA: After adding one new star, hide all over-star BGOs
void CheckAfterStarTake(bool many = false);

// EXTRA: all the logic for collecting a medal NPC
void CollectMedal(const NPC_t& medal);
// Public Sub TouchBonus(A As Integer, B As Integer) 'Code for dealing with bonus and player
// Code for dealing with bonus and player
void TouchBonus(int A, int B);
// Public Sub NPCHit(A As Integer, B As Integer, Optional C As Integer = 0) 'For NPCs that were hit
// For NPCs that were hit
void NPCHit(int A, int B, int C = 0);
// Public Sub KillNPC(A As Integer, B As Integer) 'Handles NPC deaths and death effects
// Handles NPC deaths and death effects
// Returns true if this should be resumed later
bool KillNPC(int A, int B);
// Public Sub CheckSectionNPC(A As Integer) 'find out what section the NPC is in
// find out what section the NPC is in
void CheckSectionNPC(int A);
// Public Sub Deactivate(A As Integer) 'deactive and reset the NPC when it goes offscreen
// deactive and reset the NPC when it goes offscreen
void Deactivate(int A);
// Public Sub Bomb(Location As Location, Game As Integer, Optional ImmunePlayer As Integer = 0) 'for bomb explosions
// for bomb explosions
void Bomb(Location_t Location, int Game, int ImmunePlayer = 0);
// Public Sub DropNPC(A As Integer, NPCType As Integer)  'Drops an NPC from the screen
// Drops an NPC from the screen (dead code, removed)
// void DropNPC(int A, int NPCType);
// Public Sub TurnNPCsIntoCoins() 'turns some NPCs into coins when the player reaches the level exit
// turns some NPCs into coins when the player reaches the level exit
void TurnNPCsIntoCoins();
// Public Sub NPCFrames(A As Integer) 'updates the NPCs graphics
// updates the NPCs graphics
void NPCFrames(int A);
// Public Sub SkullRide(A As Integer)
void SkullRide(int A, bool reEnable = false, const Location_t *alignAt = nullptr);
// Public Sub NPCSpecial(A As Integer)
// called before movement is applied
void NPCSpecial(int A);
// Public Sub SpecialNPC(A As Integer)
// called after movement is applied
void SpecialNPC(int A);
// Public Sub CharStuff(Optional WhatNPC As Integer = 0, Optional CheckEggs As Boolean = False)
void CharStuff(int WhatNPC = 0, bool CheckEggs = false);
// Public Function RandomBonus()
NPCID RandomBonus();

// totally new function, used in the Raft logic
bool npcHasFloor(const struct NPC_t &npc);

// totally new function, used in editor and medals-tracking logic
bool NPCIsContainer(const NPC_t& npc);
bool NPCNewContainerType(int Type);

// NEW: release an NPC from burial -- only made because the call was duplicated in 3 places. If callsite is 0, the logic should be "correct".
void NPCUnbury(int A, int Callsite);

// totally new function, used in editor and level-loading
bool NPCBansWings(const NPC_t& npc);

// totally new function, used for compatibility (in compat mode, horizontal distance; in modern mode, squared Euclidean distance)
num_t NPCPlayerTargetDist(const NPC_t& npc, const Player_t& player);

// totally new function covering old logic. returns nearest player (using NPCPlayerTargetDist) that is not Dead and is in NPC's section.
int NPCTargetPlayer(const NPC_t& npc);

// totally new function covering old logic. checks nearest player (using NPCTargetPlayer) then faces it.
int NPCFaceNearestPlayer(NPC_t& npc, bool old_version = false);

// totally new function covering old logic. sets SpeedY (based on SpeedX) such that the NPC is approaching a target location at a constant X speed.
void NPCSetSpeedTarget_FixedX(NPC_t& npc, const Location_t& target, int speed_x, int speed_y_cap);
void NPCSetSpeedTarget_FixedX(NPC_t& npc, num_t target_x, num_t target_y, int speed_x, int speed_y_cap);

// totally new function covering old logic. sets SpeedY (based on SpeedX) such that the NPC is approaching a target location at a constant speed.
void NPCSetSpeedTarget_FixedSpeed(NPC_t& npc, const Location_t& target, int speed);

#endif // NPC_H


================================================
FILE: src/npc_constant_traits.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef NPC_CONSTANT_TRAITS_H
#define NPC_CONSTANT_TRAITS_H

#include "globals.h"

// force-inline these definitions because they are often used in switch blocks depending only on NPC_t::Type
// inlining allows the compiler to seek arithmetic patterns and to know that it is safe to reorder cases if desired
// force-inlining should be used extremely sparingly but this only causes a 3kb codesize increase across the full application
#if (defined(__GNUC__) || defined(__llvm__))
#    define XT_FORCE_INLINE __attribute__((always_inline))
#else
#    define XT_FORCE_INLINE
#endif

// constant traits that determine NPC behavior based on Type
// will be replaced with other mechanisms during the NPC function pointer update

#if 0
// Should turn into trait.
//'Flags the NPC type if it is a shell
constexpr bool NPCIsAShell(int Type)
{
    return (
        Type == 237 ||
        Type == 113 ||
        Type == 114 ||
        Type == 115 ||
        Type == 116 ||
        Type == 172 ||
        Type == 174 ||
        Type == 195 ||
        Type == 5 ||
        Type == 7 ||
        Type == 24 ||
        Type == 73
    );
}

constexpr bool NPCIsAShell(const NPC_t& n)
{
    return NPCIsAShell(n.Type);
}

// Should turn into trait.
//'Flags the NPC type if it is a bonus
constexpr bool NPCIsABonus(int Type)
{
    return (
        Type == 254 ||
        Type == 251 ||
        Type == 252 ||
        Type == 253 ||
        Type == 250 ||
        Type == 240 ||//32;
        Type == 248 ||//32;
        Type == 249 ||
        Type == 274 ||
        Type == 138 ||
        Type == 152 ||
        Type == 169 ||
        Type == 170 ||
        Type == 197 ||
        Type == 182 || // SMB1 Flower
        Type == 183 || // SMW Flower
        Type == 184 || // SMB1 Mushroom
        Type == 185 || // SMW Mushroom
        Type == 186 || // SMB1 1-up
        Type == 187 || // SMW 1-up
        Type == 188 || // SMW 3 up
        Type == 192 ||
        Type == 178 ||
        Type == 9 ||
        Type == 273 ||
        Type == 10 ||
        Type == 11 ||
        Type == 14 ||
        Type == 264 ||
        Type == 277 ||
        Type == 16 ||
        Type == 33 ||
        Type == 258 ||
        Type == 34 ||
        Type == 41 ||
        Type == 75 ||
        Type == 88 ||
        Type == 90 ||
        Type == 94 ||
        Type == 198 ||
        Type == 97 ||
        Type == 101 ||
        Type == 102 ||
        Type == 103 ||
        Type == 107 ||
        Type == 153 ||
        Type == 196
    );
}

constexpr bool NPCIsABonus(const NPC_t& n)
{
    return NPCIsABonus(n.Type);
}

// Should turn into trait.
//'Flags the NPC type if it is a coin
constexpr bool NPCIsACoin(int Type)
{
    return (
        Type == 251 ||
        Type == 252 ||
        Type == 253 ||
        Type == 274 ||
        Type == 138 ||
        Type == 152 ||
        Type == 10 ||
        Type == 33 ||
        Type == 258 ||
        Type == 88 ||
        Type == 103
    );
}

constexpr bool NPCIsACoin(const NPC_t& n)
{
    return NPCIsACoin(n.Type);
}

// Should turn into trait.
//'Flags the NPC type if it is a vine
constexpr bool NPCIsAVine(int Type)
{
    return (Type >= 213 && Type <= 224);
}

constexpr bool NPCIsAVine(const NPC_t& n)
{
    return NPCIsAVine(n.Type);
}
#endif

// OKAY TO KEEP AS FUNCTION. Usages outside of NPC methods should be replaced with new usage-specific NPC traits.
//'Flags the NPC type if it is a level exit
XT_FORCE_INLINE constexpr bool NPCIsAnExit(NPCID Type)
{
    return (
        Type == NPCID_ITEMGOAL ||
        Type == NPCID_GOALORB_S3 ||
        Type == NPCID_GOALORB_S2 ||
        Type == NPCID_STAR_EXIT ||
        Type == NPCID_STAR_COLLECT ||
        Type == NPCID_FLAG_EXIT
    );
}

XT_FORCE_INLINE constexpr bool NPCIsAnExit(const NPC_t& n)
{
    return NPCIsAnExit(n.Type);
}

// OKAY TO KEEP AS FUNCTION. Usages in UpdatePlayer may become an OnPlayerCollide NPC method.
//'Flags the NPC type as a para-troopa
XT_FORCE_INLINE constexpr bool NPCIsAParaTroopa(NPCID Type)
{
    return (
        Type == NPCID_FLY_FODDER_S3 ||
        Type == NPCID_FLY_FODDER_S5 ||
        Type == NPCID_GRN_FLY_TURTLE_S3 ||
        Type == NPCID_RED_FLY_TURTLE_S3 ||
        Type == NPCID_GRN_FLY_TURTLE_S4 ||
        Type == NPCID_RED_FLY_TURTLE_S4 ||
        Type == NPCID_BLU_FLY_TURTLE_S4 ||
        Type == NPCID_YEL_FLY_TURTLE_S4 ||
        Type == NPCID_GRN_FLY_TURTLE_S1 ||
        Type == NPCID_RED_FLY_TURTLE_S1
    );
}

XT_FORCE_INLINE constexpr bool NPCIsAParaTroopa(const NPC_t& n)
{
    return NPCIsAParaTroopa(n.Type);
}

// OKAY TO KEEP AS FUNCTION. Usages in UpdatePlayer may become an OnPlayerCollide NPC method, usages in Blocks should become a new flag.
//'npc is a kurbo's shoe
XT_FORCE_INLINE constexpr bool NPCIsBoot(NPCID Type)
{
    return (Type == NPCID_GRN_BOOT || Type == NPCID_RED_BOOT || Type == NPCID_BLU_BOOT);
}

XT_FORCE_INLINE constexpr bool NPCIsBoot(const NPC_t& n)
{
    return NPCIsBoot(n.Type);
}

// OKAY TO KEEP AS FUNCTION. Usages in UpdatePlayer may become an OnPlayerCollide NPC method, usages in Blocks should become a new flag.
//'npc is a yoshi
XT_FORCE_INLINE constexpr bool NPCIsYoshi(NPCID Type)
{
    return (
        Type == NPCID_PET_GREEN ||
        Type == NPCID_PET_BLUE ||
        Type == NPCID_PET_YELLOW ||
        Type == NPCID_PET_RED ||
        Type == NPCID_PET_BLACK ||
        Type == NPCID_PET_PURPLE ||
        Type == NPCID_PET_PINK ||
        Type == NPCID_PET_CYAN
    );
}

XT_FORCE_INLINE constexpr bool NPCIsYoshi(const NPC_t& n)
{
    return NPCIsYoshi(n.Type);
}

// OKAY TO KEEP AS FUNCTION. Usages outside of NPC methods should be replaced with new usage-specific NPC traits.
//'npc is a toad
XT_FORCE_INLINE constexpr bool NPCIsToad(NPCID Type)
{
    return (
        Type == NPCID_CIVILIAN_SCARED ||
        Type == NPCID_CIVILIAN ||
        Type == NPCID_CHAR3 ||
        Type == NPCID_CHAR2 ||
        Type == NPCID_CHAR5 ||
        Type == NPCID_PINK_CIVILIAN
    );
}

XT_FORCE_INLINE constexpr bool NPCIsToad(const NPC_t& n)
{
    return NPCIsToad(n.Type);
}

// OKAY TO KEEP AS FUNCTION. Usages outside of NPC methods should be replaced with new usage-specific NPC traits.
//'Zelda 2 Bot monster
XT_FORCE_INLINE constexpr bool NPCIsABot(NPCID Type)
{
    return (Type == NPCID_BLU_SLIME || Type == NPCID_CYAN_SLIME || Type == NPCID_RED_SLIME);
}

XT_FORCE_INLINE constexpr bool NPCIsABot(const NPC_t& n)
{
    return NPCIsABot(n.Type);
}

// OKAY TO KEEP AS FUNCTION. Unused outside of NPC methods.
//'default NPC movement
XT_FORCE_INLINE constexpr bool NPCDefaultMovement(NPCID Type)
{
    return (
        Type == NPCID_FODDER_S5 ||
        Type == NPCID_GRN_TURTLE_S4 ||
        Type == NPCID_RED_TURTLE_S4 ||
        Type == NPCID_BLU_TURTLE_S4 ||
        Type == NPCID_YEL_TURTLE_S4 ||
        Type == NPCID_GRN_HIT_TURTLE_S4 ||
        Type == NPCID_RED_HIT_TURTLE_S4 ||
        Type == NPCID_BLU_HIT_TURTLE_S4 ||
        Type == NPCID_YEL_HIT_TURTLE_S4 ||
        Type == NPCID_KNIGHT ||
        Type == NPCID_BIRD ||
        Type == NPCID_RED_SPIT_GUY ||
        Type == NPCID_BLU_SPIT_GUY ||
        Type == NPCID_GRY_SPIT_GUY ||
        Type == NPCID_WALK_BOMB_S2 ||
        Type == NPCID_WALK_BOMB_S3 ||
        Type == NPCID_SKELETON ||
        Type == NPCID_GRN_TURTLE_S1 ||
        Type == NPCID_RED_TURTLE_S1 ||
        Type == NPCID_BRUTE ||
        Type == NPCID_CARRY_FODDER ||
        Type == NPCID_FLY_CARRY_FODDER ||
        Type == NPCID_ROCKET_WOOD ||
        Type == NPCID_FODDER_S3 ||
        Type == NPCID_RED_FODDER ||
        Type == NPCID_RED_FLY_FODDER ||
        Type == NPCID_GRN_TURTLE_S3 ||
        Type == NPCID_RED_TURTLE_S3 ||
        Type == NPCID_BLU_GUY ||
        Type == NPCID_RED_GUY ||
        Type == NPCID_STACKER ||
        Type == NPCID_GLASS_TURTLE ||
        Type == NPCID_UNDER_FODDER ||
        Type == NPCID_SPIKY_S3 ||
        Type == NPCID_SPIKY_S4 ||
        Type == NPCID_TOOTHY ||
        Type == NPCID_CRAB ||
        Type == NPCID_EXT_TURTLE ||
        Type == NPCID_YELSWITCH_FODDER ||
        Type == NPCID_BLUSWITCH_FODDER ||
        Type == NPCID_GRNSWITCH_FODDER ||
        Type == NPCID_REDSWITCH_FODDER ||
        Type == NPCID_BIG_FODDER ||
        Type == NPCID_BIG_TURTLE ||
        Type == NPCID_JUMPER_S4 ||
        Type == NPCID_TANK_TREADS ||
        Type == NPCID_FODDER_S1 ||
        Type == NPCID_ITEM_BURIED ||
        Type == NPCID_PINK_CIVILIAN ||
        Type == NPCID_CARRY_BUDDY
    );
}

XT_FORCE_INLINE constexpr bool NPCDefaultMovement(const NPC_t& n)
{
    return NPCDefaultMovement(n.Type);
}

// OKAY TO KEEP AS FUNCTION. Usages outside of NPC methods should be replaced with new usage-specific NPC traits.
//'turnips
XT_FORCE_INLINE constexpr bool NPCIsVeggie(NPCID Type)
{
    return Type == NPCID_VEGGIE_1 || (Type >= NPCID_VEGGIE_2 && Type <= NPCID_VEGGIE_RANDOM);
}

XT_FORCE_INLINE constexpr bool NPCIsVeggie(const NPC_t& n)
{
    return NPCIsVeggie(n.Type);
}

// factored out of block hit / UpdateGraphics code
constexpr inline bool NPCLongLife(NPCID Type)
{
    return (NPCIsYoshi(Type) || NPCIsBoot(Type) || Type == NPCID_POWER_S3
        || Type == NPCID_FIRE_POWER_S3 || Type == NPCID_CANNONITEM || Type == NPCID_LIFE_S3
        || Type == NPCID_POISON || Type == NPCID_STATUE_POWER || Type == NPCID_HEAVY_POWER || Type == NPCID_FIRE_POWER_S1
        || Type == NPCID_FIRE_POWER_S4 || Type == NPCID_POWER_S1 || Type == NPCID_POWER_S4
        || Type == NPCID_LIFE_S1 || Type == NPCID_LIFE_S4 || Type == NPCID_3_LIFE || Type == NPCID_FLIPPED_RAINBOW_SHELL
        // || Type == NPCID_PLATFORM_S3 // exclusive to UpdateGraphics
        // TheXTech-exclusive Types with long lives
        || Type == NPCID_INVINCIBILITY_POWER || Type == NPCID_AQUATIC_POWER
        || Type == NPCID_POLAR_POWER || Type == NPCID_CYCLONE_POWER || Type == NPCID_SHELL_POWER);
}

#endif // #ifndef NPC_CONSTANT_TRAITS_H


================================================
FILE: src/npc_effect.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef ENUMNPCEFFECT_HHH
#define ENUMNPCEFFECT_HHH

#include "global_constants.h"

enum NPCEffect : vbint_t
{
    NPCEFF_NORMAL = 0,
    NPCEFF_EMERGE_UP = 1,
    NPCEFF_DROP_ITEM = 2,
    NPCEFF_EMERGE_DOWN = 3,
    NPCEFF_WARP = 4,
    NPCEFF_PET_TONGUE = 5,
    NPCEFF_PET_INSIDE = 6,
    NPCEFF_WAITING = 8,
    NPCEFF_ENCASED = 208,
    NPCEFF_MAZE = 9,
};


#endif // ENUMNPCEFFECT_HHH


================================================
FILE: src/npc_id.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef ENUMNPCID_HHH
#define ENUMNPCID_HHH

#include "global_constants.h"

enum NPCID : vbint_t
{
    NPCID_NULL = 0,

    NPCID_FODDER_S3 = 1,
    NPCID_RED_FODDER = 2,
    NPCID_RED_FLY_FODDER = 3,
    NPCID_GRN_TURTLE_S3 = 4,
    NPCID_GRN_SHELL_S3 = 5,
    NPCID_RED_TURTLE_S3 = 6,
    NPCID_RED_SHELL_S3 = 7,
    NPCID_PLANT_S3 = 8,
    NPCID_POWER_S3 = 9,
    NPCID_COIN_S3 = 10,

    NPCID_ITEMGOAL = 11,
    NPCID_LAVABUBBLE = 12,
    NPCID_PLR_FIREBALL = 13,
    NPCID_FIRE_POWER_S3 = 14,
    NPCID_MINIBOSS = 15,
    NPCID_GOALORB_S3 = 16,
    NPCID_BULLET = 17,
    NPCID_BIG_BULLET = 18,
    NPCID_BLU_GUY = 19,
    NPCID_RED_GUY = 20,

    NPCID_CANNONENEMY = 21,
    NPCID_CANNONITEM = 22,
    NPCID_GLASS_TURTLE = 23,
    NPCID_GLASS_SHELL = 24,
    NPCID_JUMPER_S3 = 25,
    NPCID_SPRING = 26,
    NPCID_UNDER_FODDER = 27,
    NPCID_RED_FISH_S1 = 28,
    NPCID_HEAVY_THROWER = 29,
    NPCID_HEAVY_THROWN = 30,

    NPCID_KEY = 31,
    NPCID_COIN_SWITCH = 32,
    NPCID_COIN_S4 = 33,
    NPCID_LEAF_POWER = 34,
    NPCID_GRN_BOOT = 35,
    NPCID_SPIKY_S3 = 36,
    NPCID_STONE_S3 = 37,
    NPCID_GHOST_S3 = 38,
    NPCID_SPIT_BOSS = 39,
    NPCID_SPIT_BOSS_BALL = 40,

    NPCID_GOALORB_S2 = 41,
    NPCID_GHOST_FAST = 42,
    NPCID_GHOST_S4 = 43,
    NPCID_BIG_GHOST = 44,
    NPCID_SLIDE_BLOCK = 45,
    NPCID_FALL_BLOCK_RED = 46,
    NPCID_SPIKY_THROWER = 47,
    NPCID_SPIKY_BALL_S3 = 48,
    NPCID_TOOTHYPIPE = 49,
    NPCID_TOOTHY = 50,

    NPCID_BOTTOM_PLANT = 51,
    NPCID_SIDE_PLANT = 52,
    NPCID_CRAB = 53,
    NPCID_FLY = 54,
    NPCID_EXT_TURTLE = 55,
    NPCID_VEHICLE = 56,
    NPCID_CONVEYOR = 57,
    NPCID_METALBARREL = 58,

    NPCID_YELSWITCH_FODDER = 59,
    NPCID_YEL_PLATFORM = 60,
    NPCID_BLUSWITCH_FODDER = 61,
    NPCID_BLU_PLATFORM = 62,
    NPCID_GRNSWITCH_FODDER = 63,
    NPCID_GRN_PLATFORM = 64,
    NPCID_REDSWITCH_FODDER = 65,
    NPCID_RED_PLATFORM = 66,

    NPCID_HPIPE_SHORT = 67,
    NPCID_HPIPE_LONG = 68,
    NPCID_VPIPE_SHORT = 69,
    NPCID_VPIPE_LONG = 70,

    NPCID_BIG_FODDER = 71,
    NPCID_BIG_TURTLE = 72,
    NPCID_BIG_SHELL = 73,
    NPCID_BIG_PLANT = 74,
    NPCID_CIVILIAN_SCARED = 75,
    NPCID_GRN_FLY_TURTLE_S3 = 76,
    NPCID_JUMPER_S4 = 77,
    NPCID_TANK_TREADS = 78,
    NPCID_SHORT_WOOD = 79,
    NPCID_LONG_WOOD = 80,

    NPCID_SLANT_WOOD_L = 81,
    NPCID_SLANT_WOOD_R = 82,
    NPCID_SLANT_WOOD_M = 83,
    NPCID_STATUE_S3 = 84,
    NPCID_STATUE_FIRE = 85,
    NPCID_VILLAIN_S3 = 86,
    NPCID_VILLAIN_FIRE = 87,
    NPCID_COIN_S1 = 88,
    NPCID_FODDER_S1 = 89,
    NPCID_LIFE_S3 = 90,

    NPCID_ITEM_BURIED = 91,
    NPCID_VEGGIE_1 = 92,
    NPCID_PLANT_S1 = 93,
    NPCID_CIVILIAN = 94,
    NPCID_PET_GREEN = 95,
    NPCID_ITEM_POD = 96,
    NPCID_STAR_EXIT = 97,
    NPCID_PET_BLUE = 98,
    NPCID_PET_YELLOW = 99,
    NPCID_PET_RED = 100,

    NPCID_CHAR2 = 101,
    NPCID_CHAR5 = 102,
    NPCID_RED_COIN = 103,
    NPCID_PLATFORM_S3 = 104,
    NPCID_CHECKER_PLATFORM = 105,
    NPCID_PLATFORM_S1 = 106,
    NPCID_PINK_CIVILIAN = 107,
    NPCID_PET_FIRE = 108,

    NPCID_GRN_TURTLE_S4 = 109,
    NPCID_RED_TURTLE_S4 = 110,
    NPCID_BLU_TURTLE_S4 = 111,
    NPCID_YEL_TURTLE_S4 = 112,

    NPCID_GRN_SHELL_S4 = 113,
    NPCID_RED_SHELL_S4 = 114,
    NPCID_BLU_SHELL_S4 = 115,
    NPCID_YEL_SHELL_S4 = 116,

    NPCID_GRN_HIT_TURTLE_S4 = 117,
    NPCID_RED_HIT_TURTLE_S4 = 118,
    NPCID_BLU_HIT_TURTLE_S4 = 119,
    NPCID_YEL_HIT_TURTLE_S4 = 120,

    NPCID_GRN_FLY_TURTLE_S4 = 121,
    NPCID_RED_FLY_TURTLE_S4 = 122,
    NPCID_BLU_FLY_TURTLE_S4 = 123,
    NPCID_YEL_FLY_TURTLE_S4 = 124,

    NPCID_KNIGHT = 125,
    NPCID_BLU_SLIME = 126,
    NPCID_CYAN_SLIME = 127,
    NPCID_RED_SLIME = 128,

    NPCID_BIRD = 129,
    NPCID_RED_SPIT_GUY = 130,
    NPCID_BLU_SPIT_GUY = 131,
    NPCID_GRY_SPIT_GUY = 132,

    NPCID_SPIT_GUY_BALL = 133,
    NPCID_BOMB = 134,

    NPCID_WALK_BOMB_S2 = 135,
    NPCID_WALK_BOMB_S3 = 136,
    NPCID_LIT_BOMB_S3 = 137,
    NPCID_COIN_S2 = 138,

    NPCID_VEGGIE_2 = 139,
    NPCID_VEGGIE_3 = 140,
    NPCID_VEGGIE_4 = 141,
    NPCID_VEGGIE_5 = 142,
    NPCID_VEGGIE_6 = 143,
    NPCID_VEGGIE_7 = 144,
    NPCID_VEGGIE_8 = 145,
    NPCID_VEGGIE_9 = 146,
    NPCID_VEGGIE_RANDOM = 147,

    NPCID_PET_BLACK = 148,
    NPCID_PET_PURPLE = 149,
    NPCID_PET_PINK = 150,

    NPCID_SIGN = 151,
    NPCID_RING = 152,
    NPCID_POISON = 153,
    NPCID_CARRY_BLOCK_A = 154,
    NPCID_CARRY_BLOCK_B = 155,
    NPCID_CARRY_BLOCK_C = 156,
    NPCID_CARRY_BLOCK_D = 157,
    NPCID_CARRY_BUDDY = 158,
    NPCID_LIFT_SAND = 159,
    NPCID_ROCKET_WOOD = 160,

    NPCID_RED_FLY_TURTLE_S3 = 161,
    NPCID_BRUTE = 162,
    NPCID_BRUTE_SQUISHED = 163,
    NPCID_BIG_GUY = 164,
    NPCID_CARRY_FODDER = 165,
    NPCID_HIT_CARRY_FODDER = 166,
    NPCID_FLY_CARRY_FODDER = 167,
    NPCID_CHASER = 168,

    NPCID_STATUE_POWER = 169,
    NPCID_HEAVY_POWER = 170,
    NPCID_PLR_HEAVY = 171,

    NPCID_GRN_SHELL_S1 = 172,
    NPCID_GRN_TURTLE_S1 = 173,
    NPCID_RED_SHELL_S1 = 174,
    NPCID_RED_TURTLE_S1 = 175,
    NPCID_GRN_FLY_TURTLE_S1 = 176,
    NPCID_RED_FLY_TURTLE_S1 = 177,

    NPCID_AXE = 178,
    NPCID_SAW = 179,

    NPCID_STONE_S4 = 180,

    NPCID_STATUE_S4 = 181,
    NPCID_FIRE_POWER_S1 = 182,
    NPCID_FIRE_POWER_S4 = 183,
    NPCID_POWER_S1 = 184,
    NPCID_POWER_S4 = 185,
    NPCID_LIFE_S1 = 186,
    NPCID_LIFE_S4 = 187,
    NPCID_3_LIFE = 188,
    NPCID_SKELETON = 189,
    NPCID_RAFT = 190,

    NPCID_RED_BOOT = 191,
    NPCID_CHECKPOINT = 192,
    NPCID_BLU_BOOT = 193,
    NPCID_RAINBOW_SHELL = 194,
    NPCID_FLIPPED_RAINBOW_SHELL = 195,
    NPCID_STAR_COLLECT = 196,
    NPCID_GOALTAPE = 197,
    NPCID_CHAR3 = 198,
    NPCID_LAVA_MONSTER = 199,
    NPCID_VILLAIN_S1 = 200,

    NPCID_SICK_BOSS = 201,
    NPCID_SICK_BOSS_BALL = 202,

    NPCID_FLIER = 203,
    NPCID_ROCKET_FLIER = 204,
    NPCID_WALL_BUG = 205,
    NPCID_WALL_SPARK = 206,
    NPCID_WALL_TURTLE = 207,
    NPCID_BOSS_CASE = 208,
    NPCID_BOSS_FRAGILE = 209,
    NPCID_HOMING_BALL = 210,

    NPCID_HOMING_BALL_GEN = 211,
    NPCID_FALL_BLOCK_BROWN = 212,
    NPCID_GRN_VINE_S3 = 213,
    NPCID_RED_VINE_S3 = 214,
    NPCID_GRN_VINE_S2 = 215,
    NPCID_YEL_VINE_S2 = 216,
    NPCID_BLU_VINE_S2 = 217,
    NPCID_GRN_VINE_BASE_S2 = 218,
    NPCID_YEL_VINE_BASE_S2 = 219,
    NPCID_BLU_VINE_BASE_S2 = 220,

    NPCID_LADDER = 221,
    NPCID_GRN_VINE_S1 = 222,
    NPCID_GRN_VINE_TOP_S1 = 223,
    NPCID_GRN_VINE_S4 = 224,
    NPCID_RED_VINE_TOP_S3 = 225,
    NPCID_GRN_VINE_TOP_S3 = 226,
    NPCID_GRN_VINE_TOP_S4 = 227,
    NPCID_PET_CYAN = 228,
    NPCID_GRN_FISH_S3 = 229,
    NPCID_RED_FISH_S3 = 230,

    NPCID_SQUID_S3 = 231,
    NPCID_GRN_FISH_S4 = 232,
    NPCID_GRN_FISH_S1 = 233,
    NPCID_BONE_FISH = 234,
    NPCID_SQUID_S1 = 235,
    NPCID_YEL_FISH_S4 = 236,
    NPCID_ICE_BLOCK = 237,
    NPCID_TIME_SWITCH = 238,
    NPCID_TNT = 239,
    NPCID_TIMER_S2 = 240,

    NPCID_EARTHQUAKE_BLOCK = 241,
    NPCID_FODDER_S5 = 242,
    NPCID_FLY_FODDER_S5 = 243,
    NPCID_FLY_FODDER_S3 = 244,
    NPCID_FIRE_PLANT = 245,
    NPCID_PLANT_FIREBALL = 246,
    NPCID_STACKER = 247,
    NPCID_TIMER_S3 = 248,
    NPCID_POWER_S2 = 249,
    NPCID_POWER_S5 = 250,

    NPCID_GEM_1 = 251,
    NPCID_GEM_5 = 252,
    NPCID_GEM_20 = 253,
    NPCID_FLY_POWER = 254,
    NPCID_LOCK_DOOR = 255,
    NPCID_LONG_PLANT_UP = 256,
    NPCID_LONG_PLANT_DOWN = 257,
    NPCID_COIN_5 = 258,
    NPCID_FIRE_DISK = 259,
    NPCID_FIRE_CHAIN = 260,

    NPCID_WALK_PLANT = 261,
    NPCID_BOMBER_BOSS = 262,
    NPCID_ICE_CUBE = 263,
    NPCID_ICE_POWER_S3 = 264,
    NPCID_PLR_ICEBALL = 265,
    NPCID_SWORDBEAM = 266,
    NPCID_MAGIC_BOSS = 267,
    NPCID_MAGIC_BOSS_SHELL = 268,
    NPCID_MAGIC_BOSS_BALL = 269,
    NPCID_JUMP_PLANT = 270,

    NPCID_BAT = 271,
    NPCID_VINE_BUG = 272,
    NPCID_SWAP_POWER = 273,
    NPCID_MEDAL = 274,
    NPCID_QUAD_SPITTER = 275,
    NPCID_QUAD_BALL = 276,
    NPCID_ICE_POWER_S4 = 277,
    NPCID_FLY_BLOCK = 278,
    NPCID_FLY_CANNON = 279,

    NPCID_FIRE_BOSS = 280,
    NPCID_FIRE_BOSS_SHELL = 281,
    NPCID_FIRE_BOSS_FIRE = 282,
    NPCID_ITEM_BUBBLE = 283,
    NPCID_ITEM_THROWER = 284,
    NPCID_SPIKY_S4 = 285,
    NPCID_SPIKY_BALL_S4 = 286,
    NPCID_RANDOM_POWER = 287,
    NPCID_DOOR_MAKER = 288,
    NPCID_MAGIC_DOOR = 289,
    NPCID_COCKPIT = 290,

    NPCID_CHAR3_HEAVY = 291,
    NPCID_CHAR4_HEAVY = 292,

    // SMBX 1.3 custom NPC types
    NPCID_RESERVED_293 = 293,
    NPCID_RESERVED_294 = 294,
    NPCID_RESERVED_295 = 295,
    NPCID_RESERVED_296 = 296,
    NPCID_RESERVED_297 = 297,
    NPCID_RESERVED_298 = 298,
    NPCID_RESERVED_299 = 299,
    NPCID_RESERVED_300 = 300,

    // TheXTech-exclusive NPCs
    NPCID_INVINCIBILITY_POWER = 301,
    NPCID_AQUATIC_POWER = 302,
    NPCID_POLAR_POWER = 303,
    NPCID_CYCLONE_POWER = 304,
    NPCID_SHELL_POWER = 305,
    NPCID_FLAG_EXIT = 306,
};


#endif // ENUMNPCID_HHH


================================================
FILE: src/npc_special_data.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

// the purpose of this header is define the configurable
// Variant values for NPCs in the PGE-X standard.

// these are generally used in TheXTech to indicate unique
// modifications to the NPC's behavior / AI.

#pragma once
#ifndef NPC_SPECIAL_DATA_H
#define NPC_SPECIAL_DATA_H

#include <cstddef>
#include "npc_id.h"

// the first value listed is assumed to be the modern default.
// the string array must be nullptr-terminated.
struct NPC_Variant_Data_t
{
    // strings to describe behaviors in the editor
    // may be two lines of up to 7 characters each
    // (a sequence of constant pointers to constant characters)
    // MUST have an extra nullptr at the end
    const char* const * strings;

    // initial Variant values for each behavior
    const uint8_t* values;

    // first version of VB6 game that did NOT use a legacy behavior
    // special values:
    // 66: modern SMBX (forwards compatible, includes any future experiments)
    // 65: SMBX64
    // -1: modern TheXTech
    // -2: X38A default behavior
    // -3: SMBX2 default behavior
    const int* active_below;

    // returns the limit i (with strings[i] == nullptr) if not found
    inline size_t find_current(uint8_t value) const
    {
        size_t i;

        for(i = 0; strings[i] != nullptr; i++)
        {
            if(values[i] == value)
                return i;
        }

        return i;
    }

    // returns the limit i (with strings[i] == nullptr) if not found
    inline size_t find_legacy(int version) const
    {
        size_t earliest_behavior = 0;

        size_t i;

        for(i = 1; strings[i] != nullptr; i++)
        {
            if(version < active_below[i]
                && active_below[i] < active_below[earliest_behavior])
            {
                earliest_behavior = i;
            }
        }

        // return limit i if none of the versions are above the current version
        if(earliest_behavior == 0 && version >= active_below[earliest_behavior])
            return i;

        return earliest_behavior;
    }
};

// when multiple NPC types share the same NPC_Variant, we don't
//   need to reinitialize Variant when switching between them
struct NPC_Variant_Map_t
{
    int Type;
    const NPC_Variant_Data_t* data;
};

// NPCID_CANNONITEM // billy gun
constexpr const char* cannon_strings[] = {"1.2.1+", "1.2.0", "Pre-1.2", nullptr};
constexpr uint8_t cannon_values[] = {0, 1, 2};
constexpr int cannon_active_below[] = {66, 51, 28};
constexpr NPC_Variant_Data_t Variant_cannon = {cannon_strings, cannon_values, cannon_active_below};

// NPCID_STONE_S3
constexpr const char* thwomp_strings[] = {"Modern", "Fall\nAlways", nullptr};
constexpr uint8_t thwomp_values[] = {0, 1};
constexpr int thwomp_active_below[] = {66, 9};
constexpr NPC_Variant_Data_t Variant_thwomp = {thwomp_strings, thwomp_values, thwomp_active_below};

// NPCID_VILLAIN_S3
constexpr const char* bowser3_strings[] = {"Modern", "Section\nExpand", nullptr};
constexpr uint8_t bowser3_values[] = {0, 1};
constexpr int bowser3_active_below[] = {66, 30};
constexpr NPC_Variant_Data_t Variant_bowser3 = {bowser3_strings, bowser3_values, bowser3_active_below};

// NPCID_YEL_PLATFORM, NPCID_BLU_PLATFORM, NPCID_GRN_PLATFORM, NPCID_RED_PLATFORM, NPCID_PLATFORM_S3, NPCID_SAW
constexpr const char* platform_strings[] = {"XTech", "1.3", "Pre-1.2", nullptr};
constexpr uint8_t platform_values[] = {2, 0, 1};
constexpr int platform_active_below[] = {-1, 66, 30};
constexpr NPC_Variant_Data_t Variant_platform = {platform_strings, platform_values, platform_active_below};

constexpr NPC_Variant_Map_t NPC_Variant_map[] =
{
    {NPCID_CANNONITEM, &Variant_cannon},
    {NPCID_STONE_S3, &Variant_thwomp},
    {NPCID_VILLAIN_S3, &Variant_bowser3},
    {NPCID_YEL_PLATFORM, &Variant_platform},
    {NPCID_BLU_PLATFORM, &Variant_platform},
    {NPCID_GRN_PLATFORM, &Variant_platform},
    {NPCID_RED_PLATFORM, &Variant_platform},
    {NPCID_PLATFORM_S3, &Variant_platform},
    {NPCID_SAW, &Variant_platform},
};

constexpr size_t NPC_Variant_count = sizeof(NPC_Variant_map) / sizeof(NPC_Variant_Map_t);

inline const NPC_Variant_Data_t* find_Variant_Data(int Type)
{
    for(size_t i = 0; i < NPC_Variant_count; i++)
    {
        if(NPC_Variant_map[i].Type == Type)
            return NPC_Variant_map[i].data;
    }
    return nullptr;
}

inline uint8_t find_modern_Variant(int Type)
{
    const NPC_Variant_Data_t* data = find_Variant_Data(Type);

    if(!data)
        return 0;

    return data->values[0];
}

inline uint8_t find_legacy_Variant(int Type, int version)
{
    const NPC_Variant_Data_t* data = find_Variant_Data(Type);

    if(!data)
        return 0;

    size_t legacy_index = data->find_legacy(version);

    if(data->strings[legacy_index] == nullptr)
        return 0;

    return data->values[legacy_index];
}

#endif // NPC_SPECIAL_DATA_H


================================================
FILE: src/npc_traits.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef NPC_TRAITS_H
#define NPC_TRAITS_H

#include <cstdint>

#include "range_arr.hpp"

#include "globals.h"
#include "npc_constant_traits.h"

struct NPCTraits_t
{
    //Public NPCFrameOffsetX(0 To maxNPCType) As Integer 'NPC frame offset X
    int16_t FrameOffsetX = 0;
    //Public NPCFrameOffsetY(0 To maxNPCType) As Integer 'NPC frame offset Y
    int16_t FrameOffsetY = 0;
    //Public NPCWidth(0 To maxNPCType) As Integer 'NPC width
    int16_t TWidth = 32;
    //Public NPCHeight(0 To maxNPCType) As Integer 'NPC height
    int16_t THeight = 32;
    //Public NPCWidthGFX(0 To maxNPCType) As Integer 'NPC gfx width
    int16_t WidthGFX = 0;
    //Public NPCHeightGFX(0 To maxNPCType) As Integer 'NPC gfx height
    int16_t HeightGFX = 0;
    //Public NPCSpeedvar(0 To maxNPCType) As Single 'NPC Speed Change
    numf_t Speedvar = 1;

    //Public NPCIsABlock(0 To maxNPCType) As Boolean 'Flag NPC as a block
    bool IsABlock = false;
    //Public NPCIsAHit1Block(0 To maxNPCType) As Boolean 'Flag NPC as a hit1 block
    bool IsAHit1Block = false;
    //Public NPCJumpHurt(0 To maxNPCType) As Boolean 'Hurts the player even if it jumps on the NPC
    bool JumpHurt = false;
    //Public NPCNoClipping(0 To maxNPCType) As Boolean 'NPC can go through blocks
    bool NoClipping = false;
    //Public NPCScore(0 To maxNPCType) As Integer 'NPC score value
    int8_t Score = 2;
    //Public NPCCanWalkOn(0 To maxNPCType) As Boolean  'NPC can be walked on
    bool CanWalkOn = false;
    //Public NPCGrabFromTop(0 To maxNPCType) As Boolean  'NPC can be grabbed from the top
    bool GrabFromTop = false;
    //Public NPCTurnsAtCliffs(0 To maxNPCType) As Boolean  'NPC turns around at cliffs
    bool TurnsAtCliffs = false;
    //Public NPCWontHurt(0 To maxNPCType) As Boolean  'NPC wont hurt the player
    bool WontHurt = false;
    //Public NPCMovesPlayer(0 To maxNPCType) As Boolean 'Player can not walk through the NPC
    bool MovesPlayer = false;
    //Public NPCStandsOnPlayer(0 To maxNPCType) As Boolean 'for the clown car
    bool StandsOnPlayer = false;
    //Public NPCIsGrabbable(0 To maxNPCType) As Boolean 'Player can grab the NPC
    bool IsGrabbable = false;
    //Public NPCNoYoshi(0 To maxNPCType) As Boolean 'Player can't eat the NPC
    bool NoYoshi = false;
    //Public NPCForeground(0 To maxNPCType) As Boolean 'draw the npc in front
    bool Foreground = false;
    //Public NPCNoFireBall(0 To maxNPCType) As Boolean 'not hurt by fireball
    bool NoFireBall = false;
    //Public NPCNoIceBall(0 To maxNPCType) As Boolean 'not hurt by fireball
    bool NoIceBall = false;
    //Public NPCNoGravity(0 To maxNPCType) As Boolean 'not affected by gravity
    bool NoGravity = false;

    //Public NPCFrame(0 To maxNPCType) As Integer
    int16_t TFrames = 0;
    //Public NPCFrameSpeed(0 To maxNPCType) As Integer
    int16_t FrameSpeed = 8;
    //Public NPCFrameStyle(0 To maxNPCType) As Integer
    int16_t FrameStyle = 0;

    // Uses fish AI. Redigit's comment: 'Flags the NPC type as a cheep cheep
    bool IsFish : 1;
    //'Flags the NPC type if it is a coin
    bool IsACoin : 1;
    //'Flags the NPC type if it is a bonus
    bool IsABonus : 1;
    //'Flags the NPC type if it is a vine
    bool IsAVine : 1;
    //'Flags the NPC type if it is a shell
    bool IsAShell : 1;

    //NEW: does the NPC require the canonical activation zone?
    bool UseDefaultCam : 1;

    enum InactiveRender_t
    {
        SHADE = 0,   // shades NPC until it becomes active
        SHOW_ALWAYS, // always show the NPC (including animation)
        SHOW_STATIC, // always show the NPC (without animation)
        SKIP,        // skips NPC's render (assume it handles own intro animation from invisibility)
        SMOKE,       // hides the NPC and reveals it with a EFFID_SMOKE_S3 effect
    };

    //NEW: how should the NPC render when inactive?
    InactiveRender_t InactiveRender : 3;

    constexpr NPCTraits_t() : IsFish(false), IsACoin(false), IsABonus(false), IsAVine(false), IsAShell(false), UseDefaultCam(false), InactiveRender(SHADE) {}
};

extern RangeArr<NPCTraits_t, 0, maxNPCType> NPCTraits;

inline const NPCTraits_t* NPC_t::operator->() const
{
    return &NPCTraits[Type];
}


// some read-only accessors
inline int16_t NPCHeight(int Type)
{
    return NPCTraits[Type].THeight;
}

inline int16_t NPCWidth(int Type)
{
    return NPCTraits[Type].TWidth;
}

inline int16_t NPCHeightGFX(int Type)
{
    return NPCTraits[Type].HeightGFX;
}

inline int16_t NPCWidthGFX(int Type)
{
    return NPCTraits[Type].WidthGFX;
}

inline int16_t NPCFrameOffsetX(int Type)
{
    return NPCTraits[Type].FrameOffsetX;
}

inline int16_t NPCFrameOffsetY(int Type)
{
    return NPCTraits[Type].FrameOffsetY;
}

inline bool NPCNoYoshi(int Type)
{
    return NPCTraits[Type].NoYoshi;
}

inline bool Block_t::tempBlockNoProjClipping() const
{
    if(tempBlockNpcType <= 0)
        return false;

    // cross-ref NPC temp block creation code in UpdateNPCs
    const NPCTraits_t& npc_tr = NPCTraits[tempBlockNpcType];
    return (npc_tr.CanWalkOn && !npc_tr.IsAHit1Block && !npc_tr.IsABlock);
}

inline vbint_t NPC_t::coinSwitchBlockType() const
{
    if(NPCTraits[this->DefaultType].IsACoin)
        return this->Damage;

    return 0;
}

#endif // #ifndef NPC_TRAITS_H


================================================
FILE: src/phys_env.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "collision.h"
#include "blocks.h"
#include "layers.h"
#include "npc_traits.h"

#include "main/trees.h"

#include "phys_env.h"

void PhysEnv_Maze(Location_t& loc, vbint_t& maze_index, uint8_t& maze_state, int npc_A, int plr_A, int speedvar, std::array<bool, 4> controls)
{
    // check if on same page with water
    if(maze_index < 1 || maze_index > numWater || Water[maze_index].Hidden)
    {
        maze_index = 0;
        return;
    }

    Water_t& cur_maze = Water[maze_index];

    num_t layer_speed_x = (num_t)Layer[cur_maze.Layer].ApplySpeedX;
    num_t layer_speed_y = (num_t)Layer[cur_maze.Layer].ApplySpeedY;

    loc.X += layer_speed_x;
    loc.Y += layer_speed_y;
    loc.SpeedX -= layer_speed_x;
    loc.SpeedY -= layer_speed_y;

    int direction = maze_state % 4;
    bool cleared_to_exit = maze_state & MAZE_CAN_EXIT;
    bool do_cancel = false;

    num_t center_x = loc.X + loc.Width / 2;
    num_t center_y = loc.Y + loc.Height / 2;

    num_t target_speed_x = 0;
    num_t target_speed_y = 0;

    num_t space_left = 0;
    num_t space_to_leave = 0;
    num_t space_to_cancel = 0;

    num_t exit_check_x, exit_check_y;

    // direction logic
    if(direction == MAZE_DIR_UP || direction == MAZE_DIR_DOWN)
    {
        if(direction == MAZE_DIR_UP)
        {
            exit_check_y = cur_maze.Location.Y;
            space_left = center_y - exit_check_y;
            target_speed_y = -4;
        }
        else
        {
            exit_check_y = cur_maze.Location.Y + cur_maze.Location.Height;
            space_left = exit_check_y - center_y;
            target_speed_y = 4;
        }

        space_to_cancel = cur_maze.Location.Height;
        space_to_leave = loc.Height / 2;

        num_t maze_center_x = cur_maze.Location.X + cur_maze.Location.Width / 2;
        exit_check_x = maze_center_x;
        target_speed_x = (maze_center_x - center_x) / 8;

        if(num_t::abs(target_speed_x) > 8_n)
        {
            do_cancel = true;
            target_speed_x = 0;
        }
        else if(num_t::abs(target_speed_x) < 0.25_n)
        {
            loc.X = maze_center_x - loc.Width / 2;
            loc.SpeedX = 0;
            target_speed_x = 0;
        }
    }
    else
    {
        if(direction == MAZE_DIR_LEFT)
        {
            exit_check_x = cur_maze.Location.X;
            space_left = center_x - exit_check_x;
            target_speed_x = -4;
        }
        else
        {
            exit_check_x = cur_maze.Location.X + cur_maze.Location.Width;
            space_left = exit_check_x - center_x;
            target_speed_x = 4;
        }

        space_to_cancel = cur_maze.Location.Width;
        space_to_leave = loc.Width / 2;

        num_t maze_center_y = cur_maze.Location.Y + cur_maze.Location.Height / 2;
        exit_check_y = maze_center_y;

        if(plr_A && Player[plr_A].Mount == 3)
            maze_center_y += 8;

        target_speed_y = (maze_center_y - center_y) / 8;

        if(num_t::abs(target_speed_y) > 8_n)
        {
            do_cancel = true;
            target_speed_y = 0;
        }
        else if(num_t::abs(target_speed_y) < 0.25_n)
        {
            loc.Y = maze_center_y - loc.Height / 2;
            loc.SpeedY = 0;
            target_speed_y = 0;
        }
    }

    if(space_left > space_to_cancel + 128 || space_left < -128 || do_cancel)
    {
        do_cancel = true;
        exit_check_x = center_x;
        exit_check_y = center_y;
    }

    if(cleared_to_exit && !do_cancel)
    {
        if(space_left < -space_to_leave)
        {
            maze_index = 0;
            return;
        }

        if(direction == MAZE_DIR_UP)
            target_speed_y *= 2;
    }
    else if(space_left < 32 || do_cancel)
    {
        // need to find a new direction
        Location_t edgeLoc;
        edgeLoc.X = exit_check_x - 15 + target_speed_x * 4;
        edgeLoc.Y = exit_check_y - 15 + target_speed_y * 4;
        edgeLoc.Width = 30;
        edgeLoc.Height = 30;

        cleared_to_exit = true;

        for(int B : treeBlockQuery(edgeLoc, SORTMODE_NONE))
        {
            const Block_t& b = Block[B];

            if((!npc_A || b.tempBlockNpcIdx != npc_A) && (!plr_A || !BlockCheckPlayerFilter(B, plr_A)) && !b.Hidden && !b.Invis && !BlockOnlyHitspot1[b.Type] && !BlockIsSizable[b.Type] && !BlockNoClipping[b.Type])
            {
                if(CheckCollision(edgeLoc, b.Location))
                {
                    cleared_to_exit = false;
                    break;
                }
            }
        }

        if(!npc_A && cleared_to_exit)
        {
            for(int N : treeNPCQuery(edgeLoc, SORTMODE_NONE))
            {
                const NPC_t& n = NPC[N];

                if(n.Active && !n.Generator && n->IsABlock && (!plr_A || N != Player[plr_A].HoldingNPC))
                {
                    if(CheckCollision(edgeLoc, n.Location))
                    {
                        cleared_to_exit = false;
                        break;
                    }
                }
            }
        }

        if(cleared_to_exit && !do_cancel)
            maze_state |= MAZE_CAN_EXIT;
        else
        {
            int new_maze[4] = {0, 0, 0, 0};

            edgeLoc.X = exit_check_x - 15;
            edgeLoc.Y = exit_check_y - 15;

            for(int W : treeWaterQuery(edgeLoc, SORTMODE_NONE))
            {
                const Water_t& w = Water[W];

                if(!w.Hidden && w.Type == PHYSID_MAZE)
                {
                    if(CheckCollision(edgeLoc, w.Location))
                    {
                        if(w.Location.Height > w.Location.Width)
                        {
                            if(w.Location.Y <= exit_check_y - 32 && new_maze[MAZE_DIR_UP] < W)
                                new_maze[MAZE_DIR_UP] = W;
                            if(w.Location.Y + w.Location.Height >= exit_check_y + 32 && new_maze[MAZE_DIR_DOWN] < W)
                                new_maze[MAZE_DIR_DOWN] = W;
                        }
                        else
                        {
                            if(w.Location.X <= exit_check_x - 32 && new_maze[MAZE_DIR_LEFT] < W)
                                new_maze[MAZE_DIR_LEFT] = W;
                            if(w.Location.X + w.Location.Width >= exit_check_x + 32 && new_maze[MAZE_DIR_RIGHT] < W)
                                new_maze[MAZE_DIR_RIGHT] = W;
                        }
                    }
                }
            }

            // if things are normal, return to the same maze segment if the other directions are blocked
            if(!do_cancel)
                new_maze[direction ^ MAZE_DIR_FLIP_BIT] = maze_index;

            bool random_choice = iRand(2);
            bool choice_by_control = false;

            // don't allow player to choose to go backwards
            controls[direction ^ MAZE_DIR_FLIP_BIT] = false;

            for(int i = 0; i < 4; i++)
            {
                if(controls[i] && new_maze[i])
                {
                    maze_state = i;
                    choice_by_control = true;
                    break;
                }
            }

            if(choice_by_control)
            {
                // already have a new state
            }
            else if(new_maze[direction])
                maze_state = direction;
            else if(direction == MAZE_DIR_UP || direction == MAZE_DIR_DOWN)
            {
                if(new_maze[MAZE_DIR_LEFT] && new_maze[MAZE_DIR_RIGHT])
                    maze_state = (random_choice) ? MAZE_DIR_LEFT : MAZE_DIR_RIGHT;
                else if(new_maze[MAZE_DIR_LEFT])
                    maze_state = MAZE_DIR_LEFT;
                else if(new_maze[MAZE_DIR_RIGHT])
                    maze_state = MAZE_DIR_RIGHT;
                else
                    maze_state = (direction ^ MAZE_DIR_FLIP_BIT);
            }
            else
            {
                if(new_maze[MAZE_DIR_UP] && new_maze[MAZE_DIR_DOWN])
                    maze_state = (random_choice) ? MAZE_DIR_UP : MAZE_DIR_DOWN;
                else if(new_maze[MAZE_DIR_UP])
                    maze_state = MAZE_DIR_UP;
                else if(new_maze[MAZE_DIR_DOWN])
                    maze_state = MAZE_DIR_DOWN;
                else
                    maze_state = (direction ^ MAZE_DIR_FLIP_BIT);
            }

            maze_index = new_maze[maze_state];
        }
    }

    target_speed_x *= speedvar;
    target_speed_y *= speedvar;
    target_speed_x /= 4;
    target_speed_y /= 4;

    loc.SpeedX = loc.SpeedX / 2 + target_speed_x / 2;
    loc.SpeedY = loc.SpeedY / 2 + target_speed_y / 2;

    loc.X += loc.SpeedX;
    loc.Y += loc.SpeedY;

    loc.SpeedX += (num_t)Layer[cur_maze.Layer].SpeedX;
    loc.SpeedY += (num_t)Layer[cur_maze.Layer].SpeedY;
}

void PhysEnv_Maze_PickDirection(const Location_t& loc, vbint_t maze_index, uint8_t& maze_state)
{
    if(Water[maze_index].Location.Width > Water[maze_index].Location.Height)
    {
        num_t dx = Water[maze_index].Location.X - loc.X + (Water[maze_index].Location.Width - loc.Width) / 2;
        if(dx > 0)
            maze_state = MAZE_DIR_RIGHT;
        else
            maze_state = MAZE_DIR_LEFT;
    }
    else
    {
        num_t dy = Water[maze_index].Location.Y - loc.Y + (Water[maze_index].Location.Height - loc.Height) / 2;
        if(dy > 0)
            maze_state = MAZE_DIR_DOWN;
        else
            maze_state = MAZE_DIR_UP;
    }
}


================================================
FILE: src/phys_env.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef PHYS_ENV_H
#define PHYS_ENV_H

#include <array>

#include "globals.h"

enum PhysEnv_Maze_Status
{
    MAZE_DIR_LEFT = 0,
    MAZE_DIR_UP = 1,
    MAZE_DIR_RIGHT = 2,
    MAZE_DIR_DOWN = 3,
    MAZE_CAN_EXIT = 4,
    MAZE_PLAYER_FLIP = 128,
    MAZE_DIR_FLIP_BIT = 2,
};

// applies maze physics to a location. modifies maze_index and effect_data as needed.
// indicates leaving the env by setting maze_index to 0.
void PhysEnv_Maze(Location_t& loc, vbint_t& maze_index, uint8_t& maze_state, int npc_A, int plr_A, int speedvar, std::array<bool, 4> controls);

// picks direction for a possible maze entry
void PhysEnv_Maze_PickDirection(const Location_t& loc, vbint_t maze_index, uint8_t& maze_state);

#endif // #ifndef PHYS_ENV_H


================================================
FILE: src/phys_id.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef ENUM_PHYSID_HHH
#define ENUM_PHYSID_HHH

#include "global_constants.h"

enum PHYSID : vbint_t
{
    PHYSID_WATER = 0,
    PHYSID_QUICKSAND = 1,
    PHYSID_MAZE = 17,
};

#endif // #ifndef ENUM_PHYSID_HHH


================================================
FILE: src/pinched_info.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef PINCHED_INFO_H
#define PINCHED_INFO_H

#include <stdint.h>

// structure used to store information about whether a player / NPC is being crushed by blocks
struct PinchedInfo_t
{
    uint16_t Bottom1   : 2;
    uint16_t Left2     : 2;
    uint16_t Top3      : 2;
    uint16_t Right4    : 2;
    uint16_t Moving    : 2;
    bool     MovingLR  : 1;
    bool     MovingUD  : 1;

    // players only: frame counter to use classic (strict) pinched death condition
    uint16_t Strict    : 4;

    inline PinchedInfo_t()
    {
        reset_non_strict();
        Strict = 0;
    }

    inline void reset_non_strict()
    {
        Bottom1 = 0;
        Left2 = 0;
        Top3 = 0;
        Right4 = 0;
        Moving = 0;
        MovingLR = false;
        MovingUD = false;
    }
};

#endif // #ifndef PINCHED_INFO_H


================================================
FILE: src/player/player_action_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "player/player_update_priv.h"
#include "config.h"
#include "layers.h"
#include "npc.h"
#include "npc_traits.h"
#include "phys_env.h"
#include "npc/npc_queues.h"

void PlayerThrowItemMaze(const Player_t& p, Location_t& loc, uint8_t& maze_status)
{
    loc.SpeedX = 0;
    loc.SpeedY = 0;

    int direction = p.MazeZoneStatus % 4;

    if(direction == MAZE_DIR_UP || direction == MAZE_DIR_DOWN)
        loc.X = p.Location.X + (p.Location.Width - loc.Width) / 2;
    else
        loc.Y = p.Location.Y + (p.Location.Height - loc.Height) / 2;

    if((direction == MAZE_DIR_UP && !p.Controls.Down) || (direction == MAZE_DIR_DOWN && p.Controls.Up))
    {
        maze_status = MAZE_DIR_UP;
        loc.SpeedY = -6;
        loc.Y = p.Location.Y - loc.Height - 24;
    }
    else if(direction == MAZE_DIR_UP || direction == MAZE_DIR_DOWN)
    {
        maze_status = MAZE_DIR_DOWN;
        loc.SpeedY = 6;
        loc.Y = p.Location.Y + p.Location.Height + 24;
    }
    else if(p.Direction <= 0)
    {
        maze_status = MAZE_DIR_LEFT;
        loc.SpeedX = -6;
        loc.X = p.Location.X - loc.Width - 24;
    }
    else
    {
        maze_status = MAZE_DIR_RIGHT;
        loc.SpeedX = 6;
        loc.X = p.Location.X + p.Location.Width + 24;
    }
}

void PlayerThrownNpcMazeCheck(const Player_t& p, NPC_t& npc)
{
    if(!p.CurMazeZone)
        return;

    if(npc->NoClipping && npc.Type != NPCID_BULLET)
        return;

    npc.Effect = NPCEFF_MAZE;
    npc.Effect2 = p.CurMazeZone;
    PlayerThrowItemMaze(p, npc.Location, npc.Effect3);
}

void PlayerPoundLogic(int A)
{
    if(Player[A].Location.SpeedY != 0 && Player[A].StandingOnNPC == 0 && Player[A].Slope == 0)
    {
        if(Player[A].Mount == 3 && Player[A].MountType == 6) // Purple Yoshi Pound
        {
            bool groundPoundByAltRun = !ForcedControls && g_config.pound_by_alt_run;
            bool poundKeyPressed = groundPoundByAltRun ? Player[A].Controls.AltRun : Player[A].Controls.Down;
            bool poundKeyRelease = groundPoundByAltRun ? Player[A].AltRunRelease   : Player[A].DuckRelease;

            if(poundKeyPressed && poundKeyRelease && Player[A].CanPound)
            {
                Player[A].GroundPound = true;
                Player[A].GroundPound2 = true;
                if(Player[A].Location.SpeedY < 0)
                    Player[A].Location.SpeedY = 0;
            }
        }
    }
    else
        Player[A].CanPound = false;

    if(Player[A].GroundPound)
    {
        if(!Player[A].CanPound && Player[A].Location.SpeedY < 0)
            Player[A].GroundPound = false;

        bool groundPoundByAltRun = !ForcedControls && g_config.pound_by_alt_run;
        if(groundPoundByAltRun)
            Player[A].Controls.AltRun = true;
        else
            Player[A].Controls.Down = true;

        Player[A].CanJump = false;
        Player[A].Controls.Left = false;
        Player[A].Controls.Up = false;
        Player[A].Controls.Right = false;
        Player[A].Controls.Jump = true;
        Player[A].Location.SpeedX = Player[A].Location.SpeedX * 0.95_r;
        Player[A].RunRelease = false;
        Player[A].CanFly = false;
        Player[A].FlyCount = 0;
        Player[A].CanFly2 = false;
        Player[A].Location.SpeedY += 1;
        Player[A].CanPound = false;
        Player[A].Jump = 0;
    }
    else
    {
        // allow pounding again
        if(Player[A].Location.SpeedY < -5 && ((Player[A].Jump < 15 && Player[A].Jump != 0) || Player[A].CanFly))
            Player[A].CanPound = true;

        // rebound from hitting the ground
        if(Player[A].GroundPound2)
        {
            Player[A].Location.SpeedY = -4;
            Player[A].StandingOnNPC = 0;
            Player[A].GroundPound2 = false;
        }
    }
}

void PlayerShootChar5Beam(int A)
{
    // TODO: State-dependent moment

    Player[A].FireBallCD2 = 40;
    if(Player[A].State == 6)
        Player[A].FireBallCD2 = 25;

    if(Player[A].State == 6)
        PlaySoundSpatial(SFX_HeroSwordBeam, Player[A].Location);
    else if(Player[A].State == 7 || Player[A].State == PLR_STATE_POLAR)
        PlaySoundSpatial(SFX_HeroIce, Player[A].Location);
    else
        PlaySoundSpatial(SFX_HeroFireRod, Player[A].Location);

    numNPCs++;

    if(ShadowMode)
        NPC[numNPCs].Shadow = true;

    NPC[numNPCs].Type = NPCID_PLR_FIREBALL;

    if(Player[A].State == 7 || Player[A].State == PLR_STATE_POLAR)
        NPC[numNPCs].Type = NPCID_PLR_ICEBALL;

    if(Player[A].State == 6)
        NPC[numNPCs].Type = NPCID_SWORDBEAM;

    NPC[numNPCs].Projectile = true;
    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
    NPC[numNPCs].Location.X = Player[A].Location.X + Player[A].Location.Width / 2 + (40 * Player[A].Direction) - 8;

    if(!Player[A].Duck)
    {
        NPC[numNPCs].Location.Y = Player[A].Location.Y + 5;
        if(Player[A].State == 6)
            NPC[numNPCs].Location.Y += 7;
    }
    else
    {
        NPC[numNPCs].Location.Y = Player[A].Location.Y + 18;
        if(Player[A].State == 6)
            NPC[numNPCs].Location.Y += 4;
    }


    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = 100;
    NPC[numNPCs].Location.SpeedY = 20;
    NPC[numNPCs].CantHurt = 100;
    NPC[numNPCs].CantHurtPlayer = A;
    NPC[numNPCs].Special = Player[A].Character;
    NPC[numNPCs].Variant = Player[A].Character; // NEW: to fix a bug where ice balls did not respect char blocks

    if(NPC[numNPCs].Type == NPCID_PLR_FIREBALL)
        NPC[numNPCs].Frame = 16;

    // kill item if it is inside a wall next frame
    NPC[numNPCs].WallDeath = 5;
    NPC[numNPCs].Location.SpeedY = 0;
    NPC[numNPCs].Location.SpeedX = 5 * Player[A].Direction + (Player[A].Location.SpeedX / 3);

    if(Player[A].State == 6)
        NPC[numNPCs].Location.SpeedX = 9 * Player[A].Direction + (Player[A].Location.SpeedX / 3);

    if(Player[A].StandingOnNPC != 0)
        NPC[numNPCs].Location.Y += -Player[A].Location.SpeedY;

    if(Player[A].State != 6)
        PlayerThrownNpcMazeCheck(Player[A], NPC[numNPCs]);

    syncLayers_NPC(numNPCs);
    CheckSectionNPC(numNPCs);
}

void PlayerThrowBomb(int A)
{
    Player_t& p = Player[A];

    p.Bombs -= 1;

    numNPCs++;
    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = Physics.NPCTimeOffScreen;
    NPC[numNPCs].Section = p.Section;
    NPC[numNPCs].Type = NPCID_BOMB;
    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
    NPC[numNPCs].CantHurtPlayer = A;
    NPC[numNPCs].CantHurt = 1000;

    if(p.Duck && (p.Location.SpeedY == 0 || p.Slope > 0 || p.StandingOnNPC != 0))
    {
        NPC[numNPCs].Location.X = p.Location.X + (p.Location.Width - NPC[numNPCs].Location.Width) / 2;
        NPC[numNPCs].Location.Y = p.Location.Y + p.Location.Height - NPC[numNPCs].Location.Height;
        NPC[numNPCs].Location.SpeedX = 0;
        NPC[numNPCs].Location.SpeedY = 0;
        PlaySoundSpatial(SFX_Grab, p.Location);
    }
    else
    {
        NPC[numNPCs].Location.X = p.Location.X + (p.Location.Width - NPC[numNPCs].Location.Width) / 2;
        NPC[numNPCs].Location.Y = p.Location.Y;
        NPC[numNPCs].Location.SpeedX = 5 * p.Direction;
        NPC[numNPCs].Location.SpeedY = -6;
        NPC[numNPCs].Projectile = true;

        if(p.Location.SpeedY == 0 || p.Slope > 0 || p.StandingOnNPC != 0)
            p.SwordPoke = -10;

        PlaySoundSpatial(SFX_Throw, p.Location);
    }

    PlayerThrownNpcMazeCheck(Player[A], NPC[numNPCs]);

    syncLayers_NPC(numNPCs);
}

bool PlayerChar4HeavyOut(const int A)
{
    if(Player[A].Character != 4)
        return false;

    for(int B : NPCQueues::Active.no_change)
    {
        if(NPC[B].Active)
        {
            if(NPC[B].Type == NPCID_CHAR4_HEAVY)
            {
                if(NPC[B].Special5 == A)
                    return true;
            }
        }
    }

    return false;
}

void PlayerThrowHeavy(const int A)
{
    auto &p = Player[A];

    if(p.RunRelease && PlayerChar4HeavyOut(A))
        return;

    if(numNPCs >= maxNPCs - 100)
        return;

    p.FrameCount = 110;
    p.FireBallCD = 25;

    numNPCs++;
    NPC[numNPCs].Type = NPCID_PLR_HEAVY;
    if(ShadowMode)
        NPC[numNPCs].Shadow = true;

    if(p.Character == 3)
    {
        p.FireBallCD = 45;
        NPC[numNPCs].Type = NPCID_CHAR3_HEAVY;

        if(p.Controls.AltRun && p.Mount == 0)
        {
            NPC[numNPCs].HoldingPlayer = A;
            p.HoldingNPC = numNPCs;
            PlaySoundSpatial(SFX_Grab2, p.Location);
        }
        else
            PlaySoundSpatial(SFX_Throw, p.Location);
    }
    else if(p.Character == 4)
    {

        p.FireBallCD = 0;
        if(FlameThrower)
            p.FireBallCD = 40;
        NPC[numNPCs].Type = NPCID_CHAR4_HEAVY;
        NPC[numNPCs].Special5 = A;
        NPC[numNPCs].Special4 = p.Direction; // Special6 in SMBX 1.3
        PlaySoundSpatial(SFX_Throw, p.Location);
    }
    else
        PlaySoundSpatial(playerHammerSFX, p.Location);

    NPC[numNPCs].Projectile = true;
    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
    NPC[numNPCs].Location.X = p.Location.X + Physics.PlayerGrabSpotX[p.Character][p.State] * p.Direction;
    NPC[numNPCs].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State];
    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = 100;
    NPC[numNPCs].Location.SpeedY = 20;
    NPC[numNPCs].CantHurt = 100;
    NPC[numNPCs].CantHurtPlayer = A;

    if(p.Controls.Up)
    {
        NPC[numNPCs].Location.SpeedX = 2 * p.Direction + p.Location.SpeedX * 0.9_r;

        if(p.StandingOnNPC == 0)
            NPC[numNPCs].Location.SpeedY = -8 + p.Location.SpeedY * 0.3_r;
        else
            NPC[numNPCs].Location.SpeedY = -8 + NPC[p.StandingOnNPC].Location.SpeedY * 0.3_r;

        NPC[numNPCs].Location.Y -= 24;
        NPC[numNPCs].Location.X += -6 * p.Direction;

        if(p.Character == 3)
        {
            NPC[numNPCs].Location.SpeedY += 1;
            NPC[numNPCs].Location.SpeedX = NPC[numNPCs].Location.SpeedX * 1.5_rb;
        }
        else if(p.Character == 4)
        {
            NPC[numNPCs].Location.SpeedY = -8;
            NPC[numNPCs].Location.SpeedX = 12 * p.Direction + p.Location.SpeedX;
        }
    }
    else
    {
        NPC[numNPCs].Location.SpeedX = 4 * p.Direction + p.Location.SpeedX * 0.9_r;

        if(p.StandingOnNPC == 0)
            NPC[numNPCs].Location.SpeedY = -5 + p.Location.SpeedY * 0.3_r;
        else
            NPC[numNPCs].Location.SpeedY = -5 + NPC[p.StandingOnNPC].Location.SpeedY * 0.3_r;

        if(p.Character == 3)
            NPC[numNPCs].Location.SpeedY += 1;
        else if(p.Character == 4)
        {
            NPC[numNPCs].Location.SpeedY = -5;
            NPC[numNPCs].Location.SpeedX = 10 * p.Direction + p.Location.SpeedX;
            NPC[numNPCs].Location.Y -= 12;
        }
    }

    if(p.Character == 4)
        NPC[numNPCs].Location.X = p.Location.X + (p.Location.Width - NPC[numNPCs].Location.Width) / 2;

    PlayerThrownNpcMazeCheck(p, NPC[numNPCs]);

    syncLayers_NPC(numNPCs);
    CheckSectionNPC(numNPCs);
}

void PlayerThrowBall(const int A)
{
    // TODO: State-dependent moment
    Player_t& p = Player[A];

    if(p.SpinJump)
        p.SpinFireDir = p.Direction;

    if(numNPCs >= maxNPCs - 100)
        return;

    numNPCs++;
    NPC[numNPCs].Type = NPCID_PLR_FIREBALL;

    bool throw_ice = (p.State == PLR_STATE_ICE || p.State == PLR_STATE_POLAR);

    if(throw_ice)
        NPC[numNPCs].Type = NPCID_PLR_ICEBALL;

    if(ShadowMode)
        NPC[numNPCs].Shadow = true;

    NPC[numNPCs].Projectile = true;
    NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
    NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
    NPC[numNPCs].Location.X = p.Location.X + Physics.PlayerGrabSpotX[p.Character][p.State] * p.Direction + 4;
    NPC[numNPCs].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State];
    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = 100;
    NPC[numNPCs].CantHurt = 100;
    NPC[numNPCs].CantHurtPlayer = A;
    NPC[numNPCs].Special = p.Character;
    NPC[numNPCs].Variant = p.Character; // NEW: to fix a bug where ice balls did not respect char blocks

    if((p.Character == 3 || p.Character == 4) && p.Mount == 0 && p.Controls.AltRun) // peach holds fireballs
    {
        p.HoldingNPC = numNPCs;
        NPC[numNPCs].HoldingPlayer = A;
    }

    p.FireBallCD = 30;
    if(p.Character == 2)
        p.FireBallCD = 35;
    if(p.Character == 3)
        p.FireBallCD = 40;
    if(p.Character == 4)
        p.FireBallCD = 25;

    if(p.State == PLR_STATE_POLAR && p.Slippy)
        p.FireBallCD -= 5;

    bool throw_up = p.Controls.Up;
    int throw_dir = p.Direction;

    NPC[numNPCs].Location.SpeedX = 5 * throw_dir + (p.Location.SpeedX) / 3.5_ri;

    if(throw_ice)
    {
        NPC[numNPCs].Special = 1;

        PlaySoundSpatial(SFX_Iceball, p.Location);

        NPC[numNPCs].Location.SpeedY = (throw_up) ? -8 : 5;
        NPC[numNPCs].Location.SpeedX = NPC[numNPCs].Location.SpeedX * 0.8_r;
    }
    else
    {
        PlaySoundSpatial(SFX_Fireball, p.Location);

        NPC[numNPCs].Location.SpeedY = (throw_up) ? -6 : 20;

        if(NPC[numNPCs].Special == 2)
            NPC[numNPCs].Location.SpeedX = NPC[numNPCs].Location.SpeedX * 0.85_r;

        if(NPC[numNPCs].Special == 2)
            NPC[numNPCs].Frame = 4;
        if(NPC[numNPCs].Special == 3)
            NPC[numNPCs].Frame = 8;
        if(NPC[numNPCs].Special == 4)
            NPC[numNPCs].Frame = 12;
    }

    if(throw_up)
    {
        if(p.StandingOnNPC != 0)
            NPC[numNPCs].Location.SpeedY += NPC[p.StandingOnNPC].Location.SpeedY / 10;
        else
            NPC[numNPCs].Location.SpeedY += p.Location.SpeedY / 10;

        NPC[numNPCs].Location.SpeedX = NPC[numNPCs].Location.SpeedX * 0.9_r;
    }

    if(FlameThrower)
    {
        NPC[numNPCs].Location.SpeedX = NPC[numNPCs].Location.SpeedX * 1.5_rb;
        NPC[numNPCs].Location.SpeedY = NPC[numNPCs].Location.SpeedY * 1.5_rb;
    }

    if(p.StandingOnNPC != 0)
        NPC[numNPCs].Location.SpeedX = 5 * p.Direction + (p.Location.SpeedX + NPC[p.StandingOnNPC].Location.SpeedX) / 3.5_ri;

    // special speed and animation code for polar swimming
    if(p.AquaticSwim)
    {
        // player animation code
        p.FireBallCD -= 10;

        int plr_frame = 16;

        if(p.Controls.Left || p.Controls.Right)
        {
            // use left/right frame
        }
        else if((p.Controls.Down && !p.Controls.Up) || Player[A].Frame == 19 || Player[A].Frame == 20 || Player[A].Frame == 21)
            plr_frame = 19;
        else if(p.Controls.Up || Player[A].Frame == 40 || Player[A].Frame == 41 || Player[A].Frame == 42)
        {
            throw_up = true;
            plr_frame = 40;
        }

        if(!p.SwimCount)
        {
            p.Frame = plr_frame;
            p.FrameCount = 60;
        }

        // center NPC if player is moving up/down
        if(plr_frame != 16)
        {
            NPC[numNPCs].Location.X = p.Location.X + (p.Location.Width - NPC[numNPCs].Location.Width) / 2;
            NPC[numNPCs].Location.Y += (plr_frame == 19) ? 8 : -8;
            NPC[numNPCs].Direction = throw_dir;
            throw_dir = 0;
        }

        // don't slow NPC down in its first frame of processing
        NPC[numNPCs].Wet = 2;

        // reset NPC speed
        NPC[numNPCs].Location.SpeedX = 4 * throw_dir;
        NPC[numNPCs].Location.SpeedY = (throw_dir) ? 2 : 3;

        // special logic for throwing upwards during Polar Swim
        if(throw_up)
        {
            NPC[numNPCs].Special4 = 1; // low gravity and no speed cap
            NPC[numNPCs].Special5 = 3; // prevent bouncing
            NPC[numNPCs].Location.SpeedY = -NPC[numNPCs].Location.SpeedY;
        }

        // add player momentum
        NPC[numNPCs].Location.SpeedX += p.Location.SpeedX;
        NPC[numNPCs].Location.SpeedY += p.Location.SpeedY;
    }
    else if(!p.SpinJump)
        p.FrameCount = 110;

    PlayerThrownNpcMazeCheck(p, NPC[numNPCs]);

    syncLayers_NPC(numNPCs);
    CheckSectionNPC(numNPCs);
}

void PowerUps(const int A)
{
    auto &p = Player[A];
    //int B = 0;

    if(p.Fairy)
    {
        p.SwordPoke = 0;
        p.FireBallCD = 0;
        p.FireBallCD2 = 0;
        p.TailCount = 0;
        return;
    }

    // this condition was moved into PlayerThrowHeavy
    // if(p.State == 6 && p.Character == 4 && p.Controls.Run && p.RunRelease)
    //     BoomOut = PlayerChar4HeavyOut(A);

    // Run-triggered actions; many of the conditions were combined here, so please search for the distinctive comments to find the corresponding code in legacy source
    if(!p.Slide && p.Vine == 0 && p.Character != 5 && (!p.Duck || p.AquaticSwim) && p.Mount <= 1 && p.HoldingNPC <= 0)
    {
        // Hammer Throw Code
        if(p.State == 6)
        {
            if(p.FireBallCD <= 0)
            {
                if(p.Controls.Run && !p.SpinJump /* && !BoomOut*/)
                {
                    if(p.RunRelease || p.SpinJump || FlameThrower)
                        PlayerThrowHeavy(A);
                }
            }
        }
        // Fire Mario / Luigi code ---- FIRE FLOWER ACTION BALLS OF DOOM
        // State-dependent moment!
        else if(p.State == 3 || p.State == 7 || p.State == PLR_STATE_POLAR)
        {
            if(p.FireBallCD <= 0)
            {
                if((p.Controls.Run && !p.SpinJump) || (p.SpinJump && p.Direction != p.SpinFireDir))
                {
                    if(p.RunRelease || p.SpinJump || FlameThrower)
                        PlayerThrowBall(A);
                }
            }
        }
        // RacoonMario
        else if(p.State == 4 || p.State == 5)
        {
            // NOTE: when PowerUps is called, HoldingNPC < 0 if and only if (Player[A].Mount != 0 || Player[A].Stoned || Player[A].Fairy), and Effect is always PLREFF_NORMAL
            if(p.HoldingNPC == 0 /* && p.Mount != 2 && !p.Stoned && p.Effect == PLREFF_NORMAL */)
            {
                if((p.Controls.Run && p.RunRelease) || p.SpinJump)
                {
                    if(p.TailCount == 0 || p.TailCount >= 12)
                    {
                        p.TailCount = 1;

                        if(!p.SpinJump)
                            PlaySoundSpatial(SFX_Whip, p.Location);
                    }
                }
            }
        }
    }

    if(p.TailCount > 0)
    {
        p.TailCount += 1;
        if(p.TailCount == 25)
            p.TailCount = 0;

        if(p.TailCount % 7 == 0 || (p.SpinJump && (p.TailCount % 2) == 0))
            TailSwipe(A, true);
        else
            TailSwipe(A);

        if(p.HoldingNPC > 0)
            p.TailCount = 0;
    }


    // link stab
    if(p.Character == 5 && p.Vine == 0 && p.Mount == 0 && !p.Stoned && p.FireBallCD == 0)
        PlayerChar5StabLogic(A);


    // cooldown timer
    p.FireBallCD2 -= 1;
    if(p.FireBallCD2 < 0)
        p.FireBallCD2 = 0;

    if(!(p.Character == 3 && NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL))
    {
        p.FireBallCD -= 1;
        if(FlameThrower)
            p.FireBallCD -= 3;
        if(p.FireBallCD < 0)
            p.FireBallCD = 0;
    }
}

void Tanooki(const int A)
{
    auto &p = Player[A];

    if(p.Fairy)
       return;

    // tanooki
    if(p.Stoned && p.Controls.Down && p.StandingOnNPC == 0)
    {
        p.Location.SpeedX = p.Location.SpeedX * 0.8_r;
        if(p.Location.SpeedX >= -0.5_n && p.Location.SpeedX <= 0.5_n)
            p.Location.SpeedX = 0;
        if(p.Location.SpeedY < 8)
            p.Location.SpeedY += 0.25_n;
    }

    if(p.StonedCD == 0)
    {
        // If .Mount = 0 And .State = 5 And .Controls.Run = True And .Controls.Down = True Then
        if(p.Mount == 0 && p.State == 5 && p.Controls.AltRun && p.Bombs == 0)
        {
            if(!p.Stoned)
                p.Effect = PLREFF_STONE;
        }
        else if(p.Stoned)
            p.Effect = PLREFF_STONE;
    }
    else
        p.StonedCD -= 1;

    if(p.Stoned)
    {
        p.StonedTime += 1;
        if(p.StonedTime >= 240)
        {
            p.Effect = PLREFF_STONE;
            p.StonedCD = 60;
        }
        else if(p.StonedTime >= 180)
        {
            p.Immune += 1;
            if(p.Immune % 3 == 0)
                p.Immune2 = !p.Immune2;
        }
    }
}


================================================
FILE: src/player/player_block_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>

#include "globals.h"

#include "player.h"
#include "blocks.h"
#include "sound.h"
#include "layers.h"
#include "effect.h"
#include "eff_id.h"
#include "collision.h"
#include "eff_id.h"
#include "blk_id.h"
#include "npc_traits.h"
#include "config.h"
#include "phys_env.h"

#include "main/trees.h"

void PlayerBlockLogic(int A, int& floorBlock, bool& movingBlock, bool& DontResetGrabTime, tempf_t cursed_value_C, const int oldStandingOnNpc)
{
    int oldSlope = Player[A].Slope;
    Player[A].Slope = 0;

    int blockPushX = 0;
    bool hitCeiling = false; // previously called tempHit
    bool hitWall = false; // previously called tempHit2

    int ceilingSlope = 0; // was previously called tempSlope
    int wallBlock = 0; // was previously called tempSlope2
    int insideBlock = 0; // keeps track of hit 5 for slope detection -- was previously called tempSlope3

    int ceilingBlock1 = 0;
    int ceilingBlock2 = 0;

    Location_t floorLocation; // was previously called tempLocation3

    // This was previously shared between players, but is safe unless Block[wallBlock] satisfies certain properties before wallBlock gets set
    num_t preWallX = 0; // The old X before player was moved -- was previously called tempSlope2X

    if(Player[A].Character == 5 && Player[A].Duck && (Player[A].Location.SpeedY == Physics.PlayerGravity || Player[A].StandingOnNPC != 0 || Player[A].Slope != 0))
        Player[A].Location.set_height_floor(30);


    // block collision optimization
    // fBlock = FirstBlock[(Player[A].Location.X / 32) - 1];
    // lBlock = LastBlock[((Player[A].Location.X + Player[A].Location.Width) / 32.0) + 1];
    // blockTileGet(Player[A].Location, fBlock, lBlock);

    UpdatableQuery<BlockRef_t> q(Player[A].Location, SORTMODE_COMPAT, QUERY_FLBLOCK);

    for(auto it = q.begin(); it != q.end(); ++it)
    {
        int B = *it;

        // checks to see if a collision happened
        if(Player[A].Location.X + Player[A].Location.Width >= Block[B].Location.X)
        {
            if(Player[A].Location.X <= Block[B].Location.X + Block[B].Location.Width)
            {
                if(Player[A].Location.Y + Player[A].Location.Height >= Block[B].Location.Y)
                {
                    if(Player[A].Location.Y <= Block[B].Location.Y + Block[B].Location.Height)
                    {

                        if(!Block[B].Hidden)
                        {
                            // the hitspot is used for collision detection to find out where to put the player after it collides with a block
                            // the numbers tell what side the collision happened so it can move the plaer to the correct position
                            // 1 means the player hit the block from the top
                            // 2 is from the right
                            // 3 is from the bottom
                            // 4 is from the left
                            num_t block_belt_speed = 0;
                            if(Block[B].Type >= BLKID_CONVEYOR_L_START && Block[B].Type <= BLKID_CONVEYOR_L_END)
                                block_belt_speed = -0.8_n;
                            else if(Block[B].Type >= BLKID_CONVEYOR_R_START && Block[B].Type <= BLKID_CONVEYOR_R_END)
                                block_belt_speed = 0.8_n;

                            int HitSpot = FindRunningCollision(Player[A].Location, Block[B].Location, block_belt_speed); // this finds what part of the block the player collided

                            // force hitspot 3 during cyclone jump (prevents catching on sides of ceiling blocks)
                            if(Player[A].State == PLR_STATE_CYCLONE && !Player[A].DoubleJump && HitSpot != 1)
                            {
                                // cross-ref FindRunningCollision
                                if(Player[A].Location.Y - Player[A].Location.SpeedY >= Block[B].Location.Y + Block[B].Location.Height - Block[B].Location.SpeedY)
                                    HitSpot = 3;
                            }

                            if(BlockNoClipping[Block[B].Type]) // blocks that the player can't touch are forced to hitspot 0 (which means no collision)
                                HitSpot = 0;

                            if(BlockIsSizable[Block[B].Type] || BlockOnlyHitspot1[Block[B].Type]) // for sizable blocks, if the player didn't land on them from the top then he can walk through them
                            {
                                if(HitSpot != 1)
                                    HitSpot = 0;

                                if(Player[A].Mount == 2 || Player[A].StandingOnVehiclePlr != 0)
                                    HitSpot = 0;
                            }

                            // for blocks that hurt the player
                            if(BlockHurts[Block[B].Type])
                            {
                                if(Player[A].Mount == 2 ||
                                    InvincibilityTime ||
                                   (
                                       ((HitSpot == 1 && Player[A].Mount) || (Player[A].Rolling && Player[A].State == PLR_STATE_SHELL)) &&
                                       Block[B].Type != 598
                                   )
                                 )
                                {}
                                else
                                {
                                    if(HitSpot == 1 && (Block[B].Type == 110 || Block[B].Type == 408 || Block[B].Type == 430 || Block[B].Type == 511))
                                        PlayerHurt(A);
                                    if(HitSpot == 4 && (Block[B].Type == 269 || Block[B].Type == 429))
                                        PlayerHurt(A);
                                    if(HitSpot == 3 && (Block[B].Type == 268 || Block[B].Type == 407 || Block[B].Type == 431))
                                        PlayerHurt(A);
                                    if(HitSpot == 2 && (Block[B].Type == 267 || Block[B].Type == 428))
                                        PlayerHurt(A);
                                    if(Block[B].Type == 109)
                                        PlayerHurt(A);
                                    if(Block[B].Type == 598)
                                    {
                                        if(Player[A].Mount > 0 && HitSpot == 1)
                                        {
                                            cursed_value_C = tempf_t(Player[A].Location.Y + Player[A].Location.Height);
                                            Player[A].Location.Y = Block[B].Location.Y - Player[A].Location.Height;
                                            PlayerHurt(A);
                                            Player[A].Location.Y = (num_t)cursed_value_C - Player[A].Location.Height;
                                        }
                                        else
                                            PlayerHurt(A);
                                    }


                                    if(Player[A].TimeToLive > 0)
                                        break;
                                }
                            }

                            // hitspot 5 means the game doesn't know where the collision happened
                            // if the player just stopped ducking and there is a hitspot 5 then force hitspot 3 (hit block from below)
                            if(HitSpot == 5 && (Player[A].StandUp || NPC[Player[A].StandingOnNPC].Location.SpeedY < 0))
                            {
                                if(BlockSlope[Block[B].Type] == 0)
                                    HitSpot = 3;
                            }

                            // if the block is invisible and the player didn't hit it from below then the player won't collide with it
                            if(Block[B].Invis)
                            {
                                if(HitSpot != 3)
                                    HitSpot = 0;
                            }

                            // unclear that this does what Redigit thought; maybe it did with a previous version of the coin switch code

                            // ' fixes a bug with holding an npc that is really a block
                            if(Player[A].HoldingNPC > 0)
                            {
                                if(NPC[Player[A].HoldingNPC].coinSwitchBlockType() == B)
                                    HitSpot = 0;
                            }

                            // destroy some blocks if the player is touching it as a statue
                            if(Block[B].Type == 457 && Player[A].Stoned)
                            {
                                HitSpot = 0;
                                SafelyKillBlock(B);
                            }

                            // shadowmode is a cheat that allows the player to walk through walls
                            if(ShadowMode && HitSpot != 1 && !(Block[B].Special > 0 && HitSpot == 3))
                                HitSpot = 0;

                            // this handles the collision for blocks that are sloped on the bottom
                            if(BlockSlope2[Block[B].Type] != 0 && (Player[A].Location.Y > Block[B].Location.Y || (HitSpot != 2 && HitSpot != 4)) && HitSpot != 1 && !ShadowMode)
                            {
                                HitSpot = 0;
                                ceilingSlope = B;

                                num_t PlrMid;
                                if(BlockSlope2[Block[B].Type] == 1)
                                    PlrMid = Player[A].Location.X + Player[A].Location.Width;
                                else
                                    PlrMid = Player[A].Location.X;

                                num_t Slope = (PlrMid - Block[B].Location.X) / (int_ok)Block[B].Location.Width;

                                if(BlockSlope2[Block[B].Type] > 0)
                                    Slope = 1 - Slope;

                                if(Slope < 0)
                                    Slope = 0;

                                if(Slope > 1)
                                    Slope = 1;

                                if(Player[A].Location.Y <= Block[B].Location.Y + Block[B].Location.Height - ((int_ok)Block[B].Location.Height * Slope))
                                {
                                    if(BlockKills[Block[B].Type] && !(Player[A].Rolling && Player[A].Character == 5 && Player[A].State == PLR_STATE_SHELL))
                                    {
                                        if(!GodMode)
                                            PlayerDead(A);
                                    }

                                    if(Player[A].Location.SpeedY == 0 ||
                                       num_t::fEqual_f(Player[A].Location.SpeedY, Physics.PlayerGravity) || Player[A].Slope > 0 || Player[A].StandingOnNPC != 0)
                                    {
                                        num_t PlrMid = Player[A].Location.Y;
                                        Slope = (PlrMid - Block[B].Location.Y) / (int_ok)Block[B].Location.Height;

                                        if(Slope < 0)
                                            Slope = 0;

                                        if(Slope > 1)
                                            Slope = 1;

                                        if(BlockSlope2[Block[B].Type] < 0)
                                            Player[A].Location.X = Block[B].Location.X + Block[B].Location.Width - ((int_ok)Block[B].Location.Width * Slope);
                                        else
                                            Player[A].Location.X = Block[B].Location.X + ((int_ok)Block[B].Location.Width * Slope) - Player[A].Location.Width;

                                        Player[A].Location.SpeedX = 0;

                                    }
                                    else
                                    {
                                        Player[A].Location.Y = Block[B].Location.Y + Block[B].Location.Height - ((int_ok)Block[B].Location.Height * Slope);
                                        if(Player[A].Location.SpeedY < 0)
                                            PlaySoundSpatial(SFX_BlockHit, Player[A].Location);
                                        if(Player[A].Location.SpeedY < -0.01_n)
                                            Player[A].Location.SpeedY = -0.01_n;
                                        if(Player[A].Mount == 2)
                                            Player[A].Location.SpeedY = 2;
                                        if(Player[A].CanFly2)
                                            Player[A].Location.SpeedY = 2;
                                    }

                                    // cancel any jump except for a cyclone jump
                                    if(!(Player[A].State == PLR_STATE_CYCLONE && !Player[A].DoubleJump))
                                        Player[A].Jump = 0;
                                }
                            }

                            // collision for blocks that are sloped on the top
                            // MOST CURSED LINE: cursed_value_C (C in VB6 code) is entirely arbitrary at this point. BE WARNED, this may be a cause of incompatibilities with SMBX 1.3, and if so, we will need to improve this logic in the future.
                            if(BlockSlope[Block[B].Type] != 0 && HitSpot != 3 && !(BlockSlope[Block[B].Type] == -1 && HitSpot == 2) && !(BlockSlope[Block[B].Type] == 1 && HitSpot == 4) && (Player[A].Location.Y + Player[A].Location.Height - 4 - (num_t)cursed_value_C <= Block[B].Location.Y + Block[B].Location.Height || (Player[A].Location.Y + Player[A].Location.Height - 12 <= Block[B].Location.Y + Block[B].Location.Height && Player[A].StandingOnNPC != 0)))
                            {
                                HitSpot = 0;
                                if(
                                        (Player[A].Mount == 1 || Player[A].Location.SpeedY >= 0 ||
                                         Player[A].Slide || SuperSpeed || Player[A].Stoned) &&
                                        (Player[A].Location.Y + Player[A].Location.Height <= Block[B].Location.Y + Block[B].Location.Height + Player[A].Location.SpeedY + 0.001_n ||
                                         (Player[A].Slope == 0 && Block[B].Location.SpeedY < 0))
                                        )
                                {
                                    num_t PlrMid;
                                    if(BlockSlope[Block[B].Type] == 1)
                                        PlrMid = Player[A].Location.X;
                                    else
                                        PlrMid = Player[A].Location.X + Player[A].Location.Width;

                                    num_t Slope = (PlrMid - Block[B].Location.X) / (int_ok)Block[B].Location.Width;

                                    if(BlockSlope[Block[B].Type] < 0)
                                        Slope = 1 - Slope;

                                    if(Slope < 0)
                                        Slope = 0;

                                    if(Slope > 1)
                                        Slope = 1;

                                    // if we're already on top of another (higher or more leftwards, at level load time) block this frame, consider canceling it
                                    if(floorBlock > 0)
                                    {
                                        // the bug this is fixing is vanilla, but this case happens for a single frame every time a slope falls through ground since TheXTech 1.3.6,
                                        // and only in the rare case where a slope falls through ground *it was originally below* in vanilla
                                        if(g_config.fix_player_downward_clip && !CompareWalkBlock(floorBlock, B, Player[A].Location))
                                        {
                                            // keep the old block, other conditions are VERY likely to cancel it
                                        }
                                        else if(!BlockIsSizable[Block[floorBlock].Type])
                                        {
                                            if(Block[floorBlock].Location.Y != Block[B].Location.Y)
                                                floorBlock = 0;
                                        }
                                        else
                                        {
                                            // NOTE: looks like a good place for a vb6-style fEqual
                                            if(Block[floorBlock].Location.Y == Block[B].Location.Y + Block[B].Location.Height)
                                                floorBlock = 0;
                                        }
                                    }

                                    if(hitWall)
                                    {
                                        // NOTE: looks like a good place for a vb6-style fEqual
                                        if(Block[wallBlock].Location.Y + Block[wallBlock].Location.Height == Block[B].Location.Y && BlockSlope[Block[wallBlock].Type] == BlockSlope[Block[B].Type])
                                        {
                                            hitWall = false;
                                            wallBlock = 0;
                                            Player[A].Location.X = preWallX;
                                        }
                                    }

                                    if(insideBlock > 0)
                                    {
                                        Player[A].Location.Y = Block[insideBlock].Location.Y + Block[insideBlock].Location.Height + 0.01_n;
                                        num_t PlrMid = Player[A].Location.Y + Player[A].Location.Height;
                                        num_t Slope = 1 - (PlrMid - Block[B].Location.Y) / (int_ok)Block[B].Location.Height;

                                        if(Slope < 0)
                                            Slope = 0;

                                        if(Slope > 1)
                                            Slope = 1;

                                        if(BlockSlope[Block[B].Type] > 0)
                                            Player[A].Location.X = Block[B].Location.X + Block[B].Location.Width - ((int_ok)Block[B].Location.Width * Slope);
                                        else
                                            Player[A].Location.X = Block[B].Location.X + ((int_ok)Block[B].Location.Width * Slope) - Player[A].Location.Width;

                                        Player[A].Location.SpeedX = 0;
                                    }
                                    else
                                    {
                                        if(Player[A].Location.Y >= Block[B].Location.Y + ((int_ok)Block[B].Location.Height * Slope) - Player[A].Location.Height - 0.1_n)
                                        {

                                            if(Player[A].GroundPound)
                                            {
                                                YoshiPound(A, Player[A].Mount, true);
                                                Player[A].GroundPound = false;
                                            }
                                            else if(Player[A].YoshiYellow)
                                            {
                                                if(oldSlope == 0)
                                                    YoshiPound(A, Player[A].Mount);
                                            }

                                            Player[A].Location.Y = Block[B].Location.Y + ((int_ok)Block[B].Location.Height * Slope) - Player[A].Location.Height - 0.1_n;

                                            if(Player[A].Location.SpeedY > Player[A].Location.SpeedX * (int_ok)Block[B].Location.Height / (int_ok)Block[B].Location.Width * BlockSlope[Block[B].Type] || !Player[A].Slide)
                                            {
                                                if(!Player[A].WetFrame)
                                                {
                                                    cursed_value_C = (tempf_t)(Player[A].Location.SpeedX * (int_ok)Block[B].Location.Height / (int_ok)Block[B].Location.Width * BlockSlope[Block[B].Type]);
                                                    Player[A].Location.SpeedY = (num_t)cursed_value_C;
                                                    if(Player[A].Location.SpeedY > 0 && !Player[A].Slide && Player[A].Mount != 1 && Player[A].Mount != 2)
                                                        Player[A].Location.SpeedY = Player[A].Location.SpeedY * 4;
                                                }
                                            }

                                            Player[A].Slope = B;
                                            if(BlockSlope[Block[B].Type] == 1 && GameMenu && Player[A].Location.SpeedX >= 2)
                                            {
                                                if(Player[A].Mount == 0 && Player[A].HoldingNPC == 0 && Player[A].Character <= 2)
                                                {
                                                    if(Player[A].Duck)
                                                        UnDuck(Player[A]);
                                                    Player[A].Slide = true;
                                                }
                                            }



                                            if(Player[A].Location.SpeedY < 0 && !Player[A].Slide && !SuperSpeed && !Player[A].Stoned)
                                                Player[A].Location.SpeedY = 0;
                                            if(Block[B].Location.SpeedX != 0 || Block[B].Location.SpeedY != 0)
                                            {
                                                NPC[-A] = NPC_t();
                                                NPC[-A].Location = Block[B].Location;
                                                NPC[-A].Type = NPCID_METALBARREL;
                                                NPC[-A].Active = true;
                                                NPC[-A].TimeLeft = 100;
                                                NPC[-A].Section = Player[A].Section;
                                                NPC[-A].Special = B;
                                                NPC[-A].Special2 = BlockSlope[Block[B].Type];
                                                Player[A].StandingOnNPC = -A;
                                                movingBlock = true;
                                                // NOTE: Here was a bug that makes compare bool with 0 is always false
                                                if(
                                                        (g_config.fix_player_slope_speed &&
                                                         Player[A].Location.SpeedX - NPC[Player[A].StandingOnNPC].Location.SpeedX < 0 &&
                                                         BlockSlope[Block[B].Type]/*)*/ < 0) ||
                                                        (Player[A].Location.SpeedX - NPC[Player[A].StandingOnNPC].Location.SpeedX > 0 &&
                                                         BlockSlope[Block[B].Type] > 0)
                                                        )
                                                {
                                                    if((Player[A].Location.SpeedX < 0 && Block[B].Location.SpeedX > 0) || (Player[A].Location.SpeedX > 0 && Block[B].Location.SpeedX < 0))
                                                        Player[A].Location.SpeedY = 12;
                                                }

                                                NPC[-A].Location.Y = Player[A].Location.Y + Player[A].Location.Height;
                                            }
                                        }
                                    }
                                }
                            }


                            if(BlockKills[Block[B].Type] && !GodMode)
                            {
                                bool hot_boot = (Player[A].Mount == 1 && Player[A].MountType == 2);
                                bool lava_roller = (Player[A].Rolling && Player[A].Character == 5 && Player[A].State == PLR_STATE_SHELL);
                                hot_boot |= lava_roller;

                                // this is a fix to help the player deal with lava blocks a bit easier
                                // it moves the blocks hitbox down a few pixels
                                if(BlockSlope[Block[B].Type] == 0 && !hot_boot)
                                {
                                    if(Player[A].Location.Y + Player[A].Location.Height < Block[B].Location.Y + 6)
                                        HitSpot = 0;
                                }

                                // kill the player if touching a lava block
                                if(HitSpot > 0 || Player[A].Slope == B)
                                {
                                    if(!hot_boot)
                                    {
                                        PlayerDead(A);
                                        break;
                                    }
                                    else if(HitSpot != 1 && BlockSlope[Block[B].Type] == 0 && !lava_roller)
                                    {
                                        PlayerDead(A);
                                        break;
                                    }
                                    else
                                    {
                                        Location_t tempLocation;
                                        tempLocation.Y = Player[A].Location.Y + Player[A].Location.Height - 2;
                                        tempLocation.X = Player[A].Location.X - 4 + dRand() * ((int)Player[A].Location.Width + 8) - 4;
                                        NewEffect(EFFID_SKID_DUST, tempLocation);
                                    }
                                }
                            }

                            // if hitspot 5 with a sloped block then don't collide with it. the collision should have already been handled by the slope code above
                            if(HitSpot == 5 && BlockSlope[Block[B].Type] != 0)
                                HitSpot = 0;

                            // shelsurfing code
                            if(HitSpot > 1 && Player[A].ShellSurf)
                            {
                                Player[A].ShellSurf = false;
                                Player[A].Location.SpeedY = NPC[Player[A].StandingOnNPC].Location.SpeedY + Physics.PlayerJumpVelocity * 0.75_rb;
                                Player[A].StandingOnNPC = 0;
                                PlaySoundSpatial(SFX_BlockHit, Player[A].Location);
                            }

                            if(BlockCheckPlayerFilter(B, A))  // Optmizied
                                HitSpot = 0;
                            //if(Block[B].Type == 626 && Player[A].Character == 1)
                            //    HitSpot = 0;
                            //if(Block[B].Type == 627 && Player[A].Character == 2)
                            //    HitSpot = 0;
                            //if(Block[B].Type == 628 && Player[A].Character == 3)
                            //    HitSpot = 0;
                            //if(Block[B].Type == 629 && Player[A].Character == 4)
                            //    HitSpot = 0;
                            //if(Block[B].Type == 632 && Player[A].Character == 5)
                            //    HitSpot = 0;

                            if(g_config.fix_player_clip_wall_at_npc && (HitSpot == 5 || HitSpot == 3) && oldStandingOnNpc > 0 && Player[A].Jump)
                            {
                                // Re-compute the collision with a block to avoid the unnecessary clipping through the wall
                                auto pLoc = Player[A].Location;
                                pLoc.SpeedX += NPC[oldStandingOnNpc].Location.SpeedX;
                                pLoc.SpeedY += NPC[oldStandingOnNpc].Location.SpeedY;
                                HitSpot = FindRunningCollision(pLoc, Block[B].Location, block_belt_speed);
                                D_pLogDebug("Conveyor: Recomputed collision with block %d", B);
                            }

                            // the following code is where the collisions are handled


                            if((HitSpot == 1 || Player[A].Slope == B) && Block[B].Slippy)
                                Player[A].Slippy = true;


                            if(HitSpot == 5 && Player[A].Quicksand > 0) // fixes quicksand hitspot 3 bug
                            {
                                if(Player[A].Location.Y - Player[A].Location.SpeedY < Block[B].Location.Y + Block[B].Location.Height)
                                    HitSpot = 3;
                            }
                            // don't stop rolling when you clip into a block -- just bounce on it
                            // (if there are multiple blocks, eventually the player will get pinched and leave rolling state)
                            else if(HitSpot == 5 && Player[A].Rolling && Player[A].State == PLR_STATE_SHELL)
                            {
                                if(Block[B].Location.to_right_of(Player[A].Location))
                                    HitSpot = 4;
                                else
                                    HitSpot = 2;
                            }

                            if(HitSpot == 1) // landed on the block from the top V
                            {
                                if(Player[A].Fairy && (Player[A].FairyCD > 0 || Player[A].Location.SpeedY > 0))
                                    Player[A].FairyTime = 0;

                                Player[A].Pinched.Bottom1 = 2; // for players getting squashed

                                if(Block[B].Location.SpeedY != 0)
                                {
                                    Player[A].Pinched.Moving = 2;
                                    Player[A].Pinched.MovingUD = true;
                                }

                                Player[A].Vine = 0; // stop climbing because you are now walking
                                if(Player[A].Mount == 2) // for the clown car, make a niose and pound the ground if moving down fast enough
                                {
                                    if(Player[A].Location.SpeedY > 3)
                                    {
                                        PlaySoundSpatial(SFX_Stone, Player[A].Location);
                                        YoshiPound(A, Player[A].Mount, true);
                                    }
                                }

                                bool player_drill = (Player[A].State == PLR_STATE_CYCLONE && !Player[A].DoubleJump && Player[A].Controls.Down && Player[A].Location.SpeedY > Physics.PlayerTerminalVelocity * 0.9_n);
                                if(player_drill && BlockIsBreakable(Block[B]) && Block[B].Type != 90)
                                {
                                    BlockHitHard(B);
                                }
                                else if(player_drill)
                                {
                                    if(Block[B].Special)
                                    {
                                        BlockHit(B, true, A);
                                        PlaySoundSpatial(SFX_BlockHit, Player[A].Location);
                                    }

                                    player_drill = false;
                                }

                                if(player_drill)
                                {
                                    // just keep going down
                                }
                                else if(floorBlock == 0) // For walking
                                {
                                    floorBlock = B;
                                    floorLocation = Block[B].Location;
                                }
                                else // Find the best block to walk on if touching multiple blocks
                                {
                                    if(g_config.fix_player_downward_clip)
                                    {
                                        if(CompareWalkBlock(floorBlock, B, Player[A].Location))
                                        {
                                            floorBlock = B;
                                            floorLocation = Block[B].Location;
                                        }
                                    }
                                    else // Using old code
                                    {
                                        if(Block[B].Location.SpeedY != 0 && Block[floorBlock].Location.SpeedY == 0)
                                        {
                                            floorBlock = B;
                                            floorLocation = Block[B].Location;
                                        }
                                        else if(Block[B].Location.SpeedY == 0 && Block[floorBlock].Location.SpeedY != 0)
                                        {
                                        }
                                        else
                                        {
                                            num_t C = num_t::abs(Block[B].Location.minus_center_x(Player[A].Location));
                                            num_t D = num_t::abs(Block[floorBlock].Location.minus_center_x(Player[A].Location));

                                            if(C < D)
                                                floorBlock = B;

                                            // this is the case where an unbound C gets written to
                                            cursed_value_C = (tempf_t)C;
                                        }

                                        // if this block is moving up give it priority
                                        if(Block[B].Location.SpeedY < 0 && Block[B].Location.Y < Block[floorBlock].Location.Y)
                                        {
                                            floorBlock = B;
                                            floorLocation = Block[B].Location;
                                        }
                                    }
                                }

                            }
                            else if(HitSpot == 2 || HitSpot == 4) // hit the block from the right <---- (or left now! -------.)
                            {
                                if(HitSpot == 2 && BlockSlope[Block[oldSlope].Type] == 1 && Block[oldSlope].Location.Y <= Block[B].Location.Y)
                                {
                                    // Just a blank block :-P
                                }
                                else
                                {
                                    preWallX = Player[A].Location.X;

                                    if(HitSpot == 4)
                                    {
                                        Player[A].Location.X = Block[B].Location.X - Player[A].Location.Width - 0.01_n;
                                        Player[A].Pinched.Right4 = 2;
                                    }
                                    else
                                    {
                                        Player[A].Location.X = Block[B].Location.X + Block[B].Location.Width + 0.01_n;
                                        Player[A].Pinched.Left2 = 2;
                                    }

                                    if(Block[B].Location.SpeedX != 0)
                                    {
                                        Player[A].Pinched.Moving = 2;
                                        Player[A].Pinched.MovingLR = true;
                                    }

                                    if(Player[A].Mount == 2)
                                    {
                                        // cast through float because in VB6 the old X location was temporarily stored in mountBump, which is a float
                                        Player[A].mountBump = (numf_t)(Player[A].Location.X - (num_t)(tempf_t)preWallX);
                                    }

                                    wallBlock = B;
                                    hitWall = true;

                                    // IMPORTANT: this case was truncation until v1.3.7.1-dev. Confirm that changing to VB6 rounding does not cause any issues.
                                    blockPushX = num_t::vb6round(Block[B].Location.SpeedX);

                                    if(Block[B].Slippy)
                                        Player[A].SlippyWall = true;
                                }
                            }
                            else if(HitSpot == 3) // hit the block from below
                            {
                                // add more generous margin to prevent unfair crush death with sloped ceiling
                                bool ignore = (g_config.fix_player_crush_death
                                    && (Block[B].Location.X + Block[B].Location.Width - 2 < Player[A].Location.X
                                        || Player[A].Location.X + Player[A].Location.Width - 2 < Block[B].Location.X));

                                if(!Player[A].ForceHitSpot3 && !Player[A].StandUp && !ignore)
                                    Player[A].Pinched.Top3 = 2;

                                if(Block[B].Location.SpeedY != 0 && !ignore)
                                {
                                    Player[A].Pinched.Moving = 2;
                                    Player[A].Pinched.MovingUD = true;
                                }

                                hitCeiling = true;
                                if(ceilingBlock1 == 0)
                                    ceilingBlock1 = B;
                                else
                                    ceilingBlock2 = B;
                            }
                            else if(HitSpot == 5) // try to find out where the player hit the block from
                            {
                                if(oldSlope > 0)
                                {
                                    if(Block[oldSlope].Location.Height == 0)
                                    {
                                        // SMBX 1.3 would have crashed here
                                    }
                                    else
                                    {
                                        Player[A].Location.Y = Block[B].Location.Y + Block[B].Location.Height + 0.01_n;
                                        num_t PlrMid = Player[A].Location.Y + Player[A].Location.Height;
                                        num_t Slope = 1 - (PlrMid - Block[oldSlope].Location.Y) / (int_ok)Block[oldSlope].Location.Height;
                                        if(Slope < 0)
                                            Slope = 0;
                                        if(Slope > 1)
                                            Slope = 1;
                                        if(BlockSlope[Block[oldSlope].Type] > 0)
                                            Player[A].Location.X = Block[oldSlope].Location.X + Block[oldSlope].Location.Width - ((int_ok)Block[oldSlope].Location.Width * Slope);
                                        else
                                            Player[A].Location.X = Block[oldSlope].Location.X + ((int_ok)Block[oldSlope].Location.Width * Slope) - Player[A].Location.Width;
                                        Player[A].Location.SpeedX = 0;
                                    }
                                }
                                else
                                {
                                    insideBlock = B;

                                    if(Block[B].Location.to_right_of(Player[A].Location))
                                        Player[A].Pinched.Right4 = 2;
                                    else
                                        Player[A].Pinched.Left2 = 2;

                                    if(Block[B].Location.SpeedX != 0 || Block[B].Location.SpeedY != 0)
                                    {
                                        Player[A].Pinched.Moving = 2;

                                        if(Block[B].Location.SpeedX != 0)
                                            Player[A].Pinched.MovingLR = true;

                                        if(Block[B].Location.SpeedY != 0)
                                            Player[A].Pinched.MovingUD = true;
                                    }

                                    Location_t playerFeet; // previously tempLocation
                                    playerFeet.X = Player[A].Location.X;
                                    playerFeet.Width = Player[A].Location.Width;
                                    playerFeet.Y = Player[A].Location.Y + Player[A].Location.Height;
                                    playerFeet.Height = 0.1_n;
                                    bool hasFloor = false; // previously tempBool

                                    // this could have caused an unusual TheXTech bug where lBlock would get overwritten
                                    // (this wouldn't affect VB6 because loop bounds are evaluated only on loop start)

                                    // fBlock = FirstBlock[(playerFeet.X / 32) - 1];
                                    // lBlock = LastBlock[((playerFeet.X + playerFeet.Width) / 32.0) + 1];
                                    // blockTileGet(playerFeet, fBlock, lBlock);

                                    for(int C : treeFLBlockQuery(playerFeet, SORTMODE_COMPAT))
                                    {
                                        if(CheckCollision(playerFeet, Block[C].Location) && !Block[C].Hidden)
                                        {
                                            if(BlockSlope[Block[C].Type] == 0)
                                                hasFloor = true;
                                            else
                                            {
                                                Player[A].Location.Y = Block[B].Location.Y + Block[B].Location.Height; // + 0.01
                                                num_t PlrMid = Player[A].Location.Y + Player[A].Location.Height;
                                                num_t Slope = 1 - (PlrMid - Block[C].Location.Y) / (int_ok)Block[C].Location.Height;
                                                if(Slope < 0)
                                                    Slope = 0;
                                                if(Slope > 1)
                                                    Slope = 1;
                                                if(BlockSlope[Block[C].Type] > 0)
                                                    Player[A].Location.X = Block[C].Location.X + Block[C].Location.Width - ((int_ok)Block[C].Location.Width * Slope);
                                                else
                                                    Player[A].Location.X = Block[C].Location.X + ((int_ok)Block[C].Location.Width * Slope) - Player[A].Location.Width;
                                                Player[A].Location.SpeedX = 0;
                                                break;
                                            }
                                        }
                                    }

                                    // arbitrary but fine for here (for now)
                                    // FIXME: look for cases where this is too high
                                    cursed_value_C = numBlock;

                                    /// TODO: find all cases where C is set and could "stick", and make them persistent
                                    //// decided whether or not to care about 2P and higher (C values from NPC checks)

                                    if(hasFloor)
                                    {
                                        Player[A].CanJump = false;
                                        Player[A].Jump = 0;
                                        Player[A].Location.X += -4 * Player[A].Direction;
                                        Player[A].Location.Y += -Player[A].Location.SpeedY;
                                        Player[A].Location.SpeedX = 0;
                                        Player[A].Location.SpeedY = 0;

                                        q.update(Player[A].Location, it);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        else
        {
        }
    }

    if(Player[A].Character == 5 && Player[A].Duck && !Player[A].Rolling)
        Player[A].Location.set_height_floor(Physics.PlayerDuckHeight[Player[A].Character][Player[A].State]);


    // helps the player run down slopes at different angles
    if(Player[A].Slope == 0 && oldSlope > 0 && Player[A].Mount != 1 && Player[A].Mount != 2 && !Player[A].Slide)
    {
        if(Block[oldSlope].Location.Width == 0)
        {
            // SMBX 1.3 would have crashed here
        }
        else if(Player[A].Location.SpeedY > 0)
        {
            tempf_t C = (tempf_t)(Player[A].Location.SpeedX * (int_ok)Block[oldSlope].Location.Height / (int_ok)Block[oldSlope].Location.Width * BlockSlope[Block[oldSlope].Type]);
            if(C > 0)
                Player[A].Location.SpeedY = (num_t)C;
        }
    }

    if(hitWall && Player[A].Rolling)
    {
        int slope = BlockSlope[Block[wallBlock].Type];

        // don't crash on slopes you should be going up!
        if(slope != -Player[A].Direction)
        {
            BlockHit(wallBlock, false, A);
            BlockHitHard(wallBlock);
            PlaySoundSpatial(SFX_BlockHit, Player[A].Location);

            // uses layer's speed to fix a bug where the sides of conveyor belts changed the player's speed
            num_t block_speed = (num_t)Layer[Block[wallBlock].Layer].ApplySpeedX;
            num_t rel_speed = Player[A].Location.SpeedX - block_speed;

            if((rel_speed > 0) == (Player[A].Direction > 0) && !hitCeiling && Player[A].State == PLR_STATE_SHELL)
            {
                Player[A].Location.SpeedX = block_speed - rel_speed;

                // help player go over 1-block gaps here
                if(!floorBlock && !Player[A].StandingOnNPC && !Player[A].Slope)
                {
                    Player[A].Location.Y -= 4;
                    Player[A].StandUp = true;
                    Player[A].ForceHitSpot3 = true; // sets standup the next frame
                }
            }
        }

        hitWall = false;

        // in polar, if the block can't be destroyed, do stop!
        if(Player[A].State == PLR_STATE_POLAR)
        {
            if(!BlockIsBreakable(Block[wallBlock]))
                hitWall = true;
        }
    }

    if(floorBlock > 0) // For walking
    {
        if(Player[A].StandingOnNPC == -A) // fors standing on movable blocks
        {
            if(NPC[Player[A].StandingOnNPC].Special2 != 0)
            {
                Player[A].Location.SpeedX += -NPC[Player[A].StandingOnNPC].Location.SpeedX;
                movingBlock = false;
                Player[A].StandingOnNPC = 0;
            }
        }

        // diggable dirt
        if(Block[floorBlock].Type == 370 && Player[A].StandingOnNPC <= 0) // dig dirt
        {
            DontResetGrabTime = true;
            // B = floorBlock;
            if(Player[A].TailCount == 0 && Player[A].Controls.Down && Player[A].Controls.Run && Player[A].Mount == 0 && !Player[A].Stoned && Player[A].HoldingNPC == 0 && (Player[A].GrabTime > 0 || Player[A].RunRelease))
            {
                if((Player[A].GrabTime >= 12 && Player[A].Character < 3) || (Player[A].GrabTime >= 16 && Player[A].Character == 3) || (Player[A].GrabTime >= 8 && Player[A].Character == 4))
                {
                    Player[A].Location.SpeedX = (num_t)Player[A].GrabSpeed;
                    Player[A].GrabSpeed = 0;
                    Block[floorBlock].Hidden = true;
                    Block[floorBlock].Layer = LAYER_DESTROYED_BLOCKS;
                    syncLayersTrees_Block(floorBlock);
                    NewEffect(EFFID_SMOKE_S3, Block[floorBlock].Location);
                    // NOTE: SpeedY was not doubled for EFFID_SMOKE_S3 in SMBX 1.3
                    Effect[numEffects].Location.SpeedY = -2;
                    Player[A].GrabTime = 0;
                }
                else
                {
                    if(Player[A].GrabTime == 0)
                    {
                        PlaySoundSpatial(SFX_Grab, Player[A].Location);
                        Player[A].FrameCount = 0;
                        Player[A].GrabSpeed = (numf_t)Player[A].Location.SpeedX;
                    }
                    Player[A].Location.SpeedX = 0;
                    Player[A].Slide = false;
                    Player[A].GrabTime += 1;
                }
            }
            else if(g_config.fix_player_stuck_on_dirt)
                DontResetGrabTime = false;
        }

        bool cancelWalk = false;

        if(hitWall)
        {
            if(!WalkingCollision(Player[A].Location, Block[floorBlock].Location))
                cancelWalk = true;

            // the logic below was previously duplicated with minor differences depending on the balue of hitWall
        }

        if(!cancelWalk)
        {
            Player[A].Location.Y = floorLocation.Y - Player[A].Location.Height;

            // NEW: move aquatic swimming player away from the floor -- helps with spikes
            if(Player[A].AquaticSwim)
                Player[A].Location.Y -= 0.01_n;

            if(!hitWall && Player[A].StandingOnNPC != 0)
            {
                if(NPC[Player[A].StandingOnNPC].Location.Y <= floorLocation.Y && Player[A].StandingOnNPC != Player[A].HoldingNPC)
                    Player[A].Location.Y = NPC[Player[A].StandingOnNPC].Location.Y - Player[A].Location.Height;
            }

            if(Player[A].GroundPound)
            {
                YoshiPound(A, Player[A].Mount, true);
                Player[A].GroundPound = false;
            }
            else if(Player[A].YoshiYellow)
                YoshiPound(A, Player[A].Mount);

            if(hitWall || Player[A].Slope == 0 || Player[A].Slide)
                Player[A].Location.SpeedY = 0;

            if(floorLocation.SpeedX != 0 || floorLocation.SpeedY != 0)
            {
                NPC[-A] = NPC_t();
                NPC[-A].Location = floorLocation;
                NPC[-A].Type = NPCID_METALBARREL;
                NPC[-A].Active = true;
                NPC[-A].TimeLeft = 100;
                NPC[-A].Section = Player[A].Section;
                NPC[-A].Special = floorBlock;
                Player[A].StandingOnNPC = -A;
                movingBlock = true;
                Player[A].Location.SpeedY = 12;
            }

            if(hitWall)
            {
                // this series of if clauses did not exist in the hitWall case
            }
            else if(Player[A].StandingOnNPC != 0 && !movingBlock)
            {
                Player[A].Location.SpeedY = 1;
                // the single Pinched variable has always been false since SMBX64
                // if(!NPC[Player[A].StandingOnNPC].Pinched && !FreezeNPCs)
                if(!FreezeNPCs)
                    Player[A].Location.SpeedX += -NPC[Player[A].StandingOnNPC].Location.SpeedX - (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed;
                Player[A].StandingOnNPC = 0;
            }
            else if(movingBlock)
            {
                Player[A].Location.SpeedY = NPC[-A].Location.SpeedY + 1;
                if(Player[A].Location.SpeedY < 0)
                    Player[A].Location.SpeedY = 0;
            }
#if 0
            // in the only case where this code is reachable, it has no effect
            else
            {
                if(Player[A].Slope == 0 || Player[A].Slide)
                    Player[A].Location.SpeedY = 0;
            }
#endif

            if(Block[floorBlock].Type == 55 && !FreezeNPCs) // Make the player jump if the block is bouncy
            {
                BlockHit(floorBlock, true);

                if(!Player[A].Slide)
                    Player[A].Multiplier = 0;

                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
                PlaySoundSpatial(SFX_BlockHit, Player[A].Location);

                if(Player[A].Controls.Jump || Player[A].Controls.AltJump)
                {
                    PlaySoundSpatial(SFX_Jump, Player[A].Location);
                    Player[A].Jump = Physics.PlayerBlockJumpHeight;

                    if(Player[A].Character == 2)
                        Player[A].Jump += 3;

                    if(Player[A].SpinJump)
                        Player[A].Jump -= 6;
                }
            }

            // smash turn blocks
            if(Player[A].SpinJump && (Block[floorBlock].Type == 90 || Block[floorBlock].Type == 526) && Player[A].State > 1 && Block[floorBlock].Special == 0)
            {
                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
                Block[floorBlock].Kill = true;
                if(iBlocks < maxBlocks)
                {
                    iBlocks++;
                    iBlock[iBlocks] = floorBlock;
                }
                // HitSpot = 0; // this definition is never used
                floorBlock = 0;
                Player[A].Jump = 7;

                if(Player[A].Character == 2)
                    Player[A].Jump += 3;

                if(Player[A].Controls.Down)
                {
                    Player[A].Jump = 0;
                    Player[A].Location.SpeedY = Physics.PlayerJumpVelocity / 2;
                }
            }
        }
    }

    if(wallBlock > 0 && ceilingSlope > 0)
    {
        if(Block[ceilingSlope].Location.Y + Block[ceilingSlope].Location.Height == Block[wallBlock].Location.Y + Block[wallBlock].Location.Height)
            hitWall = false;
    }

    if(!hitCeiling && hitWall)
    {
        if(Player[A].Location.SpeedX + NPC[Player[A].StandingOnNPC].Location.SpeedX > 0 && Player[A].Controls.Right)
        {
            Player[A].Location.SpeedX = 0.2_n * Player[A].Direction;
            if(blockPushX > 0)
                Player[A].Location.SpeedX += blockPushX;
        }
        else if(Player[A].Location.SpeedX + NPC[Player[A].StandingOnNPC].Location.SpeedX < 0 && Player[A].Controls.Left)
        {
            Player[A].Location.SpeedX = 0.2_n * Player[A].Direction;
            if(blockPushX < 0)
                Player[A].Location.SpeedX += blockPushX;
        }
        else
        {
            if(Player[A].Controls.Right || Player[A].Controls.Left)
                Player[A].Location.SpeedX = -NPC[Player[A].StandingOnNPC].Location.SpeedX + 0.2_n * Player[A].Direction;
            else
                Player[A].Location.SpeedX = 0;
        }

        if(Player[A].Mount == 2)
            Player[A].Location.SpeedX = 0;

        // disable mid-hop jumps (fixes a clipping bug)
        if(Player[A].State == PLR_STATE_AQUATIC && !Player[A].Mount && Player[A].MountSpecial)
            Player[A].MountSpecial = 2;
    }

    int ceilingBlock = 0; // was called B

    if(ceilingBlock2 != 0) // Hitting a block from below
    {
        num_t C = num_t::abs(Block[ceilingBlock1].Location.minus_center_x(Player[A].Location));
        num_t D = num_t::abs(Block[ceilingBlock2].Location.minus_center_x(Player[A].Location));

        if(C < D)
            ceilingBlock = ceilingBlock1;
        else
            ceilingBlock = ceilingBlock2;
    }
    else if(ceilingBlock1 != 0)
    {
        ceilingBlock = ceilingBlock1;
        if(Block[ceilingBlock].Location.X + Block[ceilingBlock].Location.Width - Player[A].Location.X <= 4)
        {
            Player[A].Location.X = Block[ceilingBlock].Location.X + Block[ceilingBlock].Location.Width + 0.1_n;
            ceilingBlock = 0;
        }
        else if(Player[A].Location.X + Player[A].Location.Width - Block[ceilingBlock].Location.X <= 4)
        {
            Player[A].Location.X = Block[ceilingBlock].Location.X - Player[A].Location.Width - 0.1_n;
            ceilingBlock = 0;
        }
    }

    if(ceilingBlock > 0)
    {
        // NEW: bounce an aquatic-swimming player off the ceiling if it has an item
        if(Player[A].AquaticSwim && Block[ceilingBlock].Special)
            Player[A].SwimCount = MAZE_DIR_DOWN * 16 + 2;

        // play ceiling hit sound if player is not aquatic swimming (normal) or if the ceiling block has an item
        if(!Player[A].AquaticSwim || Block[ceilingBlock].Special)
            PlaySoundSpatial(SFX_BlockHit, Player[A].Location);

        Player[A].Location.Y = Block[ceilingBlock].Location.Y + Block[ceilingBlock].Location.Height + 0.01_n;

        if(Player[A].State == PLR_STATE_CYCLONE && !Player[A].DoubleJump && Player[A].Jump)
        {
            Player[A].Location.SpeedY += 2.0_n;
            Player[A].Jump -= 1;
        }
        else
        {
            Player[A].Location.SpeedY = -0.01_n + Block[ceilingBlock].Location.SpeedY;
            Player[A].Jump = 0;
        }

        if(Player[A].Vine > 0)
            Player[A].Location.Y += 0.1_n;

        if(Player[A].Fairy || Player[A].Mount == 2 || Player[A].CanFly2)
            Player[A].Location.SpeedY = 2;

        if(Player[A].Mount != 2) // Tell the block it was hit
            BlockHit(ceilingBlock, false, A);

        if(Block[ceilingBlock].Type == 55) // If it is a bouncy block the knock the player down
            Player[A].Location.SpeedY = 3;

        if(Player[A].State > 1 && (Player[A].Character != 5 || Player[A].Rolling)) // If the player was big ask the block nicely to die
        {
            if(Player[A].Mount != 2 && Block[ceilingBlock].Type != 293)
                BlockHitHard(ceilingBlock);
        }
    }

    if(Player[A].StandingOnNPC != 0)
    {
        if(!hitWall)
        {
            // the single Pinched variable has always been false since SMBX64
            // if(!NPC[Player[A].StandingOnNPC].Pinched && !FreezeNPCs)
            if(!FreezeNPCs)
                Player[A].Location.SpeedX += -NPC[Player[A].StandingOnNPC].Location.SpeedX - (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed;
        }
    }

    if(Player[A].Slide && oldSlope > 0 && Player[A].Slope == 0 && Player[A].Location.SpeedY < 0)
    {
        if(Player[A].NoGravity == 0)
        {
            // Player[A].NoGravity = static_cast<int>(floor(static_cast<double>(Player[A].Location.SpeedY / Physics.PlayerJumpVelocity * 8)));
            // PlayerJumpVelocity is -5.7, SpeedY is negative
            Player[A].NoGravity = (int)(Player[A].Location.SpeedY * -80) / 57;
        }
    }
    else if(Player[A].Slope > 0 || oldSlope > 0 || !Player[A].Slide)
        Player[A].NoGravity = 0;

    // if(Player[A].Slide)  // Simplified below
    // {
    //     if(Player[A].Location.SpeedX > 1 || Player[A].Location.SpeedX < -1)
    //         Player[A].SlideKill = true;
    //     else
    //         Player[A].SlideKill = false;
    // }
    // else
    //     Player[A].SlideKill = false;

    Player[A].SlideKill = Player[A].Slide && (num_t::abs(Player[A].Location.SpeedX) > 1);
}


================================================
FILE: src/player/player_char5_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "config.h"
#include "sound.h"
#include "effect.h"
#include "eff_id.h"
#include "collision.h"

#include "player/player_update_priv.h"
#include "main/trees.h"

// called after movement code and before block / NPC / player collisions
void PlayerChar5Logic(int A)
{
    // TODO: State-dependent moment
    if(Player[A].State == 4 || Player[A].State == 5)
    {
        bool hasNoMonts = (g_config.fix_char5_vehicle_climb && Player[A].Mount <= 0) ||
                           !g_config.fix_char5_vehicle_climb;

        bool turnFairy = Player[A].FlyCount > 0 ||
                        ((Player[A].Controls.AltJump || (Player[A].Controls.Jump && Player[A].FloatRelease)) &&
                          Player[A].Location.SpeedY != Physics.PlayerGravity && Player[A].Slope == 0 &&
                          Player[A].StandingOnNPC == 0);

        if(turnFairy && hasNoMonts)
        {
            if(Player[A].FlyCount > 0)
                Player[A].FairyCD = 0;

            if(!Player[A].Fairy && Player[A].FairyCD == 0 && Player[A].Jump == 0 && Player[A].Wet == 0)
            {
                Player[A].Jump = 0;
                if(Player[A].FlyCount == 0)
                    Player[A].FlyCount = 50;
                Player[A].FairyTime = Player[A].FlyCount;
                Player[A].FairyCD = 1;
                Player[A].FlyCount = 0;
                Player[A].Fairy = true;
                SizeCheck(Player[A]);
                PlaySoundSpatial(SFX_HeroFairy, Player[A].Location);
                Player[A].Immune = 10;
                Player[A].Effect = PLREFF_WAITING;
                Player[A].Effect2 = 4;
                NewEffect(EFFID_SMOKE_S5, Player[A].Location);
            }
        }

        if(Player[A].Controls.Run && Player[A].RunRelease && (Player[A].FairyTime > 0 || Player[A].Effect == PLREFF_WAITING))
        {
            Player[A].FairyTime = 0;
            Player[A].Controls.Run = false;
        }

        if(Player[A].Fairy)
        {
            if(Player[A].Slope > 0 || Player[A].StandingOnNPC > 0)
            {
                Player[A].FairyTime = 0;
                Player[A].FairyCD = 0;
            }
        }
        // Coins += -1
        // If Coins < 0 Then
        // Lives += -1
        // Coins += 99
        // If Lives < 0 Then
        // Lives = 0
        // Coins = 0
        // .FairyTime = 0
        // End If
        // End If
        // End If
    }

    if(Player[A].HasKey)
        KeyholeCheck(A, Player[A].Location);

    if(Player[A].SwordPoke < 0)
    {
        Player[A].SwordPoke -= 1;

        if(Player[A].SwordPoke == -7)
            Player[A].SwordPoke = 1;

        if(Player[A].SwordPoke == -40)
            Player[A].SwordPoke = 0;

        if(!(Player[A].Slippy && !Player[A].Controls.Left && !Player[A].Controls.Right))
        {
            if(Player[A].FireBallCD == 0 && Player[A].Location.SpeedX != 0)
                Player[A].SwordPoke = 0;
        }
    }
    else if(Player[A].SwordPoke > 0)
    {
        // NEW LOGIC: bit 6 (32) of SwordPoke is a cancel flag
        if(Player[A].SwordPoke == 1)
        {
            TailSwipe(A, true, true);
            PlaySoundSpatial(SFX_HeroStab, Player[A].Location);

            // TODO: State-dependent moment
            if((Player[A].State == 3 || Player[A].State == 7 || Player[A].State == 6 || Player[A].State == PLR_STATE_POLAR) && Player[A].FireBallCD2 == 0)
                PlayerShootChar5Beam(A);
        }
        else if((Player[A].SwordPoke & 32) == 0)
            TailSwipe(A, false, true);

        Player[A].SwordPoke += 1;

        if((Player[A].SwordPoke & 31) >= 10)
        {
            if(Player[A].Duck)
            {
                Player[A].SwordPoke = 0;
                Player[A].FireBallCD = 7;
            }
            else
            {
                Player[A].SwordPoke = -11;
                Player[A].FireBallCD = 0;
            }
        }
    }

    if(Player[A].FireBallCD == 0 && Player[A].Wet == 0 && !Player[A].Fairy && Player[A].Mount == 0 && !Player[A].Rolling)
    {
        // Link ducks when jumping
        // Holding Up cancels this and allows upwards stab
        if(!Player[A].Duck && Player[A].Location.SpeedY < Physics.PlayerGravity && Player[A].StandingOnNPC == 0 &&
            Player[A].Slope == 0 && !Player[A].Controls.Up && !Player[A].Stoned)
        {
            Player[A].SwordPoke = 0;
            Player[A].Duck = true;
            Player[A].Location.set_height_floor(Physics.PlayerDuckHeight[Player[A].Character][Player[A].State]);
        }
        // Link stands when falling
        else if(Player[A].Duck && Player[A].Location.SpeedY > Physics.PlayerGravity && Player[A].StandingOnNPC == 0 && Player[A].Slope == 0)
        {
            Player[A].SwordPoke = 0;
            UnDuck(Player[A]);
        }
    }

    if(Player[A].Mount > 0 && Player[A].Mount != 2)
    {
        PlayerHurt(A);
        Player[A].Mount = 0;
    }

    Player[A].HoldingNPC = -1;
}

// called in PowerUps() -- executes before movement code
void PlayerChar5StabLogic(int A)
{
    Player_t& p = Player[A];

    if(p.Bombs > 0 && p.Controls.AltRun && p.RunRelease)
    {
        p.FireBallCD = 10;
        PlayerThrowBomb(A);
    }
    else if(/*p.FireBallCD == 0 && */ p.Controls.Run && p.RunRelease) // cooldown is 0 whenever this code is reached
    {
        p.FireBallCD = 20;

        if(p.Location.SpeedY != Physics.PlayerGravity && p.StandingOnNPC == 0 && p.Slope == 0) // Link ducks when jumping
        {
            if(p.Wet == 0 && !p.WetFrame)
            {
                if(p.Controls.Down && !p.Duck && p.Mount == 0)
                {
                    p.Duck = true;
                    p.Location.set_height_floor(Physics.PlayerDuckHeight[p.Character][p.State]);
                }
                else if(!p.Controls.Down && p.Duck)
                    UnDuck(Player[A]);
            }
        }

        if(p.Duck)
            p.SwordPoke = 1;
        else
            p.SwordPoke = -1;
    }
    else if(p.Controls.Up && p.Location.SpeedY < 0 && !p.Duck && p.SwordPoke == 0) // Link stabs up
    {
        if(!p.WetFrame && p.Frame == 10)
            TailSwipe(A, true, true, 1);
    }
    else if(p.Controls.Down && (p.Location.SpeedY > 0 && p.StandingOnNPC == 0 && p.Slope == 0) && !p.Duck && p.SwordPoke == 0) // Link stabs down
    {
        if(!p.WetFrame && p.Frame == 9)
            TailSwipe(A, true, true, 2);
    }
}


================================================
FILE: src/player/player_death_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "config.h"
#include "message.h"
#include "script/luna/lunacounter.h"

// updates the position of a player that has just died
void UpdatePlayerTimeToLive(int A)
{
    Player[A].TimeToLive += 1;

    if(Player[A].TimeToLive == 50 && !g_ClonedPlayerMode)
        gDeathCounter.MarkDeath();

    const Screen_t& screen = ScreenByPlayer(A);
    bool dynamic_screen = (screen.Type == ScreenTypes::Dynamic);
    bool shared_screen = (screen.Type == ScreenTypes::SharedScreen);
    bool split_screen = (screen.active_end() - screen.active_begin() > 1);
    bool normal_multiplayer = (dynamic_screen || shared_screen || split_screen || XMessage::GetStatus() != XMessage::Status::local);

    bool player_timer_done = (Player[A].TimeToLive >= 200);

    // checks if the dead player can move towards a target location
    bool player_can_move = (player_timer_done || shared_screen || !normal_multiplayer);

    // there was a guard here that has now been moved into the subclauses
    // if(Player[A].TimeToLive >= 200 || ScreenType != 5)
    int B = CheckNearestLiving(A);

    bool someone_else_alive = false;
    for(int o_A = 1; o_A <= numPlayers; o_A++)
    {
        if(o_A == A)
            continue;

        if(!Player[o_A].Dead || (BattleMode && BattleLives[o_A] > 0))
        {
            someone_else_alive = true;

            if(shared_screen && B == 0 && Player[o_A].TimeToLive < Player[A].TimeToLive)
                B = o_A;

            break;
        }
    }

    // allow smooth panning in cloned player mode
    if(g_config.multiplayer_pause_controls && !normal_multiplayer && g_ClonedPlayerMode && B == 0 && someone_else_alive)
        B = 1;

    // move dead player towards start point in BattleMode
    bool battle_respawn = (BattleMode && BattleLives[A] > 0 && someone_else_alive && BattleWinner == 0);

    if(battle_respawn && player_can_move)
    {
        // using B as a temporary slot here
        B = maxPlayers - 1;

        Player[B].Location.Width = Player[A].Location.Width;
        Player[B].Location.Height = Player[A].Location.Height;

        // eventually, check for valid starts
        constexpr int valid_start_count = 2;
        int use_start = (A - 1) % valid_start_count + 1;

        // NOTE, there is a bugfix here without a compat flag, previously the * 0.5 did not exist
        constexpr bool do_bugfix = true;
        Player[B].Location.X = PlayerStart[use_start].X + PlayerStart[use_start].Width / 2 - Player[A].Location.Width / (do_bugfix ? 2 : 1);
        Player[B].Location.Y = PlayerStart[use_start].Y + PlayerStart[use_start].Height - Player[A].Location.Height;
        CheckSection(B);
        if(Player[A].Section != Player[B].Section)
        {
            Player[A].Location = Player[B].Location;
            Player[A].Section = Player[B].Section;
        }
    }

    if(B > 0 && player_can_move) // Move camera to the other living players
    {
        // previously floats
        num_t A1, B1;
        if(shared_screen)
        {
            const vScreen_t& vscreen = screen.vScreen(screen.active_begin() + 1);
            A1 = (Player[B].Location.X - Player[A].Location.X) + (Player[B].Location.Width - Player[A].Location.Width) / 2;
            if(!g_config.multiplayer_pause_controls)
                B1 = ((-vscreen.Y + vscreen.Height / 2) - Player[A].Location.Y);
            else
                B1 = ((-vscreen.Y + vscreen.Height / 2) - Player[A].Location.Y - Player[A].Location.Height);
        }
        else if(normal_multiplayer)
        {
            A1 = (Player[B].Location.X - Player[A].Location.X) + (Player[B].Location.Width - Player[A].Location.Width) / 2;
            if(!g_config.multiplayer_pause_controls)
                B1 = Player[B].Location.Y - Player[A].Location.Y;
            else
                B1 = Player[B].Location.Y + Player[B].Location.Height - Player[A].Location.Y - Player[A].Location.Height;
        }
        else
        {
            const vScreen_t& vscreen = screen.vScreen(screen.active_begin() + 1);
            A1 = ((-vscreen.X + vscreen.Width / 2) - (Player[A].Location.X + Player[A].Location.Width / 2));
            if(!g_config.multiplayer_pause_controls)
                B1 = ((-vscreen.Y + vscreen.Height / 2) - Player[A].Location.Y);
            else
                B1 = ((-vscreen.Y + vscreen.Height / 2) - Player[A].Location.Y - Player[A].Location.Height);
        }

        num_t C1 = num_t::dist(A1, B1);
        num_t X, Y;
        if(C1 != 0)
        {
            X = A1.divided_by(C1);
            Y = B1.divided_by(C1);
        }
        else
        {
            X = 0;
            Y = 0;
        }
        Player[A].Location.X += X * 10;
        Player[A].Location.Y += Y * 10;

        // update Player A section (was previously guarded in ScreenType == 5)
        // code previously used Player 1 and Player 2 but this doesn't differ from that logic in cheat-free SMBX64
        if(normal_multiplayer && Player[A].Section != Player[B].Section)
        {
            C1 = 0;

            Player[A].Location.X = Player[B].Location.X;
            Player[A].Location.Y = Player[B].Location.Y;
            CheckSection(A);
        }

        if(C1 < 10 && C1 > -10)
        {
            KillPlayer(A);

            // new logic: mark which player A's ghost is following
            if(normal_multiplayer && !shared_screen && Player[A].Dead)
            {
                Player[A].Effect2 = -B;

                // new logic: fix player's location
                if(g_config.multiplayer_pause_controls)
                {
                    Player[A].Location.X = Player[B].Location.X + (Player[B].Location.Width - Player[A].Location.Width) / 2;
                    Player[A].Location.Y = Player[B].Location.Y + Player[B].Location.Height - Player[A].Location.Height;
                }
            }
        }
    }
    // start fadeout (65 / 3) frames before level end
    else if(!BattleMode && B == 0 && Player[A].TimeToLive == 200 - (65 / 3))
    {
        ProcessLastDead(); // Fade out screen if the last player died
    }
    else if((!BattleMode || B == 0) && player_timer_done) // ScreenType = 1
    {
        num_t old_LocX = Player[A].Location.X;
        num_t old_LocY = Player[A].Location.Y;
        KillPlayer(A); // Time to die

        // new logic: fix player's location
        if(g_config.multiplayer_pause_controls)
        {
            Player[A].Location.X = old_LocX;
            Player[A].Location.Y = old_LocY;
        }
    }
}

// updates the position of a player that is fully dead
void UpdatePlayerDead(int A)
{
    // safer than the below code, should always be used except for compatibility concerns
    if(numPlayers > 2 || g_config.multiplayer_pause_controls)
    {
        int B;

        // continue following currently-tracked player if possible
        if(Player[A].Effect2 < 0)
        {
            B = -Player[A].Effect2;

            // check if tracked dead player is gone
            if(B > numPlayers || Player[B].Dead || Player[B].TimeToLive > 0)
            {
                Player[A].Effect2 = 0;
                B = 0;

                // put player back in TimeToLive state if there are still other players
                if(CheckNearestLiving(A))
                {
                    Player[A].Dead = false;
                    Player[A].TimeToLive = 200;
                }
            }
        }
        else
            B = CheckNearestLiving(A);

        if(B)
        {
            Player[A].Location.X = Player[B].Location.X + (Player[B].Location.Width - Player[A].Location.Width) / 2;
            Player[A].Location.Y = Player[B].Location.Y + Player[B].Location.Height - Player[A].Location.Height;

            if(Player[B].Section != Player[A].Section)
            {
                int new_sect = Player[B].Section;

#ifdef THEXTECH_ENABLE_SDL_NET
                // do the music update thing here
                if(&ScreenByPlayer(A) == l_screen && &ScreenByPlayer(B) != l_screen)
                {
                    if(curMusic != bgMusic[new_sect] || (curMusic == 24 && CustomMusic[new_sect] != CustomMusic[Player[A].Section]))
                        StartMusic(new_sect);
                }
#endif

                Player[A].Section = new_sect;
            }
        }
    }
    else
    {
        if(A == 1)
        {
            Player[A].Location.X = Player[2].Location.X;
            Player[A].Location.Y = Player[2].Location.Y;
            CheckSection(A);
        }
        else
        {
            Player[A].Location.X = Player[1].Location.X;
            Player[A].Location.Y = Player[1].Location.Y;
            CheckSection(A);
        }
    }
}


================================================
FILE: src/player/player_effect.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef ENUM_PLAYER_EFFECT_HHH
#define ENUM_PLAYER_EFFECT_HHH

#include "global_constants.h"

enum PlayerState : vbint_t
{
    PLR_STATE_SMALL = 1,
    PLR_STATE_BIG = 2,
    PLR_STATE_FIRE = 3,
    PLR_STATE_LEAF = 4,
    PLR_STATE_STATUE = 5,
    PLR_STATE_HEAVY = 6,
    PLR_STATE_ICE = 7,
    PLR_STATE_AQUATIC = 8,
    PLR_STATE_POLAR = 9,
    PLR_STATE_CYCLONE = 10,
    PLR_STATE_SHELL = 11,
};

enum PlayerEffect : vbint_t
{
    PLREFF_NORMAL = 0,
    PLREFF_TURN_BIG = 1,
    PLREFF_TURN_SMALL = 2,
    PLREFF_WARP_PIPE = 3,
    PLREFF_RESPAWN = 6,
    PLREFF_WARP_DOOR = 7,
    PLREFF_WAITING = 8,
    PLREFF_NO_COLLIDE = 9,
    PLREFF_PET_INSIDE = 10,
    PLREFF_COOP_WINGS = 13,
    PLREFF_GROW_TO_STATE = 16,
    PLREFF_GROW_TO_STATE_END = 32,
    PLREFF_TURN_TO_STATE = 32,
    PLREFF_TURN_TO_STATE_END = 48,
    PLREFF_STATE_TO_BIG = 48,
    PLREFF_STATE_TO_BIG_END = 64,
    PLREFF_STONE = 500,

    // old SMBX 1.3 Effect IDs
    // PLREFF_TURN_FIRE = 4,
    // PLREFF_TURN_LEAF = 5,
    // PLREFF_TURN_STATUE = 11,
    // PLREFF_TURN_HEAVY = 12,
    // PLREFF_TURN_ICE = 41,
    // PLREFF_FIRE_TO_BIG = 227,
    // PLREFF_ICE_TO_BIG = 228,
};


#endif // ENUM_PLAYER_EFFECT_HHH


================================================
FILE: src/player/player_fairy_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "collision.h"
#include "effect.h"
#include "eff_id.h"
#include "sound.h"
#include "config.h"
#include "npc_traits.h"

#include "player/player_update_priv.h"

#include "main/trees.h"

void PlayerFairyTimerUpdate(int A)
{
    if(Player[A].FairyTime != 0 && Player[A].Fairy)
    {
        if(iRand(10) == 0)
            p_PlayerMakeFlySparkle(Player[A].Location);

        if(Player[A].FairyTime > 0)
            Player[A].FairyTime -= 1;

        if(Player[A].FairyTime != -1 && Player[A].FairyTime < 20 && Player[A].Character == 5 && PlayerFairyOnVine(A))
        {
            Player[A].FairyTime = 20;
            Player[A].FairyCD = 0;
        }
    }
    // lose fairy power
    else if(Player[A].Fairy)
    {
        PlaySoundSpatial(SFX_HeroFairy, Player[A].Location);
        Player[A].Immune = 10;
        Player[A].Effect = PLREFF_WAITING;
        Player[A].Effect2 = 4;
        Player[A].Fairy = false;
        SizeCheck(Player[A]);
        NewEffect(EFFID_SMOKE_S5, Player[A].Location);
        PlayerPush(A, 3);
    }
    else
        Player[A].FairyTime = 0;

    if(Player[A].FairyCD != 0 && (Player[A].Location.SpeedY == 0 || Player[A].Slope != 0 || Player[A].StandingOnNPC != 0 || Player[A].WetFrame))
        Player[A].FairyCD -= 1;
}

void PlayerFairyMovementX(int A)
{
    if(Player[A].Controls.Right)
    {
        if(Player[A].Location.SpeedX < 3)
            Player[A].Location.SpeedX += 0.15_n;
        if(Player[A].Location.SpeedX < 0)
            Player[A].Location.SpeedX += 0.1_n;
    }
    else if(Player[A].Controls.Left)
    {
        if(Player[A].Location.SpeedX > -3)
            Player[A].Location.SpeedX -= 0.15_n;
        if(Player[A].Location.SpeedX > 0)
            Player[A].Location.SpeedX -= 0.1_n;
    }
    else if(Player[A].Location.SpeedX > 0.1_n)
        Player[A].Location.SpeedX -= 0.1_n;
    else if(Player[A].Location.SpeedX < -0.1_n)
        Player[A].Location.SpeedX += 0.1_n;
    else
        Player[A].Location.SpeedX = 0;
}

void PlayerFairyMovementY(int A)
{
    Player[A].WetFrame = false;
    Player[A].Wet = 0;

    // this was previously two separate clauses in VB6 (split by whether FairyCD was 0)
    if(Player[A].Controls.Jump || Player[A].Controls.AltJump || Player[A].Controls.Up)
    {
        Player[A].Location.SpeedY -= 0.15_n;
        if(Player[A].Location.SpeedY > 0)
            Player[A].Location.SpeedY -= 0.1_n;
    }
    else if(Player[A].FairyCD != 0 || Player[A].Location.SpeedY < -0.1_n || Player[A].Controls.Down)
    {
        if(Player[A].Location.SpeedY < 3)
            Player[A].Location.SpeedY += Physics.PlayerGravity / 20;
        if(Player[A].Location.SpeedY < 0)
            Player[A].Location.SpeedY += Physics.PlayerGravity / 20;
        Player[A].Location.SpeedY += Physics.PlayerGravity / 10;
        if(Player[A].Controls.Down)
            Player[A].Location.SpeedY += 0.05_n;
    }
    else if(Player[A].Location.SpeedY > 0.1_n)
        Player[A].Location.SpeedY -= 0.15_n;
    else
        Player[A].Location.SpeedY = 0;

    if(Player[A].Location.SpeedY > 4)
        Player[A].Location.SpeedY = 4;
    else if(Player[A].Location.SpeedY < -3)
        Player[A].Location.SpeedY = -3;
}


================================================
FILE: src/player/player_movement_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "sound.h"
#include "player.h"
#include "config.h"
#include "effect.h"
#include "eff_id.h"
#include "phys_env.h"

#include "player/player_update_priv.h"
#include "npc/npc_cockpit_bits.h"

void s_playerSlopeMomentum(int A);

void PlayerMovementX(int A, tempf_t& cursed_value_C)
{
    bool is_grounded = (Player[A].Location.SpeedY == 0 || Player[A].Slope != 0 || Player[A].StandingOnNPC != 0);
    bool aquatic_jumps = (Player[A].State == PLR_STATE_AQUATIC && Player[A].Character != 5 && !Player[A].Mount && !Player[A].HoldingNPC && (is_grounded || (Player[A].Duck && !Player[A].Jump)));

    // Modify player's speed if he is running up/down hill
    tempf_t speedVar = 1; // Speed var is a percentage of the player's speed
    if(Player[A].Slope > 0)
    {
        if(Block[Player[A].Slope].Location.Width == 0)
        {
            // SMBX 1.3 would have crashed here
        }
        else if(
                (Player[A].Location.SpeedX > 0 && BlockSlope[Block[Player[A].Slope].Type] == -1) ||
                (Player[A].Location.SpeedX < 0 && BlockSlope[Block[Player[A].Slope].Type] == 1)
                )
            speedVar = (tempf_t)(1 - Block[Player[A].Slope].Location.Height / (int_ok)Block[Player[A].Slope].Location.Width / 2);
        else if(!Player[A].Slide)
            speedVar = (tempf_t)(1 + (Block[Player[A].Slope].Location.Height / (int_ok)Block[Player[A].Slope].Location.Width / 4));
    }

    if(Player[A].Stoned) // if statue form reset to normal
        speedVar = 1;

    if(Player[A].Character == 3)
        speedVar = (tempf_t)((num_t)speedVar * 0.93_r);

    if(Player[A].Character == 4)
        speedVar = (tempf_t)((num_t)speedVar * 1.07_r);

    if(Player[A].State == PLR_STATE_AQUATIC)
        speedVar = (tempf_t)((num_t)speedVar * 0.87_r);

    if(Player[A].State == PLR_STATE_POLAR && Player[A].Slippy)
        speedVar += (tempf_t)0.05_n;

    // modify speedvar to slow the player down under water
    if(Player[A].Wet > 0)
    {
        if(is_grounded)
            speedVar /= 4; // if walking go really slow
        else
            speedVar /= 2; // if swimming go slower faster the walking
    }

    // special logic for shell: just keep going!
    if(((Player[A].State == PLR_STATE_SHELL && !Player[A].Wet) || Player[A].State == PLR_STATE_POLAR) && Player[A].Controls.Run && !Player[A].HoldingNPC && !Player[A].Mount)
    {
        // 7.1 is the NPC shellspeed
        num_t shell_speed = (num_t)speedVar * 7.1_r;

        if(shell_speed >= 7.5_n)
            shell_speed = 7.5_n;

        bool can_begin = is_grounded;
        if(Player[A].Slope && BlockSlope[Block[Player[A].Slope].Type] != Player[A].Direction)
            can_begin = false;

        num_t stop_speed = 0.5_n;
        if(Player[A].Slope)
        {
            // allow turning around on slopes
            stop_speed = 0.0_n;
        }

        num_t start_speed = shell_speed;

        if(Player[A].State == PLR_STATE_POLAR)
        {
            shell_speed -= 0.75_n;
            if(Player[A].Slippy)
                shell_speed += 3;

            // allow starting quickly
            start_speed -= 2;

            // or extremely quickly on a slope or ice
            if(Player[A].Slope || Player[A].Slippy)
                start_speed = 0.5_n;

            // require holding down to start
            if(!Player[A].Controls.Down)
                start_speed = 128;
        }

        // start rolling
        if(can_begin && num_t::abs(Player[A].Location.SpeedX) >= start_speed)
            Player[A].Rolling = true;

        // keep rolling
        if(Player[A].Rolling && (!is_grounded || num_t::abs(Player[A].Location.SpeedX) > stop_speed))
        {
            if(!Player[A].Duck)
            {
                Player[A].Duck = true;
                SizeCheck(Player[A]);
            }

            Player[A].Direction = (Player[A].Location.SpeedX > 0) ? 1 : -1;

            // necessarily in air in this case, use controls to pick direction if possible, otherwise don't change speed
            if(Player[A].Location.SpeedX == 0)
            {
                if(Player[A].Controls.Right)
                    Player[A].Direction = 1;
                else if(!Player[A].Controls.Left)
                    return;
            }

            if(Player[A].Slope)
                s_playerSlopeMomentum(A);
            else
                Player[A].Location.SpeedX = (Player[A].Location.SpeedX * 127 + Player[A].Direction * shell_speed) / 128;

            return;
        }

        // stop rolling
        // allow the player to go faster if they aren't a shell yet
        if(Player[A].State == PLR_STATE_SHELL)
            speedVar = speedVar * 5 / 4;
    }

    if(Player[A].Rolling)
        Player[A].Slide = false;

    Player[A].Rolling = false;

    // ducking for link
    if(Player[A].Duck && Player[A].WetFrame)
    {
        if(!is_grounded)
            UnDuck(Player[A]);
    }

    // the following code controls the players ability to duck
    if(!(Player[A].Character == 5 && (!is_grounded || Player[A].FireBallCD != 0))) // Link can't duck/unduck in air
    {
        if(Player[A].Controls.Down && !Player[A].SpinJump &&
           !Player[A].Stoned && Player[A].Vine == 0 && !Player[A].Slide &&
           (Player[A].Slope == 0 || Player[A].Mount > 0 || Player[A].WetFrame ||
            Player[A].Character >= 3 || Player[A].GrabTime > 0) &&
           ((!Player[A].WetFrame || Player[A].Character >= 3) ||
            is_grounded || Player[A].Mount == 1) &&
           !Player[A].Fairy && !Player[A].ShellSurf && !Player[A].Driving)
        {
            Player[A].Bumped = false;
            if(Player[A].Mount != 2) // cant duck in the clown car
            {
                if(Player[A].Mount == 3) // duck on a yoshi
                {
                    if(!Player[A].Duck)
                    {
                        Player[A].Location.set_height_floor(31);
                        Player[A].Duck = true;
                        // If nPlay.Online = True And A = nPlay.MySlot + 1 Then Netplay.sendData Netplay.PutPlayerLoc(nPlay.MySlot) & "1q" & A & LB
//                                        if(nPlay.Online == true && A == nPlay.MySlot + 1)
//                                            Netplay::sendData "1q" + std::to_string(A) + LB;
                    }
                }
                else // normal duck
                {
                    if((Player[A].State > 1 && Player[A].HoldingNPC <= 0) || (Player[A].Character == 3 || Player[A].Character == 4 || Player[A].Character == 5))
                    {
                        if(!Player[A].Duck && Player[A].TailCount == 0) // Player ducks
                        {
                            if(Player[A].Character == 5)
                                Player[A].SwordPoke = 0;
                            Player[A].Duck = true;
                            Player[A].Location.set_height_floor(Physics.PlayerDuckHeight[Player[A].Character][Player[A].State]);
//                                            if(nPlay.Online == true && A == nPlay.MySlot + 1)
//                                                Netplay::sendData "1q" + std::to_string(A) + LB;
                        }
                    }
                    else if(Player[A].Mount == 1)
                    {
                        if(!Player[A].Duck && Player[A].TailCount == 0) // Player ducks
                        {
                            Player[A].Duck = true;
                            Player[A].Location.Height = Physics.PlayerDuckHeight[1][2];
                            Player[A].Location.Y += -Physics.PlayerDuckHeight[1][2] + Physics.PlayerHeight[1][2];
//                                            if(nPlay.Online == true && A == nPlay.MySlot + 1)
//                                                Netplay::sendData "1q" + std::to_string(A) + LB;
                        }
                    }
                }
            }
        }
        else
        {
            if(Player[A].Duck)
                UnDuck(Player[A]);
        }
    }

    qdec_t local_C = 1.0_r;
    cursed_value_C = 1;
    // If .Character = 5 Then C = 0.94
    if(Player[A].Character == 5)
    {
        cursed_value_C = (tempf_t)0.95_n;
        local_C = 0.95_r;
    }

    // deduplicated (was previously separate sections for holding Left and Right)
    if((Player[A].Controls.Left || Player[A].Controls.Right) &&
       !Player[A].JumpOffWall &&
       !aquatic_jumps &&
       ((!Player[A].Duck && Player[A].GrabTime == 0) ||
        !is_grounded ||
        Player[A].Mount == 1)
    )
    {
        int dir = (Player[A].Controls.Left) ? -1 : 1;
        Player[A].Bumped = false;

        if(Player[A].Controls.Run || dir * Player[A].Location.SpeedX < Physics.PlayerWalkSpeed * (num_t)speedVar || Player[A].Character == 5)
        {
            // turning around or not yet walking
            if(dir * Player[A].Location.SpeedX < Physics.PlayerWalkSpeed * (num_t)speedVar * local_C)
            {
                if(Player[A].Character == 2) // LUIGI
                    Player[A].Location.SpeedX += dir * num_t::from_double(-0.1 * 0.175);
                else if(Player[A].Character == 3) // PEACH
                    Player[A].Location.SpeedX += dir * num_t::from_double(-0.05 * 0.175);
                else if(Player[A].Character == 4) // toad
                    Player[A].Location.SpeedX += dir * num_t::from_double(0.05 * 0.175);

                Player[A].Location.SpeedX += dir * (num_t)speedVar / 10;
            }
            // running
            else
            {
                if(Player[A].Character == 2) // LUIGI
                    Player[A].Location.SpeedX += dir * num_t::from_double(-0.05 * 0.175);
                else if(Player[A].Character == 3) // PEACH
                    Player[A].Location.SpeedX += dir * num_t::from_double(-0.025 * 0.175);
                else if(Player[A].Character == 4) // toad
                    Player[A].Location.SpeedX += dir * num_t::from_double(0.025 * 0.175);

                if(Player[A].Character == 5) // Link
                    Player[A].Location.SpeedX += dir * (num_t)speedVar / 40;
                else // Mario
                    Player[A].Location.SpeedX += dir * (num_t)speedVar / 20;
            }

            // turning around
            if(dir * Player[A].Location.SpeedX < 0)
            {
                if(Player[A].Character == 2) // LUIGI
                    Player[A].Location.SpeedX += dir * num_t::from_double(-0.18 * 0.29 + 0.18);
                else if(Player[A].Character == 3) // PEACH
                    Player[A].Location.SpeedX += dir * num_t::from_double(-0.09 * 0.29 + 0.18);
                else if(Player[A].Character == 4) // toad
                    Player[A].Location.SpeedX += dir * num_t::from_double(0.09 * 0.29 + 0.18);
                else
                    Player[A].Location.SpeedX += dir * 0.18_n;

                if(SuperSpeed)
                    Player[A].Location.SpeedX = Player[A].Location.SpeedX * 0.95_r;
            }
        }

        if(SuperSpeed && Player[A].Controls.Run)
            Player[A].Location.SpeedX += dir * 0.1_n;
    }
    else
    {
        if(is_grounded || Player[A].WetFrame) // Only lose speed when not in the air
        {
            // direct slowdown -- add extra friction during aquatic jumps
            auto slowdown = (num_t)speedVar * ((aquatic_jumps) ? 0.14_r : 0.07_r);
            if(Player[A].Location.SpeedX > 0)
                Player[A].Location.SpeedX -= slowdown;
            if(Player[A].Location.SpeedX < 0)
                Player[A].Location.SpeedX += slowdown;

            // ratio-based slowdown
            if(Player[A].Character == 2) // LUIGI
                Player[A].Location.SpeedX *= 1.003_r;
            else if(Player[A].Character == 3) // PEACH
                Player[A].Location.SpeedX *= 1.0015_r;
            else if(Player[A].Character == 4) // toad
                Player[A].Location.SpeedX *= 0.9985_r;

            if(SuperSpeed || (aquatic_jumps && Player[A].Controls.Run))
                Player[A].Location.SpeedX *= 0.95_r;
        }

        if(Player[A].Location.SpeedX > -0.18_n && Player[A].Location.SpeedX < 0.18_n)
        {
            Player[A].Bumped = false;
            Player[A].Location.SpeedX = 0;
        }
    }

    // hard speed cap
    if(Player[A].Location.SpeedX < -16)
        Player[A].Location.SpeedX = -16;
    else if(Player[A].Location.SpeedX > 16)
        Player[A].Location.SpeedX = 16;

    if(Player[A].WarpShooted &&
       Player[A].Location.SpeedX < Physics.PlayerRunSpeed * (num_t)speedVar &&
       Player[A].Location.SpeedX > -Physics.PlayerRunSpeed * (num_t)speedVar)
    {
        Player[A].WarpShooted = false;
    }

    // soft speed cap
    if(!Player[A].WarpShooted && (Player[A].Controls.Run || Player[A].Character == 5))
    {
        if(Player[A].Location.SpeedX >= Physics.PlayerRunSpeed * (num_t)speedVar)
        {
            if(!SuperSpeed)
                Player[A].Location.SpeedX = Physics.PlayerRunSpeed * (num_t)speedVar;
        }
        else if(Player[A].Location.SpeedX <= -Physics.PlayerRunSpeed * (num_t)speedVar)
        {
            if(!SuperSpeed)
                Player[A].Location.SpeedX = -Physics.PlayerRunSpeed * (num_t)speedVar;
        }
//                        else  // REDURANT GARBAGE
//                        {
//                        }
    }
    else
    {
        // smooth run->walk deceleration
        // (note: this is an SMBX 1.3 bug, the correct expression would be Physics.PlayerWalkSpeed * speedVar + 0.1)
        if(Player[A].Location.SpeedX > Physics.PlayerWalkSpeed + (num_t)speedVar / 10)
            Player[A].Location.SpeedX -= 0.1_n;
        else if(Player[A].Location.SpeedX < -Physics.PlayerWalkSpeed - (num_t)speedVar / 10)
            Player[A].Location.SpeedX += 0.1_n;
        else if(num_t::abs(Player[A].Location.SpeedX) > Physics.PlayerWalkSpeed * (num_t)speedVar)
        {
            if(Player[A].Location.SpeedX > 0)
                Player[A].Location.SpeedX = Physics.PlayerWalkSpeed * (num_t)speedVar;
            else
                Player[A].Location.SpeedX = -Physics.PlayerWalkSpeed * (num_t)speedVar;
        }
    }

    if(Player[A].Mount == 1 && Player[A].MountType == 3)
    {
        Player[A].CanFly2 = true;
        Player[A].FlyCount = 1000;
    }

    if(Player[A].Mount != 3)
        Player[A].YoshiBlue = false;

    if(FlyForever && !Player[A].GroundPound)
    {
        if(Player[A].Mount == 3)
            Player[A].YoshiBlue = true;

        if((Player[A].State == 4 || Player[A].State == 5) || (Player[A].YoshiBlue && Player[A].Mount == 3) || (Player[A].Mount == 1 && Player[A].MountType == 3))
            Player[A].CanFly2 = true;
        else
        {
            Player[A].CanFly2 = false;
            Player[A].CanFly = false;
            Player[A].FlyCount = 0;
            Player[A].YoshiBlue = false;
        }
    }

    // Racoon/Tanooki Mario.  this handles the ability to fly after running
    if((Player[A].State == 4 || Player[A].State == 5) && Player[A].Wet == 0)
    {
        // note: RunCount was previously a float, so its values have been multiplied by 10 everywhere
        bool is_running = (num_t::abs(Player[A].Location.SpeedX) >= Physics.PlayerRunSpeed ||
            (Player[A].Character == 3 && num_t::abs(Player[A].Location.SpeedX) >= 5.579_n)); // Rounding error of SpeedX makes an evil here (FIXME: does this match VB6?)

        if( (Player[A].CanFly2 ||
             is_grounded) &&
            is_running)
        {
            Player[A].RunCount += 10;
        }
        else if(!is_running)
        {
            Player[A].RunCount -= 3;
        }

        if(Player[A].RunCount >= 350 && Player[A].Character == 1)
        {
            Player[A].CanFly = true;
            Player[A].RunCount = 350;
        }
        else if(Player[A].RunCount >= 400 && Player[A].Character == 2)
        {
            Player[A].CanFly = true;
            Player[A].RunCount = 400;
        }
        else if(Player[A].RunCount >= 800 && Player[A].Character == 3)
        {
            Player[A].CanFly = true;
            Player[A].RunCount = 800;
        }
        else if(Player[A].RunCount >= 600 && Player[A].Character == 4)
        {
            Player[A].CanFly = true;
            Player[A].RunCount = 600;
        }
        else if(Player[A].RunCount >= 100 && Player[A].Character == 5) // link flying
        {
            Player[A].CanFly = true;
            Player[A].RunCount = 100;
        }
        else
        {
            Player[A].CanFly = false;
            if(Player[A].RunCount < 0)
                Player[A].RunCount = 0;
        }
    }

    if(is_grounded)
        Player[A].FlyCount = 1;

    if(Player[A].FlyCount > 1)
        Player[A].FlyCount -= 1;
    else if(Player[A].FlyCount == 1)
    {
        Player[A].CanFly2 = false;
        Player[A].FlyCount = 0;
    }
}

void s_playerSlopeMomentum(int A)
{
    if(Block[Player[A].Slope].Location.Width == 0)
    {
        // SMBX 1.3 would have crashed here
        return;
    }

    // Angle = 1 / (Block[Player[A].Slope].Location.Width / Block[Player[A].Slope].Location.Height);
    num_t Angle = Block[Player[A].Slope].Location.Height / (int_ok)Block[Player[A].Slope].Location.Width;
    num_t slideSpeed = Angle * BlockSlope[Block[Player[A].Slope].Type] / 10;

    num_t add_uphill = (Player[A].Rolling) ? slideSpeed : slideSpeed * 2;

    if(slideSpeed > 0 && Player[A].Location.SpeedX < 0)
        Player[A].Location.SpeedX += add_uphill;
    else if(slideSpeed < 0 && Player[A].Location.SpeedX > 0)
        Player[A].Location.SpeedX += add_uphill;
    else
        Player[A].Location.SpeedX += slideSpeed;
}

void PlayerSlideMovementX(int A)
{
    if(Player[A].Slope > 0)
        s_playerSlopeMomentum(A);
    else if(Player[A].Location.SpeedY == 0 || Player[A].StandingOnNPC != 0)
    {
        if(Player[A].Location.SpeedX > 0.2_n)
            Player[A].Location.SpeedX -= 0.1_n;
        else if(Player[A].Location.SpeedX < -0.2_n)
            Player[A].Location.SpeedX += 0.1_n;
        else
        {
            Player[A].Location.SpeedX = 0;
            Player[A].Slide = false;
        }
    }

    if(Player[A].Location.SpeedX > 11)
        Player[A].Location.SpeedX = 11;

    if(Player[A].Location.SpeedX < -11)
        Player[A].Location.SpeedX = -11;

    if(Player[A].Controls.Jump || Player[A].Controls.AltJump)
        Player[A].Slide = false;
}

void PlayerCockpitMovementX(int A)
{
    if(Player[A].Duck)
        UnDuck(Player[A]);

    Player[A].Driving = false;
    if(Player[A].StandingOnNPC > 0)
    {
        NPC[Player[A].StandingOnNPC].Special4 = NPC_COCKPIT_DRIVING;

        if(Player[A].Controls.Left)
            NPC[Player[A].StandingOnNPC].Special4 |= NPC_COCKPIT_LEFT;
        else if(Player[A].Controls.Right)
            NPC[Player[A].StandingOnNPC].Special4 |= NPC_COCKPIT_RIGHT;

        if(Player[A].Controls.Up)
            NPC[Player[A].StandingOnNPC].Special4 |= NPC_COCKPIT_UP;
        else if(Player[A].Controls.Down)
            NPC[Player[A].StandingOnNPC].Special4 |= NPC_COCKPIT_DOWN;
    }

    Player[A].Location.SpeedX = 0;
}

void PlayerMovementY(int A)
{
    bool aquatic_jumps = (Player[A].State == PLR_STATE_AQUATIC && Player[A].Character != 5 && !Player[A].Mount && !Player[A].HoldingNPC);

    // this gives the player the bounce when in the kurbio's shoe, or newly when in aquatic hopping state
    if(Player[A].Mount == 1 || (aquatic_jumps && !Player[A].Duck && !Player[A].Slide))
    {
        num_t floor_speed = NPC[Player[A].StandingOnNPC].Location.SpeedX + (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed;

        if((Player[A].Controls.Left || Player[A].Controls.Right) && (!aquatic_jumps || Player[A].CanAltJump))
        {
            if(Player[A].Location.SpeedY == 0 || Player[A].Slope > 0 || (Player[A].StandingOnNPC != 0 && Player[A].Location.Y + Player[A].Location.Height >= NPC[Player[A].StandingOnNPC].Location.Y - NPC[Player[A].StandingOnNPC].Location.SpeedY))
            {
                num_t rel_speed = Player[A].Location.SpeedX - floor_speed;
                if(aquatic_jumps && !SuperSpeed && num_t::abs(rel_speed) > 0.18_n)
                {
                    // wait for player to get some friction
                }
                else if((Player[A].Controls.Left && rel_speed <= 0) || (Player[A].Controls.Right && rel_speed >= 0))
                {
                    Player[A].Location.SpeedY = -4.1_n + NPC[Player[A].StandingOnNPC].Location.SpeedY;

                    if(aquatic_jumps)
                    {
                        Player[A].StandingOnNPC = 0;
                        Player[A].Direction = (Player[A].Controls.Left) ? -1 : 1;
                        Player[A].Location.SpeedX = Player[A].Direction * ((Player[A].Controls.Run) ? 3 : 1.5_n) + floor_speed;

                        if(SuperSpeed)
                            Player[A].Location.SpeedX *= 2;
                    }
                }
                else
                    PlaySoundSpatial(SFX_Skid, Player[A].Location);

                // allow jump during hop
                if(!aquatic_jumps || (Player[A].CanJump && Player[A].CanAltJump))
                    Player[A].MountSpecial = 1;
            }
        }

        if(Player[A].Location.SpeedY < -4.1_n)
            Player[A].MountSpecial = 0;
        else if(Player[A].Location.SpeedY > 4.1_n)
            Player[A].MountSpecial = 0;

        if(Player[A].Controls.Jump && Player[A].MountSpecial == 1 && Player[A].CanJump)
        {
            Player[A].Location.SpeedY = 0;

            if(!aquatic_jumps)
                Player[A].StandUp = true;
            else
                Player[A].MountSpecial = 0;
        }
    }
    else if(Player[A].State == PLR_STATE_AQUATIC && !Player[A].Mount)
        Player[A].MountSpecial = 0;

    if(Player[A].Mount == 1)
    {
        if(Player[A].Controls.AltJump && Player[A].CanAltJump) // check to see if the player should jump out of the shoe
            PlayerDismount(A);
    }
    else if(Player[A].Mount == 3)
    {
        if(Player[A].Controls.AltJump && Player[A].CanAltJump) // jump off of yoshi
            PlayerDismount(A);
    }

    if((Player[A].Location.SpeedY == 0 || (Player[A].Jump > 0 && !Player[A].JumpOffWall) || Player[A].Vine > 0) && Player[A].FloatTime == 0 && !(Player[A].State == PLR_STATE_CYCLONE && Player[A].SpinJump)) // princess float
        Player[A].CanFloat = true;

    if(Player[A].Wet > 0 || Player[A].WetFrame)
        Player[A].CanFloat = false;

    bool has_wall_traction = CanWallJump && (Player[A].Pinched.Left2 == 2 || Player[A].Pinched.Right4 == 2) && !Player[A].SpinJump && (!Player[A].SlippyWall || Player[A].State == PLR_STATE_POLAR) && Player[A].HoldingNPC == 0 && Player[A].Mount == 0 && !Player[A].Duck && !(Player[A].State == PLR_STATE_CYCLONE && !Player[A].DoubleJump);

    // handles the regular jump
    if(Player[A].Controls.Jump || (Player[A].Controls.AltJump &&
       ((Player[A].Character > 2 && Player[A].Character != 4) || Player[A].Quicksand > 0 || Player[A].Rolling || aquatic_jumps || g_config.disable_spin_jump) &&
       Player[A].CanAltJump))
    {
        num_t tempSpeed;
        if(Player[A].Location.SpeedX > 0)
            tempSpeed = Player[A].Location.SpeedX / 5; // tempSpeed gives the player a height boost when jumping while running, based off his SpeedX
        else
            tempSpeed = -Player[A].Location.SpeedX / 5;

        if(Player[A].ShellSurf) // this code modifies the jump based on him riding a shell
        {
            if(NPC[Player[A].StandingOnNPC].Location.SpeedY == 0 || NPC[Player[A].StandingOnNPC].Slope > 0)
            {
                if(Player[A].CanJump)
                {
                    PlaySoundSpatial(SFX_Whip, Player[A].Location); // Jump sound
                    Player[A].Jump = Physics.PlayerJumpHeight * 3 / 5;
                    NPC[Player[A].StandingOnNPC].Location.SpeedY = Physics.PlayerJumpVelocity * 0.9_r;
                }
            }
            else if(Player[A].Jump > 0)
                NPC[Player[A].StandingOnNPC].Location.SpeedY = Physics.PlayerJumpVelocity * 0.9_r;
        }
        // if not surfing a shell then proceed like normal
        else
        {
            if((Player[A].Vine > 0 || Player[A].Location.SpeedY == 0 || Player[A].StandingOnNPC != 0 ||
                MultiHop || Player[A].Slope > 0 || (Player[A].Location.SpeedY > 0 && Player[A].Quicksand > 0)) && Player[A].CanJump)
            {
                PlaySoundSpatial(SFX_Jump, Player[A].Location); // Jump sound
                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - tempSpeed;
                Player[A].Jump = Physics.PlayerJumpHeight;

                if(Player[A].Character == 4 && (Player[A].State == 4 || Player[A].State == 5) && !Player[A].SpinJump)
                    Player[A].DoubleJump = true;

                if(Player[A].Character == 2)
                    Player[A].Jump += 3;

                if(Player[A].SpinJump)
                    Player[A].Jump -= 6;

                if(aquatic_jumps)
                {
                    Player[A].Jump += 10;
                    Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
                    Player[A].Location.SpeedX /= 4;
                    Player[A].MountSpecial = 0;
                }
                else if(Player[A].State == PLR_STATE_AQUATIC)
                    Player[A].Jump += 4;

                if(Player[A].StandingOnNPC > 0 && !FreezeNPCs)
                {
                    if(NPC[Player[A].StandingOnNPC].Type != NPCID_ITEM_BURIED)
                        Player[A].Location.SpeedX += -NPC[Player[A].StandingOnNPC].Location.SpeedX;
                }

                Player[A].StandingOnNPC = 0; // the player can't stand on an NPC after jumping

                if(Player[A].CanFly) // let's the player fly if the conditions are met
                {
                    Player[A].StandingOnNPC = 0;
                    Player[A].Jump = 30;
                    if(Player[A].Character == 2)
                        Player[A].Jump += 3;
                    if(Player[A].SpinJump)
                        Player[A].Jump -= 6;
                    Player[A].CanFly = false;
                    Player[A].RunCount = 0;
                    Player[A].CanFly2 = true;

                    if(Player[A].Character == 2) // luigi doesn't fly as long as mario
                        Player[A].FlyCount = 300; // Length of flight time
                    else if(Player[A].Character == 3) // special handling for peach
                    {
                        Player[A].FlyCount = 0;
                        Player[A].RunCount = 800; // multiplied by 10 vs VB6 code, since it's an int now
                        Player[A].CanFly2 = false;
                        Player[A].Jump = 70;
                        Player[A].CanFloat = true;
                        Player[A].FlySparks = true;
                    }
#if 0
                    // FIXME: Duplicated "Character == 3" condition branch [PVS Studio]
                    else if(Player[A].Character == 3) // special handling for peach
                        Player[A].FlyCount = 280; // Length of flight time
#endif
                    else
                        Player[A].FlyCount = 320; // Length of flight time
                }
            }
            else if(has_wall_traction && Player[A].CanJump)
            {
                NewEffect(EFFID_WHACK, newLoc(Player[A].Location.X + Player[A].Location.Width / 2 - 16, Player[A].Location.Y + Player[A].Location.Height - 16));
                PlaySoundSpatial(SFX_Jump, Player[A].Location); // Jump sound
                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
                Player[A].Location.SpeedX -= 5 * Player[A].Direction;
                Player[A].Location.X += Player[A].Location.SpeedX;
                Player[A].Jump = 8;
                Player[A].JumpOffWall = true;

                if(Player[A].Character == 2)
                    Player[A].Jump += 3;
            }
            else if(Player[A].Jump > 0) // controls the height of the jump
            {
                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - tempSpeed;
                if(Player[A].Jump > 20)
                {
                    if(Player[A].Jump > 40)
                        Player[A].Location.SpeedY += -(40 - 20) * 0.2_n;
                    else
                        Player[A].Location.SpeedY += -(Player[A].Jump - 20) * 0.2_n;
                }
            }
            else if(Player[A].CanFly2)
            {
                if(Player[A].Location.SpeedY > Physics.PlayerJumpVelocity / 2)
                {
                    Player[A].Location.SpeedY -= 1;
                    Player[A].CanPound = true;
                    if(Player[A].YoshiBlue || (Player[A].Mount == 1 && Player[A].MountType == 3))
                        PlaySoundSpatial(SFX_PetTongue, Player[A].Location);
                }
            }
        }

        if(!(aquatic_jumps && Player[A].MountSpecial))
            Player[A].CanJump = false;
    }
    else
        Player[A].CanJump = true;

    if(Player[A].Jump > 0)
        Player[A].Slope = 0;

    bool is_supported = (Player[A].StandingOnNPC != 0 || Player[A].Slope != 0 || Player[A].Location.SpeedY == 0 || Player[A].Wet || Player[A].Vine || Player[A].WetFrame);
    // cyclone: allow double jump as save after falling off cliff
    if(Player[A].State == PLR_STATE_CYCLONE && !Player[A].SpinJump)
    {
        if(is_supported)
            Player[A].DoubleJump = true;
    }
    // this is the old condition which subtly differs from the supported condition tested above and below
    else if(Player[A].SpinJump || (Player[A].State != 4 && Player[A].State != 5) || Player[A].StandingOnNPC > 0 || Player[A].Slope > 0 || Player[A].Location.SpeedY == 0)
        Player[A].DoubleJump = false;

    // double jump code
    if(Player[A].DoubleJump && Player[A].Jump == 0 && !is_supported && !Player[A].Fairy && !Player[A].CanFly2)
    {
        if(Player[A].State == PLR_STATE_CYCLONE)
        {
            if(!Player[A].Mount && Player[A].Controls.AltJump && Player[A].CanAltJump)
            {
                PlaySoundSpatial(SFX_Whip, Player[A].Location);
                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
                Player[A].Jump = 32;
                Player[A].DoubleJump = false;

                if(Player[A].Character != 5)
                {
                    Player[A].SpinJump = true;
                    UnDuck(Player[A]);
                }
            }
        }
        else if(Player[A].Controls.Jump && Player[A].JumpRelease)
        {
            PlaySoundSpatial(SFX_Jump, Player[A].Location);
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
            Player[A].Jump = 10;
            Player[A].DoubleJump = false;
            Location_t tempLocation = Player[A].Location;
            tempLocation.Y = Player[A].Location.Y + Player[A].Location.Height - EffectHeight[EFFID_SPARKLE] * 0.5_n + Player[A].Location.SpeedY;
            tempLocation.Height = EffectHeight[EFFID_SPARKLE];
            tempLocation.Width = EffectWidth[EFFID_SPARKLE];
            tempLocation.X = Player[A].Location.X;

            for(int B = 1; B <= 10; B++)
            {
                NewEffect(EFFID_SPARKLE, tempLocation);
                Effect[numEffects].Location.SpeedX = (dRand() * 3) - 1.5_n;
                Effect[numEffects].Location.SpeedY = (dRand() / 2) + (1.5_n - num_t::abs(Effect[numEffects].Location.SpeedX)) / 2;
                Effect[numEffects].Location.SpeedX += -Player[A].Location.SpeedX / 5;
            }
        }
    }



#if 0
    // never set since SMBX 1.3, see dead code below
    if(Player[A].NoShellKick > 0) // countdown for the next time the player kicks a turtle shell
        Player[A].NoShellKick--;
#endif

    if(Player[A].ShellSurf)
    {
        if(Player[A].Mount != 0)
            Player[A].ShellSurf = false;

        // FIXME: SOME DEAD CODE BECAUSE OF "1 == 2"
#if 0
        if(Player[A].Direction != NPC[Player[A].StandingOnNPC].Direction && 1 == 2)
        {
            Player[A].ShellSurf = false;
            Player[A].Location.SpeedY = NPC[Player[A].StandingOnNPC].Location.SpeedY;
            if(Player[A].Location.SpeedY > 0)
                Player[A].Location.SpeedY = 0;
            PlaySoundSpatial(SFX_Skid, Player[A].Location);
            NPC[Player[A].StandingOnNPC].CantHurt = 30;
            NPC[Player[A].StandingOnNPC].CantHurtPlayer = A;
            Player[A].Location.SpeedX = NPC[Player[A].StandingOnNPC].Location.SpeedX / 2;
            Player[A].StandingOnNPC = 0;
            Player[A].NoShellKick = 30;
        }
        else
#endif
        {
            if(iRand(10) >= 3)
            {
                Location_t tempLocation;
                tempLocation.Y = Player[A].Location.Y + Player[A].Location.Height - 2 + dRand().times(NPC[Player[A].StandingOnNPC].Location.Height - 8) + 4;
                tempLocation.X = Player[A].Location.X - 4 + dRand() * ((int)Player[A].Location.Width - 8) + 4 - 8 * Player[A].Direction;
                NewEffect(EFFID_SPARKLE, tempLocation, 1, ShadowMode);
                Effect[numEffects].Frame = iRand(3);
                Effect[numEffects].Location.SpeedY = (Player[A].Location.Y + Player[A].Location.Height + NPC[Player[A].StandingOnNPC].Location.Height / 32 - tempLocation.Y + 12) / 20;
            }
        }

        if(NPC[Player[A].StandingOnNPC].Wet == 2)
        {
            if(NPC[Player[A].StandingOnNPC].Type == NPCID_FLIPPED_RAINBOW_SHELL)
                NPC[Player[A].StandingOnNPC].Special4 = 1;
            NPC[Player[A].StandingOnNPC].Location.SpeedY += -Physics.NPCGravity * 1.5_rb;
        }
    }

    // START ALT JUMP - this code does the player's spin jump
    if(Player[A].Controls.AltJump && (Player[A].Character == 1 || Player[A].Character == 2 || Player[A].Character == 4 ||
                                      (g_config.fix_char3_escape_shell_surf && Player[A].Character == 3 && Player[A].ShellSurf))
                                  && (!g_config.disable_spin_jump || Player[A].ShellSurf))
    {
        num_t tempSpeed;
        if(Player[A].Location.SpeedX > 0)
            tempSpeed = Player[A].Location.SpeedX / 5;
        else
            tempSpeed = -Player[A].Location.SpeedX / 5;

        if((Player[A].Vine > 0 || Player[A].Location.SpeedY == 0 || Player[A].StandingOnNPC != 0 || Player[A].Slope > 0 || MultiHop) && Player[A].CanAltJump) // Player Jumped
        {
            if(!Player[A].Duck && !aquatic_jumps)
            {
                Player[A].Slope = 0;
                Player[A].SpinFireDir = Player[A].Direction;
                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - tempSpeed;
                Player[A].Jump = Physics.PlayerJumpHeight;
                if(Player[A].Character == 2)
                    Player[A].Jump += 3;

                if(Player[A].StandingOnNPC > 0 && !FreezeNPCs)
                {
                    if(NPC[Player[A].StandingOnNPC].Type != NPCID_ITEM_BURIED)
                        Player[A].Location.SpeedX += -NPC[Player[A].StandingOnNPC].Location.SpeedX;
                }

                PlaySoundSpatial(SFX_Whip, Player[A].Location); // Jump sound
                Player[A].Jump -= 6;
                if(Player[A].Direction == 1)
                    Player[A].SpinFrame = 0;
                else
                    Player[A].SpinFrame = 6;
                Player[A].SpinJump = true;
//                                    if(nPlay.Online == true && nPlay.MySlot + 1 == A)
//                                        Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1l" + std::to_string(A) + LB;

                // just checked that Player[A].Duck wasn't true!
                // if(Player[A].Duck)
                //     UnDuck(Player[A]);

                if(Player[A].State == PLR_STATE_CYCLONE)
                    Player[A].Jump += 32;

                if(Player[A].ShellSurf)
                {
                    Player[A].ShellSurf = false;
                    Player[A].Location.SpeedX = NPC[Player[A].StandingOnNPC].Location.SpeedX + (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed * 0.8_r;
                    Player[A].Jump = 0;

                    if(g_config.disable_spin_jump)
                        Player[A].SpinJump = false;
                }

                Player[A].StandingOnNPC = 0;

                if(Player[A].CanFly)
                {
                    Player[A].StandingOnNPC = 0;
                    Player[A].Jump = 30;
                    if(Player[A].Character == 2)
                        Player[A].Jump += 3;
                    if(Player[A].SpinJump)
                        Player[A].Jump -= 6;
                    Player[A].CanFly = false;
                    Player[A].RunCount = 0;
                    Player[A].CanFly2 = true;
                    Player[A].FlyCount = 150; // Length of flight time
                }
            }
        }
        else if(has_wall_traction && Player[A].CanAltJump && !Player[A].JumpOffWall)
        {
            NewEffect(EFFID_WHACK, newLoc(Player[A].Location.X + Player[A].Location.Width / 2 - 16, Player[A].Location.Y + Player[A].Location.Height - 16));
            PlaySoundSpatial(SFX_Whip, Player[A].Location); // Jump sound
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
            Player[A].Location.SpeedX -= 7 * Player[A].Direction;
            Player[A].Location.X += Player[A].Location.SpeedX;
            Player[A].Jump = 5;
            Player[A].JumpOffWall = true;
            Player[A].SpinJump = true;
        }
        else if(Player[A].Jump > 0)
        {
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - tempSpeed;
            if(Player[A].Jump > 20)
                Player[A].Location.SpeedY += -(Player[A].Jump - 20) * 0.2_n;
        }
        else if(Player[A].CanFly2)
        {
            if(Player[A].Location.SpeedY > Physics.PlayerJumpVelocity / 2)
            {
                Player[A].Location.SpeedY -= 1;
                Player[A].CanPound = true;
                if(Player[A].YoshiBlue)
                    PlaySoundSpatial(SFX_PetTongue, Player[A].Location);
            }
        }
        // End If

        if(!(aquatic_jumps && Player[A].MountSpecial))
            Player[A].CanAltJump = false;
    }
    else
        Player[A].CanAltJump = true;
    // END ALT JUMP


    if((Player[A].Location.SpeedY == 0 || Player[A].StandingOnNPC != 0 || Player[A].Slope > 0) && Player[A].SpinJump)
    {
        Player[A].SpinJump = false;
//                            if(nPlay.Online == true && nPlay.MySlot + 1 == A)
//                                Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1m" + std::to_string(A) + LB;
        Player[A].TailCount = 0;
    }

    if(Player[A].Mount > 0 || aquatic_jumps)
        Player[A].SpinJump = false;

    if(!Player[A].Controls.AltJump && !Player[A].Controls.Jump)
        Player[A].Jump = 0;

    if(Player[A].Jump > 0)
        Player[A].Jump -= 1;

    if(Player[A].Jump > 0)
        Player[A].Vine = 0;
    else
        Player[A].JumpOffWall = false;


    if(Player[A].Quicksand > 1)
    {
        Player[A].Slide = false;
        if(Player[A].Location.SpeedY < -0.7_n)
        {
            Player[A].Location.SpeedY = -0.7_n;
            Player[A].Jump -= 1;
        }
        else if(Player[A].Location.SpeedY < 0)
        {
            Player[A].Location.SpeedY += 0.1_n;
            Player[A].Jump = 0;
        }

        if(Player[A].Location.SpeedY >= 0.1_n)
            Player[A].Location.SpeedY = 0.1_n;
        Player[A].Location.Y += Player[A].Location.SpeedY;
    }


    // gravity
    if(Player[A].Vine == 0)
    {
        if(Player[A].NoGravity == 0)
        {
            if(has_wall_traction && Player[A].Location.SpeedY > 0)
            {
                Player[A].Location.SpeedY += Physics.PlayerGravity / 2;

                if(Player[A].Location.SpeedY > Physics.PlayerTerminalVelocity / 2)
                    Player[A].Location.SpeedY = Physics.PlayerTerminalVelocity / 2;
            }
            else if(Player[A].Character == 2)
                Player[A].Location.SpeedY += Physics.PlayerGravity * 0.9_r;
            else
                Player[A].Location.SpeedY += Physics.PlayerGravity;

            bool has_fly_block = (Player[A].HoldingNPC > 0) && (NPC[Player[A].HoldingNPC].Type == NPCID_FLY_BLOCK || NPC[Player[A].HoldingNPC].Type == NPCID_FLY_CANNON);
            bool no_cyclone_glide = (Player[A].Location.SpeedY >= 0) && Player[A].Mount && !Player[A].GroundPound; // glide down in cases where player can't cyclone

            if(Player[A].State == PLR_STATE_CYCLONE && (!Player[A].DoubleJump || no_cyclone_glide))
            {
                if(Player[A].Controls.Down && Player[A].Location.SpeedY >= 0)
                    Player[A].Location.SpeedY += Physics.PlayerGravity / 2;
                else if((Player[A].Controls.Jump || Player[A].Controls.AltJump) && Player[A].Location.SpeedY >= 0)
                {
                    Player[A].Location.SpeedY += -Physics.PlayerGravity * 0.625_rb;

                    if(Player[A].Location.SpeedY > Physics.PlayerTerminalVelocity * 0.375_n)
                        Player[A].Location.SpeedY = Physics.PlayerTerminalVelocity * 0.375_n;
                }
            }
            else if(has_fly_block)
            {
                if(Player[A].Controls.Jump || Player[A].Controls.AltJump)
                {
                    if(Player[A].Character == 2)
                        Player[A].Location.SpeedY += -Physics.PlayerGravity * 0.72_r;
                    else
                        Player[A].Location.SpeedY += -Physics.PlayerGravity * 0.8_r;

                    if(Player[A].Location.SpeedY > Physics.PlayerGravity * 3)
                        Player[A].Location.SpeedY = Physics.PlayerGravity * 3;
                }
                else
                    NPC[Player[A].HoldingNPC].Special = 0;
            }

            if(Player[A].Location.SpeedY > Physics.PlayerTerminalVelocity)
                Player[A].Location.SpeedY = Physics.PlayerTerminalVelocity;
        }
        else
            Player[A].NoGravity -= 1;
    }

    // princess float
    if(Player[A].Character == 3 && Player[A].Wet == 0 && !Player[A].WetFrame && (!aquatic_jumps || !Player[A].MountSpecial))
    {
        if(Player[A].Location.SpeedY == 0 || Player[A].StandingOnNPC > 0 || Player[A].Slope > 0 || Player[A].CanFly2)
            Player[A].CanFloat = true;
        else if(Player[A].CanFloat)
        {
            if(Player[A].Jump == 0 && ((Player[A].Controls.Jump && Player[A].FloatRelease) ||
              (Player[A].Controls.AltJump && Player[A].Location.SpeedY > 0)))
            {
                // float time is longer during glide
                if(Player[A].State == 4 || Player[A].State == 5)
                {
                    Player[A].FloatTime = 100;
                    Player[A].FlySparks = true;
                }
                else
                    Player[A].FloatTime = 65;

                Player[A].FloatDir = 1;

                if(Player[A].Location.SpeedY < -0.5_n)
                    Player[A].FloatSpeed = 0.5_nf;
                else if(Player[A].Location.SpeedY > 0.5_n)
                    Player[A].FloatSpeed = 0.5_nf;
                else
                    Player[A].FloatSpeed = (numf_t)(Player[A].Location.SpeedY);

                Player[A].CanFloat = false;
            }
        }
    }

    if(Player[A].Character == 3 && Player[A].FlySparks)
    {
        if(Player[A].FloatTime == 0 && Player[A].Location.SpeedY >= 0)
            Player[A].FlySparks = false;
    }

    if(Player[A].CanFloat)
        Player[A].FloatTime = 0;

    if(Player[A].FloatTime > 0 && Player[A].Character == 3)
    {
        if((Player[A].Controls.Jump || Player[A].Controls.AltJump) && Player[A].Vine == 0)
        {
            tempf_t floatSpeed = (tempf_t)Player[A].FloatSpeed;
            floatSpeed += Player[A].FloatDir * (tempf_t)0.1_n;

            if(floatSpeed > (tempf_t)0.8_n)
                Player[A].FloatDir = -1;

            if(floatSpeed < -(tempf_t)0.8_n)
                Player[A].FloatDir = 1;

            Player[A].Location.SpeedY = (num_t)floatSpeed;
            Player[A].FloatSpeed = (numf_t)floatSpeed;

            Player[A].FloatTime -= 1;
            if(Player[A].FloatTime == 0 && Player[A].Location.SpeedY == 0)
                Player[A].Location.SpeedY = 0.1_n;
        }
        else
            Player[A].FloatTime = 0;
    }


    // glide ' Racoon Mario
    if((Player[A].State == PLR_STATE_LEAF || Player[A].State == PLR_STATE_STATUE) || Player[A].YoshiBlue || (Player[A].Mount == 1 && Player[A].MountType == 3))
    {
        if((Player[A].Controls.Jump || Player[A].Controls.AltJump) &&
          ((Player[A].Location.SpeedY > Physics.PlayerGravity * 5 && Player[A].Character != 3 && Player[A].Character != 4) ||
            (Player[A].Location.SpeedY > Physics.PlayerGravity * 10 && Player[A].Character == 3) ||
            (Player[A].Location.SpeedY > Physics.PlayerGravity * 7.5_rb && Player[A].Character == 4)) &&
            !Player[A].GroundPound && Player[A].Slope == 0 && Player[A].Character != 5)
        {
            if(!Player[A].ShellSurf)
            {
                if(Player[A].Character == 3)
                    Player[A].Location.SpeedY = Physics.PlayerGravity * 10;
                else if(Player[A].Character == 4)
                    Player[A].Location.SpeedY = Physics.PlayerGravity * 7.5_rb;
                else
                    Player[A].Location.SpeedY = Physics.PlayerGravity * 5;
            }
            else
            {
                if(NPC[Player[A].StandingOnNPC].Location.SpeedY > Physics.PlayerGravity * 5)
                    NPC[Player[A].StandingOnNPC].Location.SpeedY = Physics.PlayerGravity * 5;
            }

            if(
                !(
                    (!Player[A].YoshiBlue && (Player[A].CanFly || Player[A].CanFly2)) ||
                    (Player[A].Mount == 3 && Player[A].CanFly2)
                )
            )
            {
                if(iRand(10) == 0)
                    p_PlayerMakeFlySparkle(Player[A].Location);
            }
        }
    }
}

void PlayerSwimMovementY(int A)
{
    if(Player[A].Mount == 1)
    {
        if(Player[A].Controls.AltJump && Player[A].CanAltJump)
            PlayerDismount(A);
    }
    else if(Player[A].Mount == 3)
    {
        if(Player[A].Controls.AltJump && Player[A].CanAltJump)
            PlayerDismount(A);
    }

    if(Player[A].Duck)
    {
        if(Player[A].StandingOnNPC == 0 && Player[A].Slope == 0 && Player[A].Location.SpeedY != 0 && Player[A].Mount != 1)
        {
            if(Player[A].Character <= 2) // unduck wet players that aren't peach o toad
                UnDuck(Player[A]);
        }
    }

    Player[A].Location.SpeedY += Physics.PlayerGravity / 10;

    if(Player[A].Location.SpeedY >= 3) // Terminal Velocity in water
        Player[A].Location.SpeedY = 3;

    if(Player[A].Mount == 1)
    {
        if(Player[A].Controls.Left || Player[A].Controls.Right)
        {
            if(Player[A].Location.SpeedY == Physics.PlayerGravity / 10 || Player[A].Slope > 0 || (Player[A].StandingOnNPC != 0 && Player[A].Location.Y + Player[A].Location.Height >= NPC[Player[A].StandingOnNPC].Location.Y - NPC[Player[A].StandingOnNPC].Location.SpeedY))
            {
                if(Player[A].Controls.Left && Player[A].Location.SpeedX - NPC[Player[A].StandingOnNPC].Location.SpeedX - (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed <= 0)
                    Player[A].Location.SpeedY = -1.1_n + NPC[Player[A].StandingOnNPC].Location.SpeedY;
                else if(Player[A].Controls.Right && Player[A].Location.SpeedX - NPC[Player[A].StandingOnNPC].Location.SpeedX - (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed >= 0)
                    Player[A].Location.SpeedY = -1.1_n + NPC[Player[A].StandingOnNPC].Location.SpeedY;
                else
                    PlaySoundSpatial(SFX_Skid, Player[A].Location);

                Player[A].MountSpecial = 1;
            }
        }

        if(Player[A].Location.SpeedY < -1.1_n)
            Player[A].MountSpecial = 0;
        else if(Player[A].Location.SpeedY > 1.1_n)
            Player[A].MountSpecial = 0;
        else if(Player[A].FloatTime >= 0)
            Player[A].MountSpecial = 0;


        if(Player[A].Controls.Jump && Player[A].MountSpecial == 1 && Player[A].CanJump)
        {
            Player[A].Location.SpeedY = Physics.PlayerGravity / 10;
            Player[A].MountSpecial = 0;
            Player[A].StandUp = true;
        }
    }

    if(Player[A].SwimCount > 0)
        Player[A].SwimCount -= 1;

    if(Player[A].SwimCount == 0)
    {
        if(Player[A].Mount != 1 || Player[A].Location.SpeedY == Physics.PlayerGravity / 10 || Player[A].Slope != 0 || Player[A].StandingOnNPC != 0)
        {
            if((Player[A].Controls.Jump && Player[A].CanJump) ||
               (Player[A].Controls.AltJump && Player[A].CanAltJump))
            {
                if(Player[A].Duck && Player[A].Mount != 1 && Player[A].Character <= 2)
                    UnDuck(Player[A]);

                if(Player[A].Slope != 0)
                    Player[A].Location.SpeedY = 0;

                Player[A].Vine = 0;
                if(Player[A].StandingOnNPC != 0)
                {
                    Player[A].Location.SpeedY = NPC[Player[A].StandingOnNPC].Location.SpeedY;
                    Player[A].StandingOnNPC = 0;
                }

                Player[A].SwimCount = 15;
                // If .Location.SpeedY = 0 Then .Location.Y += -1
                if(Player[A].Controls.Down)
                {
                    if(Player[A].Location.SpeedY >= Physics.PlayerJumpVelocity / 5)
                    {
                        Player[A].Location.SpeedY += Physics.PlayerJumpVelocity / 5;
                        if(Player[A].Location.SpeedY < Physics.PlayerJumpVelocity / 5)
                            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity / 5;
                    }
                }
                else
                {
                    if(Player[A].Controls.Up)
                        Player[A].Location.SpeedY += Physics.PlayerJumpVelocity / 2;
                    else
                        Player[A].Location.SpeedY += Physics.PlayerJumpVelocity * 0.4_r;

                    if(Player[A].Mount == 1)
                        Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
                }

                if(Player[A].Location.SpeedY > 0)
                    Player[A].Location.SpeedY = Physics.PlayerJumpVelocity / 5;

                PlaySoundSpatial(SFX_Swim, Player[A].Location);
            }
        }
    }

    Player[A].CanJump = !Player[A].Controls.Jump;
    Player[A].CanAltJump = !Player[A].Controls.AltJump;

    if(Player[A].Controls.Up)
    {
        if(Player[A].Location.SpeedY < -4)
            Player[A].Location.SpeedY = -4;
    }
    else
    {
        if(Player[A].Location.SpeedY < -3)
            Player[A].Location.SpeedY = -3;
    }
}

void PlayerAquaticSwimMovement(int A)
{
    Player[A].Rolling = false;

    if(!Player[A].Duck)
    {
        Player[A].Duck = true;
        SizeCheck(Player[A]);
    }

    if(!Player[A].Wet)
    {
        if(Player[A].Pinched.Bottom1)
            Player[A].WetFrame = false;

        tempf_t C = 0;

        PlayerMovementX(A, C);
        return;
    }

    int current_swim_dir = -1;
    if(Player[A].SwimCount > 0)
    {
        current_swim_dir = Player[A].SwimCount / 16;

        Player[A].SwimCount -= 1;

        if((Player[A].SwimCount & 15) == 0)
            Player[A].SwimCount = 0;
    }

    num_t base_speed = (Player[A].State == PLR_STATE_POLAR) ? 2_n : 2.5_n;

    num_t target_speed = base_speed;
    int rate = 16; // out of 256

    if(Player[A].Controls.Run)
        target_speed += 1;

    if(Player[A].Character == 2)
    {
        target_speed *= 0.9_r;
        rate = rate / 2;
    }
    else if(Player[A].Character == 3)
        target_speed *= 0.85_r;
    else if(Player[A].Character == 4)
        target_speed *= 1.1_r;
    else if(Player[A].Character == 5)
    {
        target_speed *= 0.95_r;
        rate = rate * 3 / 4;
    }

    num_t target_speed_x = 0;
    num_t target_speed_y = 0;
    int rate_x = rate / 2;
    int rate_y = rate / 2;

    int old_swim_dir = (Player[A].Direction > 0) ? MAZE_DIR_RIGHT : MAZE_DIR_LEFT;

    // keep old direction if present
    if(Player[A].Frame == 19 || Player[A].Frame == 20 || Player[A].Frame == 21)
        old_swim_dir = MAZE_DIR_DOWN;
    else if(Player[A].Frame == 40 || Player[A].Frame == 41 || Player[A].Frame == 42)
        old_swim_dir = MAZE_DIR_UP;

    int new_swim_dir = old_swim_dir;

    if((Player[A].Controls.Up && current_swim_dir != MAZE_DIR_DOWN) || current_swim_dir == MAZE_DIR_UP)
    {
        new_swim_dir = MAZE_DIR_UP;
        target_speed_y = -target_speed;

        if(Player[A].Location.SpeedY < 0)
            rate_y = rate;
        else
            rate_y = rate * 2;

        if(current_swim_dir == MAZE_DIR_UP)
        {
            target_speed_y -= base_speed;
            rate_y *= 2;
        }
    }
    else if(Player[A].Controls.Down || current_swim_dir == MAZE_DIR_DOWN)
    {
        new_swim_dir = MAZE_DIR_DOWN;
        target_speed_y = target_speed;

        if(Player[A].Location.SpeedY > 0)
            rate_y = rate;
        else
            rate_y = rate * 2;

        if(current_swim_dir == MAZE_DIR_DOWN)
        {
            target_speed_y += base_speed;
            rate_y *= 2;
        }
    }

    if((Player[A].Controls.Left && current_swim_dir != MAZE_DIR_RIGHT) || current_swim_dir == MAZE_DIR_LEFT)
    {
        new_swim_dir = MAZE_DIR_LEFT;
        target_speed_x = -target_speed;

        if(Player[A].Location.SpeedX < 0)
            rate_x = rate;
        else
            rate_x = rate * 2;

        if(current_swim_dir == MAZE_DIR_LEFT)
        {
            target_speed_x -= base_speed;
            rate_x *= 2;
        }

        Player[A].Direction = -1;
    }
    else if(Player[A].Controls.Right || current_swim_dir == MAZE_DIR_RIGHT)
    {
        new_swim_dir = MAZE_DIR_RIGHT;
        target_speed_x = target_speed;

        if(Player[A].Location.SpeedX > 0)
            rate_x = rate;
        else
            rate_x = rate * 2;

        if(current_swim_dir == MAZE_DIR_RIGHT)
        {
            target_speed_x += base_speed;
            rate_x *= 2;
        }

        Player[A].Direction = 1;
    }

    // interrupt animation when the swim dir changes
    if(new_swim_dir != old_swim_dir)
        Player[A].FrameCount = 0;

    // go a bit slower vertically
    target_speed_y = target_speed_y * 3 / 4;

    Player[A].Location.SpeedX = (target_speed_x * rate_x + Player[A].Location.SpeedX * (256 - rate_x)) / 256;
    Player[A].Location.SpeedY = (target_speed_y * rate_y + Player[A].Location.SpeedY * (256 - rate_y)) / 256;

    // stop (X)
    if(num_t::abs(Player[A].Location.SpeedX) < 0.03125_n)
        Player[A].Location.SpeedX = 0;

    // stop (Y)
    if(num_t::abs(Player[A].Location.SpeedY) < 0.03125_n)
        Player[A].Location.SpeedY = 0;

    // apply gravity if about to stop being wet -- this keeps us in the water
    if(Player[A].Wet == 1)
        Player[A].Location.SpeedY += Physics.PlayerGravity;

    if(Player[A].SwimCount == 0)
    {
        if((Player[A].Controls.Jump && Player[A].CanJump) ||
           (Player[A].Controls.AltJump && Player[A].CanAltJump))
        {
            Player[A].SwimCount = 16 * new_swim_dir + 15;
            PlaySoundSpatial(SFX_Swim, Player[A].Location);
        }
    }

    Player[A].CanJump = !Player[A].Controls.Jump;
    Player[A].CanAltJump = !Player[A].Controls.AltJump;
}

void PlayerMazeZoneMovement(int A)
{
    if(Player[A].Mount == 3)
    {
        Player[A].Duck = true;
        SizeCheck(Player[A]);
    }
    else if(!Player[A].Rolling && !Player[A].AquaticSwim)
        UnDuck(Player[A]);

    Player[A].Bumped = 0;
    Player[A].Bumped2 = 0;
    Player[A].Jump = 0;
    Player[A].SpinJump = false;

    if(Player[A].MazeZoneStatus & MAZE_PLAYER_FLIP)
        Player[A].MazeZoneStatus = (Player[A].MazeZoneStatus & 3) ^ MAZE_DIR_FLIP_BIT;

    PhysEnv_Maze(Player[A].Location, Player[A].CurMazeZone, Player[A].MazeZoneStatus, 0, A, Player[A].Rolling ? 6 : (Player[A].Quicksand ? 1 : (Player[A].Wet && !Player[A].AquaticSwim ? 2 : 4)), {Player[A].Controls.Left, Player[A].Controls.Up, Player[A].Controls.Right, Player[A].Controls.Down});

    if(!Player[A].CurMazeZone)
    {
        Player[A].WetFrame = Player[A].Wet && !Player[A].Quicksand;

        // prevent unexpected block clipping
        if(Player[A].MazeZoneStatus % 4 == MAZE_DIR_DOWN)
        {
            // make sure the player won't clip into blocks below the maze zone
            PlayerPush(A, 1);

            // unduck the player now if they were on Mount 3, and then make sure they don't hit the top of the maze zone ceiling
            if(Player[A].Duck && !Player[A].Controls.Down && !Player[A].Rolling)
            {
                UnDuck(Player[A]);
                PlayerPush(A, 3);
            }
        }
        // help the player hit blocks above the maze zone
        else if(Player[A].MazeZoneStatus % 4 == MAZE_DIR_UP && !Player[A].Rolling)
        {
            Player[A].StandUp = true;
            Player[A].StandUp2 = true;
            Player[A].ForceHitSpot3 = true;
        }

        // don't allow jumping
        Player[A].CanJump = false;
        Player[A].CanAltJump = false;

        PlaySoundSpatial(SFX_HeroDash, Player[A].Location);
    }
}

void PlayerFlagSlideMovement(int A)
{
    Player[A].Location.SpeedX = 0;

    // have we hit the ground yet?
    if(Player[A].Location.SpeedY == 0 || Player[A].StandingOnNPC)
    {
        // this results in waiting 16 frames after hitting the ground
        LevelMacroWhich++;
    }
    else
    {
        Player[A].Location.SpeedY = 2;
        Player[A].Location.Y += Player[A].Location.SpeedY;
    }
}


================================================
FILE: src/player/player_npc_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"

#include "player.h"
#include "npc.h"
#include "npc_id.h"
#include "npc_traits.h"
#include "npc/npc_queues.h"
#include "sound.h"
#include "editor.h"
#include "effect.h"
#include "game_main.h"
#include "eff_id.h"
#include "collision.h"
#include "layers.h"
#include "config.h"
#include "phys_env.h"

#include "player/player_update_priv.h"

#include "main/trees.h"

void PlayerNPCLogic(int A, bool& tempSpring, bool& tempShell, int& MessageNPC, const bool movingBlock, const int floorBlock, const tempf_t oldSpeedY)
{
    int floorNpc1 = 0;
    int floorNpc2 = 0;
    // previously tempHitSpeed. was previously a float, converted through numf_t at all assignments
    num_t wallNpcSpeed = 0;
    bool spinKill = false;

    // cleanup variables for NPC collisions

    int bounceNpc = 0; // previously tempHit. Used for JUMP detection -- new: it's the ID of the last NPC that was jumped on
    bool hitWall = false; // previously tempHit2
    num_t bouncePlrY = 0; // previously shared with tempLocation.Y
    // Location_t tempLocation;

    for(int B : treeNPCQuery(Player[A].Location, SORTMODE_ID))
    {
        if(NPC[B].Active && NPC[B].Killed == 0 && NPC[B].Effect != NPCEFF_PET_TONGUE && NPC[B].Effect != NPCEFF_PET_INSIDE)
        {
            // If Not (NPC(B).Type = 17 And NPC(B).CantHurt > 0) And Not (.Mount = 2 And NPC(B).Type = 56) And Not NPC(B).vehiclePlr = A And Not NPC(B).Type = 197 And Not NPC(B).Type = 237 Then
            if(!(Player[A].Mount == 2 && NPC[B].Type == NPCID_VEHICLE) &&
                NPC[B].vehiclePlr != A &&
                NPC[B].Type != NPCID_GOALTAPE &&
                NPC[B].Type != NPCID_ICE_BLOCK
            )
            {
                if(NPC[B].HoldingPlayer == 0 || NPC[B]->IsABonus || (BattleMode && NPC[B].HoldingPlayer != A))
                {
                    if(CheckCollision(Player[A].Location, NPC[B].Location))
                    {
                        if((NPC[B].Type == NPCID_METALBARREL || NPC[B].Type == NPCID_CANNONENEMY || NPC[B].Type == NPCID_HPIPE_SHORT || NPC[B].Type == NPCID_HPIPE_LONG || NPC[B].Type == NPCID_VPIPE_SHORT || NPC[B].Type == NPCID_VPIPE_LONG) && NPC[B].Projectile)
                            PlayerHurt(A);

                        // the hitspot is used for collision detection to find out where to put the player after it collides with a block
                        // the numbers tell what side the collision happened so it can move the plaer to the correct position
                        // 1 means the player hit the block from the top
                        // 2 is from the right
                        // 3 is from the bottom
                        // 4 is from the left
                        int HitSpot;
                        if((Player[A].Mount == 1 || Player[A].Mount == 3 || Player[A].SpinJump || (Player[A].ShellSurf && NPC[B]->IsAShell) || (Player[A].Stoned && !NPC[B]->CanWalkOn)) && !NPC[B]->MovesPlayer)
                            HitSpot = BootCollision(Player[A].Location, NPC[B].Location, NPC[B]->CanWalkOn); // find the hitspot for normal mario
                        else
                            HitSpot = EasyModeCollision(Player[A].Location, NPC[B].Location, NPC[B]->CanWalkOn); // find the hitspot when in a shoe or on a yoshi

                        if(GameOutro)
                            HitSpot = 0;

                        if(NPC[B].Inert) // if the npc is friendly then you can't touch it
                        {
                            HitSpot = 0;
                            if(NPC[B].Text != STRINGINDEX_NONE && Player[A].Controls.Up && !FreezeNPCs)
                                MessageNPC = B;
                        }

                        // BEGIN type-based "onCollidePlayer" logic

                        if(!NPC[B].Inert)
                        {
                            // battlemode stuff
                            if(NPC[B].Type == NPCID_PLR_FIREBALL || NPC[B].Type == NPCID_PLR_HEAVY || NPC[B].Type == NPCID_PLR_ICEBALL || NPC[B].Type == NPCID_SWORDBEAM || NPC[B].Type == NPCID_PET_FIRE || NPC[B].Type == NPCID_CHAR3_HEAVY || NPC[B].Type == NPCID_CHAR4_HEAVY)
                            {
                                if(BattleMode && NPC[B].CantHurtPlayer != A)
                                {
                                    // duck projectile-resistance in heavy suit
                                    if(Player[A].State == 6 && Player[A].Duck && Player[A].Character != 5)
                                        NPCHit(B, 3, B);
                                    else
                                    {
                                        if(Player[A].Immune == 0)
                                        {
                                            NPCHit(B, 3, B);
                                            if(NPC[B].Type == NPCID_SWORDBEAM)
                                                PlaySoundSpatial(SFX_HeroHit, Player[A].Location);
                                        }
                                        PlayerHurt(A);
                                    }
                                }
                                HitSpot = 0;
                            }

                            if(NPC[B].Type == NPCID_BULLET && NPC[B].CantHurt > 0)
                            {
                                if(!BattleMode)
                                    HitSpot = 0;
                                else if(NPC[B].CantHurtPlayer != A)
                                {
                                    if(HitSpot != 1)
                                        PlayerHurt(A);
                                    else
                                    {
                                        NPC[B].CantHurt = 0;
                                        NPC[B].CantHurtPlayer = 0;
                                        NPC[B].Projectile = false;
                                    }
                                }
                            }

                            if((NPC[B].Type == NPCID_TOOTHY || NPC[B].Type == NPCID_HEAVY_THROWN) && BattleMode && NPC[B].CantHurtPlayer != A)
                                PlayerHurt(A);

                            if((NPC[B].Type == NPCID_ICE_CUBE || NPC[B].Type == NPCID_ITEM_POD) && BattleMode &&
                                NPC[B].CantHurtPlayer != A && NPC[B].Projectile != 0 && NPC[B].BattleOwner != A)
                            {
                                if(Player[A].Immune == 0 && NPC[B].Type == NPCID_ITEM_POD)
                                    NPC[B].Special2 = 1;

                                PlayerHurt(A);
                                HitSpot = 0;
                            }

                            if((NPC[B]->IsAShell || NPCIsVeggie(NPC[B]) ||
                                NPC[B].Type == NPCID_ICE_CUBE || NPC[B].Type == NPCID_SLIDE_BLOCK) &&
                                BattleMode && NPC[B].HoldingPlayer > 0 && NPC[B].HoldingPlayer != A)
                            {
                                if(Player[A].Immune == 0)
                                {
                                    PlayerHurt(A);
                                    NPCHit(B, 5, B);
                                }
                            }

                            if(NPCIsAParaTroopa(NPC[B]) && BattleMode && NPC[B].CantHurtPlayer == A)
                                HitSpot = 0;

                            if(BattleMode && NPCIsVeggie(NPC[B]) && NPC[B].Projectile != 0)
                            {
                                if(NPC[B].CantHurtPlayer != A)
                                {
                                    if(Player[A].Immune == 0)
                                    {
                                        PlayerHurt(A);
                                        NPCHit(B, 4, B);
                                        PlaySoundSpatial(SFX_SpitBossHit, Player[A].Location);
                                    }
                                }
                            }

                            if(BattleMode && NPC[B].HoldingPlayer > 0 && NPC[B].HoldingPlayer != A)
                            {
                                if(NPC[B]->WontHurt)
                                    HitSpot = 0;
                                else
                                    HitSpot = 5;
                            }

                            if(BattleMode && NPC[B].BattleOwner != A && NPC[B].Projectile != 0 && NPC[B].CantHurtPlayer != A)
                            {
                                if(NPC[B].Type == NPCID_BOMB || NPC[B].Type == NPCID_LIT_BOMB_S3 || NPC[B].Type == NPCID_CARRY_BLOCK_A || NPC[B].Type == NPCID_CARRY_BLOCK_B || NPC[B].Type == NPCID_CARRY_BLOCK_C || NPC[B].Type == NPCID_CARRY_BLOCK_D || NPC[B].Type == NPCID_HIT_CARRY_FODDER || ((NPC[B]->IsAShell || NPC[B].Type == NPCID_SLIDE_BLOCK) && NPC[B].Location.SpeedX == 0))
                                {
                                    if(NPC[B]->IsAShell && HitSpot == 1 && Player[A].SpinJump)
                                    {}
                                    else if(Player[A].Immune == 0)
                                    {
                                        if(NPC[B].Type != NPCID_SLIDE_BLOCK && !NPC[B]->IsAShell)
                                            NPCHit(B, 3, B);
                                        PlayerHurt(A);
                                        HitSpot = 0;
                                    }
                                }
                            }
                            // end battlemode
                        }

                        if(NPC[B].Type == NPCID_ITEM_BUBBLE)
                        {
                            NPCHit(B, 1, A);
                            HitSpot = 0;
                        }

                        if(NPC[B].Type == NPCID_HEAVY_THROWN && NPC[B].CantHurt > 0)
                            HitSpot = 0;

                        if(NPC[B].Type == NPCID_ITEM_POD && HitSpot == 1)
                            HitSpot = 0;

                        // ' Fireball immune for ducking in the hammer suit
                        if((Player[A].State == 6 && Player[A].Duck && Player[A].Mount == 0 && Player[A].Character != 5) || (Player[A].Mount == 1 && Player[A].MountType == 2))
                        {
                            if(NPC[B].Type == NPCID_STATUE_FIRE || NPC[B].Type == NPCID_VILLAIN_FIRE || NPC[B].Type == NPCID_PLANT_FIREBALL || NPC[B].Type == NPCID_QUAD_BALL)
                            {
                                PlaySoundSpatial(SFX_BlockHit, Player[A].Location);
                                HitSpot = 0;
                                NPC[B].Killed = 9;
                                NPCQueues::Killed.push_back(B);
                                for(int C = 1; C <= 10; ++C)
                                {
                                    NewEffect(EFFID_PLR_FIREBALL_TRAIL, NPC[B].Location, NPC[B].Special);
                                    Effect[numEffects].Location.SpeedX = dRand() * 3 - 1.5_n + NPC[B].Location.SpeedX / 10;
                                    Effect[numEffects].Location.SpeedY = dRand() * 3 - 1.5_n - NPC[B].Location.SpeedY / 10;
                                    if(Effect[numEffects].Frame == 0)
                                        Effect[numEffects].Frame = -iRand(3);
                                    else
                                        Effect[numEffects].Frame = 5 + iRand(3);
                                }
                                NPC[B].Location.X += NPC[B].Location.Width / 2 - EffectWidth[EFFID_SMOKE_S3] * 0.5_n;
                                NPC[B].Location.Y += NPC[B].Location.Height / 2 - EffectHeight[EFFID_SMOKE_S3] * 0.5_n;
                                NewEffect(EFFID_SMOKE_S3, NPC[B].Location);

                                treeNPCUpdate(B);
                            }
                        }


                        if(NPC[B]->IsAVine) // if the player collided with a vine then see if he should climb it
                            p_PlayerTouchVine(Player[A], NPC[B].Location.Y, B, 0);

                        // subcon warps
                        if(NPC[B].Type == NPCID_MAGIC_DOOR && HitSpot > 0 && Player[A].Controls.Up)
                        {
                            if(NPC[B].Variant <= maxSections)
                            {
                                NPC[B].Killed = 9;
                                NPCQueues::Killed.push_back(B);
                                PlaySoundSpatial(SFX_Door, Player[A].Location);
                                Player[A].Effect = PLREFF_WARP_DOOR;
                                Player[A].Warp = numWarps + 1;
                                Player[A].WarpBackward = false;
                                Warp[numWarps + 1].Entrance = static_cast<SpeedlessLocation_t>(NPC[B].Location);

                                Location_t tempLocation = NPC[B].Location;
                                tempLocation.X = NPC[B].Location.X - level[Player[A].Section].X + level[NPC[B].Variant].X;
                                tempLocation.Y = NPC[B].Location.Y - level[Player[A].Section].Y + level[NPC[B].Variant].Y;
                                Warp[numWarps + 1].Exit = static_cast<SpeedlessLocation_t>(tempLocation);
                                Warp[numWarps + 1].Hidden = false;
                                Warp[numWarps + 1].NoYoshi = false;
                                Warp[numWarps + 1].WarpNPC = true;
                                Warp[numWarps + 1].Locked = false;
                                Warp[numWarps + 1].Stars = 0;
                                Player[A].Location.SpeedX = 0;
                                Player[A].Location.SpeedY = 0;
                                // Stop
                                Player[A].Location.X = Warp[Player[A].Warp].Entrance.X + (Warp[Player[A].Warp].Entrance.Width - Player[A].Location.Width) / 2;
                                Player[A].Location.Y = Warp[Player[A].Warp].Entrance.Y + Warp[Player[A].Warp].Entrance.Height - Player[A].Location.Height;
                                tempLocation = static_cast<Location_t>(Warp[numWarps + 1].Entrance);
                                tempLocation.Y -= 32;
                                tempLocation.Height = 64;
                                NewEffect(EFFID_DOOR_S2_OPEN, tempLocation);
                                tempLocation = static_cast<Location_t>(Warp[numWarps + 1].Exit);
                                tempLocation.Y -= 32;
                                tempLocation.Height = 64;
                                NewEffect(EFFID_DOOR_S2_OPEN, tempLocation);

                                // this is a bug that came from re-using tempLocation.Y in the original code
                                bouncePlrY = tempLocation.Y;
                            }
                        }

                        if(NPC[B].Type == NPCID_LOCK_DOOR && Player[A].HasKey)
                        {
                            Player[A].HasKey = false;
                            HitSpot = 0;
                            NPC[B].Killed = 3;
                            NPCQueues::Killed.push_back(B);
                        }

                        if(NPC[B].Type == NPCID_MINIBOSS && NPC[B].Special == 4 && HitSpot > 1)
                            HitSpot = 0;

                        // END type-based "onCollidePlayer" logic

                        if(Player[A].Stoned && HitSpot != 1) // if you are a statue then SLAM into the npc
                        {
                            if(Player[A].Location.SpeedX > 3 || Player[A].Location.SpeedX < -3)
                                NPCHit(B, 3, B);
                        }

                        // kill things with the vehicle
                        if(Player[A].Mount == 2 && !Player[A].SpinJump && !(Player[A].Stoned && !NPC[B]->CanWalkOn))
                        {
                            // already checked at top
                            // if(NPC[B].vehiclePlr == A)
                            //     HitSpot = 0;
                            // else
                            if(!(NPC[B].Type == NPCID_BULLET && NPC[B].CantHurt > 0))
                            {
                                if((NPC[B].Location.Y + NPC[B].Location.Height > Player[A].Location.Y + 18 && HitSpot != 3) || HitSpot == 1)
                                {
                                    NPCHit(B, 8, A);
                                    if(NPC[B].Killed == 8)
                                        HitSpot = 0;

                                    if(NPC[B].Type == NPCID_WALK_BOMB_S2 || NPC[B].Type == NPCID_WALK_BOMB_S3 || NPC[B].Type == NPCID_LIT_BOMB_S3)
                                    {
                                        NPCHit(B, 3, B);
                                        if(NPC[B].Killed == 3)
                                            HitSpot = 0;
                                    }
                                }
                            }
                        }

                        // prevented player from grabbing active slide blocks; logic moved to side grab code
                        // if(NPC[B].Type == NPCID_SLIDE_BLOCK && NPC[B].Projectile != 0 && HitSpot > 1)
                        //     HitSpot = 5;

                        if(HitSpot == 1) // Player landed on a NPC
                        {
                            // the following code is for spin jumping and landing on things as yoshi/shoe
                            if(!InvincibilityTime && (Player[A].Mount == 1 || Player[A].Mount == 3 || Player[A].SpinJump || (Player[A].Stoned && !NPC[B]->CanWalkOn)))
                            {
                                // these types were not hit during spin bounces in SMBX 1.3 (but may be vulnerable to stomps by mounts)
                                bool dont_hit_spin_bounce = (NPC[B].Type == NPCID_FIRE_PLANT || NPC[B].Type == NPCID_QUAD_SPITTER || NPC[B].Type == NPCID_PLANT_S3 || NPC[B].Type == NPCID_LAVABUBBLE ||
                                          NPC[B].Type == NPCID_SPIKY_S3 || NPC[B].Type == NPCID_SPIKY_S4 || NPC[B].Type == NPCID_SPIKY_BALL_S4 || NPC[B].Type == NPCID_BOTTOM_PLANT ||
                                          NPC[B].Type == NPCID_SIDE_PLANT || NPC[B].Type == NPCID_CRAB || NPC[B].Type == NPCID_FLY || NPC[B].Type == NPCID_BIG_PLANT ||
                                          NPC[B].Type == NPCID_PLANT_S1 || NPC[B].Type == NPCID_VILLAIN_S1 || NPC[B].Type == NPCID_WALL_BUG || NPC[B].Type == NPCID_WALL_TURTLE ||
                                          NPC[B].Type == NPCID_SICK_BOSS || NPC[B].Type == NPCID_WALK_PLANT || NPC[B].Type == NPCID_JUMP_PLANT);

                                // these types are immune to spin bounces and were hit (with no effect) in SMBX 1.3 but are no longer hit
                                bool immune_to_spin_bounce = (NPC[B].Type == NPCID_SAW || NPC[B].Type == NPCID_STONE_S3 || NPC[B].Type == NPCID_STONE_S4 || NPC[B].Type == NPCID_GHOST_S3 ||
                                   NPC[B].Type == NPCID_GHOST_FAST || NPC[B].Type == NPCID_GHOST_S4 || NPC[B].Type == NPCID_BIG_GHOST || NPC[B].Type == NPCID_LAVA_MONSTER || NPC[B].Type == NPCID_LONG_PLANT_UP);

                                bool force_bounce = (dont_hit_spin_bounce | immune_to_spin_bounce);

                                if(Player[A].Mount == 1 || Player[A].Mount == 2 || Player[A].Stoned)
                                    NPCHit(B, 8, A);
                                else if(!force_bounce && !NPC[B]->CanWalkOn)
                                {
                                    if(Player[A].Wet > 0 && (NPC[B]->IsFish || NPC[B].Type == NPCID_SQUID_S3 || NPC[B].Type == NPCID_SQUID_S1))
                                    {
                                    }
                                    else
                                        NPCHit(B, 8, A);
                                }

                                if(NPC[B].Killed == 8 || NPC[B]->IsFish || force_bounce) // tap
                                {
                                    if(NPC[B].Killed == 8 && Player[A].Mount == 1 && Player[A].MountType == 2)
                                    {
                                        for(int i = 0; i < 2; i++)
                                        {
                                            numNPCs++;
                                            NPC[numNPCs].Active = true;
                                            NPC[numNPCs].TimeLeft = 100;
                                            NPC[numNPCs].Section = Player[A].Section;
                                            NPC[numNPCs].Type = NPCID_PLR_FIREBALL;
                                            NPC[numNPCs].Special = Player[A].Character;
                                            NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                                            NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                                            NPC[numNPCs].Location.Y = Player[A].Location.Height + Player[A].Location.Y - NPC[numNPCs].Location.Height;
                                            NPC[numNPCs].Location.X = Player[A].Location.X + (Player[A].Location.Width - NPC[numNPCs].Location.Width) / 2;
                                            NPC[numNPCs].Location.SpeedX = (i == 0) ? -4 : 4;
                                            NPC[numNPCs].Location.SpeedY = 10;
                                            syncLayers_NPC(numNPCs);
                                        }
                                    }

                                    Player[A].ForceHitSpot3 = true;
                                    if(/*HitSpot == 1 && */ !(Player[A].GroundPound && NPC[B].Killed == 8))
                                    {
                                        bounceNpc = B;
                                        bouncePlrY = NPC[B].Location.Y - Player[A].Location.Height;

                                        if(NPC[B].Killed == 0)
                                            PlaySoundSpatial(SFX_Stomp, Player[A].Location);
                                        else if(Player[A].SpinJump)
                                        {
                                            if(Player[A].Controls.Down)
                                                bounceNpc = 0;
                                            else
                                                spinKill = true;
                                        }
                                    }

                                    continue;
                                }
                            }

                            // moved from above
                            if(/* HitSpot == 1 && */ (NPC[B].Type == NPCID_COIN_SWITCH || NPC[B].Type == NPCID_TIME_SWITCH || NPC[B].Type == NPCID_TNT) && NPC[B].Projectile != 0)
                                HitSpot = 0;
                            // NPCs that can be walked on
                            else if(NPC[B]->CanWalkOn || (Player[A].ShellSurf && NPC[B]->IsAShell))
                            {
                                // the player landed on an NPC he can stand on
                                if(floorNpc1 == 0)
                                    floorNpc1 = B;
                                else if(floorNpc2 == 0)
                                    floorNpc2 = B;
                                else if(Player[A].StandingOnNPC == B)
                                {
                                    // if standing on 2 or more NPCs find out the best one to stand on
                                    num_t C = num_t::abs(NPC[floorNpc1].Location.minus_center_x(Player[A].Location));
                                    num_t D = num_t::abs(NPC[floorNpc2].Location.minus_center_x(Player[A].Location));

                                    if(C < D)
                                        floorNpc2 = B;
                                    else
                                        floorNpc1 = B;
                                }
                                else
                                    floorNpc2 = B;
                            }
                            // if landing on a yoshi or boot, mount up!
                            else if((NPCIsYoshi(NPC[B]) || NPCIsBoot(NPC[B])) && Player[A].Character != 5 && !Player[A].Fairy)
                            {
                                if(Player[A].Mount == 0 && NPC[B].CantHurtPlayer != A && Player[A].Dismount == 0)
                                {
                                    if(NPCIsBoot(NPC[B]))
                                    {
                                        UnDuck(Player[A]);
                                        NPC[B].Killed = 9;
                                        NPCQueues::Killed.push_back(B);

                                        if(Player[A].State == 1)
                                        {
                                            Player[A].Location.Height = Physics.PlayerHeight[1][2];
                                            Player[A].Location.Y += -Physics.PlayerHeight[1][2] + Physics.PlayerHeight[Player[A].Character][1];
                                        }

                                        Player[A].Mount = 1;

                                        if(NPC[B].Type == NPCID_GRN_BOOT)
                                            Player[A].MountType = 1;

                                        if(NPC[B].Type == NPCID_RED_BOOT)
                                            Player[A].MountType = 2;

                                        if(NPC[B].Type == NPCID_BLU_BOOT)
                                            Player[A].MountType = 3;

                                        PlaySoundSpatial(SFX_Stomp, Player[A].Location);
                                    }
                                    else if(NPCIsYoshi(NPC[B]) && (Player[A].Character == 1 || Player[A].Character == 2))
                                    {
                                        UnDuck(Player[A]);
                                        NPC[B].Killed = 9;
                                        NPCQueues::Killed.push_back(B);
                                        Player[A].Mount = 3;

                                        if(NPC[B].Type == NPCID_PET_GREEN)
                                            Player[A].MountType = 1;
                                        else if(NPC[B].Type == NPCID_PET_BLUE)
                                            Player[A].MountType = 2;
                                        else if(NPC[B].Type == NPCID_PET_YELLOW)
                                            Player[A].MountType = 3;
                                        else if(NPC[B].Type == NPCID_PET_RED)
                                            Player[A].MountType = 4;
                                        else if(NPC[B].Type == NPCID_PET_BLACK)
                                            Player[A].MountType = 5;
                                        else if(NPC[B].Type == NPCID_PET_PURPLE)
                                            Player[A].MountType = 6;
                                        else if(NPC[B].Type == NPCID_PET_PINK)
                                            Player[A].MountType = 7;
                                        else if(NPC[B].Type == NPCID_PET_CYAN)
                                            Player[A].MountType = 8;

                                        Player[A].YoshiNPC = 0;
                                        Player[A].YoshiPlayer = 0;
                                        Player[A].MountSpecial = 0;
                                        Player[A].YoshiTonugeBool = false;
                                        Player[A].YoshiTongueLength = 0;
                                        PlaySoundSpatial(SFX_Pet, Player[A].Location);
                                        UpdateYoshiMusic();
                                        YoshiHeight(A);
                                    }
                                }
                            }
                            else if(NPC[B].Type == NPCID_CANNONITEM || NPC[B].Type == NPCID_KEY ||
                                    NPC[B].Type == NPCID_TOOTHYPIPE || NPC[B].Type == NPCID_TOOTHY ||
                                    ((Player[A].SlideKill || InvincibilityTime) && !NPC[B]->WontHurt)) // NPCs that cannot be walked on
                            {
                                // cancel jump
                            }
#if 0
                            // dead code since SMBX 1.3, because NoShellKick was never set
                            else if(NPC[B].CantHurtPlayer == A && Player[A].NoShellKick > 0)
                            {
                                // Do nothing!
                            }
#endif
                            else
                            {
                                if(NPC[B]->IsABonus) // Bonus
                                    TouchBonus(A, B);
                                else if(Player[A].Rolling && Player[A].State == PLR_STATE_SHELL)
                                {
                                    if(NPC[B].Type == NPCID_SPRING)
                                    {
                                        tempSpring = true;
                                        bounceNpc = B;
                                        bouncePlrY = NPC[B].Location.Y - Player[A].Location.Height;
                                    }
                                    else if(NPC[B].CantHurtPlayer != A)
                                        NPCHit(B, 3, B);

                                    continue;
                                }
                                else if(NPC[B]->IsAShell && NPC[B].Location.SpeedX == 0 && Player[A].HoldingNPC == 0 && Player[A].Controls.Run && !g_config.no_shell_grab_top)
                                {
                                    // grab turtle shells
                                    //if(nPlay.Online == false || nPlay.MySlot + 1 == A)
                                    {
                                        if(Player[A].Character >= 3)
                                            PlaySoundSpatial(SFX_Grab, Player[A].Location);
                                        else
                                            UnDuck(Player[A]);

                                        Player[A].HoldingNPC = B;
                                        NPC[B].HoldingPlayer = A;
                                        NPC[B].CantHurt = Physics.NPCCanHurtWait;
                                        NPC[B].CantHurtPlayer = A;
                                    }

                                }
                                else if(NPC[B]->JumpHurt || (NPC[B]->IsFish && Player[A].WetFrame)) // NPCs that cause damage even when jumped on
                                {
                                    if(!(NPC[B].Type == NPCID_PLANT_S3 && NPC[B].Special2 == 4) && !NPC[B]->WontHurt && NPC[B].CantHurtPlayer != A)
                                    {

                                        // the n00bcollision function reduces the size of the npc's hit box before it damages the player
                                        if(n00bCollision(Player[A].Location, NPC[B].Location))
                                            PlayerHurt(A);
                                    }
                                }
                                else if(NPC[B].Type == NPCID_MINIBOSS) // Special code for BOOM BOOM
                                {
                                    if(NPC[B].Special == 0 || Player[A].Mount == 1 || Player[A].Mount == 3)
                                    {
                                        if(NPC[B].Special != 0)
                                            PlaySoundSpatial(SFX_Stomp, Player[A].Location);
                                        bounceNpc = B;
                                        bouncePlrY = NPC[B].Location.Y - Player[A].Location.Height;
                                    }
                                    else if(NPC[B].Special != 4)
                                    {
                                        if(n00bCollision(Player[A].Location, NPC[B].Location))
                                            PlayerHurt(A);
                                    }
                                }
                                else if((NPC[B].Type == NPCID_LIT_BOMB_S3) || NPC[B].Type == NPCID_HIT_CARRY_FODDER)
                                    NPCHit(B, 1, A); // NPC 'B' was jumped on '1' by player 'A'
                                else if(NPC[B].Killed != 10 && !NPCIsBoot(NPC[B]) && !NPCIsYoshi(NPC[B]) && !(NPC[B]->IsAShell && NPC[B].CantHurtPlayer == A)) // Bounce off everything except Bonus and Piranha Plants
                                {
                                    if(NPC[B].Type == NPCID_SPRING)
                                        tempSpring = true;

                                    if(NPC[B]->IsAShell && NPC[B].Location.SpeedX == 0 && NPC[B].Location.SpeedY == 0)
                                        tempShell = true;

                                    bounceNpc = B;
                                    bouncePlrY = NPC[B].Location.Y - Player[A].Location.Height;

                                    if(NPC[B].Type == NPCID_COIN_SWITCH || NPC[B].Type == NPCID_TIME_SWITCH || NPC[B].Type == NPCID_TNT)
                                    {
                                        bounceNpc = 0;
                                        Player[A].Jump = false;
                                        Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
                                        Player[A].Location.SpeedY = -Physics.PlayerGravity;
                                    }
                                }

                                // If Not (.WetFrame = True And (NPC(B).Type = 229 Or NPC(B).Type = 230) Or NPCIsAVine(NPC(B).Type)) And .HoldingNPC <> B Then
                                if(
                                    !(
                                        (Player[A].WetFrame && (NPC[B].Type == NPCID_GRN_FISH_S3 || NPC[B].Type == NPCID_RED_FISH_S3)) ||
                                        NPC[B]->IsAVine
                                    ) && (Player[A].HoldingNPC != B)
                                )
                                {
                                    if(Player[A].Vine > 0)
                                    {
                                        Player[A].Vine = 0;
                                        Player[A].Jump = 1;
                                    }

                                    if(!(NPC[B]->IsAShell && NPC[B].CantHurtPlayer == A))
                                        NPCHit(B, 1, A); // NPC 'B' was jumped on '1' by player 'A'
                                }
                            }
                        }
                        else if(HitSpot == 0)
                        {
                            // if hitspot = 0 then do nothing
                        }
                        // player touched an npc anywhere except from the top
                        else // Player touched an NPC
                        {

/* If (.CanGrabNPCs = True Or NPCIsGrabbable(NPC(B).Type) = True Or (NPC(B).Effect = 2 And NPCIsABonus(NPC(B).Type) = False)) And (NPC(B).Effect = 0 Or NPC(B).Effect = 2) Or (NPCIsAShell(NPC(B).Type) And FreezeNPCs = True) Then      'GRAB EVERYTHING
*/

                            // grab from side
                            if(
                                ((Player[A].CanGrabNPCs || NPC[B]->IsGrabbable || (NPC[B].Effect == NPCEFF_DROP_ITEM && !NPC[B]->IsABonus)) && (NPC[B].Effect == NPCEFF_NORMAL || NPC[B].Effect == NPCEFF_DROP_ITEM || NPC[B].Effect == NPCEFF_MAZE)) ||
                                 (NPC[B]->IsAShell && FreezeNPCs)
                            ) // GRAB EVERYTHING
                            {
                                if(Player[A].Controls.Run && !Player[A].Rolling)
                                {
                                    if((HitSpot == 2 && Player[A].Direction == -1) ||
                                       (HitSpot == 4 && Player[A].Direction == 1) ||
                                       (NPC[B].Type == NPCID_CANNONITEM || NPC[B].Type == NPCID_TOOTHYPIPE || NPC[B].Effect == NPCEFF_DROP_ITEM || (NPCIsVeggie(NPC[B]) && NPC[B].CantHurtPlayer != A)))
                                    {
                                        if(NPC[B].Type == NPCID_SLIDE_BLOCK && NPC[B].Projectile != 0)
                                        {
                                            // don't grab active slide blocks
                                        }
                                        else if(Player[A].HoldingNPC == 0)
                                        {
                                            if(!NPC[B]->IsAShell || Player[A].Character >= 3)
                                            {
                                                if(NPCIsVeggie(NPC[B]))
                                                    PlaySoundSpatial(SFX_Grab2, Player[A].Location);
                                                else
                                                    PlaySoundSpatial(SFX_Grab, Player[A].Location);
                                            }

                                            if(Player[A].Character <= 2)
                                                UnDuck(Player[A]);
                                            Player[A].HoldingNPC = B;
                                            NPC[B].Direction = Player[A].Direction;
                                            NPC[B].Frame = EditorNPCFrame(NPC[B].Type, NPC[B].Direction);
                                            NPC[B].HoldingPlayer = A;
                                            NPC[B].CantHurt = Physics.NPCCanHurtWait;
                                            NPC[B].CantHurtPlayer = A;
                                        }
                                    }
                                }
                            }

                            if(NPC[B]->IsAShell || (NPC[B].Type == NPCID_SLIDE_BLOCK && NPC[B].Special == 1)) // Turtle shell
                            {
                                if(Player[A].Rolling && NPC[B].HoldingPlayer == 0 && NPC[B].CantHurtPlayer != A) // Kill the shell!
                                    NPCHit(B, 3, B);
                                else if(NPC[B].Location.SpeedX == 0 && NPC[B].Location.SpeedY >= 0) // Shell is not moving
                                {
                                    if(((Player[A].Controls.Run && Player[A].HoldingNPC == 0) || Player[A].HoldingNPC == B) && NPC[B].CantHurtPlayer != A) // Grab the shell
                                    {
                                        if(Player[A].Character >= 3)
                                            PlaySoundSpatial(SFX_Grab, Player[A].Location);
                                        else
                                            UnDuck(Player[A]);

                                        Player[A].HoldingNPC = B;
                                        NPC[B].HoldingPlayer = A;
                                        NPC[B].CantHurt = Physics.NPCCanHurtWait;
                                        NPC[B].CantHurtPlayer = A;
                                    }
                                    else if(NPC[B].HoldingPlayer == 0) // Kick the shell
                                    {
                                        if((Player[A].Mount == 1 || Player[A].Mount == 2 || Player[A].Mount == 3) && NPC[B].Type != NPCID_SLIDE_BLOCK)
                                        {
                                            if(NPC[B].Type != NPCID_FLIPPED_RAINBOW_SHELL)
                                            {
                                                bouncePlrY = Player[A].Location.Y;
                                                bounceNpc = B;
                                                NPCHit(B, 8, A);
                                            }
                                        }
                                        else
                                        {
                                            Location_t tempLocation;
                                            tempLocation.Height = 0;
                                            tempLocation.Width = 0;
                                            tempLocation.Y = (Player[A].Location.Y + NPC[B].Location.Y * 4) / 5;
                                            tempLocation.X = (Player[A].Location.X + NPC[B].Location.X * 4) / 5;
                                            NewEffect(EFFID_STOMP_INIT, tempLocation);

                                            NPC[B].CantHurt = 0;
                                            NPC[B].CantHurtPlayer = 0;
                                            NPCHit(B, 1, A);

                                            // this is a bug that came from re-using tempLocation.Y in the original code
                                            bouncePlrY = tempLocation.Y;
                                        }
                                    }
                                }
                                else if(NPC[B].Location.SpeedX != 0) // Got hit by the shell
                                {
                                    if(NPC[B].CantHurtPlayer != A && !FreezeNPCs && NPC[B].Type != NPCID_FLIPPED_RAINBOW_SHELL)
                                    {
                                        if(n00bCollision(Player[A].Location, NPC[B].Location))
                                            PlayerHurt(A);
                                    }
                                }
                            }
                            else if(NPC[B]->IsABonus) // Bonus
                                TouchBonus(A, B);
                            else // Everything else
                            {
                                // player-npc hurt routine:

                                // kick the bob-om
                                if((NPC[B].Type == NPCID_LIT_BOMB_S3 || NPC[B].Type == NPCID_HIT_CARRY_FODDER) && NPC[B].HoldingPlayer != A)
                                {
                                    if(NPC[B].TailCD == 0)
                                    {
                                        NPC[B].TailCD = 12;
                                        if(NPC[B].Type != NPCID_HIT_CARRY_FODDER && NPC[B].Type != NPCID_LIT_BOMB_S3)
                                            NewEffect(EFFID_WHACK, newLoc((Player[A].Location.X + NPC[B].Location.X + (Player[A].Location.Width + NPC[B].Location.Width) / 2) / 2, (Player[A].Location.Y + NPC[B].Location.Y + (Player[A].Location.Height + NPC[B].Location.Height) / 2) / 2));
                                        NPCHit(B, 1, A);
                                    }
                                }
                                // don't hurt own thrown items
                                else if(NPC[B].CantHurtPlayer == A) {}
                                // don't hurt NPC of friendly type
                                else if(NPC[B]->WontHurt && !(Player[A].Rolling && NPC[B].Type == NPCID_BOSS_CASE)) {}
                                // also cancel hurt for player-shot bullet
                                else if(NPC[B].Type == NPCID_BULLET && NPC[B].Projectile != 0) {}
                                // special routine for hit turtles that haven't stood up yet
                                else if(NPC[B].Type >= NPCID_GRN_HIT_TURTLE_S4 && NPC[B].Type <= NPCID_YEL_HIT_TURTLE_S4 && NPC[B].Projectile != 0)
                                    NPCHit(B, 3, B);
                                // cancel hurt for dropped items
                                else if(NPC[B].Effect == NPCEFF_DROP_ITEM) {}
                                // someone's going to get hurt...
                                else
                                {
                                    if(InvincibilityTime || (Player[A].SlideKill && !NPC[B]->JumpHurt) || (Player[A].Rolling && Player[A].State == PLR_STATE_SHELL))
                                    {
                                        if(Player[A].Rolling && (NPC[B].Type == NPCID_FIRE_BOSS_SHELL || NPC[B].Type == NPCID_MAGIC_BOSS_SHELL || NPC[B].Type == NPCID_HEAVY_THROWN || NPC[B].Type == NPCID_HOMING_BALL))
                                        {
                                            // be vulnerable to these NPCs while rolling
                                        }
                                        // DO cause damage to VILLAIN_S3 even though it's meant to be immune to this kind of damage.
                                        else if(InvincibilityTime && NPC[B].Type == NPCID_VILLAIN_S3)
                                        {
                                            // But use fireball -- this will take ~6 rounds of invincibility power to kill the boss
                                            NPC[numNPCs + 1].Type = NPCID_PLR_FIREBALL;
                                            NPCHit(B, 3, numNPCs + 1);
                                        }
                                        else
                                            NPCHit(B, 3, B);
                                    }

                                    if(NPC[B].Killed == 0)
                                    {
                                        // don't hurt player by just-hurt boss
                                        if(Player[A].Rolling && (NPC[B].Immune != 0 || (NPC[B].Type == NPCID_SPIT_BOSS && NPC[B].Special5 < 0))) {}
                                        else if(n00bCollision(Player[A].Location, NPC[B].Location))
                                        {
                                            if(BattleMode && NPC[B].HoldingPlayer != A && NPC[B].HoldingPlayer > 0 && Player[A].Immune == 0)
                                                NPCHit(B, 5, B);
                                            PlayerHurt(A);
                                        }
                                    }
                                    else
                                        MoreScore(NPC[B]->Score, NPC[B].Location, Player[A].Multiplier);
                                }

                                // npc block routine

                                // this is for NPC that physically push the player
                                if(NPC[B]->MovesPlayer && NPC[B].Projectile == 0 && Player[A].HoldingNPC != B &&
                                   !(Player[A].Mount == 2 && (NPC[B].Type == NPCID_KEY || NPC[B].Type == NPCID_COIN_SWITCH)) &&
                                   !ShadowMode && NPC[B].Effect != NPCEFF_DROP_ITEM)
                                {
                                    if(Player[A].StandUp && Player[A].StandingOnNPC == 0)
                                    {
                                        if(HitSpot == 5 && Player[A].Location.Y + Player[A].Location.Height - Physics.PlayerDuckHeight[Player[A].Character][Player[A].State] - Player[A].Location.SpeedY >= NPC[B].Location.Y + NPC[B].Location.Height)
                                            HitSpot = 3;
                                    }

                                    if(Player[A].CurMazeZone != 0)
                                    {
                                        // don't actually collide
                                    }
                                    else if(HitSpot == 3)
                                    {
                                        if(NPC[B].Type == NPCID_ICE_CUBE && Player[A].Character != 5 && Player[A].State > 1)
                                            NPCHit(B, 3, B);

                                        Location_t tempLocation = Player[A].Location;

                                        // this is a bug that came from re-using tempLocation.Y in the original code
                                        bouncePlrY = tempLocation.Y;

                                        Player[A].Location.SpeedY = 0.1_n + NPC[B].Location.SpeedY;
                                        Player[A].Location.Y = NPC[B].Location.Y + NPC[B].Location.Height + 0.1_n;

                                        // fBlock = FirstBlock[(Player[A].Location.X / 32) - 1];
                                        // lBlock = LastBlock[((Player[A].Location.X + Player[A].Location.Width) / 32.0) + 1];
                                        // blockTileGet(Player[A].Location, fBlock, lBlock);

                                        for(int C : treeFLBlockQuery(Player[A].Location, SORTMODE_NONE))
                                        {
                                            if(CheckCollision(Player[A].Location, Block[C].Location) &&
                                               !Block[C].Hidden && !BlockIsSizable[Block[C].Type] &&
                                               !BlockOnlyHitspot1[Block[C].Type])
                                            {
                                                Player[A].Location = tempLocation;
                                                break;
                                            }
                                        }

                                        PlaySoundSpatial(SFX_BlockHit, Player[A].Location);
                                        Player[A].Jump = 0;
                                        if(Player[A].Mount == 2)
                                            Player[A].Location.SpeedY += 2;

                                        if(NPC[B].Type == NPCID_METALBARREL || NPC[B].Type == NPCID_CANNONENEMY || NPC[B].Type == NPCID_HPIPE_SHORT || NPC[B].Type == NPCID_HPIPE_LONG || NPC[B].Type == NPCID_VPIPE_SHORT || NPC[B].Type == NPCID_VPIPE_LONG || (NPC[B].Type >= NPCID_TANK_TREADS && NPC[B].Type <= NPCID_SLANT_WOOD_M))
                                        {
                                            if(NPC[B].Location.SpeedY >= Physics.NPCGravity * 20)
                                                PlayerHurt(A);
                                        }
                                    }
                                    // player gets pushed left/right by NPC
                                    else
                                    {
                                        hitWall = true;
                                        // this variable was previously a numf_t
                                        wallNpcSpeed = (num_t)(tempf_t)(NPC[B].Location.SpeedX + (num_t)NPC[B].BeltSpeed);

                                        // reset player speed if not on conveyor belt
                                        bool tempBool = false;
                                        if(Player[A].StandingOnNPC != 0)
                                        {
                                            if(NPC[Player[A].StandingOnNPC].Type == NPCID_CONVEYOR)
                                                tempBool = true;
                                        }

                                        if(Player[A].Rolling)
                                        {
                                            PlaySoundSpatial(SFX_BlockHit, Player[A].Location);

                                            // handle conveyor belts (which move with their layer, not their own SpeedX) correctly
                                            num_t npc_speed = wallNpcSpeed;
                                            if(NPC[B].Type == NPCID_CONVEYOR)
                                                npc_speed = (num_t)Layer[NPC[B].Layer].ApplySpeedX;

                                            // bounce player!
                                            num_t rel_speed = Player[A].Location.SpeedX - npc_speed;
                                            if((rel_speed > 0) == (Player[A].Direction > 0))
                                                Player[A].Location.SpeedX = npc_speed - rel_speed;

                                            if(Player[A].State != PLR_STATE_POLAR)
                                                hitWall = false;
                                        }
                                        else if(!tempBool && NPC[B].Type != NPCID_CHASER)
                                            Player[A].Location.SpeedX = 0.2_n * Player[A].Direction;

                                        // reset player run count
                                        Player[A].RunCount = 0;

                                        // mark moving pinched (if needed)
                                        if(NPC[B].Type != NPCID_KEY && NPC[B].Type != NPCID_COIN_SWITCH && NPC[B].Type != NPCID_CONVEYOR && (NPC[B].Location.SpeedX != 0 || NPC[B].Location.SpeedY != 0 || NPC[B].BeltSpeed) && !(NPC[B].Wings && NPC[B].CantHurtPlayer == A))
                                        {
                                            Player[A].Pinched.Moving = 2;

                                            if(NPC[B].Location.SpeedX != 0 || NPC[B].BeltSpeed)
                                                Player[A].Pinched.MovingLR = true;
                                        }

                                        // save current X location (for NPCs riding player's vehicle)
                                        tempf_t D = (tempf_t)Player[A].Location.X;

                                        // actually move the player
                                        if(NPC[B].Location.to_right_of(Player[A].Location))
                                        {
                                            Player[A].Pinched.Right4 = 2;

                                            if(floorBlock != 0 && num_t::abs(Block[floorBlock].Location.X - NPC[B].Location.X) < 1)
                                            {
                                                Player[A].Location.X = NPC[B].Location.X - Player[A].Location.Width - 1;
                                                Player[A].Location.SpeedY = (num_t)oldSpeedY;
                                            }
                                            else
                                                Player[A].Location.X = NPC[B].Location.X - Player[A].Location.Width - 0.1_n;

                                            if(NPC[Player[A].StandingOnNPC].Type == NPCID_CONVEYOR)
                                                Player[A].Location.X -= 1;

                                            // forget about floors no longer supporting player
                                            if(floorNpc1 > 0)
                                            {
                                                if(NPC[B].Location.X >= NPC[floorNpc1].Location.X - 2 && NPC[B].Location.X <= NPC[floorNpc1].Location.X + 2)
                                                    floorNpc1 = floorNpc2;
                                            }

                                            if(floorNpc2 > 0)
                                            {
                                                if(NPC[B].Location.X >= NPC[floorNpc2].Location.X - 2 && NPC[B].Location.X <= NPC[floorNpc2].Location.X + 2)
                                                    floorNpc2 = 0;
                                            }
                                        }
                                        else
                                        {
                                            Player[A].Pinched.Left2 = 2;

                                            if(floorBlock != 0 && num_t::abs(Block[floorBlock].Location.X + Block[floorBlock].Location.Width - NPC[B].Location.X - NPC[B].Location.Width) < 1)
                                            {
                                                Player[A].Location.X = NPC[B].Location.X + NPC[B].Location.Width + 1;
                                                Player[A].Location.SpeedY = (num_t)oldSpeedY;
                                            }
                                            else
                                                Player[A].Location.X = NPC[B].Location.X + NPC[B].Location.Width + 0.01_n;

                                            // forget about floors no longer supporting player
                                            if(floorNpc1 > 0)
                                            {
                                                if(NPC[B].Location.X + NPC[B].Location.Width >= NPC[floorNpc1].Location.X + NPC[floorNpc1].Location.Width - 2 && NPC[B].Location.X + NPC[B].Location.Width <= NPC[floorNpc1].Location.X + NPC[floorNpc1].Location.Width + 2)
                                                    floorNpc1 = floorNpc2;
                                            }

                                            if(floorNpc2 > 0)
                                            {
                                                if(NPC[B].Location.X + NPC[B].Location.Width >= NPC[floorNpc2].Location.X + NPC[floorNpc2].Location.Width - 2 && NPC[B].Location.X + NPC[B].Location.Width <= NPC[floorNpc2].Location.X + NPC[floorNpc2].Location.Width + 2)
                                                    floorNpc2 = 0;
                                            }
                                        }

                                        // apply speed to vehicle riders if needed
                                        if(Player[A].Mount == 2)
                                        {
                                            D = (tempf_t)(Player[A].Location.X - (num_t)D);

                                            for(int C : NPCQueues::Active.no_change)
                                            {
                                                if(NPC[C].vehiclePlr == A)
                                                {
                                                    NPC[C].Location.X += (num_t)D;
                                                    treeNPCUpdate(C);
                                                }
                                            }

                                            for(int C = 1; C <= numPlayers; C++)
                                            {
                                                if(Player[C].StandingOnVehiclePlr && (g_ClonedPlayerMode || Player[C].StandingOnVehiclePlr == A))
                                                    Player[C].Location.X += (num_t)D;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    // if the player collided on the left or right of some npcs then stop his movement
    if(hitWall)
    {
        if(Player[A].Location.SpeedX + NPC[Player[A].StandingOnNPC].Location.SpeedX + wallNpcSpeed > 0 && Player[A].Controls.Right)
            Player[A].Location.SpeedX = 0.2_n * Player[A].Direction + wallNpcSpeed;
        else if(Player[A].Location.SpeedX + NPC[Player[A].StandingOnNPC].Location.SpeedX + wallNpcSpeed < 0 && Player[A].Controls.Left)
            Player[A].Location.SpeedX = 0.2_n * Player[A].Direction + wallNpcSpeed;
        else
        {
            if(Player[A].Controls.Right || Player[A].Controls.Left)
                Player[A].Location.SpeedX = -NPC[Player[A].StandingOnNPC].Location.SpeedX + 0.2_n * Player[A].Direction;
            else
                Player[A].Location.SpeedX = 0;
        }

        // disable mid-hop jumps (fixes a clipping bug)
        if(Player[A].State == PLR_STATE_AQUATIC && !Player[A].Mount && Player[A].MountSpecial)
            Player[A].MountSpecial = 2;
    }

    if(bounceNpc && Player[A].CurMazeZone)
    {
        if(NPC[bounceNpc].Effect == NPCEFF_MAZE && NPC[bounceNpc].Effect3 != MAZE_DIR_DOWN)
            NPC[bounceNpc].TurnAround = true;

        Player[A].Location.Y = bouncePlrY;
        Player[A].Location.SpeedY += Physics.PlayerJumpVelocity / 2;

        if(Player[A].MazeZoneStatus == MAZE_DIR_DOWN)
            Player[A].MazeZoneStatus |= MAZE_PLAYER_FLIP;
    }
    else if(bounceNpc) // For multiple NPC hits
    {
        // enable another double-jump when Char4 bounces on an NPC
        if(Player[A].Character == 4 && (Player[A].State == 4 || Player[A].State == 5) && !Player[A].SpinJump)
            Player[A].DoubleJump = true;

        Player[A].CanJump = true;

        if(tempSpring)
        {
            Player[A].Jump = Physics.PlayerSpringJumpHeight;
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - 4;
        }
        else
        {
            Player[A].Jump = Physics.PlayerNPCJumpHeight;
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
        }

        if(Player[A].Character == 2)
            Player[A].Jump += 3;

        if(Player[A].SpinJump)
            Player[A].Jump -= 6;

        if(Player[A].State == PLR_STATE_AQUATIC)
            Player[A].Jump += 3;

        if(Player[A].Wet > 0)
            Player[A].Location.SpeedY *= 0.3_r;

        // this is very likely but not certain to be the y value stored when bounceNpc was set
        Player[A].Location.Y = bouncePlrY;

        if(tempShell)
            NewEffect(EFFID_STOMP_INIT, newLoc(Player[A].Location.X + Player[A].Location.Width / 2 - EffectWidth[EFFID_STOMP_INIT] * 0.5_n, Player[A].Location.Y + Player[A].Location.Height - EffectHeight[EFFID_STOMP_INIT] * 0.5_n));
        else if(!tempSpring)
            NewEffect(EFFID_WHACK, newLoc(Player[A].Location.X + Player[A].Location.Width / 2 - 16, Player[A].Location.Y + Player[A].Location.Height - 16));
        else
            tempSpring = false;

        PlayerPush(A, 3);

        if(Player[A].YoshiBlue)
        {
            Player[A].CanFly2 = true;
            Player[A].FlyCount = 300;
        }

        if(spinKill)
        {
            Player[A].Jump = 0;
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity; // * 0.5
        }
    }



    // Find out which NPC to stand on

    int B = 0;

    // this code is for standing on moving NPCs.
    if(floorNpc2 != 0)
    {
        if(NPC[floorNpc1].Location.Y == NPC[floorNpc2].Location.Y)
        {
            num_t C = num_t::abs(NPC[floorNpc1].Location.minus_center_x(Player[A].Location));
            num_t D = num_t::abs(NPC[floorNpc2].Location.minus_center_x(Player[A].Location));

            if(C < D)
                B = floorNpc1;
            else
                B = floorNpc2;
        }
        else if(NPC[floorNpc1].Location.Y < NPC[floorNpc2].Location.Y)
            B = floorNpc1;
        else
            B = floorNpc2;
    }
    else if(floorNpc1 != 0)
        B = floorNpc1;

    if(NPC[floorNpc1].Type >= NPCID_YEL_PLATFORM && NPC[floorNpc1].Type <= NPCID_RED_PLATFORM)
        B = floorNpc1;
    else if(NPC[floorNpc2].Type >= NPCID_YEL_PLATFORM && NPC[floorNpc2].Type <= NPCID_RED_PLATFORM)
        B = floorNpc2;

    if(NPC[B].Effect == NPCEFF_DROP_ITEM)
        B = 0;

    if(NPC[B].Projectile != 0 && NPCIsVeggie(NPC[B]))
        B = 0;

    // B is the number of the NPC that the player is standing on
    // .StandingOnNPC is the number of the NPC that the player was standing on last cycle
    // if B = 0 and .standingonnpc > 0 then the player was standing on something and is no longer standing on something


    if(B > 0 && Player[A].SpinJump)
    {
        if(NPC[B].Type == NPCID_ICE_CUBE)
        {
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity;
            NPC[B].Multiplier += Player[A].Multiplier;
            NPCHit(B, 3, B);
            Player[A].Jump = 7;

            if(Player[A].Character == 2)
                Player[A].Jump += 3;

            if(Player[A].Controls.Down)
            {
                Player[A].Jump = 0;
                Player[A].Location.SpeedY = Physics.PlayerJumpVelocity / 2;
            }

            B = 0;
        }
    }

    if(Player[A].HoldingNPC == B) // cant hold an npc that you are standing on
        B = 0;

    // don't stand on NPCs during maze zone
    if(Player[A].CurMazeZone)
        B = 0;

    // confusing logic, but safe, because StandingOnNPC gets set in ClownCar()
    if(B == 0 && Player[A].StandingOnVehiclePlr > 0 && Player[A].Mount == 0)
        Player[A].Location.SpeedX += (NPC[Player[A].StandingOnNPC].Location.SpeedX + (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed);
    else if(B > 0 && Player[A].StandingOnNPC == 0 && NPC[B].playerTemp && Player[A].Location.SpeedY >= 0)
        Player[A].Location.SpeedX += -(NPC[B].Location.SpeedX + (num_t)NPC[B].BeltSpeed);

    if(movingBlock) // this is for when the player is standing on a moving block
    {
        if(B > 0)
        {
            if(NPC[B].Type == NPCID_ITEM_BURIED)
            {
                // movingBlock = false;
            }
            else
                B = -A;
        }
        else
            B = -A;
    }

    if(B != 0)
    {
        if(Player[A].StandingOnNPC == 0 && (Player[A].GroundPound || Player[A].YoshiYellow))
        {
            numBlock++;
            Block[numBlock].Location.Y = NPC[B].Location.Y;
            // seems weird but I'll sync it since we don't know what could happen inside YoshiPound
            syncLayersTrees_Block(numBlock);

            YoshiPound(A, Player[A].Mount, Player[A].GroundPound);
            Player[A].GroundPound = false;

            Block[numBlock].Location.Y = 0;
            numBlock--;
            syncLayersTrees_Block(numBlock + 1);
        }

        if(NPC[B].playerTemp == 0)
            Player[A].StandingOnVehiclePlr = 0;

        if(Player[A].Location.SpeedY >= 0)
            Player[A].StandingOnNPC = B;

        Player[A].Location.Y = NPC[B].Location.Y - Player[A].Location.Height;

        // NPC has been stood on (condition over NPC types)
        if(NPC[B].Type == NPCID_FALL_BLOCK_RED || NPC[B].Type == NPCID_FALL_BLOCK_BROWN)
            NPC[B].Special2 = 1;
        else if(NPC[B].Type == NPCID_CHECKER_PLATFORM)
            NPC[B].Special = 1;
        else if(NPC[B].Type == NPCID_PLATFORM_S3)
        {
            if(Player[A].Location.SpeedY > 0)
                NPC[B].Direction = 1;
        }
        else if(NPC[B].Type == NPCID_RAFT)
        {
            if(NPC[B].Special == 0)
            {
                NPC[B].Special = 1;
                SkullRide(B);
            }
        }
        else if(NPC[B].Type == NPCID_CONVEYOR)
            Player[A].Location.SpeedY = 0;
        else if(NPC[B].Type == NPCID_VEHICLE)
        {
            if(Player[A].Controls.Down && Player[A].Mount == 0 &&
               !NPC[B].playerTemp && Player[A].DuckRelease &&
               (Player[A].HoldingNPC == 0 || Player[A].Character == 5))
            {
                UnDuck(Player[A]);

                if(g_config.fix_char5_vehicle_climb && Player[A].Fairy) // Avoid the mortal glitch
                {
                    Player[A].Fairy = false;
                    PlaySoundSpatial(SFX_HeroFairy, Player[A].Location);
                    NewEffect(EFFID_SMOKE_S5, Player[A].Location);
                }

                if(g_config.fix_vehicle_altjump_bug)
                    Player[A].SpinJump = false;

                Player[A].Location = NPC[B].Location;
                Player[A].Mount = 2;
                NPC[B].Killed = 9;
                NPCQueues::Killed.push_back(B);
                Player[A].HoldingNPC = 0;
                Player[A].StandingOnNPC = 0;
                PlaySoundSpatial(SFX_Stomp, Player[A].Location);
                for(int C = 1; C <= numPlayers; ++C)
                {
                    if(Player[C].StandingOnNPC == B)
                        Player[C].StandingOnVehiclePlr = A;
                }

                B = 0;
            }
        }

        if(Player[A].Mount == 2 && B != 0)
        {
            Player[A].StandingOnNPC = 0;
            if(Player[A].Location.SpeedY > 4 + NPC[B].Location.SpeedY)
                PlaySoundSpatial(SFX_Stone, Player[A].Location);
            Player[A].Location.SpeedY = NPC[B].Location.SpeedY;
        }
    }
    else if(Player[A].Mount == 1 && Player[A].Jump == 0)
    {
        if(Player[A].StandingOnNPC != 0)
        {
            if(Player[A].Location.X > NPC[Player[A].StandingOnNPC].Location.X + NPC[Player[A].StandingOnNPC].Location.Width || Player[A].Location.X + Player[A].Location.Width < NPC[Player[A].StandingOnNPC].Location.X)
            {
                Player[A].StandingOnNPC = 0;
                Player[A].StandingOnVehiclePlr = 0;

                if(Player[A].Location.SpeedY > 4.1_n)
                {
                    Player[A].Location.Y += -Player[A].Location.SpeedY;
                    Player[A].Location.SpeedY = NPC[0 /*Player[A].StandingOnNPC*/].Location.SpeedY; // SMBX 1.3 bug

                    if(Player[A].Location.SpeedY > Physics.PlayerTerminalVelocity)
                        Player[A].Location.SpeedY = Physics.PlayerTerminalVelocity;

                    Player[A].Location.Y += Player[A].Location.SpeedY;
                }
            }
        }
    }
    else if(Player[A].Mount == 1 && Player[A].Jump > 0)
    {
        // confusing logic, but safe, because StandingOnNPC gets set in ClownCar()
        // NOTE: we know that B == 0!
        if(/*B == 0 &&*/ Player[A].StandingOnVehiclePlr > 0)
            Player[A].Location.SpeedX += (NPC[Player[A].StandingOnNPC].Location.SpeedX + (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed);
        // else if(B > 0 && Player[A].StandingOnNPC == 0 && NPC[B].playerTemp)
        //     Player[A].Location.SpeedX += -(NPC[B].Location.SpeedX + NPC[B].BeltSpeed);

        Player[A].StandingOnNPC = 0;
        Player[A].StandingOnVehiclePlr = 0;
    }
    else
    {
        // Vanilla bugfix: the player is normally forced to stay on a moving NPC by allowing its downwards speed to reach the terminal velocity (12).
        // And then this code "unsets" that extreme downwards speed. But if the player's SpeedY has been changed since that time, unexpected things can happen:
        // * If it became negative (upwards), then the player will clip downward through the moving NPC here (by subtracting that upwards value from the Y coordinate). This occurs when Char5 is hurt on Mushroom Heights in Princess Cliche.
        // * If the player hit ground, then the player's speed should now be zero. But this will reset it to being downward, possibly allowing downward clipping. This occurs with NPCID_CHECKER_PLATFORM in Frozen Valley in The Fallen Spirits.
        // * This fix shouldn't apply to moving blocks (which have negative NPC indexes) because the player's speed is sometimes set to 0 or 1 while on a moving block, and in those cases this code helps the player keep moving with the block. (Check with Autumn Area in Marathon: ATWAB.)
        // * Since v1.3.7.2: this fix shouldn't apply when the player would be pushed upwards by staying with the NPC (instead of downwards). This replaces the hardcoded check from v1.3.7.1 where the fix required the player's speed to be less than 8 (NPC terminal velocity). (Fixes running on series of NPCID_FALL_BLOCK_RED with gaps.)
        if(Player[A].StandingOnNPC != 0 && !(Player[A].StandingOnNPC > 0 && g_config.fix_player_downward_clip && Player[A].Location.SpeedY < NPC[Player[A].StandingOnNPC].Location.SpeedY))
        {
            if(Player[A].StandingOnNPC < 0)
                Player[A].Location.SpeedX += NPC[Player[A].StandingOnNPC].Location.SpeedX;

            Player[A].Location.Y += -Player[A].Location.SpeedY;
            Player[A].Location.SpeedY = NPC[Player[A].StandingOnNPC].Location.SpeedY;

            if(FreezeNPCs)
                Player[A].Location.SpeedY = 0;
            if(Player[A].Location.SpeedY > Physics.PlayerTerminalVelocity)
                Player[A].Location.SpeedY = Physics.PlayerTerminalVelocity;

            Player[A].Location.Y += Player[A].Location.SpeedY;
        }

        Player[A].StandingOnNPC = 0;
        Player[A].StandingOnVehiclePlr = 0;
    }

    if(Player[A].StandingOnNPC > 0 && Player[A].Mount == 0) // driving stuff
    {
        if(NPC[Player[A].StandingOnNPC].Type == NPCID_COCKPIT)
        {
            Player[A].Driving = true;
            Player[A].Location.X = NPC[Player[A].StandingOnNPC].Location.X + (NPC[Player[A].StandingOnNPC].Location.Width - Player[A].Location.Width) / 2;
            Player[A].Direction = NPC[Player[A].StandingOnNPC].DefaultDirection;
        }
    }
}


================================================
FILE: src/player/player_pinched_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "config.h"

void PlayerPinchedTimerUpdate(int A)
{
    if(Player[A].Pinched.Bottom1 > 0)
        Player[A].Pinched.Bottom1 -= 1;

    if(Player[A].Pinched.Left2 > 0)
        Player[A].Pinched.Left2 -= 1;

    if(Player[A].Pinched.Top3 > 0)
        Player[A].Pinched.Top3 -= 1;

    if(Player[A].Pinched.Right4 > 0)
        Player[A].Pinched.Right4 -= 1;

    if(Player[A].Pinched.Moving > 0)
    {
        Player[A].Pinched.Moving -= 1;

        if(Player[A].Pinched.Moving == 0)
        {
            Player[A].Pinched.MovingLR = false;
            Player[A].Pinched.MovingUD = false;
        }
    }

    if(Player[A].Effect == PLREFF_NORMAL && Player[A].Pinched.Strict > 0)
        Player[A].Pinched.Strict -= 1;
}

void PlayerPinchedDeathCheck(int A)
{
    const auto& pi = Player[A].Pinched;

    bool vcrush = pi.Bottom1 && pi.Top3;
    bool hcrush = pi.Left2 && pi.Right4;

    // something strange happened to rolling player and they would have been killed -- force them into normal state instead
    if(pi.MovingLR && hcrush && Player[A].Rolling)
    {
        Player[A].Location.SpeedX = 0;
        Player[A].Immune = 5;
        hcrush = false;
    }

    // When the player is pushed through the floor or stops ducking while being crushed, they get left+right hits but no bottom hit
    bool vcrush_plus = vcrush || (hcrush && (pi.Bottom1 || pi.Top3));

    bool old_condition = pi.Moving && (vcrush || hcrush);

    bool new_condition = (pi.MovingUD && vcrush_plus) || (pi.MovingLR && hcrush);

    bool pinch_death = (g_config.fix_player_crush_death && !pi.Strict) ? new_condition : old_condition;

    if(pinch_death && Player[A].Mount != 2)
    {
        if(Player[A].Mount != 2)
            Player[A].Mount = 0;

        Player[A].State = 1;
        Player[A].Immune = 0;
        Player[A].Immune2 = false;

        // Pinch death should occur (but might get cancelled for some reason); set a timer of 15 frames to use stricter old condition
        // Why is that needed here? The details of hitspot detection mean that if a player is pushed through the floor, they get left+right hits, but no bottom hit
        Player[A].Pinched.Strict = 15;
        PlayerHurt(A);
    }
}


================================================
FILE: src/player/player_screen_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#include "globals.h"
#include "player.h"
#include "graphics.h"
#include "screen.h"
#include "blocks.h"
#include "collision.h"
#include "config.h"
#include "phys_env.h"

#include "main/trees.h"
#include "main/game_globals.h"

void PlayerSharedScreenLogic(int A)
{
    Screen_t& screen = ScreenByPlayer(A);

    // if(!LevelWrap[Player[A].Section] && LevelMacro == LEVELMACRO_OFF)
    // This section is fully new logic
    if(screen.Type == ScreenTypes::SharedScreen)
    {
        Player_t& p = Player[A];
        const SpeedlessLocation_t& section = level[p.Section];

        const vScreen_t& vscreen = vScreenByPlayer(A);

        // section for shared screen push
        bool check_left = true;
        bool check_right = true;

        bool vscreen_at_section_bound_left = -vscreen.X <= section.X + 8;
        bool vscreen_at_section_bound_right = -vscreen.X + vscreen.Width >= section.Width - 8;

        // normally, don't use the shared screen push at section boundaries
        if(vscreen_at_section_bound_left)
            check_left = false;

        if(vscreen_at_section_bound_right)
            check_right = false;

        // do use shared screen push if there's a different player at the other side of the screen
        for(int o_p_i = 0; o_p_i < screen.player_count; o_p_i++)
        {
            const Player_t& o_p = Player[screen.players[o_p_i]];

            if(o_p.Dead || o_p.TimeToLive || o_p.Effect == PLREFF_COOP_WINGS)
                continue;

            if(o_p.Location.X <= -vscreen.X + 8 && !vscreen_at_section_bound_left)
                check_right = true;
            else if(o_p.Location.X + o_p.Location.Width >= -vscreen.X + vscreen.Width - 8 && !vscreen_at_section_bound_right)
                check_left = true;
        }

        if(p.Location.X <= -vscreen.X + 8 && check_left)
        {
            if(p.Location.X <= -vscreen.X)
            {
                p.Location.X = -vscreen.X;

                // give wings to a player that would be killed by pinching
                if(p.Pinched.Right4 && p.Pinched.Moving && !p.Pinched.Left2)
                    p.Effect = PLREFF_COOP_WINGS;
                else
                    p.Pinched.Left2 = 2;

                if(p.Location.SpeedX < 0)
                    p.Location.SpeedX = 0;

                if(p.CurMazeZone && (p.MazeZoneStatus % 4) == MAZE_DIR_LEFT)
                    p.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                else if(p.CurMazeZone && (p.MazeZoneStatus % 4) != MAZE_DIR_RIGHT)
                {
                    p.CurMazeZone = 0;
                    p.Effect = PLREFF_COOP_WINGS;
                }
            }

            if(p.Location.SpeedX >= 0 && p.Location.SpeedX < 1)
                p.Location.SpeedX = 1;

            // give wings to a player that gets stuck to the left
            if(NoTurnBack[p.Section] && p.Pinched.Right4)
                p.Effect = PLREFF_COOP_WINGS;
        }
        else if(p.Location.X + p.Location.Width >= -vscreen.X + vscreen.Width - 8 && check_right)
        {
            if(p.Location.X + p.Location.Width >= -vscreen.X + vscreen.Width)
            {
                p.Location.X = -vscreen.X + vscreen.Width - p.Location.Width;

                // give wings to a player that would be killed by pinching
                if(p.Pinched.Left2 && p.Pinched.Moving && !p.Pinched.Right4)
                    p.Effect = PLREFF_COOP_WINGS;
                else
                    p.Pinched.Right4 = 2;

                if(p.Location.SpeedX > 0)
                    p.Location.SpeedX = 0;

                if(p.CurMazeZone && (p.MazeZoneStatus % 4) == MAZE_DIR_RIGHT)
                    p.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                else if(p.CurMazeZone && (p.MazeZoneStatus % 4) != MAZE_DIR_LEFT)
                {
                    p.CurMazeZone = 0;
                    p.Effect = PLREFF_COOP_WINGS;
                }
            }

            if(p.Location.SpeedX > -1 && p.Location.SpeedX <= 0)
                p.Location.SpeedX = -1;
        }


        // give wings to a player that falls offscreen but not off-section
        if(p.Location.Y > -vscreen.Y + vscreen.Height + 64 && p.Location.Y <= level[p.Section].Height)
            p.Effect = PLREFF_COOP_WINGS;

        if(p.Effect == PLREFF_COOP_WINGS)
        {
            SharedScreenAvoidJump_Pre(screen);
            p.Dead = true;
            p.Effect2 = 0;
            SizeCheck(p);
            SharedScreenAvoidJump_Post(screen, 0);
        }
    }
}

void PlayerEffectWings(int A)
{
    Screen_t& screen = ScreenByPlayer(A);
    Player_t& p = Player[A];

    // check if the player should be moving towards another player or towards the screen
    int target_plr = CheckNearestLiving(A);
    if(target_plr)
        p.Section = Player[target_plr].Section;

    int vscreen_i;
    if(target_plr && screen.Type != ScreenTypes::SharedScreen)
        vscreen_i = vScreenIdxByPlayer(target_plr);
    else
        vscreen_i = vScreenIdxByPlayer(A);

    const vScreen_t& vscreen = vScreen[vscreen_i];

    p.Fairy = false;

    bool button_pressed = p.Controls.Jump && p.CanJump;
    if(p.Controls.Jump)
        p.CanJump = false;

    int WingsFrame = 0;

    if(!button_pressed)
        target_plr = 0;

    bool offscreen = !vScreenCollision(vscreen_i, p.Location);

    // force to be close to the screen
    if(offscreen)
    {
        if(p.Location.X + p.Location.Width < -vscreen.X - 100)
            p.Location.X = -vscreen.X - 100 - p.Location.Width;
        if(p.Location.X > -vscreen.X + vscreen.Width + 100)
            p.Location.X = -vscreen.X + vscreen.Width + 100;
        if(p.Location.Y + p.Location.Height < -vscreen.Y - 100)
            p.Location.Y = -vscreen.Y - 100 - p.Location.Height;
        if(p.Location.Y > -vscreen.Y + vscreen.Height + 100)
            p.Location.Y = -vscreen.Y + vscreen.Height + 100;
    }

    // move towards screen center or living player
    if(target_plr || offscreen)
    {
        num_t target_X = (target_plr) ? (Player[target_plr].Location.X + Player[target_plr].Location.Width / 2) : -vscreen.X + vscreen.Width / 2;
        num_t target_Y = (target_plr) ? Player[target_plr].Location.Y - 8 : -vscreen.Y + vscreen.Height / 2;

        int randomness = (target_plr) ? 8 : vscreen.Width / 10;
        target_X += iRand(randomness * 2) - randomness;
        target_Y += iRand(randomness * 2) - randomness;

        num_t center_X = p.Location.X + p.Location.Width / 2;
        num_t center_Y = p.Location.Y + p.Location.Height / 2;

        num_t target_SpeedX = (target_X - center_X);
        num_t target_SpeedY = (target_Y - center_Y);

        num_t target_speed = num_t::dist(target_SpeedX, target_SpeedY);

        if(target_speed != 0)
        {
            target_SpeedX = (target_SpeedX * 8).divided_by(target_speed);
            target_SpeedY = (target_SpeedY * 8).divided_by(target_speed);
        }

        p.Location.SpeedX = (p.Location.SpeedX + target_SpeedX) / 2;
        p.Location.SpeedY = (p.Location.SpeedY + target_SpeedY) / 2;

        if(SoundPause[SFX_Swim] == 0)
        {
            PlaySoundSpatial(SFX_Swim, p.Location);
            SoundPause[SFX_Swim] = 15;
        }
    }
    // deceleration
    else
    {
        num_t sq_speed = num_t::dist2(p.Location.SpeedX, p.Location.SpeedY);
        qdec_t decelerate_rate = (sq_speed > 4) ? 0.95_r : (sq_speed > 1) ? 0.99_r : 0.999_r;

        if(sq_speed <= 4)
        {
            WingsFrame = 1;

            if(!p.Controls.Jump)
                p.CanJump = true;
        }

        p.Location.SpeedX *= decelerate_rate;
        p.Location.SpeedY *= decelerate_rate;
    }

    // update frame
    p.SpinJump = false;
    p.WetFrame = false;
    if(p.Location.SpeedY == 0)
        p.Location.SpeedY = 0.00001_n;
    PlayerFrame(p);
    if(p.Location.SpeedX >= 0)
    {
        p.Direction = 1;
        p.YoshiWingsFrame = WingsFrame + 2;
    }
    else
    {
        p.Direction = -1;
        p.YoshiWingsFrame = WingsFrame;
    }

    // apply movement
    p.Location.X += p.Location.SpeedX;
    p.Location.Y += p.Location.SpeedY;

    // tag other players
    bool found_player = false;
    for(int B = 1; B <= numPlayers; B++)
    {
        if(Player[B].Dead || Player[B].TimeToLive != 0 || Player[B].Effect != PLREFF_NORMAL)
            continue;

        if(!CheckCollision(Player[A].Location, Player[B].Location))
            continue;

        found_player = true;
        break;
    }

    // just collided with player
    if(found_player && !p.Effect2)
    {
        // if we're inside a block, then we can't respawn yet
        bool hit_block = false;
        for(BlockRef_t b_ref : treeBlockQuery(Player[A].Location, SORTMODE_NONE))
        {
            const Block_t& b = b_ref;
            int B = (int)b_ref;

            if(b.Hidden || b.Invis || BlockIsSizable[b.Type] || BlockOnlyHitspot1[b.Type] || BlockNoClipping[b.Type])
                continue;

            if(BlockCheckPlayerFilter(B, A))
                continue;

            if(!CheckCollision(Player[A].Location, b.Location))
                continue;

            if(BlockSlope[b.Type] || BlockSlope2[b.Type])
                continue;

            hit_block = true;
            break;
        }

        if(!hit_block)
        {
            p.Effect = PLREFF_NORMAL;
            PlayerCollide(A);
            PlaySoundSpatial(SFX_Transform, p.Location);
        }
    }

    p.Effect2 = found_player;

    if(p.Effect != PLREFF_COOP_WINGS)
    {
        SharedScreenAvoidJump_Pre(screen);

        p.Dead = false;
        p.CanJump = false;
        p.Effect2 = 0;
        p.Immune = 50;
        p.Immune2 = false;
        CheckSection(A);
        PlayerFrame(p);

        SharedScreenAvoidJump_Post(screen, 0);
    }
}

void PlayerLevelWrapLogic(int A)
{
    const Screen_t& screen = ScreenByPlayer(A);
    vScreen_t& vscreen = vScreenByPlayer(A);
    Location_t& pLoc = Player[A].Location;
    const SpeedlessLocation_t& section = level[Player[A].Section];

    // track whether screen wrapped in each of the four ways
    bool did_wrap_lr = false;
    bool did_wrap_rl = false;
    bool did_wrap_tb = false;
    bool did_wrap_bt = false;

    // horizontally
    if(LevelWrap[Player[A].Section])
    {
        if(pLoc.X + pLoc.Width < section.X)
        {
            pLoc.X = section.Width - 1;

            if(vscreen.Width < section.Width - section.X)
                did_wrap_lr = true;
        }
        else if(pLoc.X > section.Width)
        {
            pLoc.X = section.X - pLoc.Width + 1;

            if(vscreen.Width < section.Width - section.X)
                did_wrap_rl = true;
        }
    }

    // vertically
    if(LevelVWrap[Player[A].Section])
    {
        if(pLoc.Y + pLoc.Height < section.Y)
        {
            pLoc.Y = section.Height - 1;

            if(vscreen.Height < section.Height - section.Y)
                did_wrap_tb = true;
        }
        else if(pLoc.Y > section.Height)
        {
            pLoc.Y = section.Y - pLoc.Height + 1;

            if(vscreen.Height < section.Height - section.Y)
                did_wrap_bt = true;
        }
    }

    // shared screen: teleport other players to other side of section
    if(screen.Type == ScreenTypes::SharedScreen && (did_wrap_lr || did_wrap_rl || did_wrap_tb || did_wrap_bt))
    {
        num_t target_Y = pLoc.Y + ((Player[A].Mount != 2) ? pLoc.Height : 0);

        for(int i = 0; i < screen.player_count; i++)
        {
            int o_A = screen.players[i];

            if(o_A == A)
                continue;

            Player_t& o_p = Player[o_A];

            if(o_p.Dead)
                continue;

            // center on player that wrapped
            o_p.Location.X = pLoc.X + (pLoc.Width - o_p.Location.Width) / 2;
            o_p.Location.Y = target_Y - ((o_p.Mount != 2) ? o_p.Location.Height : 0);

            // make sure fully in section
            if(did_wrap_lr)
            {
                o_p.Location.X = section.Width - 1;
                if(o_p.Location.SpeedX > 0)
                    o_p.Location.SpeedX = 0;
            }

            if(did_wrap_rl)
            {
                o_p.Location.X = section.X - o_p.Location.Width + 1;
                if(o_p.Location.SpeedX < 0)
                    o_p.Location.SpeedX = 0;
            }

            if(did_wrap_tb)
                o_p.Location.Y = section.Height - 1;

            if(did_wrap_bt)
                o_p.Location.Y = section.Y - o_p.Location.Height + 1;

            // following effects only needed for living players
            if(o_p.TimeToLive != 0)
                continue;

            // remove from any pet's mouth that doesn't belong to this screen
            bool onscreen_pet = InOnscreenPet(o_A, screen);

            // disable collisions and remove from any offscreen pets
            if(!onscreen_pet)
            {
                RemoveFromPet(o_A);
                o_p.Effect = PLREFF_RESPAWN;
                o_p.RespawnY = o_p.Location.Y;
            }
        }

        GetvScreenAuto(vscreen);
    }
}

void PlayerOffscreenExitCheck(int A)
{
    bool offScreenExit = false;
    num_t nearby_left = (Player[A].Location.X + Player[A].Location.Width) - level[Player[A].Section].X;
    num_t nearby_right = level[Player[A].Section].Width - Player[A].Location.X;
    if(nearby_left < 0)
    {
        offScreenExit = true;
        for(int B = 1; B <= numPlayers; B++)
            Player[B].TailCount = 0;
    }
    else if(nearby_right < 0)
    {
        offScreenExit = true;
    }

    if(offScreenExit)
    {
        // Always quit to the world map by off-screen exit
        if(!NoMap && !FileRecentSubHubLevel.empty())
        {
            FileRecentSubHubLevel.clear();
            ReturnWarp = 0;
            ReturnWarpSaved = 0;
        }

        LevelBeatCode = BEATCODE_OFFSCREEN;
        EndLevel = true;
        LevelMacro = LEVELMACRO_OFF;
        LevelMacroCounter = 0;

        if(!GoToLevelNoGameThing)
        {
            if(g_config.EnableInterLevelFade)
                g_levelScreenFader.setupFader(4, 0, 65, ScreenFader::S_FADE);
            else
                g_levelScreenFader.setupFader(65, 0, 65, ScreenFader::S_FADE);

            levelWaitForFade(16);
            g_ShortDelay = true;
        }
    }
}

void PlayerLevelEdgeCheck(int A, bool check_X)
{
    if(check_X)
    {
        // Check edge of levels
        if(Player[A].Location.X < level[Player[A].Section].X)
        {
            Player[A].Location.X = level[Player[A].Section].X;

            if(Player[A].Location.SpeedX < 0)
                Player[A].Location.SpeedX = 0;

            Player[A].Pinched.Left2 = 2;

            if(AutoX[Player[A].Section] != 0)
            {
                Player[A].Pinched.Moving = 2;
                Player[A].Pinched.MovingLR = true;
            }
        }
        else if(Player[A].Location.X + Player[A].Location.Width > level[Player[A].Section].Width)
        {
            Player[A].Location.X = level[Player[A].Section].Width - Player[A].Location.Width;

            if(Player[A].Location.SpeedX > 0)
                Player[A].Location.SpeedX = 0;

            Player[A].Pinched.Right4 = 2;

            if(AutoX[Player[A].Section] != 0)
            {
                Player[A].Pinched.Moving = 2;
                Player[A].Pinched.MovingLR = true;
            }
        }
    }

    if(Player[A].Location.Y < level[Player[A].Section].Y - Player[A].Location.Height - 32 && Player[A].StandingOnVehiclePlr == 0)
    {
        Player[A].Location.Y = level[Player[A].Section].Y - Player[A].Location.Height - 32;

        if(AutoY[Player[A].Section] != 0)
        {
            Player[A].Pinched.Moving = 3;
            Player[A].Pinched.MovingUD = true;
        }
    }
}

void PlayerLevelBoundsLogic(int A)
{
    // When it's true - don't check horizontal section's bounds
    bool hBoundsHandled = false;

    // level wrap
    if(LevelWrap[Player[A].Section] || LevelVWrap[Player[A].Section])
        PlayerLevelWrapLogic(A);

    if(LevelWrap[Player[A].Section])
        hBoundsHandled = true;

    // Walk offscreen exit
    if(!hBoundsHandled && OffScreenExit[Player[A].Section])
    {
        PlayerOffscreenExitCheck(A);
        hBoundsHandled = true;
    }

    if(LevelMacro == LEVELMACRO_CARD_ROULETTE_EXIT || LevelMacro == LEVELMACRO_GOAL_TAPE_EXIT || LevelMacro == LEVELMACRO_FLAG_EXIT || GameMenu)
        hBoundsHandled = true;

    PlayerLevelEdgeCheck(A, !hBoundsHandled);
}


================================================
FILE: src/player/player_update.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>

#include "../globals.h"
#include "../config.h"
#include "../player.h"
#include "player/player_effect.h"
#include "player/player_update_priv.h"
#include "../collision.h"
#include "../sound.h"
#include "../blocks.h"
#include "../npc.h"
#include "../effect.h"
#include "../layers.h"
#include "../editor.h"
#include "../game_main.h"
#include "../main/trees.h"
#include "../frame_timer.h"
#include "../graphics.h"
#include "../controls.h"
#include "../script/msg_preprocessor.h"

#include "npc_id.h"
#include "npc_traits.h"
#include "eff_id.h"

#include "npc/npc_queues.h"
#include "main/game_loop_interrupt.h"


void p_PlayerMakeFlySparkle(const Location_t& loc, int Frame)
{
    num_t dx = dRand();
    num_t dy = dRand();
    NewEffect(EFFID_SPARKLE,
        newLoc(loc.X - 8 + dx * ((int)loc.Width + 16) - 4,
            loc.Y - 8 + dy * ((int)loc.Height + 16)),
        1, ShadowMode);
    Effect[numEffects].Location.SpeedX = (dRand() / 2) - 0.25_n;
    Effect[numEffects].Location.SpeedY = (dRand() / 2) - 0.25_n;
    Effect[numEffects].Frame = Frame;
}

static void UpdateInvincibility()
{
    if(InvincibilityTime <= 0 || FreezeNPCs || LevelMacro != LEVELMACRO_OFF || !CheckLiving())
        return;

    if(InvincibilityTime == Physics.NPCPSwitch && !GameMenu)
    {
        StopMusic();
        StartMusic(-1);
    }

    InvincibilityTime--;

    if(InvincibilityTime == 195)
        PlaySound(SFX_CoinSwitchTimeout);

    if(InvincibilityTime == 0)
    {
        for(int A = 1; A <= numPlayers; A++)
        {
            if(!Player[A].Dead && Player[A].TimeToLive == 0)
                Player[A].Immune += 120;
        }

        if(!GameMenu)
            SwitchEndResumeMusic();
    }
}

bool UpdatePlayer()
{
    // these variables do not persist over the interrupt/resume routine
    num_t SlippySpeedX;
    tempf_t cursed_value_C;

    switch(g_gameLoopInterrupt.site)
    {
    case GameLoopInterrupt::UpdatePlayer_MessageNPC:
        goto resume_MessageNPC;
    case GameLoopInterrupt::UpdatePlayer_TriggerTalk:
        goto resume_TriggerTalk;
    case GameLoopInterrupt::UpdatePlayer_SuperWarp:
        goto resume_SuperWarp;
    default:
        break;
    }

    // these variables persist over the interrupt/resume routine
    int A;
    bool tempSpring;
    bool tempShell;
    tempSpring = false; // this one is probably safe to not share between players. it is reset between players unless tempShell is also hit
    tempShell = false; // this one marks whether a player has collided with a shell in the current frame and modifies the effects created when any player hits the top of NPC

    UpdateInvincibility(); // updates player invincibility status

    StealBonus(); // allows a dead player to come back to life by using a 1-up
    ClownCar(); // updates players in the clown car


    // A is the current player, numPlayers is the last player. this loop updates all the players
    for(A = 1; A <= numPlayers; A++)
    {
        // reset variables
        Player[A].ShowWarp = 0;
        Player[A].mountBump = 0;

        // this was shared over players in SMBX 1.3 -- if the line marked "MOST CURSED LINE" in player_block_logic.cpp becomes a source of incompatibility, we will need to restore that logic
        // this will include modifying the GameLoopInterrupt struct to include it
        // for now, this variable does not persist over the interrupt/resume routine
        cursed_value_C = 0;

        if(Player[A].GrabTime > 0) // if grabbing something, take control away from the player
        {
            Player[A].Slide = false;
            Player[A].Controls.Run = true;
            Player[A].Controls.Down = true;
            Player[A].Controls.AltRun = false;
            Player[A].Controls.Jump = false;
            Player[A].Controls.AltJump = false;
        }

        if(Player[A].Dismount > 0) // count down to being able to hop in a shoe or yoshi
            Player[A].Dismount -= 1;

        if(Player[A].Mount != 0 || Player[A].Stoned || Player[A].Fairy) // if .holdingnpc is -1 then the player can't grab anything. this stops the player from grabbing things while on a yoshi/shoe
            Player[A].HoldingNPC = -1;
        else if(Player[A].HoldingNPC == -1)
            Player[A].HoldingNPC = 0;

        if(Player[A].Controls.Drop && Player[A].DropRelease && Player[A].Effect != PLREFF_COOP_WINGS)
        {
            // this is for the single player coop cheat code
            if(SingleCoop > 0 && Player[A].Controls.Down)
                SwapCoop();
            else
                DropBonus(A);
        }

        // for dropping something from the container. this makes the player have to let go of the drop button before dropping something else
        Player[A].DropRelease = !Player[A].Controls.Drop;

        // Handle the death effecs
        if(Player[A].TimeToLive > 0)
            UpdatePlayerTimeToLive(A);
        else if(Player[A].Effect == PLREFF_COOP_WINGS)
            PlayerEffectWings(A);
        else if(Player[A].Dead)
            UpdatePlayerDead(A);
        else
        {
            if(Player[A].SlideCounter > 0) // for making the slide Effect
                Player[A].SlideCounter -= 1;

            if(Player[A].Effect == PLREFF_NORMAL)
            {
                // NEW: used for compat flag "fix-player-clip-wall-at-npc"
                // this variable does not persist over the interrupt/resume routine
                int oldStandingOnNpc;
                oldStandingOnNpc = Player[A].StandingOnNPC;

                // for the pound pet mount logic
                PlayerPoundLogic(A);

                SizeCheck(Player[A]); // check that the player is the correct size for it's character/state/mount and set it if not

                if(Player[A].Stoned) // stop the player from climbing/spinning/jumping when in tanooki statue form
                {
                    Player[A].Jump = 0;
                    Player[A].Vine = 0;
                    Player[A].SpinJump = false;
                    Player[A].Controls.Left = false;
                    Player[A].Controls.Right = false;
                    Player[A].Controls.AltJump = false;
                    Player[A].Controls.Jump = false;
                    Player[A].CanAltJump = false;
                    Player[A].CanJump = false;
                }

                // let the player slide if not on a mount and holding something
                if(Player[A].GrabTime > 0)
                    Player[A].Slide = false;

                if(Player[A].Rolling)
                    Player[A].Slide = true;
                else if(Player[A].Slope > 0 && Player[A].Controls.Down &&
                   Player[A].Mount == 0 && Player[A].HoldingNPC == 0 &&
                   !(Player[A].Character == 3 || Player[A].Character == 4 || Player[A].Character == 5) &&
                   Player[A].GrabTime == 0)
                {
                    // prioritize rolling for Polar power
                    if(!(Player[A].State == PLR_STATE_POLAR && num_t::abs(Player[A].Location.SpeedX) > 1 && BlockSlope[Block[Player[A].Slope].Type] == Player[A].Direction))
                    {
                        if(Player[A].Duck)
                            UnDuck(Player[A]);
                        Player[A].Slide = true;
                    }
                }
                else if(Player[A].Location.SpeedX == 0)
                    Player[A].Slide = false;

                if(Player[A].Mount > 0 || Player[A].HoldingNPC > 0)
                    Player[A].Slide = false;

                // unduck a player that shouldn't be able to duck
                if(Player[A].Duck && (Player[A].Character == 1 || Player[A].Character == 2) && Player[A].State == 1 && (Player[A].Mount == 0 || Player[A].Mount == 2))
                    UnDuck(Player[A]);

                if(GameMenu && !Player[A].SpinJump) // force the player to look right when on the game menu
                    Player[A].Direction = 1;

                WaterCheck(A); // This sub handles all the water related stuff

                PowerUps(A); // misc power-up code

                if(Player[A].StandingOnNPC > 0)
                {
                    if(NPC[Player[A].StandingOnNPC].Type == NPCID_ICE_CUBE && NPC[Player[A].StandingOnNPC].Location.SpeedX == 0)
                        Player[A].Slippy = true;
                }

                if((Player[A].State == PLR_STATE_AQUATIC || Player[A].State == PLR_STATE_POLAR) && !Player[A].Mount && !Player[A].HoldingNPC && !Player[A].Vine && Player[A].WetFrame && !Player[A].Quicksand)
                {
                    if(Player[A].CurMazeZone)
                    {
                        // just keep things as they are
                    }
                    else if(!Player[A].AquaticSwim)
                    {
                        Player[A].SwimCount = 0;
                        Player[A].FrameCount = 0;

                        // face up!
                        if(Player[A].Location.SpeedY < 0 && !Player[A].Immune && Player[A].State == PLR_STATE_POLAR)
                            Player[A].Frame = 42;
                        else
                            Player[A].Frame = 18;

                        Player[A].AquaticSwim = true;
                    }
                }
                else
                    Player[A].AquaticSwim = false;

                // maze zone movement fully bypasses normal movement routines
                if(Player[A].CurMazeZone)
                    PlayerMazeZoneMovement(A);
                // first stage of flag exit
                else if(LevelMacro == LEVELMACRO_FLAG_EXIT && LevelMacroWhich < 0)
                    PlayerFlagSlideMovement(A);
                // normal player movement
                else
                {
                    // this variable does not persist over the interrupt/resume routine
                    SlippySpeedX = Player[A].Location.SpeedX;


                    // Player's X movement. ---------------------------

                    // Code used to move the player while sliding down a slope
                    if(Player[A].Slide && !Player[A].Rolling)
                        PlayerSlideMovementX(A);
                    // TODO: mount-dependent logic
                    // if not sliding and in the clown car
                    else if(Player[A].Mount == 2)
                        PlayerVehicleDismountCheck(A);
                    // driving (standing on NPCID_COCKPIT)
                    else if(Player[A].Driving)
                        PlayerCockpitMovementX(A);
                    // if a fairy
                    else if(Player[A].Fairy)
                        PlayerFairyMovementX(A);
                    // TODO: state-dependent logic
                    // if the player is climbing a vine
                    else if(Player[A].Vine > 0)
                        PlayerVineMovement(A);
                    else if(Player[A].AquaticSwim)
                        PlayerAquaticSwimMovement(A);
                    // if none of the above apply then the player controls like normal. remeber this is for the players X movement
                    else
                        PlayerMovementX(A, cursed_value_C);


                    // stop link when stabbing
                    if(Player[A].Character == 5)
                    {
                        if(Player[A].FireBallCD > 0 && (Player[A].Location.SpeedY == 0 || Player[A].Slope != 0 || Player[A].StandingOnNPC != 0) && Player[A].State != PLR_STATE_SHELL)
                        {
                            if(Player[A].Slippy)
                                Player[A].Location.SpeedX = Player[A].Location.SpeedX * 0.75_rb;
                            else
                                Player[A].Location.SpeedX = 0;
                        }
                    }

                    // fairy stuff
                    PlayerFairyTimerUpdate(A);


                    // the single pinched variable has been always false since SMBX64
                    if(Player[A].StandingOnNPC != 0 && /*!NPC[Player[A].StandingOnNPC].Pinched && */ !FreezeNPCs)
                    {
                        if(Player[A].StandingOnNPC < 0)
                            NPC[Player[A].StandingOnNPC].Location = Block[NPC[Player[A].StandingOnNPC].Special].Location;

                        Player[A].Location.SpeedX += NPC[Player[A].StandingOnNPC].Location.SpeedX + (num_t)NPC[Player[A].StandingOnNPC].BeltSpeed;
                    }

                    if(GameOutro) // force the player to walk a specific speed during the credits
                    {
                        if(Player[A].Location.SpeedX < -2)
                            Player[A].Location.SpeedX = -2;
                        if(Player[A].Location.SpeedX > 2)
                            Player[A].Location.SpeedX = 2;
                    }



                    // slippy code
                    if(Player[A].Slippy && (!Player[A].Slide || Player[A].Slope == 0) && (Player[A].State != PLR_STATE_POLAR || Player[A].Mount))
                    {
                        if(Player[A].Slope > 0)
                        {
                            Player[A].Location.SpeedX = (Player[A].Location.SpeedX + SlippySpeedX * 4) / 5;
                            if(Player[A].Location.SpeedX > -0.01_n && Player[A].Location.SpeedX < 0.01_n)
                                Player[A].Location.SpeedX = 0;
                        }
                        else
                        {
                            Player[A].Location.SpeedX = (Player[A].Location.SpeedX + SlippySpeedX * 3) / 4;
                            if(Player[A].Location.SpeedX > -0.01_n && Player[A].Location.SpeedX < 0.01_n)
                                Player[A].Location.SpeedX = 0;
                        }
                    }

                    // moved Slippy reset to immediately before the player Block logic
                    // bool wasSlippy = Player[A].Slippy;
                    // Player[A].Slippy = false;

                    if(Player[A].Quicksand > 1)
                    {
                        Player[A].Slide = false;
                        if(Player[A].Location.SpeedY >= 0)
                            Player[A].Location.SpeedX = Player[A].Location.SpeedX / 2;
                    }

                    // Apply movement -- this is where the actual movement happens
                    Player[A].Location.X += Player[A].Location.SpeedX;


                    // Players Y movement.
                    if(Block[Player[A].Slope].Location.SpeedY != 0 && Player[A].Slope != 0)
                        Player[A].Location.Y += Block[Player[A].Slope].Location.SpeedY;

                    if(Player[A].AquaticSwim && Player[A].Wet)
                    {
                        // Aquatic swim handles both X and Y movement
                    }
                    else if(Player[A].Fairy) // the player is a fairy
                        PlayerFairyMovementY(A);
                    // TODO: state-dependent logic
                    else if(Player[A].Wet > 0 && Player[A].Quicksand == 0) // the player is swimming
                        PlayerSwimMovementY(A);
                    else if(Player[A].Mount == 2)
                    {
                        // vehicle has own Y movement code in ClownCar()
                    }
                    else // the player is not swimming
                        PlayerMovementY(A);

                    Player[A].Location.Y += Player[A].Location.SpeedY;
                }

                // princess peach and toad stuff
                if(Player[A].Character == 3 || Player[A].Character == 4 || Player[A].Character == 5)
                {
                    Player[A].HeldBonus = NPCID(0);
                    // power up limiter
                    // If (.Character = 3 Or .Character = 4) And .State > 3 And .State <> 7 Then .State = 2

                    if(Player[A].Mount == 3)
                    {
                        PlayerHurt(A);
                        Player[A].Mount = 0;
                        UpdateYoshiMusic();
                    }

                    if(Player[A].Slide && !Player[A].Rolling)
                        Player[A].Slide = false;

                    // If .Stoned = True Then .Stoned = False
                    if(Player[A].Hearts == 1 && Player[A].State > 1)
                        Player[A].Hearts = 2;

                    if(Player[A].Hearts > 1 && Player[A].State == 1)
                        Player[A].Hearts = 1;

                    if(Player[A].Hearts == 0)
                    {
                        if(Player[A].State == 1)
                            Player[A].Hearts = 1;

                        if(Player[A].State >= 2)
                            Player[A].Hearts = 2;
                    }
                }

                // link stuff
                if(Player[A].Character == 5)
                    PlayerChar5Logic(A);

                Player[A].FloatRelease = !Player[A].Controls.Jump;

                // Player interactions
                Player[A].Location.SpeedX += Player[A].Bumped2;
                Player[A].Location.X += Player[A].Bumped2;
                Player[A].Bumped2 = 0;
                if(Player[A].Mount == 0)
                    Player[A].YoshiYellow = false;

                // perform various level bounds checks (level wrap, offscreen exit, left/right/top boundaries)
                PlayerLevelBoundsLogic(A);

                // gives the players the sparkles when he is flying
                if(
                        (
                                (!Player[A].YoshiBlue && (Player[A].CanFly || Player[A].CanFly2)) ||
                                (Player[A].Mount == 3 && Player[A].CanFly2)
                        ) || Player[A].FlySparks || InvincibilityTime
                        )
                {
                    if(iRand(4) == 0)
                        p_PlayerMakeFlySparkle(Player[A].Location, 0);
                }

                Tanooki(A); // tanooki suit code

                // this whole section is dead code, since there are no uses of these definitions of PlrMid and Slope
#if 0
                if(Player[A].StandingOnNPC == -A)
                {
                    if(Player[A].Slope != 0)
                    {
                        B = NPC[Player[A].StandingOnNPC].Special;

                        double PlrMid;
                        if(BlockSlope[Block[B].Type] == 1)
                            PlrMid = Player[A].Location.X;
                        else
                            PlrMid = Player[A].Location.X + Player[A].Location.Width;

                        double Slope = (PlrMid - Block[B].Location.X) / Block[B].Location.Width;

                        if(BlockSlope[Block[B].Type] < 0)
                            Slope = 1 - Slope;
                        if(Slope < 0)
                            Slope = 0;
                        if(Slope > 1)
                            Slope = 1;
                    }
                }
#endif

                // decrement pinched timers
                PlayerPinchedTimerUpdate(A);

                // these variables persist over the interrupt/resume routine
                int MessageNPC;
                bool DontResetGrabTime;
                MessageNPC = 0;
                DontResetGrabTime = false; // helps with grabbing things from the top

                // scoping variables shared between block logic and NPC logic
                {
                    tempf_t oldSpeedY = (tempf_t)Player[A].Location.SpeedY; // holds the players previous Y speed
                    bool movingBlock = false; // helps with collisions for moving blocks
                    int floorBlock = 0; // was previously called tempHit3

                    Player[A].Slippy = false;
                    Player[A].SlippyWall = false;

                    if(!Player[A].CurMazeZone)
                    {
                        // Block collisions.
                        PlayerBlockLogic(A, floorBlock, movingBlock, DontResetGrabTime, cursed_value_C, oldStandingOnNpc);

                        // Vine collisions.
                        PlayerVineLogic(A);
                    }

                    // Check NPC collisions
                    PlayerNPCLogic(A, tempSpring, tempShell, MessageNPC, movingBlock, floorBlock, oldSpeedY);
                }

                // reduce player's multiplier
                if((Player[A].Location.SpeedY == 0 || Player[A].StandingOnNPC != 0 || Player[A].Slope > 0) && !Player[A].Slide && !FreezeNPCs && !InvincibilityTime)
                    Player[A].Multiplier = 0;

                if(Player[A].Mount == 2)
                    Player[A].Multiplier = 0;

                // Player-player collisions
                PlayerCollide(A);

                // Talk to NPC
                if(MessageNPC > 0)
                {
                    MessageText = GetS(NPC[MessageNPC].Text);
                    preProcessMessage(MessageText, A);
                    PauseInit(PauseCode::Message, A);

                    // store entire routine state into g_gameLoopInterrupt
                    g_gameLoopInterrupt.site = GameLoopInterrupt::UpdatePlayer_MessageNPC;
                    g_gameLoopInterrupt.A = A;
                    g_gameLoopInterrupt.B = MessageNPC;
                    g_gameLoopInterrupt.bool1 = DontResetGrabTime;
                    g_gameLoopInterrupt.bool2 = tempSpring;
                    g_gameLoopInterrupt.bool3 = tempShell;
                    return true;

resume_MessageNPC:
                    // restore only the essentials for now, we may need to pause/resume again
                    A = g_gameLoopInterrupt.A;
                    MessageNPC = g_gameLoopInterrupt.B;

                    MessageText.clear();

                    if(NPC[MessageNPC].TriggerTalk != EVENT_NONE)
                    {
                        eventindex_t resume_index;
                        resume_index = ProcEvent_Safe(false, NPC[MessageNPC].TriggerTalk, A);
                        while(resume_index != EVENT_NONE)
                        {
                            g_gameLoopInterrupt.B = resume_index;
                            g_gameLoopInterrupt.site = GameLoopInterrupt::UpdatePlayer_TriggerTalk;
                            return true;

resume_TriggerTalk:
                            A = g_gameLoopInterrupt.A;
                            resume_index = g_gameLoopInterrupt.B;
                            resume_index = ProcEvent_Safe(true, resume_index, A);
                        }
                    }

                    // finish restoring state from g_gameLoopInterrupt
                    DontResetGrabTime = g_gameLoopInterrupt.bool1;
                    tempSpring = g_gameLoopInterrupt.bool2;
                    tempShell = g_gameLoopInterrupt.bool3;
                    g_gameLoopInterrupt.site = GameLoopInterrupt::None;

                    MessageNPC = 0;
                }

                YoshiEatCode(A);

                // pinch code
                if(!GodMode)
                    PlayerPinchedDeathCheck(A);

                if(false)
                {
resume_SuperWarp:
                    A = g_gameLoopInterrupt.A;

                    // restore some locals from this procedure
                    DontResetGrabTime = g_gameLoopInterrupt.bool1;
                    tempSpring = g_gameLoopInterrupt.bool2;
                    tempShell = g_gameLoopInterrupt.bool3;

                    // SuperWarp will resume at the correct index based on g_gameLoopInterrupt.B, and then clear g_gameLoopInterrupt.site
                }

                SuperWarp(A); // this sub checks warps

                if(g_gameLoopInterrupt.site != GameLoopInterrupt::None)
                {
                    // save some locals from this procedure
                    g_gameLoopInterrupt.bool1 = DontResetGrabTime;
                    g_gameLoopInterrupt.bool2 = tempSpring;
                    g_gameLoopInterrupt.bool3 = tempShell;
                    return true;
                }

                // shell surf
                if(Player[A].ShellSurf && Player[A].StandingOnNPC != 0)
                {
                    Player[A].Location.X = NPC[Player[A].StandingOnNPC].Location.X + (NPC[Player[A].StandingOnNPC].Location.Width - Player[A].Location.Width) / 2;
                    Player[A].Location.SpeedX = 0; // 1 * .Direction

                    if(NPC[Player[A].StandingOnNPC].Location.SpeedX == 0)
                        Player[A].ShellSurf = false;
                }

                // Check edge of screen
                PlayerSharedScreenLogic(A);

                if(Player[A].Location.Y > level[Player[A].Section].Height + 64)
                    PlayerDead(A);

                if(!NPC[Player[A].StandingOnNPC]->IsAShell)
                    Player[A].ShellSurf = false;

                PlayerGrabCode(A, DontResetGrabTime); // Player holding NPC code **GRAB CODE**

                Player[A].RunRelease = !Player[A].Controls.Run && !Player[A].Controls.AltRun;
                Player[A].JumpRelease = !Player[A].Controls.Jump && !Player[A].Controls.AltJump;

                PlayerFrame(Player[A]); // Update players frames
                Player[A].StandUp = false; // Fixes a block collision bug
                Player[A].StandUp2 = false;
                if(Player[A].ForceHitSpot3)
                    Player[A].StandUp = true;
                Player[A].ForceHitSpot3 = false;
                if(Player[A].ForceHold > 0)
                    Player[A].ForceHold -= 1;
            }
            else // Player special effects
                PlayerEffects(A);
        }

        Player[A].DuckRelease = !Player[A].Controls.Down;
        Player[A].AltRunRelease = !Player[A].Controls.AltRun;
    }

    CleanupVehicleNPCs();

    return false;
}

void CleanupVehicleNPCs()
{
    // int C = 0;

    // kill the player temp NPCs, from last to first
    NPCQueues::reverse_sort(NPCQueues::PlayerTemp);

    // for(A = numNPCs; A >= 1; A--)
    int last_NPC = numNPCs + 1;
    for(int A : NPCQueues::PlayerTemp)
    {
        // duplicated entry, no problem
        if(A == last_NPC)
            continue;

        if(NPC[A].playerTemp)
        {
            for(int B = 1; B <= numPlayers; B++)
            {
                if(Player[B].StandingOnNPC == A)
                    Player[B].StandingOnVehiclePlr = NPC[A].Variant; // newly stores the player who owns the vehicle
            }
            NPC[0] = NPC[A]; // was NPC[C] = NPC[A] but C was not mutated
            KillNPC(A, 9);
        }
    }

    NPCQueues::PlayerTemp.clear();
}


================================================
FILE: src/player/player_update_priv.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef PLAYER_UPDATE_PRIV_H
#define PLAYER_UPDATE_PRIV_H

#include "numeric_types.h"

struct Location_t;
struct Player_t;

void p_PlayerMakeFlySparkle(const Location_t& loc, int Frame = 1);

// most of these routines were originally part of UpdatePlayer
void PlayerNPCLogic(int A, bool& tempSpring, bool& tempShell, int& MessageNPC, const bool movingBlock, const int floorBlock, const tempf_t oldSpeedY);

void PlayerBlockLogic(int A, int& floorBlock, bool& movingBlock, bool& DontResetGrabTime, tempf_t cursed_value_C, const int oldStandingOnNpc);

bool p_PlayerTouchVine(Player_t& p, num_t vine_top, int VineNPC, int VineBGO);
void PlayerVineLogic(int A);
bool PlayerFairyOnVine(int A);
void PlayerVineMovement(int A);

void PlayerSharedScreenLogic(int A);
void PlayerLevelBoundsLogic(int A);
void PlayerEffectWings(int A);

void PlayerFairyTimerUpdate(int A);
void PlayerFairyMovementX(int A);
void PlayerFairyMovementY(int A);

void PlayerPinchedTimerUpdate(int A);
void PlayerPinchedDeathCheck(int A);

void PlayerMovementX(int A, tempf_t& cursed_value_C);
void PlayerSlideMovementX(int A);
void PlayerCockpitMovementX(int A);
void PlayerMovementY(int A);
void PlayerSwimMovementY(int A);
void PlayerAquaticSwimMovement(int A);

void PlayerPoundLogic(int A);
void PlayerShootChar5Beam(int A);
void PlayerThrowBomb(int A); // (from PowerUps)

void PlayerChar5Logic(int A);
void PlayerChar5StabLogic(int A); // (from PowerUps)

void UpdatePlayerTimeToLive(int A);
void UpdatePlayerDead(int A);

void PlayerVehicleDismountCheck(int A);

void PlayerEffectWarpPipe(int A);
void PlayerEffectWarpDoor(int A);
void PlayerEffectWarpWait(int A);

void PlayerMazeZoneMovement(int A);
void PlayerFlagSlideMovement(int A);
void PlayerThrowItemMaze(const Player_t& p, Location_t& loc, uint8_t& maze_status);
void PlayerThrownNpcMazeCheck(const Player_t& p, NPC_t& npc);

#endif // PLAYER_UPDATE_PRIV_H


================================================
FILE: src/player/player_vehicle_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "collision.h"
#include "config.h"
#include "sound.h"
#include "npc_traits.h"

#include "main/trees.h"

void PlayerVehicleDismountCheck(int A)
{
    if(!Player[A].Controls.Jump)
        Player[A].CanJump = true;

    if(!Player[A].Controls.AltJump && g_config.fix_vehicle_altjump_lock)
        Player[A].CanAltJump = true;

    if(Player[A].Controls.AltJump && Player[A].CanAltJump) // Jump out of the Clown Car
    {
        if(g_config.fix_vehicle_altjump_lock)
            Player[A].CanAltJump = false;

        Player[A].CanJump = false;

        bool dismount_safe = true;

        Location_t tempLocation = Player[A].Location;
        tempLocation.Height = Physics.PlayerHeight[Player[A].Character][Player[A].State];
        tempLocation.Y += -Physics.PlayerHeight[Player[A].Character][Player[A].State];
        tempLocation.Width = Physics.PlayerWidth[Player[A].Character][Player[A].State];
        tempLocation.X += 64 - tempLocation.Width / 2;

        // fBlock = FirstBlock[(tempLocation.X / 32) - 1];
        // lBlock = LastBlock[((tempLocation.X + tempLocation.Width) / 32.0) + 1];
        // blockTileGet(tempLocation, fBlock, lBlock);

        for(int B : treeFLBlockQuery(tempLocation, SORTMODE_NONE))
        {
            if(!Block[B].Invis && !BlockIsSizable[Block[B].Type] && !BlockOnlyHitspot1[Block[B].Type] &&
               !BlockNoClipping[Block[B].Type] && !Block[B].Hidden)
            {
                if(CheckCollision(tempLocation, Block[B].Location))
                {
                    dismount_safe = false;
                    PlaySoundSpatial(SFX_BlockHit, Player[A].Location);
                    break;
                }
            }
        }

        if(dismount_safe) for(int B : treeNPCQuery(tempLocation, SORTMODE_NONE))
        {
            if(NPC[B]->IsABlock && !NPC[B]->StandsOnPlayer && NPC[B].Active && NPC[B].Type != NPCID_VEHICLE)
            {
                if(CheckCollision(tempLocation, NPC[B].Location))
                {
                    dismount_safe = false;
                    PlaySoundSpatial(SFX_BlockHit, Player[A].Location);
                    break;
                }
            }
        }

        if(dismount_safe)
            PlayerDismount(A);
    }
}


================================================
FILE: src/player/player_vine_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "player.h"
#include "collision.h"
#include "effect.h"
#include "eff_id.h"
#include "sound.h"
#include "config.h"
#include "npc_traits.h"
#include "layers.h"

#include "main/trees.h"

bool p_PlayerTouchVine(Player_t& p, num_t vine_top, int VineNPC, int VineBGO)
{
    if(p.Character == 5)
    {
        bool hasNoMonts = (g_config.fix_char5_vehicle_climb && p.Mount <= 0) ||
                           !g_config.fix_char5_vehicle_climb;
        if(hasNoMonts && p.Immune == 0 && p.Controls.Up)
        {
            p.FairyCD = 0;

            if(!p.Fairy)
            {
                p.Fairy = true;
                SizeCheck(p);
                PlaySoundSpatial(SFX_HeroFairy, p.Location);
                p.Immune = 10;
                p.Effect = PLREFF_WAITING;
                p.Effect2 = 4;
                NewEffect(EFFID_SMOKE_S5, p.Location);
            }

            if(p.FairyTime != -1 && p.FairyTime < 20)
                p.FairyTime = 20;
        }

        return true;
    }
    else if(!p.Fairy && !p.Stoned && !p.AquaticSwim)
    {
        if(p.Mount == 0 && p.HoldingNPC <= 0)
        {
            if(p.Vine > 0)
            {
                if(p.Duck)
                    UnDuck(p);

                if(p.Location.Y >= vine_top - 20 && p.Vine < 2)
                    p.Vine = 2;

                if(p.Location.Y >= vine_top - 18)
                    p.Vine = 3;
            }
            else if((p.Controls.Up ||
                     (p.Controls.Down &&
                      !num_t::fEqual_d(p.Location.SpeedY, 0) && // Not .Location.SpeedY = 0
                      p.StandingOnNPC == 0 && // Not .StandingOnNPC <> 0
                      p.Slope <= 0) // Not .Slope > 0
                    ) && p.Jump == 0)
            {
                if(p.Duck)
                    UnDuck(p);

                if(p.Location.Y >= vine_top - 20 && p.Vine < 2)
                    p.Vine = 2;

                if(p.Location.Y >= vine_top - 18)
                    p.Vine = 3;
            }

            if(p.Vine > 0)
            {
                p.VineNPC = VineNPC;
                if(g_config.fix_climb_bgo_speed_adding)
                    p.VineBGO = VineBGO;
            }

            if(p.Vine == 3)
                return true;
        }
    }

    return false;
}

void PlayerVineLogic(int A)
{
    if(Player[A].Vine > 0)
        Player[A].Vine -= 1;

    // check vine backgrounds
    for(int B : treeBackgroundQuery(Player[A].Location, SORTMODE_NONE))
    {
        if(B > numBackground)
            continue;

        if(BackgroundFence[Background[B].Type] && (!g_config.fix_climb_invisible_fences || !Background[B].Hidden))
        {
            // if(CheckCollision(Player[A].Location, Background[B].Location))
            //{
            SpeedlessLocation_t tempLocation = Background[B].Location;
            tempLocation.Height -= 16;
            tempLocation.Width -= 20;
            tempLocation.X += 10;

            if(CheckCollision(Player[A].Location, tempLocation))
            {
                if(p_PlayerTouchVine(Player[A], Background[B].Location.Y, -1, B))
                    break;
            } // Collide player and temp location
            // }// Collide player and BGO
        } // Is BGO climbable and visible?
    } // Next A
}

bool PlayerFairyOnVine(int A)
{
    Location_t tempLocation = Player[A].Location;
    tempLocation.Width += 32;
    tempLocation.Height += 32;
    tempLocation.X -= 16;
    tempLocation.Y -= 16;

    for(int Bi : treeNPCQuery(tempLocation, SORTMODE_NONE))
    {
        if(NPC[Bi].Active && !NPC[Bi].Hidden && NPC[Bi]->IsAVine)
        {
            if(CheckCollision(tempLocation, NPC[Bi].Location))
                return true;
        }
    }

    for(int B : treeBackgroundQuery(tempLocation, SORTMODE_NONE))
    {
        if(B > numBackground)
            continue;

        if(BackgroundFence[Background[B].Type] && !Background[B].Hidden)
        {
            if(CheckCollision(tempLocation, Background[B].Location))
                return true;
        }
    }

    return false;
}

void PlayerVineMovement(int A)
{
    if(Player[A].StandingOnNPC > 0 && !Player[A].Controls.Up)
        Player[A].Vine = 0;
    Player[A].CanFly = false;
    Player[A].CanFly2 = false;
    Player[A].RunCount = 0;
    Player[A].SpinJump = false;

    if(Player[A].Controls.Left)
        Player[A].Location.SpeedX = -1.5_n;
    else if(Player[A].Controls.Right)
        Player[A].Location.SpeedX = 1.5_n;
    else
        Player[A].Location.SpeedX = 0;

    if(Player[A].Controls.Up && Player[A].Vine > 2)
        Player[A].Location.SpeedY = -2;
    else if(Player[A].Controls.Down)
        Player[A].Location.SpeedY = 3;
    else
        Player[A].Location.SpeedY = 0;

    if(g_config.fix_climb_bgo_speed_adding && Player[A].VineBGO > 0)
    {
        const Layer_t& layer = Layer[Background[Player[A].VineBGO].Layer];
        if(g_config.enable_climb_bgo_layer_move)
        {
            Player[A].Location.SpeedX += (num_t)layer.ApplySpeedX;
            Player[A].Location.SpeedY += (num_t)layer.ApplySpeedY;
        }
    }
    else
    {
        Player[A].Location.SpeedX += NPC[Player[A].VineNPC].Location.SpeedX;
        Player[A].Location.SpeedY += NPC[Player[A].VineNPC].Location.SpeedY;
    }
}


================================================
FILE: src/player/player_warp_logic.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_stdinc.h"

#include "globals.h"

#include "player.h"
#include "graphics.h"
#include "npc.h"
#include "npc_id.h"
#include "npc_traits.h"
#include "npc/npc_queues.h"
#include "sound.h"
#include "editor.h"
#include "effect.h"
#include "game_main.h"
#include "eff_id.h"
#include "collision.h"
#include "layers.h"
#include "config.h"
#include "message.h"

#include "main/game_globals.h"
#include "main/translate.h"
#include "main/trees.h"
#include "main/game_strings.h"
#include "main/game_info.h"
#include "main/game_loop_interrupt.h"


static constexpr int plr_warp_scroll_speed = 8; // 8px / frame
static constexpr int plr_warp_scroll_max_frames = 260; // 4 seconds

static void s_TriggerDoorEffects(const Location_t& loc, bool do_big_door = true)
{
    for(Background_t& bgo : treeBackgroundQuery(loc, SORTMODE_ID))
    {
        if(CheckCollision(loc, bgo.Location))
        {
            if(bgo.Type == 88)
                NewEffect(EFFID_DOOR_S2_OPEN, static_cast<Location_t>(bgo.Location));
            else if(bgo.Type == 87)
                NewEffect(EFFID_DOOR_DOUBLE_S3_OPEN, static_cast<Location_t>(bgo.Location));
            else if(bgo.Type == 107)
                NewEffect(EFFID_DOOR_SIDE_S3_OPEN, static_cast<Location_t>(bgo.Location));
            else if(do_big_door && bgo.Type == 141)
            {
                Location_t bLoc = static_cast<Location_t>(bgo.Location);
                bLoc.set_width_center(104);
                NewEffect(EFFID_BIG_DOOR_OPEN, bLoc);
            }
        }
    }
}

// copied logic from checkWarp function
// parameter release_at_warp determines whether NPC should be dropped at the warp entrance
//   (set to false in new behavior where players are being teleported to warp)
static void s_WarpReleaseItems(const Warp_t& warp, int A, bool backward, bool release_at_warp = true)
{
    Player_t& plr = Player[A];

    int direction  = backward ? warp.Direction2 : warp.Direction;
    auto &entrance = backward ? warp.Exit       : warp.Entrance;

    if(warp.NoYoshi && plr.YoshiPlayer > 0)
        YoshiSpit(A);

    if(!warp.WarpNPC || (plr.Mount == 3 && (plr.YoshiNPC != 0 || plr.YoshiPlayer != 0) && warp.NoYoshi))
    {
        if(plr.HoldingNPC > 0)
        {
            if(NPC[plr.HoldingNPC].Type == NPCID_HEAVY_THROWER)
                NPCHit(plr.HoldingNPC, 3, plr.HoldingNPC);
        }

        if((plr.Character == 3 && release_at_warp) ||
          (plr.Character == 4 && warp.Effect == 1 && direction == 1 && release_at_warp))
        {
            NPC[plr.HoldingNPC].Location.Y = entrance.Y;

            if(plr.HoldingNPC > 0 && plr.HoldingNPC <= numNPCs)
                treeNPCUpdate(plr.HoldingNPC);
        }

        plr.HoldingNPC = 0;

        if(plr.YoshiNPC > 0)
            YoshiSpit(A);
    }

    if(plr.HoldingNPC > 0)
    {
        if(NPC[plr.HoldingNPC].Type == NPCID_ICE_CUBE) // can't bring ice through warps
        {
            NPC[plr.HoldingNPC].HoldingPlayer = 0;
            plr.HoldingNPC = 0;
        }
    }

    plr.StandingOnNPC = 0;
}

// steal the mount from a player (because they just entered a no-mount warp)
static void s_WarpStealMount(int A)
{
    Player_t& p = Player[A];
    if(OwedMount[A] == 0 && p.Mount > 0 && p.Mount != 2)
    {
        OwedMount[A] = p.Mount;
        OwedMountType[A] = p.MountType;
    }
    p.Mount = 0;
    p.MountType = 0;
    p.MountOffsetY = 0;
    SizeCheck(Player[A]);
    UpdateYoshiMusic();
}

// fix the location of any players in pets, for after a player gets teleported
static void s_FixPlayersInPets(const Screen_t& screen)
{
    for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
    {
        int o_A = screen.players[plr_i];

        const Player_t& o_p = Player[o_A];
        if(o_p.Effect == PLREFF_PET_INSIDE)
            PlayerEffects(o_A);
    }
}

static void s_CheckWarpLevelExit(Player_t& plr, const Warp_t& warp, int lvl_counter, int map_counter)
{
    if(warp.level != STRINGINDEX_NONE)
    {
        GoToLevel = GetS(warp.level);
        GoToLevelNoGameThing = warp.noEntranceScene;
        plr.Effect = PLREFF_WAITING;
        plr.Effect2 = lvl_counter;
        ReturnWarp = plr.Warp;

        if(IsHubLevel)
            ReturnWarpSaved = ReturnWarp;

        StartWarp = warp.LevelWarp;
    }
    else if(warp.MapWarp)
    {
        plr.Effect = PLREFF_WAITING;
        plr.Effect2 = map_counter;
    }
}

static void s_InitWarpScroll(Player_t& p, const Location_t& warp_enter, const Location_t& warp_exit, int min_frames = 0)
{
    unsigned int warp_dist = (int)num_t::dist(warp_enter.X - warp_exit.X, warp_enter.Y - warp_exit.Y);

    int scroll_frames = warp_dist / plr_warp_scroll_speed;
    if(scroll_frames < min_frames)
        scroll_frames = min_frames;
    if(scroll_frames > plr_warp_scroll_max_frames)
        scroll_frames = plr_warp_scroll_max_frames;

    p.Effect2 = 128 + scroll_frames;
}

static void s_WarpFaderLogic(bool is_reverse, int A, int transitEffect, const Location_t& focus, bool normal_ready, bool none_ready)
{
    int fader_index = vScreenIdxByPlayer(A);
    SDL_assert_release(0 <= fader_index && fader_index <= c_vScreenCount);

    auto& fader = g_levelVScreenFader[fader_index];

    if(is_reverse && !fader.isVisible())
        return;

    int fade_from = (is_reverse) ? 65 :  0;
    int fade_to   = (is_reverse) ?  0 : 65;
    int rate      = 3;
    bool ready    = normal_ready;

    switch(transitEffect)
    {
    default:
        if(transitEffect >= ScreenFader::S_CUSTOM)
            goto generic_fade;

    // fallthrough
    case LevelDoor::TRANSIT_SCROLL:
    case LevelDoor::TRANSIT_NONE:
        ready = none_ready;
        rate = (g_config.EnableInterLevelFade ? 8 : 64);

    // fallthrough
    case LevelDoor::TRANSIT_FADE:
        transitEffect = ScreenFader::S_FADE;
        goto generic_fade;

    case LevelDoor::TRANSIT_CIRCLE_FADE:
        transitEffect = ScreenFader::S_CIRCLE;
        goto generic_fade;

    case LevelDoor::TRANSIT_FLIP_H:
        transitEffect = ScreenFader::S_FLIP_H;
        goto generic_fade;

    case LevelDoor::TRANSIT_FLIP_V:
        transitEffect = ScreenFader::S_FLIP_V;
        goto generic_fade;

    generic_fade:
        if(ready)
            fader.setupFader(rate, fade_from, fade_to, transitEffect,
                             true,
                             num_t::round(focus.X + focus.Width / 2),
                             num_t::round(focus.Y + focus.Height / 2),
                             fader_index);
        break;
    }
}

static void s_delay_pipe_exit(int A)
{
    Player_t& p = Player[A];

    const auto& warp = Warp[p.Warp];
    const auto warp_dir_exit = (p.WarpBackward) ? warp.Direction : warp.Direction2;
    bool warp_vertical = (warp_dir_exit == LevelDoor::EXIT_UP) || (warp_dir_exit == LevelDoor::EXIT_DOWN);

    // number of players ahead of this one
    int frames_before = 0;

    for(int o_A = 1; o_A <= numPlayers; o_A++)
    {
        if(o_A == A)
            continue;

        Player_t& o_p = Player[o_A];
        if(!o_p.Dead && o_p.TimeToLive == 0 && o_p.Effect == PLREFF_WARP_PIPE && o_p.Warp == p.Warp && o_p.WarpBackward == p.WarpBackward && o_p.Effect2 > 1 && (o_p.Effect2 < 128 || o_p.Effect2 >= 2000))
        {
            // wait for player to warp
            if(warp_vertical)
                frames_before += (int)o_p.Location.Height;
            else
                frames_before += (int)o_p.Location.Width;

            // pause between players
            frames_before += 70;
        }
    }

    // put in new pipe holding state
    if(frames_before)
    {
        p.Effect = PLREFF_WARP_PIPE;
        p.Effect2 = 2010 + frames_before;
    }
}

// important: each of these generalizes the cases in SMBX 1.3 and is fully compatible with SMBX 1.3 when entrance.Width is 32
static num_t s_warp_offset_x(const Location_t& pLoc, const SpeedlessLocation_t& entrance, const SpeedlessLocation_t& exit)
{
    num_t ratio_x = 0.5_n;
    if(entrance.Width > 32)
        ratio_x = (pLoc.X + pLoc.Width / 2 - entrance.X - 16) / (int_ok)(entrance.Width - 32);

    if(ratio_x < 0)
        ratio_x = 0;
    else if(ratio_x > 1)
        ratio_x = 1;

    return ratio_x * (int_ok)(exit.Width - 32) - pLoc.Width / 2 + 16;
}

static num_t s_warp_offset_y(const Location_t& pLoc, const SpeedlessLocation_t& entrance, const SpeedlessLocation_t& exit)
{
    num_t ratio_y = 1.0_n;
    if(entrance.Height > 32)
        ratio_y = (pLoc.Y + pLoc.Height - entrance.Y - 32) / (int_ok)(entrance.Height - 32);

    if(ratio_y < 0)
        ratio_y = 0;
    else if(ratio_y > 1)
        ratio_y = 1;

    return ratio_y * (int_ok)(exit.Height - 32) - pLoc.Height + 32;
}

bool PlayerWaitingInWarp(const Player_t& p)
{
    return (p.Effect == PLREFF_WARP_PIPE && p.Effect2 >= 2000)
        || (p.Effect == PLREFF_WAITING && p.Effect2 > 30 && p.Effect2 <= 2000);
}

bool PlayerScrollingInWarp(const Player_t& p)
{
    return (p.Effect == PLREFF_WARP_PIPE || p.Effect == PLREFF_WARP_DOOR)
        && (p.Effect2 >= 128 && p.Effect2 <= 128 + plr_warp_scroll_max_frames);
}

void PlayerEffectWarpPipe(int A)
{
    Player_t& p = Player[A];

    p.SpinJump = false;
    p.TailCount = 0;
    p.Location.SpeedY = 0;

    bool backward = p.WarpBackward;
    const auto &warp = Warp[p.Warp];
    SpeedlessLocation_t sl_warp_enter = (backward ? warp.Exit : warp.Entrance);
    SpeedlessLocation_t sl_warp_exit = (backward ? warp.Entrance : warp.Exit);
    Location_t warp_enter = static_cast<Location_t>(sl_warp_enter);
    Location_t warp_exit = static_cast<Location_t>(sl_warp_exit);
    const auto &warp_dir_enter = backward ? warp.Direction2 : warp.Direction;
    const auto &warp_dir_exit = backward ? warp.Direction : warp.Direction2;

    bool same_section = SectionCollision(p.Section, warp_exit);
    bool do_scroll = (warp.transitEffect == LevelDoor::TRANSIT_SCROLL) && same_section;
    bool is_level_quit = warp.level != STRINGINDEX_NONE || warp.MapWarp;

    // teleport other players into warp in shared screen mode
    Screen_t& screen = ScreenByPlayer(A);
    bool is_shared_screen = (screen.Type == 3);

    if(p.Effect2 == 0) // Entering pipe
    {
        // how many *frames* left until the player crosses the boundary of the pipe and becomes invisible
        int leftToGoal = 0;
        // how many *frames* to wait after the player crosses the boundary of the pipe and becomes invisible (set to -16 for left/right warps)
        int leftToGoal_end = -8;

        if(warp_dir_enter == LevelDoor::ENTRANCE_DOWN || warp_dir_enter == LevelDoor::ENTRANCE_UP)
        {
            if(warp_dir_enter == LevelDoor::ENTRANCE_DOWN)
            {
                p.Location.Y += 1;
                leftToGoal = num_t::floor(warp_enter.Y + warp_enter.Height - p.Location.Y);
            }
            else
            {
                p.Location.Y -= 1;
                leftToGoal = num_t::floor(p.Location.Y + p.Location.Height - warp_enter.Y);
            }

            p.Location.X = warp_enter.X + s_warp_offset_x(p.Location, sl_warp_enter, sl_warp_enter);

            if(p.Mount == 0)
                p.Frame = 15;

            if(p.HoldingNPC > 0)
            {
                NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
                NPC[p.HoldingNPC].Location.X = p.Location.X + (p.Location.Width - NPC[p.HoldingNPC].Location.Width) / 2;
            }
        }
        else if(warp_dir_enter == LevelDoor::ENTRANCE_LEFT || warp_dir_enter == LevelDoor::ENTRANCE_RIGHT)
        {
            if(warp_dir_enter == LevelDoor::ENTRANCE_LEFT)
            {
                p.Location.X -= 0.5_n;
                p.Location.SpeedX = -0.5_n;
                leftToGoal = num_t::floor((p.Location.X + p.Location.Width - warp_enter.X) * 2);
                p.Direction = -1; // makes (p.Direction > 0) always false
            }
            else
            {
                p.Location.X += 0.5_n;
                p.Location.SpeedX = 0.5_n;
                leftToGoal = num_t::floor((warp_enter.X + warp_enter.Width - p.Location.X) * 2);
                p.Direction = 1; // Makes (p.Direction > 0) always true
            }

            if(p.Mount == 3)
            {
                p.Duck = true;
                p.Location.Height = 30;
            }

            p.Location.Y = warp_enter.Y + warp_enter.Height - p.Location.Height - 2;

            if(p.HoldingNPC > 0)
            {
                NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;

                if(warp_dir_enter == LevelDoor::ENTRANCE_LEFT)
                    NPC[p.HoldingNPC].Location.X = p.Location.X + p.Location.Width - Physics.PlayerGrabSpotX[p.Character][p.State] - NPC[p.HoldingNPC].Location.Width;
                else
                    NPC[p.HoldingNPC].Location.X = p.Location.X + Physics.PlayerGrabSpotX[p.Character][p.State];
            }

            PlayerFrame(p);
            p.Location.SpeedX = 0;

            // -8px as always, but leftToGoal is measured in frames (cross-ref * 2 above)
            leftToGoal_end = -16;
        }

        // checks whether the player is 8 *pixels* beyond the pipe boundary
        if(leftToGoal < leftToGoal_end)
        {
            if(do_scroll)
                s_InitWarpScroll(p, warp_enter, warp_exit);
            else
                p.Effect2 = 1;
        }

        if(p.HoldingNPC > 0 && p.HoldingNPC <= numNPCs)
            treeNPCUpdate(p.HoldingNPC);

        // teleport other players into the pipe warp 8 frames before player crosses boundary
        if(is_shared_screen && leftToGoal == 8)
        {
            int vscreen_A = vScreenIdxByPlayer(A);
            bool do_tele = !vScreenCollision(vscreen_A, warp_exit);

            if(do_tele)
            {
                SharedScreenAvoidJump_Pre(screen);

                for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
                {
                    int o_A = screen.players[plr_i];
                    if(o_A == A)
                        continue;

                    Player_t& o_p = Player[o_A];

                    // revive someone in wings and bring to warp
                    if(o_p.Effect == PLREFF_COOP_WINGS)
                        o_p.Dead = false;

                    // in the mouth of an onscreen player's Pet?
                    bool in_onscreen_pet = !warp.NoYoshi && InOnscreenPet(o_A, screen);

                    bool status_match = (o_p.Effect == p.Effect && o_p.Warp == p.Warp && o_p.WarpBackward == p.WarpBackward);

                    if(!o_p.Dead && o_p.TimeToLive == 0 && !in_onscreen_pet && !status_match)
                    {
                        RemoveFromPet(o_A);

                        s_WarpReleaseItems(warp, o_A, p.WarpBackward, false);

                        o_p.Warp = p.Warp;
                        o_p.WarpBackward = p.WarpBackward;
                        o_p.Effect = p.Effect;
                        // make other player behind so that this player will exit first
                        o_p.Effect2 = 0;
                        o_p.Location.X = warp_enter.X + (warp_enter.Width - o_p.Location.Width) / 2;
                        o_p.Location.Y = warp_enter.Y + (warp_enter.Height - o_p.Location.Height) / 2;
                        o_p.Location.SpeedX = 0;
                        o_p.Location.SpeedY = 0;
                    }
                }

                SharedScreenAvoidJump_Post(screen, (do_scroll) ? 0 : 200);
            }
        }

        // D_pLogDebug("Warping: %g (same section? %s!)", leftToGoal, SectionCollision(p.Section, warp_exit) ? "yes" : "no");

        // trigger fader when there are 16 frames left (for normal effects) or 0 frames left (for none or scroll)
        s_WarpFaderLogic(false, A, warp.transitEffect, warp_enter, leftToGoal == 16, !is_level_quit && !same_section && leftToGoal == 0);
    }
    else if(p.Effect2 == 1)  // Exiting pipe (initialization)
    {
        if(warp.NoYoshi)
        {
            UnDuck(p);
            s_WarpStealMount(A);
        }

        if(warp_dir_exit == LevelDoor::EXIT_DOWN || warp_dir_exit == LevelDoor::EXIT_UP)
        {
            if(warp_dir_exit == LevelDoor::EXIT_DOWN)
                p.Location.Y = warp_exit.Y - p.Location.Height - 8;
            else
                p.Location.Y = warp_exit.Y + warp_exit.Height + 8;

            p.Location.X = warp_exit.X + s_warp_offset_x(p.Location, (do_scroll) ? sl_warp_exit : sl_warp_enter, sl_warp_exit);

            if(p.Mount == 0)
                p.Frame = 15;

            if(p.HoldingNPC > 0)
            {
                NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
                NPC[p.HoldingNPC].Location.X = p.Location.X + (p.Location.Width - NPC[p.HoldingNPC].Location.Width) / 2;
            }

            if(p.Duck)
                UnDuck(Player[A]);
        }
        else if(warp_dir_exit == LevelDoor::EXIT_RIGHT || warp_dir_exit == LevelDoor::EXIT_LEFT)
        {
            if(warp_dir_exit == LevelDoor::EXIT_RIGHT)
            {
                p.Location.X = warp_exit.X - p.Location.Width - 8;
                p.Direction = 1;
            }
            else
            {
                p.Location.X = warp_exit.X + warp_exit.Width + 8;
                p.Direction = -1;
            }

            if(p.Mount == 3)
            {
                p.Duck = true;
                p.Location.Height = 30;
            }

            p.Location.Y = warp_exit.Y + warp_exit.Height - p.Location.Height - 2;

            if(p.Mount == 0)
                p.Frame = 1;

            if(p.HoldingNPC > 0)
            {
                if(p.State == 1)
                    p.Frame = 5;
                else
                    p.Frame = 8;

                NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;

                p.Direction = -p.Direction;

                if(warp_dir_exit == LevelDoor::EXIT_RIGHT)
                    NPC[p.HoldingNPC].Location.X = p.Location.X + p.Location.Width - Physics.PlayerGrabSpotX[p.Character][p.State] - NPC[p.HoldingNPC].Location.Width;
                else
                    NPC[p.HoldingNPC].Location.X = p.Location.X + Physics.PlayerGrabSpotX[p.Character][p.State];
            }
        }

        if(p.HoldingNPC > 0 && p.HoldingNPC <= numNPCs)
            treeNPCUpdate(p.HoldingNPC);

        p.Effect2 = 100;

        CheckSection(A);

        if(p.HoldingNPC > 0)
            CheckSectionNPC(p.HoldingNPC);

        // set any other players warping to the same pipe to this state (needed to avoid splitting a shared screen)
        if(is_shared_screen && !do_scroll)
        {
            for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
            {
                int o_A = screen.players[plr_i];
                if(A == o_A)
                    continue;

                Player_t& o_p = Player[o_A];
                if(!o_p.Dead && o_p.TimeToLive == 0 && o_p.Effect == PLREFF_WARP_PIPE && o_p.Effect2 == 0 && o_p.Warp == Player[A].Warp && o_p.WarpBackward == Player[A].WarpBackward)
                {
                    o_p.Location.X = p.Location.X + (p.Location.Width - o_p.Location.Width) / 2;
                    o_p.Location.Y = p.Location.Y + p.Location.Height - o_p.Location.Height;

                    CheckSection(o_A);

                    o_p.Effect = PLREFF_WARP_PIPE;
                    o_p.Effect2 = 1;
                }
            }

            // update position of any players in pets
            s_FixPlayersInPets(screen);

            // disable any tempX/TempY (no longer needed)
            SharedScreenResetTemp(screen);
        }

        // delay based on number of players ahead of this one
        if(is_shared_screen)
            s_delay_pipe_exit(A);

        // many-player code
        if(g_ClonedPlayerMode)
        {
            for(int B = 1; B <= numPlayers; B++)
            {
                if(B != A)
                {
                    if(warp_dir_exit != 3)
                        Player[B].Location.Y = p.Location.Y + p.Location.Height - Player[B].Location.Height;
                    else
                        Player[B].Location.Y = p.Location.Y;

                    Player[B].Location.X = p.Location.X + (p.Location.Width - Player[B].Location.Width) / 2;
                    Player[B].Location.SpeedY = dRand() * 24 - 12;
                    Player[B].Effect = PLREFF_WAITING;
                    Player[B].Effect2 = 0;
                    CheckSection(B);

                    if(Player[B].HoldingNPC > 0)
                        CheckSectionNPC(Player[B].HoldingNPC);
                }
            }
        }

        // reverse screen fade
        if(!is_level_quit)
            s_WarpFaderLogic(true, A, warp.transitEffect, warp_exit, true, true);

        s_CheckWarpLevelExit(p, warp, 2970, 2970);
    }
    else if(p.Effect2 >= 2000) // NEW >2P holding state for pipe exit
    {
        p.Effect2 -= 1;

        if(p.Effect2 <= 2000)
        {
            SharedScreenAvoidJump_Pre(screen);

            p.Effect2 = 2;
            if(backward || !warp.cannonExit)
                PlaySoundSpatial(SFX_Warp, p.Location);

            SharedScreenAvoidJump_Post(screen, 0);
        }
    }
    else if(p.Effect2 > 128) // Scrolling between pipes
    {
        num_t targetX = p.Location.X;
        num_t targetY = p.Location.Y;

        if(warp_dir_exit == 1)
        {
            targetX = warp_exit.X + (warp_exit.Width - p.Location.Width) / 2;
            targetY = warp_exit.Y - p.Location.Height - 8;
        }
        else if(warp_dir_exit == 3)
        {
            targetX = warp_exit.X + (warp_exit.Width - p.Location.Width) / 2;
            targetY = warp_exit.Y + warp_exit.Height + 8;
        }
        else if(warp_dir_exit == 2)
        {
            if(p.Mount == 3)
                p.Location.Height = 30;

            targetX = warp_exit.X - p.Location.Width - 8;
            targetY = warp_exit.Y + warp_exit.Height - p.Location.Height - 2;
        }
        else if(warp_dir_exit == 4)
        {
            if(p.Mount == 3)
                p.Location.Height = 30;

            targetX = warp_exit.X + warp_exit.Width + 8;
            targetY = warp_exit.Y + warp_exit.Height - p.Location.Height - 2;
        }

        int frames_left = p.Effect2 - 128;

        p.Location.X += (targetX - p.Location.X) / frames_left;
        p.Location.Y += (targetY - p.Location.Y) / frames_left;

        p.Effect2 -= 1;

        if(p.Effect2 <= 128)
            p.Effect2 = 1;
    }
    else if(p.Effect2 >= 100) // Waiting until exit pipe
    {
        p.Effect2 += 1;

        if(p.Effect2 >= 110)
        {
            p.Effect2 = 2;
            if(backward || !warp.cannonExit)
                PlaySoundSpatial(SFX_Warp, p.Location);
        }
    }
    else if(p.Effect2 == 2) // Proceeding the pipe exiting
    {
        if(!backward && warp.cannonExit)
        {
            switch(warp_dir_exit)
            {
            case LevelDoor::EXIT_DOWN:
                p.Location.Y = warp_exit.Y;
                break;
            case LevelDoor::EXIT_UP:
                p.Location.Y = (warp_exit.Y + warp_exit.Height) - p.Location.Height;
                break;
            case LevelDoor::EXIT_LEFT:
                p.Location.X = (warp_exit.X + warp_exit.Width) - p.Location.Width;
                p.Direction = -1;
                break;
            case LevelDoor::EXIT_RIGHT:
                p.Location.X = warp_exit.X;
                p.Direction = +1;
                break;
            }
            p.Effect2 = 3;
            if(p.HoldingNPC > 0)
            {
                if(p.ForceHold < 5) // Prevent NPC being stuck in the wall/ceiling
                    p.ForceHold = 5;
                PlayerGrabCode(A);
            }
        }
        else if(warp_dir_exit == LevelDoor::EXIT_DOWN || warp_dir_exit == LevelDoor::EXIT_UP)
        {
            if(warp_dir_exit == LevelDoor::EXIT_DOWN)
            {
                p.Location.Y += 1;
                if(p.Location.Y >= warp_exit.Y)
                    p.Effect2 = 3;
            }
            else
            {
                p.Location.Y -= 1;
                if(p.Location.Y + p.Location.Height <= warp_exit.Y + warp_exit.Height)
                    p.Effect2 = 3;

                // make players less likely to collide chaotically out of UP exits
                if(is_shared_screen || (numPlayers > 2 && !g_ClonedPlayerMode))
                    p.StandUp2 = true;
            }

            if(p.HoldingNPC > 0)
            {
                NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
                NPC[p.HoldingNPC].Location.X = p.Location.X + (p.Location.Width - NPC[p.HoldingNPC].Location.Width) / 2;
            }

            if(p.Mount == 0)
                p.Frame = 15;
        }
        else if(warp_dir_exit == LevelDoor::EXIT_LEFT || warp_dir_exit == LevelDoor::EXIT_RIGHT)
        {
            if(warp_dir_exit == LevelDoor::EXIT_LEFT)
            {
                p.Location.X -= 0.5_n;
                p.Direction = -1; // makes (p.Direction < 0) always true

                if(p.Location.X + p.Location.Width <= warp_exit.X + warp_exit.Width)
                    p.Effect2 = 3;
            }
            else
            {
                p.Location.X += 0.5_n;
                p.Direction = 1; // makes (p.Direction < 0) always false

                if(p.Location.X >= warp_exit.X)
                    p.Effect2 = 3;
            }

            if(p.HoldingNPC > 0)
            {
                if(p.Character >= 3) // peach/toad leaving a pipe
                {
                    // VB6 bug: should have been -1 when going left
                    p.Location.SpeedX = 1;
                    PlayerFrame(p);
                    NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
                }
                else
                {
                    p.Direction = -p.Direction;

                    if(p.State == 1)
                        p.Frame = 5;
                    else
                        p.Frame = 8;

                    NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
                }

                // this logic was substantially simplified from VB6, which also appeared to depend on Direction (but actually didn't)
                if(warp_dir_exit == LevelDoor::EXIT_LEFT)
                    NPC[p.HoldingNPC].Location.X = p.Location.X + Physics.PlayerGrabSpotX[p.Character][p.State];
                else
                    NPC[p.HoldingNPC].Location.X = p.Location.X + p.Location.Width - Physics.PlayerGrabSpotX[p.Character][p.State] - NPC[p.HoldingNPC].Location.Width;
            }
            else
            {
                // VB6 bug: this should have been 0.5 when going right
                p.Location.SpeedX = -0.5_n;
                PlayerFrame(p);
                p.Location.SpeedX = 0;
            }
        }

        if(p.HoldingNPC > 0 && p.HoldingNPC <= numNPCs)
            treeNPCUpdate(p.HoldingNPC);
    }
    else if(p.Effect2 == 3) // Finishing the pipe exiting / shooting
    {
        if(!backward && warp.cannonExit)
        {
            PlaySoundSpatial(SFX_Bullet, p.Location);
            auto loc = warp_exit;
            if(warp_dir_exit == LevelDoor::EXIT_LEFT || warp_dir_exit == LevelDoor::EXIT_RIGHT)
                loc.Y += loc.Height - (p.Location.Height / 2) - (loc.Height / 2);
            NewEffect(EFFID_STOMP_INIT, loc, p.Direction); // Cannon pipe shoot effect
        }

        if(p.HoldingNPC > 0)
        {
            if(warp_dir_exit == LevelDoor::EXIT_LEFT || warp_dir_exit == LevelDoor::EXIT_RIGHT)
            {
                if(warp_dir_exit == 2)
                    p.Direction = 1;
                else if(warp_dir_exit == 4)
                    p.Direction = -1;

                if(p.State == 1)
                    p.Frame = 5;
                else
                    p.Frame = 8;

                if(!p.Controls.Run)
                    p.Controls.Run = true;

                PlayerGrabCode(A);
            }
        }

        p.Effect = PLREFF_NORMAL;
        p.Effect2 = 0;
        p.WarpCD = 20;
        p.CanJump = false;
        p.CanAltJump = false;
        p.Bumped2 = 0;

        if(!backward && warp.cannonExit)
        {
            switch(warp_dir_exit)
            {
            case LevelDoor::EXIT_DOWN:
                p.Location.SpeedY = warp.cannonExitSpeed;
                break;
            case LevelDoor::EXIT_UP:
                p.Location.SpeedY = -warp.cannonExitSpeed;
                break;
            case LevelDoor::EXIT_LEFT:
                p.Location.SpeedX = -warp.cannonExitSpeed;
                p.Direction = -1;
                break;
            case LevelDoor::EXIT_RIGHT:
                p.Location.SpeedX = warp.cannonExitSpeed;
                p.Direction = +1;
                break;
            }

            if(warp_dir_exit == LevelDoor::EXIT_LEFT || warp_dir_exit == LevelDoor::EXIT_RIGHT)
                p.WarpShooted = true;
        }
        else
        {
            p.Location.SpeedY = 0;
            p.Location.SpeedX = 0;
        }

        if(p.HoldingNPC > 0)
            NPC[p.HoldingNPC].Effect = NPCEFF_NORMAL;

        if(g_ClonedPlayerMode)
        {
            for(int B = 1; B <= numPlayers; B++)
            {
                if(B != A)
                {
                    if(warp_dir_exit != 1)
                        Player[B].Location.Y = p.Location.Y + p.Location.Height - Player[B].Location.Height;
                    else
                        Player[B].Location.Y = p.Location.Y;

                    Player[B].Location.X = p.Location.X + (p.Location.Width - Player[B].Location.Width) / 2;
                    Player[B].Location.SpeedY = dRand() * 24 - 12;
                    Player[B].Effect = PLREFF_NORMAL;
                    Player[B].Effect2 = 0;
                    CheckSection(B);
                }
            }
        }

        if(warp.eventExit != EVENT_NONE)
            TriggerEvent(warp.eventExit, A);
    }
}

void PlayerEffectWarpDoor(int A)
{
    Player_t& p = Player[A];

    bool backward = p.WarpBackward;
    const Warp_t &warp = Warp[p.Warp];
    SpeedlessLocation_t sl_warp_enter = (backward ? warp.Exit : warp.Entrance);
    SpeedlessLocation_t sl_warp_exit = (backward ? warp.Entrance : warp.Exit);
    Location_t warp_enter = static_cast<Location_t>(sl_warp_enter);
    Location_t warp_exit = static_cast<Location_t>(sl_warp_exit);

    bool same_section = SectionCollision(p.Section, warp_exit);
    bool do_scroll = (warp.transitEffect == LevelDoor::TRANSIT_SCROLL) && same_section;
    bool is_level_quit = warp.level != STRINGINDEX_NONE || warp.MapWarp;

    if(p.HoldingNPC > 0)
    {
        NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
        NPC[p.HoldingNPC].Location.X = p.Location.X + (p.Location.Width - NPC[p.HoldingNPC].Location.Width) / 2;
        treeNPCUpdate(p.HoldingNPC);
    }

    p.Effect2 += 1;

    if(p.Mount == 0 && p.Character != 5)
        p.Frame = 13;

    if(p.Character == 5)
        p.Frame = 1;

    // just stay in the door after entering it during a flag exit
    if(LevelMacro == LEVELMACRO_FLAG_EXIT)
    {
        if(p.Effect2 == 15)
        {
            p.Effect = PLREFF_WAITING;
            p.Effect2 = -A;
        }
        return;
    }

    // trigger warp fader when p.Effect2 is 5 (for normal animations) or 20 (for none/scroll animations)
    s_WarpFaderLogic(false, A, warp.transitEffect, warp_enter, p.Effect2 == 5, !is_level_quit && !same_section && (p.Effect2 == 20));

    // teleport other players into door in shared screen mode
    Screen_t& screen = ScreenByPlayer(A);
    bool is_shared_screen = (screen.Type == 3);
    if(is_shared_screen && (p.Effect2 == 15))
    {
        int vscreen_A = vScreenIdxByPlayer(A);
        bool do_tele = is_shared_screen && !vScreenCollision(vscreen_A, warp_exit);

        if(do_tele)
        {
            SharedScreenAvoidJump_Pre(screen);

            for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
            {
                int o_A = screen.players[plr_i];
                if(o_A == A)
                    continue;

                Player_t& o_p = Player[o_A];

                // revive someone in wings and bring to warp
                if(o_p.Effect == PLREFF_COOP_WINGS)
                    o_p.Dead = false;

                // in the mouth of an onscreen player's Pet?
                bool in_onscreen_pet = !warp.NoYoshi && InOnscreenPet(o_A, screen);

                bool status_match = (o_p.Effect == p.Effect && o_p.Warp == p.Warp && o_p.WarpBackward == p.WarpBackward);

                if(!o_p.Dead && o_p.TimeToLive == 0 && !in_onscreen_pet && !status_match)
                {
                    RemoveFromPet(o_A);

                    s_WarpReleaseItems(warp, o_A, p.WarpBackward, false);

                    o_p.Warp = p.Warp;
                    o_p.WarpBackward = p.WarpBackward;
                    o_p.Effect = p.Effect;
                    // 1 frame behind so that this player will exit first
                    o_p.Effect2 = 14;
                    o_p.Location.X = warp_enter.X + (warp_enter.Width - o_p.Location.Width) / 2;
                    o_p.Location.Y = warp_enter.Y + warp_enter.Height - o_p.Location.Height;
                    o_p.Location.SpeedX = 0;
                    o_p.Location.SpeedY = 0;
                }
            }

            SharedScreenAvoidJump_Post(screen, (do_scroll) ? 0 : 200);
        }
    }

    // start the scroll effect
    if(do_scroll && p.Effect2 == 29)
    {
        s_InitWarpScroll(p, warp_enter, warp_exit, 30);
        SoundPause[SFX_Door] = 60;
    }
    // process the scroll effect
    else if(p.Effect2 >= 128)
    {
        num_t targetX = warp_exit.X + (warp_exit.Width - p.Location.Width) / 2;
        num_t targetY = warp_exit.Y + warp_exit.Height - p.Location.Height;

        // += 1 above
        p.Effect2 -= 1;

        int frames_left = p.Effect2 - 128;

        p.Location.X += (targetX - p.Location.X) / frames_left;
        p.Location.Y += (targetY - p.Location.Y) / frames_left;

        if(frames_left == 30)
        {
            s_TriggerDoorEffects(warp_exit);
            PlaySoundSpatial(SFX_Door, warp_exit);
        }

        p.Effect2 -= 1;

        if(p.Effect2 <= 128)
            p.Effect2 = 30;
    }

    // finalize the warp
    if(p.Effect2 >= 30 && p.Effect2 < 128)
    {
        if(warp.NoYoshi)
        {
            s_WarpStealMount(A);
            p.Frame = 1;
        }

        p.Location.X = warp_exit.X + s_warp_offset_x(p.Location, (do_scroll) ? sl_warp_exit : sl_warp_enter, sl_warp_exit);
        p.Location.Y = warp_exit.Y + warp_exit.Height - p.Location.Height;

        // set any other players warping to the same door into the door holding pattern (needed to avoid splitting a shared screen)
        if(is_shared_screen)
        {
            for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
            {
                int o_A = screen.players[plr_i];
                if(A == o_A)
                    continue;

                Player_t& o_p = Player[o_A];
                if(!o_p.Dead && o_p.TimeToLive == 0 && o_p.Effect == PLREFF_WARP_DOOR && o_p.Warp == Player[A].Warp && o_p.WarpBackward == Player[A].WarpBackward)
                {
                    o_p.Location.X = warp_exit.X + (warp_exit.Width - o_p.Location.Width) / 2;
                    o_p.Location.Y = warp_exit.Y + warp_exit.Height - o_p.Location.Height;

                    CheckSection(o_A);

                    o_p.Effect = PLREFF_WAITING;
                    o_p.Effect2 = 131;
                    o_p.WarpCD = 40;

                    if(warp.NoYoshi)
                    {
                        s_WarpStealMount(A);
                        p.Frame = 1;
                    }
                }
            }

            // update position of any players in pets
            s_FixPlayersInPets(screen);

            SharedScreenResetTemp(screen);
        }

        CheckSection(A);

        if(p.HoldingNPC > 0)
        {
            if(!p.Controls.Run)
                p.Controls.Run = true;

            PlayerGrabCode(A);
        }

        p.Effect = PLREFF_NORMAL;
        p.Effect2 = 0;
        p.WarpCD = 40;

        if(!is_level_quit)
        {
            // reverse warp fader
            s_WarpFaderLogic(true, A, warp.transitEffect, warp_exit, true, true);

            if(warp.eventExit != EVENT_NONE)
                TriggerEvent(warp.eventExit, A);
        }

        s_CheckWarpLevelExit(p, warp, 3000, 2970);

        if(g_ClonedPlayerMode)
        {
            for(int B = 1; B <= numPlayers; B++)
            {
                if(B != A)
                {
                    Player[B].Location.Y = p.Location.Y + p.Location.Height - Player[B].Location.Height;
                    Player[B].Location.X = p.Location.X + (p.Location.Width - Player[B].Location.Width) / 2;
                    Player[B].Location.SpeedY = dRand() * 24 - 12;
                    CheckSection(B);

                    if(Player[B].HoldingNPC > 0)
                    {
                        if(Player[B].Direction > 0)
                            NPC[Player[B].HoldingNPC].Location.X = Player[B].Location.X + Physics.PlayerGrabSpotX[Player[B].Character][Player[B].State];
                        else
                            NPC[Player[B].HoldingNPC].Location.X = Player[B].Location.X + Player[B].Location.Width - Physics.PlayerGrabSpotX[Player[B].Character][Player[B].State] - NPC[p.HoldingNPC].Location.Width;

                        // TODO: investigate this possible crashing bug (should be Player[B].HoldingNPC)
                        NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
                        NPC[Player[B].HoldingNPC].Section = Player[B].Section;

                        if(p.HoldingNPC > 0 && p.HoldingNPC <= numNPCs)
                            treeNPCUpdate(p.HoldingNPC);

                        // already checked this one > 0 above
                        if(Player[B].HoldingNPC <= numNPCs)
                            treeNPCUpdate(Player[B].HoldingNPC);
                    }
                }
            }
        }
    }
}

void PlayerEffectWarpWait(int A)
{
    Player_t& p = Player[A];

    // door exit holding pattern (exit blocked)
    if(p.Effect2 == 131)
    {
        bool tempBool = false;
        for(int B = 1; B <= numPlayers; B++)
        {
            // Was previously only B != A. New conditions only apply in >2P
            bool check_coll = B != A && !Player[B].Dead && (Player[B].Effect != PLREFF_WAITING || B < A) && (Player[B].Effect != PLREFF_PET_INSIDE);
            if(check_coll && CheckCollision(p.Location, Player[B].Location))
                tempBool = true;
        }

        if(!tempBool)
        {
            p.Effect2 = 130;

            const auto& warp_exit = p.WarpBackward ? Warp[p.Warp].Entrance : Warp[p.Warp].Exit;

            s_TriggerDoorEffects(static_cast<Location_t>(warp_exit), false);

            SoundPause[SFX_Door] = 0;
            PlaySoundSpatial(SFX_Door, p.Location);
        }
    }
    // door exit wait
    else if(p.Effect2 <= 130)
    {
        p.Effect2 -= 1;
        if(p.Effect2 == 100)
        {
            Screen_t& screen = ScreenByPlayer(A);

            SharedScreenAvoidJump_Pre(screen);

            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;

            SharedScreenAvoidJump_Post(screen, 0);
        }
    }
    // 2P holding condition for start warp (pipe exit)
    else if(p.Effect2 <= 300)
    {
        p.Effect2 -= 1;
        if(p.Effect2 == 200)
        {
            Screen_t& screen = ScreenByPlayer(A);

            SharedScreenAvoidJump_Pre(screen);

            p.Effect2 = 100;
            p.Effect = PLREFF_WARP_PIPE;

            SharedScreenAvoidJump_Post(screen, 0);
        }
    }
    else if(p.Effect2 <= 1000) // Start Wait for pipe
    {
        p.Effect2 -= 1;
        if(p.Effect2 == 900)
        {
            p.Effect = PLREFF_WARP_PIPE;
            p.Effect2 = 100;

            const Screen_t& screen = ScreenByPlayer(A);

            bool do_modern = !g_ClonedPlayerMode && (numPlayers > 2 || screen.Type == ScreenTypes::SharedScreen || XMessage::GetStatus() != XMessage::Status::local);
            if(!do_modern)
            {
                // 2P holding condition for start warp
                if(A == screen.players[1])
                {
                    p.Effect = PLREFF_WAITING;
                    p.Effect2 = 300;
                }
            }
            else
                s_delay_pipe_exit(A);
        }
    }
    else if(p.Effect2 <= 2000) // Start Wait for door
    {
        p.Effect2 -= 1;

        if(p.Effect2 == 1900)
        {
            s_TriggerDoorEffects(static_cast<Location_t>(Warp[p.Warp].Exit), false);

            SoundPause[SFX_Door] = 0;

            // SMBX 1.3 logic for P1, see below
            // p.Effect = PLREFF_WAITING;
            // p.Effect2 = 30;

            if(A >= 2 && !g_ClonedPlayerMode)
            {
                p.Effect = PLREFF_WAITING;
                p.Effect2 = 131;
            }
            else
                PlaySoundSpatial(SFX_Door, p.Location);
        }
        // new code to replicate SMBX 1.3 logic setting Effect2 to 30
        else if(p.Effect2 == 1870)
        {
            // Trigger an exit event at door warp that was used to enter the level
            if(Warp[p.Warp].eventExit != EVENT_NONE)
                TriggerEvent(Warp[p.Warp].eventExit, A);

            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
        }
    }
    else if(p.Effect2 <= 3000) // exit warp wait
    {
        p.Effect2 -= 1;

        auto &w = Warp[p.Warp];

        if(g_config.EnableInterLevelFade && (w.MapWarp || w.level != STRINGINDEX_NONE) && (p.Effect2 == 2955) && !g_levelScreenFader.isFadingIn())
            g_levelScreenFader.setupFader(2, 0, 65, ScreenFader::S_FADE);

        if(p.Effect2 == 2920)
        {
            if(w.MapWarp)
            {
                LevelBeatCode = BEATCODE_WARP;

                if(!(w.MapX == -1 && w.MapY == -1))
                {
                    WorldPlayer[1].Location.X = w.MapX;
                    WorldPlayer[1].Location.Y = w.MapY;

                    for(int l = 1; l <= numWorldLevels; ++l)
                    {
                        if(CheckCollision(WorldPlayer[1].Location, WorldLevel[l].Location))
                        {
                            WorldLevel[l].Active = true;
                            curWorldLevel = l;
                        }
                    }
                }
            }
            EndLevel = true;
            return;
        }
    }
}

static inline bool checkWarp(Warp_t &warp, int B, Player_t &plr, int A, bool backward)
{
    bool onGround = !warp.stoodRequired || (plr.Pinched.Bottom1 == 2 || plr.Slope != 0 || plr.StandingOnNPC != 0);

    const auto &entrance      = backward ? warp.Exit        : warp.Entrance;
    const auto &exit          = backward ? warp.Entrance    : warp.Exit;
    const auto &direction     = backward ? warp.Direction2  : warp.Direction;

    if(!CheckCollision(plr.Location, entrance))
        return false; // continue

    // moved from SuperWarp so that we can stop WarpCD for portal warps until collision is done
    if(plr.WarpCD > 0)
    {
        // if a portal warp is the most recent warp used by player A, and they are still colliding with it, don't reset WarpCD until the collision is over.
        if(warp.Effect == 3 && B == plr.Warp)
            plr.WarpCD = 10;

        return false;
    }

    plr.ShowWarp = B;

    if(warp.LevelEnt)
        return false;

    // can't enter pipe/door warps from maze zone
    if(plr.CurMazeZone && (warp.Effect == 1 || warp.Effect == 2))
        return false;

    bool canWarp = false;

    if(warp.Effect == 3) // Portal
        canWarp = true;
    else if(direction == 1 && plr.Controls.Up) // Pipe
    {
        if(WarpCollision(plr.Location, entrance, direction) && (warp.Effect != 2 || onGround))
            canWarp = true;
    }
    else if(direction == 2 && plr.Controls.Left)
    {
        if(WarpCollision(plr.Location, entrance, direction) && onGround)
            canWarp = true;
    }
    else if(direction == 3 && plr.Controls.Down)
    {
        if(WarpCollision(plr.Location, entrance, direction) && onGround)
            canWarp = true;
    }
    else if(direction == 4 && plr.Controls.Right)
    {
        if(WarpCollision(plr.Location, entrance, direction) && onGround)
            canWarp = true;
    }
    // NOTE: Would be correct to move this up, but leave this here for a compatibility to keep the same behavior
    else if(warp.Effect == 0) // Instant
        canWarp = true;

    if(!canWarp)
        return false;

    if(warp.Stars > numStars)
    {
        bool do_swap_frame = (g_config.fix_visual_bugs && warp.Effect == 1 && direction == 3 && plr.Duck && plr.SwordPoke == 0);
        int old_plr_frame = plr.Frame;

        if(do_swap_frame)
        {
            // Show the duck frame only when attempting to go down
            plr.Frame = (plr.Character == 5) ? 5 : 7;
        }

        if(warp.StarsMsg == STRINGINDEX_NONE)
            MessageText = fmt::format_ne(g_gameStrings.warpNeedStarCount, warp.Stars, LanguageFormatNumber(warp.Stars, g_gameInfo.wordStarAccusativeSingular, g_gameInfo.wordStarAccusativeDual_Cnt, g_gameInfo.wordStarAccusativePlural), g_gameInfo.wordStarAccusativeDual_Cnt);
        else
            MessageText = GetS(warp.StarsMsg);

        // store all warp-local vars
        PauseInit(PauseCode::Message, A);
        g_gameLoopInterrupt.site = GameLoopInterrupt::UpdatePlayer_SuperWarp;
        g_gameLoopInterrupt.A = A;
        g_gameLoopInterrupt.B = B;
        g_gameLoopInterrupt.C = old_plr_frame;
        g_gameLoopInterrupt.bool4 = do_swap_frame;

        // return true to break out of the loop
        return true;
    }

    plr.Slide = false;

    if(warp.Effect != 3)
        plr.Stoned = false;

    if(warp.Locked)
    {
        // if player has a key, consume it and allow unlocking the warp
        if(plr.HoldingNPC > 0 && NPC[plr.HoldingNPC].Type == NPCID_KEY)
        {
            NPC[plr.HoldingNPC].Killed = 9;
            NPCQueues::Killed.push_back(plr.HoldingNPC);

            NewEffect(EFFID_SMOKE_S3, NPC[plr.HoldingNPC].Location);
        }
        else if(plr.Mount == 3 && plr.YoshiNPC > 0 && NPC[plr.YoshiNPC].Type == NPCID_KEY)
        {
            NPC[plr.YoshiNPC].Killed = 9;
            NPCQueues::Killed.push_back(plr.YoshiNPC);
            plr.YoshiNPC = 0;
        }
        else if(plr.HasKey)
        {
            plr.HasKey = false;
        }
        // otherwise, don't allow unlocking
        else
            return false;

        // if player can still warp, unlock the warp
        warp.Locked = false;

        // remove warp lock icon
        int allBGOs = numBackground + numLocked;
        for(int C = numBackground + 1; C <= allBGOs; C++)
        {
            if(Background[C].Type == 98)
            {
                if(CheckCollision(entrance, Background[C].Location) ||
                   (warp.twoWay && CheckCollision(exit, Background[C].Location)))
                {
                    // this makes Background[C] disappear and never reappear
                    Background[C].Layer = LAYER_NONE;
                    Background[C].Hidden = true;
                    syncLayers_BGO(C);
                }
            }
        }
    }

    // execute the warp!
    plr.AquaticSwim = false;
    UnDuck(Player[A]);
    plr.YoshiTongueLength = 0;
    plr.MountSpecial = 0;
    plr.FrameCount = 0;
    plr.TailCount = 0;
    plr.CanFly = false;
    plr.CanFly2 = false;
    plr.RunCount = 0;

    s_WarpReleaseItems(warp, A, backward);

    if(warp.Effect != 3) // Don't zero speed when passing a portal warp
    {
        plr.Location.SpeedX = 0;
        plr.Location.SpeedY = 0;
    }

    if(warp.eventEnter != EVENT_NONE)
        TriggerEvent(warp.eventEnter, A);

    if(warp.Effect == 0 || warp.Effect == 3) // Instant / Portal
    {
        if(warp.Effect == 3)
            plr.Warp = B;

        if(warp.Effect == 3 && (warp.level != STRINGINDEX_NONE || warp.MapWarp))
        {
            plr.WarpBackward = backward;
            s_CheckWarpLevelExit(plr, warp, 2921, 2921);

            return true;
        }

        plr.WarpCD = (warp.Effect == 3) ? 10 : 50;

        num_t off_x = s_warp_offset_x(plr.Location, entrance, exit);
        num_t off_y = s_warp_offset_y(plr.Location, entrance, exit) - 0.1_n;

        // special logic to keep location correct in maze zones
        if(plr.CurMazeZone)
        {
            off_x = plr.Location.X - entrance.X;
            off_y = plr.Location.Y - entrance.Y;
            plr.WarpCD = 80;
        }

        plr.Location.X = exit.X + off_x;
        plr.Location.Y = exit.Y + off_y;
        CheckSection(A);

        const Screen_t& screen = ScreenByPlayer(A);
        int vscreen_A = vScreenIdxByPlayer(A);
        bool is_shared_screen = (screen.Type == 3);
        bool do_tele = is_shared_screen && !vScreenCollision(vscreen_A, exit);

        // teleport other players using the instant/portal warp in shared screen mode
        if(do_tele)
        {
            for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
            {
                int o_A = screen.players[plr_i];
                if(o_A == A)
                    continue;

                Player_t& o_p = Player[o_A];

                // revive someone in wings and bring to warp
                if(o_p.Effect == PLREFF_COOP_WINGS)
                    o_p.Dead = false;

                // in the mouth of an onscreen player's Pet?
                bool in_onscreen_pet = !warp.NoYoshi && InOnscreenPet(o_A, screen);

                if(!o_p.Dead && o_p.TimeToLive == 0 && !in_onscreen_pet)
                {
                    RemoveFromPet(o_A);

                    o_p.Location.X = exit.X + (exit.Width - o_p.Location.Width) / 2;
                    o_p.Location.Y = exit.Y + exit.Height - o_p.Location.Height - 0.1_n;

                    // override if in maze zone
                    if(plr.CurMazeZone)
                    {
                        o_p.CurMazeZone = plr.CurMazeZone;
                        o_p.MazeZoneStatus = plr.MazeZoneStatus;
                        o_p.Location.X = plr.Location.X;
                        o_p.Location.Y = plr.Location.Y;
                    }

                    CheckSection(o_A);

                    if(warp.Effect != 3) // Don't zero speed when passing a portal warp
                    {
                        o_p.Location.SpeedX = 0;
                        o_p.Location.SpeedY = 0;
                    }

                    o_p.Vine = plr.Vine;
                    o_p.WarpCD = (warp.Effect == 3) ? 10 : 50;

                    // put other player in no-collide mode
                    o_p.Effect = PLREFF_NO_COLLIDE;
                    o_p.Effect2 = A;
                }
            }

            // update position of any players in pets
            s_FixPlayersInPets(screen);

            GetvScreenAuto(vScreen[vscreen_A]);
        }

        if(warp.eventExit != EVENT_NONE)
            TriggerEvent(warp.eventExit, A);

        return true; // break
    }
    else if(warp.Effect == 1) // Pipe
    {
        PlaySoundSpatial(SFX_Warp, plr.Location);
        plr.Effect = PLREFF_WARP_PIPE;
        if(g_config.fix_fairy_stuck_in_pipe)
            plr.Effect2 = 0;
        plr.Warp = B;
        plr.WarpBackward = backward;
//                        if(nPlay.Online && A == nPlay.MySlot + 1)
//                            Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1j" + std::to_string(A) + "|" + plr.Warp + LB;
    }
    else if(warp.Effect == 2) // Door
    {
        PlaySoundSpatial(SFX_Door, plr.Location);
        plr.Effect = PLREFF_WARP_DOOR;

        if(g_config.fix_fairy_stuck_in_pipe)
            plr.Effect2 = 0;

        plr.Warp = B;
        plr.WarpBackward = backward;
//                        if(nPlay.Online && A == nPlay.MySlot + 1)
//                            Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1j" + std::to_string(A) + "|" + plr.Warp + LB;
        plr.Location.X = entrance.X + s_warp_offset_x(plr.Location, entrance, entrance);
        plr.Location.Y = entrance.Y + entrance.Height - plr.Location.Height;

        bool same_section = SectionCollision(plr.Section, static_cast<Location_t>(exit));
        bool do_scroll = (warp.transitEffect == LevelDoor::TRANSIT_SCROLL) && same_section;

        s_TriggerDoorEffects(static_cast<Location_t>(entrance));

        if(!do_scroll)
            s_TriggerDoorEffects(static_cast<Location_t>(exit));
    }

    return false; // continue
}

void SuperWarp(const int A)
{
    auto &plr = Player[A];
    int B = 1;

    if(g_gameLoopInterrupt.site != GameLoopInterrupt::None)
    {
        // clear message text
        MessageText.clear();

        // Restore previous frame if needed
        if(g_gameLoopInterrupt.bool4)
            plr.Frame = g_gameLoopInterrupt.C;

        // check the warp after the one that triggered the message
        B = g_gameLoopInterrupt.B + 1;

        // reset the g_gameLoopInterrupt state
        g_gameLoopInterrupt.site = GameLoopInterrupt::None;
    }

    if(plr.Mount == 2)
        return;

    for(; B <= numWarps; B++)
    {
        auto &warp = Warp[B];

        if(warp.Hidden)
            continue;

        // In normal mode, ignore pounds only for pipe / door warps. In compat mode, ignore pounds for all warps.
        bool ground_pound = plr.GroundPound || plr.GroundPound2;
        bool skip_pounds = !g_config.fix_pound_skip_warp || warp.Effect == 1 || warp.Effect == 2;
        if(ground_pound && skip_pounds)
            continue;

        if(checkWarp(warp, B, plr, A, false))
            break;

        if(warp.twoWay) // Check the same warp again if two-way
        {
            if(checkWarp(warp, B, plr, A, true))
                break;
        }
    }

    if(plr.WarpCD > 0)
        plr.WarpCD--;
}


================================================
FILE: src/player.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <cmath>
#include <ctime>
#include <pge_delay.h>
#include <Logger/logger.h>

#include "sdl_proxy/sdl_stdinc.h"

#include "globals.h"
#include "player.h"
#include "player/player_effect.h"
#include "player/player_update_priv.h"
#include "graphics.h"
#include "collision.h"
#include "npc.h"
#include "npc_id.h"
#include "eff_id.h"
#include "npc_traits.h"
#include "sound.h"
#include "game_main.h"
#include "effect.h"
#include "blocks.h"
#include "editor.h"
#include "layers.h"
#include "config.h"
#include "phys_env.h"
#include "main/level_file.h"
#include "main/game_globals.h"
#include "main/trees.h"
#include "main/menu_main.h"
#include "main/level_medals.h"
#include "core/render.h"
#include "core/events.h"
#include "script/luna/lunacounter.h"

#include "npc/npc_queues.h"

#include "controls.h"


//void WaterCheck(const int A);
//// Private Sub Tanooki(A As Integer)
//void Tanooki(const int A);
//// Private Sub PowerUps(A As Integer)
//void PowerUps(const int A);
//// Private Sub SuperWarp(A As Integer)
//void SuperWarp(const int A);
//// Private Sub PlayerCollide(A As Integer)
//void PlayerCollide(const int A);
//// Private Sub PlayerEffects(A As Integer)
//void PlayerEffects(const int A);


static void setupPlayerAtCheckpoints(NPC_t &npc, Checkpoint_t &cp)
{
    Location_t tempLocation;
    int B;
    int C;
    tempLocation = npc.Location;
    tempLocation.Height = 600;

    C = 0;
    for(int bi : treeBlockQuery(tempLocation, SORTMODE_COMPAT))
    {
        if(CheckCollision(tempLocation, Block[bi].Location))
        {
            if(C == 0)
                C = bi;
            else
            {
                if(Block[bi].Location.Y < Block[C].Location.Y)
                    C = bi;
            }
        }
    }

    for(B = 1; B <= numPlayers; B++)
    {
        Player[B].Location.Y = Block[C].Location.Y - Player[B].Location.Height;
        Player[B].Location.X = npc.Location.X + (npc.Location.Width - Player[B].Location.Width) / 2;
        CheckSection(B);
        pLogDebug("Restore player %d at checkpoint ID=%d by X=%d, Y=%d",
                  B, cp.id, (int)Player[B].Location.X, (int)Player[B].Location.Y);
    }

    if(numPlayers > 1 && g_config.multiplayer_pause_controls && !g_ClonedPlayerMode)
    {
        for(B = 1; B <= numPlayers; B++)
            DodgePlayers(B);
    }
    else if(numPlayers > 1)
    {
        Player[1].Location.X -= 16;
        Player[2].Location.X += 16;
    }
}

static void setupCheckpoints()
{
    if(Checkpoint != FullFileName || Checkpoint.empty())
    {
        if(!IsHubLevel && !LevelSelect)
        {
            pLogDebug("Clear check-points at SetupPlayers()");
            Checkpoint.clear();
            CheckpointsList.clear();
            g_curLevelMedals.reset_checkpoint();
        }
        return;
    }

    // restore medals from checkpoint
    g_curLevelMedals.resume_from_checkpoint();

    pLogDebug("Trying to restore %zu checkpoints...", CheckpointsList.size());
    if(!g_config.fix_vanilla_checkpoints && CheckpointsList.empty())
    {
        pLogDebug("Using legacy algorithm");
        CheckpointsList.push_back(Checkpoint_t());
    }
    for(int cpId = 0; cpId < int(CheckpointsList.size()); cpId++)
    {
        auto &cp = CheckpointsList[size_t(cpId)];

        for(int A = 1; A <= numNPCs; A++)
        {
            if(NPC[A].Type != NPCID_CHECKPOINT)
                continue;

            if(g_config.fix_vanilla_checkpoints && cp.id != NPC[A].Special)
                continue;

            NPC[A].Killed = 9;
            NPCQueues::Killed.push_back(A);

            // found a last id, leave player here
            if(!g_config.fix_vanilla_checkpoints || cpId == int(CheckpointsList.size() - 1))
            {
                setupPlayerAtCheckpoints(NPC[A], cp);
                if(g_config.fix_vanilla_checkpoints)
                    break;// Stop to find NPCs
            }
        }// for NPCs

        if(!g_config.fix_vanilla_checkpoints)
            break;
    } // for Check points
}

struct PlayerStartInfo_t
{
    static constexpr int start_pos_count = 2;
    std::array<uint8_t, start_pos_count> players_at_start{};
    std::array<uint8_t, c_screenCount> start_for_screen{}; // used by shared screens only
};

static void s_PlacePlayerAtStart(int A, PlayerStartInfo_t& player_start_info)
{
    /**************************************
    ** (1) pick which start point to use **
    **************************************/
    int use_start = -1;

    // check for shared screen
    const int plr_screen_i = ScreenIdxByPlayer(A);
    const Screen_t& plr_screen = ScreenByPlayer(A);
    if(plr_screen.Type == ScreenTypes::SharedScreen)
        use_start = (int)player_start_info.start_for_screen[plr_screen_i] - 1;

    // if not forced by shared screen, choose start with the least players
    if(use_start == -1)
    {
        // default to initial start
        use_start = 0;

        // check whether a later start has fewer players
        for(int start = 1; start < PlayerStartInfo_t::start_pos_count; start++)
        {
            if(PlayerStart[start + 1].isNull())
                continue;

            if(player_start_info.players_at_start[start] < player_start_info.players_at_start[use_start])
                use_start = start;
        }

        // add either the player alone, or all players on the player's screen, to the count
        if(plr_screen.Type == ScreenTypes::SharedScreen)
        {
            player_start_info.players_at_start[use_start] += plr_screen.player_count;
            player_start_info.start_for_screen[plr_screen_i] = use_start + 1;
        }
        else
            player_start_info.players_at_start[use_start] += 1;
    }


    /*******************************
    ** (2) basic player placement **
    *******************************/

    // place at start
    const auto& ps = PlayerStart[use_start + 1];
    auto& pLoc = Player[A].Location;

    num_t ps_X = ps.X + (ps.Width - pLoc.Width) / 2;
    num_t ps_Y = ps.Y + ps.Height - pLoc.Height;

    pLoc.X = ps_X;
    pLoc.Y = ps_Y;
    Player[A].Direction = ps.Direction;


    /**********************************
    ** (3) logic to avoid collisions **
    **********************************/

    // ignore collisions in clone mode
    if(g_ClonedPlayerMode)
        return;

    DodgePlayers(A);
}

static void s_makePetMount(int A)
{
    const Player_t& p = Player[A];

    numNPCs++;

    NPC[numNPCs].Direction = p.Direction;
    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = 100;

    if(p.MountType == 1)
        NPC[numNPCs].Type = NPCID_PET_GREEN;
    else if(p.MountType == 2)
        NPC[numNPCs].Type = NPCID_PET_BLUE;
    else if(p.MountType == 3)
        NPC[numNPCs].Type = NPCID_PET_YELLOW;
    else if(p.MountType == 4)
        NPC[numNPCs].Type = NPCID_PET_RED;
    else if(p.MountType == 5)
        NPC[numNPCs].Type = NPCID_PET_BLACK;
    else if(p.MountType == 6)
        NPC[numNPCs].Type = NPCID_PET_PURPLE;
    else if(p.MountType == 7)
        NPC[numNPCs].Type = NPCID_PET_PINK;
    else if(p.MountType == 8)
        NPC[numNPCs].Type = NPCID_PET_CYAN;

    NPC[numNPCs].Location.Height = 32;
    NPC[numNPCs].Location.Width = 32;
    NPC[numNPCs].Location.Y = p.Location.Y + p.Location.Height - 32;
    NPC[numNPCs].Location.X = num_t::floor(p.Location.X + p.Location.Width / 2 - 16);
    NPC[numNPCs].Location.SpeedY = 0.5_n;
    NPC[numNPCs].Location.SpeedX = 0;
    NPC[numNPCs].CantHurt = 10;
    NPC[numNPCs].CantHurtPlayer = A;

    PlayerThrownNpcMazeCheck(p, NPC[numNPCs]);

    syncLayers_NPC(numNPCs);
}

static void s_makeVehicleMount(int A)
{
    const Player_t& p = Player[A];

    numNPCs++;

    NPC[numNPCs].Direction = p.Direction;
    if(NPC[numNPCs].Direction == 1)
        NPC[numNPCs].Frame = 4;

    NPC[numNPCs].Frame += SpecialFrame[2];
    NPC[numNPCs].Active = true;
    NPC[numNPCs].TimeLeft = 100;
    NPC[numNPCs].Type = NPCID_VEHICLE;

    NPC[numNPCs].Location.Height = 128;
    NPC[numNPCs].Location.Width = 128;
    NPC[numNPCs].Location.Y = num_t::floor(p.Location.Y);
    NPC[numNPCs].Location.X = num_t::floor(p.Location.X);
    NPC[numNPCs].Location.SpeedY = 0;
    NPC[numNPCs].Location.SpeedX = 0;

    NPC[numNPCs].CantHurt = 10;
    NPC[numNPCs].CantHurtPlayer = A;
    syncLayers_NPC(numNPCs);
}

void DodgePlayers(int plr_A)
{
    auto& pLoc = Player[plr_A].Location;
    const Screen_t& plr_screen = ScreenByPlayer(plr_A);

    // save current position
    num_t orig_X = pLoc.X;
    num_t orig_Y = pLoc.Y;


    // check section of current position for later use
    int cur_section = -1;
    for(int B = 0; B < numSections; B++)
    {
        if(pLoc.X + pLoc.Width >= level[B].X
            && pLoc.X <= level[B].Width
            && pLoc.Y + pLoc.Height >= level[B].Y
            && pLoc.Y <= level[B].Height)
        {
            cur_section = B;
        }
    }


    // check for floor of current position for later use
    bool orig_has_floor = false;
    const Location_t orig_floor_check = newLoc(orig_X + pLoc.Width / 2, pLoc.Y + pLoc.Height, 1, 48);

    for(BlockRef_t b_ref : treeBlockQuery(orig_floor_check, SORTMODE_NONE))
    {
        const Block_t& b = b_ref;
        int B = (int)b_ref;

        if(b.Hidden || b.Invis || BlockNoClipping[b.Type])
            continue;

        if(BlockCheckPlayerFilter(B, plr_A))
            continue;

        if(CheckCollision(orig_floor_check, b.Location))
        {
            orig_has_floor = true;
            break;
        }
    }


    // first try to place players backwards from current position, then do forwards if that doesn't work
    bool forwards_direction = false;

    // this loop repeats each time the player is placed to avoid collisions
    while(true)
    {
        // (a) check for player collision
        bool hit = false;

        for(int B = 1; B < plr_A; B++)
        {
            if(CheckCollision(pLoc, Player[B].Location))
            {
                hit = true;
                break;
            }
        }

        if(!hit)
            break;


        // (b) prepare to restore old position on failure
        bool failed = false;

        num_t old_X = pLoc.X;
        num_t old_Y = pLoc.Y;


        // (c) X logic: move player backwards, and check it hasn't moved off section / off screen
        constexpr int plr_spacing = 40;
        const int X_move = (plr_spacing - plr_spacing * 2 * forwards_direction) * Player[plr_A].Direction;
        pLoc.X -= X_move;

        // check for failures of being outside of section X bounds (partially offscreen)
        if(!failed && cur_section != -1 && (pLoc.X < level[cur_section].X || pLoc.X + pLoc.Width > level[cur_section].Width))
            failed = true;

        // also check being too far from start point (Shared Screen mode)
        if(!failed && plr_screen.Type == ScreenTypes::SharedScreen && num_t::abs(pLoc.X - orig_X) > plr_screen.W * 0.75_n)
            failed = true;


        // (d) Y logic: do floor checks, check player hasn't moved off screen, and confirm the player didn't cross a ceiling
        constexpr int max_height_add = 160;
        num_t top_bound = pLoc.Y - max_height_add;
        bool check_floor = true;

        // perform floor check (move player upwards until they are above blocks)
        while(!failed && check_floor)
        {
            check_floor = false;

            // check the whole range from player's old position to player's new position (prevents crossing walls)
            num_t left_X = pLoc.X;
            num_t right_X = pLoc.X + pLoc.Width;
            if(X_move < 0)
                right_X -= X_move;
            else
                left_X -= X_move;

            const Location_t floor_check_range = newLoc(left_X, pLoc.Y + pLoc.Height, right_X - left_X, pLoc.Height);

            for(BlockRef_t b_ref : treeBlockQuery(floor_check_range, SORTMODE_NONE))
            {
                const Block_t& b = b_ref;
                int B = (int)b_ref;

                if(b.Hidden || b.Invis || BlockIsSizable[b.Type] || BlockOnlyHitspot1[b.Type] || BlockNoClipping[b.Type])
                    continue;

                if(BlockCheckPlayerFilter(B, plr_A))
                    continue;

                if(CheckCollision(floor_check_range, b.Location))
                {
                    num_t new_Y = blockGetTopYTouching(b, pLoc);

                    if(new_Y - pLoc.Height < pLoc.Y)
                    {
                        check_floor = true;
                        pLoc.Y = new_Y - pLoc.Height;

                        break;
                    }
                }
            }

            // check we didn't go too high
            if(pLoc.Y < top_bound)
                failed = true;
        }

        // perform cliff check (move player downwards until they are on blocks) if the original position had a floor
        if(!failed && orig_has_floor && pLoc.Y >= old_Y)
        {
            bool found_floor = false;
            num_t top_Y = 0;

            const Location_t new_floor_check = newLoc(pLoc.X, pLoc.Y + pLoc.Height, pLoc.Width, max_height_add);

            for(BlockRef_t b_ref : treeBlockQuery(new_floor_check, SORTMODE_NONE))
            {
                const Block_t& b = b_ref;
                int B = (int)b_ref;

                if(b.Hidden || b.Invis || BlockNoClipping[b.Type])
                    continue;

                if(BlockCheckPlayerFilter(B, plr_A))
                    continue;

                if((BlockIsSizable[b.Type] || BlockOnlyHitspot1[b.Type]) && b.Location.Y < new_floor_check.Y)
                    continue;

                if(CheckCollision(new_floor_check, b.Location))
                {
                    num_t new_Y = blockGetTopYTouching(b, new_floor_check);

                    if(!found_floor || new_Y < top_Y)
                    {
                        found_floor = true;
                        top_Y = new_Y;
                    }
                }
            }

            if(found_floor)
                pLoc.Y = top_Y - pLoc.Height;
            else
                failed = true;
        }

        // check for failures of being outside of section Y bounds (totally offscreen)
        if(!failed && cur_section != -1 && (pLoc.Y + pLoc.Height < level[cur_section].Y || pLoc.Y > level[cur_section].Height))
            failed = true;

        // check being too far from original position (Shared Screen mode)
        if(!failed && plr_screen.Type == ScreenTypes::SharedScreen && num_t::abs(pLoc.Y - orig_Y) > plr_screen.H * 0.75_n)
            failed = true;

        // check we didn't cross a ceiling block (in the previous column)
        if(!failed && pLoc.Y < old_Y)
        {
            const Location_t ceiling_check = newLoc(old_X + pLoc.Width / 2, pLoc.Y, 1, old_Y - pLoc.Y);

            for(BlockRef_t b_ref : treeBlockQuery(pLoc, SORTMODE_NONE))
            {
                const Block_t& b = b_ref;
                int B = (int)b_ref;

                if(b.Hidden || b.Invis || BlockIsSizable[b.Type] || BlockOnlyHitspot1[b.Type] || BlockNoClipping[b.Type])
                    continue;

                if(BlockCheckPlayerFilter(B, plr_A))
                    continue;

                if(CheckCollision(ceiling_check, b.Location))
                {
                    failed = true;
                    break;
                }
            }
        }

        // perform lava check
        if(!failed)
        {
            const Location_t lava_check = newLoc(pLoc.X, pLoc.Y + pLoc.Height, pLoc.Width, 31);

            for(BlockRef_t b_ref : treeBlockQuery(lava_check, SORTMODE_NONE))
            {
                const Block_t& b = b_ref;
                int B = (int)b_ref;

                if(b.Hidden || b.Invis || BlockNoClipping[b.Type])
                    continue;

                if(BlockCheckPlayerFilter(B, plr_A))
                    continue;

                if(CheckCollision(lava_check, b.Location))
                {
                    if(BlockHurts[b.Type] || BlockKills[b.Type])
                    {
                        failed = true;
                        break;
                    }
                }
            }
        }


        // (d) on failure, first restart and try forwards direction
        if(failed && !forwards_direction)
        {
            pLoc.X = orig_X;
            pLoc.Y = orig_Y;
            forwards_direction = true;
        }
        // otherwise, restore old position and disable player collisions
        else if(failed)
        {
            pLoc.X = old_X;
            pLoc.Y = old_Y;

            Player[plr_A].Effect = PLREFF_RESPAWN;
            Player[plr_A].RespawnY = pLoc.Y;
            break;
        }
    }
}

void SetupPlayers()
{
//    Location_t tempLocation;
//    Controls_t blankControls;
    int A = 0;
    int B = 0;
//    int C = 0;

    InvincibilityTime = 0;
    FreezeNPCs = false;
    qScreen = false;
    qScreen_canonical = false;
    ForcedControls = false;
    // online stuff
    //    if(nPlay.Online)
    //    {
    //        for(A = 0; A <= 15; A++)
    //        {
    //            nPlay.Player[A].Controls = blankControls;
    //            nPlay.MyControls = blankControls;
    //        }
    //    }
    //    if(nPlay.Online)
    //    {
    //        if(nPlay.Mode == 1)
    //            nPlay.MySlot = 0;
    //        else
    //        {
    //            for(A = 1; A <= 15; A++)
    //            {
    //                if(nPlay.Player[A].IsMe)
    //                {
    //                    nPlay.MySlot = A;
    //                    break;
    //                }
    //            }
    //        }
    //    }

    // battle mode
    if(BattleMode)
    {
        for(A = 1; A <= numPlayers; A++)
        {
            Player[A].State = 2;
            Player[A].Hearts = 2;
        }
        pLogDebug("Clear check-points at Battle Mode begining");
        Checkpoint.clear();
        CheckpointsList.clear();
        g_curLevelMedals.reset_checkpoint();
    }
    else
    {
        BattleIntro = 0;
        BattleOutro = 0;
    }


    // new-added struct to handle start points in >2P
    PlayerStartInfo_t player_start_info; ////// Some sort of corruption here?? Seems unable to select the start correctly. Fix before pushing.

    for(int numPlayersMax = numPlayers, A = 1; A <= numPlayersMax; A++) // set up players
    {
        if(Player[A].Character == 0) // player has no character
        {
            Player[A].Character = 1; // Sets as Mario
            if(numPlayers == 2 && A == 2 /*&& nPlay.Online == false*/) // Sets as Luigi
                Player[A].Character = 2;
        }
        //        if(nPlay.Online) // online stuff
        //        {
        //            Player[A].State = 2; // Super mario
        //            Player[A].Mount = 0;
        //            if(A == nPlay.MySlot + 1)
        //            {
        //                if(frmNetplay::optPlayer(2).Value)
        //                    Player[A].Character = 2;
        //                else if(frmNetplay::optPlayer(3).Value)
        //                    Player[A].Character = 3;
        //                else if(frmNetplay::optPlayer(4).Value)
        //                    Player[A].Character = 4;
        //                else
        //                    Player[A].Character = 1;
        //            }
        //        }
        if(Player[A].State == 0) // if no state it defaults to small mario
            Player[A].State = 1;
        // box to hearts

        if(Player[A].Character == 3 || Player[A].Character == 4 || Player[A].Character == 5) // Peach and Toad
        {
            if(Player[A].Hearts <= 0)
                Player[A].Hearts = 1;

            // power up limiter
            // If (.Character = 3 Or .Character = 4) And .State > 3 And .State <> 7 Then .State = 2

            if(Player[A].Hearts <= 1 && Player[A].State > 1 && Player[A].Character != 5)
                Player[A].Hearts = 2;
            if(Player[A].HeldBonus > 0)
            {
                Player[A].Hearts += 1;
                Player[A].HeldBonus = NPCID(0);
            }
            if(Player[A].State == 1 && Player[A].Hearts > 1)
                Player[A].State = 2;
            if(Player[A].Hearts > 3)
                Player[A].Hearts = 3;
            if(Player[A].Mount == 3)
                Player[A].Mount = 0;
        }
        else // Mario and Luigi
        {
            if(Player[A].Hearts == 3 && Player[A].HeldBonus == 0)
                Player[A].HeldBonus = NPCID_POWER_S3;
            Player[A].Hearts = 0;
        }
        if(Player[A].Character == 5)
            Player[A].Mount = 0;

        Player[A].Direction = 1; // Moved from below to here
        Player[A].Location.Width = Physics.PlayerWidth[Player[A].Character][Player[A].State]; // set height
        Player[A].Location.Height = Physics.PlayerHeight[Player[A].Character][Player[A].State]; // set width
        if(Player[A].State == 1 && Player[A].Mount == 1) // if small and in a shoe then set the height to super mario
            Player[A].Location.Height = Physics.PlayerHeight[1][2];

        // moved from below to here
        Player[A].Effect = PLREFF_NORMAL;
        Player[A].Effect2 = 0;
        Player[A].RespawnY = 0;

        // modern multiplayer placement code
        if(g_config.multiplayer_pause_controls)
        {
            s_PlacePlayerAtStart(A, player_start_info);
        }
        // legacy multiplayer placement code
        else
        {
            if(numPlayers == 2 && A == 2)
                B = 2;
            else
                B = 1;

            if(A == 2 && PlayerStart[B].X == 0 && PlayerStart[B].Y == 0)
            {
                Player[A].Location.X = PlayerStart[1].X + (PlayerStart[1].Width - Player[A].Location.Width) / 2;
                Player[A].Location.Y = PlayerStart[1].Y + PlayerStart[1].Height - Player[A].Location.Height; // - 2
                Player[A].Direction = PlayerStart[1].Direction; // manually defined direction of player
            }
            else
            {
                Player[A].Location.X = PlayerStart[B].X + (PlayerStart[B].Width - Player[A].Location.Width) / 2;
                Player[A].Location.Y = PlayerStart[B].Y + PlayerStart[B].Height - Player[A].Location.Height; // - 2
                Player[A].Direction = PlayerStart[B].Direction; // manually defined direction of player
            }
        }

        Player[A].CanGrabNPCs = GrabAll;

        // reset all variables
        if(Player[A].Mount == 2)
            Player[A].Mount = 0;
        if(Player[A].Character >= 3 && Player[A].Mount == 3)
            Player[A].Mount = 0;

        Player[A].Slippy = false;
        Player[A].DoubleJump = false;
        Player[A].FlySparks = false;
        Player[A].Quicksand = 0;
        Player[A].Bombs = 0;
        Player[A].Wet = 0;
        Player[A].ShellSurf = false;
        Player[A].Rolling = false;
        Player[A].AquaticSwim = false;
        Player[A].WetFrame = false;
        Player[A].Slide = false;
        Player[A].Vine = 0;
        Player[A].VineNPC = 0;
        Player[A].VineBGO = 0;
        Player[A].Fairy = false;
        Player[A].GrabSpeed = 0;
        Player[A].GrabTime = 0;
        Player[A].SwordPoke = 0;
        Player[A].FireBallCD2 = 0;
        Player[A].SpinJump = false;
        Player[A].Stoned = false;
        Player[A].Slope = 0;
        Player[A].SpinFireDir = 0;
        Player[A].SpinFrame = 0;
        Player[A].YoshiNPC = 0;
        Player[A].YoshiPlayer = 0;
        Player[A].YoshiRed = false;
        Player[A].YoshiBlue = false;
        Player[A].YoshiYellow = false;
        Player[A].YoshiBFrame = 0;
        Player[A].YoshiBFrameCount = 0;
        Player[A].YoshiTFrame = 0;
        Player[A].YoshiTFrameCount = 0;
        Player[A].CanFly = false;
        Player[A].CanFly2 = false;
        Player[A].RunCount = 0;
        Player[A].FlyCount = 0;
        Player[A].ForceHitSpot3 = false;
        Player[A].StandUp = false;
        Player[A].StandUp2 = false;
        Player[A].TailCount = 0;
        Player[A].HasKey = false;
        Player[A].TimeToLive = 0;
        Player[A].Warp = 0;
        Player[A].WarpCD = 0;
        Player[A].WarpBackward = false;
        Player[A].WarpShooted = false;
        Player[A].CanPound = false;
        Player[A].AltRunRelease = false;
        Player[A].GroundPound = false;
        Player[A].GroundPound2 = false;
        Player[A].Duck = false;
        Player[A].MountSpecial = 0;
        Player[A].YoshiTongueLength = 0;

//        Player[A].Direction = 1; // Moved to above
        Player[A].Location.SpeedX = 0;
        Player[A].Location.SpeedY = 2;
        Player[A].Frame = 1;
        Player[A].FrameCount = 0;

        // Player[A].NPCPinched = 0;
        // Player[A].Pinched1 = 0;
        // Player[A].Pinched2 = 0;
        // Player[A].Pinched3 = 0;
        // Player[A].Pinched4 = 0;
        Player[A].Pinched = PinchedInfo_t();

        Player[A].StandingOnNPC = 0;
        Player[A].StandingOnVehiclePlr = 0;
        Player[A].HoldingNPC = 0;
        Player[A].Dead = false;
        //        if(nPlay.Online && nPlay.Mode == 0)
        //        {
        //            if(nPlay.Player[A - 1].Active == false)
        //                Player[A].Dead = true;
        //        }
        Player[A].TimeToLive = 0;
        Player[A].Bumped = false;
        Player[A].Bumped2 = 0;
        // Player[A].Effect = PLREFF_NORMAL; // moved above, possibly set in start-pos code
        // Player[A].Effect2 = 0;
        Player[A].Immune = 0;
        Player[A].Immune2 = false;

        // new code to prevent char5 from attacking at spawn (thanks to Sapphire Bullet Bill for the suggestion)
        if(!LevelEditor && BattleMode && numPlayers > 2)
            Player[A].Immune = 90;

        Player[A].Jump = 0;
        Player[A].Frame = 1;
        Player[A].FrameCount = 0;
        Player[A].RunRelease = false;
        Player[A].FloatTime = 0;
        Player[A].CanFloat = false;
        Player[A].CurMazeZone = 0;

        if(Player[A].Character == 3)
            Player[A].CanFloat = true;

        if(Player[A].Character == 3 || Player[A].Character == 4)
        {
            if(Player[A].State == 1)
                Player[A].Hearts = 1;
            if(Player[A].State > 1 && Player[A].Hearts < 2)
                Player[A].Hearts = 2;
        }

        // legacy code for >2P, unused in modern gameplay
        if(numPlayers > 2 && !GameMenu) // find correct positions without start locations
        {
            if(GameOutro)
            {
                Player[A].Location = Player[1].Location;
                Player[A].Location.X += A * 52 - 52;
            }
            // many-player code
            else if(g_ClonedPlayerMode)
            {
                Player[A].Location = Player[1].Location;
                Player[A].Location.SpeedY = dRand() * -12 - 6;
            }
        }

        // section check
        CheckSection_Init(A); // find the section the player is in

        // Set player's direction to left automatically when a start point is located at right side of the section
        if(Player[A].Location.X + Player[A].Location.Width / 2 > level[Player[A].Section].X + (level[Player[A].Section].Width - level[Player[A].Section].X) / 2)
            Player[A].Direction = -1;

        //        if(nPlay.Online && A <= 15)
        //        {
        //            if(nPlay.Player[A - 1].Active == false && A != 1)
        //                Player[A].Dead = true;
        //        }
        SizeCheck(Player[A]);
    }
    //    if(nPlay.Online)
    //    {
    //        Netplay::sendData "1d" + (nPlay.MySlot + 1) + "|" + Player[nPlay.MySlot + 1].Character + "|" + Player[nPlay.MySlot + 1].State + LB + Netplay::PutPlayerLoc(nPlay.MySlot + 1);
    //        StartMusic Player[nPlay.MySlot + 1].Section;
    //    }
    UpdateYoshiMusic();
    if(!LevelSelect)
        SetupScreens(); // setup the screen depending on how many players there are
    setupCheckpoints(); // setup the checkpoint and restpore the player at it if needed

    // prepare vScreens for SharedScreen since UpdatePlayer happens before UpdateGraphics
    for(int screen_i = 0; screen_i < c_screenCount; screen_i++)
    {
        Screen_t& screen = Screens[screen_i];
        if(screen.Type == ScreenTypes::SharedScreen)
        {
            // CenterScreens(screen);
            GetvScreenAuto(screen.vScreen(1));
        }
    }
}

void PlayerHurt(const int A)
{
    if(GodMode || GameOutro || BattleOutro > 0)
        return;

    auto &p = Player[A];
    Location_t tempLocation;
    int B = 0;

    if(InvincibilityTime && !p.Pinched.Moving)
        return;

    if(p.Dead || p.TimeToLive > 0 || p.Stoned || p.Immune > 0 || p.Effect > 0)
        return;

//    if(nPlay.Online) // netplay stuffs
//    {
//        if(nPlay.Allow == false && A != nPlay.MySlot + 1)
//            return;
//        if(A == nPlay.MySlot + 1)
//            Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1a" + std::to_string(A) + "|" + p.State + LB;
//    }
    p.DoubleJump = false;
    p.GrabSpeed = 0;
    p.GrabTime = 0;
    p.Slide = false;
    p.SlideKill = false;
    p.CanFly = false;
    p.CanFly2 = false;
    p.FlyCount = 0;
    p.RunCount = 0;
    p.Rolling = false;

    if(p.Fairy)
    {
        PlaySoundSpatial(SFX_HeroFairy, p.Location);
        p.Immune = 30;
        p.Effect = PLREFF_WAITING;
        p.Effect2 = 4;
        p.Fairy = false;
        p.FairyTime = 0;

        // FIXME: Here is a possible vanilla bug: B is always 0 even at original code
        SizeCheck(Player[B]);

        NewEffect(EFFID_SMOKE_S5, p.Location);
        if(p.Character == 5)
        {
            p.FrameCount = -10;
            p.Location.SpeedX = 3 * -p.Direction;
            p.Location.SpeedY = -7.01_n;
            p.StandingOnNPC = 0;
            p.FireBallCD = 20;
            PlaySoundSpatial(SFX_HeroHurt, p.Location);
        }
        return;
    }

    if(GameMenu)
    {
        if(p.State > 1)
            p.Hearts = 2;
        else
            p.Hearts = 1;
    }

    if(NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL)
        p.HoldingNPC = 0;

    if(LevelMacro == LEVELMACRO_OFF)
    {
        if(p.Immune == 0)
        {
            Controls::Rumble(A, 250, 0.5);

            if(p.Mount == 1)
            {
                p.Mount = 0;
                PlaySoundSpatial(SFX_Boot, p.Location);
                UnDuck(Player[A]);
                tempLocation = p.Location;
                tempLocation.SpeedX = 5 * -p.Direction;
                if(p.MountType == 1)
                    NewEffect(EFFID_GRN_BOOT_DIE, tempLocation);
                else if(p.MountType == 2)
                    NewEffect(EFFID_RED_BOOT_DIE, tempLocation);
                else
                    NewEffect(EFFID_BLU_BOOT_DIE, tempLocation);
                p.Location.set_height_floor(Physics.PlayerHeight[p.Character][p.State]);
                p.Immune = 150;
                p.Immune2 = true;
            }
            else if(p.Mount == 3)
            {
                UnDuck(Player[A]);
                PlaySoundSpatial(SFX_PetHurt, p.Location);
                p.Immune = 100;
                p.Immune2 = true;
                p.CanJump = false;
                p.Location.SpeedX = 0;
                if(p.Location.SpeedY > Physics.PlayerJumpVelocity)
                    p.Location.SpeedY = Physics.PlayerJumpVelocity;
                p.Jump = 0;
                p.Mount = 0;
                p.YoshiBlue = false;
                p.YoshiRed = false;
                p.GroundPound = false;
                p.GroundPound2 = false;
                p.YoshiYellow = false;
                p.Dismount = p.Immune;
                UpdateYoshiMusic();

                // was previously after numNPCs++ but will not touch numNPCs because p.YoshiRed was just set to false
                if(p.YoshiNPC > 0 || p.YoshiPlayer > 0)
                    YoshiSpit(A);

                s_makePetMount(A);

                NPC[numNPCs].Special = 1;
                NPC[numNPCs].Location.Y -= 1;

                p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            }
            else
            {
                if(p.Character == 3 || p.Character == 4)
                {
                    p.Hearts -= 1;

                    // 2 hearts left -> lose powerup, drop to big
                    if(p.Hearts == 2 && p.State != PLR_STATE_SMALL)
                    {
                        // TODO: State-dependent moment
                        if(p.State == PLR_STATE_FIRE || p.State == PLR_STATE_ICE || p.State == PLR_STATE_CYCLONE)
                        {
                            p.Effect = (PlayerEffect)(PLREFF_STATE_TO_BIG + p.State);
                            p.Effect2 = 0;
                            PlaySoundSpatial(SFX_PlayerShrink, p.Location);
                        }
                        else
                        {
                            p.State = PLR_STATE_BIG;
                            p.Immune = 150;
                            p.Immune2 = true;
                            PlaySoundSpatial(SFX_PlayerHit, p.Location);
                        }

                        return;
                    }
                    // 0 hearts left -> kill the player
                    else if(p.Hearts == 0)
                        p.State = 1;
                    // 1 heart (or invalid state) -> shrink to small
                    else
                        p.State = 2;
                }
                else if(p.Character == 5)
                {
                    p.Hearts -= 1;
                    if(p.Hearts > 0)
                    {
                        p.State = (p.Hearts == 1) ? 1 : 2;
//                        if(p.Hearts == 1)
//                            p.State = 1;
//                        else
//                            p.State = 2;
                        // Always false because of previous setup
//                        if(p.State < 1)
//                            p.State = 1;
                        if(p.Mount == 0)
                        {
                            p.FrameCount = -10;
                            p.Location.SpeedX = 3 * -p.Direction;
                            p.Location.SpeedY = -7.01_n;
                            p.FireBallCD = 30;
                            p.SwordPoke = 0;
                        }
                        p.Immune = 150;
                        p.Immune2 = true;
                        PlaySoundSpatial(SFX_HeroHurt, p.Location);
                        return;
                    }
                }

                if(p.State > 1)
                {
                    PlaySoundSpatial(SFX_PlayerShrink, p.Location);
                    p.StateNPC = NPCID_NULL;
                    p.Effect = PLREFF_TURN_SMALL;

                    if(p.State > 2 && g_config.alt_powerdown)
                    {
                        p.Effect = (PlayerEffect)(PLREFF_STATE_TO_BIG + p.State);
                        p.Effect2 = 0;
                    }
                }
                else
                {
                    PlayerDead(A);
#if 0
                    // dead code, p.Mount and p.HoldingNPC are guaranteed to be set to 0 in PlayerDead
                    p.HoldingNPC = 0;
                    if(p.Mount == 2)
                    {
                        p.Mount = 0;
                        numNPCs++;
                        NPC[numNPCs].Direction = p.Direction;
                        if(NPC[numNPCs].Direction == 1)
                            NPC[numNPCs].Frame = 4;
                        NPC[numNPCs].Frame += SpecialFrame[2];
                        NPC[numNPCs].Active = true;
                        NPC[numNPCs].TimeLeft = 100;
                        NPC[numNPCs].Type = NPCID_VEHICLE;
                        NPC[numNPCs].Location.Height = 128;
                        NPC[numNPCs].Location.Width = 128;
                        NPC[numNPCs].Location.Y = static_cast<int>(floor(static_cast<double>(p.Location.Y)));
                        NPC[numNPCs].Location.X = static_cast<int>(floor(static_cast<double>(p.Location.X)));
                        NPC[numNPCs].Location.SpeedY = 0;
                        NPC[numNPCs].Location.SpeedX = 0;
                        NPC[numNPCs].CantHurt = 10;
                        NPC[numNPCs].CantHurtPlayer = A;
                        syncLayers_NPC(numNPCs);

                        p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                        p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                        p.Location.X += 64 - Physics.PlayerWidth[p.Character][p.State] / 2;
                        p.ForceHitSpot3 = true;
                        p.Location.Y = NPC[numNPCs].Location.Y - p.Location.Height;

                        for(int B : NPCQueues::Active.no_change)
                        {
                            if(NPC[B].vehiclePlr == A)
                            {
                                NPC[B].vehiclePlr = 0;
                                NPC[B].Location.SpeedY = 0;
                                NPC[B].Location.Y = NPC[numNPCs].Location.Y - 0.1 - NPC[B].vehicleYOffset;
                                treeNPCUpdate(B);
                                if(NPC[B].tempBlock > 0)
                                    treeNPCSplitTempBlock(B);

                                NPC[B].vehicleYOffset = 0;
                                if(NPC[B].Type == NPCID_CANNONITEM)
                                    NPC[B].Special = 0;
                                if(NPC[B].Type == NPCID_TOOTHY)
                                {
                                    NPC[B].Killed = 9;
                                    NPCQueues::Killed.push_back(B);
                                    NPC[B].Special = 0;
                                }
                                else if(NPC[B].Type == NPCID_TOOTHYPIPE)
                                    NPC[B].Special = 0;
                            }
                        }
                    }
#endif
                }
            }
        }
    }
}

void PlayerDeathEffect(int A)
{
    if(Player[A].Character == 1)
        NewEffect(EFFID_CHAR1_DIE, Player[A].Location, 1, ShadowMode);
    else if(Player[A].Character == 2)
        NewEffect(EFFID_CHAR2_DIE, Player[A].Location, 1, ShadowMode);
    else if(Player[A].Character == 3)
        NewEffect(EFFID_CHAR3_DIE, Player[A].Location, 1, ShadowMode);
    else if(Player[A].Character == 4)
        NewEffect(EFFID_CHAR4_DIE, Player[A].Location, 1, ShadowMode);
    else if(Player[A].Character == 5)
    {
        NewEffect(EFFID_CHAR5_DIE, Player[A].Location, Player[A].Direction, ShadowMode);
        Effect[numEffects].Location.SpeedX = 2 * -Player[A].Direction;
    }
}

void PlayerDead(int A)
{
    Controls::Rumble(A, 400, 0.8f);

    g_curLevelMedals.on_any_death();

    bool tempBool = false;
    int B = 0;
    auto &p = Player[A];

//    if(nPlay.Online) // netplay stuffs
//    {
//        if(nPlay.Allow == false && A != nPlay.MySlot + 1)
//            return;
//        if(A == nPlay.MySlot + 1)
//            Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1b" + std::to_string(A) + LB;
//    }

    if(p.Character == 5)
        PlaySoundSpatial(SFX_HeroDied, p.Location);
    else
    {
        if(BattleMode)
            PlaySoundSpatial(SFX_PlayerDied2, p.Location);
        else if(g_ClonedPlayerMode)
        {
            for(B = 1; B <= numPlayers; B++)
            {
                if(!Player[B].Dead && Player[B].TimeToLive == 0 && A != B)
                    tempBool = true;
            }
            if(tempBool)
                PlaySoundSpatial(SFX_PlayerDied2, p.Location);
            else
                PlaySoundSpatial(SFX_PlayerDied, p.Location);
        }
        else
            PlaySoundSpatial(SFX_PlayerDied, p.Location);
    }

    if(p.YoshiNPC > 0 || p.YoshiPlayer > 0)
    {
        YoshiSpit(A);
    }

    p.Location.SpeedX = 0;
    p.Location.SpeedY = 0;
    p.Hearts = 0;
    p.Wet = 0;
    p.WetFrame = false;
    p.Quicksand = 0;
    p.Effect = PLREFF_NORMAL;
    p.Effect2 = 0;
    p.Fairy = false;

    if(p.Mount == 2)
    {
        s_makeVehicleMount(A);

        p.Mount = 0;
        p.Location.Y -= 32;
        p.Location.Height = 32;
        SizeCheck(Player[A]);
    }

    p.CurMazeZone = 0;
    p.Mount = 0;
    p.State = 1;
    p.HoldingNPC = 0;
    p.GroundPound = false;
    p.GroundPound2 = false;

    PlayerDeathEffect(A);

    p.TimeToLive = 1;

    if(CheckLiving() == 0 && !GameMenu && !BattleMode)
    {
        g_curLevelMedals.on_all_dead();
        StopMusic();
        FreezeNPCs = false;
    }

    if(A == SingleCoop)
        SwapCoop();
}

void KillPlayer(const int A)
{
    auto &p = Player[A];

    p.Location.SpeedX = 0;
    p.Location.SpeedY = 0;
    p.State = 1;
    p.Stoned = false;

    // p.Pinched1 = 0;
    // p.Pinched2 = 0;
    // p.Pinched3 = 0;
    // p.Pinched4 = 0;
    // p.NPCPinched = 0;
    p.Pinched = PinchedInfo_t();

    p.TimeToLive = 0;
    p.Direction = 1;
    p.Frame = 1;
    p.Mount = 0;
    p.Dead = true;
    p.Location.X = 0;
    p.Location.Y = 0;
    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];

    if(p.HoldingNPC > 0)
    {
        if(NPC[p.HoldingNPC].Type == NPCID_VINE_BUG)
            NPC[p.HoldingNPC].Projectile = true;
    }

    p.HoldingNPC = 0;
    if(BattleMode)
    {
        if(BattleLives[A] <= 0)
        {
            int other_alive = 0;
            bool two_others_alive = false;
            for(int o_A = 1; o_A <= numPlayers; o_A++)
            {
                if(o_A == A)
                    continue;

                if(!Player[o_A].Dead || BattleLives[o_A] > 0)
                {
                    if(other_alive != 0)
                    {
                        two_others_alive = true;
                        break;
                    }
                    else
                        other_alive = o_A;
                }
            }

            if(!two_others_alive && BattleOutro == 0)
            {
                BattleOutro = 1;
                PlaySound(SFX_GotStar);
                StopMusic();
            }

            if(!two_others_alive && BattleWinner == 0)
                BattleWinner = other_alive;
        }

        if(A == BattleWinner || (BattleWinner == 0 && BattleLives[A] > 0))
        {
            if(BattleLives[A] > 0)
                BattleLives[A] -= 1;

            PlaySoundSpatial(SFX_Transform, p.Location);
            p.Frame = 1;
            p.Location.SpeedX = 0;
            p.Location.SpeedY = 0;
            p.Mount = 0;
            p.State = 2;
            p.Hearts = 2;
            p.Effect = PLREFF_NORMAL;

            p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
            p.Location.Height = Physics.PlayerHeight[p.Character][p.State];

            // eventually, check for valid starts
            constexpr int valid_start_count = 2;
            int use_start = (A - 1) % valid_start_count + 1;

            p.Location.X = PlayerStart[use_start].X + (PlayerStart[use_start].Width - p.Location.Width) / 2;
            p.Location.Y = PlayerStart[use_start].Y + PlayerStart[use_start].Height - p.Location.Height;
            p.Direction = 1;

            p.Dead = false;
            CheckSection(A);
            if(p.Location.X + p.Location.Width / 2 > level[p.Section].X + (level[p.Section].Width - level[p.Section].X) / 2)
                p.Direction = -1;
            p.Immune = 300;
            NewEffect(EFFID_SMOKE_S4, p.Location);
            UpdateYoshiMusic();
        }
    }
}

int CheckDead()
{
    int A = 0;
    for(A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Dead && Player[A].State > 0 && Player[A].Character > 0)
        {
//            if(nPlay.Online == false)
            return A;
//            else
//            {
//                if(nPlay.Player[A - 1].Active || A == 1)
//                    return A;
//            }
        }
    }
    return 0;
}

int CheckLiving()
{
    int A = 0;
    for(A = 1; A <= numPlayers; A++)
    {
        if(!Player[A].Dead && Player[A].TimeToLive == 0)
            return A;
    }
    return 0;
}

int CheckNearestLiving(const int A)
{
    const Player_t& p = Player[A];
    const Screen_t& screen = ScreenByPlayer(A);

    int   closest      = 0;
    num_t closest_dist = 0;

    // first, look on same screen
    for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
    {
        int o_A = screen.players[plr_i];
        const Player_t& o_p = Player[o_A];

        if(o_A != A && !o_p.Dead && o_p.TimeToLive == 0 && o_A != p.YoshiPlayer)
        {
            num_t dist = num_t::dist2(o_p.Location.X - p.Location.X, o_p.Location.Y - p.Location.Y);

            if(closest == 0 || closest_dist > dist)
            {
                closest = o_A;
                closest_dist = dist;
            }
        }
    }

    if(closest)
        return closest;

    // next, look at all players
    for(int o_A = 1; o_A <= numPlayers; o_A++)
    {
        const Player_t& o_p = Player[o_A];

        if(o_A != A && !o_p.Dead && o_p.TimeToLive == 0 && o_A != p.YoshiPlayer)
        {
            num_t dist = num_t::dist2(o_p.Location.X - p.Location.X, o_p.Location.Y - p.Location.Y);

            if(closest == 0 || closest_dist > dist)
            {
                closest = o_A;
                closest_dist = dist;
            }
        }
    }

    return closest;
}

int LivingPlayersLeft()
{
    int ret = 0;

    for(int A = 1; A <= numPlayers; A++)
    {
        if(!Player[A].Dead)
            ret++;
    }

    return ret;
}

bool LivingPlayers() // Checks if anybody alive
{
    bool ret = false;

    for(int A = 1; A <= numPlayers; A++)
    {
        if(!Player[A].Dead)
        {
            ret = true;
            break;
        }
    }

    return ret;
}

void ProcessLastDead()
{
    if(!g_config.EnableInterLevelFade || BattleMode)
        return;

    if(LivingPlayersLeft() <= 1)
    {
        FadeOutMusic(500);
        g_levelScreenFader.setupFader(3, 0, 65, ScreenFader::S_FADE);
    }
}

static void s_gameOver()
{
    Lives = 3;
    Coins = 0;
    Score = 0;
    SaveGame();
    LevelMacro = LEVELMACRO_OFF;
    LevelMacroCounter = 0;
    ResetSoundFX();
    ClearLevel();
    LevelSelect = true;
    GameMenu = true;
    MenuMode = MENU_INTRO;
    MenuCursor = 0;
#ifdef ENABLE_ANTICHEAT_TRAP
    CheaterMustDie = false;
#endif
}

void EveryonesDead()
{
//    int A = 0; // UNUSED
    if(BattleMode)
        return;

    StopMusic();
    LevelMacro = LEVELMACRO_OFF;
    FreezeNPCs = false;

    // Quit to world map if died on sub-hub
    if(!NoMap && IsHubLevel && !FileRecentSubHubLevel.empty())
    {
        FileRecentSubHubLevel.clear();
        ReturnWarp = 0;
        ReturnWarpSaved = 0;
    }

    // Ensure everything is clear
    GraphicsClearScreen();

// Play fade effect instead of wait (see ProcessLastDead() above)
    if(!g_config.EnableInterLevelFade)
    {
//    if(MagicHand)
//        BitBlt frmLevelWindow::vScreen[1].hdc, 0, 0, frmLevelWindow::vScreen[1].ScaleWidth, frmLevelWindow::vScreen[1].ScaleHeight, 0, 0, 0, vbWhiteness;
        if(!g_config.unlimited_framerate)
            PGE_Delay(500);
    }

#ifdef ENABLE_ANTICHEAT_TRAP
    if(CheaterMustDie)
    {
        s_gameOver();
        return;
    }
#endif

    if(g_ClonedPlayerMode)
        gDeathCounter.MarkDeath();

    if(g_config.modern_lives_system)
    {
        g_100s--;

        if(g_100s < 0)
            Score = 0;
    }
    else
        Lives--;

    if(g_config.modern_lives_system || Lives >= 0)
    {
        LevelMacro = LEVELMACRO_OFF;
        LevelMacroCounter = 0;

        ResetSoundFX();
        ClearLevel();

        if(RestartLevel)
        {
            OpenLevel(FullFileName);
            LevelSelect = false;
            LevelRestartRequested = true;
//            SetupPlayers();
        }
        else
            LevelSelect = true;
    }
    else // no more lives
    {
// GAME OVER
        s_gameOver();
    }

    XEvents::doEvents();
}

void UnDuck(Player_t &p)
{
    if(p.AquaticSwim)
        return;

    if(p.Rolling)
    {
        p.Rolling = false;
        p.Slide = false;
    }

    if(p.Duck && p.GrabTime == 0) // Player stands up
    {
        if(p.Location.SpeedY != 0) // Fixes a block collision bug
            p.StandUp = true;
        p.StandUp2 = true;
        p.Frame = 1;
        p.FrameCount = 0;
        p.Duck = false;

        if(p.Mount == 3)
        {
            p.Location.set_height_floor((p.State == 1) ? 54 : 60);
        }
        else
        {
            if(p.State == 1 && p.Mount == 1)
            {
                p.Location.Height = Physics.PlayerHeight[1][2];
                p.Location.Y += -Physics.PlayerHeight[1][2] + Physics.PlayerDuckHeight[1][2];
            }
            else
            {
                p.Location.set_height_floor(Physics.PlayerHeight[p.Character][p.State]);
            }
        }

        SizeCheck(p);
    }
}

void CheckSection(const int A)
{
    // finds out what section the player is in and handles the music for section changes
    if(LevelSelect)
        return;

    auto &p = Player[A];

    int oldSection = p.Section;
    int foundSection_loop = 0;

    for(int B = 0; B < numSections; B++)
    {
        if(p.Location.X + p.Location.Width >= level[B].X)
        {
            if(p.Location.X <= level[B].Width)
            {
                if(p.Location.Y + p.Location.Height >= level[B].Y)
                {
                    if(p.Location.Y <= level[B].Height)
                    {
                        foundSection_loop = 1;

                        if(oldSection != B /*&& (nPlay.Online == false || nPlay.MySlot == A - 1)*/)
                        {
                            p.Section = B;

                            // there was a music update here that used a less strict criterion of never interrupting music tracks below 0

                            break;
                        }
                    }
                }
            }
        }
    }

    if(foundSection_loop == 0)
    {
        for(int B = 0; B < numSections; B++)
        {
            if(p.Location.X + p.Location.Width >= LevelREAL[B].X)
            {
                if(p.Location.X <= LevelREAL[B].Width)
                {
                    if(p.Location.Y + p.Location.Height >= LevelREAL[B].Y)
                    {
                        if(p.Location.Y <= LevelREAL[B].Height)
                        {
                            p.Section = B;
                            foundSection_loop = 2;

                            // there was a music update here that used the stricter criterion of never interrupting music tracks below 0, or 6 or 15

                            // move player to a different player in the section
                            for(int C = 1; C <= numPlayers; C++)
                            {
                                if(Player[C].Section == p.Section && C != A)
                                {
                                    p.Location.X = Player[C].Location.X + (Player[C].Location.Width - p.Location.Width) / 2;
                                    p.Location.Y = Player[C].Location.Y + Player[C].Location.Height - p.Location.Height - 0.01_n;
                                    break;
                                }
                            }

                            break;
                        }
                    }
                }
            }
        }
    }


    // audiovisual updates if player's section changed (ignore if menu is active or player is offscreen)
    if(p.Section != oldSection && !GameMenu && (&ScreenByPlayer(A) == l_screen))
    {
        int B = p.Section;

        UpdateSoundFX(B);

        bool boss_track = (curMusic == 6 || curMusic == 15);

        if(curMusic < 0)
        {
            // don't interrupt switch music
        }
        else if(foundSection_loop == 2 && boss_track)
        {
            // don't interrupt boss track (this condition only existed in the second loop above)
        }
        // do change music -- normal music change
        else if(curMusic != bgMusic[B] || (delayMusicIsSet() && bgMusic[B] != 24))
        {
            StartMusic(B);
        }
        // custom music change
        else if(bgMusic[B] == 24)
        {
            if(oldSection >= 0 && CustomMusic[oldSection] != CustomMusic[p.Section])
                StartMusic(B);
        }

        ClearBuffer = true;

#ifdef PGE_MIN_PORT
        // unload old background when changing sections (this helps prevent texture memory exhaustion)
        D_pLogDebug("Check for background clean-up: oldSection=%d, B=%d", oldSection, B);
        if(numPlayers == 1 && oldSection >= 0 && Background2[oldSection] != Background2[B])
        {
            D_pLogDebug("Trying to unload background texture at old section %d", oldSection);
            // (note: GFXBackground2 doesn't always line up exactly with Background2, but this solution still helps)
            XRender::unloadTexture(GFXBackground2[Background2[oldSection]]);
        }
#endif
    }
}

// routine moved from SetupPlayers and now used at several other call sites during level start
void CheckSection_Init(const int A)
{
    Player[A].Section = -1;

    CheckSection(A);

    if(Player[A].Section == -1)
    {
        Player[A].Section = 0;
        // SetupPlayers originally called CheckSection again here but the result could not have been different
    }
}

static void s_makeDust(Player_t& p, int dir_offset, Location_t& tempLocation)
{
    if(p.SlideCounter <= 0)
    {
        tempLocation.Y = p.Location.Y + p.Location.Height - 5;
        tempLocation.X = p.Location.X + p.Location.Width / 2 - 4 + dir_offset * p.Direction;

        int add_slide = 2;
        EFFID effid = EFFID_SKID_DUST;
        if(p.State == PLR_STATE_POLAR && (p.Slippy || p.SlippyWall) && !p.Mount)
        {
            effid = EFFID_SPARKLE;
            add_slide = 12;
            tempLocation.Y -= 4;
        }

        NewEffect(effid, tempLocation, 1, ShadowMode);

        p.SlideCounter = 2 + iRand_round(add_slide);
    }
}

void PlayerFrame(const int A)
{
    PlayerFrame(Player[A]);
}

void PlayerFrame(Player_t &p)
{
// updates the players GFX
    Location_t tempLocation;
//    auto &p = Player[A];

// cause the flicker when he is immune
    if(p.Effect != PLREFF_NO_COLLIDE)
    {
        if(p.Immune > 0)
        {
            p.Immune -= 1;
            if(p.Immune % 3 == 0)
            {
                p.Immune2 = !p.Immune2;
//                if(!p.Immune2)
//                    p.Immune2 = true;
//                else
//                    p.Immune2 = false;
            }
        }
        else
            p.Immune2 = false;
    }

    if(p.State == PLR_STATE_POLAR && !p.Mount && p.Slippy && p.Location.SpeedX)
        s_makeDust(p, 0, tempLocation);

    if(p.State == PLR_STATE_CYCLONE && !p.DoubleJump && (p.Jump || (p.Controls.Down && p.Location.SpeedY > Physics.PlayerTerminalVelocity * 0.9_n)))
        s_makeDust(p, 2, tempLocation);

// find frames for link
    if(p.Character == 5)
    {
        LinkFrame(p);
        return;
    }

// for the grab animation when picking something up from the top
    if(p.GrabTime > 0)
    {
        p.FrameCount += 1;
        if(p.FrameCount <= 6)
            p.Frame = 23;
        else if(p.FrameCount <= 12)
            p.Frame = 22;
        else
        {
            p.FrameCount = 0;
            p.Frame = 23;
        }
        return;
    }

    // Rolling frames
    if(p.Rolling)
    {
        if(p.State == PLR_STATE_SHELL)
        {
            p.FrameCount = (p.FrameCount + 1) & 15;
            p.Frame = 16 + p.FrameCount / 4;
        }
        else if(p.State == PLR_STATE_POLAR)
        {
            p.Frame = 14;
        }
        return;
    }

    // Aquatic frames
    if(p.AquaticSwim)
    {
        if(p.SwimCount)
        {
            p.FrameCount = (p.SwimCount & 15) * 4;

            if(p.FrameCount == 60)
            {
                if(p.SwimCount / 16 == MAZE_DIR_UP)
                    p.Frame = 40;
                else if(p.SwimCount / 16 == MAZE_DIR_DOWN)
                    p.Frame = 19;
                else
                    p.Frame = 16;
            }
        }
        else
        {
            p.FrameCount -= (p.Controls.Run) ? 2 : 1;

            if(p.FrameCount < 0)
            {
                p.FrameCount = 0;

                if(p.Controls.Left || p.Controls.Right || p.Controls.Up || p.Controls.Down)
                {
                    p.FrameCount = 60;

                    if(p.Controls.Left || p.Controls.Right)
                        p.Frame = 16;
                    else if(p.Controls.Up)
                        p.Frame = 40;
                    else // if(p.Controls.Down)
                        p.Frame = 19;
                }
            }
        }

        if(p.FrameCount == 32 || p.FrameCount == 48)
            p.Frame += 1;

        return;
    }

// statue frames
    if(p.Stoned)
    {
        p.Frame = 0;
        p.FrameCount = 0;
        if(p.Location.SpeedX != 0)
        {
            if(p.Location.SpeedY == 0 || p.Slope > 0 || p.StandingOnNPC != 0)
            {
                if(p.SlideCounter <= 0)
                {
                    p.SlideCounter = 2 + iRand_round(2); // p(2) = 25%, p(3) = 50%, p(4) = 25%
                    tempLocation.Y = p.Location.Y + p.Location.Height - 5;
                    tempLocation.X = p.Location.X + p.Location.Width / 2 - 4;
                    NewEffect(EFFID_SKID_DUST, tempLocation, 1, ShadowMode);
                }
            }
        }
        return;
    }

// sliding frames
    if(p.Slide && (p.Character == 1 || p.Character == 2))
    {
        if(p.Location.SpeedX != 0)
        {
            if(p.Location.SpeedY == 0 || p.Slope > 0 || p.StandingOnNPC != 0)
            {
                if(p.SlideCounter <= 0 && p.SlideKill)
                {
                    p.SlideCounter = 2 + iRand_round(2);
                    tempLocation.Y = p.Location.Y + p.Location.Height - 4;
                    if(p.Location.SpeedX < 0)
                        tempLocation.X = p.Location.X + p.Location.Width / 2 - 4 + 6;
                    else
                        tempLocation.X = p.Location.X + p.Location.Width / 2 - 4 - 6;
                    NewEffect(EFFID_SKID_DUST, tempLocation, 1, ShadowMode);
                }
            }
        }
        p.Frame = 24;
        return;
    }

// climbing a vine/ladder
    if(p.Vine > 0)
    {
        bool doesPlayerMoves = false;

        if(g_config.fix_climb_bgo_speed_adding && p.VineBGO > 0)
        {
            const Layer_t& layer = Layer[Background[p.VineBGO].Layer];

            doesPlayerMoves = !num_t::fEqual_d(p.Location.SpeedX, (num_t)layer.ApplySpeedX) ||
                               p.Location.SpeedY < (num_t)layer.ApplySpeedY - 0.1_n;
        }
        else
        {
            doesPlayerMoves = !num_t::fEqual_d(p.Location.SpeedX, NPC[p.VineNPC].Location.SpeedX) ||
                               p.Location.SpeedY < NPC[p.VineNPC].Location.SpeedY - 0.1_n;
        }

        if(doesPlayerMoves) // Or .Location.SpeedY > 0.1 Then
        {
            p.FrameCount += 1;
            if(p.FrameCount >= 8)
            {
                p.Frame += 1;
                p.FrameCount = 0;
            }
            PlaySoundSpatial(SFX_Climbing, p.Location);
        }

        if(p.Frame < 25)
            p.Frame = 26;
        else if(p.Frame > 26)
            p.Frame = 25;

        return;
    }

// this finds the players direction
    if(!LevelSelect && p.Effect != PLREFF_WARP_PIPE)
    {
        if(p.JumpOffWall)
        {
            if(p.Location.SpeedX > 0)
                p.Direction = 1;
            else
                p.Direction = -1;
        }
        else if(p.State == PLR_STATE_AQUATIC && !p.Mount && p.MountSpecial)
        {
            // in the middle of a hop, don't change direction
        }
        else if(!(p.Mount == 3 && p.MountSpecial > 0))
        {
            if(p.Controls.Left)
                p.Direction = -1;
            if(p.Controls.Right)
                p.Direction = 1;
        }
    }

    if(p.Driving && p.StandingOnNPC > 0)
        p.Direction = NPC[p.StandingOnNPC].DefaultDirection;

    if(p.Fairy)
        return;

// ducking and holding
    if(p.HoldingNPC > 0 && p.Duck)
    {
        p.Frame = 27;
        return;
    }

    p.MountOffsetY = 0;

    // cyclone frames
    if(p.SpinJump && p.State == PLR_STATE_CYCLONE && !p.HoldingNPC)
    {
        if(p.Location.SpeedY > 0)
            p.SpinFrame += 1;
        else
            p.SpinFrame += 2;

        p.SpinFrame = unsigned(p.SpinFrame) % 32;

        if(p.SpinFrame < 16)
            p.Direction = 1;
        else
            p.Direction = -1;

        p.Frame = 16 + p.SpinFrame / 8;
        if(p.Character == 4)
        {
            if(p.Frame == 17)
                p.Frame = 18;
            else if(p.Frame == 19)
                p.Frame = 16;
        }
        else
        {
            if(p.Frame == 19)
                p.Frame = 17;
        }
    }
// for the spinjump/shellsurf
    else if((p.SpinJump || p.ShellSurf) && p.Mount == 0)
    {
        if(p.SpinFrame < 4 || p.SpinFrame >= 9)
            p.Direction = -1;
        else
            p.Direction = 1;
        if(p.ShellSurf)
        {
            if(NPC[p.StandingOnNPC].Location.SpeedX > 0)
                p.Direction = -p.Direction;
        }
        p.SpinFrame += 1;
        if(p.SpinFrame < 0)
            p.SpinFrame = 14;
        if(p.SpinFrame < 3)
        {
            p.Frame = 1;
            if(p.HoldingNPC > 0)
            {
                if(p.State == 1)
                    p.Frame = 5;
                else
                    p.Frame = 8;
            }
            if(p.State == 4 || p.State == 5)
                p.Frame = 12;
        }
        else if(p.SpinFrame < 6)
            p.Frame = 13;
        else if(p.SpinFrame < 9)
        {
            p.Frame = 1;
            if(p.HoldingNPC > 0)
            {
                if(p.State == 1)
                    p.Frame = 5;
                else
                    p.Frame = 8;
            }
            if(p.State == 4 || p.State == 5)
                p.Frame = 12;
        }
        else if(p.SpinFrame < 12 - 1)
            p.Frame = 15;
        else
        {
            p.Frame = 15;
            p.SpinFrame = -1;
        }
    }
    else
    {
        bool grounded = (p.Location.SpeedY == 0 || p.StandingOnNPC != 0 || p.Slope > 0);
        bool wetframe = p.WetFrame;

        if(p.CurMazeZone)
        {
            grounded = false;

            if(p.State != PLR_STATE_POLAR && p.State != PLR_STATE_AQUATIC)
                wetframe = true;
        }

        if(p.State == 1 && (p.Character == 1 || p.Character == 2)) // Small Mario & Luigi
        {
            if(p.HoldingNPC == 0) // not holding anything
            {
                if(wetframe && !grounded && !p.Duck && p.Quicksand == 0) // swimming
                {
                    if(p.CurMazeZone)
                        p.Frame = 40;
                    else if(p.Location.SpeedY < 0 || p.Frame == 42 || p.Frame == 43)
                    {
                        if(p.Frame != 40 && p.Frame != 42 && p.Frame != 43)
                            p.FrameCount = 6;

                        p.FrameCount += 1;

                        if(p.FrameCount < 6)
                            p.Frame = 40;
                        else if(p.FrameCount < 12)
                            p.Frame = 42;
                        else if(p.FrameCount < 18)
                            p.Frame = 43;
                        else
                        {
                            p.Frame = 43;
                            p.FrameCount = 0;
                        }
                    }
                    else
                    {
                        p.FrameCount += 1;

                        if(p.FrameCount < 10)
                            p.Frame = 40;
                        else if(p.FrameCount < 20)
                            p.Frame = 41;
                        else
                        {
                            p.Frame = 41;
                            p.FrameCount = 0;
                        }
                    }
                }
                else // not swimming
                {
                    if(grounded || (p.Location.SpeedY > 0 && p.Quicksand > 0))
                    {
                        if(p.Location.SpeedX > 0 && (p.Controls.Left || (p.Direction == -1 && p.Bumped)) && p.Effect == PLREFF_NORMAL && p.Quicksand == 0)
                        {
                            if(!LevelSelect)
                            {
                                if(p.Mount != 2 && !wetframe && !p.Duck)
                                {
                                    PlaySoundSpatial(SFX_Skid, p.Location);
                                    s_makeDust(p, -8, tempLocation);
                                }

                                p.Frame = 4;
                            }
                        }
                        else if(p.Location.SpeedX < 0 && (p.Controls.Right || (p.Direction == 1 && p.Bumped)) && p.Effect == PLREFF_NORMAL && p.Quicksand == 0)
                        {
                            if(!LevelSelect)
                            {
                                if(p.Mount != 2 && !wetframe && !p.Duck)
                                {
                                    PlaySoundSpatial(SFX_Skid, p.Location);
                                    s_makeDust(p, -8, tempLocation);
                                }

                                p.Frame = 4;
                            }
                        }
                        else
                        {
                            if(p.Location.SpeedX != 0 && !(p.Slippy && !p.Controls.Left && !p.Controls.Right && p.State != PLR_STATE_POLAR))
                            {
                                p.FrameCount += 1;

                                if(p.Location.SpeedX > Physics.PlayerWalkSpeed - 1.5_n || p.Location.SpeedX < -Physics.PlayerWalkSpeed + 1.5_n)
                                    p.FrameCount += 1;

                                if(p.Location.SpeedX > Physics.PlayerWalkSpeed || p.Location.SpeedX < -Physics.PlayerWalkSpeed)
                                    p.FrameCount += 1;

                                if(p.Location.SpeedX > Physics.PlayerWalkSpeed + 1 || p.Location.SpeedX < -Physics.PlayerWalkSpeed - 1)
                                    p.FrameCount += 1;

                                if(p.Location.SpeedX > Physics.PlayerWalkSpeed + 2 || p.Location.SpeedX < -Physics.PlayerWalkSpeed - 2)
                                    p.FrameCount += 1;

                                if(p.FrameCount >= 10)
                                {
                                    p.FrameCount = 0;
                                    if(p.Frame == 1)
                                        p.Frame = 2;
                                    else
                                        p.Frame = 1;
                                }
                            }
                            else
                            {
                                p.Frame = 1;
                                p.FrameCount = 0;
                            }
                        }
                    }
                    else if(CanWallJump && (p.Pinched.Left2 == 2 || p.Pinched.Right4 == 2) && p.Mount == 0 && !p.SpinJump && !p.Duck && (!p.SlippyWall || p.State == PLR_STATE_POLAR))
                    {
                        s_makeDust(p, 8, tempLocation);
                        p.Frame = -4;
                    }
                    else
                        p.Frame = 3;
                }
            }
            else
            {
                if(grounded)
                {
                    if(p.Mount != 2 &&
                       ((p.Controls.Left && p.Location.SpeedX > 0) || (p.Controls.Right && p.Location.SpeedX < 0)) &&
                        p.Effect == PLREFF_NORMAL && !p.Duck)
                    {
                        PlaySoundSpatial(SFX_Skid, p.Location);
                        s_makeDust(p, -10, tempLocation);
                    }

                    if(p.Location.SpeedX != 0)
                    {
                        p.FrameCount += 2;

                        if(p.Location.SpeedX > Physics.PlayerWalkSpeed || p.Location.SpeedX < -Physics.PlayerWalkSpeed)
                            p.FrameCount += 3;

                        if(p.FrameCount >= 10)
                        {
                            p.FrameCount = 0;
                            if(p.Frame == 5)
                                p.Frame = 6;
                            else
                                p.Frame = 5;
                        }
                    }
                    else
                    {
                        p.Frame = 5;
                        p.FrameCount = 0;
                    }
                }
                else
                    p.Frame = 6;
            }
        }
        // TODO: state-dependent moment
        else if(p.FrameCount >= 100 && p.FrameCount <= 118 && (p.State == 3 || p.State == 6 || p.State == 7 || p.State == PLR_STATE_POLAR)) // Fire Mario and Luigi
        {
            if(p.Duck)
            {
                p.FrameCount = 0;
                p.Frame = 7;
            }
            else
            {
                if(p.FrameCount <= 106)
                {
                    p.Frame = 11;
                    if(wetframe && p.Quicksand == 0 && p.Location.SpeedY != 0 && p.Slope == 0 && p.StandingOnNPC == 0 && p.Character <= 2)
                        p.Frame = 43;
                }
                else if(p.FrameCount <= 112)
                {
                    p.Frame = 12;
                    if(wetframe && p.Quicksand == 0 && p.Location.SpeedY != 0 && p.Slope == 0 && p.StandingOnNPC == 0 && p.Character <= 2)
                        p.Frame = 44;
                }
                else
                {
                    p.Frame = 11;
                    if(wetframe && p.Quicksand == 0 && p.Location.SpeedY != 0 && p.Slope == 0 && p.StandingOnNPC == 0 && p.Character <= 2)
                        p.Frame = 43;
                }

                p.FrameCount += 1;

                if(FlameThrower)
                    p.FrameCount += 2;

                if(p.FrameCount > 118)
                    p.FrameCount = 0;
            }
        }
        else if(p.TailCount > 0) // Racoon Mario
        {
            if(p.TailCount < 5 || p.TailCount >= 20)
                p.Frame = 12;
            else if(p.TailCount < 10)
                p.Frame = 15;
            else if(p.TailCount < 15)
                p.Frame = 14;
            else
                p.Frame = 13;
        }
        else // Large Mario, Luigi, and Peach
        {
            if(p.HoldingNPC == 0 || (p.Effect == PLREFF_WARP_PIPE && p.Character >= 3))
            {
                if(wetframe && !grounded && !p.Duck && p.Quicksand == 0)
                {
                    if(p.CurMazeZone)
                    {
                        if(p.State == PLR_STATE_POLAR || p.State == PLR_STATE_AQUATIC)
                        {
                            // no normal swim frames for those states
                            p.Frame = 5;
                        }
                        else
                            p.Frame = 40;
                    }
                    else if(p.Location.SpeedY < 0 || p.Frame == 43 || p.Frame == 44)
                    {
                        if(p.Character <= 2)
                        {
                            if(p.Frame != 40 && p.Frame != 43 && p.Frame != 44)
                                p.FrameCount = 6;
                        }

                        p.FrameCount += 1;
                        if(p.FrameCount < 6)
                            p.Frame = 40;
                        else if(p.FrameCount < 12)
                            p.Frame = 43;
                        else if(p.FrameCount < 18)
                            p.Frame = 44;
                        else
                        {
                            p.Frame = 44;
                            p.FrameCount = 0;
                        }
                    }
                    else
                    {
                        p.FrameCount += 1;
                        if(p.FrameCount < 10)
                            p.Frame = 40;
                        else if(p.FrameCount < 20)
                            p.Frame = 41;
                        else if(p.FrameCount < 30)
                            p.Frame = 42;
                        else if(p.FrameCount < 40)
                            p.Frame = 41;
                        else
                        {
                            p.Frame = 41;
                            p.FrameCount = 0;
                        }
                    }

                    if(p.Character >= 3)
                    {
                        if(p.Frame == 43)
                            p.Frame = 1;
                        else if(p.Frame == 44)
                            p.Frame = 2;
                        else
                            p.Frame = 5;
                    }
                }
                else
                {
                    if(grounded || (p.Quicksand > 0 && p.Location.SpeedY > 0))
                    {
                        if(p.State == PLR_STATE_AQUATIC && !p.Bumped)
                        {
                            p.Frame = 1;
                            p.FrameCount = 0;
                        }
                        else if(p.Location.SpeedX > 0 && (p.Controls.Left || (p.Direction == -1 && p.Bumped)) &&
                           p.Effect == PLREFF_NORMAL && !p.Duck && p.Quicksand == 0)
                        {
                            if(!LevelSelect)
                            {
                                if(p.Mount != 2 && p.Wet == 0)
                                {
                                    PlaySoundSpatial(SFX_Skid, p.Location);
                                    s_makeDust(p, -6, tempLocation);
                                }
                                p.Frame = 6;
                            }
                        }
                        else if(p.Location.SpeedX < 0 && (p.Controls.Right || (p.Direction == 1 && p.Bumped)) &&
                                p.Effect == PLREFF_NORMAL && !p.Duck && p.Quicksand == 0)
                        {
                            if(!LevelSelect)
                            {
                                if(p.Mount != 2 && p.Wet == 0)
                                {
                                    PlaySoundSpatial(SFX_Skid, p.Location);
                                    s_makeDust(p, -10, tempLocation);
                                }
                                p.Frame = 6;
                            }
                        }
                        else
                        {
                            if(p.Location.SpeedX != 0 && !(p.Slippy && !p.Controls.Left && !p.Controls.Right && p.State != PLR_STATE_POLAR) && p.State != PLR_STATE_AQUATIC)
                            {
                                p.FrameCount += 1;

                                if(p.Location.SpeedX >= Physics.PlayerWalkSpeed || p.Location.SpeedX <= -Physics.PlayerWalkSpeed)
                                    p.FrameCount += 1;

                                if(p.Location.SpeedX > Physics.PlayerWalkSpeed + 1.5_n || p.Location.SpeedX < -Physics.PlayerWalkSpeed - 1.5_n)
                                    p.FrameCount += 1;

                                if(p.FrameCount >= 5 && p.FrameCount < 10)
                                {
                                    if(p.CanFly && p.Character != 3)
                                        p.Frame = 16;
                                    else
                                        p.Frame = 1;
                                }
                                else if(p.FrameCount >= 10 && p.FrameCount < 15)
                                {
                                    if(p.CanFly && p.Character != 3)
                                        p.Frame = 17;
                                    else
                                        p.Frame = 2;
                                }
                                else if(p.FrameCount >= 15 && p.FrameCount < 20)
                                {
                                    if(p.CanFly && p.Character != 3)
                                        p.Frame = 18;
                                    else
                                        p.Frame = 3;
                                }
                                else if(p.FrameCount >= 20)
                                {
                                    p.FrameCount -= 20;
                                    if(p.CanFly && p.Character != 3)
                                        p.Frame = 17;
                                    else
                                        p.Frame = 2;
                                }
                            }
                            else
                            {
                                p.Frame = 1;
                                p.FrameCount = 0;
                            }
                        }
                    }
                    else if(CanWallJump && (p.Pinched.Left2 == 2 || p.Pinched.Right4 == 2) && p.Mount == 0 && !p.SpinJump && !p.Duck && (!p.SlippyWall || p.State == PLR_STATE_POLAR))
                    {
                        s_makeDust(p, 8, tempLocation);
                        p.Frame = -6;
                    }
                    else
                    {
                        if(p.CanFly2)
                        {
                            if(!p.Controls.Jump && !p.Controls.AltJump)
                            {
                                if(p.Location.SpeedY < 0)
                                    p.Frame = 19;
                                else
                                    p.Frame = 21;
                            }
                            else
                            {
                                p.FrameCount += 1;
                                if(!(p.Frame == 19 || p.Frame == 20 || p.Frame == 21))
                                    p.Frame = 19;
                                if(p.FrameCount >= 5)
                                {
                                    p.FrameCount = 0;
                                    if(p.Frame == 19)
                                        p.Frame = 20;
                                    else if(p.Frame == 20)
                                        p.Frame = 21;
                                    else
                                        p.Frame = 19;
                                }
                            }
                        }
                        else
                        {
                            if(p.Location.SpeedY < 0)
                                p.Frame = 4;
                            else
                            {
                                if((p.State == 4 || p.State == 5) && p.Controls.Jump && !(p.Character == 3 || p.Character == 4))
                                {
                                    p.FrameCount += 1;
                                    if(!(p.Frame == 3 || p.Frame == 5 || p.Frame == 11))
                                        p.Frame = 11;
                                    if(p.FrameCount >= 5)
                                    {
                                        p.FrameCount = 0;
                                        if(p.Frame == 11)
                                            p.Frame = 3;
                                        else if(p.Frame == 3)
                                            p.Frame = 5;
                                        else
                                            p.Frame = 11;
                                    }
                                }
                                else
                                    p.Frame = 5;
                            }
                        }
                    }
                    if(p.Duck)
                        p.Frame = 7;
                }
            }
            else
            {
                if(grounded)
                {
                    if(p.Mount != 2 &&
                       ((p.Controls.Left && p.Location.SpeedX > 0) || (p.Controls.Right && p.Location.SpeedX < 0)) &&
                       p.Effect == PLREFF_NORMAL && !p.Duck)
                    {
                        PlaySoundSpatial(SFX_Skid, p.Location);
                        s_makeDust(p, -10, tempLocation);
                    }
                    if(p.Location.SpeedX != 0)
                    {
                        p.FrameCount += 1;
                        if(p.Location.SpeedX > Physics.PlayerWalkSpeed || p.Location.SpeedX < -Physics.PlayerWalkSpeed)
                            p.FrameCount += 1;
                        if(p.FrameCount >= 5 && p.FrameCount < 10)
                            p.Frame = 8;
                        else if(p.FrameCount >= 10 && p.FrameCount < 15)
                            p.Frame = 9;
                        else if(p.FrameCount >= 15 && p.FrameCount < 20)
                            p.Frame = 10;
                        else if(p.FrameCount >= 20)
                        {
                            p.FrameCount = 0;
                            p.Frame = 9;
                        }
                    }
                    else
                    {
                        p.Frame = 8;
                        p.FrameCount = 0;
                    }
                }
                else
                {
                    p.Frame = 10;
                    if(p.Character == 3)
                        p.Frame = 9;
                }
            }
        }

        if(p.Mount == 1) // Goomba's Shoe
        {
            p.MountOffsetY = 0;//-p.Location.SpeedY / 2; FIXME: Verify this didn't broke anything

            if(p.Duck || p.StandingOnNPC != 0)
                p.MountOffsetY = 0;
            if(p.Direction == 1)
                p.MountFrame = 2 + SpecialFrame[1];
            else
                p.MountFrame = 0 + SpecialFrame[1];

            p.Frame = 1;

            if(p.State == PLR_STATE_AQUATIC)
                p.Frame = 8;
        }
        else if(p.Mount == 2) // Koopa Clown Car
        {
            p.Frame = 1;
            p.MountFrame = SpecialFrame[2];

            if(p.Direction == 1)
                p.MountFrame += 4;
        }
        else if(p.Mount == 3) // Green Yoshi
        {
            p.YoshiBY = 42;
            p.YoshiBX = 0;
            p.YoshiTY = 10;
            p.YoshiTX = 20;
            p.Frame = 30;
            p.YoshiBFrame = 0;
            p.YoshiTFrame = 0;
            p.MountOffsetY = 0;

            if(p.Location.SpeedY < 0 && p.StandingOnNPC == 0 && p.Slope == 0)
            {
                p.YoshiBFrame = 3;
                p.YoshiTFrame = 2;
            }
            else if(p.Location.SpeedY > 0 && p.StandingOnNPC == 0 && p.Slope == 0)
            {
                p.YoshiBFrame = 2;
                p.YoshiTFrame = 0;
            }
            else
            {
                if(p.Location.SpeedX != 0)
                {
                    if(p.Effect == PLREFF_NORMAL)
                    {
                        // IMPORTANT: this case was truncation until v1.3.7.1-dev. Confirm that changing to VB6 rounding does not cause any issues.
                        p.YoshiBFrameCount += 1 + num_t::vb6round(num_t::abs(p.Location.SpeedX * 0.7_r));
                    }

                    if((p.Direction == -1 && p.Location.SpeedX > 0) || (p.Direction == 1 && p.Location.SpeedX < 0))
                        p.YoshiBFrameCount = 24;

                    if(p.YoshiBFrameCount < 0)
                        p.YoshiBFrameCount = 0;

                    if(p.YoshiBFrameCount > 32)
                    {
                        p.YoshiBFrame = 0;
                        p.YoshiBFrameCount = 0;
                    }
                    else if(p.YoshiBFrameCount > 24)
                    {
                        p.YoshiBFrame = 1;
                        p.YoshiTX -= 1;
                        p.YoshiTY += 2;
                        p.YoshiBY += 1;
                        p.MountOffsetY += 1;
                    }
                    else if(p.YoshiBFrameCount > 16)
                    {
                        p.YoshiBFrame = 2;
                        p.YoshiTX -= 2;
                        p.YoshiTY += 4;
                        p.YoshiBY += 2;
                        p.MountOffsetY += 2;
                    }
                    else if(p.YoshiBFrameCount > 8)
                    {
                        p.YoshiBFrame = 1;
                        p.YoshiTX -= 1;
                        p.YoshiTY += 2;
                        p.YoshiBY += 1;
                        p.MountOffsetY += 1;
                    }
                    else
                        p.YoshiBFrame = 0;
                }
                else
                    p.YoshiBFrameCount = 0;
            }

            if(p.MountSpecial == 1)
            {
                if(p.Controls.Up ||
                   (p.StandingOnNPC == 0 && p.Location.SpeedY != 0 &&
                    p.Slope == 0 && !p.Controls.Down))
                {
                    // .YoshiBFrame = 0
                    p.YoshiTFrame = 3;
                    // useless self-assignment code [PVS-Studio]
                    // p.MountOffsetY = p.MountOffsetY;
                    p.YoshiTongue.Y += p.MountOffsetY;
                    //p.YoshiTongue.Y = p.YoshiTongue.Y + p.MountOffsetY;
                }
                else
                {
                    // defaults
                    p.YoshiBY = 42;
                    p.YoshiBX = 0;
                    p.YoshiTY = 10;
                    p.YoshiTX = 20;
                    p.YoshiBFrame = 5;
                    p.YoshiTFrame = 4;
                    p.YoshiBY += 8;
                    p.YoshiTY += 24;
                    p.YoshiTX += 12;
                    /*
                    p.MountOffsetY = 0;
                    p.MountOffsetY += 8;
                    */
                    p.MountOffsetY = 8;
                }
            }

            if(p.Duck)
            {
                p.Frame = 31;
                if(p.MountSpecial == 0)
                    p.YoshiBFrame = 6;
                p.YoshiBFrameCount = 0;
            }

            if(p.YoshiTFrameCount > 0)
            {
                if(p.YoshiNPC == 0 && p.YoshiPlayer == 0)
                    p.YoshiTFrameCount += 1;

                if(p.YoshiTFrameCount < 10)
                    p.YoshiTFrame = 1;
                else if(p.YoshiTFrameCount < 20)
                    p.YoshiTFrame = 2;
                else
                    p.YoshiTFrameCount = 0;
            }
            else if(p.YoshiTFrameCount < 0)
            {
                p.YoshiTFrameCount -= 1;
                if(p.YoshiTFrameCount > -10)
                    p.YoshiTFrame = 3;
                else
                    p.YoshiTFrameCount = 0;
            }

            if(p.Direction == 1)
            {
                p.YoshiTFrame += 5;
                p.YoshiBFrame += 7;
            }
            else
            {
                p.YoshiBX = -p.YoshiBX;
                p.YoshiTX = -p.YoshiTX;
            }

            if(!p.Duck || p.MountSpecial > 0)
            {
                p.MountOffsetY -= (72 - (int)p.Location.Height);
                p.YoshiBY -= (72 - (int)p.Location.Height);
                p.YoshiTY -= (72 - (int)p.Location.Height);
            }
            else
            {
                p.MountOffsetY -= (64 - (int)p.Location.Height);
                p.YoshiBY -= (64 - (int)p.Location.Height);
                p.YoshiTY -= (64 - (int)p.Location.Height);
            }

            p.YoshiBX -= 4;
            p.YoshiTX -= 4;

            if(p.YoshiBlue)
            {
                if(p.Location.SpeedY == 0 || p.StandingOnNPC != 0)
                    p.YoshiWingsFrame = 1;
                else if(p.Location.SpeedY < 0)
                {
                    p.YoshiWingsFrameCount += 1;
                    if(p.YoshiWingsFrameCount < 6)
                        p.YoshiWingsFrame = 1;
                    else if(p.YoshiWingsFrameCount < 12)
                        p.YoshiWingsFrame = 0;
                    else
                    {
                        p.YoshiWingsFrameCount = 0;
                        p.YoshiWingsFrame = 0;
                    }
                }
                else
                {
                    p.YoshiWingsFrameCount += 1;
                    if(p.YoshiWingsFrameCount < 12)
                        p.YoshiWingsFrame = 1;
                    else if(p.YoshiWingsFrameCount < 24)
                        p.YoshiWingsFrame = 0;
                    else
                    {
                        p.YoshiWingsFrameCount = 0;
                        p.YoshiWingsFrame = 0;
                    }
                }
                if(p.GroundPound)
                    p.YoshiWingsFrame = 0;
                if(p.Direction == 1)
                    p.YoshiWingsFrame += 2;
            }
        }
    }

    if(p.Mount == 1 && p.MountType == 3)
    {
        if(p.Location.SpeedY == 0 || p.StandingOnNPC != 0)
            p.YoshiWingsFrame = 1;
        else if(p.Location.SpeedY < 0)
        {
            p.YoshiWingsFrameCount += 1;
            if(p.YoshiWingsFrameCount < 6)
                p.YoshiWingsFrame = 1;
            else if(p.YoshiWingsFrameCount < 12)
                p.YoshiWingsFrame = 0;
            else
            {
                p.YoshiWingsFrameCount = 0;
                p.YoshiWingsFrame = 0;
            }
        }
        else
        {
            p.YoshiWingsFrameCount += 1;
            if(p.YoshiWingsFrameCount < 12)
                p.YoshiWingsFrame = 1;
            else if(p.YoshiWingsFrameCount < 24)
                p.YoshiWingsFrame = 0;
            else
            {
                p.YoshiWingsFrameCount = 0;
                p.YoshiWingsFrame = 0;
            }
        }

        if(p.GroundPound)
            p.YoshiWingsFrame = 0;

        if(p.Direction == 1)
            p.YoshiWingsFrame += 2;
    }
}

void UpdatePlayerBonus(const int A, const NPCID B)
{
    auto &p = Player[A];

    // INCORRECT NOTE: I have traced all paths into this code, and it is unreachable if p.Effect != PLREFF_NORMAL
    // NOTE: this is not true if the player touches two bonuses in the same frame.

    int effect_state = PLR_STATE_SMALL;

    if(p.Effect >= PLREFF_TURN_TO_STATE && p.Effect < PLREFF_TURN_TO_STATE_END)
        effect_state = p.Effect - PLREFF_TURN_TO_STATE;
    else if(p.Effect >= PLREFF_GROW_TO_STATE && p.Effect < PLREFF_GROW_TO_STATE_END)
        effect_state = p.Effect - PLREFF_GROW_TO_STATE;
    else if(p.Effect == PLREFF_TURN_BIG)
        effect_state = PLR_STATE_BIG;

    if(p.State != PLR_STATE_SMALL || (effect_state == PLR_STATE_BIG || effect_state == PLR_STATE_FIRE || effect_state == PLR_STATE_LEAF))
    {
        if(B == NPCID_POWER_S3 || B == NPCID_POWER_S4 || B == NPCID_POWER_S1 || B == NPCID_POWER_S5)
        {
            if(p.HeldBonus == 0)
                p.HeldBonus = B;
        }
        else if((p.State == PLR_STATE_BIG || effect_state == PLR_STATE_BIG) && !(effect_state == PLR_STATE_FIRE || effect_state == PLR_STATE_LEAF))
        {
            if(p.HeldBonus == 0)
            {
                if(p.StateNPC == NPCID_POWER_S1)
                    p.HeldBonus = NPCID_POWER_S1;
                else if(p.StateNPC == NPCID_POWER_S4)
                    p.HeldBonus = NPCID_POWER_S4;
                else
                    p.HeldBonus = NPCID_POWER_S3;
            }
        }
        else
        {
            if(p.State == PLR_STATE_FIRE || effect_state == PLR_STATE_FIRE)
            {
                if(p.StateNPC == NPCID_FIRE_POWER_S4)
                    p.HeldBonus = NPCID_FIRE_POWER_S4;
                else if(p.StateNPC == NPCID_FIRE_POWER_S1)
                    p.HeldBonus = NPCID_FIRE_POWER_S1;
                else
                    p.HeldBonus = NPCID_FIRE_POWER_S3;
            }

            if(p.State == PLR_STATE_LEAF || effect_state == PLR_STATE_LEAF)
                p.HeldBonus = NPCID_LEAF_POWER;

            if(p.State == PLR_STATE_STATUE || effect_state == PLR_STATE_STATUE)
                p.HeldBonus = NPCID_STATUE_POWER;

            if(p.State == PLR_STATE_HEAVY || effect_state == PLR_STATE_HEAVY)
                p.HeldBonus = NPCID_HEAVY_POWER;

            if(p.State == PLR_STATE_ICE || effect_state == PLR_STATE_ICE)
            {
                if(p.StateNPC == NPCID_ICE_POWER_S4)
                    p.HeldBonus = NPCID_ICE_POWER_S4;
                else
                    p.HeldBonus = NPCID_ICE_POWER_S3;
            }

            // State-dependent moment, extend for states > 7, using the 38A NPCIDs and then our own dedicated range. It's not safe to rely on StateNPC because it doesn't get saved.
            if(p.State == PLR_STATE_AQUATIC || effect_state == PLR_STATE_AQUATIC)
                p.HeldBonus = NPCID_AQUATIC_POWER;
            else if(p.State == PLR_STATE_POLAR || effect_state == PLR_STATE_POLAR)
                p.HeldBonus = NPCID_POLAR_POWER;
            else if(p.State == PLR_STATE_CYCLONE || effect_state == PLR_STATE_CYCLONE)
                p.HeldBonus = NPCID_CYCLONE_POWER;
            else if(p.State == PLR_STATE_SHELL || effect_state == PLR_STATE_SHELL)
                p.HeldBonus = NPCID_SHELL_POWER;
        }
    }

    if(p.Character == 3 || p.Character == 4 || p.Character == 5)
        p.HeldBonus = NPCID(0);
}

void TailSwipe(const int plr, bool boo, bool Stab, int StabDir)
{
    auto &p = Player[plr];
    Location_t tailLoc;
    Location_t tempLoc;
    Location_t stabLoc;

    // int A = 0;
    // long long B = 0;
    // int C = 0;
    // int64_t fBlock = 0;
    // int64_t lBlock = 0;

    if(Stab)
    {
        if(!p.Duck)
        {
            if(StabDir == 1)
            {
                tailLoc.Width = 6;
                tailLoc.Height = 14;
                tailLoc.Y = p.Location.Y - tailLoc.Height;
                if(p.Direction == 1)
                    tailLoc.X = p.Location.X + p.Location.Width - 4;
                else
                    tailLoc.X = p.Location.X - tailLoc.Width + 4;
            }
            else if(StabDir == 2)
            {
                // tailLoc.Width = 8
                tailLoc.Height = 8;
                if(p.Location.SpeedY >= 10)
                    tailLoc.Height = 12;
                else if(p.Location.SpeedY >= 8)
                    tailLoc.Height = 10;
                tailLoc.Y = p.Location.Y + p.Location.Height;
                // tailLoc.X = .Location.X + .Location.Width / 2 - tailLoc.Width / 2 + (2 * .Direction)
                tailLoc.Width = p.Location.Width - 2;
                tailLoc.X = p.Location.X + 1;
            }
            else
            {
                tailLoc.Width = 38;
                tailLoc.Height = 6;
                tailLoc.Y = p.Location.Y + p.Location.Height - 42;
                if(p.Direction == 1)
                    tailLoc.X = p.Location.X + p.Location.Width;
                else
                    tailLoc.X = p.Location.X - tailLoc.Width;
            }
        }
        else
        {
            tailLoc.Width = 38;
            tailLoc.Height = 8;
            tailLoc.Y = p.Location.Y + p.Location.Height - 22;
            if(p.Direction == 1)
                tailLoc.X = p.Location.X + p.Location.Width;
            else
                tailLoc.X = p.Location.X - tailLoc.Width;
        }
    }
    else
    {
        tailLoc.Width = 18;
        tailLoc.Height = 12;
        tailLoc.Y = p.Location.Y + p.Location.Height - 26;
        if(p.Direction == 1)
            tailLoc.X = p.Location.X + p.Location.Width;
        else
            tailLoc.X = p.Location.X - tailLoc.Width;
    }

    if(p.Character == 4) // move tail down for toad
        tailLoc.Y += 4;

    if(boo) // the bool flag means hit a block
    {
        // fBlock = FirstBlock[(tailLoc.X / 32) - 1];
        // lBlock = LastBlock[((tailLoc.X + tailLoc.Width) / 32.0) + 1];
        // blockTileGet(tailLoc, fBlock, lBlock);

        for(BlockRef_t block_p : treeFLBlockQuery(tailLoc, SORTMODE_COMPAT))
        {
            Block_t& block = *block_p;
            int A = (int)block_p;

            if(!BlockIsSizable[block.Type] && !block.Hidden && (block.Type != 293 || Stab) && !block.Invis && !BlockNoClipping[block.Type])
            {
                if(CheckCollision(tailLoc, block.Location))
                {
                    // if(block.ShakeY == 0 && block.ShakeY2 == 0 && block.ShakeY3 == 0)
                    if(block.ShakeCounter == 0)
                    {
                        if(block.Special > 0 || block.Type == 55 || block.Type == 159 || block.Type == 90)
                            PlaySoundSpatial(SFX_BlockHit, block.Location);
//                        if(nPlay.Online && plr - 1 == nPlay.MySlot)
//                            Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1g" + std::to_string(plr) + "|" + p.TailCount - 1;
#if XTECH_ENABLE_WEIRD_GFX_UPDATES
                        UpdateGraphics(true); // FIXME: Why this extra graphics update is here? It causes the lag while whipping blocks by the tail
#endif

                        BlockHit(A, (StabDir == 2), plr);
                        //if(StabDir == 2)
                        //{
                        //    BlockHit(A, true, plr);
                        //}
                        //else
                        //{
                        //    BlockHit(A, false, plr);
                        //}

                        BlockHitHard(A);
                        if(!Stab)
                        {
                            // if(block.ShakeY != 0)
                            if(block.ShakeCounter != 0)
                            {
                                tempLoc.X = (block.Location.X + tailLoc.X + (block.Location.Width + tailLoc.Width) / 2) / 2 - 16;
                                tempLoc.Y = (block.Location.Y + tailLoc.Y + (block.Location.Height + tailLoc.Height) / 2) / 2 - 16;
                                NewEffect(EFFID_WHIP, tempLoc);
                            }
                            break;
                        }
                        else
                        {
                            if(StabDir == 2)
                            {
                                if(block.Type == 293 || block.Type == 370
                                    /* || block.ShakeY != 0 || block.ShakeY2 != 0 || block.ShakeY3 != 0 */
                                    || block.ShakeCounter != 0
                                    || block.Hidden || BlockHurts[block.Type])
                                {
                                    if(BlockHurts[block.Type])
                                        PlaySoundSpatial(SFX_Spring, block.Location);
                                    p.Location.Y -= 0.1_n;
                                    p.Location.SpeedY = Physics.PlayerJumpVelocity;
                                    p.StandingOnNPC = 0;
                                    if(p.Controls.Jump || p.Controls.AltJump)
                                        p.Jump = 10;
                                }
                            }

                            if(block.Type == 370)
                            {
                                PlaySoundSpatial(SFX_HeroGrass, block.Location);
                                block.Hidden = true;
                                block.Layer = LAYER_DESTROYED_BLOCKS;
                                syncLayersTrees_Block(A);
                                NewEffect(EFFID_SMOKE_S3, block.Location);
                                // SpeedY didn't get doubled for SMOKE_S3 in SMBX 1.3
                                Effect[numEffects].Location.SpeedY = -2;
                            }

                            // allow Char5 to stab gray bricks when it has heavy power
                            if(block.Type == 457 && p.State == 6)
                                SafelyKillBlock(A);
                        }
                    }
                }
            }
        }
    }

    int numNPCsMax5 = numNPCs;

    // need this complex loop syntax because Active can be modified within it
    for(int A : NPCQueues::Active.may_erase)
    {
        if(A > numNPCsMax5)
            continue;

        if(NPC[A].Active && NPC[A].Effect == NPCEFF_NORMAL && !(NPCIsAnExit(NPC[A]) || (NPC[A]->IsACoin && !Stab)) &&
            NPC[A].CantHurtPlayer != plr && !(p.StandingOnNPC == A && p.ShellSurf))
        {
            if(NPC[A].Type != NPCID_PLR_FIREBALL && NPC[A].Type != NPCID_PLR_ICEBALL && !(NPC[A].Type == NPCID_BULLET && NPC[A].Projectile) &&
                NPC[A].Type != NPCID_PET_FIRE && NPC[A].Type != NPCID_GOALTAPE && NPC[A].Type != NPCID_CHECKPOINT)
            {
                stabLoc = NPC[A].Location;
                if(NPC[A]->HeightGFX > NPC[A].Location.Height && NPC[A].Type != NPCID_PLANT_S3 && NPC[A].Type != NPCID_MINIBOSS &&
                    NPC[A].Type != NPCID_WALL_BUG && NPC[A].Type != NPCID_POWER_S3 && NPC[A].Type != NPCID_BOTTOM_PLANT && NPC[A].Type != NPCID_SIDE_PLANT &&
                    NPC[A].Type != NPCID_BIG_PLANT && NPC[A].Type != NPCID_PLANT_S1 && NPC[A].Type != NPCID_FIRE_PLANT)
                {
                    stabLoc.set_height_floor(NPC[A]->HeightGFX);
                }

                if(NPC[A].Type == NPCID_ITEM_BURIED && Stab)
                    stabLoc.Y += -stabLoc.Height;

                if(CheckCollision(tailLoc, stabLoc) && NPC[A].Killed == 0 && NPC[A].TailCD == 0 && !(StabDir != 0 && NPC[A].Type == NPCID_ITEM_BURIED))
                {
                    if(Stab)
                    {
                        if(StabDir == 2 && ((NPC[A].Type >= NPCID_CARRY_BLOCK_A && NPC[A].Type <= NPCID_CARRY_BLOCK_D) || NPC[A].Type == NPCID_SPRING || NPC[A].Type == NPCID_COIN_SWITCH || NPC[A].Type == NPCID_TIME_SWITCH || NPC[A].Type == NPCID_EARTHQUAKE_BLOCK))
                        {
                        }
                        else
                        {
                            vbint_t oldDamage = NPC[A].Damage;
                            NPCID oldType = NPC[A].Type;

                            if(NPC[A].Type == NPCID_SLIDE_BLOCK && StabDir != 0)
                            {
                                NPC[A].Special = 1;
                                NPC[A].Projectile = true;
                                NPCHit(A, 3, A);
                                p.Location.SpeedY = Physics.PlayerJumpVelocity;
                                p.StandingOnNPC = 0;
                                if(p.Controls.Jump || p.Controls.AltJump)
                                    p.Jump = 10;
                            }
                            else
                            {
                                NPCHit(A, 10, plr);
                            }

                            if(StabDir == 2 && (NPC[A].Killed == 10 || NPC[A].Damage != oldDamage || NPC[A].Type != oldType))
                            {
                                p.Location.SpeedY = Physics.PlayerJumpVelocity;
                                p.StandingOnNPC = 0;
                                if(p.Controls.Jump || p.Controls.AltJump)
                                    p.Jump = 10;
                            }
                        }
                    }
                    else
                    {
                        NPCID oldType = NPC[A].Type;
                        bool oldProj = NPC[A].Projectile;
                        num_t oldSpeedY = NPC[A].Location.SpeedY;

                        NPCHit(A, 7, plr);

                        if(NPC[A].Killed > 0 || NPC[A].Type != oldType || NPC[A].Projectile != oldProj || (NPC[A].Location.SpeedY != oldSpeedY))
                        {
//                            if(nPlay.Online && plr - 1 == nPlay.MySlot)
//                                Netplay::sendData Netplay::PutPlayerLoc(nPlay.MySlot) + "1g" + std::to_string(plr) + "|" + p.TailCount - 1;
                            tempLoc.X = (NPC[A].Location.X + tailLoc.X + (NPC[A].Location.Width + tailLoc.Width) / 2) / 2 - 16;
                            tempLoc.Y = (NPC[A].Location.Y + tailLoc.Y + (NPC[A].Location.Height + tailLoc.Height) / 2) / 2 - 16;
                            NPC[A].BattleOwner = plr;
                            NewEffect(EFFID_WHIP, tempLoc);
                        }
                    }

                    NPC[A].TailCD = 8;
                }
            }
        }
    }

    if(BattleMode)
    {
        for(int A = 1; A <= numPlayers; A++)
        {
            if(A != plr)
            {
                if(CheckCollision(tailLoc, Player[A].Location) && Player[A].Effect == PLREFF_NORMAL &&
                    Player[A].Immune == 0 && !Player[A].Dead && Player[A].TimeToLive == 0)
                {
                    if(Stab)
                    {
                        if(StabDir == 2)
                        {
                            p.Location.SpeedY = Physics.PlayerJumpVelocity;
                            p.StandingOnNPC = 0;
                            if(p.Controls.Jump || p.Controls.AltJump)
                                p.Jump = 10;
                        }
                        // NEW LOGIC: Char5 shield block -- the logic for Player[A] is based on Char5 shield logic in SpecialNPC
                        else if(StabDir == 0 && Player[A].Character == 5 && Player[A].Direction != p.Direction
                            && Player[A].Effect == PLREFF_NORMAL && Player[A].SwordPoke == 0 && !Player[A].Fairy)
                        {
                            num_t shield_t = Player[A].Location.Y + Player[A].Location.Height;
                            shield_t -= (Player[A].Duck) ? 28 : 52;

                            num_t shield_b = shield_t + 24;

                            // Player[A]'s shield blocks attack and pushes p away, canceling p's SwordPoke and creating an opening for attack
                            if(tailLoc.Y <= shield_b && tailLoc.Y + tailLoc.Height >= shield_t)
                            {
                                PlaySoundSpatial(SFX_HeroShield, tailLoc);

                                // knock p and Player[A] back a bit
                                p.Location.SpeedX = Player[A].Location.SpeedX - 2 * p.Direction;
                                Player[A].Location.SpeedX += p.Direction;
                                p.Location.Y -= 1.5_n;
                                p.Location.SpeedY -= 1.5_n;

                                // cancel stab
                                p.SwordPoke |= 32;
                                continue;
                            }
                        }

                        PlayerHurt(A);
                        PlaySoundSpatial(SFX_HeroHit, Player[A].Location);
                    }
                    else
                    {
                        Player[A].Location.SpeedX = 6 * p.Direction;
                        Player[A].Location.SpeedY = -5;
                        PlaySoundSpatial(SFX_Stomp, Player[A].Location);
                    }
                }
            }
        }
    }

    if(!Stab)
    {
        if(((p.TailCount) % 10 == 0 && !p.SpinJump) || ((p.TailCount) % 5 == 0 && p.SpinJump))
        {
            num_t dx = dRand();
            num_t dy = dRand();
            NewEffect(EFFID_SPARKLE, newLoc(tailLoc.X + (dx * (int_ok)tailLoc.Width) - 4, tailLoc.Y + (dy * (int_ok)tailLoc.Height)), 1, ShadowMode);
            Effect[numEffects].Location.SpeedX = (0.5_n + dRand()) * p.Direction;
            Effect[numEffects].Location.SpeedY = dRand() - 0.5_n;
        }
    }
}

void YoshiHeight(const int A)
{
    auto &p = Player[A];

    if(p.Mount == 3)
        p.Location.set_height_floor((p.State == 1) ? 54 : 60);
}

void YoshiEat(const int A)
{
    Location_t tempLocation;
    auto &p = Player[A];

    for(int B = 1; B <= numPlayers; B++)
    {
        auto &p2 = Player[B];

        if(B != A && p2.Effect == PLREFF_NORMAL && !p2.Dead && p2.TimeToLive == 0 && p2.Mount == 0)
        {
            if(CheckCollision(p.YoshiTongue, p2.Location))
            {
                p.YoshiPlayer = B;
                p2.HoldingNPC = 0;
                return;
            }
        }
    }

    for(int B : treeNPCQuery(static_cast<Location_t>(p.YoshiTongue), SORTMODE_ID))
    {
        auto &n = NPC[B];
        if(((n->IsACoin && n.Special == 1) || !n->NoYoshi) &&
           n.Active && ((!n->IsACoin || n.Special == 1) || n.Type == NPCID_RED_COIN) &&
           !NPCIsAnExit(n) && !n.Generator && !n.Inert && !NPCIsYoshi(n) &&
            n.Effect != NPCEFF_PET_TONGUE && n.Immune == 0 && n.Type != NPCID_ITEM_BURIED &&
            !(n.Projectile && n.Type == NPCID_BULLET) && n.HoldingPlayer == 0)
        {
            tempLocation = n.Location;
            // dead code
#if 0
            if(n.Type == NPCID_ITEM_BURIED)
                tempLocation.Y = n.Location.Y - 16;
#endif

            if(CheckCollision(p.YoshiTongue, tempLocation))
            {
                // dead code, check n.Type != 91 condition above
#if 0
                if(n.Type == NPCID_ITEM_BURIED)
                {
                    if(!NPCTraits[(int)n.Special].NoYoshi)
                    {
                        PlaySound(SFX_Grab);
                        n.Generator = false;
                        n.Frame = 0;
                        n.Type = n.Special;
                        n.Special = 0;

                        if(NPCIsYoshi(n))
                        {
                            n.Special = n.Type;
                            n.Type = 96;
                        }

                        n.Location.Height = n->THeight;
                        n.Location.Width = n->TWidth;

                        if(!(n.Type == 21 || n.Type == 22 || n.Type == 26 || n.Type == 31 || n.Type == 32 || n.Type == 35 || n.Type == 49 || NPCIsAnExit(n)))
                            n.DefaultType = 0;

                        n.Effect = 5;
                        n.Effect2 = A;
                        p.YoshiNPC = B;

                        NPCQueues::Unchecked.push_back(B);
                        treeNPCUpdate(B);
                    }
                }
                else
#endif
                if(n.Type == NPCID_ITEM_BUBBLE)
                {
                    NPCHit(B, 3, B);
                }
                else
                {
                    n.Effect = NPCEFF_PET_TONGUE;
                    n.Effect2 = A;
                    n.Location.Height = n->THeight;
                    p.YoshiNPC = B;
                    treeNPCUpdate(B);
                }

                if(n.Type == NPCID_VEGGIE_RANDOM)
                {
                    n.Type = NPCID(NPCID_VEGGIE_2 + iRand(9));
                    if(n.Type == NPCID_VEGGIE_RANDOM)
                        n.Type = NPCID_VEGGIE_1;

                    n.Location.set_width_center(n->TWidth);
                    n.Location.set_height_center(n->THeight);

                    NPCQueues::Unchecked.push_back(B);
                    treeNPCUpdate(B);
                }
                break;
            }
        }
    }
}

void YoshiSpit(const int A)
{
    int B = 0;
    auto &p = Player[A];

//    if(nPlay.Online && A - 1 == nPlay.MySlot)
//        Netplay::sendData Netplay::PutPlayerControls(nPlay.MySlot);
    p.YoshiTFrameCount = -1;

    if(p.YoshiPlayer > 0)
    {
        Player[p.YoshiPlayer].Section = p.Section;
        Player[p.YoshiPlayer].Effect = PLREFF_NORMAL;
        Player[p.YoshiPlayer].Effect2 = 0;
        Player[p.YoshiPlayer].Slide = true;

        if(Player[p.YoshiPlayer].State > 1)
            Player[p.YoshiPlayer].Location.Height = Physics.PlayerDuckHeight[Player[p.YoshiPlayer].Character][Player[p.YoshiPlayer].State];
        // Player(.YoshiPlayer).Location.Y = Player(.YoshiPlayer).Location.Y - Physics.PlayerDuckHeight(Player(.YoshiPlayer).Character, Player(.YoshiPlayer).State) + Physics.PlayerHeight(Player(.YoshiPlayer).Character, Player(.YoshiPlayer).State)
        // Player(.YoshiPlayer).Duck = True

        if(p.Controls.Down)
        {
            Player[p.YoshiPlayer].Location.X = p.Location.X + p.YoshiTX + Player[p.YoshiPlayer].Location.Width * p.Direction;
            Player[p.YoshiPlayer].Location.X += 5;
            Player[p.YoshiPlayer].Location.Y = p.Location.Y + p.Location.Height - Player[p.YoshiPlayer].Location.Height;
            Player[p.YoshiPlayer].Location.SpeedX = 0 + p.Location.SpeedX * 0.3_r;
            Player[p.YoshiPlayer].Location.SpeedY = 1 + p.Location.SpeedY * 0.3_r;
        }
        else
        {
            Player[p.YoshiPlayer].Location.X = p.Location.X + p.YoshiTX + Player[p.YoshiPlayer].Location.Width * p.Direction;
            Player[p.YoshiPlayer].Location.X += 5;
            Player[p.YoshiPlayer].Location.Y = p.Location.Y + 1;
            Player[p.YoshiPlayer].Location.SpeedX = 7 * p.Direction + p.Location.SpeedX * 0.3_r;
            Player[p.YoshiPlayer].Location.SpeedY = -3 + p.Location.SpeedY * 0.3_r;
        }

        Player[p.YoshiPlayer].Direction = -p.Direction;
        Player[p.YoshiPlayer].Bumped = true;

        // Simplified code
        if(p.CurMazeZone)
        {
            Player[p.YoshiPlayer].CurMazeZone = p.CurMazeZone;
            PlayerThrowItemMaze(p, Player[p.YoshiPlayer].Location, Player[p.YoshiPlayer].MazeZoneStatus);
        }
        else
            PlayerPush(p.YoshiPlayer, (p.Direction == 1) ? 2 : 4);
        //if(p.Direction == 1)
        //    PlayerPush(p.YoshiPlayer, 2);
        //else
        //    PlayerPush(p.YoshiPlayer, 4);

        p.YoshiPlayer = 0;
        PlaySoundSpatial(SFX_SpitBossSpit, p.Location);
    }
    else
    {
        NPC[p.YoshiNPC].RealSpeedX = 0;
        if(NPC[p.YoshiNPC]->IsAShell)
            NPC[p.YoshiNPC].Special = 0;

        if((NPC[p.YoshiNPC]->IsAShell || NPCIsABot(NPC[p.YoshiNPC]) || NPC[p.YoshiNPC].Type == NPCID_RAINBOW_SHELL) &&
           NPC[p.YoshiNPC].Type != NPCID_GLASS_SHELL && p.YoshiRed)
        {
            NPC[p.YoshiNPC].Killed = 9;
            NPCQueues::Killed.push_back(p.YoshiNPC);
            PlaySoundSpatial(SFX_BigFireball, p.Location);
            for(B = 1; B <= 3; B++)
            {
                numNPCs++;
                NPC[numNPCs].Direction = p.Direction;
                NPC[numNPCs].Type = NPCID_PET_FIRE;
                NPC[numNPCs].Frame = EditorNPCFrame(NPC[numNPCs].Type, NPC[numNPCs].Direction);
                NPC[numNPCs].Active = true;
                NPC[numNPCs].Section = p.Section;
                NPC[numNPCs].TimeLeft = 100;
                NPC[numNPCs].Effect = NPCEFF_NORMAL;
                NPC[numNPCs].Location.X = p.Location.X + p.YoshiTX + 32 * p.Direction;
                NPC[numNPCs].Location.Y = p.Location.Y + p.YoshiTY;
                NPC[numNPCs].Location.Width = 32;
                NPC[numNPCs].Location.Height = 32;

                if(B == 1)
                {
                    NPC[numNPCs].Location.SpeedY = -0.8_n;
                    NPC[numNPCs].Location.SpeedX = 5 * p.Direction;
                }
                else if(B == 2)
                {
                    NPC[numNPCs].Location.SpeedY = 0;
                    NPC[numNPCs].Location.SpeedX = 5.5_n * p.Direction;
                }
                else
                {
                    NPC[numNPCs].Location.SpeedY = 0.8_n;
                    NPC[numNPCs].Location.SpeedX = 5 * p.Direction;
                }

                syncLayers_NPC(numNPCs);
            }
        }
        else
        {
            NPC[p.YoshiNPC].Direction = p.Direction;
            NPC[p.YoshiNPC].Frame = 0;
            // this means that the NPC will be killed if it is inside a wall next frame
            NPC[p.YoshiNPC].WallDeath = 5;
            NPC[p.YoshiNPC].FrameCount = 0;
            NPC[p.YoshiNPC].Frame = EditorNPCFrame(NPC[p.YoshiNPC].Type, NPC[p.YoshiNPC].Direction);
            NPC[p.YoshiNPC].Active = true;
            NPC[p.YoshiNPC].Section = p.Section;
            NPC[p.YoshiNPC].TimeLeft = 100;
            NPC[p.YoshiNPC].Effect = NPCEFF_NORMAL;
            NPC[p.YoshiNPC].Effect2 = 0;
            NPC[p.YoshiNPC].Location.X = p.Location.X + p.YoshiTX + 32 * p.Direction;
            NPC[p.YoshiNPC].Location.Y = p.Location.Y + p.YoshiTY;
            if(p.Duck)
                NPC[p.YoshiNPC].Location.Y -= 8;
            NPC[p.YoshiNPC].Location.Y -= 2;
            NPC[p.YoshiNPC].Location.SpeedX = 0;
            NPC[p.YoshiNPC].Location.SpeedY = 0;

            if(NPC[p.YoshiNPC].Type == NPCID_SLIDE_BLOCK)
                NPC[p.YoshiNPC].Special = 1;

            PlaySoundSpatial(SFX_SpitBossSpit, p.Location);

            if(!p.Controls.Down || (p.Location.SpeedY != 0 && p.StandingOnNPC == 0 && p.Slope == 0))
            {
                if(NPC[p.YoshiNPC]->IsAShell)
                {
                    SoundPause[SFX_ShellHit] = 2;
                    // NPCHit .YoshiNPC, 1, A
                    NPC[p.YoshiNPC].Location.SpeedX = Physics.NPCShellSpeed * p.Direction;
                }
                else if(NPC[p.YoshiNPC].Type == NPCID_SLIDE_BLOCK)
                    NPC[p.YoshiNPC].Location.SpeedX = Physics.NPCShellSpeed * p.Direction;
                else
                {
                    NPC[p.YoshiNPC].Projectile = true;
                    NPC[p.YoshiNPC].Location.SpeedX = 7 * p.Direction;
                    NPC[p.YoshiNPC].Location.SpeedY = -1.3_n;
                }
            }

            if(NPC[p.YoshiNPC].Type == NPCID_ICE_BLOCK)
            {
                NPC[p.YoshiNPC].Direction = p.Direction;
                NPC[p.YoshiNPC].Projectile = true;
                NPC[p.YoshiNPC].Location.SpeedX = Physics.NPCShellSpeed * p.Direction * 0.6_r + p.Location.SpeedX * 0.4_r;
                NPC[p.YoshiNPC].TurnAround = false;
            }

            PlayerThrownNpcMazeCheck(p, NPC[p.YoshiNPC]);

            if(p.YoshiNPC > 0 && p.YoshiNPC <= numNPCs)
            {
                NPCQueues::Active.insert(p.YoshiNPC);
                NPCQueues::Unchecked.push_back(p.YoshiNPC);
                treeNPCUpdate(p.YoshiNPC);
            }
        }
    }

    p.FireBallCD = 20;
    p.YoshiNPC = 0;
    p.YoshiRed = false;

    if(p.YoshiBlue)
    {
        p.CanFly = false;
        p.CanFly2 = false;
    }

    p.YoshiBlue = false;
    p.YoshiYellow = false;
}

void YoshiPound(const int A, int mount, bool BreakBlocks)
{
    // int B = 0;
    Location_t tempLocation;
    Location_t tempLocation2;
    auto &p = Player[A];

    if(p.Location.SpeedY > 3)
    {

        tempLocation.Width = 128;
        tempLocation.X = p.Location.X + (p.Location.Width - tempLocation.Width) / 2;
        tempLocation.Height = 32;
        tempLocation.Y = p.Location.Y + p.Location.Height - 16;

        for(int B : NPCQueues::Active.may_erase)
        {
            if(!NPC[B].Hidden && NPC[B].Active && NPC[B].Effect == NPCEFF_NORMAL)
            {
                tempLocation2 = NPC[B].Location;
                tempLocation2.Y += tempLocation2.Height - 4;
                tempLocation2.Height = 8;
                if(CheckCollision(tempLocation, tempLocation2))
                {
                    Block[0].Location.Y = NPC[B].Location.Y + NPC[B].Location.Height;
                    NPCHit(B, 2, 0);
                }
            }
        }

        if(BreakBlocks)
        {
            for(BlockRef_t block : treeBlockQuery(p.Location, SORTMODE_COMPAT))
            {
                Block_t& b = block;
                int B = block;

                if(b.Hidden || b.Invis || BlockNoClipping[b.Type] || BlockIsSizable[b.Type])
                    continue;

                if(g_config.fix_vehicle_char_switch && mount == 2 &&
                    ((b.Type >= 622 && b.Type <= 625) || b.Type == 631))
                    continue; // Forbid playable character switch when riding a clown car

                if(!CheckCollision(p.Location, b.Location))
                    continue;

                BlockHit(B, true, A);
                BlockHitHard(B);
            }
        }

        tempLocation.Width = 32;
        tempLocation.Height = 32;
        tempLocation.Y = p.Location.Y + p.Location.Height - 16;
        tempLocation.X = p.Location.X + p.Location.Width / 2 - 16 - 16;
        NewEffect(EFFID_SMOKE_S3, tempLocation);
        // in SMBX 1.3, this was -2, and then SpeedX was doubled for EFFID_SMOKE_S3
        Effect[numEffects].Location.SpeedX = -4;
        tempLocation.X = p.Location.X + p.Location.Width / 2 - 16 + 16;
        NewEffect(EFFID_SMOKE_S3, tempLocation);
        // in SMBX 1.3, this was -2, and then SpeedX was doubled for EFFID_SMOKE_S3
        Effect[numEffects].Location.SpeedX = 4;
        PlaySoundSpatial(SFX_Stone, p.Location);
        if(BreakBlocks && g_config.extra_screen_shake)
            doShakeScreen(0, 4, SHAKE_SEQUENTIAL, 4, 200, p.Location);
    }
}

void PlayerDismount(const int A)
{
    auto &p = Player[A];

    num_t tempSpeed;
    if(Player[A].Location.SpeedX > 0)
        tempSpeed = Player[A].Location.SpeedX / 5; // tempSpeed gives the player a height boost when jumping while running, based off their SpeedX
    else
        tempSpeed = -Player[A].Location.SpeedX / 5;

    // jump out of boot
    if(Player[A].Mount == 1)
    {
        // if not swimming
        if(Player[A].Wet <= 0 || Player[A].Quicksand != 0)
            UnDuck(Player[A]);
        Player[A].CanJump = false;
        PlaySoundSpatial(SFX_Jump, p.Location); // Jump sound
        PlaySoundSpatial(SFX_Boot, p.Location);
        Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - tempSpeed;
        Player[A].Jump = Physics.PlayerJumpHeight;
        if(Player[A].Character == 2)
            Player[A].Jump += 3;
        if(Player[A].SpinJump)
            Player[A].Jump -= 6;
        Player[A].Mount = 0;
        Player[A].StandingOnNPC = 0;
        numNPCs++;
        Player[A].FlyCount = 0;
        Player[A].RunCount = 0;
        Player[A].CanFly = false;
        Player[A].CanFly2 = false;
        NPC[numNPCs].Direction = Player[A].Direction;
        NPC[numNPCs].Active = true;
        NPC[numNPCs].TimeLeft = 100;

        if(Player[A].MountType == 1)
            NPC[numNPCs].Type = NPCID_GRN_BOOT;
        else if(Player[A].MountType == 2)
            NPC[numNPCs].Type = NPCID_RED_BOOT;
        else if(Player[A].MountType == 3)
            NPC[numNPCs].Type = NPCID_BLU_BOOT;

        NPC[numNPCs].Location.Height = 32;
        NPC[numNPCs].Location.Width = 32;
        NPC[numNPCs].Location.Y = Player[A].Location.Y + Player[A].Location.Height - 32;
        NPC[numNPCs].Location.X = num_t::floor(Player[A].Location.X + Player[A].Location.Width / 2 - 16);
        NPC[numNPCs].Location.SpeedY = 1;
        NPC[numNPCs].Location.SpeedX = (Player[A].Location.SpeedX - NPC[Player[A].StandingOnNPC].Location.SpeedX) * 0.8_r;
        NPC[numNPCs].CantHurt = 10;
        NPC[numNPCs].CantHurtPlayer = A;

        syncLayers_NPC(numNPCs);

        Player[A].Location.Y = Player[A].Location.Y + Player[A].Location.Height;
        Player[A].Location.Height = Physics.PlayerHeight[Player[A].Character][Player[A].State];
        Player[A].Location.Y = Player[A].Location.Y - Player[A].Location.Height;
    }
    // jump out of clown car
    else if(Player[A].Mount == 2)
    {
        Player[A].CanJump = false;
        PlaySoundSpatial(SFX_Jump, p.Location); // Jump sound
        PlaySoundSpatial(SFX_Boot, p.Location);
        Player[A].Jump = Physics.PlayerJumpHeight;
        if(Player[A].Character == 2)
            Player[A].Jump = Player[A].Jump + 3;
        if(Player[A].SpinJump)
            Player[A].Jump = Player[A].Jump - 6;
        Player[A].Mount = 0;

        s_makeVehicleMount(A);

        Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - tempSpeed;
        Player[A].Location.Height = Physics.PlayerHeight[Player[A].Character][Player[A].State];
        Player[A].Location.Width = Physics.PlayerWidth[Player[A].Character][Player[A].State];
        Player[A].Location.X = Player[A].Location.X + 64 - Physics.PlayerWidth[Player[A].Character][Player[A].State] / 2;
        Player[A].StandUp = true;
        Player[A].StandUp2 = true;
        Player[A].ForceHitSpot3 = true;
        Player[A].Dismount = 30;
        Player[A].Slope = 0;
        Player[A].Location.Y = NPC[numNPCs].Location.Y - Player[A].Location.Height;

        for(int B = 1; B <= numPlayers; B++)
        {
            if(B != A && Player[B].Mount != 2 && CheckCollision(Player[A].Location, Player[B].Location))
                Player[B].Location.Y = Player[A].Location.Y - Player[B].Location.Height;

            if(Player[B].StandingOnVehiclePlr && (g_ClonedPlayerMode || Player[B].StandingOnVehiclePlr == A))
            {
                Player[B].StandingOnNPC = numNPCs;
                Player[B].StandingOnVehiclePlr = 0;
            }
        }

        for(int B : NPCQueues::Active.no_change)
        {
            if(NPC[B].vehiclePlr == A)
            {
                NPC[B].vehiclePlr = 0;
                NPC[B].Location.SpeedY = 0;
                NPC[B].Location.Y = NPC[numNPCs].Location.Y - 0.1_n - NPC[B].vehicleYOffset;
                treeNPCUpdate(B);

                NPC[B].vehicleYOffset = 0;
                if(NPC[B].Type == NPCID_CANNONITEM)
                    NPC[B].Special = 0;
                if(NPC[B].Type == NPCID_TOOTHY)
                {
                    NPC[B].Killed = 9;
                    NPC[B].Special = 0;
                    NPCQueues::Killed.push_back(B);
                }
                else if(NPC[B].Type == NPCID_TOOTHYPIPE)
                    NPC[B].Special = 0;
            }
        }
    }
    // jump off yoshi
    else if(Player[A].Mount == 3)
    {
        UnDuck(Player[A]);
        if(Player[A].YoshiNPC > 0 || Player[A].YoshiPlayer > 0)
            YoshiSpit(A);
        Player[A].CanJump = false;
        Player[A].StandingOnNPC = 0;
        Player[A].Mount = 0;
        UpdateYoshiMusic();

        s_makePetMount(A);

        Player[A].Location.Height = Physics.PlayerHeight[Player[A].Character][Player[A].State];
        // if not swimming
        if(Player[A].Wet <= 0 || Player[A].Quicksand != 0)
        {
            PlaySoundSpatial(SFX_Jump, p.Location); // Jump sound
            Player[A].Location.SpeedY = Physics.PlayerJumpVelocity - tempSpeed;
            Player[A].Jump = Physics.PlayerJumpHeight;
            if(Player[A].Character == 2)
                Player[A].Jump = Player[A].Jump + 3;
            if(Player[A].SpinJump)
                Player[A].Jump = Player[A].Jump - 6;
        }
    }
}

void SwapCoop()
{
    if(SingleCoop == 1)
    {
        if(Player[2].Dead || Player[2].TimeToLive > 0)
            return;

        SingleCoop = 2;
    }
    else
    {
        if(Player[1].Dead || Player[1].TimeToLive > 0)
            return;
        SingleCoop = 1;
    }

    Player[1].DropRelease = false;
    Player[1].Controls.Drop = true;
    Player[2].DropRelease = false;
    Player[2].Controls.Drop = true;
    PlaySound(SFX_Camera);

    Player[SingleCoop].Immune = 50;

    if(curMusic >= 0 && curMusic != bgMusic[Player[SingleCoop].Section])
    {
        StopMusic();
        StartMusic(Player[SingleCoop].Section);
    }
}

void PlayerPush(const int A, int HitSpot)
{
    Location_t tempLocation;
    // int64_t fBlock = 0;
    // int64_t lBlock = 0;

    if(ShadowMode)
        return;

    auto &p = Player[A];

    // fBlock = FirstBlock[(p.Location.X / 32) - 1];
    // lBlock = LastBlock[((p.Location.X + p.Location.Width) / 32.0) + 1];
    // blockTileGet(p.Location, fBlock, lBlock);

    UpdatableQuery<BlockRef_t> q(p.Location, SORTMODE_COMPAT, QUERY_FLBLOCK);

    for(auto it = q.begin(); it != q.end(); ++it)
    {
        int B = *it;
        Block_t& b = **it;

        if(b.Hidden || BlockIsSizable[b.Type])
            continue;

        // Note: could also apply this for a downwards clip when colliding with an invisible block
        if(g_config.fix_player_filter_bounce && BlockCheckPlayerFilter(B, A))
            continue;

        if(BlockSlope[b.Type] == 0 && BlockSlope2[b.Type] == 0)
        {
            tempLocation = p.Location;
            tempLocation.Height -= 1;
            if(CheckCollision(tempLocation, b.Location))
            {
                if(!BlockOnlyHitspot1[b.Type] && !BlockNoClipping[b.Type])
                {
                    if(HitSpot == 2)
                    {
                        // Note: this vanilla peculiarity (Width should be subtracted) only affects a victim spat rightwards out of a pet's mouth.
                        // If spat rightwards against a wall, the victim teleports to the left through the player who spat them out.
                        // If spat leftwards against a wall (non-bugged behavior), the player who spat them out gets pushed rightwards.
                        p.Location.X = b.Location.X - p.Location.Height - 0.01_n;
                    }
                    else if(HitSpot == 3)
                        p.Location.Y = b.Location.Y + b.Location.Height + 0.01_n;
                    else if(HitSpot == 4)
                        p.Location.X = b.Location.X + b.Location.Width + 0.01_n;
                    else if(HitSpot == 1) // new-added
                        p.Location.Y = b.Location.Y - p.Location.Height - 0.01_n;
                    else if(HitSpot == 5) // non-bugged 2
                        p.Location.X = b.Location.X - p.Location.Width - 0.01_n;

                    q.update(p.Location, it);
                }
            }
        }
    }
}

void SizeCheck(Player_t &p)
{
//On Error Resume Next

// player size fix
// height
    if(p.State == 0)
        p.State = 1;
    if(p.Character == 0)
        p.Character = 1;

    if(p.Character == 5 && p.Rolling)
    {
        p.Location.set_height_floor(30);
        return;
    }

    if(p.Fairy)
    {
        if(p.Duck)
        {
            UnDuck(p);
        }

        if(p.Location.Width != 22)
            p.Location.set_width_center(22);

        if(p.Location.Height != 26)
            p.Location.set_height_floor(26);
    }
    else if(p.Mount == 0)
    {
        if(!p.Duck)
        {
            if(p.Location.Height != Physics.PlayerHeight[p.Character][p.State])
                p.Location.set_height_floor(Physics.PlayerHeight[p.Character][p.State]);
        }
        else
        {
            if(p.Location.Height != Physics.PlayerDuckHeight[p.Character][p.State])
                p.Location.set_height_floor(Physics.PlayerDuckHeight[p.Character][p.State]);
        }
    }
    else if(p.Mount == 1)
    {
        if(p.Duck)
        {
            if(p.Location.Height != Physics.PlayerDuckHeight[p.Character][2])
                p.Location.set_height_floor(Physics.PlayerDuckHeight[p.Character][2]);
        }
        else if(p.Character == 2 && p.State > 1)
        {
            if(p.Location.Height != Physics.PlayerHeight[1][2])
                p.Location.set_height_floor(Physics.PlayerHeight[p.Character][p.State]);
        }
        else
        {
            if(p.Location.Height != Physics.PlayerHeight[1][2])
                p.Location.set_height_floor(Physics.PlayerHeight[1][2]);
        }
    }
    else if(p.Mount == 2)
    {
        if(p.Location.Height != 128)
            p.Location.set_height_floor(128);
    }
    else if(p.Mount == 3)
    {
        if(!p.Duck)
        {
            if(p.State == 1)
            {
                if(p.Location.Height != Physics.PlayerHeight[1][2])
                    p.Location.set_height_floor(Physics.PlayerHeight[1][2]);
            }
            else
            {
                if(p.Location.Height != Physics.PlayerHeight[2][2])
                    p.Location.set_height_floor(Physics.PlayerHeight[2][2]);
            }
        }
        else
        {
            if(p.Location.Height != 31)
                p.Location.set_height_floor(31);
        }
    }
// width
    if(p.Mount == 2)
    {
        if(p.Location.Width != 127.9_n)
            p.Location.set_width_center(127.9_n);
    }
    else
    {
        if(p.Location.Width != Physics.PlayerWidth[p.Character][p.State])
            p.Location.set_width_center(Physics.PlayerWidth[p.Character][p.State]);
    }
}

void YoshiEatCode(const int A)
{
    int B = 0;
    // Location_t tempLocation;
    auto &p = Player[A];

    if(p.Mount == 3 && !p.Fairy)
    {
    // Shell Colors
        if(p.MountSpecial == 0)
        {
            if(p.YoshiNPC > 0)
            {
                if(NPC[p.YoshiNPC].Type == NPCID_RED_SHELL_S3 || NPC[p.YoshiNPC].Type == NPCID_RED_TURTLE_S3)
                    p.YoshiRed = true;
                if(NPC[p.YoshiNPC].Type == NPCID_RED_TURTLE_S4 || NPC[p.YoshiNPC].Type == NPCID_RED_SHELL_S4 || NPC[p.YoshiNPC].Type == NPCID_RED_SLIME)
                    p.YoshiRed = true;
                if(NPC[p.YoshiNPC].Type == NPCID_RED_TURTLE_S4 || NPC[p.YoshiNPC].Type == NPCID_RED_SHELL_S4 || NPC[p.YoshiNPC].Type == NPCID_RED_SLIME)
                    p.YoshiRed = true;
                if(NPC[p.YoshiNPC].Type == NPCID_RED_SHELL_S1 || NPC[p.YoshiNPC].Type == NPCID_RED_TURTLE_S1 || NPC[p.YoshiNPC].Type == NPCID_RED_FLY_TURTLE_S1 || NPC[p.YoshiNPC].Type == NPCID_RAINBOW_SHELL)
                    p.YoshiRed = true;

                if(NPC[p.YoshiNPC].Type == NPCID_BLU_TURTLE_S4 || NPC[p.YoshiNPC].Type == NPCID_BLU_SHELL_S4 || NPC[p.YoshiNPC].Type == NPCID_RAINBOW_SHELL || NPC[p.YoshiNPC].Type == NPCID_FLIPPED_RAINBOW_SHELL)
                {
                    if(!p.YoshiBlue)
                    {
                        p.CanFly2 = true;
                        p.CanFly2 = true;
                        p.FlyCount = 300;
                    }
                    p.YoshiBlue = true;
                }

                if(NPC[p.YoshiNPC].Type == NPCID_YEL_TURTLE_S4 || NPC[p.YoshiNPC].Type == NPCID_YEL_SHELL_S4 ||
                   NPC[p.YoshiNPC].Type == NPCID_CYAN_SLIME || NPC[p.YoshiNPC].Type == NPCID_RAINBOW_SHELL ||
                   NPC[p.YoshiNPC].Type == NPCID_FLIPPED_RAINBOW_SHELL)
                    p.YoshiYellow = true;
            }

            if(p.YoshiNPC > 0 || p.YoshiPlayer > 0)
            {
                if(p.MountType == 2 || p.MountType == 5)
                {
                    if(!p.YoshiBlue)
                    {
                        p.CanFly2 = true;
                        p.CanFly2 = true;
                        p.FlyCount = 300;
                    }
                    p.YoshiBlue = true;
                }
                if(p.MountType == 3 || p.MountType == 5)
                    p.YoshiYellow = true;
                if(p.MountType == 4 || p.MountType == 5)
                    p.YoshiRed = true;//4;
            }
        }

        if(p.YoshiBlue)
        {
            p.CanFly = true;
            p.RunCount = 10000; // multiplied by 10 vs VB6 code, since it's an int now
        }

        if(p.MountSpecial == 0)
        {
            if(NPC[p.YoshiNPC].Type == NPCID_KEY) // key check
                KeyholeCheck(A, p.Location);
            else if(NPC[p.YoshiNPC].Type == NPCID_SLIDE_BLOCK)
                NPC[p.YoshiNPC].Special = 1;

            if(p.FireBallCD > 0)
                p.FireBallCD -= 1;

            if(p.Controls.Run)
            {
                if(p.RunRelease)
                {
                    if(p.YoshiNPC == 0 && p.YoshiPlayer == 0)
                    {
                        if(p.FireBallCD == 0)
                        {
                            p.MountSpecial = 1;
                            p.YoshiTongueLength = 0;
                            p.YoshiTonugeBool = false;
                            PlaySoundSpatial(SFX_PetTongue, p.Location);
                        }
                    }
                    else
                    {
                        YoshiSpit(A);
                    }
                }
            }
        }

        if(p.MountSpecial != 0)
        {
            p.YoshiTFrameCount = 0;

            if(p.YoshiNPC > 0 || p.YoshiPlayer > 0)
                p.YoshiTonugeBool = true;

            if(!p.YoshiTonugeBool)
            {
                if(p.MountType <= 4)
                {
                    if(p.YoshiTongueLength < 64 * 0.7)
                        p.YoshiTongueLength += 6;
                    else
                        p.YoshiTongueLength += 3;
                }
                else
                {
                    if(p.YoshiTongueLength < 80 * 0.7)
                        p.YoshiTongueLength += 8; // 7.5 will be rounded into 8;
                    else
                        p.YoshiTongueLength += 4; // 3.75 will be rounded into 4
                }

//                if(p.YoshiTongueLength >= 64 && p.MountType <= 4)
//                    p.YoshiTonugeBool = true;
//                else if(p.YoshiTongueLength >= 80)
//                    p.YoshiTonugeBool = true;

                // Simplified expression than commented above
                if((p.YoshiTongueLength >= 64 && p.MountType <= 4) || (p.YoshiTongueLength >= 80))
                    p.YoshiTonugeBool = true;
            }
            else
            {
                if(p.MountType <= 4)
                {
                    if(p.YoshiTongueLength < 64 * 0.7)
                        p.YoshiTongueLength -= 6;
                    else
                        p.YoshiTongueLength -= 3;
                }
                else
                {
                    if(p.YoshiTongueLength < 80 * 0.7)
                        p.YoshiTongueLength -= 8; // 7.5;
                    else
                        p.YoshiTongueLength -= 4; // 3.75;
                }
                if(p.YoshiTongueLength <= -8)
                {
                    p.YoshiTongueLength = 0;
                    p.YoshiTonugeBool = false;
                    p.MountSpecial = 0;
                }
            }

            p.YoshiTongue.Height = 12;
            p.YoshiTongue.Width = 16;

            tempf_t TongueX = tempf_t(p.Location.X + p.Location.Width / 2);

            if(p.Controls.Up || (p.StandingOnNPC == 0 && p.Slope == 0 && p.Location.SpeedY != 0 && !p.Controls.Down))
            {
                TongueX += p.Direction * (22);
                p.YoshiTongue.Y = p.Location.Y + 8 + (p.Location.Height - 54);
                p.YoshiTongue.X = num_t(TongueX + p.YoshiTongueLength * p.Direction);
            }
            else
            {
                TongueX += p.Direction * (34);
                p.YoshiTongue.Y = p.Location.Y + 30 + (p.Location.Height - 54);
                p.YoshiTongue.X = num_t(TongueX + p.YoshiTongueLength * p.Direction);
            }

            if(p.Direction == -1)
                p.YoshiTongue.X -= 16;

            if(p.YoshiNPC == 0 && p.YoshiPlayer == 0)
            {
                YoshiEat(A);
            }

            if(p.YoshiNPC > 0)
            {
                NPC[p.YoshiNPC].Effect2 = A;
                NPC[p.YoshiNPC].Effect3 = 5;
                if(!p.YoshiTonugeBool)
                    p.YoshiTonugeBool = true;
                NPC[p.YoshiNPC].Location.X = p.YoshiTongue.X - NPC[p.YoshiNPC].Location.Width / 2 + 8 + 4 * p.Direction;
                NPC[p.YoshiNPC].Location.Y = p.YoshiTongue.Y - NPC[p.YoshiNPC].Location.Height / 2 + 6;

                if(p.YoshiNPC <= numNPCs)
                    treeNPCUpdate(p.YoshiNPC);
            }

            if(p.YoshiPlayer > 0)
            {
                Player[p.YoshiPlayer].Effect = PLREFF_NO_COLLIDE;
                Player[p.YoshiPlayer].Effect2 = A;
                Player[p.YoshiPlayer].Location.X = p.YoshiTongue.X + (p.YoshiTongue.Width - Player[p.YoshiPlayer].Location.Width) / 2;
                Player[p.YoshiPlayer].Location.Y = p.YoshiTongue.Y + (p.YoshiTongue.Height - Player[p.YoshiPlayer].Location.Height) / 2;
                if(Player[p.YoshiPlayer].Location.Y + Player[p.YoshiPlayer].Location.Height > p.Location.Y + p.Location.Height)
                    Player[p.YoshiPlayer].Location.Y = p.Location.Y + p.Location.Height - Player[p.YoshiPlayer].Location.Height;
            }
        }
        if(p.MountSpecial == 0 && p.YoshiNPC > 0)
        {
            p.YoshiTFrameCount = 1;

            if(NPC[p.YoshiNPC].Type == NPCID_GRN_TURTLE_S3 || NPC[p.YoshiNPC].Type == NPCID_GRN_FLY_TURTLE_S3)
                NPC[p.YoshiNPC].Type = NPCID_GRN_SHELL_S3;
            else if(NPC[p.YoshiNPC].Type == NPCID_RED_TURTLE_S3 || NPC[p.YoshiNPC].Type == NPCID_RED_FLY_TURTLE_S3)
                NPC[p.YoshiNPC].Type = NPCID_RED_SHELL_S3;
            else if(NPC[p.YoshiNPC].Type == NPCID_GLASS_TURTLE)
                NPC[p.YoshiNPC].Type = NPCID_GLASS_SHELL;
            else if(NPC[p.YoshiNPC].Type == NPCID_BIG_TURTLE)
                NPC[p.YoshiNPC].Type = NPCID_BIG_SHELL;
            else if(NPC[p.YoshiNPC].Type >= NPCID_GRN_TURTLE_S4 && NPC[p.YoshiNPC].Type <= NPCID_YEL_TURTLE_S4)
                NPC[p.YoshiNPC].Type = NPCID(NPC[p.YoshiNPC].Type + 4);
            else if(NPC[p.YoshiNPC].Type >= NPCID_GRN_FLY_TURTLE_S4 && NPC[p.YoshiNPC].Type <= NPCID_YEL_FLY_TURTLE_S4)
            {
                NPC[p.YoshiNPC].Type = NPCID(NPC[p.YoshiNPC].Type - 8);
                NPC[p.YoshiNPC].Special = 0;
            }
            else if(NPC[p.YoshiNPC].Type == NPCID_GRN_TURTLE_S1 || NPC[p.YoshiNPC].Type == NPCID_GRN_FLY_TURTLE_S1)
            {
                NPC[p.YoshiNPC].Type = NPCID_GRN_SHELL_S1;
                NPC[p.YoshiNPC].Location.Height = 28;
            }
            else if(NPC[p.YoshiNPC].Type == NPCID_RED_TURTLE_S1 || NPC[p.YoshiNPC].Type == NPCID_RED_FLY_TURTLE_S1)
            {
                NPC[p.YoshiNPC].Type = NPCID_RED_SHELL_S1;
                NPC[p.YoshiNPC].Location.Height = 28;
            }

            NPC[p.YoshiNPC].Location.Height = NPC[p.YoshiNPC]->THeight;
            if((NPC[p.YoshiNPC]->IsGrabbable || NPC[p.YoshiNPC]->IsAShell || NPC[p.YoshiNPC].Type == NPCID_SPIT_BOSS_BALL || NPCIsABot(NPC[p.YoshiNPC]) || NPC[p.YoshiNPC].Type == NPCID_RAINBOW_SHELL || NPC[p.YoshiNPC].Type == NPCID_WALK_BOMB_S2 || NPC[p.YoshiNPC].Type == NPCID_WALK_BOMB_S3 || NPC[p.YoshiNPC].Type == NPCID_LIT_BOMB_S3) && (NPC[p.YoshiNPC].Type != NPCID_HIT_CARRY_FODDER))
            {
                if(NPC[p.YoshiNPC].Type == NPCID_WALK_BOMB_S2)
                    NPC[p.YoshiNPC].Special = 450;
                if(NPC[p.YoshiNPC].Type == NPCID_BOMB)
                    NPC[p.YoshiNPC].Special = 250;
                if(NPC[p.YoshiNPC].Type == NPCID_WALK_BOMB_S3 || NPC[p.YoshiNPC].Type == NPCID_LIT_BOMB_S3)
                {
                    NPC[p.YoshiNPC].Special = 250;
                    NPC[p.YoshiNPC].Type = NPCID_LIT_BOMB_S3;
                    NPC[p.YoshiNPC].Location.Height = NPC[p.YoshiNPC]->THeight;
                }

                NPC[p.YoshiNPC].Effect = NPCEFF_PET_INSIDE;
                NPC[p.YoshiNPC].Effect2 = A;

                if(NPC[p.YoshiNPC].Active)
                {
                    NPC[p.YoshiNPC].Active = false;
                    NPCQueues::update(p.YoshiNPC);
                }

                if(NPC[p.YoshiNPC].Type == NPCID_TOOTHYPIPE)
                {
                    NPC[p.YoshiNPC].Special = 0;
                    NPC[p.YoshiNPC].Special2 = 0;
                }
            }
            else if(p.MountType == 7 && !NPC[p.YoshiNPC]->IsABonus)
            {
                B = iRand(9);
                NPC[p.YoshiNPC].Type = NPCID(NPCID_VEGGIE_2 + B);
                if(NPC[p.YoshiNPC].Type == NPCID_VEGGIE_RANDOM)
                    NPC[p.YoshiNPC].Type = NPCID_VEGGIE_1;
                NPC[p.YoshiNPC].Location.set_width_center(NPC[p.YoshiNPC]->TWidth);
                NPC[p.YoshiNPC].Location.set_height_center(NPC[p.YoshiNPC]->THeight);
                NPC[p.YoshiNPC].Effect = NPCEFF_PET_INSIDE;
                NPC[p.YoshiNPC].Effect2 = A;

                NPCQueues::Unchecked.push_back(p.YoshiNPC);

                if(NPC[p.YoshiNPC].Active)
                {
                    NPC[p.YoshiNPC].Active = false;
                    NPCQueues::update(p.YoshiNPC);
                }
            }
            else if(p.MountType == 8 && !NPC[p.YoshiNPC]->IsABonus)
            {
                NPC[p.YoshiNPC].Type = NPCID_ICE_BLOCK;
                NPC[p.YoshiNPC].Location.set_width_center(NPC[p.YoshiNPC]->TWidth);
                NPC[p.YoshiNPC].Location.set_height_center(NPC[p.YoshiNPC]->THeight);
                NPC[p.YoshiNPC].Effect = NPCEFF_PET_INSIDE;
                NPC[p.YoshiNPC].Effect2 = A;

                NPCQueues::Unchecked.push_back(p.YoshiNPC);

                if(NPC[p.YoshiNPC].Active)
                {
                    NPC[p.YoshiNPC].Active = false;
                    NPCQueues::update(p.YoshiNPC);
                }
            }
            else
            {
                if(NPC[p.YoshiNPC]->IsABonus)
                {
                    TouchBonus(A, p.YoshiNPC);
                    p.YoshiNPC = 0;
                }
                else
                {
                    MoreScore(NPC[p.YoshiNPC]->Score, NPC[p.YoshiNPC].Location, p.Multiplier);
                    NPC[p.YoshiNPC].Killed = 9;
                    NPCQueues::Killed.push_back(p.YoshiNPC);

                    p.YoshiNPC = 0;
                    p.FireBallCD = 30;
                    Coins += 1;

                    if(Coins >= 100)
                        Got100Coins();

                    PlaySoundSpatial(SFX_PetSwallow, p.Location);
                }
            }

            if(p.YoshiNPC != 0)
            {
                NPCQueues::Unchecked.push_back(p.YoshiNPC);

                if(p.YoshiNPC <= numNPCs)
                    treeNPCUpdate(p.YoshiNPC);
            }
        }
        else if(p.MountSpecial == 0 && p.YoshiPlayer > 0)
        {
            Player[p.YoshiPlayer].CurMazeZone = 0;
            Player[p.YoshiPlayer].Effect = PLREFF_PET_INSIDE;
            Player[p.YoshiPlayer].Effect2 = A;
            Player[p.YoshiPlayer].Location.X = p.Location.X + (p.Location.Width - Player[p.YoshiPlayer].Location.Width) / 2;
            Player[p.YoshiPlayer].Location.Y = p.Location.Y + (p.Location.Height - Player[p.YoshiPlayer].Location.Height) / 2;
            p.YoshiTFrameCount = 1;
        }
    }
}

void RespawnPlayer(int A, int Direction, num_t CenterX, num_t StopY, const vScreen_t& target_screen)
{
    Player[A].Location.Width = Physics.PlayerWidth[Player[A].Character][Player[A].State];
    Player[A].Location.Height = Physics.PlayerHeight[Player[A].Character][Player[A].State];
    Player[A].Frame = 1;
    Player[A].Direction = Direction;
    Player[A].Dead = false;
    Player[A].Location.SpeedX = 0;
    Player[A].Location.SpeedY = 0;
    Player[A].Effect = PLREFF_RESPAWN;
    // location where player stops flashing
    Player[A].RespawnY = StopY - Player[A].Location.Height;
    Player[A].Location.Y = -target_screen.Y - Player[A].Location.Height;
    Player[A].Location.X = CenterX - Player[A].Location.Width / 2;
}

void RespawnPlayerTo(int A, int TargetPlayer)
{
    num_t CenterX = Player[TargetPlayer].Location.X + Player[TargetPlayer].Location.Width / 2;

    // don't lose a player when it targets a player who is already respawning
    num_t StopY;
    if(Player[TargetPlayer].Effect == PLREFF_RESPAWN)
        StopY = Player[TargetPlayer].RespawnY + Player[TargetPlayer].Location.Height;
    else if(Player[TargetPlayer].Mount == 2)
        StopY = Player[TargetPlayer].Location.Y;
    else
        StopY = Player[TargetPlayer].Location.Y + Player[TargetPlayer].Location.Height;

    // technically this would fix a vanilla bug (possible weird effects after Player 2 dies, Player 1 goes through Warp, Player 2 respawns)
    //   so I will do it where it only affects the new code.
    // Player[A].Section = Player[TargetPlayer].Section;

    // respawn at top of vScreen 1 in SMBX dynamic splitscreen, otherwise at top of target player's vScreen
    int screen_idx_A = ScreenIdxByPlayer(A);
    int screen_idx_tgt = ScreenIdxByPlayer(TargetPlayer);
    const Screen_t& screen = Screens[screen_idx_A];
    const vScreen_t& target_vscreen = (screen.Type == ScreenTypes::Dynamic) ? screen.vScreen(1) : vScreenByPlayer(TargetPlayer);

    // force a modern respawn when players are on different screens (clients), or when a player was added during a cutscene
    bool force_modern_respawn = (screen_idx_A != screen_idx_tgt) || ForcedControls;

    RespawnPlayer(A, Player[TargetPlayer].Direction, CenterX, StopY, target_vscreen);

    // if TargetPlayer is scrolling in warp, we can't spawn them directly.
    if(PlayerScrollingInWarp(Player[TargetPlayer]) || Player[TargetPlayer].CurMazeZone || force_modern_respawn)
    {
        // Give player A wings in shared screen
        if(screen.Type == ScreenTypes::SharedScreen || Player[TargetPlayer].CurMazeZone || force_modern_respawn)
        {
            Player[A].Location.Y -= 100;
            Player[A].Dead = true;
            Player[A].Effect = PLREFF_COOP_WINGS;
            Player[A].Effect2 = 0;
            Player[A].RespawnY = 0;
        }
        // respawn them to the target player's warp otherwise
        else
        {
            const auto& warp = Warp[Player[TargetPlayer].Warp];
            const auto& warp_exit = (Player[TargetPlayer].WarpBackward) ? warp.Entrance : warp.Exit;
            const auto warp_exit_dir = (Player[TargetPlayer].WarpBackward) ? warp.Direction : warp.Direction2;

            Player[A].Location.X = warp_exit.X + (warp_exit.Width - Player[A].Location.Width) / 2;

            if(Player[TargetPlayer].Effect == PLREFF_WARP_PIPE && warp_exit_dir == 1)
                Player[A].RespawnY = warp_exit.Y;
            else
                Player[A].RespawnY = warp_exit.Y + warp_exit.Height - Player[A].Location.Height;

            Player[A].Location.Y = Player[A].RespawnY - target_vscreen.Height * 3 / 4;
        }
    }
}

void StealBonus()
{
    int A = 0;
    int B = 0;
    int C = 0;
    UNUSED(C);

    // dead players steal life
    if(BattleMode || GameMenu || GameOutro || g_ClonedPlayerMode)
        return;

    // NOTE: legacy code here accepted TimeToLive <= 0, CheckLiving() requires TimeToLive == 0. TimeToLive should never be negative.
    int alive = CheckLiving();
    if(!alive)
        return;

    for(A = 1; A <= numPlayers; A++)
    {
        if(Player[A].Dead && Player[A].Effect != PLREFF_COOP_WINGS)
        {
            // find other player
            if((g_config.modern_lives_system || Lives > 0) && LevelMacro == LEVELMACRO_OFF)
            {
                if(Player[A].Controls.Jump || Player[A].Controls.Run)
                {
                    B = CheckNearestLiving(A);

                    if(g_config.modern_lives_system)
                    {
                        g_100s--;

                        if(g_100s < 0)
                            Score = 0;
                    }
                    else
                        Lives -= 1;

                    Player[A].State = 1;
                    Player[A].Hearts = 1;
                    RespawnPlayerTo(A, B);
                    PlaySoundSpatial(SFX_DropItem, Player[B].Location);
                }
            }
        }
    }
}

void ClownCar()
{
    // for when the player is in the clown car
    // int A = 0;
    // int B = 0;
//    int C = 0;
    // NPC_t blankNPC;

    for(int A = 1; A <= numPlayers; A++) // Code for running the Koopa Clown Car
    {
        // commenting out because:
        //   (1) misplaced; (2) doesn't work with abstract controls
        // logic moved to Controls::Update()

        // if(numPlayers > 2 && GameMenu == false && LevelMacro == LEVELMACRO_OFF && nPlay.Online == false)
        //     Player[A].Controls = Player[1].Controls;

        Player_t& p = Player[A];
        Location_t& pLoc = p.Location;

        // this code should only apply to living players on the vehicle mount
        if(!(p.Mount == 2 && p.Dead == false && p.TimeToLive == 0))
            continue;

        // vehicle movement code
        if(p.Effect == PLREFF_NORMAL)
        {
            if(p.Controls.Left)
            {
                pLoc.SpeedX -= 0.1_n;

                if(pLoc.SpeedX > 0)
                    pLoc.SpeedX -= 0.15_n;
            }
            else if(p.Controls.Right)
            {
                pLoc.SpeedX += 0.1_n;

                if(pLoc.SpeedX < 0)
                    pLoc.SpeedX += 0.15_n;
            }
            else
            {
                if(pLoc.SpeedX > 0.2_n)
                    pLoc.SpeedX -= 0.05_n;
                else if(pLoc.SpeedX < -0.2_n)
                    pLoc.SpeedX += 0.05_n;
                else
                    pLoc.SpeedX = 0;
            }

            if(p.Controls.Up)
            {
                pLoc.SpeedY -= 0.1_n;

                if(pLoc.SpeedY > 0)
                    pLoc.SpeedY -= 0.2_n;
            }
            else if(p.Controls.Down)
            {
                pLoc.SpeedY += 0.2_n;

                if(pLoc.SpeedY < 0)
                    pLoc.SpeedY += 0.2_n;
            }
            else
            {
                if(pLoc.SpeedY > 0.1_n)
                    pLoc.SpeedY -= 0.1_n;
                else if(pLoc.SpeedY < -0.1_n)
                    pLoc.SpeedY += 0.1_n;
                else
                    pLoc.SpeedY = 0;
            }

            if(pLoc.SpeedX > 4)
                pLoc.SpeedX = 4;
            else if(pLoc.SpeedX < -4)
                pLoc.SpeedX = -4;
            if(pLoc.SpeedY > 10)
                pLoc.SpeedY = 10;
            else if(pLoc.SpeedY < -4)
                pLoc.SpeedY = -4;
        }

        // create playerTemp NPC for the Vehicle
        numNPCs++;
        NPC[numNPCs] = NPC_t();
        NPC[numNPCs].playerTemp = true;
        NPC[numNPCs].Type = NPCID_VEHICLE;
        NPC[numNPCs].Variant = A; // newly-added to allow setting StandingOnVehiclePlr
        NPC[numNPCs].Active = true;
        NPC[numNPCs].TimeLeft = 100;
        NPC[numNPCs].Location = pLoc;

        if(p.Effect != PLREFF_NORMAL)
        {
            NPC[numNPCs].Location.SpeedX = 0;
            NPC[numNPCs].Location.SpeedY = 0;
        }

        NPC[numNPCs].Location.Y += NPC[numNPCs].Location.SpeedY;
        NPC[numNPCs].Location.X += NPC[numNPCs].Location.SpeedX;
        NPC[numNPCs].Section = p.Section;
        syncLayers_NPC(numNPCs);

        // update other players' StandingOnNPC
        for(int B = 1; B <= numPlayers; B++)
        {
            if(Player[B].StandingOnVehiclePlr && (g_ClonedPlayerMode || Player[B].StandingOnVehiclePlr == A))
            {
                Player[B].StandingOnNPC = numNPCs;
                Player[B].Location.X += num_t(p.mountBump);

                if(Player[B].Effect != PLREFF_NORMAL)
                {
                    Player[B].Location.Y = pLoc.Y - Player[B].Location.Height;
                    Player[B].Location.X += pLoc.SpeedX;
                }
            }
        }

        // handle NPCs on the vehicle
        for(int B : NPCQueues::Active.may_insert)
        {
            // only want non-toothy NPCs on A's vehicle
            if(!(NPC[B].vehiclePlr == A && NPC[B].Type != NPCID_TOOTHY))
                continue;

            if(p.Effect == PLREFF_NORMAL)
                NPC[B].Location.X += pLoc.SpeedX + num_t(p.mountBump);

            NPC[B].TimeLeft = 100;
            NPC[B].Location.SpeedY = pLoc.SpeedY;
            NPC[B].Location.SpeedX = 0;

            if(p.Effect != PLREFF_NORMAL)
                NPC[B].Location.SpeedY = 0;

            NPC[B].Location.Y = pLoc.Y + NPC[B].Location.SpeedY + 0.1_n - NPC[B].vehicleYOffset;
            treeNPCUpdate(B);

            // extend toothy pipe
            if(p.Controls.Run && NPC[B].Type == NPCID_TOOTHYPIPE)
            {
                // create toothy if it doesn't exist already
                if(NPC[B].Special == 0)
                {
                    NPC[B].Special = 1;
                    numNPCs++;
                    NPC[B].Special2 = numNPCs;

                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].Section = p.Section;
                    NPC[numNPCs].TimeLeft = 100;
                    NPC[numNPCs].Type = NPCID_TOOTHY;
                    NPC[numNPCs].Location.Height = 32;
                    NPC[numNPCs].Location.Width = 48;
                    NPC[numNPCs].Special = A;
                    NPC[numNPCs].Special2 = B;
                    NPC[numNPCs].Direction = NPC[B].Direction;

                    if(NPC[numNPCs].Direction == 1)
                        NPC[numNPCs].Frame = 2;
                    syncLayers_NPC(numNPCs);
                }

                // update toothy's position
                for(int C : NPCQueues::Active.no_change)
                {
                    if(NPC[C].Type == NPCID_TOOTHY && NPC[C].Special == A && NPC[C].Special2 == B)
                    {
                        NPC[C].vehiclePlr = A;
                        NPC[C].Projectile = true;
                        NPC[C].Direction = NPC[B].Direction;

                        if(NPC[C].Direction > 0)
                            NPC[C].Location.X = NPC[B].Location.X + 32;
                        else
                            NPC[C].Location.X = NPC[B].Location.X - NPC[C].Location.Width;

                        NPC[C].Location.Y = NPC[B].Location.Y;
                        NPC[C].TimeLeft = 100;
                        treeNPCUpdate(C);
                        break;
                    }
                }
            }

            // check if NPC should stay on the vehicle
            bool still_on_vehicle = false;
            Location_t query_loc = NPC[B].Location;
            query_loc.Y += query_loc.Height + 0.1_n;
            query_loc.X += 0.5_n;
            query_loc.Width -= 1;
            query_loc.Height = 1;

            for(int C : treeNPCQuery(query_loc, SORTMODE_NONE))
            {
                if(B != C && (NPC[C].vehiclePlr == A || NPC[C].playerTemp))
                {
                    if(CheckCollision(query_loc, NPC[C].Location))
                    {
                        still_on_vehicle = true;
                        break;
                    }
                }
            }

            if(!still_on_vehicle)
            {
                NPC[B].vehiclePlr = 0;
                NPC[B].vehicleYOffset = 0;
            }
            else
                NPC[B].Location.SpeedX = 0;
        }
    }
}

void WaterCheck(const int A)
{
    Location_t tempLocation;
    auto &p = Player[A];

    if(p.Wet > 0)
    {
        p.Wet -= 1;
        if(!InvincibilityTime)
            p.Multiplier = 0;
    }

    if(p.Quicksand > 0)
    {
        p.Quicksand -= 1;
        if(p.Quicksand == 0)
            p.WetFrame = false;
    }

    if(UnderWater[p.Section])
        p.Wet = 2;

    if(p.Wet > 0)
    {
        p.SpinJump = false;
        p.WetFrame = true;
        p.Slide = false;
    }
    else if(p.WetFrame)
    {
        if(p.Location.SpeedY >= 3.1_n || p.Location.SpeedY <= -3.1_n)
        {
            p.WetFrame = false;
            tempLocation.Width = 32;
            tempLocation.Height = 32;
            tempLocation.X = p.Location.X + (p.Location.Width - tempLocation.Width) / 2;
            tempLocation.Y = p.Location.Y + p.Location.Height - tempLocation.Height;
            NewEffect(EFFID_WATER_SPLASH, tempLocation);
        }
    }

    bool already_in_maze = p.CurMazeZone;

    Location_t query_loc = p.Location;

    // check the hitbox the player will get when leaving water if in aquatic swim state
    if(p.AquaticSwim)
        query_loc.set_height_floor(Physics.PlayerHeight[p.Character][p.State]);

    for(int B : treeWaterQuery(query_loc, SORTMODE_NONE))
    {
        if(!Water[B].Hidden)
        {
            if(CheckCollision(query_loc, Water[B].Location))
            {
                if(Water[B].Type == PHYSID_MAZE)
                {
                    if(p.CurMazeZone && (already_in_maze || p.CurMazeZone < B))
                        continue;

                    if(p.Mount == 2 || p.Fairy)
                        continue;

                    if(query_loc.Y + query_loc.Height - Physics.PlayerGravity < Water[B].Location.Y)
                        continue;

                    p.CurMazeZone = B;

                    PhysEnv_Maze_PickDirection(p.Location, B, p.MazeZoneStatus);

                    std::array<bool, 4> maze_controls = {Player[A].Controls.Left, Player[A].Controls.Up, Player[A].Controls.Right, Player[A].Controls.Down};

                    if(maze_controls[p.MazeZoneStatus] || (p.Rolling && !maze_controls[0] && !maze_controls[1] && !maze_controls[2] && !maze_controls[3]))
                        PlaySoundSpatial(SFX_HeroDash, p.Location);
                    else
                        p.CurMazeZone = 0;

                    continue;
                }

                if(p.Wet == 0 && p.Mount != 2)
                {
                    p.FlyCount = 0;
                    p.CanFly = false;
                    p.CanFly2 = false;

                    if(!p.Controls.Jump && !p.Controls.AltJump)
                        p.CanJump = true;

                    if(p.State == PLR_STATE_CYCLONE)
                        p.DoubleJump = true;

                    p.SwimCount = 0;

                    if(p.Location.SpeedY > 0.5_n)
                        p.Location.SpeedY = 0.5_n;
                    if(p.Location.SpeedY < -1.5_n)
                        p.Location.SpeedY = -1.5_n;

                    if(!p.WetFrame && !p.Rolling)
                    {
                        if(p.Location.SpeedX > 0.5_n)
                            p.Location.SpeedX = 0.5_n;
                        if(p.Location.SpeedX < -0.5_n)
                            p.Location.SpeedX = -0.5_n;
                    }

                    if(p.Location.SpeedY > 0 && !p.WetFrame)
                    {
                        tempLocation.Width = 32;
                        tempLocation.Height = 32;
                        tempLocation.X = p.Location.X + (p.Location.Width - tempLocation.Width) / 2;
                        tempLocation.Y = p.Location.Y + p.Location.Height - tempLocation.Height;
                        NewEffect(EFFID_WATER_SPLASH, tempLocation);
                    }
                }

                p.Wet = 2;
                p.SpinJump = false;

                if(Water[B].Type == PHYSID_QUICKSAND)
                    p.Quicksand = 3;
            }
        }
    }

    if(p.Mount == 2)
    {
        p.Wet = 0;
        p.WetFrame = false;
    }

    if(p.Wet == 1)
    {
        if(p.Location.SpeedY < 0 && (p.Controls.AltJump || p.Controls.Jump) && !p.Controls.Down)
        {
            p.Jump = 12;
            p.Location.SpeedY = Physics.PlayerJumpVelocity;

            if(p.State == PLR_STATE_AQUATIC && p.AquaticSwim)
                p.Jump += 8;
        }
    }
    else if(p.Wet == 2 && p.Quicksand == 0)
    {
        if(iRand(100) >= 97)
        {
            num_t dx = dRand();
            num_t dy = dRand();
            if(p.Direction == 1)
                tempLocation = newLoc(p.Location.X + p.Location.Width - dx * 8, p.Location.Y + 4 + dy * 8, 8, 8);
            else
                tempLocation = newLoc(p.Location.X - 8 + dx * 8, p.Location.Y + 4 + dy * 8, 8, 8);
            if(!UnderWater[p.Section])
            {
                for(int B : treeWaterQuery(tempLocation, SORTMODE_NONE))
                {
                    if(CheckCollision(Water[B].Location, tempLocation))
                    {
                        // NewNpc set to 0 (pop it when it's no longer colliding with water)
                        NewEffect(EFFID_AIR_BUBBLE, tempLocation, 1, ShadowMode);
                        break;
                    }
                }
            }
            else
            {
                // NewNpc set to 1 (keep it on forever)
                if(NewEffect(EFFID_AIR_BUBBLE, tempLocation, 1, ShadowMode))
                    Effect[numEffects].NewNpc = 1;
            }
        }
    }
}

// checks if player A is in the mouth of the pet of any player on the screen
bool InOnscreenPet(int plr_A, const Screen_t& screen)
{
    const Player_t& p = Player[plr_A];

    // in the mouth of any player's Pet?
    if(p.Effect == PLREFF_PET_INSIDE)
    {
        // check it really is a player on this screen
        for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
        {
            int B = screen.players[plr_i];

            if(p.Effect2 == B && Player[B].YoshiPlayer == plr_A)
                return true;
        }
    }

    return false;
}

// removes a player from a pet's mouth (so that their effect can be changed successfully)
void RemoveFromPet(int plr_A)
{
    Player_t& p = Player[plr_A];

    if(p.Effect == PLREFF_PET_INSIDE && p.Effect2 > 0 && p.Effect2 <= numPlayers && Player[p.Effect2].YoshiPlayer == plr_A)
        Player[p.Effect2].YoshiPlayer = 0;

    // set to no-collide mode with the other player (but this will be changed at the calling code)
    p.Effect = PLREFF_NO_COLLIDE;
}

void PlayerCollide(const int A)
{
    Location_t tempLocation;
    Location_t tempLocation3;
    int HitSpot = 0;
    auto &p1 = Player[A];

// Check player collisions
    for(int B = 1; B <= numPlayers; B++)
    {
        auto &p2 = Player[B];

        if(B != A && !p2.Dead && p2.TimeToLive == 0 &&
           (p2.Effect == PLREFF_NORMAL || p2.Effect == PLREFF_WARP_PIPE) &&
           !(p2.Mount == 2 || p1.Mount == 2) &&
           (!BattleMode || (p1.Immune == 0 && p2.Immune == 0)))
        {
            tempLocation = p1.Location;

            if(p1.StandingOnNPC != 0 && !FreezeNPCs)
                tempLocation.SpeedY = NPC[p1.StandingOnNPC].Location.SpeedY;

            tempLocation3 = p2.Location;

            if(p2.StandingOnNPC != 0 && !FreezeNPCs)
                tempLocation3.SpeedY = NPC[p2.StandingOnNPC].Location.SpeedY;

            if(CheckCollision(tempLocation, tempLocation3))
            {
                HitSpot = FindCollision(tempLocation, tempLocation3);
                if(HitSpot == 5)
                {
                    if(p1.StandUp2 && p1.Location.Y > p2.Location.Y)
                        HitSpot = 3;
                    else if(p2.StandUp2 && p1.Location.Y < p2.Location.Y)
                        HitSpot = 1;
                }

                if(BattleMode)
                {
                    if(p2.SlideKill)
                    {
                        HitSpot = 0;
                        PlayerHurt(A);
                    }
                    if(p1.SlideKill)
                    {
                        HitSpot = 0;
                        PlayerHurt(B);
                    }
                    if(p1.Stoned && (p1.Location.SpeedX > 3 || p1.Location.SpeedX < -3 || HitSpot == 1))
                    {
                        PlayerHurt(B);
                    }
                    else if(p2.Stoned && (p2.Location.SpeedX > 3 || p2.Location.SpeedX < -3 || HitSpot == 3))
                    {
                        PlayerHurt(A);
                    }
                }

                if(p1.Stoned || p2.Stoned)
                    HitSpot = 0;

                if(HitSpot == 2 || HitSpot == 4)
                {
                    if(!g_ClonedPlayerMode)
                        PlaySoundSpatial(SFX_Skid, p1.Location);
                    tempLocation = p1.Location;
                    p1.Location.SpeedX = p2.Location.SpeedX;
                    p2.Location.SpeedX = tempLocation.SpeedX;
                    p1.Bumped = true;
                    p2.Bumped = true;
                }
                else if(HitSpot == 1 || HitSpot == 3)
                {
                    Player_t& top_player = (HitSpot == 1) ? p1 : p2;
                    Player_t& bottom_player = (HitSpot == 1) ? p2 : p1;
                    int top_player_idx = (HitSpot == 1) ? A : B;

                    if(!g_ClonedPlayerMode)
                        PlaySoundSpatial(SFX_Stomp, top_player.Location);

                    if(!top_player.CurMazeZone)
                    {
                        top_player.Location.Y = bottom_player.Location.Y - top_player.Location.Height - 0.1_n;
                        PlayerPush(top_player_idx, 3);
                    }

                    top_player.Location.SpeedY = Physics.PlayerJumpVelocity;

                    top_player.Jump = Physics.PlayerHeadJumpHeight;

                    // yes, it's an SMBX 1.3 bug... :'(
                    if(top_player.Character == 2)
                        p1.Jump += 3;
                    if(top_player.SpinJump)
                        p1.Jump -= 6;

                    bottom_player.Jump = 0;
                    if(bottom_player.Location.SpeedY <= 0)
                        bottom_player.Location.SpeedY = 0.1_n;
                    bottom_player.CanJump = false;
                    NewEffect(EFFID_WHACK, newLoc(top_player.Location.X + top_player.Location.Width / 2 - 16, top_player.Location.Y + top_player.Location.Height - 16));
                }
                else if(HitSpot == 5)
                {
                    if(p1.Location.to_right_of(p2.Location))
                    {
                        p1.Bumped2 = 1;
                        p2.Bumped2 = -1;
                    }
                    else if(p2.Location.to_right_of(p1.Location))
                    {
                        p1.Bumped2 = -1;
                        p2.Bumped2 = 1;
                    }
                    else if(iRand(2) == 0)
                    {
                        p1.Bumped2 = -1;
                        p2.Bumped2 = 1;
                    }
                    else
                    {
                        p1.Bumped2 = 1;
                        p2.Bumped2 = -1;
                    }
                    // If Player(A).Bumped2 < -1 Then Player(A).Bumped2 = -1 - Rnd
                    // If Player(A).Bumped2 > 1 Then Player(A).Bumped2 = 1 + Rnd
                    // If Player(B).Bumped2 < -1 Then Player(B).Bumped2 = -1 - Rnd
                    // If Player(B).Bumped2 > 1 Then Player(B).Bumped2 = 1 + Rnd
                }

                if(HitSpot == 1)
                {
                    if((p1.MazeZoneStatus & 3) == MAZE_DIR_DOWN)
                        p1.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                    if((p2.MazeZoneStatus & 3) == MAZE_DIR_UP)
                        p2.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                }
                else if(HitSpot == 2)
                {
                    if((p1.MazeZoneStatus & 3) == MAZE_DIR_LEFT)
                        p1.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                    if((p2.MazeZoneStatus & 3) == MAZE_DIR_RIGHT)
                        p2.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                }
                else if(HitSpot == 3)
                {
                    if((p1.MazeZoneStatus & 3) == MAZE_DIR_UP)
                        p1.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                    if((p2.MazeZoneStatus & 3) == MAZE_DIR_DOWN)
                        p2.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                }
                else if(HitSpot == 4)
                {
                    if((p1.MazeZoneStatus & 3) == MAZE_DIR_RIGHT)
                        p1.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                    if((p2.MazeZoneStatus & 3) == MAZE_DIR_LEFT)
                        p2.MazeZoneStatus |= MAZE_PLAYER_FLIP;
                }

                if(BattleMode)
                {
                    if(HitSpot == 1 && p1.Mount == 1)
                    {
                        PlayerHurt(B);
                    }
                    else if(HitSpot == 3 && p2.Mount == 1)
                    {
                        PlayerHurt(A);
                    }
                }
            }
        }
    }
}

void PlayerGrabCode(const int A, bool DontResetGrabTime)
{
    // this code handles all the grab related stuff
    // for grabbing something while walking into it, refer to the NPC collision code in sub UpdatePlayer()
    Location_t tempLocation;
    int LayerNPC = 0;
    int B = 0;
    bool tempBool = false;
    num_t lyrX = 0;
    num_t lyrY = 0;
    auto &p = Player[A];

    if(p.StandingOnNPC != 0 && p.HoldingNPC == 0)
    {
        if(NPC[p.StandingOnNPC]->GrabFromTop)
        {
            if(((p.Controls.Run && p.Controls.Down) || ((p.Controls.Down || p.Controls.Run) && p.GrabTime > 0)) && (p.RunRelease || p.GrabTime > 0) && p.TailCount == 0)
            {
                if((p.GrabTime >= 12 && p.Character < 3) || (p.GrabTime >= 16 && p.Character == 3) || (p.GrabTime >= 8 && p.Character == 4))
                {
                    p.Location.SpeedX = (num_t)p.GrabSpeed;
                    p.GrabSpeed = 0;
                    p.GrabTime = 0;
                    p.TailCount = 0;

                    if(p.Character == 1 || p.Character == 2)
                    {
                        UnDuck(Player[A]);
                    }

                    p.HoldingNPC = p.StandingOnNPC;
                    p.Location.SpeedY = NPC[p.StandingOnNPC].Location.SpeedY;
                    if(p.Location.SpeedY == 0)
                        p.Location.SpeedY = 0.01_n;
                    p.CanJump = false;
                    if(NPC[p.StandingOnNPC]->IsAShell)
                        p.Location.SpeedX = NPC[p.StandingOnNPC].Location.SpeedX;
                    NPC[p.StandingOnNPC].HoldingPlayer = A;
                    NPC[p.StandingOnNPC].CantHurt = Physics.NPCCanHurtWait;
                    NPC[p.StandingOnNPC].CantHurtPlayer = A;
                    NPC[p.StandingOnNPC].Direction = p.Direction;
                    NPCFrames(p.StandingOnNPC);

                    // Unbury code (v3)
                    if(NPC[p.StandingOnNPC].Type == NPCID_ITEM_BURIED)
                    {
                        p.Location.SpeedX += NPC[p.StandingOnNPC].Location.SpeedX;

                        NPC[p.StandingOnNPC].Direction = p.Direction;

                        NPCUnbury(p.StandingOnNPC, 3);

                        NPCFrames(p.StandingOnNPC);

                        if(p.StandingOnNPC > 0 && p.StandingOnNPC <= numNPCs)
                        {
                            NPCQueues::Unchecked.push_back(p.StandingOnNPC);
                            treeNPCUpdate(p.StandingOnNPC);
                        }

                        p.StandingOnNPC = 0;
                    }
                }
                else
                {
                    if(p.GrabTime == 0)
                    {
                        if(NPC[p.StandingOnNPC].Type == NPCID_ITEM_BURIED || NPCIsVeggie(NPC[p.StandingOnNPC]))
                            PlaySoundSpatial(SFX_Grab2, p.Location);
                        else
                            PlaySoundSpatial(SFX_Grab, p.Location);
                        p.FrameCount = 0;
                        p.GrabSpeed = (numf_t)p.Location.SpeedX;
                    }
                    p.Location.SpeedX = 0;
                    p.GrabTime += 1;
                    p.Slide = false;
                }
            }
            else
                p.GrabTime = 0;
        }
        else
            p.GrabTime = 0;
    }
    else if(!DontResetGrabTime)
        p.GrabTime = 0;

    if(p.HoldingNPC > numNPCs) // Can't hold an NPC that is dead
        p.HoldingNPC = 0;

    if(p.HoldingNPC > 0)
    {
        lyrX = NPC[p.HoldingNPC].Location.X;
        lyrY = NPC[p.HoldingNPC].Location.Y;
        LayerNPC = p.HoldingNPC;
        if(NPC[p.HoldingNPC].Type == NPCID_FLY_BLOCK || NPC[p.HoldingNPC].Type == NPCID_FLY_CANNON)
        {
            if(p.Jump == 0)
                NPC[p.HoldingNPC].Special = 1;
            else if(p.Jump > 0 && NPC[p.HoldingNPC].Special == 1)
            {
                // IMPORTANT: this was truncated until v1.3.8-dev. The new behavior is accurate to VB6. Confirm that it does not cause issues.
                // FIXME: simplify this -- add a new vb6round_div2 call
                p.Jump = num_t::vb6round(p.Jump * 1.5_n);
                NPC[p.HoldingNPC].Special = 0;
            }
            if(NPC[p.HoldingNPC].Type == NPCID_FLY_CANNON)
            {
                NPC[p.HoldingNPC].Special2 += 1;
                if(p.SpinJump)
                {
                    if(NPC[p.HoldingNPC].Special3 == 0)
                        NPC[p.HoldingNPC].Special3 = p.Direction;
                    else if(NPC[p.HoldingNPC].Special3 == -p.Direction && NPC[p.HoldingNPC].Special2 >= 25)
                    {
                        NPC[p.HoldingNPC].Special3 = p.Direction;
                        NPC[p.HoldingNPC].Special2 = 100;
                    }
                    else if(NPC[p.HoldingNPC].Special2 >= 25)
                        NPC[p.HoldingNPC].Special2 = 25;

                }


                if(NPC[p.HoldingNPC].Special2 == 20 || NPC[p.HoldingNPC].Special2 == 40 || NPC[p.HoldingNPC].Special2 == 60 || NPC[p.HoldingNPC].Special2 == 80)
                {
                    if(NPC[p.HoldingNPC].Special2 == 20 || NPC[p.HoldingNPC].Special2 == 60)
                        B = 1;
                    else if(NPC[p.HoldingNPC].Special2 == 40)
                        B = 2;
                    else if(NPC[p.HoldingNPC].Special2 == 80)
                    {
                        B = 3;
                        NPC[p.HoldingNPC].Special2 = 0;
                    }

                        PlaySoundSpatial(SFX_FlameThrower, p.Location);

                    // For B = 1 To 3
                        numNPCs++;
                        NPC[numNPCs].CantHurt = 10000;
                        NPC[numNPCs].CantHurtPlayer = A;
                        NPC[numNPCs].BattleOwner = A;
                        NPC[numNPCs].Type = NPCID_PET_FIRE;
                        NPC[numNPCs].Location.Width = NPC[numNPCs]->TWidth;
                        NPC[numNPCs].Location.Height = NPC[numNPCs]->THeight;
                        NPC[numNPCs].Active = true;
                        NPC[numNPCs].TimeLeft = NPC[p.HoldingNPC].TimeLeft;
                        NPC[numNPCs].Layer = LAYER_SPAWNED_NPCS;
                        NPC[numNPCs].Location.Y = NPC[p.HoldingNPC].Location.Y + NPC[p.HoldingNPC].Location.Height - NPC[numNPCs].Location.Height;
                        NPC[numNPCs].Direction = p.Direction;

                        if(NPC[numNPCs].Direction == 1)
                            NPC[numNPCs].Location.X = NPC[p.HoldingNPC].Location.X + NPC[p.HoldingNPC].Location.Width * 2 - 8;
                        else
                            NPC[numNPCs].Location.X = NPC[p.HoldingNPC].Location.X - NPC[numNPCs].Location.Width - NPC[p.HoldingNPC].Location.Width + 8;

                        if(B == 1)
                            NPC[numNPCs].Location.SpeedX = 7 * NPC[numNPCs].Direction;
                        else if(B == 2)
                        {
                            NPC[numNPCs].Location.SpeedX = 6.5_n * NPC[numNPCs].Direction;
                            NPC[numNPCs].Location.SpeedY = -1.5_n;
                        }
                        else
                        {
                            NPC[numNPCs].Location.SpeedX = 6.5_n * NPC[numNPCs].Direction;
                            NPC[numNPCs].Location.SpeedY = 1.5_n;
                        }

                        NPC[numNPCs].Location.SpeedX += p.Location.SpeedX / 3.5_ri;

                        NPC[numNPCs].Projectile = true;
                        NPC[numNPCs].Frame = EditorNPCFrame(NPC[numNPCs].Type, NPC[numNPCs].Direction);

                        syncLayers_NPC(numNPCs);
                    // Next B
                }
            }
        }

        if(NPC[p.HoldingNPC].Type == NPCID_ICE_CUBE)
            NPC[p.HoldingNPC].Special3 = 0;
        NPC[p.HoldingNPC].TimeLeft = Physics.NPCTimeOffScreen;
        NPC[p.HoldingNPC].Effect = NPCEFF_NORMAL;
        NPC[p.HoldingNPC].CantHurt = Physics.NPCCanHurtWait;
        NPC[p.HoldingNPC].CantHurtPlayer = A;
        if(NPCIsVeggie(NPC[p.HoldingNPC]))
            NPC[p.HoldingNPC].CantHurt = 1000;

        if(p.Controls.Run || p.ForceHold > 0)
        {
            // fix a graphical bug where the NPC would stutter in the player's hands
            num_t use_w = (g_config.fix_visual_bugs) ? num_t::round(NPC[p.HoldingNPC].Location.Width) : NPC[p.HoldingNPC].Location.Width;

        // hold above head
            if(p.Character == 3 || p.Character == 4 || (p.Duck))
            {
                NPC[p.HoldingNPC].Bouce = true;
                NPC[p.HoldingNPC].Location.X = p.Location.X + (p.Location.Width - use_w) / 2;

                if(p.Character == 3) // princess peach
                {
                    if(p.State == 1)
                        NPC[p.HoldingNPC].Location.Y = p.Location.Y - NPC[p.HoldingNPC].Location.Height;
                    else
                        NPC[p.HoldingNPC].Location.Y = p.Location.Y - NPC[p.HoldingNPC].Location.Height + 6;
                }
                else // toad
                {
                    if(p.State == 1)
                        NPC[p.HoldingNPC].Location.Y = p.Location.Y - NPC[p.HoldingNPC].Location.Height + 6;
                    else
                    {
                        if(NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL || NPC[p.HoldingNPC].Type == NPCID_PLR_ICEBALL)
                        {
                            NPC[p.HoldingNPC].Location.X += dRand() * 4 - 2;
                            NPC[p.HoldingNPC].Location.Y = p.Location.Y - NPC[p.HoldingNPC].Location.Height - 4 + dRand() * 4 - 2;
                        }
                        else
                            NPC[p.HoldingNPC].Location.Y = p.Location.Y - NPC[p.HoldingNPC].Location.Height + 10;
                    }
                }
            }
            else
            {
                if(p.Direction > 0)
                    NPC[p.HoldingNPC].Location.X = p.Location.X + Physics.PlayerGrabSpotX[p.Character][p.State];
                else
                    NPC[p.HoldingNPC].Location.X = p.Location.X + p.Location.Width - Physics.PlayerGrabSpotX[p.Character][p.State] - use_w;

                NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;
            }

            if(NPC[p.HoldingNPC].Type == NPCID_TOOTHYPIPE && !FreezeNPCs)
            {
                if(NPC[p.HoldingNPC].Special == 0)
                {
                    NPC[p.HoldingNPC].Special = 1;
                    NPC[p.HoldingNPC].Special2 = numNPCs + 1;
                    numNPCs++;
                    NPC[numNPCs].Active = true;
                    NPC[numNPCs].Section = p.Section;
                    NPC[numNPCs].TimeLeft = 100;
                    NPC[numNPCs].Type = NPCID_TOOTHY;
                    NPC[numNPCs].Location.Height = 32;
                    NPC[numNPCs].Location.Width = 48;
                    NPC[numNPCs].Special = A;
                    if(p.Direction > 0)
                        NPC[numNPCs].Frame = 2;
                    syncLayers_NPC(numNPCs);
                }

                for(int B : NPCQueues::Active.no_change)
                {
                    if(NPC[B].Type == NPCID_TOOTHY && NPC[B].Special == A)
                    {
                        NPC[B].CantHurt = 10;
                        NPC[B].CantHurtPlayer = A;
                        NPC[B].Projectile = true;
                        NPC[B].Direction = p.Direction;
                        NPC[B].TimeLeft = 100;
                        if(p.Direction > 0)
                            NPC[B].Location.X = NPC[p.HoldingNPC].Location.X + 32;
                        else
                            NPC[B].Location.X = NPC[p.HoldingNPC].Location.X - NPC[B].Location.Width;
                        NPC[B].Location.Y = NPC[p.HoldingNPC].Location.Y;
                    }
                }
            }
        }
        else
        {
            NPC[p.HoldingNPC].Location.SpeedX = 0;
            NPC[p.HoldingNPC].Location.SpeedY = 0;
            // this means that the NPC will be killed if it is inside a wall next frame
            NPC[p.HoldingNPC].WallDeath = 5;

            if(NPC[p.HoldingNPC].Type == NPCID_HEAVY_THROWER)
                NPCHit(p.HoldingNPC, 3, p.HoldingNPC);

            if(NPC[p.HoldingNPC]->IsACoin && !p.Controls.Down) // Smoke effect for coins
                NewEffect(EFFID_SMOKE_S3, NPC[p.HoldingNPC].Location);

            if(p.Controls.Up && !NPC[p.HoldingNPC]->IsACoin && NPC[p.HoldingNPC].Type != NPCID_BULLET) // Throw the npc up
            {
                if(NPC[p.HoldingNPC]->IsAShell || NPC[p.HoldingNPC].Type == NPCID_SLIDE_BLOCK || NPC[p.HoldingNPC].Type == NPCID_ICE_CUBE)
                {
                    if(p.Controls.Left || p.Controls.Right) // Up and forward
                    {
                        NPC[p.HoldingNPC].Location.SpeedX = Physics.NPCShellSpeed * p.Direction;
                        NPC[p.HoldingNPC].Location.SpeedY = -7;
                        tempLocation.Height = 0;
                        tempLocation.Width = 0;
                        tempLocation.Y = (p.Location.Y + NPC[p.HoldingNPC].Location.Y * 4) / 5;
                        tempLocation.X = (p.Location.X + NPC[p.HoldingNPC].Location.X * 4) / 5;
                        if(NPC[p.HoldingNPC].Type != NPCID_ICE_CUBE)
                            NewEffect(EFFID_STOMP_INIT, tempLocation);
                    }
                    else
                    {
                        NPC[p.HoldingNPC].Location.SpeedY = -Physics.NPCShellSpeedY;
                        tempLocation.Height = 0;
                        tempLocation.Width = 0;
                        tempLocation.Y = (p.Location.Y + NPC[p.HoldingNPC].Location.Y * 4) / 5;
                        tempLocation.X = (p.Location.X + NPC[p.HoldingNPC].Location.X * 4) / 5;
                        if(NPC[p.HoldingNPC].Type != NPCID_ICE_CUBE)
                            NewEffect(EFFID_STOMP_INIT, tempLocation);
                    }
                }
                else
                {
                    if(p.Controls.Left || p.Controls.Right) // Up and forward
                    {
                        if(p.Character == 3 || p.Character == 4)
                        {
                            NPC[p.HoldingNPC].Location.SpeedX = 5 * p.Direction;
                            NPC[p.HoldingNPC].Location.SpeedY = -6;
                        }
                        else
                        {
                            NPC[p.HoldingNPC].Location.SpeedY = -8;
                            NPC[p.HoldingNPC].Location.SpeedX = 3 * p.Direction;
                        }
                    }
                    else
                    {
                        NPC[p.HoldingNPC].Location.SpeedY = -10;
                        if(p.Character == 3) // peach
                            NPC[p.HoldingNPC].Location.SpeedY = -9;
                    }
                }

                if(NPCIsVeggie(NPC[p.HoldingNPC]) || NPC[p.HoldingNPC].Type == NPCID_BLU_GUY || NPC[p.HoldingNPC].Type == NPCID_RED_GUY || NPC[p.HoldingNPC].Type == NPCID_JUMPER_S3 || NPC[p.HoldingNPC].Type == NPCID_BIRD || NPC[p.HoldingNPC].Type == NPCID_RED_SPIT_GUY || NPC[p.HoldingNPC].Type == NPCID_BLU_SPIT_GUY || NPC[p.HoldingNPC].Type == NPCID_GRY_SPIT_GUY || NPC[p.HoldingNPC].Type == NPCID_BOMB || NPC[p.HoldingNPC].Type == NPCID_WALK_BOMB_S2 || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_A || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_B || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_C || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_D || NPC[p.HoldingNPC].Type == NPCID_SPIT_BOSS_BALL || NPC[p.HoldingNPC].Type == NPCID_TIMER_S2 || NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL || NPC[p.HoldingNPC].Type == NPCID_PLR_ICEBALL || NPC[p.HoldingNPC].Type == NPCID_DOOR_MAKER || NPC[p.HoldingNPC].Type == NPCID_CHAR3_HEAVY)
                    PlaySoundSpatial(SFX_Throw, p.Location);
                else
                    PlaySoundSpatial(SFX_ShellHit, p.Location);

                NPC[p.HoldingNPC].Projectile = true;
            }
            else if(p.Controls.Down && NPC[p.HoldingNPC].Type != NPCID_BULLET) // Drop
            {
                tempBool = false;
                if((p.Direction == 1 && p.Location.SpeedX > 3) || (p.Direction == -1 && p.Location.SpeedX < -3))
                    tempBool = true;

                if(tempBool && NPC[p.HoldingNPC].Type == NPCID_FLIPPED_RAINBOW_SHELL)
                {
                    p.Location.SpeedX = 0;
                    NPC[p.HoldingNPC].Location.SpeedX = Physics.NPCShellSpeed * p.Direction;
                    NPC[p.HoldingNPC].Projectile = true;
                    NPC[p.HoldingNPC].CantHurt = 0;
                    NPC[p.HoldingNPC].CantHurtPlayer = 0;
                    NPC[p.HoldingNPC].HoldingPlayer = 0;
                    PlaySoundSpatial(SFX_ShellHit, p.Location);
                    NewEffect(EFFID_WHIP, newLoc(NPC[p.HoldingNPC].Location.X, NPC[p.HoldingNPC].Location.Y + NPC[p.HoldingNPC].Location.Height - 16));
                    NPC[p.HoldingNPC].Location.X = p.Location.X + (p.Location.Width - NPC[p.HoldingNPC].Location.Width) / 2;
                    NPC[p.HoldingNPC].Location.Y = p.Location.Y + p.Location.Height - NPC[p.HoldingNPC].Location.Height;
                    p.Location.Y = NPC[p.HoldingNPC].Location.Y - p.Location.Height;
                    NPC[p.HoldingNPC].Location.SpeedY = p.Location.SpeedY;
                    p.StandingOnNPC = p.HoldingNPC;
                    p.HoldingNPC = 0;
                    p.ShellSurf = true;
                    p.Jump = 0;
                    p.Location.SpeedY = 10;
                }
                else
                {
                    if(p.Direction == 1)
                        NPC[p.HoldingNPC].Location.X = p.Location.X + p.Location.Width + 0.1_n;
                    else
                        NPC[p.HoldingNPC].Location.X = p.Location.X - NPC[p.HoldingNPC].Location.Width - 0.1_n;
                    NPC[p.HoldingNPC].Projectile = false;
                    if(NPC[p.HoldingNPC].Type == NPCID_VINE_BUG)
                        NPC[p.HoldingNPC].Projectile = true;
                    if(p.StandingOnNPC != 0)
                        NPC[p.HoldingNPC].Location.Y += NPC[p.StandingOnNPC].Location.SpeedY;
                }
                if(NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL || NPC[p.HoldingNPC].Type == NPCID_PLR_ICEBALL || NPC[p.HoldingNPC].Type == NPCID_CHAR3_HEAVY)
                {
                    NPC[p.HoldingNPC].Location.X = p.Location.X + (p.Location.Width - NPC[p.HoldingNPC].Location.Width) / 2;
                    if(p.State == 1)
                        NPC[p.HoldingNPC].Location.Y = p.Location.Y - NPC[p.HoldingNPC].Location.Height;
                    else
                        NPC[p.HoldingNPC].Location.Y = p.Location.Y - NPC[p.HoldingNPC].Location.Height + 6;
                    PlaySoundSpatial(SFX_Throw, p.Location);
                    NPC[p.HoldingNPC].Location.SpeedX = 0;
                    NPC[p.HoldingNPC].Location.SpeedY = 20;
                }
            }
            else if(!NPC[p.HoldingNPC]->IsAShell &&
                    NPC[p.HoldingNPC].Type != NPCID_SLIDE_BLOCK &&
                    NPC[p.HoldingNPC].Type != NPCID_ICE_CUBE &&
                    !NPC[p.HoldingNPC]->IsACoin) // if not a shell or a coin the kick it up and forward
            {
            // peach
                if(p.Character == 3)
                {
                    if(NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL || NPC[p.HoldingNPC].Type == NPCID_PLR_ICEBALL || (p.Location.SpeedY != 0 && p.StandingOnNPC == 0 && p.Slope == 0))
                    {
                        NPC[p.HoldingNPC].Location.SpeedX = 5 * p.Direction + p.Location.SpeedX * 0.3_r;
                        NPC[p.HoldingNPC].Location.SpeedY = 3;
                    }
                    else
                    {
                        NPC[p.HoldingNPC].Location.SpeedX = 5 * p.Direction + p.Location.SpeedX * 0.3_r;
                        NPC[p.HoldingNPC].Location.SpeedY = 0;
                    }
            // toad
                }
                else if(p.Character == 4)
                {
                    if(NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL || NPC[p.HoldingNPC].Type == NPCID_PLR_ICEBALL || (p.Location.SpeedY != 0 && p.StandingOnNPC == 0 && p.Slope == 0))
                    {
                        NPC[p.HoldingNPC].Location.SpeedX = 6 * p.Direction + p.Location.SpeedX * 0.4_r;
                        NPC[p.HoldingNPC].Location.SpeedY = 3.5_n;
                    }
                    else
                    {
                        NPC[p.HoldingNPC].Location.SpeedX = 6 * p.Direction + p.Location.SpeedX * 0.4_r;
                        NPC[p.HoldingNPC].Location.SpeedY = 0;
                        NPC[p.HoldingNPC].CantHurt = NPC[p.HoldingNPC].CantHurt * 2;
                    }
                }
                else
                {
                    NPC[p.HoldingNPC].Location.SpeedX = 5 * p.Direction;
                    NPC[p.HoldingNPC].Location.SpeedY = -6;
                }
                NPC[p.HoldingNPC].Projectile = true;
                if(NPCIsVeggie(NPC[p.HoldingNPC]) || NPC[p.HoldingNPC].Type == NPCID_BLU_GUY || NPC[p.HoldingNPC].Type == NPCID_RED_GUY || NPC[p.HoldingNPC].Type == NPCID_JUMPER_S3 || NPC[p.HoldingNPC].Type == NPCID_BIRD || NPC[p.HoldingNPC].Type == NPCID_RED_SPIT_GUY || NPC[p.HoldingNPC].Type == NPCID_BLU_SPIT_GUY || NPC[p.HoldingNPC].Type == NPCID_GRY_SPIT_GUY || NPC[p.HoldingNPC].Type == NPCID_BOMB || NPC[p.HoldingNPC].Type == NPCID_WALK_BOMB_S2 || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_A || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_B || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_C || NPC[p.HoldingNPC].Type == NPCID_CARRY_BLOCK_D || NPC[p.HoldingNPC].Type == NPCID_SPIT_BOSS_BALL || NPC[p.HoldingNPC].Type == NPCID_TIMER_S2 || NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL || NPC[p.HoldingNPC].Type == NPCID_PLR_ICEBALL || NPC[p.HoldingNPC].Type == NPCID_DOOR_MAKER || NPC[p.HoldingNPC].Type == NPCID_CHAR3_HEAVY)
                    PlaySoundSpatial(SFX_Throw, p.Location);
                else if(NPC[p.HoldingNPC].Type == NPCID_BULLET)
                    PlaySoundSpatial(SFX_Bullet, p.Location);
                else
                    PlaySoundSpatial(SFX_ShellHit, p.Location);
            }
            else if(NPC[p.HoldingNPC]->IsAShell)
            {
                NPC[p.HoldingNPC].Location.SpeedY = 0;
                NPC[p.HoldingNPC].Location.SpeedX = 0;
                NPC[p.HoldingNPC].HoldingPlayer = 0;
                NPC[p.HoldingNPC].CantHurt = 0;
                NPC[p.HoldingNPC].CantHurtPlayer = 0;
                NPC[p.HoldingNPC].Projectile = false;
                NPCHit(p.HoldingNPC, 1, A);
                tempLocation.Height = 0;
                tempLocation.Width = 0;
                tempLocation.Y = (p.Location.Y + NPC[p.HoldingNPC].Location.Y * 4) / 5;
                tempLocation.X = (p.Location.X + NPC[p.HoldingNPC].Location.X * 4) / 5;
                NewEffect(EFFID_STOMP_INIT, tempLocation);
            }
            else if(NPC[p.HoldingNPC].Type == NPCID_ICE_CUBE)
            {
                PlaySoundSpatial(SFX_ShellHit, p.Location);
                NPC[p.HoldingNPC].Location.SpeedX = Physics.NPCShellSpeed * p.Direction;
                NPC[p.HoldingNPC].CantHurt = Physics.NPCCanHurtWait;
                NPC[p.HoldingNPC].CantHurtPlayer = A;
                NPC[p.HoldingNPC].Projectile = true;
            }
            if(NPC[p.HoldingNPC].Type == NPCID_BOMB && NPC[p.HoldingNPC].Location.SpeedX != 0)
            {
                NPC[p.HoldingNPC].Location.SpeedX += p.Location.SpeedX / 2;
                if(p.StandingOnNPC != 0)
                    NPC[p.HoldingNPC].Location.SpeedX += NPC[p.StandingOnNPC].Location.SpeedX;
            }
            if(NPC[p.HoldingNPC].Type == NPCID_PLR_FIREBALL && NPC[p.HoldingNPC].Special == 4) // give toad fireballs a little spunk
            {
                if(NPC[p.HoldingNPC].Location.SpeedY < 0)
                    NPC[p.HoldingNPC].Location.SpeedY += NPC[p.HoldingNPC].Location.SpeedY / 10;
            }
            if(NPC[p.HoldingNPC].Type == NPCID_CHAR3_HEAVY)
            {
                if(p.Location.SpeedX != 0 && NPC[p.HoldingNPC].Location.SpeedX != 0)
                    NPC[p.HoldingNPC].Location.SpeedX += p.Location.SpeedX / 2;
            }

            // this block was misleadingly left-indented in VB6, but its nesting in C++ is accurate to its nesting in VB6, and now I'm fixing the indentation to match the nesting -- ds-sloth
            if(NPC[p.HoldingNPC].Type == NPCID_CHAR4_HEAVY)
            {
                NPC[p.HoldingNPC].Special5 = A;
                NPC[p.HoldingNPC].Special4 = p.Direction; // Special6 in SMBX 1.3
                NPC[p.HoldingNPC].Location.SpeedY = -8;
                NPC[p.HoldingNPC].Location.SpeedX = 12 * p.Direction + p.Location.SpeedX;
                NPC[p.HoldingNPC].Projectile = true;
            }

            PlayerThrownNpcMazeCheck(p, NPC[p.HoldingNPC]);

            NPC[p.HoldingNPC].HoldingPlayer = 0;
            p.HoldingNPC = 0;
        }

        if(LayerNPC > 0 && LayerNPC <= numNPCs && (NPC[LayerNPC].Location.X != lyrX || NPC[LayerNPC].Location.Y != lyrY))
            treeNPCUpdate(LayerNPC);
    }

    if(LayerNPC > 0)
    {
        int B = NPC[LayerNPC].AttLayer;
        if(B != LAYER_NONE && B != LAYER_DEFAULT)
            SetLayerSpeed(B, NPC[LayerNPC].Location.X - lyrX, NPC[LayerNPC].Location.Y - lyrY, false);
    }
}

void LinkFrame(const int A)
{
    LinkFrame(Player[A]);
}

void LinkFrame(Player_t &p)
{
    Location_t tempLocation;
    //auto &p = Player[A];

    p.MountOffsetY = 0;

    // Hurt frame
    if(p.FrameCount == -10)
    {
        if(p.SwordPoke == 0)
        {
            if(p.Location.SpeedY == 0 ||
               p.StandingOnNPC != 0 ||
               p.Slope != 0 || p.Wet > 0 ||
               p.Immune == 0) // Hurt Frame
               p.FrameCount = 0;
            else
            {
                p.Frame = 11;
                return;
            }
        }
        else
            p.FrameCount = 0;
    }

    if(p.Stoned)
    {
        p.Frame = 12;
        if(p.Location.SpeedX != 0)
        {
            if(p.Location.SpeedY == 0 || p.Slope > 0 || p.StandingOnNPC != 0)
            {
                if(p.SlideCounter <= 0)
                {
                    p.SlideCounter = 2 + iRand_round(2);
                    tempLocation.Y = p.Location.Y + p.Location.Height - 5;
                    tempLocation.X = p.Location.X + p.Location.Width / 2 - 4;
                    NewEffect(EFFID_SKID_DUST, tempLocation, 1, ShadowMode);
                }
            }
        }
        return;
    }

    if(p.Rolling)
    {
        p.FrameCount = (p.FrameCount + 1) & 15;
        p.Frame = 12 + p.FrameCount / 4;

        if(p.State == PLR_STATE_POLAR)
            p.Frame = 11;

        return;
    }

    if(!LevelSelect && p.Effect == PLREFF_NORMAL && p.FireBallCD == 0)
    {
        if(p.Controls.Left)
            p.Direction = -1;
        if(p.Controls.Right)
            p.Direction = 1;
    }

    if(p.Fairy)
        return;

    if(p.SwordPoke < 0) // Drawing back
    {
        if(!p.Duck)
            p.Frame = 6;
        else
            p.Frame = 8;
    }
    else if(p.SwordPoke > 0) // Stabbing
    {
        if(!p.Duck)
            p.Frame = 7;
        else
            p.Frame = 8;
    }
    else if(p.Mount == 2) // Clown Car
    {
        p.Frame = 1;
        p.MountFrame = SpecialFrame[2];
        if(p.Direction == 1)
            p.MountFrame += 4;
    }
    else if(p.Duck) // Ducking
        p.Frame = 5;
    else if(p.WetFrame && p.Location.SpeedY != 0 && p.Slope == 0 && p.StandingOnNPC == 0 && !p.Duck && p.Quicksand == 0) // Link is swimming
    {
        if(p.Location.SpeedY < 0.5_n || p.Frame != 3)
        {
            if(p.Frame != 1 && p.Frame != 2 && p.Frame != 3 && p.Frame != 4)
                p.FrameCount = 6;

            p.FrameCount += 1;

            if(p.FrameCount < 6)
                p.Frame = 3;
            else if(p.FrameCount < 12)
                p.Frame = 2;
            else if(p.FrameCount < 18)
                p.Frame = 3;
            else if(p.FrameCount < 24)
                p.Frame = 1;
            else
            {
                p.Frame = 3;
                p.FrameCount = 0;
            }
        }
        else
            p.Frame = 3;
    }
    else if(p.Location.SpeedY != 0 && p.StandingOnNPC == 0 && p.Slope == 0 && !(p.Quicksand > 0 && p.Location.SpeedY > 0)) // Jumping/falling
    {
        if(CanWallJump && (p.Pinched.Left2 == 2 || p.Pinched.Right4 == 2) && (!p.SlippyWall || p.State == PLR_STATE_POLAR) && !(p.State == PLR_STATE_CYCLONE && !p.DoubleJump))
        {
            s_makeDust(p, 8, tempLocation);
            p.Frame = 11;
        }
        else if(p.Location.SpeedY < 0)
        {
            if(p.Controls.Up)
                p.Frame = 10;
            else
                p.Frame = 5;
        }
        else
        {
            if(p.Controls.Down)
                p.Frame = 9;
            else
                p.Frame = 3;
        }
    }
    else if(p.Location.SpeedX == 0 || (p.Slippy && !p.Controls.Left && !p.Controls.Right)) // Standing
        p.Frame = 1;
    else // Running
    {
        p.FrameCount += 1;

        if(p.Location.SpeedX > Physics.PlayerWalkSpeed - 1.5_n || p.Location.SpeedX < -Physics.PlayerWalkSpeed + 1.5_n)
            p.FrameCount += 1;

        if(p.Location.SpeedX > Physics.PlayerWalkSpeed || p.Location.SpeedX < -Physics.PlayerWalkSpeed)
            p.FrameCount += 1;

        if(p.Location.SpeedX > Physics.PlayerWalkSpeed + 1 || p.Location.SpeedX < -Physics.PlayerWalkSpeed - 1)
            p.FrameCount += 1;

        if(p.Location.SpeedX > Physics.PlayerWalkSpeed + 2 || p.Location.SpeedX < -Physics.PlayerWalkSpeed - 2)
            p.FrameCount += 1;

        if(p.FrameCount >= 8)
        {
            p.FrameCount = 0;
            p.Frame -= 1;
        }

        if(p.Frame <= 0)
            p.Frame = 4;
        else if(p.Frame >= 5)
            p.Frame = 1;

        if(p.Location.SpeedX >= Physics.PlayerRunSpeed * 0.9_n || p.Location.SpeedX <= -Physics.PlayerRunSpeed * 0.9_n)
        {
            if(p.SlideCounter <= 0)
            {
                PlaySoundSpatial(SFX_HeroDash, p.Location);
                p.SlideCounter = 2 + iRand_round(2);
                tempLocation.Y = p.Location.Y + p.Location.Height - 4;

                if(p.Location.SpeedX < 0)
                    tempLocation.X = p.Location.X + p.Location.Width / 2 - 6 - 4;
                else
                    tempLocation.X = p.Location.X + p.Location.Width / 2 + 6 - 4;

                NewEffect(EFFID_SKID_DUST, tempLocation, 1, ShadowMode);
            }
        }
    }
}

void PlayerEffects(const int A)
{
    int B = 0;
    // float C = 0;
    // float D = 0;
    bool tempBool = false;
    auto &p = Player[A];

    if(p.Effect != PLREFF_WAITING && p.Fairy)
    {
        p.Fairy = false;
        SizeCheck(Player[A]);
    }

    p.TailCount = 0;
    // p.Pinched1 = 0;
    // p.Pinched2 = 0;
    // p.Pinched3 = 0;
    // p.Pinched4 = 0;
    // p.NPCPinched = 0;
    p.Pinched.reset_non_strict();
    p.SwordPoke = 0;

    if(!p.YoshiBlue && p.Effect != PLREFF_STONE)
    {
        p.CanFly = false;
        p.CanFly2 = false;
        p.RunCount = 0;
    }

    p.Immune2 = false;

    // in shared screen mode, give wings to players who are above the screen waiting to exit a warp
    if(PlayerWaitingInWarp(p))
    {
        Screen_t& s = ScreenByPlayer(A);
        if(s.Type == ScreenTypes::SharedScreen && (p.Location.Y + p.Location.Height < -vScreenByPlayer(A).Y))
        {
            int O = CheckNearestLiving(A);

            if(O && p.Location.Y < Player[O].Location.Y - 300)
            {
                SharedScreenAvoidJump_Pre(s);
                p.Dead = true;
                p.Effect = PLREFF_COOP_WINGS;
                p.Effect2 = 0;
                SizeCheck(p);
                SharedScreenAvoidJump_Post(s, 0);
                return;
            }
        }
    }

    if(p.Effect == PLREFF_TURN_BIG) // Player growing effect
    {
        p.Frame = 1;
        p.Effect2 += 1;
        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 1)
            {
                p.State = 2;
                if(p.Mount == 0)
                {
                    p.Location.X += (-Physics.PlayerWidth[p.Character][2] + Physics.PlayerWidth[p.Character][1]) / 2;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
                else if(p.Mount == 3)
                {
                    YoshiHeight(A);
                }
                else if(p.Character == 2 && p.Mount != 2)
                {
                    p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
            }
            else
            {
                p.State = 1;
                if(p.Mount == 0)
                {
                    p.Location.X += (-Physics.PlayerWidth[p.Character][1] + Physics.PlayerWidth[p.Character][2]) / 2;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][1] + Physics.PlayerHeight[p.Character][2];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][1];
                }
                else if(p.Mount == 3)
                {
                    YoshiHeight(A);
                }
                else if(p.Character == 2 && p.Mount != 2)
                {
                    p.Location.Y += -Physics.PlayerHeight[1][2] + Physics.PlayerHeight[2][2];
                    p.Location.Height = Physics.PlayerHeight[1][2];
                }
            }
        }
        if(p.Effect2 >= 50 && p.State == 2)
        {
            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
    else if(p.Effect == PLREFF_TURN_SMALL) // Player shrinking effect
    {
        if(p.Duck)
        {
            p.StandUp = true; // Fixes a block collision bug
            p.Duck = false;
            p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            p.Location.Y += -Physics.PlayerHeight[p.Character][p.State] + Physics.PlayerDuckHeight[p.Character][p.State];
        }
        p.Frame = 1;
        p.Effect2 += 1;
        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 1)
            {
                p.State = 2;
                if(p.Mount == 3)
                {
                    YoshiHeight(A);
                }
                else if(p.Mount != 2)
                {
                    p.Location.X += (-Physics.PlayerWidth[p.Character][2] + Physics.PlayerWidth[p.Character][1]) / 2;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
            }
            else
            {
                p.State = 1;
                if(p.Mount == 3)
                {
                    YoshiHeight(A);
                }
                else if(p.Mount != 2)
                {
                    p.Location.X += (-Physics.PlayerWidth[p.Character][1] + Physics.PlayerWidth[p.Character][2]) / 2;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][1] + Physics.PlayerHeight[p.Character][2];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][1];
                }
            }
        }
        if(p.Effect2 >= 50)
        {
            if(p.State == 2)
            {
                p.State = 1;
                if(p.Mount != 2)
                {
                    p.Location.X += (-Physics.PlayerWidth[p.Character][1] + Physics.PlayerWidth[p.Character][2]) / 2;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][1] + Physics.PlayerHeight[p.Character][2];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
            }
            p.Immune = 150;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            // If numPlayers <= 2 Then DropBonus A
        }
    }
    // logic combined across all powerup-to-big effects
    else if(p.Effect >= PLREFF_STATE_TO_BIG && p.Effect < PLREFF_STATE_TO_BIG_END)
    {
        int prev_state = p.Effect - PLREFF_STATE_TO_BIG;

        if(p.Duck)
        {
            p.StandUp = true; // Fixes a block collision bug
            p.Duck = false;
            p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            p.Location.Y += -Physics.PlayerHeight[p.Character][p.State] + Physics.PlayerDuckHeight[p.Character][p.State];
        }

        p.Frame = 1;
        p.Effect2 += 1;

        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 2)
                p.State = prev_state;
            else
                p.State = 2;
        }

        if(p.Effect2 >= 50)
        {
            if(p.State == prev_state)
                p.State = 2;

            p.Immune = 150;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            // If numPlayers <= 2 Then DropBonus A
        }
    }
#if 0
    else if(p.Effect == PLREFF_FIRE_TO_BIG) // Player losing firepower
    {
        if(p.Duck)
        {
            p.StandUp = true; // Fixes a block collision bug
            p.Duck = false;
            p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            p.Location.Y += -Physics.PlayerHeight[p.Character][p.State] + Physics.PlayerDuckHeight[p.Character][p.State];
        }
        p.Frame = 1;
        p.Effect2 += 1;
        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 2)
                p.State = 3;
            else
                p.State = 2;
        }
        if(p.Effect2 >= 50)
        {
            if(p.State == 3)
                p.State = 2;
            p.Immune = 150;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            // If numPlayers <= 2 Then DropBonus A
        }
    }
    else if(p.Effect == PLREFF_ICE_TO_BIG) // Player losing icepower
    {
        if(p.Duck)
        {
            p.StandUp = true; // Fixes a block collision bug
            p.Duck = false;
            p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            p.Location.Y += -Physics.PlayerHeight[p.Character][p.State] + Physics.PlayerDuckHeight[p.Character][p.State];
        }

        p.Frame = 1;
        p.Effect2 += 1;

        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 2)
                p.State = 7;
            else
                p.State = 2;
        }

        if(p.Effect2 >= 50)
        {
            if(p.State == 7)
                p.State = 2;
            p.Immune = 150;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            // If numPlayers <= 2 Then DropBonus A
        }
    }
#endif
    else if(p.Effect == PLREFF_WARP_PIPE) // Warp effect
        PlayerEffectWarpPipe(A);
    else if(p.Effect == PLREFF_WARP_DOOR) // Door effect
        PlayerEffectWarpDoor(A);
    else if(p.Effect == PLREFF_WAITING) // Holding Pattern
    {
        // tracking a player that got an exit
        if(p.Effect2 < 0)
        {
            p.Location.X = Player[-p.Effect2].Location.X;
            p.Location.Y = Player[-p.Effect2].Location.Y;

            if(Player[-p.Effect2].Dead)
                p.Dead = true;

            // a player has entered a door, make some fireworks!
            if(LevelMacro == LEVELMACRO_FLAG_EXIT && -p.Effect2 == A)
            {
                if(((LevelMacroCounter & 63) == 0) && iRand(2))
                {
                    int dx = iRand(256);
                    int dy = iRand(192);
                    Location_t target = newLoc(p.Location.X + (16 - 128 + dx),
                                               p.Location.Y - 256 + dy);
                    PlaySoundSpatial(SFX_Fireworks, target);
                    NewEffect(EFFID_BOSS_FRAGILE_EXPLODE, target);
                }
            }
        }
        // temporary immunity and invisibility
        else if(p.Effect2 <= 30)
        {
            p.Effect2 -= 1;
            if(p.Effect2 == 0)
            {
                p.Effect = PLREFF_NORMAL;
                p.Effect2 = 0;
            }
        }
        else
            PlayerEffectWarpWait(A);
    }
    // logic combined across all "grow" powerup effects
    else if(p.Effect >= PLREFF_GROW_TO_STATE && p.Effect < PLREFF_GROW_TO_STATE_END) // Player got fire power
    {
        int target_state = p.Effect - PLREFF_GROW_TO_STATE;

        if(p.Duck && p.Character != 5)
        {
            int BackupGrabTime = Player[A].GrabTime;

            // forces UnDuck to work, this fixes a vanilla downwards clip for Chars 3+4 and a visual bug for the other chars
            if(g_config.fix_player_grab_clip)
                Player[A].GrabTime = 0;

            UnDuck(Player[A]);

            Player[A].GrabTime = BackupGrabTime;

            p.Frame = 1;
        }

        p.Effect2 += 1;

        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 1 && p.Character != 5)
            {
                p.State = 2;

                if(p.Mount == 0)
                {
                    p.Location.X += (-Physics.PlayerWidth[p.Character][2] + Physics.PlayerWidth[p.Character][1]) / 2;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
                else if(p.Mount == 3)
                {
                    YoshiHeight(A);
                }
                else if(p.Character == 2 && p.Mount != 2)
                {
                    p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
            }
            else if(p.State != target_state)
                p.State = target_state;
            else
                p.State = 2;
        }

        if(p.Effect2 >= 50)
        {
            if(p.State == 2)
                p.State = target_state;

            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
#if 0
    else if(p.Effect == PLREFF_TURN_FIRE) // Player got fire power
    {
        if(p.Duck && p.Character != 5)
        {
            UnDuck(Player[A]);
            p.Frame = 1;
        }

        p.Effect2 += 1;

        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 1 && p.Character != 5)
            {
                p.State = 2;

                if(p.Mount == 0)
                {
                    p.Location.X += -Physics.PlayerWidth[p.Character][2] * 0.5 + Physics.PlayerWidth[p.Character][1] * 0.5;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
                else if(p.Mount == 3)
                {
                    YoshiHeight(A);
                }
                else if(p.Character == 2 && p.Mount != 2)
                {
                    p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
            }
            else if(p.State != 3)
                p.State = 3;
            else
                p.State = 2;
        }

        if(p.Effect2 >= 50)
        {
            if(p.State == 2)
                p.State = 3;
            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
    else if(p.Effect == PLREFF_TURN_ICE) // Player got ice power
    {
        if(p.Duck && p.Character != 5)
        {
            UnDuck(Player[A]);
            p.Frame = 1;
        }

        p.Effect2 += 1;

        if(p.Effect2 % 5 == 0)
        {
            if(p.State == 1 && p.Character != 5)
            {
                p.State = 2;
                if(p.Mount == 0)
                {
                    p.Location.X += -Physics.PlayerWidth[p.Character][2] * 0.5 + Physics.PlayerWidth[p.Character][1] * 0.5;
                    p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                    p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
                else if(p.Mount == 3)
                {
                    YoshiHeight(A);
                }
                else if(p.Character == 2 && p.Mount != 2)
                {
                    p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                    p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
                }
            }
            else if(p.State != 7)
                p.State = 7;
            else
                p.State = 2;
        }

        if(p.Effect2 >= 50)
        {
            if(p.State == 2)
                p.State = 7;
            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
#endif
    // logic combined across all "transform" powerup effects
    else if(p.Effect >= PLREFF_TURN_TO_STATE && p.Effect < PLREFF_TURN_TO_STATE_END)
    {
        int target_state = p.Effect - PLREFF_TURN_TO_STATE;

        if(target_state != PLR_STATE_LEAF)
            p.Immune2 = true;

        if(!p.AquaticSwim && !p.Rolling)
            p.Frame = 1;

        if(p.Effect2 == 0)
        {
            if(p.State == 1 && p.Mount == 0)
            {
                p.Location.X += (-Physics.PlayerWidth[p.Character][2] + Physics.PlayerWidth[p.Character][1]) / 2;
                p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                p.State = target_state;
                p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            }
            else if(p.Mount == 3)
            {
                YoshiHeight(A);
            }
            else if(p.Character == 2 && p.State == 1 && p.Mount == 1)
            {
                p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                p.Location.Height = Physics.PlayerHeight[p.Character][target_state];
            }

            p.State = target_state;
            NewEffect(EFFID_SMOKE_S4, p.Location, 1, ShadowMode);
        }

        p.Effect2 += 1;

        if(p.Effect2 == 14)
        {
            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
#if 0
    else if(p.Effect == PLREFF_TURN_LEAF) // Player got a leaf
    {
        p.Frame = 1;

        if(p.Effect2 == 0.0)
        {
            if(p.State == 1 && p.Mount == 0)
            {
                p.Location.X += -Physics.PlayerWidth[p.Character][2] * 0.5 + Physics.PlayerWidth[p.Character][1] * 0.5;
                p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                p.State = 4;
                p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            }
            else if(p.Mount == 3)
            {
                YoshiHeight(A);
            }
            else if(p.Character == 2 && p.State == 1 && p.Mount == 1)
            {
                p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                p.Location.Height = Physics.PlayerHeight[p.Character][4];
            }

            p.State = 4;
            tempLocation.Width = 32;
            tempLocation.Height = 32;
            tempLocation.X = p.Location.X + (p.Location.Width - tempLocation.Width) / 2;
            tempLocation.Y = p.Location.Y + (p.Location.Height - tempLocation.Height) / 2;
            NewEffect(EFFID_SMOKE_S4, tempLocation, 1, ShadowMode);
        }

        p.Effect2 += 1;

        if(fEqual(p.Effect2, 14))
        {
            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
    else if(p.Effect == PLREFF_TURN_STATUE) // Player got a tanooki suit
    {
        p.Frame = 1;
        p.Immune2 = true;

        if(p.Effect2 == 0)
        {
            if(p.State == 1 && p.Mount == 0)
            {
                p.Location.X += -Physics.PlayerWidth[p.Character][2] * 0.5 + Physics.PlayerWidth[p.Character][1] * 0.5;
                p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                p.State = 5;
                p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            }
            else if(p.Mount == 3)
            {
                YoshiHeight(A);
            }
            else if(p.Character == 2 && p.State == 1 && p.Mount == 1)
            {
                p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                p.Location.Height = Physics.PlayerHeight[p.Character][5]; // was 4 in SMBX 1.3, but the value was the same for all characters
            }

            p.State = 5;
            tempLocation.Width = 32;
            tempLocation.Height = 32;
            tempLocation.X = p.Location.X + (p.Location.Width - tempLocation.Width) / 2;
            tempLocation.Y = p.Location.Y + (p.Location.Height - tempLocation.Height) / 2;
            NewEffect(EFFID_SMOKE_S4, tempLocation, 1, ShadowMode);
        }

        p.Effect2 += 1;

        if(fEqual(p.Effect2, 14))
        {
            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
    else if(p.Effect == PLREFF_TURN_HEAVY) // Player got a hammer suit
    {
        p.Frame = 1;
        p.Immune2 = true;

        if(p.Effect2 == 0)
        {
            if(p.State == 1 && p.Mount == 0)
            {
                p.Location.X += -Physics.PlayerWidth[p.Character][2] * 0.5 + Physics.PlayerWidth[p.Character][1] * 0.5;
                p.Location.Y += -Physics.PlayerHeight[p.Character][2] + Physics.PlayerHeight[p.Character][1];
                p.State = 6; // was 5 in SMBX 1.3, but this is fine because the dimensions are the same, and it gets set correctly below
                p.Location.Width = Physics.PlayerWidth[p.Character][p.State];
                p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            }
            else if(p.Mount == 3)
            {
                YoshiHeight(A);
            }
            else if(p.Character == 2 && p.State == 1 && p.Mount == 1)
            {
                p.Location.Y += -Physics.PlayerHeight[2][2] + Physics.PlayerHeight[1][2];
                p.Location.Height = Physics.PlayerHeight[p.Character][6];
            }

            p.State = 6;
            tempLocation.Width = 32;
            tempLocation.Height = 32;
            tempLocation.X = p.Location.X + (p.Location.Width - tempLocation.Width) / 2;
            tempLocation.Y = p.Location.Y + (p.Location.Height - tempLocation.Height) / 2;
            NewEffect(EFFID_SMOKE_S4, tempLocation, 1, ShadowMode);
        }

        p.Effect2 += 1;

        if(p.Effect2 == 14.0)
        {
            p.Immune += 50;
            p.Immune2 = true;
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.StandUp = true;
        }
    }
#endif
    else if(p.Effect == PLREFF_STONE) // Change to / from tanooki
    {
        for(B = 1; B <= 2; B++)
        {
            num_t dx = dRand();
            num_t dy = dRand();
            NewEffect(EFFID_SPARKLE, newLoc(p.Location.X + dx * ((int)p.Location.Width + 8) - 8,
                                 p.Location.Y + dy * ((int)p.Location.Height + 8) - 4), 1, ShadowMode);
            Effect[numEffects].Location.SpeedX = dRand() * 2 - 1;
            Effect[numEffects].Location.SpeedY = dRand() * 2 - 1;
        }

        if(p.Effect2 == 0)
        {
            UnDuck(Player[A]);
            PlaySoundSpatial(SFX_Transform, p.Location);
            NewEffect(EFFID_SMOKE_S3_CENTER, p.Location, 1, ShadowMode);

            if(!p.Stoned)
            {
                p.Frame = 0;
                p.Stoned = true;
                p.StonedCD = 15;
            }
            else
            {
                p.StonedCD = 60;
                p.Frame = 1;
                p.Stoned = false;
            }
        }

        p.Effect2 += 1;
        p.Immune = 10;
        p.Immune2 = true;
        p.StonedTime = 0;

        if(p.Effect2 >= 5)
        {
            p.Effect2 = 0;
            p.Effect = PLREFF_NORMAL;
            p.Immune = 0;
            p.Immune2 = false;
        }
    }
    else if(p.Effect == PLREFF_NO_COLLIDE) // MultiMario
    {
        if(p.HoldingNPC > numNPCs) // Can't hold an NPC that is dead
            p.HoldingNPC = 0;

        if(p.HoldingNPC > 0)
        {
            NPC[p.HoldingNPC].Effect = NPCEFF_NORMAL;
            NPC[p.HoldingNPC].CantHurt = Physics.NPCCanHurtWait;
            NPC[p.HoldingNPC].CantHurtPlayer = A;

            if(p.Direction > 0)
                NPC[p.HoldingNPC].Location.X = p.Location.X + Physics.PlayerGrabSpotX[p.Character][p.State];
            else
                NPC[p.HoldingNPC].Location.X = p.Location.X + p.Location.Width - Physics.PlayerGrabSpotX[p.Character][p.State] - NPC[p.HoldingNPC].Location.Width;

            NPC[p.HoldingNPC].Location.Y = p.Location.Y + Physics.PlayerGrabSpotY[p.Character][p.State] + 32 - NPC[p.HoldingNPC].Location.Height;

            if(p.HoldingNPC <= numNPCs)
                treeNPCUpdate(p.HoldingNPC);
        }

        p.MountSpecial = 0;
        p.YoshiTongueLength = 0;
        p.Immune += 1;

        if(p.Immune >= 5)
        {
            p.Immune = 0;
            if(p.Immune2)
                p.Immune2 = false;
            else
                p.Immune2 = true;
        }

        tempBool = true;

        for(B = 1; B <= numPlayers; B++)
        {
            if(B != A && (Player[B].Effect == PLREFF_NORMAL || B == p.Effect2) && !Player[B].Dead && Player[B].TimeToLive == 0 && CheckCollision(p.Location, Player[B].Location))
                tempBool = false;
        }

        if(tempBool)
        {
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.Immune = 0;
            p.Immune2 = false;
            p.Location.SpeedY = 0.01_n;
        }
        else if(p.Effect2 > 0)
        {
            int D = p.Effect2;

            if(Player[D].Effect == PLREFF_NORMAL)
                p.Effect2 = 0;

            p.Immune2 = true;
            p.Location.X = Player[D].Location.X + (Player[D].Location.Width - p.Location.Width) / 2;
            p.Location.Y = Player[D].Location.Y + Player[D].Location.Height - p.Location.Height;
        }
    }
#if 0 /* FIXME: Dead code, because of Redigit's mistake */
    else if(p.Effect == 9) // Yoshi eat
    {
        p.HoldingNPC = 0;
        p.StandingOnNPC = 0;

        if(Player[p.Effect2].YoshiPlayer != A)
        {
            p.Effect = 0;
            p.Effect2 = 0;
        }
    }
#endif
    else if(p.Effect == PLREFF_PET_INSIDE) // Yoshi swallow
    {
        p.HoldingNPC = 0;
        p.StandingOnNPC = 0;
        p.Section = Player[p.Effect2].Section;
        p.Location.X = Player[p.Effect2].Location.X + (Player[p.Effect2].Location.Width - p.Location.Width) / 2;
        p.Location.Y = Player[p.Effect2].Location.Y + (Player[p.Effect2].Location.Height - p.Location.Height) / 2;

        if(Player[p.Effect2].YoshiPlayer != A)
        {
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
        }

        // new logic: allow escape!
        if(BattleMode && g_config.multiplayer_pause_controls)
        {
            if(p.Effect == PLREFF_NORMAL)
            {
                p.Immune = 0;
                p.CanJump = false;
            }
            else if(p.Immune > 0)
                p.Immune--;

            if(p.Controls.Jump || p.Controls.AltJump)
            {
                if(p.Immune == 0 && p.CanJump && p.Effect2)
                {
                    p.Immune = 15;
                    p.CanJump = false;

                    // this gives a median carry time of 10 seconds (22 taps)
                    if(iRand(32) == 0)
                        YoshiSpit(p.Effect2);
                }
            }
            else
                p.CanJump = true;
        }
    }
    else if(p.Effect == PLREFF_RESPAWN) // player stole a heldbonus
    {
        p.Immune += 1;

        if(p.Immune >= 5)
        {
            p.Immune = 0;
            if(p.Immune2)
                p.Immune2 = false;
            else
                p.Immune2 = true;
        }

        p.Location.Y += 2.2_n;

        if(p.Location.Y >= p.RespawnY)
        {
            p.Location.Y = p.RespawnY;
            tempBool = true;
            for(B = 1; B <= numPlayers; B++)
            {
                // !Player[B].Dead condition was added to prevent confusing Drop/Add cases where player gets locked in immune state
                if(B != A && Player[B].Effect != PLREFF_RESPAWN && ((!g_config.allow_drop_add && (numPlayers < 3 || g_ClonedPlayerMode)) || (!Player[B].Dead && Player[B].Effect != PLREFF_PET_INSIDE)) && CheckCollision(p.Location, Player[B].Location))
                    tempBool = false;
            }
            if(tempBool)
            {
                p.Effect = PLREFF_NORMAL;
                p.RespawnY = 0;
                p.Immune = 50;
                p.Immune2 = false;
                p.Location.SpeedY = 0.01_n;
            }
        }
        for(B = 1; B <= numPlayers; B++)
        {
            if(B != A && CheckCollision(p.Location, Player[B].Location))
            {
                if(Player[B].Mount == 2)
                {
                    p.Effect = PLREFF_NORMAL;
                    p.Immune = 50;
                    p.Immune2 = false;
                    p.Location.Y = Player[B].Location.Y - p.Location.Height;
                    p.Location.SpeedY = 0.01_n;
                }
            }
        }
    }

    if(p.Mount == 3 && p.Effect != PLREFF_NO_COLLIDE)
        PlayerFrame(p);

//    if(Player[A].Effect == 0)
//    {
//        if(nPlay.Online && A == nPlay.MySlot + 1)
//            Netplay::sendData Netplay::PutPlayerControls(nPlay.MySlot) + "1c" + std::to_string(A) + "|" + Player[A].Effect + "|" + Player[A].Effect2 + LB + "1h" + std::to_string(A) + "|" + Player[A].State + LB;
//    }
}

bool PlayerNormal(const Player_t& p)
{
    return p.Effect == PLREFF_NORMAL || p.Effect == PLREFF_WARP_PIPE || p.Effect == PLREFF_NO_COLLIDE || p.Effect == PLREFF_PET_INSIDE || p.Effect == PLREFF_COOP_WINGS;
}

bool AllPlayersNormal()
{
    for(int B = 1; B <= numPlayers; B++)
    {
        if(!PlayerNormal(Player[B]))
            return false;
    }

    return true;
}

// NEW: ensures the players on a screen are nearby if the screen is shared
void PlayersEnsureNearby(const Screen_t& screen)
{
    if(screen.Type != ScreenTypes::SharedScreen)
        return;

    // get extreme bounds on screen players
    num_t l = 0;
    num_t r = 0;
    num_t t = 0;
    num_t b = 0;

    // also get center of alive screen players
    num_t cx = 0;
    num_t cy = 0;
    int c_count = 0;

    // if a player is currently warping, always re-calculate position, and prefer to center players on another player
    bool exists_warping = false;
    bool exists_non_warping = false;

    for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
    {
        int plr_A = screen.players[plr_i];
        const Player_t& p = Player[plr_A];
        const Location_t& pLoc = p.Location;

        num_t p_x = pLoc.X + pLoc.Width / 2;
        num_t p_top = (p.Effect == PLREFF_RESPAWN) ? p.RespawnY : pLoc.Y;
        num_t p_y = p_top + pLoc.Height / 2;

        // dead players don't affect camera
        if(p.Dead)
            continue;

        if(plr_i == 0 || p_x < l)
            l = p_x;

        if(plr_i == 0 || p_x > r)
            r = p_x;

        if(plr_i == 0 || p_y < t)
            t = p_y;

        if(plr_i == 0 || p_y > b)
            b = p_y;

        if(!p.Dead && p.TimeToLive == 0)
        {
            cx += p_x;
            cy += p_y;
            c_count += 1;

            if(p.Effect == PLREFF_WARP_PIPE || p.Effect == PLREFF_WARP_DOOR)
                exists_warping = true;
            else
                exists_non_warping = true;
        }
    }

    // no problem if players are nearby, just return
    if(!exists_warping && r - l <= screen.W && b - t <= screen.H)
        return;

    // need to calculate center and figure out which player is closest
    if(c_count > 0)
    {
        cx /= c_count;
        cy /= c_count;
    }
    else
    {
        cx = (l + r) / 2;
        cy = (t + b) / 2;
    }

    // figure out which player is closest
    int    closest      = 0;
    num_t closest_dist = 0;

    for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
    {
        int plr_A = screen.players[plr_i];
        const Player_t& p = Player[plr_A];
        const Location_t& pLoc = p.Location;

        // prefer non-warping player
        if(exists_non_warping && (p.Effect == PLREFF_WARP_PIPE || p.Effect == PLREFF_WARP_DOOR))
            continue;

        if(!p.Dead && p.TimeToLive == 0)
        {
            num_t p_top = (p.Effect == PLREFF_RESPAWN) ? p.RespawnY : pLoc.Y;
            num_t dist = num_t::dist2(pLoc.X - cx, p_top - cy);

            if(closest == 0 || closest_dist > dist)
            {
                closest = plr_A;
                closest_dist = dist;
            }
        }
    }

    // if all players dead, choose randomly
    if(closest == 0)
        closest = screen.players[0];

    Player_t& pClosest = Player[closest];
    const Location_t& pClosestLoc = pClosest.Location;

    // if the winner is currently respawning, place them at their target loc
    if(pClosest.Effect == PLREFF_RESPAWN)
        pClosest.Location.Y = pClosest.RespawnY;

    // move all players to winning player's location, and set effect if alive
    for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
    {
        int plr_A = screen.players[plr_i];

        if(plr_A == closest)
            continue;

        Player_t& p = Player[plr_A];

        // winged player will naturally return to screen
        if(p.Effect == PLREFF_COOP_WINGS)
            continue;

        Location_t& pLoc = p.Location;

        p.Section = pClosest.Section;

        pLoc.X = pClosestLoc.X + (pClosestLoc.Width - pLoc.Width) / 2;
        pLoc.Y = pClosestLoc.Y + pClosestLoc.Height - pLoc.Height;
    }

    bool in_door_scroll = PlayerScrollingInWarp(pClosest);

    for(int plr_i = 0; plr_i < screen.player_count; plr_i++)
    {
        int plr_A = screen.players[plr_i];

        Player_t& p = Player[plr_A];

        if(p.Dead || p.TimeToLive != 0)
            continue;

        p.RespawnY = 0;

        if(in_door_scroll)
        {
            p.Effect = pClosest.Effect;
            p.Effect2 = pClosest.Effect2;
            p.Warp = pClosest.Warp;
            p.WarpCD = pClosest.WarpCD;
            p.WarpBackward = pClosest.WarpBackward;
        }
        else
        {
            p.Effect = PLREFF_NORMAL;
            p.Effect2 = 0;
            p.Warp = 0;
            p.WarpCD = 0;
            p.WarpBackward = false;
            p.WarpShooted = false;

            DodgePlayers(plr_A);
        }
    }
}

void KeyholeCheck(const int A, const Location_t& loc)
{
    UNUSED(A);

    for(int B : treeBackgroundQuery(loc, SORTMODE_NONE))
    {
        if(B > numBackground)
            continue;

        if(Background[B].Type == 35)
        {
            SpeedlessLocation_t tempLocation = Background[B].Location;
            tempLocation.Width = 16;
            tempLocation.X += 8;
            tempLocation.Height = 26;
            tempLocation.Y += 2;

            if(CheckCollision(loc, tempLocation))
            {
                PlaySound(SFX_Key);
                StopMusic();
                LevelMacro = LEVELMACRO_KEYHOLE_EXIT;
                LevelMacroWhich = B;
                break;
            }
        }
    }
}

// make a death effect for player and release all items linked to them.
// used for the Die SwapCharacter and for the DropPlayer.
// do this BEFORE changing/erasing any player fields
void PlayerGone(const int A)
{
    PlaySoundSpatial(SFX_PlayerDied2, Player[A].Location);
    if(!Player[A].Dead && Player[A].TimeToLive == 0)
    {
        PlayerDismount(A);
        if(Player[A].HoldingNPC > 0)
        {
            NPC[Player[A].HoldingNPC].HoldingPlayer = 0;
            Player[A].HoldingNPC = 0;
        }
        PlayerDeathEffect(A);
    }
}

void AddPlayer(int Character, Screen_t& screen)
{
    numPlayers++;

    // add player to screen
    Screens_AssignPlayer(numPlayers, screen);

    Player_t& p = Player[numPlayers];

    p = Player_t();
    p.Character = Character;
    p.State = SavedChar[p.Character].State;
    p.HeldBonus = NPCID(SavedChar[p.Character].HeldBonus);
    p.Mount = SavedChar[p.Character].Mount;
    p.MountType = SavedChar[p.Character].MountType;
    p.Hearts = SavedChar[p.Character].Hearts;

    if(p.State == 0)
        p.State = 1;

    p.Frame = 1;
    if(p.Character == 3)
        p.CanFloat = true;
    p.Direction = 1;

    SizeCheck(Player[numPlayers]);

    // the rest only matters during level play
    if(LevelSelect)
        return;

    int alivePlayer = CheckNearestLiving(numPlayers);
    if(alivePlayer == 0 || alivePlayer == numPlayers)
        alivePlayer = 1;

    p.Section = Player[alivePlayer].Section;
    RespawnPlayerTo(numPlayers, alivePlayer);

    // the rest only matters during level play
    if(LevelSelect)
        return;

    SetupScreens();
    PlayersEnsureNearby(screen);
}

void DropPlayer(const int A)
{
    if(A < 1 || A > numPlayers)
        return;

    const Screen_t& screen = ScreenByPlayer(A);

    // in levels, make a death effect (and leave behind mount)
    if(!LevelSelect)
        PlayerGone(A);

    // IMPORTANT - removes all references to player A,
    //   decrements all references to higher players

    // NPC player references
    for(int C = 1; C <= numNPCs; C++)
    {
        NPC_t& n = NPC[C];

        // most of these should not be equal because PlayerGone has already been called.
        if(n.vehiclePlr > A && n.vehiclePlr <= numPlayers)
            n.vehiclePlr --;
        else if(n.vehiclePlr == A)
            n.vehiclePlr = 0;

        if(n.HoldingPlayer > A && n.HoldingPlayer <= numPlayers)
            n.HoldingPlayer --;
        else if(n.HoldingPlayer == A)
            n.HoldingPlayer = 0;

        if(n.CantHurtPlayer > A && n.CantHurtPlayer <= numPlayers)
            n.CantHurtPlayer --;
        else if(n.CantHurtPlayer == A)
            n.CantHurtPlayer = 0;

        if(n.BattleOwner > A && n.BattleOwner <= numPlayers)
            n.BattleOwner --;
        else if(n.BattleOwner == A)
            n.BattleOwner = 0;

        // this is not quite right (the vScreen index doesn't necessarily equal the player index, and might not get removed)
        if(n.JustActivated > A)
            n.JustActivated --;
        else if(n.JustActivated == A)
            n.JustActivated = 1;
    }

    // Block player references
    // Block[B].IsPlayer is only set for tempBlocks, so no correction here

    // Player player references
    for(int B = 1; B <= numPlayers; B++)
    {
        if(Player[B].YoshiPlayer == A)
            Player[B].YoshiPlayer = 0;
        else if(Player[B].YoshiPlayer > A)
            Player[B].YoshiPlayer --;

        if(Player[B].StandingOnVehiclePlr == A)
            Player[B].StandingOnVehiclePlr = 0;
        else if(Player[B].StandingOnVehiclePlr > A)
            Player[B].StandingOnVehiclePlr --;
    }

    // saves player without their mount, but mount is still onscreen and available
    SavedChar[Player[A].Character] = Player[A];
    for(int B = A; B < numPlayers; B++)
    {
        Player[B] = std::move(Player[B + 1]);
        OwedMount[B] = OwedMount[B + 1];
        OwedMountType[B] = OwedMountType[B + 1];
        BattleLives[B] = BattleLives[B + 1];
    }

    numPlayers --;

    // remove player from screens
    Screens_DropPlayer(A);

    // the rest only matters during level play
    if(LevelSelect)
        return;

    SetupScreens();
    PlayersEnsureNearby(screen);
}

void SwapCharacter(int A, int Character, bool FromBlock)
{
    SavedChar[Player[A].Character] = Player[A];

    // the following is identical to the code moved from blocks.cpp
    Player[A].Character = Character;
    auto &p = Player[A];
    p.State = SavedChar[p.Character].State;
    p.HeldBonus = NPCID(SavedChar[p.Character].HeldBonus);
    p.Mount = SavedChar[p.Character].Mount;
    p.MountType = SavedChar[p.Character].MountType;
    p.Hearts = SavedChar[p.Character].Hearts;
    if(p.State == 0)
    {
        p.State = 1;
    }
    p.FlySparks = false;
    p.Immune = 50;
    if(FromBlock)
    {
        p.Effect = PLREFF_WAITING;
        p.Effect2 = 14;
    }
    // NEW CODE that plays same role as old call to SetupPlayers() in the original world map char swap code
    else
    {
        p.Frame = 1;
        p.FrameCount = 0;

        if(LevelSelect)
            p.Immune = 0;
    }

    if(FromBlock)
    {
        // make player top match old player top, for bricks (from blocks.cpp)
        if(p.Mount <= 1)
        {
            p.Location.Height = Physics.PlayerHeight[p.Character][p.State];
            if(p.Mount == 1 && p.State == 1)
            {
                p.Location.Height = Physics.PlayerHeight[1][2];
            }
            p.StandUp = true;
        }
    }
    else
    {
        num_t saved_respawn_StopY = 0;
        if(p.Effect == PLREFF_RESPAWN)
            saved_respawn_StopY = p.RespawnY + p.Location.Height;

        // make player bottom match old player bottom, to avoid floor glitches
        UnDuck(Player[A]);
        SizeCheck(Player[A]);

        // if player effect is 6 (respawn downwards), update target similarly
        if(p.Effect == PLREFF_RESPAWN)
            p.RespawnY = saved_respawn_StopY - p.Location.Height;
    }

    if(!LevelSelect)
        NewEffect(EFFID_SMOKE_S3_CENTER, p.Location);

    UpdateYoshiMusic();
}

// returns whether a player is allowed to swap characters
bool SwapCharAllowed()
{
    if(LevelSelect || GameMenu || (g_config.allow_drop_add && IsHubLevel))
        return true;
    else
        return false;
}


================================================
FILE: src/player.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef PLAYER_H
#define PLAYER_H

struct Screen_t;
struct Player_t;

// NEW: moves a player to avoid collisions with other players, and sets to no-clipping if this is impossible
void DodgePlayers(int plr_A);

// Public Sub SetupPlayers() 'this set's the players values to their defaults and prepares them for playing a level
// this set's the players values to their defaults and prepares them for playing a level
void SetupPlayers();
// Public Sub UpdatePlayer() 'This is the main sub for the players
// This is the main sub for the players
// Returns true if the game has been paused
bool UpdatePlayer();
// Public Sub PlayerHurt(A As Integer) 'Player got hurt
// Player got hurt
void PlayerHurt(const int A);
// Public Sub PlayerDead(A As Integer) 'Set player up to die
// Set player up to die
void PlayerDead(const int A);
// Public Sub KillPlayer(A As Integer) 'Kill the player
// Kill the player
void KillPlayer(const int A);
// Public Function CheckDead() As Integer 'Check if players are dead and return which one, returns 0 if everyones dead
// Check if players are dead and return which one, returns 0 if everyones dead
int CheckDead();
// Public Function CheckLiving() As Integer 'Check if players are alive, returns the first player or 0 if everyones dead
// Check if players are alive, returns the first player or 0 if everyones dead
int CheckLiving();
// NEW: returns the closest player to A (prioritizing players on same screen as A) or 0 if everyone's dead
int CheckNearestLiving(const int A);
// Unknown
int LivingPlayersLeft();
// Public Function LivingPlayers() As Boolean 'true if there are still living players
// true if there are still living players
bool LivingPlayers();
// Public Sub EveryonesDead() 'Handles the game when all players have died
// Handles the game when all players have died
void EveryonesDead();
// Initiate level fadeout procedure if all players have died
void ProcessLastDead();
// Public Sub UnDuck(A As Integer) 'Un Duck the player
// Un Duck the player
void UnDuck(struct Player_t &p);
// Public Sub CheckSection(A As Integer)
void CheckSection(const int A);
// special CheckSection routine used to initialize players, allows music in section 0 to play
void CheckSection_Init(const int A);
// Public Sub PlayerFrame(A As Integer)
void PlayerFrame(const int A);
void PlayerFrame(struct Player_t &p);
// Public Sub UpdatePlayerBonus(A As Integer, B As Integer)
void UpdatePlayerBonus(const int A, const NPCID B);
// Public Sub TailSwipe(plr As Integer, Optional bool As Boolean = False, Optional Stab As Boolean = False, Optional StabDir As Integer = 0)  'for whacking something with the tail
// for whacking something with the tail
void TailSwipe(const int plr, bool boo = false, bool Stab = false, int StabDir = 0);
// Public Sub YoshiHeight(A As Integer) 'fix the players height when on a yoshi
// fix the players height when on a yoshi
void YoshiHeight(const int A);
// Public Sub YoshiEat(A As Integer)
void YoshiEat(const int A);
// Public Sub YoshiSpit(A As Integer)
void YoshiSpit(const int A);
// Public Sub YoshiPound(A As Integer, C As Integer, Optional BreakBlocks As Boolean = False)
void YoshiPound(int A, int mount, bool BreakBlocks = false);


// NEW (but derived from existing code) forces player to jump out of mount as they do for AltJump, bypassing all checks.
void PlayerDismount(const int A);

// NEW: checks if player A is in the mouth of the pet of any player on a screen
bool InOnscreenPet(int plr_A, const Screen_t& screen);

// NEW: removes a player from a pet's mouth (so that their effect can be changed successfully)
void RemoveFromPet(int plr_A);

// Public Sub SwapCoop()
void SwapCoop();
// Public Sub PlayerPush(A As Integer, HitSpot As Integer)
void PlayerPush(const int A, int HitSpot);
// Public Sub SizeCheck(A As Integer)
void SizeCheck(struct Player_t &p);
// Public Sub YoshiEatCode(A As Integer)
void YoshiEatCode(const int A);
// Public Sub StealBonus()
void StealBonus();
// Public Sub ClownCar()
void ClownCar();

void CleanupVehicleNPCs();

// Private Sub WaterCheck(A As Integer)
void WaterCheck(const int A); //PRIVATE
// Private Sub Tanooki(A As Integer)
void Tanooki(const int A); //PRIVATE
// Private Sub PowerUps(A As Integer)
void PowerUps(const int A); //PRIVATE
// Private Sub SuperWarp(A As Integer)
void SuperWarp(const int A); //PRIVATE
// NEW: reports whether a player is currently waiting to exit a warp (for shared screen)
bool PlayerWaitingInWarp(const Player_t& p);
// NEW: reports whether a player is currently scrolling between warps
bool PlayerScrollingInWarp(const Player_t& p);
// Private Sub PlayerCollide(A As Integer)
void PlayerCollide(const int A); //PRIVATE

// Public Sub PlayerGrabCode(A As Integer, Optional DontResetGrabTime As Boolean = False)
void PlayerGrabCode(const int A, bool DontResetGrabTime = false);
// Public Sub LinkFrame(A As Integer)
void LinkFrame(const int A);
void LinkFrame(struct Player_t &p);
// Private Sub PlayerEffects(A As Integer)
void PlayerEffects(const int A);

// NEW: checks if player has normal state
bool PlayerNormal(const Player_t& p);
// NEW: checks if all players have normal state (if false, layer movement and events get disabled)
bool AllPlayersNormal();

// NEW: ensures the players on a screen are nearby if the screen is shared
void PlayersEnsureNearby(const Screen_t& screen);

// NEW: checks for a keyhole at a location
void KeyholeCheck(const int A, const Location_t& loc);

// main Drop/Add functions
void DropPlayer(const int A);
void AddPlayer(int Character, Screen_t& screen);

// NEW but, when Die is false and FromBlock is true, identical to hitting character block.
void SwapCharacter(int A, int Character, bool FromBlock = false);

// returns whether a player is allowed to swap characters
bool SwapCharAllowed();

#endif // PLAYER_H


================================================
FILE: src/pseudo_vb.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef PSEUDO_VB_H
#define PSEUDO_VB_H

#define False false
#define True true
#define If if(
#define Then ) {
#define End }

#define CDbl(x) static_cast<double>(x)
#define CSng(x) static_cast<float>(x)
#define CBool(x) static_cast<bool>(x)
#define CInt(x) static_cast<int>(x)

#endif // PSEUDO_VB_H


================================================
FILE: src/rand.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <cstdlib>

#include <pcg/pcg_random.hpp>

#include "globals.h"
#include "rand.h"

static pcg32 g_random_engine;
static long g_random_n_calls = 0;

static pcg32 g_random_engine_isolated;

#ifdef DEBUG_RANDOM_CALLS
std::vector<void*> g_random_calls;
#endif

static int last_seed = 310;

void seedRandom(int seed)
{
    last_seed = seed;
    g_random_n_calls = 0;
#ifdef DEBUG_RANDOM_CALLS
    g_random_calls.clear();
#endif
    g_random_engine.seed(seed);
    g_random_engine_isolated.seed(seed);
}

int readSeed()
{
    g_random_engine.seed(last_seed);
    return last_seed;
}

long random_ncalls()
{
    return g_random_n_calls;
}

void random_set_ncalls(long ncalls)
{
    g_random_engine.seed(last_seed);

    for(long i = 0; i < ncalls; i++)
        g_random_engine();

    g_random_n_calls = ncalls;
}

// Also note that many VB6 calls use dRand * x
// and then assign the result to an Integer.
// The result is NOT iRand(x) but rather vb6Round(dRand()*x),
// iRand_round, which has a different probability distribution
// (prob 1/(2x) of being 0 or x and 1/x of being each number in between)

int iRand(int max)
{
    g_random_n_calls ++;
#ifdef DEBUG_RANDOM_CALLS
    void* stack[2] = {nullptr, nullptr};
    backtrace(stack, 2);
    g_random_calls.push_back(stack[1]);
#endif

    if(max == 0)
    {
        g_random_engine();
        return 0;
    }

    return g_random_engine() % max;
}

int iRand2(int max)
{
    if(max == 0)
    {
        g_random_engine_isolated();
        return 0;
    }

    return g_random_engine_isolated() % max;
}


num_t dRand()
{
    g_random_n_calls ++;

#ifdef DEBUG_RANDOM_CALLS
    void* stack[2] = {nullptr, nullptr};
    backtrace(stack, 2);
    g_random_calls.push_back(stack[1]);
#endif

#ifdef THEXTECH_FIXED_POINT
    return num_t((int64_t)g_random_engine(), nullptr);
#else
    return num_t(std::ldexp(g_random_engine(), -32), nullptr);
#endif
}


================================================
FILE: src/rand.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef RAND_H
#define RAND_H

#include <cmath>

#include "numeric_types.h"

// supported only on gcc
// #define DEBUG_RANDOM_CALLS
#ifdef DEBUG_RANDOM_CALLS
#   include <execinfo.h>
#   include <vector>
extern std::vector<void*> g_random_calls;
#endif

/**
 * @brief Seeds the random number generator with argument seed for reproducible results
 */
extern void seedRandom(int seed);

/**
 * @brief Reads the most recently set seed and resets the seed to that seed
 * @return current seed
 */
extern int readSeed();

/**
 * @brief Reads the number of calls to random functions since the seed was set
 * @return number of calls
 */
extern long random_ncalls();

/**
 * @brief Resets the random state to simulate the requested number of calls since the seed was set
 */
extern void random_set_ncalls(long ncalls);

/**
 * @brief Random number generator in double format, between 0.0 to 1.0 (exclusive)
 * @return random double value
 */
extern num_t dRand();

/**
 * @brief Random number generator in integer format, between 0 to argument max (exclusive)
 * Distribution equivalent to `Int(dRand() * max)`
 * @return random integer value
 */
extern int iRand(int max);

template<class T>
int iRandT(T max)
{
    return iRand(static_cast<int>(max));
}

/**
 * @brief Random number generator in integer format, between 0 to argument max (exclusive)
 * Distribution equivalent to `Int(dRand() * max)`
 *
 * Note: It's the second isolated randomizer
 * @return random integer value
 */
extern int iRand2(int max);

template<class T>
int iRand2T(T max)
{
    return iRand2(static_cast<int>(max));
}

/**
 * @brief Random number generator in integer format, between 0 to argument max (inclusive)
 * Each midpoint has probability 1/max. Each endpoint has probability 1/2max.
 * Distribution equivalent to implicitly casting `dRand() * max` to an Int in vb6
 * @return random integer value
 */
inline int iRand_round(int max)
{
    // let 0 represent top endpoint, otherwise use iRand(max*2)/2.
    int i = iRand(max*2);
    if(i == 0)
        return max;
    return i/2;
}


#endif // RAND_H


================================================
FILE: src/range_arr.hpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef RANGE_ARR_HPP
#define RANGE_ARR_HPP

#include <cstddef>

#ifndef RANGE_ARR_UNSAFE_MODE
#include "core/xerror.h"
#endif

#if defined(__clang__)
#   define RANGE_ARR_UNREACHABLE(cond) __builtin_assume(cond)
#elif defined(__GNUC__)
#   define RANGE_ARR_UNREACHABLE(cond) __builtin_unreachable()
#elif defined(_MSC_VER)
#   define RANGE_ARR_UNREACHABLE(cond) __assume(cond)
#else
#   define RANGE_ARR_UNREACHABLE(cond)
#endif

#define For(A, From, To) for(int A = From; A <= To; ++A)

template <class T, long begin, long end>
class RangeArr
{
    static constexpr long range_diff = begin - end;
    static constexpr size_t size = (range_diff < 0 ? -range_diff : range_diff) + 1;
    static constexpr long offset = -begin;

#ifdef RANGE_ARR_USE_HEAP
    T *array = nullptr;
#else
    T array[size];
#endif

public:
    using Type = T;

    RangeArr() noexcept
    {
#ifdef RANGE_ARR_USE_HEAP
        array = new T[size];
#endif
    }

#ifdef RANGE_ARR_USE_HEAP
    ~RangeArr()
    {
        delete[] array;
    }
#endif

    RangeArr(const RangeArr &o)
    {
#ifdef RANGE_ARR_USE_HEAP
        array = new T[size];
#endif
        for(size_t i = 0; i < size; i++)
            array[i] = o.array[i];
    }

    RangeArr& operator=(const RangeArr &o)
    {
#ifdef RANGE_ARR_USE_HEAP
        if(array)
            delete [] array;
        array = new T[size];
#endif
        for(size_t i = 0; i < size; i++)
            array[i] = o.array[i];
        return *this;
    }

    void fill(const T &o)
    {
        for(size_t i = 0; i < size; i++)
            array[i] = o;
    }

    constexpr T *base() const
    {
        return array + offset;
    }

    constexpr T *baseReal() const
    {
        return array;
    }

#ifdef RANGE_ARR_UNSAFE_MODE
    constexpr T& operator[](long index) const
    {
        return *(const_cast<T*>(array) + index + offset);
    }
#else
    inline T& operator[](long index)
    {
#   ifdef RANGE_ARR_USE_HEAP
        SDL_assert_release(array); // When array won't initialize
#   endif
        if(index > end || index < begin)
        {
            fatal_assert_rangearr(begin, end, index);
            RANGE_ARR_UNREACHABLE(index <= end || index >= begin);
        }

        return *(array + index + offset);
    }

    inline const T& operator[](long index) const
    {
#   ifdef RANGE_ARR_USE_HEAP
        SDL_assert_release(array); // When array won't initialize
#   endif
        if(index > end || index < begin)
        {
            fatal_assert_rangearr(begin, end, index);
            RANGE_ARR_UNREACHABLE(index >= begin || index <= end);
        }

        return *(array + index + offset);
    }
#endif
};

template <class T, long begin, long end, T defaultValue>
class RangeArrI
{
    static constexpr long range_diff = begin - end;
    static constexpr size_t size = (range_diff < 0 ? -range_diff : range_diff) + 1;
    static constexpr long offset = -begin;

#ifdef RANGE_ARR_USE_HEAP
    T *array = nullptr;
#else
    T array[size];
#endif

public:
    using Type = T;

    RangeArrI() noexcept
    {
#ifdef RANGE_ARR_USE_HEAP
        array = new T[size];
#endif
        for(size_t i = 0; i < size; i++)
            array[i] = defaultValue;
    }

#ifdef RANGE_ARR_USE_HEAP
    ~RangeArrI()
    {
        delete[] array;
    }
#endif

    RangeArrI(const RangeArrI &o)
    {
#ifdef RANGE_ARR_USE_HEAP
        array = new T[size];
#endif
        for(size_t i = 0; i < size; i++)
            array[i] = o.array[i];
    }

    RangeArrI& operator=(const RangeArrI &o)
    {
#ifdef RANGE_ARR_USE_HEAP
        if(array)
            delete [] array;
        array = new T[size];
#endif
        for(size_t i = 0; i < size; i++)
            array[i] = o.array[i];
        return *this;
    }

    void fill(const T &o)
    {
        for(size_t i = 0; i < size; i++)
            array[i] = o;
    }

    constexpr T *base() const
    {
        return array + offset;
    }

    constexpr T *baseReal() const
    {
        return array;
    }

#ifdef RANGE_ARR_UNSAFE_MODE
    constexpr T& operator[](long index) const
    {
        return *(const_cast<T*>(array) + index + offset);
    }
#else
    inline T& operator[](long index)
    {
#   ifdef RANGE_ARR_USE_HEAP
        SDL_assert_release(array); // When array won't initialize
#   endif
        if(index > end || index < begin)
        {
            fatal_assert_rangearr(begin, end, index);
            RANGE_ARR_UNREACHABLE(index >= begin || index <= end);
        }

        return *(array + index + offset);
    }

    inline const T& operator[](long index) const
    {
#   ifdef RANGE_ARR_USE_HEAP
        SDL_assert_release(array); // When array won't initialize
#   endif
        if(index > end || index < begin)
        {
            fatal_assert_rangearr(begin, end, index);
            RANGE_ARR_UNREACHABLE(index >= begin || index <= end);
        }

        return *(array + index + offset);
    }
#endif
};

#endif // RANGE_ARR_HPP


================================================
FILE: src/ref_type.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef REF_TYPE_H
#define REF_TYPE_H

#include <cstdint>
#include <functional>
#include <type_traits>


struct BaseRef_t
{
    int16_t index;

    inline constexpr BaseRef_t() : index{INT16_MIN} {}
    inline constexpr BaseRef_t(int16_t i) : index{i} {}
    inline constexpr BaseRef_t(const BaseRef_t& r) : index(r.index) {}

    inline operator int() const { return index; }
    inline operator int16_t() const { return index; }
    inline operator size_t() const { return index; }
    inline operator bool() const { return *this != nullptr; }

    inline BaseRef_t& operator=(const BaseRef_t& o) { index = o.index; return *this; }
    inline BaseRef_t& operator=(std::nullptr_t /* o */) { index = INT16_MIN; return *this; }

    inline bool operator==(std::nullptr_t /* o */) const { return index == INT16_MIN; }
    inline bool operator!=(std::nullptr_t /* o */) const { return index != INT16_MIN; }

    inline bool operator==(const BaseRef_t& o) const { return index == o.index; }
    inline bool operator!=(const BaseRef_t& o) const { return index != o.index; }
    inline bool operator<(const BaseRef_t& o) const { return index < o.index; }
    inline bool operator>(const BaseRef_t& o) const { return index > o.index; }
    inline bool operator<=(const BaseRef_t& o) const { return index <= o.index; }
    inline bool operator>=(const BaseRef_t& o) const { return index >= o.index; }
};

#if defined(_MSC_VER)
#    define XTECH_TYPEOF(x) typename std::remove_reference<decltype(x)>::type
#else
#    define XTECH_TYPEOF(x) __typeof__(x)
#endif

template<class _target, _target& target>
struct Ref_t : public BaseRef_t
{
    using T = XTECH_TYPEOF(target[1]);
    using value_type = T;

    inline constexpr Ref_t() : BaseRef_t{} {}
    inline constexpr Ref_t(int16_t i) : BaseRef_t{i} {}
    inline constexpr Ref_t(const BaseRef_t& r) : BaseRef_t{r.index} {}
    inline constexpr Ref_t(const Ref_t& r) : BaseRef_t{r.index} {}
    inline Ref_t(T* p) : BaseRef_t{(int16_t)(p - &target[1] + 1)} {}
    inline Ref_t(T& p) : BaseRef_t{(int16_t)(&p - &target[1] + 1)} {}

    inline operator int() const { return index; }
    inline operator int16_t() const { return index; }
    inline operator size_t() const { return index; }
    inline operator bool() const { return *this != nullptr; }
    inline operator T*() const { return &target[index]; }
    inline operator T&() const { return target[index]; }

    inline T& operator*() const { return target[index]; }
    inline T* operator->() const { return &target[index]; }

    inline Ref_t& operator=(const Ref_t& o) { index = o.index; return *this; }
    inline BaseRef_t& operator=(std::nullptr_t /* o */) { index = INT16_MIN; return *this; }

    inline bool operator==(std::nullptr_t /* o */) const { return index == INT16_MIN; }
    inline bool operator!=(std::nullptr_t /* o */) const { return index != INT16_MIN; }

    inline bool operator==(const Ref_t& o) const { return index == o.index; }
    inline bool operator!=(const Ref_t& o) const { return index != o.index; }
    inline bool operator<(const Ref_t& o)  const { return index <  o.index; }
    inline bool operator>(const Ref_t& o)  const { return index >  o.index; }
    inline bool operator<=(const Ref_t& o) const { return index <= o.index; }
    inline bool operator>=(const Ref_t& o) const { return index >= o.index; }
};

#undef XTECH_TYPEOF

namespace std
{
    template <>
    struct hash<BaseRef_t>
    {
        uint16_t operator()(const BaseRef_t& k) const noexcept
        {
            return (uint16_t)k.index;
        }
    };

    template<class _target, _target& target>
    struct hash<Ref_t<_target, target>>
    {
        uint16_t operator()(const Ref_t<_target, target>& k) const noexcept
        {
            return (uint16_t)k.index;
        }
    };
}

#define DECLREF_T(target) using target ## Ref_t = Ref_t<decltype(target), target>

#endif // REF_TYPE_H


================================================
FILE: src/saved_layers.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <IniProcessor/ini_processing.h>
#include "Utils/files_ini.h"

#include "sdl_proxy/sdl_stdinc.h"

#include "saved_layers.h"
#include "global_dirs.h"

int numSavedLayers;
std::array<SavedLayer_t, maxSavedLayers> SavedLayers;

// Load and save procedures

// totally resets saved layer array
void ClearSavedLayers()
{
    numSavedLayers = 0;
    SDL_memset(&SavedLayers, 0, sizeof(decltype(SavedLayers)));
}

// loads default saved layer values from the episode's savedlayers.ini
bool LoadDefaultSavedLayers()
{
    ClearSavedLayers();

    std::string savedlayers_ini_path = g_dirEpisode.resolveFileCaseExistsAbs("savedlayers.ini");
    if(savedlayers_ini_path.empty())
        return true;

    IniProcessing savedlayers_ini = Files::load_ini(savedlayers_ini_path);
    savedlayers_ini.beginGroup("General");

    for(const std::string& k : savedlayers_ini.allKeys())
    {
        if(numSavedLayers >= maxSavedLayers || k.size() > 22)
            return false;

        auto& target = SavedLayers[numSavedLayers++];

        memcpy(target.Name.data(), k.c_str(), k.size());

        savedlayers_ini.read(k.c_str(), target.Visible, false);
    }

    return true;
}

// loads a single saved layer entry from a gamesave
bool LoadSavedLayer(const void* /*userdata*/, savedLayerSaveEntry& obj)
{
    for(int i = 0; i < numSavedLayers; i++)
    {
        if(SDL_strcmp(obj.first.c_str(), SavedLayers[i].Name.data()) != 0)
            continue;

        SavedLayers[i].Visible = obj.second;
        break;
    }

    return true;
}

// exports a single saved layer entry to a gamesave
bool ExportSavedLayer(const void* /*userdata*/, savedLayerSaveEntry& obj, pge_size_t index)
{
    if((int)index >= numSavedLayers)
        return false;

    obj.first = SavedLayers[index].Name.data();
    obj.second = SavedLayers[index].Visible;

    return true;
}


================================================
FILE: src/saved_layers.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SAVED_LAYERS_H
#define SAVED_LAYERS_H

#include <array>

#include <PGE_File_Formats/save_filedata.h>

// NEW: saved layers. These are saved / loaded as an *unordered* lists of lower-cased strings corresponding to Visible and Hidden.
const int maxSavedLayers = 32;

struct SavedLayer_t
{
    std::array<char, 22> Name;
    const char null_term = '\0';
    bool Visible = false;
};

// These belong to the episode, NOT the level
extern int numSavedLayers;
extern std::array<SavedLayer_t, maxSavedLayers> SavedLayers;

// Load and save procedures

// totally resets saved layer array
void ClearSavedLayers();
// loads default saved layer values from the episode's savedlayers.ini
bool LoadDefaultSavedLayers();
// loads a single saved layer entry from a gamesave
bool LoadSavedLayer(const void* /*userdata*/, savedLayerSaveEntry& obj);
// exports a single saved layer entry to a gamesave
bool ExportSavedLayer(const void* /*userdata*/, savedLayerSaveEntry& obj, pge_size_t index);

#endif // #ifndef SAVED_LAYERS_H


================================================
FILE: src/screen.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#include "screen.h"
#include "globals.h" // SingleCoop
#include "config.h"

#include "core/render.h" // XRender::TargetX

RangeArr<Screen_t, 0, c_screenCount - 1> Screens;
Screen_t* l_screen = &Screens[0];

RangeArr<qScreen_t, 0, c_vScreenCount> qScreenLoc;
RangeArr<vScreen_t, 0, c_vScreenCount> vScreen;

static std::array<uint8_t, maxNetplayPlayers + 1> s_screenIdxByPlayer;


int vScreen_t::TargetX() const
{
    return Screens[screen_ref].TargetX() + ScreenLeft;
}

int vScreen_t::TargetY() const
{
    return Screens[screen_ref].TargetY() + ScreenTop;
}

num_t vScreen_t::CameraAddX() const
{
#ifdef PGE_MIN_PORT
    if(!Player[this->player].StandingOnNPC)
        return num_t::ceil(X / 2 - 0.5_n) * 2 + 1.0_n;

    return X + 1.0_n;
#else
    // this will be added to numeric object coordinates and then the floor will be taken.

    // the logic here is that if the player is not on a moving NPC / layer,
    //   use whole-number world coordinates to keep static objects from jittering, then round all positions
    // when the player *is* on a moving NPC / layer,
    //   use player-centric numeric coordinates to keep nearby objects from jittering, then round all positions
    if(!Player[this->player].StandingOnNPC)
        return num_t::ceil(X - 0.5_n) + 0.5_n;

    return X + 0.5_n;
#endif
}

num_t vScreen_t::CameraAddY() const
{
#ifdef PGE_MIN_PORT
    if(!Player[this->player].StandingOnNPC)
        return num_t::ceil(Y / 2 - 0.5_n) * 2 + 1.0_n;

    return Y + 1.0_n;
#else
    if(!Player[this->player].StandingOnNPC)
        return num_t::ceil(Y - 0.5_n) + 0.5_n;

    return Y + 0.5_n;
#endif
}

int vScreen_t::CameraAddX_i() const
{
    return num_t::floor(CameraAddX());
}

int vScreen_t::CameraAddY_i() const
{
    return num_t::floor(CameraAddY());
}

Screen_t& Screen_t::canonical_screen()
{
    if(is_canonical())
        return *this;

    return Screens[m_CanonicalScreen];
}

const Screen_t& Screen_t::canonical_screen() const
{
    if(is_canonical())
        return *this;

    return Screens[m_CanonicalScreen];
}

Screen_t& Screen_t::visible_screen()
{
    if(Visible || m_VisibleScreen >= c_screenCount)
        return *this;

    return Screens[m_VisibleScreen];
}

const Screen_t& Screen_t::visible_screen() const
{
    if(Visible || m_VisibleScreen >= c_screenCount)
        return *this;

    return Screens[m_VisibleScreen];
}

void Screen_t::set_canonical_screen(uint8_t index)
{
    m_CanonicalScreen = index;

    if(m_CanonicalScreen != 0)
    {
        Screen_t *mainScreen = &Screens[0];
        Screen_t &canScreen = canonical_screen();

        if(this >= mainScreen && this <= &Screens[c_screenCount - 1])
            canScreen.m_VisibleScreen = static_cast<uint8_t>(this - mainScreen);
        else
            canScreen.m_VisibleScreen = 0;

        canScreen.m_CanonicalScreen = 0;
        canScreen.players = players;
        canScreen.two_screen_pref = two_screen_pref;
        canScreen.four_screen_pref = four_screen_pref;
    }
}

int Screen_t::active_begin() const
{
    if(Type == ScreenTypes::SingleCoop && SingleCoop == 2)
        return 1;

    return 0;
}

int Screen_t::active_end() const
{
    if(!is_active())
        return 0;

    if(Type == ScreenTypes::SingleCoop && SingleCoop == 2)
        return 2;

    if(Type == ScreenTypes::TopBottom || Type == ScreenTypes::LeftRight)
        return 2;

    if(Type == ScreenTypes::Dynamic && vScreen(2).Visible)
        return 2;

    if(Type == ScreenTypes::Quad)
        return player_count <= maxLocalPlayers ? player_count : maxLocalPlayers;

    return 1;
}

int Screen_t::TargetX() const
{
    return XRender::TargetW / 2 - W / 2;
}

int Screen_t::TargetY() const
{
    return XRender::TargetH / 2 - H / 2;
}

void InitScreens()
{
    for(int s = 0; s < c_screenCount; s++)
    {
        // reset screen size and prefs
        Screens[s].W = 800;
        Screens[s].H = 600;
        Screens[s].CameraOverscanX = 0;
        Screens[s].two_screen_pref = MultiplayerPrefs::Dynamic;
        Screens[s].four_screen_pref = MultiplayerPrefs::Shared;

        // assign vScreens to screens
        for(int v = 0; v < maxLocalPlayers; v++)
        {
            Screens[s].vScreen_refs[v] = s * maxLocalPlayers + v + 1;
            Screens[s].vScreen(v + 1).screen_ref = s;
        }
    }

    // set canonical screens
    for(int s = 0; s < maxNetplayClients; s++)
    {
        Screens[s].set_canonical_screen(maxNetplayClients + s);
        Screens[maxNetplayClients + s].Visible = false;
    }

    // reset screens' players
    for(int s = 0; s < maxNetplayClients; s++)
    {
        Screens[s].players = {};
        Screens[s].player_count = 0;
    }

    UpdateScreenPlayers();
}

void UpdateScreenPlayers()
{
    // update canonical screens
    for(int s = 0; s < maxNetplayClients; s++)
    {
        Screens[s].canonical_screen().players = Screens[s].players;
        Screens[s].canonical_screen().player_count = Screens[s].player_count;
    }

    // assign players to vScreens
    for(int s = 0; s < c_screenCount; s++)
    {
        for(int v = 0; v < maxLocalPlayers; v++)
        {
            Screens[s].vScreen(v + 1).player = Screens[s].players[v];
        }
    }

    // update player screen indexes
    s_screenIdxByPlayer = {};
    for(int s = 0; s < maxNetplayClients; s++)
    {
        for(int p = 0; p < Screens[s].player_count; p++)
        {
            if(Screens[s].players[p] <= maxNetplayPlayers)
                s_screenIdxByPlayer[Screens[s].players[p]] = s;
        }
    }
}

void Screens_AssignPlayer(int player, Screen_t& screen)
{
    if(screen.player_count >= maxLocalPlayers)
        return;

    screen.players[screen.player_count] = player;
    screen.player_count++;

    UpdateScreenPlayers();
}

void Screens_DropPlayer(int player)
{
    // drop player itself
    for(int s = 0; s < maxNetplayClients; s++)
    {
        for(int i = 0; i < Screens[s].player_count; i++)
        {
            if(Screens[s].players[i] == player)
            {
                // shift other players left
                for(int j = i; j + 1 < Screens[s].player_count; j++)
                    Screens[s].players[j] = Screens[s].players[j + 1];

                // reduce player count
                Screens[s].player_count--;
            }
        }
    }

    // shift all player indices down
    for(int s = 0; s < maxNetplayClients; s++)
    {
        for(int i = 0; i < Screens[s].player_count; i++)
        {
            if(Screens[s].players[i] > player)
                Screens[s].players[i]--;
        }
    }

    UpdateScreenPlayers();
}

// finds the visible Screen that contains a specific player
int ScreenIdxByPlayer(int player)
{
    if(player > maxNetplayPlayers)
        return 0;

    return s_screenIdxByPlayer[player];
}

// finds the canonical Screen that contains a specific player
Screen_t& ScreenByPlayer_canonical(int player)
{
    Screen_t& visible_screen = ScreenByPlayer(player);

    return visible_screen.canonical_screen();
}

// finds the visible vScreen that contains a specific player
int vScreenIdxByPlayer(int player)
{
    if(player < 1 || player > maxLocalPlayers)
        return 0;

    Screen_t& screen = ScreenByPlayer(player);

    bool is_splitscreen = (screen.Type == 1 || screen.Type == 4 || (screen.Type == 5 && screen.vScreen(2).Visible) || screen.Type == 6 || screen.Type == ScreenTypes::Quad);

    if(is_splitscreen)
    {
        for(int i = 0; i < screen.player_count; i++)
        {
            if(player == screen.players[i])
                return screen.vScreen_refs[i];
        }
    }

    return screen.vScreen_refs[0];
}

// finds the canonical vScreen that contains a specific player
int vScreenIdxByPlayer_canonical(int player)
{
    if(player < 1 || player > maxLocalPlayers)
        return 0;

    Screen_t& screen = ScreenByPlayer_canonical(player);

    bool is_splitscreen = (screen.Type == 1 || screen.Type == 4 || (screen.Type == 5 && screen.vScreen(2).Visible) || screen.Type == 6 || screen.Type == ScreenTypes::Quad);

    if(is_splitscreen)
    {
        for(int i = 0; i < screen.player_count; i++)
        {
            if(player == screen.players[i])
                return screen.vScreen_refs[i];
        }
    }

    return screen.vScreen_refs[0];
}


================================================
FILE: src/screen.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef SCREEN_HHH
#define SCREEN_HHH

#include <array>

#include "range_arr.hpp"
#include "global_constants.h"

#include "numeric_types.h"

//Public Type vScreen 'Screen controls
struct qScreen_t
{
    // previously their own arrays, vScreenX and vScreenY
    num_t X = 0_n;
    num_t Y = 0_n;

//    Left As Double
    int Left = 0;
//    Top As Double
    int Top = 0;
//    Width As Double
    int Width = 0;
//    Height As Double
    int Height = 0;
//End Type

//    NEW: location on screen when vScreens are smaller due to level size
    int ScreenTop = 0;
    int ScreenLeft = 0;
};

struct vScreen_t : public qScreen_t
{
    struct SmallScreenFeatures_t
    {
        int16_t offset_x = 0;
        int16_t offset_y = 0;
        int16_t offset_y_hold = 0;
        int8_t last_buttons_held = 0;
    };

    SmallScreenFeatures_t small_screen_features;

//    tempX As Double
    num_t tempX = 0_n;
//    TempY As Double
    num_t TempY = 0_n;
//    TempDelay As Integer
    int TempDelay = 0;
//    Visible As Boolean
    bool Visible = false;

    // NEW: which screen the vScreen belongs to.
    uint8_t screen_ref = 0;

    // NEW: which player is associated with the vScreen. IMPORTANT: unused when shared screen mode is active
    uint8_t player = 0;

    //! left x-coordinate for drawing on the currently active render target
    int TargetX() const;

    //! top y-coordinate for start drawing on the currently active render target
    int TargetY() const;

    //! x-offset to add for render calls (based on X, and facilitates rounding)
    num_t CameraAddX() const;

    //! Y-offset to add for render calls (based on Y, and facilitates rounding)
    num_t CameraAddY() const;

    //! x-offset to add for render calls (based on X, but may be rounded)
    int CameraAddX_i() const;

    //! Y-offset to add for render calls (based on Y, but may be rounded)
    int CameraAddY_i() const;
};

constexpr int maxNetplayClients = 8;
constexpr int maxNetplayPlayers = maxNetplayClients * maxLocalPlayers;
constexpr int c_screenCount = 2 * maxNetplayClients;
constexpr int c_vScreenCount = c_screenCount * maxLocalPlayers;
constexpr int c_vScreenCount_visible = maxNetplayClients * maxLocalPlayers;

//Public vScreen(0 To 2) As vScreen 'Sets up the players screens
extern RangeArr<vScreen_t, 0, c_vScreenCount> vScreen;

//Public vScreen(0 To 2) As vScreen 'Sets up the players screens
extern RangeArr<qScreen_t, 0, c_vScreenCount> qScreenLoc;

namespace ScreenTypes
{
    enum ScreenTypes
    {
        SinglePlayer = 0,
        TopBottom = 1,
        Average = 2,
        SharedScreen = 3,
        LeftRight = 4,
        Dynamic = 5,
        SingleCoop = 6,
        Credits = 7,
        Quad = 9,
    };
}

namespace DScreenTypes
{
    enum DScreenTypes
    {
        Inactive = 0,
        LeftRight = 1,
        RightLeft = 2,
        BottomTop = 3,
        TopBottom = 4,
        Shared = 5,
        DiffSections = 6,
    };
}

// player-specified per-screen preferences for multiplayer mode
// (overridden by cheats SingleCoop and g_ClonedPlayerMode)
namespace MultiplayerPrefs
{
    enum MultiplayerPrefs
    {
        Dynamic = 0,
        Split = 1,     // means LeftRight in 2P mode
        Shared = 2,
        Max_4P = 2,
        TopBottom = 3, // 2P mode only
        Max_2P = 3,
    };
}

struct Screen_t
{
private:
    //! a reference to the canonical Screen for this screen (an 800x600 screen with the same players); 0 indicates that the screen itself is canonical
    uint8_t m_CanonicalScreen = 0;
    //! a reference to the visible Screen for a canonical screen
    uint8_t m_VisibleScreen = 0;

public:
    using localarr_t = std::array<uint8_t, maxLocalPlayers>;

    //! which vScreens belong to the screen
    localarr_t vScreen_refs;

    //! which players belong to the screen (no player may belong to multiple visible screens).
    localarr_t players;

    //! which characters have been requested
    localarr_t charSelect;

    //! how many active players in this screen (excluding cloned-player mode)
    int player_count = 0;

    //! whether this is being rendered by any client (not necessarily the local one)
    bool Visible = true;

    //! the logical width of the screen in pixels
    int W = 800;

    //! the logical height of the screen in pixels
    int H = 600;

    //! the amount of horizontal camera overscan in pixels (used for 3DS)
    int CameraOverscanX = 0;

    //! the currently active split mode for the screen
    int Type = ScreenTypes::SinglePlayer;

    //! the currently active dynamic split mode for the screen
    int DType = DScreenTypes::Inactive;

    //! the currently requested multiplayer modes for the screen
    int two_screen_pref = MultiplayerPrefs::Dynamic;
    int four_screen_pref = MultiplayerPrefs::Shared;

    inline bool is_active() const
    {
        return player_count != 0;
    }

    inline bool is_canonical() const
    {
        return m_CanonicalScreen == 0;
    }

    Screen_t& canonical_screen();
    const Screen_t& canonical_screen() const;

    Screen_t& visible_screen();
    const Screen_t& visible_screen() const;

    void set_canonical_screen(uint8_t index);

    // uses a 1-index to simplify conversion of legacy code
    inline vScreen_t& vScreen(size_t index) const
    {
        return ::vScreen[vScreen_refs[index - 1]];
    }

    //! First active vScreen index (0-indexed). Use to replace numScreens logic.
    int active_begin() const;

    //! Bound on active vScreen indexes (0-indexed). Use to replace numScreens logic.
    int active_end() const;

    //! left x-coordinate for drawing on the currently active render target
    int TargetX() const;

    //! top y-coordinate for start drawing on the currently active render target
    int TargetY() const;
};

//! a list of all screens (local and remote, visible and virtual)
extern RangeArr<Screen_t, 0, c_screenCount - 1> Screens;

void InitScreens();

// ensure that the vScreen players and canonical screen players are consistent with the primary screens' players
void UpdateScreenPlayers();

// assigns a player to a screen
void Screens_AssignPlayer(int player, Screen_t& screen);

// drop a player from the screens system, lowering the indices of all higher players (but does no other player drop logic)
void Screens_DropPlayer(int player);

// finds the visible Screen that contains a specific player
int ScreenIdxByPlayer(int player);

// finds the visible Screen that contains a specific player
inline Screen_t& ScreenByPlayer(int player)
{
    return Screens[ScreenIdxByPlayer(player)];
}

// finds the canonical Screen that contains a specific player
Screen_t& ScreenByPlayer_canonical(int player);

// finds the visible vScreen that contains a specific player
int vScreenIdxByPlayer(int player);

// finds the visible vScreen that contains a specific player
inline vScreen_t& vScreenByPlayer(int player)
{
    return vScreen[vScreenIdxByPlayer(player)];
}

// finds the canonical vScreen that contains a specific player
int vScreenIdxByPlayer_canonical(int player);

// finds the visible vScreen that contains a specific player
inline vScreen_t& vScreenByPlayer_canonical(int player)
{
    return vScreen[vScreenIdxByPlayer_canonical(player)];
}

//! the screen being rendered by the local client (or, try to make all uses of ScreenW / ScreenH occur in functions that get passed a screen?)
extern Screen_t* l_screen;

// define this macro at the top of a source file to force the file to access the screens in the modern way

#ifndef SCREEN_H_NO_HELPERS
//Public ScreenType As Integer 'The screen/view type
// extern int& ScreenType;
//Public DScreenType As Integer 'The dynamic screen setup
// extern int& DScreenType;

//Public ScreenType As Integer 'The screen/view type
// extern int& ScreenW;
//Public DScreenType As Integer 'The dynamic screen setup
// extern int& ScreenH;
#endif

#endif // #ifndef SCREEN_HHH


================================================
FILE: src/screen_fader.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <cmath>
#include <algorithm>

#include "sdl_proxy/sdl_stdinc.h"

#include "global_constants.h"
#include "globals.h" // vScreen
#include "range_arr.hpp"

#include "core/render.h"

#include "screen_fader.h"


#ifdef THEXTECH_BUILD_GL_MODERN
#    include <vector>
#    include "core/opengl/gl_program_bank.h"

static std::vector<LoadedGLProgramRef_t> s_loaded_effects;
#endif // #ifdef THEXTECH_BUILD_GL_MODERN


void ScreenFader::clearTransitEffects()
{
#ifdef THEXTECH_BUILD_GL_MODERN
    s_loaded_effects.clear();
#endif
}

int ScreenFader::loadTransitEffect(const std::string& name)
{
#ifdef THEXTECH_BUILD_GL_MODERN
    LoadedGLProgramRef_t effect = ResolveGLProgram("transit-" + name);

    if((int)effect < 0)
        return S_FADE;

    auto it = std::find(s_loaded_effects.begin(), s_loaded_effects.end(), effect);

    if(it != s_loaded_effects.end())
        return static_cast<int>(it - s_loaded_effects.begin()) + S_CUSTOM;

    s_loaded_effects.push_back(effect);

    return static_cast<int>(s_loaded_effects.size() - 1) + S_CUSTOM;
#else
    UNUSED(name);
    return S_FADE;
#endif
}

void ScreenFader::clearFader()
{
    m_active = false;
    m_current_fade = 0;
    m_target_fade = 0;
    m_step = 0;
    m_full = false;
    m_focusX = -1;
    m_focusY = -1;
    m_focusScreen = -1;
    m_focusSet = false;
    m_focusTrackX = nullptr;
    m_focusTrackY = nullptr;
    m_focusOffsetX = 0;
    m_focusOffsetY = 0;
}

void ScreenFader::setupFader(int step, int start, int goal, int shape, bool useFocus, int focusX, int focusY, int screen)
{
    m_shape = shape;
    m_current_fade = start;
    m_target_fade = goal;
    m_step = step;
    m_dirUp = start < goal;
    m_active = true;
    m_full = false;
    m_complete = false;
    m_focusSet = useFocus;
    m_focusX = focusX;
    m_focusY = focusY;
    m_focusScreen = screen;
    m_focusTrackX = nullptr;
    m_focusTrackY = nullptr;
    m_focusOffsetX = 0;
    m_focusOffsetY = 0;

#ifdef THEXTECH_BUILD_GL_MODERN
    if(m_shape >= S_CUSTOM && m_shape - S_CUSTOM < (int)s_loaded_effects.size() && s_loaded_effects[m_shape - S_CUSTOM]->get())
        m_focusUniform = XRender::registerUniform(*s_loaded_effects[m_shape - S_CUSTOM]->get(), "u_focus");
    else
        m_focusUniform = -1;
#endif
}

void ScreenFader::setTrackedFocus(num_t *x, num_t *y, num_t offX, num_t offY)
{
    m_focusTrackX = x;
    m_focusTrackY = y;
    m_focusOffsetX = offX;
    m_focusOffsetY = offY;
}

bool ScreenFader::isComplete()
{
    return m_complete;
}

bool ScreenFader::isVisible()
{
    return m_active || m_full;
}

bool ScreenFader::isFadingIn()
{
    return m_active && m_dirUp;
}

bool ScreenFader::isFadingOut()
{
    return m_active && !m_dirUp;
}

void ScreenFader::update()
{
    if(!m_active)
        return;

    if(m_focusSet)
    {
        if(m_focusTrackX)
            m_focusX = (int)(*m_focusTrackX + m_focusOffsetX);
        if(m_focusTrackY)
            m_focusY = (int)(*m_focusTrackY + m_focusOffsetY);
    }

    if(m_current_fade < m_target_fade)
    {
        m_current_fade += m_step;

        if(m_current_fade >= m_target_fade)
        {
            m_current_fade = m_target_fade;
            m_step = 0;

            if(m_current_fade >= 65)
            {
                m_full = true;
                m_complete = true;
            }
        }
    }
    else if(m_current_fade > m_target_fade)
    {
        m_current_fade -= m_step;

        if(m_current_fade <= m_target_fade)
        {
            m_current_fade = m_target_fade;
            m_step = 0;

            if(m_current_fade <= 0)
            {
                m_active = false;
                m_complete = true;
            }
        }
    }
}

void ScreenFader::draw(bool fullscreen)
{
    if(!m_active)
        return;

    int drawW = XRender::TargetW;
    int drawH = XRender::TargetH;

    if(m_focusScreen > 0 && m_focusScreen <= c_vScreenCount && !fullscreen)
    {
        drawW = vScreen[m_focusScreen].Width;
        drawH = vScreen[m_focusScreen].Height;
    }

    int focusX = m_focusSet ? m_focusX : (drawW / 2);
    int focusY = m_focusSet ? m_focusY : (drawH / 2);

    if(m_focusSet && m_focusScreen > 0 && m_focusScreen <= c_vScreenCount)
    {
        focusX += (int)vScreen[m_focusScreen].X;
        focusY += (int)vScreen[m_focusScreen].Y;

        if(fullscreen)
        {
            focusX += vScreen[m_focusScreen].TargetX();
            focusY += vScreen[m_focusScreen].TargetY();
        }
    }

    uint8_t alpha = m_current_fade * 255 / 65;

    switch(m_shape)
    {
    default:
#ifdef THEXTECH_BUILD_GL_MODERN
        if(XRender::userShadersSupported() && m_shape >= S_CUSTOM && m_shape - S_CUSTOM < (int)s_loaded_effects.size() && s_loaded_effects[m_shape - S_CUSTOM]->get())
        {
            StdPicture& effect = *s_loaded_effects[m_shape - S_CUSTOM]->get();

            if(m_focusUniform >= 0)
                XRender::assignUniform(effect, m_focusUniform, UniformValue_t((GLfloat)focusX, (GLfloat)focusY));

            XRender::renderTextureScale(0, 0, drawW, drawH, effect, XTAlpha(alpha));

            // if catastrophic failure, fallback to normal fader
            if(effect.inited)
                break;
        }
#endif // #ifdef THEXTECH_BUILD_GL_MODERN

    // fallthrough
    case S_FADE:
        XRender::renderRect(0, 0, drawW, drawH, color.with_alpha(alpha), true);
        break;

    case S_RECT:
        if(m_current_fade >= 65)
            XRender::renderRect(0, 0, drawW, drawH, color.with_alpha(alpha), true);
        else
        {
            int rightW = (drawW - focusX),
                bottomH = (drawH - focusY),
                leftW = focusX * m_current_fade / 65, // left side
                topY = focusY * m_current_fade / 65, // top side
                rightX = drawW - ((rightW * m_current_fade + 64) / 65) + 1, // right side
                bottomY = drawH - ((bottomH * m_current_fade + 64) / 65) + 1; // bottom side

            // Left side
            XRender::renderRect(0, 0, leftW, drawH, color, true);
            // right side
            XRender::renderRect(rightX, 0, rightW * m_current_fade / 65, drawH, color, true);
            // Top side
            XRender::renderRect(0, 0, drawW, topY, color, true);
            // Bottom side
            XRender::renderRect(0, bottomY, drawW, bottomH * m_current_fade / 65, color, true);
        }
        break;

    case S_CIRCLE:
        if(m_current_fade >= 65)
            XRender::renderRect(0, 0, drawW, drawH, color.with_alpha(alpha), true);
        else
        {
            // int radius = drawH - (drawH * m_scale);
            int maxRadius = 0, maxRadiusPre;

            // top-left corner
            maxRadiusPre = (int)num_t::sqrt(focusX * focusX + focusY * focusY);
            if(maxRadius < maxRadiusPre)
                maxRadius = maxRadiusPre;

            // top-right corner
            maxRadiusPre = (int)num_t::sqrt((drawW - focusX) * (drawW - focusX) + focusY * focusY);
            if(maxRadius < maxRadiusPre)
                maxRadius = maxRadiusPre;

            // bottom-left corner
            maxRadiusPre = (int)num_t::sqrt(focusX * focusX + (drawH - focusY) * (drawH - focusY));
            if(maxRadius < maxRadiusPre)
                maxRadius = maxRadiusPre;

            // bottom-right corner
            maxRadiusPre = (int)num_t::sqrt((drawW - focusX) * (drawW - focusX) + (drawH - focusY) * (drawH - focusY));
            if(maxRadius < maxRadiusPre)
                maxRadius = maxRadiusPre;

            int radius = maxRadius - (maxRadius * m_current_fade / 65);

            XRender::renderCircleHole(focusX, focusY, radius, color);
            // left side
            XRender::renderRect(0, 0, focusX - radius, drawH, color, true);
            // right side
            XRender::renderRect(focusX + radius, 0, drawW - (focusX + radius), drawH, color, true);
            // Top side
            XRender::renderRect(0, 0, drawW, focusY - radius + 1, color, true);
            // Bottom side
            XRender::renderRect(0, focusY + radius, drawW, drawH - (focusY + radius), color, true);
        }
        break;

    case S_FLIP_H:
        if(m_current_fade >= 65)
            XRender::renderRect(0, 0, drawW, drawH, color.with_alpha(alpha), true);
        else
        {
            int center = (drawH / 2);
            int sideHeight = (center * m_current_fade + 64) / 65;
            XRender::renderRect(0, 0, drawW, sideHeight, color, true);
            XRender::renderRect(0, drawH - sideHeight, drawW, sideHeight, color, true);
        }
        break;

    case S_FLIP_V:
        if(m_current_fade >= 65)
            XRender::renderRect(0, 0, drawW, drawH, color.with_alpha(alpha), true);
        else
        {
            int center = (drawW / 2);
            int sideWidth = (center * m_current_fade + 64) / 65;
            XRender::renderRect(0, 0, sideWidth, drawH, color, true);
            XRender::renderRect(drawW - sideWidth, 0, sideWidth, drawH, color, true);
        }
        break;
    }
}


================================================
FILE: src/screen_fader.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SCREEN_FADER_H
#define SCREEN_FADER_H

#include <string>

struct ScreenFader
{
    enum Shape
    {
        S_FADE = 0,
        S_RECT,
        S_CIRCLE,
        S_FLIP_H,
        S_FLIP_V,
        // must be higher than all LevelDoor::TRANSIT_*
        S_CUSTOM = 16,
    };

    bool m_active = false;
    bool m_full = false;
    bool m_complete = false;
    bool m_dirUp = false;

    // each with a denominator of 65
    int m_current_fade = 0;
    int m_target_fade = 0;
    int m_step = 0;

    XTColor color = {0, 0, 0};

    // Focus on the point (using circle or rectangular effect)
    int m_focusUniform = -1;
    int m_focusX = -1;
    int m_focusY = -1;
    int m_focusScreen = -1;
    bool m_focusSet = false;

    num_t *m_focusTrackX = nullptr;
    num_t *m_focusTrackY = nullptr;
    num_t m_focusOffsetX = 0.0_n;
    num_t m_focusOffsetY = 0.0_n;

    int m_shape = S_FADE;

    static void clearTransitEffects();
    static int loadTransitEffect(const std::string& name);

    void clearFader();

    void setupFader(int step, int start, int goal, int shape, bool useFocus = false, int focusX = -1, int focusY = -1, int screen = -1);
    void setTrackedFocus(num_t *x, num_t *y, num_t offX, num_t offY);

    bool isComplete();
    bool isVisible();
    bool isFadingIn();
    bool isFadingOut();

    void update();

    // fullscreen should be false if the fader is being drawn inside a vScreen, otherwise true
    void draw(bool fullscreen = true);
};

#endif // SCREEN_FADER_H


================================================
FILE: src/script/luau/test.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <cstdlib>
#include <Utils/files.h>
#include <Logger/logger.h>

#include <lua.h>
#include <luacode.h>
#include <lualib.h>

#include "global_dirs.h"

#include "script/luau/test.h"

lua_State* L = nullptr;
bool working = false;

static void *l_alloc (void *ud, void *ptr, size_t osize,
                                           size_t nsize) {
  (void)ud;  (void)osize;  /* not used */
  if (nsize == 0) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

void load_test_script()
{
    working = false;
    if(L)
    {
        lua_close(L);
        L = nullptr;
    }

    Files::Data d = Files::load_file(g_dirEpisode.resolveFileCaseExistsAbs("test.luau"));

    if(d.empty())
        return;

    size_t bytecodeSize = 0;
    char* bytecode = luau_compile(d.c_str(), d.size(), NULL, &bytecodeSize);
    if(!bytecode)
        return;

    L = lua_newstate(l_alloc, nullptr);
    luaopen_base(L);

    if(!L)
    {
        free(bytecode);
        return;
    }

    int result = luau_load(L, "chunk", bytecode, bytecodeSize, 0);
    if(result == 0)
    {
        if(lua_pcall(L, 0, 0, 0) == 0)
            working = true;
        else
        {
            pLogWarning("Error when loading code: %s", lua_tostring(L, -1));
            lua_pop(L, 1);
        }
    }
    else
    {
        pLogWarning("Error when compiling code: %s", lua_tostring(L, -1));
        lua_pop(L, 1);
    }

    luaL_sandbox(L);

    run_test_script();
    run_test_script();
}

void run_test_script()
{
    if(working)
    {
        lua_getfield(L, LUA_GLOBALSINDEX, "main");
        if(lua_pcall(L, 0, 0, 0) != 0)
        {
            pLogWarning("Error when calling main: %s", lua_tostring(L, -1));
            lua_pop(L, 1);
        }
    }
}


================================================
FILE: src/script/luau/test.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef THEXTECH_LUAU_TEST_H
#define THEXTECH_LUAU_TEST_H

void load_test_script();
void run_test_script();

#endif // #ifndef THEXTECH_LUAU_TEST_H


================================================
FILE: src/script/luna/autocode.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <list>
#include <unordered_map>

#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_stdinc.h"

#include "autocode.h"
#include "autocode_manager.h"
#include "lunamisc.h"
#include "sprite_funcs.h"
#include "csprite.h"
#include "globals.h"
#include "global_dirs.h"
#include "player.h"
#include "graphics.h"
#include "sound.h"
#include "layers.h"
#include "core/msgbox.h"
#include "main/cheat_code.h"
#include "luna.h"
#include "lunarender.h"
#include "lunaplayer.h"
#include "lunalevel.h"
#include "lunanpc.h"
#include "lunalayer.h"
#include "lunablock.h"
#include "lunaspriteman.h"
#include "lunainput.h"
#include "lunavarbank.h"
#include "lunacounter.h"
#include "renderop_string.h"
#include "mememu.h"
#include "config.h"

#include "main/trees.h"

static inline int s_round2int(num_t d)
{
    return num_t::floor(d + 0.5_n);
}

static FIELDTYPE StrToFieldtype(std::string string)
{
    string.erase(string.find_last_not_of(" \n\r\t") + 1);
    if(string == "b")
        return FT_BYTE;
    else if(string == "s" || string == "w")
        return FT_WORD;
    else if(string == "dw")
        return FT_DWORD;
    else if(string == "f")
        return FT_FLOAT;
    else if(string == "df")
        return FT_DFLOAT;

    return FT_BYTE;
}


Autocode::Autocode()
{
    m_Type = AT_Invalid;
}

Autocode::Autocode(AutocodeType iType, num_t iTarget, num_t ip1, num_t ip2, num_t ip3,
                   const stringindex_t& ip4, num_t iLength, int iSection, const stringindex_t& iVarRef)
{
    m_Type = iType;
    Target = iTarget;
    Param1 = ip1;
    Param2 = ip2;
    Param3 = ip3;
    Length = iLength;
    MyString = ip4;
    MyRef = iVarRef;
    m_OriginalTime = iLength;
    ftype = FT_INVALID;
    Activated = true;
    Expired = false;
    //comp = nullptr;

    // Adjust section
    ActiveSection = (iSection < 1000 ? --iSection : iSection);
    Activated = (iSection < 1000);
}

Autocode::Autocode(const Autocode &o)
{
    operator=(o);
}

Autocode &Autocode::operator=(const Autocode &o)
{
    m_Type = o.m_Type;

    Target = o.Target;
    Param1 = o.Param1;
    Param2 = o.Param2;
    Param3 = o.Param3;
    Length = o.Length;
    // de-duplicate strings, while re-using allocated string indices if possible
    MyString = o.MyString;
    MyRef = o.MyRef;

    m_OriginalTime = o.m_OriginalTime;
    ActiveSection = o.ActiveSection;
    ftype = o.ftype;
    Activated = o.Activated;
    Expired = o.Expired;

    return *this;
}

// DO - Perform autocodes for this section. Only does init codes if "init" is set
void Autocode::Do(bool init)
{
    // Is it expired?
    if(Expired || !Activated)
        return;

    // Make sure game is in OK state to run
    Player_t *demo = PlayerF::Get(1);
    const vScreen_t& vscreen = vScreenByPlayer(1);

    if(!demo)
        return;

    // Only allow initrun on codes set to section -1
    if(init)
        init = (uint8_t)ActiveSection == (uint8_t)0xFE;

    // Run this code if "always" section, or if current section is a match, or forced by init
    if((uint8_t)ActiveSection == (uint8_t)0xFF || demo->Section == ActiveSection || init)
    {
        int pretick_len = (int)this->Length;
        this->SelfTick();

        // Run specified autocode
        switch(m_Type)
        {
        // INVALID
        case 0 /*Invalid*/:
        default:
            break;

        // FILTERS
        case AT_FilterToSmall:
        {
            PlayerF::FilterToSmall(demo);
            break;
        }
        case AT_FilterToBig:
        {
            PlayerF::FilterToBig(demo);
            break;
        }
        case AT_FilterToFire:
        {
            PlayerF::FilterToFire(demo);
            break;
        }
        case AT_FilterMount:
        {
            PlayerF::FilterMount(demo);
            break;
        }
        case AT_FilterReservePowerup:
        {
            PlayerF::FilterReservePowerup(demo);
            break;
        }

        case AT_FilterPlayer:
        {
            // Player_t *demo = PlayerF::Get(1); // Already declared above
            //if(demo) // Useless, null check was done above
            //{
            if(demo->Character == Param1)
            {
                if(Param2 > 0 && Param2 < 6)
                    demo->Character = (int)Param2;
            }
            //}
            break;
        }

        // INFINITE FLYING
        case AT_InfiniteFlying:
            PlayerF::InfiniteFlying(1);
            break;

        // SET HEARTS
        case AT_SetHearts:
            demo->Hearts = (short)Param1;
            if(Param1 > 1 && demo->State < 2)
                demo->State = 2;
            break;

        // HEART SYSTEM
        case AT_HeartSystem:
            HeartSystem();
            break;

        // SCREEN EDGE BUFFER
        case AT_ScreenEdgeBuffer:
        {
            //char* dbg = "SCREEN EDGE DBG";

            // Get all target NPCs in section into a list (slow, could easily optimize using NPCQueues::Active.no_change)
            std::list<NPC_t *> npcs;
            NpcF::FindAll((int)Target, demo->Section, &npcs);

            if(!npcs.empty())
            {
                // Loop over list of NPCs
                for(auto npc : npcs)
                {
                    switch((int)Param1)
                    {
                    default:
                    case 0: // UP
                    {
                        //double* pCamera = vScreenY;
                        num_t top = -vscreen.Y;
                        if(npc->Location.Y < top + Param2)
                        {
                            npc->Location.Y = (top + Param2) + 1;
                            treeNPCUpdate(npc);
                        }
                        break;
                    }

                    case 1:  // DOWN
                    {
                        //double* pCamera = GM_CAMERA_Y;
                        num_t bot = -vscreen.Y + vscreen.Height;
                        if(npc->Location.Y > bot - Param2)
                        {
                            npc->Location.Y = (bot - Param2) - 1;
                            treeNPCUpdate(npc);
                        }
                        break;
                    }

                    case 2: // LEFT
                    {
                        //double* pCamera = GM_CAMERA_X;
                        num_t left = -vscreen.X;
                        if(npc->Location.X < left + Param2)
                        {
                            npc->Location.X = (left + Param2) + 1;
                            treeNPCUpdate(npc);
                        }
                        break;
                    }

                    case 3: // RIGHT
                    {
                        //double* pCamera = GM_CAMERA_X;
                        num_t rt = -vscreen.X + vscreen.Width;
                        if(npc->Location.Y > rt - Param2)
                        {
                            npc->Location.Y = (rt - Param2) - 1;
                            treeNPCUpdate(npc);
                        }
                        break;
                    }
                    }
                }
            }
            break;
        }



        // SHOW TEXT
        case AT_ShowText:
            Renderer::Get().AddOp(new RenderStringOp(GetS(MyString), (int)Param3, s_round2int(Param1), s_round2int(Param2)));
            break;

        // SHOW NPC LIFE LEFT
        case AT_ShowNPCLifeLeft:
        {
            int base_health = SDL_atoi(GetS(MyString).data());
            NPC_t *npc = NpcF::GetFirstMatch((int)Target, (int)Param3 - 1);
            if(npc != nullptr)
            {
                //float hits = *(((float *)((&(*(uint8_t *)npc)) + 0x148)));
                int hits = npc->Damage;
                Renderer::Get().AddOp(new RenderStringOp(fmt::format_ne("{0}", (base_health - hits)), 3, s_round2int(Param1), s_round2int(Param2)));
            }
            else
                Renderer::Get().AddOp(new RenderStringOp("?", 3, s_round2int(Param1), s_round2int(Param2)));
            break;
        }

        // Show level's internal name (or show the filename if empty)
        case AT_ShowLevelName:
            Renderer::Get().AddOp(new RenderStringOp(LevelName.empty() ? FileName : LevelName, (int)Param3, s_round2int(Param1), s_round2int(Param2)));
            break;

        // Show level's file name (without extension)
        case AT_ShowLevelFile:
            Renderer::Get().AddOp(new RenderStringOp(FileName, (int)Param3, s_round2int(Param1), s_round2int(Param2)));
            break;

        // AUDIO
        case AT_SFX:
        {
            if(this->Length <= 1) // Play once when delay runs out
            {
                // Play built in sound
                if(Param1 > 0)
                    PlaySound((int)Param1);
                else
                {
                    // Sound from level folder
                    if(GetS(MyString).length() > 0)
                    {
                        //char* dbg = "CUSTOM SOUND PLAY DBG";
                        std::string full_path = g_dirCustom.resolveFileCaseAbs(GetS(MyString));
                        PlayExtSound(full_path);
                    }

                }
                expire();
            }
            break;
        }

        case AT_PlaySFX:
        {
            if(this->Length <= 1) // Play once when delay runs out
            {
                // Play built in sound
                if(Param1 > 0)
                    PlaySound((int)Param1, (int)Param2, (int)(Param3 <= 0 ? 128 : Param3));
                else
                {
                    // Sound from level folder
                    if(GetS(MyString).length() > 0)
                    {
                        //char* dbg = "CUSTOM SOUND PLAY DBG";
                        std::string full_path = g_dirCustom.resolveFileCaseAbs(GetS(MyString));
                        PlayExtSound(full_path, (int)Param2, (int)(Param3 <= 0 ? 128 : Param3));
                    }

                }
                expire();
            }
            break;
        }

        case AT_StopSFX:
        {
            if(this->Length <= 1) // Stop once when delay runs out
            {
                // Sound from level folder
                if(GetS(MyString).length() > 0)
                {
                    //char* dbg = "CUSTOM SOUND STOP DBG";
                    std::string full_path = g_dirCustom.resolveFileCaseAbs(GetS(MyString));
                    StopExtSound(full_path);
                }
                expire();
            }
            break;
        }

        case AT_SFXPreLoad:
        {
            if(this->Length <= 1) // Preload custom SFX file
            {
                // Sound from level folder
                if(GetS(MyString).length() > 0)
                {
                    //char* dbg = "CUSTOM SOUND PLAY DBG";
                    std::string full_path = g_dirCustom.resolveFileCaseAbs(GetS(MyString));
                    PreloadExtSound(full_path);
                }
                expire();
            }
            break;
        }

        case AT_SetMusic:
        {
            int sec = (int)Target - 1;
            if(sec >= 0 && sec < numSections)
            {
                if(Param1 >= 0 && Param1 <= 24)
                    bgMusic[sec] = (int)Param1;
                if(GetS(MyString).length() >= 5)
                    CustomMusic[sec] = GetS(MyString);
            }
            break;
        }

        case AT_PlayMusic:
        {
            if(Length <= 1)   // Play once when delay runs out
            {
                StartMusic((int)Param1 - 1);
                expire();
            }
            break;
        }

        // EVENTS & BRANCHES
        case AT_Trigger:
        {
            expire();
            gAutoMan.ActivateCustomEvents((int)Target, (int)Param1);
            break;
        }

        case AT_Timer:
            if(Param2 != 0) // Display timer?
            {
                Renderer::Get().AddOp(new RenderStringOp("TIMER", 3, 600, 27));
                Renderer::Get().AddOp(new RenderStringOp(fmt::format_ne("{0}", (int64_t)Length / 60), 3, 618, 48));
            }

            if(Length == 1 || Length == 0)
            {
                if(Length == 1)
                    expire();

                Autocode::DoPredicate((int)Target, (int)Param1);

                // Reset time?
                if(Param3 != 0)
                {
                    Activated = true;
                    Expired = false;
                    Length = m_OriginalTime;
                }
            }
            break;

        case AT_IfNPC:
        {
            if(numNPCs < 1)
                break;

            if(Autocode::NPCConditional((int)Target, (int)Param1))
            {
                RunSelfOption();
                gAutoMan.ActivateCustomEvents((int)Param2, (int)Param3);
            }
            break;
        }

        case AT_BlockTrigger:
        {
            if(Target == 0) //if target is player
            {
                if(BlocksF::IsPlayerTouchingType((int)Param1, (int)Param2, demo))
                {
                    RunSelfOption();
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                }
            }
            break;
        }

        case AT_IfCompatMode:
        {
            if(CheckConditionI(g_config.compatibility_mode, (int)Param2, (COMPARETYPE)(int)Param1))
                gAutoMan.ActivateCustomEvents(0, (int)Param3);
            break;
        }

        case AT_IfSpeedRunMode:
        {
            if(CheckConditionI(g_config.speedrun_mode.m_value, (int)Param2, (COMPARETYPE)(int)Param1))
                gAutoMan.ActivateCustomEvents(0, (int)Param3);
            break;
        }

        case AT_TriggerRandom:
        {
            int choice = iRand2(4);
            switch(choice)
            {
            default:
                break;
            case 0:
                gAutoMan.ActivateCustomEvents(0, (int)Target);
                break;
            case 1:
                gAutoMan.ActivateCustomEvents(0, (int)Param1);
                break;
            case 2:
                gAutoMan.ActivateCustomEvents(0, (int)Param2);
                break;
            case 3:
                gAutoMan.ActivateCustomEvents(0, (int)Param3);
                break;
            }
            break;
        }

        case AT_TriggerRandomRange:
        {
            if(Target >= Param1) // rule out bad values
                break;

            int diff = (int)Param1 - (int)Target;
            int choice = iRand2(diff);
            gAutoMan.ActivateCustomEvents(0, (int)Target + choice);
            break;
        }

        case AT_TriggerZone:
        {
            Length++; // undo length decrement
            if(demo->Location.X > Param3 &&
               demo->Location.Y > Param1 &&
               demo->Location.Y < Param2 &&
               demo->Location.X < Length)
            {
                gAutoMan.ActivateCustomEvents(0, (int)Target);
                RunSelfOption();
            }
            break;
        }

        case AT_ScreenBorderTrigger:
        {
            LunaRect player_screen_rect = PlayerF::GetScreenPosition(demo);
            int depth = 0;
            if(GetS(MyString).length() > 0)
                depth = SDL_atoi(GetS(MyString).c_str());

            double L_edge = 0 + depth;
            double U_edge = 0 + depth;
            double D_edge = vscreen.Height - depth;
            double R_edge = vscreen.Width - depth;

            if(demo->WarpCD < 1)
            {
                if(player_screen_rect.left <= L_edge && demo->Location.SpeedX < 0)
                {
                    gAutoMan.ActivateCustomEvents(0, (int)Target);
                    demo->WarpCD = 2;
                }
                else if(player_screen_rect.top <= U_edge  && demo->Location.SpeedY < 0)
                {
                    gAutoMan.ActivateCustomEvents(0, (int)Param1);
                    demo->WarpCD = 2;
                }
                else if(player_screen_rect.right >= R_edge  && demo->Location.SpeedX > 0)
                {
                    gAutoMan.ActivateCustomEvents(0, (int)Param2);
                    demo->WarpCD = 2;
                }
                else if(player_screen_rect.bottom >= D_edge && demo->Location.SpeedY > 0)
                {
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                    demo->WarpCD = 2;
                }
            }
            break;
        }

        case AT_OnInput:
        {
            switch((int)Param1)
            {
            case 1: // Up
                if(Param2 == 1 && Input::UpThisFrame()) // First frame press only
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                else if(Param2 != 1 && Input::PressingUp()) // Any press
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                break;

            case 2: // Down
                if(Param2 == 1 && Input::DownThisFrame()) // First frame press only
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                else if(Param2 != 1 && Input::PressingDown()) // Any press
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                break;

            case 3: // Left
                if(Param2 == 1 && Input::LeftThisFrame()) // First frame press only
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                else if(Param2 != 1 && Input::PressingLeft()) // Any press
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                break;

            case 4: // Right
                if(Param2 == 1 && Input::RightThisFrame()) // First frame press only
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                else if(Param2 != 1 && Input::PressingRight()) // Any press
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                break;

            case 5: //Run
                if(Param2 == 1 && Input::RunThisFrame()) // First frame press only
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                else if(Param2 != 1 && Input::PressingRun()) // Any press
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                break;

            case 6: //Jump
                if(Param2 == 1 && Input::JumpThisFrame()) // First frame press only
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                else if(Param2 != 1 && Input::PressingJump()) // Any press
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
                break;
            }
            break;
        }

        case AT_OnPlayerMem:
        {
            if(ftype == FT_INVALID)
            {
                ftype = FT_BYTE;
                ftype = StrToFieldtype(GetS(MyString));
            }
//            uint8_t *ptr = (uint8_t *)demo;
//            ptr += (int)Target; // offset
            bool triggered = CheckMem(demo, (size_t)Target, Param1, (COMPARETYPE)(int)Param2, ftype);
            if(triggered)
                gAutoMan.ActivateCustomEvents(0, (int)Param3);
            break;
        }

        case AT_OnGlobalMem:
        {
            if(ftype == FT_INVALID)
            {
                ftype = FT_BYTE;
                ftype = StrToFieldtype(GetS(MyString));
            }

            bool triggered = CheckMem((size_t)Target, Param1, (COMPARETYPE)(int)Param2, ftype);
            if(triggered)
                gAutoMan.ActivateCustomEvents(0, (int)Param3);
            break;
        }

        // USER VARS
        case AT_SetVar:
        {
            if(ReferenceOK())
                gAutoMan.VarOperation(GetS(MyRef), Param2, (OPTYPE)(int)Param1);
            else
                gAutoMan.VarOperation(GetS(MyString), Param2, (OPTYPE)(int)Param1);
            break;
        }

        case AT_CopyVar:
        {
            if(ReferenceOK() && MyString != STRINGINDEX_NONE && gAutoMan.VarExists(GetS(MyString)))
                gAutoMan.VarOperation(GetS(MyRef), gAutoMan.GetVar(GetS(MyString)), (OPTYPE)(int)Param1);
            break;
        }

        case AT_LoadPlayerVar:
        {
            if(!this->ReferenceOK() || Param1 > (0x184 * 99))
                break;

            if(ftype == FT_INVALID)
            {
                ftype = FT_BYTE;
                ftype = StrToFieldtype(GetS(MyString));
            }

            // Get the memory
            //uint8_t *ptr = (uint8_t *)demo;
            //ptr += (int)Param1; // offset
            num_t gotval = GetMem(demo, (size_t)Param1, ftype);

            // Perform the load/add/sub/etc operation on the banked variable using the ref as the name
            gAutoMan.VarOperation(GetS(MyRef), gotval, (OPTYPE)(int)Param2);

            break;
        }

        case AT_LoadNPCVar:
        {
            if(!this->ReferenceOK() || Param1 > (0x158))
                break;
            if(ftype == FT_INVALID)
            {
                ftype = FT_BYTE;
                ftype = StrToFieldtype(GetS(MyString));
            }

            NPC_t *pFound_npc = NpcF::GetFirstMatch((int)Target, (int)Param3);
            if(pFound_npc != nullptr)
            {
                num_t gotval = GetMem(pFound_npc, (size_t)Param1, ftype);
                gAutoMan.VarOperation(GetS(MyRef), gotval, (OPTYPE)(int)Param2);
            }

            break;
        }

        case AT_LoadGlobalVar:
        {
            if(Target >= GM_BASE && Param1 <=  GM_END && ReferenceOK())
            {
                if(ftype == FT_INVALID)
                {
                    ftype = FT_BYTE;
                    ftype = StrToFieldtype(GetS(MyString));
                }

                // byte *ptr = (byte *)(int)Target;
                num_t gotval = GetMem((size_t)Target, ftype);
                gAutoMan.VarOperation(GetS(MyRef), gotval, (OPTYPE)(int)Param1);
            }
            break;
        }

        case AT_IfVar:
        {
            if(!ReferenceOK())
            {
                InitIfMissing(&gAutoMan.m_UserVars, GetS(MyString), 0);// Initalize var if not existing
            }
            num_t varval;
            if(ReferenceOK())
                varval = gAutoMan.m_UserVars[GetS(MyRef)];
            else
                varval = gAutoMan.m_UserVars[GetS(MyString)];

            // Check if the value meets the criteria and activate event if so
            if(CheckConditionD(varval, Param2, (COMPARETYPE)(int)Param1))
                gAutoMan.ActivateCustomEvents(0, (int)Param3);

            break;
        }

        case AT_CompareVar:
        {
            if(ReferenceOK())
            {
                auto compare_type = (COMPARETYPE)(int)Param1;
                InitIfMissing(&gAutoMan.m_UserVars, GetS(MyString), 0);
                InitIfMissing(&gAutoMan.m_UserVars, GetS(MyRef), 0);

                num_t var1 = gAutoMan.m_UserVars[GetS(MyRef)];
                num_t var2 = gAutoMan.m_UserVars[GetS(MyString)];

                if(CheckConditionD(var1, var2, compare_type))
                    gAutoMan.ActivateCustomEvents(0, (int)Param3);
            }
            break;
        }

        case AT_ShowVar:
        {
            if(ReferenceOK())
            {
                std::string str = fmt::format_ne("{0}", (double)gAutoMan.GetVar(GetS(MyRef)));
                if(GetS(MyString).length() > 0)
                    str = GetS(MyString) + str;
                Renderer::Get().AddOp(new RenderStringOp(str, (int)Param3, s_round2int(Param1), s_round2int(Param2)));
            }
            break;
        }

        case AT_BankVar:
        {
            if(GetS(MyString).length() > 0)
                gSavedVarBank.SetVar(GetS(MyString), gAutoMan.GetVar(GetS(MyString)));
            break;
        }

        case AT_WriteBank:
        {
            gSavedVarBank.WriteBank();
            break;
        }


        // LUNA CONTROL
        case AT_LunaControl:
        {
            Autocode::LunaControl((LunaControlAct)(int)Target, (int)Param1);
            break;
        }


        // DELETE COMMAND
        case AT_DeleteCommand:
        {
            gAutoMan.DeleteEvent(GetS(MyString));
            break;
        }

        // MOD PARAM
        case AT_ModParam:
        {
            if(Target < 6 && Target > 0)
            {
                Autocode *coderef = nullptr;
                coderef = gAutoMan.GetEventByRef(GetS(MyString));
                if(coderef)
                {
                    switch((int)Target)
                    {
                    case 1:
                        Autocode::modParam(coderef->Target, Param1, (OPTYPE)(int)Param2);
                        break;
                    case 2:
                        Autocode::modParam(coderef->Param1, Param1, (OPTYPE)(int)Param2);
                        break;
                    case 3:
                        Autocode::modParam(coderef->Param2, Param1, (OPTYPE)(int)Param2);
                        break;
                    case 4:
                        Autocode::modParam(coderef->Param3, Param1, (OPTYPE)(int)Param2);
                        break;
                    case 5:
                        Autocode::modParam(coderef->Length, Param1, (OPTYPE)(int)Param2);
                        break;
                    }
                }
            }
            break;
        }

        // ChangeTime
        case AT_ChangeTime:
        {
            Autocode *coderef = nullptr;
            coderef = gAutoMan.GetEventByRef(GetS(MyString));
            if(coderef)
                Autocode::modParam(coderef->Length, Param1, (OPTYPE)(int)Param2);
            break;
        }

        // INPUT BUFFER STUFF
        case AT_OnCustomCheat:
        {
            if(cheats_contains(GetS(MyString)))
            {
                gAutoMan.ActivateCustomEvents(0, (int)Param3);
                cheats_clearBuffer();
                if(Param2 != 0)
                    this->expire();
            }
            break;
        }

        case AT_ClearInputString:
        {
            //wchar_t* dbg = L"ClearInputString debug";
            cheats_clearBuffer();
            break;
        }

        case AT_RunCheat:
        {
            if(this->Length <= 1) // Play once when delay runs out
            {
                cheats_setBuffer(GetS(MyString), true);
                this->expire();
            }
            break;
        }

        case AT_DeleteEventsFrom:
        {
            gAutoMan.ForceExpire((int)Target);
            break;
        }

        // LAYER CONTROL
        case AT_LayerXSpeed:
        {
            Layer_t *layer = LayerF::Get((int)Target);
            if(layer)
            {
                LayerF::SetXSpeed(layer, num_t::from_double(SDL_atof(GetS(MyString).c_str())));
                if(Length == 1 && Param1 != 0)
                    LayerF::SetXSpeed(layer, 0.0001_n);
            }
            break;
        }

        case AT_LayerYSpeed:
        {
            Layer_t *layer = LayerF::Get((int)Target);
            if(layer)
            {
                LayerF::SetYSpeed(layer, num_t::from_double(SDL_atof(GetS(MyString).c_str())));
                if(Length == 1 && Param1 != 0)
                    LayerF::SetYSpeed(layer, 0.0001_n);
            }
            break;
        }

        case AT_AccelerateLayerX:
        {
            Layer_t *layer = LayerF::Get((int)Target);
            if(layer)
            {
                num_t accel = num_t::from_double(SDL_atof(GetS(MyString).c_str()));
                if(num_t::abs((num_t)layer->SpeedX) + num_t::abs(accel) >= num_t::abs(Param1))
                    LayerF::SetXSpeed(layer, Param1);
                else
                    LayerF::SetXSpeed(layer, (num_t)layer->SpeedX + accel);
            }
            break;
        }

        case AT_AccelerateLayerY:
        {
            Layer_t *layer = LayerF::Get((int)Target);
            if(layer)
            {
                num_t accel = num_t::from_double(SDL_atof(GetS(MyString).c_str()));
                if(num_t::abs((num_t)layer->SpeedY) + num_t::abs(accel) >= num_t::abs((num_t)Param1))
                    LayerF::SetYSpeed(layer, Param1);
                else
                    LayerF::SetYSpeed(layer, (num_t)layer->SpeedY + accel);
            }
            break;
        }

        case AT_DeccelerateLayerX:
        {
            Layer_t *layer = LayerF::Get((int)Target);
            if(layer)
            {
                num_t deccel = num_t::from_double(SDL_atof(GetS(MyString).c_str()));
                deccel = num_t::abs(deccel);
                if(layer->SpeedX > 0)
                {
                    layer->SpeedX = numf_t((num_t)layer->SpeedX - deccel);
                    if(layer->SpeedX < 0)
                        LayerF::Stop(layer);
                }
                else if(layer->SpeedX < 0)
                {
                    layer->SpeedX = numf_t((num_t)layer->SpeedX + deccel);
                    if(layer->SpeedX > 0)
                        LayerF::Stop(layer);
                }
            }
            break;
        }


        case AT_DeccelerateLayerY:
        {
            Layer_t *layer = LayerF::Get((int)Target);
            if(layer)
            {
                num_t deccel = num_t::from_double(SDL_atof(GetS(MyString).c_str()));
                deccel = num_t::abs(deccel);
                if(layer->SpeedY > 0)
                {
                    layer->SpeedY = numf_t((num_t)layer->SpeedY - deccel);
                    if(layer->SpeedY < 0)
                        LayerF::Stop(layer);
                }
                else if(layer->SpeedY < 0)
                {
                    layer->SpeedY = numf_t((num_t)layer->SpeedY + deccel);
                    if(layer->SpeedY > 0)
                        LayerF::Stop(layer);
                }
            }
            break;
        }

        // BLOCK MODIFIERS
        case AT_SetAllBlocksID:
        {
            BlocksF::SetAll((int)Target, (int)Param1);
            break;
        }

        case AT_SwapAllBlocks:
        {
            BlocksF::SwapAll((int)Target, (int)Param1);
            break;
        }

        case AT_ShowAllBlocks:
        {
            BlocksF::ShowAll((int)Target);
            break;
        }

        case AT_HideAllBlocks:
        {
            BlocksF::HideAll((int)Target);
            break;
        }


        case AT_PushScreenBoundary:
        {
            int sec = (int)Target - 1;
            if(sec >= 0 && sec < numSections && Param1 >= 0 && Param1 < 5)
                LevelF::PushSectionBoundary(sec, (int)Param1, num_t::from_double(SDL_atof(GetS(MyString).c_str())));
            break;
        }

        case AT_SnapSectionBounds:
        {
            int sec = (int)Target - 1;
            if(sec >= 0 && sec < numSections) // Make sure valid section
            {
                //RECT current_bounds;
                //int sec = ((int)Target) - 1;
                //Level::GetBoundary(&current_bounds, sec);
                //double x_dist = Param1 - current_bounds.left;
                //double y_dist = Param2 - current_bounds.top;
                //double x_stepsize = x_dist / Length;
                //double y_stepsize = y_dist / Length;
                //double x_stepped =  current_bounds.left + x_stepsize;
                //double y_stepped =  current_bounds.top + y_stepsize;
                //Level::SetSectionBounds(sec, x_stepped,  y_stepped, x_stepped + 800, y_stepped + 600);

                //if(Length <= 1) { // When travel time is up, force screen into the right place
                LevelF::SetSectionBounds(sec, Param1, Param2, Param1 + 800, Param2 + 600);
                //}
            }
            break;
        }

        // PLAYER CYCLE
        case AT_CyclePlayerRight:
        {
            PlayerF::CycleRight(demo);
            break;
        }

        case AT_CyclePlayerLeft:
        {
            PlayerF::CycleLeft(demo);
            break;
        }


        // SET HITS
        case AT_SetHits:
        {
            NpcF::AllSetHits((int)Target, (int)Param1 - 1, (int)Param2);
            break;
        }

        // FORCE FACING
        case AT_ForceFacing:
        {
            // Player_t *demo = PlayerF::Get(1); // No need, everything was done above
            // if(demo != 0)
            NpcF::AllFace((int)Target, (int)Param1 - 1, demo->Location.SpeedX);
            break;
        }

        case AT_TriggerSMBXEvent:
        {
            TriggerEvent(FindEvent(GetS(MyString)), (int)Param1);
            break;
        }

        case AT_OnEvent:
        {
            if(EventWasTriggered(FindEvent(GetS(MyString))))
            {
                gAutoMan.ActivateCustomEvents(0, (int)Param3);
                if(Param2 != 0)
                    this->expire();
            }
            break;
        }

        case AT_CancelSMBXEvent:
        {
            if(Length <= 1) // Cancel event after delay
            {
                CancelNewEvent(FindEvent(GetS(MyString)));
                expire();
            }
            break;
        }

        // PREDICATES
        case AT_Hurt:
        {
            short tempint = 1;
            if(Target == 0)
                PlayerHurt(tempint);
            RunSelfOption();
            break;
        }

        case AT_Kill:
        {
            short tempint = 1;
            if(Target == 0)
                PlayerDead(tempint);
            RunSelfOption();
            break;
        }

        // NPC MEMORY SET
        case AT_NPCMemSet:
        {
            if(ftype == FT_INVALID)
            {
                ftype = FT_BYTE;
                ftype = StrToFieldtype(GetS(MyString));
            }

            // Assign the mem
            if(ReferenceOK())   // Use referenced var as value
            {
                num_t gotval = gAutoMan.GetVar(GetS(MyRef));
                NpcF::MemSet((int)Target, (size_t)Param1, gotval, (OPTYPE)(int)Param3, ftype);
            }
            else   // Use given value as value
            {
                NpcF::MemSet((int)Target, (size_t)Param1, Param2, (OPTYPE)(int)Param3, ftype); // NPC ID, offset in obj, value, op, field type
            }

            break;
        }

        // PLAYER MEMORY SET
        case AT_PlayerMemSet:
        {
            if(ftype == FT_INVALID)
            {
                ftype = FT_BYTE;
                ftype = StrToFieldtype(GetS(MyString));
            }

            if(ReferenceOK())
            {
                num_t gotval = gAutoMan.GetVar(GetS(MyRef));
                PlayerF::MemSet((size_t)Param1, gotval, (OPTYPE)(int)Param3, ftype);
            }
            else
                PlayerF::MemSet((size_t)Param1, Param2, (OPTYPE)(int)Param3, ftype);
            break;
        }


        // MEM ASSIGN
        case AT_MemAssign:
        {
            if(Target >= GM_BASE && Param1 <=  GM_END)
            {
                if(ftype == FT_INVALID)
                {
                    ftype = FT_BYTE;
                    ftype = StrToFieldtype(GetS(MyString));
                }

                if(ReferenceOK())
                {
                    num_t gotval = gAutoMan.GetVar(GetS(MyRef));
                    MemAssign((size_t)Target, gotval, (OPTYPE)(int)Param2, ftype);
                }
                else
                    MemAssign((size_t)Target, Param1, (OPTYPE)(int)Param2, ftype);
            }
            break;
        }

        // DEBUG
        case AT_DebugPrint:
        {
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("LunaScript (TheXTech) VERSION-%d", LUNA_VERSION), 3, 50, 250));
            //Renderer::Get().SafePrint(, 3, 340, 250);
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("Globl: %zu", gAutoMan.m_GlobalCodes.size()), 3, 50, 280));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("Init:  %zu", gAutoMan.m_InitAutocodes.size()), 3, 50, 300));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("Codes: %zu", gAutoMan.m_Autocodes.size()), 3, 50, 320));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("Queue: %zu", gAutoMan.m_CustomCodes.size()), 3, 50, 340));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("Sprites: %d", gSpriteMan.CountSprites()), 3, 50, 360));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("BlueePrints: %d", gSpriteMan.CountBlueprints()), 3, 50, 380));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("Components: %zu", gSpriteMan.m_ComponentList.size()), 3, 50, 400));

            // some stats of lunacell were printed here

            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("STRINGS: %zu", StringsBankSize()), 3, 50, 460));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("STRINGS-Unused: %zu", StringsUnusedEntries()), 3, 50, 480));
            Renderer::Get().AddOp(new RenderStringOp(fmt::sprintf_ne("Allocator-Max: %zu, prev %zu", g_rAlloc.maximum(), g_rAlloc.prevMaximum()), 3, 50, 500));
            break;
        }

        case AT_DebugWindow:
        {
            XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_INFORMATION, "LunaScript debug message", GetS(MyString));
            expire();
            break;
        }

        case AT_CollisionScan:
        {
            // this is now a no-op because the block lookup table is always filled
            break;
        }

        // SPRITE FUNCTIONS
        case AT_LoadImage:
        {
            // Only allow loading image during init phase
            if(init)
                Renderer::Get().LoadBitmapResource(GetS(MyString), (int)Target, (uint32_t)(int32_t)Param1);
            expire();
            break;
        }

        case AT_SpriteBlueprint:
        {
            if(ReferenceOK())
            {
                auto *blueprint = new CSprite();
                gSpriteMan.AddBlueprint(GetS(MyRef).c_str(), blueprint);
            }

            expire();
            break;
        }

        case AT_Attach:
        {
            //char* dbg = "!!! ATTACH DEBUG !!!";
            if(ReferenceOK() && !GetS(MyString).empty())
            {
                if(gSpriteMan.m_SpriteBlueprints.find(GetS(MyRef)) != gSpriteMan.m_SpriteBlueprints.end()) // BLueprint exists
                {
                    CSprite *pSpr = gSpriteMan.m_SpriteBlueprints[GetS(MyRef)];                   // Get blueprint
                    Autocode *pComponent = gAutoMan.GetEventByRef(GetS(MyString));                // Get autocode containing component
                    if(pComponent)
                    {
                        switch((BlueprintAttachType)(int)Target)
                        {
                        case BPAT_Behavior:
                            pSpr->AddBehaviorComponent(GenerateComponent(*pComponent));
                            break;
                        case BPAT_Draw:
                            pSpr->AddDrawComponent(GetDrawFunc(*pComponent));
                            break;
                        case BPAT_Birth:
                            pSpr->AddBirthComponent(GenerateComponent(*pComponent));
                            break;
                        case BPAT_Death:
                            pSpr->AddDeathComponent(GenerateComponent(*pComponent));
                            break;
                        default:
                            break;
                        }
                    }
                }
            }

            expire();
            break;
        }

        case AT_PlaceSprite:
        {
            //1: Type   2: ImgResource  3: Xpos         4: Ypos     5:              6: Extra
            CSpriteRequest req;
            req.type = (int)Target;
            req.img_resource_code = (int)Param1;
            req.x = (int)Param2;
            req.y = (int)Param3;
            req.time = pretick_len;
            req.str = GetS(MyString);
            gSpriteMan.InstantiateSprite(&req, false);

            expire();
            break;
        }

        }//switch

    }//section
}

// SELF TICK
void Autocode::SelfTick()
{
    if(Length == 1)
        expire();
    else if(Length == 0)
        return;
    else
        Length -= 1;
}

// DO PREDICATE
void Autocode::DoPredicate(int target, int predicate)
{
    // Activate custom event?
    if(predicate >= 1000 && predicate < 100000)
    {
        gAutoMan.ActivateCustomEvents(target, predicate);
        return;
    }

    // Else, do predicate
    auto pred = (AutocodePredicate)predicate;
    short tempint = 1;

    switch(pred)
    {
    // DEATH PREDICATE
    case AP_Hurt:
        PlayerHurt(tempint);
        break;

    case AP_Death:
        PlayerDead(tempint);
        break;

    default:
        break;
    }
}

// NPC CONDITIONAL
bool Autocode::NPCConditional(int target, int cond)
{
    //const char* dbg = "NPC COND DBG";
    bool ret = false;

    switch((AC_Conditional)cond)
    {
    case AC_Invalid:
    default:
        return ret;

    case AC_Exists:
        return NpcF::GetFirstMatch(target, -1) != nullptr;

    case AC_DoesNotExist:
        return NpcF::GetFirstMatch(target, -1) == nullptr;
    }
}

bool Autocode::CheckConditionI(int value1, int value2, COMPARETYPE cond)
{
    switch(cond)
    {
    case CMPT_EQUALS:
        if(value1 == value2)
            return true;
        break;
    case CMPT_GREATER:
        if(value1 > value2)
            return true;
        break;
    case CMPT_LESS:
        if(value1 < value2)
            return true;
        break;
    case CMPT_NOTEQ:
        if(value1 != value2)
            return true;
        break;
    default:
        break;
    }

    return false;
}

bool Autocode::CheckConditionD(num_t value1, num_t value2, COMPARETYPE cond)
{
    switch(cond)
    {
    case CMPT_EQUALS:
        if(num_t::fEqual_d(value1, value2))
            return true;
        break;
    case CMPT_GREATER:
        if(value1 > value2)
            return true;
        break;
    case CMPT_LESS:
        if(value1 < value2)
            return true;
        break;
    case CMPT_NOTEQ:
        if(!num_t::fEqual_d(value1, value2))
            return true;
        break;
    default:
        break;
    }

    return false;
}

// RUN SELF OPTION
void Autocode::RunSelfOption()
{
    if(GetS(this->MyString).find("once") != std::string::npos)
        this->expire();
}

// REFERENCE OK
bool Autocode::ReferenceOK() const
{
    return (!GetS(this->MyRef).empty());
}



void Autocode::HeartSystem() const
{
    Player_t *sheath = PlayerF::Get(1);

    if(sheath)
    {
        // Don't run for demo or iris
        if(!PlayerF::UsesHearts(sheath))
            return;

        // Detect extra heart pickup and hold displayed hearts at 2
        if(sheath->Hearts > 2)
        {
            gAutoMan.m_Hearts++;
            sheath->Hearts = 2;
            sheath->State = (sheath->State > 2 ? sheath->State : 2);
        }

        if(sheath->Hearts == 2 && gAutoMan.m_Hearts < 2)
            gAutoMan.m_Hearts = 2;

        // Limit tracked max hearts
        if(gAutoMan.m_Hearts > Param2)
            gAutoMan.m_Hearts = (int)Param2;

        // If damaged, take hearts from extra hearts
        if(sheath->Hearts == 1 && gAutoMan.m_Hearts > 2)
        {
            //char* dbg = "HEART SET";
            sheath->Hearts = 2;
            sheath->State = (sheath->State > 2 ? sheath->State : 2);
            gAutoMan.m_Hearts--;
        }
        else if(sheath->Hearts == 1)
        {
            sheath->State = 1;
            gAutoMan.m_Hearts = 1;
        }
        else if(sheath->Hearts == 0)
            gAutoMan.m_Hearts = 0;

        // Display life stuff on screen
        Renderer::Get().AddOp(new RenderStringOp(fmt::format_ne("HP: {}", gAutoMan.m_Hearts),
                                                 3, s_round2int(Target), s_round2int(Param1)));
    }//if heartuser
}


void Autocode::LunaControl(LunaControlAct act, int val)
{
    switch(act)
    {
    case LCA_DemoCounter:
        {
            ConfigChangeSentinel sent(ConfigSetLevel::script);
            g_config.show_fails_counter = (val == 1);
        }

        if(g_config.show_fails_counter && !g_config.enable_fails_tracking && !gEnableDemoCounterByLC) // Initialize the demos counter if wasn't enabled before
        {
            if(!GameMenu && !GameOutro && !BattleMode && !LevelEditor && !TestLevel)
            {
                gEnableDemoCounterByLC = true;
                gDeathCounter.init();
                gDeathCounter.Recount();
            }
        }
        break;

    case LCA_SMBXHUD:
        gSMBXHUDSettings.skip = (val == 1);
        break;

    case LCA_Invalid:
    default:
        return;
    }
}

void Autocode::expire()
{
    Expired = true;
    gAutoMan.m_hasExpired = true;
}

void Autocode::modParam(num_t &dst, num_t src, OPTYPE operation)
{
    switch(operation)
    {
    default: // Do nothing
        break;
    case OP_Assign:
        dst = src;
        break;
    case OP_Add:
        dst += src;
        break;
    case OP_Sub:
        dst -= src;
        break;
    case OP_Mult:
        dst = dst.times(src);
        break;
    case OP_Div:
        dst = dst.divided_by(src);
        break;
    case OP_XOR:
        dst = (int)dst ^ (int)src;
        break;
    }
}

static const std::unordered_map<std::string, AutocodeType> s_commandMap =
{
    {"FilterToSmall", AT_FilterToSmall},
    {"FilterToBig", AT_FilterToBig},
    {"FilterToFire", AT_FilterToFire},
    {"FilterMount", AT_FilterMount},
    {"FilterReservePowerup", AT_FilterReservePowerup},
    {"FilterPlayer", AT_FilterPlayer},

    {"SetHearts", AT_SetHearts},
    {"HeartSystem", AT_HeartSystem},
    {"InfiniteFlying", AT_InfiniteFlying},

    {"ScreenEdgeBuffer", AT_ScreenEdgeBuffer},

    {"ShowText", AT_ShowText},
    {"ShowNPCLifeLeft", AT_ShowNPCLifeLeft},
    {"ShowLevelName", AT_ShowLevelName},
    {"ShowLevelFile", AT_ShowLevelFile},

    {"Trigger", AT_Trigger},
    {"Timer", AT_Timer},
    {"IfNPC", AT_IfNPC},
    {"BlockTrigger", AT_BlockTrigger},
    {"IfCompatMode", AT_IfCompatMode},
    {"IfSpeedRunMode", AT_IfSpeedRunMode},
    {"TriggerRandom", AT_TriggerRandom},
    {"TriggerRandomRange", AT_TriggerRandomRange},
    {"TriggerZone", AT_TriggerZone},
    {"ScreenBorderTrigger", AT_ScreenBorderTrigger},
    {"OnInput", AT_OnInput},
    {"OnCustomCheat", AT_OnCustomCheat},
    {"OnPlayerMem", AT_OnPlayerMem},
    {"OnGlobalMem", AT_OnGlobalMem},
    {"RunCheat", AT_RunCheat},

    {"SetVar", AT_SetVar},
    {"CopyVar", AT_CopyVar},
    {"LoadPlayerVar", AT_LoadPlayerVar},
    {"LoadNPCVar", AT_LoadNPCVar},
    {"LoadGlobalVar", AT_LoadGlobalVar},
    {"ShowVar", AT_ShowVar},
    {"IfVar", AT_IfVar},
    {"CompareVar", AT_CompareVar},
    {"BankVar", AT_BankVar},
    {"WriteBank", AT_WriteBank},

    {"LunaControl", AT_LunaControl},

    {"DeleteCommand", AT_DeleteCommand},
    {"ModParam", AT_ModParam},
    {"ChangeTime", AT_ChangeTime},

    {"DeleteEventsFrom", AT_DeleteEventsFrom},
    {"ClearInputString", AT_ClearInputString},

    {"LayerXSpeed", AT_LayerXSpeed},
    {"LayerYSpeed", AT_LayerYSpeed},
    {"AccelerateLayerX", AT_AccelerateLayerX},
    {"AccelerateLayerY", AT_AccelerateLayerY},
    {"DeccelerateLayerX", AT_DeccelerateLayerX},
    {"DeccelerateLayerY", AT_DeccelerateLayerY},
    {"SetAllBlocksID", AT_SetAllBlocksID},
    {"SwapAllBlocks", AT_SwapAllBlocks},
    {"ShowAllBlocks", AT_ShowAllBlocks},
    {"HideAllBlocks", AT_HideAllBlocks},

    {"PushScreenBoundary", AT_PushScreenBoundary},
    {"SnapSectionBounds", AT_SnapSectionBounds},

    {"CyclePlayerRight", AT_CyclePlayerRight},
    {"CyclePlayerLeft", AT_CyclePlayerLeft},

    {"SFX", AT_SFX},
    {"PlaySFX", AT_PlaySFX},
    {"StopSFX", AT_StopSFX},
    {"SFXPreLoad", AT_SFXPreLoad},
    {"SetMusic", AT_SetMusic},
    {"PlayMusic", AT_PlayMusic},

    {"TriggerSMBXEvent", AT_TriggerSMBXEvent},
    {"OnEvent", AT_OnEvent},
    {"CancelSMBXEvent", AT_CancelSMBXEvent},

    {"Kill", AT_Kill},
    {"Hurt", AT_Hurt},

    {"SetHits", AT_SetHits},
    {"NPCMemSet", AT_NPCMemSet},
    {"PlayerMemSet", AT_PlayerMemSet},
    {"ForceFacing", AT_ForceFacing},
    {"MemAssign", AT_MemAssign},
    {"DebugPrint", AT_DebugPrint},
    {"DebugWindow", AT_DebugWindow},

    {"CollisionScan", AT_CollisionScan},

    {"LoadImage", AT_LoadImage},
    {"SpriteBlueprint", AT_SpriteBlueprint},
    {"Attach", AT_Attach},
    {"PlaceSprite", AT_PlaceSprite},

    {"OnPlayerCollide", AT_OnPlayerCollide},
    {"OnPlayerDistance", AT_OnPlayerDistance},
    {"WaitForPlayer", AT_WaitForPlayer},
    {"PlayerHoldingSprite", AT_PlayerHoldingSprite},
    {"RandomComponent", AT_RandomComponent},
    {"RandomComponentRange", AT_RandomComponentRange},
    {"SetSpriteVar", AT_SetSpriteVar},
    {"IfSpriteVar", AT_IfSpriteVar},
    {"IfLunaVar", AT_IfLunaVar},
    {"Die", AT_Die},
    {"Deccelerate", AT_Deccelerate},
    {"AccelToPlayer", AT_AccelToPlayer},
    {"ApplyVariableGravity", AT_ApplyVariableGravity},
    {"PhaseMove", AT_PhaseMove},
    {"BumpMove", AT_BumpMove},
    {"CrashMove", AT_CrashMove},
    {"SetXSpeed", AT_SetXSpeed},
    {"SetYSpeed", AT_SetYSpeed},
    {"SetAlwaysProcess", AT_SetAlwaysProcess},
    {"SetVisible", AT_SetVisible},
    {"SetHitbox", AT_SetHitbox},
    {"TeleportNearPlayer", AT_TeleportNearPlayer},
    {"TeleportTo", AT_TeleportTo},
    {"HarmPlayer", AT_HarmPlayer},
    {"GenerateInRadius", AT_GenerateInRadius},
    {"GenerateAtAngle", AT_GenerateAtAngle},
    {"BasicAnimate", AT_BasicAnimate},
    {"Blink", AT_Blink},
    {"AnimateFloat", AT_AnimateFloat},
    {"TriggerLunaEvent", AT_TriggerLunaEvent},
    {"HarmPlayer", AT_HarmPlayer},
    {"SpriteTimer", AT_SpriteTimer},
    {"SpriteDebug", AT_SpriteDebug},
    {"StaticDraw", AT_StaticDraw},
    {"RelativeDraw", AT_RelativeDraw}
};

AutocodeType Autocode::EnumerizeCommand(char *wbuf, int lineNumber)
{
    if(wbuf)
    {
        char command[100];
        SDL_memset(command, 0, 100 * sizeof(char));

        int success = XTECH_sscanf(wbuf, " %99[^,] ,", command);
        if(!success)
        {
            // Bad or mistyped command?
            std::string line = std::string(wbuf);
            gAutoMan.addError(lineNumber, line, "Syntax error");
            gAutoMan.m_hasExpired = true;
            return AT_Invalid;
        }

        auto cmd = s_commandMap.find(std::string(command));
        if(cmd != s_commandMap.end())
            return cmd->second;
    }

    if(wbuf)
    {
        // Nothing matched. Bad or mistyped command?
        std::string line = std::string(wbuf);
        gAutoMan.addError(lineNumber, line, "Unknown command");
    }

    gAutoMan.m_hasExpired = true;
    return AT_Invalid;
}

SpriteComponent Autocode::GenerateComponent(const Autocode &obj_to_convert)
{
    SpriteComponent comp;
    comp.Init((int)obj_to_convert.Length);
    comp.data1 = obj_to_convert.Target;
    comp.data2 = obj_to_convert.Param1;
    comp.data3 = obj_to_convert.Param2;
    comp.data4 = obj_to_convert.Param3;
    comp.data5 = GetS(obj_to_convert.MyString);
    comp.lookup_code = obj_to_convert.ActiveSection;

    comp.func = Autocode::GetSpriteFunc(obj_to_convert);
    return comp;
}

pfnSprFunc Autocode::GetSpriteFunc(const Autocode &pAC)
{
    switch(pAC.m_Type)
    {
    case AT_OnPlayerCollide:
        return SpriteFunc::OnPlayerCollide;
    case AT_OnPlayerDistance:
        return SpriteFunc::OnPlayerDistance;
    case AT_WaitForPlayer:
        return SpriteFunc::WaitForPlayer;
    case AT_PlayerHoldingSprite:
        return SpriteFunc::PlayerHoldingSprite;
    case AT_RandomComponent:
        return SpriteFunc::RandomComponent;
    case AT_RandomComponentRange:
        return SpriteFunc::RandomComponentRange;
    case AT_SetSpriteVar:
        return SpriteFunc::SetSpriteVar;
    case AT_IfSpriteVar:
        return SpriteFunc::IfSpriteVar;
    case AT_IfLunaVar:
        return SpriteFunc::IfLunaVar;
    case AT_Die:
        return SpriteFunc::Die;
    case AT_Deccelerate:
        return SpriteFunc::Deccelerate;
    case AT_AccelToPlayer:
        return SpriteFunc::AccelToPlayer;
    case AT_ApplyVariableGravity:
        return SpriteFunc::ApplyVariableGravity;
    case AT_PhaseMove:
        return SpriteFunc::PhaseMove;
    case AT_BumpMove:
        return SpriteFunc::BumpMove;
    case AT_CrashMove:
        return SpriteFunc::CrashMove;
    case AT_SetXSpeed:
        return SpriteFunc::SetXSpeed;
    case AT_SetYSpeed:
        return SpriteFunc::SetYSpeed;
    case AT_SetAlwaysProcess:
        return SpriteFunc::SetAlwaysProcess;
    case AT_SetVisible:
        return SpriteFunc::SetVisible;
    case AT_SetHitbox:
        return SpriteFunc::SetHitbox;
    case AT_TeleportNearPlayer:
        return SpriteFunc::TeleportNearPlayer;
    case AT_TeleportTo:
        return SpriteFunc::TeleportTo;
    case AT_GenerateInRadius:
        return SpriteFunc::GenerateInRadius;
    case AT_GenerateAtAngle:
        return SpriteFunc::GenerateAtAngle;
    case AT_BasicAnimate:
        return SpriteFunc::BasicAnimate;
    case AT_Blink:
        return SpriteFunc::Blink;
    case AT_AnimateFloat:
        return SpriteFunc::AnimateFloat;
    case AT_TriggerLunaEvent:
        return SpriteFunc::TriggerLunaEvent;
    case AT_HarmPlayer:
        return SpriteFunc::HarmPlayer;
    case AT_SpriteTimer:
        return SpriteFunc::SpriteTimer;
    case AT_SpriteDebug:
        return SpriteFunc::SpriteDebug;
    default:
        return nullptr;
    }
}

pfnSprDraw Autocode::GetDrawFunc(const Autocode &pAC)
{
    switch(pAC.m_Type)
    {
    case AT_StaticDraw:
        return SpriteFunc::StaticDraw;
    case AT_RelativeDraw:
        return SpriteFunc::RelativeDraw;
    default:
        return nullptr;
    }
}


================================================
FILE: src/script/luna/autocode.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef AutoCode_hhh
#define AutoCode_hhh

#include <string>

#include "numeric_types.h"
#include "lunadefs.h"
#include "global_strings.h"

enum LunaControlAct
{
    LCA_Invalid = 0,
    LCA_DemoCounter = 1,
    LCA_SMBXHUD = 2,
};

enum BlueprintAttachType
{
    BPAT_Behavior = 0,
    BPAT_Draw = 1,
    BPAT_Birth = 2,
    BPAT_Death = 3,
};

enum AutocodeType
{
    AT_Invalid = 0,
    AT_FilterToSmall,           //1:        2:              3:              4:          5: Active time  6:
    AT_FilterToBig,             //1:        2:              3:              4:          5: Active time  6:
    AT_FilterToFire,            //1:        2:              3:              4:          5: Active time  6:
    AT_FilterMount,             //1:        2:              3:              4:          5: Active time  6:
    AT_FilterReservePowerup,    //1:        2:              3:              4:          5: Active time  6:
    AT_FilterPlayer,            //1:        2: Filter ID    3: Filter to    4:          5: Active time  6:

    AT_InfiniteFlying,          //1:        2:              3:              4:          5: Active time  6:
    AT_HeartSystem,             //1: X pos  2: Y pos        3: Max hearts   4:          5: Active time  6:

    AT_ScreenEdgeBuffer,        //1: NPC ID 2: UDLR Bordr   3: Buffer space 4:          5: Active time  6:

    AT_ShowText,                //1:        2: Xpos         3: Ypos         4: Font #   5: Active time  6: Text
    AT_ShowNPCLifeLeft,         //1: NpcID  2: Xpos         3: Ypos         4: Section  5: Active time  6: Base health
    AT_ShowLevelName,           //1:        2: Xpos         3: Ypos         4: Font #   5: Active time  6:
    AT_ShowLevelFile,           //1:        2: Xpos         3: Ypos         4: Font #   5: Active time  6:

    AT_Trigger,                 //1: Newsec 2: Event        3:              4:          5: Active time  6:
    AT_Timer,                   //1: Target 2: Effect       3: Display Y/N  4: Repeat?  5: Active time  6:
    AT_IfNPC,                   //1: NpcID  2: Condition    3: Argument     4: Event    5: Active time  6: Option
    AT_BlockTrigger,            //1: NpcID  2: Block Type   3: Argument     4: Event    5: Active time  6: Option
    AT_IfCompatMode,            //1:        2: Condition    3: Mode         4: Event    5: Active time  6:
    AT_IfSpeedRunMode,          //1:        2: Condition    3: Mode         4: Event    5: Active time  6:
    AT_TriggerRandom,           //1: Event  2: Event        3: Event        4: Event    5: Active time  6:
    AT_TriggerRandomRange,      //1: StartEv2: EndEv        3:              4:          5: Active time  6:
    AT_TriggerZone,             //1: Event  2: Top          3: Bottom       4: Left     5: Right        6: Option
    AT_ScreenBorderTrigger,     //1: EventL 2: EventU       3: EventR       4: EventD   5: ActiveTime   6: Inward depth

    AT_OnInput,                 //1:        2: Button       3: First frame? 4: Event    5: Active time  6:
    AT_OnCustomCheat,           //1:        2:              3: Only once?   4: Event    5: Active time  6: Cheat string
    AT_OnPlayerMem,             //1: Offset 2: Value        3: Comparison   4: Event    5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_OnGlobalMem,             //1: Addr   2: Value        3: Comparison   4: Event    5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_RunCheat,                //1:        2:              3:              4:          5: Delay        6: Cheat string

    AT_SetVar,                  //1:        2: Op           3: Value        4:          5: Active time  6:
    AT_CopyVar,                 //1:        2: Op           3:              4:          5: Active time  6: Source variable name; $ Target Variable Name
    AT_LoadPlayerVar,           //1:        2: Offset       3: Op           4:          5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_LoadNPCVar,              //1: Type   2: Offset       3: Op           4: Section  5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_LoadGlobalVar,           //1: Addr   2: Op           3:              4:          5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_IfVar,                   //1:        2: CompareType  3: Value        4: Event    5: Active time  6:
    AT_CompareVar,              //$Var 1    1:  2:CompareType 3:            4: Event    5: ActiveTime   6: Var 2
    AT_ShowVar,                 //1:        2: Xpos         3: Ypos         4: Font #   5: Active time  6: Base text
    AT_BankVar,                 //1:        2:              3:              4:          5: Active time  6: Name of luna var
    AT_WriteBank,               //1:        2:              3:              4:          5:              6:

    AT_LunaControl,             //1: Action 2: Value        3:              4:          5: Active time  6:

    AT_DeleteCommand,           //1:        2:              3:              4:          5: Active time  6: Refernece to cmd
    AT_ModParam,                //1: To mod#2: Value        3: Operation    4:          5: Active time  6: Refernece to cmd
    AT_ChangeTime,              //1:        2: Value        3: Operation    4:          5: Active time  6: Refernece to cmd

    AT_DeleteEventsFrom,        //1: Section2:              3:              4:          5: Active time  6:
    AT_ClearInputString,        //1:        2:              3:              4:          5: Active time  6:

    AT_LayerXSpeed,             //1: Layer #2: Stop after?  3:              4:          5: Active time  6: Speed
    AT_LayerYSpeed,             //1: Layer #2: Stop after?  3:              4:          5: Active time  6: Speed
    AT_AccelerateLayerX,        //1: Layer #2: Max speed    3:              4:          5: Active time  6: Speed
    AT_AccelerateLayerY,        //1: Layer #2: Max speed    3:              4:          5: Active time  6: Speed
    AT_DeccelerateLayerX,       //1: Layer #2: Deccel to    3:              4:          5: Active time  6: Speed
    AT_DeccelerateLayerY,       //1: Layer #2: Deccel to    3:              4:          5: Active time  6: Speed

    AT_SetAllBlocksID,          //1: Type   2: Set to       3:              4:          5: Active time  6:
    AT_SwapAllBlocks,           //1: Type 1 2: Type 2       3:              4:          5: Active time  6:
    AT_ShowAllBlocks,           //1: Type 1 2:              3:              4:          5: Active time  6:
    AT_HideAllBlocks,           //1: Type 1 2:              3:              4:          5: Active time  6:

    AT_PushScreenBoundary,      //1: Section2: UDLR         3:              4:          5: Active time  6: Speed
    AT_SnapSectionBounds,       //1: Section2: Target X     3: Target Y     4:          5: Active time  6:

    AT_CyclePlayerRight,        //1:        2:              3:              4:          5: Active time  6:
    AT_CyclePlayerLeft,         //1:        2:              3:              4:          5: Active time  6:

    AT_SetHearts,               //1:        2: Hearts       3:              4:          5: Active time  6:
    AT_SetHits,                 //1: NpcID  2: Section      3: Hits         4:          5: Active time  6:
    AT_ForceFacing,             //1: NpcID  2: Section      3:              4:          5: Active time  6:

    AT_SFX,                     //1:        2: Index        3:              4:          5: Delay        6:
    AT_PlaySFX,                 //1:        2: Index        3: Loops        4: Volume   5: Delay        6:
    AT_StopSFX,                 //1:        2: Index        3:              4:          5: Delay        6:
    AT_SFXPreLoad,              //1:        2: Index        3:              4:          5: Delay        6:
    AT_SetMusic,                //1: Section2: Music #      3:              4:          5: Active time  6: Optional file name
    AT_PlayMusic,               //1:        2: Section      3:              4:          5: Delay        6:

    AT_TriggerSMBXEvent,        //1:        2: Arg          3:              4:          5: Active time  6: Name of event
    AT_OnEvent,                 //1:        2:              3: Only once?   4: Event    5: Active time  6: Name of event
    AT_CancelSMBXEvent,         //1:        2: Arg          3:              4:          5: Active time  6: Name of event

    AT_Hurt,                    //1: Target 2:              3:              4:          5: Active time  6: Option
    AT_Kill,                    //1: Target 2:              3:              4:          5: Active time  6: Option

    AT_NPCMemSet,               //1: Type   2: Offset       3: Value        4: Op       5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_PlayerMemSet,            //1:        2: Offset       3: Value        4: Op       5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_MemAssign,               //1: Addr   2: Value        3: Operation    4:          5: Active time  6: Type (b, w, dw, f, qw/df)

    AT_DebugPrint,              //1:        2:              3:              4:          5: Active time  6:
    AT_DebugWindow,             //1:        2:              3:              4:          5:              6: Text

    AT_CollisionScan,           //1:        2:              3:              4:          5: Active time  6:

    /// Sprite stuff ///
    AT_LoadImage,               //1: Code   2: TransColor   3:              4:          5:              6: File name
    AT_SpriteBlueprint,         //0: $RefName, others empty
    AT_Attach,                  //0: $Target blueprint,     1: Attach type  2: 3: 4: 5: 6: Source component name
    AT_PlaceSprite,             //1: Type   2: ImgResource  3: Xpos         4: Ypos     5: Sprite time  6:

    // Sprite components //
    AT_OnPlayerCollide = 10000, //1:        2: Player small circle hitbox? 3: 4: Comp   5: Active time  6:
    AT_OnPlayerDistance,        //1: Dist   2: far/close    3:              4: Comp     5: Active time  6:
    AT_WaitForPlayer,           //1: Offset 2: Value        3: Comparison   4: Comp     5: Active time  6: Type (b, w, dw, f, qw/df)
    AT_PlayerHoldingSprite,     //1: Type   2:              3:              4: Comp     5: Active time  6:

    AT_RandomComponent,         //1: choice 2: choice       3: choice       4: choice   5: Active time  6:
    AT_RandomComponentRange,    //1: start  2: end          3:              4:          5: Active time  6:

    AT_SetSpriteVar,            //1:        2: Op           3: Value        4:          5: Active time  6:
    AT_IfSpriteVar,             //1:        2: CompareType  3: Value        4: Event    5: Active time  6:
    AT_IfLunaVar,               //1:        2: CompareType  3: Value        4: Event    5: Active time  6:

    AT_Die,                     //1:        2:              3:              4:          5: Active time  6:

    AT_Deccelerate,             //1: X rate 2: Y rate       3: Minimum      4:          5: Active time  6:
    //AT_Accelerate             //1: X rate 2: Y rate       3: Maximum      4:          5: Active time  6: Option
    AT_AccelToPlayer,           //1: X rate 2: Y rate       3: Maximum      4:          5: Active time  6:
    AT_ApplyVariableGravity,    //1:        2: 0=x 1=y      3:              4:          5: Active time  6: Name of lunadll variable

    AT_TeleportNearPlayer,      //1: Radius 2:              3:              4:          5: Active time  6:
    AT_TeleportTo,              //1: x      2: y            3:              4:          5: Active time  6:

    AT_PhaseMove,               //1:        2:              3:              4:          5: Active time  6:
    AT_BumpMove,                //1:        2: NRGLoss%     3:              4:          5: Active time  6:
    AT_CrashMove,               //1:        2:              3:              4:          5: Active time  6:

    AT_SetXSpeed,               //1: Speed  2:              3:              4:          5: Active time  6:
    AT_SetYSpeed,               //1: Speed  2:              3:              4:          5: Active time  6:
    AT_SetAlwaysProcess,        //1: Off/On
    AT_SetVisible,              //1: Off/On
    AT_SetHitbox,               //1: LeftOff2: Top offset   3: Width        4: Height   5: Active time  6: option

    AT_BasicAnimate,            //1: Height 2: Speed
    AT_Blink,                   //1: Speed  2: Reverse      3:              4:          5: Active time  6:
    AT_AnimateFloat,            //1: Speed  2: X magnitude  3: Y magnitude

    AT_TriggerLunaEvent,        //1: Event  2:              3:              4:          5: Active time  6:
    AT_HarmPlayer,              //1:        2:              3:              4:          5: Active time  6:

    AT_GenerateInRadius,        //1:        2: ImgResource  3: Radius       4: SprTime  5: Active time  6: Sprite blueprint name
    AT_GenerateAtAngle,         //1:        2: ImgResource  3: Speed        4: SprTime  5: Active time  6: Sprite blueprint name

    AT_SpriteTimer,             //1:        2:              3: Repeat       4: Comp     5: Active time  6:

    AT_SpriteDebug,             //1:        2:              3: Repeat       4: Comp     5: Active time  6:

    AT_StaticDraw,
    AT_RelativeDraw
};

enum AutocodePredicate
{
    AP_Invalid = 0,
    AP_Death,
    AP_Hurt
};

enum AC_Conditional
{
    AC_Invalid = 0,
    AC_Exists,
    AC_DoesNotExist
};

struct SpriteComponent; // forward dec

// An autocode event
class Autocode
{

public:
    // Ctors
    Autocode();
    Autocode(AutocodeType, num_t Target, num_t p1, num_t p2, num_t p3,
             const stringindex_t &p4, num_t Length, int Section, const stringindex_t &VarRef);
    Autocode(const Autocode &o);
    ~Autocode() = default;

    Autocode &operator=(const Autocode &o);

    void Do(bool init);
    static void DoPredicate(int target, int predicate);

    static bool NPCConditional(int NPCID, int condition);
    static bool CheckConditionI(int value1, int value2, COMPARETYPE cond);
    static bool CheckConditionD(num_t value1, num_t value2, COMPARETYPE cond);

    static AutocodeType EnumerizeCommand(char *wbuf, int lineNumber = -1);
    static SpriteComponent GenerateComponent(const Autocode &obj_to_convert); // Convert an autocode object to a sprite component
    static pfnSprFunc GetSpriteFunc(const Autocode &pAC);                     // Get sprite function address from AC object, or NULL
    static pfnSprDraw GetDrawFunc(const Autocode &pAC);                       // Get draw function address from AC object, or NULL

    /// Command functions ///
    void HeartSystem() const;
    static void LunaControl(LunaControlAct act, int val);

    /// Members ///
    AutocodeType m_Type = AT_Invalid;

    num_t Target = 0;                          // arg 1 "Target"
    num_t Param1 = 0;                          // arg 2 "Param 1"
    num_t Param2 = 0;                          // arg 3 "Param 2"
    num_t Param3 = 0;                          // arg 4 "Param 3"
    num_t Length = 0;                          // arg 5 "Length"
    stringindex_t MyString = STRINGINDEX_NONE; // arg 6 "string"
    stringindex_t MyRef = STRINGINDEX_NONE;    // Optional arg 0 value

    num_t m_OriginalTime = 0;
    int ActiveSection = 0;          // Section to be active in, or custom event ID if > 1000
    FIELDTYPE ftype = FT_INVALID;
    bool Activated = false;             // False for custom event blueprints
    bool Expired = false;

    void expire();

    //SpriteComponent* comp;

private:
    static void modParam(num_t &dst, num_t src, OPTYPE operation);
    void SelfTick();
    void RunSelfOption(); // activate the string portion of this code on self
    bool ReferenceOK() const; // check if this object has a valid reference (not empty)
};

#endif // AutoCode_hhh


================================================
FILE: src/script/luna/autocode_manager.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Utils/files.h>
#include <Utils/dir_list_ci.h>
#include <AppPath/app_path.h>
#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "sdl_proxy/sdl_stdinc.h"
#include "core/msgbox.h"
#include "main/translate_episode.h"

#include "autocode_manager.h"
#include "globals.h"
#include "global_dirs.h"
#include "lunamisc.h"
#include "lunaspriteman.h"

#define PARSEDEBUG true

AutocodeManager gAutoMan;

// CTOR
AutocodeManager::AutocodeManager() noexcept
{
    Clear();
}

AutocodeManager::~AutocodeManager()
{
    Clear();
}

// CLEAR - Delete all autocodes and clear lists (and reset hearts to 2)
void AutocodeManager::Clear()
{
    // Clear global codes
    m_GlobalCodes.clear();
    m_GlobalEnabled = false;

    m_globcodeIdxRef.clear();
    m_globcodeIdxSection.clear();


    // Clear level local and index tables
    m_Autocodes.clear();
    m_InitAutocodes.clear();
    m_CustomCodes.clear();

    m_autocodeIdxRef.clear();
    m_autocodeIdxSection.clear();

    m_Hearts = 2;

    m_Enabled = false;
}

bool AutocodeManager::LoadFiles()
{
    bool ret = false;
    std::string lunaLevel, lunaWorld,
                keyLevel, keyWorld;

    g_dirEpisode.setCurDir(FileNamePath);
    g_dirCustom.setCurDir(FileNamePath + FileName);

    Clear();

    // Load autocode
    lunaLevel = g_dirCustom.resolveFileCaseExistsAbs(AUTOCODE_FNAME);
    keyLevel = FileName + "/" + g_dirCustom.resolveFileCase(AUTOCODE_FNAME);
    if(!lunaLevel.empty())
        ret |= ReadFile(lunaLevel, keyLevel);

    // Try to load world codes
    lunaWorld = g_dirEpisode.resolveFileCaseExistsAbs(WORLDCODE_FNAME);
    keyWorld = g_dirEpisode.resolveFileCase(WORLDCODE_FNAME);
    if(!lunaWorld.empty())
        ret |= ReadWorld(lunaWorld, keyWorld);

    // Attempt to load global codes at the assets directory
    ret |= ReadGlobals(AppPathManager::assetsRoot() + GLOBALCODE_FNAME);

    // Do some stuff
    DoEvents(true); // do with init

    return ret;
}

// READ FILE - Read the autocode file in the level folder
bool AutocodeManager::ReadFile(const std::string &script_path, const std::string& tr_key)
{
    SDL_RWops *code_file = Files::open_file(script_path, "rb");
    if(!code_file)
        return false;

    pLogDebug("Loading %s level local autocode script...", script_path.c_str());

    m_Enabled = true;
    Parse(code_file, false, tr_key);
    SDL_RWclose(code_file);
    showErrors(script_path);

    return true;
}

// READ WORLD - Read the world autocode file in the world folder
bool AutocodeManager::ReadWorld(const std::string &script_path, const std::string& tr_key)
{
    SDL_RWops *code_file = Files::open_file(script_path, "rb");
    if(!code_file)
        return false;

    pLogDebug("Loading %s episode wide autocode script...", script_path.c_str());

    m_Enabled = true;
    Parse(code_file, false, tr_key);
    SDL_RWclose(code_file);
    showErrors(script_path);

    return true;
}

// READ GLOBALS - Read the global code file
bool AutocodeManager::ReadGlobals(const std::string &script_path)
{
    SDL_RWops *code_file = Files::open_file(script_path, "rb");
    if(!code_file)
        return false;

    pLogDebug("Loading %s global autocode script...", script_path.c_str());

    m_Enabled = true;
    Parse(code_file, true);
    SDL_RWclose(code_file);
    m_GlobalEnabled = true;
    showErrors(script_path);

    return true;
}

template<int temp_buf_size>
struct read_buf
{
    char temp_buf[temp_buf_size];
    int temp_buf_cur = 0;
    int temp_buf_end = 0;
    bool eof = false;

    bool fgets(char* out_buf, int out_buf_size, SDL_RWops *code_file)
    {
        char* out_buf_end = out_buf + out_buf_size;
        if(out_buf >= out_buf_end)
            return false;

        while(true)
        {
            while(temp_buf_cur < temp_buf_end)
            {
                char c = temp_buf[temp_buf_cur++];

                if(c == '\r')
                    continue;

                *(out_buf++) = c;
                if(out_buf >= out_buf_end)
                {
                    out_buf[-1] = '\0';
                    return true;
                }

                if(c == '\n')
                {
                    *(out_buf++) = '\0';
                    return true;
                }
            }

            temp_buf_cur = 0;
            temp_buf_end = SDL_RWread(code_file, temp_buf, 1, sizeof(temp_buf));

            if(temp_buf_end == 0)
                eof = true;

            if(eof)
            {
                *(out_buf++) = '\0';
                return false;
            }
        }
    }
};

// PARSE    - Parse the autocode file and populate manager with the contained code/settings
//            Doesn't delete codes already in the lists
void AutocodeManager::Parse(SDL_RWops *code_file, bool add_to_globals, const std::string& tr_key)
{
    read_buf<2048> readbuf;

    char wbuf[2000];
    char wmidbuf[2000];
    size_t wbuflen = 0;
    char combuf[150];
    int cur_section = 0;
    AutocodeType ac_type = AT_Invalid;

    char wstrbuf[1000];
    char wrefbuf[128];
    int lineNum = 0;

    SDL_memset(wbuf, 0, 2000);
    SDL_memset(combuf, 0, 150);
    SDL_memset(wstrbuf, 0, 1000);
    SDL_memset(wrefbuf, 0, 128);

    m_errors.clear();

    TranslateEpisode tr;
    tr.loadLunaScript(tr_key);

    SDL_RWseek(code_file, 0, RW_SEEK_SET);

    // Check and skip a BOM marker
    const char *charset;
    if(Files::skipBom(code_file, &charset) != Files::CHARSET_UTF8)
    {
        addError(lineNum, charset, "File uses an unsupported charset. Please save it as UTF-8.");
        return;
    }

    //char* dbg = "ParseDbgEOF";
    while(!readbuf.eof)
    {
        // Get a line and reset buffers
        SDL_memset(wbuf, 0, sizeof(wbuf));
        SDL_memset(wmidbuf, 0, sizeof(wmidbuf));
        SDL_memset(wstrbuf, 0, sizeof(wstrbuf));
        SDL_memset(wrefbuf, 0, sizeof(wrefbuf));
        SDL_memset(combuf, 0, sizeof(combuf));

        num_t target = 0;
        num_t param1 = 0;
        num_t param2 = 0;
        num_t param3 = 0;
        num_t length = 0;
        double dtarget = 0;
        double dparam1 = 0;
        double dparam2 = 0;
        double dparam3 = 0;
        double dlength = 0;
        int btarget = 0;
        int bparam1 = 0;
        int bparam2 = 0;
        int bparam3 = 0;
        int blength = 0;

        if(!readbuf.fgets(wbuf, 2000, code_file))
            break; // End of file has reached
        lineNum++;

        // Is it a comment?
        char *commentLine = SDL_strstr(wbuf, "//");
        if(commentLine != nullptr)
            commentLine[0] = '\0'; // Cut the comment line at here

        // does this line contains anything useful?
        wbuflen = SDL_strlen(wbuf);
        while(wbuflen > 0)
        {
            auto c = wbuf[wbuflen - 1];
            if(c != '\n' && c != '\r' && c != '\t' && c != ' ')
                break;
            wbuf[wbuflen - 1] = '\0';
            wbuflen--;
        }

        // Is it an empty line?
        if(wbuflen <= 0)
            continue;

        // Is it a new section header?
        if(wbuf[0] == '#')
        {
            // Is it the level load header?
            if(wbuf[1] == '-')
                cur_section = -1;
            else if(SDL_strncasecmp(wbuf + 1, "end", sizeof(wbuf) - 1) == 0)
                continue; // "END" keyword, just do nothing
            else // Else, parse the section number
            {
                try
                {
                    cur_section = std::stoi(wbuf + 1);
                }
                catch (const std::exception &e)
                {
                    addError(lineNum, wbuf, fmt::format_ne("Bad section format ({0})", e.what()));
                    // Keep section number unchanged
                }
            }
        }
        else   // Else, parse as a command
        {
            // Is there a variable reference marker?
            if(wbuf[0] == '$')
            {
                int i = 1;
                while(wbuf[i] != ',' && wbuf[i] != '\x0D' && wbuf[i] != '\x0A' && i < 126)
                    ++i;

                wbuf[i] = '\x00'; // Turn the comma into a null terminator
                SDL_strlcpy(wrefbuf, &wbuf[1], sizeof(wrefbuf)); // Copy new string into wrefbuf
                SDL_memcpy(wmidbuf, wbuf, sizeof(wmidbuf));
                SDL_strlcpy(wbuf, &wmidbuf[i + 1], sizeof(wbuf)); // The rest of the line minus the ref is the new wbuf
            }

            ac_type = Autocode::EnumerizeCommand(wbuf, lineNum);

            // Decimal pass
            int hits = XTECH_sscanf(wbuf, PARSE_FMT_STR, combuf, &dtarget, &dparam1, &dparam2, &dparam3, &dlength, wstrbuf);

            // Integer pass
            int bhits = XTECH_sscanf(wbuf, PARSE_FMT_STR_2, combuf, &btarget, &bparam1, &bparam2, &bparam3, &blength, wstrbuf);

            // Check for formatting failure
            if(hits < 3 && bhits < 3)
            {
                addError(lineNum, wbuf, "Bad line format");
                continue;
            }

            // Check for hexadecimal inputs
            //if(true) // Always true
            {
                target = num_t::from_double(dtarget);
                param1 = num_t::from_double(dparam1);
                param2 = num_t::from_double(dparam2);
                param3 = num_t::from_double(dparam3);
                length = num_t::from_double(dlength);

                if(target == 0 && btarget != 0)
                    target = btarget;
                if(param1 == 0 && bparam1 != 0)
                    param1 = bparam1;
                if(param2 == 0 && bparam2 != 0)
                    param2 = bparam2;
                if(param3 == 0 && bparam3 != 0)
                    param3 = bparam3;
                if(length == 0 && blength != 0)
                    length = blength;
            }

            // Register new autocode

            std::string ac_str = std::string(wstrbuf); // Get the string out of strbuf

            switch(ac_type) // Translate string if possible
            {
            case AT_ShowText:
            case AT_ShowVar:
                tr.trScriptLine(ac_str, lineNum);
                break;
            default:
                break;
            }

            ac_str.erase(ac_str.find_last_not_of(" \n\r\t") + 1);

            std::string ref_str = std::string(wrefbuf); // Get var reference string if any

            Autocode newcode(ac_type, target, param1, param2, param3, AllocS(ac_str), length, cur_section, AllocS(ref_str));
            if(!add_to_globals)
            {
                if(newcode.m_Type < 10000 || newcode.MyRef != STRINGINDEX_NONE)
                {
                    m_Autocodes.emplace_back(std::move(newcode));
                    addToIndex(&m_Autocodes.back());
                }
                else   // Sprite components (type 10000+) with no reference go into callable component list
                    gSpriteMan.m_ComponentList.push_back(Autocode::GenerateComponent(newcode));
            }
            else
            {
                if(newcode.m_Type < 10000)
                {
                    m_GlobalCodes.emplace_back(std::move(newcode));
                    addToIndexGlob(&m_GlobalCodes.back());
                }
            }
        }
    }//while
}

std::string AutocodeManager::resolveWorldFileCase(const std::string &in_name)
{
    return g_dirEpisode.resolveFileCaseExistsAbs(in_name);
}

std::string AutocodeManager::resolveCustomFileCase(const std::string &in_name)
{
    return g_dirCustom.resolveFileCaseExistsAbs(in_name);
}

// DO EVENTS
void AutocodeManager::DoEvents(bool init)
{
    //char* dbg = "DO EVENTS DBG";
    if(m_Enabled)
    {
        // Add any outstanding custom events
        while(!m_CustomCodes.empty())
        {
            m_Autocodes.push_back(m_CustomCodes.back());
            m_CustomCodes.pop_back();
            addToIndex(&m_Autocodes.back());
        }

        // Do each code
        for(auto &m_Autocode : m_Autocodes)
            m_Autocode.Do(init);
    }

    if(m_GlobalEnabled)
    {
        // Do each global code
        for(auto &m_GlobalCode : m_GlobalCodes)
            m_GlobalCode.Do(init);
    }
}

// GET EVENT BY REF
Autocode *AutocodeManager::GetEventByRef(const std::string &ref_name)
{
    if(ref_name.length() > 0)
    {
        auto ref = m_autocodeIdxRef.find(ref_name);
        if(ref == m_autocodeIdxRef.end() || ref->second.empty())
            return nullptr;

        return ref->second.front();
    }
    return nullptr;
}

// DELETE EVENT -- Expires any command that matches the given name
void AutocodeManager::DeleteEvent(const std::string &ref_name)
{
    if(ref_name.length() > 0)
    {
        auto ref = m_autocodeIdxRef.find(ref_name);
        if(ref != m_autocodeIdxRef.end())
        {
            for(auto *code : ref->second)
                code->expire();
        }
    }
}

// CLEAN EXPIRED - Don't call this while iterating over codes
void AutocodeManager::ClearExpired()
{
    if(!m_hasExpired)
        return; // Nothing to do

// #define DEBUG_CLEAN_EXPIRED

#ifdef DEBUG_CLEAN_EXPIRED
    int cleanedAutos = 0, cleanedGlobs = 0;
#endif

    //char* dbg = "CLEAN EXPIRED DBG";
    auto iter = m_Autocodes.begin();
    auto end  = m_Autocodes.end();

    while(iter != m_Autocodes.end())
    {
        //Autocode* ac = *iter;
        if((*iter).Expired || (*iter).m_Type == AT_Invalid)
        {
            removeFromIndex(&*iter);
//            delete(*iter);
            iter = m_Autocodes.erase(iter);
#ifdef DEBUG_CLEAN_EXPIRED
            cleanedAutos++;
#endif
        }
        else
            ++iter;
    }

    iter = m_GlobalCodes.begin();
    end  = m_GlobalCodes.end();

    while(iter != m_GlobalCodes.end())
    {
        //Autocode* ac = *iter;
        if((*iter).Expired || (*iter).m_Type == AT_Invalid)
        {
//            delete(*iter);
            removeFromIndexGlob(&*iter);
            iter = m_GlobalCodes.erase(iter);
#ifdef DEBUG_CLEAN_EXPIRED
            cleanedGlobs++;
#endif
        }
        else
            ++iter;
    }

#ifdef DEBUG_CLEAN_EXPIRED
    if(cleanedAutos > 0)
        D_pLogDebug("Autocode: Cleaned %d expired autocodes", cleanedAutos);

    if(cleanedGlobs > 0)
        D_pLogDebug("Autocode: Cleaned %d expired global autocodes", cleanedGlobs);
#endif

    m_hasExpired = false;
}

// ACTIVATE CUSTOM EVENTS
void AutocodeManager::ActivateCustomEvents(int new_section, int eventcode)
{
    //char* dbg = "ACTIVATE CUSTOM DBG";
    if(m_Enabled)
    {
        auto secA = m_autocodeIdxSection.find(eventcode);
        if(secA != m_autocodeIdxSection.end())
        {
            for(auto *code : secA->second)
            {
                // Activate copies of events with 'eventcode' and move them to 'new_section'
                if(!code->Activated && !code->Expired)
                {
                    Autocode newcode = *code;
                    newcode.Activated = true;
                    newcode.ActiveSection = (new_section < 1000 ? (new_section - 1) : new_section);
                    newcode.Length = code->m_OriginalTime;
                    m_CustomCodes.push_front(std::move(newcode));
                }
            }
        }

        auto secG = m_globcodeIdxSection.find(eventcode);
        if(secG != m_globcodeIdxSection.end())
        {
            for(auto *code : secG->second)
            {
                // Activate copies of events with 'eventcode' and move them to 'new_section'
                if(!code->Activated && !code->Expired)
                {
                    Autocode newcode = *code;
                    newcode.Activated = true;
                    newcode.ActiveSection = (new_section < 1000 ? (new_section - 1) : new_section);
                    newcode.Length = code->m_OriginalTime;
                    m_CustomCodes.push_front(std::move(newcode));
                }
            }
        }
    }
}

// FORCE EXPIRE -- Expire all codes in section
void AutocodeManager::ForceExpire(int section)
{
    //char* dbg = "FORCE EXPIRE DBG";
    if(m_Enabled)
    {
        auto sec = m_autocodeIdxSection.find(section);
        if(sec != m_autocodeIdxSection.end())
        {
            for(auto *code : sec->second)
                code->expire();
        }

        auto secG = m_globcodeIdxSection.find(section);
        if(secG != m_globcodeIdxSection.end())
        {
            for(auto *code : secG->second)
                code->expire();
        }
    }
}

// FIND MATCHING -- Return a reference to the first autocode that matches, or 0
Autocode *AutocodeManager::FindMatching(int section, const std::string &soughtstr)
{
    //char* dbg = "FIND MATCHING DBG";
    // Find at m_Autocodes
    auto s = m_autocodeIdxSection.find(section);
    if(s == m_autocodeIdxSection.end())
        return nullptr;

    for(auto *code : s->second)
    {
        if(GetS(code->MyString) == soughtstr)
            return code;
    }

    return nullptr;
}

// VAR OPERATION -- Do something to a variable in the user variable bank
bool AutocodeManager::VarOperation(const std::string &var_name, num_t value, OPTYPE operation_to_do)
{
    if(var_name.length() > 0)
    {
        // Create var if doesn't exist
        InitIfMissing(&gAutoMan.m_UserVars, var_name, 0);

        num_t var_val = m_UserVars[var_name];

        // Do the operation
        OPTYPE oper = operation_to_do;
        switch(oper)
        {
        case OP_Assign:
            m_UserVars[var_name] = value;
            return true;
        case OP_Add:
            m_UserVars[var_name] = var_val + value;
            return true;
        case OP_Sub:
            m_UserVars[var_name] = var_val - value;
            return true;
        case OP_Mult:
            m_UserVars[var_name] = var_val.times(value);
            return true;
        case OP_Div:
            if(value == 0)
                return false;
            m_UserVars[var_name] = var_val.divided_by(value);
            return true;
        case OP_XOR:
            m_UserVars[var_name] = (int)var_val ^ (int)value;
            return true;
        default:
            return true;
        }
    }
    return false;
}

void AutocodeManager::addToIndex(Autocode *code)
{
    m_autocodeIdxSection[code->ActiveSection].push_back(code);
    if(!GetS(code->MyRef).empty())
        m_autocodeIdxRef[GetS(code->MyRef)].push_back(code);
}

void AutocodeManager::removeFromIndex(Autocode *code)
{
    auto &sec = m_autocodeIdxSection[code->ActiveSection];
    for(auto it = sec.begin(); it != sec.end(); )
    {
        if(*it == code)
            it = sec.erase(it);
        else
            ++it;
    }

    if(!GetS(code->MyRef).empty())
    {
        auto &ref = m_autocodeIdxRef[GetS(code->MyRef)];
        for(auto it = ref.begin(); it != ref.end(); )
        {
            if(*it == code)
                it = ref.erase(it);
            else
                ++it;
        }
    }
}

void AutocodeManager::addToIndexGlob(Autocode *code)
{
    m_globcodeIdxSection[code->ActiveSection].push_back(code);
    if(!GetS(code->MyRef).empty())
        m_globcodeIdxRef[GetS(code->MyRef)].push_back(code);
}

void AutocodeManager::removeFromIndexGlob(Autocode *code)
{
    auto &sec = m_globcodeIdxSection[code->ActiveSection];
    for(auto it = sec.begin(); it != sec.end(); )
    {
        if(*it == code)
            it = sec.erase(it);
        else
            ++it;
    }

    if(!GetS(code->MyRef).empty())
    {
        auto &ref = m_globcodeIdxRef[GetS(code->MyRef)];
        for(auto it = ref.begin(); it != ref.end(); )
        {
            if(*it == code)
                it = ref.erase(it);
            else
                ++it;
        }
    }
}

void AutocodeManager::addError(int lineNumber, const std::string &line, const std::string &msg)
{
    ParseError err;
    err.lineNumber = lineNumber;
    err.line = line;
    err.message = msg;

    // Trim the tail of the line
    while(!err.line.empty())
    {
        auto c = err.line.back();
        if(c != '\n' && c != '\r' && c != '\t' && c != ' ')
            break;
        err.line.pop_back();
    }

    // Cut the line to 80 symbols
    if(err.line.size() > 80)
    {
        err.line.erase(80);
        err.line += "...";
    }

    pLogWarning("Autocode: Script parse error: [%s] at %d: %s",
                err.message.c_str(), err.lineNumber, err.line.c_str());

    m_errors.push_back(std::move(err));
}

void AutocodeManager::showErrors(const std::string &file)
{
    if(m_errors.empty())
        return; // No errors

    std::string out = fmt::format_ne("While parsing the {0} file, next errors has ocurred:\n\n", file);

    int lines = 0;
    for(auto &e : m_errors)
    {
        out += fmt::format_ne("{0}, {1}:{2}\n", e.message, e.lineNumber, e.line);
        lines++;
        if(lines > 25)
        {
            out += "... ";
            break;
        }
    }

    XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR, "Autocode script parse errors", out);
}

// VAR EXISTS
bool AutocodeManager::VarExists(const std::string &var_name)
{
    return (m_UserVars.find(var_name) != m_UserVars.end());
}

// GET VAR
num_t AutocodeManager::GetVar(const std::string &var_name)
{
    if(!VarExists(var_name))
        return 0;

    return m_UserVars[var_name];
}


================================================
FILE: src/script/luna/autocode_manager.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef AutoCodeManager_hhh
#define AutoCodeManager_hhh

#include <string>
#include <map>
#include <unordered_map>
#include <list>
#include <SDL2/SDL_rwops.h>

#include "autocode.h"

#define AUTOCODE_FNAME      "lunadll.txt"
#define WORLDCODE_FNAME     "lunaworld.txt"
#define GLOBALCODE_FNAME    "lunaglobal.txt"
#define PARSE_FMT_STR       " %149[^,], %lf , %lf , %lf , %lf , %lf , %999[^\n]"
#define PARSE_FMT_STR_2     " %149[^,], %i , %i , %i , %i , %i , %999[^\n]"
//                       Cmd    Trg   P1    P2    P3    Len   String

struct AutocodeManager
{
    AutocodeManager() noexcept;
    ~AutocodeManager();

    bool LoadFiles();

    // File funcs
    bool ReadFile(const std::string &script_path, const std::string &tr_key); // Load level codes from dir_path
    bool ReadWorld(const std::string &script_path, const std::string &tr_key); // Load worldwide codes from dir_path
    bool ReadGlobals(const std::string &script_path); // Load global codes from dir_path
    void Parse(SDL_RWops *open_file, bool add_to_globals, const std::string &tr_key = std::string());

    static std::string resolveWorldFileCase(const std::string &in_name);
    static std::string resolveCustomFileCase(const std::string &in_name);

    // Management funcs
    void Clear();
    void ForceExpire(int section);
    void ClearExpired();
    void DeleteEvent(const std::string &event_reference_name);     // Look up event with given name and expire it
    void DoEvents(bool init);
    void ActivateCustomEvents(int new_section, int eventcode);
    Autocode *GetEventByRef(const std::string &event_reference_name);   // Return ptr to event with the given ref, or NULL if it fails
    Autocode *FindMatching(int section, const std::string &string);

    // Variable bank funcs
    num_t GetVar(const std::string &var_name);        // returns 0 if var doesn't exist in bank
    bool VarExists(const std::string &var_name);
    bool VarOperation(const std::string &var_name, num_t value, OPTYPE operation_to_do);

    // Members
    bool                    m_Enabled = false;          // Whether or not individual level scripts enabled
    bool                    m_GlobalEnabled = false;    // Whether or not global game scripts enabled
    std::list<Autocode>     m_Autocodes;
    std::list<Autocode>     m_InitAutocodes;
    std::list<Autocode>     m_CustomCodes;
    std::list<Autocode>     m_GlobalCodes;

    //! When any event gets expired, this field gets set to proceed the cleanup of expired events
    bool                    m_hasExpired = false;

    //! Index table to find autocodes by section
    std::unordered_map<int, std::list<Autocode*>>          m_autocodeIdxSection;
    //! Index table to find autocodes by referrence
    std::unordered_map<std::string, std::list<Autocode*>>  m_autocodeIdxRef;

    //! Index table to find global autocodes by section
    std::unordered_map<int, std::list<Autocode*>>          m_globcodeIdxSection;
    //! Index table to find global autocodes by reference
    std::unordered_map<std::string, std::list<Autocode*>>  m_globcodeIdxRef;

    void addToIndex(Autocode *code);
    void removeFromIndex(Autocode *code);

    void addToIndexGlob(Autocode *code);
    void removeFromIndexGlob(Autocode *code);

    struct ParseError
    {
        int lineNumber = -1;
        std::string line;
        std::string message;
    };

    std::list<ParseError> m_errors;
    void addError(int lineNumber, const std::string &line, const std::string &msg);
    void showErrors(const std::string &file);

    std::map<std::string, num_t> m_UserVars;

    // Hearts manager stuff
    int m_Hearts = 2;
};

extern AutocodeManager gAutoMan;

#endif // AutoCodeManager_hhh


================================================
FILE: src/script/luna/csprite.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "csprite.h"
#include "sprite_funcs.h"
#include "renderop_rect.h"
#include "lunaimgbox.h"


// CTOR
CSprite::CSprite()
{
    Init();
}

// INIT
void CSprite::Init()
{
    m_ImgResCode = -1;
    m_CollisionCode = -1;
    m_StaticScreenPos = false;
    m_Visible = true;
    m_Birthed = false;
    m_Died = false;
    m_Invalidated = false;
    m_LimitedFrameLife = false;
    m_AnimationSet = false;
    m_AlwaysProcess = false;
    m_FramesLeft = 0;
    m_DrawPriorityLevel = 1;
    m_OffscreenCount = 0;
    m_FrameCounter = 0;
    m_GfxXOffset = 0;
    m_GfxYOffset = 0;
    m_Xpos = 0;
    m_Ypos = 0;
    m_Ht = 0;
    m_Wd = 0;
    m_Xspd = 0;
    m_Yspd = 0;
    m_AnimationPhase = 0;
    m_AnimationFrame = 0;
    m_AnimationTimer = 0;
    m_Hitbox.pParent = this;
}

// CLEAR EXPIRED COMPONENTS
void CSprite::ClearExpiredComponents()
{
    std::list<SpriteComponent>::iterator iter = m_BehavComponents.begin();
    // std::list<SpriteComponent>::iterator end  = m_BehavComponents.end();

    while(iter != m_BehavComponents.end())
    {
        SpriteComponent comp = *iter;
        if((*iter).expired)
            iter = m_BehavComponents.erase(iter);
        else
            ++iter;
    }
}

//#ifndef __MINGW32__
//#pragma region Add functions
//#endif

// ADD BIRTH -- Add a birth function to sprite
void CSprite::AddBirthComponent(SpriteComponent comp)
{
    if(comp.func != nullptr)
        m_BirthComponents.push_back(comp);
}

// ADD BEHAVIOR -- Add a behavior component to sprite
void CSprite::AddBehaviorComponent(SpriteComponent comp)
{
    if(comp.func != nullptr)
        m_BehavComponents.push_back(comp);
}

// ADD DRAW -- Add a draw component to sprite. Updates m_StaticScreenPos if static drawing detected.
void CSprite::AddDrawComponent(pfnSprDraw func)
{
    if(func != nullptr)
        m_DrawFuncs.push_back(func);
    if(func == SpriteFunc::StaticDraw)
        m_StaticScreenPos = true;
}

// ADD DEATH -- Add a death function to sprite
void CSprite::AddDeathComponent(SpriteComponent comp)
{
    if(comp.func != nullptr)
        m_DeathComponents.push_back(comp);
}

//#ifndef __MINGW32__
//#pragma endregion
//#endif

// SET IMAGE RESOURCE
void CSprite::SetImageResource(int _resource_code)
{
    m_ImgResCode = _resource_code;
}
void CSprite::SetImage(LunaImage *in_img)
{
    m_directImg = in_img;
}

// MAKE LIMITED LIFETIME
void CSprite::MakeLimitedLifetime(int new_lifetime)
{
    this->m_LimitedFrameLife = true;
    this->m_FramesLeft = new_lifetime;
}

// BIRTH -- Run the birth components
void CSprite::Birth()
{
    if(!m_Birthed)
    {
        for(std::list<SpriteComponent>::iterator iter = m_BirthComponents.begin(); iter != m_BirthComponents.end(); ++iter)
            (*iter).func(this, &(*iter));
    }
    m_Birthed = true;
}

// PROCESS -- Process 1 frame of lifetime. Call all of the running behavior components
void CSprite::Process()
{
    ClearExpiredComponents();

    if(!m_Birthed)
        Birth();

    m_FrameCounter++;

    for(std::list<SpriteComponent>::iterator iter = m_BehavComponents.begin(); iter != m_BehavComponents.end(); ++iter)
    {
        (*iter).func(this, &(*iter));
        (*iter).Tick();
    }

    // Die?
    if(this->m_LimitedFrameLife)
    {
        this->m_FramesLeft--;
        if(m_FramesLeft <= 0 && !m_Died)
            Die();
    }
}

// DRAW -- Call all of the registered draw components
void CSprite::Draw()
{
    for(auto &iter  : m_DrawFuncs)
        iter(this);

#if 0   //debug
    {
        RenderRectOp op;
        op.x1 = m_Xpos;
        op.y1 = m_Ypos;
        op.x2 = m_Xpos + m_Wd;
        op.y2 = m_Xpos + m_Ht;
        op.m_FramesLeft = 1;
        op.Draw(&Renderer::Get());
    }
#endif
}

// DIE -- Run the death components
void CSprite::Die()
{
    for(auto &iter : m_DeathComponents)
        iter.func(this, &iter);

    m_Died = true;
    m_Invalidated = true;
}

// SET CUSTOM VAR
void CSprite::SetCustomVar(std::string var_name, OPTYPE operation_to_do, num_t value)
{
    if(var_name.length() > 0)
    {
        // Create var if doesn't exist
        if(m_CustomVars.find(var_name) == m_CustomVars.end())
            m_CustomVars[var_name] = 0;

        num_t var_val = m_CustomVars[var_name];

        // Do the operation
        OPTYPE oper = operation_to_do;
        switch(oper)
        {
        case OP_Assign:
            m_CustomVars[var_name] = value;
            break;
        case OP_Add:
            m_CustomVars[var_name] = var_val + value;
            break;
        case OP_Sub:
            m_CustomVars[var_name] = var_val - value;
            break;
        case OP_Mult:
            m_CustomVars[var_name] = var_val.times(value);
            break;
        case OP_Div:
            if(value == 0)
                break;
            m_CustomVars[var_name] = var_val.divided_by(value);
            break;
        case OP_XOR:
            m_CustomVars[var_name] = (int)var_val ^ (int)value;
            break;
        default:
            break;
        }
    }
}

// CUSTOM VAR EXISTS
bool CSprite::CustomVarExists(std::string var_name)
{
    return m_CustomVars.find(var_name) == m_CustomVars.end() ? false : true;
}

// GET CUSTOM VAR
num_t CSprite::GetCustomVar(std::string var_name)
{
    if(m_CustomVars.find(var_name) == m_CustomVars.end())
        return 0;
    return m_CustomVars[var_name];
}


================================================
FILE: src/script/luna/csprite.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CSPRITE_HHHHH
#define CSPRITE_HHHHH

#include <list>
#include <map>
#include <vector>

#include "lunadefs.h"
#include "hitbox.h"
#include "sprite_component.h"

/// CSprite builtin custom variables
#define CVAR_GEN_ANGLE "_GenAngle"

class LunaImage;
class CSprite;
struct CSpriteRequest;
struct SpriteComponent;

typedef void (*pfnSprFunc)(CSprite*, SpriteComponent* obj);
typedef void (*pfnSprDraw)(CSprite*);

// General custom sprite class
class CSprite
{
public:

    /// Functions ///
    CSprite();
    void Init();

    void ClearExpiredComponents();

    void AddBirthComponent(SpriteComponent component);
    void AddBehaviorComponent(SpriteComponent component);
    void AddDrawComponent(pfnSprDraw component);
    void AddDeathComponent(SpriteComponent component);

    void SetImageResource(int _resource_code);
    void SetImage(LunaImage *in_img);
    void MakeLimitedLifetime(int new_lifetime);

    void Birth();
    void Process();
    void Draw();
    void Die();

    void SetCustomVar(std::string var_name, OPTYPE operation, num_t val);
    bool CustomVarExists(std::string var_name);
    num_t GetCustomVar(std::string var_name);

    /// Members///
    //! Image bank code of image resource the sprite uses
    int m_ImgResCode = 0;
    LunaImage *m_directImg = nullptr;
    //! Collision code for collision blueprint bank (-1 == all blocks collide as solid)
    int m_CollisionCode = 0;

    //! How many frames are left if dying automatically
    int m_FramesLeft = 0;
    //! 0 = Low  1 = Mid  2 = High (drawn in front)
    int m_DrawPriorityLevel = 0;
    //! How many frames this sprite has been offscreen
    int m_OffscreenCount = 0;
    //! Incremented each Process()
    int m_FrameCounter = 0;
    int m_GfxXOffset = 0;
    int m_GfxYOffset = 0;
    //! Whether or not sprite uses absolute screen coords for drawing
    bool m_StaticScreenPos = false;
    //! Whether or not this sprite should be drawn
    bool m_Visible = true;
    //! Whether or not sprite's birth funcs have been run yet
    bool m_Birthed = false;
    //! Whether or not sprite's death funcs have been run yet
    bool m_Died = false;
    //! Whether or not this sprite will be removed during the next cleanup phase
    bool m_Invalidated = false;
    //! Whether or not the sprite dies automatically after a number of frames
    bool m_LimitedFrameLife = false;
    //! Whether or not the animation parameters have been set for this sprite yet
    bool m_AnimationSet = false;
    //! Whether or not this sprite should be processed regardless of player's current section
    bool m_AlwaysProcess = false;

    num_t m_Xpos;
    num_t m_Ypos;
    //! Height Of loaded image graphic for backwards compat with native SMBX sprites
    int m_Ht;
    //! Width Of loaded image graphic for backwards compat with native SMBX sprites
    int m_Wd;
    num_t m_Xspd;
    num_t m_Yspd;

    //! Hitbox relative to sprite position
    Hitbox m_Hitbox;

    //! Time per animation
    int m_AnimationPhase;
    //! Current timer for animation (animate when reaching 0)
    int m_AnimationTimer;
    //! The current frame in m_GfxRects to be drawn (0 == first frame)
    int m_AnimationFrame;
    //! Spritesheet areas to draw, indexed by animation frame
    std::vector<LunaRect> m_GfxRects;

    std::list<SpriteComponent> m_BirthComponents;
    //! Currently loaded behavioral components
    std::list<SpriteComponent> m_BehavComponents;
    std::list<pfnSprDraw> m_DrawFuncs;
    std::list<SpriteComponent> m_DeathComponents;

    //! User-defined vars
    std::map<std::string, num_t> m_CustomVars;
};


// Obj for interfacing with sprite factory
struct CSpriteRequest
{
    CSpriteRequest() : type(0), x(0), y(0), time(0), img_resource_code(0), x_speed(0), y_speed(0), spawned(false) {}
    int type = 0;
    int x = 0;
    int y = 0;
    int time = 0;
    int img_resource_code = 0;
    LunaImage *direct_img = nullptr;
    std::string str;

    // Optional parameters
    num_t x_speed = 0;
    num_t y_speed = 0;
    //! "spawned" means the sprite will be deleted after being offscreen for some time
    bool spawned = false;
};

#endif // CSPRITE_HHHHH


================================================
FILE: src/script/luna/hitbox.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "hitbox.h"
#include "csprite.h"

// TEST -- fast rectangle
bool Hitbox::Test(int Left2, int Up2, int iW, int iH) const
{
    if(pParent)
    {
        if(this->CollisionType == 0)   // square aabb collision detection
        {
            // bool rightcol = true;
            // bool leftcol = true;
            // bool upcol = true;
            // bool downcol = true;

            if(CalcRight() < Left2)
                return false;
            if(CalcLeft() > Left2 + iW)
                return false;
            if(CalcTop() > Up2 + iH)
                return false;
            if(CalcBottom() < Up2)
                return false;

            // This condition is ALWAYS FALSE
            //if(!rightcol || !leftcol || !upcol || !downcol)
            //    return false;
            return true;
        }
        else   // circle vs aaab -> convert to circle
        {
            int hW = iW / 2;
            int hH = iH / 2;
            int halfwidth = hW;
            int halfheight = hH;
            return Test((int)(Left2 + halfwidth), (int)(Up2 + halfheight), (int)(halfwidth <= halfheight ? halfwidth : halfheight));
        }
    }

    return false;
}

// TEST -- fast circle/distance
bool Hitbox::Test(int cx, int cy, int radius) const
{
    int radi_total = radius + (W <= H ? W / 2 : H / 2); // Other obj radius + my radius
    radi_total *= radi_total;
    int x_dist = (int)CenterX() - cx;
    int y_dist = (int)CenterY() - cy;
    int sqr_dist = x_dist * x_dist + y_dist * y_dist;

    if(sqr_dist > radi_total)
        return false;

    return true;
}

num_t Hitbox::CalcLeft() const
{
    if(pParent)
        return pParent->m_Xpos + Left_off;
    return 0;
}

num_t Hitbox::CalcTop() const
{
    if(pParent)
        return pParent->m_Ypos + Top_off;
    return 0;
}

num_t Hitbox::CalcBottom() const
{
    if(pParent)
        return pParent->m_Ypos + H;
    return 0;
}

num_t Hitbox::CalcRight() const
{
    if(pParent)
        return pParent->m_Xpos + W;
    return 0;
}

num_t Hitbox::CenterX() const
{
    return CalcLeft() + W * 0.5_n;
}

num_t Hitbox::CenterY() const
{
    return CalcTop() + H * 0.5_n;
}


================================================
FILE: src/script/luna/hitbox.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef HitBox_HHHHH
#define HitBox_HHHHH

#include <cstddef>
#include "numeric_types.h"

class CSprite;

enum COLLISION_TYPE
{
    COLTYPE_NONE = 0,
    COLTYPE_LEFT,
    COLTYPE_RIGHT,
    COLTYPE_TOP,
    COLTYPE_BOT,
};

struct Hitbox
{
    Hitbox() = default;

    num_t CalcLeft() const;      // Get the left absolute position (with parent base coords)
    num_t CalcRight() const;     // Get the right absolute position (with parent base coords)
    num_t CalcTop() const;       // Get the top absolute position (with parent base coords)
    num_t CalcBottom() const;    // Get the bottom absolute position (with parent base coords)
    num_t CenterX() const;       // Get the center X position (from parent base coords)
    num_t CenterY() const;       // Get the center Y position (from parent base coords)

    bool Test(int left, int up, int iW, int iH) const; // Test hitbox against given rect
    bool Test(int cx, int cy, int radius) const;              // Test hitbox against given circle

    short Left_off = 0;         // Offset from 0,0 on sprite
    short Top_off = 0;          // Offset from 0,0 on sprite
    short W = 0;                // Width
    short H = 0;                // Height

    //COLLISION_TYPE GetCollisionDir(int left, int up, int right, int down); // Get the direction this hitbox is colliding with given rect
    char CollisionType = 0;     // 0 = square aabb  1 = circle/dist
    CSprite *pParent = nullptr;   // Pointer to parent sprite (for calculating actual coordinates + collision area)

};

#endif // HitBox_HHHHH


================================================
FILE: src/script/luna/levels/Docopoper-AbstractAssault.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/*************************************************
 *  Episode:    A2MBXT, Episode 1: Analog Funk   *
 *  Level:      Abstract Assault                 *
 *  Filename:   Docopoper-AbstractAssault.lvl    *
 *  Author:     Docopoper                        *
 *************************************************/

#include "sdl_proxy/sdl_assert.h"

#include "globals.h"
#include "layers.h"
#include "../lunaplayer.h"
#include "../lunalayer.h"
#include "Docopoper-AbstractAssault.h"


#define X_MAX(a, b) (((a) > (b)) ? (a) : (b))
#define X_MIN(a, b) (((a) < (b)) ? (a) : (b))
#define X_CLAMP(x, l, h) (((x) > (h)) ? (h) : (((x) < (l)) ? (l) : (x)))


void AbstractAssaultCode()
{
    Player_t *demo = PlayerF::Get(1);
    Layer_t *layerDefault = LayerF::Get(0);
    Layer_t *layerStartingPlatform = LayerF::Get(3);

    SDL_assert_release(demo);
    SDL_assert_release(layerDefault);
    SDL_assert_release(layerStartingPlatform);

    static num_t hspeed = 0, vspeed = 0;
    static char gameStarted = 0;
    static unsigned short noControlTimer = 0;

    bool press_up = demo->Controls.Up;
    bool press_left = demo->Controls.Left;
    bool press_down = demo->Controls.Down;
    bool press_right = demo->Controls.Right;

    auto &powerup = demo->State;

    if(layerStartingPlatform -> SpeedY == 0)
    {
        demo -> Character = 1; //Demo
        //player_id_set = 1;
        gameStarted = 0;
        powerup = 1;
    }
    else if(!gameStarted)
    {
        powerup = 6;
        demo -> SpinJump = false;
        demo -> Hearts = 3;
        vspeed = -16;
        hspeed = -4;
        gameStarted = 1;
        noControlTimer = 30;
        demo->Character = 5; //Sheath
    }

    if(gameStarted)
    {
        if(layerStartingPlatform -> SpeedY == 0)
            gameStarted = 0;

        demo -> SpinJump = false;

        layerDefault -> SpeedX = (numf_t) X_MAX((num_t)layerDefault -> SpeedX - 0.015_n, -2.5_n);

        if(demo -> Hearts > 1)
            powerup = 6;

        demo -> Direction = 1;
        demo -> Multiplier %= 9;

        if(noControlTimer == 0)
        {
            vspeed = X_CLAMP(vspeed + (press_down - press_up) * 0.5_n, -10, 10);
            hspeed = X_CLAMP(hspeed + (press_right - press_left) * 0.5_n, -10, 10);
        }
        else
            noControlTimer--;

        demo->Location.SpeedY = -0.4_n + vspeed;
        demo->Location.SpeedX = hspeed;

        hspeed *= 0.9_r;
        vspeed *= 0.9_r;
    }
}


================================================
FILE: src/script/luna/levels/Docopoper-AbstractAssault.h
================================================
extern void AbstractAssaultCode();

================================================
FILE: src/script/luna/levels/Docopoper-Calleoca.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/*************************************************
 *  Episode:    A2MBXT, Episode 1: Analog Funk   *
 *  Level:      Custom C++ Code, Example #3      *
 *  Filename:   Docopoper-Calleoca.lvl           *
 *  Author:     Docopoper                        *
 *************************************************/

#include <cstdlib>
#include <cmath>

#include "sdl_proxy/sdl_stdinc.h"

#include "Docopoper-Calleoca.h"
#include "globals.h"
#include "main/trees.h"
#include "../lunaplayer.h"
#include "../lunanpc.h"


#define PI 3.14159_r
#define PI_DIV 3.14159_ri

#define NPCID_SIGN 151
#define NPCID_COIN 10
#define NPCID_FIRE_CHAIN 260
#define NPCID_GOAL 16

#define OFFSCREEN_DIST 400
#define MIDPOINT_X -194620
#define END_X -188792


NPC_t* FindNPC(vbint_t identity);
void HurtPlayer();
bool TriggerBox(num_t x1, num_t y1, num_t x2, num_t y2);
int AngleDifference(int angle1, int angle2);

static bool init_doonce = false;

static Player_t* demo = nullptr;

static NPC_t* calleoca_npc1 = nullptr;
static NPC_t* calleoca_npc2 = nullptr;
static NPC_t* hurt_npc = nullptr;
static NPC_t* goal_npc = nullptr;

static int win_timer = 0;
static int freeze_timer = 0;
static int phase = 0;
static num_t calleoca_x = 0, calleoca_y = 0, storage_x = 0, storage_y = 0;

static num_t thwomp_hspeed = 0;
static num_t thwomp_vspeed = 0;
static num_t thwomp_height = 0, thwomp_bottom = 0;

static num_t missile_direction = 0;
static num_t missile_hspeed = 0;
static num_t missile_vspeed = 0;
static num_t missile_top = 0, missile_bottom = 0;
static int missile_fuel = 0;

static num_t fishingboo_hspeed = 0;
static num_t fishingboo_vspeed = 0;
static num_t fishingboo_ferocity = 1;

template <typename T> T Clamp(const T& value, const T& low, const T& high)
{
  return value < low ? low : (value > high ? high : value);
}

void CalleocaInitCode()
{
    init_doonce = false;

    phase = 0;

    win_timer = 100;

    thwomp_hspeed = 0;
    thwomp_vspeed = 0;

    freeze_timer = 0;

    missile_direction = 0;
    missile_hspeed = 0;
    missile_vspeed = 0;

    fishingboo_hspeed = 0;
    fishingboo_vspeed = 0;
    fishingboo_ferocity = 1;
}

void Phase0()
{
    calleoca_npc1->Frame = 0;

    if(demo->Location.X > calleoca_x + 128)
    {
        freeze_timer = 45;
        phase = 1;
    }

    if(demo->Location.X >= MIDPOINT_X)
    {
        phase = 3;
        calleoca_x = MIDPOINT_X - 256;
        calleoca_y -= 256;
    }
}

/*************************************************************************************************/
//Standing there
void Phase1()
{
    thwomp_hspeed += (demo->Location.X - calleoca_x) / 1000;
    if(num_t::abs(thwomp_height - calleoca_y) < 8)
    {
        thwomp_hspeed = Clamp<num_t>(thwomp_hspeed, -9, 9);

        if (TriggerBox(calleoca_x, calleoca_y + 64, calleoca_x + 64, calleoca_y + 512))
            phase = 2;
    }
    else
        thwomp_hspeed = 0;

    thwomp_vspeed = (thwomp_height - calleoca_y) / 10;
    thwomp_vspeed = Clamp<num_t>(thwomp_vspeed, -6, 6);

    if(freeze_timer > 0)
    {
        thwomp_vspeed = 0;
        freeze_timer--;
    }

    calleoca_x += thwomp_hspeed;
    calleoca_y += thwomp_vspeed;

    calleoca_npc1->Frame = 2;
    if(TriggerBox(calleoca_x + 10, calleoca_y + 0, calleoca_x + 54, calleoca_y + 64))
        HurtPlayer();

    if(demo->Location.X >= MIDPOINT_X)
    {
        freeze_timer = 150;
        phase = 3;
    }
}

/*************************************************************************************************/
//Thwomp rising / moving
void Phase2()
{
    thwomp_hspeed *= 0.9_r;
    if(demo->Location.Y <= calleoca_y)
        thwomp_hspeed *= 0.9_r;

    thwomp_vspeed += (thwomp_bottom - calleoca_y) / 20;
    thwomp_vspeed = Clamp<num_t>(thwomp_vspeed, -8, 8);

    calleoca_x += thwomp_hspeed;
    calleoca_y += thwomp_vspeed;
    calleoca_npc1->Frame = 1;
    if(TriggerBox(calleoca_x + 10, calleoca_y + 0, calleoca_x + 54, calleoca_y + 64))
        HurtPlayer();

    if(calleoca_y >= thwomp_bottom)
    {
        freeze_timer = 22;
        phase = 1;
    }

    if(demo->Location.X >= MIDPOINT_X)
    {
        freeze_timer = 150;
        phase = 3;
    }
}

/*************************************************************************************************/
//Missile
void Phase3()
{
    calleoca_npc1->Frame = 3 + num_t::round(missile_direction / 45) % 8;

    int dir = (int)(num_t::atan2((demo->Location.Y + demo->Location.Height / 2) - (calleoca_y + 32),
                              -(demo->Location.X + demo->Location.Width / 2) + (calleoca_x + 32))
                                * 180 / PI_DIV);

    missile_direction += AngleDifference((int)missile_direction, dir) * 0.015_n;

    if(missile_direction >= 360)
        missile_direction -= 360;
    else if(missile_direction < 0)
        missile_direction += 360;

    missile_hspeed += num_t::cos(missile_direction * PI / 180) / 4;
    missile_vspeed -= num_t::sin(missile_direction * PI / 180) / 4;

    missile_hspeed = Clamp<num_t>(missile_hspeed * 0.975_r, -15, 15);
    missile_vspeed = Clamp<num_t>(missile_vspeed * 0.975_r, -15, 15);

    if(freeze_timer > 0)
    {
        freeze_timer--;
        missile_hspeed = 0;
        missile_vspeed = 0;
        missile_fuel = 600;
    }
    else
    {
        missile_fuel--;
        if(missile_fuel <= 0 && !TriggerBox(calleoca_x - 100, calleoca_y - 100, calleoca_x + 164, calleoca_y + 164))
            freeze_timer = 110;
    }


    calleoca_x = Clamp<num_t>(calleoca_x + missile_hspeed, demo->Location.X - 464, demo->Location.X + 464);
    calleoca_y = Clamp<num_t>(calleoca_y + missile_vspeed, missile_top, missile_bottom);

    if(TriggerBox(calleoca_x + 18, calleoca_y + 18, calleoca_x + 46, calleoca_y + 46))
        HurtPlayer();

    if(demo->Location.X >= END_X)
    {
        if (calleoca_x > END_X - 64)
            calleoca_x = END_X - 64;
        freeze_timer = 150;
        phase = 4;
    }
}

void Phase4()
{
    if(freeze_timer > 0)
    {
        freeze_timer--;
    }
    else
    {
        fishingboo_hspeed += (demo->Location.X - calleoca_x).times(fishingboo_ferocity) / 1000;
        fishingboo_vspeed += (demo->Location.Y - calleoca_y).times(fishingboo_ferocity) / 1000;
        fishingboo_hspeed = Clamp<num_t>(fishingboo_hspeed, -7 * fishingboo_ferocity, 7 * fishingboo_ferocity);
        fishingboo_vspeed = Clamp<num_t>(fishingboo_vspeed, -0.5_rb * fishingboo_ferocity, 0.5_rb * fishingboo_ferocity);

        calleoca_x += fishingboo_hspeed;
        calleoca_y += fishingboo_vspeed;

        fishingboo_ferocity += 0.0002_n;
    }

    calleoca_x = Clamp<num_t>(calleoca_x, demo->Location.X - 512, demo->Location.X + 464);
}

void CalleocaCode()
{
    demo = PlayerF::Get(1);

    demo->Character = 1;

    if(calleoca_npc2 == nullptr && init_doonce)
    {
        if(win_timer > 0)
            win_timer--;
        else
        {
            goal_npc = FindNPC(NPCID_GOAL);
            if(goal_npc != nullptr)
            {
                goal_npc->Location.X = demo->Location.X;
                goal_npc->Location.Y = demo->Location.Y;
                treeNPCUpdate(goal_npc);
            }
        }

        return; //boss beaten
    }

    if(!init_doonce)
    {
        calleoca_npc1 = FindNPC(NPCID_SIGN);
        calleoca_npc2 = FindNPC(NPCID_COIN);
        hurt_npc	  = FindNPC(NPCID_FIRE_CHAIN);

        calleoca_x = calleoca_npc1->Location.X;
        calleoca_y = calleoca_npc1->Location.Y;
        storage_x  = calleoca_npc2->Location.X;
        storage_y  = calleoca_npc2->Location.Y;

        thwomp_height = calleoca_y - 64 * 6 + 16;
        thwomp_bottom = calleoca_y + 128;

        missile_top = calleoca_y - 64 * 7 - 16;
        missile_bottom = calleoca_y + 180;

        init_doonce = true;
    }

    if(calleoca_npc1->Type != NPCID_SIGN)
        calleoca_npc1 = FindNPC(NPCID_SIGN);

    if(calleoca_npc2->Type != NPCID_COIN)
        calleoca_npc2 = FindNPC(NPCID_COIN);

    if(hurt_npc->Type != NPCID_FIRE_CHAIN)
        hurt_npc = FindNPC(NPCID_FIRE_CHAIN);

    hurt_npc->Location.X = demo->Location.X;
    hurt_npc->Location.Y = demo->Location.Y - 128;
    treeNPCUpdate(hurt_npc);

    switch (phase)
    {
    case 0: //Standing there
        Phase0();
        break;

    case 1: //Thwomp rising
        Phase1();
        break;

    case 2: //Thwomp attacking
        Phase2();
        break;

    case 3: //Missile
        Phase3();
        break;

    case 4: //Fishing Boo
        Phase4();
        break;

    default:
        break;
    }

    if(!calleoca_npc2)
        return; //boss beaten

    if(phase < 4)
    {
        calleoca_npc1->Location.X = calleoca_x;
        calleoca_npc1->Location.Y = calleoca_y;
        calleoca_npc2->Location.X = storage_x;
        calleoca_npc2->Location.Y = storage_y;
    }
    else
    {
        calleoca_npc2->Location.X = calleoca_x;
        calleoca_npc2->Location.Y = calleoca_y;
        calleoca_npc1->Location.X = storage_x;
        calleoca_npc1->Location.Y = storage_y;
    }

    treeNPCUpdate(calleoca_npc1);
    treeNPCUpdate(calleoca_npc2);

    //Renderer::Get().SafePrint(std::wstring(L"FUEL: " + std::to_wstring(missile_fuel)), 3, 0, 256);
    //Renderer::Get().SafePrint(std::wstring(L"DEMO X: " + std::to_wstring(demo->CurYPos)), 3, 0, 256 + 32);
}

NPC_t* FindNPC(vbint_t identity)
{
    NPC_t* currentnpc = nullptr;

    for(int i = 0; i < numNPCs; i++)
    {
        currentnpc = NpcF::Get(i);
        if(currentnpc && currentnpc->Type == identity)
            return currentnpc;
    }

    return nullptr;
}

bool TriggerBox(num_t x1, num_t y1, num_t x2, num_t y2)
{
    return (demo->Location.X + demo->Location.Width     > x1 &&
            demo->Location.X                            < x2 &&
            demo->Location.Y + demo->Location.Height    > y1 &&
            demo->Location.Y                            < y2);
}

void HurtPlayer()
{
    hurt_npc->Location.Y = demo->Location.Y;
}

int AngleDifference(int angle1, int angle2)
{
    return ((((angle1 - angle2) % 360) + 540) % 360) - 180;
}


================================================
FILE: src/script/luna/levels/Docopoper-Calleoca.h
================================================
extern void CalleocaInitCode();
extern void CalleocaCode();


================================================
FILE: src/script/luna/levels/Docopoper-TheFloorisLava.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/*************************************************
 *  Episode:    A2MBXT, Episode 1: Analog Funk   *
 *  Level:      The Floor is Lava!               *
 *  Filename:   Docopoper-TheFloorisLava.lvl     *
 *  Author:     Docopoper                        *
 *************************************************/

#include "sdl_proxy/sdl_assert.h"

#include "globals.h"
#include "../lunaplayer.h"
#include "../lunalayer.h"
#include "layers.h"
#include "Docopoper-TheFloorisLava.h"


void TheFloorisLavaInit()
{
    Player_t* demo = PlayerF::Get(1);
    if(demo)
        demo->Character = 1;
}

void TheFloorisLavaCode()
{
    Player_t *demo = PlayerF::Get(1);
    Layer_t *layerSecretExit = LayerF::Get(3);
    Layer_t *layerSinUpDown = LayerF::Get(4);
    Layer_t *layerSinRightLeft = LayerF::Get(5);
    Layer_t *layerSinUpDownAlternate = LayerF::Get(6);
    Layer_t *layerSinUpDownWeak = LayerF::Get(7);
    Layer_t *layerSinUpDownWeakAlt = LayerF::Get(8);
    Layer_t *layerSinRightLeftAlternate = LayerF::Get(9);

    static num_t layerSinUpDown_displacement = 0;
    static num_t layerSinRightLeft_displacement = 0;
    static char secretExitFailedStage = 0;

    if(!demo)
        return;

    SDL_assert_release(layerSecretExit);
    SDL_assert_release(layerSinUpDown);
    SDL_assert_release(layerSinRightLeft);
    SDL_assert_release(layerSinUpDownAlternate);
    SDL_assert_release(layerSinUpDownWeak);
    SDL_assert_release(layerSinUpDownWeakAlt);
    SDL_assert_release(layerSinRightLeftAlternate);

    // The player has touched the ground, trigger the fail sequence
    if(demo->Slippy && secretExitFailedStage == 0)
    {
        secretExitFailedStage = 1;
        layerSecretExit -> SpeedY = -0.4_nf;
    }

    //different movements to create the dropping off the world effect
    switch(secretExitFailedStage)
    {
    case 0:
        layerSecretExit -> SpeedY = 0;
        break;

    case 1:
        layerSecretExit -> SpeedY -= 0.2_nf;

        if(layerSecretExit -> SpeedY < -4)
            secretExitFailedStage = 2;
        break;

    case 2:
        layerSecretExit -> SpeedY += 0.4_nf;

        if(layerSecretExit -> SpeedY > -2.5_nf)
            secretExitFailedStage = 3;
        break;

    case 3:
        layerSecretExit -> SpeedY += 1.5_nf;

        if(layerSecretExit -> SpeedY > 50)
            secretExitFailedStage = 4;
        break;

    case 4:
        layerSecretExit -> SpeedY = 0;
        secretExitFailedStage = 5;
        break;

    default:
        break;
    }

    //Up Down sine wave motion
    if(layerSinUpDown -> SpeedY == 0)
    {
        secretExitFailedStage = 0;

        layerSinRightLeft_displacement = 0;
        layerSinRightLeft -> SpeedX = 3;

        layerSinUpDown_displacement = 0;
        layerSinUpDown -> SpeedY = 3;
    }

    layerSinUpDown -> SpeedY -= (numf_t)layerSinUpDown_displacement / 1000;
    layerSinUpDown_displacement += (num_t)layerSinUpDown -> SpeedY;

    layerSinUpDownAlternate -> SpeedY = -(layerSinUpDown -> SpeedY);
    layerSinUpDownWeak -> SpeedY = (layerSinUpDown -> SpeedY) / 3;
    layerSinUpDownWeakAlt -> SpeedY = -(layerSinUpDown -> SpeedY) / 3;

    //stop the initial trigger going off again
    if(layerSinUpDown -> SpeedY == 0)
        layerSinUpDown -> SpeedY = 0.001_nf;

    //Right Left sine wave motion
    layerSinRightLeft -> SpeedX -= (numf_t)layerSinRightLeft_displacement / 2000;
    layerSinRightLeft_displacement += (num_t)layerSinRightLeft -> SpeedX;
    layerSinRightLeftAlternate -> SpeedX = -(layerSinRightLeft -> SpeedX);
}


================================================
FILE: src/script/luna/levels/Docopoper-TheFloorisLava.h
================================================
extern void TheFloorisLavaInit();
extern void TheFloorisLavaCode();


================================================
FILE: src/script/luna/levels/KilArmoryCode.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/**************************************************
 *  Episode:    MAGL X2 ?????                     *
 *  Level:      Thou starts a new video           *
 *  Filename:   LUNA12-thou_starts_a_new_video.lvl*
 *  Author:     ??????                            *
 **************************************************/

#include "KilArmoryCode.h"
#include "globals.h"
#include "../lunaplayer.h"
#include "../lunainput.h"
#include "../lunarender.h"
#include "../renderop_effect.h"
#include "../autocode_manager.h"


void KilArmoryInit()
{
    auto *demo = PlayerF::Get(1);
    if(demo)
    {
        PlayerF::FilterToBig(demo);
        PlayerF::FilterMount(demo);
        PlayerF::FilterReservePowerup(demo);
        demo->Character = 1;
    }
}

void KilArmoryCode()
{
    Player_t *demo = PlayerF::Get(1);

    if(demo)
    {
        // Section 20(19) glow effect code
        if(gFrames > 60 && demo->Section == 19)
        {
            int intensity = (int)(num_t::sin((num_t)(gFrames) / 22) * 35) + 60;
            intensity <<= 16;
            auto *op = new RenderEffectOp(RNDEFF_ScreenGlow, BLEND_Additive, intensity, 100);
            op->m_FramesLeft = 1;
            Renderer::Get().AddOp(op);
        }

        // Section 1(0) glow effect code
        if(gFrames > 60 && demo->Section == 0 && gAutoMan.GetVar("GOTSANGRE") == 0)
        {
            int intensity = (int)(num_t::sin((num_t)(gFrames) / 10) * 45) + 48;
            intensity <<= 16;
            auto *op = new RenderEffectOp(RNDEFF_ScreenGlow, BLEND_Additive, intensity, 100);
            op->m_FramesLeft = 1;
            Renderer::Get().AddOp(op);
        }
    }
}



================================================
FILE: src/script/luna/levels/KilArmoryCode.h
================================================
extern void KilArmoryInit();
extern void KilArmoryCode();


================================================
FILE: src/script/luna/levels/README.txt
================================================
There are level specific custom levels made by Talkhaus members.

Most of these codes targeted to work at the "A Second Mario Bros. Thing,
Episode 1: Analog Funk" game, with an except for "KilArmoryCode.cpp" targeted
probably for MAGL X2 or something also (absolutely no idea for which thing this
code is).

These codes was originally created as a part of LunaDLL which initially had no
scripting language at all, except for LunaDLL Autocode simple language that
wasn't enough to make the complex logic.


================================================
FILE: src/script/luna/levels/SAJewers-QraestoliaCaverns.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/*************************************************
 *  Episode:    A2MBXT, Episode 1: Analog Funk   *
 *  Level:      Qraestolia Caverns               *
 *  Filename:   SAJewers-QraestoliaCaverns.lvl   *
 *  Author:     SAJewers                         *
 *************************************************/

#include "SAJewers-QraestoliaCaverns.h"
#include "globals.h"
#include "../lunaplayer.h"
#include "../lunainput.h"


void QraestoliaCavernsCode()
{
    static int lastDownPress = 0;
    Player_t *demo = PlayerF::Get(1);

    if(!demo)
        return;

    // Player pressed down, what do we do?
    if(PlayerF::PressingDown(demo))
    {
        // Else, see if pressed down in the last 7 frames
        if(gFrames < lastDownPress + 10 && gFrames > lastDownPress + 1)
        {
            if(demo->Character == 2 && demo->MountType != 0)
                PlayerF::CycleLeft(demo);
            else
                PlayerF::CycleRight(demo);

            lastDownPress = gFrames - 9;
            return;
        }

        // Else, set last press frame as this one
        lastDownPress = gFrames;
    }
}


================================================
FILE: src/script/luna/levels/SAJewers-QraestoliaCaverns.h
================================================
extern void QraestoliaCavernsCode();

================================================
FILE: src/script/luna/levels/SAJewers-Snowboardin.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/*************************************************
 *  Episode:    A2MBXT, Episode 1: Analog Funk   *
 *  Level:      Snowboardin'                     *
 *  Filename:   SAJewers-Snowboardin.lvl         *
 *  Author:     SAJewers                         *
 *************************************************/

#include "globals.h"
#include "SAJewers-Snowboardin.h"
#include "../lunanpc.h"

#define NPCID_SHELL 195

namespace SAJSnowbordin
{

NPC_t *FindNPC(short identity);
int combo_start;

void SnowbordinInitCode()
{
    combo_start = 0;
}

void SnowbordinCode()
{
    NPC_t *shell_npc = FindNPC(NPCID_SHELL);

    if(!shell_npc)
        return;

    uint8_t &shell_kills = shell_npc->Multiplier;

    if(shell_kills >= 9)
    {
        if(combo_start < 6)
            combo_start += 2;
        shell_kills = combo_start;
    }

    //Renderer::Get().SafePrint(std::wstring(L"KILLS: " + std::to_wstring(*shell_kills)), 3, 0, 256);
}

NPC_t *FindNPC(short identity)
{
    NPC_t *currentnpc = nullptr;

    for(int i = 0; i < numNPCs; i++)
    {
        currentnpc = NpcF::Get(i);
        if(currentnpc && currentnpc->Type == identity)
            return currentnpc;
    }

    return nullptr;
}

} // SAJSnowbordin


================================================
FILE: src/script/luna/levels/SAJewers-Snowboardin.h
================================================
namespace SAJSnowbordin
{
extern void SnowbordinInitCode();
extern void SnowbordinCode();
}

================================================
FILE: src/script/luna/levels/Talkhaus-Science_Final_Battle.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

/**************************************************
 *  Episode:    A2MBXT, Episode 1: Analog Funk    *
 *  Level:      A Final Thing (Name Pending)      *
 *  Filename:   Talkhaus-Science_Final_Battle.lvl *
 *  Authors:    Septentrion_Pleiades, Docopoper,  *
 *              SAJewers, Sturgyman, Demolition   *
 **************************************************/

#include <vector>

#include "sdl_proxy/sdl_assert.h"
#include "sdl_proxy/sdl_stdinc.h"

#include "Talkhaus-Science_Final_Battle.h"
#include "globals.h"
#include "main/trees.h"
#include "../lunanpc.h"
#include "../lunaplayer.h"


#define NPCID_FIRE_CHAIN 260
#define NPCID_DOUGHNUT 210
#define NPCID_SCIENCE 209

namespace ScienceBattle
{

static NPC_t *FindNPC(short identity);
static std::vector<NPC_t *> FindAllNPC(short identity);
static bool TriggerBox(num_t x1, num_t y1, num_t x2, num_t y2);
static void HurtPlayer();

static bool init_doonce;
static NPC_t *hurt_npc; //, *science_npc, *friendly_doughnut;
static std::vector<NPC_t *> doughnuts;
static Player_t *demo;
static int hurt_timer;
static int grace_timer;
static int throw_timer;

void ScienceInitCode()
{
    init_doonce = false;
}

void ScienceCode()
{
    if(!init_doonce)
    {
        init_doonce     = true;
        hurt_timer      = 0;
        throw_timer     = 0;
        demo            = PlayerF::Get(1);
        SDL_assert_release(demo);
    }

    hurt_npc = FindNPC(NPCID_FIRE_CHAIN);

    if(!hurt_npc)
        return;


    if(hurt_timer <= 0)
        hurt_npc->Location.Y = demo->Location.Y - 128;
    else
    {
        hurt_timer--;
        hurt_npc ->Location.Y = demo->Location.Y;
    }

    hurt_npc->Location.X = demo->Location.X;
    treeNPCUpdate(hurt_npc);

    doughnuts = FindAllNPC(NPCID_DOUGHNUT);

    if(demo->HoldingNPC > 0)
        throw_timer = 30;

    //Renderer::Get().SafePrint(std::wstring(L"ID: " + std::to_wstring(demo->HeldNPCIndex)), 3, 0, 256);


    if(grace_timer >= 0)
    {
        for(auto doughnut : doughnuts)
        {
            num_t x_diff, y_diff, m;

            x_diff = doughnut->Location.X - demo->Location.X;
            y_diff = doughnut->Location.Y - demo->Location.Y;
            m = num_t::dist(x_diff, y_diff);

            if(m == 0)
                continue;

            x_diff = x_diff.divided_by(m);
            y_diff = y_diff.divided_by(m);

            doughnut->Location.X += x_diff * 15;
            doughnut->Location.Y += y_diff * 15;
            treeNPCUpdate(doughnut);
        }
        grace_timer--;
    }
    else
    {
        if(throw_timer <= 0)
        {
            for(auto doughnut : doughnuts)
            {
                //Ignore generators
                if(doughnut->Hidden) // if((*((int *)doughnut + 16)) != 0)
                    continue;
                // Explanation why "Hidden":
                //   1) pointer turned into int* format
                //   2) +16 made an offset with 16 steps of int, i.e. 4 bytes. So, offset is 4x16 = 64
                //   3) at 64 (0x40) position, the "Hidden" field, not "generator"

                num_t x1, x2, y1, y2;

                x1 = doughnut->Location.X + 28 * 0.42_n;
                y1 = doughnut->Location.Y + 32 * 0.42_n;
                x2 = doughnut->Location.X + 28 * 0.57_n;
                y2 = doughnut->Location.Y + 32 * 0.57_n;

                if(TriggerBox(x1, y1, x2, y2))
                    HurtPlayer();
            }
        }
    }


    if(throw_timer > 0)
        throw_timer--;
}

static NPC_t *FindNPC(short identity)
{
    NPC_t *currentnpc = nullptr;

    for(int i = 0; i < numNPCs; i++)
    {
        currentnpc = NpcF::Get(i);
        if(currentnpc && currentnpc->Type == identity)
            return currentnpc;
    }

    return nullptr;
}

static std::vector<NPC_t *> FindAllNPC(short identity)
{
    std::vector<NPC_t *> npcs_found = std::vector<NPC_t *>();
    NPC_t *currentnpc = nullptr;

    for(int i = 0; i < numNPCs; i++)
    {
        currentnpc = NpcF::Get(i);
        if(currentnpc && currentnpc->Type == identity)
            npcs_found.push_back(currentnpc);
    }

    return npcs_found;
}

static void HurtPlayer()
{
    hurt_timer = 3;
    grace_timer = 120;
}

static bool TriggerBox(num_t x1, num_t y1, num_t x2, num_t y2)
{
    return (demo->Location.X + demo->Location.Width     > x1 &&
            demo->Location.X                            < x2 &&
            demo->Location.Y + demo->Location.Height    > y1 &&
            demo->Location.Y                            < y2);
}

} // ScienceBattle


================================================
FILE: src/script/luna/levels/Talkhaus-Science_Final_Battle.h
================================================
namespace ScienceBattle
{
extern void ScienceInitCode();
extern void ScienceCode();
}

================================================
FILE: src/script/luna/luna.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#include "luna.h"
#include "autocode.h"
#include "autocode_manager.h"
#include "lunainput.h"
#include "lunarender.h"
#include "lunaspriteman.h"
#include "lunaplayer.h"
#include "lunacounter.h"
#include "lunalevels.h"
#include "lunavarbank.h"
#include "config.h"

#include "globals.h"


SDL_FORCE_INLINE bool lunaAllowed()
{
    return g_config.luna_enable_engine;
}

void lunaReset()
{
    lunaLevelsClear();

    gFrames = 0;

    gLastDownPress = 0;
    gDownTapped = 0;
    gLastUpPress = 0;
    gUpTapped = 0;
    gLastLeftPress = 0;
    gLeftTapped = 0;
    gLastRightPress = 0;
    gRightTapped = 0;

    gLastJumpPress = 0;
    gJumpTapped = 0;
    gLastRunPress = 0;
    gRunTapped = 0;

    gEnableDemoCounterByLC = false;
    gSMBXHUDSettings = SMBXHUDSettings();

    gAutoMan.Clear();
    Renderer::Get().ClearAllDebugMessages();
    Renderer::Get().ClearAllLoadedImages();
    Renderer::Get().ClearQueue();
    gSpriteMan.ResetSpriteManager();
    Input::ResetAll();

    gDeathCounter.quit();
}

void lunaLoad()
{
    lunaReset();

    bool isGame = !GameMenu && !GameOutro && !BattleMode && !LevelEditor && !TestLevel;
    bool dcAllow = g_config.enable_fails_tracking;

    if(dcAllow && isGame)
        gDeathCounter.init();

    if(!LevelEditor && g_config.luna_enable_engine && lunaAllowed())
    {
        // Load autocode
        gAutoMan.LoadFiles();

        // Init var bank
        gSavedVarBank.CopyBank(&gAutoMan.m_UserVars);

        // Init some stuff
        if(g_config.luna_allow_level_codes)
            lunaLevelsInit();
        gAutoMan.m_Hearts = 2;
    }

    if(dcAllow && isGame)
        gDeathCounter.Recount();
}

void lunaLoop()
{
    if(g_config.luna_enable_engine)
    {
        // Clean up
        gAutoMan.ClearExpired();

        // Update inputs
        Input::CheckSpecialCheats();
        Input::UpdateInputTasks();
    }

    if(!LevelEditor && g_config.luna_enable_engine && lunaAllowed())
    {
#if COMPILE_PLAYGROUND
        Playground::doPlaygroundStuff();
#endif
//        g_EventHandler.hookLevelLoop();

        Renderer::Get().StartRenderLogic();

        // Run autocode
        gAutoMan.DoEvents(false);

        // Update some stuff
        gFrames++;
        gSavedVarBank.SaveIfNeeded();

        // Run any framecode
//        TestFrameCode();
        if(g_config.luna_allow_level_codes)
            lunaLevelsDo();

        Renderer::Get().EndRenderLogic();
    }
}


void lunaRenderHud(int screenZ)
{
    bool dcAllow = g_config.enable_fails_tracking || gEnableDemoCounterByLC;
    if(dcAllow && g_config.show_fails_counter && ShowOnScreenHUD)
        gDeathCounter.Draw(screenZ);

    Renderer::Get().RenderBelowPriority(PLANE_INTERNAL_FG);
}

void lunaRender(int screenZ)
{
    if(!LevelEditor && g_config.luna_enable_engine && lunaAllowed())
    {
        Renderer::Get().StartCameraRender(screenZ);
        gSpriteMan.RunSprites();
        Renderer::Get().RenderBelowPriority((PLANE)(PLANE_LVL_SECTION_FG + 4));
    }
}

void lunaRenderStart()
{
    if(!LevelEditor && g_config.luna_enable_engine && lunaAllowed())
        Renderer::Get().StartFrameRender();
}

void lunaRenderEnd()
{
    if(!LevelEditor && g_config.luna_enable_engine && lunaAllowed())
        Renderer::Get().EndFrameRender();
}


================================================
FILE: src/script/luna/luna.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNA_H
#define LUNA_H

#include <string>

struct SMBXHUDSettings
{
    bool              skip = false; // Skip the whole HUD drawing
    // WORLD_HUD_CONTROL overworldHudState;
    // bool              skipStarCount;
};

extern SMBXHUDSettings gSMBXHUDSettings;

//! Enable Demos counter locally by LunaControl command
extern bool gEnableDemoCounterByLC;

extern void lunaReset();
extern void lunaLoad();
extern void lunaLoop();
extern void lunaRenderStart();
extern void lunaRenderHud(int screenZ);
extern void lunaRender(int screenZ);
extern void lunaRenderEnd();

#endif // LUNA_H


================================================
FILE: src/script/luna/lunablock.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunablock.h"
#include "collision.h"

#include "main/trees.h"

#include "graphics/gfx_update.h" // invalidateDrawBlocks

Block_t *BlocksF::Get(int index)
{
    return &Block[index];
}

int BlocksF::TestCollision(Player_t *pMobPOS, Block_t *pBlockPOS)
{
    return FindCollision(pMobPOS->Location, pBlockPOS->Location);
}

void BlocksF::SetAll(int type1, int type2)
{
    for(int i = 1; i <= numBlock; i++)
    {
        if(Block[i].Type == type1)
            Block[i].Type = type2;
    }
}

void BlocksF::SwapAll(int type1, int type2)
{
    for(int i = 1; i <= numBlock; i++)
    {
        if(Block[i].Type == type1)
            Block[i].Type = type2;
        else if(Block[i].Type == type2)
            Block[i].Type = type1;
    }
}

void BlocksF::ShowAll(int type)
{
    bool any_change = false;

    for(int i = 1; i <= numBlock; i++)
    {
        if(Block[i].Type == type)
        {
            Block[i].Invis = false;
            any_change = true;
        }
    }

    if(any_change)
        invalidateDrawBlocks();
}

void BlocksF::HideAll(int type)
{
    bool any_change = false;

    for(int i = 1; i <= numBlock; i++)
    {
        if(Block[i].Type == type)
        {
            Block[i].Invis = true;
            any_change = true;
        }
    }

    if(any_change)
        invalidateDrawBlocks();
}

bool BlocksF::IsPlayerTouchingType(int type, int sought, Player_t *demo)
{
    //    Block* blocks = Blocks::GetBase();
    num_t playerX = demo->Location.X - 0.20_n;
    num_t playerY = demo->Location.Y - 0.20_n;
    num_t playerX2 = demo->Location.X + demo->Location.Width + 0.20_n;
    num_t playerY2 = demo->Location.Y + demo->Location.Height + 0.20_n;

    for(Block_t* block : treeFLBlockQuery(demo->Location, SORTMODE_NONE))
    {
        if(block->Type == type)
        {
            if(playerX > block->Location.X + block->Location.Width ||
               playerX2 < block->Location.X  ||
               playerY > block->Location.Y + block->Location.Height ||
               playerY2 < block->Location.Y)
                continue;

            int ret = TestCollision(demo, block);

            if(sought != 0 && ret == sought)
                return true;
            else if(sought == 0 && ret != 0)
                return false;
        }
    }

    return (sought == 0); // no collision
}


================================================
FILE: src/script/luna/lunablock.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNABLOCK_H
#define LUNABLOCK_H

#include "globals.h"

namespace BlocksF
{
Block_t* Get(int index);			// Get ptr to a block

int TestCollision(Player_t* pMobPOS, Block_t* pBlockPOS);

void SetAll(int type1, int type2);  // Set ID of all blocks of type 1 to type 2
void SwapAll(int type1, int type2); // Swap ID of all blocks of type 1 to type 2, and vice versa
void ShowAll(int type);				// Show all blocks of type
void HideAll(int type);				// Hide all blocks of type

bool IsPlayerTouchingType(int BlockType, int sought_collision, Player_t* pMobPOS); // See if player touching block of BlockType

}

#endif // LUNABLOCK_H


================================================
FILE: src/script/luna/lunacounter.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Utils/files.h>
#include <Logger/logger.h>
#include <fmt_format_ne.h>

#include "luna.h"
#include "lunacounter.h"
#include "lunacounter_util.h"
#include "lunaplayer.h"
#include "lunarender.h"
#include "renderop_string.h"
#include "globals.h"
#include "config.h"
#include "graphics.h"
#include "config.h"
#include "game_main.h"
#include "core/render.h"
#include "main/game_info.h"
#include "main/menu_main.h"


DeathCounter gDeathCounter;

// CTOR
DeathCounter::DeathCounter() noexcept
{
    mStatFileOK = false;
    mEnabled = false;
    mCurTotalDeaths = 0;
    mCurLevelDeaths = 0;

    // Print Demos counter with a font 3
    m_print.font = 3;
}

DeathCounter::~DeathCounter() noexcept
{
    if(m_openFile)
        SDL_RWclose(m_openFile);
}

void DeathCounter::init()
{
    if(counterFile.empty())
    {
        // prevent a segfault
        if(TestLevel || selWorld < 0 || selWorld >= (int)SelectWorld.size() || BattleMode || LevelEditor || selSave <= 0)
        {
            mEnabled = false;
            return;
        }

        std::string oldFile = makeGameSavePath(SelectWorld[selWorld].WorldFilePath,
                                               fmt::format_ne("demos-{0}.dmo", selSave));

        std::string oldFile2 = makeGameSavePath(SelectWorld[selWorld].WorldFilePath,
                                               fmt::format_ne("deaths-{0}.rip", selSave));

        counterFile = makeGameSavePath(SelectWorld[selWorld].WorldFilePath,
                                       fmt::format_ne("fails-{0}.rip", selSave));

        if(Files::fileExists(oldFile)) // Rename old file ino the new name
            Files::moveFile(counterFile, oldFile);
        else if(Files::fileExists(oldFile2)) // Rename old file ino the new name
            Files::moveFile(counterFile, oldFile2);

        if(!TryLoadStats())
            mEnabled = false;
    }
}

void DeathCounter::quit()
{
    counterFile.clear();
    mStatFileOK = false;
    mEnabled = false;
    mCurTotalDeaths = 0;
    mCurLevelDeaths = 0;
    mDeathRecords.clear();

    if(m_openFile)
    {
        SDL_RWclose(m_openFile);
        m_openFile = nullptr;
    }
}

// TRY LOAD STATS - Attempts to load stats from stats file. Creates and inits the file if it doesn't exist.
bool DeathCounter::TryLoadStats()
{
    // Try to open the file
    int32_t tempint = 0;
    size_t got;

    // If file is not exist yet, try to create empty file
    if(!Files::fileExists(counterFile))
    {
        SDL_RWops *statsfile = Files::open_file(counterFile, "wb");
        if(!statsfile)
        {
            mStatFileOK = false;
            mEnabled = false;
            pLogWarning("Unable to initialize Demos counter: %s", counterFile.c_str());
            return false;
        }

        SDL_RWwrite(statsfile, &tempint, 1, sizeof(int));
        SDL_RWclose(statsfile);
    }

    // close old open file if present
    if(m_openFile)
    {
        SDL_RWclose(m_openFile);
        m_openFile = nullptr;
    }

    m_openFile = Files::open_file(counterFile, "r+b");

    // If create failed, disable death counter
    if(!m_openFile)
    {
        pLogWarning("Unable to open the Demos counter: %s", counterFile.c_str());
        mStatFileOK = false;
        mEnabled = false;
        return false;
    }

    // If size less than 100, init new file
    int cursize = (int)SDL_RWsize(m_openFile);

    if(cursize < 50)
    {
        InitStatsFile(m_openFile);
        Files::flush_file(m_openFile);
        mStatFileOK = true;
        SDL_RWseek(m_openFile, 0, SEEK_SET);
    }

//    if(statsfile.good() == false)
//    {
//        mStatFileOK = false;
//        mEnabled = false;
//        return false;
//    }

    // Check version
    got = LunaCounterUtil::readIntLE(m_openFile, tempint);
    if(got != sizeof(int32_t) || tempint < 5)
    {
        if(got != sizeof(int32_t))
            pLogWarning("Fails counter: Failed to read version number at the %s file", counterFile.c_str());

        mStatFileOK = false;
        mEnabled = false;

        SDL_RWclose(m_openFile);
        m_openFile = nullptr;

        return false;
    }

    mStatFileOK = true;
    mEnabled = true;

    ClearRecords();
    ReadRecords(m_openFile);

    return true;
}

// mark that a death occurred in the current level
void DeathCounter::MarkDeath(bool write_save)
{
    bool dcAllow = (gEnableDemoCounterByLC || g_config.enable_fails_tracking);

    if(!dcAllow)
        return;

    AddDeath(FileNameFull, 1);

    if(write_save)
    {
        TrySave();
        Recount();
    }
}

// ADD DEATH
void DeathCounter::AddDeath(const std::string &lvlname, int amount)
{
    if(!mEnabled)
        return;

    for(auto &iter : mDeathRecords)
    {
        if(iter.m_levelName == lvlname)   // On first name match...
        {
            iter.m_deaths += amount;      // Inc death count
            return;                        // and exit
        }
    }

    // if no match, create new death record and add it to list
    DeathRecord newrec;
    newrec.m_levelName = lvlname;
    newrec.m_deaths = amount;
    mDeathRecords.push_back(newrec);
}

// INIT STATS FILE
void DeathCounter::InitStatsFile(SDL_RWops *statsfile)
{
    WriteHeader(statsfile);
}


// WRITE HEADER - Write the death counter file header at beginning of file
void DeathCounter::WriteHeader(SDL_RWops *statsfile)
{
    // Write dll version
    SDL_RWseek(statsfile, 0, RW_SEEK_SET);
    LunaCounterUtil::writeIntLE(statsfile, LUNA_VERSION);

    // Init reserved
    uint8_t writebyte = 0;
    off_t offset = SDL_RWtell(statsfile);
    while(offset < 100)
    {
        SDL_RWwrite(statsfile, &writebyte, 1, sizeof(writebyte));
        offset = SDL_RWtell(statsfile);
    }

    // Write record count at 100 bytes (0 record count)
    LunaCounterUtil::writeIntLE(statsfile, 0);
}

// READ RECORDS - Add death records from file into death record list
void DeathCounter::ReadRecords(SDL_RWops *statsfile)
{
    int32_t tempint = 0;
    size_t got;

    // Read the record count at 100 bytes
    SDL_RWseek(statsfile, 100, RW_SEEK_SET);
    got = LunaCounterUtil::readIntLE(statsfile, tempint);

    if(got != sizeof(tempint))
    {
        pLogWarning("Fails counter: Failed to read the number of records");
        return;
    }

    if(tempint == 0)
        return;

    for(int i = 0; i < tempint; i++)
    {
        DeathRecord newrec;
        if(newrec.Load(statsfile))
            mDeathRecords.push_back(newrec);
    }
}


// WRITE RECORDS - Writes death record count at pos 100 in the file followed by each record
void DeathCounter::WriteRecords(SDL_RWops *statsfile)
{
    int32_t reccount = (int32_t)mDeathRecords.size();
    SDL_RWseek(statsfile, 100, RW_SEEK_SET);
    LunaCounterUtil::writeIntLE(statsfile, reccount);

    // Write each record, if any exist
    if(!mDeathRecords.empty())
    {
        for(auto &mDeathRecord : mDeathRecords)
            mDeathRecord.Save(statsfile);
    }
}

// TRY SAVE - Externally callable, safe auto-save function
void DeathCounter::TrySave()
{
    if(mStatFileOK && mEnabled && m_openFile)
    {
        if(SDL_RWseek(m_openFile, 0, RW_SEEK_SET))
        {
            // attempt to reopen the file
            SDL_RWclose(m_openFile);
            m_openFile = Files::open_file(counterFile, "wb");
        }

        if(m_openFile)
        {
            Save(m_openFile);
            Files::flush_file(m_openFile);
        }
    }
}

// SAVE
void DeathCounter::Save(SDL_RWops *statsfile)
{
    if(mStatFileOK && mEnabled)
    {
        WriteHeader(statsfile);
        WriteRecords(statsfile);
    }
}


// CLEAR RECORDS - Clear the death record list and dealloc its records
void DeathCounter::ClearRecords()
{
    mDeathRecords.clear();
}

// RECOUNT - Recount and relist the death count for the current level and the total deathcount
void DeathCounter::Recount()
{
    if(!mEnabled)
        return;

    int total = 0;
    mCurLevelDeaths = 0;

    for(const auto &iter : mDeathRecords)
    {
        total += iter.m_deaths;
        if(iter.m_levelName == FileNameFull)
            mCurLevelDeaths = iter.m_deaths;
    }

    mCurTotalDeaths = total;

}

// DRAW - Print the death counter in its current state
void DeathCounter::Draw(int screenZ)
{
    if(!mEnabled)
        return;

    // Format string to print
    m_print.syncCache(mCurLevelDeaths, mCurTotalDeaths);
    m_print.syncCache(g_gameInfo.fails_counter_title);

    const vScreen_t& vscreen = vScreen[screenZ];
    const Screen_t& screen = Screens[vscreen.screen_ref];

    // HUD is very wide in >2P shared screen
    bool wide_hud = (screen.Type == ScreenTypes::SharedScreen && screen.player_count > 2);

    int ScreenTop = 0;
    if(vscreen.Height > 600)
        ScreenTop = vscreen.Height / 2 - 300;
    int HUDLeft = vscreen.Width / 2 - 400;

    // With normal res, print to screen in upper left
    if(vscreen.Width >= 800 && !wide_hud)
    {
        int title_X   = 123 - m_print.titlePixLen / 2;
        int counter_X = 123 - m_print.counterPixLen / 2;

        // make even
        title_X &= ~1;
        counter_X &= ~1;

        SuperPrint(g_gameInfo.fails_counter_title, m_print.font, HUDLeft + title_X, ScreenTop + 26);
        SuperPrint(m_print.counterOut, m_print.font, HUDLeft + counter_X, ScreenTop + 48);
    }
    // At low res, print to top of screen
    else
    {
        int total_W = m_print.titlePixLen + 16 + m_print.counterPixLen;
        int title_X = vscreen.Width / 2 - total_W / 2;

        if(vscreen.Width < 640)
            title_X -= 64;

        int counter_X = title_X + m_print.titlePixLen + 16;

        // make even
        title_X &= ~1;
        counter_X &= ~1;

        SuperPrint(g_gameInfo.fails_counter_title, m_print.font, title_X, ScreenTop);
        SuperPrint(m_print.counterOut, m_print.font, counter_X, ScreenTop);
    }
}

void DeathCounter::CachedPrint::syncCache(int curLevel, int total)
{
    if(curLevel != counterLevel || total != counterTotal)
    {
        counterLevel = curLevel;
        counterTotal = total;
        counterOut = fmt::format_ne("{0} / {1}", curLevel, total);
        counterPixLen = SuperTextPixLen(counterOut.c_str(), font);
    }
}

void DeathCounter::CachedPrint::syncCache(const std::string &title)
{
    intptr_t ptr = reinterpret_cast<intptr_t>(title.c_str());

    if(titlePointer != ptr || titleSize != title.size())
    {
        titlePointer = ptr;
        titleSize = title.size();
        titlePixLen = SuperTextPixLen(title.c_str(), font);
    }
}


================================================
FILE: src/script/luna/lunacounter.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef DEATHCOUNTER_H
#define DEATHCOUNTER_H

#include <string>
#include <list>

#include "lunacounter_record.h"

#define DEATHCT_FNAME "demos.dmo"

struct SDL_RWops;

struct DeathCounter
{
    DeathCounter() noexcept;
    ~DeathCounter() noexcept;

    void init();
    void quit();

    bool TryLoadStats();
    // Marks a death on the current level
    void MarkDeath(bool write_save = true);
    void AddDeath(const std::string &, int amount);
    void TrySave();
    void Draw(int screenZ);
    void Recount();
    void ClearRecords();

    struct CachedPrint
    {
        // Cache meta-data for counter
        void syncCache(int curLevel, int total);
        int counterLevel = -1;
        int counterTotal = -1;
        int counterPixLen = 0;
        int font = -1;
        std::string counterOut;

        // Cache meta-data for title
        void syncCache(const std::string &title);
        int titlePixLen = 0;
        intptr_t titlePointer = 0;
        size_t titleSize = std::string::npos;
    } m_print;

private:
    SDL_RWops* m_openFile = nullptr;

    friend struct DeathRecord;
    static void InitStatsFile(SDL_RWops *openfile);
    static void WriteHeader(SDL_RWops *openfile);
    void WriteRecords(SDL_RWops *statsfile);
    void ReadRecords(SDL_RWops *openfile);
    void Save(SDL_RWops *openfile);

    // Members
public:
    bool mStatFileOK = false;
    bool mEnabled = false;

    int mCurTotalDeaths = 0;
    int mCurLevelDeaths = 0;

    std::list<DeathRecord> mDeathRecords;

    std::string counterFile;
};

extern DeathCounter	gDeathCounter;

#endif // DEATHCOUNTER_H


================================================
FILE: src/script/luna/lunacounter_record.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunacounter_record.h"
#include "lunacounter_util.h"
#include <Logger/logger.h>

#include "sdl_proxy/sdl_stdinc.h"


void DeathRecord::Save(SDL_RWops *openfile)
{
    // Write character count
    auto tempint = (uint32_t)m_levelName.size();
    LunaCounterUtil::writeUIntLE(openfile, tempint);

    // Write string data
    int16_t nullt = 0;
    SDL_RWwrite(openfile, m_levelName.data(), 1, tempint);
    SDL_RWwrite(openfile, &nullt, 1, sizeof(int16_t));

    // Write death count
    LunaCounterUtil::writeIntLE(openfile, m_deaths);
}

bool DeathRecord::Load(SDL_RWops *openfile)
{
    size_t got;
    char buf[151];
    SDL_memset(buf, 0, 151);

    // Read string length
    uint32_t length;
    uint32_t skip = 0;

    got = LunaCounterUtil::readUIntLE(openfile, length);
    if(got != sizeof(uint32_t))
    {
        pLogWarning("Demos counter Record: Failed to read the length of the level name");
        return false;
    }

    if(length > 150)
    {
        skip = length - 150;
        length = 150;
    }

    // Read string data
    got = SDL_RWread(openfile, buf, 1, length);
    if(got != length)
    {
        pLogWarning("Demos counter Record: Failed to read the level name");
        return false;
    }

    if(skip > 0)
        SDL_RWseek(openfile, skip, RW_SEEK_CUR);

    m_levelName = std::string(buf);
    SDL_RWseek(openfile, 2, RW_SEEK_CUR);

    // Read death count
    got = LunaCounterUtil::readIntLE(openfile, m_deaths);
    if(got != sizeof(int32_t))
    {
        pLogWarning("Demos counter Record: Failed to read the counter value");
        return false;
    }

    return true;
}


================================================
FILE: src/script/luna/lunacounter_record.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef DEATHRECORD_H
#define DEATHRECORD_H

#include <cstdint>
#include <cstdio>
#include <string>
#include <SDL2/SDL_rwops.h>

struct DeathRecord
{
    void Save(SDL_RWops *openfile);
    bool Load(SDL_RWops *openfile);

    std::string m_levelName;
    int32_t m_deaths = 0;
};

#endif // DEATHRECORD_H


================================================
FILE: src/script/luna/lunacounter_util.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNACOUNTER_UTIL_H
#define LUNACOUNTER_UTIL_H

#include <cstdio>
#include <cstdint>


namespace LunaCounterUtil
{

inline size_t writeIntLE(SDL_RWops *openfile, int32_t inValue)
{
    uint8_t out[4];
    out[0] = 0xFF & (static_cast<uint32_t>(inValue) >> 0);
    out[1] = 0xFF & (static_cast<uint32_t>(inValue) >> 8);
    out[2] = 0xFF & (static_cast<uint32_t>(inValue) >> 16);
    out[3] = 0xFF & (static_cast<uint32_t>(inValue) >> 24);
    return SDL_RWwrite(openfile, out, 1, 4);
}

inline size_t readIntLE(SDL_RWops *openfile, int32_t &outValue)
{
    uint8_t in[4];
    size_t ret = SDL_RWread(openfile, in, 1, 4);

    if(ret != 4)
        return ret;

    outValue = (int32_t)
               ((static_cast<uint32_t>(in[0]) << 0) & 0x000000FF)
             | ((static_cast<uint32_t>(in[1]) << 8) & 0x0000FF00)
             | ((static_cast<uint32_t>(in[2]) << 16) & 0x00FF0000)
             | ((static_cast<uint32_t>(in[3]) << 24) & 0xFF000000);

    return ret;
}

inline size_t writeUIntLE(SDL_RWops *openfile, uint32_t inValue)
{
    uint8_t out[4];
    out[0] = 0xFF & (inValue >> 0);
    out[1] = 0xFF & (inValue >> 8);
    out[2] = 0xFF & (inValue >> 16);
    out[3] = 0xFF & (inValue >> 24);
    return SDL_RWwrite(openfile, out, 1, 4);
}

inline size_t readUIntLE(SDL_RWops *openfile, uint32_t &outValue)
{
    uint8_t in[4];
    size_t ret = SDL_RWread(openfile, in, 1, 4);

    if(ret != 4)
        return ret;

    outValue = ((static_cast<uint32_t>(in[0]) << 0) & 0x000000FF)
             | ((static_cast<uint32_t>(in[1]) << 8) & 0x0000FF00)
             | ((static_cast<uint32_t>(in[2]) << 16) & 0x00FF0000)
             | ((static_cast<uint32_t>(in[3]) << 24) & 0xFF000000);

    return ret;
}

} // namespace


#endif // LUNACOUNTER_UTIL_H


================================================
FILE: src/script/luna/lunadefs.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNADEFS_H
#define LUNADEFS_H

#include "numeric_types.h"

#define LUNA_VERSION    9

enum FIELDTYPE
{
    FT_INVALID = 0,
    FT_BYTE = 1,
    FT_WORD = 2,
    FT_DWORD = 3,
    FT_FLOAT = 4,
    FT_DFLOAT = 5,

    FT_MAX = 5
};

enum OPTYPE
{
    OP_Assign = 0,
    OP_Add = 1,
    OP_Sub = 2,
    OP_Mult = 3,
    OP_Div = 4,
    OP_XOR = 5,
    OP_ABS = 6
};

enum COMPARETYPE
{
    CMPT_EQUALS = 0,
    CMPT_GREATER = 1,
    CMPT_LESS = 2,
    CMPT_NOTEQ = 3
};

enum DIRECTION
{
    DIR_UP = 1,
    DIR_RIGHT = 2,
    DIR_DOWN = 3,
    DIR_LEFT = 4
};

enum PRIORITY
{
    PRI_LOW = 0,
    PRI_MID,
    PRI_HIGH
};

enum WORLD_HUD_CONTROL
{
    WHUD_ALL,
    WHUD_ONLY_OVERLAY,
    WHUD_NONE
};

enum LEVEL_HUD_CONTROL
{
    LHUD_UNKNOWN1 // Only temporary
};

struct LunaRect
{
    int left = 0;
    int top = 0;
    int right = 0;
    int bottom = 0;
};

class LunaImage;
class CSprite;
struct CSpriteRequest;
struct SpriteComponent;

typedef void (*pfnSprFunc)(CSprite*, SpriteComponent* obj);
typedef void (*pfnSprDraw)(CSprite*);

#endif // LUNADEFS_H


================================================
FILE: src/script/luna/lunaglobals.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "luna.h"

SMBXHUDSettings gSMBXHUDSettings;

bool gEnableDemoCounterByLC = false;

/* Fallback dummy calls for the case when Luna Autocode has been disabled */

#ifndef THEXTECH_ENABLE_LUNA_AUTOCODE

void lunaReset()
{}

void lunaLoad()
{}

void lunaLoop()
{}

void lunaRenderStart()
{}

void lunaRenderHud()
{}

void lunaRender(int)
{}

void lunaRenderEnd()
{}

#endif


================================================
FILE: src/script/luna/lunaimgbox.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunaimgbox.h"
#include "core/render.h"
#include <Utils/files.h>

uint64_t LunaImage::p_uidCounter = 1;

uint64_t LunaImage::getNewUID()
{
    return p_uidCounter++;
}

LunaImage::LunaImage()
{
    Init();
}

LunaImage::~LunaImage()
{}

LunaImage::LunaImage(const std::string &filename)
{
    if(filename.empty())
        return;

    Init();

    XRender::lazyLoadPicture(m_image, filename);
    if(Files::hasSuffix(filename, ".jpg") || Files::hasSuffix(filename, ".bmp"))
    {
        m_useTransColor = true;
        XRender::setTransparentColor(m_image, m_TransColor);
    }

    m_uid = getNewUID();

    m_W = m_image.w;
    m_H = m_image.h;
}

LunaImage::LunaImage(LunaImage &&o)
{
    operator=(std::move(o));
}

LunaImage &LunaImage::operator=(LunaImage &&o)
{
    m_H = o.m_H;
    m_W = o.m_W;
    m_uid = o.m_uid;
    m_TransColor = o.m_TransColor;

    // clear current texture from renderer if it exists
    m_image.reset();

    // initialize load data from other texture
    static_cast<StdPicture_Sub&>(m_image) = std::move(static_cast<StdPicture_Sub&>(o.m_image));

    o.Unload();

    return *this;
}

void LunaImage::Init()
{
    m_W = 0;
    m_H = 0;
    m_uid = 0;
    m_TransColor = DEFAULT_TRANS_COLOR;
}

void LunaImage::Unload()
{
    m_image.reset();
    Init();
}

bool LunaImage::ImageLoaded()
{
    return m_image.inited;
}

void LunaImage::setTransparentColor(uint32_t rgb)
{
    m_TransColor = rgb;
    if(m_useTransColor)
        XRender::setTransparentColor(m_image, rgb);
}


================================================
FILE: src/script/luna/lunaimgbox.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNAIMGBOX_H
#define LUNAIMGBOX_H

#include <string>
#include "std_picture.h"

#define DEFAULT_TRANS_COLOR 0xFF00DC

// A user-loaded bitmap container
class LunaImage
{
    static uint64_t p_uidCounter;
    static uint64_t getNewUID();
    uint64_t m_uid = 0;

    //! Height of bitmap
    int m_H = 0;
    //! Width of bitmap
    int m_W = 0;
    //! Value that represents transparency (will write nothing)
    uint32_t m_TransColor = DEFAULT_TRANS_COLOR;
    bool     m_useTransColor = false;

public:
    /// Functions ///
    LunaImage();
    ~LunaImage();

    LunaImage(const std::string &filename);
    LunaImage(const LunaImage &o) = delete;
    LunaImage(LunaImage &&o);
    LunaImage &operator=(const LunaImage &o) = delete;
    LunaImage &operator=(LunaImage &&o);

    void Init();

    void Unload();

    bool ImageLoaded();

    void setTransparentColor(uint32_t rgb);

    inline uint64_t getUID() const
    {
        return m_uid;
    }

    inline int32_t getW() const
    {
        return m_W;
    }

    inline int32_t getH() const
    {
        return m_H;
    }



    //! Image handler
    StdPicture m_image;
};

#endif // LUNAIMGBOX_H


================================================
FILE: src/script/luna/lunainput.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include "luna.h"
#include "lunainput.h"
#include "lunaplayer.h"
#include "lunacounter.h"
#include "main/cheat_code.h"
#include "sound.h"
#include "autocode_manager.h"

int gFrames;

int gLastDownPress;
int gDownTapped;
int gLastUpPress;
int gUpTapped;
int gLastLeftPress;
int gLeftTapped;
int gLastRightPress;
int gRightTapped;

int gLastJumpPress;
int gJumpTapped;
int gLastRunPress;
int gRunTapped;


bool Input::PressingUp()
{
    return gLastUpPress == gFrames;
}

bool Input::PressingDown()
{
    return gLastDownPress == gFrames;
}

bool Input::PressingLeft()
{
    return gLastLeftPress == gFrames;
}

bool Input::PressingRight()
{
    return gLastRightPress == gFrames;
}

bool Input::PressingRun()
{
    return gLastRunPress == gFrames;
}

bool Input::PressingJump()
{
    return gLastJumpPress == gFrames;
}

bool Input::UpThisFrame()
{
    return gUpTapped != 0;
}

bool Input::DownThisFrame()
{
    return gDownTapped != 0;
}

bool Input::LeftThisFrame()
{
    return gLeftTapped != 0;
}

bool Input::RightThisFrame()
{
    return gRightTapped != 0;
}

bool Input::RunThisFrame()
{
    return gRunTapped != 0;
}

bool Input::JumpThisFrame()
{
    return gJumpTapped != 0;
}

void Input::UpdateKeyRecords(Player_t *pPlayer)
{
    if(!pPlayer)
        return;

    //wchar_t* dbg = L"Update keys debug";

    // Up
    if(PlayerF::PressingUp(pPlayer))
    {
        // If still holding from last frame
        if(gFrames - 1 == gLastUpPress)
            gLastUpPress = gFrames;
        else   //else set tapped this frame
        {
            gLastUpPress = gFrames;
            gUpTapped = gFrames;
        }
    }

    // Down
    if(PlayerF::PressingDown(pPlayer))
    {
        // If still holding from last frame
        if(gFrames - 1 == gLastDownPress)
            gLastDownPress = gFrames;
        else   //else set tapped this frame
        {
            gLastDownPress = gFrames;
            gDownTapped = gFrames;
        }
    }

    // Left
    if(PlayerF::PressingLeft(pPlayer))
    {
        // If still holding from last frame
        if(gFrames - 1 == gLastLeftPress)
            gLastLeftPress = gFrames;
        else   //else set tapped this frame
        {
            gLastLeftPress = gFrames;
            gLeftTapped = gFrames;
        }
    }

    // Right
    if(PlayerF::PressingRight(pPlayer))
    {
        // If still holding from last frame
        if(gFrames - 1 == gLastRightPress)
            gLastRightPress = gFrames;
        else   //else set tapped this frame
        {
            gLastRightPress = gFrames;
            gRightTapped = gFrames;
        }
    }

    // Jump
    if(PlayerF::PressingJump(pPlayer))
    {
        // If still holding from last frame
        if(gFrames - 1 == gLastJumpPress)
            gLastJumpPress = gFrames;
        else   //else set tapped this frame
        {
            gLastJumpPress = gFrames;
            gJumpTapped = gFrames;
        }
    }

    // Run
    if(PlayerF::PressingRun(pPlayer))
    {
        // If still holding from last frame
        if(gFrames - 1 == gLastRunPress)
            gLastRunPress = gFrames;
        else   //else set tapped this frame
        {
            gLastRunPress = gFrames;
            gRunTapped = gFrames;
        }
    }
}

static const std::string FULL_LUNA_TOGGLE_CHT    = "thouartdamned";
static const std::string TOGGLE_DEMO_COUNTER_CHT = "toggledemocounter";
static const std::string DELETE_ALL_RECORDS_CHT  = "formatcdrive";
static const std::string LUNA_DEBUG_CHT          = "lunadebug";
static const std::string LUNA_LONG_DEBUG_CHT     = "lunalongdebug";

void Input::CheckSpecialCheats()
{
    if(cheats_contains(FULL_LUNA_TOGGLE_CHT))
    {
        g_config.luna_enable_engine = !g_config.luna_enable_engine;
        PlaySound(SFX_Smash);
        cheats_clearBuffer();
        return;
    }

    else if(cheats_contains(LUNA_DEBUG_CHT) || cheats_contains(LUNA_LONG_DEBUG_CHT))
    {
        int length = cheats_contains(LUNA_LONG_DEBUG_CHT) ? 99999 : 600;
        // FIXME: Replace this with the boolean toggle than adding this command infinitely times
        gAutoMan.m_CustomCodes.emplace_back(AT_DebugPrint, 0, 0, 0, 0, STRINGINDEX_NONE, length, 0, STRINGINDEX_NONE);
        PlaySound(SFX_Stomp);
        cheats_clearBuffer();
        return;
    }

    if(g_config.enable_fails_tracking)
    {
        if(cheats_contains(TOGGLE_DEMO_COUNTER_CHT))
        {
            g_config.show_fails_counter = !g_config.show_fails_counter;
            PlaySound(SFX_Smash);
            cheats_clearBuffer();
            return;
        }
        else if(cheats_contains(DELETE_ALL_RECORDS_CHT))
        {
            gDeathCounter.ClearRecords();
            gDeathCounter.TrySave();
            gDeathCounter.Recount();
            PlaySound(SFX_Smash);
            cheats_clearBuffer();
            return;
        }
    }
}

void Input::UpdateInputTasks()
{
    //wchar_t* dbg = L"Input tasks debug";
    ResetTaps();
    UpdateKeyRecords(PlayerF::Get(1));
}

void Input::ResetTaps()
{
    gDownTapped = 0;
    gUpTapped = 0;
    gLeftTapped = 0;
    gRightTapped = 0;
    gRunTapped = 0;
    gJumpTapped = 0;
}

void Input::ResetAll()
{
    gLastDownPress = 0;
    gDownTapped = 0;
    gLastUpPress = 0;
    gUpTapped = 0;
    gLastLeftPress = 0;
    gLeftTapped = 0;
    gLastRightPress = 0;
    gRightTapped = 0;
    gLastJumpPress = 0;
    gJumpTapped = 0;
    gLastRunPress = 0;
    gRunTapped = 0;
}


================================================
FILE: src/script/luna/lunainput.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNAINPUT_H
#define LUNAINPUT_H

struct Player_t;

extern int gFrames;

extern int gLastDownPress;
extern int gDownTapped;
extern int gLastUpPress;
extern int gUpTapped;
extern int gLastLeftPress;
extern int gLeftTapped;
extern int gLastRightPress;
extern int gRightTapped;

extern int gLastJumpPress;
extern int gJumpTapped;
extern int gLastRunPress;
extern int gRunTapped;


namespace Input {

void CheckSpecialCheats();

void UpdateInputTasks();

void ResetTaps();
void ResetAll();
void UpdateKeyRecords(Player_t* player);

bool PressingUp();
bool PressingDown();
bool PressingLeft();
bool PressingRight();
bool PressingRun();
bool PressingJump();

bool UpThisFrame();
bool DownThisFrame();
bool LeftThisFrame();
bool RightThisFrame();
bool RunThisFrame();
bool JumpThisFrame();

}


#endif // LUNAINPUT_H


================================================
FILE: src/script/luna/lunalayer.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunalayer.h"
#include "layers.h"

Layer_t *LayerF::Get(int layerIdx)
{
    if(layerIdx < 0 || layerIdx >= numLayers)
        return nullptr;
    return &Layer[layerIdx];
}

void LayerF::Stop(Layer_t *layer)
{
    layer->EffectStop = false;
    layer->SpeedX = 0.0001_nf;
    layer->SpeedY = 0.0001_nf;

    // NOTE from ds-sloth: why non-zero? probably, to make sure all objects get updated.
    // It would be better to set all objects (Blocks, BGOs, NPCs) in layer to speed 0.
    // keep it this way to preserve compatibility with existing Autocode content.
}

void LayerF::SetYSpeed(Layer_t *layer, num_t setY)
{
    layer->SpeedY = (setY == 0 ?  0.0001_nf : (numf_t)setY);
    layer->EffectStop = true;
}

void LayerF::SetXSpeed(Layer_t *layer, num_t setX)
{
    layer->SpeedX = (setX == 0 ?  0.0001_nf : (numf_t)setX);
    layer->EffectStop = true;
}


================================================
FILE: src/script/luna/lunalayer.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNALAYER_H
#define LUNALAYER_H

#include "numeric_types.h"

struct Layer_t;

namespace LayerF
{

Layer_t *Get(int layerIdx);

// Stop a layer
void Stop(Layer_t *layer);

void SetYSpeed(Layer_t *layer, num_t setY);

void SetXSpeed(Layer_t *layer, num_t setX);

} // LayerF

#endif // LUNALAYER_H


================================================
FILE: src/script/luna/lunalevel.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunalevel.h"
#include "globals.h"

#include "npc/section_overlap.h"


void LevelF::PushSectionBoundary(int section, int which_boundary_UDLR, num_t push_val)
{
    SpeedlessLocation_t &boundarray = level[section];

    switch(which_boundary_UDLR)
    {
    case 0:     // U
        boundarray.Y += push_val;
        break;

    case 1:     // D
        boundarray.Height += push_val;
        break;

    case 2:     // L
        boundarray.X += push_val;
        break;

    case 3:     // R
        boundarray.Width += push_val;
        break;

    default:
        break;
    }

    UpdateSectionOverlaps(section);
}

void LevelF::SetSectionBounds(int section, num_t left_bound, num_t top_bound, num_t right_bound, num_t bot_bound)
{
    SpeedlessLocation_t &boundarray = level[section];
    boundarray.X = left_bound;
    boundarray.Y = top_bound;
    boundarray.Height = bot_bound;
    boundarray.Width = right_bound;
    UpdateSectionOverlaps(section);
}

num_t LevelF::GetBoundary(int section, int which_boundary_UDLR)
{
    const SpeedlessLocation_t &boundarray = level[section];

    switch(which_boundary_UDLR)
    {
    case 0:     // U
        return boundarray.Y;
    case 1:     // D
        return boundarray.Height;
    case 2:     // L
        return boundarray.X;
    case 3:     // R
        return boundarray.Width;
    default:
        break;
    }

    return 0;
}

void LevelF::GetBoundary(LunaRect *rect, int section)
{
    if(section >= 0 && section < numSections)
    {
        const SpeedlessLocation_t &boundarray = level[section];
        rect->top = (int)boundarray.Y;
        rect->bottom = (int)boundarray.Height;
        rect->left = (int)boundarray.X;
        rect->right = (int)boundarray.Width;
    }
}

std::string LevelF::GetName()
{
    return LevelName;
}


================================================
FILE: src/script/luna/lunalevel.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNALEVEL_H
#define LUNALEVEL_H

#include <string>
#include "lunadefs.h"

namespace LevelF
{

num_t GetBoundary(int section, int which_boundary_UDLR);
void GetBoundary(LunaRect* rectangle, int section);
void PushSectionBoundary(int section, int which_boundary_UDLR, num_t push_val);
void SetSectionBounds(int section, num_t left_bound, num_t top_bound, num_t right_bound, num_t bot_bound);

std::string GetName();

}

#endif // LUNALEVEL_H


================================================
FILE: src/script/luna/lunalevels.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <unordered_map>
#include <string>
#include <functional>
#include "lunalevels.h"

#include "globals.h"

#include "levels/Docopoper-Calleoca.h"
#include "levels/Docopoper-AbstractAssault.h"
#include "levels/Docopoper-TheFloorisLava.h"
#include "levels/SAJewers-QraestoliaCaverns.h"
#include "levels/SAJewers-Snowboardin.h"
#include "levels/Talkhaus-Science_Final_Battle.h"
#include "levels/KilArmoryCode.h"


static void (*levelCodeRun)() = nullptr;

static const std::unordered_map<std::string, std::function<void()>> s_levelInit =
{

// Abtract Assault init block
{
    "Docopoper-AbstractAssault.lvl",
    []()->void
    {
        levelCodeRun = AbstractAssaultCode;
    }
},
// Calleoca init block
{
    "Docopoper-Calleoca.lvl",
    []()->void
    {
        CalleocaInitCode();
        levelCodeRun = CalleocaCode;
    }
},
// The Floor is Lava init block
{
    "Docopoper-TheFloorisLava.lvl",
    []()->void
    {
        levelCodeRun = TheFloorisLavaCode;
        TheFloorisLavaInit();
    }
},

// Qraestolia Caverns init block
{
    "SAJewers-QraestoliaCaverns.lvl",
    []()->void
    {
        levelCodeRun = QraestoliaCavernsCode;
    }
},

// Snowbordin init block
{
    "SAJewers-Snowboardin.lvl",
    []()->void
    {
        levelCodeRun = SAJSnowbordin::SnowbordinCode;
        SAJSnowbordin::SnowbordinInitCode();
    }
},

// Science init block
{
    "Talkhaus-Science_Final_Battle.lvl",
    []()->void
    {
        levelCodeRun = ScienceBattle::ScienceCode;
        ScienceBattle::ScienceInitCode();
    }
},

{
    "LUNA12-thou_starts_a_new_video.lvl",
    []()->void
    {
        levelCodeRun = KilArmoryCode;
        KilArmoryInit();
    }
},

};


void lunaLevelsInit()
{
    levelCodeRun = nullptr;

    auto l = s_levelInit.find(FileNameFull);
    if(l != s_levelInit.end())
        l->second();
}

void lunaLevelsClear()
{
    levelCodeRun = nullptr;
}

void lunaLevelsDo()
{
    if(levelCodeRun)
        levelCodeRun();
}


================================================
FILE: src/script/luna/lunalevels.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNALEVELS_H
#define LUNALEVELS_H

/*!
 * \brief Initialize level custom codes and attach to current runner
 */
extern void lunaLevelsInit();

/*!
 * \brief Remove the custom code attachment
 */
extern void lunaLevelsClear();

/*!
 * \brief Process one step of level custom code if attached
 */
extern void lunaLevelsDo();

#endif // LUNALEVELS_H


================================================
FILE: src/script/luna/lunamisc.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunamisc.h"
#include "globals.h"
#include "collision.h"
#include "rand.h"
#include <Utils/files.h>
#include "global_dirs.h"


void InitIfMissing(std::map<std::string, num_t> *pMap, const std::string& sought_key, num_t init_val)
{
    if(pMap->find(sought_key) == pMap->end())
        (*pMap)[sought_key] = init_val;
}

bool FastTestCollision(int L1, int U1, int R1, int D1, int L2, int U2, int R2, int D2)
{
    bool rightcol = true;
    bool leftcol = true;
    bool upcol = true;
    bool downcol = true;

    if(R1 < L2)
        rightcol = false;
    if(L1 > R2)
        leftcol = false;
    if(U1 > D2)
        downcol = false;
    if(D1 < U2)
        upcol = false;

    if(!rightcol || !leftcol || !upcol || !downcol)
        return false;

    return true;
}

int ComputeLevelSection(int x, int y)
{
    Location_t l;
    l.X = x - 64;
    l.Y = y - 64;
    l.Width = 128;
    l.Height = 128;

    int ret = -1;

    for(int i = 0; i < numSections; ++i)
    {
        if(SectionCollision(i, l))
        {
            ret = i;
            break;
        }
    }

    return ret;
}

void RandomPointInRadius(num_t *ox, num_t *oy, num_t cx, num_t cy, int radius)
{
    // this does not do what the author thinks it does -- terribly biased towards the edges of the square enclosing the circle of interest
    num_t phase1 = iRand2(360);
    num_t phase2 = iRand2(360);

    num_t xoff = num_t::sin(phase1) * radius;
    num_t yoff = num_t::cos(phase2) * radius;

    *ox = cx + xoff;
    *oy = cy + yoff;
}

std::string resolveIfNotAbsolutePath(const std::string &filename)
{
    if(Files::isAbsolute(filename)) {
        return filename;
    }

    std::vector<DirListCI *> dirs =
    {
        &g_dirCustom,
        &g_dirEpisode
    };

    for(DirListCI *nextSearchDir : dirs)
    {
        std::string nextEntry = nextSearchDir->resolveFileCaseExistsAbs(filename);
        if(nextEntry.empty())
            continue;
        return nextEntry;
    }

    return filename;
}


================================================
FILE: src/script/luna/lunamisc.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNAMISC_H
#define LUNAMISC_H

#include "numeric_types.h"

#include <map>
#include <string>

extern void InitIfMissing(std::map<std::string, num_t>* pMap, const std::string& sought_key, num_t init_val);

extern bool FastTestCollision(int Left1, int Up1, int Right1, int Down1, int Left2, int Up2, int Right2, int Down2);

// Compute the current SMBX level section for the given coords, or -1 if invalid
extern int ComputeLevelSection(int x, int y);

extern void RandomPointInRadius(num_t* ox, num_t* oy, num_t cx, num_t cy, int radius);

extern std::string resolveIfNotAbsolutePath(const std::string &filename);

#endif // LUNAMISC_H


================================================
FILE: src/script/luna/lunanpc.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunanpc.h"
#include "globals.h"
#include "mememu.h"
#include "npc.h"


NPC_t *NpcF::Get(int index)
{
    if(index < 0 || index >= numNPCs)
        return nullptr;

    return &NPC[index + 1];
}

NPC_t *NpcF::GetRaw(int index)
{
    return &NPC[index];
}

void NpcF::FindAll(int ID, int section, std::list<NPC_t *> *return_list)
{
    bool anyID = (ID == -1);
    bool anySec = (section == -1);
    NPC_t *thisnpc = nullptr;

    for(int i = 1; i <= numNPCs; i++)
    {
        thisnpc = &NPC[i];
        if(thisnpc->Type == ID || anyID)
        {
            if(thisnpc->Section == section || anySec)
                return_list->push_back(thisnpc);
        }
    }
}

NPC_t *NpcF::GetFirstMatch(int ID, int section)
{
    bool anyID = (ID == -1);
    bool anySec = (section == -1);
    NPC_t *thisnpc = nullptr;

    for(int i = 1; i <= numNPCs; i++)
    {
        thisnpc = &NPC[i];
        if(thisnpc->Type == ID || anyID)
        {
            if(thisnpc->Section == section || anySec)
                return thisnpc; //matched
        }
    }

    return nullptr; //not matched
}

void NpcF::MemSet(int ID, size_t offset, num_t value, OPTYPE operation, FIELDTYPE ftype)
{
    //    char* dbg =  "MemSetDbg";
    if(ftype == FT_INVALID || offset > 0x15C)
        return;

    bool anyID = (ID == -1);
    NPC_t *thisnpc;

    for(int i = 1; i <= numNPCs; i++)
    {
        thisnpc = &NPC[i];
        if(anyID || thisnpc->Type == ID)
            MemAssign(thisnpc, offset, value, operation, ftype);
    }//for
}

void NpcF::AllSetHits(int identity, int section, int hits)
{
    bool anyID = (identity == -1);
    bool anySec = (section == -1);
    NPC_t *thisnpc;

    for(int i = 1; i <= numNPCs; i++)
    {
        thisnpc = &NPC[i];
        if(anyID || thisnpc->Type == identity)
        {
            if(anySec || thisnpc->Section == section)
                thisnpc->Damage = hits;
        }
    }
}

void NpcF::AllFace(int identity, int section, num_t x)
{
    bool anyID = (identity == -1);
    bool anySec = (section == -1);
    NPC_t *thisnpc;

    for(int i = 1; i <= numNPCs; i++)
    {
        thisnpc = &NPC[i];
        if(anyID || thisnpc->Type == identity)
        {
            if(anySec || thisnpc->Section == section)
            {
                // thisnpc->Special6 = (x < thisnpc->Location.X) ? -1.0 : 1.0;
                thisnpc->Direction = (x < thisnpc->Location.X) ? -1 : 1;
            }
        }
    }
}


================================================
FILE: src/script/luna/lunanpc.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNANPC_H
#define LUNANPC_H

#include <cstddef>
#include <list>

#include "lunadefs.h"

struct NPC_t;

namespace NpcF
{

NPC_t* Get(int index); //Get ptr to an NPC
NPC_t* GetRaw(int index);

void FindAll(int ID, int section, std::list<NPC_t *> *return_list);

// GET FIRST MATCH
NPC_t *GetFirstMatch(int ID, int section);

void MemSet(int ID, size_t offset, num_t value, OPTYPE operation, FIELDTYPE ftype); // ID -1 for ALL

// ITERATORS
void AllSetHits(int identity, int section, int hits);		// Set all specified NPC hits
void AllFace(int identity, int section, num_t x);	// All specified NPCs face the supplied x/y point

} // NpcF

#endif // LUNANPC_H


================================================
FILE: src/script/luna/lunaplayer.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunaplayer.h"
#include "lunanpc.h"
#include "globals.h"
#include "sound.h"
#include "mememu.h"


Player_t *PlayerF::Get(int num)
{
    if(num > numPlayers || num < 1)
        return nullptr;

    return &Player[num];
}

void PlayerF::MemSet(size_t offset, num_t value, OPTYPE operation, FIELDTYPE ftype)
{
    //    char* dbg =  "PLAYER MEM SET";
    if(ftype == FT_INVALID || offset > (0x184 * 99))
        return;
    Player_t *pPlayer = Get(1);
    MemAssign(pPlayer, offset, value, operation, ftype);
}


bool PlayerF::PressingDown(Player_t *player)
{
    return player->Controls.Down;
}

bool PlayerF::PressingUp(Player_t *player)
{
    return player->Controls.Up;
}

bool PlayerF::PressingLeft(Player_t *player)
{
    return player->Controls.Left;
}

bool PlayerF::PressingRight(Player_t *player)
{
    return player->Controls.Right;
}

bool PlayerF::PressingJump(Player_t *player)
{
    return player->Controls.Jump;
}

bool PlayerF::PressingRun(Player_t *player)
{
    return player->Controls.Run;
}

bool PlayerF::PressingSEL(Player_t *player)
{
    return player->Controls.Drop;
}



void PlayerF::FilterToFire(Player_t *player)
{
    if(player->State > 3)
        player->State = 3;
}

void PlayerF::FilterToBig(Player_t *player)
{
    if(player->State > 2)
        player->State = 2;
}

void PlayerF::FilterToSmall(Player_t *player)
{
    if(player->State > 1)
        player->State = 1;
}

void PlayerF::FilterReservePowerup(Player_t *player)
{
    player->HeldBonus = NPCID(0);
}

void PlayerF::FilterMount(Player_t *player)
{
    player->MountType = 0;
    player->Mount = 0;
    UpdateYoshiMusic();
}


void PlayerF::InfiniteFlying(int player)
{
    Player_t *demo = Get(player);

    if(demo)
        demo->FlyCount = 50;
}

bool PlayerF::UsesHearts(Player_t *p)
{
    return p->Character != 1 && p->Character != 2;
}

LunaRect PlayerF::GetScreenPosition(Player_t *player)
{
    //    double* pCameraY = (double*)GM_CAMERA_Y;
    //    double* pCameraX = (double*)GM_CAMERA_X;
    ptrdiff_t plr_index = (player - &Player[1] + 1);
    if(plr_index < 1 || plr_index > numPlayers)
        plr_index = 1;

    const auto& vscreen = vScreenByPlayer(plr_index);
    num_t cam_y = -vscreen.Y;
    num_t cam_x = -vscreen.X;
    //    double cam_d = cam_y + 600;
    //    double cam_r = cam_x + 800;

    LunaRect ret_rect;
    ret_rect.left = num_t::round(player->Location.X - cam_x);
    ret_rect.top = num_t::round(player->Location.Y - cam_y);
    ret_rect.right = num_t::round(ret_rect.left + player->Location.Width);
    ret_rect.bottom = num_t::round(ret_rect.top + player->Location.Height);
    return ret_rect;
}

void PlayerF::CycleRight(Player_t *player)
{
    player->Character++;
    if(player->Character > 5)
        player->Character = 1;

    UpdateYoshiMusic();
}

void PlayerF::CycleLeft(Player_t *player)
{
    player->Character--;
    if(player->Character <= 0)
        player->Character = 5;

    UpdateYoshiMusic();
}

bool PlayerF::IsHoldingSpriteType(Player_t *player, int NPC_ID)
{
    if(player->HoldingNPC != 0)
    {
        NPC_t *npc = &NPC[player->HoldingNPC];
        if(npc->Type == NPC_ID)
            return true;
    }

    return false;
}


================================================
FILE: src/script/luna/lunaplayer.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LunaPlayer_HHH
#define LunaPlayer_HHH

#include <cstddef>
#include "lunadefs.h"

struct Player_t;

namespace PlayerF
{

Player_t *Get(int num);

// PLAYER MANAGEMENT

void MemSet(size_t offset, num_t value, OPTYPE operation, FIELDTYPE ftype);

// PLAYER BUTTONS
bool PressingDown(Player_t* player);
bool PressingUp(Player_t* player);
bool PressingLeft(Player_t* player);
bool PressingRight(Player_t* player);
bool PressingJump(Player_t* player);
bool PressingRun(Player_t* player);
bool PressingSEL(Player_t* pPlayer);

// CYCLE PLAYER
void CycleRight(Player_t* player);	// Changes player identity to the next character, or around to Demo
void CycleLeft(Player_t* player);	// Changes player identity to the previous character, or around to Sheath

// PLAYER STATES
bool IsHoldingSpriteType(Player_t* player, int NPC_ID);

// FILTER FUNCS
void FilterToFire(Player_t *player);
void FilterToBig(Player_t *player);
void FilterToSmall(Player_t *player);
void FilterReservePowerup(Player_t *player);
void FilterMount(Player_t *player);

void InfiniteFlying(int player);

bool UsesHearts(Player_t *p);

// GET SCREEN POSITION
LunaRect GetScreenPosition(Player_t *player);

} // PlayerF

#endif // LunaPlayer_HHH


================================================
FILE: src/script/luna/lunarender.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunarender.h"
#include "autocode_manager.h"
#include "renderop.h"
#include "globals.h"
#include "config.h"
#include "lunamisc.h"
#include "renderop_string.h"
#include "game_main.h"
#include <fmt_format_ne.h>

#include <algorithm>


PoolAllocator g_rAlloc(c_rAllocTotalSize, c_rAllocChunkSize);

static Renderer sLunaRender;

Renderer &Renderer::Get()
{
    return sLunaRender;
}

void Renderer::SetAltThread()
{}

void Renderer::UnsetAltThread()
{}

bool Renderer::IsAltThreadActive()
{
    return false;
}

Renderer::Renderer() noexcept :
    m_queueState(),
    m_legacyResourceCodeImages()
{
    g_rAlloc.Init();
}

Renderer::~Renderer()
{
    ClearQueue();
}

bool Renderer::LoadBitmapResource(const std::string& filename, int resource_code, uint32_t transparency_color)
{
    DeleteImage(resource_code);

    auto absPath = AutocodeManager::resolveCustomFileCase(filename);

    if(absPath.empty())
        absPath = AutocodeManager::resolveWorldFileCase(filename);

    if(absPath.empty())
    {
        pLogWarning("LunaRender: image file %s is not found", filename.c_str());
        return false;
    }

    LunaImage img(absPath);
    if(!img.ImageLoaded())
    {
        pLogWarning("LunaRender: Failed to load image: %s", absPath.c_str());
        return false;
    }

    img.setTransparentColor(transparency_color);
    StoreImage(std::move(img), resource_code);

    return true;
}

bool Renderer::LoadBitmapResource(const std::string& filename, int resource_code)
{
    return LoadBitmapResource(filename, resource_code, DEFAULT_TRANS_COLOR);
}

void Renderer::StoreImage(LunaImage &&bmp, int resource_code)
{
    m_legacyResourceCodeImages[resource_code] = std::move(bmp);
}

bool Renderer::DeleteImage(int resource_code)
{
    auto it = m_legacyResourceCodeImages.find(resource_code);
    if(it != m_legacyResourceCodeImages.end())
    {
        it->second.Unload();
        m_legacyResourceCodeImages.erase(it);
        return true;
    }

    return false;
}

LunaImage *Renderer::GetImageForResourceCode(int resource_code)
{
    auto it = m_legacyResourceCodeImages.find(resource_code);
    if(it != m_legacyResourceCodeImages.end())
        return &it->second;

    return nullptr;
}

void Renderer::AddOp(RenderOp *op)
{
    if(op->m_selectedCamera == 0)
    {
        // If the rendering operation was created in the middle of handling a
        // camera's rendering, lock the rendering operation to that camera.
        op->m_selectedCamera = m_queueState.m_curCamIdx;
    }

    this->m_queueState.m_currentRenderOps.push_back(op);
}

void Renderer::DebugPrint(const std::string &message)
{
    this->m_queueState.m_debugMessages.push_back(message);
}

void Renderer::DebugPrint(const std::string &message, num_t val)
{
    this->m_queueState.m_debugMessages.push_back(fmt::format_ne("{0} {1}", message, (double)val));
}

static bool CompareRenderPriority(const RenderOp *lhs, const RenderOp *rhs)
{
    return lhs->m_renderPriority < rhs->m_renderPriority;
}

void Renderer::RenderBelowPriority(PLANE maxPriority)
{
    if(!m_queueState.m_InFrameRender) return;

    //    if (this == &sLunaRender)
    //    {
    //        // Make sure we kill the loadscreen before main thread rendering
    //        LunaLoadScreenKill();
    //    }

    auto &ops = m_queueState.m_currentRenderOps;
    if(ops.size() <= m_queueState.m_renderOpsProcessedCount) return;

    // Flush pending BltBlt
    //    g_BitBltEmulation.flushPendingBlt();

    // Assume operations already processed were already sorted
    if(m_queueState.m_renderOpsSortedCount == 0)
    {
        std::stable_sort(ops.begin(), ops.end(), CompareRenderPriority);
        m_queueState.m_renderOpsSortedCount = ops.size();
    }
    else if(m_queueState.m_renderOpsSortedCount < ops.size())
    {
        // Sort the new operations
        std::stable_sort(ops.begin() + m_queueState.m_renderOpsSortedCount, ops.end(), CompareRenderPriority);

        // Render things as many of the new items as we should before merging the sorted lists
        PLANE maxPassPriority = maxPriority;
        if(m_queueState.m_renderOpsSortedCount > m_queueState.m_renderOpsProcessedCount)
        {
            PLANE nextPriorityInOldList = ops[m_queueState.m_renderOpsProcessedCount]->m_renderPriority;
            if(nextPriorityInOldList < maxPassPriority)
                maxPassPriority = nextPriorityInOldList;
        }

        for(auto iter = ops.cbegin() + m_queueState.m_renderOpsSortedCount, end = ops.cend(); iter != end; ++iter)
        {
            RenderOp &op = **iter;
            if(op.m_renderPriority >= maxPassPriority)
                break;
            DrawOp(op);
            m_queueState.m_renderOpsProcessedCount++;
        }

        // Merge sorted list sections (note, std::inplace_merge is a stable sort)
        std::inplace_merge(ops.begin(), ops.begin() + m_queueState.m_renderOpsSortedCount, ops.end(), CompareRenderPriority);
        m_queueState.m_renderOpsSortedCount = ops.size();
    }

    // Render other operations
    for(auto iter = ops.cbegin() + m_queueState.m_renderOpsProcessedCount, end = ops.cend(); iter != end; ++iter)
    {
        RenderOp &op = **iter;
        if(op.m_renderPriority >= maxPriority)
            break;
        DrawOp(op);
        m_queueState.m_renderOpsProcessedCount++;
    }

    if(maxPriority >= RENDEROP_PRIORITY_MAX)
    {
        // Format debug messages and enter them into renderstring list
        int dbg_x = 325;
        int dbg_y = 160;

        for(auto &dbg : m_queueState.m_debugMessages)
        {
            RenderStringOp(dbg, 4, dbg_x, dbg_y).Draw(this);
            dbg_y += 20;
            if(dbg_y > 560)
            {
                dbg_y = 160;
                dbg_x += 190;
            }
        }

        this->m_queueState.m_debugMessages.clear();
    }
}

void Renderer::ClearAllDebugMessages()
{
    this->m_queueState.m_debugMessages.clear();
}

void Renderer::ClearAllLoadedImages()
{
    for(auto &i : m_legacyResourceCodeImages)
        i.second.Unload();
    m_legacyResourceCodeImages.clear();
}

void Renderer::StartCameraRender(int idx)
{
    m_queueState.m_curCamIdx = idx;
    m_queueState.m_renderOpsProcessedCount = 0;
}

void Renderer::StoreCameraPosition(int idx)
{
    UNUSED(idx);
    //    if (g_GLEngine.IsEnabled())
    //    {
    //        std::shared_ptr<GLEngineCmd_SetCamera> cmd = std::make_shared<GLEngineCmd_SetCamera>();
    //        cmd->mX = SMBX_CameraInfo::getCameraX(idx);
    //        cmd->mY = SMBX_CameraInfo::getCameraY(idx);
    //        g_GLEngine.QueueCmd(cmd);
    //    }
}

void Renderer::StartRenderLogic()
{
    // Decrement life time counters
    for(auto &m_currentRenderOp : m_queueState.m_currentRenderOps)
        m_currentRenderOp->m_FramesLeft--;
}

void Renderer::EndRenderLogic()
{
    // Remove cleared operations
    std::vector<RenderOp *> nonExpiredOps;
    for(auto &m_currentRenderOp : m_queueState.m_currentRenderOps)
    {
        RenderOp *pOp = m_currentRenderOp;
        if(pOp->m_FramesLeft <= 0)
        {
            m_currentRenderOp = nullptr;
            delete pOp;
        }
        else
            nonExpiredOps.push_back(pOp);
    }

    m_queueState.m_currentRenderOps.swap(nonExpiredOps);
}

void Renderer::StartFrameRender()
{
    m_queueState.m_curCamIdx = 0;
    m_queueState.m_InFrameRender = true;
    m_queueState.m_renderOpsSortedCount = m_queueState.m_currentRenderOps.size();
}

void Renderer::EndFrameRender()
{
    if(!m_queueState.m_InFrameRender)
        return;

    m_queueState.m_curCamIdx = 0;
    m_queueState.m_renderOpsProcessedCount = 0;
    m_queueState.m_InFrameRender = false;
}

void Renderer::ClearQueue()
{
    m_queueState.m_curCamIdx = 0;
    for(auto &m_currentRenderOp : m_queueState.m_currentRenderOps)
        delete m_currentRenderOp;
    g_rAlloc.Reset();
    m_queueState.m_currentRenderOps.clear();
    m_queueState.m_renderOpsProcessedCount = 0;
    m_queueState.m_renderOpsSortedCount = 0;
    m_queueState.m_InFrameRender = false;
}

void Renderer::DrawOp(RenderOp &op)
{
    if((op.m_selectedCamera == 0 || op.m_selectedCamera == m_queueState.m_curCamIdx) && (op.m_FramesLeft >= 1 || GamePaused != PauseCode::None))
        op.Draw(this);
}


bool Render::IsOnScreen(int x, int y, int w, int h)
{
    int cam_x = vScreen[1].CameraAddX_i();
    int cam_y = vScreen[1].CameraAddY_i();
    int cam_w = vScreen[1].Width;
    int cam_h = vScreen[1].Height;

    return FastTestCollision((int)cam_x, (int)cam_y, (int)cam_x + (int)cam_w, (int)cam_y + (int)cam_h,
                             (int)x, (int)y, (int)x + (int)w, (int)y + (int)h);
}

#if 0
void Render::CalcCameraPos(double *ret_x, double *ret_y)
{
    // Old camera func, using "camera" memory
    double val;

    if(ret_x != nullptr)
    {
        val = vScreen[1].X;
        *ret_x = val - val - val; // Fix backwards smbx camera
    }

    if(ret_y != nullptr)
    {
        val = vScreen[1].Y;
        *ret_y = val - val - val; // Fix backwards smbx camera
    }
}
#endif

void Render::TranslateScreenCoords(int &x, int &y, int w, int h)
{
    // FIXME: What we shall to do with w and h?
    UNUSED(w);
    UNUSED(h);

    if(g_config.autocode_translate_coords)
    {
        int top = 0;
        if(vScreen[1].Height > 600)
            top = vScreen[1].Height / 2 - 300;
        int left = vScreen[1].Width / 2 - 400;

        x += left;
        y += top;

        if(vScreen[1].Height < 600)
            y = (y * vScreen[1].Height) / 600;
    }
}


================================================
FILE: src/script/luna/lunarender.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNARENDER_H
#define LUNARENDER_H

#include "numeric_types.h"

#include <unordered_map>
#include <vector>
#include <string>
#include <list>
#include <Allocator/PoolAllocator.h>

#include "draw_planes.h"
#include "lunaimgbox.h"

class RenderOp;
class LunaImage;

constexpr size_t c_rAllocChunkSize = 96;
constexpr size_t c_rAllocTotalSize = c_rAllocChunkSize * 1000;
extern PoolAllocator g_rAlloc;

struct Renderer
{
    static Renderer &Get();
    static void SetAltThread();
    static void UnsetAltThread();
    static bool IsAltThreadActive();

    Renderer() noexcept;
    ~Renderer();

    bool LoadBitmapResource(const std::string &filename, int resource_code, uint32_t transparency_color); // don't give full path
    bool LoadBitmapResource(const std::string &filename, int resource_code);
    void StoreImage(LunaImage&& bmp, int resource_code);
    bool DeleteImage(int resource_code);
    LunaImage *GetImageForResourceCode(int resource_code);

    void AddOp(RenderOp *op);                           // Add a drawing operation to the list
    // void GLCmd(const std::shared_ptr<GLEngineCmd>& cmd, double renderPriority = 1.0);

    void DebugPrint(const std::string &message);                // Print a debug message on the screen
    void DebugPrint(const std::string &message, num_t val);    // Print a debug message on the screen and display a related value

    void RenderBelowPriority(PLANE maxPriority);

    void ClearAllDebugMessages();

    void ClearAllLoadedImages();

    // Calls from hooks
    void StartCameraRender(int idx);
    void StoreCameraPosition(int idx);

    // Render logic
    void StartRenderLogic();
    void EndRenderLogic();

    // Render begin/end
    void StartFrameRender();
    void EndFrameRender();

    void ClearQueue();
private:
    void DrawOp(RenderOp &render_operation);


    // Members //
public:
    class QueueState
    {
    public:
        bool m_InFrameRender;
        int m_curCamIdx; // Camera state

        std::size_t m_renderOpsSortedCount;
        std::size_t m_renderOpsProcessedCount;
        std::vector<RenderOp *> m_currentRenderOps; // render operations to be performed

        std::list<std::string> m_debugMessages;    // Debug message to be printed

    public:
        QueueState() :
            m_InFrameRender(false),
            m_curCamIdx(1),
            m_renderOpsSortedCount(0),
            m_renderOpsProcessedCount(0),
            m_currentRenderOps(),
            m_debugMessages()
        {}
    };

private:
    QueueState m_queueState;
    std::unordered_map<int, LunaImage> m_legacyResourceCodeImages;  // loaded image resources

    // Simple getters //
public:
    int GetCameraIdx() const
    {
        return m_queueState.m_curCamIdx;
    }
    // HDC GetScreenDC() { return (HDC)GM_SCRN_HDC; }

    class QueueStateStacker
    {
    private:
        Renderer &m_renderer;
        QueueState m_savedState;

    public:
        QueueStateStacker() :
            m_renderer(Renderer::Get())
        {
            m_savedState = m_renderer.m_queueState;
            // Don't use m_renderer.ClearQueue() for this because we're effectively moving things and ClearQueue frees some pointers
            m_renderer.m_queueState.m_InFrameRender = false;
            m_renderer.m_queueState.m_curCamIdx = 1;
            m_renderer.m_queueState.m_renderOpsSortedCount = 0;
            m_renderer.m_queueState.m_renderOpsProcessedCount = 0;
            m_renderer.m_queueState.m_currentRenderOps.clear();
            m_renderer.m_queueState.m_debugMessages.clear();
        }

        ~QueueStateStacker()
        {
            m_renderer.ClearQueue();
            m_renderer.m_queueState = m_savedState;
        }
    };
};

namespace Render
{

bool IsOnScreen(int x, int y, int w, int h);              // Returns whether or not the digven rectangle is on screen this frame
// void CalcCameraPos(double *p_X, double *p_Y);                         // Tries to read smbx memory to return the camera coords in the 2 passed args
void TranslateScreenCoords(int &x, int &y, int w, int h); // Converts 800x600 coordinates to dynamic-res coordinates, depending on config options

}


#endif // LUNARENDER_H


================================================
FILE: src/script/luna/lunaspriteman.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunaspriteman.h"
#include "csprite.h"
#include "lunarender.h"
#include "sprite_funcs.h"
#include "lunaplayer.h"
#include "lunamisc.h"
#include "lunaimgbox.h"
#include "game_main.h" // GamePaused

#include "globals.h"


CSpriteManager gSpriteMan;


void CSpriteManager::ResetSpriteManager()
{
    ClearAllSprites();
    m_ComponentList.clear();
}

void CSpriteManager::BasicInit(CSprite *spr, CSpriteRequest *pReq, bool center)
{
    spr->m_Xpos = pReq->x;
    spr->m_Ypos = pReq->y;
    //spr->m_StaticScreenPos = false;
    spr->SetImageResource(pReq->img_resource_code);
    spr->SetImage(pReq->direct_img);
    InitializeDimensions(spr, center);
    if(pReq->time != 0)
        spr->MakeLimitedLifetime(pReq->time);
}

void CSpriteManager::InitializeDimensions(CSprite *spr, bool center_coords)
{
    const LunaImage *box = spr->m_directImg;

    if(!box)
        box = Renderer::Get().GetImageForResourceCode(spr->m_ImgResCode);

    if(box)
    {
        LunaRect rect;
        rect.left = 0;
        rect.top = 0;
        rect.right = box->getW();
        rect.bottom = box->getH();
        spr->m_GfxRects.clear();
        spr->m_GfxRects.push_back(rect);

        spr->m_Ht = rect.bottom;
        spr->m_Wd = rect.right;
        spr->m_AnimationSet = false;

        spr->m_Hitbox.Left_off = 0;
        spr->m_Hitbox.Top_off = 0;
        spr->m_Hitbox.W = (short)rect.right;
        spr->m_Hitbox.H = (short)rect.bottom;
        spr->m_Hitbox.CollisionType = 0;
        spr->m_Hitbox.pParent = spr;

        if(center_coords) // Fix to generate with x/y as center instead of minimum left/top
        {
            spr->m_Xpos -= spr->m_Wd * 0.5_n;
            spr->m_Ypos -= spr->m_Ht * 0.5_n;
        }
    }
}

void CSpriteManager::InstantiateSprite(CSpriteRequest *req, bool center_coords)
{
    CSprite *spr = nullptr;

    // For built in sprites
    if(req != nullptr && req->type != (BUILTIN_SPRITE_TYPE)BST_Custom)
    {
        switch(req->type)
        {

        // STATIC SPRITE
        case BST_Static:
        {
            spr = new CSprite;
            BasicInit(spr, req, center_coords);
            spr->m_StaticScreenPos = true;
            spr->AddDrawComponent(&SpriteFunc::StaticDraw);
            break;
        }

        // NORMAL SPRITE
        case BST_Normal:
        {
            spr = new CSprite;
            BasicInit(spr, req, center_coords);
            spr->AddDrawComponent(&SpriteFunc::RelativeDraw);
            break;
        }

        // ITEM SPRITE
        case BST_Item:
        {
            spr = new CSprite;
            BasicInit(spr, req, center_coords);
            spr->AddDrawComponent(&SpriteFunc::RelativeDraw);

            // Add collectible event # if applicable
            int str_arg = std::atoi(req->str.c_str());
            if(str_arg > 21)
            {
                SpriteComponent comp;                       // Add collectible component
                comp.func = SpriteFunc::PlayerCollectible;
                spr->AddBehaviorComponent(comp);

//                if(str_arg > 21) // Useless condition as it's already true from above
//                {
                // Add trigger event on death
                comp.func = SpriteFunc::TriggerLunaEvent;
                comp.data1 = str_arg;
                spr->AddDeathComponent(comp);
//                }

            }
            break;
        }

        // PROGRESS BAR
        case BST_Bar:
        {
            //spr = new CSprite;
            //TODO: MAKE IT
            spr = nullptr;
            // WHO ATTEMPTED TO USE THE NULL POINTER? EXECUTE!
            // (Joke! It's all my fault that I left this code piece taken from LunaDLL being uncommented)
            //spr->m_Xpos = req->x;
            //spr->m_Ypos = req->y;
            break;
        }

        // PHANTO
        case BST_Phanto:
        {
            // Need to add phanto to blueprints?
            if(m_SpriteBlueprints.find("__DefaultPhanto") == m_SpriteBlueprints.end())
            {
                spr = new CSprite;
                SpriteComponent comp;
                BasicInit(spr, req, center_coords);
                spr->AddDrawComponent(&SpriteFunc::RelativeDraw);

                // Always Decelerate
                comp.Init(0);
                comp.func = SpriteFunc::Deccelerate;
                comp.data1 = 0.04_n;
                comp.data2 = 0.04_n;
                comp.data3 = 0.00_n;
                spr->AddBehaviorComponent(comp);

                // Wait for player to have key -- activate 100
                comp.Init(0);
                comp.func = SpriteFunc::PlayerHoldingSprite;
                comp.data1 = 31; // key ID
                comp.data4 = 100; // activates 100
                spr->AddBehaviorComponent(comp);

                comp.Init(0);
                comp.func = SpriteFunc::PlayerHoldingSprite;
                comp.data1 = 0x0E; // key ID alternate
                comp.data4 = 100; // activates 100
                spr->AddBehaviorComponent(comp);

                comp.Init(0); // Phase Move
                comp.func = SpriteFunc::PhaseMove;
                //comp.lookup_code;
                spr->AddBehaviorComponent(comp);

                // #100 -- Chase player / active mode
                comp.Init(1);
                comp.func = SpriteFunc::AccelToPlayer;
                comp.data1 = 0.11_n;
                comp.data2 = 0.11_n;
                comp.data3 = 5.6_n;
                comp.lookup_code = 100;
                gSpriteMan.m_ComponentList.push_back(comp);

                comp.Init(1); // Check for collision -- activate 101
                comp.func = SpriteFunc::OnPlayerCollide;
                comp.data4 = 101; // harm player
                comp.lookup_code = 100;
                gSpriteMan.m_ComponentList.push_back(comp);

                comp.Init(1); // Check for too much distance from player -- activate 102
                comp.func = SpriteFunc::OnPlayerDistance;
                comp.data1 = 3000;
                comp.data4 = 102; // tele near player
                comp.lookup_code = 100;
                gSpriteMan.m_ComponentList.push_back(comp);

                // #101 -- harm player
                comp.Init(1); // Check for too much distance from player
                comp.func = SpriteFunc::HarmPlayer;
                comp.lookup_code = 101;
                gSpriteMan.m_ComponentList.push_back(comp);

                // #102 -- teleport near player
                comp.Init(1); // Check for too much distance from player
                comp.func = SpriteFunc::TeleportNearPlayer;
                comp.data1 = 1000;
                comp.lookup_code = 102;
                gSpriteMan.m_ComponentList.push_back(comp);
                m_SpriteBlueprints["__DefaultPhanto"] = spr;
            }

            const char *defPhant = "__DefaultPhanto";
            CSprite *from_bp = CopyFromBlueprint(defPhant);
            from_bp->m_Xpos = req->x;
            from_bp->m_Ypos = req->y;
            from_bp->SetImageResource(req->img_resource_code);
            from_bp->SetImage(req->direct_img);
            InitializeDimensions(from_bp, center_coords);
            if(req->time != 0)
                from_bp->MakeLimitedLifetime(req->time);
            spr = from_bp;
            break;
        }

        } //< Switch

        // Add the sprite
        if(spr != nullptr)
            AddSprite(spr);
    }
    // Else, instantiate custom sprite?
    else if(req != nullptr && req->type == BST_Custom)
    {
        CSprite *from_bp = CopyFromBlueprint(const_cast<char *>(req->str.c_str()));

        if(from_bp)
        {
            from_bp->m_Xpos = req->x;
            from_bp->m_Ypos = req->y;
            from_bp->m_Xspd = req->x_speed;
            from_bp->m_Yspd = req->y_speed;
            from_bp->SetImageResource(req->img_resource_code);
            from_bp->SetImage(req->direct_img);
            InitializeDimensions(from_bp, center_coords);
            if(req->time != 0)
                from_bp->MakeLimitedLifetime(req->time);
            from_bp->Birth();
            AddSprite(from_bp);
        }
    }
}

void CSpriteManager::AddBlueprint(const char *blueprint_name, CSprite *spr)
{
    m_SpriteBlueprints[blueprint_name] = spr;
}

CSprite *CSpriteManager::CopyFromBlueprint(const char *blueprint_name)
{
    if(m_SpriteBlueprints.find(blueprint_name) != m_SpriteBlueprints.end())
    {
        auto *newspr = new CSprite;
        *newspr = *m_SpriteBlueprints[blueprint_name];
        return newspr;
    }
    else
        return nullptr;
}

void CSpriteManager::RunSprites()
{
    ClearInvalidSprites();
    Player_t *demo = PlayerF::Get(1);

    if(demo && GamePaused == PauseCode::None)
    {
        // Process each
        for(auto &iter : m_SpriteList)
        {
            if(!iter->m_Invalidated)  // Don't process invalids
            {
                if(ComputeLevelSection((int)iter->m_Xpos, (int)iter->m_Ypos) == demo->Section + 1 ||
                   iter->m_AlwaysProcess || iter->m_StaticScreenPos)   // Valid level section to process in?
                    iter->Process();
            }
            else
                m_hasInvalid = true;
        }

        // Draw each
        for(auto &iter : m_SpriteList)
        {
            if(!iter->m_Invalidated)
            {
                if(iter->m_StaticScreenPos || Render::IsOnScreen((int)iter->m_Xpos, (int)iter->m_Ypos, (int)iter->m_Wd, (int)iter->m_Ht))
                    iter->Draw();
            }
            else
                m_hasInvalid = true;
        }
    }
}

void CSpriteManager::ClearInvalidSprites()
{
    if(!m_hasInvalid)
        return;

    auto iter = m_SpriteList.begin();
    // std::list<CSprite*>::iterator end = m_SpriteList.end();

    while(iter != m_SpriteList.end())
    {
        //CSprite* spr = *iter;
        if((*iter)->m_Invalidated)
        {
            delete(*iter);
            iter = m_SpriteList.erase(iter);
        }
        else
            ++iter;
    }

    m_hasInvalid = false;
}

void CSpriteManager::ClearAllSprites()
{
    while(!m_SpriteList.empty())
    {
        delete m_SpriteList.back();
        m_SpriteList.pop_back();
    }
}

void CSpriteManager::ClearSprites(int imgResourceCode, int xPos, int yPos)
{
    auto iter = m_SpriteList.begin();
    //    std::list<CSprite*>::iterator end = m_SpriteList.end();

    while(iter != m_SpriteList.end())
    {
        //CSprite* spr = *iter;
        CSprite *next = *iter;
        if(next->m_ImgResCode == imgResourceCode && (int)next->m_Xpos == xPos && (int)next->m_Ypos == yPos)
        {
            delete(*iter);
            iter = m_SpriteList.erase(iter);
        }
        else
            ++iter;
    }
}

void CSpriteManager::ClearSprites(int imgResourceCode)
{
    auto iter = m_SpriteList.begin();
    //    std::list<CSprite*>::iterator end = m_SpriteList.end();

    while(iter != m_SpriteList.end())
    {
        //CSprite* spr = *iter;
        CSprite *next = *iter;

        if(!next->m_directImg && next->m_ImgResCode == imgResourceCode)
        {
            delete(*iter);
            iter = m_SpriteList.erase(iter);
        }
        else
            ++iter;
    }
}

void CSpriteManager::ClearSprites(LunaImage *img, int xPos, int yPos)
{
    std::list<CSprite *>::iterator iter = m_SpriteList.begin();
    //    std::list<CSprite*>::iterator end = m_SpriteList.end();

    while(iter != m_SpriteList.end())
    {
        //CSprite* spr = *iter;
        CSprite *next = *iter;
        if(next->m_directImg && next->m_directImg->getUID() == img->getUID() &&
           (int)next->m_Xpos == xPos && (int)next->m_Ypos == yPos)
        {
            delete(*iter);
            iter = m_SpriteList.erase(iter);
        }
        else
            ++iter;
    }
}

void CSpriteManager::ClearSprites(LunaImage *img)
{
    std::list<CSprite *>::iterator iter = m_SpriteList.begin();
    // std::list<CSprite*>::iterator end = m_SpriteList.end();

    while(iter != m_SpriteList.end())
    {
        //CSprite* spr = *iter;
        CSprite *next = *iter;
        if(next->m_directImg->getUID() == img->getUID())
        {
            delete(*iter);
            iter = m_SpriteList.erase(iter);
        }
        else
            ++iter;
    }
}

void CSpriteManager::AddSprite(CSprite *spr)
{
    m_SpriteList.push_back(spr);
    if(spr->m_Invalidated)
        m_hasInvalid = true;
}

void CSpriteManager::GetComponents(int code, std::list<SpriteComponent *> *component_list)
{
    for(auto &iter : m_ComponentList)
    {
        // Lookup components that match the code
        if(iter.lookup_code == code)
            component_list->push_back(&iter);
    }
}


================================================
FILE: src/script/luna/lunaspriteman.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef CSPRITEMANAGER_H
#define CSPRITEMANAGER_H

#include <list>
#include <map>
#include <list>

#include "sprite_component.h"


class LunaImage;

////////////////////////////
/// BUILTIN SPRITE TYPES /// ****************************************************************************************************
////////////////////////////
//
// 1 = Static / HUD sprite      1: Type     2: Img code     3: Xpos     4: Ypos     5: Active lifetime  6:
// 2 = "In level" sprite        1: Type     2: Img code     3: Xpos     4: Ypos     5: Active lifetime  6:
// 3 = Collectible item         1: Type     2: Img code     3: Xpos     4: Ypos     5: Active lifetime  6: Lundll event to trigger
// 4 = Progress bar             1: Type     2: Img code     3: Xpos     4: Ypos     5: Active lifetime  6:
// 5 = Phanto                   1: Type     2: Img code     3: Xpos     4: Ypos     5: Active lifetime  6:
//
//////////////////////////// ****************************************************************************************************

enum BUILTIN_SPRITE_TYPE
{
    BST_Custom = 0,
    BST_Static = 1,
    BST_Normal = 2,
    BST_Item = 3,
    BST_Bar = 4,
    BST_Phanto
};


struct CSpriteRequest;
class CSprite;

// Basic manager class for sprites
struct CSpriteManager
{
    void ResetSpriteManager();                                          // Will be called on level load to re-init everything

    void BasicInit(CSprite *spr, CSpriteRequest *req, bool center);     // Quickly set frequently-used sprite attributes
    void InitializeDimensions(CSprite *spr, bool center_coords);        // Set hitbox and dimensions to size of image
    void InstantiateSprite(CSpriteRequest *req, bool center_coords);    // Officially place sprite in level (m_SpriteList)

    void AddBlueprint(const char *blueprint_name, CSprite *spr);
    CSprite *CopyFromBlueprint(const char *blueprint_name);// Generate new sprite based on blueprint

    void RunSprites();
    int CountSprites() const
    {
        return (int)m_SpriteList.size();
    }

    int CountBlueprints() const
    {
        return (int)m_SpriteBlueprints.size();
    }

    int CountComponents() const
    {
        return (int)m_ComponentList.size();
    }

    void ClearInvalidSprites(); // Don't call while iterating
    void ClearAllSprites();
    void ClearSprites(int imgResourceCode, int xPos, int yPos);
    void ClearSprites(int imgResourceCode);
    void ClearSprites(LunaImage *img, int xPos, int yPos);
    void ClearSprites(LunaImage *img);

    void AddSprite(CSprite *spr);

    void GetComponents(int code, std::list<SpriteComponent *> *component_list); // Get components with the given code #

    std::list<CSprite *> m_SpriteList;
    std::map<std::string, CSprite *> m_SpriteBlueprints;
    std::list<SpriteComponent> m_ComponentList;     // User components that can be copied (activated) into a sprite's behavior list
    bool m_hasInvalid = false;
};

extern CSpriteManager gSpriteMan;

#endif // CSPRITEMANAGER_H


================================================
FILE: src/script/luna/lunavarbank.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "lunavarbank.h"
#include "lunadefs.h"
#include "globals.h"
#include <fmt_format_ne.h>
#include <Utils/files.h>

saveUserData::DataSection gLunaVarBank;
SavedVariableBank gSavedVarBank;

#define SPECIAL_SAVE_STR "__LunaVarBankSpecialCounter"

// INIT
void SavedVariableBank::Init()
{}

// TRY LOAD WORLD VARS
SavedVariableBank::SavedVariableBank()
{
    Init();
}

bool SavedVariableBank::TryLoadWorldVars()
{
    if(selSave <= 0 || selSave > maxSaveSlots)
        return false;

    ClearBank();
    ImportBank();

    return true;
}

// INIT SAVE FILE
void SavedVariableBank::InitSaveFile()
{
    const char *lunaKey = "__Lunadll_Version";
    if(m_VarBank.find(lunaKey) == m_VarBank.end())
        m_VarBank.insert({lunaKey, LUNA_VERSION});
}

void SavedVariableBank::ImportBank()
{
    if(gLunaVarBank.data.empty())
        InitSaveFile();

    for(auto &d : gLunaVarBank.data)
        SetVar(d.key, num_t::from_double(std::atof(d.value.c_str())));

    lastStarsNumber = num_t::round(GetVar(SPECIAL_SAVE_STR));
}

// SET VAR
void SavedVariableBank::SetVar(const std::string &k, num_t v)
{
    m_VarBank[k] = v;
}

// GET VAR
num_t SavedVariableBank::GetVar(const std::string &key)
{
    if(!VarExists(key))
        return 0;
    return m_VarBank[key];
}

// VAR EXISTS
bool SavedVariableBank::VarExists(const std::string &k)
{
    if(m_VarBank.find(k) == m_VarBank.end())
        return false;
    return true;
}

// CLEAR BANK
void SavedVariableBank::ClearBank()
{
    lastStarsNumber = 0;
    m_VarBank.clear();
}

// WRITE BANK
void SavedVariableBank::WriteBank()
{
    if(selSave <= 0 || selSave > maxSaveSlots)
        return;

    gLunaVarBank.name = "LunaDLL";
    gLunaVarBank.location = saveUserData::DATA_GLOBAL;
    gLunaVarBank.data.clear();

    for(auto &it : m_VarBank)
    {
        saveUserData::DataEntry de;
        de.key = it.first;
        de.value = fmt::format_ne("{0}", (double)it.second);
        gLunaVarBank.data.push_back(std::move(de));
    }
}

// SaveIfNeeded
void SavedVariableBank::SaveIfNeeded()
{
    // Basically, force save if the player collected a star
    if(numStars > lastStarsNumber)
    {
        lastStarsNumber = numStars;
        SetVar(SPECIAL_SAVE_STR, numStars);
        WriteBank();
    }
}

//COPY BANK
void SavedVariableBank::CopyBank(std::map<std::string, num_t> *target_map)
{
    if(!target_map)
        return;

    for(auto &it : m_VarBank)
    {
        auto n = (*target_map).find(it.first);
        if(n == (*target_map).end())
            (*target_map).insert(it);
        else
            n->second = it.second;
    }
}


================================================
FILE: src/script/luna/lunavarbank.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef LUNAVARBANK_H
#define LUNAVARBANK_H

#include "numeric_types.h"

#include <string>
#include <map>
#include <PGE_File_Formats/save_filedata.h>

extern saveUserData::DataSection gLunaVarBank;

// -- Custom user variables saving/loading manager --
// How it works: (On level load) Reads global "LunaDLL" section from the game save and reads all vars into object's local variable bank
// Whole variable bank will be written back to the gamesave when calling WriteBank
// Object is basically a wrapper around a map with some file management functions
class SavedVariableBank
{
    int lastStarsNumber = 0;
public:
    SavedVariableBank();

    /*!
     * \brief Try to read in the saved variables for this world & current save slot
     * \return True on success, false on error
     */
    bool TryLoadWorldVars();

    /*!
     * \brief Sets or adds a key/value pair to the bank
     * \param key Key
     * \param val Value
     */
    void SetVar(const std::string &key, num_t val);

    /*!
     * \brief Returns whether or not this var exists in the bank
     * \param key Key
     * \return true if exists
     */
    bool VarExists(const std::string &key);

    /*!
     * \brief Get value of a key, or 0 if key not found
     * \param key Key
     * \return Value
     */
    num_t GetVar(const std::string &key);

    /*!
     * \brief Copy all k,v pairs of variable bank to another map
     * \param target Destination map of copy
     */
    void CopyBank(std::map<std::string, num_t> *target);

    void ClearBank();

    /*!
     * \brief Save vars by writing the current bank back to world folder
     */
    void WriteBank();

    /*!
     * \brief Saves if it detects the player has collected a new star
     */
    void SaveIfNeeded();

    /// Members ///
    std::map<std::string, num_t> m_VarBank;

private:
    // Init the object
    void Init();
    // Init a new save file
    void InitSaveFile();
    // Read all vars from open file into bank
    void ImportBank();
};

extern SavedVariableBank gSavedVarBank;

#endif // LUNAVARBANK_H


================================================
FILE: src/script/luna/mememu.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <Logger/logger.h>

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_assert.h"

#include "mememu.h"
#include "globals.h"
#include "global_constants.h"
#include "layers.h"
#include "config.h"
#include "game_main.h" // GamePaused
#include "main/trees.h" // treeNPCUpdate
#include "npc/npc_queues.h"
#include "main/cheat_code.h"

#include <unordered_map>
#include <functional>
#include <type_traits>
#include <limits>


#if defined(arm) && !defined(__SOFTFP__) && !defined(__VFP_FP__) && !defined(__MAVERICK__)
#   define ARM_BIDI_ENDIAN
//inline void swap_halfes(uint64_t &x)
//{
//    uint64_t y = ((x & 0xFFFFFFFF00000000) >> 32) & 0xFFFFFFFF;
//    x = ((x << 32) & 0xFFFFFFFF00000000) & y;
//}
//#else // Do nothing
//#   define swap_halfes(x)
#endif


#if 0 // Unused yet
SDL_FORCE_INLINE void toX86Endian(num_t in_d, uint8_t out[8])
{
    auto *in = reinterpret_cast<uint8_t*>(&in_d);

#if defined(THEXTECH_BIG_ENDIAN)
    out[0] = in[7];
    out[1] = in[6];
    out[2] = in[5];
    out[3] = in[4];
    out[4] = in[3];
    out[5] = in[2];
    out[6] = in[1];
    out[7] = in[0];
#elif defined(ARM_BIDI_ENDIAN) // some old devices
    out[4] = in[0];
    out[5] = in[1];
    out[6] = in[2];
    out[7] = in[3];
    out[0] = in[4];
    out[1] = in[5];
    out[2] = in[6];
    out[3] = in[7];
#else // normal little endian
    out[0] = in[0];
    out[1] = in[1];
    out[2] = in[2];
    out[3] = in[3];
    out[4] = in[4];
    out[5] = in[5];
    out[6] = in[6];
    out[7] = in[7];
#endif
}

SDL_FORCE_INLINE void fromX86Endian(const uint8_t in[8], num_t &out_d)
{
    auto *out = reinterpret_cast<uint8_t*>(&out_d);

#if defined(THEXTECH_BIG_ENDIAN)
    out[0] = in[7];
    out[1] = in[6];
    out[2] = in[5];
    out[3] = in[4];
    out[4] = in[3];
    out[5] = in[2];
    out[6] = in[1];
    out[7] = in[0];
#elif defined(ARM_BIDI_ENDIAN) // some old devices
    out[4] = in[0];
    out[5] = in[1];
    out[6] = in[2];
    out[7] = in[3];
    out[0] = in[4];
    out[1] = in[5];
    out[2] = in[6];
    out[3] = in[7];
#else // normal little endian
    out[0] = in[0];
    out[1] = in[1];
    out[2] = in[2];
    out[3] = in[3];
    out[4] = in[4];
    out[5] = in[5];
    out[6] = in[6];
    out[7] = in[7];
#endif
}
#endif


template<class T>
T f2i_cast(num_t in)
{
#ifndef THEXTECH_FIXED_POINT
    if(std::is_same<T, uint64_t>::value)
    {
        if(in < static_cast<num_t>(std::numeric_limits<uint64_t>::min()) || (in > 2.0_n * 0x8000000000000000))
            in = num_t::from_double(SDL_fmod((double)in, 2.0 * 0x8000000000000000));
        return static_cast<T>(in);
    }

    if(in < static_cast<num_t>(std::numeric_limits<int64_t>::min()) || in > static_cast<num_t>(std::numeric_limits<int64_t>::max()))
        in = num_t::from_double(SDL_fmod((double)in, 0x8000000000000000));
#endif

    return static_cast<T>(static_cast<int64_t>(in));
}

SDL_FORCE_INLINE void modifyByteX86(num_t &dst, size_t byte, uint8_t data)
{
#ifdef THEXTECH_FIXED_POINT
    return;
#endif

    auto *in = reinterpret_cast<uint8_t*>(&dst);
    SDL_assert(byte < 8);

#if defined(THEXTECH_BIG_ENDIAN)
    in[7 - byte] = data;
#elif defined(ARM_BIDI_ENDIAN) // some old devices
    byte += (byte < 4) ? +4 : -4;
    in[byte] = data;
#else // normal little endian
    in[byte] = data;
#endif
}

SDL_FORCE_INLINE void modifyByteX86(numf_t &dst, size_t byte, uint8_t data)
{
#ifdef THEXTECH_FIXED_POINT
    return;
#endif

    auto *in = reinterpret_cast<uint8_t*>(&dst);
    SDL_assert(byte < 4);

#if defined(THEXTECH_BIG_ENDIAN)
    in[3 - byte] = data;
#else // normal little endian
    in[byte] = data;
#endif
}

SDL_FORCE_INLINE void modifyByteX86(int16_t &dst, size_t byte, uint8_t data)
{
    auto *in = reinterpret_cast<uint8_t*>(&dst);
    SDL_assert(byte < 2);

#if defined(THEXTECH_BIG_ENDIAN)
    in[1 - byte] = data;
#else // normal little endian
    in[byte] = data;
#endif
}


SDL_FORCE_INLINE uint8_t getByteX86(const num_t &src, size_t byte)
{
#ifdef THEXTECH_FIXED_POINT
    return 0;
#endif

    const auto *in = reinterpret_cast<const uint8_t*>(&src);
    SDL_assert(byte < 8);
#if defined(THEXTECH_BIG_ENDIAN)
    return in[7 - byte];
#elif defined(ARM_BIDI_ENDIAN) // some old devices
    byte += (byte < 4) ? +4 : -4;
    return in[byte];
#else // normal little endian
    return in[byte];
#endif
}

SDL_FORCE_INLINE uint8_t getByteX86(const numf_t &src, size_t byte)
{
#ifdef THEXTECH_FIXED_POINT
    return 0;
#endif

    const auto *in = reinterpret_cast<const uint8_t*>(&src);
    SDL_assert(byte < 4);
#if defined(THEXTECH_BIG_ENDIAN)
    return in[3 - byte];
#else // normal little endian
    return in[byte];
#endif
}

SDL_FORCE_INLINE uint8_t getByteX86(const int16_t &src, size_t byte)
{
    const auto *in = reinterpret_cast<const uint8_t*>(&src);
    SDL_assert(byte < 2);
#if defined(THEXTECH_BIG_ENDIAN)
    return in[1 - byte];
#else // normal little endian
    return in[byte];
#endif
}


/*----------------------------------------------*
 *          Write memory value                  *
 *----------------------------------------------*/

SDL_FORCE_INLINE void memToValue(num_t &target, num_t value, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        target =static_cast<num_t>(f2i_cast<uint8_t>(value));
        break;
    case FT_WORD:
        target =static_cast<num_t>(static_cast<int16_t>(f2i_cast<uint16_t>(value)));
        break;
    case FT_DWORD:
        target =static_cast<num_t>(f2i_cast<int32_t>(value));
        break;
    case FT_FLOAT:
        target =static_cast<num_t>(static_cast<numf_t>(value));
        break;
    case FT_DFLOAT:
        target = value;
        break;
    default:
        break; // Don't change
    }
}

SDL_FORCE_INLINE void memToValue(numf_t &target, num_t value, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        target = static_cast<numf_t>(f2i_cast<uint8_t>(value));
        break;
    case FT_WORD:
        target = static_cast<numf_t>(static_cast<int16_t>(f2i_cast<uint16_t>(value)));
        break;
    case FT_DWORD:
        target = static_cast<numf_t>(f2i_cast<int32_t>(value));
        break;
    case FT_FLOAT:
        target = static_cast<numf_t>(value);
        break;
    case FT_DFLOAT:
        target = static_cast<numf_t>(value);
        break;
    default: //Don't change
        break;
    }
}

SDL_FORCE_INLINE void memToValue(int &target, num_t value, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        target = static_cast<int32_t>(f2i_cast<uint8_t>(value));
        break;
    case FT_WORD:
        target = static_cast<int32_t>(static_cast<int16_t>(f2i_cast<uint16_t>(value)));
        break;
    case FT_DWORD:
    case FT_DFLOAT:
        target = static_cast<int32_t>(value);
        break;
    case FT_FLOAT:
        target = static_cast<int32_t>(f2i_cast<tempf_t>(value));
        break;
//    case FT_DFLOAT: // United with FT_DWORD
//        target = static_cast<int32_t>(value);
//        break;
    default: //Don't change
        break;
    }
}

SDL_FORCE_INLINE void memToValue(short &target, num_t value, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        target = static_cast<int16_t>(f2i_cast<uint8_t>(value));
        break;
    case FT_WORD:
        target = static_cast<int16_t>(static_cast<int16_t>(f2i_cast<uint16_t>(value)));
        break;
    case FT_DWORD:
    case FT_DFLOAT:
        target = static_cast<int16_t>(value);
        break;
    case FT_FLOAT:
        target = static_cast<int16_t>(f2i_cast<tempf_t>(value));
        break;
//    case FT_DFLOAT: // United with FT_DWORD
//        target = static_cast<int32_t>(value);
//        break;
    default: //Don't change
        break;
    }
}

SDL_FORCE_INLINE void memToValue(uint8_t &target, num_t value, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        target = static_cast<uint8_t>(f2i_cast<uint8_t>(value));
        break;
    case FT_WORD:
        target = static_cast<uint8_t>(static_cast<int16_t>(f2i_cast<uint16_t>(value)));
        break;
    case FT_DWORD:
    case FT_DFLOAT:
        target = static_cast<uint8_t>(value);
        break;
    case FT_FLOAT:
        target = static_cast<uint8_t>(f2i_cast<tempf_t>(value));
        break;
//    case FT_DFLOAT: // United with FT_DWORD
//        target = static_cast<int32_t>(value);
//        break;
    default: //Don't change
        break;
    }
}

SDL_FORCE_INLINE void memToValue(bool &target, num_t value, FIELDTYPE ftype)
{
    UNUSED(ftype);
    target = (value != 0);
}


/*----------------------------------------------*
 *           Read memory value                  *
 *----------------------------------------------*/

SDL_FORCE_INLINE num_t valueToMem(const num_t &source, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        return static_cast<num_t>(static_cast<uint8_t>(source));
    case FT_WORD:
        return static_cast<num_t>(static_cast<int16_t>(static_cast<uint16_t>(source)));
    case FT_DWORD:
        return static_cast<num_t>(static_cast<int32_t>(source));
    case FT_FLOAT:
        return static_cast<num_t>(static_cast<numf_t>(source));
    default:
    case FT_DFLOAT:
        return source;
    }
}

SDL_FORCE_INLINE num_t valueToMem(const numf_t &source, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        return static_cast<num_t>(static_cast<uint8_t>(source));
    case FT_WORD:
        return static_cast<num_t>(static_cast<int16_t>(static_cast<uint16_t>(source)));
    case FT_DWORD:
        return static_cast<num_t>(static_cast<int32_t>(source));
    default:
    case FT_FLOAT:
    case FT_DFLOAT:
        return static_cast<num_t>(source);
    }
}

SDL_FORCE_INLINE num_t valueToMem(const int &source, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        return static_cast<num_t>(static_cast<uint8_t>(source));
    case FT_WORD:
        return static_cast<num_t>(static_cast<int16_t>(source));
    default:
    case FT_DWORD:
        return static_cast<num_t>(source);
    case FT_FLOAT:
        return static_cast<num_t>(static_cast<numf_t>(source));
    case FT_DFLOAT:
        return static_cast<num_t>(source);
    }
}

SDL_FORCE_INLINE num_t valueToMem(const short &source, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        return static_cast<num_t>(static_cast<uint8_t>(source));
    case FT_WORD:
        return static_cast<num_t>(static_cast<int16_t>(source));
    default:
    case FT_DWORD:
        return static_cast<num_t>(source);
    case FT_FLOAT:
        return static_cast<num_t>(static_cast<numf_t>(source));
    case FT_DFLOAT:
        return static_cast<num_t>(source);
    }
}

SDL_FORCE_INLINE num_t valueToMem(const uint8_t &source, FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        return static_cast<num_t>(static_cast<uint8_t>(source));
    case FT_WORD:
        return static_cast<num_t>(static_cast<int16_t>(source));
    default:
    case FT_DWORD:
        return static_cast<num_t>(source);
    case FT_FLOAT:
        return static_cast<num_t>(static_cast<numf_t>(source));
    case FT_DFLOAT:
        return static_cast<num_t>(source);
    }
}

SDL_FORCE_INLINE num_t valueToMem(const bool &source, FIELDTYPE ftype)
{
    UNUSED(ftype);
    return source ? 0xFFFF : 0;
}


/*!
 * \brief Convert field type into string
 * \param ftype Field type
 * \return Human-readable string
 */
static const char *FieldtypeToStr(FIELDTYPE ftype)
{
    switch(ftype)
    {
    case FT_BYTE:
        return "Uint8";
    case FT_WORD:
        return "SInt16";
    case FT_DWORD:
        return "SInt32";
    case FT_FLOAT:
        return "Float";
    case FT_DFLOAT:
        return "Double";
    default:
        return "<Invalid>";
    }
}



/*!
 * \brief Global memory emulator
 */
class SMBXMemoryEmulator
{
    std::unordered_map<size_t, num_t *> m_df;
    std::unordered_map<size_t, numf_t *>  m_ff;
    std::unordered_map<size_t, short *>  m_i16f;
    std::unordered_map<size_t, int *>    m_i32f;
    std::unordered_map<size_t, bool *>   m_bf;
    std::unordered_map<size_t, std::string *>   m_sf;

    typedef std::function<num_t(FIELDTYPE)> Getter;
    typedef std::function<void(num_t,FIELDTYPE)> Setter;
    std::unordered_map<size_t, std::pair<Getter, Setter>> m_lff;

    typedef std::function<std::string()> StrGetter;
    typedef std::function<void(const std::string&)> StrSetter;
    std::unordered_map<size_t, std::pair<StrGetter, StrSetter>> m_sff;

    enum ValueType
    {
        VT_UNKNOWN = 0,
        VT_DOUBLE,
        VT_FLOAT,
        VT_INT16,
        VT_INT32,
        VT_BOOL,
        VT_STRING,
        VT_LAMBDA,
        VT_STRLAMBDA
    };

    std::unordered_map<int, ValueType> m_type;

    void insert(size_t address, short *field)
    {
        m_i16f.insert({address, field});
        m_type.insert({address, VT_INT16});
    }

    void insert(size_t address, int *field)
    {
        m_i32f.insert({address, field});
        m_type.insert({address, VT_INT32});
    }

    void insert(size_t address, num_t *field)
    {
        m_df.insert({address, field});
        m_type.insert({address, VT_DOUBLE});
    }

    void insert(size_t address, numf_t *field)
    {
        m_ff.insert({address, field});
        m_type.insert({address, VT_FLOAT});
    }

    void insert(size_t address, bool *field)
    {
        m_bf.insert({address, field});
        m_type.insert({address, VT_BOOL});
    }

    void insert(size_t address, std::string *field)
    {
        m_sf.insert({address, field});
        m_type.insert({address, VT_STRING});
    }

    void insert(size_t address, Getter g, Setter s)
    {
        m_lff.insert({address, {g, s}});
        m_type.insert({address, VT_LAMBDA});
    }

    void insert(size_t address, StrGetter g, StrSetter s)
    {
        m_sff.insert({address, {g, s}});
        m_type.insert({address, VT_STRLAMBDA});
    }

public:
    SMBXMemoryEmulator() noexcept
    {
        buildTable();
    }

    void buildTable()
    {
        insert(0x00B2504C, &TakeScreen);
        insert(0x00B250D6, &numLocked);
        insert(0x00B250E2, // Pause menu visible
            [](FIELDTYPE ftype)->num_t
            {
                bool tmp = (GamePaused != PauseCode::None);
                return valueToMem(tmp, ftype);
            },
            [](num_t in, FIELDTYPE ftype)->void
            {
                // FIXME: Verify this, if it needs to be written, try to work around this
                pLogWarning("Attempt to write the read-only field at 0x00B250E2 "
                            "(GamePaused) with value %d as %s", (int)in, FieldtypeToStr(ftype));
            }
        );
        insert(0x00B25134, &LevelEditor);

        insert(0x00B251E0, &numStars); // HUD star count
        insert(0x00B25700, &numWater);

        insert(0x00B25724, &StartLevel);
        insert(0x00B25728, &NoMap);
        insert(0x00B2572A, &RestartLevel);

        // should all be read-only
        insert(0x00B257A4, &numTiles);
        insert(0x00B257A6, &numScenes);
        insert(0x00B258E0, &numWorldPaths);
        insert(0x00B258E2, &numWarps);
        insert(0x00B25956, &numBlock);
        insert(0x00B25958, &numBackground);
        insert(0x00B2595A, &numNPCs); // NPC count
        insert(0x00B2595E, &numPlayers); // Player Count
        insert(0x00B25960, &numWorldLevels);
        insert(0x00B25980, &numWorldMusic);

        insert(0x00B2C5A8, &Coins); // HUD coins count
        insert(0x00B2C5AC, // HUD lives count
            [](FIELDTYPE ftype)->num_t
            {
                int tmp = g_config.modern_lives_system ? g_100s : Lives;
                if(tmp < 0)
                    tmp = 0;
                if(tmp > 99)
                    tmp = 99;
                return valueToMem(tmp, ftype);
            },
            [](num_t in, FIELDTYPE ftype)->void
            {
                if(!g_config.modern_lives_system)
                    memToValue(Lives, in, ftype);

                int old = g_100s;
                if(old < 0)
                    old = 0;
                if(old > 99)
                    old = 99;

                int out = old;
                memToValue(out, in, ftype);

                g_100s += out - old;
            }
        );  // lives now replaced by g_100s

        insert(0x00B2C624, &WorldName);

        insert(0x00B2C62C, &PSwitchTime); // P-Switch Timer
        insert(0x00B2C62E, &PSwitchStop); // Stopwatch Timer
        insert(0x00B2C630, &PSwitchPlayer); // P-Switch/Stopwatch Player

        // FIXME: properly report as modified when set
        insert(0x00B2C684, &g_config.enable_frameskip.m_value);

        insert(0x00B2C6DC, &Physics.PlayerJumpHeight);
        insert(0x00B2C6DE, &Physics.PlayerBlockJumpHeight);
        insert(0x00B2C6E0, &Physics.PlayerHeadJumpHeight);
        insert(0x00B2C6E2, &Physics.PlayerNPCJumpHeight);
        insert(0x00B2C6E4, &Physics.PlayerSpringJumpHeight);
        insert(0x00B2C6E8, &Physics.PlayerJumpVelocity);
        insert(0x00B2C6EC, &Physics.PlayerRunSpeed);
        insert(0x00B2C6F0, &Physics.PlayerWalkSpeed);
        insert(0x00B2C6F4, &Physics.PlayerTerminalVelocity);
        insert(0x00B2C6F8, &Physics.PlayerGravity);
        insert(0x00B2C860, &Physics.NPCShellSpeed);
        insert(0x00B2C864, &Physics.NPCShellSpeedY);
        insert(0x00B2C868, &Physics.NPCWalkingSpeed);
        insert(0x00B2C86C, &Physics.NPCWalkingOnSpeed);
        insert(0x00B2C870, &Physics.NPCMushroomSpeed);
        insert(0x00B2C874, &Physics.NPCGravity);
        insert(0x00B2C878, &Physics.NPCGravityReal);
        insert(0x00B2C87C, &Physics.NPCPSwitch); // P-Switch/Stopwatch Length

        insert(0x00B2C880, &MenuCursor); // Current menu choice
        insert(0x00B2C882, &MenuMode); // Current menu mode

        // insert(0x00B2C884, ???}; // Key Released!!!
        // insert(0x00B2C894, &BlocksSorted); // removed by block quadtree
        insert(0x00B2C894,
            [](FIELDTYPE ftype)->num_t
            {
                bool ret = true;
                return valueToMem(ret, ftype);
            },
            [](num_t in, FIELDTYPE ftype)->void
            {
                pLogWarning("Attempt to write the read-only field at 0x00B2C894 "
                            "(BlocksSorted) with value %d as %s", (int)in, FieldtypeToStr(ftype));
            }
        );

        insert(0x00B2C896, &SingleCoop);
        insert(0x00B2C898,
            []()->std::string
            {
                D_pLogDebugNA("Attempt to read unsupported field at 0x00B2C898 (cheats buffer)");
                return std::string();
            },
            [](const std::string &in)->void
            {
                cheats_setBuffer(in, true);
            }
        );

        insert(0x00B2C89C, &GameOutro);
        insert(0x00B2C8A0, &CreditChop);
        insert(0x00B2C8A4, &EndCredits);

        insert(0x00B2C8A6, &curStars);
        // insert(0x00B2C8A8, &maxStars);

        insert(0x00B2C8AA, &ShadowMode);
        insert(0x00B2C8AC, &MultiHop);
        insert(0x00B2C8AE, &SuperSpeed);
        insert(0x00B2C8B0, &WalkAnywhere);
        insert(0x00B2C8B2, &FlyForever);
        insert(0x00B2C8B4, &FreezeNPCs);
        insert(0x00B2C8B6, &CaptainN);
        insert(0x00B2C8B8, &FlameThrower);
        insert(0x00B2C8BA, &CoinMode);

        // FIXME: properly report as modified when set
        insert(0x00B2C8BE, &g_config.unlimited_framerate.m_value);
        insert(0x00B2C8C0, &GodMode);
        insert(0x00B2C8C2, &GrabAll);

        insert(0x00B2C8C4, &Cheater);

        insert(0x00B2C8E4, &Score); // HUD points count
        insert(0x00B2C906, &MaxWorldStars); // Max stars at episode

        // insert(0x00B2C908, &Debugger);

        // insert(0x00B2D6B8, &PlayerCharacter);
        // insert(0x00B2D6BA, &PlayerCharacter2);

        insert(0x00B2D6BC, &SharedCursor.X); // Mouse cursor X
        insert(0x00B2D6C4, &SharedCursor.Y); // Mouse cursor Y
        insert(0x00B2D6CC, &SharedCursor.Primary);
        insert(0x00B2D6D0, &MenuMouseRelease);
        insert(0x00B2D6D2, &SharedCursor.Move);
        insert(0x00B2D710, &numEvents);
        insert(0x00B2D740, &BattleMode);
        // was previously unlinked with sound engine status, replaced by (1) !g_config.audio_enable and (2) !g_mixerLoaded
        // If we wanted to reimplement, should probably read from (2) and write to (1), including the (expensive!) UpdateConfig hook
        // insert(0x00B2D734, &noSound);
    }

    num_t getValue(size_t address, FIELDTYPE ftype)
    {
        if(ftype == FT_INVALID)
        {
            pLogWarning("MemEmu: Requested value of invalid type: <Global> 0x%x", static_cast<unsigned>(address));
            return 0;
        }

        auto ft = m_type.find(address);
        if(ft == m_type.end())
        {
            pLogWarning("MemEmu: Unknown %s address to read: <Global> 0x%x", FieldtypeToStr(ftype), static_cast<unsigned>(address));
            return 0;
        }

        switch(ft->second)
        {
        case VT_DOUBLE:
        {
            auto dres = m_df.find(address);
            if(dres != m_df.end())
            {
                if(ftype != FT_DFLOAT)
                    pLogWarning("MemEmu: Read type missmatched at 0x%x (Double expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                return valueToMem(*dres->second, ftype);
            }
            break;
        }

        case VT_FLOAT:
        {
            auto fres = m_ff.find(address);
            if(fres != m_ff.end())
            {
                if(ftype != FT_FLOAT)
                    pLogWarning("MemEmu: Read type missmatched at 0x%x (Float expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                return valueToMem(*fres->second, ftype);
            }
            break;
        }

        case VT_INT32:
        {
            auto ires = m_i32f.find(address);
            if(ires != m_i32f.end())
            {
                if(ftype != FT_DWORD && ftype != FT_WORD)
                    pLogWarning("MemEmu: Read type missmatched at 0x%x (SInt16 or SInt32 expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                return valueToMem(*ires->second, ftype);
            }
            break;
        }

        case VT_INT16:
        {
            auto ires = m_i16f.find(address);
            if(ires != m_i16f.end())
            {
                if(ftype != FT_WORD)
                    pLogWarning("MemEmu: Read type missmatched at 0x%x (SInt16 expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                return valueToMem(*ires->second, ftype);
            }
            break;
        }

        case VT_BOOL:
        {
            auto bres = m_bf.find(address);
            if(bres != m_bf.end())
            {
                if(ftype != FT_WORD && ftype != FT_BYTE)
                    pLogWarning("MemEmu: Read type missmatched at 0x%x (Sint16 or Uint8 as boolean expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));
                return *bres->second ? 0xffff : 0x0000;
            }
            break;
        }

        case VT_LAMBDA:
        {
            auto lfres = m_lff.find(address);
            if(lfres != m_lff.end())
            {
                auto &l = lfres->second;
                return l.first(ftype);
            }
            break;
        }

        default:
            break;
        }

        return 0;
    }

    void setValue(size_t address, num_t value, FIELDTYPE ftype)
    {
        if(ftype == FT_INVALID)
        {
            pLogWarning("MemEmu: Passed value of invalid type: <Global> 0x%x", static_cast<unsigned>(address));
            return;
        }

        auto ft = m_type.find(address);
        if(ft == m_type.end())
        {
            pLogWarning("MemEmu: Unknown %s address to write: 0x%x", FieldtypeToStr(ftype), static_cast<unsigned>(address));
            return;
        }

        switch(ft->second)
        {
        case VT_DOUBLE:
        {
            auto dres = m_df.find(address);
            if(dres != m_df.end())
            {
                if(ftype != FT_DFLOAT)
                    pLogWarning("MemEmu: Write type missmatched at 0x%x (Double expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                memToValue(*dres->second, value, ftype);
                return;
            }
            break;
        }

        case VT_FLOAT:
        {
            auto fres = m_ff.find(address);
            if(fres != m_ff.end())
            {
                if(ftype != FT_FLOAT)
                    pLogWarning("MemEmu: Write type missmatched at 0x%x (Float expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                memToValue(*fres->second, value, ftype);
                return;
            }
            break;
        }

        case VT_INT32:
        {
            auto ires = m_i32f.find(address);
            if(ires != m_i32f.end())
            {
                if(ftype != FT_DWORD && ftype != FT_WORD)
                    pLogWarning("MemEmu: Write type missmatched at 0x%x (SInt16 or SInt32 expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                memToValue(*ires->second, value, ftype);
                return;
            }
            break;
        }

        case VT_INT16:
        {
            auto ires = m_i16f.find(address);
            if(ires != m_i16f.end())
            {
                if(ftype != FT_WORD)
                    pLogWarning("MemEmu: Write type missmatched at 0x%x (SInt16 expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));

                memToValue(*ires->second, value, ftype);
                return;
            }
            break;
        }

        case VT_BOOL:
        {
            auto bres = m_bf.find(address);
            if(bres != m_bf.end())
            {
                if(ftype != FT_WORD && ftype != FT_BYTE)
                    pLogWarning("MemEmu: Write type missmatched at 0x%x (Sint16 or Uint8 as boolean expected, %s actually)", static_cast<unsigned>(address), FieldtypeToStr(ftype));
                *bres->second = (value != 0);
                return;
            }
            break;
        }

        case VT_LAMBDA:
        {
            auto lfres = m_lff.find(address);
            if(lfres != m_lff.end())
            {
                auto &l = lfres->second;
                l.second(value, ftype);
            }
            break;
        }

        default:
            break;
        }
    }
};

/*!
 * \brief Per-Object memory emulator
 */
template<class T, char const *objName, size_t maxAddr>
class SMBXObjectMemoryEmulator
{
protected:

    typedef std::function<num_t(const T&,FIELDTYPE)> Getter;
    typedef std::function<void(T&,num_t,FIELDTYPE)> Setter;

    // typedef std::function<std::string(const T&)> StrGetter;
    // typedef std::function<void(T&,const std::string&)> StrSetter;

    enum ValueType : uint8_t
    {
        VT_UNKNOWN = 0,
        VT_DOUBLE,
        VT_FLOAT,
        VT_UINT8,
        VT_INT16,
        VT_INT32,
        VT_BOOL,
        VT_STRING,
        VT_BYTE_HACK,
        VT_LAMBDA,
    };

    struct Value
    {
        //! Type of field
        ValueType type = VT_UNKNOWN;
        //! Base type for byte hacking mode
        ValueType baseType = VT_UNKNOWN;
        //! Byte offset
        uint8_t offset = 0;
        //! Base address of real value
        int baseAddress = 0;

        union
        {
            //! Double-type field pointer
            num_t       T::* d = nullptr;
            //! Float-type field pointer
            numf_t      T::* f;
            //! UInt8-type field pointer (note: used exclusively for i16s converted to u8s)
            uint8_t     T::* u8;
            //! Int-type field pointer
            short       T::* i16;
            //! Int-type field pointer
            int         T::* i32;
            //! Boolean type field pointer
            bool        T::* b;
            //! String-type field pointer
            std::string T::* s;
        } field;

        //! Lambda-type field pointer
        std::pair<Getter, Setter> field_lf;
    };

    //! Basic map of addresses
    Value m_type[maxAddr];

    void insert(size_t address, uint8_t T::*field)
    {
        Value v;

        // Normal field
        v.field.u8 = field;
        v.type = VT_UINT8;
        v.baseType = VT_UINT8;
        v.offset = 0; //-V1048
        v.baseAddress = address;
        m_type[address] = v;
    }

    void insert(size_t address, short T::*field)
    {
        Value v;

        // Normal field
        v.field.i16 = field;
        v.type = VT_INT16;
        v.baseType = VT_INT16;
        v.offset = 0; //-V1048
        v.baseAddress = address;
        m_type[address] = v;

        // Byte hack fields
        v.type = VT_BYTE_HACK;
        for(int i = 0; i < 2; ++i)
        {
            v.offset = i;
            if(i > 0)
                m_type[address + i] = v;
        }
    }

    void insert(size_t address, int T::*field)
    {
        Value v;

        // Normal field
        v.field.i32 = field;
        v.type = VT_INT32;
        v.baseType = VT_INT32;
        v.offset = 0; //-V1048
        v.baseAddress = address;
        m_type[address] = v;

        // Byte hack fields
        v.type = VT_BYTE_HACK;
        for(int i = 0; i < 2; ++i)
        {
            v.offset = i;
            if(i > 0)
                m_type[address + i] = v;
        }
    }

    void insert(size_t address, num_t T::*field)
    {
        Value v;

        // Normal field
        v.field.d = field;
        v.type = VT_DOUBLE;
        v.baseType = VT_DOUBLE;
        v.offset = 0;
        v.baseAddress = address;
        m_type[address] = v;

        // Byte hack fields
        v.type = VT_BYTE_HACK;
        for(int i = 0; i < 8; ++i)
        {
            v.offset = i;
            if(i > 0)
                m_type[address + i] = v;
        }
    }

    void insert(size_t address, numf_t T::*field)
    {
        Value v;

        // Normal field
        v.field.f = field;
        v.type = VT_FLOAT;
        v.baseType = VT_FLOAT;
        v.offset = 0;
        v.baseAddress = address;
        m_type[address] = v;

        // Byte hack fields
        v.type = VT_BYTE_HACK;
        for(int i = 0; i < 4; ++i)
        {
            v.offset = i;
            if(i > 0)
                m_type[address + i] = v;
        }
    }

    void insert(size_t address, bool T::*field)
    {
        Value v;

        // Normal field
        v.field.b = field;
        v.type = VT_BOOL;
        v.baseType = VT_BOOL;
        v.offset = 0;
        v.baseAddress = address;
        m_type[address] = v;
    }

    void insert(size_t address, std::string T::*field)
    {
        Value v;

        // Normal field
        v.field.s = field; // -V820 // False positive, it's a pointer, not a std::string
        v.type = VT_STRING;
        v.baseType = VT_STRING;
        v.offset = 0;
        v.baseAddress = address;
        m_type[address] = v;
    }

    void insert(size_t address, Getter g, Setter s)
    {
        Value v;

        // Normal field
        v.field_lf = {g, s};
        v.type = VT_LAMBDA;
        v.baseType = VT_LAMBDA;
        v.offset = 0;
        v.baseAddress = address;
        m_type[address] = v;
    }

public:
    SMBXObjectMemoryEmulator() noexcept
    {}

    virtual num_t getValue(T *obj, size_t address, FIELDTYPE ftype)
    {
        Value *t = nullptr;

        if(address >= maxAddr)
        {
            pLogWarning("MemEmu: Requested value of out-of-range address: %s 0x%x", objName, static_cast<unsigned>(address));
            return 0;
        }

        if(ftype == FT_INVALID)
        {
            pLogWarning("MemEmu: Requested value of invalid type: %s 0x%x", objName, static_cast<unsigned>(address));
            return 0;
        }

        t = &m_type[address];
        auto vtype = t->type;

        if(ftype == FT_BYTE) // byte hacking
        {
            if(vtype != VT_BOOL && vtype != VT_UINT8 && vtype != VT_UNKNOWN)
                vtype = VT_BYTE_HACK;
        }

        if(vtype == VT_UNKNOWN)
        {
            pLogWarning("MemEmu: Unknown %s::%s address to read: 0x%x", objName, FieldtypeToStr(ftype), static_cast<unsigned>(address));
            return 0;
        }

        switch(vtype)
        {
        case VT_DOUBLE:
        {
            SDL_assert(t->field.d);
            if(ftype != FT_DFLOAT)
                pLogWarning("MemEmu: Read type missmatched at %s 0x%x (Double expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            return valueToMem(obj->*(t->field.d), ftype);
        }

        case VT_FLOAT:
        {
            SDL_assert(t->field.f);
            if(ftype != FT_FLOAT)
                pLogWarning("MemEmu: Read type missmatched at %s 0x%x (Float expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            return valueToMem(obj->*(t->field.f), ftype);
        }

        case VT_INT32:
        {
            SDL_assert(t->field.i32);
            if(ftype != FT_DWORD && ftype != FT_WORD)
                pLogWarning("MemEmu: Read type missmatched at %s 0x%x (SInt16 or SInt32 expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            return valueToMem(obj->*(t->field.i32), ftype);
        }

        case VT_INT16:
        {
            SDL_assert(t->field.i16);
            if(ftype != FT_WORD)
                pLogWarning("MemEmu: Read type missmatched at %s 0x%x (SInt16 expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            return valueToMem(obj->*(t->field.i16), ftype);
        }

        case VT_UINT8:
        {
            SDL_assert(t->field.u8);
            if(ftype != FT_WORD)
                pLogWarning("MemEmu: Read type missmatched at %s 0x%x (SInt16 expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            return valueToMem(obj->*(t->field.u8), ftype);
        }

        case VT_BOOL:
        {
            SDL_assert(t->field.b);
            if(ftype != FT_WORD && ftype != FT_BYTE)
                pLogWarning("MemEmu: Read type missmatched at %s 0x%x (Sint16 or Uint8 as boolean expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            return valueToMem(obj->*(t->field.b), ftype);
        }

        case VT_LAMBDA:
        {
            return t->field_lf.first(*obj, ftype);
        }

        case VT_BYTE_HACK:
        {
            switch(t->baseType)
            {
            case VT_DOUBLE:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_DOUBLE && bt.field.d);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Read type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                return (num_t)getByteX86(obj->*(bt.field.d), t->offset);
            }

            case VT_FLOAT:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_FLOAT && bt.field.f);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Read type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                return (num_t)getByteX86(obj->*(bt.field.f), t->offset);
            }

            case VT_INT16:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_INT16 && bt.field.i16);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Read type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                int16_t s = static_cast<int16_t>(obj->*(bt.field.i16));
                return (num_t)getByteX86(s, t->offset);
            }

            case VT_INT32:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_INT32 && bt.field.i32);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Read type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                int16_t s = static_cast<int16_t>(obj->*(bt.field.i32));
                return (num_t)getByteX86(s, t->offset);
            }

            default:
                break;
            }

            break;
        }

        default:
            break;
        }

        return 0;
    }

    virtual void setValue(T *obj, size_t address, num_t value, FIELDTYPE ftype)
    {
        Value *t = nullptr;

        if(address >= maxAddr)
        {
            pLogWarning("MemEmu: Requested value of out-of-range address: %s 0x%x", objName, static_cast<unsigned>(address));
            return;
        }

        if(ftype == FT_INVALID)
        {
            pLogWarning("MemEmu: Passed value of invalid type: %s 0x%x", objName, static_cast<unsigned>(address));
            return;
        }

        t = &m_type[address];
        auto vtype = t->type;

        if(ftype == FT_BYTE) // byte hacking
        {
            if(vtype != VT_BOOL && vtype != VT_UINT8 && vtype != VT_UNKNOWN)
                vtype = VT_BYTE_HACK;
        }

        if(vtype == VT_UNKNOWN)
        {
            pLogWarning("MemEmu: Unknown %s::%s address to write: 0x%x", objName, FieldtypeToStr(ftype), static_cast<unsigned>(address));
            return;
        }

        switch(vtype)
        {
        case VT_DOUBLE:
        {
            SDL_assert(t->field.d);
            if(ftype != FT_DFLOAT)
                pLogWarning("MemEmu: Write type missmatched at %s 0x%x (Double expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            memToValue(obj->*(t->field.d), value, ftype);
            return;
        }

        case VT_FLOAT:
        {
            SDL_assert(t->field.f);
            if(ftype != FT_FLOAT)
                pLogWarning("MemEmu: Write type missmatched at %s 0x%x (Float expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            memToValue(obj->*(t->field.f), value, ftype);
            return;
        }

        case VT_INT32:
        {
            SDL_assert(t->field.i32);
            if(ftype != FT_DWORD && ftype != FT_WORD)
                pLogWarning("MemEmu: Write type missmatched at %s 0x%x (SInt16 or SInt32 expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            memToValue(obj->*(t->field.i32), value, ftype);
            return;
        }

        case VT_INT16:
        {
            SDL_assert(t->field.i16);
            if(ftype != FT_WORD)
                pLogWarning("MemEmu: Write type missmatched at %s 0x%x (SInt16 expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            memToValue(obj->*(t->field.i16), value, ftype);
            return;
        }

        case VT_UINT8:
        {
            SDL_assert(t->field.u8);
            if(ftype != FT_WORD)
                pLogWarning("MemEmu: Write type missmatched at %s 0x%x (SInt16 expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            memToValue(obj->*(t->field.u8), value, ftype);
            return;
        }

        case VT_BOOL:
        {
            SDL_assert(t->field.b);
            if(ftype != FT_WORD && ftype != FT_BYTE)
                pLogWarning("MemEmu: Write type missmatched at %s 0x%x (Sint16 or Uint8 as boolean expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
            memToValue(obj->*(t->field.b), value, ftype);
            return;
        }

        case VT_LAMBDA:
        {
            t->field_lf.second(*obj, value, ftype);
            return;
        }

        case VT_BYTE_HACK:
        {
            switch(t->baseType)
            {
            case VT_DOUBLE:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_DOUBLE && bt.field.d);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Write type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                modifyByteX86(obj->*(bt.field.d), t->offset, f2i_cast<uint8_t>(value));
                return;
            }

            case VT_FLOAT:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_FLOAT && bt.field.f);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Write type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                modifyByteX86(obj->*(bt.field.f), t->offset, f2i_cast<uint8_t>(value));
                return;
            }

            case VT_INT16:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_INT16 && bt.field.i16);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Write type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                int16_t s = static_cast<int16_t>(obj->*(bt.field.i16));
                modifyByteX86(s, t->offset, f2i_cast<uint8_t>(value));
                obj->*(bt.field.i16) = static_cast<int>(s);
                return;
            }

            case VT_INT32:
            {
                auto &bt = m_type[t->baseAddress];
                SDL_assert(bt.type == VT_INT32 && bt.field.i32);
                if(ftype != FT_BYTE)
                    pLogWarning("MemEmu: Write type missmatched at %s 0x%x (byte expected, %s actually)", objName, static_cast<unsigned>(address), FieldtypeToStr(ftype));
                int16_t s = static_cast<int16_t>(obj->*(bt.field.i32));
                modifyByteX86(s, t->offset, f2i_cast<uint8_t>(value));
                obj->*(bt.field.i32) = static_cast<int>(s);
                return;
            }

            default:
                break;
            }

            break;
        }

        default:
            break;
        }
    }
};

static constexpr char location_t_name[] = "Location_t";
typedef SMBXObjectMemoryEmulator<Location_t, location_t_name, 0x31> LocationParent;
class LocationMemory final : public LocationParent
{
public:
    LocationMemory() noexcept : LocationParent()
    {
        buildTable();
    }

    void buildTable()
    {
        insert(0x00, &Location_t::X);
        insert(0x08, &Location_t::Y);
        insert(0x10, &Location_t::Height);
        insert(0x18, &Location_t::Width);
        insert(0x20, &Location_t::SpeedX);
        insert(0x28, &Location_t::SpeedY);
    }
};

static constexpr char speedless_location_t_name[] = "SpeedlessLocation_t";
typedef SMBXObjectMemoryEmulator<SpeedlessLocation_t, speedless_location_t_name, 0x20> SpeedlessLocationParent;
class SpeedlessLocationMemory final : public SpeedlessLocationParent
{
public:
    SpeedlessLocationMemory() noexcept : SpeedlessLocationParent()
    {
        buildTable();
    }

    void buildTable()
    {
        insert(0x00, &SpeedlessLocation_t::X);
        insert(0x08, &SpeedlessLocation_t::Y);
        insert(0x10, &SpeedlessLocation_t::Height);
        insert(0x18, &SpeedlessLocation_t::Width);
    }
};


static constexpr char controls_t_name[] = "Controls_t";
typedef SMBXObjectMemoryEmulator<Controls_t, controls_t_name, 0x16> ControlsParent;
class ControlsMemory final : public ControlsParent
{
public:
    ControlsMemory() noexcept :  ControlsParent()
    {
        buildTable();
    }

    void buildTable()
    {
        insert(0x00, &Controls_t::Up);
        insert(0x02, &Controls_t::Down);
        insert(0x04, &Controls_t::Left);
        insert(0x06, &Controls_t::Right);
        insert(0x08, &Controls_t::Jump);
        insert(0x0A, &Controls_t::AltJump);
        insert(0x0C, &Controls_t::Run);
        insert(0x0E, &Controls_t::AltRun);
        insert(0x10, &Controls_t::Drop);
        insert(0x12, &Controls_t::Start);
    }
};

static ControlsMemory s_conMem;
static LocationMemory s_locMem;
static SpeedlessLocationMemory s_spLocMem;


static constexpr char playere_t_name[] = "Player_t";
typedef SMBXObjectMemoryEmulator<Player_t, playere_t_name, 0x186> PlayerParent;
class PlayerMemory final : public PlayerParent
{
public:
    PlayerMemory() noexcept : PlayerParent()
    {
        buildTable();
    }

    void buildTable()
    {
        insert(0x00000000, &Player_t::DoubleJump);
        insert(0x00000002, &Player_t::FlySparks);
        insert(0x00000004, &Player_t::Driving);
        insert(0x00000006, &Player_t::Quicksand);
        insert(0x00000008, &Player_t::Bombs);
        insert(0x0000000a, &Player_t::Slippy);

        insert(0x0000000c, &Player_t::Fairy);
        insert(0x0000000e, &Player_t::FairyCD);
        insert(0x00000010, &Player_t::FairyTime);
        insert(0x00000012, &Player_t::HasKey);
        insert(0x00000014, &Player_t::SwordPoke);
        insert(0x00000016, &Player_t::Hearts);

        insert(0x00000018, &Player_t::CanFloat);
        insert(0x0000001a, &Player_t::FloatRelease);
        insert(0x0000001c, &Player_t::FloatTime);
        insert(0x00000020, &Player_t::FloatSpeed);
        insert(0x00000024, &Player_t::FloatDir);
        insert(0x00000026, &Player_t::GrabTime);
        insert(0x00000028, &Player_t::GrabSpeed);
        insert(0x0000002c, &Player_t::VineNPC);

        insert(0x00000034, &Player_t::Wet);
        insert(0x00000036, &Player_t::WetFrame);
        insert(0x00000038, &Player_t::SwimCount);
        insert(0x0000003a, &Player_t::NoGravity);
        insert(0x0000003c, &Player_t::Slide);
        insert(0x0000003e, &Player_t::SlideKill);
        insert(0x00000040, &Player_t::Vine);
        // insert(0x00000042, &Player_t::NoShellKick);
        insert(0x00000044, &Player_t::ShellSurf);
        static_assert(sizeof(Player_t::StateNPC) == sizeof(vbint_t), "underlying type of Player_t::StateNPC must be vbint_t");
        insert(0x00000046, reinterpret_cast<vbint_t Player_t::*>(&Player_t::StateNPC));
        insert(0x00000048, &Player_t::Slope);
        insert(0x0000004a, &Player_t::Stoned);
        insert(0x0000004c, &Player_t::StonedCD);
        insert(0x0000004e, &Player_t::StonedTime);
        insert(0x00000050, &Player_t::SpinJump);
        insert(0x00000052, &Player_t::SpinFrame);
        insert(0x00000054, &Player_t::SpinFireDir);
        insert(0x00000056, &Player_t::Multiplier);
        insert(0x00000058, &Player_t::SlideCounter);
        insert(0x0000005a, &Player_t::ShowWarp);
        // pound state handled below
        // insert(0x0000005c, &Player_t::GroundPound);
        // insert(0x0000005e, &Player_t::GroundPound2);
        // insert(0x00000060, &Player_t::CanPound);
        insert(0x00000062, &Player_t::ForceHold);
        insert(0x00000064, &Player_t::YoshiYellow);
        insert(0x00000066, &Player_t::YoshiBlue);
        insert(0x00000068, &Player_t::YoshiRed);
        insert(0x0000006a, &Player_t::YoshiWingsFrame);
        insert(0x0000006c, &Player_t::YoshiWingsFrameCount);
        insert(0x0000006e, &Player_t::YoshiTX);
        insert(0x00000070, &Player_t::YoshiTY);
        insert(0x00000072, &Player_t::YoshiTFrame);
        insert(0x00000074, &Player_t::YoshiTFrameCount);
        insert(0x00000076, &Player_t::YoshiBX);
        insert(0x00000078, &Player_t::YoshiBY);
        insert(0x0000007a, &Player_t::YoshiBFrame);
        insert(0x0000007c, &Player_t::YoshiBFrameCount);
        //Location_t YoshiTongue; (Between 0x80 and 0xB0)
        // insert(0x000000b0, &Player_t::YoshiTongueX);
        insert(0x000000b4, &Player_t::YoshiTongueLength);
        insert(0x000000b6, &Player_t::YoshiTonugeBool);
        insert(0x000000b8, &Player_t::YoshiNPC);
        insert(0x000000ba, &Player_t::YoshiPlayer);
        insert(0x000000bc, &Player_t::Dismount);
        // insert(0x000000be, &Player_t::NoPlayerCol);
        //Location_t Location; (Between 0xC0 and 0xF0)
        insert(0x000000f0, &Player_t::Character);
        //Controls_t Controls; (Between 0xF2 and 0x105)
        insert(0x00000106, &Player_t::Direction);
        insert(0x00000108, &Player_t::Mount);
        insert(0x0000010a, &Player_t::MountType);
        insert(0x0000010c, &Player_t::MountSpecial);
        insert(0x0000010e, &Player_t::MountOffsetY);
        insert(0x00000110, &Player_t::MountFrame);
        insert(0x00000112, &Player_t::State);
        insert(0x00000114, &Player_t::Frame);
        insert(0x00000118, &Player_t::FrameCount);
        insert(0x0000011c, &Player_t::Jump);
        insert(0x0000011e, &Player_t::CanJump);

        // CanAltJump -- enforce read-only if compat flag `disable-spin-jump` is set
        insert(0x00000120, // CanAltJump
            [](const Player_t& p, FIELDTYPE ftype)->num_t
            {
                return valueToMem(p.CanAltJump, ftype);
            },
            [](Player_t& p, num_t in, FIELDTYPE ftype)->void
            {
                bool temp = p.CanAltJump;
                memToValue(temp, in, ftype);
                if(!g_config.disable_spin_jump)
                    p.CanAltJump = temp;
            }
        );

        static_assert(sizeof(Player_t::Effect) == sizeof(vbint_t), "underlying type of Player_t::Effect must be vbint_t");
        insert(0x00000122, reinterpret_cast<vbint_t Player_t::*>(&Player_t::Effect));
        insert(0x00000124, &Player_t::Effect2);
        // pound state handled below
        // insert(0x0000012c, &Player_t::DuckRelease);
        insert(0x0000012e, &Player_t::Duck);
        insert(0x00000130, &Player_t::DropRelease);
        insert(0x00000132, &Player_t::StandUp);
        insert(0x00000134, &Player_t::StandUp2);
        insert(0x00000136, &Player_t::Bumped);
        insert(0x00000138, &Player_t::Bumped2);
        insert(0x0000013c, &Player_t::Dead);
        insert(0x0000013e, &Player_t::TimeToLive);
        insert(0x00000140, &Player_t::Immune);
        insert(0x00000142, &Player_t::Immune2);
        insert(0x00000144, &Player_t::ForceHitSpot3);

        // handlers below
        // insert(0x00000146, &Player_t::Pinched1);
        // insert(0x00000148, &Player_t::Pinched2);
        // insert(0x0000014a, &Player_t::Pinched3);
        // insert(0x0000014c, &Player_t::Pinched4);
        // insert(0x0000014e, &Player_t::NPCPinched);

        // insert(0x00000150, &Player_t::m2Speed);
        insert(0x00000154, &Player_t::HoldingNPC);
        insert(0x00000156, &Player_t::CanGrabNPCs);
        static_assert(sizeof(Player_t::HeldBonus) == sizeof(vbint_t), "underlying type of Player_t::HeldBonus must be vbint_t");
        insert(0x00000158, reinterpret_cast<vbint_t Player_t::*>(&Player_t::HeldBonus));
        insert(0x0000015a, &Player_t::Section);
        insert(0x0000015c, &Player_t::WarpCD);
        insert(0x0000015e, &Player_t::Warp);
        insert(0x00000160, &Player_t::FireBallCD);
        insert(0x00000162, &Player_t::FireBallCD2);
        insert(0x00000164, &Player_t::TailCount);
        // insert(0x00000168, &Player_t::RunCount);
        insert(0x0000016c, &Player_t::CanFly);
        insert(0x0000016e, &Player_t::CanFly2);
        insert(0x00000170, &Player_t::FlyCount);
        insert(0x00000172, &Player_t::RunRelease);
        insert(0x00000174, &Player_t::JumpRelease);
        insert(0x00000176, &Player_t::StandingOnNPC);
        insert(0x00000178, &Player_t::StandingOnVehiclePlr);
        insert(0x0000017a, &Player_t::UnStart);
        insert(0x0000017c, &Player_t::mountBump);
        // insert(0x00000180, &Player_t::SpeedFixY);
    }

    num_t getValue(Player_t *obj, size_t address, FIELDTYPE ftype) override
    {
        if(address >= 0x80 && address < 0xB0) // YoshiTongue
            return s_spLocMem.getValue(&obj->YoshiTongue, address - 0x80, ftype);
        else if(address >= 0xC0 && address < 0xF0) // Location
            return s_locMem.getValue(&obj->Location, address - 0xC0, ftype);
        else if(address >= 0xF2 && address < 0x106) // Controls
            return s_conMem.getValue(&obj->Controls, address - 0xF2, ftype);
        else if((address >= 0x5C && address < 0x62) || address == 0x12C) // pound state
        {
            switch(address)
            {
            case 0x5c: // GroundPound
                return valueToMem((bool)obj->GroundPound, ftype);
            case 0x5e: // GroundPound2
                return valueToMem((bool)obj->GroundPound2, ftype);
            case 0x60: // CanPound
                return valueToMem((bool)obj->CanPound, ftype);
            case 0x12C: // DuckRelease
                return valueToMem((bool)obj->DuckRelease, ftype);
            default:
                pLogWarning("MemEmu: Attempt to read player address 0x%x (invalid byte hacking)", static_cast<unsigned>(address));
                break;
            }
        }
        else if(address >= 0x146 && address < 0x150) // Pinched
        {
            switch(address)
            {
            case 0x146: // Pinched1
                return valueToMem((int)obj->Pinched.Bottom1, ftype);
            case 0x148: // Pinched2
                return valueToMem((int)obj->Pinched.Left2, ftype);
            case 0x14a: // Pinched3
                return valueToMem((int)obj->Pinched.Top3, ftype);
            case 0x14c: // Pinched4
                return valueToMem((int)obj->Pinched.Right4, ftype);
            case 0x14e: // NPCPinched
                return valueToMem((int)obj->Pinched.Moving, ftype);
            default:
                pLogWarning("MemEmu: Attempt to read player address 0x%x (invalid byte hacking)", static_cast<unsigned>(address));
                break;
            }
        }
        return PlayerParent::getValue(obj, address, ftype);
    }

    void setValue(Player_t *obj, size_t address, num_t value, FIELDTYPE ftype) override
    {
        if(address >= 0x80 && address < 0xB0) // YoshiTongue
        {
            s_spLocMem.setValue(&obj->YoshiTongue, static_cast<unsigned>(address) - 0x80, value, ftype);
            return;
        }
        else if(address >= 0xC0 && address < 0xF0) // Location
        {
            s_locMem.setValue(&obj->Location, static_cast<unsigned>(address) - 0xC0, value, ftype);
            return;
        }
        else if(address >= 0xF2 && address < 0x106) // Controls
        {
            s_conMem.setValue(&obj->Controls, static_cast<unsigned>(address) - 0xF2, value, ftype);
            return;
        }
        else if((address >= 0x5C && address < 0x62) || address == 0x12C) // pound state
        {
            bool in = false;

            memToValue(in, value, ftype);

            switch(address)
            {
            case 0x5c: // GroundPound
                obj->GroundPound = in;
                return;
            case 0x5e: // GroundPound2
                obj->GroundPound2 = in;
                return;
            case 0x60: // CanPound
                obj->CanPound = in;
                return;
            case 0x12C: // DuckRelease
                obj->DuckRelease = in;
                return;
            default:
                pLogWarning("MemEmu: Attempt to set player address 0x%x to %d (invalid byte hacking)", static_cast<unsigned>(address), (int)in);
                break;
            }
        }
        else if(address >= 0x146 && address < 0x150) // Pinched
        {
            int in = 0;

            memToValue(in, value, ftype);

            // clamp to range
            if(in < 0)
                in = 0;
            else if(in > 3)
                in = 3;

            switch(address)
            {
            case 0x146: // Pinched1
                obj->Pinched.Bottom1 = in;
                return;
            case 0x148: // Pinched2
                obj->Pinched.Left2 = in;
                return;
            case 0x14a: // Pinched3
                obj->Pinched.Top3 = in;
                return;
            case 0x14c: // Pinched4
                obj->Pinched.Right4 = in;
                return;
            case 0x14e: // NPCPinched
                obj->Pinched.Moving = in;

                obj->Pinched.MovingLR = (bool)in;
                obj->Pinched.MovingUD = (bool)in;

                return;
            default:
                pLogWarning("MemEmu: Attempt to set player address 0x%x to %d (invalid byte hacking)", static_cast<unsigned>(address), in);
                break;
            }
        }

        PlayerParent::setValue(obj, address, value, ftype);
    }
};

static constexpr char npc_t_name[] = "NPC_t";
typedef SMBXObjectMemoryEmulator<NPC_t, npc_t_name, 0x160> NpcParent;
class NPCMemory final : public NpcParent
{
public:
    NPCMemory() noexcept : NpcParent()
    {
        buildTable();
    }

    void buildTable()
    {
        // Note: strings that became indices have been blocked out temporarily
        // (mememu does not support setting strings yet)

        // insert(0x00000000, &NPC_t::AttLayer);
        // insert(0x00000004, &NPC_t::Quicksand); // turned into bitfield, unused in Analogue Funk
        // insert(0x00000006, &NPC_t::RespawnDelay); // only usable in Battle Mode
        insert(0x00000008, // Bouce
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Bouce, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                bool temp = n.Bouce;
                memToValue(temp, in, ftype);
                n.Bouce = temp;
            }
        );

        // handler below
        // insert(0x0000000a, &NPC_t::Pinched1);
        // insert(0x0000000c, &NPC_t::Pinched2);
        // insert(0x0000000e, &NPC_t::Pinched3);
        // insert(0x00000010, &NPC_t::Pinched4);
        // insert(0x00000012, &NPC_t::MovingPinched);

        // insert(0x00000014, &NPC_t::NetTimeout); // unused since SMBX64, now removed
        insert(0x00000018, // RealSpeedX
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.RealSpeedX, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                memToValue(n.RealSpeedX, in, ftype);
                NPCQueues::Unchecked.push_back(n);
            }
        );
        insert(0x0000001c, &NPC_t::Wet);
        // insert(0x0000001e, &NPC_t::Settings); // unused since SMBX64, now removed
        insert(0x00000020, // NoLavaSplash
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.NoLavaSplash, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                bool temp = n.NoLavaSplash;
                memToValue(temp, in, ftype);
                n.NoLavaSplash = temp;
            }
        );
        insert(0x00000022, &NPC_t::Slope);
        insert(0x00000024, // Multiplier
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Multiplier, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                memToValue(n.Multiplier, in, ftype);
                NPCQueues::Unchecked.push_back(n);
            }
        );
        insert(0x00000026, // TailCD
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.TailCD, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                memToValue(n.TailCD, in, ftype);
                NPCQueues::Unchecked.push_back(n);
            }
        );
        // insert(0x00000028, &NPC_t::Shadow); // turned into bitfield, unused in Analogue Funk
        // insert(0x0000002c, &NPC_t::TriggerActivate);
        // insert(0x00000030, &NPC_t::TriggerDeath);
        // insert(0x00000034, &NPC_t::TriggerTalk);
        // insert(0x00000038, &NPC_t::TriggerLast);
        // insert(0x0000003c, &NPC_t::Layer);
        insert(0x00000040, &NPC_t::Hidden);
        insert(0x00000042, // Legacy
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Legacy, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                bool temp = n.Legacy;
                memToValue(temp, in, ftype);
                n.Legacy = temp;
            }
        );
        insert(0x00000044, // Chat
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Chat, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                bool temp = n.Chat;
                memToValue(temp, in, ftype);
                n.Chat = temp;
            }
        );
        insert(0x00000046, &NPC_t::Inert);
        // insert(0x00000048, &NPC_t::Stuck); // turned into bitfield, unused in Analogue Funk
        // insert(0x0000004a, &NPC_t::DefaultStuck); // turned into bitfield, unused in Analogue Funk
        // insert(0x0000004c, &NPC_t::Text);
        insert(0x00000050, &NPC_t::oldAddBelt);
        // insert(0x00000054, &NPC_t::PinchCount); // unused since SMBX64, now removed
        // insert(0x00000056, &NPC_t::Pinched); // unused since SMBX64, now removed
        // insert(0x00000058, &NPC_t::PinchedDirection); // unused since SMBX64, now removed
        insert(0x0000005c, &NPC_t::BeltSpeed);
        insert(0x00000060, &NPC_t::vehiclePlr);
        insert(0x00000062, &NPC_t::vehicleYOffset);
        // insert(0x00000064, // Generator // turned into bitfield, unused in Analogue Funk
        //     [](const NPC_t& n, FIELDTYPE ftype)->num_t
        //     {
        //         return valueToMem(n.Generator, ftype);
        //     },
        //     [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
        //     {
        //         memToValue(n.Generator, in, ftype);

        //         if(n.Generator)
        //             NPCQueues::Active.insert(n);
        //         else if(!NPCQueues::check_active(n))
        //             NPCQueues::Active.erase(n);
        //     }
        // );
        // all removed
        // insert(0x00000068, &NPC_t::GeneratorTimeMax);
        // insert(0x0000006c, &NPC_t::GeneratorTime);
        // insert(0x00000070, &NPC_t::GeneratorDirection);
        // insert(0x00000072, &NPC_t::GeneratorEffect);
        // insert(0x00000074, &NPC_t::GeneratorActive); // turned into bitfield, unused in Analogue Funk
        insert(0x00000076, // playerTemp
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.playerTemp, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                bool prev = n.playerTemp;

                bool temp = n.playerTemp;
                memToValue(temp, in, ftype);
                n.playerTemp = temp;

                if(!prev && n.playerTemp)
                    NPCQueues::PlayerTemp.push_back(n);
            }
        );
        // insert(0x00000078, &NPC_t::Location); // between 0x78 and 0xA8
        // insert(0x000000a8, &NPC_t::DefaultLocation); // between 0xA8 and 0xD8
        insert(0x000000a8, &NPC_t::DefaultLocationX); // 0xA8
        insert(0x000000b0, &NPC_t::DefaultLocationY); // 0xB0
        insert(0x000000d8, // DefaultDirection
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem((vbint_t)n.DefaultDirection, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                vbint_t direction = 0;
                memToValue(direction, in, ftype);

                n.DefaultDirection = (int8_t)direction;
            }
        );
        static_assert(sizeof(NPC_t::DefaultType) == sizeof(vbint_t), "underlying type of NPC_t::DefaultType must be vbint_t");
        insert(0x000000dc, reinterpret_cast<vbint_t NPC_t::*>(&NPC_t::DefaultType));
        insert(0x000000de, &NPC_t::DefaultSpecial);
        // insert(0x000000e0, &NPC_t::DefaultSpecial2); // removed, was unused except by NPCID_MAGIC_DOOR and friends
        insert(0x000000e2, // Type
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Type, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                int type = NPCID(0);
                memToValue(type, in, ftype);

                n.Type = NPCID(type);

                // may have switched to/from an always-active type
                if(NPCQueues::check_active(n))
                    NPCQueues::Active.insert(n);
                else
                    NPCQueues::Active.erase(n);
            }
        );
        insert(0x000000e4, &NPC_t::Frame);
        insert(0x000000e8, &NPC_t::FrameCount);
        insert(0x000000ec, &NPC_t::Direction);
        insert(0x000000f0, &NPC_t::Special);
        insert(0x000000f8, &NPC_t::Special2);
        insert(0x00000100, &NPC_t::Special3);
        insert(0x00000108, &NPC_t::Special4);
        insert(0x00000110, &NPC_t::Special5);
        // insert(0x00000118, &NPC_t::Special6); // removed!
        insert(0x00000120, // TurnAround
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.TurnAround, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                bool temp = n.TurnAround;
                memToValue(temp, in, ftype);
                n.TurnAround = temp;
            }
        );
        insert(0x00000122, // Killed
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Killed, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                bool prev = (n.Killed != 0);

                memToValue(n.Killed, in, ftype);

                if(!prev && n.Killed != 0)
                    NPCQueues::Killed.push_back(n);
            }
        );
        insert(0x00000124, // Active
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Active, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                memToValue(n.Active, in, ftype);

                if(NPCQueues::check_active(n))
                    NPCQueues::Active.insert(n);
                else
                {
                    NPCQueues::Active.erase(n);
                    NPCQueues::Unchecked.push_back(n);
                }
            }
        );
        // insert(0x00000126, &NPC_t::Reset);
        insert(0x0000012a, &NPC_t::TimeLeft);
        insert(0x0000012c, &NPC_t::HoldingPlayer);
        insert(0x0000012e, &NPC_t::CantHurt);
        insert(0x00000130, &NPC_t::CantHurtPlayer);
        insert(0x00000132, &NPC_t::BattleOwner);
        insert(0x00000134, &NPC_t::WallDeath);
        insert(0x00000136, &NPC_t::Projectile);
        static_assert(sizeof(NPC_t::Effect) == sizeof(vbint_t), "underlying type of NPC_t::Effect must be vbint_t");
        insert(0x00000138, reinterpret_cast<vbint_t NPC_t::*>(&NPC_t::Effect));
        insert(0x0000013c, &NPC_t::Effect2);
        insert(0x00000144, &NPC_t::Effect3);
        insert(0x00000146, &NPC_t::Section);
        insert(0x00000148, &NPC_t::Damage);
        insert(0x0000014c, // JustActivated
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.JustActivated, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                memToValue(n.JustActivated, in, ftype);

                if(n.JustActivated)
                    NPCQueues::Active.insert(n);
                else if(!NPCQueues::check_active(n))
                    NPCQueues::Active.erase(n);
            }
        );
        // insert(0x0000014e, &NPC_t::coinSwitchBlockType); // never-used for non-coins, now shares storage with Damage (never-used for coins)
        insert(0x00000150, &NPC_t::tempBlock);
        // insert(0x00000152, &NPC_t::onWall); // removed temporary variable
        // insert(0x00000154, &NPC_t::TurnBackWipe); // turned into bitfield, unused in Analogue Funk
        insert(0x00000156, // Immune
            [](const NPC_t& n, FIELDTYPE ftype)->num_t
            {
                return valueToMem(n.Immune, ftype);
            },
            [](NPC_t& n, num_t in, FIELDTYPE ftype)->void
            {
                memToValue(n.Immune, in, ftype);
                NPCQueues::Unchecked.push_back(n);
            }
        );
    }

    num_t getValue(NPC_t *obj, size_t address, FIELDTYPE ftype) override
    {
        if(address >= 0x78 && address < 0xA8) // Location
            return s_locMem.getValue(&obj->Location, address - 0x78, ftype);
        else if(address >= 0xB8 && address < 0xD8) // invalid part of DefaultLocation
            pLogWarning("MemEmu: Attempt to read NPC address 0x%x (removed part of DefaultLocation)", static_cast<unsigned>(address));
        else if(address == 0x126)
            return obj->Reset[1] ? 0xFFFF : 0;
        else if(address == 0x128)
            return obj->Reset[2] ? 0xFFFF : 0;
        else if(address >= 0x0A && address < 0x14) // Pinched
        {
            switch(address)
            {
            case 0x0A: // Pinched1
                return valueToMem((short)obj->Pinched.Bottom1, ftype);
            case 0x0C: // Pinched2
                return valueToMem((short)obj->Pinched.Left2, ftype);
            case 0x0E: // Pinched3
                return valueToMem((short)obj->Pinched.Top3, ftype);
            case 0x10: // Pinched4
                return valueToMem((short)obj->Pinched.Right4, ftype);
            case 0x12: // MovingPinched
                return valueToMem((short)obj->Pinched.Moving, ftype);
            default:
                pLogWarning("MemEmu: Attempt to read NPC address 0x%x (invalid byte hacking)", static_cast<unsigned>(address));
                break;
            }
        }
        return NpcParent::getValue(obj, address, ftype);
    }

    void setValue(NPC_t *obj, size_t address, num_t value, FIELDTYPE ftype) override
    {
        if(address >= 0x78 && address < 0xA8) // Location
        {
            s_locMem.setValue(&obj->Location, address - 0x78, value, ftype);

            NPCQueues::Unchecked.push_back(obj);
            treeNPCUpdate(obj);
            return;
        }
        else if(address >= 0xB8 && address < 0xD8) // DefaultLocation, invalid part
        {
            pLogWarning("MemEmu: Attempt to set NPC address 0x%x (removed part of DefaultLocation)", static_cast<unsigned>(address));
            return;
        }
        else if(address == 0x126)
        {
            obj->Reset[1] = value != 0;

            if(value == 0)
                NPCQueues::NoReset.push_back(obj);

            return;
        }
        else if(address == 0x128)
        {
            obj->Reset[2] = value != 0;

            if(value == 0)
                NPCQueues::NoReset.push_back(obj);

            return;
        }
        else if(address >= 0x0A && address < 0x14) // Pinched
        {
            int in = 0;

            memToValue(in, value, ftype);

            // clamp to range
            if(in < 0)
                in = 0;
            else if(in > 3)
                in = 3;

            switch(address)
            {
            case 0x0A: // Pinched1
                obj->Pinched.Bottom1 = in;
                return;
            case 0x0C: // Pinched2
                obj->Pinched.Left2 = in;
                return;
            case 0x0E: // Pinched3
                obj->Pinched.Top3 = in;
                return;
            case 0x10: // Pinched4
                obj->Pinched.Right4 = in;
                return;
            case 0x12: // MovingPinched
                obj->Pinched.Moving = in;
                return;
            default:
                pLogWarning("MemEmu: Attempt to set NPC address 0x%x to %d (invalid byte hacking)", static_cast<unsigned>(address), in);
                return;
            }
        }

        NpcParent::setValue(obj, address, value, ftype);

#if 0 // Layer sync hook, but setting it is not yet supported.
        if(address == 0x3C)
        {
            int index = obj - &NPC[0];
            if(index >= -128 && index <= maxNPCs)
                syncLayers_NPC(index);
        }
#endif
    }
};

static SMBXMemoryEmulator   s_emu;
static PlayerMemory         s_emuPlayer;
static NPCMemory            s_emuNPC;

template<typename T, class D>
SDL_FORCE_INLINE void opAdd(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    T res = static_cast<T>(o1) + static_cast<T>(o2);
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D>
SDL_FORCE_INLINE void opSub(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    T res = static_cast<T>(o1) - static_cast<T>(o2);
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D>
SDL_FORCE_INLINE void opMul(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    T res = static_cast<T>(o1) * static_cast<T>(o2);
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<class D>
SDL_FORCE_INLINE void opMul_numf_t(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    numf_t res = static_cast<numf_t>(o1).times(static_cast<numf_t>(o2));
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<class D>
SDL_FORCE_INLINE void opMul_num_t(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    num_t res = o1.times(o2);
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D>
SDL_FORCE_INLINE void opDiv(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    T res = static_cast<T>(o1) / static_cast<T>(o2);
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<class D>
SDL_FORCE_INLINE void opDiv_numf_t(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    numf_t res = static_cast<numf_t>(o1).divided_by(static_cast<numf_t>(o2));
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<class D>
SDL_FORCE_INLINE void opDiv_num_t(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    num_t res = o1.divided_by(o2);
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D>
SDL_FORCE_INLINE void opXor(D &mem, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(addr, ftype);
    T res = static_cast<T>(o1) ^ static_cast<T>(o2);
    mem.setValue(addr, static_cast<num_t>(res), ftype);
}


void MemAssign(size_t address, num_t value, OPTYPE operation, FIELDTYPE ftype)
{
    if((address < GM_BASE) || (address > GM_END))
    {
        pLogWarning("MemEmu: MemAssign Requested value of out-of-range global address: 0x%x", static_cast<unsigned>(address));
        return;
    }

    if(ftype == FT_INVALID)
        return;

    if(operation == OP_Div && value == 0)
        return;

    switch(operation)
    {
    case OP_Assign:
        s_emu.setValue(address, value, ftype);
        break;

    case OP_Add:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opAdd<uint8_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opAdd<int16_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opAdd<int32_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opAdd<numf_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opAdd<num_t>(s_emu, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Add
    break;

    case OP_Sub:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opSub<uint8_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opSub<int16_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opSub<int32_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opSub<numf_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opSub<num_t>(s_emu, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Sub
    break;

    case OP_Mult:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opMul<uint8_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opMul<int16_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opMul<int32_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opMul_numf_t(s_emu, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opMul_num_t(s_emu, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Mult
    break;

    case OP_Div:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opDiv<uint8_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opDiv<int16_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opDiv<int32_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opDiv_numf_t(s_emu, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opDiv_num_t(s_emu, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Div
    break;

    case OP_XOR:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opXor<uint8_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opXor<int16_t>(s_emu, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opXor<int32_t>(s_emu, address, value, ftype);
            break;
        }
        default:
            break;
        }
    }//OP XOR
    break;

    default:
        break;
    }// switch on op
}

bool CheckMem(size_t address, num_t value, COMPARETYPE ctype, FIELDTYPE ftype)
{
    if((address < GM_BASE) || (address > GM_END))
    {
        pLogWarning("MemEmu: CheckMem Requested value of out-of-range global address: 0x%x", static_cast<unsigned>(address));
        return false;
    }

    num_t cur = s_emu.getValue(address, ftype);

    switch(ctype)
    {
    case CMPT_EQUALS:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) == static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) == static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) == static_cast<int32_t>(value);
        case FT_FLOAT:
            return num_t::fEqual_f(static_cast<numf_t>(cur), static_cast<numf_t>(value));
        case FT_DFLOAT:
            return num_t::fEqual_d(cur, value);
        default:
            return false;
        }

    case CMPT_GREATER:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) > static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) > static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) > static_cast<int32_t>(value);
        case FT_FLOAT:
            return static_cast<numf_t>(cur) > static_cast<numf_t>(value);
        case FT_DFLOAT:
            return cur > value;
        default:
            return false;
        }

    case CMPT_LESS:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) < static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) < static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) < static_cast<int32_t>(value);
        case FT_FLOAT:
            return static_cast<numf_t>(cur) < static_cast<numf_t>(value);
        case FT_DFLOAT:
            return cur < value;
        default:
            return false;
        }

    case CMPT_NOTEQ:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) != static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) != static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) != static_cast<int32_t>(value);
        case FT_FLOAT:
            return !num_t::fEqual_f(static_cast<numf_t>(cur), static_cast<numf_t>(value));
        case FT_DFLOAT:
            return !num_t::fEqual_d(cur, value);
        default:
            return false;
        }
    }

    return false;
}

num_t GetMem(size_t addr, FIELDTYPE ftype)
{
    if((addr < GM_BASE) || (addr > GM_END))
    {
        pLogWarning("MemEmu: GetMem Requested value of out-of-range global address: 0x%x", static_cast<unsigned>(addr));
        return 0;
    }

    num_t cur = s_emu.getValue(addr, ftype);

    switch(ftype)
    {
    case FT_BYTE:
        return static_cast<num_t>(static_cast<uint8_t>(cur));
    case FT_WORD:
        return static_cast<num_t>(static_cast<int16_t>(cur));
    case FT_DWORD:
        return static_cast<num_t>(static_cast<int32_t>(cur));
    case FT_FLOAT:
        return static_cast<num_t>(static_cast<numf_t>(cur));
    default:
    case FT_DFLOAT:
        return cur;
    }
}


template<typename T, class D, class U>
SDL_FORCE_INLINE void opAdd(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    T res = static_cast<T>(o1) + static_cast<T>(o2);
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D, class U>
SDL_FORCE_INLINE void opSub(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    T res = static_cast<T>(o1) - static_cast<T>(o2);
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D, class U>
SDL_FORCE_INLINE void opMul(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    T res = static_cast<T>(o1) * static_cast<T>(o2);
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<class D, class U>
SDL_FORCE_INLINE void opMul_numf_t(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    numf_t res = static_cast<numf_t>(o1).times(static_cast<numf_t>(o2));
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<class D, class U>
SDL_FORCE_INLINE void opMul_num_t(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    num_t res = o1.times(o2);
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D, class U>
SDL_FORCE_INLINE void opDiv(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    T res = static_cast<T>(o1) / static_cast<T>(o2);
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<class D, class U>
SDL_FORCE_INLINE void opDiv_numf_t(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    numf_t res = static_cast<numf_t>(o1).divided_by(static_cast<numf_t>(o2));
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<class D, class U>
SDL_FORCE_INLINE void opDiv_num_t(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    num_t res = o1.divided_by(o2);
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<typename T, class D, class U>
SDL_FORCE_INLINE void opXor(D &mem, U *obj, size_t addr, num_t o2, FIELDTYPE ftype)
{
    num_t o1 = mem.getValue(obj, addr, ftype);
    T res = static_cast<T>(o1) ^ static_cast<T>(o2);
    mem.setValue(obj, addr, static_cast<num_t>(res), ftype);
}

template<class T, class U>
static void MemAssignType(T &mem, U *obj, size_t address, num_t value, OPTYPE operation, FIELDTYPE ftype)
{
    if(ftype == FT_INVALID)
        return;

    if(operation == OP_Div && value == 0)
        return;

    switch(operation)
    {
    case OP_Assign:
        mem.setValue(obj, address, value, ftype);
        break;

    case OP_Add:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opAdd<uint8_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opAdd<int16_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opAdd<int32_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opAdd<numf_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opAdd<num_t>(mem, obj, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Add
    break;

    case OP_Sub:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opSub<uint8_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opSub<int16_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opSub<int32_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opSub<numf_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opSub<num_t>(mem, obj, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Sub
    break;

    case OP_Mult:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opMul<uint8_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opMul<int16_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opMul<int32_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opMul_numf_t(mem, obj, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opMul_num_t(mem, obj, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Mult
    break;

    case OP_Div:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opDiv<uint8_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opDiv<int16_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opDiv<int32_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_FLOAT:
        {
            opDiv_numf_t(mem, obj, address, value, ftype);
            break;
        }
        case FT_DFLOAT:
            opDiv_num_t(mem, obj, address, value, ftype);
            break;
        default:
            break;
        }
    }//OP Div
    break;

    case OP_XOR:
    {
        switch(ftype)
        {
        case FT_BYTE:
        {
            opXor<uint8_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_WORD:
        {
            opXor<int16_t>(mem, obj, address, value, ftype);
            break;
        }
        case FT_DWORD:
        {
            opXor<int32_t>(mem, obj, address, value, ftype);
            break;
        }
        default:
            break;
        }
    }//OP XOR
    break;

    default:
        break;
    }// switch on op
}

template<class T, class U>
static bool ChecmMemType(T &mem, U *obj, size_t offset, num_t value, COMPARETYPE ctype, FIELDTYPE ftype)
{
    num_t cur = mem.getValue(obj, offset, ftype);

    switch(ctype)
    {
    case CMPT_EQUALS:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) == static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) == static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) == static_cast<int32_t>(value);
        case FT_FLOAT:
            return num_t::fEqual_f(static_cast<numf_t>(cur), static_cast<numf_t>(value));
        case FT_DFLOAT:
            return num_t::fEqual_d(cur, value);
        default:
            return false;
        }

    case CMPT_GREATER:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) > static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) > static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) > static_cast<int32_t>(value);
        case FT_FLOAT:
            return static_cast<numf_t>(cur) > static_cast<numf_t>(value);
        case FT_DFLOAT:
            return cur > value;
        default:
            return false;
        }

    case CMPT_LESS:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) < static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) < static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) < static_cast<int32_t>(value);
        case FT_FLOAT:
            return static_cast<numf_t>(cur) < static_cast<numf_t>(value);
        case FT_DFLOAT:
            return cur < value;
        default:
            return false;
        }

    case CMPT_NOTEQ:
        switch(ftype)
        {
        case FT_BYTE:
            return static_cast<uint8_t>(cur) != static_cast<uint8_t>(value);
        case FT_WORD:
            return static_cast<int16_t>(cur) != static_cast<int16_t>(value);
        case FT_DWORD:
            return static_cast<int32_t>(cur) != static_cast<int32_t>(value);
        case FT_FLOAT:
            return !num_t::fEqual_f(static_cast<numf_t>(cur), static_cast<numf_t>(value));
        case FT_DFLOAT:
            return !num_t::fEqual_d(cur, value);
        default:
            return false;
        }
    }

    return false;
}


// #define DEBUG_MEMEMU_TRACE

void MemAssign(Player_t *obj, size_t address, num_t value, OPTYPE operation, FIELDTYPE ftype)
{
#ifdef DEBUG_MEMEMU_TRACE
    D_pLogDebug("Player mem TRACE: Write 0x%08X, %g, op-%d, ft-%d", address, value, (int)operation, (int)ftype);
#endif
    MemAssignType(s_emuPlayer, obj, address, value, operation, ftype);
}

bool CheckMem(Player_t *obj, size_t offset, num_t value, COMPARETYPE ctype, FIELDTYPE ftype)
{
#ifdef DEBUG_MEMEMU_TRACE
    D_pLogDebug("Player mem TRACE: Compare 0x%08X, %g, cp-%d, ft-%d", offset, value, (int)ctype, (int)ftype);
#endif
    return ChecmMemType(s_emuPlayer, obj, offset, value, ctype, ftype);
}

num_t GetMem(Player_t *obj, size_t offset, FIELDTYPE ftype)
{
#ifdef DEBUG_MEMEMU_TRACE
    num_t value = s_emuPlayer.getValue(obj, offset, ftype);
    D_pLogDebug("Player mem TRACE: Read 0x%08X, %g, ft-%d", offset, value, (int)ftype);
    return value;
#else
    return s_emuPlayer.getValue(obj, offset, ftype);
#endif
}


void MemAssign(NPC_t *obj, size_t address, num_t value, OPTYPE operation, FIELDTYPE ftype)
{
#ifdef DEBUG_MEMEMU_TRACE
    D_pLogDebug("NPC mem TRACE: Write 0x%08X, %g, op-%d, ft-%d", address, value, (int)operation, (int)ftype);
#endif
    MemAssignType(s_emuNPC, obj, address, value, operation, ftype);
}

bool CheckMem(NPC_t *obj, size_t offset, num_t value, COMPARETYPE ctype, FIELDTYPE ftype)
{
#ifdef DEBUG_MEMEMU_TRACE
    D_pLogDebug("NPC mem TRACE: Compare 0x%08X, %g, cp-%d, ft-%d", offset, value, (int)ctype, (int)ftype);
#endif
    return ChecmMemType(s_emuNPC, obj, offset, value, ctype, ftype);
}

num_t GetMem(NPC_t *obj, size_t offset, FIELDTYPE ftype)
{
#ifdef DEBUG_MEMEMU_TRACE
    num_t value = s_emuNPC.getValue(obj, offset, ftype);
    D_pLogDebug("NPC mem TRACE: Read 0x%08X, %g, ft-%d", offset, value, (int)ftype);
    return value;
#else
    return s_emuNPC.getValue(obj, offset, ftype);
#endif
}


================================================
FILE: src/script/luna/mememu.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef MEMEMU_H
#define MEMEMU_H

#include <cstddef>
#include "lunadefs.h"

struct Player_t;
struct NPC_t;

#define GM_BASE             0x00B25000
#define GM_END              0x00B2E000

//Global
void MemAssign(size_t address, num_t value, OPTYPE operation, FIELDTYPE ftype);
bool CheckMem(size_t address, num_t value, COMPARETYPE ctype, FIELDTYPE ftype);
num_t GetMem(size_t addr, FIELDTYPE ftype);

// Player relative
void MemAssign(Player_t *obj, size_t address, num_t value, OPTYPE operation, FIELDTYPE ftype);
bool CheckMem(Player_t *obj, size_t offset, num_t value, COMPARETYPE ctype, FIELDTYPE ftype);
num_t GetMem(Player_t *obj, size_t offset, FIELDTYPE ftype);

// NPC relative
void MemAssign(NPC_t *obj, size_t address, num_t value, OPTYPE operation, FIELDTYPE ftype);
bool CheckMem(NPC_t *obj, size_t offset, num_t value, COMPARETYPE ctype, FIELDTYPE ftype);
num_t GetMem(NPC_t *obj, size_t offset, FIELDTYPE ftype);

#endif // MEMEMU_H


================================================
FILE: src/script/luna/renderop.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef RENDEROP_H
#define RENDEROP_H

#include "lunarender.h"
#include "sdl_proxy/sdl_assert.h"

#include "xt_color.h"
#include "draw_planes.h"

static const PLANE RENDEROP_PRIORITY_MIN = PLANE_INTERNAL_BG;
static const PLANE RENDEROP_PRIORITY_MAX = PLANE_INTERNAL_FG;
static const PLANE RENDEROP_DEFAULT_PRIORITY_RENDEROP = (PLANE)(PLANE_LVL_HUD - 2); // Default priority for RenderOp and RenderImage
static const PLANE RENDEROP_DEFAULT_PRIORITY_CGFX = (PLANE)(PLANE_LVL_HUD - 1); // Default priority for Custom GFX
static const PLANE RENDEROP_DEFAULT_PRIORITY_TEXT = (PLANE)(PLANE_LVL_HUD); // Default priority for Text

static const PLANE RENDEROP_DEFAULT_PRIORITY_RENDEROP_SCENE = (PLANE)(PLANE_LVL_SECTION_FG - 2); // Default priority for RenderOp and RenderImage (scene)
static const PLANE RENDEROP_DEFAULT_PRIORITY_CGFX_SCENE = (PLANE)(PLANE_LVL_SECTION_FG - 1); // Default priority for Custom GFX (scene)
static const PLANE RENDEROP_DEFAULT_PRIORITY_TEXT_SCENE = (PLANE)(PLANE_LVL_SECTION_FG); // Default priority for Text (scene)

// Base class respresenting a rendering operation
// Rendering operations include a draw function and a count of how many frames of activity remain
class RenderOp
{
public:
    RenderOp() : m_FramesLeft(1), m_selectedCamera(0), m_renderPriority(RENDEROP_DEFAULT_PRIORITY_RENDEROP) {}
    explicit RenderOp(PLANE priority) : m_FramesLeft(1), m_selectedCamera(0), m_renderPriority(priority) {}
    virtual ~RenderOp() = default;
    virtual void Draw(Renderer* /*renderer*/) {}

    inline void* operator new(size_t size)
    {
        // Note: If you creating any chunks with a size bigger than current size, please increase it
        SDL_assert_release(size < c_rAllocChunkSize);
        auto *ret = g_rAlloc.Allocate(c_rAllocChunkSize);
        return ret;
    }

    inline void operator delete(void* memory)
    {
        g_rAlloc.Free(memory);
    }

    int m_FramesLeft;		// How many frames until this op should be destroyed
    int m_selectedCamera;
    PLANE m_renderPriority;
};

#endif // RENDEROP_H


================================================
FILE: src/script/luna/renderop_bitmap.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "renderop_bitmap.h"
#include "core/render.h"
#include "globals.h"
#include "lunaimgbox.h"


RenderBitmapOp::RenderBitmapOp() : RenderOp()
{
    static_assert(sizeof(RenderBitmapOp) <= c_rAllocChunkSize,
                  "Size of RenderBitmapOp class must be smaller than c_rAllocChunkSize");
}

void RenderBitmapOp::Draw(Renderer *renderer)
{
    if(!direct_img || (direct_img->getH() == 0) || (direct_img->getW() == 0))
        return;

    int screenX = this->x;
    int screenY = this->y;

    if(sceneCoords)
    {
        screenX -= vScreen[renderer->GetCameraIdx()].CameraAddX_i();
        screenY -= vScreen[renderer->GetCameraIdx()].CameraAddY_i();
    }
    else
    {
        Render::TranslateScreenCoords(screenX, screenY, this->sw, this->sh);
    }

    // Get integer values as current rendering backends prefer that
    int x = screenX;
    int y = screenY;
    int sx = this->sx;
    int sy = this->sy;
    int width = this->sw;
    int height = this->sh;

    // Trim height/width if necessary
    if(direct_img->getW() < width + sx)
        width = direct_img->getW() - sx;

    if(direct_img->getH() < height + sy)
        height = direct_img->getH() - sy;

    // Don't render if no size
    if((width <= 0) || (height <= 0))
        return;

    XRender::renderTextureBasic(x, y, width, height, direct_img->m_image, sx, sy, color);
}


================================================
FILE: src/script/luna/renderop_bitmap.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef RENDERBITMAPOP_H
#define RENDERBITMAPOP_H

#include <memory>
#include "renderop.h"

class RenderBitmapOp final : public RenderOp
{
public:
    RenderBitmapOp();
    ~RenderBitmapOp() override = default;

    void Draw(Renderer* renderer) override;

    inline void* operator new(size_t size)
    {
        // Note: If you creating any chunks with a size bigger than current size, please increase it
        SDL_assert_release(size < c_rAllocChunkSize);
        auto *ret = g_rAlloc.Allocate(c_rAllocChunkSize);
        return ret;
    }

    inline void operator delete(void* memory)
    {
        g_rAlloc.Free(memory);
    }

    int x = 0;				// Absolute screen x position
    int y = 0;				// Absolute screen y position
    int sx = 0;				// Source x1 (left edge)
    int sy = 0;				// Source y1 (top edge)
    int sw = 0;				// Source x1 (right edge)
    int sh = 0;				// Source x1 (bottom edge)

    XTColor color = XTAlpha(255);         // Opacity value
    bool    sceneCoords = false;     // If true, x and y are scene coordinates

    LunaImage *direct_img = nullptr;
};

#endif // RENDERBITMAPOP_H


================================================
FILE: src/script/luna/renderop_effect.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "renderop_effect.h"
#include "core/render.h"
#include "globals.h"

// DRAW
RenderEffectOp::RenderEffectOp() : RenderOp(),
    effect_type(RNDEFF_ScreenGlow),
    blend_type(BLEND_Additive),
    color(0x00000000),
    intensity(0),
    flip_type(FLIP_TYPE_NONE)
{
    static_assert(sizeof(RenderEffectOp) <= c_rAllocChunkSize,
                  "Size of RenderBitmapOp class must be smaller than c_rAllocChunkSize");
}

RenderEffectOp::RenderEffectOp(RENDER_EFFECT effect, BLEND_TYPE blend, COLORREF col, int intensity)
{
    effect_type = effect;
    blend_type = blend;
    color = col;
    this->intensity = intensity;
    flip_type = FLIP_TYPE_NONE;
}

void RenderEffectOp::Draw(Renderer *g)
{
    switch(effect_type)
    {
    case RNDEFF_ScreenGlow:
        ScreenGlow(g);
        break;
    case RNDEFF_Flip:
        Flip(g);
        break;
    default:
        break;
    }
}

// SCREEN GLOW
void RenderEffectOp::ScreenGlow(Renderer *g)
{
    UNUSED(g);
    // TODO: Re-Implement this differently

//    HDC hScreen = g->GetScreenDC();

//    HBITMAP hOld = (HBITMAP)SelectObject(ghMemDC, ghGeneralDIB);

//    if(ghGeneralDIB && ghMemDC && gpScreenBits)
//    {
//        BitBlt(ghMemDC, 0, 0, 800, 600, hScreen, 0, 0, SRCCOPY);

//#ifndef __MINGW32__
//        // MMX code and loop
//        _mm_empty();
//        int nLoops = (800 * 600) / 2;
//        __m64 color64 = _mm_set_pi32(color, color);
//        __m64 *pDest = (__m64 *)gpScreenBits;

//        if(blend_type == BLEND_Additive)
//        {
//            for(int i = 0; i < nLoops; i++)
//            {
//                //tmp =
//                pDest[i] = _mm_adds_pu8(color64, pDest[i]);

//                //pDest[i] = tmp;
//            }
//        }
//        else if(blend_type == BLEND_Subtractive)
//        {
//            for(int i = 0; i < nLoops; i++)
//            {
//                //tmp =
//                pDest[i] = _mm_subs_pu8(color64, pDest[i]);

//                //pDest[i] = tmp;
//            }
//        }

//        _mm_empty();
//#endif

//        BitBlt(hScreen, 0, 0, 800, 600, ghMemDC, 0, 0, SRCCOPY);

//        SelectObject(ghMemDC, hOld);
//    }
}


// Flip
void RenderEffectOp::Flip(Renderer *g)
{
    UNUSED(g);
//    HDC hScreen = g->GetScreenDC();

//    HBITMAP hOld = (HBITMAP)SelectObject(ghMemDC, ghGeneralDIB);
//    if(!(ghGeneralDIB && ghMemDC && gpScreenBits)) return;

//    BitBlt(ghMemDC, 0, 0, 800, 600, hScreen, 0, 0, SRCCOPY);

//    StretchBlt(hScreen,
//               (flip_type & FLIP_TYPE_X) ? 800 : 0,
//               (flip_type & FLIP_TYPE_Y) ? 600 : 0,
//               (flip_type & FLIP_TYPE_X) ? -800 : 800,
//               (flip_type & FLIP_TYPE_Y) ? -600 : 600,
//               ghMemDC, 0, 0, 800, 600, SRCCOPY);

//    SelectObject(ghMemDC, hOld);
}


================================================
FILE: src/script/luna/renderop_effect.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef RENDEROP_EFFECT_H
#define RENDEROP_EFFECT_H

#include "renderop.h"

typedef uint32_t COLORREF;

enum RENDER_EFFECT
{
    RNDEFF_ScreenGlow,
    RNDEFF_Flip
};

enum BLEND_TYPE
{
    BLEND_Additive,
    BLEND_Subtractive
};

enum FLIP_TYPE
{
    FLIP_TYPE_NONE = 0x0,
    FLIP_TYPE_X = 0x1,
    FLIP_TYPE_Y = 0x2,
    FLIP_TYPE_XY = 0x3,
};

class RenderEffectOp final : public RenderOp
{
public:
    RenderEffectOp();
    explicit RenderEffectOp(RENDER_EFFECT effect, BLEND_TYPE blend, COLORREF col, int intensity);

    ~RenderEffectOp() override = default;

    void Draw(Renderer *renderer) override;

    inline void* operator new(size_t size)
    {
        // Note: If you creating any chunks with a size bigger than current size, please increase it
        SDL_assert_release(size < c_rAllocChunkSize);
        auto *ret = g_rAlloc.Allocate(c_rAllocChunkSize);
        return ret;
    }

    inline void operator delete(void* memory)
    {
        g_rAlloc.Free(memory);
    }

    // Effects //
    void ScreenGlow(Renderer *renderer);
    void Flip(Renderer *renderer);

    // Members //
    RENDER_EFFECT effect_type;
    BLEND_TYPE blend_type;
    COLORREF color;
    int intensity;
    FLIP_TYPE flip_type;
};


#endif // RENDEROP_EFFECT_H


================================================
FILE: src/script/luna/renderop_rect.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "renderop_rect.h"
#include "core/render.h"
#include "globals.h"


RenderRectOp::RenderRectOp() : RenderOp(),
    x1(0), y1(0), x2(0), y2(0),
    fillColor(0, 0, 0, 0),
    borderColor(255, 255, 255, 255),
    sceneCoords(false)
{
    static_assert(sizeof(RenderRectOp) <= c_rAllocChunkSize,
            "Size of RenderRectOp class must be smaller than c_rAllocChunkSize");
}

void RenderRectOp::Draw(Renderer *renderer)
{
    if(borderColor.a <= 0 && fillColor.a <= 0) return;

    // Convert coordinates
    int sx1 = this->x1, sy1 = this->y1, sx2 = this->x2, sy2 = this->y2;
    if(sceneCoords)
    {
        sx1 -= vScreen[renderer->GetCameraIdx()].CameraAddX_i();
        sy1 -= vScreen[renderer->GetCameraIdx()].CameraAddY_i();
        sx2 -= vScreen[renderer->GetCameraIdx()].CameraAddX_i();
        sy2 -= vScreen[renderer->GetCameraIdx()].CameraAddY_i();
    }
    else
    {
        if(sx1 == 0 && sx2 == 800 && sy1 == 0 && sy2 == 600)
        {
            sx2 = vScreen[1].Width;
            sy2 = vScreen[1].Height;
        }
        else
        {
            Render::TranslateScreenCoords(sx1, sy1, sx2 - sx1, sy2 - sy1);
        }
    }

    if(fillColor.a > 0)
        XRender::renderRect(sx1,
                            sy1,
                            sx2 - sx1,
                            sy2 - sy1,
                            fillColor, true);

    if(borderColor.a > 0)
        XRender::renderRect(sx1,
                            sy1,
                            sx2 - sx1,
                            sy2 - sy1,
                            borderColor, false);
}



================================================
FILE: src/script/luna/renderop_rect.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef RENDERRECTOP_H
#define RENDERRECTOP_H

#include "renderop.h"

class RenderRectOp final : public RenderOp
{
public:
    RenderRectOp();

    ~RenderRectOp() override = default;

    void Draw(Renderer *renderer) override;

    inline void* operator new(size_t size)
    {
        // Note: If you creating any chunks with a size bigger than current size, please increase it
        SDL_assert_release(size < c_rAllocChunkSize);
        auto *ret = g_rAlloc.Allocate(c_rAllocChunkSize);
        return ret;
    }

    inline void operator delete(void* memory)
    {
        g_rAlloc.Free(memory);
    }

    int x1;
    int y1;
    int x2;
    int y2;
    XTColor fillColor;
    XTColor borderColor;
    bool   sceneCoords;        // If true, x and y are scene coordinates
};


#endif // RENDERRECTOP_H


================================================
FILE: src/script/luna/renderop_string.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "renderop_string.h"

#include "sdl_proxy/sdl_stdinc.h"
#include "core/render.h"

RenderStringOp::RenderStringOp() :
    RenderStringOp(std::string(), 1, 400, 400)
{
    static_assert(sizeof(RenderStringOp) <= c_rAllocChunkSize,
                  "Size of RenderStringOp class must be smaller than c_rAllocChunkSize");
}

RenderStringOp::RenderStringOp(const std::string &str, int font_type, int X, int Y) :
    RenderOp(RENDEROP_DEFAULT_PRIORITY_TEXT),
    m_FontType(font_type),
    m_X(X),
    m_Y(Y),
    sceneCoords(false)
{
    m_StringSize = str.size();
    m_StringDup = (m_StringSize >= c_rAllocChunkSize);

    if(m_StringDup) // fallback if string is longer than chunk size, that shouldn't happen usually
        m_String = SDL_strdup(str.c_str());
    else
    {
        m_String = (char*)g_rAlloc.Allocate(c_rAllocChunkSize);
        m_StringSize = SDL_strlcpy(m_String, str.c_str(), c_rAllocChunkSize);
    }
}

RenderStringOp::~RenderStringOp()
{
    if(m_StringDup)
        SDL_free(m_String);
    else
        g_rAlloc.Free(m_String);
    m_String = nullptr;
}

void RenderStringOp::Draw(Renderer *renderer)
{
    //        VB6StrPtr text(m_String);
    int x = m_X, y = m_Y;

    if(sceneCoords)
    {
        x -= vScreen[renderer->GetCameraIdx()].CameraAddX_i();
        y -= vScreen[renderer->GetCameraIdx()].CameraAddY_i();
    }
    else
    {
        int w = SuperTextPixLen(m_StringSize, m_String, m_FontType);
        Render::TranslateScreenCoords(x, y, w, 18);
    }

    SuperPrint(m_StringSize, m_String, m_FontType, x, y);
}


================================================
FILE: src/script/luna/renderop_string.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef RENDEROP_STRING_H
#define RENDEROP_STRING_H

#include "renderop.h"
#include "graphics.h"

// String object to be rendered later
class RenderStringOp final : public RenderOp
{
public:
    // Quick ctor
    RenderStringOp();

    RenderStringOp(const std::string &str, int font_type, int X, int Y);

    ~RenderStringOp() override;

    void Draw(Renderer *renderer) override;

    inline void* operator new(size_t size)
    {
        // Note: If you creating any chunks with a size bigger than current size, please increase it
        SDL_assert_release(size < c_rAllocChunkSize);
        auto *ret = g_rAlloc.Allocate(c_rAllocChunkSize);
        return ret;
    }

    inline void operator delete(void* memory)
    {
        g_rAlloc.Free(memory);
    }

    // FIXME: Replace this with the string data index
    // Every autocode should use the string index storage, and this thing won't be needed
    char*  m_String = nullptr;
    size_t m_StringSize = 0;
    bool   m_StringDup = false;

    int m_FontType;
    int m_X;
    int m_Y;
    bool   sceneCoords;     // If true, x and y are scene coordinates
};

#endif // RENDEROP_STRING_H


================================================
FILE: src/script/luna/sprite_component.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sprite_component.h"

void SpriteComponent::Tick()
{
    if(org_time == 0)   // endless component
        return;

    run_time--;         // normal behavior

    if(run_time == 0)   // time to delete
        expired = true;
}


================================================
FILE: src/script/luna/sprite_component.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SpriteComponent_HHH
#define SpriteComponent_HHH

#include "numeric_types.h"
#include <string>

struct SpriteComponent;
class CSprite;

typedef void (*pfnSprFunc)(CSprite *, SpriteComponent *obj);

// Class for wrapping a sprite component.
// Sprite manager will run it (calling func) until run_time == 0
struct SpriteComponent
{
    SpriteComponent() = default;

    void Init(int set_time)
    {
        func = nullptr;
        lookup_code = 0;
        data1 = 0;
        data2 = 0;
        data3 = 0;
        data4 = 0;
        run_time = set_time;
        org_time = set_time;
        expired = false;
    }

    void Tick();            // Tick down the timer of this component. Expires self when run_time reaches 1

    num_t data1 = 0;
    num_t data2 = 0;
    num_t data3 = 0;
    num_t data4 = 0;
    pfnSprFunc func = nullptr;
    int lookup_code = 0;        // Which "bucket" of custom components this component is a part of
    int run_time = 0;           // Run time frame countdown. 0 = infinite lifetime, always run
    int org_time = 0;           // Frame count to begin countdown at

    std::string data5;
    bool expired = false;           // If this component should be deleted at the next clean up cycle
};

#endif // SpriteComponent_HHH


================================================
FILE: src/script/luna/sprite_funcs.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"

#include "sprite_funcs.h"
#include "sprite_component.h"
#include "autocode_manager.h"
#include "csprite.h"
#include "globals.h"
#include "player.h"
#include "rand.h"
#include "lunarender.h"
#include "lunaplayer.h"
#include "main/trees.h"
#include "lunamisc.h"
#include "lunaspriteman.h"
#include "renderop_bitmap.h"
#include "mememu.h"

static inline int s_round2int(num_t d)
{
    return num_t::floor(d + 0.5_n);
}


// Activate -- Formally trigger a component link in the given sprite (copy all matches into behavior list)
void Activate(int code, CSprite *spr)
{
    if(code > 99)
    {
        std::list<SpriteComponent *> complist;
        gSpriteMan.GetComponents(code, &complist);
        while(!complist.empty())
        {
            spr->AddBehaviorComponent(*complist.front());
            complist.pop_front();
        }
    }
}

// PLAYER COLLECTIBLE -- Call sprite's "Die()" when touched by player
void SpriteFunc::PlayerCollectible(CSprite *me, SpriteComponent *comp)
{
    UNUSED(comp);
    Player_t *demo = PlayerF::Get(1);
    if(demo)
    {
        if(me->m_Hitbox.Test((int)demo->Location.X, (int)demo->Location.Y,
                             (int)demo->Location.Width, (int)demo->Location.Height))
        {
            me->Die();
            gSpriteMan.m_hasInvalid = true;
        }
    }
}

// WAIT FOR PLAYER -- Activate the linked component when a player condition becomes true
void SpriteFunc::WaitForPlayer(CSprite *me, SpriteComponent *obj)
{
    UNUSED(me);
    Player_t *demo = PlayerF::Get(1);
    if(demo)
    {
        auto ftype = (FIELDTYPE)SDL_atoi(obj->data5.c_str());
//        uint8_t *ptr = (uint8_t *)demo;
//        ptr += (int)obj->data1; // offset
        bool triggered = CheckMem(demo, (int)obj->data1, num_t::floor(obj->data2), (COMPARETYPE)(int)obj->data3, ftype);
        if(triggered)
        {
            //TODO: FINISH IT
            // me->AddBehaviorComponent(
        }
    }
}

// PLAYER HOLDING SPRITE
void SpriteFunc::PlayerHoldingSprite(CSprite *me, SpriteComponent *obj)
{
    Player_t *demo = PlayerF::Get(1);
    if(demo)
    {
        if(PlayerF::IsHoldingSpriteType(demo, (int)obj->data1))
            Activate((int)obj->data4, me);
    }
}

// SET SPRITE VAR
void SpriteFunc::SetSpriteVar(CSprite *me, SpriteComponent *obj)
{
    if(obj->data5.length() > 0)
        me->SetCustomVar(obj->data5, (OPTYPE)(int)obj->data2, obj->data3);
}

// IF SPRITE VAR
void SpriteFunc::IfSpriteVar(CSprite *me, SpriteComponent *obj)
{
    if(obj->data5.length() > 0)
    {
        if(me->CustomVarExists(obj->data5))
        {
            num_t var_val = me->GetCustomVar(obj->data5);
            num_t check_against = obj->data3;
            num_t component_to_activate = obj->data4;

            switch((COMPARETYPE)(int)obj->data2)
            {
            case CMPT_EQUALS:
                if(var_val == check_against)
                    Activate((int)component_to_activate, me);
                break;
            case CMPT_GREATER:
                if(var_val > check_against)
                    Activate((int)component_to_activate, me);
                break;
            case CMPT_LESS:
                if(var_val < check_against)
                    Activate((int)component_to_activate, me);
                break;
            case CMPT_NOTEQ:
                if(var_val != check_against)
                    Activate((int)component_to_activate, me);
                break;
            default:
                break;
            }
        }
    }
}

// IF LUNA VAR
void SpriteFunc::IfLunaVar(CSprite *me, SpriteComponent *obj)
{
    if(obj->data5.length() > 0)
    {
        if(gAutoMan.VarExists(obj->data5))
        {
            num_t var_val = gAutoMan.GetVar(obj->data5);
            num_t check_against = obj->data3;
            num_t component_to_activate = obj->data4;

            switch((COMPARETYPE)(int)obj->data2)
            {
            case CMPT_EQUALS:
                if(var_val == check_against)
                    Activate((int)component_to_activate, me);
                break;
            case CMPT_GREATER:
                if(var_val > check_against)
                    Activate((int)component_to_activate, me);
                break;
            case CMPT_LESS:
                if(var_val < check_against)
                    Activate((int)component_to_activate, me);
                break;
            case CMPT_NOTEQ:
                if(var_val != check_against)
                    Activate((int)component_to_activate, me);
                break;
            default:
                break;
            }
        }
    }
}

// RANDOM COMPONENT
void SpriteFunc::RandomComponent(CSprite *me, SpriteComponent *obj)
{
    int choice = iRand2(4);

    switch(choice)
    {
    default:
        break;
    case 0:
        Activate((int)obj->data1, me);
        break;
    case 1:
        Activate((int)obj->data2, me);
        break;
    case 2:
        Activate((int)obj->data3, me);
        break;
    case 3:
        Activate((int)obj->data4, me);
        break;
    }
}

// RANDOM COMPONENT RANGE
void SpriteFunc::RandomComponentRange(CSprite *me, SpriteComponent *obj)
{
    int val1 = (int)obj->data1;
    int val2 = (int)obj->data2;
    if(val1 < val2)   // rule out bad values
    {
        int diff = val2 - val1;
        int choice = iRand2(diff);
        Activate(val1 + choice, me);
    }
}

// DIE
void SpriteFunc::Die(CSprite *me, SpriteComponent *obj)
{
    UNUSED(obj);
    me->Die();
    gSpriteMan.m_hasInvalid = true;
}

// DECCELERATE
void SpriteFunc::Deccelerate(CSprite *me, SpriteComponent *obj)
{
    num_t XRate = obj->data1;
    num_t YRate = obj->data2;
    num_t Min  = obj->data3;
    num_t accum = 0;
    if(me->m_Xspd >= 0 && XRate != 0)
    {
        accum = me->m_Xspd - XRate;
        if(accum < Min)
            accum = Min;
        me->m_Xspd = accum;
    }
    else if(XRate != 0)
    {
        accum = me->m_Xspd + XRate;
        if(accum > Min)
            accum = Min;
        me->m_Xspd = accum;
    }

    if(me->m_Yspd >= 0 && YRate != 0)
    {
        accum = me->m_Yspd - YRate;
        if(accum < Min)
            accum = Min;
        me->m_Yspd = accum;
    }
    else if(YRate != 0)
    {
        accum = me->m_Yspd + YRate;
        if(accum > Min)
            accum = Min;
        me->m_Yspd = accum;
    }
}

// ACCELERATE
void SpriteFunc::Accelerate(CSprite *me, SpriteComponent *obj)
{
    UNUSED(me);
    UNUSED(obj);
    //TODO
}

// ACCEL TO PLAYER
void SpriteFunc::AccelToPlayer(CSprite *me, SpriteComponent *obj)
{
    Player_t *demo = PlayerF::Get(1);
    if(demo)
    {
        num_t negmax = obj->data3 * -1;
        if(demo->Location.X < me->m_Xpos)
            me->m_Xspd -= obj->data1;
        else
            me->m_Xspd += obj->data1;
        if(demo->Location.Y < me->m_Ypos)
            me->m_Yspd -= obj->data2;
        else
            me->m_Yspd += obj->data2;
        if(obj->data3 != 0)
        {
            if(me->m_Xspd > obj->data3)
                me->m_Xspd = obj->data3;
            else if(me->m_Xspd < negmax)
                me->m_Xspd = negmax;
            if(me->m_Yspd > obj->data3)
                me->m_Yspd = obj->data3;
            else if(me->m_Yspd < negmax)
                me->m_Yspd = negmax;
        }
    }
}

// APPLY VARIABLE GRAVITY
void SpriteFunc::ApplyVariableGravity(CSprite *me, SpriteComponent *obj)
{
    num_t var = gAutoMan.GetVar(obj->data5);
    if(obj->data2 == 0)  // x
        me->m_Xspd += var;
    else   // y
        me->m_Yspd += var;
}

// ON PLAYER COLLIDE
void SpriteFunc::OnPlayerCollide(CSprite *me, SpriteComponent *obj)
{
    Player_t *demo = PlayerF::Get(1);

    if(demo)
    {
        if(obj->data2 == 0)   // player normal hitbox
        {
            if(me->m_Hitbox.Test((int)demo->Location.X, (int)demo->Location.Y, (int)demo->Location.Width, (int)demo->Location.Height))
                Activate((int)obj->data4, me);
        }
        else   // special small circle hitbox
        {
            num_t extent = obj->data2 / 2;

            num_t cx = demo->Location.X + (demo->Location.Width / 2);
            num_t cy = demo->Location.Y + (demo->Location.Height / 2);
            if(me->m_Hitbox.Test((int)cx, (int)cy, (int)extent))
                Activate((int)obj->data4, me);
        }
    }
}

// ON PLAYER DISTANCE
void SpriteFunc::OnPlayerDistance(CSprite *me, SpriteComponent *obj)
{
    Player_t *demo = PlayerF::Get(1);
    if(demo)
    {
        num_t xdist = num_t::abs(demo->Location.X - me->m_Xpos);
        num_t ydist = num_t::abs(demo->Location.Y - me->m_Ypos);

        // Checking farness or nearness?
        if(obj->data2 == 0)
        {
            if(xdist + ydist >= obj->data1)
                Activate((int)obj->data4, me);
        }
        else
        {
            if(xdist + ydist <= obj->data1)
                Activate((int)obj->data4, me);
        }
    }
}

// PHASE MOVE
void SpriteFunc::PhaseMove(CSprite *me, SpriteComponent *obj)
{
    UNUSED(obj);
    me->m_Xpos += me->m_Xspd;
    me->m_Ypos += me->m_Yspd;
}

// BUMP MOVE
void SpriteFunc::BumpMove(CSprite *me, SpriteComponent *obj)
{
    num_t energy_loss_mod = (100 - obj->data2) / 100;

    me->m_Xpos += me->m_Xspd;
    me->m_Ypos += me->m_Yspd;

    // uint32_t COLOR = 0x11111111; // ACTUALLY UNUSED

    bool collided_left = false;
    bool collided_right = false;
    bool collided_top = false;
//    bool collided_bot = false;

    // NOTE: these were previously sorted closest first. If we keep this function, we should replicate that logic here.

    for(BlockRef_t block : treeBlockQuery(newLoc(me->m_Hitbox.CalcLeft(), me->m_Hitbox.CalcRight(), me->m_Hitbox.W, me->m_Hitbox.H), SORTMODE_COMPAT))
    {
        if(!block->Invis && !block->Hidden
           && me->m_Hitbox.Test((int)block->Location.X, (int)block->Location.Y, (int)block->Location.Width, (int)block->Location.Height))
        {
            num_t sprite_bot = me->m_Hitbox.CalcBottom();
            num_t sprite_right = me->m_Hitbox.CalcRight();
            num_t sprite_top = me->m_Hitbox.CalcTop();
            num_t sprite_left = me->m_Hitbox.CalcLeft();

            if(me->m_CollisionCode == -1)   // default solid collision
            {
                num_t block_topcol = num_t::abs(block->Location.Y - sprite_bot);
                num_t block_botcol = num_t::abs((block->Location.Y + block->Location.Height) - sprite_top);
                num_t block_leftcol = num_t::abs(block->Location.X - sprite_right);
                num_t block_rightcol = num_t::abs((block->Location.X + block->Location.Width) - sprite_left);

                // Determine best direction to free sprite
                // Top collision, push sprite up and out
                if(block_topcol <= block_botcol && block_topcol <= block_leftcol &&
                   block_topcol <= block_rightcol && !collided_top)
                {
                    me->m_Ypos = (block->Location.Y - me->m_Hitbox.H) - 1;
                    me->m_Yspd = -(me->m_Yspd.times(energy_loss_mod));
                    collided_top = true;
                }

                // Bot collision, push sprite down
                else if(block_botcol <= block_leftcol && block_botcol <= block_rightcol && !collided_right)
                {
                    me->m_Ypos = ((block->Location.Y + block->Location.Height) - me->m_Hitbox.Top_off) + 1;
                    me->m_Yspd = -(me->m_Yspd.times(energy_loss_mod));
                    // collided_bot = true;
                }

                // Left collision, push sprite left
                else if(block_leftcol <= block_rightcol && !collided_left)
                {
                    me->m_Xpos = (block->Location.X - me->m_Hitbox.W) - 1;
                    me->m_Xspd = -(me->m_Xspd.times(energy_loss_mod));
                    collided_left = true;
                }

                // Right collision, push sprite right
                else if(!collided_right)
                {
                    me->m_Xpos = ((block->Location.X + block->Location.Width) - me->m_Hitbox.Left_off) + 1;
                    me->m_Xspd = -(me->m_Xspd.times(energy_loss_mod));
                    collided_right = true;
                }
            }
        }
    }
}

// CRASH MOVE
void SpriteFunc::CrashMove(CSprite *me, SpriteComponent *obj)
{
    UNUSED(obj);
    me->m_Xpos += me->m_Xspd;
    me->m_Ypos += me->m_Yspd;

    for(BlockRef_t block : treeBlockQuery(newLoc(me->m_Hitbox.CalcLeft(), me->m_Hitbox.CalcRight(), me->m_Hitbox.W, me->m_Hitbox.H), SORTMODE_NONE))
    {
        if(!block->Invis && !block->Hidden &&
            me->m_Hitbox.Test((int)block->Location.X,
                              (int)block->Location.Y,
                              (int)block->Location.Width,
                              (int)block->Location.Height))
        {
            me->Die();
            gSpriteMan.m_hasInvalid = true;
            break;
        }
    }
}

// SET X SPEED
void SpriteFunc::SetXSpeed(CSprite *me, SpriteComponent *obj)
{
    me->m_Xspd = obj->data1;
}

// SET Y SPEED
void SpriteFunc::SetYSpeed(CSprite *me, SpriteComponent *obj)
{
    me->m_Yspd = obj->data1;
}

// SET ALWAYS PROCESS
void SpriteFunc::SetAlwaysProcess(CSprite *me, SpriteComponent *obj)
{
    me->m_AlwaysProcess = (bool)obj->data1;
}

// SET VISIBLE
void SpriteFunc::SetVisible(CSprite *me, SpriteComponent *obj)
{
    me->m_Visible = (bool)obj->data1;
}

// SET HITBOX
void SpriteFunc::SetHitbox(CSprite *me, SpriteComponent *obj)
{
    if(obj->data5.find("circle") != std::wstring::npos)
        me->m_Hitbox.CollisionType = 1;
    else
        me->m_Hitbox.CollisionType = 0;
    me->m_Hitbox.Left_off = (short)obj->data1;
    me->m_Hitbox.Top_off = (short)obj->data2;
    me->m_Hitbox.W = (short)obj->data3;
    me->m_Hitbox.H = (short)obj->data4;
}

// TELEPORT NEAR PLAYER
void SpriteFunc::TeleportNearPlayer(CSprite *me, SpriteComponent *obj)
{
    Player_t *demo = PlayerF::Get(1);
    if(demo)
    {
        num_t cx = demo->Location.X;
        num_t cy = demo->Location.Y;
        num_t phase = iRand2(360);
        num_t xoff = num_t::sin(phase).times(obj->data1);
        num_t yoff = num_t::cos(phase).times(obj->data1);
        me->m_Xpos = cx + xoff;
        me->m_Ypos = cy + yoff;
    }
}

// TELEPORT TO
void SpriteFunc::TeleportTo(CSprite *me, SpriteComponent *obj)
{
    me->m_Xpos = obj->data1;
    me->m_Ypos = obj->data2;
}

// TRIGGER LUNA EVENT -- Trigger a lunadll script event (such as #1000)
void SpriteFunc::TriggerLunaEvent(CSprite *me, SpriteComponent *obj)
{
    UNUSED(me);
    if(obj->data1 > 21)
        gAutoMan.ActivateCustomEvents(0, (int)obj->data1);
}

// HARM PLAYER
void SpriteFunc::HarmPlayer(CSprite *me, SpriteComponent *obj)
{
    UNUSED(me);
    UNUSED(obj);
    PlayerHurt(1);
}

// GENERATE IN RADIUS
void SpriteFunc::GenerateInRadius(CSprite *me, SpriteComponent *obj)
{
    num_t rand_x;
    num_t rand_y;
    RandomPointInRadius(&rand_x, &rand_y, me->m_Hitbox.CenterX(), me->m_Hitbox.CenterY(), (int)obj->data3);

    CSpriteRequest req;
    req.type = 0;
    req.img_resource_code = (int)obj->data2;
    req.x = (int)rand_x;
    req.y = (int)rand_y;
    req.time = (int)obj->data4;
    req.str = obj->data5;
    req.spawned = true;

    gSpriteMan.InstantiateSprite(&req, false);
}

// GENERATE AT ANGLE
void SpriteFunc::GenerateAtAngle(CSprite *me, SpriteComponent *obj)
{
    num_t angle = me->GetCustomVar(CVAR_GEN_ANGLE);
    num_t speed = obj->data3;

    num_t vx = num_t::cos(angle).times(speed);     // vector x speed
    num_t vy = num_t::sin(angle).times(speed);     // vector y speed
    num_t gx = me->m_Hitbox.CenterX() + (vx * 2);  // generation point
    num_t gy = me->m_Hitbox.CenterY() + (vy * 2);  // generation point

    CSpriteRequest req;
    req.type = 0;
    req.img_resource_code = (int)obj->data2;
    req.x = (int)gx;
    req.y = (int)gy;
    req.time = (int)obj->data4;
    req.str = obj->data5;

    req.x_speed = vx;
    req.y_speed = vy;
    req.spawned = true;

    gSpriteMan.InstantiateSprite(&req, false);
}

// SPRITE TIMER
void SpriteFunc::SpriteTimer(CSprite *me, SpriteComponent *obj)
{
    bool repeat = (bool)obj->data3;
    int timer = (int)obj->run_time;
    if(timer == 1 || timer == 0)
    {
        if(timer == 1)
            obj->expired = true;
        Activate((int)obj->data4, me);

        if(repeat)
        {
            obj->expired = false;
            obj->run_time = obj->org_time;
        }
    }
}

// BASIC ANIMATE
void SpriteFunc::BasicAnimate(CSprite *me, SpriteComponent *obj)
{
    int anim_height = (int)obj->data1;
    if(anim_height == 0)
        anim_height = 1;
    int implicit_frames = (int)me->m_Ht / anim_height;

    // Init animation state if necessary
    if(!me->m_AnimationSet)
    {
        me->m_Hitbox.H = static_cast<short>(anim_height);
        me->m_AnimationFrame = 0;
        me->m_AnimationPhase = (int)obj->data2;
        me->m_AnimationTimer = (int)obj->data2;
        me->m_GfxRects.clear();
        for(int i = 0; i < implicit_frames; i++)
        {
            LunaRect temp;
            temp.left = 0;
            temp.right = (int)me->m_Wd;
            temp.top = (int)anim_height * i;
            temp.bottom = (int)anim_height; // <this is a HEIGHT argument
            me->m_GfxRects.push_back(temp);
        }
        me->m_AnimationSet = true;
    }

    // Process animation
    me->m_AnimationTimer--;
    if(me->m_AnimationTimer <= 0)
    {
        me->m_AnimationTimer = me->m_AnimationPhase;
        me->m_AnimationFrame += 1;
        if(me->m_AnimationFrame + 1 > implicit_frames)
            me->m_AnimationFrame = 0;
    }
}

// ANIMATE FLOAT
void SpriteFunc::AnimateFloat(CSprite *me, SpriteComponent *obj)
{
    num_t speed = obj->data1;
    num_t x_mag = obj->data2;
    num_t y_mag = obj->data3;
    if(speed != 0 && (x_mag != 0 || y_mag != 0))
    {
        num_t frame_val = num_t(me->m_FrameCounter).divided_by(speed);
        if(x_mag != 0)
            me->m_GfxXOffset = (int)(num_t::cos(frame_val).times(x_mag));
        if(y_mag != 0)
            me->m_GfxYOffset = (int)(num_t::sin(frame_val).times(y_mag));
    }
}

// BLINK
void SpriteFunc::Blink(CSprite *me, SpriteComponent *obj)
{
    int mod = (int)obj->run_time % (int)obj->data1;
    if(mod == 0)
        me->m_Visible = (bool)obj->data2;
    else
        me->m_Visible = (bool)(obj->data2 == 0 ? 1 : 0);
}

// SPRITE DEBUG
void SpriteFunc::SpriteDebug(CSprite *me, SpriteComponent *obj)
{
    UNUSED(obj);
    Renderer::Get().DebugPrint("XPOS - ", me->m_Xpos);
    Renderer::Get().DebugPrint("YPOS - ", me->m_Ypos);
    Renderer::Get().DebugPrint("XSPD - ", me->m_Xspd);
    Renderer::Get().DebugPrint("YSPD - ", me->m_Yspd);
    Renderer::Get().DebugPrint("FRAME - ", me->m_AnimationFrame);
    Renderer::Get().DebugPrint("VISIBLE - ", (me->m_Visible ? 1 : 0));
    Renderer::Get().DebugPrint("CVARS - ", (uint32_t)me->m_CustomVars.size());
    Renderer::Get().DebugPrint("BEHAVIORS - ", (uint32_t)me->m_BehavComponents.size());
}





// STATIC DRAW - Simply draw the sprite at its absolute screen coordinates
//               by registering a new bitmap render operation
void SpriteFunc::StaticDraw(CSprite *me)
{
    if(me != nullptr && me->m_Visible)
    {
        if(!me->m_directImg && me->m_GfxRects.empty()) // Workaround
        {
            auto *direct_img = Renderer::Get().GetImageForResourceCode(me->m_ImgResCode);
            if(direct_img)
                gSpriteMan.InitializeDimensions(me, false);
        }

        if(me->m_AnimationFrame < (signed)me->m_GfxRects.size())   // Frame should be less than size of GfxRect container
        {
            auto *op = new RenderBitmapOp();
            op->m_FramesLeft = 1;
            op->x = s_round2int(me->m_Xpos) + me->m_GfxXOffset;
            op->y = s_round2int(me->m_Ypos) + me->m_GfxYOffset;
            auto &r = me->m_GfxRects[me->m_AnimationFrame];
            op->sx = r.left;
            op->sy = r.top;
            op->sw = r.right;
            op->sh = r.bottom;
            if(me->m_directImg)
                op->direct_img = me->m_directImg;
            else
                op->direct_img = Renderer::Get().GetImageForResourceCode(me->m_ImgResCode);

            Renderer::Get().AddOp(op);
        }
    }
}

// RELATIVE DRAW - Calculate sprite position inside level and draw relative
//                 to camera position by registering new bitmap render operation
void SpriteFunc::RelativeDraw(CSprite *me)
{
    if(me != nullptr && me->m_Visible)
    {
        if(!me->m_directImg && me->m_GfxRects.empty()) // Workaround
        {
            auto *direct_img = Renderer::Get().GetImageForResourceCode(me->m_ImgResCode);
            if(direct_img)
                gSpriteMan.InitializeDimensions(me, false);
        }

        if(me->m_AnimationFrame < (signed)me->m_GfxRects.size())
        {
            // double cx = 0;              // camera x (top left of screen)
            // double cy = 0;              // camera y (top left of screen)
            int sx = s_round2int(me->m_Xpos);     // sprite x position (top left of sprite)
            int sy = s_round2int(me->m_Ypos);     // sprite y position (top left of sprite)
            sx +=  me->m_GfxXOffset;
            sy +=  me->m_GfxYOffset;

            // Calc screen draw position based on camera position
            // Render::CalcCameraPos(&cx, &cy);
            // sx = sx - cx;
            // sy = sy - cy;

            // Register drawing operation
            auto *op = new RenderBitmapOp();
            op->m_FramesLeft = 1;
            op->x = sx;
            op->y = sy;

            auto &r = me->m_GfxRects[me->m_AnimationFrame];
            op->sx = r.left;
            op->sy = r.top;
            op->sw = r.right;
            op->sh = r.bottom;

            if(me->m_directImg)
                op->direct_img = me->m_directImg;
            else
                op->direct_img = Renderer::Get().GetImageForResourceCode(me->m_ImgResCode);
            op->sceneCoords = true;
            op->m_renderPriority = RENDEROP_DEFAULT_PRIORITY_RENDEROP_SCENE;

            Renderer::Get().AddOp(op);
            return;
        }
    }
}


================================================
FILE: src/script/luna/sprite_funcs.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SpriteFuncs_HHHH
#define SpriteFuncs_HHHH

class CSprite;
struct SpriteComponent;

void Activate(int code, CSprite *spr);  // Formally add the components specified by "code" to sprite behaviors

namespace SpriteFunc
{

/////////////////////
/// Behavior funcs///
/////////////////////


// Collision funcs
void OnPlayerCollide(CSprite *me, SpriteComponent *obj);        // Activate given behavior when colliding with player
void OnPlayerDistance(CSprite *me, SpriteComponent *obj);
void PlayerCollectible(CSprite *me, SpriteComponent *obj);      // Calls Die() if detecting collision with player

// Sprite personal variable funcs
void SetSpriteVar(CSprite *me, SpriteComponent *obj);           // Set sprite custom variable
void IfSpriteVar(CSprite *me, SpriteComponent *obj);            // Activate component based on custom variable comparison
void IfLunaVar(CSprite *me, SpriteComponent *obj);              // Activate component based on lunadll user variable state

// Wait-on-condition funcs
void WaitForPlayer(CSprite *me, SpriteComponent *obj);          // Activate linked component on a player memory condition
void PlayerHoldingSprite(CSprite *me, SpriteComponent *obj);    // Activate linked component when player holding certain sprite

// Random funcs
void RandomComponent(CSprite *me, SpriteComponent *obj);        // Trigger one of 5 random component codes at a 25% chance each
void RandomComponentRange(CSprite *me, SpriteComponent *obj);   // Trigger a component code in the range of two numbers

// Self-action funcs
void Die(CSprite *me, SpriteComponent *obj);

// Speed funcs
void Deccelerate(CSprite *me, SpriteComponent *obj);        // Subtract sprite's speed towards minimum for each active frame
void Accelerate(CSprite *me, SpriteComponent *obj);         // Add to sprite's speed towards maximum for each active frame
void AccelToPlayer(CSprite *me, SpriteComponent *obj);      // Push towards player for each active frame
void ApplyVariableGravity(CSprite *me, SpriteComponent *obj); // Apply gravity specified in a lunadll variable

// Teleport funcs
void TeleportNearPlayer(CSprite *me, SpriteComponent *obj); // Direct set x/y position to somewhere in a circle around the player
void TeleportTo(CSprite *me, SpriteComponent *obj);         // Teleport to direct coordinates

// Move funcs
void PhaseMove(CSprite *me, SpriteComponent *obj);          // Move directly according to speed, ignoring collisions
void BumpMove(CSprite *me, SpriteComponent *obj);           // Move according to speed, bump into and reverse speed when colliding
void CrashMove(CSprite *me, SpriteComponent *obj);          // Calls die() when colliding with any block

// Set funcs
void SetXSpeed(CSprite *me, SpriteComponent *obj);
void SetYSpeed(CSprite *me, SpriteComponent *obj);
void SetAlwaysProcess(CSprite *me, SpriteComponent *obj);
void SetVisible(CSprite *me, SpriteComponent *obj);
void SetHitbox(CSprite *me, SpriteComponent *obj);

// Action funcs
void TriggerLunaEvent(CSprite *me, SpriteComponent *obj);   // Trigger a lunadll eventAT_BumpMove
void HarmPlayer(CSprite *me, SpriteComponent *obj);

// Generator funcs
void GenerateInRadius(CSprite *me, SpriteComponent *obj);   // Generate a sprite in a random radius around this sprite
void GenerateAtAngle(CSprite *me, SpriteComponent *obj);    // Generate a sprite with direction from CVAR_GEN_ANGLE

// Time funcs
void SpriteTimer(CSprite *me, SpriteComponent *obj);        // Counts down to 0 and then activates a component

// Animation funcs
void BasicAnimate(CSprite *me, SpriteComponent *obj);       // Simple animation func (moves drawing rect down the spritesheet)
void Blink(CSprite *me, SpriteComponent *obj);              // Cause sprite to blink by toggling visiblity flag on and off quickly
void AnimateFloat(CSprite *me, SpriteComponent *obj);       // Create "floaty" effect by oscillating graphics offset height

// Debug funcs
void SpriteDebug(CSprite *me, SpriteComponent *obj);        // Prints diagnostic information about the sprite this is attached to


//////////////////
/// Draw funcs ///
//////////////////

void StaticDraw(CSprite *me);       // Draw sprite to absolute position on the screen
void RelativeDraw(CSprite *me);     // Draw sprite inside level, relative to camera position
}

#endif // SpriteFuncs_HHHH


================================================
FILE: src/script/msg_macros.cpp
================================================
/*
 * Moondust, a free game engine and development kit for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#include <cstring>
#include <string>
#include <climits>
#include <array>
#include "msg_macros.h"

#ifdef MOONDUST_MSG_MACROS_ERROR_HANDLING
#   define MSG_MACRO_ERROR_ARG , MsgMacroErrors *error
#   define D_ERROR(arg) if(error) *error = arg
#   define D_ELSE_SEEN(arg) else_seen = arg
#   define D_CHECK_ELSE_SEEN else_seen
#else
#   define MSG_MACRO_ERROR_ARG
#   define D_ERROR(arg) (void)1
#   define D_ELSE_SEEN(arg) (void)1
#   define D_CHECK_ELSE_SEEN false
#endif


static void skip_spaces(const char*& buffer)
{
    while(*buffer == ' ')
        buffer++;
}

struct Keyword
{
    const char* str;
    const int length;
};

static int enumerateKeyword(const char*& buffer, const Keyword* keywords, int num_keywords)
{
    skip_spaces(buffer);

    for(int keyword_i = 0; keyword_i < num_keywords; keyword_i++)
    {
        const Keyword& keyword = keywords[keyword_i];

        // check whether keyword is a prefix of buffer
        if(strncmp(buffer, keyword.str, keyword.length) != 0)
            continue;

        // check whether buffer has a token separator following keyword (more validation can be done later)
        const char end = buffer[keyword.length];
        if(!(end == '\n' || end == ' ' || end == '\0' || end == '(' || end == ',' || end == ')'))
            continue;

        buffer += keyword.length;
        skip_spaces(buffer);

        return keyword_i;
    }

    return -1;
}

enum CondCmd
{
    CondCmd_Unknown = -1,
    // Regular "if"
    CondCmd_If = 0,
    // Regular "elif"
    CondCmd_Elif,
    // Regular "endif"
    CondCmd_Else,
    // Regular "else"
    CondCmd_Endif,
    // "if" without line breaking, space will be appended
    CondCmd_IW_If,
    // "if" without line breaking, nothing will be appended
    CondCmd_IN_If,
    // "endif" without line breaking, space will be appended
    CondCmd_IW_Endif,
    // "endif" without line breaking, nothing will be appended
    CondCmd_IN_Endif,
    // dummy limit item
    CondCmd_MAX,
};

const std::array<Keyword, CondCmd_MAX> commands = {Keyword{"if", 2}, Keyword{"elif", 4}, Keyword{"else", 4}, Keyword{"endif", 5}, Keyword{"if_iw", 5}, Keyword{"if_in", 5}, Keyword{"endif_iw", 8}, Keyword{"endif_in", 8}};

enum CondFunc
{
    CondFunc_Unknown = -1,
    CondFunc_Player = 0,
    CondFunc_State,
    CondFunc_MAX,
};

const std::array<Keyword, CondFunc_MAX> funcs = {Keyword{"player", 6}, Keyword{"state", 5}};

static CondCmd enumerateCmd(const char*& buffer)
{
    return (CondCmd)enumerateKeyword(buffer, commands.data(), commands.size());
}

static CondFunc enumerateFunc(const char*& buffer)
{
    return (CondFunc)enumerateKeyword(buffer, funcs.data(), funcs.size());
}

static int parseValue(const char*& buffer)
{
    skip_spaces(buffer);
    if(!std::isdigit(*buffer))
        return INT_MIN;

    int ret = std::atoi(buffer);

    while(std::isdigit(*buffer))
        buffer++;

    return ret;
}

void msgMacroProcess(const std::string &in, std::string &ret, int macro_player, int macro_state MSG_MACRO_ERROR_ARG)
{
    enum class Status
    {
        outside = 0,   // outside of if/else clause, lines go to output, wait for #if
        inside,        // inside an active clause, lines go to output, wait for #elif / #else / #endif
        skip_to_else,  // no clause has been triggered yet, look for next elif/else
        skip_to_endif, // a clause has been triggered, look for else
    } status = Status::outside;

    bool line_start = true;

#ifdef MOONDUST_MSG_MACROS_ERROR_HANDLING
    bool else_seen = false;
#endif

    for(const char* in_ptr = in.c_str(); *in_ptr != '\0';)
    {
        char cur = *in_ptr;
        in_ptr++;

        // check if this is a macro
        bool is_macro = (line_start && cur == '#');

        if(!is_macro)
        {
            if(status == Status::outside || status == Status::inside)
                ret.push_back(cur);

            line_start = (cur == '\n');
            continue;
        }

        // exit a current block
        if(status == Status::inside)
            status = Status::skip_to_endif;

        // advances in_ptr
        CondCmd cmd = enumerateCmd(in_ptr);

        if(cmd == CondCmd_Unknown)
        {
            D_ERROR(MSG_MACRO_ERROR_UNKNOWN_CMD);
            return;
        }
        else if(cmd == CondCmd_Endif || cmd == CondCmd_IW_Endif || cmd == CondCmd_IN_Endif)
        {
            if(status == Status::outside)
            {
                D_ERROR(MSG_MACRO_ERROR_ILLEGAL_CMD);
                return;
            }

            // if anything has been written from the current condition
            if(ret.size() && ret.back() == '\n' && status != Status::skip_to_else)
            {
                if(cmd == CondCmd_IN_Endif)
                    ret.pop_back();
                else if(cmd == CondCmd_IW_Endif)
                    ret.back() = ' ';
            }

            D_ELSE_SEEN(false);
            status = Status::outside;
        }
        else if(cmd == CondCmd_Else)
        {
            if(status == Status::outside || D_CHECK_ELSE_SEEN)
            {
                D_ERROR(MSG_MACRO_ERROR_ILLEGAL_CMD);
                return;
            }

            D_ELSE_SEEN(true);

            // enter the else clause if we haven't already matched
            if(status != Status::skip_to_endif)
                status = Status::inside;
        }
        // condition macros
        else
        {
            if(cmd == CondCmd_If || cmd == CondCmd_IW_If || cmd == CondCmd_IN_If)
            {
                if(status != Status::outside)
                {
                    D_ERROR(MSG_MACRO_ERROR_ILLEGAL_CMD);
                    return;
                }

                if(ret.size() && ret.back() == '\n')
                {
                    if(cmd == CondCmd_IN_If)
                        ret.pop_back();
                    else if(cmd == CondCmd_IW_If)
                        ret.back() = ' ';
                }
            }
            else if(status == Status::outside)
            {
                D_ERROR(MSG_MACRO_ERROR_ILLEGAL_CMD);
                return;
            }
            else if(D_CHECK_ELSE_SEEN)
            {
                D_ERROR(MSG_MACRO_ERROR_ILLEGAL_CMD);
                return;
            }

            // -- CONDITION CHECK CODE --
            // we have a condition to check, and decide whether to enter Status::inside or Status::skip_to_else
            CondFunc func = enumerateFunc(in_ptr);

            int true_value = 0;
            if(func == CondFunc_Unknown)
            {
                D_ERROR((*in_ptr == '\n') ? MSG_MACRO_ERROR_BAD_CMD_SYNTAX : MSG_MACRO_ERROR_UNKNOWN_FUNC);
                return;
            }
            else if(func == CondFunc_Player)
                true_value = macro_player;
            else if(func == CondFunc_State)
                true_value = macro_state;

            if(*(in_ptr++) != '(')
            {
                D_ERROR(MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
                return;
            }

            // look for value that matches true_value
            bool matched = false;
            while(true)
            {
                int value = parseValue(in_ptr);
                if(value == INT_MIN)
                {
                    D_ERROR((*in_ptr == '\n' || *in_ptr == '(' || *in_ptr == ',' || *in_ptr == ')') ? MSG_MACRO_ERROR_BAD_FUNC_SYNTAX : MSG_MACRO_ERROR_BAD_FUNC_ARGS);
                    return;
                }

#ifdef MOONDUST_MSG_MACROS_ERROR_HANDLING
                bool has_trailing_space = (*in_ptr == ' ');
#endif
                skip_spaces(in_ptr);

                if(value == true_value)
                    matched = true;

                char delim = *(in_ptr++);
                switch(delim)
                {
                case ')':
                    // double break below
                    break;
                case ',':
                    continue;
                default:
                    D_ERROR((delim == '\n' || delim == '(' || delim == '\0' || has_trailing_space) ? MSG_MACRO_ERROR_BAD_FUNC_SYNTAX : MSG_MACRO_ERROR_BAD_FUNC_ARGS);

                    return;
                }

                // case ')' from above
                break;
            }

            skip_spaces(in_ptr);

            if(status != Status::skip_to_endif)
            {
                if(matched)
                    status = Status::inside;
                else
                    status = Status::skip_to_else;
            }
        }

        // done with macro, time to proceed
        if(*in_ptr == '\0')
            break;

        if(*in_ptr != '\n')
        {
            D_ERROR(MSG_MACRO_ERROR_EXTRA_SYMBOLS_AT_END);
            return;
        }

        line_start = true;
        in_ptr++;
    }

    // remove trailing whitespace for legacy purposes
    if(ret.size() && ret.back() == '\n')
        ret.pop_back();

    D_ERROR(MSG_MACRO_ERROR_OK);
}


================================================
FILE: src/script/msg_macros.h
================================================
/*
 * Moondust, a free game engine and development kit for platform game making
 * Copyright (c) 2014-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * This software is licensed under a dual license system (MIT or GPL version 3 or later).
 * This means you are free to choose with which of both licenses (MIT or GPL version 3 or later)
 * you want to use this software.
 *
 * 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.
 *
 * You can see text of MIT license in the LICENSE.mit file you can see in Engine folder,
 * or see https://mit-license.org/.
 *
 * You can see text of GPLv3 license in the LICENSE.gpl3 file you can see in Engine folder,
 * or see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef MSGMACROS_H
#define MSGMACROS_H

#include <string>
#ifdef MOONDUST_UNIT_TEST
#   include <vector>
#   ifndef MOONDUST_MSG_MACROS_ERROR_HANDLING
#       define MOONDUST_MSG_MACROS_ERROR_HANDLING
#   endif
#endif

#ifdef MOONDUST_MSG_MACROS_ERROR_HANDLING
enum MsgMacroErrors
{
    MSG_MACRO_ERROR_OK = 0,
    MSG_MACRO_ERROR_BAD_CMD_SYNTAX,
    MSG_MACRO_ERROR_BAD_FUNC_SYNTAX,
    MSG_MACRO_ERROR_UNKNOWN_CMD,
    MSG_MACRO_ERROR_UNKNOWN_FUNC,
    MSG_MACRO_ERROR_BAD_FUNC_ARGS,
    MSG_MACRO_ERROR_EXTRA_SYMBOLS_AT_END,
    MSG_MACRO_ERROR_ILLEGAL_CMD,
};
#endif

#ifdef MOONDUST_UNIT_TEST
extern bool msgMacroParseTokens(const std::string &line, std::vector<std::string> &tokens);
#endif

#ifdef MOONDUST_MSG_MACROS_ERROR_HANDLING
/**
 * @brief Pre-Process the message (apply conditions, or place player names where is possible)
 * @param in Input text to pre-process
 * @param out Output text of pre-processing result
 * @param macro_player ID of playable character to match the condition
 * @param macro_state ID of character state to match the condition
 * @param error Optional parse error
 */
extern void msgMacroProcess(const std::string &in, std::string &out, int macro_player, int macro_state, MsgMacroErrors *error = nullptr);
#else // MOONDUST_MSG_MACROS_ERROR_HANDLING
/**
 * @brief Pre-Process the message (apply conditions, or place player names where is possible)
 * @param in Input text to pre-process
 * @param out Output text of pre-processing result
 * @param macro_player ID of playable character to match the condition
 * @param macro_state ID of character state to match the condition
 */
extern void msgMacroProcess(const std::string &in, std::string &out, int macro_player, int macro_state);
#endif // MOONDUST_MSG_MACROS_ERROR_HANDLING

#endif // MSGMACROS_H


================================================
FILE: src/script/msg_preprocessor.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "msg_preprocessor.h"
#include "msg_macros.h"

void preProcessMessage(std::string &text, int playerWho)
{
    std::string ret;
    bool canCheckPlayers = playerWho > 0 && playerWho <= numPlayers;
    int macro_player = canCheckPlayers ? Player[playerWho].Character : -1;
    int macro_state = canCheckPlayers ? Player[playerWho].State : -1;

    msgMacroProcess(text, ret, macro_player, macro_state);

    text = ret;
}


================================================
FILE: src/script/msg_preprocessor.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef MSG_PREPROCESSOR_H
#define MSG_PREPROCESSOR_H

#include <string>

/**
 * @brief Pre-Process the message (apply conditions, or place player names where is possible)
 * @param text Input-Output text to pre-process
 * @param playerWho The player number who triggered this message box, or -1 to heuristically detect somebody.
 */
extern void preProcessMessage(std::string &text, int playerWho);

#endif // MSG_PREPROCESSOR_H


================================================
FILE: src/sorting.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "globals.h"
#include "sorting.h"
#include "npc_traits.h"

#include <algorithm>

// these are now used only when saving levels
void qSortBlocksY(int min, int max)
{
    Block_t medBlock;
    int hi = 0;
    int lo = 0;
    int i = 0;
    if(min >= max)
        return;
    i = (max + min) / 2;
    medBlock = Block[i];
    Block[i] = Block[min];
    lo = min;
    hi = max;
    do
    {
        while(Block[hi].Location.Y >= medBlock.Location.Y)
        {
            hi -= 1;
            if(hi <= lo)
                break;
        }
        if(hi <= lo)
        {
            Block[lo] = medBlock;
            break;
        }
        Block[lo] = Block[hi];
        lo += 1;
        while(Block[lo].Location.Y < medBlock.Location.Y)
        {
            lo += 1;
            if(lo >= hi)
                break;
        }
        if(lo >= hi)
        {
            lo = hi;
            Block[hi] = medBlock;
            break;
        }
        Block[hi] = Block[lo];
    } while(true);
    qSortBlocksY(min, lo - 1);
    qSortBlocksY(lo + 1, max);
}

void qSortBlocksX(int min, int max)
{

    Block_t medBlock;
    int hi = 0;
    int lo = 0;
    int i = 0;
    if(min >= max)
        return;
    i = (max + min) / 2;
    medBlock = Block[i];
    Block[i] = Block[min];
    lo = min;
    hi = max;
    do
    {
        while(Block[hi].Location.X >= medBlock.Location.X)
        {
            hi -= 1;
            if(hi <= lo)
                break;
        }
        if(hi <= lo)
        {
            Block[lo] = medBlock;
            break;
        }
        Block[lo] = Block[hi];
        lo += 1;
        while(Block[lo].Location.X < medBlock.Location.X)
        {
            lo += 1;
            if(lo >= hi)
                break;
        }
        if(lo >= hi)
        {
            lo = hi;
            Block[hi] = medBlock;
            break;
        }
        Block[hi] = Block[lo];
    } while(true);
    qSortBlocksX(min, lo - 1);
    qSortBlocksX(lo + 1, max);
}

void qSortBlocks(int min, int max)
{
    if(min >= max)
        return;

    std::stable_sort(&Block[min], (&Block[max]) + 1,
    [](const Block_t& a, const Block_t& b)
    {
        return (a.Location.X <= b.Location.X
            && (a.Location.X < b.Location.X
                || a.Location.Y < b.Location.Y));
    });
}

void qSortBackgrounds(int min, int max, bool use_x)
{
    if(min >= max)
        return;

    std::stable_sort(&Background[min], (&Background[max]) + 1,
    [use_x](const Background_t& a, const Background_t& b)
    {
        return a.SortPriority < b.SortPriority || (use_x && a.SortPriority == b.SortPriority && a.Location.X < b.Location.X);
    });

    // old code was acceptable but didn't make it easy to sort by SortPriority first, Location second
#if 0
    Background_t medBackground;
    double medBackgroundPri = 0.0;
    int hi = 0;
    int lo = 0;
    int i = 0;
    if(min >= max)
        return;
    i = floor((max + min) / 2.0);
    medBackground = Background[i];
    medBackgroundPri = BackGroundPri(i);
    Background[i] = Background[min];
    lo = min;
    hi = max;
    do
    {
        while(BackGroundPri(hi) >= medBackgroundPri)
        {

            hi -= 1;
            if(hi <= lo)
                break;
        }
        if(hi <= lo)
        {
            Background[lo] = medBackground;
            break;
        }
        Background[lo] = Background[hi];
        lo += 1;
        while(BackGroundPri(lo) < medBackgroundPri)
        {
            lo += 1;
            if(lo >= hi)
                break;
        }
        if(lo >= hi)
        {
            lo = hi;
            Background[hi] = medBackground;
            break;
        }
        Background[hi] = Background[lo];
    } while(true);
    qSortBackgrounds(min, lo - 1);
    qSortBackgrounds(lo + 1, max);
#endif
}

// deprecated by block quadtree

#if 0
void FindBlocks()
{
    int A = 0;
    int B = 0;
//    int C = 0;
    int curBlk = 0;
//    bool fBool = false;
    curBlk = 1;
    for(A = -FLBlocks; A <= FLBlocks; A++)
    {
        for(B = curBlk; B <= numBlock; B++)
        {
            if(Block[B].Location.X + Block[B].Location.Width >= A * 32)
            {
                curBlk = int(B);
                break;
            }
        }
        FirstBlock[A] = curBlk;
    }
    curBlk = numBlock;

    for(A = FLBlocks; A >= -FLBlocks; A--)
    {
//        fBool = false;
        for(B = curBlk; B >= 1; B--)
        {
            if(Block[B].Location.X <= A * 32)
            {
                curBlk = int(B);
                break;
            }
        }
        LastBlock[A] = curBlk;
    }
    // BlocksSorted = true;
}

void BlockSort()
{
    int A = 0;
    int B = 0;
    Block_t tempBlock;

    // Sort Sizable Blocks
    for(A = 1; A <= numBlock; A++)
    {
        if(BlockIsSizable[Block[A].Type])
        {
            for(B = 1; B < A; B++)
            {
                if(!BlockIsSizable[Block[B].Type])
                {
                    tempBlock = Block[A];
                    Block[A] = Block[B];
                    Block[B] = tempBlock;
                    break;
                }
            }
        }
    }

    for(A = 1; A <= numBlock; A++)
    {
        if(BlockIsSizable[Block[A].Type])
        {
            for(B = 1; B <= numBlock; B++)
            {
                if(BlockIsSizable[Block[B].Type])
                {
                    if(B != 1)
                    {
                        if(Block[A].Location.Y < Block[B].Location.Y && A > B)
                        {
                            tempBlock = Block[A];
                            Block[A] = Block[B];
                            Block[B] = tempBlock;
                        }
                        else if(Block[A].Location.Y > Block[B].Location.Y && A < B)
                        {
                            tempBlock = Block[A];
                            Block[A] = Block[B];
                            Block[B] = tempBlock;
                        }
                    }
                }
            }
        }
    }
}

void BlockSort2()
{
    int A = 0;
    int B = 0;
    Block_t tempBlock;
    bool sortAgain = false;
    do
    {
        sortAgain = false;
        for(A = 1; A <= numBlock; A++)
        {
            for(B = 1; B <= numBlock; B++)
            {
                if(B != A)
                {
                    if(Block[A].Location.Y < Block[B].Location.Y && A > B)
                    {
                        tempBlock = Block[A];
                        Block[A] = Block[B];
                        Block[B] = tempBlock;
                        sortAgain = true;
                    }
                }
            }
        }
    } while(sortAgain);
}

void BackgroundSort()
{

    int A = 0;
    int B = 0;
    Background_t tempBackground;
    bool sortAgain = false;

    do
    {
        sortAgain = false;
        for(A = 1; A <= numBackground; A++)
        {
            for(B = 1; B <= numBackground; B++)
            {
                if(B != A)
                {
                    if(BackGroundPri(A) < BackGroundPri(B) && A > B)
                    {
                        tempBackground = Background[A];
                        Background[A] = Background[B];
                        Background[B] = tempBackground;
                        sortAgain = true;
                    }
                }
            }
        }
    } while(sortAgain);
}
#endif

//! checks if a custom layer is set, returns -2, -1, +1, or +2 if so, 0 if not
int Background_t::GetCustomLayer() const
{
    switch(SortPriority & 0xf8)
    {
    case(0x08):
    case(0x18):
    case(0x28):
        return -2;
    case(0x30):
    case(0x48):
    case(0x98):
        return -1;
    case(0xC0):
    case(0xD8):
        return +1;
    case(0xF8):
        return +2;
    default:
        return 0;
    }
}

//! returns the custom offset of a BGO
int Background_t::GetCustomOffset() const
{
    return int((SortPriority) & 0x07) - 4;
}

//! update a background's priority based on its current type, custom layer, and custom offset
void Background_t::UpdateSortPriority()
{
    // check user-specified Z-layer
    int user_order = GetCustomLayer();

    // clear upper 5 bits
    SortPriority &= ~0xf8;

    // set upper 5 bits by user order
    if(user_order)
    {
        int user_offset = GetCustomOffset();

        if(user_order == -2 && user_offset < 0)
            SortPriority |= 0x08;
        else if(user_order == -2 && user_offset == 0)
            SortPriority |= 0x18;
        else if(user_order == -2)
            SortPriority |= 0x28;
        else if(user_order == -1 && user_offset < 0)
            SortPriority |= 0x30;
        else if(user_order == -1 && user_offset == 0)
            SortPriority |= 0x48;
        else if(user_order == -1)
            SortPriority |= 0x98;
        else if(user_order == +1 && user_offset <= 0)
            SortPriority |= 0xC0;
        else if(user_order == +1)
            SortPriority |= 0xD8;
        else
            SortPriority |= 0xF8;

        return;
    }

    // set upper 5 bits by Type-based order

    // PLANE_LVL_BGO_LOW
    // custom -2 with - offset is 0x08
    if(Type == 75 || Type == 76 || Type == 77 || Type == 78 || Type == 14)
        SortPriority |= 0x10;
    // custom -2 with 0 offset is 0x18
    else if(Type == 11 || Type == 12 || Type == 60 || Type == 61)
        SortPriority |= 0x20;
    // custom -2 with + offset is 0x28
    // PLANE_LVL_BGO_NORM
    // custom -1 with - offset is 0x30
    else if(Type == 168 || Type == 159 || Type == 172 || Type == 66 || Type == 158) // WATER FALLS
        SortPriority |= 0x38;
    else if(Type == 65 || Type == 26 || Type == 82 || Type == 83 || Type == 164 || Type == 165 || Type == 166 || Type == 167 || Type == 168 || Type == 169) // WATER
        SortPriority |= 0x40;
    // custom -1 with 0 offset is 0x48
    else if(Type == 79 || Type == 52)
        SortPriority |= 0x50;
    else if(Type == 66)
        SortPriority |= 0x58;
    // default is 0x60
    else if(Type == 1)
        SortPriority |= 0x68;
    else if(Type >= 129 && Type <= 131)
        SortPriority |= 0x70;
    else if(Type == 139 || Type == 140 || Type == 48)
        SortPriority |= 0x78;
    else if(Type == 70 || Type == 71 || Type == 72 || Type == 73 || Type == 74 || Type == 141)
        SortPriority |= 0x80;
    else if(Type == 87 || Type == 88 || Type == 92 || Type == 107 || Type == 105 || Type == 104) // Doors
        SortPriority |= 0x88;
    else if(Type == 99)
        SortPriority |= 0x90; // Always doors + 1
    // custom -1 with + offset is 0x98
    // PLANE_LVL_BGO_FG
    // custom +1 with - or 0 offset is 0xC0
    else if(Foreground[Type])
        SortPriority |= 0xC8;
    else if(Type == 65 || Type == 165)
        SortPriority |= 0xD0;
    // custom +1 with + offset is 0xD8
    // PLANE_LVL_BGO_TOP
    // custom +2 is 0xF8
    else
        SortPriority |= 0x60;
}

//! sets custom layer and offset bits for a bgo and updates its sort priority
void Background_t::SetSortPriority(int layer, int offset)
{
    SortPriority = 0;

    // set upper 5 bits by layer
    if(layer == -2)
        SortPriority = 0x18;
    else if(layer == -1)
        SortPriority = 0x48;
    else if(layer == +1)
        SortPriority = 0xC0;
    else if(layer == +2)
        SortPriority = 0xF8;

    // set lower 3 bits by offset
    uint8_t offset_bits = uint8_t(offset + 4) & 7;
    SortPriority |= offset_bits;

    UpdateSortPriority();
}


#if 0
double BackGroundPri(int A)
{
    double tempBackGroundPri = 0;


    if(Background[A].SortPriority > 0) // Custom priority per every BGO
        tempBackGroundPri = Background[A].SortPriority;
    // Lower Numbers get drawn first
    else if(Background[A].Type == 11 || Background[A].Type == 12 || Background[A].Type == 60 || Background[A].Type == 61)
        tempBackGroundPri = 20;
    else if(Background[A].Type == 65 || Background[A].Type == 26 || Background[A].Type == 82 || Background[A].Type == 83 || Background[A].Type == 164 || Background[A].Type == 165 || Background[A].Type == 166 || Background[A].Type == 167 || Background[A].Type == 168 || Background[A].Type == 169) // WATER

        tempBackGroundPri = 26;
    else if(Background[A].Type == 168 || Background[A].Type == 159 || Background[A].Type == 172 || Background[A].Type == 66 || Background[A].Type == 158) // WATER FALLS
        tempBackGroundPri = 25;
    else if(Background[A].Type == 75 || Background[A].Type == 76 || Background[A].Type == 77 || Background[A].Type == 78 || Background[A].Type == 14)
        tempBackGroundPri = 10;
    else if(Background[A].Type == 79 || Background[A].Type == 52)
        tempBackGroundPri = 30;
    else if(Background[A].Type == 70 || Background[A].Type == 71 || Background[A].Type == 72 || Background[A].Type == 73 || Background[A].Type == 74 || Background[A].Type == 141)
        tempBackGroundPri = 90;
    else if(Background[A].Type == 139 || Background[A].Type == 140 || Background[A].Type == 48)
        tempBackGroundPri = 80;
    else if(Background[A].Type == 65 || Background[A].Type == 165)
        tempBackGroundPri = 150;
    else if(Foreground[Background[A].Type])
        tempBackGroundPri = 125;
    else if(Background[A].Type == 66)
        tempBackGroundPri = 50;
    else if(Background[A].Type == 99)
        tempBackGroundPri = 99; // Always doors + 1
    else if(Background[A].Type == 87 || Background[A].Type == 88 || Background[A].Type == 92 || Background[A].Type == 107 || Background[A].Type == 105 || Background[A].Type == 104) // Doors
        tempBackGroundPri = 98;
    else if(Background[A].Type >= 129 && Background[A].Type <= 131)
        tempBackGroundPri = 76;
    else if(Background[A].Type == 1)
        tempBackGroundPri = 77;
    else
        tempBackGroundPri = 75;

    //tempBackGroundPri += Background[A].Location.X / 10000000.0;
    tempBackGroundPri += Background[A].uid / 100000000000.0;
    tempBackGroundPri += Background[A].zOffset;


    return tempBackGroundPri;
}
#endif

void NPCSort()
{
    int A = 0;
    int B = 0;
    NPC_t tempNPC;

    for(A = 1; A <= numNPCs; A++)
    {
        if(NPC[A]->IsACoin)
        {
            for(B = 1; B < A; B++)
            {
                if(!NPC[B]->IsACoin)
                {
                    tempNPC = NPC[A];
                    NPC[A] = NPC[B];
                    NPC[B] = tempNPC;
                    break;
                }
            }
        }
    }
}

// deprecated
#if 0
void FindSBlocks()
{
    int A = 0;
    sBlockNum = 0;
    for(A = 1; A <= numBlock; A++)
    {
        if(BlockIsSizable[Block[A].Type])
        {
            sBlockNum += 1;
            sBlockArray[sBlockNum] = A;
        }
    }
    qSortSBlocks(1, sBlockNum);
}

void qSortSBlocks(int min, int max)
{
    int medBlock = 0;
    int hi = 0;
    int lo = 0;
    int i = 0;
    if(min >= max)
        return;

    i = floor((max + min) / 2.0);
    medBlock = sBlockArray[i];
    sBlockArray[i] = sBlockArray[min];
    lo = min;
    hi = max;
    do
    {
        while(Block[sBlockArray[hi]].Location.Y >= Block[medBlock].Location.Y)
        {
            hi -= 1;
            if(hi <= lo)
                break;
        }
        if(hi <= lo)
        {
            sBlockArray[lo] = medBlock;
            break;
        }
        sBlockArray[lo] = sBlockArray[hi];
        lo += 1;
        while(Block[sBlockArray[lo]].Location.Y < Block[medBlock].Location.Y)
        {
            lo += 1;
            if(lo >= hi)
                break;
        }
        if(lo >= hi)
        {
            lo = hi;
            sBlockArray[hi] = medBlock;
            break;
        }
        sBlockArray[hi] = sBlockArray[lo];
    } while(true);
    qSortSBlocks(min, lo - 1);
    qSortSBlocks(lo + 1, max);
}
#endif

void qSortNPCsY(int min, int max)
{
    NPC_t medNPC;
    int hi = 0;
    int lo = 0;
    int i = 0;
    if(min >= max)
        return;
    i = (max + min) / 2;
    medNPC = NPC[i];
    NPC[i] = NPC[min];
    lo = min;
    hi = max;
    do
    {
        while(NPC[hi].Location.Y < medNPC.Location.Y)
        {
            hi -= 1;
            if(hi <= lo)
                break;
        }
        if(hi <= lo)
        {
            NPC[lo] = medNPC;
            break;
        }
        NPC[lo] = NPC[hi];
        lo += 1;
        while(NPC[lo].Location.Y >= medNPC.Location.Y)
        {
            lo += 1;
            if(lo >= hi)
                break;
        }
        if(lo >= hi)
        {
            lo = hi;
            NPC[hi] = medNPC;
            break;
        }
        NPC[hi] = NPC[lo];
    } while(true);
    qSortNPCsY(min, lo - 1);
    qSortNPCsY(lo + 1, max);
}

void UpdateBackgrounds()
{
    int A = 0;
    int B = 0;
    LastBackground = numBackground;
    MidBackground = 1;
    for(A = 1; A <= numBackground; A++)
    {
        if(Background[A].SortPriority >= Background_t::PRI_NORM_START)
        {
            for(B = A; B <= numBackground; B++)
            {
                if(Background[B].SortPriority >= Background_t::PRI_FG_START)
                {
                    LastBackground = B - 1;
                    break;
                }
            }
            break;
        }
    }
    MidBackground = A;
//    if(noUpdate == false)
//        Netplay::sendData "s" + std::to_string(numBackground) + LB;
}

// deprecated
#if 0
void qSortTempBlocksX(int min, int max)
{
    Block_t medBlock;
    int hi = 0;
    int lo = 0;
    int i = 0;

    if(min >= max)
        return;

    i = floor((max + min) / 2.0);
    medBlock = Block[i];
    Block[i] = Block[min];
    lo = min;
    hi = max;

    do
    {
        while(Block[hi].Location.X >= medBlock.Location.X)
        {
            hi -= 1;
            if(hi <= lo)
                break;
        }
        if(hi <= lo)
        {
            Block[lo] = medBlock;
            break;
        }
        Block[lo] = Block[hi];
        lo += 1;
        while(Block[lo].Location.X < medBlock.Location.X)
        {
            lo += 1;
            if(lo >= hi)
                break;
        }
        if(lo >= hi)
        {
            lo = hi;
            Block[hi] = medBlock;
            break;
        }
        Block[hi] = Block[lo];
    } while(true);

    qSortBlocksX(min, lo - 1);
    qSortBlocksX(lo + 1, max);
}
#endif


================================================
FILE: src/sorting.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SORTING_H
#define SORTING_H

// most functions here have been deprecated by the corresponding quadtree functions, but should be preserved for historical comparison

// Public Sub qSortBlocksY(min As Integer, max As Integer) 'quicksort the blocks Y
// quicksort the blocks Y (kept for compatibility with coin switch logic)
void qSortBlocksY(int min, int max);
// Public Sub qSortBlocksX(min As Integer, max As Integer) 'quicksort the blocks X
// quicksort the blocks X (kept for compatibility with coin switch and tempBlock logic)
void qSortBlocksX(int min, int max);
// NEW: just sort them all at once, stably (used at save to prevent altering order as much as possible)
void qSortBlocks(int min, int max);
// Public Sub qSortBackgrounds(min As Integer, max As Integer) 'quicksort the backgrounds
// quicksort the backgrounds
void qSortBackgrounds(int min, int max, bool use_x = true);

// Public Sub FindBlocks() 'create a table of contents for blocks for an optimization
// create a table of contents for blocks for an optimization
// void FindBlocks();

// Public Sub BlockSort() 'sizable block sorting
// sizable block sorting
// void BlockSort();
// Public Sub BlockSort2() 'Super Block sorting / slow and only used when saving
// Super Block sorting / slow and only used when saving
// void BlockSort2();
// Public Sub BackgroundSort()
// void BackgroundSort();

// Public Function BackGroundPri(A As Integer) As Double 'finds where the backgrounds should be put to set drawing priority
// finds where the backgrounds should be put to set drawing priority
// double BackGroundPri(int A);
// Public Sub NPCSort()
void NPCSort();
// Public Sub FindSBlocks() 'sorts sizable blocks
// sorts sizable blocks
// void FindSBlocks();
// Public Sub qSortSBlocks(min As Integer, max As Integer)
// void qSortSBlocks(int min, int max);
// Public Sub qSortNPCsY(min As Integer, max As Integer)
void qSortNPCsY(int min, int max);
// Public Sub UpdateBackgrounds()
void UpdateBackgrounds();
// Public Sub qSortTempBlocksX(min As Integer, max As Integer)
// void qSortTempBlocksX(int min, int max);


#endif // SORTING_H


================================================
FILE: src/sound/fx/fx_common.hpp
================================================
#ifndef FX_COMMON_HPP
#define FX_COMMON_HPP

#include <stdint.h>
#include "fx_format.h"

#ifndef INT8_MIN
#define INT8_MIN    (-0x7f - 1)
#endif
#ifndef INT8_MAX
#define INT8_MAX    0x7f
#endif

#ifndef UINT8_MAX
#define UINT8_MAX   0xff
#endif

#ifndef INT16_MIN
#define INT16_MIN   (-0x7fff - 1)
#endif
#ifndef INT16_MAX
#define INT16_MAX   0x7fff
#endif

#ifndef UINT16_MAX
#define UINT16_MAX  0xffff
#endif

#ifndef INT32_MIN
#define INT32_MIN   (-0x7fffffff - 1)
#endif

#ifndef INT32_MAX
#define INT32_MAX   0x7fffffff
#endif

#define MAX_CHANNELS    10

// Float32-LE
static float getFloatLSBSample(uint8_t *raw, int c)
{
    union
    {
        float f;
        uint32_t r;
    } o;
    raw += (c * sizeof(float));
    o.r = (((uint32_t)raw[0] <<  0) & 0x000000FF) |
          (((uint32_t)raw[1] <<  8) & 0x0000FF00) |
          (((uint32_t)raw[2] << 16) & 0x00FF0000) |
          (((uint32_t)raw[3] << 24) & 0xFF000000);
    return o.f;
}
static void setFloatLSBSample(uint8_t **raw, float ov)
{
    void *t = &ov;
    uint32_t r = *(uint32_t*)t;
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 16) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 24) & 0xFF);
}

// Float32-BE
static float getFloatMSBSample(uint8_t *raw, int c)
{
    union
    {
        float f;
        uint32_t r;
    } o;
    raw += (c * sizeof(float));
    o.r = (((uint32_t)raw[3] <<  0) & 0x000000FF) |
          (((uint32_t)raw[2] <<  8) & 0x0000FF00) |
          (((uint32_t)raw[1] << 16) & 0x00FF0000) |
          (((uint32_t)raw[0] << 24) & 0xFF000000);
    return o.f;
}
static void setFloatMSBSample(uint8_t **raw, float ov)
{
    void *t = &ov;
    uint32_t r = *(uint32_t*)t;
    *(*raw)++ = (uint8_t)((r >> 24) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 16) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
}

// int32_t-LE
static float getInt32LSB(uint8_t *raw, int c)
{
    uint32_t r;
    int32_t f;
    raw += (c * sizeof(int32_t));
    r = (((uint32_t)raw[0] <<  0) & 0x000000FF) |
        (((uint32_t)raw[1] <<  8) & 0x0000FF00) |
        (((uint32_t)raw[2] << 16) & 0x00FF0000) |
        (((uint32_t)raw[3] << 24) & 0xFF000000);
    f = *(int32_t*)(&r);
    return (float)((double)f / INT32_MAX);
}
static void setInt32LSB(uint8_t **raw, float ov)
{
    int32_t f = ((int32_t)(double(ov) * INT32_MAX));
    uint32_t r = *(uint32_t*)(&f);
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 16) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 24) & 0xFF);
}

// int32_t-BE
static float getInt32MSB(uint8_t *raw, int c)
{
    uint32_t r;
    int32_t f;
    raw += (c * sizeof(int32_t));
    r = (((uint32_t)raw[3] <<  0) & 0x000000FF) |
        (((uint32_t)raw[2] <<  8) & 0x0000FF00) |
        (((uint32_t)raw[1] << 16) & 0x00FF0000) |
        (((uint32_t)raw[0] << 24) & 0xFF000000);
    f = *(int32_t*)(&r);
    return (float)((double)f / INT32_MAX);
}
static void setInt32MSB(uint8_t **raw, float ov)
{
    int32_t f = (int32_t(double(ov) * INT32_MAX));
    uint32_t r = *(uint32_t*)(&f);
    *(*raw)++ = (uint8_t)((r >> 24) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 16) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
}

// int16_t-LE
static float getInt16LSB(uint8_t *raw, int c)
{
    uint16_t r;
    int16_t f;
    raw += (c * sizeof(int16_t));
    r = (((uint16_t)raw[0] <<  0) & 0x00FF) |
        (((uint16_t)raw[1] <<  8) & 0xFF00);
    f = *(int16_t*)(&r);
    return (float)f / INT16_MAX;
}
static void setInt16LSB(uint8_t **raw, float ov)
{
    int16_t f = int16_t(ov * INT16_MAX);
    uint16_t r = *(uint16_t*)(&f);
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
}

// int16_t-BE
static float getInt16MSB(uint8_t *raw, int c)
{
    uint16_t r;
    int16_t f;
    raw += (c * sizeof(int16_t));
    r = (((uint16_t)raw[1] <<  0) & 0x00FF) |
        (((uint16_t)raw[0] <<  8) & 0xFF00);
    f = *(int16_t*)(&r);
    return (float)f / INT16_MIN;
}
static void setInt16MSB(uint8_t **raw, float ov)
{
    int16_t f = int16_t(ov * INT16_MAX);
    uint16_t r = *(uint16_t*)(&f);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
}

// uint16_t-LE
static float getuint16_tLSB(uint8_t *raw, int c)
{
    uint16_t r;
    float f;
    raw += (c * sizeof(uint16_t));
    r = (((uint16_t)raw[0] <<  0) & 0x00FF) |
        (((uint16_t)raw[1] <<  8) & 0xFF00);
    f = ((float)r + INT16_MIN) / INT16_MAX;
    return f;
}
static void setuint16_tLSB(uint8_t **raw, float ov)
{
    int16_t f = int16_t((ov * INT16_MAX) - INT16_MIN);
    uint16_t r = *(uint16_t*)(&f);
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
}

// uint16_t-BE
static float getuint16_tMSB(uint8_t *raw, int c)
{
    uint16_t r;
    float f;
    raw += (c * sizeof(uint16_t));
    r = (((uint16_t)raw[1] <<  0) & 0x00FF) |
        (((uint16_t)raw[0] <<  8) & 0xFF00);
    f = ((float)r + INT16_MIN) / INT16_MAX;
    return f;
}
static void setuint16_tMSB(uint8_t **raw, float ov)
{
    int16_t f = int16_t((ov * INT16_MAX) - INT16_MIN);
    uint16_t r = *(uint16_t*)(&f);
    *(*raw)++ = (uint8_t)((r >> 8) & 0xFF);
    *(*raw)++ = (uint8_t)((r >> 0) & 0xFF);
}

// int8_t
static float getInt8(uint8_t *raw, int c)
{
    float f;
    raw += (c * sizeof(int8_t));
    f = (float)(int8_t)(*raw) / INT8_MAX;
    return f;
}
static void setInt8(uint8_t **raw, float ov)
{
    *(*raw)++ = (uint8_t)(ov * INT8_MAX);
}

// uint8_t
static float getuint8_t(uint8_t *raw, int c)
{
    float f;
    raw += (c * sizeof(int8_t));
    f = (float)((int)*raw + INT8_MIN) / INT8_MAX;
    return f;
}
static void setuint8_t(uint8_t **raw, float ov)
{
    *(*raw)++ = (uint8_t)((ov * INT8_MAX) - INT8_MIN);
}


typedef float (*ReadSampleCB)(uint8_t* raw, int channel);
typedef  void (*WriteSampleCB)(uint8_t** raw, float sample);

static bool initFormat(ReadSampleCB &readSample,
                       WriteSampleCB &writeSample,
                       int &sample_size, uint16_t format)
{
    switch(format)
    {
    case AUDIO_U8:
        readSample = getuint8_t;
        writeSample = setuint8_t;
        sample_size = sizeof(uint8_t);
        break;

    case AUDIO_S8:
        readSample = getInt8;
        writeSample = setInt8;
        sample_size = sizeof(int8_t);
        break;

    case AUDIO_S16LSB:
        readSample = getInt16LSB;
        writeSample = setInt16LSB;
        sample_size = sizeof(int16_t);
        break;

    case AUDIO_S16MSB:
        readSample = getInt16MSB;
        writeSample = setInt16MSB;
        sample_size = sizeof(int16_t);
        break;

    case AUDIO_U16LSB:
        readSample = getuint16_tLSB;
        writeSample = setuint16_tLSB;
        sample_size = sizeof(uint16_t);
        break;

    case AUDIO_U16MSB:
        readSample = getuint16_tMSB;
        writeSample = setuint16_tMSB;
        sample_size = sizeof(uint16_t);
        break;

    case AUDIO_S32LSB:
        readSample = getInt32LSB;
        writeSample = setInt32LSB;
        sample_size = sizeof(int32_t);
        break;

    case AUDIO_S32MSB:
        readSample = getInt32MSB;
        writeSample = setInt32MSB;
        sample_size = sizeof(int32_t);
        break;

    case AUDIO_F32LSB:
        readSample = getFloatLSBSample;
        writeSample = setFloatLSBSample;
        sample_size = sizeof(float);
        break;

    case AUDIO_F32MSB:
        readSample = getFloatMSBSample;
        writeSample = setFloatMSBSample;
        sample_size = sizeof(float);
        break;

    default:
        return false; /* Unsupported format */
    }

    return true;
}


#endif // FX_COMMON_HPP


================================================
FILE: src/sound/fx/fx_format.h
================================================
#ifndef FX_FORMAT_H
#define FX_FORMAT_H

/* Types are same as at the SDL2 */
#ifndef AUDIO_U8
#define AUDIO_U8        0x0008  /**< Unsigned 8-bit samples */
#define AUDIO_S8        0x8008  /**< Signed 8-bit samples */
#define AUDIO_U16LSB    0x0010  /**< Unsigned 16-bit samples */
#define AUDIO_S16LSB    0x8010  /**< Signed 16-bit samples */
#define AUDIO_U16MSB    0x1010  /**< As above, but big-endian byte order */
#define AUDIO_S16MSB    0x9010  /**< As above, but big-endian byte order */
#define AUDIO_U16       AUDIO_U16LSB
#define AUDIO_S16       AUDIO_S16LSB
#define AUDIO_S32LSB    0x8020  /**< 32-bit integer samples */
#define AUDIO_S32MSB    0x9020  /**< As above, but big-endian byte order */
#define AUDIO_S32       AUDIO_S32LSB
#define AUDIO_F32LSB    0x8120  /**< 32-bit floating point samples */
#define AUDIO_F32MSB    0x9120  /**< As above, but big-endian byte order */
#define AUDIO_F32       AUDIO_F32LSB
#endif

#endif // FX_FORMAT_H


================================================
FILE: src/sound/fx/reverb.cpp
================================================
/*
 * Simple Reverb sound effect
 *
 * Copyright (c) 2022-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include <cstddef>
#include <vector>
#include <deque>
#include <cmath>
#include <tgmath.h>
#include "reverb.h"
#include "fx_common.hpp"


// Code was taken from FreeVerb: https://github.com/sinshu/freeverb (Public Domain)

// Written by Jezar at Dreampoint, June 2000
// http://www.dreampoint.co.uk
// This code is public domain

const int   numcombs        = 8;
const int   numallpasses    = 4;
const float muted           = 0;
const float fixedgain       = 0.015f;
const float scalewet        = 3;
const float scaledry        = 2;
const float scaledamp       = 0.4f;
const float scaleroom       = 0.28f;
const float offsetroom      = 0.7f;
const float initialroom     = 0.5f;
const float initialdamp     = 0.5f;
const float initialwet      = 1 / scalewet;
const float initialdry      = 0;
const float initialwidth    = 1;
const float initialmode     = 0;
const float freezemode      = 0.5f;
const int   stereospread    = 23;

// These values assume 44.1KHz sample rate
// they will probably be OK for 48KHz sample rate
// but would need scaling for 96KHz (or other) sample rates.
// The values were obtained by listening tests.
const int combtuningL1      = 1116;
const int combtuningR1      = 1116 + stereospread;
const int combtuningL2      = 1188;
const int combtuningR2      = 1188 + stereospread;
const int combtuningL3      = 1277;
const int combtuningR3      = 1277 + stereospread;
const int combtuningL4      = 1356;
const int combtuningR4      = 1356 + stereospread;
const int combtuningL5      = 1422;
const int combtuningR5      = 1422 + stereospread;
const int combtuningL6      = 1491;
const int combtuningR6      = 1491 + stereospread;
const int combtuningL7      = 1557;
const int combtuningR7      = 1557 + stereospread;
const int combtuningL8      = 1617;
const int combtuningR8      = 1617 + stereospread;
const int allpasstuningL1   = 556;
const int allpasstuningR1   = 556 + stereospread;
const int allpasstuningL2   = 441;
const int allpasstuningR2   = 441 + stereospread;
const int allpasstuningL3   = 341;
const int allpasstuningR3   = 341 + stereospread;
const int allpasstuningL4   = 225;
const int allpasstuningR4   = 225 + stereospread;


static inline void undenormalise(float &sample)
{
    uint32_t i = *reinterpret_cast<uint32_t*>(&sample);
    if((i & 0x7f800000) == 0)
        sample = 0.0f;
}


class comb
{
public:
    comb()
    {
        filterstore = 0;
        bufidx = 0;
    }

    void setbuffer(float* buf, int size)
    {
        buffer = buf;
        bufsize = size;
    }

    // Big to inline - but crucial for speed
    inline float process(float input)
    {
        float output;

        output = buffer[bufidx];
        undenormalise(output);

        filterstore = (output * damp2) + (filterstore * damp1);
        undenormalise(filterstore);

        buffer[bufidx] = input + (filterstore * feedback);

        if(++bufidx >= bufsize) bufidx = 0;

        return output;
    }

    void mute()
    {
        for(int i = 0; i < bufsize; i++)
            buffer[i] = 0;
    }

    void setdamp(float val)
    {
        damp1 = val;
        damp2 = 1 - val;
    }

    float getdamp()
    {
        return damp1;
    }

    void setfeedback(float val)
    {
        feedback = val;
    }

    float getfeedback()
    {
        return feedback;
    }

private:
    float   feedback = 0.f;
    float   filterstore = 0.f;
    float   damp1 = 0.f;
    float   damp2 = 0.f;
    float*  buffer = nullptr;
    int     bufsize = 0;
    int     bufidx = 0;
};


class allpass
{
public:
    allpass()
    {
        bufidx = 0;
    }

    void setbuffer(float* buf, int size)
    {
        buffer = buf;
        bufsize = size;
    }

    // Big to inline - but crucial for speed
    inline float process(float input)
    {
        float output;
        float bufout;

        bufout = buffer[bufidx];
        undenormalise(bufout);

        output = -input + bufout;
        buffer[bufidx] = input + (bufout * feedback);

        if(++bufidx >= bufsize)
            bufidx = 0;

        return output;
    }

    void mute()
    {
        for(int i = 0; i < bufsize; i++)
            buffer[i] = 0;
    }

    void setfeedback(float val)
    {
        feedback = val;
    }

    float getfeedback()
    {
        return feedback;
    }

    // private:
    float   feedback = 0.f;
    float*  buffer = nullptr;
    int     bufsize = 0;
    int     bufidx = 0;
};


class revmodel
{
    double rateScale = 1.0;

public:
    void setSampleRate(int rate)
    {
        rateScale = rate / 44100.0;
        // Prepare buffers
        bufcombL1.resize(static_cast<size_t>(combtuningL1 * rateScale));
        bufcombR1.resize(static_cast<size_t>(combtuningR1 * rateScale));
        bufcombL2.resize(static_cast<size_t>(combtuningL2 * rateScale));
        bufcombR2.resize(static_cast<size_t>(combtuningR2 * rateScale));
        bufcombL3.resize(static_cast<size_t>(combtuningL3 * rateScale));
        bufcombR3.resize(static_cast<size_t>(combtuningR3 * rateScale));
        bufcombL4.resize(static_cast<size_t>(combtuningL4 * rateScale));
        bufcombR4.resize(static_cast<size_t>(combtuningR4 * rateScale));
        bufcombL5.resize(static_cast<size_t>(combtuningL5 * rateScale));
        bufcombR5.resize(static_cast<size_t>(combtuningR5 * rateScale));
        bufcombL6.resize(static_cast<size_t>(combtuningL6 * rateScale));
        bufcombR6.resize(static_cast<size_t>(combtuningR6 * rateScale));
        bufcombL7.resize(static_cast<size_t>(combtuningL7 * rateScale));
        bufcombR7.resize(static_cast<size_t>(combtuningR7 * rateScale));
        bufcombL8.resize(static_cast<size_t>(combtuningL8 * rateScale));
        bufcombR8.resize(static_cast<size_t>(combtuningR8 * rateScale));
        bufallpassL1.resize(static_cast<size_t>(allpasstuningL1 * rateScale));
        bufallpassR1.resize(static_cast<size_t>(allpasstuningR1 * rateScale));
        bufallpassL2.resize(static_cast<size_t>(allpasstuningL2 * rateScale));
        bufallpassR2.resize(static_cast<size_t>(allpasstuningR2 * rateScale));
        bufallpassL3.resize(static_cast<size_t>(allpasstuningL3 * rateScale));
        bufallpassR3.resize(static_cast<size_t>(allpasstuningR3 * rateScale));
        bufallpassL4.resize(static_cast<size_t>(allpasstuningL4 * rateScale));
        bufallpassR4.resize(static_cast<size_t>(allpasstuningR4 * rateScale));

        // Tie the components to their buffers
        combL[0].setbuffer(bufcombL1.data(), static_cast<int>(bufcombL1.size()));
        combR[0].setbuffer(bufcombR1.data(), static_cast<int>(bufcombR1.size()));
        combL[1].setbuffer(bufcombL2.data(), static_cast<int>(bufcombL2.size()));
        combR[1].setbuffer(bufcombR2.data(), static_cast<int>(bufcombR2.size()));
        combL[2].setbuffer(bufcombL3.data(), static_cast<int>(bufcombL3.size()));
        combR[2].setbuffer(bufcombR3.data(), static_cast<int>(bufcombR3.size()));
        combL[3].setbuffer(bufcombL4.data(), static_cast<int>(bufcombL4.size()));
        combR[3].setbuffer(bufcombR4.data(), static_cast<int>(bufcombR4.size()));
        combL[4].setbuffer(bufcombL5.data(), static_cast<int>(bufcombL5.size()));
        combR[4].setbuffer(bufcombR5.data(), static_cast<int>(bufcombR5.size()));
        combL[5].setbuffer(bufcombL6.data(), static_cast<int>(bufcombL6.size()));
        combR[5].setbuffer(bufcombR6.data(), static_cast<int>(bufcombR6.size()));
        combL[6].setbuffer(bufcombL7.data(), static_cast<int>(bufcombL7.size()));
        combR[6].setbuffer(bufcombR7.data(), static_cast<int>(bufcombR7.size()));
        combL[7].setbuffer(bufcombL8.data(), static_cast<int>(bufcombL8.size()));
        combR[7].setbuffer(bufcombR8.data(), static_cast<int>(bufcombR8.size()));
        allpassL[0].setbuffer(bufallpassL1.data(), static_cast<int>(bufallpassL1.size()));
        allpassR[0].setbuffer(bufallpassR1.data(), static_cast<int>(bufallpassR1.size()));
        allpassL[1].setbuffer(bufallpassL2.data(), static_cast<int>(bufallpassL2.size()));
        allpassR[1].setbuffer(bufallpassR2.data(), static_cast<int>(bufallpassR2.size()));
        allpassL[2].setbuffer(bufallpassL3.data(), static_cast<int>(bufallpassL3.size()));
        allpassR[2].setbuffer(bufallpassR3.data(), static_cast<int>(bufallpassR3.size()));
        allpassL[3].setbuffer(bufallpassL4.data(), static_cast<int>(bufallpassL4.size()));
        allpassR[3].setbuffer(bufallpassR4.data(), static_cast<int>(bufallpassR4.size()));
    }

    revmodel()
    {
        // Set default values
        allpassL[0].setfeedback(0.5f);
        allpassR[0].setfeedback(0.5f);
        allpassL[1].setfeedback(0.5f);
        allpassR[1].setfeedback(0.5f);
        allpassL[2].setfeedback(0.5f);
        allpassR[2].setfeedback(0.5f);
        allpassL[3].setfeedback(0.5f);
        allpassR[3].setfeedback(0.5f);
        setwet(initialwet);
        setroomsize(initialroom);
        setdry(initialdry);
        setdamp(initialdamp);
        setwidth(initialwidth);
        setmode(initialmode);

        // Buffer will be full of rubbish - so we MUST mute them
        mute();
    }

    void mute()
    {
        if(getmode() >= freezemode)
            return;

        for(int i = 0; i < numcombs; i++)
        {
            combL[i].mute();
            combR[i].mute();
        }

        for(int i = 0; i < numallpasses; i++)
        {
            allpassL[i].mute();
            allpassR[i].mute();
        }
    }

    void processmix(float* inputL, float* inputR, float* outputL, float* outputR, long numsamples, int skip)
    {
        float outL, outR, input;

        while(numsamples-- > 0)
        {
            outL = outR = 0;
            input = (*inputL + *inputR) * gain;

            // Accumulate comb filters in parallel
            for(int i = 0; i < numcombs; i++)
            {
                outL += combL[i].process(input);
                outR += combR[i].process(input);
            }

            // Feed through allpasses in series
            for(int i = 0; i < numallpasses; i++)
            {
                outL = allpassL[i].process(outL);
                outR = allpassR[i].process(outR);
            }

            // Calculate output MIXING with anything already there
            *outputL += outL * wet1 + outR * wet2 + *inputL * dry;
            *outputR += outR * wet1 + outL * wet2 + *inputR * dry;

            // Increment sample pointers, allowing for interleave (if any)
            inputL += skip;
            inputR += skip;
            outputL += skip;
            outputR += skip;
        }
    }

    void processreplace(float* inputL, float* inputR, float* outputL, float* outputR, long numsamples, int skip)
    {
        float outL, outR, input;

        while(numsamples-- > 0)
        {
            outL = outR = 0;
            input = (*inputL + *inputR) * gain;

            // Accumulate comb filters in parallel
            for(int i = 0; i < numcombs; i++)
            {
                outL += combL[i].process(input);
                outR += combR[i].process(input);
            }

            // Feed through allpasses in series
            for(int i = 0; i < numallpasses; i++)
            {
                outL = allpassL[i].process(outL);
                outR = allpassR[i].process(outR);
            }

            // Calculate output REPLACING anything already there
            *outputL = outL * wet1 + outR * wet2 + *inputL * dry;
            *outputR = outR * wet1 + outL * wet2 + *inputR * dry;

            // Increment sample pointers, allowing for interleave (if any)
            inputL += skip;
            inputR += skip;
            outputL += skip;
            outputR += skip;
        }
    }


    // The following get/set functions are not inlined, because
    // speed is never an issue when calling them, and also
    // because as you develop the reverb model, you may
    // wish to take dynamic action when they are called.

    void setroomsize(float value)
    {
        roomsize = (value * scaleroom) + offsetroom;
        update();
    }

    float getroomsize()
    {
        return (roomsize - offsetroom) / scaleroom;
    }

    void setdamp(float value)
    {
        damp = value * scaledamp;
        update();
    }

    float getdamp()
    {
        return damp / scaledamp;
    }

    void setwet(float value)
    {
        wet = value * scalewet;
        update();
    }

    float getwet()
    {
        return wet / scalewet;
    }

    void setdry(float value)
    {
        dry = value * scaledry;
    }

    float getdry()
    {
        return dry / scaledry;
    }

    void setwidth(float value)
    {
        width = value;
        update();
    }

    float getwidth()
    {
        return width;
    }

    void setmode(float value)
    {
        mode = value;
        update();
    }

    float getmode()
    {
        if(mode >= freezemode)
            return 1;
        else
            return 0;
    }

private:
    void update()
    {
        // Recalculate internal values after parameter change

        int i;

        wet1 = wet * (width / 2 + 0.5f);
        wet2 = wet * ((1 - width) / 2);

        if(mode >= freezemode)
        {
            roomsize1 = 1;
            damp1 = 0;
            gain = muted;
        }
        else
        {
            roomsize1 = roomsize;
            damp1 = damp;
            gain = fixedgain;
        }

        for(i = 0; i < numcombs; i++)
        {
            combL[i].setfeedback(roomsize1);
            combR[i].setfeedback(roomsize1);
        }

        for(i = 0; i < numcombs; i++)
        {
            combL[i].setdamp(damp1);
            combR[i].setdamp(damp1);
        }
    }

private:
    float   gain = 0.0f;
    float   roomsize = 0.0f, roomsize1 = 0.0f;
    float   damp = 0.0f, damp1 = 0.0f;
    float   wet = 0.0f, wet1 = 0.0f, wet2 = 0.0f;
    float   dry = 0.0f;
    float   width = 0.0f;
    float   mode = 0.0f;

    // The following are all declared inline
    // to remove the need for dynamic allocation
    // with its subsequent error-checking messiness

    // Comb filters
    comb    combL[numcombs];
    comb    combR[numcombs];

    // Allpass filters
    allpass allpassL[numallpasses];
    allpass allpassR[numallpasses];

    // Buffers for the combs
    std::vector<float>  bufcombL1;
    std::vector<float>  bufcombR1;
    std::vector<float>  bufcombL2;
    std::vector<float>  bufcombR2;
    std::vector<float>  bufcombL3;
    std::vector<float>  bufcombR3;
    std::vector<float>  bufcombL4;
    std::vector<float>  bufcombR4;
    std::vector<float>  bufcombL5;
    std::vector<float>  bufcombR5;
    std::vector<float>  bufcombL6;
    std::vector<float>  bufcombR6;
    std::vector<float>  bufcombL7;
    std::vector<float>  bufcombR7;
    std::vector<float>  bufcombL8;
    std::vector<float>  bufcombR8;

    // Buffers for the allpasses
    std::vector<float> bufallpassL1;
    std::vector<float> bufallpassR1;
    std::vector<float> bufallpassL2;
    std::vector<float> bufallpassR2;
    std::vector<float> bufallpassL3;
    std::vector<float> bufallpassR3;
    std::vector<float> bufallpassL4;
    std::vector<float> bufallpassR4;
};


typedef struct FxReverb
{
    int         channels = 0;
    int         sampleRate = 0;
    uint16_t    format = AUDIO_F32LSB;
    bool        isValid = false;
    ReverbSetup m_setup;

    revmodel    rev[MAX_CHANNELS / 2];

    std::vector<std::vector<float>> inBuffer;
    std::vector<std::vector<float>> outBuffer;
    int                             lastBufferSize = 0;

    ReadSampleCB    readSample = nullptr;
    WriteSampleCB   writeSample = nullptr;
    int             sample_size = 2;

    int init(int i_rate, uint16_t i_format, int i_channels)
    {
        isValid = false;

        if(channels > MAX_CHANNELS)
            return -1;

        format = i_format;
        sampleRate = i_rate;
        channels = i_channels;

        if(!initFormat(readSample, writeSample, sample_size, format))
            return -1;

        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setSampleRate(sampleRate);
        }

        setSettings(m_setup);

        inBuffer.clear();
        outBuffer.clear();
        inBuffer.resize(channels + (channels % 2));
        outBuffer.resize(channels + (channels % 2));
        lastBufferSize = 0;

        isValid = true;
        return 0;
    }

    void updateSetup(const ReverbSetup& setup)
    {
        m_setup = setup;
    }

    void getSetup(ReverbSetup& setup)
    {
        setup = m_setup;
    }

    void setSettings(const ReverbSetup& setup)
    {
        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setroomsize(setup.roomSize);
            c.setdamp(setup.damping);
            c.setmode(setup.mode);
            c.setdry(setup.dryLevel);
            c.setwet(setup.wetLevel);
            c.setwidth(setup.width);
        }
    }

    void setMode(float val)
    {
        m_setup.mode = val;
        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setmode(val);
        }
    }

    void setRoomSize(float val)
    {
        m_setup.roomSize = val;
        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setroomsize(val);
        }
    }

    void setDamping(float val)
    {
        m_setup.damping = val;
        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setdamp(val);
        }
    }

    void setWetLevel(float val)
    {
        m_setup.wetLevel = val;
        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setwet(val);
        }
    }

    void setDryLevel(float val)
    {
        m_setup.dryLevel = val;
        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setdry(val);
        }
    }

    void setWidth(float val)
    {
        m_setup.width = val;
        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.setwidth(val);
        }
    }

    void close()
    {
        isValid = false;
    }

    void process(uint8_t* stream, int len)
    {
        if(!isValid)
            return; // Do nothing

        int frames = len / (sample_size * channels);
        uint8_t* in_stream = stream;
        uint8_t* out_stream = stream;

        for(int i = 0; i < channels; i += 2)
        {
            if(inBuffer[i].size() < size_t(frames))
                inBuffer[i].resize(frames);
            if(inBuffer[i + 1].size() < size_t(frames))
                inBuffer[i + 1].resize(frames);
            if(outBuffer[i].size() < size_t(frames))
                outBuffer[i].resize(frames);
            if(outBuffer[i + 1].size() < size_t(frames))
                outBuffer[i + 1].resize(frames);
        }

        for(int i = 0; i < frames; ++i)
        {
            for(int c = 0; c < channels; ++c)
            {
                inBuffer[c][i] = readSample(in_stream, c);
                if(channels % 2 == 1 && c == channels - 1) // Mono to Stereo
                    inBuffer[c + 1][i] = inBuffer[c][i];
            }

            in_stream += sample_size * channels;
        }

        for(int i = 0; i < channels; i += 2)
        {
            auto &c = rev[i / 2];
            c.processreplace(inBuffer[i].data(), inBuffer[i + 1].data(),
                             outBuffer[i].data(), outBuffer[i + 1].data(), frames, 1);
        }

        for(int p = 0; p < frames; ++p)
        {
            for(int w = 0; w < channels; ++w)
            {
                if(channels % 2 == 1 && w == channels - 1) // Stereo to Mono
                    outBuffer[w][p] = (outBuffer[w][p] + outBuffer[w + 1][p]) / 2.0f;

                writeSample(&out_stream, outBuffer[w][p]);
            }
        }
    }
} FxReverb;


FxReverb* reverbEffectInit(int rate, uint16_t format, int channels)
{
    FxReverb* out = new FxReverb();
    out->init(rate, format, channels);
    return out;
}

void reverbEffectFree(FxReverb* context)
{
    if(context)
    {
        context->close();
        delete context;
    }
}

void reverbEffect(int, void* stream, int len, void* context)
{
    FxReverb* out = reinterpret_cast<FxReverb*>(context);

    if(!out)
        return; // Effect doesn't working

    out->process((uint8_t*)stream, len);
}

void reverbUpdateSetup(FxReverb* context, const ReverbSetup& setup)
{
    if(context)
    {
        context->setSettings(setup);
        context->updateSetup(setup);
    }
}

void reverbGetSetup(FxReverb *context, ReverbSetup &setup)
{
    if(context)
        context->getSetup(setup);
}

void reverbUpdateMode(FxReverb *context, float mode)
{
    if(context)
        context->setMode(mode);
}

void reverbUpdateRoomSize(FxReverb *context, float roomSize)
{
    if(context)
        context->setRoomSize(roomSize);
}

void reverbUpdateDamping(FxReverb *context, float damping)
{
    if(context)
        context->setDamping(damping);
}

void reverbUpdateWetLevel(FxReverb *context, float wet)
{
    if(context)
        context->setWetLevel(wet);
}

void reverbUpdateDryLevel(FxReverb *context, float dry)
{
    if(context)
        context->setDryLevel(dry);
}

void reverbUpdateWidth(FxReverb *context, float width)
{
    if(context)
        context->setWidth(width);
}


================================================
FILE: src/sound/fx/reverb.h
================================================
/*
 * Simple Reverb sound effect
 *
 * Copyright (c) 2022-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef REVERB_H
#define REVERB_H

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

#include "fx_format.h"

typedef struct FxReverb FxReverb;

typedef struct ReverbSetup
{
    float mode         = 0.0f; // Normal (0) or Freeze (>0.5)
    float roomSize     = 0.7f;
    float damping      = 0.5f; // 0.0...1.0
    float wetLevel     = 0.2f;
    float dryLevel     = 0.4f;
    float width        = 1.0f; // 0.0...1.0
} ReverbSetup;

extern FxReverb *reverbEffectInit(int rate, uint16_t format, int channels);
extern void reverbEffectFree(FxReverb *context);

extern void reverbEffect(int chan, void *stream, int len, void *context);

// Update all setup at once
extern void reverbUpdateSetup(FxReverb *context, const ReverbSetup &setup);
extern void reverbGetSetup(FxReverb *context, ReverbSetup &setup);

// Update every single setting
extern void reverbUpdateMode(FxReverb *context, float mode);
extern void reverbUpdateRoomSize(FxReverb *context, float roomSize);
extern void reverbUpdateDamping(FxReverb *context, float damping);
extern void reverbUpdateWetLevel(FxReverb *context, float wet);
extern void reverbUpdateDryLevel(FxReverb *context, float dry);
extern void reverbUpdateWidth(FxReverb *context, float width);

#ifdef __cplusplus
}
#endif

#endif // REVERB_H


================================================
FILE: src/sound/fx/spc_echo.cpp
================================================
/*
 * SPC Echo sound effect
 *
 * Copyright (c) 2022-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include <tgmath.h>
#include <string.h>
#include "spc_echo.h"
#include "fx_common.hpp"


#define CLAMP16F( io )\
    {\
        if(io < -1.f)\
            io = -1.f;\
        else if(io > 1.f)\
            io = 1.f;\
    }\

#define ECHO_HIST_SIZE  8
#define SDSP_RATE       32000
#define MAX_CHANNELS    10
#define ECHO_BUFFER_SIZE (32 * 1024 * MAX_CHANNELS)

//// Global registers
//enum
//{
//    r_mvoll = 0x0C, r_mvolr = 0x1C,
//    r_evoll = 0x2C, r_evolr = 0x3C,
//    r_kon   = 0x4C, r_koff  = 0x5C,
//    r_flg   = 0x6C, r_endx  = 0x7C,
//    r_efb   = 0x0D, r_pmon  = 0x2D,
//    r_non   = 0x3D, r_eon   = 0x4D,
//    r_dir   = 0x5D, r_esa   = 0x6D,
//    r_edl   = 0x7D,
//    r_fir   = 0x0F // 8 coefficients at 0x0F, 0x1F ... 0x7F
//};

//static uint8_t_t const initial_regs[register_count] =
//{
///*      0      1     2     3    4     5     6     7     8      9     A    B     C      D     E     F  */
///*00*/ 0x45, 0x8B, 0x5A, 0x9A, 0xE4, 0x82, 0x1B, 0x78, 0x00, 0x00, 0xAA, 0x96, 0x89, 0x0E, 0xE0, 0x80, /*00*/
///*10*/ 0x2A, 0x49, 0x3D, 0xBA, 0x14, 0xA0, 0xAC, 0xC5, 0x00, 0x00, 0x51, 0xBB, 0x9C, 0x4E, 0x7B, 0xFF, /*10*/
///*20*/ 0xF4, 0xFD, 0x57, 0x32, 0x37, 0xD9, 0x42, 0x22, 0x00, 0x00, 0x5B, 0x3C, 0x9F, 0x1B, 0x87, 0x9A, /*20*/
///*30*/ 0x6F, 0x27, 0xAF, 0x7B, 0xE5, 0x68, 0x0A, 0xD9, 0x00, 0x00, 0x9A, 0xC5, 0x9C, 0x4E, 0x7B, 0xFF, /*30*/
///*40*/ 0xEA, 0x21, 0x78, 0x4F, 0xDD, 0xED, 0x24, 0x14, 0x00, 0x00, 0x77, 0xB1, 0xD1, 0x36, 0xC1, 0x67, /*40*/
///*50*/ 0x52, 0x57, 0x46, 0x3D, 0x59, 0xF4, 0x87, 0xA4, 0x00, 0x00, 0x7E, 0x44, 0x9C, 0x4E, 0x7B, 0xFF, /*50*/
///*60*/ 0x75, 0xF5, 0x06, 0x97, 0x10, 0xC3, 0x24, 0xBB, 0x00, 0x00, 0x7B, 0x7A, 0xE0, 0x60, 0x12, 0x0F, /*60*/
///*70*/ 0xF7, 0x74, 0x1C, 0xE5, 0x39, 0x3D, 0x73, 0xC1, 0x00, 0x00, 0x7A, 0xB3, 0xFF, 0x4E, 0x7B, 0xFF  /*70*/
///*      0      1     2     3    4     5     6     7     8      9     A    B     C      D     E     F  */
//};


typedef struct SpcEcho
{
    int is_valid = 0;
    float echo_ram[ECHO_BUFFER_SIZE];

    // Echo history keeps most recent 8 samples (twice the size to simplify wrap handling)
    float echo_hist[ECHO_HIST_SIZE * 2 * MAX_CHANNELS][MAX_CHANNELS];
    float (*echo_hist_pos)[MAX_CHANNELS] = echo_hist; // &echo_hist [0 to 7]

    //! offset from ESA in echo buffer
    int echo_offset = 0;
    //! number of bytes that echo_offset will stop at
    int echo_length = 0;

    double  rate_factor = 1.0;
    int     rate = SDSP_RATE;
    int     channels = 2;
    uint16_t format = AUDIO_F32;

    //! Flags
    uint8_t reg_flg = 0;
    //! $4d rw EON - Echo enable
    uint8_t reg_eon = 0;
    //! $7d rw EDL - Echo delay (ring buffer size)
    uint8_t reg_edl = 0;
    //! $0d rw EFB - Echo feedback volume
    int8_t reg_efb = 0;

    int8_t reg_mvoll = 0;
    int8_t reg_mvolr = 0;
    int8_t reg_evoll = 0;
    int8_t reg_evolr = 0;

    //! FIR Defaults: 80 FF 9A FF 67 FF 0F FF
    const uint8_t reg_fir_initial[8] = {0x80, 0xFF, 0x9A, 0xFF, 0x67, 0xFF, 0x0F, 0xFF};
    //! $xf rw FFCx - Echo FIR Filter Coefficient (FFC) X
    int8_t reg_fir[8] = {0, 0, 0, 0, 0, 0, 0, 0};
    int8_t reg_fir_resampled[8];

    void recomputeFirResampled()
    {
        const double y_factor1 = 1.0;
        const double y_factor2 = rate_factor;
        for(size_t i = 0; i < 8; i++)
        {
            double newFactor = y_factor2 + ((y_factor1 - y_factor2) / (0.0 - 7.0)) * (i - 7.0);
            reg_fir_resampled[i] = (int8_t)(reg_fir[i] * (1.0 + ((newFactor - 1.0) / 100.0)));
        }
    }

    void setDefaultFir()
    {
        memcpy(reg_fir, reg_fir_initial, 8);
        recomputeFirResampled();
    }

    void setDefaultRegs()
    {
        reg_flg = 0;

        reg_mvoll = (int8_t)0x89;
        reg_mvolr = (int8_t)0x9C;
        reg_evoll = (int8_t)0x9F;
        reg_evolr = (int8_t)0x9C;

        setDefaultFir();

        // $0d rw EFB - Echo feedback volume
        reg_efb = (int8_t)0x0E;
        // $4d rw EON - Echo enable
        reg_eon = 1;
        // $7d rw EDL - Echo delay (ring buffer size)
        reg_edl = 3;
    }

    ReadSampleCB    readSample = nullptr;
    WriteSampleCB   writeSample = nullptr;
    int             sample_size = 2;

    int init(int i_rate, uint16_t i_format, int i_channels)
    {
        is_valid = 0;
        rate = i_rate;
        format = i_format;
        channels = i_channels;
        rate_factor = (double)i_rate / SDSP_RATE;

        if(rate_factor > 50.0)
            return -1; /* Too big scale factor */

        if(i_rate < 4000)
            return -1; /* Too small sample rate */

        memset(echo_ram, 0, sizeof(echo_ram));
        memset(echo_hist, 0, sizeof(echo_hist));
        memset(reg_fir_resampled, 0, sizeof(reg_fir_resampled));

        if(!initFormat(readSample, writeSample, sample_size, format))
            return -1;

        setDefaultRegs();

        is_valid = 1;
        return 0;
    }

    void close()
    {}

    void process(uint8_t *stream, int len)
    {
        int frames = len / (sample_size * channels);

        float main_out[MAX_CHANNELS];
        float echo_out[MAX_CHANNELS];
        float echo_in[MAX_CHANNELS];

        int c;
        float ov;

        int f, e_offset;
        float v;

        float mvoll[2] = {(float)reg_mvoll, (float)reg_mvolr};
        float evoll[2] = {(float)reg_evoll, (float)reg_evolr};

        float (*echohist_pos)[MAX_CHANNELS];
        float *echo_ptr;

        memset(main_out, 0, sizeof(main_out));
        memset(echo_out, 0, sizeof(echo_out));
        memset(echo_in, 0, sizeof(echo_in));

        if(!is_valid)
            return;

        do
        {
            for(c = 0; c < channels; ++c)
                main_out[c] = readSample(stream, c) * 128;

            if(reg_eon & 1)
            {
                for(c = 0; c < channels; c++)
                    echo_out[c] = main_out[c];
            }

            e_offset = echo_offset;
            echo_ptr = echo_ram + echo_offset;

            if(!echo_offset)
                echo_length = (int)round((((reg_edl & 0x0F) * 0x400 * channels) / 2.0) * rate_factor);
            e_offset += channels;
            if(e_offset >= echo_length)
                e_offset = 0;
            echo_offset = e_offset;

            /* FIR */
            for(c = 0; c < channels; c++)
                echo_in[c] = echo_ptr[c];

            echohist_pos = echo_hist_pos;
            if(++echohist_pos >= &echo_hist[ECHO_HIST_SIZE])
                echohist_pos = echo_hist;
            echo_hist_pos = echohist_pos;

            /* --------------- FIR filter-------------- */
            for(c = 0; c < channels; c++)
                echohist_pos[0][c] = echohist_pos[8][c] = echo_in[c];

            for(c = 0; c < channels; ++c)
                echo_in[c] *= reg_fir_resampled[7];

            for(f = 0; f <= 6; ++f)
            {
                for(c = 0; c < channels; ++c)
                    echo_in[c] += echo_hist_pos[f + 1][c] * reg_fir_resampled[f];
            }
            /* ---------------------------------------- */

            /* Echo out */
            if(!(reg_flg & 0x20))
            {
                for(c = 0; c < channels; c++)
                {
                    //v = (echo_out[c] >> 7) + ((echo_in[c] * reg_efb) >> 14);
                    v = (echo_out[c] / 128) + ((echo_in[c] * reg_efb) / 16384.f);
                    CLAMP16F(v);
                    echo_ptr[c] = v;
                }
            }

            /* Sound out */
            for(c = 0; c < channels; c++)
            {
                ov = (main_out[c] * mvoll[c % 2] + echo_in[c] * evoll[c % 2]) / 16384;
                CLAMP16F(ov);
                if((reg_flg & 0x40))
                    ov = 0;
                writeSample(&stream, ov);
            }
        }
        while(--frames);
    }
} SpcEcho;


SpcEcho *echoEffectInit(int rate, uint16_t format, int channels)
{
    SpcEcho *out = new SpcEcho();
    out->init(rate, format, channels);
    return out;
}

void echoEffectFree(SpcEcho *context)
{
    if(context)
    {
        context->close();
        delete context;
    }
}

void spcEchoEffect(int, void *stream, int len, void *context)
{
    SpcEcho *out = reinterpret_cast<SpcEcho *>(context);
    if(!out)
        return; // Effect doesn't working
    out->process((uint8_t*)stream, len);
}

void echoEffectSetReg(SpcEcho *out, EchoSetup key, int val)
{
    if(!out)
        return;

    switch(key)
    {
    case ECHO_EON:
        out->reg_eon = (uint8_t)val;
        break;
    case ECHO_EDL:
        out->reg_edl = (uint8_t)val;
        break;
    case ECHO_EFB:
        out->reg_efb = (int8_t)val;
        break;
    case ECHO_MVOLL:
        out->reg_mvoll = (int8_t)val;
        break;
    case ECHO_MVOLR:
        out->reg_mvolr = (int8_t)val;
        break;
    case ECHO_EVOLL:
        out->reg_evoll = (int8_t)val;
        break;
    case ECHO_EVOLR:
        out->reg_evolr = (int8_t)val;
        break;

    case ECHO_FIR0:
        out->reg_fir[0]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    case ECHO_FIR1:
        out->reg_fir[1]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    case ECHO_FIR2:
        out->reg_fir[2]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    case ECHO_FIR3:
        out->reg_fir[3]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    case ECHO_FIR4:
        out->reg_fir[4]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    case ECHO_FIR5:
        out->reg_fir[5]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    case ECHO_FIR6:
        out->reg_fir[6]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    case ECHO_FIR7:
        out->reg_fir[7]= (int8_t)val;
        out->recomputeFirResampled();
        break;
    }
}

int echoEffectGetReg(SpcEcho *out, EchoSetup key)
{
    if(!out)
        return 0;

    switch(key)
    {
    case ECHO_EON:
        return out->reg_eon;
    case ECHO_EDL:
        return out->reg_edl;
    case ECHO_EFB:
        return out->reg_efb;
    case ECHO_MVOLL:
        return out->reg_mvoll;
    case ECHO_MVOLR:
        return out->reg_mvolr;
    case ECHO_EVOLL:
        return out->reg_evoll;
    case ECHO_EVOLR:
        return out->reg_evolr;

    case ECHO_FIR0:
        return out->reg_fir[0];
    case ECHO_FIR1:
        return out->reg_fir[1];
    case ECHO_FIR2:
        return out->reg_fir[2];
    case ECHO_FIR3:
        return out->reg_fir[3];
    case ECHO_FIR4:
        return out->reg_fir[4];
    case ECHO_FIR5:
        return out->reg_fir[5];
    case ECHO_FIR6:
        return out->reg_fir[6];
    case ECHO_FIR7:
        return out->reg_fir[7];
    }

    return 0;
}

void echoEffectResetFir(SpcEcho *out)
{
    if(!out)
        return;
    out->setDefaultFir();
}

void echoEffectResetDefaults(SpcEcho *out)
{
    if(!out)
        return;
    out->setDefaultRegs();
}


================================================
FILE: src/sound/fx/spc_echo.h
================================================
/*
 * SPC Echo sound effect
 *
 * Copyright (c) 2022-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef SPC_ECHO_HHHH
#define SPC_ECHO_HHHH

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif
#include "fx_format.h"

typedef struct SpcEcho SpcEcho;

extern SpcEcho *echoEffectInit(int rate, uint16_t format, int channels);
extern void echoEffectFree(SpcEcho *context);

typedef enum EchoSetup
{
    ECHO_EON = 0,
    ECHO_EDL,
    ECHO_EFB,

    ECHO_MVOLL,
    ECHO_MVOLR,
    ECHO_EVOLL,
    ECHO_EVOLR,

    ECHO_FIR0,
    ECHO_FIR1,
    ECHO_FIR2,
    ECHO_FIR3,
    ECHO_FIR4,
    ECHO_FIR5,
    ECHO_FIR6,
    ECHO_FIR7
} EchoSetup;

extern void spcEchoEffect(int chan, void *stream, int len, void *context);

extern void echoEffectResetFir(SpcEcho *out);
extern void echoEffectResetDefaults(SpcEcho *out);

extern void echoEffectSetReg(SpcEcho *out, EchoSetup key, int val);
extern int  echoEffectGetReg(SpcEcho *out, EchoSetup key);
#ifdef __cplusplus
}
#endif

#endif // SPC_ECHO_HHHH


================================================
FILE: src/sound/sound_msgsnd.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/mixer.h"

#include "../sound.h"
#include "sound_msgsnd.h"

extern bool g_mixerLoaded;

static unsigned char s_sndGlas[] =
{
    0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x05,
    0x03, 0xc0, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x00, 0x57, 0x00, 0xff,
    0x03, 0x08, 0x75, 0x6e, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x64, 0x00, 0xff,
    0x02, 0x1a, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20,
    0xa9, 0x20, 0x32, 0x30, 0x30, 0x31, 0x20, 0x62, 0x79, 0x20, 0x3c, 0x6e,
    0x61, 0x6d, 0x65, 0x3e, 0x00, 0xff, 0x01, 0x10, 0x56, 0x69, 0x74, 0x61,
    0x6c, 0x79, 0x20, 0x4e, 0x6f, 0x76, 0x69, 0x63, 0x68, 0x6b, 0x6f, 0x76,
    0x00, 0xff, 0x58, 0x04, 0x04, 0x02, 0x18, 0x08, 0x00, 0xff, 0x59, 0x02,
    0x00, 0x00, 0x00, 0xff, 0x51, 0x03, 0x09, 0x27, 0xc0, 0x00, 0xff, 0x2f,
    0x00, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0xc0, 0x74,
    0x00, 0x90, 0x28, 0x64, 0x00, 0x27, 0x64, 0x00, 0x25, 0x64, 0x87, 0x40,
    0x25, 0x00, 0x00, 0x27, 0x00, 0x00, 0x28, 0x00, 0x00, 0xff, 0x2f, 0x00,
    0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0xc1, 0x7f, 0x00,
    0x91, 0x44, 0x64, 0x00, 0x40, 0x64, 0x00, 0x37, 0x64, 0x87, 0x40, 0x37,
    0x00, 0x00, 0x40, 0x00, 0x00, 0x44, 0x00, 0x00, 0xff, 0x2f, 0x00, 0x4d,
    0x54, 0x72, 0x6b, 0x00, 0x00, 0x01, 0x66, 0x00, 0xc2, 0x71, 0x00, 0x92,
    0x66, 0x7f, 0x00, 0x61, 0x7f, 0x00, 0x57, 0x7f, 0x00, 0x58, 0x7f, 0x00,
    0x5a, 0x7f, 0x00, 0x55, 0x7f, 0x00, 0x64, 0x7f, 0x00, 0x60, 0x7f, 0x00,
    0x5d, 0x7f, 0x00, 0x6a, 0x7f, 0x26, 0x63, 0x67, 0x1a, 0x5f, 0x68, 0x19,
    0x5c, 0x6a, 0x1f, 0x55, 0x00, 0x00, 0x58, 0x00, 0x00, 0x66, 0x00, 0x00,
    0x57, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x61, 0x00, 0x00, 0x5e, 0x6b, 0x00,
    0x62, 0x6b, 0x26, 0x63, 0x00, 0x1a, 0x5f, 0x00, 0x19, 0x5c, 0x00, 0x1f,
    0x5e, 0x00, 0x00, 0x62, 0x00, 0x00, 0x5f, 0x62, 0x00, 0x5b, 0x62, 0x00,
    0x65, 0x62, 0x78, 0x65, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x5b, 0x00, 0x00,
    0x66, 0x69, 0x24, 0x5e, 0x69, 0x1a, 0x62, 0x69, 0x3a, 0x66, 0x00, 0x00,
    0x61, 0x70, 0x00, 0x63, 0x70, 0x24, 0x5e, 0x00, 0x1a, 0x62, 0x00, 0x2e,
    0x58, 0x73, 0x0c, 0x63, 0x00, 0x00, 0x61, 0x00, 0x00, 0x5c, 0x35, 0x00,
    0x60, 0x35, 0x28, 0x5e, 0x01, 0x19, 0x66, 0x01, 0x2b, 0x58, 0x00, 0x08,
    0x5f, 0x01, 0x04, 0x60, 0x00, 0x00, 0x5c, 0x00, 0x28, 0x5e, 0x00, 0x19,
    0x66, 0x00, 0x33, 0x5f, 0x00, 0x04, 0x66, 0x18, 0x00, 0x62, 0x18, 0x6b,
    0x57, 0x45, 0x0d, 0x62, 0x00, 0x00, 0x60, 0x00, 0x00, 0x5d, 0x00, 0x00,
    0x64, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x66, 0x00, 0x40, 0x60, 0x1a, 0x19,
    0x5d, 0x4e, 0x12, 0x57, 0x00, 0x3b, 0x62, 0x67, 0x12, 0x60, 0x00, 0x19,
    0x5d, 0x00, 0x1f, 0x60, 0x67, 0x00, 0x63, 0x67, 0x2e, 0x62, 0x00, 0x4a,
    0x63, 0x00, 0x00, 0x60, 0x00, 0x3e, 0x5a, 0x43, 0x10, 0x5f, 0x66, 0x00,
    0x65, 0x66, 0x00, 0x60, 0x66, 0x56, 0x5d, 0x59, 0x12, 0x5a, 0x00, 0x10,
    0x60, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x65, 0x00, 0x2a, 0x63, 0x2c, 0x00,
    0x61, 0x2c, 0x0e, 0x5f, 0x7f, 0x1e, 0x5d, 0x00, 0x4c, 0x63, 0x00, 0x00,
    0x61, 0x00, 0x0e, 0x5f, 0x00, 0x62, 0x61, 0x70, 0x78, 0x61, 0x00, 0x08,
    0x5d, 0x2f, 0x00, 0x62, 0x2f, 0x78, 0x62, 0x00, 0x00, 0x5d, 0x00, 0x00,
    0x5f, 0x6d, 0x54, 0x62, 0x77, 0x24, 0x5f, 0x00, 0x1c, 0x64, 0x7c, 0x38,
    0x62, 0x00, 0x40, 0x64, 0x00, 0x5c, 0x5e, 0x64, 0x13, 0x5f, 0x5d, 0x26,
    0x62, 0x76, 0x3f, 0x5e, 0x00, 0x13, 0x5f, 0x00, 0x26, 0x62, 0x00, 0x08,
    0x62, 0x65, 0x78, 0x62, 0x00, 0x81, 0x62, 0x5e, 0x36, 0x00, 0x62, 0x36,
    0x78, 0x62, 0x00, 0x00, 0x5e, 0x00, 0x81, 0x2e, 0x5e, 0x2b, 0x78, 0x5e,
    0x00, 0x00, 0xff, 0x2f, 0x00, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x00,
    0x04, 0x00, 0xff, 0x2f, 0x00,
    0x00
};

static unsigned char s_sndMsg[] =
{
    0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x03,
    0x03, 0xc0, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x00, 0x57, 0x00, 0xff,
    0x03, 0x08, 0x75, 0x6e, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x64, 0x00, 0xff,
    0x02, 0x1a, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20,
    0xa9, 0x20, 0x32, 0x30, 0x30, 0x31, 0x20, 0x62, 0x79, 0x20, 0x3c, 0x6e,
    0x61, 0x6d, 0x65, 0x3e, 0x00, 0xff, 0x01, 0x10, 0x56, 0x69, 0x74, 0x61,
    0x6c, 0x79, 0x20, 0x4e, 0x6f, 0x76, 0x69, 0x63, 0x68, 0x6b, 0x6f, 0x76,
    0x00, 0xff, 0x58, 0x04, 0x04, 0x02, 0x18, 0x08, 0x00, 0xff, 0x59, 0x02,
    0x00, 0x00, 0x00, 0xff, 0x51, 0x03, 0x06, 0x8a, 0x1b, 0x00, 0xff, 0x2f,
    0x00, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x00, 0x22, 0x00, 0xc0, 0x0a,
    0x00, 0x90, 0x48, 0x64, 0x00, 0x54, 0x64, 0x87, 0x40, 0x48, 0x64, 0x00,
    0x3c, 0x64, 0x88, 0x38, 0x54, 0x00, 0x00, 0x48, 0x00, 0x78, 0x48, 0x00,
    0x00, 0x3c, 0x00, 0x00, 0xff, 0x2f, 0x00, 0x4d, 0x54, 0x72, 0x6b, 0x00,
    0x00, 0x00, 0x04, 0x00, 0xff, 0x2f, 0x00,
    0x00
};

#ifndef CUSTOM_AUDIO
void playFallbackSfx(int sfxId, int loops, int volume)
{
    if(!g_mixerLoaded)
        return;

    SDL_RWops *sfx = nullptr;

    switch(sfxId)
    {
    case SFX_Message:
        sfx = SDL_RWFromConstMem(s_sndMsg, sizeof(s_sndMsg));
        break;
    case SFX_SMGlass:
        sfx = SDL_RWFromConstMem(s_sndGlas, sizeof(s_sndGlas));
        break;
    }

    if(sfx)
    {
        Mix_Music *sfxF = Mix_LoadMUS_RW_ARG(sfx, 1, "s0;b58;e0;c1;");
        if(!sfxF)
        {
            SDL_RWclose(sfx);
            return;
        }

        Mix_VolumeMusicStream(sfxF, volume);
        Mix_PlayMusicStream(sfxF, loops + 1);
        Mix_SetFreeOnStop(sfxF, 1);
    }
}
#else
void playFallbackSfx(int, int, int) {}
#endif


================================================
FILE: src/sound/sound_msgsnd.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

void playFallbackSfx(int sfxId, int loops, int volume);


================================================
FILE: src/sound.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "sdl_proxy/sdl_stdinc.h"
#include "sdl_proxy/sdl_atomic.h"
#include "sdl_proxy/sdl_assert.h"
#include "sdl_proxy/sdl_timer.h"
#include "sdl_proxy/mixer.h"

#include "globals.h"
#include "config.h"
#include "global_dirs.h"
#include "frame_timer.h"
#include "message.h"

#include "load_gfx.h"
#include "core/msgbox.h"
#include "main/screen_progress.h"

#include "sound.h"
#include "sound_thread.h"

#ifdef THEXTECH_ENABLE_AUDIO_FX
#include "sound/fx/reverb.h"
#include "sound/fx/spc_echo.h"
#endif

#include "sound/sound_msgsnd.h"

#include <Logger/logger.h>
#include <IniProcessor/ini_processing.h>
#include <Utils/files.h>
#include <Utils/files_ini.h>
#include <Utils/strings.h>
#include <unordered_map>
#include <fmt_format_ne.h>

enum class SoundScope
{
    global,
    episode,
    custom
};

// Public musicPlaying As Boolean
bool musicPlaying = false;
// Public musicLoop As Integer
int musicLoop = 0;
// Public musicName As String
std::string musicName;

int playerHammerSFX = SFX_Fireball;

const AudioDefaults_t g_audioDefaults =
#if defined(__WII__) /* Defaults for Nintendo Wii */
{
    32000,
    2,
    1536,
    (int)AUDIO_S16SYS
};
#elif defined(__WIIU__)
{
    44100,
    2,
    1024,
    (int)AUDIO_F32SYS
};
#elif defined(__3DS__)
{
    44100,
    2,
    2048,
    (int)AUDIO_S16SYS
};
#elif defined(__SWITCH__) /* Defaults for Nintendo Switch */
{
    48000,
    2,
    1024,
    (int)AUDIO_S16SYS
};
#else /* Defaults for all other platforms */
{
    44100,
    2,
    512,
    (int)AUDIO_F32SYS
};
#endif

static Mix_Music *g_curMusic = nullptr;
bool g_mixerLoaded = false;

//! most recent argument to StartMusic. Could be a world map music ID or a section index.
static constexpr int s_null_music = -5;
static int s_recentMusicA = s_null_music;

static int g_customLvlMusicId = 24;
static int g_customWldMusicId = 17;
static int g_reservedChannels = 0;

//! Total count of loaded default sounds
static unsigned int g_totalSounds = 0;
//! Are custom sounds was loaded from the level/world data folder?
static bool g_customSoundsInDataFolder = false;
//! Are custom music files was loaded from the level/world data folder?
static bool g_customMusicInDataFolder = false;
//! Total count of level music
static unsigned int g_totalMusicLevel = 0;
//! Total count of world map music
static unsigned int g_totalMusicWorld = 0;
//! Total count of special music
static unsigned int g_totalMusicSpecial = 0;
//! Enable using the unique iceball SFX when available
static bool s_useIceBallSfx = false;
//! Enable using of the new ice SFX: NPC freeze and breaking of the frozen NPC
static bool s_useNewIceSfx = false;

static int g_errorsSfx = 0;
// static int g_errorsMusic = 0; // Unued yet

static bool s_musicHasYoshiMode = false;
static int  s_musicYoshiTrackNumber = -1;
#ifdef THEXTECH_ENABLE_AUDIO_FX
static bool s_musicDisableSpcEcho = false;
#endif
static int s_musicDefaultVolume = 64;

static std::string MusicRoot;
static std::string SfxRoot;

static std::string musicIni; // = "music.ini";
static std::string sfxIni; // = "sounds.ini";

#ifdef THEXTECH_ENABLE_AUDIO_FX
struct SectionEffect_t
{
    enum FX
    {
        FX_None = 0,
        FX_Echo,
        FX_Reverb
    };
    //! Reverb effect settings
    SoundFXReverb rev;
    //! Echo effect settings
    SoundFXEchoSetup echo;
    //! Selected effect
    int fx = FX_None;
    //! Disable echo of playing SPC files
    bool disableSpcEcho = false;
};

static SectionEffect_t s_sectionEffect[maxSections + 1];
static std::unordered_map<std::string, SectionEffect_t> s_effectsList;
#endif

struct Music_t
{
    std::string path;
    int volume = 52;
    int yoshiModeTrack = -1;
};

struct SFX_t
{
    std::string path;
    std::string customPath;
    Mix_Chunk *chunk = nullptr;
    Mix_Music *music = nullptr;
    Mix_Chunk *chunkOrig = nullptr;
    Mix_Music *musicOrig = nullptr;
    int8_t channel = -1;
    bool isCustom = false;
    bool isSilent = false;
    bool isSilentOrig = false;
};

static std::unordered_map<std::string, Music_t> music;
static std::unordered_map<int, SFX_t>           sound;

//! Sounds played by scripts
static SDL_atomic_t                                extSfxBusy;
static std::unordered_map<std::string, Mix_Chunk*> extSfx;
static std::unordered_map<int, std::string>        extSfxPlaying;
#ifndef THEXTECH_NO_SDL_BUILD
static void extSfxStopCallback(int channel);
#endif

static const int maxSfxChannels = 91;

#ifdef LOW_MEM
static const double c_max_chunk_duration = 1.25; // max length of an in-memory chunk in seconds
#else
static const double c_max_chunk_duration = 5.0;  // max length of an in-memory chunk in seconds
#endif

#ifndef THEXTECH_NO_SDL_BUILD
static const char *audio_format_to_string(SDL_AudioFormat f)
{
    switch(f)
    {
    default:
        return "<unknown>";
    case AUDIO_U8:
        return "U8";
    case AUDIO_S8:
        return "S8";
    case AUDIO_S16LSB:
        return "S16-LE";
    case AUDIO_S16MSB:
        return "S16-BE";
    case AUDIO_U16LSB:
        return "U16-LE";
    case AUDIO_U16MSB:
        return "U16-BE";
    case AUDIO_S32LSB:
        return "S32-LE";
    case AUDIO_S32MSB:
        return "S32-BE";
    case AUDIO_F32LSB:
        return "F32-LE";
    case AUDIO_F32MSB:
        return "F32-BE";
    }
}
#endif

static void clear_sfx(SFX_t &s)
{
    if(s.chunk)
        Mix_FreeChunk(s.chunk);

    s.chunk = nullptr;

    if(s.chunkOrig)
        Mix_FreeChunk(s.chunkOrig);

    s.chunkOrig = nullptr;

    if(s.music)
    {
        Mix_HaltMusicStream(s.music);
        Mix_FreeMusic(s.music);
    }

    s.music = nullptr;

    if(s.musicOrig)
        Mix_FreeMusic(s.musicOrig);

    s.musicOrig = nullptr;
}


int CustomWorldMusicId()
{
    return g_customWldMusicId;
}

void InitMixerX()
{
#ifndef THEXTECH_NO_SDL_BUILD
    if(!g_config.audio_enable)
        return;

    int ret;
    const int initFlags = MIX_INIT_MID | MIX_INIT_MOD | MIX_INIT_FLAC | MIX_INIT_OGG | MIX_INIT_OPUS | MIX_INIT_MP3;

    MusicRoot = AppPath + "music/";
    SfxRoot = AppPath + "sound/";

    Mix_SetRWFromFile(Files::open_file);

    SDL_AtomicSet(&extSfxBusy, 0);

    if(g_mixerLoaded)
        return;

#ifdef __3DS__
    // Create the blank "dspfirm.cdc" if not exists (it's required to exist for the 3DS audio work on Citra HLE)
    if(!Files::fileExists("/3ds/dspfirm.cdc"))
    {
        FILE *x = Files::utf8_fopen("/3ds/dspfirm.cdc", "wb");
        fclose(x);
    }
#endif

    pLogDebug("Opening sound (wanted: rate=%d hz, format=%s, channels=%d, buffer=%d frames)...",
              (int)g_config.audio_sample_rate,
              audio_format_to_string((int)g_config.audio_format),
              (int)g_config.audio_channels,
              (int)g_config.audio_buffer_size);

    ret = Mix_Init(initFlags);

    if(ret != initFlags)
    {
        pLogWarning("MixerX: Some modules aren't properly initialized");
        if((ret & MIX_INIT_MID) != MIX_INIT_MID)
            pLogWarning("MixerX: Failed to initialize MIDI module");
        if((ret & MIX_INIT_MOD) != MIX_INIT_MOD)
            pLogWarning("MixerX: Failed to initialize Tracker music module");
        if((ret & MIX_INIT_FLAC) != MIX_INIT_FLAC)
            pLogWarning("MixerX: Failed to initialize FLAC module");
        if((ret & MIX_INIT_OGG) != MIX_INIT_OGG)
            pLogWarning("MixerX: Failed to initialize OGG Vorbis module");
        if((ret & MIX_INIT_OPUS) != MIX_INIT_OPUS)
            pLogWarning("MixerX: Failed to initialize Opus module");
        if((ret & MIX_INIT_MP3) != MIX_INIT_MP3)
            pLogWarning("MixerX: Failed to initialize MP3 module");
    }

    ret = Mix_OpenAudio(g_config.audio_sample_rate,
                        g_config.audio_format,
                        g_config.audio_channels,
                        g_config.audio_buffer_size);

    if(ret < 0)
    {
        std::string msg = fmt::format_ne("Can't open audio stream, continuing without audio: ({0})", Mix_GetError());
        pLogCritical("%s", msg.c_str());
        XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR, "Sound opening error", msg);
    }
    else
    {
        SDL_AudioSpec ob;
        ret = Mix_QuerySpecEx(&ob);

        if(ret == 0)
        {
            pLogCritical("Failed to call the Mix_QuerySpec!");
            g_config.audio_sample_rate.obtained = g_config.audio_sample_rate;
            g_config.audio_format.obtained = g_config.audio_format;
            g_config.audio_channels.obtained = g_config.audio_channels;
            g_config.audio_buffer_size.obtained = g_config.audio_buffer_size;
        }
        else
        {
            g_config.audio_sample_rate.obtained = ob.freq;
            g_config.audio_format.obtained = ob.format;
            g_config.audio_channels.obtained = ob.channels;
            g_config.audio_buffer_size.obtained = ob.samples;

            pLogDebug("Sound opened (obtained: rate=%d hz, format=%s, channels=%d, buffer=%d frames)...",
                      ob.freq,
                      audio_format_to_string(ob.format),
                      ob.channels,
                      ob.samples);
        }

#if defined(__3DS__)
        // Set fastest emulators to be default
        Mix_OPNMIDI_setEmulator(OPNMIDI_OPN2_EMU_GENS);
        Mix_OPNMIDI_setChannelAllocMode(MIX_CHIP_CHANALLOC_SameInst);
        Mix_OPNMIDI_setChipsCount(2);
        Mix_ADLMIDI_setEmulator(ADLMIDI_OPL3_EMU_DOSBOX);
        Mix_ADLMIDI_setChannelAllocMode(MIX_CHIP_CHANALLOC_SameInst);
        Mix_ADLMIDI_setChipsCount(2);
#elif defined(__WII__)
        // Set fastest emulators to be default
        Mix_OPNMIDI_setEmulator(OPNMIDI_OPN2_EMU_MAME_OPN2);
        Mix_OPNMIDI_setChipsCount(2);
        Mix_ADLMIDI_setEmulator(ADLMIDI_OPL3_EMU_DOSBOX);
        Mix_ADLMIDI_setChipsCount(2);
#elif defined(__vita__)
        Mix_OPNMIDI_setEmulator(OPNMIDI_OPN2_EMU_MAME_OPN2);
        Mix_OPNMIDI_setChipsCount(2);
        Mix_ADLMIDI_setEmulator(ADLMIDI_OPL3_EMU_DOSBOX);
        Mix_ADLMIDI_setChipsCount(2);
#endif

        Mix_VolumeMusic(MIX_MAX_VOLUME);
        Mix_AllocateChannels(maxSfxChannels);

        // Set channel finished callback to handle finished custom SFX
        Mix_ChannelFinished(&extSfxStopCallback);

        StartSfxThread();

        g_mixerLoaded = true;
    }
#endif // #ifndef THEXTECH_NO_SDL_BUILD
}

void RestartMixerX()
{
    int recent_music = s_recentMusicA;

    if(g_mixerLoaded && !musicPlaying)
        recent_music = s_null_music;

    UnloadSound();
    QuitMixerX();

    InitMixerX();
    InitSound();
    LoadCustomSound();

    if(recent_music != s_null_music)
        StartMusic(recent_music);
}

void QuitMixerX()
{
    if(!g_mixerLoaded)
        return;

    EndSfxThread();

    UnloadExtSounds();

    if(g_curMusic)
        Mix_FreeMusic(g_curMusic);

    g_curMusic = nullptr;
    g_reservedChannels = 0;

    for(auto & it : sound)
    {
        auto &s = it.second;
        clear_sfx(s);
    }

    sound.clear();
    music.clear();

    Mix_CloseAudio();
    Mix_Quit();

    g_mixerLoaded = false;
}

static void AddMusic(SoundScope root,
                     IniProcessing &ini,
                     const std::string &alias,
                     const std::string &group,
                     int volume)
{
    std::string f;
    ini.beginGroup(group);
    ini.read("file", f, std::string());

    if(!f.empty())
    {
        Music_t m;
        if(root == SoundScope::global)
            m.path = MusicRoot + f;
        else if(root == SoundScope::episode)
            m.path = g_dirEpisode.resolveFileCaseAbs(f);
        else if(root == SoundScope::custom)
            m.path = g_dirCustom.resolveFileCaseAbs(f);

        ini.read("yoshi-mode-track", m.yoshiModeTrack, -1);
        m.volume = volume;
        pLogDebug("Adding music [%s] '%s'", alias.c_str(), m.path.c_str());

        auto a = music.find(alias);

        if(a == music.end())
            music.insert({alias, m});
        else
            a->second = m;
    }

    ini.endGroup();
}

static void RestoreSfx(SFX_t &u)
{
    if(u.isCustom)
    {
        if(u.chunk)
            Mix_FreeChunk(u.chunk);

        if(u.music)
            Mix_FreeMusic(u.music);

        u.chunk = u.chunkOrig;
        u.music = u.musicOrig;
        u.isSilent = u.isSilentOrig;

        u.chunkOrig = nullptr;
        u.musicOrig = nullptr;
        u.isSilentOrig = false;

        u.isCustom = false;
    }
}

static void AddSfx(SoundScope root,
                   IniProcessing &ini,
                   int alias,
                   const std::string &group,
                   bool isCustom = false)
{
    std::string f;
    bool isSilent;
    ini.beginGroup(group);
    ini.read("file", f, std::string());
    ini.read("silent", isSilent, false);

    if(!f.empty() || isSilent)
    {
        if(LoadingInProcess)
            LoaderUpdateDebugString(fmt::format_ne("sound {0}", f));

        if(isCustom)
        {
            auto s = sound.find(alias);

            if(s != sound.end())
            {
                auto &m = s->second;

                std::string newPath;
                if(root == SoundScope::global)
                    newPath = SfxRoot + f;
                else if(root == SoundScope::episode)
                    newPath = g_dirEpisode.resolveFileCaseAbs(f);
                else if(root == SoundScope::custom)
                    newPath = g_dirCustom.resolveFileCaseAbs(f);

                if(!isSilent && m.isCustom && newPath == m.customPath)
                {
                    ini.endGroup();
                    return;  // Don't load the same file twice!
                }

                Mix_Chunk *backup_chunk = m.chunk;
                Mix_Music *backup_music = m.music;
                bool backup_isSilent = m.isSilent;
                m.customPath = newPath;

                m.chunk = nullptr;
                m.music = nullptr;
                m.isSilent = false;

                if(!isSilent)
                {
                    m.music = Mix_LoadMUS((newPath).c_str());
                    if(m.music)
                    {
                        // check, if short enough, load it as a chunk instead
                        double duration = Mix_MusicDuration(m.music);
                        if(duration >= 0 && duration < c_max_chunk_duration)
                        {
                            Mix_FreeMusic(m.music);
                            m.music = nullptr;
                        }
                        else
                            pLogInfo("Will load SFX %s as a multi-music", newPath.c_str());
                    }

                    if(!m.music)
                        m.chunk = Mix_LoadWAV((newPath).c_str());
                }

                if(m.chunk || m.music || isSilent)
                {
                    if(!m.isCustom && !m.chunkOrig && !m.musicOrig)
                    {
                        m.chunkOrig = backup_chunk;
                        m.musicOrig = backup_music;
                        m.isSilentOrig = backup_isSilent;
                    }
                    else
                    {
                        if(backup_chunk)
                            Mix_FreeChunk(backup_chunk);

                        if(backup_music)
                            Mix_FreeMusic(backup_music);
                    }

                    m.isCustom = true;
                    m.isSilent = isSilent;
                }
                else
                {
                    m.chunk = backup_chunk;
                    m.music = backup_music;
                    m.isSilent = backup_isSilent;
                    pLogWarning("ERROR: SFX '%s' loading error: %s", m.path.c_str(), Mix_GetError());
                }
            }
        }
        else
        {
            SFX_t m;

            if(root == SoundScope::global)
                m.path = SfxRoot + f;
            else if(root == SoundScope::episode)
                m.path = g_dirEpisode.resolveFileCaseAbs(f);
            else if(root == SoundScope::custom)
                m.path = g_dirCustom.resolveFileCaseAbs(f);

            m.isSilent = isSilent;
            pLogDebug("Adding SFX [sound%d] '%s'", alias, isSilent ? "<silence>" : m.path.c_str());
            if(!isSilent)
            {
                m.music = Mix_LoadMUS((m.path).c_str());
                if(m.music)
                {
                    // check, if short enough, load it as a chunk instead
                    double duration = Mix_MusicDuration(m.music);
                    if(duration >= 0 && duration < c_max_chunk_duration)
                    {
                        Mix_FreeMusic(m.music);
                        m.music = nullptr;
                    }
                    else
                        pLogInfo("Will load SFX %s as a multi-music", m.path.c_str());
                }

                if(!m.music)
                    m.chunk = Mix_LoadWAV((m.path).c_str());
            }

            if(m.chunk || m.music || isSilent)
            {
                bool isSingleChannel = false;
                ini.read("single-channel", isSingleChannel, false);
                if(isSingleChannel && m.chunk)
                    m.channel = g_reservedChannels++;

                auto se = sound.find(alias);
                if(se != sound.end()) // Avoid memory leaks
                {
                    auto &s = se->second;
                    clear_sfx(s);
                    s = std::move(m);
                }
                else
                    sound.insert({alias, m});
            }
            else
            {
                pLogWarning("ERROR: SFX '%s' loading error: %s", m.path.c_str(), Mix_GetError());
                g_errorsSfx++;
            }
        }
    }
    ini.endGroup();
}

void SetMusicVolume(const std::string &Alias, long Volume)
{
    auto mus = music.find(Alias);
    if(mus != music.end())
    {
        mus->second.volume = int(Volume);
    }
}

void SoundPauseAll()
{
    if(!g_mixerLoaded)
        return;

    pLogDebug("Pause all sound");
    Mix_PauseAudio(1);
}

void SoundResumeAll()
{
    if(!g_mixerLoaded)
        return;

    pLogDebug("Resume all sound");
    Mix_PauseAudio(0);
}

void SoundPauseEngine(int paused)
{
    if(!g_mixerLoaded)
        return;

    Mix_PauseAudio(paused);
}

static void processPathArgs(std::string &path,
                            const std::string &episodeRoot,
                            const std::string &dataDirName,
                            int *yoshiModeTrack = nullptr)
{
    if(path.find('|') == std::string::npos)
        return; // Nothing to do
    Strings::List p;
    Strings::split(p, path, '|');

    if(yoshiModeTrack)
    {
        *yoshiModeTrack = -1;
        Strings::List args;
        Strings::split(args, p[1], ';');
        for(auto &arg : args)
        {
            if(arg.compare(0, 3, "ym=") != 0)
                continue;
            *yoshiModeTrack = SDL_atoi(arg.substr(3).c_str());
        }
    }

    Strings::replaceInAll(p[1], "{e}", episodeRoot);
    Strings::replaceInAll(p[1], "{d}", episodeRoot + dataDirName);
    Strings::replaceInAll(p[1], "{r}", MusicRoot);
    path = p[0] + "|" + p[1];
}

void PlayMusic(const std::string &Alias, int fadeInMs)
{
    if(!g_mixerLoaded)
        return;

    if(g_curMusic)
    {
        Mix_HaltMusicStream(g_curMusic);
        Mix_FreeMusic(g_curMusic);
        g_curMusic = nullptr;
        g_stats.currentMusic.clear();
        g_stats.currentMusicFile.clear();
    }

    auto mus = music.find(Alias);
    if(mus != music.end())
    {
        auto &m = mus->second;
        std::string p = m.path;
        processPathArgs(p, FileNamePath + "/", FileName + "/");
        g_curMusic = Mix_LoadMUS(p.c_str());

        if(!g_curMusic)
            pLogWarning("Music '%s' opening error: %s", m.path.c_str(), Mix_GetError());
        else
        {
            int ret;

            Mix_VolumeMusicStream(g_curMusic, m.volume * g_config.audio_mus_volume / 100);
            s_musicYoshiTrackNumber = m.yoshiModeTrack;
            s_musicHasYoshiMode = (s_musicYoshiTrackNumber >= 0 && (Mix_GetMusicTracks(g_curMusic) > s_musicYoshiTrackNumber));
            s_musicDefaultVolume = m.volume;
            UpdateYoshiMusic();

#ifdef THEXTECH_ENABLE_AUDIO_FX
            if(s_musicDisableSpcEcho)
                Mix_GME_SetSpcEchoDisabled(g_curMusic, s_musicDisableSpcEcho);
#endif

            if(fadeInMs > 0)
                ret = Mix_FadeInMusic(g_curMusic, -1, fadeInMs);
            else
                ret = Mix_PlayMusic(g_curMusic, -1);

            if(ret >= 0)
            {
                g_stats.currentMusic = Mix_GetMusicTitle(g_curMusic);
                g_stats.currentMusicFile = Files::basename(m.path);
            }
            else
                pLogWarning("Music '%s' playing error: %s", m.path.c_str(), Mix_GetError());
        }
    }
    else
        pLogWarning("Unknown music alias '%s'", Alias.c_str());
}

static int getFallbackSfx(int A);
void PlaySfx_Blocking(int Alias, int loops, int volume, uint8_t left, uint8_t right)
{
    if(!g_mixerLoaded || (int)g_config.audio_sfx_volume == 0 || XMessage::GetStatus() == XMessage::Status::replay)
        return;

    auto sfx = sound.find(Alias);

    if(sfx == sound.end() || (!sfx->second.chunk && !sfx->second.music && !sfx->second.isSilent))
        sfx = sound.find(getFallbackSfx(Alias));

    if(sfx != sound.end())
    {
        auto &s = sfx->second;
        if(s.chunk)
        {
            int channel = Mix_PlayChannelVol(s.channel, s.chunk, loops, volume * g_config.audio_sfx_volume / 100);

            if(channel >= 0)
                Mix_SetPanning(channel, left, right);
        }
        else if(s.music)
        {
            if(Mix_PlayingMusicStream(s.music))
                Mix_RewindMusicStream(s.music);

            Mix_VolumeMusicStream(s.music, volume * g_config.audio_sfx_volume / 100);
            Mix_SetMusicEffectPanning(s.music, left, right);
            Mix_PlayMusicStream(s.music, loops);
        }
    }
}

void StopSfx(int Alias)
{
    auto sfx = sound.find(Alias);
    if(sfx != sound.end())
    {
        auto &s = sfx->second;
        if(s.chunk)
            Mix_HaltChannel(s.channel);
        else if(s.music)
            Mix_HaltMusicStream(s.music);
    }
}


static bool s_delayMusic = false;
static bool s_delayedMusicRequested = false;
static int  s_delayedMusicA = 0;
static int  s_delayedMusicFadeInMs = 0;

void setMusicStartDelay()
{
    s_delayedMusicRequested = false;
    s_delayMusic = true;
}

bool delayMusicIsSet()
{
    return s_delayMusic;
}

void delayedMusicStart()
{
    s_delayMusic = false;
    if(s_delayedMusicRequested)
    {
        D_pLogDebug("Restored delayed music request A=%d", s_delayedMusicA);
        StartMusic(s_delayedMusicA, s_delayedMusicFadeInMs);
        s_delayedMusicRequested = false;
    }
}

void delayedMusicReset()
{
    s_delayMusic = false;
    if(s_delayedMusicRequested)
        D_pLogDebug("Saved music request erase A=%d", s_delayedMusicA);
    s_delayedMusicRequested = false;
}

void StartMusic(int A, int fadeInMs)
{
    if(s_delayMusic)
    {
        s_delayedMusicA = A;
        s_delayedMusicFadeInMs = fadeInMs;
        s_delayedMusicRequested = true;
        D_pLogDebug("Saved start music request A=%d", A);
        return;
    }

    D_pLogDebug("Start music A=%d", A);

    if(!g_mixerLoaded || (int)g_config.audio_mus_volume == 0 || XMessage::GetStatus() == XMessage::Status::replay)
    {
        if(g_mixerLoaded && g_curMusic)
            StopMusic();

        // Keep world map music being remembered when sound disabled
        if((LevelSelect || WorldEditor) && !GameMenu && !GameOutro)
            curWorldMusic = A;

        s_recentMusicA = A;
        musicPlaying = true;

        return;
    }

    if((LevelSelect || WorldEditor) && !GameMenu && !GameOutro) // music on the world map
    {
        StopMusic();
        curWorldMusic = A;
        std::string mus = fmt::format_ne("wmusic{0}", A);
        if(curWorldMusic == g_customWldMusicId)
        {
            pLogDebug("Starting custom music [%s]", curWorldMusicFile.c_str());
            if(g_curMusic)
                Mix_FreeMusic(g_curMusic);
            std::string p = FileNamePath + "/" + curWorldMusicFile;
            processPathArgs(p, FileNamePath + "/", FileName + "/");
            g_curMusic = Mix_LoadMUS(p.c_str());
            s_musicHasYoshiMode = false;
            s_musicYoshiTrackNumber = -1;
            Mix_VolumeMusicStream(g_curMusic, 64 * g_config.audio_mus_volume / 100);
            s_musicDefaultVolume = 64;
            if(fadeInMs > 0)
                Mix_FadeInMusic(g_curMusic, -1, fadeInMs);
            else
                Mix_PlayMusic(g_curMusic, -1);
        }
        else
        {
            pLogDebug("Starting world music [%s]", mus.c_str());
            PlayMusic(mus, fadeInMs);
        }
        musicName = std::move(mus);
    }
    else if(A == -1) // P switch music
    {
        StopMusic();
        if(FreezeNPCs)
        {
            pLogDebug("Starting special music [stmusic]");
            PlayMusic("stmusic", fadeInMs);
            musicName = "stmusic";
        }
        else if(InvincibilityTime && !PSwitchTime && g_totalMusicSpecial >= 4)
        {
            pLogDebug("Starting special music [smusic4]");
            PlayMusic("smusic4", fadeInMs);
            musicName = "smusic4";
        }
        else
        {
            pLogDebug("Starting special music [smusic]");
            PlayMusic("smusic", fadeInMs);
            musicName = "smusic";
        }
        curMusic = -1;
    }
    else if(PSwitchTime == 0 && PSwitchStop == 0) // level music
    {
        StopMusic();
        curMusic = bgMusic[A];
        std::string mus = fmt::format_ne("music{0}", curMusic);
        if(curMusic == g_customLvlMusicId)
        {
            int ret = 0;

            pLogDebug("Starting custom music [%s%s]", FileNamePath.c_str(), CustomMusic[A].c_str());
            if(g_curMusic)
                Mix_FreeMusic(g_curMusic);
            std::string p = FileNamePath + CustomMusic[A];
            s_musicYoshiTrackNumber = -1;
            processPathArgs(p, FileNamePath, FileName + "/", &s_musicYoshiTrackNumber);
            g_curMusic = Mix_LoadMUS(p.c_str());
            if(!g_curMusic)
                pLogWarning("Failed to open the music [%s]: %s", p.c_str(), Mix_GetError());
            else
            {
                s_musicHasYoshiMode = (s_musicYoshiTrackNumber >= 0 && (Mix_GetMusicTracks(g_curMusic) > s_musicYoshiTrackNumber));
                UpdateYoshiMusic();
                Mix_VolumeMusicStream(g_curMusic, 52 * g_config.audio_mus_volume / 100);
                s_musicDefaultVolume = 52;
                if(fadeInMs > 0)
                {
                    ret = Mix_FadeInMusic(g_curMusic, -1, fadeInMs);
                    if(ret < 0)
                        pLogWarning("Failed to fade-in the music [%s]: %s", p.c_str(), Mix_GetError());
                }
                else
                {
                    ret = Mix_PlayMusic(g_curMusic, -1);
                    if(ret < 0)
                        pLogWarning("Failed to play the music [%s]: %s", p.c_str(), Mix_GetError());
                }
            }

            if(ret >= 0)
            {
                g_stats.currentMusic = Mix_GetMusicTitle(g_curMusic);
                g_stats.currentMusicFile = CustomMusic[A];
            }
        }
        else
        {
            pLogDebug("Starting level music [%s]", mus.c_str());
            PlayMusic(mus);
        }
        musicName = std::move(mus);
    }

    s_recentMusicA = A;
    musicPlaying = true;
}

void StartMusicIfOnscreen(int section)
{
    for(int i = 0; i < l_screen->player_count; i++)
    {
        if(Player[l_screen->players[i]].Section == section)
        {
            StartMusic(section);
            break;
        }
    }
}

void PauseMusic()
{
    if(!musicPlaying || !g_mixerLoaded)
        return;

    if(g_curMusic && Mix_PlayingMusicStream(g_curMusic))
        Mix_PauseMusicStream(g_curMusic);
}

void ResumeMusic()
{
    if(!musicPlaying || !g_mixerLoaded)
        return;

    if(g_curMusic && Mix_PausedMusicStream(g_curMusic))
        Mix_ResumeMusicStream(g_curMusic);
}

void StopMusic()
{
    if(!musicPlaying || !g_mixerLoaded)
        return;

    pLogDebug("Stopping music");

    if(g_curMusic)
    {
        Mix_HaltMusicStream(g_curMusic);
        Mix_FreeMusic(g_curMusic);
    }
    g_curMusic = nullptr;
    musicPlaying = false;
    s_recentMusicA = s_null_music;
    g_stats.currentMusic.clear();
    g_stats.currentMusicFile.clear();
}

void FadeOutMusic(int ms)
{
    if(!musicPlaying || !g_mixerLoaded)
        return;

    pLogDebug("Fading out music");
    if(g_curMusic)
        Mix_FadeOutMusicStream(g_curMusic, ms);
    musicPlaying = false;
    s_recentMusicA = s_null_music;
}

void UpdateMusicVolume()
{
    if(!musicPlaying || !g_mixerLoaded)
        return;

    if(g_curMusic)
    {
        if((int)g_config.audio_mus_volume == 0)
            StartMusic(s_recentMusicA); // will actually STOP it
        else
            Mix_VolumeMusicStream(g_curMusic, s_musicDefaultVolume * g_config.audio_mus_volume / 100);
    }
    else if(s_recentMusicA != s_null_music)
        StartMusic(s_recentMusicA); // will restart it
}

void PlayInitSound()
{
    MusicRoot = AppPath + "music/";
    SfxRoot = AppPath + "sound/";

    // std::string doSound = AppPath + "sound/";
    IniProcessing sounds = Files::load_ini(AppPath + "sounds.ini");
    unsigned int totalSounds;
    sounds.beginGroup("sound-main");
    sounds.read("total", totalSounds, 0);
    sounds.endGroup();

    if(totalSounds >= 29)
    {
        std::string p;
        sounds.beginGroup("sound-29");
        sounds.read("file", p, std::string());
        sounds.endGroup();

        if(!p.empty())
        {
            Mix_Music *loadsfx = Mix_LoadMUS((SfxRoot + p).c_str());
            if(loadsfx)
            {
                if(Mix_PlayMusicStream(loadsfx, 0) < 0)
                    Mix_FreeMusic(loadsfx);
                else
                    Mix_SetFreeOnStop(loadsfx, 1);
            }
        }
    }
}

static void loadMusicIni(SoundScope root, const std::string &path, bool isLoadingCustom)
{
    IniProcessing musicSetup = Files::load_ini(path);
    if(!isLoadingCustom)
    {
        music.clear();
        g_totalMusicLevel = 0;
        g_totalMusicWorld = 0;
        g_totalMusicSpecial = 0;
        musicSetup.beginGroup("music-main");
        musicSetup.read("total-level", g_totalMusicLevel, 0);
        musicSetup.read("total-world", g_totalMusicWorld, 0);
        musicSetup.read("total-special", g_totalMusicSpecial, 0);
        musicSetup.read("level-custom-music-id", g_customLvlMusicId, 0);
        musicSetup.read("world-custom-music-id", g_customWldMusicId, 0);
        musicSetup.endGroup();

        if(LoadingInProcess)
            UpdateLoad();
    }

    for(unsigned int i = 1; i <= g_totalMusicLevel; ++i)
    {
        std::string alias = fmt::format_ne("music{0}", i);
        std::string group = fmt::format_ne("level-music-{0}", i);
        AddMusic(root, musicSetup, alias, group, 52);
    }

    if(!isLoadingCustom && LoadingInProcess)
        UpdateLoad();

    for(unsigned int i = 1; i <= g_totalMusicWorld; ++i)
    {
        std::string alias = fmt::format_ne("wmusic{0}", i);
        std::string group = fmt::format_ne("world-music-{0}", i);
        AddMusic(root, musicSetup, alias, group, 64);
    }

    if(!isLoadingCustom && LoadingInProcess)
        UpdateLoad();

    for(unsigned int i = 1; i <= g_totalMusicSpecial; ++i)
    {
        std::string alias = fmt::format_ne("smusic{0}", i);
        if(i == 1)
            alias = "smusic";
        else if(i == 2)
            alias = "stmusic";
        else if(i == 3)
            alias = "tmusic";
        std::string group = fmt::format_ne("special-music-{0}", i);
        AddMusic(root, musicSetup, alias, group, 64);
    }
}

#ifdef THEXTECH_ENABLE_AUDIO_FX
static void readFx(IniProcessing &sounds, SectionEffect_t &s)
{
    const IniProcessing::StrEnumMap fxType =
    {
        {"none", SectionEffect_t::FX_None},
        {"reverb", SectionEffect_t::FX_Reverb},
        {"echo", SectionEffect_t::FX_Echo}
    };

    sounds.readEnum("fx", s.fx, (int)SectionEffect_t::FX_None, fxType);
    sounds.read("spc-echo-off", s.disableSpcEcho, false);

    switch(s.fx)
    {
    case SectionEffect_t::FX_Reverb:
        sounds.read("mode", s.rev.mode, 0.0f);
        sounds.read("room-size", s.rev.roomSize, 0.7f);
        sounds.read("damping", s.rev.damping, 0.5f);
        sounds.read("wet-level", s.rev.wetLevel, 0.2f);
        sounds.read("dry-level", s.rev.dryLevel, 0.4f);
        sounds.read("width", s.rev.width, 1.0f);
        break;

    case SectionEffect_t::FX_Echo:
        sounds.read("echo-on", s.echo.echoOn, 1);
        sounds.read("delay", s.echo.echoDelay, 6);
        sounds.read("feedback", s.echo.echoFeedBack, 30);
        sounds.read("main-volume-left", s.echo.echoMainVolL, 127);
        sounds.read("main-volume-right", s.echo.echoMainVolR, 127);
        sounds.read("echo-volume-left", s.echo.echoVolL, 28);
        sounds.read("echo-volume-right", s.echo.echoVolR, 28);
        sounds.read("fir-0", s.echo.echoFir[0], 99);
        sounds.read("fir-1", s.echo.echoFir[1], -52);
        sounds.read("fir-2", s.echo.echoFir[2], 32);
        sounds.read("fir-3", s.echo.echoFir[3], 50);
        sounds.read("fir-4", s.echo.echoFir[4], 25);
        sounds.read("fir-5", s.echo.echoFir[5], 51);
        sounds.read("fir-6", s.echo.echoFir[6], -35);
        sounds.read("fir-7", s.echo.echoFir[7], 56);
        break;

    default:
    case SectionEffect_t::FX_None:
        break;
    }
}
#endif // THEXTECH_ENABLE_AUDIO_FX

static void loadCustomSfxIni(SoundScope root, const std::string &path)
{
    IniProcessing sounds = Files::load_ini(path);
    for(unsigned int i = 1; i <= g_totalSounds; ++i)
    {
        int alias = i;
        std::string group = fmt::format_ne("sound-{0}", i);
        AddSfx(root, sounds, alias, group, true);
    }

#ifdef THEXTECH_ENABLE_AUDIO_FX
    auto ch = sounds.childGroups();
    for(const auto &g : ch)
    {
        if(g.find("fx-") == 0)
        {
            sounds.beginGroup(g);
            SectionEffect_t fx;
            auto e = g;
            e.erase(e.begin(), e.begin() + 3);
            readFx(sounds, fx);
            s_effectsList.insert({e, fx});
            sounds.endGroup();
        }
    }

    // FX settings
    for(int i = 0; i <= maxSections; ++i)
    {
        auto &s = s_sectionEffect[i];
        std::string cfx;

        sounds.beginGroup(fmt::format_ne("section-fx-{0}", i));
        sounds.read("custom-fx", cfx, std::string());
        if(!cfx.empty() && s_effectsList.find(cfx) != s_effectsList.end())
            s = s_effectsList[cfx];
        else
            readFx(sounds, s);
        sounds.endGroup();
    }
#endif // THEXTECH_ENABLE_AUDIO_FX
}

static void restoreDefaultSfx()
{
    for(auto &s : sound)
    {
        auto &u = s.second;
        RestoreSfx(u);
    }

#ifdef THEXTECH_ENABLE_AUDIO_FX
    s_effectsList.clear();

    for(int i = 0; i <= maxSections; ++i)
    {
        s_sectionEffect[i].fx = SectionEffect_t::FX_None;
        s_sectionEffect[i].rev = SoundFXReverb();
        s_sectionEffect[i].echo = SoundFXEchoSetup();
    }
    SoundFX_Clear();
#endif
}

void InitSound()
{
    if(!g_mixerLoaded)
        return;

    uint32_t start_time = SDL_GetTicks();

    MusicRoot = AppPath + "music/";
    SfxRoot = AppPath + "sound/";

    musicIni = AppPath + "music.ini";
    sfxIni = AppPath + "sounds.ini";


    if(LoadingInProcess)
    {
        LoaderUpdateDebugString("Sound configs");
        UpdateLoad();
    }

    if(!Files::fileExists(musicIni) && !Files::fileExists(sfxIni))
    {
        pLogWarning("music.ini and sounds.ini are missing");
        XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR,
                     "music.ini and sounds.ini are missing",
                     "Files music.ini and sounds.ini are not exist, game will work without default music and SFX.");
        g_customLvlMusicId = 24;
        g_customWldMusicId = 17;
        return;
    }
    else if(!Files::fileExists(musicIni))
    {
        pLogWarning("music.ini is missing");
        XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR,
                     "music.ini is missing",
                     "File music.ini is not exist, game will work without default music.");
    }
    else if(!Files::fileExists(sfxIni))
    {
        pLogWarning("sounds.ini is missing");
        XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR,
                     "sounds.ini is missing",
                     "File sounds.ini is not exist, game will work without SFX.");
    }

    loadMusicIni(SoundScope::global, musicIni, false);

    if(LoadingInProcess)
        UpdateLoad();
    else
        IndicateProgress(start_time, 0.01_n, "");

    IniProcessing sounds = Files::load_ini(sfxIni);
    sounds.beginGroup("sound-main");
    sounds.read("total", g_totalSounds, 0);
    sounds.read("use-iceball-sfx", s_useIceBallSfx, false);
    sounds.read("use-new-ice-sfx", s_useNewIceSfx, false);
    bool playerUseNPCHammer;
    bool playerUseOwnHammer;
    sounds.read("player-use-npc-hammer-sfx", playerUseNPCHammer, false);
    sounds.read("player-use-own-hammer-sfx", playerUseOwnHammer, false);
    sounds.endGroup();

    if(playerUseOwnHammer)
        playerHammerSFX = SFX_PlayerHeavy;
    else if(playerUseNPCHammer)
        playerHammerSFX = SFX_Throw;
    else
        playerHammerSFX = SFX_Fireball;

    if(LoadingInProcess)
        UpdateLoad();
    else
        IndicateProgress(start_time, 0.75_n / g_totalSounds, "");

    for(unsigned int i = 1; i <= g_totalSounds; ++i)
    {
        int alias = i;
        std::string group = fmt::format_ne("sound-{0}", i);
        AddSfx(SoundScope::global, sounds, alias, group);

        if(!LoadingInProcess)
            IndicateProgress(start_time, num_t(i) / g_totalSounds, "");
#ifdef PGE_NO_THREADING
        else
            UpdateLoad();
#endif

        if(!GameIsActive)
            return;
    }

    if(LoadingInProcess)
    {
        LoaderUpdateDebugString("All sounds loaded");
        UpdateLoad();
    }

    Mix_ReserveChannels(g_reservedChannels);

    if(g_errorsSfx > 0 && GameIsActive)
    {
        XMsgBox::simpleMsgBox(XMsgBox::MESSAGEBOX_ERROR,
                              "Sounds loading error",
                              fmt::format_ne("Failed to load some SFX assets. Loo a log file to get more details:\n{0}", getLogFilePath()));
        g_errorsSfx = 0;
    }

    // Print the stats of loaded sound files
    int statSfxDump = 0;
    int statSfxAsMusic = 0;

    for(auto & it : sound)
    {
        auto &s = it.second;

        if(s.music)
            statSfxAsMusic++;

        if(s.chunk)
            statSfxDump++;
    }

    pLogInfo("Loaded sound effects: dumped=%d; as music=%d", statSfxDump, statSfxAsMusic);
}

void UnloadSound()
{
    restoreDefaultSfx();

    UnloadExtSounds();

    if(g_curMusic)
        Mix_FreeMusic(g_curMusic);

    g_curMusic = nullptr;
    g_reservedChannels = 0;

    for(auto & it : sound)
    {
        auto &s = it.second;
        clear_sfx(s);
    }

    sound.clear();
    music.clear();
}

static const std::unordered_map<int, int> s_soundDelays =
{
    {2, 12}, {3, 12},  {4, 12},  {5, 30}, {8, 10},  {9, 4},
    {10, 8}, {12, 10}, {17, 10}, {26, 8}, {31, 20}, {37, 10},
    {42, 16},{50, 8},  {54, 8},  {71, 9}, {74, 8},  {81, 5},
    {86, 8}, {SFX_Icebreak, 4}
};

static void s_resetSoundDelay(int A)
{
    // set the delay before a sound can be played again
    auto i = s_soundDelays.find(A);
    if(i == s_soundDelays.end())
        SoundPause[A] = 4;
    else
        SoundPause[A] = i->second;

#if 0 // Very old code, replaced with a more flexible thing at above
    switch(A)
    {
    case 2: SoundPause[A] = 12; break;
    case 3: SoundPause[A] = 12; break;
    case 4: SoundPause[A] = 12; break;
    case 5: SoundPause[A] = 30; break;
    case 8: SoundPause[A] = 10; break;
    case 9: SoundPause[A] = 4; break;
    case 10: SoundPause[A] = 8; break;
    case 12: SoundPause[A] = 10; break;
    case 17: SoundPause[A] = 10; break;
    case 26: SoundPause[A] = 8; break;
    case 31: SoundPause[A] = 20; break;
    case 37: SoundPause[A] = 10; break;
    case 42: SoundPause[A] = 16; break;
    case 50: SoundPause[A] = 8; break;
    case 54: SoundPause[A] = 8; break;
    case 71: SoundPause[A] = 9; break;
    case 74: SoundPause[A] = 8; break;
    case 81: SoundPause[A] = 5; break;
    case 86: SoundPause[A] = 8; break;
    default: SoundPause[A] = 4; break;
    }
#endif
}

static const std::unordered_map<int, int> s_soundFallback =
{
    {SFX_Iceball, SFX_Fireball},
    {SFX_Freeze, SFX_ShellHit},
    {SFX_Icebreak, SFX_ShellHit},
    {SFX_SproutVine, SFX_ItemEmerge},
    {SFX_FireBossKilled, SFX_SickBossKilled},
    {SFX_HeroIce, SFX_HeroFire},
    {SFX_HeroFireRod, SFX_HeroFire},
    {SFX_FlameThrower, SFX_HeroFire},
    {SFX_FlagExit, SFX_TapeExit},
    {SFX_PlayerHeavy, SFX_Fireball},
};

static int getFallbackSfx(int A)
{
    auto fb = s_soundFallback.find(A);
    if(fb != s_soundFallback.end())
        A = fb->second;
    return A;
}

void PlaySound(int A, int loops, int volume)
{
    if(!g_mixerLoaded)
        return;

    if(g_totalSounds == 0)
    {
        playFallbackSfx(A, loops, volume);
        return;
    }

    if(GameMenu || GameOutro) // || A == 26 || A == 27 || A == 29)
        return;

    if(A > (int)g_totalSounds || !g_config.sfx_modern) // Play fallback sound for the missing SFX
        A = getFallbackSfx(A);
    else if(!s_useIceBallSfx && A == SFX_Iceball)
        A = SFX_Fireball; // Fell back into fireball when iceball sound isn't preferred
    else if(!s_useIceBallSfx && A == SFX_HeroIce)
        A = SFX_HeroFire;
    else if(!s_useNewIceSfx && (A == SFX_Freeze || A == SFX_Icebreak))
        A = SFX_ShellHit; // Restore the old behavior

    if(g_ClonedPlayerMode)
        SoundPause[SFX_Skid] = 1;

    if(SoundPause[A] == 0) // if the sound wasn't just played
    {
        int alias = A;
        PlaySfx(alias, loops, volume);
        s_resetSoundDelay(A);
    }
}

void PlaySoundSpatial(int A, int l, int t, int r, int b, int loops, int volume)
{
    if(!g_mixerLoaded)
        return;

    if(GameMenu || GameOutro) // || A == 26 || A == 27 || A == 29)
        return;

    if(A > (int)g_totalSounds || !g_config.sfx_modern) // Play fallback sound for the missing SFX
        A = getFallbackSfx(A);
    else if(!s_useIceBallSfx && A == SFX_Iceball)
        A = SFX_Fireball; // Fell back into fireball when iceball sound isn't preferred
    else if(!s_useIceBallSfx && A == SFX_HeroIce)
        A = SFX_HeroFire;
    else if(!s_useNewIceSfx && (A == SFX_Freeze || A == SFX_Icebreak))
        A = SFX_ShellHit; // Restore the old behavior

    if(g_ClonedPlayerMode)
        SoundPause[SFX_Skid] = 1;

    if(SoundPause[A] == 0) // if the sound wasn't just played
    {
        uint8_t left = 255, right = 255;

        if(g_config.sfx_spatial_audio)
            Sound_ResolveSpatialMod(left, right, l, t, r, b);

        int alias = A;
        PlaySfx(alias, loops, volume, left, right);
        s_resetSoundDelay(A);
    }
}

bool HasSound(int A)
{
    return A <= (int)g_totalSounds;
}

void PlaySoundMenu(int A, int loops)
{
    if(SoundPause[A] > 0) // if the sound wasn't just played
        return;

    if(g_totalSounds == 0 || A > (int)g_totalSounds)
    {
        playFallbackSfx(A, loops, 128);
        return;
    }

    int alias = A;
    PlaySfx(alias, loops);
    s_resetSoundDelay(A);
}

#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
void PlayErrorSound(int A, int loops)
{
    playFallbackSfx(A, loops, 128);
}
#endif

// stops all sound from being played for 10 cycles
void BlockSound()
{
    For(A, 1, numSounds)
    {
        SoundPause[A] = 10;
    }
}

void UpdateSound()
{
    if(!g_mixerLoaded)
        return;

    For(A, 1, numSounds)
    {
        if(SoundPause[A] > 0)
            SoundPause[A] -= 1;
    }
}

void LoadCustomSound()
{
    if(!g_mixerLoaded)
        return;

    if(GameMenu || GameOutro)
        return; // Don't load custom music in menu mode

    // To avoid bugs like custom local sounds was transferred into another level, it's need to clean-up old one if that was
    if(g_customMusicInDataFolder)
    {
        loadMusicIni(SoundScope::global, musicIni, true);
        g_customMusicInDataFolder = false;
    }

    if(g_customSoundsInDataFolder)
    {
        restoreDefaultSfx();
        g_customSoundsInDataFolder = false;
    }

    if(FileNamePath == AppPath)
        return; // Don't treat default music/sounds ini as custom

    std::string mIni = g_dirEpisode.resolveFileCaseExistsAbs("music.ini");
    if(!mIni.empty()) // Load music.ini from an episode folder
        loadMusicIni(SoundScope::episode, mIni, true);

    std::string mIniC = g_dirCustom.resolveFileCaseExistsAbs("music.ini");
    if(!mIniC.empty()) // Load music.ini from a level/world custom folder
    {
        loadMusicIni(SoundScope::custom, mIniC, true);
        g_customMusicInDataFolder = true;
    }

    std::string sIni = g_dirEpisode.resolveFileCaseExistsAbs("sounds.ini");
    if(!sIni.empty()) // Load sounds.ini from an episode folder
        loadCustomSfxIni(SoundScope::episode, sIni);

    std::string sIniC = g_dirCustom.resolveFileCaseExistsAbs("sounds.ini");
    if(!sIniC.empty()) // Load sounds.ini from a level/world custom folder
    {
        loadCustomSfxIni(SoundScope::custom, sIniC);
        g_customSoundsInDataFolder = true;
    }
}

void UnloadCustomSound()
{
    if(!g_mixerLoaded)
        return;

    loadMusicIni(SoundScope::global, musicIni, true);
    restoreDefaultSfx();
    g_customMusicInDataFolder = false;
    g_customSoundsInDataFolder = false;

    UnloadExtSounds();
}

void UpdateYoshiMusic()
{
    if(!s_musicHasYoshiMode || !g_mixerLoaded)
        return;

    bool hasYoshi = false;

    if(!g_config.sfx_pet_beat)
        hasYoshi = false;
    else
    {
        for(int i = 1; i <= numPlayers; ++i)
            hasYoshi |= (Player[i].Mount == 3);
    }

    Mix_SetMusicTrackMute(g_curMusic, s_musicYoshiTrackNumber, hasYoshi ? 0 : 1);
}

void PreloadExtSound(const std::string& path)
{
    if(!g_mixerLoaded)
        return;

    auto f = extSfx.find(path);
    if(f == extSfx.end())
    {
        pLogDebug("Preloading custom sound [%s]...", path.c_str());
        SDL_RWops *f = Files::open_file(path, "rb");
        if(!f)
        {
            pLogWarning("Custom sound preload: Can't acquire a file handle for [%s] (SDL Error: %s)", path.c_str(), SDL_GetError());
            return;
        }

        auto *ch = Mix_LoadWAV_RW(f, 1);
        if(!ch)
        {
            pLogWarning("Custom sound preload: Can't load custom sound [%s]: %s", path.c_str(), Mix_GetError());
            return;
        }
        extSfx.insert({path, ch});
    }
}

void UnloadExtSounds()
{
    if(!g_mixerLoaded)
        return;

    SDL_AtomicSet(&extSfxBusy, 1);

    for(auto &f : extSfx)
        Mix_FreeChunk(f.second);

    extSfx.clear();
    extSfxPlaying.clear();

    SDL_AtomicSet(&extSfxBusy, 0);
}

void PlayExtSound(const std::string &path, int loops, int volume)
{
    int play_ch = -1;

    if(!g_mixerLoaded || (int)g_config.audio_sfx_volume == 0 || XMessage::GetStatus() == XMessage::Status::replay)
        return;

    auto f = extSfx.find(path);
    if(f == extSfx.end())
    {
        auto *ch = Mix_LoadWAV(path.c_str());
        if(!ch)
        {
            pLogWarning("Can't load custom sound %s: %s", path.c_str(), Mix_GetError());
            return;
        }

        extSfx.insert({path, ch});
        play_ch = Mix_PlayChannelVol(-1, ch, loops, volume * g_config.audio_sfx_volume / 100);
    }
    else
        play_ch = Mix_PlayChannelVol(-1, f->second, loops, volume * g_config.audio_sfx_volume / 100);

    if(play_ch >= 0)
    {
        SDL_AtomicSet(&extSfxBusy, 1);
        // Never re-use the same channel!
        SDL_assert_release(extSfxPlaying.find(play_ch) == extSfxPlaying.end());
        extSfxPlaying.insert({play_ch, path});
        SDL_AtomicSet(&extSfxBusy, 0);
    }
    else
        pLogWarning("Can't play custom sound %s: %s", path.c_str(), Mix_GetError());
}

#ifndef THEXTECH_NO_SDL_BUILD
static void extSfxStopCallback(int channel)
{
    if(SDL_AtomicGet(&extSfxBusy) == 1)
        return; // Do nothing!

    auto i = extSfxPlaying.find(channel);
    if(i != extSfxPlaying.end())
        extSfxPlaying.erase(i);
}
#endif

void StopExtSound(const std::string& path)
{
    if(!g_mixerLoaded)
        return;

    SDL_AtomicSet(&extSfxBusy, 1);

    for(auto i = extSfxPlaying.begin(); i != extSfxPlaying.end();)
    {
        if(i->second == path)
        {
            Mix_HaltChannel(i->first);
            i = extSfxPlaying.erase(i);
        }
        else
            ++i;
    }

    SDL_AtomicSet(&extSfxBusy, 0);
}

void StopAllExtSounds()
{
    if(!g_mixerLoaded)
        return;

    SDL_AtomicSet(&extSfxBusy, 1);

    for(auto i = extSfxPlaying.begin(); i != extSfxPlaying.end(); ++i)
        Mix_HaltChannel(i->first);

    extSfxPlaying.clear();

    SDL_AtomicSet(&extSfxBusy, 0);
}

void StopAllSounds()
{
    if(!g_mixerLoaded)
        return;

    SDL_AtomicSet(&extSfxBusy, 1);
    Mix_HaltChannel(-1);
    extSfxPlaying.clear();
    SDL_AtomicSet(&extSfxBusy, 0);
}

#ifdef THEXTECH_ENABLE_AUDIO_FX

static bool     enableEffectEcho = false;
static SpcEcho *effectEcho = nullptr;

static void echoEffectDone(int, void *context)
{
    SpcEcho *out = reinterpret_cast<SpcEcho *>(context);
    if(out == effectEcho)
    {
        echoEffectFree(effectEcho);
        effectEcho = nullptr;
        enableEffectEcho = false;
    }
}

void SoundFX_SetEcho(const SoundFXEchoSetup& setup)
{
    if(!g_mixerLoaded)
        return;

    bool isNew = false;

    // Clear previously installed effects first
    if(!effectEcho)
    {
        SoundFX_Clear();

        effectEcho = echoEffectInit(g_config.audio_sample_rate.obtained,
                                    g_config.audio_format.obtained,
                                    g_config.audio_channels.obtained);
        isNew = true;
    }

    if(effectEcho)
    {
        echoEffectSetReg(effectEcho, ECHO_EON, setup.echoOn);
        echoEffectSetReg(effectEcho, ECHO_EDL, setup.echoDelay);
        echoEffectSetReg(effectEcho, ECHO_EFB, setup.echoFeedBack);

        echoEffectSetReg(effectEcho, ECHO_MVOLL, setup.echoMainVolL);
        echoEffectSetReg(effectEcho, ECHO_MVOLR, setup.echoMainVolR);
        echoEffectSetReg(effectEcho, ECHO_EVOLL, setup.echoVolL);
        echoEffectSetReg(effectEcho, ECHO_EVOLR, setup.echoVolR);

        echoEffectSetReg(effectEcho, ECHO_FIR0, setup.echoFir[0]);
        echoEffectSetReg(effectEcho, ECHO_FIR1, setup.echoFir[1]);
        echoEffectSetReg(effectEcho, ECHO_FIR2, setup.echoFir[2]);
        echoEffectSetReg(effectEcho, ECHO_FIR3, setup.echoFir[3]);
        echoEffectSetReg(effectEcho, ECHO_FIR4, setup.echoFir[4]);
        echoEffectSetReg(effectEcho, ECHO_FIR5, setup.echoFir[5]);
        echoEffectSetReg(effectEcho, ECHO_FIR6, setup.echoFir[6]);
        echoEffectSetReg(effectEcho, ECHO_FIR7, setup.echoFir[7]);
        if(isNew)
            Mix_RegisterEffect(MIX_CHANNEL_POST, spcEchoEffect, echoEffectDone, effectEcho);
        enableEffectEcho = true;
    }
}

static bool enableEffectReverb = false;
static FxReverb *effectReverb = nullptr;

static void reverbEffectDone(int, void *context)
{
    FxReverb *out = reinterpret_cast<FxReverb *>(context);
    if(out == effectReverb)
    {
        reverbEffectFree(effectReverb);
        effectReverb = nullptr;
        enableEffectReverb = false;
    }
}

void SoundFX_SetReverb(const SoundFXReverb& setup)
{
    if(!g_mixerLoaded)
        return;

    bool isNew = false;

    if(!effectReverb)
    {
        // Clear previously installed effects first
        SoundFX_Clear();

        effectReverb = reverbEffectInit(g_config.audio_sample_rate.obtained,
                                        g_config.audio_format.obtained,
                                        g_config.audio_channels.obtained);
        isNew = true;
    }

    if(effectReverb)
    {
        ReverbSetup set;
        set.mode = setup.mode;
        set.roomSize = setup.roomSize;
        set.damping = setup.damping;
        set.wetLevel = setup.wetLevel;
        set.dryLevel = setup.dryLevel;
        set.width = setup.width;
        reverbUpdateSetup(effectReverb, set);
        if(isNew)
            Mix_RegisterEffect(MIX_CHANNEL_POST, reverbEffect, reverbEffectDone, effectReverb);
        enableEffectReverb = true;
    }
}

void SoundFX_Clear()
{
    if(!g_mixerLoaded)
        return;

    if(effectEcho)
    {
        Mix_UnregisterEffect(MIX_CHANNEL_POST, spcEchoEffect);
        if(effectEcho)
        {
            echoEffectFree(effectEcho);
            effectEcho = nullptr;
        }
        enableEffectEcho = false;
    }

    if(effectReverb)
    {
        Mix_UnregisterEffect(MIX_CHANNEL_POST, reverbEffect);
        if(effectReverb)
        {
            reverbEffectFree(effectReverb);
            effectReverb = nullptr;
        }
        enableEffectReverb = false;
    }
}

#endif // THEXTECH_ENABLE_AUDIO_FX


void ResetSoundFX()
{
#ifdef THEXTECH_ENABLE_AUDIO_FX
    SoundFX_Clear();
    s_musicDisableSpcEcho = false;
#endif
}

void UpdateSoundFX(int recentSection)
{
#ifndef THEXTECH_ENABLE_AUDIO_FX
    UNUSED(recentSection);
#else
    if(!g_mixerLoaded || LevelSelect)
        return;

    SDL_assert_release(recentSection >= 0 && recentSection <= maxSections);
    const auto &s = g_config.sfx_audio_fx ? s_sectionEffect[recentSection] : SectionEffect_t();

    s_musicDisableSpcEcho = s.disableSpcEcho;
    if(g_curMusic)
        Mix_GME_SetSpcEchoDisabled(g_curMusic, s.disableSpcEcho);

    switch(s.fx)
    {
    default:
    case SectionEffect_t::FX_None:
        SoundFX_Clear();
        break;

    case SectionEffect_t::FX_Echo:
        SoundFX_SetEcho(s.echo);
        break;

    case SectionEffect_t::FX_Reverb:
        SoundFX_SetReverb(s.rev);
        break;
    }
#endif // THEXTECH_ENABLE_AUDIO_FX
}


================================================
FILE: src/sound.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SOUND_H
#define SOUND_H

#include <string>
#include <cstdint>

#include "location.h"

// Public musicPlaying As Boolean
extern bool musicPlaying;
// Public musicLoop As Integer
extern int musicLoop;
// Public musicName As String
extern std::string musicName;

extern int playerHammerSFX;

extern const struct AudioDefaults_t
{
    int sampleRate;
    int channels;
    int bufferSize;
    uint16_t format;
} g_audioDefaults;

struct AudioSetup_t
{
    bool disableSound = false;
    int sampleRate = 44100;
    int channels = 2;
    int bufferSize = 512;
    uint16_t format = 0x8120;
};


enum
{
    SFX_Jump            = 1,
    SFX_Stomp,
    SFX_BlockHit,
    SFX_BlockSmashed,
    SFX_PlayerShrink,
    SFX_PlayerGrow,
    SFX_ItemEmerge,
    SFX_PlayerDied,
    SFX_ShellHit,
    SFX_Skid            = 10,
    SFX_DropItem,
    SFX_GotItem,
    SFX_Camera,
    SFX_Coin,
    SFX_1up,
    SFX_Lava,
    SFX_Warp,
    SFX_Fireball,
    SFX_CardRouletteClear,
    SFX_BossBeat        = 20,
    SFX_DungeonClear,
    SFX_Bullet,
    SFX_Grab,
    SFX_Spring,
    SFX_HeavyToss,
    SFX_Slide,
    SFX_NewPath,
    SFX_LevelSelect,
    SFX_Do,
    SFX_Pause           = 30,
    SFX_Key,
    SFX_PSwitch,
    SFX_Whip,
    SFX_Transform,
    SFX_Boot,
    SFX_Smash,
    SFX_Stone,
    SFX_SpitBossSpit,
    SFX_SpitBossHit,
    SFX_CrystalBallExit = 40,
    SFX_SpitBossBeat,
    SFX_BigFireball,
    SFX_Fireworks,
    SFX_VillainKilled,
    SFX_GameBeat,
    SFX_Door,
    SFX_Message,
    SFX_Pet,
    SFX_PetHurt,
    SFX_PetTongue       = 50,
    SFX_PetBirth,
    SFX_GotStar,
    SFX_HeroKill,
    SFX_PlayerDied2,
    SFX_PetSwallow,
    SFX_RingGet,
    SFX_Skeleton,
    SFX_Checkpoint,
    SFX_MedalGet,
    SFX_TapeExit        = 60,
    SFX_LavaMonster,
    SFX_SickBossSpit,
    SFX_SickBossKilled,
    SFX_SMBlockHit,
    SFX_SMKilled,
    SFX_SMHurt,
    SFX_SMGlass,
    SFX_SMBossHit,
    SFX_SMCry,
    SFX_SMExplosion     = 70,
    SFX_Climbing,
    SFX_Swim,
    SFX_Grab2,
    SFX_Saw,
    SFX_Throw,
    SFX_PlayerHit,
    SFX_HeroStab,
    SFX_HeroHurt,
    SFX_HeroHeart,
    SFX_HeroDied        = 80,
    SFX_HeroRupee,
    SFX_HeroFire,
    SFX_HeroItem,
    SFX_HeroKey,
    SFX_HeroShield,
    SFX_HeroDash,
    SFX_HeroFairy,
    SFX_HeroGrass,
    SFX_HeroHit,
    SFX_HeroSwordBeam   = 90,
    SFX_Bubble,

    // non-SMBX64, Extra
    SFX_CoinSwitchTimeout,
    SFX_BatFlap,
    SFX_Iceball,
    SFX_Freeze,
    SFX_Icebreak,
    SFX_PlayerHeavy, // Reserved
    SFX_SproutVine,
    SFX_MagicBossShell,
    SFX_MagicBossKilled = 100,
    SFX_FireBossKilled,
    SFX_HeroIce,
    SFX_HeroFireRod,
    SFX_FlameThrower,
    SFX_FlagExit,
};

int CustomWorldMusicId();

void InitSoundDefaults();

// Public Sub InitMixerX()
void InitMixerX();
// Public Sub RestartMixerX()
void RestartMixerX();
// Public Sub QuitMixerX()
void QuitMixerX();
// Public Sub SetMusicVolume(Alias As String, Volume As Long)
void SetMusicVolume(const std::string &Alias, long Volume);
// Public Sub SoundPauseAll()
void SoundPauseAll();
// Public Sub SoundResumeAll()
void SoundResumeAll();
void SoundPauseEngine(int paused);
// Public Sub PlayMusic(Alias As String)
void PlayMusic(const std::string &Alias, int fadeInMs = 0);
// Public Sub PlaySfx(Alias As String)
void PlaySfx_Blocking(int Alias, int loops = 0, int volume = 128, uint8_t left = 255, uint8_t right = 255);
// Public Sub StopSfx(Alias As String)
void StopSfx(int Alias);
// Public Sub StartMusic(A As Integer) 'play music
void setMusicStartDelay();
void delayedMusicStart();
void delayedMusicReset();
bool delayMusicIsSet();
// play music
void StartMusic(int A, int fadeInMs = 0);
void StartMusicIfOnscreen(int section);
// Public Sub StopMusic() 'stop playing music
void PauseMusic();
void ResumeMusic();
// stop playing music
void StopMusic();
// Public Sub PlayInitSound()
void PlayInitSound();
// Public Sub InitSound() 'readys sound and music to be played
// readys sound and music to be played
void InitSound();
// unloads all sounds for asset pack switch
void UnloadSound();
// Public Sub PlaySound(A As Integer) 'play a sound
// play a sound
void PlaySound(int A, int loops = 0, int volume = 128);

// NEW: play a sound with spatial awareness
void PlaySoundSpatial(int A, int l, int t, int r, int b, int loops = 0, int volume = 128);

// public signatures for spatial sound feature
inline void PlaySoundSpatial(int A, const Location_t& loc, int loops = 0, int volume = 128)
{
    PlaySoundSpatial(A, (int)loc.X, (int)loc.Y, (int)(loc.X + loc.Width), (int)(loc.Y + loc.Height), loops, volume);
}

inline void PlaySoundSpatial(int A, const SpeedlessLocation_t& loc, int loops = 0, int volume = 128)
{
    PlaySoundSpatial(A, (int)loc.X, (int)loc.Y, (int)(loc.X + loc.Width), (int)(loc.Y + loc.Height), loops, volume);
}

inline void PlaySoundSpatial(int A, int x, int y, int loops = 0, int volume = 128)
{
    PlaySoundSpatial(A, x, y, x, y, loops, volume);
}

// NEW: internal function to determine the panning for a sound (defined in sound_spatial.cpp)
void Sound_ResolveSpatialMod(uint8_t& left, uint8_t& right, int l, int t, int r, int b);

// Check does sound is defined at sounds.ini
bool HasSound(int A);
void PlaySoundMenu(int A, int loops = 0);

#if defined(THEXTECH_ASSERTS_INGAME_MESSAGE) && !defined(THEXTECH_NO_SDL_BUILD)
// always uses fallback sound
void PlayErrorSound(int A, int loops = 0);
#endif

// Public Sub BlockSound() 'stops all sound from being played for 10 cycles
// stops all sound from being played for 10 cycles
void BlockSound();
// Public Sub UpdateSound() 'checks to loop music and update the soundpause variable
// checks to loop music and update the soundpause variable
void UpdateSound();

void UpdateYoshiMusic();
// EXTRA: Fade out music
void FadeOutMusic(int ms);
// EXTRA: load custom sounds.ini and music.ini from episode and custom folder!
void LoadCustomSound();
// EXTRA: Unload custom-loaded music and sounds, and restore originals
void UnloadCustomSound();

void UpdateMusicVolume();

void PreloadExtSound(const std::string &path);
void UnloadExtSounds();
void PlayExtSound(const std::string &path, int loops = 0, int volume = 128);
void StopExtSound(const std::string &path);
void StopAllExtSounds();
void StopAllSounds();

#ifdef THEXTECH_ENABLE_AUDIO_FX
struct SoundFXEchoSetup
{
    int echoOn = 0;
    int echoDelay = 0;
    int echoFeedBack = 0;

    int echoMainVolL = 0;
    int echoMainVolR = 0;

    int echoVolL = 0;
    int echoVolR = 0;

    int echoFir[8] = {0, 0, 0, 0, 0, 0, 0, 0};
};
void SoundFX_SetEcho(const SoundFXEchoSetup &setup);

struct SoundFXReverb
{
    float mode         = 0.0f; // Normal (0) or Freeze (>0.5)
    float roomSize     = 0.7f;
    float damping      = 0.5f; // 0.0...1.0
    float wetLevel     = 0.2f;
    float dryLevel     = 0.4f;
    float width        = 1.0f; // 0.0...1.0
};
void SoundFX_SetReverb(const SoundFXReverb &setup);

void SoundFX_Clear();
#endif // THEXTECH_ENABLE_AUDIO_FX

void ResetSoundFX();

void UpdateSoundFX(int recentSection);

#endif // SOUND_H


================================================
FILE: src/sound_spatial.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "screen.h"
#include "sound.h"

void Sound_ResolveSpatialMod(uint8_t& left, uint8_t& right, int l, int t, int r, int b)
{
    const Screen_t& screen = *l_screen;

    left = 0;
    right = 0;

    for(int vscreen_i = screen.active_begin(); vscreen_i != screen.active_end(); vscreen_i++)
    {
        const vScreen_t& vscreen = vScreen[screen.vScreen_refs[vscreen_i]];

        int vscreen_l = -(int)vscreen.X;
        int vscreen_r = vscreen_l + vscreen.Width;
        int vscreen_c = vscreen_l + vscreen.Width / 2;
        int vscreen_t = -(int)vscreen.Y;
        int vscreen_b = vscreen_t + vscreen.Height;

        int l_dist = (r < vscreen_l) ? vscreen_l - r
                   : (l > vscreen_c) ? l - vscreen_c
                   : 0;

        int r_dist = (r < vscreen_c) ? vscreen_c - r
                   : (l > vscreen_r) ? l - vscreen_r
                   : 0;

        int x_dist = (r < vscreen_l) ? vscreen_l - r
                   : (l > vscreen_r) ? l - vscreen_r
                   : 0;

        int y_dist = (b < vscreen_t) ? vscreen_t - b
                   : (t > vscreen_b) ? t - vscreen_b
                   : 0;

        // decay constant: a sound 200px away should be 10dB quieter
        int64_t x_num = 200 * 200;
        int64_t y_num = 200 * 200;

        if(x_num <= 0)
            x_num = 1;
        if(y_num <= 0)
            y_num = 1;

        int64_t l_div = l_dist * l_dist;
        int64_t r_div = r_dist * r_dist;

        int64_t c_div = x_dist * x_dist;
        int64_t y_div = y_dist * y_dist;

        int l_calc = 127 * (x_num + y_num) / (l_div + y_div + x_num + y_num);
        int r_calc = 127 * (x_num + y_num) / (r_div + y_div + x_num + y_num);

        int c_calc = 128 * (x_num + y_num) / (c_div + y_div + x_num + y_num);

        l_calc = l_calc + c_calc;
        r_calc = r_calc + c_calc;

        if(l_calc > 255)
            l_calc = 255;
        if(r_calc > 255)
            r_calc = 255;

        if(vscreen.ScreenLeft >= screen.W / 2)
            l_calc = (l_calc * 3) / 4;
        else if(vscreen.ScreenLeft + vscreen.Width <= screen.W / 2)
            r_calc = (r_calc * 3) / 4;

        if(l_calc > (int)left)
            left = l_calc;
        if(r_calc > (int)right)
            right = r_calc;
    }
}


================================================
FILE: src/sound_thread.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <vector>
#include <cstdint>
#include <exception>

#include <SDL2/SDL_thread.h>
#include <SDL2/SDL_mutex.h>

#include "sound.h"
#include "config.h"
#include "message.h"
#include "sound_thread.h"

struct EnqueuedSfx_t
{
    int Alias;
    uint8_t loops;
    uint8_t volume;
    uint8_t left;
    uint8_t right;
};

static std::vector<EnqueuedSfx_t> s_sfx_queue;

static SDL_Thread* s_sound_thread = nullptr;
static SDL_mutex*  s_sound_thread_mutex = nullptr;
static SDL_cond*   s_sound_thread_cond = nullptr;

static bool        s_sound_thread_quit = false;

static int s_sound_thread_main(void*)
{
    static std::vector<EnqueuedSfx_t> s_sfx_queue_pop;
    s_sfx_queue_pop.clear();

    while(true)
    {
        // load state from the main thread
        SDL_LockMutex(s_sound_thread_mutex);

        if(!s_sound_thread_quit && s_sfx_queue.empty())
            SDL_CondWait(s_sound_thread_cond, s_sound_thread_mutex);

        bool quit = s_sound_thread_quit;
        std::swap(s_sfx_queue, s_sfx_queue_pop);

        SDL_UnlockMutex(s_sound_thread_mutex);

        if(quit)
            break;

        // execute SFX queue
        for(const EnqueuedSfx_t& sfx : s_sfx_queue_pop)
            PlaySfx_Blocking(sfx.Alias, sfx.loops, sfx.volume, sfx.left, sfx.right);

        s_sfx_queue_pop.clear();
    }

    return 0;
}

void PlaySfx(int Alias, int loops, int volume, uint8_t left, uint8_t right)
{
    if((int)g_config.audio_sfx_volume == 0 || XMessage::GetStatus() == XMessage::Status::replay)
        return;

    if(!s_sound_thread)
    {
        PlaySfx_Blocking(Alias, loops, volume, left, right);
        return;
    }

    SDL_LockMutex(s_sound_thread_mutex);

    try
    {
        s_sfx_queue.push_back(EnqueuedSfx_t{Alias, (uint8_t)loops, (uint8_t)volume, left, right});
    }
    catch(...)
    {
        SDL_UnlockMutex(s_sound_thread_mutex);

        std::exception_ptr e = std::current_exception();

        if(e)
            std::rethrow_exception(e);
    }

    SDL_UnlockMutex(s_sound_thread_mutex);
    SDL_CondSignal(s_sound_thread_cond);
}

void StartSfxThread()
{
    EndSfxThread();

    s_sound_thread_mutex = SDL_CreateMutex();
    if(!s_sound_thread_mutex)
        return;

    s_sound_thread_cond = SDL_CreateCond();
    if(!s_sound_thread_cond)
        return;

    s_sound_thread = SDL_CreateThread(s_sound_thread_main, "SFX thread", nullptr);
}

void EndSfxThread()
{
    if(s_sound_thread)
    {
        SDL_LockMutex(s_sound_thread_mutex);
        s_sound_thread_quit = true;
        SDL_UnlockMutex(s_sound_thread_mutex);
        SDL_CondSignal(s_sound_thread_cond);

        SDL_WaitThread(s_sound_thread, nullptr);
        s_sound_thread = nullptr;
        s_sound_thread_quit = false;
    }

    if(s_sound_thread_cond)
    {
        SDL_DestroyCond(s_sound_thread_cond);
        s_sound_thread_cond = nullptr;
    }

    if(s_sound_thread_mutex)
    {
        SDL_DestroyMutex(s_sound_thread_mutex);
        s_sound_thread_mutex = nullptr;
    }
}


================================================
FILE: src/sound_thread.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef SOUND_THREAD_H
#define SOUND_THREAD_H

#include <stdint.h>

#ifndef THEXTECH_NO_SDL_BUILD

/**
 * @brief Enqueues the SFX but does not block
 * @param Alias The alias of the sound
 * @param loops Number loops to play (n-1 value. When -1 - loop forever)
 * @param volume The volume level between 0 and 128
 * @param left The panning volume of left channel between 0 and 255
 * @param right The panning volume of right channel between 0 and 255
 */
void PlaySfx(int Alias, int loops = 0, int volume = 128, uint8_t left = 255, uint8_t right = 255);

/**
 * @brief Starts sound thread
 */
void StartSfxThread();

/**
 * @brief ends sound thread
 */
void EndSfxThread();

#else

// fallback: just call directly
#define PlaySfx PlaySfx_Blocking

static inline void StartSfxThread() {}
static inline void EndSfxThread() {}

#endif

#endif // #ifndef SOUND_THREAD_H


================================================
FILE: src/std_picture.cpp
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "std_picture.h"
#include "core/render.h"

StdPicture::~StdPicture()
{
    if(d.hasTexture())
        XRender::unloadTexture(*this);
}

void StdPicture::reset()
{
    if(d.hasTexture())
        XRender::unloadTexture(*this);

    static_cast<StdPicture_Sub&>(*this) = StdPicture_Sub();
}


================================================
FILE: src/std_picture.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef STD_PICTURE_H
#define STD_PICTURE_H

#include "xt_color.h"

#include "core/picture_data.h"
#include "core/picture_load.h"

#ifdef DEBUG_BUILD
#   include <string>
#   define STD_PICTURE_HAS_ORIG_PATH
#endif


struct SDL_Texture;

/**
 * @brief Handler of a graphical texture, excluding renderer-specific data
 */
struct StdPicture_Sub
{
#ifdef STD_PICTURE_HAS_ORIG_PATH
    //! Debug-only file path to the original picture
    std::string origPath;
#endif

    //! Was this texture initialized by graphical engine or not?
    bool inited = false;

    //! Width of texture
    int w = 0;
    //! Height of texture
    int h = 0;

    // [UNUSED] Frame width and height (for animation sprite textures)
    //! Animation frame width
    // int frame_w = 0;
    //1 Animation frame height
    // int frame_h = 0;

    // These colors were used to auto-choose the fill color for the background
    //! Left-top pixel color
    XTColor ColorUpper;
    //! Left-bottom pixel color
    XTColor ColorLower;

    /*!
     * \brief Reset colors into black
     */
    inline void resetColors()
    {
        ColorUpper.r = 0;
        ColorUpper.g = 0;
        ColorUpper.b = 0;
        ColorUpper.a = 255;

        ColorLower.r = 0;
        ColorLower.g = 0;
        ColorLower.b = 0;
        ColorLower.a = 255;
    }


    /* Loader related stuff */

    //! Loader-related data
    StdPictureLoad l;

};


/**
 * @brief Handler of a graphical texture, including renderer-specific data
 */
struct StdPicture : public StdPicture_Sub
{
    StdPicture() = default;

    //! Platform specific texture data
    StdPictureData d;

    /*!
     * \brief Prevent any assignment of textures to preserve renderer references to loaded textures
     */
    StdPicture& operator=(const StdPicture& o) = delete;
    StdPicture(const StdPicture& o) = delete;

    /*!
     * \brief reset operation unloads StdPictureData and also resets the StdPicture_Sub state
     */
    void reset();

    /*!
     * \brief Explicit destructor ensures that renderer unloads StdPictureData
     */
    ~StdPicture();
};

// This macro allows to get the original texture path when debug build is on,
// and safely return the blank string when the release build is
#ifdef STD_PICTURE_HAS_ORIG_PATH
#   define StdPictureGetOrigPath(x) x.origPath
#else
#   define StdPictureGetOrigPath(x) std::string()
#endif


#endif // STD_PICTURE_H


================================================
FILE: src/video.h
================================================


================================================
FILE: src/xt_color.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#ifndef XT_COLOR_H
#define XT_COLOR_H

#include <cstdint>
#include <string>

#include "numeric_types.h"

/*!
 * \brief RGBA pixel color
 */
struct alignas(uint32_t) XTColor
{
    uint8_t r = 255;
    uint8_t g = 255;
    uint8_t b = 255;
    uint8_t a = 255;

    // helper functions
    static inline constexpr uint8_t mul(uint8_t a, uint8_t b)
    {
        return uint8_t((uint16_t(a) * uint16_t(b)) >> 8);
    }

    static inline constexpr uint8_t from_num(num_t f)
    {
        return static_cast<uint8_t>(f * 255);
    }

    // initializers
    inline constexpr XTColor() {}
    inline constexpr XTColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) : r(r), g(g), b(b), a(a) {}
    inline constexpr XTColor(XTColor o, uint8_t alpha) : r(o.r), g(o.g), b(o.b), a(alpha) {}

    // multiply operator
    inline constexpr XTColor operator*(XTColor o) const
    {
        return XTColor(mul(r, o.r), mul(g, o.g), mul(b, o.b), mul(a, o.a));
    }

    // intensity scale
    inline constexpr XTColor operator*(num_t o) const
    {
        return XTColor(uint8_t(r * o), uint8_t(g * o), uint8_t(b * o), a);
    }

    inline constexpr XTColor operator*(uint8_t o) const
    {
        return XTColor(mul(r, o), mul(g, o), mul(b, o), a);
    }

    inline constexpr XTColor operator*(float o) const = delete;

    // (in)equality operators
    inline constexpr bool operator==(XTColor o) const
    {
        return r == o.r && g == o.g && b == o.b && a == o.a;
    }

    inline constexpr bool operator!=(XTColor o) const
    {
        return !(*this == o);
    }

    // alpha change operators (return new colors)
    inline constexpr XTColor with_alpha(uint8_t new_a) const
    {
        return XTColor(r, g, b, new_a);
    }

    inline constexpr XTColor with_alphaF(num_t new_a) const
    {
        return XTColor(r, g, b, from_num(new_a));
    }
};

static inline constexpr XTColor XTColorF(num_t r, num_t g, num_t b, num_t a = 1)
{
    return XTColor(XTColor::from_num(r),
        XTColor::from_num(g),
        XTColor::from_num(b),
        XTColor::from_num(a));
}

static inline constexpr XTColor XTAlpha(uint8_t a)
{
    return XTColor().with_alpha(a);
}

static inline constexpr XTColor XTAlphaF(num_t a)
{
    return XTColor().with_alpha(XTColor::from_num(a));
}

/**
 * \brief converts a color string into an XTColor instance
 *
 * \param s string reference
 *
 * Currently supports hex strings only. Defined in globals.cpp.
 **/
XTColor XTColorString(const std::string& s);

#endif


================================================
FILE: test/CI-tests.py
================================================
#!/usr/bin/python3

#
#  TheXTech - A platform game engine ported from old source code for VB6
#
#  Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
#  Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
#
#  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 3 of the License, or
#  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, see <http://www.gnu.org/licenses/>.
#

# This script is a WIP way to measure the game's compatibility and performance on recordings made with SMBX-R.
# It will be used in the future to automate compatibility and performance testing for TheXTech.

import argparse
import subprocess
import json
import sys
import os

parser = argparse.ArgumentParser(
                    prog='CI-tests.py',
                    description='This script is a WIP way to measure the game\'s compatibility and performance on using gameplay recordings.')

parser.add_argument('-n', '--name', help='name to record this test with', required=True)
parser.add_argument('-e', '--executable', help='path to the game executable (should generally be a command-line build)', required=True)
parser.add_argument('-d', '--records-dir', help='directory of gameplay records to use', required=True)
parser.add_argument('-o', '--output', help='output file to append a CSV row to')
args = parser.parse_args()

title = args.name
binary = args.executable
test_dir = args.records_dir

benches = [os.path.join(test_dir, test) for test in os.listdir(test_dir) if test.endswith('.rec')]

sections = subprocess.check_output(['size', binary]).decode().strip().split('\n')[1].split()
text = int(sections[0]) // 1024
static_ram = (int(sections[1]) + int(sections[2])) // 1024

max_heap = 0
total_instructions = 0
total_cycles = 0

total_pass = 0
total_warn = 0
total_fail = 0
total_invalid = 0

print(f'Code size {text} KB, static RAM use {static_ram} KB')

for bench in benches:
    print(f'On {bench}...')
    output_lines = subprocess.check_output(['/usr/bin/time', '-f', '%M', 'perf', 'stat', '-j', binary, bench], stderr=subprocess.STDOUT).decode().strip().split('\n')

    # 1-2 lines to indicate logs, then results
    if output_lines[1].strip() == '':
        start = 2
    else:
        start = 1

    test_result = output_lines[start]
    mem_peak = int(output_lines[-1])
    stack_heap = mem_peak - (text + static_ram)

    if stack_heap > max_heap:
        max_heap = stack_heap


    for line in output_lines[start + 1:-1]:
        line_out = json.loads(line)

        if not 'event' in line_out:
            continue

        if line_out['event'] == 'cycles:u':
            cycles = int(float(line_out['counter-value']))
        elif line_out['event'] == 'instructions:u':
            instructions = int(float(line_out['counter-value']))

    total_instructions += instructions
    total_cycles += cycles

    if 'CONGRATULATIONS' in test_result:
        total_pass += 1
    elif 'MINOR' in test_result:
        total_warn += 1
    elif 'DIVERGED' in test_result:
        total_fail += 1
    else:
        total_invalid += 1

    print(f'  {test_result}')
    print(f'  Used {stack_heap} KB RAM')
    print(f'  Took {instructions} instructions ({cycles} cycles)')

# an output to be added to a CSV
template = 'title,pass,warn,fail,invalid,codesizeKB,staticmemKB,maxheapKB,Minstructions,Mcycles'
output_row = f'{title},{total_pass},{total_warn},{total_fail},{total_invalid},{text},{static_ram},{max_heap},{total_instructions // 1000000},{total_cycles // 1000000}'

if args.output:
    open(args.output, 'a').write(output_row+'\n')
else:
    print()
    print('    The template is:')
    print(template)
    print('    The next row should be:')
    print(output_row)


================================================
FILE: test/CMakeLists.txt
================================================

set(CMAKE_CXX_STANDARD 14)

add_library(test_common INTERFACE)
target_include_directories(test_common INTERFACE
    ${CMAKE_CURRENT_SOURCE_DIR}/common
    ${TheXTech_SOURCE_DIR}/include
    ${TheXTech_SOURCE_DIR}/src
)

add_subdirectory(test_msg_macro)

add_library(Catch-objects OBJECT "common/catch_amalgamated.cpp")
target_include_directories(Catch-objects PRIVATE "common")


================================================
FILE: test/common/catch_amalgamated.cpp
================================================

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0

//  Catch v3.9.0
//  Generated: 2025-07-24 22:00:25.173359
//  ----------------------------------------------------------
//  This file is an amalgamation of multiple different files.
//  You probably shouldn't edit it directly.
//  ----------------------------------------------------------

#include "catch_amalgamated.hpp"


#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED


#if defined(CATCH_PLATFORM_WINDOWS)

// We might end up with the define made globally through the compiler,
// and we don't want to trigger warnings for this
#if !defined(NOMINMAX)
#  define NOMINMAX
#endif
#if !defined(WIN32_LEAN_AND_MEAN)
#  define WIN32_LEAN_AND_MEAN
#endif

#include <windows.h>

#endif // defined(CATCH_PLATFORM_WINDOWS)

#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED




namespace Catch {
    namespace Benchmark {
        namespace Detail {
            ChronometerConcept::~ChronometerConcept() = default;
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch


// Adapted from donated nonius code.


#include <vector>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
                if (!cfg.benchmarkNoAnalysis()) {
                    std::vector<double> samples;
                    samples.reserve(static_cast<size_t>(last - first));
                    for (auto current = first; current != last; ++current) {
                        samples.push_back( current->count() );
                    }

                    auto analysis = Catch::Benchmark::Detail::analyse_samples(
                        cfg.benchmarkConfidenceInterval(),
                        cfg.benchmarkResamples(),
                        samples.data(),
                        samples.data() + samples.size() );
                    auto outliers = Catch::Benchmark::Detail::classify_outliers(
                        samples.data(), samples.data() + samples.size() );

                    auto wrap_estimate = [](Estimate<double> e) {
                        return Estimate<FDuration> {
                            FDuration(e.point),
                                FDuration(e.lower_bound),
                                FDuration(e.upper_bound),
                                e.confidence_interval,
                        };
                    };
                    std::vector<FDuration> samples2;
                    samples2.reserve(samples.size());
                    for (auto s : samples) {
                        samples2.push_back( FDuration( s ) );
                    }

                    return {
                        CATCH_MOVE(samples2),
                        wrap_estimate(analysis.mean),
                        wrap_estimate(analysis.standard_deviation),
                        outliers,
                        analysis.outlier_variance,
                    };
                } else {
                    std::vector<FDuration> samples;
                    samples.reserve(static_cast<size_t>(last - first));

                    FDuration mean = FDuration(0);
                    int i = 0;
                    for (auto it = first; it < last; ++it, ++i) {
                        samples.push_back(*it);
                        mean += *it;
                    }
                    mean /= i;

                    return SampleAnalysis{
                        CATCH_MOVE(samples),
                        Estimate<FDuration>{ mean, mean, mean, 0.0 },
                        Estimate<FDuration>{ FDuration( 0 ),
                                             FDuration( 0 ),
                                             FDuration( 0 ),
                                             0.0 },
                        OutlierClassification{},
                        0.0
                    };
                }
            }
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch




namespace Catch {
    namespace Benchmark {
        namespace Detail {
            struct do_nothing {
                void operator()() const {}
            };

            BenchmarkFunction::callable::~callable() = default;
            BenchmarkFunction::BenchmarkFunction():
                f( new model<do_nothing>{ {} } ){}
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch




#include <exception>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            struct optimized_away_error : std::exception {
                const char* what() const noexcept override;
            };

            const char* optimized_away_error::what() const noexcept {
                return "could not measure benchmark, maybe it was optimized away";
            }

            void throw_optimized_away_error() {
                Catch::throw_exception(optimized_away_error{});
            }

        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch


// Adapted from donated nonius code.



#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <numeric>
#include <random>


#if defined(CATCH_CONFIG_USE_ASYNC)
#include <future>
#endif

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            namespace {

                template <typename URng, typename Estimator>
                static sample
                resample( URng& rng,
                          unsigned int resamples,
                          double const* first,
                          double const* last,
                          Estimator& estimator ) {
                    auto n = static_cast<size_t>( last - first );
                    Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );

                    sample out;
                    out.reserve( resamples );
                    std::vector<double> resampled;
                    resampled.reserve( n );
                    for ( size_t i = 0; i < resamples; ++i ) {
                        resampled.clear();
                        for ( size_t s = 0; s < n; ++s ) {
                            resampled.push_back( first[dist( rng )] );
                        }
                        const auto estimate =
                            estimator( resampled.data(), resampled.data() + resampled.size() );
                        out.push_back( estimate );
                    }
                    std::sort( out.begin(), out.end() );
                    return out;
                }

                static double outlier_variance( Estimate<double> mean,
                                                Estimate<double> stddev,
                                                int n ) {
                    double sb = stddev.point;
                    double mn = mean.point / n;
                    double mg_min = mn / 2.;
                    double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
                    double sg2 = sg * sg;
                    double sb2 = sb * sb;

                    auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
                        double k = mn - x;
                        double d = k * k;
                        double nd = n * d;
                        double k0 = -n * nd;
                        double k1 = sb2 - n * sg2 + nd;
                        double det = k1 * k1 - 4 * sg2 * k0;
                        return static_cast<int>( -2. * k0 /
                                                 ( k1 + std::sqrt( det ) ) );
                    };

                    auto var_out = [n, sb2, sg2]( double c ) {
                        double nc = n - c;
                        return ( nc / n ) * ( sb2 - nc * sg2 );
                    };

                    return (std::min)( var_out( 1 ),
                                       var_out(
                                           (std::min)( c_max( 0. ),
                                                       c_max( mg_min ) ) ) ) /
                           sb2;
                }

                static double erf_inv( double x ) {
                    // Code accompanying the article "Approximating the erfinv
                    // function" in GPU Computing Gems, Volume 2
                    double w, p;

                    w = -log( ( 1.0 - x ) * ( 1.0 + x ) );

                    if ( w < 6.250000 ) {
                        w = w - 3.125000;
                        p = -3.6444120640178196996e-21;
                        p = -1.685059138182016589e-19 + p * w;
                        p = 1.2858480715256400167e-18 + p * w;
                        p = 1.115787767802518096e-17 + p * w;
                        p = -1.333171662854620906e-16 + p * w;
                        p = 2.0972767875968561637e-17 + p * w;
                        p = 6.6376381343583238325e-15 + p * w;
                        p = -4.0545662729752068639e-14 + p * w;
                        p = -8.1519341976054721522e-14 + p * w;
                        p = 2.6335093153082322977e-12 + p * w;
                        p = -1.2975133253453532498e-11 + p * w;
                        p = -5.4154120542946279317e-11 + p * w;
                        p = 1.051212273321532285e-09 + p * w;
                        p = -4.1126339803469836976e-09 + p * w;
                        p = -2.9070369957882005086e-08 + p * w;
                        p = 4.2347877827932403518e-07 + p * w;
                        p = -1.3654692000834678645e-06 + p * w;
                        p = -1.3882523362786468719e-05 + p * w;
                        p = 0.0001867342080340571352 + p * w;
                        p = -0.00074070253416626697512 + p * w;
                        p = -0.0060336708714301490533 + p * w;
                        p = 0.24015818242558961693 + p * w;
                        p = 1.6536545626831027356 + p * w;
                    } else if ( w < 16.000000 ) {
                        w = sqrt( w ) - 3.250000;
                        p = 2.2137376921775787049e-09;
                        p = 9.0756561938885390979e-08 + p * w;
                        p = -2.7517406297064545428e-07 + p * w;
                        p = 1.8239629214389227755e-08 + p * w;
                        p = 1.5027403968909827627e-06 + p * w;
                        p = -4.013867526981545969e-06 + p * w;
                        p = 2.9234449089955446044e-06 + p * w;
                        p = 1.2475304481671778723e-05 + p * w;
                        p = -4.7318229009055733981e-05 + p * w;
                        p = 6.8284851459573175448e-05 + p * w;
                        p = 2.4031110387097893999e-05 + p * w;
                        p = -0.0003550375203628474796 + p * w;
                        p = 0.00095328937973738049703 + p * w;
                        p = -0.0016882755560235047313 + p * w;
                        p = 0.0024914420961078508066 + p * w;
                        p = -0.0037512085075692412107 + p * w;
                        p = 0.005370914553590063617 + p * w;
                        p = 1.0052589676941592334 + p * w;
                        p = 3.0838856104922207635 + p * w;
                    } else {
                        w = sqrt( w ) - 5.000000;
                        p = -2.7109920616438573243e-11;
                        p = -2.5556418169965252055e-10 + p * w;
                        p = 1.5076572693500548083e-09 + p * w;
                        p = -3.7894654401267369937e-09 + p * w;
                        p = 7.6157012080783393804e-09 + p * w;
                        p = -1.4960026627149240478e-08 + p * w;
                        p = 2.9147953450901080826e-08 + p * w;
                        p = -6.7711997758452339498e-08 + p * w;
                        p = 2.2900482228026654717e-07 + p * w;
                        p = -9.9298272942317002539e-07 + p * w;
                        p = 4.5260625972231537039e-06 + p * w;
                        p = -1.9681778105531670567e-05 + p * w;
                        p = 7.5995277030017761139e-05 + p * w;
                        p = -0.00021503011930044477347 + p * w;
                        p = -0.00013871931833623122026 + p * w;
                        p = 1.0103004648645343977 + p * w;
                        p = 4.8499064014085844221 + p * w;
                    }
                    return p * x;
                }

                static double
                standard_deviation( double const* first, double const* last ) {
                    auto m = Catch::Benchmark::Detail::mean( first, last );
                    double variance =
                        std::accumulate( first,
                                         last,
                                         0.,
                                         [m]( double a, double b ) {
                                             double diff = b - m;
                                             return a + diff * diff;
                                         } ) /
                        static_cast<double>( last - first );
                    return std::sqrt( variance );
                }

                static sample jackknife( double ( *estimator )( double const*,
                                                                double const* ),
                                         double* first,
                                         double* last ) {
                    const auto second = first + 1;
                    sample results;
                    results.reserve( static_cast<size_t>( last - first ) );

                    for ( auto it = first; it != last; ++it ) {
                        std::iter_swap( it, first );
                        results.push_back( estimator( second, last ) );
                    }

                    return results;
                }


            } // namespace
        }     // namespace Detail
    }         // namespace Benchmark
} // namespace Catch

namespace Catch {
    namespace Benchmark {
        namespace Detail {

            double weighted_average_quantile( int k,
                                              int q,
                                              double* first,
                                              double* last ) {
                auto count = last - first;
                double idx = static_cast<double>((count - 1) * k) / static_cast<double>(q);
                int j = static_cast<int>(idx);
                double g = idx - j;
                std::nth_element(first, first + j, last);
                auto xj = first[j];
                if ( Catch::Detail::directCompare( g, 0 ) ) {
                    return xj;
                }

                auto xj1 = *std::min_element(first + (j + 1), last);
                return xj + g * (xj1 - xj);
            }

            OutlierClassification
            classify_outliers( double const* first, double const* last ) {
                std::vector<double> copy( first, last );

                auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() );
                auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() );
                auto iqr = q3 - q1;
                auto los = q1 - ( iqr * 3. );
                auto lom = q1 - ( iqr * 1.5 );
                auto him = q3 + ( iqr * 1.5 );
                auto his = q3 + ( iqr * 3. );

                OutlierClassification o;
                for ( ; first != last; ++first ) {
                    const double t = *first;
                    if ( t < los ) {
                        ++o.low_severe;
                    } else if ( t < lom ) {
                        ++o.low_mild;
                    } else if ( t > his ) {
                        ++o.high_severe;
                    } else if ( t > him ) {
                        ++o.high_mild;
                    }
                    ++o.samples_seen;
                }
                return o;
            }

            double mean( double const* first, double const* last ) {
                auto count = last - first;
                double sum = 0.;
                while (first != last) {
                    sum += *first;
                    ++first;
                }
                return sum / static_cast<double>(count);
            }

            double normal_cdf( double x ) {
                return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0;
            }

            double erfc_inv(double x) {
                return erf_inv(1.0 - x);
            }

            double normal_quantile(double p) {
                static const double ROOT_TWO = std::sqrt(2.0);

                double result = 0.0;
                assert(p >= 0 && p <= 1);
                if (p < 0 || p > 1) {
                    return result;
                }

                result = -erfc_inv(2.0 * p);
                // result *= normal distribution standard deviation (1.0) * sqrt(2)
                result *= /*sd * */ ROOT_TWO;
                // result += normal disttribution mean (0)
                return result;
            }

            Estimate<double>
            bootstrap( double confidence_level,
                       double* first,
                       double* last,
                       sample const& resample,
                       double ( *estimator )( double const*, double const* ) ) {
                auto n_samples = last - first;

                double point = estimator( first, last );
                // Degenerate case with a single sample
                if ( n_samples == 1 )
                    return { point, point, point, confidence_level };

                sample jack = jackknife( estimator, first, last );
                double jack_mean =
                    mean( jack.data(), jack.data() + jack.size() );
                double sum_squares = 0, sum_cubes = 0;
                for ( double x : jack ) {
                    auto difference = jack_mean - x;
                    auto square = difference * difference;
                    auto cube = square * difference;
                    sum_squares += square;
                    sum_cubes += cube;
                }

                double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
                long n = static_cast<long>( resample.size() );
                double prob_n = static_cast<double>(
                    std::count_if( resample.begin(),
                                   resample.end(),
                                   [point]( double x ) { return x < point; } )) /
                    static_cast<double>( n );
                // degenerate case with uniform samples
                if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
                    return { point, point, point, confidence_level };
                }

                double bias = normal_quantile( prob_n );
                double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );

                auto cumn = [n]( double x ) -> long {
                    return std::lround( normal_cdf( x ) *
                                        static_cast<double>( n ) );
                };
                auto a = [bias, accel]( double b ) {
                    return bias + b / ( 1. - accel * b );
                };
                double b1 = bias + z1;
                double b2 = bias - z1;
                double a1 = a( b1 );
                double a2 = a( b2 );
                auto lo = static_cast<size_t>( (std::max)( cumn( a1 ), 0l ) );
                auto hi =
                    static_cast<size_t>( (std::min)( cumn( a2 ), n - 1 ) );

                return { point, resample[lo], resample[hi], confidence_level };
            }

            bootstrap_analysis analyse_samples(double confidence_level,
                                               unsigned int n_resamples,
                                               double* first,
                                               double* last) {
                auto mean = &Detail::mean;
                auto stddev = &standard_deviation;

#if defined(CATCH_CONFIG_USE_ASYNC)
                auto Estimate = [=](double(*f)(double const*, double const*)) {
                    std::random_device rd;
                    auto seed = rd();
                    return std::async(std::launch::async, [=] {
                        SimplePcg32 rng( seed );
                        auto resampled = resample(rng, n_resamples, first, last, f);
                        return bootstrap(confidence_level, first, last, resampled, f);
                    });
                };

                auto mean_future = Estimate(mean);
                auto stddev_future = Estimate(stddev);

                auto mean_estimate = mean_future.get();
                auto stddev_estimate = stddev_future.get();
#else
                auto Estimate = [=](double(*f)(double const* , double const*)) {
                    std::random_device rd;
                    auto seed = rd();
                    SimplePcg32 rng( seed );
                    auto resampled = resample(rng, n_resamples, first, last, f);
                    return bootstrap(confidence_level, first, last, resampled, f);
                };

                auto mean_estimate = Estimate(mean);
                auto stddev_estimate = Estimate(stddev);
#endif // CATCH_USE_ASYNC

                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);

                return { mean_estimate, stddev_estimate, outlier_variance };
            }
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch



#include <cmath>
#include <limits>

namespace {

// Performs equivalent check of std::fabs(lhs - rhs) <= margin
// But without the subtraction to allow for INFINITY in comparison
bool marginComparison(double lhs, double rhs, double margin) {
    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
}

}

namespace Catch {

    Approx::Approx ( double value )
    :   m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
        m_margin( 0.0 ),
        m_scale( 0.0 ),
        m_value( value )
    {}

    Approx Approx::custom() {
        return Approx( 0 );
    }

    Approx Approx::operator-() const {
        auto temp(*this);
        temp.m_value = -temp.m_value;
        return temp;
    }


    std::string Approx::toString() const {
        ReusableStringStream rss;
        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
        return rss.str();
    }

    bool Approx::equalityComparisonImpl(const double other) const {
        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
        // Thanks to Richard Harris for his help refining the scaled margin value
        return marginComparison(m_value, other, m_margin)
            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
    }

    void Approx::setMargin(double newMargin) {
        CATCH_ENFORCE(newMargin >= 0,
            "Invalid Approx::margin: " << newMargin << '.'
            << " Approx::Margin has to be non-negative.");
        m_margin = newMargin;
    }

    void Approx::setEpsilon(double newEpsilon) {
        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
            "Invalid Approx::epsilon: " << newEpsilon << '.'
            << " Approx::epsilon has to be in [0, 1]");
        m_epsilon = newEpsilon;
    }

namespace literals {
    Approx operator ""_a(long double val) {
        return Approx(val);
    }
    Approx operator ""_a(unsigned long long val) {
        return Approx(val);
    }
} // end namespace literals

std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
    return value.toString();
}

} // end namespace Catch



namespace Catch {

    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression):
        lazyExpression(_lazyExpression),
        resultType(_resultType) {}

    std::string AssertionResultData::reconstructExpression() const {

        if( reconstructedExpression.empty() ) {
            if( lazyExpression ) {
                ReusableStringStream rss;
                rss << lazyExpression;
                reconstructedExpression = rss.str();
            }
        }
        return reconstructedExpression;
    }

    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
    :   m_info( info ),
        m_resultData( CATCH_MOVE(data) )
    {}

    // Result was a success
    bool AssertionResult::succeeded() const {
        return Catch::isOk( m_resultData.resultType );
    }

    // Result was a success, or failure is suppressed
    bool AssertionResult::isOk() const {
        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
    }

    ResultWas::OfType AssertionResult::getResultType() const {
        return m_resultData.resultType;
    }

    bool AssertionResult::hasExpression() const {
        return !m_info.capturedExpression.empty();
    }

    bool AssertionResult::hasMessage() const {
        return !m_resultData.message.empty();
    }

    std::string AssertionResult::getExpression() const {
        // Possibly overallocating by 3 characters should be basically free
        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
        if (isFalseTest(m_info.resultDisposition)) {
            expr += "!(";
        }
        expr += m_info.capturedExpression;
        if (isFalseTest(m_info.resultDisposition)) {
            expr += ')';
        }
        return expr;
    }

    std::string AssertionResult::getExpressionInMacro() const {
        if ( m_info.macroName.empty() ) {
            return static_cast<std::string>( m_info.capturedExpression );
        }
        std::string expr;
        expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
        expr += m_info.macroName;
        expr += "( ";
        expr += m_info.capturedExpression;
        expr += " )";
        return expr;
    }

    bool AssertionResult::hasExpandedExpression() const {
        return hasExpression() && getExpandedExpression() != getExpression();
    }

    std::string AssertionResult::getExpandedExpression() const {
        std::string expr = m_resultData.reconstructExpression();
        return expr.empty()
                ? getExpression()
                : expr;
    }

    StringRef AssertionResult::getMessage() const {
        return m_resultData.message;
    }
    SourceLineInfo AssertionResult::getSourceInfo() const {
        return m_info.lineInfo;
    }

    StringRef AssertionResult::getTestMacroName() const {
        return m_info.macroName;
    }

} // end namespace Catch



#include <fstream>

namespace Catch {

    namespace {
        static bool enableBazelEnvSupport() {
#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
            return true;
#else
            return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
#endif
        }

        struct bazelShardingOptions {
            unsigned int shardIndex, shardCount;
            std::string shardFilePath;
        };

        static Optional<bazelShardingOptions> readBazelShardingOptions() {
            const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
            const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
            const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );


            const bool has_all =
                bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
            if ( !has_all ) {
                // We provide nice warning message if the input is
                // misconfigured.
                auto warn = []( const char* env_var ) {
                    Catch::cerr()
                        << "Warning: Bazel shard configuration is missing '"
                        << env_var << "'. Shard configuration is skipped.\n";
                };
                if ( !bazelShardIndex ) {
                    warn( "TEST_SHARD_INDEX" );
                }
                if ( !bazelShardTotal ) {
                    warn( "TEST_TOTAL_SHARDS" );
                }
                if ( !bazelShardInfoFile ) {
                    warn( "TEST_SHARD_STATUS_FILE" );
                }
                return {};
            }

            auto shardIndex = parseUInt( bazelShardIndex );
            if ( !shardIndex ) {
                Catch::cerr()
                    << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
                    << "') as unsigned int.\n";
                return {};
            }
            auto shardTotal = parseUInt( bazelShardTotal );
            if ( !shardTotal ) {
                Catch::cerr()
                    << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
                    << bazelShardTotal << "') as unsigned int.\n";
                return {};
            }

            return bazelShardingOptions{
                *shardIndex, *shardTotal, bazelShardInfoFile };

        }
    } // end namespace


    bool operator==( ProcessedReporterSpec const& lhs,
                     ProcessedReporterSpec const& rhs ) {
        return lhs.name == rhs.name &&
               lhs.outputFilename == rhs.outputFilename &&
               lhs.colourMode == rhs.colourMode &&
               lhs.customOptions == rhs.customOptions;
    }

    Config::Config( ConfigData const& data ):
        m_data( data ) {
        // We need to trim filter specs to avoid trouble with superfluous
        // whitespace (esp. important for bdd macros, as those are manually
        // aligned with whitespace).

        for (auto& elem : m_data.testsOrTags) {
            elem = trim(elem);
        }
        for (auto& elem : m_data.sectionsToRun) {
            elem = trim(elem);
        }

        // Insert the default reporter if user hasn't asked for a specific one
        if ( m_data.reporterSpecifications.empty() ) {
#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
            const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;
#else
            const auto default_spec = "console";
#endif
            auto parsed = parseReporterSpec(default_spec);
            CATCH_ENFORCE( parsed,
                           "Cannot parse the provided default reporter spec: '"
                               << default_spec << '\'' );
            m_data.reporterSpecifications.push_back( std::move( *parsed ) );
        }

        if ( enableBazelEnvSupport() ) {
            readBazelEnvVars();
        }

        // Bazel support can modify the test specs, so parsing has to happen
        // after reading Bazel env vars.
        TestSpecParser parser( ITagAliasRegistry::get() );
        if ( !m_data.testsOrTags.empty() ) {
            m_hasTestFilters = true;
            for ( auto const& testOrTags : m_data.testsOrTags ) {
                parser.parse( testOrTags );
            }
        }
        m_testSpec = parser.testSpec();


        // We now fixup the reporter specs to handle default output spec,
        // default colour spec, etc
        bool defaultOutputUsed = false;
        for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
            // We do the default-output check separately, while always
            // using the default output below to make the code simpler
            // and avoid superfluous copies.
            if ( reporterSpec.outputFile().none() ) {
                CATCH_ENFORCE( !defaultOutputUsed,
                               "Internal error: cannot use default output for "
                               "multiple reporters" );
                defaultOutputUsed = true;
            }

            m_processedReporterSpecs.push_back( ProcessedReporterSpec{
                reporterSpec.name(),
                reporterSpec.outputFile() ? *reporterSpec.outputFile()
                                          : data.defaultOutputFilename,
                reporterSpec.colourMode().valueOr( data.defaultColourMode ),
                reporterSpec.customOptions() } );
        }
    }

    Config::~Config() = default;


    bool Config::listTests() const          { return m_data.listTests; }
    bool Config::listTags() const           { return m_data.listTags; }
    bool Config::listReporters() const      { return m_data.listReporters; }
    bool Config::listListeners() const      { return m_data.listListeners; }

    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }

    std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
        return m_data.reporterSpecifications;
    }

    std::vector<ProcessedReporterSpec> const&
    Config::getProcessedReporterSpecs() const {
        return m_processedReporterSpecs;
    }

    TestSpec const& Config::testSpec() const { return m_testSpec; }
    bool Config::hasTestFilters() const { return m_hasTestFilters; }

    bool Config::showHelp() const { return m_data.showHelp; }

    // IConfig interface
    bool Config::allowThrows() const                   { return !m_data.noThrow; }
    StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
    bool Config::warnAboutMissingAssertions() const {
        return !!( m_data.warnings & WarnAbout::NoAssertions );
    }
    bool Config::warnAboutUnmatchedTestSpecs() const {
        return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
    }
    bool Config::zeroTestsCountAsSuccess() const       { return m_data.allowZeroTests; }
    ShowDurations Config::showDurations() const        { return m_data.showDurations; }
    double Config::minDuration() const                 { return m_data.minDuration; }
    TestRunOrder Config::runOrder() const              { return m_data.runOrder; }
    uint32_t Config::rngSeed() const                   { return m_data.rngSeed; }
    unsigned int Config::shardCount() const            { return m_data.shardCount; }
    unsigned int Config::shardIndex() const            { return m_data.shardIndex; }
    ColourMode Config::defaultColourMode() const       { return m_data.defaultColourMode; }
    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
    int Config::abortAfter() const                     { return m_data.abortAfter; }
    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
    Verbosity Config::verbosity() const                { return m_data.verbosity; }

    bool Config::skipBenchmarks() const                           { return m_data.skipBenchmarks; }
    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
    unsigned int Config::benchmarkSamples() const                 { return m_data.benchmarkSamples; }
    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }

    void Config::readBazelEnvVars() {
        // Register a JUnit reporter for Bazel. Bazel sets an environment
        // variable with the path to XML output. If this file is written to
        // during test, Bazel will not generate a default XML output.
        // This allows the XML output file to contain higher level of detail
        // than what is possible otherwise.
        const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );

        if ( bazelOutputFile ) {
            m_data.reporterSpecifications.push_back(
                { "junit", std::string( bazelOutputFile ), {}, {} } );
        }

        const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
        if ( bazelTestSpec ) {
            // Presumably the test spec from environment should overwrite
            // the one we got from CLI (if we got any)
            m_data.testsOrTags.clear();
            m_data.testsOrTags.push_back( bazelTestSpec );
        }

        const auto bazelShardOptions = readBazelShardingOptions();
        if ( bazelShardOptions ) {
            std::ofstream f( bazelShardOptions->shardFilePath,
                             std::ios_base::out | std::ios_base::trunc );
            if ( f.is_open() ) {
                f << "";
                m_data.shardIndex = bazelShardOptions->shardIndex;
                m_data.shardCount = bazelShardOptions->shardCount;
            }
        }
    }

} // end namespace Catch





namespace Catch {
    std::uint32_t getSeed() {
        return getCurrentContext().getConfig()->rngSeed();
    }
}



#include <cassert>
#include <stack>

namespace Catch {

    ////////////////////////////////////////////////////////////////////////////


    ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
        m_info( CATCH_MOVE(builder.m_info) ) {
        m_info.message = builder.m_stream.str();
        getResultCapture().pushScopedMessage( m_info );
    }

    ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
        m_info( CATCH_MOVE( old.m_info ) ) {
        old.m_moved = true;
    }

    ScopedMessage::~ScopedMessage() {
        if ( !m_moved ){
            getResultCapture().popScopedMessage(m_info);
        }
    }


    Capturer::Capturer( StringRef macroName,
                        SourceLineInfo const& lineInfo,
                        ResultWas::OfType resultType,
                        StringRef names ):
        m_resultCapture( getResultCapture() ) {
        auto trimmed = [&] (size_t start, size_t end) {
            while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
                ++start;
            }
            while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
                --end;
            }
            return names.substr(start, end - start + 1);
        };
        auto skipq = [&] (size_t start, char quote) {
            for (auto i = start + 1; i < names.size() ; ++i) {
                if (names[i] == quote)
                    return i;
                if (names[i] == '\\')
                    ++i;
            }
            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
        };

        size_t start = 0;
        std::stack<char> openings;
        for (size_t pos = 0; pos < names.size(); ++pos) {
            char c = names[pos];
            switch (c) {
            case '[':
            case '{':
            case '(':
            // It is basically impossible to disambiguate between
            // comparison and start of template args in this context
//            case '<':
                openings.push(c);
                break;
            case ']':
            case '}':
            case ')':
//           case '>':
                openings.pop();
                break;
            case '"':
            case '\'':
                pos = skipq(pos, c);
                break;
            case ',':
                if (start != pos && openings.empty()) {
                    m_messages.emplace_back(macroName, lineInfo, resultType);
                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
                    m_messages.back().message += " := ";
                    start = pos;
                }
                break;
            default:; // noop
            }
        }
        assert(openings.empty() && "Mismatched openings");
        m_messages.emplace_back(macroName, lineInfo, resultType);
        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
        m_messages.back().message += " := ";
    }
    Capturer::~Capturer() {
        assert( m_captured == m_messages.size() );
        for ( size_t i = 0; i < m_captured; ++i )
            m_resultCapture.popScopedMessage( m_messages[i] );
    }

    void Capturer::captureValue( size_t index, std::string const& value ) {
        assert( index < m_messages.size() );
        m_messages[index].message += value;
        m_resultCapture.pushScopedMessage( m_messages[index] );
        m_captured++;
    }

} // end namespace Catch




#include <exception>

namespace Catch {

    namespace {

        class RegistryHub : public IRegistryHub,
                            public IMutableRegistryHub,
                            private Detail::NonCopyable {

        public: // IRegistryHub
            RegistryHub() = default;
            ReporterRegistry const& getReporterRegistry() const override {
                return m_reporterRegistry;
            }
            ITestCaseRegistry const& getTestCaseRegistry() const override {
                return m_testCaseRegistry;
            }
            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
                return m_exceptionTranslatorRegistry;
            }
            ITagAliasRegistry const& getTagAliasRegistry() const override {
                return m_tagAliasRegistry;
            }
            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
                return m_exceptionRegistry;
            }

        public: // IMutableRegistryHub
            void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
                m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
            }
            void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
                m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
            }
            void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
                m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
            }
            void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
                m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
            }
            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
                m_tagAliasRegistry.add( alias, tag, lineInfo );
            }
            void registerStartupException() noexcept override {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
                m_exceptionRegistry.add(std::current_exception());
#else
                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
#endif
            }
            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
                return m_enumValuesRegistry;
            }

        private:
            TestRegistry m_testCaseRegistry;
            ReporterRegistry m_reporterRegistry;
            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
            TagAliasRegistry m_tagAliasRegistry;
            StartupExceptionRegistry m_exceptionRegistry;
            Detail::EnumValuesRegistry m_enumValuesRegistry;
        };
    }

    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;

    IRegistryHub const& getRegistryHub() {
        return RegistryHubSingleton::get();
    }
    IMutableRegistryHub& getMutableRegistryHub() {
        return RegistryHubSingleton::getMutable();
    }
    void cleanUp() {
        cleanupSingletons();
        cleanUpContext();
    }
    std::string translateActiveException() {
        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
    }


} // end namespace Catch



#include <cassert>
#include <exception>
#include <iomanip>
#include <set>

namespace Catch {

    namespace {
        IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');

            return reporter;
        }

        IEventListenerPtr prepareReporters(Config const* config) {
            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
                    && config->getProcessedReporterSpecs().size() == 1) {
                auto const& spec = config->getProcessedReporterSpecs()[0];
                return createReporter(
                    spec.name,
                    ReporterConfig( config,
                                    makeStream( spec.outputFilename ),
                                    spec.colourMode,
                                    spec.customOptions ) );
            }

            auto multi = Detail::make_unique<MultiReporter>(config);

            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
            for (auto const& listener : listeners) {
                multi->addListener(listener->create(config));
            }

            for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
                multi->addReporter( createReporter(
                    reporterSpec.name,
                    ReporterConfig( config,
                                    makeStream( reporterSpec.outputFilename ),
                                    reporterSpec.colourMode,
                                    reporterSpec.customOptions ) ) );
            }

            return multi;
        }

        class TestGroup {
        public:
            explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
                m_reporter(reporter.get()),
                m_config{config},
                m_context{config, CATCH_MOVE(reporter)} {

                assert( m_config->testSpec().getInvalidSpecs().empty() &&
                        "Invalid test specs should be handled before running tests" );

                auto const& allTestCases = getAllTestCasesSorted(*m_config);
                auto const& testSpec = m_config->testSpec();
                if ( !testSpec.hasFilters() ) {
                    for ( auto const& test : allTestCases ) {
                        if ( !test.getTestCaseInfo().isHidden() ) {
                            m_tests.emplace( &test );
                        }
                    }
                } else {
                    m_matches =
                        testSpec.matchesByFilter( allTestCases, *m_config );
                    for ( auto const& match : m_matches ) {
                        m_tests.insert( match.tests.begin(),
                                        match.tests.end() );
                    }
                }

                m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
            }

            Totals execute() {
                Totals totals;
                for (auto const& testCase : m_tests) {
                    if (!m_context.aborting())
                        totals += m_context.runTest(*testCase);
                    else
                        m_reporter->skipTest(testCase->getTestCaseInfo());
                }

                for (auto const& match : m_matches) {
                    if (match.tests.empty()) {
                        m_unmatchedTestSpecs = true;
                        m_reporter->noMatchingTestCases( match.name );
                    }
                }

                return totals;
            }

            bool hadUnmatchedTestSpecs() const {
                return m_unmatchedTestSpecs;
            }


        private:
            IEventListener* m_reporter;
            Config const* m_config;
            RunContext m_context;
            std::set<TestCaseHandle const*> m_tests;
            TestSpec::Matches m_matches;
            bool m_unmatchedTestSpecs = false;
        };

        void applyFilenamesAsTags() {
            for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
                testInfo->addFilenameTag();
            }
        }

    } // anon namespace

    Session::Session() {
        static bool alreadyInstantiated = false;
        if( alreadyInstantiated ) {
            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
        }

        // There cannot be exceptions at startup in no-exception mode.
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
        if ( !exceptions.empty() ) {
            config();
            getCurrentMutableContext().setConfig(m_config.get());

            m_startupExceptions = true;
            auto errStream = makeStream( "%stderr" );
            auto colourImpl = makeColourImpl(
                ColourMode::PlatformDefault, errStream.get() );
            auto guard = colourImpl->guardColour( Colour::Red );
            errStream->stream() << "Errors occurred during startup!" << '\n';
            // iterate over all exceptions and notify user
            for ( const auto& ex_ptr : exceptions ) {
                try {
                    std::rethrow_exception(ex_ptr);
                } catch ( std::exception const& ex ) {
                    errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
                }
            }
        }
#endif

        alreadyInstantiated = true;
        m_cli = makeCommandLineParser( m_configData );
    }
    Session::~Session() {
        Catch::cleanUp();
    }

    void Session::showHelp() const {
        Catch::cout()
                << "\nCatch2 v" << libraryVersion() << '\n'
                << m_cli << '\n'
                << "For more detailed usage please see the project docs\n\n" << std::flush;
    }
    void Session::libIdentify() {
        Catch::cout()
                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
                << std::left << std::setw(16) << "category: " << "testframework\n"
                << std::left << std::setw(16) << "framework: " << "Catch2\n"
                << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
    }

    int Session::applyCommandLine( int argc, char const * const * argv ) {
        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }

        auto result = m_cli.parse( Clara::Args( argc, argv ) );

        if( !result ) {
            config();
            getCurrentMutableContext().setConfig(m_config.get());
            auto errStream = makeStream( "%stderr" );
            auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );

            errStream->stream()
                << colour->guardColour( Colour::Red )
                << "\nError(s) in input:\n"
                << TextFlow::Column( result.errorMessage() ).indent( 2 )
                << "\n\n";
            errStream->stream() << "Run with -? for usage\n\n" << std::flush;
            return UnspecifiedErrorExitCode;
        }

        if( m_configData.showHelp )
            showHelp();
        if( m_configData.libIdentify )
            libIdentify();

        m_config.reset();
        return 0;
    }

#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {

        char **utf8Argv = new char *[ argc ];

        for ( int i = 0; i < argc; ++i ) {
            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );

            utf8Argv[ i ] = new char[ bufSize ];

            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
        }

        int returnCode = applyCommandLine( argc, utf8Argv );

        for ( int i = 0; i < argc; ++i )
            delete [] utf8Argv[ i ];

        delete [] utf8Argv;

        return returnCode;
    }
#endif

    void Session::useConfigData( ConfigData const& configData ) {
        m_configData = configData;
        m_config.reset();
    }

    int Session::run() {
        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
            Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
            static_cast<void>(std::getchar());
        }
        int exitCode = runInternal();
        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush;
            static_cast<void>(std::getchar());
        }
        return exitCode;
    }

    Clara::Parser const& Session::cli() const {
        return m_cli;
    }
    void Session::cli( Clara::Parser const& newParser ) {
        m_cli = newParser;
    }
    ConfigData& Session::configData() {
        return m_configData;
    }
    Config& Session::config() {
        if( !m_config )
            m_config = Detail::make_unique<Config>( m_configData );
        return *m_config;
    }

    int Session::runInternal() {
        if ( m_startupExceptions ) { return UnspecifiedErrorExitCode; }

        if (m_configData.showHelp || m_configData.libIdentify) {
            return 0;
        }

        if ( m_configData.shardIndex >= m_configData.shardCount ) {
            Catch::cerr() << "The shard count (" << m_configData.shardCount
                          << ") must be greater than the shard index ("
                          << m_configData.shardIndex << ")\n"
                          << std::flush;
            return UnspecifiedErrorExitCode;
        }

        CATCH_TRY {
            config(); // Force config to be constructed

            seedRng( *m_config );

            if (m_configData.filenamesAsTags) {
                applyFilenamesAsTags();
            }

            // Set up global config instance before we start calling into other functions
            getCurrentMutableContext().setConfig(m_config.get());

            // Create reporter(s) so we can route listings through them
            auto reporter = prepareReporters(m_config.get());

            auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
            if ( !invalidSpecs.empty() ) {
                for ( auto const& spec : invalidSpecs ) {
                    reporter->reportInvalidTestSpec( spec );
                }
                return InvalidTestSpecExitCode;
            }


            // Handle list request
            if (list(*reporter, *m_config)) {
                return 0;
            }

            TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
            auto const totals = tests.execute();

            if ( tests.hadUnmatchedTestSpecs()
                && m_config->warnAboutUnmatchedTestSpecs() ) {
                // UnmatchedTestSpecExitCode
                return UnmatchedTestSpecExitCode;
            }

            if ( totals.testCases.total() == 0
                && !m_config->zeroTestsCountAsSuccess() ) {
                return NoTestsRunExitCode;
            }

            if ( totals.testCases.total() > 0 &&
                 totals.testCases.total() == totals.testCases.skipped
                && !m_config->zeroTestsCountAsSuccess() ) {
                return AllTestsSkippedExitCode;
            }

            if ( totals.assertions.failed ) { return TestFailureExitCode; }
            return 0;

        }
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
            return UnspecifiedErrorExitCode;
        }
#endif
    }

} // end namespace Catch




namespace Catch {

    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
        CATCH_TRY {
            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
        } CATCH_CATCH_ALL {
            // Do not throw when constructing global objects, instead register the exception to be processed later
            getMutableRegistryHub().registerStartupException();
        }
    }

}



#include <cassert>
#include <cctype>
#include <algorithm>

namespace Catch {

    namespace {
        using TCP_underlying_type = uint8_t;
        static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
                      "The size of the TestCaseProperties is different from the assumed size");

        constexpr TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
            return static_cast<TestCaseProperties>(
                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
            );
        }

        constexpr TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
            lhs = static_cast<TestCaseProperties>(
                static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
            );
            return lhs;
        }

        constexpr TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
            return static_cast<TestCaseProperties>(
                static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
            );
        }

        constexpr bool applies(TestCaseProperties tcp) {
            static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
                          "TestCaseProperties::None must be equal to 0");
            return tcp != TestCaseProperties::None;
        }

        TestCaseProperties parseSpecialTag( StringRef tag ) {
            if( !tag.empty() && tag[0] == '.' )
                return TestCaseProperties::IsHidden;
            else if( tag == "!throws"_sr )
                return TestCaseProperties::Throws;
            else if( tag == "!shouldfail"_sr )
                return TestCaseProperties::ShouldFail;
            else if( tag == "!mayfail"_sr )
                return TestCaseProperties::MayFail;
            else if( tag == "!nonportable"_sr )
                return TestCaseProperties::NonPortable;
            else if( tag == "!benchmark"_sr )
                return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
            else
                return TestCaseProperties::None;
        }
        bool isReservedTag( StringRef tag ) {
            return parseSpecialTag( tag ) == TestCaseProperties::None
                && tag.size() > 0
                && !std::isalnum( static_cast<unsigned char>(tag[0]) );
        }
        void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
            CATCH_ENFORCE( !isReservedTag(tag),
                          "Tag name: [" << tag << "] is not allowed.\n"
                          << "Tag names starting with non alphanumeric characters are reserved\n"
                          << _lineInfo );
        }

        std::string makeDefaultName() {
            static size_t counter = 0;
            return "Anonymous test case " + std::to_string(++counter);
        }

        constexpr StringRef extractFilenamePart(StringRef filename) {
            size_t lastDot = filename.size();
            while (lastDot > 0 && filename[lastDot - 1] != '.') {
                --lastDot;
            }
            // In theory we could have filename without any extension in it
            if ( lastDot == 0 ) { return StringRef(); }

            --lastDot;
            size_t nameStart = lastDot;
            while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
                --nameStart;
            }

            return filename.substr(nameStart, lastDot - nameStart);
        }

        // Returns the upper bound on size of extra tags ([#file]+[.])
        constexpr size_t sizeOfExtraTags(StringRef filepath) {
            // [.] is 3, [#] is another 3
            const size_t extras = 3 + 3;
            return extractFilenamePart(filepath).size() + extras;
        }
    } // end unnamed namespace

    bool operator<(  Tag const& lhs, Tag const& rhs ) {
        Detail::CaseInsensitiveLess cmp;
        return cmp( lhs.original, rhs.original );
    }
    bool operator==( Tag const& lhs, Tag const& rhs ) {
        Detail::CaseInsensitiveEqualTo cmp;
        return cmp( lhs.original, rhs.original );
    }

    Detail::unique_ptr<TestCaseInfo>
        makeTestCaseInfo(StringRef _className,
                         NameAndTags const& nameAndTags,
                         SourceLineInfo const& _lineInfo ) {
        return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
    }

    TestCaseInfo::TestCaseInfo(StringRef _className,
                               NameAndTags const& _nameAndTags,
                               SourceLineInfo const& _lineInfo):
        name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
        className( _className ),
        lineInfo( _lineInfo )
    {
        StringRef originalTags = _nameAndTags.tags;
        // We need to reserve enough space to store all of the tags
        // (including optional hidden tag and filename tag)
        auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
        backingTags.reserve(requiredSize);

        // We cannot copy the tags directly, as we need to normalize
        // some tags, so that [.foo] is copied as [.][foo].
        size_t tagStart = 0;
        size_t tagEnd = 0;
        bool inTag = false;
        for (size_t idx = 0; idx < originalTags.size(); ++idx) {
            auto c = originalTags[idx];
            if (c == '[') {
                CATCH_ENFORCE(
                    !inTag,
                    "Found '[' inside a tag while registering test case '"
                        << _nameAndTags.name << "' at " << _lineInfo );

                inTag = true;
                tagStart = idx;
            }
            if (c == ']') {
                CATCH_ENFORCE(
                    inTag,
                    "Found unmatched ']' while registering test case '"
                        << _nameAndTags.name << "' at " << _lineInfo );

                inTag = false;
                tagEnd = idx;
                assert(tagStart < tagEnd);

                // We need to check the tag for special meanings, copy
                // it over to backing storage and actually reference the
                // backing storage in the saved tags
                StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
                CATCH_ENFORCE( !tagStr.empty(),
                               "Found an empty tag while registering test case '"
                                   << _nameAndTags.name << "' at "
                                   << _lineInfo );

                enforceNotReservedTag(tagStr, lineInfo);
                properties |= parseSpecialTag(tagStr);
                // When copying a tag to the backing storage, we need to
                // check if it is a merged hide tag, such as [.foo], and
                // if it is, we need to handle it as if it was [foo].
                if (tagStr.size() > 1 && tagStr[0] == '.') {
                    tagStr = tagStr.substr(1, tagStr.size() - 1);
                }
                // We skip over dealing with the [.] tag, as we will add
                // it later unconditionally and then sort and unique all
                // the tags.
                internalAppendTag(tagStr);
            }
        }
        CATCH_ENFORCE( !inTag,
                       "Found an unclosed tag while registering test case '"
                           << _nameAndTags.name << "' at " << _lineInfo );


        // Add [.] if relevant
        if (isHidden()) {
            internalAppendTag("."_sr);
        }

        // Sort and prepare tags
        std::sort(begin(tags), end(tags));
        tags.erase(std::unique(begin(tags), end(tags)),
                   end(tags));
    }

    bool TestCaseInfo::isHidden() const {
        return applies( properties & TestCaseProperties::IsHidden );
    }
    bool TestCaseInfo::throws() const {
        return applies( properties & TestCaseProperties::Throws );
    }
    bool TestCaseInfo::okToFail() const {
        return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
    }
    bool TestCaseInfo::expectedToFail() const {
        return applies( properties & (TestCaseProperties::ShouldFail) );
    }

    void TestCaseInfo::addFilenameTag() {
        std::string combined("#");
        combined += extractFilenamePart(lineInfo.file);
        internalAppendTag(combined);
    }

    std::string TestCaseInfo::tagsAsString() const {
        std::string ret;
        // '[' and ']' per tag
        std::size_t full_size = 2 * tags.size();
        for (const auto& tag : tags) {
            full_size += tag.original.size();
        }
        ret.reserve(full_size);
        for (const auto& tag : tags) {
            ret.push_back('[');
            ret += tag.original;
            ret.push_back(']');
        }

        return ret;
    }

    void TestCaseInfo::internalAppendTag(StringRef tagStr) {
        backingTags += '[';
        const auto backingStart = backingTags.size();
        backingTags += tagStr;
        const auto backingEnd = backingTags.size();
        backingTags += ']';
        tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
    }

    bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
        // We want to avoid redoing the string comparisons multiple times,
        // so we store the result of a three-way comparison before using
        // it in the actual comparison logic.
        const auto cmpName = lhs.name.compare( rhs.name );
        if ( cmpName != 0 ) {
            return cmpName < 0;
        }
        const auto cmpClassName = lhs.className.compare( rhs.className );
        if ( cmpClassName != 0 ) {
            return cmpClassName < 0;
        }
        return lhs.tags < rhs.tags;
    }

} // end namespace Catch



#include <algorithm>
#include <string>
#include <vector>
#include <ostream>

namespace Catch {

    TestSpec::Pattern::Pattern( std::string const& name )
    : m_name( name )
    {}

    TestSpec::Pattern::~Pattern() = default;

    std::string const& TestSpec::Pattern::name() const {
        return m_name;
    }


    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
    : Pattern( filterString )
    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
    {}

    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
        return m_wildcardPattern.matches( testCase.name );
    }

    void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
        out << '"' << name() << '"';
    }


    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
    : Pattern( filterString )
    , m_tag( tag )
    {}

    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
        return std::find( begin( testCase.tags ),
                          end( testCase.tags ),
                          Tag( m_tag ) ) != end( testCase.tags );
    }

    void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
        out << name();
    }

    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
        bool should_use = !testCase.isHidden();
        for (auto const& pattern : m_required) {
            should_use = true;
            if (!pattern->matches(testCase)) {
                return false;
            }
        }
        for (auto const& pattern : m_forbidden) {
            if (pattern->matches(testCase)) {
                return false;
            }
        }
        return should_use;
    }

    void TestSpec::Filter::serializeTo( std::ostream& out ) const {
        bool first = true;
        for ( auto const& pattern : m_required ) {
            if ( !first ) {
                out << ' ';
            }
            out << *pattern;
            first = false;
        }
        for ( auto const& pattern : m_forbidden ) {
            if ( !first ) {
                out << ' ';
            }
            out << *pattern;
            first = false;
        }
    }


    std::string TestSpec::extractFilterName( Filter const& filter ) {
        Catch::ReusableStringStream sstr;
        sstr << filter;
        return sstr.str();
    }

    bool TestSpec::hasFilters() const {
        return !m_filters.empty();
    }

    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
    }

    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
        Matches matches;
        matches.reserve( m_filters.size() );
        for ( auto const& filter : m_filters ) {
            std::vector<TestCaseHandle const*> currentMatches;
            for ( auto const& test : testCases )
                if ( isThrowSafe( test, config ) &&
                     filter.matches( test.getTestCaseInfo() ) )
                    currentMatches.emplace_back( &test );
            matches.push_back(
                FilterMatch{ extractFilterName( filter ), currentMatches } );
        }
        return matches;
    }

    const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
        return m_invalidSpecs;
    }

    void TestSpec::serializeTo( std::ostream& out ) const {
        bool first = true;
        for ( auto const& filter : m_filters ) {
            if ( !first ) {
                out << ',';
            }
            out << filter;
            first = false;
        }
    }

}



#include <chrono>

namespace Catch {

    namespace {
        static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
        }
    } // end unnamed namespace

    void Timer::start() {
       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
    }
    auto Timer::getElapsedNanoseconds() const -> uint64_t {
        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
    }
    auto Timer::getElapsedMicroseconds() const -> uint64_t {
        return getElapsedNanoseconds()/1000;
    }
    auto Timer::getElapsedMilliseconds() const -> unsigned int {
        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
    }
    auto Timer::getElapsedSeconds() const -> double {
        return static_cast<double>(getElapsedMicroseconds())/1000000.0;
    }


} // namespace Catch




#include <iomanip>

namespace Catch {

namespace Detail {

    namespace {
        const int hexThreshold = 255;

        struct Endianness {
            enum Arch : uint8_t {
                Big,
                Little
            };

            static Arch which() {
                int one = 1;
                // If the lowest byte we read is non-zero, we can assume
                // that little endian format is used.
                auto value = *reinterpret_cast<char*>(&one);
                return value ? Little : Big;
            }
        };

        template<typename T>
        std::string fpToString(T value, int precision) {
            if (Catch::isnan(value)) {
                return "nan";
            }

            ReusableStringStream rss;
            rss << std::setprecision(precision)
                << std::fixed
                << value;
            std::string d = rss.str();
            std::size_t i = d.find_last_not_of('0');
            if (i != std::string::npos && i != d.size() - 1) {
                if (d[i] == '.')
                    i++;
                d = d.substr(0, i + 1);
            }
            return d;
        }
    } // end unnamed namespace

    std::string convertIntoString(StringRef string, bool escapeInvisibles) {
        std::string ret;
        // This is enough for the "don't escape invisibles" case, and a good
        // lower bound on the "escape invisibles" case.
        ret.reserve(string.size() + 2);

        if (!escapeInvisibles) {
            ret += '"';
            ret += string;
            ret += '"';
            return ret;
        }

        ret += '"';
        for (char c : string) {
            switch (c) {
            case '\r':
                ret.append("\\r");
                break;
            case '\n':
                ret.append("\\n");
                break;
            case '\t':
                ret.append("\\t");
                break;
            case '\f':
                ret.append("\\f");
                break;
            default:
                ret.push_back(c);
                break;
            }
        }
        ret += '"';

        return ret;
    }

    std::string convertIntoString(StringRef string) {
        return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
    }

    std::string rawMemoryToString( const void *object, std::size_t size ) {
        // Reverse order for little endian architectures
        int i = 0, end = static_cast<int>( size ), inc = 1;
        if( Endianness::which() == Endianness::Little ) {
            i = end-1;
            end = inc = -1;
        }

        unsigned char const *bytes = static_cast<unsigned char const *>(object);
        ReusableStringStream rss;
        rss << "0x" << std::setfill('0') << std::hex;
        for( ; i != end; i += inc )
             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
       return rss.str();
    }
} // end Detail namespace



//// ======================================================= ////
//
//   Out-of-line defs for full specialization of StringMaker
//
//// ======================================================= ////

std::string StringMaker<std::string>::convert(const std::string& str) {
    return Detail::convertIntoString( str );
}

#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
std::string StringMaker<std::string_view>::convert(std::string_view str) {
    return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
}
#endif

std::string StringMaker<char const*>::convert(char const* str) {
    if (str) {
        return Detail::convertIntoString( str );
    } else {
        return{ "{null string}" };
    }
}
std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
    if (str) {
        return Detail::convertIntoString( str );
    } else {
        return{ "{null string}" };
    }
}

#ifdef CATCH_CONFIG_WCHAR
std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
    std::string s;
    s.reserve(wstr.size());
    for (auto c : wstr) {
        s += (c <= 0xff) ? static_cast<char>(c) : '?';
    }
    return ::Catch::Detail::stringify(s);
}

# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
    return StringMaker<std::wstring>::convert(std::wstring(str));
}
# endif

std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}
std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}
#endif

#if defined(CATCH_CONFIG_CPP17_BYTE)
#include <cstddef>
std::string StringMaker<std::byte>::convert(std::byte value) {
    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
}
#endif // defined(CATCH_CONFIG_CPP17_BYTE)

std::string StringMaker<int>::convert(int value) {
    return ::Catch::Detail::stringify(static_cast<long long>(value));
}
std::string StringMaker<long>::convert(long value) {
    return ::Catch::Detail::stringify(static_cast<long long>(value));
}
std::string StringMaker<long long>::convert(long long value) {
    ReusableStringStream rss;
    rss << value;
    if (value > Detail::hexThreshold) {
        rss << " (0x" << std::hex << value << ')';
    }
    return rss.str();
}

std::string StringMaker<unsigned int>::convert(unsigned int value) {
    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
}
std::string StringMaker<unsigned long>::convert(unsigned long value) {
    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
}
std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
    ReusableStringStream rss;
    rss << value;
    if (value > Detail::hexThreshold) {
        rss << " (0x" << std::hex << value << ')';
    }
    return rss.str();
}

std::string StringMaker<signed char>::convert(signed char value) {
    if (value == '\r') {
        return "'\\r'";
    } else if (value == '\f') {
        return "'\\f'";
    } else if (value == '\n') {
        return "'\\n'";
    } else if (value == '\t') {
        return "'\\t'";
    } else if ('\0' <= value && value < ' ') {
        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
    } else {
        char chstr[] = "' '";
        chstr[1] = value;
        return chstr;
    }
}
std::string StringMaker<char>::convert(char c) {
    return ::Catch::Detail::stringify(static_cast<signed char>(c));
}
std::string StringMaker<unsigned char>::convert(unsigned char value) {
    return ::Catch::Detail::stringify(static_cast<char>(value));
}

int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;

std::string StringMaker<float>::convert(float value) {
    return Detail::fpToString(value, precision) + 'f';
}

int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;

std::string StringMaker<double>::convert(double value) {
    return Detail::fpToString(value, precision);
}

} // end namespace Catch



namespace Catch {

    Counts Counts::operator - ( Counts const& other ) const {
        Counts diff;
        diff.passed = passed - other.passed;
        diff.failed = failed - other.failed;
        diff.failedButOk = failedButOk - other.failedButOk;
        diff.skipped = skipped - other.skipped;
        return diff;
    }

    Counts& Counts::operator += ( Counts const& other ) {
        passed += other.passed;
        failed += other.failed;
        failedButOk += other.failedButOk;
        skipped += other.skipped;
        return *this;
    }

    std::uint64_t Counts::total() const {
        return passed + failed + failedButOk + skipped;
    }
    bool Counts::allPassed() const {
        return failed == 0 && failedButOk == 0 && skipped == 0;
    }
    bool Counts::allOk() const {
        return failed == 0;
    }

    Totals Totals::operator - ( Totals const& other ) const {
        Totals diff;
        diff.assertions = assertions - other.assertions;
        diff.testCases = testCases - other.testCases;
        return diff;
    }

    Totals& Totals::operator += ( Totals const& other ) {
        assertions += other.assertions;
        testCases += other.testCases;
        return *this;
    }

    Totals Totals::delta( Totals const& prevTotals ) const {
        Totals diff = *this - prevTotals;
        if( diff.assertions.failed > 0 )
            ++diff.testCases.failed;
        else if( diff.assertions.failedButOk > 0 )
            ++diff.testCases.failedButOk;
        else if ( diff.assertions.skipped > 0 )
            ++ diff.testCases.skipped;
        else
            ++diff.testCases.passed;
        return diff;
    }

}




namespace Catch {
    namespace Detail {
        void registerTranslatorImpl(
            Detail::unique_ptr<IExceptionTranslator>&& translator ) {
            getMutableRegistryHub().registerTranslator(
                CATCH_MOVE( translator ) );
        }
    } // namespace Detail
} // namespace Catch


#include <ostream>

namespace Catch {

    Version::Version
        (   unsigned int _majorVersion,
            unsigned int _minorVersion,
            unsigned int _patchNumber,
            char const * const _branchName,
            unsigned int _buildNumber )
    :   majorVersion( _majorVersion ),
        minorVersion( _minorVersion ),
        patchNumber( _patchNumber ),
        branchName( _branchName ),
        buildNumber( _buildNumber )
    {}

    std::ostream& operator << ( std::ostream& os, Version const& version ) {
        os  << version.majorVersion << '.'
            << version.minorVersion << '.'
            << version.patchNumber;
        // branchName is never null -> 0th char is \0 if it is empty
        if (version.branchName[0]) {
            os << '-' << version.branchName
               << '.' << version.buildNumber;
        }
        return os;
    }

    Version const& libraryVersion() {
        static Version version( 3, 9, 0, "", 0 );
        return version;
    }

}




namespace Catch {

    const char* GeneratorException::what() const noexcept {
        return m_msg;
    }

} // end namespace Catch




namespace Catch {

    IGeneratorTracker::~IGeneratorTracker() = default;

namespace Generators {

namespace Detail {

    [[noreturn]]
    void throw_generator_exception(char const* msg) {
        Catch::throw_exception(GeneratorException{ msg });
    }
} // end namespace Detail

    GeneratorUntypedBase::~GeneratorUntypedBase() = default;

    IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
    }

    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
                                 SourceLineInfo lineInfo,
                                 GeneratorBasePtr&& generator ) {
        return getResultCapture().createGeneratorTracker(
            generatorName, lineInfo, CATCH_MOVE( generator ) );
    }

} // namespace Generators
} // namespace Catch




#include <random>

namespace Catch {
    namespace Generators {
        namespace Detail {
            std::uint32_t getSeed() { return sharedRng()(); }
        } // namespace Detail

        struct RandomFloatingGenerator<long double>::PImpl {
            PImpl( long double a, long double b, uint32_t seed ):
                rng( seed ), dist( a, b ) {}

            Catch::SimplePcg32 rng;
            std::uniform_real_distribution<long double> dist;
        };

        RandomFloatingGenerator<long double>::RandomFloatingGenerator(
            long double a, long double b, std::uint32_t seed) :
            m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) {
            static_cast<void>( next() );
        }

        RandomFloatingGenerator<long double>::~RandomFloatingGenerator() =
            default;
        bool RandomFloatingGenerator<long double>::next() {
            m_current_number = m_pimpl->dist( m_pimpl->rng );
            return true;
        }
    } // namespace Generators
} // namespace Catch




namespace Catch {
    IResultCapture::~IResultCapture() = default;
}




namespace Catch {
    IConfig::~IConfig() = default;
}




namespace Catch {
    IExceptionTranslator::~IExceptionTranslator() = default;
    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
}



#include <string>

namespace Catch {
    namespace Generators {

        bool GeneratorUntypedBase::countedNext() {
            auto ret = next();
            if ( ret ) {
                m_stringReprCache.clear();
                ++m_currentElementIndex;
            }
            return ret;
        }

        StringRef GeneratorUntypedBase::currentElementAsString() const {
            if ( m_stringReprCache.empty() ) {
                m_stringReprCache = stringifyImpl();
            }
            return m_stringReprCache;
        }

    } // namespace Generators
} // namespace Catch




namespace Catch {
    IRegistryHub::~IRegistryHub() = default;
    IMutableRegistryHub::~IMutableRegistryHub() = default;
}



#include <cassert>

namespace Catch {

    ReporterConfig::ReporterConfig(
        IConfig const* _fullConfig,
        Detail::unique_ptr<IStream> _stream,
        ColourMode colourMode,
        std::map<std::string, std::string> customOptions ):
        m_stream( CATCH_MOVE(_stream) ),
        m_fullConfig( _fullConfig ),
        m_colourMode( colourMode ),
        m_customOptions( CATCH_MOVE( customOptions ) ) {}

    Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
        assert( m_stream );
        return CATCH_MOVE( m_stream );
    }
    IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
    ColourMode ReporterConfig::colourMode() const { return m_colourMode; }

    std::map<std::string, std::string> const&
    ReporterConfig::customOptions() const {
        return m_customOptions;
    }

    ReporterConfig::~ReporterConfig() = default;

    AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
                                    std::vector<MessageInfo> const& _infoMessages,
                                    Totals const& _totals )
    :   assertionResult( _assertionResult ),
        infoMessages( _infoMessages ),
        totals( _totals )
    {
        if( assertionResult.hasMessage() ) {
            // Copy message into messages list.
            // !TBD This should have been done earlier, somewhere
            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
            builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());

            infoMessages.push_back( CATCH_MOVE(builder.m_info) );
        }
    }

    SectionStats::SectionStats(  SectionInfo&& _sectionInfo,
                                 Counts const& _assertions,
                                 double _durationInSeconds,
                                 bool _missingAssertions )
    :   sectionInfo( CATCH_MOVE(_sectionInfo) ),
        assertions( _assertions ),
        durationInSeconds( _durationInSeconds ),
        missingAssertions( _missingAssertions )
    {}


    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
                                   Totals const& _totals,
                                   std::string&& _stdOut,
                                   std::string&& _stdErr,
                                   bool _aborting )
    : testInfo( &_testInfo ),
        totals( _totals ),
        stdOut( CATCH_MOVE(_stdOut) ),
        stdErr( CATCH_MOVE(_stdErr) ),
        aborting( _aborting )
    {}


    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
                    Totals const& _totals,
                    bool _aborting )
    :   runInfo( _runInfo ),
        totals( _totals ),
        aborting( _aborting )
    {}

    IEventListener::~IEventListener() = default;

} // end namespace Catch




namespace Catch {
    IReporterFactory::~IReporterFactory() = default;
    EventListenerFactory::~EventListenerFactory() = default;
}




namespace Catch {
    ITestCaseRegistry::~ITestCaseRegistry() = default;
}



namespace Catch {

    AssertionHandler::AssertionHandler
        (   StringRef macroName,
            SourceLineInfo const& lineInfo,
            StringRef capturedExpression,
            ResultDisposition::Flags resultDisposition )
    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
        m_resultCapture( getResultCapture() )
    {
        m_resultCapture.notifyAssertionStarted( m_assertionInfo );
    }

    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
    }
    void AssertionHandler::handleMessage(ResultWas::OfType resultType, std::string&& message) {
        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
    }

    auto AssertionHandler::allowThrows() const -> bool {
        return getCurrentContext().getConfig()->allowThrows();
    }

    void AssertionHandler::complete() {
        m_completed = true;
        if( m_reaction.shouldDebugBreak ) {

            // If you find your debugger stopping you here then go one level up on the
            // call-stack for the code that caused it (typically a failed assertion)

            // (To go back to the test and change execution, jump over the throw, next)
            CATCH_BREAK_INTO_DEBUGGER();
        }
        if (m_reaction.shouldThrow) {
            throw_test_failure_exception();
        }
        if ( m_reaction.shouldSkip ) {
            throw_test_skip_exception();
        }
    }

    void AssertionHandler::handleUnexpectedInflightException() {
        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
    }

    void AssertionHandler::handleExceptionThrownAsExpected() {
        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
    }
    void AssertionHandler::handleExceptionNotThrownAsExpected() {
        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
    }

    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
    }

    void AssertionHandler::handleThrowingCallSkipped() {
        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
    }

    // This is the overload that takes a string and infers the Equals matcher from it
    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
        handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
    }

} // namespace Catch




#include <algorithm>

namespace Catch {
    namespace Detail {

        bool CaseInsensitiveLess::operator()( StringRef lhs,
                                              StringRef rhs ) const {
            return std::lexicographical_compare(
                lhs.begin(), lhs.end(),
                rhs.begin(), rhs.end(),
                []( char l, char r ) { return toLower( l ) < toLower( r ); } );
        }

        bool
        CaseInsensitiveEqualTo::operator()( StringRef lhs,
                                            StringRef rhs ) const {
            return std::equal(
                lhs.begin(), lhs.end(),
                rhs.begin(), rhs.end(),
                []( char l, char r ) { return toLower( l ) == toLower( r ); } );
        }

    } // namespace Detail
} // namespace Catch




#include <algorithm>
#include <ostream>

namespace {
    bool isOptPrefix( char c ) {
        return c == '-'
#ifdef CATCH_PLATFORM_WINDOWS
               || c == '/'
#endif
            ;
    }

    Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
        if ( optName[0] == '-'
#if defined(CATCH_PLATFORM_WINDOWS)
             || optName[0] == '/'
#endif
        ) {
            return optName.substr( 1, optName.size() );
        }

        return optName;
    }

    static size_t find_first_separator(Catch::StringRef sr) {
        auto is_separator = []( char c ) {
            return c == ' ' || c == ':' || c == '=';
        };
        size_t pos = 0;
        while (pos < sr.size()) {
            if (is_separator(sr[pos])) { return pos; }
            ++pos;
        }

        return Catch::StringRef::npos;
    }

} // namespace

namespace Catch {
    namespace Clara {
        namespace Detail {

            void TokenStream::loadBuffer() {
                m_tokenBuffer.clear();

                // Skip any empty strings
                while ( it != itEnd && it->empty() ) {
                    ++it;
                }

                if ( it != itEnd ) {
                    StringRef next = *it;
                    if ( isOptPrefix( next[0] ) ) {
                        auto delimiterPos = find_first_separator(next);
                        if ( delimiterPos != StringRef::npos ) {
                            m_tokenBuffer.push_back(
                                { TokenType::Option,
                                  next.substr( 0, delimiterPos ) } );
                            m_tokenBuffer.push_back(
                                { TokenType::Argument,
                                  next.substr( delimiterPos + 1, next.size() ) } );
                        } else {
                            if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) {
                                // Combined short args, e.g. "-ab" for "-a -b"
                                for ( size_t i = 1; i < next.size(); ++i ) {
                                    m_tokenBuffer.push_back(
                                        { TokenType::Option,
                                          next.substr( i, 1 ) } );
                                }
                            } else {
                                m_tokenBuffer.push_back(
                                    { TokenType::Option, next } );
                            }
                        }
                    } else {
                        m_tokenBuffer.push_back(
                            { TokenType::Argument, next } );
                    }
                }
            }

            TokenStream::TokenStream( Args const& args ):
                TokenStream( args.m_args.begin(), args.m_args.end() ) {}

            TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
                it( it_ ), itEnd( itEnd_ ) {
                loadBuffer();
            }

            TokenStream& TokenStream::operator++() {
                if ( m_tokenBuffer.size() >= 2 ) {
                    m_tokenBuffer.erase( m_tokenBuffer.begin() );
                } else {
                    if ( it != itEnd )
                        ++it;
                    loadBuffer();
                }
                return *this;
            }

            ParserResult convertInto( std::string const& source,
                                      std::string& target ) {
                target = source;
                return ParserResult::ok( ParseResultType::Matched );
            }

            ParserResult convertInto( std::string const& source,
                                      bool& target ) {
                std::string srcLC = toLower( source );

                if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
                     srcLC == "yes" || srcLC == "on" ) {
                    target = true;
                } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
                            srcLC == "no" || srcLC == "off" ) {
                    target = false;
                } else {
                    return ParserResult::runtimeError(
                        "Expected a boolean value but did not recognise: '" +
                        source + '\'' );
                }
                return ParserResult::ok( ParseResultType::Matched );
            }

            size_t ParserBase::cardinality() const { return 1; }

            InternalParseResult ParserBase::parse( Args const& args ) const {
                return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) );
            }

            ParseState::ParseState( ParseResultType type,
                                    TokenStream remainingTokens ):
                m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {}

            ParserResult BoundFlagRef::setFlag( bool flag ) {
                m_ref = flag;
                return ParserResult::ok( ParseResultType::Matched );
            }

            ResultBase::~ResultBase() = default;

            bool BoundRef::isContainer() const { return false; }

            bool BoundRef::isFlag() const { return false; }

            bool BoundFlagRefBase::isFlag() const { return true; }

} // namespace Detail

        Detail::InternalParseResult Arg::parse(std::string const&,
                                               Detail::TokenStream tokens) const {
            auto validationResult = validate();
            if (!validationResult)
                return Detail::InternalParseResult(validationResult);

            auto token = *tokens;
            if (token.type != Detail::TokenType::Argument)
                return Detail::InternalParseResult::ok(Detail::ParseState(
                    ParseResultType::NoMatch, CATCH_MOVE(tokens)));

            assert(!m_ref->isFlag());
            auto valueRef =
                static_cast<Detail::BoundValueRefBase*>(m_ref.get());

            auto result = valueRef->setValue(static_cast<std::string>(token.token));
            if ( !result )
                return Detail::InternalParseResult( result );
            else
                return Detail::InternalParseResult::ok(
                    Detail::ParseState( ParseResultType::Matched,
                                        CATCH_MOVE( ++tokens ) ) );
        }

        Opt::Opt(bool& ref) :
            ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}

        Detail::HelpColumns Opt::getHelpColumns() const {
            ReusableStringStream oss;
            bool first = true;
            for (auto const& opt : m_optNames) {
                if (first)
                    first = false;
                else
                    oss << ", ";
                oss << opt;
            }
            if (!m_hint.empty())
                oss << " <" << m_hint << '>';
            return { oss.str(), m_description };
        }

        bool Opt::isMatch(StringRef optToken) const {
            auto normalisedToken = normaliseOpt(optToken);
            for (auto const& name : m_optNames) {
                if (normaliseOpt(name) == normalisedToken)
                    return true;
            }
            return false;
        }

        Detail::InternalParseResult Opt::parse(std::string const&,
                                       Detail::TokenStream tokens) const {
            auto validationResult = validate();
            if (!validationResult)
                return Detail::InternalParseResult(validationResult);

            if (tokens &&
                tokens->type == Detail::TokenType::Option) {
                auto const& token = *tokens;
                if (isMatch(token.token)) {
                    if (m_ref->isFlag()) {
                        auto flagRef =
                            static_cast<Detail::BoundFlagRefBase*>(
                                m_ref.get());
                        auto result = flagRef->setFlag(true);
                        if (!result)
                            return Detail::InternalParseResult(result);
                        if (result.value() ==
                            ParseResultType::ShortCircuitAll)
                            return Detail::InternalParseResult::ok(Detail::ParseState(
                                result.value(), CATCH_MOVE(tokens)));
                    } else {
                        auto valueRef =
                            static_cast<Detail::BoundValueRefBase*>(
                                m_ref.get());
                        ++tokens;
                        if (!tokens)
                            return Detail::InternalParseResult::runtimeError(
                                "Expected argument following " +
                                token.token);
                        auto const& argToken = *tokens;
                        if (argToken.type != Detail::TokenType::Argument)
                            return Detail::InternalParseResult::runtimeError(
                                "Expected argument following " +
                                token.token);
                        const auto result = valueRef->setValue(static_cast<std::string>(argToken.token));
                        if (!result)
                            return Detail::InternalParseResult(result);
                        if (result.value() ==
                            ParseResultType::ShortCircuitAll)
                            return Detail::InternalParseResult::ok(Detail::ParseState(
                                result.value(), CATCH_MOVE(tokens)));
                    }
                    return Detail::InternalParseResult::ok(Detail::ParseState(
                        ParseResultType::Matched, CATCH_MOVE(++tokens)));
                }
            }
            return Detail::InternalParseResult::ok(
                Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
        }

        Detail::Result Opt::validate() const {
            if (m_optNames.empty())
                return Detail::Result::logicError("No options supplied to Opt");
            for (auto const& name : m_optNames) {
                if (name.empty())
                    return Detail::Result::logicError(
                        "Option name cannot be empty");
#ifdef CATCH_PLATFORM_WINDOWS
                if (name[0] != '-' && name[0] != '/')
                    return Detail::Result::logicError(
                        "Option name must begin with '-' or '/'");
#else
                if (name[0] != '-')
                    return Detail::Result::logicError(
                        "Option name must begin with '-'");
#endif
            }
            return ParserRefImpl::validate();
        }

        ExeName::ExeName() :
            m_name(std::make_shared<std::string>("<executable>")) {}

        ExeName::ExeName(std::string& ref) : ExeName() {
            m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
        }

        Detail::InternalParseResult
            ExeName::parse(std::string const&,
                           Detail::TokenStream tokens) const {
            return Detail::InternalParseResult::ok(
                Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
        }

        ParserResult ExeName::set(std::string const& newName) {
            auto lastSlash = newName.find_last_of("\\/");
            auto filename = (lastSlash == std::string::npos)
                ? newName
                : newName.substr(lastSlash + 1);

            *m_name = filename;
            if (m_ref)
                return m_ref->setValue(filename);
            else
                return ParserResult::ok(ParseResultType::Matched);
        }




        Parser& Parser::operator|=( Parser const& other ) {
            m_options.insert( m_options.end(),
                              other.m_options.begin(),
                              other.m_options.end() );
            m_args.insert(
                m_args.end(), other.m_args.begin(), other.m_args.end() );
            return *this;
        }

        std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
            std::vector<Detail::HelpColumns> cols;
            cols.reserve( m_options.size() );
            for ( auto const& o : m_options ) {
                cols.push_back(o.getHelpColumns());
            }
            return cols;
        }

        void Parser::writeToStream( std::ostream& os ) const {
            if ( !m_exeName.name().empty() ) {
                os << "usage:\n"
                   << "  " << m_exeName.name() << ' ';
                bool required = true, first = true;
                for ( auto const& arg : m_args ) {
                    if ( first )
                        first = false;
                    else
                        os << ' ';
                    if ( arg.isOptional() && required ) {
                        os << '[';
                        required = false;
                    }
                    os << '<' << arg.hint() << '>';
                    if ( arg.cardinality() == 0 )
                        os << " ... ";
                }
                if ( !required )
                    os << ']';
                if ( !m_options.empty() )
                    os << " options";
                os << "\n\nwhere options are:\n";
            }

            auto rows = getHelpColumns();
            size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
            size_t optWidth = 0;
            for ( auto const& cols : rows )
                optWidth = ( std::max )( optWidth, cols.left.size() + 2 );

            optWidth = ( std::min )( optWidth, consoleWidth / 2 );

            for ( auto& cols : rows ) {
                auto row = TextFlow::Column( CATCH_MOVE(cols.left) )
                               .width( optWidth )
                               .indent( 2 ) +
                           TextFlow::Spacer( 4 ) +
                           TextFlow::Column( static_cast<std::string>(cols.descriptions) )
                               .width( consoleWidth - 7 - optWidth );
                os << row << '\n';
            }
        }

        Detail::Result Parser::validate() const {
            for ( auto const& opt : m_options ) {
                auto result = opt.validate();
                if ( !result )
                    return result;
            }
            for ( auto const& arg : m_args ) {
                auto result = arg.validate();
                if ( !result )
                    return result;
            }
            return Detail::Result::ok();
        }

        Detail::InternalParseResult
        Parser::parse( std::string const& exeName,
                       Detail::TokenStream tokens ) const {

            struct ParserInfo {
                ParserBase const* parser = nullptr;
                size_t count = 0;
            };
            std::vector<ParserInfo> parseInfos;
            parseInfos.reserve( m_options.size() + m_args.size() );
            for ( auto const& opt : m_options ) {
                parseInfos.push_back( { &opt, 0 } );
            }
            for ( auto const& arg : m_args ) {
                parseInfos.push_back( { &arg, 0 } );
            }

            m_exeName.set( exeName );

            auto result = Detail::InternalParseResult::ok(
                Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) );
            while ( result.value().remainingTokens() ) {
                bool tokenParsed = false;

                for ( auto& parseInfo : parseInfos ) {
                    if ( parseInfo.parser->cardinality() == 0 ||
                         parseInfo.count < parseInfo.parser->cardinality() ) {
                        result = parseInfo.parser->parse(
                            exeName, CATCH_MOVE(result).value().remainingTokens() );
                        if ( !result )
                            return result;
                        if ( result.value().type() !=
                             ParseResultType::NoMatch ) {
                            tokenParsed = true;
                            ++parseInfo.count;
                            break;
                        }
                    }
                }

                if ( result.value().type() == ParseResultType::ShortCircuitAll )
                    return result;
                if ( !tokenParsed )
                    return Detail::InternalParseResult::runtimeError(
                        "Unrecognised token: " +
                        result.value().remainingTokens()->token );
            }
            // !TBD Check missing required options
            return result;
        }

        Args::Args(int argc, char const* const* argv) :
            m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}

        Args::Args(std::initializer_list<StringRef> args) :
            m_exeName(*args.begin()),
            m_args(args.begin() + 1, args.end()) {}


        Help::Help( bool& showHelpFlag ):
            Opt( [&]( bool flag ) {
                showHelpFlag = flag;
                return ParserResult::ok( ParseResultType::ShortCircuitAll );
            } ) {
            static_cast<Opt&> ( *this )(
                "display usage information" )["-?"]["-h"]["--help"]
                .optional();
        }

    } // namespace Clara
} // namespace Catch




#include <fstream>
#include <string>

namespace Catch {

    Clara::Parser makeCommandLineParser( ConfigData& config ) {

        using namespace Clara;

        auto const setWarning = [&]( std::string const& warning ) {
            if ( warning == "NoAssertions" ) {
                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
                return ParserResult::ok( ParseResultType::Matched );
            } else if ( warning == "UnmatchedTestSpec" ) {
                config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
                return ParserResult::ok( ParseResultType::Matched );
            }

            return ParserResult ::runtimeError(
                "Unrecognised warning option: '" + warning + '\'' );
        };
        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
                std::ifstream f( filename.c_str() );
                if( !f.is_open() )
                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );

                std::string line;
                while( std::getline( f, line ) ) {
                    line = trim(line);
                    if( !line.empty() && !startsWith( line, '#' ) ) {
                        if( !startsWith( line, '"' ) )
                            line = '"' + CATCH_MOVE(line) + '"';
                        config.testsOrTags.push_back( line );
                        config.testsOrTags.emplace_back( "," );
                    }
                }
                //Remove comma in the end
                if(!config.testsOrTags.empty())
                    config.testsOrTags.erase( config.testsOrTags.end()-1 );

                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setTestOrder = [&]( std::string const& order ) {
                if( startsWith( "declared", order ) )
                    config.runOrder = TestRunOrder::Declared;
                else if( startsWith( "lexical", order ) )
                    config.runOrder = TestRunOrder::LexicographicallySorted;
                else if( startsWith( "random", order ) )
                    config.runOrder = TestRunOrder::Randomized;
                else
                    return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setRngSeed = [&]( std::string const& seed ) {
                if( seed == "time" ) {
                    config.rngSeed = generateRandomSeed(GenerateFrom::Time);
                    return ParserResult::ok(ParseResultType::Matched);
                } else if (seed == "random-device") {
                    config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
                    return ParserResult::ok(ParseResultType::Matched);
                }

                // TODO: ideally we should be parsing uint32_t directly
                //       fix this later when we add new parse overload
                auto parsedSeed = parseUInt( seed, 0 );
                if ( !parsedSeed ) {
                    return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
                }
                config.rngSeed = *parsedSeed;
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
            Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
            if ( !maybeMode ) {
                return ParserResult::runtimeError(
                    "colour mode must be one of: default, ansi, win32, "
                    "or none. '" +
                    colourMode + "' is not recognised" );
            }
            auto mode = *maybeMode;
            if ( !isColourImplAvailable( mode ) ) {
                return ParserResult::runtimeError(
                    "colour mode '" + colourMode +
                    "' is not supported in this binary" );
            }
            config.defaultColourMode = mode;
            return ParserResult::ok( ParseResultType::Matched );
        };
        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
                auto keypressLc = toLower( keypress );
                if (keypressLc == "never")
                    config.waitForKeypress = WaitForKeypress::Never;
                else if( keypressLc == "start" )
                    config.waitForKeypress = WaitForKeypress::BeforeStart;
                else if( keypressLc == "exit" )
                    config.waitForKeypress = WaitForKeypress::BeforeExit;
                else if( keypressLc == "both" )
                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
                else
                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
            return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setVerbosity = [&]( std::string const& verbosity ) {
            auto lcVerbosity = toLower( verbosity );
            if( lcVerbosity == "quiet" )
                config.verbosity = Verbosity::Quiet;
            else if( lcVerbosity == "normal" )
                config.verbosity = Verbosity::Normal;
            else if( lcVerbosity == "high" )
                config.verbosity = Verbosity::High;
            else
                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
            return ParserResult::ok( ParseResultType::Matched );
        };
        auto const setReporter = [&]( std::string const& userReporterSpec ) {
            if ( userReporterSpec.empty() ) {
                return ParserResult::runtimeError( "Received empty reporter spec." );
            }

            Optional<ReporterSpec> parsed =
                parseReporterSpec( userReporterSpec );
            if ( !parsed ) {
                return ParserResult::runtimeError(
                    "Could not parse reporter spec '" + userReporterSpec +
                    "'" );
            }

            auto const& reporterSpec = *parsed;

            auto const& factories =
                getRegistryHub().getReporterRegistry().getFactories();
            auto result = factories.find( reporterSpec.name() );

            if ( result == factories.end() ) {
                return ParserResult::runtimeError(
                    "Unrecognized reporter, '" + reporterSpec.name() +
                    "'. Check available with --list-reporters" );
            }


            const bool hadOutputFile = reporterSpec.outputFile().some();
            config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
            // It would be enough to check this only once at the very end, but
            // there is  not a place where we could call this check, so do it
            // every time it could fail. For valid inputs, this is still called
            // at most once.
            if (!hadOutputFile) {
                int n_reporters_without_file = 0;
                for (auto const& spec : config.reporterSpecifications) {
                    if (spec.outputFile().none()) {
                        n_reporters_without_file++;
                    }
                }
                if (n_reporters_without_file > 1) {
                    return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
                }
            }

            return ParserResult::ok( ParseResultType::Matched );
        };
        auto const setShardCount = [&]( std::string const& shardCount ) {
            auto parsedCount = parseUInt( shardCount );
            if ( !parsedCount ) {
                return ParserResult::runtimeError(
                    "Could not parse '" + shardCount + "' as shard count" );
            }
            if ( *parsedCount == 0 ) {
                return ParserResult::runtimeError(
                    "Shard count must be positive" );
            }
            config.shardCount = *parsedCount;
            return ParserResult::ok( ParseResultType::Matched );
        };

        auto const setShardIndex = [&](std::string const& shardIndex) {
            auto parsedIndex = parseUInt( shardIndex );
            if ( !parsedIndex ) {
                return ParserResult::runtimeError(
                    "Could not parse '" + shardIndex + "' as shard index" );
            }
            config.shardIndex = *parsedIndex;
            return ParserResult::ok( ParseResultType::Matched );
        };

        auto cli
            = ExeName( config.processName )
            | Help( config.showHelp )
            | Opt( config.showSuccessfulTests )
                ["-s"]["--success"]
                ( "include successful tests in output" )
            | Opt( config.shouldDebugBreak )
                ["-b"]["--break"]
                ( "break into debugger on failure" )
            | Opt( config.noThrow )
                ["-e"]["--nothrow"]
                ( "skip exception tests" )
            | Opt( config.showInvisibles )
                ["-i"]["--invisibles"]
                ( "show invisibles (tabs, newlines)" )
            | Opt( config.defaultOutputFilename, "filename" )
                ["-o"]["--out"]
                ( "default output filename" )
            | Opt( accept_many, setReporter, "name[::key=value]*" )
                ["-r"]["--reporter"]
                ( "reporter to use (defaults to console)" )
            | Opt( config.name, "name" )
                ["-n"]["--name"]
                ( "suite name" )
            | Opt( [&]( bool ){ config.abortAfter = 1; } )
                ["-a"]["--abort"]
                ( "abort at first failure" )
            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
                ["-x"]["--abortx"]
                ( "abort after x failures" )
            | Opt( accept_many, setWarning, "warning name" )
                ["-w"]["--warn"]
                ( "enable warnings" )
            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
                ["-d"]["--durations"]
                ( "show test durations" )
            | Opt( config.minDuration, "seconds" )
                ["-D"]["--min-duration"]
                ( "show test durations for tests taking at least the given number of seconds" )
            | Opt( loadTestNamesFromFile, "filename" )
                ["-f"]["--input-file"]
                ( "load test names to run from a file" )
            | Opt( config.filenamesAsTags )
                ["-#"]["--filenames-as-tags"]
                ( "adds a tag for the filename" )
            | Opt( config.sectionsToRun, "section name" )
                ["-c"]["--section"]
                ( "specify section to run" )
            | Opt( setVerbosity, "quiet|normal|high" )
                ["-v"]["--verbosity"]
                ( "set output verbosity" )
            | Opt( config.listTests )
                ["--list-tests"]
                ( "list all/matching test cases" )
            | Opt( config.listTags )
                ["--list-tags"]
                ( "list all/matching tags" )
            | Opt( config.listReporters )
                ["--list-reporters"]
                ( "list all available reporters" )
            | Opt( config.listListeners )
                ["--list-listeners"]
                ( "list all listeners" )
            | Opt( setTestOrder, "decl|lex|rand" )
                ["--order"]
                ( "test case order (defaults to decl)" )
            | Opt( setRngSeed, "'time'|'random-device'|number" )
                ["--rng-seed"]
                ( "set a specific seed for random numbers" )
            | Opt( setDefaultColourMode, "ansi|win32|none|default" )
                ["--colour-mode"]
                ( "what color mode should be used as default" )
            | Opt( config.libIdentify )
                ["--libidentify"]
                ( "report name and version according to libidentify standard" )
            | Opt( setWaitForKeypress, "never|start|exit|both" )
                ["--wait-for-keypress"]
                ( "waits for a keypress before exiting" )
            | Opt( config.skipBenchmarks)
                ["--skip-benchmarks"]
                ( "disable running benchmarks")
            | Opt( config.benchmarkSamples, "samples" )
                ["--benchmark-samples"]
                ( "number of samples to collect (default: 100)" )
            | Opt( config.benchmarkResamples, "resamples" )
                ["--benchmark-resamples"]
                ( "number of resamples for the bootstrap (default: 100000)" )
            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
                ["--benchmark-confidence-interval"]
                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
            | Opt( config.benchmarkNoAnalysis )
                ["--benchmark-no-analysis"]
                ( "perform only measurements; do not perform any analysis" )
            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
                ["--benchmark-warmup-time"]
                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
            | Opt( setShardCount, "shard count" )
                ["--shard-count"]
                ( "split the tests to execute into this many groups" )
            | Opt( setShardIndex, "shard index" )
                ["--shard-index"]
                ( "index of the group of tests to execute (see --shard-count)" )
            | Opt( config.allowZeroTests )
                ["--allow-running-no-tests"]
                ( "Treat 'No tests run' as a success" )
            | Arg( config.testsOrTags, "test name|pattern|tags" )
                ( "which test or tests to use" );

        return cli;
    }

} // end namespace Catch


#if defined(__clang__)
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif



#include <cassert>
#include <ostream>
#include <utility>

namespace Catch {

    ColourImpl::~ColourImpl() = default;

    ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
        return ColourGuard(colourCode, this );
    }

    void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
        assert( &stream == &m_colourImpl->m_stream->stream() &&
                "Engaging colour guard for different stream than used by the "
                "parent colour implementation" );
        static_cast<void>( stream );

        m_engaged = true;
        m_colourImpl->use( m_code );
    }

    ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
                                          ColourImpl const* colour ):
        m_colourImpl( colour ), m_code( code ) {
    }
    ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
        m_colourImpl( rhs.m_colourImpl ),
        m_code( rhs.m_code ),
        m_engaged( rhs.m_engaged ) {
        rhs.m_engaged = false;
    }
    ColourImpl::ColourGuard&
    ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
        using std::swap;
        swap( m_colourImpl, rhs.m_colourImpl );
        swap( m_code, rhs.m_code );
        swap( m_engaged, rhs.m_engaged );

        return *this;
    }
    ColourImpl::ColourGuard::~ColourGuard() {
        if ( m_engaged ) {
            m_colourImpl->use( Colour::None );
        }
    }

    ColourImpl::ColourGuard&
    ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
        engageImpl( stream );
        return *this;
    }

    ColourImpl::ColourGuard&&
    ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
        engageImpl( stream );
        return CATCH_MOVE(*this);
    }

    namespace {
        //! A do-nothing implementation of colour, used as fallback for unknown
        //! platforms, and when the user asks to deactivate all colours.
        class NoColourImpl final : public ColourImpl {
        public:
            NoColourImpl( IStream* stream ): ColourImpl( stream ) {}

        private:
            void use( Colour::Code ) const override {}
        };
    } // namespace


} // namespace Catch


#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////

namespace Catch {
namespace {

    class Win32ColourImpl final : public ColourImpl {
    public:
        Win32ColourImpl(IStream* stream):
            ColourImpl(stream) {
            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
            GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
                                        &csbiInfo );
            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
        }

        static bool useImplementationForStream(IStream const& stream) {
            // Win32 text colour APIs can only be used on console streams
            // We cannot check that the output hasn't been redirected,
            // so we just check that the original stream is console stream.
            return stream.isConsole();
        }

    private:
        void use( Colour::Code _colourCode ) const override {
            switch( _colourCode ) {
                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
                case Colour::Grey:      return setTextAttribute( 0 );

                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );

                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );

                default:
                    CATCH_ERROR( "Unknown colour requested" );
            }
        }

        void setTextAttribute( WORD _textAttribute ) const {
            SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
                                     _textAttribute |
                                         originalBackgroundAttributes );
        }
        WORD originalForegroundAttributes;
        WORD originalBackgroundAttributes;
    };

} // end anon namespace
} // end namespace Catch

#endif // Windows/ ANSI/ None


#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) || defined( __GLIBC__ )
#    define CATCH_INTERNAL_HAS_ISATTY
#    include <unistd.h>
#endif

namespace Catch {
namespace {

    class ANSIColourImpl final : public ColourImpl {
    public:
        ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}

        static bool useImplementationForStream(IStream const& stream) {
            // This is kinda messy due to trying to support a bunch of
            // different platforms at once.
            // The basic idea is that if we are asked to do autodetection (as
            // opposed to being told to use posixy colours outright), then we
            // only want to use the colours if we are writing to console.
            // However, console might be redirected, so we make an attempt at
            // checking for that on platforms where we know how to do that.
            bool useColour = stream.isConsole();
#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
    !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
            ErrnoGuard _; // for isatty
            useColour = useColour && isatty( STDOUT_FILENO );
#    endif
#    if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
            useColour = useColour && !isDebuggerActive();
#    endif

            return useColour;
        }

    private:
        void use( Colour::Code _colourCode ) const override {
            auto setColour = [&out =
                                  m_stream->stream()]( char const* escapeCode ) {
                // The escape sequence must be flushed to console, otherwise
                // if stdin and stderr are intermixed, we'd get accidentally
                // coloured output.
                out << '\033' << escapeCode << std::flush;
            };
            switch( _colourCode ) {
                case Colour::None:
                case Colour::White:     return setColour( "[0m" );
                case Colour::Red:       return setColour( "[0;31m" );
                case Colour::Green:     return setColour( "[0;32m" );
                case Colour::Blue:      return setColour( "[0;34m" );
                case Colour::Cyan:      return setColour( "[0;36m" );
                case Colour::Yellow:    return setColour( "[0;33m" );
                case Colour::Grey:      return setColour( "[1;30m" );

                case Colour::LightGrey:     return setColour( "[0;37m" );
                case Colour::BrightRed:     return setColour( "[1;31m" );
                case Colour::BrightGreen:   return setColour( "[1;32m" );
                case Colour::BrightWhite:   return setColour( "[1;37m" );
                case Colour::BrightYellow:  return setColour( "[1;33m" );

                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
            }
        }
    };

} // end anon namespace
} // end namespace Catch

namespace Catch {

    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
                                                   IStream* stream ) {
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
        if ( colourSelection == ColourMode::Win32 ) {
            return Detail::make_unique<Win32ColourImpl>( stream );
        }
#endif
        if ( colourSelection == ColourMode::ANSI ) {
            return Detail::make_unique<ANSIColourImpl>( stream );
        }
        if ( colourSelection == ColourMode::None ) {
            return Detail::make_unique<NoColourImpl>( stream );
        }

        if ( colourSelection == ColourMode::PlatformDefault) {
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
            if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
                return Detail::make_unique<Win32ColourImpl>( stream );
            }
#endif
            if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
                return Detail::make_unique<ANSIColourImpl>( stream );
            }
            return Detail::make_unique<NoColourImpl>( stream );
        }

        CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) );
    }

    bool isColourImplAvailable( ColourMode colourSelection ) {
        switch ( colourSelection ) {
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
        case ColourMode::Win32:
#endif
        case ColourMode::ANSI:
        case ColourMode::None:
        case ColourMode::PlatformDefault:
            return true;
        default:
            return false;
        }
    }


} // end namespace Catch

#if defined(__clang__)
#    pragma clang diagnostic pop
#endif




namespace Catch {

    Context* Context::currentContext = nullptr;

    void cleanUpContext() {
        delete Context::currentContext;
        Context::currentContext = nullptr;
    }
    void Context::createContext() {
        currentContext = new Context();
    }

    Context& getCurrentMutableContext() {
        if ( !Context::currentContext ) { Context::createContext(); }
        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
        return *Context::currentContext;
    }

    SimplePcg32& sharedRng() {
        static SimplePcg32 s_rng;
        return s_rng;
    }

}





#include <ostream>

#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
#include <android/log.h>

    namespace Catch {
        void writeToDebugConsole( std::string const& text ) {
            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
        }
    }

#elif defined(CATCH_PLATFORM_WINDOWS)

    namespace Catch {
        void writeToDebugConsole( std::string const& text ) {
            ::OutputDebugStringA( text.c_str() );
        }
    }

#else

    namespace Catch {
        void writeToDebugConsole( std::string const& text ) {
            // !TBD: Need a version for Mac/ XCode and other IDEs
            Catch::cout() << text;
        }
    }

#endif // Platform



#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)

#  include <cassert>
#  include <sys/types.h>
#  include <unistd.h>
#  include <cstddef>
#  include <ostream>

#ifdef __apple_build_version__
    // These headers will only compile with AppleClang (XCode)
    // For other compilers (Clang, GCC, ... ) we need to exclude them
#  include <sys/sysctl.h>
#endif

    namespace Catch {
        #ifdef __apple_build_version__
        // The following function is taken directly from the following technical note:
        // https://developer.apple.com/library/archive/qa/qa1361/_index.html

        // Returns true if the current process is being debugged (either
        // running under the debugger or has a debugger attached post facto).
        bool isDebuggerActive(){
            int                 mib[4];
            struct kinfo_proc   info;
            std::size_t         size;

            // Initialize the flags so that, if sysctl fails for some bizarre
            // reason, we get a predictable result.

            info.kp_proc.p_flag = 0;

            // Initialize mib, which tells sysctl the info we want, in this case
            // we're looking for information about a specific process ID.

            mib[0] = CTL_KERN;
            mib[1] = KERN_PROC;
            mib[2] = KERN_PROC_PID;
            mib[3] = getpid();

            // Call sysctl.

            size = sizeof(info);
            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
                return false;
            }

            // We're being debugged if the P_TRACED flag is set.

            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
        }
        #else
        bool isDebuggerActive() {
            // We need to find another way to determine this for non-appleclang compilers on macOS
            return false;
        }
        #endif
    } // namespace Catch

#elif defined(CATCH_PLATFORM_LINUX)
    #include <fstream>
    #include <string>

    namespace Catch{
        // The standard POSIX way of detecting a debugger is to attempt to
        // ptrace() the process, but this needs to be done from a child and not
        // this process itself to still allow attaching to this process later
        // if wanted, so is rather heavy. Under Linux we have the PID of the
        // "debugger" (which doesn't need to be gdb, of course, it could also
        // be strace, for example) in /proc/$PID/status, so just get it from
        // there instead.
        bool isDebuggerActive(){
            // Libstdc++ has a bug, where std::ifstream sets errno to 0
            // This way our users can properly assert over errno values
            ErrnoGuard guard;
            std::ifstream in("/proc/self/status");
            for( std::string line; std::getline(in, line); ) {
                static const int PREFIX_LEN = 11;
                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
                    // We're traced if the PID is not 0 and no other PID starts
                    // with 0 digit, so it's enough to check for just a single
                    // character.
                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
                }
            }

            return false;
        }
    } // namespace Catch
#elif defined(_MSC_VER)
    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
    namespace Catch {
        bool isDebuggerActive() {
            return IsDebuggerPresent() != 0;
        }
    }
#elif defined(__MINGW32__)
    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
    namespace Catch {
        bool isDebuggerActive() {
            return IsDebuggerPresent() != 0;
        }
    }
#else
    namespace Catch {
       bool isDebuggerActive() { return false; }
    }
#endif // Platform




namespace Catch {

    void ITransientExpression::streamReconstructedExpression(
        std::ostream& os ) const {
        // We can't make this function pure virtual to keep ITransientExpression
        // constexpr, so we write error message instead
        os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
    }

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
        if( lhs.size() + rhs.size() < 40 &&
                lhs.find('\n') == std::string::npos &&
                rhs.find('\n') == std::string::npos )
            os << lhs << ' ' << op << ' ' << rhs;
        else
            os << lhs << '\n' << op << '\n' << rhs;
    }
}



#include <stdexcept>


namespace Catch {
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
    [[noreturn]]
    void throw_exception(std::exception const& e) {
        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
                      << "The message was: " << e.what() << '\n';
        std::terminate();
    }
#endif

    [[noreturn]]
    void throw_logic_error(std::string const& msg) {
        throw_exception(std::logic_error(msg));
    }

    [[noreturn]]
    void throw_domain_error(std::string const& msg) {
        throw_exception(std::domain_error(msg));
    }

    [[noreturn]]
    void throw_runtime_error(std::string const& msg) {
        throw_exception(std::runtime_error(msg));
    }



} // namespace Catch;



#include <cassert>

namespace Catch {

    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;

    namespace Detail {

        namespace {
            // Extracts the actual name part of an enum instance
            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
            StringRef extractInstanceName(StringRef enumInstance) {
                // Find last occurrence of ":"
                size_t name_start = enumInstance.size();
                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
                    --name_start;
                }
                return enumInstance.substr(name_start, enumInstance.size() - name_start);
            }
        }

        std::vector<StringRef> parseEnums( StringRef enums ) {
            auto enumValues = splitStringRef( enums, ',' );
            std::vector<StringRef> parsed;
            parsed.reserve( enumValues.size() );
            for( auto const& enumValue : enumValues ) {
                parsed.push_back(trim(extractInstanceName(enumValue)));
            }
            return parsed;
        }

        EnumInfo::~EnumInfo() = default;

        StringRef EnumInfo::lookup( int value ) const {
            for( auto const& valueToName : m_values ) {
                if( valueToName.first == value )
                    return valueToName.second;
            }
            return "{** unexpected enum value **}"_sr;
        }

        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
            auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
            enumInfo->m_name = enumName;
            enumInfo->m_values.reserve( values.size() );

            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
            assert( valueNames.size() == values.size() );
            std::size_t i = 0;
            for( auto value : values )
                enumInfo->m_values.emplace_back(value, valueNames[i++]);

            return enumInfo;
        }

        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
            return *m_enumInfos.back();
        }

    } // Detail
} // Catch





#include <cerrno>

namespace Catch {
        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
}



#include <exception>

namespace Catch {

#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
    namespace {
        static std::string tryTranslators(
            std::vector<
                Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
            if ( translators.empty() ) {
                std::rethrow_exception( std::current_exception() );
            } else {
                return translators[0]->translate( translators.begin() + 1,
                                                  translators.end() );
            }
        }

    }
#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;

    void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
        m_translators.push_back( CATCH_MOVE( translator ) );
    }

#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
    std::string ExceptionTranslatorRegistry::translateActiveException() const {
        // Compiling a mixed mode project with MSVC means that CLR
        // exceptions will be caught in (...) as well. However, these do
        // do not fill-in std::current_exception and thus lead to crash
        // when attempting rethrow.
        // /EHa switch also causes structured exceptions to be caught
        // here, but they fill-in current_exception properly, so
        // at worst the output should be a little weird, instead of
        // causing a crash.
        if ( std::current_exception() == nullptr ) {
            return "Non C++ exception. Possibly a CLR exception.";
        }

        // First we try user-registered translators. If none of them can
        // handle the exception, it will be rethrown handled by our defaults.
        try {
            return tryTranslators(m_translators);
        }
        // To avoid having to handle TFE explicitly everywhere, we just
        // rethrow it so that it goes back up the caller.
        catch( TestFailureException& ) {
            std::rethrow_exception(std::current_exception());
        }
        catch( TestSkipException& ) {
            std::rethrow_exception(std::current_exception());
        }
        catch( std::exception const& ex ) {
            return ex.what();
        }
        catch( std::string const& msg ) {
            return msg;
        }
        catch( const char* msg ) {
            return msg;
        }
        catch(...) {
            return "Unknown exception";
        }
    }

#else // ^^ Exceptions are enabled // Exceptions are disabled vv
    std::string ExceptionTranslatorRegistry::translateActiveException() const {
        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
    }
#endif

}



/** \file
 * This file provides platform specific implementations of FatalConditionHandler
 *
 * This means that there is a lot of conditional compilation, and platform
 * specific code. Currently, Catch2 supports a dummy handler (if no
 * handler is desired), and 2 platform specific handlers:
 *  * Windows' SEH
 *  * POSIX signals
 *
 * Consequently, various pieces of code below are compiled if either of
 * the platform specific handlers is enabled, or if none of them are
 * enabled. It is assumed that both cannot be enabled at the same time,
 * and doing so should cause a compilation error.
 *
 * If another platform specific handler is added, the compile guards
 * below will need to be updated taking these assumptions into account.
 */



#include <algorithm>

#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )

namespace Catch {

    // If neither SEH nor signal handling is required, the handler impls
    // do not have to do anything, and can be empty.
    void FatalConditionHandler::engage_platform() {}
    void FatalConditionHandler::disengage_platform() noexcept {}
    FatalConditionHandler::FatalConditionHandler() = default;
    FatalConditionHandler::~FatalConditionHandler() = default;

} // end namespace Catch

#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS

#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS

#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )

namespace {
    //! Signals fatal error message to the run context
    void reportFatal( char const * const message ) {
        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
    }

    //! Minimal size Catch2 needs for its own fatal error handling.
    //! Picked empirically, so it might not be sufficient on all
    //! platforms, and for all configurations.
    constexpr std::size_t minStackSizeForErrors = 32 * 1024;
} // end unnamed namespace

#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS

#if defined( CATCH_CONFIG_WINDOWS_SEH )

namespace Catch {

    struct SignalDefs { DWORD id; const char* name; };

    // There is no 1-1 mapping between signals and windows exceptions.
    // Windows can easily distinguish between SO and SigSegV,
    // but SigInt, SigTerm, etc are handled differently.
    static constexpr SignalDefs signalDefs[] = {
        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
    };

    static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
        for (auto const& def : signalDefs) {
            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
                reportFatal(def.name);
            }
        }
        // If its not an exception we care about, pass it along.
        // This stops us from eating debugger breaks etc.
        return EXCEPTION_CONTINUE_SEARCH;
    }

    // Since we do not support multiple instantiations, we put these
    // into global variables and rely on cleaning them up in outlined
    // constructors/destructors
    static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;


    // For MSVC, we reserve part of the stack memory for handling
    // memory overflow structured exception.
    FatalConditionHandler::FatalConditionHandler() {
        ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
        if (!SetThreadStackGuarantee(&guaranteeSize)) {
            // We do not want to fully error out, because needing
            // the stack reserve should be rare enough anyway.
            Catch::cerr()
                << "Failed to reserve piece of stack."
                << " Stack overflows will not be reported successfully.";
        }
    }

    // We do not attempt to unset the stack guarantee, because
    // Windows does not support lowering the stack size guarantee.
    FatalConditionHandler::~FatalConditionHandler() = default;


    void FatalConditionHandler::engage_platform() {
        // Register as a the top level exception filter.
        previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
    }

    void FatalConditionHandler::disengage_platform() noexcept {
        if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
            Catch::cerr()
                << "Unexpected SEH unhandled exception filter on disengage."
                << " The filter was restored, but might be rolled back unexpectedly.";
        }
        previousTopLevelExceptionFilter = nullptr;
    }

} // end namespace Catch

#endif // CATCH_CONFIG_WINDOWS_SEH

#if defined( CATCH_CONFIG_POSIX_SIGNALS )

#include <signal.h>

namespace Catch {

    struct SignalDefs {
        int id;
        const char* name;
    };

    static constexpr SignalDefs signalDefs[] = {
        { SIGINT,  "SIGINT - Terminal interrupt signal" },
        { SIGILL,  "SIGILL - Illegal instruction signal" },
        { SIGFPE,  "SIGFPE - Floating point error signal" },
        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
        { SIGTERM, "SIGTERM - Termination request signal" },
        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
    };

// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
// which is zero initialization, but not explicit. We want to avoid
// that.
#if defined(__GNUC__)
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif

    static char* altStackMem = nullptr;
    static std::size_t altStackSize = 0;
    static stack_t oldSigStack{};
    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};

    static void restorePreviousSignalHandlers() noexcept {
        // We set signal handlers back to the previous ones. Hopefully
        // nobody overwrote them in the meantime, and doesn't expect
        // their signal handlers to live past ours given that they
        // installed them after ours..
        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
            sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
        }
        // Return the old stack
        sigaltstack(&oldSigStack, nullptr);
    }

    static void handleSignal( int sig ) {
        char const * name = "<unknown signal>";
        for (auto const& def : signalDefs) {
            if (sig == def.id) {
                name = def.name;
                break;
            }
        }
        // We need to restore previous signal handlers and let them do
        // their thing, so that the users can have the debugger break
        // when a signal is raised, and so on.
        restorePreviousSignalHandlers();
        reportFatal( name );
        raise( sig );
    }

    FatalConditionHandler::FatalConditionHandler() {
        assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
        if (altStackSize == 0) {
            altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
        }
        altStackMem = new char[altStackSize]();
    }

    FatalConditionHandler::~FatalConditionHandler() {
        delete[] altStackMem;
        // We signal that another instance can be constructed by zeroing
        // out the pointer.
        altStackMem = nullptr;
    }

    void FatalConditionHandler::engage_platform() {
        stack_t sigStack;
        sigStack.ss_sp = altStackMem;
        sigStack.ss_size = altStackSize;
        sigStack.ss_flags = 0;
        sigaltstack(&sigStack, &oldSigStack);
        struct sigaction sa = { };

        sa.sa_handler = handleSignal;
        sa.sa_flags = SA_ONSTACK;
        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
        }
    }

#if defined(__GNUC__)
#    pragma GCC diagnostic pop
#endif


    void FatalConditionHandler::disengage_platform() noexcept {
        restorePreviousSignalHandlers();
    }

} // end namespace Catch

#endif // CATCH_CONFIG_POSIX_SIGNALS




#include <cstring>

namespace Catch {
    namespace Detail {

        uint32_t convertToBits(float f) {
            static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
            uint32_t i;
            std::memcpy(&i, &f, sizeof(f));
            return i;
        }

        uint64_t convertToBits(double d) {
            static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
            uint64_t i;
            std::memcpy(&i, &d, sizeof(d));
            return i;
        }

#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        bool directCompare( float lhs, float rhs ) { return lhs == rhs; }
        bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic pop
#endif


    } // end namespace Detail
} // end namespace Catch






#include <cstdlib>

namespace Catch {
    namespace Detail {

#if !defined (CATCH_CONFIG_GETENV)
        char const* getEnv( char const* ) { return nullptr; }
#else

        char const* getEnv( char const* varName ) {
#    if defined( _MSC_VER )
#        pragma warning( push )
#        pragma warning( disable : 4996 ) // use getenv_s instead of getenv
#    endif

            return std::getenv( varName );

#    if defined( _MSC_VER )
#        pragma warning( pop )
#    endif
        }
#endif
} // namespace Detail
} // namespace Catch




#include <cstdio>
#include <fstream>

namespace Catch {

    Catch::IStream::~IStream() = default;

namespace Detail {
    namespace {
        template<typename WriterF, std::size_t bufferSize=256>
        class StreamBufImpl final : public std::streambuf {
            char data[bufferSize];
            WriterF m_writer;

        public:
            StreamBufImpl() {
                setp( data, data + sizeof(data) );
            }

            ~StreamBufImpl() noexcept override {
                StreamBufImpl::sync();
            }

        private:
            int overflow( int c ) override {
                sync();

                if( c != EOF ) {
                    if( pbase() == epptr() )
                        m_writer( std::string( 1, static_cast<char>( c ) ) );
                    else
                        sputc( static_cast<char>( c ) );
                }
                return 0;
            }

            int sync() override {
                if( pbase() != pptr() ) {
                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
                    setp( pbase(), epptr() );
                }
                return 0;
            }
        };

        ///////////////////////////////////////////////////////////////////////////

        struct OutputDebugWriter {

            void operator()( std::string const& str ) {
                if ( !str.empty() ) {
                    writeToDebugConsole( str );
                }
            }
        };

        ///////////////////////////////////////////////////////////////////////////

        class FileStream final : public IStream {
            std::ofstream m_ofs;
        public:
            FileStream( std::string const& filename ) {
                m_ofs.open( filename.c_str() );
                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
                m_ofs << std::unitbuf;
            }
        public: // IStream
            std::ostream& stream() override {
                return m_ofs;
            }
        };

        ///////////////////////////////////////////////////////////////////////////

        class CoutStream final : public IStream {
            std::ostream m_os;
        public:
            // Store the streambuf from cout up-front because
            // cout may get redirected when running tests
            CoutStream() : m_os( Catch::cout().rdbuf() ) {}

        public: // IStream
            std::ostream& stream() override { return m_os; }
            bool isConsole() const override { return true; }
        };

        class CerrStream : public IStream {
            std::ostream m_os;

        public:
            // Store the streambuf from cerr up-front because
            // cout may get redirected when running tests
            CerrStream(): m_os( Catch::cerr().rdbuf() ) {}

        public: // IStream
            std::ostream& stream() override { return m_os; }
            bool isConsole() const override { return true; }
        };

        ///////////////////////////////////////////////////////////////////////////

        class DebugOutStream final : public IStream {
            Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
            std::ostream m_os;
        public:
            DebugOutStream()
            :   m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
                m_os( m_streamBuf.get() )
            {}

        public: // IStream
            std::ostream& stream() override { return m_os; }
        };

    } // unnamed namespace
} // namespace Detail

    ///////////////////////////////////////////////////////////////////////////

    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
        if ( filename.empty() || filename == "-" ) {
            return Detail::make_unique<Detail::CoutStream>();
        }
        if( filename[0] == '%' ) {
            if ( filename == "%debug" ) {
                return Detail::make_unique<Detail::DebugOutStream>();
            } else if ( filename == "%stderr" ) {
                return Detail::make_unique<Detail::CerrStream>();
            } else if ( filename == "%stdout" ) {
                return Detail::make_unique<Detail::CoutStream>();
            } else {
                CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
            }
        }
        return Detail::make_unique<Detail::FileStream>( filename );
    }

}



namespace Catch {
    void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
        for ( std::uint64_t i = 0; i < level; ++i ) {
            os << "  ";
        }
    }
    void JsonUtils::appendCommaNewline( std::ostream& os,
                                        bool& should_comma,
                                        std::uint64_t level ) {
        if ( should_comma ) { os << ','; }
        should_comma = true;
        os << '\n';
        indent( os, level );
    }

    JsonObjectWriter::JsonObjectWriter( std::ostream& os ):
        JsonObjectWriter{ os, 0 } {}

    JsonObjectWriter::JsonObjectWriter( std::ostream& os,
                                        std::uint64_t indent_level ):
        m_os{ os }, m_indent_level{ indent_level } {
        m_os << '{';
    }
    JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept:
        m_os{ source.m_os },
        m_indent_level{ source.m_indent_level },
        m_should_comma{ source.m_should_comma },
        m_active{ source.m_active } {
        source.m_active = false;
    }

    JsonObjectWriter::~JsonObjectWriter() {
        if ( !m_active ) { return; }

        m_os << '\n';
        JsonUtils::indent( m_os, m_indent_level );
        m_os << '}';
    }

    JsonValueWriter JsonObjectWriter::write( StringRef key ) {
        JsonUtils::appendCommaNewline(
            m_os, m_should_comma, m_indent_level + 1 );

        m_os << '"' << key << "\": ";
        return JsonValueWriter{ m_os, m_indent_level + 1 };
    }

    JsonArrayWriter::JsonArrayWriter( std::ostream& os ):
        JsonArrayWriter{ os, 0 } {}
    JsonArrayWriter::JsonArrayWriter( std::ostream& os,
                                      std::uint64_t indent_level ):
        m_os{ os }, m_indent_level{ indent_level } {
        m_os << '[';
    }
    JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept:
        m_os{ source.m_os },
        m_indent_level{ source.m_indent_level },
        m_should_comma{ source.m_should_comma },
        m_active{ source.m_active } {
        source.m_active = false;
    }
    JsonArrayWriter::~JsonArrayWriter() {
        if ( !m_active ) { return; }

        m_os << '\n';
        JsonUtils::indent( m_os, m_indent_level );
        m_os << ']';
    }

    JsonObjectWriter JsonArrayWriter::writeObject() {
        JsonUtils::appendCommaNewline(
            m_os, m_should_comma, m_indent_level + 1 );
        return JsonObjectWriter{ m_os, m_indent_level + 1 };
    }

    JsonArrayWriter JsonArrayWriter::writeArray() {
        JsonUtils::appendCommaNewline(
            m_os, m_should_comma, m_indent_level + 1 );
        return JsonArrayWriter{ m_os, m_indent_level + 1 };
    }

    JsonArrayWriter& JsonArrayWriter::write( bool value ) {
        return writeImpl( value );
    }

    JsonValueWriter::JsonValueWriter( std::ostream& os ):
        JsonValueWriter{ os, 0 } {}

    JsonValueWriter::JsonValueWriter( std::ostream& os,
                                      std::uint64_t indent_level ):
        m_os{ os }, m_indent_level{ indent_level } {}

    JsonObjectWriter JsonValueWriter::writeObject() && {
        return JsonObjectWriter{ m_os, m_indent_level };
    }

    JsonArrayWriter JsonValueWriter::writeArray() && {
        return JsonArrayWriter{ m_os, m_indent_level };
    }

    void JsonValueWriter::write( Catch::StringRef value ) && {
        writeImpl( value, true );
    }

    void JsonValueWriter::write( bool value ) && {
        writeImpl( value ? "true"_sr : "false"_sr, false );
    }

    void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
        if ( quote ) { m_os << '"'; }
        for (char c : value) {
            // Escape list taken from https://www.json.org/json-en.html,
            // string definition.
            // Note that while forward slash _can_ be escaped, it does
            // not have to be, if JSON is not further embedded somewhere
            // where forward slash is meaningful.
            if ( c == '"' ) {
                m_os << "\\\"";
            } else if ( c == '\\' ) {
                m_os << "\\\\";
            } else if ( c == '\b' ) {
                m_os << "\\b";
            } else if ( c == '\f' ) {
                m_os << "\\f";
            } else if ( c == '\n' ) {
                m_os << "\\n";
            } else if ( c == '\r' ) {
                m_os << "\\r";
            } else if ( c == '\t' ) {
                m_os << "\\t";
            } else {
                m_os << c;
            }
        }
        if ( quote ) { m_os << '"'; }
    }

} // namespace Catch




namespace Catch {

    auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
        if (lazyExpr.m_isNegated)
            os << '!';

        if (lazyExpr) {
            if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
                os << '(' << *lazyExpr.m_transientExpression << ')';
            else
                os << *lazyExpr.m_transientExpression;
        } else {
            os << "{** error - unchecked empty expression requested **}";
        }
        return os;
    }

} // namespace Catch




#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
#include <crtdbg.h>

namespace Catch {

    LeakDetector::LeakDetector() {
        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
        flag |= _CRTDBG_LEAK_CHECK_DF;
        flag |= _CRTDBG_ALLOC_MEM_DF;
        _CrtSetDbgFlag(flag);
        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
        // Change this to leaking allocation's number to break there
        _CrtSetBreakAlloc(-1);
    }
}

#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv

    Catch::LeakDetector::LeakDetector() = default;

#endif // CATCH_CONFIG_WINDOWS_CRTDBG

Catch::LeakDetector::~LeakDetector() {
    Catch::cleanUp();
}




namespace Catch {
    namespace {

        void listTests(IEventListener& reporter, IConfig const& config) {
            auto const& testSpec = config.testSpec();
            auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
            reporter.listTests(matchedTestCases);
        }

        void listTags(IEventListener& reporter, IConfig const& config) {
            auto const& testSpec = config.testSpec();
            std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);

            std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
            for (auto const& testCase : matchedTestCases) {
                for (auto const& tagName : testCase.getTestCaseInfo().tags) {
                    auto it = tagCounts.find(tagName.original);
                    if (it == tagCounts.end())
                        it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
                    it->second.add(tagName.original);
                }
            }

            std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
            for (auto& tagc : tagCounts) {
                infos.push_back(CATCH_MOVE(tagc.second));
            }

            reporter.listTags(infos);
        }

        void listReporters(IEventListener& reporter) {
            std::vector<ReporterDescription> descriptions;

            auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
            descriptions.reserve(factories.size());
            for (auto const& fac : factories) {
                descriptions.push_back({ fac.first, fac.second->getDescription() });
            }

            reporter.listReporters(descriptions);
        }

        void listListeners(IEventListener& reporter) {
            std::vector<ListenerDescription> descriptions;

            auto const& factories =
                getRegistryHub().getReporterRegistry().getListeners();
            descriptions.reserve( factories.size() );
            for ( auto const& fac : factories ) {
                descriptions.push_back( { fac->getName(), fac->getDescription() } );
            }

            reporter.listListeners( descriptions );
        }

    } // end anonymous namespace

    void TagInfo::add( StringRef spelling ) {
        ++count;
        spellings.insert( spelling );
    }

    std::string TagInfo::all() const {
        // 2 per tag for brackets '[' and ']'
        size_t size =  spellings.size() * 2;
        for (auto const& spelling : spellings) {
            size += spelling.size();
        }

        std::string out; out.reserve(size);
        for (auto const& spelling : spellings) {
            out += '[';
            out += spelling;
            out += ']';
        }
        return out;
    }

    bool list( IEventListener& reporter, Config const& config ) {
        bool listed = false;
        if (config.listTests()) {
            listed = true;
            listTests(reporter, config);
        }
        if (config.listTags()) {
            listed = true;
            listTags(reporter, config);
        }
        if (config.listReporters()) {
            listed = true;
            listReporters(reporter);
        }
        if ( config.listListeners() ) {
            listed = true;
            listListeners( reporter );
        }
        return listed;
    }

} // end namespace Catch



namespace Catch {
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
    static const LeakDetector leakDetector;
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
}

// Allow users of amalgamated .cpp file to remove our main and provide their own.
#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)

#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
// Standard C/C++ Win32 Unicode wmain entry point
extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
#else
// Standard C/C++ main entry point
int main (int argc, char * argv[]) {
#endif

    // We want to force the linker not to discard the global variable
    // and its constructor, as it (optionally) registers leak detector
    (void)&Catch::leakDetector;

    return Catch::Session().run( argc, argv );
}

#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN




namespace Catch {

    MessageInfo::MessageInfo(   StringRef _macroName,
                                SourceLineInfo const& _lineInfo,
                                ResultWas::OfType _type )
    :   macroName( _macroName ),
        lineInfo( _lineInfo ),
        type( _type ),
        sequence( ++globalCount )
    {}

    // This may need protecting if threading support is added
    unsigned int MessageInfo::globalCount = 0;

} // end namespace Catch



#include <cstdio>
#include <cstring>
#include <iosfwd>
#include <sstream>

#if defined( CATCH_CONFIG_NEW_CAPTURE )
#    if defined( _MSC_VER )
#        include <io.h> //_dup and _dup2
#        define dup _dup
#        define dup2 _dup2
#        define fileno _fileno
#    else
#        include <unistd.h> // dup and dup2
#    endif
#endif

namespace Catch {

    namespace {
        //! A no-op implementation, used if no reporter wants output
        //! redirection.
        class NoopRedirect : public OutputRedirect {
            void activateImpl() override {}
            void deactivateImpl() override {}
            std::string getStdout() override { return {}; }
            std::string getStderr() override { return {}; }
            void clearBuffers() override {}
        };

        /**
         * Redirects specific stream's rdbuf with another's.
         *
         * Redirection can be stopped and started on-demand, assumes
         * that the underlying stream's rdbuf aren't changed by other
         * users.
         */
        class RedirectedStreamNew {
            std::ostream& m_originalStream;
            std::ostream& m_redirectionStream;
            std::streambuf* m_prevBuf;

        public:
            RedirectedStreamNew( std::ostream& originalStream,
                                 std::ostream& redirectionStream ):
                m_originalStream( originalStream ),
                m_redirectionStream( redirectionStream ),
                m_prevBuf( m_originalStream.rdbuf() ) {}

            void startRedirect() {
                m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
            }
            void stopRedirect() { m_originalStream.rdbuf( m_prevBuf ); }
        };

        /**
         * Redirects the `std::cout`, `std::cerr`, `std::clog` streams,
         * but does not touch the actual `stdout`/`stderr` file descriptors.
         */
        class StreamRedirect : public OutputRedirect {
            ReusableStringStream m_redirectedOut, m_redirectedErr;
            RedirectedStreamNew m_cout, m_cerr, m_clog;

        public:
            StreamRedirect():
                m_cout( Catch::cout(), m_redirectedOut.get() ),
                m_cerr( Catch::cerr(), m_redirectedErr.get() ),
                m_clog( Catch::clog(), m_redirectedErr.get() ) {}

            void activateImpl() override {
                m_cout.startRedirect();
                m_cerr.startRedirect();
                m_clog.startRedirect();
            }
            void deactivateImpl() override {
                m_cout.stopRedirect();
                m_cerr.stopRedirect();
                m_clog.stopRedirect();
            }
            std::string getStdout() override { return m_redirectedOut.str(); }
            std::string getStderr() override { return m_redirectedErr.str(); }
            void clearBuffers() override {
                m_redirectedOut.str( "" );
                m_redirectedErr.str( "" );
            }
        };

#if defined( CATCH_CONFIG_NEW_CAPTURE )

        // Windows's implementation of std::tmpfile is terrible (it tries
        // to create a file inside system folder, thus requiring elevated
        // privileges for the binary), so we have to use tmpnam(_s) and
        // create the file ourselves there.
        class TempFile {
        public:
            TempFile( TempFile const& ) = delete;
            TempFile& operator=( TempFile const& ) = delete;
            TempFile( TempFile&& ) = delete;
            TempFile& operator=( TempFile&& ) = delete;

#    if defined( _MSC_VER )
            TempFile() {
                if ( tmpnam_s( m_buffer ) ) {
                    CATCH_RUNTIME_ERROR( "Could not get a temp filename" );
                }
                if ( fopen_s( &m_file, m_buffer, "wb+" ) ) {
                    char buffer[100];
                    if ( strerror_s( buffer, errno ) ) {
                        CATCH_RUNTIME_ERROR(
                            "Could not translate errno to a string" );
                    }
                    CATCH_RUNTIME_ERROR( "Could not open the temp file: '"
                                         << m_buffer
                                         << "' because: " << buffer );
                }
            }
#    else
            TempFile() {
                m_file = std::tmpfile();
                if ( !m_file ) {
                    CATCH_RUNTIME_ERROR( "Could not create a temp file." );
                }
            }
#    endif

            ~TempFile() {
                // TBD: What to do about errors here?
                std::fclose( m_file );
                // We manually create the file on Windows only, on Linux
                // it will be autodeleted
#    if defined( _MSC_VER )
                std::remove( m_buffer );
#    endif
            }

            std::FILE* getFile() { return m_file; }
            std::string getContents() {
                ReusableStringStream sstr;
                constexpr long buffer_size = 100;
                char buffer[buffer_size + 1] = {};
                long current_pos = ftell( m_file );
                CATCH_ENFORCE( current_pos >= 0,
                               "ftell failed, errno: " << errno );
                std::rewind( m_file );
                while ( current_pos > 0 ) {
                    auto read_characters =
                        std::fread( buffer,
                                    1,
                                    std::min( buffer_size, current_pos ),
                                    m_file );
                    buffer[read_characters] = '\0';
                    sstr << buffer;
                    current_pos -= static_cast<long>( read_characters );
                }
                return sstr.str();
            }

            void clear() { std::rewind( m_file ); }

        private:
            std::FILE* m_file = nullptr;
            char m_buffer[L_tmpnam] = { 0 };
        };

        /**
         * Redirects the actual `stdout`/`stderr` file descriptors.
         *
         * Works by replacing the file descriptors numbered 1 and 2
         * with an open temporary file.
         */
        class FileRedirect : public OutputRedirect {
            TempFile m_outFile, m_errFile;
            int m_originalOut = -1;
            int m_originalErr = -1;

            // Flushes cout/cerr/clog streams and stdout/stderr FDs
            void flushEverything() {
                Catch::cout() << std::flush;
                fflush( stdout );
                // Since we support overriding these streams, we flush cerr
                // even though std::cerr is unbuffered
                Catch::cerr() << std::flush;
                Catch::clog() << std::flush;
                fflush( stderr );
            }

        public:
            FileRedirect():
                m_originalOut( dup( fileno( stdout ) ) ),
                m_originalErr( dup( fileno( stderr ) ) ) {
                CATCH_ENFORCE( m_originalOut >= 0, "Could not dup stdout" );
                CATCH_ENFORCE( m_originalErr >= 0, "Could not dup stderr" );
            }

            std::string getStdout() override { return m_outFile.getContents(); }
            std::string getStderr() override { return m_errFile.getContents(); }
            void clearBuffers() override {
                m_outFile.clear();
                m_errFile.clear();
            }

            void activateImpl() override {
                // We flush before starting redirect, to ensure that we do
                // not capture the end of message sent before activation.
                flushEverything();

                int ret;
                ret = dup2( fileno( m_outFile.getFile() ), fileno( stdout ) );
                CATCH_ENFORCE( ret >= 0,
                               "dup2 to stdout has failed, errno: " << errno );
                ret = dup2( fileno( m_errFile.getFile() ), fileno( stderr ) );
                CATCH_ENFORCE( ret >= 0,
                               "dup2 to stderr has failed, errno: " << errno );
            }
            void deactivateImpl() override {
                // We flush before ending redirect, to ensure that we
                // capture all messages sent while the redirect was active.
                flushEverything();

                int ret;
                ret = dup2( m_originalOut, fileno( stdout ) );
                CATCH_ENFORCE(
                    ret >= 0,
                    "dup2 of original stdout has failed, errno: " << errno );
                ret = dup2( m_originalErr, fileno( stderr ) );
                CATCH_ENFORCE(
                    ret >= 0,
                    "dup2 of original stderr has failed, errno: " << errno );
            }
        };

#endif // CATCH_CONFIG_NEW_CAPTURE

    } // end namespace

    bool isRedirectAvailable( OutputRedirect::Kind kind ) {
        switch ( kind ) {
        // These two are always available
        case OutputRedirect::None:
        case OutputRedirect::Streams:
            return true;
#if defined( CATCH_CONFIG_NEW_CAPTURE )
        case OutputRedirect::FileDescriptors:
            return true;
#endif
        default:
            return false;
        }
    }

    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual ) {
        if ( actual ) {
            // TODO: Clean this up later
#if defined( CATCH_CONFIG_NEW_CAPTURE )
            return Detail::make_unique<FileRedirect>();
#else
            return Detail::make_unique<StreamRedirect>();
#endif
        } else {
            return Detail::make_unique<NoopRedirect>();
        }
    }

    RedirectGuard scopedActivate( OutputRedirect& redirectImpl ) {
        return RedirectGuard( true, redirectImpl );
    }

    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl ) {
        return RedirectGuard( false, redirectImpl );
    }

    OutputRedirect::~OutputRedirect() = default;

    RedirectGuard::RedirectGuard( bool activate, OutputRedirect& redirectImpl ):
        m_redirect( &redirectImpl ),
        m_activate( activate ),
        m_previouslyActive( redirectImpl.isActive() ) {

        // Skip cases where there is no actual state change.
        if ( m_activate == m_previouslyActive ) { return; }

        if ( m_activate ) {
            m_redirect->activate();
        } else {
            m_redirect->deactivate();
        }
    }

    RedirectGuard::~RedirectGuard() noexcept( false ) {
        if ( m_moved ) { return; }
        // Skip cases where there is no actual state change.
        if ( m_activate == m_previouslyActive ) { return; }

        if ( m_activate ) {
            m_redirect->deactivate();
        } else {
            m_redirect->activate();
        }
    }

    RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept:
        m_redirect( rhs.m_redirect ),
        m_activate( rhs.m_activate ),
        m_previouslyActive( rhs.m_previouslyActive ),
        m_moved( false ) {
        rhs.m_moved = true;
    }

    RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept {
        m_redirect = rhs.m_redirect;
        m_activate = rhs.m_activate;
        m_previouslyActive = rhs.m_previouslyActive;
        m_moved = false;
        rhs.m_moved = true;
        return *this;
    }

} // namespace Catch

#if defined( CATCH_CONFIG_NEW_CAPTURE )
#    if defined( _MSC_VER )
#        undef dup
#        undef dup2
#        undef fileno
#    endif
#endif




#include <limits>
#include <stdexcept>

namespace Catch {

    Optional<unsigned int> parseUInt(std::string const& input, int base) {
        auto trimmed = trim( input );
        // std::stoull is annoying and accepts numbers starting with '-',
        // it just negates them into unsigned int
        if ( trimmed.empty() || trimmed[0] == '-' ) {
            return {};
        }

        CATCH_TRY {
            size_t pos = 0;
            const auto ret = std::stoull( trimmed, &pos, base );

            // We did not consume the whole input, so there is an issue
            // This can be bunch of different stuff, like multiple numbers
            // in the input, or invalid digits/characters and so on. Either
            // way, we do not want to return the partially parsed result.
            if ( pos != trimmed.size() ) {
                return {};
            }
            // Too large
            if ( ret > std::numeric_limits<unsigned int>::max() ) {
                return {};
            }
            return static_cast<unsigned int>(ret);
        }
        CATCH_CATCH_ANON( std::invalid_argument const& ) {
            // no conversion could be performed
        }
        CATCH_CATCH_ANON( std::out_of_range const& ) {
            // the input does not fit into an unsigned long long
        }
        return {};
    }

} // namespace Catch




#include <cmath>

namespace Catch {

#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
    bool isnan(float f) {
        return std::isnan(f);
    }
    bool isnan(double d) {
        return std::isnan(d);
    }
#else
    // For now we only use this for embarcadero
    bool isnan(float f) {
        return std::_isnan(f);
    }
    bool isnan(double d) {
        return std::_isnan(d);
    }
#endif

#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER )
    float nextafter( float x, float y ) { return std::nextafter( x, y ); }
    double nextafter( double x, double y ) { return std::nextafter( x, y ); }
#else
    float nextafter( float x, float y ) { return ::nextafterf( x, y ); }
    double nextafter( double x, double y ) { return ::nextafter( x, y ); }
#endif

} // end namespace Catch



#if defined( __clang__ )
#    define CATCH2_CLANG_NO_SANITIZE_INTEGER \
        __attribute__( ( no_sanitize( "unsigned-integer-overflow" ) ) )
#else
#    define CATCH2_CLANG_NO_SANITIZE_INTEGER
#endif
namespace Catch {

namespace {

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4146) // we negate uint32 during the rotate
#endif
        // Safe rotr implementation thanks to John Regehr
        CATCH2_CLANG_NO_SANITIZE_INTEGER
        uint32_t rotate_right(uint32_t val, uint32_t count) {
            const uint32_t mask = 31;
            count &= mask;
            return (val >> count) | (val << (-count & mask));
        }

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

}


    SimplePcg32::SimplePcg32(result_type seed_) {
        seed(seed_);
    }


    void SimplePcg32::seed(result_type seed_) {
        m_state = 0;
        (*this)();
        m_state += seed_;
        (*this)();
    }

    void SimplePcg32::discard(uint64_t skip) {
        // We could implement this to run in O(log n) steps, but this
        // should suffice for our use case.
        for (uint64_t s = 0; s < skip; ++s) {
            static_cast<void>((*this)());
        }
    }

    CATCH2_CLANG_NO_SANITIZE_INTEGER
    SimplePcg32::result_type SimplePcg32::operator()() {
        // prepare the output value
        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
        const auto output = rotate_right(xorshifted, static_cast<uint32_t>(m_state >> 59u));

        // advance state
        m_state = m_state * 6364136223846793005ULL + s_inc;

        return output;
    }

    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
        return lhs.m_state == rhs.m_state;
    }

    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
        return lhs.m_state != rhs.m_state;
    }
}





#include <ctime>
#include <random>

namespace Catch {

    std::uint32_t generateRandomSeed( GenerateFrom from ) {
        switch ( from ) {
        case GenerateFrom::Time:
            return static_cast<std::uint32_t>( std::time( nullptr ) );

        case GenerateFrom::Default:
        case GenerateFrom::RandomDevice: {
            std::random_device rd;
            return Detail::fillBitsFrom<std::uint32_t>( rd );
        }

        default:
            CATCH_ERROR("Unknown generation method");
        }
    }

} // end namespace Catch




namespace Catch {
    struct ReporterRegistry::ReporterRegistryImpl {
        std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
        std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
            factories;
    };

    ReporterRegistry::ReporterRegistry():
        m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
        // Because it is impossible to move out of initializer list,
        // we have to add the elements manually
        m_impl->factories["Automake"] =
            Detail::make_unique<ReporterFactory<AutomakeReporter>>();
        m_impl->factories["compact"] =
            Detail::make_unique<ReporterFactory<CompactReporter>>();
        m_impl->factories["console"] =
            Detail::make_unique<ReporterFactory<ConsoleReporter>>();
        m_impl->factories["JUnit"] =
            Detail::make_unique<ReporterFactory<JunitReporter>>();
        m_impl->factories["SonarQube"] =
            Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
        m_impl->factories["TAP"] =
            Detail::make_unique<ReporterFactory<TAPReporter>>();
        m_impl->factories["TeamCity"] =
            Detail::make_unique<ReporterFactory<TeamCityReporter>>();
        m_impl->factories["XML"] =
            Detail::make_unique<ReporterFactory<XmlReporter>>();
        m_impl->factories["JSON"] =
            Detail::make_unique<ReporterFactory<JsonReporter>>();
    }

    ReporterRegistry::~ReporterRegistry() = default;

    IEventListenerPtr
    ReporterRegistry::create( std::string const& name,
                              ReporterConfig&& config ) const {
        auto it = m_impl->factories.find( name );
        if ( it == m_impl->factories.end() ) return nullptr;
        return it->second->create( CATCH_MOVE( config ) );
    }

    void ReporterRegistry::registerReporter( std::string const& name,
                                             IReporterFactoryPtr factory ) {
        CATCH_ENFORCE( name.find( "::" ) == name.npos,
                       "'::' is not allowed in reporter name: '" + name +
                           '\'' );
        auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
        CATCH_ENFORCE( ret.second,
                       "reporter using '" + name +
                           "' as name was already registered" );
    }
    void ReporterRegistry::registerListener(
        Detail::unique_ptr<EventListenerFactory> factory ) {
        m_impl->listeners.push_back( CATCH_MOVE( factory ) );
    }

    std::map<std::string,
             IReporterFactoryPtr,
             Detail::CaseInsensitiveLess> const&
    ReporterRegistry::getFactories() const {
        return m_impl->factories;
    }

    std::vector<Detail::unique_ptr<EventListenerFactory>> const&
    ReporterRegistry::getListeners() const {
        return m_impl->listeners;
    }
} // namespace Catch





#include <algorithm>

namespace Catch {

    namespace {
        struct kvPair {
            StringRef key, value;
        };

        kvPair splitKVPair(StringRef kvString) {
            auto splitPos = static_cast<size_t>(
                std::find( kvString.begin(), kvString.end(), '=' ) -
                kvString.begin() );

            return { kvString.substr( 0, splitPos ),
                     kvString.substr( splitPos + 1, kvString.size() ) };
        }
    }

    namespace Detail {
        std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
            static constexpr auto separator = "::";
            static constexpr size_t separatorSize = 2;

            size_t separatorPos = 0;
            auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
                static_assert(
                    separatorSize == 2,
                    "The code below currently assumes 2 char separator" );

                auto currentPos = startPos;
                do {
                    while ( currentPos < reporterSpec.size() &&
                            reporterSpec[currentPos] != separator[0] ) {
                        ++currentPos;
                    }
                    if ( currentPos + 1 < reporterSpec.size() &&
                         reporterSpec[currentPos + 1] == separator[1] ) {
                        return currentPos;
                    }
                    ++currentPos;
                } while ( currentPos < reporterSpec.size() );

                return static_cast<size_t>( -1 );
            };

            std::vector<std::string> parts;

            while ( separatorPos < reporterSpec.size() ) {
                const auto nextSeparator = findNextSeparator( separatorPos );
                parts.push_back( static_cast<std::string>( reporterSpec.substr(
                    separatorPos, nextSeparator - separatorPos ) ) );

                if ( nextSeparator == static_cast<size_t>( -1 ) ) {
                    break;
                }
                separatorPos = nextSeparator + separatorSize;
            }

            // Handle a separator at the end.
            // This is not a valid spec, but we want to do validation in a
            // centralized place
            if ( separatorPos == reporterSpec.size() ) {
                parts.emplace_back();
            }

            return parts;
        }

        Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
            if ( colourMode == "default" ) {
                return ColourMode::PlatformDefault;
            } else if ( colourMode == "ansi" ) {
                return ColourMode::ANSI;
            } else if ( colourMode == "win32" ) {
                return ColourMode::Win32;
            } else if ( colourMode == "none" ) {
                return ColourMode::None;
            } else {
                return {};
            }
        }
    } // namespace Detail


    bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
        return lhs.m_name == rhs.m_name &&
               lhs.m_outputFileName == rhs.m_outputFileName &&
               lhs.m_colourMode == rhs.m_colourMode &&
               lhs.m_customOptions == rhs.m_customOptions;
    }

    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
        auto parts = Detail::splitReporterSpec( reporterSpec );

        assert( parts.size() > 0 && "Split should never return empty vector" );

        std::map<std::string, std::string> kvPairs;
        Optional<std::string> outputFileName;
        Optional<ColourMode> colourMode;

        // First part is always reporter name, so we skip it
        for ( size_t i = 1; i < parts.size(); ++i ) {
            auto kv = splitKVPair( parts[i] );
            auto key = kv.key, value = kv.value;

            if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone)
                return {};
            } else if ( key[0] == 'X' ) {
                // This is a reporter-specific option, we don't check these
                // apart from basic sanity checks
                if ( key.size() == 1 ) {
                    return {};
                }

                auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
                if ( !ret.second ) {
                    // Duplicated key. We might want to handle this differently,
                    // e.g. by overwriting the existing value?
                    return {};
                }
            } else if ( key == "out" ) {
                // Duplicated key
                if ( outputFileName ) {
                    return {};
                }
                outputFileName = static_cast<std::string>( value );
            } else if ( key == "colour-mode" ) {
                // Duplicated key
                if ( colourMode ) {
                    return {};
                }
                colourMode = Detail::stringToColourMode( value );
                // Parsing failed
                if ( !colourMode ) {
                    return {};
                }
            } else {
                // Unrecognized option
                return {};
            }
        }

        return ReporterSpec{ CATCH_MOVE( parts[0] ),
                             CATCH_MOVE( outputFileName ),
                             CATCH_MOVE( colourMode ),
                             CATCH_MOVE( kvPairs ) };
    }

ReporterSpec::ReporterSpec(
        std::string name,
        Optional<std::string> outputFileName,
        Optional<ColourMode> colourMode,
        std::map<std::string, std::string> customOptions ):
        m_name( CATCH_MOVE( name ) ),
        m_outputFileName( CATCH_MOVE( outputFileName ) ),
        m_colourMode( CATCH_MOVE( colourMode ) ),
        m_customOptions( CATCH_MOVE( customOptions ) ) {}

} // namespace Catch



#include <cstdio>
#include <sstream>
#include <vector>

namespace Catch {

    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
    struct StringStreams {
        std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
        std::vector<std::size_t> m_unused;
        std::ostringstream m_referenceStream; // Used for copy state/ flags from

        auto add() -> std::size_t {
            if( m_unused.empty() ) {
                m_streams.push_back( Detail::make_unique<std::ostringstream>() );
                return m_streams.size()-1;
            }
            else {
                auto index = m_unused.back();
                m_unused.pop_back();
                return index;
            }
        }

        void release( std::size_t index ) {
            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
            m_unused.push_back(index);
        }
    };

    ReusableStringStream::ReusableStringStream()
    :   m_index( Singleton<StringStreams>::getMutable().add() ),
        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
    {}

    ReusableStringStream::~ReusableStringStream() {
        static_cast<std::ostringstream*>( m_oss )->str("");
        m_oss->clear();
        Singleton<StringStreams>::getMutable().release( m_index );
    }

    std::string ReusableStringStream::str() const {
        return static_cast<std::ostringstream*>( m_oss )->str();
    }

    void ReusableStringStream::str( std::string const& str ) {
        static_cast<std::ostringstream*>( m_oss )->str( str );
    }


}




#include <cassert>
#include <algorithm>

namespace Catch {

    namespace Generators {
        namespace {
            struct GeneratorTracker final : TestCaseTracking::TrackerBase,
                                      IGeneratorTracker {
                GeneratorBasePtr m_generator;

                GeneratorTracker(
                    TestCaseTracking::NameAndLocation&& nameAndLocation,
                    TrackerContext& ctx,
                    ITracker* parent ):
                    TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}

                static GeneratorTracker*
                acquire( TrackerContext& ctx,
                         TestCaseTracking::NameAndLocationRef const&
                             nameAndLocation ) {
                    GeneratorTracker* tracker;

                    ITracker& currentTracker = ctx.currentTracker();
                    // Under specific circumstances, the generator we want
                    // to acquire is also the current tracker. If this is
                    // the case, we have to avoid looking through current
                    // tracker's children, and instead return the current
                    // tracker.
                    // A case where this check is important is e.g.
                    //     for (int i = 0; i < 5; ++i) {
                    //         int n = GENERATE(1, 2);
                    //     }
                    //
                    // without it, the code above creates 5 nested generators.
                    if ( currentTracker.nameAndLocation() == nameAndLocation ) {
                        auto thisTracker = currentTracker.parent()->findChild(
                            nameAndLocation );
                        assert( thisTracker );
                        assert( thisTracker->isGeneratorTracker() );
                        tracker = static_cast<GeneratorTracker*>( thisTracker );
                    } else if ( ITracker* childTracker =
                                    currentTracker.findChild(
                                        nameAndLocation ) ) {
                        assert( childTracker );
                        assert( childTracker->isGeneratorTracker() );
                        tracker =
                            static_cast<GeneratorTracker*>( childTracker );
                    } else {
                        return nullptr;
                    }

                    if ( !tracker->isComplete() ) { tracker->open(); }

                    return tracker;
                }

                // TrackerBase interface
                bool isGeneratorTracker() const override { return true; }
                auto hasGenerator() const -> bool override {
                    return !!m_generator;
                }
                void close() override {
                    TrackerBase::close();
                    // If a generator has a child (it is followed by a section)
                    // and none of its children have started, then we must wait
                    // until later to start consuming its values.
                    // This catches cases where `GENERATE` is placed between two
                    // `SECTION`s.
                    // **The check for m_children.empty cannot be removed**.
                    // doing so would break `GENERATE` _not_ followed by
                    // `SECTION`s.
                    const bool should_wait_for_child = [&]() {
                        // No children -> nobody to wait for
                        if ( m_children.empty() ) { return false; }
                        // If at least one child started executing, don't wait
                        if ( std::find_if(
                                 m_children.begin(),
                                 m_children.end(),
                                 []( TestCaseTracking::ITrackerPtr const&
                                         tracker ) {
                                     return tracker->hasStarted();
                                 } ) != m_children.end() ) {
                            return false;
                        }

                        // No children have started. We need to check if they
                        // _can_ start, and thus we should wait for them, or
                        // they cannot start (due to filters), and we shouldn't
                        // wait for them
                        ITracker* parent = m_parent;
                        // This is safe: there is always at least one section
                        // tracker in a test case tracking tree
                        while ( !parent->isSectionTracker() ) {
                            parent = parent->parent();
                        }
                        assert( parent &&
                                "Missing root (test case) level section" );

                        auto const& parentSection =
                            static_cast<SectionTracker const&>( *parent );
                        auto const& filters = parentSection.getFilters();
                        // No filters -> no restrictions on running sections
                        if ( filters.empty() ) { return true; }

                        for ( auto const& child : m_children ) {
                            if ( child->isSectionTracker() &&
                                 std::find( filters.begin(),
                                            filters.end(),
                                            static_cast<SectionTracker const&>(
                                                *child )
                                                .trimmedName() ) !=
                                     filters.end() ) {
                                return true;
                            }
                        }
                        return false;
                    }();

                    // This check is a bit tricky, because m_generator->next()
                    // has a side-effect, where it consumes generator's current
                    // value, but we do not want to invoke the side-effect if
                    // this generator is still waiting for any child to start.
                    assert( m_generator && "Tracker without generator" );
                    if ( should_wait_for_child ||
                         ( m_runState == CompletedSuccessfully &&
                           m_generator->countedNext() ) ) {
                        m_children.clear();
                        m_runState = Executing;
                    }
                }

                // IGeneratorTracker interface
                auto getGenerator() const -> GeneratorBasePtr const& override {
                    return m_generator;
                }
                void setGenerator( GeneratorBasePtr&& generator ) override {
                    m_generator = CATCH_MOVE( generator );
                }
            };
        } // namespace
    }

    namespace Detail {
        // Assertions are owned by the thread that is executing them.
        // This allows for lock-free progress in common cases where we
        // do not need to send the assertion events to the reporter.
        // This also implies that messages are owned by their respective
        // threads, and should not be shared across different threads.
        //
        // For simplicity, we disallow messages in multi-threaded contexts,
        // but in the future we can enable them under this logic.
        //
        // This implies that various pieces of metadata referring to last
        // assertion result/source location/message handling, etc
        // should also be thread local. For now we just use naked globals
        // below, in the future we will want to allocate piece of memory
        // from heap, to avoid consuming too much thread-local storage.

        // This is used for the "if" part of CHECKED_IF/CHECKED_ELSE
        static thread_local bool g_lastAssertionPassed = false;
        // Should we clear message scopes before sending off the messages to
        // reporter? Set in `assertionPassedFastPath` to avoid doing the full
        // clear there for performance reasons.
        static thread_local bool g_clearMessageScopes = false;
        // This is the source location for last encountered macro. It is
        // used to provide the users with more precise location of error
        // when an unexpected exception/fatal error happens.
        static thread_local SourceLineInfo g_lastKnownLineInfo("DummyLocation", static_cast<size_t>(-1));
    }

    RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
    :   m_runInfo(_config->name()),
        m_config(_config),
        m_reporter(CATCH_MOVE(reporter)),
        m_outputRedirect( makeOutputRedirect( m_reporter->getPreferences().shouldRedirectStdOut ) ),
        m_abortAfterXFailedAssertions( m_config->abortAfter() ),
        m_reportAssertionStarting( m_reporter->getPreferences().shouldReportAllAssertionStarts ),
        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions ),
        m_shouldDebugBreak( m_config->shouldDebugBreak() )
    {
        getCurrentMutableContext().setResultCapture( this );
        m_reporter->testRunStarting(m_runInfo);
    }

    RunContext::~RunContext() {
        updateTotalsFromAtomics();
        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
    }

    Totals RunContext::runTest(TestCaseHandle const& testCase) {
        updateTotalsFromAtomics();
        const Totals prevTotals = m_totals;

        auto const& testInfo = testCase.getTestCaseInfo();
        m_reporter->testCaseStarting(testInfo);
        testCase.prepareTestCase();
        m_activeTestCase = &testCase;


        ITracker& rootTracker = m_trackerContext.startRun();
        assert(rootTracker.isSectionTracker());
        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());

        // We intentionally only seed the internal RNG once per test case,
        // before it is first invoked. The reason for that is a complex
        // interplay of generator/section implementation details and the
        // Random*Generator types.
        //
        // The issue boils down to us needing to seed the Random*Generators
        // with different seed each, so that they return different sequences
        // of random numbers. We do this by giving them a number from the
        // shared RNG instance as their seed.
        //
        // However, this runs into an issue if the reseeding happens each
        // time the test case is entered (as opposed to first time only),
        // because multiple generators could get the same seed, e.g. in
        // ```cpp
        // TEST_CASE() {
        //     auto i = GENERATE(take(10, random(0, 100));
        //     SECTION("A") {
        //         auto j = GENERATE(take(10, random(0, 100));
        //     }
        //     SECTION("B") {
        //         auto k = GENERATE(take(10, random(0, 100));
        //     }
        // }
        // ```
        // `i` and `j` would properly return values from different sequences,
        // but `i` and `k` would return the same sequence, because their seed
        // would be the same.
        // (The reason their seeds would be the same is that the generator
        //  for k would be initialized when the test case is entered the second
        //  time, after the shared RNG instance was reset to the same value
        //  it had when the generator for i was initialized.)
        seedRng( *m_config );

        uint64_t testRuns = 0;
        std::string redirectedCout;
        std::string redirectedCerr;
        do {
            m_trackerContext.startCycle();
            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));

            m_reporter->testCasePartialStarting(testInfo, testRuns);

            updateTotalsFromAtomics();
            const auto beforeRunTotals = m_totals;
            runCurrentTest();
            std::string oneRunCout = m_outputRedirect->getStdout();
            std::string oneRunCerr = m_outputRedirect->getStderr();
            m_outputRedirect->clearBuffers();
            redirectedCout += oneRunCout;
            redirectedCerr += oneRunCerr;

            updateTotalsFromAtomics();
            const auto singleRunTotals = m_totals.delta(beforeRunTotals);
            auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
            m_reporter->testCasePartialEnded(statsForOneRun, testRuns);

            ++testRuns;
        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());

        Totals deltaTotals = m_totals.delta(prevTotals);
        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
            deltaTotals.assertions.failed++;
            deltaTotals.testCases.passed--;
            deltaTotals.testCases.failed++;
        }
        m_totals.testCases += deltaTotals.testCases;
        testCase.tearDownTestCase();
        m_reporter->testCaseEnded(TestCaseStats(testInfo,
                                  deltaTotals,
                                  CATCH_MOVE(redirectedCout),
                                  CATCH_MOVE(redirectedCerr),
                                  aborting()));

        m_activeTestCase = nullptr;
        m_testCaseTracker = nullptr;

        return deltaTotals;
    }


    void RunContext::assertionEnded(AssertionResult&& result) {
        Detail::g_lastKnownLineInfo = result.m_info.lineInfo;
        if (result.getResultType() == ResultWas::Ok) {
            m_atomicAssertionCount.passed++;
            Detail::g_lastAssertionPassed = true;
        } else if (result.getResultType() == ResultWas::ExplicitSkip) {
            m_atomicAssertionCount.skipped++;
            Detail::g_lastAssertionPassed = true;
        } else if (!result.succeeded()) {
            Detail::g_lastAssertionPassed = false;
            if (result.isOk()) {
            }
            else if( m_activeTestCase->getTestCaseInfo().okToFail() ) // Read from a shared state established before the threads could start, this is fine
                m_atomicAssertionCount.failedButOk++;
            else
                m_atomicAssertionCount.failed++;
        }
        else {
            Detail::g_lastAssertionPassed = true;
        }

        // From here, we are touching shared state and need mutex.
        Detail::LockGuard lock( m_assertionMutex );
        {
            if ( Detail::g_clearMessageScopes ) {
                m_messageScopes.clear();
                Detail::g_clearMessageScopes = false;
            }
            auto _ = scopedDeactivate( *m_outputRedirect );
            updateTotalsFromAtomics();
            m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) );
        }

        if ( result.getResultType() != ResultWas::Warning ) {
            m_messageScopes.clear();
        }

        // Reset working state. assertion info will be reset after
        // populateReaction is run if it is needed
        m_lastResult = CATCH_MOVE( result );
    }

    void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
        if (m_reportAssertionStarting) {
            Detail::LockGuard lock( m_assertionMutex );
            auto _ = scopedDeactivate( *m_outputRedirect );
            m_reporter->assertionStarting( info );
        }
    }

    bool RunContext::sectionStarted( StringRef sectionName,
                                     SourceLineInfo const& sectionLineInfo,
                                     Counts& assertions ) {
        ITracker& sectionTracker =
            SectionTracker::acquire( m_trackerContext,
                                     TestCaseTracking::NameAndLocationRef(
                                         sectionName, sectionLineInfo ) );

        if (!sectionTracker.isOpen())
            return false;
        m_activeSections.push_back(&sectionTracker);

        SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
        Detail::g_lastKnownLineInfo = sectionLineInfo;

        {
            auto _ = scopedDeactivate( *m_outputRedirect );
            m_reporter->sectionStarting( sectionInfo );
        }

        updateTotalsFromAtomics();
        assertions = m_totals.assertions;

        return true;
    }
    IGeneratorTracker*
    RunContext::acquireGeneratorTracker( StringRef generatorName,
                                         SourceLineInfo const& lineInfo ) {
        auto* tracker = Generators::GeneratorTracker::acquire(
            m_trackerContext,
            TestCaseTracking::NameAndLocationRef(
                 generatorName, lineInfo ) );
        Detail::g_lastKnownLineInfo = lineInfo;
        return tracker;
    }

    IGeneratorTracker* RunContext::createGeneratorTracker(
        StringRef generatorName,
        SourceLineInfo lineInfo,
        Generators::GeneratorBasePtr&& generator ) {

        auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
        auto& currentTracker = m_trackerContext.currentTracker();
        assert(
            currentTracker.nameAndLocation() != nameAndLoc &&
            "Trying to create tracker for a generator that already has one" );

        auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
            CATCH_MOVE(nameAndLoc), m_trackerContext, &currentTracker );
        auto ret = newTracker.get();
        currentTracker.addChild( CATCH_MOVE( newTracker ) );

        ret->setGenerator( CATCH_MOVE( generator ) );
        ret->open();
        return ret;
    }

    bool RunContext::testForMissingAssertions(Counts& assertions) {
        if (assertions.total() != 0)
            return false;
        if (!m_config->warnAboutMissingAssertions())
            return false;
        if (m_trackerContext.currentTracker().hasChildren())
            return false;
        m_atomicAssertionCount.failed++;
        assertions.failed++;
        return true;
    }

    void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
        updateTotalsFromAtomics();
        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
        bool missingAssertions = testForMissingAssertions(assertions);

        if (!m_activeSections.empty()) {
            m_activeSections.back()->close();
            m_activeSections.pop_back();
        }

        {
            auto _ = scopedDeactivate( *m_outputRedirect );
            m_reporter->sectionEnded(
                SectionStats( CATCH_MOVE( endInfo.sectionInfo ),
                              assertions,
                              endInfo.durationInSeconds,
                              missingAssertions ) );
        }
    }

    void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
        if ( m_unfinishedSections.empty() ) {
            m_activeSections.back()->fail();
        } else {
            m_activeSections.back()->close();
        }
        m_activeSections.pop_back();

        m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
    }

    void RunContext::benchmarkPreparing( StringRef name ) {
        auto _ = scopedDeactivate( *m_outputRedirect );
        m_reporter->benchmarkPreparing( name );
    }
    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
        auto _ = scopedDeactivate( *m_outputRedirect );
        m_reporter->benchmarkStarting( info );
    }
    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
        auto _ = scopedDeactivate( *m_outputRedirect );
        m_reporter->benchmarkEnded( stats );
    }
    void RunContext::benchmarkFailed( StringRef error ) {
        auto _ = scopedDeactivate( *m_outputRedirect );
        m_reporter->benchmarkFailed( error );
    }

    void RunContext::pushScopedMessage(MessageInfo const & message) {
        m_messages.push_back(message);
    }

    void RunContext::popScopedMessage( MessageInfo const& message ) {
        // Note: On average, it would probably be better to look for the message
        //       backwards. However, we do not expect to have to deal with more
        //       messages than low single digits, so the optimization is tiny,
        //       and we would have to hand-write the loop to avoid terrible
        //       codegen of reverse iterators in debug mode.
        m_messages.erase(
            std::find_if( m_messages.begin(),
                          m_messages.end(),
                          [id = message.sequence]( MessageInfo const& msg ) {
                              return msg.sequence == id;
                          } ) );
    }

    void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
        m_messageScopes.emplace_back( CATCH_MOVE(builder) );
    }

    std::string RunContext::getCurrentTestName() const {
        return m_activeTestCase
            ? m_activeTestCase->getTestCaseInfo().name
            : std::string();
    }

    const AssertionResult * RunContext::getLastResult() const {
        // m_lastResult is updated inside the assertion slow-path, under
        // a mutex, so the read needs to happen under mutex as well.

        // TBD: The last result only makes sense if it is a thread-local
        //      thing, because the answer is different per thread, like
        //      last line info, whether last assertion passed, and so on.
        //
        //      However, the last result was also never updated in the
        //      assertion fast path, so it was always somewhat broken,
        //      and since IResultCapture::getLastResult is deprecated,
        //      we will leave it as is, until it is finally removed.
        Detail::LockGuard _( m_assertionMutex );
        return &(*m_lastResult);
    }

    void RunContext::exceptionEarlyReported() {
        m_shouldReportUnexpected = false;
    }

    void RunContext::handleFatalErrorCondition( StringRef message ) {
        // We lock only when touching the reporters directly, to avoid
        // deadlocks when we call into other functions that also want
        // to lock the mutex before touching reporters.
        //
        // This does mean that we allow other threads to run while handling
        // a fatal error, but this is all a best effort attempt anyway.
        {
            Detail::LockGuard lock( m_assertionMutex );
            // TODO: scoped deactivate here? Just give up and do best effort?
            //       the deactivation can break things further, OTOH so can the
            //       capture
            auto _ = scopedDeactivate( *m_outputRedirect );

            // First notify reporter that bad things happened
            m_reporter->fatalErrorEncountered( message );
        }

        // Don't rebuild the result -- the stringification itself can cause more fatal errors
        // Instead, fake a result data.
        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
        tempResult.message = static_cast<std::string>(message);
        AssertionResult result( makeDummyAssertionInfo(),
                                CATCH_MOVE( tempResult ) );

        assertionEnded(CATCH_MOVE(result) );


        // At this point we touch sections/test cases from this thread
        // to try and end them. Technically that is not supported when
        // using multiple threads, but the worst thing that can happen
        // is that the process aborts harder :-D
        Detail::LockGuard lock( m_assertionMutex );

        // Best effort cleanup for sections that have not been destructed yet
        // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
        while (!m_activeSections.empty()) {
            auto const& nl = m_activeSections.back()->nameAndLocation();
            SectionEndInfo endInfo{ SectionInfo(nl.location, nl.name), {}, 0.0 };
            sectionEndedEarly(CATCH_MOVE(endInfo));
        }
        handleUnfinishedSections();

        // Recreate section for test case (as we will lose the one that was in scope)
        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);

        Counts assertions;
        assertions.failed = 1;
        SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
        m_reporter->sectionEnded( testCaseSectionStats );

        auto const& testInfo = m_activeTestCase->getTestCaseInfo();

        Totals deltaTotals;
        deltaTotals.testCases.failed = 1;
        deltaTotals.assertions.failed = 1;
        m_reporter->testCaseEnded(TestCaseStats(testInfo,
                                  deltaTotals,
                                  std::string(),
                                  std::string(),
                                  false));
        m_totals.testCases.failed++;
        updateTotalsFromAtomics();
        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
    }

    bool RunContext::lastAssertionPassed() {
        return Detail::g_lastAssertionPassed;
    }

    void RunContext::assertionPassedFastPath(SourceLineInfo lineInfo) {
        // We want to save the line info for better experience with unexpected assertions
        Detail::g_lastKnownLineInfo = lineInfo;
        ++m_atomicAssertionCount.passed;
        Detail::g_lastAssertionPassed = true;
        Detail::g_clearMessageScopes = true;
    }

    void RunContext::updateTotalsFromAtomics() {
        m_totals.assertions = Counts{
            m_atomicAssertionCount.passed,
            m_atomicAssertionCount.failed,
            m_atomicAssertionCount.failedButOk,
            m_atomicAssertionCount.skipped,
        };
    }

    bool RunContext::aborting() const {
        return m_atomicAssertionCount.failed >= m_abortAfterXFailedAssertions;
    }

    void RunContext::runCurrentTest() {
        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
        m_reporter->sectionStarting(testCaseSection);
        updateTotalsFromAtomics();
        Counts prevAssertions = m_totals.assertions;
        double duration = 0;
        m_shouldReportUnexpected = true;
        Detail::g_lastKnownLineInfo = testCaseInfo.lineInfo;

        Timer timer;
        CATCH_TRY {
            {
                auto _ = scopedActivate( *m_outputRedirect );
                timer.start();
                invokeActiveTestCase();
            }
            duration = timer.getElapsedSeconds();
        } CATCH_CATCH_ANON (TestFailureException&) {
            // This just means the test was aborted due to failure
        } CATCH_CATCH_ANON (TestSkipException&) {
            // This just means the test was explicitly skipped
        } CATCH_CATCH_ALL {
            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
            // are reported without translation at the point of origin.
            if ( m_shouldReportUnexpected ) {
                AssertionReaction dummyReaction;
                handleUnexpectedInflightException( makeDummyAssertionInfo(),
                                                   translateActiveException(),
                                                   dummyReaction );
            }
        }
        updateTotalsFromAtomics();
        Counts assertions = m_totals.assertions - prevAssertions;
        bool missingAssertions = testForMissingAssertions(assertions);

        m_testCaseTracker->close();
        handleUnfinishedSections();
        m_messageScopes.clear();
        // TBD: At this point, m_messages should be empty. Do we want to
        //      assert that this is true, or keep the defensive clear call?
        m_messages.clear();

        SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
        m_reporter->sectionEnded(testCaseSectionStats);
    }

    void RunContext::invokeActiveTestCase() {
        // We need to engage a handler for signals/structured exceptions
        // before running the tests themselves, or the binary can crash
        // without failed test being reported.
        FatalConditionHandlerGuard _(&m_fatalConditionhandler);
        // We keep having issue where some compilers warn about an unused
        // variable, even though the type has non-trivial constructor and
        // destructor. This is annoying and ugly, but it makes them stfu.
        (void)_;

        m_activeTestCase->invoke();
    }

    void RunContext::handleUnfinishedSections() {
        // If sections ended prematurely due to an exception we stored their
        // infos here so we can tear them down outside the unwind process.
        for ( auto it = m_unfinishedSections.rbegin(),
                   itEnd = m_unfinishedSections.rend();
              it != itEnd;
              ++it ) {
            sectionEnded( CATCH_MOVE( *it ) );
        }
        m_unfinishedSections.clear();
    }

    void RunContext::handleExpr(
        AssertionInfo const& info,
        ITransientExpression const& expr,
        AssertionReaction& reaction
    ) {
        bool negated = isFalseTest( info.resultDisposition );
        bool result = expr.getResult() != negated;

        if( result ) {
            if (!m_includeSuccessfulResults) {
                assertionPassedFastPath(info.lineInfo);
            }
            else {
                reportExpr(info, ResultWas::Ok, &expr, negated);
            }
        }
        else {
            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
            populateReaction(
                reaction, info.resultDisposition & ResultDisposition::Normal );
        }
    }
    void RunContext::reportExpr(
            AssertionInfo const &info,
            ResultWas::OfType resultType,
            ITransientExpression const *expr,
            bool negated ) {

        Detail::g_lastKnownLineInfo = info.lineInfo;
        AssertionResultData data( resultType, LazyExpression( negated ) );

        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;

        assertionEnded( CATCH_MOVE(assertionResult) );
    }

    void RunContext::handleMessage(
            AssertionInfo const& info,
            ResultWas::OfType resultType,
            std::string&& message,
            AssertionReaction& reaction
    ) {
        Detail::g_lastKnownLineInfo = info.lineInfo;

        AssertionResultData data( resultType, LazyExpression( false ) );
        data.message = CATCH_MOVE( message );
        AssertionResult assertionResult{ info,
                                         CATCH_MOVE( data ) };

        const auto isOk = assertionResult.isOk();
        assertionEnded( CATCH_MOVE(assertionResult) );
        if ( !isOk ) {
            populateReaction(
                reaction, info.resultDisposition & ResultDisposition::Normal );
        } else if ( resultType == ResultWas::ExplicitSkip ) {
            // TODO: Need to handle this explicitly, as ExplicitSkip is
            // considered "OK"
            reaction.shouldSkip = true;
        }
    }

    void RunContext::handleUnexpectedExceptionNotThrown(
            AssertionInfo const& info,
            AssertionReaction& reaction
    ) {
        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
    }

    void RunContext::handleUnexpectedInflightException(
            AssertionInfo const& info,
            std::string&& message,
            AssertionReaction& reaction
    ) {
        Detail::g_lastKnownLineInfo = info.lineInfo;

        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
        data.message = CATCH_MOVE(message);
        AssertionResult assertionResult{ info, CATCH_MOVE(data) };
        assertionEnded( CATCH_MOVE(assertionResult) );
        populateReaction( reaction,
                          info.resultDisposition & ResultDisposition::Normal );
    }

    void RunContext::populateReaction( AssertionReaction& reaction,
                                       bool has_normal_disposition ) {
        reaction.shouldDebugBreak = m_shouldDebugBreak;
        reaction.shouldThrow = aborting() || has_normal_disposition;
    }

    AssertionInfo RunContext::makeDummyAssertionInfo() {
        const bool testCaseJustStarted =
            Detail::g_lastKnownLineInfo ==
            m_activeTestCase->getTestCaseInfo().lineInfo;

        return AssertionInfo{
            testCaseJustStarted ? "TEST_CASE"_sr : StringRef(),
            Detail::g_lastKnownLineInfo,
            testCaseJustStarted ? StringRef() : "{Unknown expression after the reported line}"_sr,
            ResultDisposition::Normal
        };
    }

    void RunContext::handleIncomplete(
            AssertionInfo const& info
    ) {
        using namespace std::string_literals;
        Detail::g_lastKnownLineInfo = info.lineInfo;

        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
        assertionEnded( CATCH_MOVE(assertionResult) );
    }

    void RunContext::handleNonExpr(
            AssertionInfo const &info,
            ResultWas::OfType resultType,
            AssertionReaction &reaction
    ) {
        AssertionResultData data( resultType, LazyExpression( false ) );
        AssertionResult assertionResult{ info, CATCH_MOVE( data ) };

        const auto isOk = assertionResult.isOk();
        if ( isOk && !m_includeSuccessfulResults ) {
            assertionPassedFastPath( info.lineInfo );
            return;
        }

        assertionEnded( CATCH_MOVE(assertionResult) );
        if ( !isOk ) {
            populateReaction(
                reaction, info.resultDisposition & ResultDisposition::Normal );
        }
    }

    IResultCapture& getResultCapture() {
        if (auto* capture = getCurrentContext().getResultCapture())
            return *capture;
        else
            CATCH_INTERNAL_ERROR("No result capture instance");
    }

    void seedRng(IConfig const& config) {
        sharedRng().seed(config.rngSeed());
    }

    unsigned int rngSeed() {
        return getCurrentContext().getConfig()->rngSeed();
    }

}



namespace Catch {

    Section::Section( SectionInfo&& info ):
        m_info( CATCH_MOVE( info ) ),
        m_sectionIncluded(
            getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
        // Non-"included" sections will not use the timing information
        // anyway, so don't bother with the potential syscall.
        if (m_sectionIncluded) {
            m_timer.start();
        }
    }

    Section::Section( SourceLineInfo const& _lineInfo,
                      StringRef _name,
                      const char* const ):
        m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
        m_sectionIncluded(
            getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
        // We delay initialization the SectionInfo member until we know
        // this section needs it, so we avoid allocating std::string for name.
        // We also delay timer start to avoid the potential syscall unless we
        // will actually use the result.
        if ( m_sectionIncluded ) {
            m_info.name = static_cast<std::string>( _name );
            m_info.lineInfo = _lineInfo;
            m_timer.start();
        }
    }

    Section::~Section() {
        if( m_sectionIncluded ) {
            SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
            if ( uncaught_exceptions() ) {
                getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
            } else {
                getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
            }
        }
    }

    // This indicates whether the section should be executed or not
    Section::operator bool() const {
        return m_sectionIncluded;
    }


} // end namespace Catch



#include <vector>

namespace Catch {

    namespace {
        static auto getSingletons() -> std::vector<ISingleton*>*& {
            static std::vector<ISingleton*>* g_singletons = nullptr;
            if( !g_singletons )
                g_singletons = new std::vector<ISingleton*>();
            return g_singletons;
        }
    }

    ISingleton::~ISingleton() = default;

    void addSingleton(ISingleton* singleton ) {
        getSingletons()->push_back( singleton );
    }
    void cleanupSingletons() {
        auto& singletons = getSingletons();
        for( auto singleton : *singletons )
            delete singleton;
        delete singletons;
        singletons = nullptr;
    }

} // namespace Catch



#include <cstring>
#include <ostream>

namespace Catch {

    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
    }
    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
        // We can assume that the same file will usually have the same pointer.
        // Thus, if the pointers are the same, there is no point in calling the strcmp
        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
    }

    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
        os << info.file << '(' << info.line << ')';
#else
        os << info.file << ':' << info.line;
#endif
        return os;
    }

} // end namespace Catch




namespace Catch {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
    void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
        CATCH_TRY {
            m_exceptions.push_back(exception);
        } CATCH_CATCH_ALL {
            // If we run out of memory during start-up there's really not a lot more we can do about it
            std::terminate();
        }
    }

    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
        return m_exceptions;
    }
#endif

} // end namespace Catch





#include <iostream>

namespace Catch {

// If you #define this you must implement these functions
#if !defined( CATCH_CONFIG_NOSTDOUT )
    std::ostream& cout() { return std::cout; }
    std::ostream& cerr() { return std::cerr; }
    std::ostream& clog() { return std::clog; }
#endif

} // namespace Catch



#include <ostream>
#include <cstring>
#include <cctype>
#include <vector>

namespace Catch {

    bool startsWith( std::string const& s, std::string const& prefix ) {
        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
    }
    bool startsWith( StringRef s, char prefix ) {
        return !s.empty() && s[0] == prefix;
    }
    bool endsWith( std::string const& s, std::string const& suffix ) {
        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
    }
    bool endsWith( std::string const& s, char suffix ) {
        return !s.empty() && s[s.size()-1] == suffix;
    }
    bool contains( std::string const& s, std::string const& infix ) {
        return s.find( infix ) != std::string::npos;
    }
    void toLowerInPlace( std::string& s ) {
        for ( char& c : s ) {
            c = toLower( c );
        }
    }
    std::string toLower( std::string const& s ) {
        std::string lc = s;
        toLowerInPlace( lc );
        return lc;
    }
    char toLower(char c) {
        return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
    }

    std::string trim( std::string const& str ) {
        static char const* whitespaceChars = "\n\r\t ";
        std::string::size_type start = str.find_first_not_of( whitespaceChars );
        std::string::size_type end = str.find_last_not_of( whitespaceChars );

        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
    }

    StringRef trim(StringRef ref) {
        const auto is_ws = [](char c) {
            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
        };
        size_t real_begin = 0;
        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
        size_t real_end = ref.size();
        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }

        return ref.substr(real_begin, real_end - real_begin);
    }

    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
        std::size_t i = str.find( replaceThis );
        if (i == std::string::npos) {
            return false;
        }
        std::size_t copyBegin = 0;
        std::string origStr = CATCH_MOVE(str);
        str.clear();
        // There is at least one replacement, so reserve with the best guess
        // we can make without actually counting the number of occurrences.
        str.reserve(origStr.size() - replaceThis.size() + withThis.size());
        do {
            str.append(origStr, copyBegin, i-copyBegin );
            str += withThis;
            copyBegin = i + replaceThis.size();
            if( copyBegin < origStr.size() )
                i = origStr.find( replaceThis, copyBegin );
            else
                i = std::string::npos;
        } while( i != std::string::npos );
        if ( copyBegin < origStr.size() ) {
            str.append(origStr, copyBegin, origStr.size() );
        }
        return true;
    }

    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
        std::vector<StringRef> subStrings;
        std::size_t start = 0;
        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
            if( str[pos] == delimiter ) {
                if( pos - start > 1 )
                    subStrings.push_back( str.substr( start, pos-start ) );
                start = pos+1;
            }
        }
        if( start < str.size() )
            subStrings.push_back( str.substr( start, str.size()-start ) );
        return subStrings;
    }

    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
        os << pluraliser.m_count << ' ' << pluraliser.m_label;
        if( pluraliser.m_count != 1 )
            os << 's';
        return os;
    }

}



#include <algorithm>
#include <ostream>
#include <cstring>

namespace Catch {
    StringRef::StringRef( char const* rawChars ) noexcept
    : StringRef( rawChars, std::strlen(rawChars) )
    {}


    bool StringRef::operator<(StringRef rhs) const noexcept {
        if (m_size < rhs.m_size) {
            return strncmp(m_start, rhs.m_start, m_size) <= 0;
        }
        return strncmp(m_start, rhs.m_start, rhs.m_size) < 0;
    }

    int StringRef::compare( StringRef rhs ) const {
        auto cmpResult =
            strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );

        // This means that strncmp found a difference before the strings
        // ended, and we can return it directly
        if ( cmpResult != 0 ) {
            return cmpResult;
        }

        // If strings are equal up to length, then their comparison results on
        // their size
        if ( m_size < rhs.m_size ) {
            return -1;
        } else if ( m_size > rhs.m_size ) {
            return 1;
        } else {
            return 0;
        }
    }

    auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& {
        return os.write(str.data(), static_cast<std::streamsize>(str.size()));
    }

    std::string operator+(StringRef lhs, StringRef rhs) {
        std::string ret;
        ret.reserve(lhs.size() + rhs.size());
        ret += lhs;
        ret += rhs;
        return ret;
    }

    auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& {
        lhs.append(rhs.data(), rhs.size());
        return lhs;
    }

} // namespace Catch



namespace Catch {

    TagAliasRegistry::~TagAliasRegistry() = default;

    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
        auto it = m_registry.find( alias );
        if( it != m_registry.end() )
            return &(it->second);
        else
            return nullptr;
    }

    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
        std::string expandedTestSpec = unexpandedTestSpec;
        for( auto const& registryKvp : m_registry ) {
            std::size_t pos = expandedTestSpec.find( registryKvp.first );
            if( pos != std::string::npos ) {
                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
                                    registryKvp.second.tag +
                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
            }
        }
        return expandedTestSpec;
    }

    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );

        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
                      "error: tag alias, '" << alias << "' already registered.\n"
                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
                      << "\tRedefined at: " << lineInfo );
    }

    ITagAliasRegistry::~ITagAliasRegistry() = default;

    ITagAliasRegistry const& ITagAliasRegistry::get() {
        return getRegistryHub().getTagAliasRegistry();
    }

} // end namespace Catch




namespace Catch {
    TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}

    uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const {
        // FNV-1a hash algorithm that is designed for uniqueness:
        const hash_t prime = 1099511628211u;
        hash_t hash = 14695981039346656037u;
        for ( const char c : t.name ) {
            hash ^= c;
            hash *= prime;
        }
        for ( const char c : t.className ) {
            hash ^= c;
            hash *= prime;
        }
        for ( const Tag& tag : t.tags ) {
            for ( const char c : tag.original ) {
                hash ^= c;
                hash *= prime;
            }
        }
        hash ^= m_seed;
        hash *= prime;
        const uint32_t low{ static_cast<uint32_t>( hash ) };
        const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
        return low * high;
    }
} // namespace Catch




#include <algorithm>
#include <set>

namespace Catch {

    namespace {
        static void enforceNoDuplicateTestCases(
            std::vector<TestCaseHandle> const& tests ) {
            auto testInfoCmp = []( TestCaseInfo const* lhs,
                                   TestCaseInfo const* rhs ) {
                return *lhs < *rhs;
            };
            std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests(
                testInfoCmp );
            for ( auto const& test : tests ) {
                const auto infoPtr = &test.getTestCaseInfo();
                const auto prev = seenTests.insert( infoPtr );
                CATCH_ENFORCE( prev.second,
                               "error: test case \""
                                   << infoPtr->name << "\", with tags \""
                                   << infoPtr->tagsAsString()
                                   << "\" already defined.\n"
                                   << "\tFirst seen at "
                                   << ( *prev.first )->lineInfo << "\n"
                                   << "\tRedefined at " << infoPtr->lineInfo );
            }
        }

        static bool matchTest( TestCaseHandle const& testCase,
                               TestSpec const& testSpec,
                               IConfig const& config ) {
            return testSpec.matches( testCase.getTestCaseInfo() ) &&
                   isThrowSafe( testCase, config );
        }

    } // end unnamed namespace

    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
        switch (config.runOrder()) {
        case TestRunOrder::Declared:
            return unsortedTestCases;

        case TestRunOrder::LexicographicallySorted: {
            std::vector<TestCaseHandle> sorted = unsortedTestCases;
            std::sort(
                sorted.begin(),
                sorted.end(),
                []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) {
                    return lhs.getTestCaseInfo() < rhs.getTestCaseInfo();
                }
            );
            return sorted;
        }
        case TestRunOrder::Randomized: {
            using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;

            TestCaseInfoHasher h{ config.rngSeed() };
            std::vector<TestWithHash> indexed_tests;
            indexed_tests.reserve(unsortedTestCases.size());

            for (auto const& handle : unsortedTestCases) {
                indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle);
            }

            std::sort( indexed_tests.begin(),
                       indexed_tests.end(),
                       []( TestWithHash const& lhs, TestWithHash const& rhs ) {
                           if ( lhs.first == rhs.first ) {
                               return lhs.second.getTestCaseInfo() <
                                      rhs.second.getTestCaseInfo();
                           }
                           return lhs.first < rhs.first;
                       } );

            std::vector<TestCaseHandle> randomized;
            randomized.reserve(indexed_tests.size());

            for (auto const& indexed : indexed_tests) {
                randomized.push_back(indexed.second);
            }

            return randomized;
        }
        }

        CATCH_INTERNAL_ERROR("Unknown test order value!");
    }

    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) {
        return !testCase.getTestCaseInfo().throws() || config.allowThrows();
    }

    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
        std::vector<TestCaseHandle> filtered;
        filtered.reserve( testCases.size() );
        for (auto const& testCase : testCases) {
            if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) ||
                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
                filtered.push_back(testCase);
            }
        }
        return createShard(filtered, config.shardCount(), config.shardIndex());
    }
    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) {
        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
    }

    TestRegistry::~TestRegistry() = default;

    void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
        m_handles.emplace_back(testInfo.get(), testInvoker.get());
        m_viewed_test_infos.push_back(testInfo.get());
        m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
        m_invokers.push_back(CATCH_MOVE(testInvoker));
    }

    std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
        return m_viewed_test_infos;
    }

    std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
        return m_handles;
    }
    std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
        if( m_sortedFunctions.empty() )
            enforceNoDuplicateTestCases( m_handles );

        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
            m_sortedFunctions = sortTests( config, m_handles );
            m_currentSortOrder = config.runOrder();
        }
        return m_sortedFunctions;
    }

} // end namespace Catch




#include <algorithm>
#include <cassert>

#if defined(__clang__)
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif

namespace Catch {
namespace TestCaseTracking {

    NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
    :   name( CATCH_MOVE(_name) ),
        location( _location )
    {}


    ITracker::~ITracker() = default;

    void ITracker::markAsNeedingAnotherRun() {
        m_runState = NeedsAnotherRun;
    }

    void ITracker::addChild( ITrackerPtr&& child ) {
        m_children.push_back( CATCH_MOVE(child) );
    }

    ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
        auto it = std::find_if(
            m_children.begin(),
            m_children.end(),
            [&nameAndLocation]( ITrackerPtr const& tracker ) {
                auto const& tnameAndLoc = tracker->nameAndLocation();
                if ( tnameAndLoc.location.line !=
                     nameAndLocation.location.line ) {
                    return false;
                }
                return tnameAndLoc == nameAndLocation;
            } );
        return ( it != m_children.end() ) ? it->get() : nullptr;
    }

    bool ITracker::isSectionTracker() const { return false; }
    bool ITracker::isGeneratorTracker() const { return false; }

    bool ITracker::isOpen() const {
        return m_runState != NotStarted && !isComplete();
    }

    bool ITracker::hasStarted() const { return m_runState != NotStarted; }

    void ITracker::openChild() {
        if (m_runState != ExecutingChildren) {
            m_runState = ExecutingChildren;
            if (m_parent) {
                m_parent->openChild();
            }
        }
    }

    ITracker& TrackerContext::startRun() {
        using namespace std::string_literals;
        m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
            NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ),
            *this,
            nullptr );
        m_currentTracker = nullptr;
        m_runState = Executing;
        return *m_rootTracker;
    }

    void TrackerContext::completeCycle() {
        m_runState = CompletedCycle;
    }

    bool TrackerContext::completedCycle() const {
        return m_runState == CompletedCycle;
    }
    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
        m_currentTracker = tracker;
    }


    TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
        ITracker(CATCH_MOVE(nameAndLocation), parent),
        m_ctx( ctx )
    {}

    bool TrackerBase::isComplete() const {
        return m_runState == CompletedSuccessfully || m_runState == Failed;
    }

    void TrackerBase::open() {
        m_runState = Executing;
        moveToThis();
        if( m_parent )
            m_parent->openChild();
    }

    void TrackerBase::close() {

        // Close any still open children (e.g. generators)
        while( &m_ctx.currentTracker() != this )
            m_ctx.currentTracker().close();

        switch( m_runState ) {
            case NeedsAnotherRun:
                break;

            case Executing:
                m_runState = CompletedSuccessfully;
                break;
            case ExecutingChildren:
                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
                    m_runState = CompletedSuccessfully;
                break;

            case NotStarted:
            case CompletedSuccessfully:
            case Failed:
                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );

            default:
                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
        }
        moveToParent();
        m_ctx.completeCycle();
    }
    void TrackerBase::fail() {
        m_runState = Failed;
        if( m_parent )
            m_parent->markAsNeedingAnotherRun();
        moveToParent();
        m_ctx.completeCycle();
    }

    void TrackerBase::moveToParent() {
        assert( m_parent );
        m_ctx.setCurrentTracker( m_parent );
    }
    void TrackerBase::moveToThis() {
        m_ctx.setCurrentTracker( this );
    }

    SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
    :   TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
        m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
    {
        if( parent ) {
            while ( !parent->isSectionTracker() ) {
                parent = parent->parent();
            }

            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
            addNextFilters( parentSection.m_filters );
        }
    }

    bool SectionTracker::isComplete() const {
        bool complete = true;

        if (m_filters.empty()
            || m_filters[0].empty()
            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
            complete = TrackerBase::isComplete();
        }
        return complete;
    }

    bool SectionTracker::isSectionTracker() const { return true; }

    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
        SectionTracker* tracker;

        ITracker& currentTracker = ctx.currentTracker();
        if ( ITracker* childTracker =
                 currentTracker.findChild( nameAndLocation ) ) {
            assert( childTracker );
            assert( childTracker->isSectionTracker() );
            tracker = static_cast<SectionTracker*>( childTracker );
        } else {
            auto newTracker = Catch::Detail::make_unique<SectionTracker>(
                NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
                                 nameAndLocation.location },
                ctx,
                &currentTracker );
            tracker = newTracker.get();
            currentTracker.addChild( CATCH_MOVE( newTracker ) );
        }

        if ( !ctx.completedCycle() ) {
            tracker->tryOpen();
        }

        return *tracker;
    }

    void SectionTracker::tryOpen() {
        if( !isComplete() )
            open();
    }

    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
        if( !filters.empty() ) {
            m_filters.reserve( m_filters.size() + filters.size() + 2 );
            m_filters.emplace_back(StringRef{}); // Root - should never be consulted
            m_filters.emplace_back(StringRef{}); // Test Case - not a section filter
            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
        }
    }
    void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) {
        if( filters.size() > 1 )
            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
    }

    StringRef SectionTracker::trimmedName() const {
        return m_trimmed_name;
    }

} // namespace TestCaseTracking

} // namespace Catch

#if defined(__clang__)
#    pragma clang diagnostic pop
#endif




namespace Catch {

    void throw_test_failure_exception() {
#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
        throw TestFailureException{};
#else
        CATCH_ERROR( "Test failure requires aborting test!" );
#endif
    }

    void throw_test_skip_exception() {
#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
        throw Catch::TestSkipException();
#else
        CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
#endif
    }

} // namespace Catch



#include <algorithm>
#include <iterator>

namespace Catch {
    void ITestInvoker::prepareTestCase() {}
    void ITestInvoker::tearDownTestCase() {}
    ITestInvoker::~ITestInvoker() = default;

    namespace {
        static StringRef extractClassName( StringRef classOrMethodName ) {
            if ( !startsWith( classOrMethodName, '&' ) ) {
                return classOrMethodName;
            }

            // Remove the leading '&' to avoid having to special case it later
            const auto methodName =
                classOrMethodName.substr( 1, classOrMethodName.size() );

            auto reverseStart = std::make_reverse_iterator( methodName.end() );
            auto reverseEnd = std::make_reverse_iterator( methodName.begin() );

            // We make a simplifying assumption that ":" is only present
            // in the input as part of "::" from C++ typenames (this is
            // relatively safe assumption because the input is generated
            // as stringification of type through preprocessor).
            auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1;
            auto secondLastColons =
                std::find( lastColons + 1, reverseEnd, ':' );

            auto const startIdx = reverseEnd - secondLastColons;
            auto const classNameSize = secondLastColons - lastColons - 1;

            return methodName.substr(
                static_cast<std::size_t>( startIdx ),
                static_cast<std::size_t>( classNameSize ) );
        }

        class TestInvokerAsFunction final : public ITestInvoker {
            using TestType = void ( * )();
            TestType m_testAsFunction;

        public:
            constexpr TestInvokerAsFunction( TestType testAsFunction ) noexcept:
                m_testAsFunction( testAsFunction ) {}

            void invoke() const override { m_testAsFunction(); }
        };

    } // namespace

    Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
        return Detail::make_unique<TestInvokerAsFunction>( testAsFunction );
    }

    AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
        CATCH_TRY {
            getMutableRegistryHub()
                    .registerTest(
                        makeTestCaseInfo(
                            extractClassName( classOrMethod ),
                            nameAndTags,
                            lineInfo),
                        CATCH_MOVE(invoker)
                    );
        } CATCH_CATCH_ALL {
            // Do not throw when constructing global objects, instead register the exception to be processed later
            getMutableRegistryHub().registerStartupException();
        }
    }
}





namespace Catch {

    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}

    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
        m_mode = None;
        m_exclusion = false;
        m_arg = m_tagAliases->expandAliases( arg );
        m_escapeChars.clear();
        m_substring.reserve(m_arg.size());
        m_patternName.reserve(m_arg.size());
        m_realPatternPos = 0;

        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
          //if visitChar fails
           if( !visitChar( m_arg[m_pos] ) ){
               m_testSpec.m_invalidSpecs.push_back(arg);
               break;
           }
        endMode();
        return *this;
    }
    TestSpec TestSpecParser::testSpec() {
        addFilter();
        return CATCH_MOVE(m_testSpec);
    }
    bool TestSpecParser::visitChar( char c ) {
        if( (m_mode != EscapedName) && (c == '\\') ) {
            escape();
            addCharToPattern(c);
            return true;
        }else if((m_mode != EscapedName) && (c == ',') )  {
            return separate();
        }

        switch( m_mode ) {
        case None:
            if( processNoneChar( c ) )
                return true;
            break;
        case Name:
            processNameChar( c );
            break;
        case EscapedName:
            endMode();
            addCharToPattern(c);
            return true;
        default:
        case Tag:
        case QuotedName:
            if( processOtherChar( c ) )
                return true;
            break;
        }

        m_substring += c;
        if( !isControlChar( c ) ) {
            m_patternName += c;
            m_realPatternPos++;
        }
        return true;
    }
    // Two of the processing methods return true to signal the caller to return
    // without adding the given character to the current pattern strings
    bool TestSpecParser::processNoneChar( char c ) {
        switch( c ) {
        case ' ':
            return true;
        case '~':
            m_exclusion = true;
            return false;
        case '[':
            startNewMode( Tag );
            return false;
        case '"':
            startNewMode( QuotedName );
            return false;
        default:
            startNewMode( Name );
            return false;
        }
    }
    void TestSpecParser::processNameChar( char c ) {
        if( c == '[' ) {
            if( m_substring == "exclude:" )
                m_exclusion = true;
            else
                endMode();
            startNewMode( Tag );
        }
    }
    bool TestSpecParser::processOtherChar( char c ) {
        if( !isControlChar( c ) )
            return false;
        m_substring += c;
        endMode();
        return true;
    }
    void TestSpecParser::startNewMode( Mode mode ) {
        m_mode = mode;
    }
    void TestSpecParser::endMode() {
        switch( m_mode ) {
        case Name:
        case QuotedName:
            return addNamePattern();
        case Tag:
            return addTagPattern();
        case EscapedName:
            revertBackToLastMode();
            return;
        case None:
        default:
            return startNewMode( None );
        }
    }
    void TestSpecParser::escape() {
        saveLastMode();
        m_mode = EscapedName;
        m_escapeChars.push_back(m_realPatternPos);
    }
    bool TestSpecParser::isControlChar( char c ) const {
        switch( m_mode ) {
            default:
                return false;
            case None:
                return c == '~';
            case Name:
                return c == '[';
            case EscapedName:
                return true;
            case QuotedName:
                return c == '"';
            case Tag:
                return c == '[' || c == ']';
        }
    }

    void TestSpecParser::addFilter() {
        if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) {
            m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) );
            m_currentFilter = TestSpec::Filter();
        }
    }

    void TestSpecParser::saveLastMode() {
      lastMode = m_mode;
    }

    void TestSpecParser::revertBackToLastMode() {
      m_mode = lastMode;
    }

    bool TestSpecParser::separate() {
      if( (m_mode==QuotedName) || (m_mode==Tag) ){
         //invalid argument, signal failure to previous scope.
         m_mode = None;
         m_pos = m_arg.size();
         m_substring.clear();
         m_patternName.clear();
         m_realPatternPos = 0;
         return false;
      }
      endMode();
      addFilter();
      return true; //success
    }

    std::string TestSpecParser::preprocessPattern() {
        std::string token = m_patternName;
        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
        m_escapeChars.clear();
        if (startsWith(token, "exclude:")) {
            m_exclusion = true;
            token = token.substr(8);
        }

        m_patternName.clear();
        m_realPatternPos = 0;

        return token;
    }

    void TestSpecParser::addNamePattern() {
        auto token = preprocessPattern();

        if (!token.empty()) {
            if (m_exclusion) {
                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
            } else {
                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
            }
        }
        m_substring.clear();
        m_exclusion = false;
        m_mode = None;
    }

    void TestSpecParser::addTagPattern() {
        auto token = preprocessPattern();

        if (!token.empty()) {
            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
            // we have to create a separate hide tag and shorten the real one
            if (token.size() > 1 && token[0] == '.') {
                token.erase(token.begin());
                if (m_exclusion) {
                    m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
                } else {
                    m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
                }
            }
            if (m_exclusion) {
                m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
            } else {
                m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
            }
        }
        m_substring.clear();
        m_exclusion = false;
        m_mode = None;
    }

} // namespace Catch



#include <algorithm>
#include <cstring>
#include <ostream>

namespace {
    bool isWhitespace( char c ) {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
    }

    bool isBreakableBefore( char c ) {
        static const char chars[] = "[({<|";
        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
    }

    bool isBreakableAfter( char c ) {
        static const char chars[] = "])}>.,:;*+-=&/\\";
        return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
    }

} // namespace

namespace Catch {
    namespace TextFlow {
        void AnsiSkippingString::preprocessString() {
            for ( auto it = m_string.begin(); it != m_string.end(); ) {
                // try to read through an ansi sequence
                while ( it != m_string.end() && *it == '\033' &&
                        it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
                    auto cursor = it + 2;
                    while ( cursor != m_string.end() &&
                            ( isdigit( *cursor ) || *cursor == ';' ) ) {
                        ++cursor;
                    }
                    if ( cursor == m_string.end() || *cursor != 'm' ) {
                        break;
                    }
                    // 'm' -> 0xff
                    *cursor = AnsiSkippingString::sentinel;
                    // if we've read an ansi sequence, set the iterator and
                    // return to the top of the loop
                    it = cursor + 1;
                }
                if ( it != m_string.end() ) {
                    ++m_size;
                    ++it;
                }
            }
        }

        AnsiSkippingString::AnsiSkippingString( std::string const& text ):
            m_string( text ) {
            preprocessString();
        }

        AnsiSkippingString::AnsiSkippingString( std::string&& text ):
            m_string( CATCH_MOVE( text ) ) {
            preprocessString();
        }

        AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
            return const_iterator( m_string );
        }

        AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
            return const_iterator( m_string, const_iterator::EndTag{} );
        }

        std::string AnsiSkippingString::substring( const_iterator begin,
                                                   const_iterator end ) const {
            // There's one caveat here to an otherwise simple substring: when
            // making a begin iterator we might have skipped ansi sequences at
            // the start. If `begin` here is a begin iterator, skipped over
            // initial ansi sequences, we'll use the true beginning of the
            // string. Lastly: We need to transform any chars we replaced with
            // 0xff back to 'm'
            auto str = std::string( begin == this->begin() ? m_string.begin()
                                                           : begin.m_it,
                                    end.m_it );
            std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
                return c == AnsiSkippingString::sentinel ? 'm' : c;
            } );
            return str;
        }

        void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
            // check if we've landed on an ansi sequence, and if so read through
            // it
            while ( m_it != m_string->end() && *m_it == '\033' &&
                    m_it + 1 != m_string->end() &&  *( m_it + 1 ) == '[' ) {
                auto cursor = m_it + 2;
                while ( cursor != m_string->end() &&
                        ( isdigit( *cursor ) || *cursor == ';' ) ) {
                    ++cursor;
                }
                if ( cursor == m_string->end() ||
                     *cursor != AnsiSkippingString::sentinel ) {
                    break;
                }
                // if we've read an ansi sequence, set the iterator and
                // return to the top of the loop
                m_it = cursor + 1;
            }
        }

        void AnsiSkippingString::const_iterator::advance() {
            assert( m_it != m_string->end() );
            m_it++;
            tryParseAnsiEscapes();
        }

        void AnsiSkippingString::const_iterator::unadvance() {
            assert( m_it != m_string->begin() );
            m_it--;
            // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
            // (and repeat check)
            while ( *m_it == AnsiSkippingString::sentinel ) {
                while ( *m_it != '\033' ) {
                    assert( m_it != m_string->begin() );
                    m_it--;
                }
                // if this happens, we must have been a begin iterator that had
                // skipped over ansi sequences at the start of a string
                assert( m_it != m_string->begin() );
                assert( *m_it == '\033' );
                m_it--;
            }
        }

        static bool isBoundary( AnsiSkippingString const& line,
                                AnsiSkippingString::const_iterator it ) {
            return it == line.end() ||
                   ( isWhitespace( *it ) &&
                     !isWhitespace( *it.oneBefore() ) ) ||
                   isBreakableBefore( *it ) ||
                   isBreakableAfter( *it.oneBefore() );
        }

        void Column::const_iterator::calcLength() {
            m_addHyphen = false;
            m_parsedTo = m_lineStart;
            AnsiSkippingString const& current_line = m_column.m_string;

            if ( m_parsedTo == current_line.end() ) {
                m_lineEnd = m_parsedTo;
                return;
            }

            assert( m_lineStart != current_line.end() );
            if ( *m_lineStart == '\n' ) { ++m_parsedTo; }

            const auto maxLineLength = m_column.m_width - indentSize();
            std::size_t lineLength = 0;
            while ( m_parsedTo != current_line.end() &&
                    lineLength < maxLineLength && *m_parsedTo != '\n' ) {
                ++m_parsedTo;
                ++lineLength;
            }

            // If we encountered a newline before the column is filled,
            // then we linebreak at the newline and consider this line
            // finished.
            if ( lineLength < maxLineLength ) {
                m_lineEnd = m_parsedTo;
            } else {
                // Look for a natural linebreak boundary in the column
                // (We look from the end, so that the first found boundary is
                // the right one)
                m_lineEnd = m_parsedTo;
                while ( lineLength > 0 &&
                        !isBoundary( current_line, m_lineEnd ) ) {
                    --lineLength;
                    --m_lineEnd;
                }
                while ( lineLength > 0 &&
                        isWhitespace( *m_lineEnd.oneBefore() ) ) {
                    --lineLength;
                    --m_lineEnd;
                }

                // If we found one, then that is where we linebreak, otherwise
                // we have to split text with a hyphen
                if ( lineLength == 0 ) {
                    m_addHyphen = true;
                    m_lineEnd = m_parsedTo.oneBefore();
                }
            }
        }

        size_t Column::const_iterator::indentSize() const {
            auto initial = m_lineStart == m_column.m_string.begin()
                               ? m_column.m_initialIndent
                               : std::string::npos;
            return initial == std::string::npos ? m_column.m_indent : initial;
        }

        std::string Column::const_iterator::addIndentAndSuffix(
            AnsiSkippingString::const_iterator start,
            AnsiSkippingString::const_iterator end ) const {
            std::string ret;
            const auto desired_indent = indentSize();
            // ret.reserve( desired_indent + (end - start) + m_addHyphen );
            ret.append( desired_indent, ' ' );
            // ret.append( start, end );
            ret += m_column.m_string.substring( start, end );
            if ( m_addHyphen ) { ret.push_back( '-' ); }

            return ret;
        }

        Column::const_iterator::const_iterator( Column const& column ):
            m_column( column ),
            m_lineStart( column.m_string.begin() ),
            m_lineEnd( column.m_string.begin() ),
            m_parsedTo( column.m_string.begin() ) {
            assert( m_column.m_width > m_column.m_indent );
            assert( m_column.m_initialIndent == std::string::npos ||
                    m_column.m_width > m_column.m_initialIndent );
            calcLength();
            if ( m_lineStart == m_lineEnd ) {
                m_lineStart = m_column.m_string.end();
            }
        }

        std::string Column::const_iterator::operator*() const {
            assert( m_lineStart <= m_parsedTo );
            return addIndentAndSuffix( m_lineStart, m_lineEnd );
        }

        Column::const_iterator& Column::const_iterator::operator++() {
            m_lineStart = m_lineEnd;
            AnsiSkippingString const& current_line = m_column.m_string;
            if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
                m_lineStart++;
            } else {
                while ( m_lineStart != current_line.end() &&
                        isWhitespace( *m_lineStart ) ) {
                    ++m_lineStart;
                }
            }

            if ( m_lineStart != current_line.end() ) { calcLength(); }
            return *this;
        }

        Column::const_iterator Column::const_iterator::operator++( int ) {
            const_iterator prev( *this );
            operator++();
            return prev;
        }

        std::ostream& operator<<( std::ostream& os, Column const& col ) {
            bool first = true;
            for ( auto line : col ) {
                if ( first ) {
                    first = false;
                } else {
                    os << '\n';
                }
                os << line;
            }
            return os;
        }

        Column Spacer( size_t spaceWidth ) {
            Column ret{ "" };
            ret.width( spaceWidth );
            return ret;
        }

        Columns::iterator::iterator( Columns const& columns, EndTag ):
            m_columns( columns.m_columns ), m_activeIterators( 0 ) {

            m_iterators.reserve( m_columns.size() );
            for ( auto const& col : m_columns ) {
                m_iterators.push_back( col.end() );
            }
        }

        Columns::iterator::iterator( Columns const& columns ):
            m_columns( columns.m_columns ),
            m_activeIterators( m_columns.size() ) {

            m_iterators.reserve( m_columns.size() );
            for ( auto const& col : m_columns ) {
                m_iterators.push_back( col.begin() );
            }
        }

        std::string Columns::iterator::operator*() const {
            std::string row, padding;

            for ( size_t i = 0; i < m_columns.size(); ++i ) {
                const auto width = m_columns[i].width();
                if ( m_iterators[i] != m_columns[i].end() ) {
                    std::string col = *m_iterators[i];
                    row += padding;
                    row += col;

                    padding.clear();
                    if ( col.size() < width ) {
                        padding.append( width - col.size(), ' ' );
                    }
                } else {
                    padding.append( width, ' ' );
                }
            }
            return row;
        }

        Columns::iterator& Columns::iterator::operator++() {
            for ( size_t i = 0; i < m_columns.size(); ++i ) {
                if ( m_iterators[i] != m_columns[i].end() ) {
                    ++m_iterators[i];
                }
            }
            return *this;
        }

        Columns::iterator Columns::iterator::operator++( int ) {
            iterator prev( *this );
            operator++();
            return prev;
        }

        std::ostream& operator<<( std::ostream& os, Columns const& cols ) {
            bool first = true;
            for ( auto line : cols ) {
                if ( first ) {
                    first = false;
                } else {
                    os << '\n';
                }
                os << line;
            }
            return os;
        }

        Columns operator+( Column const& lhs, Column const& rhs ) {
            Columns cols;
            cols += lhs;
            cols += rhs;
            return cols;
        }
        Columns operator+( Column&& lhs, Column&& rhs ) {
            Columns cols;
            cols += CATCH_MOVE( lhs );
            cols += CATCH_MOVE( rhs );
            return cols;
        }

        Columns& operator+=( Columns& lhs, Column const& rhs ) {
            lhs.m_columns.push_back( rhs );
            return lhs;
        }
        Columns& operator+=( Columns& lhs, Column&& rhs ) {
            lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
            return lhs;
        }
        Columns operator+( Columns const& lhs, Column const& rhs ) {
            auto combined( lhs );
            combined += rhs;
            return combined;
        }
        Columns operator+( Columns&& lhs, Column&& rhs ) {
            lhs += CATCH_MOVE( rhs );
            return CATCH_MOVE( lhs );
        }

    } // namespace TextFlow
} // namespace Catch




#include <exception>

namespace Catch {
    bool uncaught_exceptions() {
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        return false;
#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
        return std::uncaught_exceptions() > 0;
#else
        return std::uncaught_exception();
#endif
  }
} // end namespace Catch



namespace Catch {

    WildcardPattern::WildcardPattern( std::string const& pattern,
                                      CaseSensitive caseSensitivity )
    :   m_caseSensitivity( caseSensitivity ),
        m_pattern( normaliseString( pattern ) )
    {
        if( startsWith( m_pattern, '*' ) ) {
            m_pattern = m_pattern.substr( 1 );
            m_wildcard = WildcardAtStart;
        }
        if( endsWith( m_pattern, '*' ) ) {
            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
        }
    }

    bool WildcardPattern::matches( std::string const& str ) const {
        switch( m_wildcard ) {
            case NoWildcard:
                return m_pattern == normaliseString( str );
            case WildcardAtStart:
                return endsWith( normaliseString( str ), m_pattern );
            case WildcardAtEnd:
                return startsWith( normaliseString( str ), m_pattern );
            case WildcardAtBothEnds:
                return contains( normaliseString( str ), m_pattern );
            default:
                CATCH_INTERNAL_ERROR( "Unknown enum" );
        }
    }

    std::string WildcardPattern::normaliseString( std::string const& str ) const {
        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
    }
}


// Note: swapping these two includes around causes MSVC to error out
//       while in /permissive- mode. No, I don't know why.
//       Tested on VS 2019, 18.{3, 4}.x

#include <cstdint>
#include <iomanip>
#include <type_traits>

namespace Catch {

namespace {

    size_t trailingBytes(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return 2;
        }
        if ((c & 0xF0) == 0xE0) {
            return 3;
        }
        if ((c & 0xF8) == 0xF0) {
            return 4;
        }
        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

    uint32_t headerValue(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return c & 0x1F;
        }
        if ((c & 0xF0) == 0xE0) {
            return c & 0x0F;
        }
        if ((c & 0xF8) == 0xF0) {
            return c & 0x07;
        }
        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

    void hexEscapeChar(std::ostream& os, unsigned char c) {
        std::ios_base::fmtflags f(os.flags());
        os << "\\x"
            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
            << static_cast<int>(c);
        os.flags(f);
    }

    constexpr bool shouldNewline(XmlFormatting fmt) {
        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
    }

    constexpr bool shouldIndent(XmlFormatting fmt) {
        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
    }

} // anonymous namespace

    void XmlEncode::encodeTo( std::ostream& os ) const {
        // Apostrophe escaping not necessary if we always use " to write attributes
        // (see: http://www.w3.org/TR/xml/#syntax)

        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
            unsigned char c = static_cast<unsigned char>(m_str[idx]);
            switch (c) {
            case '<':   os << "&lt;"; break;
            case '&':   os << "&amp;"; break;

            case '>':
                // See: http://www.w3.org/TR/xml/#syntax
                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
                    os << "&gt;";
                else
                    os << c;
                break;

            case '\"':
                if (m_forWhat == ForAttributes)
                    os << "&quot;";
                else
                    os << c;
                break;

            default:
                // Check for control characters and invalid utf-8

                // Escape control characters in standard ascii
                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
                    hexEscapeChar(os, c);
                    break;
                }

                // Plain ASCII: Write it to stream
                if (c < 0x7F) {
                    os << c;
                    break;
                }

                // UTF-8 territory
                // Check if the encoding is valid and if it is not, hex escape bytes.
                // Important: We do not check the exact decoded values for validity, only the encoding format
                // First check that this bytes is a valid lead byte:
                // This means that it is not encoded as 1111 1XXX
                // Or as 10XX XXXX
                if (c <  0xC0 ||
                    c >= 0xF8) {
                    hexEscapeChar(os, c);
                    break;
                }

                auto encBytes = trailingBytes(c);
                // Are there enough bytes left to avoid accessing out-of-bounds memory?
                if (idx + encBytes - 1 >= m_str.size()) {
                    hexEscapeChar(os, c);
                    break;
                }
                // The header is valid, check data
                // The next encBytes bytes must together be a valid utf-8
                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
                bool valid = true;
                uint32_t value = headerValue(c);
                for (std::size_t n = 1; n < encBytes; ++n) {
                    unsigned char nc = static_cast<unsigned char>(m_str[idx + n]);
                    valid &= ((nc & 0xC0) == 0x80);
                    value = (value << 6) | (nc & 0x3F);
                }

                if (
                    // Wrong bit pattern of following bytes
                    (!valid) ||
                    // Overlong encodings
                    (value < 0x80) ||
                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
                    // Encoded value out of range
                    (value >= 0x110000)
                    ) {
                    hexEscapeChar(os, c);
                    break;
                }

                // If we got here, this is in fact a valid(ish) utf-8 sequence
                for (std::size_t n = 0; n < encBytes; ++n) {
                    os << m_str[idx + n];
                }
                idx += encBytes - 1;
                break;
            }
        }
    }

    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
        xmlEncode.encodeTo( os );
        return os;
    }

    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
    :   m_writer( writer ),
        m_fmt(fmt)
    {}

    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
    :   m_writer( other.m_writer ),
        m_fmt(other.m_fmt)
    {
        other.m_writer = nullptr;
        other.m_fmt = XmlFormatting::None;
    }
    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
        if ( m_writer ) {
            m_writer->endElement();
        }
        m_writer = other.m_writer;
        other.m_writer = nullptr;
        m_fmt = other.m_fmt;
        other.m_fmt = XmlFormatting::None;
        return *this;
    }


    XmlWriter::ScopedElement::~ScopedElement() {
        if (m_writer) {
            m_writer->endElement(m_fmt);
        }
    }

    XmlWriter::ScopedElement&
    XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) {
        m_writer->writeText( text, fmt );
        return *this;
    }

    XmlWriter::ScopedElement&
    XmlWriter::ScopedElement::writeAttribute( StringRef name,
                                              StringRef attribute ) {
        m_writer->writeAttribute( name, attribute );
        return *this;
    }


    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
    {
        writeDeclaration();
    }

    XmlWriter::~XmlWriter() {
        while (!m_tags.empty()) {
            endElement();
        }
        newlineIfNecessary();
    }

    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
        ensureTagClosed();
        newlineIfNecessary();
        if (shouldIndent(fmt)) {
            m_os << m_indent;
            m_indent += "  ";
        }
        m_os << '<' << name;
        m_tags.push_back( name );
        m_tagIsOpen = true;
        applyFormatting(fmt);
        return *this;
    }

    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
        ScopedElement scoped( this, fmt );
        startElement( name, fmt );
        return scoped;
    }

    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
        m_indent = m_indent.substr(0, m_indent.size() - 2);

        if( m_tagIsOpen ) {
            m_os << "/>";
            m_tagIsOpen = false;
        } else {
            newlineIfNecessary();
            if (shouldIndent(fmt)) {
                m_os << m_indent;
            }
            m_os << "</" << m_tags.back() << '>';
        }
        m_os << std::flush;
        applyFormatting(fmt);
        m_tags.pop_back();
        return *this;
    }

    XmlWriter& XmlWriter::writeAttribute( StringRef name,
                                          StringRef attribute ) {
        if( !name.empty() && !attribute.empty() )
            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
        return *this;
    }

    XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
        writeAttribute(name, (attribute ? "true"_sr : "false"_sr));
        return *this;
    }

    XmlWriter& XmlWriter::writeAttribute( StringRef name,
                                          char const* attribute ) {
        writeAttribute( name, StringRef( attribute ) );
        return *this;
    }

    XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
        CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element");
        if( !text.empty() ){
            bool tagWasOpen = m_tagIsOpen;
            ensureTagClosed();
            if (tagWasOpen && shouldIndent(fmt)) {
                m_os << m_indent;
            }
            m_os << XmlEncode( text, XmlEncode::ForTextNodes );
            applyFormatting(fmt);
        }
        return *this;
    }

    XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
        ensureTagClosed();
        if (shouldIndent(fmt)) {
            m_os << m_indent;
        }
        m_os << "<!-- " << text << " -->";
        applyFormatting(fmt);
        return *this;
    }

    void XmlWriter::writeStylesheetRef( StringRef url ) {
        m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n';
    }

    void XmlWriter::ensureTagClosed() {
        if( m_tagIsOpen ) {
            m_os << '>' << std::flush;
            newlineIfNecessary();
            m_tagIsOpen = false;
        }
    }

    void XmlWriter::applyFormatting(XmlFormatting fmt) {
        m_needsNewline = shouldNewline(fmt);
    }

    void XmlWriter::writeDeclaration() {
        m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n';
    }

    void XmlWriter::newlineIfNecessary() {
        if( m_needsNewline ) {
            m_os << '\n' << std::flush;
            m_needsNewline = false;
        }
    }
}





namespace Catch {
namespace Matchers {

    std::string MatcherUntypedBase::toString() const {
        if (m_cachedToString.empty()) {
            m_cachedToString = describe();
        }
        return m_cachedToString;
    }

    MatcherUntypedBase::~MatcherUntypedBase() = default;

} // namespace Matchers
} // namespace Catch




namespace Catch {
namespace Matchers {

    std::string IsEmptyMatcher::describe() const {
        return "is empty";
    }

    std::string HasSizeMatcher::describe() const {
        ReusableStringStream sstr;
        sstr << "has size == " << m_target_size;
        return sstr.str();
    }

    IsEmptyMatcher IsEmpty() {
        return {};
    }

    HasSizeMatcher SizeIs(std::size_t sz) {
        return HasSizeMatcher{ sz };
    }

} // end namespace Matchers
} // end namespace Catch



namespace Catch {
namespace Matchers {

bool ExceptionMessageMatcher::match(std::exception const& ex) const {
    return ex.what() == m_message;
}

std::string ExceptionMessageMatcher::describe() const {
    return "exception message matches \"" + m_message + '"';
}

ExceptionMessageMatcher Message(std::string const& message) {
    return ExceptionMessageMatcher(message);
}

} // namespace Matchers
} // namespace Catch



#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstdint>
#include <sstream>
#include <iomanip>
#include <limits>


namespace Catch {
namespace {

    template <typename FP>
    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
        // Comparison with NaN should always be false.
        // This way we can rule it out before getting into the ugly details
        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
            return false;
        }

        // This should also handle positive and negative zeros, infinities
        const auto ulpDist = ulpDistance(lhs, rhs);

        return ulpDist <= maxUlpDiff;
    }


template <typename FP>
FP step(FP start, FP direction, uint64_t steps) {
    for (uint64_t i = 0; i < steps; ++i) {
        start = Catch::nextafter(start, direction);
    }
    return start;
}

// Performs equivalent check of std::fabs(lhs - rhs) <= margin
// But without the subtraction to allow for INFINITY in comparison
bool marginComparison(double lhs, double rhs, double margin) {
    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
}

template <typename FloatingPoint>
void write(std::ostream& out, FloatingPoint num) {
    out << std::scientific
        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
        << num;
}

} // end anonymous namespace

namespace Matchers {
namespace Detail {

    enum class FloatingPointKind : uint8_t {
        Float,
        Double
    };

} // end namespace Detail


    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
        :m_target{ target }, m_margin{ margin } {
        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
            << " Margin has to be non-negative.");
    }

    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
    // But without the subtraction to allow for INFINITY in comparison
    bool WithinAbsMatcher::match(double const& matchee) const {
        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
    }

    std::string WithinAbsMatcher::describe() const {
        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
    }


    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType)
        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
        CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
            "Provided ULP is impossibly large for a float comparison.");
        CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
                       "WithinUlp matcher only supports platforms with "
                       "IEEE-754 compatible floating point representation" );
    }

#if defined(__clang__)
#pragma clang diagnostic push
// Clang <3.5 reports on the default branch in the switch below
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif

    bool WithinUlpsMatcher::match(double const& matchee) const {
        switch (m_type) {
        case Detail::FloatingPointKind::Float:
            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
        case Detail::FloatingPointKind::Double:
            return almostEqualUlps<double>(matchee, m_target, m_ulps);
        default:
            CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" );
        }
    }

#if defined(__clang__)
#pragma clang diagnostic pop
#endif

    std::string WithinUlpsMatcher::describe() const {
        std::stringstream ret;

        ret << "is within " << m_ulps << " ULPs of ";

        if (m_type == Detail::FloatingPointKind::Float) {
            write(ret, static_cast<float>(m_target));
            ret << 'f';
        } else {
            write(ret, m_target);
        }

        ret << " ([";
        if (m_type == Detail::FloatingPointKind::Double) {
            write( ret,
                   step( m_target,
                         -std::numeric_limits<double>::infinity(),
                         m_ulps ) );
            ret << ", ";
            write( ret,
                   step( m_target,
                         std::numeric_limits<double>::infinity(),
                         m_ulps ) );
        } else {
            // We have to cast INFINITY to float because of MinGW, see #1782
            write( ret,
                   step( static_cast<float>( m_target ),
                         -std::numeric_limits<float>::infinity(),
                         m_ulps ) );
            ret << ", ";
            write( ret,
                   step( static_cast<float>( m_target ),
                         std::numeric_limits<float>::infinity(),
                         m_ulps ) );
        }
        ret << "])";

        return ret.str();
    }

    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
        m_target(target),
        m_epsilon(epsilon){
        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
    }

    bool WithinRelMatcher::match(double const& matchee) const {
        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
        return marginComparison(matchee, m_target,
                                std::isinf(relMargin)? 0 : relMargin);
    }

    std::string WithinRelMatcher::describe() const {
        Catch::ReusableStringStream sstr;
        sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other";
        return sstr.str();
    }


WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
}

WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
    return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);
}

WithinAbsMatcher WithinAbs(double target, double margin) {
    return WithinAbsMatcher(target, margin);
}

WithinRelMatcher WithinRel(double target, double eps) {
    return WithinRelMatcher(target, eps);
}

WithinRelMatcher WithinRel(double target) {
    return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
}

WithinRelMatcher WithinRel(float target, float eps) {
    return WithinRelMatcher(target, eps);
}

WithinRelMatcher WithinRel(float target) {
    return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
}



bool IsNaNMatcher::match( double const& matchee ) const {
    return std::isnan( matchee );
}

std::string IsNaNMatcher::describe() const {
    using namespace std::string_literals;
    return "is NaN"s;
}

IsNaNMatcher IsNaN() { return IsNaNMatcher(); }

    } // namespace Matchers
} // namespace Catch




std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
    if (desc.empty()) {
        return "matches undescribed predicate";
    } else {
        return "matches predicate: \"" + desc + '"';
    }
}



namespace Catch {
    namespace Matchers {
        std::string AllTrueMatcher::describe() const { return "contains only true"; }

        AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }

        std::string NoneTrueMatcher::describe() const { return "contains no true"; }

        NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }

        std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }

        AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
    } // namespace Matchers
} // namespace Catch



#include <regex>

namespace Catch {
namespace Matchers {

    CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity )
    :   m_caseSensitivity( caseSensitivity ),
        m_str( adjustString( str ) )
    {}
    std::string CasedString::adjustString( std::string const& str ) const {
        return m_caseSensitivity == CaseSensitive::No
               ? toLower( str )
               : str;
    }
    StringRef CasedString::caseSensitivitySuffix() const {
        return m_caseSensitivity == CaseSensitive::Yes
                   ? StringRef()
                   : " (case insensitive)"_sr;
    }


    StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator )
    : m_comparator( comparator ),
      m_operation( operation ) {
    }

    std::string StringMatcherBase::describe() const {
        std::string description;
        description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
                                    m_comparator.caseSensitivitySuffix().size());
        description += m_operation;
        description += ": \"";
        description += m_comparator.m_str;
        description += '"';
        description += m_comparator.caseSensitivitySuffix();
        return description;
    }

    StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}

    bool StringEqualsMatcher::match( std::string const& source ) const {
        return m_comparator.adjustString( source ) == m_comparator.m_str;
    }


    StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}

    bool StringContainsMatcher::match( std::string const& source ) const {
        return contains( m_comparator.adjustString( source ), m_comparator.m_str );
    }


    StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {}

    bool StartsWithMatcher::match( std::string const& source ) const {
        return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
    }


    EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {}

    bool EndsWithMatcher::match( std::string const& source ) const {
        return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
    }



    RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {}

    bool RegexMatcher::match(std::string const& matchee) const {
        auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
        if (m_caseSensitivity == CaseSensitive::No) {
            flags |= std::regex::icase;
        }
        auto reg = std::regex(m_regex, flags);
        return std::regex_match(matchee, reg);
    }

    std::string RegexMatcher::describe() const {
        return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
    }


    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
        return StringEqualsMatcher( CasedString( str, caseSensitivity) );
    }
    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
        return StringContainsMatcher( CasedString( str, caseSensitivity) );
    }
    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
        return EndsWithMatcher( CasedString( str, caseSensitivity) );
    }
    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
        return StartsWithMatcher( CasedString( str, caseSensitivity) );
    }

    RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
        return RegexMatcher(regex, caseSensitivity);
    }

} // namespace Matchers
} // namespace Catch



namespace Catch {
namespace Matchers {
    MatcherGenericBase::~MatcherGenericBase() = default;

    namespace Detail {

        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) {
            std::string description;
            std::size_t combined_size = 4;
            for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
                combined_size += desc->size();
            }
            combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();

            description.reserve(combined_size);

            description += "( ";
            bool first = true;
            for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
                if( first )
                    first = false;
                else
                    description += combine;
                description += *desc;
            }
            description += " )";
            return description;
        }

    } // namespace Detail
} // namespace Matchers
} // namespace Catch




namespace Catch {

    // This is the general overload that takes a any string matcher
    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
    // the Equals matcher (so the header does not mention matchers)
    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
        std::string exceptionMessage = Catch::translateActiveException();
        MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
        handler.handleExpr( expr );
    }

} // namespace Catch



#include <ostream>

namespace Catch {

    AutomakeReporter::~AutomakeReporter() = default;

    void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
        // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
        m_stream << ":test-result: ";
        if ( _testCaseStats.totals.testCases.skipped > 0 ) {
            m_stream << "SKIP";
        } else if (_testCaseStats.totals.assertions.allPassed()) {
            m_stream << "PASS";
        } else if (_testCaseStats.totals.assertions.allOk()) {
            m_stream << "XFAIL";
        } else {
            m_stream << "FAIL";
        }
        m_stream << ' ' << _testCaseStats.testInfo->name << '\n';
        StreamingReporterBase::testCaseEnded(_testCaseStats);
    }

    void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) {
        m_stream << ":test-result: SKIP " << testInfo.name << '\n';
    }

} // end namespace Catch






namespace Catch {
    ReporterBase::ReporterBase( ReporterConfig&& config ):
        IEventListener( config.fullConfig() ),
        m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
        m_stream( m_wrapped_stream->stream() ),
        m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
        m_customOptions( config.customOptions() )
    {}

    ReporterBase::~ReporterBase() = default;

    void ReporterBase::listReporters(
        std::vector<ReporterDescription> const& descriptions ) {
        defaultListReporters(m_stream, descriptions, m_config->verbosity());
    }

    void ReporterBase::listListeners(
        std::vector<ListenerDescription> const& descriptions ) {
        defaultListListeners( m_stream, descriptions );
    }

    void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
        defaultListTests(m_stream,
                         m_colour.get(),
                         tests,
                         m_config->hasTestFilters(),
                         m_config->verbosity());
    }

    void ReporterBase::listTags(std::vector<TagInfo> const& tags) {
        defaultListTags( m_stream, tags, m_config->hasTestFilters() );
    }

} // namespace Catch




#include <ostream>

namespace Catch {
namespace {

    // Colour::LightGrey
    static constexpr Colour::Code compactDimColour = Colour::FileName;

#ifdef CATCH_PLATFORM_MAC
    static constexpr Catch::StringRef compactFailedString = "FAILED"_sr;
    static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;
#else
    static constexpr Catch::StringRef compactFailedString = "failed"_sr;
    static constexpr Catch::StringRef compactPassedString = "passed"_sr;
#endif

// Implementation of CompactReporter formatting
class AssertionPrinter {
public:
    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
    AssertionPrinter(AssertionPrinter const&) = delete;
    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_)
        : stream(_stream)
        , result(_stats.assertionResult)
        , messages(_stats.infoMessages)
        , itMessage(_stats.infoMessages.begin())
        , printInfoMessages(_printInfoMessages)
        , colourImpl(colourImpl_)
    {}

    void print() {
        printSourceInfo();

        itMessage = messages.begin();

        switch (result.getResultType()) {
        case ResultWas::Ok:
            printResultType(Colour::ResultSuccess, compactPassedString);
            printOriginalExpression();
            printReconstructedExpression();
            if (!result.hasExpression())
                printRemainingMessages(Colour::None);
            else
                printRemainingMessages();
            break;
        case ResultWas::ExpressionFailed:
            if (result.isOk())
                printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr);
            else
                printResultType(Colour::Error, compactFailedString);
            printOriginalExpression();
            printReconstructedExpression();
            printRemainingMessages();
            break;
        case ResultWas::ThrewException:
            printResultType(Colour::Error, compactFailedString);
            printIssue("unexpected exception with message:");
            printMessage();
            printExpressionWas();
            printRemainingMessages();
            break;
        case ResultWas::FatalErrorCondition:
            printResultType(Colour::Error, compactFailedString);
            printIssue("fatal error condition with message:");
            printMessage();
            printExpressionWas();
            printRemainingMessages();
            break;
        case ResultWas::DidntThrowException:
            printResultType(Colour::Error, compactFailedString);
            printIssue("expected exception, got none");
            printExpressionWas();
            printRemainingMessages();
            break;
        case ResultWas::Info:
            printResultType(Colour::None, "info"_sr);
            printMessage();
            printRemainingMessages();
            break;
        case ResultWas::Warning:
            printResultType(Colour::None, "warning"_sr);
            printMessage();
            printRemainingMessages();
            break;
        case ResultWas::ExplicitFailure:
            printResultType(Colour::Error, compactFailedString);
            printIssue("explicitly");
            printRemainingMessages(Colour::None);
            break;
        case ResultWas::ExplicitSkip:
            printResultType(Colour::Skip, "skipped"_sr);
            printMessage();
            printRemainingMessages();
            break;
            // These cases are here to prevent compiler warnings
        case ResultWas::Unknown:
        case ResultWas::FailureBit:
        case ResultWas::Exception:
            printResultType(Colour::Error, "** internal error **");
            break;
        }
    }

private:
    void printSourceInfo() const {
        stream << colourImpl->guardColour( Colour::FileName )
               << result.getSourceInfo() << ':';
    }

    void printResultType(Colour::Code colour, StringRef passOrFail) const {
        if (!passOrFail.empty()) {
            stream << colourImpl->guardColour(colour) << ' ' << passOrFail;
            stream << ':';
        }
    }

    void printIssue(char const* issue) const {
        stream << ' ' << issue;
    }

    void printExpressionWas() {
        if (result.hasExpression()) {
            stream << ';';
            {
                stream << colourImpl->guardColour(compactDimColour) << " expression was:";
            }
            printOriginalExpression();
        }
    }

    void printOriginalExpression() const {
        if (result.hasExpression()) {
            stream << ' ' << result.getExpression();
        }
    }

    void printReconstructedExpression() const {
        if (result.hasExpandedExpression()) {
            stream << colourImpl->guardColour(compactDimColour) << " for: ";
            stream << result.getExpandedExpression();
        }
    }

    void printMessage() {
        if (itMessage != messages.end()) {
            stream << " '" << itMessage->message << '\'';
            ++itMessage;
        }
    }

    void printRemainingMessages(Colour::Code colour = compactDimColour) {
        if (itMessage == messages.end())
            return;

        const auto itEnd = messages.cend();
        const auto N = static_cast<std::size_t>(itEnd - itMessage);

        stream << colourImpl->guardColour( colour ) << " with "
               << pluralise( N, "message"_sr ) << ':';

        while (itMessage != itEnd) {
            // If this assertion is a warning ignore any INFO messages
            if (printInfoMessages || itMessage->type != ResultWas::Info) {
                printMessage();
                if (itMessage != itEnd) {
                    stream << colourImpl->guardColour(compactDimColour) << " and";
                }
                continue;
            }
            ++itMessage;
        }
    }

private:
    std::ostream& stream;
    AssertionResult const& result;
    std::vector<MessageInfo> const& messages;
    std::vector<MessageInfo>::const_iterator itMessage;
    bool printInfoMessages;
    ColourImpl* colourImpl;
};

} // anon namespace

        std::string CompactReporter::getDescription() {
            return "Reports test results on a single line, suitable for IDEs";
        }

        void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
            m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
        }

        void CompactReporter::testRunStarting( TestRunInfo const& ) {
            if ( m_config->testSpec().hasFilters() ) {
                m_stream << m_colour->guardColour( Colour::BrightYellow )
                         << "Filters: "
                         << m_config->testSpec()
                         << '\n';
            }
            m_stream << "RNG seed: " << getSeed() << '\n'
                     << std::flush;
        }

        void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
            AssertionResult const& result = _assertionStats.assertionResult;

            bool printInfoMessages = true;

            // Drop out if result was successful and we're not printing those
            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
                if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
                    return;
                printInfoMessages = false;
            }

            AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() );
            printer.print();

            m_stream << '\n' << std::flush;
        }

        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
            double dur = _sectionStats.durationInSeconds;
            if ( shouldShowDuration( *m_config, dur ) ) {
                m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
            }
        }

        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
            printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
            m_stream << "\n\n" << std::flush;
            StreamingReporterBase::testRunEnded( _testRunStats );
        }

        CompactReporter::~CompactReporter() = default;

} // end namespace Catch




#include <cstdio>

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
 // Note that 4062 (not all labels are handled and default is missing) is enabled
#endif

#if defined(__clang__)
#  pragma clang diagnostic push
// For simplicity, benchmarking-only helpers are always enabled
#  pragma clang diagnostic ignored "-Wunused-function"
#endif



namespace Catch {

namespace {

// Formatter impl for ConsoleReporter
class ConsoleAssertionPrinter {
public:
    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages)
        : stream(_stream),
        stats(_stats),
        result(_stats.assertionResult),
        colour(Colour::None),
        messages(_stats.infoMessages),
        colourImpl(colourImpl_),
        printInfoMessages(_printInfoMessages) {
        switch (result.getResultType()) {
        case ResultWas::Ok:
            colour = Colour::Success;
            passOrFail = "PASSED"_sr;
            //if( result.hasMessage() )
            if (messages.size() == 1)
                messageLabel = "with message"_sr;
            if (messages.size() > 1)
                messageLabel = "with messages"_sr;
            break;
        case ResultWas::ExpressionFailed:
            if (result.isOk()) {
                colour = Colour::Success;
                passOrFail = "FAILED - but was ok"_sr;
            } else {
                colour = Colour::Error;
                passOrFail = "FAILED"_sr;
            }
            if (messages.size() == 1)
                messageLabel = "with message"_sr;
            if (messages.size() > 1)
                messageLabel = "with messages"_sr;
            break;
        case ResultWas::ThrewException:
            colour = Colour::Error;
            passOrFail = "FAILED"_sr;
            // todo switch
            switch (messages.size()) { case 0:
                messageLabel = "due to unexpected exception with "_sr;
                break;
            case 1:
                messageLabel = "due to unexpected exception with message"_sr;
                break;
            default:
                messageLabel = "due to unexpected exception with messages"_sr;
                break;
            }
            break;
        case ResultWas::FatalErrorCondition:
            colour = Colour::Error;
            passOrFail = "FAILED"_sr;
            messageLabel = "due to a fatal error condition"_sr;
            break;
        case ResultWas::DidntThrowException:
            colour = Colour::Error;
            passOrFail = "FAILED"_sr;
            messageLabel = "because no exception was thrown where one was expected"_sr;
            break;
        case ResultWas::Info:
            messageLabel = "info"_sr;
            break;
        case ResultWas::Warning:
            messageLabel = "warning"_sr;
            break;
        case ResultWas::ExplicitFailure:
            passOrFail = "FAILED"_sr;
            colour = Colour::Error;
            if (messages.size() == 1)
                messageLabel = "explicitly with message"_sr;
            if (messages.size() > 1)
                messageLabel = "explicitly with messages"_sr;
            break;
        case ResultWas::ExplicitSkip:
            colour = Colour::Skip;
            passOrFail = "SKIPPED"_sr;
            if (messages.size() == 1)
                messageLabel = "explicitly with message"_sr;
            if (messages.size() > 1)
                messageLabel = "explicitly with messages"_sr;
            break;
            // These cases are here to prevent compiler warnings
        case ResultWas::Unknown:
        case ResultWas::FailureBit:
        case ResultWas::Exception:
            passOrFail = "** internal error **"_sr;
            colour = Colour::Error;
            break;
        }
    }

    void print() const {
        printSourceInfo();
        if (stats.totals.assertions.total() > 0) {
            printResultType();
            printOriginalExpression();
            printReconstructedExpression();
        } else {
            stream << '\n';
        }
        printMessage();
    }

private:
    void printResultType() const {
        if (!passOrFail.empty()) {
            stream << colourImpl->guardColour(colour) << passOrFail << ":\n";
        }
    }
    void printOriginalExpression() const {
        if (result.hasExpression()) {
            stream << colourImpl->guardColour( Colour::OriginalExpression )
                   << "  " << result.getExpressionInMacro() << '\n';
        }
    }
    void printReconstructedExpression() const {
        if (result.hasExpandedExpression()) {
            stream << "with expansion:\n";
            stream << colourImpl->guardColour( Colour::ReconstructedExpression )
                   << TextFlow::Column( result.getExpandedExpression() )
                          .indent( 2 )
                   << '\n';
        }
    }
    void printMessage() const {
        if (!messageLabel.empty())
            stream << messageLabel << ':' << '\n';
        for (auto const& msg : messages) {
            // If this assertion is a warning ignore any INFO messages
            if (printInfoMessages || msg.type != ResultWas::Info)
                stream << TextFlow::Column(msg.message).indent(2) << '\n';
        }
    }
    void printSourceInfo() const {
        stream << colourImpl->guardColour( Colour::FileName )
               << result.getSourceInfo() << ": ";
    }

    std::ostream& stream;
    AssertionStats const& stats;
    AssertionResult const& result;
    Colour::Code colour;
    StringRef passOrFail;
    StringRef messageLabel;
    std::vector<MessageInfo> const& messages;
    ColourImpl* colourImpl;
    bool printInfoMessages;
};

std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
    const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
    return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
}

std::size_t&
findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
    if (i > j && i > k && i > l)
        return i;
    else if (j > k && j > l)
        return j;
    else if (k > l)
        return k;
    else
        return l;
}

struct ColumnBreak {};
struct RowBreak {};
struct OutputFlush {};

class Duration {
    enum class Unit : uint8_t {
        Auto,
        Nanoseconds,
        Microseconds,
        Milliseconds,
        Seconds,
        Minutes
    };
    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;

    double m_inNanoseconds;
    Unit m_units;

public:
    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
        : m_inNanoseconds(inNanoseconds),
        m_units(units) {
        if (m_units == Unit::Auto) {
            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
                m_units = Unit::Nanoseconds;
            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
                m_units = Unit::Microseconds;
            else if (m_inNanoseconds < s_nanosecondsInASecond)
                m_units = Unit::Milliseconds;
            else if (m_inNanoseconds < s_nanosecondsInAMinute)
                m_units = Unit::Seconds;
            else
                m_units = Unit::Minutes;
        }

    }

    auto value() const -> double {
        switch (m_units) {
        case Unit::Microseconds:
            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
        case Unit::Milliseconds:
            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
        case Unit::Seconds:
            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
        case Unit::Minutes:
            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
        default:
            return m_inNanoseconds;
        }
    }
    StringRef unitsAsString() const {
        switch (m_units) {
        case Unit::Nanoseconds:
            return "ns"_sr;
        case Unit::Microseconds:
            return "us"_sr;
        case Unit::Milliseconds:
            return "ms"_sr;
        case Unit::Seconds:
            return "s"_sr;
        case Unit::Minutes:
            return "m"_sr;
        default:
            return "** internal error **"_sr;
        }

    }
    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
        return os << duration.value() << ' ' << duration.unitsAsString();
    }
};
} // end anon namespace

enum class Justification : uint8_t {
    Left,
    Right
};

struct ColumnInfo {
    std::string name;
    std::size_t width;
    Justification justification;
};

class TablePrinter {
    std::ostream& m_os;
    std::vector<ColumnInfo> m_columnInfos;
    ReusableStringStream m_oss;
    int m_currentColumn = -1;
    bool m_isOpen = false;

public:
    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
    :   m_os( os ),
        m_columnInfos( CATCH_MOVE( columnInfos ) ) {}

    auto columnInfos() const -> std::vector<ColumnInfo> const& {
        return m_columnInfos;
    }

    void open() {
        if (!m_isOpen) {
            m_isOpen = true;
            *this << RowBreak();

			TextFlow::Columns headerCols;
			for (auto const& info : m_columnInfos) {
                assert(info.width > 2);
				headerCols += TextFlow::Column(info.name).width(info.width - 2);
                headerCols += TextFlow::Spacer( 2 );
			}
			m_os << headerCols << '\n';

            m_os << lineOfChars('-') << '\n';
        }
    }
    void close() {
        if (m_isOpen) {
            *this << RowBreak();
            m_os << '\n' << std::flush;
            m_isOpen = false;
        }
    }

    template<typename T>
    friend TablePrinter& operator<< (TablePrinter& tp, T const& value) {
        tp.m_oss << value;
        return tp;
    }

    friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) {
        auto colStr = tp.m_oss.str();
        const auto strSize = colStr.size();
        tp.m_oss.str("");
        tp.open();
        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
            tp.m_currentColumn = -1;
            tp.m_os << '\n';
        }
        tp.m_currentColumn++;

        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
        auto padding = (strSize + 1 < colInfo.width)
            ? std::string(colInfo.width - (strSize + 1), ' ')
            : std::string();
        if (colInfo.justification == Justification::Left)
            tp.m_os << colStr << padding << ' ';
        else
            tp.m_os << padding << colStr << ' ';
        return tp;
    }

    friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) {
        if (tp.m_currentColumn > 0) {
            tp.m_os << '\n';
            tp.m_currentColumn = -1;
        }
        return tp;
    }

    friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) {
        tp.m_os << std::flush;
        return tp;
    }
};

ConsoleReporter::ConsoleReporter(ReporterConfig&& config):
    StreamingReporterBase( CATCH_MOVE( config ) ),
    m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream,
        [&config]() -> std::vector<ColumnInfo> {
        if (config.fullConfig()->benchmarkNoAnalysis())
        {
            return{
                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
                { "     samples", 14, Justification::Right },
                { "  iterations", 14, Justification::Right },
                { "        mean", 14, Justification::Right }
            };
        }
        else
        {
            return{
                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
                { "samples      mean       std dev", 14, Justification::Right },
                { "iterations   low mean   low std dev", 14, Justification::Right },
                { "est run time high mean  high std dev", 14, Justification::Right }
            };
        }
    }())) {
    m_preferences.shouldReportAllAssertionStarts = false;
}

ConsoleReporter::~ConsoleReporter() = default;

std::string ConsoleReporter::getDescription() {
    return "Reports test results as plain lines of text";
}

void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
    m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
}

void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) {
    m_stream << "Invalid Filter: " << arg << '\n';
}

void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
    AssertionResult const& result = _assertionStats.assertionResult;

    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();

    // Drop out if result was successful but we're not printing them.
    // TODO: Make configurable whether skips should be printed
    if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
        return;

    lazyPrint();

    ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults);
    printer.print();
    m_stream << '\n' << std::flush;
}

void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
    m_tablePrinter->close();
    m_headerPrinted = false;
    StreamingReporterBase::sectionStarting(_sectionInfo);
}
void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
    m_tablePrinter->close();
    if (_sectionStats.missingAssertions) {
        lazyPrint();
        auto guard =
            m_colour->guardColour( Colour::ResultError ).engage( m_stream );
        if (m_sectionStack.size() > 1)
            m_stream << "\nNo assertions in section";
        else
            m_stream << "\nNo assertions in test case";
        m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush;
    }
    double dur = _sectionStats.durationInSeconds;
    if (shouldShowDuration(*m_config, dur)) {
        m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
    }
    if (m_headerPrinted) {
        m_headerPrinted = false;
    }
    StreamingReporterBase::sectionEnded(_sectionStats);
}

void ConsoleReporter::benchmarkPreparing( StringRef name ) {
	lazyPrintWithoutClosingBenchmarkTable();

	auto nameCol = TextFlow::Column( static_cast<std::string>( name ) )
                       .width( m_tablePrinter->columnInfos()[0].width - 2 );

	bool firstLine = true;
	for (auto line : nameCol) {
		if (!firstLine)
			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
		else
			firstLine = false;

		(*m_tablePrinter) << line << ColumnBreak();
	}
}

void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
    (*m_tablePrinter) << info.samples << ColumnBreak()
        << info.iterations << ColumnBreak();
    if ( !m_config->benchmarkNoAnalysis() ) {
        ( *m_tablePrinter )
            << Duration( info.estimatedDuration ) << ColumnBreak();
    }
    ( *m_tablePrinter ) << OutputFlush{};
}
void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
    if (m_config->benchmarkNoAnalysis())
    {
        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
    }
    else
    {
        (*m_tablePrinter) << ColumnBreak()
            << Duration(stats.mean.point.count()) << ColumnBreak()
            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
    }
}

void ConsoleReporter::benchmarkFailed( StringRef error ) {
    auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream );
    (*m_tablePrinter)
        << "Benchmark failed (" << error << ')'
        << ColumnBreak() << RowBreak();
}

void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
    m_tablePrinter->close();
    StreamingReporterBase::testCaseEnded(_testCaseStats);
    m_headerPrinted = false;
}
void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
    printTotalsDivider(_testRunStats.totals);
    printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
    m_stream << '\n' << std::flush;
    StreamingReporterBase::testRunEnded(_testRunStats);
}
void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) {
    StreamingReporterBase::testRunStarting(_testRunInfo);
    if ( m_config->testSpec().hasFilters() ) {
        m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
                 << m_config->testSpec() << '\n';
    }
    m_stream << "Randomness seeded to: " << getSeed() << '\n'
             << std::flush;
}

void ConsoleReporter::lazyPrint() {

    m_tablePrinter->close();
    lazyPrintWithoutClosingBenchmarkTable();
}

void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {

    if ( !m_testRunInfoPrinted ) {
        lazyPrintRunInfo();
    }
    if (!m_headerPrinted) {
        printTestCaseAndSectionHeader();
        m_headerPrinted = true;
    }
}
void ConsoleReporter::lazyPrintRunInfo() {
    m_stream << '\n'
             << lineOfChars( '~' ) << '\n'
             << m_colour->guardColour( Colour::SecondaryText )
             << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
             << " host application.\n"
             << "Run with -? for options\n\n";

    m_testRunInfoPrinted = true;
}
void ConsoleReporter::printTestCaseAndSectionHeader() {
    assert(!m_sectionStack.empty());
    printOpenHeader(currentTestCaseInfo->name);

    if (m_sectionStack.size() > 1) {
        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );

        auto
            it = m_sectionStack.begin() + 1, // Skip first section (test case)
            itEnd = m_sectionStack.end();
        for (; it != itEnd; ++it)
            printHeaderString(it->name, 2);
    }

    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;


    m_stream << lineOfChars( '-' ) << '\n'
             << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n'
             << lineOfChars( '.' ) << "\n\n"
             << std::flush;
}

void ConsoleReporter::printClosedHeader(std::string const& _name) {
    printOpenHeader(_name);
    m_stream << lineOfChars('.') << '\n';
}
void ConsoleReporter::printOpenHeader(std::string const& _name) {
    m_stream << lineOfChars('-') << '\n';
    {
        auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
        printHeaderString(_name);
    }
}

void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
    // We want to get a bit fancy with line breaking here, so that subsequent
    // lines start after ":" if one is present, e.g.
    // ```
    // blablabla: Fancy
    //            linebreaking
    // ```
    // but we also want to avoid problems with overly long indentation causing
    // the text to take up too many lines, e.g.
    // ```
    // blablabla: F
    //            a
    //            n
    //            c
    //            y
    //            .
    //            .
    //            .
    // ```
    // So we limit the prefix indentation check to first quarter of the possible
    // width
    std::size_t idx = _string.find( ": " );
    if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) {
        idx += 2;
    } else {
        idx = 0;
    }
    m_stream << TextFlow::Column( _string )
                  .indent( indent + idx )
                  .initialIndent( indent )
           << '\n';
}

void ConsoleReporter::printTotalsDivider(Totals const& totals) {
    if (totals.testCases.total() > 0) {
        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
        std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
        while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
            findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
            findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;

        m_stream << m_colour->guardColour( Colour::Error )
                 << std::string( failedRatio, '=' )
                 << m_colour->guardColour( Colour::ResultExpectedFailure )
                 << std::string( failedButOkRatio, '=' );
        if ( totals.testCases.allPassed() ) {
            m_stream << m_colour->guardColour( Colour::ResultSuccess )
                     << std::string( passedRatio, '=' );
        } else {
            m_stream << m_colour->guardColour( Colour::Success )
                     << std::string( passedRatio, '=' );
        }
        m_stream << m_colour->guardColour( Colour::Skip )
                 << std::string( skippedRatio, '=' );
    } else {
        m_stream << m_colour->guardColour( Colour::Warning )
                 << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
    }
    m_stream << '\n';
}

} // end namespace Catch

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

#if defined(__clang__)
#  pragma clang diagnostic pop
#endif




#include <algorithm>
#include <cassert>

namespace Catch {
    namespace {
        struct BySectionInfo {
            BySectionInfo( SectionInfo const& other ): m_other( other ) {}
            BySectionInfo( BySectionInfo const& other ) = default;
            bool operator()(
                Detail::unique_ptr<CumulativeReporterBase::SectionNode> const&
                    node ) const {
                return (
                    ( node->stats.sectionInfo.name == m_other.name ) &&
                    ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) );
            }
            void operator=( BySectionInfo const& ) = delete;

        private:
            SectionInfo const& m_other;
        };

    } // namespace

    namespace Detail {
        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
            AssertionStats const& assertion ):
            m_assertion( assertion ) {}

        AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
            BenchmarkStats<> const& benchmark ):
            m_benchmark( benchmark ) {}

        bool AssertionOrBenchmarkResult::isAssertion() const {
            return m_assertion.some();
        }
        bool AssertionOrBenchmarkResult::isBenchmark() const {
            return m_benchmark.some();
        }

        AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
            assert(m_assertion.some());

            return *m_assertion;
        }
        BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const {
            assert(m_benchmark.some());

            return *m_benchmark;
        }

    }

    CumulativeReporterBase::~CumulativeReporterBase() = default;

    void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
        m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats);
    }

    void
    CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
        // We need a copy, because SectionStats expect to take ownership
        SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
        SectionNode* node;
        if ( m_sectionStack.empty() ) {
            if ( !m_rootSection ) {
                m_rootSection =
                    Detail::make_unique<SectionNode>( incompleteStats );
            }
            node = m_rootSection.get();
        } else {
            SectionNode& parentNode = *m_sectionStack.back();
            auto it = std::find_if( parentNode.childSections.begin(),
                                    parentNode.childSections.end(),
                                    BySectionInfo( sectionInfo ) );
            if ( it == parentNode.childSections.end() ) {
                auto newNode =
                    Detail::make_unique<SectionNode>( incompleteStats );
                node = newNode.get();
                parentNode.childSections.push_back( CATCH_MOVE( newNode ) );
            } else {
                node = it->get();
            }
        }

        m_deepestSection = node;
        m_sectionStack.push_back( node );
    }

    void CumulativeReporterBase::assertionEnded(
        AssertionStats const& assertionStats ) {
        assert( !m_sectionStack.empty() );
        // AssertionResult holds a pointer to a temporary DecomposedExpression,
        // which getExpandedExpression() calls to build the expression string.
        // Our section stack copy of the assertionResult will likely outlive the
        // temporary, so it must be expanded or discarded now to avoid calling
        // a destroyed object later.
        if ( m_shouldStoreFailedAssertions &&
             !assertionStats.assertionResult.isOk() ) {
            static_cast<void>(
                assertionStats.assertionResult.getExpandedExpression() );
        }
        if ( m_shouldStoreSuccesfulAssertions &&
             assertionStats.assertionResult.isOk() ) {
            static_cast<void>(
                assertionStats.assertionResult.getExpandedExpression() );
        }
        SectionNode& sectionNode = *m_sectionStack.back();
        sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats );
    }

    void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) {
        assert( !m_sectionStack.empty() );
        SectionNode& node = *m_sectionStack.back();
        node.stats = sectionStats;
        m_sectionStack.pop_back();
    }

    void CumulativeReporterBase::testCaseEnded(
        TestCaseStats const& testCaseStats ) {
        auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
        assert( m_sectionStack.size() == 0 );
        node->children.push_back( CATCH_MOVE(m_rootSection) );
        m_testCases.push_back( CATCH_MOVE(node) );

        assert( m_deepestSection );
        m_deepestSection->stdOut = testCaseStats.stdOut;
        m_deepestSection->stdErr = testCaseStats.stdErr;
    }


    void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) {
        assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run");
        m_testRun = Detail::make_unique<TestRunNode>( testRunStats );
        m_testRun->children.swap( m_testCases );
        testRunEndedCumulative();
    }

    bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const {
        return std::any_of(
            assertionsAndBenchmarks.begin(),
            assertionsAndBenchmarks.end(),
            []( Detail::AssertionOrBenchmarkResult const& res ) {
                return res.isAssertion();
            } );
    }

} // end namespace Catch




namespace Catch {

    void EventListenerBase::fatalErrorEncountered( StringRef ) {}

    void EventListenerBase::benchmarkPreparing( StringRef ) {}
    void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {}
    void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {}
    void EventListenerBase::benchmarkFailed( StringRef ) {}

    void EventListenerBase::assertionStarting( AssertionInfo const& ) {}

    void EventListenerBase::assertionEnded( AssertionStats const& ) {}
    void EventListenerBase::listReporters(
        std::vector<ReporterDescription> const& ) {}
    void EventListenerBase::listListeners(
        std::vector<ListenerDescription> const& ) {}
    void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {}
    void EventListenerBase::listTags( std::vector<TagInfo> const& ) {}
    void EventListenerBase::noMatchingTestCases( StringRef ) {}
    void EventListenerBase::reportInvalidTestSpec( StringRef ) {}
    void EventListenerBase::testRunStarting( TestRunInfo const& ) {}
    void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {}
    void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {}
    void EventListenerBase::sectionStarting( SectionInfo const& ) {}
    void EventListenerBase::sectionEnded( SectionStats const& ) {}
    void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {}
    void EventListenerBase::testCaseEnded( TestCaseStats const& ) {}
    void EventListenerBase::testRunEnded( TestRunStats const& ) {}
    void EventListenerBase::skipTest( TestCaseInfo const& ) {}
} // namespace Catch




#include <algorithm>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <ostream>
#include <iomanip>

namespace Catch {

    namespace {
        void listTestNamesOnly(std::ostream& out,
                               std::vector<TestCaseHandle> const& tests) {
            for (auto const& test : tests) {
                auto const& testCaseInfo = test.getTestCaseInfo();

                if (startsWith(testCaseInfo.name, '#')) {
                    out << '"' << testCaseInfo.name << '"';
                } else {
                    out << testCaseInfo.name;
                }

                out << '\n';
            }
            out << std::flush;
        }
    } // end unnamed namespace


    // Because formatting using c++ streams is stateful, drop down to C is
    // required Alternatively we could use stringstream, but its performance
    // is... not good.
    std::string getFormattedDuration( double duration ) {
        // Max exponent + 1 is required to represent the whole part
        // + 1 for decimal point
        // + 3 for the 3 decimal places
        // + 1 for null terminator
        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
        char buffer[maxDoubleSize];

        // Save previous errno, to prevent sprintf from overwriting it
        ErrnoGuard guard;
#ifdef _MSC_VER
        size_t printedLength = static_cast<size_t>(
            sprintf_s( buffer, "%.3f", duration ) );
#else
        size_t printedLength = static_cast<size_t>(
            std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );
#endif
        return std::string( buffer, printedLength );
    }

    bool shouldShowDuration( IConfig const& config, double duration ) {
        if ( config.showDurations() == ShowDurations::Always ) {
            return true;
        }
        if ( config.showDurations() == ShowDurations::Never ) {
            return false;
        }
        const double min = config.minDuration();
        return min >= 0 && duration >= min;
    }

    std::string serializeFilters( std::vector<std::string> const& filters ) {
        // We add a ' ' separator between each filter
        size_t serialized_size = filters.size() - 1;
        for (auto const& filter : filters) {
            serialized_size += filter.size();
        }

        std::string serialized;
        serialized.reserve(serialized_size);
        bool first = true;

        for (auto const& filter : filters) {
            if (!first) {
                serialized.push_back(' ');
            }
            first = false;
            serialized.append(filter);
        }

        return serialized;
    }

    std::ostream& operator<<( std::ostream& out, lineOfChars value ) {
        for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) {
            out.put( value.c );
        }
        return out;
    }

    void
    defaultListReporters( std::ostream& out,
                          std::vector<ReporterDescription> const& descriptions,
                          Verbosity verbosity ) {
        out << "Available reporters:\n";
        const auto maxNameLen =
            std::max_element( descriptions.begin(),
                              descriptions.end(),
                              []( ReporterDescription const& lhs,
                                  ReporterDescription const& rhs ) {
                                  return lhs.name.size() < rhs.name.size();
                              } )
                ->name.size();

        for ( auto const& desc : descriptions ) {
            if ( verbosity == Verbosity::Quiet ) {
                out << TextFlow::Column( desc.name )
                           .indent( 2 )
                           .width( 5 + maxNameLen )
                    << '\n';
            } else {
                out << TextFlow::Column( desc.name + ':' )
                               .indent( 2 )
                               .width( 5 + maxNameLen ) +
                           TextFlow::Column( desc.description )
                               .initialIndent( 0 )
                               .indent( 2 )
                               .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
                    << '\n';
            }
        }
        out << '\n' << std::flush;
    }

    void defaultListListeners( std::ostream& out,
                               std::vector<ListenerDescription> const& descriptions ) {
        out << "Registered listeners:\n";

        if(descriptions.empty()) {
            return;
        }

        const auto maxNameLen =
            std::max_element( descriptions.begin(),
                              descriptions.end(),
                              []( ListenerDescription const& lhs,
                                  ListenerDescription const& rhs ) {
                                  return lhs.name.size() < rhs.name.size();
                              } )
                ->name.size();

        for ( auto const& desc : descriptions ) {
            out << TextFlow::Column( static_cast<std::string>( desc.name ) +
                                     ':' )
                           .indent( 2 )
                           .width( maxNameLen + 5 ) +
                       TextFlow::Column( desc.description )
                           .initialIndent( 0 )
                           .indent( 2 )
                           .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
                << '\n';
        }

        out << '\n' << std::flush;
    }

    void defaultListTags( std::ostream& out,
                          std::vector<TagInfo> const& tags,
                          bool isFiltered ) {
        if ( isFiltered ) {
            out << "Tags for matching test cases:\n";
        } else {
            out << "All available tags:\n";
        }

        // minimum whitespace to pad tag counts, possibly overwritten below
        size_t maxTagCountLen = 2;

        // determine necessary padding for tag count column
        if ( ! tags.empty() ) {
            const auto maxTagCount =
                std::max_element( tags.begin(),
                                  tags.end(),
                                  []( auto const& lhs, auto const& rhs ) {
                                      return lhs.count < rhs.count;
                                  } )
                    ->count;
            
            // more padding necessary for 3+ digits
            if (maxTagCount >= 100) {
                auto numDigits = 1 + std::floor( std::log10( maxTagCount ) );
                maxTagCountLen = static_cast<size_t>( numDigits );
            }
        }

        for ( auto const& tagCount : tags ) {
            ReusableStringStream rss;
            rss << "  " << std::setw( maxTagCountLen ) << tagCount.count << "  ";
            auto str = rss.str();
            auto wrapper = TextFlow::Column( tagCount.all() )
                               .initialIndent( 0 )
                               .indent( str.size() )
                               .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 );
            out << str << wrapper << '\n';
        }
        out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush;
    }

    void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) {
        // We special case this to provide the equivalent of old
        // `--list-test-names-only`, which could then be used by the
        // `--input-file` option.
        if (verbosity == Verbosity::Quiet) {
            listTestNamesOnly(out, tests);
            return;
        }

        if (isFiltered) {
            out << "Matching test cases:\n";
        } else {
            out << "All available test cases:\n";
        }

        for (auto const& test : tests) {
            auto const& testCaseInfo = test.getTestCaseInfo();
            Colour::Code colour = testCaseInfo.isHidden()
                ? Colour::SecondaryText
                : Colour::None;
            auto colourGuard = streamColour->guardColour( colour ).engage( out );

            out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n';
            if (verbosity >= Verbosity::High) {
                out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n';
            }
            if (!testCaseInfo.tags.empty() &&
                verbosity > Verbosity::Quiet) {
                out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n';
            }
        }

        if (isFiltered) {
            out << pluralise(tests.size(), "matching test case"_sr);
        } else {
            out << pluralise(tests.size(), "test case"_sr);
        }
        out << "\n\n" << std::flush;
    }

    namespace {
        class SummaryColumn {
        public:
            SummaryColumn( std::string suffix, Colour::Code colour ):
                m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}

            SummaryColumn&& addRow( std::uint64_t count ) && {
                std::string row = std::to_string(count);
                auto const new_width = std::max( m_width, row.size() );
                if ( new_width > m_width ) {
                    for ( auto& oldRow : m_rows ) {
                        oldRow.insert( 0, new_width - m_width, ' ' );
                    }
                } else {
                    row.insert( 0, m_width - row.size(), ' ' );
                }
                m_width = new_width;
                m_rows.push_back( row );
                return std::move( *this );
            }

            std::string const& getSuffix() const { return m_suffix; }
            Colour::Code getColour() const { return m_colour; }
            std::string const& getRow( std::size_t index ) const {
                return m_rows[index];
            }

        private:
            std::string m_suffix;
            Colour::Code m_colour;
            std::size_t m_width = 0;
            std::vector<std::string> m_rows;
        };

        void printSummaryRow( std::ostream& stream,
                              ColourImpl& colour,
                              StringRef label,
                              std::vector<SummaryColumn> const& cols,
                              std::size_t row ) {
            for ( auto const& col : cols ) {
                auto const& value = col.getRow( row );
                auto const& suffix = col.getSuffix();
                if ( suffix.empty() ) {
                    stream << label << ": ";
                    if ( value != "0" ) {
                        stream << value;
                    } else {
                        stream << colour.guardColour( Colour::Warning )
                               << "- none -";
                    }
                } else if ( value != "0" ) {
                    stream << colour.guardColour( Colour::LightGrey ) << " | "
                           << colour.guardColour( col.getColour() ) << value
                           << ' ' << suffix;
                }
            }
            stream << '\n';
        }
    } // namespace

    void printTestRunTotals( std::ostream& stream,
                             ColourImpl& streamColour,
                             Totals const& totals ) {
        if ( totals.testCases.total() == 0 ) {
            stream << streamColour.guardColour( Colour::Warning )
                   << "No tests ran\n";
            return;
        }

        if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
            stream << streamColour.guardColour( Colour::ResultSuccess )
                   << "All tests passed";
            stream << " ("
                   << pluralise( totals.assertions.passed, "assertion"_sr )
                   << " in "
                   << pluralise( totals.testCases.passed, "test case"_sr )
                   << ')' << '\n';
            return;
        }

        std::vector<SummaryColumn> columns;
        // Don't include "skipped assertions" in total count
        const auto totalAssertionCount =
            totals.assertions.total() - totals.assertions.skipped;
        columns.push_back( SummaryColumn( "", Colour::None )
                               .addRow( totals.testCases.total() )
                               .addRow( totalAssertionCount ) );
        columns.push_back( SummaryColumn( "passed", Colour::Success )
                               .addRow( totals.testCases.passed )
                               .addRow( totals.assertions.passed ) );
        columns.push_back( SummaryColumn( "failed", Colour::ResultError )
                               .addRow( totals.testCases.failed )
                               .addRow( totals.assertions.failed ) );
        columns.push_back( SummaryColumn( "skipped", Colour::Skip )
                               .addRow( totals.testCases.skipped )
                               // Don't print "skipped assertions"
                               .addRow( 0 ) );
        columns.push_back(
            SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
                .addRow( totals.testCases.failedButOk )
                .addRow( totals.assertions.failedButOk ) );
        printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
        printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
    }

} // namespace Catch


//

namespace Catch {
    namespace {
        void writeSourceInfo( JsonObjectWriter& writer,
                              SourceLineInfo const& sourceInfo ) {
            auto source_location_writer =
                writer.write( "source-location"_sr ).writeObject();
            source_location_writer.write( "filename"_sr )
                .write( sourceInfo.file );
            source_location_writer.write( "line"_sr ).write( sourceInfo.line );
        }

        void writeTags( JsonArrayWriter writer, std::vector<Tag> const& tags ) {
            for ( auto const& tag : tags ) {
                writer.write( tag.original );
            }
        }

        void writeProperties( JsonArrayWriter writer,
                              TestCaseInfo const& info ) {
            if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); }
            if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); }
            if ( info.expectedToFail() ) {
                writer.write( "expected-to-fail"_sr );
            }
            if ( info.throws() ) { writer.write( "throws"_sr ); }
        }

    } // namespace

    JsonReporter::JsonReporter( ReporterConfig&& config ):
        StreamingReporterBase{ CATCH_MOVE( config ) } {

        m_preferences.shouldRedirectStdOut = true;
        // TBD: Do we want to report all assertions? XML reporter does
        //      not, but for machine-parseable reporters I think the answer
        //      should be yes.
        m_preferences.shouldReportAllAssertions = true;
        // We only handle assertions when they end
        m_preferences.shouldReportAllAssertionStarts = false;

        m_objectWriters.emplace( m_stream );
        m_writers.emplace( Writer::Object );
        auto& writer = m_objectWriters.top();

        writer.write( "version"_sr ).write( 1 );

        {
            auto metadata_writer = writer.write( "metadata"_sr ).writeObject();
            metadata_writer.write( "name"_sr ).write( m_config->name() );
            metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() );
            metadata_writer.write( "catch2-version"_sr )
                .write( libraryVersion() );
            if ( m_config->testSpec().hasFilters() ) {
                metadata_writer.write( "filters"_sr )
                    .write( m_config->testSpec() );
            }
        }
    }

    JsonReporter::~JsonReporter() {
        endListing();
        // TODO: Ensure this closes the top level object, add asserts
        assert( m_writers.size() == 1 && "Only the top level object should be open" );
        assert( m_writers.top() == Writer::Object );
        endObject();
        m_stream << '\n' << std::flush;
        assert( m_writers.empty() );
    }

    JsonArrayWriter& JsonReporter::startArray() {
        m_arrayWriters.emplace( m_arrayWriters.top().writeArray() );
        m_writers.emplace( Writer::Array );
        return m_arrayWriters.top();
    }
    JsonArrayWriter& JsonReporter::startArray( StringRef key ) {
        m_arrayWriters.emplace(
            m_objectWriters.top().write( key ).writeArray() );
        m_writers.emplace( Writer::Array );
        return m_arrayWriters.top();
    }

    JsonObjectWriter& JsonReporter::startObject() {
        m_objectWriters.emplace( m_arrayWriters.top().writeObject() );
        m_writers.emplace( Writer::Object );
        return m_objectWriters.top();
    }
    JsonObjectWriter& JsonReporter::startObject( StringRef key ) {
        m_objectWriters.emplace(
            m_objectWriters.top().write( key ).writeObject() );
        m_writers.emplace( Writer::Object );
        return m_objectWriters.top();
    }

    void JsonReporter::endObject() {
        assert( isInside( Writer::Object ) );
        m_objectWriters.pop();
        m_writers.pop();
    }
    void JsonReporter::endArray() {
        assert( isInside( Writer::Array ) );
        m_arrayWriters.pop();
        m_writers.pop();
    }

    bool JsonReporter::isInside( Writer writer ) {
        return !m_writers.empty() && m_writers.top() == writer;
    }

    void JsonReporter::startListing() {
        if ( !m_startedListing ) { startObject( "listings"_sr ); }
        m_startedListing = true;
    }
    void JsonReporter::endListing() {
        if ( m_startedListing ) { endObject(); }
        m_startedListing = false;
    }

    std::string JsonReporter::getDescription() {
        return "Outputs listings as JSON. Test listing is Work-in-Progress!";
    }

    void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) {
        StreamingReporterBase::testRunStarting( runInfo );
        endListing();

        assert( isInside( Writer::Object ) );
        startObject( "test-run"_sr );
        startArray( "test-cases"_sr );
    }

     static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) {
        writer.write( "passed"_sr ).write( counts.passed );
        writer.write( "failed"_sr ).write( counts.failed );
        writer.write( "fail-but-ok"_sr ).write( counts.failedButOk );
        writer.write( "skipped"_sr ).write( counts.skipped );
    }

    void JsonReporter::testRunEnded(TestRunStats const& runStats) {
        assert( isInside( Writer::Array ) );
        // End "test-cases"
        endArray();

        {
            auto totals =
                m_objectWriters.top().write( "totals"_sr ).writeObject();
            writeCounts( totals.write( "assertions"_sr ).writeObject(),
                         runStats.totals.assertions );
            writeCounts( totals.write( "test-cases"_sr ).writeObject(),
                         runStats.totals.testCases );
        }

        // End the "test-run" object
        endObject();
    }

    void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) {
        StreamingReporterBase::testCaseStarting( tcInfo );

        assert( isInside( Writer::Array ) &&
                "We should be in the 'test-cases' array" );
        startObject();
        // "test-info" prelude
        {
            auto testInfo =
                m_objectWriters.top().write( "test-info"_sr ).writeObject();
            // TODO: handle testName vs className!!
            testInfo.write( "name"_sr ).write( tcInfo.name );
            writeSourceInfo(testInfo, tcInfo.lineInfo);
            writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags );
            writeProperties( testInfo.write( "properties"_sr ).writeArray(),
                             tcInfo );
        }


        // Start the array for individual test runs (testCasePartial pairs)
        startArray( "runs"_sr );
    }

    void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) {
        StreamingReporterBase::testCaseEnded( tcStats );

        // We need to close the 'runs' array before finishing the test case
        assert( isInside( Writer::Array ) );
        endArray();

        {
            auto totals =
                m_objectWriters.top().write( "totals"_sr ).writeObject();
            writeCounts( totals.write( "assertions"_sr ).writeObject(),
                         tcStats.totals.assertions );
            // We do not write the test case totals, because there will always be just one test case here.
            // TODO: overall "result" -> success, skip, fail here? Or in partial result?
        }
        // We do not write out stderr/stdout, because we instead wrote those out in partial runs

        // TODO: aborting?

        // And we also close this test case's object
        assert( isInside( Writer::Object ) );
        endObject();
    }

    void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/,
                                                uint64_t index ) {
        startObject();
        m_objectWriters.top().write( "run-idx"_sr ).write( index );
        startArray( "path"_sr );
        // TODO: we want to delay most of the printing to the 'root' section
        // TODO: childSection key name?
    }

    void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats,
                                             uint64_t /*index*/ ) {
        // Fixme: the top level section handles this.
        //// path object
        endArray();
        if ( !tcStats.stdOut.empty() ) {
            m_objectWriters.top()
                .write( "captured-stdout"_sr )
                .write( tcStats.stdOut );
        }
        if ( !tcStats.stdErr.empty() ) {
            m_objectWriters.top()
                .write( "captured-stderr"_sr )
                .write( tcStats.stdErr );
        }
        {
            auto totals =
                m_objectWriters.top().write( "totals"_sr ).writeObject();
            writeCounts( totals.write( "assertions"_sr ).writeObject(),
                         tcStats.totals.assertions );
            // We do not write the test case totals, because there will
            // always be just one test case here.
            // TODO: overall "result" -> success, skip, fail here? Or in
            // partial result?
        }
        // TODO: aborting?
        // run object
        endObject();
    }

    void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) {
        assert( isInside( Writer::Array ) &&
                "Section should always start inside an object" );
        // We want to nest top level sections, even though it shares name
        // and source loc with the TEST_CASE
        auto& sectionObject = startObject();
        sectionObject.write( "kind"_sr ).write( "section"_sr );
        sectionObject.write( "name"_sr ).write( sectionInfo.name );
        writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo );


        // TBD: Do we want to create this event lazily? It would become
        //      rather complex, but we could do it, and it would look
        //      better for empty sections. OTOH, empty sections should
        //      be rare.
        startArray( "path"_sr );
    }
    void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) {
        // End the subpath array
        endArray();
        // TODO: metadata
        // TODO: what info do we have here?

        // End the section object
        endObject();
    }

    void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) {
        // TODO: There is lot of different things to handle here, but
        //       we can fill it in later, after we show that the basic
        //       outline and streaming reporter impl works well enough.
        //if ( !m_config->includeSuccessfulResults()
        //    && assertionStats.assertionResult.isOk() ) {
        //    return;
        //}
        assert( isInside( Writer::Array ) );
        auto assertionObject = m_arrayWriters.top().writeObject();

        assertionObject.write( "kind"_sr ).write( "assertion"_sr );
        writeSourceInfo( assertionObject,
                         assertionStats.assertionResult.getSourceInfo() );
        assertionObject.write( "status"_sr )
            .write( assertionStats.assertionResult.isOk() );
        // TODO: handling of result.
        // TODO: messages
        // TODO: totals?
    }


    void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; }
    void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {}
    void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {}
    void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; }

    void JsonReporter::listReporters(
        std::vector<ReporterDescription> const& descriptions ) {
        startListing();

        auto writer =
            m_objectWriters.top().write( "reporters"_sr ).writeArray();
        for ( auto const& desc : descriptions ) {
            auto desc_writer = writer.writeObject();
            desc_writer.write( "name"_sr ).write( desc.name );
            desc_writer.write( "description"_sr ).write( desc.description );
        }
    }
    void JsonReporter::listListeners(
        std::vector<ListenerDescription> const& descriptions ) {
        startListing();

        auto writer =
            m_objectWriters.top().write( "listeners"_sr ).writeArray();

        for ( auto const& desc : descriptions ) {
            auto desc_writer = writer.writeObject();
            desc_writer.write( "name"_sr ).write( desc.name );
            desc_writer.write( "description"_sr ).write( desc.description );
        }
    }
    void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) {
        startListing();

        auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();

        for ( auto const& test : tests ) {
            auto desc_writer = writer.writeObject();
            auto const& info = test.getTestCaseInfo();

            desc_writer.write( "name"_sr ).write( info.name );
            desc_writer.write( "class-name"_sr ).write( info.className );
            {
                auto tag_writer = desc_writer.write( "tags"_sr ).writeArray();
                for ( auto const& tag : info.tags ) {
                    tag_writer.write( tag.original );
                }
            }
            writeSourceInfo( desc_writer, info.lineInfo );
        }
    }
    void JsonReporter::listTags( std::vector<TagInfo> const& tags ) {
        startListing();

        auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray();
        for ( auto const& tag : tags ) {
            auto tag_writer = writer.writeObject();
            {
                auto aliases_writer =
                    tag_writer.write( "aliases"_sr ).writeArray();
                for ( auto alias : tag.spellings ) {
                    aliases_writer.write( alias );
                }
            }
            tag_writer.write( "count"_sr ).write( tag.count );
        }
    }
} // namespace Catch




#include <cassert>
#include <ctime>
#include <algorithm>
#include <iomanip>

namespace Catch {

    namespace {
        std::string getCurrentTimestamp() {
            time_t rawtime;
            std::time(&rawtime);

            std::tm timeInfo = {};
#if defined (_MSC_VER) || defined (__MINGW32__)
            gmtime_s(&timeInfo, &rawtime);
#elif defined (CATCH_PLATFORM_PLAYSTATION)
            gmtime_s(&rawtime, &timeInfo);
#elif defined (__IAR_SYSTEMS_ICC__)
            timeInfo = *std::gmtime(&rawtime);
#else
            gmtime_r(&rawtime, &timeInfo);
#endif

            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
            char timeStamp[timeStampSize];
            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";

            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);

            return std::string(timeStamp, timeStampSize - 1);
        }

        std::string fileNameTag(std::vector<Tag> const& tags) {
            auto it = std::find_if(begin(tags),
                                   end(tags),
                                   [] (Tag const& tag) {
                                       return tag.original.size() > 0
                                           && tag.original[0] == '#'; });
            if (it != tags.end()) {
                return static_cast<std::string>(
                    it->original.substr(1, it->original.size() - 1)
                );
            }
            return std::string();
        }

        // Formats the duration in seconds to 3 decimal places.
        // This is done because some genius defined Maven Surefire schema
        // in a way that only accepts 3 decimal places, and tools like
        // Jenkins use that schema for validation JUnit reporter output.
        std::string formatDuration( double seconds ) {
            ReusableStringStream rss;
            rss << std::fixed << std::setprecision( 3 ) << seconds;
            return rss.str();
        }

        static void normalizeNamespaceMarkers(std::string& str) {
            std::size_t pos = str.find( "::" );
            while ( pos != std::string::npos ) {
                str.replace( pos, 2, "." );
                pos += 1;
                pos = str.find( "::", pos );
            }
        }

    } // anonymous namespace

    JunitReporter::JunitReporter( ReporterConfig&& _config )
        :   CumulativeReporterBase( CATCH_MOVE(_config) ),
            xml( m_stream )
        {
            m_preferences.shouldRedirectStdOut = true;
            m_preferences.shouldReportAllAssertions = false;
            m_preferences.shouldReportAllAssertionStarts = false;
            m_shouldStoreSuccesfulAssertions = false;
        }

    std::string JunitReporter::getDescription() {
        return "Reports test results in an XML format that looks like Ant's junitreport target";
    }

    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
        CumulativeReporterBase::testRunStarting( runInfo );
        xml.startElement( "testsuites" );
        suiteTimer.start();
        stdOutForSuite.clear();
        stdErrForSuite.clear();
        unexpectedExceptions = 0;
    }

    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
        m_okToFail = testCaseInfo.okToFail();
    }

    void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
            unexpectedExceptions++;
        CumulativeReporterBase::assertionEnded( assertionStats );
    }

    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
        stdOutForSuite += testCaseStats.stdOut;
        stdErrForSuite += testCaseStats.stdErr;
        CumulativeReporterBase::testCaseEnded( testCaseStats );
    }

    void JunitReporter::testRunEndedCumulative() {
        const auto suiteTime = suiteTimer.getElapsedSeconds();
        writeRun( *m_testRun, suiteTime );
        xml.endElement();
    }

    void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );

        TestRunStats const& stats = testRunNode.value;
        xml.writeAttribute( "name"_sr, stats.runInfo.name );
        xml.writeAttribute( "errors"_sr, unexpectedExceptions );
        xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
        xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
        xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
        xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
        if( m_config->showDurations() == ShowDurations::Never )
            xml.writeAttribute( "time"_sr, ""_sr );
        else
            xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) );
        xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );

        // Write properties
        {
            auto properties = xml.scopedElement("properties");
            xml.scopedElement("property")
                .writeAttribute("name"_sr, "random-seed"_sr)
                .writeAttribute("value"_sr, m_config->rngSeed());
            if (m_config->testSpec().hasFilters()) {
                xml.scopedElement("property")
                    .writeAttribute("name"_sr, "filters"_sr)
                    .writeAttribute("value"_sr, m_config->testSpec());
            }
        }

        // Write test cases
        for( auto const& child : testRunNode.children )
            writeTestCase( *child );

        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
    }

    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
        TestCaseStats const& stats = testCaseNode.value;

        // All test cases have exactly one section - which represents the
        // test case itself. That section may have 0-n nested sections
        assert( testCaseNode.children.size() == 1 );
        SectionNode const& rootSection = *testCaseNode.children.front();

        std::string className =
            static_cast<std::string>( stats.testInfo->className );

        if( className.empty() ) {
            className = fileNameTag(stats.testInfo->tags);
            if ( className.empty() ) {
                className = "global";
            }
        }

        if ( !m_config->name().empty() )
            className = static_cast<std::string>(m_config->name()) + '.' + className;

        normalizeNamespaceMarkers(className);

        writeSection( className, "", rootSection, stats.testInfo->okToFail() );
    }

    void JunitReporter::writeSection( std::string const& className,
                                      std::string const& rootName,
                                      SectionNode const& sectionNode,
                                      bool testOkToFail) {
        std::string name = trim( sectionNode.stats.sectionInfo.name );
        if( !rootName.empty() )
            name = rootName + '/' + name;

        if ( sectionNode.stats.assertions.total() > 0
           || !sectionNode.stdOut.empty()
           || !sectionNode.stdErr.empty() ) {
            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
            if( className.empty() ) {
                xml.writeAttribute( "classname"_sr, name );
                xml.writeAttribute( "name"_sr, "root"_sr );
            }
            else {
                xml.writeAttribute( "classname"_sr, className );
                xml.writeAttribute( "name"_sr, name );
            }
            xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) );
            // This is not ideal, but it should be enough to mimic gtest's
            // junit output.
            // Ideally the JUnit reporter would also handle `skipTest`
            // events and write those out appropriately.
            xml.writeAttribute( "status"_sr, "run"_sr );

            if (sectionNode.stats.assertions.failedButOk) {
                xml.scopedElement("skipped")
                    .writeAttribute("message", "TEST_CASE tagged with !mayfail");
            }

            writeAssertions( sectionNode );


            if( !sectionNode.stdOut.empty() )
                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
            if( !sectionNode.stdErr.empty() )
                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
        }
        for( auto const& childNode : sectionNode.childSections )
            if( className.empty() )
                writeSection( name, "", *childNode, testOkToFail );
            else
                writeSection( className, name, *childNode, testOkToFail );
    }

    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
            if (assertionOrBenchmark.isAssertion()) {
                writeAssertion(assertionOrBenchmark.asAssertion());
            }
        }
    }

    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
        AssertionResult const& result = stats.assertionResult;
        if ( !result.isOk() ||
             result.getResultType() == ResultWas::ExplicitSkip ) {
            std::string elementName;
            switch( result.getResultType() ) {
                case ResultWas::ThrewException:
                case ResultWas::FatalErrorCondition:
                    elementName = "error";
                    break;
                case ResultWas::ExplicitFailure:
                case ResultWas::ExpressionFailed:
                case ResultWas::DidntThrowException:
                    elementName = "failure";
                    break;
                case ResultWas::ExplicitSkip:
                    elementName = "skipped";
                    break;
                // We should never see these here:
                case ResultWas::Info:
                case ResultWas::Warning:
                case ResultWas::Ok:
                case ResultWas::Unknown:
                case ResultWas::FailureBit:
                case ResultWas::Exception:
                    elementName = "internalError";
                    break;
            }

            XmlWriter::ScopedElement e = xml.scopedElement( elementName );

            xml.writeAttribute( "message"_sr, result.getExpression() );
            xml.writeAttribute( "type"_sr, result.getTestMacroName() );

            ReusableStringStream rss;
            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
                rss << "SKIPPED\n";
            } else {
                rss << "FAILED" << ":\n";
                if (result.hasExpression()) {
                    rss << "  ";
                    rss << result.getExpressionInMacro();
                    rss << '\n';
                }
                if (result.hasExpandedExpression()) {
                    rss << "with expansion:\n";
                    rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
                }
            }

            if( result.hasMessage() )
                rss << result.getMessage() << '\n';
            for( auto const& msg : stats.infoMessages )
                if( msg.type == ResultWas::Info )
                    rss << msg.message << '\n';

            rss << "at " << result.getSourceInfo();
            xml.writeText( rss.str(), XmlFormatting::Newline );
        }
    }

} // end namespace Catch




#include <ostream>

namespace Catch {
    void MultiReporter::updatePreferences(IEventListener const& reporterish) {
        m_preferences.shouldRedirectStdOut |=
            reporterish.getPreferences().shouldRedirectStdOut;
        m_preferences.shouldReportAllAssertions |=
            reporterish.getPreferences().shouldReportAllAssertions;
        m_preferences.shouldReportAllAssertionStarts |=
            reporterish.getPreferences().shouldReportAllAssertionStarts;
    }

    void MultiReporter::addListener( IEventListenerPtr&& listener ) {
        updatePreferences(*listener);
        m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
        ++m_insertedListeners;
    }

    void MultiReporter::addReporter( IEventListenerPtr&& reporter ) {
        updatePreferences(*reporter);

        // We will need to output the captured stdout if there are reporters
        // that do not want it captured.
        // We do not consider listeners, because it is generally assumed that
        // listeners are output-transparent, even though they can ask for stdout
        // capture to do something with it.
        m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;

        // Reporters can always be placed to the back without breaking the
        // reporting order
        m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
    }

    void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->noMatchingTestCases( unmatchedSpec );
        }
    }

    void MultiReporter::fatalErrorEncountered( StringRef error ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->fatalErrorEncountered( error );
        }
    }

    void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->reportInvalidTestSpec( arg );
        }
    }

    void MultiReporter::benchmarkPreparing( StringRef name ) {
        for (auto& reporterish : m_reporterLikes) {
            reporterish->benchmarkPreparing(name);
        }
    }
    void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->benchmarkStarting( benchmarkInfo );
        }
    }
    void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->benchmarkEnded( benchmarkStats );
        }
    }

    void MultiReporter::benchmarkFailed( StringRef error ) {
        for (auto& reporterish : m_reporterLikes) {
            reporterish->benchmarkFailed(error);
        }
    }

    void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->testRunStarting( testRunInfo );
        }
    }

    void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->testCaseStarting( testInfo );
        }
    }

    void
    MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
                                                uint64_t partNumber ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->testCasePartialStarting( testInfo, partNumber );
        }
    }

    void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->sectionStarting( sectionInfo );
        }
    }

    void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->assertionStarting( assertionInfo );
        }
    }

    void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
        const bool reportByDefault =
            assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
            m_config->includeSuccessfulResults();

        for ( auto & reporterish : m_reporterLikes ) {
            if ( reportByDefault ||
                 reporterish->getPreferences().shouldReportAllAssertions ) {
                    reporterish->assertionEnded( assertionStats );
            }
        }
    }

    void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->sectionEnded( sectionStats );
        }
    }

    void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
                                                  uint64_t partNumber ) {
        if ( m_preferences.shouldRedirectStdOut &&
             m_haveNoncapturingReporters ) {
            if ( !testStats.stdOut.empty() ) {
                Catch::cout() << testStats.stdOut << std::flush;
            }
            if ( !testStats.stdErr.empty() ) {
                Catch::cerr() << testStats.stdErr << std::flush;
            }
        }

        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->testCasePartialEnded( testStats, partNumber );
        }
    }

    void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->testCaseEnded( testCaseStats );
        }
    }

    void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->testRunEnded( testRunStats );
        }
    }


    void MultiReporter::skipTest( TestCaseInfo const& testInfo ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->skipTest( testInfo );
        }
    }

    void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
        for (auto& reporterish : m_reporterLikes) {
            reporterish->listReporters(descriptions);
        }
    }

    void MultiReporter::listListeners(
        std::vector<ListenerDescription> const& descriptions ) {
        for ( auto& reporterish : m_reporterLikes ) {
            reporterish->listListeners( descriptions );
        }
    }

    void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) {
        for (auto& reporterish : m_reporterLikes) {
            reporterish->listTests(tests);
        }
    }

    void MultiReporter::listTags(std::vector<TagInfo> const& tags) {
        for (auto& reporterish : m_reporterLikes) {
            reporterish->listTags(tags);
        }
    }

} // end namespace Catch





namespace Catch {
    namespace Detail {

        void registerReporterImpl( std::string const& name,
                                   IReporterFactoryPtr reporterPtr ) {
            CATCH_TRY {
                getMutableRegistryHub().registerReporter(
                    name, CATCH_MOVE( reporterPtr ) );
            }
            CATCH_CATCH_ALL {
                // Do not throw when constructing global objects, instead
                // register the exception to be processed later
                getMutableRegistryHub().registerStartupException();
            }
        }

        void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
            getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
        }


    } // namespace Detail
} // namespace Catch




#include <map>

namespace Catch {

    namespace {
        std::string createMetadataString(IConfig const& config) {
            ReusableStringStream sstr;
            if ( config.testSpec().hasFilters() ) {
                sstr << "filters='"
                         << config.testSpec()
                         << "' ";
            }
            sstr << "rng-seed=" << config.rngSeed();
            return sstr.str();
        }
    }

    void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
        CumulativeReporterBase::testRunStarting(testRunInfo);

        xml.writeComment( createMetadataString( *m_config ) );
        xml.startElement("testExecutions");
        xml.writeAttribute("version"_sr, '1');
    }

    void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
        std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;

        for ( auto const& child : runNode.children ) {
            testsPerFile[child->value.testInfo->lineInfo.file].push_back(
                child.get() );
        }

        for ( auto const& kv : testsPerFile ) {
            writeTestFile( kv.first, kv.second );
        }
    }

    void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
        XmlWriter::ScopedElement e = xml.scopedElement("file");
        xml.writeAttribute("path"_sr, filename);

        for (auto const& child : testCaseNodes)
            writeTestCase(*child);
    }

    void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
        // All test cases have exactly one section - which represents the
        // test case itself. That section may have 0-n nested sections
        assert(testCaseNode.children.size() == 1);
        SectionNode const& rootSection = *testCaseNode.children.front();
        writeSection("", rootSection, testCaseNode.value.testInfo->okToFail());
    }

    void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
        std::string name = trim(sectionNode.stats.sectionInfo.name);
        if (!rootName.empty())
            name = rootName + '/' + name;

        if ( sectionNode.stats.assertions.total() > 0
            || !sectionNode.stdOut.empty()
            || !sectionNode.stdErr.empty() ) {
            XmlWriter::ScopedElement e = xml.scopedElement("testCase");
            xml.writeAttribute("name"_sr, name);
            xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));

            writeAssertions(sectionNode, okToFail);
        }

        for (auto const& childNode : sectionNode.childSections)
            writeSection(name, *childNode, okToFail);
    }

    void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) {
        for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
            if (assertionOrBenchmark.isAssertion()) {
                writeAssertion(assertionOrBenchmark.asAssertion(), okToFail);
            }
        }
    }

    void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
        AssertionResult const& result = stats.assertionResult;
        if ( !result.isOk() ||
             result.getResultType() == ResultWas::ExplicitSkip ) {
            std::string elementName;
            if (okToFail) {
                elementName = "skipped";
            } else {
                switch (result.getResultType()) {
                case ResultWas::ThrewException:
                case ResultWas::FatalErrorCondition:
                    elementName = "error";
                    break;
                case ResultWas::ExplicitFailure:
                case ResultWas::ExpressionFailed:
                case ResultWas::DidntThrowException:
                    elementName = "failure";
                    break;
                case ResultWas::ExplicitSkip:
                    elementName = "skipped";
                    break;
                    // We should never see these here:
                case ResultWas::Info:
                case ResultWas::Warning:
                case ResultWas::Ok:
                case ResultWas::Unknown:
                case ResultWas::FailureBit:
                case ResultWas::Exception:
                    elementName = "internalError";
                    break;
                }
            }

            XmlWriter::ScopedElement e = xml.scopedElement(elementName);

            ReusableStringStream messageRss;
            messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')';
            xml.writeAttribute("message"_sr, messageRss.str());

            ReusableStringStream textRss;
            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
                textRss << "SKIPPED\n";
            } else {
                textRss << "FAILED:\n";
                if (result.hasExpression()) {
                    textRss << '\t' << result.getExpressionInMacro() << '\n';
                }
                if (result.hasExpandedExpression()) {
                    textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n';
                }
            }

            if (result.hasMessage())
                textRss << result.getMessage() << '\n';

            for (auto const& msg : stats.infoMessages)
                if (msg.type == ResultWas::Info)
                    textRss << msg.message << '\n';

            textRss << "at " << result.getSourceInfo();
            xml.writeText(textRss.str(), XmlFormatting::Newline);
        }
    }

} // end namespace Catch



namespace Catch {

    StreamingReporterBase::~StreamingReporterBase() = default;

    void
    StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) {
        currentTestRunInfo = _testRunInfo;
    }

    void StreamingReporterBase::testRunEnded( TestRunStats const& ) {
        currentTestCaseInfo = nullptr;
    }

} // end namespace Catch



#include <algorithm>
#include <ostream>

namespace Catch {

    namespace {
        // Yes, this has to be outside the class and namespaced by naming.
        // Making older compiler happy is hard.
        static constexpr StringRef tapFailedString = "not ok"_sr;
        static constexpr StringRef tapPassedString = "ok"_sr;
        static constexpr Colour::Code tapDimColour = Colour::FileName;

        class TapAssertionPrinter {
        public:
            TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
            TapAssertionPrinter(TapAssertionPrinter const&) = delete;
            TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_)
                : stream(_stream)
                , result(_stats.assertionResult)
                , messages(_stats.infoMessages)
                , itMessage(_stats.infoMessages.begin())
                , printInfoMessages(true)
                , counter(_counter)
                , colourImpl( colour_ ) {}

            void print() {
                itMessage = messages.begin();

                switch (result.getResultType()) {
                case ResultWas::Ok:
                    printResultType(tapPassedString);
                    printOriginalExpression();
                    printReconstructedExpression();
                    if (!result.hasExpression())
                        printRemainingMessages(Colour::None);
                    else
                        printRemainingMessages();
                    break;
                case ResultWas::ExpressionFailed:
                    if (result.isOk()) {
                        printResultType(tapPassedString);
                    } else {
                        printResultType(tapFailedString);
                    }
                    printOriginalExpression();
                    printReconstructedExpression();
                    if (result.isOk()) {
                        printIssue(" # TODO");
                    }
                    printRemainingMessages();
                    break;
                case ResultWas::ThrewException:
                    printResultType(tapFailedString);
                    printIssue("unexpected exception with message:"_sr);
                    printMessage();
                    printExpressionWas();
                    printRemainingMessages();
                    break;
                case ResultWas::FatalErrorCondition:
                    printResultType(tapFailedString);
                    printIssue("fatal error condition with message:"_sr);
                    printMessage();
                    printExpressionWas();
                    printRemainingMessages();
                    break;
                case ResultWas::DidntThrowException:
                    printResultType(tapFailedString);
                    printIssue("expected exception, got none"_sr);
                    printExpressionWas();
                    printRemainingMessages();
                    break;
                case ResultWas::Info:
                    printResultType("info"_sr);
                    printMessage();
                    printRemainingMessages();
                    break;
                case ResultWas::Warning:
                    printResultType("warning"_sr);
                    printMessage();
                    printRemainingMessages();
                    break;
                case ResultWas::ExplicitFailure:
                    printResultType(tapFailedString);
                    printIssue("explicitly"_sr);
                    printRemainingMessages(Colour::None);
                    break;
                case ResultWas::ExplicitSkip:
                    printResultType(tapPassedString);
                    printIssue(" # SKIP"_sr);
                    printMessage();
                    printRemainingMessages();
                    break;
                    // These cases are here to prevent compiler warnings
                case ResultWas::Unknown:
                case ResultWas::FailureBit:
                case ResultWas::Exception:
                    printResultType("** internal error **"_sr);
                    break;
                }
            }

        private:
            void printResultType(StringRef passOrFail) const {
                if (!passOrFail.empty()) {
                    stream << passOrFail << ' ' << counter << " -";
                }
            }

            void printIssue(StringRef issue) const {
                stream << ' ' << issue;
            }

            void printExpressionWas() {
                if (result.hasExpression()) {
                    stream << ';';
                    stream << colourImpl->guardColour( tapDimColour )
                           << " expression was:";
                    printOriginalExpression();
                }
            }

            void printOriginalExpression() const {
                if (result.hasExpression()) {
                    stream << ' ' << result.getExpression();
                }
            }

            void printReconstructedExpression() const {
                if (result.hasExpandedExpression()) {
                    stream << colourImpl->guardColour( tapDimColour ) << " for: ";

                    std::string expr = result.getExpandedExpression();
                    std::replace(expr.begin(), expr.end(), '\n', ' ');
                    stream << expr;
                }
            }

            void printMessage() {
                if (itMessage != messages.end()) {
                    stream << " '" << itMessage->message << '\'';
                    ++itMessage;
                }
            }

            void printRemainingMessages(Colour::Code colour = tapDimColour) {
                if (itMessage == messages.end()) {
                    return;
                }

                // using messages.end() directly (or auto) yields compilation error:
                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
                const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);

                stream << colourImpl->guardColour( colour ) << " with "
                       << pluralise( N, "message"_sr ) << ':';

                for (; itMessage != itEnd; ) {
                    // If this assertion is a warning ignore any INFO messages
                    if (printInfoMessages || itMessage->type != ResultWas::Info) {
                        stream << " '" << itMessage->message << '\'';
                        if (++itMessage != itEnd) {
                            stream << colourImpl->guardColour(tapDimColour) << " and";
                        }
                    }
                }
            }

        private:
            std::ostream& stream;
            AssertionResult const& result;
            std::vector<MessageInfo> const& messages;
            std::vector<MessageInfo>::const_iterator itMessage;
            bool printInfoMessages;
            std::size_t counter;
            ColourImpl* colourImpl;
        };

    } // End anonymous namespace

    void TAPReporter::testRunStarting( TestRunInfo const& ) {
        if ( m_config->testSpec().hasFilters() ) {
            m_stream << "# filters: " << m_config->testSpec() << '\n';
        }
        m_stream << "# rng-seed: " << m_config->rngSeed() << '\n'
                 << std::flush;
    }

    void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
        m_stream << "# No test cases matched '" << unmatchedSpec << "'\n";
    }

    void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) {
        ++counter;

        m_stream << "# " << currentTestCaseInfo->name << '\n';
        TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get());
        printer.print();

        m_stream << '\n' << std::flush;
    }

    void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) {
        m_stream << "1.." << _testRunStats.totals.assertions.total();
        if (_testRunStats.totals.testCases.total() == 0) {
            m_stream << " # Skipped: No tests ran.";
        }
        m_stream << "\n\n" << std::flush;
        StreamingReporterBase::testRunEnded(_testRunStats);
    }




} // end namespace Catch




#include <cassert>
#include <ostream>

namespace Catch {

    namespace {
        // if string has a : in first line will set indent to follow it on
        // subsequent lines
        void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) {
            std::size_t i = _string.find(": ");
            if (i != std::string::npos)
                i += 2;
            else
                i = 0;
            os << TextFlow::Column(_string)
                  .indent(indent + i)
                  .initialIndent(indent) << '\n';
        }

        std::string escape(StringRef str) {
            std::string escaped = static_cast<std::string>(str);
            replaceInPlace(escaped, "|", "||");
            replaceInPlace(escaped, "'", "|'");
            replaceInPlace(escaped, "\n", "|n");
            replaceInPlace(escaped, "\r", "|r");
            replaceInPlace(escaped, "[", "|[");
            replaceInPlace(escaped, "]", "|]");
            return escaped;
        }
    } // end anonymous namespace


    TeamCityReporter::~TeamCityReporter() = default;

    void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) {
        m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name )
               << "']\n";
    }

    void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) {
        m_stream << "##teamcity[testSuiteFinished name='"
               << escape( runStats.runInfo.name ) << "']\n";
    }

    void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
        AssertionResult const& result = assertionStats.assertionResult;
        if ( !result.isOk() ||
             result.getResultType() == ResultWas::ExplicitSkip ) {

            ReusableStringStream msg;
            if (!m_headerPrintedForThisSection)
                printSectionHeader(msg.get());
            m_headerPrintedForThisSection = true;

            msg << result.getSourceInfo() << '\n';

            switch (result.getResultType()) {
            case ResultWas::ExpressionFailed:
                msg << "expression failed";
                break;
            case ResultWas::ThrewException:
                msg << "unexpected exception";
                break;
            case ResultWas::FatalErrorCondition:
                msg << "fatal error condition";
                break;
            case ResultWas::DidntThrowException:
                msg << "no exception was thrown where one was expected";
                break;
            case ResultWas::ExplicitFailure:
                msg << "explicit failure";
                break;
            case ResultWas::ExplicitSkip:
                msg << "explicit skip";
                break;

                // We shouldn't get here because of the isOk() test
            case ResultWas::Ok:
            case ResultWas::Info:
            case ResultWas::Warning:
                CATCH_ERROR("Internal error in TeamCity reporter");
                // These cases are here to prevent compiler warnings
            case ResultWas::Unknown:
            case ResultWas::FailureBit:
            case ResultWas::Exception:
                CATCH_ERROR("Not implemented");
            }
            if (assertionStats.infoMessages.size() == 1)
                msg << " with message:";
            if (assertionStats.infoMessages.size() > 1)
                msg << " with messages:";
            for (auto const& messageInfo : assertionStats.infoMessages)
                msg << "\n  \"" << messageInfo.message << '"';


            if (result.hasExpression()) {
                msg <<
                    "\n  " << result.getExpressionInMacro() << "\n"
                    "with expansion:\n"
                    "  " << result.getExpandedExpression() << '\n';
            }

            if ( result.getResultType() == ResultWas::ExplicitSkip ) {
                m_stream << "##teamcity[testIgnored";
            } else if ( currentTestCaseInfo->okToFail() ) {
                msg << "- failure ignore as test marked as 'ok to fail'\n";
                m_stream << "##teamcity[testIgnored";
            } else {
                m_stream << "##teamcity[testFailed";
            }
            m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
                     << " message='" << escape( msg.str() ) << '\'' << "]\n";
        }
        m_stream.flush();
    }

    void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
        m_testTimer.start();
        StreamingReporterBase::testCaseStarting(testInfo);
        m_stream << "##teamcity[testStarted name='"
            << escape(testInfo.name) << "']\n";
        m_stream.flush();
    }

    void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) {
        StreamingReporterBase::testCaseEnded(testCaseStats);
        auto const& testCaseInfo = *testCaseStats.testInfo;
        if (!testCaseStats.stdOut.empty())
            m_stream << "##teamcity[testStdOut name='"
            << escape(testCaseInfo.name)
            << "' out='" << escape(testCaseStats.stdOut) << "']\n";
        if (!testCaseStats.stdErr.empty())
            m_stream << "##teamcity[testStdErr name='"
            << escape(testCaseInfo.name)
            << "' out='" << escape(testCaseStats.stdErr) << "']\n";
        m_stream << "##teamcity[testFinished name='"
            << escape(testCaseInfo.name) << "' duration='"
            << m_testTimer.getElapsedMilliseconds() << "']\n";
        m_stream.flush();
    }

    void TeamCityReporter::printSectionHeader(std::ostream& os) {
        assert(!m_sectionStack.empty());

        if (m_sectionStack.size() > 1) {
            os << lineOfChars('-') << '\n';

            std::vector<SectionInfo>::const_iterator
                it = m_sectionStack.begin() + 1, // Skip first section (test case)
                itEnd = m_sectionStack.end();
            for (; it != itEnd; ++it)
                printHeaderString(os, it->name);
            os << lineOfChars('-') << '\n';
        }

        SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;

        os << lineInfo << '\n';
        os << lineOfChars('.') << "\n\n";
    }

} // end namespace Catch




#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
                              // Note that 4062 (not all labels are handled
                              // and default is missing) is enabled
#endif

namespace Catch {
    XmlReporter::XmlReporter( ReporterConfig&& _config )
    :   StreamingReporterBase( CATCH_MOVE(_config) ),
        m_xml(m_stream)
    {
        m_preferences.shouldRedirectStdOut = true;
        m_preferences.shouldReportAllAssertions = true;
        m_preferences.shouldReportAllAssertionStarts = false;
    }

    XmlReporter::~XmlReporter() = default;

    std::string XmlReporter::getDescription() {
        return "Reports test results as an XML document";
    }

    std::string XmlReporter::getStylesheetRef() const {
        return std::string();
    }

    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
        m_xml
            .writeAttribute( "filename"_sr, sourceInfo.file )
            .writeAttribute( "line"_sr, sourceInfo.line );
    }

    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
        StreamingReporterBase::testRunStarting( testInfo );
        std::string stylesheetRef = getStylesheetRef();
        if( !stylesheetRef.empty() )
            m_xml.writeStylesheetRef( stylesheetRef );
        m_xml.startElement("Catch2TestRun")
             .writeAttribute("name"_sr, m_config->name())
             .writeAttribute("rng-seed"_sr, m_config->rngSeed())
             .writeAttribute("xml-format-version"_sr, 3)
             .writeAttribute("catch2-version"_sr, libraryVersion());
        if ( m_config->testSpec().hasFilters() ) {
            m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
        }
    }

    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
        StreamingReporterBase::testCaseStarting(testInfo);
        m_xml.startElement( "TestCase" )
            .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
            .writeAttribute( "tags"_sr, testInfo.tagsAsString() );

        writeSourceInfo( testInfo.lineInfo );

        if ( m_config->showDurations() == ShowDurations::Always )
            m_testCaseTimer.start();
        m_xml.ensureTagClosed();
    }

    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
        StreamingReporterBase::sectionStarting( sectionInfo );
        if( m_sectionDepth++ > 0 ) {
            m_xml.startElement( "Section" )
                .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
            writeSourceInfo( sectionInfo.lineInfo );
            m_xml.ensureTagClosed();
        }
    }

    void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {

        AssertionResult const& result = assertionStats.assertionResult;

        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();

        if( includeResults || result.getResultType() == ResultWas::Warning ) {
            // Print any info messages in <Info> tags.
            for( auto const& msg : assertionStats.infoMessages ) {
                if( msg.type == ResultWas::Info && includeResults ) {
                    auto t = m_xml.scopedElement( "Info" );
                    writeSourceInfo( msg.lineInfo );
                    t.writeText( msg.message );
                } else if ( msg.type == ResultWas::Warning ) {
                    auto t = m_xml.scopedElement( "Warning" );
                    writeSourceInfo( msg.lineInfo );
                    t.writeText( msg.message );
                }
            }
        }

        // Drop out if result was successful but we're not printing them.
        if ( !includeResults && result.getResultType() != ResultWas::Warning &&
             result.getResultType() != ResultWas::ExplicitSkip ) {
            return;
        }

        // Print the expression if there is one.
        if( result.hasExpression() ) {
            m_xml.startElement( "Expression" )
                .writeAttribute( "success"_sr, result.succeeded() )
                .writeAttribute( "type"_sr, result.getTestMacroName() );

            writeSourceInfo( result.getSourceInfo() );

            m_xml.scopedElement( "Original" )
                .writeText( result.getExpression() );
            m_xml.scopedElement( "Expanded" )
                .writeText( result.getExpandedExpression() );
        }

        // And... Print a result applicable to each result type.
        switch( result.getResultType() ) {
            case ResultWas::ThrewException:
                m_xml.startElement( "Exception" );
                writeSourceInfo( result.getSourceInfo() );
                m_xml.writeText( result.getMessage() );
                m_xml.endElement();
                break;
            case ResultWas::FatalErrorCondition:
                m_xml.startElement( "FatalErrorCondition" );
                writeSourceInfo( result.getSourceInfo() );
                m_xml.writeText( result.getMessage() );
                m_xml.endElement();
                break;
            case ResultWas::Info:
                m_xml.scopedElement( "Info" )
                     .writeText( result.getMessage() );
                break;
            case ResultWas::Warning:
                // Warning will already have been written
                break;
            case ResultWas::ExplicitFailure:
                m_xml.startElement( "Failure" );
                writeSourceInfo( result.getSourceInfo() );
                m_xml.writeText( result.getMessage() );
                m_xml.endElement();
                break;
            case ResultWas::ExplicitSkip:
                m_xml.startElement( "Skip" );
                writeSourceInfo( result.getSourceInfo() );
                m_xml.writeText( result.getMessage() );
                m_xml.endElement();
                break;
            default:
                break;
        }

        if( result.hasExpression() )
            m_xml.endElement();
    }

    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
        StreamingReporterBase::sectionEnded( sectionStats );
        if ( --m_sectionDepth > 0 ) {
            {
                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
                e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
                e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
                e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
                e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );

                if ( m_config->showDurations() == ShowDurations::Always )
                    e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
            }
            // Ends assertion tag
            m_xml.endElement();
        }
    }

    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
        StreamingReporterBase::testCaseEnded( testCaseStats );
        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
        e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
        e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );

        if ( m_config->showDurations() == ShowDurations::Always )
            e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
        if( !testCaseStats.stdOut.empty() )
            m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
        if( !testCaseStats.stdErr.empty() )
            m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );

        m_xml.endElement();
    }

    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
        StreamingReporterBase::testRunEnded( testRunStats );
        m_xml.scopedElement( "OverallResults" )
            .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
            .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
            .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
        m_xml.scopedElement( "OverallResultsCases")
            .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
            .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
            .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
            .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
        m_xml.endElement();
    }

    void XmlReporter::benchmarkPreparing( StringRef name ) {
        m_xml.startElement("BenchmarkResults")
             .writeAttribute("name"_sr, name);
    }

    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
        m_xml.writeAttribute("samples"_sr, info.samples)
            .writeAttribute("resamples"_sr, info.resamples)
            .writeAttribute("iterations"_sr, info.iterations)
            .writeAttribute("clockResolution"_sr, info.clockResolution)
            .writeAttribute("estimatedDuration"_sr, info.estimatedDuration)
            .writeComment("All values in nano seconds"_sr);
    }

    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
        m_xml.scopedElement("mean")
            .writeAttribute("value"_sr, benchmarkStats.mean.point.count())
            .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count())
            .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count())
            .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval);
        m_xml.scopedElement("standardDeviation")
            .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count())
            .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count())
            .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count())
            .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval);
        m_xml.scopedElement("outliers")
            .writeAttribute("variance"_sr, benchmarkStats.outlierVariance)
            .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild)
            .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe)
            .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild)
            .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe);
        m_xml.endElement();
    }

    void XmlReporter::benchmarkFailed(StringRef error) {
        m_xml.scopedElement("failed").
            writeAttribute("message"_sr, error);
        m_xml.endElement();
    }

    void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
        auto outerTag = m_xml.scopedElement("AvailableReporters");
        for (auto const& reporter : descriptions) {
            auto inner = m_xml.scopedElement("Reporter");
            m_xml.startElement("Name", XmlFormatting::Indent)
                 .writeText(reporter.name, XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);
            m_xml.startElement("Description", XmlFormatting::Indent)
                 .writeText(reporter.description, XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);
        }
    }

    void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
        auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
        for ( auto const& listener : descriptions ) {
            auto inner = m_xml.scopedElement( "Listener" );
            m_xml.startElement( "Name", XmlFormatting::Indent )
                .writeText( listener.name, XmlFormatting::None )
                .endElement( XmlFormatting::Newline );
            m_xml.startElement( "Description", XmlFormatting::Indent )
                .writeText( listener.description, XmlFormatting::None )
                .endElement( XmlFormatting::Newline );
        }
    }

    void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
        auto outerTag = m_xml.scopedElement("MatchingTests");
        for (auto const& test : tests) {
            auto innerTag = m_xml.scopedElement("TestCase");
            auto const& testInfo = test.getTestCaseInfo();
            m_xml.startElement("Name", XmlFormatting::Indent)
                 .writeText(testInfo.name, XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);
            m_xml.startElement("ClassName", XmlFormatting::Indent)
                 .writeText(testInfo.className, XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);
            m_xml.startElement("Tags", XmlFormatting::Indent)
                 .writeText(testInfo.tagsAsString(), XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);

            auto sourceTag = m_xml.scopedElement("SourceInfo");
            m_xml.startElement("File", XmlFormatting::Indent)
                 .writeText(testInfo.lineInfo.file, XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);
            m_xml.startElement("Line", XmlFormatting::Indent)
                 .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);
        }
    }

    void XmlReporter::listTags(std::vector<TagInfo> const& tags) {
        auto outerTag = m_xml.scopedElement("TagsFromMatchingTests");
        for (auto const& tag : tags) {
            auto innerTag = m_xml.scopedElement("Tag");
            m_xml.startElement("Count", XmlFormatting::Indent)
                 .writeText(std::to_string(tag.count), XmlFormatting::None)
                 .endElement(XmlFormatting::Newline);
            auto aliasTag = m_xml.scopedElement("Aliases");
            for (auto const& alias : tag.spellings) {
                m_xml.startElement("Alias", XmlFormatting::Indent)
                     .writeText(alias, XmlFormatting::None)
                     .endElement(XmlFormatting::Newline);
            }
        }
    }

} // end namespace Catch

#if defined(_MSC_VER)
#pragma warning(pop)
#endif


================================================
FILE: test/common/catch_amalgamated.hpp
================================================

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0

//  Catch v3.9.0
//  Generated: 2025-07-24 22:00:24.654688
//  ----------------------------------------------------------
//  This file is an amalgamation of multiple different files.
//  You probably shouldn't edit it directly.
//  ----------------------------------------------------------
#ifndef CATCH_AMALGAMATED_HPP_INCLUDED
#define CATCH_AMALGAMATED_HPP_INCLUDED


/** \file
 * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
 *
 * Generally the Catch2 users should use specific includes they need,
 * but this header can be used instead for ease-of-experimentation, or
 * just plain convenience, at the cost of (significantly) increased
 * compilation times.
 *
 * When a new header is added to either the top level folder, or to the
 * corresponding internal subfolder, it should be added here. Headers
 * added to the various subparts (e.g. matchers, generators, etc...),
 * should go their respective catch-all headers.
 */

#ifndef CATCH_ALL_HPP_INCLUDED
#define CATCH_ALL_HPP_INCLUDED



/** \file
 * This is a convenience header for Catch2's benchmarking. It includes
 * **all** of Catch2 headers related to benchmarking.
 *
 * Generally the Catch2 users should use specific includes they need,
 * but this header can be used instead for ease-of-experimentation, or
 * just plain convenience, at the cost of (significantly) increased
 * compilation times.
 *
 * When a new header is added to either the `benchmark` folder, or to
 * the corresponding internal (detail) subfolder, it should be added here.
 */

#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
#define CATCH_BENCHMARK_ALL_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_BENCHMARK_HPP_INCLUDED
#define CATCH_BENCHMARK_HPP_INCLUDED



#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED

// Detect a number of compiler features - by compiler
// The following features are defined:
//
// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
// ****************
// Note to maintainers: if new toggles are added please document them
// in configuration.md, too
// ****************

// In general each macro has a _NO_<feature name> form
// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
// Many features, at point of detection, define an _INTERNAL_ macro, so they
// can be combined, en-mass, with the _NO_ forms later.



#ifndef CATCH_PLATFORM_HPP_INCLUDED
#define CATCH_PLATFORM_HPP_INCLUDED

// See e.g.:
// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
#ifdef __APPLE__
#  ifndef __has_extension
#    define __has_extension(x) 0
#  endif
#  include <TargetConditionals.h>
#  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
#    define CATCH_PLATFORM_MAC
#  elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
#    define CATCH_PLATFORM_IPHONE
#  endif

#elif defined(linux) || defined(__linux) || defined(__linux__)
#  define CATCH_PLATFORM_LINUX

#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
#  define CATCH_PLATFORM_WINDOWS

#  if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
#      define CATCH_PLATFORM_WINDOWS_UWP
#  endif

#elif defined(__ORBIS__) || defined(__PROSPERO__)
#  define CATCH_PLATFORM_PLAYSTATION

#endif

#endif // CATCH_PLATFORM_HPP_INCLUDED

#ifdef __cplusplus

#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#    define CATCH_CPP17_OR_GREATER
#  endif

#  if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
#    define CATCH_CPP20_OR_GREATER
#  endif

#endif

// Only GCC compiler should be used in this block, so other compilers trying to
// mask themselves as GCC should be ignored.
#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )

// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses
// for older versions of GCC.
#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )

#    define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
         _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )

#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
         _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )

#    define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
         _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )

#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
         _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )

#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P

#endif

#if defined(__NVCOMPILER)
#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "diag pop" )
#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
#endif

#if defined(__CUDACC__) && !defined(__clang__)
#  ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
// New pragmas introduced in CUDA 11.5+
#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "nv_diagnostic pop" )
#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
#  else
#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
#  endif
#endif

// clang-cl defines _MSC_VER as well as __clang__, which could cause the
// start/stop internal suppression macros to be double defined.
#if defined(__clang__) && !defined(_MSC_VER)
#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
#endif // __clang__ && !_MSC_VER

#if defined(__clang__)

#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")

#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )

#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )

#    if (__clang_major__ >= 20)
#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
             _Pragma( "clang diagnostic ignored \"-Wvariadic-macro-arguments-omitted\"" )
#    elif (__clang_major__ == 19)
#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
	         _Pragma( "clang diagnostic ignored \"-Wc++20-extensions\"" )
#    else
#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
             _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
#    endif

#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )

#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )

#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )

#endif // __clang__

// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
// which results in calls to destructors being emitted for each temporary,
// without a matching initialization. In practice, this can result in something
// like `std::string::~string` being called on an uninitialized value.
//
// For example, this code will likely segfault under IBM XL:
// ```
// REQUIRE(std::string("12") + "34" == "1234")
// ```
//
// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which
// results in calls to the immediately evaluated lambda expressions to be
// reported as unevaluated lambdas.
// https://developer.nvidia.com/nvidia_bug/3321845.
//
// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
#if defined( __ibmxl__ ) || defined( __CUDACC__ ) || defined( __NVCOMPILER )
#    define CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P
#endif



////////////////////////////////////////////////////////////////////////////////
// We know some environments not to support full POSIX signals
#if defined( CATCH_PLATFORM_WINDOWS ) ||                                       \
    defined( CATCH_PLATFORM_PLAYSTATION ) ||                                   \
    defined( __CYGWIN__ ) ||                                                   \
    defined( __QNX__ ) ||                                                      \
    defined( __EMSCRIPTEN__ ) ||                                               \
    defined( __DJGPP__ ) ||                                                    \
    defined( __OS400__ )
#    define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
#else
#    define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
#endif

////////////////////////////////////////////////////////////////////////////////
// Assume that some platforms do not support getenv.
#if defined( CATCH_PLATFORM_WINDOWS_UWP ) ||                                   \
    defined( CATCH_PLATFORM_PLAYSTATION ) ||                                   \
    defined( _GAMING_XBOX )
#    define CATCH_INTERNAL_CONFIG_NO_GETENV
#else
#    define CATCH_INTERNAL_CONFIG_GETENV
#endif

////////////////////////////////////////////////////////////////////////////////
// Android somehow still does not support std::to_string
#if defined(__ANDROID__)
#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
#endif

////////////////////////////////////////////////////////////////////////////////
// Not all Windows environments support SEH properly
#if defined(__MINGW32__)
#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
#endif

////////////////////////////////////////////////////////////////////////////////
// PS4
#if defined(__ORBIS__)
#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
#endif

////////////////////////////////////////////////////////////////////////////////
// Cygwin
#ifdef __CYGWIN__

// Required for some versions of Cygwin to declare gettimeofday
// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
#   define _BSD_SOURCE
// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))

#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING

# endif
#endif // __CYGWIN__

////////////////////////////////////////////////////////////////////////////////
// Visual C++
#if defined(_MSC_VER)

// We want to defer to nvcc-specific warning suppression if we are compiled
// with nvcc masquerading for MSVC.
#    if !defined( __CUDACC__ )
#        define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            __pragma( warning( push ) )
#        define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
            __pragma( warning( pop ) )
#    endif

// Universal Windows platform does not support SEH
// Or console colours (or console at all...)
#  if defined(CATCH_PLATFORM_WINDOWS_UWP)
#    define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
#  else
#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
#  endif

// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
#  if !defined(__clang__) // Handle Clang masquerading for msvc
#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#    endif // MSVC_TRADITIONAL
#  endif // __clang__

#endif // _MSC_VER

#if defined(_REENTRANT) || defined(_MSC_VER)
// Enable async processing, as -pthread is specified or no additional linking is required
# define CATCH_INTERNAL_CONFIG_USE_ASYNC
#endif // _MSC_VER

////////////////////////////////////////////////////////////////////////////////
// Check if we are compiled with -fno-exceptions or equivalent
#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
#endif


////////////////////////////////////////////////////////////////////////////////
// Embarcadero C++Build
#if defined(__BORLANDC__)
    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
#endif

////////////////////////////////////////////////////////////////////////////////

// RTX is a special version of Windows that is real time.
// This means that it is detected as Windows, but does not provide
// the same set of capabilities as real Windows does.
#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
    #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
#endif

#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
#endif

// Various stdlib support checks that require __has_include
#if defined(__has_include)
  // Check if string_view is available and usable
  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
  #endif

  // Check if optional is available and usable
  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)

  // Check if byte is available and usable
  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
  #    include <cstddef>
  #    if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
  #    endif
  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)

  // Check if variant is available and usable
  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
  #    if defined(__clang__) && (__clang_major__ < 8)
         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
         // fix should be in clang 8, workaround in libstdc++ 8.2
  #      include <ciso646>
  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
  #        define CATCH_CONFIG_NO_CPP17_VARIANT
  #      else
  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
  #    else
  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
  #    endif // defined(__clang__) && (__clang_major__ < 8)
  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
#endif // defined(__has_include)


#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
#   define CATCH_CONFIG_WINDOWS_SEH
#endif
// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
#   define CATCH_CONFIG_POSIX_SIGNALS
#endif

#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
#   define CATCH_CONFIG_GETENV
#endif

#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
#    define CATCH_CONFIG_CPP11_TO_STRING
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
#  define CATCH_CONFIG_CPP17_OPTIONAL
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
#  define CATCH_CONFIG_CPP17_STRING_VIEW
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
#  define CATCH_CONFIG_CPP17_VARIANT
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
#  define CATCH_CONFIG_CPP17_BYTE
#endif


#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
#endif

#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
#  define CATCH_CONFIG_NEW_CAPTURE
#endif

#if !defined( CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ) && \
    !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) &&          \
    !defined( CATCH_CONFIG_NO_DISABLE_EXCEPTIONS )
#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
#endif

#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
#  define CATCH_CONFIG_POLYFILL_ISNAN
#endif

#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
#  define CATCH_CONFIG_USE_ASYNC
#endif

#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
#endif


// The goal of this macro is to avoid evaluation of the arguments, but
// still have the compiler warn on problems inside...
#if defined( CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
    !defined( CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P ) && !defined(CATCH_CONFIG_USE_BUILTIN_CONSTANT_P)
#define CATCH_CONFIG_USE_BUILTIN_CONSTANT_P
#endif

#if defined( CATCH_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
    !defined( CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P )
#    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )                                              \
        (void)__builtin_constant_p( __VA_ARGS__ ) /* NOLINT(cppcoreguidelines-pro-type-vararg, \
                                                     hicpp-vararg) */
#else
#    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )
#endif

// Even if we do not think the compiler has that warning, we still have
// to provide a macro that can be used by the code.
#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
#endif
#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
#   define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
#endif
#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif
#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
#endif
#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
#endif

#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#elif defined(__clang__) && (__clang_major__ < 5)
#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif


#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
#define CATCH_TRY if ((true))
#define CATCH_CATCH_ALL if ((false))
#define CATCH_CATCH_ANON(type) if ((false))
#else
#define CATCH_TRY try
#define CATCH_CATCH_ALL catch (...)
#define CATCH_CATCH_ANON(type) catch (type)
#endif

#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#endif

#if defined( CATCH_PLATFORM_WINDOWS ) &&       \
    !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \
    !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \
    !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 )
#    define CATCH_CONFIG_COLOUR_WIN32
#endif

#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
    !defined( CATCH_CONFIG_STATIC )
#    ifdef Catch2_EXPORTS
#        define CATCH_EXPORT //__declspec( dllexport ) // not needed
#    else
#        define CATCH_EXPORT __declspec( dllimport )
#    endif
#else
#    define CATCH_EXPORT
#endif

#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED


#ifndef CATCH_CONTEXT_HPP_INCLUDED
#define CATCH_CONTEXT_HPP_INCLUDED


namespace Catch {

    class IResultCapture;
    class IConfig;

    class Context {
        IConfig const* m_config = nullptr;
        IResultCapture* m_resultCapture = nullptr;

        CATCH_EXPORT static Context* currentContext;
        friend Context& getCurrentMutableContext();
        friend Context const& getCurrentContext();
        static void createContext();
        friend void cleanUpContext();

    public:
        constexpr IResultCapture* getResultCapture() const {
            return m_resultCapture;
        }
        constexpr IConfig const* getConfig() const { return m_config; }
        constexpr void setResultCapture( IResultCapture* resultCapture ) {
            m_resultCapture = resultCapture;
        }
        constexpr void setConfig( IConfig const* config ) { m_config = config; }

    };

    Context& getCurrentMutableContext();

    inline Context const& getCurrentContext() {
        // We duplicate the logic from `getCurrentMutableContext` here,
        // to avoid paying the call overhead in debug mode.
        if ( !Context::currentContext ) { Context::createContext(); }
        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
        return *Context::currentContext;
    }

    void cleanUpContext();

    class SimplePcg32;
    SimplePcg32& sharedRng();
}

#endif // CATCH_CONTEXT_HPP_INCLUDED


#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED

#include <type_traits>

//! Replacement for std::move with better compile time performance
#define CATCH_MOVE(...) static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)

//! Replacement for std::forward with better compile time performance
#define CATCH_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)

#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED


#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED

namespace Catch {

    //! Used to signal that an assertion macro failed
    struct TestFailureException{};
    //! Used to signal that the remainder of a test should be skipped
    struct TestSkipException {};

    /**
     * Outlines throwing of `TestFailureException` into a single TU
     *
     * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
     */
    [[noreturn]] void throw_test_failure_exception();

    /**
     * Outlines throwing of `TestSkipException` into a single TU
     *
     * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
     */
    [[noreturn]] void throw_test_skip_exception();

} // namespace Catch

#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED


#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED
#define CATCH_UNIQUE_NAME_HPP_INCLUDED




/** \file
 * Wrapper for the CONFIG configuration option
 *
 * When generating internal unique names, there are two options. Either
 * we mix in the current line number, or mix in an incrementing number.
 * We prefer the latter, using `__COUNTER__`, but users might want to
 * use the former.
 */

#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
#define CATCH_CONFIG_COUNTER_HPP_INCLUDED


#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
    #define CATCH_INTERNAL_CONFIG_COUNTER
#endif

#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \
    !defined( CATCH_CONFIG_NO_COUNTER ) && \
    !defined( CATCH_CONFIG_COUNTER )
#    define CATCH_CONFIG_COUNTER
#endif


#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED
#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
#ifdef CATCH_CONFIG_COUNTER
#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
#else
#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
#endif

#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED


#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED

#include <string>



#ifndef CATCH_STRINGREF_HPP_INCLUDED
#define CATCH_STRINGREF_HPP_INCLUDED

#include <cstddef>
#include <string>
#include <iosfwd>
#include <cassert>

#include <cstring>

namespace Catch {

    /// A non-owning string class (similar to the forthcoming std::string_view)
    /// Note that, because a StringRef may be a substring of another string,
    /// it may not be null terminated.
    class StringRef {
    public:
        using size_type = std::size_t;
        using const_iterator = const char*;

        static constexpr size_type npos{ static_cast<size_type>( -1 ) };

    private:
        static constexpr char const* const s_empty = "";

        char const* m_start = s_empty;
        size_type m_size = 0;

    public: // construction
        constexpr StringRef() noexcept = default;

        StringRef( char const* rawChars ) noexcept;

        constexpr StringRef( char const* rawChars, size_type size ) noexcept
        :   m_start( rawChars ),
            m_size( size )
        {}

        StringRef( std::string const& stdString ) noexcept
        :   m_start( stdString.c_str() ),
            m_size( stdString.size() )
        {}

        explicit operator std::string() const {
            return std::string(m_start, m_size);
        }

    public: // operators
        auto operator == ( StringRef other ) const noexcept -> bool {
            return m_size == other.m_size
                && (std::memcmp( m_start, other.m_start, m_size ) == 0);
        }
        auto operator != (StringRef other) const noexcept -> bool {
            return !(*this == other);
        }

        constexpr auto operator[] ( size_type index ) const noexcept -> char {
            assert(index < m_size);
            return m_start[index];
        }

        bool operator<(StringRef rhs) const noexcept;

    public: // named queries
        constexpr auto empty() const noexcept -> bool {
            return m_size == 0;
        }
        constexpr auto size() const noexcept -> size_type {
            return m_size;
        }

        // Returns a substring of [start, start + length).
        // If start + length > size(), then the substring is [start, size()).
        // If start > size(), then the substring is empty.
        constexpr StringRef substr(size_type start, size_type length) const noexcept {
            if (start < m_size) {
                const auto shortened_size = m_size - start;
                return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length);
            } else {
                return StringRef();
            }
        }

        // Returns the current start pointer. May not be null-terminated.
        constexpr char const* data() const noexcept {
            return m_start;
        }

        constexpr const_iterator begin() const { return m_start; }
        constexpr const_iterator end() const { return m_start + m_size; }


        friend std::string& operator += (std::string& lhs, StringRef rhs);
        friend std::ostream& operator << (std::ostream& os, StringRef str);
        friend std::string operator+(StringRef lhs, StringRef rhs);

        /**
         * Provides a three-way comparison with rhs
         *
         * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive
         * number if lhs > rhs
         */
        int compare( StringRef rhs ) const;
    };


    constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
        return StringRef( rawChars, size );
    }
} // namespace Catch

constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
    return Catch::StringRef( rawChars, size );
}

#endif // CATCH_STRINGREF_HPP_INCLUDED


#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED
#define CATCH_RESULT_TYPE_HPP_INCLUDED

namespace Catch {

    // ResultWas::OfType enum
    struct ResultWas { enum OfType {
        Unknown = -1,
        Ok = 0,
        Info = 1,
        Warning = 2,
        // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
        ExplicitSkip = 4,

        FailureBit = 0x10,

        ExpressionFailed = FailureBit | 1,
        ExplicitFailure = FailureBit | 2,

        Exception = 0x100 | FailureBit,

        ThrewException = Exception | 1,
        DidntThrowException = Exception | 2,

        FatalErrorCondition = 0x200 | FailureBit

    }; };

    constexpr bool isOk( ResultWas::OfType resultType ) {
        return ( resultType & ResultWas::FailureBit ) == 0;
    }
    constexpr bool isJustInfo( int flags ) { return flags == ResultWas::Info; }


    // ResultDisposition::Flags enum
    struct ResultDisposition { enum Flags {
        Normal = 0x01,

        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
        FalseTest = 0x04,           // Prefix expression with !
        SuppressFail = 0x08         // Failures are reported but do not fail the test
    }; };

    constexpr ResultDisposition::Flags operator|( ResultDisposition::Flags lhs,
                                        ResultDisposition::Flags rhs ) {
        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) |
                                                      static_cast<int>( rhs ) );
    }

    constexpr bool isFalseTest( int flags ) {
        return ( flags & ResultDisposition::FalseTest ) != 0;
    }
    constexpr bool shouldSuppressFailure( int flags ) {
        return ( flags & ResultDisposition::SuppressFail ) != 0;
    }

} // end namespace Catch

#endif // CATCH_RESULT_TYPE_HPP_INCLUDED


#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
#define CATCH_UNIQUE_PTR_HPP_INCLUDED

#include <cassert>
#include <type_traits>


namespace Catch {
namespace Detail {
    /**
     * A reimplementation of `std::unique_ptr` for improved compilation performance
     *
     * Does not support arrays nor custom deleters.
     */
    template <typename T>
    class unique_ptr {
        T* m_ptr;
    public:
        constexpr unique_ptr(std::nullptr_t = nullptr):
            m_ptr{}
        {}
        explicit constexpr unique_ptr(T* ptr):
            m_ptr(ptr)
        {}

        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
        unique_ptr(unique_ptr<U>&& from):
            m_ptr(from.release())
        {}

        template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
        unique_ptr& operator=(unique_ptr<U>&& from) {
            reset(from.release());

            return *this;
        }

        unique_ptr(unique_ptr const&) = delete;
        unique_ptr& operator=(unique_ptr const&) = delete;

        unique_ptr(unique_ptr&& rhs) noexcept:
            m_ptr(rhs.m_ptr) {
            rhs.m_ptr = nullptr;
        }
        unique_ptr& operator=(unique_ptr&& rhs) noexcept {
            reset(rhs.release());

            return *this;
        }

        ~unique_ptr() {
            delete m_ptr;
        }

        T& operator*() {
            assert(m_ptr);
            return *m_ptr;
        }
        T const& operator*() const {
            assert(m_ptr);
            return *m_ptr;
        }
        T* operator->() noexcept {
            assert(m_ptr);
            return m_ptr;
        }
        T const* operator->() const noexcept {
            assert(m_ptr);
            return m_ptr;
        }

        T* get() { return m_ptr; }
        T const* get() const { return m_ptr; }

        void reset(T* ptr = nullptr) {
            delete m_ptr;
            m_ptr = ptr;
        }

        T* release() {
            auto temp = m_ptr;
            m_ptr = nullptr;
            return temp;
        }

        explicit operator bool() const {
            return m_ptr;
        }

        friend void swap(unique_ptr& lhs, unique_ptr& rhs) {
            auto temp = lhs.m_ptr;
            lhs.m_ptr = rhs.m_ptr;
            rhs.m_ptr = temp;
        }
    };

    //! Specialization to cause compile-time error for arrays
    template <typename T>
    class unique_ptr<T[]>;

    template <typename T, typename... Args>
    unique_ptr<T> make_unique(Args&&... args) {
        return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
    }


} // end namespace Detail
} // end namespace Catch

#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED


#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_CLOCK_HPP_INCLUDED
#define CATCH_CLOCK_HPP_INCLUDED

#include <chrono>

namespace Catch {
    namespace Benchmark {
        using IDuration = std::chrono::nanoseconds;
        using FDuration = std::chrono::duration<double, std::nano>;

        template <typename Clock>
        using TimePoint = typename Clock::time_point;

        using default_clock = std::chrono::steady_clock;
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_CLOCK_HPP_INCLUDED

namespace Catch {

    // We cannot forward declare the type with default template argument
    // multiple times, so it is split out into a separate header so that
    // we can prevent multiple declarations in dependees
    template <typename Duration = Benchmark::FDuration>
    struct BenchmarkStats;

} // end namespace Catch

#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED

namespace Catch {

    class AssertionResult;
    struct AssertionInfo;
    struct SectionInfo;
    struct SectionEndInfo;
    struct MessageInfo;
    struct MessageBuilder;
    struct Counts;
    struct AssertionReaction;
    struct SourceLineInfo;

    class ITransientExpression;
    class IGeneratorTracker;

    struct BenchmarkInfo;

    namespace Generators {
        class GeneratorUntypedBase;
        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
    }


    class IResultCapture {
    public:
        virtual ~IResultCapture();

        virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
        virtual bool sectionStarted( StringRef sectionName,
                                     SourceLineInfo const& sectionLineInfo,
                                     Counts& assertions ) = 0;
        virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
        virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;

        virtual IGeneratorTracker*
        acquireGeneratorTracker( StringRef generatorName,
                                 SourceLineInfo const& lineInfo ) = 0;
        virtual IGeneratorTracker*
        createGeneratorTracker( StringRef generatorName,
                                SourceLineInfo lineInfo,
                                Generators::GeneratorBasePtr&& generator ) = 0;

        virtual void benchmarkPreparing( StringRef name ) = 0;
        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
        virtual void benchmarkFailed( StringRef error ) = 0;

        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
        virtual void popScopedMessage( MessageInfo const& message ) = 0;

        virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;

        virtual void handleFatalErrorCondition( StringRef message ) = 0;

        virtual void handleExpr
                (   AssertionInfo const& info,
                    ITransientExpression const& expr,
                    AssertionReaction& reaction ) = 0;
        virtual void handleMessage
                (   AssertionInfo const& info,
                    ResultWas::OfType resultType,
                    std::string&& message,
                    AssertionReaction& reaction ) = 0;
        virtual void handleUnexpectedExceptionNotThrown
                (   AssertionInfo const& info,
                    AssertionReaction& reaction ) = 0;
        virtual void handleUnexpectedInflightException
                (   AssertionInfo const& info,
                    std::string&& message,
                    AssertionReaction& reaction ) = 0;
        virtual void handleIncomplete
                (   AssertionInfo const& info ) = 0;
        virtual void handleNonExpr
                (   AssertionInfo const &info,
                    ResultWas::OfType resultType,
                    AssertionReaction &reaction ) = 0;


        virtual bool lastAssertionPassed() = 0;

        // Deprecated, do not use:
        virtual std::string getCurrentTestName() const = 0;
        virtual const AssertionResult* getLastResult() const = 0;
        virtual void exceptionEarlyReported() = 0;
    };

    IResultCapture& getResultCapture();
}

#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED


#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED
#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED



#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED
#define CATCH_NONCOPYABLE_HPP_INCLUDED

namespace Catch {
    namespace Detail {

        //! Deriving classes become noncopyable and nonmovable
        class NonCopyable {
        public:
            NonCopyable( NonCopyable const& ) = delete;
            NonCopyable( NonCopyable&& ) = delete;
            NonCopyable& operator=( NonCopyable const& ) = delete;
            NonCopyable& operator=( NonCopyable&& ) = delete;

        protected:
            NonCopyable() noexcept = default;
        };

    } // namespace Detail
} // namespace Catch

#endif // CATCH_NONCOPYABLE_HPP_INCLUDED

#include <chrono>
#include <string>
#include <vector>

namespace Catch {

    enum class Verbosity {
        Quiet = 0,
        Normal,
        High
    };

    struct WarnAbout { enum What {
        Nothing = 0x00,
        //! A test case or leaf section did not run any assertions
        NoAssertions = 0x01,
        //! A command line test spec matched no test cases
        UnmatchedTestSpec = 0x02,
    }; };

    enum class ShowDurations {
        DefaultForReporter,
        Always,
        Never
    };
    enum class TestRunOrder {
        Declared,
        LexicographicallySorted,
        Randomized
    };
    enum class ColourMode : std::uint8_t {
        //! Let Catch2 pick implementation based on platform detection
        PlatformDefault,
        //! Use ANSI colour code escapes
        ANSI,
        //! Use Win32 console colour API
        Win32,
        //! Don't use any colour
        None
    };
    struct WaitForKeypress { enum When {
        Never,
        BeforeStart = 1,
        BeforeExit = 2,
        BeforeStartAndExit = BeforeStart | BeforeExit
    }; };

    class TestSpec;
    class IStream;

    class IConfig : public Detail::NonCopyable {
    public:
        virtual ~IConfig();

        virtual bool allowThrows() const = 0;
        virtual StringRef name() const = 0;
        virtual bool includeSuccessfulResults() const = 0;
        virtual bool shouldDebugBreak() const = 0;
        virtual bool warnAboutMissingAssertions() const = 0;
        virtual bool warnAboutUnmatchedTestSpecs() const = 0;
        virtual bool zeroTestsCountAsSuccess() const = 0;
        virtual int abortAfter() const = 0;
        virtual bool showInvisibles() const = 0;
        virtual ShowDurations showDurations() const = 0;
        virtual double minDuration() const = 0;
        virtual TestSpec const& testSpec() const = 0;
        virtual bool hasTestFilters() const = 0;
        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
        virtual TestRunOrder runOrder() const = 0;
        virtual uint32_t rngSeed() const = 0;
        virtual unsigned int shardCount() const = 0;
        virtual unsigned int shardIndex() const = 0;
        virtual ColourMode defaultColourMode() const = 0;
        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
        virtual Verbosity verbosity() const = 0;

        virtual bool skipBenchmarks() const = 0;
        virtual bool benchmarkNoAnalysis() const = 0;
        virtual unsigned int benchmarkSamples() const = 0;
        virtual double benchmarkConfidenceInterval() const = 0;
        virtual unsigned int benchmarkResamples() const = 0;
        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
    };
}

#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED


#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED


#include <string>

namespace Catch {

    class TestCaseHandle;
    struct TestCaseInfo;
    class ITestCaseRegistry;
    class IExceptionTranslatorRegistry;
    class IExceptionTranslator;
    class ReporterRegistry;
    class IReporterFactory;
    class ITagAliasRegistry;
    class ITestInvoker;
    class IMutableEnumValuesRegistry;
    struct SourceLineInfo;

    class StartupExceptionRegistry;
    class EventListenerFactory;

    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;

    class IRegistryHub {
    public:
        virtual ~IRegistryHub(); // = default

        virtual ReporterRegistry const& getReporterRegistry() const = 0;
        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;


        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
    };

    class IMutableRegistryHub {
    public:
        virtual ~IMutableRegistryHub(); // = default
        virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
        virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
        virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
        virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
        virtual void registerStartupException() noexcept = 0;
        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
    };

    IRegistryHub const& getRegistryHub();
    IMutableRegistryHub& getMutableRegistryHub();
    void cleanUp();
    std::string translateActiveException();

}

#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED


#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED
#define CATCH_BENCHMARK_STATS_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_ESTIMATE_HPP_INCLUDED
#define CATCH_ESTIMATE_HPP_INCLUDED

namespace Catch {
    namespace Benchmark {
        template <typename Type>
        struct Estimate {
            Type point;
            Type lower_bound;
            Type upper_bound;
            double confidence_interval;
        };
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_ESTIMATE_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED

namespace Catch {
    namespace Benchmark {
        struct OutlierClassification {
            int samples_seen = 0;
            int low_severe = 0;     // more than 3 times IQR below Q1
            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
            int high_severe = 0;    // more than 3 times IQR above Q3

            constexpr int total() const {
                return low_severe + low_mild + high_mild + high_severe;
            }
        };
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED
// The fwd decl & default specialization needs to be seen by VS2017 before
// BenchmarkStats itself, or VS2017 will report compilation error.

#include <string>
#include <vector>

namespace Catch {

    struct BenchmarkInfo {
        std::string name;
        double estimatedDuration;
        int iterations;
        unsigned int samples;
        unsigned int resamples;
        double clockResolution;
        double clockCost;
    };

    // We need to keep template parameter for backwards compatibility,
    // but we also do not want to use the template paraneter.
    template <class Dummy>
    struct BenchmarkStats {
        BenchmarkInfo info;

        std::vector<Benchmark::FDuration> samples;
        Benchmark::Estimate<Benchmark::FDuration> mean;
        Benchmark::Estimate<Benchmark::FDuration> standardDeviation;
        Benchmark::OutlierClassification outliers;
        double outlierVariance;
    };


} // end namespace Catch

#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
#define CATCH_ENVIRONMENT_HPP_INCLUDED


namespace Catch {
    namespace Benchmark {
        struct EnvironmentEstimate {
            FDuration mean;
            OutlierClassification outliers;
        };
        struct Environment {
            EnvironmentEstimate clock_resolution;
            EnvironmentEstimate clock_cost;
        };
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_ENVIRONMENT_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
#define CATCH_EXECUTION_PLAN_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
#define CATCH_CHRONOMETER_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
#define CATCH_OPTIMIZER_HPP_INCLUDED

#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
#   include <atomic> // atomic_thread_fence
#endif


#include <type_traits>

namespace Catch {
    namespace Benchmark {
#if defined(__GNUC__) || defined(__clang__)
        template <typename T>
        inline void keep_memory(T* p) {
            asm volatile("" : : "g"(p) : "memory");
        }
        inline void keep_memory() {
            asm volatile("" : : : "memory");
        }

        namespace Detail {
            inline void optimizer_barrier() { keep_memory(); }
        } // namespace Detail
#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)

#if defined(_MSVC_VER)
#pragma optimize("", off)
#elif defined(__IAR_SYSTEMS_ICC__)
// For IAR the pragma only affects the following function
#pragma optimize=disable
#endif
        template <typename T>
        inline void keep_memory(T* p) {
            // thanks @milleniumbug
            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
        }
        // TODO equivalent keep_memory()
#if defined(_MSVC_VER)
#pragma optimize("", on)
#endif

        namespace Detail {
            inline void optimizer_barrier() {
                std::atomic_thread_fence(std::memory_order_seq_cst);
            }
        } // namespace Detail

#endif

        template <typename T>
        inline void deoptimize_value(T&& x) {
            keep_memory(&x);
        }

        template <typename Fn, typename... Args>
        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
            deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
        }

        template <typename Fn, typename... Args>
        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
            CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
        }
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_OPTIMIZER_HPP_INCLUDED


#ifndef CATCH_META_HPP_INCLUDED
#define CATCH_META_HPP_INCLUDED

#include <type_traits>

namespace Catch {
    template <typename>
    struct true_given : std::true_type {};

    struct is_callable_tester {
        template <typename Fun, typename... Args>
        static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
        template <typename...>
        static std::false_type test(...);
    };

    template <typename T>
    struct is_callable;

    template <typename Fun, typename... Args>
    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};


#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
    // replaced with std::invoke_result here.
    template <typename Func, typename... U>
    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
#else
    template <typename Func, typename... U>
    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
#endif

} // namespace Catch

namespace mpl_{
    struct na;
}

#endif // CATCH_META_HPP_INCLUDED

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            struct ChronometerConcept {
                virtual void start() = 0;
                virtual void finish() = 0;
                virtual ~ChronometerConcept(); // = default;

                ChronometerConcept() = default;
                ChronometerConcept(ChronometerConcept const&) = default;
                ChronometerConcept& operator=(ChronometerConcept const&) = default;
            };
            template <typename Clock>
            struct ChronometerModel final : public ChronometerConcept {
                void start() override { started = Clock::now(); }
                void finish() override { finished = Clock::now(); }

                IDuration elapsed() const {
                    return std::chrono::duration_cast<std::chrono::nanoseconds>(
                        finished - started );
                }

                TimePoint<Clock> started;
                TimePoint<Clock> finished;
            };
        } // namespace Detail

        struct Chronometer {
        public:
            template <typename Fun>
            void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable<Fun(int)>()); }

            int runs() const { return repeats; }

            Chronometer(Detail::ChronometerConcept& meter, int repeats_)
                : impl(&meter)
                , repeats(repeats_) {}

        private:
            template <typename Fun>
            void measure(Fun&& fun, std::false_type) {
                measure([&fun](int) { return fun(); }, std::true_type());
            }

            template <typename Fun>
            void measure(Fun&& fun, std::true_type) {
                Detail::optimizer_barrier();
                impl->start();
                for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
                impl->finish();
                Detail::optimizer_barrier();
            }

            Detail::ChronometerConcept* impl;
            int repeats;
        };
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_CHRONOMETER_HPP_INCLUDED

#include <type_traits>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename T, typename U>
            static constexpr bool is_related_v = std::is_same<std::decay_t<T>, std::decay_t<U>>::value;

            /// We need to reinvent std::function because every piece of code that might add overhead
            /// in a measurement context needs to have consistent performance characteristics so that we
            /// can account for it in the measurement.
            /// Implementations of std::function with optimizations that aren't always applicable, like
            /// small buffer optimizations, are not uncommon.
            /// This is effectively an implementation of std::function without any such optimizations;
            /// it may be slow, but it is consistently slow.
            struct BenchmarkFunction {
            private:
                struct callable {
                    virtual void call(Chronometer meter) const = 0;
                    virtual ~callable(); // = default;

                    callable() = default;
                    callable(callable&&) = default;
                    callable& operator=(callable&&) = default;
                };
                template <typename Fun>
                struct model : public callable {
                    model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
                    model(Fun const& fun_) : fun(fun_) {}

                    void call(Chronometer meter) const override {
                        call(meter, is_callable<Fun(Chronometer)>());
                    }
                    void call(Chronometer meter, std::true_type) const {
                        fun(meter);
                    }
                    void call(Chronometer meter, std::false_type) const {
                        meter.measure(fun);
                    }

                    Fun fun;
                };

            public:
                BenchmarkFunction();

                template <typename Fun,
                    std::enable_if_t<!is_related_v<Fun, BenchmarkFunction>, int> = 0>
                    BenchmarkFunction(Fun&& fun)
                    : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}

                BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
                    f( CATCH_MOVE( that.f ) ) {}

                BenchmarkFunction&
                operator=( BenchmarkFunction&& that ) noexcept {
                    f = CATCH_MOVE( that.f );
                    return *this;
                }

                void operator()(Chronometer meter) const { f->call(meter); }

            private:
                Catch::Detail::unique_ptr<callable> f;
            };
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_REPEAT_HPP_INCLUDED
#define CATCH_REPEAT_HPP_INCLUDED

#include <type_traits>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename Fun>
            struct repeater {
                void operator()(int k) const {
                    for (int i = 0; i < k; ++i) {
                        fun();
                    }
                }
                Fun fun;
            };
            template <typename Fun>
            repeater<std::decay_t<Fun>> repeat(Fun&& fun) {
                return { CATCH_FORWARD(fun) };
            }
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_REPEAT_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_MEASURE_HPP_INCLUDED
#define CATCH_MEASURE_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED


namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename T>
            struct CompleteType { using type = T; };
            template <>
            struct CompleteType<void> { struct type {}; };

            template <typename T>
            using CompleteType_t = typename CompleteType<T>::type;

            template <typename Result>
            struct CompleteInvoker {
                template <typename Fun, typename... Args>
                static Result invoke(Fun&& fun, Args&&... args) {
                    return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
                }
            };
            template <>
            struct CompleteInvoker<void> {
                template <typename Fun, typename... Args>
                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
                    CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
                    return {};
                }
            };

            // invoke and not return void :(
            template <typename Fun, typename... Args>
            CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
            }

        } // namespace Detail

        template <typename Fun>
        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
            return Detail::complete_invoke(CATCH_FORWARD(fun));
        }
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_TIMING_HPP_INCLUDED
#define CATCH_TIMING_HPP_INCLUDED


namespace Catch {
    namespace Benchmark {
        template <typename Result>
        struct Timing {
            IDuration elapsed;
            Result result;
            int iterations;
        };
        template <typename Func, typename... Args>
        using TimingOf = Timing<Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_TIMING_HPP_INCLUDED

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename Clock, typename Fun, typename... Args>
            TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
                auto start = Clock::now();
                auto&& r = Detail::complete_invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
                auto end = Clock::now();
                auto delta = end - start;
                return { delta, CATCH_FORWARD(r), 1 };
            }
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_MEASURE_HPP_INCLUDED

#include <type_traits>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename Clock, typename Fun>
            TimingOf<Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
                return Detail::measure<Clock>(fun, iters);
            }
            template <typename Clock, typename Fun>
            TimingOf<Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
                Detail::ChronometerModel<Clock> meter;
                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));

                return { meter.elapsed(), CATCH_MOVE(result), iters };
            }

            template <typename Clock, typename Fun>
            using run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>;


            [[noreturn]]
            void throw_optimized_away_error();

            template <typename Clock, typename Fun>
            TimingOf<Fun, run_for_at_least_argument_t<Clock, Fun>>
                run_for_at_least(IDuration how_long,
                                 const int initial_iterations,
                                 Fun&& fun) {
                auto iters = initial_iterations;
                while (iters < (1 << 30)) {
                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());

                    if (Timing.elapsed >= how_long) {
                        return { Timing.elapsed, CATCH_MOVE(Timing.result), iters };
                    }
                    iters *= 2;
                }
                throw_optimized_away_error();
            }
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED

#include <vector>

namespace Catch {
    namespace Benchmark {
        struct ExecutionPlan {
            int iterations_per_sample;
            FDuration estimated_duration;
            Detail::BenchmarkFunction benchmark;
            FDuration warmup_time;
            int warmup_iterations;

            template <typename Clock>
            std::vector<FDuration> run(const IConfig &cfg, Environment env) const {
                // warmup a bit
                Detail::run_for_at_least<Clock>(
                    std::chrono::duration_cast<IDuration>( warmup_time ),
                    warmup_iterations,
                    Detail::repeat( []() { return Clock::now(); } )
                );

                std::vector<FDuration> times;
                const auto num_samples = cfg.benchmarkSamples();
                times.reserve( num_samples );
                for ( size_t i = 0; i < num_samples; ++i ) {
                    Detail::ChronometerModel<Clock> model;
                    this->benchmark( Chronometer( model, iterations_per_sample ) );
                    auto sample_time = model.elapsed() - env.clock_cost.mean;
                    if ( sample_time < FDuration::zero() ) {
                        sample_time = FDuration::zero();
                    }
                    times.push_back(sample_time / iterations_per_sample);
                }
                return times;
            }
        };
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_STATS_HPP_INCLUDED
#define CATCH_STATS_HPP_INCLUDED


#include <vector>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            using sample = std::vector<double>;

            double weighted_average_quantile( int k,
                                              int q,
                                              double* first,
                                              double* last );

            OutlierClassification
            classify_outliers( double const* first, double const* last );

            double mean( double const* first, double const* last );

            double normal_cdf( double x );

            double erfc_inv(double x);

            double normal_quantile(double p);

            Estimate<double>
            bootstrap( double confidence_level,
                       double* first,
                       double* last,
                       sample const& resample,
                       double ( *estimator )( double const*, double const* ) );

            struct bootstrap_analysis {
                Estimate<double> mean;
                Estimate<double> standard_deviation;
                double outlier_variance;
            };

            bootstrap_analysis analyse_samples(double confidence_level,
                                               unsigned int n_resamples,
                                               double* first,
                                               double* last);
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_STATS_HPP_INCLUDED

#include <algorithm>
#include <vector>
#include <cmath>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename Clock>
            std::vector<double> resolution(int k) {
                const size_t points = static_cast<size_t>( k + 1 );
                // To avoid overhead from the branch inside vector::push_back,
                // we allocate them all and then overwrite.
                std::vector<TimePoint<Clock>> times(points);
                for ( auto& time : times ) {
                    time = Clock::now();
                }

                std::vector<double> deltas;
                deltas.reserve(static_cast<size_t>(k));
                for ( size_t idx = 1; idx < points; ++idx ) {
                    deltas.push_back( static_cast<double>(
                        ( times[idx] - times[idx - 1] ).count() ) );
                }

                return deltas;
            }

            constexpr auto warmup_iterations = 10000;
            constexpr auto warmup_time = std::chrono::milliseconds(100);
            constexpr auto minimum_ticks = 1000;
            constexpr auto warmup_seed = 10000;
            constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
            constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
            constexpr auto clock_cost_estimation_tick_limit = 100000;
            constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
            constexpr auto clock_cost_estimation_iterations = 10000;

            template <typename Clock>
            int warmup() {
                return run_for_at_least<Clock>(warmup_time, warmup_seed, &resolution<Clock>)
                    .iterations;
            }
            template <typename Clock>
            EnvironmentEstimate estimate_clock_resolution(int iterations) {
                auto r = run_for_at_least<Clock>(clock_resolution_estimation_time, iterations, &resolution<Clock>)
                    .result;
                return {
                    FDuration(mean(r.data(), r.data() + r.size())),
                    classify_outliers(r.data(), r.data() + r.size()),
                };
            }
            template <typename Clock>
            EnvironmentEstimate estimate_clock_cost(FDuration resolution) {
                auto time_limit = (std::min)(
                    resolution * clock_cost_estimation_tick_limit,
                    FDuration(clock_cost_estimation_time_limit));
                auto time_clock = [](int k) {
                    return Detail::measure<Clock>([k] {
                        for (int i = 0; i < k; ++i) {
                            volatile auto ignored = Clock::now();
                            (void)ignored;
                        }
                    }).elapsed;
                };
                time_clock(1);
                int iters = clock_cost_estimation_iterations;
                auto&& r = run_for_at_least<Clock>(clock_cost_estimation_time, iters, time_clock);
                std::vector<double> times;
                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
                times.reserve(static_cast<size_t>(nsamples));
                for ( int s = 0; s < nsamples; ++s ) {
                    times.push_back( static_cast<double>(
                        ( time_clock( r.iterations ) / r.iterations )
                            .count() ) );
                }
                return {
                    FDuration(mean(times.data(), times.data() + times.size())),
                    classify_outliers(times.data(), times.data() + times.size()),
                };
            }

            template <typename Clock>
            Environment measure_environment() {
#if defined(__clang__)
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif
                static Catch::Detail::unique_ptr<Environment> env;
#if defined(__clang__)
#    pragma clang diagnostic pop
#endif
                if (env) {
                    return *env;
                }

                auto iters = Detail::warmup<Clock>();
                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);

                env = Catch::Detail::make_unique<Environment>( Environment{resolution, cost} );
                return *env;
            }
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_ANALYSE_HPP_INCLUDED
#define CATCH_ANALYSE_HPP_INCLUDED



// Adapted from donated nonius code.

#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED


#include <vector>

namespace Catch {
    namespace Benchmark {
        struct SampleAnalysis {
            std::vector<FDuration> samples;
            Estimate<FDuration> mean;
            Estimate<FDuration> standard_deviation;
            OutlierClassification outliers;
            double outlier_variance;
        };
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED


namespace Catch {
    class IConfig;

    namespace Benchmark {
        namespace Detail {
            SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last);
        } // namespace Detail
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_ANALYSE_HPP_INCLUDED

#include <algorithm>
#include <chrono>
#include <exception>
#include <string>
#include <cmath>

namespace Catch {
    namespace Benchmark {
        struct Benchmark {
            Benchmark(std::string&& benchmarkName)
                : name(CATCH_MOVE(benchmarkName)) {}

            template <class FUN>
            Benchmark(std::string&& benchmarkName , FUN &&func)
                : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}

            template <typename Clock>
            ExecutionPlan prepare(const IConfig &cfg, Environment env) {
                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), CATCH_MOVE(fun), std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
            }

            template <typename Clock = default_clock>
            void run() {
                static_assert( Clock::is_steady,
                               "Benchmarking clock should be steady" );
                auto const* cfg = getCurrentContext().getConfig();

                auto env = Detail::measure_environment<Clock>();

                getResultCapture().benchmarkPreparing(name);
                CATCH_TRY{
                    auto plan = user_code([&] {
                        return prepare<Clock>(*cfg, env);
                    });

                    BenchmarkInfo info {
                        CATCH_MOVE(name),
                        plan.estimated_duration.count(),
                        plan.iterations_per_sample,
                        cfg->benchmarkSamples(),
                        cfg->benchmarkResamples(),
                        env.clock_resolution.mean.count(),
                        env.clock_cost.mean.count()
                    };

                    getResultCapture().benchmarkStarting(info);

                    auto samples = user_code([&] {
                        return plan.template run<Clock>(*cfg, env);
                    });

                    auto analysis = Detail::analyse(*cfg, samples.data(), samples.data() + samples.size());
                    BenchmarkStats<> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
                    getResultCapture().benchmarkEnded(stats);
                } CATCH_CATCH_ANON (TestFailureException const&) {
                    getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
                } CATCH_CATCH_ALL{
                    getResultCapture().benchmarkFailed(translateActiveException());
                    // We let the exception go further up so that the
                    // test case is marked as failed.
                    std::rethrow_exception(std::current_exception());
                }
            }

            // sets lambda to be used in fun *and* executes benchmark!
            template <typename Fun, std::enable_if_t<!Detail::is_related_v<Fun, Benchmark>, int> = 0>
                Benchmark & operator=(Fun func) {
                auto const* cfg = getCurrentContext().getConfig();
                if (!cfg->skipBenchmarks()) {
                    fun = Detail::BenchmarkFunction(func);
                    run();
                }
                return *this;
            }

            explicit operator bool() {
                return true;
            }

        private:
            Detail::BenchmarkFunction fun;
            std::string name;
        };
    }
} // namespace Catch

#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2

#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
        BenchmarkName = [&](int benchmarkIndex)

#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
        BenchmarkName = [&]

#if defined(CATCH_CONFIG_PREFIX_ALL)

#define CATCH_BENCHMARK(...) \
    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
#define CATCH_BENCHMARK_ADVANCED(name) \
    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)

#else

#define BENCHMARK(...) \
    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
#define BENCHMARK_ADVANCED(name) \
    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)

#endif

#endif // CATCH_BENCHMARK_HPP_INCLUDED


// Adapted from donated nonius code.

#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
#define CATCH_CONSTRUCTOR_HPP_INCLUDED


#include <type_traits>

namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename T, bool Destruct>
            struct ObjectStorage
            {
                ObjectStorage() = default;

                ObjectStorage(const ObjectStorage& other)
                {
                    new(&data) T(other.stored_object());
                }

                ObjectStorage(ObjectStorage&& other)
                {
                    new(data) T(CATCH_MOVE(other.stored_object()));
                }

                ~ObjectStorage() { destruct_on_exit<T>(); }

                template <typename... Args>
                void construct(Args&&... args)
                {
                    new (data) T(CATCH_FORWARD(args)...);
                }

                template <bool AllowManualDestruction = !Destruct>
                std::enable_if_t<AllowManualDestruction> destruct()
                {
                    stored_object().~T();
                }

            private:
                // If this is a constructor benchmark, destruct the underlying object
                template <typename U>
                void destruct_on_exit(std::enable_if_t<Destruct, U>* = nullptr) { destruct<true>(); }
                // Otherwise, don't
                template <typename U>
                void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }

#if defined( __GNUC__ ) && __GNUC__ <= 6
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
                T& stored_object() { return *reinterpret_cast<T*>( data ); }

                T const& stored_object() const {
                    return *reinterpret_cast<T const*>( data );
                }
#if defined( __GNUC__ ) && __GNUC__ <= 6
#    pragma GCC diagnostic pop
#endif

                alignas( T ) unsigned char data[sizeof( T )]{};
            };
        } // namespace Detail

        template <typename T>
        using storage_for = Detail::ObjectStorage<T, true>;

        template <typename T>
        using destructable_object = Detail::ObjectStorage<T, false>;
    } // namespace Benchmark
} // namespace Catch

#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED

#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED


#ifndef CATCH_APPROX_HPP_INCLUDED
#define CATCH_APPROX_HPP_INCLUDED



#ifndef CATCH_TOSTRING_HPP_INCLUDED
#define CATCH_TOSTRING_HPP_INCLUDED


#include <vector>
#include <cstddef>
#include <type_traits>
#include <string>




/** \file
 * Wrapper for the WCHAR configuration option
 *
 * We want to support platforms that do not provide `wchar_t`, so we
 * sometimes have to disable providing wchar_t overloads through Catch2,
 * e.g. the StringMaker specialization for `std::wstring`.
 */

#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
#define CATCH_CONFIG_WCHAR_HPP_INCLUDED


// We assume that WCHAR should be enabled by default, and only disabled
// for a shortlist (so far only DJGPP) of compilers.

#if defined(__DJGPP__)
#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
#endif // __DJGPP__

#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \
    !defined( CATCH_CONFIG_NO_WCHAR ) && \
    !defined( CATCH_CONFIG_WCHAR )
#    define CATCH_CONFIG_WCHAR
#endif

#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED


#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED


#include <iosfwd>
#include <cstddef>
#include <ostream>
#include <string>

namespace Catch {

    class ReusableStringStream : Detail::NonCopyable {
        std::size_t m_index;
        std::ostream* m_oss;
    public:
        ReusableStringStream();
        ~ReusableStringStream();

        //! Returns the serialized state
        std::string str() const;
        //! Sets internal state to `str`
        void str(std::string const& str);

#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
// Old versions of GCC do not understand -Wnonnull-compare
#pragma GCC diagnostic ignored "-Wpragmas"
// Streaming a function pointer triggers Waddress and Wnonnull-compare
// on GCC, because it implicitly converts it to bool and then decides
// that the check it uses (a? true : false) is tautological and cannot
// be null...
#pragma GCC diagnostic ignored "-Waddress"
#pragma GCC diagnostic ignored "-Wnonnull-compare"
#endif

        template<typename T>
        auto operator << ( T const& value ) -> ReusableStringStream& {
            *m_oss << value;
            return *this;
        }

#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
        auto get() -> std::ostream& { return *m_oss; }
    };
}

#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED


#ifndef CATCH_VOID_TYPE_HPP_INCLUDED
#define CATCH_VOID_TYPE_HPP_INCLUDED


namespace Catch {
    namespace Detail {

        template <typename...>
        struct make_void { using type = void; };

        template <typename... Ts>
        using void_t = typename make_void<Ts...>::type;

    } // namespace Detail
} // namespace Catch


#endif // CATCH_VOID_TYPE_HPP_INCLUDED


#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED


#include <vector>

namespace Catch {

    namespace Detail {
        struct EnumInfo {
            StringRef m_name;
            std::vector<std::pair<int, StringRef>> m_values;

            ~EnumInfo();

            StringRef lookup( int value ) const;
        };
    } // namespace Detail

    class IMutableEnumValuesRegistry {
    public:
        virtual ~IMutableEnumValuesRegistry(); // = default;

        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;

        template<typename E>
        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
            std::vector<int> intValues;
            intValues.reserve( values.size() );
            for( auto enumValue : values )
                intValues.push_back( static_cast<int>( enumValue ) );
            return registerEnum( enumName, allEnums, intValues );
        }
    };

} // Catch

#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED

#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
#include <string_view>
#endif

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
#endif

// We need a dummy global operator<< so we can bring it into Catch namespace later
struct Catch_global_namespace_dummy{};
std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);

namespace Catch {
    // Bring in global namespace operator<< for ADL lookup in
    // `IsStreamInsertable` below.
    using ::operator<<;

    namespace Detail {

        inline std::size_t catch_strnlen(const char *str, std::size_t n) {
            auto ret = std::char_traits<char>::find(str, n, '\0');
            if (ret != nullptr) {
                return static_cast<std::size_t>(ret - str);
            }
            return n;
        }

        constexpr StringRef unprintableString = "{?}"_sr;

        //! Encases `string in quotes, and optionally escapes invisibles
        std::string convertIntoString( StringRef string, bool escapeInvisibles );

        //! Encases `string` in quotes, and escapes invisibles if user requested
        //! it via CLI
        std::string convertIntoString( StringRef string );

        std::string rawMemoryToString( const void *object, std::size_t size );

        template<typename T>
        std::string rawMemoryToString( const T& object ) {
          return rawMemoryToString( &object, sizeof(object) );
        }

        template<typename T,typename = void>
        static constexpr bool IsStreamInsertable_v = false;

        template <typename T>
        static constexpr bool IsStreamInsertable_v<
            T,
            decltype( void( std::declval<std::ostream&>() << std::declval<T>() ) )> =
            true;

        template<typename E>
        std::string convertUnknownEnumToString( E e );

        template<typename T>
        std::enable_if_t<
            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
        std::string> convertUnstreamable( T const& ) {
            return std::string(Detail::unprintableString);
        }
        template<typename T>
        std::enable_if_t<
            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
         std::string> convertUnstreamable(T const& ex) {
            return ex.what();
        }


        template<typename T>
        std::enable_if_t<
            std::is_enum<T>::value,
        std::string> convertUnstreamable( T const& value ) {
            return convertUnknownEnumToString( value );
        }

#if defined(_MANAGED)
        //! Convert a CLR string to a utf8 std::string
        template<typename T>
        std::string clrReferenceToString( T^ ref ) {
            if (ref == nullptr)
                return std::string("null");
            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
            cli::pin_ptr<System::Byte> p = &bytes[0];
            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
        }
#endif

    } // namespace Detail


    template <typename T, typename = void>
    struct StringMaker {
        template <typename Fake = T>
        static
        std::enable_if_t<::Catch::Detail::IsStreamInsertable_v<Fake>, std::string>
            convert(const Fake& value) {
                ReusableStringStream rss;
                // NB: call using the function-like syntax to avoid ambiguity with
                // user-defined templated operator<< under clang.
                rss.operator<<(value);
                return rss.str();
        }

        template <typename Fake = T>
        static
        std::enable_if_t<!::Catch::Detail::IsStreamInsertable_v<Fake>, std::string>
            convert( const Fake& value ) {
#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
            return Detail::convertUnstreamable(value);
#else
            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
#endif
        }
    };

    namespace Detail {

        // This function dispatches all stringification requests inside of Catch.
        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
        template <typename T>
        std::string stringify(const T& e) {
            return ::Catch::StringMaker<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
        }

        template<typename E>
        std::string convertUnknownEnumToString( E e ) {
            return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(e));
        }

#if defined(_MANAGED)
        template <typename T>
        std::string stringify( T^ e ) {
            return ::Catch::StringMaker<T^>::convert(e);
        }
#endif

    } // namespace Detail

    // Some predefined specializations

    template<>
    struct StringMaker<std::string> {
        static std::string convert(const std::string& str);
    };

#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker<std::string_view> {
        static std::string convert(std::string_view str);
    };
#endif

    template<>
    struct StringMaker<char const *> {
        static std::string convert(char const * str);
    };
    template<>
    struct StringMaker<char *> {
        static std::string convert(char * str);
    };

#if defined(CATCH_CONFIG_WCHAR)
    template<>
    struct StringMaker<std::wstring> {
        static std::string convert(const std::wstring& wstr);
    };

# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker<std::wstring_view> {
        static std::string convert(std::wstring_view str);
    };
# endif

    template<>
    struct StringMaker<wchar_t const *> {
        static std::string convert(wchar_t const * str);
    };
    template<>
    struct StringMaker<wchar_t *> {
        static std::string convert(wchar_t * str);
    };
#endif // CATCH_CONFIG_WCHAR

    template<size_t SZ>
    struct StringMaker<char[SZ]> {
        static std::string convert(char const* str) {
            return Detail::convertIntoString(
                StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
        }
    };
    template<size_t SZ>
    struct StringMaker<signed char[SZ]> {
        static std::string convert(signed char const* str) {
            auto reinterpreted = reinterpret_cast<char const*>(str);
            return Detail::convertIntoString(
                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
        }
    };
    template<size_t SZ>
    struct StringMaker<unsigned char[SZ]> {
        static std::string convert(unsigned char const* str) {
            auto reinterpreted = reinterpret_cast<char const*>(str);
            return Detail::convertIntoString(
                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
        }
    };

#if defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker<std::byte> {
        static std::string convert(std::byte value);
    };
#endif // defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker<int> {
        static std::string convert(int value);
    };
    template<>
    struct StringMaker<long> {
        static std::string convert(long value);
    };
    template<>
    struct StringMaker<long long> {
        static std::string convert(long long value);
    };
    template<>
    struct StringMaker<unsigned int> {
        static std::string convert(unsigned int value);
    };
    template<>
    struct StringMaker<unsigned long> {
        static std::string convert(unsigned long value);
    };
    template<>
    struct StringMaker<unsigned long long> {
        static std::string convert(unsigned long long value);
    };

    template<>
    struct StringMaker<bool> {
        static std::string convert(bool b) {
            using namespace std::string_literals;
            return b ? "true"s : "false"s;
        }
    };

    template<>
    struct StringMaker<char> {
        static std::string convert(char c);
    };
    template<>
    struct StringMaker<signed char> {
        static std::string convert(signed char value);
    };
    template<>
    struct StringMaker<unsigned char> {
        static std::string convert(unsigned char value);
    };

    template<>
    struct StringMaker<std::nullptr_t> {
        static std::string convert(std::nullptr_t) {
            using namespace std::string_literals;
            return "nullptr"s;
        }
    };

    template<>
    struct StringMaker<float> {
        static std::string convert(float value);
        CATCH_EXPORT static int precision;
    };

    template<>
    struct StringMaker<double> {
        static std::string convert(double value);
        CATCH_EXPORT static int precision;
    };

    template <typename T>
    struct StringMaker<T*> {
        template <typename U>
        static std::string convert(U* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

    template <typename R, typename C>
    struct StringMaker<R C::*> {
        static std::string convert(R C::* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

#if defined(_MANAGED)
    template <typename T>
    struct StringMaker<T^> {
        static std::string convert( T^ ref ) {
            return ::Catch::Detail::clrReferenceToString(ref);
        }
    };
#endif

    namespace Detail {
        template<typename InputIterator, typename Sentinel = InputIterator>
        std::string rangeToString(InputIterator first, Sentinel last) {
            ReusableStringStream rss;
            rss << "{ ";
            if (first != last) {
                rss << ::Catch::Detail::stringify(*first);
                for (++first; first != last; ++first)
                    rss << ", " << ::Catch::Detail::stringify(*first);
            }
            rss << " }";
            return rss.str();
        }
    }

} // namespace Catch

//////////////////////////////////////////////////////
// Separate std-lib types stringification, so it can be selectively enabled
// This means that we do not bring in their headers

#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
#endif

// Separate std::pair specialization
#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
#include <utility>
namespace Catch {
    template<typename T1, typename T2>
    struct StringMaker<std::pair<T1, T2> > {
        static std::string convert(const std::pair<T1, T2>& pair) {
            ReusableStringStream rss;
            rss << "{ "
                << ::Catch::Detail::stringify(pair.first)
                << ", "
                << ::Catch::Detail::stringify(pair.second)
                << " }";
            return rss.str();
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER

#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
#include <optional>
namespace Catch {
    template<typename T>
    struct StringMaker<std::optional<T> > {
        static std::string convert(const std::optional<T>& optional) {
            if (optional.has_value()) {
                return ::Catch::Detail::stringify(*optional);
            } else {
                return "{ }";
            }
        }
    };
    template <>
    struct StringMaker<std::nullopt_t> {
        static std::string convert(const std::nullopt_t&) {
            return "{ }";
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER

// Separate std::tuple specialization
#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
#include <tuple>
namespace Catch {
    namespace Detail {
        template<
            typename Tuple,
            std::size_t N = 0,
            bool = (N < std::tuple_size<Tuple>::value)
            >
            struct TupleElementPrinter {
            static void print(const Tuple& tuple, std::ostream& os) {
                os << (N ? ", " : " ")
                    << ::Catch::Detail::stringify(std::get<N>(tuple));
                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
            }
        };

        template<
            typename Tuple,
            std::size_t N
        >
            struct TupleElementPrinter<Tuple, N, false> {
            static void print(const Tuple&, std::ostream&) {}
        };

    }


    template<typename ...Types>
    struct StringMaker<std::tuple<Types...>> {
        static std::string convert(const std::tuple<Types...>& tuple) {
            ReusableStringStream rss;
            rss << '{';
            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
            rss << " }";
            return rss.str();
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER

#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
#include <variant>
namespace Catch {
    template<>
    struct StringMaker<std::monostate> {
        static std::string convert(const std::monostate&) {
            return "{ }";
        }
    };

    template<typename... Elements>
    struct StringMaker<std::variant<Elements...>> {
        static std::string convert(const std::variant<Elements...>& variant) {
            if (variant.valueless_by_exception()) {
                return "{valueless variant}";
            } else {
                return std::visit(
                    [](const auto& value) {
                        return ::Catch::Detail::stringify(value);
                    },
                    variant
                );
            }
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER

namespace Catch {
    // Import begin/ end from std here
    using std::begin;
    using std::end;

    namespace Detail {
        template <typename T, typename = void>
        struct is_range_impl : std::false_type {};

        template <typename T>
        struct is_range_impl<T, void_t<decltype(begin(std::declval<T>()))>> : std::true_type {};
    } // namespace Detail

    template <typename T>
    struct is_range : Detail::is_range_impl<T> {};

#if defined(_MANAGED) // Managed types are never ranges
    template <typename T>
    struct is_range<T^> {
        static const bool value = false;
    };
#endif

    template<typename Range>
    std::string rangeToString( Range const& range ) {
        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
    }

    // Handle vector<bool> specially
    template<typename Allocator>
    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
        ReusableStringStream rss;
        rss << "{ ";
        bool first = true;
        for( bool b : v ) {
            if( first )
                first = false;
            else
                rss << ", ";
            rss << ::Catch::Detail::stringify( b );
        }
        rss << " }";
        return rss.str();
    }

    template<typename R>
    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable_v<R>>> {
        static std::string convert( R const& range ) {
            return rangeToString( range );
        }
    };

    template <typename T, size_t SZ>
    struct StringMaker<T[SZ]> {
        static std::string convert(T const(&arr)[SZ]) {
            return rangeToString(arr);
        }
    };


} // namespace Catch

// Separate std::chrono::duration specialization
#include <ctime>
#include <ratio>
#include <chrono>


namespace Catch {

template <class Ratio>
struct ratio_string {
    static std::string symbol() {
        Catch::ReusableStringStream rss;
        rss << '[' << Ratio::num << '/'
            << Ratio::den << ']';
        return rss.str();
    }
};

template <>
struct ratio_string<std::atto> {
    static char symbol() { return 'a'; }
};
template <>
struct ratio_string<std::femto> {
    static char symbol() { return 'f'; }
};
template <>
struct ratio_string<std::pico> {
    static char symbol() { return 'p'; }
};
template <>
struct ratio_string<std::nano> {
    static char symbol() { return 'n'; }
};
template <>
struct ratio_string<std::micro> {
    static char symbol() { return 'u'; }
};
template <>
struct ratio_string<std::milli> {
    static char symbol() { return 'm'; }
};

    ////////////
    // std::chrono::duration specializations
    template<typename Value, typename Ratio>
    struct StringMaker<std::chrono::duration<Value, Ratio>> {
        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
            return rss.str();
        }
    };
    template<typename Value>
    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " s";
            return rss.str();
        }
    };
    template<typename Value>
    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " m";
            return rss.str();
        }
    };
    template<typename Value>
    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " h";
            return rss.str();
        }
    };

    ////////////
    // std::chrono::time_point specialization
    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
    template<typename Clock, typename Duration>
    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
        }
    };
    // std::chrono::time_point<system_clock> specialization
    template<typename Duration>
    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
            auto converted = std::chrono::system_clock::to_time_t(time_point);

#ifdef _MSC_VER
            std::tm timeInfo = {};
            const auto err = gmtime_s(&timeInfo, &converted);
            if ( err ) {
                return "gmtime from provided timepoint has failed. This "
                       "happens e.g. with pre-1970 dates using Microsoft libc";
            }
#else
            std::tm* timeInfo = std::gmtime(&converted);
#endif

            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
            char timeStamp[timeStampSize];
            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";

#ifdef _MSC_VER
            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
#else
            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
#endif
            return std::string(timeStamp, timeStampSize - 1);
        }
    };
}


#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
namespace Catch { \
    template<> struct StringMaker<enumName> { \
        static std::string convert( enumName value ) { \
            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
        } \
    }; \
}

#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )

#ifdef _MSC_VER
#pragma warning(pop)
#endif

#endif // CATCH_TOSTRING_HPP_INCLUDED

#include <type_traits>

namespace Catch {

    class Approx {
    private:
        bool equalityComparisonImpl(double other) const;
        // Sets and validates the new margin (margin >= 0)
        void setMargin(double margin);
        // Sets and validates the new epsilon (0 < epsilon < 1)
        void setEpsilon(double epsilon);

    public:
        explicit Approx ( double value );

        static Approx custom();

        Approx operator-() const;

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        Approx operator()( T const& value ) const {
            Approx approx( static_cast<double>(value) );
            approx.m_epsilon = m_epsilon;
            approx.m_margin = m_margin;
            approx.m_scale = m_scale;
            return approx;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        explicit Approx( T const& value ): Approx(static_cast<double>(value))
        {}


        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator == ( const T& lhs, Approx const& rhs ) {
            auto lhs_v = static_cast<double>(lhs);
            return rhs.equalityComparisonImpl(lhs_v);
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator == ( Approx const& lhs, const T& rhs ) {
            return operator==( rhs, lhs );
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator != ( T const& lhs, Approx const& rhs ) {
            return !operator==( lhs, rhs );
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator != ( Approx const& lhs, T const& rhs ) {
            return !operator==( rhs, lhs );
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        Approx& epsilon( T const& newEpsilon ) {
            const auto epsilonAsDouble = static_cast<double>(newEpsilon);
            setEpsilon(epsilonAsDouble);
            return *this;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        Approx& margin( T const& newMargin ) {
            const auto marginAsDouble = static_cast<double>(newMargin);
            setMargin(marginAsDouble);
            return *this;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        Approx& scale( T const& newScale ) {
            m_scale = static_cast<double>(newScale);
            return *this;
        }

        std::string toString() const;

    private:
        double m_epsilon;
        double m_margin;
        double m_scale;
        double m_value;
    };

namespace literals {
    Approx operator ""_a(long double val);
    Approx operator ""_a(unsigned long long val);
} // end namespace literals

template<>
struct StringMaker<Catch::Approx> {
    static std::string convert(Catch::Approx const& value);
};

} // end namespace Catch

#endif // CATCH_APPROX_HPP_INCLUDED


#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
#define CATCH_ASSERTION_INFO_HPP_INCLUDED



#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED

#include <cstddef>
#include <iosfwd>

namespace Catch {

    struct SourceLineInfo {

        SourceLineInfo() = delete;
        constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
            file( _file ),
            line( _line )
        {}

        bool operator == ( SourceLineInfo const& other ) const noexcept;
        bool operator < ( SourceLineInfo const& other ) const noexcept;

        char const* file;
        std::size_t line;

        friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info);
    };
}

#define CATCH_INTERNAL_LINEINFO \
    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )

#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED

namespace Catch {

    struct AssertionInfo {
        // AssertionInfo() = delete;

        StringRef macroName;
        SourceLineInfo lineInfo;
        StringRef capturedExpression;
        ResultDisposition::Flags resultDisposition;
    };

} // end namespace Catch

#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED


#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
#define CATCH_ASSERTION_RESULT_HPP_INCLUDED



#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED
#define CATCH_LAZY_EXPR_HPP_INCLUDED

#include <iosfwd>

namespace Catch {

    class ITransientExpression;

    class LazyExpression {
        friend class AssertionHandler;
        friend struct AssertionStats;
        friend class RunContext;

        ITransientExpression const* m_transientExpression = nullptr;
        bool m_isNegated;
    public:
        constexpr LazyExpression( bool isNegated ):
            m_isNegated(isNegated)
        {}
        constexpr LazyExpression(LazyExpression const& other) = default;
        LazyExpression& operator = ( LazyExpression const& ) = delete;

        constexpr explicit operator bool() const {
            return m_transientExpression != nullptr;
        }

        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
    };

} // namespace Catch

#endif // CATCH_LAZY_EXPR_HPP_INCLUDED

#include <string>

namespace Catch {

    struct AssertionResultData
    {
        AssertionResultData() = delete;

        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );

        std::string message;
        mutable std::string reconstructedExpression;
        LazyExpression lazyExpression;
        ResultWas::OfType resultType;

        std::string reconstructExpression() const;
    };

    class AssertionResult {
    public:
        AssertionResult() = delete;
        AssertionResult( AssertionInfo const& info, AssertionResultData&& data );

        bool isOk() const;
        bool succeeded() const;
        ResultWas::OfType getResultType() const;
        bool hasExpression() const;
        bool hasMessage() const;
        std::string getExpression() const;
        std::string getExpressionInMacro() const;
        bool hasExpandedExpression() const;
        std::string getExpandedExpression() const;
        StringRef getMessage() const;
        SourceLineInfo getSourceInfo() const;
        StringRef getTestMacroName() const;

    //protected:
        AssertionInfo m_info;
        AssertionResultData m_resultData;
    };

} // end namespace Catch

#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED


#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
#define CATCH_CASE_SENSITIVE_HPP_INCLUDED

namespace Catch {

    enum class CaseSensitive { Yes, No };

} // namespace Catch

#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED


#ifndef CATCH_CONFIG_HPP_INCLUDED
#define CATCH_CONFIG_HPP_INCLUDED



#ifndef CATCH_TEST_SPEC_HPP_INCLUDED
#define CATCH_TEST_SPEC_HPP_INCLUDED

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#endif



#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED


#include <string>

namespace Catch
{
    class WildcardPattern {
        enum WildcardPosition {
            NoWildcard = 0,
            WildcardAtStart = 1,
            WildcardAtEnd = 2,
            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
        };

    public:

        WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
        bool matches( std::string const& str ) const;

    private:
        std::string normaliseString( std::string const& str ) const;
        CaseSensitive m_caseSensitivity;
        WildcardPosition m_wildcard = NoWildcard;
        std::string m_pattern;
    };
}

#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED

#include <iosfwd>
#include <string>
#include <vector>

namespace Catch {

    class IConfig;
    struct TestCaseInfo;
    class TestCaseHandle;

    class TestSpec {

        class Pattern {
        public:
            explicit Pattern( std::string const& name );
            virtual ~Pattern();
            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
            std::string const& name() const;
        private:
            virtual void serializeTo( std::ostream& out ) const = 0;
            // Writes string that would be reparsed into the pattern
            friend std::ostream& operator<<(std::ostream& out,
                                            Pattern const& pattern) {
                pattern.serializeTo( out );
                return out;
            }

            std::string const m_name;
        };

        class NamePattern : public Pattern {
        public:
            explicit NamePattern( std::string const& name, std::string const& filterString );
            bool matches( TestCaseInfo const& testCase ) const override;
        private:
            void serializeTo( std::ostream& out ) const override;

            WildcardPattern m_wildcardPattern;
        };

        class TagPattern : public Pattern {
        public:
            explicit TagPattern( std::string const& tag, std::string const& filterString );
            bool matches( TestCaseInfo const& testCase ) const override;
        private:
            void serializeTo( std::ostream& out ) const override;

            std::string m_tag;
        };

        struct Filter {
            std::vector<Detail::unique_ptr<Pattern>> m_required;
            std::vector<Detail::unique_ptr<Pattern>> m_forbidden;

            //! Serializes this filter into a string that would be parsed into
            //! an equivalent filter
            void serializeTo( std::ostream& out ) const;
            friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
                f.serializeTo( out );
                return out;
            }

            bool matches( TestCaseInfo const& testCase ) const;
        };

        static std::string extractFilterName( Filter const& filter );

    public:
        struct FilterMatch {
            std::string name;
            std::vector<TestCaseHandle const*> tests;
        };
        using Matches = std::vector<FilterMatch>;
        using vectorStrings = std::vector<std::string>;

        bool hasFilters() const;
        bool matches( TestCaseInfo const& testCase ) const;
        Matches matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const;
        const vectorStrings & getInvalidSpecs() const;

    private:
        std::vector<Filter> m_filters;
        std::vector<std::string> m_invalidSpecs;

        friend class TestSpecParser;
        //! Serializes this test spec into a string that would be parsed into
        //! equivalent test spec
        void serializeTo( std::ostream& out ) const;
        friend std::ostream& operator<<(std::ostream& out,
                                        TestSpec const& spec) {
            spec.serializeTo( out );
            return out;
        }
    };
}

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#endif // CATCH_TEST_SPEC_HPP_INCLUDED


#ifndef CATCH_OPTIONAL_HPP_INCLUDED
#define CATCH_OPTIONAL_HPP_INCLUDED


#include <cassert>

namespace Catch {

    // An optional type
    template<typename T>
    class Optional {
    public:
        Optional(): nullableValue( nullptr ) {}
        ~Optional() { reset(); }

        Optional( T const& _value ):
            nullableValue( new ( storage ) T( _value ) ) {}
        Optional( T&& _value ):
            nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}

        Optional& operator=( T const& _value ) {
            reset();
            nullableValue = new ( storage ) T( _value );
            return *this;
        }
        Optional& operator=( T&& _value ) {
            reset();
            nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
            return *this;
        }

        Optional( Optional const& _other ):
            nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
        Optional( Optional&& _other ):
            nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
                                  : nullptr ) {}

        Optional& operator=( Optional const& _other ) {
            if ( &_other != this ) {
                reset();
                if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
            }
            return *this;
        }
        Optional& operator=( Optional&& _other ) {
            if ( &_other != this ) {
                reset();
                if ( _other ) {
                    nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
                }
            }
            return *this;
        }

        void reset() {
            if ( nullableValue ) { nullableValue->~T(); }
            nullableValue = nullptr;
        }

        T& operator*() {
            assert(nullableValue);
            return *nullableValue;
        }
        T const& operator*() const {
            assert(nullableValue);
            return *nullableValue;
        }
        T* operator->() {
            assert(nullableValue);
            return nullableValue;
        }
        const T* operator->() const {
            assert(nullableValue);
            return nullableValue;
        }

        T valueOr( T const& defaultValue ) const {
            return nullableValue ? *nullableValue : defaultValue;
        }

        bool some() const { return nullableValue != nullptr; }
        bool none() const { return nullableValue == nullptr; }

        bool operator !() const { return nullableValue == nullptr; }
        explicit operator bool() const {
            return some();
        }

        friend bool operator==(Optional const& a, Optional const& b) {
            if (a.none() && b.none()) {
                return true;
            } else if (a.some() && b.some()) {
                return *a == *b;
            } else {
                return false;
            }
        }
        friend bool operator!=(Optional const& a, Optional const& b) {
            return !( a == b );
        }

    private:
        T* nullableValue;
        alignas(alignof(T)) char storage[sizeof(T)];
    };

} // end namespace Catch

#endif // CATCH_OPTIONAL_HPP_INCLUDED


#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED

#include <cstdint>

namespace Catch {

    enum class GenerateFrom {
        Time,
        RandomDevice,
        //! Currently equivalent to RandomDevice, but can change at any point
        Default
    };

    std::uint32_t generateRandomSeed(GenerateFrom from);

} // end namespace Catch

#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED


#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED


#include <map>
#include <string>
#include <vector>

namespace Catch {

    enum class ColourMode : std::uint8_t;

    namespace Detail {
        //! Splits the reporter spec into reporter name and kv-pair options
        std::vector<std::string> splitReporterSpec( StringRef reporterSpec );

        Optional<ColourMode> stringToColourMode( StringRef colourMode );
    }

    /**
     * Structured reporter spec that a reporter can be created from
     *
     * Parsing has been validated, but semantics have not. This means e.g.
     * that the colour mode is known to Catch2, but it might not be
     * compiled into the binary, and the output filename might not be
     * openable.
     */
    class ReporterSpec {
        std::string m_name;
        Optional<std::string> m_outputFileName;
        Optional<ColourMode> m_colourMode;
        std::map<std::string, std::string> m_customOptions;

        friend bool operator==( ReporterSpec const& lhs,
                                ReporterSpec const& rhs );
        friend bool operator!=( ReporterSpec const& lhs,
                                ReporterSpec const& rhs ) {
            return !( lhs == rhs );
        }

    public:
        ReporterSpec(
            std::string name,
            Optional<std::string> outputFileName,
            Optional<ColourMode> colourMode,
            std::map<std::string, std::string> customOptions );

        std::string const& name() const { return m_name; }

        Optional<std::string> const& outputFile() const {
            return m_outputFileName;
        }

        Optional<ColourMode> const& colourMode() const { return m_colourMode; }

        std::map<std::string, std::string> const& customOptions() const {
            return m_customOptions;
        }
    };

    /**
     * Parses provided reporter spec string into
     *
     * Returns empty optional on errors, e.g.
     *  * field that is not first and not a key+value pair
     *  * duplicated keys in kv pair
     *  * unknown catch reporter option
     *  * empty key/value in an custom kv pair
     *  * ...
     */
    Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec );

}

#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED

#include <chrono>
#include <map>
#include <string>
#include <vector>

namespace Catch {

    class IStream;

    /**
     * `ReporterSpec` but with the defaults filled in.
     *
     * Like `ReporterSpec`, the semantics are unchecked.
     */
    struct ProcessedReporterSpec {
        std::string name;
        std::string outputFilename;
        ColourMode colourMode;
        std::map<std::string, std::string> customOptions;
        friend bool operator==( ProcessedReporterSpec const& lhs,
                                ProcessedReporterSpec const& rhs );
        friend bool operator!=( ProcessedReporterSpec const& lhs,
                                ProcessedReporterSpec const& rhs ) {
            return !( lhs == rhs );
        }
    };

    struct ConfigData {

        bool listTests = false;
        bool listTags = false;
        bool listReporters = false;
        bool listListeners = false;

        bool showSuccessfulTests = false;
        bool shouldDebugBreak = false;
        bool noThrow = false;
        bool showHelp = false;
        bool showInvisibles = false;
        bool filenamesAsTags = false;
        bool libIdentify = false;
        bool allowZeroTests = false;

        int abortAfter = -1;
        uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default);

        unsigned int shardCount = 1;
        unsigned int shardIndex = 0;

        bool skipBenchmarks = false;
        bool benchmarkNoAnalysis = false;
        unsigned int benchmarkSamples = 100;
        double benchmarkConfidenceInterval = 0.95;
        unsigned int benchmarkResamples = 100'000;
        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;

        Verbosity verbosity = Verbosity::Normal;
        WarnAbout::What warnings = WarnAbout::Nothing;
        ShowDurations showDurations = ShowDurations::DefaultForReporter;
        double minDuration = -1;
        TestRunOrder runOrder = TestRunOrder::Randomized;
        ColourMode defaultColourMode = ColourMode::PlatformDefault;
        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;

        std::string defaultOutputFilename;
        std::string name;
        std::string processName;
        std::vector<ReporterSpec> reporterSpecifications;

        std::vector<std::string> testsOrTags;
        std::vector<std::string> sectionsToRun;
    };


    class Config : public IConfig {
    public:

        Config() = default;
        Config( ConfigData const& data );
        ~Config() override; // = default in the cpp file

        bool listTests() const;
        bool listTags() const;
        bool listReporters() const;
        bool listListeners() const;

        std::vector<ReporterSpec> const& getReporterSpecs() const;
        std::vector<ProcessedReporterSpec> const&
        getProcessedReporterSpecs() const;

        std::vector<std::string> const& getTestsOrTags() const override;
        std::vector<std::string> const& getSectionsToRun() const override;

        TestSpec const& testSpec() const override;
        bool hasTestFilters() const override;

        bool showHelp() const;

        // IConfig interface
        bool allowThrows() const override;
        StringRef name() const override;
        bool includeSuccessfulResults() const override;
        bool warnAboutMissingAssertions() const override;
        bool warnAboutUnmatchedTestSpecs() const override;
        bool zeroTestsCountAsSuccess() const override;
        ShowDurations showDurations() const override;
        double minDuration() const override;
        TestRunOrder runOrder() const override;
        uint32_t rngSeed() const override;
        unsigned int shardCount() const override;
        unsigned int shardIndex() const override;
        ColourMode defaultColourMode() const override;
        bool shouldDebugBreak() const override;
        int abortAfter() const override;
        bool showInvisibles() const override;
        Verbosity verbosity() const override;
        bool skipBenchmarks() const override;
        bool benchmarkNoAnalysis() const override;
        unsigned int benchmarkSamples() const override;
        double benchmarkConfidenceInterval() const override;
        unsigned int benchmarkResamples() const override;
        std::chrono::milliseconds benchmarkWarmupTime() const override;

    private:
        // Reads Bazel env vars and applies them to the config
        void readBazelEnvVars();

        ConfigData m_data;
        std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
        TestSpec m_testSpec;
        bool m_hasTestFilters = false;
    };
} // end namespace Catch

#endif // CATCH_CONFIG_HPP_INCLUDED


#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED

#include <cstdint>

namespace Catch {
    //! Returns Catch2's current RNG seed.
    std::uint32_t getSeed();
}

#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED


#ifndef CATCH_MESSAGE_HPP_INCLUDED
#define CATCH_MESSAGE_HPP_INCLUDED




/** \file
 * Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option
 *
 * CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros
 * by prepending CATCH_. This may not be desirable if the only clashes are with
 * logger macros such as INFO and WARN. In this cases
 * CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset
 * of relevant macros.
 *
 */

#ifndef CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED


#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_PREFIX_MESSAGES)
    #define CATCH_CONFIG_PREFIX_MESSAGES
#endif

#endif // CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED


#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED
#define CATCH_STREAM_END_STOP_HPP_INCLUDED


namespace Catch {

    // Use this in variadic streaming macros to allow
    //    << +StreamEndStop
    // as well as
    //    << stuff +StreamEndStop
    struct StreamEndStop {
        constexpr StringRef operator+() const { return StringRef(); }

        template <typename T>
        constexpr friend T const& operator+( T const& value, StreamEndStop ) {
            return value;
        }
    };

} // namespace Catch

#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED


#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED
#define CATCH_MESSAGE_INFO_HPP_INCLUDED



#ifndef CATCH_DEPRECATION_MACRO_HPP_INCLUDED
#define CATCH_DEPRECATION_MACRO_HPP_INCLUDED


#if !defined( CATCH_CONFIG_NO_DEPRECATION_ANNOTATIONS )
#    define DEPRECATED( msg ) [[deprecated( msg )]]
#else
#    define DEPRECATED( msg )
#endif

#endif // CATCH_DEPRECATION_MACRO_HPP_INCLUDED

#include <string>

namespace Catch {

    struct MessageInfo {
        MessageInfo(    StringRef _macroName,
                        SourceLineInfo const& _lineInfo,
                        ResultWas::OfType _type );

        StringRef macroName;
        std::string message;
        SourceLineInfo lineInfo;
        ResultWas::OfType type;
        unsigned int sequence;

        DEPRECATED( "Explicitly use the 'sequence' member instead" )
        bool operator == (MessageInfo const& other) const {
            return sequence == other.sequence;
        }
        DEPRECATED( "Explicitly use the 'sequence' member instead" )
        bool operator < (MessageInfo const& other) const {
            return sequence < other.sequence;
        }
    private:
        static unsigned int globalCount;
    };

} // end namespace Catch

#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED

#include <string>
#include <vector>

namespace Catch {

    struct SourceLineInfo;
    class IResultCapture;

    struct MessageStream {

        template<typename T>
        MessageStream& operator << ( T const& value ) {
            m_stream << value;
            return *this;
        }

        ReusableStringStream m_stream;
    };

    struct MessageBuilder : MessageStream {
        MessageBuilder( StringRef macroName,
                        SourceLineInfo const& lineInfo,
                        ResultWas::OfType type ):
            m_info(macroName, lineInfo, type) {}

        template<typename T>
        MessageBuilder&& operator << ( T const& value ) && {
            m_stream << value;
            return CATCH_MOVE(*this);
        }

        MessageInfo m_info;
    };

    class ScopedMessage {
    public:
        explicit ScopedMessage( MessageBuilder&& builder );
        ScopedMessage( ScopedMessage& duplicate ) = delete;
        ScopedMessage( ScopedMessage&& old ) noexcept;
        ~ScopedMessage();

        MessageInfo m_info;
        bool m_moved = false;
    };

    class Capturer {
        std::vector<MessageInfo> m_messages;
        IResultCapture& m_resultCapture;
        size_t m_captured = 0;
    public:
        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );

        Capturer(Capturer const&) = delete;
        Capturer& operator=(Capturer const&) = delete;

        ~Capturer();

        void captureValue( size_t index, std::string const& value );

        template<typename T>
        void captureValues( size_t index, T const& value ) {
            captureValue( index, Catch::Detail::stringify( value ) );
        }

        template<typename T, typename... Ts>
        void captureValues( size_t index, T const& value, Ts const&... values ) {
            captureValue( index, Catch::Detail::stringify(value) );
            captureValues( index+1, values... );
        }
    };

} // end namespace Catch

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
        catchAssertionHandler.complete(); \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
    Catch::Capturer varName( macroName##_catch_sr,        \
                             CATCH_INTERNAL_LINEINFO,     \
                             Catch::ResultWas::Info,      \
                             #__VA_ARGS__##_catch_sr );   \
    varName.captureValues( 0, __VA_ARGS__ )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_INFO( macroName, log ) \
    const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )


#if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)

  #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
  #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
  #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
  #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ )

#elif defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)

  #define CATCH_INFO( msg )          (void)(0)
  #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
  #define CATCH_WARN( msg )          (void)(0)
  #define CATCH_CAPTURE( ... )       (void)(0)

#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)

  #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
  #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
  #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
  #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )

#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)

  #define INFO( msg )          (void)(0)
  #define UNSCOPED_INFO( msg ) (void)(0)
  #define WARN( msg )          (void)(0)
  #define CAPTURE( ... )       (void)(0)

#endif // end of user facing macro declarations




#endif // CATCH_MESSAGE_HPP_INCLUDED


#ifndef CATCH_SECTION_INFO_HPP_INCLUDED
#define CATCH_SECTION_INFO_HPP_INCLUDED



#ifndef CATCH_TOTALS_HPP_INCLUDED
#define CATCH_TOTALS_HPP_INCLUDED

#include <cstdint>

namespace Catch {

    struct Counts {
        Counts operator - ( Counts const& other ) const;
        Counts& operator += ( Counts const& other );

        std::uint64_t total() const;
        bool allPassed() const;
        bool allOk() const;

        std::uint64_t passed = 0;
        std::uint64_t failed = 0;
        std::uint64_t failedButOk = 0;
        std::uint64_t skipped = 0;
    };

    struct Totals {

        Totals operator - ( Totals const& other ) const;
        Totals& operator += ( Totals const& other );

        Totals delta( Totals const& prevTotals ) const;

        Counts assertions;
        Counts testCases;
    };
}

#endif // CATCH_TOTALS_HPP_INCLUDED

#include <string>

namespace Catch {

    struct SectionInfo {
        // The last argument is ignored, so that people can write
        // SECTION("ShortName", "Proper description that is long") and
        // still use the `-c` flag comfortably.
        SectionInfo( SourceLineInfo const& _lineInfo, std::string _name,
                    const char* const = nullptr ):
            name(CATCH_MOVE(_name)),
            lineInfo(_lineInfo)
            {}

        std::string name;
        SourceLineInfo lineInfo;
    };

    struct SectionEndInfo {
        SectionInfo sectionInfo;
        Counts prevAssertions;
        double durationInSeconds;
    };

} // end namespace Catch

#endif // CATCH_SECTION_INFO_HPP_INCLUDED


#ifndef CATCH_SESSION_HPP_INCLUDED
#define CATCH_SESSION_HPP_INCLUDED



#ifndef CATCH_COMMANDLINE_HPP_INCLUDED
#define CATCH_COMMANDLINE_HPP_INCLUDED



#ifndef CATCH_CLARA_HPP_INCLUDED
#define CATCH_CLARA_HPP_INCLUDED

#if defined( __clang__ )
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wweak-vtables"
#    pragma clang diagnostic ignored "-Wshadow"
#    pragma clang diagnostic ignored "-Wdeprecated"
#endif

#if defined( __GNUC__ )
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wsign-conversion"
#endif

#ifndef CLARA_CONFIG_OPTIONAL_TYPE
#    ifdef __has_include
#        if __has_include( <optional>) && __cplusplus >= 201703L
#            include <optional>
#            define CLARA_CONFIG_OPTIONAL_TYPE std::optional
#        endif
#    endif
#endif


#include <cassert>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

namespace Catch {
    namespace Clara {

        class Args;
        class Parser;

        // enum of result types from a parse
        enum class ParseResultType {
            Matched,
            NoMatch,
            ShortCircuitAll,
            ShortCircuitSame
        };

        struct accept_many_t {};
        constexpr accept_many_t accept_many {};

        namespace Detail {
            struct fake_arg {
                template <typename T>
                operator T();
            };

            template <typename F, typename = void>
            static constexpr bool is_unary_function_v = false;

            template <typename F>
            static constexpr bool is_unary_function_v<
                F,
                Catch::Detail::void_t<decltype( std::declval<F>()(
                    fake_arg() ) )>> = true;

            // Traits for extracting arg and return type of lambdas (for single
            // argument lambdas)
            template <typename L>
            struct UnaryLambdaTraits
                : UnaryLambdaTraits<decltype( &L::operator() )> {};

            template <typename ClassT, typename ReturnT, typename... Args>
            struct UnaryLambdaTraits<ReturnT ( ClassT::* )( Args... ) const> {
                static const bool isValid = false;
            };

            template <typename ClassT, typename ReturnT, typename ArgT>
            struct UnaryLambdaTraits<ReturnT ( ClassT::* )( ArgT ) const> {
                static const bool isValid = true;
                using ArgType = std::remove_const_t<std::remove_reference_t<ArgT>>;
                using ReturnType = ReturnT;
            };

            class TokenStream;

            // Wraps a token coming from a token stream. These may not directly
            // correspond to strings as a single string may encode an option +
            // its argument if the : or = form is used
            enum class TokenType { Option, Argument };
            struct Token {
                TokenType type;
                StringRef token;
            };

            // Abstracts iterators into args as a stream of tokens, with option
            // arguments uniformly handled
            class TokenStream {
                using Iterator = std::vector<StringRef>::const_iterator;
                Iterator it;
                Iterator itEnd;
                std::vector<Token> m_tokenBuffer;
                void loadBuffer();

            public:
                explicit TokenStream( Args const& args );
                TokenStream( Iterator it, Iterator itEnd );

                explicit operator bool() const {
                    return !m_tokenBuffer.empty() || it != itEnd;
                }

                size_t count() const {
                    return m_tokenBuffer.size() + ( itEnd - it );
                }

                Token operator*() const {
                    assert( !m_tokenBuffer.empty() );
                    return m_tokenBuffer.front();
                }

                Token const* operator->() const {
                    assert( !m_tokenBuffer.empty() );
                    return &m_tokenBuffer.front();
                }

                TokenStream& operator++();
            };

            //! Denotes type of a parsing result
            enum class ResultType {
                Ok,          ///< No errors
                LogicError,  ///< Error in user-specified arguments for
                             ///< construction
                RuntimeError ///< Error in parsing inputs
            };

            class ResultBase {
            protected:
                ResultBase( ResultType type ): m_type( type ) {}
                virtual ~ResultBase(); // = default;


                ResultBase(ResultBase const&) = default;
                ResultBase& operator=(ResultBase const&) = default;
                ResultBase(ResultBase&&) = default;
                ResultBase& operator=(ResultBase&&) = default;

                virtual void enforceOk() const = 0;

                ResultType m_type;
            };

            template <typename T>
            class ResultValueBase : public ResultBase {
            public:
                T const& value() const& {
                    enforceOk();
                    return m_value;
                }
                T&& value() && {
                    enforceOk();
                    return CATCH_MOVE( m_value );
                }

            protected:
                ResultValueBase( ResultType type ): ResultBase( type ) {}

                ResultValueBase( ResultValueBase const& other ):
                    ResultBase( other ) {
                    if ( m_type == ResultType::Ok )
                        new ( &m_value ) T( other.m_value );
                }
                ResultValueBase( ResultValueBase&& other ):
                    ResultBase( other ) {
                    if ( m_type == ResultType::Ok )
                        new ( &m_value ) T( CATCH_MOVE(other.m_value) );
                }


                ResultValueBase( ResultType, T const& value ):
                    ResultBase( ResultType::Ok ) {
                    new ( &m_value ) T( value );
                }
                ResultValueBase( ResultType, T&& value ):
                    ResultBase( ResultType::Ok ) {
                    new ( &m_value ) T( CATCH_MOVE(value) );
                }

                ResultValueBase& operator=( ResultValueBase const& other ) {
                    if ( m_type == ResultType::Ok )
                        m_value.~T();
                    ResultBase::operator=( other );
                    if ( m_type == ResultType::Ok )
                        new ( &m_value ) T( other.m_value );
                    return *this;
                }
                ResultValueBase& operator=( ResultValueBase&& other ) {
                    if ( m_type == ResultType::Ok ) m_value.~T();
                    ResultBase::operator=( other );
                    if ( m_type == ResultType::Ok )
                        new ( &m_value ) T( CATCH_MOVE(other.m_value) );
                    return *this;
                }


                ~ResultValueBase() override {
                    if ( m_type == ResultType::Ok )
                        m_value.~T();
                }

                union {
                    T m_value;
                };
            };

            template <> class ResultValueBase<void> : public ResultBase {
            protected:
                using ResultBase::ResultBase;
            };

            template <typename T = void>
            class BasicResult : public ResultValueBase<T> {
            public:
                template <typename U>
                explicit BasicResult( BasicResult<U> const& other ):
                    ResultValueBase<T>( other.type() ),
                    m_errorMessage( other.errorMessage() ) {
                    assert( type() != ResultType::Ok );
                }

                template <typename U>
                static auto ok( U&& value ) -> BasicResult {
                    return { ResultType::Ok, CATCH_FORWARD(value) };
                }
                static auto ok() -> BasicResult { return { ResultType::Ok }; }
                static auto logicError( std::string&& message )
                    -> BasicResult {
                    return { ResultType::LogicError, CATCH_MOVE(message) };
                }
                static auto runtimeError( std::string&& message )
                    -> BasicResult {
                    return { ResultType::RuntimeError, CATCH_MOVE(message) };
                }

                explicit operator bool() const {
                    return m_type == ResultType::Ok;
                }
                auto type() const -> ResultType { return m_type; }
                auto errorMessage() const -> std::string const& {
                    return m_errorMessage;
                }

            protected:
                void enforceOk() const override {

                    // Errors shouldn't reach this point, but if they do
                    // the actual error message will be in m_errorMessage
                    assert( m_type != ResultType::LogicError );
                    assert( m_type != ResultType::RuntimeError );
                    if ( m_type != ResultType::Ok )
                        std::abort();
                }

                std::string
                    m_errorMessage; // Only populated if resultType is an error

                BasicResult( ResultType type,
                             std::string&& message ):
                    ResultValueBase<T>( type ), m_errorMessage( CATCH_MOVE(message) ) {
                    assert( m_type != ResultType::Ok );
                }

                using ResultValueBase<T>::ResultValueBase;
                using ResultBase::m_type;
            };

            class ParseState {
            public:
                ParseState( ParseResultType type,
                            TokenStream remainingTokens );

                ParseResultType type() const { return m_type; }
                TokenStream const& remainingTokens() const& {
                    return m_remainingTokens;
                }
                TokenStream&& remainingTokens() && {
                    return CATCH_MOVE( m_remainingTokens );
                }

            private:
                ParseResultType m_type;
                TokenStream m_remainingTokens;
            };

            using Result = BasicResult<void>;
            using ParserResult = BasicResult<ParseResultType>;
            using InternalParseResult = BasicResult<ParseState>;

            struct HelpColumns {
                std::string left;
                StringRef descriptions;
            };

            template <typename T>
            ParserResult convertInto( std::string const& source, T& target ) {
                std::stringstream ss( source );
                ss >> target;
                if ( ss.fail() ) {
                    return ParserResult::runtimeError(
                        "Unable to convert '" + source +
                        "' to destination type" );
                } else {
                    return ParserResult::ok( ParseResultType::Matched );
                }
            }
            ParserResult convertInto( std::string const& source,
                                      std::string& target );
            ParserResult convertInto( std::string const& source, bool& target );

#ifdef CLARA_CONFIG_OPTIONAL_TYPE
            template <typename T>
            auto convertInto( std::string const& source,
                              CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
                -> ParserResult {
                T temp;
                auto result = convertInto( source, temp );
                if ( result )
                    target = CATCH_MOVE( temp );
                return result;
            }
#endif // CLARA_CONFIG_OPTIONAL_TYPE

            struct BoundRef : Catch::Detail::NonCopyable {
                virtual ~BoundRef() = default;
                virtual bool isContainer() const;
                virtual bool isFlag() const;
            };
            struct BoundValueRefBase : BoundRef {
                virtual auto setValue( std::string const& arg )
                    -> ParserResult = 0;
            };
            struct BoundFlagRefBase : BoundRef {
                virtual auto setFlag( bool flag ) -> ParserResult = 0;
                bool isFlag() const override;
            };

            template <typename T> struct BoundValueRef : BoundValueRefBase {
                T& m_ref;

                explicit BoundValueRef( T& ref ): m_ref( ref ) {}

                ParserResult setValue( std::string const& arg ) override {
                    return convertInto( arg, m_ref );
                }
            };

            template <typename T>
            struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
                std::vector<T>& m_ref;

                explicit BoundValueRef( std::vector<T>& ref ): m_ref( ref ) {}

                auto isContainer() const -> bool override { return true; }

                auto setValue( std::string const& arg )
                    -> ParserResult override {
                    T temp;
                    auto result = convertInto( arg, temp );
                    if ( result )
                        m_ref.push_back( temp );
                    return result;
                }
            };

            struct BoundFlagRef : BoundFlagRefBase {
                bool& m_ref;

                explicit BoundFlagRef( bool& ref ): m_ref( ref ) {}

                ParserResult setFlag( bool flag ) override;
            };

            template <typename ReturnType> struct LambdaInvoker {
                static_assert(
                    std::is_same<ReturnType, ParserResult>::value,
                    "Lambda must return void or clara::ParserResult" );

                template <typename L, typename ArgType>
                static auto invoke( L const& lambda, ArgType const& arg )
                    -> ParserResult {
                    return lambda( arg );
                }
            };

            template <> struct LambdaInvoker<void> {
                template <typename L, typename ArgType>
                static auto invoke( L const& lambda, ArgType const& arg )
                    -> ParserResult {
                    lambda( arg );
                    return ParserResult::ok( ParseResultType::Matched );
                }
            };

            template <typename ArgType, typename L>
            auto invokeLambda( L const& lambda, std::string const& arg )
                -> ParserResult {
                ArgType temp{};
                auto result = convertInto( arg, temp );
                return !result ? result
                               : LambdaInvoker<typename UnaryLambdaTraits<
                                     L>::ReturnType>::invoke( lambda, temp );
            }

            template <typename L> struct BoundLambda : BoundValueRefBase {
                L m_lambda;

                static_assert(
                    UnaryLambdaTraits<L>::isValid,
                    "Supplied lambda must take exactly one argument" );
                explicit BoundLambda( L const& lambda ): m_lambda( lambda ) {}

                auto setValue( std::string const& arg )
                    -> ParserResult override {
                    return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
                        m_lambda, arg );
                }
            };

            template <typename L> struct BoundManyLambda : BoundLambda<L> {
                explicit BoundManyLambda( L const& lambda ): BoundLambda<L>( lambda ) {}
                bool isContainer() const override { return true; }
            };

            template <typename L> struct BoundFlagLambda : BoundFlagRefBase {
                L m_lambda;

                static_assert(
                    UnaryLambdaTraits<L>::isValid,
                    "Supplied lambda must take exactly one argument" );
                static_assert(
                    std::is_same<typename UnaryLambdaTraits<L>::ArgType,
                                 bool>::value,
                    "flags must be boolean" );

                explicit BoundFlagLambda( L const& lambda ):
                    m_lambda( lambda ) {}

                auto setFlag( bool flag ) -> ParserResult override {
                    return LambdaInvoker<typename UnaryLambdaTraits<
                        L>::ReturnType>::invoke( m_lambda, flag );
                }
            };

            enum class Optionality { Optional, Required };

            class ParserBase {
            public:
                virtual ~ParserBase() = default;
                virtual auto validate() const -> Result { return Result::ok(); }
                virtual auto parse( std::string const& exeName,
                                    TokenStream tokens ) const
                    -> InternalParseResult = 0;
                virtual size_t cardinality() const;

                InternalParseResult parse( Args const& args ) const;
            };

            template <typename DerivedT>
            class ComposableParserImpl : public ParserBase {
            public:
                template <typename T>
                auto operator|( T const& other ) const -> Parser;
            };

            // Common code and state for Args and Opts
            template <typename DerivedT>
            class ParserRefImpl : public ComposableParserImpl<DerivedT> {
            protected:
                Optionality m_optionality = Optionality::Optional;
                std::shared_ptr<BoundRef> m_ref;
                StringRef m_hint;
                StringRef m_description;

                explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
                    m_ref( ref ) {}

            public:
                template <typename LambdaT>
                ParserRefImpl( accept_many_t,
                               LambdaT const& ref,
                               StringRef hint ):
                    m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
                    m_hint( hint ) {}

                template <typename T,
                          typename = typename std::enable_if_t<
                              !Detail::is_unary_function_v<T>>>
                ParserRefImpl( T& ref, StringRef hint ):
                    m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
                    m_hint( hint ) {}

                template <typename LambdaT,
                          typename = typename std::enable_if_t<
                              Detail::is_unary_function_v<LambdaT>>>
                ParserRefImpl( LambdaT const& ref, StringRef hint ):
                    m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
                    m_hint( hint ) {}

                DerivedT& operator()( StringRef description ) & {
                    m_description = description;
                    return static_cast<DerivedT&>( *this );
                }
                DerivedT&& operator()( StringRef description ) && {
                    m_description = description;
                    return static_cast<DerivedT&&>( *this );
                }

                auto optional() -> DerivedT& {
                    m_optionality = Optionality::Optional;
                    return static_cast<DerivedT&>( *this );
                }

                auto required() -> DerivedT& {
                    m_optionality = Optionality::Required;
                    return static_cast<DerivedT&>( *this );
                }

                auto isOptional() const -> bool {
                    return m_optionality == Optionality::Optional;
                }

                auto cardinality() const -> size_t override {
                    if ( m_ref->isContainer() )
                        return 0;
                    else
                        return 1;
                }

                StringRef hint() const { return m_hint; }
            };

        } // namespace detail


        // A parser for arguments
        class Arg : public Detail::ParserRefImpl<Arg> {
        public:
            using ParserRefImpl::ParserRefImpl;
            using ParserBase::parse;

            Detail::InternalParseResult
                parse(std::string const&,
                      Detail::TokenStream tokens) const override;
        };

        // A parser for options
        class Opt : public Detail::ParserRefImpl<Opt> {
        protected:
            std::vector<StringRef> m_optNames;

        public:
            template <typename LambdaT>
            explicit Opt(LambdaT const& ref) :
                ParserRefImpl(
                    std::make_shared<Detail::BoundFlagLambda<LambdaT>>(ref)) {}

            explicit Opt(bool& ref);

            template <typename LambdaT,
                      typename = typename std::enable_if_t<
                          Detail::is_unary_function_v<LambdaT>>>
            Opt( LambdaT const& ref, StringRef hint ):
                ParserRefImpl( ref, hint ) {}

            template <typename LambdaT>
            Opt( accept_many_t, LambdaT const& ref, StringRef hint ):
                ParserRefImpl( accept_many, ref, hint ) {}

            template <typename T,
                      typename = typename std::enable_if_t<
                          !Detail::is_unary_function_v<T>>>
            Opt( T& ref, StringRef hint ):
                ParserRefImpl( ref, hint ) {}

            Opt& operator[]( StringRef optName ) & {
                m_optNames.push_back(optName);
                return *this;
            }
            Opt&& operator[]( StringRef optName ) && {
                m_optNames.push_back( optName );
                return CATCH_MOVE(*this);
            }

            Detail::HelpColumns getHelpColumns() const;

            bool isMatch(StringRef optToken) const;

            using ParserBase::parse;

            Detail::InternalParseResult
                parse(std::string const&,
                      Detail::TokenStream tokens) const override;

            Detail::Result validate() const override;
        };

        // Specifies the name of the executable
        class ExeName : public Detail::ComposableParserImpl<ExeName> {
            std::shared_ptr<std::string> m_name;
            std::shared_ptr<Detail::BoundValueRefBase> m_ref;

        public:
            ExeName();
            explicit ExeName(std::string& ref);

            template <typename LambdaT>
            explicit ExeName(LambdaT const& lambda) : ExeName() {
                m_ref = std::make_shared<Detail::BoundLambda<LambdaT>>(lambda);
            }

            // The exe name is not parsed out of the normal tokens, but is
            // handled specially
            Detail::InternalParseResult
                parse(std::string const&,
                      Detail::TokenStream tokens) const override;

            std::string const& name() const { return *m_name; }
            Detail::ParserResult set(std::string const& newName);
        };


        // A Combined parser
        class Parser : Detail::ParserBase {
            mutable ExeName m_exeName;
            std::vector<Opt> m_options;
            std::vector<Arg> m_args;

        public:

            auto operator|=(ExeName const& exeName) -> Parser& {
                m_exeName = exeName;
                return *this;
            }

            auto operator|=(Arg const& arg) -> Parser& {
                m_args.push_back(arg);
                return *this;
            }

            friend Parser& operator|=( Parser& p, Opt const& opt ) {
                p.m_options.push_back( opt );
                return p;
            }
            friend Parser& operator|=( Parser& p, Opt&& opt ) {
                p.m_options.push_back( CATCH_MOVE(opt) );
                return p;
            }

            Parser& operator|=(Parser const& other);

            template <typename T>
            friend Parser operator|( Parser const& p, T&& rhs ) {
                Parser temp( p );
                temp |= rhs;
                return temp;
            }

            template <typename T>
            friend Parser operator|( Parser&& p, T&& rhs ) {
                p |= CATCH_FORWARD(rhs);
                return CATCH_MOVE(p);
            }

            std::vector<Detail::HelpColumns> getHelpColumns() const;

            void writeToStream(std::ostream& os) const;

            friend auto operator<<(std::ostream& os, Parser const& parser)
                -> std::ostream& {
                parser.writeToStream(os);
                return os;
            }

            Detail::Result validate() const override;

            using ParserBase::parse;
            Detail::InternalParseResult
                parse(std::string const& exeName,
                      Detail::TokenStream tokens) const override;
        };

        /**
         * Wrapper over argc + argv, assumes that the inputs outlive it
         */
        class Args {
            friend Detail::TokenStream;
            StringRef m_exeName;
            std::vector<StringRef> m_args;

        public:
            Args(int argc, char const* const* argv);
            // Helper constructor for testing
            Args(std::initializer_list<StringRef> args);

            StringRef exeName() const { return m_exeName; }
        };


        // Convenience wrapper for option parser that specifies the help option
        struct Help : Opt {
            Help(bool& showHelpFlag);
        };

        // Result type for parser operation
        using Detail::ParserResult;

        namespace Detail {
            template <typename DerivedT>
            template <typename T>
            Parser
                ComposableParserImpl<DerivedT>::operator|(T const& other) const {
                return Parser() | static_cast<DerivedT const&>(*this) | other;
            }
        }

    } // namespace Clara
} // namespace Catch

#if defined( __clang__ )
#    pragma clang diagnostic pop
#endif

#if defined( __GNUC__ )
#    pragma GCC diagnostic pop
#endif

#endif // CATCH_CLARA_HPP_INCLUDED

namespace Catch {

    struct ConfigData;

    Clara::Parser makeCommandLineParser( ConfigData& config );

} // end namespace Catch

#endif // CATCH_COMMANDLINE_HPP_INCLUDED

namespace Catch {

    // TODO: Use C++17 `inline` variables
    constexpr int UnspecifiedErrorExitCode = 1;
    constexpr int NoTestsRunExitCode = 2;
    constexpr int UnmatchedTestSpecExitCode = 3;
    constexpr int AllTestsSkippedExitCode = 4;
    constexpr int InvalidTestSpecExitCode = 5;
    constexpr int TestFailureExitCode = 42;

    class Session : Detail::NonCopyable {
    public:

        Session();
        ~Session();

        void showHelp() const;
        void libIdentify();

        int applyCommandLine( int argc, char const * const * argv );
    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
        int applyCommandLine( int argc, wchar_t const * const * argv );
    #endif

        void useConfigData( ConfigData const& configData );

        template<typename CharT>
        int run(int argc, CharT const * const argv[]) {
            if (m_startupExceptions)
                return 1;
            int returnCode = applyCommandLine(argc, argv);
            if (returnCode == 0)
                returnCode = run();
            return returnCode;
        }

        int run();

        Clara::Parser const& cli() const;
        void cli( Clara::Parser const& newParser );
        ConfigData& configData();
        Config& config();
    private:
        int runInternal();

        Clara::Parser m_cli;
        ConfigData m_configData;
        Detail::unique_ptr<Config> m_config;
        bool m_startupExceptions = false;
    };

} // end namespace Catch

#endif // CATCH_SESSION_HPP_INCLUDED


#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
#define CATCH_TAG_ALIAS_HPP_INCLUDED


#include <string>

namespace Catch {

    struct TagAlias {
        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
            tag(_tag),
            lineInfo(_lineInfo)
        {}

        std::string tag;
        SourceLineInfo lineInfo;
    };

} // end namespace Catch

#endif // CATCH_TAG_ALIAS_HPP_INCLUDED


#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED


namespace Catch {

    struct RegistrarForTagAliases {
        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
    };

} // end namespace Catch

#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
    namespace{ const Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED


#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED

// We need this suppression to leak, because it took until GCC 10
// for the front end to handle local suppression via _Pragma properly
// inside templates (so `TEMPLATE_TEST_CASE` and co).
// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT**
#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10
#pragma GCC diagnostic ignored "-Wparentheses"
#endif




#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
#define CATCH_TEST_MACROS_HPP_INCLUDED



#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED



#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED



#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
#define CATCH_DECOMPOSER_HPP_INCLUDED



#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
#define CATCH_COMPARE_TRAITS_HPP_INCLUDED


#include <type_traits>

namespace Catch {
    namespace Detail {

#if defined( __GNUC__ ) && !defined( __clang__ )
#    pragma GCC diagnostic push
    // GCC likes to complain about comparing bool with 0, in the decltype()
    // that defines the comparable traits below.
#    pragma GCC diagnostic ignored "-Wbool-compare"
    // "ordered comparison of pointer with integer zero" same as above,
    // but it does not have a separate warning flag to suppress
#    pragma GCC diagnostic ignored "-Wextra"
    // Did you know that comparing floats with `0` directly
    // is super-duper dangerous in unevaluated context?
#    pragma GCC diagnostic ignored "-Wfloat-equal"
#endif

#if defined( __clang__ )
#    pragma clang diagnostic push
    // Did you know that comparing floats with `0` directly
    // is super-duper dangerous in unevaluated context?
#    pragma clang diagnostic ignored "-Wfloat-equal"
#endif

#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op )                               \
    template <typename, typename, typename = void>                            \
    struct is_##id##_comparable : std::false_type {};                         \
    template <typename T, typename U>                                         \
    struct is_##id##_comparable<                                              \
        T,                                                                    \
        U,                                                                    \
        void_t<decltype( std::declval<T>() op std::declval<U>() )>>           \
        : std::true_type {};                                                  \
    template <typename, typename = void>                                      \
    struct is_##id##_0_comparable : std::false_type {};                       \
    template <typename T>                                                     \
    struct is_##id##_0_comparable<T,                                          \
                                  void_t<decltype( std::declval<T>() op 0 )>> \
        : std::true_type {};

        // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
        CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
        CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
        CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
        CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
        CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
        CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )

#undef CATCH_DEFINE_COMPARABLE_TRAIT

#if defined( __GNUC__ ) && !defined( __clang__ )
#    pragma GCC diagnostic pop
#endif
#if defined( __clang__ )
#    pragma clang diagnostic pop
#endif


    } // namespace Detail
} // namespace Catch

#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED


#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED

#include <type_traits>

namespace Catch {
namespace Detail {

#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510

    using std::conjunction;
    using std::disjunction;
    using std::negation;

#else

    template <class...> struct conjunction : std::true_type {};
    template <class B1> struct conjunction<B1> : B1 {};
    template <class B1, class... Bn>
    struct conjunction<B1, Bn...>
        : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};

    template <class...> struct disjunction : std::false_type {};
    template <class B1> struct disjunction<B1> : B1 {};
    template <class B1, class... Bn>
    struct disjunction<B1, Bn...>
        : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};

    template <class B>
    struct negation : std::integral_constant<bool, !bool(B::value)> {};

#endif

} // namespace Detail
} // namespace Catch

#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED

#include <type_traits>
#include <iosfwd>

/** \file
 * Why does decomposing look the way it does:
 *
 * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into
 * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first,
 * and our custom operator is used for `a == b`, because `a` is transformed
 * into `ExprLhs<T&>` and then into `BinaryExpr<T&, U&>`.
 *
 * In practice, decomposing ends up a mess, because we have to support
 * various fun things.
 *
 * 1) Types that are only comparable with literal 0, and they do this by
 *    comparing against a magic type with pointer constructor and deleted
 *    other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++
 *
 * 2) Types that are only comparable with literal 0, and they do this by
 *    comparing against a magic type with consteval integer constructor.
 *    Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL.
 *
 * 3) Types that have no linkage, and so we cannot form a reference to
 *    them. Example: some implementations of traits.
 *
 * 4) Starting with C++20, when the compiler sees `a == b`, it also uses
 *    `b == a` when constructing the overload set. For us this means that
 *    when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
 *    the overload set for `b == ExprLhs<T>`.
 *
 * To accommodate these use cases, decomposer ended up rather complex.
 *
 * 1) These types are handled by adding SFINAE overloads to our comparison
 *    operators, checking whether `T == U` are comparable with the given
 *    operator, and if not, whether T (or U) are comparable with literal 0.
 *    If yes, the overload compares T (or U) with 0 literal inline in the
 *    definition.
 *
 *    Note that for extra correctness, we check  that the other type is
 *    either an `int` (literal 0 is captured as `int` by templates), or
 *    a `long` (some platforms use 0L for `NULL` and we want to support
 *    that for pointer comparisons).
 *
 * 2) For these types, `is_foo_comparable<T, int>` is true, but letting
 *    them fall into the overload that actually does `T == int` causes
 *    compilation error. Handling them requires that the decomposition
 *    is `constexpr`, so that P2564R3 applies and the `consteval` from
 *    their accompanying magic type is propagated through the `constexpr`
 *    call stack.
 *
 *    However this is not enough to handle these types automatically,
 *    because our default is to capture types by reference, to avoid
 *    runtime copies. While these references cannot become dangling,
 *    they outlive the constexpr context and thus the default capture
 *    path cannot be actually constexpr.
 *
 *    The solution is to capture these types by value, by explicitly
 *    specializing `Catch::capture_by_value` for them. Catch2 provides
 *    specialization for `std::foo_ordering`s, but users can specialize
 *    the trait for their own types as well.
 *
 * 3) If a type has no linkage, we also cannot capture it by reference.
 *    The solution is once again to capture them by value. We handle
 *    the common cases by using `std::is_arithmetic` as the default
 *    for `Catch::capture_by_value`, but that is only a some-effort
 *    heuristic. But as with 2), users can specialize `capture_by_value`
 *    for their own types as needed.
 *
 * 4) To support C++20 and make the SFINAE on our decomposing operators
 *    work, the SFINAE has to happen in return type, rather than in
 *    a template type. This is due to our use of logical type traits
 *    (`conjunction`/`disjunction`/`negation`), that we use to workaround
 *    an issue in older (9-) versions of GCC. I still blame C++20 for
 *    this, because without the comparison order switching, the logical
 *    traits could still be used in template type.
 *
 * There are also other side concerns, e.g. supporting both `REQUIRE(a)`
 * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot
 * nicely into the same expression handling logic, but these are rather
 * straightforward and add only a bit of complexity (e.g. common base
 * class for decomposed expressions).
 */

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
#pragma warning(disable:4018) // more "signed/unsigned mismatch"
#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
#pragma warning(disable:4180) // qualifier applied to function type has no meaning
#pragma warning(disable:4800) // Forcing result to true or false
#endif

#ifdef __clang__
#  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Wsign-compare"
#  pragma clang diagnostic ignored "-Wnon-virtual-dtor"
#elif defined __GNUC__
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wsign-compare"
#  pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
#endif

#if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
#  include <compare>
#    if defined( __cpp_lib_three_way_comparison ) && \
            __cpp_lib_three_way_comparison >= 201907L
#      define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS
#    endif
#endif

namespace Catch {

    namespace Detail {
        // This was added in C++20, but we require only C++14 for now.
        template <typename T>
        using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
    }

    // Note: There is nothing that stops us from extending this,
    //       e.g. to `std::is_scalar`, but the more encompassing
    //       traits are usually also more expensive. For now we
    //       keep this as it used to be and it can be changed later.
    template <typename T>
    struct capture_by_value
        : std::integral_constant<bool, std::is_arithmetic<T>{}> {};

#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
    template <>
    struct capture_by_value<std::strong_ordering> : std::true_type {};
    template <>
    struct capture_by_value<std::weak_ordering> : std::true_type {};
    template <>
    struct capture_by_value<std::partial_ordering> : std::true_type {};
#endif

    template <typename T>
    struct always_false : std::false_type {};

    class ITransientExpression {
        bool m_isBinaryExpression;
        bool m_result;

    protected:
        ~ITransientExpression() = default;

    public:
        constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
        constexpr auto getResult() const -> bool { return m_result; }
        //! This function **has** to be overridden by the derived class.
        virtual void streamReconstructedExpression( std::ostream& os ) const;

        constexpr ITransientExpression( bool isBinaryExpression, bool result )
        :   m_isBinaryExpression( isBinaryExpression ),
            m_result( result )
        {}

        constexpr ITransientExpression( ITransientExpression const& ) = default;
        constexpr ITransientExpression& operator=( ITransientExpression const& ) = default;

        friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
            expr.streamReconstructedExpression(out);
            return out;
        }
    };

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );

    template<typename LhsT, typename RhsT>
    class BinaryExpr  : public ITransientExpression {
        LhsT m_lhs;
        StringRef m_op;
        RhsT m_rhs;

        void streamReconstructedExpression( std::ostream &os ) const override {
            formatReconstructedExpression
                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
        }

    public:
        constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
        :   ITransientExpression{ true, comparisonResult },
            m_lhs( lhs ),
            m_op( op ),
            m_rhs( rhs )
        {}

        template<typename T>
        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }
    };

    template<typename LhsT>
    class UnaryExpr : public ITransientExpression {
        LhsT m_lhs;

        void streamReconstructedExpression( std::ostream &os ) const override {
            os << Catch::Detail::stringify( m_lhs );
        }

    public:
        explicit constexpr UnaryExpr( LhsT lhs )
        :   ITransientExpression{ false, static_cast<bool>(lhs) },
            m_lhs( lhs )
        {}
    };


    template<typename LhsT>
    class ExprLhs {
        LhsT m_lhs;
    public:
        explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}

#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op )           \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                Detail::negation<capture_by_value<             \
                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                capture_by_value<RhsT>>::value,                \
            BinaryExpr<LhsT, RhsT>> {                                          \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_eq_0_comparable<LhsT>,                              \
              /* We allow long because we want `ptr op NULL` to be accepted */ \
                Detail::disjunction<std::is_same<RhsT, int>,                   \
                                    std::is_same<RhsT, long>>>::value,         \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_eq_0_comparable<RhsT>,                              \
              /* We allow long because we want `ptr op NULL` to be accepted */ \
                Detail::disjunction<std::is_same<LhsT, int>,                   \
                                    std::is_same<LhsT, long>>>::value,         \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
    }

        CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
        CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )

    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR


#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op )         \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                Detail::negation<capture_by_value<             \
                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
                                capture_by_value<RhsT>>::value,                \
            BinaryExpr<LhsT, RhsT>> {                                          \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_##id##_0_comparable<LhsT>,                          \
                std::is_same<RhsT, int>>::value,                               \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
            Detail::conjunction<                                               \
                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
                Detail::is_##id##_0_comparable<RhsT>,                          \
                std::is_same<LhsT, int>>::value,                               \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
    }

        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )

    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR


#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op )                        \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
        -> std::enable_if_t<                                                   \
            !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value,             \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<capture_by_value<RhsT>::value,                     \
                            BinaryExpr<LhsT, RhsT>> {                          \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }

        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)

    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR

        template<typename RhsT>
        friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
            static_assert(always_false<RhsT>::value,
            "operator&& is not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename RhsT>
        friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
            static_assert(always_false<RhsT>::value,
            "operator|| is not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        constexpr auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
            return UnaryExpr<LhsT>{ m_lhs };
        }
    };

    struct Decomposer {
        template <typename T,
                  std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
                      int> = 0>
        constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
            return ExprLhs<const T&>{ lhs };
        }

        template <typename T,
                  std::enable_if_t<capture_by_value<T>::value, int> = 0>
        constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
            return ExprLhs<T>{ value };
        }
    };

} // end namespace Catch

#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef __clang__
#  pragma clang diagnostic pop
#elif defined __GNUC__
#  pragma GCC diagnostic pop
#endif

#endif // CATCH_DECOMPOSER_HPP_INCLUDED

#include <string>

namespace Catch {

    struct AssertionReaction {
        bool shouldDebugBreak = false;
        bool shouldThrow = false;
        bool shouldSkip = false;
    };

    class AssertionHandler {
        AssertionInfo m_assertionInfo;
        AssertionReaction m_reaction;
        bool m_completed = false;
        IResultCapture& m_resultCapture;

    public:
        AssertionHandler
            (   StringRef macroName,
                SourceLineInfo const& lineInfo,
                StringRef capturedExpression,
                ResultDisposition::Flags resultDisposition );
        ~AssertionHandler() {
            if ( !m_completed ) {
                m_resultCapture.handleIncomplete( m_assertionInfo );
            }
        }


        template<typename T>
        constexpr void handleExpr( ExprLhs<T> const& expr ) {
            handleExpr( expr.makeUnaryExpr() );
        }
        void handleExpr( ITransientExpression const& expr );

        void handleMessage(ResultWas::OfType resultType, std::string&& message);

        void handleExceptionThrownAsExpected();
        void handleUnexpectedExceptionNotThrown();
        void handleExceptionNotThrownAsExpected();
        void handleThrowingCallSkipped();
        void handleUnexpectedInflightException();

        void complete();

        // query
        auto allowThrows() const -> bool;
    };

    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );

} // namespace Catch

#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED


#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED


#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
#else
  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
#endif

#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED

// We need this suppression to leak, because it took until GCC 10
// for the front end to handle local suppression via _Pragma properly
#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9
  #pragma GCC diagnostic ignored "-Wparentheses"
#endif

#if !defined(CATCH_CONFIG_DISABLE)

#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

///////////////////////////////////////////////////////////////////////////////
// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
// macros.
#define INTERNAL_CATCH_TRY
#define INTERNAL_CATCH_CATCH( capturer )

#else // CATCH_CONFIG_FAST_COMPILE

#define INTERNAL_CATCH_TRY try
#define INTERNAL_CATCH_CATCH( handler ) catch(...) { (handler).handleUnexpectedInflightException(); }

#endif

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
    do { /* NOLINT(bugprone-infinite-loop) */ \
        /* The expression should not be evaluated, but warnings should hopefully be checked */ \
        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        INTERNAL_CATCH_TRY { \
            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        catchAssertionHandler.complete(); \
    } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
    if( Catch::getResultCapture().lastAssertionPassed() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
    if( !Catch::getResultCapture().lastAssertionPassed() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        try { \
            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
            static_cast<void>(__VA_ARGS__); \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
        } \
        catch( ... ) { \
            catchAssertionHandler.handleUnexpectedInflightException(); \
        } \
        catchAssertionHandler.complete(); \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(__VA_ARGS__); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        catchAssertionHandler.complete(); \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(expr); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleUnexpectedInflightException(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        catchAssertionHandler.complete(); \
    } while( false )



///////////////////////////////////////////////////////////////////////////////
// Although this is matcher-based, it can be used with just a string
#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(__VA_ARGS__); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        catchAssertionHandler.complete(); \
    } while( false )

#endif // CATCH_CONFIG_DISABLE

#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED


#ifndef CATCH_SECTION_HPP_INCLUDED
#define CATCH_SECTION_HPP_INCLUDED




/** \file
 * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option
 *
 * Some of Catch2's macros can be defined differently to work better with
 * static analysis tools, like clang-tidy or coverity.
 * Currently the main use case is to show that `SECTION`s are executed
 * exclusively, and not all in one run of a `TEST_CASE`.
 */

#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED


#if defined(__clang_analyzer__) || defined(__COVERITY__)
    #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
#endif

#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
    !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
    !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
#    define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
#endif


#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED


#ifndef CATCH_TIMER_HPP_INCLUDED
#define CATCH_TIMER_HPP_INCLUDED

#include <cstdint>

namespace Catch {

    class Timer {
        uint64_t m_nanoseconds = 0;
    public:
        void start();
        auto getElapsedNanoseconds() const -> uint64_t;
        auto getElapsedMicroseconds() const -> uint64_t;
        auto getElapsedMilliseconds() const -> unsigned int;
        auto getElapsedSeconds() const -> double;
    };

} // namespace Catch

#endif // CATCH_TIMER_HPP_INCLUDED

namespace Catch {

    class Section : Detail::NonCopyable {
    public:
        Section( SectionInfo&& info );
        Section( SourceLineInfo const& _lineInfo,
                 StringRef _name,
                 const char* const = nullptr );
        ~Section();

        // This indicates whether the section should be executed or not
        explicit operator bool() const;

    private:
        SectionInfo m_info;

        Counts m_assertions;
        bool m_sectionIncluded;
        Timer m_timer;
    };

} // end namespace Catch

#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
#    define INTERNAL_CATCH_SECTION( ... )                                 \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                         \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                  \
        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(            \
                 catch_internal_Section ) =                               \
                 Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                     \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                     \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS              \
        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(        \
                 catch_internal_Section ) =                           \
                 Catch::SectionInfo(                                  \
                     CATCH_INTERNAL_LINEINFO,                         \
                     ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
                         .str() ) )                                   \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#else

// These section definitions imply that at most one section at one level
// will be entered (because only one section's __LINE__ can be equal to
// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).

namespace Catch {
    namespace Detail {
        // Intentionally without linkage, as it should only be used as a dummy
        // symbol for static analysis.
        // The arguments are used as a dummy for checking warnings in the passed
        // expressions.
        int GetNewSectionHint( StringRef, const char* const = nullptr );
    } // namespace Detail
} // namespace Catch


#    define INTERNAL_CATCH_SECTION( ... )                                   \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
                 catchInternalSectionHint,                                  \
             catchInternalSectionHint =                                     \
                 Catch::Detail::GetNewSectionHint(__VA_ARGS__);             \
             catchInternalPreviousSectionHint == __LINE__ )                 \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                           \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
        if ( [[maybe_unused]] const int catchInternalPreviousSectionHint =  \
                 catchInternalSectionHint,                                  \
             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(   \
                ( Catch::ReusableStringStream() << __VA_ARGS__ ).str());    \
             catchInternalPreviousSectionHint == __LINE__ )                 \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#endif


#endif // CATCH_SECTION_HPP_INCLUDED


#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
#define CATCH_TEST_REGISTRY_HPP_INCLUDED



#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED

namespace Catch {

    class ITestInvoker {
    public:
        virtual void prepareTestCase();
        virtual void tearDownTestCase();
        virtual void invoke() const = 0;
        virtual ~ITestInvoker(); // = default
    };

} // namespace Catch

#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED


#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED

#define INTERNAL_CATCH_EXPAND1( param ) INTERNAL_CATCH_EXPAND2( param )
#define INTERNAL_CATCH_EXPAND2( ... ) INTERNAL_CATCH_NO##__VA_ARGS__
#define INTERNAL_CATCH_DEF( ... ) INTERNAL_CATCH_DEF __VA_ARGS__
#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF

#define INTERNAL_CATCH_REMOVE_PARENS( ... ) \
    INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ )

#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED

// GCC 5 and older do not properly handle disabling unused-variable warning
// with a _Pragma. This means that we have to leak the suppression to the
// user code as well :-(
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
#pragma GCC diagnostic ignored "-Wunused-variable"
#endif



namespace Catch {

template<typename C>
class TestInvokerAsMethod : public ITestInvoker {
    void (C::*m_testAsMethod)();
public:
    constexpr TestInvokerAsMethod( void ( C::*testAsMethod )() ) noexcept:
        m_testAsMethod( testAsMethod ) {}

    void invoke() const override {
        C obj;
        (obj.*m_testAsMethod)();
    }
};

Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() );

template<typename C>
Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
    return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
}

template <typename C>
class TestInvokerFixture : public ITestInvoker {
    void ( C::*m_testAsMethod )() const;
    Detail::unique_ptr<C> m_fixture = nullptr;

public:
    constexpr TestInvokerFixture( void ( C::*testAsMethod )() const ) noexcept:
        m_testAsMethod( testAsMethod ) {}

    void prepareTestCase() override {
        m_fixture = Detail::make_unique<C>();
    }

    void tearDownTestCase() override {
        m_fixture.reset();
    }

    void invoke() const override {
        auto* f = m_fixture.get();
        ( f->*m_testAsMethod )();
    }
};

template<typename C>
Detail::unique_ptr<ITestInvoker> makeTestInvokerFixture( void ( C::*testAsMethod )() const ) {
    return Detail::make_unique<TestInvokerFixture<C>>( testAsMethod );
}

struct NameAndTags {
    constexpr NameAndTags( StringRef name_ = StringRef(),
                           StringRef tags_ = StringRef() ) noexcept:
        name( name_ ), tags( tags_ ) {}
    StringRef name;
    StringRef tags;
};

struct AutoReg : Detail::NonCopyable {
    AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
};

} // end namespace Catch

#if defined(CATCH_CONFIG_DISABLE)
    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
        static inline void TestName()
    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
        namespace{                        \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                void test();              \
            };                            \
        }                                 \
        void TestName::test()
#endif


#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
        static void TestName(); \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( ... ) \
        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )

#else  // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT


// Dummy registrator for the dumy test case macros
namespace Catch {
    namespace Detail {
        struct DummyUse {
            DummyUse( void ( * )( int ), Catch::NameAndTags const& );
        };
    } // namespace Detail
} // namespace Catch

// Note that both the presence of the argument and its exact name are
// necessary for the section support.

// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE`
// tests can compile. The redefined `TEST_CASE` shadows this with param.
static int catchInternalSectionHint = 0;

#    define INTERNAL_CATCH_TESTCASE2( fname, ... )                         \
        static void fname( int );                                          \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                          \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                           \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                   \
        static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME(   \
            dummyUser )( &(fname), Catch::NameAndTags{ __VA_ARGS__ } );    \
        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                            \
        static void fname( [[maybe_unused]] int catchInternalSectionHint ) \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
#    define INTERNAL_CATCH_TESTCASE( ... ) \
        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ), __VA_ARGS__ )


#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace{ \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                void test(); \
            }; \
            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
            Catch::makeTestInvoker( &TestName::test ),                    \
            CATCH_INTERNAL_LINEINFO,                                      \
            #ClassName##_catch_sr,                                        \
            Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        void TestName::test()
    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( TestName, ClassName, ... )      \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                             \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                              \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                      \
        namespace {                                                           \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS( ClassName ) {     \
                void test() const;                                            \
            };                                                                \
            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
                Catch::makeTestInvokerFixture( &TestName::test ),                    \
                CATCH_INTERNAL_LINEINFO,                                      \
                #ClassName##_catch_sr,                                        \
                Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */             \
        }                                                                     \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                              \
        void TestName::test() const
    #define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( ClassName, ... )    \
        INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )


    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace {                                                           \
        const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
            Catch::makeTestInvoker( &QualifiedMethod ),                   \
            CATCH_INTERNAL_LINEINFO,                                      \
            "&" #QualifiedMethod##_catch_sr,                              \
            Catch::NameAndTags{ __VA_ARGS__ } );                          \
    } /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION


    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
        do { \
            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
            CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } while(false)


#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED


#ifndef CATCH_UNREACHABLE_HPP_INCLUDED
#define CATCH_UNREACHABLE_HPP_INCLUDED

/**\file
 * Polyfill `std::unreachable`
 *
 * We need something like `std::unreachable` to tell the compiler that
 * some macros, e.g. `FAIL` or `SKIP`, do not continue execution in normal
 * manner, and should handle it as such, e.g. not warn if there is no return
 * from non-void function after a `FAIL` or `SKIP`.
 */

#include <exception>

#if defined( __cpp_lib_unreachable ) && __cpp_lib_unreachable > 202202L
#    include <utility>
namespace Catch {
    namespace Detail {
        using Unreachable = std::unreachable;
    }
} // namespace Catch

#else // vv If we do not have std::unreachable, we implement something similar

namespace Catch {
    namespace Detail {

        [[noreturn]]
        inline void Unreachable() noexcept {
#    if defined( NDEBUG )
#        if defined( _MSC_VER ) && !defined( __clang__ )
            __assume( false );
#        elif defined( __GNUC__ )
            __builtin_unreachable();
#        endif
#    endif // ^^ NDEBUG
            std::terminate();
        }

    } // namespace Detail
} // end namespace Catch

#endif

#endif // CATCH_UNREACHABLE_HPP_INCLUDED


// All of our user-facing macros support configuration toggle, that
// forces them to be defined prefixed with CATCH_. We also like to
// support another toggle that can minimize (disable) their implementation.
// Given this, we have 4 different configuration options below

#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)

  #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
  #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )

  #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
  #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )

  #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
  #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
  #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
  #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )

  #define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
  #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )

  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
  #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
  #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
  #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
  #define CATCH_FAIL( ... ) do { \
           INTERNAL_CATCH_MSG("CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ );  \
           Catch::Detail::Unreachable(); \
         } while ( false )
  #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define CATCH_SKIP( ... ) do { \
           INTERNAL_CATCH_MSG( "CATCH_SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ ); \
           Catch::Detail::Unreachable(); \
         } while (false)


  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
    #define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
    #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
    #define CATCH_STATIC_CHECK( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
    #define CATCH_STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
  #else
    #define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
    #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
    #define CATCH_STATIC_CHECK( ... )       CATCH_CHECK( __VA_ARGS__ )
    #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_FALSE( __VA_ARGS__ )
  #endif


  // "BDD-style" convenience wrappers
  #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
  #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
  #define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
  #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
  #define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
  #define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
  #define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
  #define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )

#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled

  #define CATCH_REQUIRE( ... )        (void)(0)
  #define CATCH_REQUIRE_FALSE( ... )  (void)(0)

  #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
  #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
  #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)

  #define CATCH_CHECK( ... )         (void)(0)
  #define CATCH_CHECK_FALSE( ... )   (void)(0)
  #define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
  #define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
  #define CATCH_CHECK_NOFAIL( ... )  (void)(0)

  #define CATCH_CHECK_THROWS( ... )  (void)(0)
  #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
  #define CATCH_CHECK_NOTHROW( ... ) (void)(0)

  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define CATCH_METHOD_AS_TEST_CASE( method, ... )
  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
  #define CATCH_SECTION( ... )
  #define CATCH_DYNAMIC_SECTION( ... )
  #define CATCH_FAIL( ... ) (void)(0)
  #define CATCH_FAIL_CHECK( ... ) (void)(0)
  #define CATCH_SUCCEED( ... ) (void)(0)
  #define CATCH_SKIP( ... ) (void)(0)

  #define CATCH_STATIC_REQUIRE( ... )       (void)(0)
  #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
  #define CATCH_STATIC_CHECK( ... )       (void)(0)
  #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0)

  // "BDD-style" convenience wrappers
  #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
  #define CATCH_GIVEN( desc )
  #define CATCH_AND_GIVEN( desc )
  #define CATCH_WHEN( desc )
  #define CATCH_AND_WHEN( desc )
  #define CATCH_THEN( desc )
  #define CATCH_AND_THEN( desc )

#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented

  #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
  #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )

  #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
  #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
  #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )

  #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
  #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
  #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
  #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )

  #define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
  #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )

  #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
  #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
  #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
  #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
  #define FAIL( ... ) do { \
           INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ ); \
           Catch::Detail::Unreachable(); \
         } while (false)
  #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
  #define SKIP( ... ) do { \
           INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ ); \
           Catch::Detail::Unreachable(); \
         } while (false)


  #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
    #define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
    #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
    #define STATIC_CHECK( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
    #define STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
  #else
    #define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
    #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
    #define STATIC_CHECK( ... )       CHECK( __VA_ARGS__ )
    #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ )
  #endif

  // "BDD-style" convenience wrappers
  #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
  #define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
  #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
  #define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
  #define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
  #define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
  #define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )

#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled

  #define REQUIRE( ... )       (void)(0)
  #define REQUIRE_FALSE( ... ) (void)(0)

  #define REQUIRE_THROWS( ... ) (void)(0)
  #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
  #define REQUIRE_NOTHROW( ... ) (void)(0)

  #define CHECK( ... ) (void)(0)
  #define CHECK_FALSE( ... ) (void)(0)
  #define CHECKED_IF( ... ) if (__VA_ARGS__)
  #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
  #define CHECK_NOFAIL( ... ) (void)(0)

  #define CHECK_THROWS( ... )  (void)(0)
  #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
  #define CHECK_NOTHROW( ... ) (void)(0)

  #define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define METHOD_AS_TEST_CASE( method, ... )
  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
  #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
  #define SECTION( ... )
  #define DYNAMIC_SECTION( ... )
  #define FAIL( ... ) (void)(0)
  #define FAIL_CHECK( ... ) (void)(0)
  #define SUCCEED( ... ) (void)(0)
  #define SKIP( ... ) (void)(0)

  #define STATIC_REQUIRE( ... )       (void)(0)
  #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
  #define STATIC_CHECK( ... )       (void)(0)
  #define STATIC_CHECK_FALSE( ... ) (void)(0)

  // "BDD-style" convenience wrappers
  #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) )
  #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )

  #define GIVEN( desc )
  #define AND_GIVEN( desc )
  #define WHEN( desc )
  #define AND_WHEN( desc )
  #define THEN( desc )
  #define AND_THEN( desc )

#endif // ^^ unprefixed, disabled

// end of user facing macros

#endif // CATCH_TEST_MACROS_HPP_INCLUDED


#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED



#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED
#define CATCH_PREPROCESSOR_HPP_INCLUDED


#if defined(__GNUC__)
// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work
#pragma GCC system_header
#endif


namespace Catch {
    namespace Detail {
        template <int N>
        struct priority_tag : priority_tag<N - 1> {};
        template <>
        struct priority_tag<0> {};
    }
}

#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))

#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
// MSVC needs more evaluations
#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
#else
#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
#endif

#define CATCH_REC_END(...)
#define CATCH_REC_OUT

#define CATCH_EMPTY()
#define CATCH_DEFER(id) id CATCH_EMPTY()

#define CATCH_REC_GET_END2() 0, CATCH_REC_END
#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)

#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )

#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )

// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
// and passes userdata as the first parameter to each invocation,
// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
#else
// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
#endif

#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>(Catch::Detail::priority_tag<1>{}))
#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
#else
#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>(Catch::Detail::priority_tag<1>{})))
#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
#endif

#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)

#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)

#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N

#define INTERNAL_CATCH_TYPE_GEN\
    template<typename...> struct TypeList {};\
    template<typename... Ts>\
    constexpr auto get_wrapper(Catch::Detail::priority_tag<1>) noexcept -> TypeList<Ts...> { return {}; }\
    template<template<typename...> class...> struct TemplateTypeList{};\
    template<template<typename...> class...Cs>\
    constexpr auto get_wrapper(Catch::Detail::priority_tag<1>) noexcept -> TemplateTypeList<Cs...> { return {}; }\
    template<typename...>\
    struct append;\
    template<typename...>\
    struct rewrap;\
    template<template<typename...> class, typename...>\
    struct create;\
    template<template<typename...> class, typename>\
    struct convert;\
    \
    template<typename T> \
    struct append<T> { using type = T; };\
    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
    template< template<typename...> class L1, typename...E1, typename...Rest>\
    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
    \
    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
    \
    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };

#define INTERNAL_CATCH_NTTP_1(signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    constexpr auto get_wrapper(Catch::Detail::priority_tag<0>) noexcept -> Nttp<__VA_ARGS__> { return {}; } \
    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
    constexpr auto get_wrapper(Catch::Detail::priority_tag<0>) noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
    \
    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };

#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()
#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()
#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

#define INTERNAL_CATCH_TYPES_REGISTER(TestFunc)\
    template<typename... Ts>\
    void reg_test(TypeList<Ts...>, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Ts...>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
    }

#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature, ...)
#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
    }

#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
    template<typename Type>\
    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }

#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
    template<typename TestType> \
    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
        void test();\
    }

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
        void test();\
    }

#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
    template<typename TestType> \
    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_NTTP_0
#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_TYPES_REGISTER(TestFunc) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
#else
#define INTERNAL_CATCH_NTTP_0(signature)
#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_TYPES_REGISTER(TestFunc) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
#endif

#endif // CATCH_PREPROCESSOR_HPP_INCLUDED


// GCC 5 and older do not properly handle disabling unused-variable warning
// with a _Pragma. This means that we have to leak the suppression to the
// user code as well :-(
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
#pragma GCC diagnostic ignored "-Wunused-variable"
#endif

#if defined(CATCH_CONFIG_DISABLE)
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
        namespace{                                                                                  \
            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
        }                                                                                           \
        }                                                                                           \
        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
    #endif

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
    #endif

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
    #endif

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
    #endif
#endif


    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
            INTERNAL_CATCH_TYPE_GEN\
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types> \
            struct TestName{\
                TestName(){\
                    size_t index = 0;                                    \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
                    using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
            return 0;\
        }();\
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS       \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        template<typename TestType> static void TestFuncName();       \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
            INTERNAL_CATCH_TYPE_GEN                                                  \
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
            template<typename... Types>                               \
            struct TestName {                                         \
                void reg_tests() {                                          \
                    size_t index = 0;                                    \
                    using expander = size_t[];                           \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + types_list[index % num_types] + '>', Tags } ), index++)... };/* NOLINT */\
                }                                                     \
            };                                                        \
            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(Catch::Detail::priority_tag<1>{})), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
                TestInit t;                                           \
                t.reg_tests();                                        \
                return 0;                                             \
            }();                                                      \
        }                                                             \
        }                                                             \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
        template<typename TestType>                                   \
        static void TestFuncName()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T, __VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        template<typename TestType> static void TestFunc();       \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
        INTERNAL_CATCH_TYPE_GEN\
        template<typename... Types>                               \
        struct TestName {                                         \
            void reg_tests() {                                          \
                size_t index = 0;                                    \
                using expander = size_t[];                           \
                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
            }                                                     \
        };\
        static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
                using TestInit = typename convert<TestName, TmplList>::type; \
                TestInit t;                                           \
                t.reg_tests();                                        \
                return 0;                                             \
            }();                                                      \
        }}\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
        template<typename TestType>                                   \
        static void TestFunc()

    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )


    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
            INTERNAL_CATCH_TYPE_GEN\
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types> \
            struct TestNameClass{\
                TestNameClass(){\
                    size_t index = 0;                                    \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
                    using expander = size_t[];\
                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
                return 0;\
        }();\
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        template<typename TestType> \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
                void test();\
            };\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
            INTERNAL_CATCH_TYPE_GEN                  \
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types>\
            struct TestNameClass{\
                void reg_tests(){\
                    std::size_t index = 0;\
                    using expander = std::size_t[];\
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + types_list[index % num_types] + '>', Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>(Catch::Detail::priority_tag<1>{})), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
                TestInit t;\
                t.reg_tests();\
                return 0;\
            }(); \
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        template<typename TestType> \
        void TestName<TestType>::test()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        template<typename TestType> \
        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
            void test();\
        };\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
            INTERNAL_CATCH_TYPE_GEN\
            template<typename...Types>\
            struct TestNameClass{\
                void reg_tests(){\
                    size_t index = 0;\
                    using expander = size_t[];\
                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                using TestInit = typename convert<TestNameClass, TmplList>::type;\
                TestInit t;\
                t.reg_tests();\
                return 0;\
            }(); \
        }}\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        template<typename TestType> \
        void TestName<TestType>::test()

#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )


#endif // CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED


#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)

  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #else
    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
  #endif

#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)

  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
  #else
    #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
    #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
    #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
    #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
  #endif

  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
  #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )

#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)

  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #else
    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
    #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
    #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
    #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
    #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
    #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
  #endif

#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)

  #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
  #else
    #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
    #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
    #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
    #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
  #endif

  // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
  #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
  #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define TEMPLATE_LIST_TEST_CASE( ... ) TEMPLATE_TEST_CASE(__VA_ARGS__)
  #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )

#endif // end of user facing macro declarations


#endif // CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED


#ifndef CATCH_TEST_CASE_INFO_HPP_INCLUDED
#define CATCH_TEST_CASE_INFO_HPP_INCLUDED



#include <cstdint>
#include <string>
#include <vector>

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#endif

namespace Catch {

    /**
     * A **view** of a tag string that provides case insensitive comparisons
     *
     * Note that in Catch2 internals, the square brackets around tags are
     * not a part of tag's representation, so e.g. "[cool-tag]" is represented
     * as "cool-tag" internally.
     */
    struct Tag {
        constexpr Tag(StringRef original_):
            original(original_)
        {}
        StringRef original;

        friend bool operator< ( Tag const& lhs, Tag const& rhs );
        friend bool operator==( Tag const& lhs, Tag const& rhs );
    };

    class ITestInvoker;
    struct NameAndTags;

    enum class TestCaseProperties : uint8_t {
        None = 0,
        IsHidden = 1 << 1,
        ShouldFail = 1 << 2,
        MayFail = 1 << 3,
        Throws = 1 << 4,
        NonPortable = 1 << 5,
        Benchmark = 1 << 6
    };

    /**
     * Various metadata about the test case.
     *
     * A test case is uniquely identified by its (class)name and tags
     * combination, with source location being ignored, and other properties
     * being determined from tags.
     *
     * Tags are kept sorted.
     */
    struct TestCaseInfo : Detail::NonCopyable {

        TestCaseInfo(StringRef _className,
                     NameAndTags const& _nameAndTags,
                     SourceLineInfo const& _lineInfo);

        bool isHidden() const;
        bool throws() const;
        bool okToFail() const;
        bool expectedToFail() const;

        // Adds the tag(s) with test's filename (for the -# flag)
        void addFilenameTag();

        //! Orders by name, classname and tags
        friend bool operator<( TestCaseInfo const& lhs,
                               TestCaseInfo const& rhs );


        std::string tagsAsString() const;

        std::string name;
        StringRef className;
    private:
        std::string backingTags;
        // Internally we copy tags to the backing storage and then add
        // refs to this storage to the tags vector.
        void internalAppendTag(StringRef tagString);
    public:
        std::vector<Tag> tags;
        SourceLineInfo lineInfo;
        TestCaseProperties properties = TestCaseProperties::None;
    };

    /**
     * Wrapper over the test case information and the test case invoker
     *
     * Does not own either, and is specifically made to be cheap
     * to copy around.
     */
    class TestCaseHandle {
        TestCaseInfo* m_info;
        ITestInvoker* m_invoker;
    public:
        constexpr TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
            m_info(info), m_invoker(invoker) {}

        void prepareTestCase() const {
            m_invoker->prepareTestCase();
        }

        void tearDownTestCase() const {
            m_invoker->tearDownTestCase();
        }

        void invoke() const {
            m_invoker->invoke();
        }

        constexpr TestCaseInfo const& getTestCaseInfo() const {
            return *m_info;
        }
    };

    Detail::unique_ptr<TestCaseInfo>
    makeTestCaseInfo( StringRef className,
                      NameAndTags const& nameAndTags,
                      SourceLineInfo const& lineInfo );
}

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#endif // CATCH_TEST_CASE_INFO_HPP_INCLUDED


#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
#define CATCH_TEST_RUN_INFO_HPP_INCLUDED


namespace Catch {

    struct TestRunInfo {
        constexpr TestRunInfo(StringRef _name) : name(_name) {}
        StringRef name;
    };

} // end namespace Catch

#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED


#ifndef CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED



#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED


#include <string>
#include <vector>

namespace Catch {
    using exceptionTranslateFunction = std::string(*)();

    class IExceptionTranslator;
    using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;

    class IExceptionTranslator {
    public:
        virtual ~IExceptionTranslator(); // = default
        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
    };

    class IExceptionTranslatorRegistry {
    public:
        virtual ~IExceptionTranslatorRegistry(); // = default
        virtual std::string translateActiveException() const = 0;
    };

} // namespace Catch

#endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED

#include <exception>

namespace Catch {
    namespace Detail {
        void registerTranslatorImpl(
            Detail::unique_ptr<IExceptionTranslator>&& translator );
    }

    class ExceptionTranslatorRegistrar {
        template<typename T>
        class ExceptionTranslator : public IExceptionTranslator {
        public:

            constexpr ExceptionTranslator( std::string(*translateFunction)( T const& ) )
            : m_translateFunction( translateFunction )
            {}

            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
                try {
                    if( it == itEnd )
                        std::rethrow_exception(std::current_exception());
                    else
                        return (*it)->translate( it+1, itEnd );
                }
                catch( T const& ex ) {
                    return m_translateFunction( ex );
                }
#else
                return "You should never get here!";
#endif
            }

        protected:
            std::string(*m_translateFunction)( T const& );
        };

    public:
        template<typename T>
        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
            Detail::registerTranslatorImpl(
                Detail::make_unique<ExceptionTranslator<T>>(
                    translateFunction ) );
        }
    };

} // namespace Catch

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
    static std::string translatorName( signature ); \
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
    namespace{ const Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
    static std::string translatorName( signature )

#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )

#if defined(CATCH_CONFIG_DISABLE)
    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
            static std::string translatorName( signature )
#endif


// This macro is always prefixed
#if !defined(CATCH_CONFIG_DISABLE)
#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
#else
#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
#endif


#endif // CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED


#ifndef CATCH_VERSION_HPP_INCLUDED
#define CATCH_VERSION_HPP_INCLUDED

#include <iosfwd>

namespace Catch {

    // Versioning information
    struct Version {
        Version( Version const& ) = delete;
        Version& operator=( Version const& ) = delete;
        Version(    unsigned int _majorVersion,
                    unsigned int _minorVersion,
                    unsigned int _patchNumber,
                    char const * const _branchName,
                    unsigned int _buildNumber );

        unsigned int const majorVersion;
        unsigned int const minorVersion;
        unsigned int const patchNumber;

        // buildNumber is only used if branchName is not null
        char const * const branchName;
        unsigned int const buildNumber;

        friend std::ostream& operator << ( std::ostream& os, Version const& version );
    };

    Version const& libraryVersion();
}

#endif // CATCH_VERSION_HPP_INCLUDED


#ifndef CATCH_VERSION_MACROS_HPP_INCLUDED
#define CATCH_VERSION_MACROS_HPP_INCLUDED

#define CATCH_VERSION_MAJOR 3
#define CATCH_VERSION_MINOR 9
#define CATCH_VERSION_PATCH 0

#endif // CATCH_VERSION_MACROS_HPP_INCLUDED


/** \file
 * This is a convenience header for Catch2's Generator support. It includes
 * **all** of Catch2 headers related to generators.
 *
 * Generally the Catch2 users should use specific includes they need,
 * but this header can be used instead for ease-of-experimentation, or
 * just plain convenience, at the cost of (significantly) increased
 * compilation times.
 *
 * When a new header is added to either the `generators` folder,
 * or to the corresponding internal subfolder, it should be added here.
 */

#ifndef CATCH_GENERATORS_ALL_HPP_INCLUDED
#define CATCH_GENERATORS_ALL_HPP_INCLUDED



#ifndef CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED

#include <exception>

namespace Catch {

    // Exception type to be thrown when a Generator runs into an error,
    // e.g. it cannot initialize the first return value based on
    // runtime information
    class GeneratorException : public std::exception {
        const char* const m_msg = "";

    public:
        GeneratorException(const char* msg):
            m_msg(msg)
        {}

        const char* what() const noexcept final;
    };

} // end namespace Catch

#endif // CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED


#ifndef CATCH_GENERATORS_HPP_INCLUDED
#define CATCH_GENERATORS_HPP_INCLUDED



#ifndef CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED


#include <string>

namespace Catch {

    namespace Generators {
        class GeneratorUntypedBase {
            // Caches result from `toStringImpl`, assume that when it is an
            // empty string, the cache is invalidated.
            mutable std::string m_stringReprCache;

            // Counts based on `next` returning true
            std::size_t m_currentElementIndex = 0;

            /**
             * Attempts to move the generator to the next element
             *
             * Returns true iff the move succeeded (and a valid element
             * can be retrieved).
             */
            virtual bool next() = 0;

            //! Customization point for `currentElementAsString`
            virtual std::string stringifyImpl() const = 0;

        public:
            GeneratorUntypedBase() = default;
            // Generation of copy ops is deprecated (and Clang will complain)
            // if there is a user destructor defined
            GeneratorUntypedBase(GeneratorUntypedBase const&) = default;
            GeneratorUntypedBase& operator=(GeneratorUntypedBase const&) = default;

            virtual ~GeneratorUntypedBase(); // = default;

            /**
             * Attempts to move the generator to the next element
             *
             * Serves as a non-virtual interface to `next`, so that the
             * top level interface can provide sanity checking and shared
             * features.
             *
             * As with `next`, returns true iff the move succeeded and
             * the generator has new valid element to provide.
             */
            bool countedNext();

            std::size_t currentElementIndex() const { return m_currentElementIndex; }

            /**
             * Returns generator's current element as user-friendly string.
             *
             * By default returns string equivalent to calling
             * `Catch::Detail::stringify` on the current element, but generators
             * can customize their implementation as needed.
             *
             * Not thread-safe due to internal caching.
             *
             * The returned ref is valid only until the generator instance
             * is destructed, or it moves onto the next element, whichever
             * comes first.
             */
            StringRef currentElementAsString() const;
        };
        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;

    } // namespace Generators

    class IGeneratorTracker {
    public:
        virtual ~IGeneratorTracker(); // = default;
        virtual auto hasGenerator() const -> bool = 0;
        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
    };

} // namespace Catch

#endif // CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED

#include <vector>
#include <tuple>

namespace Catch {

namespace Generators {

namespace Detail {

    //! Throws GeneratorException with the provided message
    [[noreturn]]
    void throw_generator_exception(char const * msg);

} // end namespace detail

    template<typename T>
    class IGenerator : public GeneratorUntypedBase {
        std::string stringifyImpl() const override {
            return ::Catch::Detail::stringify( get() );
        }

    public:
        // Returns the current element of the generator
        //
        // \Precondition The generator is either freshly constructed,
        // or the last call to `next()` returned true
        virtual T const& get() const = 0;
        using type = T;
    };

    template <typename T>
    using GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>;

    template <typename T>
    class GeneratorWrapper final {
        GeneratorPtr<T> m_generator;
    public:
        //! Takes ownership of the passed pointer.
        GeneratorWrapper(IGenerator<T>* generator):
            m_generator(generator) {}
        GeneratorWrapper(GeneratorPtr<T> generator):
            m_generator(CATCH_MOVE(generator)) {}

        T const& get() const {
            return m_generator->get();
        }
        bool next() {
            return m_generator->countedNext();
        }
    };


    template<typename T>
    class SingleValueGenerator final : public IGenerator<T> {
        T m_value;
    public:
        SingleValueGenerator(T const& value) :
            m_value(value)
        {}
        SingleValueGenerator(T&& value):
            m_value(CATCH_MOVE(value))
        {}

        T const& get() const override {
            return m_value;
        }
        bool next() override {
            return false;
        }
    };

    template<typename T>
    class FixedValuesGenerator final : public IGenerator<T> {
        static_assert(!std::is_same<T, bool>::value,
            "FixedValuesGenerator does not support bools because of std::vector<bool>"
            "specialization, use SingleValue Generator instead.");
        std::vector<T> m_values;
        size_t m_idx = 0;
    public:
        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}

        T const& get() const override {
            return m_values[m_idx];
        }
        bool next() override {
            ++m_idx;
            return m_idx < m_values.size();
        }
    };

    template <typename T, typename DecayedT = std::decay_t<T>>
    GeneratorWrapper<DecayedT> value( T&& value ) {
        return GeneratorWrapper<DecayedT>(
            Catch::Detail::make_unique<SingleValueGenerator<DecayedT>>(
                CATCH_FORWARD( value ) ) );
    }
    template <typename T>
    GeneratorWrapper<T> values(std::initializer_list<T> values) {
        return GeneratorWrapper<T>(Catch::Detail::make_unique<FixedValuesGenerator<T>>(values));
    }

    template<typename T>
    class Generators : public IGenerator<T> {
        std::vector<GeneratorWrapper<T>> m_generators;
        size_t m_current = 0;

        void add_generator( GeneratorWrapper<T>&& generator ) {
            m_generators.emplace_back( CATCH_MOVE( generator ) );
        }
        void add_generator( T const& val ) {
            m_generators.emplace_back( value( val ) );
        }
        void add_generator( T&& val ) {
            m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
        }
        template <typename U>
        std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
        add_generator( U&& val ) {
            add_generator( T( CATCH_FORWARD( val ) ) );
        }

        template <typename U> void add_generators( U&& valueOrGenerator ) {
            add_generator( CATCH_FORWARD( valueOrGenerator ) );
        }

        template <typename U, typename... Gs>
        void add_generators( U&& valueOrGenerator, Gs&&... moreGenerators ) {
            add_generator( CATCH_FORWARD( valueOrGenerator ) );
            add_generators( CATCH_FORWARD( moreGenerators )... );
        }

    public:
        template <typename... Gs>
        Generators(Gs &&... moreGenerators) {
            m_generators.reserve(sizeof...(Gs));
            add_generators(CATCH_FORWARD(moreGenerators)...);
        }

        T const& get() const override {
            return m_generators[m_current].get();
        }

        bool next() override {
            if (m_current >= m_generators.size()) {
                return false;
            }
            const bool current_status = m_generators[m_current].next();
            if (!current_status) {
                ++m_current;
            }
            return m_current < m_generators.size();
        }
    };


    template <typename... Ts>
    GeneratorWrapper<std::tuple<std::decay_t<Ts>...>>
    table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
        return values<std::tuple<Ts...>>( tuples );
    }

    // Tag type to signal that a generator sequence should convert arguments to a specific type
    template <typename T>
    struct as {};

    template<typename T, typename... Gs>
    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
        return Generators<T>(CATCH_MOVE(generator), CATCH_FORWARD(moreGenerators)...);
    }
    template<typename T>
    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
        return Generators<T>(CATCH_MOVE(generator));
    }
    template<typename T, typename... Gs>
    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<std::decay_t<T>> {
        return makeGenerators( value( CATCH_FORWARD( val ) ), CATCH_FORWARD( moreGenerators )... );
    }
    template<typename T, typename U, typename... Gs>
    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
        return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
    }

    IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
                                                SourceLineInfo const& lineInfo );
    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
                                               SourceLineInfo lineInfo,
                                               GeneratorBasePtr&& generator );

    template<typename L>
    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
        using UnderlyingType = typename decltype(generatorExpression())::type;

        IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
        // Creation of tracker is delayed after generator creation, so
        // that constructing generator can fail without breaking everything.
        if (!tracker) {
            tracker = createGeneratorTracker(
                generatorName,
                lineInfo,
                Catch::Detail::make_unique<Generators<UnderlyingType>>(
                    generatorExpression() ) );
        }

        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
        return generator.get();
    }

} // namespace Generators
} // namespace Catch

#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)

#define GENERATE( ... ) \
    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_COPY( ... ) \
    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_REF( ... ) \
    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)

#endif // CATCH_GENERATORS_HPP_INCLUDED


#ifndef CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED


#include <cassert>

namespace Catch {
namespace Generators {

    template <typename T>
    class TakeGenerator final : public IGenerator<T> {
        GeneratorWrapper<T> m_generator;
        size_t m_returned = 0;
        size_t m_target;
    public:
        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
            m_generator(CATCH_MOVE(generator)),
            m_target(target)
        {
            assert(target != 0 && "Empty generators are not allowed");
        }
        T const& get() const override {
            return m_generator.get();
        }
        bool next() override {
            ++m_returned;
            if (m_returned >= m_target) {
                return false;
            }

            const auto success = m_generator.next();
            // If the underlying generator does not contain enough values
            // then we cut short as well
            if (!success) {
                m_returned = m_target;
            }
            return success;
        }
    };

    template <typename T>
    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<T>(Catch::Detail::make_unique<TakeGenerator<T>>(target, CATCH_MOVE(generator)));
    }


    template <typename T, typename Predicate>
    class FilterGenerator final : public IGenerator<T> {
        GeneratorWrapper<T> m_generator;
        Predicate m_predicate;
    public:
        template <typename P = Predicate>
        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
            m_generator(CATCH_MOVE(generator)),
            m_predicate(CATCH_FORWARD(pred))
        {
            if (!m_predicate(m_generator.get())) {
                // It might happen that there are no values that pass the
                // filter. In that case we throw an exception.
                auto has_initial_value = next();
                if (!has_initial_value) {
                    Detail::throw_generator_exception("No valid value found in filtered generator");
                }
            }
        }

        T const& get() const override {
            return m_generator.get();
        }

        bool next() override {
            bool success = m_generator.next();
            if (!success) {
                return false;
            }
            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
            return success;
        }
    };


    template <typename T, typename Predicate>
    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
    }

    template <typename T>
    class RepeatGenerator final : public IGenerator<T> {
        static_assert(!std::is_same<T, bool>::value,
            "RepeatGenerator currently does not support bools"
            "because of std::vector<bool> specialization");
        GeneratorWrapper<T> m_generator;
        mutable std::vector<T> m_returned;
        size_t m_target_repeats;
        size_t m_current_repeat = 0;
        size_t m_repeat_index = 0;
    public:
        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
            m_generator(CATCH_MOVE(generator)),
            m_target_repeats(repeats)
        {
            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
        }

        T const& get() const override {
            if (m_current_repeat == 0) {
                m_returned.push_back(m_generator.get());
                return m_returned.back();
            }
            return m_returned[m_repeat_index];
        }

        bool next() override {
            // There are 2 basic cases:
            // 1) We are still reading the generator
            // 2) We are reading our own cache

            // In the first case, we need to poke the underlying generator.
            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
            if (m_current_repeat == 0) {
                const auto success = m_generator.next();
                if (!success) {
                    ++m_current_repeat;
                }
                return m_current_repeat < m_target_repeats;
            }

            // In the second case, we need to move indices forward and check that we haven't run up against the end
            ++m_repeat_index;
            if (m_repeat_index == m_returned.size()) {
                m_repeat_index = 0;
                ++m_current_repeat;
            }
            return m_current_repeat < m_target_repeats;
        }
    };

    template <typename T>
    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<T>(Catch::Detail::make_unique<RepeatGenerator<T>>(repeats, CATCH_MOVE(generator)));
    }

    template <typename T, typename U, typename Func>
    class MapGenerator final : public IGenerator<T> {
        // TBD: provide static assert for mapping function, for friendly error message
        GeneratorWrapper<U> m_generator;
        Func m_function;
        // To avoid returning dangling reference, we have to save the values
        T m_cache;
    public:
        template <typename F2 = Func>
        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
            m_generator(CATCH_MOVE(generator)),
            m_function(CATCH_FORWARD(function)),
            m_cache(m_function(m_generator.get()))
        {}

        T const& get() const override {
            return m_cache;
        }
        bool next() override {
            const auto success = m_generator.next();
            if (success) {
                m_cache = m_function(m_generator.get());
            }
            return success;
        }
    };

    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
        return GeneratorWrapper<T>(
            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
        );
    }

    template <typename T, typename U, typename Func>
    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
        return GeneratorWrapper<T>(
            Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
        );
    }

    template <typename T>
    class ChunkGenerator final : public IGenerator<std::vector<T>> {
        std::vector<T> m_chunk;
        size_t m_chunk_size;
        GeneratorWrapper<T> m_generator;
        bool m_used_up = false;
    public:
        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
            m_chunk_size(size), m_generator(CATCH_MOVE(generator))
        {
            m_chunk.reserve(m_chunk_size);
            if (m_chunk_size != 0) {
                m_chunk.push_back(m_generator.get());
                for (size_t i = 1; i < m_chunk_size; ++i) {
                    if (!m_generator.next()) {
                        Detail::throw_generator_exception("Not enough values to initialize the first chunk");
                    }
                    m_chunk.push_back(m_generator.get());
                }
            }
        }
        std::vector<T> const& get() const override {
            return m_chunk;
        }
        bool next() override {
            m_chunk.clear();
            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
                if (!m_generator.next()) {
                    return false;
                }
                m_chunk.push_back(m_generator.get());
            }
            return true;
        }
    };

    template <typename T>
    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<std::vector<T>>(
            Catch::Detail::make_unique<ChunkGenerator<T>>(size, CATCH_MOVE(generator))
        );
    }

} // namespace Generators
} // namespace Catch


#endif // CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED


#ifndef CATCH_GENERATORS_RANDOM_HPP_INCLUDED
#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED



#ifndef CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED

#include <cstdint>

namespace Catch {

    // This is a simple implementation of C++11 Uniform Random Number
    // Generator. It does not provide all operators, because Catch2
    // does not use it, but it should behave as expected inside stdlib's
    // distributions.
    // The implementation is based on the PCG family (http://pcg-random.org)
    class SimplePcg32 {
        using state_type = std::uint64_t;
    public:
        using result_type = std::uint32_t;
        static constexpr result_type (min)() {
            return 0;
        }
        static constexpr result_type (max)() {
            return static_cast<result_type>(-1);
        }

        // Provide some default initial state for the default constructor
        SimplePcg32():SimplePcg32(0xed743cc4U) {}

        explicit SimplePcg32(result_type seed_);

        void seed(result_type seed_);
        void discard(uint64_t skip);

        result_type operator()();

    private:
        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);

        // In theory we also need operator<< and operator>>
        // In practice we do not use them, so we will skip them for now


        std::uint64_t m_state;
        // This part of the state determines which "stream" of the numbers
        // is chosen -- we take it as a constant for Catch2, so we only
        // need to deal with seeding the main state.
        // Picked by reading 8 bytes from `/dev/random` :-)
        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
    };

} // end namespace Catch

#endif // CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED



#ifndef CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
#define CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED




#ifndef CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
#define CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED

#include <climits>
#include <cstddef>
#include <cstdint>
#include <type_traits>

// Note: We use the usual enable-disable-autodetect dance here even though
//       we do not support these in CMake configuration options (yet?).
//       It is highly unlikely that we will need to make these actually
//       user-configurable, but this will make it simpler if weend up needing
//       it, and it provides an escape hatch to the users who need it.
#if defined( __SIZEOF_INT128__ )
#    define CATCH_CONFIG_INTERNAL_UINT128
// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
// Currently we do not bother doing this ourselves, but we could if it became
// important for perf.
#elif defined( _MSC_VER ) && defined( _M_X64 )
#    define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
#endif

#if defined( CATCH_CONFIG_INTERNAL_UINT128 ) && \
    !defined( CATCH_CONFIG_NO_UINT128 ) &&      \
    !defined( CATCH_CONFIG_UINT128 )
#define CATCH_CONFIG_UINT128
#endif

#if defined( CATCH_CONFIG_INTERNAL_MSVC_UMUL128 ) && \
    !defined( CATCH_CONFIG_NO_MSVC_UMUL128 ) &&      \
    !defined( CATCH_CONFIG_MSVC_UMUL128 )
#    define CATCH_CONFIG_MSVC_UMUL128
#    include <intrin.h>
#endif


namespace Catch {
    namespace Detail {

        template <std::size_t>
        struct SizedUnsignedType;
#define SizedUnsignedTypeHelper( TYPE )        \
    template <>                                \
    struct SizedUnsignedType<sizeof( TYPE )> { \
        using type = TYPE;                     \
    }

        SizedUnsignedTypeHelper( std::uint8_t );
        SizedUnsignedTypeHelper( std::uint16_t );
        SizedUnsignedTypeHelper( std::uint32_t );
        SizedUnsignedTypeHelper( std::uint64_t );
#undef SizedUnsignedTypeHelper

        template <std::size_t sz>
        using SizedUnsignedType_t = typename SizedUnsignedType<sz>::type;

        template <typename T>
        using DoubleWidthUnsignedType_t = SizedUnsignedType_t<2 * sizeof( T )>;

        template <typename T>
        struct ExtendedMultResult {
            T upper;
            T lower;
            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
                return upper == rhs.upper && lower == rhs.lower;
            }
        };

        /**
         * Returns 128 bit result of lhs * rhs using portable C++ code
         *
         * This implementation is almost twice as fast as naive long multiplication,
         * and unlike intrinsic-based approach, it supports constexpr evaluation.
         */
        constexpr ExtendedMultResult<std::uint64_t>
        extendedMultPortable(std::uint64_t lhs, std::uint64_t rhs) {
#define CarryBits( x ) ( x >> 32 )
#define Digits( x ) ( x & 0xFF'FF'FF'FF )
            std::uint64_t lhs_low = Digits( lhs );
            std::uint64_t rhs_low = Digits( rhs );
            std::uint64_t low_low = ( lhs_low * rhs_low );
            std::uint64_t high_high = CarryBits( lhs ) * CarryBits( rhs );

            // We add in carry bits from low-low already
            std::uint64_t high_low =
                ( CarryBits( lhs ) * rhs_low ) + CarryBits( low_low );
            // Note that we can add only low bits from high_low, to avoid
            // overflow with large inputs
            std::uint64_t low_high =
                ( lhs_low * CarryBits( rhs ) ) + Digits( high_low );

            return { high_high + CarryBits( high_low ) + CarryBits( low_high ),
                     ( low_high << 32 ) | Digits( low_low ) };
#undef CarryBits
#undef Digits
        }

        //! Returns 128 bit result of lhs * rhs
        inline ExtendedMultResult<std::uint64_t>
        extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
#if defined( CATCH_CONFIG_UINT128 )
            auto result = __uint128_t( lhs ) * __uint128_t( rhs );
            return { static_cast<std::uint64_t>( result >> 64 ),
                     static_cast<std::uint64_t>( result ) };
#elif defined( CATCH_CONFIG_MSVC_UMUL128 )
            std::uint64_t high;
            std::uint64_t low = _umul128( lhs, rhs, &high );
            return { high, low };
#else
            return extendedMultPortable( lhs, rhs );
#endif
        }


        template <typename UInt>
        constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
            static_assert( std::is_unsigned<UInt>::value,
                           "extendedMult can only handle unsigned integers" );
            static_assert( sizeof( UInt ) < sizeof( std::uint64_t ),
                           "Generic extendedMult can only handle types smaller "
                           "than uint64_t" );
            using WideType = DoubleWidthUnsignedType_t<UInt>;

            auto result = WideType( lhs ) * WideType( rhs );
            return {
                static_cast<UInt>( result >> ( CHAR_BIT * sizeof( UInt ) ) ),
                static_cast<UInt>( result & UInt( -1 ) ) };
        }


        template <typename TargetType,
                  typename Generator>
            std::enable_if_t<sizeof(typename Generator::result_type) >= sizeof(TargetType),
            TargetType> fillBitsFrom(Generator& gen) {
            using gresult_type = typename Generator::result_type;
            static_assert( std::is_unsigned<TargetType>::value, "Only unsigned integers are supported" );
            static_assert( Generator::min() == 0 &&
                           Generator::max() == static_cast<gresult_type>( -1 ),
                           "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );

            // We want to return the top bits from a generator, as they are
            // usually considered higher quality.
            constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
            constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;

            return static_cast<TargetType>( gen() >>
                                            ( generated_bits - return_bits) );
        }

        template <typename TargetType,
                  typename Generator>
            std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
            TargetType> fillBitsFrom(Generator& gen) {
            using gresult_type = typename Generator::result_type;
            static_assert( std::is_unsigned<TargetType>::value,
                           "Only unsigned integers are supported" );
            static_assert( Generator::min() == 0 &&
                           Generator::max() == static_cast<gresult_type>( -1 ),
                           "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );

            constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
            constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
            std::size_t filled_bits = 0;
            TargetType ret = 0;
            do {
                ret <<= generated_bits;
                ret |= gen();
                filled_bits += generated_bits;
            } while ( filled_bits < return_bits );

            return ret;
        }

        /*
         * Transposes numbers into unsigned type while keeping their ordering
         *
         * This means that signed types are changed so that the ordering is
         * [INT_MIN, ..., -1, 0, ..., INT_MAX], rather than order we would
         * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
         */
        template <typename OriginalType, typename UnsignedType>
        constexpr
        std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
        transposeToNaturalOrder( UnsignedType in ) {
            static_assert(
                sizeof( OriginalType ) == sizeof( UnsignedType ),
                "reordering requires the same sized types on both sides" );
            static_assert( std::is_unsigned<UnsignedType>::value,
                           "Input type must be unsigned" );
            // Assuming 2s complement (standardized in current C++), the
            // positive and negative numbers are already internally ordered,
            // and their difference is in the top bit. Swapping it orders
            // them the desired way.
            constexpr auto highest_bit =
                UnsignedType( 1 ) << ( sizeof( UnsignedType ) * CHAR_BIT - 1 );
            return static_cast<UnsignedType>( in ^ highest_bit );
        }



        template <typename OriginalType,
                  typename UnsignedType>
        constexpr
        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
            transposeToNaturalOrder(UnsignedType in) {
            static_assert(
                sizeof( OriginalType ) == sizeof( UnsignedType ),
                "reordering requires the same sized types on both sides" );
            static_assert( std::is_unsigned<UnsignedType>::value, "Input type must be unsigned" );
            // No reordering is needed for unsigned -> unsigned
            return in;
        }
    } // namespace Detail
} // namespace Catch

#endif // CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED

namespace Catch {

/**
 * Implementation of uniform distribution on integers.
 *
 * Unlike `std::uniform_int_distribution`, this implementation supports
 * various 1 byte integral types, including bool (but you should not
 * actually use it for bools).
 *
 * The underlying algorithm is based on the one described in "Fast Random
 * Integer Generation in an Interval" by Daniel Lemire, but has been
 * optimized under the assumption of reuse of the same distribution object.
 */
template <typename IntegerType>
class uniform_integer_distribution {
    static_assert(std::is_integral<IntegerType>::value, "...");

    using UnsignedIntegerType = Detail::SizedUnsignedType_t<sizeof(IntegerType)>;

    // Only the left bound is stored, and we store it converted to its
    // unsigned image. This avoids having to do the conversions inside
    // the operator(), at the cost of having to do the conversion in
    // the a() getter. The right bound is only needed in the b() getter,
    // so we recompute it there from other stored data.
    UnsignedIntegerType m_a;

    // How many different values are there in [a, b]. a == b => 1, can be 0 for distribution over all values in the type.
    UnsignedIntegerType m_ab_distance;

    // We hoisted this out of the main generation function. Technically,
    // this means that using this distribution will be slower than Lemire's
    // algorithm if this distribution instance will be used only few times,
    // but it will be faster if it is used many times. Since Catch2 uses
    // distributions only to implement random generators, we assume that each
    // distribution will be reused many times and this is an optimization.
    UnsignedIntegerType m_rejection_threshold = 0;

    static constexpr UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) {
        // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
        // We handle that later when generating the number.
        return transposeTo(b) - transposeTo(a) + 1;
    }

    static constexpr UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
        // distance == 0 means that we will return all possible values from
        // the type's range, and that we shouldn't reject anything.
        if ( ab_distance == 0 ) { return 0; }
        return ( ~ab_distance + 1 ) % ab_distance;
    }

    static constexpr UnsignedIntegerType transposeTo(IntegerType in) {
        return Detail::transposeToNaturalOrder<IntegerType>(
            static_cast<UnsignedIntegerType>( in ) );
    }
    static constexpr IntegerType transposeBack(UnsignedIntegerType in) {
        return static_cast<IntegerType>(
            Detail::transposeToNaturalOrder<IntegerType>(in) );
    }

public:
    using result_type = IntegerType;

    constexpr uniform_integer_distribution( IntegerType a, IntegerType b ):
        m_a( transposeTo(a) ),
        m_ab_distance( computeDistance(a, b) ),
        m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
        assert( a <= b );
    }

    template <typename Generator>
    constexpr result_type operator()( Generator& g ) {
        // All possible values of result_type are valid.
        if ( m_ab_distance == 0 ) {
            return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
        }

        auto random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
        auto emul = Detail::extendedMult( random_number, m_ab_distance );
        // Unlike Lemire's algorithm we skip the ab_distance check, since
        // we precomputed the rejection threshold, which is always tighter.
        while (emul.lower < m_rejection_threshold) {
            random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
            emul = Detail::extendedMult( random_number, m_ab_distance );
        }

        return transposeBack(m_a + emul.upper);
    }

    constexpr result_type a() const { return transposeBack(m_a); }
    constexpr result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
};

} // end namespace Catch

#endif // CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED



#ifndef CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
#define CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED




#ifndef CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
#define CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED



#ifndef CATCH_POLYFILLS_HPP_INCLUDED
#define CATCH_POLYFILLS_HPP_INCLUDED

namespace Catch {

    bool isnan(float f);
    bool isnan(double d);

    float nextafter(float x, float y);
    double nextafter(double x, double y);

}

#endif // CATCH_POLYFILLS_HPP_INCLUDED

#include <cassert>
#include <cmath>
#include <cstdint>
#include <limits>
#include <type_traits>

namespace Catch {

    namespace Detail {
        /**
         * Returns the largest magnitude of 1-ULP distance inside the [a, b] range.
         *
         * Assumes `a < b`.
         */
        template <typename FloatType>
        FloatType gamma(FloatType a, FloatType b) {
            static_assert( std::is_floating_point<FloatType>::value,
                           "gamma returns the largest ULP magnitude within "
                           "floating point range [a, b]. This only makes sense "
                           "for floating point types" );
            assert( a <= b );

            const auto gamma_up = Catch::nextafter( a, std::numeric_limits<FloatType>::infinity() ) - a;
            const auto gamma_down = b - Catch::nextafter( b, -std::numeric_limits<FloatType>::infinity() );

            return gamma_up < gamma_down ? gamma_down : gamma_up;
        }

        template <typename FloatingPoint>
        struct DistanceTypePicker;
        template <>
        struct DistanceTypePicker<float> {
            using type = std::uint32_t;
        };
        template <>
        struct DistanceTypePicker<double> {
            using type = std::uint64_t;
        };

        template <typename T>
        using DistanceType = typename DistanceTypePicker<T>::type;

#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        /**
         * Computes the number of equi-distant floats in [a, b]
         *
         * Since not every range can be split into equidistant floats
         * exactly, we actually compute ceil(b/distance - a/distance),
         * because in those cases we want to overcount.
         *
         * Uses modified Dekker's FastTwoSum algorithm to handle rounding.
         */
        template <typename FloatType>
        DistanceType<FloatType>
        count_equidistant_floats( FloatType a, FloatType b, FloatType distance ) {
            assert( a <= b );
            // We get distance as gamma for our uniform float distribution,
            // so this will round perfectly.
            const auto ag = a / distance;
            const auto bg = b / distance;

            const auto s = bg - ag;
            const auto err = ( std::fabs( a ) <= std::fabs( b ) )
                                 ? -ag - ( s - bg )
                                 : bg - ( s + ag );
            const auto ceil_s = static_cast<DistanceType<FloatType>>( std::ceil( s ) );

            return ( ceil_s != s ) ? ceil_s : ceil_s + ( err > 0 );
        }
#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic pop
#endif

    }

} // end namespace Catch

#endif // CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED

#include <cmath>
#include <type_traits>

namespace Catch {

    namespace Detail {
#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
        // The issue with overflow only happens with maximal ULP and HUGE
        // distance, e.g. when generating numbers in [-inf, inf] for given
        // type. So we only check for the largest possible ULP in the
        // type, and return something that does not overflow to inf in 1 mult.
        constexpr std::uint64_t calculate_max_steps_in_one_go(double gamma) {
            if ( gamma == 1.99584030953472e+292 ) { return 9007199254740991; }
            return static_cast<std::uint64_t>( -1 );
        }
        constexpr std::uint32_t calculate_max_steps_in_one_go(float gamma) {
            if ( gamma == 2.028241e+31f ) { return 16777215; }
            return static_cast<std::uint32_t>( -1 );
        }
#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic pop
#endif
    }

/**
 * Implementation of uniform distribution on floating point numbers.
 *
 * Note that we support only `float` and `double` types, because these
 * usually mean the same thing across different platform. `long double`
 * varies wildly by platform and thus we cannot provide reproducible
 * implementation. Also note that we don't implement all parts of
 * distribution per standard: this distribution is not serializable, nor
 * can the range be arbitrarily reset.
 *
 * The implementation also uses different approach than the one taken by
 * `std::uniform_real_distribution`, where instead of generating a number
 * between [0, 1) and then multiplying the range bounds with it, we first
 * split the [a, b] range into a set of equidistributed floating point
 * numbers, and then use uniform int distribution to pick which one to
 * return.
 *
 * This has the advantage of guaranteeing uniformity (the multiplication
 * method loses uniformity due to rounding when multiplying floats), except
 * for small non-uniformity at one side of the interval, where we have
 * to deal with the fact that not every interval is splittable into
 * equidistributed floats.
 *
 * Based on "Drawing random floating-point numbers from an interval" by
 * Frederic Goualard.
 */
template <typename FloatType>
class uniform_floating_point_distribution {
    static_assert(std::is_floating_point<FloatType>::value, "...");
    static_assert(!std::is_same<FloatType, long double>::value,
                  "We do not support long double due to inconsistent behaviour between platforms");

    using WidthType = Detail::DistanceType<FloatType>;

    FloatType m_a, m_b;
    FloatType m_ulp_magnitude;
    WidthType m_floats_in_range;
    uniform_integer_distribution<WidthType> m_int_dist;

    // In specific cases, we can overflow into `inf` when computing the
    // `steps * g` offset. To avoid this, we don't offset by more than this
    // in one multiply + addition.
    WidthType m_max_steps_in_one_go;
    // We don't want to do the magnitude check every call to `operator()`
    bool m_a_has_leq_magnitude;

public:
    using result_type = FloatType;

    uniform_floating_point_distribution( FloatType a, FloatType b ):
        m_a( a ),
        m_b( b ),
        m_ulp_magnitude( Detail::gamma( m_a, m_b ) ),
        m_floats_in_range( Detail::count_equidistant_floats( m_a, m_b, m_ulp_magnitude ) ),
        m_int_dist(0, m_floats_in_range),
        m_max_steps_in_one_go( Detail::calculate_max_steps_in_one_go(m_ulp_magnitude)),
        m_a_has_leq_magnitude(std::fabs(m_a) <= std::fabs(m_b))
    {
        assert( a <= b );
    }

    template <typename Generator>
    result_type operator()( Generator& g ) {
        WidthType steps = m_int_dist( g );
        if ( m_a_has_leq_magnitude ) {
            if ( steps == m_floats_in_range ) { return m_a; }
            auto b = m_b;
            while (steps > m_max_steps_in_one_go) {
                b -= m_max_steps_in_one_go * m_ulp_magnitude;
                steps -= m_max_steps_in_one_go;
            }
            return b - steps * m_ulp_magnitude;
        } else {
            if ( steps == m_floats_in_range ) { return m_b; }
            auto a = m_a;
            while (steps > m_max_steps_in_one_go) {
                a += m_max_steps_in_one_go * m_ulp_magnitude;
                steps -= m_max_steps_in_one_go;
            }
            return a + steps * m_ulp_magnitude;
        }
    }

    result_type a() const { return m_a; }
    result_type b() const { return m_b; }
};

} // end namespace Catch

#endif // CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED

namespace Catch {
namespace Generators {
namespace Detail {
    // Returns a suitable seed for a random floating generator based off
    // the primary internal rng. It does so by taking current value from
    // the rng and returning it as the seed.
    std::uint32_t getSeed();
}

template <typename Float>
class RandomFloatingGenerator final : public IGenerator<Float> {
    Catch::SimplePcg32 m_rng;
    Catch::uniform_floating_point_distribution<Float> m_dist;
    Float m_current_number;
public:
    RandomFloatingGenerator( Float a, Float b, std::uint32_t seed ):
        m_rng(seed),
        m_dist(a, b) {
        static_cast<void>(next());
    }

    Float const& get() const override {
        return m_current_number;
    }
    bool next() override {
        m_current_number = m_dist(m_rng);
        return true;
    }
};

template <>
class RandomFloatingGenerator<long double> final : public IGenerator<long double> {
    // We still rely on <random> for this specialization, but we don't
    // want to drag it into the header.
    struct PImpl;
    Catch::Detail::unique_ptr<PImpl> m_pimpl;
    long double m_current_number;

public:
    RandomFloatingGenerator( long double a, long double b, std::uint32_t seed );

    long double const& get() const override { return m_current_number; }
    bool next() override;

    ~RandomFloatingGenerator() override; // = default
};

template <typename Integer>
class RandomIntegerGenerator final : public IGenerator<Integer> {
    Catch::SimplePcg32 m_rng;
    Catch::uniform_integer_distribution<Integer> m_dist;
    Integer m_current_number;
public:
    RandomIntegerGenerator( Integer a, Integer b, std::uint32_t seed ):
        m_rng(seed),
        m_dist(a, b) {
        static_cast<void>(next());
    }

    Integer const& get() const override {
        return m_current_number;
    }
    bool next() override {
        m_current_number = m_dist(m_rng);
        return true;
    }
};

template <typename T>
std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
random(T a, T b) {
    return GeneratorWrapper<T>(
        Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
    );
}

template <typename T>
std::enable_if_t<std::is_floating_point<T>::value,
GeneratorWrapper<T>>
random(T a, T b) {
    return GeneratorWrapper<T>(
        Catch::Detail::make_unique<RandomFloatingGenerator<T>>(a, b, Detail::getSeed())
    );
}


} // namespace Generators
} // namespace Catch


#endif // CATCH_GENERATORS_RANDOM_HPP_INCLUDED


#ifndef CATCH_GENERATORS_RANGE_HPP_INCLUDED
#define CATCH_GENERATORS_RANGE_HPP_INCLUDED


#include <iterator>
#include <type_traits>

namespace Catch {
namespace Generators {


template <typename T>
class RangeGenerator final : public IGenerator<T> {
    T m_current;
    T m_end;
    T m_step;
    bool m_positive;

public:
    RangeGenerator(T const& start, T const& end, T const& step):
        m_current(start),
        m_end(end),
        m_step(step),
        m_positive(m_step > T(0))
    {
        assert(m_current != m_end && "Range start and end cannot be equal");
        assert(m_step != T(0) && "Step size cannot be zero");
        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
    }

    RangeGenerator(T const& start, T const& end):
        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
    {}

    T const& get() const override {
        return m_current;
    }

    bool next() override {
        m_current += m_step;
        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
    }
};

template <typename T>
GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
}

template <typename T>
GeneratorWrapper<T> range(T const& start, T const& end) {
    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
}


template <typename T>
class IteratorGenerator final : public IGenerator<T> {
    static_assert(!std::is_same<T, bool>::value,
        "IteratorGenerator currently does not support bools"
        "because of std::vector<bool> specialization");

    std::vector<T> m_elems;
    size_t m_current = 0;
public:
    template <typename InputIterator, typename InputSentinel>
    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
        if (m_elems.empty()) {
            Detail::throw_generator_exception("IteratorGenerator received no valid values");
        }
    }

    T const& get() const override {
        return m_elems[m_current];
    }

    bool next() override {
        ++m_current;
        return m_current != m_elems.size();
    }
};

template <typename InputIterator,
          typename InputSentinel,
          typename ResultType = std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type>>
GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
}

template <typename Container>
auto from_range(Container const& cnt) {
    using std::begin;
    using std::end;
    return from_range( begin( cnt ), end( cnt ) );
}


} // namespace Generators
} // namespace Catch


#endif // CATCH_GENERATORS_RANGE_HPP_INCLUDED

#endif // CATCH_GENERATORS_ALL_HPP_INCLUDED


/** \file
 * This is a convenience header for Catch2's interfaces. It includes
 * **all** of Catch2 headers related to interfaces.
 *
 * Generally the Catch2 users should use specific includes they need,
 * but this header can be used instead for ease-of-experimentation, or
 * just plain convenience, at the cost of somewhat increased compilation
 * times.
 *
 * When a new header is added to either the `interfaces` folder, or to
 * the corresponding internal subfolder, it should be added here.
 */


#ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
#define CATCH_INTERFACES_ALL_HPP_INCLUDED



#ifndef CATCH_INTERFACES_REPORTER_HPP_INCLUDED
#define CATCH_INTERFACES_REPORTER_HPP_INCLUDED


#include <map>
#include <string>
#include <vector>

namespace Catch {

    struct ReporterDescription;
    struct ListenerDescription;
    struct TagInfo;
    struct TestCaseInfo;
    class TestCaseHandle;
    class IConfig;
    class IStream;
    enum class ColourMode : std::uint8_t;

    struct ReporterConfig {
        ReporterConfig( IConfig const* _fullConfig,
                        Detail::unique_ptr<IStream> _stream,
                        ColourMode colourMode,
                        std::map<std::string, std::string> customOptions );

        ReporterConfig( ReporterConfig&& ) = default;
        ReporterConfig& operator=( ReporterConfig&& ) = default;
        ~ReporterConfig(); // = default

        Detail::unique_ptr<IStream> takeStream() &&;
        IConfig const* fullConfig() const;
        ColourMode colourMode() const;
        std::map<std::string, std::string> const& customOptions() const;

    private:
        Detail::unique_ptr<IStream> m_stream;
        IConfig const* m_fullConfig;
        ColourMode m_colourMode;
        std::map<std::string, std::string> m_customOptions;
    };

    struct AssertionStats {
        AssertionStats( AssertionResult const& _assertionResult,
                        std::vector<MessageInfo> const& _infoMessages,
                        Totals const& _totals );

        AssertionStats( AssertionStats const& )              = default;
        AssertionStats( AssertionStats && )                  = default;
        AssertionStats& operator = ( AssertionStats const& ) = delete;
        AssertionStats& operator = ( AssertionStats && )     = delete;

        AssertionResult assertionResult;
        std::vector<MessageInfo> infoMessages;
        Totals totals;
    };

    struct SectionStats {
        SectionStats(   SectionInfo&& _sectionInfo,
                        Counts const& _assertions,
                        double _durationInSeconds,
                        bool _missingAssertions );

        SectionInfo sectionInfo;
        Counts assertions;
        double durationInSeconds;
        bool missingAssertions;
    };

    struct TestCaseStats {
        TestCaseStats(  TestCaseInfo const& _testInfo,
                        Totals const& _totals,
                        std::string&& _stdOut,
                        std::string&& _stdErr,
                        bool _aborting );

        TestCaseInfo const * testInfo;
        Totals totals;
        std::string stdOut;
        std::string stdErr;
        bool aborting;
    };

    struct TestRunStats {
        TestRunStats(   TestRunInfo const& _runInfo,
                        Totals const& _totals,
                        bool _aborting );

        TestRunInfo runInfo;
        Totals totals;
        bool aborting;
    };

    //! By setting up its preferences, a reporter can modify Catch2's behaviour
    //! in some regards, e.g. it can request Catch2 to capture writes to
    //! stdout/stderr during test execution, and pass them to the reporter.
    struct ReporterPreferences {
        //! Catch2 should redirect writes to stdout and pass them to the
        //! reporter
        bool shouldRedirectStdOut = false;
        //! Catch2 should call `Reporter::assertionEnded` even for passing
        //! assertions
        bool shouldReportAllAssertions = false;
        //! Catch2 should call `Reporter::assertionStarting` for all assertions
        // Defaults to true for backwards compatibility, but none of our current
        // reporters actually want this, and it enables a fast path in assertion
        // handling.
        bool shouldReportAllAssertionStarts = true;
    };

    /**
     * The common base for all reporters and event listeners
     *
     * Implementing classes must also implement:
     *
     *     //! User-friendly description of the reporter/listener type
     *     static std::string getDescription()
     *
     * Generally shouldn't be derived from by users of Catch2 directly,
     * instead they should derive from one of the utility bases that
     * derive from this class.
     */
    class IEventListener {
    protected:
        //! Derived classes can set up their preferences here
        ReporterPreferences m_preferences;
        //! The test run's config as filled in from CLI and defaults
        IConfig const* m_config;

    public:
        IEventListener( IConfig const* config ): m_config( config ) {}

        virtual ~IEventListener(); // = default;

        // Implementing class must also provide the following static methods:
        // static std::string getDescription();

        ReporterPreferences const& getPreferences() const {
            return m_preferences;
        }

        //! Called when no test cases match provided test spec
        virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
        //! Called for all invalid test specs from the cli
        virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;

        /**
         * Called once in a testing run before tests are started
         *
         * Not called if tests won't be run (e.g. only listing will happen)
         */
        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;

        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
        virtual void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) = 0;
        //! Called when a `SECTION` is being entered. Not called for skipped sections
        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;

        //! Called when user-code is being probed before the actual benchmark runs
        virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
        //! Called after probe but before the user-code is being benchmarked
        virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
        //! Called with the benchmark results if benchmark successfully finishes
        virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
        //! Called if running the benchmarks fails for any reason
        virtual void benchmarkFailed( StringRef benchmarkName ) = 0;

        //! Called before assertion success/failure is evaluated
        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;

        //! Called after assertion was fully evaluated
        virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;

        //! Called after a `SECTION` has finished running
        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
        //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
        virtual void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber ) = 0;
        //! Called _once_ for each TEST_CASE, no matter how many times it is entered
        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
        /**
         * Called once after all tests in a testing run are finished
         *
         * Not called if tests weren't run (e.g. only listings happened)
         */
        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;

        /**
         * Called with test cases that are skipped due to the test run aborting.
         * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
         *
         * Deprecated - will be removed in the next major release.
         */
        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;

        //! Called if a fatal error (signal/structured exception) occurred
        virtual void fatalErrorEncountered( StringRef error ) = 0;

        //! Writes out information about provided reporters using reporter-specific format
        virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
        //! Writes out the provided listeners descriptions using reporter-specific format
        virtual void listListeners(std::vector<ListenerDescription> const& descriptions) = 0;
        //! Writes out information about provided tests using reporter-specific format
        virtual void listTests(std::vector<TestCaseHandle> const& tests) = 0;
        //! Writes out information about the provided tags using reporter-specific format
        virtual void listTags(std::vector<TagInfo> const& tags) = 0;
    };
    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;

} // end namespace Catch

#endif // CATCH_INTERFACES_REPORTER_HPP_INCLUDED


#ifndef CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
#define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED


#include <string>

namespace Catch {

    struct ReporterConfig;
    class IConfig;
    class IEventListener;
    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;


    class IReporterFactory {
    public:
        virtual ~IReporterFactory(); // = default

        virtual IEventListenerPtr
        create( ReporterConfig&& config ) const = 0;
        virtual std::string getDescription() const = 0;
    };
    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;

    class EventListenerFactory {
    public:
        virtual ~EventListenerFactory(); // = default
        virtual IEventListenerPtr create( IConfig const* config ) const = 0;
        //! Return a meaningful name for the listener, e.g. its type name
        virtual StringRef getName() const = 0;
        //! Return listener's description if available
        virtual std::string getDescription() const = 0;
    };
} // namespace Catch

#endif // CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED


#ifndef CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED

#include <string>

namespace Catch {

    struct TagAlias;

    class ITagAliasRegistry {
    public:
        virtual ~ITagAliasRegistry(); // = default
        // Nullptr if not present
        virtual TagAlias const* find( std::string const& alias ) const = 0;
        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;

        static ITagAliasRegistry const& get();
    };

} // end namespace Catch

#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED


#ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
#define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED

#include <vector>

namespace Catch {

    struct TestCaseInfo;
    class TestCaseHandle;
    class IConfig;

    class ITestCaseRegistry {
    public:
        virtual ~ITestCaseRegistry(); // = default
        // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
        virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
        virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
        virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
    };

}

#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED

#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED


#ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
#define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED


namespace Catch {
    namespace Detail {
        //! Provides case-insensitive `op<` semantics when called
        struct CaseInsensitiveLess {
            bool operator()( StringRef lhs,
                             StringRef rhs ) const;
        };

        //! Provides case-insensitive `op==` semantics when called
        struct CaseInsensitiveEqualTo {
            bool operator()( StringRef lhs,
                             StringRef rhs ) const;
        };

    } // namespace Detail
} // namespace Catch

#endif // CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED



/** \file
 * Wrapper for ANDROID_LOGWRITE configuration option
 *
 * We want to default to enabling it when compiled for android, but
 * users of the library should also be able to disable it if they want
 * to.
 */

#ifndef CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
#define CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED


#if defined(__ANDROID__)
#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
#endif


#if defined( CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ) && \
    !defined( CATCH_CONFIG_NO_ANDROID_LOGWRITE ) &&      \
    !defined( CATCH_CONFIG_ANDROID_LOGWRITE )
#    define CATCH_CONFIG_ANDROID_LOGWRITE
#endif

#endif // CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED



/** \file
 * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
 *
 * For some functionality, Catch2 requires to know whether there is
 * an active exception. Because `std::uncaught_exception` is deprecated
 * in C++17, we want to use `std::uncaught_exceptions` if possible.
 */

#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED


#if defined(_MSC_VER)
#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
#  endif
#endif


#include <exception>

#if defined(__cpp_lib_uncaught_exceptions) \
    && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)

#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
#endif // __cpp_lib_uncaught_exceptions


#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
    && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
    && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)

#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
#endif


#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED


#ifndef CATCH_CONSOLE_COLOUR_HPP_INCLUDED
#define CATCH_CONSOLE_COLOUR_HPP_INCLUDED


#include <iosfwd>
#include <cstdint>

namespace Catch {

    enum class ColourMode : std::uint8_t;
    class IStream;

    struct Colour {
        enum Code {
            None = 0,

            White,
            Red,
            Green,
            Blue,
            Cyan,
            Yellow,
            Grey,

            Bright = 0x10,

            BrightRed = Bright | Red,
            BrightGreen = Bright | Green,
            LightGrey = Bright | Grey,
            BrightWhite = Bright | White,
            BrightYellow = Bright | Yellow,

            // By intention
            FileName = LightGrey,
            Warning = BrightYellow,
            ResultError = BrightRed,
            ResultSuccess = BrightGreen,
            ResultExpectedFailure = Warning,

            Error = BrightRed,
            Success = Green,
            Skip = LightGrey,

            OriginalExpression = Cyan,
            ReconstructedExpression = BrightYellow,

            SecondaryText = LightGrey,
            Headers = White
        };
    };

    class ColourImpl {
    protected:
        //! The associated stream of this ColourImpl instance
        IStream* m_stream;
    public:
        ColourImpl( IStream* stream ): m_stream( stream ) {}

        //! RAII wrapper around writing specific colour of text using specific
        //! colour impl into a stream.
        class ColourGuard {
            ColourImpl const* m_colourImpl;
            Colour::Code m_code;
            bool m_engaged = false;

        public:
            //! Does **not** engage the guard/start the colour
            ColourGuard( Colour::Code code,
                         ColourImpl const* colour );

            ColourGuard( ColourGuard const& rhs ) = delete;
            ColourGuard& operator=( ColourGuard const& rhs ) = delete;

            ColourGuard( ColourGuard&& rhs ) noexcept;
            ColourGuard& operator=( ColourGuard&& rhs ) noexcept;

            //! Removes colour _if_ the guard was engaged
            ~ColourGuard();

            /**
             * Explicitly engages colour for given stream.
             *
             * The API based on operator<< should be preferred.
             */
            ColourGuard& engage( std::ostream& stream ) &;
            /**
             * Explicitly engages colour for given stream.
             *
             * The API based on operator<< should be preferred.
             */
            ColourGuard&& engage( std::ostream& stream ) &&;

        private:
            //! Engages the guard and starts using colour
            friend std::ostream& operator<<( std::ostream& lhs,
                                             ColourGuard& guard ) {
                guard.engageImpl( lhs );
                return lhs;
            }
            //! Engages the guard and starts using colour
            friend std::ostream& operator<<( std::ostream& lhs,
                                            ColourGuard&& guard) {
                guard.engageImpl( lhs );
                return lhs;
            }

            void engageImpl( std::ostream& stream );

        };

        virtual ~ColourImpl(); // = default
        /**
         * Creates a guard object for given colour and this colour impl
         *
         * **Important:**
         * the guard starts disengaged, and has to be engaged explicitly.
         */
        ColourGuard guardColour( Colour::Code colourCode );

    private:
        virtual void use( Colour::Code colourCode ) const = 0;
    };

    //! Provides ColourImpl based on global config and target compilation platform
    Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
                                                   IStream* stream );

    //! Checks if specific colour impl has been compiled into the binary
    bool isColourImplAvailable( ColourMode colourSelection );

} // end namespace Catch

#endif // CATCH_CONSOLE_COLOUR_HPP_INCLUDED


#ifndef CATCH_CONSOLE_WIDTH_HPP_INCLUDED
#define CATCH_CONSOLE_WIDTH_HPP_INCLUDED

// This include must be kept so that user's configured value for CONSOLE_WIDTH
// is used before we attempt to provide a default value

#ifndef CATCH_CONFIG_CONSOLE_WIDTH
#define CATCH_CONFIG_CONSOLE_WIDTH 80
#endif

#endif // CATCH_CONSOLE_WIDTH_HPP_INCLUDED


#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED


#include <cstddef>
#include <initializer_list>

// We want a simple polyfill over `std::empty`, `std::size` and so on
// for C++14 or C++ libraries with incomplete support.
// We also have to handle that MSVC std lib will happily provide these
// under older standards.
#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)

// We are already using this header either way, so there shouldn't
// be much additional overhead in including it to get the feature
// test macros
#include <string>

#  if !defined(__cpp_lib_nonmember_container_access)
#      define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
#  endif

#else
#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
#endif



namespace Catch {
namespace Detail {

#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
    template <typename Container>
    constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
        return cont.empty();
    }
    template <typename T, std::size_t N>
    constexpr bool empty(const T (&)[N]) noexcept {
        // GCC < 7 does not support the const T(&)[] parameter syntax
        // so we have to ignore the length explicitly
        (void)N;
        return false;
    }
    template <typename T>
    constexpr bool empty(std::initializer_list<T> list) noexcept {
        return list.size() > 0;
    }


    template <typename Container>
    constexpr auto size(Container const& cont) -> decltype(cont.size()) {
        return cont.size();
    }
    template <typename T, std::size_t N>
    constexpr std::size_t size(const T(&)[N]) noexcept {
        return N;
    }
#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS

} // end namespace Detail
} // end namespace Catch



#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED


#ifndef CATCH_DEBUG_CONSOLE_HPP_INCLUDED
#define CATCH_DEBUG_CONSOLE_HPP_INCLUDED

#include <string>

namespace Catch {
    void writeToDebugConsole( std::string const& text );
}

#endif // CATCH_DEBUG_CONSOLE_HPP_INCLUDED


#ifndef CATCH_DEBUGGER_HPP_INCLUDED
#define CATCH_DEBUGGER_HPP_INCLUDED


namespace Catch {
    bool isDebuggerActive();
}

#ifdef CATCH_PLATFORM_MAC

    #if defined(__i386__) || defined(__x86_64__)
        #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
    #elif defined(__aarch64__)
        #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
    #elif defined(__POWERPC__)
        #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
        : : : "memory","r0","r3","r4" ) /* NOLINT */
    #endif

#elif defined(CATCH_PLATFORM_IPHONE)

    // use inline assembler
    #if defined(__i386__) || defined(__x86_64__)
        #define CATCH_TRAP()  __asm__("int $3")
    #elif defined(__aarch64__)
        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
    #elif defined(__arm__) && !defined(__thumb__)
        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
    #elif defined(__arm__) &&  defined(__thumb__)
        #define CATCH_TRAP()  __asm__(".inst 0xde01")
    #endif

#elif defined(CATCH_PLATFORM_LINUX)
    // If we can use inline assembler, do it because this allows us to break
    // directly at the location of the failing check instead of breaking inside
    // raise() called from it, i.e. one stack frame below.
    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
    #else // Fall back to the generic way.
        #include <signal.h>

        #define CATCH_TRAP() raise(SIGTRAP)
    #endif
#elif defined(_MSC_VER)
    #define CATCH_TRAP() __debugbreak()
#elif defined(__MINGW32__)
    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
    #define CATCH_TRAP() DebugBreak()
#endif

#ifndef CATCH_BREAK_INTO_DEBUGGER
    #ifdef CATCH_TRAP
        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
    #else
        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
    #endif
#endif

#endif // CATCH_DEBUGGER_HPP_INCLUDED


#ifndef CATCH_ENFORCE_HPP_INCLUDED
#define CATCH_ENFORCE_HPP_INCLUDED


#include <exception> // for `std::exception` in no-exception configuration

namespace Catch {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
    template <typename Ex>
    [[noreturn]]
    void throw_exception(Ex const& e) {
        throw e;
    }
#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
    [[noreturn]]
    void throw_exception(std::exception const& e);
#endif

    [[noreturn]]
    void throw_logic_error(std::string const& msg);
    [[noreturn]]
    void throw_domain_error(std::string const& msg);
    [[noreturn]]
    void throw_runtime_error(std::string const& msg);

} // namespace Catch;

#define CATCH_MAKE_MSG(...) \
    (Catch::ReusableStringStream() << __VA_ARGS__).str()

#define CATCH_INTERNAL_ERROR(...) \
    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))

#define CATCH_ERROR(...) \
    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))

#define CATCH_RUNTIME_ERROR(...) \
    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))

#define CATCH_ENFORCE( condition, ... ) \
    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)


#endif // CATCH_ENFORCE_HPP_INCLUDED


#ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
#define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED


#include <vector>

namespace Catch {

    namespace Detail {

        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );

        class EnumValuesRegistry : public IMutableEnumValuesRegistry {

            std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;

            EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
        };

        std::vector<StringRef> parseEnums( StringRef enums );

    } // Detail

} // Catch

#endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED


#ifndef CATCH_ERRNO_GUARD_HPP_INCLUDED
#define CATCH_ERRNO_GUARD_HPP_INCLUDED

namespace Catch {

    //! Simple RAII class that stores the value of `errno`
    //! at construction and restores it at destruction.
    class ErrnoGuard {
    public:
        // Keep these outlined to avoid dragging in macros from <cerrno>

        ErrnoGuard();
        ~ErrnoGuard();
    private:
        int m_oldErrno;
    };

}

#endif // CATCH_ERRNO_GUARD_HPP_INCLUDED


#ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
#define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED


#include <string>

namespace Catch {

    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
    public:
        ~ExceptionTranslatorRegistry() override;
        void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
        std::string translateActiveException() const override;

    private:
        ExceptionTranslators m_translators;
    };
}

#endif // CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED


#ifndef CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
#define CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED

#include <cassert>

namespace Catch {

    /**
     * Wrapper for platform-specific fatal error (signals/SEH) handlers
     *
     * Tries to be cooperative with other handlers, and not step over
     * other handlers. This means that unknown structured exceptions
     * are passed on, previous signal handlers are called, and so on.
     *
     * Can only be instantiated once, and assumes that once a signal
     * is caught, the binary will end up terminating. Thus, there
     */
    class FatalConditionHandler {
        bool m_started = false;

        // Install/disengage implementation for specific platform.
        // Should be if-defed to work on current platform, can assume
        // engage-disengage 1:1 pairing.
        void engage_platform();
        void disengage_platform() noexcept;
    public:
        // Should also have platform-specific implementations as needed
        FatalConditionHandler();
        ~FatalConditionHandler();

        void engage() {
            assert(!m_started && "Handler cannot be installed twice.");
            m_started = true;
            engage_platform();
        }

        void disengage() noexcept {
            assert(m_started && "Handler cannot be uninstalled without being installed first");
            m_started = false;
            disengage_platform();
        }
    };

    //! Simple RAII guard for (dis)engaging the FatalConditionHandler
    class FatalConditionHandlerGuard {
        FatalConditionHandler* m_handler;
    public:
        FatalConditionHandlerGuard(FatalConditionHandler* handler):
            m_handler(handler) {
            m_handler->engage();
        }
        ~FatalConditionHandlerGuard() {
            m_handler->disengage();
        }
    };

} // end namespace Catch

#endif // CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED


#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED


#include <cassert>
#include <cmath>
#include <cstdint>
#include <utility>
#include <limits>

namespace Catch {
    namespace Detail {

        uint32_t convertToBits(float f);
        uint64_t convertToBits(double d);

        // Used when we know we want == comparison of two doubles
        // to centralize warning suppression
        bool directCompare( float lhs, float rhs );
        bool directCompare( double lhs, double rhs );

    } // end namespace Detail



#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic push
    // We do a bunch of direct compensations of floating point numbers,
    // because we know what we are doing and actually do want the direct
    // comparison behaviour.
#    pragma GCC diagnostic ignored "-Wfloat-equal"
#endif

    /**
     * Calculates the ULP distance between two floating point numbers
     *
     * The ULP distance of two floating point numbers is the count of
     * valid floating point numbers representable between them.
     *
     * There are some exceptions between how this function counts the
     * distance, and the interpretation of the standard as implemented.
     * by e.g. `nextafter`. For this function it always holds that:
     * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
     * * `ulpDistance(maxFinite, INF) == 1`
     * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
     *
     * \pre `!isnan( lhs )`
     * \pre `!isnan( rhs )`
     * \pre floating point numbers are represented in IEEE-754 format
     */
    template <typename FP>
    uint64_t ulpDistance( FP lhs, FP rhs ) {
        assert( std::numeric_limits<FP>::is_iec559 &&
            "ulpDistance assumes IEEE-754 format for floating point types" );
        assert( !Catch::isnan( lhs ) &&
                "Distance between NaN and number is not meaningful" );
        assert( !Catch::isnan( rhs ) &&
                "Distance between NaN and number is not meaningful" );

        // We want X == Y to imply 0 ULP distance even if X and Y aren't
        // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
        if ( lhs == rhs ) { return 0; }

        // We need a properly typed positive zero for type inference.
        static constexpr FP positive_zero{};

        // We want to ensure that +/- 0 is always represented as positive zero
        if ( lhs == positive_zero ) { lhs = positive_zero; }
        if ( rhs == positive_zero ) { rhs = positive_zero; }

        // If arguments have different signs, we can handle them by summing
        // how far are they from 0 each.
        if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
            return ulpDistance( std::abs( lhs ), positive_zero ) +
                   ulpDistance( std::abs( rhs ), positive_zero );
        }

        // When both lhs and rhs are of the same sign, we can just
        // read the numbers bitwise as integers, and then subtract them
        // (assuming IEEE).
        uint64_t lc = Detail::convertToBits( lhs );
        uint64_t rc = Detail::convertToBits( rhs );

        // The ulp distance between two numbers is symmetric, so to avoid
        // dealing with overflows we want the bigger converted number on the lhs
        if ( lc < rc ) {
            std::swap( lc, rc );
        }

        return lc - rc;
    }

#if defined( __GNUC__ ) || defined( __clang__ )
#    pragma GCC diagnostic pop
#endif


} // end namespace Catch

#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED


#ifndef CATCH_GETENV_HPP_INCLUDED
#define CATCH_GETENV_HPP_INCLUDED

namespace Catch {
namespace Detail {

    //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
    char const* getEnv(char const* varName);

}
}

#endif // CATCH_GETENV_HPP_INCLUDED


#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
#define CATCH_IS_PERMUTATION_HPP_INCLUDED

#include <iterator>
#include <type_traits>

namespace Catch {
    namespace Detail {

        template <typename ForwardIter,
                  typename Sentinel,
                  typename T,
                  typename Comparator>
        constexpr
        ForwardIter find_sentinel( ForwardIter start,
                                   Sentinel sentinel,
                                   T const& value,
                                   Comparator cmp ) {
            while ( start != sentinel ) {
                if ( cmp( *start, value ) ) { break; }
                ++start;
            }
            return start;
        }

        template <typename ForwardIter,
                  typename Sentinel,
                  typename T,
                  typename Comparator>
        constexpr
        std::ptrdiff_t count_sentinel( ForwardIter start,
                                       Sentinel sentinel,
                                       T const& value,
                                       Comparator cmp ) {
            std::ptrdiff_t count = 0;
            while ( start != sentinel ) {
                if ( cmp( *start, value ) ) { ++count; }
                ++start;
            }
            return count;
        }

        template <typename ForwardIter, typename Sentinel>
        constexpr
        std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
                         std::ptrdiff_t>
        sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
            std::ptrdiff_t dist = 0;
            while ( iter != sentinel ) {
                ++iter;
                ++dist;
            }
            return dist;
        }

        template <typename ForwardIter>
        constexpr std::ptrdiff_t sentinel_distance( ForwardIter first,
                                                    ForwardIter last ) {
            return std::distance( first, last );
        }

        template <typename ForwardIter1,
                  typename Sentinel1,
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
        constexpr bool check_element_counts( ForwardIter1 first_1,
                                             const Sentinel1 end_1,
                                             ForwardIter2 first_2,
                                             const Sentinel2 end_2,
                                             Comparator cmp ) {
            auto cursor = first_1;
            while ( cursor != end_1 ) {
                if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
                     cursor ) {
                    // we haven't checked this element yet
                    const auto count_in_range_2 =
                        count_sentinel( first_2, end_2, *cursor, cmp );
                    // Not a single instance in 2nd range, so it cannot be a
                    // permutation of 1st range
                    if ( count_in_range_2 == 0 ) { return false; }

                    const auto count_in_range_1 =
                        count_sentinel( cursor, end_1, *cursor, cmp );
                    if ( count_in_range_1 != count_in_range_2 ) {
                        return false;
                    }
                }

                ++cursor;
            }

            return true;
        }

        template <typename ForwardIter1,
                  typename Sentinel1,
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
        constexpr bool is_permutation( ForwardIter1 first_1,
                                       const Sentinel1 end_1,
                                       ForwardIter2 first_2,
                                       const Sentinel2 end_2,
                                       Comparator cmp ) {
            // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
            // TODO: Comparator has to be "both sides", e.g. a == b => b == a
            // This skips shared prefix of the two ranges
            while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
                ++first_1;
                ++first_2;
            }

            // We need to handle case where at least one of the ranges has no more elements
            if (first_1 == end_1 || first_2 == end_2) {
                return first_1 == end_1 && first_2 == end_2;
            }

            // pair counting is n**2, so we pay linear walk to compare the sizes first
            auto dist_1 = sentinel_distance( first_1, end_1 );
            auto dist_2 = sentinel_distance( first_2, end_2 );

            if (dist_1 != dist_2) { return false; }

            // Since we do not try to handle stronger iterators pair (e.g.
            // bidir) optimally, the only thing left to do is to check counts in
            // the remaining ranges.
            return check_element_counts( first_1, end_1, first_2, end_2, cmp );
        }

    } // namespace Detail
} // namespace Catch

#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED


#ifndef CATCH_ISTREAM_HPP_INCLUDED
#define CATCH_ISTREAM_HPP_INCLUDED


#include <iosfwd>
#include <string>

namespace Catch {

    class IStream {
    public:
        virtual ~IStream(); // = default
        virtual std::ostream& stream() = 0;
        /**
         * Best guess on whether the instance is writing to a console (e.g. via stdout/stderr)
         *
         * This is useful for e.g. Win32 colour support, because the Win32
         * API manipulates console directly, unlike POSIX escape codes,
         * that can be written anywhere.
         *
         * Due to variety of ways to change where the stdout/stderr is
         * _actually_ being written, users should always assume that
         * the answer might be wrong.
         */
        virtual bool isConsole() const { return false; }
    };

    /**
     * Creates a stream wrapper that writes to specific file.
     *
     * Also recognizes 4 special filenames
     * * `-` for stdout
     * * `%stdout` for stdout
     * * `%stderr` for stderr
     * * `%debug` for platform specific debugging output
     *
     * \throws if passed an unrecognized %-prefixed stream
     */
    auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream>;

}

#endif // CATCH_STREAM_HPP_INCLUDED


#ifndef CATCH_JSONWRITER_HPP_INCLUDED
#define CATCH_JSONWRITER_HPP_INCLUDED


#include <cstdint>
#include <sstream>

namespace Catch {
    class JsonObjectWriter;
    class JsonArrayWriter;

    struct JsonUtils {
        static void indent( std::ostream& os, std::uint64_t level );
        static void appendCommaNewline( std::ostream& os,
                                        bool& should_comma,
                                        std::uint64_t level );
    };

    class JsonValueWriter {
    public:
        JsonValueWriter( std::ostream& os );
        JsonValueWriter( std::ostream& os, std::uint64_t indent_level );

        JsonObjectWriter writeObject() &&;
        JsonArrayWriter writeArray() &&;

        template <typename T>
        void write( T const& value ) && {
            writeImpl( value, !std::is_arithmetic<T>::value );
        }
        void write( StringRef value ) &&;
        void write( bool value ) &&;

    private:
        void writeImpl( StringRef value, bool quote );

        // Without this SFINAE, this overload is a better match
        // for `std::string`, `char const*`, `char const[N]` args.
        // While it would still work, it would cause code bloat
        // and multiple iteration over the strings
        template <typename T,
                  typename = typename std::enable_if_t<
                      !std::is_convertible<T, StringRef>::value>>
        void writeImpl( T const& value, bool quote_value ) {
            m_sstream << value;
            writeImpl( m_sstream.str(), quote_value );
        }

        std::ostream& m_os;
        std::stringstream m_sstream;
        std::uint64_t m_indent_level;
    };

    class JsonObjectWriter {
    public:
        JsonObjectWriter( std::ostream& os );
        JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );

        JsonObjectWriter( JsonObjectWriter&& source ) noexcept;
        JsonObjectWriter& operator=( JsonObjectWriter&& source ) = delete;

        ~JsonObjectWriter();

        JsonValueWriter write( StringRef key );

    private:
        std::ostream& m_os;
        std::uint64_t m_indent_level;
        bool m_should_comma = false;
        bool m_active = true;
    };

    class JsonArrayWriter {
    public:
        JsonArrayWriter( std::ostream& os );
        JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );

        JsonArrayWriter( JsonArrayWriter&& source ) noexcept;
        JsonArrayWriter& operator=( JsonArrayWriter&& source ) = delete;

        ~JsonArrayWriter();

        JsonObjectWriter writeObject();
        JsonArrayWriter writeArray();

        template <typename T>
        JsonArrayWriter& write( T const& value ) {
            return writeImpl( value );
        }

        JsonArrayWriter& write( bool value );

    private:
        template <typename T>
        JsonArrayWriter& writeImpl( T const& value ) {
            JsonUtils::appendCommaNewline(
                m_os, m_should_comma, m_indent_level + 1 );
            JsonValueWriter{ m_os }.write( value );

            return *this;
        }

        std::ostream& m_os;
        std::uint64_t m_indent_level;
        bool m_should_comma = false;
        bool m_active = true;
    };

} // namespace Catch

#endif // CATCH_JSONWRITER_HPP_INCLUDED


#ifndef CATCH_LEAK_DETECTOR_HPP_INCLUDED
#define CATCH_LEAK_DETECTOR_HPP_INCLUDED

namespace Catch {

    struct LeakDetector {
        LeakDetector();
        ~LeakDetector();
    };

}
#endif // CATCH_LEAK_DETECTOR_HPP_INCLUDED


#ifndef CATCH_LIST_HPP_INCLUDED
#define CATCH_LIST_HPP_INCLUDED


#include <set>
#include <string>


namespace Catch {

    class IEventListener;
    class Config;


    struct ReporterDescription {
        std::string name, description;
    };
    struct ListenerDescription {
        StringRef name;
        std::string description;
    };

    struct TagInfo {
        void add(StringRef spelling);
        std::string all() const;

        std::set<StringRef> spellings;
        std::size_t count = 0;
    };

    bool list( IEventListener& reporter, Config const& config );

} // end namespace Catch

#endif // CATCH_LIST_HPP_INCLUDED


#ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
#define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED


#include <cassert>
#include <string>

namespace Catch {

    class OutputRedirect {
        bool m_redirectActive = false;
        virtual void activateImpl() = 0;
        virtual void deactivateImpl() = 0;
    public:
        enum Kind {
            //! No redirect (noop implementation)
            None,
            //! Redirect std::cout/std::cerr/std::clog streams internally
            Streams,
            //! Redirect the stdout/stderr file descriptors into files
            FileDescriptors,
        };

        virtual ~OutputRedirect(); // = default;

        // TODO: Do we want to check that redirect is not active before retrieving the output?
        virtual std::string getStdout() = 0;
        virtual std::string getStderr() = 0;
        virtual void clearBuffers() = 0;
        bool isActive() const { return m_redirectActive; }
        void activate() {
            assert( !m_redirectActive && "redirect is already active" );
            activateImpl();
            m_redirectActive = true;
        }
        void deactivate() {
            assert( m_redirectActive && "redirect is not active" );
            deactivateImpl();
            m_redirectActive = false;
        }
    };

    bool isRedirectAvailable( OutputRedirect::Kind kind);
    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual );

    class RedirectGuard {
        OutputRedirect* m_redirect;
        bool m_activate;
        bool m_previouslyActive;
        bool m_moved = false;

    public:
        RedirectGuard( bool activate, OutputRedirect& redirectImpl );
        ~RedirectGuard() noexcept( false );

        RedirectGuard( RedirectGuard const& ) = delete;
        RedirectGuard& operator=( RedirectGuard const& ) = delete;

        // C++14 needs move-able guards to return them from functions
        RedirectGuard( RedirectGuard&& rhs ) noexcept;
        RedirectGuard& operator=( RedirectGuard&& rhs ) noexcept;
    };

    RedirectGuard scopedActivate( OutputRedirect& redirectImpl );
    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl );

} // end namespace Catch

#endif // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED


#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
#define CATCH_PARSE_NUMBERS_HPP_INCLUDED


#include <string>

namespace Catch {

    /**
     * Parses unsigned int from the input, using provided base
     *
     * Effectively a wrapper around std::stoul but with better error checking
     * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
     */
    Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
}

#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED


#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED


#include <map>
#include <string>
#include <vector>

namespace Catch {

    class IEventListener;
    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
    class IReporterFactory;
    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
    struct ReporterConfig;
    class EventListenerFactory;

    class ReporterRegistry {
        struct ReporterRegistryImpl;
        Detail::unique_ptr<ReporterRegistryImpl> m_impl;

    public:
        ReporterRegistry();
        ~ReporterRegistry(); // = default;

        IEventListenerPtr create( std::string const& name,
                                  ReporterConfig&& config ) const;

        void registerReporter( std::string const& name,
                               IReporterFactoryPtr factory );

        void
        registerListener( Detail::unique_ptr<EventListenerFactory> factory );

        std::map<std::string,
                 IReporterFactoryPtr,
                 Detail::CaseInsensitiveLess> const&
        getFactories() const;

        std::vector<Detail::unique_ptr<EventListenerFactory>> const&
        getListeners() const;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED


#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
#define CATCH_RUN_CONTEXT_HPP_INCLUDED



#ifndef CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
#define CATCH_TEST_CASE_TRACKER_HPP_INCLUDED


#include <string>
#include <vector>

namespace Catch {
namespace TestCaseTracking {

    struct NameAndLocation {
        std::string name;
        SourceLineInfo location;

        NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
        friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
            // This is a very cheap check that should have a very high hit rate.
            // If we get to SourceLineInfo::operator==, we will redo it, but the
            // cost of repeating is trivial at that point (we will be paying
            // multiple strcmp/memcmps at that point).
            if ( lhs.location.line != rhs.location.line ) { return false; }
            return lhs.name == rhs.name && lhs.location == rhs.location;
        }
        friend bool operator!=(NameAndLocation const& lhs,
                               NameAndLocation const& rhs) {
            return !( lhs == rhs );
        }
    };

    /**
     * This is a variant of `NameAndLocation` that does not own the name string
     *
     * This avoids extra allocations when trying to locate a tracker by its
     * name and location, as long as we make sure that trackers only keep
     * around the owning variant.
     */
    struct NameAndLocationRef {
        StringRef name;
        SourceLineInfo location;

        constexpr NameAndLocationRef( StringRef name_,
                                      SourceLineInfo location_ ):
            name( name_ ), location( location_ ) {}

        friend bool operator==( NameAndLocation const& lhs,
                                NameAndLocationRef const& rhs ) {
            // This is a very cheap check that should have a very high hit rate.
            // If we get to SourceLineInfo::operator==, we will redo it, but the
            // cost of repeating is trivial at that point (we will be paying
            // multiple strcmp/memcmps at that point).
            if ( lhs.location.line != rhs.location.line ) { return false; }
            return StringRef( lhs.name ) == rhs.name &&
                   lhs.location == rhs.location;
        }
        friend bool operator==( NameAndLocationRef const& lhs,
                                NameAndLocation const& rhs ) {
            return rhs == lhs;
        }
    };

    class ITracker;

    using ITrackerPtr = Catch::Detail::unique_ptr<ITracker>;

    class ITracker {
        NameAndLocation m_nameAndLocation;

        using Children = std::vector<ITrackerPtr>;

    protected:
        enum CycleState {
            NotStarted,
            Executing,
            ExecutingChildren,
            NeedsAnotherRun,
            CompletedSuccessfully,
            Failed
        };

        ITracker* m_parent = nullptr;
        Children m_children;
        CycleState m_runState = NotStarted;

    public:
        ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
            m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
            m_parent( parent )
        {}


        // static queries
        NameAndLocation const& nameAndLocation() const {
            return m_nameAndLocation;
        }
        ITracker* parent() const {
            return m_parent;
        }

        virtual ~ITracker(); // = default


        // dynamic queries

        //! Returns true if tracker run to completion (successfully or not)
        virtual bool isComplete() const = 0;
        //! Returns true if tracker run to completion successfully
        bool isSuccessfullyCompleted() const {
            return m_runState == CompletedSuccessfully;
        }
        //! Returns true if tracker has started but hasn't been completed
        bool isOpen() const;
        //! Returns true iff tracker has started
        bool hasStarted() const;

        // actions
        virtual void close() = 0; // Successfully complete
        virtual void fail() = 0;
        void markAsNeedingAnotherRun();

        //! Register a nested ITracker
        void addChild( ITrackerPtr&& child );
        /**
         * Returns ptr to specific child if register with this tracker.
         *
         * Returns nullptr if not found.
         */
        ITracker* findChild( NameAndLocationRef const& nameAndLocation );
        //! Have any children been added?
        bool hasChildren() const {
            return !m_children.empty();
        }


        //! Marks tracker as executing a child, doing se recursively up the tree
        void openChild();

        /**
         * Returns true if the instance is a section tracker
         *
         * Subclasses should override to true if they are, replaces RTTI
         * for internal debug checks.
         */
        virtual bool isSectionTracker() const;
        /**
         * Returns true if the instance is a generator tracker
         *
         * Subclasses should override to true if they are, replaces RTTI
         * for internal debug checks.
         */
        virtual bool isGeneratorTracker() const;
    };

    class TrackerContext {

        enum RunState {
            NotStarted,
            Executing,
            CompletedCycle
        };

        ITrackerPtr m_rootTracker;
        ITracker* m_currentTracker = nullptr;
        RunState m_runState = NotStarted;

    public:

        ITracker& startRun();

        void startCycle() {
            m_currentTracker = m_rootTracker.get();
            m_runState = Executing;
        }
        void completeCycle();

        bool completedCycle() const;
        ITracker& currentTracker() { return *m_currentTracker; }
        void setCurrentTracker( ITracker* tracker );
    };

    class TrackerBase : public ITracker {
    protected:

        TrackerContext& m_ctx;

    public:
        TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );

        bool isComplete() const override;

        void open();

        void close() override;
        void fail() override;

    private:
        void moveToParent();
        void moveToThis();
    };

    class SectionTracker : public TrackerBase {
        std::vector<StringRef> m_filters;
        // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
        // Currently it allocates owns the name, so this is safe. If it is later refactored
        // to not own the name, the name still has to outlive the `ITracker` parent, so
        // this should still be safe.
        StringRef m_trimmed_name;
    public:
        SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );

        bool isSectionTracker() const override;

        bool isComplete() const override;

        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );

        void tryOpen();

        void addInitialFilters( std::vector<std::string> const& filters );
        void addNextFilters( std::vector<StringRef> const& filters );
        //! Returns filters active in this tracker
        std::vector<StringRef> const& getFilters() const { return m_filters; }
        //! Returns whitespace-trimmed name of the tracked section
        StringRef trimmedName() const;
    };

} // namespace TestCaseTracking

using TestCaseTracking::ITracker;
using TestCaseTracking::TrackerContext;
using TestCaseTracking::SectionTracker;

} // namespace Catch

#endif // CATCH_TEST_CASE_TRACKER_HPP_INCLUDED


#ifndef CATCH_THREAD_SUPPORT_HPP_INCLUDED
#define CATCH_THREAD_SUPPORT_HPP_INCLUDED


#if defined( CATCH_CONFIG_EXPERIMENTAL_THREAD_SAFE_ASSERTIONS )
#    include <atomic>
#    include <mutex>
#endif


namespace Catch {
    namespace Detail {
#if defined( CATCH_CONFIG_EXPERIMENTAL_THREAD_SAFE_ASSERTIONS )
        using Mutex = std::mutex;
        using LockGuard = std::lock_guard<std::mutex>;
        struct AtomicCounts {
            std::atomic<std::uint64_t> passed = 0;
            std::atomic<std::uint64_t> failed = 0;
            std::atomic<std::uint64_t> failedButOk = 0;
            std::atomic<std::uint64_t> skipped = 0;
        };
#else // ^^ Use actual mutex, lock and atomics
      // vv Dummy implementations for single-thread performance

        struct Mutex {
            void lock() {}
            void unlock() {}
        };

        struct LockGuard {
            LockGuard( Mutex ) {}
        };

        using AtomicCounts = Counts;
#endif

    } // namespace Detail
} // namespace Catch

#endif // CATCH_THREAD_SUPPORT_HPP_INCLUDED

#include <string>

namespace Catch {

    class IGeneratorTracker;
    class IConfig;
    class IEventListener;
    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
    class OutputRedirect;

    ///////////////////////////////////////////////////////////////////////////

    class RunContext final : public IResultCapture {

    public:
        RunContext( RunContext const& ) = delete;
        RunContext& operator =( RunContext const& ) = delete;

        explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );

        ~RunContext() override;

        Totals runTest(TestCaseHandle const& testCase);

    public: // IResultCapture

        // Assertion handlers
        void handleExpr
                (   AssertionInfo const& info,
                    ITransientExpression const& expr,
                    AssertionReaction& reaction ) override;
        void handleMessage
                (   AssertionInfo const& info,
                    ResultWas::OfType resultType,
                    std::string&& message,
                    AssertionReaction& reaction ) override;
        void handleUnexpectedExceptionNotThrown
                (   AssertionInfo const& info,
                    AssertionReaction& reaction ) override;
        void handleUnexpectedInflightException
                (   AssertionInfo const& info,
                    std::string&& message,
                    AssertionReaction& reaction ) override;
        void handleIncomplete
                (   AssertionInfo const& info ) override;
        void handleNonExpr
                (   AssertionInfo const &info,
                    ResultWas::OfType resultType,
                    AssertionReaction &reaction ) override;

        void notifyAssertionStarted( AssertionInfo const& info ) override;
        bool sectionStarted( StringRef sectionName,
                             SourceLineInfo const& sectionLineInfo,
                             Counts& assertions ) override;

        void sectionEnded( SectionEndInfo&& endInfo ) override;
        void sectionEndedEarly( SectionEndInfo&& endInfo ) override;

        IGeneratorTracker*
        acquireGeneratorTracker( StringRef generatorName,
                                 SourceLineInfo const& lineInfo ) override;
        IGeneratorTracker* createGeneratorTracker(
            StringRef generatorName,
            SourceLineInfo lineInfo,
            Generators::GeneratorBasePtr&& generator ) override;


        void benchmarkPreparing( StringRef name ) override;
        void benchmarkStarting( BenchmarkInfo const& info ) override;
        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
        void benchmarkFailed( StringRef error ) override;

        void pushScopedMessage( MessageInfo const& message ) override;
        void popScopedMessage( MessageInfo const& message ) override;

        void emplaceUnscopedMessage( MessageBuilder&& builder ) override;

        std::string getCurrentTestName() const override;

        const AssertionResult* getLastResult() const override;

        void exceptionEarlyReported() override;

        void handleFatalErrorCondition( StringRef message ) override;

        bool lastAssertionPassed() override;

    public:
        // !TBD We need to do this another way!
        bool aborting() const;

    private:
        void assertionPassedFastPath( SourceLineInfo lineInfo );
        // Update the non-thread-safe m_totals from the atomic assertion counts.
        void updateTotalsFromAtomics();

        void runCurrentTest();
        void invokeActiveTestCase();

        bool testForMissingAssertions( Counts& assertions );

        void assertionEnded( AssertionResult&& result );
        void reportExpr
                (   AssertionInfo const &info,
                    ResultWas::OfType resultType,
                    ITransientExpression const *expr,
                    bool negated );

        void populateReaction( AssertionReaction& reaction, bool has_normal_disposition );

        // Creates dummy info for unexpected exceptions/fatal errors,
        // where we do not have the access to one, but we still need
        // to send one to the reporters.
        AssertionInfo makeDummyAssertionInfo();

    private:

        void handleUnfinishedSections();
        mutable Detail::Mutex m_assertionMutex;
        TestRunInfo m_runInfo;
        TestCaseHandle const* m_activeTestCase = nullptr;
        ITracker* m_testCaseTracker = nullptr;
        Optional<AssertionResult> m_lastResult;
        IConfig const* m_config;
        Totals m_totals;
        Detail::AtomicCounts m_atomicAssertionCount;
        IEventListenerPtr m_reporter;
        std::vector<MessageInfo> m_messages;
        // Owners for the UNSCOPED_X information macro
        std::vector<ScopedMessage> m_messageScopes;
        std::vector<SectionEndInfo> m_unfinishedSections;
        std::vector<ITracker*> m_activeSections;
        TrackerContext m_trackerContext;
        Detail::unique_ptr<OutputRedirect> m_outputRedirect;
        FatalConditionHandler m_fatalConditionhandler;
        // Caches m_config->abortAfter() to avoid vptr calls/allow inlining
        size_t m_abortAfterXFailedAssertions;
        bool m_shouldReportUnexpected = true;
        // Caches whether `assertionStarting` events should be sent to the reporter.
        bool m_reportAssertionStarting;
        // Caches whether `assertionEnded` events for successful assertions should be sent to the reporter
        bool m_includeSuccessfulResults;
        // Caches m_config->shouldDebugBreak() to avoid vptr calls/allow inlining
        bool m_shouldDebugBreak;
    };

    void seedRng(IConfig const& config);
    unsigned int rngSeed();
} // end namespace Catch

#endif // CATCH_RUN_CONTEXT_HPP_INCLUDED


#ifndef CATCH_SHARDING_HPP_INCLUDED
#define CATCH_SHARDING_HPP_INCLUDED

#include <cassert>
#include <algorithm>

namespace Catch {

    template<typename Container>
    Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
        assert(shardCount > shardIndex);

        if (shardCount == 1) {
            return container;
        }

        const std::size_t totalTestCount = container.size();

        const std::size_t shardSize = totalTestCount / shardCount;
        const std::size_t leftoverTests = totalTestCount % shardCount;

        const std::size_t startIndex = shardIndex * shardSize + (std::min)(shardIndex, leftoverTests);
        const std::size_t endIndex = (shardIndex + 1) * shardSize + (std::min)(shardIndex + 1, leftoverTests);

        auto startIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(startIndex));
        auto endIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(endIndex));

        return Container(startIterator, endIterator);
    }

}

#endif // CATCH_SHARDING_HPP_INCLUDED


#ifndef CATCH_SINGLETONS_HPP_INCLUDED
#define CATCH_SINGLETONS_HPP_INCLUDED

namespace Catch {

    struct ISingleton {
        virtual ~ISingleton(); // = default
    };


    void addSingleton( ISingleton* singleton );
    void cleanupSingletons();


    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
    class Singleton : SingletonImplT, public ISingleton {

        static auto getInternal() -> Singleton* {
            static Singleton* s_instance = nullptr;
            if( !s_instance ) {
                s_instance = new Singleton;
                addSingleton( s_instance );
            }
            return s_instance;
        }

    public:
        static auto get() -> InterfaceT const& {
            return *getInternal();
        }
        static auto getMutable() -> MutableInterfaceT& {
            return *getInternal();
        }
    };

} // namespace Catch

#endif // CATCH_SINGLETONS_HPP_INCLUDED


#ifndef CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
#define CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED


#include <vector>
#include <exception>

namespace Catch {

    class StartupExceptionRegistry {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
    public:
        void add(std::exception_ptr const& exception) noexcept;
        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
    private:
        std::vector<std::exception_ptr> m_exceptions;
#endif
    };

} // end namespace Catch

#endif // CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED



#ifndef CATCH_STDSTREAMS_HPP_INCLUDED
#define CATCH_STDSTREAMS_HPP_INCLUDED

#include <iosfwd>

namespace Catch {

    std::ostream& cout();
    std::ostream& cerr();
    std::ostream& clog();

} // namespace Catch

#endif


#ifndef CATCH_STRING_MANIP_HPP_INCLUDED
#define CATCH_STRING_MANIP_HPP_INCLUDED


#include <cstdint>
#include <string>
#include <iosfwd>
#include <vector>

namespace Catch {

    bool startsWith( std::string const& s, std::string const& prefix );
    bool startsWith( StringRef s, char prefix );
    bool endsWith( std::string const& s, std::string const& suffix );
    bool endsWith( std::string const& s, char suffix );
    bool contains( std::string const& s, std::string const& infix );
    void toLowerInPlace( std::string& s );
    std::string toLower( std::string const& s );
    char toLower( char c );
    //! Returns a new string without whitespace at the start/end
    std::string trim( std::string const& str );
    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
    StringRef trim(StringRef ref);

    // !!! Be aware, returns refs into original string - make sure original string outlives them
    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );

    /**
     * Helper for streaming a "count [maybe-plural-of-label]" human-friendly string
     *
     * Usage example:
     * ```cpp
     * std::cout << "Found " << pluralise(count, "error") << '\n';
     * ```
     *
     * **Important:** The provided string must outlive the instance
     */
    class pluralise {
        std::uint64_t m_count;
        StringRef m_label;

    public:
        constexpr pluralise(std::uint64_t count, StringRef label):
            m_count(count),
            m_label(label)
        {}

        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
    };
}

#endif // CATCH_STRING_MANIP_HPP_INCLUDED


#ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
#define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED


#include <map>
#include <string>

namespace Catch {
    struct SourceLineInfo;

    class TagAliasRegistry : public ITagAliasRegistry {
    public:
        ~TagAliasRegistry() override;
        TagAlias const* find( std::string const& alias ) const override;
        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );

    private:
        std::map<std::string, TagAlias> m_registry;
    };

} // end namespace Catch

#endif // CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED


#ifndef CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
#define CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED

#include <cstdint>

namespace Catch {

    struct TestCaseInfo;

    class TestCaseInfoHasher {
    public:
        using hash_t = std::uint64_t;
        TestCaseInfoHasher( hash_t seed );
        uint32_t operator()( TestCaseInfo const& t ) const;

    private:
        hash_t m_seed;
    };

} // namespace Catch

#endif /* CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED */


#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED


#include <vector>

namespace Catch {

    class IConfig;
    class ITestInvoker;
    class TestCaseHandle;
    class TestSpec;

    std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );

    bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );

    std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
    std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );

    class TestRegistry : public ITestCaseRegistry {
    public:
        void registerTest( Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker );

        std::vector<TestCaseInfo*> const& getAllInfos() const override;
        std::vector<TestCaseHandle> const& getAllTests() const override;
        std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;

        ~TestRegistry() override; // = default

    private:
        std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
        // Keeps a materialized vector for `getAllInfos`.
        // We should get rid of that eventually (see interface note)
        std::vector<TestCaseInfo*> m_viewed_test_infos;

        std::vector<Detail::unique_ptr<ITestInvoker>> m_invokers;
        std::vector<TestCaseHandle> m_handles;
        mutable TestRunOrder m_currentSortOrder = TestRunOrder::Declared;
        mutable std::vector<TestCaseHandle> m_sortedFunctions;
    };

    ///////////////////////////////////////////////////////////////////////////


} // end namespace Catch


#endif // CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED


#ifndef CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
#define CATCH_TEST_SPEC_PARSER_HPP_INCLUDED

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#endif


#include <vector>
#include <string>

namespace Catch {

    class ITagAliasRegistry;

    class TestSpecParser {
        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
        Mode m_mode = None;
        Mode lastMode = None;
        bool m_exclusion = false;
        std::size_t m_pos = 0;
        std::size_t m_realPatternPos = 0;
        std::string m_arg;
        std::string m_substring;
        std::string m_patternName;
        std::vector<std::size_t> m_escapeChars;
        TestSpec::Filter m_currentFilter;
        TestSpec m_testSpec;
        ITagAliasRegistry const* m_tagAliases = nullptr;

    public:
        TestSpecParser( ITagAliasRegistry const& tagAliases );

        TestSpecParser& parse( std::string const& arg );
        TestSpec testSpec();

    private:
        bool visitChar( char c );
        void startNewMode( Mode mode );
        bool processNoneChar( char c );
        void processNameChar( char c );
        bool processOtherChar( char c );
        void endMode();
        void escape();
        bool isControlChar( char c ) const;
        void saveLastMode();
        void revertBackToLastMode();
        void addFilter();
        bool separate();

        // Handles common preprocessing of the pattern for name/tag patterns
        std::string preprocessPattern();
        // Adds the current pattern as a test name
        void addNamePattern();
        // Adds the current pattern as a tag
        void addTagPattern();

        inline void addCharToPattern(char c) {
            m_substring += c;
            m_patternName += c;
            m_realPatternPos++;
        }

    };

} // namespace Catch

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#endif // CATCH_TEST_SPEC_PARSER_HPP_INCLUDED


#ifndef CATCH_TEXTFLOW_HPP_INCLUDED
#define CATCH_TEXTFLOW_HPP_INCLUDED


#include <cassert>
#include <string>
#include <vector>

namespace Catch {
    namespace TextFlow {

        class Columns;

        /**
         * Abstraction for a string with ansi escape sequences that
         * automatically skips over escapes when iterating. Only graphical
         * escape sequences are considered.
         *
         * Internal representation:
         * An escape sequence looks like \033[39;49m
         * We need bidirectional iteration and the unbound length of escape
         * sequences poses a problem for operator-- To make this work we'll
         * replace the last `m` with a 0xff (this is a codepoint that won't have
         * any utf-8 meaning).
         */
        class AnsiSkippingString {
            std::string m_string;
            std::size_t m_size = 0;

            // perform 0xff replacement and calculate m_size
            void preprocessString();

        public:
            class const_iterator;
            using iterator = const_iterator;
            // note: must be u-suffixed or this will cause a "truncation of
            // constant value" warning on MSVC
            static constexpr char sentinel = static_cast<char>( 0xffu );

            explicit AnsiSkippingString( std::string const& text );
            explicit AnsiSkippingString( std::string&& text );

            const_iterator begin() const;
            const_iterator end() const;

            size_t size() const { return m_size; }

            std::string substring( const_iterator begin,
                                   const_iterator end ) const;
        };

        class AnsiSkippingString::const_iterator {
            friend AnsiSkippingString;
            struct EndTag {};

            const std::string* m_string;
            std::string::const_iterator m_it;

            explicit const_iterator( const std::string& string, EndTag ):
                m_string( &string ), m_it( string.end() ) {}

            void tryParseAnsiEscapes();
            void advance();
            void unadvance();

        public:
            using difference_type = std::ptrdiff_t;
            using value_type = char;
            using pointer = value_type*;
            using reference = value_type&;
            using iterator_category = std::bidirectional_iterator_tag;

            explicit const_iterator( const std::string& string ):
                m_string( &string ), m_it( string.begin() ) {
                tryParseAnsiEscapes();
            }

            char operator*() const { return *m_it; }

            const_iterator& operator++() {
                advance();
                return *this;
            }
            const_iterator operator++( int ) {
                iterator prev( *this );
                operator++();
                return prev;
            }
            const_iterator& operator--() {
                unadvance();
                return *this;
            }
            const_iterator operator--( int ) {
                iterator prev( *this );
                operator--();
                return prev;
            }

            bool operator==( const_iterator const& other ) const {
                return m_it == other.m_it;
            }
            bool operator!=( const_iterator const& other ) const {
                return !operator==( other );
            }
            bool operator<=( const_iterator const& other ) const {
                return m_it <= other.m_it;
            }

            const_iterator oneBefore() const {
                auto it = *this;
                return --it;
            }
        };

        /**
         * Represents a column of text with specific width and indentation
         *
         * When written out to a stream, it will perform linebreaking
         * of the provided text so that the written lines fit within
         * target width.
         */
        class Column {
            // String to be written out
            AnsiSkippingString m_string;
            // Width of the column for linebreaking
            size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
            // Indentation of other lines (including first if initial indent is
            // unset)
            size_t m_indent = 0;
            // Indentation of the first line
            size_t m_initialIndent = std::string::npos;

        public:
            /**
             * Iterates "lines" in `Column` and returns them
             */
            class const_iterator {
                friend Column;
                struct EndTag {};

                Column const& m_column;
                // Where does the current line start?
                AnsiSkippingString::const_iterator m_lineStart;
                // How long should the current line be?
                AnsiSkippingString::const_iterator m_lineEnd;
                // How far have we checked the string to iterate?
                AnsiSkippingString::const_iterator m_parsedTo;
                // Should a '-' be appended to the line?
                bool m_addHyphen = false;

                const_iterator( Column const& column, EndTag ):
                    m_column( column ),
                    m_lineStart( m_column.m_string.end() ),
                    m_lineEnd( column.m_string.end() ),
                    m_parsedTo( column.m_string.end() ) {}

                // Calculates the length of the current line
                void calcLength();

                // Returns current indentation width
                size_t indentSize() const;

                // Creates an indented and (optionally) suffixed string from
                // current iterator position, indentation and length.
                std::string addIndentAndSuffix(
                    AnsiSkippingString::const_iterator start,
                    AnsiSkippingString::const_iterator end ) const;

            public:
                using difference_type = std::ptrdiff_t;
                using value_type = std::string;
                using pointer = value_type*;
                using reference = value_type&;
                using iterator_category = std::forward_iterator_tag;

                explicit const_iterator( Column const& column );

                std::string operator*() const;

                const_iterator& operator++();
                const_iterator operator++( int );

                bool operator==( const_iterator const& other ) const {
                    return m_lineStart == other.m_lineStart &&
                           &m_column == &other.m_column;
                }
                bool operator!=( const_iterator const& other ) const {
                    return !operator==( other );
                }
            };
            using iterator = const_iterator;

            explicit Column( std::string const& text ): m_string( text ) {}
            explicit Column( std::string&& text ):
                m_string( CATCH_MOVE( text ) ) {}

            Column& width( size_t newWidth ) & {
                assert( newWidth > 0 );
                m_width = newWidth;
                return *this;
            }
            Column&& width( size_t newWidth ) && {
                assert( newWidth > 0 );
                m_width = newWidth;
                return CATCH_MOVE( *this );
            }
            Column& indent( size_t newIndent ) & {
                m_indent = newIndent;
                return *this;
            }
            Column&& indent( size_t newIndent ) && {
                m_indent = newIndent;
                return CATCH_MOVE( *this );
            }
            Column& initialIndent( size_t newIndent ) & {
                m_initialIndent = newIndent;
                return *this;
            }
            Column&& initialIndent( size_t newIndent ) && {
                m_initialIndent = newIndent;
                return CATCH_MOVE( *this );
            }

            size_t width() const { return m_width; }
            const_iterator begin() const { return const_iterator( *this ); }
            const_iterator end() const {
                return { *this, const_iterator::EndTag{} };
            }

            friend std::ostream& operator<<( std::ostream& os,
                                             Column const& col );

            friend Columns operator+( Column const& lhs, Column const& rhs );
            friend Columns operator+( Column&& lhs, Column&& rhs );
        };

        //! Creates a column that serves as an empty space of specific width
        Column Spacer( size_t spaceWidth );

        class Columns {
            std::vector<Column> m_columns;

        public:
            class iterator {
                friend Columns;
                struct EndTag {};

                std::vector<Column> const& m_columns;
                std::vector<Column::const_iterator> m_iterators;
                size_t m_activeIterators;

                iterator( Columns const& columns, EndTag );

            public:
                using difference_type = std::ptrdiff_t;
                using value_type = std::string;
                using pointer = value_type*;
                using reference = value_type&;
                using iterator_category = std::forward_iterator_tag;

                explicit iterator( Columns const& columns );

                auto operator==( iterator const& other ) const -> bool {
                    return m_iterators == other.m_iterators;
                }
                auto operator!=( iterator const& other ) const -> bool {
                    return m_iterators != other.m_iterators;
                }
                std::string operator*() const;
                iterator& operator++();
                iterator operator++( int );
            };
            using const_iterator = iterator;

            iterator begin() const { return iterator( *this ); }
            iterator end() const { return { *this, iterator::EndTag() }; }

            friend Columns& operator+=( Columns& lhs, Column const& rhs );
            friend Columns& operator+=( Columns& lhs, Column&& rhs );
            friend Columns operator+( Columns const& lhs, Column const& rhs );
            friend Columns operator+( Columns&& lhs, Column&& rhs );

            friend std::ostream& operator<<( std::ostream& os,
                                             Columns const& cols );
        };

    } // namespace TextFlow
} // namespace Catch
#endif // CATCH_TEXTFLOW_HPP_INCLUDED


#ifndef CATCH_TO_STRING_HPP_INCLUDED
#define CATCH_TO_STRING_HPP_INCLUDED

#include <string>


namespace Catch {
    template <typename T>
    std::string to_string(T const& t) {
#if defined(CATCH_CONFIG_CPP11_TO_STRING)
        return std::to_string(t);
#else
        ReusableStringStream rss;
        rss << t;
        return rss.str();
#endif
    }
} // end namespace Catch

#endif // CATCH_TO_STRING_HPP_INCLUDED


#ifndef CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
#define CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED

namespace Catch {
    bool uncaught_exceptions();
} // end namespace Catch

#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED


#ifndef CATCH_XMLWRITER_HPP_INCLUDED
#define CATCH_XMLWRITER_HPP_INCLUDED


#include <iosfwd>
#include <vector>
#include <cstdint>

namespace Catch {
    enum class XmlFormatting : std::uint8_t {
        None = 0x00,
        Indent = 0x01,
        Newline = 0x02,
    };

    constexpr XmlFormatting operator|( XmlFormatting lhs, XmlFormatting rhs ) {
        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) |
                                           static_cast<std::uint8_t>( rhs ) );
    }

    constexpr XmlFormatting operator&( XmlFormatting lhs, XmlFormatting rhs ) {
        return static_cast<XmlFormatting>( static_cast<std::uint8_t>( lhs ) &
                                           static_cast<std::uint8_t>( rhs ) );
    }


    /**
     * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
     *
     * Note: doesn't take ownership of passed strings, and thus the
     *       encoded string must outlive the encoding instance.
     */
    class XmlEncode {
    public:
        enum ForWhat { ForTextNodes, ForAttributes };

        constexpr XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes ):
            m_str( str ), m_forWhat( forWhat ) {}


        void encodeTo( std::ostream& os ) const;

        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );

    private:
        StringRef m_str;
        ForWhat m_forWhat;
    };

    class XmlWriter {
    public:

        class ScopedElement {
        public:
            ScopedElement( XmlWriter* writer, XmlFormatting fmt );

            ScopedElement( ScopedElement&& other ) noexcept;
            ScopedElement& operator=( ScopedElement&& other ) noexcept;

            ~ScopedElement();

            ScopedElement&
            writeText( StringRef text,
                       XmlFormatting fmt = XmlFormatting::Newline |
                                           XmlFormatting::Indent );

            ScopedElement& writeAttribute( StringRef name,
                                           StringRef attribute );
            template <typename T,
                      // Without this SFINAE, this overload is a better match
                      // for `std::string`, `char const*`, `char const[N]` args.
                      // While it would still work, it would cause code bloat
                      // and multiple iteration over the strings
                      typename = typename std::enable_if_t<
                          !std::is_convertible<T, StringRef>::value>>
            ScopedElement& writeAttribute( StringRef name,
                                           T const& attribute ) {
                m_writer->writeAttribute( name, attribute );
                return *this;
            }

        private:
            XmlWriter* m_writer = nullptr;
            XmlFormatting m_fmt;
        };

        XmlWriter( std::ostream& os );
        ~XmlWriter();

        XmlWriter( XmlWriter const& ) = delete;
        XmlWriter& operator=( XmlWriter const& ) = delete;

        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);

        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);

        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);

        //! The attribute content is XML-encoded
        XmlWriter& writeAttribute( StringRef name, StringRef attribute );

        //! Writes the attribute as "true/false"
        XmlWriter& writeAttribute( StringRef name, bool attribute );

        //! The attribute content is XML-encoded
        XmlWriter& writeAttribute( StringRef name, char const* attribute );

        //! The attribute value must provide op<<(ostream&, T). The resulting
        //! serialization is XML-encoded
        template <typename T,
                  // Without this SFINAE, this overload is a better match
                  // for `std::string`, `char const*`, `char const[N]` args.
                  // While it would still work, it would cause code bloat
                  // and multiple iteration over the strings
                  typename = typename std::enable_if_t<
                      !std::is_convertible<T, StringRef>::value>>
        XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
            ReusableStringStream rss;
            rss << attribute;
            return writeAttribute( name, rss.str() );
        }

        //! Writes escaped `text` in a element
        XmlWriter& writeText( StringRef text,
                              XmlFormatting fmt = XmlFormatting::Newline |
                                                  XmlFormatting::Indent );

        //! Writes XML comment as "<!-- text -->"
        XmlWriter& writeComment( StringRef text,
                                 XmlFormatting fmt = XmlFormatting::Newline |
                                                     XmlFormatting::Indent );

        void writeStylesheetRef( StringRef url );

        void ensureTagClosed();

    private:

        void applyFormatting(XmlFormatting fmt);

        void writeDeclaration();

        void newlineIfNecessary();

        bool m_tagIsOpen = false;
        bool m_needsNewline = false;
        std::vector<std::string> m_tags;
        std::string m_indent;
        std::ostream& m_os;
    };

}

#endif // CATCH_XMLWRITER_HPP_INCLUDED


/** \file
 * This is a convenience header for Catch2's Matcher support. It includes
 * **all** of Catch2 headers related to matchers.
 *
 * Generally the Catch2 users should use specific includes they need,
 * but this header can be used instead for ease-of-experimentation, or
 * just plain convenience, at the cost of increased compilation times.
 *
 * When a new header is added to either the `matchers` folder, or to
 * the corresponding internal subfolder, it should be added here.
 */

#ifndef CATCH_MATCHERS_ALL_HPP_INCLUDED
#define CATCH_MATCHERS_ALL_HPP_INCLUDED



#ifndef CATCH_MATCHERS_HPP_INCLUDED
#define CATCH_MATCHERS_HPP_INCLUDED



#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
#define CATCH_MATCHERS_IMPL_HPP_INCLUDED


#include <string>

namespace Catch {

#ifdef __clang__
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wsign-compare"
#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
#elif defined __GNUC__
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wsign-compare"
#    pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
#endif

    template<typename ArgT, typename MatcherT>
    class MatchExpr : public ITransientExpression {
        ArgT && m_arg;
        MatcherT const& m_matcher;
    public:
        constexpr MatchExpr( ArgT && arg, MatcherT const& matcher )
        :   ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
            m_arg( CATCH_FORWARD(arg) ),
            m_matcher( matcher )
        {}

        void streamReconstructedExpression( std::ostream& os ) const override {
            os << Catch::Detail::stringify( m_arg )
               << ' '
               << m_matcher.toString();
        }
    };

#ifdef __clang__
#    pragma clang diagnostic pop
#elif defined __GNUC__
#    pragma GCC diagnostic pop
#endif


    namespace Matchers {
        template <typename ArgT>
        class MatcherBase;
    }

    using StringMatcher = Matchers::MatcherBase<std::string>;

    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );

    template<typename ArgT, typename MatcherT>
    constexpr MatchExpr<ArgT, MatcherT>
    makeMatchExpr( ArgT&& arg, MatcherT const& matcher ) {
        return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
    }

} // namespace Catch


///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        INTERNAL_CATCH_TRY { \
            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        catchAssertionHandler.complete(); \
    } while( false )


///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(__VA_ARGS__ ); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ex ) { \
                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleUnexpectedInflightException(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        catchAssertionHandler.complete(); \
    } while( false )


#endif // CATCH_MATCHERS_IMPL_HPP_INCLUDED

#include <string>
#include <vector>

namespace Catch {
namespace Matchers {

    class MatcherUntypedBase {
    public:
        MatcherUntypedBase() = default;

        MatcherUntypedBase(MatcherUntypedBase const&) = default;
        MatcherUntypedBase(MatcherUntypedBase&&) = default;

        MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
        MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;

        std::string toString() const;

    protected:
        virtual ~MatcherUntypedBase(); // = default;
        virtual std::string describe() const = 0;
        mutable std::string m_cachedToString;
    };


    template<typename T>
    class MatcherBase : public MatcherUntypedBase {
    public:
        virtual bool match( T const& arg ) const = 0;
    };

    namespace Detail {

        template<typename ArgT>
        class MatchAllOf final : public MatcherBase<ArgT> {
            std::vector<MatcherBase<ArgT> const*> m_matchers;

        public:
            MatchAllOf() = default;
            MatchAllOf(MatchAllOf const&) = delete;
            MatchAllOf& operator=(MatchAllOf const&) = delete;
            MatchAllOf(MatchAllOf&&) = default;
            MatchAllOf& operator=(MatchAllOf&&) = default;


            bool match( ArgT const& arg ) const override {
                for( auto matcher : m_matchers ) {
                    if (!matcher->match(arg))
                        return false;
                }
                return true;
            }
            std::string describe() const override {
                std::string description;
                description.reserve( 4 + m_matchers.size()*32 );
                description += "( ";
                bool first = true;
                for( auto matcher : m_matchers ) {
                    if( first )
                        first = false;
                    else
                        description += " and ";
                    description += matcher->toString();
                }
                description += " )";
                return description;
            }

            friend MatchAllOf operator&& (MatchAllOf&& lhs, MatcherBase<ArgT> const& rhs) {
                lhs.m_matchers.push_back(&rhs);
                return CATCH_MOVE(lhs);
            }
            friend MatchAllOf operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf&& rhs) {
                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
                return CATCH_MOVE(rhs);
            }
        };

        //! lvalue overload is intentionally deleted, users should
        //! not be trying to compose stored composition matchers
        template<typename ArgT>
        MatchAllOf<ArgT> operator&& (MatchAllOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
        //! lvalue overload is intentionally deleted, users should
        //! not be trying to compose stored composition matchers
        template<typename ArgT>
        MatchAllOf<ArgT> operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf<ArgT> const& rhs) = delete;

        template<typename ArgT>
        class MatchAnyOf final : public MatcherBase<ArgT> {
            std::vector<MatcherBase<ArgT> const*> m_matchers;
        public:
            MatchAnyOf() = default;
            MatchAnyOf(MatchAnyOf const&) = delete;
            MatchAnyOf& operator=(MatchAnyOf const&) = delete;
            MatchAnyOf(MatchAnyOf&&) = default;
            MatchAnyOf& operator=(MatchAnyOf&&) = default;

            bool match( ArgT const& arg ) const override {
                for( auto matcher : m_matchers ) {
                    if (matcher->match(arg))
                        return true;
                }
                return false;
            }
            std::string describe() const override {
                std::string description;
                description.reserve( 4 + m_matchers.size()*32 );
                description += "( ";
                bool first = true;
                for( auto matcher : m_matchers ) {
                    if( first )
                        first = false;
                    else
                        description += " or ";
                    description += matcher->toString();
                }
                description += " )";
                return description;
            }

            friend MatchAnyOf operator|| (MatchAnyOf&& lhs, MatcherBase<ArgT> const& rhs) {
                lhs.m_matchers.push_back(&rhs);
                return CATCH_MOVE(lhs);
            }
            friend MatchAnyOf operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf&& rhs) {
                rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
                return CATCH_MOVE(rhs);
            }
        };

        //! lvalue overload is intentionally deleted, users should
        //! not be trying to compose stored composition matchers
        template<typename ArgT>
        MatchAnyOf<ArgT> operator|| (MatchAnyOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
        //! lvalue overload is intentionally deleted, users should
        //! not be trying to compose stored composition matchers
        template<typename ArgT>
        MatchAnyOf<ArgT> operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf<ArgT> const& rhs) = delete;

        template<typename ArgT>
        class MatchNotOf final : public MatcherBase<ArgT> {
            MatcherBase<ArgT> const& m_underlyingMatcher;

        public:
            explicit MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ):
                m_underlyingMatcher( underlyingMatcher )
            {}

            bool match( ArgT const& arg ) const override {
                return !m_underlyingMatcher.match( arg );
            }

            std::string describe() const override {
                return "not " + m_underlyingMatcher.toString();
            }
        };

    } // namespace Detail

    template <typename T>
    Detail::MatchAllOf<T> operator&& (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
        return Detail::MatchAllOf<T>{} && lhs && rhs;
    }
    template <typename T>
    Detail::MatchAnyOf<T> operator|| (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
        return Detail::MatchAnyOf<T>{} || lhs || rhs;
    }

    template <typename T>
    Detail::MatchNotOf<T> operator! (MatcherBase<T> const& matcher) {
        return Detail::MatchNotOf<T>{ matcher };
    }


} // namespace Matchers
} // namespace Catch


#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )

  #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )

  #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
  #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )

#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)

  #define CATCH_REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
  #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)

  #define CATCH_CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
  #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)

  #define CATCH_CHECK_THAT( arg, matcher )                             (void)(0)
  #define CATCH_REQUIRE_THAT( arg, matcher )                           (void)(0)

#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)

  #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )

  #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )

  #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
  #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )

#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)

  #define REQUIRE_THROWS_WITH( expr, matcher )                   (void)(0)
  #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)

  #define CHECK_THROWS_WITH( expr, matcher )                     (void)(0)
  #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher )   (void)(0)

  #define CHECK_THAT( arg, matcher )                             (void)(0)
  #define REQUIRE_THAT( arg, matcher )                           (void)(0)

#endif // end of user facing macro declarations

#endif // CATCH_MATCHERS_HPP_INCLUDED


#ifndef CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
#define CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED



#ifndef CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
#define CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED


#include <array>
#include <algorithm>
#include <string>
#include <type_traits>

namespace Catch {
namespace Matchers {
    class MatcherGenericBase : public MatcherUntypedBase {
    public:
        MatcherGenericBase() = default;
        ~MatcherGenericBase() override; // = default;

        MatcherGenericBase(MatcherGenericBase const&) = default;
        MatcherGenericBase(MatcherGenericBase&&) = default;

        MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
        MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
    };


    namespace Detail {
        template<std::size_t N, std::size_t M>
        std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
            std::array<void const*, N + M> arr{};
            std::copy_n(lhs.begin(), N, arr.begin());
            std::copy_n(rhs.begin(), M, arr.begin() + N);
            return arr;
        }

        template<std::size_t N>
        std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
            std::array<void const*, N+1> arr{};
            std::copy_n(lhs.begin(), N, arr.begin());
            arr[N] = rhs;
            return arr;
        }

        template<std::size_t N>
        std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
            std::array<void const*, N + 1> arr{ {lhs} };
            std::copy_n(rhs.begin(), N, arr.begin() + 1);
            return arr;
        }

        template<typename T>
        static constexpr bool is_generic_matcher_v = std::is_base_of<
            Catch::Matchers::MatcherGenericBase,
            std::remove_cv_t<std::remove_reference_t<T>>
        >::value;

        template<typename... Ts>
        static constexpr bool are_generic_matchers_v = Catch::Detail::conjunction<std::integral_constant<bool,is_generic_matcher_v<Ts>>...>::value;

        template<typename T>
        static constexpr bool is_matcher_v = std::is_base_of<
            Catch::Matchers::MatcherUntypedBase,
            std::remove_cv_t<std::remove_reference_t<T>>
        >::value;


        template<std::size_t N, typename Arg>
        bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
            return true;
        }

        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
        bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
            return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
        }


        template<std::size_t N, typename Arg>
        bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
            return false;
        }

        template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
        bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
            return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
        }

        std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end);

        template<typename... MatcherTs, std::size_t... Idx>
        std::string describe_multi_matcher(StringRef combine, std::array<void const*, sizeof...(MatcherTs)> const& matchers, std::index_sequence<Idx...>) {
            std::array<std::string, sizeof...(MatcherTs)> descriptions {{
                static_cast<MatcherTs const*>(matchers[Idx])->toString()...
            }};

            return describe_multi_matcher(combine, descriptions.data(), descriptions.data() + descriptions.size());
        }


        template<typename... MatcherTs>
        class MatchAllOfGeneric final : public MatcherGenericBase {
        public:
            MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
            MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
            MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
            MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;

            MatchAllOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
            explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}

            template<typename Arg>
            bool match(Arg&& arg) const {
                return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
            }

            std::string describe() const override {
                return describe_multi_matcher<MatcherTs...>(" and "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
            }

            // Has to be public to enable the concatenating operators
            // below, because they are not friend of the RHS, only LHS,
            // and thus cannot access private fields of RHS
            std::array<void const*, sizeof...( MatcherTs )> m_matchers;


            //! Avoids type nesting for `GenericAllOf && GenericAllOf` case
            template<typename... MatchersRHS>
            friend
            MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
                    MatchAllOfGeneric<MatcherTs...>&& lhs,
                    MatchAllOfGeneric<MatchersRHS...>&& rhs) {
                return MatchAllOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
            }

            //! Avoids type nesting for `GenericAllOf && some matcher` case
            template<typename MatcherRHS>
            friend std::enable_if_t<is_matcher_v<MatcherRHS>,
            MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
                    MatchAllOfGeneric<MatcherTs...>&& lhs,
                    MatcherRHS const& rhs) {
                return MatchAllOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(&rhs))};
            }

            //! Avoids type nesting for `some matcher && GenericAllOf` case
            template<typename MatcherLHS>
            friend std::enable_if_t<is_matcher_v<MatcherLHS>,
            MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
                    MatcherLHS const& lhs,
                    MatchAllOfGeneric<MatcherTs...>&& rhs) {
                return MatchAllOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
            }
        };


        template<typename... MatcherTs>
        class MatchAnyOfGeneric final : public MatcherGenericBase {
        public:
            MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
            MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
            MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;

            MatchAnyOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
            explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}

            template<typename Arg>
            bool match(Arg&& arg) const {
                return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
            }

            std::string describe() const override {
                return describe_multi_matcher<MatcherTs...>(" or "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
            }


            // Has to be public to enable the concatenating operators
            // below, because they are not friend of the RHS, only LHS,
            // and thus cannot access private fields of RHS
            std::array<void const*, sizeof...( MatcherTs )> m_matchers;

            //! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
            template<typename... MatchersRHS>
            friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
                    MatchAnyOfGeneric<MatchersRHS...>&& rhs) {
                return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
            }

            //! Avoids type nesting for `GenericAnyOf || some matcher` case
            template<typename MatcherRHS>
            friend std::enable_if_t<is_matcher_v<MatcherRHS>,
            MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
                    MatchAnyOfGeneric<MatcherTs...>&& lhs,
                    MatcherRHS const& rhs) {
                return MatchAnyOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(std::addressof(rhs)))};
            }

            //! Avoids type nesting for `some matcher || GenericAnyOf` case
            template<typename MatcherLHS>
            friend std::enable_if_t<is_matcher_v<MatcherLHS>,
            MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
                MatcherLHS const& lhs,
                MatchAnyOfGeneric<MatcherTs...>&& rhs) {
                return MatchAnyOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
            }
        };


        template<typename MatcherT>
        class MatchNotOfGeneric final : public MatcherGenericBase {
            MatcherT const& m_matcher;

        public:
            MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
            MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
            MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
            MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;

            explicit MatchNotOfGeneric(MatcherT const& matcher) : m_matcher{matcher} {}

            template<typename Arg>
            bool match(Arg&& arg) const {
                return !m_matcher.match(arg);
            }

            std::string describe() const override {
                return "not " + m_matcher.toString();
            }

            //! Negating negation can just unwrap and return underlying matcher
            friend MatcherT const& operator ! (MatchNotOfGeneric<MatcherT> const& matcher) {
                return matcher.m_matcher;
            }
        };
    } // namespace Detail


    // compose only generic matchers
    template<typename MatcherLHS, typename MatcherRHS>
    std::enable_if_t<Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
        operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
        return { lhs, rhs };
    }

    template<typename MatcherLHS, typename MatcherRHS>
    std::enable_if_t<Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
        operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
        return { lhs, rhs };
    }

    //! Wrap provided generic matcher in generic negator
    template<typename MatcherT>
    std::enable_if_t<Detail::is_generic_matcher_v<MatcherT>, Detail::MatchNotOfGeneric<MatcherT>>
        operator ! (MatcherT const& matcher) {
        return Detail::MatchNotOfGeneric<MatcherT>{matcher};
    }


    // compose mixed generic and non-generic matchers
    template<typename MatcherLHS, typename ArgRHS>
    std::enable_if_t<Detail::is_generic_matcher_v<MatcherLHS>, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
        operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
        return { lhs, rhs };
    }

    template<typename ArgLHS, typename MatcherRHS>
    std::enable_if_t<Detail::is_generic_matcher_v<MatcherRHS>, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
        operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
        return { lhs, rhs };
    }

    template<typename MatcherLHS, typename ArgRHS>
    std::enable_if_t<Detail::is_generic_matcher_v<MatcherLHS>, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
        operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
        return { lhs, rhs };
    }

    template<typename ArgLHS, typename MatcherRHS>
    std::enable_if_t<Detail::is_generic_matcher_v<MatcherRHS>, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
        operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
        return { lhs, rhs };
    }

} // namespace Matchers
} // namespace Catch

#endif // CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED

namespace Catch {
    namespace Matchers {

        class IsEmptyMatcher final : public MatcherGenericBase {
        public:
            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
                using Catch::Detail::empty;
#else
                using std::empty;
#endif
                return empty(rng);
            }

            std::string describe() const override;
        };

        class HasSizeMatcher final : public MatcherGenericBase {
            std::size_t m_target_size;
        public:
            explicit HasSizeMatcher(std::size_t target_size):
                m_target_size(target_size)
            {}

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
                using Catch::Detail::size;
#else
                using std::size;
#endif
                return size(rng) == m_target_size;
            }

            std::string describe() const override;
        };

        template <typename Matcher>
        class SizeMatchesMatcher final : public MatcherGenericBase {
            Matcher m_matcher;
        public:
            explicit SizeMatchesMatcher(Matcher m):
                m_matcher(CATCH_MOVE(m))
            {}

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
                using Catch::Detail::size;
#else
                using std::size;
#endif
                return m_matcher.match(size(rng));
            }

            std::string describe() const override {
                return "size matches " + m_matcher.describe();
            }
        };


        //! Creates a matcher that accepts empty ranges/containers
        IsEmptyMatcher IsEmpty();
        //! Creates a matcher that accepts ranges/containers with specific size
        HasSizeMatcher SizeIs(std::size_t sz);
        template <typename Matcher>
        std::enable_if_t<Detail::is_matcher_v<Matcher>,
        SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
            return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
        }

    } // end namespace Matchers
} // end namespace Catch

#endif // CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED


#ifndef CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
#define CATCH_MATCHERS_CONTAINS_HPP_INCLUDED


#include <functional>
#include <type_traits>

namespace Catch {
    namespace Matchers {
        //! Matcher for checking that an element in range is equal to specific element
        template <typename T, typename Equality>
        class ContainsElementMatcher final : public MatcherGenericBase {
            T m_desired;
            Equality m_eq;
        public:
            template <typename T2, typename Equality2>
            ContainsElementMatcher(T2&& target, Equality2&& predicate):
                m_desired(CATCH_FORWARD(target)),
                m_eq(CATCH_FORWARD(predicate))
            {}

            std::string describe() const override {
                return "contains element " + Catch::Detail::stringify(m_desired);
            }

            template <typename RangeLike>
            bool match( RangeLike&& rng ) const {
                for ( auto&& elem : rng ) {
                    if ( m_eq( elem, m_desired ) ) { return true; }
                }
                return false;
            }
        };

        //! Meta-matcher for checking that an element in a range matches a specific matcher
        template <typename Matcher>
        class ContainsMatcherMatcher final : public MatcherGenericBase {
            Matcher m_matcher;
        public:
            // Note that we do a copy+move to avoid having to SFINAE this
            // constructor (and also avoid some perfect forwarding failure
            // cases)
            ContainsMatcherMatcher(Matcher matcher):
                m_matcher(CATCH_MOVE(matcher))
            {}

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
                for (auto&& elem : rng) {
                    if (m_matcher.match(elem)) {
                        return true;
                    }
                }
                return false;
            }

            std::string describe() const override {
                return "contains element matching " + m_matcher.describe();
            }
        };

        /**
         * Creates a matcher that checks whether a range contains a specific element.
         *
         * Uses `std::equal_to` to do the comparison
         */
        template <typename T>
        std::enable_if_t<!Detail::is_matcher_v<T>,
        ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
            return { CATCH_FORWARD(elem), std::equal_to<>{} };
        }

        //! Creates a matcher that checks whether a range contains element matching a matcher
        template <typename Matcher>
        std::enable_if_t<Detail::is_matcher_v<Matcher>,
        ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
            return { CATCH_FORWARD(matcher) };
        }

        /**
         * Creates a matcher that checks whether a range contains a specific element.
         *
         * Uses `eq` to do the comparisons, the element is provided on the rhs
         */
        template <typename T, typename Equality>
        ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
            return { CATCH_FORWARD(elem), CATCH_FORWARD(eq) };
        }

    }
}

#endif // CATCH_MATCHERS_CONTAINS_HPP_INCLUDED


#ifndef CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
#define CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED


namespace Catch {
namespace Matchers {

class ExceptionMessageMatcher final : public MatcherBase<std::exception> {
    std::string m_message;
public:

    ExceptionMessageMatcher(std::string const& message):
        m_message(message)
    {}

    bool match(std::exception const& ex) const override;

    std::string describe() const override;
};

//! Creates a matcher that checks whether a std derived exception has the provided message
ExceptionMessageMatcher Message(std::string const& message);

template <typename StringMatcherType>
class ExceptionMessageMatchesMatcher final
    : public MatcherBase<std::exception> {
    StringMatcherType m_matcher;

public:
    ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
        m_matcher( CATCH_MOVE( matcher ) ) {}

    bool match( std::exception const& ex ) const override {
        return m_matcher.match( ex.what() );
    }

    std::string describe() const override {
        return " matches \"" + m_matcher.describe() + '"';
    }
};

//! Creates a matcher that checks whether a message from an std derived
//! exception matches a provided matcher
template <typename StringMatcherType>
ExceptionMessageMatchesMatcher<StringMatcherType>
MessageMatches( StringMatcherType&& matcher ) {
    return { CATCH_FORWARD( matcher ) };
}

} // namespace Matchers
} // namespace Catch

#endif // CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED


#ifndef CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
#define CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED


namespace Catch {
namespace Matchers {

    namespace Detail {
        enum class FloatingPointKind : uint8_t;
    }

    class  WithinAbsMatcher final : public MatcherBase<double> {
    public:
        WithinAbsMatcher(double target, double margin);
        bool match(double const& matchee) const override;
        std::string describe() const override;
    private:
        double m_target;
        double m_margin;
    };

    //! Creates a matcher that accepts numbers within certain range of target
    WithinAbsMatcher WithinAbs( double target, double margin );



    class WithinUlpsMatcher final : public MatcherBase<double> {
    public:
        WithinUlpsMatcher( double target,
                           uint64_t ulps,
                           Detail::FloatingPointKind baseType );
        bool match(double const& matchee) const override;
        std::string describe() const override;
    private:
        double m_target;
        uint64_t m_ulps;
        Detail::FloatingPointKind m_type;
    };

    //! Creates a matcher that accepts doubles within certain ULP range of target
    WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
    //! Creates a matcher that accepts floats within certain ULP range of target
    WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);



    // Given IEEE-754 format for floats and doubles, we can assume
    // that float -> double promotion is lossless. Given this, we can
    // assume that if we do the standard relative comparison of
    // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
    // the same result if we do this for floats, as if we do this for
    // doubles that were promoted from floats.
    class WithinRelMatcher final : public MatcherBase<double> {
    public:
        WithinRelMatcher( double target, double epsilon );
        bool match(double const& matchee) const override;
        std::string describe() const override;
    private:
        double m_target;
        double m_epsilon;
    };

    //! Creates a matcher that accepts doubles within certain relative range of target
    WithinRelMatcher WithinRel(double target, double eps);
    //! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
    WithinRelMatcher WithinRel(double target);
    //! Creates a matcher that accepts doubles within certain relative range of target
    WithinRelMatcher WithinRel(float target, float eps);
    //! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
    WithinRelMatcher WithinRel(float target);



    class IsNaNMatcher final : public MatcherBase<double> {
    public:
        IsNaNMatcher() = default;
        bool match( double const& matchee ) const override;
        std::string describe() const override;
    };

    IsNaNMatcher IsNaN();

} // namespace Matchers
} // namespace Catch

#endif // CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED


#ifndef CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
#define CATCH_MATCHERS_PREDICATE_HPP_INCLUDED


#include <string>

namespace Catch {
namespace Matchers {

namespace Detail {
    std::string finalizeDescription(const std::string& desc);
} // namespace Detail

template <typename T, typename Predicate>
class PredicateMatcher final : public MatcherBase<T> {
    Predicate m_predicate;
    std::string m_description;
public:

    PredicateMatcher(Predicate&& elem, std::string const& descr)
        :m_predicate(CATCH_FORWARD(elem)),
        m_description(Detail::finalizeDescription(descr))
    {}

    bool match( T const& item ) const override {
        return m_predicate(item);
    }

    std::string describe() const override {
        return m_description;
    }
};

    /**
     * Creates a matcher that calls delegates `match` to the provided predicate.
     *
     * The user has to explicitly specify the argument type to the matcher
     */
    template<typename T, typename Pred>
    PredicateMatcher<T, Pred> Predicate(Pred&& predicate, std::string const& description = "") {
        static_assert(is_callable<Pred(T)>::value, "Predicate not callable with argument T");
        static_assert(std::is_same<bool, FunctionReturnType<Pred, T>>::value, "Predicate does not return bool");
        return PredicateMatcher<T, Pred>(CATCH_FORWARD(predicate), description);
    }

} // namespace Matchers
} // namespace Catch

#endif // CATCH_MATCHERS_PREDICATE_HPP_INCLUDED


#ifndef CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
#define CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED


namespace Catch {
    namespace Matchers {
        // Matcher for checking that all elements in range matches a given matcher.
        template <typename Matcher>
        class AllMatchMatcher final : public MatcherGenericBase {
            Matcher m_matcher;
        public:
            AllMatchMatcher(Matcher matcher):
                m_matcher(CATCH_MOVE(matcher))
            {}

            std::string describe() const override {
                return "all match " + m_matcher.describe();
            }

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
                for (auto&& elem : rng) {
                    if (!m_matcher.match(elem)) {
                        return false;
                    }
                }
                return true;
            }
        };

        // Matcher for checking that no element in range matches a given matcher.
        template <typename Matcher>
        class NoneMatchMatcher final : public MatcherGenericBase {
            Matcher m_matcher;
        public:
            NoneMatchMatcher(Matcher matcher):
                m_matcher(CATCH_MOVE(matcher))
            {}

            std::string describe() const override {
                return "none match " + m_matcher.describe();
            }

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
                for (auto&& elem : rng) {
                    if (m_matcher.match(elem)) {
                        return false;
                    }
                }
                return true;
            }
        };

        // Matcher for checking that at least one element in range matches a given matcher.
        template <typename Matcher>
        class AnyMatchMatcher final : public MatcherGenericBase {
            Matcher m_matcher;
        public:
            AnyMatchMatcher(Matcher matcher):
                m_matcher(CATCH_MOVE(matcher))
            {}

            std::string describe() const override {
                return "any match " + m_matcher.describe();
            }

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
                for (auto&& elem : rng) {
                    if (m_matcher.match(elem)) {
                        return true;
                    }
                }
                return false;
            }
        };

        // Matcher for checking that all elements in range are true.
        class AllTrueMatcher final : public MatcherGenericBase {
        public:
            std::string describe() const override;

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
                for (auto&& elem : rng) {
                    if (!elem) {
                        return false;
                    }
                }
                return true;
            }
        };

        // Matcher for checking that no element in range is true.
        class NoneTrueMatcher final : public MatcherGenericBase {
        public:
            std::string describe() const override;

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
                for (auto&& elem : rng) {
                    if (elem) {
                        return false;
                    }
                }
                return true;
            }
        };

        // Matcher for checking that any element in range is true.
        class AnyTrueMatcher final : public MatcherGenericBase {
        public:
            std::string describe() const override;

            template <typename RangeLike>
            bool match(RangeLike&& rng) const {
                for (auto&& elem : rng) {
                    if (elem) {
                        return true;
                    }
                }
                return false;
            }
        };

        // Creates a matcher that checks whether all elements in a range match a matcher
        template <typename Matcher>
        AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
            return { CATCH_FORWARD(matcher) };
        }

        // Creates a matcher that checks whether no element in a range matches a matcher.
        template <typename Matcher>
        NoneMatchMatcher<Matcher> NoneMatch(Matcher&& matcher) {
            return { CATCH_FORWARD(matcher) };
        }

        // Creates a matcher that checks whether any element in a range matches a matcher.
        template <typename Matcher>
        AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
            return { CATCH_FORWARD(matcher) };
        }

        // Creates a matcher that checks whether all elements in a range are true
        AllTrueMatcher AllTrue();

        // Creates a matcher that checks whether no element in a range is true
        NoneTrueMatcher NoneTrue();

        // Creates a matcher that checks whether any element in a range is true
        AnyTrueMatcher AnyTrue();
    }
}

#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED


#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED


#include <functional>

namespace Catch {
    namespace Matchers {

        /**
         * Matcher for checking that an element contains the same
         * elements in the same order
         */
        template <typename TargetRangeLike, typename Equality>
        class RangeEqualsMatcher final : public MatcherGenericBase {
            TargetRangeLike m_desired;
            Equality m_predicate;

        public:
            template <typename TargetRangeLike2, typename Equality2>
            constexpr
            RangeEqualsMatcher( TargetRangeLike2&& range,
                                Equality2&& predicate ):
                m_desired( CATCH_FORWARD( range ) ),
                m_predicate( CATCH_FORWARD( predicate ) ) {}

            template <typename RangeLike>
            constexpr
            bool match( RangeLike&& rng ) const {
                auto rng_start = begin( rng );
                const auto rng_end = end( rng );
                auto target_start = begin( m_desired );
                const auto target_end = end( m_desired );

                while (rng_start != rng_end && target_start != target_end) {
                    if (!m_predicate(*rng_start, *target_start)) {
                        return false;
                    }
                    ++rng_start;
                    ++target_start;
                }
                return rng_start == rng_end && target_start == target_end;
            }

            std::string describe() const override {
                return "elements are " + Catch::Detail::stringify( m_desired );
            }
        };

        /**
         * Matcher for checking that an element contains the same
         * elements (but not necessarily in the same order)
         */
        template <typename TargetRangeLike, typename Equality>
        class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
            TargetRangeLike m_desired;
            Equality m_predicate;

        public:
            template <typename TargetRangeLike2, typename Equality2>
            constexpr
            UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
                                         Equality2&& predicate ):
                m_desired( CATCH_FORWARD( range ) ),
                m_predicate( CATCH_FORWARD( predicate ) ) {}

            template <typename RangeLike>
            constexpr
            bool match( RangeLike&& rng ) const {
                using std::begin;
                using std::end;
                return Catch::Detail::is_permutation( begin( m_desired ),
                                                      end( m_desired ),
                                                      begin( rng ),
                                                      end( rng ),
                                                      m_predicate );
            }

            std::string describe() const override {
                return "unordered elements are " +
                       ::Catch::Detail::stringify( m_desired );
            }
        };

        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range.
         *
         * Uses the provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
        template <typename RangeLike,
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        RangeEqualsMatcher<RangeLike, Equality>
        RangeEquals( RangeLike&& range,
                     Equality&& predicate = std::equal_to<>{} ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
        }

        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in an initializer list.
         *
         * Uses the provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
        template <typename T,
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        RangeEqualsMatcher<std::initializer_list<T>, Equality>
        RangeEquals( std::initializer_list<T> range,
                     Equality&& predicate = std::equal_to<>{} ) {
            return { range, CATCH_FORWARD( predicate ) };
        }

        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in another range, in some permutation.
         *
         * Uses the provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
        template <typename RangeLike,
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        UnorderedRangeEqualsMatcher<RangeLike, Equality>
        UnorderedRangeEquals( RangeLike&& range,
                              Equality&& predicate = std::equal_to<>{} ) {
            return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
        }

        /**
         * Creates a matcher that checks if all elements in a range are equal
         * to all elements in an initializer list, in some permutation.
         *
         * Uses the provided predicate `predicate` to do the comparisons
         * (defaulting to `std::equal_to`)
         */
        template <typename T,
                  typename Equality = decltype( std::equal_to<>{} )>
        constexpr
        UnorderedRangeEqualsMatcher<std::initializer_list<T>, Equality>
        UnorderedRangeEquals( std::initializer_list<T> range,
                              Equality&& predicate = std::equal_to<>{} ) {
            return { range, CATCH_FORWARD( predicate ) };
        }
    } // namespace Matchers
} // namespace Catch

#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED


#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
#define CATCH_MATCHERS_STRING_HPP_INCLUDED


#include <string>

namespace Catch {
namespace Matchers {

    struct CasedString {
        CasedString( std::string const& str, CaseSensitive caseSensitivity );
        std::string adjustString( std::string const& str ) const;
        StringRef caseSensitivitySuffix() const;

        CaseSensitive m_caseSensitivity;
        std::string m_str;
    };

    class StringMatcherBase : public MatcherBase<std::string> {
    protected:
        CasedString m_comparator;
        StringRef m_operation;

    public:
        StringMatcherBase( StringRef operation,
                           CasedString const& comparator );
        std::string describe() const override;
    };

    class StringEqualsMatcher final : public StringMatcherBase {
    public:
        StringEqualsMatcher( CasedString const& comparator );
        bool match( std::string const& source ) const override;
    };
    class StringContainsMatcher final : public StringMatcherBase {
    public:
        StringContainsMatcher( CasedString const& comparator );
        bool match( std::string const& source ) const override;
    };
    class StartsWithMatcher final : public StringMatcherBase {
    public:
        StartsWithMatcher( CasedString const& comparator );
        bool match( std::string const& source ) const override;
    };
    class EndsWithMatcher final : public StringMatcherBase {
    public:
        EndsWithMatcher( CasedString const& comparator );
        bool match( std::string const& source ) const override;
    };

    class RegexMatcher final : public MatcherBase<std::string> {
        std::string m_regex;
        CaseSensitive m_caseSensitivity;

    public:
        RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
        bool match( std::string const& matchee ) const override;
        std::string describe() const override;
    };

    //! Creates matcher that accepts strings that are exactly equal to `str`
    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
    //! Creates matcher that accepts strings that contain `str`
    StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
    //! Creates matcher that accepts strings that _end_ with `str`
    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
    //! Creates matcher that accepts strings that _start_ with `str`
    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
    //! Creates matcher that accepts strings matching `regex`
    RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );

} // namespace Matchers
} // namespace Catch

#endif // CATCH_MATCHERS_STRING_HPP_INCLUDED


#ifndef CATCH_MATCHERS_VECTOR_HPP_INCLUDED
#define CATCH_MATCHERS_VECTOR_HPP_INCLUDED


#include <algorithm>

namespace Catch {
namespace Matchers {

    template<typename T, typename Alloc>
    class VectorContainsElementMatcher final : public MatcherBase<std::vector<T, Alloc>> {
        T const& m_comparator;

    public:
        VectorContainsElementMatcher(T const& comparator):
            m_comparator(comparator)
        {}

        bool match(std::vector<T, Alloc> const& v) const override {
            for (auto const& el : v) {
                if (el == m_comparator) {
                    return true;
                }
            }
            return false;
        }

        std::string describe() const override {
            return "Contains: " + ::Catch::Detail::stringify( m_comparator );
        }
    };

    template<typename T, typename AllocComp, typename AllocMatch>
    class ContainsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
        std::vector<T, AllocComp> const& m_comparator;

    public:
        ContainsMatcher(std::vector<T, AllocComp> const& comparator):
            m_comparator( comparator )
        {}

        bool match(std::vector<T, AllocMatch> const& v) const override {
            // !TBD: see note in EqualsMatcher
            if (m_comparator.size() > v.size())
                return false;
            for (auto const& comparator : m_comparator) {
                auto present = false;
                for (const auto& el : v) {
                    if (el == comparator) {
                        present = true;
                        break;
                    }
                }
                if (!present) {
                    return false;
                }
            }
            return true;
        }
        std::string describe() const override {
            return "Contains: " + ::Catch::Detail::stringify( m_comparator );
        }
    };

    template<typename T, typename AllocComp, typename AllocMatch>
    class EqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
        std::vector<T, AllocComp> const& m_comparator;

    public:
        EqualsMatcher(std::vector<T, AllocComp> const& comparator):
            m_comparator( comparator )
        {}

        bool match(std::vector<T, AllocMatch> const& v) const override {
            // !TBD: This currently works if all elements can be compared using !=
            // - a more general approach would be via a compare template that defaults
            // to using !=. but could be specialised for, e.g. std::vector<T> etc
            // - then just call that directly
            if ( m_comparator.size() != v.size() ) { return false; }
            for ( std::size_t i = 0; i < v.size(); ++i ) {
                if ( !( m_comparator[i] == v[i] ) ) { return false; }
            }
            return true;
        }
        std::string describe() const override {
            return "Equals: " + ::Catch::Detail::stringify( m_comparator );
        }
    };

    template<typename T, typename AllocComp, typename AllocMatch>
    class ApproxMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
        std::vector<T, AllocComp> const& m_comparator;
        mutable Catch::Approx approx = Catch::Approx::custom();

    public:
        ApproxMatcher(std::vector<T, AllocComp> const& comparator):
            m_comparator( comparator )
        {}

        bool match(std::vector<T, AllocMatch> const& v) const override {
            if (m_comparator.size() != v.size())
                return false;
            for (std::size_t i = 0; i < v.size(); ++i)
                if (m_comparator[i] != approx(v[i]))
                    return false;
            return true;
        }
        std::string describe() const override {
            return "is approx: " + ::Catch::Detail::stringify( m_comparator );
        }
        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        ApproxMatcher& epsilon( T const& newEpsilon ) {
            approx.epsilon(static_cast<double>(newEpsilon));
            return *this;
        }
        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        ApproxMatcher& margin( T const& newMargin ) {
            approx.margin(static_cast<double>(newMargin));
            return *this;
        }
        template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
        ApproxMatcher& scale( T const& newScale ) {
            approx.scale(static_cast<double>(newScale));
            return *this;
        }
    };

    template<typename T, typename AllocComp, typename AllocMatch>
    class UnorderedEqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
        std::vector<T, AllocComp> const& m_target;

    public:
        UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target):
            m_target(target)
        {}
        bool match(std::vector<T, AllocMatch> const& vec) const override {
            if (m_target.size() != vec.size()) {
                return false;
            }
            return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
        }

        std::string describe() const override {
            return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
        }
    };


    // The following functions create the actual matcher objects.
    // This allows the types to be inferred

    //! Creates a matcher that matches vectors that contain all elements in `comparator`
    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
        return ContainsMatcher<T, AllocComp, AllocMatch>(comparator);
    }

    //! Creates a matcher that matches vectors that contain `comparator` as an element
    template<typename T, typename Alloc = std::allocator<T>>
    VectorContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
        return VectorContainsElementMatcher<T, Alloc>(comparator);
    }

    //! Creates a matcher that matches vectors that are exactly equal to `comparator`
    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
        return EqualsMatcher<T, AllocComp, AllocMatch>(comparator);
    }

    //! Creates a matcher that matches vectors that `comparator` as an element
    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
        return ApproxMatcher<T, AllocComp, AllocMatch>(comparator);
    }

    //! Creates a matcher that matches vectors that is equal to `target` modulo permutation
    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
        return UnorderedEqualsMatcher<T, AllocComp, AllocMatch>(target);
    }

} // namespace Matchers
} // namespace Catch

#endif // CATCH_MATCHERS_VECTOR_HPP_INCLUDED

#endif // CATCH_MATCHERS_ALL_HPP_INCLUDED


/** \file
 * This is a convenience header for Catch2's Reporter support. It includes
 * **all** of Catch2 headers related to reporters, including all reporters.
 *
 * Generally the Catch2 users should use specific includes they need,
 * but this header can be used instead for ease-of-experimentation, or
 * just plain convenience, at the cost of (significantly) increased
 * compilation times.
 *
 * When a new header (reporter) is added to either the `reporter` folder,
 * or to the corresponding internal subfolder, it should be added here.
 */

#ifndef CATCH_REPORTERS_ALL_HPP_INCLUDED
#define CATCH_REPORTERS_ALL_HPP_INCLUDED



#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED



#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED



#ifndef CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
#define CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED


#include <map>
#include <string>

namespace Catch {
    class ColourImpl;

    /**
     * This is the base class for all reporters.
     *
     * If are writing a reporter, you must derive from this type, or one
     * of the helper reporter bases that are derived from this type.
     *
     * ReporterBase centralizes handling of various common tasks in reporters,
     * like storing the right stream for the reporters to write to, and
     * providing the default implementation of the different listing events.
     */
    class ReporterBase : public IEventListener {
    protected:
        //! The stream wrapper as passed to us by outside code
        Detail::unique_ptr<IStream> m_wrapped_stream;
        //! Cached output stream from `m_wrapped_stream` to reduce
        //! number of indirect calls needed to write output.
        std::ostream& m_stream;
        //! Colour implementation this reporter was configured for
        Detail::unique_ptr<ColourImpl> m_colour;
        //! The custom reporter options user passed down to the reporter
        std::map<std::string, std::string> m_customOptions;

    public:
        ReporterBase( ReporterConfig&& config );
        ~ReporterBase() override; // = default;

        /**
         * Provides a simple default listing of reporters.
         *
         * Should look roughly like the reporter listing in v2 and earlier
         * versions of Catch2.
         */
        void listReporters(
            std::vector<ReporterDescription> const& descriptions ) override;
        /**
         * Provides a simple default listing of listeners
         *
         * Looks similarly to listing of reporters, but with listener type
         * instead of reporter name.
         */
        void listListeners(
            std::vector<ListenerDescription> const& descriptions ) override;
        /**
         * Provides a simple default listing of tests.
         *
         * Should look roughly like the test listing in v2 and earlier versions
         * of Catch2. Especially supports low-verbosity listing that mimics the
         * old `--list-test-names-only` output.
         */
        void listTests( std::vector<TestCaseHandle> const& tests ) override;
        /**
         * Provides a simple default listing of tags.
         *
         * Should look roughly like the tag listing in v2 and earlier versions
         * of Catch2.
         */
        void listTags( std::vector<TagInfo> const& tags ) override;
    };
} // namespace Catch

#endif // CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED

#include <vector>

namespace Catch {

    class StreamingReporterBase : public ReporterBase {
    public:
        // GCC5 compat: we cannot use inherited constructor, because it
        //              doesn't implement backport of P0136
        StreamingReporterBase(ReporterConfig&& _config):
            ReporterBase(CATCH_MOVE(_config))
        {}
        ~StreamingReporterBase() override;

        void benchmarkPreparing( StringRef ) override {}
        void benchmarkStarting( BenchmarkInfo const& ) override {}
        void benchmarkEnded( BenchmarkStats<> const& ) override {}
        void benchmarkFailed( StringRef ) override {}

        void fatalErrorEncountered( StringRef /*error*/ ) override {}
        void noMatchingTestCases( StringRef /*unmatchedSpec*/ ) override {}
        void reportInvalidTestSpec( StringRef /*invalidArgument*/ ) override {}

        void testRunStarting( TestRunInfo const& _testRunInfo ) override;

        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
            currentTestCaseInfo = &_testInfo;
        }
        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
        void sectionStarting(SectionInfo const& _sectionInfo) override {
            m_sectionStack.push_back(_sectionInfo);
        }

        void assertionStarting( AssertionInfo const& ) override {}
        void assertionEnded( AssertionStats const& ) override {}

        void sectionEnded(SectionStats const& /* _sectionStats */) override {
            m_sectionStack.pop_back();
        }
        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
            currentTestCaseInfo = nullptr;
        }
        void testRunEnded( TestRunStats const& /* _testRunStats */ ) override;

        void skipTest(TestCaseInfo const&) override {
            // Don't do anything with this by default.
            // It can optionally be overridden in the derived class.
        }

    protected:
        TestRunInfo currentTestRunInfo{ "test run has not started yet"_sr };
        TestCaseInfo const* currentTestCaseInfo = nullptr;

        //! Stack of all _active_ sections in the _current_ test case
        std::vector<SectionInfo> m_sectionStack;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED

#include <string>

namespace Catch {

    class AutomakeReporter final : public StreamingReporterBase {
    public:
        // GCC5 compat: we cannot use inherited constructor, because it
        //              doesn't implement backport of P0136
        AutomakeReporter( ReporterConfig&& _config ):
            StreamingReporterBase( CATCH_MOVE( _config ) ) {
            m_preferences.shouldReportAllAssertionStarts = false;
        }

        ~AutomakeReporter() override;

        static std::string getDescription() {
            using namespace std::string_literals;
            return "Reports test results in the format of Automake .trs files"s;
        }

        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
        void skipTest(TestCaseInfo const& testInfo) override;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED


#ifndef CATCH_REPORTER_COMPACT_HPP_INCLUDED
#define CATCH_REPORTER_COMPACT_HPP_INCLUDED




namespace Catch {

    class CompactReporter final : public StreamingReporterBase {
    public:
        CompactReporter( ReporterConfig&& _config ):
            StreamingReporterBase( CATCH_MOVE( _config ) ) {
            m_preferences.shouldReportAllAssertionStarts = false;
        }

        ~CompactReporter() override;

        static std::string getDescription();

        void noMatchingTestCases( StringRef unmatchedSpec ) override;

        void testRunStarting( TestRunInfo const& _testInfo ) override;

        void assertionEnded(AssertionStats const& _assertionStats) override;

        void sectionEnded(SectionStats const& _sectionStats) override;

        void testRunEnded(TestRunStats const& _testRunStats) override;

    };

} // end namespace Catch

#endif // CATCH_REPORTER_COMPACT_HPP_INCLUDED


#ifndef CATCH_REPORTER_CONSOLE_HPP_INCLUDED
#define CATCH_REPORTER_CONSOLE_HPP_INCLUDED


namespace Catch {
    // Fwd decls
    class TablePrinter;

    class ConsoleReporter final : public StreamingReporterBase {
        Detail::unique_ptr<TablePrinter> m_tablePrinter;

    public:
        ConsoleReporter(ReporterConfig&& config);
        ~ConsoleReporter() override;
        static std::string getDescription();

        void noMatchingTestCases( StringRef unmatchedSpec ) override;
        void reportInvalidTestSpec( StringRef arg ) override;

        void assertionEnded(AssertionStats const& _assertionStats) override;

        void sectionStarting(SectionInfo const& _sectionInfo) override;
        void sectionEnded(SectionStats const& _sectionStats) override;

        void benchmarkPreparing( StringRef name ) override;
        void benchmarkStarting(BenchmarkInfo const& info) override;
        void benchmarkEnded(BenchmarkStats<> const& stats) override;
        void benchmarkFailed( StringRef error ) override;

        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
        void testRunEnded(TestRunStats const& _testRunStats) override;
        void testRunStarting(TestRunInfo const& _testRunInfo) override;

    private:
        void lazyPrint();

        void lazyPrintWithoutClosingBenchmarkTable();
        void lazyPrintRunInfo();
        void printTestCaseAndSectionHeader();

        void printClosedHeader(std::string const& _name);
        void printOpenHeader(std::string const& _name);

        // if string has a : in first line will set indent to follow it on
        // subsequent lines
        void printHeaderString(std::string const& _string, std::size_t indent = 0);

        void printTotalsDivider(Totals const& totals);

        bool m_headerPrinted = false;
        bool m_testRunInfoPrinted = false;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_CONSOLE_HPP_INCLUDED


#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED


#include <string>
#include <vector>

namespace Catch {

    namespace Detail {

        //! Represents either an assertion or a benchmark result to be handled by cumulative reporter later
        class AssertionOrBenchmarkResult {
            // This should really be a variant, but this is much faster
            // to write and the data layout here is already terrible
            // enough that we do not have to care about the object size.
            Optional<AssertionStats> m_assertion;
            Optional<BenchmarkStats<>> m_benchmark;
        public:
            AssertionOrBenchmarkResult(AssertionStats const& assertion);
            AssertionOrBenchmarkResult(BenchmarkStats<> const& benchmark);

            bool isAssertion() const;
            bool isBenchmark() const;

            AssertionStats const& asAssertion() const;
            BenchmarkStats<> const& asBenchmark() const;
        };
    }

    /**
     * Utility base for reporters that need to handle all results at once
     *
     * It stores tree of all test cases, sections and assertions, and after the
     * test run is finished, calls into `testRunEndedCumulative` to pass the
     * control to the deriving class.
     *
     * If you are deriving from this class and override any testing related
     * member functions, you should first call into the base's implementation to
     * avoid breaking the tree construction.
     *
     * Due to the way this base functions, it has to expand assertions up-front,
     * even if they are later unused (e.g. because the deriving reporter does
     * not report successful assertions, or because the deriving reporter does
     * not use assertion expansion at all). Derived classes can use two
     * customization points, `m_shouldStoreSuccesfulAssertions` and
     * `m_shouldStoreFailedAssertions`, to disable the expansion and gain extra
     * performance. **Accessing the assertion expansions if it wasn't stored is
     * UB.**
     */
    class CumulativeReporterBase : public ReporterBase {
    public:
        template<typename T, typename ChildNodeT>
        struct Node {
            explicit Node( T const& _value ) : value( _value ) {}

            using ChildNodes = std::vector<Detail::unique_ptr<ChildNodeT>>;
            T value;
            ChildNodes children;
        };
        struct SectionNode {
            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}

            bool operator == (SectionNode const& other) const {
                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
            }

            bool hasAnyAssertions() const;

            SectionStats stats;
            std::vector<Detail::unique_ptr<SectionNode>> childSections;
            std::vector<Detail::AssertionOrBenchmarkResult> assertionsAndBenchmarks;
            std::string stdOut;
            std::string stdErr;
        };


        using TestCaseNode = Node<TestCaseStats, SectionNode>;
        using TestRunNode = Node<TestRunStats, TestCaseNode>;

        // GCC5 compat: we cannot use inherited constructor, because it
        //              doesn't implement backport of P0136
        CumulativeReporterBase(ReporterConfig&& _config):
            ReporterBase(CATCH_MOVE(_config))
        {}
        ~CumulativeReporterBase() override;

        void benchmarkPreparing( StringRef ) override {}
        void benchmarkStarting( BenchmarkInfo const& ) override {}
        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
        void benchmarkFailed( StringRef ) override {}

        void noMatchingTestCases( StringRef ) override {}
        void reportInvalidTestSpec( StringRef ) override {}
        void fatalErrorEncountered( StringRef /*error*/ ) override {}

        void testRunStarting( TestRunInfo const& ) override {}

        void testCaseStarting( TestCaseInfo const& ) override {}
        void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
        void sectionStarting( SectionInfo const& sectionInfo ) override;

        void assertionStarting( AssertionInfo const& ) override {}

        void assertionEnded( AssertionStats const& assertionStats ) override;
        void sectionEnded( SectionStats const& sectionStats ) override;
        void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
        void testRunEnded( TestRunStats const& testRunStats ) override;
        //! Customization point: called after last test finishes (testRunEnded has been handled)
        virtual void testRunEndedCumulative() = 0;

        void skipTest(TestCaseInfo const&) override {}

    protected:
        //! Should the cumulative base store the assertion expansion for successful assertions?
        bool m_shouldStoreSuccesfulAssertions = true;
        //! Should the cumulative base store the assertion expansion for failed assertions?
        bool m_shouldStoreFailedAssertions = true;

        // We need lazy construction here. We should probably refactor it
        // later, after the events are redone.
        //! The root node of the test run tree.
        Detail::unique_ptr<TestRunNode> m_testRun;

    private:
        // Note: We rely on pointer identity being stable, which is why
        //       we store pointers to the nodes rather than the values.
        std::vector<Detail::unique_ptr<TestCaseNode>> m_testCases;
        // Root section of the _current_ test case
        Detail::unique_ptr<SectionNode> m_rootSection;
        // Deepest section of the _current_ test case
        SectionNode* m_deepestSection = nullptr;
        // Stack of _active_ sections in the _current_ test case
        std::vector<SectionNode*> m_sectionStack;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED


#ifndef CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
#define CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED


namespace Catch {

    /**
     * Base class to simplify implementing listeners.
     *
     * Provides empty default implementation for all IEventListener member
     * functions, so that a listener implementation can pick which
     * member functions it actually cares about.
     */
    class EventListenerBase : public IEventListener {
    public:
        using IEventListener::IEventListener;

        void reportInvalidTestSpec( StringRef unmatchedSpec ) override;
        void fatalErrorEncountered( StringRef error ) override;

        void benchmarkPreparing( StringRef name ) override;
        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
        void benchmarkFailed( StringRef error ) override;

        void assertionStarting( AssertionInfo const& assertionInfo ) override;
        void assertionEnded( AssertionStats const& assertionStats ) override;

        void listReporters(
            std::vector<ReporterDescription> const& descriptions ) override;
        void listListeners(
            std::vector<ListenerDescription> const& descriptions ) override;
        void listTests( std::vector<TestCaseHandle> const& tests ) override;
        void listTags( std::vector<TagInfo> const& tagInfos ) override;

        void noMatchingTestCases( StringRef unmatchedSpec ) override;
        void testRunStarting( TestRunInfo const& testRunInfo ) override;
        void testCaseStarting( TestCaseInfo const& testInfo ) override;
        void testCasePartialStarting( TestCaseInfo const& testInfo,
                                      uint64_t partNumber ) override;
        void sectionStarting( SectionInfo const& sectionInfo ) override;
        void sectionEnded( SectionStats const& sectionStats ) override;
        void testCasePartialEnded( TestCaseStats const& testCaseStats,
                                   uint64_t partNumber ) override;
        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
        void testRunEnded( TestRunStats const& testRunStats ) override;
        void skipTest( TestCaseInfo const& testInfo ) override;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED


#ifndef CATCH_REPORTER_HELPERS_HPP_INCLUDED
#define CATCH_REPORTER_HELPERS_HPP_INCLUDED

#include <iosfwd>
#include <string>
#include <vector>


namespace Catch {

    class IConfig;
    class TestCaseHandle;
    class ColourImpl;

    // Returns double formatted as %.3f (format expected on output)
    std::string getFormattedDuration( double duration );

    //! Should the reporter show duration of test given current configuration?
    bool shouldShowDuration( IConfig const& config, double duration );

    std::string serializeFilters( std::vector<std::string> const& filters );

    struct lineOfChars {
        char c;
        constexpr lineOfChars( char c_ ): c( c_ ) {}

        friend std::ostream& operator<<( std::ostream& out, lineOfChars value );
    };

    /**
     * Lists reporter descriptions to the provided stream in user-friendly
     * format
     *
     * Used as the default listing implementation by the first party reporter
     * bases. The output should be backwards compatible with the output of
     * Catch2 v2 binaries.
     */
    void
    defaultListReporters( std::ostream& out,
                          std::vector<ReporterDescription> const& descriptions,
                          Verbosity verbosity );

    /**
     * Lists listeners descriptions to the provided stream in user-friendly
     * format
     */
    void defaultListListeners( std::ostream& out,
                               std::vector<ListenerDescription> const& descriptions );

    /**
     * Lists tag information to the provided stream in user-friendly format
     *
     * Used as the default listing implementation by the first party reporter
     * bases. The output should be backwards compatible with the output of
     * Catch2 v2 binaries.
     */
    void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered );

    /**
     * Lists test case information to the provided stream in user-friendly
     * format
     *
     * Used as the default listing implementation by the first party reporter
     * bases. The output is backwards compatible with the output of Catch2
     * v2 binaries, and also supports the format specific to the old
     * `--list-test-names-only` option, for people who used it in integrations.
     */
    void defaultListTests( std::ostream& out,
                           ColourImpl* streamColour,
                           std::vector<TestCaseHandle> const& tests,
                           bool isFiltered,
                           Verbosity verbosity );

    /**
     * Prints test run totals to the provided stream in user-friendly format
     *
     * Used by the console and compact reporters.
     */
    void printTestRunTotals( std::ostream& stream,
                      ColourImpl& streamColour,
                      Totals const& totals );

} // end namespace Catch

#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED



#ifndef CATCH_REPORTER_JSON_HPP_INCLUDED
#define CATCH_REPORTER_JSON_HPP_INCLUDED


#include <stack>

namespace Catch {
    class JsonReporter : public StreamingReporterBase {
    public:
        JsonReporter( ReporterConfig&& config );

        ~JsonReporter() override;

        static std::string getDescription();

    public: // StreamingReporterBase
        void testRunStarting( TestRunInfo const& runInfo ) override;
        void testRunEnded( TestRunStats const& runStats ) override;

        void testCaseStarting( TestCaseInfo const& tcInfo ) override;
        void testCaseEnded( TestCaseStats const& tcStats ) override;

        void testCasePartialStarting( TestCaseInfo const& tcInfo,
                                      uint64_t index ) override;
        void testCasePartialEnded( TestCaseStats const& tcStats,
                                   uint64_t index ) override;

        void sectionStarting( SectionInfo const& sectionInfo ) override;
        void sectionEnded( SectionStats const& sectionStats ) override;

        void assertionEnded( AssertionStats const& assertionStats ) override;

        //void testRunEndedCumulative() override;

        void benchmarkPreparing( StringRef name ) override;
        void benchmarkStarting( BenchmarkInfo const& ) override;
        void benchmarkEnded( BenchmarkStats<> const& ) override;
        void benchmarkFailed( StringRef error ) override;

        void listReporters(
            std::vector<ReporterDescription> const& descriptions ) override;
        void listListeners(
            std::vector<ListenerDescription> const& descriptions ) override;
        void listTests( std::vector<TestCaseHandle> const& tests ) override;
        void listTags( std::vector<TagInfo> const& tags ) override;

    private:
        Timer m_testCaseTimer;
        enum class Writer {
            Object,
            Array
        };

        JsonArrayWriter& startArray();
        JsonArrayWriter& startArray( StringRef key );

        JsonObjectWriter& startObject();
        JsonObjectWriter& startObject( StringRef key );

        void endObject();
        void endArray();

        bool isInside( Writer writer );

        void startListing();
        void endListing();

        // Invariant:
        // When m_writers is not empty and its top element is
        // - Writer::Object, then m_objectWriters is not be empty
        // - Writer::Array,  then m_arrayWriters shall not be empty
        std::stack<JsonObjectWriter> m_objectWriters{};
        std::stack<JsonArrayWriter> m_arrayWriters{};
        std::stack<Writer> m_writers{};

        bool m_startedListing = false;

        // std::size_t m_sectionDepth = 0;
        // std::size_t m_sectionStarted = 0;
    };
} // namespace Catch

#endif // CATCH_REPORTER_JSON_HPP_INCLUDED


#ifndef CATCH_REPORTER_JUNIT_HPP_INCLUDED
#define CATCH_REPORTER_JUNIT_HPP_INCLUDED



namespace Catch {

    class JunitReporter final : public CumulativeReporterBase {
    public:
        JunitReporter(ReporterConfig&& _config);

        static std::string getDescription();

        void testRunStarting(TestRunInfo const& runInfo) override;

        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
        void assertionEnded(AssertionStats const& assertionStats) override;

        void testCaseEnded(TestCaseStats const& testCaseStats) override;

        void testRunEndedCumulative() override;

    private:
        void writeRun(TestRunNode const& testRunNode, double suiteTime);

        void writeTestCase(TestCaseNode const& testCaseNode);

        void writeSection( std::string const& className,
                           std::string const& rootName,
                           SectionNode const& sectionNode,
                           bool testOkToFail );

        void writeAssertions(SectionNode const& sectionNode);
        void writeAssertion(AssertionStats const& stats);

        XmlWriter xml;
        Timer suiteTimer;
        std::string stdOutForSuite;
        std::string stdErrForSuite;
        unsigned int unexpectedExceptions = 0;
        bool m_okToFail = false;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_JUNIT_HPP_INCLUDED


#ifndef CATCH_REPORTER_MULTI_HPP_INCLUDED
#define CATCH_REPORTER_MULTI_HPP_INCLUDED


namespace Catch {

    class MultiReporter final : public IEventListener {
        /*
         * Stores all added reporters and listeners
         *
         * All Listeners are stored before all reporters, and individual
         * listeners/reporters are stored in order of insertion.
         */
        std::vector<IEventListenerPtr> m_reporterLikes;
        bool m_haveNoncapturingReporters = false;

        // Keep track of how many listeners we have already inserted,
        // so that we can insert them into the main vector at the right place
        size_t m_insertedListeners = 0;

        void updatePreferences(IEventListener const& reporterish);

    public:
        MultiReporter( IConfig const* config ):
            IEventListener( config ) {
            m_preferences.shouldReportAllAssertionStarts = false;
        }

        using IEventListener::IEventListener;

        void addListener( IEventListenerPtr&& listener );
        void addReporter( IEventListenerPtr&& reporter );

    public: // IEventListener

        void noMatchingTestCases( StringRef unmatchedSpec ) override;
        void fatalErrorEncountered( StringRef error ) override;
        void reportInvalidTestSpec( StringRef arg ) override;

        void benchmarkPreparing( StringRef name ) override;
        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
        void benchmarkFailed( StringRef error ) override;

        void testRunStarting( TestRunInfo const& testRunInfo ) override;
        void testCaseStarting( TestCaseInfo const& testInfo ) override;
        void testCasePartialStarting(TestCaseInfo const& testInfo, uint64_t partNumber) override;
        void sectionStarting( SectionInfo const& sectionInfo ) override;
        void assertionStarting( AssertionInfo const& assertionInfo ) override;

        void assertionEnded( AssertionStats const& assertionStats ) override;
        void sectionEnded( SectionStats const& sectionStats ) override;
        void testCasePartialEnded(TestCaseStats const& testStats, uint64_t partNumber) override;
        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
        void testRunEnded( TestRunStats const& testRunStats ) override;

        void skipTest( TestCaseInfo const& testInfo ) override;

        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
        void listTests(std::vector<TestCaseHandle> const& tests) override;
        void listTags(std::vector<TagInfo> const& tags) override;


    };

} // end namespace Catch

#endif // CATCH_REPORTER_MULTI_HPP_INCLUDED


#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED


#include <type_traits>

namespace Catch {

    namespace Detail {

        template <typename T, typename = void>
        struct has_description : std::false_type {};

        template <typename T>
        struct has_description<
            T,
            void_t<decltype( T::getDescription() )>>
            : std::true_type {};

        //! Indirection for reporter registration, so that the error handling is
        //! independent on the reporter's concrete type
        void registerReporterImpl( std::string const& name,
                                   IReporterFactoryPtr reporterPtr );
        //! Actually registers the factory, independent on listener's concrete type
        void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory );
    } // namespace Detail

    class IEventListener;
    using IEventListenerPtr = Detail::unique_ptr<IEventListener>;

    template <typename T>
    class ReporterFactory : public IReporterFactory {

        IEventListenerPtr create( ReporterConfig&& config ) const override {
            return Detail::make_unique<T>( CATCH_MOVE(config) );
        }

        std::string getDescription() const override {
            return T::getDescription();
        }
    };


    template<typename T>
    class ReporterRegistrar {
    public:
        explicit ReporterRegistrar( std::string const& name ) {
            registerReporterImpl( name,
                                  Detail::make_unique<ReporterFactory<T>>() );
        }
    };

    template<typename T>
    class ListenerRegistrar {

        class TypedListenerFactory : public EventListenerFactory {
            StringRef m_listenerName;

            std::string getDescriptionImpl( std::true_type ) const {
                return T::getDescription();
            }

            std::string getDescriptionImpl( std::false_type ) const {
                return "(No description provided)";
            }

        public:
            TypedListenerFactory( StringRef listenerName ):
                m_listenerName( listenerName ) {}

            IEventListenerPtr create( IConfig const* config ) const override {
                return Detail::make_unique<T>( config );
            }

            StringRef getName() const override {
                return m_listenerName;
            }

            std::string getDescription() const override {
                return getDescriptionImpl( Detail::has_description<T>{} );
            }
        };

    public:
        ListenerRegistrar(StringRef listenerName) {
            registerListenerImpl( Detail::make_unique<TypedListenerFactory>(listenerName) );
        }
    };
}

#if !defined(CATCH_CONFIG_DISABLE)

#    define CATCH_REGISTER_REPORTER( name, reporterType )                  \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                          \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                           \
        namespace {                                                        \
            const Catch::ReporterRegistrar<reporterType>                   \
                INTERNAL_CATCH_UNIQUE_NAME( catch_internal_RegistrarFor )( \
                    name );                                                \
        }                                                                  \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#    define CATCH_REGISTER_LISTENER( listenerType )                        \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                          \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                           \
        namespace {                                                        \
            const Catch::ListenerRegistrar<listenerType>                   \
                INTERNAL_CATCH_UNIQUE_NAME( catch_internal_RegistrarFor )( \
                    #listenerType##_catch_sr );                            \
        }                                                                  \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#else // CATCH_CONFIG_DISABLE

#define CATCH_REGISTER_REPORTER(name, reporterType)
#define CATCH_REGISTER_LISTENER(listenerType)

#endif // CATCH_CONFIG_DISABLE

#endif // CATCH_REPORTER_REGISTRARS_HPP_INCLUDED


#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED



namespace Catch {

    class SonarQubeReporter final : public CumulativeReporterBase {
    public:
        SonarQubeReporter(ReporterConfig&& config)
        : CumulativeReporterBase(CATCH_MOVE(config))
        , xml(m_stream) {
            m_preferences.shouldRedirectStdOut = true;
            m_preferences.shouldReportAllAssertions = false;
            m_preferences.shouldReportAllAssertionStarts = false;
            m_shouldStoreSuccesfulAssertions = false;
        }

        static std::string getDescription() {
            using namespace std::string_literals;
            return "Reports test results in the Generic Test Data SonarQube XML format"s;
        }

        void testRunStarting( TestRunInfo const& testRunInfo ) override;

        void testRunEndedCumulative() override {
            writeRun( *m_testRun );
            xml.endElement();
        }

        void writeRun( TestRunNode const& runNode );

        void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);

        void writeTestCase(TestCaseNode const& testCaseNode);

        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail);

        void writeAssertions(SectionNode const& sectionNode, bool okToFail);

        void writeAssertion(AssertionStats const& stats, bool okToFail);

    private:
        XmlWriter xml;
    };


} // end namespace Catch

#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED


#ifndef CATCH_REPORTER_TAP_HPP_INCLUDED
#define CATCH_REPORTER_TAP_HPP_INCLUDED


namespace Catch {

    class TAPReporter final : public StreamingReporterBase {
    public:
        TAPReporter( ReporterConfig&& config ):
            StreamingReporterBase( CATCH_MOVE(config) ) {
            m_preferences.shouldReportAllAssertions = true;
            m_preferences.shouldReportAllAssertionStarts = false;
        }

        static std::string getDescription() {
            using namespace std::string_literals;
            return "Reports test results in TAP format, suitable for test harnesses"s;
        }

        void testRunStarting( TestRunInfo const& testInfo ) override;

        void noMatchingTestCases( StringRef unmatchedSpec ) override;

        void assertionEnded(AssertionStats const& _assertionStats) override;

        void testRunEnded(TestRunStats const& _testRunStats) override;

    private:
        std::size_t counter = 0;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_TAP_HPP_INCLUDED


#ifndef CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
#define CATCH_REPORTER_TEAMCITY_HPP_INCLUDED


#include <cstring>

#ifdef __clang__
#   pragma clang diagnostic push
#   pragma clang diagnostic ignored "-Wpadded"
#endif

namespace Catch {

    class TeamCityReporter final : public StreamingReporterBase {
    public:
        TeamCityReporter( ReporterConfig&& _config )
        :   StreamingReporterBase( CATCH_MOVE(_config) )
        {
            m_preferences.shouldRedirectStdOut = true;
            m_preferences.shouldReportAllAssertionStarts = false;
        }

        ~TeamCityReporter() override;

        static std::string getDescription() {
            using namespace std::string_literals;
            return "Reports test results as TeamCity service messages"s;
        }

        void testRunStarting( TestRunInfo const& runInfo ) override;
        void testRunEnded( TestRunStats const& runStats ) override;


        void assertionEnded(AssertionStats const& assertionStats) override;

        void sectionStarting(SectionInfo const& sectionInfo) override {
            m_headerPrintedForThisSection = false;
            StreamingReporterBase::sectionStarting( sectionInfo );
        }

        void testCaseStarting(TestCaseInfo const& testInfo) override;

        void testCaseEnded(TestCaseStats const& testCaseStats) override;

    private:
        void printSectionHeader(std::ostream& os);

        bool m_headerPrintedForThisSection = false;
        Timer m_testTimer;
    };

} // end namespace Catch

#ifdef __clang__
#   pragma clang diagnostic pop
#endif

#endif // CATCH_REPORTER_TEAMCITY_HPP_INCLUDED


#ifndef CATCH_REPORTER_XML_HPP_INCLUDED
#define CATCH_REPORTER_XML_HPP_INCLUDED




namespace Catch {
    class XmlReporter : public StreamingReporterBase {
    public:
        XmlReporter(ReporterConfig&& _config);

        ~XmlReporter() override;

        static std::string getDescription();

        virtual std::string getStylesheetRef() const;

        void writeSourceInfo(SourceLineInfo const& sourceInfo);

    public: // StreamingReporterBase

        void testRunStarting(TestRunInfo const& testInfo) override;

        void testCaseStarting(TestCaseInfo const& testInfo) override;

        void sectionStarting(SectionInfo const& sectionInfo) override;

        void assertionEnded(AssertionStats const& assertionStats) override;

        void sectionEnded(SectionStats const& sectionStats) override;

        void testCaseEnded(TestCaseStats const& testCaseStats) override;

        void testRunEnded(TestRunStats const& testRunStats) override;

        void benchmarkPreparing( StringRef name ) override;
        void benchmarkStarting(BenchmarkInfo const&) override;
        void benchmarkEnded(BenchmarkStats<> const&) override;
        void benchmarkFailed( StringRef error ) override;

        void listReporters(std::vector<ReporterDescription> const& descriptions) override;
        void listListeners(std::vector<ListenerDescription> const& descriptions) override;
        void listTests(std::vector<TestCaseHandle> const& tests) override;
        void listTags(std::vector<TagInfo> const& tags) override;

    private:
        Timer m_testCaseTimer;
        XmlWriter m_xml;
        int m_sectionDepth = 0;
    };

} // end namespace Catch

#endif // CATCH_REPORTER_XML_HPP_INCLUDED

#endif // CATCH_REPORTERS_ALL_HPP_INCLUDED

#endif // CATCH_ALL_HPP_INCLUDED
#endif // CATCH_AMALGAMATED_HPP_INCLUDED


================================================
FILE: test/levels/Beech kick 1.lvl
================================================
64
0
"Beech kick"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199836
-200438
24
54
0
0
0
0
-199904
-200384
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200384
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200384
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200384
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200384
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199424
-200224
-1
55
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199424
-200128
-1
119
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199488
-200224
-1
45
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199488
-200128
-1
45
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199360
-200224
-1
5
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199360
-200128
-1
5
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Beech kick 2.lvl
================================================
64
0
"Kick55"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199660
-200470
24
54
0
0
0
0
-200000
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200416
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200384
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200288
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200192
32
32
48
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200128
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200064
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199296
-200160
-1
119
#TRUE#
1
1
5
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199424
-200352
-1
45
#TRUE#
1
1
1
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199424
-200256
-1
45
#TRUE#
1
1
1
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199424
-200160
-1
45
#TRUE#
1
1
1
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199296
-200352
-1
55
#TRUE#
1
1
5
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199296
-200256
-1
55
#TRUE#
1
1
5
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Conveyor hell.lvl
================================================
64
0
"Conveyor hell"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199612
-200310
24
54
0
0
0
0
-200000
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200256
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200160
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200128
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200256
32
32
169
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200256
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200160
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200128
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200096
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-200064
-200064
71
"Default"
-200032
-200064
71
"Default"
-200000
-200064
71
"Default"
-199968
-200064
71
"Default"
-199936
-200064
71
"Default"
-199904
-200064
71
"Default"
-199872
-200064
71
"Default"
-199840
-200064
71
"Default"
-199808
-200064
71
"Default"
-199776
-200064
71
"Default"
-199744
-200064
71
"Default"
-199712
-200064
71
"Default"
-199680
-200064
71
"Default"
-199648
-200064
71
"Default"
-199616
-200064
71
"Default"
-199584
-200064
71
"Default"
-199552
-200064
71
"Default"
-199520
-200064
71
"Default"
-199488
-200064
71
"Default"
-199456
-200064
71
"Default"
-199424
-200064
71
"Default"
-199392
-200064
71
"Default"
-199360
-200064
71
"Default"
-199328
-200064
71
"Default"
-199296
-200064
71
"Default"
-199264
-200064
71
"Default"
-199232
-200080
73
"Default"
"next"
-199744
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199712
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199680
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199648
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199616
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199584
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199552
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199488
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199520
-200128
-1
57
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199248
-200112
1
104
#TRUE#
2
1
1
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Exits test.lvl
================================================
64
0
"Exits test"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199900
-200182
24
54
0
0
0
0
-199968
-200128
128
800
28
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-199520
-200192
35
"Default"
-199648
-200192
107
"Default"
"next"
-199968
-200160
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199248
-200224
-1
197
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"bonus"
""
""
""
""
""
-199840
-200160
-1
16
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199776
-200160
-1
41
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199712
-200224
-1
11
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"bonus"
""
"hide"
""
""
""
-199552
-200160
-1
31
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
-199648
-200160
-199648
-200160
1
1
2
""
0
#FALSE#
#TRUE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"bonus"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"hide"
""
0
0
"bonus"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Fall test.lvl
================================================
64
0
"Fall test"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
48
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199852
-200086
24
54
0
0
0
0
-200000
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-200000
-200448
55
"Default"
-199968
-200448
55
"Default"
-199936
-200448
55
"Default"
-199904
-200448
55
"Default"
-199872
-200448
55
"Default"
-199840
-200448
55
"Default"
-199808
-200448
55
"Default"
-199776
-200448
55
"Default"
-199744
-200448
55
"Default"
-199712
-200448
55
"Default"
-199680
-200448
55
"Default"
-199648
-200448
55
"Default"
-199616
-200448
55
"Default"
-199584
-200448
55
"Default"
-199552
-200448
55
"Default"
-199520
-200448
55
"Default"
-199488
-200448
55
"Default"
-199456
-200448
55
"Default"
-199424
-200448
55
"Default"
-199392
-200448
55
"Default"
-199360
-200448
55
"Default"
-199328
-200448
55
"Default"
-199296
-200448
55
"Default"
-199264
-200448
55
"Default"
-199232
-200448
55
"Default"
-199696
-200176
70
"Default"
-199568
-200176
70
"Default"
-199440
-200176
70
"Default"
-199824
-200176
70
"Default"
-199952
-200176
70
"Default"
-199312
-200176
70
"Default"
-199936
-200512
71
"Default"
-199904
-200512
71
"Default"
-199872
-200512
71
"Default"
-199840
-200512
71
"Default"
-199808
-200512
71
"Default"
-199776
-200512
71
"Default"
-199744
-200512
71
"Default"
-199712
-200512
71
"Default"
-199680
-200512
71
"Default"
-199648
-200512
71
"Default"
-199616
-200512
71
"Default"
-199584
-200512
71
"Default"
-199552
-200512
71
"Default"
-199520
-200512
71
"Default"
-199488
-200512
71
"Default"
-199456
-200512
71
"Default"
-199424
-200512
71
"Default"
-199392
-200512
71
"Default"
-199360
-200512
71
"Default"
-199328
-200512
71
"Default"
-199296
-200512
71
"Default"
-199968
-200512
70
"Default"
-199264
-200512
70
"Default"
-199232
-200160
70
"Default"
-199232
-200416
70
"Default"
-199232
-200384
72
"Default"
-199232
-200352
72
"Default"
-199232
-200320
72
"Default"
-199232
-200288
72
"Default"
-199232
-200256
72
"Default"
-199232
-200224
72
"Default"
-199232
-200192
72
"Default"
"next"
-199904
-200064
-1
182
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199808
-200064
-1
264
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199728
-200416
1
104
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200052
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199856
-200416
1
62
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199600
-200416
1
66
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199472
-200416
1
60
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199984
-200416
1
64
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199320
-200416
-1
179
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200512
1
104
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199504
-200512
1
104
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199360
-200512
1
104
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199264
-200352
1
104
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Fence climb Move.lvl
================================================
64
0
"Fence climb Move"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
27
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199852
-200086
24
54
0
0
0
0
-200000
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200160
32
32
169
0
#FALSE#
#FALSE#
"Default"
""
"HideShow Fence"
""
-199904
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200128
32
32
54
0
#FALSE#
#FALSE#
"I like to move move"
""
""
""
-199552
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200128
32
32
54
0
#FALSE#
#FALSE#
"I like to move move"
""
""
""
-199520
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200128
32
32
54
0
#FALSE#
#FALSE#
"I like to move move"
""
""
""
-199488
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200128
32
32
54
0
#FALSE#
#FALSE#
"I like to move move"
""
""
""
-199456
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200128
32
32
54
0
#FALSE#
#FALSE#
"I like to move move"
""
""
""
-199424
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200128
32
32
54
0
#FALSE#
#FALSE#
"I like to move move"
""
""
""
-199392
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-199744
-200512
182
"fence"
-199744
-200480
182
"fence"
-199744
-200448
182
"fence"
-199744
-200416
182
"fence"
-199744
-200384
182
"fence"
-199744
-200352
182
"fence"
-199744
-200320
182
"fence"
-199744
-200288
182
"fence"
-199744
-200256
182
"fence"
-199744
-200224
182
"fence"
-199744
-200192
182
"fence"
-199744
-200160
182
"fence"
-199744
-200128
182
"fence"
-199744
-200096
182
"fence"
-199744
-200064
182
"fence"
-199712
-200512
182
"fence"
-199712
-200480
182
"fence"
-199712
-200448
182
"fence"
-199712
-200416
182
"fence"
-199712
-200384
182
"fence"
-199712
-200352
182
"fence"
-199712
-200320
182
"fence"
-199712
-200288
182
"fence"
-199712
-200256
182
"fence"
-199712
-200224
182
"fence"
-199712
-200192
182
"fence"
-199712
-200160
182
"fence"
-199712
-200128
182
"fence"
-199712
-200096
182
"fence"
-199712
-200064
182
"fence"
-199680
-200512
182
"fence"
-199680
-200480
182
"fence"
-199680
-200448
182
"fence"
-199680
-200416
182
"fence"
-199680
-200384
182
"fence"
-199680
-200352
182
"fence"
-199680
-200320
182
"fence"
-199680
-200288
182
"fence"
-199680
-200256
182
"fence"
-199680
-200224
182
"fence"
-199680
-200192
182
"fence"
-199680
-200160
182
"fence"
-199680
-200128
182
"fence"
-199680
-200096
182
"fence"
-199680
-200064
182
"fence"
-199648
-200512
182
"fence"
-199648
-200480
182
"fence"
-199648
-200448
182
"fence"
-199648
-200416
182
"fence"
-199648
-200384
182
"fence"
-199648
-200352
182
"fence"
-199648
-200320
182
"fence"
-199648
-200288
182
"fence"
-199648
-200256
182
"fence"
-199648
-200224
182
"fence"
-199648
-200192
182
"fence"
-199648
-200160
182
"fence"
-199648
-200128
182
"fence"
-199648
-200096
182
"fence"
-199648
-200064
182
"fence"
-199616
-200512
182
"fence"
-199616
-200480
182
"fence"
-199616
-200448
182
"fence"
-199616
-200416
182
"fence"
-199616
-200384
182
"fence"
-199616
-200352
182
"fence"
-199616
-200320
182
"fence"
-199616
-200288
182
"fence"
-199616
-200256
182
"fence"
-199616
-200224
182
"fence"
-199616
-200192
182
"fence"
-199616
-200160
182
"fence"
-199616
-200128
182
"fence"
-199616
-200096
182
"fence"
-199616
-200064
182
"fence"
-199584
-200512
182
"fence"
-199584
-200480
182
"fence"
-199584
-200448
182
"fence"
-199584
-200416
182
"fence"
-199584
-200384
182
"fence"
-199584
-200352
182
"fence"
-199584
-200320
182
"fence"
-199584
-200288
182
"fence"
-199584
-200256
182
"fence"
-199584
-200224
182
"fence"
-199584
-200192
182
"fence"
-199584
-200160
182
"fence"
-199584
-200128
182
"fence"
-199584
-200096
182
"fence"
-199584
-200064
182
"fence"
-199552
-200512
182
"fence"
-199552
-200480
182
"fence"
-199552
-200448
182
"fence"
-199552
-200416
182
"fence"
-199552
-200384
182
"fence"
-199552
-200352
182
"fence"
-199552
-200320
182
"fence"
-199552
-200288
182
"fence"
-199552
-200256
182
"fence"
-199552
-200224
182
"fence"
-199552
-200192
182
"fence"
-199552
-200160
182
"fence"
-199552
-200128
182
"fence"
-199552
-200096
182
"fence"
-199552
-200064
182
"fence"
-199520
-200512
182
"fence"
-199520
-200480
182
"fence"
-199520
-200448
182
"fence"
-199520
-200416
182
"fence"
-199520
-200384
182
"fence"
-199520
-200352
182
"fence"
-199520
-200320
182
"fence"
-199520
-200288
182
"fence"
-199520
-200256
182
"fence"
-199520
-200224
182
"fence"
-199520
-200192
182
"fence"
-199520
-200160
182
"fence"
-199520
-200128
182
"fence"
-199520
-200096
182
"fence"
-199520
-200064
182
"fence"
-199488
-200512
182
"fence"
-199488
-200480
182
"fence"
-199488
-200448
182
"fence"
-199488
-200416
182
"fence"
-199488
-200384
182
"fence"
-199488
-200352
182
"fence"
-199488
-200320
182
"fence"
-199488
-200288
182
"fence"
-199488
-200256
182
"fence"
-199488
-200224
182
"fence"
-199488
-200192
182
"fence"
-199488
-200160
182
"fence"
-199488
-200128
182
"fence"
-199488
-200096
182
"fence"
-199488
-200064
182
"fence"
-199456
-200512
182
"fence"
-199456
-200480
182
"fence"
-199456
-200448
182
"fence"
-199456
-200416
182
"fence"
-199456
-200384
182
"fence"
-199456
-200352
182
"fence"
-199456
-200320
182
"fence"
-199456
-200288
182
"fence"
-199456
-200256
182
"fence"
-199456
-200224
182
"fence"
-199456
-200192
182
"fence"
-199456
-200160
182
"fence"
-199456
-200128
182
"fence"
-199456
-200096
182
"fence"
-199456
-200064
182
"fence"
-199392
-200224
182
"I like to move move"
-199392
-200256
182
"I like to move move"
-199392
-200288
182
"I like to move move"
-199392
-200320
182
"I like to move move"
-199392
-200352
182
"I like to move move"
-199360
-200352
182
"I like to move move"
-199328
-200352
182
"I like to move move"
-199296
-200352
182
"I like to move move"
-199296
-200320
182
"I like to move move"
-199296
-200288
182
"I like to move move"
-199296
-200256
182
"I like to move move"
-199296
-200224
182
"I like to move move"
-199328
-200224
182
"I like to move move"
-199360
-200224
182
"I like to move move"
-199360
-200256
182
"I like to move move"
-199360
-200288
182
"I like to move move"
-199360
-200320
182
"I like to move move"
-199328
-200320
182
"I like to move move"
-199328
-200288
182
"I like to move move"
-199328
-200256
182
"I like to move move"
"next"
-199256
-200352
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
""
""
""
""
""
-199256
-200320
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
""
""
""
""
""
-199256
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
""
""
""
""
""
-199256
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
""
""
""
""
""
-199256
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
""
""
""
""
""
-199256
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"fence"
#FALSE#
"I like to move move"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"HideShow Fence"
""
0
0
""
""
"fence"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"MoveUp"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"StopUp"
10
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#TRUE#
"I like to move move"
0
-0.492308
0
0
0
"StopUp"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"MoveDown"
10
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
0
0
0
0
0
"MoveDown"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"StopDown"
10
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
0
0.492308
0
0
0
"StopDown"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"MoveUp"
10
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"I like to move move"
0
0
0
0
0


================================================
FILE: test/levels/Fence climb.lvl
================================================
64
0
"Fence climb"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
27
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199852
-200086
24
54
0
0
0
0
-200000
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200160
32
32
169
0
#FALSE#
#FALSE#
"Default"
""
"HideShow Fence"
""
-199904
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-199744
-200512
182
"fence"
-199744
-200480
182
"fence"
-199744
-200448
182
"fence"
-199744
-200416
182
"fence"
-199744
-200384
182
"fence"
-199744
-200352
182
"fence"
-199744
-200320
182
"fence"
-199744
-200288
182
"fence"
-199744
-200256
182
"fence"
-199744
-200224
182
"fence"
-199744
-200192
182
"fence"
-199744
-200160
182
"fence"
-199744
-200128
182
"fence"
-199744
-200096
182
"fence"
-199744
-200064
182
"fence"
-199712
-200512
182
"fence"
-199712
-200480
182
"fence"
-199712
-200448
182
"fence"
-199712
-200416
182
"fence"
-199712
-200384
182
"fence"
-199712
-200352
182
"fence"
-199712
-200320
182
"fence"
-199712
-200288
182
"fence"
-199712
-200256
182
"fence"
-199712
-200224
182
"fence"
-199712
-200192
182
"fence"
-199712
-200160
182
"fence"
-199712
-200128
182
"fence"
-199712
-200096
182
"fence"
-199712
-200064
182
"fence"
-199680
-200512
182
"fence"
-199680
-200480
182
"fence"
-199680
-200448
182
"fence"
-199680
-200416
182
"fence"
-199680
-200384
182
"fence"
-199680
-200352
182
"fence"
-199680
-200320
182
"fence"
-199680
-200288
182
"fence"
-199680
-200256
182
"fence"
-199680
-200224
182
"fence"
-199680
-200192
182
"fence"
-199680
-200160
182
"fence"
-199680
-200128
182
"fence"
-199680
-200096
182
"fence"
-199680
-200064
182
"fence"
-199648
-200512
182
"fence"
-199648
-200480
182
"fence"
-199648
-200448
182
"fence"
-199648
-200416
182
"fence"
-199648
-200384
182
"fence"
-199648
-200352
182
"fence"
-199648
-200320
182
"fence"
-199648
-200288
182
"fence"
-199648
-200256
182
"fence"
-199648
-200224
182
"fence"
-199648
-200192
182
"fence"
-199648
-200160
182
"fence"
-199648
-200128
182
"fence"
-199648
-200096
182
"fence"
-199648
-200064
182
"fence"
-199616
-200512
182
"fence"
-199616
-200480
182
"fence"
-199616
-200448
182
"fence"
-199616
-200416
182
"fence"
-199616
-200384
182
"fence"
-199616
-200352
182
"fence"
-199616
-200320
182
"fence"
-199616
-200288
182
"fence"
-199616
-200256
182
"fence"
-199616
-200224
182
"fence"
-199616
-200192
182
"fence"
-199616
-200160
182
"fence"
-199616
-200128
182
"fence"
-199616
-200096
182
"fence"
-199616
-200064
182
"fence"
-199584
-200512
182
"fence"
-199584
-200480
182
"fence"
-199584
-200448
182
"fence"
-199584
-200416
182
"fence"
-199584
-200384
182
"fence"
-199584
-200352
182
"fence"
-199584
-200320
182
"fence"
-199584
-200288
182
"fence"
-199584
-200256
182
"fence"
-199584
-200224
182
"fence"
-199584
-200192
182
"fence"
-199584
-200160
182
"fence"
-199584
-200128
182
"fence"
-199584
-200096
182
"fence"
-199584
-200064
182
"fence"
-199552
-200512
182
"fence"
-199552
-200480
182
"fence"
-199552
-200448
182
"fence"
-199552
-200416
182
"fence"
-199552
-200384
182
"fence"
-199552
-200352
182
"fence"
-199552
-200320
182
"fence"
-199552
-200288
182
"fence"
-199552
-200256
182
"fence"
-199552
-200224
182
"fence"
-199552
-200192
182
"fence"
-199552
-200160
182
"fence"
-199552
-200128
182
"fence"
-199552
-200096
182
"fence"
-199552
-200064
182
"fence"
-199520
-200512
182
"fence"
-199520
-200480
182
"fence"
-199520
-200448
182
"fence"
-199520
-200416
182
"fence"
-199520
-200384
182
"fence"
-199520
-200352
182
"fence"
-199520
-200320
182
"fence"
-199520
-200288
182
"fence"
-199520
-200256
182
"fence"
-199520
-200224
182
"fence"
-199520
-200192
182
"fence"
-199520
-200160
182
"fence"
-199520
-200128
182
"fence"
-199520
-200096
182
"fence"
-199520
-200064
182
"fence"
-199488
-200512
182
"fence"
-199488
-200480
182
"fence"
-199488
-200448
182
"fence"
-199488
-200416
182
"fence"
-199488
-200384
182
"fence"
-199488
-200352
182
"fence"
-199488
-200320
182
"fence"
-199488
-200288
182
"fence"
-199488
-200256
182
"fence"
-199488
-200224
182
"fence"
-199488
-200192
182
"fence"
-199488
-200160
182
"fence"
-199488
-200128
182
"fence"
-199488
-200096
182
"fence"
-199488
-200064
182
"fence"
-199456
-200512
182
"fence"
-199456
-200480
182
"fence"
-199456
-200448
182
"fence"
-199456
-200416
182
"fence"
-199456
-200384
182
"fence"
-199456
-200352
182
"fence"
-199456
-200320
182
"fence"
-199456
-200288
182
"fence"
-199456
-200256
182
"fence"
-199456
-200224
182
"fence"
-199456
-200192
182
"fence"
-199456
-200160
182
"fence"
-199456
-200128
182
"fence"
-199456
-200096
182
"fence"
-199456
-200064
182
"fence"
"next"
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"fence"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"HideShow Fence"
""
0
0
""
""
"fence"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Player clip - min.lvl
================================================
64
0
"Player clip [Minimal]"
-200000
-201184
-200000
-198496
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199452
-200534
24
54
0
0
0
0
-200000
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199904
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199872
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199840
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199808
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199776
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199744
-200384
32
128
321
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199712
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199680
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199648
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199616
-200384
32
128
319
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199584
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199552
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199520
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199488
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199456
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199424
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199392
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199360
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199328
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199296
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199584
-200512
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199712
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199648
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199776
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"kurwa"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"Up"
40
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"kurwa"
0
1
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"Up"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"Level - Start"
40
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"kurwa"
0
-1
0
0
0


================================================
FILE: test/levels/Player clip.lvl
================================================
64
0
"Player clip"
-200000
-201184
-200000
-198496
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199516
-200534
24
54
0
0
0
0
-200000
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199776
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199744
-200384
32
128
321
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199712
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199680
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199648
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199616
-200384
32
128
319
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199584
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199552
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199520
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199488
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199456
-200416
96
192
28
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199424
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199392
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199360
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199328
-200384
64
160
28
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199296
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199264
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199232
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199200
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199168
-200384
32
128
319
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199136
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199104
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199072
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199040
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-199008
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-198976
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-198944
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200480
32
32
54
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-198912
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200480
32
128
319
0
#FALSE#
#FALSE#
"kurwa"
""
""
""
-198880
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200384
32
128
321
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200352
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198656
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198656
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198624
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198624
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198560
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198560
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200224
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200192
32
32
54
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199424
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199328
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199264
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199200
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199072
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199136
-200512
-1
89
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199744
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199614
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199456
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199424
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199360
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199328
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199296
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199264
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199232
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199200
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199168
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199136
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199104
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199072
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199040
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199008
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198976
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198944
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198912
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198880
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198848
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198816
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198784
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198752
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198720
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198688
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198656
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198624
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198592
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198560
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198528
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199808
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199872
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199904
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199936
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199968
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-200000
-200576
-1
264
#FALSE#
""
#TRUE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"kurwa"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"Up"
40
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"kurwa"
0
1
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"Up"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"Level - Start"
40
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"kurwa"
0
-1
0
0
0


================================================
FILE: test/levels/Player through block.lvl
================================================
64
0
"Player through block"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199916
-200086
24
54
-199484
-200348
24
60
-200000
-200192
32
32
628
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200192
32
32
628
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200192
32
32
628
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200192
32
32
624
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200192
32
32
622
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200320
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200416
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200384
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200352
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200320
32
32
626
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200288
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200256
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200224
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200192
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200160
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
52
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199616
-200288
-1
1
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Pockey test.lvl
================================================
64
0
"Pockey test"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199996
-200150
24
54
0
0
0
0
-200032
-200608
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200576
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200544
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200512
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200480
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200448
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200416
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200384
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200352
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200320
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200288
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200256
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200224
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200192
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200160
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200128
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200096
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200124
32
32
188
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200128
32
32
600
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200096
32
32
602
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200160
32
32
600
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200128
32
32
602
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200096
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200192
32
32
600
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200160
32
32
602
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200128
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200096
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200192
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200160
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200128
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200096
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200192
32
32
6
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200160
32
32
17
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200128
32
32
17
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200096
32
32
17
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200064
32
32
17
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
17
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200320
32
32
557
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200288
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200256
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200224
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200192
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200160
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200128
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200096
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200064
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
561
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200192
32
32
7
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200160
32
32
15
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200128
32
32
15
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200096
32
32
15
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200064
32
32
15
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
15
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200192
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200160
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200128
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200096
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200192
32
32
601
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200160
32
32
603
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200128
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200096
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200160
32
32
601
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200128
32
32
603
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200096
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200128
32
32
601
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200096
32
32
603
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200124
32
32
188
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200608
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200576
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200544
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200512
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200480
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200448
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200416
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200384
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200352
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200320
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200288
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200256
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200224
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200192
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200160
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200128
32
32
558
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200096
32
32
3
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200064
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200032
32
32
16
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199392
-200158
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200190
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200222
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200126
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200222
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200190
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200158
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200126
-1
247
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Raft ride.lvl
================================================
64
0
"Raft ride"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199996
-200502
24
54
0
0
0
0
-200032
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200448
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200288
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200064
160
224
568
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200160
224
160
568
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200576
32
32
173
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200448
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200256
32
32
179
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200480
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200512
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200608
32
32
174
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200576
32
32
174
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200544
32
32
174
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200512
32
32
174
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200480
32
32
174
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200448
32
32
174
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
180
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200192
32
32
180
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200160
32
32
180
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200512
480
192
568
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200384
32
32
177
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200352
32
32
177
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200320
32
32
177
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200288
32
32
177
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200160
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200288
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200160
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200384
32
32
176
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200288
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200448
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200416
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200288
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199904
-200148
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199872
-200148
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199936
-200148
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200148
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199968
-200148
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199264
-200276
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200276
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199360
-200276
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199296
-200276
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199328
-200276
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200436
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199968
-200436
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199904
-200436
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199872
-200436
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199936
-200436
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199616
-200448
-1
89
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Shelf surf.lvl
================================================
64
0
"Shelf surf"
-200000
-200600
-200000
-198048
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199564
-200086
24
54
0
0
0
0
-200064
-200288
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200256
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200224
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200192
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200160
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200128
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200096
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200064
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198656
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198464
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198400
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198144
-200032
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200480
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200448
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200416
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200384
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200352
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200320
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200288
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200256
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200224
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200192
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200160
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200128
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200096
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200064
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199392
-200064
-1
195
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199488
-200064
-1
169
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Shell on spring.lvl
================================================
64
0
"Shell on spring"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199772
-200278
24
54
0
0
0
0
-199840
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
229
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200192
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200192
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200192
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200224
32
32
227
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200224
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199712
-200256
-1
113
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199616
-200224
-1
26
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Skull raft 2.lvl
================================================
64
0
"Skull raft 2"
-200000
-200600
-200000
-197888
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199980
-200310
24
54
0
0
0
0
-200000
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200064
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200384
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200352
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200320
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200288
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200256
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200064
32
128
319
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200352
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200320
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200288
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200256
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200320
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200288
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200256
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200288
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200256
32
32
415
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200256
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
64
366
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
451
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200000
32
32
453
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200000
32
32
453
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200000
32
32
453
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200000
32
32
453
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200288
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200256
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200000
32
32
453
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200064
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200096
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200128
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200160
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200192
32
32
452
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200224
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200224
32
64
366
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200192
32
64
366
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200160
32
64
366
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200128
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200096
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200064
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200064
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200064
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200064
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200064
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198656
-200064
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198656
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198624
-200064
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198624
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200064
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198560
-200064
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198560
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200064
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198496
-200064
32
32
315
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198496
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198464
-200064
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198464
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198432
-200096
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198432
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198432
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198400
-200128
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198400
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198400
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198400
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198368
-200160
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198368
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198368
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198368
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198368
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200192
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200224
32
32
316
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200224
32
64
366
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198240
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198240
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198240
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198240
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198240
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198240
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200192
32
64
366
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198144
-200160
32
64
366
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198144
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198144
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198144
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198144
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198112
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198080
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198080
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198080
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198080
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198048
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198048
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198048
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198048
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198016
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198016
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198016
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198016
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197984
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197984
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197984
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197984
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197952
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197952
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197952
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197952
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197920
-200192
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197920
-200160
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197920
-200128
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197920
-200096
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197920
-200064
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
-197920
-200032
32
32
251
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
"next"
-199936
-200404
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199904
-200372
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199872
-200340
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199840
-200308
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199808
-200276
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199360
-200212
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200180
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199424
-200148
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199456
-200116
-1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199040
-200212
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199008
-200212
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198976
-200180
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198944
-200180
1
190
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Slope test.lvl
================================================
64
0
"Slope test"
-200800
-200600
-200000
-198176
24
16291944
#FALSE#
#FALSE#
14
#FALSE#
#FALSE#
"Slope test/Charles Ray - Hit the road jack - loop-Nineko.vgz"
-180000
-180600
-180000
-179200
24
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
"Slope test/Charles Ray - Hit the road jack - loop-Nineko.vgz"
-160000
-160600
-160000
-159200
24
16291944
#TRUE#
#FALSE#
0
#FALSE#
#FALSE#
"Slope test/Charles Ray - Hit the road jack - loop-Nineko.vgz"
-140000
-140600
-140000
-139200
24
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
"Slope test/Charles Ray - Hit the road jack - loop-Nineko.vgz"
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-384
-312
288
416
24
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
"Slope test/Charles Ray - Hit the road jack - loop-Nineko.vgz"
20000
19400
20000
20800
24
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
"Slope test/Charles Ray - Hit the road jack - loop-Nineko.vgz"
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-198396
-200086
24
54
-198396
-200220
24
60
-200800
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200768
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200736
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200704
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200672
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200640
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200608
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200576
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200576
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200544
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200544
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200512
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200512
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200480
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200480
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200448
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200448
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200416
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200416
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200384
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200384
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200352
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200352
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200320
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200320
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200288
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200288
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200256
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200256
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200224
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200224
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200192
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200192
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200160
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200160
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200128
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200128
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200096
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200096
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200064
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200032
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200736
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200704
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200672
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200640
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200608
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200576
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200544
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200512
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200480
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200448
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200416
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200384
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200352
32
32
111
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200320
32
32
268
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200352
32
32
4
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200288
32
32
193
1009
#FALSE#
#FALSE#
"superMushrook"
""
"superkek"
""
-199680
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200352
32
32
4
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200288
32
32
282
0
#FALSE#
#FALSE#
"Default"
""
"Скрыть-показать забор"
""
-199520
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200160
32
64
638
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200160
32
64
636
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199200
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199168
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199136
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200320
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
-199104
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199104
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200320
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
-199072
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199072
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200320
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
-199040
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199040
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200320
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
-199008
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199008
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198976
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198944
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198912
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198880
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198848
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200608
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200576
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200544
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200512
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200480
32
64
140
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200160
32
32
183
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198816
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198784
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200608
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200576
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200544
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200512
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200480
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200448
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200416
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200384
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200352
32
64
140
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200160
32
32
183
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198752
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198720
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200608
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200576
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200544
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200512
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200480
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200448
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200416
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200384
32
64
145
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200352
32
64
140
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200160
32
32
183
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198688
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198656
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198656
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198624
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198624
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200288
32
32
5
1034
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198592
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198560
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198560
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200288
32
32
5
1009
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198528
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198496
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198496
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198464
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198464
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198432
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198432
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198400
-200160
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198400
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198368
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198336
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198304
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198272
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198240
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198208
-200256
32
32
173
0
#FALSE#
#FALSE#
"Default"
""
"move forward"
""
-198208
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200640
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200608
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200576
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200544
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200512
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200480
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200448
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200416
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200384
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200352
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200320
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200288
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200256
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200224
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200192
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198176
-200032
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-198144
-200192
32
32
163
0
#FALSE#
#FALSE#
"Default"
""
""
""
-180000
-180224
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-180000
-180192
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-180000
-180160
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-180000
-180128
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-180000
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-180000
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-180000
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179968
-180224
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179968
-180192
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179968
-180160
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179968
-180128
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179968
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179968
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179968
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179936
-180224
32
32
96
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179936
-180192
32
32
99
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179936
-180160
32
32
99
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179936
-180128
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179936
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179936
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179936
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179904
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179904
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179904
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179904
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179872
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179872
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179872
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179872
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179840
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179840
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179840
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179840
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179808
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179808
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179808
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179808
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179776
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179776
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179776
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179776
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179744
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179744
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179744
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179744
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179712
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179712
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179712
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179712
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179680
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179680
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179680
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179680
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179648
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179648
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179648
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179648
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179616
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179616
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179616
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179616
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179584
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179584
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179584
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179584
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179552
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179552
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179552
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179552
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179520
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179520
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179520
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179520
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179488
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179488
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179488
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179488
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179456
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179456
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179456
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179456
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179424
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179424
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179424
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179424
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179392
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179392
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179392
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179392
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179360
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179360
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179360
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179360
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179328
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179328
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179328
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179328
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179296
-180128
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179296
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179296
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179296
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180256
32
32
94
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180224
32
32
97
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180192
32
32
97
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180160
32
32
97
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180128
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179264
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180256
32
32
95
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180224
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180192
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180160
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180128
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180096
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180064
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-179232
-180032
32
32
98
0
#FALSE#
#FALSE#
"Default"
""
""
""
-160000
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159968
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159936
-160576
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159936
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159904
-160576
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159904
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159872
-160448
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159872
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159840
-160448
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159840
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159808
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159776
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159776
-160064
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159744
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159744
-160064
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159712
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159712
-160064
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159680
-160064
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159520
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159488
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159456
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159424
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159392
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159360
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159328
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159296
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159264
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-159232
-160320
32
32
89
0
#FALSE#
#FALSE#
"Default"
""
""
""
-140000
-140096
32
64
141
0
#FALSE#
#FALSE#
"Default"
""
""
""
-140000
-140064
32
64
146
0
#FALSE#
#FALSE#
"Default"
""
""
""
-140000
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139968
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139936
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139904
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139872
-140320
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139872
-140288
32
64
146
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139872
-140256
32
64
146
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139872
-140224
32
64
141
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139872
-140064
32
64
141
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139872
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139840
-140320
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139840
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139808
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139776
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139744
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139712
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139680
-140096
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139680
-140064
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139680
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139648
-140416
64
64
224
1
#FALSE#
#FALSE#
"lol"
""
""
""
-139648
-140096
64
32
156
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139648
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139616
-140096
64
32
150
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139616
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139584
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139552
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139520
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139488
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139456
-140096
64
32
150
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139456
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139424
-140096
64
32
156
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139424
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139392
-140096
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139392
-140064
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139392
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139360
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139328
-140160
32
64
141
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139328
-140128
32
64
146
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139328
-140096
32
64
146
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139328
-140064
32
64
146
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139328
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139296
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139264
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-139232
-140032
32
32
397
0
#FALSE#
#FALSE#
"Default"
""
""
""
-384
-96
32
32
169
0
#FALSE#
#FALSE#
"Default"
""
"makeNewKoopa"
""
-384
32
32
32
229
0
#FALSE#
#FALSE#
"Default"
""
""
""
-384
64
32
32
235
0
#FALSE#
#FALSE#
"Default"
""
""
""
-384
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-384
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-384
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-384
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-384
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-352
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-352
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-352
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-352
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-352
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-320
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-320
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-320
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-320
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-320
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-288
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-288
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-288
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-288
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-288
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-288
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-256
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-256
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-256
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-256
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-256
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-256
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-224
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-224
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-224
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-224
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-224
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-224
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-192
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-192
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-192
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-192
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-192
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-192
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-160
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-160
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-160
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-160
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-160
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-160
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-128
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-128
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-128
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-128
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-128
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-128
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-96
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-96
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-96
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-96
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-96
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-96
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-64
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-64
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-64
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-64
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-64
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-64
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-32
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
-32
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
-32
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-32
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-32
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-32
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
0
32
32
289
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
128
32
32
228
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
0
32
32
227
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
32
32
32
230
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
64
32
32
230
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
96
32
32
230
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
128
32
32
238
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
224
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
256
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
20000
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20000
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20000
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20000
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20032
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20032
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20032
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20032
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20064
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20064
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20064
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20064
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20096
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20096
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20096
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20096
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20128
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20128
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20128
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20128
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20160
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20160
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20160
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20160
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20192
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20192
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20192
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20192
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20224
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20224
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20224
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20224
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20256
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20256
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20256
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20256
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20288
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20288
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20288
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20288
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20320
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20320
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20320
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20320
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20352
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20352
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20352
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20352
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20384
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20384
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20384
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20384
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20416
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20416
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20416
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20416
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20448
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20448
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20448
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20448
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20480
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20480
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20480
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20480
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20512
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20512
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20512
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20512
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20544
19872
32
64
140
0
#FALSE#
#FALSE#
"Default"
""
""
""
20544
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20544
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20544
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20576
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20576
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20576
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20608
19552
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
20608
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20608
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20608
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20608
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20640
19552
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
20640
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20640
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20640
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20640
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20672
19552
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
20672
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20672
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20672
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20672
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20704
19552
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
20704
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20704
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20704
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20704
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20736
19552
32
32
188
0
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
20736
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20736
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20736
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20736
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20768
19872
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20768
19904
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20768
19936
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
20768
19968
32
32
521
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-179904
-180192
169
"Default"
-179904
-180224
168
"Default"
-179840
-180224
168
"Default"
-179840
-180192
169
"Default"
-179776
-180224
168
"Default"
-179776
-180192
169
"Default"
-179712
-180224
168
"Default"
-179712
-180192
169
"Default"
-179648
-180224
168
"Default"
-179648
-180192
169
"Default"
-179584
-180224
168
"Default"
-179584
-180192
169
"Default"
-179520
-180192
169
"Default"
-179520
-180224
168
"Default"
-179456
-180192
169
"Default"
-179456
-180224
168
"Default"
-179392
-180192
169
"Default"
-179392
-180224
168
"Default"
-179328
-180192
169
"Default"
-179328
-180224
168
"Default"
-200320
-200192
134
"Default"
-200320
-200256
136
"Default"
-200320
-200224
135
"Default"
-199456
-200288
182
"fence to show/hide"
-199456
-200416
182
"fence to show/hide"
-199456
-200448
182
"fence to show/hide"
-199456
-200320
182
"fence to show/hide"
-199456
-200512
182
"fence to show/hide"
-199456
-200384
182
"fence to show/hide"
-199456
-200224
182
"fence to show/hide"
-199456
-200352
182
"fence to show/hide"
-199456
-200192
182
"fence to show/hide"
-199456
-200256
182
"fence to show/hide"
-199456
-200480
182
"fence to show/hide"
-199424
-200192
182
"fence to show/hide"
-199424
-200256
182
"fence to show/hide"
-199424
-200384
182
"fence to show/hide"
-199424
-200288
182
"fence to show/hide"
-199424
-200416
182
"fence to show/hide"
-199424
-200352
182
"fence to show/hide"
-199424
-200448
182
"fence to show/hide"
-199424
-200320
182
"fence to show/hide"
-199424
-200480
182
"fence to show/hide"
-199424
-200512
182
"fence to show/hide"
-199424
-200224
182
"fence to show/hide"
-199392
-200320
182
"fence to show/hide"
-199392
-200480
182
"fence to show/hide"
-199392
-200352
182
"fence to show/hide"
-199392
-200256
182
"fence to show/hide"
-199392
-200384
182
"fence to show/hide"
-199392
-200288
182
"fence to show/hide"
-199392
-200416
182
"fence to show/hide"
-199392
-200512
182
"fence to show/hide"
-199392
-200448
182
"fence to show/hide"
-199392
-200192
182
"fence to show/hide"
-199392
-200224
182
"fence to show/hide"
-199136
-200256
182
"Default"
-199136
-200416
182
"Default"
-199136
-200448
182
"Default"
-199136
-200320
182
"Default"
-199136
-200480
182
"Default"
-199136
-200384
182
"Default"
-199136
-200512
182
"Default"
-199136
-200352
182
"Default"
-199136
-200224
182
"Default"
-199136
-200288
182
"Default"
-199136
-200192
182
"Default"
-199104
-200320
182
"Default"
-199104
-200384
182
"Default"
-199104
-200192
182
"Default"
-199104
-200416
182
"Default"
-199104
-200256
182
"Default"
-199104
-200448
182
"Default"
-199104
-200352
182
"Default"
-199104
-200480
182
"Default"
-199104
-200288
182
"Default"
-199104
-200512
182
"Default"
-199104
-200224
182
"Default"
-199104
-200384
118
"Floating bricks"
-199072
-200512
182
"Default"
-199072
-200320
182
"Default"
-199072
-200352
182
"Default"
-199072
-200224
182
"Default"
-199072
-200384
182
"Default"
-199072
-200288
182
"Default"
-199072
-200416
182
"Default"
-199072
-200256
182
"Default"
-199072
-200448
182
"Default"
-199072
-200192
182
"Default"
-199072
-200480
182
"Default"
-199040
-200320
182
"Default"
-199040
-200384
182
"Default"
-199040
-200352
182
"Default"
-199040
-200480
182
"Default"
-199040
-200288
182
"Default"
-199040
-200416
182
"Default"
-199040
-200256
182
"Default"
-199040
-200448
182
"Default"
-199040
-200224
182
"Default"
-199040
-200512
182
"Default"
-199040
-200192
182
"Default"
-199008
-200320
182
"Default"
-199008
-200512
182
"Default"
-199008
-200192
182
"Default"
-199008
-200352
182
"Default"
-199008
-200384
182
"Default"
-199008
-200288
182
"Default"
-199008
-200416
182
"Default"
-199008
-200256
182
"Default"
-199008
-200448
182
"Default"
-199008
-200224
182
"Default"
-199008
-200480
182
"Default"
-198976
-200512
182
"Default"
-198976
-200384
182
"Default"
-198976
-200352
182
"Default"
-198976
-200480
182
"Default"
-198976
-200320
182
"Default"
-198976
-200416
182
"Default"
-198976
-200288
182
"Default"
-198976
-200448
182
"Default"
-198976
-200256
182
"Default"
-198976
-200192
182
"Default"
-198976
-200224
182
"Default"
-198944
-200384
182
"Default"
-198944
-200352
182
"Default"
-198944
-200320
182
"Default"
-198944
-200480
182
"Default"
-198944
-200288
182
"Default"
-198944
-200416
182
"Default"
-198944
-200256
182
"Default"
-198944
-200448
182
"Default"
-198944
-200224
182
"Default"
-198944
-200512
182
"Default"
-198944
-200192
182
"Default"
-198912
-200416
182
"Default"
-198912
-200320
182
"Default"
-198912
-200352
182
"Default"
-198912
-200224
182
"Default"
-198912
-200384
182
"Default"
-198912
-200288
182
"Default"
-198912
-200512
182
"Default"
-198912
-200256
182
"Default"
-198912
-200448
182
"Default"
-198912
-200192
182
"Default"
-198912
-200480
182
"Default"
-198880
-200480
182
"Default"
-198880
-200288
182
"Default"
-198880
-200512
182
"Default"
-198880
-200192
182
"Default"
-198880
-200448
182
"Default"
-198880
-200320
182
"Default"
-198880
-200224
182
"Default"
-198880
-200352
182
"Default"
-198880
-200416
182
"Default"
-198880
-200256
182
"Default"
-198880
-200384
182
"Default"
-159904
-160192
161
"Default"
-159392
-160480
161
"Default"
64
-96
136
"Default"
64
-32
134
"Default"
64
-64
135
"Default"
20192
19808
135
"Default"
20192
19840
134
"Default"
20192
19776
136
"Default"
20608
19488
118
"Floating bricks"
-200016
-200256
70
"Default"
-198784
-200128
141
"Default"
-139760
-140128
141
"Default"
-198848
-200096
88
"Default"
-198688
-200096
107
"Default"
-198592
-200096
88
"Default"
-198496
-200096
87
"Default"
-198496
-200224
92
"Default"
-179968
-180288
88
"Default"
-159840
-160384
107
"Default"
-384
-32
87
"Default"
20128
19808
92
"Default"
-200256
-200224
137
"Default"
-200256
-200192
137
"Default"
-200256
-200256
138
"Default"
128
-64
137
"Default"
128
-96
138
"Default"
128
-32
137
"Default"
20256
19808
137
"Default"
20256
19840
137
"Default"
20256
19776
138
"Default"
"next"
20560
19840
-1
109
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
20224
19808
-1
192
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
20672
19552
-1
91
134
#TRUE#
1
1
31
""
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
""
""
20740
19520
-1
33
#TRUE#
1
1
20
""
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
""
""
20612
19488
-1
33
#TRUE#
1
1
20
""
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
""
""
64
96
-1
111
#TRUE#
1
1
20
""
#FALSE#
#FALSE#
#FALSE#
"makeNewKoopa"
""
""
""
""
""
96
-64
-1
192
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-159776
-160106
1
158
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-159744
-160352
-1
49
#TRUE#
1
1
20
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-159936
-160362
-1
158
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-159456
-160362
-1
158
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-179552
-180192
-1
111
#TRUE#
1
1
20
""
#FALSE#
#FALSE#
#FALSE#
"makeNewKoopa"
""
""
""
""
""
-179248
-180288
-1
35
#TRUE#
1
1
10
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199520
-200192
1
98
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199456
-200192
-1
116
#TRUE#
1
1
20
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198400
-200192
-1
49
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-200064
-200192
0
273
#TRUE#
1
1
1
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200192
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198752
-200208
-1
8
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198816
-200208
-1
8
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198688
-200208
-1
93
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-200288
-200224
-1
192
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200224
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200256
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200288
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199040
-200320
-1
91
134
#TRUE#
1
1
1
""
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
""
""
-198456
-200320
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200320
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198736
-200320
-1
51
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198672
-200320
-1
51
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200320
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200352
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200352
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200352
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198624
-200352
1
52
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199100
-200384
-1
33
#TRUE#
1
1
20
""
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
""
""
""
""
""
-198456
-200384
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200384
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200384
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200416
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-200048
-200416
1
104
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200416
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200416
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200448
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198808
-200448
-1
257
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200448
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200448
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198864
-200480
-1
52
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200480
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200480
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200480
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200512
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200512
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200512
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200544
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200544
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200544
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199016
-200560
-1
283
169
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199112
-200560
-1
283
169
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200576
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200576
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200576
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200608
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199192
-200608
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199160
-200608
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-198456
-200640
-1
213
#FALSE#
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
-198496
-200192
20128
19840
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-198496
-200064
-384
0
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-198592
-200064
-179968
-180256
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-198688
-200064
-159840
-160352
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#TRUE#
#FALSE#
-159376
-160464
-159888
-160176
1
1
3
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#TRUE#
#FALSE#
-198768
-200064
-139744
-140064
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-139856
-140096
-139856
-140192
3
1
1
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-139984
-140128
-139312
-140192
3
3
1
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-139584
-140064
-139488
-140064
2
4
1
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-198848
-200064
-198560
-200192
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
500
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"next"
-179904
-180208
640
80
0
#FALSE#
"Default"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"Floating bricks"
#FALSE#
"makeNewKoopa"
#TRUE#
"superMushrook"
#FALSE#
"fence to show/hide"
#FALSE#
"stopper"
#FALSE#
"reverser"
#FALSE#
"lol"
#TRUE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"briks A"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"briks B"
3
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
0
.1
0
0
0
"briks B"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"briks C"
15
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
0
.3
0
0
0
"briks C"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"briks D"
4
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
0
.1
0
0
0
"briks D"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"briks E"
3
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
0
-.1
0
0
0
"briks E"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"briks F"
15
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
0
-.3
0
0
0
"briks F"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"briks A"
4
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"Floating bricks"
0
-.1
0
0
0
"makeNewKoopa"
""
0
0
""
""
"makeNewKoopa"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#TRUE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"superkek"
""
0
0
""
"Destroyed Blocks"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"Скрыть-показать забор"
""
0
0
""
""
"fence to show/hide"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"move forward"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"move back"
100
#FALSE#
#FALSE#
#TRUE#
#FALSE#
#FALSE#
#FALSE#
#TRUE#
#FALSE#
#TRUE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"move back"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"stop"
100
#FALSE#
#FALSE#
#TRUE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#TRUE#
#TRUE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"stop"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"lol"
""
0
0
""
"lol"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
"lolHide"
20
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"lolHide"
""
0
0
"lol"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/Veggies shoot.lvl
================================================
64
0
"Veggies shoot"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-199868
-200086
24
54
0
0
0
0
-200000
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199584
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199552
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199296
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199264
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199232
-200032
32
32
223
0
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-199680
-200096
148
"Default"
-199552
-200096
148
"Default"
-199424
-200096
148
"Default"
-199296
-200096
148
"Default"
"next"
-199664
-200128
-1
147
#TRUE#
1
2
20
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199536
-200128
-1
147
#TRUE#
1
2
20
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199408
-200128
-1
147
#TRUE#
1
2
20
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
-199280
-200128
-1
5
#TRUE#
1
2
20
""
#FALSE#
#FALSE#
#FALSE#
"Default"
""
""
""
""
""
"next"
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/levels/compat.ini
================================================
[compatibility]
enable-last-warp-hub-resume = true
fix-platform-acceleration = true
fix-pokey-collapse = true
fix-player-filter-bounce = true
fix-player-downward-clip = true
fix-npc-downward-clip = true
fix-npc55-kick-ice-blocks = true
fix-climb-invisible-fences = true
fix-climb-bgo-speed-adding = true
enable-climb-bgo-layer-move = true
fix-player-clip-wall-at-npc = true
fix-skull-raft = true
fix-peach-escape-shell-surf = false


================================================
FILE: test/levels/doors test.lvl
================================================
64
0
"Doors test"
-200000
-200600
-200000
-199200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-40000
-40600
-40000
-39200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
-20000
-20600
-20000
-19200
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
296
896
800
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
20000
19400
20000
20800
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
40000
39400
40000
40800
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
60000
59400
60000
60800
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
80000
79400
80000
80800
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
0
0
0
0
0
16291944
#FALSE#
#FALSE#
0
#FALSE#
#FALSE#
""
372
458
24
54
0
0
0
0
-200000
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-200000
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199968
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200480
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199936
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200512
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199904
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200544
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199872
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199840
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199808
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200096
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199776
-200064
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199744
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200192
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199712
-200032
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200160
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200128
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200096
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199680
-200064
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200384
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200352
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200320
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200288
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200256
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199648
-200224
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199616
-200384
192
416
575
0
#FALSE#
#FALSE#
"Default"
""
""
""
-199520
-200480
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199488
-200512
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199456
-200544
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199424
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199392
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199360
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
-199328
-200576
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
0
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
0
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
32
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
416
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
64
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
64
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
384
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
96
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
96
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
352
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
128
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
128
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
160
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
736
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
160
864
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
192
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
704
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
736
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
768
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
800
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
832
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
192
864
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
224
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
224
864
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
256
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
256
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
736
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
768
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
800
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
288
832
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
704
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
320
864
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
512
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
544
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
576
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
608
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
640
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
672
32
32
413
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
704
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
352
864
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
512
192
416
575
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
736
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
768
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
800
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
384
832
32
32
231
0
#FALSE#
#FALSE#
"Default"
""
""
""
480
416
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
512
384
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
544
352
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
576
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
608
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
640
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
672
320
32
32
5
99
#FALSE#
#FALSE#
"Default"
""
""
""
"next"
-199648
-200448
88
"Default"
320
448
88
"Default"
"next"
608
480
-1
9
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
-199392
-200416
-1
9
#FALSE#
""
#FALSE#
#TRUE#
#FALSE#
"Default"
""
""
""
""
""
"next"
320
480
-199648
-200416
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
-199648
-200416
320
480
1
1
2
""
0
#FALSE#
#FALSE#
-1
-1
0
"Default"
#FALSE#
#FALSE#
#FALSE#
#FALSE#
"next"
"next"
"Default"
#FALSE#
"Destroyed Blocks"
#TRUE#
"Spawned NPCs"
#FALSE#
"next"
"Level - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - Start"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0
"P Switch - End"
""
0
0
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
""
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
-1
-1
-1
0
0
0
""
0
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
#FALSE#
""
0
0
0
0
0


================================================
FILE: test/test_msg_macro/CMakeLists.txt
================================================
set(CMAKE_CXX_STANDARD 14)

add_executable(TestMsgMacro
    ${TheXTech_SOURCE_DIR}/src/script/msg_macros.cpp
    ${TheXTech_SOURCE_DIR}/src/script/msg_macros.h
    test_msg_macro.cpp
    $<TARGET_OBJECTS:Catch-objects>
)
target_link_libraries(TestMsgMacro PRIVATE test_common)
target_compile_definitions(TestMsgMacro PRIVATE -DMOONDUST_UNIT_TEST)
add_test(NAME TestMsgMacro COMMAND ConversionTest)


================================================
FILE: test/test_msg_macro/test_msg_macro.cpp
================================================
#include "catch_amalgamated.hpp"
#include "script/msg_macros.h"

static std::string str2escaped(std::string src)
{
    if(src.empty())
        return src;

    static const std::string from = "\n";
    static const std::string to = "\\n";

    size_t start_pos = 0;
    while((start_pos = src.find(from, start_pos)) != std::string::npos)
    {
        src.replace(start_pos, from.length(), to);
        start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
    }

    return src;
}

void testMessageCondition(const char *line, const std::string &expected, int macro_character, int macro_state)
{
    std::string ret;
    MsgMacroErrors err;
    msgMacroProcess(std::string(line), ret, macro_character, macro_state, &err);

    INFO("Error handling of input:\n------------------------------------\n" << line << "\n------------------------------------\n");
    CAPTURE(str2escaped(line));
    CHECK(err == MSG_MACRO_ERROR_OK);

    INFO("Comparison of:\n-----------Expected:----------------\n" << expected  << "\n-----------Actual:------------------\n" << ret << "\n------------------------------------");
    CAPTURE(str2escaped(ret), str2escaped(expected));
    CHECK(ret == expected);
}

void testMessageValidness(const char *line, int macro_character, int macro_state, MsgMacroErrors expected)
{
    std::string ret;
    MsgMacroErrors err;
    INFO("Error handling of input:\n------------------------------------\n" << line << "\n------------------------------------\n");
    msgMacroProcess(std::string(line), ret, macro_character, macro_state, &err);
    INFO("Expected error code: " << expected << "\nActual error code: " << err);
    CHECK(err == expected);
}


TEST_CASE("[message-box text macros] Ordinary usage")
{
    const char *sample_001 =
        "Hello!\n"
        "#if player(1,2)\n"
        "You are plumber?!\n"
        "#elif player(3)\n"
        "You are princess?!\n"
        "#elif player(4)\n"
        "What the heck yo uare here?! Go clean toilets!\n"
        "#else\n"
        "Welcome to our world, stranger!\n"
        "#endif\n"
        "I have nothing to tell you!";

    SECTION("Sample 001");
    testMessageCondition(sample_001, "Hello!\nYou are plumber?!\nI have nothing to tell you!", 1, -1);
    testMessageCondition(sample_001, "Hello!\nYou are plumber?!\nI have nothing to tell you!", 2, -1);
    testMessageCondition(sample_001, "Hello!\nYou are princess?!\nI have nothing to tell you!", 3, -1);
    testMessageCondition(sample_001, "Hello!\nWhat the heck yo uare here?! Go clean toilets!\nI have nothing to tell you!", 4, -1);
    testMessageCondition(sample_001, "Hello!\nWelcome to our world, stranger!\nI have nothing to tell you!", 5, -1);

    const char *sample_002 =
        "#if player(3)\nХахаха. Ты сюда не вой-\n"
        "дёшь. Эта дверь запечатана магически. Ты должна соб-\n"
        "рать 15 звёзд, чтобы она открылась. Проваливай, малявка!\n"
        "#else\n"
        "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\n"
        "рать 15 звёзд, чтобы она открылась. Проваливай, сопляк!\n"
        "#endif";

    SECTION("Sample 002");
    testMessageCondition(sample_002, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 1, -1);
    testMessageCondition(sample_002, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 2, -1);
    testMessageCondition(sample_002, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должна соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, малявка!", 3, -1);
    testMessageCondition(sample_002, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 4, -1);
    testMessageCondition(sample_002, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 5, -1);
    testMessageCondition(sample_002, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", -1, -1);

    const char *sample_003 =
        "#if player(3)\n"
        "Hey, you! Get off my lawn!\n"
        "I don't care if you're a princess, just, get out!\n"
        "#else\n"
        "You boys better get off my lawn!\n"
        "#endif";
    testMessageCondition(sample_003, "You boys better get off my lawn!", 1, -1);
    testMessageCondition(sample_003, "You boys better get off my lawn!", 2, -1);
    testMessageCondition(sample_003, "Hey, you! Get off my lawn!\nI don't care if you're a princess, just, get out!", 3, -1);
    testMessageCondition(sample_003, "You boys better get off my lawn!", 4, -1);
    testMessageCondition(sample_003, "You boys better get off my lawn!", 5, -1);
    testMessageCondition(sample_003, "You boys better get off my lawn!", -1, -1);


    const char *sample_004 = "#if player(3)\nБудь осторожна,\n#else\nБудь осторожен,\n#endif\nна пути много опасностей!";
    testMessageCondition(sample_004, "Будь осторожен,\nна пути много опасностей!", 1, -1);
    testMessageCondition(sample_004, "Будь осторожен,\nна пути много опасностей!", 2, -1);
    testMessageCondition(sample_004, "Будь осторожна,\nна пути много опасностей!", 3, -1);
    testMessageCondition(sample_004, "Будь осторожен,\nна пути много опасностей!", 4, -1);
    testMessageCondition(sample_004, "Будь осторожен,\nна пути много опасностей!", 5, -1);
    testMessageCondition(sample_004, "Будь осторожен,\nна пути много опасностей!", -1, -1);


    const char *sample_005 = "#if player(3)\n"
        "Oh, Your Highness! It's such an honor to see you, Princess! I have a gift for you, let me open the chest...\n"
        "#elif player(4)\n"
        "Hello, bro! What's up? Take the thing from the chest, you'll need it!\n"
        "#elif player(5)\n"
        "Oh, you that hero from a far kingdom that everyone keep talking about? Here, you can have what's in this chest.\n"
        "#else\n"
        "Aren't you that plumber that everyone keeps talking about? Here, you can have what's in this chest.\n"
        "#endif";
    testMessageCondition(sample_005, "Aren't you that plumber that everyone keeps talking about? Here, you can have what's in this chest.", 1, -1);
    testMessageCondition(sample_005, "Aren't you that plumber that everyone keeps talking about? Here, you can have what's in this chest.", 2, -1);
    testMessageCondition(sample_005, "Oh, Your Highness! It's such an honor to see you, Princess! I have a gift for you, let me open the chest...", 3, -1);
    testMessageCondition(sample_005, "Hello, bro! What's up? Take the thing from the chest, you'll need it!", 4, -1);
    testMessageCondition(sample_005, "Oh, you that hero from a far kingdom that everyone keep talking about? Here, you can have what's in this chest.", 5, -1);
    testMessageCondition(sample_005, "Aren't you that plumber that everyone keeps talking about? Here, you can have what's in this chest.", -1, -1);

    const char *sample_006 = "#if player(3)\n"
        "Did you like my gift?\n"
        "#else\n"
        "I hope that was helpful.\n"
        "#endif";
    testMessageCondition(sample_006, "I hope that was helpful.", 1, -1);
    testMessageCondition(sample_006, "I hope that was helpful.", 2, -1);
    testMessageCondition(sample_006, "Did you like my gift?", 3, -1);
    testMessageCondition(sample_006, "I hope that was helpful.", 4, -1);
    testMessageCondition(sample_006, "I hope that was helpful.", 5, -1);
    testMessageCondition(sample_006, "I hope that was helpful.", -1, -1);

    const char *sample_007 = "#if player(3)\n"
        "О, Ваше Высочество! Для меня такая честь повидать Вас! У меня есть для Вас подарок, позвольте открыть сундук...\n"
        "#elif player(4)\n"
        "Здарова, брательник! Как поживаешь? Возьми кое-что из сундука, это тебе пригодится!\n"
        "#elif player(5)\n"
        "О, ты случайно не тот герой из далёкой страны, про которого все рассказывали? Возьми кое-что из этого сундука.\n"
        "#else\n"
        "Ты случайно не тот санте-\n"
        "хник, о котором все гово-\n"
        "рят? Возьми кое-что из \n"
        "этого сундука.\n"
        "#endif";
    testMessageCondition(sample_007, "Ты случайно не тот санте-\nхник, о котором все гово-\nрят? Возьми кое-что из \nэтого сундука.", 1, -1);
    testMessageCondition(sample_007, "Ты случайно не тот санте-\nхник, о котором все гово-\nрят? Возьми кое-что из \nэтого сундука.", 2, -1);
    testMessageCondition(sample_007, "О, Ваше Высочество! Для меня такая честь повидать Вас! У меня есть для Вас подарок, позвольте открыть сундук...", 3, -1);
    testMessageCondition(sample_007, "Здарова, брательник! Как поживаешь? Возьми кое-что из сундука, это тебе пригодится!", 4, -1);
    testMessageCondition(sample_007, "О, ты случайно не тот герой из далёкой страны, про которого все рассказывали? Возьми кое-что из этого сундука.", 5, -1);
    testMessageCondition(sample_007, "Ты случайно не тот санте-\nхник, о котором все гово-\nрят? Возьми кое-что из \nэтого сундука.", -1, -1);
}

TEST_CASE("[message-box text macros] State function")
{
    const char *sample_001 =
        "#if state(1)\n"
        "Tiny as mouse!\n"
        "#elif state(2)\n"
        "Just a human.\n"
        "#elif state(3)\n"
        "Don't burn me!\n"
        "#elif state(4)\n"
        "So cute raccoon!\n"
        "#elif state(5)\n"
        "Hey, what this statue does here?\n"
        "#elif state(6)\n"
        "Armored warrior!\n"
        "#elif state(7)\n"
        "Freeze me, I want see the future!\n"
        "#else\n"
        "Who are you?!\n"
        "#endif";

    testMessageCondition(sample_001, "Tiny as mouse!", 1, 1);
    testMessageCondition(sample_001, "Just a human.", 1, 2);
    testMessageCondition(sample_001, "Don't burn me!", 1, 3);
    testMessageCondition(sample_001, "So cute raccoon!", 3, 4);
    testMessageCondition(sample_001, "Hey, what this statue does here?", 3, 5);
    testMessageCondition(sample_001, "Armored warrior!", 3, 6);
    testMessageCondition(sample_001, "Freeze me, I want see the future!", 3, 7);
    testMessageCondition(sample_001, "Who are you?!", 3, 8);
    testMessageCondition(sample_001, "Who are you?!", 3, 9);

    const char *sample_002 =
        "You have power of\n"
        "#if_iw state(1)\n"
        "tininess\n"
        "#elif state(2)\n"
        "humanity\n"
        "#elif state(3)\n"
        "fire\n"
        "#elif state(4)\n"
        "tail\n"
        "#elif state(5)\n"
        "fur\n"
        "#elif state(6)\n"
        "armor\n"
        "#elif state(7)\n"
        "ice\n"
        "#else\n"
        "what?\n"
        "#endif_in\n"
        "!";

    testMessageCondition(sample_002, "You have power of tininess!", 1, 1);
    testMessageCondition(sample_002, "You have power of humanity!", 1, 2);
    testMessageCondition(sample_002, "You have power of fire!", 1, 3);
    testMessageCondition(sample_002, "You have power of tail!", 3, 4);
    testMessageCondition(sample_002, "You have power of fur!", 3, 5);
    testMessageCondition(sample_002, "You have power of armor!", 3, 6);
    testMessageCondition(sample_002, "You have power of ice!", 3, 7);
    testMessageCondition(sample_002, "You have power of what?!", 3, 8);
    testMessageCondition(sample_002, "You have power of what?!", 3, 9);
}

TEST_CASE("[message-box text macros] Extra spaces")
{
    const char *sample_001 =
        "Hello!\n"
        "#  if     player(   1 ,      2       )   \n"
        "You are plumber?!\n"
        "# elif             player(  3      )   \n"
        "You are princess?!\n"
        "#          elif player( 4    )  \n"
        "What the heck yo uare here?! Go clean toilets!\n"
        "#    else  \n"
        "Welcome to our world, stranger!\n"
        "#     endif   \n"
        "I have nothing to tell you!";

    testMessageCondition(sample_001, "Hello!\nYou are plumber?!\nI have nothing to tell you!", 1, -1);
    testMessageCondition(sample_001, "Hello!\nYou are plumber?!\nI have nothing to tell you!", 2, -1);
    testMessageCondition(sample_001, "Hello!\nYou are princess?!\nI have nothing to tell you!", 3, -1);
    testMessageCondition(sample_001, "Hello!\nWhat the heck yo uare here?! Go clean toilets!\nI have nothing to tell you!", 4, -1);
    testMessageCondition(sample_001, "Hello!\nWelcome to our world, stranger!\nI have nothing to tell you!", 5, -1);
}

TEST_CASE("[message-box text macros] Non-Line-breaking branches")
{
    const char *sample_001 =
        "Хахаха. Ты сюда не вой-\n"
        "дёшь. Эта дверь запечатана магически. Ты\n"
        "#if_iw player(3)\n"
        "должна\n"
        "#else\n"
        "должен\n"
        "#endif_iw\n"
        "соб-\n"
        "рать 15 звёзд, чтобы она открылась. Проваливай,\n"
        "#if_iw player(3)\n"
        "малявка!\n"
        "#else\n"
        "сопляк!\n"
        "#endif_in";

    testMessageCondition(sample_001, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 1, -1);
    testMessageCondition(sample_001, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 2, -1);
    testMessageCondition(sample_001, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должна соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, малявка!", 3, -1);
    testMessageCondition(sample_001, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 4, -1);
    testMessageCondition(sample_001, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", 5, -1);
    testMessageCondition(sample_001, "Хахаха. Ты сюда не вой-\nдёшь. Эта дверь запечатана магически. Ты должен соб-\nрать 15 звёзд, чтобы она открылась. Проваливай, сопляк!", -1, -1);

    const char *sample_002 =
        "Some phrase with\n"
        "#if_iw player(1)\n"
        "first\n"
        "#else\n"
        "another\n"
        "#endif_iw\n"
        "player.";

    testMessageCondition(sample_002, "Some phrase with first player.", 1, -1);
    testMessageCondition(sample_002, "Some phrase with another player.", 2, -1);
    testMessageCondition(sample_002, "Some phrase with another player.", 3, -1);
    testMessageCondition(sample_002, "Some phrase with another player.", 4, -1);
    testMessageCondition(sample_002, "Some phrase with another player.", 5, -1);
    testMessageCondition(sample_002, "Some phrase with another player.", -1, -1);

    const char *sample_003 =
        "This is mega\n"
        "#if_in player(1)\n"
        "demo\n"
        "#elif player(2)\n"
        "iris\n"
        "#elif player(3)\n"
        "tortoise\n"
        "#elif player(4,5)\n"
        "human\n"
        "#else\n"
        "trash\n"
        "#endif_in\n"
        "!";

    testMessageCondition(sample_003, "This is megademo!", 1, -1);
    testMessageCondition(sample_003, "This is megairis!", 2, -1);
    testMessageCondition(sample_003, "This is megatortoise!", 3, -1);
    testMessageCondition(sample_003, "This is megahuman!", 4, -1);
    testMessageCondition(sample_003, "This is megahuman!", 5, -1);
    testMessageCondition(sample_003, "This is megatrash!", 6, -1);
    testMessageCondition(sample_003, "This is megatrash!", -1, -1);
}

TEST_CASE("[message-box text macros] Error handling")
{
    SECTION("Valid example")
    {
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_OK);
    }

    SECTION("Unknown condition command")
    {
        testMessageValidness("Hello!\n#wtfcond player(1)\nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_UNKNOWN_CMD);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#what\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_UNKNOWN_CMD);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#else\nWho are you?\n#no you are mess\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_UNKNOWN_CMD);
    }

    SECTION("Unknown function")
    {
        testMessageValidness("Hello!\n#if drillingneighbour(1)\nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_UNKNOWN_FUNC);
        testMessageValidness("Hello!\n#if drillingneighbour(1) , some\nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_UNKNOWN_FUNC);
    }


    SECTION("Bad function syntax")
    {
        testMessageValidness("Hello!\n#if player\nYou are plumber?!\n#elif player(2)\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
        testMessageValidness("Hello!\n#if player(\nYou are plumber?!\n#elif player(2)\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#elif player)\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
        testMessageValidness("Hello!\n#if player)1)\nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
        testMessageValidness("Hello!\n#if state ] 1  \nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
        testMessageValidness("Hello!\n#if player(1 3)\nYou are plumber?!\n#else\nWho are you?\n#no you are mess\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
        testMessageValidness("Hello!\n#if player(3 (2 3)\nYou are plumber?!\n#else\nWho are you?\n#no you are mess\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_SYNTAX);
    }

    SECTION("Bad function arguments")
    {
        testMessageValidness("Hello!\n#if player(1x)\nYou are plumber?!\n#else\nWho are you?\n#no you are mess\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_ARGS);
        testMessageValidness("Hello!\n#if player(f, \", 3)\nYou are plumber?!\n#else\nWho are you?\n#no you are mess\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_ARGS);
        testMessageValidness("Hello!\n#if player(fe,(,2, 3)\nYou are plumber?!\n#else\nWho are you?\n#no you are mess\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_ARGS);
        testMessageValidness("Hello!\n#if player(ff (2 3)\nYou are plumber?!\n#else\nWho are you?\n#no you are mess\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_BAD_FUNC_ARGS);
    }

    SECTION("Junk at end of line")
    {
        testMessageValidness("Hello!\n#if player(1)мыши\nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_EXTRA_SYMBOLS_AT_END);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#elif player(  3331, 31) , some\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_EXTRA_SYMBOLS_AT_END);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#else player(2)\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_EXTRA_SYMBOLS_AT_END);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#else\nWho are you?\n#endif player(2)\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_EXTRA_SYMBOLS_AT_END);
    }

    SECTION("Illegal command")
    {
        testMessageValidness("Hello!\n#elif player(1)\nYou are plumber?!\n#else\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_ILLEGAL_CMD);
        testMessageValidness("Hello!\n#else\nYou are plumber?!\nWho are you?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_ILLEGAL_CMD);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#else\nWho are you?\n#else\nWho are you really?\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_ILLEGAL_CMD);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#else\nWho are you?\n#elif player(2)\nL is real...ly out of order\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_ILLEGAL_CMD);
        testMessageValidness("Hello!\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_ILLEGAL_CMD);
        testMessageValidness("Hello!\n#if player(1)\nYou are plumber?!\n#if player(2)\nsecond if without finishing first\n#endif\nI have nothing to tell you!", 1, -1, MSG_MACRO_ERROR_ILLEGAL_CMD);
    }
}


================================================
FILE: test/worlds/speedrun-unit-test/unit-test.lvlx
================================================
HEAD
TL:"test";CPID:"SMBX1.3Compat";
HEAD_END
SECTION
SC:0;L:-200000;R:-192320;T:-200600;B:-200000;MZ:54;MF:"";BG:13;
SECTION_END
STARTPOINT
ID:1;X:-199916;Y:-200118;D:1;
ID:2;X:-199980;Y:-200124;D:1;
STARTPOINT_END
BLOCK
ID:3;X:-200000;Y:-200064;W:32;H:32;
ID:276;X:-200000;Y:-200032;W:32;H:32;
ID:3;X:-199968;Y:-200064;W:32;H:32;
ID:276;X:-199968;Y:-200032;W:32;H:32;
ID:3;X:-199936;Y:-200064;W:32;H:32;
ID:276;X:-199936;Y:-200032;W:32;H:32;
ID:3;X:-199904;Y:-200064;W:32;H:32;
ID:276;X:-199904;Y:-200032;W:32;H:32;
ID:3;X:-199872;Y:-200064;W:32;H:32;
ID:276;X:-199872;Y:-200032;W:32;H:32;
ID:3;X:-199840;Y:-200064;W:32;H:32;
ID:276;X:-199840;Y:-200032;W:32;H:32;
ID:3;X:-199808;Y:-200064;W:32;H:32;
ID:276;X:-199808;Y:-200032;W:32;H:32;
ID:3;X:-199776;Y:-200064;W:32;H:32;
ID:276;X:-199776;Y:-200032;W:32;H:32;
ID:3;X:-199744;Y:-200064;W:32;H:32;
ID:276;X:-199744;Y:-200032;W:32;H:32;
ID:3;X:-199712;Y:-200064;W:32;H:32;
ID:276;X:-199712;Y:-200032;W:32;H:32;
ID:3;X:-199680;Y:-200064;W:32;H:32;
ID:276;X:-199680;Y:-200032;W:32;H:32;
ID:3;X:-199648;Y:-200064;W:32;H:32;
ID:276;X:-199648;Y:-200032;W:32;H:32;
ID:3;X:-199616;Y:-200064;W:32;H:32;
ID:276;X:-199616;Y:-200032;W:32;H:32;
ID:3;X:-199584;Y:-200064;W:32;H:32;
ID:276;X:-199584;Y:-200032;W:32;H:32;
ID:3;X:-199552;Y:-200064;W:32;H:32;
ID:276;X:-199552;Y:-200032;W:32;H:32;
ID:3;X:-199520;Y:-200064;W:32;H:32;
ID:276;X:-199520;Y:-200032;W:32;H:32;
ID:3;X:-199488;Y:-200064;W:32;H:32;
ID:276;X:-199488;Y:-200032;W:32;H:32;
ID:3;X:-199456;Y:-200064;W:32;H:32;
ID:276;X:-199456;Y:-200032;W:32;H:32;
ID:3;X:-199424;Y:-200064;W:32;H:32;
ID:276;X:-199424;Y:-200032;W:32;H:32;
ID:3;X:-199392;Y:-200064;W:32;H:32;
ID:276;X:-199392;Y:-200032;W:32;H:32;
ID:3;X:-199360;Y:-200064;W:32;H:32;
ID:276;X:-199360;Y:-200032;W:32;H:32;
ID:3;X:-199328;Y:-200064;W:32;H:32;
ID:276;X:-199328;Y:-200032;W:32;H:32;
ID:3;X:-199296;Y:-200064;W:32;H:32;
ID:276;X:-199296;Y:-200032;W:32;H:32;
ID:3;X:-199264;Y:-200064;W:32;H:32;
ID:276;X:-199264;Y:-200032;W:32;H:32;
ID:3;X:-199232;Y:-200064;W:32;H:32;
ID:276;X:-199232;Y:-200032;W:32;H:32;
ID:3;X:-199200;Y:-200064;W:32;H:32;
ID:276;X:-199200;Y:-200032;W:32;H:32;
ID:3;X:-199168;Y:-200064;W:32;H:32;
ID:276;X:-199168;Y:-200032;W:32;H:32;
ID:3;X:-199136;Y:-200064;W:32;H:32;
ID:276;X:-199136;Y:-200032;W:32;H:32;
ID:3;X:-199104;Y:-200064;W:32;H:32;
ID:276;X:-199104;Y:-200032;W:32;H:32;
ID:3;X:-199072;Y:-200064;W:32;H:32;
ID:276;X:-199072;Y:-200032;W:32;H:32;
ID:3;X:-199040;Y:-200064;W:32;H:32;
ID:276;X:-199040;Y:-200032;W:32;H:32;
ID:3;X:-199008;Y:-200064;W:32;H:32;
ID:276;X:-199008;Y:-200032;W:32;H:32;
ID:3;X:-198976;Y:-200064;W:32;H:32;
ID:276;X:-198976;Y:-200032;W:32;H:32;
ID:3;X:-198944;Y:-200064;W:32;H:32;
ID:276;X:-198944;Y:-200032;W:32;H:32;
ID:3;X:-198912;Y:-200064;W:32;H:32;
ID:276;X:-198912;Y:-200032;W:32;H:32;
ID:3;X:-198880;Y:-200064;W:32;H:32;
ID:276;X:-198880;Y:-200032;W:32;H:32;
ID:3;X:-198848;Y:-200064;W:32;H:32;
ID:276;X:-198848;Y:-200032;W:32;H:32;
ID:3;X:-198816;Y:-200064;W:32;H:32;
ID:276;X:-198816;Y:-200032;W:32;H:32;
ID:3;X:-198784;Y:-200064;W:32;H:32;
ID:276;X:-198784;Y:-200032;W:32;H:32;
ID:3;X:-198752;Y:-200064;W:32;H:32;
ID:276;X:-198752;Y:-200032;W:32;H:32;
ID:3;X:-198720;Y:-200064;W:32;H:32;
ID:276;X:-198720;Y:-200032;W:32;H:32;
ID:3;X:-198688;Y:-200064;W:32;H:32;
ID:276;X:-198688;Y:-200032;W:32;H:32;
ID:3;X:-198656;Y:-200064;W:32;H:32;
ID:276;X:-198656;Y:-200032;W:32;H:32;
ID:3;X:-198624;Y:-200064;W:32;H:32;
ID:276;X:-198624;Y:-200032;W:32;H:32;
ID:3;X:-198592;Y:-200064;W:32;H:32;
ID:276;X:-198592;Y:-200032;W:32;H:32;
ID:3;X:-198560;Y:-200064;W:32;H:32;
ID:276;X:-198560;Y:-200032;W:32;H:32;
ID:3;X:-198528;Y:-200064;W:32;H:32;
ID:276;X:-198528;Y:-200032;W:32;H:32;
ID:3;X:-198496;Y:-200064;W:32;H:32;
ID:276;X:-198496;Y:-200032;W:32;H:32;
ID:3;X:-198464;Y:-200064;W:32;H:32;
ID:276;X:-198464;Y:-200032;W:32;H:32;
ID:3;X:-198432;Y:-200064;W:32;H:32;
ID:276;X:-198432;Y:-200032;W:32;H:32;
ID:3;X:-198400;Y:-200064;W:32;H:32;
ID:276;X:-198400;Y:-200032;W:32;H:32;
ID:3;X:-198368;Y:-200064;W:32;H:32;
ID:276;X:-198368;Y:-200032;W:32;H:32;
ID:3;X:-198336;Y:-200064;W:32;H:32;
ID:276;X:-198336;Y:-200032;W:32;H:32;
ID:3;X:-198304;Y:-200064;W:32;H:32;
ID:276;X:-198304;Y:-200032;W:32;H:32;
ID:3;X:-198272;Y:-200064;W:32;H:32;
ID:276;X:-198272;Y:-200032;W:32;H:32;
ID:3;X:-198240;Y:-200064;W:32;H:32;
ID:276;X:-198240;Y:-200032;W:32;H:32;
ID:3;X:-198208;Y:-200064;W:32;H:32;
ID:276;X:-198208;Y:-200032;W:32;H:32;
ID:3;X:-198176;Y:-200064;W:32;H:32;
ID:276;X:-198176;Y:-200032;W:32;H:32;
ID:3;X:-198144;Y:-200064;W:32;H:32;
ID:276;X:-198144;Y:-200032;W:32;H:32;
ID:3;X:-198112;Y:-200064;W:32;H:32;
ID:276;X:-198112;Y:-200032;W:32;H:32;
ID:3;X:-198080;Y:-200064;W:32;H:32;
ID:276;X:-198080;Y:-200032;W:32;H:32;
ID:3;X:-198048;Y:-200064;W:32;H:32;
ID:276;X:-198048;Y:-200032;W:32;H:32;
ID:3;X:-198016;Y:-200064;W:32;H:32;
ID:276;X:-198016;Y:-200032;W:32;H:32;
ID:3;X:-197984;Y:-200064;W:32;H:32;
ID:276;X:-197984;Y:-200032;W:32;H:32;
ID:3;X:-197952;Y:-200064;W:32;H:32;
ID:276;X:-197952;Y:-200032;W:32;H:32;
ID:3;X:-197920;Y:-200064;W:32;H:32;
ID:276;X:-197920;Y:-200032;W:32;H:32;
ID:3;X:-197888;Y:-200064;W:32;H:32;
ID:276;X:-197888;Y:-200032;W:32;H:32;
ID:3;X:-197856;Y:-200064;W:32;H:32;
ID:276;X:-197856;Y:-200032;W:32;H:32;
ID:3;X:-197824;Y:-200064;W:32;H:32;
ID:276;X:-197824;Y:-200032;W:32;H:32;
ID:3;X:-197792;Y:-200064;W:32;H:32;
ID:276;X:-197792;Y:-200032;W:32;H:32;
ID:3;X:-197760;Y:-200064;W:32;H:32;
ID:276;X:-197760;Y:-200032;W:32;H:32;
ID:3;X:-197728;Y:-200064;W:32;H:32;
ID:276;X:-197728;Y:-200032;W:32;H:32;
ID:3;X:-197696;Y:-200064;W:32;H:32;
ID:276;X:-197696;Y:-200032;W:32;H:32;
ID:3;X:-197664;Y:-200064;W:32;H:32;
ID:276;X:-197664;Y:-200032;W:32;H:32;
ID:3;X:-197632;Y:-200064;W:32;H:32;
ID:276;X:-197632;Y:-200032;W:32;H:32;
ID:3;X:-197600;Y:-200064;W:32;H:32;
ID:276;X:-197600;Y:-200032;W:32;H:32;
ID:3;X:-197568;Y:-200064;W:32;H:32;
ID:276;X:-197568;Y:-200032;W:32;H:32;
ID:3;X:-197536;Y:-200064;W:32;H:32;
ID:276;X:-197536;Y:-200032;W:32;H:32;
ID:3;X:-197504;Y:-200064;W:32;H:32;
ID:276;X:-197504;Y:-200032;W:32;H:32;
ID:3;X:-197472;Y:-200064;W:32;H:32;
ID:276;X:-197472;Y:-200032;W:32;H:32;
ID:3;X:-197440;Y:-200064;W:32;H:32;
ID:276;X:-197440;Y:-200032;W:32;H:32;
ID:3;X:-197408;Y:-200064;W:32;H:32;
ID:276;X:-197408;Y:-200032;W:32;H:32;
ID:3;X:-197376;Y:-200064;W:32;H:32;
ID:276;X:-197376;Y:-200032;W:32;H:32;
ID:3;X:-197344;Y:-200064;W:32;H:32;
ID:276;X:-197344;Y:-200032;W:32;H:32;
ID:3;X:-197312;Y:-200064;W:32;H:32;
ID:276;X:-197312;Y:-200032;W:32;H:32;
ID:3;X:-197280;Y:-200064;W:32;H:32;
ID:276;X:-197280;Y:-200032;W:32;H:32;
ID:3;X:-197248;Y:-200064;W:32;H:32;
ID:276;X:-197248;Y:-200032;W:32;H:32;
ID:3;X:-197216;Y:-200064;W:32;H:32;
ID:276;X:-197216;Y:-200032;W:32;H:32;
ID:3;X:-197184;Y:-200064;W:32;H:32;
ID:276;X:-197184;Y:-200032;W:32;H:32;
ID:3;X:-197152;Y:-200064;W:32;H:32;
ID:276;X:-197152;Y:-200032;W:32;H:32;
ID:3;X:-197120;Y:-200064;W:32;H:32;
ID:276;X:-197120;Y:-200032;W:32;H:32;
ID:3;X:-197088;Y:-200064;W:32;H:32;
ID:276;X:-197088;Y:-200032;W:32;H:32;
ID:3;X:-197056;Y:-200064;W:32;H:32;
ID:276;X:-197056;Y:-200032;W:32;H:32;
ID:3;X:-197024;Y:-200064;W:32;H:32;
ID:276;X:-197024;Y:-200032;W:32;H:32;
ID:3;X:-196992;Y:-200064;W:32;H:32;
ID:276;X:-196992;Y:-200032;W:32;H:32;
ID:3;X:-196960;Y:-200064;W:32;H:32;
ID:276;X:-196960;Y:-200032;W:32;H:32;
ID:3;X:-196928;Y:-200064;W:32;H:32;
ID:276;X:-196928;Y:-200032;W:32;H:32;
ID:3;X:-196896;Y:-200064;W:32;H:32;
ID:276;X:-196896;Y:-200032;W:32;H:32;
ID:3;X:-196864;Y:-200064;W:32;H:32;
ID:276;X:-196864;Y:-200032;W:32;H:32;
ID:3;X:-196832;Y:-200064;W:32;H:32;
ID:276;X:-196832;Y:-200032;W:32;H:32;
ID:3;X:-196800;Y:-200064;W:32;H:32;
ID:276;X:-196800;Y:-200032;W:32;H:32;
ID:3;X:-196768;Y:-200064;W:32;H:32;
ID:276;X:-196768;Y:-200032;W:32;H:32;
ID:3;X:-196736;Y:-200064;W:32;H:32;
ID:276;X:-196736;Y:-200032;W:32;H:32;
ID:3;X:-196704;Y:-200064;W:32;H:32;
ID:276;X:-196704;Y:-200032;W:32;H:32;
ID:3;X:-196672;Y:-200064;W:32;H:32;
ID:276;X:-196672;Y:-200032;W:32;H:32;
ID:3;X:-196640;Y:-200064;W:32;H:32;
ID:276;X:-196640;Y:-200032;W:32;H:32;
ID:3;X:-196608;Y:-200064;W:32;H:32;
ID:276;X:-196608;Y:-200032;W:32;H:32;
ID:3;X:-196576;Y:-200064;W:32;H:32;
ID:276;X:-196576;Y:-200032;W:32;H:32;
ID:3;X:-196544;Y:-200064;W:32;H:32;
ID:276;X:-196544;Y:-200032;W:32;H:32;
ID:3;X:-196512;Y:-200064;W:32;H:32;
ID:276;X:-196512;Y:-200032;W:32;H:32;
ID:3;X:-196480;Y:-200064;W:32;H:32;
ID:276;X:-196480;Y:-200032;W:32;H:32;
ID:3;X:-196448;Y:-200064;W:32;H:32;
ID:276;X:-196448;Y:-200032;W:32;H:32;
ID:3;X:-196416;Y:-200064;W:32;H:32;
ID:276;X:-196416;Y:-200032;W:32;H:32;
ID:3;X:-196384;Y:-200064;W:32;H:32;
ID:276;X:-196384;Y:-200032;W:32;H:32;
ID:3;X:-196352;Y:-200064;W:32;H:32;
ID:276;X:-196352;Y:-200032;W:32;H:32;
ID:3;X:-196320;Y:-200064;W:32;H:32;
ID:276;X:-196320;Y:-200032;W:32;H:32;
ID:3;X:-196288;Y:-200064;W:32;H:32;
ID:276;X:-196288;Y:-200032;W:32;H:32;
ID:3;X:-196256;Y:-200064;W:32;H:32;
ID:276;X:-196256;Y:-200032;W:32;H:32;
ID:3;X:-196224;Y:-200064;W:32;H:32;
ID:276;X:-196224;Y:-200032;W:32;H:32;
ID:3;X:-196192;Y:-200064;W:32;H:32;
ID:276;X:-196192;Y:-200032;W:32;H:32;
ID:3;X:-196160;Y:-200064;W:32;H:32;
ID:276;X:-196160;Y:-200032;W:32;H:32;
ID:3;X:-196128;Y:-200064;W:32;H:32;
ID:276;X:-196128;Y:-200032;W:32;H:32;
ID:3;X:-196096;Y:-200064;W:32;H:32;
ID:276;X:-196096;Y:-200032;W:32;H:32;
ID:3;X:-196064;Y:-200064;W:32;H:32;
ID:276;X:-196064;Y:-200032;W:32;H:32;
ID:3;X:-196032;Y:-200064;W:32;H:32;
ID:276;X:-196032;Y:-200032;W:32;H:32;
ID:3;X:-196000;Y:-200064;W:32;H:32;
ID:276;X:-196000;Y:-200032;W:32;H:32;
ID:3;X:-195968;Y:-200064;W:32;H:32;
ID:276;X:-195968;Y:-200032;W:32;H:32;
ID:3;X:-195936;Y:-200064;W:32;H:32;
ID:276;X:-195936;Y:-200032;W:32;H:32;
ID:3;X:-195904;Y:-200064;W:32;H:32;
ID:276;X:-195904;Y:-200032;W:32;H:32;
ID:3;X:-195872;Y:-200064;W:32;H:32;
ID:276;X:-195872;Y:-200032;W:32;H:32;
ID:3;X:-195840;Y:-200064;W:32;H:32;
ID:276;X:-195840;Y:-200032;W:32;H:32;
ID:3;X:-195808;Y:-200064;W:32;H:32;
ID:276;X:-195808;Y:-200032;W:32;H:32;
ID:3;X:-195776;Y:-200064;W:32;H:32;
ID:276;X:-195776;Y:-200032;W:32;H:32;
ID:3;X:-195744;Y:-200064;W:32;H:32;
ID:276;X:-195744;Y:-200032;W:32;H:32;
ID:3;X:-195712;Y:-200064;W:32;H:32;
ID:276;X:-195712;Y:-200032;W:32;H:32;
ID:3;X:-195680;Y:-200064;W:32;H:32;
ID:276;X:-195680;Y:-200032;W:32;H:32;
ID:3;X:-195648;Y:-200064;W:32;H:32;
ID:276;X:-195648;Y:-200032;W:32;H:32;
ID:3;X:-195616;Y:-200064;W:32;H:32;
ID:276;X:-195616;Y:-200032;W:32;H:32;
ID:3;X:-195584;Y:-200064;W:32;H:32;
ID:276;X:-195584;Y:-200032;W:32;H:32;
ID:3;X:-195552;Y:-200064;W:32;H:32;
ID:276;X:-195552;Y:-200032;W:32;H:32;
ID:3;X:-195520;Y:-200064;W:32;H:32;
ID:276;X:-195520;Y:-200032;W:32;H:32;
ID:3;X:-195488;Y:-200064;W:32;H:32;
ID:276;X:-195488;Y:-200032;W:32;H:32;
ID:3;X:-195456;Y:-200064;W:32;H:32;
ID:276;X:-195456;Y:-200032;W:32;H:32;
ID:3;X:-195424;Y:-200064;W:32;H:32;
ID:276;X:-195424;Y:-200032;W:32;H:32;
ID:3;X:-195392;Y:-200064;W:32;H:32;
ID:276;X:-195392;Y:-200032;W:32;H:32;
ID:3;X:-195360;Y:-200064;W:32;H:32;
ID:276;X:-195360;Y:-200032;W:32;H:32;
ID:3;X:-195328;Y:-200064;W:32;H:32;
ID:276;X:-195328;Y:-200032;W:32;H:32;
ID:3;X:-195296;Y:-200064;W:32;H:32;
ID:276;X:-195296;Y:-200032;W:32;H:32;
ID:3;X:-195264;Y:-200064;W:32;H:32;
ID:276;X:-195264;Y:-200032;W:32;H:32;
ID:3;X:-195232;Y:-200064;W:32;H:32;
ID:276;X:-195232;Y:-200032;W:32;H:32;
ID:3;X:-195200;Y:-200064;W:32;H:32;
ID:276;X:-195200;Y:-200032;W:32;H:32;
ID:3;X:-195168;Y:-200064;W:32;H:32;
ID:276;X:-195168;Y:-200032;W:32;H:32;
ID:3;X:-195136;Y:-200064;W:32;H:32;
ID:276;X:-195136;Y:-200032;W:32;H:32;
ID:3;X:-195104;Y:-200064;W:32;H:32;
ID:276;X:-195104;Y:-200032;W:32;H:32;
ID:3;X:-195072;Y:-200064;W:32;H:32;
ID:276;X:-195072;Y:-200032;W:32;H:32;
ID:3;X:-195040;Y:-200064;W:32;H:32;
ID:276;X:-195040;Y:-200032;W:32;H:32;
ID:3;X:-195008;Y:-200064;W:32;H:32;
ID:276;X:-195008;Y:-200032;W:32;H:32;
ID:3;X:-194976;Y:-200064;W:32;H:32;
ID:276;X:-194976;Y:-200032;W:32;H:32;
ID:3;X:-194944;Y:-200064;W:32;H:32;
ID:276;X:-194944;Y:-200032;W:32;H:32;
ID:3;X:-194912;Y:-200064;W:32;H:32;
ID:276;X:-194912;Y:-200032;W:32;H:32;
ID:3;X:-194880;Y:-200064;W:32;H:32;
ID:276;X:-194880;Y:-200032;W:32;H:32;
ID:3;X:-194848;Y:-200064;W:32;H:32;
ID:276;X:-194848;Y:-200032;W:32;H:32;
ID:3;X:-194816;Y:-200064;W:32;H:32;
ID:276;X:-194816;Y:-200032;W:32;H:32;
ID:3;X:-194784;Y:-200064;W:32;H:32;
ID:276;X:-194784;Y:-200032;W:32;H:32;
ID:3;X:-194752;Y:-200064;W:32;H:32;
ID:276;X:-194752;Y:-200032;W:32;H:32;
ID:3;X:-194720;Y:-200064;W:32;H:32;
ID:276;X:-194720;Y:-200032;W:32;H:32;
ID:3;X:-194688;Y:-200064;W:32;H:32;
ID:276;X:-194688;Y:-200032;W:32;H:32;
ID:3;X:-194656;Y:-200064;W:32;H:32;
ID:276;X:-194656;Y:-200032;W:32;H:32;
ID:3;X:-194624;Y:-200064;W:32;H:32;
ID:276;X:-194624;Y:-200032;W:32;H:32;
ID:3;X:-194592;Y:-200064;W:32;H:32;
ID:276;X:-194592;Y:-200032;W:32;H:32;
ID:3;X:-194560;Y:-200064;W:32;H:32;
ID:276;X:-194560;Y:-200032;W:32;H:32;
ID:3;X:-194528;Y:-200064;W:32;H:32;
ID:276;X:-194528;Y:-200032;W:32;H:32;
ID:3;X:-194496;Y:-200064;W:32;H:32;
ID:276;X:-194496;Y:-200032;W:32;H:32;
ID:3;X:-194464;Y:-200064;W:32;H:32;
ID:276;X:-194464;Y:-200032;W:32;H:32;
ID:3;X:-194432;Y:-200064;W:32;H:32;
ID:276;X:-194432;Y:-200032;W:32;H:32;
ID:3;X:-194400;Y:-200064;W:32;H:32;
ID:276;X:-194400;Y:-200032;W:32;H:32;
ID:3;X:-194368;Y:-200064;W:32;H:32;
ID:276;X:-194368;Y:-200032;W:32;H:32;
ID:3;X:-194336;Y:-200064;W:32;H:32;
ID:276;X:-194336;Y:-200032;W:32;H:32;
ID:3;X:-194304;Y:-200064;W:32;H:32;
ID:276;X:-194304;Y:-200032;W:32;H:32;
ID:3;X:-194272;Y:-200064;W:32;H:32;
ID:276;X:-194272;Y:-200032;W:32;H:32;
ID:3;X:-194240;Y:-200064;W:32;H:32;
ID:276;X:-194240;Y:-200032;W:32;H:32;
ID:3;X:-194208;Y:-200064;W:32;H:32;
ID:276;X:-194208;Y:-200032;W:32;H:32;
ID:3;X:-194176;Y:-200064;W:32;H:32;
ID:276;X:-194176;Y:-200032;W:32;H:32;
ID:3;X:-194144;Y:-200064;W:32;H:32;
ID:276;X:-194144;Y:-200032;W:32;H:32;
ID:3;X:-194112;Y:-200064;W:32;H:32;
ID:276;X:-194112;Y:-200032;W:32;H:32;
ID:3;X:-194080;Y:-200064;W:32;H:32;
ID:276;X:-194080;Y:-200032;W:32;H:32;
ID:3;X:-194048;Y:-200064;W:32;H:32;
ID:276;X:-194048;Y:-200032;W:32;H:32;
ID:3;X:-194016;Y:-200064;W:32;H:32;
ID:276;X:-194016;Y:-200032;W:32;H:32;
ID:3;X:-193984;Y:-200064;W:32;H:32;
ID:276;X:-193984;Y:-200032;W:32;H:32;
ID:3;X:-193952;Y:-200064;W:32;H:32;
ID:276;X:-193952;Y:-200032;W:32;H:32;
ID:3;X:-193920;Y:-200064;W:32;H:32;
ID:276;X:-193920;Y:-200032;W:32;H:32;
ID:3;X:-193888;Y:-200064;W:32;H:32;
ID:276;X:-193888;Y:-200032;W:32;H:32;
ID:3;X:-193856;Y:-200064;W:32;H:32;
ID:276;X:-193856;Y:-200032;W:32;H:32;
ID:3;X:-193824;Y:-200064;W:32;H:32;
ID:276;X:-193824;Y:-200032;W:32;H:32;
ID:3;X:-193792;Y:-200064;W:32;H:32;
ID:276;X:-193792;Y:-200032;W:32;H:32;
ID:3;X:-193760;Y:-200064;W:32;H:32;
ID:276;X:-193760;Y:-200032;W:32;H:32;
ID:3;X:-193728;Y:-200064;W:32;H:32;
ID:276;X:-193728;Y:-200032;W:32;H:32;
ID:3;X:-193696;Y:-200064;W:32;H:32;
ID:276;X:-193696;Y:-200032;W:32;H:32;
ID:3;X:-193664;Y:-200064;W:32;H:32;
ID:276;X:-193664;Y:-200032;W:32;H:32;
ID:3;X:-193632;Y:-200064;W:32;H:32;
ID:276;X:-193632;Y:-200032;W:32;H:32;
ID:3;X:-193600;Y:-200064;W:32;H:32;
ID:276;X:-193600;Y:-200032;W:32;H:32;
ID:3;X:-193568;Y:-200064;W:32;H:32;
ID:276;X:-193568;Y:-200032;W:32;H:32;
ID:3;X:-193536;Y:-200064;W:32;H:32;
ID:276;X:-193536;Y:-200032;W:32;H:32;
ID:3;X:-193504;Y:-200064;W:32;H:32;
ID:276;X:-193504;Y:-200032;W:32;H:32;
ID:3;X:-193472;Y:-200064;W:32;H:32;
ID:276;X:-193472;Y:-200032;W:32;H:32;
ID:3;X:-193440;Y:-200064;W:32;H:32;
ID:276;X:-193440;Y:-200032;W:32;H:32;
ID:3;X:-193408;Y:-200064;W:32;H:32;
ID:276;X:-193408;Y:-200032;W:32;H:32;
ID:3;X:-193376;Y:-200064;W:32;H:32;
ID:276;X:-193376;Y:-200032;W:32;H:32;
ID:3;X:-193344;Y:-200064;W:32;H:32;
ID:276;X:-193344;Y:-200032;W:32;H:32;
ID:3;X:-193312;Y:-200064;W:32;H:32;
ID:276;X:-193312;Y:-200032;W:32;H:32;
ID:3;X:-193280;Y:-200064;W:32;H:32;
ID:276;X:-193280;Y:-200032;W:32;H:32;
ID:3;X:-193248;Y:-200064;W:32;H:32;
ID:276;X:-193248;Y:-200032;W:32;H:32;
ID:3;X:-193216;Y:-200064;W:32;H:32;
ID:276;X:-193216;Y:-200032;W:32;H:32;
ID:3;X:-193184;Y:-200064;W:32;H:32;
ID:276;X:-193184;Y:-200032;W:32;H:32;
ID:3;X:-193152;Y:-200064;W:32;H:32;
ID:276;X:-193152;Y:-200032;W:32;H:32;
ID:3;X:-193120;Y:-200064;W:32;H:32;
ID:276;X:-193120;Y:-200032;W:32;H:32;
ID:3;X:-193088;Y:-200064;W:32;H:32;
ID:276;X:-193088;Y:-200032;W:32;H:32;
ID:3;X:-193056;Y:-200064;W:32;H:32;
ID:276;X:-193056;Y:-200032;W:32;H:32;
ID:3;X:-193024;Y:-200064;W:32;H:32;
ID:276;X:-193024;Y:-200032;W:32;H:32;
ID:3;X:-192992;Y:-200064;W:32;H:32;
ID:276;X:-192992;Y:-200032;W:32;H:32;
ID:3;X:-192960;Y:-200064;W:32;H:32;
ID:276;X:-192960;Y:-200032;W:32;H:32;
ID:3;X:-192928;Y:-200064;W:32;H:32;
ID:276;X:-192928;Y:-200032;W:32;H:32;
ID:3;X:-192896;Y:-200064;W:32;H:32;
ID:276;X:-192896;Y:-200032;W:32;H:32;
ID:3;X:-192864;Y:-200064;W:32;H:32;
ID:276;X:-192864;Y:-200032;W:32;H:32;
ID:3;X:-192832;Y:-200064;W:32;H:32;
ID:276;X:-192832;Y:-200032;W:32;H:32;
ID:3;X:-192800;Y:-200064;W:32;H:32;
ID:276;X:-192800;Y:-200032;W:32;H:32;
ID:3;X:-192768;Y:-200064;W:32;H:32;
ID:276;X:-192768;Y:-200032;W:32;H:32;
ID:3;X:-192736;Y:-200064;W:32;H:32;
ID:276;X:-192736;Y:-200032;W:32;H:32;
ID:3;X:-192704;Y:-200064;W:32;H:32;
ID:276;X:-192704;Y:-200032;W:32;H:32;
ID:3;X:-192672;Y:-200064;W:32;H:32;
ID:276;X:-192672;Y:-200032;W:32;H:32;
ID:3;X:-192640;Y:-200064;W:32;H:32;
ID:276;X:-192640;Y:-200032;W:32;H:32;
ID:3;X:-192608;Y:-200064;W:32;H:32;
ID:276;X:-192608;Y:-200032;W:32;H:32;
ID:3;X:-192576;Y:-200064;W:32;H:32;
ID:276;X:-192576;Y:-200032;W:32;H:32;
ID:3;X:-192544;Y:-200064;W:32;H:32;
ID:276;X:-192544;Y:-200032;W:32;H:32;
ID:3;X:-192512;Y:-200064;W:32;H:32;
ID:276;X:-192512;Y:-200032;W:32;H:32;
ID:3;X:-192480;Y:-200064;W:32;H:32;
ID:276;X:-192480;Y:-200032;W:32;H:32;
ID:3;X:-192448;Y:-200064;W:32;H:32;
ID:276;X:-192448;Y:-200032;W:32;H:32;
ID:3;X:-192416;Y:-200064;W:32;H:32;
ID:276;X:-192416;Y:-200032;W:32;H:32;
ID:3;X:-192384;Y:-200064;W:32;H:32;
ID:276;X:-192384;Y:-200032;W:32;H:32;
ID:3;X:-192352;Y:-200064;W:32;H:32;
ID:276;X:-192352;Y:-200032;W:32;H:32;
BLOCK_END
NPC
ID:88;X:-199866;Y:-200096;D:-1;
ID:88;X:-199834;Y:-200096;D:-1;
ID:88;X:-199802;Y:-200096;D:-1;
ID:88;X:-199770;Y:-200096;D:-1;
ID:88;X:-199738;Y:-200096;D:-1;
ID:88;X:-199706;Y:-200096;D:-1;
ID:88;X:-199674;Y:-200096;D:-1;
ID:88;X:-199642;Y:-200096;D:-1;
ID:88;X:-199610;Y:-200096;D:-1;
ID:88;X:-199578;Y:-200096;D:-1;
ID:88;X:-199546;Y:-200096;D:-1;
ID:88;X:-199514;Y:-200096;D:-1;
ID:88;X:-199482;Y:-200096;D:-1;
ID:88;X:-199450;Y:-200096;D:-1;
ID:88;X:-199418;Y:-200096;D:-1;
ID:88;X:-199386;Y:-200096;D:-1;
ID:88;X:-199354;Y:-200096;D:-1;
ID:88;X:-199322;Y:-200096;D:-1;
ID:88;X:-199290;Y:-200096;D:-1;
ID:88;X:-199258;Y:-200096;D:-1;
ID:88;X:-199226;Y:-200096;D:-1;
ID:88;X:-199194;Y:-200096;D:-1;
ID:88;X:-199162;Y:-200096;D:-1;
ID:88;X:-199130;Y:-200096;D:-1;
ID:88;X:-199098;Y:-200096;D:-1;
ID:88;X:-199066;Y:-200096;D:-1;
ID:88;X:-199034;Y:-200096;D:-1;
ID:88;X:-199002;Y:-200096;D:-1;
ID:88;X:-198970;Y:-200096;D:-1;
ID:88;X:-198938;Y:-200096;D:-1;
ID:88;X:-198906;Y:-200096;D:-1;
ID:88;X:-198874;Y:-200096;D:-1;
ID:88;X:-198842;Y:-200096;D:-1;
ID:88;X:-198810;Y:-200096;D:-1;
ID:88;X:-198778;Y:-200096;D:-1;
ID:88;X:-198746;Y:-200096;D:-1;
ID:88;X:-198714;Y:-200096;D:-1;
ID:88;X:-198682;Y:-200096;D:-1;
ID:88;X:-198650;Y:-200096;D:-1;
ID:88;X:-198618;Y:-200096;D:-1;
ID:88;X:-198586;Y:-200096;D:-1;
ID:88;X:-198554;Y:-200096;D:-1;
ID:88;X:-198522;Y:-200096;D:-1;
ID:88;X:-198490;Y:-200096;D:-1;
ID:88;X:-198458;Y:-200096;D:-1;
ID:88;X:-198426;Y:-200096;D:-1;
ID:88;X:-198394;Y:-200096;D:-1;
ID:88;X:-198362;Y:-200096;D:-1;
ID:88;X:-198330;Y:-200096;D:-1;
ID:88;X:-198298;Y:-200096;D:-1;
ID:88;X:-198266;Y:-200096;D:-1;
ID:88;X:-198234;Y:-200096;D:-1;
ID:88;X:-198202;Y:-200096;D:-1;
ID:88;X:-198170;Y:-200096;D:-1;
ID:88;X:-198138;Y:-200096;D:-1;
ID:88;X:-198106;Y:-200096;D:-1;
ID:88;X:-198074;Y:-200096;D:-1;
ID:88;X:-198042;Y:-200096;D:-1;
ID:88;X:-198010;Y:-200096;D:-1;
ID:88;X:-197978;Y:-200096;D:-1;
ID:88;X:-197946;Y:-200096;D:-1;
ID:88;X:-197914;Y:-200096;D:-1;
ID:88;X:-197882;Y:-200096;D:-1;
ID:88;X:-197850;Y:-200096;D:-1;
ID:88;X:-197818;Y:-200096;D:-1;
ID:88;X:-197786;Y:-200096;D:-1;
ID:88;X:-197754;Y:-200096;D:-1;
ID:88;X:-197722;Y:-200096;D:-1;
ID:88;X:-197690;Y:-200096;D:-1;
ID:88;X:-197658;Y:-200096;D:-1;
ID:88;X:-197626;Y:-200096;D:-1;
ID:88;X:-197594;Y:-200096;D:-1;
ID:88;X:-197562;Y:-200096;D:-1;
ID:88;X:-197530;Y:-200096;D:-1;
ID:88;X:-197498;Y:-200096;D:-1;
ID:88;X:-197466;Y:-200096;D:-1;
ID:88;X:-197434;Y:-200096;D:-1;
ID:88;X:-197402;Y:-200096;D:-1;
ID:88;X:-197370;Y:-200096;D:-1;
ID:88;X:-197338;Y:-200096;D:-1;
ID:88;X:-197306;Y:-200096;D:-1;
ID:88;X:-197274;Y:-200096;D:-1;
ID:88;X:-197242;Y:-200096;D:-1;
ID:88;X:-197210;Y:-200096;D:-1;
ID:88;X:-197178;Y:-200096;D:-1;
ID:88;X:-197146;Y:-200096;D:-1;
ID:88;X:-197114;Y:-200096;D:-1;
ID:88;X:-197082;Y:-200096;D:-1;
ID:88;X:-197050;Y:-200096;D:-1;
ID:88;X:-197018;Y:-200096;D:-1;
ID:88;X:-196986;Y:-200096;D:-1;
ID:88;X:-196954;Y:-200096;D:-1;
ID:88;X:-196922;Y:-200096;D:-1;
ID:88;X:-196890;Y:-200096;D:-1;
ID:88;X:-196858;Y:-200096;D:-1;
ID:88;X:-196826;Y:-200096;D:-1;
ID:88;X:-196794;Y:-200096;D:-1;
ID:88;X:-196762;Y:-200096;D:-1;
ID:88;X:-196730;Y:-200096;D:-1;
ID:88;X:-196698;Y:-200096;D:-1;
ID:88;X:-196666;Y:-200096;D:-1;
ID:88;X:-196634;Y:-200096;D:-1;
ID:88;X:-196602;Y:-200096;D:-1;
ID:88;X:-196570;Y:-200096;D:-1;
ID:88;X:-196538;Y:-200096;D:-1;
ID:88;X:-196506;Y:-200096;D:-1;
ID:88;X:-196474;Y:-200096;D:-1;
ID:88;X:-196442;Y:-200096;D:-1;
ID:88;X:-196410;Y:-200096;D:-1;
ID:88;X:-196378;Y:-200096;D:-1;
ID:88;X:-196346;Y:-200096;D:-1;
ID:88;X:-196314;Y:-200096;D:-1;
ID:88;X:-196282;Y:-200096;D:-1;
ID:88;X:-196250;Y:-200096;D:-1;
ID:88;X:-196218;Y:-200096;D:-1;
ID:88;X:-196186;Y:-200096;D:-1;
ID:88;X:-196154;Y:-200096;D:-1;
ID:88;X:-196122;Y:-200096;D:-1;
ID:88;X:-196090;Y:-200096;D:-1;
ID:88;X:-196058;Y:-200096;D:-1;
ID:88;X:-196026;Y:-200096;D:-1;
ID:88;X:-195994;Y:-200096;D:-1;
ID:88;X:-195962;Y:-200096;D:-1;
ID:88;X:-195930;Y:-200096;D:-1;
ID:88;X:-195898;Y:-200096;D:-1;
ID:88;X:-195866;Y:-200096;D:-1;
ID:88;X:-195834;Y:-200096;D:-1;
ID:88;X:-195802;Y:-200096;D:-1;
ID:88;X:-195770;Y:-200096;D:-1;
ID:88;X:-195738;Y:-200096;D:-1;
ID:88;X:-195706;Y:-200096;D:-1;
ID:88;X:-195674;Y:-200096;D:-1;
ID:88;X:-195642;Y:-200096;D:-1;
ID:88;X:-195610;Y:-200096;D:-1;
ID:88;X:-195578;Y:-200096;D:-1;
ID:88;X:-195546;Y:-200096;D:-1;
ID:88;X:-195514;Y:-200096;D:-1;
ID:88;X:-195482;Y:-200096;D:-1;
ID:88;X:-195450;Y:-200096;D:-1;
ID:88;X:-195418;Y:-200096;D:-1;
ID:88;X:-195386;Y:-200096;D:-1;
ID:88;X:-195354;Y:-200096;D:-1;
ID:88;X:-195322;Y:-200096;D:-1;
ID:88;X:-195290;Y:-200096;D:-1;
ID:88;X:-195258;Y:-200096;D:-1;
ID:88;X:-195226;Y:-200096;D:-1;
ID:88;X:-195194;Y:-200096;D:-1;
ID:88;X:-195162;Y:-200096;D:-1;
ID:88;X:-195130;Y:-200096;D:-1;
ID:88;X:-195098;Y:-200096;D:-1;
ID:88;X:-195066;Y:-200096;D:-1;
ID:88;X:-195034;Y:-200096;D:-1;
ID:88;X:-195002;Y:-200096;D:-1;
ID:88;X:-194970;Y:-200096;D:-1;
ID:88;X:-194938;Y:-200096;D:-1;
ID:88;X:-194906;Y:-200096;D:-1;
ID:88;X:-194874;Y:-200096;D:-1;
ID:88;X:-194842;Y:-200096;D:-1;
ID:88;X:-194810;Y:-200096;D:-1;
ID:88;X:-194778;Y:-200096;D:-1;
ID:88;X:-194746;Y:-200096;D:-1;
ID:88;X:-194714;Y:-200096;D:-1;
ID:88;X:-194682;Y:-200096;D:-1;
ID:88;X:-194650;Y:-200096;D:-1;
ID:88;X:-194618;Y:-200096;D:-1;
ID:88;X:-194586;Y:-200096;D:-1;
ID:88;X:-194554;Y:-200096;D:-1;
ID:88;X:-194522;Y:-200096;D:-1;
ID:88;X:-194490;Y:-200096;D:-1;
ID:88;X:-194458;Y:-200096;D:-1;
ID:88;X:-194426;Y:-200096;D:-1;
ID:88;X:-194394;Y:-200096;D:-1;
ID:88;X:-194362;Y:-200096;D:-1;
ID:88;X:-194330;Y:-200096;D:-1;
ID:88;X:-194298;Y:-200096;D:-1;
ID:88;X:-194266;Y:-200096;D:-1;
ID:88;X:-194234;Y:-200096;D:-1;
ID:88;X:-194202;Y:-200096;D:-1;
ID:88;X:-194170;Y:-200096;D:-1;
ID:88;X:-194138;Y:-200096;D:-1;
ID:88;X:-194106;Y:-200096;D:-1;
ID:88;X:-194074;Y:-200096;D:-1;
ID:88;X:-194042;Y:-200096;D:-1;
ID:88;X:-194010;Y:-200096;D:-1;
ID:88;X:-193978;Y:-200096;D:-1;
ID:88;X:-193946;Y:-200096;D:-1;
ID:88;X:-193914;Y:-200096;D:-1;
ID:88;X:-193882;Y:-200096;D:-1;
ID:88;X:-193850;Y:-200096;D:-1;
ID:88;X:-193818;Y:-200096;D:-1;
ID:88;X:-193786;Y:-200096;D:-1;
ID:88;X:-193754;Y:-200096;D:-1;
ID:88;X:-193722;Y:-200096;D:-1;
ID:88;X:-193690;Y:-200096;D:-1;
ID:88;X:-193658;Y:-200096;D:-1;
ID:88;X:-193626;Y:-200096;D:-1;
ID:88;X:-193594;Y:-200096;D:-1;
ID:88;X:-193562;Y:-200096;D:-1;
ID:88;X:-193530;Y:-200096;D:-1;
ID:88;X:-193498;Y:-200096;D:-1;
ID:88;X:-193466;Y:-200096;D:-1;
ID:88;X:-193434;Y:-200096;D:-1;
ID:88;X:-193402;Y:-200096;D:-1;
ID:88;X:-193370;Y:-200096;D:-1;
ID:88;X:-193338;Y:-200096;D:-1;
ID:88;X:-193306;Y:-200096;D:-1;
ID:88;X:-193274;Y:-200096;D:-1;
ID:88;X:-193242;Y:-200096;D:-1;
ID:88;X:-193210;Y:-200096;D:-1;
ID:88;X:-193178;Y:-200096;D:-1;
ID:88;X:-193146;Y:-200096;D:-1;
ID:88;X:-193114;Y:-200096;D:-1;
ID:88;X:-193082;Y:-200096;D:-1;
ID:88;X:-193050;Y:-200096;D:-1;
ID:88;X:-193018;Y:-200096;D:-1;
ID:88;X:-192986;Y:-200096;D:-1;
ID:88;X:-192954;Y:-200096;D:-1;
ID:88;X:-192922;Y:-200096;D:-1;
ID:88;X:-192890;Y:-200096;D:-1;
ID:88;X:-192858;Y:-200096;D:-1;
ID:88;X:-192826;Y:-200096;D:-1;
ID:88;X:-192794;Y:-200096;D:-1;
ID:88;X:-192762;Y:-200096;D:-1;
ID:88;X:-192730;Y:-200096;D:-1;
ID:88;X:-192698;Y:-200096;D:-1;
ID:88;X:-192666;Y:-200096;D:-1;
ID:88;X:-192634;Y:-200096;D:-1;
ID:88;X:-192602;Y:-200096;D:-1;
ID:88;X:-192570;Y:-200096;D:-1;
ID:88;X:-192538;Y:-200096;D:-1;
ID:88;X:-192506;Y:-200096;D:-1;
ID:88;X:-192474;Y:-200096;D:-1;
ID:88;X:-192442;Y:-200096;D:-1;
ID:88;X:-192410;Y:-200096;D:-1;
ID:88;X:-192378;Y:-200096;D:-1;
ID:11;X:-192352;Y:-200096;D:-1;
ID:103;X:-199582;Y:-200320;D:-1;
ID:103;X:-199262;Y:-200320;D:-1;
ID:103;X:-199262;Y:-200352;D:-1;
ID:103;X:-198942;Y:-200320;D:-1;
ID:103;X:-198942;Y:-200352;D:-1;
ID:103;X:-198942;Y:-200384;D:-1;
ID:103;X:-198622;Y:-200320;D:-1;
ID:103;X:-198622;Y:-200352;D:-1;
ID:103;X:-198622;Y:-200384;D:-1;
ID:103;X:-198622;Y:-200416;D:-1;
ID:103;X:-198302;Y:-200320;D:-1;
ID:103;X:-198302;Y:-200352;D:-1;
ID:103;X:-198302;Y:-200384;D:-1;
ID:103;X:-198302;Y:-200416;D:-1;
ID:103;X:-198302;Y:-200448;D:-1;
ID:103;X:-197982;Y:-200320;D:-1;
ID:103;X:-197982;Y:-200352;D:-1;
ID:103;X:-197982;Y:-200384;D:-1;
ID:103;X:-197982;Y:-200416;D:-1;
ID:103;X:-197982;Y:-200448;D:-1;
ID:103;X:-197982;Y:-200480;D:-1;
ID:103;X:-197662;Y:-200320;D:-1;
ID:103;X:-197662;Y:-200352;D:-1;
ID:103;X:-197662;Y:-200384;D:-1;
ID:103;X:-197662;Y:-200416;D:-1;
ID:103;X:-197662;Y:-200448;D:-1;
ID:103;X:-197662;Y:-200480;D:-1;
ID:103;X:-197662;Y:-200512;D:-1;
ID:103;X:-197342;Y:-200320;D:-1;
ID:103;X:-197342;Y:-200352;D:-1;
ID:103;X:-197342;Y:-200384;D:-1;
ID:103;X:-197342;Y:-200416;D:-1;
ID:103;X:-197342;Y:-200448;D:-1;
ID:103;X:-197342;Y:-200480;D:-1;
ID:103;X:-197342;Y:-200512;D:-1;
ID:103;X:-197342;Y:-200544;D:-1;
ID:103;X:-197022;Y:-200320;D:-1;
ID:103;X:-197022;Y:-200352;D:-1;
ID:103;X:-197022;Y:-200384;D:-1;
ID:103;X:-197022;Y:-200416;D:-1;
ID:103;X:-197022;Y:-200448;D:-1;
ID:103;X:-197022;Y:-200480;D:-1;
ID:103;X:-197022;Y:-200512;D:-1;
ID:103;X:-197022;Y:-200544;D:-1;
ID:103;X:-197022;Y:-200576;D:-1;
ID:258;X:-196700;Y:-200320;D:-1;
ID:258;X:-196380;Y:-200320;D:-1;
ID:103;X:-196382;Y:-200352;D:-1;
ID:103;X:-196062;Y:-200352;D:-1;
ID:258;X:-196060;Y:-200320;D:-1;
ID:103;X:-196062;Y:-200384;D:-1;
ID:103;X:-195742;Y:-200352;D:-1;
ID:103;X:-195742;Y:-200384;D:-1;
ID:258;X:-195740;Y:-200320;D:-1;
ID:258;X:-195420;Y:-200320;D:-1;
ID:258;X:-195100;Y:-200320;D:-1;
ID:258;X:-194780;Y:-200320;D:-1;
ID:258;X:-194460;Y:-200320;D:-1;
ID:258;X:-194140;Y:-200320;D:-1;
ID:258;X:-193820;Y:-200320;D:-1;
ID:103;X:-195422;Y:-200352;D:-1;
ID:103;X:-195422;Y:-200384;D:-1;
ID:103;X:-195422;Y:-200416;D:-1;
ID:103;X:-195102;Y:-200352;D:-1;
ID:103;X:-195102;Y:-200384;D:-1;
ID:103;X:-195102;Y:-200416;D:-1;
ID:103;X:-195102;Y:-200448;D:-1;
ID:103;X:-194782;Y:-200352;D:-1;
ID:103;X:-194782;Y:-200384;D:-1;
ID:103;X:-194782;Y:-200416;D:-1;
ID:103;X:-194782;Y:-200448;D:-1;
ID:103;X:-194782;Y:-200480;D:-1;
ID:103;X:-194462;Y:-200352;D:-1;
ID:103;X:-194462;Y:-200384;D:-1;
ID:103;X:-194462;Y:-200416;D:-1;
ID:103;X:-194462;Y:-200448;D:-1;
ID:103;X:-194462;Y:-200480;D:-1;
ID:103;X:-194462;Y:-200512;D:-1;
ID:103;X:-194142;Y:-200352;D:-1;
ID:103;X:-194142;Y:-200384;D:-1;
ID:103;X:-194142;Y:-200416;D:-1;
ID:103;X:-194142;Y:-200448;D:-1;
ID:103;X:-194142;Y:-200480;D:-1;
ID:103;X:-194142;Y:-200512;D:-1;
ID:103;X:-194142;Y:-200544;D:-1;
ID:103;X:-193822;Y:-200352;D:-1;
ID:103;X:-193822;Y:-200384;D:-1;
ID:103;X:-193822;Y:-200416;D:-1;
ID:103;X:-193822;Y:-200448;D:-1;
ID:103;X:-193822;Y:-200480;D:-1;
ID:103;X:-193822;Y:-200512;D:-1;
ID:103;X:-193822;Y:-200544;D:-1;
ID:103;X:-193822;Y:-200576;D:-1;
ID:103;X:-193502;Y:-200352;D:-1;
ID:103;X:-193502;Y:-200384;D:-1;
ID:103;X:-193502;Y:-200416;D:-1;
ID:103;X:-193502;Y:-200448;D:-1;
ID:103;X:-193502;Y:-200480;D:-1;
ID:103;X:-193502;Y:-200512;D:-1;
ID:103;X:-193502;Y:-200544;D:-1;
ID:103;X:-193502;Y:-200576;D:-1;
ID:103;X:-193502;Y:-200608;D:-1;
ID:258;X:-193500;Y:-200320;D:-1;
ID:258;X:-193180;Y:-200320;D:-1;
ID:258;X:-193180;Y:-200352;D:-1;
ID:258;X:-192860;Y:-200320;D:-1;
ID:258;X:-192860;Y:-200352;D:-1;
ID:258;X:-192540;Y:-200320;D:-1;
ID:258;X:-192540;Y:-200352;D:-1;
ID:103;X:-193182;Y:-200384;D:-1;
ID:103;X:-192862;Y:-200384;D:-1;
ID:103;X:-192862;Y:-200416;D:-1;
ID:103;X:-192542;Y:-200384;D:-1;
ID:103;X:-192542;Y:-200416;D:-1;
ID:103;X:-192542;Y:-200448;D:-1;
NPC_END
LAYERS
LR:"Default";
LR:"Destroyed Blocks";HD:1;
LR:"Spawned NPCs";
LAYERS_END
EVENTS_CLASSIC
ET:"Level - Start";PC:000110000011;AS:0;AX:0;AY:0;
ET:"P Switch - Start";AS:0;AX:0;AY:0;
ET:"P Switch - End";AS:0;AX:0;AY:0;
EVENTS_CLASSIC_END


================================================
FILE: test/worlds/speedrun-unit-test/unit-test.wldx
================================================
HEAD
TL:"Speed-run unit-test";DC:11101;IT:"unit-test.lvlx";CPID:"SMBX1.3Compat";
HEAD_END
LEVELS
ID:12;X:0;Y:0;LT:"Auto-runnable level";LF:"unit-test.lvlx";SP:1;
LEVELS_END


================================================
FILE: utils/convertkit/GIFs2PNG/CMakeLists.txt
================================================
cmake_minimum_required (VERSION 3.5)
project(MoondustGIFs2PNG LANGUAGES C CXX)

include(CheckCXXCompilerFlag)
include(ExternalProject)
include(GNUInstallDirs)

set(CMAKE_INSTALL_RPATH ".")
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)

set(DEPENDENCIES_INSTALL_DIR ${CMAKE_BINARY_DIR}/output)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/bin)

foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
    message("--> ${OUTPUTCONFIG}")
    string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}")
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES )

set(PGE_INSTALL_DIRECTORY "GIFs2PNG")

include_directories(
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${DEPENDENCIES_INSTALL_DIR}/include
)
link_directories(${DEPENDENCIES_INSTALL_DIR}/lib)

if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
    message("== Using default build configuration which is a Release!")
endif()

if(NOT WIN32 AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX))
    check_cxx_compiler_flag("-no-pie" HAS_NO_PIE)
endif()

function(pge_set_nopie _target)
    set_target_properties(${_target} PROPERTIES
        POSITION_INDEPENDENT_CODE False
    )
    if(HAS_NO_PIE AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX))
        set_property(TARGET ${_target} APPEND_STRING PROPERTY LINK_FLAGS " -no-pie")
    endif()
endfunction()

# Version
include(version.cmake)
# Default GIT version
include(../../../cmake/git_version.cmake)
# Common building properties and optimization flags
include(../../../cmake/build_props.cmake)

include(../../../lib/tclap/tclap.cmake)
include(../../../lib/DirManager/dirman.cmake)
include(../../../lib/Utils/Utils.cmake)
include(../../../lib/FileMapper/FileMapper.cmake)
include(../../../lib/Utf8Main/utf8main.cmake)
include(../../../lib/IniProcessor/IniProcessor.cmake)
include(../../../lib/Graphics/bitmask2rgba.cmake)

pge_cxx_standard(14)

set(GIFs2PNG_SRCS)

list(APPEND GIFs2PNG_SRCS
    gifs2png.cpp
    common_features/config_manager.cpp
)

if(WIN32 AND NOT EMSCRIPTEN)
    list(APPEND GIFs2PNG_SRCS
        _resources/gifs2png.rc
    )
endif()

add_executable(GIFs2PNG
    ${GIFs2PNG_SRCS}
    ${DIRMANAGER_SRCS}
    ${FILEMAPPER_SRCS}
    ${INIPROCESSOR_SRCS}
    ${UTF8MAIN_SRCS}
    ${UTILS_SRCS}
    ${BITMASK2RGBA_SRCS}
)

if(WIN32 AND NOT EMSCRIPTEN)
    target_compile_definitions(GIFs2PNG
        PUBLIC
        -DUNICODE
        -D_UNICODE
        -DNOMINMAX
    )
    if(MSVC)
        target_compile_definitions(GIFs2PNG PRIVATE -DWIN32_CONSOLE)
    endif()
endif()

string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER)
if(${CMAKE_BUILD_TYPE_LOWER} STREQUAL "debug")
    target_compile_definitions(GIFs2PNG
        PRIVATE
        -DDEBUG_BUILD
    )
endif()

include(../../../cmake/library_FreeImage.cmake)

add_dependencies(GIFs2PNG
    FreeImage_Local
)

set(GIFs2PNG_LINK_LIBS)
set(GIFs2PNG_INSTALLS)

list(APPEND GIFs2PNG_LINK_LIBS
    ${UTILS_LIBS}
    PGE_FreeImage
)

list(APPEND GIFs2PNG_INSTALLS
    GIFs2PNG
)

if(NOT APPLE AND NOT MSVC AND NOT USE_SYSTEM_LIBC)
    set_property(TARGET GIFs2PNG APPEND_STRING PROPERTY LINK_FLAGS "-static-libgcc -static-libstdc++")
endif()

if(NOT EMSCRIPTEN AND NOT MSVC)
    if(WIN32)
        set_target_properties(GIFs2PNG PROPERTIES WIN32_EXECUTABLE OFF)
        list(APPEND GIFs2PNG_LINK_LIBS "-static")
    endif()
    find_library(_LIB_PTHREAD pthread)
    if(_LIB_PTHREAD)
        list(APPEND GIFs2PNG_LINK_LIBS ${_LIB_PTHREAD})
    endif()
endif()

target_link_libraries(GIFs2PNG
    ${GIFs2PNG_LINK_LIBS}
)

pge_set_nopie(GIFs2PNG)

install(TARGETS ${GIFs2PNG_INSTALLS}
        RUNTIME DESTINATION "${PGE_INSTALL_DIRECTORY}/"
)


================================================
FILE: utils/convertkit/GIFs2PNG/_resources/cat_gif2png/make_icns.sh
================================================
#!/bin/bash

TYPE="${PWD##*/}"
if [[ "$TYPE" == "" ]]; then
echo "Error: empty name!"
exit 1
fi

mkdir $TYPE".iconset"
cp $TYPE"_16.png" $TYPE".iconset/icon_16x16.png"
sips -Z 32 $TYPE".iconset/icon_16x16.png" --out $TYPE".iconset/icon_16x16@2x.png"
cp $TYPE"_32.png" $TYPE".iconset/icon_32x32.png"
sips -Z 64 $TYPE".iconset/icon_32x32.png" --out $TYPE".iconset/icon_32x32@2x.png"
cp $TYPE"_48.png" $TYPE".iconset/icon_48x48.png"
sips -Z 96 $TYPE".iconset/icon_48x48.png" --out $TYPE".iconset/icon_48x48@2x.png"
cp $TYPE"_256.png" $TYPE".iconset/icon_256x256.png"
cp $TYPE"_256.png" $TYPE".iconset/icon_128x128@2x.png"
sips -Z 512 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_256x256@2x.png"
#sips -Z 512 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_512x512.png"
sips -Z 128 $TYPE".iconset/icon_256x256.png" --out $TYPE".iconset/icon_128x128.png"

echo "makeIcon..."

iconutil -c icns $TYPE".iconset"
mv $TYPE".icns" ../

rm -Rf $TYPE".iconset"


================================================
FILE: utils/convertkit/GIFs2PNG/_resources/gifs2png.qrc
================================================
<RCC>
    <qresource prefix="/">
        <file>cat_gif2png.icns</file>
        <file>cat_gif2png.ico</file>
    </qresource>
</RCC>


================================================
FILE: utils/convertkit/GIFs2PNG/_resources/gifs2png.rc
================================================
IDI_ICON1               ICON    DISCARDABLE     "cat_gif2png.ico"

#include <windows.h>
#include "../version.h"

VS_VERSION_INFO     VERSIONINFO
FILEVERSION         V_VF1, V_VF2, V_VF3, V_VF4
PRODUCTVERSION      V_VP1, V_VP2, V_VP3, V_VP4
FILEFLAGSMASK       0x3fL
FILEFLAGS           0
FILEOS              VOS_NT_WINDOWS32
FILETYPE            VFT_APP
FILESUBTYPE         VFT2_UNKNOWN
BEGIN
BLOCK   "VarFileInfo"
BEGIN
    VALUE   "Translation",  0x409,  1200
END
BLOCK   "StringFileInfo"
BEGIN
    BLOCK   "040904b0"
    BEGIN
        VALUE   "CompanyName",      V_COMPANY
        VALUE   "FileDescription",  V_FILE_DESC
        VALUE   "FileVersion",      V_FILE_VERSION V_FILE_RELEASE
        VALUE   "InternalName",     V_INTERNAL_NAME
        VALUE   "LegalCopyright",   V_COPYRIGHT
        VALUE   "OriginalFilename", V_ORIGINAL_NAME
        VALUE   "ProductName",      V_PRODUCT_NAME
        VALUE   "ProductVersion",   V_VERSION V_RELEASE
    END
END
END


================================================
FILE: utils/convertkit/GIFs2PNG/common_features/config_manager.cpp
================================================
#include "config_manager.h"

#include <IniProcessor/ini_processing.h>
#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <algorithm>

std::string g_ApplicationPath = "./";

static void addSlashToTail(std::string &str)
{
    if(str.empty())
        return;

    if((str.back() != '/') && (str.back() != '\\'))
        str.push_back('/');
}

static void removeDoubleSlash(std::string &dir)
{
    std::string dirN;
    dirN.reserve(dir.size());
    char c_prev = 0;
    for(char c : dir)
    {
        if(c != c_prev)
            dirN.push_back(c);
        c_prev = (c == '/') ? c : 0;
    }
    dir = dirN;
}

ConfigPackMiniManager::ConfigPackMiniManager() :
    m_is_using(false)
{}

void ConfigPackMiniManager::setConfigDir(const std::string &config_dir)
{
    if(config_dir.empty())
        return;

    DirMan confDir(config_dir);

    if(!confDir.exists())
        return;

    if(!Files::fileExists(confDir.absolutePath() + "/main.ini"))
        return;

    m_cp_root_path = confDir.absolutePath() + "/";

    std::string main_ini = m_cp_root_path + "main.ini";
    IniProcessing mainset(main_ini);

    std::string customAppPath = g_ApplicationPath;
    customAppPath.push_back('/');

    m_dir_list.clear();
    m_dir_listUQ.insert(m_cp_root_path);

    mainset.beginGroup("main");
    {
        customAppPath = mainset.value("application-path", customAppPath).toString();
        std::replace(customAppPath.begin(), customAppPath.end(), '\\', '/');

        m_cp_root_path = (mainset.value("application-dir", false).toBool() ?
                              customAppPath + "/" : m_cp_root_path + "/data/" );

        std::string tmpPath;

        mainset.read("graphics-level", tmpPath, "data/graphics/level");
        addIntoDirList(m_cp_root_path + tmpPath);

        mainset.read("graphics-worldmap", tmpPath, "data/graphics/worldmap");
        addIntoDirList(m_cp_root_path + tmpPath);

        mainset.read("graphics-characters", tmpPath, "data/graphics/characters");
        addIntoDirList(m_cp_root_path + tmpPath);

        mainset.read("custom-data", tmpPath, "data-custom");
        addIntoDirList(m_cp_root_path + tmpPath);
    }
    mainset.endGroup();

    m_is_using = true;
}

bool ConfigPackMiniManager::isUsing()
{
    return m_is_using;
}

void ConfigPackMiniManager::addIntoDirList(std::string dir)
{
    appendDir(dir);
    appendDirList(dir);
}

void ConfigPackMiniManager::appendDir(std::string dir)
{
    std::replace(dir.begin(), dir.end(), '\\', '/');
    removeDoubleSlash(dir);
    addSlashToTail(dir);
    if(m_dir_listUQ.find(dir) == m_dir_listUQ.end())
    {
        m_dir_list.push_back(dir);
        m_dir_listUQ.insert(dir);
    }

}

void ConfigPackMiniManager::appendDirList(const std::string& dir)
{
    DirMan dirs(dir);
    std::vector<std::string> folders;
    if(dirs.getListOfFolders(folders))
    {
        for(std::string &f : folders)
        {
            std::string newpath = dirs.absolutePath() + "/" + f;
            appendDir(newpath);
        }
    }
}

std::string ConfigPackMiniManager::getFile(const std::string &file, std::string customPath, bool *isReadonly)
{
    if(!customPath.empty())
        addSlashToTail(customPath);

    if(!m_is_using)
    {
        if(isReadonly)
            *isReadonly = false;
        return customPath + file;
    }

    if(!customPath.empty() && Files::fileExists(customPath + file))
    {
        if(isReadonly)
            *isReadonly = false;
        return customPath + file;
    }

    if(isReadonly)
        *isReadonly = true; //File is not custom, must not be removed!

    for(std::vector<std::string>::reverse_iterator it = m_dir_list.rbegin();
        it != m_dir_list.rend();
        it++)
    {
        std::string path = *it;
        addSlashToTail(path);
        if(Files::fileExists(path + file))
            return path + file;
    }
    return customPath + file;
}


================================================
FILE: utils/convertkit/GIFs2PNG/common_features/config_manager.h
================================================
#pragma once
#ifndef CONFIGMANAGER_H
#define CONFIGMANAGER_H

#include <string>
#include <vector>
#include <set>

extern std::string g_ApplicationPath;

class ConfigPackMiniManager
{
public:
    typedef std::vector<std::string> StringList;
    ConfigPackMiniManager();
    ~ConfigPackMiniManager() {}

    /**
     * @brief Initialize config pack's directory tree
     * @param config_dir path to config pack's root directory
     */
    void setConfigDir(const std::string &config_dir);
    /**
     * @brief Is config pack initialized and in use?
     * @return true if config pack is initialized
     */
    bool isUsing();

    /**
     * @brief Add a data directory with all it's sub-directories with depth 1
     * @param dir Path to data directory to add
     */
    void addIntoDirList(std::string dir);

    /**
     * @brief Add a single data directory
     * @param dir Path to data directory to add
     */
    void appendDir(std::string dir);
    /**
     * @brief Append all sub-directories in this directory
     * @param dir Path to data directory to add it's sub-directories
     */
    void appendDirList(const std::string &dir);

    /**
     * @brief Find file in added data directories
     * @param [__in] file file to find
     * @param [__in] customPath custom directory path
     * @param [__out] isReadonly Is file a part of config pack (true) or is a custom file which located in same folder as custom Path (false)
     * @return absolute path to found file. Empty string if no files are found.
     */
    std::string getFile(const std::string &file, std::string customPath = "", bool *isReadonly = nullptr);

private:
    bool                    m_is_using;
    std::string             m_cp_root_path;
    std::string             m_custom_path;
    //! Unique checking list
    std::set<std::string>    m_dir_listUQ;
    //! Ordered list of folderd by priority sequence
    std::vector<std::string> m_dir_list;
};

#endif // CONFIGMANAGER_H


================================================
FILE: utils/convertkit/GIFs2PNG/gifs2png.cpp
================================================
/*
 * GIFs2PNG, a free tool for merge GIF images with his masks and save into PNG
 * This is a part of the Platformer Game Engine by Wohlstand, a free platform for game making
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <locale>
#include <iostream>
#include <set>
#include <algorithm>
#include <cctype>
#include <stdio.h>

#include <FileMapper/file_mapper.h>
#include <DirManager/dirman.h>
#include <Utils/files.h>
#include <Graphics/bitmask2rgba.h>
#include <Utf8Main/utf8main.h>
#include <tclap/CmdLine.h>
#include "version.h"

#include <FreeImageLite.h>

#include "common_features/config_manager.h"

static FIBITMAP *loadImage(const std::string &file, bool convertTo32bit = true)
{
#if  defined(__unix__) || defined(__APPLE__) || defined(_WIN32)
    FileMapper fileMap;
    if(!fileMap.open_file(file.c_str()))
        return nullptr;

    FIMEMORY *imgMEM = FreeImage_OpenMemory(reinterpret_cast<unsigned char *>(fileMap.data()),
                                            (unsigned int)fileMap.size());
    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);
    if(formato  == FIF_UNKNOWN)
        return nullptr;
    FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);
    FreeImage_CloseMemory(imgMEM);
    fileMap.close_file();
    if(!img)
        return nullptr;
#else
    FREE_IMAGE_FORMAT formato = FreeImage_GetFileType(file.c_str(), 0);
    if(formato  == FIF_UNKNOWN)
        return nullptr;
    FIBITMAP *img = FreeImage_Load(formato, file.c_str());
    if(!img)
        return nullptr;
#endif

    if(convertTo32bit)
    {
        FIBITMAP *temp;
        temp = FreeImage_ConvertTo32Bits(img);
        if(!temp)
            return nullptr;
        FreeImage_Unload(img);
        img = temp;
    }
    return img;
}

static void mergeBitBltToRGBA(FIBITMAP *image, const std::string &pathToMask, FIBITMAP *extMask = nullptr)
{
    if(!image)
        return;

    if(!Files::fileExists(pathToMask) && !extMask)
        return; //Nothing to do

    FIBITMAP *mask = extMask ? extMask : loadImage(pathToMask);

    if(!mask)
        return;//Nothing to do

    bitmask_to_rgba(image, mask);

    if(!extMask)
        FreeImage_Unload(mask);
}


struct GIFs2PNG_Setup
{
    //! Input path (folder)
    std::string pathIn;
    //! Is a list of files mode (otherwise, checking entire folder)
    bool listOfFiles        = false;

    //! Output path (folder where destinition images will be saved)
    std::string pathOut;
    //! Put every image into same folder where original is located
    bool pathOutSame        = false;

    //! Path to configuration package which a source of missing mask files
    std::string configPath;
    //! List of masks (which are located in the episode-folder, are dependent to sub-directories and must be deleted after conversion completion)
    std::set<std::string> deleteLater;

    //! Source images are will be removed after conversion
    bool removeSource       = false;
    //! Scan also all subdirectories, otherwise only current folder content will be converted
    bool walkSubDirs        = false;
    //! Skip background2-*.gif images (which are rendering buggy in LunaLua in PNG format, in GIF there are valid)
    bool skipBackground2    = false;
    //! Count of successfully converted images
    unsigned int count_success  = 0;
    //! Count of failed conversions
    unsigned int count_failed   = 0;
    //! Count of skipped image conversions
    unsigned int count_skipped  = 0;
};

static inline void delEndSlash(std::string &dirPath)
{
    if(!dirPath.empty())
    {
        char last = dirPath[dirPath.size() - 1];
        if((last == '/') || (last == '\\'))
            dirPath.resize(dirPath.size() - 1);
    }
}

static inline void getGifMask(std::string &mask, const std::string &front)
{
    mask = front;
    //Make mask filename
    size_t dotPos = mask.find_last_of('.');
    if(dotPos == std::string::npos)
        mask.push_back('m');
    else
        mask.insert(mask.begin() + std::string::difference_type(dotPos), 'm');
}

void doGifs2PNG(std::string pathIn,  std::string imgFileIn,
                std::string pathOut,
                GIFs2PNG_Setup &setup,
                ConfigPackMiniManager &cnf)
{
    if(Files::hasSuffix(imgFileIn, "m.gif"))
        return; //Skip mask files

    //! Lower-case filename for case-insensitive checks
    std::string imgFileInL = imgFileIn;
    std::transform(imgFileInL.begin(), imgFileInL.end(), imgFileInL.begin(),
                   [](unsigned char c){ return std::tolower(c); });

    std::string imgPathIn = pathIn + "/" + imgFileIn;
    std::string maskPathIn;

    std::cout << imgPathIn;
    std::cout.flush();

    bool isBackground2 = (imgFileInL.compare(0, 11, "background2", 11) == 0);

    if(setup.skipBackground2 && isBackground2)
    {
        setup.count_skipped++;
        std::cout << "...SKIP!\n";
        std::cout.flush();
        return;
    }

    std::string maskFileIn;
    bool maskIsReadOnly = false;
    getGifMask(maskFileIn, imgFileIn);

    maskPathIn = cnf.getFile(maskFileIn, pathIn, &maskIsReadOnly);

    FIBITMAP *image = loadImage(imgPathIn);
    if(!image)
    {
        setup.count_failed++;
        std::cout << "...CAN'T OPEN!\n";
        std::cout.flush();
        return;
    }

    bool isFail = false;
    bool maskIsExists = Files::fileExists(maskPathIn);

    if(maskIsExists) /* When mask exists, use it */
        mergeBitBltToRGBA(image, maskPathIn);
    else if(!isBackground2)/* Try to find the PNG as source of the mask, except of backgrounds */
    {
        maskFileIn = Files::changeSuffix(imgFileIn, ".png");
        maskPathIn = cnf.getFile(maskFileIn);
        std::cout << ".chkPNG.";
        if(Files::fileExists(maskPathIn))
        {
            FIBITMAP *front = loadImage(maskPathIn);
            if(front)
            {
                FIBITMAP *mask = nullptr;
                std::cout << ".PNG-AS-MASK.";
                bitmask_get_mask_from_rgba(front, &mask);
                FreeImage_Unload(front);
                mergeBitBltToRGBA(image, "", mask);
                FreeImage_Unload(mask);
            }
            else
            {
                std::cout << ".NO-MASK.";
            }
        }
    }

    if(image)
    {
        std::string outPath = pathOut + "/" + Files::changeSuffix(imgFileIn, ".png");
        int ret = FreeImage_Save(FIF_PNG, image, outPath.c_str());
        if(!ret)
        {
            std::cout << "...F-WRT FAILED!\n";
            isFail = true;
        }
        FreeImage_Unload(image);
    }

    if(isFail)
    {
        setup.count_failed++;
        std::cout << "...FAILED!\n";
    }
    else
    {
        setup.count_success++;
        if(setup.removeSource)// Detele old files
        {
            if(Files::deleteFile(imgPathIn))
                std::cout << ".F-DEL.";
            //Try to delete or delete-late mask if it is exist and is not read-only
            if(maskIsExists && !maskIsReadOnly)
            {
                /* Delete-Later if mask file is stored in the root of episode directory.
                   Mask file is dependent to images are inside the subfolder */
                if(!setup.listOfFiles && setup.walkSubDirs && (setup.pathIn == Files::dirname(maskPathIn)))
                    setup.deleteLater.insert(maskPathIn);
                else if(Files::deleteFile(maskPathIn)) //Or just delete the mask file
                    std::cout << ".M-DEL.";
            }
        }
        std::cout << "...done\n";
    }

    std::cout.flush();
}


int main(int argc, char *argv[])
{
    if(argc > 0)
        g_ApplicationPath = Files::dirname(argv[0]);
    g_ApplicationPath = DirMan(g_ApplicationPath).absolutePath();

    DirMan imagesDir;
    std::vector<std::string> fileList;
    FreeImage_Initialise();
    ConfigPackMiniManager config;

    GIFs2PNG_Setup setup;

    try
    {
        // Define the command line object.
        TCLAP::CmdLine  cmd(V_FILE_DESC "\n"
                            "Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>\n"
                            "This program is distributed under the GNU GPLv3+ license\n", ' ', V_FILE_VERSION V_FILE_RELEASE);

        TCLAP::SwitchArg switchRemove("r", "remove", "Remove source images after a succesful conversion", false);
        TCLAP::SwitchArg switchSkipBG("b", "ingnore-bg", "Skip all \"background2-*.gif\" sprites", false);
        TCLAP::SwitchArg switchDigRecursive("d", "dig-recursive", "Look for images in subdirectories", false);
        TCLAP::SwitchArg switchDigRecursiveDEP("w", "dig-recursive-old", "Look for images in subdirectories [deprecated]", false);

        TCLAP::ValueArg<std::string> outputDirectory("O", "output",
                "path to a directory where the PNG images will be saved",
                false, "", "/path/to/output/directory/");
        TCLAP::ValueArg<std::string> configDirectory("C", "config",
                "Allow usage of default masks from specific PGE config pack "
                "(Useful for cases where the GFX designer didn't make a mask image)",
                false, "", "/path/to/config/pack");
        TCLAP::UnlabeledMultiArg<std::string> inputFileNames("filePath(s)",
                "Input GIF file(s)",
                true,
                "Input file path(s)");

        cmd.add(&switchRemove);
        cmd.add(&switchSkipBG);
        cmd.add(&switchDigRecursive);
        cmd.add(&switchDigRecursiveDEP);
        cmd.add(&outputDirectory);
        cmd.add(&configDirectory);
        cmd.add(&inputFileNames);

        cmd.parse(argc, argv);

        setup.removeSource      = switchRemove.getValue();
        setup.skipBackground2 = switchSkipBG.getValue();
        setup.walkSubDirs     = switchDigRecursive.getValue() | switchDigRecursiveDEP.getValue();
        //nopause         = switchNoPause.getValue();

        setup.pathOut     = outputDirectory.getValue();
        setup.configPath  = configDirectory.getValue();

        for(const std::string &fpath : inputFileNames.getValue())
        {
            if(Files::hasSuffix(fpath, "m.gif"))
                continue;
            else if(DirMan::exists(fpath))
                setup.pathIn = fpath;
            else
            {
                fileList.push_back(fpath);
                setup.listOfFiles = true;
            }
        }

        if((argc <= 1) || (setup.pathIn.empty() && !setup.listOfFiles))
        {
            fprintf(stderr, "\n"
                    "ERROR: Missing input files!\n"
                    "Type \"%s --help\" to display usage.\n\n", argv[0]);
            return 2;
        }
    }
    catch(TCLAP::ArgException &e)   // catch any exceptions
    {
        std::cerr << "Error: " << e.error() << " for arg " << e.argId() << std::endl;
        return 2;
    }

    fprintf(stderr, "============================================================================\n"
            "Pair of GIFs to PNG converter tool by Wohlstand. Version " V_FILE_VERSION V_FILE_RELEASE "\n"
            "============================================================================\n"
            "This program is distributed under the GNU GPLv3 license \n"
            "============================================================================\n");
    fflush(stderr);

    if(!setup.listOfFiles)
    {
        if(setup.pathIn.empty())
            goto WrongInputPath;
        if(!DirMan::exists(setup.pathIn))
            goto WrongInputPath;

        imagesDir.setPath(setup.pathIn);
        setup.pathIn = imagesDir.absolutePath();
    }

    if(!setup.pathOut.empty())
    {
        if(!DirMan::exists(setup.pathOut) && !DirMan::mkAbsPath(setup.pathOut))
            goto WrongOutputPath;

        setup.pathOut = DirMan(setup.pathOut).absolutePath();
        setup.pathOutSame   = false;
    }
    else
    {
        setup.pathOut       = setup.pathIn;
        setup.pathOutSame   = true;
    }

    delEndSlash(setup.pathIn);
    delEndSlash(setup.pathOut);

    printf("============================================================================\n"
           "Converting images...\n"
           "============================================================================\n");
    fflush(stdout);

    if(!setup.listOfFiles)
        std::cout << ("Input path:  " + setup.pathIn + "\n");

    std::cout << ("Output path: " + setup.pathOut + "\n");

    std::cout << "============================================================================\n";
    std::cout.flush();

    config.setConfigDir(setup.configPath);

    if(config.isUsing())
    {
        std::cout << "============================================================================\n";
        std::cout << ("Used config pack: " + setup.configPath + "\n");
        if(!setup.listOfFiles)
        {
            config.appendDir(setup.pathIn);
            std::cout << ("With episode directory: " + setup.pathIn + "\n");
        }
        std::cout << "============================================================================\n";
        std::cout.flush();
    }

    if(setup.listOfFiles)// Process a list of flies
    {
        for(std::string &file : fileList)
        {
            std::string fname   = Files::basename(file);
            setup.pathIn = DirMan(Files::dirname(file)).absolutePath();
            if(setup.pathOutSame)
                setup.pathOut = DirMan(Files::dirname(file)).absolutePath();
            doGifs2PNG(setup.pathIn, fname , setup.pathOut, setup, config);
        }
    }
    else // Process directories with a source files
    {
        imagesDir.getListOfFiles(fileList, {".gif"});
        if(!setup.walkSubDirs) //By directories
        {
            for(std::string &fname : fileList)
                doGifs2PNG(setup.pathIn, fname, setup.pathOut, setup, config);
        }
        else
        {
            imagesDir.beginWalking({".gif"});
            std::string curPath;
            while(imagesDir.fetchListFromWalker(curPath, fileList))
            {
                if(Files::hasSuffix(curPath, "/_backup"))
                    continue; //Skip LazyFix's backup directories
                for(std::string &file : fileList)
                {
                    if(setup.pathOutSame)
                        setup.pathOut = curPath;
                    doGifs2PNG(curPath, file, setup.pathOut, setup, config);
                }
            }
        }
    }

    if(!setup.deleteLater.empty())
    {
        printf("======================Deleting old files...=================================\n");
        fflush(stdout);
        for(const std::string &s : setup.deleteLater)
        {
            std::cout << s << "...";
            std::cout.flush();
            if(Files::deleteFile(s))
                std::cout << ".DEL.";
            std::cout << "\n";
            std::cout.flush();
        }
    }

    printf("============================================================================\n"
           "                      Conversion has been completed!\n"
           "============================================================================\n"
           "Successfully merged:        %d\n"
           "Conversion failed:          %d\n"
           "Skipped files (bg2-*):      %d\n"
           "\n",
           setup.count_success,
           setup.count_failed,
           setup.count_skipped);
    fflush(stdout);
    return (setup.count_failed == 0) ? 0 : 1;

WrongInputPath:
    std::cout.flush();
    std::cerr.flush();
    printf("============================================================================\n"
           "                           Wrong input path!\n"
           "============================================================================\n");
    fflush(stdout);
    return 2;

WrongOutputPath:
    std::cout.flush();
    std::cerr.flush();
    printf("============================================================================\n"
           "                          Wrong output path!\n"
           "============================================================================\n");
    fflush(stdout);
    return 2;
}


================================================
FILE: utils/convertkit/GIFs2PNG/version.cmake
================================================
# Major
set(GIFS2PNG_VERSION_1 3)
# Minor
set(GIFS2PNG_VERSION_2 1)
# Revision
set(GIFS2PNG_VERSION_3 0)
# Patch
set(GIFS2PNG_VERSION_4 0)
# Type of version: "-alpha","-beta","-dev", or "" aka "release"
set(GIFS2PNG_VERSION_REL "")

add_definitions(-DGIFS2PNG_VERSION_1=${GIFS2PNG_VERSION_1})
add_definitions(-DGIFS2PNG_VERSION_2=${GIFS2PNG_VERSION_2})
add_definitions(-DGIFS2PNG_VERSION_3=${GIFS2PNG_VERSION_3})
add_definitions(-DGIFS2PNG_VERSION_4=${GIFS2PNG_VERSION_4})
add_definitions(-DGIFS2PNG_VERSION_REL=${GIFS2PNG_VERSION_REL})

set(GIFS2PNG_VERSION_STRING "${GIFS2PNG_VERSION_1}.${GIFS2PNG_VERSION_2}")

if(NOT ${GIFS2PNG_VERSION_3} EQUAL 0 OR NOT ${GIFS2PNG_VERSION_4} EQUAL 0)
    string(CONCAT GIFS2PNG_VERSION_STRING "${GIFS2PNG_VERSION_STRING}" ".${GIFS2PNG_VERSION_3}")
endif()

if(NOT ${GIFS2PNG_VERSION_4} EQUAL 0)
    string(CONCAT GIFS2PNG_VERSION_STRING "${GIFS2PNG_VERSION_STRING}" ".${GIFS2PNG_VERSION_4}")
endif()

if(NOT "${GIFS2PNG_VERSION_REL}" STREQUAL "")
    string(CONCAT GIFS2PNG_VERSION_STRING "${GIFS2PNG_VERSION_STRING}" "${GIFS2PNG_VERSION_REL}")
endif()

message("== GIFs2PNG version ${GIFS2PNG_VERSION_STRING} ==")



================================================
FILE: utils/convertkit/GIFs2PNG/version.h
================================================
/*
 * GIFs2PNG, a free tool for merge GIF images with his masks and save into PNG
 * This is a part of the Platformer Game Engine by Wohlstand, a free platform for game making
 * Copyright (c) 2017-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "../pge_version.h" //Global Project version file

#pragma once
#ifndef GIFS2PNG_VERSION_H
#define GIFS2PNG_VERSION_H

//Version of this program

#ifdef GIFS2PNG_VERSION_1
#   define V_VF1 GIFS2PNG_VERSION_1
#else
#   define V_VF1 0
#endif

#ifdef GIFS2PNG_VERSION_2
#   define V_VF2 GIFS2PNG_VERSION_2
#else
#   define V_VF2 0
#endif

#ifdef GIFS2PNG_VERSION_3
#   define V_VF3 GIFS2PNG_VERSION_3
#else
#   define V_VF3 0
#endif

#ifdef GIFS2PNG_VERSION_4
#   define V_VF4 GIFS2PNG_VERSION_4
#else
#   define V_VF4 0
#endif

#ifdef GIFS2PNG_VERSION_REL
#   define V_FILE_RELEASE STR_VALUE(GIFS2PNG_VERSION_REL)
#else
#   define V_FILE_RELEASE "-unk" //"-alpha","-beta","-dev", or "" aka "release"
#endif


#define V_VF1_s STR_VALUE(V_VF1)
#define V_VF2_s STR_VALUE(V_VF2)
#define V_VF3_s STR_VALUE(V_VF3)
#define V_VF4_s STR_VALUE(V_VF4)
#if V_VF4 == 0
    #if V_VF3 == 0
        #define V_FILE_VERSION_NUM GEN_VERSION_NUMBER_2(V_VF1_s, V_VF2_s)
    #else
        #define V_FILE_VERSION_NUM GEN_VERSION_NUMBER_3(V_VF1_s, V_VF2_s, V_VF3_s)
    #endif
#else
    #define V_FILE_VERSION_NUM GEN_VERSION_NUMBER_4(V_VF1_s, V_VF2_s, V_VF3_s, V_VF4_s)
#endif

//Version of this program
#define V_FILE_VERSION V_FILE_VERSION_NUM

#define V_FILE_DESC "Bit-Mask GIFs pair to PNG with transparency converter by Wohlstand"

#define V_INTERNAL_NAME "GIFs2PNG"

#ifdef _WIN32
	#define V_ORIGINAL_NAME "GIFs2PNG.exe" // for Windows platforms
#else
	#define V_ORIGINAL_NAME "GIFs2PNG" // for any other platforms
#endif

//Uncomment this for enable detal logging
//#define DEBUG

#endif


================================================
FILE: utils/convertkit/assets-convert-homebrew.py
================================================
#!/usr/bin/python3

# this should be fixed later but currently delegates to the other two scripts in the directory

import os
import sys
import subprocess
import argparse

parser = argparse.ArgumentParser(
    description='Converts TheXTech assets for use on Nintendo homebrew devices')

parser.add_argument('input')
parser.add_argument('output')
parser.add_argument('-t', '--target', choices=['3ds', 'wii'], required=True)

args = parser.parse_args()

script_directory = os.path.dirname(os.path.abspath(sys.argv[0]))

if args.target == '3ds':
    subprocess.run(['python3', os.path.join(script_directory, 'gfx-convert-3ds.py'), args.input, args.output])
elif args.target == 'wii':
    subprocess.run(['python3', os.path.join(script_directory, 'gfx-convert-wii.py'), args.input, args.output])


================================================
FILE: utils/convertkit/audio_convert_16m.py
================================================
#!/usr/bin/python3

import os
import sys
import shutil
import configparser

def convert_audio(datadir, outdir):
    music_filenames = {}
    sound_filenames = {}

    os.makedirs(os.path.join(outdir, 'temp', 'music'), exist_ok=True)
    os.makedirs(os.path.join(outdir, 'temp', 'sound'), exist_ok=True)

    # load the INI files
    for filenames_dict, ini_filename in [(music_filenames, 'music.ini'), (sound_filenames, 'sounds.ini')]:
        ini = configparser.ConfigParser(inline_comment_prefixes=';')
        ini.read(os.path.join(datadir, ini_filename))

        for name in ini.sections():
            try:
                file = ini[name]['file']
            except KeyError:
                continue

            if len(file) < 3 or file[0] != '"' or file[-1] != '"':
                continue

            file = file[1:-1]

            if ini_filename == "music.ini" and '|' in file:
                file = '|'.join(file.split('|')[:-1])

            filenames_dict[name] = file

    # temporary transformations (spc2it, ogg2wav)
    for key in list(music_filenames.keys()):
        filename = music_filenames[key]
        use_fn = os.path.join(datadir, 'music', filename)

        if os.path.exists(use_fn + '.spc'):
            filename += '.spc'
            use_fn += '.spc'

        if os.path.exists(use_fn + '.it'):
            filename += '.it'
            use_fn += '.it'

        temp_fn = os.path.join(outdir, 'temp', 'music', filename)

        if filename.endswith('.spc'):
            shutil.copy(use_fn, temp_fn)
            os.system(f'spc2it "{temp_fn}"')
            use_fn = temp_fn[:-4] + '.it'

        music_filenames[key] = use_fn

        okay = (music_filenames[key].endswith('.it')
            or music_filenames[key].endswith('.mod')
            or music_filenames[key].endswith('.s3m')
            or music_filenames[key].endswith('.xm'))

        if not okay:
            del music_filenames[key]

    for key in list(sound_filenames.keys()):
        filename = sound_filenames[key]
        use_fn = os.path.join(datadir, 'sound', filename)
        temp_fn = os.path.join(outdir, 'temp', 'sound', filename)

        if filename.endswith('.ogg'):
            os.system(f'ffmpeg -i "{use_fn}" -ac 1 -ar 24000 -c:a pcm_u8 -y "{temp_fn}.wav"')
            use_fn = temp_fn + '.wav'

        sound_filenames[key] = use_fn

        okay = (sound_filenames[key].endswith('.wav'))

        if not okay:
            del sound_filenames[key]

    # make the mmutil invocation
    mmutil_invoke = f'mmutil -d "-o{outdir}soundbank.bin" "-c{outdir}soundbank.ini"'
    for filename in set(music_filenames.values()):
        mmutil_invoke += f' "{filename}"'

    for filename in set(sound_filenames.values()):
        mmutil_invoke += f' "{filename}"'

    os.system(mmutil_invoke)

    # update the INI files
    mmutil_out = configparser.ConfigParser(inline_comment_prefixes=';')
    mmutil_out.read(os.path.join(outdir, 'soundbank.ini'))

    for filenames_dict, ini_filename, group_name, resolved_name in [(music_filenames, 'music.ini', 'modules', 'resolved-mod'), (sound_filenames, 'sounds.ini', 'samples', 'resolved-sfx')]:
        ini = configparser.ConfigParser(inline_comment_prefixes=';')
        ini.read(os.path.join(datadir, ini_filename))

        for key in filenames_dict.keys():
            ini[key][resolved_name] = mmutil_out[group_name][filenames_dict[key]]

        ini.write(open(os.path.join(outdir, ini_filename), 'w'))

    # delete temp files
    os.remove(os.path.join(outdir, 'soundbank.ini'))
    shutil.rmtree(os.path.join(outdir, 'temp'))


================================================
FILE: utils/convertkit/convert_plr.py
================================================
import os, sys

def blit(fn, sx, sy, dx, dy, w, h, flip):
    flip = '-flop ' if flip else ''
    return f'\\( "{fn}" -crop {w}x{h}+{sx}+{sy} +repage {flip}\\) -geometry +{dx}+{dy} -composite '

def check_trim(fn, sx, sy, w, h):
    return w - int(os.popen(f'convert "{fn}" -crop {w}x{h}+{sx}+{sy} +repage -define trim:edges=east -trim -format \"%w\" info:').read())


def do_sheet(fn, frames, out, w, h, cols, rows, make_flippable=False):
    ow = 100
    oh = 100
    ocols = 10
    orows = 10

    cmd = f'convert -size {w*cols}x{h*rows*2} xc:none -compose Replace -gravity NorthWest -define trim:edges=east '

    for df, sf in enumerate(frames):
        for dir in [-1, 1]:
            o_coord = dir * sf + 49
            sx = ow * (o_coord // orows)
            sy = oh * (o_coord % orows)

            dx = w * (df // rows)
            dy = h * (df % rows)

            flip = False

            dw = w

            if dir == -1:
                dx = (cols - 1) * w - dx
                dy += rows * h

                if make_flippable:
                    flip = (sf == 0)

                    if not flip:
                        trim = check_trim(fn, sx, sy, w, h)
                        print(f'lo-{sf} = {trim}')
                        dx += trim
                        dw -= trim

                    if sf == 25 or sf == 26:
                        flip = True
                elif sf == 0:
                    continue

            cmd += blit(fn, sx, sy, dx, dy, dw, h, flip)

    cmd += '"' + out + '"'

    cmd.replace('\'', '\\\'')

    print(cmd)

    return cmd

def do_sheet_nonlink(fn, outfn):
    return do_sheet(fn, list(range(0,33))+list(range(40,45)), outfn, 48, 64, 10, 4)

def do_sheet_link(fn, outfn):
    return do_sheet(fn, range(1,17), outfn, 64, 64, 4, 4)

if __name__ == '__main__':
    if len(sys.argv) > 1:
        fns = sys.argv[1:]
    else:
        fns = os.listdir()

    for fn in fns:
        if 'link' in fn:
            os.system(do_sheet_link(fn, fn[:-4]+'.out.png'))
        else:
            os.system(do_sheet_nonlink(fn, fn[:-4]+'.out.png'))


================================================
FILE: utils/convertkit/dist/gameinfo.ini
================================================
[game]
title="Super Mario Bros. X"

[characters]
name1="Mario"
name2="Luigi"
name3="Peach"
name4="Toad"
name5="Link"


================================================
FILE: utils/convertkit/dist/gfx-convert-lin.sh
================================================
#!/bin/bash

echo "------------------------------------------------------------------------"
echo "   All default masked GIF stuff will be converted into PNG"
echo "------------------------------------------------------------------------"
echo " Do you want to remove all old GIFs [Y]? or keep both GIFs and PNG [N]?"
echo "------------------------------------------------------------------------"
echo "Answer Y/N ?"
read -n 1 REMOVE

echo -e "\n\n"

if [[ "$REMOVE" == "y" ]]; then
    REMOVE=-r
else
    REMOVE=
fi

smbxexe="smbx.exe"
if [[ -f "asmbxt.exe" ]]; then
    smbxexe="asmbxt.exe"
elif [[ -f "a2mbxt.exe" ]]; then
    smbxexe="a2mbxt.exe"
fi

chmod +x exe2ui-linux-x86_64
echo "Executing exe2ui ${smbxexe}..."
./exe2ui-linux-x86_64 "${smbxexe}"

chmod +x GIFs2PNG-linux-x86_64
echo "Executing ./GIFs2PNG-linux-x86_64 -d $REMOVE graphics ..."
./GIFs2PNG-linux-x86_64 -d $REMOVE graphics

echo "Cleaning up from garbage..."
find graphics -name "npc*.txt" -delete
find graphics -name "Thumbds.db" -delete

echo -e "\n\n"
echo "---------------------------------------------------------------"
echo "  Press any key to quit..."
echo "---------------------------------------------------------------"
read -n 1


================================================
FILE: utils/convertkit/dist/gfx-convert-win.cmd
================================================
@echo off

echo ------------------------------------------------------------------------
echo    All default masked GIF stuff will be converted into PNG
echo ------------------------------------------------------------------------
echo  Do you want to remove all old GIFs [Y]? or keep both GIFs and PNG [N]?
echo ------------------------------------------------------------------------
choice
if errorlevel 2 set REMOVE=
if errorlevel 1 set REMOVE=-r

set smbxexe=smbx.exe
if exist asmbxt.exe set smbxexe=asmbxt.exe
if exist a2mbxt.exe set smbxexe=a2mbxt.exe

echo Executing exe2ui %smbxexe% ...
exe2ui.exe %smbxexe%

echo Executing GIFs2PNG.exe -d %REMOVE% graphics ...
GIFs2PNG.exe -d %REMOVE% graphics

echo Cleaning up from garbage...
del /s graphics\block\*block-*.txt > NUL
del /s graphics\background\*background-*.txt > NUL
del /s graphics\npc\*npc-*.txt > NUL

echo .
echo .
echo ---------------------------------------------------------------
echo   Press any key to quit...
echo ---------------------------------------------------------------
pause > NUL


================================================
FILE: utils/convertkit/dist/music.ini
================================================
[music-main]
total-world=17
total-level=56
total-special=3
level-custom-music-id=24
world-custom-music-id=17

[world-music-1]
name="SMB3 World 1 (Grass land)"
file="smb3-world1.mp3"


[world-music-2]
name="SMB3 World 4 (Giant land)"
file="smb3-world4.mp3"


[world-music-3]
name="SMB3 World 7 (Pipe land)"
file="smb3-world7.mp3"


[world-music-4]
name="SMW: Wandering the Plains"
file="smw-worldmap.mp3"


[world-music-5]
name="SSBB SMB3-Remix fragment"
file="nsmb-world.mp3"


[world-music-6]
name="SMB3 World 2 (Desert land)"
file="smb3-world2.mp3"


[world-music-7]
name="SMW Forest"
file="smw-forestofillusion.mp3"


[world-music-8]
name="SMB3 World 3 (Ocean land)"
file="smb3-world3.mp3"


[world-music-9]
name="SMB3 World 8 (Dark land)"
file="smb3-world8.mp3"


[world-music-10]
name="SMB3 World 6 (Ice land)"
file="smb3-world6.mp3"


[world-music-11]
name="SMB3 World 5 (Sky land (Ground))"
file="smb3-world5.mp3"


[world-music-12]
name="SMW Special"
file="smw-special.mp3"


[world-music-13]
name="SMW Bowser"
file="smw-bowserscastle.mp3"


[world-music-14]
name="SMW Star Road"
file="smw-starroad.mp3"


[world-music-15]
name="SMW Island"
file="smw-yoshisisland.mp3"


[world-music-16]
name="SMW Cave"
file="smw-vanilladome.mp3"

[world-music-17]
name="[custom]"
file="dummy"

[special-music-1]
name="SMW P-Switch"
file="smw-switch.mp3"


[special-music-2]
name="SMB3 P-Switch"
file="smb3-switch.mp3"


[special-music-3]
name="Credits (SMG Title)"
file="smg-title.mp3"


[level-music-1]
name="SMB3 Overworld"
file="smb3-overworld.mp3"


[level-music-2]
name="SMB3 Sky"
file="smb3-sky.mp3"


[level-music-3]
name="SMB3 Castle"
file="smb3-castle.mp3"


[level-music-4]
name="SMB3 Underground"
file="smb3-underground.mp3"


[level-music-5]
name="SMB2 Overworld"
file="smb2-overworld.mp3"


[level-music-6]
name="SMB3 Battle"
file="smb3-boss.mp3"


[level-music-7]
name="SMB Underground"
file="smb-underground.mp3"


[level-music-8]
name="Corneria"
file="sf-corneria.mp3"


[level-music-9]
name="SMB Overworld"
file="smb-overworld.mp3"


[level-music-10]
name="SMW Overworld"
file="smw-overworld.mp3"


[level-music-11]
name="Brinstar"
file="sm-brinstar.mp3"


[level-music-12]
name="Crateria"
file="sm-crateria.mp3"


[level-music-13]
name="New SMB"
file="nsmb-overworld.mp3"


[level-music-14]
name="SM64 Desert"
file="sm64-desert.mp3"


[level-music-15]
name="SMB2 Boss"
file="smb2-boss.mp3"


[level-music-16]
name="SMRPG Forest Maze"
file="mariorpg-forestmaze.mp3"


[level-music-17]
name="SMW Ghost House"
file="smw-ghosthouse.mp3"


[level-music-18]
name="Beach Bowl"
file="smg-beach-bowl-galaxy.mp3"


[level-music-19]
name="Airship Theme"
file="ssbb-airship.mp3"


[level-music-20]
name="SMG Star Reactor"
file="smg-star-reactor.mp3"


[level-music-21]
name="SMRPG Bowser Battle"
file="mariorpg-bowser.mp3"


[level-music-22]
name="Metroid Charge"
file="tds-metroid-charge.mp3"


[level-music-23]
name="Lost Woods"
file="z3-lost-woods.mp3"


[level-music-24]
name="Custom"
file=""


[level-music-25]
name="SMB2 Underground"
file="smb2-underground.mp3"


[level-music-26]
name="SM64 Castle"
file="mario64-castle.mp3"


[level-music-27]
name="SM64 Main Theme"
file="mario64-maintheme.mp3"


[level-music-28]
name="SMW Athletic"
file="smw-sky.mp3"


[level-music-29]
name="SMW Cave"
file="smw-cave.mp3"


[level-music-30]
name="SMRPG Mario's Pad"
file="mariorpg-mariospad.mp3"


[level-music-31]
name="SMRPG Seaside Town"
file="mariorpg-seasidetown.mp3"


[level-music-32]
name="SMRPG Tadpole Pond"
file="mariorpg-tadpolepond.mp3"


[level-music-33]
name="SMRPG Nimbus Land"
file="mariorpg-nimbusland.mp3"


[level-music-34]
name="SMRPG Rose Town"
file="mariorpg-rosetown.mp3"


[level-music-35]
name="SM64 Snow"
file="mario64-snowmountain.mp3"


[level-music-36]
name="SM64 Boss"
file="mario64-boss.mp3"


[level-music-37]
name="Shiver Mnt"
file="pm-shiver-mountain.mp3"


[level-music-38]
name="Yoshi's Village"
file="pm-yoshis-village.mp3"


[level-music-39]
name="Hyrule Temple"
file="ssbb-zelda2.mp3"


[level-music-40]
name="Meta Knight"
file="ssbb-meta.mp3"


[level-music-41]
name="SMW Castle"
file="smw-castle.mp3"


[level-music-42]
name="SMB Castle"
file="smb-castle.mp3"


[level-music-43]
name="SMB2 Wart"
file="smb2-wart.mp3"


[level-music-44]
name="Item Room"
file="sm-itemroom.mp3"


[level-music-45]
name="Mother Brain"
file="sm-brain.mp3"


[level-music-46]
name="SMB Water"
file="smb-water.mp3"


[level-music-47]
name="SMB3 Water"
file="smb3-water.mp3"


[level-music-48]
name="SMW Water"
file="smw-water.mp3"


[level-music-49]
name="SM64 Water"
file="mario64-water.mp3"


[level-music-50]
name="SM64 Cave"
file="mario64-cave.mp3"


[level-music-51]
name="SMW Boss"
file="smw-boss.mp3"


[level-music-52]
name="Underground"
file="ssbb-underground.mp3"


[level-music-53]
name="Waluigi"
file="ssbb-waluigi.mp3"


[level-music-54]
name="SMB3 Hammer Bros"
file="smb3-hammer.mp3"


[level-music-55]
name="Fleet Glide"
file="smg2-fg.mp3"


[level-music-56]
name="M. Gorge"
file="mkwii-mushroom-gorge.mp3"


================================================
FILE: utils/convertkit/dist/sounds.ini
================================================
[sound-main]
total=91

[sound-1]
name="Jump"
file="player-jump.mp3"
single-channel=1 ;don't dupe sound in another channel
hidden=0

[sound-2]
name="Stomp"
file="stomped.mp3"
hidden=0

[sound-3]
name="Block Hit"
file="block-hit.mp3"
hidden=0

[sound-4]
name="Block Smashed"
file="block-smash.mp3"
hidden=0

[sound-5]
name="Shrink"
file="player-shrink.mp3"
hidden=0

[sound-6]
name="Grow"
file="player-grow.mp3"
hidden=0

[sound-7]
name="Mushroom"
file="mushroom.mp3"
hidden=0

[sound-8]
name="Player Died"
file="player-died.mp3"
hidden=0

[sound-9]
name="Shell Kick"
file="shell-hit.mp3"
single-channel=1
hidden=0

[sound-10]
name="Skid"
file="player-slide.mp3"
single-channel=1
hidden=0

[sound-11]
name="Drop Item"
file="item-dropped.mp3"
hidden=0

[sound-12]
name="Got Item"
file="has-item.mp3"
hidden=0

[sound-13]
name="Camera"
file="camera-change.mp3"
hidden=0

[sound-14]
name="Coin"
file="coin.mp3"
hidden=0

[sound-15]
name="1up"
file="1up.mp3"
hidden=0

[sound-16]
name="Lava"
file="lava.mp3"
hidden=0

[sound-17]
name="Warp"
file="warp.mp3"
hidden=0

[sound-18]
name="Fireball"
file="fireball.mp3"
hidden=0

[sound-19]
name="SMB3 Exit"
file="level-win.mp3"
hidden=0

[sound-20]
name="Defeat Boss"
file="boss-beat.mp3"
hidden=0

[sound-21]
name="Dungeon Clear "
file="dungeon-win.mp3"
hidden=0

[sound-22]
name="Bullet Bill"
file="bullet-bill.mp3"
hidden=0

[sound-23]
name="Grab"
file="grab.mp3"
hidden=0

[sound-24]
name="Spring"
file="spring.mp3"
hidden=0

[sound-25]
name="Hammer Toss"
file="hammer.mp3"
hidden=0

[sound-26]
name="Slide"
file="slide.mp3"
hidden=0

[sound-27]
name="New Path"
file="newpath.mp3"
single-channel=1
hidden=0

[sound-28]
name="Level Select"
file="level-select.mp3"
hidden=0

[sound-29]
name="Do"
file="do.mp3"
hidden=0

[sound-30]
name="Pause"
file="pause.mp3"
hidden=0

[sound-31]
name="Key"
file="key.mp3"
hidden=0

[sound-32]
name="Switch"
file="pswitch.mp3"
hidden=0

[sound-33]
name="Tail"
file="tail.mp3"
single-channel=1
hidden=0

[sound-34]
name="Racoon"
file="racoon.mp3"
hidden=0

[sound-35]
name="Boot"
file="boot.mp3"
hidden=0

[sound-36]
name="Smash"
file="smash.mp3"
single-channel=1
hidden=0

[sound-37]
name="Thwomp"
file="thwomp.mp3"
hidden=0

[sound-38]
name="Birdo Spit"
file="birdo-spit.mp3"
hidden=0

[sound-39]
name="Birdo Hit"
file="birdo-hit.mp3"
hidden=0

[sound-40]
name="SMB2 Exit"
file="smb2-exit.mp3"
hidden=0

[sound-41]
name="Birdo Beat"
file="birdo-beat.mp3"
hidden=0

[sound-42]
name="Big Fireball"
file="npc-fireball.mp3"
hidden=0

[sound-43]
name="Fireworks"
file="fireworks.mp3"
hidden=0

[sound-44]
name="Bowser Killed"
file="bowser-killed.mp3"
hidden=0

[sound-45]
name="SMB3 Game Beat"
file="game-beat.mp3"
hidden=0

[sound-46]
name="Door"
file="door.mp3"
hidden=0

[sound-47]
name="Message"
file="message.mp3"
hidden=0

[sound-48]
name="Yoshi"
file="yoshi.mp3"
hidden=0

[sound-49]
name="Yoshi Hurt"
file="yoshi-hurt.mp3"
hidden=0

[sound-50]
name="Yoshi Tongue"
file="yoshi-tongue.mp3"
single-channel=1
hidden=0

[sound-51]
name="Yoshi Egg"
file="yoshi-egg.mp3"
hidden=0

[sound-52]
name="Got Star Exit"
file="got-star.mp3"
hidden=0

[sound-53]
name="Zelda Kill"
file="zelda-kill.mp3"
hidden=0

[sound-54]
name="Player Died 2"
file="player-died2.mp3"
hidden=0

[sound-55]
name="Yoshi Swallow"
file="yoshi-swallow.mp3"
hidden=0

[sound-56]
name="Sonic Ring"
file="ring.mp3"
hidden=0

[sound-57]
name="Dry Bones"
file="dry-bones.mp3"
hidden=0

[sound-58]
name="SMW Checkpoint"
file="smw-checkpoint.mp3"
hidden=0

[sound-59]
name="Dragon Coin"
file="dragon-coin.mp3"
hidden=0

[sound-60]
name="SMW Exit"
file="smw-exit.mp3"
hidden=0

[sound-61]
name="Blaarg"
file="smw-blaarg.mp3"
hidden=0

[sound-62]
name="Wart Bubbles"
file="wart-bubble.mp3"
hidden=0

[sound-63]
name="Wart Killed"
file="wart-die.mp3"
hidden=0

[sound-64]
name="SM Block Hit"
file="sm-block-hit.mp3"
hidden=0

[sound-65]
name="SM Killed"
file="sm-killed.mp3"
hidden=0

[sound-66]
name="SM Hurt"
file="sm-hurt.mp3"
hidden=0

[sound-67]
name="SM Glass"
file="sm-glass.mp3"
hidden=0

[sound-68]
name="SM Boss Hit"
file="sm-boss-hit.mp3"
hidden=0

[sound-69]
name="SM Cry"
file="sm-cry.mp3"
hidden=0

[sound-70]
name="SM Explosion"
file="sm-explosion.mp3"
hidden=0

[sound-71]
name="Climbing"
file="climbing.mp3"
single-channel=1
hidden=0

[sound-72]
name="Swim"
file="swim.mp3"
single-channel=1
hidden=0

[sound-73]
name="Light Grab"
file="grab2.mp3"
hidden=0

[sound-74]
name="Saw"
file="smw-saw.mp3"
hidden=0

[sound-75]
name="SMB2 Throw"
file="smb2-throw.mp3"
hidden=0

[sound-76]
name="SMB2 Hit"
file="smb2-hit.mp3"
hidden=0

[sound-77]
name="Zelda Stab"
file="zelda-stab.mp3"
hidden=0

[sound-78]
name="Zelda Hurt"
file="zelda-hurt.mp3"
hidden=0

[sound-79]
name="Zelda Heart"
file="zelda-heart.mp3"
hidden=0

[sound-80]
name="Zelda Died"
file="zelda-died.mp3"
hidden=0

[sound-81]
name="Zelda Rupee"
file="zelda-rupee.mp3"
hidden=0

[sound-82]
name="Zelda Fire"
file="zelda-fire.mp3"
hidden=0

[sound-83]
name="Zelda Item"
file="zelda-item.mp3"
hidden=0

[sound-84]
name="Zelda Key"
file="zelda-key.mp3"
hidden=0

[sound-85]
name="Zelda Shield"
file="zelda-shield.mp3"
hidden=0

[sound-86]
name="Zelda Dash"
file="zelda-dash.mp3"
hidden=0

[sound-87]
name="Zelda Fairy"
file="zelda-fairy.mp3"
hidden=0

[sound-88]
name="Zelda Grass"
file="zelda-grass.mp3"
hidden=0

[sound-89]
name="Zelda Hit"
file="zelda-hit.mp3"
hidden=1

[sound-90]
name="Zelda Sword Beam"
file="zelda-sword-beam.mp3"
hidden=1

[sound-91]
name="Bubble"
file="bubble.mp3"
hidden=1


================================================
FILE: utils/convertkit/dist/thextech.ini
================================================
[Main]
force-portable = true



================================================
FILE: utils/convertkit/exe2ui/exe2ui.c
================================================
#include <stdint.h>
#include <stdio.h>
#include <string.h>


static unsigned char g_Font2_1_gif[] =
{
    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0xdf, 0x03, 0x11, 0x00, 0x80, 0x01,
    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x21, 0xfe, 0x11, 0x43, 0x72,
    0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x47,
    0x49, 0x4d, 0x50, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0xdf, 0x03, 0x11,
    0x00, 0x00, 0x02, 0x9e, 0x84, 0x8f, 0xa9, 0xcb, 0xed, 0x0f, 0xa3, 0x9c,
    0xb4, 0xda, 0x8b, 0xb3, 0xde, 0xbc, 0xfb, 0x0f, 0x86, 0xe2, 0x48, 0x96,
    0xe6, 0x89, 0xa6, 0xea, 0xca, 0xb6, 0xee, 0x0b, 0xc7, 0xf2, 0x4c, 0xd7,
    0xf6, 0x8d, 0xe7, 0xfa, 0xce, 0xf7, 0xfe, 0x0f, 0x0c, 0x0a, 0x87, 0xc4,
    0xa2, 0xf1, 0x88, 0x4c, 0x2a, 0x97, 0xcc, 0xa6, 0xf3, 0x09, 0x8d, 0x4a,
    0xa7, 0xd4, 0xaa, 0xf5, 0x8a, 0xcd, 0x6a, 0xb7, 0xdc, 0xae, 0xf7, 0x0b,
    0x0e, 0x8b, 0xc7, 0xe4, 0xb2, 0xf9, 0x8c, 0x4e, 0xab, 0xd7, 0xec, 0xb6,
    0xfb, 0x0d, 0x8f, 0xcb, 0xe7, 0xf4, 0xba, 0xfd, 0x8e, 0xcf, 0xeb, 0xf7,
    0xfc, 0xbe, 0xff, 0x0f, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, 0x88,
    0x98, 0xa8, 0xb8, 0xc8, 0xd8, 0xe8, 0xf8, 0x08, 0x19, 0x29, 0x39, 0x49,
    0x59, 0x69, 0x79, 0x89, 0x99, 0xa9, 0xb9, 0xc9, 0xd9, 0xe9, 0xf9, 0x09,
    0x1a, 0x2a, 0x3a, 0x4a, 0x5a, 0x6a, 0x7a, 0x8a, 0x9a, 0xaa, 0xba, 0xca,
    0xda, 0xea, 0xfa, 0x0a, 0x1b, 0x2b, 0x3b, 0x4b, 0x5b, 0x6b, 0x7b, 0x8b,
    0x9b, 0xab, 0xbb, 0xfb, 0x50, 0x00, 0x00, 0x3b,
    0x00
};

static unsigned char g_Font2_3m_gif[] =
{
    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x11, 0x00, 0xe3, 0x05, 0xa1, 0x02,
    0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0x21, 0xfe, 0x11, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20,
    0x77, 0x69, 0x74, 0x68, 0x20, 0x47, 0x49, 0x4d, 0x50, 0x00, 0x2c, 0x00,
    0x00, 0x00, 0x00, 0x11, 0x00, 0xe3, 0x05, 0x00, 0x02, 0xfe, 0x94, 0x8f,
    0xa9, 0xcb, 0x08, 0xff, 0xda, 0x81, 0x51, 0x0a, 0x0a, 0xec, 0xa5, 0x1a,
    0x77, 0x6e, 0x79, 0x21, 0xa8, 0x95, 0x66, 0x22, 0x4a, 0xe9, 0xc9, 0xb6,
    0x6e, 0x03, 0x4d, 0x95, 0x12, 0x1b, 0x35, 0x3d, 0xdf, 0x68, 0x3e, 0xef,
    0x99, 0xdd, 0x73, 0xf0, 0x7e, 0xaf, 0xa2, 0xf1, 0x88, 0x4c, 0x2a, 0x8f,
    0x37, 0x9d, 0x90, 0xe8, 0xdc, 0x60, 0xa6, 0xcf, 0x29, 0x49, 0x06, 0x0d,
    0x62, 0xb7, 0x3e, 0xab, 0xce, 0xbb, 0x02, 0x66, 0x89, 0x3e, 0xee, 0xf2,
    0x8c, 0x3e, 0x5b, 0x55, 0xd4, 0x85, 0x27, 0x2c, 0x8d, 0xc0, 0xc5, 0x9c,
    0xd5, 0x5a, 0xf4, 0x6e, 0xd3, 0x33, 0xeb, 0x38, 0xd9, 0xbf, 0xd7, 0x45,
    0x06, 0x06, 0xe8, 0x57, 0x77, 0x95, 0x86, 0x15, 0xf4, 0x85, 0xc8, 0xd8,
    0x74, 0x95, 0x32, 0xa7, 0xf8, 0xe7, 0x86, 0x28, 0xf8, 0x11, 0x55, 0x45,
    0x89, 0x93, 0x39, 0xe9, 0xf9, 0x59, 0x18, 0x86, 0xd7, 0x68, 0x99, 0x68,
    0x5a, 0x29, 0xb9, 0xa7, 0x15, 0x08, 0x97, 0xd7, 0x79, 0x07, 0x49, 0x35,
    0x1a, 0xd3, 0xc7, 0xda, 0x26, 0x0a, 0x82, 0xeb, 0x28, 0x9b, 0xeb, 0x55,
    0x78, 0x0a, 0x0c, 0x53, 0x7a, 0x39, 0xd2, 0xa9, 0xc9, 0x66, 0x0c, 0x1a,
    0xbc, 0xcc, 0xdc, 0xec, 0xfc, 0x2b, 0x9c, 0x9c, 0xaa, 0xcc, 0x30, 0x1d,
    0x58, 0xbc, 0x4a, 0x8c, 0x9c, 0x7d, 0x5c, 0x62, 0x0d, 0xfd, 0xbc, 0xfc,
    0xfd, 0x7d, 0xbd, 0xbd, 0xa9, 0x1d, 0xcd, 0x4d, 0x8d, 0xaa, 0x5e, 0x9e,
    0x7e, 0xee, 0x5e, 0x3d, 0x1c, 0x8e, 0xe6, 0xaa, 0x65, 0x4f, 0x09, 0x76,
    0xaf, 0x2f, 0x3f, 0x5d, 0x2b, 0xa8, 0x67, 0x52, 0x40, 0x5b, 0x51, 0xf0,
    0xd1, 0x3b, 0x98, 0x66, 0xdc, 0xbc, 0x75, 0x9c, 0xb2, 0xe9, 0xdb, 0x45,
    0x88, 0x1d, 0x3c, 0x86, 0xe8, 0xfa, 0xb5, 0x43, 0x88, 0x31, 0xa3, 0xc6,
    0xfe, 0x84, 0x0b, 0xe3, 0x49, 0xc4, 0xa4, 0x4e, 0x61, 0xb2, 0x8d, 0x24,
    0x9f, 0x3d, 0xec, 0x71, 0x72, 0x62, 0xc9, 0x95, 0x2c, 0x5b, 0xba, 0x2c,
    0x29, 0xf2, 0x62, 0x4c, 0x95, 0x2f, 0x5b, 0xcc, 0x34, 0x07, 0x72, 0xe2,
    0xcd, 0x77, 0x39, 0x31, 0x99, 0x18, 0x59, 0xb3, 0x65, 0xc4, 0x86, 0xad,
    0x48, 0xd8, 0x31, 0x1a, 0x8b, 0x56, 0x40, 0x7c, 0x28, 0x79, 0x41, 0x94,
    0x93, 0x74, 0x48, 0xd3, 0x47, 0x05, 0x7d, 0x49, 0xec, 0x18, 0x14, 0x1b,
    0x4d, 0x7f, 0x03, 0x01, 0x6e, 0xc5, 0xba, 0x13, 0xa7, 0xd6, 0x9e, 0xef,
    0x86, 0x0d, 0xcd, 0xca, 0xe2, 0xac, 0x26, 0x4b, 0x91, 0xa2, 0x8e, 0x91,
    0x09, 0x96, 0xad, 0x55, 0xa2, 0x72, 0x81, 0xce, 0x9c, 0x6b, 0xe8, 0x1f,
    0xda, 0x9c, 0x66, 0xf1, 0x96, 0x3b, 0x4a, 0x35, 0x64, 0x5c, 0xa0, 0x1e,
    0x89, 0x76, 0x83, 0xd6, 0xb6, 0xaa, 0x5e, 0x81, 0x84, 0xf7, 0x16, 0xae,
    0xf8, 0xb1, 0xa8, 0x52, 0xc5, 0x50, 0x29, 0xf3, 0xa9, 0xcb, 0x8f, 0x71,
    0xd7, 0xc3, 0x3c, 0xc7, 0x7a, 0x76, 0xcc, 0xf7, 0x5f, 0xca, 0x27, 0x3f,
    0x2f, 0xaa, 0x92, 0xec, 0xb7, 0xb3, 0xd8, 0xbf, 0x6e, 0xd7, 0xa9, 0xd5,
    0x4c, 0x13, 0x34, 0x6c, 0x8b, 0xa8, 0xbf, 0xda, 0xcd, 0xbc, 0xb6, 0xb6,
    0xb2, 0xc4, 0x53, 0xa5, 0x0e, 0x42, 0x6a, 0xb9, 0xef, 0x62, 0xd9, 0x74,
    0x45, 0x9f, 0x5c, 0xad, 0x3a, 0x39, 0x6d, 0xe4, 0xcb, 0x3f, 0x2b, 0xff,
    0xe8, 0x9c, 0xb8, 0x56, 0xe1, 0x5d, 0x79, 0xff, 0x0e, 0x9c, 0x2f, 0xf5,
    0xe9, 0x7d, 0xd8, 0x0f, 0x03, 0xf6, 0xed, 0x1d, 0xb3, 0xa4, 0xd7, 0xd2,
    0x8b, 0x3b, 0x4c, 0x6d, 0x3d, 0x3c, 0xc4, 0xdd, 0xc0, 0xb9, 0xa3, 0xc7,
    0xfd, 0xdc, 0xb0, 0xd7, 0xf3, 0xc3, 0xcb, 0xcb, 0x67, 0x0e, 0x1d, 0x7f,
    0xb8, 0xb0, 0xf1, 0xfe, 0x21, 0xdb, 0x3f, 0xc8, 0x5f, 0x73, 0xfa, 0x99,
    0x34, 0x18, 0x5c, 0xb7, 0x1d, 0x58, 0x5a, 0x6c, 0xff, 0x71, 0x26, 0x60,
    0x7e, 0xfd, 0x3d, 0xc6, 0xe0, 0x83, 0x14, 0xdd, 0x27, 0xe1, 0x82, 0xa7,
    0x3c, 0x64, 0x5e, 0x70, 0xb5, 0x6d, 0x06, 0x0c, 0x86, 0xf3, 0x69, 0x28,
    0x1e, 0x87, 0x16, 0x9a, 0x12, 0x60, 0x85, 0xe0, 0x98, 0xc8, 0xd5, 0x81,
    0x82, 0xa9, 0xa8, 0xe0, 0x88, 0x89, 0x90, 0x97, 0x97, 0x7b, 0x6f, 0x5d,
    0x07, 0x5e, 0x74, 0x0e, 0xe6, 0x66, 0x8e, 0x69, 0x24, 0x16, 0xd8, 0x22,
    0x71, 0x30, 0xbe, 0x96, 0x1e, 0x28, 0xdf, 0x5d, 0x36, 0x64, 0x5e, 0xc7,
    0xe8, 0xa6, 0x9b, 0x8d, 0xb4, 0x55, 0x07, 0xdf, 0x88, 0x3f, 0xbe, 0xd7,
    0x9d, 0x90, 0xad, 0xb9, 0x13, 0xe4, 0x76, 0x43, 0xe2, 0x55, 0xe5, 0x2f,
    0x45, 0x52, 0xd9, 0x5e, 0x8f, 0x41, 0x79, 0x98, 0x9b, 0x78, 0xec, 0x45,
    0x69, 0xa5, 0x8c, 0x4c, 0x92, 0xa9, 0xe5, 0x94, 0x88, 0x75, 0x19, 0x26,
    0x88, 0x8d, 0xc9, 0xf6, 0xe4, 0x62, 0x59, 0xce, 0xc9, 0x23, 0x59, 0x03,
    0xaa, 0xd7, 0xdb, 0x8c, 0x19, 0x2e, 0xf9, 0xe6, 0x5e, 0x60, 0xc2, 0x26,
    0xe3, 0x98, 0x35, 0xb2, 0xb6, 0x1e, 0x97, 0x68, 0xd2, 0x79, 0x28, 0x9b,
    0x80, 0x66, 0x07, 0xa3, 0x7d, 0xa3, 0x2d, 0x9a, 0xa7, 0x9d, 0x65, 0xbd,
    0xa2, 0xdd, 0x89, 0x14, 0x36, 0x88, 0xe9, 0x55, 0xc6, 0xfd, 0xb9, 0xe0,
    0xa3, 0x65, 0x16, 0x7a, 0xe7, 0x6c, 0x9a, 0xd2, 0x67, 0x60, 0xa9, 0xb6,
    0x99, 0x2a, 0xa9, 0x8b, 0xa3, 0x9e, 0x03, 0xa4, 0xa2, 0x84, 0x46, 0xaa,
    0xe4, 0x25, 0x9b, 0x56, 0xa6, 0xe6, 0x96, 0x27, 0xc6, 0x29, 0x62, 0x79,
    0x88, 0x0e, 0x9a, 0x26, 0xa8, 0x57, 0xce, 0x7a, 0xd6, 0xae, 0x7a, 0x4a,
    0xe9, 0x6b, 0xad, 0xc6, 0xf6, 0x89, 0xfe, 0x16, 0xae, 0x29, 0xa2, 0x1a,
    0x6b, 0x84, 0x97, 0xde, 0x08, 0xed, 0xb3, 0x6d, 0xf2, 0xa9, 0x23, 0x9c,
    0x4d, 0xc6, 0x28, 0x4d, 0x9d, 0xcd, 0x4e, 0xc8, 0xad, 0x47, 0x06, 0xc9,
    0x4a, 0x5d, 0xb6, 0xe4, 0xf8, 0xe8, 0x6a, 0xaf, 0x91, 0x22, 0x19, 0x22,
    0xa5, 0xf5, 0x29, 0x1b, 0xee, 0xad, 0x87, 0x58, 0x26, 0xe8, 0xb0, 0x4e,
    0x6a, 0x1b, 0x2a, 0x84, 0xdd, 0x5a, 0xea, 0x5f, 0xbe, 0xce, 0xea, 0xbb,
    0x68, 0x86, 0xd5, 0xfa, 0x49, 0x4a, 0x0d, 0xba, 0x54, 0x00, 0xcb, 0x2c,
    0xef, 0xf6, 0xf2, 0x68, 0x4a, 0x04, 0xbf, 0x1b, 0x0a, 0xc3, 0x06, 0xff,
    0xf1, 0x30, 0x31, 0x03, 0xff, 0x30, 0xf1, 0xbc, 0x89, 0x5e, 0x7c, 0x30,
    0x8d, 0x93, 0xe5, 0x89, 0xe5, 0x71, 0x90, 0x6a, 0xdc, 0xf1, 0xc6, 0xeb,
    0x01, 0x1b, 0xef, 0xbd, 0xd6, 0xae, 0x0b, 0x25, 0xaf, 0xc2, 0x96, 0x6c,
    0xa8, 0xca, 0xe5, 0xae, 0xec, 0x6d, 0xa5, 0x8d, 0xea, 0x7a, 0x2d, 0xa7,
    0xe6, 0x6a, 0xcc, 0xf2, 0x9a, 0x18, 0xcb, 0x59, 0x33, 0xbd, 0x28, 0x62,
    0x65, 0x31, 0x87, 0xad, 0xee, 0x9c, 0xb3, 0xad, 0x46, 0x1f, 0x7b, 0xae,
    0x98, 0xe3, 0x39, 0x55, 0x9c, 0x14, 0xaa, 0xda, 0x0c, 0xf5, 0xcb, 0x52,
    0x13, 0xdd, 0x32, 0xcf, 0x43, 0xbb, 0x4c, 0xb5, 0xce, 0xbc, 0x06, 0xbd,
    0xb4, 0xd5, 0x8b, 0xc0, 0x6a, 0x86, 0xa8, 0x7b, 0x7a, 0xe3, 0x33, 0xcc,
    0xee, 0xa2, 0x5c, 0x9f, 0xa3, 0x1e, 0x7f, 0x4a, 0xea, 0xa9, 0x6e, 0xa7,
    0x1a, 0x2d, 0xbf, 0xf6, 0xce, 0x8d, 0xef, 0xbe, 0x9d, 0x4e, 0x8d, 0x75,
    0xde, 0xf2, 0xde, 0x8c, 0x27, 0xce, 0x55, 0x17, 0x8d, 0x34, 0xa3, 0x42,
    0x57, 0xaa, 0x76, 0xd6, 0x47, 0x17, 0x8b, 0x38, 0xd8, 0x87, 0x2b, 0x9e,
    0x6e, 0xdb, 0x0b, 0x95, 0xc8, 0xb5, 0xc4, 0x01, 0x2f, 0xfe, 0xec, 0x44,
    0xc4, 0xdd, 0xb8, 0xd2, 0xf0, 0x64, 0x99, 0x7b, 0xac, 0x30, 0xc5, 0x4e,
    0x21, 0x9c, 0x31, 0xe5, 0x5f, 0x0b, 0x3c, 0xb9, 0x97, 0x2e, 0x99, 0xbd,
    0xa1, 0xba, 0xb9, 0x42, 0x2e, 0xf6, 0x87, 0xf7, 0x2d, 0x7e, 0x1d, 0x2a,
    0xa4, 0x71, 0xf2, 0x34, 0xde, 0x7b, 0xa3, 0xde, 0x38, 0xab, 0x84, 0xd7,
    0x7d, 0x2f, 0xeb, 0x76, 0x9b, 0x4c, 0xee, 0x9f, 0x9e, 0xc6, 0xfd, 0xbb,
    0xef, 0xbc, 0xdb, 0x6b, 0x3c, 0xdb, 0x20, 0xa7, 0xfd, 0x1f, 0xf3, 0xce,
    0xfb, 0x9c, 0xa9, 0xb4, 0x72, 0x1f, 0x4f, 0xfd, 0x5d, 0x3a, 0xe5, 0x2a,
    0x5d, 0xf2, 0xbd, 0x03, 0x5d, 0x3d, 0xf7, 0xda, 0x8b, 0x91, 0xa0, 0xaa,
    0xfb, 0xad, 0x8e, 0x7d, 0xf7, 0x2c, 0xc2, 0x2d, 0xfd, 0xef, 0x74, 0x2f,
    0x2b, 0x2e, 0xf7, 0x2f, 0x92, 0xdf, 0x35, 0xad, 0x82, 0x13, 0xf9, 0xaf,
    0xf8, 0xf6, 0xdf, 0x8f, 0x7f, 0xfe, 0x46, 0x0c, 0x3f, 0x7c, 0xe4, 0xdb,
    0xae, 0xef, 0x3d, 0xe8, 0xe9, 0x6f, 0x80, 0x42, 0xe9, 0x59, 0xb0, 0x6c,
    0x07, 0xb8, 0xc4, 0xf9, 0x4d, 0x6b, 0x7b, 0x3b, 0x0d, 0x03, 0xe5, 0xc7,
    0x0c, 0xed, 0x49, 0xd0, 0x80, 0x29, 0xbb, 0x1d, 0x02, 0xff, 0x86, 0x41,
    0x06, 0xc6, 0xeb, 0x4c, 0xbb, 0x23, 0x60, 0x11, 0xd8, 0x05, 0xaf, 0x0c,
    0xda, 0xea, 0x67, 0x86, 0xcb, 0x1d, 0xb5, 0x4c, 0xf7, 0xbe, 0xf3, 0xfd,
    0xef, 0x6c, 0x15, 0x5c, 0xca, 0x05, 0x35, 0x28, 0xc2, 0xc0, 0xf5, 0xcd,
    0x5f, 0xf3, 0x2b, 0x9f, 0x07, 0x4f, 0x00, 0xc2, 0x40, 0xc5, 0xf0, 0x29,
    0xa9, 0x13, 0xd3, 0x0a, 0x3f, 0x45, 0x43, 0xfd, 0x3d, 0x2f, 0x7e, 0x6f,
    0x9b, 0x94, 0xe3, 0xda, 0x57, 0xc4, 0x7a, 0x99, 0x8f, 0x59, 0x37, 0xac,
    0x07, 0x05, 0x49, 0xb6, 0x43, 0xc6, 0x29, 0x30, 0x88, 0x1f, 0x62, 0xe2,
    0xfe, 0x73, 0x72, 0x38, 0x3f, 0xf4, 0x4d, 0xcf, 0x7a, 0xb9, 0xd3, 0x21,
    0x0c, 0xbf, 0x08, 0xbb, 0x19, 0x12, 0x4b, 0x8a, 0x64, 0x44, 0x21, 0x12,
    0xbe, 0xd7, 0x21, 0x01, 0xa6, 0x6f, 0x7b, 0x2a, 0x54, 0xe2, 0x04, 0x91,
    0xb5, 0xa3, 0x36, 0x22, 0xe4, 0x8d, 0x56, 0x8c, 0xde, 0x16, 0x05, 0xf8,
    0xad, 0x23, 0x85, 0x6b, 0x45, 0xed, 0x5a, 0x21, 0x1d, 0x2d, 0xb8, 0x33,
    0x0e, 0x7a, 0x8d, 0x88, 0xed, 0x42, 0x57, 0x08, 0xc1, 0xe8, 0x3e, 0x25,
    0xfc, 0x51, 0x8b, 0xea, 0x5b, 0x62, 0x12, 0x49, 0x58, 0x47, 0xe2, 0x79,
    0x25, 0x47, 0x66, 0x6c, 0x22, 0x63, 0x1e, 0x48, 0x3f, 0x9c, 0x89, 0x8c,
    0x20, 0x9b, 0x23, 0x52, 0x27, 0x9d, 0x16, 0xb1, 0x4d, 0x02, 0x42, 0x94,
    0x98, 0x0b, 0x25, 0x04, 0x2d, 0xb9, 0xbf, 0x27, 0x0a, 0x32, 0x81, 0x65,
    0x14, 0xe3, 0xab, 0x16, 0x18, 0xc6, 0x31, 0x56, 0x12, 0x95, 0x56, 0x3a,
    0xe1, 0xeb, 0x64, 0x28, 0x4b, 0x57, 0xf2, 0x2d, 0x97, 0xae, 0x5b, 0x15,
    0x2d, 0x99, 0xa0, 0xca, 0x24, 0x21, 0x72, 0x8a, 0xbc, 0x04, 0x62, 0x15,
    0xb3, 0xe8, 0x47, 0x35, 0xde, 0x2f, 0x6a, 0x07, 0x2c, 0x21, 0x31, 0x5f,
    0x49, 0xc5, 0x36, 0x99, 0x8a, 0x8f, 0x48, 0x64, 0x64, 0xf0, 0x4e, 0xa9,
    0x47, 0x0d, 0x61, 0xf2, 0x8b, 0x90, 0x7c, 0xa4, 0x1d, 0x1b, 0xf9, 0x4b,
    0x9b, 0xc8, 0xac, 0x82, 0xd6, 0x9c, 0x96, 0x2f, 0xc9, 0x26, 0x47, 0x66,
    0x76, 0x90, 0x66, 0x72, 0x8c, 0x66, 0xbf, 0x24, 0x09, 0xc0, 0x76, 0x46,
    0x46, 0x69, 0x7b, 0xbc, 0xde, 0xb8, 0xc2, 0x79, 0xcb, 0x67, 0xee, 0x12,
    0x9a, 0xc5, 0xdc, 0xa7, 0x3f, 0xb3, 0xe4, 0xc0, 0x5f, 0x51, 0x0f, 0x9f,
    0xfd, 0xc4, 0x9d, 0x3e, 0x0d, 0x6a, 0x26, 0xd5, 0xb1, 0xaf, 0x9c, 0x04,
    0xe5, 0x09, 0x29, 0x74, 0x1d, 0x06, 0x3a, 0x4f, 0x9a, 0x32, 0x93, 0x9c,
    0x9c, 0xe8, 0x27, 0x1f, 0xaa, 0xb9, 0x22, 0x91, 0x8c, 0x79, 0x0d, 0x2d,
    0xa8, 0xed, 0x42, 0x16, 0xcc, 0x23, 0x26, 0xd4, 0x85, 0xc2, 0x7b, 0xe1,
    0x3d, 0x1b, 0x8a, 0x50, 0x58, 0xe2, 0x92, 0x9f, 0x2c, 0x7d, 0xa7, 0x34,
    0xbd, 0x09, 0x2d, 0x2c, 0xda, 0x8f, 0x7f, 0x6b, 0x83, 0x27, 0xef, 0x8c,
    0x87, 0xd3, 0x9a, 0xf6, 0x4f, 0x7c, 0x39, 0x95, 0xa7, 0x03, 0x27, 0x95,
    0xa0, 0x48, 0xae, 0x91, 0x6e, 0xf1, 0xac, 0x1f, 0x68, 0x16, 0x99, 0x4c,
    0x9f, 0xde, 0x51, 0xa9, 0x8d, 0x44, 0x63, 0xf6, 0x94, 0x39, 0xd4, 0x81,
    0x1a, 0x09, 0xa8, 0x36, 0x45, 0xea, 0x37, 0x81, 0xd7, 0xd1, 0xab, 0x22,
    0x0f, 0x82, 0x8e, 0x18, 0x25, 0x35, 0x19, 0x9a, 0xd5, 0x96, 0x14, 0x00,
    0x00, 0x3b,
    0x00
};

static unsigned char g_Font2S_gif[] =
{
    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0xf0, 0x01, 0x10, 0x00, 0x80, 0x01,
    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x2c, 0x00, 0x00, 0x00, 0x00,
    0xf0, 0x01, 0x10, 0x00, 0x00, 0x02, 0x64, 0x84, 0x8f, 0xa9, 0xcb, 0xed,
    0x0f, 0xa3, 0x9c, 0xb4, 0xda, 0x8b, 0xb3, 0xde, 0xbc, 0xfb, 0x0f, 0x86,
    0xe2, 0x48, 0x96, 0xe6, 0x89, 0xa6, 0xea, 0xca, 0xb6, 0xee, 0x0b, 0xc7,
    0xf2, 0x4c, 0xd7, 0xf6, 0x8d, 0xe7, 0xfa, 0xce, 0xf7, 0xfe, 0x0f, 0x0c,
    0x0a, 0x87, 0xc4, 0xa2, 0xf1, 0x88, 0x4c, 0x2a, 0x97, 0xcc, 0xa6, 0xf3,
    0x09, 0x8d, 0x4a, 0xa7, 0xd4, 0xaa, 0xf5, 0x8a, 0xcd, 0x6a, 0xb7, 0xdc,
    0xae, 0xf7, 0x0b, 0x0e, 0x8b, 0xc7, 0xe4, 0xb2, 0xf9, 0x8c, 0x4e, 0xab,
    0xd7, 0xec, 0xb6, 0xfb, 0x0d, 0x8f, 0xcb, 0xe7, 0xf4, 0xba, 0xfd, 0x8e,
    0xcf, 0xeb, 0xf7, 0xfc, 0xbe, 0xff, 0x0f, 0x18, 0x18, 0x54, 0x00, 0x00,
    0x3b,
    0x00
};



static unsigned char g_MenuGFX1m_orig_gif[] =
{
    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x20, 0x03, 0x30, 0x00, 0x87, 0x00,
    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x21, 0xf9, 0x04, 0x00, 0x00, 0x00, 0xff, 0x00, 0x2c, 0x00, 0x00,
    0x00, 0x00, 0x20, 0x03, 0x30, 0x00, 0x00, 0x08, 0xff, 0x00, 0x01, 0x08,
    0x1c, 0x48, 0xb0, 0xa0, 0xc1, 0x83, 0x08, 0x13, 0x2a, 0x5c, 0xc8, 0xb0,
    0xa1, 0xc3, 0x87, 0x10, 0x23, 0x4a, 0x9c, 0x48, 0xb1, 0xa2, 0xc5, 0x8b,
    0x18, 0x33, 0x6a, 0xdc, 0xc8, 0xb1, 0xa3, 0xc7, 0x8f, 0x20, 0x43, 0x8a,
    0x1c, 0x49, 0xb2, 0xa4, 0xc9, 0x93, 0x28, 0x53, 0xaa, 0x5c, 0xc9, 0xb2,
    0xa5, 0xcb, 0x97, 0x30, 0x63, 0xca, 0x9c, 0x49, 0xb3, 0xa6, 0xcd, 0x9b,
    0x38, 0x73, 0xea, 0xdc, 0xc9, 0xb3, 0xa7, 0xcf, 0x9f, 0x40, 0x83, 0x0a,
    0x1d, 0x4a, 0xb4, 0xa8, 0xd1, 0xa3, 0x48, 0x93, 0x2a, 0x5d, 0xca, 0xb4,
    0xa9, 0xd3, 0xa7, 0x50, 0xa3, 0x4a, 0x9d, 0x4a, 0xb5, 0xaa, 0xd5, 0xab,
    0x58, 0xb3, 0x6a, 0xdd, 0xca, 0xb5, 0xab, 0xd7, 0xaf, 0x60, 0xc3, 0x8a,
    0x1d, 0x4b, 0xb6, 0xac, 0xd9, 0xb3, 0x68, 0xd3, 0xaa, 0x5d, 0xcb, 0xb6,
    0xad, 0xdb, 0xb7, 0x70, 0xe3, 0xca, 0x9d, 0x4b, 0xb7, 0xae, 0xdd, 0xbb,
    0x78, 0xf3, 0xea, 0xdd, 0xcb, 0xb7, 0xaf, 0xdf, 0xbf, 0x80, 0x03, 0x0b,
    0x1e, 0x4c, 0xb8, 0xb0, 0xe1, 0xc3, 0x88, 0x13, 0x2b, 0x5e, 0xcc, 0xb8,
    0xb1, 0xe3, 0xc7, 0x90, 0x23, 0x4b, 0x9e, 0x4c, 0xb9, 0xb2, 0xe5, 0xcb,
    0x98, 0x33, 0x6b, 0xde, 0xcc, 0xb9, 0xb3, 0xe7, 0xcf, 0xa0, 0x43, 0x8b,
    0x1e, 0x4d, 0xba, 0xb4, 0xe9, 0xd3, 0xa8, 0x53, 0xab, 0x5e, 0xcd, 0xba,
    0xb5, 0xeb, 0xd7, 0xb0, 0x63, 0xcb, 0x9e, 0x4d, 0xbb, 0xb6, 0xed, 0xdb,
    0xb8, 0x73, 0xeb, 0xde, 0xcd, 0xbb, 0xb7, 0xef, 0xdf, 0xc0, 0x83, 0x0b,
    0x1f, 0x4e, 0xbc, 0xb8, 0xf1, 0xe3, 0xc8, 0x93, 0x2b, 0x5f, 0xbe, 0x38,
    0x80, 0xf3, 0x00, 0x3c, 0x9f, 0x43, 0xdf, 0x29, 0x3d, 0xfa, 0x73, 0xeb,
    0xce, 0xb1, 0x4f, 0xd7, 0x59, 0x9d, 0xfa, 0x75, 0xef, 0xd9, 0xc1, 0x6f,
    0xff, 0xcf, 0xd9, 0x9d, 0xfb, 0x77, 0xad, 0xe5, 0xc9, 0x9f, 0x57, 0x1f,
    0xde, 0x7c, 0x7b, 0xf6, 0xe3, 0x71, 0xa6, 0x97, 0xbf, 0x9e, 0xfe, 0x7b,
    0xfb, 0xf1, 0x6f, 0xce, 0xd7, 0x5f, 0x9f, 0xff, 0xfd, 0xab, 0xfb, 0xd9,
    0x14, 0x60, 0x4d, 0x03, 0xd2, 0x54, 0xe0, 0x4c, 0x07, 0xca, 0x94, 0x60,
    0x4c, 0x0b, 0xc2, 0xd4, 0xe0, 0x4b, 0x0f, 0xba, 0x14, 0x61, 0x4b, 0x13,
    0xb2, 0x54, 0xe1, 0x52, 0x17, 0xaa, 0x94, 0x61, 0x4a, 0x1b, 0xa2, 0xd4,
    0xe1, 0x49, 0x1f, 0x9a, 0x14, 0x62, 0x49, 0x23, 0x92, 0x54, 0xe2, 0x48,
    0x27, 0x8a, 0x94, 0x62, 0x48, 0x2b, 0x82, 0xd4, 0x62, 0x4f, 0xd2, 0xbd,
    0xa8, 0x51, 0x8c, 0xfd, 0x29, 0x48, 0x63, 0x7e, 0x36, 0xd2, 0x88, 0x9f,
    0x8c, 0x19, 0xdd, 0x88, 0x23, 0x83, 0x37, 0xee, 0x58, 0x23, 0x90, 0x3a,
    0xfa, 0x17, 0xa3, 0x90, 0xff, 0xe5, 0x78, 0x24, 0x80, 0x41, 0x1a, 0xc9,
    0x23, 0x46, 0x3e, 0x22, 0xf9, 0xa3, 0x83, 0x4d, 0x0a, 0x58, 0x25, 0x81,
    0x57, 0x1a, 0x98, 0x25, 0x82, 0x5b, 0x2a, 0xf9, 0xe4, 0x45, 0x51, 0x3a,
    0x39, 0x24, 0x54, 0x61, 0x5a, 0x59, 0xa4, 0x99, 0x4b, 0xa2, 0xf9, 0xa5,
    0x45, 0x65, 0x62, 0x79, 0xa6, 0x9b, 0x69, 0xc2, 0xb9, 0x66, 0x45, 0x6d,
    0x6a, 0xf9, 0xa6, 0x9d, 0x71, 0xe2, 0x39, 0xa7, 0x9e, 0x63, 0x42, 0xd8,
    0x25, 0x91, 0x79, 0x72, 0x79, 0xa7, 0xa0, 0x81, 0x7a, 0xd9, 0xa7, 0x84,
    0x7f, 0x52, 0x39, 0xa8, 0xa1, 0x49, 0x02, 0xba, 0xe7, 0x44, 0x75, 0x12,
    0xfa, 0xa8, 0xa2, 0x3e, 0x4e, 0xb9, 0x52, 0xa5, 0x87, 0x72, 0x88, 0xa9,
    0xa5, 0x1a, 0x6e, 0xca, 0xe7, 0xa2, 0x14, 0x7a, 0x2a, 0x69, 0xa2, 0x97,
    0x8a, 0xca, 0x68, 0xa1, 0xa1, 0x62, 0xfa, 0x29, 0xaa, 0x16, 0x9a, 0x1a,
    0xd5, 0xa6, 0x9c, 0x6a, 0xff, 0xaa, 0xea, 0xa8, 0xa0, 0xb6, 0x3a, 0xeb,
    0xa9, 0x93, 0x36, 0x04, 0xeb, 0xaa, 0xb9, 0x32, 0xb4, 0x2b, 0xad, 0xac,
    0x96, 0x7a, 0xab, 0xa3, 0xa4, 0x76, 0x3a, 0xac, 0x53, 0xb0, 0xf6, 0x7a,
    0x50, 0xb2, 0x99, 0x9a, 0xc8, 0x6c, 0xac, 0xce, 0x32, 0x4b, 0xe9, 0xaf,
    0x88, 0x4a, 0xeb, 0xa7, 0xb5, 0xd5, 0x26, 0x3b, 0xad, 0xab, 0xb6, 0x6a,
    0x7b, 0xad, 0xb7, 0xd9, 0x52, 0xdb, 0xd4, 0xb3, 0xd0, 0xa2, 0xf8, 0xec,
    0xb6, 0xc7, 0x0a, 0x0b, 0x6e, 0xaa, 0xeb, 0x76, 0x2b, 0xae, 0xbb, 0xdc,
    0xaa, 0xfb, 0xae, 0xbc, 0xf1, 0x1a, 0xdb, 0x2e, 0xbd, 0xe9, 0xda, 0x3b,
    0x2f, 0x52, 0xe4, 0x2a, 0x2b, 0x50, 0xbf, 0xcd, 0x7e, 0x04, 0x70, 0xa3,
    0xd1, 0xf6, 0x0b, 0x2f, 0xb6, 0xb2, 0x1a, 0x8c, 0xef, 0xbd, 0x22, 0x0e,
    0x7c, 0x30, 0xc3, 0x24, 0x3a, 0xbc, 0xf0, 0xbe, 0x11, 0x03, 0xcc, 0xd4,
    0xc0, 0xe5, 0x7a, 0x84, 0xf1, 0xc3, 0x14, 0x17, 0x4c, 0x2e, 0xc7, 0xf5,
    0x56, 0xac, 0xb0, 0xbe, 0xe7, 0x4e, 0x1c, 0xb2, 0xc7, 0x25, 0x93, 0x8c,
    0xb0, 0x87, 0x12, 0xab, 0x0c, 0xb1, 0x50, 0x18, 0xe7, 0x1a, 0x73, 0xc0,
    0x33, 0xce, 0x9c, 0x71, 0x8f, 0x36, 0xb3, 0x3c, 0xb3, 0xce, 0x31, 0xf3,
    0xbc, 0x31, 0x88, 0x39, 0x03, 0xbd, 0xb3, 0xd0, 0x3d, 0x13, 0xfd, 0x73,
    0xc3, 0x43, 0x1b, 0x65, 0xf3, 0xcd, 0x50, 0x06, 0x8d, 0x74, 0xd1, 0x4f,
    0x1f, 0x2d, 0xb2, 0xd4, 0x28, 0x5b, 0x6c, 0x74, 0xcb, 0x53, 0x63, 0x5d,
    0xf5, 0xc8, 0x59, 0x5b, 0x1d, 0xb5, 0xd6, 0xe6, 0x26, 0x1d, 0xd4, 0xd2,
    0x91, 0xd6, 0x4c, 0x76, 0xb0, 0x6c, 0x9e, 0x8d, 0x36, 0x9d, 0x6a, 0xf3,
    0xd8, 0xb6, 0xdb, 0x6f, 0x13, 0x0c, 0x66, 0xdc, 0x4c, 0x3f, 0x44, 0x77,
    0xdd, 0x0e, 0xdd, 0xed, 0x22, 0xdd, 0x7b, 0xc7, 0xb7, 0xdd, 0xf7, 0xdb,
    0x2e, 0x0a, 0xcc, 0xb7, 0xe0, 0x7e, 0x13, 0x0e, 0xb8, 0xe1, 0x6d, 0xff,
    0x9d, 0x38, 0xe2, 0x6a, 0x2b, 0xde, 0x38, 0xe3, 0x67, 0x3b, 0x1e, 0x39,
    0xe4, 0x64, 0x4b, 0x5e, 0x39, 0xe5, 0x4b, 0xff, 0xdd, 0xf4, 0xdd, 0xb5,
    0xda, 0xcd, 0x79, 0xe7, 0x79, 0x7f, 0xbe, 0xb6, 0xaf, 0xa2, 0x8f, 0x58,
    0xba, 0xe9, 0xa7, 0xcb, 0x1d, 0x7a, 0xea, 0x9b, 0x9f, 0xde, 0x7a, 0xe9,
    0xaf, 0x8b, 0x1e, 0xfb, 0xe7, 0xb3, 0x73, 0x5e, 0x7b, 0xed, 0x7a, 0xcf,
    0xcd, 0xba, 0xee, 0xae, 0xf3, 0x0e, 0xbb, 0xef, 0xb2, 0x03, 0x4f, 0xbb,
    0xf0, 0xb6, 0x13, 0x9f, 0x7b, 0xda, 0xbb, 0x23, 0xdf, 0xbb, 0xf2, 0xbf,
    0x33, 0x1f, 0xbc, 0xf3, 0x65, 0x17, 0x94, 0xfa, 0xca, 0xcb, 0x4e, 0xdf,
    0xf1, 0x40, 0xd6, 0x5f, 0xff, 0x6f, 0xf6, 0xf9, 0x4a, 0xcf, 0x7d, 0xa5,
    0xa4, 0x7f, 0x5f, 0x2c, 0x00, 0xe2, 0x47, 0x4f, 0x50, 0xf9, 0xe3, 0xa3,
    0x0f, 0x3a, 0xf9, 0xea, 0x2f, 0xd8, 0xbe, 0xfb, 0xef, 0xab, 0xce, 0xbe,
    0xd7, 0x09, 0xc5, 0x2f, 0xbf, 0xfd, 0xb1, 0xe2, 0x1f, 0xfe, 0xfb, 0xfb,
    0xb7, 0xdf, 0xbf, 0xfa, 0xff, 0x43, 0x5f, 0x00, 0xcb, 0x37, 0x40, 0xf1,
    0x15, 0xf0, 0x7b, 0x07, 0xe4, 0x5e, 0x02, 0xb3, 0x97, 0xc0, 0x80, 0x00,
    0x00, 0x3b,
    0x00
};

static unsigned char g_MenuGFX1m_fixed_gif[] =
{
    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x20, 0x03, 0x3c, 0x00, 0x80, 0x01,
    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x21, 0xfe, 0x11, 0x43, 0x72,
    0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x47,
    0x49, 0x4d, 0x50, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x20, 0x03, 0x3c,
    0x00, 0x00, 0x02, 0xfe, 0x84, 0x8f, 0xa9, 0xcb, 0xed, 0x0f, 0xa3, 0x9c,
    0xb4, 0xda, 0x8b, 0xb3, 0xde, 0xbc, 0xfb, 0x0f, 0x86, 0xe2, 0x48, 0x96,
    0xe6, 0x89, 0xa6, 0xea, 0xca, 0xb6, 0xee, 0x0b, 0xc7, 0xf2, 0x4c, 0xd7,
    0xf6, 0x8d, 0xe7, 0xfa, 0xce, 0xf7, 0xfe, 0x0f, 0x0c, 0x0a, 0x87, 0xc4,
    0xa2, 0xf1, 0x88, 0x4c, 0x2a, 0x97, 0xcc, 0xa6, 0xf3, 0x09, 0x8d, 0x4a,
    0xa7, 0xd4, 0xaa, 0xf5, 0x8a, 0xcd, 0x6a, 0xb7, 0xdc, 0xae, 0xf7, 0x0b,
    0x0e, 0x8b, 0xc7, 0xe4, 0xb2, 0xf9, 0x8c, 0x4e, 0xab, 0xd7, 0xec, 0xb6,
    0xfb, 0x0d, 0x8f, 0xcb, 0xe7, 0xf4, 0xba, 0xfd, 0x8e, 0xcf, 0xeb, 0xf7,
    0xfc, 0xbe, 0xff, 0x0f, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, 0x88,
    0x98, 0xa8, 0xb8, 0xc8, 0xd8, 0xe8, 0xf8, 0x08, 0x19, 0x29, 0x39, 0x49,
    0x59, 0x69, 0x79, 0x89, 0x99, 0xa9, 0xb9, 0xc9, 0xd9, 0xe9, 0xf9, 0x09,
    0x1a, 0x2a, 0x3a, 0x4a, 0x5a, 0x6a, 0x7a, 0x8a, 0x9a, 0xaa, 0xba, 0xca,
    0xda, 0xea, 0xfa, 0x0a, 0x1b, 0x2b, 0x3b, 0x4b, 0x5b, 0x6b, 0x7b, 0x8b,
    0x9b, 0xab, 0xbb, 0xcb, 0xdb, 0xeb, 0xfb, 0x0b, 0x1c, 0x2c, 0x3c, 0x4c,
    0x5c, 0x6c, 0x7c, 0x8c, 0x9c, 0xac, 0xbc, 0xcc, 0xdc, 0xec, 0xfc, 0xfc,
    0x18, 0x20, 0x1d, 0x00, 0x34, 0x4d, 0xfd, 0x63, 0x5d, 0x3d, 0xad, 0x2d,
    0xcd, 0x7d, 0xed, 0x93, 0x8d, 0xbd, 0x2d, 0xde, 0x4d, 0xfe, 0xdd, 0x13,
    0x0e, 0x3e, 0xee, 0x95, 0x8e, 0xbe, 0xee, 0x5e, 0xae, 0x1e, 0x0f, 0x7f,
    0xce, 0xd3, 0x6e, 0xff, 0x8e, 0x3f, 0xaf, 0x5f, 0xbf, 0x73, 0xef, 0x9f,
    0x0f, 0xe0, 0xbe, 0x2d, 0xff, 0x74, 0x14, 0xcc, 0x71, 0x10, 0x47, 0xc2,
    0x1b, 0x0b, 0x6d, 0x34, 0xac, 0xf1, 0x90, 0x46, 0xc4, 0x19, 0x13, 0x65,
    0x54, 0x8c, 0x71, 0x11, 0x46, 0xc6, 0xfe, 0x27, 0x1b, 0x5d, 0x74, 0x6c,
    0xf1, 0x91, 0x45, 0xc8, 0x15, 0x23, 0x55, 0x94, 0x4c, 0x71, 0x12, 0x45,
    0xca, 0x13, 0x2b, 0x4d, 0xb4, 0x2c, 0xf1, 0x92, 0x44, 0xcc, 0x20, 0xd6,
    0x66, 0x7a, 0xa8, 0x19, 0xd0, 0x21, 0xce, 0x7e, 0x3a, 0x71, 0xf2, 0xb3,
    0xd9, 0x61, 0x27, 0x4f, 0x88, 0x3b, 0x7f, 0xe6, 0x24, 0xea, 0x53, 0x60,
    0x4d, 0xa3, 0x03, 0x7b, 0x2e, 0x25, 0x58, 0x54, 0x29, 0x50, 0x0e, 0x42,
    0x99, 0x0e, 0x95, 0x18, 0xd5, 0x60, 0x56, 0x84, 0x5b, 0x15, 0x76, 0x65,
    0xf8, 0xd5, 0xe9, 0xd4, 0x0d, 0x55, 0xa5, 0x1e, 0xa5, 0x52, 0x56, 0x6b,
    0x52, 0xb5, 0x4f, 0xd9, 0x8e, 0xd5, 0x90, 0x96, 0xeb, 0x5a, 0xb9, 0x6d,
    0xe9, 0xbe, 0xcd, 0x10, 0xd7, 0xeb, 0x5c, 0xbd, 0x75, 0xf9, 0xde, 0xf5,
    0x7b, 0x96, 0x62, 0x58, 0xa4, 0x7d, 0xc1, 0xee, 0x35, 0x5c, 0x58, 0x6c,
    0x60, 0x8b, 0x83, 0xb1, 0x1e, 0x56, 0xdc, 0x94, 0xf0, 0xdf, 0x0b, 0x79,
    0x11, 0x4f, 0x76, 0x2c, 0xf4, 0xea, 0x8b, 0xcc, 0x8b, 0x41, 0x72, 0xd6,
    0xec, 0xf1, 0x33, 0xe0, 0xc7, 0x18, 0x45, 0x5b, 0x6e, 0xbc, 0xd9, 0x34,
    0xe4, 0xc4, 0xa5, 0x39, 0x8f, 0x66, 0xad, 0x51, 0x75, 0x95, 0xcf, 0xa0,
    0x3d, 0xbb, 0x3e, 0x4d, 0x3a, 0xf6, 0xed, 0xd5, 0x97, 0x23, 0xd0, 0x7e,
    0xdd, 0x1b, 0xc2, 0x6f, 0xdc, 0xb0, 0x53, 0xef, 0x96, 0x8c, 0x3a, 0xf4,
    0x71, 0x29, 0xb4, 0x83, 0x2f, 0x68, 0xde, 0x59, 0x25, 0xf4, 0xda, 0xd2,
    0xa1, 0x63, 0x1e, 0xce, 0xd8, 0xba, 0x60, 0xed, 0xd9, 0x9b, 0x5f, 0x97,
    0xad, 0xdb, 0xfb, 0x76, 0xf1, 0xdd, 0xb1, 0x47, 0x99, 0x4e, 0x9d, 0xe5,
    0xf4, 0xef, 0xcb, 0x8d, 0x93, 0x6f, 0xfd, 0x3e, 0xbc, 0x79, 0xf9, 0xe0,
    0xdd, 0xcf, 0xb7, 0x5f, 0x5f, 0x79, 0x7c, 0xfc, 0xed, 0xfe, 0xf5, 0xdf,
    0x67, 0x82, 0x9e, 0x73, 0x06, 0x04, 0x18, 0xdd, 0x08, 0x04, 0x46, 0x56,
    0x5d, 0x80, 0xf4, 0x71, 0x67, 0x9b, 0x82, 0xfc, 0xed, 0x67, 0xd2, 0x81,
    0x0b, 0x42, 0x88, 0x92, 0x84, 0x0f, 0xfe, 0x57, 0x21, 0x81, 0x50, 0x1c,
    0x98, 0x9e, 0x08, 0x1c, 0x4e, 0x88, 0x61, 0x82, 0xe8, 0x81, 0x98, 0x5f,
    0x86, 0x0e, 0xfa, 0xb7, 0xde, 0x85, 0x25, 0x8a, 0x98, 0x22, 0x8a, 0x0c,
    0x8a, 0x64, 0xa1, 0x8b, 0x14, 0x1a, 0xc1, 0x61, 0x6f, 0x35, 0x16, 0x78,
    0xd3, 0x8d, 0x1d, 0x06, 0xa5, 0x23, 0x8c, 0x37, 0xfa, 0x58, 0x23, 0x90,
    0x1f, 0x92, 0xd4, 0x23, 0x91, 0x3f, 0x1a, 0x19, 0x24, 0x92, 0x43, 0x46,
    0x78, 0xa4, 0x12, 0x3a, 0xee, 0x48, 0x55, 0x91, 0x4c, 0x26, 0x39, 0xe5,
    0x92, 0x26, 0x5a, 0xc9, 0xa2, 0x86, 0x4a, 0xc6, 0x78, 0x25, 0x97, 0x59,
    0x9e, 0xd8, 0xa5, 0x96, 0x55, 0x7a, 0xa9, 0x5e, 0x93, 0x45, 0x3c, 0x59,
    0x59, 0x8e, 0x68, 0x16, 0x07, 0xd7, 0x9a, 0x6c, 0xe2, 0xe5, 0x26, 0x50,
    0x71, 0xca, 0x39, 0x27, 0x82, 0x64, 0xd5, 0x09, 0xe5, 0x04, 0x78, 0xe6,
    0x29, 0xc1, 0x9e, 0x32, 0xe1, 0xf9, 0x67, 0x9d, 0x81, 0xce, 0x29, 0x93,
    0x81, 0x80, 0x1a, 0x2a, 0x28, 0xa2, 0x84, 0x2a, 0x1a, 0xe7, 0xa0, 0x8d,
    0x32, 0xea, 0xa6, 0xa3, 0x91, 0x42, 0xba, 0xa6, 0xa4, 0x95, 0x52, 0x8a,
    0xa6, 0xa5, 0x99, 0x62, 0xfa, 0xe4, 0xa0, 0x51, 0xee, 0x99, 0x9b, 0x9e,
    0xa0, 0x86, 0xda, 0xe7, 0xa8, 0x6f, 0x0a, 0x67, 0xea, 0x49, 0xa9, 0xaa,
    0xba, 0xaa, 0x9d, 0xa5, 0xb6, 0xfa, 0xe9, 0xaa, 0xb1, 0xa6, 0x3a, 0xab,
    0xa9, 0xb5, 0x8e, 0x7a, 0x2b, 0xa8, 0xb9, 0xe6, 0xea, 0xe7, 0x9d, 0xb0,
    0xfa, 0x2a, 0x2b, 0xb0, 0xb4, 0x0a, 0x6b, 0x2b, 0xb1, 0xb8, 0x1a, 0xab,
    0xd6, 0x2b, 0xb2, 0xbd, 0xb6, 0xf9, 0x2b, 0xb3, 0xc1, 0x3a, 0x3b, 0x2c,
    0xb4, 0xc5, 0x4a, 0x9b, 0x66, 0x02, 0xad, 0xbe, 0xf8, 0xdc, 0xb5, 0x21,
    0x1e, 0xa0, 0xed, 0xb6, 0x03, 0x76, 0xdb, 0x9f, 0xb5, 0xe0, 0x66, 0x86,
    0xea, 0xb8, 0xc9, 0x01, 0x60, 0x6e, 0xb5, 0x08, 0xa4, 0x7b, 0x2e, 0xbb,
    0xa4, 0xa2, 0xeb, 0xee, 0x43, 0xf1, 0xca, 0x3b, 0xaf, 0xab, 0xf0, 0x8a,
    0xd9, 0x40, 0xbd, 0xf6, 0xea, 0x5b, 0x1b, 0xbf, 0xe5, 0xce, 0xfb, 0x6f,
    0xbc, 0x01, 0xbb, 0x3b, 0x30, 0xbb, 0x05, 0xa7, 0x7b, 0xb0, 0xb9, 0x09,
    0x8f, 0xbb, 0x30, 0xb8, 0x0d, 0x77, 0xfb, 0x30, 0xbf, 0x12, 0x4f, 0x4c,
    0x71, 0xc5, 0x16, 0x5f, 0x8c, 0x71, 0xc6, 0x1a, 0x6f, 0xcc, 0x71, 0xc7,
    0x1e, 0x7f, 0x0c, 0x72, 0xc8, 0x22, 0x8f, 0x4c, 0x72, 0xc9, 0x26, 0x9f,
    0x8c, 0x72, 0xca, 0x2a, 0xaf, 0xcc, 0x72, 0xcb, 0x2e, 0xbf, 0x0c, 0x73,
    0xcc, 0x32, 0xcf, 0x4c, 0x73, 0xcd, 0x36, 0xdf, 0x8c, 0x73, 0xce, 0x3a,
    0xef, 0xcc, 0x73, 0xcf, 0x3e, 0xff, 0x0c, 0x74, 0xd0, 0x42, 0x0f, 0x4d,
    0x74, 0xd1, 0x46, 0x1f, 0x8d, 0x74, 0xd2, 0x4a, 0x2f, 0xcd, 0x74, 0xd3,
    0x4e, 0x3f, 0x0d, 0x75, 0xd4, 0x52, 0x4f, 0x4d, 0x75, 0xd5, 0x56, 0x5f,
    0x8d, 0x75, 0xd6, 0x5a, 0x6f, 0xcd, 0x75, 0xd7, 0x5e, 0x7f, 0x0d, 0x76,
    0xd8, 0x62, 0x8f, 0x4d, 0x76, 0xd9, 0x66, 0x9f, 0x8d, 0x76, 0xda, 0x6a,
    0xaf, 0xcd, 0x76, 0xdb, 0x6e, 0xbf, 0x0d, 0xb7, 0xbb, 0x05, 0x00, 0x00,
    0x3b,
    0x00
};



struct Exe2UI
{
    off_t offset;
    size_t size;
    const char* filename;
};

static struct Exe2UI s_exe2ui[] =
{
    {207393, 10862, "EditorSplash.gif"},
    {827416, 35359, "MenuGFX4.gif"},
    {888848, 1032, "Coin.gif"},
    {889931, 1126, "Loader.gif"},
    {2997483, 898, "BMVsm.gif"},
    {2998435, 940, "BMVs.gif"},
    {2999434, 1001, "BMWinm.gif"},
    {3000490, 1156, "BMWin.gif"},
    {3001718, 976, "CharacterName5m.gif"},
    {3002766, 985, "CharacterName4m.gif"},
    {3003823, 1004, "CharacterName3m.gif"},
    {3004899, 1005, "CharacterName2m.gif"},
    {3005976, 1015, "CharacterName1m.gif"},
    {3007059, 1095, "CharacterName5.gif"},
    {3008222, 1109, "CharacterName4.gif"},
    {3009399, 1166, "CharacterName3.gif"},
    {3010633, 1136, "CharacterName2.gif"},
    {3011837, 1177, "CharacterName1.gif"},
    {3013076, 1119, "LoadCoinm.gif"},
    {3014253, 1338, "LoadCoin.gif"},
    {3015975, 3126, "Warpm.gif"},
    {3019157, 3126, "Warp.gif"},
    {3022441, 1307, "YoshiWings.gif"},
    {3023807, 1116, "YoshiWingsm.gif"},
    {3024979, 902, "Tongue1.gif"},
    {3025941, 879, "Tongue1m.gif"},
    {3026876, 985, "Tongue2.gif"},
    {3027921, 985, "Tongue2m.gif"},
    {3029007, 1423,"Boot3m.gif"},
    {3030484, 1423, "Boot3.gif"},
    {3031961, 1503, "Boot2.gif"},
    {3033522, 1041, "Boot2m.gif"},
    {3034618, 13640, "Mount.gif"},
    {3048317, 3496, "Mountm.gif"},
    {3051871, 1041, "Boot1m.gif"},
    {3052966, 1503, "Boot1.gif"},
    {3054571, 1754, "MenuGFX1m.gif"},
    {3056382, 35359, "MenuGFX4.gif"},
    {3091802, 1496, "MenuGFX3m.gif"},
    {3093355, 1765, "MenuGFX3.gif"},
    {3095181, 2886, "MenuGFX2m.gif"},
    {3098124, 8430, "MenuGFX2.gif"},
    {3106611, 4595, "MenuGFX1.gif"},
    {3111314, 895, "Interface8m.gif"},
    {3112268, 895, "Interface8.gif"},
    {3113226, 936, "Interface7m.gif"},
    {3114221, 936, "Interface7.gif"},
    {3115220, 854, "Interface6m.gif"},
    {3116133, 879, "Interface6.gif"},
    {3117075, 862, "Interface0m.gif"},
    {3117996, 861, "Interface0.gif"},
    {3118914, 856, "MCursor3.gif"},
    {3159803, 822, "MCursor3m.gif"},
    {3119829, 896, "Heart2m.gif"},
    {3120784, 896, "Heart1m.gif"},
    {3121735, 992, "Heart2.gif"},
    {3122782, 992, "Heart1.gif"},
    {3123831, 874, "MCursor2.gif"},
    {3124766, 874, "MCursor2m.gif"},
    {3125697, 874, "MCursor1.gif"},
    {3126632, 874, "MCursor1m.gif"},
    {3127567, 931, "nCursor7m.gif"},
    {3128555, 994, "nCursor7.gif"},
    {3129606, 994, "nCursor6.gif"},
    {3130661, 931, "nCursor6m.gif"},
    {3131649, 994, "nCursor5.gif"},
    {3132704, 931, "nCursor5m.gif"},
    {3133692, 994, "nCursor3.gif"},
    {3134747, 931, "nCursor3m.gif"},
    {3135735, 994, "nCursor2.gif"},
    {3136790, 931, "nCursor2m.gif"},
    {3137778, 994, "nCursor1.gif"},
    {3138833, 931, "nCursor1m.gif"},
    {3139821, 994, "nCursor0.gif"},
    {3140876, 931, "nCursor0m.gif"},
    {3141868, 931, "nCursor4m.gif"},
    {3142856, 994, "nCursor4.gif"},
    {3143906, 1540, "Font2Sm.gif"}, // GENERATE BLACK-FILLED FRONT OF SAME SIZE!!!
    {3145507, 866, "ECursor3m.gif"},
    {3146430, 934, "ECursor3.gif"},
    {3147421, 981, "ECursor2.gif"},
    {3148463, 931, "ECursor2m.gif"},
    {3149451, 994, "ECursor1.gif"},
    {3150506, 931, "ECursor1m.gif"},
    {3151500, 865, "Interface5m.gif"},
    {3152424, 865, "Interface5.gif"},
    {3153338, 864, "Chat.gif"},
    {3154255, 864, "Chatm.gif"},
    {3155174, 2613, "Font2_3.gif"}, // GENERATE INVERTED MASK OF SAME SIZE!!!
    {3157839, 1903, "TextBox.gif"},
    {3159803, 822, "MCursor0m.gif"},
    {3160682, 822, "MCursor0.gif"},
    {3161563, 116454, "Font2_2m.gif"},
    {3278072, 116454, "Font2_2.gif"},
    {3394581, 50646, "Font2_1m.gif"}, // GENERATE BLACK-FILLED FRONT OF SAME SIZE!!!
    {3445286, 1440054, "Interface4.gif"},
    {4885399, 9462, "Container1.gif"},
    {4894924, 9462, "Container1m.gif"},
    {4904449, 9462, "Container2m.gif"},
    {4913970, 9462, "Container2.gif"},
    {4923495, 9462, "Container0m.gif"},
    {4933016, 9462, "Container0.gif"},
    {4942533, 726, "Font1_0.gif"},
    {4943315, 726, "Font1_0m.gif"},
    {4944096, 726, "Font1_1.gif"},
    {4944878, 726, "Font1_1m.gif"},
    {4945659, 726, "Font1_2.gif"},
    {4946441, 726, "Font1_2m.gif"},
    {4947222, 726, "Font1_3.gif"},
    {4948004, 726, "Font1_3m.gif"},
    {4948785, 726, "Font1_4.gif"},
    {4949567, 726, "Font1_4m.gif"},
    {4950348, 726, "Font1_5.gif"},
    {4951130, 726, "Font1_5m.gif"},
    {4951911, 726, "Font1_6.gif"},
    {4952693, 726, "Font1_6m.gif"},
    {4953474, 726, "Font1_7.gif"},
    {4954256, 726, "Font1_7m.gif"},
    {4955037, 726, "Font1_8.gif"},
    {4955819, 726, "Font1_8m.gif"},
    {4956600, 726, "Font1_9.gif"},
    {4957382, 726, "Font1_9m.gif"},
    {4958167, 670, "Interface1.gif"},
    {4958900, 670, "Interface1m.gif"},
    {4959629, 822, "Interface2.gif"},
    {4960514, 822, "Interface2m.gif"},
    {4961395, 1590, "Interface3.gif"},
    {4963048, 1590, "Interface3m.gif"},
    {0, 0, NULL}
};


int dumpMem(unsigned char*in, size_t in_size, const char *name)
{
    char filename[1024];
    FILE *out;

    snprintf(filename, 1024, "graphics/ui/%s", name);
    out = fopen(filename, "wb");
    if(!out)
    {
        printf("ОШИБКА - не удалось открыть файл %s для записи", filename);
        return 0;
    }

    fwrite(in, 1, in_size, out);
    fclose(out);
    return 1;
}

int dumpFile(FILE *in, off_t src_pos, size_t fileSize, const char *name)
{
    uint32_t writtenSize = 0, readSize = 0;
    char filename[1024];
    char outBuffer[1024];
    int outBufferSize = 0;
    FILE *out;

    fseek(in, src_pos, SEEK_SET);

    snprintf(filename, 1024, "graphics/ui/%s", name);

    out = fopen(filename, "wb");
    if(!out)
    {
        printf("ОШИБКА - не удалось открыть файл %s для записи", filename);
        return 0;
    }

    writtenSize = 0;
    do
    {
        readSize = (writtenSize + 1024 >= fileSize) ? (fileSize - writtenSize) : 1024;
        outBufferSize = fread(outBuffer, 1, readSize, in);
        fwrite(outBuffer, 1, outBufferSize, out);
        writtenSize += outBufferSize;
    } while(writtenSize < fileSize);

    fclose(out);
    return 1;
}

int main(int argc, char **argv)
{
    struct Exe2UI *it;
    FILE *in;
    const char *smbxName = "smbx.exe";
    char buffer[2048];

    if(argc > 1)
        smbxName = argv[1];

    in = fopen(smbxName, "rb");
    if(!in)
    {
        fprintf(stderr, "Can't open smbx.exe\n");
        return 1;
    }

    for(it = s_exe2ui; it->filename; it++)
    {
        fseek(in, it->offset, SEEK_SET);
        fprintf(stdout, "Dumping graphics/ui/%s ...\n", it->filename);
        fflush(stdout);
        if(strcmp(it->filename, "MenuGFX1m.gif") == 0)
        {
            if(fread(buffer, 1, it->size, in) != it->size)
            {
                --it;
                continue;
            }

            if(memcmp(buffer, g_MenuGFX1m_orig_gif, it->size) == 0)
            {
                dumpMem(g_MenuGFX1m_fixed_gif, sizeof(g_MenuGFX1m_fixed_gif), "MenuGFX1m.gif");
                continue;
            }
            else
            {
                fprintf(stderr, "...MenuGFX1m.gif doesn't matches to original, keeping existing one...\n");
                fflush(stdout);
            }
            fseek(in, it->offset, SEEK_SET);
        }
        dumpFile(in, it->offset, it->size, it->filename);
    }

    fclose(in);

    dumpMem(g_Font2S_gif, sizeof(g_Font2S_gif), "Font2S.gif");
    dumpMem(g_Font2_1_gif, sizeof(g_Font2_1_gif), "Font2_1.gif");
    dumpMem(g_Font2_3m_gif, sizeof(g_Font2_3m_gif), "Font2_3m.gif");

    fprintf(stdout, "Done!\n");
    fflush(stdout);

    return 0;
}


================================================
FILE: utils/convertkit/exe2ui/exe2ui_build.sh
================================================
#!/bin/bash

gcc exe2ui.c -static -static-libgcc -O3 -no-pie -o exe2ui-linux-x86_64
i686-w64-mingw32-gcc exe2ui.c -static -static-libgcc -O3 -no-pie -o exe2ui.exe


================================================
FILE: utils/convertkit/gfx-convert-16m.py
================================================
#!/usr/bin/python3

# this is a simple script

import os
import sys
import math
import shutil
import configparser

import audio_convert_16m

from convert_plr import *

PREVIEW = False
REDO = False
datadir = sys.argv[1]
graphicsdir = os.path.join(datadir, 'graphics')
fallbackdir = os.path.join(datadir, 'graphics', 'fallback')
outdir = sys.argv[2]

if not datadir.endswith('/'): datadir += '/'
if not outdir.endswith('/'): outdir += '/'

def has_dot(p):
    if not p:
        return False

    p, t = os.path.split(p)

    if t.startswith('.'):
        return True

    return has_dot(p)

for dirpath, _, files in os.walk(datadir, topdown=True):
    if dirpath.endswith('fallback'):
        continue

    if has_dot(dirpath[len(datadir):]):
        continue

    if dirpath[len(datadir):] == 'music' or dirpath[len(datadir):] == 'sound':
        continue

    print(dirpath)

    if dirpath.endswith('fonts'):
        print('found fonts dir', dirpath)
        is_fonts_dir = True
        texture_1x = set()

        for fn in files:
            if fn.endswith('.ini'):
                rfn = os.path.join(dirpath, fn)

                font = configparser.ConfigParser(inline_comment_prefixes=';')
                font.read(rfn)

                if 'font-map' in font:
                    if 'texture-scale' in font['font-map'] and font['font-map']['texture-scale'].strip != '1':
                        if 'texture' in font['font-map']:
                            tex_string = font['font-map']['texture'].strip().strip('\"')
                            print(f"{tex_string} is 1x")
                            texture_1x.add(tex_string)

    else:
        is_fonts_dir = False

    outpath = outdir+dirpath[len(datadir):]
    os.makedirs(outpath, exist_ok=True)
    for fn in files:
        if fn.startswith('.'):
            continue

        rfn = os.path.join(dirpath, fn)
        if not os.path.isfile(rfn): continue
        destfn = os.path.join(outpath, fn)
        bmpfn = os.path.join(outpath, fn[:-3]+'bmp')
        dsgfn = os.path.join(outpath, fn[:-3]+'dsg')
        if not REDO and (os.path.isfile(destfn) or os.path.isfile(destfn+'.wav' or os.path.isfile(destfn+'.qoa')) or ((fn.endswith('.gif') or fn.endswith('.png')) and os.path.isfile(dsgfn))): continue
        print(rfn)

        is_1x = is_fonts_dir and fn in texture_1x

        if is_1x:
            downscale = "-sample 100%"
        else:
            downscale = "-sample 50%"

        if not REDO and not is_fonts_dir and (os.path.isfile(destfn) or os.path.isfile(destfn+'.wav') or ((fn.endswith('.gif') or fn.endswith('.png')) and os.path.isfile(dsgfn))): continue

        is_image = fn.endswith('.png') or fn.endswith('.gif')
        if fn.startswith('link') and is_image:
            os.system(do_sheet_link(rfn, bmpfn))
            rfn = bmpfn
        elif fn[:5] in ('mario', 'luigi', 'peach', 'toad-') and is_image:
            os.system(do_sheet_nonlink(rfn, bmpfn))
            rfn = bmpfn

        if fn.endswith('.png'):
            os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')
        elif fn.endswith('m.gif') and os.path.isfile(rfn[:-5]+'.gif'):
            continue
        elif fn.endswith('.gif'):
            maskfn = rfn[:-4]+'m.gif'
            ftype = fn[:fn.rfind('-')]
            altmaskfn_gif_1 = os.path.join(fallbackdir, fn[:-4]+'m.gif')
            altmaskfn_gif = os.path.join(graphicsdir, ftype, fn[:-4]+'m.gif')
            altmaskfn_png = os.path.join(graphicsdir, ftype, fn[:-4]+'.png')
            if os.path.isfile(maskfn):
                os.system(f'convert "{rfn}" "{maskfn}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')
            elif os.path.isfile(altmaskfn_gif_1):
                if os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{rfn}"').read() == os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{altmaskfn_gif_1}"').read():
                    os.system(f'convert "{rfn}" "{altmaskfn_gif_1}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')
                else:
                    os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')
            elif os.path.isfile(altmaskfn_gif):
                if os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{rfn}"').read() == os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{altmaskfn_gif}"').read():
                    os.system(f'convert "{rfn}" "{altmaskfn_gif}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')
                else:
                    os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')
            elif os.path.isfile(altmaskfn_png):
                if os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{rfn}"').read() == os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{altmaskfn_png}"').read():
                    os.system(f'convert "{rfn}" "{altmaskfn_png}" -alpha On -compose CopyOpacity -composite {downscale} "{bmpfn}"')
                else:
                    os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')
            else:
                os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')

            # handle animated GIFs
            if not os.path.isfile(bmpfn) and os.path.isfile(bmpfn[:-4]+'-0.bmp'):
                shutil.move(bmpfn[:-4]+'-0.bmp', bmpfn)

                # get rid of junk frames
                i = 1
                while os.path.isfile(bmpfn[:-4]+f'-{i}.bmp'):
                    os.remove(bmpfn[:-4]+f'-{i}.bmp')
                    i += 1
        elif fn.endswith('.db') or fn.endswith('.xcf') or fn.endswith('.odt') or fn.endswith('.pdf'):
            continue
        elif fn.endswith('.ogg') and '/sound/' in rfn:
            # os.system(f'ffmpeg -i "{rfn}" "{destfn}.wav"')
            # os.system(f'ffmpeg -i "{rfn}" -acodec pcm_u8 -ar 16000 "{destfn}.wav"')
            continue
        elif is_fonts_dir and fn.endswith('.ini'):
            shutil.copy(rfn, destfn)
            os.system(f'sed \'s/\\.png/\\.dsg/\' -i "{destfn}"')
            continue
        elif fn == 'sounds.ini':
            # shutil.copy(rfn, destfn)
            # os.system(f'sed \'s/\\.ogg"/\\.ogg.wav"/\' -i "{destfn}"')
            continue
        elif fn.lower().endswith('.mp3') or fn.lower().endswith('.ogg'):
            wavfn = destfn + ".wav"
            qoafn = destfn + ".qoa"
            os.system(f'ffmpeg -i "{rfn}" -acodec pcm_s16le -ar 24000 -ac 1 "{wavfn}"')
            os.system(f'qoaconv "{wavfn}" "{qoafn}"')
            os.remove(wavfn)
            continue
        else:
            shutil.copy(rfn, destfn)
            continue
        w, h, op = os.popen(f'identify -format "%[fx:w*2],%[fx:h*2],%[opaque]" "{bmpfn}"').read().split(',')

        # downscale further if needed
        flags = 0
        i_w = int(w) / 2; i_h = int(h) / 2
        i_w = max(8, 2 ** math.ceil(math.log2(i_w)))
        i_h = max(8, 2 ** math.ceil(math.log2(i_h)))
        while (i_w * i_h) > 65536:
            print("SCALING DOWN. Consider revising the asset.")
            flags += 1
            i_w /= 2
            i_h /= 2
        i_w = int(w) >> (flags + 1)
        i_h = int(h) >> (flags + 1)

        if i_w != int(w) / 2:
            os.system(f'convert -resize {200 * i_w / int(w)}% "{bmpfn}" "{bmpfn}"')

        if op.lower().strip() == 'true':
            flags |= 1 << 4

        open(dsgfn+'.size','w').write(f'{w:>4}\n{h:>4}\n{flags}\n')
        dsgfns = [dsgfn]
        bmpfns = [bmpfn]
        if int(h) > 2048:
            os.system(f'convert "{bmpfn}" -crop {w}x{2048 * i_h / int(h)} "{bmpfn}%d.bmp"')
            os.remove(bmpfn)
            shutil.move(bmpfn+'0.bmp', bmpfn) #???
            dsgfns.append(dsgfn+'1')
            bmpfns.append(bmpfn+'1.bmp')
            if int(h) > 4096:
                dsgfns.append(dsgfn+'2')
                bmpfns.append(bmpfn+'2.bmp')
        for dsgfn_i, bmpfn_i in zip(dsgfns, bmpfns):
            h_i = int(h)
            if h_i > 2048:
                h_i = 2048
            h = int(h) - h_i

            cont_w = max(8, 2 ** math.ceil(math.log2(i_w)))
            cont_h = max(8, 2 ** math.ceil(math.log2(h_i * i_w / int(w))))

            basefn_i = bmpfn_i.replace('.bmp', '')
            pngfn_i = basefn_i + '.png'
            os.system(f'convert "{bmpfn_i}" "{pngfn_i}"')
            os.system(f'pngquant 16 "{pngfn_i}"')
            os.system(f'grit "{basefn_i}-fs8.png" -gb -gB 4 -pe16 -ftb -aw {cont_w} -ah {cont_h} -o "{basefn_i}-fs8.png"')
            pal = open(f'{basefn_i}-fs8.pal.bin', 'rb').read()
            img = open(f'{basefn_i}-fs8.img.bin', 'rb').read()
            if len(pal) < 32:
                pal = pal + bytes([0]) * (32 - len(pal))
            open(dsgfn_i, 'wb').write(pal + img)

            os.remove(bmpfn_i)
            os.remove(pngfn_i)
            os.remove(basefn_i+'-fs8.pal.bin')
            os.remove(basefn_i+'-fs8.img.bin')
            os.remove(basefn_i+'-fs8.h')

            if not PREVIEW:
                os.remove(basefn_i+'-fs8.png')

# construct graphics load lists
for dirpath, dirs, files in os.walk(outdir, topdown=True):
    print(dirpath)

    if dirpath.endswith('graphics'):
        l = open(os.path.join(dirpath, 'graphics.list'), 'w')

        for d in dirs:
            if d == 'touchscreen' or d == 'ui' or d == 'fallback':
                continue

            for f in os.listdir(os.path.join(dirpath, d)):
                if not f.endswith('.size'):
                    continue

                abs_f = os.path.join(dirpath, d, f)

                basename = f[:f.find('.')]
                if len(basename.split('-')) != 2:
                    continue

                basename = basename.replace('-', ' ').lower()

                if not basename[:basename.find(' ')] in ('background', 'background2', 'block', 'effect', 'level',
                        'link', 'luigi', 'mario', 'npc', 'path',
                        'peach', 'player', 'scene', 'tile', 'toad',
                        'yoshib', 'yoshit'):
                    continue

                fullname = os.path.join(d, f[:-5])
                l.write(basename+'\n')
                l.write(fullname+'\n')
                l.write(open(abs_f, 'r').read())
                l.write('\n')

        l.close()
        continue
    elif 'graphics' in os.path.split(dirpath):
        continue

    opened = False

    for f in files:
        if not f.endswith('.size'):
            continue

        if not opened:
            l = open(os.path.join(dirpath, 'graphics.list'), 'w')
            opened = True

        abs_f = os.path.join(dirpath, f)

        basename = f[:f.find('.')]
        if len(basename.split('-')) != 2:
            continue

        basename = basename.replace('-', ' ').lower()

        if not basename[:basename.find(' ')] in ('background', 'background2', 'block', 'effect', 'level',
                'link', 'luigi', 'mario', 'npc', 'path',
                'peach', 'player', 'scene', 'tile', 'toad',
                'yoshib', 'yoshit'):
            continue

        fullname = f[:-5]

        l.write(basename+'\n')
        l.write(fullname+'\n')
        l.write(open(abs_f, 'r').read())
        l.write('\n')


    if opened:
        l.close()

# construct soundbank
if REDO or not os.path.isfile(os.path.join(outdir, 'soundbank.bin')):
    audio_convert_16m.convert_audio(datadir, outdir)

if os.path.isdir(os.path.join(outdir, 'music')):
    shutil.rmtree(os.path.join(outdir, 'music'))

if os.path.isdir(os.path.join(outdir, 'sound')):
    shutil.rmtree(os.path.join(outdir, 'sound'))


================================================
FILE: utils/convertkit/gfx-convert-3ds.py
================================================
#!/usr/bin/python3

# this is a simple script

import os
import sys
import shutil
import configparser

PREVIEW = False
REDO = False
datadir = sys.argv[1]
graphicsdir = os.path.join(datadir, 'graphics')
outdir = sys.argv[2]

if not datadir.endswith('/'): datadir += '/'
if not outdir.endswith('/'): outdir += '/'

os.makedirs(os.path.join(outdir, 'graphics', 'fallback'), exist_ok=True)

def has_dot(p):
    if not p:
        return False

    p, t = os.path.split(p)

    if t.startswith('.'):
        return True

    return has_dot(p)

for dirpath, _, files in os.walk(datadir, topdown=True):
    if has_dot(dirpath[len(datadir):]):
        continue

    outpath = os.path.join(outdir, dirpath[len(datadir):])
    os.makedirs(outpath, exist_ok=True)

    if dirpath.endswith('fonts'):
        print('found fonts dir', dirpath)
        is_fonts_dir = True
        texture_1x = set()

        for fn in files:
            if fn.endswith('.ini'):
                rfn = os.path.join(dirpath, fn)

                font = configparser.ConfigParser(inline_comment_prefixes=';')
                font.read(rfn)

                if 'font-map' in font:
                    if 'texture-scale' in font['font-map'] and font['font-map']['texture-scale'].strip() != '1':
                        if 'texture' in font['font-map']:
                            tex_string = font['font-map']['texture'].strip().strip('\"')
                            print(f"{tex_string} is 1x")
                            texture_1x.add(tex_string)

    else:
        is_fonts_dir = False

    for fn in files:
        rfn = os.path.join(dirpath, fn)
        if not os.path.isfile(rfn): continue
        destfn = os.path.join(outpath, fn)
        bmpfn = os.path.join(outpath, fn[:-3]+'bmp')
        t3xfn = os.path.join(outpath, fn[:-3]+'t3x')

        is_1x = is_fonts_dir and fn in texture_1x

        if is_1x:
            downscale = "-sample 100%"
        else:
            downscale = "-sample 50%"

        if not REDO and not is_fonts_dir and not fn.endswith('m.gif') and (os.path.isfile(destfn) or os.path.isfile(destfn+'.wav') or ((fn.endswith('.gif') or fn.endswith('.png')) and os.path.isfile(t3xfn)) or os.path.isfile(destfn+'.it')):
            continue

        print(rfn)
        if fn.endswith('.png'):
            os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')

            ftype = fn[:fn.rfind('-')]

            if f'/graphics/{ftype}/' in rfn:
                dest_maskfn = destfn[:-4] + 'm.gif'
                dest_maskfn = dest_maskfn.replace(f'/graphics/{ftype}/', '/graphics/fallback/')

                if not os.path.isfile(dest_maskfn):
                    os.system(f'convert "{rfn}" -set colorspace RGB -alpha extract -negate "{dest_maskfn}"')
        elif fn.endswith('m.gif') and os.path.isfile(rfn[:-5]+'.gif'):
            continue
        elif fn.endswith('m.gif'):
            shutil.copy(rfn, destfn)
            continue
        elif fn.endswith('.gif'):
            maskfn = rfn[:-4]+'m.gif'
            ftype = fn[:fn.rfind('-')]
            altmaskfn_gif = os.path.join(graphicsdir, 'fallback', fn[:-4]+'m.gif')
            altmaskfn_gif2 = os.path.join(graphicsdir, ftype, fn[:-4]+'m.gif')
            altmaskfn_png = os.path.join(graphicsdir, ftype, fn[:-4]+'.png')

            # would be nice to confirm merge safety
            if os.path.isfile(maskfn):
                os.system(f'convert "{rfn}" "{maskfn}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')

                if f'/graphics/{ftype}/' in rfn:
                    dest_maskfn = destfn[:-4] + 'm.gif'
                    dest_maskfn = dest_maskfn.replace(f'/graphics/{ftype}/', '/graphics/fallback/')

                    if not os.path.isfile(dest_maskfn):
                        shutil.copy(maskfn, dest_maskfn)
            elif os.path.isfile(altmaskfn_gif):
                os.system(f'convert "{rfn}" "{altmaskfn_gif}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')
            elif os.path.isfile(altmaskfn_gif2):
                os.system(f'convert "{rfn}" "{altmaskfn_gif2}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')
            elif os.path.isfile(altmaskfn_png):
                os.system(f'convert "{rfn}" "{altmaskfn_png}" -alpha On -compose CopyOpacity -composite {downscale} "{bmpfn}"')
            else:
                os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')

            # handle animated GIFs
            if not os.path.isfile(bmpfn) and os.path.isfile(bmpfn[:-4]+'-0.bmp'):
                shutil.move(bmpfn[:-4]+'-0.bmp', bmpfn)

                # get rid of junk frames
                i = 1
                while os.path.isfile(bmpfn[:-4]+f'-{i}.bmp'):
                    os.remove(bmpfn[:-4]+f'-{i}.bmp')
                    i += 1
        elif fn.endswith('.db'):
            continue
        elif fn.endswith('.ogg') and '/sound/' in rfn:
            os.system(f'ffmpeg -i "{rfn}" "{destfn}.wav"')
            continue
        elif fn.endswith('.spc') and os.path.join(datadir, 'music/') in rfn:
            shutil.copy(rfn, destfn)
            os.system(f'spc2it "{destfn}"')
            os.remove(destfn)
            shutil.move(destfn[:-3] + 'it', destfn + '.it')
            continue
        elif fn.endswith('.spc'):
            # hackish for now
            shutil.copy(rfn, destfn)
            os.system(f'spc2it "{destfn}"')
            os.remove(destfn)
            shutil.move(destfn[:-3] + 'it', destfn)
            continue
        elif is_fonts_dir and fn.endswith('.ini'):
            shutil.copy(rfn, destfn)
            os.system(f'sed \'s/\\.png/\\.t3x/\' -i "{destfn}"')
            continue
        elif rfn == os.path.join(datadir, 'sounds.ini'):
            shutil.copy(rfn, destfn)
            os.system(f'sed \'s/\\.ogg"/\\.ogg.wav"/\' -i "{destfn}"')
            continue
        elif rfn == os.path.join(datadir, 'music.ini'):
            shutil.copy(rfn, destfn)
            os.system(f'sed \'s/\\.spc"/\\.spc.it"/\' -i "{destfn}"')
            os.system(f'sed \'s/\\.spc|/\\.spc.it|/\' -i "{destfn}"')
            continue
        # elif fn.endswith('.mp3'):
        #     os.system(f'ffmpeg -i "{rfn}" -aq 1 "{destfn}.ogg"')
        #     shutil.move(destfn+'.ogg', destfn)
        #     continue
        else:
            shutil.copy(rfn, destfn)
            continue
        w, h = os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{bmpfn}"').read().split(',')
        open(t3xfn+'.size','w').write(f'{w:>4}\n{h:>4}\n')
        t3xfns = [t3xfn]
        bmpfns = [bmpfn]
        if int(h) > 2048:
            os.system(f'convert "{bmpfn}" -crop {w}x1024 "{bmpfn}%d.bmp"')
            os.remove(bmpfn)
            shutil.move(bmpfn+'0.bmp', bmpfn) #???
            t3xfns.append(t3xfn+'1')
            bmpfns.append(bmpfn+'1.bmp')
            if int(h) > 4096:
                t3xfns.append(t3xfn+'2')
                bmpfns.append(bmpfn+'2.bmp')
        for t3xfn_i, bmpfn_i in zip(t3xfns, bmpfns):
            if PREVIEW:
                pvwfn_i = t3xfn_i+'.bmp'
                os.system(f'tex3ds "{bmpfn_i}" -f rgba8888 -o "{t3xfn_i}" -p "{pvwfn_i}"')
            else:
                if os.system(f'tex3ds "{bmpfn_i}" -f rgba8888 -o "{t3xfn_i}"'):
                    print(f"It didn't work and {t3xfn_i} is missing. (Size: {w}x{h})")
                os.remove(bmpfn_i)

# construct graphics load lists
for dirpath, dirs, files in os.walk(outdir, topdown=True):
    print(dirpath)

    if dirpath.endswith('graphics'):
        l = open(os.path.join(dirpath, 'graphics.list'), 'w')

        for d in dirs:
            if d == 'touchscreen' or d == 'ui' or d == 'fallback':
                continue

            for f in os.listdir(os.path.join(dirpath, d)):
                if not f.endswith('.size'):
                    continue

                abs_f = os.path.join(dirpath, d, f)

                basename = f[:f.find('.')]
                if len(basename.split('-')) != 2:
                    continue

                basename = basename.replace('-', ' ').lower()

                if not basename[:basename.find(' ')] in ('background', 'background2', 'block', 'effect', 'level',
                        'link', 'luigi', 'mario', 'npc', 'path',
                        'peach', 'player', 'scene', 'tile', 'toad',
                        'yoshib', 'yoshit'):
                    continue

                fullname = os.path.join(d, f[:-5])
                l.write(basename+'\n')
                l.write(fullname+'\n')
                l.write(open(abs_f, 'r').read())
                l.write('\n')

        l.close()
        continue
    elif 'graphics' in os.path.split(dirpath):
        continue

    opened = False

    for f in files:
        if not f.endswith('.size'):
            continue

        if not opened:
            l = open(os.path.join(dirpath, 'graphics.list'), 'w')
            opened = True

        abs_f = os.path.join(dirpath, f)

        basename = f[:f.find('.')]
        if len(basename.split('-')) != 2:
            continue

        basename = basename.replace('-', ' ').lower()

        if not basename[:basename.find(' ')] in ('background', 'background2', 'block', 'effect', 'level',
                'link', 'luigi', 'mario', 'npc', 'path',
                'peach', 'player', 'scene', 'tile', 'toad',
                'yoshib', 'yoshit'):
            continue

        fullname = f[:-5]

        l.write(basename+'\n')
        l.write(fullname+'\n')
        l.write(open(abs_f, 'r').read())
        l.write('\n')


    if opened:
        l.close()


================================================
FILE: utils/convertkit/gfx-convert-wii.py
================================================
#!/usr/bin/python3

# this is a simple script

import os
import sys
import shutil
import configparser

PREVIEW = False
REDO = False
datadir = sys.argv[1]
graphicsdir = os.path.join(datadir, 'graphics')
outdir = sys.argv[2]

if not datadir.endswith('/'): datadir += '/'
if not outdir.endswith('/'): outdir += '/'

os.makedirs(os.path.join(outdir, 'graphics', 'fallback'), exist_ok=True)

def has_dot(p):
    if not p:
        return False

    p, t = os.path.split(p)

    if t.startswith('.'):
        return True

    return has_dot(p)

for dirpath, _, files in os.walk(datadir, topdown=True):
    if has_dot(dirpath[len(datadir):]):
        continue

    outpath = os.path.join(outdir, dirpath[len(datadir):])
    os.makedirs(outpath, exist_ok=True)

    if dirpath.endswith('fonts'):
        print('found fonts dir')
        is_fonts_dir = True
        texture_1x = set()

        for fn in files:
            if fn.endswith('.ini'):
                rfn = os.path.join(dirpath, fn)

                font = configparser.ConfigParser(inline_comment_prefixes=';')
                font.read(rfn)

                if 'font-map' in font:
                    if 'texture-scale' in font['font-map'] and font['font-map']['texture-scale'].strip() != '1':
                        if 'texture' in font['font-map']:
                            tex_string = font['font-map']['texture'].strip().strip('\"')
                            print(f"{tex_string} is 1x")
                            texture_1x.add(tex_string)

    else:
        is_fonts_dir = False

    for fn in files:
        rfn = os.path.join(dirpath, fn)
        if not os.path.isfile(rfn): continue
        destfn = os.path.join(outpath, fn)
        bmpfn = os.path.join(outpath, fn[:-3]+'bmp')
        tplfn = os.path.join(outpath, fn[:-3]+'tpl')

        is_1x = is_fonts_dir and fn in texture_1x

        if is_1x:
            downscale = "-sample 100%"
        else:
            downscale = "-sample 50%"

        if not REDO and not is_fonts_dir and not fn.endswith('m.gif') and (os.path.isfile(destfn) or os.path.isfile(destfn+'.wav') or ((fn.endswith('.gif') or fn.endswith('.png')) and os.path.isfile(tplfn))): continue

        print(rfn)
        if fn.endswith('.png'):
            os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')

            ftype = fn[:fn.rfind('-')]

            if f'/graphics/{ftype}/' in rfn:
                dest_maskfn = destfn[:-4] + 'm.gif'
                dest_maskfn = dest_maskfn.replace(f'/graphics/{ftype}/', '/graphics/fallback/')

                if not os.path.isfile(dest_maskfn):
                    os.system(f'convert "{rfn}" -set colorspace RGB -alpha extract -negate "{dest_maskfn}"')
        elif fn.endswith('m.gif') and os.path.isfile(rfn[:-5]+'.gif'):
            continue
        elif fn.endswith('m.gif'):
            shutil.copy(rfn, destfn)
            continue
        elif fn.endswith('.gif'):
            maskfn = rfn[:-4]+'m.gif'
            ftype = fn[:fn.rfind('-')]
            altmaskfn_gif = os.path.join(graphicsdir, 'fallback', fn[:-4]+'m.gif')
            altmaskfn_gif2 = os.path.join(graphicsdir, ftype, fn[:-4]+'m.gif')
            altmaskfn_png = os.path.join(graphicsdir, ftype, fn[:-4]+'.png')

            # would be nice to confirm merge safety
            if os.path.isfile(maskfn):
                os.system(f'convert "{rfn}" "{maskfn}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')

                if f'/graphics/{ftype}/' in rfn:
                    dest_maskfn = destfn[:-4] + 'm.gif'
                    dest_maskfn = dest_maskfn.replace(f'/graphics/{ftype}/', '/graphics/fallback/')

                    if not os.path.isfile(dest_maskfn):
                        shutil.copy(maskfn, dest_maskfn)
            elif os.path.isfile(altmaskfn_gif):
                os.system(f'convert "{rfn}" "{altmaskfn_gif}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')
            elif os.path.isfile(altmaskfn_gif2):
                os.system(f'convert "{rfn}" "{altmaskfn_gif2}" -alpha Off -compose CopyOpacity -composite -channel a -negate +channel {downscale} "{bmpfn}"')
            elif os.path.isfile(altmaskfn_png):
                os.system(f'convert "{rfn}" "{altmaskfn_png}" -alpha On -compose CopyOpacity -composite {downscale} "{bmpfn}"')
            else:
                os.system(f'convert {downscale} "{rfn}" "{bmpfn}"')

            # handle animated GIFs
            if not os.path.isfile(bmpfn) and os.path.isfile(bmpfn[:-4]+'-0.bmp'):
                shutil.move(bmpfn[:-4]+'-0.bmp', bmpfn)

                # get rid of junk frames
                i = 1
                while os.path.isfile(bmpfn[:-4]+f'-{i}.bmp'):
                    os.remove(bmpfn[:-4]+f'-{i}.bmp')
                    i += 1
        elif fn.endswith('.db'):
            continue
        elif fn.endswith('.ogg') and '/sound/' in rfn:
            os.system(f'ffmpeg -i "{rfn}" "{destfn}.wav"')
            continue
        elif is_fonts_dir and fn.endswith('.ini'):
            shutil.copy(rfn, destfn)
            os.system(f'sed \'s/\\.png/\\.tpl/\' -i "{destfn}"')
            continue
        elif fn == 'sounds.ini':
            shutil.copy(rfn, destfn)
            os.system(f'sed \'s/\\.ogg"/\\.ogg.wav"/\' -i "{destfn}"')
            continue
        else:
            shutil.copy(rfn, destfn)
            continue
        w, h = os.popen(f'identify -format "%[fx:w*2],%[fx:h*2]" "{bmpfn}"').read().split(',')
        open(tplfn+'.size','w').write(f'{w:>4}\n{h:>4}\n')
        if int(w) & 6 or int(h) & 6:
            w_ = int(w) // 2
            h_ = int(h) // 2
            print("is", w_, h_)
            if w_ & 3: w_ += 4 - w_ & 3
            if h_ & 3: h_ += 4 - h_ & 3
            print("> extending to", w_, h_)
            os.system(f'convert "{bmpfn}" -gravity NorthWest -background none -extent {w_}x{h_} "{bmpfn}e.bmp"')
            os.system(f'mv "{bmpfn}e.bmp" "{bmpfn}"')
        tplfns = [tplfn]
        bmpfns = [bmpfn]
        if int(h) > 2048:
            os.system(f'convert "{bmpfn}" -crop {w}x1024 "{bmpfn}%d.bmp"')
            os.remove(bmpfn)
            shutil.move(bmpfn+'0.bmp', bmpfn) #???
            tplfns.append(tplfn+'1')
            bmpfns.append(bmpfn+'1.bmp')
            if int(h) > 4096:
                tplfns.append(tplfn+'2')
                bmpfns.append(bmpfn+'2.bmp')
        for tplfn_i, bmpfn_i in zip(tplfns, bmpfns):
            colors = int(os.popen(f'identify -format %k "{bmpfn_i}"').read())

            colfmt = 6

            # PREVIEW = True

            if PREVIEW:
                os.system(f'gxtexconv -i "{bmpfn_i}" -o "{tplfn_i}" colfmt={colfmt} mipmap=no')
                os.remove(tplfn.replace('.tpl', '.h'))
            else:
                if os.system(f'gxtexconv -i "{bmpfn_i}" -o "{tplfn_i}" colfmt={colfmt} mipmap=no'):
                    print(f"It didn't work and {tplfn_i} is missing. (Size: {w}x{h})")
                else:
                    os.remove(tplfn.replace('.tpl', '.h'))
                os.remove(bmpfn_i)

# construct graphics load lists
for dirpath, dirs, files in os.walk(outdir, topdown=True):
    print(dirpath)

    if dirpath.endswith('graphics'):
        l = open(os.path.join(dirpath, 'graphics.list'), 'w')

        for d in dirs:
            if d == 'touchscreen' or d == 'ui' or d == 'fallback':
                continue

            for f in os.listdir(os.path.join(dirpath, d)):
                if not f.endswith('.size'):
                    continue

                abs_f = os.path.join(dirpath, d, f)

                basename = f[:f.find('.')]
                if len(basename.split('-')) != 2:
                    continue

                basename = basename.replace('-', ' ').lower()

                if not basename[:basename.find(' ')] in ('background', 'background2', 'block', 'effect', 'level',
                        'link', 'luigi', 'mario', 'npc', 'path',
                        'peach', 'player', 'scene', 'tile', 'toad',
                        'yoshib', 'yoshit'):
                    continue

                fullname = os.path.join(d, f[:-5])
                l.write(basename+'\n')
                l.write(fullname+'\n')
                l.write(open(abs_f, 'r').read())
                l.write('\n')

                os.remove(abs_f)

        l.close()
        continue
    elif 'graphics' in os.path.split(dirpath):
        continue

    opened = False

    for f in files:
        if not f.endswith('.size'):
            continue

        abs_f = os.path.join(dirpath, f)

        basename = f[:f.find('.')]
        if len(basename.split('-')) != 2:
            continue

        basename = basename.replace('-', ' ').lower()

        if not basename[:basename.find(' ')] in ('background', 'background2', 'block', 'effect', 'level',
                'link', 'luigi', 'mario', 'npc', 'path',
                'peach', 'player', 'scene', 'tile', 'toad',
                'yoshib', 'yoshit'):
            continue

        if not opened:
            l = open(os.path.join(dirpath, 'graphics.list'), 'w')
            opened = True

        fullname = f[:-5]

        l.write(basename+'\n')
        l.write(fullname+'\n')
        l.write(open(abs_f, 'r').read())
        l.write('\n')

        os.remove(abs_f)


    if opened:
        l.close()


================================================
FILE: utils/submodule-update.sh
================================================
#!/bin/bash

projroot=$(dirname "$1")
projroot_len=$((${#projroot}+1))
cur_dir=$(pwd)
repo_path=${cur_dir:$projroot_len}

echo "-----------------------------------"
#echo "Debug: projroot=$projroot"
#echo "Debug: projroot_len=$projroot_len"
#echo "Debug: cur_dir=$cur_dir"
#echo "Debug: repo_path=$repo_path"

SED_EXEC=sed

if [[ "$OSTYPE" == "darwin"* || "$OSTYPE" == "freebsd"* ]]; then
    SED_EXEC=gsed
fi

dstbranch=""
found=false

while IFS= read -r line; do
    line_clear=$(echo "$line" | $SED_EXEC 's/^[ \t]*//g')

    if $found ; then
        if [[ "$line_clear" == "branch = "* ]]; then
            dstbranch=$(echo "$line_clear" | $SED_EXEC 's/^branch = *//g')
            echo "Found branch name: $dstbranch"
            break
        fi
    elif [[ "$line_clear" == "path = $repo_path" ]]; then
        found=true
    fi
done < "$1"

if [[ "$dstbranch" == "" ]]; then
    echo "Failed to detect brach at the repo $reponame ($repo_path)"
    exit 1
fi

reponame=$(basename `git rev-parse --show-toplevel`)
echo "Updating repo $reponame (path=$repo_path), branch $dstbranch"

git checkout $dstbranch
git pull origin $dstbranch

if [[ -f .gitmodules ]]; then
    echo "========================================="
    echo "Running recursive submodule sync..."
    echo "========================================="
    git submodule init
    git submodule update
    echo ""
    git submodule foreach submodule-update.sh "$PWD/.gitmodules"
    echo "========================================="
    echo "Exiting recursive scan of the $reponame's submodules!"
    echo "========================================="
fi


================================================
FILE: utils/update-copyright.sh
================================================
#!/bin/bash

find . -type f -exec grep -Il "Copyright" {} \;     \
| grep -v \.git \
| while read file;                            \
do \
  LC_ALL=C sed -b -i "s/\(.*Copyright.*\)[0-9]\{4\}\( *Vitali\?y Novichkov\)/\1`date +%Y`\2/" "$file"; \
done

if [[ -f "pge_version.h" ]]; then
    LC_ALL=C sed -b -i "s/\(.*V_COPYRIGHT.*\)[0-9]\{4\}\( *by Wohlstand\)/\1`date +%Y`\2/" "pge_version.h";
fi


================================================
FILE: version.cmake
================================================
# Major
set(THEXTECH_VERSION_1 1)
# Minor
set(THEXTECH_VERSION_2 3)
# Revision
set(THEXTECH_VERSION_3 8)
# Patch
set(THEXTECH_VERSION_4 0)
# Type of version: "-alpha","-beta","-dev", or "" aka "release"
set(THEXTECH_VERSION_REL "-dev")

# Static version values for F-Droid to parse (PLEASE KEEP IT IN SYNC WITH VERSION NUMBER PARTS FROM ABOVE)
set(THEXTECH_ANDROID_VERSION_NAME "1.3.8-dev")
set(THEXTECH_ANDROID_VERSION_CODE "1030800")

# Defining global macros
add_definitions(-DTHEXTECH_VERSION_1=${THEXTECH_VERSION_1})
add_definitions(-DTHEXTECH_VERSION_2=${THEXTECH_VERSION_2})
add_definitions(-DTHEXTECH_VERSION_3=${THEXTECH_VERSION_3})
add_definitions(-DTHEXTECH_VERSION_4=${THEXTECH_VERSION_4})
add_definitions(-DTHEXTECH_VERSION_REL=${THEXTECH_VERSION_REL})

# Buildin the version name
set(THEXTECH_VERSION_STRING "${THEXTECH_VERSION_1}.${THEXTECH_VERSION_2}")

if(NOT ${THEXTECH_VERSION_3} EQUAL 0 OR NOT ${THEXTECH_VERSION_4} EQUAL 0)
    string(CONCAT THEXTECH_VERSION_STRING "${THEXTECH_VERSION_STRING}" ".${THEXTECH_VERSION_3}")
endif()

if(NOT ${THEXTECH_VERSION_4} EQUAL 0)
    string(CONCAT THEXTECH_VERSION_STRING "${THEXTECH_VERSION_STRING}" ".${THEXTECH_VERSION_4}")
endif()

if(NOT "${THEXTECH_VERSION_REL}" STREQUAL "")
    string(CONCAT THEXTECH_VERSION_STRING "${THEXTECH_VERSION_STRING}" "${THEXTECH_VERSION_REL}")
endif()

# Haiku-specific version name
if(HAIKU)
    set(THEXTECH_HAIKU_VERSION_STRING "${THEXTECH_VERSION_1}.${THEXTECH_VERSION_2}")

    if(NOT ${THEXTECH_VERSION_3} EQUAL 0 OR NOT ${THEXTECH_VERSION_4} EQUAL 0)
        string(CONCAT THEXTECH_HAIKU_VERSION_STRING "${THEXTECH_HAIKU_VERSION_STRING}" ".${THEXTECH_VERSION_3}")
    endif()

    if(NOT ${THEXTECH_VERSION_4} EQUAL 0)
        string(CONCAT THEXTECH_HAIKU_VERSION_STRING "${THEXTECH_HAIKU_VERSION_STRING}" ".${THEXTECH_VERSION_4}")
    endif()

    if(NOT "${THEXTECH_VERSION_REL}" STREQUAL "")
        string(SUBSTRING "${THEXTECH_VERSION_REL}" 1 10 THEXTECH_HAIKU_VERSION_REL)
        string(CONCAT THEXTECH_HAIKU_VERSION_STRING "${THEXTECH_HAIKU_VERSION_STRING}" "~${THEXTECH_HAIKU_VERSION_REL}")
    endif()

    string(CONCAT THEXTECH_HAIKU_VERSION_STRING "${THEXTECH_HAIKU_VERSION_STRING}" "-1")
endif()

# Building the version code (for Android)
math(EXPR THEXTECH_VERSION_CODE "1000000 * ${THEXTECH_VERSION_1} + 10000 * ${THEXTECH_VERSION_2} + 100 * ${THEXTECH_VERSION_3} + ${THEXTECH_VERSION_4}")

message("== TheXTech version ${THEXTECH_VERSION_STRING} (${THEXTECH_VERSION_CODE}) ==")

# A reminder that will compare dynamically computed values with a static value, and will fail a configure if mismatch:
# ==================================================

if(NOT "${THEXTECH_ANDROID_VERSION_NAME}" STREQUAL "${THEXTECH_VERSION_STRING}")
    message(FATAL_ERROR "Android version name value doesn't matching to the primary version name\n(expected ${THEXTECH_VERSION_STRING}, ${THEXTECH_ANDROID_VERSION_NAME} actually)")
endif()

if(NOT "${THEXTECH_ANDROID_VERSION_CODE}" STREQUAL "${THEXTECH_VERSION_CODE}")
    message(FATAL_ERROR "Android version code doesn't matching to the primary version code\n(expected ${THEXTECH_VERSION_CODE}, ${THEXTECH_ANDROID_VERSION_CODE} actually)")
endif()
# ==================================================


================================================
FILE: version.h
================================================
/*
 * TheXTech - A platform game engine ported from old source code for VB6
 *
 * Copyright (c) 2009-2011 Andrew Spinks, original VB6 code
 * Copyright (c) 2020-2026 Vitaly Novichkov <admin@wohlnet.ru>
 *
 * 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 3 of the License, or
 * 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, see <http://www.gnu.org/licenses/>.
 */


#include "pge_version.h" //Global Project version file
#include "git_version.h" // generated git version info

#ifndef THEXTECH_VERSION_H
#define THEXTECH_VERSION_H

#ifdef GIT_VERSION
#define V_BUILD_VER GIT_VERSION
#else
#define V_BUILD_VER "<empty>"
#endif

#ifdef GIT_BRANCH
#define V_BUILD_BRANCH GIT_BRANCH
#else
#define V_BUILD_BRANCH "<unknown>"
#endif

#ifdef THEXTECH_VERSION_1
#   define V_VF1 THEXTECH_VERSION_1
#else
#   define V_VF1 0
#endif

#ifdef THEXTECH_VERSION_2
#   define V_VF2 THEXTECH_VERSION_2
#else
#   define V_VF2 0
#endif

#ifdef THEXTECH_VERSION_3
#   define V_VF3 THEXTECH_VERSION_3
#else
#   define V_VF3 0
#endif

#ifdef THEXTECH_VERSION_4
#   define V_VF4 THEXTECH_VERSION_4
#else
#   define V_VF4 0
#endif

#define V_FEATURE_LEVEL (((V_VF1 * 100 + V_VF2) * 100 + V_VF3) * 100 + V_VF4)

#ifdef THEXTECH_VERSION_REL
#   define V_FILE_RELEASE STR_VALUE(THEXTECH_VERSION_REL)
#else
#   define V_FILE_RELEASE "-unk" //"-alpha","-beta","-dev", or "" aka "release"
#endif

#define V_VF1_s STR_VALUE(V_VF1)
#define V_VF2_s STR_VALUE(V_VF2)
#define V_VF3_s STR_VALUE(V_VF3)
#define V_VF4_s STR_VALUE(V_VF4)
#if V_VF4 == 0
    #if V_VF3 == 0
        #define V_FILE_VERSION_NUM GEN_VERSION_NUMBER_2(V_VF1_s, V_VF2_s)
    #else
        #define V_FILE_VERSION_NUM GEN_VERSION_NUMBER_3(V_VF1_s, V_VF2_s, V_VF3_s)
    #endif
#else
    #define V_FILE_VERSION_NUM GEN_VERSION_NUMBER_4(V_VF1_s, V_VF2_s, V_VF3_s, V_VF4_s)
#endif

#define V_FILE_VERSION V_FILE_VERSION_NUM
//Version of this program
#define V_LATEST_STABLE V_FILE_VERSION_NUM V_FILE_RELEASE

#define V_FILE_DESC "TheXTech - the modern C++ port and successor of the SMBX engine"

#define V_INTERNAL_NAME "thextech"

#ifdef _WIN32
    #define V_ORIGINAL_NAME "thextech.exe" // for Windows platforms
#else
    #define V_ORIGINAL_NAME "thextech" // for any other platforms
#endif

//Uncomment this for enable detal logging
//#define DEBUG

#endif